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::map< cond::Time_t, std::shared_ptr< LHCInfo >> &iovsToTransfer, std::shared_ptr< LHCInfo > &prevPayload)

Variables
static const std::map < std::string, int >	vecMap

Function Documentation

template<typename T >

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

Definition at line 124 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 792 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 131 of file LHCInfo.cc.

References SurfaceOrientation::inner, mergeVDriftHistosByStation::name, and submitPVValidationJobs::params.

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 117 of file LHCInfo.cc.

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

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

References LHCInfo::COSMICS, BeamSpotPI::creationTime, relval_parameters_module::energy, cond::time::from_boost(), LHCInfo::GAP, LHCInfo::IONS, cond::persistency::Session::nominalSchema(), LHCInfo::NONE, LHCInfo::PB82, LHCInfo::PROTON, LHCInfo::PROTONS, runTheMatrix::ret, contentValuesCheck::ss, AlCaHLTBitMon_QueryRunRegistry::string, 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 = std::make_unique<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 59 of file LHCInfoPopConSourceHandler.cc.

References AlCaHLTBitMon_ParallelJobs::p, cuda_std::upper_bound(), and hgcalPerformanceValidation::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 632 of file LHCInfoPopConSourceHandler.cc.

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

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 142 of file LHCInfo.cc.

References submitPVValidationJobs::params, and 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 149 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::map< cond::Time_t, std::shared_ptr< LHCInfo >> &	iovsToTransfer,
		std::shared_ptr< LHCInfo > &	prevPayload
	)

Definition at line 816 of file LHCInfoPopConSourceHandler.cc.

References PVValHelper::add(), edmScanValgrind::buffer, comparePayloads(), jetCorrFactors_cfi::payload, and SiStripO2O_cfg_template::since.

Referenced by LHCInfoPopConSourceHandler::getNewObjects().

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

Variable Documentation

const std::map<std::string, int> LHCInfoImpl::vecMap

static

Initial value:

= {
      {"Beam1/beamPhaseMean", 1}, {"Beam2/beamPhaseMean", 2}, {"Beam1/cavPhaseMean", 3}, {"Beam2/cavPhaseMean", 4}}

Definition at line 630 of file LHCInfoPopConSourceHandler.cc.

Referenced by setElementData().