#include <EcalADCToGeVHandler.h>

Inheritance diagram for popcon::EcalADCToGeVHandler:

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

void	getNewObjects () override

std::string	id () const override

	~EcalADCToGeVHandler () override

Public Member Functions inherited from popcon::PopConSourceHandler< EcalADCToGeVConstant >
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_highfield

std::string	m_file_lowfield

unsigned int	m_firstRun

std::string	m_gentag

unsigned int	m_lastRun

std::string	m_location

std::string	m_locationsource

std::string	m_name

std::string	m_pass

std::string	m_sid

std::string	m_user

const EcalADCToGeVConstant *	myintercalib

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

typedef std::unique_ptr < EcalADCToGeVConstant >	Ref

typedef PopConSourceHandler < EcalADCToGeVConstant >	self

typedef cond::Time_t	Time_t

typedef EcalADCToGeVConstant	value_type

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

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

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

std::string	m_userTextLog

Detailed Description

Definition at line 48 of file EcalADCToGeVHandler.h.

Constructor & Destructor Documentation

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

Definition at line 8 of file EcalADCToGeVHandler.cc.

References gather_cfg::cout, edm::ParameterSet::getParameter(), m_file_highfield, m_file_lowfield, m_firstRun, m_gentag, m_lastRun, m_location, m_locationsource, m_pass, m_sid, m_user, and AlCaHLTBitMon_QueryRunRegistry::string.

     : m_name(ps.getUntrackedParameter<std::string>("name", "EcalADCToGeVHandler")) {
   std::cout << "EcalADCToGeV Source handler constructor\n" << std::endl;
   m_firstRun = static_cast<unsigned int>(atoi(ps.getParameter<std::string>("firstRun").c_str()));
   m_lastRun = static_cast<unsigned int>(atoi(ps.getParameter<std::string>("lastRun").c_str()));
   m_sid = ps.getParameter<std::string>("OnlineDBSID");
   m_user = ps.getParameter<std::string>("OnlineDBUser");
   m_pass = ps.getParameter<std::string>("OnlineDBPassword");
   m_locationsource = ps.getParameter<std::string>("LocationSource");
   m_location = ps.getParameter<std::string>("Location");
   m_gentag = ps.getParameter<std::string>("GenTag");
   m_file_lowfield = ps.getParameter<std::string>("FileLowField");
   m_file_highfield = ps.getParameter<std::string>("FileHighField");
 
   std::cout << m_sid << "/" << m_user << "/" << m_location << "/" << m_gentag << std::endl;
 }

popcon::EcalADCToGeVHandler::~EcalADCToGeVHandler ( )

override

Definition at line 25 of file EcalADCToGeVHandler.cc.

25 {}

Member Function Documentation

void popcon::EcalADCToGeVHandler::getNewObjects ( )

overridevirtual

Implements popcon::PopConSourceHandler< EcalADCToGeVConstant >.

Definition at line 27 of file EcalADCToGeVHandler.cc.

References SplitLinear::begin, gather_cfg::cout, writedatasetfile::dataset, test_db_connect::econn, dataset::end, HLT_FULL_cff::exponent, EcalADCToGeVConstant::getEEValue(), RunDCSMagnetDat::getMagnetCurrent(), RunIOV::getRunNumber(), geometryCSVtoXML::line, VarParsing::mult, jetCorrFactors_cfi::payload, funct::pow(), EcalADCToGeVConstant::setEBValue(), EcalADCToGeVConstant::setEEValue(), findQualityFiles::size, contentValuesCheck::ss, AlCaHLTBitMon_QueryRunRegistry::string, dumpRecoGeometry_cfg::tagInfo, and hgcalPerformanceValidation::val.

                                               {
   std::cout << "------- Ecal - > getNewObjects\n";
 
   std::ostringstream ss;
   ss << "ECAL ";
 
   unsigned int max_since = 0;
   max_since = static_cast<unsigned int>(tagInfo().lastInterval.since);
   std::cout << "max_since : " << max_since << std::endl;
   bool magnet_high = false;
   bool something_to_transfer = false;
   if (tagInfo().size) {
     Ref ped_db = lastPayload();
 
     // we parse the last record in the DB and check if it is low or high field
 
     std::cout << "retrieved last payload " << std::endl;
 
     EcalADCToGeVConstant the_cal;
 
     //unused    float adc_eb=ped_db->getEBValue();
     float adc_ee = ped_db->getEEValue();
 
     //  float the_value_high_eb=0.03894;
     //      float the_value_high_ee=0.06285;
     // float the_value_high_eb=0.03894;
     // float the_value_high_ee=0.06378;
 
     // bool magnet_high=true;
     // if(adc_eb!= the_value_high_eb || adc_ee!= the_value_high_ee ) magnet_high=false;
 
     //unused    float the_value_low_eb=0.03894;
     // Run 1 :  float the_value_low_ee=0.05678;
     float the_value_low_ee = 0.0590975;
     if (adc_ee > the_value_low_ee)
       magnet_high = true;
   }  // check if there is already a payload
   else
     something_to_transfer = true;
 
   // here we connect to the online DB to check the value of the magnetic field
   std::cout << "Connecting to ONLINE DB ... " << std::endl;
   econn = new EcalCondDBInterface(m_sid, m_user, m_pass);
   std::cout << "Connection done" << std::endl;
 
   std::cout << "Retrieving last run from ONLINE DB ... " << std::endl;
   std::map<EcalLogicID, RunDat> rundat;
   RunIOV rp;
   run_t runmax = 10000000;
   std::string location_p5 = "P5_Co";
   econn->fetchValidDataSet(&rundat, &rp, location_p5, runmax);
 
   unsigned long long irun = (unsigned long long)rp.getRunNumber();
 
   std::cout << "retrieved run number " << irun << std::endl;
 
   if (irun > max_since) {
     // retrieve from last value data record
     // always call this method at first run
 
     std::map<EcalLogicID, RunDCSMagnetDat> dataset;
 
     econn->fetchDataSet(&dataset, &rp);
 
     if (dataset.empty()) {
       throw(std::runtime_error("Zero rows read back"));
     } else {
       std::cout << "retrieved magnet current" << std::endl;
     }
 
     float mag_cur = 0;
 
     std::map<EcalLogicID, RunDCSMagnetDat>::iterator it;
     for (it = dataset.begin(); it != dataset.end(); ++it) {
       RunDCSMagnetDat a_mag = (*it).second;
       mag_cur = a_mag.getMagnetCurrent();
     }
 
     std::string file_ = m_file_highfield;
     if (tagInfo().size) {
       if (mag_cur > 7000. && magnet_high) {
         std::cout << " the magnet is ON and the constants are for magnet ON " << std::endl;
 
       } else if (mag_cur > 7000. && !magnet_high) {
         something_to_transfer = true;
         std::cout << " the magnet is ON and the constants are for magnet OFF " << std::endl;
         std::cout << " I transfer the ON constants " << std::endl;
         file_ = m_file_highfield;
 
       } else if (mag_cur < 6000. && magnet_high) {
         something_to_transfer = true;
         std::cout << " the magnet is OFF and the constants are for magnet ON " << std::endl;
         std::cout << " I transfer the OFF constants " << std::endl;
         file_ = m_file_lowfield;
 
       } else if (mag_cur < 6000. && !magnet_high) {
         std::cout << " the magnet is OFF and the constants are for magnet OFF " << std::endl;
         file_ = m_file_lowfield;
 
       } else {
         std::cout << " the magnet is in a strange situation I do nothing ... just be patient " << std::endl;
       }
     } else {
       if (mag_cur > 7000.)
         std::cout << " first payload, the magnet is ON " << std::endl;
       else if (mag_cur < 6000.) {
         std::cout << " first payload, the magnet is OFF " << std::endl;
         file_ = m_file_lowfield;
       } else
         std::cout << " the magnet is in a strange situation I do nothing ... just be patient " << std::endl;
     }
 
     if (something_to_transfer) {
       std::cout << "Generating popcon record for run " << irun << "  going to open file " << file_ << "\n"
                 << std::flush;
       EcalADCToGeVConstant* payload = new EcalADCToGeVConstant;
       //      EcalCondHeader   header;   // DBv1
       //        EcalADCToGeVXMLTranslator::readXML(file_,header,*payload);   // DBv1
       // DBv2 poor xml file :-(
       std::ifstream fxml;
       fxml.open(file_.c_str());
       std::string line, bid, bid2;
       float val;
       for (int il = 0; il < 4; il++) {
         std::getline(fxml, line);
         //  std::cout << line << "\n";
       }
       for (int iPart = 0; iPart < 2; iPart++) {  //  EB, EE
         fxml >> bid;
         std::size_t begin = bid.find_first_of('>');
         std::size_t end = bid.find_last_of('<');
         begin++;
         std::string str2 = bid.substr(begin, end - begin);
         std::size_t endmantissa = str2.find('e');
         std::string mantissa = str2.substr(0, endmantissa);
         std::size_t string_size = str2.size();
         std::string exponent = str2.substr(endmantissa + 1, string_size);
         std::istringstream is(mantissa);
         is >> val;
         float mult;
         std::istringstream ise(exponent);
         ise >> mult;
         val = val * pow(10, mult);
         std::cout << " Partition " << iPart << " ADCToGeV " << val << "\n";
         if (iPart < 1)
           payload->setEBValue(val);
         else
           payload->setEEValue(val);
       }
       // end change for DBv2
 
       Time_t snc = (Time_t)irun;
       popcon::PopConSourceHandler<EcalADCToGeVConstant>::m_to_transfer.push_back(std::make_pair(payload, snc));
       ss << "Run=" << irun << "_Magnet_changed_" << std::endl;
       m_userTextLog = ss.str() + ";";
     } else {
       std::cout << "Run " << irun << " nothing sent to the DB" << std::endl;
       ss << "Run=" << irun << "_Magnet_NOT_changed_" << std::endl;
       m_userTextLog = ss.str() + ";";
     }
 
     delete econn;
   }  // irun > max_since
   else {
     std::cout << "Run " << irun << " nothing sent to the DB" << std::endl;
     ss << "Run=" << irun << "_no_new_runs_" << std::endl;
     m_userTextLog = ss.str() + ";";
   }
   std::cout << "Ecal - > end of getNewObjects -----------\n";
 }