#include <EcalPFRecHitThresholdsHandler.h>

Inheritance diagram for popcon::EcalPFRecHitThresholdsHandler:

Public Member Functions
	EcalPFRecHitThresholdsHandler (edm::ParameterSet const &)

void	getNewObjects () override

std::string	id () const override

void	readTXT (const std::string &filename, EcalFloatCondObjectContainer &record)

void	readXML (const std::string &filename, EcalFloatCondObjectContainer &record)

	~EcalPFRecHitThresholdsHandler () override

Public Member Functions inherited from popcon::PopConSourceHandler< EcalPFRecHitThresholds >
void	initialize (const cond::persistency::Session &dbSession, cond::TagInfo_t const &tagInfo, cond::LogDBEntry_t const &logDBEntry)

Ref	lastPayload () const

cond::LogDBEntry_t const &	logDBEntry () const

std::pair< Container const *, std::string const >	operator() (const cond::persistency::Session &session, cond::TagInfo_t const &tagInfo, cond::LogDBEntry_t const &logDBEntry) const

	PopConSourceHandler ()

Container const &	returnData ()

cond::TagInfo_t const &	tagInfo () const

std::string const &	userTextLog () const

virtual	~PopConSourceHandler ()

Public Attributes
EcalCondDBInterface *	econn

Private Attributes
std::string	m_file_name

std::string	m_file_type

unsigned int	m_firstRun

std::string	m_name

const EcalPFRecHitThresholds *	myPFRecHitThresholds

Additional Inherited Members
Public Types inherited from popcon::PopConSourceHandler< EcalPFRecHitThresholds >
typedef std::map< Time_t, std::shared_ptr< EcalPFRecHitThresholds > >	Container

typedef std::unique_ptr< EcalPFRecHitThresholds >	Ref

typedef PopConSourceHandler< EcalPFRecHitThresholds >	self

typedef cond::Time_t	Time_t

typedef EcalPFRecHitThresholds	value_type

Protected Member Functions inherited from popcon::PopConSourceHandler< EcalPFRecHitThresholds >
cond::persistency::Session &	dbSession () const

Protected Attributes inherited from popcon::PopConSourceHandler< EcalPFRecHitThresholds >
Container	m_iovs

std::vector< std::pair< EcalPFRecHitThresholds *, Time_t > >	m_to_transfer

std::string	m_userTextLog

Detailed Description

Definition at line 46 of file EcalPFRecHitThresholdsHandler.h.

Constructor & Destructor Documentation

◆ EcalPFRecHitThresholdsHandler()

popcon::EcalPFRecHitThresholdsHandler::EcalPFRecHitThresholdsHandler ( edm::ParameterSet const & ps )

Definition at line 10 of file EcalPFRecHitThresholdsHandler.cc.

References edm::ParameterSet::getParameter(), m_file_name, m_file_type, m_firstRun, and AlCaHLTBitMon_QueryRunRegistry::string.

     : m_name(ps.getUntrackedParameter<std::string>("name", "EcalPFRecHitThresholdsHandler")) {
   edm::LogInfo("EcalPFRecHitThresholds Source handler constructor\n");
   m_firstRun = static_cast<unsigned int>(atoi(ps.getParameter<std::string>("firstRun").c_str()));
   m_file_type = ps.getParameter<std::string>("type");  // xml/txt
   m_file_name = ps.getParameter<std::string>("fileName");
 }

◆ ~EcalPFRecHitThresholdsHandler()

popcon::EcalPFRecHitThresholdsHandler::~EcalPFRecHitThresholdsHandler ( )

override

Definition at line 18 of file EcalPFRecHitThresholdsHandler.cc.

18 {}

Member Function Documentation

◆ getNewObjects()

void popcon::EcalPFRecHitThresholdsHandler::getNewObjects ( )

overridevirtual

Implements popcon::PopConSourceHandler< EcalPFRecHitThresholds >.

Definition at line 20 of file EcalPFRecHitThresholdsHandler.cc.

References jetsAK4_Puppi_cff::payload, contentValuesCheck::ss, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                         {
   //  std::cout << "------- Ecal - > getNewObjects\n";
   std::ostringstream ss;
   ss << "ECAL ";
 
   unsigned long long irun;
   std::string file_ = m_file_name;
   edm::LogInfo("going to open file ") << file_;
 
   //      EcalCondHeader   header;
   EcalPFRecHitThresholds* payload = new EcalPFRecHitThresholds;
   if (m_file_type == "xml")
     readXML(file_, *payload);
   else
     readTXT(file_, *payload);
   irun = m_firstRun;
   Time_t snc = (Time_t)irun;
 
   popcon::PopConSourceHandler<EcalPFRecHitThresholds>::m_to_transfer.push_back(std::make_pair(payload, snc));
 }

◆ id()

std::string popcon::EcalPFRecHitThresholdsHandler::id ( ) const

inlineoverridevirtual

Implements popcon::PopConSourceHandler< EcalPFRecHitThresholds >.

Definition at line 55 of file EcalPFRecHitThresholdsHandler.h.

References m_name.

55 { return m_name; }

popcon::EcalPFRecHitThresholdsHandler::m_name

std::string m_name

Definition: EcalPFRecHitThresholdsHandler.h:60

◆ readTXT()

void popcon::EcalPFRecHitThresholdsHandler::readTXT	(	const std::string &	filename,
		EcalFloatCondObjectContainer &	record
	)

Definition at line 97 of file EcalPFRecHitThresholdsHandler.cc.

References PVValHelper::eta, EBDetId::ETAPHIMODE, beamvalidation::exit(), kChannels, kEBChannels, kEEChannels, mps_splice::line, phi, Hcal_FrontierConditions_cff::record, AlCaHLTBitMon_QueryRunRegistry::string, heppy_batch::val, x, EEDetId::XYMODE, y, and z.

                                                                                                               {
   std::ifstream ftxt;
   ftxt.open(file_);
   if (!ftxt.is_open()) {
     edm::LogInfo("ERROR : cannot open file ") << file_;
     exit(1);
   }
   int number_of_lines = 0, eta, phi, x, y, z;
   float val;
   std::string line;
   while (std::getline(ftxt, line)) {
     if (number_of_lines < kEBChannels) {  // barrel
       sscanf(line.c_str(), "%i %i %i %f", &eta, &phi, &z, &val);
       EBDetId ebdetid(eta, phi, EBDetId::ETAPHIMODE);
       record[ebdetid] = val;
     } else {  // endcaps
       sscanf(line.c_str(), "%i %i %i %f", &x, &y, &z, &val);
       EEDetId eedetid(x, y, z, EEDetId::XYMODE);
       record[eedetid] = val;
     }
     number_of_lines++;
   }
   edm::LogInfo("Number of lines in text file: ") << number_of_lines;
   int kChannels = kEBChannels + kEEChannels;
   if (number_of_lines != kChannels)
     edm::LogInfo("wrong number of channels!  Please check ");
 }

◆ readXML()

void popcon::EcalPFRecHitThresholdsHandler::readXML	(	const std::string &	filename,
		EcalFloatCondObjectContainer &	record
	)

Definition at line 41 of file EcalPFRecHitThresholdsHandler.cc.

References beamvalidation::exit(), newFWLiteAna::found, mps_fire::i, kEBChannels, kEEChannels, Hcal_FrontierConditions_cff::record, AlCaHLTBitMon_QueryRunRegistry::string, EBDetId::unhashIndex(), EEDetId::unhashIndex(), and heppy_batch::val.

                                                                                                               {
   std::string dummyLine, bid;
   std::ifstream fxml;
   fxml.open(file_);
   if (!fxml.is_open()) {
     edm::LogInfo("ERROR : cannot open file ") << file_;
     exit(1);
   }
   // header
   for (int i = 0; i < 6; i++) {
     getline(fxml, dummyLine);  // skip first lines
     //  std::cout << dummyLine << std::endl;
   }
   fxml >> bid;
   std::string stt = bid.substr(7, 5);
   std::istringstream iEB(stt);
   int nEB;
   iEB >> nEB;
   if (nEB != kEBChannels) {
     edm::LogInfo("strange number of EB channels ") << nEB;
     exit(-1);
   }
   fxml >> bid;  // <item_version>0</item_version>
   for (int iChannel = 0; iChannel < kEBChannels; iChannel++) {
     EBDetId myEBDetId = EBDetId::unhashIndex(iChannel);
     fxml >> bid;
     std::size_t found = bid.find("</");
     stt = bid.substr(6, found - 6);
     float val = std::stof(stt);
     record[myEBDetId] = val;
   }
   for (int i = 0; i < 5; i++) {
     getline(fxml, dummyLine);  // skip first lines
     //  std::cout << dummyLine << std::endl;
   }
   fxml >> bid;
   stt = bid.substr(7, 5);
   std::istringstream iEE(stt);
   int nEE;
   iEE >> nEE;
   if (nEE != kEEChannels) {
     edm::LogInfo("strange number of EE channels ") << nEE;
     exit(-1);
   }
   fxml >> bid;  // <item_version>0</item_version>
   // now endcaps
   for (int iChannel = 0; iChannel < kEEChannels; iChannel++) {
     EEDetId myEEDetId = EEDetId::unhashIndex(iChannel);
     fxml >> bid;
     std::size_t found = bid.find("</");
     stt = bid.substr(6, found - 6);
     float val = std::stof(stt);
     record[myEEDetId] = val;
   }
 }