Differential D41 Diff 204 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 "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 );
				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
	/*!
	\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) noexcept;

	//! 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) noexcept;

				//! Set flag to ignore Blatt-Weisskopf-like barrier factor
				void ignoreBWBarrierFactor() noexcept {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 noexcept {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 noexcept {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 noexcept {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 noexcept;

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

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

	//! 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 noexcept {return L_[iChannel];}

				//! Get index of final channel
				/*!
				\return the index of the channel into which the scattering happens
				*/
				Int_t getIndex() const noexcept {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) noexcept;

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

	//! 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) noexcept;

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

	//! 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) noexcept;

	//! 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() noexcept {return s0Prod_;}

	//! Get sA production parameter			//! Get sA production parameter
	/*!			/*!
	\return the sA parameter			\return the sA parameter
	*/			*/
	LauParameter& getsA() {return sA_;}			LauParameter& getsA() noexcept {return sA_;}

	//! Get sA0 production parameter			//! Get sA0 production parameter
	/*!			/*!
	\return the sA0 parameter			\return the sA0 parameter
	*/			*/
	LauParameter& getsA0() {return sA0_;}			LauParameter& getsA0() noexcept {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 noexcept {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 noexcept;

	//! 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 noexcept {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 noexcept {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 noexcept {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 noexcept {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) noexcept;

	//! 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) noexcept;

	//! 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 noexcept {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) noexcept;

	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) noexcept;

	//! 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) noexcept;

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

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

	//! 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
	/*!			/*!
				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.
	\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) noexcept;

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

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

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

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

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

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

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

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

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

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

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

	//! 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) noexcept;

	//! 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) noexcept;

	//! 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) noexcept;

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


	//! 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) noexcept;

	//! 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) noexcept;

	//! Get the square root of the phase space matrix			//! Get the square root of the phase space matrix
	void getSqrtRhoMatrix();			void getSqrtRhoMatrix() noexcept;

	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() noexcept;

	//! 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) noexcept;

	//! 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) noexcept;

	//! 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) noexcept;

				//! 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) noexcept;

				//! 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
				*/
				void storeOrbitalAngularMomenta(const std::vector<std::string>& theLine) noexcept;

				//! 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) noexcept;


	//! 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) noexcept;


	//! 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
				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…
	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_;
				//! Vector of denominator parameters in centrifugal barrier factor
				std::vector<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<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.5sAmPi*mPi			//! Defined as 0.5sAmPi*mPi
	Double_t sAConst_;			Double_t sAConst_{0.0};
	//! Defined as 4mPimPi			//! Defined as 4mPimPi
	Double_t m2piSq_;			Double_t m2piSq_{4.0*LauConstants::mPiSq};
	//! Defined as 4mKmK			//! Defined as 4mKmK
	Double_t m2KSq_;			Double_t m2KSq_{4.0*LauConstants::mKSq};
	//! Defined as 4mEtamEta			//! Defined as 4mEtamEta
	Double_t m2EtaSq_;			Double_t m2EtaSq_{4.0*LauConstants::mEtaSq};
	//! Defined as (mEta+mEta')^2			//! Defined as (mEta+mEta')^2
	Double_t mEtaEtaPSumSq_;			Double_t mEtaEtaPSumSq_{(LauConstants::mEta + LauConstants::mEtaPrime)*(LauConstants::mEta + LauConstants::mEtaPrime)};
	//! Defined as (mEta-mEta')^2			//! Defined as (mEta-mEta')^2
	Double_t mEtaEtaPDiffSq_;			Double_t mEtaEtaPDiffSq_{(LauConstants::mEta - LauConstants::mEtaPrime)*(LauConstants::mEta - LauConstants::mEtaPrime)};
	//! Defined as (mK+mPi)^2			//! Defined as (mK+mPi)^2
	Double_t mKpiSumSq_;			Double_t mKpiSumSq_{(LauConstants::mK + LauConstants::mPi)*(LauConstants::mK + LauConstants::mPi)};
	//! Defined as (mK-mPi)^2			//! Defined as (mK-mPi)^2
	Double_t mKpiDiffSq_;			Double_t mKpiDiffSq_{(LauConstants::mK - LauConstants::mPi)*(LauConstants::mK - LauConstants::mPi)};
	//! Defined as (mK+mEta')^2			//! Defined as (mK+mEta')^2
	Double_t mKEtaPSumSq_;			Double_t mKEtaPSumSq_{(LauConstants::mK + LauConstants::mEtaPrime)*(LauConstants::mK + LauConstants::mEtaPrime)};
	//! Defined as (mK-mEta')^2			//! Defined as (mK-mEta')^2
	Double_t mKEtaPDiffSq_;			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_;			Double_t mK3piDiffSq_{(LauConstants::mK - 3.0LauConstants::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_;			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_;			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_;			Double_t fourPiFactor2_{TMath::Sqrt(1.0 - fourPiFactor1_)};
				//! Defined as (mD0+mK)^2
				Double_t mD0KSumSq_{(LauConstants::mD0 + LauConstants::mK)*(LauConstants::mD0 + LauConstants::mK)};
				//! Defined as (mD0-mK)^2
				Double_t mD0KDiffSq_{(LauConstants::mD0 - LauConstants::mK)*(LauConstants::mD0 - LauConstants::mK)};
				//! Defined as (mD*0+mK)^2
				Double_t mDstar0KSumSq_{(LauResonanceMaker::get().getResInfo("D0")->getMass()->value() + LauConstants::mK)(LauResonanceMaker::get().getResInfo("D*0")->getMass()->value() + LauConstants::mK)};
				//! Defined as (mD*0-mK)^2
				Double_t mDstar0KDiffSq_{(LauResonanceMaker::get().getResInfo("D0")->getMass()->value() - LauConstants::mK)(LauResonanceMaker::get().getResInfo("D*0")->getMass()->value() - LauConstants::mK)};

				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_{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_;			Bool_t verbose_{kFALSE};
				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_{kFALSE};

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

	#endif			#endif