Alignable.h

Go to the documentation of this file.

#ifndef Alignment_CommonAlignment_Alignable_H
#define Alignment_CommonAlignment_Alignable_H
 
#include "Alignment/CommonAlignment/interface/AlignableSurface.h"
#include "Alignment/CommonAlignment/interface/StructureType.h"
#include "Alignment/CommonAlignment/interface/Utilities.h"
#include "DataFormats/DetId/interface/DetId.h"
 
class AlignmentErrorsExtended;
class AlignmentParameters;
class AlignmentPositionError;
class Alignments;
class AlignmentSurfaceDeformations;
class SurfaceDeformation;
 
class AlignmentParameters;
class SurveyDet;
 
class Alignable {
public:
  typedef align::Scalar Scalar;
  typedef align::PositionType PositionType;
  typedef align::RotationType RotationType;
  typedef align::GlobalVector GlobalVector;
  typedef align::LocalVector LocalVector;
  typedef align::Alignables Alignables;
  typedef align::StructureType StructureType;
 
  enum class CompConstraintType { NONE, POSITION, POSITION_Z };
 
  Alignable(align::ID, const AlignableSurface&);
 
  Alignable(align::ID, const RotationType&);
 
  virtual ~Alignable();
 
  void update(align::ID, const AlignableSurface&);
 
  void setAlignmentParameters(AlignmentParameters* dap);
 
  AlignmentParameters* alignmentParameters() const { return theAlignmentParameters; }
 
  virtual void addComponent(Alignable*) = 0;
 
  virtual const Alignables& components() const = 0;
 
  int size() const { return components().size(); }
 
  const Alignables& deepComponents() const { return theDeepComponents; }
 
  virtual void recursiveComponents(Alignables& result) const = 0;
 
  bool firstCompsWithParams(Alignables& paramComps) const;
 
  bool lastCompsWithParams(Alignables& paramComps) const;
 
  Alignable* mother() const { return theMother; }
 
  void setMother(Alignable* mother) { theMother = mother; }
 
  virtual void move(const GlobalVector& displacement) = 0;
 
  virtual void rotateInGlobalFrame(const RotationType& rotation) = 0;
 
  virtual void rotateInLocalFrame(const RotationType& rotation);
 
  virtual void rotateAroundGlobalAxis(const GlobalVector& axis, Scalar radians);
 
  virtual void rotateAroundLocalAxis(const LocalVector& axis, Scalar radians);
 
  virtual void rotateAroundGlobalX(Scalar radians);
 
  virtual void rotateAroundLocalX(Scalar radians);
 
  virtual void rotateAroundGlobalY(Scalar radians);
 
  virtual void rotateAroundLocalY(Scalar radians);
 
  virtual void rotateAroundGlobalZ(Scalar radians);
 
  virtual void rotateAroundLocalZ(Scalar radians);
 
  const AlignableSurface& surface() const { return theSurface; }
 
  const PositionType& globalPosition() const { return surface().position(); }
 
  const RotationType& globalRotation() const { return surface().rotation(); }
 
  const GlobalVector& displacement() const { return theDisplacement; }
 
  const RotationType& rotation() const { return theRotation; }
 
  virtual void setAlignmentPositionError(const AlignmentPositionError& ape, bool propagateDown) = 0;
 
  virtual void addAlignmentPositionError(const AlignmentPositionError& ape, bool propagateDown) = 0;
 
  virtual void addAlignmentPositionErrorFromRotation(const RotationType& rotation, bool propagateDown) = 0;
 
  virtual void addAlignmentPositionErrorFromLocalRotation(const RotationType& rotation, bool propagateDown) = 0;
 
  virtual void setSurfaceDeformation(const SurfaceDeformation* deformation, bool propagateDown) = 0;
 
  virtual void addSurfaceDeformation(const SurfaceDeformation* deformation, bool propagateDown) = 0;
 
  virtual StructureType alignableObjectId() const = 0;
 
  const DetId& geomDetId() const { return theDetId; }
 
  align::ID id() const { return theId; }
 
  virtual CompConstraintType compConstraintType() const { return compConstraintType_; }
 
  virtual void dump() const = 0;
 
  virtual Alignments* alignments() const = 0;
 
  virtual AlignmentErrorsExtended* alignmentErrors() const = 0;
 
  AlignmentSurfaceDeformations* surfaceDeformations() const;
 
  virtual int surfaceDeformationIdPairs(std::vector<std::pair<int, SurfaceDeformation*> >&) const = 0;
 
  virtual void cacheTransformation();
 
  virtual void cacheTransformation(const align::RunNumber&);
 
  virtual void restoreCachedTransformation();
 
  virtual void restoreCachedTransformation(const align::RunNumber&);
 
  const SurveyDet* survey() const { return theSurvey; }
 
  void setSurvey(const SurveyDet*);
 
  virtual void recenterSurface();
 
protected:
  template <class T>
  using Cache = std::map<align::RunNumber, T>;
 
  void addDisplacement(const GlobalVector& displacement);
  void addRotation(const RotationType& rotation);
  virtual void updateMother(const GlobalVector& shift);
 
  DetId theDetId;  // used to check if Alignable is associated to a GeomDet
                   // ugly way to keep AlignableNavigator happy for now
 
  align::ID theId;  // real ID as int, above DetId should be removed
 
  AlignableSurface theSurface;  // Global position and orientation of surface
 
  GlobalVector theDisplacement;  // total linear displacement
  RotationType theRotation;      // total angular displacement
 
  AlignableSurface theCachedSurface;
  GlobalVector theCachedDisplacement;
  RotationType theCachedRotation;
 
  CompConstraintType compConstraintType_{CompConstraintType::NONE};
 
  Alignables theDeepComponents;  // list of lowest daughters
                                 // contain itself if Alignable is a unit
 
  Cache<AlignableSurface> surfacesCache_;
  Cache<GlobalVector> displacementsCache_;
  Cache<RotationType> rotationsCache_;
 
private:
  Alignable(){};
 
  AlignmentParameters* theAlignmentParameters;
 
  Alignable* theMother;  // Pointer to container
 
  const SurveyDet* theSurvey;  // Pointer to survey info; owned by class
};
 
#endif