LauAbsResonance.hh

Go to the documentation of this file.

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

#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:
                enum LauResonanceModel {
                        BW,                     
                        RelBW,                  
                        GS,                     
                        Flatte,                 
                        Sigma,                  
                        Kappa,                  
                        Dabba,                  
                        LASS,                   
                        LASS_BW,                
                        LASS_NR,                
                        EFKLLM,                 
                        KMatrix,                
                        FlatNR,                 
                        NRModel,                
                        BelleNR,                
                        PowerLawNR,             
                        BelleSymNR,             
                        BelleSymNRNoInter,      
                        TaylorNR,               
                        PolNR,                  
                        MIPW_MagPhase,          
                        MIPW_RealImag,          
                        GaussIncoh,             
                        RhoOmegaMix_GS,         
                        RhoOmegaMix_RBW,        
                        RhoOmegaMix_GS_1,       
                        RhoOmegaMix_RBW_1       
                };

                enum LauSpinType {
                        Zemach_P,       
                        Zemach_Pstar,   
                        Covariant,      
                        Legendre        
                };


                static bool isIncoherentModel(LauResonanceModel model);


                LauAbsResonance(LauResonanceInfo* resInfo, const Int_t resPairAmpInt, const LauDaughters* daughters);


                LauAbsResonance(const TString& resName, const Int_t resPairAmpInt, const LauDaughters* daughters);

                virtual ~LauAbsResonance();

                virtual void initialise() = 0;


                virtual LauComplex amplitude(const LauKinematics* kinematics);


                virtual LauResonanceModel getResonanceModel() const = 0;


                LauSpinType getSpinType() const {return spinType_;}


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


                const TString& getSanitisedName() const {return sanitisedName_;}


                Int_t getPairInt() const {return resPairAmpInt_;}


                Int_t getSpin() const {return resSpin_;}


                Int_t getCharge() const {return resCharge_;}


                Double_t getMass() const {return (resMass_!=0) ? resMass_->unblindValue() : -1.0;}


                Double_t getWidth() const {return (resWidth_!=0) ? resWidth_->unblindValue() : -1.0;}


                LauParameter* getMassPar() {return resMass_;}


                LauParameter* getWidthPar() {return resWidth_;}


                virtual const std::vector<LauParameter*>& getFloatingParameters() { return this->getParameters(); };


                virtual Bool_t preSymmetrised() const {return kFALSE;}


                Bool_t flipHelicity() const {return flipHelicity_;}


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

                Bool_t ignoreMomenta() const {return ignoreMomenta_;}


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


                Bool_t ignoreSpin() const {return ignoreSpin_;}


                void ignoreSpin(const Bool_t boolean) {ignoreSpin_ = boolean;}


                Bool_t ignoreBarrierScaling() const {return ignoreBarrierScaling_;}


                void ignoreBarrierScaling(const Bool_t boolean) {ignoreBarrierScaling_ = boolean;}


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


                void changeBWBarrierRadii(const Double_t resRadius, const Double_t parRadius);


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


                virtual void floatResonanceParameter(const TString& name);


                virtual LauParameter* getResonanceParameter(const TString& name);


                void fixMass(const Bool_t parFixed) { if (resMass_!=0) { resMass_->fixed(parFixed); } }


                void fixWidth(const Bool_t parFixed) { if (resWidth_!=0) { resWidth_->fixed(parFixed); } }


                Bool_t fixMass() const { return (resMass_!=0) ? resMass_->fixed() : kTRUE; }


                Bool_t fixWidth() const { return (resWidth_!=0) ? resWidth_->fixed() : kTRUE; }


                void setSpinType(const LauSpinType spinType) {spinType_ = spinType;}


                void setBarrierRadii(LauBlattWeisskopfFactor* resFactor, LauBlattWeisskopfFactor* parFactor)
                {
                        resBWFactor_ = resFactor;
                        parBWFactor_ = parFactor;
                }

                void fixBarrierRadii(const Bool_t fixResRadius, const Bool_t fixParRadius);

                Bool_t fixResRadius() const;

                Bool_t fixParRadius() const;

                Double_t getResRadius() const;

                Double_t getParRadius() const;

        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 getCovFactor() const {return covFactor_;}

                LauBlattWeisskopfFactor* getParBWFactor() {return parBWFactor_;}
                const LauBlattWeisskopfFactor* getParBWFactor() const {return parBWFactor_;}
                LauBlattWeisskopfFactor* getResBWFactor() {return resBWFactor_;}
                const LauBlattWeisskopfFactor* getResBWFactor() const {return resBWFactor_;}

                LauResonanceInfo* getResInfo() const {return resInfo_;}

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


                Double_t calcZemachSpinFactor( const Double_t pProd ) const;


                Double_t calcCovSpinFactor( const Double_t pProd );


                void calcCovFactor( const Double_t erm );


                Double_t calcLegendrePoly() const;


                Double_t calcLegendrePoly( const Double_t cosHel );


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

                void clearFloatingParameters() { resParameters_.clear(); }


                void addFloatingParameter( LauParameter* param );

                std::vector<LauParameter*>& getParameters() { return resParameters_; }

        private:
                LauAbsResonance(const LauAbsResonance& rhs);

                LauAbsResonance& operator=(const LauAbsResonance& rhs);

                LauResonanceInfo* resInfo_;

                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_;

                TString sanitisedName_;

                LauParameter* resMass_; 
                LauParameter* resWidth_;

                std::vector<LauParameter*> resParameters_;

                Int_t resSpin_; 
                Int_t resCharge_; 
                Int_t resPairAmpInt_;
                LauBlattWeisskopfFactor* parBWFactor_;
                LauBlattWeisskopfFactor* resBWFactor_;

                LauSpinType spinType_;

                Bool_t flipHelicity_;
                Bool_t ignoreMomenta_;
                Bool_t ignoreSpin_;
                Bool_t ignoreBarrierScaling_;

                // Event kinematics information

                Double_t mass_;
                Double_t cosHel_;

                Double_t q_;
                Double_t p_;
                Double_t pstar_;


                Double_t erm_;

                Double_t covFactor_;

                ClassDef(LauAbsResonance,0) // Abstract resonance class

};

#endif