Inheritance diagram for CTPPSIncludeAlignments:

Public Member Functions
	CTPPSIncludeAlignments (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 &)

	~CTPPSIncludeAlignments () 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 &)

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 31 of file CTPPSIncludeAlignments.cc.

Constructor & Destructor Documentation

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

Definition at line 63 of file CTPPSIncludeAlignments.cc.

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

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

CTPPSIncludeAlignments::~CTPPSIncludeAlignments ( )

override

Definition at line 84 of file CTPPSIncludeAlignments.cc.

85 {

86 }

Member Function Documentation

RPAlignmentCorrectionsDataSequence CTPPSIncludeAlignments::Merge ( const std::vector< RPAlignmentCorrectionsDataSequence > & files ) const

protected

merges an array of sequences to one

Definition at line 90 of file CTPPSIncludeAlignments.cc.

References PVValHelper::add(), corr, delta, TimeValidityInterval::EndOfTime(), FrontierConditions_GlobalTag_cff::file, TimeValidityInterval::first, TimeValidityInterval::last, genParticles_cff::map, mps_fire::result, TimeValidityInterval::ValueToUNIXString(), and verbosity.

Referenced by PrepareSequence().

 {
   // find interval boundaries
   map< TimeValue_t, vector< pair<bool, const RPAlignmentCorrectionsData*> > > bounds;
 
   for (const auto & file : files)
   {
     for (RPAlignmentCorrectionsDataSequence::const_iterator iit = file.begin(); iit != file.end(); ++iit)
     {
       const TimeValidityInterval &tvi = iit->first;
       const RPAlignmentCorrectionsData *corr = & iit->second;
 
       bounds[tvi.first].emplace_back( pair<bool, const RPAlignmentCorrectionsData*>(true, corr) );
 
       TimeValue_t delta = (tvi.last != TimeValidityInterval::EndOfTime()) ? (1ULL << 32) : 0;  // input resolution is 1s
       bounds[tvi.last + delta].emplace_back( pair<bool, const RPAlignmentCorrectionsData*>(false, corr) );
     }
   }
   
   // build correction sums per interval
   set<const RPAlignmentCorrectionsData*> accumulator;
   RPAlignmentCorrectionsDataSequence result;
   //  bool gap_found = false;
   for (map< TimeValue_t, 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);
     }
     
     map< TimeValue_t, vector< pair<bool, const RPAlignmentCorrectionsData*> > >::const_iterator tit_next = tit;
     tit_next++;
     if (tit_next == bounds.end())
       break;
 
     TimeValue_t delta = (tit_next->first != TimeValidityInterval::EndOfTime()) ? 1 : 0; // minimal step
     TimeValidityInterval tvi(tit->first, tit_next->first - delta);
 
     if (verbosity)
     {
       printf("\tfirst=%10s, last=%10s: alignment blocks=%li\n",
         TimeValidityInterval::ValueToUNIXString(tvi.first).c_str(),
         TimeValidityInterval::ValueToUNIXString(tvi.last).c_str(),
         accumulator.size()
       );
     }
 
     for (auto sit : accumulator)
       result[tvi].addCorrections(*sit);
   }
 
   return result;
 }

void CTPPSIncludeAlignments::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 152 of file CTPPSIncludeAlignments.cc.

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

Referenced by CTPPSIncludeAlignments().

 {
   if (verbosity)
     printf(">> CTPPSIncludeAlignments::PrepareSequence(%s)\n", label.c_str());
 
   vector<RPAlignmentCorrectionsDataSequence> sequences;
   for (const auto & file : files)
     sequences.emplace_back(RPAlignmentCorrectionsDataSequence(file));
 
   seq = Merge(sequences);
 }

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

Definition at line 166 of file CTPPSIncludeAlignments.cc.

References acMeasured.

Referenced by CTPPSIncludeAlignments().

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

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

Definition at line 180 of file CTPPSIncludeAlignments.cc.

References acMisaligned.

Referenced by CTPPSIncludeAlignments().

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

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

Definition at line 173 of file CTPPSIncludeAlignments.cc.

References acReal.

Referenced by CTPPSIncludeAlignments().

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

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

overrideprotectedvirtual

Implements edm::EventSetupRecordIntervalFinder.

Definition at line 187 of file CTPPSIncludeAlignments.cc.

References acMeasured, acMisaligned, acReal, acsMeasured, acsMisaligned, acsReal, corr, DEFINE_FWK_EVENTSETUP_SOURCE, TimeValidityInterval::EndOfTime(), edm::IOVSyncValue::endOfTime(), edm::EventID::event(), edm::IOVSyncValue::eventID(), Exception, edm::ValidityInterval::first(), edm::ValidityInterval::last(), min(), edm::eventsetup::EventSetupRecordKey::name(), edm::EventID::run(), lumiQTWidget::t, edm::IOVSyncValue::time(), edm::Timestamp::unixTime(), edm::Timestamp::value(), TimeValidityInterval::ValueToUNIXString(), and verbosity.

 {
   if (verbosity)
   {
     LogVerbatim("CTPPSIncludeAlignments")
       << ">> CTPPSIncludeAlignments::setIntervalFor(" << key.name() << ")";
 
     time_t unixTime = iosv.time().unixTime();
     char timeStr[50];
     strftime(timeStr, 50, "%F %T", localtime(&unixTime));
 
     LogVerbatim("CTPPSIncludeAlignments")
       << "    run=" << iosv.eventID().run() << ", event=" << iosv.eventID().event() << ", UNIX timestamp=" << unixTime << " (" << timeStr << ")";
   }
 
   // determine what sequence and corrections should be used
   RPAlignmentCorrectionsDataSequence *seq = nullptr;
   RPAlignmentCorrectionsData *corr = nullptr;
 
   if (strcmp(key.name(), "RPMeasuredAlignmentRecord") == 0)
   {
     seq = &acsMeasured;
     corr = &acMeasured;
   }
 
   if (strcmp(key.name(), "RPRealAlignmentRecord") == 0)
   {
     seq = &acsReal;
     corr = &acReal;
   }
 
   if (strcmp(key.name(), "RPMisalignedAlignmentRecord") == 0)
   {
     seq = &acsMisaligned;
     corr = &acMisaligned;
   }
 
   if (seq == nullptr)
     throw cms::Exception("CTPPSIncludeAlignments::setIntervalFor") << "Unknown record " << key.name();
 
   // find the corresponding time interval
   bool next_exists = false;
   TimeValue_t t = iosv.time().value(), next_start = TimeValidityInterval::EndOfTime();
 
   for (auto & it : *seq)
   {
     if (it.first.first <= t && it.first.last >= t)
     {
       valInt = ValidityInterval(IOVSyncValue(Timestamp(it.first.first)), IOVSyncValue(Timestamp(it.first.last)));
       *corr = it.second;
 
       if (verbosity)
       {
         LogVerbatim("CTPPSIncludeAlignments")
           << "    setting validity interval [" << TimeValidityInterval::ValueToUNIXString(valInt.first().time().value())
           << ", " << TimeValidityInterval::ValueToUNIXString(valInt.last().time().value()) << "]";
       }
 
       return;
     }
 
     if (t <= it.first.first)
     {
       next_exists = true;
       next_start = min(next_start, it.first.first);
     }
   }
     
   // no interval found, set empty corrections
   *corr = RPAlignmentCorrectionsData();
 
   if (!next_exists)
     valInt = ValidityInterval(iosv, iosv.endOfTime());
   else 
     valInt = ValidityInterval(iosv, IOVSyncValue(Timestamp(next_start - 1)));
   
   if (verbosity)
   {
     LogVerbatim("CTPPSIncludeAlignments")
       << "    setting validity interval [" << TimeValidityInterval::ValueToUNIXString(valInt.first().time().value())
       << ", " << TimeValidityInterval::ValueToUNIXString(valInt.last().time().value()) << "]";
   }
 }