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 LauEffModel;
class LauFitDataTree;
class LauKMatrixPropagator;

class LauIsobarDynamics : public LauAbsDPDynamics {

        public:

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


                LauIsobarDynamics(LauDaughters* daughters, LauEffModel* 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 void addResonance(const TString& resName, Int_t resPairAmpInt, const TString& resType,
                                  Double_t newMass = -1.0, Double_t newWidth = -1.0, Int_t newSpin = -1);


                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 setBelleNRAlpha(Double_t alpha) {BelleNRAlpha_ = alpha;}


                inline Double_t getBelleNRAlpha() const {return BelleNRAlpha_;}


                inline void setLASSParameters(Double_t a, Double_t r, Double_t R = 1.0, Double_t phiR = 0.0, Double_t B = 1.0, Double_t phiB = 0.0, Double_t cutOff = 1.8)
                {
                        this->setLASSScatteringLength(a);
                        this->setLASSEffectiveRange(r);
                        this->setLASSResonanceMag(R);
                        this->setLASSResonancePhase(phiR);
                        this->setLASSBackgroundMag(B);
                        this->setLASSBackgroundPhase(phiB);
                        this->setLASSCutOff(cutOff);
                }


                inline void setLASSScatteringLength(Double_t a)   {LASSScatteringLength_ = a;   changeLASSScatteringLength_ = kTRUE;}


                inline void setLASSEffectiveRange(Double_t r)     {LASSEffectiveRange_ = r;     changeLASSEffectiveRange_ = kTRUE;}


                inline void setLASSResonanceMag(Double_t R)       {LASSResonanceMag_ = R;       changeLASSResonanceMag_ = kTRUE;}


                inline void setLASSResonancePhase(Double_t phiR)  {LASSResonancePhase_ = phiR;  changeLASSResonancePhase_ = kTRUE;}


                inline void setLASSBackgroundMag(Double_t B)      {LASSBackgroundMag_ = B;      changeLASSBackgroundMag_ = kTRUE;}


                inline void setLASSBackgroundPhase(Double_t phiB) {LASSBackgroundPhase_ = phiB; changeLASSBackgroundPhase_ = kTRUE;}


                inline void setLASSCutOff(Double_t cutOff) {LASSCutOff_ = cutOff; changeLASSCutOff_ = kTRUE;}


                inline Double_t getLASSScatteringLength() const {return LASSScatteringLength_;}


                inline Double_t getLASSEffectiveRange() const {return LASSEffectiveRange_;}


                inline Double_t getLASSResonanceMag() const {return LASSResonanceMag_;}


                inline Double_t getLASSResonancePhase() const {return LASSResonancePhase_;}


                inline Double_t getLASSBackgroundMag() const {return LASSBackgroundMag_;}


                inline Double_t getLASSBackgroundPhase() const {return LASSBackgroundPhase_;}


                inline Double_t getLASSCutOff()  const {return LASSCutOff_;}


                inline void setFlatteParameters(Double_t g1, Double_t g2) {this->setFlatteg1(g1); this->setFlatteg2(g2);}


                inline void setFlatteg1(Double_t g1) {FlatteParameterg1_ = g1; changeFlatteParameterg1_ = kTRUE;}


                inline void setFlatteg2(Double_t g2) {FlatteParameterg2_ = g2; changeFlatteParameterg2_ = kTRUE;}


                inline Double_t getFlatteg1() const {return FlatteParameterg1_;}


                inline Double_t getFlatteg2() const {return FlatteParameterg2_;}


                inline void setBarrierRadii( Double_t resRadius, Double_t parRadius = 4.0,
                                LauAbsResonance::BarrierType type = LauAbsResonance::BWPrimeBarrier )
                {
                        this->setResBarrierRadius(resRadius);
                        this->setParBarrierRadius(parRadius);
                        this->setBarrierType(type);
                }


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


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


                inline void setBarrierType( LauAbsResonance::BarrierType type ) {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_;

                Double_t BelleNRAlpha_;

                Double_t LASSScatteringLength_;

                Double_t LASSEffectiveRange_;

                Double_t LASSResonanceMag_;

                Double_t LASSResonancePhase_;

                Double_t LASSBackgroundMag_;

                Double_t LASSBackgroundPhase_;

                Double_t LASSCutOff_;

                Bool_t changeLASSScatteringLength_;

                Bool_t changeLASSEffectiveRange_;

                Bool_t changeLASSResonanceMag_;

                Bool_t changeLASSResonancePhase_;

                Bool_t changeLASSBackgroundMag_;

                Bool_t changeLASSBackgroundPhase_;

                Bool_t changeLASSCutOff_;

                Double_t FlatteParameterg1_;

                Double_t FlatteParameterg2_;

                Bool_t changeFlatteParameterg1_;

                Bool_t changeFlatteParameterg2_;

                Double_t resBarrierRadius_;

                Double_t parBarrierRadius_;

                LauAbsResonance::BarrierType barrierType_;

                Bool_t flipHelicity_;

                ClassDef(LauIsobarDynamics,0)

};

#endif