BmnOfflineQaSteering.h

Go to the documentation of this file.

#include <BmnCSCStationSet.h>
#include <BmnGemStripStationSet.h>
#include <BmnSiliconStationSet.h>
#include <TMath.h>
#include <TNamed.h>
#include <TObjArray.h>
#include <TObjString.h>
#include <TSystem.h>
#include <TVector3.h>
#include <fstream>
#include <iostream>
#include <sstream>
#include <vector>
 
#ifndef BMNOFFLINEQASTEERING_H
#define BMNOFFLINEQASTEERING_H 1
 
using namespace std;
using namespace TMath;
 
class BmnOfflineQaSteering : public TNamed
{
  public:
    BmnOfflineQaSteering();
    // BmnOfflineQaSteering(TString) {};
 
    virtual ~BmnOfflineQaSteering();
 
    pair<Int_t, Int_t> GetCanvasSizes(Int_t run, TString setup, TString name, TString dim)
    {
        for (auto it : fCanvasAttributes) {
            if (TString(it[0]).Atoi() == run && it[1] == setup && name.Contains(TString(it[2]).Data())) {
                return (dim == "1d")   ? make_pair(TString(it[3]).Atoi(), TString(it[4]).Atoi())
                       : (dim == "2d") ? make_pair(TString(it[5]).Atoi(), TString(it[6]).Atoi())
                                       : make_pair(-1, -1);
            }
        }
        return make_pair(-1, -1);
    }
 
    Int_t GetNCanvases() { return fNCanvases; }
 
    Int_t GetNReleases() { return fNReleases; }
 
    vector<TString> GetListOfReleases() { return fListReleases; }
 
    vector<TString> GetListOfCanvases() { return fListCanvases; }
 
    pair<Int_t, Int_t> GetBorderRuns(Int_t period, TString setup = "BM@N")
    {
        if (period == 6 && setup == "SRC")
            return make_pair(-1, -1);
        return fBorderRuns.find(make_pair(period, setup))->second;
    }
 
    vector<TString> GetDetectors(Int_t period, TString setup = "BM@N")
    {
        if (period == 6 && setup == "SRC") {
            // Configuration does not exist !!!
            vector<TString> tmp;
            tmp.resize(0);
            return tmp;
        } else
            return fDetectors.find(make_pair(period, setup))->second;
    }
 
    vector<TString> GetTriggers(Int_t period, TString setup = "BM@N")
    {
        if (period == 6 && setup == "SRC") {
            // Configuration does not exist !!!
            vector<TString> tmp;
            tmp.resize(0);
            return tmp;
        } else
            return fTriggers.find(make_pair(period, setup))->second;
    }
 
    pair<Int_t, TString> GetRunAndSetupByRunId(Int_t id)
    {
        const Int_t nPeriods = 2;
        const Int_t nSetups = 2;
 
        Int_t runPeriods[nPeriods] = {6, 7};
        TString setups[nSetups] = {"BM@N", "SRC"};
 
        for (Int_t iPeriod = 0; iPeriod < nPeriods; iPeriod++)
            for (Int_t iSetup = 0; iSetup < nSetups; iSetup++)
                if (id >= GetBorderRuns(runPeriods[iPeriod], setups[iSetup]).first
                    && id <= GetBorderRuns(runPeriods[iPeriod], setups[iSetup]).second)
                    return make_pair(runPeriods[iPeriod], setups[iSetup]);
 
        return make_pair(-1, "");
    }
 
    Int_t GetNumberOfDets(Int_t period, TString setup, TString type)
    {
        // Possible det. types are: coordinate, time, calorimeter
        if (type != "coordinate" && type != "time" && type != "calorimeter")
            return -1;
        Int_t detCounter = 0;
        for (size_t iDet = 0; iDet < GetDetectors(period, setup).size(); iDet++) {
            TString det = GetDetectors(period, setup)[iDet];
 
            if (type == "coordinate") {
                if (det.Contains("GEM") || det.Contains("SILICON") || det.Contains("CSC"))
                    detCounter++;
            } else if (type == "time") {
                if (det.Contains("TOF400") || det.Contains("TOF700") || det.Contains("MWPC") || det.Contains("DCH"))
                    detCounter++;
            } else if (type == "calorimeter") {
                if (det.Contains("ECAL") || det.Contains("ZDC"))
                    detCounter++;
            }
        }
        return detCounter;
    }
 
    void SetGeometriesByRunId(Int_t id,
                              BmnGemStripStationSet*& gem,
                              BmnSiliconStationSet*& silicon,
                              BmnCSCStationSet*& csc)
    {
        TString gPathConfig = gSystem->Getenv("VMCWORKDIR");
 
        TString gPathGemConfig = gPathConfig + "/parameters/gem/XMLConfigs/";
        TString gPathSilConfig = gPathConfig + "/parameters/silicon/XMLConfigs/";
        TString gPathCscConfig = gPathConfig + "/parameters/csc/XMLConfigs/";
 
        const Int_t nPeriods = 2;
        const Int_t nSetups = 2;
 
        Int_t runPeriods[nPeriods] = {6, 7};
        TString setups[nSetups] = {"BM@N", "SRC"};
 
        TString confGEM = "";
        TString confSIL = "";
        TString confCSC = "";
 
        for (Int_t iPeriod = 0; iPeriod < nPeriods; iPeriod++)
            for (Int_t iSetup = 0; iSetup < nSetups; iSetup++)
                if (id >= GetBorderRuns(runPeriods[iPeriod], setups[iSetup]).first
                    && id <= GetBorderRuns(runPeriods[iPeriod], setups[iSetup]).second)
                {
 
                    if (iPeriod == 0 && iSetup == 0) {
                        // RUN6, BM@N
 
                        confGEM = "GemRunSpring2017.xml";
                        confSIL = "SiliconRunSpring2017.xml";
                    } else if (iPeriod == 1 && iSetup == 0) {
                        // RUN7, BM@N
 
                        confGEM = "GemRunSpring2018.xml";
                        confSIL = "SiliconRunSpring2018.xml";
                        confCSC = "CSCRunSpring2018.xml";
                    } else if (iPeriod == 1 && iSetup == 1) {
                        // RUN7, SRC
 
                        confGEM = "GemRunSRCSpring2018.xml";
                        confSIL = "SiliconRunSRCSpring2018.xml";
                        confCSC = "CSCRunSRCSpring2018.xml";
                    }
 
                    if (!gem)
                        gem = new BmnGemStripStationSet(gPathGemConfig + confGEM);
 
                    if (!silicon)
                        silicon = new BmnSiliconStationSet(gPathSilConfig + confSIL);
 
                    if (!confCSC.IsNull() && !csc)
                        csc = new BmnCSCStationSet(gPathCscConfig + confCSC);
                }
    }
 
    vector<Double_t> GetAxisAttributes(TString);
 
  private:
    void ParseSteerFile(TString f = "qaOffline.dat");
 
    Int_t fNCanvases;
    Int_t fNReleases;
 
    vector<TString> fListCanvases;
    vector<TString> fListReleases;
 
    vector<vector<TString>> fCanvasAttributes;
 
    map<pair<Int_t, TString>, pair<Int_t, Int_t>> fBorderRuns;   // (period, setup) --> (start, finish)
    map<pair<Int_t, TString>, vector<TString>> fDetectors;       // (period, setup) --> list of detectors
    map<pair<Int_t, TString>, vector<TString>> fTriggers;        // (period, setup) --> list of triggers
 
    ClassDef(BmnOfflineQaSteering, 1);
};
 
#endif