SVDSummaryPlots.h

/**************************************************************************
 * basf2 (Belle II Analysis Software Framework)                           *
 * Author: The Belle II Collaboration                                     *
 *                                                                        *
 * See git log for contributors and copyright holders.                    *
 * This file is licensed under LGPL-3.0, see LICENSE.md.                  *
 **************************************************************************/
 
#pragma once
#include <vxd/dataobjects/VxdID.h>
#include <string>
#include <regex>
#include <TH2F.h>
#include <TProfile.h>
 
namespace Belle2 {
  class SVDSummaryPlots: public TObject {
 
  public:
    SVDSummaryPlots():
      SVDSummaryPlots("", "") {}; 
    SVDSummaryPlots(TString name, TString title)
    {
      m_defaultHistogram = new TH2F(name.Data(), title.Data(),
                                    16, 0.5, 16.5,
                                    19, 0, 19);
 
      for (int view = VIndex ; view < UIndex + 1; view++) {
        std::string hname = name.Data();
        bool isU = (view == UIndex);
        customizeString(hname, isU);
        m_histos[view] = new TH2F(hname.c_str(), title.Data(),
                                  16, 0.5, 16.5,
                                  19, 0, 19);
        customize(*m_histos[view], view);
        m_Title[view] = m_histos[view]->GetTitle();
      }
    }
 
 
    ~SVDSummaryPlots() { clean(); };
 
    enum E_side { VIndex = 0, UIndex = 1 };
 
    TH2F* getHistogram(int view)
    {
      TH2F* returnValue = m_defaultHistogram;
      try {
        returnValue = m_histos[view];
      } catch (...) {
        B2WARNING("Unexpected view: " << view);
 
        returnValue = m_defaultHistogram;
      }
 
      return returnValue;
    }
 
    float getValue(const VxdID& vxdID, int view)
    {
      int layer = vxdID.getLayerNumber();
      int ladder = vxdID.getLadderNumber();
      int sensor = vxdID.getSensorNumber();
 
      int bin = m_histos[view]->FindBin(ladder, findBinY(layer, sensor));
      return getHistogram(view)->GetBinContent(bin);
    }
 
    float getValue(int layer, int ladder, int sensor, int view)
    {
      int bin = m_histos[view]->FindBin(ladder, findBinY(layer, sensor));
      return getHistogram(view)->GetBinContent(bin);
    }
 
    void fill(int layer, int ladder, int sensor, int view, float value)
    {
      getHistogram(view)->Fill(ladder, findBinY(layer, sensor), value);
    }
 
    void fill(const VxdID& vxdID, int view, float value)
    {
      int layer = vxdID.getLayerNumber();
      int ladder = vxdID.getLadderNumber();
      int sensor = vxdID.getSensorNumber();
 
      getHistogram(view)->Fill(ladder, findBinY(layer, sensor), value);
    }
 
    void setRunID(const TString& runID)
    {
      for (int view = VIndex ; view < UIndex + 1; view++) {
        // add blank if needed before adding runID
        if (!m_Title[view].EndsWith(" "))
          m_Title[view].Append(" ");
 
        getHistogram(view)->SetTitle(m_Title[view] + runID);
      }
    }
 
    void reset()
    {
      for (int view = VIndex ; view < UIndex + 1; view++)
        getHistogram(view)->Reset();
    }
 
    void setStats(bool stats = true)
    {
      for (int view = VIndex ; view < UIndex + 1; view++)
        getHistogram(view)->SetStats(stats);
    }
 
    void fill(const VxdID& vxdID, bool isU, float value)
    {
      int view = isU ? UIndex : VIndex;
 
      int layer = vxdID.getLayerNumber();
      int ladder = vxdID.getLadderNumber();
      int sensor = vxdID.getSensorNumber();
 
      getHistogram(view)->Fill(ladder, findBinY(layer, sensor), value);
    }
 
    void customizeString(std::string& base, bool isU)
    {
      std::string view = isU ? "U" : "V" ;
      base = std::regex_replace(base, std::regex("[@]view"), view);
      std::string side = isU ? "P" : "N" ;
      base = std::regex_replace(base, std::regex("[@]side"), side);
    }
 
    void clean()
    {
      delete m_histos[0];
      delete m_histos[1];
      delete m_defaultHistogram;
    }
 
  private:
 
    Int_t findBinY(Int_t layer, Int_t sensor)
    {
 
      if (layer == 3)
        return sensor; //2
      if (layer == 4)
        return 2 + 1 + sensor; //6
      if (layer == 5)
        return 6 + 1 + sensor; // 11
      if (layer == 6)
        return 11 + 1 + sensor; // 17
      else
        return -1;
    }
 
    TH2F* m_histos[2]; 
    TH2F* m_defaultHistogram = nullptr; 
    TString m_Title[2];    
    void customize(TH2F& histogram, int view)
    {
 
      const int nY = 19;
      TString Ylabels[nY] = {"", "L3.x.1", "L3.x.2",
                             " ", "L4.x.1", "L4.x.2", "L4.x.3",
                             "  ", "L5.x.1", "L5.x.2", "L5.x.3", "L5.x.4",
                             "   ", "L6.x.1", "L6.x.2", "L6.x.3", "L6.x.4", "L6.x.5", "    "
                            };
 
      histogram.SetMarkerSize(1.1);
      histogram.GetXaxis()->SetTitle("ladder number");
      histogram.GetXaxis()->SetLabelSize(0.04);
      for (unsigned short i = 0; i < nY; i++)
        histogram.GetYaxis()->SetBinLabel(i + 1, Ylabels[i].Data());
 
      bool isU = view == UIndex;
      std::string title = histogram.GetTitle();
      customizeString(title, isU);
      histogram.SetTitle(title.c_str());
 
      std::string xAxis = histogram.GetXaxis()->GetTitle();
      customizeString(xAxis, isU);
      histogram.SetXTitle(xAxis.c_str());
 
      std::string yAxis = histogram.GetYaxis()->GetTitle();
      customizeString(yAxis, isU);
      histogram.SetYTitle(yAxis.c_str());
 
      std::string zAxis = histogram.GetZaxis()->GetTitle();
      customizeString(zAxis, isU);
      histogram.SetZTitle(zAxis.c_str());
 
    }
 
 
    ClassDef(SVDSummaryPlots, 2);  
  };
 
 
}