#include <AlignableCompositeBuilder.h>

Public Member Functions
void	addAlignmentLevel (std::unique_ptr< AlignmentLevel > level)

	AlignableCompositeBuilder (const TrackerTopology , const TrackerGeometry , const AlignableIndexer &)

unsigned int	buildAll (AlignableMap &, bool update=false)

void	clearAlignmentLevels ()
	Resets the alignment-levels. More...

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

virtual	~AlignableCompositeBuilder ()=default

Private Member Functions
unsigned int	buildLevel (unsigned int parentLevel, AlignableMap &, std::ostringstream &, bool update=false)
	Builds the components for a given level in the hierarchy. More...

unsigned int	getIndexOfStructure (align::ID, unsigned int level) const

unsigned int	maxNumComponents (unsigned int startLevel) const

Private Attributes
AlignableIndexer	alignableIndexer_

const AlignableObjectId	alignableObjectId_

align::AlignmentLevels	alignmentLevels_

const TrackerTopology *	trackerTopology_

Detailed Description

Definition at line 16 of file AlignableCompositeBuilder.h.

Constructor & Destructor Documentation

AlignableCompositeBuilder::AlignableCompositeBuilder	(	const TrackerTopology *	trackerTopology,
		const TrackerGeometry *	trackerGeometry,
		const AlignableIndexer &	alignableIndexer
	)

Definition at line 20 of file AlignableCompositeBuilder.cc.

References addAlignmentLevel().

                                                                       :
   trackerTopology_(trackerTopology),
   alignableObjectId_(trackerGeometry, nullptr, nullptr),
   alignableIndexer_(alignableIndexer)
 {
 }

virtual AlignableCompositeBuilder::~AlignableCompositeBuilder ( )

virtualdefault

Member Function Documentation

void AlignableCompositeBuilder::addAlignmentLevel ( std::unique_ptr< AlignmentLevel > level )

Add all desired AlignmentLevels for a sub-detector to the builder before calling buildAll(), the order matters! Example for PixelBarrel-RunI geometry: -> PXBModule, PXBLadder, TPBLayer, TPBHalfBarrel, TPBBarrel

Definition at line 31 of file AlignableCompositeBuilder.cc.

References clearAlignmentLevels(), and eostools::move().

Referenced by AlignableCompositeBuilder(), and AlignableTrackerBuilder::buildAlignableComposites().

                                                        {
   alignmentLevels_.push_back(std::move(level));
 }

unsigned int AlignableCompositeBuilder::buildAll	(	AlignableMap &	alignableMap,
		bool	update = `false`
	)

Builds all composite Alignables according to the levels added before via addAlignmentLevel(). The Alignables were built from bottom- to the top- hierarchy, e.g. for PixelBarrel-RunI geometry:

PXBLadder (with PXBModule as children)
TPBLayer (with PXBLadder as children)
TPBHalfBarrel (with TPBLayer as children)
TPBBarrel (with TPBHalfBarrel as children) Returns the number of composite Alignables which were built.

Definition at line 43 of file AlignableCompositeBuilder.cc.

References buildLevel(), and hcalDigis_cfi::level.

Referenced by clearAlignmentLevels().

 {
   auto highestLevel = alignmentLevels_.back()->levelType;
 
   std::ostringstream ss;
   ss << "building CompositeAlignables for "
      << alignableObjectId_.idToString(highestLevel) << "\n";
 
   unsigned int numCompositeAlignables = 0;
   for (unsigned int level = 1; level < alignmentLevels_.size(); ++level) {
     numCompositeAlignables += buildLevel(level, alignableMap, ss, update);
   }
 
   ss << "built " << numCompositeAlignables << " CompositeAlignables for "
      << alignableObjectId_.idToString(highestLevel);
   edm::LogInfo("AlignableBuildProcess")
     << "@SUB=AlignableCompositeBuilder::buildAll" << ss.str();
 
   return numCompositeAlignables;
 }

unsigned int AlignableCompositeBuilder::buildLevel	(	unsigned int	parentLevel,
		AlignableMap &	alignableMap,
		std::ostringstream &	ss,
		bool	update = `false`
	)

private

Builds the components for a given level in the hierarchy.

Definition at line 72 of file AlignableCompositeBuilder.cc.

References class-composition::children, Exception, AlignableMap::find(), AlignableMap::get(), diffTreeTool::index, maxNumComponents(), class-composition::parent, and parents.

Referenced by buildAll(), and objectIdProvider().

 {
   unsigned int childLevel    = parentLevel - 1;
   unsigned int maxNumParents = maxNumComponents(parentLevel);
 
   auto childType  = alignmentLevels_[childLevel] ->levelType;
   auto parentType = alignmentLevels_[parentLevel]->levelType;
 
   auto& children = alignableMap.find(alignableObjectId_.idToString(childType));
   auto& parents  = alignableMap.get (alignableObjectId_.idToString(parentType));
   if (!update) parents.reserve(maxNumParents);
 
   // This vector is used indicate if a parent already exists. It is initialized
   // with 'naked' Alignables-pointers; if the pointer is not naked (!= nullptr)
   // for one of the child-IDs, its parent was already built before.
   Alignables tmpParents(maxNumParents, nullptr);
 
   for (auto* child: children) {
     // get the number of the child-Alignable ...
     const auto index = getIndexOfStructure(child->id(), parentLevel);
     // ... and use it as index to get the parent of this child
     auto& parent = tmpParents[index];
 
     // if parent was not built yet ...
     if (!parent && !update) {
       if (update) {
     throw cms::Exception("LogicError")
       << "@SUB=AlignableCompositeBuilder::buildLevel\n"
       << "trying to update a non-existing AlignableComposite";
       }
       // ... build new composite Alignable with ID of child (obviously its the
       // first child of the Alignable)
       if (alignmentLevels_[parentLevel]->isFlat) {
         parent = new AlignableComposite(child->id(), parentType,
                                         child->globalRotation());
       } else {
         parent = new AlignableComposite(child->id(), parentType,
                                         align::RotationType());
       }
       parents.push_back(parent);
     } else if (update) {
       if (alignmentLevels_[parentLevel]->isFlat) {
         // needed to update rotation of flat composites
     auto mother = dynamic_cast<AlignableComposite*>(child->mother());
     if (!mother) {
       throw cms::Exception("LogicError")
         << "@SUB=AlignableCompositeBuilder::buildLevel\n"
         << "trying to update a flat composite that is not of type "
         << "AlignableComposite";
     }
     if (mother->id() == child->id()) {
       mother->update(child->id(), parentType, child->globalRotation());
     }
       }
     }
 
     // in all cases (except updates) add the child to the parent Alignable
     if (!update) parent->addComponent(child);
   }
 
   ss << "   built " << parents.size() << " "
      << alignableObjectId_.idToString(alignmentLevels_[parentLevel]->levelType)
      << "(s) (theoretical maximum: " << maxNumParents
      << ") consisting of " << children.size() << " "
      << alignableObjectId_.idToString(alignmentLevels_[childLevel]->levelType)
      << "(s)\n";
 
   return parents.size();
 }

void AlignableCompositeBuilder::clearAlignmentLevels ( )

Resets the alignment-levels.

Definition at line 37 of file AlignableCompositeBuilder.cc.

References buildAll().

Referenced by addAlignmentLevel().

                        {
   alignmentLevels_.clear();
 }

unsigned int AlignableCompositeBuilder::getIndexOfStructure	(	align::ID	id,
		unsigned int	level
	)		const

private

Calculates the index of an Alignable within the hierarchy; unique for each component of a given structure-type.

Definition at line 162 of file AlignableCompositeBuilder.cc.

References hcalDigis_cfi::level.

Referenced by maxNumComponents(), and objectIdProvider().

 {
   // indexer returns a function pointer for the structure-type
   auto indexOf = alignableIndexer_.get(alignmentLevels_[level]->levelType,
                                        alignableObjectId_);
 
   if (alignmentLevels_.size() - 1 > level) {
     return getIndexOfStructure(id, level + 1)
              * alignmentLevels_[level]->maxNumComponents
              + indexOf(id) - 1;
   }
 
   return indexOf(id) - 1;
 }

unsigned int AlignableCompositeBuilder::maxNumComponents ( unsigned int startLevel ) const

private

Calculates the theoretical max. number of components for a given level in the hierarchy.

Definition at line 147 of file AlignableCompositeBuilder.cc.

References makeMuonMisalignmentScenario::components, getIndexOfStructure(), and hcalDigis_cfi::level.

Referenced by buildLevel(), and objectIdProvider().

 {
   unsigned int components = 1;
 
   for (unsigned int level = startLevel;
        level < alignmentLevels_.size();
        ++level) {
     components *= alignmentLevels_[level]->maxNumComponents;
   }
 
   return components;
 }