Differential D41 Diff 175 inc/LauKMatrixPropagator.hh

Changeset 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 "LauComplex.hh"
#include "LauKinematics.hh"		#include "LauKinematics.hh"
#include "LauParameter.hh"		#include "LauParameter.hh"

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

#include <map>		#include <map>
#include <vector>		#include <vector>

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
		\param [in] L this specifies the spin of this K-matrix
*/		*/
LauKMatrixPropagator(const TString& name, const TString& paramFileName,		LauKMatrixPropagator( const TString& name, const TString& paramFileName,
Int_t resPairAmpInt, Int_t nChannels, Int_t nPoles,		Int_t resPairAmpInt, Int_t nChannels, Int_t nPoles,
Int_t rowIndex = 1);		Int_t rowIndex = 1, Int_t L = 0 );
		jbackUnsubmitted Done Inline Actions 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}; jback: We should add another parameter in the constructor to define the spin L value (the last…
		jbackUnsubmitted Done Inline Actions Instead 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		//! Calculate the invariant mass squared s
/*!		/*!
\param [in] kinematics the kinematics of the current event		\param [in] kinematics the kinematics of the current event
*/		*/
void updatePropagator(const LauKinematics* kinematics);		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(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(Int_t channelIndex) const;

Show All 14 Lines	public:
//! 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(Int_t poleIndex, Int_t channelIndex) const;

		//! Get coupling parameters, set according to the input file
		/*!
		\param [in] poleIndex number of the required pole
		\param [in] channelIndex number of the required channel
		\return the parameter of the coupling constant
		*/
		LauParameter& getCouplingParameter(Int_t poleIndex, 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(Int_t channel1Index, Int_t channel2Index) const;

		//! Get scattering parameters, set according to the input file
		/*!
		\param [in] channel1Index number of the first channel index
		\param [in] channel2Index number of the second channel index
		\return the parameter of the scattering constant
		*/
		LauParameter& getScatteringParameter(Int_t channel1Index, Int_t channel2Index);

		//! Get s0 production parameter
		/*!
		\return the s0Prod parameter
		*/
		LauParameter& gets0Prod() {return s0Prod_;}

//! 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(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
/*!		/*!
/return the number of channels		\return the number of channels
*/		*/
Int_t getNChannels() const {return nChannels_;}		Int_t getNChannels() const {return nChannels_;}

//! Get the number of poles		//! Get the number of poles
/*!		/*!
/return the number of poles		\return the number of poles
*/		*/
Int_t getNPoles() const {return nPoles_;}		Int_t getNPoles() const {return nPoles_;}

//! Get the propagator name		//! Get the propagator name
/*!		/*!
/return the name of the propagator		\return the name of the propagator
*/		*/
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(Double_t s, 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(Double_t s, 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(Double_t s, Int_t channel);


protected:		protected:
//! 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(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(Double_t s);

		//! Calculate the (real) gamma angular-momentum barrier matrix
		/*!
		\param [in] s the invariant mass squared
		*/
		void calcGammaMatrix(Double_t s);

		//! Calculate the Xspin matrix
		void calcXspinMatrix();

		//! 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(Int_t iCh, Double_t s, Int_t phaseSpaceIndex) const;
		jbackUnsubmitted Not Done Inline Actions Please 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.

//! 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
/*!		/*!
\param [in] s the invariant mass squared		\param [in] s the invariant mass squared
*/		*/
void calcPoleDenomVect(Double_t s);		void calcPoleDenomVect(Double_t s);

		//! Calculate the D0K+ phase space factor
		/*!
		\param [in] s the invariant mass squared
		\return the complex phase space factor
		*/
		LauComplex calcD0KRho(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(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(Double_t s) const;

//! Calculate the KK phase space factor		//! Calculate the KK phase space factor
▲ Show 20 Lines • Show All 74 Lines • ▼ Show 20 Lines	protected:
//! 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(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(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);

//! Copy assignment operator (not implemented)		//! Copy assignment operator (not implemented)
LauKMatrixPropagator& operator=(const LauKMatrixPropagator& rhs);		LauKMatrixPropagator& operator=(const LauKMatrixPropagator& rhs);

//! Create a map for the K-matrix parameters		//! Create a map for the K-matrix parameters
typedef std::map<int, std::vector<LauParameter> > KMatrixParamMap;		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 barrier-factor parameter from a line in the parameter file
		/*!
		\param [in] theLine Vector of strings corresponding to the line from the parameter file
		*/
		void storeBarrierFactorParameter(const std::vector<std::string>& theLine);


//! 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_;
//! "slowly-varying part" for the scattering K-matrix		//! "slowly-varying part" for the scattering K-matrix
Double_t scattSVP_;		Double_t scattSVP_;
//! "slowly-varying part" for the production K-matrix		//! "slowly-varying part" for the production K-matrix
Double_t prodSVP_;		Double_t prodSVP_;
//! 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.		// Integers to specify the allowed channels for the phase space calculations.
// Please keep Zero at the start and leave TotChannels at the end		// Please keep Zero at the start and leave TotChannels at the end
// whenever more channels are added to this.		// whenever more channels are added to this.
//! Integers to specify the allowed channels for the phase space calculations		//! Integers to specify the allowed channels for the phase space calculations
enum KMatrixChannels {Zero, PiPi, KK, FourPi, EtaEta, EtaEtaP,		enum KMatrixChannels {Zero, PiPi, KK, FourPi, EtaEta, EtaEtaP,
KPi, KEtaP, KThreePi, TotChannels};		KPi, KEtaP, KThreePi, D0K, Dstar0K, TotChannels};
		jbackUnsubmitted Done Inline Actions I 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…

//! Scattering K-matrix		//! Scattering K-matrix
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_;
		//! Xspin matrix
		TMatrixD XspinMatrix_;
//! 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_;
		//! Spin of K-matrix
		Int_t L_;
		//! Denominator parameter in centrifugal barrier factor
		Int_t a_;
		//! Boolean to dictate whether to include Blatt-Weisskopf-like denominator in K-matrix centrifugal barrier factor
		Bool_t includeBWBarrierFactor_ = kTRUE;
		tlathamUnsubmitted Done Inline Actions Use 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<Int_t> 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.5sAmPi*mPi		//! Defined as 0.5sAmPi*mPi
Double_t sAConst_;		Double_t sAConst_;
//! Defined as 4mPimPi		//! Defined as 4mPimPi
Double_t m2piSq_;		Double_t m2piSq_;
//! Defined as 4mKmK		//! Defined as 4mKmK
Double_t m2KSq_;		Double_t m2KSq_;
//! Defined as 4mEtamEta		//! Defined as 4mEtamEta
Double_t m2EtaSq_;		Double_t m2EtaSq_;
//! Defined as (mEta+mEta')^2		//! Defined as (mEta+mEta')^2
Double_t mEtaEtaPSumSq_;		Double_t mEtaEtaPSumSq_;
//! Defined as (mEta-mEta')^2		//! Defined as (mEta-mEta')^2
Double_t mEtaEtaPDiffSq_;		Double_t mEtaEtaPDiffSq_;
//! Defined as (mK+mPi)^2		//! Defined as (mK+mPi)^2
Double_t mKpiSumSq_;		Double_t mKpiSumSq_;
//! Defined as (mK-mPi)^2		//! Defined as (mK-mPi)^2
Double_t mKpiDiffSq_;		Double_t mKpiDiffSq_;
//! Defined as (mK+mEta')^2		//! Defined as (mK+mEta')^2
Double_t mKEtaPSumSq_;		Double_t mKEtaPSumSq_;
//! Defined as (mK-mEta')^2		//! Defined as (mK-mEta')^2
Double_t mKEtaPDiffSq_;		Double_t mKEtaPDiffSq_;
//! Defined as (mK-3*mPi)^2		//! Defined as (mK-3*mPi)^2
Double_t mK3piDiffSq_;		Double_t mK3piDiffSq_;
//! Factor used to calculate the Kpipipi phase space term		//! Factor used to calculate the Kpipipi phase space term
Double_t k3piFactor_;		Double_t k3piFactor_;
//! Factor used to calculate the pipipipi phase space term		//! Factor used to calculate the pipipipi phase space term
Double_t fourPiFactor1_;		Double_t fourPiFactor1_;
//! Factor used to calculate the pipipipi phase space term		//! Factor used to calculate the pipipipi phase space term
Double_t fourPiFactor2_;		Double_t fourPiFactor2_;
		//! Defined as (mD0+mK)^2
		Double_t mD0KSumSq_;
		//! Defined as (mD0-mK)^2
		Double_t mD0KDiffSq_;
		//! Defined as (mD*0+mK)^2
		Double_t mDstar0KSumSq_;
		//! Defined as (mD*0-mK)^2
		Double_t mDstar0KDiffSq_;

		tlathamUnsubmitted Done Inline Actions These 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_;
//! Tracks if all params have been set		//! Tracks if all params have been set
Bool_t parametersSet_;		Bool_t parametersSet_;

		//! Helicity angle cosine
		Double_t cosHel_;

//! Control the output of the functions		//! Control the output of the functions
Bool_t verbose_;		Bool_t verbose_;
		tlathamUnsubmitted Done Inline Actions This 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_;

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

#endif		#endif