AlignableTrackerBuilder Class Reference

#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	buildOuterTrackerDetector (AlignableTracker *)
	Builds the Phase-2 Outer Tracker Detector by hand. More...
void	buildOuterTrackerDetectorAlignable (const GeomDet *, int subdetId, Alignables &aliDets, Alignables &aliDetUnits, bool update=false)
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 26 of file AlignableTrackerBuilder.cc.

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

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

~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 300 of file AlignableTrackerBuilder.cc.

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

Referenced by buildAlignables().

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

buildAlignableDetUnits()

void AlignableTrackerBuilder::buildAlignableDetUnits ( bool  update = false )

private

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

Definition at line 89 of file AlignableTrackerBuilder.cc.

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

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

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 54 of file AlignableTrackerBuilder.cc.

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

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

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

  // for the Outer Tracker, decide which geometry we are addressing
  if (alignableObjectId_.geometry() < AlignableObjectId::Geometry::PhaseII) {
    // create strip-detector
    buildStripDetector(trackerAlignables);
  } else {
    // create Phase2 Outer Tracker-detector
    buildOuterTrackerDetector(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();
}

buildOuterTrackerDetector()

void AlignableTrackerBuilder::buildOuterTrackerDetector ( AlignableTracker *  trackerAlignables )

private

Builds the Phase-2 Outer Tracker Detector by hand.

Definition at line 381 of file AlignableTrackerBuilder.cc.

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

Referenced by buildAlignables().

                                                                                            {
  const std::string& tidName = alignableObjectId_.idToString(align::TIDEndcap);
  const std::string& tobName = alignableObjectId_.idToString(align::TOBBarrel);
  const std::string& stripName = alignableObjectId_.idToString(align::Strip);

  auto& tidAlignables = alignableMap_->find(tidName);
  auto& tobAlignables = alignableMap_->find(tobName);
  auto& stripAlignables = alignableMap_->get(stripName);

  stripAlignables.push_back(new AlignableComposite(tobAlignables[0]->id(), align::Strip, align::RotationType()));
  stripAlignables[0]->addComponent(tobAlignables[0]);
  stripAlignables[0]->addComponent(tidAlignables[0]);
  stripAlignables[0]->addComponent(tidAlignables[1]);

  trackerAlignables->addComponent(stripAlignables[0]);

  edm::LogInfo("AlignableBuildProcess") << "@SUB=AlignableTrackerBuilder::buildStripDetector"
                                        << "Built " << stripName << "-detector Alignable, consisting of Alignables"
                                        << " of " << tidName << " and " << tobName;
}

buildOuterTrackerDetectorAlignable()

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

private

Definition at line 254 of file AlignableTrackerBuilder.cc.

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

Referenced by convertGeomDetsToAlignables().

                                                                                                     {
  // hopefully all the geomdets are composite (either PS or SS modules in Ph-2 Outer Tracker)
  if (!geomDet->components().empty()) {
    // 2D-module, convert it to StackGeomDet
    const StackGeomDet* stackGeomDet = dynamic_cast<const StackGeomDet*>(geomDet);
    if (!stackGeomDet) {
      throw cms::Exception("LogicError") << "[AlignableTrackerBuilder] dynamic_cast<const StackGeomDet*> "
                                         << "failed.";
    }

    // components (AlignableDetUnits) constructed within
    if (update) {
      auto ali = std::find_if(aliDets.cbegin(), aliDets.cend(), [&stackGeomDet](const auto& i) {
        return i->id() == stackGeomDet->geographicalId().rawId();
      });
      if (ali != aliDets.end()) {
        auto aliStackDet = dynamic_cast<AlignableStackDet*>(*ali);
        if (aliStackDet) {
          aliStackDet->update(geomDet);
        } else {
          throw cms::Exception("LogicError") << "[AlignableTrackerBuilder::buildOuterTrackerDetectorAlignable] "
                                             << "cast to 'AlignableStackDet*' failed while it should not\n";
        }
      } else {
        throw cms::Exception("GeometryMismatch")
            << "[AlignableTrackerBuilder::buildStripDetectorAlignable] "
            << "GeomDet with DetId " << stackGeomDet->geographicalId().rawId() << " not found in current geometry.\n";
      }
    } else {
      aliDets.push_back(new AlignableStackDet(stackGeomDet));
    }
    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;
  }  // no else: stacked components of AlignableDet constructed within
     // AlignableStackDet -> AlignableDet, see above
}

buildPixelDetector()

void AlignableTrackerBuilder::buildPixelDetector ( AlignableTracker *  trackerAlignables )

private

Builds the PixelDetector by hand.

Definition at line 327 of file AlignableTrackerBuilder.cc.

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

Referenced by buildAlignables().

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

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 161 of file AlignableTrackerBuilder.cc.

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

Referenced by buildStripDetectorAlignable(), and convertGeomDetsToAlignables().

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

buildStripDetector()

void AlignableTrackerBuilder::buildStripDetector ( AlignableTracker *  trackerAlignables )

private

Builds the StripDetector by hand.

Definition at line 350 of file AlignableTrackerBuilder.cc.

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

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

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 195 of file AlignableTrackerBuilder.cc.

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

Referenced by convertGeomDetsToAlignables().

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

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 110 of file AlignableTrackerBuilder.cc.

References TrackerAlignmentLevelBuilder::addDetUnitInfo(), alignableMap_, alignableObjectId_, buildOuterTrackerDetectorAlignable(), buildPixelDetectorAlignable(), buildStripDetectorAlignable(), Exception, AlignableObjectId::geometry(), AlignableMap::get(), EcalCalibMonitorClient_cfi::moduleName, numDetUnits, AlignableObjectId::PhaseII, PixelSubdetector::PixelBarrel, PixelSubdetector::PixelEndcap, SiStripDetId::TEC, SiStripDetId::TIB, SiStripDetId::TID, SiStripDetId::TOB, trackerAlignmentLevelBuilder_, and update.

Referenced by buildAlignableDetUnits().

                                                                        {
  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

      if (alignableObjectId_.geometry() < AlignableObjectId::Geometry::PhaseII) {
        buildStripDetectorAlignable(geomDet, subdetId, alignables, aliUnits, update);
      } else {
        buildOuterTrackerDetectorAlignable(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;
}

objectIdProvider()

const AlignableObjectId& AlignableTrackerBuilder::objectIdProvider ( ) const

inline

Return tracker alignable object ID provider derived from the tracker's geometry.

Definition at line 33 of file AlignableTrackerBuilder.h.

References alignableObjectId_.

Referenced by AlignableTracker::AlignableTracker().

{ return alignableObjectId_; }

trackerNameSpace()

const align::TrackerNameSpace& AlignableTrackerBuilder::trackerNameSpace ( ) const

inline

Return tracker name space derived from the tracker's topology.

Definition at line 30 of file AlignableTrackerBuilder.h.

References trackerAlignmentLevelBuilder_, and TrackerAlignmentLevelBuilder::trackerNameSpace().

Referenced by AlignableTracker::AlignableTracker().

{ return trackerAlignmentLevelBuilder_.trackerNameSpace(); }

Member Data Documentation

alignableMap_

AlignableMap* AlignableTrackerBuilder::alignableMap_

private

Definition at line 72 of file AlignableTrackerBuilder.h.

Referenced by buildAlignableComposites(), buildAlignables(), buildOuterTrackerDetector(), buildPixelDetector(), buildStripDetector(), and convertGeomDetsToAlignables().

alignableObjectId_

const AlignableObjectId AlignableTrackerBuilder::alignableObjectId_

private

Definition at line 70 of file AlignableTrackerBuilder.h.

Referenced by AlignableTrackerBuilder(), buildAlignableDetUnits(), buildAlignables(), buildOuterTrackerDetector(), buildPixelDetector(), buildStripDetector(), convertGeomDetsToAlignables(), and objectIdProvider().

numDetUnits

int AlignableTrackerBuilder::numDetUnits = 0

private

Definition at line 76 of file AlignableTrackerBuilder.h.

Referenced by buildOuterTrackerDetectorAlignable(), buildPixelDetectorAlignable(), buildStripDetectorAlignable(), and convertGeomDetsToAlignables().

trackerAlignmentLevelBuilder_

TrackerAlignmentLevelBuilder AlignableTrackerBuilder::trackerAlignmentLevelBuilder_

private

Definition at line 74 of file AlignableTrackerBuilder.h.

Referenced by buildAlignableComposites(), convertGeomDetsToAlignables(), and trackerNameSpace().

trackerGeometry_

const TrackerGeometry* AlignableTrackerBuilder::trackerGeometry_

private

Definition at line 68 of file AlignableTrackerBuilder.h.

Referenced by buildAlignableComposites(), and buildAlignableDetUnits().

trackerTopology_

const TrackerTopology* AlignableTrackerBuilder::trackerTopology_

private

Definition at line 69 of file AlignableTrackerBuilder.h.

Referenced by buildAlignableComposites().