LauSPlot.hh

Go to the documentation of this file.

// Copyright University of Warwick 2006 - 2013.
// 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

/**********************************************************************
 *                                                                    *
 * Copyright (c) 2005 ROOT Foundation,  CERN/PH-SFT                   *
 *                                                                    *
 **********************************************************************/

#ifndef LAU_SPLOT
#define LAU_SPLOT

#include <vector>
#include <map>
#include <set>

#include "TMatrixD.h"
#include "TString.h"

class TEventList;
class TLeaf;
class TFile;
class TTree;


class LauSPlot : public TObject {

        public:
                typedef std::set<TString> NameSet;

                typedef std::map<TString,Double_t> NumbMap;

                typedef std::map<TString,TLeaf*> LeafMap;

                typedef std::multimap< TString, std::pair<TString,TString> > TwoDMap;


                LauSPlot(const TString& fileName, const TString& treeName,
                                Int_t firstExpt,
                                Int_t nExpt,
                                const NameSet& variableNames,
                                const LauSPlot::NumbMap& freeSpecies,
                                const LauSPlot::NumbMap& fixdSpecies,
                                const TwoDMap& twodimPDFs,
                                Bool_t sigSplit = kFALSE,
                                Bool_t scfDPSmeared = kFALSE);

                virtual ~LauSPlot();


                void runCalculations(const TString& option = "q");

                void writeOutResults();


                const std::vector<LauSPlot::NumbMap>& totalPdf() const {return pdfTot_;}

        protected:

                Bool_t readInput() const {return readInput_;}


                void readInput(Bool_t ok) {readInput_ = ok;}


                Bool_t signalSplit() const {return signalSplit_;}


                Bool_t scfDPSmear() const {return scfDPSmear_;}


                Bool_t definedCNBranches() const {return definedCNBranches_;}


                void definedCNBranches(Bool_t defined) {definedCNBranches_ = defined;}


                Bool_t definedSWeightBranches() const {return definedSWeightBranches_;}


                void definedSWeightBranches(Bool_t defined) {definedSWeightBranches_ = defined;}

                void openInputFileAndTree();

                void readInputInfo();

                Bool_t readInputLeaves();

                Bool_t checkLeaves() const;

                void createCNTree();
                void defineCNBranches();

                void createSWeightTree();
                void defineSWeightBranches();


                void setExperiment(Int_t iExpt);

                void readExpt();

                void checkFitter() const;


                void initialiseFitter(const TString& opt);

                void setFitParameters() const;

                void runFit();


                void retrieveFittedParameters(const TString& opt);


                void printCovMatrixElements(const Double_t * covmat = 0) const;


                void printSumOfWeights(const TString& exclName) const;

                // Calculate the covariance matrix from the various PDFs
                Bool_t calcCovMatrix();


                void calcTotPDFValues(const TString& exclName);


                void calcCNCoeffs(const TString& exclName, const Double_t * covmat = 0);


                void calcSWeights(const TString& exclName, Double_t * covmat = 0);


                void copyEventWeights(Int_t iEvent);

                void fillCNBranches();

                void fillSWeightBranches();

                void addFriendTree();

        private:
                LauSPlot(const LauSPlot& rhs);

                LauSPlot& operator=(const LauSPlot& rhs);

                TString fileName_;
                TString inputTreeName_;
                TString cnTreeName_;
                TString sweightTreeName_;
                TFile*  file_;
                TTree*  inputTree_;
                TTree*  cnTree_;
                TTree*  sweightTree_;

                TEventList* eventList_;

                LeafMap leaves_;

                NameSet   variableNames_;
                NumbMap   freeSpecies_;
                NumbMap   fixdSpecies_;
                NumbMap   origFreeSpecies_;
                NumbMap   origFixdSpecies_;
                TwoDMap   twodimPDFs_;

                const Bool_t signalSplit_;
                const Bool_t scfDPSmear_;

                Bool_t readInput_;
                Bool_t definedCNBranches_;
                Bool_t definedSWeightBranches_;

                Int_t    firstExpt_;
                Int_t    nExpt_;
                Int_t    iExpt_;
                Int_t    nEvents_;
                Int_t    nDiscVars_;
                Int_t    nFreeSpecies_;
                Int_t    nFixdSpecies_;
                Int_t    nSpecies_;

                std::vector<NumbMap> pdfTot_;
                std::vector<std::map<TString,NumbMap> > discPdf_;
                std::vector<Double_t> scfFrac_;

                TMatrixD covMat_;

                std::vector< std::map<TString,NumbMap> > sWeights_;
                std::map<TString,NumbMap> sWeightsCurrent_;
                std::map<TString,NumbMap> cN_;

                ClassDef(LauSPlot, 0)
};

#endif