AlignableDetUnit.cc

Go to the documentation of this file.

#include "Alignment/CommonAlignment/interface/AlignableDetUnit.h"
 
#include "Geometry/CommonDetUnit/interface/GeomDet.h"
 
#include "CondFormats/Alignment/interface/Alignments.h"
#include "CondFormats/Alignment/interface/AlignmentErrorsExtended.h"
#include "CLHEP/Vector/RotationInterfaces.h"
#include "DataFormats/TrackingRecHit/interface/AlignmentPositionError.h"
#include "Geometry/CommonTopologies/interface/SurfaceDeformation.h"
 
#include "FWCore/MessageLogger/interface/MessageLogger.h"
#include "FWCore/Utilities/interface/Exception.h"
 
//__________________________________________________________________________________________________
AlignableDetUnit::AlignableDetUnit(const GeomDetUnit* geomDetUnit)
    :  // rely on non-NULL pointer!
      Alignable(geomDetUnit->geographicalId().rawId(), geomDetUnit->surface()),
      theAlignmentPositionError(nullptr),
      theSurfaceDeformation(nullptr),
      theCachedSurfaceDeformation(nullptr) {
  if (geomDetUnit->alignmentPositionError()) {  // take over APE from geometry
    // 2nd argument w/o effect:
    this->setAlignmentPositionError(*(geomDetUnit->alignmentPositionError()), false);
  }
 
  if (geomDetUnit->surfaceDeformation()) {  // take over surface modification
    // 2nd argument w/o effect:
    this->setSurfaceDeformation(geomDetUnit->surfaceDeformation(), false);
  }
 
  theDeepComponents.push_back(this);
}
 
//__________________________________________________________________________________________________
AlignableDetUnit::~AlignableDetUnit() {
  delete theAlignmentPositionError;
  delete theSurfaceDeformation;
  delete theCachedSurfaceDeformation;
  for (auto surface : surfaceDeformationsCache_)
    delete surface.second;
}
 
//__________________________________________________________________________________________________
void AlignableDetUnit::update(const GeomDetUnit* geomDetUnit) {
  if (!geomDetUnit) {
    throw cms::Exception("Alignment") << "@SUB=AlignableDetUnit::update\n"
                                      << "Trying to update with GeomDetUnit* pointing to 'nullptr'.";
  }
 
  Alignable::update(geomDetUnit->geographicalId().rawId(), geomDetUnit->surface());
 
  if (geomDetUnit->alignmentPositionError()) {  // take over APE from geometry
    // 2nd argument w/o effect:
    this->setAlignmentPositionError(*(geomDetUnit->alignmentPositionError()), false);
  }
 
  if (geomDetUnit->surfaceDeformation()) {  // take over surface modification
    // 2nd argument w/o effect:
    this->setSurfaceDeformation(geomDetUnit->surfaceDeformation(), false);
  }
}
 
//__________________________________________________________________________________________________
void AlignableDetUnit::addComponent(Alignable* /*unused*/) {
  throw cms::Exception("LogicError") << "AlignableDetUnit cannot have components, but try to add one!";
}
 
//__________________________________________________________________________________________________
void AlignableDetUnit::move(const GlobalVector& displacement) {
  theSurface.move(displacement);
  this->addDisplacement(displacement);
}
 
//__________________________________________________________________________________________________
void AlignableDetUnit::rotateInGlobalFrame(const RotationType& rotation) {
  theSurface.rotate(rotation);
  this->addRotation(rotation);
}
 
//__________________________________________________________________________________________________
void AlignableDetUnit::setAlignmentPositionError(const AlignmentPositionError& ape, bool /*propagateDown*/) {
  if (!theAlignmentPositionError)
    theAlignmentPositionError = new AlignmentPositionError(ape);
  else
    *theAlignmentPositionError = ape;
}
 
//__________________________________________________________________________________________________
void AlignableDetUnit::addAlignmentPositionError(const AlignmentPositionError& ape, bool propagateDown) {
  if (!theAlignmentPositionError)
    this->setAlignmentPositionError(ape, propagateDown);  // 2nd argument w/o effect
  else
    *theAlignmentPositionError += ape;
}
 
//__________________________________________________________________________________________________
void AlignableDetUnit::addAlignmentPositionErrorFromRotation(const RotationType& rot, bool propagateDown) {
  // average error calculated by movement of a local point at
  // (xWidth/2,yLength/2,0) caused by the rotation rot
  GlobalVector localPositionVector =
      surface().toGlobal(LocalVector(.5 * surface().width(), .5 * surface().length(), 0.));
 
  const LocalVector::BasicVectorType& lpvgf = localPositionVector.basicVector();
  GlobalVector gv(rot.multiplyInverse(lpvgf) - lpvgf);
 
  AlignmentPositionError ape(gv.x(), gv.y(), gv.z());
  this->addAlignmentPositionError(ape, propagateDown);  // 2nd argument w/o effect
}
 
//__________________________________________________________________________________________________
void AlignableDetUnit::addAlignmentPositionErrorFromLocalRotation(const RotationType& rot, bool propagateDown) {
  RotationType globalRot = globalRotation().multiplyInverse(rot * globalRotation());
  this->addAlignmentPositionErrorFromRotation(globalRot, propagateDown);  // 2nd argument w/o effect
}
 
//__________________________________________________________________________________________________
void AlignableDetUnit::setSurfaceDeformation(const SurfaceDeformation* deformation, bool /* propagateDown */) {
  delete theSurfaceDeformation;  // OK for zero pointers
  if (deformation) {
    theSurfaceDeformation = deformation->clone();
  } else {
    theSurfaceDeformation = nullptr;
  }
}
 
//__________________________________________________________________________________________________
void AlignableDetUnit::addSurfaceDeformation(const SurfaceDeformation* deformation, bool propagateDown) {
  if (!deformation) {
    // nothing to do
  } else if (!theSurfaceDeformation) {
    this->setSurfaceDeformation(deformation, propagateDown);  // fine since no components
  } else if (!theSurfaceDeformation->add(*deformation)) {
    edm::LogError("Alignment") << "@SUB=AlignableDetUnit::addSurfaceDeformation"
                               << "Cannot add deformation type " << deformation->type() << " to type "
                               << theSurfaceDeformation->type() << ", so erase deformation information.";
    delete theSurfaceDeformation;
    theSurfaceDeformation = nullptr;
  }
}
 
//__________________________________________________________________________________________________
void AlignableDetUnit::dump() const {
  std::ostringstream parameters;
  if (theSurfaceDeformation) {
    parameters << "    surface deformation parameters:";
    for (const auto& param : theSurfaceDeformation->parameters()) {
      parameters << " " << param;
    }
  } else {
    parameters << "    no surface deformation parameters";
  }
 
  edm::LogInfo("AlignableDump") << " AlignableDetUnit has position = " << this->globalPosition()
                                << ", orientation:" << std::endl
                                << this->globalRotation() << std::endl
                                << " total displacement and rotation: " << this->displacement() << std::endl
                                << this->rotation() << "\n"
                                << parameters.str();
}
 
//__________________________________________________________________________________________________
Alignments* AlignableDetUnit::alignments() const {
  Alignments* m_alignments = new Alignments();
  RotationType rot(this->globalRotation());
 
  // Get alignments (position, rotation, detId)
  CLHEP::Hep3Vector clhepVector(globalPosition().x(), globalPosition().y(), globalPosition().z());
  CLHEP::HepRotation clhepRotation(
      CLHEP::HepRep3x3(rot.xx(), rot.xy(), rot.xz(), rot.yx(), rot.yy(), rot.yz(), rot.zx(), rot.zy(), rot.zz()));
  uint32_t detId = this->geomDetId().rawId();
 
  AlignTransform transform(clhepVector, clhepRotation, detId);
 
  // Add to alignments container
  m_alignments->m_align.push_back(transform);
 
  return m_alignments;
}
 
//__________________________________________________________________________________________________
AlignmentErrorsExtended* AlignableDetUnit::alignmentErrors() const {
  AlignmentErrorsExtended* m_alignmentErrors = new AlignmentErrorsExtended();
 
  uint32_t detId = this->geomDetId().rawId();
 
  CLHEP::HepSymMatrix clhepSymMatrix(6, 0);
  if (theAlignmentPositionError)  // Might not be set
    clhepSymMatrix = asHepMatrix(theAlignmentPositionError->globalError().matrix());
 
  AlignTransformErrorExtended transformError(clhepSymMatrix, detId);
 
  m_alignmentErrors->m_alignError.push_back(transformError);
 
  return m_alignmentErrors;
}
 
//__________________________________________________________________________________________________
int AlignableDetUnit::surfaceDeformationIdPairs(std::vector<std::pair<int, SurfaceDeformation*> >& result) const {
  if (theSurfaceDeformation) {
    result.push_back(std::pair<int, SurfaceDeformation*>(this->geomDetId().rawId(), theSurfaceDeformation));
    return 1;
  }
 
  return 0;
}
 
//__________________________________________________________________________________________________
void AlignableDetUnit::cacheTransformation() {
  theCachedSurface = theSurface;
  theCachedDisplacement = theDisplacement;
  theCachedRotation = theRotation;
 
  if (theCachedSurfaceDeformation) {
    delete theCachedSurfaceDeformation;
    theCachedSurfaceDeformation = nullptr;
  }
 
  if (theSurfaceDeformation)
    theCachedSurfaceDeformation = theSurfaceDeformation->clone();
}
 
//__________________________________________________________________________________________________
void AlignableDetUnit::cacheTransformation(const align::RunNumber& run) {
  surfacesCache_[run] = theSurface;
  displacementsCache_[run] = theDisplacement;
  rotationsCache_[run] = theRotation;
 
  auto existingCache = surfaceDeformationsCache_.find(run);
  if (existingCache != surfaceDeformationsCache_.end()) {
    delete existingCache->second;
    existingCache->second = nullptr;
  }
 
  if (theSurfaceDeformation) {
    surfaceDeformationsCache_[run] = theSurfaceDeformation->clone();
  }
}
 
//__________________________________________________________________________________________________
void AlignableDetUnit::restoreCachedTransformation() {
  theSurface = theCachedSurface;
  theDisplacement = theCachedDisplacement;
  theRotation = theCachedRotation;
 
  if (theSurfaceDeformation) {
    delete theSurfaceDeformation;
    theSurfaceDeformation = nullptr;
  }
 
  if (theCachedSurfaceDeformation) {
    this->setSurfaceDeformation(theCachedSurfaceDeformation, false);
  }
}
 
//__________________________________________________________________________________________________
void AlignableDetUnit::restoreCachedTransformation(const align::RunNumber& run) {
  if (surfacesCache_.find(run) == surfacesCache_.end()) {
    throw cms::Exception("Alignment") << "@SUB=Alignable::restoreCachedTransformation\n"
                                      << "Trying to restore cached transformation for a run (" << run
                                      << ") that has not been cached.";
  } else {
    theSurface = surfacesCache_[run];
    theDisplacement = displacementsCache_[run];
    theRotation = rotationsCache_[run];
 
    if (theSurfaceDeformation) {
      delete theSurfaceDeformation;
      theSurfaceDeformation = nullptr;
    }
 
    if (surfaceDeformationsCache_[run]) {
      this->setSurfaceDeformation(surfaceDeformationsCache_[run], false);
    }
  }
}
 
//______________________________________________________________________________
const align::Alignables AlignableDetUnit::emptyComponents_{};