LauAbsPdf.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_PDF
#define LAU_ABS_PDF

#include <map>
#include <vector>

#include "Rtypes.h"
#include "TRandom.h"
#include "TString.h"

#include "LauFitDataTree.hh"
#include "LauAbsRValue.hh"
#include "LauParameter.hh"
#include "LauParamFixed.hh"

class LauKinematics;


class LauAbsPdf {

        public:
                typedef std::vector<Double_t> LauAbscissas;

                enum IntMethod {
                        GaussLegendre, 
                        Trapezoid      
                };


                LauAbsPdf(const TString& theVarName, const std::vector<LauAbsRValue*>& params,
                                Double_t minAbscissa, Double_t maxAbscissa);


                LauAbsPdf(const std::vector<TString>& theVarNames, const std::vector<LauAbsRValue*>& params,
                                const LauFitData& minAbscissas, const LauFitData& maxAbscissas);

                virtual ~LauAbsPdf() {}


                virtual const TString& varName() const {return varNames_.find(0)->second;}


                virtual std::vector<TString> varNames() const;


                virtual UInt_t nParameters() const {return param_.size();}


                virtual UInt_t nFixedParameters() const;


                virtual UInt_t nInputVars() const {return varNames_.size();}


                virtual Bool_t isDPDependent() const {return kFALSE;}


                virtual Double_t getMinAbscissa() const {return minAbscissas_.front();}


                virtual Double_t getMaxAbscissa() const {return maxAbscissas_.front();}


                virtual Double_t getRange() const {return this->getMaxAbscissa() - this->getMinAbscissa();}


                virtual Double_t getMinAbscissa( const TString& theVarName ) const;


                virtual Double_t getMaxAbscissa( const TString& theVarName ) const;


                virtual Double_t getRange( const TString& theVarName ) const {return this->getMaxAbscissa(theVarName) - this->getMinAbscissa(theVarName);}


                virtual LauFitData getMinAbscissas() const;


                virtual LauFitData getMaxAbscissas() const;


                virtual LauFitData getRanges() const;

                virtual void updatePulls();


                virtual void cacheInfo(const LauFitDataTree& inputData);


                virtual void calcLikelihoodInfo(const LauAbscissas& abscissas) = 0;


                virtual void calcLikelihoodInfo(UInt_t iEvt);


                virtual Double_t getUnNormLikelihood() const {return unNormPDFVal_;}


                virtual Double_t getNorm() const {return norm_;}


                virtual Double_t getLikelihood() const;


                virtual Double_t getLikelihood( const TString& theVarName ) const;


                virtual Double_t getMaxHeight() const {return maxHeight_;}


                virtual LauFitData generate(const LauKinematics* kinematics);


                virtual void setRandomFun(TRandom* randomFun) {randomFun_ = randomFun;}


                virtual const std::vector<LauAbsRValue*>& getParameters() const { return param_; }


                virtual std::vector<LauAbsRValue*>& getParameters() { return param_; }


                virtual void calcNorm();


                virtual void calcPDFHeight( const LauKinematics* kinematics ) = 0;


                virtual Bool_t heightUpToDate() const {return heightUpToDate_;}


                virtual void heightUpToDate(Bool_t hutd) {heightUpToDate_ = hutd;}


                virtual Bool_t cachePDF() const {return cachePDF_;}


                virtual Int_t nNormPoints() const {return nNormPoints_;}


                virtual void nNormPoints(Int_t nPoints) {nNormPoints_ = nPoints;}


                virtual IntMethod integMethod() const {return integMethod_;}


                virtual void integMethod(IntMethod method) {integMethod_ = method;}

        protected:

                virtual void cachePDF( Bool_t doCachePDF ) {cachePDF_ = doCachePDF;}


                virtual Double_t integrGaussLegendre();


                virtual Double_t integTrapezoid();


                virtual void setNorm(Double_t norm) {norm_ = norm;}


                virtual void setMaxHeight(Double_t maxHeight) {
                        maxHeight_ = maxHeight;
                        this->heightUpToDate(kTRUE);
                }


                virtual void setMinAbscissa(const TString& theVarName, Double_t minAbscissa);


                virtual void setMaxAbscissa(const TString& theVarName, Double_t maxAbscissa);


                virtual void setRange(const TString& theVarName, Double_t minAbscissa, Double_t maxAbscissa) {
                        this->setMinAbscissa(theVarName, minAbscissa);
                        this->setMaxAbscissa(theVarName, maxAbscissa);
                }


                virtual Bool_t checkRange(const LauAbscissas& abscissas) const;

                virtual void setUnNormPDFVal(Double_t unNormPDFVal) {unNormPDFVal_ = unNormPDFVal;}


                virtual LauAbsRValue* findParameter(const TString& parName);


                virtual const LauAbsRValue* findParameter(const TString& parName) const;


                virtual TRandom* getRandomFun() const {return randomFun_;}


                virtual std::vector<LauAbscissas>& getAbscissas() {return abscissas_;}


                virtual const std::vector<LauAbscissas>& getAbscissas() const {return abscissas_;}


                virtual std::vector<Double_t>& getUnNormPDFValues() {return unNormPDFValues_;}
                

                virtual const std::vector<Double_t>& getUnNormPDFValues() const {return unNormPDFValues_;}


                virtual void addParameters(std::vector<LauAbsRValue*>& params);


                virtual Bool_t withinNormCalc() const {return withinNormCalc_;}
                

                virtual void withinNormCalc(Bool_t yorn) {withinNormCalc_ = yorn;}


                virtual Bool_t withinGeneration() const {return withinGeneration_;}


                virtual void withinGeneration(Bool_t yorn) {withinGeneration_ = yorn;}


                virtual Bool_t normWeightsDone() const {return normWeightsDone_;}


                virtual void normWeightsDone(Bool_t yorn) {normWeightsDone_ = yorn;}
                
                virtual void getNormWeights();


                virtual const std::vector<LauAbscissas>& normAbscissas() const {return normAbscissas_;}


                virtual const std::vector<Double_t>& normWeights() const {return normWeights_;}

        private:
                LauAbsPdf(const LauAbsPdf& rhs);

                LauAbsPdf& operator=(const LauAbsPdf& rhs);

                std::map<UInt_t,TString> varNames_;

                std::vector<LauAbsRValue*> param_;

                Double_t norm_;

                Double_t maxHeight_;
                
                Bool_t heightUpToDate_;

                LauAbscissas minAbscissas_;

                LauAbscissas maxAbscissas_;

                TRandom* randomFun_;

                std::vector<LauAbscissas> abscissas_;

                std::vector<Double_t> unNormPDFValues_;


                Bool_t cachePDF_;

                Double_t unNormPDFVal_;

                Int_t nNormPoints_;
                
                IntMethod integMethod_;
                
                Bool_t withinNormCalc_;
                
                Bool_t withinGeneration_;
                
                Bool_t normWeightsDone_;
                
                std::vector<LauAbscissas> normAbscissas_;

                std::vector<Double_t> normWeights_;

                ClassDef(LauAbsPdf,0) // Define the abstract PDF class
};

#endif