#include <RunRangeDependentPedeLabeler.h>

Inheritance diagram for RunRangeDependentPedeLabeler:

Public Member Functions
Alignable *	alignableFromLabel (unsigned int label) const override

unsigned int	alignableLabel (Alignable *alignable) const override
	Return 32-bit unique label for alignable, 0 indicates failure. More...

unsigned int	alignableLabelFromLabel (unsigned int label) const override
	alignable label from parameter label (works also for alignable label...) More...

unsigned int	alignableLabelFromParamAndInstance (Alignable *alignable, unsigned int param, unsigned int instance) const override

bool	hasSplitParameters (Alignable *alignable) const override
	returns true if the alignable has parameters that are split into various bins More...

unsigned int	lasBeamIdFromLabel (unsigned int label) const override

unsigned int	lasBeamLabel (unsigned int lasBeamId) const override

unsigned int	maxNumberOfParameterInstances () const override
	returns the maximum number of instances for any parameter of an Alignable* More...

unsigned int	numberOfParameterInstances (Alignable *alignable, int param=-1) const override
	returns the number of instances for a given parameter More...

unsigned int	parameterLabel (unsigned int aliLabel, unsigned int parNum) const override
	returns the label for a given alignable parameter number combination More...

unsigned int	parameterLabel (Alignable *alignable, unsigned int parNum, const AlignmentAlgorithmBase::EventInfo &eventInfo, const TrajectoryStateOnSurface &tsos) const override

unsigned int	paramNumFromLabel (unsigned int paramLabel) const override
	parameter number, 0 <= .. < theMaxNumParam, belonging to unique parameter label More...

	RunRangeDependentPedeLabeler (const PedeLabelerBase::TopLevelAlignables &alignables, const edm::ParameterSet &config)
	constructor from three Alignables (null pointers allowed ) More...

const RunRange &	runRangeFromLabel (unsigned int label) const override

	~RunRangeDependentPedeLabeler () override

Public Member Functions inherited from PedeLabelerBase
virtual void	addCalibrations (const std::vector< IntegratedCalibrationBase * > &iCals)
	tell labeler to treat also integrated calibrations More...

const AlignableExtras *	alignableExtras () const

const AlignableMuon *	alignableMuon () const

const AlignableTracker *	alignableTracker () const

virtual unsigned int	calibrationLabel (const IntegratedCalibrationBase *calib, unsigned int paramNum) const
	label for parameter 'paramNum' (counted from 0) of an integrated calibration More...

virtual std::pair< IntegratedCalibrationBase *, unsigned int >	calibrationParamFromLabel (unsigned int label) const

virtual unsigned int	firstFreeLabel () const

unsigned int	parameterInstanceOffset () const
	offset in labels between consecutive parameter instances of Alignable*s More...

	PedeLabelerBase (const TopLevelAlignables &alignables, const edm::ParameterSet &config)
	constructor from three Alignables (null pointers allowed ) More...

virtual	~PedeLabelerBase ()

Private Types
typedef std::map< Alignable *, unsigned int >	AlignableToIdMap

typedef AlignableToIdMap::value_type	AlignableToIdPair

typedef std::map< Alignable *, RunRangeParamMap >	AlignableToRunRangeRangeMap

typedef AlignableToRunRangeRangeMap::value_type	AlignableToRunRangeRangePair

typedef std::map< unsigned int, Alignable * >	IdToAlignableMap

typedef std::map< unsigned int, RunRangeVector >	RunRangeParamMap

typedef std::vector< RunRange >	RunRangeVector

typedef std::map< unsigned int, unsigned int >	UintUintMap

Private Member Functions
unsigned int	buildMap (const std::vector< Alignable * > &alis)
	returns size of map More...

unsigned int	buildReverseMap ()
	returns size of map More...

unsigned int	buildRunRangeDependencyMap (AlignableTracker aliTracker, AlignableMuon aliMuon, AlignableExtras *extras, const edm::ParameterSet &config)

std::vector< unsigned int >	convertParamSel (const std::string &selString) const

std::vector< std::string >	decompose (const std::string &s, std::string::value_type delimiter) const

unsigned int	runRangeIndexFromLabel (unsigned int label) const

Private Attributes
AlignableToIdMap	theAlignableToIdMap

AlignableToRunRangeRangeMap	theAlignableToRunRangeRangeMap
	providing unique ID for alignable, space for param IDs More...

IdToAlignableMap	theIdToAlignableMap
	providing unique ID for alignable, space for param IDs More...

UintUintMap	theLabelToLasBeamMap
	labels for las beams More...

UintUintMap	theLasBeamToLabelMap
	reverse map More...

unsigned int	theMaxNumberOfParameterInstances
	reverse of the above More...

Additional Inherited Members
Public Types inherited from PedeLabelerBase
using	RunNumber = align::RunNumber

using	RunRange = align::RunRange

using	RunRanges = align::RunRanges

Static Public Attributes inherited from PedeLabelerBase
static const unsigned int	theMaxNumParam = RigidBodyAlignmentParameters::N_PARAM + 14

static const unsigned int	theMinLabel = 1

static const unsigned int	theParamInstanceOffset = 700000

Protected Member Functions inherited from PedeLabelerBase
virtual unsigned int	firstNonAlignableLabel () const

const AlignableObjectId &	objectIdProvider () const
	Return tracker alignable object ID provider derived from the tracker's geometry. More...

Protected Attributes inherited from PedeLabelerBase
const RunRange	theOpenRunRange

Detailed Description

provides labels for AlignmentParameters for pede

Author: : Gero Flucke date : September 2007

Date: 2011/02/16 13:12:41

Revision: 1.1

(last update by

Author: mussgill

)

Definition at line 31 of file RunRangeDependentPedeLabeler.h.

Member Typedef Documentation

typedef std::map<Alignable*, unsigned int> RunRangeDependentPedeLabeler::AlignableToIdMap

private

Definition at line 80 of file RunRangeDependentPedeLabeler.h.

typedef AlignableToIdMap::value_type RunRangeDependentPedeLabeler::AlignableToIdPair

private

Definition at line 81 of file RunRangeDependentPedeLabeler.h.

typedef std::map<Alignable*, RunRangeParamMap> RunRangeDependentPedeLabeler::AlignableToRunRangeRangeMap

private

Definition at line 84 of file RunRangeDependentPedeLabeler.h.

typedef AlignableToRunRangeRangeMap::value_type RunRangeDependentPedeLabeler::AlignableToRunRangeRangePair

private

Definition at line 85 of file RunRangeDependentPedeLabeler.h.

typedef std::map<unsigned int, Alignable*> RunRangeDependentPedeLabeler::IdToAlignableMap

private

Definition at line 86 of file RunRangeDependentPedeLabeler.h.

typedef std::map<unsigned int, RunRangeVector> RunRangeDependentPedeLabeler::RunRangeParamMap

private

Definition at line 83 of file RunRangeDependentPedeLabeler.h.

typedef std::vector<RunRange> RunRangeDependentPedeLabeler::RunRangeVector

private

Definition at line 82 of file RunRangeDependentPedeLabeler.h.

typedef std::map<unsigned int, unsigned int> RunRangeDependentPedeLabeler::UintUintMap

private

Definition at line 87 of file RunRangeDependentPedeLabeler.h.

Constructor & Destructor Documentation

RunRangeDependentPedeLabeler::RunRangeDependentPedeLabeler	(	const PedeLabelerBase::TopLevelAlignables &	alignables,
		const edm::ParameterSet &	config
	)

constructor from three Alignables (null pointers allowed )

Definition at line 28 of file RunRangeDependentPedeLabeler.cc.

References PedeLabelerBase::TopLevelAlignables::aliExtras_, PedeLabelerBase::TopLevelAlignables::aliMuon_, PedeLabelerBase::TopLevelAlignables::aliTracker_, buildMap(), buildReverseMap(), buildRunRangeDependencyMap(), and AlignableExtras::components().

   : PedeLabelerBase(alignables, config),
     theMaxNumberOfParameterInstances(0)
 {
   std::vector<Alignable*> alis;
   alis.push_back(alignables.aliTracker_);
   alis.push_back(alignables.aliMuon_);
 
   if (alignables.aliExtras_) {
     for (const auto& ali: alignables.aliExtras_->components()) {
       alis.push_back(ali);
     }
   }
 
   this->buildRunRangeDependencyMap(alignables.aliTracker_,
                    alignables.aliMuon_,
                    alignables.aliExtras_, 
                    config);
   this->buildMap(alis);
   this->buildReverseMap(); // needed already now to 'fill' theMaxNumberOfParameterInstances
 }

RunRangeDependentPedeLabeler::~RunRangeDependentPedeLabeler ( )

override

non-virtual destructor: do not inherit from this class

Definition at line 53 of file RunRangeDependentPedeLabeler.cc.

54 {

55 }

Member Function Documentation

Alignable * RunRangeDependentPedeLabeler::alignableFromLabel ( unsigned int label ) const

overridevirtual

Alignable from alignable or parameter label, null if no alignable (but error only if not las beam, either!)

Implements PedeLabelerBase.

Definition at line 245 of file RunRangeDependentPedeLabeler.cc.

References alignableLabelFromLabel(), position, theIdToAlignableMap, theLabelToLasBeamMap, and PedeLabelerBase::theMinLabel.

Referenced by runRangeFromLabel(), and runRangeIndexFromLabel().

 {
   const unsigned int aliLabel = this->alignableLabelFromLabel(label);
   if (aliLabel < theMinLabel) return nullptr; // error already given
   
   IdToAlignableMap::const_iterator position = theIdToAlignableMap.find(aliLabel);
   if (position != theIdToAlignableMap.end()) {
     return position->second;
   } else {
     // error only if not in lasBeamMap:
     UintUintMap::const_iterator position = theLabelToLasBeamMap.find(aliLabel);
     if (position == theLabelToLasBeamMap.end()) {
       edm::LogError("LogicError") << "@SUB=RunRangeDependentPedeLabeler::alignableFromLabel"
                   << "Alignable label " << aliLabel << " not in map.";
     }
     return nullptr;
   }
 }

unsigned int RunRangeDependentPedeLabeler::alignableLabel ( Alignable * alignable ) const

overridevirtual

Return 32-bit unique label for alignable, 0 indicates failure.

uniqueId of Alignable, 0 if alignable not known between this ID and the next there is enough 'space' to add parameter numbers 0...nPar-1 to make unique IDs for the labels of active parameters

Implements PedeLabelerBase.

Definition at line 59 of file RunRangeDependentPedeLabeler.cc.

References Alignable::alignableObjectId(), Alignable::id(), position, and theAlignableToIdMap.

Referenced by runRangeFromLabel(), and runRangeIndexFromLabel().

 {
   if (!alignable) return 0;
 
   AlignableToIdMap::const_iterator position = theAlignableToIdMap.find(alignable);
   if (position != theAlignableToIdMap.end()) {
     return position->second;
   } else {
     const DetId detId(alignable->id());
     //throw cms::Exception("LogicError") 
     edm::LogError("LogicError")
       << "@SUB=RunRangeDependentPedeLabeler::alignableLabel" << "Alignable "
       << typeid(*alignable).name() << " not in map, det/subdet/alignableStructureType = "
       << detId.det() << "/" << detId.subdetId() << "/" << alignable->alignableObjectId();
     return 0;
   }
 }

unsigned int RunRangeDependentPedeLabeler::alignableLabelFromLabel ( unsigned int label ) const

overridevirtual

alignable label from parameter label (works also for alignable label...)

Implements PedeLabelerBase.

Definition at line 239 of file RunRangeDependentPedeLabeler.cc.

References paramNumFromLabel().

Referenced by alignableFromLabel(), and lasBeamIdFromLabel().

 {
   return paramLabel - this->paramNumFromLabel(paramLabel);
 }

unsigned int RunRangeDependentPedeLabeler::alignableLabelFromParamAndInstance	(	Alignable *	alignable,
		unsigned int	param,
		unsigned int	instance
	)		const

overridevirtual

uniqueId of Alignable for a given parameter index and instance, 0 if alignable not known between this ID and the next there is enough 'space' to add parameter numbers 0...nPar-1 to make unique IDs for the labels of active parameters

Implements PedeLabelerBase.

Definition at line 79 of file RunRangeDependentPedeLabeler.cc.

References Alignable::alignableObjectId(), Exception, Alignable::id(), position, theAlignableToIdMap, theAlignableToRunRangeRangeMap, and PedeLabelerBase::theParamInstanceOffset.

 {
   if (!alignable) return 0;
   
   AlignableToIdMap::const_iterator position = theAlignableToIdMap.find(alignable);
   if (position != theAlignableToIdMap.end()) {
     AlignableToRunRangeRangeMap::const_iterator positionAli = theAlignableToRunRangeRangeMap.find(alignable);
     if (positionAli != theAlignableToRunRangeRangeMap.end()) {
       RunRangeParamMap::const_iterator positionParam = (*positionAli).second.find(param);
       if (positionParam!=(*positionAli).second.end()) {
     if (instance>=(*positionParam).second.size()) {
       throw cms::Exception("Alignment") << "RunRangeDependentPedeLabeler::alignableLabelFromParamAndRunRange: " 
                         << "RunRangeIdx out of bounds.\n";
     }
     return position->second + instance * theParamInstanceOffset;
       } else {
     return position->second;
       }
     } else {
       return position->second;
     }
   } else {
     const DetId detId(alignable->id());
     //throw cms::Exception("LogicError") 
     edm::LogError("LogicError")
       << "@SUB=RunRangeDependentPedeLabeler::alignableLabel" << "Alignable "
       << typeid(*alignable).name() << " not in map, det/subdet/alignableStructureType = "
       << detId.det() << "/" << detId.subdetId() << "/" << alignable->alignableObjectId();
     return 0;
   }
 }

unsigned int RunRangeDependentPedeLabeler::buildMap ( const std::vector< Alignable * > & alis )

private

returns size of map

Definition at line 456 of file RunRangeDependentPedeLabeler.cc.

References Exception, triggerObjects_cff::id, theAlignableToIdMap, theLasBeamToLabelMap, PedeLabelerBase::theMaxNumParam, PedeLabelerBase::theMinLabel, and PedeLabelerBase::theParamInstanceOffset.

Referenced by RunRangeDependentPedeLabeler().

 {
   theAlignableToIdMap.clear(); // just in case of re-use...
 
   std::vector<Alignable*> allComps;
   
   for (const auto& iAli: alis) {
     if (iAli) {
       allComps.push_back(iAli);
       iAli->recursiveComponents(allComps);
     }
   }
 
   unsigned int id = theMinLabel;
   for (const auto& iter: allComps) {
     theAlignableToIdMap.insert(AlignableToIdPair(iter, id));
     id += theMaxNumParam;
   }
   
   // also care about las beams
   theLasBeamToLabelMap.clear(); // just in case of re-use...
   // FIXME: Temporarily hard code values stolen from 
   // https://twiki.cern.ch/twiki/bin/view/CMS/TkLasTrackBasedInterface#Beam_identifier .
   unsigned int beamIds[] = {  0,  10,  20,  30,  40,  50,  60,  70, // TEC+ R4
                   1,  11,  21,  31,  41,  51,  61,  71, // TEC+ R6
                 100, 110, 120, 130, 140, 150, 160, 170, // TEC- R4
                 101, 111, 121, 131, 141, 151, 161, 171, // TEC- R6
                 200, 210, 220, 230, 240, 250, 260, 270};// AT
 
   const size_t nBeams = sizeof(beamIds)/sizeof(beamIds[0]);
   for (size_t iBeam = 0; iBeam < nBeams; ++iBeam) {
     //edm::LogInfo("Alignment") << "Las beam " << beamIds[iBeam] << " gets label " << id << ".";
     theLasBeamToLabelMap[beamIds[iBeam]] = id;
     id += theMaxNumParam;
   }
 
   if (id > theParamInstanceOffset) { // 'overflow' per instance
     throw cms::Exception("Alignment") << "@SUB=RunRangeDependentPedeLabeler::buildMap: " 
                                       << "Too many labels per instance (" << id-1 << ") leading to double use, "
                                       << "increase PedeLabelerBase::theParamInstanceOffset!\n";
   }
   // return combined size
   return theAlignableToIdMap.size() + theLasBeamToLabelMap.size();
 }

unsigned int RunRangeDependentPedeLabeler::buildReverseMap ( )

private

returns size of map

Definition at line 502 of file RunRangeDependentPedeLabeler.cc.

References DEFINE_EDM_PLUGIN, crabWrapper::key, SiStripPI::max, numberOfParameterInstances(), theAlignableToIdMap, theIdToAlignableMap, theLabelToLasBeamMap, theLasBeamToLabelMap, theMaxNumberOfParameterInstances, and PedeLabelerBase::theParamInstanceOffset.

Referenced by RunRangeDependentPedeLabeler().

 {
 
   // alignables
   theIdToAlignableMap.clear();  // just in case of re-use...
 
   for (const auto& it: theAlignableToIdMap) {
     const unsigned int key = it.second;
     Alignable *ali = it.first;
     const unsigned int nInstances = this->numberOfParameterInstances(ali, -1);
     theMaxNumberOfParameterInstances = std::max(nInstances, theMaxNumberOfParameterInstances);
     for (unsigned int iInstance=0;iInstance<nInstances;++iInstance) {
       theIdToAlignableMap[key+iInstance*theParamInstanceOffset] = ali;
     }
   }
   
   // las beams
   theLabelToLasBeamMap.clear(); // just in case of re-use...
 
   for (const auto& it: theLasBeamToLabelMap) {
     theLabelToLasBeamMap[it.second] = it.first; //revert key/value
   }
 
   // return combined size
   return theIdToAlignableMap.size() + theLabelToLasBeamMap.size();
 }

unsigned int RunRangeDependentPedeLabeler::buildRunRangeDependencyMap	(	AlignableTracker *	aliTracker,
		AlignableMuon *	aliMuon,
		AlignableExtras *	extras,
		const edm::ParameterSet &	config
	)

private

Definition at line 338 of file RunRangeDependentPedeLabeler.cc.

References AlignmentParameterSelector::addSelection(), cond::TimeTypeSpecs::beginValue, AlignmentParameterSelector::clear(), convertParamSel(), decompose(), Exception, plotBeamSpotDB::first, edm::ParameterSet::getUntrackedParameter(), mps_fire::i, AlignableObjectId::idToString(), PedeLabelerBase::objectIdProvider(), cond::runnumber, edm::second(), AlignmentParameterSelector::selectedAlignables(), AlignmentParameters::size(), groupFilesInBlocks::temp, theAlignableToRunRangeRangeMap, cond::timeTypeSpecs, and edm::tokenize().

Referenced by RunRangeDependentPedeLabeler().

 {
   static std::atomic<bool> oldRunRangeSelectionWarning{ false };
 
   theAlignableToRunRangeRangeMap.clear();
 
   AlignmentParameterSelector selector(aliTracker, aliMuon, aliExtras);
  
   std::vector<char> paramSelDummy(6, '1');
   
   const std::vector<edm::ParameterSet> RunRangeSelectionVPSet =
     config.getUntrackedParameter<std::vector<edm::ParameterSet> >("RunRangeSelection");
   
   for (const auto& runRangeSel: RunRangeSelectionVPSet) {
     
     const auto tempRunRanges = runRangeSel.getParameter<std::vector<std::string> >("RunRanges");
     if (tempRunRanges.empty()) {
       throw cms::Exception("BadConfig") << "@SUB=RunRangeDependentPedeLabeler::buildRunRangeDependencyMap\n"
                     << "RunRanges empty\n";
     }
 
     RunRangeVector RunRanges;
     cond::Time_t first;
     long int temp;
     for (const auto& iRunRange: tempRunRanges) {
       if (iRunRange.find(':') == std::string::npos) {
     
     first = cond::timeTypeSpecs[cond::runnumber].beginValue;
     temp = strtol(iRunRange.c_str(), nullptr, 0);
     if (temp!=-1) first = temp;
     
       } else {
     
         bool expected = false;
     if (oldRunRangeSelectionWarning.compare_exchange_strong(expected,true)) {
       edm::LogWarning("BadConfig") << "@SUB=RunRangeDependentPedeLabeler::buildRunRangeDependencyMap"
                        << "Config file contains old format for 'RunRangeSelection'. Only the start run\n"
                        << "number is used internally. The number of the last run is ignored and can be\n"
                        << "safely removed from the config file.\n";
     }
 
     std::vector<std::string> tokens = edm::tokenize(iRunRange, ":");
     first = cond::timeTypeSpecs[cond::runnumber].beginValue;
     temp = strtol(tokens[0].c_str(), nullptr, 0);
     if (temp!=-1) first = temp;
     
       }
       
       RunRanges.push_back(std::pair<cond::Time_t,cond::Time_t>(first, cond::timeTypeSpecs[cond::runnumber].endValue));
     }
     
     for (unsigned int i = 0;i<RunRanges.size()-1;++i) {
       RunRanges[i].second = RunRanges[i+1].first - 1;
       if (RunRanges[i].first > RunRanges[i].second) {
     throw cms::Exception("BadConfig") << "@SUB=RunRangeDependentPedeLabeler::buildRunRangeDependencyMap\n"
                       << "Inconsistency in 'RunRangeSelection' parameter set.";
       }
     }
     
     const auto selStrings = runRangeSel.getParameter<std::vector<std::string> >("selector");
     for (const auto& iSel: selStrings) {
       std::vector<std::string> decompSel(this->decompose(iSel, ','));
       
       if (decompSel.size()!=2) {
     throw cms::Exception("BadConfig") << "@SUB=RunRangeDependentPedeLabeler::buildRunRangeDependencyMap\n"
                       << iSel <<" should have at least 2 ','-separated parts\n";
       }
 
       std::vector<unsigned int> selParam = this->convertParamSel(decompSel[1]);
       selector.clear();
       selector.addSelection(decompSel[0], paramSelDummy);
 
       const std::vector<Alignable*> &alis = selector.selectedAlignables();
        
       for (const auto& iAli: alis) {
         
         if(iAli->alignmentParameters() == nullptr) {
           throw cms::Exception("BadConfig")
             << "@SUB=RunRangeDependentPedeLabeler::buildRunRangeDependencyMap\n"
             << "Run dependence configured for alignable of type "
             << objectIdProvider().idToString(iAli->alignableObjectId())
             << " at (" << iAli->globalPosition().x() << ","
             << iAli->globalPosition().y() << ","
             << iAli->globalPosition().z()<< "), "
             << "but that has no parameters. Please check that all run "
             << "dependent parameters are also selected for alignment.\n"; 
         }
 
     for (const auto& iParam: selParam) {
       AlignableToRunRangeRangeMap::const_iterator positionAli = theAlignableToRunRangeRangeMap.find(iAli);
       if (positionAli!=theAlignableToRunRangeRangeMap.end()) {
         
         AlignmentParameters *AliParams = (*positionAli).first->alignmentParameters();
         if (static_cast<int>(selParam[selParam.size()-1]) >= AliParams->size()) {
           throw cms::Exception("BadConfig") << "@SUB=RunRangeDependentPedeLabeler::buildRunRangeDependencyMap\n"
                         << "mismatch in number of parameters\n";
         }
         
         RunRangeParamMap::const_iterator positionParam = (*positionAli).second.find(iParam);
         if (positionParam!=(*positionAli).second.end()) {
           throw cms::Exception("BadConfig") << "@SUB=RunRangeDependentPedeLabeler::buildRunRangeDependencyMap\n"
                         << "RunRange range for parameter specified twice\n";
         }
       }
       
       theAlignableToRunRangeRangeMap[iAli][iParam] = RunRanges;
     }
       }
     }
   }
   
   return theAlignableToRunRangeRangeMap.size();
 }

std::vector< unsigned int > RunRangeDependentPedeLabeler::convertParamSel ( const std::string & selString ) const

private

Definition at line 329 of file RunRangeDependentPedeLabeler.cc.

References mps_fire::result.

Referenced by buildRunRangeDependencyMap().

 {
   std::vector<unsigned int> result;
   for (std::string::size_type pos = 0; pos < selString.size(); ++pos) {
     if (selString[pos]=='1') result.push_back(pos);
   }
   return result;
 }

std::vector< std::string > RunRangeDependentPedeLabeler::decompose	(	const std::string &	s,
		std::string::value_type	delimiter
	)		const

private

Definition at line 309 of file RunRangeDependentPedeLabeler.cc.

References mps_fire::result.

Referenced by buildRunRangeDependencyMap().

 {
   std::vector<std::string> result;
 
   std::string::size_type previousPos = 0;
   while (true) {
     const std::string::size_type delimiterPos = s.find(delimiter, previousPos);
     if (delimiterPos == std::string::npos) {
       result.push_back(s.substr(previousPos)); // until end
       break;
     }
     result.push_back(s.substr(previousPos, delimiterPos - previousPos));
     previousPos = delimiterPos + 1; // +1: skip delimiter
   }
 
   return result;
 }

bool RunRangeDependentPedeLabeler::hasSplitParameters ( Alignable * alignable ) const

overridevirtual

returns true if the alignable has parameters that are split into various bins

Implements PedeLabelerBase.

Definition at line 195 of file RunRangeDependentPedeLabeler.cc.

References theAlignableToRunRangeRangeMap.

 {
   AlignableToRunRangeRangeMap::const_iterator positionAli = theAlignableToRunRangeRangeMap.find(alignable);
   if (positionAli != theAlignableToRunRangeRangeMap.end()) return true;
   return false;
 }

unsigned int RunRangeDependentPedeLabeler::lasBeamIdFromLabel ( unsigned int label ) const

overridevirtual

las beam id from las beam or parameter label zero and error if not a valid las beam label

Implements PedeLabelerBase.

Definition at line 265 of file RunRangeDependentPedeLabeler.cc.

References alignableLabelFromLabel(), position, theLabelToLasBeamMap, and PedeLabelerBase::theMinLabel.

 {
   const unsigned int aliLabel = this->alignableLabelFromLabel(label);
   if (aliLabel < theMinLabel) return 0; // error already given
   
   UintUintMap::const_iterator position = theLabelToLasBeamMap.find(aliLabel);
   if (position != theLabelToLasBeamMap.end()) {
     return position->second;
   } else {
     edm::LogError("LogicError") << "@SUB=RunRangeDependentPedeLabeler::lasBeamIdFromLabel"
                 << "Alignable label " << aliLabel << " not in map.";
     return 0;
   }
 }

unsigned int RunRangeDependentPedeLabeler::lasBeamLabel ( unsigned int lasBeamId ) const

overridevirtual

Implements PedeLabelerBase.

Definition at line 114 of file RunRangeDependentPedeLabeler.cc.

References position, and theLasBeamToLabelMap.

 {
   UintUintMap::const_iterator position = theLasBeamToLabelMap.find(lasBeamId);
   if (position != theLasBeamToLabelMap.end()) {
     return position->second;
   } else {
     //throw cms::Exception("LogicError") 
     edm::LogError("LogicError") << "@SUB=RunRangeDependentPedeLabeler::lasBeamLabel"
                 << "No label for beam Id " << lasBeamId;
     return 0;
   }
 }

unsigned int RunRangeDependentPedeLabeler::maxNumberOfParameterInstances ( ) const

inlineoverridevirtual

returns the maximum number of instances for any parameter of an Alignable*

Implements PedeLabelerBase.

Definition at line 64 of file RunRangeDependentPedeLabeler.h.

References diffTwoXMLs::label.

64 { return theMaxNumberOfParameterInstances; }

RunRangeDependentPedeLabeler::theMaxNumberOfParameterInstances

unsigned int theMaxNumberOfParameterInstances

reverse of the above

Definition: RunRangeDependentPedeLabeler.h:108

unsigned int RunRangeDependentPedeLabeler::numberOfParameterInstances	(	Alignable *	alignable,
		int	param = `-1`
	)		const

overridevirtual

returns the number of instances for a given parameter

Implements PedeLabelerBase.

Definition at line 203 of file RunRangeDependentPedeLabeler.cc.

References SiStripPI::max, and theAlignableToRunRangeRangeMap.

Referenced by buildReverseMap().

 {
   AlignableToRunRangeRangeMap::const_iterator positionAli = theAlignableToRunRangeRangeMap.find(alignable);
   if (positionAli != theAlignableToRunRangeRangeMap.end()) {
 
     size_t nRunRanges = 1;
     if (param==-1) {
       for (const auto iParam: (*positionAli).second) {
     nRunRanges = std::max(nRunRanges, iParam.second.size());
       }
       return nRunRanges;
     } else {
       RunRangeParamMap::const_iterator iParam = (*positionAli).second.find(param);
       if (iParam != (*positionAli).second.end()) {
     return iParam->second.size();
       } else {
     return 1;
       }
     }
   }
   
   return 1;
 }

unsigned int RunRangeDependentPedeLabeler::parameterLabel	(	unsigned int	aliLabel,
		unsigned int	parNum
	)		const

overridevirtual

returns the label for a given alignable parameter number combination

Implements PedeLabelerBase.

Definition at line 128 of file RunRangeDependentPedeLabeler.cc.

References Exception, and PedeLabelerBase::theMaxNumParam.

 {
   if (parNum >= theMaxNumParam) {
     throw cms::Exception("Alignment") << "@SUB=RunRangeDependentPedeLabeler::parameterLabel" 
                                       << "Parameter number " << parNum 
                                       << " out of range 0 <= num < " << theMaxNumParam;
   }
   return aliLabel + parNum;
 }

unsigned int RunRangeDependentPedeLabeler::parameterLabel	(	Alignable *	alignable,
		unsigned int	parNum,
		const AlignmentAlgorithmBase::EventInfo &	eventInfo,
		const TrajectoryStateOnSurface &	tsos
	)		const

overridevirtual

returns the label for a given alignable parameter number combination in case the parameters are split into v

Implements PedeLabelerBase.

Definition at line 139 of file RunRangeDependentPedeLabeler.cc.

References Alignable::alignableObjectId(), AlignmentAlgorithmBase::EventInfo::eventId(), Exception, Alignable::id(), PFRecoTauDiscriminationByIsolation_cfi::offset, position, edm::EventID::run(), theAlignableToIdMap, theAlignableToRunRangeRangeMap, PedeLabelerBase::theMaxNumParam, and PedeLabelerBase::theParamInstanceOffset.

 {
   if (!alignable) return 0;
   
   if (parNum >= theMaxNumParam) {
     throw cms::Exception("Alignment") << "@SUB=RunRangeDependentPedeLabeler::parameterLabel" 
                                       << "Parameter number " << parNum 
                                       << " out of range 0 <= num < " << theMaxNumParam;
   }
   
   AlignableToIdMap::const_iterator position = theAlignableToIdMap.find(alignable);
   if (position != theAlignableToIdMap.end()) {
 
     AlignableToRunRangeRangeMap::const_iterator positionAli = theAlignableToRunRangeRangeMap.find(alignable);
     if (positionAli != theAlignableToRunRangeRangeMap.end()) {
       
       RunRangeParamMap::const_iterator positionParam = (*positionAli).second.find(parNum);
       if (positionParam!=(*positionAli).second.end()) {
     
     int offset = 0;
     const RunRangeVector & runRanges = (*positionParam).second;
     for (const auto& iRunRange: runRanges) {
       if (eventInfo.eventId().run() >= iRunRange.first &&
           eventInfo.eventId().run() <= iRunRange.second) {
         return position->second + offset * theParamInstanceOffset + parNum;
       }
       offset++;
     }
     const DetId detId(alignable->id());
     edm::LogError("LogicError")
       << "@SUB=RunRangeDependentPedeLabeler::parameterLabel" << "Instance for Alignable "
       << typeid(*alignable).name() << " not in map, det/subdet/alignableStructureType = "
       << detId.det() << "/" << detId.subdetId() << "/" << alignable->alignableObjectId()
       << " for run " << eventInfo.eventId().run();
     return 0;
       } else {
     return position->second + parNum;
       }
 
     } else {
       return position->second + parNum;
     }
   } else {
     const DetId detId(alignable->id());
     //throw cms::Exception("LogicError") 
     edm::LogError("LogicError")
       << "@SUB=RunRangeDependentPedeLabeler::parameterLabel" << "Alignable "
       << typeid(*alignable).name() << " not in map, det/subdet/alignableStructureType = "
       << detId.det() << "/" << detId.subdetId() << "/" << alignable->alignableObjectId();
     return 0;
   } 
 }

unsigned int RunRangeDependentPedeLabeler::paramNumFromLabel ( unsigned int paramLabel ) const

overridevirtual

parameter number, 0 <= .. < theMaxNumParam, belonging to unique parameter label

Implements PedeLabelerBase.

Definition at line 228 of file RunRangeDependentPedeLabeler.cc.

References PedeLabelerBase::theMaxNumParam, and PedeLabelerBase::theMinLabel.

Referenced by alignableLabelFromLabel(), and runRangeFromLabel().

 {
   if (paramLabel < theMinLabel) {
     edm::LogError("LogicError") << "@SUB=RunRangeDependentPedeLabeler::paramNumFromLabel"
                                 << "Label " << paramLabel << " should be >= " << theMinLabel;
     return 0;
   }
   return (paramLabel - theMinLabel) % theMaxNumParam;
 }

const RunRangeDependentPedeLabeler::RunRange & RunRangeDependentPedeLabeler::runRangeFromLabel ( unsigned int label ) const

overridevirtual

Reimplemented from PedeLabelerBase.

Definition at line 288 of file RunRangeDependentPedeLabeler.cc.

References alignableFromLabel(), alignableLabel(), paramNumFromLabel(), theAlignableToRunRangeRangeMap, PedeLabelerBase::theOpenRunRange, and PedeLabelerBase::theParamInstanceOffset.

 {
   Alignable* ali = alignableFromLabel(label);
 
   AlignableToRunRangeRangeMap::const_iterator positionAli = theAlignableToRunRangeRangeMap.find(ali);
   if (positionAli==theAlignableToRunRangeRangeMap.end())
     return theOpenRunRange;
   
   unsigned int firstLabel = alignableLabel(ali);
   unsigned int runRangeIndex = (label-firstLabel)/theParamInstanceOffset;
   unsigned int paramNum = this->paramNumFromLabel(label);
 
   RunRangeParamMap::const_iterator positionParam = (*positionAli).second.find(paramNum);
   if (positionParam==(*positionAli).second.end()) {
     return theOpenRunRange;
   }
   
   return positionParam->second[runRangeIndex];
 }

unsigned int RunRangeDependentPedeLabeler::runRangeIndexFromLabel ( unsigned int label ) const

private

Definition at line 280 of file RunRangeDependentPedeLabeler.cc.

References alignableFromLabel(), alignableLabel(), and PedeLabelerBase::theMaxNumParam.

 {
   Alignable* ali = alignableFromLabel(label);
   unsigned int firstLabel = alignableLabel(ali);
   return (label-firstLabel)/theMaxNumParam;
 }

Member Data Documentation

AlignableToIdMap RunRangeDependentPedeLabeler::theAlignableToIdMap

private

Definition at line 103 of file RunRangeDependentPedeLabeler.h.

Referenced by alignableLabel(), alignableLabelFromParamAndInstance(), buildMap(), buildReverseMap(), and parameterLabel().

AlignableToRunRangeRangeMap RunRangeDependentPedeLabeler::theAlignableToRunRangeRangeMap

private

providing unique ID for alignable, space for param IDs

Definition at line 104 of file RunRangeDependentPedeLabeler.h.

Referenced by alignableLabelFromParamAndInstance(), buildRunRangeDependencyMap(), hasSplitParameters(), numberOfParameterInstances(), parameterLabel(), and runRangeFromLabel().

IdToAlignableMap RunRangeDependentPedeLabeler::theIdToAlignableMap

private

providing unique ID for alignable, space for param IDs

Definition at line 105 of file RunRangeDependentPedeLabeler.h.

Referenced by alignableFromLabel(), and buildReverseMap().

UintUintMap RunRangeDependentPedeLabeler::theLabelToLasBeamMap

private

labels for las beams

Definition at line 107 of file RunRangeDependentPedeLabeler.h.

Referenced by alignableFromLabel(), buildReverseMap(), and lasBeamIdFromLabel().

UintUintMap RunRangeDependentPedeLabeler::theLasBeamToLabelMap

private

reverse map

Definition at line 106 of file RunRangeDependentPedeLabeler.h.

Referenced by buildMap(), buildReverseMap(), and lasBeamLabel().

unsigned int RunRangeDependentPedeLabeler::theMaxNumberOfParameterInstances

private

reverse of the above

Definition at line 108 of file RunRangeDependentPedeLabeler.h.

Referenced by buildReverseMap().

Public Member Functions

Private Types

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation