LauKMatrixPropagator.hh

Go to the documentation of this file.

/*
Copyright 2008 University of Warwick

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/

/*
Laura++ package authors:
John Back
Paul Harrison
Thomas Latham
*/

#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_;}


                TMatrixD getRealPropMatrix() const {return realProp_;}


                TMatrixD getNegImagPropMatrix() const {return negImagProp_;}


                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 getScatteringConstant(Int_t channel1Index, Int_t channel2Index) 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);


                Double_t getAdlerZero() const {return adlerZeroFactor_;}
    


                LauComplex getTHat(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;


                void initialiseMatrices();


                void storeChannels(const std::vector<std::string>& theLine);
 

                void storePole(const std::vector<std::string>& theLine);


                void storeScattering(const std::vector<std::string>& theLine);


                void storeParameter(const TString& keyword, const TString& parString);


                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_;

                LauParArray gCouplings_;
                LauParArray 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_;

                Bool_t scattSymmetry_;

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

#endif