LauIsobarDynamics.hh

Go to the documentation of this file.

// Copyright University of Warwick 2005 - 2013.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

// Authors:
// Thomas Latham
// John Back
// Paul Harrison

#ifndef LAU_ISOBAR_DYNAMICS
#define LAU_ISOBAR_DYNAMICS

#include <vector>

#include "TString.h"

#include "LauAbsDPDynamics.hh"
#include "LauAbsResonance.hh"
#include "LauComplex.hh"

class LauDaughters;
class LauAbsEffModel;
class LauFitDataTree;
class LauKMatrixPropagator;

class LauIsobarDynamics : public LauAbsDPDynamics {

        public:

                LauIsobarDynamics(LauDaughters* daughters, LauAbsEffModel* effModel, LauAbsEffModel* scfFractionModel = 0);


                LauIsobarDynamics(LauDaughters* daughters, LauAbsEffModel* effModel, LauTagCatScfFractionModelMap scfFractionModel);

                virtual ~LauIsobarDynamics();


                virtual void initialise(const std::vector<LauComplex>& coeffs);


                inline void setIntFileName(const TString& fileName) {intFileName_ = fileName;}

                // Integration

                virtual void setIntegralBinWidths(Double_t m13BinWidth, Double_t m23BinWidth);


                virtual LauAbsResonance* addResonance(const TString& resName, const Int_t resPairAmpInt, const LauAbsResonance::LauResonanceModel resType);


                virtual void defineKMatrixPropagator(const TString& propName, const TString& paramFileName,
                                                     Int_t resPairAmpInt, Int_t nChannels, Int_t nPoles, Int_t rowIndex = 1);


                virtual void addKMatrixProdPole(const TString& poleName, const TString& propName, Int_t poleIndex);


                virtual void addKMatrixProdSVP(const TString& SVPName, const TString& propName, Int_t channelIndex);


                virtual void changeResonance(const TString& resName, Double_t newMass = -1.0, Double_t newWidth = -1.0, Int_t newSpin = -1);


                virtual Bool_t generate();


                virtual ToyMCStatus checkToyMC(Bool_t printErrorMessages = kTRUE, Bool_t printInfoMessages = kFALSE);


                inline Int_t maxGenIterations() const {return iterationsMax_;}


                virtual void calcLikelihoodInfo(UInt_t iEvt);


                virtual void calcLikelihoodInfo(Double_t m13Sq, Double_t m23Sq);


                virtual void calcLikelihoodInfo(Double_t m13Sq, Double_t m23Sq, Int_t tagCat);


                virtual const LauComplex& getEvtDPAmp() const {return totAmp_;}


                virtual Double_t getEvtm13Sq() const {return m13Sq_;}


                virtual Double_t getEvtm23Sq() const {return m23Sq_;}


                virtual Double_t getEvtmPrime() const {return mPrime_;}


                virtual Double_t getEvtthPrime() const {return thPrime_;}


                virtual Double_t getEvtEff() const {return eff_;}


                virtual Double_t getEvtScfFraction() const {return scfFraction_;}


                virtual Double_t getEvtJacobian() const {return jacobian_;}


                virtual Double_t getEvtLikelihood() const {return evtLike_;}


                virtual void calcExtraInfo(Bool_t init = kFALSE);


                virtual Bool_t gotReweightedEvent();


                virtual Double_t getEventWeight();


                inline void setASqMaxValue(Double_t value) {aSqMaxSet_ = value;}


                inline Double_t getASqMaxSetValue() const { return aSqMaxSet_; }


                inline Double_t getASqMaxVarValue() const { return aSqMaxVar_; }


                virtual LauComplex getDynamicAmp(Int_t resID) const {return ff_[resID].scale(fNorm_[resID]);}


                inline const std::vector< std::vector<LauComplex> >& getFiFjSum() const {return fifjSum_;}


                inline const std::vector< std::vector<LauComplex> >& getFiFjEffSum() const {return fifjEffSum_;}


                inline const std::vector<Double_t>& getFNorm() const {return fNorm_;}


                virtual void fillDataTree(const LauFitDataTree& fitDataTree);


                virtual void setDataEventNo(UInt_t iEvt);


                inline void setBarrierRadii( Double_t resRadius, Double_t parRadius = 4.0,
                                LauAbsResonance::BarrierType type = LauAbsResonance::BWPrimeBarrier )
                {
                        setBarrierRadius_ = kTRUE;
                        resBarrierRadius_ = resRadius;
                        parBarrierRadius_ = parRadius;
                        barrierType_ = type;
                }


                inline void setResBarrierRadius(Double_t radius) {setBarrierRadius_ = kTRUE; resBarrierRadius_ = radius;}


                inline void setParBarrierRadius(Double_t radius) {setBarrierRadius_ = kTRUE; parBarrierRadius_ = radius;}


                inline void setBarrierType( LauAbsResonance::BarrierType type ) {setBarrierRadius_ = kTRUE; barrierType_ = type;}


                inline Double_t getResBarrierRadius() const {return resBarrierRadius_;}


                inline Double_t getParBarrierRadius() const {return parBarrierRadius_;}


                inline void flipHelicityForCPEigenstates(Bool_t boolean) {flipHelicity_ = boolean;}

        protected:
                virtual void initSummary();

                virtual void initialiseVectors();

                virtual void calcDPNormalisation();


                virtual void calcDPPartialIntegral(Double_t minm13, Double_t maxm13, Double_t minm23,
                                Double_t maxm23, Double_t m13BinWidth, Double_t m23BinWidth);

                virtual void writeIntegralsFile();


                virtual void setFFTerm(UInt_t index, Double_t realPart, Double_t imagPart);


                virtual void dynamics(Bool_t cacheResData = kTRUE, Double_t weight = 1.0, Bool_t useEff = kTRUE);


                inline void setASqMaxVarValue(Double_t value) {aSqMaxVar_ = value;}


                virtual Double_t calcSigDPNorm();


                virtual LauComplex resAmp(Int_t index);


                virtual LauAbsResonance* findResonance(const TString& name);


                virtual const LauAbsResonance* findResonance(const TString& name) const;


                virtual void removeCharge(TString& string) const;


                Bool_t gotKMatrixMatch(UInt_t resAmpInt, const TString& propName) const;

        private:
                typedef std::map<TString, LauKMatrixPropagator*> KMPropMap;

                typedef std::map<TString, TString> KMStringMap;

                std::vector<LauAbsResonance*> sigResonances_;

                KMPropMap kMatrixPropagators_;

                KMStringMap kMatrixPropSet_;

                std::vector<TString> resTypAmp_;

                std::vector<Int_t> resIntAmp_;

                std::vector<Int_t> resPairAmp_;

                std::vector<Int_t> typDaug_;

                Bool_t symmetricalDP_;

                Bool_t integralsDone_;

                TString intFileName_;

                Double_t m13BinWidth_;

                Double_t m23BinWidth_;

                Double_t m13Sq_;

                Double_t m23Sq_;

                Double_t mPrime_;

                Double_t thPrime_;

                Double_t eff_;

                Double_t scfFraction_;

                Double_t jacobian_;

                Double_t ASq_;

                Double_t evtLike_;

                LauComplex totAmp_;


                std::vector< std::vector<LauComplex> > fifjEffSum_;


                std::vector< std::vector<LauComplex> > fifjSum_;

                std::vector<LauComplex> ff_;

                std::vector<Double_t> fSqSum_;

                std::vector<Double_t> fNorm_;

                Int_t iterationsMax_;

                Int_t nSigGenLoop_;

                Double_t aSqMaxSet_;

                Double_t aSqMaxVar_;

                Bool_t setBarrierRadius_;

                Double_t resBarrierRadius_;

                Double_t parBarrierRadius_;

                LauAbsResonance::BarrierType barrierType_;

                Bool_t flipHelicity_;

                ClassDef(LauIsobarDynamics,0)
};

#endif