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 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* );

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

};

typedef std::vector<Alignable*> Alignables;

#endif