AlignableCompositeBuilder.cc

Go to the documentation of this file.

#include "Alignment/CommonAlignment/interface/AlignableCompositeBuilder.h"
 
// Original Author:  Max Stark
//         Created:  Thu, 13 Jan 2016 10:22:57 CET
 
// core framework functionality
#include "FWCore/MessageLogger/interface/MessageLogger.h"
 
// alignment
#include "Alignment/CommonAlignment/interface/AlignableObjectId.h"
 
//=============================================================================
//===   PUBLIC METHOD IMPLEMENTATION                                        ===
//=============================================================================
 
//_____________________________________________________________________________
AlignableCompositeBuilder ::AlignableCompositeBuilder(const TrackerTopology* trackerTopology,
                                                      const TrackerGeometry* trackerGeometry,
                                                      const AlignableIndexer& alignableIndexer)
    : trackerTopology_(trackerTopology),
      alignableObjectId_(trackerGeometry, nullptr, nullptr),
      alignableIndexer_(alignableIndexer) {}
 
//_____________________________________________________________________________
void AlignableCompositeBuilder ::addAlignmentLevel(std::unique_ptr<AlignmentLevel> level) {
  alignmentLevels_.push_back(std::move(level));
}
 
//_____________________________________________________________________________
void AlignableCompositeBuilder ::clearAlignmentLevels() { alignmentLevels_.clear(); }
 
//_____________________________________________________________________________
unsigned int AlignableCompositeBuilder ::buildAll(AlignableMap& alignableMap, bool update) {
  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;
}
 
//=============================================================================
//===   PRIVATE METHOD IMPLEMENTATION                                       ===
//=============================================================================
 
//_____________________________________________________________________________
unsigned int AlignableCompositeBuilder ::buildLevel(unsigned int parentLevel,
                                                    AlignableMap& alignableMap,
                                                    std::ostringstream& ss,
                                                    bool update) {
  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();
}
 
//_____________________________________________________________________________
unsigned int AlignableCompositeBuilder ::maxNumComponents(unsigned int startLevel) const {
  unsigned int components = 1;
 
  for (unsigned int level = startLevel; level < alignmentLevels_.size(); ++level) {
    components *= alignmentLevels_[level]->maxNumComponents;
  }
 
  return components;
}
 
//_____________________________________________________________________________
unsigned int AlignableCompositeBuilder ::getIndexOfStructure(align::ID id, unsigned int level) const {
  // 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;
}