LauSPlot.hh

Go to the documentation of this file.

/*
Copyright 2006 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
*/

/**********************************************************************
 *                                                                    *
 * 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