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 "LauConstants.hh"
#include "LauResonanceInfo.hh"
#include "LauResonanceMaker.hh"
 
#include "TMatrixD.h"
#include "TString.h"
 
#include <map>
#include <vector>
 
class LauParameter;
class LauKinematics;
class LauComplex;
 
class LauKMatrixPropagator {
 
  public:
 
    LauKMatrixPropagator( const TString& name,
                          const TString& paramFileName,
                          const Int_t resPairAmpInt,
                          const Int_t nChannels,
                          const Int_t nPoles,
                          const Int_t rowIndex = 1 );
 
    virtual ~LauKMatrixPropagator();
 
 
    void updatePropagator( const Double_t s );
 
 
    void setParameters( const TString& inputFile );
 
    void ignoreBWBarrierFactor() { includeBWBarrierFactor_ = kFALSE; }
 
 
    TMatrixD getKMatrix() const { return ScattKMatrix_; }
 
 
    TMatrixD getRealPropMatrix() const { return realProp_; }
 
 
    TMatrixD getNegImagPropMatrix() const { return negImagProp_; }
 
 
    Double_t getRealPropTerm( const Int_t channelIndex ) const;
 
 
    Double_t getImagPropTerm( const Int_t channelIndex ) const;
 
 
    Double_t getPoleDenomTerm( const Int_t poleIndex ) const;
 
 
    Int_t getL( const Int_t iChannel ) const { return L_[iChannel]; }
 
 
    Int_t getIndex() const { return index_; };
 
 
    LauParameter& getPoleMassSqParameter( const Int_t poleIndex );
 
 
    Double_t getCouplingConstant( const Int_t poleIndex, const Int_t channelIndex ) const;
 
 
    LauParameter& getCouplingParameter( const Int_t poleIndex, const Int_t channelIndex );
 
 
    Double_t getScatteringConstant( const Int_t channel1Index, const Int_t channel2Index ) const;
 
 
    LauParameter& getScatteringParameter( const Int_t channel1Index, const Int_t channel2Index );
 
 
    LauParameter& getmSq0() { return mSq0_; }
 
 
    LauParameter& gets0Scatt() { return s0Scatt_; }
 
 
    LauParameter& gets0Prod() { return s0Prod_; }
 
 
    LauParameter& getsA() { return sA_; }
 
 
    LauParameter& getsA0() { return sA0_; }
 
 
    Double_t getProdSVPTerm() const { return prodSVP_; }
 
 
    LauComplex getPropTerm( const 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( const Double_t s, const Int_t channel );
 
 
    LauComplex getPhaseSpaceTerm( const Double_t s, const Int_t channel );
 
 
    Double_t getAdlerZero() const { return adlerZeroFactor_; }
 
 
    LauComplex getTHat( const Double_t s, const Int_t channel );
 
  protected:
    // 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 class KMatrixChannels {
        Zero,
        PiPi,
        KK,
        FourPi,
        EtaEta,
        EtaEtaP,
        KPi,
        KEtaP,
        KThreePi,
        D0K,
        Dstar0K,
        TotChannels
    };
 
 
    void calcScattKMatrix( const Double_t s );
 
 
    void calcRhoMatrix( const Double_t s );
 
 
    LauComplex getRho( const Double_t s, const LauKMatrixPropagator::KMatrixChannels ) const;
 
 
    void calcGammaMatrix( const Double_t s );
 
 
    Double_t calcGamma( const Int_t iCh, const Double_t s ) const;
 
 
    void calcPoleDenomVect( const Double_t s );
 
 
    LauComplex calcD0KRho( const Double_t s ) const;
 
 
    LauComplex calcDstar0KRho( const Double_t s ) const;
 
 
    LauComplex calcPiPiRho( const Double_t s ) const;
 
 
    LauComplex calcKKRho( const Double_t s ) const;
 
 
    LauComplex calcFourPiRho( const Double_t s ) const;
 
 
    LauComplex calcEtaEtaRho( const Double_t s ) const;
 
 
    LauComplex calcEtaEtaPRho( const Double_t s ) const;
 
 
    LauComplex calcKPiRho( const Double_t s ) const;
 
 
    LauComplex calcKEtaPRho( const Double_t s ) const;
 
 
    LauComplex calcKThreePiRho( const Double_t s ) const;
 
 
    Double_t calcSVPTerm( const Double_t s, const Double_t s0 ) const;
 
 
    void updateScattSVPTerm( const Double_t s );
 
 
    void updateProdSVPTerm( const Double_t s );
 
 
    void updateAdlerZeroFactor( const Double_t s );
 
 
    Bool_t checkPhaseSpaceType( const Int_t phaseSpaceInt ) const;
 
 
    void getTMatrix( const LauKinematics* kinematics );
 
 
    void getTMatrix( const Double_t s );
 
    void getSqrtRhoMatrix();
 
  private:
    LauKMatrixPropagator( const LauKMatrixPropagator& rhs ) = delete;
 
    LauKMatrixPropagator& operator=( const LauKMatrixPropagator& rhs ) = delete;
 
    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 storeRadii( const std::vector<std::string>& theLine );
 
 
    void storeOrbitalAngularMomenta( const std::vector<std::string>& theLine, std::vector<Int_t>& a );
 
 
    void storeBarrierFactorParameter( const std::vector<std::string>& theLine, std::vector<Int_t>& a );
 
 
    void storeParameter( const TString& keyword, const TString& parString );
 
    TString name_;
    TString paramFileName_;
    Int_t resPairAmpInt_;
    Int_t index_;
 
    Double_t previousS_ { 0.0 };
    Double_t scattSVP_ { 0.0 };
    Double_t prodSVP_ { 0.0 };
    TMatrixD realProp_;
    TMatrixD negImagProp_;
 
    TMatrixD ScattKMatrix_;
    TMatrixD ReRhoMatrix_;
    TMatrixD ImRhoMatrix_;
    TMatrixD GammaMatrix_;
    TMatrixD IMatrix_;
    TMatrixD zeroMatrix_;
 
    TMatrixD ReSqrtRhoMatrix_;
    TMatrixD ImSqrtRhoMatrix_;
    TMatrixD ReTMatrix_;
    TMatrixD ImTMatrix_;
 
    Int_t nChannels_;
    Int_t nPoles_;
    std::vector<Int_t> L_;
    Bool_t haveCalled_storeBarrierFactorParameter { kFALSE };
    Bool_t includeBWBarrierFactor_ { kTRUE };
 
    std::vector<LauParameter> mSqPoles_;
 
    LauParArray gCouplings_;
    LauParArray fScattering_;
    std::vector<Double_t> radii_;
    std::vector<Double_t> gamAInvRadSq_;
 
    std::vector<KMatrixChannels> 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_ { 0.0 };
 
    const Double_t m2piSq_ { 4.0 * LauConstants::mPiSq };
    const Double_t m2KSq_ { 4.0 * LauConstants::mKSq };
    const Double_t m2EtaSq_ { 4.0 * LauConstants::mEtaSq };
    const Double_t mEtaEtaPSumSq_ { ( LauConstants::mEta + LauConstants::mEtaPrime ) *
                                    ( LauConstants::mEta + LauConstants::mEtaPrime ) };
    const Double_t mEtaEtaPDiffSq_ { ( LauConstants::mEta - LauConstants::mEtaPrime ) *
                                     ( LauConstants::mEta - LauConstants::mEtaPrime ) };
    const Double_t mKpiSumSq_ { ( LauConstants::mK + LauConstants::mPi ) *
                                ( LauConstants::mK + LauConstants::mPi ) };
    const Double_t mKpiDiffSq_ { ( LauConstants::mK - LauConstants::mPi ) *
                                 ( LauConstants::mK - LauConstants::mPi ) };
    const Double_t mKEtaPSumSq_ { ( LauConstants::mK + LauConstants::mEtaPrime ) *
                                  ( LauConstants::mK + LauConstants::mEtaPrime ) };
    const Double_t mKEtaPDiffSq_ { ( LauConstants::mK - LauConstants::mEtaPrime ) *
                                   ( LauConstants::mK - LauConstants::mEtaPrime ) };
    const Double_t mK3piDiffSq_ { ( LauConstants::mK - 3.0 * LauConstants::mPi ) *
                                  ( LauConstants::mK - 3.0 * LauConstants::mPi ) };
    const Double_t k3piFactor_ { TMath::Power( ( 1.44 - mK3piDiffSq_ ) / 1.44, -2.5 ) };
    const Double_t fourPiFactor1_ { 16.0 * LauConstants::mPiSq };
    const Double_t fourPiFactor2_ { TMath::Sqrt( 1.0 - fourPiFactor1_ ) };
    const Double_t mD0KSumSq_ { ( LauConstants::mD0 + LauConstants::mK ) *
                                ( LauConstants::mD0 + LauConstants::mK ) };
    const Double_t mD0KDiffSq_ { ( LauConstants::mD0 - LauConstants::mK ) *
                                 ( LauConstants::mD0 - LauConstants::mK ) };
    const Double_t mDstar0KSumSq_ {
        ( LauResonanceMaker::get().getResInfo( "D*0" )->getMass()->value() + LauConstants::mK ) *
        ( LauResonanceMaker::get().getResInfo( "D*0" )->getMass()->value() + LauConstants::mK ) };
    const Double_t mDstar0KDiffSq_ {
        ( LauResonanceMaker::get().getResInfo( "D*0" )->getMass()->value() - LauConstants::mK ) *
        ( LauResonanceMaker::get().getResInfo( "D*0" )->getMass()->value() - LauConstants::mK ) };
 
    Double_t adlerZeroFactor_ { 0.0 };
    Bool_t parametersSet_ { kFALSE };
 
    static constexpr Bool_t verbose_ { kFALSE };
 
    Bool_t scattSymmetry_ { kFALSE };
 
    ClassDef( LauKMatrixPropagator, 0 )    // K-matrix amplitude model
};
 
#endif