ShiftingDerivCalcTool.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef TRK_SHIFTINGDERIVCALCTOOL_H
#define TRK_SHIFTINGDERIVCALCTOOL_H
 
#include "AthenaBaseComps/AthAlgTool.h"
#include "GaudiKernel/ToolHandle.h"
 
#include "TrkEventPrimitives/ParamDefs.h"
#include "TrkEventPrimitives/ParticleHypothesis.h"
 
#include "TrkFitterInterfaces/IGlobalTrackFitter.h"
#include "TrkAlignInterfaces/IDerivCalcTool.h"
#include "TrkAlignInterfaces/IAlignResidualCalculator.h"
#include "TrkAlignInterfaces/IAlignModuleTool.h"
 
 
#include <vector>
#include <map>

 
class TGraph;
 
namespace Trk {
 
  class TrackStateOnSurface;
  class Track;
  class AlignModule;
  class AlignTSOS;
  class AlignTrack;
  class AlignPar;
 
  class ShiftingDerivCalcTool : virtual public IDerivCalcTool, public AthAlgTool {
 
  public:
    ShiftingDerivCalcTool(const std::string& type, const std::string& name,
                           const IInterface* parent);
    virtual ~ShiftingDerivCalcTool();
 
    StatusCode initialize();
    StatusCode finalize();

    bool setDerivatives(AlignTrack* track);
 
    void showStatistics() {}

    bool setResidualCovMatrix(AlignTrack* alignTrack) const;
 
  protected:
 
    // protected typedefs
    typedef std::vector<Amg::VectorX> HitDerivative;
    typedef std::map<const TrackStateOnSurface*,HitDerivative*> DerivativeMap;
    typedef DerivativeMap::value_type DerivativePair;
    
    // protected methods
    Amg::VectorX getDerivatives(AlignTrack* alignTrack, 
                                int ipar, AlignPar* alignPar,
                                Amg::VectorX& derivativeErr, bool& resetIPar,
                                double& actualSecondDerivative);
 
    void   setChi2VAlignParam(const AlignTrack* alignTrack, 
                              const AlignModule* module,
                              int nshifts=0);
    void   deleteChi2VAlignParam();
 
    double shiftSize(const AlignPar* alignPar) const;
    bool   setUnshiftedResiduals(AlignTrack* alignTrack);
 
  private:
    // private methods
    const Trk::Track* bestPerigeeTrack(const Track* track) const;
    bool scanShifts(const AlignTrack* alignTrack, 
    const std::vector<AlignModule*>& alignModules);
 
    bool getAllDerivatives(AlignTrack* alignTrack, const AlignModule* alignModule,
                           std::vector<Amg::VectorX>& deriv_vec,
                           std::vector<Amg::VectorX>& derivErr_vec,
                           std::vector<double>& actualsecderiv_vec,
                           bool& resetIPar);
 
    // private variables
    ToolHandle<IGlobalTrackFitter> m_trackFitterTool
      {this, "TrackFitterTool", "Trk::GlobalChi2Fitter/MCTBFitter"};
    ToolHandle<IGlobalTrackFitter> m_SLTrackFitterTool
      {this, "SLTrackFitterTool", "Trk::GlobalChi2Fitter/MCTBSLFitter"};
    ToolHandle<IGlobalTrackFitter> m_fitter;
    
    ToolHandle<IAlignResidualCalculator> m_residualCalculator
      {this, "ResidualCalculator", "Trk::AlignResidualCalculator/ResidualCalculator"};
    ToolHandle<IAlignModuleTool> m_alignModuleTool
      {this, "AlignModuleTool", "Trk::AlignModuleTool/AlignModuleTool"};
 
    Gaudi::Property<double> m_traSize{this, "TranslationSize", .1};
    Gaudi::Property<double> m_rotSize{this, "RotationSize", .1};
 
    Gaudi::Property<bool> m_runOutlierRemoval
      {this, "RunOutlierRemoval", false};
    ParticleHypothesis m_particleHypothesis = Trk::muon;
 
    Gaudi::Property<int> m_particleNumber{this, "ParticleNumber", 2};
 
    DerivativeMap m_derivative_map;
  
    Gaudi::Property<bool> m_doFits{this, "doResidualFits", true};
    Gaudi::Property<int> m_nFits{this, "NumberOfShifts", 5};
    Gaudi::Property<bool> m_doChi2VAlignParamMeasType
      {this, "doChi2VChamberShiftsMeasType", false};
    Gaudi::Property<bool> m_doResidualPlots{this, "doResidualPlots", false};
    int m_nIterations = 0;
 
    Amg::VectorX* m_unshiftedResiduals = nullptr;
    Amg::VectorX* m_unshiftedResErrors = nullptr;
 
    // stores double** for each module that track passes through
    std::vector<double**> m_chi2VAlignParamVec;  
    std::vector<double**> m_chi2VAlignParamXVec; 
 
    double** m_tmpChi2VAlignParam = nullptr;
    double** m_tmpChi2VAlignParamX = nullptr;
    double*** m_tmpChi2VAlignParamMeasType = nullptr;
 
    // stores double*** for each module that track passes through 
    // (one double** for each TrackState::MeasurementType)
    std::vector<double***> m_chi2VAlignParamVecMeasType;  
 
    double  m_unshiftedTrackChi2{};
    std::unique_ptr<double[]> m_unshiftedTrackChi2MeasType;

    Gaudi::Property<double> m_trackAlignParamCut{this, "TrackAlignParamCut", 1e6};

    Gaudi::Property<bool> m_setMinIterations{this, "SetMinIterations", false};

    Gaudi::Property<int> m_maxIter{this, "MaxIterations", 50};

    Gaudi::Property<int> m_minIter{this, "MinIterations", 10};

    Gaudi::Property<bool> m_removeScatteringBeforeRefit
      {this, "RemoveScatteringBeforeRefit", false};
 
    int m_ntracksProcessed = 0;           
    int m_ntracksPassInitScan = 0;        
    int m_ntracksPassSetUnshiftedRes = 0; 
    int m_ntracksPassDerivatives = 0;     
    int m_ntracksPassGetDeriv = 0;        
    int m_ntracksPassGetDerivSecPass = 0; 
    int m_ntracksPassGetDerivLastPass = 0; 
    int m_ntracksFailMaxIter = 0;
    int m_ntracksFailTrackRefit = 0;
    int m_ntracksFailAlignParamCut = 0;
    int m_ntracksFailFinalAttempt = 0;
 
    bool m_secPass{};
 
  }; // end class
 
 
} // end namespace
 
#endif // TRK_SHIFTINGDERIVCALCTOOL_H