theLHCInfoPerFillImpl Namespace Reference

Functions
bool	comparePayloads (const LHCInfoPerFill &rhs, const LHCInfoPerFill &lhs)
bool	makeFillPayload (std::unique_ptr< LHCInfoPerFill > &targetPayload, const cond::OMSServiceResult &queryResult)
void	setElementData (cond::Time_t since, const std::string &dipVal, unsigned int elementNr, float value, LHCInfoPerFill &payload, std::set< cond::Time_t > &initList)
size_t	transferPayloads (const std::vector< std::pair< cond::Time_t, std::shared_ptr< LHCInfoPerFill >>> &buffer, std::map< cond::Time_t, std::shared_ptr< LHCInfoPerFill >> &iovsToTransfer, std::shared_ptr< LHCInfoPerFill > &prevPayload)

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

Function Documentation

comparePayloads()

bool theLHCInfoPerFillImpl::comparePayloads	(	const LHCInfoPerFill &	rhs,
		const LHCInfoPerFill &	lhs
	)

Definition at line 160 of file LHCInfoPerFillPopConAnalyzer.cc.

References LHCInfoPerFill::ctppsStatus(), LHCInfoPerFill::delivLumi(), LHCInfoPerFill::fillNumber(), LHCInfoPerFill::instLumi(), LHCInfoPerFill::instLumiError(), LHCInfoPerFill::lhcComment(), LHCInfoPerFill::lhcState(), and LHCInfoPerFill::recLumi().

Referenced by transferPayloads().

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

makeFillPayload()

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

Definition at line 78 of file LHCInfoPerFillPopConAnalyzer.cc.

References cond::OMSServiceResult::begin(), beamSpotPI::creationTime, cond::OMSServiceResult::empty(), HBHEDarkening_cff::energy, cond::time::from_boost(), runTheMatrix::ret, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by LHCInfoPerFillPopConSourceHandler::getNewObjects().

                                                                                                              {
    bool ret = false;
    if (!queryResult.empty()) {
      auto row = *queryResult.begin();
      auto currentFill = row.get<unsigned short>("fill_number");
      auto bunches1 = row.get<unsigned short>("bunches_beam1");
      auto bunches2 = row.get<unsigned short>("bunches_beam2");
      auto collidingBunches = row.get<unsigned short>("bunches_colliding");
      auto targetBunches = row.get<unsigned short>("bunches_target");
      auto fillType = row.get<LHCInfoPerFill::FillType>("fill_type_runtime");
      auto particleType1 = row.get<LHCInfoPerFill::ParticleType>("fill_type_party1");
      auto particleType2 = row.get<LHCInfoPerFill::ParticleType>("fill_type_party2");
      auto intensityBeam1 = row.get<float>("intensity_beam1");
      auto intensityBeam2 = row.get<float>("intensity_beam2");
      auto energy = row.get<float>("energy");
      auto creationTime = row.get<boost::posix_time::ptime>("start_time");
      auto stableBeamStartTime = row.get<boost::posix_time::ptime>("start_stable_beam");
      std::string endTimeStr = row.get<std::string>("end_time");
      auto beamDumpTime =
          (endTimeStr == "null") ? 0 : cond::time::from_boost(row.get<boost::posix_time::ptime>("end_time"));
      auto injectionScheme = row.get<std::string>("injection_scheme");
      targetPayload = std::make_unique<LHCInfoPerFill>();
      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(cond::time::from_boost(creationTime));
      targetPayload->setBeginTime(cond::time::from_boost(stableBeamStartTime));
      targetPayload->setEndTime(beamDumpTime);
      targetPayload->setInjectionScheme(injectionScheme);
      ret = true;
    }
    return ret;
  }

setElementData()

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

Definition at line 124 of file LHCInfoPerFillPopConAnalyzer.cc.

References LHCInfoPerFill::bunchSlots, jetsAK4_Puppi_cff::payload, SiStripO2O_cfg_template::since, relativeConstraints::value, and vecMap.

Referenced by LHCInfoPerFillPopConSourceHandler::getEcalData().

                                                    {
    if (initList.find(since) == initList.end()) {
      payload.beam1VC().resize(LHCInfoPerFill::bunchSlots, 0.);
      payload.beam2VC().resize(LHCInfoPerFill::bunchSlots, 0.);
      payload.beam1RF().resize(LHCInfoPerFill::bunchSlots, 0.);
      payload.beam2RF().resize(LHCInfoPerFill::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 < LHCInfoPerFill::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;
      }
    }
  }

transferPayloads()

size_t theLHCInfoPerFillImpl::transferPayloads	(	const std::vector< std::pair< cond::Time_t, std::shared_ptr< LHCInfoPerFill >>> &	buffer,
		std::map< cond::Time_t, std::shared_ptr< LHCInfoPerFill >> &	iovsToTransfer,
		std::shared_ptr< LHCInfoPerFill > &	prevPayload
	)

Definition at line 170 of file LHCInfoPerFillPopConAnalyzer.cc.

References PVValHelper::add(), edmScanValgrind::buffer, comparePayloads(), jetsAK4_Puppi_cff::payload, SiStripO2O_cfg_template::since, and cond::time::to_boost().

Referenced by LHCInfoPerFillPopConSourceHandler::getNewObjects().

                                                                      {
    size_t niovs = 0;
    std::stringstream condIovs;
    std::stringstream formattedIovs;
    for (auto& iov : buffer) {
      bool add = false;
      auto payload = iov.second;
      cond::Time_t since = iov.first;
      if (iovsToTransfer.empty()) {
        add = true;
      } else {
        LHCInfoPerFill& lastAdded = *iovsToTransfer.rbegin()->second;
        if (!comparePayloads(lastAdded, *payload)) {
          add = true;
        }
      }
      if (add) {
        niovs++;
        condIovs << since << " ";
        formattedIovs << boost::posix_time::to_iso_extended_string(cond::time::to_boost(since)) << " ";
        iovsToTransfer.insert(std::make_pair(since, payload));
        prevPayload = iov.second;
      }
    }
    edm::LogInfo("transferPayloads") << "TRANSFERED IOVS: " << condIovs.str();
    edm::LogInfo("transferPayloads") << "FORMATTED TRANSFERED IOVS: " << formattedIovs.str();
    return niovs;
  }

Variable Documentation

vecMap

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

static

Initial value:

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

Definition at line 122 of file LHCInfoPerFillPopConAnalyzer.cc.

Referenced by setElementData().