diff --git a/inc/LauAbsResonance.hh b/inc/LauAbsResonance.hh index a6598bb..8ba5339 100644 --- a/inc/LauAbsResonance.hh +++ b/inc/LauAbsResonance.hh @@ -1,576 +1,578 @@ /* Copyright 2004 University of Warwick Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. */ /* Laura++ package authors: John Back Paul Harrison Thomas Latham */ /*! \file LauAbsResonance.hh \brief File containing declaration of LauAbsResonance class. */ /*! \class LauAbsResonance \brief Abstract class for defining type for resonance amplitude models (Breit-Wigner, Flatte etc.) Abstract Class for defining the type for all classes used to model resonances in the Dalitz plot, such as Breit-Wigner functions. In addition, some common functionality is implemented, including data such as the mass and width of the desired state. */ #ifndef LAU_ABS_RESONANCE #define LAU_ABS_RESONANCE #include "TString.h" #include "LauBlattWeisskopfFactor.hh" #include "LauComplex.hh" #include "LauParameter.hh" class LauDaughters; class LauKinematics; class LauResonanceInfo; class LauAbsResonance { public: //! Define the allowed resonance types enum LauResonanceModel { BW, /*!< simple Breit-Wigner */ RelBW, /*!< relativistic Breit-Wigner */ GS, /*!< a modified Breit-Wigner from Gounaris-Sakurai */ Flatte, /*!< Flatte or coupled-channel Breit-Wigner */ Sigma, /*!< special shape for the sigma or f_0(600) */ Kappa, /*!< special shape for the kappa, a low-mass Kpi scalar */ Dabba, /*!< special shape for the dabba, a low-mass Dpi scalar */ LASS, /*!< the LASS amplitude to describe the Kpi S-wave */ LASS_BW, /*!< the resonant part of the LASS amplitude */ LASS_NR, /*!< the nonresonant part of the LASS amplitude */ EFKLLM, /*!< a form-factor-based description of the Kpi S-wave */ KMatrix, /*!< S-wave description using K-matrix and P-vector */ FlatNR, /*!< a uniform nonresonant amplitude */ NRModel, /*!< a theoretical model nonresonant amplitude */ BelleNR, /*!< an empirical exponential nonresonant amplitude */ PowerLawNR, /*!< an empirical power law nonresonant amplitude */ BelleSymNR, /*!< an empirical exponential nonresonant amplitude for symmetrised DPs */ BelleSymNRNoInter, /*!< an empirical exponential nonresonant amplitude for symmetrised DPs without interference */ TaylorNR, /*!< an empirical Taylor expansion nonresonant amplitude for symmetrised DPs */ PolNR, /*!< an empirical polynomial nonresonant amplitude */ POLE, /*!< scalar Pole lineshape */ PolarFFNR, /*!< Polar Form Factor nonresonant amplitude */ PolarFFSymNR, /*!< Polar Form Factor nonresonant amplitude for symmetrised DPs without interference */ PolarFFSymNRNoInter, /*!< Polar Form Factor nonresonant amplitude */ - KKPiPiScatt, /*!< KK-PiPi inelastic scattering amplitude */ + Rescattering, /*!< KK-PiPi inelastic scattering amplitude */ + Rescattering2, /*!< KK-PiPi inelastic scattering amplitude */ + RescatteringNoInter, /*!< KK-PiPi inelastic scattering amplitude */ MIPW_MagPhase, /*!< a model independent partial wave - magnitude and phase representation */ MIPW_RealImag, /*!< a model independent partial wave - real and imaginary part representation */ GaussIncoh, /*!< an incoherent Gaussian shape */ RhoOmegaMix_GS, /*!< mass mixing model using GS for res 1 and RBW for res 2 */ RhoOmegaMix_RBW, /*!< mass mixing model using two RBWs */ RhoOmegaMix_GS_1, /*!< mass mixing model using GS for res 1 and RBW for res 2, with denominator factor = 1 */ RhoOmegaMix_RBW_1 /*!< mass mixing model using two RBWs, with denominator factor = 1 */ }; //! Define the allowed spin formalisms enum LauSpinType { Zemach_P, /*!< Zemach tensor formalism, bachelor momentum in resonance rest frame */ Zemach_Pstar, /*!< Zemach tensor formalism, bachelor momentum in parent rest frame */ Covariant, /*!< Covariant tensor formalism */ Legendre /*!< Legendre polynomials only */ }; //! Is the resonance model incoherent? /*! \param [in] model the resonance model \return true if the model is incoherent */ static bool isIncoherentModel(LauResonanceModel model); //! Constructor (for use by standard resonances) /*! \param [in] resInfo the object containing information on the resonance name, mass, width, spin, charge, etc. \param [in] resPairAmpInt the number of the daughter not produced by the resonance \param [in] daughters the daughter particles */ LauAbsResonance(LauResonanceInfo* resInfo, const Int_t resPairAmpInt, const LauDaughters* daughters); //! Constructor (for use by K-matrix components) /*! \param [in] resName the name of the component \param [in] resPairAmpInt the number of the daughter not produced by the resonance \param [in] daughters the daughter particles */ LauAbsResonance(const TString& resName, const Int_t resPairAmpInt, const LauDaughters* daughters); //! Destructor virtual ~LauAbsResonance(); //! Initialise the model virtual void initialise() = 0; //! Calculate the complex amplitude /*! \param [in] kinematics the kinematic variables of the current event \return the complex amplitude */ virtual LauComplex amplitude(const LauKinematics* kinematics); //! Get the resonance model type /*! \return the resonance model type */ virtual LauResonanceModel getResonanceModel() const = 0; //! Get the spin type /*! \return the spin formalism */ LauSpinType getSpinType() const {return spinType_;} //! Get the name of the resonance /*! \return the resonance name */ const TString& getResonanceName() const {return resName_;} //! Get the name of the resonance /*! \return the resonance name */ const TString& getSanitisedName() const {return sanitisedName_;} //! Get the integer to identify which DP axis the resonance belongs to /*! \return the DP axis identification number, the ID of the bachelor */ Int_t getPairInt() const {return resPairAmpInt_;} //! Get the spin of the resonance /*! \return the resonance spin */ Int_t getSpin() const {return resSpin_;} //! Get the charge of the resonance /*! \return the resonance charge */ Int_t getCharge() const {return resCharge_;} //! Get the mass of the resonance /*! \return the resonance mass */ Double_t getMass() const {return (resMass_!=0) ? resMass_->unblindValue() : -1.0;} //! Get the width of the resonance /*! \return the resonance width */ Double_t getWidth() const {return (resWidth_!=0) ? resWidth_->unblindValue() : -1.0;} //! Get the mass parameter of the resonance /*! \return the resonance mass parameter */ LauParameter* getMassPar() {return resMass_;} //! Get the width parameter of the resonance /*! \return the resonance width parameter */ LauParameter* getWidthPar() {return resWidth_;} //! Retrieve the resonance parameters, e.g. so that they can be loaded into a fit /*! \return floating parameters of the resonance */ virtual const std::vector& getFloatingParameters() { return this->getParameters(); }; //! Is the amplitude pre-symmetrised? /*! The default value is kFALSE, so pre-symmetrised lineshapes should override this. \return whether the amplitude is already symmetrised */ virtual Bool_t preSymmetrised() const {return kFALSE;} //! Get the helicity flip flag /*! \return the flip helicity flag */ Bool_t flipHelicity() const {return flipHelicity_;} //! Set the helicity flip flag /*! \param [in] boolean the helicity flip status */ void flipHelicity(const Bool_t boolean) {flipHelicity_ = boolean;} //! Get the ignore momenta flag /*! Whether to ignore the momentum factors in both the spin factor and the mass-dependent width \return the ignore momenta flag */ Bool_t ignoreMomenta() const {return ignoreMomenta_;} //! Set the ignore momenta flag /*! Whether to ignore the momentum factors in both the spin factor and the mass-dependent width \param [in] boolean the ignore momenta status */ void ignoreMomenta(const Bool_t boolean) {ignoreMomenta_ = boolean;} //! Get the ignore spin flag /*! Whether to set the spinTerm to unity always \return the ignore spin flag */ Bool_t ignoreSpin() const {return ignoreSpin_;} //! Set the ignore spin flag /*! Whether to set the spinTerm to unity always \param [in] boolean the ignore spin status */ void ignoreSpin(const Bool_t boolean) {ignoreSpin_ = boolean;} //! Get the ignore barrier factor scaling flag /*! Whether to ignore barrier factor scaling in the amplitude numerator, they are still used for the mass-dependent width \return the ignore barrier amplitude scaling flag */ Bool_t ignoreBarrierScaling() const {return ignoreBarrierScaling_;} //! Set the ignore barrier factor scaling flag /*! Whether to ignore barrier factor scaling in the amplitude numerator, they are still used for the mass-dependent width \param [in] boolean the ignore barrier factor scaling status */ void ignoreBarrierScaling(const Bool_t boolean) {ignoreBarrierScaling_ = boolean;} //! Allow the mass, width and spin of the resonance to be changed /*! Negative values wil be ignored, so if, for example, you want to only change the spin you can provide negative values for the mass and width \param [in] newMass new value of the resonance mass \param [in] newWidth new value of the resonance width \param [in] newSpin new value of the resonance spin */ void changeResonance(const Double_t newMass, const Double_t newWidth, const Int_t newSpin); //! Allow the Blatt-Weisskopf radius for the resonance and parent factors to be changed /*! Negative values wil be ignored, so if, for example, you want to only change the parent radius you can provide a negative value for the resonance radius \param [in] resRadius new value of the resonance radius \param [in] parRadius new value of the parent radius */ void changeBWBarrierRadii(const Double_t resRadius, const Double_t parRadius); //! Set value of the various parameters /*! \param [in] name the name of the parameter to be changed \param [in] value the new parameter value */ virtual void setResonanceParameter(const TString& name, const Double_t value); //! Allow the various parameters to float in the fit /*! \param [in] name the name of the parameter to be floated */ virtual void floatResonanceParameter(const TString& name); //! Access the given resonance parameter /*! \param [in] name the name of the parameter \return the corresponding parameter */ virtual LauParameter* getResonanceParameter(const TString& name); //! Fix or release the resonance mass /*! \param [in] parFixed new status of mass */ void fixMass(const Bool_t parFixed) { if (resMass_!=0) { resMass_->fixed(parFixed); } } //! Fix or release the resonance width /*! \param [in] parFixed new status of width */ void fixWidth(const Bool_t parFixed) { if (resWidth_!=0) { resWidth_->fixed(parFixed); } } //! Get the status of resonance mass (fixed or released) /*! \return the status of resonance mass (fixed or released) */ Bool_t fixMass() const { return (resMass_!=0) ? resMass_->fixed() : kTRUE; } //! Get the status of resonance width (fixed or released) /*! \return the status of resonance width (fixed or released) */ Bool_t fixWidth() const { return (resWidth_!=0) ? resWidth_->fixed() : kTRUE; } //! Set the spin formalism to be used /*! \param [in] spinType the spin formalism */ void setSpinType(const LauSpinType spinType) {spinType_ = spinType;} //! Set the form factor model and parameters /*! \param [in] resFactor the barrier factor for the resonance decay \param [in] parFactor the barrier factor for the parent decay */ void setBarrierRadii(LauBlattWeisskopfFactor* resFactor, LauBlattWeisskopfFactor* parFactor) { resBWFactor_ = resFactor; parBWFactor_ = parFactor; } //! Fix or release the Blatt-Weisskopf barrier radii void fixBarrierRadii(const Bool_t fixResRadius, const Bool_t fixParRadius); //! Get the status of resonance barrier radius (fixed or released) Bool_t fixResRadius() const; //! Get the status of parent barrier radius (fixed or released) Bool_t fixParRadius() const; //! Get the radius of the resonance barrier factor Double_t getResRadius() const; //! Get the radius of the parent barrier factor Double_t getParRadius() const; protected: //! Get the name of the parent particle TString getNameParent() const; //! Get the name of the first daughter of the resonance TString getNameDaug1() const; //! Get the name of the second daughter of the resonance TString getNameDaug2() const; //! Get the name of the daughter that does not originate form the resonance TString getNameBachelor() const; //! Get the parent particle mass Double_t getMassParent() const; //! Get the mass of daughter 1 Double_t getMassDaug1() const; //! Get the mass of daughter 2 Double_t getMassDaug2() const; //! Get the mass of the bachelor daughter Double_t getMassBachelor() const; //! Get the Charge of the parent particle Int_t getChargeParent() const; //! Get the charge of daughter 1 Int_t getChargeDaug1() const; //! Get the charge of daughter 2 Int_t getChargeDaug2() const; //! Get the charge of the bachelor daughter Int_t getChargeBachelor() const; //! Get the current value of the daughter momentum in the resonance rest frame Double_t getQ() const {return q_;} //! Get the current value of the bachelor momentum in the resonance rest frame Double_t getP() const {return p_;} //! Get the current value of the bachelor momentum in the parent rest frame Double_t getPstar() const {return pstar_;} //! Get the current value of the full spin-dependent covariant factor Double_t getCovFactor() const {return covFactor_;} //! Get the centrifugal barrier for the parent decay LauBlattWeisskopfFactor* getParBWFactor() {return parBWFactor_;} const LauBlattWeisskopfFactor* getParBWFactor() const {return parBWFactor_;} //! Get the centrifugal barrier for the resonance decay LauBlattWeisskopfFactor* getResBWFactor() {return resBWFactor_;} const LauBlattWeisskopfFactor* getResBWFactor() const {return resBWFactor_;} //! Access the resonance info object LauResonanceInfo* getResInfo() const {return resInfo_;} //! Access the daughters object const LauDaughters* getDaughters() const {return daughters_;} //! Calculate the amplitude spin term using the Zemach tensor formalism /*! \param [in] pProd the momentum factor (either q * p or q * pstar) */ Double_t calcZemachSpinFactor( const Double_t pProd ) const; //! Calculate the amplitude spin term using the covariant tensor formalism /*! \param [in] pProd the momentum factor (q * pstar) */ Double_t calcCovSpinFactor( const Double_t pProd ); //! Calculate the spin-dependent covariant factor /*! \param [in] erm E_ij in the parent rest-frame divided by m_ij (equivalent to sqrt(1 + p^2/mParent^2)) */ void calcCovFactor( const Double_t erm ); //! Calculate the Legendre polynomial for the spin factor /*! Uses the current-event value of cosHel_ */ Double_t calcLegendrePoly() const; //! Calculate the Legendre polynomial for the spin factor (specifying the cosHel value) /*! \param [in] cosHel the cosine of the helicity angle */ Double_t calcLegendrePoly( const Double_t cosHel ); //! Complex resonant amplitude /*! \param [in] mass appropriate invariant mass for the resonance \param [in] spinTerm spin term */ virtual LauComplex resAmp(Double_t mass, Double_t spinTerm) = 0; //! Clear list of floating parameters void clearFloatingParameters() { resParameters_.clear(); } //! Add parameter to the list of floating parameters /*! \param [in] param the parameter to be added to the list */ void addFloatingParameter( LauParameter* param ); //! Access the list of floating parameters std::vector& getParameters() { return resParameters_; } private: //! Copy constructor (not implemented) LauAbsResonance(const LauAbsResonance& rhs); //! Copy assignment operator (not implemented) LauAbsResonance& operator=(const LauAbsResonance& rhs); //! Information on the resonance LauResonanceInfo* resInfo_; //! Information on the particles const LauDaughters* daughters_; //! Parent name TString nameParent_; //! Daughter 1 name TString nameDaug1_; //! Daughter 2 name TString nameDaug2_; //! Bachelor name TString nameBachelor_; //! Parent charge Int_t chargeParent_; //! Daughter 1 charge Int_t chargeDaug1_; //! Daughter 2 charge Int_t chargeDaug2_; //! Bachelor charge Int_t chargeBachelor_; //! Parent mass Double_t massParent_; //! Daughter 1 mass Double_t massDaug1_; //! Daughter 2 mass Double_t massDaug2_; // Bachelor mass Double_t massBachelor_; //! Resonance name TString resName_; //! Resonance name with illegal characters removed TString sanitisedName_; //! Resonance mass LauParameter* resMass_; //! Resonance width LauParameter* resWidth_; //! All parameters of the resonance std::vector resParameters_; //! Resonance spin Int_t resSpin_; //! Resonance charge Int_t resCharge_; //! DP axis identifier Int_t resPairAmpInt_; //! Blatt Weisskopf barrier for parent decay LauBlattWeisskopfFactor* parBWFactor_; //! Blatt Weisskopf barrier for resonance decay LauBlattWeisskopfFactor* resBWFactor_; //! Spin formalism LauSpinType spinType_; //! Boolean to flip helicity Bool_t flipHelicity_; //! Boolean to ignore the momentum factors in both the spin factor and the mass-dependent width Bool_t ignoreMomenta_; //! Boolean to set the spinTerm to unity always Bool_t ignoreSpin_; //! Boolean to ignore barrier factor scaling in the amplitude numerator, they are still used for the mass-dependent width Bool_t ignoreBarrierScaling_; // Event kinematics information //! Invariant mass Double_t mass_; //! Helicity angle cosine Double_t cosHel_; //! Daughter momentum in resonance rest frame Double_t q_; //! Bachelor momentum in resonance rest frame Double_t p_; //! Bachelor momentum in parent rest frame Double_t pstar_; //! Covariant factor /*! sqrt(1 + z*z), where z = p / mParent Can also be expressed as E_ij in the parent rest-frame divided by m_ij - indeed this is how LauKinematics calculates it. \see LauKinematics::getcov12 \see LauKinematics::getcov13 \see LauKinematics::getcov23 */ Double_t erm_; //! Covariant factor (full spin-dependent expression) Double_t covFactor_; ClassDef(LauAbsResonance,0) // Abstract resonance class }; #endif diff --git a/inc/LauPolarFormFactorNR.hh b/inc/LauPolarFormFactorNR.hh index e274c93..e2f96bc 100644 --- a/inc/LauPolarFormFactorNR.hh +++ b/inc/LauPolarFormFactorNR.hh @@ -1,134 +1,134 @@ // Copyright University of Warwick 2004 - 2014. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // Authors: // Thomas Latham // John Back // Paul Harrison /*! \file LauPolarFormFactorNR.hh \brief File containing declaration of LauPolarFormFactorNR class. */ /*! \class LauPolarFormFactorNR \brief Class for defining the Reescatering model. Defines the reescatering model from: Pelaez et Yndúrain: arXiv:hep-ph/0411334v2 Mar 2005 Nogueira, Bediaga, Cavalcante, Frederico, Lorenco: JHEP ??? */ #ifndef LAU_POLAR_FORM_FACTOR_NR #define LAU_POLAR_FORM_FACTOR_NR #include "TString.h" #include "LauComplex.hh" #include "LauAbsResonance.hh" class LauKinematics; class LauParameter; class LauPolarFormFactorNR : public LauAbsResonance { public: //! Constructor /*! \param [in] resInfo the object containing information on the resonance name, mass, width, spin, charge, etc. \param [in] resType the model of the resonance \param [in] resPairAmpInt the number of the daughter not produced by the resonance \param [in] daughters the daughter particles */ LauPolarFormFactorNR(LauResonanceInfo* resInfo, const LauAbsResonance::LauResonanceModel resType, const Int_t resPairAmpInt, const LauDaughters* daughters); //! Destructor virtual ~LauPolarFormFactorNR(); //! Initialise the model virtual void initialise(); //! Get the complex dynamical amplitude /*! \param [in] kinematics the kinematic variables of the current event \return the complex amplitude */ - virtual LauComplex amplitude(const LauKinematics* kinematics); + //virtual LauComplex amplitude(const LauKinematics* kinematics); //! Get the resonance model type /*! \return the resonance model type */ virtual LauAbsResonance::LauResonanceModel getResonanceModel() const {return model_;} //! Set value of the various parameters /*! \param [in] name the name of the parameter to be changed \param [in] value the new parameter value */ virtual void setResonanceParameter(const TString& name, const Double_t value); //! Allow the various parameters to float in the fit /*! \param [in] name the name of the parameter to be floated */ virtual void floatResonanceParameter(const TString& name); //! Access the given resonance parameter /*! \param [in] name the name of the parameter \return the corresponding parameter */ virtual LauParameter* getResonanceParameter(const TString& name); //! Retrieve the resonance parameters, e.g. so that they can be loaded into a fit /*! \return floating parameters of the resonance */ virtual const std::vector& getFloatingParameters(); protected: //! Set the parameter lambda, the NR term for the /*! \param [in] lambda, the NR term for the */ void setLambda(const Double_t lambda); //! Get the lambda, the NR term for the /*! \return the lambda, the NR term for the */ Double_t getLambda() const {return (lambda_!=0) ? lambda_->value() : 0.0;} //! See if the lambda parameter is fixed or floating /*! \return kTRUE if the lambda parameter is fixed, kFALSE otherwise */ Bool_t fixLambda() const {return (lambda_!=0) ? lambda_->fixed() : kTRUE;} //! Complex resonant amplitude /*! \param [in] mass appropriate invariant mass for the resonance \param [in] spinTerm Zemach spin term */ virtual LauComplex resAmp(Double_t mass, Double_t spinTerm); private: //! Copy constructor (not implemented) LauPolarFormFactorNR(const LauPolarFormFactorNR& rhs); //! Copy assignment operator (not implemented) LauPolarFormFactorNR& operator=(const LauPolarFormFactorNR& rhs); LauParameter* lambda_; //! The model to use LauAbsResonance::LauResonanceModel model_; ClassDef(LauPolarFormFactorNR,0) }; #endif diff --git a/inc/LauRescattering2Res.hh b/inc/LauRescattering2Res.hh new file mode 100644 index 0000000..5073bc5 --- /dev/null +++ b/inc/LauRescattering2Res.hh @@ -0,0 +1,174 @@ + +// Copyright University of Warwick 2004 - 2014. +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +// Authors: +// Thomas Latham +// John Back +// Paul Harrison + +/*! \file LauRescattering2Res.hh + \brief File containing declaration of LauRescattering2Res class. +*/ + +/*! \class LauRescattering2Res + \brief Class for defining the NR amplitude model. + + Class for defining pipi SWave poposed by J.Schechter as used by Cleo (PRD76,01200(2007) + to replace the sigma and f0(980) contributions. +*/ + +#ifndef LAU_RESCATERING2_RES +#define LAU_RESCATERING2_RES + +#include "TString.h" + +#include "LauAbsResonance.hh" +#include "LauComplex.hh" + +class LauKinematics; + + +class LauRescattering2Res : public LauAbsResonance { + + public: + //! Constructor + /*! + \param [in] resInfo the object containing information on the resonance name, mass, width, spin, charge, etc. + \param [in] resPairAmpInt the number of the daughter not produced by the resonance + \param [in] daughters the daughter particles + */ + LauRescattering2Res(LauResonanceInfo* resInfo, const Int_t resPairAmpInt, const LauDaughters* daughters); + + //! Destructor + virtual ~LauRescattering2Res(); + + //! Initialise the model + virtual void initialise(); + + + //! Get the resonance model type + /*! + \return the resonance model type + */ + virtual LauAbsResonance::LauResonanceModel getResonanceModel() const {return LauAbsResonance::Rescattering2;} + + //! Set value of a resonance parameter + /*! + \param [in] name the name of the parameter to be changed + \param [in] value the new parameter value + */ + virtual void setResonanceParameter(const TString& name, const Double_t value); + + //! Allow the various parameters to float in the fit + /*! + \param [in] name the name of the parameter to be floated + */ + virtual void floatResonanceParameter(const TString& name); + + //! Access the given resonance parameter + /*! + \param [in] name the name of the parameter + \return the corresponding parameter + */ + virtual LauParameter* getResonanceParameter(const TString& name); + + //! Retrieve the resonance parameters, e.g. so that they can be loaded into a fit + /*! + \return floating parameters of the resonance + */ + virtual const std::vector& getFloatingParameters(); + + protected: + //! This is not meant to be called + virtual LauComplex resAmp(Double_t mass, Double_t spinTerm); + + Double_t pn(const Double_t x, const Double_t n) const; + Double_t x(const Double_t sqr_t, const Int_t i) const; + Double_t phi00(const Double_t sqr_t, const Int_t i) const; + Double_t g00(const Double_t sqr_t, const Int_t i) const; + + void setB1Parameter(const Double_t B1); + void setB2Parameter(const Double_t B2); + void setB3Parameter(const Double_t B3); + void setC1Parameter(const Double_t C1); + void setC2Parameter(const Double_t C2); + void setC3Parameter(const Double_t C3); + void setC4Parameter(const Double_t C4); + void setC5Parameter(const Double_t C5); + void setD0Parameter(const Double_t D0); + void setD1Parameter(const Double_t D1); + void setD2Parameter(const Double_t D2); + void setD3Parameter(const Double_t D3); + void setF1Parameter(const Double_t F1); + void setF2Parameter(const Double_t F2); + void setF3Parameter(const Double_t F3); + void setF4Parameter(const Double_t F4); + + Double_t getB1Parameter() const {return (B1_!=0) ? B1_->value() : 0.0;} + Bool_t fixB1Parameter() const {return (B1_!=0) ? B1_->fixed() : kTRUE;} + Double_t getB2Parameter() const {return (B2_!=0) ? B2_->value() : 0.0;} + Bool_t fixB2Parameter() const {return (B2_!=0) ? B2_->fixed() : kTRUE;} + Double_t getB3Parameter() const {return (B3_!=0) ? B3_->value() : 0.0;} + Bool_t fixB3Parameter() const {return (B3_!=0) ? B3_->fixed() : kTRUE;} + Double_t getC1Parameter() const {return (C1_!=0)? C1_->value() : 0.0;} + Bool_t fixC1Parameter() const {return (C1_!=0) ?C1_->fixed() : kTRUE;} + Double_t getC2Parameter() const {return (C2_!=0)? C2_->value() : 0.0;} + Bool_t fixC2Parameter() const {return (C2_!=0) ?C2_->fixed() : kTRUE;} + Double_t getC3Parameter() const {return (C3_!=0)? C3_->value() : 0.0;} + Bool_t fixC3Parameter() const {return (C3_!=0) ?C3_->fixed() : kTRUE;} + Double_t getC4Parameter() const {return (C4_!=0)? C4_->value() : 0.0;} + Bool_t fixC4Parameter() const {return (C4_!=0) ?C4_->fixed() : kTRUE;} + Double_t getC5Parameter() const {return (C5_!=0)? C5_->value() : 0.0;} + Bool_t fixC5Parameter() const {return (C5_!=0) ?C5_->fixed() : kTRUE;} + Double_t getD0Parameter() const {return (D0_!=0) ? D0_->value() : 0.0;} + Bool_t fixD0Parameter() const {return (D0_!=0) ? D0_->fixed() : kTRUE;} + Double_t getD1Parameter() const {return (D1_!=0) ? D1_->value() : 0.0;} + Bool_t fixD1Parameter() const {return (D1_!=0) ? D1_->fixed() : kTRUE;} + Double_t getD2Parameter() const {return (D2_!=0) ? D2_->value() : 0.0;} + Bool_t fixD2Parameter() const {return (D2_!=0) ? D2_->fixed() : kTRUE;} + Double_t getD3Parameter() const {return (D3_!=0) ? D3_->value() : 0.0;} + Bool_t fixD3Parameter() const {return (D3_!=0) ? D3_->fixed() : kTRUE;} + Double_t getF1Parameter() const {return (F1_!=0) ? F1_->value() : 0.0;} + Bool_t fixF1Parameter() const {return (F1_!=0) ? F1_->fixed() : kTRUE;} + Double_t getF2Parameter() const {return (F2_!=0) ? F2_->value() : 0.0;} + Bool_t fixF2Parameter() const {return (F2_!=0) ? F2_->fixed() : kTRUE;} + Double_t getF3Parameter() const {return (F3_!=0) ? F3_->value() : 0.0;} + Bool_t fixF3Parameter() const {return (F3_!=0) ? F3_->fixed() : kTRUE;} + Double_t getF4Parameter() const {return (F4_!=0) ? F4_->value() : 0.0;} + Bool_t fixF4Parameter() const {return (F4_!=0) ? F4_->fixed() : kTRUE;} + + + private: + //! Copy constructor (not implemented) + LauRescattering2Res(const LauRescattering2Res& rhs); + + //! Copy assignment operator (not implemented) + LauRescattering2Res& operator=(const LauRescattering2Res& rhs); + + //! Parameter + LauParameter* B1_; + LauParameter* B2_; + LauParameter* B3_; + LauParameter* C1_; + LauParameter* C2_; + LauParameter* C3_; + LauParameter* C4_; + LauParameter* C5_; + LauParameter* D0_; + LauParameter* D1_; + LauParameter* D2_; + LauParameter* D3_; + LauParameter* F1_; + LauParameter* F2_; + LauParameter* F3_; + LauParameter* F4_; + + Double_t sqr_tmin[3], sqr_tmax[3]; + Double_t B0_, C0_, F0_; + + ClassDef(LauRescattering2Res,0) // pipi S wave model by Schechter amplitude model +}; + +#endif diff --git a/inc/LauRescatteringRes.hh b/inc/LauRescatteringRes.hh index 36871f0..5a097fc 100644 --- a/inc/LauRescatteringRes.hh +++ b/inc/LauRescatteringRes.hh @@ -1,269 +1,306 @@ -// Copyright University of Warwick 2004 - 2014. -// Distributed under the Boost Software License, Version 1.0. -// (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +/* +Copyright 2008 University of Warwick -// Authors: -// Thomas Latham -// John Back -// Paul Harrison +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +/* +Laura++ package authors: +John Back +Paul Harrison +Thomas Latham +*/ /*! \file LauRescatteringRes.hh \brief File containing declaration of LauRescatteringRes class. */ /*! \class LauRescatteringRes \brief Class for defining the Rescatering model. Defines the Rescatering models from PiPi-KK Inelastic Scatering : 2005: J.R. Pelaez, F. J. Ynduráin: PHYSICAL REVIEW D 71, 074016 (2005) 2015: J. H. Alvarenga Nogueira, I. Bediaga, A. B. R. Cavalcante, T. Frederico, and O. Lourenço: PHYSICAL REVIEW D 92, 054010 (2015) 2018: J.R. Pelaez, A.Rodas: Unpublished yet PiPi -> KK scattering up to 1.47 GeV with hyperbolic dispersion relations. */ #ifndef LAU_RESCATERING_RES #define LAU_RESCATERING_RES #include "TString.h" #include "LauComplex.hh" #include "LauAbsResonance.hh" class LauKinematics; class LauParameter; class LauRescatteringRes : public LauAbsResonance { public: //! Constructor /*! \param [in] resInfo the object containing information on the resonance name, mass, width, spin, charge, etc. \param [in] resType the model of the resonance \param [in] resPairAmpInt the number of the daughter not produced by the resonance \param [in] daughters the daughter particles */ LauRescatteringRes(LauResonanceInfo* resInfo, const LauAbsResonance::LauResonanceModel resType, const Int_t resPairAmpInt, const LauDaughters* daughters); //! Destructor virtual ~LauRescatteringRes(); //! Initialise the model virtual void initialise(); //! Get the complex dynamical amplitude /*! \param [in] kinematics the kinematic variables of the current event \return the complex amplitude */ virtual LauComplex amplitude(const LauKinematics* kinematics); //! Get the resonance model type /*! \return the resonance model type */ virtual LauAbsResonance::LauResonanceModel getResonanceModel() const {return model_;} //! Set value of the various parameters /*! \param [in] name the name of the parameter to be changed \param [in] value the new parameter value */ virtual void setResonanceParameter(const TString& name, const Double_t value); //! Allow the various parameters to float in the fit /*! \param [in] name the name of the parameter to be floated */ virtual void floatResonanceParameter(const TString& name); //! Access the given resonance parameter /*! \param [in] name the name of the parameter \return the corresponding parameter */ virtual LauParameter* getResonanceParameter(const TString& name); //! Retrieve the resonance parameters, e.g. so that they can be loaded into a fit /*! \return floating parameters of the resonance */ virtual const std::vector& getFloatingParameters(); protected: - //! Set the parameter lambdaPiPi, the NR term for the PiPi + //! Set the parameter lambdaPiPi, the term for the PiPi /*! - \param [in] lambdaPiPi, the NR term for the PiPi + \param [in] lambdaPiPi, the term for the PiPi */ void setLambdaPiPi(const Double_t lambda); - //! Get the lambdaPiPi, the NR term for the PiPi + //! Get the lambdaPiPi, the term for the PiPi /*! - \return the lambdaPiPi, the NR term for the PiPi + \return the lambdaPiPi, the term for the PiPi */ Double_t getLambdaPiPi() const {return (lambdaPiPi_!=0) ? lambdaPiPi_->value() : 0.0;} //! See if the lambdaPiPi parameter is fixed or floating /*! \return kTRUE if the lambdaPiPi parameter is fixed, kFALSE otherwise */ Bool_t fixLambdaPiPi() const {return (lambdaPiPi_!=0) ? lambdaPiPi_->fixed() : kTRUE;} - //! Set the parameter lambdaKK, the NR term for the KK + //! Set the parameter lambdaKK, the term for the KK /*! - \param [in] lambdaKK, the NR term for the KK + \param [in] lambdaKK, the term for the KK */ void setLambdaKK(const Double_t lambda); - //! Get the lambdaKK, the NR term for the KK + //! Get the lambdaKK, the term for the KK /*! - \return the lambdaKK, the NR term for the KK + \return the lambdaKK, the term for the KK */ Double_t getLambdaKK() const {return (lambdaKK_!=0) ? lambdaKK_->value() : 0.0;} //! See if the lambdaKK parameter is fixed or floating /*! \return kTRUE if the lambdaKK parameter is fixed, kFALSE otherwise */ Bool_t fixLambdaKK() const {return (lambdaKK_!=0) ? lambdaKK_->fixed() : kTRUE;} - void setkkps(const Double_t KKps); - Double_t getkkps() const {return (kkps_!=0) ? kkps_->value() : 0.0;} - Bool_t fixkkps() const {return (kkps_!=0) ? kkps_->fixed() : kTRUE;} + //! Set the parameter Ms + /*! + \param [in] Ms + */ + void setMs(const Double_t Ms); + + //! Get the Ms + /*! + \return the Ms + */ + Double_t getMs() const {return (Ms_!=0) ? Ms_->value() : 0.0;} + + //! See if the Ms parameter is fixed or floating + /*! + \return kTRUE if the Ms parameter is fixed, kFALSE otherwise + */ + Bool_t fixMs() const {return (Ms_!=0) ? Ms_->fixed() : kTRUE;} + + + //! Set the parameter Mf + /*! + \param [in] Mf + */ + void setMf(const Double_t Mf); + + //! Get the Mf + /*! + \return the Mf + */ + Double_t getMf() const {return (Mf_!=0) ? Mf_->value() : 0.0;} + + //! See if the Mf parameter is fixed or floating + /*! + \return kTRUE if the Mf parameter is fixed, kFALSE otherwise + */ + Bool_t fixMf() const {return (Mf_!=0) ? Mf_->fixed() : kTRUE;} - void setMF(const Double_t mff); - - //! Get the lambdaKK, the NR term for the KK - /*! - \return the lambdaKK, the NR term for the KK - */ - Double_t getMF() const {return (Mf_!=0) ? Mf_->value() : 0.0;} - - //! See if the lambdaKK parameter is fixed or floating - /*! - \return kTRUE if the lambdaKK parameter is fixed, kFALSE otherwise - */ - Bool_t fixMF() const {return (Mf_!=0) ? Mf_->fixed() : kTRUE;} - - void setMS(const Double_t mss); - - //! Get the lambdaKK, the NR term for the KK - /*! - \return the lambdaKK, the NR term for the KK - */ - Double_t getMS() const {return (Ms_!=0) ? Ms_->value() : 0.0;} - - //! See if the lambdaKK parameter is fixed or floating - /*! - \return kTRUE if the lambdaKK parameter is fixed, kFALSE otherwise - */ - Bool_t fixMS() const {return (Ms_!=0) ? Ms_->fixed() : kTRUE;} - void setMPrime(const Double_t mprimee); - - //! Get the lambdaKK, the NR term for the KK - /*! - \return the lambdaKK, the NR term for the KK - */ - Double_t getMPrime() const {return (Mprime_!=0) ? Mprime_->value() : 0.0;} - - //! See if the lambdaKK parameter is fixed or floating - /*! - \return kTRUE if the lambdaKK parameter is fixed, kFALSE otherwise - */ - Bool_t fixMPrime() const {return (Mprime_!=0) ? Mprime_->fixed() : kTRUE;} - void setBETA(const Double_t betaa); - - //! Get the lambdaKK, the NR term for the KK - /*! - \return the lambdaKK, the NR term for the KK - */ - Double_t getBETA() const {return (Beta_!=0) ? Beta_->value() : 0.0;} - - //! See if the lambdaKK parameter is fixed or floating - /*! - \return kTRUE if the lambdaKK parameter is fixed, kFALSE otherwise - */ - Bool_t fixBETA() const {return (Beta_!=0) ? Beta_->fixed() : kTRUE;} - void setEPSA(const Double_t epsaa); - - //! Get the lambdaKK, the NR term for the KK - /*! - \return the lambdaKK, the NR term for the KK - */ - Double_t getEPSA() const {return (EpsA_!=0) ? EpsA_->value() : 0.0;} - - //! See if the lambdaKK parameter is fixed or floating - /*! - \return kTRUE if the lambdaKK parameter is fixed, kFALSE otherwise - */ - Bool_t fixEPSA() const {return (EpsA_!=0) ? EpsA_->fixed() : kTRUE;} - void setEPSB(const Double_t epsbb); - - //! Get the lambdaKK, the NR term for the KK - /*! - \return the lambdaKK, the NR term for the KK - */ - Double_t getEPSB() const {return (EpsB_!=0) ? EpsB_->value() : 0.0;} - - //! See if the lambdaKK parameter is fixed or floating - /*! - \return kTRUE if the lambdaKK parameter is fixed, kFALSE otherwise - */ - Bool_t fixEPSB() const {return (EpsB_!=0) ? EpsB_->fixed() : kTRUE;} - - + + //! Set the parameter Mprime + /*! + \param [in] Mprime + */ + void setMprime(const Double_t Mprime); + + //! Get the Mprime + /*! + \return the Mprime + */ + Double_t getMprime() const {return (Mprime_!=0) ? Mprime_->value() : 0.0;} + + //! See if the Mprime parameter is fixed or floating + /*! + \return kTRUE if the Mprime parameter is fixed, kFALSE otherwise + */ + Bool_t fixMprime() const {return (Mprime_!=0) ? Mprime_->fixed() : kTRUE;} + + + //! Set the parameter Eps1 + /*! + \param [in] Eps1 + */ + void setEps1(const Double_t Eps1); + + //! Get the Eps1 + /*! + \return the Eps1 + */ + Double_t getEps1() const {return (Eps1_!=0) ? Eps1_->value() : 0.0;} + + //! See if the Eps1 parameter is fixed or floating + /*! + \return kTRUE if the Eps1 parameter is fixed, kFALSE otherwise + */ + Bool_t fixEps1() const {return (Eps1_!=0) ? Eps1_->fixed() : kTRUE;} + + + //! Set the parameter Eps2 + /*! + \param [in] Eps2 + */ + void setEps2(const Double_t Eps2); + + //! Get the Eps2 + /*! + \return the Eps2 + */ + Double_t getEps2() const {return (Eps2_!=0) ? Eps2_->value() : 0.0;} + + //! See if the Eps2 parameter is fixed or floating + /*! + \return kTRUE if the Eps2 parameter is fixed, kFALSE otherwise + */ + Bool_t fixEps2() const {return (Eps2_!=0) ? Eps2_->fixed() : kTRUE;} + + + //! Set the parameter C0 + /*! + \param [in] C0 + */ + void setC0(const Double_t C0); + + //! Get the C0 + /*! + \return the C0 + */ + Double_t getC0() const {return (C0_!=0) ? C0_->value() : 0.0;} + + //! See if the C0 parameter is fixed or floating + /*! + \return kTRUE if the C0 parameter is fixed, kFALSE otherwise + */ + Bool_t fixC0() const {return (C0_!=0) ? C0_->fixed() : kTRUE;} //! Complex resonant amplitude /*! \param [in] mass appropriate invariant mass for the resonance \param [in] spinTerm Zemach spin term */ virtual LauComplex resAmp(Double_t mass, Double_t spinTerm); private: //! Copy constructor (not implemented) LauRescatteringRes(const LauRescatteringRes& rhs); //! Copy assignment operator (not implemented) LauRescatteringRes& operator=(const LauRescatteringRes& rhs); - //! the NR term for the PiPi + //! the term for the PiPi LauParameter* lambdaPiPi_; - //! the NR term for the KK + //! the term for the KK LauParameter* lambdaKK_; - //! the NR term for the PiPi - LauParameter* kkps_; - - //! the NR term for the PiPi + //! the term for the Mf_ LauParameter* Mf_; - //! the NR term for the KK + //! the term for the Ms LauParameter* Ms_; - //! the NR term for the PiPi + //! the term for the Mprime LauParameter* Mprime_; - //! the NR term for the KK - LauParameter* Beta_; - - //! the NR term for the KK - LauParameter* EpsA_; + //! the term for the Eps1 + LauParameter* Eps1_; - //! the NR term for the KK - LauParameter* EpsB_; + //! the term for the Eps2 + LauParameter* Eps2_; + //! the term for the C0 + LauParameter* C0_; UInt_t type_; //! The model to use LauAbsResonance::LauResonanceModel model_; ClassDef(LauRescatteringRes,0) }; #endif diff --git a/inc/Laura++_LinkDef.h b/inc/Laura++_LinkDef.h index 63327fb..4a3f1b8 100644 --- a/inc/Laura++_LinkDef.h +++ b/inc/Laura++_LinkDef.h @@ -1,151 +1,152 @@ /* Copyright 2013 University of Warwick Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. */ /* Laura++ package authors: John Back Paul Harrison Thomas Latham */ #ifdef __CINT__ #pragma link off all globals; #pragma link off all classes; #pragma link off all functions; #pragma link C++ class Lau1DCubicSpline+; #pragma link C++ class Lau1DHistPdf+; #pragma link C++ class Lau2DAbsDP+; #pragma link C++ class Lau2DAbsDPPdf+; #pragma link C++ class Lau2DAbsHistDP+; #pragma link C++ class Lau2DAbsHistDPPdf+; #pragma link C++ class Lau2DCubicSpline+; #pragma link C++ class Lau2DHistDP+; #pragma link C++ class Lau2DHistDPPdf+; #pragma link C++ class Lau2DHistPdf+; #pragma link C++ class Lau2DSplineDP+; #pragma link C++ class Lau2DSplineDPPdf+; #pragma link C++ class LauAbsBkgndDPModel+; #pragma link C++ class LauAbsCoeffSet+; #pragma link C++ class LauAbsEffModel+; #pragma link C++ class LauAbsFitter+; #pragma link C++ class LauAbsFitModel+; #pragma link C++ class LauAbsIncohRes+; #pragma link C++ class LauAbsModIndPartWave+; #pragma link C++ class LauAbsPdf+; #pragma link C++ class LauAbsResonance+; #pragma link C++ class LauAbsRValue+; #pragma link C++ class LauArgusPdf+; #pragma link C++ class LauAsymmCalc+; #pragma link C++ class LauBelleCPCoeffSet+; #pragma link C++ class LauBelleNR+; #pragma link C++ class LauBelleSymNR+; #pragma link C++ class LauBifurcatedGaussPdf+; #pragma link C++ class LauBkgndDPModel+; #pragma link C++ class LauBlattWeisskopfFactor+; #pragma link C++ class LauBlind+; #pragma link C++ class LauBreitWignerRes+; #pragma link C++ class LauCacheData+; #pragma link C++ class LauCartesianCPCoeffSet+; #pragma link C++ class LauCartesianGammaCPCoeffSet+; #pragma link C++ class LauChebychevPdf+; #pragma link C++ class LauCleoCPCoeffSet+; #pragma link C++ class LauComplex+; #pragma link C++ class LauCPFitModel+; #pragma link C++ class LauCruijffPdf+; #pragma link C++ class LauCrystalBallPdf+; #pragma link C++ class LauDabbaRes+; #pragma link C++ class LauDatabasePDG+; #pragma link C++ class LauDaughters+; #pragma link C++ class LauDPDepBifurGaussPdf+; #pragma link C++ class LauDPDepCruijffPdf+; #pragma link C++ class LauDPDepGaussPdf+; #pragma link C++ class LauDPDepMapPdf+; #pragma link C++ class LauDPDepSumPdf+; #pragma link C++ class LauEffModel+; #pragma link C++ class LauEFKLLMRes+; #pragma link C++ class LauEmbeddedData+; #pragma link C++ class LauExponentialPdf+; #pragma link C++ class LauFitDataTree+; #pragma link C++ class LauFitNtuple+; #pragma link C++ class LauFitter+; #pragma link C++ class LauFitObject+; #pragma link C++ class LauFlatteRes+; #pragma link C++ class LauFlatNR+; #pragma link C++ class LauFormulaPar+; #pragma link C++ class LauGaussIncohRes+; #pragma link C++ class LauGaussPdf+; #pragma link C++ class LauGenNtuple+; #pragma link C++ class LauGounarisSakuraiRes+; #pragma link C++ class LauIntegrals+; #pragma link C++ class LauDPPartialIntegralInfo+; #pragma link C++ class LauIsobarDynamics+; #pragma link C++ class LauKappaRes+; #pragma link C++ class LauKinematics+; #pragma link C++ class LauKMatrixProdPole+; #pragma link C++ class LauKMatrixProdSVP+; #pragma link C++ class LauKMatrixPropagator+; #pragma link C++ class LauKMatrixPropFactory+; #pragma link C++ class LauLASSBWRes+; #pragma link C++ class LauLASSNRRes+; #pragma link C++ class LauLASSRes+; #pragma link C++ class LauLinearPdf+; #pragma link C++ class LauMagPhaseCoeffSet+; #pragma link C++ class LauMagPhaseCPCoeffSet+; #pragma link C++ class LauMinuit+; #pragma link C++ class LauModIndPartWaveMagPhase+; #pragma link C++ class LauModIndPartWaveRealImag+; #pragma link C++ class LauNovosibirskPdf+; #pragma link C++ class LauNRAmplitude+; #pragma link C++ class LauParameter+; #pragma link C++ class LauParametricStepFuncPdf+; #pragma link C++ class LauParamFixed+; #pragma link C++ class LauParticlePDG+; #pragma link C++ class LauPolNR+; #pragma link C++ class LauPoleRes+; #pragma link C++ class LauPolarFormFactorNR+; #pragma link C++ class LauPolarFormFactorSymNR+; #pragma link C++ class LauPolarGammaCPCoeffSet+; #pragma link C++ class LauPrint+; #pragma link C++ class LauRealImagCoeffSet+; #pragma link C++ class LauRealImagCPCoeffSet+; #pragma link C++ class LauRealImagGammaCPCoeffSet+; #pragma link C++ class LauRelBreitWignerRes+; #pragma link C++ class LauResonanceInfo+; #pragma link C++ class LauRescatteringRes+; +#pragma link C++ class LauRescattering2Res+; #pragma link C++ class LauResonanceMaker+; #pragma link C++ class LauRhoOmegaMix+; #ifdef DOLAUROOFITSLAVE #pragma link C++ class LauRooFitSlave+; #endif #pragma link C++ class LauScfMap+; #pragma link C++ class LauSigmaRes+; #pragma link C++ class LauSigmoidPdf+; #pragma link C++ class LauSimpleFitModel+; #pragma link C++ class LauSimFitMaster+; #pragma link C++ class LauSimFitSlave+; #pragma link C++ class LauSPlot+; #pragma link C++ class LauString+; #pragma link C++ class LauSumPdf+; #pragma link C++ class LauTextFileParser+; #pragma link C++ class LauVetoes+; #pragma link C++ class LauWeightedSumEffModel+; #pragma link C++ namespace LauConstants+; #pragma link C++ namespace LauRandom+; #endif diff --git a/src/LauAbsResonance.cc b/src/LauAbsResonance.cc index e045de7..4b654e7 100644 --- a/src/LauAbsResonance.cc +++ b/src/LauAbsResonance.cc @@ -1,717 +1,719 @@ /* Copyright 2004 University of Warwick Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. */ /* Laura++ package authors: John Back Paul Harrison Thomas Latham */ /*! \file LauAbsResonance.cc \brief File containing implementation of LauAbsResonance class. */ #include #include "TSystem.h" #include "LauAbsResonance.hh" #include "LauConstants.hh" #include "LauDaughters.hh" #include "LauKinematics.hh" #include "LauParameter.hh" #include "LauResonanceInfo.hh" ClassImp(LauAbsResonance) bool LauAbsResonance::isIncoherentModel(LauResonanceModel model) { switch(model) { case BW: case RelBW: case GS: case Flatte: case Sigma: case Kappa: case Dabba: case LASS: case LASS_BW: case LASS_NR: case EFKLLM: case KMatrix: case FlatNR: case NRModel: case BelleNR: case PowerLawNR: case BelleSymNR: case BelleSymNRNoInter: case TaylorNR: case PolNR: case POLE: case PolarFFNR: case PolarFFSymNR: case PolarFFSymNRNoInter: + case Rescattering: + case RescatteringNoInter: case MIPW_MagPhase: case MIPW_RealImag: case RhoOmegaMix_GS: case RhoOmegaMix_RBW: case RhoOmegaMix_GS_1: case RhoOmegaMix_RBW_1: break; case GaussIncoh: return true; } return false; } // Constructor LauAbsResonance::LauAbsResonance(LauResonanceInfo* resInfo, const Int_t resPairAmpInt, const LauDaughters* daughters) : resInfo_(resInfo), daughters_(daughters), nameParent_(""), nameDaug1_(""), nameDaug2_(""), nameBachelor_(""), chargeParent_(0), chargeDaug1_(0), chargeDaug2_(0), chargeBachelor_(0), massParent_(0.0), massDaug1_(0.0), massDaug2_(0.0), massBachelor_(0.0), resName_( (resInfo!=0) ? resInfo->getName() : "" ), sanitisedName_( (resInfo!=0) ? resInfo->getSanitisedName() : "" ), resMass_( (resInfo!=0) ? resInfo->getMass() : 0 ), resWidth_( (resInfo!=0) ? resInfo->getWidth() : 0 ), resSpin_( (resInfo!=0) ? resInfo->getSpin() : 0 ), resCharge_( (resInfo!=0) ? resInfo->getCharge() : 0 ), resPairAmpInt_(resPairAmpInt), parBWFactor_(0), resBWFactor_(0), spinType_(Zemach_P), flipHelicity_(kFALSE), ignoreMomenta_(kFALSE), ignoreSpin_(kFALSE), ignoreBarrierScaling_(kFALSE), mass_(0.0), cosHel_(0.0), q_(0.0), p_(0.0), pstar_(0.0), erm_(1.0), covFactor_(1.0) { if ( resInfo == 0 ) { std::cerr << "ERROR in LauAbsResonance constructor : null LauResonanceInfo object provided" << std::endl; gSystem->Exit(EXIT_FAILURE); } if ( daughters_ == 0 ) { std::cerr << "ERROR in LauAbsResonance constructor : null LauDaughters object provided" << std::endl; gSystem->Exit(EXIT_FAILURE); } nameParent_ = this->getNameParent(); nameDaug1_ = this->getNameDaug1(); nameDaug2_ = this->getNameDaug2(); nameBachelor_ = this->getNameBachelor(); massParent_ = this->getMassParent(); massDaug1_ = this->getMassDaug1(); massDaug2_ = this->getMassDaug2(); massBachelor_ = this->getMassBachelor(); chargeParent_ = this->getChargeParent(); chargeDaug1_ = this->getChargeDaug1(); chargeDaug2_ = this->getChargeDaug2(); chargeBachelor_ = this->getChargeBachelor(); // check that the total charge adds up to that of the resonance Int_t totalCharge = chargeDaug1_ + chargeDaug2_; if ( (totalCharge != resCharge_) && (resPairAmpInt_ != 0) ) { std::cerr << "ERROR in LauAbsResonance : Total charge of daughters = " << totalCharge << ". Resonance charge = " << resCharge_ << "." << std::endl; gSystem->Exit(EXIT_FAILURE); } } // Constructor LauAbsResonance::LauAbsResonance(const TString& resName, const Int_t resPairAmpInt, const LauDaughters* daughters) : resInfo_(0), daughters_(daughters), nameParent_(""), nameDaug1_(""), nameDaug2_(""), nameBachelor_(""), chargeParent_(0), chargeDaug1_(0), chargeDaug2_(0), chargeBachelor_(0), massParent_(0.0), massDaug1_(0.0), massDaug2_(0.0), massBachelor_(0.0), resName_(resName), sanitisedName_(resName), resMass_(0), resWidth_(0), resSpin_(0), resCharge_(0), resPairAmpInt_(resPairAmpInt), parBWFactor_(0), resBWFactor_(0), spinType_(Zemach_P), flipHelicity_(kFALSE), ignoreMomenta_(kFALSE), ignoreSpin_(kFALSE), ignoreBarrierScaling_(kFALSE), mass_(0.0), cosHel_(0.0), q_(0.0), p_(0.0), pstar_(0.0), erm_(1.0), covFactor_(1.0) { if ( daughters_ == 0 ) { std::cerr << "ERROR in LauAbsResonance constructor : null LauDaughters object provided" << std::endl; gSystem->Exit(EXIT_FAILURE); } nameParent_ = this->getNameParent(); nameDaug1_ = this->getNameDaug1(); nameDaug2_ = this->getNameDaug2(); nameBachelor_ = this->getNameBachelor(); massParent_ = this->getMassParent(); massDaug1_ = this->getMassDaug1(); massDaug2_ = this->getMassDaug2(); massBachelor_ = this->getMassBachelor(); chargeParent_ = this->getChargeParent(); chargeDaug1_ = this->getChargeDaug1(); chargeDaug2_ = this->getChargeDaug2(); chargeBachelor_ = this->getChargeBachelor(); // Since we haven't been provided with a LauResonanceInfo object we can just // set the change of the resonance to be the sum of the daughter charges resCharge_ = chargeDaug1_ + chargeDaug2_; } // Destructor LauAbsResonance::~LauAbsResonance() { } LauComplex LauAbsResonance::amplitude(const LauKinematics* kinematics) { // Use LauKinematics interface for amplitude // For resonance made from tracks i, j, we need the momenta // of tracks i and k in the i-j rest frame for spin helicity calculations // in the Zemach tensor formalism. // Also need the momentum of track k in the parent rest-frame for // calculation of the Blatt-Weisskopf factors. mass_ = 0.0; cosHel_ = 0.0; q_ = 0.0; p_ = 0.0; pstar_ = 0.0; erm_ = 1.0; covFactor_ = 1.0; if (resPairAmpInt_ == 1) { mass_ = kinematics->getm23(); cosHel_ = kinematics->getc23(); q_ = kinematics->getp2_23(); p_ = kinematics->getp1_23(); pstar_ = kinematics->getp1_Parent(); erm_ = kinematics->getcov23(); } else if (resPairAmpInt_ == 2) { mass_ = kinematics->getm13(); cosHel_ = kinematics->getc13(); q_ = kinematics->getp1_13(); p_ = kinematics->getp2_13(); pstar_ = kinematics->getp2_Parent(); erm_ = kinematics->getcov13(); } else if (resPairAmpInt_ == 3) { mass_ = kinematics->getm12(); cosHel_ = kinematics->getc12(); q_ = kinematics->getp1_12(); p_ = kinematics->getp3_12(); pstar_ = kinematics->getp3_Parent(); erm_ = kinematics->getcov12(); } else { std::cerr << "ERROR in LauAbsResonance::amplitude : Nonsense setup of resPairAmp array." << std::endl; gSystem->Exit(EXIT_FAILURE); } if (this->flipHelicity()) { cosHel_ *= -1.0; } if (this->ignoreMomenta()) { q_ = 1.0; p_ = 1.0; pstar_ = 1.0; erm_ = 1.0; } // Calculate the spin factors Double_t spinTerm(1.0); Double_t pProd(1.0); if (!this->ignoreSpin()) { switch ( this->getSpinType() ) { case Zemach_P: pProd = q_*p_; spinTerm = this->calcZemachSpinFactor( pProd ); break; case Zemach_Pstar: pProd = q_*pstar_; spinTerm = this->calcZemachSpinFactor( pProd ); break; case Covariant: pProd = q_*pstar_; spinTerm = this->calcCovSpinFactor( pProd ); break; case Legendre: spinTerm = this->calcLegendrePoly(); break; } } // Calculate the full amplitude LauComplex resAmplitude = this->resAmp(mass_, spinTerm); return resAmplitude; } void LauAbsResonance::calcCovFactor( const Double_t erm ) { if (resSpin_ == 0) { covFactor_ = 1.0; } else if (resSpin_ == 1) { covFactor_ = erm; } else if (resSpin_ == 2) { covFactor_ = erm*erm + 0.5; } else if (resSpin_ == 3) { covFactor_ = erm*(erm*erm + 1.5); } else if (resSpin_ == 4) { covFactor_ = (8.*erm*erm*erm*erm + 24.*erm*erm + 3.)/35.; } else if (resSpin_ > 4) { std::cerr << "WARNING in LauAbsResonance::calcCovFactor : covariant spin factor cannot (yet) be fully calculated for spin >= 5" << std::endl; std::cerr << " : the function of sqrt(1 + (p/mParent)^2) part will be missing" << std::endl; covFactor_ = 1.0; } } Double_t LauAbsResonance::calcCovSpinFactor( const Double_t pProd ) { if (resSpin_ == 0) { covFactor_ = 1.0; return 1.0; } // Covariant spin factor is (p* q)^L * f_L(erm) * P_L(cosHel) Double_t spinFactor(pProd); for ( Int_t i(1); i < resSpin_; ++i ) { spinFactor *= pProd; } this->calcCovFactor( erm_ ); spinFactor *= covFactor_; spinFactor *= this->calcLegendrePoly(); return spinFactor; } Double_t LauAbsResonance::calcZemachSpinFactor( const Double_t pProd ) const { // Calculate the spin factors // // These are calculated as follows // // -2^j * (q*p)^j * cj * Pj(cosHel) // // where Pj(coshHel) is the jth order Legendre polynomial and // // cj = j! / (2j-1)!! if (resSpin_ == 0) { return 1.0; } Double_t spinFactor(pProd); for ( Int_t i(1); i < resSpin_; ++i ) { spinFactor *= pProd; } spinFactor *= this->calcLegendrePoly(); return spinFactor; } Double_t LauAbsResonance::calcLegendrePoly( const Double_t cosHel ) { cosHel_ = cosHel; return this->calcLegendrePoly(); } Double_t LauAbsResonance::calcLegendrePoly() const { Double_t legPol = 1.0; if (resSpin_ == 1) { // Calculate vector resonance Legendre polynomial legPol = -2.0*cosHel_; } else if (resSpin_ == 2) { // Calculate tensor resonance Legendre polynomial legPol = 4.0*(3.0*cosHel_*cosHel_ - 1.0)/3.0; } else if (resSpin_ == 3) { // Calculate spin 3 resonance Legendre polynomial legPol = -8.0*(5.0*cosHel_*cosHel_*cosHel_ - 3.0*cosHel_)/5.0; } else if (resSpin_ == 4) { // Calculate spin 4 resonance Legendre polynomial legPol = 16.0*(35.0*cosHel_*cosHel_*cosHel_*cosHel_ - 30.0*cosHel_*cosHel_ + 3.0)/35.0; } else if (resSpin_ == 5) { // Calculate spin 5 resonance Legendre polynomial legPol = -32.0*(63.0*cosHel_*cosHel_*cosHel_*cosHel_*cosHel_ - 70.0*cosHel_*cosHel_*cosHel_ + 15.0*cosHel_)/63.0; } else if (resSpin_ > 5) { std::cerr << "WARNING in LauAbsResonance::calcLegendrePoly : Legendre polynomials not (yet) implemented for spin > 5" << std::endl; } return legPol; } void LauAbsResonance::changeResonance(const Double_t newMass, const Double_t newWidth, const Int_t newSpin) { if (newMass > 0.0) { resMass_->valueAndRange(newMass,0.0,3.0*newMass); resMass_->initValue(newMass); resMass_->genValue(newMass); std::cout << "INFO in LauAbsResonance::changeResonance : Setting mass to " << resMass_->value() << std::endl; } if (newWidth > 0.0) { resWidth_->valueAndRange(newWidth,0.0,3.0*newWidth); resWidth_->initValue(newWidth); resWidth_->genValue(newWidth); std::cout << "INFO in LauAbsResonance::changeResonance : Setting width to " << resWidth_->value() << std::endl; } if (newSpin > -1) { resSpin_ = newSpin; std::cout << "INFO in LauAbsResonance::changeResonance : Setting spin to " << resSpin_ << std::endl; } } void LauAbsResonance::changeBWBarrierRadii(const Double_t resRadius, const Double_t parRadius) { if ( resRadius >= 0.0 && resBWFactor_ != 0 ) { LauParameter* resBWRadius = resBWFactor_->getRadiusParameter(); resBWRadius->value(resRadius); resBWRadius->initValue(resRadius); resBWRadius->genValue(resRadius); std::cout << "INFO in LauAbsResonance::changeBWBarrierRadii : Setting resonance factor radius to " << resBWRadius->value() << std::endl; } if ( parRadius >= 0.0 && parBWFactor_ != 0 ) { LauParameter* parBWRadius = parBWFactor_->getRadiusParameter(); parBWRadius->value(parRadius); parBWRadius->initValue(parRadius); parBWRadius->genValue(parRadius); std::cout << "INFO in LauAbsResonance::changeBWBarrierRadii : Setting parent factor radius to " << parBWRadius->value() << std::endl; } } void LauAbsResonance::setResonanceParameter(const TString& name, const Double_t value) { //This function should always be overwritten if needed in classes inheriting from LauAbsResonance. std::cerr << "WARNING in LauAbsResonance::setResonanceParameter : Unable to set parameter \"" << name << "\" to value: " << value << "." << std::endl; } void LauAbsResonance::floatResonanceParameter(const TString& name) { //This function should always be overwritten if needed in classes inheriting from LauAbsResonance. std::cerr << "WARNING in LauAbsResonance::floatResonanceParameter : Unable to release parameter \"" << name << "\"." << std::endl; } LauParameter* LauAbsResonance::getResonanceParameter(const TString& name) { //This function should always be overwritten if needed in classes inheriting from LauAbsResonance. std::cerr << "WARNING in LauAbsResonance::getResonanceParameter : Unable to get parameter \"" << name << "\"." << std::endl; return 0; } void LauAbsResonance::addFloatingParameter( LauParameter* param ) { if ( param == 0 ) { return; } if ( param->clone() ) { resParameters_.push_back( param->parent() ); } else { resParameters_.push_back( param ); } } void LauAbsResonance::fixBarrierRadii(const Bool_t fixResRad, const Bool_t fixParRad) { if ( resBWFactor_ == 0 ) { std::cerr << "WARNING in LauAbsResonance::fixBarrierRadii : resonance barrier factor not present, cannot fix/float it" << std::endl; return; } if ( parBWFactor_ == 0 ) { std::cerr << "WARNING in LauAbsResonance::fixBarrierRadii : parent barrier factor not present, cannot fix/float it" << std::endl; return; } LauParameter* resBWRadius = resBWFactor_->getRadiusParameter(); resBWRadius->fixed(fixResRad); LauParameter* parBWRadius = parBWFactor_->getRadiusParameter(); parBWRadius->fixed(fixParRad); } Bool_t LauAbsResonance::fixResRadius() const { if ( resBWFactor_ == 0 ) { std::cerr << "WARNING in LauAbsResonance::fixResRadius : resonance barrier factor not present" << std::endl; return kTRUE; } LauParameter* bwRadius = resBWFactor_->getRadiusParameter(); return bwRadius->fixed(); } Bool_t LauAbsResonance::fixParRadius() const { if ( parBWFactor_ == 0 ) { std::cerr << "WARNING in LauAbsResonance::fixParRadius : parent barrier factor not present" << std::endl; return kTRUE; } LauParameter* bwRadius = parBWFactor_->getRadiusParameter(); return bwRadius->fixed(); } Double_t LauAbsResonance::getResRadius() const { if ( resBWFactor_ == 0 ) { std::cerr << "WARNING in LauAbsResonance::getResRadius : resonance barrier factor not present" << std::endl; return -1.0; } LauParameter* bwRadius = resBWFactor_->getRadiusParameter(); return bwRadius->unblindValue(); } Double_t LauAbsResonance::getParRadius() const { if ( parBWFactor_ == 0 ) { std::cerr << "WARNING in LauAbsResonance::getParRadius : parent barrier factor not present" << std::endl; return -1.0; } LauParameter* bwRadius = parBWFactor_->getRadiusParameter(); return bwRadius->unblindValue(); } Double_t LauAbsResonance::getMassParent() const { // Get the parent mass Double_t mass(LauConstants::mB); if (daughters_) { mass = daughters_->getMassParent(); } return mass; } Double_t LauAbsResonance::getMassDaug1() const { // Get the daughter mass Double_t mass(LauConstants::mPi); if (daughters_) { if (resPairAmpInt_ == 1) { mass = daughters_->getMassDaug2(); } else if (resPairAmpInt_ == 2) { mass = daughters_->getMassDaug1(); } else if (resPairAmpInt_ == 3) { mass = daughters_->getMassDaug1(); } } return mass; } Double_t LauAbsResonance::getMassDaug2() const { // Get the daughter mass Double_t mass(LauConstants::mPi); if (daughters_) { if (resPairAmpInt_ == 1) { mass = daughters_->getMassDaug3(); } else if (resPairAmpInt_ == 2) { mass = daughters_->getMassDaug3(); } else if (resPairAmpInt_ == 3) { mass = daughters_->getMassDaug2(); } } return mass; } Double_t LauAbsResonance::getMassBachelor() const { // Get the bachelor mass Double_t mass(LauConstants::mPi); if (daughters_) { if (resPairAmpInt_ == 1) { mass = daughters_->getMassDaug1(); } else if (resPairAmpInt_ == 2) { mass = daughters_->getMassDaug2(); } else if (resPairAmpInt_ == 3) { mass = daughters_->getMassDaug3(); } } return mass; } Int_t LauAbsResonance::getChargeParent() const { // Get the parent charge Int_t charge(0); if (daughters_) { charge = daughters_->getChargeParent(); } return charge; } Int_t LauAbsResonance::getChargeDaug1() const { // Get the daughter charge Int_t charge(0); if (daughters_) { if (resPairAmpInt_ == 1) { charge = daughters_->getChargeDaug2(); } else if (resPairAmpInt_ == 2) { charge = daughters_->getChargeDaug1(); } else if (resPairAmpInt_ == 3) { charge = daughters_->getChargeDaug1(); } } return charge; } Int_t LauAbsResonance::getChargeDaug2() const { // Get the daughter charge Int_t charge(0); if (daughters_) { if (resPairAmpInt_ == 1) { charge = daughters_->getChargeDaug3(); } else if (resPairAmpInt_ == 2) { charge = daughters_->getChargeDaug3(); } else if (resPairAmpInt_ == 3) { charge = daughters_->getChargeDaug2(); } } return charge; } Int_t LauAbsResonance::getChargeBachelor() const { // Get the bachelor charge Int_t charge(0); if (daughters_) { if (resPairAmpInt_ == 1) { charge = daughters_->getChargeDaug1(); } else if (resPairAmpInt_ == 2) { charge = daughters_->getChargeDaug2(); } else if (resPairAmpInt_ == 3) { charge = daughters_->getChargeDaug3(); } } return charge; } TString LauAbsResonance::getNameParent() const { // Get the parent name TString name(""); if (daughters_) { name = daughters_->getNameParent(); } return name; } TString LauAbsResonance::getNameDaug1() const { // Get the daughter name TString name(""); if (daughters_) { if (resPairAmpInt_ == 1) { name = daughters_->getNameDaug2(); } else if (resPairAmpInt_ == 2) { name = daughters_->getNameDaug1(); } else if (resPairAmpInt_ == 3) { name = daughters_->getNameDaug1(); } } return name; } TString LauAbsResonance::getNameDaug2() const { // Get the daughter name TString name(""); if (daughters_) { if (resPairAmpInt_ == 1) { name = daughters_->getNameDaug3(); } else if (resPairAmpInt_ == 2) { name = daughters_->getNameDaug3(); } else if (resPairAmpInt_ == 3) { name = daughters_->getNameDaug2(); } } return name; } TString LauAbsResonance::getNameBachelor() const { // Get the bachelor name TString name(""); if (daughters_) { if (resPairAmpInt_ == 1) { name = daughters_->getNameDaug1(); } else if (resPairAmpInt_ == 2) { name = daughters_->getNameDaug2(); } else if (resPairAmpInt_ == 3) { name = daughters_->getNameDaug3(); } } return name; } diff --git a/src/LauRescattering2Res.cc b/src/LauRescattering2Res.cc new file mode 100644 index 0000000..0fb5cc8 --- /dev/null +++ b/src/LauRescattering2Res.cc @@ -0,0 +1,658 @@ + +// Copyright University of Warwick 2004 - 2014. +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +// Authors: +// Thomas Latham +// John Back +// Paul Harrison + +/*! \file LauRescattering2Res.cc + \brief File containing implementation of LauRescattering2Res class. +*/ + +#include + +#include "LauConstants.hh" +#include "LauRescattering2Res.hh" +#include "LauResonanceInfo.hh" + +ClassImp(LauRescattering2Res) + +LauRescattering2Res::LauRescattering2Res(LauResonanceInfo* resInfo, const Int_t resPairAmpInt, const LauDaughters* daughters) : + LauAbsResonance(resInfo, resPairAmpInt, daughters), + B1_(0),B2_(0),B3_(0), + C1_(0),C2_(0),C3_(0),C4_(0),C5_(0), + D0_(0),D1_(0),D2_(0),D3_(0), + F1_(0),F2_(0),F3_(0),F4_(0) +{ + // Default values for parameters, taken from + const Double_t B1Val(23.6); + const Double_t B2Val(29.4); + const Double_t B3Val(0.6); + const Double_t C1Val(34.39); + const Double_t C2Val(4.4); + const Double_t C3Val(-32.9); + const Double_t C4Val(-16.); + const Double_t C5Val(7.4); + const Double_t D0Val(0.59); + const Double_t D1Val(-0.38); + const Double_t D2Val(0.12); + const Double_t D3Val(-0.09); + const Double_t F1Val(-0.043); + const Double_t F2Val(-0.008); + const Double_t F3Val(-0.28); + const Double_t F4Val(0.026); + const TString& parNameBase = this->getSanitisedName(); + + TString B1Name(parNameBase); + B1Name += "_B1"; + B1_ = resInfo->getExtraParameter( B1Name ); + if ( B1_ == 0 ) { + B1_ = new LauParameter( B1Name, B1Val, -100.,100., kTRUE ); + B1_->secondStage(kTRUE); + resInfo->addExtraParameter( B1_ ); + } + TString B2Name(parNameBase); + B2Name += "_B2"; + B2_ = resInfo->getExtraParameter( B2Name ); + if ( B2_ == 0 ) { + B2_ = new LauParameter( B2Name, B2Val, -100.,100., kTRUE ); + B2_->secondStage(kTRUE); + resInfo->addExtraParameter( B2_ ); + } + TString B3Name(parNameBase); + B3Name += "_B3"; + B3_ = resInfo->getExtraParameter( B3Name ); + if ( B3_ == 0 ) { + B3_ = new LauParameter( B3Name, B3Val, -100.,100., kTRUE ); + B3_->secondStage(kTRUE); + resInfo->addExtraParameter( B3_ ); + } + + TString C1Name(parNameBase); + C1Name += "_C1"; + C1_ = resInfo->getExtraParameter( C1Name ); + if ( C1_ == 0 ) { + C1_ = new LauParameter( C1Name, C1Val, -100.,100., kTRUE ); + C1_->secondStage(kTRUE); + resInfo->addExtraParameter( C1_ ); + } + TString C2Name(parNameBase); + C2Name += "_C2"; + C2_ = resInfo->getExtraParameter( C2Name ); + if ( C2_ == 0 ) { + C2_ = new LauParameter( C2Name, C2Val, -100.,100., kTRUE ); + C2_->secondStage(kTRUE); + resInfo->addExtraParameter( C2_ ); + } + TString C3Name(parNameBase); + C3Name += "_C3"; + C3_ = resInfo->getExtraParameter( C3Name ); + if ( C3_ == 0 ) { + C3_ = new LauParameter( C3Name, C3Val, -100.,100., kTRUE ); + C3_->secondStage(kTRUE); + resInfo->addExtraParameter( C3_ ); + } + TString C4Name(parNameBase); + C4Name += "_C4"; + C4_ = resInfo->getExtraParameter( C4Name ); + if ( C4_ == 0 ) { + C4_ = new LauParameter( C4Name, C4Val, -100.,100., kTRUE ); + C4_->secondStage(kTRUE); + resInfo->addExtraParameter( C4_ ); + } + TString C5Name(parNameBase); + C5Name += "_C5"; + C5_ = resInfo->getExtraParameter( C5Name ); + if ( C5_ == 0 ) { + C5_ = new LauParameter( C5Name, C5Val, -100.,100., kTRUE ); + C5_->secondStage(kTRUE); + resInfo->addExtraParameter( C5_ ); + } + + TString D0Name(parNameBase); + D0Name += "_D0"; + D0_ = resInfo->getExtraParameter( D0Name ); + if ( D0_ == 0 ) { + D0_ = new LauParameter( D0Name, D0Val, -100.,100., kTRUE ); + D0_->secondStage(kTRUE); + resInfo->addExtraParameter( D0_ ); + } + TString D1Name(parNameBase); + D1Name += "_D1"; + D1_ = resInfo->getExtraParameter( D1Name ); + if ( D1_ == 0 ) { + D1_ = new LauParameter( D1Name, D1Val, -100.,100., kTRUE ); + D1_->secondStage(kTRUE); + resInfo->addExtraParameter( D1_ ); + } + TString D2Name(parNameBase); + D2Name += "_D2"; + D2_ = resInfo->getExtraParameter( D2Name ); + if ( D2_ == 0 ) { + D2_ = new LauParameter( D2Name, D2Val,-100.,100., kTRUE ); + D2_->secondStage(kTRUE); + resInfo->addExtraParameter( D2_ ); + } + TString D3Name(parNameBase); + D3Name += "_D3"; + D3_ = resInfo->getExtraParameter( D3Name ); + if ( D3_ == 0 ) { + D3_ = new LauParameter( D3Name, D3Val, -100.,100., kTRUE ); + D3_->secondStage(kTRUE); + resInfo->addExtraParameter( D3_ ); + } + TString F1Name(parNameBase); + F1Name += "_F1"; + F1_ = resInfo->getExtraParameter( F1Name ); + if ( F1_ == 0 ) { + F1_ = new LauParameter( F1Name, F1Val, -100.,100., kTRUE ); + F1_->secondStage(kTRUE); + resInfo->addExtraParameter( F1_ ); + } + TString F2Name(parNameBase); + F2Name += "_F2"; + F2_ = resInfo->getExtraParameter( F2Name ); + if ( F2_ == 0 ) { + F2_ = new LauParameter( F2Name, F2Val, -100.,100., kTRUE ); + F2_->secondStage(kTRUE); + resInfo->addExtraParameter( F2_ ); + } + TString F3Name(parNameBase); + F3Name += "_F3"; + F3_ = resInfo->getExtraParameter( F3Name ); + if ( F3_ == 0 ) { + F3_ = new LauParameter( F3Name, F3Val, -100.,100., kTRUE ); + F3_->secondStage(kTRUE); + resInfo->addExtraParameter( F3_ ); + } + TString F4Name(parNameBase); + F4Name += "_F4"; + F4_ = resInfo->getExtraParameter( F4Name ); + if ( F4_ == 0 ) { + F4_ = new LauParameter( F4Name, F4Val, -100.,100., kTRUE ); + F4_->secondStage(kTRUE); + resInfo->addExtraParameter( F4_ ); + } +} + +LauRescattering2Res::~LauRescattering2Res() +{ + delete B1_;delete B2_;delete B3_; + delete C1_;delete C2_;delete C3_;delete C4_;delete C5_; + delete D0_;delete D1_;delete D2_;delete D3_; + delete F1_;delete F2_;delete F3_;delete F4_; +} + +void LauRescattering2Res::initialise() +{ + sqr_tmin[1] = 2.00*LauConstants::mK; + sqr_tmin[2] = 1.47; + sqr_tmax[1] = 1.47; + sqr_tmax[2] = 2.00; + + B0_ = 226.5*TMath::Pi()/180.0 + B1_->value() - B2_->value() + B3_->value(); + C0_ = phi00(sqr_tmax[1]*sqr_tmax[1], 1) + C1_->value() - C2_->value() + C3_->value() - C4_->value() + C5_->value(); + F0_ = g00(sqr_tmax[1]*sqr_tmax[1], 1) + F1_->value() - F2_->value() + F3_->value() - F4_->value(); + + std::cout << "##### B = " << this->B1_->value()<<", "<< this->B2_->value()<<", "<< this->B3_->value()<C2_->value()<<", "<< this->C3_->value()<<", "<< this->C4_->value()<<", "<< this->C5_->value()<D1_->value()<<", "<< this->D2_->value()<<", "<< this->D3_->value()<< std::endl; + std::cout << "##### F = " << this->F1_->value()<<", "<< this->F2_->value()<<", "<< this->F3_->value()<<", "<< this->F4_->value()< sqr_tmax[1] && mass < sqr_tmax[2]) i = 2; + if (i == 0) { + std::cout << " ERROR MASS = " << mass <<" out of limmits mI, mII" << std::endl; + return LauComplex(0,0); + } + + Double_t sqr_t = mass; + Double_t mag = this->g00(sqr_t, i); + Double_t phase = this->phi00(sqr_t, i); + + return LauComplex(mag*TMath::Cos(phase), mag*TMath::Sin(phase)); +} + +Double_t LauRescattering2Res::pn(const Double_t x, const Double_t n) const +{ + if (n==0) return 1.0; + if (n==1) return x; + return 2*x*pn(x,n-1) - pn(x,n-2); +} + + +Double_t LauRescattering2Res::x(const Double_t sqr_t, const Int_t i) const +{ + return 2.0*(sqr_t-sqr_tmin[i])/(sqr_tmax[i]-sqr_tmin[i]) -1.0; +} + +Double_t LauRescattering2Res::phi00(const Double_t sqr_t, const Int_t i) const +{ + Double_t x_t = x(sqr_t, i); + + if (i==1) return B0_*this->pn(x_t,0)+ + B1_->value()*this->pn(x_t,1)+ + B2_->value()*this->pn(x_t,2)+ + B3_->value()*this->pn(x_t,3); + + if (i==2) return C0_*this->pn(x_t,0)+ + C1_->value()*this->pn(x_t,1)+ + C2_->value()*this->pn(x_t,2)+ + C3_->value()*this->pn(x_t,3)+ + C4_->value()*this->pn(x_t,4)+ + C5_->value()*this->pn(x_t,5); + + return 0; +} + +Double_t LauRescattering2Res::g00(const Double_t sqr_t, const Int_t i) const +{ + Double_t x_t = x(sqr_t, i); + + if (i==1) return D0_->value()*this->pn(x_t,0)+ + D1_->value()*this->pn(x_t,1)+ + D2_->value()*this->pn(x_t,2)+ + D3_->value()*this->pn(x_t,3); + + + if (i==2) return F0_*this->pn(x_t,0)+ + F1_->value()*this->pn(x_t,1)+ + F2_->value()*this->pn(x_t,2)+ + F3_->value()*this->pn(x_t,3)+ + F4_->value()*this->pn(x_t,4); + + return 0; +} + + +// TODO up to here! +const std::vector& LauRescattering2Res::getFloatingParameters() +{ + this->clearFloatingParameters(); + + if ( ! this->fixB1Parameter() ) { + this->addFloatingParameter( B1_ ); + } + if ( ! this->fixB2Parameter() ) { + this->addFloatingParameter( B2_ ); + } + if ( ! this->fixB3Parameter() ) { + this->addFloatingParameter( B3_ ); + } + + if ( ! this->fixC1Parameter() ) { + this->addFloatingParameter( C1_ ); + } + if ( ! this->fixC2Parameter() ) { + this->addFloatingParameter( C2_ ); + } + if ( ! this->fixC3Parameter() ) { + this->addFloatingParameter( C3_ ); + } + if ( ! this->fixC4Parameter() ) { + this->addFloatingParameter( C4_ ); + } + if ( ! this->fixC5Parameter() ) { + this->addFloatingParameter( C5_ ); + } + + if ( ! this->fixD0Parameter() ) { + this->addFloatingParameter( D0_ ); + } + if ( ! this->fixD1Parameter() ) { + this->addFloatingParameter( D1_ ); + } + if ( ! this->fixD2Parameter() ) { + this->addFloatingParameter( D2_ ); + } + if ( ! this->fixD3Parameter() ) { + this->addFloatingParameter( D3_ ); + } + + if ( ! this->fixF1Parameter() ) { + this->addFloatingParameter( F1_ ); + } + + if ( ! this->fixF2Parameter() ) { + this->addFloatingParameter( F2_ ); + } + + if ( ! this->fixF3Parameter() ) { + this->addFloatingParameter( F3_ ); + } + + if ( ! this->fixF4Parameter() ) { + this->addFloatingParameter( F4_ ); + } + + + return this->getParameters(); +} + +void LauRescattering2Res::setResonanceParameter(const TString& name, const Double_t value) +{ + // Set various parameters for the NRAmplitude lineshape dynamics + if (name == "B1") { + this->setB1Parameter(value); + std::cout << "INFO in LauRescattering2Res::setResonanceParameter : Setting NRAmplitude B1 = " << this->getB1Parameter() << std::endl; + } else if (name == "B2") { + this->setB2Parameter(value); + std::cout << "INFO in LauRescattering2Res::setResonanceParameter : Setting NRAmplitude B2 = " << this->getB2Parameter() << std::endl; + } else if (name == "B3") { + this->setB3Parameter(value); + std::cout << "INFO in LauRescattering2Res::setResonanceParameter : Setting NRAmplitude B3 = " << this->getB3Parameter() << std::endl; + } else if (name == "C1") { + this->setC1Parameter(value); + std::cout << "INFO in LauRescattering2Res::setResonanceParameter : Setting NRAmplitude C1 = " << this->getC1Parameter() << std::endl; + } else if (name == "C2") { + this->setC2Parameter(value); + std::cout << "INFO in LauRescattering2Res::setResonanceParameter : Setting NRAmplitude C2 = " << this->getC2Parameter() << std::endl; + } else if (name == "C3") { + this->setC3Parameter(value); + std::cout << "INFO in LauRescattering2Res::setResonanceParameter : Setting NRAmplitude C3 = " << this->getC3Parameter() << std::endl; + } else if (name == "C4") { + this->setC4Parameter(value); + std::cout << "INFO in LauRescattering2Res::setResonanceParameter : Setting NRAmplitude C4 = " << this->getC4Parameter() << std::endl; + } else if (name == "C5") { + this->setC5Parameter(value); + std::cout << "INFO in LauRescattering2Res::setResonanceParameter : Setting NRAmplitude C5 = " << this->getC5Parameter() << std::endl; + } else if (name == "D0") { + this->setD0Parameter(value); + std::cout << "INFO in LauRescattering2Res::setResonanceParameter : Setting NRAmplitude D0 = " << this->getD0Parameter() << std::endl; + } else if (name == "D1") { + this->setD1Parameter(value); + std::cout << "INFO in LauRescattering2Res::setResonanceParameter : Setting NRAmplitude D1 = " << this->getD1Parameter() << std::endl; + } else if (name == "D2") { + this->setD2Parameter(value); + std::cout << "INFO in LauRescattering2Res::setResonanceParameter : Setting NRAmplitude D2 = " << this->getD2Parameter() << std::endl; + } else if (name == "D3") { + this->setD3Parameter(value); + std::cout << "INFO in LauRescattering2Res::setResonanceParameter : Setting NRAmplitude D3 = " << this->getD3Parameter() << std::endl; + } else if (name == "F1") { + this->setF1Parameter(value); + std::cout << "INFO in LauRescattering2Res::setResonanceParameter : Setting NRAmplitude F1 = " << this->getF1Parameter() << std::endl; + } else if (name == "F2") { + this->setF2Parameter(value); + std::cout << "INFO in LauRescattering2Res::setResonanceParameter : Setting NRAmplitude F2 = " << this->getF2Parameter() << std::endl; + } else if (name == "F3") { + this->setF3Parameter(value); + std::cout << "INFO in LauRescattering2Res::setResonanceParameter : Setting NRAmplitude F3 = " << this->getF3Parameter() << std::endl; + } else if (name == "F4") { + this->setF4Parameter(value); + std::cout << "INFO in LauRescattering2Res::setResonanceParameter : Setting NRAmplitude F4 = " << this->getF4Parameter() << std::endl; + } else { + std::cerr << "WARNING in LauRescattering2Res::setResonanceParameter: Parameter name not reconised. No parameter changes made." << std::endl; + } +} + +void LauRescattering2Res::floatResonanceParameter(const TString& name) +{ + if (name == "B1") { + if ( B1_->fixed() ) { + B1_->fixed( kFALSE ); + this->addFloatingParameter( B1_ ); + } else { + std::cerr << "WARNING in LauRescattering2Res::floatResonanceParameter: Parameter already floating. No parameter changes made." << std::endl; + } + } else if (name == "B2") { + if ( B2_->fixed() ) { + B2_->fixed( kFALSE ); + this->addFloatingParameter( B2_ ); + } else { + std::cerr << "WARNING in LauRescattering2Res::floatResonanceParameter: Parameter already floating. No parameter changes made." << std::endl; + } + } else if (name == "B3") { + if ( B3_->fixed() ) { + B3_->fixed( kFALSE ); + this->addFloatingParameter( B3_ ); + } else { + std::cerr << "WARNING in LauRescattering2Res::floatResonanceParameter: Parameter already floating. No parameter changes made." << std::endl; + } + } else if (name == "C1") { + if ( C1_->fixed() ) { + C1_->fixed( kFALSE ); + this->addFloatingParameter( C1_ ); + } else { + std::cerr << "WARNING in LauRescattering2Res::floatResonanceParameter: Parameter already floating. No parameter changes made." << std::endl; + } + } else if (name == "C2") { + if ( C2_->fixed() ) { + C2_->fixed( kFALSE ); + this->addFloatingParameter( C2_ ); + } else { + std::cerr << "WARNING in LauRescattering2Res::floatResonanceParameter: Parameter already floating. No parameter changes made." << std::endl; + } + } else if (name == "C3") { + if ( C3_->fixed() ) { + C3_->fixed( kFALSE ); + this->addFloatingParameter( C3_ ); + } else { + std::cerr << "WARNING in LauRescattering2Res::floatResonanceParameter: Parameter already floating. No parameter changes made." << std::endl; + } + } else if (name == "C4") { + if ( C4_->fixed() ) { + C4_->fixed( kFALSE ); + this->addFloatingParameter( C4_ ); + } else { + std::cerr << "WARNING in LauRescattering2Res::floatResonanceParameter: Parameter already floating. No parameter changes made." << std::endl; + } + } else if (name == "C5") { + if ( C5_->fixed() ) { + C5_->fixed( kFALSE ); + this->addFloatingParameter( C5_ ); + } else { + std::cerr << "WARNING in LauRescattering2Res::floatResonanceParameter: Parameter already floating. No parameter changes made." << std::endl; + } + } else if (name == "D0") { + if ( D0_->fixed() ) { + D0_->fixed( kFALSE ); + this->addFloatingParameter( D0_ ); + } else { + std::cerr << "WARNING in LauRescattering2Res::floatResonanceParameter: Parameter already floating. No parameter changes made." << std::endl; + } + } else if (name == "D1") { + if ( D1_->fixed() ) { + D1_->fixed( kFALSE ); + this->addFloatingParameter( D1_ ); + } else { + std::cerr << "WARNING in LauRescattering2Res::floatResonanceParameter: Parameter already floating. No parameter changes made." << std::endl; + } + } else if (name == "D2") { + if ( D2_->fixed() ) { + D2_->fixed( kFALSE ); + this->addFloatingParameter( D2_ ); + } else { + std::cerr << "WARNING in LauRescattering2Res::floatResonanceParameter: Parameter already floating. No parameter changes made." << std::endl; + } + } else if (name == "D3") { + if ( D3_->fixed() ) { + D3_->fixed( kFALSE ); + this->addFloatingParameter( D3_ ); + } else { + std::cerr << "WARNING in LauRescattering2Res::floatResonanceParameter: Parameter already floating. No parameter changes made." << std::endl; + } + } else if (name == "F1") { + if ( F1_->fixed() ) { + F1_->fixed( kFALSE ); + this->addFloatingParameter( F1_ ); + } else { + std::cerr << "WARNING in LauRescattering2Res::floatResonanceParameter: Parameter already floating. No parameter changes made." << std::endl; + } + } else if (name == "F2") { + if ( F2_->fixed() ) { + F2_->fixed( kFALSE ); + this->addFloatingParameter( F2_ ); + } else { + std::cerr << "WARNING in LauRescattering2Res::floatResonanceParameter: Parameter already floating. No parameter changes made." << std::endl; + } + } else if (name == "F3") { + if ( F3_->fixed() ) { + F3_->fixed( kFALSE ); + this->addFloatingParameter( F3_ ); + } else { + std::cerr << "WARNING in LauRescattering2Res::floatResonanceParameter: Parameter already floating. No parameter changes made." << std::endl; + } + } else if (name == "4F") { + if ( F4_->fixed() ) { + F4_->fixed( kFALSE ); + this->addFloatingParameter( F4_ ); + } else { + std::cerr << "WARNING in LauRescattering2Res::floatResonanceParameter: Parameter already floating. No parameter changes made." << std::endl; + } + } else { + std::cerr << "WARNING in LauRescattering2Res::fixResonanceParameter: Parameter name not reconised. No parameter changes made." << std::endl; + } +} + +LauParameter* LauRescattering2Res::getResonanceParameter(const TString& name) +{ + if (name == "B1") { + return B1_; + } else if (name == "B2") { + return B2_; + } else if (name == "B3") { + return B3_; + } else if (name == "C1") { + return C1_; + } else if (name == "C2") { + return C2_; + } else if (name == "C3") { + return C3_; + } else if (name == "C4") { + return C4_; + } else if (name == "C5") { + return C5_; + } else if (name == "D0") { + return D0_; + } else if (name == "D1") { + return D1_; + } else if (name == "D2") { + return D2_; + } else if (name == "D3") { + return D3_; + } else if (name == "F1") { + return F1_; + } else if (name == "F2") { + return F2_; + } else if (name == "F3") { + return F3_; + } else if (name == "F4") { + return F4_; + } else { + std::cerr << "WARNING in LauRescattering2Res::getResonanceParameter: Parameter name not reconised." << std::endl; + return 0; + } +} + +void LauRescattering2Res::setB1Parameter(const Double_t B1) +{ + B1_->value( B1 ); + B1_->genValue( B1 ); + B1_->initValue( B1 ); +} +void LauRescattering2Res::setB2Parameter(const Double_t B2) +{ + B2_->value( B2 ); + B2_->genValue( B2 ); + B2_->initValue( B2 ); +} +void LauRescattering2Res::setB3Parameter(const Double_t B3) +{ + B3_->value( B3 ); + B3_->genValue( B3 ); + B3_->initValue( B3 ); +} + +void LauRescattering2Res::setC1Parameter(const Double_t C1) +{ + C1_->value( C1 ); + C1_->genValue( C1 ); + C1_->initValue( C1 ); +} +void LauRescattering2Res::setC2Parameter(const Double_t C2) +{ + C2_->value( C2 ); + C2_->genValue( C2 ); + C2_->initValue( C2 ); +} +void LauRescattering2Res::setC3Parameter(const Double_t C3) +{ + C3_->value( C3 ); + C3_->genValue( C3 ); + C3_->initValue( C3 ); +} +void LauRescattering2Res::setC4Parameter(const Double_t C4) +{ + C4_->value( C4 ); + C4_->genValue( C4 ); + C4_->initValue( C4 ); +} +void LauRescattering2Res::setC5Parameter(const Double_t C5) +{ + C5_->value( C5 ); + C5_->genValue( C5 ); + C5_->initValue( C5 ); +} + + +void LauRescattering2Res::setD0Parameter(const Double_t D0) +{ + D0_->value( D0 ); + D0_->genValue( D0 ); + D0_->initValue( D0 ); +} +void LauRescattering2Res::setD1Parameter(const Double_t D1) +{ + D1_->value( D1 ); + D1_->genValue( D1 ); + D1_->initValue( D1 ); +} +void LauRescattering2Res::setD2Parameter(const Double_t D2) +{ + D2_->value( D2 ); + D2_->genValue( D2 ); + D2_->initValue( D2 ); +} +void LauRescattering2Res::setD3Parameter(const Double_t D3) +{ + D3_->value( D3 ); + D3_->genValue( D3 ); + D3_->initValue( D3 ); +} +void LauRescattering2Res::setF1Parameter(const Double_t F1) +{ + F1_->value( F1 ); + F1_->genValue( F1 ); + F1_->initValue( F1 ); +} + +void LauRescattering2Res::setF2Parameter(const Double_t F2) +{ + F2_->value( F2 ); + F2_->genValue( F2 ); + F2_->initValue( F2 ); +} + +void LauRescattering2Res::setF3Parameter(const Double_t F3) +{ + F3_->value( F3 ); + F3_->genValue( F3 ); + F3_->initValue( F3 ); +} + +void LauRescattering2Res::setF4Parameter(const Double_t F4) +{ + F4_->value( F4 ); + F4_->genValue( F4 ); + F4_->initValue( F4 ); +} + diff --git a/src/LauRescatteringRes.cc b/src/LauRescatteringRes.cc index 60b598d..095c2d3 100644 --- a/src/LauRescatteringRes.cc +++ b/src/LauRescatteringRes.cc @@ -1,561 +1,466 @@ -// Copyright University of Warwick 2004 - 2014. -// Distributed under the Boost Software License, Version 1.0. -// (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +/* +Copyright 2008 University of Warwick -// Authors: -// Thomas Latham -// John Back -// Paul Harrison +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +/* +Laura++ package authors: +John Back +Paul Harrison +Thomas Latham +*/ /*! \file LauRescatteringRes.cc \brief File containing implementation of LauRescatteringRes class. */ #include #include "TMath.h" #include "TSystem.h" #include "LauConstants.hh" #include "LauRescatteringRes.hh" #include "LauDaughters.hh" #include "LauParameter.hh" #include "LauResonanceInfo.hh" ClassImp(LauRescatteringRes) LauRescatteringRes::LauRescatteringRes(LauResonanceInfo* resInfo, const LauAbsResonance::LauResonanceModel resType, const Int_t resPairAmpInt, const LauDaughters* daughters) : LauAbsResonance(resInfo, resPairAmpInt, daughters), lambdaPiPi_(0), lambdaKK_(0), - kkps_(0), //use (==1) or not (==0) the kkpahse space - Mf_(0), //Parametro Mf, do delta_pipi - Ms_(0), //Parametro Ms, do delta_pipi - Mprime_(0), //Parametro Mf, do delta_pipi - Beta_(0), //Parametro Ms, do delta_pipi - EpsA_(0), //Parametro Ms, do delta_pipi - EpsB_(0), //Parametro Ms, do delta_pipi + Mf_(0), + Ms_(0), + Mprime_(0), + Eps1_(0), + Eps2_(0), + C0_(0), type_(0), model_(resType) { TString parNameBase = this->getSanitisedName(); TString lambdaPiPiName(parNameBase); lambdaPiPiName += "_lambdaPiPi"; lambdaPiPi_ = resInfo->getExtraParameter( lambdaPiPiName ); if ( lambdaPiPi_ == 0 ) { lambdaPiPi_ = new LauParameter( lambdaPiPiName, 1.0, 0.0, 10.0, kTRUE ); lambdaPiPi_->secondStage(kTRUE); resInfo->addExtraParameter( lambdaPiPi_ ); } TString lambdaKKName(parNameBase); lambdaKKName += "_lambdaKK"; lambdaKK_ = resInfo->getExtraParameter( lambdaKKName ); if ( lambdaKK_ == 0 ) { lambdaKK_ = new LauParameter( lambdaKKName, 2.8, 0.0, 10.0, kTRUE ); lambdaKK_->secondStage(kTRUE); resInfo->addExtraParameter( lambdaKK_ ); } - TString kkpsName(parNameBase); - kkpsName += "_kkps"; - kkps_ = resInfo->getExtraParameter( kkpsName ); - if ( kkps_ == 0 ) { - kkps_ = new LauParameter( kkpsName, 0.0, 0.0, 10.0, kTRUE ); - kkps_->secondStage(kTRUE); - resInfo->addExtraParameter( kkps_ ); - } TString MfName(parNameBase); MfName += "_Mf"; Mf_ = resInfo->getExtraParameter( MfName ); if ( Mf_ == 0 ) { Mf_ = new LauParameter( MfName, 1.32, 0.0, 10.0, kTRUE ); Mf_->secondStage(kTRUE); resInfo->addExtraParameter( Mf_ ); } TString MsName(parNameBase); MsName += "_Ms"; Ms_ = resInfo->getExtraParameter( MsName ); if ( Ms_ == 0 ) { Ms_ = new LauParameter( MsName, 0.92, 0.0, 10.0, kTRUE ); Ms_->secondStage(kTRUE); resInfo->addExtraParameter( Ms_ ); } - TString BetaName(parNameBase); - BetaName += "_Beta"; - Beta_ = resInfo->getExtraParameter( BetaName ); - if ( Beta_ == 0 ) { - Beta_ = new LauParameter( BetaName, 1.00, -10.0, 10.0, kTRUE ); - Beta_->secondStage(kTRUE); - resInfo->addExtraParameter( Beta_ ); - } TString MprimeName(parNameBase); MprimeName += "_Mprime"; Mprime_ = resInfo->getExtraParameter( MprimeName ); if ( Mprime_ == 0 ) { - Mprime_ = new LauParameter( MprimeName, 2.11, 0.0, 10.0, kTRUE ); + Mprime_ = new LauParameter( MprimeName, 1.5, 0.0, 10.0, kTRUE ); Mprime_->secondStage(kTRUE); resInfo->addExtraParameter( Mprime_ ); } - TString EpsAName(parNameBase); - EpsAName += "_Eps1"; - EpsA_ = resInfo->getExtraParameter( EpsAName ); - if ( EpsA_ == 0 ) { - EpsA_ = new LauParameter( EpsAName, 1.9, 0.0, 10.0, kTRUE ); - EpsA_->secondStage(kTRUE); - resInfo->addExtraParameter( EpsA_ ); + + TString Eps1Name(parNameBase); + Eps1Name += "_Eps1"; + Eps1_ = resInfo->getExtraParameter( Eps1Name ); + if ( Eps1_ == 0 ) { + Eps1_ = new LauParameter( Eps1Name, 2.4, 0.0, 10.0, kTRUE ); + Eps1_->secondStage(kTRUE); + resInfo->addExtraParameter( Eps1_ ); } - TString EpsBName(parNameBase); - EpsBName += "_Eps2"; - EpsB_ = resInfo->getExtraParameter( EpsBName ); - if ( EpsB_ == 0 ) { - EpsB_ = new LauParameter( EpsBName, -3.7, -10.0, 10.0, kTRUE ); - EpsB_->secondStage(kTRUE); - resInfo->addExtraParameter( EpsB_ ); + TString Eps2Name(parNameBase); + Eps2Name += "_Eps2"; + Eps2_ = resInfo->getExtraParameter( Eps2Name ); + if ( Eps2_ == 0 ) { + Eps2_ = new LauParameter( Eps2Name, -5.5, -10.0, 10.0, kTRUE ); + Eps2_->secondStage(kTRUE); + resInfo->addExtraParameter( Eps2_ ); + } + + TString C0Name(parNameBase); + C0Name += "_C0"; + C0_ = resInfo->getExtraParameter( C0Name ); + if ( C0_ == 0 ) { + C0_ = new LauParameter( C0Name, 1.3, 0.0, 10.0, kTRUE ); + C0_->secondStage(kTRUE); + resInfo->addExtraParameter( C0_ ); } - - - } LauRescatteringRes::~LauRescatteringRes() { delete lambdaPiPi_; delete lambdaKK_; delete Mf_; delete Ms_; - delete Beta_; delete Mprime_; - delete EpsA_; - delete EpsB_; - delete kkps_; - + delete Eps1_; + delete Eps2_; + delete C0_; } void LauRescatteringRes::initialise() { + + const LauDaughters* daughters = this->getDaughters(); Int_t resPairAmpInt = this->getPairInt(); if ( daughters->gotSymmetricalDP() && resPairAmpInt != 3 ) { - std::cerr << "WARNING in LauRescatteringRes::initialise : Rescatteringhybrid with kkpi model and KK phase space.." << std::endl; + std::cerr << "WARNING in LauRescatteringRes::initialise : Dalitz plot is symmetric - this lineshape is not appropriate." << std::endl; std::cerr << "WARNING I think that this warning is not appropiate because Laura Simetrize at LauIsobarModel level." << std::endl; } - if ( model_ != LauAbsResonance::KKPiPiScatt) { - std::cerr << "WARNING in LauRescatteringRes::initialise : Unknown model requested, defaulting to Rescatering." << std::endl; - model_ = LauAbsResonance::KKPiPiScatt; + if ( (model_ != LauAbsResonance::Rescattering) && (model_ != LauAbsResonance::RescatteringNoInter)) { + std::cerr << "WARNING in LauRescatteringRes::initialise : Unknown model requested, defaulting to exponential." << std::endl; + model_ = LauAbsResonance::Rescattering; } - - TString name = this->getResonanceName(); - if (name.CompareTo("RescateringHbKK")==0 ){ - type_ = 0; - std::cerr << "RescateringHbKK parameters......" << std::endl; - std::cerr << "=== kkps "<getkkps() << std::endl; - std::cerr << "=== LambdaKK "<getLambdaKK() << std::endl; - std::cerr << "=== mf--ms--LambdaKK "<getLambdaKK() << std::endl; - } - else if (name.CompareTo("Rescatering_ExclHbKK")==0 ){ - type_ = 1; - } - else{ - std::cerr << "ERROR in LauRescatteringRes::initialise : Resonance type unknown (known types : 0, 1)" << std::endl; - std::cerr << " : Defaulting to 0." << std::endl; + if ( (model_ != LauAbsResonance::RescatteringNoInter) && (this->getSpin() != 0) ) { + std::cerr << "WARNING in LauRescatteringRes::initialise : Non-zero spin will be ignored for this model - perhaps you should use LauAbsResonance::BelleSymNRNoInter instead" << std::endl; } } LauComplex LauRescatteringRes::amplitude(const LauKinematics* kinematics) { // This function returns the complex dynamical amplitude for a Reescatering distribution o original - // pelaez paper parameters - // Double_t mprime = 1.5; // Eq 2.15a [Pelaez et Yndúrain: arXiv:hep-ph/0411334v2 Mar 2005] - Double_t mprime = this->getMPrime(); // Eq 2.15a [Pelaez et Yndúrain: arXiv:hep-ph/0411334v2 Mar 2005] - Double_t beta = this->getBETA(); - Double_t eps1 = this->getEPSA(); - Double_t eps2 = this->getEPSB(); - - Double_t c0 = 1.3; - Double_t mk = LauConstants::mK; - Double_t mpi= LauConstants::mPi; - Double_t mb= LauConstants::mB; + // pelaez paper parameters Eq 2.15a [Pelaez et Yndúrain: arXiv:hep-ph/0411334v2 Mar 2005] + Double_t Mprime = this->getMprime(); + Double_t Mf = this->getMf(); + Double_t Ms = this->getMs(); + Double_t eps1 = this->getEps1(); + Double_t eps2 = this->getEps2(); + Double_t c0 = this->getC0(); Double_t lambPiPi = this->getLambdaPiPi(); Double_t lambKK = this->getLambdaKK(); - Double_t kkps = this->getkkps(); - Double_t mf = this->getMF(); - Double_t ms = this->getMS(); - Double_t PI =LauConstants::pi; - // Calculate Mandelstam variables. - // s = m_13^2, t = m_23^2, u = m_12^2. + + Double_t mk = LauConstants::mK; + + // Calculate Mandelstam variables: s = m_13^2, t = m_23^2, u = m_12^2. Double_t s = 0; Double_t t = 0; - Double_t u = 0; Int_t resPairAmpInt = getPairInt(); - //if (resPairAmpInt == 1) { - // s = kinematics->getm23Sq(); - // t = kinematics->getm12Sq(); - //} else if (resPairAmpInt == 2) { - // s = kinematics->getm13Sq(); - // t = kinematics->getm23Sq(); - //} else if (resPairAmpInt == 3) { - // s = kinematics->getm12Sq(); - // t = kinematics->getm13Sq(); - - if (resPairAmpInt == 1) { - s = kinematics->getm13Sq(); - t = kinematics->getm23Sq(); - u = kinematics->getm12Sq(); - } else if (resPairAmpInt == 2) { s = kinematics->getm23Sq(); t = kinematics->getm12Sq(); - u = kinematics->getm13Sq(); + } else if (resPairAmpInt == 2) { + s = kinematics->getm13Sq(); + t = kinematics->getm23Sq(); } else if (resPairAmpInt == 3) { s = kinematics->getm12Sq(); t = kinematics->getm13Sq(); - u = kinematics->getm23Sq(); } else { std::cerr << "ERROR in LauAbsResonance::amplitude : Nonsense setup of resPairAmp array." << std::endl; gSystem->Exit(EXIT_FAILURE); } - - Double_t magnitude(0.); - Double_t phase(0.); - - //in KK phasespace - Double_t mth = 0.493*2.; - Double_t ss = s/mth; - - // check if u variable is within the KK phase space - Double_t m=sqrt(s); - Double_t E2 =(m*m )/(2*m); - Double_t E3 =(mb*mb- m*m -mpi*mpi)/(2*m); - Double_t p2= sqrt(E2*E2 - mk*mk); - Double_t p3 =sqrt(E3*E3 - mpi*mpi); - - Double_t umin=1000.; - Double_t umax=0.; - - if((E2 + E3)>(p2 + p3))umin=pow((E2 + E3),2) - pow((p2 + p3),2); - if((E2 + E3)>(p2 - p3))umax=pow((E2 + E3),2) - pow((p2 - p3),2); - - if ((kkps ==1. && u>umin && u1. ) || kkps ==0. ) { - - // Calculate amplitude for s variable. - Double_t mass_s = TMath::Sqrt(s); - Double_t k2Square_s = (s - 4.0*mk*mk)/4.0; - Double_t k2Abs_s=0; - if (k2Square_s > 0) k2Abs_s = TMath::Sqrt(k2Square_s); - else k2Abs_s = TMath::Sqrt(-1.0*k2Square_s); - - //fase beyond mkk**2 - Double_t meta =0.54751; - Double_t B = 93.3; - Double_t C= 48.7; - Double_t D=-88.3; - Double_t d0=226.5; - Double_t k3= 0.; - Double_t etaP= 0.0; - Double_t etaN=0.0; - if(s>4.0*meta*meta){ - k3= sqrt( s/4.0 - meta*meta); - etaP= D*pow(k3,2.0)/pow(meta,2.0); - etaN= k3/sqrt(s); - } - Double_t delta2pp = d0 + B*k2Abs_s*k2Abs_s/pow(mk,2.0) + C*pow(k2Abs_s,4.0)/pow(mk,4.0) + etaP;//para 1.4>s>4mk i - - - Double_t delta0_s= delta2pp*PI/180.0; // convert to rad - - - - - Double_t eta0_s = 1.0 - (eps1*k2Abs_s/mass_s + eps2*k2Square_s/s)*(mprime*mprime-s)/s; // Eq 2.15a - if ((mass_s < 2.0*mk)||(mass_s > mprime)) eta0_s = 1; - Double_t mag_s = TMath::Sqrt( 1-eta0_s*eta0_s); + // Calculate amplitude for s variable. + Double_t mass_s = TMath::Sqrt(s); + Double_t k2Square_s = (s - 4.0*mk*mk)/4.0; + Double_t k2Abs_s=0; + if (k2Square_s > 0) k2Abs_s = TMath::Sqrt(k2Square_s); + else k2Abs_s = TMath::Sqrt(-1.0*k2Square_s); + Double_t cotdelta0_s = c0*(s - Ms*Ms)*(Mf*Mf - s)*k2Abs_s/(Mf*Mf*mass_s*k2Square_s); // Eq 2.15a + Double_t delta0_s = TMath::ATan(1.0/cotdelta0_s); + Double_t eta0_s = 1.0 - (eps1*k2Abs_s/mass_s + eps2*k2Square_s/s)*(Mprime*Mprime-s)/s; // Eq 2.15a - Double_t tauRe_s = mag_s*TMath::Cos(2.0*delta0_s); - Double_t tauIm_s = mag_s*TMath::Sin(2.0*delta0_s); + if ((mass_s < 2.0*mk)||(mass_s > Mprime )) eta0_s = 1; + Double_t mag_s = TMath::Sqrt( 1-eta0_s*eta0_s); - Double_t NR1_s = 1.0/(1.0+s/(lambPiPi*lambPiPi)); - Double_t NR2_s = 1.0/(1.0+s/(lambKK*lambKK)); + Double_t tauRe_s = mag_s*TMath::Cos(2.0*delta0_s); + Double_t tauIm_s = mag_s*TMath::Sin(2.0*delta0_s); - //LauComplex resAmplitude(-tauIm_s*NR1_s*NR2_s - tauIm_t*NR1_t*NR2_t, tauRe_s*NR1_s*NR2_s + tauRe_t*NR1_t*NR2_t ); - if ((type_ == 1)&&(t<=s)) - { - NR1_s=0.0; NR2_s=0.0; tauRe_s=0.0; tauIm_s=0.0; - } + Double_t NR1_s = 1.0/(1.0+s/(lambPiPi*lambPiPi)); + Double_t NR2_s = 1.0/(1.0+s/(lambKK*lambKK)); + + //LauComplex resAmplitude(-tauIm_s*NR1_s*NR2_s - tauIm_t*NR1_t*NR2_t, tauRe_s*NR1_s*NR2_s + tauRe_t*NR1_t*NR2_t ); + if ((model_ == LauAbsResonance::RescatteringNoInter)&&(t<=s)) + { + NR1_s=0.0; NR2_s=0.0; tauRe_s=0.0; tauIm_s=0.0; + } + + LauComplex resAmplitude(-tauIm_s*NR1_s*NR2_s ,tauRe_s*NR1_s*NR2_s); - magnitude=-tauIm_s*NR1_s; - phase= tauRe_s*NR1_s;//*NR2_s - - } - LauComplex resAmplitude(magnitude,phase); return resAmplitude; + } LauComplex LauRescatteringRes::resAmp(Double_t mass, Double_t spinTerm) { std::cerr << "ERROR in LauRescatteringRes : This method should never be called." << std::endl; std::cerr << " : Returning zero amplitude for mass = " << mass << " and spinTerm = " << spinTerm << "." << std::endl; return LauComplex(0.0, 0.0); } const std::vector& LauRescatteringRes::getFloatingParameters() { this->clearFloatingParameters(); if ( ! this->fixLambdaPiPi() ) { this->addFloatingParameter( lambdaPiPi_ ); } if ( ! this->fixLambdaKK() ) { this->addFloatingParameter( lambdaKK_ ); } - if ( ! this->fixkkps() ) { - this->addFloatingParameter( kkps_ ); - } - if ( ! this->fixMF() ) { + if ( ! this->fixMf() ) { this->addFloatingParameter( Mf_ ); } - if ( ! this->fixMS() ) { + if ( ! this->fixMs() ) { this->addFloatingParameter( Ms_ ); } - if ( ! this->fixMPrime() ) { + if ( ! this->fixMprime() ) { this->addFloatingParameter( Mprime_ ); } - if ( ! this->fixBETA() ) { - this->addFloatingParameter( Beta_ ); + if ( ! this->fixEps1() ) { + this->addFloatingParameter( Eps1_ ); } - if ( ! this->fixEPSA() ) { - this->addFloatingParameter( EpsA_ ); + if ( ! this->fixEps2() ) { + this->addFloatingParameter( Eps2_ ); } - if ( ! this->fixEPSB() ) { - this->addFloatingParameter( EpsB_ ); + if ( ! this->fixC0() ) { + this->addFloatingParameter( C0_ ); } return this->getParameters(); } void LauRescatteringRes::setResonanceParameter(const TString& name, const Double_t value) { // Set various parameters for the lineshape if (name == "lambdaPiPi") { this->setLambdaPiPi(value); std::cout << "INFO in LauRescatteringRes::setResonanceParameter : Setting parameter lambdaPiPi = " << this->getLambdaPiPi() << std::endl; } else if (name == "lambdaKK") { this->setLambdaKK(value); std::cout << "INFO in LauRescatteringRes::setResonanceParameter : Setting parameter lambdaKK = " << this->getLambdaKK() << std::endl; } - else if (name == "kkps") { - this->setkkps(value); - std::cout << "INFO in LauPhaseRescRes::setResonanceParameter : Setting parameter kkps = " << this->getkkps() << std::endl; - } else if (name == "Mf") { - this->setMF(value); - std::cout << "INFO in LauPhaseRescRes::setResonanceParameter : Setting parameter Mf = " << this->getMF() << std::endl; + this->setMf(value); + std::cout << "INFO in LauRescatteringRes::setResonanceParameter : Setting parameter Mf = " << this->getMf() << std::endl; } else if (name == "Ms") { - this->setMS(value); - std::cout << "INFO in LauPhaseRescRes::setResonanceParameter : Setting parameter Ms = " << this->getMS() << std::endl; + this->setMs(value); + std::cout << "INFO in LauRescatteringRes::setResonanceParameter : Setting parameter Ms = " << this->getMs() << std::endl; } else if (name == "Mprime") { - this->setMPrime(value); - std::cout << "INFO in LauPhaseRescRes::setResonanceParameter : Setting parameter Mprime = " << this->getMPrime() << std::endl; + this->setMprime(value); + std::cout << "INFO in LauRescatteringRes::setResonanceParameter : Setting parameter Mprime = " << this->getMprime() << std::endl; } - else if (name == "Beta") { - this->setBETA(value); - std::cout << "INFO in LauPhaseRescRes::setResonanceParameter : Setting parameter Beta = " << this->getBETA() << std::endl; + else if (name == "Eps1") { + this->setEps1(value); + std::cout << "INFO in LauRescatteringRes::setResonanceParameter : Setting parameter eps1 = " << this->getEps1() << std::endl; } - else if (name == "EpsA") { - this->setEPSA(value); - std::cout << "INFO in LauPhaseRescRes::setResonanceParameter : Setting parameter Beta = " << this->getEPSA() << std::endl; + else if (name == "Eps2") { + this->setEps2(value); + std::cout << "INFO in LauRescatteringRes::setResonanceParameter : Setting parameter eps2 = " << this->getEps2() << std::endl; } - else if (name == "EpsB") { - this->setEPSB(value); - std::cout << "INFO in LauPhaseRescRes::setResonanceParameter : Setting parameter Beta = " << this->getEPSB() << std::endl; + else if (name == "C0") { + this->setC0(value); + std::cout << "INFO in LauRescatteringRes::setResonanceParameter : Setting parameter eps2 = " << this->getC0() << std::endl; } - else { std::cerr << "WARNING in LauRescatteringRes::setResonanceParameter: Parameter name not reconised. No parameter changes made." << std::endl; } } void LauRescatteringRes::floatResonanceParameter(const TString& name) { if (name == "lambdaPiPi") { if ( lambdaPiPi_->fixed() ) { lambdaPiPi_->fixed( kFALSE ); this->addFloatingParameter( lambdaPiPi_ ); } else { std::cerr << "WARNING in LauRescatteringRes::floatResonanceParameter: Parameter already floating. No parameter changes made." << std::endl; } } else if (name == "lambdaKK") { if ( lambdaKK_->fixed() ) { lambdaKK_->fixed( kFALSE ); this->addFloatingParameter( lambdaKK_ ); } else { std::cerr << "WARNING in LauRescatteringRes::floatResonanceParameter: Parameter already floating. No parameter changes made." << std::endl; } } - else if (name == "kkps") { - if ( kkps_->fixed() ) { - kkps_->fixed( kFALSE ); - this->addFloatingParameter( kkps_ ); - } else { - std::cerr << "WARNING in LauRescatteringRes::floatResonanceParameter: Parameter already floating. No parameter changes made." << std::endl; - } - } else if (name == "Mf") { if ( Mf_->fixed() ) { Mf_->fixed( kFALSE ); this->addFloatingParameter( Mf_ ); } else { std::cerr << "WARNING in LauRescatteringRes::floatResonanceParameter: Parameter already floating. No parameter changes made." << std::endl; } } else if (name == "Ms") { if ( Ms_->fixed() ) { Ms_->fixed( kFALSE ); this->addFloatingParameter( Ms_ ); } else { std::cerr << "WARNING in LauRescatteringRes::floatResonanceParameter: Parameter already floating. No parameter changes made." << std::endl; } } else if (name == "Mprime") { if ( Mprime_->fixed() ) { Mprime_->fixed( kFALSE ); this->addFloatingParameter( Mprime_ ); } else { std::cerr << "WARNING in LauRescatteringRes::floatResonanceParameter: Parameter already floating. No parameter changes made." << std::endl; } } - else if (name == "Beta") { - if ( Beta_->fixed() ) { - Beta_->fixed( kFALSE ); - this->addFloatingParameter( Beta_ ); + else if (name == "Eps1") { + if ( Eps1_->fixed() ) { + Eps1_->fixed( kFALSE ); + this->addFloatingParameter( Eps1_ ); } else { std::cerr << "WARNING in LauRescatteringRes::floatResonanceParameter: Parameter already floating. No parameter changes made." << std::endl; } } - else if (name == "EpsA") { - if ( EpsA_->fixed() ) { - EpsA_->fixed( kFALSE ); - this->addFloatingParameter( EpsA_ ); + else if (name == "Eps2") { + if ( Eps2_->fixed() ) { + Eps2_->fixed( kFALSE ); + this->addFloatingParameter( Eps2_ ); } else { std::cerr << "WARNING in LauRescatteringRes::floatResonanceParameter: Parameter already floating. No parameter changes made." << std::endl; } } - else if (name == "EpsB") { - if ( EpsB_->fixed() ) { - EpsB_->fixed( kFALSE ); - this->addFloatingParameter( EpsB_ ); + else if (name == "C0") { + if ( C0_->fixed() ) { + C0_->fixed( kFALSE ); + this->addFloatingParameter( C0_ ); } else { std::cerr << "WARNING in LauRescatteringRes::floatResonanceParameter: Parameter already floating. No parameter changes made." << std::endl; } } else { std::cerr << "WARNING in LauRescatteringRes::fixResonanceParameter: Parameter name not reconised. No parameter changes made." << std::endl; } } LauParameter* LauRescatteringRes::getResonanceParameter(const TString& name) { if (name == "lambdaPiPi") { return lambdaPiPi_; } else if (name == "lambdaKK") { return lambdaKK_; } - if (name == "kkps") { - return kkps_; - } if (name == "Mf") { return Mf_; } else if (name == "Ms") { return Ms_; } if (name == "Mprime") { return Mprime_; } - else if (name == "Beta") { - return Beta_; + if (name == "Eps1") { + return Eps1_; } - if (name == "EpsA") { - return EpsA_; + if (name == "Eps2") { + return Eps2_; } - if (name == "EpsB") { - return EpsB_; + if (name == "C0") { + return C0_; } - else { std::cerr << "WARNING in LauRescatteringRes::getResonanceParameter: Parameter name not reconised." << std::endl; return 0; } } void LauRescatteringRes::setLambdaPiPi(const Double_t lambda) { lambdaPiPi_->value( lambda ); lambdaPiPi_->genValue( lambda ); lambdaPiPi_->initValue( lambda ); } void LauRescatteringRes::setLambdaKK(const Double_t lambda) { lambdaKK_->value( lambda ); lambdaKK_->genValue( lambda ); lambdaKK_->initValue( lambda ); } -void LauRescatteringRes::setkkps(const Double_t KKps) -{ - kkps_->value( KKps); - kkps_->genValue( KKps); - kkps_->initValue( KKps); -} -void LauRescatteringRes::setMF(const Double_t mff) + +void LauRescatteringRes::setMf(const Double_t Mf) { - Mf_->value( mff ); - Mf_->genValue( mff ); - Mf_->initValue( mff ); + Mf_->value( Mf ); + Mf_->genValue( Mf ); + Mf_->initValue( Mf ); } -void LauRescatteringRes::setMS(const Double_t mss) + +void LauRescatteringRes::setMs(const Double_t Ms) { - Ms_->value( mss ); - Ms_->genValue( mss ); - Ms_->initValue( mss ); + Ms_->value( Ms ); + Ms_->genValue( Ms ); + Ms_->initValue( Ms ); } -void LauRescatteringRes::setMPrime(const Double_t mprimee) + +void LauRescatteringRes::setMprime(const Double_t Mprime) { - Mprime_->value( mprimee ); - Mprime_->genValue( mprimee); - Mprime_->initValue( mprimee ); + Mprime_->value( Mprime ); + Mprime_->genValue( Mprime); + Mprime_->initValue( Mprime ); } -void LauRescatteringRes::setBETA(const Double_t betaa) + +void LauRescatteringRes::setEps1(const Double_t Eps1) { - Beta_->value( betaa ); - Beta_->genValue( betaa ); - Beta_->initValue( betaa ); + Eps1_->value( Eps1 ); + Eps1_->genValue( Eps1 ); + Eps1_->initValue( Eps1 ); } -void LauRescatteringRes::setEPSA(const Double_t epsaa) + +void LauRescatteringRes::setEps2(const Double_t Eps2) { - EpsA_->value( epsaa ); - EpsA_->genValue( epsaa ); - EpsA_->initValue( epsaa ); + Eps2_->value( Eps2 ); + Eps2_->genValue( Eps2 ); + Eps2_->initValue( Eps2 ); } -void LauRescatteringRes::setEPSB(const Double_t epsbb) + +void LauRescatteringRes::setC0(const Double_t C0) { - EpsB_->value( epsbb ); - EpsB_->genValue( epsbb ); - EpsB_->initValue( epsbb ); + C0_->value( C0 ); + C0_->genValue( C0 ); + C0_->initValue( C0 ); } diff --git a/src/LauResonanceMaker.cc b/src/LauResonanceMaker.cc index 29ecf5c..03caa26 100644 --- a/src/LauResonanceMaker.cc +++ b/src/LauResonanceMaker.cc @@ -1,972 +1,983 @@ /* Copyright 2004 University of Warwick Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. */ /* Laura++ package authors: John Back Paul Harrison Thomas Latham */ /*! \file LauResonanceMaker.cc \brief File containing implementation of LauResonanceMaker class. */ #include #include "LauAbsResonance.hh" #include "LauBelleNR.hh" #include "LauBelleSymNR.hh" #include "LauBreitWignerRes.hh" #include "LauDabbaRes.hh" #include "LauDaughters.hh" #include "LauEFKLLMRes.hh" #include "LauFlatteRes.hh" #include "LauFlatNR.hh" #include "LauGaussIncohRes.hh" #include "LauGounarisSakuraiRes.hh" #include "LauKappaRes.hh" #include "LauLASSRes.hh" #include "LauLASSBWRes.hh" #include "LauLASSNRRes.hh" #include "LauModIndPartWaveMagPhase.hh" #include "LauModIndPartWaveRealImag.hh" #include "LauNRAmplitude.hh" #include "LauRescatteringRes.hh" #include "LauPolNR.hh" #include "LauPoleRes.hh" #include "LauPolarFormFactorNR.hh" #include "LauPolarFormFactorSymNR.hh" #include "LauRelBreitWignerRes.hh" #include "LauResonanceInfo.hh" #include "LauResonanceMaker.hh" #include "LauRhoOmegaMix.hh" #include "LauSigmaRes.hh" ClassImp(LauResonanceMaker); LauResonanceMaker* LauResonanceMaker::resonanceMaker_ = 0; LauResonanceMaker::LauResonanceMaker() : nResDefMax_(0), bwBarrierType_(LauBlattWeisskopfFactor::BWPrimeBarrier), bwRestFrame_(LauBlattWeisskopfFactor::ResonanceFrame), spinFormalism_(LauAbsResonance::Zemach_P), summaryPrinted_(kFALSE) { this->createResonanceVector(); this->setDefaultBWRadius( LauBlattWeisskopfFactor::Parent, 4.0 ); } LauResonanceMaker::~LauResonanceMaker() { for ( std::vector::iterator iter = bwIndepFactors_.begin(); iter != bwIndepFactors_.end(); ++iter ) { delete *iter; } bwIndepFactors_.clear(); for ( BWFactorCategoryMap::iterator iter = bwFactors_.begin(); iter != bwFactors_.end(); ++iter ) { delete iter->second.bwFactor_; } bwFactors_.clear(); } LauResonanceMaker& LauResonanceMaker::get() { if ( resonanceMaker_ == 0 ) { resonanceMaker_ = new LauResonanceMaker(); } return *resonanceMaker_; } void LauResonanceMaker::createResonanceVector() { // Function to create all possible resonances that this class supports. // Also add in the sigma and kappa - but a special paramterisation is used // instead of the PDG "pole mass and width" values. std::cout << "INFO in LauResonanceMaker::createResonanceVector : Setting up possible resonance states..." << std::endl; LauResonanceInfo* neutral(0); LauResonanceInfo* positve(0); LauResonanceInfo* negatve(0); // Define the resonance names and store them in the array resInfo_.clear(); resInfo_.reserve(100); // rho resonances name, mass, width, spin, charge, default BW category, BW radius parameter (defaults to 4.0) // rho(770) neutral = new LauResonanceInfo("rho0(770)", 0.77526, 0.1478, 1, 0, LauBlattWeisskopfFactor::Light, 5.3); positve = new LauResonanceInfo("rho+(770)", 0.77511, 0.1491, 1, 1, LauBlattWeisskopfFactor::Light, 5.3); negatve = positve->createChargeConjugate(); resInfo_.push_back( neutral ); resInfo_.push_back( positve ); resInfo_.push_back( negatve ); // The following two lines of code are placed here in order to allow the following, rather niche, scenario: // The LauRhoOmegaMix code permits (through the use of the optional independentPar argument of LauResonanceInfo::addExtraParameter) the magnitude and phase of the rho/omega mixing to potentially differ between the decay of the parent particle to rho0 X and the parent antiparticle to rho0 Xbar. // This can be acheived by using the rho0(770) record in one case and the rho0(770)_COPY record in the other. neutral = neutral->createSharedParameterRecord("rho0(770)_COPY"); resInfo_.push_back( neutral ); // rho(1450) neutral = new LauResonanceInfo("rho0(1450)", 1.465, 0.400, 1, 0, LauBlattWeisskopfFactor::Light ); positve = new LauResonanceInfo("rho+(1450)", 1.465, 0.400, 1, 1, LauBlattWeisskopfFactor::Light ); negatve = positve->createChargeConjugate(); resInfo_.push_back( neutral ); resInfo_.push_back( positve ); resInfo_.push_back( negatve ); // rho_3(1690) neutral = new LauResonanceInfo("rho0_3(1690)", 1.686, 0.186, 3, 0, LauBlattWeisskopfFactor::Light ); positve = new LauResonanceInfo("rho+_3(1690)", 1.686, 0.186, 3, 1, LauBlattWeisskopfFactor::Light ); negatve = positve->createChargeConjugate(); resInfo_.push_back( neutral ); resInfo_.push_back( positve ); resInfo_.push_back( negatve ); // rho(1700) neutral = new LauResonanceInfo("rho0(1700)", 1.720, 0.250, 1, 0, LauBlattWeisskopfFactor::Light ); positve = new LauResonanceInfo("rho+(1700)", 1.720, 0.250, 1, 1, LauBlattWeisskopfFactor::Light ); negatve = positve->createChargeConjugate(); resInfo_.push_back( neutral ); resInfo_.push_back( positve ); resInfo_.push_back( negatve ); // rho(1900) neutral = new LauResonanceInfo("rho0(1900)", 1.909, 0.130, 1, 0, LauBlattWeisskopfFactor::Light ); positve = new LauResonanceInfo("rho+(1900)", 1.909, 0.130, 1, 1, LauBlattWeisskopfFactor::Light ); negatve = positve->createChargeConjugate(); resInfo_.push_back( neutral ); resInfo_.push_back( positve ); resInfo_.push_back( negatve ); // rho_3(1990) neutral = new LauResonanceInfo("rho0_3(1990)", 1.982, 0.188, 3, 0, LauBlattWeisskopfFactor::Light ); positve = new LauResonanceInfo("rho+_3(1990)", 1.982, 0.188, 3, 1, LauBlattWeisskopfFactor::Light ); negatve = positve->createChargeConjugate(); resInfo_.push_back( neutral ); resInfo_.push_back( positve ); resInfo_.push_back( negatve ); // K* resonances name, mass, width, spin, charge, BW category, BW radius parameter (defaults to 4.0) // K*(892) neutral = new LauResonanceInfo("K*0(892)", 0.89581, 0.0474, 1, 0, LauBlattWeisskopfFactor::Kstar, 3.0); positve = new LauResonanceInfo("K*+(892)", 0.89166, 0.0508, 1, 1, LauBlattWeisskopfFactor::Kstar, 3.0); negatve = positve->createChargeConjugate(); resInfo_.push_back( neutral ); resInfo_.push_back( positve ); resInfo_.push_back( negatve ); // K*(1410) neutral = new LauResonanceInfo("K*0(1410)", 1.414, 0.232, 1, 0, LauBlattWeisskopfFactor::Kstar ); positve = new LauResonanceInfo("K*+(1410)", 1.414, 0.232, 1, 1, LauBlattWeisskopfFactor::Kstar ); negatve = positve->createChargeConjugate(); resInfo_.push_back( neutral ); resInfo_.push_back( positve ); resInfo_.push_back( negatve ); // K*_0(1430) neutral = new LauResonanceInfo("K*0_0(1430)", 1.425, 0.270, 0, 0, LauBlattWeisskopfFactor::Kstar ); positve = new LauResonanceInfo("K*+_0(1430)", 1.425, 0.270, 0, 1, LauBlattWeisskopfFactor::Kstar ); negatve = positve->createChargeConjugate(); resInfo_.push_back( neutral ); resInfo_.push_back( positve ); resInfo_.push_back( negatve ); // LASS nonresonant model neutral = neutral->createSharedParameterRecord("LASSNR0"); positve = positve->createSharedParameterRecord("LASSNR+"); negatve = negatve->createSharedParameterRecord("LASSNR-"); resInfo_.push_back( neutral ); resInfo_.push_back( positve ); resInfo_.push_back( negatve ); // K*_2(1430) neutral = new LauResonanceInfo("K*0_2(1430)", 1.4324, 0.109, 2, 0, LauBlattWeisskopfFactor::Kstar ); positve = new LauResonanceInfo("K*+_2(1430)", 1.4256, 0.0985, 2, 1, LauBlattWeisskopfFactor::Kstar ); negatve = positve->createChargeConjugate(); resInfo_.push_back( neutral ); resInfo_.push_back( positve ); resInfo_.push_back( negatve ); // K*(1680) neutral = new LauResonanceInfo("K*0(1680)", 1.717, 0.322, 1, 0, LauBlattWeisskopfFactor::Kstar ); positve = new LauResonanceInfo("K*+(1680)", 1.717, 0.322, 1, 1, LauBlattWeisskopfFactor::Kstar ); negatve = positve->createChargeConjugate(); resInfo_.push_back( neutral ); resInfo_.push_back( positve ); resInfo_.push_back( negatve ); // K*(1950) neutral = new LauResonanceInfo("K*0_0(1950)", 1.945, 0.201, 0, 0, LauBlattWeisskopfFactor::Kstar ); positve = new LauResonanceInfo("K*+_0(1950)", 1.945, 0.201, 0, 1, LauBlattWeisskopfFactor::Kstar ); negatve = positve->createChargeConjugate(); resInfo_.push_back( neutral ); resInfo_.push_back( positve ); resInfo_.push_back( negatve ); // phi resonances name, mass, width, spin, charge, BW category, BW radius parameter (defaults to 4.0) // phi(1020) neutral = new LauResonanceInfo("phi(1020)", 1.019461, 0.004266, 1, 0, LauBlattWeisskopfFactor::Light ); resInfo_.push_back( neutral ); // phi(1680) neutral = new LauResonanceInfo("phi(1680)", 1.680, 0.150, 1, 0, LauBlattWeisskopfFactor::Light ); resInfo_.push_back( neutral ); // f resonances name, mass, width, spin, charge, BW category, BW radius parameter (defaults to 4.0) // f_0(980) neutral = new LauResonanceInfo("f_0(980)", 0.990, 0.070, 0, 0, LauBlattWeisskopfFactor::Light ); resInfo_.push_back( neutral ); // f_2(1270) neutral = new LauResonanceInfo("f_2(1270)", 1.2751, 0.1851, 2, 0, LauBlattWeisskopfFactor::Light ); resInfo_.push_back( neutral ); // f_0(1370) neutral = new LauResonanceInfo("f_0(1370)", 1.370, 0.350, 0, 0, LauBlattWeisskopfFactor::Light ); resInfo_.push_back( neutral ); // f'_0(1300), from Belle's Kspipi paper neutral = new LauResonanceInfo("f'_0(1300)", 1.449, 0.126, 0, 0, LauBlattWeisskopfFactor::Light ); resInfo_.push_back( neutral ); // f_2(1430) neutral = new LauResonanceInfo("f_2(1430)", 1.430, 0.150, 2, 0, LauBlattWeisskopfFactor::Light ); // PDG width in the range 13 - 150 resInfo_.push_back( neutral ); // f_0(1500) neutral = new LauResonanceInfo("f_0(1500)", 1.505, 0.109, 0, 0, LauBlattWeisskopfFactor::Light ); resInfo_.push_back( neutral ); // f'_2(1525) neutral = new LauResonanceInfo("f'_2(1525)", 1.525, 0.073, 2, 0, LauBlattWeisskopfFactor::Light ); resInfo_.push_back( neutral ); // f_2(1565) neutral = new LauResonanceInfo("f_2(1565)", 1.562, 0.134, 2, 0, LauBlattWeisskopfFactor::Light ); resInfo_.push_back( neutral ); // f_2(1640) neutral = new LauResonanceInfo("f_2(1640)", 1.639, 0.099, 2, 0, LauBlattWeisskopfFactor::Light ); resInfo_.push_back( neutral ); // f_0(1710) neutral = new LauResonanceInfo("f_0(1710)", 1.722, 0.135, 0, 0, LauBlattWeisskopfFactor::Light ); resInfo_.push_back( neutral ); // f_2(1810) neutral = new LauResonanceInfo("f_2(1810)", 1.816, 0.197, 2, 0, LauBlattWeisskopfFactor::Light ); resInfo_.push_back( neutral ); // f_2(1910) neutral = new LauResonanceInfo("f_2(1910)", 1.903, 0.196, 2, 0, LauBlattWeisskopfFactor::Light ); resInfo_.push_back( neutral ); // f_2(1950) neutral = new LauResonanceInfo("f_2(1950)", 1.944, 0.472, 2, 0, LauBlattWeisskopfFactor::Light ); resInfo_.push_back( neutral ); // f_2(2010) neutral = new LauResonanceInfo("f_2(2010)", 2.011, 0.202, 2, 0, LauBlattWeisskopfFactor::Light ); resInfo_.push_back( neutral ); // f_0(2020) neutral = new LauResonanceInfo("f_0(2020)", 1.992, 0.442, 0, 0, LauBlattWeisskopfFactor::Light ); resInfo_.push_back( neutral ); // f_4(2050) neutral = new LauResonanceInfo("f_4(2050)", 2.018, 0.237, 4, 0, LauBlattWeisskopfFactor::Light ); resInfo_.push_back( neutral ); // f_0(2100) neutral = new LauResonanceInfo("f_0(2100)", 2.101, 0.224, 0, 0, LauBlattWeisskopfFactor::Light ); resInfo_.push_back( neutral ); // omega resonances name, mass, width, spin, charge, BW category, BW radius parameter (defaults to 4.0) // omega(782) neutral = new LauResonanceInfo("omega(782)", 0.78265, 0.00849, 1, 0, LauBlattWeisskopfFactor::Light ); resInfo_.push_back( neutral ); // a resonances name, mass, width, spin, charge, BW category, BW radius parameter (defaults to 4.0) // a_0(980) neutral = new LauResonanceInfo("a0_0(980)", 0.980, 0.092, 0, 0, LauBlattWeisskopfFactor::Light ); positve = new LauResonanceInfo("a+_0(980)", 0.980, 0.092, 0, 1, LauBlattWeisskopfFactor::Light ); negatve = positve->createChargeConjugate(); resInfo_.push_back( neutral ); resInfo_.push_back( positve ); resInfo_.push_back( negatve ); // a_0(1450) neutral = new LauResonanceInfo("a0_0(1450)", 1.474, 0.265, 0, 0, LauBlattWeisskopfFactor::Light ); positve = new LauResonanceInfo("a+_0(1450)", 1.474, 0.265, 0, 1, LauBlattWeisskopfFactor::Light ); negatve = positve->createChargeConjugate(); resInfo_.push_back( neutral ); resInfo_.push_back( positve ); resInfo_.push_back( negatve ); // a_2(1320) neutral = new LauResonanceInfo("a0_2(1320)", 1.3190, 0.1050, 2, 0, LauBlattWeisskopfFactor::Light ); positve = new LauResonanceInfo("a+_2(1320)", 1.3190, 0.1050, 2, 1, LauBlattWeisskopfFactor::Light ); negatve = positve->createChargeConjugate(); resInfo_.push_back( neutral ); resInfo_.push_back( positve ); resInfo_.push_back( negatve ); // charmonium resonances name, mass, width, spin, charge, BW category, BW radius parameter (defaults to 4.0) // chi_c0 neutral = new LauResonanceInfo("chi_c0", 3.41475, 0.0105, 0, 0, LauBlattWeisskopfFactor::Charmonium ); resInfo_.push_back( neutral ); // chi_c1 neutral = new LauResonanceInfo("chi_c1", 3.51066, 0.00084, 0, 0, LauBlattWeisskopfFactor::Charmonium ); resInfo_.push_back( neutral ); // chi_c2 neutral = new LauResonanceInfo("chi_c2", 3.55620, 0.00193, 2, 0, LauBlattWeisskopfFactor::Charmonium ); resInfo_.push_back( neutral ); // X(3872) neutral = new LauResonanceInfo("X(3872)", 3.87169, 0.0012, 1, 0, LauBlattWeisskopfFactor::Charmonium ); resInfo_.push_back( neutral ); // unknown scalars name, mass, width, spin, charge, BW category, BW radius parameter (defaults to 4.0) // sigma neutral = new LauResonanceInfo("sigma0", 0.475, 0.550, 0, 0, LauBlattWeisskopfFactor::Light ); positve = new LauResonanceInfo("sigma+", 0.475, 0.550, 0, 1, LauBlattWeisskopfFactor::Light ); negatve = positve->createChargeConjugate(); resInfo_.push_back( neutral ); resInfo_.push_back( positve ); resInfo_.push_back( negatve ); // kappa neutral = new LauResonanceInfo("kappa0", 0.682, 0.547, 0, 0, LauBlattWeisskopfFactor::Kstar ); positve = new LauResonanceInfo("kappa+", 0.682, 0.547, 0, 1, LauBlattWeisskopfFactor::Kstar ); negatve = positve->createChargeConjugate(); resInfo_.push_back( neutral ); resInfo_.push_back( positve ); resInfo_.push_back( negatve ); // dabba neutral = new LauResonanceInfo("dabba0", 2.098, 0.520, 0, 0, LauBlattWeisskopfFactor::Charm ); positve = new LauResonanceInfo("dabba+", 2.098, 0.520, 0, 1, LauBlattWeisskopfFactor::Charm ); negatve = positve->createChargeConjugate(); resInfo_.push_back( neutral ); resInfo_.push_back( positve ); resInfo_.push_back( negatve ); // excited charm states name, mass, width, spin, charge, BW category, BW radius parameter (defaults to 4.0) // D* neutral = new LauResonanceInfo("D*0", 2.00696, 0.0021, 1, 0, LauBlattWeisskopfFactor::Charm ); positve = new LauResonanceInfo("D*+", 2.01026, 83.4e-6, 1, 1, LauBlattWeisskopfFactor::Charm ); negatve = positve->createChargeConjugate(); resInfo_.push_back( neutral ); resInfo_.push_back( positve ); resInfo_.push_back( negatve ); // D*_0 neutral = new LauResonanceInfo("D*0_0", 2.318, 0.267, 0, 0, LauBlattWeisskopfFactor::Charm ); positve = new LauResonanceInfo("D*+_0", 2.403, 0.283, 0, 1, LauBlattWeisskopfFactor::Charm ); negatve = positve->createChargeConjugate(); resInfo_.push_back( neutral ); resInfo_.push_back( positve ); resInfo_.push_back( negatve ); // D*_2 //AVERAGE--neutral = new LauResonanceInfo("D*0_2", 2.4618, 0.049, 2, 0 ); neutral = new LauResonanceInfo("D*0_2", 2.4626, 0.049, 2, 0, LauBlattWeisskopfFactor::Charm ); positve = new LauResonanceInfo("D*+_2", 2.4643, 0.037, 2, 1, LauBlattWeisskopfFactor::Charm ); negatve = positve->createChargeConjugate(); resInfo_.push_back( neutral ); resInfo_.push_back( positve ); resInfo_.push_back( negatve ); // D1(2420) neutral = new LauResonanceInfo("D0_1(2420)", 2.4214, 0.0274, 1, 0, LauBlattWeisskopfFactor::Charm ); positve = new LauResonanceInfo("D+_1(2420)", 2.4232, 0.025, 1, 1, LauBlattWeisskopfFactor::Charm ); negatve = positve->createChargeConjugate(); resInfo_.push_back( neutral ); resInfo_.push_back( positve ); resInfo_.push_back( negatve ); // D(2600) //OLD--neutral = new LauResonanceInfo("D0(2600)", 2.6087, 0.093, 0, 0 ); //OLD--positve = new LauResonanceInfo("D+(2600)", 2.6213, 0.093, 0, 1 ); neutral = new LauResonanceInfo("D0(2600)", 2.612, 0.093, 0, 0, LauBlattWeisskopfFactor::Charm ); positve = new LauResonanceInfo("D+(2600)", 2.612, 0.093, 0, 1, LauBlattWeisskopfFactor::Charm ); negatve = positve->createChargeConjugate(); resInfo_.push_back( neutral ); resInfo_.push_back( positve ); resInfo_.push_back( negatve ); // D(2760) //OLD-- neutral = new LauResonanceInfo("D0(2760)", 2.7633, 0.061, 1, 0 ); //OLD-- positve = new LauResonanceInfo("D+(2760)", 2.7697, 0.061, 1, 1 ); neutral = new LauResonanceInfo("D0(2760)", 2.761, 0.063, 1, 0, LauBlattWeisskopfFactor::Charm ); positve = new LauResonanceInfo("D+(2760)", 2.761, 0.063, 1, 1, LauBlattWeisskopfFactor::Charm ); negatve = positve->createChargeConjugate(); resInfo_.push_back( neutral ); resInfo_.push_back( positve ); resInfo_.push_back( negatve ); // D(2900) neutral = new LauResonanceInfo("D0(3000)", 3.0, 0.15, 0, 0, LauBlattWeisskopfFactor::Charm ); resInfo_.push_back( neutral ); // D(3400) neutral = new LauResonanceInfo("D0(3400)", 3.4, 0.15, 0, 0, LauBlattWeisskopfFactor::Charm ); resInfo_.push_back( neutral ); // excited strange charm name, mass, width, spin, charge, BW category, BW radius parameter (defaults to 4.0) // Ds* positve = new LauResonanceInfo("Ds*+", 2.1121, 0.0019, 1, 1, LauBlattWeisskopfFactor::StrangeCharm ); negatve = positve->createChargeConjugate(); resInfo_.push_back( positve ); resInfo_.push_back( negatve ); // Ds0*(2317) positve = new LauResonanceInfo("Ds*+_0(2317)", 2.3177, 0.0038, 0, 1, LauBlattWeisskopfFactor::StrangeCharm ); negatve = positve->createChargeConjugate(); resInfo_.push_back( positve ); resInfo_.push_back( negatve ); // Ds2*(2573) positve = new LauResonanceInfo("Ds*+_2(2573)", 2.5719, 0.017, 2, 1, LauBlattWeisskopfFactor::StrangeCharm ); negatve = positve->createChargeConjugate(); resInfo_.push_back( positve ); resInfo_.push_back( negatve ); // Ds1*(2700) positve = new LauResonanceInfo("Ds*+_1(2700)", 2.709, 0.117, 1, 1, LauBlattWeisskopfFactor::StrangeCharm ); negatve = positve->createChargeConjugate(); resInfo_.push_back( positve ); resInfo_.push_back( negatve ); // Ds1*(2860) positve = new LauResonanceInfo("Ds*+_1(2860)", 2.862, 0.180, 1, 1, LauBlattWeisskopfFactor::StrangeCharm ); negatve = positve->createChargeConjugate(); resInfo_.push_back( positve ); resInfo_.push_back( negatve ); // Ds3*(2860) positve = new LauResonanceInfo("Ds*+_3(2860)", 2.862, 0.058, 3, 1, LauBlattWeisskopfFactor::StrangeCharm ); negatve = positve->createChargeConjugate(); resInfo_.push_back( positve ); resInfo_.push_back( negatve ); // excited bottom states name, mass, width, spin, charge, BW category, BW radius parameter (defaults to 4.0) // B* neutral = new LauResonanceInfo("B*0", 5.3252, 0.00, 1, 0, LauBlattWeisskopfFactor::Beauty, 6.0); positve = new LauResonanceInfo("B*+", 5.3252, 0.00, 1, 1, LauBlattWeisskopfFactor::Beauty, 6.0); negatve = positve->createChargeConjugate(); resInfo_.push_back( neutral ); resInfo_.push_back( positve ); resInfo_.push_back( negatve ); // excited strange bottom name, mass, width, spin, charge, BW category, BW radius parameter (defaults to 4.0) // Bs* neutral = new LauResonanceInfo("Bs*0", 5.4154, 0.00, 1, 0, LauBlattWeisskopfFactor::StrangeBeauty, 6.0); resInfo_.push_back( neutral ); // nonresonant models name, mass, width, spin, charge, BW category, BW radius parameter (defaults to 4.0) // Phase-space nonresonant model neutral = new LauResonanceInfo("NonReson", 0.0, 0.0, 0, 0, LauBlattWeisskopfFactor::Light ); resInfo_.push_back( neutral ); // Theory-based nonresonant model neutral = new LauResonanceInfo("NRModel", 0.0, 0.0, 0, 0, LauBlattWeisskopfFactor::Light ); resInfo_.push_back( neutral ); // Belle nonresonant models neutral = new LauResonanceInfo("BelleSymNR", 0.0, 0.0, 0, 0, LauBlattWeisskopfFactor::Light ); resInfo_.push_back( neutral ); neutral = new LauResonanceInfo("BelleNR", 0.0, 0.0, 0, 0, LauBlattWeisskopfFactor::Light ); resInfo_.push_back( neutral ); positve = new LauResonanceInfo("BelleNR+", 0.0, 0.0, 0, 1, LauBlattWeisskopfFactor::Light ); negatve = positve->createChargeConjugate(); resInfo_.push_back( positve ); resInfo_.push_back( negatve ); neutral = new LauResonanceInfo("BelleNR_Swave", 0.0, 0.0, 0, 0, LauBlattWeisskopfFactor::Light ); resInfo_.push_back( neutral ); positve = new LauResonanceInfo("BelleNR_Swave+",0.0, 0.0, 0, 1, LauBlattWeisskopfFactor::Light ); negatve = positve->createChargeConjugate(); resInfo_.push_back( positve ); resInfo_.push_back( negatve ); neutral = new LauResonanceInfo("BelleNR_Pwave", 0.0, 0.0, 1, 0, LauBlattWeisskopfFactor::Light ); resInfo_.push_back( neutral ); positve = new LauResonanceInfo("BelleNR_Pwave+",0.0, 0.0, 1, 1, LauBlattWeisskopfFactor::Light ); negatve = positve->createChargeConjugate(); resInfo_.push_back( positve ); resInfo_.push_back( negatve ); neutral = new LauResonanceInfo("BelleNR_Dwave", 0.0, 0.0, 2, 0, LauBlattWeisskopfFactor::Light ); resInfo_.push_back( neutral ); positve = new LauResonanceInfo("BelleNR_Dwave+",0.0, 0.0, 2, 1, LauBlattWeisskopfFactor::Light ); negatve = positve->createChargeConjugate(); resInfo_.push_back( positve ); resInfo_.push_back( negatve ); neutral = new LauResonanceInfo("BelleNR_Fwave", 0.0, 0.0, 3, 0, LauBlattWeisskopfFactor::Light ); resInfo_.push_back( neutral ); positve = new LauResonanceInfo("BelleNR_Fwave+",0.0, 0.0, 3, 1, LauBlattWeisskopfFactor::Light ); negatve = positve->createChargeConjugate(); resInfo_.push_back( positve ); resInfo_.push_back( negatve ); // Taylor expansion nonresonant model neutral = new LauResonanceInfo("NRTaylor", 0.0, 0.0, 0, 0, LauBlattWeisskopfFactor::Light ); resInfo_.push_back( neutral ); // Polynomial nonresonant models neutral = new LauResonanceInfo("PolNR_S0", 0.0, 0.0, 0, 0, LauBlattWeisskopfFactor::Light ); resInfo_.push_back( neutral ); neutral = new LauResonanceInfo("PolNR_S1", 0.0, 0.0, 0, 0, LauBlattWeisskopfFactor::Light ); resInfo_.push_back( neutral ); neutral = new LauResonanceInfo("PolNR_S2", 0.0, 0.0, 0, 0, LauBlattWeisskopfFactor::Light ); resInfo_.push_back( neutral ); neutral = new LauResonanceInfo("PolNR_P0", 0.0, 0.0, 1, 0, LauBlattWeisskopfFactor::Light ); resInfo_.push_back( neutral ); neutral = new LauResonanceInfo("PolNR_P1", 0.0, 0.0, 1, 0, LauBlattWeisskopfFactor::Light ); resInfo_.push_back( neutral ); neutral = new LauResonanceInfo("PolNR_P2", 0.0, 0.0, 1, 0, LauBlattWeisskopfFactor::Light ); resInfo_.push_back( neutral ); // Fake resonances for S-Wave splines neutral = new LauResonanceInfo("Spline_S0", 0.0, 0.0, 0, 0, LauBlattWeisskopfFactor::Light ); resInfo_.push_back( neutral ); neutral = new LauResonanceInfo("Spline_S0_Bar", 0.0, 0.0, 0, 0, LauBlattWeisskopfFactor::Light ); resInfo_.push_back( neutral ); + // Polar Form Factor nonresonant model + neutral = new LauResonanceInfo("PolarFFSymNR", 0.0, 0.0, 0, 0, LauBlattWeisskopfFactor::Light ); + resInfo_.push_back( neutral ); + neutral = new LauResonanceInfo("PolarFFNR", 0.0, 0.0, 0, 0, LauBlattWeisskopfFactor::Light ); + resInfo_.push_back( neutral ); + + // PiPi-KK Inelastic Scattering + neutral = new LauResonanceInfo("Rescattering", 0.0, 0.0, 0, 0, LauBlattWeisskopfFactor::Light ); + resInfo_.push_back( neutral ); + nResDefMax_ = resInfo_.size(); } void LauResonanceMaker::setBWType(const LauBlattWeisskopfFactor::BarrierType bwType) { // Check whether any BW factors have been created and bail out if so if ( ! bwIndepFactors_.empty() ) { std::cerr << "ERROR in LauResonanceMaker::setBWType : some barrier factors have already been created - cannot change the barrier type now!" << std::endl; return; } for ( BWFactorCategoryMap::const_iterator iter = bwFactors_.begin(); iter != bwFactors_.end(); ++iter ) { if ( iter->second.bwFactor_ != 0 ) { std::cerr << "ERROR in LauResonanceMaker::setBWType : some barrier factors have already been created - cannot change the barrier type now!" << std::endl; return; } } bwBarrierType_ = bwType; } void LauResonanceMaker::setBWBachelorRestFrame(const LauBlattWeisskopfFactor::RestFrame restFrame) { // Check whether any BW factors have been created and bail out if so if ( ! bwIndepFactors_.empty() ) { std::cerr << "ERROR in LauResonanceMaker::setBWBachelorRestFrame : some barrier factors have already been created - cannot change the rest frame now!" << std::endl; return; } for ( BWFactorCategoryMap::const_iterator iter = bwFactors_.begin(); iter != bwFactors_.end(); ++iter ) { if ( iter->second.bwFactor_ != 0 ) { std::cerr << "ERROR in LauResonanceMaker::setBWBachelorRestFrame : some barrier factors have already been created - cannot change the rest frame now!" << std::endl; return; } } bwRestFrame_ = restFrame; } void LauResonanceMaker::setSpinFormalism(const LauAbsResonance::LauSpinType spinType) { if ( summaryPrinted_ ) { std::cerr << "ERROR in LauResonanceMaker::setSpinFormalism : cannot redefine the spin formalism after creating one or more resonances" << std::endl; return; } spinFormalism_ = spinType; } void LauResonanceMaker::setDefaultBWRadius(const LauBlattWeisskopfFactor::BlattWeisskopfCategory bwCategory, const Double_t bwRadius) { if ( bwCategory == LauBlattWeisskopfFactor::Default || bwCategory == LauBlattWeisskopfFactor::Indep ) { std::cerr << "WARNING in LauResonanceMaker::setDefaultBWRadius : cannot set radius values for Default or Indep categories" << std::endl; return; } // Check if we have an information object for this category BWFactorCategoryMap::iterator factor_iter = bwFactors_.find( bwCategory ); if ( factor_iter != bwFactors_.end() ) { // If so, we can set the value in the information object BlattWeisskopfCategoryInfo& categoryInfo = factor_iter->second; categoryInfo.defaultRadius_ = bwRadius; // Then we can check if a LauBlattWeisskopfFactor object has been created for this category LauBlattWeisskopfFactor* bwFactor = categoryInfo.bwFactor_; if ( bwFactor != 0 ) { // If it has then we can also set its radius value directly LauParameter* radius = bwFactor->getRadiusParameter(); radius->value(bwRadius); radius->initValue(bwRadius); radius->genValue(bwRadius); } } else { // If not then we just store the value to be used later BlattWeisskopfCategoryInfo& categoryInfo = bwFactors_[bwCategory]; categoryInfo.bwFactor_ = 0; categoryInfo.defaultRadius_ = bwRadius; categoryInfo.radiusFixed_ = kTRUE; } } void LauResonanceMaker::fixBWRadius(const LauBlattWeisskopfFactor::BlattWeisskopfCategory bwCategory, const Bool_t fixRadius) { if ( bwCategory == LauBlattWeisskopfFactor::Default || bwCategory == LauBlattWeisskopfFactor::Indep ) { std::cerr << "WARNING in LauResonanceMaker::fixBWRadius : cannot fix/float radius values for Default or Indep categories" << std::endl; return; } // Check if we have an information object for this category BWFactorCategoryMap::iterator factor_iter = bwFactors_.find( bwCategory ); if ( factor_iter != bwFactors_.end() ) { // If so, we can set the value in the information object BlattWeisskopfCategoryInfo& categoryInfo = factor_iter->second; categoryInfo.radiusFixed_ = fixRadius; // Then we can check if a LauBlattWeisskopfFactor object has been created for this category LauBlattWeisskopfFactor* bwFactor = categoryInfo.bwFactor_; if ( bwFactor != 0 ) { // If it has then we can also fix/float its radius value directly LauParameter* radius = bwFactor->getRadiusParameter(); radius->fixed(fixRadius); } } else { // If not then we just store the value to be used later BlattWeisskopfCategoryInfo& categoryInfo = bwFactors_[bwCategory]; categoryInfo.bwFactor_ = 0; categoryInfo.defaultRadius_ = -1.0; categoryInfo.radiusFixed_ = fixRadius; } } LauBlattWeisskopfFactor* LauResonanceMaker::getBWFactor( const LauBlattWeisskopfFactor::BlattWeisskopfCategory bwCategory, const LauResonanceInfo* resInfo ) { LauBlattWeisskopfFactor* bwFactor(0); // If this is an independent factor, create it and add it to the list of independent factors, then return it if ( bwCategory == LauBlattWeisskopfFactor::Indep ) { bwFactor = new LauBlattWeisskopfFactor( *resInfo, bwBarrierType_, bwRestFrame_, bwCategory ); bwIndepFactors_.push_back(bwFactor); return bwFactor; } // Otherwise, look up the category in the category information map BWFactorCategoryMap::iterator factor_iter = bwFactors_.find( bwCategory ); if ( factor_iter == bwFactors_.end() ) { // If the category is currently undefined we need to create it bwFactor = new LauBlattWeisskopfFactor( *resInfo, bwBarrierType_, bwRestFrame_, bwCategory ); BlattWeisskopfCategoryInfo& categoryInfo = bwFactors_[bwCategory]; categoryInfo.bwFactor_ = bwFactor; categoryInfo.defaultRadius_ = bwFactor->getRadiusParameter()->value(); categoryInfo.radiusFixed_ = kTRUE; } else { // If it exists, we can check if the factor object has been created BlattWeisskopfCategoryInfo& categoryInfo = factor_iter->second; if ( categoryInfo.bwFactor_ != 0 ) { // If so, simply clone it const UInt_t resSpin = resInfo->getSpin(); bwFactor = categoryInfo.bwFactor_->createClone( resSpin ); } else { // Otherwise we need to create it, using the default value if it has been set if ( categoryInfo.defaultRadius_ >= 0.0 ) { bwFactor = new LauBlattWeisskopfFactor( *resInfo, categoryInfo.defaultRadius_, bwBarrierType_, bwRestFrame_, bwCategory ); } else { bwFactor = new LauBlattWeisskopfFactor( *resInfo, bwBarrierType_, bwRestFrame_, bwCategory ); } categoryInfo.bwFactor_ = bwFactor; // Set whether the radius should be fixed/floated LauParameter* radius = bwFactor->getRadiusParameter(); radius->fixed( categoryInfo.radiusFixed_ ); } } return bwFactor; } LauAbsResonance* LauResonanceMaker::getResonance(const LauDaughters* daughters, const TString& resName, const Int_t resPairAmpInt, const LauAbsResonance::LauResonanceModel resType, const LauBlattWeisskopfFactor::BlattWeisskopfCategory bwCategory) { // Routine to return the appropriate LauAbsResonance object given the resonance // name (resName), which daughter is the bachelor track (resPairAmpInt = 1,2 or 3), // and the resonance type ("BW" = Breit-Wigner, "Flatte" = Flatte distribution). // If this is the first resonance we are making, first print a summary of the formalism if ( ! summaryPrinted_ ) { std::cout << "INFO in LauResonanceMaker::getResonance : Freezing amplitude formalism:" << std::endl; switch ( spinFormalism_ ) { case LauAbsResonance::Zemach_P : std::cout << " : Spin factors use Zemach spin tensors, with bachelor momentum in resonance rest frame" << std::endl; break; case LauAbsResonance::Zemach_Pstar : std::cout << " : Spin factors use Zemach spin tensors, with bachelor momentum in parent rest frame" << std::endl; break; case LauAbsResonance::Covariant : std::cout << " : Spin factors use Covariant spin tensors" << std::endl; break; case LauAbsResonance::Legendre : std::cout << " : Spin factors are just Legendre polynomials" << std::endl; break; } switch ( bwBarrierType_ ) { case LauBlattWeisskopfFactor::BWBarrier : std::cout << " : Blatt-Weisskopf barrier factors are the 'non-primed' form" << std::endl; break; case LauBlattWeisskopfFactor::BWPrimeBarrier : std::cout << " : Blatt-Weisskopf barrier factors are the 'primed' form" << std::endl; break; case LauBlattWeisskopfFactor::ExpBarrier : std::cout << " : Blatt-Weisskopf barrier factors are the exponential form" << std::endl; break; } switch ( bwRestFrame_ ) { case LauBlattWeisskopfFactor::ParentFrame : std::cout << " : Blatt-Weisskopf barrier factors use bachelor momentum in parent rest frame" << std::endl; break; case LauBlattWeisskopfFactor::ResonanceFrame : std::cout << " : Blatt-Weisskopf barrier factors use bachelor momentum in resonance rest frame" << std::endl; break; case LauBlattWeisskopfFactor::Covariant : std::cout << " : Blatt-Weisskopf barrier factors use covariant expression" << std::endl; break; } summaryPrinted_ = kTRUE; } // Loop over all possible resonance states we have defined in // createResonanceVector() until we get a match with the name of the resonance LauResonanceInfo* resInfo(0); for (std::vector::const_iterator iter=resInfo_.begin(); iter!=resInfo_.end(); ++iter) { if (resName == (*iter)->getName()) { // We have recognised the resonance name. std::cout<<"INFO in LauResonanceMaker::getResonance : Creating resonance: "<getBWCategory(); } LauBlattWeisskopfFactor* resBWFactor = this->getBWFactor( resCategory, resInfo ); LauBlattWeisskopfFactor* parBWFactor = this->getBWFactor( parCategory, resInfo ); theResonance->setBarrierRadii( resBWFactor, parBWFactor ); break; } case LauAbsResonance::GS : { // Gounaris-Sakurai function to try and model the rho(770) better std::cout<<" : Using Gounaris-Sakurai lineshape. "<getBWCategory(); } LauBlattWeisskopfFactor* resBWFactor = this->getBWFactor( resCategory, resInfo ); LauBlattWeisskopfFactor* parBWFactor = this->getBWFactor( parCategory, resInfo ); theResonance->setBarrierRadii( resBWFactor, parBWFactor ); break; } case LauAbsResonance::Flatte : // Flatte distribution - coupled channel Breit-Wigner std::cout<<" : Using Flatte lineshape. "<getBWCategory(); } LauBlattWeisskopfFactor* resBWFactor = this->getBWFactor( resCategory, resInfo ); LauBlattWeisskopfFactor* parBWFactor = this->getBWFactor( parCategory, resInfo ); theResonance->setBarrierRadii( resBWFactor, parBWFactor ); break; } // Set the spin formalism choice theResonance->setSpinType( spinFormalism_ ); return theResonance; } Int_t LauResonanceMaker::resTypeInt(const TString& name) const { // Internal function that returns the resonance integer, specified by the // order of the resonance vector defined in createResonanceVector(), // for a given resonance name. Int_t resTypInt(-99); Int_t i(0); for (std::vector::const_iterator iter=resInfo_.begin(); iter!=resInfo_.end(); ++iter) { if (name.BeginsWith((*iter)->getName(), TString::kExact) == kTRUE) { // We have recognised the resonance from those that are available resTypInt = i; return resTypInt; } ++i; } return resTypInt; } void LauResonanceMaker::printAll( std::ostream& stream ) const { for ( std::vector::const_iterator iter = resInfo_.begin(); iter != resInfo_.end(); ++iter ) { stream << (**iter) << std::endl; } } LauResonanceInfo* LauResonanceMaker::getResInfo(const TString& resName) const { LauResonanceInfo* resInfo(0); for (std::vector::const_iterator iter=resInfo_.begin(); iter!=resInfo_.end(); ++iter) { if (resName == (*iter)->getName()) { // We have recognised the resonance name. resInfo = (*iter); // stop looping break; } } return resInfo; }