LauAbsFitModel.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_ABS_FIT_MODEL
#define LAU_ABS_FIT_MODEL

#include "TMatrixD.h"
#include "TString.h"
#include "TStopwatch.h"
#include "TVectorDfwd.h"

#include <iosfwd>
#include <set>
#include <vector>

#include "LauFitObject.hh"
#include "LauFormulaPar.hh"
#include "LauSimFitSlave.hh"
// LauSPlot included to get LauSPlot::NameSet typedef
#include "LauSPlot.hh"

class TMessage;
class TMonitor;
class TSocket;
class TTree;
class LauAbsCoeffSet;
class LauAbsPdf;
class LauComplex;
class LauFitDataTree;
class LauFitNtuple;
class LauGenNtuple;
class LauAbsRValue;
class LauParameter;

class LauAbsFitModel : public LauFitObject, public LauSimFitSlave {

        public:
                LauAbsFitModel();

                virtual ~LauAbsFitModel();

                Bool_t useDP() const { return usingDP_; }


                void useDP(Bool_t usingDP) { usingDP_ = usingDP; }

                Bool_t doSFit() const { return doSFit_; }


                void doSFit( const TString& sWeightBranchName, Double_t scaleFactor = 1.0 );

                Bool_t doEMLFit() const {return emlFit_;}


                void doEMLFit(Bool_t emlFit) {emlFit_ = emlFit;}

                virtual Bool_t twoStageFit() const {return twoStageFit_;}


                virtual void twoStageFit(Bool_t doTwoStageFit) {twoStageFit_ = doTwoStageFit;}

                Bool_t useAsymmFitErrors() const {return useAsymmFitErrors_;}


                void useAsymmFitErrors(Bool_t useAsymmErrors) {useAsymmFitErrors_ = useAsymmErrors;}

                Bool_t doPoissonSmearing() const {return poissonSmear_;}


                void doPoissonSmearing(Bool_t poissonSmear) {poissonSmear_ = poissonSmear;}

                Bool_t enableEmbedding() const {return enableEmbedding_;}


                void enableEmbedding(Bool_t enable) {enableEmbedding_ = enable;}


                virtual void withinAsymErrorCalc(Bool_t inAsymErrCalc) {withinAsymErrorCalc_ = inAsymErrCalc;}

                Bool_t writeLatexTable() const {return writeLatexTable_;}


                void writeLatexTable(Bool_t writeTable) {writeLatexTable_ = writeTable;}


                void writeSPlotData(const TString& fileName, const TString& treeName, Bool_t storeDPEfficiency, const TString& verbosity = "q");

                Bool_t writeSPlotData() const {return writeSPlotData_;}

                Bool_t storeDPEff() const {return storeDPEff_;}

                Bool_t useRandomInitFitPars() const {return randomFit_;}

                void useRandomInitFitPars(Bool_t boolean) {randomFit_ = boolean;}


                void setNExpts(UInt_t nExperiments, UInt_t firstExperiment = 0) {
                        nExpt_ = nExperiments;
                        firstExpt_ = firstExperiment;
                }

                UInt_t eventsPerExpt() const {return evtsPerExpt_;}

                UInt_t nExpt() const {return nExpt_;}

                UInt_t firstExpt() const {return firstExpt_;}

                UInt_t iExpt() const {return iExpt_;}


                virtual void setBkgndClassNames( const std::vector<TString>& names );

                inline UInt_t nBkgndClasses() const {return bkgndClassNames_.size();}


                virtual void setNSigEvents(LauParameter* nSigEvents) = 0;


                virtual void setNBkgndEvents(LauParameter* nBkgndEvents) = 0;


                virtual void setAmpCoeffSet(LauAbsCoeffSet* coeffSet) = 0;


                void compareFitData(UInt_t toyMCScale = 10, const TString& mcFileName = "fitToyMC.root",
                                const TString& tableFileName = "fitToyMCTable.tex", Bool_t poissonSmearing = kTRUE);


                virtual void weightEvents( const TString& dataFileName, const TString& dataTreeName ) = 0;


                void run(const TString& applicationCode, const TString& dataFileName, const TString& dataTreeName,
                         const TString& histFileName, const TString& tableFileName = "");


                void runSlave(const TString& dataFileName, const TString& dataTreeName,
                              const TString& histFileName, const TString& tableFileName = "",
                              const TString& addressMaster = "localhost", const UInt_t portMaster = 9090);


                virtual void setParsFromMinuit(Double_t* par, Int_t npar);


                virtual Double_t getTotNegLogLikelihood();


                virtual void addConstraint(const TString& formula, const std::vector<TString>& pars, const Double_t mean, const Double_t width);

        protected:

                // Some typedefs

                typedef std::vector<LauAbsPdf*> LauPdfList;
                typedef std::vector<LauParameter*> LauParameterPList;
                typedef std::vector<LauAbsRValue*> LauAbsRValuePList;
                typedef std::set<LauParameter*> LauParameterPSet;
                typedef std::vector<LauParameter> LauParameterList;
                typedef std::map<UInt_t,TString> LauBkgndClassMap;

                void clearFitParVectors();

                void clearExtraVarVectors();


                virtual void generate(const TString& dataFileName, const TString& dataTreeName, const TString& histFileName, const TString& tableFileNameBase);


                virtual Bool_t genExpt() = 0;


                void fit(const TString& dataFileName, const TString& dataTreeName, const TString& histFileName, const TString& tableFileNameBase);


                void fitSlave(const TString& dataFileName, const TString& dataTreeName, const TString& histFileName, const TString& tableFileNameBase);

                void fitExpt();


                Bool_t runMinimisation();


                void createFitToyMC(const TString& mcFileName, const TString& tableFileName);


                virtual UInt_t readExperimentData( const UInt_t exptIndex );


                Bool_t cacheFitData(const TString& dataFileName, const TString& dataTreeName);

                virtual void cacheInputFitVars() = 0;

                virtual void cacheInputSWeights();


                virtual void initialise() = 0;

                virtual void recalculateNormalisation() = 0;

                virtual void initialiseDPModels() = 0;

                virtual void updateCoeffs() = 0;

                virtual void propagateParUpdates() = 0;


                Double_t getLogLikelihood( UInt_t iStart, UInt_t iEnd );

                Double_t getLogLikelihoodPenalty();


                virtual Double_t getTotEvtLikelihood(UInt_t iEvt) = 0;

                virtual Double_t getEventSum() const = 0;


                virtual void printEventInfo(UInt_t iEvt) const;

                virtual void printVarsInfo() const;

                virtual void checkInitFitParams() = 0;


                virtual void prepareInitialParArray( TObjArray& array );


                virtual void finaliseResults( const Int_t fitStat, const Double_t NLL, const TObjArray* parsFromMaster, const TMatrixD* covMat, TObjArray& parsToMaster );


                virtual void finaliseFitResults(const TString& tableFileName) = 0;


                virtual void writeOutTable(const TString& outputFile) = 0;

                virtual void storePerEvtLlhds() = 0;

                virtual void writeOutAllFitResults();

                virtual void calculateSPlotData();

                void setGenValues();

                virtual void setupBkgndVectors() = 0;


                Bool_t validBkgndClass( const TString& className ) const;


                UInt_t bkgndClassID( const TString& className ) const;


                const TString& bkgndClassName( UInt_t classID ) const;

                void eventsPerExpt(UInt_t nEvents) {evtsPerExpt_ = nEvents;}

                virtual void setupGenNtupleBranches() = 0;


                virtual void addGenNtupleIntegerBranch(const TString& name);


                virtual void addGenNtupleDoubleBranch(const TString& name);


                virtual void setGenNtupleIntegerBranchValue(const TString& name, Int_t value);


                virtual void setGenNtupleDoubleBranchValue(const TString& name, Double_t value);


                virtual Int_t getGenNtupleIntegerBranchValue(const TString& name) const;


                virtual Double_t getGenNtupleDoubleBranchValue(const TString& name) const;

                virtual void fillGenNtupleBranches();

                virtual void setupSPlotNtupleBranches() = 0;


                virtual void addSPlotNtupleIntegerBranch(const TString& name);


                virtual void addSPlotNtupleDoubleBranch(const TString& name);


                virtual void setSPlotNtupleIntegerBranchValue(const TString& name, Int_t value);


                virtual void setSPlotNtupleDoubleBranchValue(const TString& name, Double_t value);

                virtual void fillSPlotNtupleBranches();

                virtual LauSPlot::NameSet variableNames() const = 0;

                virtual LauSPlot::NumbMap freeSpeciesNames() const = 0;

                virtual LauSPlot::NumbMap fixdSpeciesNames() const = 0;

                virtual LauSPlot::TwoDMap twodimPDFs() const = 0;

                virtual Bool_t splitSignal() const = 0;

                virtual Bool_t scfDPSmear() const = 0;


                UInt_t addFitParameters(LauPdfList& pdfList);

                void addConParameters();


                void printFitParameters(const LauPdfList& pdfList, std::ostream& fout) const;


                void updateFitParameters(LauPdfList& pdfList);


                void cacheInfo(LauPdfList& pdfList, const LauFitDataTree& theData);


                Double_t prodPdfValue(LauPdfList& pdfList, UInt_t iEvt);


                Bool_t pdfsDependOnDP() const {return pdfsDependOnDP_;}


                void pdfsDependOnDP(Bool_t dependOnDP) { pdfsDependOnDP_ = dependOnDP; }

                const LauParameterPList& fitPars() const {return fitVars_;}
                LauParameterPList& fitPars() {return fitVars_;}

                const LauParameterPSet& resPars() const {return resVars_;}
                LauParameterPSet& resPars() {return resVars_;}

                const LauParameterList& extraPars() const {return extraVars_;}
                LauParameterList& extraPars() {return extraVars_;}

                const LauAbsRValuePList& conPars() const {return conVars_;}
                LauAbsRValuePList& conPars() {return conVars_;}

                const LauFitNtuple* fitNtuple() const {return fitNtuple_;}
                LauFitNtuple* fitNtuple() {return fitNtuple_;}

                const LauGenNtuple* genNtuple() const {return genNtuple_;}
                LauGenNtuple* genNtuple() {return genNtuple_;}

                const LauGenNtuple* sPlotNtuple() const {return sPlotNtuple_;}
                LauGenNtuple* sPlotNtuple() {return sPlotNtuple_;}

                const LauFitDataTree* fitData() const {return inputFitData_;}
                LauFitDataTree* fitData() {return inputFitData_;}

                Double_t nll() const {return NLL_;}

                Int_t fitStatus() const {return fitStatus_;}

                const TMatrixD& covarianceMatrix() const {return covMatrix_;}

        private:
                LauAbsFitModel(const LauAbsFitModel& rhs);

                LauAbsFitModel& operator=(const LauAbsFitModel& rhs);

                // Setup a struct to store information on constrained fit parameters
                struct StoreConstraints {
                        TString formula_;
                        std::vector<TString> conPars_;
                        Double_t mean_;
                        Double_t width_;
                };

                std::vector<StoreConstraints> storeCon_;

                // Various control booleans

                Bool_t twoStageFit_; 
                Bool_t useAsymmFitErrors_; 
                Bool_t compareFitData_; 
                Bool_t writeLatexTable_; 
                Bool_t writeSPlotData_; 
                Bool_t storeDPEff_; 
                Bool_t randomFit_; 
                Bool_t emlFit_; 
                Bool_t poissonSmear_; 
                Bool_t enableEmbedding_; 
                Bool_t usingDP_; 
                Bool_t pdfsDependOnDP_;

                // Info on number of experiments and number of events

                UInt_t firstExpt_; 
                UInt_t nExpt_; 
                UInt_t evtsPerExpt_; 
                UInt_t iExpt_;

                LauParameterPList fitVars_;

                LauParameterPSet resVars_;

                LauParameterList extraVars_;

                LauAbsRValuePList conVars_;

                // Input data and output ntuple

                LauFitDataTree* inputFitData_;
                LauFitNtuple* fitNtuple_;
                LauGenNtuple* genNtuple_;
                LauGenNtuple* sPlotNtuple_;

                // Fit bookeeping variables

                Int_t fitStatus_;
                Double_t NLL_;
                TMatrixD covMatrix_;
                UInt_t numberOKFits_; 
                UInt_t numberBadFits_; 
                UInt_t nParams_; 
                UInt_t nFreeParams_;
                Double_t worstLogLike_;
                Bool_t withinAsymErrorCalc_;

                // Background class names
                LauBkgndClassMap bkgndClassNames_;
                const TString nullString_;

                // sFit related variables

                Bool_t doSFit_;
                TString sWeightBranchName_;
                std::vector<Double_t> sWeights_;
                Double_t sWeightScaleFactor_;

                // Fit timers

                TStopwatch timer_; 
                TStopwatch cumulTimer_;

                TString outputTableName_;

                // Comparison toy MC related variables

                TString fitToyMCFileName_; 
                TString fitToyMCTableName_;
                UInt_t fitToyMCScale_;
                Bool_t fitToyMCPoissonSmear_;

                // sPlot related variables

                TString sPlotFileName_; 
                TString sPlotTreeName_; 
                TString sPlotVerbosity_;

                ClassDef(LauAbsFitModel,0) // Abstract interface to fit/toyMC model
};

#endif