MdtDriftCircleOnTrackCreator.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef MUON_MDTDRIFTCIRCLEONTRACKCREATOR_H
#define MUON_MDTDRIFTCIRCLEONTRACKCREATOR_H
 
#include <bitset>
#include <memory>
#include <string>
 
#include "AthenaBaseComps/AthAlgTool.h"
#include "GaudiKernel/PhysicalConstants.h"
#include "MdtCalibData/MdtCalibDataContainer.h"
#include "MdtCalibInterfaces/IMdtCalibrationTool.h"
#include "MuonIdHelpers/IMuonIdHelperSvc.h"
#include "MuonRIO_OnTrack/MdtDriftCircleOnTrack.h"
#include "MuonRIO_OnTrack/MuonDriftCircleErrorStrategy.h"
#include "MuonRecToolInterfaces/IMdtDriftCircleOnTrackCreator.h"
#include "StoreGate/ReadCondHandleKey.h"
#include "TrkEventPrimitives/LocalParameters.h"
#include "TrkSpaceTimePoint/SpaceTimePoint.h"
 
class MdtCalibToolInput;
 
namespace Muon {
 
class MdtPrepData;

class MdtDriftCircleOnTrackCreator: public AthAlgTool, public IMdtDriftCircleOnTrackCreator {
   public:
    enum TimingMode {
        ATLTIME =0, 
        NO_CORRECTIONS = 1,
        COSMICS_TRIGGERTIME = 2,  
        COSMICS_TOF =3,  
               
        NumberOfTimingModes
    };
 
   public:
    MdtDriftCircleOnTrackCreator(const std::string&, const std::string&, const IInterface*);
    virtual ~MdtDriftCircleOnTrackCreator() = default;
    
    virtual StatusCode initialize() override final;

    virtual MdtRotPtr createRIO_OnTrack(const MdtPrepData& prd, 
                                        const Amg::Vector3D& globalPos,
                                        const Amg::Vector3D* gdir = nullptr, 
                                        const double t0Shift = 0.,
                                        const MuonDriftCircleErrorStrategy* strategy = nullptr, 
                                        const double beta = 1,
                                        const double tTrack = 1) const override final;

    virtual void updateSign(MdtDriftCircleOnTrack& rot,
                            const Trk::DriftCircleSide si) const override final;

    virtual MdtRotPtr updateError(const MdtDriftCircleOnTrack& DCT, 
                                  const Trk::TrackParameters* pars = nullptr,
                                  const MuonDriftCircleErrorStrategy* strategy = nullptr) const override;
 
    
    virtual  Trk::RIO_OnTrack* correct(const Trk::PrepRawData& prd, 
                                       const Trk::TrackParameters& tp, const EventContext& /*ctx*/) const override;

    virtual MdtRotPtr correct(const MdtPrepData& prd, 
                             const Trk::TrackParameters& tp,
                             const MuonDriftCircleErrorStrategy* strategy, 
                             const double beta,
                             const double tTrack) const override final;

    virtual const MuonDriftCircleErrorStrategy& errorStrategy() const override {
        return m_errorStrategy;
    };
    
    struct CalibrationOutput {
        CalibrationOutput(Trk::LocalParameters lp,  
                          Amg::MatrixX le,          
                          double t,                 
                          bool ok)
            : locPars(lp), locErr(le), driftTime(t), calibOk(ok) {}
        Trk::LocalParameters locPars;
        Amg::MatrixX locErr;
        double driftTime;
        bool calibOk;
    };
 
 
 
   private:
   
    double timeOfFlight(const Amg::Vector3D& pos, 
                        const double beta,
                        const double tTrack, 
                        const double tShift) const;

    CalibrationOutput getLocalMeasurement(const EventContext& ctx,
                                          const MdtPrepData& DC, 
                                          const MdtCalibInput& calibInput,
                                          const MuonDriftCircleErrorStrategy& strategy) const;

    double getTriggerTime() const { return 0.; }
 
    // parametrised error function
    static double parametrisedSigma(double r);
 
    double mooreErrorStrategy(const MuonDriftCircleErrorStrategy& myStrategy,
                              double sigmaR, 
                              const Identifier& id) const;
    
    double mooreErrorStrategyMC(const MuonDriftCircleErrorStrategy& myStrategy,
                                double sigmaR, 
                                const Identifier& id) const;
    
    double mooreErrorStrategyLoose(const MuonDriftCircleErrorStrategy& myStrategy, 
                                   double sigmaR,
                                   const Identifier& id) const;
    
    double mooreErrorStrategyTight(const MuonDriftCircleErrorStrategy& myStrategy, 
                                   double sigmaR,
                                   const Identifier& id) const;
 
    double muonErrorStrategy(const MuonDriftCircleErrorStrategy& myStrategy,
                             double sigmaR, 
                             const Identifier& id) const;
 
    ServiceHandle<Muon::IMuonIdHelperSvc> m_idHelperSvc{this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"};
 
    ToolHandle<IMdtCalibrationTool> m_mdtCalibrationTool{this, "CalibrationTool", ""};
 
    // Configuration variables
    Gaudi::Property<bool> m_doMdt{this, "doMDT", true};  
    Gaudi::Property<int> m_timeCorrectionType{this, "TimingMode", 0};
    // Constants for use during calculations
    Gaudi::Property<double> m_fixedError{this, "FixedError", 1.};
 
    Gaudi::Property<double> m_globalToLocalTolerance{this, "GlobalToLocalTolerance", 1000.,
                                                     "Tolerance used for the Surface::globalToLocal"};
 
    // Member variables used to fill the default error strategy
    MuonDriftCircleErrorStrategy m_errorStrategy{MuonDriftCircleErrorStrategyInput{}};  
   
    Gaudi::Property<std::string> m_defaultStrategy{this, "DefaultErrorStrategy", "Muon",
                        "Default error strategy to be used in calculating errors"};

    Gaudi::Property<bool> m_createTubeHits{this, "CreateTubeHit", false};
    Gaudi::Property<bool> m_scaleMdtCov{this, "DoErrorScaling", true};
    Gaudi::Property<bool> m_doFixedError{this, "DoFixedError", true};  
    Gaudi::Property<bool> m_useErrorParametrisation{this, "UseParametrisedError", false};
    Gaudi::Property<bool> m_errorAtPredictedPosition{this, "UseErrorAtPredictedPosition", false};
    Gaudi::Property<bool> m_stationError{this, "DoStationError", false};
    Gaudi::Property<bool> m_t0Refit{this, "T0RefitError", false};
    Gaudi::Property<bool> m_doSegments{this, "DoSegmentErrors", true};
    Gaudi::Property<bool> m_doIndividualChamberReweights{this, "DeweightIndividualChambers", true};
    Gaudi::Property<bool> m_isMC{this, "IsMC", false};
    Gaudi::Property<bool> m_applyToF{this, "ApplyToF", true};
    Gaudi::Property<bool> m_looseErrors{this, "UseLooseErrors", false,
                                        "Use error strategy for MC"};
    Gaudi::Property<bool> m_wasConfigured{this, "WasConfigured", false,
                    "This tool is too complicated to rely on defaults. Will fail if not configured."};
 
    static constexpr double s_inverseSpeedOfLight{1. / Gaudi::Units::c_light};
 
    int m_BME_idx{-1};
    
};
 
}  // namespace Muon
 
#endif