Inheritance diagram for CTPPSIncludeAlignmentsFromXML:

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

std::unique_ptr< RPAlignmentCorrectionsData >	produceMeasured (const RPMeasuredAlignmentRecord &)

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

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

	~CTPPSIncludeAlignmentsFromXML () override

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

	~ESProducer ()(false) override

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

void	newInterval (const eventsetup::EventSetupRecordKey &iRecordType, const ValidityInterval &iInterval) override
	overrides DataProxyProvider method More...

	~ESProxyFactoryProducer () noexcept(false) override

Public Member Functions inherited from edm::eventsetup::DataProxyProvider
	DataProxyProvider ()

const ComponentDescription &	description () const

bool	isUsingRecord (const EventSetupRecordKey &) const

const KeyedProxies &	keyedProxies (const EventSetupRecordKey &iRecordKey) const

void	resetProxies (const EventSetupRecordKey &iRecordType)

void	resetProxiesIfTransient (const EventSetupRecordKey &iRecordType)

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
const eventsetup::ComponentDescription &	descriptionForFinder () const

	EventSetupRecordIntervalFinder ()

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

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

void	setDescriptionForFinder (const eventsetup::ComponentDescription &iDescription)

virtual	~EventSetupRecordIntervalFinder () noexcept(false)

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

void	PrepareSequence (const std::string &label, RPAlignmentCorrectionsDataSequence &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 >
void	setWhatProduced (T *iThis, const es::Label &iLabel=es::Label())

template<typename T >
void	setWhatProduced (T iThis, const char iLabel)

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

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

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

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

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 eventsetup::EventSetupRecordKey &iRecord, std::unique_ptr< eventsetup::ProxyFactoryBase > iFactory, const std::string &iLabel=std::string())

void	registerProxies (const eventsetup::EventSetupRecordKey &iRecord, KeyedProxies &aProxyList) override
	override DataProxyProvider method More...

Protected Member Functions inherited from edm::eventsetup::DataProxyProvider
void	eraseAll (const EventSetupRecordKey &iRecordKey)
	deletes all the Proxies in aStream More...

void	invalidateProxies (const EventSetupRecordKey &iRecordKey)

template<class T >
void	usingRecord ()

void	usingRecordWithKey (const EventSetupRecordKey &)

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
RPAlignmentCorrectionsData	acMeasured

RPAlignmentCorrectionsData	acMisaligned

RPAlignmentCorrectionsData	acReal

RPAlignmentCorrectionsDataSequence	acsMeasured

RPAlignmentCorrectionsDataSequence	acsMisaligned

RPAlignmentCorrectionsDataSequence	acsReal

unsigned int	verbosity

Additional Inherited Members
Public Types inherited from edm::eventsetup::DataProxyProvider
typedef std::vector< std::pair< DataKey, edm::propagate_const< std::shared_ptr< DataProxy > > > >	KeyedProxies

typedef std::vector< EventSetupRecordKey >	Keys

typedef std::map< EventSetupRecordKey, KeyedProxies >	RecordProxies

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

Detailed Description

Loads alignment corrections to EventSetup.

Definition at line 35 of file CTPPSIncludeAlignmentsFromXML.cc.

Constructor & Destructor Documentation

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

Definition at line 91 of file CTPPSIncludeAlignmentsFromXML.cc.

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

                                                                                         :
   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, &CTPPSIncludeAlignmentsFromXML::produceMeasured);
   setWhatProduced(this, &CTPPSIncludeAlignmentsFromXML::produceReal);
   setWhatProduced(this, &CTPPSIncludeAlignmentsFromXML::produceMisaligned);
 
   findingRecord<RPMeasuredAlignmentRecord>();
   findingRecord<RPRealAlignmentRecord>();
   findingRecord<RPMisalignedAlignmentRecord>();
 }

CTPPSIncludeAlignmentsFromXML::~CTPPSIncludeAlignmentsFromXML ( )

override

Definition at line 120 of file CTPPSIncludeAlignmentsFromXML.cc.

121 {

122 }

Member Function Documentation

RPAlignmentCorrectionsDataSequence CTPPSIncludeAlignmentsFromXML::Merge ( const std::vector< RPAlignmentCorrectionsDataSequence > & seqs ) const

protected

merges an array of sequences to one

Definition at line 126 of file CTPPSIncludeAlignmentsFromXML.cc.

References mixOne_premix_on_sim_cfi::accumulator, PVValHelper::add(), RPAlignmentCorrectionsData::addCorrections(), corr, edm::IOVSyncValue::eventID(), edm::ValidityInterval::first(), RPAlignmentCorrectionsDataSequence::insert(), RPAlignmentCorrectionsMethods::iovValueToString(), edm::ValidityInterval::last(), genParticles_cff::map, nextLS(), AlCaHLTBitMon_ParallelJobs::p, previousLS(), mps_fire::result, and verbosity.

Referenced by nextLS(), and PrepareSequence().

 {
   // find interval boundaries
   map< edm::EventID, vector< pair<bool, const RPAlignmentCorrectionsData*> > > bounds;
 
   for (const auto & seq : seqs)
   {
     for (const auto &p : seq)
     {
       const ValidityInterval &iov = p.first;
       const RPAlignmentCorrectionsData *corr = & p.second;
 
       const EventID &event_first = iov.first().eventID();
       bounds[event_first].emplace_back( pair<bool, const RPAlignmentCorrectionsData*>(true, corr) );
 
       const EventID &event_after = nextLS(iov.last().eventID());
       bounds[event_after].emplace_back( pair<bool, const RPAlignmentCorrectionsData*>(false, corr) );
     }
   }
 
   // build correction sums per interval
   set<const RPAlignmentCorrectionsData*> accumulator;
   RPAlignmentCorrectionsDataSequence result;
   for (map< EventID, vector< pair<bool, const RPAlignmentCorrectionsData*> > >::const_iterator tit = bounds.begin(); tit != bounds.end(); ++tit)
   {
     for (const auto & cit : tit->second)
     {
       bool add = cit.first;
       const RPAlignmentCorrectionsData *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("CTPPSIncludeAlignmentsFromXML")
         << "    first=" << RPAlignmentCorrectionsMethods::iovValueToString(edm::IOVSyncValue(event_first))
         << ", last=" << RPAlignmentCorrectionsMethods::iovValueToString(edm::IOVSyncValue(event_last))
         << ": alignment blocks " << accumulator.size();
     }
 
     RPAlignmentCorrectionsData 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;
 }

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

inlinestaticprotected

Definition at line 63 of file CTPPSIncludeAlignmentsFromXML.cc.

References edm::EventID::event(), PatBasicFWLiteAnalyzer::files, diffTwoXMLs::label, edm::EventID::luminosityBlock(), edm::EventID::maxLuminosityBlockNumber(), edm::EventID::maxRunNumber(), Merge(), PrepareSequence(), edm::EventID::run(), and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by Merge().

     {
       if (src.luminosityBlock() == edm::EventID::maxLuminosityBlockNumber())
       {
         if (src.run() == edm::EventID::maxRunNumber())
           return src;
 
         return edm::EventID(src.run() + 1, 0, src.event());
       }
 
       return edm::EventID(src.run(), src.luminosityBlock() + 1, src.event());
     }

void CTPPSIncludeAlignmentsFromXML::PrepareSequence	(	const std::string &	label,
		RPAlignmentCorrectionsDataSequence &	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 190 of file CTPPSIncludeAlignmentsFromXML.cc.

References FrontierConditions_GlobalTag_cff::file, RPAlignmentCorrectionsMethods::loadFromXML(), Merge(), and verbosity.

Referenced by CTPPSIncludeAlignmentsFromXML(), and nextLS().

 {
   if (verbosity)
     LogVerbatim(">> CTPPSIncludeAlignmentsFromXML") << "CTPPSIncludeAlignmentsFromXML::PrepareSequence(" << label << ")";
 
   vector<RPAlignmentCorrectionsDataSequence> sequences;
   for (const auto & file : files)
     sequences.emplace_back(RPAlignmentCorrectionsMethods::loadFromXML(file));
 
   seq = Merge(sequences);
 }

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

inlinestaticprotected

Definition at line 52 of file CTPPSIncludeAlignmentsFromXML.cc.

References edm::EventID::event(), edm::EventID::luminosityBlock(), edm::EventID::maxLuminosityBlockNumber(), edm::EventID::maxRunNumber(), and edm::EventID::run().

Referenced by Merge(), and setIntervalFor().

     {
       if (src.run() == edm::EventID::maxRunNumber() && src.luminosityBlock() == edm::EventID::maxLuminosityBlockNumber())
           return src;
 
       if (src.luminosityBlock() == 0)
         return edm::EventID(src.run() - 1, edm::EventID::maxLuminosityBlockNumber(), src.event());
 
       return edm::EventID(src.run(), src.luminosityBlock() - 1, src.event());
     }

std::unique_ptr< RPAlignmentCorrectionsData > CTPPSIncludeAlignmentsFromXML::produceMeasured ( const RPMeasuredAlignmentRecord & iRecord )

Definition at line 204 of file CTPPSIncludeAlignmentsFromXML.cc.

References acMeasured.

Referenced by CTPPSIncludeAlignmentsFromXML().

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

std::unique_ptr< RPAlignmentCorrectionsData > CTPPSIncludeAlignmentsFromXML::produceMisaligned ( const RPMisalignedAlignmentRecord & iRecord )

Definition at line 218 of file CTPPSIncludeAlignmentsFromXML.cc.

References acMisaligned.

Referenced by CTPPSIncludeAlignmentsFromXML().

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

std::unique_ptr< RPAlignmentCorrectionsData > CTPPSIncludeAlignmentsFromXML::produceReal ( const RPRealAlignmentRecord & iRecord )

Definition at line 211 of file CTPPSIncludeAlignmentsFromXML.cc.

References acReal.

Referenced by CTPPSIncludeAlignmentsFromXML().

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

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

overrideprotectedvirtual

Implements edm::EventSetupRecordIntervalFinder.

Definition at line 225 of file CTPPSIncludeAlignmentsFromXML.cc.

References acMeasured, acMisaligned, acReal, acsMeasured, acsMisaligned, acsReal, DEFINE_FWK_EVENTSETUP_SOURCE, edm::IOVSyncValue::endOfTime(), edm::IOVSyncValue::eventID(), Exception, edm::ValidityInterval::first(), RPAlignmentCorrectionsMethods::iovValueToString(), edm::ValidityInterval::last(), edm::EventID::luminosityBlock(), edm::EventID::maxLuminosityBlockNumber(), edm::EventID::maxRunNumber(), edm::eventsetup::EventSetupRecordKey::name(), previousLS(), edm::EventID::run(), edm::IOVSyncValue::time(), edm::Timestamp::unixTime(), and verbosity.

 {
   if (verbosity)
   {
     time_t unixTime = iosv.time().unixTime();
     char timeStr[50];
     strftime(timeStr, 50, "%F %T", localtime(&unixTime));
 
     LogVerbatim("CTPPSIncludeAlignmentsFromXML")
       << ">> CTPPSIncludeAlignmentsFromXML::setIntervalFor(" << key.name() << ")";
 
     LogVerbatim("CTPPSIncludeAlignmentsFromXML")
       << "    event=" << iosv.eventID() << ", UNIX timestamp=" << unixTime << " (" << timeStr << ")";
   }
 
   // determine what sequence and corrections should be used
   RPAlignmentCorrectionsDataSequence *p_seq = nullptr;
   RPAlignmentCorrectionsData *p_corr = nullptr;
 
   if (strcmp(key.name(), "RPMeasuredAlignmentRecord") == 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_seq == nullptr)
     throw cms::Exception("CTPPSIncludeAlignmentsFromXML::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("CTPPSIncludeAlignmentsFromXML")
           << "    setting validity interval ["
           << RPAlignmentCorrectionsMethods::iovValueToString(valInt.first())
           << ", " << RPAlignmentCorrectionsMethods::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 = RPAlignmentCorrectionsData();
 
   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("CTPPSIncludeAlignmentsFromXML")
       << "    setting validity interval ["
       << RPAlignmentCorrectionsMethods::iovValueToString(valInt.first())
       << ", " << RPAlignmentCorrectionsMethods::iovValueToString(valInt.last()) << "] (empty alignment corrections)";
   }
 }