LauAbsModIndPartWave.hh

Go to the documentation of this file.

 
/*
Copyright 2014 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_ABSMODINDPARTWAVE
#define LAU_ABSMODINDPARTWAVE
 
#include "Lau1DCubicSpline.hh"
#include "LauAbsResonance.hh"
#include "LauComplex.hh"
 
#include <set>
 
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