AlignableDetUnit Class Reference

#include <AlignableDetUnit.h>

Inheritance diagram for AlignableDetUnit:

Public Member Functions
void	addAlignmentPositionError (const AlignmentPositionError &ape, bool) final
void	addAlignmentPositionErrorFromLocalRotation (const RotationType &rot, bool) final
void	addAlignmentPositionErrorFromRotation (const RotationType &rot, bool) final
void	addComponent (Alignable *) final
	No components here => exception! More...
void	addSurfaceDeformation (const SurfaceDeformation *deformation, bool) final
	Add surface deformation parameters to the existing ones (2nd argument without effect) More...
	AlignableDetUnit (const GeomDetUnit *geomDetUnit)
	Constructor from GeomDetUnit - must not be NULL pointer! More...
StructureType	alignableObjectId () const override
	Return the alignable type identifier. More...
AlignmentErrorsExtended *	alignmentErrors () const override
	Return vector of alignment errors. More...
const AlignmentPositionError *	alignmentPositionError () const
	alignment position error - for checking only, otherwise use alignmentErrors() above! More...
Alignments *	alignments () const override
	Return vector of alignment data. More...
void	cacheTransformation () override
	cache the current position, rotation and other parameters (e.g. surface deformations) More...
void	cacheTransformation (const align::RunNumber &) override
	cache for the given run the current position, rotation and other parameters (e.g. surface deformations) More...
const Alignables &	components () const override
	Returns a null vector (no components here) More...
void	dump () const override
	Printout information about GeomDet. More...
void	move (const GlobalVector &displacement) override
	Move with respect to the global reference frame. More...
void	recursiveComponents (Alignables &result) const override
	Do nothing (no components here, so no subcomponents either...) More...
void	restoreCachedTransformation () override
	restore the previously cached transformation More...
void	restoreCachedTransformation (const align::RunNumber &) override
	restore for the given run the previously cached transformation More...
void	rotateInGlobalFrame (const RotationType &rotation) override
	Rotation with respect to the global reference frame. More...
void	setAlignmentPositionError (const AlignmentPositionError &ape, bool) final
	Set the AlignmentPositionError (no components => second argument ignored) More...
void	setSurfaceDeformation (const SurfaceDeformation *deformation, bool) final
	Set surface deformation parameters (2nd argument without effect) More...
int	surfaceDeformationIdPairs (std::vector< std::pair< int, SurfaceDeformation *> > &) const override
	Return surface deformations. More...
void	update (const GeomDetUnit *geomDetUnit)
	~AlignableDetUnit () override
	Destructor. More...
Public Member Functions inherited from Alignable
	Alignable (align::ID, const AlignableSurface &)
	Alignable (align::ID, const RotationType &)
AlignmentParameters *	alignmentParameters () const
	Get the AlignmentParameters. More...
virtual CompConstraintType	compConstraintType () const
	Return the alignable type of contraints wrt. its components. More...
const Alignables &	deepComponents () const
const GlobalVector &	displacement () const
	Return change of the global position since the creation of the object. More...
bool	firstCompsWithParams (Alignables &paramComps) const
const DetId &	geomDetId () const
const PositionType &	globalPosition () const
	Return the global position of the object. More...
const RotationType &	globalRotation () const
	Return the global orientation of the object. More...
align::ID	id () const
	Return the ID of Alignable, i.e. DetId of 'first' component GeomDet(Unit). More...
bool	lastCompsWithParams (Alignables &paramComps) const
Alignable *	mother () const
	Return pointer to container alignable (if any) More...
virtual void	recenterSurface ()
	Recenter surface object without moving possible components. More...
virtual void	rotateAroundGlobalAxis (const GlobalVector &axis, Scalar radians)
	Rotation around arbitratry global axis. More...
virtual void	rotateAroundGlobalX (Scalar radians)
	Rotation around global x-axis. More...
virtual void	rotateAroundGlobalY (Scalar radians)
	Rotation around global y-axis. More...
virtual void	rotateAroundGlobalZ (Scalar radians)
	Rotation around global z-axis. More...
virtual void	rotateAroundLocalAxis (const LocalVector &axis, Scalar radians)
	Rotation around arbitratry local axis. More...
virtual void	rotateAroundLocalX (Scalar radians)
	Rotation around local x-axis. More...
virtual void	rotateAroundLocalY (Scalar radians)
	Rotation around local y-axis. More...
virtual void	rotateAroundLocalZ (Scalar radians)
	Rotation around local z-axis. More...
virtual void	rotateInLocalFrame (const RotationType &rotation)
	Rotation intepreted in the local reference frame. More...
const RotationType &	rotation () const
	Return change of orientation since the creation of the object. More...
void	setAlignmentParameters (AlignmentParameters *dap)
	Set the AlignmentParameters. More...
void	setMother (Alignable *mother)
	Assign mother to alignable. More...
void	setSurvey (const SurveyDet *)
	Set survey info. More...
int	size () const
	Return number of direct components. More...
const AlignableSurface &	surface () const
	Return the Surface (global position and orientation) of the object. More...
AlignmentSurfaceDeformations *	surfaceDeformations () const
	Return surface deformations, sorted by DetId. More...
const SurveyDet *	survey () const
	Return survey info. More...
void	update (align::ID, const AlignableSurface &)
virtual	~Alignable ()
	Destructor. More...

Private Attributes
Cache< SurfaceDeformation * >	surfaceDeformationsCache_
AlignmentPositionError *	theAlignmentPositionError
SurfaceDeformation *	theCachedSurfaceDeformation
SurfaceDeformation *	theSurfaceDeformation

Static Private Attributes
static const Alignables	emptyComponents_ {}

Additional Inherited Members
Public Types inherited from Alignable
typedef align::Alignables	Alignables
enum	CompConstraintType { CompConstraintType::NONE, CompConstraintType::POSITION, CompConstraintType::POSITION_Z }
typedef align::GlobalVector	GlobalVector
typedef align::LocalVector	LocalVector
typedef align::PositionType	PositionType
typedef align::RotationType	RotationType
typedef align::Scalar	Scalar
typedef align::StructureType	StructureType
Protected Types inherited from Alignable
template<class T >
using	Cache = std::map< align::RunNumber, T >
Protected Member Functions inherited from Alignable
void	addDisplacement (const GlobalVector &displacement)
void	addRotation (const RotationType &rotation)
virtual void	updateMother (const GlobalVector &shift)
Protected Attributes inherited from Alignable
CompConstraintType	compConstraintType_ {CompConstraintType::NONE}
Cache< GlobalVector >	displacementsCache_
Cache< RotationType >	rotationsCache_
Cache< AlignableSurface >	surfacesCache_
GlobalVector	theCachedDisplacement
RotationType	theCachedRotation
AlignableSurface	theCachedSurface
Alignables	theDeepComponents
DetId	theDetId
GlobalVector	theDisplacement
align::ID	theId
RotationType	theRotation
AlignableSurface	theSurface

Detailed Description

A concrete class that allows to (mis)align a DetUnit.

Typically all AlignableComposites have (directly or indirectly) this one as the ultimate component.

Definition at line 12 of file AlignableDetUnit.h.

Constructor & Destructor Documentation

AlignableDetUnit()

AlignableDetUnit::AlignableDetUnit

(

const GeomDetUnit *

geomDetUnit

)

Constructor from GeomDetUnit - must not be NULL pointer!

Definition at line 15 of file AlignableDetUnit.cc.

References GeomDet::alignmentPositionError(), setAlignmentPositionError(), setSurfaceDeformation(), GeomDet::surfaceDeformation(), and Alignable::theDeepComponents.

    :  // 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::~AlignableDetUnit ( )

override

Destructor.

Definition at line 35 of file AlignableDetUnit.cc.

References Alignable::surface(), surfaceDeformationsCache_, theAlignmentPositionError, theCachedSurfaceDeformation, and theSurfaceDeformation.

                                    {
  delete theAlignmentPositionError;
  delete theSurfaceDeformation;
  delete theCachedSurfaceDeformation;
  for (auto surface : surfaceDeformationsCache_)
    delete surface.second;
}

Member Function Documentation

addAlignmentPositionError()

void AlignableDetUnit::addAlignmentPositionError ( const AlignmentPositionError &  ape, bool  propagateDown  )

finalvirtual

Add (or set if it does not exist yet) the AlignmentPositionError (no components => second argument without effect)

Implements Alignable.

Definition at line 89 of file AlignableDetUnit.cc.

References setAlignmentPositionError(), and theAlignmentPositionError.

Referenced by addAlignmentPositionErrorFromRotation().

                                                                                                      {
  if (!theAlignmentPositionError)
    this->setAlignmentPositionError(ape, propagateDown);  // 2nd argument w/o effect
  else
    *theAlignmentPositionError += ape;
}

addAlignmentPositionErrorFromLocalRotation()

void AlignableDetUnit::addAlignmentPositionErrorFromLocalRotation ( const RotationType &  rot, bool  propagateDown  )

finalvirtual

Add (or set if it does not exist yet) the AlignmentPositionError resulting from a rotation in the local reference frame (no components => second argument without effect)

Implements Alignable.

Definition at line 111 of file AlignableDetUnit.cc.

References addAlignmentPositionErrorFromRotation(), Alignable::globalRotation(), TkRotation< T >::multiplyInverse(), and makeMuonMisalignmentScenario::rot.

                                                                                                             {
  RotationType globalRot = globalRotation().multiplyInverse(rot * globalRotation());
  this->addAlignmentPositionErrorFromRotation(globalRot, propagateDown);  // 2nd argument w/o effect
}

addAlignmentPositionErrorFromRotation()

void AlignableDetUnit::addAlignmentPositionErrorFromRotation ( const RotationType &  rot, bool  propagateDown  )

finalvirtual

Add (or set if it does not exist yet) the AlignmentPositionError resulting from a rotation in the global reference frame (no components => second argument without effect)

Implements Alignable.

Definition at line 97 of file AlignableDetUnit.cc.

References addAlignmentPositionError(), PV3DBase< T, PVType, FrameType >::basicVector(), makeMuonMisalignmentScenario::rot, Alignable::surface(), AlignableSurface::toGlobal(), and ApeEstimator_cff::width.

Referenced by addAlignmentPositionErrorFromLocalRotation().

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

addComponent()

void AlignableDetUnit::addComponent ( Alignable *  )

finalvirtual

No components here => exception!

Implements Alignable.

Definition at line 64 of file AlignableDetUnit.cc.

References Exception.

                                                {
  throw cms::Exception("LogicError") << "AlignableDetUnit cannot have components, but try to add one!";
}

addSurfaceDeformation()

void AlignableDetUnit::addSurfaceDeformation ( const SurfaceDeformation *  deformation, bool  propagateDown  )

finalvirtual

Add surface deformation parameters to the existing ones (2nd argument without effect)

Implements Alignable.

Definition at line 127 of file AlignableDetUnit.cc.

References SurfaceDeformation::add(), setSurfaceDeformation(), theSurfaceDeformation, and SurfaceDeformation::type().

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

alignableObjectId()

StructureType AlignableDetUnit::alignableObjectId ( ) const

inlineoverridevirtual

Return the alignable type identifier.

Implements Alignable.

Definition at line 62 of file AlignableDetUnit.h.

References align::AlignableDetUnit.

{ return align::AlignableDetUnit; }

alignmentErrors()

AlignmentErrorsExtended * AlignableDetUnit::alignmentErrors ( void  ) const

overridevirtual

Return vector of alignment errors.

Implements Alignable.

Definition at line 181 of file AlignableDetUnit.cc.

References asHepMatrix(), Alignable::geomDetId(), AlignmentPositionError::globalError(), AlignmentErrorsExtended::m_alignError, GlobalErrorBaseExtended< T, ErrorWeightType >::matrix(), DetId::rawId(), and theAlignmentPositionError.

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

alignmentPositionError()

const AlignmentPositionError* AlignableDetUnit::alignmentPositionError ( ) const

inline

alignment position error - for checking only, otherwise use alignmentErrors() above!

Definition at line 89 of file AlignableDetUnit.h.

References theAlignmentPositionError.

Referenced by AlignableDetOrUnitPtr::alignmentPositionError().

{ return theAlignmentPositionError; }

alignments()

Alignments * AlignableDetUnit::alignments ( void  ) const

overridevirtual

Return vector of alignment data.

Implements Alignable.

Definition at line 162 of file AlignableDetUnit.cc.

References Alignable::geomDetId(), Alignable::globalPosition(), Alignable::globalRotation(), Alignments::m_align, DetId::rawId(), makeMuonMisalignmentScenario::rot, HcalDetIdTransform::transform(), x, y, and z.

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

cacheTransformation() [1/2]

void AlignableDetUnit::cacheTransformation ( )

overridevirtual

cache the current position, rotation and other parameters (e.g. surface deformations)

Reimplemented from Alignable.

Definition at line 208 of file AlignableDetUnit.cc.

References SurfaceDeformation::clone(), Alignable::theCachedDisplacement, Alignable::theCachedRotation, Alignable::theCachedSurface, theCachedSurfaceDeformation, Alignable::theDisplacement, Alignable::theRotation, Alignable::theSurface, and theSurfaceDeformation.

                                           {
  theCachedSurface = theSurface;
  theCachedDisplacement = theDisplacement;
  theCachedRotation = theRotation;

  if (theCachedSurfaceDeformation) {
    delete theCachedSurfaceDeformation;
    theCachedSurfaceDeformation = nullptr;
  }

  if (theSurfaceDeformation)
    theCachedSurfaceDeformation = theSurfaceDeformation->clone();
}

cacheTransformation() [2/2]

void AlignableDetUnit::cacheTransformation ( const align::RunNumber &  run )

overridevirtual

cache for the given run the current position, rotation and other parameters (e.g. surface deformations)

Reimplemented from Alignable.

Definition at line 223 of file AlignableDetUnit.cc.

References SurfaceDeformation::clone(), Alignable::displacementsCache_, Alignable::rotationsCache_, writedatasetfile::run, surfaceDeformationsCache_, Alignable::surfacesCache_, Alignable::theDisplacement, Alignable::theRotation, Alignable::theSurface, and theSurfaceDeformation.

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

components()

const Alignables& AlignableDetUnit::components ( ) const

inlineoverridevirtual

Returns a null vector (no components here)

Implements Alignable.

Definition at line 28 of file AlignableDetUnit.h.

References emptyComponents_.

{ return emptyComponents_; }

dump()

void AlignableDetUnit::dump ( void  ) const

overridevirtual

Printout information about GeomDet.

Implements Alignable.

Definition at line 142 of file AlignableDetUnit.cc.

References Alignable::displacement(), Alignable::globalPosition(), Alignable::globalRotation(), SurfaceDeformation::parameters(), Alignable::rotation(), and theSurfaceDeformation.

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

move()

void AlignableDetUnit::move ( const GlobalVector &  displacement )

overridevirtual

Move with respect to the global reference frame.

Implements Alignable.

Definition at line 69 of file AlignableDetUnit.cc.

References Alignable::addDisplacement(), Alignable::displacement(), GloballyPositioned< T >::move(), and Alignable::theSurface.

                                                            {
  theSurface.move(displacement);
  this->addDisplacement(displacement);
}

recursiveComponents()

void AlignableDetUnit::recursiveComponents ( Alignables &  result ) const

inlineoverridevirtual

Do nothing (no components here, so no subcomponents either...)

Implements Alignable.

Definition at line 31 of file AlignableDetUnit.h.

{}

restoreCachedTransformation() [1/2]

void AlignableDetUnit::restoreCachedTransformation ( )

overridevirtual

restore the previously cached transformation

Reimplemented from Alignable.

Definition at line 240 of file AlignableDetUnit.cc.

References setSurfaceDeformation(), Alignable::theCachedDisplacement, Alignable::theCachedRotation, Alignable::theCachedSurface, theCachedSurfaceDeformation, Alignable::theDisplacement, Alignable::theRotation, Alignable::theSurface, and theSurfaceDeformation.

                                                   {
  theSurface = theCachedSurface;
  theDisplacement = theCachedDisplacement;
  theRotation = theCachedRotation;

  if (theSurfaceDeformation) {
    delete theSurfaceDeformation;
    theSurfaceDeformation = nullptr;
  }

  if (theCachedSurfaceDeformation) {
    this->setSurfaceDeformation(theCachedSurfaceDeformation, false);
  }
}

restoreCachedTransformation() [2/2]

void AlignableDetUnit::restoreCachedTransformation ( const align::RunNumber &  run )

overridevirtual

restore for the given run the previously cached transformation

Reimplemented from Alignable.

Definition at line 256 of file AlignableDetUnit.cc.

References Alignable::displacementsCache_, Exception, Alignable::rotationsCache_, writedatasetfile::run, setSurfaceDeformation(), surfaceDeformationsCache_, Alignable::surfacesCache_, Alignable::theDisplacement, Alignable::theRotation, Alignable::theSurface, and theSurfaceDeformation.

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

rotateInGlobalFrame()

void AlignableDetUnit::rotateInGlobalFrame ( const RotationType &  rotation )

overridevirtual

Rotation with respect to the global reference frame.

Implements Alignable.

Definition at line 75 of file AlignableDetUnit.cc.

References Alignable::addRotation(), GloballyPositioned< T >::rotate(), Alignable::rotation(), and Alignable::theSurface.

                                                                       {
  theSurface.rotate(rotation);
  this->addRotation(rotation);
}

setAlignmentPositionError()

void AlignableDetUnit::setAlignmentPositionError ( const AlignmentPositionError &  ape, bool    )

finalvirtual

Set the AlignmentPositionError (no components => second argument ignored)

Implements Alignable.

Definition at line 81 of file AlignableDetUnit.cc.

References theAlignmentPositionError.

Referenced by addAlignmentPositionError(), AlignableDetUnit(), and update().

                                                                                          {
  if (!theAlignmentPositionError)
    theAlignmentPositionError = new AlignmentPositionError(ape);
  else
    *theAlignmentPositionError = ape;
}

setSurfaceDeformation()

void AlignableDetUnit::setSurfaceDeformation ( const SurfaceDeformation *  deformation, bool    )

finalvirtual

Set surface deformation parameters (2nd argument without effect)

Implements Alignable.

Definition at line 117 of file AlignableDetUnit.cc.

References SurfaceDeformation::clone(), and theSurfaceDeformation.

Referenced by addSurfaceDeformation(), AlignableDetUnit(), restoreCachedTransformation(), and update().

                                                                                          {
  delete theSurfaceDeformation;  // OK for zero pointers
  if (deformation) {
    theSurfaceDeformation = deformation->clone();
  } else {
    theSurfaceDeformation = nullptr;
  }
}

surfaceDeformationIdPairs()

int AlignableDetUnit::surfaceDeformationIdPairs ( std::vector< std::pair< int, SurfaceDeformation *> > &  result ) const

overridevirtual

Return surface deformations.

Implements Alignable.

Definition at line 198 of file AlignableDetUnit.cc.

References Alignable::geomDetId(), mps_fire::result, and theSurfaceDeformation.

                                                                                                           {
  if (theSurfaceDeformation) {
    result.push_back(std::pair<int, SurfaceDeformation*>(this->geomDetId().rawId(), theSurfaceDeformation));
    return 1;
  }

  return 0;
}

update()

void AlignableDetUnit::update

(

const GeomDetUnit *

geomDetUnit

)

Updater from GeomDetUnit The given GeomDetUnit id has to match the current id.

Definition at line 44 of file AlignableDetUnit.cc.

References GeomDet::alignmentPositionError(), Exception, GeomDet::geographicalId(), DetId::rawId(), setAlignmentPositionError(), setSurfaceDeformation(), GeomDet::surface(), GeomDet::surfaceDeformation(), and Alignable::update().

Referenced by progressbar.ProgressBar::__next__(), MatrixUtil.Matrix::__setitem__(), MatrixUtil.Steps::__setitem__(), AlignableTrackerBuilder::buildPixelDetectorAlignable(), dqm-mbProfile.Profile::finish(), progressbar.ProgressBar::finish(), MatrixUtil.Steps::overwrite(), and AlignableDet::update().

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

Member Data Documentation

emptyComponents_

const align::Alignables AlignableDetUnit::emptyComponents_ {}

staticprivate

Definition at line 92 of file AlignableDetUnit.h.

Referenced by components().

surfaceDeformationsCache_

Cache<SurfaceDeformation*> AlignableDetUnit::surfaceDeformationsCache_

private

Definition at line 96 of file AlignableDetUnit.h.

Referenced by cacheTransformation(), restoreCachedTransformation(), and ~AlignableDetUnit().

theAlignmentPositionError

AlignmentPositionError* AlignableDetUnit::theAlignmentPositionError

private

Definition at line 93 of file AlignableDetUnit.h.

Referenced by addAlignmentPositionError(), alignmentErrors(), alignmentPositionError(), setAlignmentPositionError(), and ~AlignableDetUnit().

theCachedSurfaceDeformation

SurfaceDeformation* AlignableDetUnit::theCachedSurfaceDeformation

private

Definition at line 95 of file AlignableDetUnit.h.

Referenced by cacheTransformation(), restoreCachedTransformation(), and ~AlignableDetUnit().

theSurfaceDeformation

SurfaceDeformation* AlignableDetUnit::theSurfaceDeformation

private

Definition at line 94 of file AlignableDetUnit.h.

Referenced by addSurfaceDeformation(), cacheTransformation(), dump(), restoreCachedTransformation(), setSurfaceDeformation(), surfaceDeformationIdPairs(), and ~AlignableDetUnit().