#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 ()

Static Public Attributes
static constexpr unsigned int	kLumisectionsQueryLimit = 4000

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)

void	getDipData (const cond::OMSService &service, 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)

size_t	getLumiData (const cond::OMSService &service, unsigned short fillId, const boost::posix_time::ptime &beginFillTime, const boost::posix_time::ptime &endFillTime)

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::string	m_omsBaseUrl

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 14 of file LHCInfoPopConSourceHandler.h.

Constructor & Destructor Documentation

◆ LHCInfoPopConSourceHandler()

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

Definition at line 64 of file LHCInfoPopConSourceHandler.cc.

References m_endTime, m_startTime, submitPVValidationJobs::now, muonDTDigis_cfi::pset, 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_omsBaseUrl(pset.getUntrackedParameter<std::string>("omsBaseUrl", "")),
       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::~LHCInfoPopConSourceHandler ( )

override

Definition at line 92 of file LHCInfoPopConSourceHandler.cc.

92 {}

Member Function Documentation

◆ addEmptyPayload()

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

private

Definition at line 535 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;
   }
 }

◆ getCTTPSData()

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

private

Definition at line 299 of file LHCInfoPopConSourceHandler.cc.

References cond::persistency::Session::coralSession(), ALCARECOTkAlBeamHalo_cff::filter, cond::time::from_boost(), m_debug, m_tmpBuffer, jetsAK4_Puppi_cff::payload, runTheMatrix::ret, 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_PPS_SPECT_COND");
   //execute query for CTPPS Data
   std::unique_ptr<coral::IQuery> CTPPSDataQuery(CTPPS.newQuery());
   //FROM clause
   CTPPSDataQuery->addToTableList(std::string("PPS_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("LUMI_SECTION"));
   CTPPSDataQuery->addToOutputList(std::string("XING_ANGLE_P5_X_URAD"));
   CTPPSDataQuery->addToOutputList(std::string("BETA_STAR_P5_X_M"));
   //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<int>(std::string("LUMI_SECTION"));
   CTPPSDataOutput.extend<float>(std::string("XING_ANGLE_P5_X_URAD"));
   CTPPSDataOutput.extend<float>(std::string("BETA_STAR_P5_X_M"));
   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& lumiSectionAttribute = CTPPSDataCursor.currentRow()[std::string("LUMI_SECTION")];
         if (!lumiSectionAttribute.isNull()) {
           lumiSection = lumiSectionAttribute.data<int>();
         }
         coral::Attribute const& crossingAngleXAttribute =
             CTPPSDataCursor.currentRow()[std::string("XING_ANGLE_P5_X_URAD")];
         if (!crossingAngleXAttribute.isNull()) {
           crossingAngle = crossingAngleXAttribute.data<float>();
         }
         coral::Attribute const& betaStarXAttribute = CTPPSDataCursor.currentRow()[std::string("BETA_STAR_P5_X_M")];
         if (!betaStarXAttribute.isNull()) {
           betastar = betaStarXAttribute.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;
 }

◆ getDipData()

void LHCInfoPopConSourceHandler::getDipData	(	const cond::OMSService &	service,
		const boost::posix_time::ptime &	beginFillTime,
		const boost::posix_time::ptime &	endFillTime
	)

private

Definition at line 237 of file LHCInfoPopConSourceHandler.cc.

References m_fillPayload, and cond::OMSService::query().

Referenced by getNewObjects().

                                                                                      {
   // unsure how to handle this.
   // the old implementation is not helping: apparently it is checking only the bunchconfiguration for the first diptime set of values...
   auto query1 = oms.query("diplogger/dip/acc/LHC/RunControl/CirculatingBunchConfig/Beam1");
   query1->filterGT("dip_time", beginFillTime).filterLT("dip_time", endFillTime);
   //This query is limited to 100 rows, but currently only one is used
   //If all this data is needed and saved properly the limit has to be set: query1->limit(...)
   if (query1->execute()) {
     auto res = query1->result();
     if (!res.empty()) {
       std::bitset<LHCInfo::bunchSlots + 1> bunchConfiguration1(0ULL);
       auto row = *res.begin();
       auto vbunchConf1 = row.getArray<unsigned short>("value");
       for (auto vb : vbunchConf1) {
         if (vb != 0) {
           unsigned short slot = (vb - 1) / 10 + 1;
           bunchConfiguration1[slot] = true;
         }
       }
       m_fillPayload->setBunchBitsetForBeam1(bunchConfiguration1);
     }
   }
   auto query2 = oms.query("diplogger/dip/acc/LHC/RunControl/CirculatingBunchConfig/Beam2");
   query2->filterGT("dip_time", beginFillTime).filterLT("dip_time", endFillTime);
   //This query is limited to 100 rows, but currently only one is used
   if (query2->execute()) {
     auto res = query2->result();
     if (!res.empty()) {
       std::bitset<LHCInfo::bunchSlots + 1> bunchConfiguration2(0ULL);
       auto row = *res.begin();
       auto vbunchConf2 = row.getArray<unsigned short>("value");
       for (auto vb : vbunchConf2) {
         if (vb != 0) {
           unsigned short slot = (vb - 1) / 10 + 1;
           bunchConfiguration2[slot] = true;
         }
       }
       m_fillPayload->setBunchBitsetForBeam2(bunchConfiguration2);
     }
   }
 
   auto query3 = oms.query("diplogger/dip/CMS/LHC/LumiPerBunch");
   query3->filterGT("dip_time", beginFillTime).filterLT("dip_time", endFillTime);
   //This query is limited to 100 rows, but currently only one is used
   if (query3->execute()) {
     auto res = query3->result();
     if (!res.empty()) {
       std::vector<float> lumiPerBX;
       auto row = *res.begin();
       auto lumiBunchInst = row.getArray<float>("lumi_bunch_inst");
       for (auto lb : lumiBunchInst) {
         if (lb != 0.) {
           lumiPerBX.push_back(lb);
         }
       }
       m_fillPayload->setLumiPerBX(lumiPerBX);
     }
   }
 }

◆ getEcalData()

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 429 of file LHCInfoPopConSourceHandler.cc.

References ECAL, ALCARECOTkAlBeamHalo_cff::filter, cond::time::from_boost(), CommonMethods::isnan(), m_debug, m_name, m_prevPayload, m_tmpBuffer, cond::persistency::Session::nominalSchema(), jetsAK4_Puppi_cff::payload, runTheMatrix::ret, LHCInfoImpl::setElementData(), AlCaHLTBitMon_QueryRunRegistry::string, protons_cff::time, cond::time::to_boost(), and update.

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 (std::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;
 }

◆ getLumiData()

size_t LHCInfoPopConSourceHandler::getLumiData	(	const cond::OMSService &	service,
		unsigned short	fillId,
		const boost::posix_time::ptime &	beginFillTime,
		const boost::posix_time::ptime &	endFillTime
	)

private

Definition at line 153 of file LHCInfoPopConSourceHandler.cc.

References cond::time::from_boost(), kLumisectionsQueryLimit, cond::time::lumiTime(), m_fillPayload, m_tmpBuffer, jetsAK4_Puppi_cff::payload, cond::OMSService::query(), and alignCSCRings::r.

Referenced by getNewObjects().

                                                                                         {
   auto query = oms.query("lumisections");
   query->addOutputVars({"start_time", "delivered_lumi", "recorded_lumi"});
   query->filterEQ("fill_number", fillId);
   query->filterGT("start_time", beginFillTime).filterLT("start_time", endFillTime);
   query->limit(kLumisectionsQueryLimit);
   size_t nlumi = 0;
   if (query->execute()) {
     auto res = query->result();
     for (auto r : res) {
       nlumi++;
       auto lumiTime = r.get<boost::posix_time::ptime>("start_time");
       auto delivLumi = r.get<float>("delivered_lumi");
       auto recLumi = r.get<float>("recorded_lumi");
       LHCInfo* thisLumiSectionInfo = m_fillPayload->cloneFill();
       m_tmpBuffer.emplace_back(std::make_pair(cond::time::from_boost(lumiTime), thisLumiSectionInfo));
       LHCInfo& payload = *thisLumiSectionInfo;
       payload.setDelivLumi(delivLumi);
       payload.setRecLumi(recLumi);
     }
   }
   return nlumi;
 }

◆ getNewObjects()

void LHCInfoPopConSourceHandler::getNewObjects ( )

overridevirtual

Implements popcon::PopConSourceHandler< LHCInfo >.

Definition at line 605 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().size == 0) {
     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 (tagInfo().isEmpty()) {
     // for a new or empty tag, an empty payload should be added on top with since=1
     addEmptyPayload(1);
     lastSince = 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;
 
     cond::OMSService oms;
     oms.connect(m_omsBaseUrl);
     auto query = oms.query("fills");
 
     if (!m_endFill and m_prevPayload->fillNumber() and m_prevPayload->endTime() == 0ULL) {
       // execute the query for the current fill
       edm::LogInfo(m_name) << "Searching started fill #" << m_prevPayload->fillNumber();
       query->filterEQ("fill_number", m_prevPayload->fillNumber());
       bool foundFill = query->execute();
       if (foundFill)
         foundFill = LHCInfoImpl::makeFillPayload(m_fillPayload, query->result());
       if (!foundFill) {
         edm::LogError(m_name) << "Could not find fill #" << m_prevPayload->fillNumber();
         break;
       }
       updateEcal = true;
       startSampleTime = cond::time::to_boost(lastSince);
     } else {
       edm::LogInfo(m_name) << "Searching new fill after " << boost::posix_time::to_simple_string(targetTime);
       query->filterNotNull("start_stable_beam").filterNotNull("fill_number");
       if (targetTime > cond::time::to_boost(m_prevPayload->createTime())) {
         query->filterGE("start_time", targetTime);
       } else {
         query->filterGT("start_time", targetTime);
       }
 
       query->filterLT("start_time", m_endTime);
       if (m_endFill)
         query->filterNotNull("end_time");
       bool foundFill = query->execute();
       if (foundFill)
         foundFill = LHCInfoImpl::makeFillPayload(m_fillPayload, query->result());
       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;
     }
 
     getDipData(oms, startSampleTime, endSampleTime);
     size_t nlumi = getLumiData(oms, lhcFill, 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;
     session.transaction().start(true);
     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());
   }
 }