Inheritance diagram for LHCInfoPerLSPopConSourceHandler:

Public Member Functions
void	getNewObjects () override

std::string	id () const override

	LHCInfoPerLSPopConSourceHandler (edm::ParameterSet const &pset)

	~LHCInfoPerLSPopConSourceHandler () override=default

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

void	addPayloadToBuffer (cond::OMSServiceResultRef &row)

size_t	bufferAllLS (const cond::OMSServiceResult &queryResult)

size_t	bufferFirstStableBeamLS (const cond::OMSServiceResult &queryResult)

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

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

bool	makeFillPayload (std::unique_ptr< LHCInfoPerLS > &targetPayload, const cond::OMSServiceResult &queryResult)

Private Attributes
std::string	m_authpath

std::string	m_connectionString

bool	m_debug

bool	m_endFillMode = true

cond::Time_t	m_endFillTime

cond::Time_t	m_endStableBeamTime

boost::posix_time::ptime	m_endTime

std::unique_ptr< LHCInfoPerLS >	m_fillPayload

bool	m_lastPayloadEmpty = false

std::map< pair< cond::Time_t, unsigned int >, pair< cond::Time_t, unsigned int > >	m_lsIdMap

std::string	m_name

std::string	m_omsBaseUrl

cond::Time_t	m_prevEndFillTime

std::shared_ptr< LHCInfoPerLS >	m_prevPayload

cond::Time_t	m_prevStartFillTime

cond::Time_t	m_startFillTime

cond::Time_t	m_startStableBeamTime

boost::posix_time::ptime	m_startTime

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

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

typedef std::unique_ptr< LHCInfoPerLS >	Ref

typedef PopConSourceHandler< LHCInfoPerLS >	self

typedef cond::Time_t	Time_t

typedef LHCInfoPerLS	value_type

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

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

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

std::string	m_userTextLog

Detailed Description

Definition at line 123 of file LHCInfoPerLSPopConAnalyzer.cc.

Constructor & Destructor Documentation

◆ LHCInfoPerLSPopConSourceHandler()

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

inline

Definition at line 125 of file LHCInfoPerLSPopConAnalyzer.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_endFillMode(pset.getUntrackedParameter<bool>("endFill", true)),
         m_name(pset.getUntrackedParameter<std::string>("name", "LHCInfoPerLSPopConSourceHandler")),
         m_connectionString(pset.getUntrackedParameter<std::string>("connectionString", "")),
         m_authpath(pset.getUntrackedParameter<std::string>("authenticationPath", "")),
         m_omsBaseUrl(pset.getUntrackedParameter<std::string>("omsBaseUrl", "")),
         m_fillPayload(),
         m_prevPayload(),
         m_tmpBuffer() {
     if (!pset.getUntrackedParameter<std::string>("startTime").empty()) {
       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.getUntrackedParameter<std::string>("endTime").empty()) {
       m_endTime = boost::posix_time::time_from_string(pset.getUntrackedParameter<std::string>("endTime"));
       if (m_endTime > now)
         m_endTime = now;
     }
   }

◆ ~LHCInfoPerLSPopConSourceHandler()

LHCInfoPerLSPopConSourceHandler::~LHCInfoPerLSPopConSourceHandler ( )

overridedefault

Member Function Documentation

◆ addEmptyPayload()

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

inlineprivate

Definition at line 339 of file LHCInfoPerLSPopConAnalyzer.cc.

References PVValHelper::add(), popcon::PopConSourceHandler< LHCInfoPerLS >::m_iovs, m_lastPayloadEmpty, m_name, m_prevEndFillTime, m_prevPayload, m_prevStartFillTime, and cond::time::to_boost().

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<LHCInfoPerLS>();
       m_iovs.insert(make_pair(iov, newPayload));
       m_prevPayload = newPayload;
       m_prevEndFillTime = 0;
       m_prevStartFillTime = 0;
       edm::LogInfo(m_name) << "Added empty payload with IOV" << iov << " ( "
                            << boost::posix_time::to_iso_extended_string(cond::time::to_boost(iov)) << " )";
     }
   }

◆ addPayloadToBuffer()

void LHCInfoPerLSPopConSourceHandler::addPayloadToBuffer ( cond::OMSServiceResultRef & row )

inlineprivate

Definition at line 379 of file LHCInfoPerLSPopConAnalyzer.cc.

References cond::time::from_boost(), cond::OMSServiceResultRef::get(), cond::time::lumiTime(), m_endFillMode, m_fillPayload, m_lsIdMap, m_tmpBuffer, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by bufferAllLS(), bufferFirstStableBeamLS(), and getLumiData().

                                                         {
     auto lumiTime = row.get<boost::posix_time::ptime>("start_time");
     LHCInfoPerLS* thisLumiSectionInfo = new LHCInfoPerLS(*m_fillPayload);
     thisLumiSectionInfo->setLumiSection(std::stoul(row.get<std::string>("lumisection_number")));
     thisLumiSectionInfo->setRunNumber(std::stoul(row.get<std::string>("run_number")));
     m_lsIdMap[make_pair(thisLumiSectionInfo->runNumber(), thisLumiSectionInfo->lumiSection())] = make_pair(-1, -1);
     if (m_endFillMode) {
       m_tmpBuffer.emplace_back(make_pair(cond::time::from_boost(lumiTime), thisLumiSectionInfo));
     } else {
       m_tmpBuffer.emplace_back(
           make_pair(cond::time::lumiTime(thisLumiSectionInfo->runNumber(), thisLumiSectionInfo->lumiSection()),
                     thisLumiSectionInfo));
     }
   }

◆ bufferAllLS()

size_t LHCInfoPerLSPopConSourceHandler::bufferAllLS ( const cond::OMSServiceResult & queryResult )

inlineprivate

Definition at line 394 of file LHCInfoPerLSPopConAnalyzer.cc.

References addPayloadToBuffer(), and alignCSCRings::r.

Referenced by getLumiData().

                                                               {
     for (auto r : queryResult) {
       addPayloadToBuffer(r);
     }
     return queryResult.size();
   }

◆ bufferFirstStableBeamLS()

size_t LHCInfoPerLSPopConSourceHandler::bufferFirstStableBeamLS ( const cond::OMSServiceResult & queryResult )

inlineprivate

Definition at line 401 of file LHCInfoPerLSPopConAnalyzer.cc.

References addPayloadToBuffer(), m_name, alignCSCRings::r, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                           {
     for (auto r : queryResult) {
       if (r.get<std::string>("beams_stable") == "true") {
         addPayloadToBuffer(r);
         edm::LogInfo(m_name) << "Buffered first lumisection of stable beam: LS: "
                              << r.get<std::string>("lumisection_number")
                              << " run: " << r.get<std::string>("run_number");
         return 1;
       }
     }
     return 0;
   }

◆ getCTPPSData()

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

inlineprivate

Definition at line 445 of file LHCInfoPerLSPopConAnalyzer.cc.

References cond::persistency::Session::coralSession(), m_debug, m_lsIdMap, m_tmpBuffer, jetsAK4_Puppi_cff::payload, runTheMatrix::ret, convertSQLiteXML::runNumber, 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("LUMI_SECTION"));
     CTPPSDataQuery->addToOutputList(std::string("RUN_NUMBER"));
     CTPPSDataQuery->addToOutputList(std::string("FILL_NUMBER"));
     CTPPSDataQuery->addToOutputList(std::string("XING_ANGLE_P5_X_URAD"));
     CTPPSDataQuery->addToOutputList(std::string("XING_ANGLE_P5_Y_URAD"));
     CTPPSDataQuery->addToOutputList(std::string("BETA_STAR_P5_X_M"));
     CTPPSDataQuery->addToOutputList(std::string("BETA_STAR_P5_Y_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<int>(std::string("LUMI_SECTION"));
     CTPPSDataOutput.extend<int>(std::string("RUN_NUMBER"));
     CTPPSDataOutput.extend<int>(std::string("FILL_NUMBER"));
     CTPPSDataOutput.extend<float>(std::string("XING_ANGLE_P5_X_URAD"));
     CTPPSDataOutput.extend<float>(std::string("XING_ANGLE_P5_Y_URAD"));
     CTPPSDataOutput.extend<float>(std::string("BETA_STAR_P5_X_M"));
     CTPPSDataOutput.extend<float>(std::string("BETA_STAR_P5_Y_M"));
     CTPPSDataQuery->defineOutput(CTPPSDataOutput);
     //execute the query
     coral::ICursor& CTPPSDataCursor = CTPPSDataQuery->execute();
     unsigned int lumiSection = 0;
     cond::Time_t runNumber = 0;
     int fillNumber = 0;
     float crossingAngleX = 0., betaStarX = 0.;
     float crossingAngleY = 0., betaStarY = 0.;
 
     bool ret = false;
     int wrongFillNumbers = 0;
     std::stringstream wrongFills;
     std::vector<pair<cond::Time_t, std::shared_ptr<LHCInfoPerLS>>>::iterator current = m_tmpBuffer.begin();
     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()) {
         ret = true;
         coral::Attribute const& lumiSectionAttribute = CTPPSDataCursor.currentRow()[std::string("LUMI_SECTION")];
         if (!lumiSectionAttribute.isNull()) {
           lumiSection = lumiSectionAttribute.data<int>();
         }
         coral::Attribute const& runNumberAttribute = CTPPSDataCursor.currentRow()[std::string("RUN_NUMBER")];
         if (!runNumberAttribute.isNull()) {
           runNumber = runNumberAttribute.data<int>();
         }
         coral::Attribute const& fillNumberAttribute = CTPPSDataCursor.currentRow()[std::string("FILL_NUMBER")];
         if (!fillNumberAttribute.isNull()) {
           fillNumber = fillNumberAttribute.data<int>();
         }
         coral::Attribute const& crossingAngleXAttribute =
             CTPPSDataCursor.currentRow()[std::string("XING_ANGLE_P5_X_URAD")];
         if (!crossingAngleXAttribute.isNull()) {
           crossingAngleX = crossingAngleXAttribute.data<float>();
         }
         coral::Attribute const& crossingAngleYAttribute =
             CTPPSDataCursor.currentRow()[std::string("XING_ANGLE_P5_Y_URAD")];
         if (!crossingAngleYAttribute.isNull()) {
           crossingAngleY = crossingAngleYAttribute.data<float>();
         }
         coral::Attribute const& betaStarXAttribute = CTPPSDataCursor.currentRow()[std::string("BETA_STAR_P5_X_M")];
         if (!betaStarXAttribute.isNull()) {
           betaStarX = betaStarXAttribute.data<float>();
         }
         coral::Attribute const& betaStarYAttribute = CTPPSDataCursor.currentRow()[std::string("BETA_STAR_P5_Y_M")];
         if (!betaStarYAttribute.isNull()) {
           betaStarY = betaStarYAttribute.data<float>();
         }
         if (current != m_tmpBuffer.end() && current->second->fillNumber() != fillNumber) {
           wrongFills << "( " << runNumber << "_" << lumiSection << " fill: OMS: " << current->second->fillNumber()
                      << " PPSdb: " << fillNumber << " ) ";
           wrongFillNumbers++;
         }
         for (;
              current != m_tmpBuffer.end() && make_pair(current->second->runNumber(), current->second->lumiSection()) <=
                                                  make_pair(runNumber, lumiSection);
              current++) {
           LHCInfoPerLS& payload = *(current->second);
           payload.setCrossingAngleX(crossingAngleX);
           payload.setCrossingAngleY(crossingAngleY);
           payload.setBetaStarX(betaStarX);
           payload.setBetaStarY(betaStarY);
           payload.setLumiSection(lumiSection);
           payload.setRunNumber(runNumber);
           if (m_lsIdMap.find(make_pair(payload.runNumber(), payload.lumiSection())) != m_lsIdMap.end()) {
             m_lsIdMap[make_pair(payload.runNumber(), payload.lumiSection())] = make_pair(runNumber, lumiSection);
           }
         }
       }
     }
     if (wrongFillNumbers) {
       edm::LogWarning("getCTPPSData") << "Number of records from PPS DB with fillNumber different from OMS: "
                                       << wrongFillNumbers;
       edm::LogWarning("getCTPPSData") << "Records from PPS DB with fillNumber different from OMS: " << wrongFills.str();
     }
     return ret;
   }

◆ getLumiData()

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

inlineprivate

Definition at line 414 of file LHCInfoPerLSPopConAnalyzer.cc.

References addPayloadToBuffer(), bufferAllLS(), kLumisectionsQueryLimit, m_endFillMode, m_name, cond::OMSService::query(), and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by getNewObjects().

                                                               {
     auto query = oms.query("lumisections");
     query->addOutputVars({"start_time", "run_number", "beams_stable", "lumisection_number"});
     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 queryResult = query->result();
       if (m_endFillMode) {
         nlumi = bufferAllLS(queryResult);
       } else if (!queryResult.empty()) {
         auto newestPayload = queryResult.back();
         if (newestPayload.get<std::string>("beams_stable") == "true") {
           addPayloadToBuffer(newestPayload);
           nlumi = 1;
           edm::LogInfo(m_name) << "Buffered most recent lumisection:"
                                << " LS: " << newestPayload.get<std::string>("lumisection_number")
                                << " run: " << newestPayload.get<std::string>("run_number");
         }
       }
       edm::LogInfo(m_name) << "Found " << queryResult.size() << " lumisections during the fill " << fillId;
     } else {
       edm::LogInfo(m_name) << "OMS query for lumisections of fill " << fillId << "failed, status:" << query->status();
     }
     return nlumi;
   }

◆ getNewObjects()

void LHCInfoPerLSPopConSourceHandler::getNewObjects ( )

inlineoverridevirtual

Implements popcon::PopConSourceHandler< LHCInfoPerLS >.

Definition at line 151 of file LHCInfoPerLSPopConAnalyzer.cc.

                                 {
     //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
       if (m_endFillMode) {
         addEmptyPayload(1);
         lastSince = 1;
       } else {
         addEmptyPayload(cond::time::lumiTime(1, 1));
         lastSince = cond::time::lumiTime(1, 1);
       }
     } else {
       edm::LogInfo(m_name) << "The last Iov in tag " << tagInfo().name << " valid since " << lastSince << "from "
                            << m_name << "::getNewObjects";
     }
 
     //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);
     // fetch last payload when available
     if (!tagInfo().lastInterval.payloadId.empty()) {
       cond::persistency::Session session3 = dbSession();
       session3.transaction().start(true);
       m_prevPayload = session3.fetchPayload<LHCInfoPerLS>(tagInfo().lastInterval.payloadId);
       session3.transaction().commit();
 
       // find startFillTime and endFillTime of the most recent fill already saved in the tag
       if (m_prevPayload->fillNumber() != 0) {
         cond::OMSService oms;
         oms.connect(m_omsBaseUrl);
         auto query = oms.query("fills");
         query->addOutputVar("end_time");
         query->addOutputVar("start_time");
         query->filterEQ("fill_number", m_prevPayload->fillNumber());
         bool foundFill = query->execute();
         if (foundFill) {
           auto result = query->result();
 
           if (!result.empty()) {
             std::string endTimeStr = (*result.begin()).get<std::string>("end_time");
             m_prevEndFillTime =
                 (endTimeStr == "null")
                     ? 0
                     : cond::time::from_boost((*result.begin()).get<boost::posix_time::ptime>("end_time"));
             auto startFillTime = (*result.begin()).get<boost::posix_time::ptime>("start_time");
             m_prevStartFillTime = cond::time::from_boost(startFillTime);
           } else {
             foundFill = false;
           }
         }
         if (!foundFill) {
           edm::LogError(m_name) << "Could not find end time of fill #" << m_prevPayload->fillNumber();
         }
       } else {
         m_prevEndFillTime = 0;
         m_prevStartFillTime = 0;
       }
     }
 
     boost::posix_time::ptime executionTime = boost::posix_time::second_clock::local_time();
     cond::Time_t executionTimeIov = cond::time::from_boost(executionTime);
 
     cond::Time_t startTimestamp = m_startTime.is_not_a_date_time() ? 0 : cond::time::from_boost(m_startTime);
     cond::Time_t nextFillSearchTimestamp = std::max(startTimestamp, m_endFillMode ? lastSince : m_prevEndFillTime);
 
     edm::LogInfo(m_name) << "Starting sampling at "
                          << boost::posix_time::to_simple_string(cond::time::to_boost(nextFillSearchTimestamp));
 
     while (true) {
       if (nextFillSearchTimestamp >= executionTimeIov) {
         edm::LogInfo(m_name) << "Sampling ended at the time "
                              << boost::posix_time::to_simple_string(cond::time::to_boost(executionTimeIov));
         break;
       }
       boost::posix_time::ptime nextFillSearchTime = cond::time::to_boost(nextFillSearchTimestamp);
       boost::posix_time::ptime startSampleTime;
       boost::posix_time::ptime endSampleTime;
 
       cond::OMSService oms;
       oms.connect(m_omsBaseUrl);
       auto query = oms.query("fills");
 
       if (!m_endFillMode and m_prevPayload->fillNumber() and m_prevEndFillTime == 0ULL) {
         // continue processing unfinished fill with some payloads already in the tag
         edm::LogInfo(m_name) << "Searching started fill #" << m_prevPayload->fillNumber();
         query->filterEQ("fill_number", m_prevPayload->fillNumber());
         bool foundFill = query->execute();
         if (foundFill)
           foundFill = makeFillPayload(m_fillPayload, query->result());
         if (!foundFill) {
           edm::LogError(m_name) << "Could not find fill #" << m_prevPayload->fillNumber();
           break;
         }
         startSampleTime = cond::time::to_boost(lastSince);
       } else {
         edm::LogInfo(m_name) << "Searching new fill after " << boost::posix_time::to_simple_string(nextFillSearchTime);
         query->filterNotNull("start_stable_beam").filterNotNull("fill_number");
         if (nextFillSearchTime > cond::time::to_boost(m_prevStartFillTime)) {
           query->filterGE("start_time", nextFillSearchTime);
         } else {
           query->filterGT("start_time", nextFillSearchTime);
         }
 
         query->filterLT("start_time", m_endTime);
         if (m_endFillMode)
           query->filterNotNull("end_time");
         bool foundFill = query->execute();
         if (foundFill)
           foundFill = makeFillPayload(m_fillPayload, query->result());
         if (!foundFill) {
           edm::LogInfo(m_name) << "No fill found - END of job.";
           break;
         }
         startSampleTime = cond::time::to_boost(m_startFillTime);
       }
 
       unsigned short lhcFill = m_fillPayload->fillNumber();
       bool ongoingFill = m_endFillTime == 0ULL;
       if (ongoingFill) {
         edm::LogInfo(m_name) << "Found ongoing fill " << lhcFill << " created at "
                              << cond::time::to_boost(m_startFillTime);
         endSampleTime = executionTime;
         nextFillSearchTimestamp = executionTimeIov;
       } else {
         edm::LogInfo(m_name) << "Found fill " << lhcFill << " created at " << cond::time::to_boost(m_startFillTime)
                              << " ending at " << cond::time::to_boost(m_endFillTime);
         endSampleTime = cond::time::to_boost(m_endFillTime);
         nextFillSearchTimestamp = m_endFillTime;
       }
 
       if (m_endFillMode || ongoingFill) {
         getLumiData(oms, lhcFill, startSampleTime, endSampleTime);
 
         if (!m_tmpBuffer.empty()) {
           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 buffered lumi starts at " << flumiStart << " last lumi starts at "
                                << flumiStop;
           session.transaction().start(true);
           getCTPPSData(session, startSampleTime, endSampleTime);
           session.transaction().commit();
         }
       }
 
       size_t niovs = theLHCInfoPerLSImpl::transferPayloads(
           m_tmpBuffer, m_iovs, m_prevPayload, m_lsIdMap, m_startStableBeamTime, m_endStableBeamTime);
       edm::LogInfo(m_name) << "Added " << niovs << " iovs within the Fill time";
       if (niovs) {
         m_prevEndFillTime = m_endFillTime;
         m_prevStartFillTime = m_startFillTime;
       }
       m_tmpBuffer.clear();
       m_lsIdMap.clear();
       if (m_prevPayload->fillNumber() and !ongoingFill) {
         if (m_endFillMode) {
           addEmptyPayload(m_endFillTime);
         } else {
           addEmptyPayload(cond::lhcInfoHelper::getFillLastLumiIOV(oms, lhcFill));
         }
       }
     }
   }

◆ id()

std::string LHCInfoPerLSPopConSourceHandler::id ( ) const

inlineoverridevirtual

Implements popcon::PopConSourceHandler< LHCInfoPerLS >.

Definition at line 334 of file LHCInfoPerLSPopConAnalyzer.cc.

References m_name.

334 { return m_name; }

LHCInfoPerLSPopConSourceHandler::m_name

std::string m_name

Definition: LHCInfoPerLSPopConAnalyzer.cc:571

◆ makeFillPayload()

bool LHCInfoPerLSPopConSourceHandler::makeFillPayload	(	std::unique_ptr< LHCInfoPerLS > &	targetPayload,
		const cond::OMSServiceResult &	queryResult
	)

inlineprivate

Definition at line 361 of file LHCInfoPerLSPopConAnalyzer.cc.

References cond::OMSServiceResult::begin(), cond::OMSServiceResult::empty(), cond::time::from_boost(), m_endFillTime, m_endStableBeamTime, m_startFillTime, m_startStableBeamTime, runTheMatrix::ret, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by getNewObjects().

                                                                                                             {
     bool ret = false;
     if (!queryResult.empty()) {
       auto row = *queryResult.begin();
       auto currentFill = row.get<unsigned short>("fill_number");
       m_startFillTime = cond::time::from_boost(row.get<boost::posix_time::ptime>("start_time"));
       std::string endTimeStr = row.get<std::string>("end_time");
       m_endFillTime =
           (endTimeStr == "null") ? 0 : cond::time::from_boost(row.get<boost::posix_time::ptime>("end_time"));
       m_startStableBeamTime = cond::time::from_boost(row.get<boost::posix_time::ptime>("start_stable_beam"));
       m_endStableBeamTime = cond::time::from_boost(row.get<boost::posix_time::ptime>("end_stable_beam"));
       targetPayload = std::make_unique<LHCInfoPerLS>();
       targetPayload->setFillNumber(currentFill);
       ret = true;
     }
     return ret;
   }