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