DecayTree.h

Go to the documentation of this file.

/*  YAP - Yet another PWA toolkit
    Copyright 2015, Technische Universitaet Muenchen,
    Authors: Daniel Greenwald, Johannes Rauch

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */


#ifndef yap_DecayTree_h
#define yap_DecayTree_h

#include "fwd/DecayTree.h"

#include "fwd/AmplitudeComponent.h"
#include "fwd/DataPoint.h"
#include "fwd/DecayChannel.h"
#include "fwd/FreeAmplitude.h"
#include "fwd/Model.h"
#include "fwd/ParticleCombination.h"
#include "fwd/Spin.h"
#include "fwd/SpinAmplitude.h"
#include "fwd/StatusManager.h"
#include "fwd/VariableStatus.h"

#include <array>
#include <complex>
#include <map>
#include <memory>
#include <string>
#include <vector>

namespace yap {

class DecayTree
{
public:

    using DaughterDecayTreeMap = std::map<unsigned, std::shared_ptr<DecayTree> >;

    explicit DecayTree(std::shared_ptr<FreeAmplitude> free_amp);

    const std::complex<double> dataIndependentAmplitude() const;

    const std::complex<double> dataDependentAmplitude(const DataPoint& d) const;

    const std::complex<double> dataDependentAmplitude(const DataPoint& d, const std::shared_ptr<ParticleCombination>& pc) const;

    const VariableStatus dataDependentAmplitudeStatus() const;

    const std::shared_ptr<FreeAmplitude>& freeAmplitude() const
    { return FreeAmplitude_; }

    const DaughterDecayTreeMap daughterDecayTrees() const
    { return DaughterDecayTrees_; }

    std::shared_ptr<DecayingParticle> decayingParticle() const;

    const Model* model() const;

    friend class DecayChannel;

    friend class DecayingParticle;

    friend class Resonance;

protected:

    void setDaughterDecayTree(unsigned i, std::shared_ptr<DecayTree> dt);

    void setDaughterSpinProjection(unsigned i, int two_m)
    { DaughtersTwoM_.at(i) = two_m; }

    void addAmplitudeComponent(const AmplitudeComponent& rda);

private:

    std::shared_ptr<FreeAmplitude> FreeAmplitude_;

    SpinProjectionVector DaughtersTwoM_;

    std::vector<const AmplitudeComponent*> AmplitudeComponents_;

    DaughterDecayTreeMap DaughterDecayTrees_;

};

std::string to_string(const DecayTree& dt, std::string offset = "");

std::string to_string(const DecayTreeVector& dtv);

inline bool operator==(const DecayTree& lhs, const DecayTree& rhs)
{ return lhs.freeAmplitude() == rhs.freeAmplitude() and lhs.daughterDecayTrees() == rhs.daughterDecayTrees(); }

unsigned depth(const DecayTree& DT);

inline const std::complex<double> amplitude(const DecayTree& dt, const DataPoint& d)
{ return dt.dataIndependentAmplitude() * dt.dataDependentAmplitude(d); }

inline const std::complex<double> amplitude(const DecayTree& dt, const DataPoint& d, const std::shared_ptr<ParticleCombination>& pc)
{ return dt.dataIndependentAmplitude() * dt.dataDependentAmplitude(d, pc); }

const std::complex<double> amplitude(const DecayTreeVector& dtv, const DataPoint& d);

inline const double intensity(const DecayTreeVector& dtv, const DataPoint& d)
{ return norm(amplitude(dtv, d)); }

FreeAmplitudeSet free_amplitudes(const DecayTree& DT);

FreeAmplitudeSet free_amplitudes(const DecayTreeVector& DTV);

const bool has_changed(const std::shared_ptr<DecayTree>& dt);

const DecayTreeVector select_changed(const DecayTreeVector& dtv);

}

#endif