LauCPFitModel.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_CP_FIT_MODEL
#define LAU_CP_FIT_MODEL

#include <vector>

#include "TString.h"

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

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


class LauCPFitModel : public LauAbsFitModel {

        public:

                LauCPFitModel(LauIsobarDynamics* negModel, LauIsobarDynamics* posModel, Bool_t tagged = kTRUE, const TString& tagVarName = "charge");

                virtual ~LauCPFitModel();


                virtual void setNSigEvents(LauParameter* nSigEvents);


                virtual void setNSigEvents(LauParameter* nSigEvents, LauParameter* sigAsym, Bool_t forceAsym = kFALSE);


                virtual void setNBkgndEvents(LauParameter* nBkgndEvents);


                virtual void setNBkgndEvents(LauParameter* nBkgndEvents, LauParameter* bkgndAsym);


                void setBkgndDPModels(const TString& bkgndClass, LauAbsBkgndDPModel* negModel, LauAbsBkgndDPModel* posModel);


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

                // Set the DeltaE and mES models, i.e. give us the PDFs

                void setSignalPdfs(LauAbsPdf* negPdf, LauAbsPdf* posPdf);


                void setSCFPdfs(LauAbsPdf* negPdf, LauAbsPdf* posPdf);


                void setBkgndPdfs(const TString& bkgndClass, LauAbsPdf* negPdf, LauAbsPdf* posPdf);


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


                void embedNegBkgnd(const TString& bgClass, const TString& fileName, const TString& treeName,
                                Bool_t reuseEventsWithinEnsemble, Bool_t reuseEventsWithinExperiment = kFALSE);


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


                void embedPosBkgnd(const TString& bgClass, const TString& fileName, const TString& treeName,
                                Bool_t reuseEventsWithinEnsemble, Bool_t reuseEventsWithinExperiment = kFALSE);


                virtual void setAmpCoeffSet(LauAbsCoeffSet* coeffSet);

        protected:
                typedef std::map< std::pair<TString,Int_t>, 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 weightEvents( const TString& dataFileName, const TString& dataTreeName );

                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 printAsymmetries(std::ostream& output);


                virtual void writeOutTable(const TString& outputFile);


                virtual void savePDFPlots(const TString& label);


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


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


                void calcExtraFractions(Bool_t initValues = kFALSE);


                void calcAsymmetries(Bool_t initValues = kFALSE);

                virtual void setupBkgndVectors();

                std::pair<LauGenInfo,Bool_t> eventsToGenerate();

                Bool_t generateSignalEvent();


                Bool_t generateBkgndEvent(UInt_t bgID);

                void setupGenNtupleBranches();

                void setDPBranchValues();


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


                Bool_t storeSignalMCMatch(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 );

                LauIsobarDynamics* getNegSigModel() {return negSigModel_;}
                LauIsobarDynamics* getPosSigModel() {return posSigModel_;}

        private:
                LauCPFitModel(const LauCPFitModel& rhs);

                LauCPFitModel& operator=(const LauCPFitModel& rhs);

                LauIsobarDynamics *negSigModel_; 

                LauIsobarDynamics *posSigModel_;

                LauBkgndDPModelList negBkgndDPModels_; 

                LauBkgndDPModelList posBkgndDPModels_;

                LauKinematics *negKinematics_;

                LauKinematics *posKinematics_;

                LauPdfList negSignalPdfs_; 

                LauPdfList posSignalPdfs_;

                LauPdfList negScfPdfs_; 

                LauPdfList posScfPdfs_;

                LauBkgndPdfsList negBkgndPdfs_; 

                LauBkgndPdfsList posBkgndPdfs_;

                Bool_t usingBkgnd_;

                UInt_t nSigComp_;

                UInt_t nSigDPPar_;

                UInt_t nExtraPdfPar_;

                UInt_t nNormPar_;

                std::vector<LauAbsCoeffSet*> coeffPars_;

                LauParArray negFitFrac_; 

                LauParArray posFitFrac_; 

                LauParArray negFitFracEffUnCorr_;

                LauParArray posFitFracEffUnCorr_;

                LauParArray CPVFitFrac_; 

                LauParArray CPCFitFrac_;

                std::vector<LauParameter> fitFracAsymm_; 

                std::vector<LauParameter> acp_;

                LauParameter negMeanEff_; 

                LauParameter posMeanEff_;

                LauParameter negDPRate_;

                LauParameter posDPRate_;

                LauParameter* signalEvents_; 

                LauParameter* signalAsym_;

                Bool_t forceAsym_;

                LauBkgndYieldList bkgndEvents_; 

                LauBkgndYieldList bkgndAsym_;

                const Bool_t tagged_;

                const TString tagVarName_;

                Int_t curEvtCharge_;

                std::vector<Int_t> evtCharges_;

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

                TString negParent_;

                TString posParent_;

                std::vector<LauComplex> negCoeffs_;

                std::vector<LauComplex> posCoeffs_;

                // Embedding full simulation events

                LauEmbeddedData *negSignalTree_; 
                
                LauEmbeddedData *posSignalTree_;

                LauBkgndEmbDataList negBkgndTree_; 

                LauBkgndEmbDataList posBkgndTree_;

                Bool_t reuseSignal_;

                Bool_t useNegReweighting_; 

                Bool_t usePosReweighting_;

                LauBkgndReuseEventsList reuseBkgnd_;

                // Likelihood values
                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(LauCPFitModel,0) //  CP fit/ToyMC model

};

#endif