DQMHistAnalysisPXDInjection.cc

/**************************************************************************
 * 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.                  *
 **************************************************************************/
//+
// File : DQMHistAnalysisPXDInjection.cc
// Description : DQM module, which gives histograms showing occupancies after injection
//-
 
 
#include <dqm/analysis/modules/DQMHistAnalysisPXDInjection.h>
#include <TROOT.h>
 
using namespace std;
using namespace Belle2;
 
//-----------------------------------------------------------------
//                 Register the Module
//-----------------------------------------------------------------
REG_MODULE(DQMHistAnalysisPXDInjection);
 
//-----------------------------------------------------------------
//                 Implementation
//-----------------------------------------------------------------
 
DQMHistAnalysisPXDInjectionModule::DQMHistAnalysisPXDInjectionModule() : DQMHistAnalysisModule()
{
  // This module CAN NOT be run in parallel!
  setDescription("DQM Analysis for PXD Hits after Injection");
 
  addParam("histogramDirectoryName", m_histogramDirectoryName, "Name of the directory where histograms were placed",
           std::string("PXDINJ"));
  B2DEBUG(1, "DQMHistAnalysisPXDInjection: Constructor done.");
}
 
void DQMHistAnalysisPXDInjectionModule::initialize()
{
 
  gROOT->cd(); // this seems to be important, or strange things happen
 
  m_cInjectionLERPXD = new TCanvas(m_histogramDirectoryName +
                                   TString("/c_PXDInjectionLER")); // different name, as we have the other module
  m_cInjectionHERPXD = new TCanvas(m_histogramDirectoryName +
                                   TString("/c_PXDInjectionHER")); // which makes this hist for ALL detectors (SVD, ECl, TOP)
  m_hInjectionLERPXD = new TH1F("HitInjectionLERPXD", "PXD Hits after LER Injection;Time in #mus;Mean Hits/event", 4000, 0, 20000);
  m_hInjectionHERPXD = new TH1F("HitInjectionHERPXD", "PXD Hits after HER Injection;Time in #mus;Mean Hits/event", 4000, 0, 20000);
  const VXD::GeoCache& vxdGeometry = VXD::GeoCache::getInstance();
  std::vector<VxdID> vxdsensors = vxdGeometry.getListOfSensors();
  for (const auto& avxdid : vxdsensors) {
    VXD::SensorInfoBase info = vxdGeometry.getSensorInfo(avxdid);
    if (info.getType() != VXD::SensorInfoBase::PXD) continue;
    m_sensors.push_back(avxdid);
  }
 
  for (const auto& avxdid : m_sensors) {
    TString buff = (std::string)avxdid;
    TString bufful = buff;
    bufful.ReplaceAll(".", "_");
 
    m_cInjectionLERPXDMod[avxdid] = new TCanvas(m_histogramDirectoryName + "/c_PXDInjectionLER_" + bufful);
    m_cInjectionHERPXDMod[avxdid] = new TCanvas(m_histogramDirectoryName + "/c_PXDInjectionHER_" + bufful);
    m_hInjectionLERPXDMod[avxdid] = new TH1F("HitInjectionLERPXD_" + bufful,
                                             "PXD Hits after LER Injection " + buff + "/Time;Time in #mus;Count/Time (5 #mus bins)", 4000, 0, 20000);
    m_hInjectionHERPXDMod[avxdid] = new TH1F("HitInjectionHERPXD_" + bufful,
                                             "PXD Hits after HER Injection " + buff + "/Time;Time in #mus;Count/Time (5 #mus bins)", 4000, 0, 20000);
    m_cInjectionLERPXDModNorm[avxdid] = new TCanvas(m_histogramDirectoryName + "/c_PXDInjectionLERNorm_" + bufful);
    m_cInjectionHERPXDModNorm[avxdid] = new TCanvas(m_histogramDirectoryName + "/c_PXDInjectionHERNorm_" + bufful);
    m_hInjectionLERPXDModNorm[avxdid] = new TH1F("HitInjectionLERPXDNorm_" + bufful,
                                                 "PXD Hits after LER Injection " + buff + " normalized to 1.1.x/Time;Time in #mus;factor", 4000, 0, 20000);
    m_hInjectionHERPXDModNorm[avxdid] = new TH1F("HitInjectionHERPXDNorm_" + bufful,
                                                 "PXD Hits after HER Injection " + buff + " normalized to 1.1.x/Time;Time in #mus;factor", 4000, 0, 20000);
  }
 
  B2DEBUG(1, "DQMHistAnalysisPXDInjection: initialized.");
}
 
 
void DQMHistAnalysisPXDInjectionModule::beginRun()
{
  B2DEBUG(1, "DQMHistAnalysisPXDInjection: beginRun called.");
 
//   m_cInjectionLERPXD->Clear(); // FIXME, unclear if this lets to crashes on new run?
//   m_cInjectionLERPXDOcc->Clear();
//   m_cInjectionLERECL->Clear();
//   m_cInjectionHERPXD->Clear();
//   m_cInjectionHERPXDOcc->Clear();
//   m_cInjectionHERECL->Clear();
}
 
 
void DQMHistAnalysisPXDInjectionModule::event()
{
  //Finding only one of them should only happen in very strange situations...
  if (auto Triggers = findHist(m_histogramDirectoryName, "PXDEOccInjLER"); Triggers != nullptr) {
    if (auto Hits = findHist(m_histogramDirectoryName, "PXDOccInjLER"); Hits != nullptr) {
      m_hInjectionLERPXD->Divide(Hits, Triggers);
    }
    auto RefMod_fw = findHist(m_histogramDirectoryName, "PXDOccInjLER_1_1_1");
    auto RefMod_bw = findHist(m_histogramDirectoryName, "PXDOccInjLER_1_1_2");
 
    // assume trigger is the same for all modules (makes sense :-)
    for (const auto& avxdid : m_sensors) {
      TString buff = (std::string)avxdid;
      TString bufful = buff;
      bufful.ReplaceAll(".", "_");
 
      if (auto Hits = findHist(m_histogramDirectoryName, ("PXDOccInjLER_" + bufful).Data()); Hits != nullptr) {
        m_hInjectionLERPXDMod[avxdid]->Divide(Hits, Triggers);
        if (avxdid.getSensorNumber() == 1 && RefMod_fw) {
          m_hInjectionLERPXDModNorm[avxdid]->Divide(Hits, RefMod_fw);
        } else if (avxdid.getSensorNumber() == 2 && RefMod_bw) {
          m_hInjectionLERPXDModNorm[avxdid]->Divide(Hits, RefMod_bw);
        }
      }
 
    }
 
  }
 
  //Finding only one of them should only happen in very strange situations...
  if (auto Triggers = findHist(m_histogramDirectoryName, "PXDEOccInjHER"); Triggers != nullptr) {
    if (auto Hits = findHist(m_histogramDirectoryName, "PXDOccInjHER");
        Hits != 0) {
      m_hInjectionHERPXD->Divide(Hits, Triggers);
    }
    auto RefMod_fw = findHist(m_histogramDirectoryName, "PXDOccInjHER_1_1_1");
    auto RefMod_bw = findHist(m_histogramDirectoryName, "PXDOccInjHER_1_1_2");
 
    // assume trigger is the same for all modules (makes sense :-)
    for (const auto& avxdid : m_sensors) {
      TString buff = (std::string)avxdid;
      TString bufful = buff;
      bufful.ReplaceAll(".", "_");
      if (auto Hits = findHist(m_histogramDirectoryName, ("PXDOccInjHER_" + bufful).Data());
          Hits != nullptr) {
        m_hInjectionHERPXDMod[avxdid]->Divide(Hits, Triggers);
        if (avxdid.getSensorNumber() == 1 && RefMod_fw) {
          m_hInjectionHERPXDModNorm[avxdid]->Divide(Hits, RefMod_fw);
        } else if (avxdid.getSensorNumber() == 2 && RefMod_bw) {
          m_hInjectionHERPXDModNorm[avxdid]->Divide(Hits, RefMod_bw);
        }
      }
 
 
    }
  }
 
  m_cInjectionLERPXD->Clear();
  m_cInjectionLERPXD->cd(0);
  m_cInjectionLERPXD->Pad()->SetLogy();
  m_hInjectionLERPXD->Draw("hist");
 
  m_cInjectionHERPXD->Clear();
  m_cInjectionHERPXD->cd(0);
  m_cInjectionHERPXD->Pad()->SetLogy();
  m_hInjectionHERPXD->Draw("hist");
 
  for (const auto& avxdid : m_sensors) {
    m_cInjectionHERPXDMod[avxdid]->Clear();
    m_cInjectionHERPXDMod[avxdid]->cd(0);
    m_cInjectionHERPXDMod[avxdid]->Pad()->SetLogy();
    m_hInjectionHERPXDMod[avxdid]->Draw("hist");
    m_cInjectionHERPXDModNorm[avxdid]->Clear();
    m_cInjectionHERPXDModNorm[avxdid]->cd(0);
    m_hInjectionHERPXDModNorm[avxdid]->Draw("hist");
    m_cInjectionLERPXDMod[avxdid]->Clear();
    m_cInjectionLERPXDMod[avxdid]->cd(0);
    m_cInjectionLERPXDMod[avxdid]->Pad()->SetLogy();
    m_hInjectionLERPXDMod[avxdid]->Draw("hist");
    m_cInjectionLERPXDModNorm[avxdid]->Clear();
    m_cInjectionLERPXDModNorm[avxdid]->cd(0);
    m_hInjectionLERPXDModNorm[avxdid]->Draw("hist");
  }
}
 
 
void DQMHistAnalysisPXDInjectionModule::terminate()
{
  if (m_cInjectionLERPXD) delete m_cInjectionLERPXD;
  if (m_cInjectionHERPXD) delete m_cInjectionHERPXD;
  if (m_hInjectionLERPXD) delete m_hInjectionLERPXD;
  if (m_hInjectionHERPXD) delete m_hInjectionHERPXD;
 
  for (const auto& avxdid : m_sensors) {
    if (m_cInjectionLERPXDMod[avxdid]) delete m_cInjectionLERPXDMod[avxdid];
    if (m_cInjectionHERPXDMod[avxdid]) delete m_cInjectionHERPXDMod[avxdid];
    if (m_hInjectionLERPXDMod[avxdid]) delete m_hInjectionLERPXDMod[avxdid];
    if (m_hInjectionHERPXDMod[avxdid]) delete m_hInjectionHERPXDMod[avxdid];
    if (m_cInjectionLERPXDModNorm[avxdid]) delete m_cInjectionLERPXDModNorm[avxdid];
    if (m_cInjectionHERPXDModNorm[avxdid]) delete m_cInjectionHERPXDModNorm[avxdid];
    if (m_hInjectionLERPXDModNorm[avxdid]) delete m_hInjectionLERPXDModNorm[avxdid];
    if (m_hInjectionHERPXDModNorm[avxdid]) delete m_hInjectionHERPXDModNorm[avxdid];
  }
}