diff --git a/Makefile b/Makefile index dec31b4..edc69e2 100644 --- a/Makefile +++ b/Makefile @@ -1,196 +1,196 @@ ############################################################################ # 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 # # # ############################################################################ # # # ------------------------------- # # Standalone Makefile for Laura++ # # ------------------------------- # # # # Instructions # # - Review 'external configuration' section below # # to match systems compilers setup # # # # - Make sure the ROOTSYS environment variable is set and points # # to your ROOT release or the root-config script is in your PATH # # # # - run 'make ' # # # # Build targets # # lib - make libLaura++.a # # shlib - make libLaura++.so (default) # # clean - delete all intermediate and final build objects # # # ############################################################################ # --- External configuration ---------------------------------- # first check that ROOTSYS is defined ifndef ROOTSYS ROOTSYS := $(shell root-config --prefix) ROOTBINDIR := $(shell root-config --bindir) ifeq ($(ROOTSYS), ) $(error running of root-config failed or reported null value) endif else ROOTBINDIR := $(ROOTSYS)/bin endif ROOTCONFIG := $(ROOTBINDIR)/root-config ARCH := $(shell $(ROOTCONFIG) --arch) PLATFORM := $(shell $(ROOTCONFIG) --platform) ROOTVERSION := $(shell $(ROOTCONFIG) --version | awk -F. '{print $$1}') INCLUDES = SRCDIR = src INCDIR = inc LIBDIR = lib WORKDIR = tmp # By default, don't build the LauRooFitSlave class since it depends on RooFit # and we don't want to pull in that library if we don't have to. # If you want to build it, just set the SKIPLIST variable to be empty. SKIPLIST = LauRooFitSlave ifeq ($(findstring linux, $(ARCH)),linux) # This set here should work for Linux. CXX = g++ LD = g++ -#CXXFLAGS = -g -O2 -Wall -Wextra -Wshadow -Woverloaded-virtual -Werror -fPIC -std=c++11 -CXXFLAGS = -g -O2 -Wall -Wextra -Wshadow -Woverloaded-virtual -fPIC -std=c++11 +CXXFLAGS = -g -O2 -Wall -Wextra -Wshadow -Woverloaded-virtual -Werror -fPIC -std=c++11 +#CXXFLAGS = -g -O2 -Wall -Wextra -Wshadow -Woverloaded-virtual -fPIC -std=c++11 MFLAGS = -MM LDFLAGS = -shared endif ifeq ($(ARCH),macosx64) # This set here should work for MacOSX. CXX = g++ LD = g++ -#CXXFLAGS = -g -O3 -Wall -Wextra -Wshadow -Woverloaded-virtual -Werror -fPIC -CXXFLAGS = -g -O3 -Wall -Wextra -Wshadow -Woverloaded-virtual -fPIC -std=c++11 +CXXFLAGS = -g -O3 -Wall -Wextra -Wshadow -Woverloaded-virtual -Werror -fPIC +#CXXFLAGS = -g -O3 -Wall -Wextra -Wshadow -Woverloaded-virtual -fPIC -std=c++11 MFLAGS = -MM LDFLAGS = -dynamiclib -single_module -undefined dynamic_lookup endif # --- Internal configuration ---------------------------------- PACKAGE=Laura++ DEPDIR=$(WORKDIR)/dependencies OBJDIR=$(WORKDIR)/objects INCLUDES += -I$(INCDIR) CXXFLAGS += $(INCLUDES) CXXFLAGS += $(shell $(ROOTCONFIG) --cflags) LDFLAGS += $(shell $(ROOTCONFIG) --ldflags) CINTFILE = $(WORKDIR)/$(PACKAGE)Cint.cc CINTOBJ = $(OBJDIR)/$(PACKAGE)Cint.o LIBFILE = $(LIBDIR)/lib$(PACKAGE).a SHLIBFILE = $(LIBDIR)/lib$(PACKAGE).so ROOTMAPFILE = $(patsubst %.so,%.rootmap,$(SHLIBFILE)) ROOTLIBS = libCore.so libEG.so libHist.so libMathCore.so libMatrix.so libNet.so libRIO.so libTree.so DEFINES = ifeq ($(strip $(SKIPLIST)),) ROOTLIBS += libRooFitCore.so libRooFit.so DEFINES += -DDOLAUROOFITSLAVE endif default: shlib # List of all header files HHLIST:=$(filter-out $(addprefix $(INCDIR)/, $(addsuffix .hh, $(SKIPLIST))),$(wildcard $(INCDIR)/*.hh)) # List of all source files to build CCLIST:=$(filter-out $(addprefix $(SRCDIR)/, $(addsuffix .cc, $(SKIPLIST))),$(wildcard $(SRCDIR)/*.cc)) # List of all object files to build OLIST:=$(patsubst %.cc,%.o,$(addprefix $(OBJDIR)/,$(notdir $(CCLIST)))) # List of all dependency files to make DLIST:=$(patsubst %.cc,%.d,$(addprefix $(DEPDIR)/,$(notdir $(CCLIST)))) # Implicit rule making all dependency Makefiles included at the end of this makefile $(DEPDIR)/%.d: $(SRCDIR)/%.cc @echo "Making $@" @mkdir -p $(DEPDIR) @set -e; $(CXX) $(MFLAGS) $(CXXFLAGS) $< \ | sed 's#\($(notdir $*)\)\.o[ :]*#$(OBJDIR)/\1.o $@ : #g' > $@; \ [ -s $@ ] || rm -f $@ # Implicit rule to compile all classes $(OBJDIR)/%.o : $(SRCDIR)/%.cc @echo "Compiling $<" @mkdir -p $(OBJDIR) @$(CXX) $(CXXFLAGS) -c $< -o $@ # Rule to make ROOTCINT output file $(CINTOBJ): $(HHLIST) $(INCDIR)/$(PACKAGE)_LinkDef.h @mkdir -p $(OBJDIR) @mkdir -p $(LIBDIR) ifeq ($(ROOTVERSION),5) @echo "Running rootcint" @$(ROOTBINDIR)/rootcint -f $(CINTFILE) -c $(INCLUDES) $(DEFINES) $(notdir $(HHLIST)) $(INCDIR)/$(PACKAGE)_LinkDef.h else @echo "Running rootcling" @$(ROOTBINDIR)/rootcling -f $(CINTFILE) -s $(SHLIBFILE) -rml $(SHLIBFILE) $(addprefix -rml , $(ROOTLIBS)) -rmf $(ROOTMAPFILE) -I$(PWD)/$(INCDIR) $(DEFINES) $(notdir $(HHLIST)) $(INCDIR)/$(PACKAGE)_LinkDef.h endif @echo "Compiling $(CINTFILE)" @$(CXX) $(CXXFLAGS) -c $(CINTFILE) -o $(CINTOBJ) # Rule to combine objects into a library $(LIBFILE): $(OLIST) $(CINTOBJ) @echo "Making $(LIBFILE)" @mkdir -p $(LIBDIR) @rm -f $(LIBFILE) @ar rcs $(LIBFILE) $(OLIST) $(CINTOBJ) # Rule to combine objects into a shared library $(SHLIBFILE): $(OLIST) $(CINTOBJ) @echo "Making $(SHLIBFILE)" @mkdir -p $(LIBDIR) @rm -f $(SHLIBFILE) @$(CXX) $(OLIST) $(CINTOBJ) $(LDFLAGS) -o $(SHLIBFILE) ifeq ($(ROOTVERSION),5) # Rule to create rootmap file $(ROOTMAPFILE): $(SHLIBFILE) @echo "Making $(ROOTMAPFILE)" @mkdir -p $(LIBDIR) @rm -f $(ROOTMAPFILE) @rlibmap -f -o $(ROOTMAPFILE) -l $(SHLIBFILE) -d $(ROOTLIBS) -c $(INCDIR)/$(PACKAGE)_LinkDef.h endif # Useful build targets lib: $(LIBFILE) ifeq ($(ROOTVERSION),5) shlib: $(SHLIBFILE) $(ROOTMAPFILE) else shlib: $(SHLIBFILE) endif clean: rm -rf $(WORKDIR) rm -f $(LIBFILE) rm -f $(SHLIBFILE) rm -f $(ROOTMAPFILE) .PHONY : shlib lib default clean -include $(DLIST) diff --git a/inc/LauAbsResonance.hh b/inc/LauAbsResonance.hh index 319202d..a6598bb 100644 --- a/inc/LauAbsResonance.hh +++ b/inc/LauAbsResonance.hh @@ -1,575 +1,576 @@ /* 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 */ 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 e2c36c6..e274c93 100644 --- a/inc/LauPolarFormFactorNR.hh +++ b/inc/LauPolarFormFactorNR.hh @@ -1,133 +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 Int_t resPairAmpInt, const LauDaughters* daughters); + 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); //! 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/LauPolarFormFactorSymNR.hh b/inc/LauPolarFormFactorSymNR.hh index 1a4685a..77113e7 100644 --- a/inc/LauPolarFormFactorSymNR.hh +++ b/inc/LauPolarFormFactorSymNR.hh @@ -1,133 +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 LauPolarFormFactorSymNR.hh \brief File containing declaration of LauPolarFormFactorSymNR class. */ /*! \class LauPolarFormFactorSymNR \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_SYM_NR #define LAU_POLAR_FORM_FACTOR_SYM_NR #include "TString.h" #include "LauComplex.hh" #include "LauAbsResonance.hh" class LauKinematics; class LauParameter; class LauPolarFormFactorSymNR : 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 */ - LauPolarFormFactorSymNR(LauResonanceInfo* resInfo, const Int_t resPairAmpInt, const LauDaughters* daughters); + LauPolarFormFactorSymNR(LauResonanceInfo* resInfo, const LauAbsResonance::LauResonanceModel resType, + const Int_t resPairAmpInt, const LauDaughters* daughters); //! Destructor virtual ~LauPolarFormFactorSymNR(); //! 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 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) LauPolarFormFactorSymNR(const LauPolarFormFactorSymNR& rhs); //! Copy assignment operator (not implemented) LauPolarFormFactorSymNR& operator=(const LauPolarFormFactorSymNR& rhs); LauParameter* lambda_; //! The model to use LauAbsResonance::LauResonanceModel model_; ClassDef(LauPolarFormFactorSymNR,0) }; #endif diff --git a/inc/LauRescatteringRes.hh b/inc/LauRescatteringRes.hh new file mode 100644 index 0000000..36871f0 --- /dev/null +++ b/inc/LauRescatteringRes.hh @@ -0,0 +1,269 @@ +// 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 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 + /*! + \param [in] lambdaPiPi, the NR term for the PiPi + */ + void setLambdaPiPi(const Double_t lambda); + + //! Get the lambdaPiPi, the NR term for the PiPi + /*! + \return the lambdaPiPi, the NR 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 + /*! + \param [in] lambdaKK, the NR term for the KK + */ + void setLambdaKK(const Double_t lambda); + + //! Get the lambdaKK, the NR term for the KK + /*! + \return the lambdaKK, the NR 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;} + + 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;} + + + + + //! 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 + LauParameter* lambdaPiPi_; + + //! the NR term for the KK + LauParameter* lambdaKK_; + + //! the NR term for the PiPi + LauParameter* kkps_; + + //! the NR term for the PiPi + LauParameter* Mf_; + + //! the NR term for the KK + LauParameter* Ms_; + + //! the NR term for the PiPi + LauParameter* Mprime_; + + //! the NR term for the KK + LauParameter* Beta_; + + //! the NR term for the KK + LauParameter* EpsA_; + + //! the NR term for the KK + LauParameter* EpsB_; + + + 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 45ab699..63327fb 100644 --- a/inc/Laura++_LinkDef.h +++ b/inc/Laura++_LinkDef.h @@ -1,150 +1,151 @@ /* 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 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/LauPolarFormFactorNR.cc b/src/LauPolarFormFactorNR.cc index 259e54d..94dc5f3 100644 --- a/src/LauPolarFormFactorNR.cc +++ b/src/LauPolarFormFactorNR.cc @@ -1,146 +1,148 @@ /* 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 LauBelleNR.cc \brief File containing implementation of LauBelleNR class. */ #include #include "TMath.h" #include "LauConstants.hh" #include "LauPolarFormFactorNR.hh" #include "LauDaughters.hh" #include "LauParameter.hh" #include "LauResonanceInfo.hh" ClassImp(LauPolarFormFactorNR) -LauPolarFormFactorNR::LauPolarFormFactorNR(LauResonanceInfo* resInfo, const Int_t resPairAmpInt, const LauDaughters* daughters) : +LauPolarFormFactorNR::LauPolarFormFactorNR(LauResonanceInfo* resInfo, const LauAbsResonance::LauResonanceModel resType, const Int_t resPairAmpInt, const LauDaughters* daughters) : LauAbsResonance(resInfo, resPairAmpInt, daughters), - lambda_(0) + lambda_(0), + model_(resType) + { TString parName = this->getSanitisedName(); parName += "_lambda"; lambda_ = resInfo->getExtraParameter( parName ); if ( lambda_ == 0 ) { lambda_ = new LauParameter( parName, 1.0, 0.0, 10.0, kTRUE ); lambda_->secondStage(kTRUE); resInfo->addExtraParameter( lambda_ ); } } LauPolarFormFactorNR::~LauPolarFormFactorNR() { } void LauPolarFormFactorNR::initialise() { const LauDaughters* daughters = this->getDaughters(); Int_t resPairAmpInt = this->getPairInt(); if ( daughters->gotSymmetricalDP() && resPairAmpInt != 3 ) { std::cerr << "WARNING in LauPolarFormFactorNR::initialise : Dalitz plot is symmetric - this lineshape is not appropriate." << std::endl; } if ( model_ != LauAbsResonance::PolarFFNR) { std::cerr << "WARNING in LauPolarFormFactorNR::initialise : Unknown model requested, defaulting to Polar Form Factor." << std::endl; model_ = LauAbsResonance::PolarFFNR; } } LauComplex LauPolarFormFactorNR::resAmp(Double_t mass, Double_t spinTerm) { Double_t magnitude(1.0); Double_t lambda = this->getLambda(); magnitude = 1.0/(1.0 + mass*mass /(lambda*lambda)); LauComplex resAmplitude(magnitude, 0.0); return resAmplitude; } const std::vector& LauPolarFormFactorNR::getFloatingParameters() { this->clearFloatingParameters(); if ( ! this->fixLambda() ) { this->addFloatingParameter( lambda_ ); } return this->getParameters(); } void LauPolarFormFactorNR::setResonanceParameter(const TString& name, const Double_t value) { // Set various parameters for the lineshape if (name == "lambda") { this->setLambda(value); std::cout << "INFO in LauPolarFormFactorNR::setResonanceParameter : Setting parameter lambda = " << this->getLambda() << std::endl; } else { std::cerr << "WARNING in LauPolarFormFactorNR::setResonanceParameter: Parameter name not reconised. No parameter changes made." << std::endl; } } void LauPolarFormFactorNR::floatResonanceParameter(const TString& name) { if (name == "lambda") { if ( lambda_->fixed() ) { lambda_->fixed( kFALSE ); this->addFloatingParameter( lambda_ ); } else { std::cerr << "WARNING in LauPolarFormFactorNR::floatResonanceParameter: Parameter already floating. No parameter changes made." << std::endl; } } else { std::cerr << "WARNING in LauPolarFormFactorNR::fixResonanceParameter: Parameter name not reconised. No parameter changes made." << std::endl; } } LauParameter* LauPolarFormFactorNR::getResonanceParameter(const TString& name) { if (name == "lambda") { return lambda_; } else { std::cerr << "WARNING in LauPolarFormFactorNR::getResonanceParameter: Parameter name not reconised." << std::endl; return 0; } } void LauPolarFormFactorNR::setLambda(const Double_t lambda) { lambda_->value( lambda ); lambda_->genValue( lambda ); lambda_->initValue( lambda ); } diff --git a/src/LauPolarFormFactorSymNR.cc b/src/LauPolarFormFactorSymNR.cc index a4e18f3..9cb0407 100644 --- a/src/LauPolarFormFactorSymNR.cc +++ b/src/LauPolarFormFactorSymNR.cc @@ -1,184 +1,186 @@ /* 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 LauPolarFormFactorSymNR.cc \brief File containing implementation of LauPolarFormFactorSymNR class. */ #include #include "TMath.h" #include "LauConstants.hh" #include "LauPolarFormFactorSymNR.hh" #include "LauDaughters.hh" #include "LauParameter.hh" #include "LauResonanceInfo.hh" ClassImp(LauPolarFormFactorSymNR) -LauPolarFormFactorSymNR::LauPolarFormFactorSymNR(LauResonanceInfo* resInfo, const Int_t resPairAmpInt, const LauDaughters* daughters) : +LauPolarFormFactorSymNR::LauPolarFormFactorSymNR(LauResonanceInfo* resInfo, const LauAbsResonance::LauResonanceModel resType, const Int_t resPairAmpInt, const LauDaughters* daughters) : LauAbsResonance(resInfo, resPairAmpInt, daughters), - lambda_(0) + lambda_(0), + model_(resType) + { TString parName = this->getSanitisedName(); parName += "_lambda"; lambda_ = resInfo->getExtraParameter( parName ); if ( lambda_ == 0 ) { lambda_ = new LauParameter( parName, 1.0, 0.0, 10.0, kTRUE ); lambda_->secondStage(kTRUE); resInfo->addExtraParameter( lambda_ ); } } LauPolarFormFactorSymNR::~LauPolarFormFactorSymNR() { } void LauPolarFormFactorSymNR::initialise() { const LauDaughters* daughters = this->getDaughters(); if ( ! daughters->gotSymmetricalDP() ) { std::cerr << "WARNING in LauPolarFormFactorSymNR::initialise : Dalitz plot is symmetric - this lineshape is not appropriate." << std::endl; } Int_t resPairAmpInt = this->getPairInt(); if ( resPairAmpInt == 3 ) { std::cerr << "WARNING in LauPolarFormFactorSymNR::initialise : This lineshape is intended to be on the symmetrised axes of the DP." << std::endl; } if ( (model_ != LauAbsResonance::PolarFFSymNR) && (model_ != LauAbsResonance::PolarFFSymNRNoInter)) { std::cerr << "WARNING in LauPolarFormFactorSymNR::initialise : Unknown model requested, defaulting to Polar Form Factor." << std::endl; model_ = LauAbsResonance::PolarFFSymNR; } if ( (model_ != LauAbsResonance::PolarFFSymNR) && (this->getSpin() != 0) ) { std::cerr << "WARNING in LauPolarFormFactorSymNR::initialise : Non-zero spin will be ignored for this model - perhaps you should use LauAbsResonance::PolarFFSymNRNoInter instead" << std::endl; } // NB we do not need to call setSpinType(LauAbsResonance::Legendre) here (as is done in LauPolarFormFactorNR) since override the amplitude method and explicitly use calcLegendrePoly } LauComplex LauPolarFormFactorSymNR::resAmp(Double_t mass, Double_t spinTerm) { std::cerr << "ERROR in LauPolarFormFactorSymNR : 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); } LauComplex LauPolarFormFactorSymNR::amplitude(const LauKinematics* kinematics) { // This function returns the complex dynamical amplitude for a Polar Form Factor Non-Resonant distribution // Calculate for symmetric DPs, e.g. 3pi or 3K, by using shapeNo = 1 or 2 // Have s<->t symmetry already done in Dynamics flip function. // For Kpipi or similar plots, one can use the separate terms // and consider them as two separate components with their own mag and phase. // For this shapeNo = 3 and shapeNo = 4 need to be used to create the two // individual amplitudes (with the same value of lambda). // Calculate Mandelstam variables. // s = m_13^2, t = m_23^2 const Double_t s = kinematics->getm13Sq(); const Double_t t = kinematics->getm23Sq(); Double_t magnitude(1.0); const Double_t lambda = this->getLambda(); if ( model_ == LauAbsResonance::PolarFFSymNR ) { magnitude = 1.0/(1.0 + s /(lambda*lambda)) + 1.0/(1.0 + t /(lambda*lambda)); } else if ( model_ == LauAbsResonance::PolarFFSymNRNoInter ) { magnitude = (s <= t) ? 1.0/(1.0 + s /(lambda*lambda)) : 1.0/(1.0 + t /(lambda*lambda)); } LauComplex resAmplitude(magnitude, 0.0); return resAmplitude; } const std::vector& LauPolarFormFactorSymNR::getFloatingParameters() { this->clearFloatingParameters(); if ( ! this->fixLambda() ) { this->addFloatingParameter( lambda_ ); } return this->getParameters(); } void LauPolarFormFactorSymNR::setResonanceParameter(const TString& name, const Double_t value) { // Set various parameters for the lineshape if (name == "lambda") { this->setLambda(value); std::cout << "INFO in LauPolarFormFactorSymNR::setResonanceParameter : Setting parameter lambda = " << this->getLambda() << std::endl; } else { std::cerr << "WARNING in LauPolarFormFactorSymNR::setResonanceParameter: Parameter name not reconised. No parameter changes made." << std::endl; } } void LauPolarFormFactorSymNR::floatResonanceParameter(const TString& name) { if (name == "lambda") { if ( lambda_->fixed() ) { lambda_->fixed( kFALSE ); this->addFloatingParameter( lambda_ ); } else { std::cerr << "WARNING in LauPolarFormFactorSymNR::floatResonanceParameter: Parameter already floating. No parameter changes made." << std::endl; } } else { std::cerr << "WARNING in LauPolarFormFactorSymNR::fixResonanceParameter: Parameter name not reconised. No parameter changes made." << std::endl; } } LauParameter* LauPolarFormFactorSymNR::getResonanceParameter(const TString& name) { if (name == "lambda") { return lambda_; } else { std::cerr << "WARNING in LauPolarFormFactorSymNR::getResonanceParameter: Parameter name not reconised." << std::endl; return 0; } } void LauPolarFormFactorSymNR::setLambda(const Double_t lambda) { lambda_->value( lambda ); lambda_->genValue( lambda ); lambda_->initValue( lambda ); } diff --git a/src/LauRescatteringRes.cc b/src/LauRescatteringRes.cc new file mode 100644 index 0000000..60b598d --- /dev/null +++ b/src/LauRescatteringRes.cc @@ -0,0 +1,561 @@ + +// 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 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 + 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_->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 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_ ); + } + + + +} + +LauRescatteringRes::~LauRescatteringRes() +{ + delete lambdaPiPi_; + delete lambdaKK_; + delete Mf_; + delete Ms_; + delete Beta_; + delete Mprime_; + delete EpsA_; + delete EpsB_; + delete kkps_; + +} + +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 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; + } + + + 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; + } +} + + +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; + 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 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 == 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); + + Double_t tauRe_s = mag_s*TMath::Cos(2.0*delta0_s); + Double_t tauIm_s = mag_s*TMath::Sin(2.0*delta0_s); + + 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 ((type_ == 1)&&(t<=s)) + { + NR1_s=0.0; NR2_s=0.0; tauRe_s=0.0; tauIm_s=0.0; + } + + 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() ) { + this->addFloatingParameter( Mf_ ); + } + if ( ! this->fixMS() ) { + this->addFloatingParameter( Ms_ ); + } + if ( ! this->fixMPrime() ) { + this->addFloatingParameter( Mprime_ ); + } + if ( ! this->fixBETA() ) { + this->addFloatingParameter( Beta_ ); + } + if ( ! this->fixEPSA() ) { + this->addFloatingParameter( EpsA_ ); + } + if ( ! this->fixEPSB() ) { + this->addFloatingParameter( EpsB_ ); + } + + 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; + } + else if (name == "Ms") { + this->setMS(value); + std::cout << "INFO in LauPhaseRescRes::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; + } + else if (name == "Beta") { + this->setBETA(value); + std::cout << "INFO in LauPhaseRescRes::setResonanceParameter : Setting parameter Beta = " << this->getBETA() << 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 == "EpsB") { + this->setEPSB(value); + std::cout << "INFO in LauPhaseRescRes::setResonanceParameter : Setting parameter Beta = " << this->getEPSB() << 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 { + 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 { + 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 { + 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 == "EpsA") { + return EpsA_; + } + if (name == "EpsB") { + return EpsB_; + } + + 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) +{ + Mf_->value( mff ); + Mf_->genValue( mff ); + Mf_->initValue( mff ); +} +void LauRescatteringRes::setMS(const Double_t mss) +{ + Ms_->value( mss ); + Ms_->genValue( mss ); + Ms_->initValue( mss ); +} +void LauRescatteringRes::setMPrime(const Double_t mprimee) +{ + Mprime_->value( mprimee ); + Mprime_->genValue( mprimee); + Mprime_->initValue( mprimee ); +} +void LauRescatteringRes::setBETA(const Double_t betaa) +{ + Beta_->value( betaa ); + Beta_->genValue( betaa ); + Beta_->initValue( betaa ); +} +void LauRescatteringRes::setEPSA(const Double_t epsaa) +{ + EpsA_->value( epsaa ); + EpsA_->genValue( epsaa ); + EpsA_->initValue( epsaa ); +} +void LauRescatteringRes::setEPSB(const Double_t epsbb) +{ + EpsB_->value( epsbb ); + EpsB_->genValue( epsbb ); + EpsB_->initValue( epsbb ); +} + + diff --git a/src/LauResonanceMaker.cc b/src/LauResonanceMaker.cc index e2521cd..29ecf5c 100644 --- a/src/LauResonanceMaker.cc +++ b/src/LauResonanceMaker.cc @@ -1,965 +1,972 @@ /* 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 ); 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; }