LauAbsModIndPartWave.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_ABSMODINDPARTWAVE
#define LAU_ABSMODINDPARTWAVE

#include <set>

#include "LauComplex.hh"
#include "LauAbsResonance.hh"
#include "Lau1DCubicSpline.hh"


class LauAbsModIndPartWave : public LauAbsResonance {

        public:

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

                virtual ~LauAbsModIndPartWave();

                virtual void initialise();


                void defineKnots(const std::set<Double_t>& masses);


                UInt_t nKnots() const { return nKnots_; }


                virtual void setKnotAmp(const UInt_t knot, const Double_t ampVal1, const Double_t ampVal2, const Bool_t fixAmpVal1, const Bool_t fixAmpVal2) = 0;


                void floatKnotsSecondStage(const Bool_t secondStage);

                Bool_t floatKnotsSecondStage() const {return secondStage_;};


                virtual const std::vector<LauParameter*>& getFloatingParameters();

        protected:

                virtual LauComplex resAmp(Double_t mass, Double_t spinTerm);


                virtual void evaluateAmplitude(const Double_t mass) = 0;


                virtual std::set<Double_t> checkKnots(const std::set<Double_t>& masses);


                virtual void createAmpParameters(const UInt_t iKnot) = 0;


                void setSplineType(Lau1DCubicSpline::LauSplineType type1, Lau1DCubicSpline::LauSplineType type2);


                void setSplineBoundaryConditions(Lau1DCubicSpline::LauSplineBoundaryType leftBound1, 
                                                 Lau1DCubicSpline::LauSplineBoundaryType rightBound1,
                                                 Lau1DCubicSpline::LauSplineBoundaryType leftBound2,
                                                 Lau1DCubicSpline::LauSplineBoundaryType rightBound2,
                                                 Double_t leftGrad1 = 0.0, Double_t rightGrad1 = 0.0,
                                                 Double_t leftGrad2 = 0.0, Double_t rightGrad2 = 0.0);


                void setAmp(const Double_t realPart, const Double_t imagPart)
                {
                        amp_.setRealImagPart(realPart,imagPart);
                }

                const std::vector<Double_t>& getMasses() {return masses_;}

                std::vector<Double_t>& getAmp1Vals() {return amp1Vals_;}

                std::vector<Double_t>& getAmp2Vals() {return amp2Vals_;}

                std::vector<LauParameter*>& getAmp1Pars() {return amp1Pars_;}

                std::vector<LauParameter*>& getAmp2Pars() {return amp2Pars_;}

                const Lau1DCubicSpline* getSpline1() const {return spline1_;}

                const Lau1DCubicSpline* getSpline2() const {return spline2_;}

        private:
                UInt_t nKnots_;

                std::vector<Double_t> masses_;

                std::vector<Double_t> amp1Vals_;
                std::vector<Double_t> amp2Vals_;

                std::vector<LauParameter*> amp1Pars_;
                std::vector<LauParameter*> amp2Pars_;

                Lau1DCubicSpline* spline1_;
                Lau1DCubicSpline* spline2_;

                Lau1DCubicSpline::LauSplineType type1_;
                Lau1DCubicSpline::LauSplineType type2_;

                Lau1DCubicSpline::LauSplineBoundaryType leftBound1_;
                Lau1DCubicSpline::LauSplineBoundaryType rightBound1_;
                Lau1DCubicSpline::LauSplineBoundaryType leftBound2_;
                Lau1DCubicSpline::LauSplineBoundaryType rightBound2_;

                Double_t leftGrad1_;
                Double_t rightGrad1_;
                Double_t leftGrad2_;
                Double_t rightGrad2_;

                Bool_t secondStage_;

                LauComplex amp_;

                ClassDef(LauAbsModIndPartWave,0) // model independent partial wave

};

#endif