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, cmsPerfSuiteHarvest::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 48 of file LHCInfoPopConSourceHandler.cc.

{}

Member Function Documentation

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

private

Definition at line 754 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 520 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(), 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 384 of file LHCInfoPopConSourceHandler.cc.

References LHCInfo::availableBunchSlots, cond::persistency::Session::coralSession(), cond::time::from_boost(), m_debug, m_dipSchema, m_fillPayload, or, 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 651 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(), 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 243 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 253 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(), ntuplemaker::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 816 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, dataset::name, cond::TagInfo_t::name, dataDML::session, 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 229 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 943 of file LHCInfoPopConSourceHandler.cc.

References m_name.

                                               { 
  return m_name;
}

Member Data Documentation

std::string LHCInfoPopConSourceHandler::m_authpath

private

Definition at line 36 of file LHCInfoPopConSourceHandler.h.

Referenced by getNewObjects().

std::string LHCInfoPopConSourceHandler::m_connectionString

private

Definition at line 35 of file LHCInfoPopConSourceHandler.h.

Referenced by getNewObjects().

bool LHCInfoPopConSourceHandler::m_debug

private

Definition at line 26 of file LHCInfoPopConSourceHandler.h.

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

std::string LHCInfoPopConSourceHandler::m_dipSchema

private

Definition at line 36 of file LHCInfoPopConSourceHandler.h.

Referenced by getDipData().

std::string LHCInfoPopConSourceHandler::m_ecalConnectionString

private

Definition at line 35 of file LHCInfoPopConSourceHandler.h.

Referenced by getNewObjects().

bool LHCInfoPopConSourceHandler::m_endFill = true

private

Definition at line 32 of file LHCInfoPopConSourceHandler.h.

Referenced by getNewObjects().

boost::posix_time::ptime LHCInfoPopConSourceHandler::m_endTime

private

Definition at line 29 of file LHCInfoPopConSourceHandler.h.

Referenced by LHCInfoPopConSourceHandler().

std::unique_ptr<LHCInfo> LHCInfoPopConSourceHandler::m_fillPayload

private

Definition at line 37 of file LHCInfoPopConSourceHandler.h.

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

bool LHCInfoPopConSourceHandler::m_lastPayloadEmpty = false

private

Definition at line 41 of file LHCInfoPopConSourceHandler.h.

Referenced by addEmptyPayload().

std::string LHCInfoPopConSourceHandler::m_name

private

Definition at line 33 of file LHCInfoPopConSourceHandler.h.

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

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

private

Definition at line 40 of file LHCInfoPopConSourceHandler.h.

Referenced by addEmptyPayload(), and getNewObjects().

std::shared_ptr<LHCInfo> LHCInfoPopConSourceHandler::m_prevPayload

private

Definition at line 38 of file LHCInfoPopConSourceHandler.h.

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

unsigned int LHCInfoPopConSourceHandler::m_samplingInterval

private

Definition at line 31 of file LHCInfoPopConSourceHandler.h.

boost::posix_time::ptime LHCInfoPopConSourceHandler::m_startTime

private

Definition at line 28 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 39 of file LHCInfoPopConSourceHandler.h.

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