Changeset View
Changeset View
Standalone View
Standalone View
inc/LauKMatrixPropagator.hh
/* | /* | ||||
Copyright 2008 University of Warwick | Copyright 2008 University of Warwick | ||||
Licensed under the Apache License, Version 2.0 (the "License"); | Licensed under the Apache License, Version 2.0 (the "License"); | ||||
you may not use this file except in compliance with the License. | you may not use this file except in compliance with the License. | ||||
You may obtain a copy of the License at | You may obtain a copy of the License at | ||||
http://www.apache.org/licenses/LICENSE-2.0 | http://www.apache.org/licenses/LICENSE-2.0 | ||||
Unless required by applicable law or agreed to in writing, software | Unless required by applicable law or agreed to in writing, software | ||||
distributed under the License is distributed on an "AS IS" BASIS, | distributed under the License is distributed on an "AS IS" BASIS, | ||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | ||||
See the License for the specific language governing permissions and | See the License for the specific language governing permissions and | ||||
limitations under the License. | limitations under the License. | ||||
*/ | */ | ||||
/* | /* | ||||
Laura++ package authors: | Laura++ package authors: | ||||
John Back | John Back | ||||
Paul Harrison | Paul Harrison | ||||
Thomas Latham | Thomas Latham | ||||
*/ | */ | ||||
/*! \file LauKMatrixPropagator.hh | /*! \file LauKMatrixPropagator.hh | ||||
\brief File containing declaration of LauKMatrixPropagator class. | \brief File containing declaration of LauKMatrixPropagator class. | ||||
*/ | */ | ||||
/*! \class LauKMatrixPropagator | /*! \class LauKMatrixPropagator | ||||
\brief Class for defining a K-matrix propagator. | \brief Class for defining a K-matrix propagator. | ||||
Class used to define a K-matrix propagator. | Class used to define a K-matrix propagator. | ||||
See the following papers for info: | See the following papers for info: | ||||
hep-ph/0204328, hep-ex/0312040, [hep-ex]0804.2089 and hep-ph/9705401. | hep-ph/0204328, hep-ex/0312040, [hep-ex]0804.2089 and hep-ph/9705401. | ||||
*/ | */ | ||||
#ifndef LAU_KMATRIX_PROPAGATOR | #ifndef LAU_KMATRIX_PROPAGATOR | ||||
#define LAU_KMATRIX_PROPAGATOR | #define LAU_KMATRIX_PROPAGATOR | ||||
#include "LauComplex.hh" | #include "LauConstants.hh" | ||||
#include "LauKinematics.hh" | #include "LauResonanceMaker.hh" | ||||
#include "LauParameter.hh" | #include "LauResonanceInfo.hh" | ||||
#include "TMatrixD.h" | #include "TMatrixD.h" | ||||
#include "TString.h" | #include "TString.h" | ||||
#include <map> | #include <map> | ||||
#include <vector> | #include <vector> | ||||
class LauParameter; | |||||
class LauKinematics; | |||||
class LauComplex; | |||||
class LauKMatrixPropagator { | class LauKMatrixPropagator { | ||||
public: | public: | ||||
//! Constructor | //! Constructor | ||||
/*! | /*! | ||||
\param [in] name name of the propagator | \param [in] name name of the propagator | ||||
\param [in] paramFileName the parameter file name | \param [in] paramFileName the parameter file name | ||||
\param [in] resPairAmpInt the number of the daughter not produced by the resonance | \param [in] resPairAmpInt the number of the daughter not produced by the resonance | ||||
\param [in] nChannels the number of channels | \param [in] nChannels the number of channels | ||||
\param [in] nPoles the number of poles | \param [in] nPoles the number of poles | ||||
\param [in] rowIndex this specifies which row of the propagator should be used when summing over the amplitude channels | \param [in] rowIndex this specifies which row of the propagator should be used when summing over the amplitude channels | ||||
*/ | */ | ||||
LauKMatrixPropagator( const TString& name, const TString& paramFileName, | LauKMatrixPropagator( const TString& name, const TString& paramFileName, | ||||
Int_t resPairAmpInt, Int_t nChannels, Int_t nPoles, | const Int_t resPairAmpInt, const Int_t nChannels, const Int_t nPoles, | ||||
Int_t rowIndex = 1 ); | const Int_t rowIndex = 1 ); | ||||
jback: We should add another parameter in the constructor to define the spin L value (the last… | |||||
Done Inline ActionsInstead of defining the KMatrixSpin enum (mentioned also below) we just need to set a spin integer L_. jback: Instead of defining the KMatrixSpin enum (mentioned also below) we just need to set a spin… | |||||
//! Destructor | //! Destructor | ||||
virtual ~LauKMatrixPropagator(); | virtual ~LauKMatrixPropagator(); | ||||
//! Calculate the invariant mass squared s | |||||
/*! | |||||
\param [in] kinematics the kinematics of the current event | |||||
*/ | |||||
void updatePropagator(const LauKinematics* kinematics); | |||||
//! Calculate the K-matrix propagator for the given s value | //! Calculate the K-matrix propagator for the given s value | ||||
/*! | /*! | ||||
\param [in] s the invariant mass squared | \param [in] s the invariant mass squared | ||||
*/ | */ | ||||
void updatePropagator(Double_t s); | void updatePropagator(const Double_t s); | ||||
//! Read an input file to set parameters | //! Read an input file to set parameters | ||||
/*! | /*! | ||||
\param [in] inputFile name of the input file | \param [in] inputFile name of the input file | ||||
*/ | */ | ||||
void setParameters(const TString& inputFile); | void setParameters(const TString& inputFile); | ||||
//! Set flag to ignore Blatt-Weisskopf-like barrier factor | |||||
void ignoreBWBarrierFactor() {includeBWBarrierFactor_=kFALSE;} | |||||
//! Get the scattering K matrix | //! Get the scattering K matrix | ||||
/*! | /*! | ||||
\return the real, symmetric scattering K matrix | \return the real, symmetric scattering K matrix | ||||
*/ | */ | ||||
TMatrixD getKMatrix() const {return ScattKMatrix_;} | TMatrixD getKMatrix() const {return ScattKMatrix_;} | ||||
//! Get the real part of the propagator full matrix | //! Get the real part of the propagator full matrix | ||||
/*! | /*! | ||||
\return the real part of the propagator full matrix | \return the real part of the propagator full matrix | ||||
*/ | */ | ||||
TMatrixD getRealPropMatrix() const {return realProp_;} | TMatrixD getRealPropMatrix() const {return realProp_;} | ||||
//! Get the negative imaginary part of the full propagator matrix | //! Get the negative imaginary part of the full propagator matrix | ||||
/*! | /*! | ||||
\return the negative imaginary part of the full propagator matrix | \return the negative imaginary part of the full propagator matrix | ||||
*/ | */ | ||||
TMatrixD getNegImagPropMatrix() const {return negImagProp_;} | TMatrixD getNegImagPropMatrix() const {return negImagProp_;} | ||||
//! Get the real part of the term of the propagator | //! Get the real part of the term of the propagator | ||||
/*! | /*! | ||||
\param [in] channelIndex the channel number | \param [in] channelIndex the channel number | ||||
\return the real part of the propagator term | \return the real part of the propagator term | ||||
*/ | */ | ||||
Double_t getRealPropTerm(Int_t channelIndex) const; | Double_t getRealPropTerm(const Int_t channelIndex) const; | ||||
//! Get the imaginary part of the term of the propagator | //! Get the imaginary part of the term of the propagator | ||||
/*! | /*! | ||||
\param [in] channelIndex the channel number | \param [in] channelIndex the channel number | ||||
\return the imaginiary part of the propagator term | \return the imaginiary part of the propagator term | ||||
*/ | */ | ||||
Double_t getImagPropTerm(Int_t channelIndex) const; | Double_t getImagPropTerm(const Int_t channelIndex) const; | ||||
//! Get the 1/(m_pole^2 -s) terms for the scattering and production K-matrix formulae | //! Get the 1/(m_pole^2 -s) terms for the scattering and production K-matrix formulae | ||||
/*! | /*! | ||||
\param [in] poleIndex the number of the pole required | \param [in] poleIndex the number of the pole required | ||||
\return the value of 1/(m_pole^2 -s) | \return the value of 1/(m_pole^2 -s) | ||||
*/ | */ | ||||
Double_t getPoleDenomTerm(Int_t poleIndex) const; | Double_t getPoleDenomTerm(const Int_t poleIndex) const; | ||||
//! Get coupling parameters, set according to the input file | //! Get spin of K-matrix | ||||
/*! | |||||
\param [in] iChannel the index of the channel | |||||
\return the value of the orbital angular momentum, L_, for this channel | |||||
*/ | |||||
Int_t getL(const Int_t iChannel) const {return L_[iChannel];} | |||||
//! Get index of final channel | |||||
/*! | |||||
\return the index of the channel into which the scattering happens | |||||
*/ | |||||
Int_t getIndex() const {return index_;}; | |||||
//! Get pole mass parameters, set according to the input file | |||||
/*! | /*! | ||||
\param [in] poleIndex number of the required pole | \param [in] poleIndex number of the required pole | ||||
\param [in] channelIndex number of the required channel | \param [in] channelIndex number of the required channel | ||||
\return the parameter of the coupling constant | \return the parameter of the pole mass | ||||
*/ | */ | ||||
LauParameter& getPoleMassSqParameter(Int_t poleIndex); | LauParameter& getPoleMassSqParameter(const Int_t poleIndex); | ||||
//! Get coupling constants that were loaded from the input file | //! Get coupling constants that were loaded from the input file | ||||
/*! | /*! | ||||
\param [in] poleIndex number of the required pole | \param [in] poleIndex number of the required pole | ||||
\param [in] channelIndex number of the required channel | \param [in] channelIndex number of the required channel | ||||
\return the value of the coupling constant | \return the value of the coupling constant | ||||
*/ | */ | ||||
Double_t getCouplingConstant(Int_t poleIndex, Int_t channelIndex) const; | Double_t getCouplingConstant(const Int_t poleIndex, const Int_t channelIndex) const; | ||||
//! Get coupling parameters, set according to the input file | //! Get coupling parameters, set according to the input file | ||||
/*! | /*! | ||||
\param [in] poleIndex number of the required pole | \param [in] poleIndex number of the required pole | ||||
\param [in] channelIndex number of the required channel | \param [in] channelIndex number of the required channel | ||||
\return the parameter of the coupling constant | \return the parameter of the coupling constant | ||||
*/ | */ | ||||
LauParameter& getCouplingParameter(Int_t poleIndex, Int_t channelIndex); | LauParameter& getCouplingParameter(const Int_t poleIndex, const Int_t channelIndex); | ||||
//! Get scattering constants that were loaded from the input file | //! Get scattering constants that were loaded from the input file | ||||
/*! | /*! | ||||
\param [in] channel1Index number of the first channel index | \param [in] channel1Index number of the first channel index | ||||
\param [in] channel2Index number of the second channel index | \param [in] channel2Index number of the second channel index | ||||
\return the value of the scattering constant | \return the value of the scattering constant | ||||
*/ | */ | ||||
Double_t getScatteringConstant(Int_t channel1Index, Int_t channel2Index) const; | Double_t getScatteringConstant(const Int_t channel1Index, const Int_t channel2Index) const; | ||||
//! Get scattering parameters, set according to the input file | //! Get scattering parameters, set according to the input file | ||||
/*! | /*! | ||||
\param [in] channel1Index number of the first channel index | \param [in] channel1Index number of the first channel index | ||||
\param [in] channel2Index number of the second channel index | \param [in] channel2Index number of the second channel index | ||||
\return the parameter of the scattering constant | \return the parameter of the scattering constant | ||||
*/ | */ | ||||
LauParameter& getScatteringParameter(Int_t channel1Index, Int_t channel2Index); | LauParameter& getScatteringParameter(const Int_t channel1Index, const Int_t channel2Index); | ||||
//! Get mSq0 production parameter | //! Get mSq0 production parameter | ||||
/*! | /*! | ||||
\return the mSq0 parameter | \return the mSq0 parameter | ||||
*/ | */ | ||||
LauParameter& getmSq0() {return mSq0_;} | LauParameter& getmSq0() {return mSq0_;} | ||||
//! Get s0Scatt production parameter | //! Get s0Scatt production parameter | ||||
/*! | /*! | ||||
\return the s0Scatt parameter | \return the s0Scatt parameter | ||||
*/ | */ | ||||
LauParameter& gets0Scatt() {return s0Scatt_;} | LauParameter& gets0Scatt() {return s0Scatt_;} | ||||
//! Get s0 production parameter | //! Get s0 production parameter | ||||
/*! | /*! | ||||
\return the s0Prod parameter | \return the s0Prod parameter | ||||
*/ | */ | ||||
LauParameter& gets0Prod() {return s0Prod_;} | LauParameter& gets0Prod() {return s0Prod_;} | ||||
//! Get sA production parameter | //! Get sA production parameter | ||||
/*! | /*! | ||||
\return the sA parameter | \return the sA parameter | ||||
*/ | */ | ||||
LauParameter& getsA() {return sA_;} | LauParameter& getsA() {return sA_;} | ||||
//! Get sA0 production parameter | //! Get sA0 production parameter | ||||
/*! | /*! | ||||
\return the sA0 parameter | \return the sA0 parameter | ||||
*/ | */ | ||||
LauParameter& getsA0() {return sA0_;} | LauParameter& getsA0() {return sA0_;} | ||||
//! Get the "slowly-varying part" term of the amplitude | //! Get the "slowly-varying part" term of the amplitude | ||||
/*! | /*! | ||||
\return the svp term | \return the svp term | ||||
*/ | */ | ||||
Double_t getProdSVPTerm() const {return prodSVP_;} | Double_t getProdSVPTerm() const {return prodSVP_;} | ||||
//! Get the full complex propagator term for a given channel | //! Get the full complex propagator term for a given channel | ||||
/*! | /*! | ||||
\param [in] channelIndex the number of the required channel | \param [in] channelIndex the number of the required channel | ||||
\return the complex propagator term | \return the complex propagator term | ||||
*/ | */ | ||||
LauComplex getPropTerm(Int_t channelIndex) const; | LauComplex getPropTerm(const Int_t channelIndex) const; | ||||
//! Get the DP axis identifier | //! Get the DP axis identifier | ||||
/*! | /*! | ||||
\return the value to identify the DP axis in question | \return the value to identify the DP axis in question | ||||
*/ | */ | ||||
Int_t getResPairAmpInt() const {return resPairAmpInt_;} | Int_t getResPairAmpInt() const {return resPairAmpInt_;} | ||||
//! Get the number of channels | //! Get the number of channels | ||||
Show All 15 Lines | public: | ||||
TString getName() const {return name_;} | TString getName() const {return name_;} | ||||
//! Get the unitary transition amplitude for the given channel | //! Get the unitary transition amplitude for the given channel | ||||
/*! | /*! | ||||
\param [in] s The invariant mass squared | \param [in] s The invariant mass squared | ||||
\param [in] channel The index number of the channel process | \param [in] channel The index number of the channel process | ||||
\return the complex amplitude T | \return the complex amplitude T | ||||
*/ | */ | ||||
LauComplex getTransitionAmp(Double_t s, Int_t channel); | LauComplex getTransitionAmp(const Double_t s, const Int_t channel); | ||||
//! Get the complex phase space term for the given channel and invariant mass squared | //! Get the complex phase space term for the given channel and invariant mass squared | ||||
/*! | /*! | ||||
\param [in] s The invariant mass squared | \param [in] s The invariant mass squared | ||||
\param [in] channel The index number of the channel process | \param [in] channel The index number of the channel process | ||||
\return the complex phase space term rho(channel, channel) | \return the complex phase space term rho(channel, channel) | ||||
*/ | */ | ||||
LauComplex getPhaseSpaceTerm(Double_t s, Int_t channel); | LauComplex getPhaseSpaceTerm(const Double_t s, const Int_t channel); | ||||
//! Get the Adler zero factor, which is set when updatePropagator is called | //! Get the Adler zero factor, which is set when updatePropagator is called | ||||
/*! | /*! | ||||
\return the Adler zero factor | \return the Adler zero factor | ||||
*/ | */ | ||||
Double_t getAdlerZero() const {return adlerZeroFactor_;} | Double_t getAdlerZero() const {return adlerZeroFactor_;} | ||||
//! Get the THat amplitude for the given s and channel number | //! Get the THat amplitude for the given s and channel number | ||||
/*! | /*! | ||||
\param [in] s The invariant mass squared | \param [in] s The invariant mass squared | ||||
\param [in] channel The index number of the channel process | \param [in] channel The index number of the channel process | ||||
\return the complex THat amplitude | \return the complex THat amplitude | ||||
*/ | */ | ||||
LauComplex getTHat(Double_t s, Int_t channel); | LauComplex getTHat(const Double_t s, const Int_t channel); | ||||
protected: | 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. | |||||
//! Integers to specify the allowed channels for the phase space calculations | |||||
enum class KMatrixChannels {Zero, PiPi, KK, FourPi, EtaEta, EtaEtaP, | |||||
KPi, KEtaP, KThreePi, D0K, Dstar0K, TotChannels}; | |||||
//! Calculate the scattering K-matrix for the given value of s | //! Calculate the scattering K-matrix for the given value of s | ||||
/*! | /*! | ||||
\param [in] s the invariant mass squared | \param [in] s the invariant mass squared | ||||
*/ | */ | ||||
void calcScattKMatrix(Double_t s); | void calcScattKMatrix(const Double_t s); | ||||
//! Calculate the real and imaginary part of the phase space density diagonal matrix | //! Calculate the real and imaginary part of the phase space density diagonal matrix | ||||
/*! | /*! | ||||
\param [in] s the invariant mass squared | \param [in] s the invariant mass squared | ||||
*/ | */ | ||||
void calcRhoMatrix(Double_t s); | void calcRhoMatrix(const Double_t s); | ||||
//! Calculate the (real) gamma angular-momentum barrier matrix | |||||
/*! | |||||
\param [in] s the invariant mass squared | |||||
*/ | |||||
void calcGammaMatrix(const Double_t s); | |||||
//! Calculate the DK P-wave gamma angular-momentum barrier | |||||
/*! | |||||
\param [in] s the invariant mass squared | |||||
\return the centrifugal barrier factor for L=0,1, or 2 | |||||
*/ | |||||
Double_t calcGamma(const Int_t iCh, const Double_t s, KMatrixChannels phaseSpaceIndex) const; | |||||
//! Calulate the term 1/(m_pole^2 - s) for the scattering and production K-matrix formulae | //! Calulate the term 1/(m_pole^2 - s) for the scattering and production K-matrix formulae | ||||
/*! | /*! | ||||
Not Done Inline ActionsPlease remove "DK P-wave" in the comment here, since method is general. jback: Please remove "DK P-wave" in the comment here, since method is general. | |||||
\param [in] s the invariant mass squared | \param [in] s the invariant mass squared | ||||
*/ | */ | ||||
void calcPoleDenomVect(Double_t s); | void calcPoleDenomVect(const Double_t s); | ||||
//! Calculate the D0K+ phase space factor | |||||
/*! | |||||
\param [in] s the invariant mass squared | |||||
\return the complex phase space factor | |||||
*/ | |||||
LauComplex calcD0KRho(const Double_t s) const; | |||||
//! Calculate the D*0K+ phase space factor | |||||
/*! | |||||
\param [in] s the invariant mass squared | |||||
\return the complex phase space factor | |||||
*/ | |||||
LauComplex calcDstar0KRho(const Double_t s) const; | |||||
//! Calculate the pipi phase space factor | //! Calculate the pipi phase space factor | ||||
/*! | /*! | ||||
\param [in] s the invariant mass squared | \param [in] s the invariant mass squared | ||||
\return the complex phase space factor | \return the complex phase space factor | ||||
*/ | */ | ||||
LauComplex calcPiPiRho(Double_t s) const; | LauComplex calcPiPiRho(const Double_t s) const; | ||||
//! Calculate the KK phase space factor | //! Calculate the KK phase space factor | ||||
/*! | /*! | ||||
\param [in] s the invariant mass squared | \param [in] s the invariant mass squared | ||||
\return the complex phase space factor | \return the complex phase space factor | ||||
*/ | */ | ||||
LauComplex calcKKRho(Double_t s) const; | LauComplex calcKKRho(const Double_t s) const; | ||||
//! Calculate the 4 pi phase space factor | //! Calculate the 4 pi phase space factor | ||||
/*! | /*! | ||||
\param [in] s the invariant mass squared | \param [in] s the invariant mass squared | ||||
\return the complex phase space factor | \return the complex phase space factor | ||||
*/ | */ | ||||
LauComplex calcFourPiRho(Double_t s) const; | LauComplex calcFourPiRho(const Double_t s) const; | ||||
//! Calculate the eta-eta phase space factor | //! Calculate the eta-eta phase space factor | ||||
/*! | /*! | ||||
\param [in] s the invariant mass squared | \param [in] s the invariant mass squared | ||||
\return the complex phase space factor | \return the complex phase space factor | ||||
*/ | */ | ||||
LauComplex calcEtaEtaRho(Double_t s) const; | LauComplex calcEtaEtaRho(const Double_t s) const; | ||||
//! Calculate the eta-eta' phase space factor | //! Calculate the eta-eta' phase space factor | ||||
/*! | /*! | ||||
\param [in] s the invariant mass squared | \param [in] s the invariant mass squared | ||||
\return the complex phase space factor | \return the complex phase space factor | ||||
*/ | */ | ||||
LauComplex calcEtaEtaPRho(Double_t s) const; | LauComplex calcEtaEtaPRho(const Double_t s) const; | ||||
//! Calculate the Kpi phase space factor | //! Calculate the Kpi phase space factor | ||||
/*! | /*! | ||||
\param [in] s the invariant mass squared | \param [in] s the invariant mass squared | ||||
\return the complex phase space factor | \return the complex phase space factor | ||||
*/ | */ | ||||
LauComplex calcKPiRho(Double_t s) const; | LauComplex calcKPiRho(const Double_t s) const; | ||||
//! Calculate the K-eta' phase space factor | //! Calculate the K-eta' phase space factor | ||||
/*! | /*! | ||||
\param [in] s the invariant mass squared | \param [in] s the invariant mass squared | ||||
\return the complex phase space factor | \return the complex phase space factor | ||||
*/ | */ | ||||
LauComplex calcKEtaPRho(Double_t s) const; | LauComplex calcKEtaPRho(const Double_t s) const; | ||||
//! Calculate the Kpipipi phase space factor | //! Calculate the Kpipipi phase space factor | ||||
/*! | /*! | ||||
\param [in] s the invariant mass squared | \param [in] s the invariant mass squared | ||||
\return the complex phase space factor | \return the complex phase space factor | ||||
*/ | */ | ||||
LauComplex calcKThreePiRho(Double_t s) const; | LauComplex calcKThreePiRho(const Double_t s) const; | ||||
//! Calculate the "slow-varying part" | //! Calculate the "slow-varying part" | ||||
/*! | /*! | ||||
\param [in] s the invariant mass squared | \param [in] s the invariant mass squared | ||||
\param [in] s0 the invariant mass squared at the Adler zero | \param [in] s0 the invariant mass squared at the Adler zero | ||||
\return the SVP term | \return the SVP term | ||||
*/ | */ | ||||
Double_t calcSVPTerm(Double_t s, Double_t s0) const; | Double_t calcSVPTerm(const Double_t s, const Double_t s0) const; | ||||
//! Update the scattering "slowly-varying part" | //! Update the scattering "slowly-varying part" | ||||
/*! | /*! | ||||
\param [in] s the invariant mass squared | \param [in] s the invariant mass squared | ||||
*/ | */ | ||||
void updateScattSVPTerm(Double_t s); | void updateScattSVPTerm(const Double_t s); | ||||
//! Update the production "slowly-varying part" | //! Update the production "slowly-varying part" | ||||
/*! | /*! | ||||
\param [in] s the invariant mass squared | \param [in] s the invariant mass squared | ||||
*/ | */ | ||||
void updateProdSVPTerm(Double_t s); | void updateProdSVPTerm(const Double_t s); | ||||
//! Calculate the multiplicative factor containing severa Adler zero constants | //! Calculate the multiplicative factor containing severa Adler zero constants | ||||
/*! | /*! | ||||
\param [in] s the invariant mass squared | \param [in] s the invariant mass squared | ||||
*/ | */ | ||||
void updateAdlerZeroFactor(Double_t s); | void updateAdlerZeroFactor(const Double_t s); | ||||
//! Check the phase space factors that need to be used | //! Check the phase space factors that need to be used | ||||
/*! | /*! | ||||
\param [in] phaseSpaceInt phase space types | \param [in] phaseSpaceInt phase space types | ||||
\return true of false | \return true of false | ||||
*/ | */ | ||||
Bool_t checkPhaseSpaceType(Int_t phaseSpaceInt) const; | Bool_t checkPhaseSpaceType(const Int_t phaseSpaceInt) const; | ||||
//! Get the unitary transition amplitude matrix for the given kinematics | //! Get the unitary transition amplitude matrix for the given kinematics | ||||
/*! | /*! | ||||
\param [in] kinematics The pointer to the constant kinematics | \param [in] kinematics The pointer to the constant kinematics | ||||
*/ | */ | ||||
void getTMatrix(const LauKinematics* kinematics); | void getTMatrix(const LauKinematics* kinematics); | ||||
//! Get the unitary transition amplitude matrix for the given kinematics | //! Get the unitary transition amplitude matrix for the given kinematics | ||||
/*! | /*! | ||||
\param [in] s The invariant mass squared of the system | \param [in] s The invariant mass squared of the system | ||||
*/ | */ | ||||
void getTMatrix(Double_t s); | void getTMatrix(const Double_t s); | ||||
//! Get the square root of the phase space matrix | //! Get the square root of the phase space matrix | ||||
void getSqrtRhoMatrix(); | void getSqrtRhoMatrix(); | ||||
private: | private: | ||||
//! Copy constructor (not implemented) | //! Copy constructor (not implemented) | ||||
LauKMatrixPropagator(const LauKMatrixPropagator& rhs); | LauKMatrixPropagator(const LauKMatrixPropagator& rhs)=delete; | ||||
//! Copy assignment operator (not implemented) | //! Copy assignment operator (not implemented) | ||||
LauKMatrixPropagator& operator=(const LauKMatrixPropagator& rhs); | LauKMatrixPropagator& operator=(const LauKMatrixPropagator& rhs)=delete; | ||||
//! Create a map for the K-matrix parameters | |||||
typedef std::map<int, std::vector<LauParameter> > KMatrixParamMap; | |||||
//! Initialise and set the dimensions for the internal matrices and parameter arrays | //! Initialise and set the dimensions for the internal matrices and parameter arrays | ||||
void initialiseMatrices(); | void initialiseMatrices(); | ||||
//! Store the (phase space) channel indices from a line in the parameter file | //! Store the (phase space) channel indices from a line in the parameter file | ||||
/*! | /*! | ||||
\param [in] theLine Vector of strings corresponding to the line from the parameter file | \param [in] theLine Vector of strings corresponding to the line from the parameter file | ||||
*/ | */ | ||||
void storeChannels(const std::vector<std::string>& theLine); | void storeChannels(const std::vector<std::string>& theLine); | ||||
//! Store the pole mass and couplings from a line in the parameter file | //! Store the pole mass and couplings from a line in the parameter file | ||||
/*! | /*! | ||||
\param [in] theLine Vector of strings corresponding to the line from the parameter file | \param [in] theLine Vector of strings corresponding to the line from the parameter file | ||||
*/ | */ | ||||
void storePole(const std::vector<std::string>& theLine); | void storePole(const std::vector<std::string>& theLine); | ||||
//! Store the scattering coefficients from a line in the parameter file | //! Store the scattering coefficients from a line in the parameter file | ||||
/*! | /*! | ||||
\param [in] theLine Vector of strings corresponding to the line from the parameter file | \param [in] theLine Vector of strings corresponding to the line from the parameter file | ||||
*/ | */ | ||||
void storeScattering(const std::vector<std::string>& theLine); | void storeScattering(const std::vector<std::string>& theLine); | ||||
//! Store the channels' characteristic radii from a line in the parameter file | |||||
/*! | |||||
\param [in] theLine Vector of strings corresponding to the line from the parameter file | |||||
*/ | |||||
void storeRadii(const std::vector<std::string>& theLine); | |||||
//! Store the channels' angular momenta from a line in the parameter file | |||||
/*! | |||||
\param [in] theLine Vector of strings corresponding to the line from the parameter file | |||||
\param [in] a Vector of integers corresponding to parameter in the propagator denominator | |||||
*/ | |||||
void storeOrbitalAngularMomenta(const std::vector<std::string>& theLine, std::vector<Int_t> a); | |||||
//! Store the barrier-factor parameter from a line in the parameter file | |||||
/*! | |||||
\param [in] theLine Vector of strings corresponding to the line from the parameter file | |||||
\param [in] a Vector of integers corresponding to parameter in the propagator denominator | |||||
*/ | |||||
void storeBarrierFactorParameter(const std::vector<std::string>& theLine, std::vector<Int_t> a); | |||||
//! Store miscelleanous parameters from a line in the parameter file | //! Store miscelleanous parameters from a line in the parameter file | ||||
/*! | /*! | ||||
\param [in] keyword the name of the parameter to be set | \param [in] keyword the name of the parameter to be set | ||||
\param [in] parString the string containing the value of the parameter | \param [in] parString the string containing the value of the parameter | ||||
*/ | */ | ||||
void storeParameter(const TString& keyword, const TString& parString); | void storeParameter(const TString& keyword, const TString& parString); | ||||
//! String to store the propagator name | //! String to store the propagator name | ||||
TString name_; | TString name_; | ||||
//! Name of the input parameter file | //! Name of the input parameter file | ||||
TString paramFileName_; | TString paramFileName_; | ||||
//! Number to identify the DP axis in question | //! Number to identify the DP axis in question | ||||
Int_t resPairAmpInt_; | Int_t resPairAmpInt_; | ||||
//! Row index - 1 | //! Row index - 1 | ||||
Int_t index_; | Int_t index_; | ||||
//! s value of the previous pole | //! s value of the previous pole | ||||
Double_t previousS_; | Double_t previousS_{0.0}; | ||||
//! "slowly-varying part" for the scattering K-matrix | //! "slowly-varying part" for the scattering K-matrix | ||||
Double_t scattSVP_; | Double_t scattSVP_{0.0}; | ||||
//! "slowly-varying part" for the production K-matrix | //! "slowly-varying part" for the production K-matrix | ||||
Double_t prodSVP_; | Double_t prodSVP_{0.0}; | ||||
//! Real part of the propagator matrix | //! Real part of the propagator matrix | ||||
TMatrixD realProp_; | TMatrixD realProp_; | ||||
//! Imaginary part of the propagator matrix | //! Imaginary part of the propagator matrix | ||||
TMatrixD negImagProp_; | 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. | |||||
//! Integers to specify the allowed channels for the phase space calculations | |||||
enum KMatrixChannels {Zero, PiPi, KK, FourPi, EtaEta, EtaEtaP, | |||||
KPi, KEtaP, KThreePi, TotChannels}; | |||||
//! Scattering K-matrix | //! Scattering K-matrix | ||||
Done Inline ActionsI think it will be much better to define another enumeration that specifies the spin of the K-matrix, irrespective of the channels. That way we can use non-zero spins for other modes such as pi pi etc. enum KMatrixSpin {SWave, PWave, DWave, MaxSpin}; I would change D0K_Pwave to D0K etc. and then we specify the spin via the constructor. Would we never use S-wave for D0K? jback: I think it will be much better to define another enumeration that specifies the spin of the K… | |||||
TMatrixD ScattKMatrix_; | TMatrixD ScattKMatrix_; | ||||
//! Real part of the phase space density diagonal matrix | //! Real part of the phase space density diagonal matrix | ||||
TMatrixD ReRhoMatrix_; | TMatrixD ReRhoMatrix_; | ||||
//! Imaginary part of the phase space density diagonal matrix | //! Imaginary part of the phase space density diagonal matrix | ||||
TMatrixD ImRhoMatrix_; | TMatrixD ImRhoMatrix_; | ||||
//! Gamma angular-momentum barrier matrix | |||||
TMatrixD GammaMatrix_; | |||||
//! Identity matrix | //! Identity matrix | ||||
TMatrixD IMatrix_; | TMatrixD IMatrix_; | ||||
//! Null matrix | //! Null matrix | ||||
TMatrixD zeroMatrix_; | TMatrixD zeroMatrix_; | ||||
//! Real part of the square root of the phase space density diagonal matrix | //! Real part of the square root of the phase space density diagonal matrix | ||||
TMatrixD ReSqrtRhoMatrix_; | TMatrixD ReSqrtRhoMatrix_; | ||||
//! Imaginary part of the square root of the phase space density diagonal matrix | //! Imaginary part of the square root of the phase space density diagonal matrix | ||||
TMatrixD ImSqrtRhoMatrix_; | TMatrixD ImSqrtRhoMatrix_; | ||||
//! Real part of the unitary T matrix | //! Real part of the unitary T matrix | ||||
TMatrixD ReTMatrix_; | TMatrixD ReTMatrix_; | ||||
//! Imaginary part of the unitary T matrix | //! Imaginary part of the unitary T matrix | ||||
TMatrixD ImTMatrix_; | TMatrixD ImTMatrix_; | ||||
//! Number of channels | //! Number of channels | ||||
Int_t nChannels_; | Int_t nChannels_; | ||||
//! Number of poles | //! Number of poles | ||||
Int_t nPoles_; | Int_t nPoles_; | ||||
//! Vector of orbital angular momenta | |||||
std::vector<Int_t> L_; | |||||
//! Boolean to indicate whether storeBarrierFactorParameter has been called | |||||
Bool_t haveCalled_storeBarrierFactorParameter{kFALSE}; | |||||
//! Boolean to dictate whether to include Blatt-Weisskopf-like denominator in K-matrix centrifugal barrier factor | |||||
Bool_t includeBWBarrierFactor_{kTRUE}; | |||||
Done Inline ActionsUse uniform initialisation here for consistency. tlatham: Use uniform initialisation here for consistency. | |||||
//! Vector of squared pole masses | //! Vector of squared pole masses | ||||
std::vector<LauParameter> mSqPoles_; | std::vector<LauParameter> mSqPoles_; | ||||
//! Array of coupling constants | //! Array of coupling constants | ||||
LauParArray gCouplings_; | LauParArray gCouplings_; | ||||
//! Array of scattering SVP values | //! Array of scattering SVP values | ||||
LauParArray fScattering_; | LauParArray fScattering_; | ||||
//! Vector of characteristic radii | |||||
std::vector<Double_t> radii_; | |||||
//! Vector of ratio a/R^2 | |||||
std::vector<Double_t> gamAInvRadSq_; | |||||
//! Vector of phase space types | //! Vector of phase space types | ||||
std::vector<Int_t> phaseSpaceTypes_; | std::vector<KMatrixChannels> phaseSpaceTypes_; | ||||
//! Vector of squared masses | //! Vector of squared masses | ||||
std::vector<Double_t> mSumSq_; | std::vector<Double_t> mSumSq_; | ||||
//! Vector of mass differences | //! Vector of mass differences | ||||
std::vector<Double_t> mDiffSq_; | std::vector<Double_t> mDiffSq_; | ||||
//! Vector of 1/(m_pole^2 - s) terms for scattering and production K-matrix formulae | //! Vector of 1/(m_pole^2 - s) terms for scattering and production K-matrix formulae | ||||
std::vector<Double_t> poleDenomVect_; | std::vector<Double_t> poleDenomVect_; | ||||
//! Constant from input file | //! Constant from input file | ||||
LauParameter mSq0_; | LauParameter mSq0_; | ||||
//! Constant from input file | //! Constant from input file | ||||
LauParameter s0Scatt_; | LauParameter s0Scatt_; | ||||
//! Constant from input file | //! Constant from input file | ||||
LauParameter s0Prod_; | LauParameter s0Prod_; | ||||
//! Constant from input file | //! Constant from input file | ||||
LauParameter sA_; | LauParameter sA_; | ||||
//! Constant from input file | //! Constant from input file | ||||
LauParameter sA0_; | LauParameter sA0_; | ||||
//! Defined as 0.5*sA*mPi*mPi | //! Defined as 0.5*sA*mPi*mPi | ||||
Double_t sAConst_; | Double_t sAConst_{0.0}; | ||||
//! Defined as 4*mPi*mPi | //! Defined as 4*mPi*mPi | ||||
Double_t m2piSq_; | const Double_t m2piSq_{4.0*LauConstants::mPiSq}; | ||||
//! Defined as 4*mK*mK | //! Defined as 4*mK*mK | ||||
Double_t m2KSq_; | const Double_t m2KSq_{4.0*LauConstants::mKSq}; | ||||
//! Defined as 4*mEta*mEta | //! Defined as 4*mEta*mEta | ||||
Double_t m2EtaSq_; | const Double_t m2EtaSq_{4.0*LauConstants::mEtaSq}; | ||||
//! Defined as (mEta+mEta')^2 | //! Defined as (mEta+mEta')^2 | ||||
Double_t mEtaEtaPSumSq_; | const Double_t mEtaEtaPSumSq_{(LauConstants::mEta + LauConstants::mEtaPrime)*(LauConstants::mEta + LauConstants::mEtaPrime)}; | ||||
//! Defined as (mEta-mEta')^2 | //! Defined as (mEta-mEta')^2 | ||||
Double_t mEtaEtaPDiffSq_; | const Double_t mEtaEtaPDiffSq_{(LauConstants::mEta - LauConstants::mEtaPrime)*(LauConstants::mEta - LauConstants::mEtaPrime)}; | ||||
//! Defined as (mK+mPi)^2 | //! Defined as (mK+mPi)^2 | ||||
Double_t mKpiSumSq_; | const Double_t mKpiSumSq_{(LauConstants::mK + LauConstants::mPi)*(LauConstants::mK + LauConstants::mPi)}; | ||||
//! Defined as (mK-mPi)^2 | //! Defined as (mK-mPi)^2 | ||||
Double_t mKpiDiffSq_; | const Double_t mKpiDiffSq_{(LauConstants::mK - LauConstants::mPi)*(LauConstants::mK - LauConstants::mPi)}; | ||||
//! Defined as (mK+mEta')^2 | //! Defined as (mK+mEta')^2 | ||||
Double_t mKEtaPSumSq_; | const Double_t mKEtaPSumSq_{(LauConstants::mK + LauConstants::mEtaPrime)*(LauConstants::mK + LauConstants::mEtaPrime)}; | ||||
//! Defined as (mK-mEta')^2 | //! Defined as (mK-mEta')^2 | ||||
Double_t mKEtaPDiffSq_; | const Double_t mKEtaPDiffSq_{(LauConstants::mK - LauConstants::mEtaPrime)*(LauConstants::mK - LauConstants::mEtaPrime)}; | ||||
//! Defined as (mK-3*mPi)^2 | //! Defined as (mK-3*mPi)^2 | ||||
Double_t mK3piDiffSq_; | const Double_t mK3piDiffSq_{(LauConstants::mK - 3.0*LauConstants::mPi)*(LauConstants::mK - 3.0*LauConstants::mPi)}; | ||||
//! Factor used to calculate the Kpipipi phase space term | //! Factor used to calculate the Kpipipi phase space term | ||||
Double_t k3piFactor_; | const Double_t k3piFactor_{TMath::Power((1.44 - mK3piDiffSq_)/1.44, -2.5)}; | ||||
//! Factor used to calculate the pipipipi phase space term | //! Factor used to calculate the pipipipi phase space term | ||||
Double_t fourPiFactor1_; | const Double_t fourPiFactor1_{16.0*LauConstants::mPiSq}; | ||||
//! Factor used to calculate the pipipipi phase space term | //! Factor used to calculate the pipipipi phase space term | ||||
Double_t fourPiFactor2_; | const Double_t fourPiFactor2_{TMath::Sqrt(1.0 - fourPiFactor1_)}; | ||||
//! Defined as (mD0+mK)^2 | |||||
const Double_t mD0KSumSq_{(LauConstants::mD0 + LauConstants::mK)*(LauConstants::mD0 + LauConstants::mK)}; | |||||
//! Defined as (mD0-mK)^2 | |||||
const Double_t mD0KDiffSq_{(LauConstants::mD0 - LauConstants::mK)*(LauConstants::mD0 - LauConstants::mK)}; | |||||
//! Defined as (mD*0+mK)^2 | |||||
const Double_t mDstar0KSumSq_{(LauResonanceMaker::get().getResInfo("D*0")->getMass()->value() + LauConstants::mK)*(LauResonanceMaker::get().getResInfo("D*0")->getMass()->value() + LauConstants::mK)}; | |||||
//! Defined as (mD*0-mK)^2 | |||||
const Double_t mDstar0KDiffSq_{(LauResonanceMaker::get().getResInfo("D*0")->getMass()->value() - LauConstants::mK)*(LauResonanceMaker::get().getResInfo("D*0")->getMass()->value() - LauConstants::mK)}; | |||||
Done Inline ActionsThese can all be made const I think tlatham: These can all be made `const` I think | |||||
//! Multiplicative factor containing various Adler zero constants | //! Multiplicative factor containing various Adler zero constants | ||||
Double_t adlerZeroFactor_; | Double_t adlerZeroFactor_{0.0}; | ||||
//! Tracks if all params have been set | //! Tracks if all params have been set | ||||
Bool_t parametersSet_; | Bool_t parametersSet_{kFALSE}; | ||||
//! Control the output of the functions | //! Control the output of the functions | ||||
Bool_t verbose_; | static constexpr Bool_t verbose_{kFALSE}; | ||||
Done Inline ActionsThis can be static constexpr I think. tlatham: This can be `static constexpr` I think. | |||||
//! Control if scattering constants are channel symmetric: f_ji = f_ij | //! Control if scattering constants are channel symmetric: f_ji = f_ij | ||||
Bool_t scattSymmetry_; | Bool_t scattSymmetry_{kFALSE}; | ||||
ClassDef(LauKMatrixPropagator,0) // K-matrix amplitude model | ClassDef(LauKMatrixPropagator,0) // K-matrix amplitude model | ||||
}; | }; | ||||
#endif | #endif |
We should add another parameter in the constructor to define the spin L value (the last argument). By default L = 0, and for specific channels it could be set appropriately by the code. This integer should probably be another enumeration, something like:
enum KMatrixSpin {SWave, PWave, DWave, MaxSpin};