KLMCalibrationChecker Class Reference

KLM calibration checker. More...

#include <KLMCalibrationChecker.h>

Public Member Functions
	KLMCalibrationChecker ()
	Constructor.
	~KLMCalibrationChecker ()
	Destructor.
void	setExperimentRun (int experiment, int run)
	Set experiment and run numbers.
void	setTestingPayload (const std::string &testingPayloadName)
	Set testing payload name.
void	setGlobalTag (const std::string &globalTagName)
	Set Global Tag name.
void	setAlignmentResultsFile (const std::string &alignmentResultsFile)
	Set alignment results file.
void	setStripEfficiencyResultsFile (const std::string &stripEfficiencyResultsFile)
	Set strip efficiency results file.
void	setTimeCableDelayResultsFile (const std::string &timeCableDelayResultsFile)
	Set time cable delay results file.
void	setTimeConstantsResultsFile (const std::string &timeConstantsResultsFile)
	Set time constants result file.
void	checkAlignment ()
	Check alignment.
void	checkStripEfficiency ()
	Check strip efficiency.
void	createStripEfficiencyHistograms ()
	Create strip efficiency histograms.
void	checkTimeCableDelay ()
	Check time cable delay.
void	checkTimeConstants ()
	Check time constants.

Private Member Functions
void	initializeDatabase ()
	Initialize the database.
void	resetDatabase ()
	Reset the database.
template<class T >
void	printPayloadInformation (DBObjPtr< T > &dbObject)
	Print payload information.

Private Attributes
int	m_experiment
	Experiment number.
int	m_run
	Run number.
std::string	m_testingPayloadName = ""
	Testing payload location.
std::string	m_GlobalTagName = ""
	Global Tag name.
std::string	m_AlignmentResultsFile = "alignment.root"
	Output file for alignment results.
std::string	m_StripEfficiencyResultsFile = "strip_efficiency.root"
	Output file for alignment results.
std::string	m_TimeCableDelayResultsFile = "timeCableDelay.root"
	Output file for time cable delay results.
std::string	m_TimeConstantsResultsFile = "timeConstants.root"
	Output file for time constants results.
const KLMElementNumbers *	m_ElementNumbers
	Element numbers.
StoreObjPtr< EventMetaData >	m_EventMetaData
	Event metadata.

Detailed Description

KLM calibration checker.

Definition at line 32 of file KLMCalibrationChecker.h.

Constructor & Destructor Documentation

KLMCalibrationChecker()

KLMCalibrationChecker

(

)

Constructor.

Definition at line 38 of file KLMCalibrationChecker.cc.

                                             :
  m_experiment(0),
  m_run(0),
  m_ElementNumbers(&(KLMElementNumbers::Instance()))
{
}

~KLMCalibrationChecker()

~KLMCalibrationChecker

(

)

Destructor.

Definition at line 45 of file KLMCalibrationChecker.cc.

{
}

Member Function Documentation

checkAlignment()

void checkAlignment

(

)

Check alignment.

Definition at line 88 of file KLMCalibrationChecker.cc.

{
  /* Initialize the database. */
  initializeDatabase();
  /* Now we can read the payload. */
  DBObjPtr<BKLMAlignment> bklmAlignment;
  DBObjPtr<EKLMAlignment> eklmAlignment;
  DBObjPtr<EKLMSegmentAlignment> eklmSegmentAlignment;
  DBObjPtr<BKLMAlignment> bklmAlignmentErrors("BKLMAlignment_ERRORS");
  DBObjPtr<EKLMAlignment> eklmAlignmentErrors("EKLMAlignment_ERRORS");
  DBObjPtr<EKLMSegmentAlignment> eklmSegmentAlignmentErrors("EKLMSegmentAlignment_ERRORS");
  DBObjPtr<BKLMAlignment> bklmAlignmentCorrections("BKLMAlignment_CORRECTIONS");
  DBObjPtr<EKLMAlignment> eklmAlignmentCorrections("EKLMAlignment_CORRECTIONS");
  DBObjPtr<EKLMSegmentAlignment> eklmSegmentAlignmentCorrections("EKLMSegmentAlignment_CORRECTIONS");
  if (!bklmAlignment.isValid() ||
      !eklmAlignment.isValid() ||
      !eklmSegmentAlignment.isValid() ||
      !bklmAlignmentErrors.isValid() ||
      !eklmAlignmentErrors.isValid() ||
      !eklmSegmentAlignmentErrors.isValid() ||
      !bklmAlignmentCorrections.isValid() ||
      !eklmAlignmentCorrections.isValid() ||
      !eklmSegmentAlignmentCorrections.isValid())
    B2FATAL("Alignment data are not valid.");
  if (m_GlobalTagName != "") {
    printPayloadInformation(bklmAlignment);
    printPayloadInformation(eklmAlignment);
    printPayloadInformation(eklmSegmentAlignment);
    printPayloadInformation(bklmAlignmentErrors);
    printPayloadInformation(eklmAlignmentErrors);
    printPayloadInformation(eklmSegmentAlignmentErrors);
    printPayloadInformation(bklmAlignmentCorrections);
    printPayloadInformation(eklmAlignmentCorrections);
    printPayloadInformation(eklmSegmentAlignmentCorrections);
  }
  /* Create trees with alignment results. */
  int section, sector, layer, plane, segment, param;
  float value, correction, error;
  TFile* alignmentResults = new TFile(m_AlignmentResultsFile.c_str(),
                                      "recreate");
  TTree* bklmModuleTree = new TTree("bklm_module",
                                    "BKLM module alignment data.");
  bklmModuleTree->Branch("experiment", &m_experiment, "experiment/I");
  bklmModuleTree->Branch("run", &m_run, "run/I");
  bklmModuleTree->Branch("section", &section, "section/I");
  bklmModuleTree->Branch("sector", &sector, "sector/I");
  bklmModuleTree->Branch("layer", &layer, "layer/I");
  bklmModuleTree->Branch("param", &param, "param/I");
  bklmModuleTree->Branch("value", &value, "value/F");
  bklmModuleTree->Branch("correction", &correction, "correction/F");
  bklmModuleTree->Branch("error", &error, "error/F");
  TTree* eklmModuleTree = new TTree("eklm_module",
                                    "EKLM module alignment data.");
  eklmModuleTree->Branch("experiment", &m_experiment, "experiment/I");
  eklmModuleTree->Branch("run", &m_run, "run/I");
  eklmModuleTree->Branch("section", &section, "section/I");
  eklmModuleTree->Branch("sector", &sector, "sector/I");
  eklmModuleTree->Branch("layer", &layer, "layer/I");
  eklmModuleTree->Branch("param", &param, "param/I");
  eklmModuleTree->Branch("value", &value, "value/F");
  eklmModuleTree->Branch("correction", &correction, "correction/F");
  eklmModuleTree->Branch("error", &error, "error/F");
  TTree* eklmSegmentTree = new TTree("eklm_segment",
                                     "EKLM segment alignment data.");
  eklmSegmentTree->Branch("experiment", &m_experiment, "experiment/I");
  eklmSegmentTree->Branch("run", &m_run, "run/I");
  eklmSegmentTree->Branch("section", &section, "section/I");
  eklmSegmentTree->Branch("sector", &sector, "sector/I");
  eklmSegmentTree->Branch("layer", &layer, "layer/I");
  eklmSegmentTree->Branch("plane", &plane, "plane/I");
  eklmSegmentTree->Branch("segment", &segment, "segment/I");
  eklmSegmentTree->Branch("param", &param, "param/I");
  eklmSegmentTree->Branch("value", &value, "value/F");
  eklmSegmentTree->Branch("correction", &correction, "correction/F");
  eklmSegmentTree->Branch("error", &error, "error/F");
  const KLMAlignmentData* alignment, *alignmentError, *alignmentCorrection;
  KLMAlignmentData zeroAlignment(0, 0, 0, 0, 0, 0);
  KLMChannelIndex klmModules(KLMChannelIndex::c_IndexLevelLayer);
  for (KLMChannelIndex& klmModule : klmModules) {
    KLMModuleNumber module = klmModule.getKLMModuleNumber();
    if (klmModule.getSubdetector() == KLMElementNumbers::c_BKLM) {
      alignment = bklmAlignment->getModuleAlignment(module);
      alignmentError = bklmAlignmentErrors->getModuleAlignment(module);
      alignmentCorrection =
        bklmAlignmentCorrections->getModuleAlignment(module);
    } else {
      alignment = eklmAlignment->getModuleAlignment(module);
      alignmentError = eklmAlignmentErrors->getModuleAlignment(module);
      alignmentCorrection =
        eklmAlignmentCorrections->getModuleAlignment(module);
    }
    if (alignment == nullptr)
      B2FATAL("Incomplete KLM alignment data.");
    if ((alignmentError == nullptr) && (alignmentCorrection == nullptr)) {
      B2WARNING("Alignment is not determined for KLM module."
                << LogVar("Module", module));
      alignmentError = &zeroAlignment;
      alignmentCorrection = &zeroAlignment;
    } else if ((alignmentError == nullptr) ||
               (alignmentCorrection == nullptr)) {
      B2FATAL("Inconsistent undtermined parameters.");
    }
    section = klmModule.getSection();
    sector = klmModule.getSector();
    layer = klmModule.getLayer();
    param = KLMAlignmentData::c_DeltaU;
    value = alignment->getDeltaU();
    error = alignmentError->getDeltaU();
    correction = alignmentCorrection->getDeltaU();
    if (klmModule.getSubdetector() == KLMElementNumbers::c_BKLM)
      bklmModuleTree->Fill();
    else
      eklmModuleTree->Fill();
    /* cppcheck-suppress redundantAssignment */
    param = KLMAlignmentData::c_DeltaV;
    /* cppcheck-suppress redundantAssignment */
    value = alignment->getDeltaV();
    /* cppcheck-suppress redundantAssignment */
    error = alignmentError->getDeltaV();
    /* cppcheck-suppress redundantAssignment */
    correction = alignmentCorrection->getDeltaV();
    if (klmModule.getSubdetector() == KLMElementNumbers::c_BKLM)
      bklmModuleTree->Fill();
    else
      eklmModuleTree->Fill();
    /* cppcheck-suppress redundantAssignment */
    param = KLMAlignmentData::c_DeltaW;
    /* cppcheck-suppress redundantAssignment */
    value = alignment->getDeltaW();
    /* cppcheck-suppress redundantAssignment */
    error = alignmentError->getDeltaW();
    /* cppcheck-suppress redundantAssignment */
    correction = alignmentCorrection->getDeltaW();
    if (klmModule.getSubdetector() == KLMElementNumbers::c_BKLM)
      bklmModuleTree->Fill();
    else
      eklmModuleTree->Fill();
    /* cppcheck-suppress redundantAssignment */
    param = KLMAlignmentData::c_DeltaAlpha;
    /* cppcheck-suppress redundantAssignment */
    value = alignment->getDeltaAlpha();
    /* cppcheck-suppress redundantAssignment */
    error = alignmentError->getDeltaAlpha();
    /* cppcheck-suppress redundantAssignment */
    correction = alignmentCorrection->getDeltaAlpha();
    if (klmModule.getSubdetector() == KLMElementNumbers::c_BKLM)
      bklmModuleTree->Fill();
    else
      eklmModuleTree->Fill();
    /* cppcheck-suppress redundantAssignment */
    param = KLMAlignmentData::c_DeltaBeta;
    /* cppcheck-suppress redundantAssignment */
    value = alignment->getDeltaBeta();
    /* cppcheck-suppress redundantAssignment */
    error = alignmentError->getDeltaBeta();
    /* cppcheck-suppress redundantAssignment */
    correction = alignmentCorrection->getDeltaBeta();
    if (klmModule.getSubdetector() == KLMElementNumbers::c_BKLM)
      bklmModuleTree->Fill();
    else
      eklmModuleTree->Fill();
    /* cppcheck-suppress redundantAssignment */
    param = KLMAlignmentData::c_DeltaGamma;
    /* cppcheck-suppress redundantAssignment */
    value = alignment->getDeltaGamma();
    /* cppcheck-suppress redundantAssignment */
    error = alignmentError->getDeltaGamma();
    /* cppcheck-suppress redundantAssignment */
    correction = alignmentCorrection->getDeltaGamma();
    if (klmModule.getSubdetector() == KLMElementNumbers::c_BKLM)
      bklmModuleTree->Fill();
    else
      eklmModuleTree->Fill();
  }
  KLMChannelIndex eklmSegments(KLMChannelIndex::c_IndexLevelStrip);
  KLMChannelIndex eklmSegment(KLMChannelIndex::c_IndexLevelStrip);
  eklmSegment = eklmSegments.beginEKLM();
  eklmSegment.useEKLMSegments();
  for (; eklmSegment != eklmSegments.endEKLM(); ++eklmSegment) {
    int eklmSegmentNumber = eklmSegment.getEKLMSegmentNumber();
    alignment = eklmSegmentAlignment->getSegmentAlignment(eklmSegmentNumber);
    alignmentError =
      eklmSegmentAlignmentErrors->getSegmentAlignment(eklmSegmentNumber);
    alignmentCorrection =
      eklmSegmentAlignmentCorrections->getSegmentAlignment(eklmSegmentNumber);
    if (alignment == nullptr)
      B2FATAL("Incomplete KLM alignment data.");
    if ((alignmentError == nullptr) && (alignmentCorrection == nullptr)) {
      /*
       * The segment alignment is not determined now.
       * TODO: If it will be turned on in the future, add a warning here.
       */
      alignmentError = &zeroAlignment;
      alignmentCorrection = &zeroAlignment;
    } else if ((alignmentError == nullptr) ||
               (alignmentCorrection == nullptr)) {
      B2FATAL("Inconsistent undtermined parameters.");
    }
    section = eklmSegment.getSection();
    sector = eklmSegment.getSector();
    layer = eklmSegment.getLayer();
    plane = eklmSegment.getPlane();
    segment = eklmSegment.getStrip();
    param = KLMAlignmentData::c_DeltaU;
    value = alignment->getDeltaU();
    error = alignmentError->getDeltaU();
    correction = alignmentCorrection->getDeltaU();
    eklmSegmentTree->Fill();
    /* cppcheck-suppress redundantAssignment */
    param = KLMAlignmentData::c_DeltaV;
    /* cppcheck-suppress redundantAssignment */
    value = alignment->getDeltaV();
    /* cppcheck-suppress redundantAssignment */
    error = alignmentError->getDeltaV();
    /* cppcheck-suppress redundantAssignment */
    correction = alignmentCorrection->getDeltaV();
    eklmSegmentTree->Fill();
    /* cppcheck-suppress redundantAssignment */
    param = KLMAlignmentData::c_DeltaW;
    /* cppcheck-suppress redundantAssignment */
    value = alignment->getDeltaW();
    /* cppcheck-suppress redundantAssignment */
    error = alignmentError->getDeltaW();
    /* cppcheck-suppress redundantAssignment */
    correction = alignmentCorrection->getDeltaW();
    eklmSegmentTree->Fill();
    /* cppcheck-suppress redundantAssignment */
    param = KLMAlignmentData::c_DeltaAlpha;
    /* cppcheck-suppress redundantAssignment */
    value = alignment->getDeltaAlpha();
    /* cppcheck-suppress redundantAssignment */
    error = alignmentError->getDeltaAlpha();
    /* cppcheck-suppress redundantAssignment */
    correction = alignmentCorrection->getDeltaAlpha();
    eklmSegmentTree->Fill();
    /* cppcheck-suppress redundantAssignment */
    param = KLMAlignmentData::c_DeltaBeta;
    /* cppcheck-suppress redundantAssignment */
    value = alignment->getDeltaBeta();
    /* cppcheck-suppress redundantAssignment */
    error = alignmentError->getDeltaBeta();
    /* cppcheck-suppress redundantAssignment */
    correction = alignmentCorrection->getDeltaBeta();
    eklmSegmentTree->Fill();
    /* cppcheck-suppress redundantAssignment */
    param = KLMAlignmentData::c_DeltaGamma;
    /* cppcheck-suppress redundantAssignment */
    value = alignment->getDeltaGamma();
    /* cppcheck-suppress redundantAssignment */
    error = alignmentError->getDeltaGamma();
    /* cppcheck-suppress redundantAssignment */
    correction = alignmentCorrection->getDeltaGamma();
    eklmSegmentTree->Fill();
  }
  bklmModuleTree->Write();
  eklmModuleTree->Write();
  eklmSegmentTree->Write();
  delete bklmModuleTree;
  delete eklmModuleTree;
  delete eklmSegmentTree;
  delete alignmentResults;
  /* Reset the database. Needed to avoid mess if we call this method multiple times with different GTs. */
  resetDatabase();
}

checkStripEfficiency()

void checkStripEfficiency

(

)

Check strip efficiency.

Definition at line 353 of file KLMCalibrationChecker.cc.

{
  /* Initialize the database. */
  initializeDatabase();
  /* Now we can read the payload. */
  DBObjPtr<KLMStripEfficiency> stripEfficiency;
  if (!stripEfficiency.isValid())
    B2FATAL("Strip efficiency data are not valid.");
  if (m_GlobalTagName != "")
    printPayloadInformation(stripEfficiency);
  /* Create trees with strip efficiency measurement results. */
  int subdetector, section, sector, layer, plane;
  float efficiency, error;
  TFile* stripEfficiencyResults =
    new TFile(m_StripEfficiencyResultsFile.c_str(), "recreate");
  TTree* efficiencyTree = new TTree("efficiency", "KLM strip efficiency data.");
  efficiencyTree->Branch("experiment", &m_experiment, "experiment/I");
  efficiencyTree->Branch("run", &m_run, "run/I");
  efficiencyTree->Branch("subdetector", &subdetector, "subdetector/I");
  efficiencyTree->Branch("section", &section, "section/I");
  efficiencyTree->Branch("sector", &sector, "sector/I");
  efficiencyTree->Branch("layer", &layer, "layer/I");
  efficiencyTree->Branch("plane", &plane, "plane/I");
  efficiencyTree->Branch("efficiency", &efficiency, "efficiency/F");
  efficiencyTree->Branch("error", &error, "error/F");
  KLMChannelIndex klmPlanes(KLMChannelIndex::c_IndexLevelPlane);
  for (KLMChannelIndex& klmPlane : klmPlanes) {
    subdetector = klmPlane.getSubdetector();
    section = klmPlane.getSection();
    sector = klmPlane.getSector();
    layer = klmPlane.getLayer();
    plane = klmPlane.getPlane();
    KLMChannelNumber channel = m_ElementNumbers->channelNumber(
                                 subdetector, section, sector, layer, plane, 1);
    efficiency = stripEfficiency->getEfficiency(channel);
    error = stripEfficiency->getEfficiencyError(channel);
    efficiencyTree->Fill();
  }
  efficiencyTree->Write();
  delete efficiencyTree;
  delete stripEfficiencyResults;
  /* Reset the database. Needed to avoid mess if we call this method multiple times with different GTs. */
  resetDatabase();
}

checkTimeCableDelay()

void checkTimeCableDelay

(

)

Check time cable delay.

Definition at line 473 of file KLMCalibrationChecker.cc.

{
  /* Initialize the database. */
  initializeDatabase();
  /* Now we can read the payload. */
  DBObjPtr<KLMTimeCableDelay> timeCableDelay;
  if (!timeCableDelay.isValid())
    B2FATAL("Time Cable delay data are not valid.");
  if (m_GlobalTagName != "")
    printPayloadInformation(timeCableDelay);
  /* Create trees with time cable delay measurement results. */
  int subdetector, section, sector, layer, plane, strip, channelNumber;
  double timeDelay;
  TFile* timeCableDelayResults =
    new TFile(m_TimeCableDelayResultsFile.c_str(), "recreate");
  TTree* cableDelayTree = new TTree("cabledelay", "KLM timecabledelay data");
  cableDelayTree->Branch("experiment", &m_experiment, "experiment/I");
  cableDelayTree->Branch("run", &m_run, "run/I");
  cableDelayTree->Branch("subdetector", &subdetector, "subdetector/I");
  cableDelayTree->Branch("section", &section, "section/I");
  cableDelayTree->Branch("sector", &sector, "sector/I");
  cableDelayTree->Branch("layer", &layer, "layer/I");
  cableDelayTree->Branch("plane", &plane, "plane/I");
  cableDelayTree->Branch("strip", &strip, "strip/I");
  cableDelayTree->Branch("channelNumber", &channelNumber, "channelNumber/I");
  cableDelayTree->Branch("timeDelay", &timeDelay, "timeDelay/D");
  KLMChannelIndex klmStrips(KLMChannelIndex::c_IndexLevelStrip);
  for (KLMChannelIndex& klmStrip : klmStrips) {
    subdetector = klmStrip.getSubdetector();
    section = klmStrip.getSection();
    sector = klmStrip.getSector();
    layer = klmStrip.getLayer();
    plane = klmStrip.getPlane();
    strip = klmStrip.getStrip();
    KLMChannelNumber channel = m_ElementNumbers->channelNumber(
                                 subdetector, section, sector, layer, plane, strip);
    timeDelay = timeCableDelay->getTimeDelay(channel);
    channelNumber = m_ElementNumbers->channelNumber(subdetector, section, sector, layer, plane, strip);
    cableDelayTree->Fill();
  }
  cableDelayTree->Write();
  delete cableDelayTree;
  delete timeCableDelayResults;
  /* Reset the database. Needed to avoid mess if we call this method multiple times with different GTs. */
  resetDatabase();
}

checkTimeConstants()

void checkTimeConstants

(

)

Check time constants.

Definition at line 520 of file KLMCalibrationChecker.cc.

{
  /* Initialize the database. */
  initializeDatabase();
  /* Now we can read the payload. */
  DBObjPtr<KLMTimeConstants> timeConstants;
  if (!timeConstants.isValid())
    B2FATAL("Time Constants data are not valid.");
  if (m_GlobalTagName != "")
    printPayloadInformation(timeConstants);
  /* Create trees with time constant measurement results. */
  int subdetector, section, sector, layer, plane, strip, module, channelNumber;
  float delayEKLM, delayBKLM, delayRPCPhi, delayRPCZ;
  TFile* timeConstantsResults =
    new TFile(m_TimeConstantsResultsFile.c_str(), "recreate");
  TTree* constantsTree = new TTree("constants", "KLM timeConstants data");
  constantsTree->Branch("experiment", &m_experiment, "experiment/I");
  constantsTree->Branch("run", &m_run, "run/I");
  constantsTree->Branch("subdetector", &subdetector, "subdetector/I");
  constantsTree->Branch("section", &section, "section/I");
  constantsTree->Branch("sector", &sector, "sector/I");
  constantsTree->Branch("layer", &layer, "layer/I");
  constantsTree->Branch("plane", &plane, "plane/I");
  constantsTree->Branch("strip", &strip, "strip/I");
  constantsTree->Branch("module", &module, "module/I");
  constantsTree->Branch("channelNumber", &channelNumber, "channelNumber/I");
  constantsTree->Branch("delayEKLM", &delayEKLM, "delayEKLM/F");
  constantsTree->Branch("delayBKLM", &delayBKLM, "delayBKLM/F");
  constantsTree->Branch("delayRPCPhi", &delayRPCPhi, "delayRPCPhi/F");
  constantsTree->Branch("delayRPCZ", &delayRPCZ, "delayRPCZ/F");
  KLMChannelIndex klmStrips(KLMChannelIndex::c_IndexLevelStrip);
  for (KLMChannelIndex& klmStrip : klmStrips) {
    subdetector = klmStrip.getSubdetector();
    section = klmStrip.getSection();
    sector = klmStrip.getSector();
    layer = klmStrip.getLayer();
    plane = klmStrip.getPlane();
    strip = klmStrip.getStrip();
    channelNumber = m_ElementNumbers->channelNumber(subdetector, section, sector, layer, plane, strip);
    module = m_ElementNumbers->moduleNumber(subdetector, section, sector, layer);
    delayEKLM = timeConstants->getDelay(KLMTimeConstants::c_EKLM);
    delayBKLM = timeConstants->getDelay(KLMTimeConstants::c_BKLM);
    delayRPCPhi = timeConstants->getDelay(KLMTimeConstants::c_RPCPhi);
    delayRPCZ = timeConstants->getDelay(KLMTimeConstants::c_RPCZ);
    constantsTree->Fill();
  }
  constantsTree->Write();
  delete constantsTree;
  delete timeConstantsResults;
  /* Reset the database. Needed to avoid mess if we call this method multiple times with different GTs. */
  resetDatabase();
}

createStripEfficiencyHistograms()

void createStripEfficiencyHistograms

(

)

Create strip efficiency histograms.

Definition at line 398 of file KLMCalibrationChecker.cc.

{
  /* Initialize the database. */
  initializeDatabase();
  /* Now we can read the payload. */
  DBObjPtr<KLMStripEfficiency> stripEfficiency;
  if (not stripEfficiency.isValid())
    B2FATAL("Strip efficiency data are not valid.");
  if (m_GlobalTagName != "")
    printPayloadInformation(stripEfficiency);
  /* Finally, loop over KLM sectors to check the efficiency. */
  KLMChannelIndex klmSectors(KLMChannelIndex::c_IndexLevelSector);
  TCanvas* canvas = new TCanvas();
  for (KLMChannelIndex& klmSector : klmSectors) {
    int subdetector = klmSector.getSubdetector();
    int section = klmSector.getSection();
    int sector = klmSector.getSector();
    /* Setup the histogram. */
    TH1F* hist = new TH1F("plane_histogram", "", 30, 0.5, 30.5);
    hist->GetYaxis()->SetTitle("Efficiency");
    hist->SetMinimum(0.4);
    hist->SetMaximum(1.);
    hist->SetMarkerStyle(20);
    hist->SetMarkerSize(0.5);
    TString title;
    if (subdetector == KLMElementNumbers::c_BKLM) {
      if (section == BKLMElementNumbers::c_BackwardSection)
        title.Form("BKLM backward sector %d", sector);
      else
        title.Form("BKLM forward sector %d", sector);
      hist->SetTitle(title.Data());
      hist->GetXaxis()->SetTitle("(Layer - 1) * 2 + plane + 1");
      for (int layer = 1; layer <= BKLMElementNumbers::getMaximalLayerNumber(); layer++) {
        for (int plane = 0; plane <= BKLMElementNumbers::getMaximalPlaneNumber(); plane++) {
          int bin = (layer - 1) * 2 + plane + 1;
          float efficiency = stripEfficiency->getBarrelEfficiency(section, sector, layer, plane, 2);
          float efficiencyError = stripEfficiency->getBarrelEfficiencyError(section, sector, layer, plane, 2);
          hist->SetBinContent(bin, efficiency);
          hist->SetBinError(bin, efficiencyError);
        }
      }
    } else {
      if (section == EKLMElementNumbers::c_BackwardSection) {
        hist->SetBins(24, 0.5, 24.5);
        title.Form("EKLM backward sector %d", sector);
      } else {
        hist->SetBins(28, 0.5, 28.5);
        title.Form("EKLM forward sector %d", sector);
      }
      hist->SetTitle(title.Data());
      hist->GetXaxis()->SetTitle("(Layer - 1) * 2 + plane");
      const EKLMElementNumbers* elementNumbersEKLM = &(EKLMElementNumbers::Instance());
      for (int layer = 1; layer <= elementNumbersEKLM->getMaximalDetectorLayerNumber(section); layer++) {
        for (int plane = 1; plane <= EKLMElementNumbers::getMaximalPlaneNumber(); plane++) {
          int bin = (layer - 1) * 2 + plane;
          float efficiency = stripEfficiency->getEndcapEfficiency(section, sector, layer, plane, 2);
          float efficiencyError = stripEfficiency->getEndcapEfficiencyError(section, sector, layer, plane, 2);
          hist->SetBinContent(bin, efficiency);
          hist->SetBinError(bin, efficiencyError);
        }
      }
    }
    hist->Draw("e");
    TString name;
    name.Form("efficiency_subdetector_%d_section_%d_sector_%d.pdf", subdetector, section, sector);
    canvas->Print(name.Data());
    canvas->Update();
    delete hist;
  }
  delete canvas;
  /* Reset the database. Needed to avoid mess if we call this method multiple times with different GTs. */
  resetDatabase();
}

initializeDatabase()

void initializeDatabase ( )

private

Initialize the database.

Definition at line 59 of file KLMCalibrationChecker.cc.

{
  /* Mimic a module initialization. */
  DataStore::Instance().setInitializeActive(true);
  m_EventMetaData.registerInDataStore();
  DataStore::Instance().setInitializeActive(false);
  if (!m_EventMetaData.isValid())
    m_EventMetaData.construct(1, m_run, m_experiment);
  /* Database instance and configuration. */
  DBStore& dbStore = DBStore::Instance();
  dbStore.update();
  dbStore.updateEvent();
  auto& dbConfiguration = Conditions::Configuration::getInstance();
  if ((m_testingPayloadName != "") and (m_GlobalTagName == ""))
    dbConfiguration.prependTestingPayloadLocation(m_testingPayloadName);
  else if ((m_testingPayloadName == "") and (m_GlobalTagName != ""))
    dbConfiguration.prependGlobalTag(m_GlobalTagName);
  else
    B2FATAL("Setting both testing payload and Global Tag or setting no one of them.");
}

printPayloadInformation()

void printPayloadInformation ( DBObjPtr< T > &  dbObject )

inlineprivate

Print payload information.

Definition at line 144 of file KLMCalibrationChecker.h.

    {
      B2INFO("Analyzing the following payload:"
             << LogVar("Global Tag", m_GlobalTagName.c_str())
             << LogVar("Name", dbObject.getName())
             << LogVar("Revision", dbObject.getRevision())
             << LogVar("IoV", dbObject.getIoV()));
    }

resetDatabase()

void resetDatabase ( )

private

Reset the database.

Definition at line 80 of file KLMCalibrationChecker.cc.

{
  /* Reset both DataStore and Database. */
  DataStore::Instance().reset();
  Database::Instance().reset(false);
  DBStore::Instance().reset(false);
}

setAlignmentResultsFile()

void setAlignmentResultsFile ( const std::string &  alignmentResultsFile )

inline

Set alignment results file.

Definition at line 70 of file KLMCalibrationChecker.h.

    {
      m_AlignmentResultsFile = alignmentResultsFile;
    }

setExperimentRun()

void setExperimentRun	(	int	experiment,
		int	run
	)

Set experiment and run numbers.

Definition at line 49 of file KLMCalibrationChecker.cc.

{
  m_experiment = experiment;
  m_run = run;
  if (m_EventMetaData.isValid()) {
    m_EventMetaData->setExperiment(experiment);
    m_EventMetaData->setRun(run);
  }
}

setGlobalTag()

void setGlobalTag ( const std::string &  globalTagName )

inline

Set Global Tag name.

Definition at line 62 of file KLMCalibrationChecker.h.

    {
      m_GlobalTagName = globalTagName;
    }

setStripEfficiencyResultsFile()

void setStripEfficiencyResultsFile ( const std::string &  stripEfficiencyResultsFile )

inline

Set strip efficiency results file.

Definition at line 78 of file KLMCalibrationChecker.h.

    {
      m_StripEfficiencyResultsFile = stripEfficiencyResultsFile;
    }

setTestingPayload()

void setTestingPayload ( const std::string &  testingPayloadName )

inline

Set testing payload name.

Definition at line 54 of file KLMCalibrationChecker.h.

    {
      m_testingPayloadName = testingPayloadName;
    }

setTimeCableDelayResultsFile()

void setTimeCableDelayResultsFile ( const std::string &  timeCableDelayResultsFile )

inline

Set time cable delay results file.

Definition at line 87 of file KLMCalibrationChecker.h.

    {
      m_TimeCableDelayResultsFile = timeCableDelayResultsFile;
    }

setTimeConstantsResultsFile()

void setTimeConstantsResultsFile ( const std::string &  timeConstantsResultsFile )

inline

Set time constants result file.

Definition at line 96 of file KLMCalibrationChecker.h.

    {
      m_TimeConstantsResultsFile = timeConstantsResultsFile;
    }

Member Data Documentation

m_AlignmentResultsFile

std::string m_AlignmentResultsFile = "alignment.root"

private

Output file for alignment results.

Definition at line 166 of file KLMCalibrationChecker.h.

m_ElementNumbers

const KLMElementNumbers* m_ElementNumbers

private

Element numbers.

Definition at line 178 of file KLMCalibrationChecker.h.

m_EventMetaData

StoreObjPtr<EventMetaData> m_EventMetaData

private

Event metadata.

Definition at line 181 of file KLMCalibrationChecker.h.

m_experiment

int m_experiment

private

Experiment number.

Definition at line 154 of file KLMCalibrationChecker.h.

m_GlobalTagName

std::string m_GlobalTagName = ""

private

Global Tag name.

Definition at line 163 of file KLMCalibrationChecker.h.

m_run

int m_run

private

Run number.

Definition at line 157 of file KLMCalibrationChecker.h.

m_StripEfficiencyResultsFile

std::string m_StripEfficiencyResultsFile = "strip_efficiency.root"

private

Output file for alignment results.

Definition at line 169 of file KLMCalibrationChecker.h.

m_testingPayloadName

std::string m_testingPayloadName = ""

private

Testing payload location.

Definition at line 160 of file KLMCalibrationChecker.h.

m_TimeCableDelayResultsFile

std::string m_TimeCableDelayResultsFile = "timeCableDelay.root"

private

Output file for time cable delay results.

Definition at line 172 of file KLMCalibrationChecker.h.

m_TimeConstantsResultsFile

std::string m_TimeConstantsResultsFile = "timeConstants.root"

private

Output file for time constants results.

Definition at line 175 of file KLMCalibrationChecker.h.

---

The documentation for this class was generated from the following files:

• klm/calibration/include/KLMCalibrationChecker.h
• klm/calibration/src/KLMCalibrationChecker.cc