#include <AlignableTrackerBuilder.h>

Public Member Functions
	AlignableTrackerBuilder (const TrackerGeometry , const TrackerTopology )

void	buildAlignables (AlignableTracker *, bool update=false)

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

const align::TrackerNameSpace &	trackerNameSpace () const
	Return tracker name space derived from the tracker's topology. More...

virtual	~AlignableTrackerBuilder ()=default

Private Types
using	Alignables = align::Alignables

Private Member Functions
void	buildAlignableComposites (bool update=false)

void	buildAlignableDetUnits (bool update=false)
	Builds Alignables on module-level for each part of the tracker. More...

void	buildPixelDetector (AlignableTracker *)
	Builds the PixelDetector by hand. More...

void	buildPixelDetectorAlignable (const GeomDet *, int subdetId, Alignables &aliDets, Alignables &aliDetUnits, bool update=false)
	Converts GeomDetUnits of PXB and PXE to AlignableDetUnits. More...

void	buildStripDetector (AlignableTracker *)
	Builds the StripDetector by hand. More...

void	buildStripDetectorAlignable (const GeomDet *, int subdetId, Alignables &aliDets, Alignables &aliDetUnits, bool update=false)

void	convertGeomDetsToAlignables (const TrackingGeometry::DetContainer &, const std::string &moduleName, bool update=false)

Private Attributes
AlignableMap *	alignableMap_

const AlignableObjectId	alignableObjectId_

int	numDetUnits = 0

TrackerAlignmentLevelBuilder	trackerAlignmentLevelBuilder_

const TrackerGeometry *	trackerGeometry_

const TrackerTopology *	trackerTopology_

Detailed Description

Definition at line 17 of file AlignableTrackerBuilder.h.

Member Typedef Documentation

◆ Alignables

using AlignableTrackerBuilder::Alignables = align::Alignables

private

Definition at line 18 of file AlignableTrackerBuilder.h.

Constructor & Destructor Documentation

◆ AlignableTrackerBuilder()

AlignableTrackerBuilder::AlignableTrackerBuilder	(	const TrackerGeometry *	trackerGeometry,
		const TrackerTopology *	trackerTopology
	)

Definition at line 24 of file AlignableTrackerBuilder.cc.

     : trackerGeometry_(trackerGeometry),
       trackerTopology_(trackerTopology),
       alignableObjectId_(trackerGeometry, nullptr, nullptr, nullptr),
       alignableMap_(nullptr),
       trackerAlignmentLevelBuilder_(trackerTopology, trackerGeometry) {
   std::ostringstream ss;
  
   switch (alignableObjectId_.geometry()) {
     case AlignableObjectId::Geometry::RunI:
       ss << "RunI geometry";
       break;
     case AlignableObjectId::Geometry::PhaseI:
       ss << "PhaseI geometry";
       break;
     case AlignableObjectId::Geometry::PhaseII:
       ss << "PhaseII geometry";
       break;
     default:
       throw cms::Exception("LogicError") << "[AlignableTrackerBuilder] unknown version of TrackerGeometry";
   }
  
   edm::LogInfo("AlignableBuildProcess") << "@SUB=AlignableTrackerBuilder::AlignableTrackerBuilder"
                                         << "GeometryVersion: " << ss.str();
 }

References alignableObjectId_, Exception, AlignableObjectId::geometry(), AlignableObjectId::PhaseI, AlignableObjectId::PhaseII, AlignableObjectId::RunI, and contentValuesCheck::ss.

◆ ~AlignableTrackerBuilder()

virtual AlignableTrackerBuilder::~AlignableTrackerBuilder ( )

virtualdefault

Member Function Documentation

◆ buildAlignableComposites()

void AlignableTrackerBuilder::buildAlignableComposites ( bool update = false )

private

Builds all composite Alignables for the tracker. The hierarchy and numbers of components are determined in TrackerAlignmentLevelBuilder.

Definition at line 240 of file AlignableTrackerBuilder.cc.

                                                                    {
   unsigned int numCompositeAlignables = 0;
  
   // tracker levels must be built before the indexer is created in order to pass
   // a valid namespace to the indexer; an exception would be thrown if one tries
   // to get the namespace w/o building the levels
   auto trackerLevels = trackerAlignmentLevelBuilder_.build();
   TrackerAlignableIndexer trackerIndexer{trackerAlignmentLevelBuilder_.trackerNameSpace()};
   AlignableCompositeBuilder compositeBuilder{trackerTopology_, trackerGeometry_, trackerIndexer};
  
   for (auto& trackerSubLevels : trackerLevels) {
     // first add all levels of the current subdetector to the builder
     for (auto& level : trackerSubLevels) {
       compositeBuilder.addAlignmentLevel(std::move(level));
     }
     // now build this tracker-level
     numCompositeAlignables += compositeBuilder.buildAll(*alignableMap_, update);
     // finally, reset the builder
     compositeBuilder.clearAlignmentLevels();
   }
  
   edm::LogInfo("AlignableBuildProcess") << "@SUB=AlignableTrackerBuilder::buildAlignableComposites"
                                         << "AlignableComposites built for Tracker: " << numCompositeAlignables
                                         << " (note: without Pixel- and Strip-Alignable)";
 }

References alignableMap_, TrackerAlignmentLevelBuilder::build(), personalPlayback::level, eostools::move(), trackerAlignmentLevelBuilder_, trackerGeometry_, TrackerAlignmentLevelBuilder::trackerNameSpace(), trackerTopology_, and update.

Referenced by buildAlignables().

◆ buildAlignableDetUnits()

void AlignableTrackerBuilder::buildAlignableDetUnits ( bool update = false )

private

Builds Alignables on module-level for each part of the tracker.

Definition at line 80 of file AlignableTrackerBuilder.cc.

                                                                  {
   // PixelBarrel
   convertGeomDetsToAlignables(trackerGeometry_->detsPXB(), alignableObjectId_.idToString(align::TPBModule), update);
  
   // PixelEndcap
   convertGeomDetsToAlignables(trackerGeometry_->detsPXF(), alignableObjectId_.idToString(align::TPEModule), update);
  
   // TIB
   convertGeomDetsToAlignables(trackerGeometry_->detsTIB(), alignableObjectId_.idToString(align::TIBModule), update);
  
   // TID
   convertGeomDetsToAlignables(trackerGeometry_->detsTID(), alignableObjectId_.idToString(align::TIDModule), update);
  
   // TOB
   convertGeomDetsToAlignables(trackerGeometry_->detsTOB(), alignableObjectId_.idToString(align::TOBModule), update);
  
   // TEC
   convertGeomDetsToAlignables(trackerGeometry_->detsTEC(), alignableObjectId_.idToString(align::TECModule), update);
 }

References alignableObjectId_, convertGeomDetsToAlignables(), TrackerGeometry::detsPXB(), TrackerGeometry::detsPXF(), TrackerGeometry::detsTEC(), TrackerGeometry::detsTIB(), TrackerGeometry::detsTID(), TrackerGeometry::detsTOB(), AlignableObjectId::idToString(), align::TECModule, align::TIBModule, align::TIDModule, align::TOBModule, align::TPBModule, align::TPEModule, trackerGeometry_, and update.

Referenced by buildAlignables().

◆ buildAlignables()

void AlignableTrackerBuilder::buildAlignables	(	AlignableTracker *	trackerAlignables,
		bool	update = `false`
	)

Builds all Alignables (units and composites) of the tracker, based on the given TrackerGeometry.

Definition at line 52 of file AlignableTrackerBuilder.cc.

                                                                                                {
   alignableMap_ = &trackerAlignables->alignableMap_;
  
   // first, build Alignables on module-level (AlignableDetUnits)
   buildAlignableDetUnits(update);
  
   // now build the composite Alignables (Ladders, Layers etc.)
   buildAlignableComposites(update);
  
   if (update)
     return;  // everything else not needed for the update
  
   // create pixel-detector
   buildPixelDetector(trackerAlignables);
   // create strip-detector
   buildStripDetector(trackerAlignables);
  
   // tracker itself is of course also an Alignable
   alignableMap_->get("Tracker").push_back(trackerAlignables);
   // id is the id of first component (should be TPBBarrel)
   trackerAlignables->theId = trackerAlignables->components()[0]->id();
 }

References alignableMap_, AlignableTracker::alignableMap_, buildAlignableComposites(), buildAlignableDetUnits(), buildPixelDetector(), buildStripDetector(), AlignableComposite::components(), AlignableMap::get(), Alignable::theId, and update.

Referenced by AlignableTracker::AlignableTracker(), and AlignableTracker::update().

◆ buildPixelDetector()

void AlignableTrackerBuilder::buildPixelDetector ( AlignableTracker * trackerAlignables )

private

Builds the PixelDetector by hand.

Definition at line 267 of file AlignableTrackerBuilder.cc.

                                                                                      {
   const std::string& pxbName = alignableObjectId_.idToString(align::TPBBarrel);
   const std::string& pxeName = alignableObjectId_.idToString(align::TPEEndcap);
   const std::string& pixelName = alignableObjectId_.idToString(align::Pixel);
  
   auto& pxbAlignables = alignableMap_->find(pxbName);
   auto& pxeAlignables = alignableMap_->find(pxeName);
   auto& pixelAlignables = alignableMap_->get(pixelName);
  
   pixelAlignables.push_back(new AlignableComposite(pxbAlignables[0]->id(), align::Pixel, align::RotationType()));
  
   pixelAlignables[0]->addComponent(pxbAlignables[0]);
   pixelAlignables[0]->addComponent(pxeAlignables[0]);
   pixelAlignables[0]->addComponent(pxeAlignables[1]);
  
   trackerAlignables->addComponent(pixelAlignables[0]);
  
   edm::LogInfo("AlignableBuildProcess") << "@SUB=AlignableTrackerBuilder::buildPixelDetector"
                                         << "Built " << pixelName << "-detector Alignable, consisting of Alignables"
                                         << " of " << pxbName << " and " << pxeName;
 }

References AlignableComposite::addComponent(), alignableMap_, alignableObjectId_, AlignableMap::find(), AlignableMap::get(), AlignableObjectId::idToString(), align::Pixel, AlCaHLTBitMon_QueryRunRegistry::string, align::TPBBarrel, and align::TPEEndcap.

Referenced by buildAlignables().

◆ buildPixelDetectorAlignable()

void AlignableTrackerBuilder::buildPixelDetectorAlignable	(	const GeomDet *	geomDetUnit,
		int	subdetId,
		Alignables &	aliDets,
		Alignables &	aliDetUnits,
		bool	update = `false`
	)

private

Converts GeomDetUnits of PXB and PXE to AlignableDetUnits.

Definition at line 147 of file AlignableTrackerBuilder.cc.

                                                                                                          {
   // treat all pixel dets in same way with one AlignableDetUnit
   if (!geomDetUnit->isLeaf()) {
     throw cms::Exception("BadHierarchy") << "[AlignableTrackerBuilder] Pixel GeomDet (subdetector " << subdetId
                                          << ") is not a GeomDetUnit.";
   }
  
   if (update) {
     auto ali = std::find_if(aliDets.cbegin(), aliDets.cend(), [&geomDetUnit](const auto& i) {
       return i->id() == geomDetUnit->geographicalId().rawId();
     });
     if (ali != aliDets.end()) {
       // add dynamic cast here to get AlignableDetUnit!
       auto aliDetUnit = dynamic_cast<AlignableDetUnit*>(*ali);
       if (aliDetUnit) {
         aliDetUnit->update(geomDetUnit);
       } else {
         throw cms::Exception("LogicError") << "[AlignableTrackerBuilder::buildPixelDetectorAlignable] "
                                            << "cast to 'AlignableDetUnit*' failed while it should not\n";
       }
     } else {
       throw cms::Exception("GeometryMismatch")
           << "[AlignableTrackerBuilder::buildPixelDetectorAlignable] "
           << "GeomDet with DetId " << geomDetUnit->geographicalId().rawId() << " not found in current geometry.\n";
     }
   } else {
     aliDets.push_back(new AlignableDetUnit(geomDetUnit));
     aliDetUnits.push_back(aliDets.back());
   }
   numDetUnits += 1;
 }

References align::AlignableDetUnit, Exception, GeomDet::geographicalId(), mps_fire::i, GeomDet::isLeaf(), numDetUnits, DetId::rawId(), and update.

Referenced by buildStripDetectorAlignable(), and convertGeomDetsToAlignables().

◆ buildStripDetector()

void AlignableTrackerBuilder::buildStripDetector ( AlignableTracker * trackerAlignables )

private

Builds the StripDetector by hand.

Definition at line 290 of file AlignableTrackerBuilder.cc.

                                                                                      {
   const std::string& tibName = alignableObjectId_.idToString(align::TIBBarrel);
   const std::string& tidName = alignableObjectId_.idToString(align::TIDEndcap);
   const std::string& tobName = alignableObjectId_.idToString(align::TOBBarrel);
   const std::string& tecName = alignableObjectId_.idToString(align::TECEndcap);
   const std::string& stripName = alignableObjectId_.idToString(align::Strip);
  
   auto& tibAlignables = alignableMap_->find(tibName);
   auto& tidAlignables = alignableMap_->find(tidName);
   auto& tobAlignables = alignableMap_->find(tobName);
   auto& tecAlignables = alignableMap_->find(tecName);
   auto& stripAlignables = alignableMap_->get(stripName);
  
   stripAlignables.push_back(new AlignableComposite(tibAlignables[0]->id(), align::Strip, align::RotationType()));
  
   stripAlignables[0]->addComponent(tibAlignables[0]);
   stripAlignables[0]->addComponent(tidAlignables[0]);
   stripAlignables[0]->addComponent(tidAlignables[1]);
   stripAlignables[0]->addComponent(tobAlignables[0]);
   stripAlignables[0]->addComponent(tecAlignables[0]);
   stripAlignables[0]->addComponent(tecAlignables[1]);
  
   trackerAlignables->addComponent(stripAlignables[0]);
  
   edm::LogInfo("AlignableBuildProcess") << "@SUB=AlignableTrackerBuilder::buildStripDetector"
                                         << "Built " << stripName << "-detector Alignable, consisting of Alignables"
                                         << " of " << tibName << ", " << tidName << ", " << tobName << " and "
                                         << tecName;
 }

References AlignableComposite::addComponent(), alignableMap_, alignableObjectId_, AlignableMap::find(), AlignableMap::get(), AlignableObjectId::idToString(), AlCaHLTBitMon_QueryRunRegistry::string, align::Strip, align::TECEndcap, align::TIBBarrel, align::TIDEndcap, and align::TOBBarrel.

Referenced by buildAlignables().

◆ buildStripDetectorAlignable()

void AlignableTrackerBuilder::buildStripDetectorAlignable	(	const GeomDet *	geomDet,
		int	subdetId,
		Alignables &	aliDets,
		Alignables &	aliDetUnits,
		bool	update = `false`
	)

private

Converts GeomDets of TIB, TID, TOB and TEC either to AlignableDetUnits or AlignableSiStripDet, depending on the module-type (2D or 1D).

Definition at line 181 of file AlignableTrackerBuilder.cc.

                                                                                                      {
   // In strip we have:
   // 1) 'Pure' 1D-modules like TOB layers 3-6 (not glued): AlignableDetUnit
   // 2) Composite 2D-modules like TOB layers 1&2 (not glued): AlignableDet
   // 3) The two 1D-components of case 2 (glued): AlignableDetUnit that is constructed
   //      inside AlignableDet-constructor of 'mother', only need to add to alignableLists
   const SiStripDetId detId(geomDet->geographicalId());
  
   // 2D- or 'pure' 1D-module
   if (!detId.glued()) {
     if (!geomDet->components().empty()) {
       // 2D-module, convert it to GluedGeomDet
       const GluedGeomDet* gluedGeomDet = dynamic_cast<const GluedGeomDet*>(geomDet);
       if (!gluedGeomDet) {
         throw cms::Exception("LogicError") << "[AlignableTrackerBuilder] dynamic_cast<const GluedGeomDet*> "
                                            << "failed.";
       }
  
       // components (AlignableDetUnits) constructed within
       if (update) {
         auto ali = std::find_if(aliDets.cbegin(), aliDets.cend(), [&gluedGeomDet](const auto& i) {
           return i->id() == gluedGeomDet->geographicalId().rawId();
         });
         if (ali != aliDets.end()) {
           auto aliSiStripDet = dynamic_cast<AlignableSiStripDet*>(*ali);
           if (aliSiStripDet) {
             aliSiStripDet->update(gluedGeomDet);
           } else {
             throw cms::Exception("LogicError") << "[AlignableTrackerBuilder::buildStripDetectorAlignable] "
                                                << "cast to 'AlignableSiStripDet*' failed while it should not\n";
           }
         } else {
           throw cms::Exception("GeometryMismatch")
               << "[AlignableTrackerBuilder::buildStripDetectorAlignable] "
               << "GeomDet with DetId " << gluedGeomDet->geographicalId().rawId() << " not found in current geometry.\n";
         }
       } else {
         aliDets.push_back(new AlignableSiStripDet(gluedGeomDet));
       }
       const auto& addAliDetUnits = aliDets.back()->components();
       const auto& nAddedUnits = addAliDetUnits.size();
  
       if (!update) {
         // reserve space for the additional units:
         aliDetUnits.reserve(aliDetUnits.size() + nAddedUnits - 1);
         aliDetUnits.insert(aliDetUnits.end(), addAliDetUnits.begin(), addAliDetUnits.end());
       }
       numDetUnits += nAddedUnits;
  
     } else {
       // no components: pure 1D-module
       buildPixelDetectorAlignable(geomDet, subdetId, aliDets, aliDetUnits, update);
     }
   }  // no else: glued components of AlignableDet constructed within
      // AlignableSiStripDet -> AlignableDet, see above
 }

References buildPixelDetectorAlignable(), GeomDet::components(), Exception, GeomDet::geographicalId(), mps_fire::i, numDetUnits, DetId::rawId(), and update.

Referenced by convertGeomDetsToAlignables().

◆ convertGeomDetsToAlignables()

void AlignableTrackerBuilder::convertGeomDetsToAlignables	(	const TrackingGeometry::DetContainer &	geomDets,
		const std::string &	moduleName,
		bool	update = `false`
	)

private

Decides whether a GeomDet is from Pixel- or Strip-Detector and calls the according method to build the Alignable.

Definition at line 101 of file AlignableTrackerBuilder.cc.

                                                                         {
   numDetUnits = 0;
  
   auto& alignables = alignableMap_->get(moduleName);
   if (!update)
     alignables.reserve(geomDets.size());
  
   // units are added for each moduleName, which are at moduleName + "Unit"
   // in the pixel Module and ModuleUnit are equivalent
   auto& aliUnits = alignableMap_->get(moduleName + "Unit");
   if (!update)
     aliUnits.reserve(geomDets.size());  // minimal number space needed
  
   for (auto& geomDet : geomDets) {
     int subdetId = geomDet->geographicalId().subdetId();  //don't check det()==Tracker
  
     if (subdetId == PixelSubdetector::PixelBarrel || subdetId == PixelSubdetector::PixelEndcap) {
       buildPixelDetectorAlignable(geomDet, subdetId, alignables, aliUnits, update);
  
     } else if (subdetId == SiStripDetId::TIB || subdetId == SiStripDetId::TID || subdetId == SiStripDetId::TOB ||
                subdetId == SiStripDetId::TEC) {
       // for strip we create also <TIB/TID/TOB/TEC>ModuleUnit list
       // for 1D components of 2D layers
       buildStripDetectorAlignable(geomDet, subdetId, alignables, aliUnits, update);
  
     } else {
       throw cms::Exception("LogicError") << "[AlignableTrackerBuilder] GeomDet of unknown subdetector";
     }
  
     trackerAlignmentLevelBuilder_.addDetUnitInfo(geomDet->geographicalId());
   }
  
   // JFI: For PXB and PXE we exclusively build AlignableDetUnit, hence
   // alignables.size() and numDetUnits are equal. But for modules in Strip
   // we also create AlignableSiStripDets, which consist of multiple
   // AlignableDetUnits, hence alignables.size() and numDetUnits are not equal.
  
   edm::LogInfo("AlignableBuildProcess") << "@SUB=AlignableTrackerBuilder::convertGeomDetsToAlignables"
                                         << "converted GeomDets to Alignables for " << moduleName << "\n"
                                         << "   GeomDets:             " << geomDets.size() << "\n"
                                         << "   AlignableDetUnits:    " << numDetUnits;
 }