Muon::MdtDriftCircleOnTrackCreator Class Reference

Interface for the reconstruction to MDT calibration and alignment corrections. More...

#include <MdtDriftCircleOnTrackCreator.h>

Inheritance diagram for Muon::MdtDriftCircleOnTrackCreator:

Collaboration diagram for Muon::MdtDriftCircleOnTrackCreator:

Classes
struct	CalibrationOutput
	struct to hold output of calibration More...

Public Types
enum	TimingMode {   ATLTIME =0, NO_CORRECTIONS = 1, COSMICS_TRIGGERTIME = 2, COSMICS_TOF =3,   NumberOfTimingModes }
using	MdtRotPtr = MdtDriftCircleOnTrack *

Public Member Functions
	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
	Calibrate a MdtPrepData object. More...
virtual void	updateSign (MdtDriftCircleOnTrack &rot, const Trk::DriftCircleSide si) const override final
	Update of the sign of the drift radius. More...
virtual MdtRotPtr	updateError (const MdtDriftCircleOnTrack &DCT, const Trk::TrackParameters *pars=nullptr, const MuonDriftCircleErrorStrategy *strategy=nullptr) const override
	Update error of a ROT without changing the drift radius. More...
virtual Trk::RIO_OnTrack *	correct (const Trk::PrepRawData &prd, const Trk::TrackParameters &tp, const EventContext &) const override
	Base class method for correct. More...
virtual MdtRotPtr	correct (const MdtPrepData &prd, const Trk::TrackParameters &tp, const MuonDriftCircleErrorStrategy *strategy, const double beta, const double tTrack) const override final
	Returns calibrated MdtDriftCircleOnTrack. More...
virtual const MuonDriftCircleErrorStrategy &	errorStrategy () const override
	Returns the default error strategy object. More...
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
const ServiceHandle< StoreGateSvc > &	evtStore () const
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc. More...
virtual StatusCode	sysInitialize () override
	Perform system initialization for an algorithm. More...
virtual StatusCode	sysStart () override
	Handle START transition. More...
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles. More...
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles. More...
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T > &t)
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
	Declare a new Gaudi property. More...
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
	Declare a new Gaudi property. More...
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
	Declare a new Gaudi property. More...
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc="none")
	Declare a new Gaudi property. More...
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
MsgStream &	msg (const MSG::Level lvl) const
bool	msgLvl (const MSG::Level lvl) const
	DeclareInterfaceID (Muon::IMdtDriftCircleOnTrackCreator, 1, 0)

Static Public Member Functions
static const InterfaceID &	interfaceID ()
	The AlgTool InterfaceID. More...

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution More...
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void >	renounce (T &h)
void	extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
	Add StoreName to extra input/output deps as needed. More...

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
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
	preform the mdt calibration More...
double	getTriggerTime () const
	currently returns 0. More...
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
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey> More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
	specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
	specialization for handling Gaudi::Property<SG::VarHandleBase> More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
	specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...

Static Private Member Functions
static double	parametrisedSigma (double r)

Private Attributes
ServiceHandle< Muon::IMuonIdHelperSvc >	m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}
ToolHandle< IMdtCalibrationTool >	m_mdtCalibrationTool {this, "CalibrationTool", ""}
Gaudi::Property< bool >	m_doMdt {this, "doMDT", true}
	Process MDT ROTs. More...
Gaudi::Property< int >	m_timeCorrectionType {this, "TimingMode", 0}
Gaudi::Property< double >	m_fixedError {this, "FixedError", 1.}
	< Error used when m_doFixed error =true or m_scaleErrorManually = true More...
Gaudi::Property< double >	m_globalToLocalTolerance
MuonDriftCircleErrorStrategy	m_errorStrategy {MuonDriftCircleErrorStrategyInput{}}
	< Error strategy for created ROTs More...
Gaudi::Property< std::string >	m_defaultStrategy
	if set to true, the ROT creator create 'tube' hits with a local position of 0 and an error of tube radius/sqrt(12) More...
Gaudi::Property< bool >	m_createTubeHits {this, "CreateTubeHit", false}
	Scale ROTs depending on local alignment (i.e. More...
Gaudi::Property< bool >	m_scaleMdtCov {this, "DoErrorScaling", true}
	Fixed error (not tube radius) More...
Gaudi::Property< bool >	m_doFixedError {this, "DoFixedError", true}
	Use parameterised errors. More...
Gaudi::Property< bool >	m_useErrorParametrisation {this, "UseParametrisedError", false}
	Use the predicted track position to correct the Error. More...
Gaudi::Property< bool >	m_errorAtPredictedPosition {this, "UseErrorAtPredictedPosition", false}
	Add a term to the error to account for very poorly aligned stations. More...
Gaudi::Property< bool >	m_stationError {this, "DoStationError", false}
	Add a special error to account for the T0 refit. More...
Gaudi::Property< bool >	m_t0Refit {this, "T0RefitError", false}
	Use error strategy for segments by default. More...
Gaudi::Property< bool >	m_doSegments {this, "DoSegmentErrors", true}
	Deweight individual chambers. More...
Gaudi::Property< bool >	m_doIndividualChamberReweights {this, "DeweightIndividualChambers", true}
	toggle between MC and data alignment errors (to be removed in rel. More...
Gaudi::Property< bool >	m_isMC {this, "IsMC", false}
	toggle whether the time of flight is included in the t0 shifts More...
Gaudi::Property< bool >	m_applyToF {this, "ApplyToF", true}
	toggle between loose errors (initial before alignment) and tight after alignment More...
Gaudi::Property< bool >	m_looseErrors
Gaudi::Property< bool >	m_wasConfigured
int	m_BME_idx {-1}
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default) More...
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default) More...
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Static Private Attributes
static constexpr double	s_inverseSpeedOfLight {1. / Gaudi::Units::c_light}

Detailed Description

Interface for the reconstruction to MDT calibration and alignment corrections.

It should be used by reconstruction and pattern recognition to create Muon::MdtDriftCircleOnTrack (s).

It offers several interfaces:

• Create new Muon::MdtDriftCircleOnTrack from a Trk::MdtPrepData and a predicted Trk::TrackParameter.

   const MdtRotPtr correct ( const Trk::PrepRawData& prd,
  const Trk::TrackParameters& tp) const 

• Create new Muon::MdtDriftCircleOnTrack from a Trk::MdtPrepData and a prediction of the global position of the point of closest approach of the track to the wire. Knowing the second coordinate is sufficient as the side on which the track passed the wire is not determined.

   createRIO_OnTrack(const MdtPrepData& prd, const Trk::GlobalPosition&
  globalPos) const 

• Update the side (sign) of the Muon::MdtDriftCircleOnTrack.

   updateSign(const MdtDriftCircleOnTrack& rot, const
  Trk::DriftCircleSide si) const 

The tool is capable of handling serveral different timing cases (click links to see definitions):

• normal time of flight corrections assuming IP + light speed to be used for simulated data and collision data
• cosmics taken with scintilator trigger or cosmic simulation without TOF
• cosmics taken with scintilator trigger which is read out so the offset with respect to the clock is known. This mode is not completely functional yet as the way to access the trigger time is not known at the moment
• normal cosmic data with rpc trigger or simulation including TOF. It uses the MuonCosmicTofTool to calculate the correct timing with respect to the MuonTriggerPoint
• testbeam running. Currently not implemented, propose not to change anything for the moment for testbeam The modes can be selected setting the TimingMode in the job options.

JobOptions Flags:

• doMDT: switch on/off ROT creation (default = true)
• TimingMode: select timing mode (default = ATLTIME)
• CreateTubeHit: Flag to turn on the creation of tube hits (default = false)

Definition at line 69 of file MdtDriftCircleOnTrackCreator.h.

Member Typedef Documentation

MdtRotPtr

using Muon::IMdtDriftCircleOnTrackCreator::MdtRotPtr = MdtDriftCircleOnTrack*

inherited

Definition at line 26 of file IMdtDriftCircleOnTrackCreator.h.

StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< AlgTool > >::StoreGateSvc_t

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Member Enumeration Documentation

TimingMode

enum Muon::MdtDriftCircleOnTrackCreator::TimingMode

Enumerator
ATLTIME	normal time of flight corrections assuming IP + light speed to be used for simulated data and collision data special case for cosmics taken with scintilator trigger or cosmic simulation without TOF
NO_CORRECTIONS	special case for cosmics taken with scintilator trigger which is read out so the offset with respect to the clock is known. This mode is not completely functional yet as the way to access the trigger time is not known at the moment
COSMICS_TRIGGERTIME	case for normal cosmic data with rpc trigger or simulation including TOF. It uses the MuonCosmicTofTool to calculate the correct timing with respect to the MuonTriggerPoint
COSMICS_TOF
NumberOfTimingModes

Definition at line 71 of file MdtDriftCircleOnTrackCreator.h.

                    {
        ATLTIME =0, 
        NO_CORRECTIONS = 1,
        COSMICS_TRIGGERTIME = 2,  
        COSMICS_TOF =3,  
               
        NumberOfTimingModes
    };

Constructor & Destructor Documentation

MdtDriftCircleOnTrackCreator()

Muon::MdtDriftCircleOnTrackCreator::MdtDriftCircleOnTrackCreator	(	const std::string &	ty,
		const std::string &	na,
		const IInterface *	pa
	)

Definition at line 27 of file MdtDriftCircleOnTrackCreator.cxx.

    : AthAlgTool(ty, na, pa) {
    // algtool interface - necessary!
    declareInterface<IMdtDriftCircleOnTrackCreator>(this);
    declareInterface<IRIO_OnTrackCreator>(this);
}

~MdtDriftCircleOnTrackCreator()

virtual Muon::MdtDriftCircleOnTrackCreator::~MdtDriftCircleOnTrackCreator ( )

virtualdefault

Member Function Documentation

correct() [1/2]

MdtRotPtr Muon::MdtDriftCircleOnTrackCreator::correct ( const MdtPrepData &  prd, const Trk::TrackParameters &  tp, const MuonDriftCircleErrorStrategy *  strategy, const double  beta, const double  tTrack  ) const

finaloverridevirtual

Returns calibrated MdtDriftCircleOnTrack.

Implementation of IRIO_OnTrackCreator method

Parameters

prd	Reference to a Trk::PrepRawData object (which should always be a Muon::MdtPrepData in this case)
tp	Reference to the extrapolated/predicted TrackParameters at this MdtPrepData

Returns

calibrated MdtDriftCircleOnTrack. Memory management is passed to user.

Implements Muon::IMdtDriftCircleOnTrackCreator.

Definition at line 375 of file MdtDriftCircleOnTrackCreator.cxx.

                                                                           {
 
    const Amg::Vector3D& momentum = tp.momentum();
    return createRIO_OnTrack(prd, tp.position(), &momentum, 0, strategy, beta, tTrack);
}

correct() [2/2]

Trk::RIO_OnTrack * Muon::MdtDriftCircleOnTrackCreator::correct ( const Trk::PrepRawData &  prd, const Trk::TrackParameters &  tp, const EventContext &    ) const

overridevirtual

Base class method for correct.

Implements Trk::IRIO_OnTrackCreator.

Definition at line 385 of file MdtDriftCircleOnTrackCreator.cxx.

                                                                                     {
    if (!prd.type(Trk::PrepRawDataType::MdtPrepData)){
        ATH_MSG_WARNING(__FILE__<<":"<<__LINE__<<" Incorrect hit type: "
                      <<" Trk::PrepRawData not a MdtPrepData!! No rot created ");
        return nullptr;
    }
    Amg::Vector3D momentum = tp.momentum();
 
    return createRIO_OnTrack(static_cast<const MdtPrepData&>(prd), tp.position(), &momentum);
}

createRIO_OnTrack()

MdtRotPtr Muon::MdtDriftCircleOnTrackCreator::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

finaloverridevirtual

Calibrate a MdtPrepData object.

The result is stored in a new MdtDriftCircleOnTrack object. Included calibrations:

• Conversion t->r using MdtCalibrationSvc
• Wire sag + chamber deformations (if available)
• Special treatment for cosmics if switched on

  Parameters

  prd	MdtPrepData object
  globalPos	GlobalPosition (including second coordinate along the tube)
  gdir	GlobalDirection of track
  strategy	optional drift circle error strategy to override the default

  Returns

  Fully calibrated MdtDriftCircleOnTrack (the user must delete this object when it is no longer needed)

Implements Muon::IMdtDriftCircleOnTrackCreator.

Definition at line 140 of file MdtDriftCircleOnTrackCreator.cxx.

                                                                                     {
 
    const EventContext& ctx{Gaudi::Hive::currentContext()};
 
    const MuonDriftCircleErrorStrategy& myStrategy{!strategy ? m_errorStrategy : *strategy};
 
    const Identifier iD = mdtPrd.identify();
 
    MdtCalibInput calibInput{mdtPrd};
    calibInput.setClosestApproach(GP);
    if (GD) calibInput.setTrackDirection((*GD).unit());
 
    switch (m_timeCorrectionType) {
        case ATLTIME:
            // normal time of flight corrections assuming IP + light speed
            calibInput.setTimeOfFlight(calibInput.closestApproach().mag() * s_inverseSpeedOfLight);
            ATH_MSG_VERBOSE(" running in ATLTIME mode, tof: " << calibInput.timeOfFlight());
            break;
        case NO_CORRECTIONS:
            // special case for cosmics taken with scintilator trigger or
            // cosmic simulation without TOF
            calibInput.setTimeOfFlight(0);
            ATH_MSG_VERBOSE("running in NO_CORRECTIONS mode, tof: " << calibInput.timeOfFlight());
            break;
        case COSMICS_TRIGGERTIME:
            // special case for cosmics taken with scintilator trigger which
            // is read out so the offset with respect to the clock is known
            // getTriggerTime() NOT IMPLEMENETED YET!!!!!!
            calibInput.setTriggerTime(getTriggerTime());
            ATH_MSG_VERBOSE(" running in COSMICS_TRIGGERTIME mode, triggerOffset: "
                            << calibInput.triggerTime());
            break;
        case COSMICS_TOF:
            calibInput.setTimeOfFlight(timeOfFlight(calibInput.closestApproach(), beta, tTrack, t0Shift));
            ATH_MSG_VERBOSE(" running in COSMICS_TOF mode, tof: "
                            << calibInput.timeOfFlight() << " tTrack: " << tTrack
                            << " t0Shift: " << t0Shift
                            << " applyToF: " << m_applyToF);
            break;
        default:
            // default, no tof. Indicates wrong configuration
            ATH_MSG_WARNING("No valid mode selected, cannot apply tof correction");
            calibInput.setTimeOfFlight(0);
            break;
    }
 
    Amg::Vector2D posOnWire{Amg::Vector2D::Zero()};
    // if wire sag is taken into account, cast the surface to
    // StraightLineSurface so it can be added to the ROT
    const Trk::Surface& surf{calibInput.legacySurface()};
    std::optional<Amg::Vector2D> posOnIdealWire = surf.globalToLocal(GP, m_globalToLocalTolerance);
    if (!posOnIdealWire) {
            ATH_MSG_WARNING(__FILE__<<":"<<__LINE__<<" globalToLocal() failed for ideal surface");
            return nullptr;
    }
    posOnWire = std::move(*posOnIdealWire);
 
    double positionAlongWire = posOnWire[Trk::locZ];
    // set driftcirclestatus, NODRIFTTIME if creating tube hits else UNDECIDED
    Trk::DriftCircleStatus dcstatus = m_doMdt ? Trk::UNDECIDED : Trk::NODRIFTTIME;
 
    CalibrationOutput calibOutput = getLocalMeasurement(ctx, mdtPrd, calibInput, myStrategy);
    // This basically determines the error etc and is where the bulk of the work
    // is done.
 
    // hack to determine whether we are before or after the spectrum, until we
    // sort this out properly
    if (!calibOutput.calibOk && calibOutput.driftTime > 500.) {
        ATH_MSG_WARNING("Unable to perform calibration ");
        return nullptr;
    }
 
    std::unique_ptr<MdtDriftCircleOnTrack> rot{};
 
    // we have to calculate sign, check whether direction is given
    if (m_doMdt && GD) {
        // calculate sign using surface
        const Trk::Surface& surf{calibInput.legacySurface()};
        std::optional<Amg::Vector2D> pos = surf.globalToLocal(GP, calibInput.trackDirection());
 
        // check this might still fail....
        if (!pos) {
            ATH_MSG_WARNING("Unexpected globalToLocal failure, cannot create MDT ROT ");
            return nullptr;
        }
 
        // calculate sign
        double sign = (*pos)[Trk::driftRadius] < 0 ? -1.0 : 1.0;
        calibOutput.locPars[Trk::driftRadius] *= sign;
        rot = std::make_unique<MdtDriftCircleOnTrack>(&mdtPrd,
                                                      std::move(calibOutput.locPars),
                                                      std::move(calibOutput.locErr),
                                                      calibOutput.driftTime,
                                                      Trk::DECIDED,
                                                      calibInput.trackDirection(),
                                                      positionAlongWire,
                                                      myStrategy);
 
    } else {
        // If the track direction is missing, the B-field correction was not
        // applied
        if (GD) {
            // do not have access to direction, so have to use partial
            // constructor:
            rot = std::make_unique<MdtDriftCircleOnTrack>(&mdtPrd,
                                                          std::move(calibOutput.locPars),
                                                          std::move(calibOutput.locErr),
                                                          calibOutput.driftTime,
                                                          dcstatus,
                                                          positionAlongWire,
                                                          myStrategy);
        } else {
            MuonDriftCircleErrorStrategy tmpStrategy(myStrategy.getBits());
            tmpStrategy.setParameter(MuonDriftCircleErrorStrategy::MagFieldCorrection, false);
            rot = std::make_unique<MdtDriftCircleOnTrack>(&mdtPrd,
                                                          std::move(calibOutput.locPars),
                                                          std::move(calibOutput.locErr),
                                                          calibOutput.driftTime,
                                                          dcstatus,
                                                          positionAlongWire,
                                                          tmpStrategy);
        }
    }
    ATH_MSG_DEBUG("MDT ROT: radius = "
                  << rot->localParameters().get(Trk::driftRadius) << " error = "
                  << Amg::error(rot->localCovariance(), Trk::locR)
                  <<" ,channel "
                  << m_idHelperSvc->toString(iD));
 
    return rot.release();
}

declareGaudiProperty() [1/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl, const SG::VarHandleKeyArrayType &    )

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKeyArray>

Definition at line 170 of file AthCommonDataStore.h.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
 
  }

declareGaudiProperty() [2/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl, const SG::VarHandleKeyType &    )

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
 
  }

declareGaudiProperty() [3/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl, const SG::VarHandleType &    )

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleBase>

Definition at line 184 of file AthCommonDataStore.h.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
  }

declareGaudiProperty() [4/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  t, const SG::NotHandleType &    )

inlineprivateinherited

specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray>

Definition at line 199 of file AthCommonDataStore.h.

  {
    return PBASE::declareProperty(t);
  }

DeclareInterfaceID()

Muon::IMdtDriftCircleOnTrackCreator::DeclareInterfaceID ( Muon::IMdtDriftCircleOnTrackCreator  , 1  , 0    )

inherited

declareProperty() [1/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name, SG::VarHandleBase &  hndl, const std::string &  doc, const SG::VarHandleType &    )

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleBase. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 245 of file AthCommonDataStore.h.

  {
    this->declare(hndl.vhKey());
    hndl.vhKey().setOwner(this);
 
    return PBASE::declareProperty(name,hndl,doc);
  }

declareProperty() [2/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name, SG::VarHandleKey &  hndl, const std::string &  doc, const SG::VarHandleKeyType &    )

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleKey. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 221 of file AthCommonDataStore.h.

  {
    this->declare(hndl);
    hndl.setOwner(this);
 
    return PBASE::declareProperty(name,hndl,doc);
  }

declareProperty() [3/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name, SG::VarHandleKeyArray &  hndArr, const std::string &  doc, const SG::VarHandleKeyArrayType &    )

inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

  {
 
    // std::ostringstream ost;
    // ost << Algorithm::name() << " VHKA declareProp: " << name 
    //     << " size: " << hndArr.keys().size() 
    //     << " mode: " << hndArr.mode() 
    //     << "  vhka size: " << m_vhka.size()
    //     << "\n";
    // debug() << ost.str() << endmsg;
 
    hndArr.setOwner(this);
    m_vhka.push_back(&hndArr);
 
    Gaudi::Details::PropertyBase* p =  PBASE::declareProperty(name, hndArr, doc);
    if (p != 0) {
      p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
    } else {
      ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray " 
                    << name);
    }
 
    return p;
 
  }

declareProperty() [4/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name, T &  property, const std::string &  doc, const SG::NotHandleType &    )

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This is the generic version, for types that do not derive from SG::VarHandleKey. It just forwards to the base class version of declareProperty.

Definition at line 333 of file AthCommonDataStore.h.

  {
    return PBASE::declareProperty(name, property, doc);
  }

declareProperty() [5/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name, T &  property, const std::string &  doc = "none"  )

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This dispatches to either the generic declareProperty or the one for VarHandle/Key/KeyArray.

Definition at line 352 of file AthCommonDataStore.h.

  {
    typedef typename SG::HandleClassifier<T>::type htype;
    return declareProperty (name, property, doc, htype());
  }

declareProperty() [6/6]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( Gaudi::Property< T > &  t )

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

                                                                 {
    typedef typename SG::HandleClassifier<T>::type htype;
    return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
  }

detStore()

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< AlgTool > >::detStore ( ) const

inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

{ return m_detStore; }

errorStrategy()

virtual const MuonDriftCircleErrorStrategy& Muon::MdtDriftCircleOnTrackCreator::errorStrategy ( ) const

inlineoverridevirtual

Returns the default error strategy object.

Implements Muon::IMdtDriftCircleOnTrackCreator.

Definition at line 163 of file MdtDriftCircleOnTrackCreator.h.

                                                                               {
        return m_errorStrategy;
    };

evtStore() [1/2]

ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore ( )

inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

{ return m_evtStore; }

evtStore() [2/2]

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore ( ) const

inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 90 of file AthCommonDataStore.h.

{ return m_evtStore; }

extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase &  ExtraDeps )

protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

getLocalMeasurement()

CalibrationOutput Muon::MdtDriftCircleOnTrackCreator::getLocalMeasurement ( const EventContext &  ctx, const MdtPrepData &  DC, const MdtCalibInput &  calibInput, const MuonDriftCircleErrorStrategy &  strategy  ) const

private

preform the mdt calibration

copy new values

Use same value

Definition at line 296 of file MdtDriftCircleOnTrackCreator.cxx.

                                                                                                                          {
 
 
    ATH_MSG_VERBOSE("getLocalMeasurement "<<calibInput<<" with m_doMdt=" << m_doMdt << " and " << myStrategy);
    const Amg::Vector3D& gpos{calibInput.closestApproach()};
    const Amg::Vector3D& gdir{calibInput.trackDirection()};
 
    double sigmaR{1.}, driftTime{0.}, radius{0.}, errRadius{0.};
    MdtCalibOutput calibOutput{};
    if (m_doMdt) {
        // call the calibration service providing the time when the particle
        // passed the tube
        calibOutput = m_mdtCalibrationTool->calibrate(ctx, calibInput);
        ATH_MSG_VERBOSE("getLocalMeasurement() - Calibrated output "<<calibOutput);
        driftTime = calibOutput.driftTime();
        radius = calibOutput.driftRadius(); 
        errRadius = radius;                 
 
        if (myStrategy.creationParameter(MuonDriftCircleErrorStrategy::ErrorAtPredictedPosition)) {
            const Trk::Surface& surf{calibInput.legacySurface()};
            std::optional<Amg::Vector2D> myLocalPosition = surf.globalToLocal(gpos, gdir);
            if (myLocalPosition) {
                errRadius = (*myLocalPosition)[Trk::driftRadius];
            } else {
                ATH_MSG_WARNING(__FILE__<<":"<<__LINE__<<" ErrorAtPredictedPosition failed because local position "<<
                                    "transformation didn't succeed. Using measured radius instead.");
                errRadius = radius;
            }
        }
    } else {
        // use PRD values
        radius = DC.localPosition().x();
        errRadius = radius;
        // check consistency of error matrix
        if (DC.localCovariance().cols() > 1) {
            ATH_MSG_WARNING("Error matrix of DC doesn't have dimension 1 "<< DC.localCovariance());
            ATH_MSG_WARNING("Reducing size to 1 dim");
        }
    }
 
    // Handle the errors here.  Begin by getting the first part of the
    // resolution term
    if (!m_doMdt) {
        sigmaR = Amg::error(DC.localCovariance(), Trk::driftRadius);
    } else if (myStrategy.creationParameter(MuonDriftCircleErrorStrategy::ParameterisedErrors)) {
        sigmaR = parametrisedSigma(errRadius);
    } else {
        sigmaR = calibOutput.driftRadiusUncert();
    }
    ATH_MSG_DEBUG("Tube : " << m_idHelperSvc->toString(calibInput.identify())
                            << " SigmaR = " << sigmaR);
    double sigmaR2 = 0.0;
    // Handle the errors scaling / addition of fixed terms
    if (myStrategy.strategy() == MuonDriftCircleErrorStrategy::Moore) {
        sigmaR2 = mooreErrorStrategy(myStrategy, sigmaR * sigmaR, calibInput.identify());
        ATH_MSG_DEBUG("After scaling etc:\t Moore sigmaR2 = " << sigmaR2);
    } else if (myStrategy.strategy() == MuonDriftCircleErrorStrategy::Muon) {
        sigmaR2 = muonErrorStrategy(myStrategy, sigmaR * sigmaR, calibInput.identify());
        ATH_MSG_DEBUG("After scaling etc:\t Muon ErrorStrategy sigmaR2 = " << sigmaR2);
    }
    // update or copy drift radius and error
 
    // new radius
    Trk::DefinedParameter radiusPar(radius, Trk::driftRadius);
 
    // create new error matrix
    Amg::MatrixX newLocalCov(1, 1);
    newLocalCov(0, 0) = sigmaR2;
 
    // return new values
    bool ok = true;
    return {Trk::LocalParameters(radiusPar), newLocalCov, driftTime,
            ok};
}

getTriggerTime()

double Muon::MdtDriftCircleOnTrackCreator::getTriggerTime ( ) const

inlineprivate

currently returns 0.

Definition at line 196 of file MdtDriftCircleOnTrackCreator.h.

{ return 0.; }

initialize()

StatusCode Muon::MdtDriftCircleOnTrackCreator::initialize ( )

finaloverridevirtual

Definition at line 36 of file MdtDriftCircleOnTrackCreator.cxx.

                                                    {
    ATH_CHECK(m_mdtCalibrationTool.retrieve());
    ATH_CHECK(m_idHelperSvc.retrieve());
    m_BME_idx = m_idHelperSvc->mdtIdHelper().stationNameIndex("BME");
 
 
    m_errorStrategy.setParameter(MuonDriftCircleErrorStrategy::BroadError, m_createTubeHits);
    m_errorStrategy.setParameter(MuonDriftCircleErrorStrategy::ScaledError, m_scaleMdtCov);
    m_errorStrategy.setParameter(MuonDriftCircleErrorStrategy::FixedError, m_doFixedError);
    m_errorStrategy.setParameter(MuonDriftCircleErrorStrategy::ParameterisedErrors, m_useErrorParametrisation);
    m_errorStrategy.setParameter(MuonDriftCircleErrorStrategy::StationError, m_stationError);
    m_errorStrategy.setParameter(MuonDriftCircleErrorStrategy::ErrorAtPredictedPosition, m_errorAtPredictedPosition);
    m_errorStrategy.setParameter(MuonDriftCircleErrorStrategy::T0Refit, m_t0Refit);
    m_errorStrategy.setParameter(MuonDriftCircleErrorStrategy::Segment, m_doSegments);
    using ToolSettings = IMdtCalibrationTool::ToolSettings;
    using Property = ToolSettings::Property;
    ToolSettings calibSettings = m_mdtCalibrationTool->getSettings();
    m_errorStrategy.setParameter(MuonDriftCircleErrorStrategy::TofCorrection,
                                 calibSettings.isActive(Property::TofCorrection));
    m_errorStrategy.setParameter(MuonDriftCircleErrorStrategy::PropCorrection,
                                 calibSettings.isActive(Property::PropCorrection));
    m_errorStrategy.setParameter(MuonDriftCircleErrorStrategy::TempCorrection,
                                 calibSettings.isActive(Property::TempCorrection));
    m_errorStrategy.setParameter(MuonDriftCircleErrorStrategy::MagFieldCorrection,
                                 calibSettings.isActive(Property::MagFieldCorrection));
    m_errorStrategy.setParameter(MuonDriftCircleErrorStrategy::SlewCorrection,
                                 calibSettings.isActive(Property::SlewCorrection));
    m_errorStrategy.setParameter(MuonDriftCircleErrorStrategy::BackgroundCorrection,
                                 calibSettings.isActive(Property::BackgroundCorrection));
    m_errorStrategy.setCalibWindow(calibSettings.window);
 
    if ("Moore" == m_defaultStrategy) {
        m_errorStrategy.setStrategy(MuonDriftCircleErrorStrategy::Moore);
    } else if ("Muon" == m_defaultStrategy) {
        m_errorStrategy.setStrategy(MuonDriftCircleErrorStrategy::Muon);
    } else {
        // By default use one of the real strategies - don't default to unknown!
        m_errorStrategy.setStrategy(MuonDriftCircleErrorStrategy::Muon);
        ATH_MSG_FATAL("Unknown error strategy "<<m_errorStrategy);
        return StatusCode::FAILURE;
    }
    if (msgLevel(MSG::INFO)) {
        std::stringstream ss;
        ss << "Constructed default MuonDriftCircleErrorStrategy:";
        if (m_errorStrategy.creationParameter(MuonDriftCircleErrorStrategy::BroadError))
            ss << " Broad";
        if (m_errorStrategy.creationParameter(MuonDriftCircleErrorStrategy::ScaledError))
            ss << " Scaled";
        if (m_errorStrategy.creationParameter(MuonDriftCircleErrorStrategy::FixedError))
            ss << " Fixed";
        if (m_errorStrategy.creationParameter(MuonDriftCircleErrorStrategy::ParameterisedErrors))
            ss << " Parm";
        if (m_errorStrategy.creationParameter(MuonDriftCircleErrorStrategy::StationError))
            ss << " Station";
        if (m_errorStrategy.creationParameter(MuonDriftCircleErrorStrategy::ErrorAtPredictedPosition))
            ss << " ErrAtPos";
        if (m_errorStrategy.creationParameter(MuonDriftCircleErrorStrategy::T0Refit))
            ss << " T0";
        if (m_errorStrategy.creationParameter(MuonDriftCircleErrorStrategy::TofCorrection))
            ss << " TOF";
        if (m_errorStrategy.creationParameter(MuonDriftCircleErrorStrategy::PropCorrection))
            ss << " Prop";
        if (m_errorStrategy.creationParameter(MuonDriftCircleErrorStrategy::TempCorrection))
            ss << " Temp";
        if (m_errorStrategy.creationParameter(MuonDriftCircleErrorStrategy::MagFieldCorrection))
            ss << " Mag";
        if (m_errorStrategy.creationParameter(MuonDriftCircleErrorStrategy::SlewCorrection))
            ss << " Slew";
        if (m_errorStrategy.creationParameter(MuonDriftCircleErrorStrategy::BackgroundCorrection))
            ss << " Back";
        if (m_errorStrategy.creationParameter(MuonDriftCircleErrorStrategy::Segment))
            ss << " Seg";
        ss << ". ";
        if (!m_isMC && m_looseErrors)
            ss << "Using Data Loose error tuning";
        if (!m_isMC && !m_looseErrors)
            ss << "Using Data Tight error tuning";
 
        msg(MSG::INFO) << ss.str() << endmsg;
    }
    if (m_isMC)
        ATH_MSG_INFO("Using MC error tuning");
    ATH_MSG_VERBOSE("A correction is made if set to true: do_MDT = " << m_doMdt);
 
    if (m_timeCorrectionType == COSMICS_TOF) {
        if (!m_errorStrategy.creationParameter(MuonDriftCircleErrorStrategy::TofCorrection)) {
            ATH_MSG_ERROR("Detected bad default configuration, using Cosmic TOF without "
                        <<"time of flight corrections does not work");
            return StatusCode::FAILURE;
        }
    }
    ATH_MSG_DEBUG("Timing mode set to  " << m_timeCorrectionType);
    if (m_timeCorrectionType >= NumberOfTimingModes) {
        ATH_MSG_ERROR("Time Correction Type too large! Aborting.");
        return StatusCode::FAILURE;
    }
 
    if (!m_wasConfigured) {
        ATH_MSG_ERROR("This tool is too complicated to rely on defaults. Potential configuration issue.");
        return StatusCode::FAILURE;
    }
    return StatusCode::SUCCESS;
}

inputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< AlgTool > >::inputHandles ( ) const

overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

interfaceID()

static const InterfaceID& Trk::IRIO_OnTrackCreator::interfaceID ( )

inlinestaticinherited

The AlgTool InterfaceID.

Definition at line 42 of file IRIO_OnTrackCreator.h.

mooreErrorStrategy()

double Muon::MdtDriftCircleOnTrackCreator::mooreErrorStrategy ( const MuonDriftCircleErrorStrategy &  myStrategy, double  sigmaR, const Identifier &  id  ) const

private

Definition at line 482 of file MdtDriftCircleOnTrackCreator.cxx.

                                                                                    {
    if (m_isMC)
        return mooreErrorStrategyMC(myStrategy, sigmaR2, id);
 
    if (m_looseErrors)
        return mooreErrorStrategyLoose(myStrategy, sigmaR2, id);
    else
        return mooreErrorStrategyTight(myStrategy, sigmaR2, id);
 
}

mooreErrorStrategyLoose()

double Muon::MdtDriftCircleOnTrackCreator::mooreErrorStrategyLoose ( const MuonDriftCircleErrorStrategy &  myStrategy, double  sigmaR, const Identifier &  id  ) const

private

Need to check whether this Identifier is still existent

Definition at line 578 of file MdtDriftCircleOnTrackCreator.cxx.

                                                                                         {
    ATH_MSG_DEBUG("mooreErrorStrategy sigmaR2=" << sigmaR2<<" "<<m_idHelperSvc->toString(id));
 
    // Moore error strategy.  Hard coding numbers for the time being - hope to
    // make them configurable some day
    if (myStrategy.creationParameter(MuonDriftCircleErrorStrategy::Segment)) {
        if (myStrategy.creationParameter(MuonDriftCircleErrorStrategy::FixedError) &&
            myStrategy.creationParameter(MuonDriftCircleErrorStrategy::ScaledError)) {
            if (myStrategy.creationParameter(MuonDriftCircleErrorStrategy::T0Refit)) {
                ATH_MSG_VERBOSE(" segment error, t0fit ");
                return sigmaR2 + 0.005;  // Collisions with T0 refit (input)
            } else if (myStrategy.creationParameter(
                           MuonDriftCircleErrorStrategy::BroadError)) {
                ATH_MSG_VERBOSE(" segment error, broad ");
                return 4 * sigmaR2 + 0.16;  // Output segments - broad errors
            } else {
                ATH_MSG_VERBOSE(" segment error, precise ");
                return sigmaR2 + 0.005;  // Input segments , no T0 refit
            }
        }
        // Don't know how to handle other cases - error?
    } else {  // Track
        MuonStationIndex::StIndex stIndex = m_idHelperSvc->stationIndex(id);
        if (myStrategy.creationParameter(
                MuonDriftCircleErrorStrategy::StationError)) {
            if (stIndex == MuonStationIndex::BE) {
                ATH_MSG_VERBOSE(" track error BEE ");
                return 1.44 * sigmaR2 + 4;  // 1.2* + 2 mm
            } else if (stIndex == MuonStationIndex::EE) {
                ATH_MSG_VERBOSE(" track error EE ");
                return 1.44 * sigmaR2 + 0.04;  // 1.2* + 0.2 mm
            } else if (m_idHelperSvc->chamberIndex(id) == MuonStationIndex::BIS &&
                       std::abs(m_idHelperSvc->stationEta(id)) >= 7) {
                ATH_MSG_VERBOSE(" track error BIS78 ");
                if (std::abs(m_idHelperSvc->stationEta(id)) == 7)
                    return 1.44 * sigmaR2 + 1.;  // 1.2* + 1. mm
                return 4 * sigmaR2 + 25;  // 2* + 5. mm
            } else if (m_idHelperSvc->mdtIdHelper().stationName(id) == m_BME_idx &&
                       m_idHelperSvc->stationPhi(id) == 7) {
                ATH_MSG_VERBOSE(" track error BME ");
                return 1.44 * sigmaR2 + 0.25;  // 1.2* + 0.5 mm
            }
            else if (m_idHelperSvc->chamberIndex(id) == MuonStationIndex::BOL &&
                       std::abs(m_idHelperSvc->stationEta(id)) == 7 &&
                       m_idHelperSvc->stationPhi(id) == 7) {
                ATH_MSG_VERBOSE(" track error BOE ");
                return 1.44 * sigmaR2 + 0.25;  // 1.2* + 0.5 mm
            }
            ATH_MSG_VERBOSE(" track station error  ");
            return 1.44 * sigmaR2 + 0.04;  // 1.2* + 0.2 mm
 
        } else if (myStrategy.creationParameter(MuonDriftCircleErrorStrategy::FixedError)) {
 
            if (myStrategy.creationParameter(
                    MuonDriftCircleErrorStrategy::BroadError)) {
                ATH_MSG_VERBOSE(" track error Fixed/Broad ");
                return 4 * sigmaR2 + 4.;  // 2* + 2 mm -> barrel/endcap overlaps
            } else {
                ATH_MSG_VERBOSE(" track error Fixed ");
                return 4 * sigmaR2 + 4.;  // 2* + 2mm S/L overlaps
            }
 
        } else if (myStrategy.creationParameter(MuonDriftCircleErrorStrategy::ScaledError)) {
 
            if (myStrategy.creationParameter(MuonDriftCircleErrorStrategy::BroadError)) {
                ATH_MSG_VERBOSE(" track error Scaled/Broad ");
                return 2.25 * sigmaR2 + 0.09;
            } else {
                // use slightly smaller errors for the barrel
                double fixedTerm = (stIndex == MuonStationIndex::BI ||
                                    stIndex == MuonStationIndex::BM ||
                                    stIndex == MuonStationIndex::BO)
                                       ? 0.015
                                       : 0.015;
                if (m_doIndividualChamberReweights &&
                    m_idHelperSvc->chamberIndex(id) == MuonStationIndex::BIL &&
                    m_idHelperSvc->stationEta(id) == 1 &&
                    m_idHelperSvc->sector(id) == 13 &&
                    m_idHelperSvc->mdtIdHelper().multilayer(id) == 1) {
                    fixedTerm = 1;
                    ATH_MSG_VERBOSE(" track error Scaled: BIL1A13, first multi layer ");
                } else {
                    ATH_MSG_VERBOSE(" track error Scaled ");
                }
 
                return 1.44 * sigmaR2 + fixedTerm;
            }
        }
    }  // End of segment or track
    return sigmaR2;
}

mooreErrorStrategyMC()

double Muon::MdtDriftCircleOnTrackCreator::mooreErrorStrategyMC ( const MuonDriftCircleErrorStrategy &  myStrategy, double  sigmaR, const Identifier &  id  ) const

private

Definition at line 495 of file MdtDriftCircleOnTrackCreator.cxx.

                                                                                      {
    ATH_MSG_DEBUG("mooreErrorStrategy sigmaR2=" << sigmaR2<<" "<<m_idHelperSvc->toString(id));
 
    // Moore error strategy.  Hard coding numbers for the time being - hope to
    // make them configurable some day
    if (myStrategy.creationParameter(MuonDriftCircleErrorStrategy::Segment)) {
        if (myStrategy.creationParameter(MuonDriftCircleErrorStrategy::FixedError) &&
            myStrategy.creationParameter(MuonDriftCircleErrorStrategy::ScaledError)) {
            if (myStrategy.creationParameter(MuonDriftCircleErrorStrategy::T0Refit)) {
                ATH_MSG_VERBOSE(" segment error, t0fit ");
                return sigmaR2 + 0.005;  // Collisions with T0 refit (input)
            } else if (myStrategy.creationParameter(MuonDriftCircleErrorStrategy::BroadError)) {
                ATH_MSG_VERBOSE(" segment error, broad ");
                return 4 * sigmaR2 + 0.16;  // Output segments - broad errors
            } else {
                ATH_MSG_VERBOSE(" segment error, precise ");
                return sigmaR2 + 0.005;  // Input segments , no T0 refit
            }
        }
        // Don't know how to handle other cases - error?
    } else {  // Track
        MuonStationIndex::StIndex stIndex = m_idHelperSvc->stationIndex(id);
        if (myStrategy.creationParameter(MuonDriftCircleErrorStrategy::StationError)) {
            if (stIndex == MuonStationIndex::BE) {
                ATH_MSG_VERBOSE(" track error BEE ");
                return 1.44 * sigmaR2 + 1.44;  // 1.2* + 1.2 mm
            } else if (stIndex == MuonStationIndex::EE) {
                ATH_MSG_VERBOSE(" track error EE ");
                if (!m_isMC && m_idHelperSvc->stationEta(id) < 0)
                    return 1.44 * sigmaR2 + 0.16;  // 1.2* + 0.4 mm
                return 1.44 * sigmaR2 + 1.;        // 1.2* + 1. mm
            } else if (m_idHelperSvc->chamberIndex(id) == MuonStationIndex::BIS &&
                       std::abs(m_idHelperSvc->stationEta(id)) >= 7) {
                ATH_MSG_VERBOSE(" track error BIS78 ");
                if (std::abs(m_idHelperSvc->stationEta(id)) == 7)
                    return 1.44 * sigmaR2 + 1.;  // 1.2* + 1. mm
                else
                    return 4 * sigmaR2 + 25;  // 2* + 5. mm
            }
            ATH_MSG_VERBOSE(" track station error  ");
            return 1.44 * sigmaR2 + 1.;  // 1.2* + 1. mm
 
        } else if (myStrategy.creationParameter(MuonDriftCircleErrorStrategy::FixedError)) {
 
            if (myStrategy.creationParameter(MuonDriftCircleErrorStrategy::BroadError)) {
                ATH_MSG_VERBOSE(" track error Fixed/Broad ");
                return 4 * sigmaR2 + 49.;  // 2* + 7 mm -> barrel/endcap overlaps
            } else {
                ATH_MSG_VERBOSE(" track error Fixed ");
                return 4 * sigmaR2 + 4.;  // 2* + 2mm S/L overlaps
            }
 
        } else if (myStrategy.creationParameter(MuonDriftCircleErrorStrategy::ScaledError)) {
 
            if (myStrategy.creationParameter(MuonDriftCircleErrorStrategy::BroadError)) {
                ATH_MSG_VERBOSE(" track error Scaled/Broad ");
                return 2.25 * sigmaR2 + 0.09;
            } else {
                // use slightly smaller errors for the barrel
                double fixedTerm = (stIndex == MuonStationIndex::BI ||
                                    stIndex == MuonStationIndex::BM ||
                                    stIndex == MuonStationIndex::BO)
                                       ? 0.014
                                       : 0.04;
                if (m_doIndividualChamberReweights &&
                    m_idHelperSvc->chamberIndex(id) == MuonStationIndex::BIL &&
                    m_idHelperSvc->stationEta(id) == 1 &&
                    m_idHelperSvc->sector(id) == 13 &&
                    m_idHelperSvc->mdtIdHelper().multilayer(id) == 1) {
                    fixedTerm = 1;
                    ATH_MSG_VERBOSE(" track error Scaled: BIL1A13, first multi layer ");
                } else {
                    ATH_MSG_VERBOSE(" track error Scaled ");
                }
                return 1.44 * sigmaR2 + fixedTerm;
            }
        }
    }  // End of segment or track
    return sigmaR2;
}

mooreErrorStrategyTight()

double Muon::MdtDriftCircleOnTrackCreator::mooreErrorStrategyTight ( const MuonDriftCircleErrorStrategy &  myStrategy, double  sigmaR, const Identifier &  id  ) const

private

Need to check whether this Identifier is still valid?

Definition at line 673 of file MdtDriftCircleOnTrackCreator.cxx.

                                                                                         {
    ATH_MSG_DEBUG("mooreErrorStrategy sigmaR2=" << sigmaR2);
 
    // Moore error strategy.  Hard coding numbers for the time being - hope to
    // make them configurable some day
    if (myStrategy.creationParameter(MuonDriftCircleErrorStrategy::Segment)) {
        if (myStrategy.creationParameter(MuonDriftCircleErrorStrategy::FixedError) &&
            myStrategy.creationParameter(MuonDriftCircleErrorStrategy::ScaledError)) {
            if (myStrategy.creationParameter(MuonDriftCircleErrorStrategy::T0Refit)) {
                ATH_MSG_VERBOSE(" segment error, t0fit ");
                return sigmaR2 + 0.005;  // Collisions with T0 refit (input)
            } else if (myStrategy.creationParameter(MuonDriftCircleErrorStrategy::BroadError)) {
                ATH_MSG_VERBOSE(" segment error, broad ");
                return 4 * sigmaR2 + 0.16;  // Output segments - broad errors
            } else {
                ATH_MSG_VERBOSE(" segment error, precise ");
                return sigmaR2 + 0.005;  // Input segments , no T0 refit
            }
        }
        // Don't know how to handle other cases - error?
    } else {  // Track
        MuonStationIndex::StIndex stIndex = m_idHelperSvc->stationIndex(id);
        if (myStrategy.creationParameter(MuonDriftCircleErrorStrategy::StationError)) {
            if (stIndex == MuonStationIndex::BE) {
                ATH_MSG_VERBOSE(" track error BEE ");
                return 1.44 * sigmaR2 + 0.04;  // 1.2* + 0.2 mm
            } else if (stIndex == MuonStationIndex::EE) {
                ATH_MSG_VERBOSE(" track error EE ");
                if (m_idHelperSvc->isSmallChamber(id))
                    return 1.21 * sigmaR2 + 0.01;  // 1.1* + 0.1 mm
                else
                    return 1.21 * sigmaR2 + 0.01;  // 1.1* + 0.1 mm
            } else if (m_idHelperSvc->chamberIndex(id) == MuonStationIndex::BIS &&
                       std::abs(m_idHelperSvc->stationEta(id)) >= 7) {
                ATH_MSG_VERBOSE(" track error BIS78 ");
                if (std::abs(m_idHelperSvc->stationEta(id)) == 7)
                    return 1.44 * sigmaR2 + 1.;  // 1.2* + 1. mm
 
                return 4 * sigmaR2 + 1.;  // 2* + 1. mm
            } else if (stIndex == MuonStationIndex::BM &&
                       m_idHelperSvc->stationPhi(id) == 7 &&
                       (m_idHelperSvc->mdtIdHelper()).stationName(id) == m_BME_idx) {
                ATH_MSG_VERBOSE(" track error BME ");
                return 1.21 * sigmaR2 + 0.25;  // 1.1* + 0.5 mm
            }
            else if (m_idHelperSvc->chamberIndex(id) == MuonStationIndex::BOL &&
                       std::abs(m_idHelperSvc->stationEta(id)) == 7 &&
                       m_idHelperSvc->stationPhi(id) == 7) {
                ATH_MSG_VERBOSE(" track error BOE ");
                return 1.21 * sigmaR2 + 0.25;  // 1.1* + 0.5 mm
            } else if (stIndex == MuonStationIndex::EE &&
                       m_idHelperSvc->chamberIndex(id) == MuonStationIndex::EEL &&
                       m_idHelperSvc->stationEta(id) < 0 &&
                       m_idHelperSvc->stationPhi(id) == 3) {
                ATH_MSG_VERBOSE(" track error EEL1C05 ");
                return 1.21 * sigmaR2 + 25.;  // 1.1* + 5 mm
            }
            ATH_MSG_VERBOSE(" track station error  ");
            return 1.21 * sigmaR2 + 0.04;  // 1.1* + 0.2 mm
 
        } else if (myStrategy.creationParameter(MuonDriftCircleErrorStrategy::FixedError)) {
 
            if (myStrategy.creationParameter(MuonDriftCircleErrorStrategy::BroadError)) {
                ATH_MSG_VERBOSE(" track error Fixed/Broad ");
                return 4 * sigmaR2 + 4.;  // 2* + 2 mm -> barrel/endcap overlaps
            } else {
                ATH_MSG_VERBOSE(" track error Fixed ");
                return 4 * sigmaR2 + 4.;  // 2* + 2mm S/L overlaps
            }
 
        } else if (myStrategy.creationParameter(MuonDriftCircleErrorStrategy::ScaledError)) {
 
            if (myStrategy.creationParameter(MuonDriftCircleErrorStrategy::BroadError)) {
                ATH_MSG_VERBOSE(" track error Scaled/Broad ");
                return 2.25 * sigmaR2 + 0.09;
            } else {
 
                // use slightly smaller errors for the barrel
                //
                double fixedTerm = 0.01;
                if (m_doIndividualChamberReweights) {
                    if (m_idHelperSvc->chamberIndex(id) == MuonStationIndex::BIL &&
                        m_idHelperSvc->stationEta(id) == 1 &&
                        m_idHelperSvc->sector(id) == 13 &&
                        m_idHelperSvc->mdtIdHelper().multilayer(id) == 1) {
                        fixedTerm = 1;
                        ATH_MSG_VERBOSE(" track error Scaled: BIL1A13, first multi layer ");
                    }
                } else {
                    ATH_MSG_VERBOSE(" track error Scaled ");
                }
 
                return 1.21 * sigmaR2 + fixedTerm;
            }
        }
    }  // End of segment or track
    return sigmaR2;
}

msg() [1/2]

MsgStream& AthCommonMsg< AlgTool >::msg ( ) const

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msg() [2/2]

MsgStream& AthCommonMsg< AlgTool >::msg ( const MSG::Level  lvl ) const

inlineinherited

Definition at line 27 of file AthCommonMsg.h.

                                                  {
    return this->msgStream(lvl);
  }

msgLvl()

bool AthCommonMsg< AlgTool >::msgLvl ( const MSG::Level  lvl ) const

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

muonErrorStrategy()

double Muon::MdtDriftCircleOnTrackCreator::muonErrorStrategy ( const MuonDriftCircleErrorStrategy &  myStrategy, double  sigmaR, const Identifier &  id  ) const

private

Definition at line 775 of file MdtDriftCircleOnTrackCreator.cxx.

                                                                                  {
 
    //
    //   the new muonErrorStrategy is identical for Data and MC
    //   it assumes that for tracks the alignment uncertainties are added later
    //   this is done by the AignmentErrorTool where AlignmentEffectsOnTrack are
    //   used. (for segment errors the mooreStrategy is coded)
    //
    //   it is inspired by the mooreErrorStrategyTight but does not need a constant term
    //
 
    ATH_MSG_DEBUG("muonErrorStrategy sigmaR2=" << sigmaR2);
 
    // Muon error strategy.  Hard coding numbers for the time being - hope to
    // make them configurable some day
    if (myStrategy.creationParameter(MuonDriftCircleErrorStrategy::Segment)) {
        if (myStrategy.creationParameter(MuonDriftCircleErrorStrategy::FixedError) &&
            myStrategy.creationParameter(MuonDriftCircleErrorStrategy::ScaledError)) {
            if (myStrategy.creationParameter(MuonDriftCircleErrorStrategy::T0Refit)) {
                ATH_MSG_VERBOSE(" segment error, t0fit ");
                return sigmaR2 + 0.005;  // Collisions with T0 refit (input)
            } else if (myStrategy.creationParameter(MuonDriftCircleErrorStrategy::BroadError)) {
                ATH_MSG_VERBOSE(" segment error, broad ");
                return 4 * sigmaR2 + 0.16;  // Output segments - broad errors
            } else {
                ATH_MSG_VERBOSE(" segment error, precise ");
                return sigmaR2 + 0.005;  // Input segments , no T0 refit
            }
        }
    } else {  // Track
        if (myStrategy.creationParameter(MuonDriftCircleErrorStrategy::StationError)) {
            ATH_MSG_VERBOSE(" track station error  ");
            return 1.21 * sigmaR2;  // 1.1* mm
        } else if (myStrategy.creationParameter(MuonDriftCircleErrorStrategy::FixedError)) {
            ATH_MSG_VERBOSE(" track error Fixed ");
            return 4 * sigmaR2;  // 2*
        } else if (myStrategy.creationParameter(MuonDriftCircleErrorStrategy::ScaledError)) {
            if (myStrategy.creationParameter(MuonDriftCircleErrorStrategy::BroadError)) {
                ATH_MSG_VERBOSE(" track error Scaled/Broad ");
                return 2.25 * sigmaR2;
            } else {
                ATH_MSG_VERBOSE(" Track scaled error ");
                return 1.21 * sigmaR2;
            }
        }
    }  // End of segment or track
    return sigmaR2;
}

outputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< AlgTool > >::outputHandles ( ) const

overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

parametrisedSigma()

double Muon::MdtDriftCircleOnTrackCreator::parametrisedSigma ( double  r )

staticprivate

These are presumably fitted from data but no clue where and how

Definition at line 477 of file MdtDriftCircleOnTrackCreator.cxx.

                                                               {
    return 0.23 * std::exp(-std::abs(r) / 6.06) + 0.0362;
}

renounce()

std::enable_if_t<std::is_void_v<std::result_of_t<decltype(&T::renounce)(T)> > && !std::is_base_of_v<SG::VarHandleKeyArray, T> && std::is_base_of_v<Gaudi::DataHandle, T>, void> AthCommonDataStore< AthCommonMsg< AlgTool > >::renounce ( T &  h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

  {
    h.renounce();
    PBASE::renounce (h);
  }

renounceArray()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::renounceArray ( SG::VarHandleKeyArray &  handlesArray )

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

sysInitialize()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysInitialize ( )

overridevirtualinherited

Perform system initialization for an algorithm.

We override this to declare all the elements of handle key arrays at the end of initialization. See comments on updateVHKA.

Reimplemented in DerivationFramework::CfAthAlgTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and asg::AsgMetadataTool.

sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysStart ( )

overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

timeOfFlight()

double Muon::MdtDriftCircleOnTrackCreator::timeOfFlight ( const Amg::Vector3D &  pos, const double  beta, const double  tTrack, const double  tShift  ) const

private

Definition at line 469 of file MdtDriftCircleOnTrackCreator.cxx.

                                                                             {
    return m_applyToF * (pos.mag() * s_inverseSpeedOfLight / beta) +
           tTrack + tShift;
}

updateError()

MdtRotPtr Muon::MdtDriftCircleOnTrackCreator::updateError ( const MdtDriftCircleOnTrack &  DCT, const Trk::TrackParameters *  pars = nullptr, const MuonDriftCircleErrorStrategy *  strategy = nullptr  ) const

overridevirtual

Update error of a ROT without changing the drift radius.

Parameters

DCT	reference to the Muon::MdtDriftCircleOnTrack of which the sign should be updated.
pars	track prediction at DCT used when using the track prediction to update the error
strategy	optional drift circle error strategy to override the default

Returns

New ROT with updated error. (the user must delete this object when it is no longer needed).

Parameters

pars

pars

Implements Muon::IMdtDriftCircleOnTrackCreator.

Definition at line 397 of file MdtDriftCircleOnTrackCreator.cxx.

                                                                                                        {
 
    const MuonDriftCircleErrorStrategy& myStrategy = (!strategy) ? m_errorStrategy : *strategy;
 
    // calculate error
    double sigmaR(1.);
    double t = DCT.driftTime();
 
    const MuonGM::MdtReadoutElement* detEl = DCT.detectorElement();
    if (!detEl) {
        ATH_MSG_WARNING("MdtDriftCircleOnTrack without MdtReadoutElement "
                        << m_idHelperSvc->toString(DCT.identify()));
        return nullptr;
    }
 
    double radius = DCT.driftRadius();
 
    if (myStrategy.creationParameter(MuonDriftCircleErrorStrategy::BroadError) &&
        !myStrategy.creationParameter(MuonDriftCircleErrorStrategy::ScaledError) &&
        !myStrategy.creationParameter(MuonDriftCircleErrorStrategy::FixedError)) {
        sigmaR = detEl->innerTubeRadius() / std::sqrt(3.0);  // Tube hit
    } else {
        if (myStrategy.creationParameter(MuonDriftCircleErrorStrategy::ErrorAtPredictedPosition))
            ATH_MSG_WARNING("updateError: ErrorAtPredictedPosition is not yet supported!");
        // get error
        if (myStrategy.creationParameter(MuonDriftCircleErrorStrategy::ParameterisedErrors)) {
            if (myStrategy.strategy() == MuonDriftCircleErrorStrategy::Moore) {
                sigmaR = parametrisedSigma(radius);
            } else if (myStrategy.strategy() == MuonDriftCircleErrorStrategy::Muon) {
                sigmaR = parametrisedSigma(radius);
                ATH_MSG_DEBUG("Muon drift errors:" << sigmaR
                                                   << " for radius=" << radius);
            }
        } else {
            const EventContext& ctx{Gaudi::Hive::currentContext()};
            sigmaR = m_mdtCalibrationTool->getResolutionFromRt(ctx,
                                                               DCT.identify(),
                                                               DCT.driftTime());
            if (sigmaR < 0.0001 || sigmaR * sigmaR < 0.0001) {
                ATH_MSG_WARNING("Bad obtained from calibration service: error "
                                << m_idHelperSvc->toString(DCT.identify())
                                << " reso " << sigmaR << " sigma2 "
                                << sigmaR * sigmaR << " drift time " << t
                                << " original " << DCT.driftTime());
                return nullptr;
            }
        }
 
    }  // end of tube hit check
 
    double sigmaR2 = 0.0;
    // Handle the errors scaling / addition of fixed terms
    if (myStrategy.strategy() == MuonDriftCircleErrorStrategy::Moore) {
        sigmaR2 = mooreErrorStrategy(myStrategy, sigmaR * sigmaR, DCT.identify());
    } else if (myStrategy.strategy() == MuonDriftCircleErrorStrategy::Muon) {
        sigmaR2 =  muonErrorStrategy(myStrategy, sigmaR * sigmaR, DCT.identify());
        ATH_MSG_DEBUG("After scaling etc:\t Muon ErrorStrategy sigmaR2 = " << sigmaR2);
    }
    std::unique_ptr<MdtDriftCircleOnTrack> rot{DCT.clone()};
    rot->m_localCovariance(0, 0) = sigmaR2;
    rot->setErrorStrategy(myStrategy);
 
    ATH_MSG_VERBOSE("updated error for "
                    << m_idHelperSvc->toString(DCT.identify()) << " new error "
                    << Amg::error(rot->localCovariance(), Trk::locR)
                    << " old error "
                    << Amg::error(DCT.localCovariance(), Trk::locR));
    return rot.release();
}

updateSign()

void Muon::MdtDriftCircleOnTrackCreator::updateSign ( MdtDriftCircleOnTrack &  rot, const Trk::DriftCircleSide  si  ) const

finaloverridevirtual

Update of the sign of the drift radius.

The method creates a new MdtDriftCircleOnTrack, the old input MdtDriftCircleOnTrack is not deleted. The user should take care of the memory managment of both MdtDriftCircleOnTracks.

Parameters

rot	reference to the Muon::MdtDriftCircleOnTrack of which the sign should be updated.
si	Trk::DriftCircleSide indicating whether the muon passed on the left or right side of the wire.

Implements Muon::IMdtDriftCircleOnTrackCreator.

Definition at line 278 of file MdtDriftCircleOnTrackCreator.cxx.

                                                                           {
    // ************************
    // Apply additional corrections to local position
    Trk::LocalParameters lpos(caliDriftCircle.localParameters());
 
    // set sign LocalPosition
    if (si == Trk::LEFT) {
        lpos[Trk::driftRadius] = -std::abs(lpos[Trk::driftRadius]);
    } else {
        lpos[Trk::driftRadius] = std::abs(lpos[Trk::driftRadius]);
    }
 
    caliDriftCircle.setLocalParameters(lpos);
    caliDriftCircle.m_status = Trk::DECIDED;
    ATH_MSG_VERBOSE("MDT DriftCircleOnTrack made with radius = " << lpos);
}

updateVHKA()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::updateVHKA ( Gaudi::Details::PropertyBase &  )

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

                                               {
    // debug() << "updateVHKA for property " << p.name() << " " << p.toString() 
    //         << "  size: " << m_vhka.size() << endmsg;
    for (auto &a : m_vhka) {
      std::vector<SG::VarHandleKey*> keys = a->keys();
      for (auto k : keys) {
        k->setOwner(this);
      }
    }
  }

Member Data Documentation

m_applyToF

Gaudi::Property<bool> Muon::MdtDriftCircleOnTrackCreator::m_applyToF {this, "ApplyToF", true}

private

toggle between loose errors (initial before alignment) and tight after alignment

Definition at line 269 of file MdtDriftCircleOnTrackCreator.h.

m_BME_idx

int Muon::MdtDriftCircleOnTrackCreator::m_BME_idx {-1}

private

Definition at line 279 of file MdtDriftCircleOnTrackCreator.h.

m_createTubeHits

Gaudi::Property<bool> Muon::MdtDriftCircleOnTrackCreator::m_createTubeHits {this, "CreateTubeHit", false}

private

Scale ROTs depending on local alignment (i.e.

location in detector)

Definition at line 246 of file MdtDriftCircleOnTrackCreator.h.

m_defaultStrategy

Gaudi::Property<std::string> Muon::MdtDriftCircleOnTrackCreator::m_defaultStrategy

private

Initial value:

{this, "DefaultErrorStrategy", "Muon",
                        "Default error strategy to be used in calculating errors"}

if set to true, the ROT creator create 'tube' hits with a local position of 0 and an error of tube radius/sqrt(12)

Definition at line 241 of file MdtDriftCircleOnTrackCreator.h.

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

m_doFixedError

Gaudi::Property<bool> Muon::MdtDriftCircleOnTrackCreator::m_doFixedError {this, "DoFixedError", true}

private

Use parameterised errors.

Definition at line 250 of file MdtDriftCircleOnTrackCreator.h.

m_doIndividualChamberReweights

Gaudi::Property<bool> Muon::MdtDriftCircleOnTrackCreator::m_doIndividualChamberReweights {this, "DeweightIndividualChambers", true}

private

toggle between MC and data alignment errors (to be removed in rel.

21!)

Definition at line 265 of file MdtDriftCircleOnTrackCreator.h.

m_doMdt

Gaudi::Property<bool> Muon::MdtDriftCircleOnTrackCreator::m_doMdt {this, "doMDT", true}

private

Process MDT ROTs.

Defined in TimingMode enum.

Definition at line 226 of file MdtDriftCircleOnTrackCreator.h.

m_doSegments

Gaudi::Property<bool> Muon::MdtDriftCircleOnTrackCreator::m_doSegments {this, "DoSegmentErrors", true}

private

Deweight individual chambers.

Definition at line 263 of file MdtDriftCircleOnTrackCreator.h.

m_errorAtPredictedPosition

Gaudi::Property<bool> Muon::MdtDriftCircleOnTrackCreator::m_errorAtPredictedPosition {this, "UseErrorAtPredictedPosition", false}

private

Add a term to the error to account for very poorly aligned stations.

Definition at line 257 of file MdtDriftCircleOnTrackCreator.h.

m_errorStrategy

MuonDriftCircleErrorStrategy Muon::MdtDriftCircleOnTrackCreator::m_errorStrategy {MuonDriftCircleErrorStrategyInput{}}

private

< Error strategy for created ROTs

Default error strategy for the error strategy object

Definition at line 238 of file MdtDriftCircleOnTrackCreator.h.

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

m_fixedError

Gaudi::Property<double> Muon::MdtDriftCircleOnTrackCreator::m_fixedError {this, "FixedError", 1.}

private

< Error used when m_doFixed error =true or m_scaleErrorManually = true

Definition at line 231 of file MdtDriftCircleOnTrackCreator.h.

m_globalToLocalTolerance

Gaudi::Property<double> Muon::MdtDriftCircleOnTrackCreator::m_globalToLocalTolerance

private

Initial value:

{this, "GlobalToLocalTolerance", 1000.,
                                                     "Tolerance used for the Surface::globalToLocal"}

Definition at line 233 of file MdtDriftCircleOnTrackCreator.h.

m_idHelperSvc

ServiceHandle<Muon::IMuonIdHelperSvc> Muon::MdtDriftCircleOnTrackCreator::m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}

private

Definition at line 221 of file MdtDriftCircleOnTrackCreator.h.

m_isMC

Gaudi::Property<bool> Muon::MdtDriftCircleOnTrackCreator::m_isMC {this, "IsMC", false}

private

toggle whether the time of flight is included in the t0 shifts

Definition at line 267 of file MdtDriftCircleOnTrackCreator.h.

m_looseErrors

Gaudi::Property<bool> Muon::MdtDriftCircleOnTrackCreator::m_looseErrors

private

Initial value:

{this, "UseLooseErrors", false,
                                        "Use error strategy for MC"}

Definition at line 272 of file MdtDriftCircleOnTrackCreator.h.

m_mdtCalibrationTool

ToolHandle<IMdtCalibrationTool> Muon::MdtDriftCircleOnTrackCreator::m_mdtCalibrationTool {this, "CalibrationTool", ""}

private

Definition at line 223 of file MdtDriftCircleOnTrackCreator.h.

m_scaleMdtCov

Gaudi::Property<bool> Muon::MdtDriftCircleOnTrackCreator::m_scaleMdtCov {this, "DoErrorScaling", true}

private

Fixed error (not tube radius)

Definition at line 248 of file MdtDriftCircleOnTrackCreator.h.

m_stationError

Gaudi::Property<bool> Muon::MdtDriftCircleOnTrackCreator::m_stationError {this, "DoStationError", false}

private

Add a special error to account for the T0 refit.

Definition at line 259 of file MdtDriftCircleOnTrackCreator.h.

m_t0Refit

Gaudi::Property<bool> Muon::MdtDriftCircleOnTrackCreator::m_t0Refit {this, "T0RefitError", false}

private

Use error strategy for segments by default.

Definition at line 261 of file MdtDriftCircleOnTrackCreator.h.

m_timeCorrectionType

Gaudi::Property<int> Muon::MdtDriftCircleOnTrackCreator::m_timeCorrectionType {this, "TimingMode", 0}

private

Definition at line 228 of file MdtDriftCircleOnTrackCreator.h.

m_useErrorParametrisation

Gaudi::Property<bool> Muon::MdtDriftCircleOnTrackCreator::m_useErrorParametrisation {this, "UseParametrisedError", false}

private

Use the predicted track position to correct the Error.

See Muon::MdtDriftCircleOnTrack::ErrorAtPredictedPosition The error will be adjusted to be that corresponding to the predicted position. This is useful to fix problems with tracks very close to the wire.

Definition at line 252 of file MdtDriftCircleOnTrackCreator.h.

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

m_wasConfigured

Gaudi::Property<bool> Muon::MdtDriftCircleOnTrackCreator::m_wasConfigured

private

Initial value:

{this, "WasConfigured", false,
                    "This tool is too complicated to rely on defaults. Will fail if not configured."}

Definition at line 274 of file MdtDriftCircleOnTrackCreator.h.

s_inverseSpeedOfLight

constexpr double Muon::MdtDriftCircleOnTrackCreator::s_inverseSpeedOfLight {1. / Gaudi::Units::c_light}

staticconstexprprivate

Definition at line 277 of file MdtDriftCircleOnTrackCreator.h.

---

The documentation for this class was generated from the following files:

• MdtDriftCircleOnTrackCreator.h
• MdtDriftCircleOnTrackCreator.cxx