LauCPFitModel.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_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(LauAbsRValue* nBkgndEvents);


                virtual void setNBkgndEvents(LauAbsRValue* nBkgndEvents, LauAbsRValue* 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<LauAbsRValue*> 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