ECLDatabaseImporter Class Reference

ECL database importer. More...

#include <ECLDatabaseImporter.h>

Public Member Functions
	ECLDatabaseImporter (std::vector< std::string > inputFileNames, const std::string &m_name)
	Constructor.
virtual	~ECLDatabaseImporter ()
	Destructor.
void	importDigitEnergyCalibration ()
	Import ECL energy calibration constants to the database.
void	importDigitTimeCalibration ()
	Import ECL time calibration constants to the database.
void	importShowerShapesSecondMomentCorrections ()
	Import ECL shower shape corrections to second moment to the database.
void	importShowerCorrectorLeakageCorrections ()
	Import ECL leakage corrections to showers.
void	importShowerEnergyCorrectionTemporary ()
	Import ECL corrections to showers energies.
void	importTrackClusterMatchingThresholds ()
	Import threshold values for track ECL cluster matching to the database.
void	importTrackClusterMatchingParameterizations ()
	Import parameterizations for the RMS between tracks and ECL clusters to the database.

Private Member Functions
template<class rootClass >
rootClass	getRootObjectFromFile (TFile *file, const std::string &rootObjName) const
	Extract a root object rootObjName from a root file file.

Private Attributes
std::vector< std::string >	m_inputFileNames
	Input file name.
std::string	m_name
	Database object (output) file name.
std::string	m_bgFractionBinNumBranchName = "bgFractionBinNum"
	Branch names for shower corrector leakage correction root file.
std::string	m_regNumBranchName = "regNum"
	regNum branch name
std::string	m_phiBinNumBranchName = "phiBinNum"
	phiBinNum branch name
std::string	m_thetaBinNumBranchName = "thetaBinNum"
	thetaBinNum branch name
std::string	m_energyBinNumBranchName = "energyBinNum"
	energyBinNum branch name
std::string	m_correctionFactorBranchName = "correctionFactor"
	correctionFactor branch name
const int	m_numAvgRecEnEntries = 15
	Number of entries in avgRecEn array.
std::string	m_avgRecEnBranchName = "avgRecEn"
	avgRecEn branch name
std::string	m_lReg1ThetaBranchName = "lReg1Theta"
	lReg1Theta branch name
std::string	m_hReg1ThetaBranchName = "hReg1Theta"
	hReg1Theta branch name
std::string	m_lReg2ThetaBranchName = "lReg2Theta"
	lReg2Theta branch name
std::string	m_hReg2ThetaBranchName = "hReg2Theta"
	hReg2Theta branch name
std::string	m_lReg3ThetaBranchName = "lReg3Theta"
	lReg3Theta branch name
std::string	m_hReg3ThetaBranchName = "hReg3Theta"
	hReg3Theta branch name
std::string	m_numOfBfBinsBranchName = "numOfBfBins"
	numOfBfBins branch name
std::string	m_numOfEnergyBinsBranchName = "numOfEnergyBins"
	numOfEnergyBins branch name
std::string	m_numOfPhiBinsBranchName = "numOfPhiBins"
	numOfPhiBins branch name
std::string	m_numOfReg1ThetaBinsBranchName = "numOfReg1ThetaBins"
	numOfReg1ThetaBins branch name
std::string	m_numOfReg2ThetaBinsBranchName = "numOfReg2ThetaBins"
	numOfReg2ThetaBins branch name
std::string	m_numOfReg3ThetaBinsBranchName = "numOfReg3ThetaBins"
	numOfReg3ThetaBins branch name
std::string	m_phiPeriodicityBranchName = "phiPeriodicity"
	phiPeriodicity branch name

Detailed Description

ECL database importer.

This module writes data from e.g. a ROOT histogram to database.

Definition at line 26 of file ECLDatabaseImporter.h.

Constructor & Destructor Documentation

ECLDatabaseImporter()

ECLDatabaseImporter	(	std::vector< std::string >	inputFileNames,
		const std::string &	m_name
	)

Constructor.

Definition at line 44 of file ECLDatabaseImporter.cc.

{
  //input file names
  for (auto& inputFileName : inputFileNames)
    m_inputFileNames.push_back(inputFileName);
 
  //output file name
  m_name = name;
}

~ECLDatabaseImporter()

virtual ~ECLDatabaseImporter ( )

inlinevirtual

Destructor.

Definition at line 38 of file ECLDatabaseImporter.h.

{};

Member Function Documentation

getRootObjectFromFile()

rootClass getRootObjectFromFile ( TFile *  file, const std::string &  rootObjName  ) const

inlineprivate

Extract a root object rootObjName from a root file file.

The file is assumed to be valid (pointer valid and not zombie). If rootObjName doesn't exist in file, do B2FATAL.

Definition at line 88 of file ECLDatabaseImporter.h.

    {
      rootClass rootObj = (rootClass)file->Get(rootObjName.data());
      if (!rootObj) {
        std::string filename = file->GetName();
        delete file;
        B2FATAL("Could not find " << rootObjName << " in " << filename);
      }
      return rootObj;
    }

importDigitEnergyCalibration()

void importDigitEnergyCalibration

(

)

Import ECL energy calibration constants to the database.

Definition at line 54 of file ECLDatabaseImporter.cc.

{
 
  TClonesArray digitCalibrationConstants("Belle2::ECLDigitEnergyConstants");
 
  TH1F* energy = 0;
  TH1F* amplitude = 0;
  int nFiles = 0;
 
  for (const string& inputFile : m_inputFileNames) {
 
    TFile* f = TFile::Open(inputFile.c_str(), "READ");
 
    TIter next(f->GetListOfKeys());
    TKey* key;
    while ((key = (TKey*) next())) {
 
      string histconstants = key->GetName();
 
      if (histconstants.compare("energy") == 0) {
        energy = (TH1F*)f->Get(histconstants.c_str());
      } else  if (histconstants.compare("amplitude") == 0) {
        amplitude = (TH1F*)f->Get(histconstants.c_str());
      }
 
      else { B2FATAL("Key name does not match any of the following: energy, amplitude!"); }
    }
 
    nFiles++;
  }
 
  if (nFiles != 1) { B2FATAL("Sorry, you must only import one file at a time for now!"); }
 
  if (!amplitude) B2FATAL("None of the input files contains the histogram called 'amplitude'!");
  if (!energy) B2FATAL("None of the input files contains the histogram called 'energy'!");
 
  // loop over the histogram to fill the TClonesArray
  int cell = 0;
  for (int bin = 1; bin <= amplitude->GetNbinsX(); ++bin) {
    float amplitudeval = amplitude->GetBinContent(bin);
    float energyval = energy->GetBinContent(bin);
    new (digitCalibrationConstants[cell]) ECLDigitEnergyConstants(bin, amplitudeval, energyval);
    cell++;
  }
 
  IntervalOfValidity iov(0, 0, -1, -1); // IOV (0,0,-1,-1) is valid for all runs and experiments
  Database::Instance().storeData(m_name, &digitCalibrationConstants, iov);
}

importDigitTimeCalibration()

void importDigitTimeCalibration

(

)

Import ECL time calibration constants to the database.

Definition at line 103 of file ECLDatabaseImporter.cc.

{
 
  TClonesArray digitCalibrationConstants("Belle2::ECLDigitTimeConstants");
 
  TH1F* offset = 0;
  int nFiles = 0;
 
  for (const string& inputFile : m_inputFileNames) {
 
    TFile* f = TFile::Open(inputFile.c_str(), "READ");
 
    TIter next(f->GetListOfKeys());
    TKey* key;
    while ((key = (TKey*) next())) {
 
      string histconstants = key->GetName();
 
      if (histconstants.compare("constantB") == 0) {
        offset = (TH1F*)f->Get(histconstants.c_str());
      } else { B2FATAL("Key name does not match any of the following: constantC!"); }
    }
 
    nFiles++;
  }
 
  if (nFiles != 1) { B2FATAL("Sorry, you must only import one file at a time for now!"); }
 
  if (!offset) B2FATAL("None of the input files contains the histogram called 'constantB'!");
 
  // loop over the histogram to fill the TClonesArray
  int cell = 0;
  for (int bin = 1; bin <= offset->GetNbinsX(); ++bin) {
    float offsetval = offset->GetBinContent(bin);
    new (digitCalibrationConstants[cell]) ECLDigitTimeConstants(bin, offsetval);
    cell++;
  }
 
  IntervalOfValidity iov(0, 0, -1, -1); // IOV (0,0,-1,-1) is valid for all runs and experiments
  Database::Instance().storeData(m_name, &digitCalibrationConstants, iov);
}

importShowerCorrectorLeakageCorrections()

void importShowerCorrectorLeakageCorrections

(

)

Import ECL leakage corrections to showers.

Definition at line 145 of file ECLDatabaseImporter.cc.

{
  if (m_inputFileNames.size() > 1)
    B2FATAL("Sorry, you must only import one file at a time for now!");
 
  //Open file
  TFile* inputFile = new TFile(m_inputFileNames[0].data(), "READ");
 
  if (!inputFile || inputFile->IsZombie())
    B2FATAL("Could not open file " << m_inputFileNames[0]);
 
  //Get trees
  TTree* correctionTree = getRootObjectFromFile<TTree*>(inputFile, "ParameterNtuple");
  TTree* helperTree = getRootObjectFromFile<TTree*>(inputFile, "ConstantNtuple");
 
  //----------------------------------------------------------------------------------------------
  //Fill ParameterNtuple vectors
  //----------------------------------------------------------------------------------------------
 
  int bgFractionBinNum;
  int regNum;
  int phiBinNum;
  int thetaBinNum;
  int energyBinNum;
  float correctionFactor;
 
  //Set Branch Addresses
  correctionTree->SetBranchAddress(m_bgFractionBinNumBranchName.c_str(), &bgFractionBinNum);
  correctionTree->SetBranchAddress(m_regNumBranchName.c_str(), &regNum);
  correctionTree->SetBranchAddress(m_phiBinNumBranchName.c_str(), &phiBinNum);
  correctionTree->SetBranchAddress(m_thetaBinNumBranchName.c_str(), &thetaBinNum);
  correctionTree->SetBranchAddress(m_energyBinNumBranchName.c_str(), &energyBinNum);
  correctionTree->SetBranchAddress(m_correctionFactorBranchName.c_str(), &correctionFactor);
 
  //Fill vectors
  std::vector<int> m_bgFractionBinNum;
  std::vector<int> m_regNum;
  std::vector<int> m_phiBinNum;
  std::vector<int> m_thetaBinNum;
  std::vector<int> m_energyBinNum;
  std::vector<float> m_correctionFactor;
 
  for (long iEntry = 0; iEntry < correctionTree->GetEntries(); ++iEntry) {
    correctionTree->GetEntry(iEntry);
 
    m_bgFractionBinNum.push_back(bgFractionBinNum);
    m_regNum.push_back(regNum);
    m_phiBinNum.push_back(phiBinNum);
    m_thetaBinNum.push_back(thetaBinNum);
    m_energyBinNum.push_back(energyBinNum);
    m_correctionFactor.push_back(correctionFactor);
  }
 
  //----------------------------------------------------------------------------------------------
  //Fill ConstantNtuple vectors
  //----------------------------------------------------------------------------------------------
 
 
  float lReg1Theta;
  float hReg1Theta;
  float lReg2Theta;
  float hReg2Theta;
  float lReg3Theta;
  float hReg3Theta;
  int numOfBfBins;
  int numOfEnergyBins;
  int numOfPhiBins;
  int numOfReg1ThetaBins;
  int numOfReg2ThetaBins;
  int numOfReg3ThetaBins;
  int phiPeriodicity;
 
  //Ugly hack to circumvent 'stack usage might be unbounded [-Wstack-usage=]' compiler warning that's caused by the use of c-type arrays.
  //This is not for the faint of heart
 
  //because root GetEntry fills the whole internal array of the vector without changing it's size, we must ensure that it's the right size.
  std::vector<float> avgRecEns(m_numAvgRecEnEntries);
  helperTree->SetBranchAddress(m_avgRecEnBranchName.c_str(), avgRecEns.data()); //Read c-style array right into internal vector array.
 
  helperTree->SetBranchAddress(m_lReg1ThetaBranchName.c_str(), &lReg1Theta);
  helperTree->SetBranchAddress(m_hReg1ThetaBranchName.c_str(), &hReg1Theta);
  helperTree->SetBranchAddress(m_lReg2ThetaBranchName.c_str(), &lReg2Theta);
  helperTree->SetBranchAddress(m_hReg2ThetaBranchName.c_str(), &hReg2Theta);
  helperTree->SetBranchAddress(m_lReg3ThetaBranchName.c_str(), &lReg3Theta);
  helperTree->SetBranchAddress(m_hReg3ThetaBranchName.c_str(), &hReg3Theta);
  helperTree->SetBranchAddress(m_numOfBfBinsBranchName.c_str(), &numOfBfBins);
  helperTree->SetBranchAddress(m_numOfEnergyBinsBranchName.c_str(), &numOfEnergyBins);
  helperTree->SetBranchAddress(m_numOfPhiBinsBranchName.c_str(), &numOfPhiBins);
  helperTree->SetBranchAddress(m_numOfReg1ThetaBinsBranchName.c_str(), &numOfReg1ThetaBins);
  helperTree->SetBranchAddress(m_numOfReg2ThetaBinsBranchName.c_str(), &numOfReg2ThetaBins);
  helperTree->SetBranchAddress(m_numOfReg3ThetaBinsBranchName.c_str(), &numOfReg3ThetaBins);
  helperTree->SetBranchAddress(m_phiPeriodicityBranchName.c_str(), &phiPeriodicity);
 
  //Fill vectors
  std::vector<float> m_avgRecEn;
  std::vector<float> m_lReg1Theta;
  std::vector<float> m_hReg1Theta;
  std::vector<float> m_lReg2Theta;
  std::vector<float> m_hReg2Theta;
  std::vector<float> m_lReg3Theta;
  std::vector<float> m_hReg3Theta;
  std::vector<int>   m_numOfBfBins;
  std::vector<int>   m_numOfEnergyBins;
  std::vector<int>   m_numOfPhiBins;
  std::vector<int>   m_numOfReg1ThetaBins;
  std::vector<int>   m_numOfReg2ThetaBins;
  std::vector<int>   m_numOfReg3ThetaBins;
  std::vector<int>   m_phiPeriodicity;
 
  for (long iEntry = 0; iEntry < helperTree->GetEntries(); ++iEntry) {
    helperTree->GetEntry(iEntry);
    for (unsigned int iIdx = 0; iIdx < avgRecEns.size(); ++iIdx) m_avgRecEn.push_back(avgRecEns[iIdx]);
 
    m_lReg1Theta.push_back(lReg1Theta);
    m_hReg1Theta.push_back(hReg1Theta);
    m_lReg2Theta.push_back(lReg2Theta);
    m_hReg2Theta.push_back(hReg2Theta);
    m_lReg3Theta.push_back(lReg3Theta);
    m_hReg3Theta.push_back(hReg3Theta);
    m_numOfBfBins.push_back(numOfBfBins);
    m_numOfEnergyBins.push_back(numOfEnergyBins);
    m_numOfPhiBins.push_back(numOfPhiBins);
    m_numOfReg1ThetaBins.push_back(numOfReg1ThetaBins);
    m_numOfReg2ThetaBins.push_back(numOfReg2ThetaBins);
    m_numOfReg3ThetaBins.push_back(numOfReg3ThetaBins);
    m_phiPeriodicity.push_back(phiPeriodicity);
  }
 
  //----------------------------------------------------------------------------------------------
 
  //Construct DB object
  DBImportObjPtr<ECLShowerCorrectorLeakageCorrection> dbPtr("ecl_shower_corrector_leakage_corrections");
  dbPtr.construct(m_bgFractionBinNum,
                  m_regNum,
                  m_phiBinNum,
                  m_thetaBinNum,
                  m_energyBinNum,
                  m_correctionFactor,
                  m_avgRecEn,
                  m_lReg1Theta,
                  m_hReg1Theta,
                  m_lReg2Theta,
                  m_hReg2Theta,
                  m_lReg3Theta,
                  m_hReg3Theta,
                  m_numOfBfBins,
                  m_numOfEnergyBins,
                  m_numOfPhiBins,
                  m_numOfReg1ThetaBins,
                  m_numOfReg2ThetaBins,
                  m_numOfReg3ThetaBins,
                  m_phiPeriodicity);
 
  //Create IOV object
  int startExp = 0;
  int startRun = 0;
  int endExp = -1;
  int endRun = -1;
  IntervalOfValidity iov(startExp, startRun, endExp, endRun);
 
  //Import into local db
  dbPtr.import(iov);
 
  delete inputFile;
 
}

importShowerEnergyCorrectionTemporary()

void importShowerEnergyCorrectionTemporary

(

)

Import ECL corrections to showers energies.

Temperary - there will be additional improvements done to these corrections in the future. Input file should be .txt file and have the format: generated-energy bkg-scale-factor theta-min theta-max corr-factor. The numbers should be seperated by spaces. For each line, the theta value used is the average of theta-min and theta-max

Definition at line 354 of file ECLDatabaseImporter.cc.

{
  if (m_inputFileNames.size() > 1)
    B2FATAL("Sorry, you must only import one file at a time for now!");
 
  //Expect a root file
  std::filesystem::path path(m_inputFileNames[0]);
  if (path.extension() != ".root")
    B2FATAL("Expecting a .root file. Aborting");
 
  TFile* inputFile = new TFile(m_inputFileNames[0].data(), "READ");
 
  TGraph2D* theta_geo_graph = getRootObjectFromFile<TGraph2D*>(inputFile, "LeakageCorrections_theta_geometry");
  TGraph2D* phi_geo_graph = getRootObjectFromFile<TGraph2D*>(inputFile, "LeakageCorrections_phi_geometry");
  TGraph2D* theta_en_graph = getRootObjectFromFile<TGraph2D*>(inputFile, "LeakageCorrections_theta_energy");
  TGraph2D* phi_en_graph = getRootObjectFromFile<TGraph2D*>(inputFile, "LeakageCorrections_phi_energy");
  TH1F* bg_histo = getRootObjectFromFile<TH1F*>(inputFile, "LeakageCorrections_background_fraction");
 
  double bkgFactor = bg_histo->GetBinContent(1);
 
  double thetaMin = theta_en_graph->GetXmin();
  double thetaMax = theta_en_graph->GetXmax();
  double phiMin = phi_en_graph->GetXmin();
  double phiMax = phi_en_graph->GetXmax();
 
  double energyMin = theta_en_graph->GetYmin();
  double energyMax = theta_en_graph->GetYmax();
 
 
  B2DEBUG(28, "Leakage DBobjects angle boundaries: thetaMin=" << thetaMin << " thetaMax=" << thetaMax << " phiMin= " << phiMin <<
          " phiMax= " << phiMax << " enmin=" << energyMin <<
          " enmax=" << energyMax);
 
  //    Import to DB
  int startExp = 0;
  int startRun = 0;
  int endExp = -1;
  int endRun = -1;
  IntervalOfValidity iov(startExp, startRun, endExp, endRun);
 
  if (std::abs(bkgFactor - 1.0) < 1e-9) { //bkgFactor == 1 -> phase 2 backgrounds
 
    DBImportObjPtr<ECLShowerEnergyCorrectionTemporary> dbPtr_theta_geo("ECLLeakageCorrection_thetaGeometry_phase2");
    dbPtr_theta_geo.construct(*theta_geo_graph, thetaMin, thetaMax, energyMin, energyMax);
    DBImportObjPtr<ECLShowerEnergyCorrectionTemporary> dbPtr_phi_geo("ECLLeakageCorrection_phiGeometry_phase2");
    dbPtr_phi_geo.construct(*phi_geo_graph, phiMin, phiMax, energyMin, energyMax);
    DBImportObjPtr<ECLShowerEnergyCorrectionTemporary> dbPtr_theta_en("ECLLeakageCorrection_thetaEnergy_phase2");
    dbPtr_theta_en.construct(*theta_en_graph, thetaMin, thetaMax, energyMin, energyMax);
    DBImportObjPtr<ECLShowerEnergyCorrectionTemporary> dbPtr_phi_en("ECLLeakageCorrection_phiEnergy_phase2");
    dbPtr_phi_en.construct(*phi_en_graph, phiMin, phiMax, energyMin, energyMax);
 
    //Import into local db
    dbPtr_theta_geo.import(iov);
    dbPtr_phi_geo.import(iov);
    dbPtr_theta_en.import(iov);
    dbPtr_phi_en.import(iov);
  }
  /*else (because currently phase_2 and phase_3 are same payload*/ if (std::abs(bkgFactor - 1.0) < 1e-9) {
 
    DBImportObjPtr<ECLShowerEnergyCorrectionTemporary> dbPtr_theta_geo("ECLLeakageCorrection_thetaGeometry_phase3");
    dbPtr_theta_geo.construct(*theta_geo_graph, thetaMin, thetaMax, energyMin, energyMax);
    DBImportObjPtr<ECLShowerEnergyCorrectionTemporary> dbPtr_phi_geo("ECLLeakageCorrection_phiGeometry_phase3");
    dbPtr_phi_geo.construct(*phi_geo_graph, phiMin, phiMax, energyMin, energyMax);
    DBImportObjPtr<ECLShowerEnergyCorrectionTemporary> dbPtr_theta_en("ECLLeakageCorrection_thetaEnergy_phase3");
    dbPtr_theta_en.construct(*theta_en_graph, thetaMin, thetaMax, energyMin, energyMax);
    DBImportObjPtr<ECLShowerEnergyCorrectionTemporary> dbPtr_phi_en("ECLLeakageCorrection_phiEnergy_phase3");
    dbPtr_phi_en.construct(*phi_en_graph, phiMin, phiMax, energyMin, energyMax);
 
    //Import into local db
    dbPtr_theta_geo.import(iov);
    dbPtr_phi_geo.import(iov);
    dbPtr_theta_en.import(iov);
    dbPtr_phi_en.import(iov);
  }
 
 
}

importShowerShapesSecondMomentCorrections()

void importShowerShapesSecondMomentCorrections

(

)

Import ECL shower shape corrections to second moment to the database.

Definition at line 312 of file ECLDatabaseImporter.cc.

{
  if (m_inputFileNames.size() > 1)
    B2FATAL("Sorry, you must only import one file at a time for now!");
 
  //Extract TGraphs from file
  DBImportArray<ECLShowerShapeSecondMomentCorrection> dbArray("ecl_shower_shape_second_moment_corrections");
  TFile* inputFile = new TFile(m_inputFileNames[0].data(), "READ");
 
  if (!inputFile || inputFile->IsZombie())
    B2FATAL("Could not open file " << m_inputFileNames[0]);
 
  //N1 theta
  TGraph* theta_N1_graph = getRootObjectFromFile<TGraph*>(inputFile, "SecondMomentCorrections_theta_N1");
  dbArray.appendNew(ECLShower::c_nPhotons, ECLShowerShapeModule::c_thetaType, *theta_N1_graph);
 
  //N1 phi
  TGraph* phi_N1_graph = getRootObjectFromFile<TGraph*>(inputFile, "SecondMomentCorrections_phi_N1");
  dbArray.appendNew(ECLShower::c_nPhotons, ECLShowerShapeModule::c_phiType, *phi_N1_graph);
 
  //N2 theta
  TGraph* theta_N2_graph = getRootObjectFromFile<TGraph*>(inputFile, "SecondMomentCorrections_theta_N2");
  dbArray.appendNew(ECLShower::c_neutralHadron, ECLShowerShapeModule::c_thetaType, *theta_N2_graph);
 
  //N2 phi
  TGraph* phi_N2_graph = getRootObjectFromFile<TGraph*>(inputFile, "SecondMomentCorrections_phi_N2");
  dbArray.appendNew(ECLShower::c_neutralHadron, ECLShowerShapeModule::c_phiType, *phi_N2_graph);
 
 
  //Import to DB
  int startExp = 0;
  int startRun = 0;
  int endExp = -1;
  int endRun = -1;
  IntervalOfValidity iov(startExp, startRun, endExp, endRun);
 
  //Import into local db
  dbArray.import(iov);
 
  delete inputFile;
}

importTrackClusterMatchingParameterizations()

void importTrackClusterMatchingParameterizations

(

)

Import parameterizations for the RMS between tracks and ECL clusters to the database.

Definition at line 477 of file ECLDatabaseImporter.cc.

{
  if (m_inputFileNames.size() > 1)
    B2FATAL("Sorry, you must only import one file at a time for now!");
 
  // Open file
  TFile* inputFile = new TFile(m_inputFileNames[0].data(), "READ");
 
  if (!inputFile || inputFile->IsZombie())
    B2FATAL("Could not open file " << m_inputFileNames[0]);
 
  map<string, TF1> m_parametrizationFunctions;
  vector<string> angles = {"Theta", "Phi"};
  vector<string> regions = {"BRL", "BWD", "FWD"};
  vector<string> hittypes = {"CROSS", "DL", "NEAR"};
 
  for (const auto& angle : angles) {
    for (const auto& region : regions) {
      for (const auto& hittype : hittypes) {
        m_parametrizationFunctions.insert(make_pair(angle + region + hittype, *(getRootObjectFromFile<TF1*>(inputFile,
                                                    "RMSParameterization" + angle + region + hittype))));
      }
    }
  }
 
  DBImportObjPtr<ECLTrackClusterMatchingParameterizations> dbPtr("ECLTrackClusterMatchingParameterizations");
  dbPtr.construct(m_parametrizationFunctions);
 
  IntervalOfValidity iov(0, 0, -1, -1);
 
  //Import into local db
  dbPtr.import(iov);
 
  delete inputFile;
}

importTrackClusterMatchingThresholds()

void importTrackClusterMatchingThresholds

(

)

Import threshold values for track ECL cluster matching to the database.

Definition at line 432 of file ECLDatabaseImporter.cc.

{
  if (m_inputFileNames.size() > 1)
    B2FATAL("Sorry, you must only import one file at a time for now!");
 
  //Expect a txt file
  std::filesystem::path path(m_inputFileNames[0]);
  if (path.extension() != ".txt")
    B2FATAL("Expecting a .txt file. Aborting");
 
  vector<pair<double, double>> m_matchingThresholdPairsFWD;
  vector<pair<double, double>> m_matchingThresholdPairsBWD;
  vector<pair<double, pair<double, double>>> m_matchingThresholdPairsBRL;
  pair<double, double> m_matchingThresholdPair;
  pair<double, pair<double, double>> m_thetaMatchingThresholdPair;
  double pt, threshold, thetalimit;
  string eclregion;
 
  ifstream infile(m_inputFileNames[0]);
  string line;
  while (getline(infile, line)) {
    istringstream iss(line);
    iss >> eclregion;
    if (eclregion == "FWD" || eclregion == "BWD") {
      iss >> pt >> threshold;
      m_matchingThresholdPair = make_pair(pt, threshold);
      if (eclregion == "FWD") m_matchingThresholdPairsFWD.push_back(m_matchingThresholdPair);
      else m_matchingThresholdPairsBWD.push_back(m_matchingThresholdPair);
    } else if (eclregion == "BRL") {
      iss >> thetalimit >> pt >> threshold;
      m_matchingThresholdPair = make_pair(pt, threshold);
      m_thetaMatchingThresholdPair = make_pair(thetalimit, m_matchingThresholdPair);
      m_matchingThresholdPairsBRL.push_back(m_thetaMatchingThresholdPair);
    }
  }
 
  DBImportObjPtr<ECLTrackClusterMatchingThresholds> dbPtr("ECLTrackClusterMatchingThresholds");
  dbPtr.construct(m_matchingThresholdPairsFWD, m_matchingThresholdPairsBWD, m_matchingThresholdPairsBRL);
 
  IntervalOfValidity iov(0, 0, -1, -1);
 
  //Import into local db
  dbPtr.import(iov);
}

Member Data Documentation

m_avgRecEnBranchName

std::string m_avgRecEnBranchName = "avgRecEn"

private

avgRecEn branch name

Definition at line 113 of file ECLDatabaseImporter.h.

m_bgFractionBinNumBranchName

std::string m_bgFractionBinNumBranchName = "bgFractionBinNum"

private

Branch names for shower corrector leakage correction root file.

bgFractionBinNum branch name

Definition at line 104 of file ECLDatabaseImporter.h.

m_correctionFactorBranchName

std::string m_correctionFactorBranchName = "correctionFactor"

private

correctionFactor branch name

Definition at line 109 of file ECLDatabaseImporter.h.

m_energyBinNumBranchName

std::string m_energyBinNumBranchName = "energyBinNum"

private

energyBinNum branch name

Definition at line 108 of file ECLDatabaseImporter.h.

m_hReg1ThetaBranchName

std::string m_hReg1ThetaBranchName = "hReg1Theta"

private

hReg1Theta branch name

Definition at line 115 of file ECLDatabaseImporter.h.

m_hReg2ThetaBranchName

std::string m_hReg2ThetaBranchName = "hReg2Theta"

private

hReg2Theta branch name

Definition at line 117 of file ECLDatabaseImporter.h.

m_hReg3ThetaBranchName

std::string m_hReg3ThetaBranchName = "hReg3Theta"

private

hReg3Theta branch name

Definition at line 119 of file ECLDatabaseImporter.h.

m_inputFileNames

std::vector<std::string> m_inputFileNames

private

Input file name.

Definition at line 82 of file ECLDatabaseImporter.h.

m_lReg1ThetaBranchName

std::string m_lReg1ThetaBranchName = "lReg1Theta"

private

lReg1Theta branch name

Definition at line 114 of file ECLDatabaseImporter.h.

m_lReg2ThetaBranchName

std::string m_lReg2ThetaBranchName = "lReg2Theta"

private

lReg2Theta branch name

Definition at line 116 of file ECLDatabaseImporter.h.

m_lReg3ThetaBranchName

std::string m_lReg3ThetaBranchName = "lReg3Theta"

private

lReg3Theta branch name

Definition at line 118 of file ECLDatabaseImporter.h.

m_name

std::string m_name

private

Database object (output) file name.

Definition at line 83 of file ECLDatabaseImporter.h.

m_numAvgRecEnEntries

const int m_numAvgRecEnEntries = 15

private

Number of entries in avgRecEn array.

If this is wrong bad things will happen

Definition at line 112 of file ECLDatabaseImporter.h.

m_numOfBfBinsBranchName

std::string m_numOfBfBinsBranchName = "numOfBfBins"

private

numOfBfBins branch name

Definition at line 120 of file ECLDatabaseImporter.h.

m_numOfEnergyBinsBranchName

std::string m_numOfEnergyBinsBranchName = "numOfEnergyBins"

private

numOfEnergyBins branch name

Definition at line 121 of file ECLDatabaseImporter.h.

m_numOfPhiBinsBranchName

std::string m_numOfPhiBinsBranchName = "numOfPhiBins"

private

numOfPhiBins branch name

Definition at line 122 of file ECLDatabaseImporter.h.

m_numOfReg1ThetaBinsBranchName

std::string m_numOfReg1ThetaBinsBranchName = "numOfReg1ThetaBins"

private

numOfReg1ThetaBins branch name

Definition at line 123 of file ECLDatabaseImporter.h.

m_numOfReg2ThetaBinsBranchName

std::string m_numOfReg2ThetaBinsBranchName = "numOfReg2ThetaBins"

private

numOfReg2ThetaBins branch name

Definition at line 124 of file ECLDatabaseImporter.h.

m_numOfReg3ThetaBinsBranchName

std::string m_numOfReg3ThetaBinsBranchName = "numOfReg3ThetaBins"

private

numOfReg3ThetaBins branch name

Definition at line 125 of file ECLDatabaseImporter.h.

m_phiBinNumBranchName

std::string m_phiBinNumBranchName = "phiBinNum"

private

phiBinNum branch name

Definition at line 106 of file ECLDatabaseImporter.h.

m_phiPeriodicityBranchName

std::string m_phiPeriodicityBranchName = "phiPeriodicity"

private

phiPeriodicity branch name

Definition at line 126 of file ECLDatabaseImporter.h.

m_regNumBranchName

std::string m_regNumBranchName = "regNum"

private

regNum branch name

Definition at line 105 of file ECLDatabaseImporter.h.

m_thetaBinNumBranchName

std::string m_thetaBinNumBranchName = "thetaBinNum"

private

thetaBinNum branch name

Definition at line 107 of file ECLDatabaseImporter.h.

---

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

• ecl/dbobjects/include/ECLDatabaseImporter.h
• ecl/dbobjects/src/ECLDatabaseImporter.cc