LHCInfoImpl Namespace Reference

Classes
struct	IOVComp
struct	LumiSectionFilter

Functions
template<typename T >
T &	accessParams (std::vector< T > &params, size_t index)
bool	comparePayloads (const LHCInfo &rhs, const LHCInfo &lhs)
template<typename T >
const T &	getOneParam (const std::vector< std::vector< T > > &params, size_t index)
template<typename T >
const T &	getParams (const std::vector< T > &params, size_t index)
bool	makeFillDataQuery (cond::persistency::Session &session, const std::string &conditionString, const coral::AttributeList &fillDataBindVariables, std::unique_ptr< LHCInfo > &targetPayload, bool debug)
std::vector< std::pair< cond::Time_t, std::shared_ptr< LHCInfo > > >::const_iterator	search (const cond::Time_t &val, const std::vector< std::pair< cond::Time_t, std::shared_ptr< LHCInfo > >> &container)
void	setElementData (cond::Time_t since, const std::string &dipVal, unsigned int elementNr, float value, LHCInfo &payload, std::set< cond::Time_t > &initList)
template<typename T >
void	setOneParam (std::vector< std::vector< T > > &params, size_t index, const T &value)
template<typename T >
void	setParams (std::vector< T > &params, size_t index, const T &value)
size_t	transferPayloads (const std::vector< std::pair< cond::Time_t, std::shared_ptr< LHCInfo > > > &buffer, std::vector< std::shared_ptr< LHCInfo > > &payloadBuffer, std::vector< std::pair< LHCInfo *, cond::Time_t > > &vecToTransfer, std::shared_ptr< LHCInfo > &prevPayload)

Variables
static const std::map< std::string, int >	vecMap = {{"Beam1/beamPhaseMean",1},{"Beam2/beamPhaseMean",2},{"Beam1/cavPhaseMean",3},{"Beam2/cavPhaseMean",4}}

Function Documentation

template<typename T >

T& LHCInfoImpl::accessParams	(	std::vector< T > &	params,
		size_t	index
	)

Definition at line 119 of file LHCInfo.cc.

Referenced by LHCInfo::beam1RF(), LHCInfo::beam1VC(), LHCInfo::beam2RF(), and LHCInfo::beam2VC().

                                                                             {
    if( index >= params.size() ) throw std::out_of_range("Parameter with index "+std::to_string(index)+" is out of range.");
    return params[index];
  }

bool LHCInfoImpl::comparePayloads	(	const LHCInfo &	rhs,
		const LHCInfo &	lhs
	)

Definition at line 773 of file LHCInfoPopConSourceHandler.cc.

References LHCInfo::betaStar(), LHCInfo::crossingAngle(), LHCInfo::ctppsStatus(), LHCInfo::delivLumi(), LHCInfo::fillNumber(), LHCInfo::instLumi(), LHCInfo::instLumiError(), LHCInfo::lhcComment(), LHCInfo::lhcState(), and LHCInfo::recLumi().

Referenced by transferPayloads().

                                                                {
    if( rhs.fillNumber() != lhs.fillNumber() ) return false;
    if( rhs.delivLumi()  != lhs.delivLumi() ) return false;
    if( rhs.recLumi()  != lhs.recLumi() ) return false;
    if( rhs.instLumi()  != lhs.instLumi() ) return false;
    if( rhs.instLumiError()  != lhs.instLumiError() ) return false;
    if( rhs.crossingAngle() != rhs.crossingAngle() ) return false;
    if( rhs.betaStar() != rhs.betaStar() ) return false;
    if( rhs.lhcState() != rhs.lhcState() ) return false;
    if( rhs.lhcComment() != rhs.lhcComment() ) return false;
    if( rhs.ctppsStatus() != rhs.ctppsStatus() ) return false;
    return true;
  }

template<typename T >

const T& LHCInfoImpl::getOneParam	(	const std::vector< std::vector< T > > &	params,
		size_t	index
	)

Definition at line 124 of file LHCInfo.cc.

References SurfaceOrientation::inner, and dataset::name.

Referenced by LHCInfo::beginTime(), LHCInfo::betaStar(), LHCInfo::bunchesInBeam1(), LHCInfo::bunchesInBeam2(), LHCInfo::collidingBunches(), LHCInfo::createTime(), LHCInfo::crossingAngle(), LHCInfo::ctppsStatus(), LHCInfo::delivLumi(), LHCInfo::endTime(), LHCInfo::energy(), LHCInfo::fillNumber(), LHCInfo::fillType(), LHCInfo::injectionScheme(), LHCInfo::instLumi(), LHCInfo::instLumiError(), LHCInfo::intensityForBeam1(), LHCInfo::intensityForBeam2(), LHCInfo::lhcComment(), LHCInfo::lhcState(), LHCInfo::lumiSection(), LHCInfo::particleTypeForBeam1(), LHCInfo::particleTypeForBeam2(), LHCInfo::recLumi(), and LHCInfo::targetBunches().

                                                                                                     {
    if( index >= params.size() ) throw std::out_of_range("Parameter with index "+std::to_string(index)+" is out of range.");
    const std::vector<T>& inner = params[index];
    if( inner.empty() ) throw std::out_of_range("Parameter with index "+std::to_string(index)+" type="+typeid(T).name()+" has no value stored.");
    return inner[ 0 ];
  }

template<typename T >

const T& LHCInfoImpl::getParams	(	const std::vector< T > &	params,
		size_t	index
	)

Definition at line 114 of file LHCInfo.cc.

Referenced by LHCInfo::beam1RF(), LHCInfo::beam1VC(), LHCInfo::beam2RF(), LHCInfo::beam2VC(), LHCInfo::lumiPerBX(), and QTestConfigurationParser::qtestsConfig().

                                                                                      {
    if( index >= params.size() ) throw std::out_of_range("Parameter with index "+std::to_string(index)+" is out of range.");
    return params[index];
  }  

bool LHCInfoImpl::makeFillDataQuery	(	cond::persistency::Session &	session,
		const std::string &	conditionString,
		const coral::AttributeList &	fillDataBindVariables,
		std::unique_ptr< LHCInfo > &	targetPayload,
		bool	debug
	)

Definition at line 64 of file LHCInfoPopConSourceHandler.cc.

References LHCInfo::COSMICS, cond::time::from_boost(), LHCInfo::GAP, LHCInfo::IONS, cond::persistency::Session::nominalSchema(), LHCInfo::NONE, LHCInfo::PB82, LHCInfo::PROTON, LHCInfo::PROTONS, AlCaHLTBitMon_QueryRunRegistry::string, ntuplemaker::time, and LHCInfo::UNKNOWN.

Referenced by LHCInfoPopConSourceHandler::getFillData(), and LHCInfoPopConSourceHandler::getNextFillData().

                          {
    coral::ISchema& runTimeLoggerSchema = session.nominalSchema();
    //prepare the query for table 1:
    std::unique_ptr<coral::IQuery> fillDataQuery( runTimeLoggerSchema.newQuery() );
    //FROM clause
    fillDataQuery->addToTableList( std::string( "RUNTIME_SUMMARY" ) );
    //SELECT clause
    fillDataQuery->addToOutputList( std::string( "LHCFILL" ) );
    fillDataQuery->addToOutputList( std::string( "NBUNCHESBEAM1" ) );
    fillDataQuery->addToOutputList( std::string( "NBUNCHESBEAM2" ) );
    fillDataQuery->addToOutputList( std::string( "NCOLLIDINGBUNCHES" ) );
    fillDataQuery->addToOutputList( std::string( "NTARGETBUNCHES" ) );
    fillDataQuery->addToOutputList( std::string( "RUNTIME_TYPE_ID" ) );
    fillDataQuery->addToOutputList( std::string( "PARTY1" ) );
    fillDataQuery->addToOutputList( std::string( "PARTY2" ) );
    fillDataQuery->addToOutputList( std::string( "INTENSITYBEAM1" ) );
    fillDataQuery->addToOutputList( std::string( "INTENSITYBEAM2" ) );
    fillDataQuery->addToOutputList( std::string( "ENERGY" ) );
    fillDataQuery->addToOutputList( std::string( "CREATETIME" ) );
    fillDataQuery->addToOutputList( std::string( "BEGINTIME" ) );
    fillDataQuery->addToOutputList( std::string( "ENDTIME" ) );
    fillDataQuery->addToOutputList( std::string( "INJECTIONSCHEME" ) );
    //WHERE clause
    fillDataQuery->setCondition( conditionString, fillDataBindVariables );
    //ORDER BY clause
    std::string orderStr("BEGINTIME");
    //define query output  
    coral::AttributeList fillDataOutput;
    fillDataOutput.extend<unsigned short>( std::string( "LHCFILL" ) );
    fillDataOutput.extend<unsigned short>( std::string( "NBUNCHESBEAM1" ) );
    fillDataOutput.extend<unsigned short>( std::string( "NBUNCHESBEAM2" ) );
    fillDataOutput.extend<unsigned short>( std::string( "NCOLLIDINGBUNCHES" ) );
    fillDataOutput.extend<unsigned short>( std::string( "NTARGETBUNCHES" ) );
    fillDataOutput.extend<int>( std::string( "RUNTIME_TYPE_ID" ) );
    fillDataOutput.extend<int>( std::string( "PARTY1" ) );
    fillDataOutput.extend<int>( std::string( "PARTY2" ) );
    fillDataOutput.extend<float>( std::string( "INTENSITYBEAM1" ) );
    fillDataOutput.extend<float>( std::string( "INTENSITYBEAM2" ) );
    fillDataOutput.extend<float>( std::string( "ENERGY" ) );
    fillDataOutput.extend<coral::TimeStamp>( std::string( "CREATETIME" ) );
    fillDataOutput.extend<coral::TimeStamp>( std::string( "BEGINTIME" ) );
    fillDataOutput.extend<coral::TimeStamp>( std::string( "ENDTIME" ) );
    fillDataOutput.extend<std::string>( std::string( "INJECTIONSCHEME" ) );
    fillDataQuery->defineOutput( fillDataOutput );
    fillDataQuery->limitReturnedRows( 1 );
    //execute the query
    coral::ICursor& fillDataCursor = fillDataQuery->execute();
    //
    unsigned short currentFill = 0;
    unsigned short bunches1 = 0, bunches2 = 0, collidingBunches = 0, targetBunches = 0;
    LHCInfo::FillTypeId fillType = LHCInfo::UNKNOWN;
    LHCInfo::ParticleTypeId particleType1 = LHCInfo::NONE, particleType2 = LHCInfo::NONE;
    float intensityBeam1 = 0., intensityBeam2 = 0., energy = 0.;
    coral::TimeStamp stableBeamStartTimeStamp, beamDumpTimeStamp;
    cond::Time_t creationTime = 0ULL, stableBeamStartTime = 0ULL, beamDumpTime = 0ULL;
    std::string injectionScheme( "None" );
    std::ostringstream ss;
    bool ret = false;
    if( fillDataCursor.next() ) {
      ret = true;
      if( debug ) {
    std::ostringstream qs;
    fillDataCursor.currentRow().toOutputStream( qs );
      }
      coral::Attribute const & fillAttribute = fillDataCursor.currentRow()[ std::string( "LHCFILL" ) ];
      if( !fillAttribute.isNull() ){
    currentFill = fillAttribute.data<unsigned short>();
      }
      coral::Attribute const & bunches1Attribute = fillDataCursor.currentRow()[ std::string( "NBUNCHESBEAM1" ) ];
      if( !bunches1Attribute.isNull() ) {
    bunches1 = bunches1Attribute.data<unsigned short>();
      }
      coral::Attribute const & bunches2Attribute = fillDataCursor.currentRow()[ std::string( "NBUNCHESBEAM2" ) ];
      if( !bunches2Attribute.isNull() ) {
    bunches2 = bunches2Attribute.data<unsigned short>();
      }
      coral::Attribute const & collidingBunchesAttribute = fillDataCursor.currentRow()[ std::string( "NCOLLIDINGBUNCHES" ) ];
      if( !collidingBunchesAttribute.isNull() ) {
    collidingBunches = collidingBunchesAttribute.data<unsigned short>();
      }
      coral::Attribute const & targetBunchesAttribute = fillDataCursor.currentRow()[ std::string( "NTARGETBUNCHES" ) ];
      if( !targetBunchesAttribute.isNull() ) {
    targetBunches = targetBunchesAttribute.data<unsigned short>();
      }
      //RUNTIME_TYPE_ID IS NOT NULL
      fillType = static_cast<LHCInfo::FillTypeId>( fillDataCursor.currentRow()[ std::string( "RUNTIME_TYPE_ID" ) ].data<int>() );
      coral::Attribute const & particleType1Attribute = fillDataCursor.currentRow()[ std::string( "PARTY1" ) ];
      if( !particleType1Attribute.isNull() ) {
    particleType1 = static_cast<LHCInfo::ParticleTypeId>( particleType1Attribute.data<int>() );
      }
      coral::Attribute const & particleType2Attribute = fillDataCursor.currentRow()[ std::string( "PARTY2" ) ];
      if( !particleType2Attribute.isNull() ) {
    particleType2 = static_cast<LHCInfo::ParticleTypeId>( particleType2Attribute.data<int>() );
      }
      coral::Attribute const & intensityBeam1Attribute = fillDataCursor.currentRow()[ std::string( "INTENSITYBEAM1" ) ];
      if( !intensityBeam1Attribute.isNull() ) {
    intensityBeam1 = intensityBeam1Attribute.data<float>();
      }
      coral::Attribute const & intensityBeam2Attribute = fillDataCursor.currentRow()[ std::string( "INTENSITYBEAM2" ) ];
      if( !intensityBeam2Attribute.isNull() ) {
    intensityBeam2 = intensityBeam2Attribute.data<float>();
      }
      coral::Attribute const & energyAttribute = fillDataCursor.currentRow()[ std::string( "ENERGY" ) ];
      if( !energyAttribute.isNull() ){
    energy = energyAttribute.data<float>();
      }
    }
    if( ret ){
      //CREATETIME IS NOT NULL
      creationTime = cond::time::from_boost( fillDataCursor.currentRow()[ std::string( "CREATETIME" ) ].data<coral::TimeStamp>().time() );
      //BEGINTIME is imposed to be NOT NULL in the WHERE clause
      stableBeamStartTimeStamp = fillDataCursor.currentRow()[ std::string( "BEGINTIME" ) ].data<coral::TimeStamp>();
      stableBeamStartTime = cond::time::from_boost( stableBeamStartTimeStamp.time() );
      coral::Attribute const & beamDumpTimeAttribute = fillDataCursor.currentRow()[ std::string( "ENDTIME" ) ];
      if( !beamDumpTimeAttribute.isNull() ) {
    beamDumpTimeStamp = beamDumpTimeAttribute.data<coral::TimeStamp>();
    beamDumpTime = cond::time::from_boost( beamDumpTimeStamp.time() );
      }
      coral::Attribute const & injectionSchemeAttribute = fillDataCursor.currentRow()[ std::string( "INJECTIONSCHEME" ) ];
      if( !injectionSchemeAttribute.isNull() ) {
    injectionScheme = injectionSchemeAttribute.data<std::string>();
      }
      //fix an inconsistency in RunTimeLogger: if the fill type is defined, the particle type should reflect it!
      if( fillType != LHCInfo::UNKNOWN && ( particleType1 == LHCInfo::NONE || particleType2 == LHCInfo::NONE ) ) {
    switch( fillType ) {
    case LHCInfo::PROTONS :
      particleType1 = LHCInfo::PROTON;
      particleType2 = LHCInfo::PROTON;
      break;
    case LHCInfo::IONS :
      particleType1 = LHCInfo::PB82;
      particleType2 = LHCInfo::PB82;
      break;
    case LHCInfo::UNKNOWN :
    case LHCInfo::COSMICS :
    case LHCInfo::GAP :
      break;
    }
      }
      targetPayload.reset( new LHCInfo() );
      targetPayload->setFillNumber( currentFill );
      targetPayload->setBunchesInBeam1( bunches1 );
      targetPayload->setBunchesInBeam2( bunches2 );
      targetPayload->setCollidingBunches( collidingBunches );
      targetPayload->setTargetBunches( targetBunches );
      targetPayload->setFillType( fillType );
      targetPayload->setParticleTypeForBeam1( particleType1 );
      targetPayload->setParticleTypeForBeam2( particleType2 );
      targetPayload->setIntensityForBeam1( intensityBeam1 );
      targetPayload->setIntensityForBeam2( intensityBeam2 );
      targetPayload->setEnergy( energy );
      targetPayload->setCreationTime( creationTime );
      targetPayload->setBeginTime( stableBeamStartTime );
      targetPayload->setEndTime( beamDumpTime );
      targetPayload->setInjectionScheme( injectionScheme );
    }
    return ret;
  }

std::vector<std::pair<cond::Time_t,std::shared_ptr<LHCInfo> > >::const_iterator LHCInfoImpl::search	(	const cond::Time_t &	val,
		const std::vector< std::pair< cond::Time_t, std::shared_ptr< LHCInfo > >> &	container
	)

Definition at line 57 of file LHCInfoPopConSourceHandler.cc.

References AlCaHLTBitMon_ParallelJobs::p, and heppy_batch::val.

Referenced by LHCInfoImpl::LumiSectionFilter::process().

                                                                                                                       {
    if( container.empty() ) return container.end();
    auto p = std::upper_bound( container.begin(), container.end(), val, IOVComp() );
    return (p!= container.begin()) ? p-1 : container.end();
  }

void LHCInfoImpl::setElementData	(	cond::Time_t	since,
		const std::string &	dipVal,
		unsigned int	elementNr,
		float	value,
		LHCInfo &	payload,
		std::set< cond::Time_t > &	initList
	)

Definition at line 619 of file LHCInfoPopConSourceHandler.cc.

References LHCInfo::beam1RF(), LHCInfo::beam1VC(), LHCInfo::beam2RF(), LHCInfo::beam2VC(), LHCInfo::bunchSlots, and relativeConstraints::value.

Referenced by LHCInfoPopConSourceHandler::getEcalData().

                                                               {
    if( initList.find(since)==initList.end() ){
      payload.beam1VC().resize( LHCInfo::bunchSlots ,0.);
      payload.beam2VC().resize( LHCInfo::bunchSlots ,0.);
      payload.beam1RF().resize( LHCInfo::bunchSlots,0.);
      payload.beam2RF().resize( LHCInfo::bunchSlots,0.);
      initList.insert(since);
    }
    // set the current values to all of the payloads of the lumi section samples after the current since 
    if( elementNr < LHCInfo::bunchSlots ){
      switch( vecMap.at(dipVal) ){
      case 1:
    payload.beam1VC()[elementNr]=value; 
    break;
      case 2: 
    payload.beam2VC()[elementNr]=value;
    break;
      case 3:
    payload.beam1RF()[elementNr]=value;
    break;
      case 4:
    payload.beam2RF()[elementNr]=value;
    break;
      default:
    break;
      }
    }
  }

template<typename T >

void LHCInfoImpl::setOneParam	(	std::vector< std::vector< T > > &	params,
		size_t	index,
		const T &	value
	)

Definition at line 131 of file LHCInfo.cc.

References relativeConstraints::value.

Referenced by LHCInfo::setBeginTime(), LHCInfo::setBetaStar(), LHCInfo::setBunchesInBeam1(), LHCInfo::setBunchesInBeam2(), LHCInfo::setCollidingBunches(), LHCInfo::setCreationTime(), LHCInfo::setCrossingAngle(), LHCInfo::setCtppsStatus(), LHCInfo::setDelivLumi(), LHCInfo::setEndTime(), LHCInfo::setEnergy(), LHCInfo::setFillNumber(), LHCInfo::setFillType(), LHCInfo::setInjectionScheme(), LHCInfo::setInstLumi(), LHCInfo::setInstLumiError(), LHCInfo::setIntensityForBeam1(), LHCInfo::setIntensityForBeam2(), LHCInfo::setLhcComment(), LHCInfo::setLhcState(), LHCInfo::setLumiSection(), LHCInfo::setParticleTypeForBeam1(), LHCInfo::setParticleTypeForBeam2(), LHCInfo::setRecLumi(), and LHCInfo::setTargetBunches().

                                                                                                           {
    if( index >= params.size() ) throw std::out_of_range("Parameter with index "+std::to_string(index)+" is out of range.");
    params[ index ] = std::vector<T>(1,value);
  }

template<typename T >

void LHCInfoImpl::setParams	(	std::vector< T > &	params,
		size_t	index,
		const T &	value
	)

Definition at line 136 of file LHCInfo.cc.

References relativeConstraints::value.

Referenced by LHCInfo::setBeam1RF(), LHCInfo::setBeam1VC(), LHCInfo::setBeam2RF(), LHCInfo::setBeam2VC(), and LHCInfo::setLumiPerBX().

                                                                                            {
    if( index >= params.size() ) throw std::out_of_range("Parameter with index "+std::to_string(index)+" is out of range.");
    params[ index ] = value;
  }

size_t LHCInfoImpl::transferPayloads	(	const std::vector< std::pair< cond::Time_t, std::shared_ptr< LHCInfo > > > &	buffer,
		std::vector< std::shared_ptr< LHCInfo > > &	payloadBuffer,
		std::vector< std::pair< LHCInfo *, cond::Time_t > > &	vecToTransfer,
		std::shared_ptr< LHCInfo > &	prevPayload
	)

Definition at line 787 of file LHCInfoPopConSourceHandler.cc.

References popcon::PopConSourceHandler< LHCInfo >::add(), edmScanValgrind::buffer, comparePayloads(), jets_cff::payload, and ntuplemaker::since.

Referenced by LHCInfoPopConSourceHandler::getNewObjects().

                                                    {
    size_t niovs = 0;
    for( auto& iov: buffer ){
      bool add = false;
      LHCInfo& payload = *iov.second;
      cond::Time_t since = iov.first;
      if( vecToTransfer.empty() ){
    add = true;
      } else {
    LHCInfo& lastAdded = *vecToTransfer.back().first;
    if( !comparePayloads( lastAdded,payload ) ) {
      add = true;
    }
      }
      if( add ) {
        niovs++;
    vecToTransfer.push_back( std::make_pair( &payload, since  ) );
        payloadBuffer.push_back( iov.second );
        prevPayload = iov.second;
      } 
    }
    return niovs;
  }

Variable Documentation

const std::map<std::string, int> LHCInfoImpl::vecMap = {{"Beam1/beamPhaseMean",1},{"Beam2/beamPhaseMean",2},{"Beam1/cavPhaseMean",3},{"Beam2/cavPhaseMean",4}}

static

Definition at line 618 of file LHCInfoPopConSourceHandler.cc.