LauAbsResonance.hh

Go to the documentation of this file.

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

#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