LauKMatrixPropagator.hh

Go to the documentation of this file.

// Copyright University of Warwick 2008 - 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_KMATRIX_PROPAGATOR
#define LAU_KMATRIX_PROPAGATOR

#include "LauComplex.hh"
#include "LauKinematics.hh"
#include "LauParameter.hh"

#include "TMatrixD.h"
#include "TString.h"

#include <map>
#include <vector>

class LauKMatrixPropagator {

        public:

                LauKMatrixPropagator(const TString& name, const TString& paramFileName, 
                                     Int_t resPairAmpInt, Int_t nChannels, Int_t nPoles,
                                     Int_t rowIndex = 1);

                virtual ~LauKMatrixPropagator();


                void updatePropagator(const LauKinematics* kinematics);


                void updatePropagator(Double_t s);


                void setParameters(const TString& inputFile);


                TMatrixD getKMatrix() const {return ScattKMatrix_;}


                Double_t getRealPropTerm(Int_t channelIndex) const;


                Double_t getImagPropTerm(Int_t channelIndex) const;


                Double_t getPoleDenomTerm(Int_t poleIndex) const;


                Double_t getCouplingConstant(Int_t poleIndex, Int_t channelIndex) const;


                Double_t getProdSVPTerm() const {return prodSVP_;}


                LauComplex getPropTerm(Int_t channelIndex) const;


                Int_t getResPairAmpInt() const {return resPairAmpInt_;}


                Int_t getNChannels() const {return nChannels_;}


                Int_t getNPoles() const {return nPoles_;}


                TString getName() const {return name_;}


                LauComplex getTransitionAmp(Double_t s, Int_t channel);



                LauComplex getPhaseSpaceTerm(Double_t s, Int_t channel);


        protected:

                void calcScattKMatrix(Double_t s);


                void calcRhoMatrix(Double_t s);


                void calcPoleDenomVect(Double_t s);


                LauComplex calcPiPiRho(Double_t s) const;


                LauComplex calcKKRho(Double_t s) const;


                LauComplex calcFourPiRho(Double_t s) const;


                LauComplex calcEtaEtaRho(Double_t s) const;


                LauComplex calcEtaEtaPRho(Double_t s) const;


                LauComplex calcKPiRho(Double_t s) const;


                LauComplex calcKEtaPRho(Double_t s) const;


                LauComplex calcKThreePiRho(Double_t s) const;


                Double_t calcSVPTerm(Double_t s, Double_t s0) const;


                void updateScattSVPTerm(Double_t s);


                void updateProdSVPTerm(Double_t s);


                void updateAdlerZeroFactor(Double_t s);


                Bool_t checkPhaseSpaceType(Int_t phaseSpaceInt) const;



                void getTMatrix(const LauKinematics* kinematics);


                void getTMatrix(Double_t s);

                void getSqrtRhoMatrix();
                
        private:
                LauKMatrixPropagator(const LauKMatrixPropagator& rhs);

                LauKMatrixPropagator& operator=(const LauKMatrixPropagator& rhs);

                typedef std::map<int, std::vector<LauParameter> > KMatrixParamMap;

                TString name_;
                TString paramFileName_;
                Int_t resPairAmpInt_;
                Int_t index_;

                Double_t previousS_;
                Double_t scattSVP_;
                Double_t prodSVP_;
                TMatrixD realProp_; 
                TMatrixD negImagProp_;
                
                // Integers to specify the allowed channels for the phase space calculations.
                // Please keep Zero at the start and leave TotChannels at the end 
                // whenever more channels are added to this.
                enum KMatrixChannels {Zero, PiPi, KK, FourPi, EtaEta, EtaEtaP,
                                      KPi, KEtaP, KThreePi, TotChannels};

                TMatrixD ScattKMatrix_; 
                TMatrixD ReRhoMatrix_;
                TMatrixD ImRhoMatrix_;
                TMatrixD IMatrix_; 
                TMatrixD zeroMatrix_;

                TMatrixD ReSqrtRhoMatrix_;
                TMatrixD ImSqrtRhoMatrix_;
                TMatrixD ReTMatrix_;
                TMatrixD ImTMatrix_;

                Int_t nChannels_;
                Int_t nPoles_;

                std::vector<LauParameter> mSqPoles_;
                KMatrixParamMap gCouplings_;
                KMatrixParamMap fScattering_;
                std::vector<Int_t> phaseSpaceTypes_;
                std::vector<Double_t> mSumSq_;
                std::vector<Double_t> mDiffSq_;
                std::vector<Double_t> poleDenomVect_;

                LauParameter mSq0_; 
                LauParameter s0Scatt_; 
                LauParameter s0Prod_; 
                LauParameter sA_; 
                LauParameter sA0_;

                Double_t sAConst_;
                Double_t m2piSq_; 
                Double_t m2KSq_; 
                Double_t m2EtaSq_; 
                Double_t mEtaEtaPSumSq_; 
                Double_t mEtaEtaPDiffSq_;
                Double_t mKpiSumSq_; 
                Double_t mKpiDiffSq_; 
                Double_t mKEtaPSumSq_; 
                Double_t mKEtaPDiffSq_;
                Double_t mK3piDiffSq_; 
                Double_t k3piFactor_; 
                Double_t fourPiFactor1_; 
                Double_t fourPiFactor2_;

                Double_t adlerZeroFactor_;
                Bool_t parametersSet_;

                Bool_t verbose_;

                ClassDef(LauKMatrixPropagator,0) // K-matrix amplitude model

};

#endif