#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 14 of file AlignableCompositeBuilder.h.

Constructor & Destructor Documentation

◆ AlignableCompositeBuilder()

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

Definition at line 17 of file AlignableCompositeBuilder.cc.

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

◆ ~AlignableCompositeBuilder()

virtual AlignableCompositeBuilder::~AlignableCompositeBuilder ( )

virtualdefault

Member Function Documentation

◆ addAlignmentLevel()

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 25 of file AlignableCompositeBuilder.cc.

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

References alignmentLevels_, personalPlayback::level, and eostools::move().

◆ buildAll()

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 33 of file AlignableCompositeBuilder.cc.

                                                                                          {
   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;
 }

References alignableObjectId_, alignmentLevels_, buildLevel(), AlignableObjectId::idToString(), personalPlayback::level, contentValuesCheck::ss, and update.

◆ buildLevel()

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 56 of file AlignableCompositeBuilder.cc.

                                                                  {
   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.
   align::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();
 }

References alignableObjectId_, alignmentLevels_, class-composition::children, Exception, AlignableMap::find(), AlignableMap::get(), getIndexOfStructure(), AlignableObjectId::idToString(), maxNumComponents(), class-composition::parent, parents, contentValuesCheck::ss, and update.

Referenced by buildAll().

◆ clearAlignmentLevels()

void AlignableCompositeBuilder::clearAlignmentLevels ( )

Resets the alignment-levels.

Definition at line 30 of file AlignableCompositeBuilder.cc.

30 { alignmentLevels_.clear(); }

References alignmentLevels_.

◆ getIndexOfStructure()

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 135 of file AlignableCompositeBuilder.cc.

                                                                                                  {
   // 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;
 }

References alignableIndexer_, alignableObjectId_, alignmentLevels_, AlignableIndexer::get(), and personalPlayback::level.

Referenced by buildLevel().

◆ maxNumComponents()

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 124 of file AlignableCompositeBuilder.cc.

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