LHCInfoPopConSourceHandler Class Reference

#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	convertFromOld ()
Summary *	dummySummary (typename OldContainer::value_type const &) const
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 ()
void	sort ()
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::vector< std::shared_ptr< LHCInfo > >	m_payloadBuffer
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::vector< Triplet >	Container
typedef std::vector< std::pair< LHCInfo *, cond::Time_t > >	OldContainer
typedef PopConSourceHandler< LHCInfo >	self
typedef cond::Summary	Summary
typedef cond::Time_t	Time_t
typedef LHCInfo	value_type
Protected Member Functions inherited from popcon::PopConSourceHandler< LHCInfo >
int	add (value_type *payload, Summary *summary, Time_t time)
cond::persistency::Session &	dbSession () const
Protected Attributes inherited from popcon::PopConSourceHandler< LHCInfo >
OldContainer	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, fileCollector::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(),
      m_payloadBuffer() {
  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 49 of file LHCInfoPopConSourceHandler.cc.

{}

Member Function Documentation

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

private

Definition at line 774 of file LHCInfoPopConSourceHandler.cc.

References popcon::PopConSourceHandler< LHCInfo >::add(), LHCInfo::fillNumber(), m_lastPayloadEmpty, m_payloadBuffer, m_prevPayload, and popcon::PopConSourceHandler< LHCInfo >::m_to_transfer.

Referenced by getNewObjects().

                                                               {
  bool add = false;
  if (m_to_transfer.empty()) {
    if (!m_lastPayloadEmpty)
      add = true;
  } else {
    LHCInfo* lastAdded = m_to_transfer.back().first;
    if (lastAdded->fillNumber() != 0) {
      add = true;
    }
  }
  if (add) {
    auto newPayload = std::make_shared<LHCInfo>();
    m_to_transfer.push_back(std::make_pair(newPayload.get(), iov));
    m_payloadBuffer.push_back(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 533 of file LHCInfoPopConSourceHandler.cc.

References cond::persistency::Session::coralSession(), LHCInfoImpl::LumiSectionFilter::current(), ALCARECOTkAlBeamHalo_cff::filter, cond::time::from_boost(), m_debug, m_tmpBuffer, jets_cff::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 390 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 668 of file LHCInfoPopConSourceHandler.cc.

References LHCInfoImpl::LumiSectionFilter::current(), ECAL, ALCARECOTkAlBeamHalo_cff::filter, cond::time::from_boost(), edm::detail::isnan(), m_debug, m_name, m_prevPayload, m_tmpBuffer, cond::persistency::Session::nominalSchema(), jets_cff::payload, LHCInfoImpl::LumiSectionFilter::process(), runTheMatrix::ret, LHCInfoImpl::setElementData(), AlCaHLTBitMon_QueryRunRegistry::string, ntuplemaker::time, and cond::time::to_boost().

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

References cond::time::from_boost(), muonGEMDigis_cfi::instLumi, m_fillPayload, m_tmpBuffer, cond::persistency::Session::nominalSchema(), jets_cff::payload, LHCInfo::setDelivLumi(), LHCInfo::setInstLumi(), LHCInfo::setInstLumiError(), LHCInfo::setRecLumi(), writeEcalDQMStatus::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 847 of file LHCInfoPopConSourceHandler.cc.

References addEmptyPayload(), cond::persistency::Transaction::commit(), cond::persistency::ConnectionPool::configure(), cond::persistency::ConnectionPool::createSession(), popcon::PopConSourceHandler< LHCInfo >::dbSession(), Debug, cond::persistency::Session::fetchPayload(), cond::time::from_boost(), getCTTPSData(), getDipData(), getEcalData(), getFillData(), getLumiData(), getNextFillData(), cond::TagInfo_t::lastInterval, cond::TagInfo_t::lastPayloadToken, m_authpath, m_connectionString, m_debug, m_ecalConnectionString, m_endFill, m_fillPayload, m_name, m_payloadBuffer, m_prevPayload, m_startTime, m_tmpBuffer, popcon::PopConSourceHandler< LHCInfo >::m_to_transfer, Skims_PA_cff::name, cond::TagInfo_t::name, cond::persistency::ConnectionPool::setAuthenticationPath(), cond::persistency::ConnectionPool::setMessageVerbosity(), cond::TagInfo_t::size, cond::persistency::Transaction::start(), popcon::PopConSourceHandler< LHCInfo >::tagInfo(), cond::time::to_boost(), cond::TagInfo_t::token, cond::persistency::Session::transaction(), and LHCInfoImpl::transferPayloads().

                                               {
  //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 << ", IOVSequence token " << tagInfo().token
                         << ": size " << tagInfo().size << ", last object valid since " << tagInfo().lastInterval.first
                         << " ( "
                         << boost::posix_time::to_iso_extended_string(
                                cond::time::to_boost(tagInfo().lastInterval.first))
                         << " ); from " << m_name << "::getNewObjects";
  }

  cond::Time_t lastSince = tagInfo().lastInterval.first;
  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().lastPayloadToken.empty()) {
    cond::persistency::Session session3 = dbSession();
    session3.transaction().start(true);
    m_prevPayload = session3.fetchPayload<LHCInfo>(tagInfo().lastPayloadToken);
    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_payloadBuffer, m_to_transfer, m_prevPayload);
    edm::LogInfo(m_name) << "Added " << niovs << " iovs within the Fill time";
    m_tmpBuffer.clear();
    iovAdded = true;
    //if(m_prevPayload->fillNumber() and m_prevPayload->endTime()!=0ULL) addEmptyPayload( m_fillPayload->endTime() );
    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 235 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);
}

std::string LHCInfoPopConSourceHandler::id ( ) const

overridevirtual

Implements popcon::PopConSourceHandler< LHCInfo >.

Definition at line 979 of file LHCInfoPopConSourceHandler.cc.

References m_name.

{ return m_name; }

Member Data Documentation

std::string LHCInfoPopConSourceHandler::m_authpath

private

Definition at line 46 of file LHCInfoPopConSourceHandler.h.

Referenced by getNewObjects().

std::string LHCInfoPopConSourceHandler::m_connectionString

private

Definition at line 45 of file LHCInfoPopConSourceHandler.h.

Referenced by getNewObjects().

bool LHCInfoPopConSourceHandler::m_debug

private

Definition at line 36 of file LHCInfoPopConSourceHandler.h.

Referenced by getCTTPSData(), getDipData(), getEcalData(), getFillData(), getNewObjects(), and getNextFillData().

std::string LHCInfoPopConSourceHandler::m_dipSchema

private

Definition at line 46 of file LHCInfoPopConSourceHandler.h.

Referenced by getDipData().

std::string LHCInfoPopConSourceHandler::m_ecalConnectionString

private

Definition at line 45 of file LHCInfoPopConSourceHandler.h.

Referenced by getNewObjects().

bool LHCInfoPopConSourceHandler::m_endFill = true

private

Definition at line 42 of file LHCInfoPopConSourceHandler.h.

Referenced by getNewObjects().

boost::posix_time::ptime LHCInfoPopConSourceHandler::m_endTime

private

Definition at line 39 of file LHCInfoPopConSourceHandler.h.

Referenced by LHCInfoPopConSourceHandler().

std::unique_ptr<LHCInfo> LHCInfoPopConSourceHandler::m_fillPayload

private

Definition at line 47 of file LHCInfoPopConSourceHandler.h.

Referenced by getDipData(), getFillData(), getLumiData(), getNewObjects(), and getNextFillData().

bool LHCInfoPopConSourceHandler::m_lastPayloadEmpty = false

private

Definition at line 51 of file LHCInfoPopConSourceHandler.h.

Referenced by addEmptyPayload().

std::string LHCInfoPopConSourceHandler::m_name

private

Definition at line 43 of file LHCInfoPopConSourceHandler.h.

Referenced by getEcalData(), getNewObjects(), and id().

std::vector<std::shared_ptr<LHCInfo> > LHCInfoPopConSourceHandler::m_payloadBuffer

private

Definition at line 50 of file LHCInfoPopConSourceHandler.h.

Referenced by addEmptyPayload(), and getNewObjects().

std::shared_ptr<LHCInfo> LHCInfoPopConSourceHandler::m_prevPayload

private

Definition at line 48 of file LHCInfoPopConSourceHandler.h.

Referenced by addEmptyPayload(), getEcalData(), and getNewObjects().

unsigned int LHCInfoPopConSourceHandler::m_samplingInterval

private

Definition at line 41 of file LHCInfoPopConSourceHandler.h.

boost::posix_time::ptime LHCInfoPopConSourceHandler::m_startTime

private

Definition at line 38 of file LHCInfoPopConSourceHandler.h.

Referenced by getNewObjects(), and LHCInfoPopConSourceHandler().

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

private

Definition at line 49 of file LHCInfoPopConSourceHandler.h.

Referenced by getCTTPSData(), getEcalData(), getLumiData(), and getNewObjects().