LauAbsResonance.hh

Go to the documentation of this file.

// Copyright University of Warwick 2004 - 2013.
// 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

#ifndef LAU_ABS_RESONANCE
#define LAU_ABS_RESONANCE

#include "TString.h"

#include "LauComplex.hh"

class LauDaughters;
class LauKinematics;

class LauAbsResonance {

        public:
                enum LauResonanceModel {
                        BW,             
                        RelBW,          
                        GS,             
                        Flatte,         
                        Sigma,          
                        Kappa,          
                        Dabba,          
                        LASS,           
                        LASS_BW,        
                        LASS_NR,        
                        KMatrix,        
                        FlatNR,         
                        NRModel,        
                        BelleNR,        
                        PowerLawNR,     
                        BelleSymNR,     
                        TaylorNR,       
                        PolNR           
                };

                enum BarrierType {
                        BWBarrier,      
                        BWPrimeBarrier, 
                        ExpBarrier      
                };


                LauAbsResonance(const TString& resName, Double_t resMass, Double_t resWidth,
                                Int_t resSpin, Int_t resCharge, Int_t resPairAmpInt, 
                                const LauDaughters* daughters);

                virtual ~LauAbsResonance();

                virtual void initialise() = 0;


                virtual LauComplex amplitude(const LauKinematics* kinematics);


                virtual LauResonanceModel getResonanceModel() const = 0;


                const TString& getResonanceName() const {return resName_;}


                Int_t getPairInt() const {return resPairAmpInt_;}


                Int_t getSpin() const {return resSpin_;}


                Int_t getCharge() const {return resCharge_;}


                Double_t getMass() const {return resMass_;}


                Double_t getWidth() const {return resWidth_;}


                Bool_t flipHelicity() const {return flipHelicity_;}


                void flipHelicity(Bool_t boolean) {flipHelicity_ = boolean;}
        

                Bool_t ignoreMomenta() const {return ignoreMomenta_;}


                void ignoreMomenta(Bool_t boolean) {ignoreMomenta_ = boolean;}


                void changeResonance(const Double_t newMass, const Double_t newWidth, const Int_t newSpin);


                virtual void setResonanceParameter(const TString& name, const Double_t value);


                virtual void setBarrierRadii(const Double_t resRadius, const Double_t parRadius, const BarrierType type)
                {
                        resR_ = resRadius;
                        parR_ = parRadius;
                        barrierType_ = type;
                }

        protected:
                TString getNameParent() const;
                TString getNameDaug1() const;
                TString getNameDaug2() const;
                TString getNameBachelor() const;
                Double_t getMassParent() const;
                Double_t getMassDaug1() const;
                Double_t getMassDaug2() const;
                Double_t getMassBachelor() const;
                Int_t getChargeParent() const;
                Int_t getChargeDaug1() const;
                Int_t getChargeDaug2() const;
                Int_t getChargeBachelor() const;

                Double_t getQ() const {return q_;}
                Double_t getP() const {return p_;}
                Double_t getPstar() const {return pstar_;}

                Double_t getParBWRadius() const {return parR_;}
                Double_t getResBWRadius() const {return resR_;}
                BarrierType getBarrierType() const {return barrierType_;}

                const LauDaughters* getDaughters() const {return daughters_;}


                virtual LauComplex resAmp(Double_t mass, Double_t spinTerm) = 0;

        private:
                const LauDaughters* daughters_;

                TString nameParent_; 
                TString nameDaug1_;
                TString nameDaug2_;
                TString nameBachelor_;

                Int_t chargeParent_;
                Int_t chargeDaug1_; 
                Int_t chargeDaug2_; 
                Int_t chargeBachelor_;

                Double_t massParent_; 
                Double_t massDaug1_; 
                Double_t massDaug2_; 
                // Bachelor mass
                Double_t massBachelor_;

                TString resName_;
                Double_t resMass_; 
                Double_t resWidth_;
                Int_t resSpin_; 
                Int_t resCharge_; 
                Int_t resPairAmpInt_;
                Double_t parR_;
                Double_t resR_;
                BarrierType barrierType_;

                Bool_t flipHelicity_;
                Bool_t ignoreMomenta_;

                Double_t q_;
                Double_t p_;
                Double_t pstar_;

                ClassDef(LauAbsResonance,0) // Abstract resonance class

};

#endif