AlignModule.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef TRKALIGNEVENT_ALIGNMODULE_H
#define TRKALIGNEVENT_ALIGNMODULE_H
 
#include "TrkEventPrimitives/ParamDefs.h"
 
 
#include "AthenaBaseComps/AthMessaging.h"
#include "Identifier/Identifier.h"
#include "TrkTrack/TrackStateOnSurface.h"
#include "TrkEventPrimitives/TrackStateDefs.h"
 
#include <vector>
#include <string>
 
class MsgStream;
class AlgTool;
 
namespace Trk {
  
  class TrkDetElementBase;
  class AlignTrack;
  class AlignPar;
 
  void decomposeTransform(const Amg::Transform3D& transform, double* values);
  
  class AlignModule : public AthMessaging {
       
  public:
    
    // enums/typedefs
    
    enum TransformParameters { TransX=0, TransY, TransZ, RotX, RotY, RotZ, BowX, BowY, BowZ,  
             NTransformPar, MaxNPar=10 };
        
    enum DetectorType { unidentified=0,Pixel,SCT,TRT,MDT,CSC,RPC,TGC,NDetectorTypes};    
      
    typedef std::vector<const TrkDetElementBase*> DetElementCollection;
    typedef std::vector<Identifier>               IdentifierCollection;
    typedef std::vector<Amg::Transform3D>           TransformCollection;
 
    // constructors/destructor
 
    AlignModule(const AlgTool* algtool, 
                const Amg::Transform3D& globalToAlignXform=Amg::Transform3D::Identity(),
                const std::string& name="");
 
    AlignModule() = delete; // don't allow constructor without IMessageSvc
    
    AlignModule(const AlignModule & rhs) = delete;
    
    AlignModule & operator=(const AlignModule & rhs) = delete;
 
    virtual ~AlignModule();
 
    // public methods
 
    void  setName(const std::string& name) { m_name=name; }
    const std::string& name() const { return m_name; }
 
    IdentifierHash  identifyHash() const { return m_idHash; }
    void setIdHash(IdentifierHash id) { m_idHash = id; }
    
    void setIdentifier(Identifier identifier) { m_identifier = identifier; }
    Identifier identify() const { return m_identifier; }
 
    unsigned int identify32() const { return m_identifier.get_identifier32().get_compact(); }
 
    // alignment transforms
 
    const Amg::Transform3D& globalFrameToAlignFrame() const { return m_globalToAlignFrameTransform ; }
 
    const Amg::RotationMatrix3D& globalToAlignFrameRotation() const { return m_globalToAlignFrameRotation ; }
    const Amg::Vector3D&         globalToAlignFrameTranslation() const { return m_globalToAlignFrameTranslation ; }
    
    void setGlobalFrameToAlignFrameTransform( const Amg::Transform3D& t ) {
      m_globalToAlignFrameTransform   = t ;
      m_globalToAlignFrameTranslation = t.translation() ;
      m_globalToAlignFrameRotation    = t.rotation() ;
    }
 
    void setAlignParShift(const AlignPar* alignPar) const;
 
    //
    // methods dealing with detector elements
    //
 
    const DetElementCollection* detElementCollection(AlignModule::DetectorType detType) const { return m_detelements[detType]; } 
 
    const IdentifierCollection* identifierCollection(AlignModule::DetectorType detType) const { return m_detIdentifiers[detType]; }
 
    const std::vector<Amg::Transform3D>* alignModuleToDetElementTransforms(AlignModule::DetectorType detType) { return m_alignModuleToDetElementTransforms[detType]; }
 
    const Amg::Transform3D *
      alignModuleToDetElementTransform(AlignModule::DetectorType detType, 
                                       const TrkDetElementBase* det,
                                       const Identifier id=Identifier()) const;
 
    void addDetElement(AlignModule::DetectorType detType,
                       const TrkDetElementBase* det,
                       const Amg::Transform3D &transform,
                       Identifier id=Identifier());
    
    //
    // methods used for numerical derivatives
    // 
 
    void setNChamberShifts(int nShifts) { m_nChamberShifts = nShifts; }
    int  nChamberShifts() const { return m_nChamberShifts; }
 
    void     setChi2VAlignParamArray(double** chi2VAlignParam) { m_chi2VAlignParam = chi2VAlignParam; }
    double** chi2VAlignParamArray() const { return m_chi2VAlignParam; }
 
    void     setChi2VAlignParamXArray(double** chi2VAlignParamX) { m_chi2VAlignParamX = chi2VAlignParamX; }
    double** chi2VAlignParamXArray() const { return m_chi2VAlignParamX; }
    
    void     setChi2VAlignParamArrayMeasType(int measType, double** chi2VAlignParam) { m_chi2VAlignParamMeasType[measType]=chi2VAlignParam; }
    double** chi2VAlignParamArrayMeasType(int measType) const { return m_chi2VAlignParamMeasType[measType]; }
    
    //
    // miscellaneous methods
    //
    
    void addTrack(int ntracks=1) { m_ntracks+=ntracks; }
    int  nTracks() const { return m_ntracks; }
    void setNTracks(int ntracks) { m_ntracks=ntracks; }
 
    void addTrackChi2(double chi2) { m_trackchi2+=chi2; }
    double trackChi2() const { return m_trackchi2; }
    void setTrackChi2(double chi2) { m_trackchi2=chi2; }
 
    void addHit(int nhits=1) { m_nhits+=nhits; }
    int  nHits() const { return m_nhits; }
    void setNHits(int nhits) { m_nhits=nhits; }
 
    void addNDoF(int nDoF) { m_nDoF+=nDoF; }
    int  nDoF() const { return m_nDoF; }
    void setNDoF(int nDoF) { m_nDoF=nDoF; }
 
    static Amg::Vector3D  centerOfGravity(const std::vector<DetElementCollection*>&);
    Amg::Vector3D         centerOfGravity() const;
 
    void shiftSurface(TrkDetElementBase*, Identifier) const {}
    void restoreSurfaces(TrkDetElementBase*) const {}
 
    Amg::Transform3D  calculateAlignModuleToGlobal() const;
     
    void resetAlignModuleToDetElementTransforms();
 
 
 
  protected:
 
    std::vector<DetElementCollection*> m_detelements;
    std::vector<IdentifierCollection*> m_detIdentifiers;
 
    // vector of parameters and transforms for individual detectors
    std::vector<std::vector<Amg::Transform3D>* > m_alignModuleToDetElementTransforms;
 
  private:
    
    
    // private variables
    Amg::Transform3D        m_globalToAlignFrameTransform ;   // transform to go from global frame to alignment frame
    Amg::RotationMatrix3D   m_globalToAlignFrameRotation ;    // cache for speed up
    Amg::Vector3D           m_globalToAlignFrameTranslation ;  //actually a vector not a point
        
    
    // chi2 vs. align parameters
    int      m_nChamberShifts;
    double** m_chi2VAlignParam;
    double** m_chi2VAlignParamX;
    double*** m_chi2VAlignParamMeasType;
    
    std::string    m_name;
    IdentifierHash m_idHash;
    Identifier     m_identifier;
 
    int m_ntracks; // number of tracks going through module
    int m_nhits;   // number of hits in the module
 
    double m_trackchi2; // chi2 of tracks going through module
    int    m_nDoF;    // number of degrees of freedom for tracks going through module
    
  }; // end class
 
 
  std::string detTypeStr(AlignModule::DetectorType detType);
 
  MsgStream& operator << (MsgStream& sl, const AlignModule& alignModule);
 
 
} // end namespace
 
#endif // TRKALIGNEVENT_ALIGNMODULE_H