LauAbsPdf.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_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