#include <LHCInfoPopConSourceHandler.h>

Inheritance diagram for LHCInfoPopConSourceHandler:

Public Member Functions
void	getNewObjects () override

std::string	id () const override

	LHCInfoPopConSourceHandler (const edm::ParameterSet &pset)

	~LHCInfoPopConSourceHandler () override

Public Member Functions inherited from popcon::PopConSourceHandler< LHCInfo >
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 ()

Private Member Functions
void	addEmptyPayload (cond::Time_t iov)

bool	getCTTPSData (cond::persistency::Session &session, const boost::posix_time::ptime &beginFillTime, const boost::posix_time::ptime &endFillTime)

bool	getDipData (cond::persistency::Session &session, const boost::posix_time::ptime &beginFillTime, const boost::posix_time::ptime &endFillTime)

bool	getEcalData (cond::persistency::Session &session, const boost::posix_time::ptime &lowerTime, const boost::posix_time::ptime &upperTime, bool update)

bool	getFillData (cond::persistency::Session &session, unsigned short fillId)

size_t	getLumiData (cond::persistency::Session &session, const boost::posix_time::ptime &beginFillTime, const boost::posix_time::ptime &endFillTime)

bool	getNextFillData (cond::persistency::Session &session, const boost::posix_time::ptime &targetTime, bool ended)

Private Attributes
std::string	m_authpath

std::string	m_connectionString

bool	m_debug

std::string	m_dipSchema

std::string	m_ecalConnectionString

bool	m_endFill = true

boost::posix_time::ptime	m_endTime

std::unique_ptr< LHCInfo >	m_fillPayload

bool	m_lastPayloadEmpty = false

std::string	m_name

std::shared_ptr< LHCInfo >	m_prevPayload

unsigned int	m_samplingInterval

boost::posix_time::ptime	m_startTime

std::vector< std::pair < cond::Time_t, std::shared_ptr< LHCInfo > > >	m_tmpBuffer

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

typedef std::unique_ptr< LHCInfo >	Ref

typedef PopConSourceHandler < LHCInfo >	self

typedef cond::Time_t	Time_t

typedef LHCInfo	value_type

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

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

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

std::string	m_userTextLog

Detailed Description

Definition at line 10 of file LHCInfoPopConSourceHandler.h.

Constructor & Destructor Documentation

LHCInfoPopConSourceHandler::LHCInfoPopConSourceHandler ( const edm::ParameterSet & pset )

Definition at line 21 of file LHCInfoPopConSourceHandler.cc.

References edm::ParameterSet::exists(), edm::ParameterSet::getUntrackedParameter(), m_endTime, m_startTime, submitPVValidationJobs::now, and AlCaHLTBitMon_QueryRunRegistry::string.

     : m_debug(pset.getUntrackedParameter<bool>("debug", false)),
       m_startTime(),
       m_endTime(),
       m_samplingInterval((unsigned int)pset.getUntrackedParameter<unsigned int>("samplingInterval", 300)),
       m_endFill(pset.getUntrackedParameter<bool>("endFill", true)),
       m_name(pset.getUntrackedParameter<std::string>("name", "LHCInfoPopConSourceHandler")),
       m_connectionString(pset.getUntrackedParameter<std::string>("connectionString", "")),
       m_ecalConnectionString(pset.getUntrackedParameter<std::string>("ecalConnectionString", "")),
       m_dipSchema(pset.getUntrackedParameter<std::string>("DIPSchema", "")),
       m_authpath(pset.getUntrackedParameter<std::string>("authenticationPath", "")),
       m_fillPayload(),
       m_prevPayload(),
       m_tmpBuffer() {
   if (pset.exists("startTime")) {
     m_startTime = boost::posix_time::time_from_string(pset.getUntrackedParameter<std::string>("startTime"));
   }
   boost::posix_time::ptime now = boost::posix_time::second_clock::local_time();
   m_endTime = now;
   if (pset.exists("endTime")) {
     m_endTime = boost::posix_time::time_from_string(pset.getUntrackedParameter<std::string>("endTime"));
     if (m_endTime > now)
       m_endTime = now;
   }
 }

LHCInfoPopConSourceHandler::~LHCInfoPopConSourceHandler ( )

override

Definition at line 48 of file LHCInfoPopConSourceHandler.cc.

48 {}

Member Function Documentation

void LHCInfoPopConSourceHandler::addEmptyPayload ( cond::Time_t iov )

private

Definition at line 773 of file LHCInfoPopConSourceHandler.cc.

References PVValHelper::add(), popcon::PopConSourceHandler< LHCInfo >::m_iovs, m_lastPayloadEmpty, and m_prevPayload.

Referenced by getNewObjects().

                                                                {
   bool add = false;
   if (m_iovs.empty()) {
     if (!m_lastPayloadEmpty)
       add = true;
   } else {
     auto lastAdded = m_iovs.rbegin()->second;
     if (lastAdded->fillNumber() != 0) {
       add = true;
     }
   }
   if (add) {
     auto newPayload = std::make_shared<LHCInfo>();
     m_iovs.insert(std::make_pair(iov, newPayload));
     m_prevPayload = newPayload;
   }
 }

bool LHCInfoPopConSourceHandler::getCTTPSData	(	cond::persistency::Session &	session,
		const boost::posix_time::ptime &	beginFillTime,
		const boost::posix_time::ptime &	endFillTime
	)

private

Definition at line 532 of file LHCInfoPopConSourceHandler.cc.

References cond::persistency::Session::coralSession(), LHCInfoImpl::LumiSectionFilter::current(), alcazmumu_cfi::filter, cond::time::from_boost(), m_debug, m_tmpBuffer, jetCorrFactors_cfi::payload, LHCInfoImpl::LumiSectionFilter::process(), runTheMatrix::ret, LHCInfo::setBetaStar(), LHCInfo::setCrossingAngle(), LHCInfo::setCtppsStatus(), LHCInfo::setLhcComment(), LHCInfo::setLhcState(), LHCInfo::setLumiSection(), and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by getNewObjects().

                                                                                        {
   //run the fifth query against the CTPPS schema
   //Initializing the CMS_CTP_CTPPS_COND schema.
   coral::ISchema& CTPPS = session.coralSession().schema("CMS_CTP_CTPPS_COND");
   //execute query for CTPPS Data
   std::unique_ptr<coral::IQuery> CTPPSDataQuery(CTPPS.newQuery());
   //FROM clause
   CTPPSDataQuery->addToTableList(std::string("CTPPS_LHC_MACHINE_PARAMS"));
   //SELECT clause
   CTPPSDataQuery->addToOutputList(std::string("DIP_UPDATE_TIME"));
   CTPPSDataQuery->addToOutputList(std::string("LHC_STATE"));
   CTPPSDataQuery->addToOutputList(std::string("LHC_COMMENT"));
   CTPPSDataQuery->addToOutputList(std::string("CTPPS_STATUS"));
   CTPPSDataQuery->addToOutputList(std::string("LUMI_SECTION"));
   CTPPSDataQuery->addToOutputList(std::string("XING_ANGLE_URAD"));
   CTPPSDataQuery->addToOutputList(std::string("BETA_STAR_CMS"));
   //WHERE CLAUSE
   coral::AttributeList CTPPSDataBindVariables;
   CTPPSDataBindVariables.extend<coral::TimeStamp>(std::string("beginFillTime"));
   CTPPSDataBindVariables.extend<coral::TimeStamp>(std::string("endFillTime"));
   CTPPSDataBindVariables[std::string("beginFillTime")].data<coral::TimeStamp>() = coral::TimeStamp(beginFillTime);
   CTPPSDataBindVariables[std::string("endFillTime")].data<coral::TimeStamp>() = coral::TimeStamp(endFillTime);
   std::string conditionStr = std::string("DIP_UPDATE_TIME>= :beginFillTime and DIP_UPDATE_TIME< :endFillTime");
   CTPPSDataQuery->setCondition(conditionStr, CTPPSDataBindVariables);
   //ORDER BY clause
   CTPPSDataQuery->addToOrderList(std::string("DIP_UPDATE_TIME"));
   //define query output
   coral::AttributeList CTPPSDataOutput;
   CTPPSDataOutput.extend<coral::TimeStamp>(std::string("DIP_UPDATE_TIME"));
   CTPPSDataOutput.extend<std::string>(std::string("LHC_STATE"));
   CTPPSDataOutput.extend<std::string>(std::string("LHC_COMMENT"));
   CTPPSDataOutput.extend<std::string>(std::string("CTPPS_STATUS"));
   CTPPSDataOutput.extend<int>(std::string("LUMI_SECTION"));
   CTPPSDataOutput.extend<float>(std::string("XING_ANGLE_URAD"));
   CTPPSDataOutput.extend<float>(std::string("BETA_STAR_CMS"));
   CTPPSDataQuery->defineOutput(CTPPSDataOutput);
   //execute the query
   coral::ICursor& CTPPSDataCursor = CTPPSDataQuery->execute();
   cond::Time_t dipTime = 0;
   std::string lhcState = "", lhcComment = "", ctppsStatus = "";
   unsigned int lumiSection = 0;
   float crossingAngle = 0., betastar = 0.;
 
   bool ret = false;
   LHCInfoImpl::LumiSectionFilter filter(m_tmpBuffer);
   while (CTPPSDataCursor.next()) {
     if (m_debug) {
       std::ostringstream CTPPS;
       CTPPSDataCursor.currentRow().toOutputStream(CTPPS);
     }
     coral::Attribute const& dipTimeAttribute = CTPPSDataCursor.currentRow()[std::string("DIP_UPDATE_TIME")];
     if (!dipTimeAttribute.isNull()) {
       dipTime = cond::time::from_boost(dipTimeAttribute.data<coral::TimeStamp>().time());
       if (filter.process(dipTime)) {
         ret = true;
         coral::Attribute const& lhcStateAttribute = CTPPSDataCursor.currentRow()[std::string("LHC_STATE")];
         if (!lhcStateAttribute.isNull()) {
           lhcState = lhcStateAttribute.data<std::string>();
         }
         coral::Attribute const& lhcCommentAttribute = CTPPSDataCursor.currentRow()[std::string("LHC_COMMENT")];
         if (!lhcCommentAttribute.isNull()) {
           lhcComment = lhcCommentAttribute.data<std::string>();
         }
         coral::Attribute const& ctppsStatusAttribute = CTPPSDataCursor.currentRow()[std::string("CTPPS_STATUS")];
         if (!ctppsStatusAttribute.isNull()) {
           ctppsStatus = ctppsStatusAttribute.data<std::string>();
         }
         coral::Attribute const& lumiSectionAttribute = CTPPSDataCursor.currentRow()[std::string("LUMI_SECTION")];
         if (!lumiSectionAttribute.isNull()) {
           lumiSection = lumiSectionAttribute.data<int>();
         }
         coral::Attribute const& crossingAngleAttribute = CTPPSDataCursor.currentRow()[std::string("XING_ANGLE_URAD")];
         if (!crossingAngleAttribute.isNull()) {
           crossingAngle = crossingAngleAttribute.data<float>();
         }
         coral::Attribute const& betaStarAttribute = CTPPSDataCursor.currentRow()[std::string("BETA_STAR_CMS")];
         if (!betaStarAttribute.isNull()) {
           betastar = betaStarAttribute.data<float>();
         }
         for (auto it = filter.current(); it != m_tmpBuffer.end(); it++) {
           // set the current values to all of the payloads of the lumi section samples after the current since
           LHCInfo& payload = *(it->second);
           payload.setCrossingAngle(crossingAngle);
           payload.setBetaStar(betastar);
           payload.setLhcState(lhcState);
           payload.setLhcComment(lhcComment);
           payload.setCtppsStatus(ctppsStatus);
           payload.setLumiSection(lumiSection);
         }
       }
     }
   }
   return ret;
 }

bool LHCInfoPopConSourceHandler::getDipData	(	cond::persistency::Session &	session,
		const boost::posix_time::ptime &	beginFillTime,
		const boost::posix_time::ptime &	endFillTime
	)

private

Definition at line 389 of file LHCInfoPopConSourceHandler.cc.

References LHCInfo::availableBunchSlots, cond::persistency::Session::coralSession(), cond::time::from_boost(), m_debug, m_dipSchema, m_fillPayload, or, runTheMatrix::ret, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by getNewObjects().

                                                                                      {
   //run the third and fourth query against the schema hosting detailed DIP information
   coral::ISchema& beamCondSchema = session.coralSession().schema(m_dipSchema);
   //start the transaction against the DIP "deep" database backend schema
   //prepare the WHERE clause for both queries
   coral::AttributeList bunchConfBindVariables;
   bunchConfBindVariables.extend<coral::TimeStamp>(std::string("beginFillTime"));
   bunchConfBindVariables.extend<coral::TimeStamp>(std::string("endFillTime"));
   bunchConfBindVariables[std::string("beginFillTime")].data<coral::TimeStamp>() = coral::TimeStamp(beginFillTime);
   bunchConfBindVariables[std::string("endFillTime")].data<coral::TimeStamp>() = coral::TimeStamp(endFillTime);
   std::string conditionStr = std::string("DIPTIME >= :beginFillTime and DIPTIME< :endFillTime");
   //define the output types for both queries
   coral::AttributeList bunchConfOutput;
   bunchConfOutput.extend<coral::TimeStamp>(std::string("DIPTIME"));
   bunchConfOutput.extend<unsigned short>(std::string("BUCKET"));
   //execute query for Beam 1
   std::unique_ptr<coral::IQuery> bunchConf1Query(beamCondSchema.newQuery());
   bunchConf1Query->addToTableList(std::string("LHC_CIRCBUNCHCONFIG_BEAM1"),
                                   std::string("BEAMCONF\", TABLE( BEAMCONF.VALUE ) \"BUCKETS"));
   bunchConf1Query->addToOutputList(std::string("BEAMCONF.DIPTIME"), std::string("DIPTIME"));
   bunchConf1Query->addToOutputList(std::string("BUCKETS.COLUMN_VALUE"), std::string("BUCKET"));
   bunchConf1Query->setCondition(conditionStr, bunchConfBindVariables);
   bunchConf1Query->addToOrderList(std::string("DIPTIME"));
   bunchConf1Query->limitReturnedRows(LHCInfo::availableBunchSlots);  //maximum number of filled bunches
   bunchConf1Query->defineOutput(bunchConfOutput);
 
   coral::ICursor& bunchConf1Cursor = bunchConf1Query->execute();
   std::bitset<LHCInfo::bunchSlots + 1> bunchConfiguration1(0ULL);
   bool ret = false;
   cond::Time_t lumiSectionTime = 0;
   while (bunchConf1Cursor.next()) {
     if (m_debug) {
       std::ostringstream b1s;
       bunchConf1Cursor.currentRow().toOutputStream(b1s);
     }
     coral::Attribute const& dipTimeAttribute = bunchConf1Cursor.currentRow()[std::string("DIPTIME")];
     coral::Attribute const& bunchConf1Attribute = bunchConf1Cursor.currentRow()[std::string("BUCKET")];
     if (!dipTimeAttribute.isNull() and !bunchConf1Attribute.isNull()) {
       cond::Time_t dipTime = cond::time::from_boost(dipTimeAttribute.data<coral::TimeStamp>().time());
       // assuming only one sample has been selected...
       unsigned short slot = (bunchConf1Attribute.data<unsigned short>() - 1) / 10 + 1;
       if (lumiSectionTime == 0 or lumiSectionTime == dipTime) {
         bunchConfiguration1[slot] = true;
       } else
         break;
       lumiSectionTime = dipTime;
     }
   }
   if (ret) {
     m_fillPayload->setBunchBitsetForBeam1(bunchConfiguration1);
   }
 
   //execute query for Beam 2
   std::unique_ptr<coral::IQuery> bunchConf2Query(beamCondSchema.newQuery());
   bunchConf2Query->addToTableList(std::string("LHC_CIRCBUNCHCONFIG_BEAM2"),
                                   std::string("BEAMCONF\", TABLE( BEAMCONF.VALUE ) \"BUCKETS"));
   bunchConf2Query->addToOutputList(std::string("BEAMCONF.DIPTIME"), std::string("DIPTIME"));
   bunchConf2Query->addToOutputList(std::string("BUCKETS.COLUMN_VALUE"), std::string("BUCKET"));
   bunchConf2Query->setCondition(conditionStr, bunchConfBindVariables);
   bunchConf2Query->addToOrderList(std::string("DIPTIME"));
   bunchConf2Query->limitReturnedRows(LHCInfo::availableBunchSlots);  //maximum number of filled bunches
   bunchConf2Query->defineOutput(bunchConfOutput);
   coral::ICursor& bunchConf2Cursor = bunchConf2Query->execute();
 
   std::bitset<LHCInfo::bunchSlots + 1> bunchConfiguration2(0ULL);
   ret = false;
   lumiSectionTime = 0;
   while (bunchConf2Cursor.next()) {
     if (m_debug) {
       std::ostringstream b2s;
       bunchConf2Cursor.currentRow().toOutputStream(b2s);
     }
     coral::Attribute const& dipTimeAttribute = bunchConf2Cursor.currentRow()[std::string("DIPTIME")];
     coral::Attribute const& bunchConf2Attribute = bunchConf2Cursor.currentRow()[std::string("BUCKET")];
     if (!dipTimeAttribute.isNull() and !bunchConf2Attribute.isNull()) {
       ret = true;
       cond::Time_t dipTime = cond::time::from_boost(dipTimeAttribute.data<coral::TimeStamp>().time());
       // assuming only one sample has been selected...
       unsigned short slot = (bunchConf2Attribute.data<unsigned short>() - 1) / 10 + 1;
       if (lumiSectionTime == 0 or lumiSectionTime == dipTime) {
         bunchConfiguration2[slot] = true;
       } else
         break;
       lumiSectionTime = dipTime;
     }
   }
   if (ret) {
     m_fillPayload->setBunchBitsetForBeam2(bunchConfiguration2);
   }
   //execute query for lumiPerBX
   std::unique_ptr<coral::IQuery> lumiDataQuery(beamCondSchema.newQuery());
   lumiDataQuery->addToTableList(std::string("CMS_LHC_LUMIPERBUNCH"),
                                 std::string("LUMIPERBUNCH\", TABLE( LUMIPERBUNCH.LUMI_BUNCHINST ) \"VALUE"));
   lumiDataQuery->addToOutputList(std::string("LUMIPERBUNCH.DIPTIME"), std::string("DIPTIME"));
   lumiDataQuery->addToOutputList(std::string("VALUE.COLUMN_VALUE"), std::string("LUMI_BUNCH"));
   coral::AttributeList lumiDataBindVariables;
   lumiDataBindVariables.extend<coral::TimeStamp>(std::string("beginFillTime"));
   lumiDataBindVariables.extend<coral::TimeStamp>(std::string("endFillTime"));
   lumiDataBindVariables[std::string("beginFillTime")].data<coral::TimeStamp>() = coral::TimeStamp(beginFillTime);
   lumiDataBindVariables[std::string("endFillTime")].data<coral::TimeStamp>() = coral::TimeStamp(endFillTime);
   conditionStr = std::string("DIPTIME BETWEEN :beginFillTime AND :endFillTime");
   lumiDataQuery->setCondition(conditionStr, lumiDataBindVariables);
   lumiDataQuery->addToOrderList(std::string("DIPTIME"));
   lumiDataQuery->limitReturnedRows(3564);  //Maximum number of bunches.
   //define query output
   coral::AttributeList lumiDataOutput;
   lumiDataOutput.extend<coral::TimeStamp>(std::string("DIPTIME"));
   lumiDataOutput.extend<float>(std::string("LUMI_BUNCH"));
   lumiDataQuery->defineOutput(lumiDataOutput);
   //execute the query
   coral::ICursor& lumiDataCursor = lumiDataQuery->execute();
 
   std::vector<float> lumiPerBX;
   ret = false;
   lumiSectionTime = 0;
   while (lumiDataCursor.next()) {
     if (m_debug) {
       std::ostringstream lpBX;
       lumiDataCursor.currentRow().toOutputStream(lpBX);
     }
     coral::Attribute const& dipTimeAttribute = lumiDataCursor.currentRow()[std::string("DIPTIME")];
     coral::Attribute const& lumiBunchAttribute = lumiDataCursor.currentRow()[std::string("LUMI_BUNCH")];
     if (!dipTimeAttribute.isNull() and !lumiBunchAttribute.isNull()) {
       ret = true;
       cond::Time_t dipTime = cond::time::from_boost(dipTimeAttribute.data<coral::TimeStamp>().time());
       // assuming only one sample has been selected...
       float lumi_b = lumiBunchAttribute.data<float>();
       if (lumiSectionTime == 0 or lumiSectionTime == dipTime) {
         if (lumi_b != 0.00)
           lumiPerBX.push_back(lumi_b);
       } else
         break;
       lumiSectionTime = dipTime;
     }
   }
   if (ret) {
     m_fillPayload->setLumiPerBX(lumiPerBX);
   }
   return ret;
 }

bool LHCInfoPopConSourceHandler::getEcalData	(	cond::persistency::Session &	session,
		const boost::posix_time::ptime &	lowerTime,
		const boost::posix_time::ptime &	upperTime,
		bool	update
	)

private

Definition at line 667 of file LHCInfoPopConSourceHandler.cc.

References LHCInfoImpl::LumiSectionFilter::current(), ECAL, alcazmumu_cfi::filter, cond::time::from_boost(), CommonMethods::isnan(), m_debug, m_name, m_prevPayload, m_tmpBuffer, cond::persistency::Session::nominalSchema(), jetCorrFactors_cfi::payload, LHCInfoImpl::LumiSectionFilter::process(), runTheMatrix::ret, LHCInfoImpl::setElementData(), AlCaHLTBitMon_QueryRunRegistry::string, cond::time::to_boost(), and relativeConstraints::value.

Referenced by getNewObjects().

                                                           {
   //run the sixth query against the CMS_DCS_ENV_PVSS_COND schema
   //Initializing the CMS_DCS_ENV_PVSS_COND schema.
   coral::ISchema& ECAL = session.nominalSchema();
   //start the transaction against the fill logging schema
   //execute query for ECAL Data
   std::unique_ptr<coral::IQuery> ECALDataQuery(ECAL.newQuery());
   //FROM clause
   ECALDataQuery->addToTableList(std::string("BEAM_PHASE"));
   //SELECT clause
   ECALDataQuery->addToOutputList(std::string("CHANGE_DATE"));
   ECALDataQuery->addToOutputList(std::string("DIP_value"));
   ECALDataQuery->addToOutputList(std::string("element_nr"));
   ECALDataQuery->addToOutputList(std::string("VALUE_NUMBER"));
   //WHERE CLAUSE
   coral::AttributeList ECALDataBindVariables;
   ECALDataBindVariables.extend<coral::TimeStamp>(std::string("lowerTime"));
   ECALDataBindVariables.extend<coral::TimeStamp>(std::string("upperTime"));
   ECALDataBindVariables[std::string("lowerTime")].data<coral::TimeStamp>() = coral::TimeStamp(lowerTime);
   ECALDataBindVariables[std::string("upperTime")].data<coral::TimeStamp>() = coral::TimeStamp(upperTime);
   std::string conditionStr = std::string(
       "(DIP_value LIKE '%beamPhaseMean%' OR DIP_value LIKE '%cavPhaseMean%') AND CHANGE_DATE >= :lowerTime AND "
       "CHANGE_DATE < :upperTime");
 
   ECALDataQuery->setCondition(conditionStr, ECALDataBindVariables);
   //ORDER BY clause
   ECALDataQuery->addToOrderList(std::string("CHANGE_DATE"));
   ECALDataQuery->addToOrderList(std::string("DIP_value"));
   ECALDataQuery->addToOrderList(std::string("element_nr"));
   //define query output
   coral::AttributeList ECALDataOutput;
   ECALDataOutput.extend<coral::TimeStamp>(std::string("CHANGE_DATE"));
   ECALDataOutput.extend<std::string>(std::string("DIP_value"));
   ECALDataOutput.extend<unsigned int>(std::string("element_nr"));
   ECALDataOutput.extend<float>(std::string("VALUE_NUMBER"));
   //ECALDataQuery->limitReturnedRows( 14256 ); //3564 entries per vector.
   ECALDataQuery->defineOutput(ECALDataOutput);
   //execute the query
   coral::ICursor& ECALDataCursor = ECALDataQuery->execute();
   cond::Time_t changeTime = 0;
   cond::Time_t firstTime = 0;
   std::string dipVal = "";
   unsigned int elementNr = 0;
   float value = 0.;
   std::set<cond::Time_t> initializedVectors;
   LHCInfoImpl::LumiSectionFilter filter(m_tmpBuffer);
   bool ret = false;
   if (m_prevPayload.get()) {
     for (auto& lumiSlot : m_tmpBuffer) {
       lumiSlot.second->setBeam1VC(m_prevPayload->beam1VC());
       lumiSlot.second->setBeam2VC(m_prevPayload->beam2VC());
       lumiSlot.second->setBeam1RF(m_prevPayload->beam1RF());
       lumiSlot.second->setBeam2RF(m_prevPayload->beam2RF());
     }
   }
   std::map<cond::Time_t, cond::Time_t> iovMap;
   cond::Time_t lowerLumi = m_tmpBuffer.front().first;
   while (ECALDataCursor.next()) {
     if (m_debug) {
       std::ostringstream ECAL;
       ECALDataCursor.currentRow().toOutputStream(ECAL);
     }
     coral::Attribute const& changeDateAttribute = ECALDataCursor.currentRow()[std::string("CHANGE_DATE")];
     if (!changeDateAttribute.isNull()) {
       ret = true;
       boost::posix_time::ptime chTime = changeDateAttribute.data<coral::TimeStamp>().time();
       // move the first IOV found to the start of the fill interval selected
       if (changeTime == 0) {
         firstTime = cond::time::from_boost(chTime);
       }
       changeTime = cond::time::from_boost(chTime);
       cond::Time_t iovTime = changeTime;
       if (!update and changeTime == firstTime)
         iovTime = lowerLumi;
       coral::Attribute const& dipValAttribute = ECALDataCursor.currentRow()[std::string("DIP_value")];
       coral::Attribute const& valueNumberAttribute = ECALDataCursor.currentRow()[std::string("VALUE_NUMBER")];
       coral::Attribute const& elementNrAttribute = ECALDataCursor.currentRow()[std::string("element_nr")];
       if (!dipValAttribute.isNull() and !valueNumberAttribute.isNull()) {
         dipVal = dipValAttribute.data<std::string>();
         elementNr = elementNrAttribute.data<unsigned int>();
         value = valueNumberAttribute.data<float>();
         if (isnan(value))
           value = 0.;
         if (filter.process(iovTime)) {
           iovMap.insert(std::make_pair(changeTime, filter.current()->first));
           for (auto it = filter.current(); it != m_tmpBuffer.end(); it++) {
             LHCInfo& payload = *(it->second);
             LHCInfoImpl::setElementData(it->first, dipVal, elementNr, value, payload, initializedVectors);
           }
         }
         //}
       }
     }
   }
   if (m_debug) {
     for (auto& im : iovMap) {
       edm::LogInfo(m_name) << "Found iov=" << im.first << " (" << cond::time::to_boost(im.first) << " ) moved to "
                            << im.second << " ( " << cond::time::to_boost(im.second) << " )";
     }
   }
   return ret;
 }

bool LHCInfoPopConSourceHandler::getFillData	(	cond::persistency::Session &	session,
		unsigned short	fillId
	)

private

Definition at line 250 of file LHCInfoPopConSourceHandler.cc.

References m_debug, m_fillPayload, LHCInfoImpl::makeFillDataQuery(), and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by getNewObjects().

                                                                                                    {
   // Prepare the WHERE clause
   coral::AttributeList fillDataBindVariables;
   fillDataBindVariables.extend<unsigned short>(std::string("fillId"));
   fillDataBindVariables[std::string("fillId")].data<unsigned short>() = fillId;
   std::string conditionStr = "LHCFILL=:fillId";
   return LHCInfoImpl::makeFillDataQuery(session, conditionStr, fillDataBindVariables, m_fillPayload, m_debug);
 }

size_t LHCInfoPopConSourceHandler::getLumiData	(	cond::persistency::Session &	session,
		const boost::posix_time::ptime &	beginFillTime,
		const boost::posix_time::ptime &	endFillTime
	)

private

Definition at line 259 of file LHCInfoPopConSourceHandler.cc.

References cond::time::from_boost(), m_fillPayload, m_tmpBuffer, cond::persistency::Session::nominalSchema(), jetCorrFactors_cfi::payload, LHCInfo::setDelivLumi(), LHCInfo::setInstLumi(), LHCInfo::setInstLumiError(), LHCInfo::setRecLumi(), SiStripO2O_cfg_template::since, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by getNewObjects().

                                                                                         {
   coral::ISchema& runTimeLoggerSchema = session.nominalSchema();
   //prepare the query for table 2:
   std::unique_ptr<coral::IQuery> fillDataQuery2(runTimeLoggerSchema.newQuery());
   //FROM clause
   fillDataQuery2->addToTableList(std::string("LUMI_SECTIONS"));
   //SELECT clause
   fillDataQuery2->addToOutputList(std::string("DELIVLUMI"));
   fillDataQuery2->addToOutputList(std::string("LIVELUMI"));
   fillDataQuery2->addToOutputList(std::string("INSTLUMI"));
   fillDataQuery2->addToOutputList(std::string("INSTLUMIERROR"));
   fillDataQuery2->addToOutputList(std::string("STARTTIME"));
   fillDataQuery2->addToOutputList(std::string("LHCFILL"));
   //WHERE clause
   coral::AttributeList fillDataBindVariables;
   fillDataBindVariables.extend<coral::TimeStamp>(std::string("start"));
   fillDataBindVariables.extend<coral::TimeStamp>(std::string("stop"));
   fillDataBindVariables[std::string("start")].data<coral::TimeStamp>() = coral::TimeStamp(beginFillTime);
   fillDataBindVariables[std::string("stop")].data<coral::TimeStamp>() = coral::TimeStamp(endFillTime);
   std::string conditionStr = "DELIVLUMI IS NOT NULL AND STARTTIME >= :start AND STARTTIME< :stop";
   fillDataQuery2->setCondition(conditionStr, fillDataBindVariables);
   //ORDER BY clause
   fillDataQuery2->addToOrderList(std::string("STARTTIME"));
   //define query output*/
   coral::AttributeList fillDataOutput2;
   fillDataOutput2.extend<float>(std::string("DELIVEREDLUMI"));
   fillDataOutput2.extend<float>(std::string("RECORDEDLUMI"));
   fillDataOutput2.extend<float>(std::string("INSTLUMI"));
   fillDataOutput2.extend<float>(std::string("INSTLUMIERROR"));
   fillDataOutput2.extend<coral::TimeStamp>(std::string("STARTTIME"));
   fillDataOutput2.extend<int>(std::string("LHCFILL"));
   fillDataQuery2->defineOutput(fillDataOutput2);
   //execute the query
   coral::ICursor& fillDataCursor2 = fillDataQuery2->execute();
 
   size_t nlumi = 0;
   while (fillDataCursor2.next()) {
     nlumi++;
     float delivLumi = 0., recLumi = 0., instLumi = 0, instLumiErr = 0.;
     cond::Time_t since = 0;
     coral::Attribute const& delivLumiAttribute = fillDataCursor2.currentRow()[std::string("DELIVEREDLUMI")];
     if (!delivLumiAttribute.isNull()) {
       delivLumi = delivLumiAttribute.data<float>() / 1000.;
     }
     coral::Attribute const& recLumiAttribute = fillDataCursor2.currentRow()[std::string("RECORDEDLUMI")];
     if (!recLumiAttribute.isNull()) {
       recLumi = recLumiAttribute.data<float>() / 1000.;
     }
     coral::Attribute const& instLumiAttribute = fillDataCursor2.currentRow()[std::string("INSTLUMI")];
     if (!instLumiAttribute.isNull()) {
       instLumi = instLumiAttribute.data<float>() / 1000.;
     }
     coral::Attribute const& instLumiErrAttribute = fillDataCursor2.currentRow()[std::string("INSTLUMIERROR")];
     if (!instLumiErrAttribute.isNull()) {
       instLumiErr = instLumiErrAttribute.data<float>() / 1000.;
     }
     coral::Attribute const& startLumiSectionAttribute = fillDataCursor2.currentRow()[std::string("STARTTIME")];
     if (!startLumiSectionAttribute.isNull()) {
       since = cond::time::from_boost(startLumiSectionAttribute.data<coral::TimeStamp>().time());
     }
     LHCInfo* thisLumiSectionInfo = m_fillPayload->cloneFill();
     m_tmpBuffer.emplace_back(std::make_pair(since, thisLumiSectionInfo));
     LHCInfo& payload = *thisLumiSectionInfo;
     payload.setDelivLumi(delivLumi);
     payload.setRecLumi(recLumi);
     payload.setInstLumi(instLumi);
     payload.setInstLumiError(instLumiErr);
   }
   return nlumi;
 }

void LHCInfoPopConSourceHandler::getNewObjects ( )

overridevirtual

Implements popcon::PopConSourceHandler< LHCInfo >.

Definition at line 843 of file LHCInfoPopConSourceHandler.cc.

                                                {
   //reference to the last payload in the tag
   Ref previousFill;
 
   //if a new tag is created, transfer fake fill from 1 to the first fill for the first time
   if (tagInfo().name.empty()) {
     edm::LogInfo(m_name) << "New tag " << tagInfo().name << "; from " << m_name << "::getNewObjects";
   } else {
     //check what is already inside the database
     edm::LogInfo(m_name) << "got info for tag " << tagInfo().name << ": size " << tagInfo().size
                          << ", last object valid since " << tagInfo().lastInterval.since << " ( "
                          << boost::posix_time::to_iso_extended_string(
                                 cond::time::to_boost(tagInfo().lastInterval.since))
                          << " ); from " << m_name << "::getNewObjects";
   }
 
   cond::Time_t lastSince = tagInfo().lastInterval.since;
   if (lastSince == 0) {
     // for a new or empty tag, an empty payload should be added on top with since=1
     addEmptyPayload(1);
   } else {
     edm::LogInfo(m_name) << "The last Iov in tag " << tagInfo().name << " valid since " << lastSince << "from "
                          << m_name << "::getNewObjects";
   }
 
   boost::posix_time::ptime executionTime = boost::posix_time::second_clock::local_time();
   cond::Time_t targetSince = 0;
   cond::Time_t endIov = cond::time::from_boost(executionTime);
   if (!m_startTime.is_not_a_date_time()) {
     targetSince = cond::time::from_boost(m_startTime);
   }
   if (lastSince > targetSince)
     targetSince = lastSince;
 
   edm::LogInfo(m_name) << "Starting sampling at "
                        << boost::posix_time::to_simple_string(cond::time::to_boost(targetSince));
 
   //retrieve the data from the relational database source
   cond::persistency::ConnectionPool connection;
   //configure the connection
   if (m_debug) {
     connection.setMessageVerbosity(coral::Debug);
   } else {
     connection.setMessageVerbosity(coral::Error);
   }
   connection.setAuthenticationPath(m_authpath);
   connection.configure();
   //create the sessions
   cond::persistency::Session session = connection.createSession(m_connectionString, false);
   cond::persistency::Session session2 = connection.createSession(m_ecalConnectionString, false);
   // fetch last payload when available
   if (!tagInfo().lastInterval.payloadId.empty()) {
     cond::persistency::Session session3 = dbSession();
     session3.transaction().start(true);
     m_prevPayload = session3.fetchPayload<LHCInfo>(tagInfo().lastInterval.payloadId);
     session3.transaction().commit();
   }
 
   bool iovAdded = false;
   while (true) {
     if (targetSince >= endIov) {
       edm::LogInfo(m_name) << "Sampling ended at the time "
                            << boost::posix_time::to_simple_string(cond::time::to_boost(endIov));
       break;
     }
     bool updateEcal = false;
     boost::posix_time::ptime targetTime = cond::time::to_boost(targetSince);
     boost::posix_time::ptime startSampleTime;
     boost::posix_time::ptime endSampleTime;
     if (!m_endFill and m_prevPayload->fillNumber() and m_prevPayload->endTime() == 0ULL) {
       // execute the query for the current fill
       session.transaction().start(true);
       edm::LogInfo(m_name) << "Searching started fill #" << m_prevPayload->fillNumber();
       bool foundFill = getFillData(session, m_prevPayload->fillNumber());
       session.transaction().commit();
       if (!foundFill) {
         edm::LogError(m_name) << "Could not find fill #" << m_prevPayload->fillNumber();
         break;
       }
       updateEcal = true;
       startSampleTime = cond::time::to_boost(lastSince);
     } else {
       session.transaction().start(true);
       edm::LogInfo(m_name) << "Searching new fill after " << boost::posix_time::to_simple_string(targetTime);
       bool foundFill = getNextFillData(session, targetTime, m_endFill);
       session.transaction().commit();
       if (!foundFill) {
         edm::LogInfo(m_name) << "No fill found - END of job.";
         if (iovAdded)
           addEmptyPayload(targetSince);
         break;
       }
       startSampleTime = cond::time::to_boost(m_fillPayload->createTime());
     }
     cond::Time_t startFillTime = m_fillPayload->createTime();
     cond::Time_t endFillTime = m_fillPayload->endTime();
     unsigned short lhcFill = m_fillPayload->fillNumber();
     if (endFillTime == 0ULL) {
       edm::LogInfo(m_name) << "Found ongoing fill " << lhcFill << " created at " << cond::time::to_boost(startFillTime);
       endSampleTime = executionTime;
       targetSince = endIov;
     } else {
       edm::LogInfo(m_name) << "Found fill " << lhcFill << " created at " << cond::time::to_boost(startFillTime)
                            << " ending at " << cond::time::to_boost(endFillTime);
       endSampleTime = cond::time::to_boost(endFillTime);
       targetSince = endFillTime;
     }
 
     session.transaction().start(true);
     getDipData(session, startSampleTime, endSampleTime);
     size_t nlumi = getLumiData(session, startSampleTime, endSampleTime);
     edm::LogInfo(m_name) << "Found " << nlumi << " lumisections during the fill " << lhcFill;
     boost::posix_time::ptime flumiStart = cond::time::to_boost(m_tmpBuffer.front().first);
     boost::posix_time::ptime flumiStop = cond::time::to_boost(m_tmpBuffer.back().first);
     edm::LogInfo(m_name) << "First lumi starts at " << flumiStart << " last lumi starts at " << flumiStop;
     getCTTPSData(session, startSampleTime, endSampleTime);
     session.transaction().commit();
     session2.transaction().start(true);
     getEcalData(session2, startSampleTime, endSampleTime, updateEcal);
     session2.transaction().commit();
     //
     size_t niovs = LHCInfoImpl::transferPayloads(m_tmpBuffer, m_iovs, m_prevPayload);
     edm::LogInfo(m_name) << "Added " << niovs << " iovs within the Fill time";
     m_tmpBuffer.clear();
     iovAdded = true;
     if (m_prevPayload->fillNumber() and m_fillPayload->endTime() != 0ULL)
       addEmptyPayload(m_fillPayload->endTime());
   }
 }

bool LHCInfoPopConSourceHandler::getNextFillData	(	cond::persistency::Session &	session,
		const boost::posix_time::ptime &	targetTime,
		bool	ended
	)

private

Definition at line 234 of file LHCInfoPopConSourceHandler.cc.

References m_debug, m_fillPayload, LHCInfoImpl::makeFillDataQuery(), seconds(), and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by getNewObjects().

                                                              {
   // Prepare the WHERE clause
   coral::AttributeList fillDataBindVariables;
   fillDataBindVariables.extend<coral::TimeStamp>(std::string("targetTime"));
   fillDataBindVariables[std::string("targetTime")].data<coral::TimeStamp>() =
       coral::TimeStamp(targetTime + boost::posix_time::seconds(1));
   //by imposing BEGINTIME IS NOT NULL, we remove fills which never went into stable beams,
   //by additionally imposing ENDTIME IS NOT NULL, we select only finished fills
   std::string conditionStr = "BEGINTIME IS NOT NULL AND CREATETIME > :targetTime AND LHCFILL IS NOT NULL";
   if (ended)
     conditionStr += " AND ENDTIME IS NOT NULL";
   return LHCInfoImpl::makeFillDataQuery(session, conditionStr, fillDataBindVariables, m_fillPayload, m_debug);
 }