LauSimpleFitModel.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_SIMPLE_FIT_MODEL
#define LAU_SIMPLE_FIT_MODEL

#include <vector>

#include "TString.h"

#include "LauAbsFitModel.hh"
#include "LauParameter.hh"

class TH2;
class LauAbsBkgndDPModel;
class LauAbsCoeffSet;
class LauIsobarDynamics;
class LauAbsPdf;
class LauEffModel;
class LauEmbeddedData;
class LauKinematics;
class LauScfMap;


class LauSimpleFitModel : public LauAbsFitModel {

        public:

                explicit LauSimpleFitModel(LauIsobarDynamics* sigDPModel);

                virtual ~LauSimpleFitModel();


                virtual void setNSigEvents(LauParameter* nSigEvents);


                virtual void setNBkgndEvents(LauParameter* nBkgndEvents);


                void setBkgndDPModel(const TString& bkgndClass, LauAbsBkgndDPModel* bkgndModel);


                void splitSignalComponent( const TH2* dpHisto, const Bool_t upperHalf = kFALSE, const Bool_t fluctuateBins = kFALSE, LauScfMap* scfMap = 0 );


                void splitSignalComponent( const Double_t scfFrac, const Bool_t fixed );

                Bool_t useSCF() const { return useSCF_; }

                Bool_t useSCFHist() const { return useSCFHist_; }

                Bool_t smearSCFDP() const { return (scfMap_ != 0); }


                void setSignalPdf(LauAbsPdf* pdf);


                void setSCFPdf(LauAbsPdf* pdf);


                void setBkgndPdf(const TString& bkgndClass, LauAbsPdf* pdf);


                void embedSignal(const TString& fileName, const TString& treeName,
                                Bool_t reuseEventsWithinEnsemble, Bool_t reuseEventsWithinExperiment = kFALSE,
                                Bool_t useReweighting = kFALSE);


                void embedBkgnd(const TString& bkgndClass, const TString& fileName, const TString& treeName,
                                Bool_t reuseEventsWithinEnsemble, Bool_t reuseEventsWithinExperiment = kFALSE);


                virtual void setAmpCoeffSet(LauAbsCoeffSet* coeffSet);


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

        protected:
                typedef std::map< TString, std::pair<Int_t,Double_t> > LauGenInfo;

                typedef std::vector<LauAbsBkgndDPModel*> LauBkgndDPModelList;

                typedef std::vector<LauPdfList> LauBkgndPdfsList;

                typedef std::vector<LauParameter*> LauBkgndYieldList;

                typedef std::vector<LauEmbeddedData*> LauBkgndEmbDataList;

                typedef std::vector<Bool_t> LauBkgndReuseEventsList;

                virtual void initialise();

                virtual void initialiseDPModels();

                virtual void recalculateNormalisation();

                virtual void updateCoeffs();

                virtual Bool_t genExpt();

                virtual void propagateParUpdates();

                virtual void cacheInputFitVars();

                virtual void checkInitFitParams();


                virtual void finaliseFitResults(const TString& tablePrefixName);


                virtual void printFitFractions(std::ostream& output);


                virtual void writeOutTable(const TString& outputFile);

                virtual void storePerEvtLlhds();

                // Methods to do with calculating the likelihood functions
                // and manipulating the fitting parameters.


                virtual Double_t getTotEvtLikelihood(UInt_t iEvt);


                virtual void getEvtDPLikelihood(UInt_t iEvt);


                virtual Double_t getEvtSCFDPLikelihood(UInt_t iEvt);


                virtual void getEvtExtraLikelihoods(UInt_t iEvt);


                virtual Double_t getEventSum() const;
                
                void setSignalDPParameters();

                void setExtraPdfParameters();

                void setFitNEvents();

                void setExtraNtupleVars();

                void randomiseInitFitPars();

                virtual void setupBkgndVectors();

                LauGenInfo eventsToGenerate();

                Bool_t generateSignalEvent();


                Bool_t generateBkgndEvent(UInt_t bkgndID);

                void setupGenNtupleBranches();

                void setDPBranchValues();


                void generateExtraPdfValues(LauPdfList* extraPdfs, LauEmbeddedData* embeddedData);


                void addSPlotNtupleBranches(const LauPdfList* extraPdfs, const TString& prefix);


                Double_t setSPlotNtupleBranchValues(LauPdfList* extraPdfs, const TString& prefix, UInt_t iEvt);

                void updateSigEvents();

                virtual void setupSPlotNtupleBranches();

                virtual LauSPlot::NameSet variableNames() const;

                virtual LauSPlot::NumbMap freeSpeciesNames() const;

                virtual LauSPlot::NumbMap fixdSpeciesNames() const;

                virtual LauSPlot::TwoDMap twodimPDFs() const;

                virtual Bool_t splitSignal() const {return this->useSCF();}

                virtual Bool_t scfDPSmear() const {return (scfMap_ != 0);}


                void appendBinCentres( LauFitDataTree* inputData );

        private:
                LauSimpleFitModel(const LauSimpleFitModel& rhs);

                LauSimpleFitModel& operator=(const LauSimpleFitModel& rhs);

                LauIsobarDynamics* sigDPModel_;

                LauBkgndDPModelList bkgndDPModels_;

                LauKinematics *kinematics_;

                LauPdfList signalPdfs_;

                LauPdfList scfPdfs_;

                LauBkgndPdfsList bkgndPdfs_;

                Bool_t usingBkgnd_;

                UInt_t nSigComp_;

                UInt_t nSigDPPar_; 

                UInt_t nExtraPdfPar_; 

                UInt_t nNormPar_;

                std::vector<LauAbsCoeffSet*> coeffPars_;

                LauParArray fitFrac_;

                LauParArray fitFracEffUnCorr_;

                LauParameter meanEff_;

                LauParameter dpRate_;

                LauParameter* signalEvents_;

                LauBkgndYieldList bkgndEvents_;

                Bool_t useSCF_;

                Bool_t useSCFHist_;

                LauParameter scfFrac_;

                LauEffModel* scfFracHist_;

                LauScfMap* scfMap_;

                std::vector<Double_t> recoSCFFracs_;

                std::vector<Double_t> fakeSCFFracs_;

                std::vector<Double_t> recoJacobians_;

                std::vector<Double_t> fakeJacobians_;

                Bool_t compareFitData_;

                std::vector<LauComplex> coeffs_;

                // Embedding full simulation events

                LauEmbeddedData* signalTree_;

                LauBkgndEmbDataList bkgndTree_;

                Bool_t reuseSignal_;

                Bool_t useReweighting_;

                LauBkgndReuseEventsList reuseBkgnd_;

                Double_t sigDPLike_;

                Double_t scfDPLike_;

                std::vector<Double_t> bkgndDPLike_;

                Double_t sigExtraLike_;

                Double_t scfExtraLike_;

                std::vector<Double_t> bkgndExtraLike_;

                Double_t sigTotalLike_;

                Double_t scfTotalLike_;

                std::vector<Double_t> bkgndTotalLike_;

                ClassDef(LauSimpleFitModel,0) // Total fit/ToyMC model

};

#endif