Inheritance diagram for CTPPSRPAlignmentCorrectionsDataESSourceXML:

Public Member Functions
	CTPPSRPAlignmentCorrectionsDataESSourceXML (const edm::ParameterSet &p)

std::unique_ptr< CTPPSRPAlignmentCorrectionsData >	produceMeasured (const CTPPSRPAlignmentCorrectionsDataRcd &)

std::unique_ptr< CTPPSRPAlignmentCorrectionsData >	produceMisaligned (const RPMisalignedAlignmentRecord &)

std::unique_ptr< CTPPSRPAlignmentCorrectionsData >	produceReal (const RPRealAlignmentRecord &)

	~CTPPSRPAlignmentCorrectionsDataESSourceXML () override

Public Member Functions inherited from edm::ESProducer
	ESProducer ()

	ESProducer (const ESProducer &)=delete

ESProxyIndex const *	getTokenIndices (unsigned int iIndex) const

ESRecordIndex const *	getTokenRecordIndices (unsigned int iIndex) const

bool	hasMayConsumes () const noexcept

size_t	numberOfTokenIndices (unsigned int iIndex) const

ESProducer const &	operator= (const ESProducer &)=delete

SerialTaskQueueChain &	queue ()

template<typename Record >
std::optional< std::vector< ESProxyIndex > >	updateFromMayConsumes (unsigned int iIndex, const Record &iRecord) const

void	updateLookup (eventsetup::ESRecordsToProxyIndices const &) final

	~ESProducer () noexcept(false) override

Public Member Functions inherited from edm::ESProxyFactoryProducer
	ESProxyFactoryProducer ()

	ESProxyFactoryProducer (const ESProxyFactoryProducer &)=delete

const ESProxyFactoryProducer &	operator= (const ESProxyFactoryProducer &)=delete

	~ESProxyFactoryProducer () noexcept(false) override

Public Member Functions inherited from edm::eventsetup::DataProxyProvider
void	createKeyedProxies (EventSetupRecordKey const &key, unsigned int nConcurrentIOVs)

	DataProxyProvider ()

	DataProxyProvider (const DataProxyProvider &)=delete

const ComponentDescription &	description () const

void	fillRecordsNotAllowingConcurrentIOVs (std::set< EventSetupRecordKey > &recordsNotAllowingConcurrentIOVs) const

virtual void	initConcurrentIOVs (EventSetupRecordKey const &key, unsigned int nConcurrentIOVs)

bool	isUsingRecord (const EventSetupRecordKey &key) const

KeyedProxies &	keyedProxies (const EventSetupRecordKey &iRecordKey, unsigned int iovIndex=0)

const DataProxyProvider &	operator= (const DataProxyProvider &)=delete

void	setAppendToDataLabel (const edm::ParameterSet &)

void	setDescription (const ComponentDescription &iDescription)

std::set< EventSetupRecordKey >	usingRecords () const

virtual	~DataProxyProvider () noexcept(false)

Public Member Functions inherited from edm::EventSetupRecordIntervalFinder
bool	concurrentFinder () const

const eventsetup::ComponentDescription &	descriptionForFinder () const

	EventSetupRecordIntervalFinder ()

	EventSetupRecordIntervalFinder (const EventSetupRecordIntervalFinder &)=delete

std::set< eventsetup::EventSetupRecordKey >	findingForRecords () const

const ValidityInterval &	findIntervalFor (const eventsetup::EventSetupRecordKey &, const IOVSyncValue &)

bool	nonconcurrentAndIOVNeedsUpdate (const eventsetup::EventSetupRecordKey &key, const IOVSyncValue &syncValue) const

const EventSetupRecordIntervalFinder &	operator= (const EventSetupRecordIntervalFinder &)=delete

void	resetInterval (const eventsetup::EventSetupRecordKey &)

void	setDescriptionForFinder (const eventsetup::ComponentDescription &iDescription)

virtual	~EventSetupRecordIntervalFinder () noexcept(false)

Protected Member Functions
CTPPSRPAlignmentCorrectionsDataSequence	Merge (const std::vector< CTPPSRPAlignmentCorrectionsDataSequence > &) const
	merges an array of sequences to one More...

void	PrepareSequence (const std::string &label, CTPPSRPAlignmentCorrectionsDataSequence &seq, const std::vector< std::string > &files) const
	builds a sequence of corrections from provided sources and runs a few checks More...

void	setIntervalFor (const edm::eventsetup::EventSetupRecordKey &, const edm::IOVSyncValue &, edm::ValidityInterval &) override

Protected Member Functions inherited from edm::ESProducer
template<typename T >
auto	setWhatProduced (T iThis, const char iLabel)

template<typename T >
auto	setWhatProduced (T *iThis, const es::Label &iLabel={})

template<typename T >
auto	setWhatProduced (T *iThis, const std::string &iLabel)

template<typename T , typename TDecorator >
auto	setWhatProduced (T *iThis, const TDecorator &iDec, const es::Label &iLabel={})

template<typename T , typename TReturn , typename TRecord >
auto	setWhatProduced (T iThis, TReturn(T ::iMethod)(const TRecord &), const es::Label &iLabel={})

template<typename T , typename TReturn , typename TRecord , typename TArg >
ESConsumesCollectorT< TRecord >	setWhatProduced (T iThis, TReturn(T ::iMethod)(const TRecord &), const TArg &iDec, const es::Label &iLabel={})

void	usesResources (std::vector< std::string > const &)

Protected Member Functions inherited from edm::ESProxyFactoryProducer
template<class TFactory >
void	registerFactory (std::unique_ptr< TFactory > iFactory, const std::string &iLabel=std::string())

virtual void	registerFactoryWithKey (const EventSetupRecordKey &iRecord, std::unique_ptr< eventsetup::ProxyFactoryBase > iFactory, const std::string &iLabel=std::string())

KeyedProxiesVector	registerProxies (const EventSetupRecordKey &, unsigned int iovIndex) override

Protected Member Functions inherited from edm::eventsetup::DataProxyProvider
template<class T >
void	usingRecord ()

void	usingRecordWithKey (const EventSetupRecordKey &key)

Protected Member Functions inherited from edm::EventSetupRecordIntervalFinder
template<class T >
void	findingRecord ()

void	findingRecordWithKey (const eventsetup::EventSetupRecordKey &)

Static Protected Member Functions
static edm::EventID	nextLS (const edm::EventID &src)

static edm::EventID	previousLS (const edm::EventID &src)

Protected Attributes
CTPPSRPAlignmentCorrectionsData	acMeasured

CTPPSRPAlignmentCorrectionsData	acMisaligned

CTPPSRPAlignmentCorrectionsData	acReal

CTPPSRPAlignmentCorrectionsDataSequence	acsMeasured

CTPPSRPAlignmentCorrectionsDataSequence	acsMisaligned

CTPPSRPAlignmentCorrectionsDataSequence	acsReal

unsigned int	verbosity

Additional Inherited Members
Static Public Member Functions inherited from edm::eventsetup::DataProxyProvider
static void	prevalidate (ConfigurationDescriptions &)

Protected Types inherited from edm::ESProxyFactoryProducer
using	EventSetupRecordKey = eventsetup::EventSetupRecordKey

Protected Types inherited from edm::eventsetup::DataProxyProvider
using	KeyedProxiesVector = std::vector< std::pair< DataKey, std::shared_ptr< DataProxy > >>

Detailed Description

Loads alignment corrections to EventSetup.

Definition at line 35 of file CTPPSRPAlignmentCorrectionsDataESSourceXML.cc.

Constructor & Destructor Documentation

◆ CTPPSRPAlignmentCorrectionsDataESSourceXML()

CTPPSRPAlignmentCorrectionsDataESSourceXML::CTPPSRPAlignmentCorrectionsDataESSourceXML ( const edm::ParameterSet & p )

Definition at line 91 of file CTPPSRPAlignmentCorrectionsDataESSourceXML.cc.

     : verbosity(pSet.getUntrackedParameter<unsigned int>("verbosity", 0)) {
   std::vector<std::string> measuredFiles;
   for (const auto &f : pSet.getParameter<vector<string> >("MeasuredFiles"))
     measuredFiles.push_back(edm::FileInPath(f).fullPath());
   PrepareSequence("Measured", acsMeasured, measuredFiles);
  
   std::vector<std::string> realFiles;
   for (const auto &f : pSet.getParameter<vector<string> >("RealFiles"))
     realFiles.push_back(edm::FileInPath(f).fullPath());
   PrepareSequence("Real", acsReal, realFiles);
  
   std::vector<std::string> misalignedFiles;
   for (const auto &f : pSet.getParameter<vector<string> >("MisalignedFiles"))
     misalignedFiles.push_back(edm::FileInPath(f).fullPath());
   PrepareSequence("Misaligned", acsMisaligned, misalignedFiles);
  
   setWhatProduced(this, &CTPPSRPAlignmentCorrectionsDataESSourceXML::produceMeasured);
   setWhatProduced(this, &CTPPSRPAlignmentCorrectionsDataESSourceXML::produceReal);
   setWhatProduced(this, &CTPPSRPAlignmentCorrectionsDataESSourceXML::produceMisaligned);
  
   findingRecord<CTPPSRPAlignmentCorrectionsDataRcd>();
   findingRecord<RPRealAlignmentRecord>();
   findingRecord<RPMisalignedAlignmentRecord>();
 }

References acsMeasured, acsMisaligned, acsReal, f, contentValuesFiles::fullPath, edm::ParameterSet::getParameter(), PrepareSequence(), produceMeasured(), produceMisaligned(), produceReal(), and edm::ESProducer::setWhatProduced().

◆ ~CTPPSRPAlignmentCorrectionsDataESSourceXML()

CTPPSRPAlignmentCorrectionsDataESSourceXML::~CTPPSRPAlignmentCorrectionsDataESSourceXML ( )

override

Definition at line 119 of file CTPPSRPAlignmentCorrectionsDataESSourceXML.cc.

119 {}

Member Function Documentation

◆ Merge()

CTPPSRPAlignmentCorrectionsDataSequence CTPPSRPAlignmentCorrectionsDataESSourceXML::Merge ( const std::vector< CTPPSRPAlignmentCorrectionsDataSequence > & seqs ) const

protected

merges an array of sequences to one

Definition at line 123 of file CTPPSRPAlignmentCorrectionsDataESSourceXML.cc.

                                                                        {
   // find interval boundaries
   map<edm::EventID, vector<pair<bool, const CTPPSRPAlignmentCorrectionsData *> > > bounds;
  
   for (const auto &seq : seqs) {
     for (const auto &p : seq) {
       const ValidityInterval &iov = p.first;
       const CTPPSRPAlignmentCorrectionsData *corr = &p.second;
  
       const EventID &event_first = iov.first().eventID();
       bounds[event_first].emplace_back(pair<bool, const CTPPSRPAlignmentCorrectionsData *>(true, corr));
  
       const EventID &event_after = nextLS(iov.last().eventID());
       bounds[event_after].emplace_back(pair<bool, const CTPPSRPAlignmentCorrectionsData *>(false, corr));
     }
   }
  
   // build correction sums per interval
   set<const CTPPSRPAlignmentCorrectionsData *> accumulator;
   CTPPSRPAlignmentCorrectionsDataSequence result;
   for (map<EventID, vector<pair<bool, const CTPPSRPAlignmentCorrectionsData *> > >::const_iterator tit = bounds.begin();
        tit != bounds.end();
        ++tit) {
     for (const auto &cit : tit->second) {
       bool add = cit.first;
       const CTPPSRPAlignmentCorrectionsData *corr = cit.second;
  
       if (add)
         accumulator.insert(corr);
       else
         accumulator.erase(corr);
     }
  
     auto tit_next = tit;
     tit_next++;
     if (tit_next == bounds.end())
       break;
  
     const EventID &event_first = tit->first;
     const EventID &event_last = previousLS(tit_next->first);
  
     if (verbosity) {
       LogVerbatim("CTPPSRPAlignmentCorrectionsDataESSourceXML")
           << "    first=" << CTPPSRPAlignmentCorrectionsMethods::iovValueToString(edm::IOVSyncValue(event_first))
           << ", last=" << CTPPSRPAlignmentCorrectionsMethods::iovValueToString(edm::IOVSyncValue(event_last))
           << ": alignment blocks " << accumulator.size();
     }
  
     CTPPSRPAlignmentCorrectionsData corr_sum;
     for (auto sit : accumulator)
       corr_sum.addCorrections(*sit);
  
     result.insert(edm::ValidityInterval(edm::IOVSyncValue(event_first), edm::IOVSyncValue(event_last)), corr_sum);
   }
  
   return result;
 }

References mixOne_premix_on_sim_cfi::accumulator, PVValHelper::add(), CTPPSRPAlignmentCorrectionsData::addCorrections(), alignCSCRings::corr, edm::IOVSyncValue::eventID(), edm::ValidityInterval::first(), CTPPSRPAlignmentCorrectionsMethods::iovValueToString(), edm::ValidityInterval::last(), genParticles_cff::map, nextLS(), AlCaHLTBitMon_ParallelJobs::p, previousLS(), mps_fire::result, cmsswSequenceInfo::seq, cmsswSequenceInfo::seqs, trackerHitRTTI::vector, and verbosity.

Referenced by PrepareSequence().

◆ nextLS()

static edm::EventID CTPPSRPAlignmentCorrectionsDataESSourceXML::nextLS ( const edm::EventID & src )

inlinestaticprotected

Definition at line 69 of file CTPPSRPAlignmentCorrectionsDataESSourceXML.cc.

Referenced by Merge().

◆ PrepareSequence()

void CTPPSRPAlignmentCorrectionsDataESSourceXML::PrepareSequence	(	const std::string &	label,
		CTPPSRPAlignmentCorrectionsDataSequence &	seq,
		const std::vector< std::string > &	files
	)		const

protected

builds a sequence of corrections from provided sources and runs a few checks

Definition at line 184 of file CTPPSRPAlignmentCorrectionsDataESSourceXML.cc.

                                                                                                     {
   if (verbosity)
     LogVerbatim(">> CTPPSRPAlignmentCorrectionsDataESSourceXML")
         << "CTPPSRPAlignmentCorrectionsDataESSourceXML::PrepareSequence(" << label << ")";
  
   vector<CTPPSRPAlignmentCorrectionsDataSequence> sequences;
   sequences.reserve(files.size());
   for (const auto &file : files)
     sequences.emplace_back(CTPPSRPAlignmentCorrectionsMethods::loadFromXML(file));
  
   seq = Merge(sequences);
 }

References FrontierConditions_GlobalTag_cff::file, submitPVResolutionJobs::files, label, CTPPSRPAlignmentCorrectionsMethods::loadFromXML(), Merge(), cmsswSequenceInfo::seq, and verbosity.

Referenced by CTPPSRPAlignmentCorrectionsDataESSourceXML().

◆ previousLS()

static edm::EventID CTPPSRPAlignmentCorrectionsDataESSourceXML::previousLS ( const edm::EventID & src )

inlinestaticprotected

Definition at line 59 of file CTPPSRPAlignmentCorrectionsDataESSourceXML.cc.

                                                   {
     if (src.luminosityBlock() == edm::EventID::maxLuminosityBlockNumber()) {
       if (src.run() == edm::EventID::maxRunNumber())
         return src;
  

Referenced by Merge(), and setIntervalFor().

◆ produceMeasured()

std::unique_ptr< CTPPSRPAlignmentCorrectionsData > CTPPSRPAlignmentCorrectionsDataESSourceXML::produceMeasured ( const CTPPSRPAlignmentCorrectionsDataRcd & iRecord )

Definition at line 201 of file CTPPSRPAlignmentCorrectionsDataESSourceXML.cc.

                                                        {
   return std::make_unique<CTPPSRPAlignmentCorrectionsData>(acMeasured);
 }

References acMeasured.

Referenced by CTPPSRPAlignmentCorrectionsDataESSourceXML().

◆ produceMisaligned()

std::unique_ptr< CTPPSRPAlignmentCorrectionsData > CTPPSRPAlignmentCorrectionsDataESSourceXML::produceMisaligned ( const RPMisalignedAlignmentRecord & iRecord )

Definition at line 215 of file CTPPSRPAlignmentCorrectionsDataESSourceXML.cc.

                                                 {
   return std::make_unique<CTPPSRPAlignmentCorrectionsData>(acMisaligned);
 }

References acMisaligned.

Referenced by CTPPSRPAlignmentCorrectionsDataESSourceXML().

◆ produceReal()

std::unique_ptr< CTPPSRPAlignmentCorrectionsData > CTPPSRPAlignmentCorrectionsDataESSourceXML::produceReal ( const RPRealAlignmentRecord & iRecord )

Definition at line 208 of file CTPPSRPAlignmentCorrectionsDataESSourceXML.cc.

                                           {
   return std::make_unique<CTPPSRPAlignmentCorrectionsData>(acReal);
 }

References acReal.

Referenced by CTPPSRPAlignmentCorrectionsDataESSourceXML().

◆ setIntervalFor()

void CTPPSRPAlignmentCorrectionsDataESSourceXML::setIntervalFor	(	const edm::eventsetup::EventSetupRecordKey &	key,
		const edm::IOVSyncValue &	iosv,
		edm::ValidityInterval &	valInt
	)

overrideprotectedvirtual

Implements edm::EventSetupRecordIntervalFinder.

Definition at line 222 of file CTPPSRPAlignmentCorrectionsDataESSourceXML.cc.

                                                                                           {
   if (verbosity) {
     time_t unixTime = iosv.time().unixTime();
     char timeStr[50];
     strftime(timeStr, 50, "%F %T", localtime(&unixTime));
  
     LogVerbatim("CTPPSRPAlignmentCorrectionsDataESSourceXML")
         << ">> CTPPSRPAlignmentCorrectionsDataESSourceXML::setIntervalFor(" << key.name() << ")";
  
     LogVerbatim("CTPPSRPAlignmentCorrectionsDataESSourceXML")
         << "    event=" << iosv.eventID() << ", UNIX timestamp=" << unixTime << " (" << timeStr << ")";
   }
  
   // // determine what sequence and corrections should be used
   CTPPSRPAlignmentCorrectionsDataSequence *p_seq = nullptr;
   CTPPSRPAlignmentCorrectionsData *p_corr = nullptr;
  
   if (strcmp(key.name(), "CTPPSRPAlignmentCorrectionsDataRcd") == 0) {
     p_seq = &acsMeasured;
     p_corr = &acMeasured;
   }
  
   if (strcmp(key.name(), "RPRealAlignmentRecord") == 0) {
     p_seq = &acsReal;
     p_corr = &acReal;
   }
  
   if (strcmp(key.name(), "RPMisalignedAlignmentRecord") == 0) {
     p_seq = &acsMisaligned;
     p_corr = &acMisaligned;
   }
  
   if (p_corr == nullptr)
     throw cms::Exception("CTPPSRPAlignmentCorrectionsDataESSourceXML::setIntervalFor")
         << "Unknown record " << key.name();
  
   // // find the corresponding interval
   bool next_exists = false;
   const edm::EventID &event_curr = iosv.eventID();
   edm::EventID event_next_start(edm::EventID::maxRunNumber(), edm::EventID::maxLuminosityBlockNumber(), 1);
  
   for (const auto &it : *p_seq) {
     const auto &it_event_first = it.first.first().eventID();
     const auto &it_event_last = it.first.last().eventID();
  
     bool it_contained_lo = ((it_event_first.run() < event_curr.run()) ||
                             ((it_event_first.run() == event_curr.run()) &&
                              (it_event_first.luminosityBlock() <= event_curr.luminosityBlock())));
  
     bool it_contained_up = ((it_event_last.run() > event_curr.run()) ||
                             ((it_event_last.run() == event_curr.run()) &&
                              (it_event_last.luminosityBlock() >= event_curr.luminosityBlock())));
  
     if (it_contained_lo && it_contained_up) {
       valInt = it.first;
       *p_corr = it.second;
  
       if (verbosity) {
         LogVerbatim("CTPPSRPAlignmentCorrectionsDataESSourceXML")
             << "    setting validity interval [" << CTPPSRPAlignmentCorrectionsMethods::iovValueToString(valInt.first())
             << ", " << CTPPSRPAlignmentCorrectionsMethods::iovValueToString(valInt.last()) << "]";
       }
  
       return;
     }
  
     bool it_in_future = ((it_event_first.run() > event_curr.run()) ||
                          ((it_event_first.run() == event_curr.run() &&
                            (it_event_first.luminosityBlock() > event_curr.luminosityBlock()))));
  
     if (it_in_future) {
       next_exists = true;
       if (event_next_start > it_event_first)
         event_next_start = it_event_first;
     }
   }
  
   // no interval found, set empty corrections
   *p_corr = CTPPSRPAlignmentCorrectionsData();
  
   if (!next_exists) {
     valInt = ValidityInterval(iosv, iosv.endOfTime());
   } else {
     const EventID &event_last = previousLS(event_next_start);
     valInt = ValidityInterval(iosv, IOVSyncValue(event_last));
   }
  
   if (verbosity) {
     LogVerbatim("CTPPSRPAlignmentCorrectionsDataESSourceXML")
         << "    setting validity interval [" << CTPPSRPAlignmentCorrectionsMethods::iovValueToString(valInt.first())
         << ", " << CTPPSRPAlignmentCorrectionsMethods::iovValueToString(valInt.last())
         << "] (empty alignment corrections)";
   }
 }