Differential D41 Diff 145 inc/LauKMatrixPropagator.hh

Changeset View

Standalone View

inc/LauKMatrixPropagator.hh

Show First 20 Lines • Show All 43 Lines • ▼ Show 20 Lines
#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
*/		*/
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 );
		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);

//! 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 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
*/		*/

		//! 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_;}

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 and imaginary part of the 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
		*/
		Double_t calcD0KPwaveGamma(Double_t s) 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 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_Pwave, Dstar0K_Swave, 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_;

//! 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_;
		tlathamUnsubmitted Done Inline Actions Use uniform initialisation here for consistency. tlatham: Use uniform initialisation here for consistency.
//! Array of scattering SVP values		//! Array of scattering SVP values
LauParArray fScattering_;		LauParArray fScattering_;

//! 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