AlignTSOS.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef TRKALIGNEVENT_ALIGNTSOS_H
#define TRKALIGNEVENT_ALIGNTSOS_H
 
#include "TrkEventPrimitives/TrackStateDefs.h"
#include "TrkTrack/TrackStateOnSurface.h"
#include "Identifier/Identifier.h"
#include "TrkAlignEvent/Residual.h"
 
#include <vector>
 
namespace CLHEP {
  class HepVector;
}
 
namespace Trk {
  
  class CompetingRIOsOnTrack;
  class RIO_OnTrack;
  class AlignModule;
  class TrkDetElementBase;
 
  class AlignTSOS : public TrackStateOnSurface {
    
  public:
 
    AlignTSOS(const TrackStateOnSurface& tsos, AlignModule * module,
          const RIO_OnTrack * rio, 
          TrackState::MeasurementType detType);       
 
    AlignTSOS(const TrackStateOnSurface& tsos, AlignModule * module,
          const CompetingRIOsOnTrack * crio, 
          TrackState::MeasurementType detType);
 
    AlignTSOS(const TrackStateOnSurface& tsos, 
          TrackState::MeasurementType measType);
 
    AlignTSOS(const AlignTSOS& atsos);
 
    virtual ~AlignTSOS();
 
    AlignTSOS& operator=(const AlignTSOS& atsos);
 
    const AlignModule* module() const { return m_module; }
    AlignModule* module() { return m_module; }
 
    void setValid(bool isvalid) { m_isvalid=isvalid; }    
    bool isValid() const { return m_isvalid; }
    
    int nResDim() const { return m_residuals.size(); }
 
    TrackState::MeasurementType measType() const { return m_measType; }
 
    Identifier identify() const;
 
    const RIO_OnTrack* rio() const;
 
    void setCompetingRIOsOnTrack(const CompetingRIOsOnTrack* crio) { m_crio=crio; }
 
    const CompetingRIOsOnTrack* crio() const { return m_crio; }
 
    void addResidual(const Residual& residual) { m_residuals.push_back(residual); }
   
    const std::vector<Residual>& residuals() const { return m_residuals; }
 
    void clearResiduals() { m_residuals.clear(); }
 
    std::vector<Residual>::const_iterator firstResidual() const { return m_residuals.begin(); }
 
    std::vector<Residual>::const_iterator lastResidual() const { return m_residuals.end(); }
 
    const TrkDetElementBase* detelement(int i=0) const { return m_detelements[i]; }
 
    int nDetElements() const { return m_detelements.size(); }
 
    std::string dumpMeasType() const;
 
    void setAlphaStrip(double alpha) { m_alphaStrip = alpha; }
 
    double alphaStrip() const { return m_alphaStrip; }
 
    void setMeasDir(Trk::ParamDefs dir) { m_measDir = dir; }
 
    Trk::ParamDefs measDir() const { return m_measDir; }
 
    std::string dumpMeasDir() const;
 
    const TrackParameters * unbiasedTrackPars() const { return m_unbiasedTrackPars; }
 
    void setUnbiasedTrackPars(const TrackParameters * trkPars) { m_unbiasedTrackPars = trkPars; }
 
    const std::vector<Amg::VectorX> * derivatives() const { return m_derivatives; }
 
    const std::vector<Amg::VectorX> * derivativesVtx() const { return m_derivativesVtx; }
 
    void setDerivatives(std::vector<Amg::VectorX> * derivs) { m_derivatives = derivs; }
 
    void setDerivativesVtx(std::vector<Amg::VectorX> * derivs) { m_derivativesVtx = derivs; }
 
    virtual TrackStateOnSurface::Variety variety() const override final {
      return TrackStateOnSurface::Align;
    }
   private:
    // private methods
    AlignTSOS();  // don't use this one
 
    // private variables    
    AlignModule * m_module;
    const RIO_OnTrack * m_rio;   
    const CompetingRIOsOnTrack * m_crio;
 
    const TrackParameters * m_unbiasedTrackPars;
 
    std::vector<Residual> m_residuals;
 
    std::vector<const TrkDetElementBase *> m_detelements;
 
    std::vector<Amg::VectorX> * m_derivatives;
 
    bool   m_isvalid;
 
    TrackState::MeasurementType m_measType;
 
    Trk::ParamDefs m_measDir; 
 
    double m_alphaStrip;
 
    std::vector<Amg::VectorX> * m_derivativesVtx;
 
  }; // end class
  
  MsgStream& operator << ( MsgStream& sl, const AlignTSOS& atsos);
  
} // end namespace
 
#endif // TRKALIGNEVENT_ALIGNTSOS_H