BmnLambdaAnalRun7.h

Go to the documentation of this file.

#ifndef BMNLAMBDAANALRUN7_H
#define BMNLAMBDAANALRUN7_H 1
 
#include "TObjString.h"
 
#include <BmnMassSpectrumAnal.h>
#include <set>
 
using namespace std;
 
// Class to store signal (and its error, if necessary) for different samples of data and path bins
 
class SdeltaS
{
  public:
    TString dSet;   // MC or DATA
 
    Int_t pathBin = -1;   // path bin
    Int_t ptBin = -1;     // pt bin
    Int_t yBin = -1;      // y bin
 
    Int_t s;
    Int_t ds;
};
 
class TriggerEfficiency : public TObject
{
  public:
    TriggerEfficiency() { ; }
 
    TriggerEfficiency(TString tr, pair<Int_t, Int_t> mult, pair<Double_t, Double_t> e)
    {
        trigg = tr;
 
        minMult = mult.first;
        maxMult = mult.second;
 
        eff = e.first;
        errEff = e.second;
    }
 
    virtual ~TriggerEfficiency() { ; }
 
    TString trigger() { return trigg; }
 
    pair<Int_t, Int_t> multilplicity() { return make_pair(minMult, maxMult); }
 
    Double_t efficiency() { return eff; }
 
    Double_t efficiencyError() { return errEff; }
 
  private:
    TString trigg;
 
    Int_t minMult;
    Int_t maxMult;
 
    Double_t eff;
    Double_t errEff;
 
    ClassDef(TriggerEfficiency, 1)
};
 
class BmnLambdaAnalRun7 : public BmnMassSpectrumAnal
{
  public:
    BmnLambdaAnalRun7()
        : fTrigEffs(new TClonesArray("TriggerEfficiency"))
    {}
 
    BmnLambdaAnalRun7(TString dir)
        : BmnMassSpectrumAnal(dir)
        , fTrigEffs(nullptr)
    {
 
        fPtBinMap.clear();
        fYBinMap.clear();
 
        isMc = kFALSE;
    }
 
    // Constructor with two input dirs (data and MC)
 
    BmnLambdaAnalRun7(TString dirMc, TString dirData, TString target = "")
        : fTrigEffs(nullptr)
    {
 
        fPtBinMap.clear();
        fYBinMap.clear();
 
        isMc = kTRUE;
 
        BmnMassSpectrumAnal* mc = new BmnMassSpectrumAnal(dirMc);
        fMcList = mc->GetFileList();
        delete mc;
 
        BmnMassSpectrumAnal* data = new BmnMassSpectrumAnal(dirData);
        data->SetTarget(target);
        fDataList = data->createFilelist();
        delete data;
 
        hSpectrumImproved = nullptr;
    }
 
    virtual ~BmnLambdaAnalRun7()
    {
        if (fTrigEffs)
            delete fTrigEffs;
    }
 
    void SetIsMc(Bool_t flag) { isMc = flag; }
 
    // Cuts to be used for analysis ...
 
    void SetCuts(TString target,
                 Double_t DCA0,
                 Double_t DCA1,
                 Double_t DCA2,
                 Double_t DCA12,
                 Double_t PATH = -1,
                 Int_t nHitsPos = 2,
                 Int_t nHitsNeg = 2)
    {
 
        BmnParticlePairCut* pCut = new BmnParticlePairCut();
        pCut->SetDca0(DCA0);
        pCut->SetDca1(DCA1);
        pCut->SetDca2(DCA2);
        pCut->SetDca12(DCA12);
        pCut->SetPath(PATH);
        pCut->SetNHitsGemPos(nHitsPos);
        pCut->SetNHitsGemNeg(nHitsNeg);
 
        fTargCutsMap[target] = pCut;
    }
 
    BmnParticlePairCut* GetCuts(TString target) const { return fTargCutsMap.find(target)->second; }
 
    void SetPtBins(vector<pair<Double_t, Double_t>> bins)
    {
        fPtBinMap.clear();
 
        nPtBins = bins.size();
 
        for (size_t iBin = 0; iBin < bins.size(); iBin++)
            fPtBinMap[iBin] = bins.at(iBin);
    }
 
    void SetYBins(vector<pair<Double_t, Double_t>> bins)
    {
        fYBinMap.clear();
 
        nYBins = bins.size();
 
        for (size_t iBin = 0; iBin < bins.size(); iBin++)
            fYBinMap[iBin] = bins.at(iBin);
    }
 
    void SetPathBins(vector<pair<Double_t, Double_t>> bins)
    {
        fPathBins.clear();
 
        nPathBins = bins.size();
 
        for (size_t iBin = 0; iBin < bins.size(); iBin++)
            fPathBins[iBin] = bins.at(iBin);
    }
 
    // Trigger efficiency ...
 
    void SetTriggerEffData(TString trigger, TString data) { fTrigEffData[trigger] = data; }
 
    // Getters ...
 
    map<TString, BmnParticlePairCut*> GetTargetCutsMap() { return fTargCutsMap; }
 
    // For specific use outside the class if needed ...
    TClonesArray* GetFilledArray() { return fTrigEffs; }
 
    map<Int_t, pair<Double_t, Double_t>> GetSignalPtBinMap() { return fSdeltaS_PtBinMap; }
 
    map<Int_t, pair<Double_t, Double_t>> GetSignalYBinMap() { return fSdeltaS_YBinMap; }
 
    void doAllTargetsAnal();
    void doTargetAnal(TString target);
    void doTargetAnal(vector<TString> targets);
 
  private:
    void targetListsByCutsEstablished(
        set<TString>&,
        set<TString>&);   // Checking whether the established cuts are the same for all targets ...
    void DrawH(TH1F*, Double_t, Double_t, pair<Double_t, Double_t>, pair<Double_t, Double_t>, Int_t si = 1);
 
    void doTargetAnal();   // For internal use in the class ...
    void doTargetAnalPath();
 
  public:
    void ReadData()
    {
        fTrigEffs = new TClonesArray("TriggerEfficiency");
 
        for (auto trigger : fTrigEffData) {
            TString trig = trigger.first;
            TString data = trigger.second;
 
            TFile* f = new TFile(data.Data());
            TH1F* h = (TH1F*)f->Get("Eff");
 
            if (!h)
                continue;
 
            for (Int_t iBin = 1; iBin < h->GetNbinsX() + 1; iBin++) {
                vector<Int_t> mults;
                vector<Double_t> effs;
 
                effs.push_back(h->GetBinContent(iBin));
                effs.push_back(h->GetBinError(iBin));
 
                TString label = (TString)h->GetXaxis()->GetBinLabel(iBin);
                label.ReplaceAll(")", "").ReplaceAll("[", "").ReplaceAll(",", "");
 
                TObjArray* tx = label.Tokenize(" ");
 
                for (Int_t i = 0; i < tx->GetEntries(); i++)
                    mults.push_back(((TObjString*)(tx->At(i)))->String().Atoi());
 
                new ((*fTrigEffs)[fTrigEffs->GetEntriesFast()])
                    TriggerEfficiency(trig, make_pair(mults.at(0), mults.at(1)), make_pair(effs.at(0), effs.at(1)));
            }
        }
    }
 
  private:
    TClonesArray* fTrigEffs;
    map<TString, TString> fTrigEffData;
 
    // Maps with output S and deltaS for all bins over Pt and Y ...
    map<Int_t, pair<Double_t, Double_t>> fSdeltaS_PtBinMap;
    map<Int_t, pair<Double_t, Double_t>> fSdeltaS_YBinMap;
 
    vector<TString> fMcList;
    vector<TString> fDataList;
 
  protected:
    map<TString, BmnParticlePairCut*> fTargCutsMap;
 
    ClassDef(BmnLambdaAnalRun7, 0)
};
 
#endif