Model.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_Model_h
#define yap_Model_h

#include "fwd/DataAccessor.h"
#include "fwd/DataPartition.h"
#include "fwd/DataPoint.h"
#include "fwd/DataSet.h"
#include "fwd/DecayingParticle.h"
#include "fwd/Filters.h"
#include "fwd/FinalStateParticle.h"
#include "fwd/FourMomenta.h"
#include "fwd/FourVector.h"
#include "fwd/FreeAmplitude.h"
#include "fwd/HelicityAngles.h"
#include "fwd/MassAxes.h"
#include "fwd/MeasuredBreakupMomenta.h"
#include "fwd/Parameter.h"
#include "fwd/Particle.h"
#include "fwd/RecalculableDataAccessor.h"
#include "fwd/StaticDataAccessor.h"
#include "fwd/StatusManager.h"

#include "CoordinateSystem.h"
#include "ParticleCombinationCache.h"
#include "SpinAmplitudeCache.h"

#include <complex>
#include <memory>
#include <vector>

namespace yap {

class Model
{
public:

    Model(std::unique_ptr<SpinAmplitudeCache> SAC, bool include_phsp_factors = true);

    Model(const Model&) = delete;

    Model& operator=(const Model&) = delete;

    Model(Model&&) = delete;

    Model& operator=(Model&&) = delete;

    void calculate(DataPartition& D) const;

    virtual bool consistent() const;

    bool locked() const
    { return Locked_; }

    void lock();


    const bool includePhaseSpaceFactors() const
    { return IncludePhaseSpaceFactors_; }

    const CoordinateSystem<double, 3>& coordinateSystem() const
    { return CoordinateSystem_; }

    std::shared_ptr<FourMomenta> fourMomenta()
    { return FourMomenta_; }

    const std::shared_ptr<FourMomenta> fourMomenta() const
    { return FourMomenta_; }

    std::shared_ptr<MeasuredBreakupMomenta> measuredBreakupMomenta()
    { return MeasuredBreakupMomenta_; }

    const std::shared_ptr<MeasuredBreakupMomenta> measuredBreakupMomenta() const
    { return MeasuredBreakupMomenta_; }

    std::shared_ptr<HelicityAngles> helicityAngles()
    { return HelicityAngles_; }

    const std::shared_ptr<HelicityAngles> helicityAngles() const
    { return HelicityAngles_; }

    ParticleCombinationCache& particleCombinationCache()
    { return ParticleCombinationCache_; }

    const ParticleCombinationCache& particleCombinationCache() const
    { return ParticleCombinationCache_; }

    SpinAmplitudeCache* spinAmplitudeCache()
    { return SpinAmplitudeCache_.get(); }

    const SpinAmplitudeCache* spinAmplitudeCache() const
    { return SpinAmplitudeCache_.get(); }

    const FinalStateParticleVector& finalStateParticles() const
    { return FinalStateParticles_; }

    const InitialStateParticleMap& initialStateParticles() const
    { return InitialStateParticles_; }

    const DataAccessorSet& dataAccessors() const
    { return DataAccessors_; }



    void setFinalState(const FinalStateParticleVector& FSP);

    template <typename ... Types>
    void setFinalState(Types ... FSPs)
    { FinalStateParticleVector V{FSPs...}; setFinalState(V); }

    const InitialStateParticleMap::value_type& addInitialStateParticle(std::shared_ptr<DecayingParticle> bg);

    void setFinalStateMomenta(DataPoint& d, const std::vector<FourVector<double> >& P, StatusManager& sm) const;

    void setCoordinateSystem(const CoordinateSystem<double, 3>& cs);

    void setIncludePhaseSpaceFactors(bool b)
    { IncludePhaseSpaceFactors_ = b; }



    const MassAxes massAxes(std::vector<std::vector<unsigned> > pcs = {});


    void requireHelicityAngles();

    void requireMeasuredBreakupMomenta();

    DataSet createDataSet(size_t n = 0);

    void setParameterFlagsToUnchanged();

    void printDataAccessors(bool printParticleCombinations = true) const;

    void printFlags(const StatusManager& sm) const;

    friend class DataAccessor;

    friend class RecalculableDataAccessor;

    friend class StaticDataAccessor;

    friend class DecayingParticle;

protected:

    virtual void addParticleCombination(std::shared_ptr<ParticleCombination> pc);

    /* /// remove a DataAccessor from this Model */
    /* virtual void removeDataAccessor(DataAccessorSet::value_type da); */

private:

    bool Locked_;

    CoordinateSystem<double, 3> CoordinateSystem_;

    bool IncludePhaseSpaceFactors_;

    ParticleCombinationCache ParticleCombinationCache_;

    std::unique_ptr<SpinAmplitudeCache> SpinAmplitudeCache_;

    DataAccessorSet DataAccessors_;

    StaticDataAccessorVector StaticDataAccessors_;

    RecalculableDataAccessorSet RecalculableDataAccessors_;

    InitialStateParticleMap InitialStateParticles_;

    FinalStateParticleVector FinalStateParticles_;

    std::shared_ptr<FourMomenta> FourMomenta_;

    std::shared_ptr<MeasuredBreakupMomenta> MeasuredBreakupMomenta_;

    std::shared_ptr<HelicityAngles> HelicityAngles_;

};

std::string to_string(const AdmixtureMap& mix);

const bool decays_to_full_final_state(const Particle& p);

std::vector<std::shared_ptr<DecayingParticle> > full_final_state_isp(const Model& M);

const double intensity(const InitialStateParticleMap::value_type& isp_mix, const DataPoint& d);

const double intensity(const InitialStateParticleMap& isp_map, const DataPoint& d);

const double sum_of_log_intensity(const Model& M, DataPartition& D, double ped = 0);

const double sum_of_log_intensity(const Model& M, DataPartitionVector& DP, double ped = 0);

FreeAmplitudeSet free_amplitudes(const Model& M);

template <typename Last, typename ... UnaryPredicates>
FreeAmplitudeSet free_amplitudes(const Model& M, Last p, UnaryPredicates ... P)
{ return filter(free_amplitudes(M), p, P...); }

template <typename Last, typename ... UnaryPredicates>
FreeAmplitudeSet::value_type free_amplitude(const Model& M, Last p, UnaryPredicates ... P)
{ return lone_elt(filter(free_amplitudes(M), p, P...)); }

ParticleSet particles(const Model& M);

template <typename Last, typename ... UnaryPredicates>
ParticleSet particles(const Model& M, Last p, UnaryPredicates ... P)
{ return filter(particles(M), p, P...); }

template <typename Last, typename ... UnaryPredicates>
ParticleSet::value_type particle(const Model& M, Last p, UnaryPredicates ... P)
{ return lone_elt(filter(particles(M), p, P...)); }

}

#endif