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

#include "TMatrixDfwd.h"
#include "TString.h"
#include "TStopwatch.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 LauAbsCoeffSet;
class LauAbsPdf;
class LauFitDataTree;
class LauGenNtuple;
class LauAbsRValue;
class LauParameter;

class LauAbsFitModel : 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;}

                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;}

                Bool_t writeLatexTable() const {return writeLatexTable_;}


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

                Bool_t saveFilePDF() const {return savePDF_;}


                void saveFilePDF(Bool_t savePDF) {savePDF_ = savePDF;}


                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;}


                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(LauAbsRValue* 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);


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


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


                virtual Double_t getTotNegLogLikelihood();

        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 weightEvents( const TString& dataFileName, const TString& dataTreeName ) = 0;


                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 fitExpt();


                Bool_t runMinimisation();


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


                virtual UInt_t readExperimentData();


                virtual Bool_t verifyFitData(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 setupResultsOutputs( const TString& histFileName, const TString& tableFileName );


                virtual void prepareInitialParArray( TObjArray& array );


                virtual void finaliseExperiment( const LauAbsFitter::FitStatus& fitStat, const TObjArray* parsFromMaster, const TMatrixD* covMat, TObjArray& parsToMaster );


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


                virtual void savePDFPlots(const TString& label) = 0;


                virtual void savePDFPlotsWave(const TString& label, const Int_t& spin) = 0;


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

                virtual void storePerEvtLlhds() = 0;

                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;

                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 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_;}

        private:
                LauAbsFitModel(const LauAbsFitModel& rhs);

                LauAbsFitModel& operator=(const LauAbsFitModel& rhs);

                // Various control booleans

                Bool_t compareFitData_; 
                Bool_t savePDF_; 
                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

                LauParameterPList fitVars_;

                LauParameterPSet resVars_;

                LauParameterList extraVars_;

                LauAbsRValuePList conVars_;

                // Input data and output ntuple

                LauFitDataTree* inputFitData_;
                LauGenNtuple* genNtuple_;
                LauGenNtuple* sPlotNtuple_;

                // 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