A class adding (mis)alignments to geometry (both real and misaligned). More...

Inheritance diagram for TotemRPIncludeAlignments:

Public Member Functions
std::auto_ptr < RPAlignmentCorrectionsData >	produceMeasured (const RPMeasuredAlignmentRecord &)

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

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

	TotemRPIncludeAlignments (const edm::ParameterSet &p)

virtual	~TotemRPIncludeAlignments ()

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

virtual	~ESProducer ()

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

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

virtual	~ESProxyFactoryProducer ()

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 ()

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 ()

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...

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

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::auto_ptr< TFactory > iFactory, const std::string &iLabel=std::string())

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

virtual void	registerProxies (const eventsetup::EventSetupRecordKey &iRecord, KeyedProxies &aProxyList)
	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

A class adding (mis)alignments to geometry (both real and misaligned).

See schema of TOTEM RP geometry classes

Definition at line 34 of file TotemRPIncludeAlignments.cc.

Constructor & Destructor Documentation

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

Definition at line 66 of file TotemRPIncludeAlignments.cc.

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

                                                                               :
   verbosity(pSet.getUntrackedParameter<unsigned int>("verbosity", 1))
 {
   PrepareSequence("Measured", acsMeasured, pSet.getParameter< vector<string> >("MeasuredFiles"));
   PrepareSequence("Real", acsReal, pSet.getParameter< vector<string> >("RealFiles"));
   PrepareSequence("Misaligned", acsMisaligned, pSet.getParameter< vector<string> >("MisalignedFiles"));
 
   setWhatProduced(this, &TotemRPIncludeAlignments::produceMeasured);
   setWhatProduced(this, &TotemRPIncludeAlignments::produceReal);
   setWhatProduced(this, &TotemRPIncludeAlignments::produceMisaligned);
   
   findingRecord<RPMeasuredAlignmentRecord>();
   findingRecord<RPRealAlignmentRecord>();
   findingRecord<RPMisalignedAlignmentRecord>();
 }

TotemRPIncludeAlignments::~TotemRPIncludeAlignments ( )

virtual

Definition at line 84 of file TotemRPIncludeAlignments.cc.

85 {

86 }

Member Function Documentation

RPAlignmentCorrectionsDataSequence TotemRPIncludeAlignments::Merge ( const std::vector< RPAlignmentCorrectionsDataSequence > files ) const

protected

merges an array of sequences to one

Definition at line 90 of file TotemRPIncludeAlignments.cc.

References Clusterizer1DCommons::add(), corr, delta, TimeValidityInterval::EndOfTime(), TimeValidityInterval::first, TimeValidityInterval::last, mps_fire::result, TimeValidityInterval::ValueToUNIXString(), and verbosity.

Referenced by PrepareSequence().

 {
   // find interval boundaries
   map< TimeValue_t, vector< pair<bool, const RPAlignmentCorrectionsData*> > > bounds;
 
   for (vector<RPAlignmentCorrectionsDataSequence>::const_iterator fit = files.begin(); fit != files.end(); ++fit)
   {
     for (RPAlignmentCorrectionsDataSequence::const_iterator iit = fit->begin(); iit != fit->end(); ++iit)
     {
       const TimeValidityInterval &tvi = iit->first;
       const RPAlignmentCorrectionsData *corr = & iit->second;
 
       bounds[tvi.first].push_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].push_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 (vector< pair<bool, const RPAlignmentCorrectionsData*> >::const_iterator cit = tit->second.begin(); cit != tit->second.end(); ++cit)
     {
       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 (set<const RPAlignmentCorrectionsData*>::iterator sit = accumulator.begin(); sit != accumulator.end(); ++sit)
       result[tvi].AddCorrections(*(*sit));
   }
 
   return result;
 }

void TotemRPIncludeAlignments::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 TotemRPIncludeAlignments.cc.

References i, Merge(), and verbosity.

Referenced by TotemRPIncludeAlignments().

 {
   if (verbosity)
     printf(">> TotemRPIncludeAlignments::PrepareSequence(%s)\n", label.c_str());
 
   vector<RPAlignmentCorrectionsDataSequence> sequences;
   for (unsigned int i = 0; i < files.size(); i++)
     sequences.push_back(RPAlignmentCorrectionsDataSequence(files[i]));
 
   seq = Merge(sequences);
 }

std::auto_ptr< RPAlignmentCorrectionsData > TotemRPIncludeAlignments::produceMeasured ( const RPMeasuredAlignmentRecord & iRecord )

Definition at line 166 of file TotemRPIncludeAlignments.cc.

References acMeasured.

Referenced by TotemRPIncludeAlignments().

 {
   std::auto_ptr<RPAlignmentCorrectionsData> alignments(new RPAlignmentCorrectionsData(acMeasured));
   return alignments;
 }

std::auto_ptr< RPAlignmentCorrectionsData > TotemRPIncludeAlignments::produceMisaligned ( const RPMisalignedAlignmentRecord & iRecord )

Definition at line 182 of file TotemRPIncludeAlignments.cc.

References acMisaligned.

Referenced by TotemRPIncludeAlignments().

 {
   std::auto_ptr<RPAlignmentCorrectionsData> alignments(new RPAlignmentCorrectionsData(acMisaligned));
   return alignments;
 }

std::auto_ptr< RPAlignmentCorrectionsData > TotemRPIncludeAlignments::produceReal ( const RPRealAlignmentRecord & iRecord )

Definition at line 174 of file TotemRPIncludeAlignments.cc.

References acReal.

Referenced by TotemRPIncludeAlignments().

 {
   std::auto_ptr<RPAlignmentCorrectionsData> alignments(new RPAlignmentCorrectionsData(acReal));
   return alignments;
 }

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

protectedvirtual

Implements edm::EventSetupRecordIntervalFinder.

Definition at line 190 of file TotemRPIncludeAlignments.cc.

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

 {
   if (verbosity)
   {
     LogVerbatim("TotemRPIncludeAlignments")
       << ">> TotemRPIncludeAlignments::setIntervalFor(" << key.name() << ")";
 
     time_t unixTime = iosv.time().unixTime();
     char timeStr[50];
     strftime(timeStr, 50, "%F %T", localtime(&unixTime));
 
     LogVerbatim("TotemRPIncludeAlignments")
       << "    run=" << iosv.eventID().run() << ", event=" << iosv.eventID().event() << ", UNIX timestamp=" << unixTime << " (" << timeStr << ")";
   }
 
   // determine what sequence and corrections should be used
   RPAlignmentCorrectionsDataSequence *seq = NULL;
   RPAlignmentCorrectionsData *corr = NULL;
 
   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 == NULL)
     throw cms::Exception("TotemRPIncludeAlignments::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 (RPAlignmentCorrectionsDataSequence::iterator it = seq->begin(); it != seq->end(); ++it)
   {
     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("TotemRPIncludeAlignments")
           << "    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("TotemRPIncludeAlignments")
       << "    setting validity interval [" << TimeValidityInterval::ValueToUNIXString(valInt.first().time().value())
       << ", " << TimeValidityInterval::ValueToUNIXString(valInt.last().time().value()) << "]";
   }
 }