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	setEventT0HitResolutionResultsFile (const std::string &eventT0HitResolutionResultsFile)
	Set EventT0 hit resolution results 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.
void	checkEventT0HitResolution ()
	Check EventT0 hit resolution.

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.
std::string	m_EventT0HitResolutionResultsFile = "eventT0HitResolution.root"
	Output file for EventT0 hit resolution 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 39 of file KLMCalibrationChecker.cc.

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

~KLMCalibrationChecker()

~KLMCalibrationChecker

(

)

Destructor.

Definition at line 46 of file KLMCalibrationChecker.cc.

{
}

Member Function Documentation

checkAlignment()

void checkAlignment

(

)

Check alignment.

Definition at line 89 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();
}

checkEventT0HitResolution()

void checkEventT0HitResolution

(

)

Check EventT0 hit resolution.

Definition at line 574 of file KLMCalibrationChecker.cc.

{
  /* Initialize the database. */
  initializeDatabase();
  /* Now we can read the payload. */
  DBObjPtr<KLMEventT0HitResolution> eventT0HitResolution;
  if (!eventT0HitResolution.isValid())
    B2FATAL("EventT0 Hit Resolution data are not valid.");
  if (m_GlobalTagName != "")
    printPayloadInformation(eventT0HitResolution);
  /* Create tree with EventT0 hit resolution (one row per detector category). */
  int category;
  float sigma, sigmaErr;
  TFile* eventT0HitResolutionResults =
    new TFile(m_EventT0HitResolutionResultsFile.c_str(), "recreate");
  TTree* resolutionTree = new TTree("eventT0HitResolution", "KLM EventT0 hit resolution data");
  resolutionTree->Branch("experiment", &m_experiment, "experiment/I");
  resolutionTree->Branch("run", &m_run, "run/I");
  resolutionTree->Branch("category", &category, "category/I");
  resolutionTree->Branch("sigma", &sigma, "sigma/F");
  resolutionTree->Branch("sigmaErr", &sigmaErr, "sigmaErr/F");
  /* Category order must match KLMEventT0HitResolution::Category enum. */
  const int categories[5] = {
    KLMEventT0HitResolution::c_EKLMScint,
    KLMEventT0HitResolution::c_BKLMScint,
    KLMEventT0HitResolution::c_RPC,
    KLMEventT0HitResolution::c_RPCPhi,
    KLMEventT0HitResolution::c_RPCZ,
  };
  for (int cat : categories) {
    category = cat;
    sigma = eventT0HitResolution->getSigma(cat);
    sigmaErr = eventT0HitResolution->getSigmaErr(cat);
    resolutionTree->Fill();
  }
  resolutionTree->Write();
  delete resolutionTree;
  delete eventT0HitResolutionResults;
  /* 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 354 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 474 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 521 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 399 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 60 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()

template<class T>

void printPayloadInformation ( DBObjPtr< T > & dbObject )

inlineprivate

Print payload information.

Definition at line 158 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 81 of file KLMCalibrationChecker.cc.

{
  /* Reset both DataStore and Database. */
  DataStore::Instance().reset();
  Database::Instance().reset(true); // keep the configuration
  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;
    }

setEventT0HitResolutionResultsFile()

void setEventT0HitResolutionResultsFile ( const std::string & eventT0HitResolutionResultsFile )

inline

Set EventT0 hit resolution results file.

Definition at line 105 of file KLMCalibrationChecker.h.

    {
      m_EventT0HitResolutionResultsFile = eventT0HitResolutionResultsFile;
    }

setExperimentRun()

void setExperimentRun	(	int	experiment,
		int	run )

Set experiment and run numbers.

Definition at line 50 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 180 of file KLMCalibrationChecker.h.

m_ElementNumbers

const KLMElementNumbers* m_ElementNumbers

private

Element numbers.

Definition at line 195 of file KLMCalibrationChecker.h.

m_EventMetaData

StoreObjPtr<EventMetaData> m_EventMetaData

private

Event metadata.

Definition at line 198 of file KLMCalibrationChecker.h.

m_EventT0HitResolutionResultsFile

std::string m_EventT0HitResolutionResultsFile = "eventT0HitResolution.root"

private

Output file for EventT0 hit resolution results.

Definition at line 192 of file KLMCalibrationChecker.h.

m_experiment

int m_experiment

private

Experiment number.

Definition at line 168 of file KLMCalibrationChecker.h.

m_GlobalTagName

std::string m_GlobalTagName = ""

private

Global Tag name.

Definition at line 177 of file KLMCalibrationChecker.h.

m_run

int m_run

private

Run number.

Definition at line 171 of file KLMCalibrationChecker.h.

m_StripEfficiencyResultsFile

std::string m_StripEfficiencyResultsFile = "strip_efficiency.root"

private

Output file for alignment results.

Definition at line 183 of file KLMCalibrationChecker.h.

m_testingPayloadName

std::string m_testingPayloadName = ""

private

Testing payload location.

Definition at line 174 of file KLMCalibrationChecker.h.

m_TimeCableDelayResultsFile

std::string m_TimeCableDelayResultsFile = "timeCableDelay.root"

private

Output file for time cable delay results.

Definition at line 186 of file KLMCalibrationChecker.h.

m_TimeConstantsResultsFile

std::string m_TimeConstantsResultsFile = "timeConstants.root"

private

Output file for time constants results.

Definition at line 189 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