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