LauSimpleFitModel.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_SIMPLE_FIT_MODEL
#define LAU_SIMPLE_FIT_MODEL
 
#include "LauAbsFitModel.hh"
#include "LauComplex.hh"
#include "LauParameter.hh"
 
#include "TString.h"
 
#include <vector>
 
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( LauAbsRValue* 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 std::map<TString, LauComplex> getDPAmps( const Double_t m13Sq, const Double_t m23Sq );
 
 
    virtual std::map<TString, Double_t> getDPLikelihoods( const Double_t m13Sq, const Double_t m23Sq );
 
  protected:
    typedef std::map<TString, std::pair<Int_t, Double_t>> LauGenInfo;
 
    typedef std::vector<LauAbsBkgndDPModel*> LauBkgndDPModelList;
 
    typedef std::vector<LauPdfPList> 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 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();
 
    virtual void setupBkgndVectors();
 
    std::pair<LauGenInfo, Bool_t> eventsToGenerate();
 
    Bool_t generateSignalEvent();
 
 
    Bool_t generateBkgndEvent( UInt_t bkgndID );
 
    void setupGenNtupleBranches();
 
    void setDPBranchValues();
 
 
    void generateExtraPdfValues( LauPdfPList* extraPdfs, LauEmbeddedData* embeddedData );
 
 
    void addSPlotNtupleBranches( const LauPdfPList* extraPdfs, const TString& prefix );
 
 
    Double_t setSPlotNtupleBranchValues( LauPdfPList* 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_;
 
    LauPdfPList signalPdfs_;
 
    LauPdfPList 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