From 3276faa1acfbb30ae9d4155085d89ca033b0944e Mon Sep 17 00:00:00 2001
From: Johannes Junggeburth <johannes.josef.junggeburth@cern.ch>
Date: Fri, 22 Sep 2023 20:07:07 +0200
Subject: [PATCH] MdtCalibration - Initial clean up of the calibration tools
Revise MdtCalibration Svc
Remove obsolete files
ALWAYS
Fix test
Apply 2 suggestion(s) to 1 file(s)
---
.../MdtCalib/MdtCalibData/CMakeLists.txt | 2 +-
.../MdtCalibData/MdtCalibDataContainer.h | 59 +
.../MdtCalibData/MdtCorFuncSetCollection.h | 31 -
.../MdtCalibData/MdtFullCalibData.h | 27 +-
.../MdtCalibData/MdtRtRelationCollection.h | 31 -
.../MdtCalibData/MdtTubeCalibContainer.h | 66 +-
.../MdtTubeCalibContainerCollection.h | 31 -
.../MdtCalibData/MdtTubeFitContainer.h | 103 +-
.../MdtCalibData/MdtTubeFullInfoContainer.h | 63 +-
.../MdtCalibData/RtScaleFunction.h | 6 +-
.../src/MdtCalibDataContainer.cxx | 114 ++
.../src/MdtTubeCalibContainer.cxx | 53 +
.../MdtCalibData/src/MdtTubeFitContainer.cxx | 59 +
.../src/MdtTubeFullInfoContainer.cxx | 36 +
.../MdtCalibData/src/RtScaleFunction.cxx | 10 +-
.../MdtCalibInterfaces/CMakeLists.txt | 4 +-
.../MdtCalibInterfaces/IMdtCalibrationTool.h | 107 ++
.../MdtCalibInterfaces/IShiftMapTools.h | 2 +-
.../MdtCalibInterfaces/MdtCalibInput.h | 145 ++
.../MdtCalibInterfaces/MdtCalibOutput.h | 84 +
.../MdtCalibInterfaces/MdtCalibTwinOutput.h | 66 +
.../MdtCalibInterfaces/src/MdtCalibInput.cxx | 153 ++
.../MdtCalibInterfaces/src/MdtCalibOutput.cxx | 56 +
.../src/MdtCalibTwinOutput.cxx | 55 +
.../MdtCalib/MdtCalibSvc/CMakeLists.txt | 6 +-
.../MdtCalibSvc/MdtCalibrationDbTool.h | 98 -
.../MdtCalibSvc/MdtCalibrationRegionSvc.h | 98 -
.../MdtCalibSvc/MdtCalibrationSvcInput.h | 41 -
.../MdtCalibSvc/MdtCalibrationSvcSettings.h | 159 --
.../MdtCalibSvc/MdtCalibrationTool.h | 131 --
.../MdtCalibSvc/src/MdtCalibrationDbTool.cxx | 218 ---
.../src/MdtCalibrationRegionSvc.cxx | 98 -
.../src/MdtCalibrationShiftMapBase.cxx | 6 +-
.../MdtCalibrationShiftMapBase.h | 2 +-
.../src/MdtCalibrationT0ShiftTool.cxx | 4 +-
.../MdtCalibrationT0ShiftTool.h | 5 +-
.../src/MdtCalibrationTMaxShiftTool.cxx | 8 +-
.../MdtCalibrationTMaxShiftTool.h | 6 +-
.../MdtCalibSvc/src/MdtCalibrationTool.cxx | 1064 ++++------
.../MdtCalibSvc/src/MdtCalibrationTool.h | 136 ++
.../src/components/MdtCalibSvc_entries.cxx | 14 +-
.../MdtCalibT0/src/T0CalibrationClassic.cxx | 17 +-
.../MdtCalibT0/src/T0CalibrationMT.cxx | 19 +-
.../MdtCalibUtils/GlobalTimeFitter.h | 3 +-
.../MdtCalibUtils/TubeDataFromFile.h | 10 +-
.../MdtCalibUtils/src/GlobalTimeFitter.cxx | 2 +-
.../MdtCalibUtils/src/TubeDataFromFile.cxx | 251 +--
.../CalibT0DbOperations.h | 20 +-
.../src/CalibT0DbOperations.cxx | 142 +-
...CMakeLists.txt => CMakeLists_disabled.txt} | 0
...CMakeLists.txt => CMakeLists_disabled.txt} | 0
.../MuonCnvExample/python/MuonCalibConfig.py | 13 +-
.../MdtDriftCircleOnTrackCnv_p1.h | 6 +-
.../MdtDriftCircleOnTrackCnv_p1.cxx | 10 +-
.../MdtDriftCircleOnTrackCnv_p2.cxx | 13 +-
.../test/MdtDriftCircleOnTrackCnv_p2_test.cxx | 3 +-
.../src/MdtRdoToPrepDataToolMT.cxx | 624 ++----
.../src/MdtRdoToPrepDataToolMT.h | 28 +-
.../MuonCondAlg/MuonCondAlg/MdtCalibDbAlg.h | 75 +-
.../MuonCondAlg/src/MdtCalibDbAlg.cxx | 480 ++---
.../MuonCondDump/CMakeLists.txt | 2 +-
.../python/MDT_DigitizationConfig.py | 22 +-
.../python/MuonCalibrationConfig.py | 36 +-
.../MuonRIO_OnTrackCreatorToolConfig.py | 29 +-
.../MuonConfig/python/MuonRdoDecodeConfig.py | 4 +-
.../python/MuonSegmentFindingConfig.py | 5 +-
.../share/MdtRdoToPrepDataTool_test.ref | 1712 ++++++++---------
.../MDT_Digitization/MdtDigitizationTool.h | 9 +-
.../RT_Relation_DB_DigiTool.h | 5 +-
.../python/MdtDigitizationConfigLegacy.py | 7 +-
.../src/MdtDigitizationTool.cxx | 38 +-
.../src/RT_Relation_DB_DigiTool.cxx | 43 +-
.../CMakeLists.txt | 5 +-
.../doc/packagedoc.h | 14 +-
.../src/MdtDriftCircleOnTrackCreator.cxx | 1669 ++++++++--------
.../src/MdtDriftCircleOnTrackCreator.h | 489 ++---
.../MdtDriftCircleOnTrackCreator_entries.cxx | 6 +-
.../MuonRIO_OnTrack/MdtDriftCircleOnTrack.h | 254 +--
.../MuonDriftCircleErrorStrategy.h | 6 +-
.../src/MdtDriftCircleOnTrack.cxx | 336 +---
.../MuonRecExample/python/MuonRecTools.py | 46 +-
.../IMdtDriftCircleOnTrackCreator.h | 56 +-
.../MdtSegmentT0Fitter/MdtSegmentT0Fitter.h | 11 +-
.../src/MdtSegmentT0Fitter.cxx | 34 +-
.../python/MuonCombinedRecToolsConfig.py | 14 +-
.../python/MuGirlTagTool.py | 4 +-
.../src/MuonStauRecoTool.cxx | 21 +-
.../src/MuonStauRecoTool.h | 17 +-
.../test/test_MC16a_Digi_tf_configuration.py | 2 +-
Tools/PROCTools/data/q442_AOD_digest.ref | 2 +-
Tools/PROCTools/data/q449_AOD_digest.ref | 8 +-
Tools/PROCTools/data/q450_AOD_digest.ref | 2 +-
Tools/WorkflowTestRunner/python/References.py | 8 +-
.../TrigL2MuonSA/src/MuFastPatternFinder.cxx | 36 +-
.../TrigL2MuonSA/src/MuFastPatternFinder.h | 4 +-
.../share/ref_v1Dev_decodeBS_build.ref | 451 +----
.../VP1TrackSystems/src/TrkObjToString.cxx | 2 +-
97 files changed, 4565 insertions(+), 6017 deletions(-)
create mode 100644 MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibData/MdtCalibData/MdtCalibDataContainer.h
delete mode 100644 MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibData/MdtCalibData/MdtCorFuncSetCollection.h
delete mode 100644 MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibData/MdtCalibData/MdtRtRelationCollection.h
delete mode 100644 MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibData/MdtCalibData/MdtTubeCalibContainerCollection.h
create mode 100644 MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibData/src/MdtCalibDataContainer.cxx
create mode 100644 MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibData/src/MdtTubeCalibContainer.cxx
create mode 100644 MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibData/src/MdtTubeFitContainer.cxx
create mode 100644 MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibData/src/MdtTubeFullInfoContainer.cxx
create mode 100644 MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibInterfaces/MdtCalibInterfaces/IMdtCalibrationTool.h
create mode 100644 MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibInterfaces/MdtCalibInterfaces/MdtCalibInput.h
create mode 100644 MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibInterfaces/MdtCalibInterfaces/MdtCalibOutput.h
create mode 100644 MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibInterfaces/MdtCalibInterfaces/MdtCalibTwinOutput.h
create mode 100644 MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibInterfaces/src/MdtCalibInput.cxx
create mode 100644 MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibInterfaces/src/MdtCalibOutput.cxx
create mode 100644 MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibInterfaces/src/MdtCalibTwinOutput.cxx
delete mode 100644 MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibSvc/MdtCalibSvc/MdtCalibrationDbTool.h
delete mode 100644 MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibSvc/MdtCalibSvc/MdtCalibrationRegionSvc.h
delete mode 100644 MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibSvc/MdtCalibSvc/MdtCalibrationSvcInput.h
delete mode 100644 MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibSvc/MdtCalibSvc/MdtCalibrationSvcSettings.h
delete mode 100644 MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibSvc/MdtCalibSvc/MdtCalibrationTool.h
delete mode 100644 MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibSvc/src/MdtCalibrationDbTool.cxx
delete mode 100644 MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibSvc/src/MdtCalibrationRegionSvc.cxx
rename MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibSvc/{MdtCalibSvc => src}/MdtCalibrationShiftMapBase.h (96%)
rename MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibSvc/{MdtCalibSvc => src}/MdtCalibrationT0ShiftTool.h (85%)
rename MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibSvc/{MdtCalibSvc => src}/MdtCalibrationTMaxShiftTool.h (85%)
create mode 100644 MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibSvc/src/MdtCalibrationTool.h
rename MuonSpectrometer/MuonCalib/MuonCalibPatRec/{CMakeLists.txt => CMakeLists_disabled.txt} (100%)
rename MuonSpectrometer/MuonCalib/MuonCalibStandAlone/MdtCalibIOSvc/{CMakeLists.txt => CMakeLists_disabled.txt} (100%)
diff --git a/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibData/CMakeLists.txt b/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibData/CMakeLists.txt
index cab5766d382..55cd9c99992 100644
--- a/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibData/CMakeLists.txt
+++ b/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibData/CMakeLists.txt
@@ -13,6 +13,6 @@ atlas_add_library( MdtCalibData
src/*.cxx
PUBLIC_HEADERS MdtCalibData
PRIVATE_INCLUDE_DIRS ${ROOT_INCLUDE_DIRS}
- LINK_LIBRARIES AthContainers EventPrimitives MuonCalibMath
+ LINK_LIBRARIES AthContainers EventPrimitives MuonCalibMath GeoModelUtilities MuonIdHelpersLib
PRIVATE_LINK_LIBRARIES ${ROOT_LIBRARIES} AthenaKernel GaudiKernel )
diff --git a/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibData/MdtCalibData/MdtCalibDataContainer.h b/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibData/MdtCalibData/MdtCalibDataContainer.h
new file mode 100644
index 00000000000..c1ed8cc1fb7
--- /dev/null
+++ b/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibData/MdtCalibData/MdtCalibDataContainer.h
@@ -0,0 +1,59 @@
+/*
+ Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
+*/
+#ifndef MUONCALIB_MDTCALIBDATACONTAINER_H
+#define MUONCALIB_MDTCALIBDATACONTAINER_H
+
+
+#include <AthenaKernel/CLASS_DEF.h>
+#include <AthenaKernel/CondCont.h>
+#include <GaudiKernel/MsgStream.h>
+
+#include <MuonIdHelpers/IMuonIdHelperSvc.h>
+#include <MdtCalibData/MdtFullCalibData.h>
+
+#include <memory>
+#include <optional>
+
+namespace MuonCalib{
+
+ class MdtCalibDataContainer{
+ public:
+ using CorrectionPtr = MdtFullCalibData::CorrectionPtr;
+ using RtRelationPtr = MdtFullCalibData::RtRelationPtr;
+ using TubeContainerPtr = MdtFullCalibData::TubeContainerPtr;
+
+ enum class RegionGranularity { OneRt, OnePerChamber, OnePerMultiLayer };
+ MdtCalibDataContainer(const Muon::IMuonIdHelperSvc* idHelprSvc,
+ const RegionGranularity granularity);
+
+ ~MdtCalibDataContainer() = default;
+ /// Returns the calibration data associated with this station
+ const MdtFullCalibData* getCalibData(const Identifier& measId,
+ MsgStream& msg) const;
+ /// Checks whether a calibration data object is already present
+ bool hasDataForChannel(const Identifier& measId, MsgStream& msg) const;
+
+
+ bool storeData(const Identifier& mlID, CorrectionPtr corrFuncSet, MsgStream& msg);
+ bool storeData(const Identifier& mlID, RtRelationPtr rtRelation, MsgStream& msg);
+ bool storeData(const Identifier& mlID, TubeContainerPtr tubeContainer, MsgStream& msg);
+
+ RegionGranularity granularity() const;
+ private:
+ std::optional<unsigned int> containerIndex(const Identifier& measId,
+ MsgStream& msg) const;
+
+ const Muon::IMuonIdHelperSvc* m_idHelperSvc{nullptr};
+ const RegionGranularity m_granularity{RegionGranularity::OneRt};
+ const MdtIdHelper& m_idHelper{m_idHelperSvc->mdtIdHelper()};
+ std::vector<MdtFullCalibData> m_dataCache{};
+
+ };
+
+}
+
+CLASS_DEF( MuonCalib::MdtCalibDataContainer , 1228248101 , 1 );
+CONDCONT_DEF( MuonCalib::MdtCalibDataContainer , 1267664791 );
+
+#endif
diff --git a/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibData/MdtCalibData/MdtCorFuncSetCollection.h b/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibData/MdtCalibData/MdtCorFuncSetCollection.h
deleted file mode 100644
index adc41b35a28..00000000000
--- a/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibData/MdtCalibData/MdtCorFuncSetCollection.h
+++ /dev/null
@@ -1,31 +0,0 @@
-/*
- Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
-*/
-
-// MdtCalibDataCollection.h
-// Header file for class MdtCalibDataCollection
-///////////////////////////////////////////////////////////////////
-// (c) ATLAS Detector software
-///////////////////////////////////////////////////////////////////
-// nveldik@nikhef.nl
-///////////////////////////////////////////////////////////////////
-
-#ifndef MUONCALIB_MDTCORFUNCSETCOLLECTION_H
-#define MUONCALIB_MDTCORFUNCSETCOLLECTION_H
-
-#include "AthContainers/DataVector.h"
-#include "AthenaKernel/CLASS_DEF.h"
-#include "MdtCalibData/MdtCorFuncSet.h"
-
-/**
-This typedef representing:
-- a collection of MdtCorFuncSet objects.
-It is a DataVector. It can be saved to storegate.
-*/
-typedef DataVector<MuonCalib::MdtCorFuncSet> MdtCorFuncSetCollection;
-CLASS_DEF(MdtCorFuncSetCollection, 1176811704, 1)
-
-#include "AthenaKernel/CondCont.h"
-CONDCONT_DEF(MdtCorFuncSetCollection, 1338477494);
-
-#endif
diff --git a/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibData/MdtCalibData/MdtFullCalibData.h b/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibData/MdtCalibData/MdtFullCalibData.h
index 3be67494888..65c5b6b02f4 100644
--- a/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibData/MdtCalibData/MdtFullCalibData.h
+++ b/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibData/MdtCalibData/MdtFullCalibData.h
@@ -1,24 +1,29 @@
/*
- Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+ Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
*/
#ifndef MUONCALIB_MDTFULLCALIBDATA_H
#define MUONCALIB_MDTFULLCALIBDATA_H
+#include <MdtCalibData/MdtCorFuncSet.h>
+#include <MdtCalibData/MdtRtRelation.h>
+#include <MdtCalibData/MdtTubeCalibContainer.h>
+#include <GeoModelUtilities/TransientConstSharedPtr.h>
namespace MuonCalib {
- class MdtCorFuncSet;
- class MdtRtRelation;
- class MdtTubeCalibContainer;
-
/** class which holds the full set of calibration constants for a given tube */
struct MdtFullCalibData {
- const MdtCorFuncSet* corrections;
- const MdtRtRelation* rtRelation;
- const MdtTubeCalibContainer* tubeCalib;
- MdtFullCalibData() : corrections(0), rtRelation(0), tubeCalib(0) {}
- MdtFullCalibData(const MdtCorFuncSet* cor, const MdtRtRelation* rt, const MdtTubeCalibContainer* tub) :
- corrections(cor), rtRelation(rt), tubeCalib(tub) {}
+ using CorrectionPtr = GeoModel::TransientConstSharedPtr<MdtCorFuncSet>;
+ using RtRelationPtr = GeoModel::TransientConstSharedPtr<MdtRtRelation>;
+ using TubeContainerPtr = GeoModel::TransientConstSharedPtr<MdtTubeCalibContainer>;
+
+ CorrectionPtr corrections{nullptr};
+ RtRelationPtr rtRelation{nullptr};
+ TubeContainerPtr tubeCalib{nullptr};
+ /// Returns whether one of the constants is set.
+ operator bool () const {
+ return corrections || rtRelation || tubeCalib;
+ }
};
} // namespace MuonCalib
diff --git a/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibData/MdtCalibData/MdtRtRelationCollection.h b/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibData/MdtCalibData/MdtRtRelationCollection.h
deleted file mode 100644
index a8a35787638..00000000000
--- a/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibData/MdtCalibData/MdtRtRelationCollection.h
+++ /dev/null
@@ -1,31 +0,0 @@
-/*
- Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
-*/
-
-// MdtCalibDataCollection.h
-// Header file for class MdtCalibDataCollection
-///////////////////////////////////////////////////////////////////
-// (c) ATLAS Detector software
-///////////////////////////////////////////////////////////////////
-// nveldik@nikhef.nl
-///////////////////////////////////////////////////////////////////
-
-#ifndef MUONCALIB_MDTRTRELATIONCOLLECTION_H
-#define MUONCALIB_MDTRTRELATIONCOLLECTION_H
-
-#include "AthContainers/DataVector.h"
-#include "AthenaKernel/CLASS_DEF.h"
-#include "MdtCalibData/MdtRtRelation.h"
-
-/**
-This typedef representing:
-- a collection of MdtRtRelation objects.
-It is a DataVector. It can be saved to storegate.
-*/
-typedef DataVector<MuonCalib::MdtRtRelation> MdtRtRelationCollection;
-CLASS_DEF(MdtRtRelationCollection, 1270996316, 1)
-
-#include "AthenaKernel/CondCont.h"
-CONDCONT_DEF(MdtRtRelationCollection, 1160701058);
-
-#endif
diff --git a/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibData/MdtCalibData/MdtTubeCalibContainer.h b/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibData/MdtCalibData/MdtTubeCalibContainer.h
index 624dc26912f..d4d2107a4ee 100644
--- a/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibData/MdtCalibData/MdtTubeCalibContainer.h
+++ b/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibData/MdtCalibData/MdtTubeCalibContainer.h
@@ -1,5 +1,5 @@
/*
- Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
+ Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
*/
#ifndef MUONCALIB_MDTTUBECALIBCONTAINER_H
@@ -8,6 +8,7 @@
#include <iostream>
#include <string>
#include <vector>
+#include <MuonIdHelpers/IMuonIdHelperSvc.h>
namespace MuonCalib {
@@ -15,56 +16,57 @@ namespace MuonCalib {
class MdtTubeCalibContainer {
public:
struct SingleTubeCalib {
- float t0; //!< relative t0 in chamber (ns)
- float inversePropSpeed; //!< inverse propagation speed (ns/mm)
- float adcCal; //!< multiplicative correction factor for ADC measurement w.r.t. multilayer average (around 1.0)
- unsigned int
- statusCode; //!< quality flag for the SingleTubeCalib constants: 0 all ok, 1 no hits found, 2 too few hits, 3 bad chi2
- SingleTubeCalib() : t0(0.0), inversePropSpeed(1. / 300.), adcCal(1.0), statusCode(1){};
+ //!< relative t0 in chamber (ns)
+ float t0{0.f};
+ //!< inverse propagation speed (ns/mm)
+ float inversePropSpeed{0.f};
+ //!< multiplicative correction factor for ADC measurement w.r.t. multilayer average (around 1.0)
+ float adcCal{0.f};
+ //!< quality flag for the SingleTubeCalib constants: 0 all ok, 1 no hits found, 2 too few hits, 3 bad chi2
+ unsigned int statusCode{1};
+ SingleTubeCalib() = default;
+
+ operator bool() const { return inversePropSpeed >0.;}
};
/** nMl = number of multilayres, nLayers = number of layers in multilayer (3 or 4); nTubes = number of tubes in one layer */
- MdtTubeCalibContainer(const std::string& region, unsigned int nMl, unsigned int nLayers, unsigned int nTubes) :
- m_regionKey(region), m_nMl(nMl), m_nLayers(nLayers), m_nTubes(nTubes), m_data(nMl * nLayers * nTubes) {}
+ MdtTubeCalibContainer(const Muon::IMuonIdHelperSvc* idHelperSvc,
+ const Identifier& moduleID);
/** return calibration constants of a single tube */
- const SingleTubeCalib* getCalib(unsigned int nMl, unsigned int layerIndex, unsigned int tubeIndex) const {
- unsigned int idx = vectorIndex(nMl, layerIndex, tubeIndex);
- if (idx >= m_data.size()) return 0;
- return &m_data[idx];
- };
- SingleTubeCalib* getCalib(unsigned int nMl, unsigned int layerIndex, unsigned int tubeIndex) {
- unsigned int idx = vectorIndex(nMl, layerIndex, tubeIndex);
- if (idx >= m_data.size()) return 0;
+ const SingleTubeCalib* getCalib(const Identifier& tubeId) const {
+ unsigned int idx = vectorIndex(tubeId);
+ if (idx >= m_data.size()) return nullptr;
return &m_data[idx];
};
/** set the calibration constants of a single tube */
- bool setCalib(unsigned int nMl, unsigned int layerIndex, unsigned int tubeIndex, const SingleTubeCalib& val) {
- unsigned int idx = vectorIndex(nMl, layerIndex, tubeIndex);
- if (idx >= m_data.size()) return false;
- m_data[idx] = val;
- return true;
- }
+ bool setCalib(SingleTubeCalib&& val, const Identifier& tubeId, MsgStream& msg);
/** return container name and dimensions */
- std::string regionKey() const { return m_regionKey; }
+ const Identifier& identify() const { return m_moduleID; }
unsigned int size() const { return m_data.size(); }
unsigned int numMultilayers() const { return m_nMl; };
unsigned int numLayers() const { return m_nLayers; };
unsigned int numTubes() const { return m_nTubes; };
+ const Muon::IMuonIdHelperSvc* idHelperSvc() const;
+
protected:
+ const Identifier m_moduleID{};
+ const Muon::IMuonIdHelperSvc* m_idHelperSvc{nullptr};
+ const MdtIdHelper& m_idHelper{m_idHelperSvc->mdtIdHelper()};
+
/** calculate postion of tube in vector */
- unsigned int vectorIndex(unsigned int nMl, unsigned int layerIndex, unsigned int tubeIndex) const {
- return nMl * m_nLayers * m_nTubes + m_nTubes * layerIndex + tubeIndex;
+ unsigned int vectorIndex(const Identifier& measID) const {
+ return (m_idHelper.multilayer(measID) - 1) * (m_nLayers * m_nTubes) +
+ (m_idHelper.tubeLayer(measID) - 1) * m_nTubes +
+ (m_idHelper.tube(measID) -1);
}
-
- std::string m_regionKey; //!< a string identifying the chamber (StationName_eta_phi)
- unsigned int m_nMl; //!< number of multilayers in chamber
- unsigned int m_nLayers; //!< number of layer
- unsigned int m_nTubes; //!< number of tubes
- std::vector<SingleTubeCalib> m_data;
+ unsigned int m_nMl{0}; //!< number of multilayers in chamber
+ unsigned int m_nLayers{0}; //!< number of layer
+ unsigned int m_nTubes{0}; //!< number of tubes
+ std::vector<SingleTubeCalib> m_data{};
};
} // namespace MuonCalib
diff --git a/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibData/MdtCalibData/MdtTubeCalibContainerCollection.h b/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibData/MdtCalibData/MdtTubeCalibContainerCollection.h
deleted file mode 100644
index eb2075b7493..00000000000
--- a/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibData/MdtCalibData/MdtTubeCalibContainerCollection.h
+++ /dev/null
@@ -1,31 +0,0 @@
-/*
- Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
-*/
-
-// MdtTubeCalibContainerCollection.h
-// Header file for class MdtTubeCalibContainerCollection
-///////////////////////////////////////////////////////////////////
-// (c) ATLAS Detector software
-///////////////////////////////////////////////////////////////////
-// nveldik@nikhef.nl
-///////////////////////////////////////////////////////////////////
-
-#ifndef MUONCALIB_MDTTUBECALIBCONTAINERCOLLECTION_H
-#define MUONCALIB_MDTTUBECALIBCONTAINERCOLLECTION_H
-
-#include "AthContainers/DataVector.h"
-#include "AthenaKernel/CLASS_DEF.h"
-#include "MdtCalibData/MdtTubeCalibContainer.h"
-
-/**
-This typedef representing:
-- a collection of MdtTubeCalibContainer objects.
-It is a DataVector. It can be saved to storegate.
-*/
-typedef DataVector<MuonCalib::MdtTubeCalibContainer> MdtTubeCalibContainerCollection;
-CLASS_DEF(MdtTubeCalibContainerCollection, 1221928754, 1)
-
-#include "AthenaKernel/CondCont.h"
-CONDCONT_DEF(MdtTubeCalibContainerCollection, 1164762092);
-
-#endif
diff --git a/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibData/MdtCalibData/MdtTubeFitContainer.h b/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibData/MdtCalibData/MdtTubeFitContainer.h
index 731fbeda31d..b8d7261f908 100644
--- a/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibData/MdtCalibData/MdtTubeFitContainer.h
+++ b/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibData/MdtCalibData/MdtTubeFitContainer.h
@@ -1,11 +1,12 @@
/*
- Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
+ Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
*/
#ifndef MUONFIT_MDTTUBECALIBCONTAINER_H
#define MUONFIT_MDTTUBECALIBCONTAINER_H
#include <vector>
+#include <array>
#include "MdtCalibData/MdtTubeCalibContainer.h"
@@ -15,85 +16,51 @@ namespace MuonCalib {
class MdtTubeFitContainer : public MdtTubeCalibContainer {
public:
struct SingleTubeFit {
- int statistics; //!< number of hits used for the fit
- int n_hits; //!< number of hits in the tube (differs from statistics in case of grouped fit
- int n_hits_above_adc_cut; //! number of hits above adc cut
- float chi2Tdc; //!< chisquared of the fit to the tdc spectrum
- float chi2TdcEnd; //! for MTT0 chi2 of trailing edge fit
- float par[8];
- float cov[36];
- float adc_par[4];
- float adc_err[4];
- float adc_chi2;
- std::string group_by;
- SingleTubeFit() :
- statistics(0), n_hits(0), n_hits_above_adc_cut(0), chi2Tdc(0.), chi2TdcEnd(0.), adc_chi2(0), group_by("UNKNOWN") {
- for (int i = 0; i < 8; i++) par[i] = 0;
- for (int i = 0; i < 36; i++) cov[i] = 0;
- for (int i = 0; i < 4; i++) adc_par[i] = 0;
- for (int i = 0; i < 4; i++) adc_err[i] = 0;
- };
+ //!< number of hits used for the fit
+ int statistics{0};
+ //!< number of hits in the tube (differs from statistics in case of grouped fit
+ int n_hits{0};
+ //! number of hits above adc cut
+ int n_hits_above_adc_cut{0};
+ //!< chisquared of the fit to the tdc spectrum
+ float chi2Tdc{0.f};
+ //! for MTT0 chi2 of trailing edge fit
+ float chi2TdcEnd{0.f};
+ std::array<float, 8> par{};
+ std::array<float, 36> cov{};
+ std::array<float, 4> adc_par{};
+ std::array<float, 4> adc_err{};
+ float adc_chi2{0.f};
+ std::string group_by{"UNKNOWN"};
+ SingleTubeFit() = default;
};
/** nMl = number of multilayres, nLayers = number of layers in multilayer (3 or 4); nTubes = number of tubes in one layer */
- MdtTubeFitContainer(const std::string& region, unsigned int nMl, unsigned int nLayers, unsigned int nTubes) :
- MdtTubeCalibContainer(region, nMl, nLayers, nTubes),
- m_info(nMl * nLayers * nTubes),
- m_name("MdtTubeFitContainer"),
- m_implementation("implementation"),
- m_group_by("UNKNOWN") {}
-
- /** nMl = number of multilayres, nLayers = number of layers in multilayer (3 or 4); nTubes = number of tubes in one layer */
- MdtTubeFitContainer(const MdtTubeCalibContainer& calibContainer) :
- MdtTubeCalibContainer(calibContainer),
- m_info(calibContainer.size()),
- m_name("MdtTubeFitContainer"),
- m_implementation("implementation") {}
-
+ MdtTubeFitContainer(const Muon::IMuonIdHelperSvc* idHelperSvc,
+ const Identifier& moduleID);
+
/** return calibration constants of a single tube */
- const SingleTubeFit* getFit(unsigned int nMl, unsigned int layerIndex, unsigned int tubeIndex) const {
- unsigned int idx = vectorIndex(nMl, layerIndex, tubeIndex);
- if (idx >= m_info.size()) return 0;
- return &m_info[idx];
- };
- SingleTubeFit* getFit(unsigned int nMl, unsigned int layerIndex, unsigned int tubeIndex) {
- unsigned int idx = vectorIndex(nMl, layerIndex, tubeIndex);
- if (idx >= m_info.size()) return 0;
- return &m_info[idx];
- };
+ const SingleTubeFit* getFit(const Identifier& tubeId) const;
+ SingleTubeFit* getFit(const Identifier& tubeId);
/** set the calibration constants of a single tube */
- bool setFit(unsigned int nMl, unsigned int layerIndex, unsigned int tubeIndex, const SingleTubeFit& val) {
- unsigned int idx = vectorIndex(nMl, layerIndex, tubeIndex);
- if (idx >= m_info.size()) return false;
- m_info[idx] = val;
- return true;
- }
+ bool setFit(SingleTubeFit&& val, const Identifier& tubeId, MsgStream& log);
/** set the name of the implementation used to fill this class */
- void setImplementation(const std::string& impl) { m_implementation = impl; }
-
+ void setImplementation(const std::string& impl);
/** return the name of this class */
- std::string name() const { return m_name; }
-
+ std::string name() const;
/** return the name of the implementation filling this class */
- std::string implementation() const { return m_implementation; }
-
- inline void setGroupBy(const std::string& group_by) {
- for (SingleTubeFit& fit : m_info) {
- fit.group_by = group_by;
- }
- }
- inline const std::string& GroupBy() const {
- if (!m_info.size()) return m_group_by;
- return m_info.begin()->group_by;
- }
+ std::string implementation() const;
+ void setGroupBy(const std::string& group_by);
+
+ std::string GroupBy() const;
private:
- std::vector<SingleTubeFit> m_info;
- std::string m_name;
- std::string m_implementation;
- std::string m_group_by;
+ std::vector<SingleTubeFit> m_info{};
+ std::string m_name{"MdtTubeFitContainer"};
+ std::string m_implementation{"implementation"};
+ std::string m_group_by {"UNKNOWN"};
};
} // namespace MuonCalib
diff --git a/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibData/MdtCalibData/MdtTubeFullInfoContainer.h b/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibData/MdtCalibData/MdtTubeFullInfoContainer.h
index 1d05d6d4502..6340dad6013 100644
--- a/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibData/MdtCalibData/MdtTubeFullInfoContainer.h
+++ b/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibData/MdtCalibData/MdtTubeFullInfoContainer.h
@@ -12,64 +12,43 @@
namespace MuonCalib {
/** Holds single-tube full calibration information of one chamber */
- class MdtTubeFullInfoContainer : public MdtTubeCalibContainer {
+ class MdtTubeFullInfoContainer: public MdtTubeCalibContainer {
public:
struct SingleTubeFullInfo {
- int statistics; //!< number of hits
- float chi2Tdc; //!< chisquared of the fit to the tdc spectrum
- float t0Err; //!< error on t0 from the fit to the tdc spectrum
- float tMax; //!< tmax from the fit to the tdc spectrum
- float tMaxErr; //!< error on tmax from the fit to the tdc spectrum
- float noise; //!< noise level from the fit to the tdc spectrum
- float noiseErr; //!< error on noise from the fit to the tdc spectrum
- float slope; //!< slope of the tdc spectrum near t0
- float slopeErr; //!< error on the slope of the tdc spectrum near t0
- SingleTubeFullInfo() :
- statistics(0), chi2Tdc(0.), t0Err(0.), tMax(0.), tMaxErr(0.), noise(0.), noiseErr(0.), slope(0.), slopeErr(0.){};
+ int statistics{0}; //!< number of hits
+ float chi2Tdc{0.f}; //!< chisquared of the fit to the tdc spectrum
+ float t0Err{0.f}; //!< error on t0 from the fit to the tdc spectrum
+ float tMax{0.f}; //!< tmax from the fit to the tdc spectrum
+ float tMaxErr{0.f}; //!< error on tmax from the fit to the tdc spectrum
+ float noise{0.f}; //!< noise level from the fit to the tdc spectrum
+ float noiseErr{0.f}; //!< error on noise from the fit to the tdc spectrum
+ float slope{0.f}; //!< slope of the tdc spectrum near t0
+ float slopeErr{0.f}; //!< error on the slope of the tdc spectrum near t0
+ SingleTubeFullInfo() = default;
};
-
- /** nMl = number of multilayres, nLayers = number of layers in multilayer (3 or 4); nTubes = number of tubes in one layer */
- MdtTubeFullInfoContainer(const std::string& region, unsigned int nMl, unsigned int nLayers, unsigned int nTubes) :
- MdtTubeCalibContainer(region, nMl, nLayers, nTubes),
- m_info(nMl * nLayers * nTubes),
- m_name("MdtTubeFullInfoContainer"),
- m_implementation("implementation") {}
-
/** nMl = number of multilayres, nLayers = number of layers in multilayer (3 or 4); nTubes = number of tubes in one layer */
- MdtTubeFullInfoContainer(const MdtTubeCalibContainer& calibContainer) :
- MdtTubeCalibContainer(calibContainer),
- m_info(calibContainer.size()),
- m_name("MdtTubeFullInfoContainer"),
- m_implementation("implementation") {}
+ MdtTubeFullInfoContainer(const Muon::IMuonIdHelperSvc* idHelperSvc,
+ const Identifier& moduleID);
/** return calibration constants of a single tube */
- const SingleTubeFullInfo* getFullInfo(unsigned int nMl, unsigned int layerIndex, unsigned int tubeIndex) const {
- unsigned int idx = vectorIndex(nMl, layerIndex, tubeIndex);
- if (idx >= m_info.size()) return 0;
- return &m_info[idx];
- };
+ const SingleTubeFullInfo* getFullInfo(const Identifier& tubeId) const;
/** set the calibration constants of a single tube */
- bool setFullInfo(unsigned int nMl, unsigned int layerIndex, unsigned int tubeIndex, const SingleTubeFullInfo& val) {
- unsigned int idx = vectorIndex(nMl, layerIndex, tubeIndex);
- if (idx >= m_info.size()) return false;
- m_info[idx] = val;
- return true;
- }
+ bool setFullInfo(const Identifier& tubeId, SingleTubeFullInfo&& val);
/** set the name of the implementation used to fill this class */
- void setImplementation(const std::string& impl) { m_implementation = impl; }
+ void setImplementation(const std::string& impl);
/** return the name of this class */
- std::string name() const { return m_name; }
+ std::string name() const;
/** return the name of the implementation filling this class */
- std::string implementation() const { return m_implementation; }
-
+ std::string implementation() const;
private:
std::vector<SingleTubeFullInfo> m_info;
- std::string m_name;
- std::string m_implementation;
+ std::string m_name{"MdtTubeFullInfoContainer"};
+ std::string m_implementation{"implementation"};
+
};
} // namespace MuonCalib
diff --git a/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibData/MdtCalibData/RtScaleFunction.h b/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibData/MdtCalibData/RtScaleFunction.h
index b7523870570..53f24eba414 100644
--- a/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibData/MdtCalibData/RtScaleFunction.h
+++ b/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibData/MdtCalibData/RtScaleFunction.h
@@ -1,5 +1,5 @@
/*
- Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+ Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
*/
#ifndef MuonCalib_RtScaleFunction_h
@@ -9,9 +9,9 @@ namespace MuonCalib {
class IRtRelation;
- float RtScalePolynomial(const float &r);
+ float RtScalePolynomial(const float r);
- float RtScaleFunction(const float &t, const bool ml2, const IRtRelation &rtrelation);
+ float RtScaleFunction(const float t, const bool ml2, const IRtRelation &rtrelation);
} // namespace MuonCalib
diff --git a/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibData/src/MdtCalibDataContainer.cxx b/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibData/src/MdtCalibDataContainer.cxx
new file mode 100644
index 00000000000..b0cd215b9fe
--- /dev/null
+++ b/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibData/src/MdtCalibDataContainer.cxx
@@ -0,0 +1,114 @@
+/*
+ Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
+*/
+
+#include <MdtCalibData/MdtCalibDataContainer.h>
+namespace MuonCalib{
+
+MdtCalibDataContainer::MdtCalibDataContainer(const Muon::IMuonIdHelperSvc* idHelperSvc,
+ const RegionGranularity granularity):
+ m_idHelperSvc{idHelperSvc},
+ m_granularity{granularity} {
+}
+MdtCalibDataContainer::RegionGranularity MdtCalibDataContainer::granularity() const { return m_granularity; }
+inline std::optional<unsigned int> MdtCalibDataContainer::containerIndex(const Identifier& measId, MsgStream& msg) const {
+ IdentifierHash hash{0};
+
+ if (m_granularity == RegionGranularity::OnePerMultiLayer &&
+ (m_idHelper.get_detectorElement_hash(measId, hash) ||
+ m_idHelper.detectorElement_hash_max() < static_cast<unsigned int>(hash))) {
+ msg<<MSG::ERROR <<__FILE__<<":"<<__LINE__<<" Failed to look up a proper detector element hash for "
+ <<m_idHelperSvc->toString(measId)<<endmsg;
+ return std::nullopt;
+ } else if (m_granularity == RegionGranularity::OnePerChamber &&
+ (m_idHelper.get_module_hash(measId, hash) ||
+ m_idHelper.module_hash_max() < static_cast<unsigned int>(hash))) {
+ msg<<MSG::ERROR <<__FILE__<<":"<<__LINE__<<" Failed to look up a proper detector element hash for "
+ <<m_idHelperSvc->toString(measId)<<endmsg;
+ return std::nullopt;
+ }
+ return std::make_optional<unsigned int>(static_cast<unsigned int>(hash));
+}
+
+bool MdtCalibDataContainer::hasDataForChannel(const Identifier& measId, MsgStream& msg) const {
+ std::optional<unsigned int > index = containerIndex(measId, msg);
+ return !(!index || (*index) >= m_dataCache.size() || !m_dataCache[*index]);
+}
+
+const MdtFullCalibData* MdtCalibDataContainer::getCalibData(const Identifier& measId, MsgStream& msg) const {
+ std::optional<unsigned int> index = containerIndex(measId, msg);
+ if (!index) return nullptr;
+ if ((*index ) < m_dataCache.size()) {
+ const MdtFullCalibData& data = m_dataCache[*index];
+ if (data) {return &data;}
+ }
+ msg<<MSG::WARNING<<__FILE__<<":"<<__LINE__<<" No Mdt calibration data is stored for "
+ <<m_idHelperSvc->toString(measId)<<endmsg;
+ return nullptr;
+}
+bool MdtCalibDataContainer::storeData(const Identifier& mlID, CorrectionPtr corrFuncSet, MsgStream& msg) {
+ /// Check for a valid index
+ std::optional<unsigned int> index = containerIndex(mlID, msg);
+ if (!index) return false;
+ /// Resize the container if neccessary
+ if (m_dataCache.size() <= (*index)) m_dataCache.resize(*index + 1);
+ MdtFullCalibData& cache = m_dataCache[*index];
+ if (cache.corrections) {
+ msg << MSG::ERROR<<__FILE__<<":"<<__LINE__<<" There already exist a rt relation object for multilayer "
+ <<m_idHelperSvc->toString(mlID) << endmsg;
+ return false;
+ }
+ cache.corrections = corrFuncSet;
+
+ if (msg.level() <= MSG::DEBUG) {
+ msg << MSG::DEBUG<<__FILE__<<":"<<__LINE__<<" Added successfully the rt corrections for "
+ << m_idHelperSvc->toString(mlID)<<endmsg;
+ }
+ return true;
+}
+bool MdtCalibDataContainer::storeData(const Identifier& mlID, RtRelationPtr rtRelation, MsgStream& msg) {
+ /// Check for a valid index
+ std::optional<unsigned int> index = containerIndex(mlID, msg);
+ if (!index) return false;
+ /// Resize the container if neccessary
+ if (m_dataCache.size() <= (*index)) m_dataCache.resize(*index + 1);
+ MdtFullCalibData& cache = m_dataCache[*index];
+ if (cache.rtRelation) {
+ msg << MSG::ERROR<<__FILE__<<":"<<__LINE__<<" There already exist a rt relation object for multilayer "
+ <<m_idHelperSvc->toString(mlID) << endmsg;
+ return false;
+ }
+ cache.rtRelation = rtRelation;
+
+ if (msg.level() <= MSG::DEBUG) {
+ msg << MSG::DEBUG<<__FILE__<<":"<<__LINE__<<" Added successfully the rt relations for "
+ << m_idHelperSvc->toString(mlID)<<endmsg;
+ }
+ return true;
+}
+bool MdtCalibDataContainer::storeData(const Identifier& mlID, TubeContainerPtr tubeContainer, MsgStream& msg){
+ /// Check for a valid index
+ std::optional<unsigned int> index = containerIndex(mlID, msg);
+ if (!index) return false;
+ /// Resize the container if neccessary
+ if (m_dataCache.size() <= (*index)) m_dataCache.resize(*index + 1);
+ MdtFullCalibData& cache = m_dataCache[*index];
+ if (cache.tubeCalib) {
+ msg << MSG::ERROR<<__FILE__<<":"<<__LINE__<<" There already exist a tube calibration container for multilayer "
+ <<m_idHelperSvc->toString(mlID) << endmsg;
+ return false;
+ }
+ if (msg.level() <= MSG::DEBUG) {
+ msg << MSG::DEBUG<<__FILE__<<":"<<__LINE__<<" Added successfully the tube calibrations for "
+ << m_idHelperSvc->toString(mlID)<<endmsg;
+ }
+ cache.tubeCalib = tubeContainer;
+ if (m_granularity == RegionGranularity::OneRt ||
+ m_idHelper.multilayer(mlID) == 2 ||
+ m_idHelper.numberOfMultilayers(mlID) == 1) return true;
+ return storeData(m_idHelper.multilayerID(mlID, 2), tubeContainer, msg);
+}
+
+
+
+}
\ No newline at end of file
diff --git a/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibData/src/MdtTubeCalibContainer.cxx b/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibData/src/MdtTubeCalibContainer.cxx
new file mode 100644
index 00000000000..08cc784ed70
--- /dev/null
+++ b/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibData/src/MdtTubeCalibContainer.cxx
@@ -0,0 +1,53 @@
+/*
+ Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
+*/
+#include <MdtCalibData/MdtTubeCalibContainer.h>
+namespace MuonCalib {
+ MdtTubeCalibContainer::MdtTubeCalibContainer(const Muon::IMuonIdHelperSvc* idHelperSvc,
+ const Identifier& moduleID):
+ m_moduleID{idHelperSvc->chamberId(moduleID)},
+ m_idHelperSvc{idHelperSvc}{
+
+ m_nMl = m_idHelper.numberOfMultilayers(moduleID);
+ const Identifier secondMl = m_idHelper.multilayerID(m_moduleID, m_nMl);
+ m_nLayers = std::max(m_idHelper.tubeLayerMax(m_moduleID),
+ m_idHelper.tubeLayerMax(secondMl));
+ m_nTubes = std::max(m_idHelper.tubeMax(m_moduleID),
+ m_idHelper.tubeMax(secondMl));
+ m_data.resize(m_nLayers * m_nTubes * m_nMl);
+}
+bool MdtTubeCalibContainer::setCalib(SingleTubeCalib&& val, const Identifier& tubeId, MsgStream& msg) {
+ /// Make enough space for the calibration constants
+ const unsigned int index = vectorIndex(tubeId);
+ if (m_moduleID != m_idHelperSvc->chamberId(tubeId)) {
+ msg << MSG::ERROR<<__FILE__<<":"<<__LINE__<<" The channel "<<m_idHelperSvc->toString(tubeId)
+ <<" does not correspond to chamber "<<m_idHelperSvc->chamberNameString(tubeId) <<endmsg;
+ return false;
+ }
+ if (!val) {
+ msg << MSG::ERROR<<__FILE__<<":" <<__LINE__<<" No data is parsed for "
+ << m_idHelperSvc->toString(tubeId)<<endmsg;
+ return false;
+ }
+ if (index >= m_data.size()) {
+ msg << MSG::WARNING<<__FILE__<<":"<<__LINE__<<" The channel "<<m_idHelperSvc->toString(tubeId)
+ <<"does not seem to match the anticipated chamber sizes of "
+ <<m_idHelperSvc->chamberNameString(m_moduleID)<<endmsg;
+ m_data.resize(index +1);
+ }
+ SingleTubeCalib& store = m_data[index];
+ if (store) {
+ msg << MSG::ERROR<< __FILE__ << __LINE__<< " Data has already been stored for channel "
+ << m_idHelperSvc->toString(tubeId) << endmsg;
+ return false;
+ }
+ store = std::move(val);
+ if (msg.level() <= MSG::DEBUG) {
+ msg << MSG::DEBUG<<" Succesfully stored calibration data for channel "<<m_idHelperSvc->toString(tubeId) << endmsg;
+ }
+ return true;
+}
+const Muon::IMuonIdHelperSvc* MdtTubeCalibContainer::idHelperSvc() const {
+ return m_idHelperSvc;
+}
+}
\ No newline at end of file
diff --git a/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibData/src/MdtTubeFitContainer.cxx b/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibData/src/MdtTubeFitContainer.cxx
new file mode 100644
index 00000000000..6875d3fdf9e
--- /dev/null
+++ b/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibData/src/MdtTubeFitContainer.cxx
@@ -0,0 +1,59 @@
+/*
+ Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
+*/
+#include <MdtCalibData/MdtTubeFitContainer.h>
+
+namespace MuonCalib{
+using SingleTubeFit = MdtTubeFitContainer::SingleTubeFit;
+MdtTubeFitContainer::MdtTubeFitContainer(const Muon::IMuonIdHelperSvc* idHelperSvc,
+ const Identifier& moduleID):
+ MdtTubeCalibContainer(idHelperSvc, moduleID) {
+ m_info.resize(size());
+}
+
+void MdtTubeFitContainer::setImplementation(const std::string& impl) {
+ m_implementation = impl;
+}
+
+std::string MdtTubeFitContainer::name() const {
+ return m_name;
+}
+
+std::string MdtTubeFitContainer::implementation() const {
+ return m_implementation;
+}
+
+bool MdtTubeFitContainer::setFit(SingleTubeFit&& val, const Identifier& tubeId, MsgStream& log) {
+ unsigned int idx = vectorIndex(tubeId);
+ if (idx >= m_info.size()) {
+ log<<MSG::WARNING<<__FILE__<<":"<<__LINE__<<" Index "<<idx
+ <<" exceeds range "<<m_info.size()<<endmsg;
+ return false;
+ }
+ m_info[idx] = std::move(val);
+ return true;
+}
+
+void MdtTubeFitContainer::setGroupBy(const std::string& group_by) {
+ for (SingleTubeFit& fit : m_info) {
+ fit.group_by = group_by;
+ }
+}
+std::string MdtTubeFitContainer::GroupBy() const {
+ if (!m_info.size()) return m_group_by;
+ return m_info.begin()->group_by;
+}
+
+const SingleTubeFit* MdtTubeFitContainer::getFit(const Identifier& tubeId) const {
+ unsigned int idx = vectorIndex(tubeId);
+ if (idx >= m_info.size()) return nullptr;
+ return &m_info[idx];
+}
+
+SingleTubeFit* MdtTubeFitContainer::getFit(const Identifier& tubeId) {
+ unsigned int idx = vectorIndex(tubeId);
+ if (idx >= m_info.size()) return nullptr;
+ return &m_info[idx];
+}
+
+}
\ No newline at end of file
diff --git a/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibData/src/MdtTubeFullInfoContainer.cxx b/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibData/src/MdtTubeFullInfoContainer.cxx
new file mode 100644
index 00000000000..bc4b2824066
--- /dev/null
+++ b/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibData/src/MdtTubeFullInfoContainer.cxx
@@ -0,0 +1,36 @@
+/*
+ Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
+*/
+#include "MdtCalibData/MdtTubeFullInfoContainer.h"
+
+namespace MuonCalib {
+using SingleTubeFullInfo = MdtTubeFullInfoContainer::SingleTubeFullInfo;
+MdtTubeFullInfoContainer::MdtTubeFullInfoContainer(const Muon::IMuonIdHelperSvc* idHelperSvc,
+ const Identifier& moduleID):
+ MdtTubeCalibContainer(idHelperSvc, moduleID) {
+ m_info.resize(size());
+}
+
+bool MdtTubeFullInfoContainer::setFullInfo(const Identifier& tubeId, SingleTubeFullInfo&& val) {
+ unsigned int idx = vectorIndex(tubeId);
+ if (idx >= m_info.size()) return false;
+ m_info[idx] = std::move(val);
+ return true;
+}
+void MdtTubeFullInfoContainer::setImplementation(const std::string& impl) {
+ m_implementation = impl;
+}
+std::string MdtTubeFullInfoContainer::name() const {
+ return m_name;
+}
+std::string MdtTubeFullInfoContainer::implementation() const {
+ return m_implementation;
+}
+const SingleTubeFullInfo* MdtTubeFullInfoContainer::getFullInfo(const Identifier& tubeId) const {
+ unsigned int idx = vectorIndex(tubeId);
+ if (idx >= m_info.size()) return nullptr;
+ return &m_info[idx];
+}
+
+
+} // namespace MuonCalib
diff --git a/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibData/src/RtScaleFunction.cxx b/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibData/src/RtScaleFunction.cxx
index 2300f0be08e..5724c30a25b 100644
--- a/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibData/src/RtScaleFunction.cxx
+++ b/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibData/src/RtScaleFunction.cxx
@@ -1,23 +1,23 @@
/*
- Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+ Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
*/
#include "MdtCalibData/RtScaleFunction.h"
#include "MdtCalibData/IRtRelation.h"
-
+#include <array>
namespace MuonCalib {
- static const double RtScaleFunction_p[] = {-0.00102327, 0.00582117, -0.00676815, 0.00167504, -8.67371e-05, 1.66509e-06};
+ static constexpr std::array<double, 6> RtScaleFunction_p{-0.00102327, 0.00582117, -0.00676815, 0.00167504, -8.67371e-05, 1.66509e-06};
- float RtScalePolynomial(const float &r) {
+ float RtScalePolynomial(const float r) {
// calculate polynomial
float p = 0;
for (int i = 5; i >= 0; i--) { p = RtScaleFunction_p[i] + r * p; }
return p;
}
- float RtScaleFunction(const float &t, const bool ml2, const IRtRelation &rt) {
+ float RtScaleFunction(const float t, const bool ml2, const IRtRelation &rt) {
if (t < rt.tLower() || !rt.HasTmaxDiff()) return 0.0;
// apply linear scale and calculate r as input to the polinomial
float rt_length = rt.tUpper() - rt.tLower();
diff --git a/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibInterfaces/CMakeLists.txt b/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibInterfaces/CMakeLists.txt
index a0c83811145..b78190bef9c 100644
--- a/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibInterfaces/CMakeLists.txt
+++ b/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibInterfaces/CMakeLists.txt
@@ -8,5 +8,7 @@ atlas_subdir( MdtCalibInterfaces )
atlas_add_library( MdtCalibInterfacesLib
src/*.cxx
PUBLIC_HEADERS MdtCalibInterfaces
- LINK_LIBRARIES AthenaKernel GaudiKernel )
+ LINK_LIBRARIES AthenaKernel GaudiKernel GeoPrimitives
+ MuonDigitContainer MuonReadoutGeometry MuonPrepRawData MuonReadoutGeometryR4
+ )
diff --git a/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibInterfaces/MdtCalibInterfaces/IMdtCalibrationTool.h b/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibInterfaces/MdtCalibInterfaces/IMdtCalibrationTool.h
new file mode 100644
index 00000000000..2a9ef14605f
--- /dev/null
+++ b/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibInterfaces/MdtCalibInterfaces/IMdtCalibrationTool.h
@@ -0,0 +1,107 @@
+/*
+ Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef MDTCALIBSVC_IMDTCALIBRATIONTOOL_H
+#define MDTCALIBSVC_IMDTCALIBRATIONTOOL_H
+
+#include <GaudiKernel/IAlgTool.h>
+
+#include <MdtCalibInterfaces/MdtCalibInput.h>
+#include <MdtCalibInterfaces/MdtCalibOutput.h>
+#include <MdtCalibInterfaces/MdtCalibTwinOutput.h>
+
+
+/**
+ @class IMdtCalibrationTool
+ the Mdt Calib Service provides, on request, the drift radius and its
+ error, computed applying the proper calibration, for any hit in Mdt chambers
+ @author Martin Woudstra, Niels van Eldik
+*/
+
+class IMdtCalibrationTool : virtual public IAlgTool {
+public:
+
+ enum timeWindowMode {
+ UserDefined = 0, /// User can configure the window
+ Default = 1, /// 1000, 2000
+ CollisionG4 = 2, /// 20, 30
+ CollisionData = 3, /// 10, 30
+ CollisionFitT0 = 4, /// 50, 100
+ };
+
+ /** destructor */
+ virtual ~IMdtCalibrationTool() = default;
+
+ /** implements IInterface */
+ DeclareInterfaceID(IMdtCalibrationTool, 1, 0);
+
+ /** Convert the raw MDT time (+charge) into a drift radius + error.
+ It returns whether the conversion was successful.
+
+ @param[in,out] hit Hit must have pointer set to the MdtDigit,
+ as well as the global hit position (including the position along the tube!)
+ @param[in] signedTracklength the track length from the 'triggerpoint' to the hit.
+ It is used for the time-of-flight correction.
+ This triggerpoint is the I.P. for ATLAS p-p collisions,
+ typically scintillators in test-beam and cosmic teststands,
+ and not clear yet what is it is for cosmics in ATLAS.
+ The sign is for determining the sign of the time-of-flight correction.
+ If a muon first passes the triggerpoint, and then the MDT tube, the sign
+ should be positive (the case for ATLAS p-p and H8 test-beam).
+ If a muon first passes the MDT tube, and then de triggerpoint, the sign
+ should be negative (typically the case for cosmic-ray teststands).
+ @param[in] triggerTime the time of the 'triggerpoint' in ns. This is the time (measured with
+ the same clock as the MDT TDC's) when the muon passed a known point in
+ space: the 'triggerpoint'.
+ For ATLAS this is 0.0 since the TDC's are synchonised w.r.t. the bunch-crossings.
+ For H8 test-beam it is the trigger time, which is time when the muon passed
+ the trigger scintillators. For cosmic-ray teststands it is usually also the
+ time when the muon passed the trigger scintillators.
+ For cosmics in ATLAS it is not clear yet.
+ @param[in] resolFromRtrack indicates the method to provide the resolution as a function
+ of the distance of the reconstructed track from the anode wire instead of the drift
+ radius
+ */
+ virtual MdtCalibOutput calibrate(const EventContext& ctx,
+ const MdtCalibInput& hit,
+ bool resolFromRtrack=false) const = 0;
+
+ /** Convert the raw MDT times of two twin hits into a Twin position (coordinate along tube)
+ It returns whether the conversion was successful. */
+ virtual MdtCalibTwinOutput calibrateTwinTubes(const EventContext& ctx,
+ const MdtCalibInput& primHit,
+ const MdtCalibInput& twinHit) const = 0;
+
+ virtual double getResolutionFromRt(const EventContext& ctx,
+ const Identifier& module,
+ const double time) const = 0;
+ struct ToolSettings {
+ enum class Property {
+ TofCorrection = 0,
+ PropCorrection,
+ TempCorrection,
+ MagFieldCorrection,
+ WireSagTimeCorrection,
+ SlewCorrection,
+ BackgroundCorrection,
+ NumSettings
+ };
+
+ void setBit(const Property prop, const bool value){
+ m_mask.set(static_cast<unsigned int>(prop), value);
+ }
+ bool isActive(const Property prop) const {
+ return m_mask.test(static_cast<unsigned int>(prop));
+ }
+ timeWindowMode window{timeWindowMode::UserDefined};
+ private:
+ using bitmask = std::bitset<static_cast<unsigned>(Property::NumSettings)>;
+ bitmask m_mask{0};
+
+ };
+ virtual ToolSettings getSettings() const = 0;
+
+};
+
+#endif
\ No newline at end of file
diff --git a/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibInterfaces/MdtCalibInterfaces/IShiftMapTools.h b/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibInterfaces/MdtCalibInterfaces/IShiftMapTools.h
index b1833aaa4dd..2b25a2ad708 100644
--- a/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibInterfaces/MdtCalibInterfaces/IShiftMapTools.h
+++ b/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibInterfaces/MdtCalibInterfaces/IShiftMapTools.h
@@ -1,5 +1,5 @@
/*
- Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
+ Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
*/
#ifndef ISHIFTMAPTOOLS_H
diff --git a/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibInterfaces/MdtCalibInterfaces/MdtCalibInput.h b/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibInterfaces/MdtCalibInterfaces/MdtCalibInput.h
new file mode 100644
index 00000000000..de5bcd24b89
--- /dev/null
+++ b/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibInterfaces/MdtCalibInterfaces/MdtCalibInput.h
@@ -0,0 +1,145 @@
+/*
+ Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
+*/
+#ifndef MDTCALIBINTEFACES_MDTCALIBINPUT_H
+#define MDTCALIBINTEFACES_MDTCALIBINPUT_H
+
+#include "GeoPrimitives/GeoPrimitives.h"
+///
+
+#include <MuonReadoutGeometry/MdtReadoutElement.h>
+#include <MuonReadoutGeometry/MuonDetectorManager.h>
+///
+#include <MuonReadoutGeometryR4/MdtReadoutElement.h>
+#include <MuonReadoutGeometryR4/MuonDetectorManager.h>
+///
+#include <MuonDigitContainer/MdtDigit.h>
+#include <MuonPrepRawData/MdtPrepData.h>
+#include <TrkSurfaces/StraightLineSurface.h>
+
+
+#include <GaudiKernel/PhysicalConstants.h>
+#include <CxxUtils/CachedUniquePtr.h>
+
+#include <iostream>
+
+
+class MdtCalibInput {
+public:
+ /** Constructor taking the MdtDigits --
+ * Typically used inside digitization or RDO -> PRD conversion
+ * Given that digits don't have intrinsically any readout element attached,
+ * the detector manager needs to parsed for fetching the proper element
+ */
+ MdtCalibInput(const MdtDigit& digit,
+ const MuonGM::MuonDetectorManager& detMgr);
+
+ MdtCalibInput(const MdtDigit& digit,
+ const MuonGMR4::MuonDetectorManager& detMgr,
+ const ActsGeometryContext& gctx);
+
+ /** Constructor taking the MdtPrepdata */
+ MdtCalibInput(const Muon::MdtPrepData& prd);
+ /** Constructor taking the */
+ MdtCalibInput(const Identifier& id,
+ const int adc,
+ const int tdc,
+ const Amg::Vector3D& globalPos);
+
+ /// Returns the Identifier of the hit
+ const Identifier& identify() const;
+ /// Returns the tdc counts of the hit
+ int tdc() const;
+ /// Returns the amount of accumulated charge
+ int adc() const;
+ /// Returns whether the constructing digit has been masked
+ bool isMasked() const;
+ /// Returns the legacy readout element
+ const MuonGM::MdtReadoutElement* legacyDescriptor() const;
+ /// Returns the R4 readout element
+ const MuonGMR4::MdtReadoutElement* decriptor() const;
+
+ /// Returns the global position of the hit
+ const Amg::Vector3D& globalPos() const;
+ /// Returns the point of closest approach to the wire
+ const Amg::Vector3D& closestApproach() const;
+ /// Sets the closest approach
+ void setClosestApproach(const Amg::Vector3D& approach);
+
+ /// Returns the track direction (Can be zero)
+ const Amg::Vector3D& trackDirection() const;
+ /// Sets the track direction if it's given from an external seed
+ void setTrackDirection(const Amg::Vector3D& trackDir);
+
+
+ /// Returns the time of flight
+ double timeOfFlight() const;
+ /// Sets the time of flight (Usually globPos.mag() * inverseSpeed of light)
+ void setTimeOfFlight(const double toF);
+
+ /// Returns the trigger offset time
+ double triggerTime() const;
+ /// Sets the trigger offset time
+ void setTriggerTime(const double trigTime);
+ /// Returns the distance to track (signed)
+ double distanceToTrack() const;
+ enum BFieldComp{
+ alongWire = 0,
+ alongTrack = 1,
+ };
+ /// Splits the B-field into the components that point along the transverse
+ /// track direction & along the tube wire
+ Amg::Vector2D projectMagneticField(const Amg::Vector3D& fieldInGlob) const;
+ /// Calculates the distance that the signal has to travel along the wire
+ double signalPropagationDistance() const;
+ /// Returns the assocaited ideal surface (Throw exception if no legacy RE is available)
+ const Trk::SaggedLineSurface& idealSurface() const;
+
+ /// Returns the surface modeling the wire sagging at the point of
+ /// the closest approach (Throw exceptions if no legacy RE is available)
+ const Trk::StraightLineSurface& saggedSurface() const;
+ /// Releases the sagged line surface (Can be a nullptr)
+ std::unique_ptr<Trk::StraightLineSurface> releaseSurface();
+
+ /// Returns the center of the associated surface
+ const Amg::Vector3D& surfaceCenter() const;
+ /// Returns the center of the sagged line surface
+ const Amg::Vector3D& saggedSurfCenter() const;
+ /// Returns the tube length
+ double tubeLength() const;
+ /// Returns the sign of the readout position in local coordinates
+ double readOutSide() const;
+private:
+
+ Identifier m_id{0};
+ bool m_isMasked{false};
+ int m_adc{0};
+ int m_tdc{0};
+ /// Pointer to the readout elements of the legacy geometry
+ const MuonGM::MdtReadoutElement* m_legRE{nullptr};
+
+ const ActsGeometryContext* m_gctx{nullptr};
+ const MuonGMR4::MdtReadoutElement* m_RE{nullptr};
+ IdentifierHash m_hash{};
+
+ Amg::Transform3D m_globToLoc{Amg::Transform3D::Identity()};
+ Amg::Vector3D m_globPos{Amg::Vector3D::Zero()};
+ Amg::Vector3D m_approach{m_globPos};
+ Amg::Vector3D m_trackDir{Amg::Vector3D::Zero()};
+
+ /// Time of flight
+ static constexpr double s_inverseSpeed{1. / Gaudi::Units::c_light};
+ double m_ToF{m_globPos.mag() * s_inverseSpeed};
+ /// Trigger time
+ double m_trigTime{0.};
+ /// Distance to track (signed)
+ double m_distToTrack{0.};
+
+ CxxUtils::CachedUniquePtrT<Trk::StraightLineSurface> m_saggedSurf{};
+
+};
+
+std::ostream& operator<<(std::ostream& ostr, const MdtCalibInput& input);
+
+
+#endif
diff --git a/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibInterfaces/MdtCalibInterfaces/MdtCalibOutput.h b/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibInterfaces/MdtCalibInterfaces/MdtCalibOutput.h
new file mode 100644
index 00000000000..8c7cb2eca14
--- /dev/null
+++ b/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibInterfaces/MdtCalibInterfaces/MdtCalibOutput.h
@@ -0,0 +1,84 @@
+/*
+ Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
+*/
+#ifndef MDTCALIBINTEFACES_MDTCALIBOUTPUT_H
+#define MDTCALIBINTEFACES_MDTCALIBOUTPUT_H
+
+#include <MuonPrepRawData/MdtDriftCircleStatus.h>
+#include <iostream>
+
+class MdtCalibOutput {
+public:
+ MdtCalibOutput() = default;
+ /// Returns the drift radius of the calibrated object
+ double driftRadius() const;
+ /// Returns the uncertainty on the drift radius
+ double driftRadiusUncert() const;
+ /// Sets the charge drift radius and its associated uncertainty
+ void setDriftRadius(const double radius,
+ const double uncert);
+ /// Returns the drift time inside the tube
+ double driftTime() const;
+ /// Sets the drift time
+ void setDriftTime(const double driftTime);
+
+ /// Returns the point in time where the muon typically enters the chamber
+ double tubeT0() const;
+ /// Sets the tube T0
+ void setTubeT0(const double T0);
+
+ /// Sets the signal propagation time in the tube wire
+ void setPropagationTime(const double T0);
+ /// Returns the signal propagation time
+ double signalPropagationTime() const;
+
+
+ /// Returns the slewing time (Needed time that the accumulated charge
+ /// passes the electronic threshold to trigger the tdc counter)
+ double slewingTime() const;
+ /// Sets the slewing time
+ void setSlewingTime(const double slewTime);
+ /// Returns the time corrections from the signal propgation inside a magnetic field
+ double lorentzTime() const;
+ /// Sets the Lorentz time
+ void setLorentzTime(const double time);
+ /// Returns the time corrections stemming from temperature & pressure corrections
+ double temperatureTime() const;
+ /// Sets the temperature time correction
+ void setTemperatureTime(const double tempTime);
+ /// Sets the mean tube adc
+ void setMeanAdc(const double adc);
+ /// Returns the mean tube adc
+ double meanAdc() const;
+ /// Return the time correction arising from background processes
+ double backgroundTime() const;
+ /// Sets the background time correction
+ void setBackgroundTime(const double bkgTime);
+
+ // Returns the time correction arising from a wire sagging in the tube
+ double saggingTime() const;
+ /// Sets the sagging time
+ void setSaggingTime(const double sagTime);
+
+ using MdtDriftCircleStatus = Muon::MdtDriftCircleStatus;
+ /// Status of the calibration
+ MdtDriftCircleStatus status() const;
+ void setStatus(const MdtDriftCircleStatus stat);
+private:
+ double m_driftR{0.};
+ double m_driftUncert{0.};
+ double m_tubeT0{0.};
+ double m_sigPropTime{0.};
+ double m_driftTime{0.};
+ double m_slewingTime{0.};
+ double m_lorentzTime{0.};
+ double m_tempTime{0.};
+ double m_meanAdc{0.};
+ double m_bkgTime{0.};
+ double m_sagTime{0.};
+ MdtDriftCircleStatus m_status{MdtDriftCircleStatus::MdtStatusUnDefined};
+};
+
+std::ostream& operator<<(std::ostream& ostr, const MdtCalibOutput& calibResult);
+#endif
+
diff --git a/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibInterfaces/MdtCalibInterfaces/MdtCalibTwinOutput.h b/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibInterfaces/MdtCalibInterfaces/MdtCalibTwinOutput.h
new file mode 100644
index 00000000000..0a2b8b1e8b5
--- /dev/null
+++ b/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibInterfaces/MdtCalibInterfaces/MdtCalibTwinOutput.h
@@ -0,0 +1,66 @@
+/*
+ Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
+*/
+#ifndef MDTCALIBINTEFACES_MDTCALIBTWINOUTPUT_H
+#define MDTCALIBINTEFACES_MDTCALIBTWINOUTPUT_H
+
+#include <MdtCalibInterfaces/MdtCalibInput.h>
+#include <MdtCalibInterfaces/MdtCalibOutput.h>
+
+
+class MdtCalibTwinOutput{
+ public:
+ using MdtDriftCircleStatus = MdtCalibOutput::MdtDriftCircleStatus;
+ MdtCalibTwinOutput () = default;
+
+ MdtCalibTwinOutput(const MdtCalibInput& primHit,
+ const MdtCalibInput& twinHit,
+ const MdtCalibOutput& primRes,
+ const MdtCalibOutput& twinRes);
+
+ int primaryAdc() const;
+ int twinAdc() const;
+
+ int primaryTdc() const;
+ int twinTdc() const;
+
+ double primaryDriftR() const;
+ double twinDriftR() const;
+
+ double uncertPrimaryR() const;
+ double uncertTwinR() const;
+
+
+ Identifier primaryID() const;
+ Identifier twinID() const;
+
+
+ void setLocZ(const double locZ, const double locZuncert);
+
+ double locZ() const;
+ double sigmaZ() const;
+
+ MdtDriftCircleStatus primaryStatus() const;
+ MdtDriftCircleStatus twinStatus() const;
+
+ private:
+ Identifier m_primId{};
+ int m_primAdc{0};
+ int m_primTdc{0};
+ double m_primDriftR{0.};
+ double m_primDriftUncert{0.};
+ MdtDriftCircleStatus m_primStatus{MdtDriftCircleStatus::MdtStatusUnDefined};
+
+ Identifier m_twinId{};
+ int m_twinAdc{0};
+ int m_twinTdc{0};
+ double m_twinDriftR{0.};
+ double m_twinDriftUncert{0.};
+ MdtDriftCircleStatus m_twinStatus{MdtDriftCircleStatus::MdtStatusUnDefined};
+
+ double m_locZ{0.};
+ double m_locZuncert{0.};
+};
+
+std::ostream& operator<<(std::ostream& ostr, const MdtCalibTwinOutput& output);
+#endif
\ No newline at end of file
diff --git a/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibInterfaces/src/MdtCalibInput.cxx b/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibInterfaces/src/MdtCalibInput.cxx
new file mode 100644
index 00000000000..231e774df31
--- /dev/null
+++ b/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibInterfaces/src/MdtCalibInput.cxx
@@ -0,0 +1,153 @@
+/*
+ Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
+*/
+#include "MdtCalibInterfaces/MdtCalibInput.h"
+#include "GaudiKernel/PhysicalConstants.h"
+#include "GeoPrimitives/GeoPrimitivesToStringConverter.h"
+
+std::ostream& operator<<(std::ostream& ostr, const MdtCalibInput& input){
+ ostr<<"adc: "<<input.adc()<<", ";
+ ostr<<"tdc: "<<input.tdc()<<", ";
+ ostr<<"is masked: "<<(input.isMasked() ? "yay" : "nay")<<", ";
+ ostr<<"global position: "<<Amg::toString(input.globalPos(), 2)<<", ";
+ ostr<<"closest approach: "<<Amg::toString(input.closestApproach(), 2)<<", ";
+ ostr<<"global direction: "<<Amg::toString(input.trackDirection(), 2)<<", ";
+ ostr<<"prop distance: "<<input.signalPropagationDistance()<<", ";
+
+ ostr<<"ToF: "<<input.timeOfFlight()<<", ";
+ ostr<<"trigger time: "<<input.triggerTime();
+ return ostr;
+}
+
+MdtCalibInput::MdtCalibInput(const MdtDigit& digit,
+ const MuonGM::MuonDetectorManager& detMgr):
+ m_id{digit.identify()},
+ m_isMasked{digit.is_masked()},
+ m_adc{digit.adc()},
+ m_tdc{digit.tdc()},
+ m_legRE{detMgr.getMdtReadoutElement(m_id)},
+ m_globToLoc{m_legRE->globalToLocalTransf(m_id)},
+ m_globPos{m_legRE->center(m_id)} {}
+
+MdtCalibInput::MdtCalibInput(const MdtDigit& digit,
+ const MuonGMR4::MuonDetectorManager& detMgr,
+ const ActsGeometryContext& gctx):
+ m_id{digit.identify()},
+ m_isMasked{digit.is_masked()},
+ m_adc{digit.adc()},
+ m_tdc{digit.tdc()},
+ m_gctx{&gctx},
+ m_RE{detMgr.getMdtReadoutElement(m_id)},
+ m_hash{m_RE->measurementHash(m_id)},
+ m_globToLoc{m_RE->globalToLocalTrans(gctx, m_hash)},
+ m_globPos{m_RE->center(gctx, m_hash)} {}
+
+MdtCalibInput::MdtCalibInput(const Identifier& id, const int adc, const int tdc, const Amg::Vector3D& globPos):
+ m_id{id},
+ m_adc{adc},
+ m_tdc{tdc},
+ m_globPos{globPos} {}
+
+MdtCalibInput::MdtCalibInput(const Muon::MdtPrepData& prd):
+ m_id{prd.identify()},
+ m_adc{prd.adc()},
+ m_tdc{prd.tdc()},
+ m_legRE{prd.detectorElement()},
+ m_globToLoc{m_legRE->globalToLocalTransf(m_id)},
+ m_globPos{prd.globalPosition()} {
+
+}
+
+
+const Identifier& MdtCalibInput::identify() const { return m_id; }
+int MdtCalibInput::tdc() const{ return m_tdc; }
+int MdtCalibInput::adc() const{ return m_adc; }
+const MuonGM::MdtReadoutElement* MdtCalibInput::legacyDescriptor() const { return m_legRE; }
+const MuonGMR4::MdtReadoutElement* MdtCalibInput::decriptor() const { return m_RE; }
+bool MdtCalibInput::isMasked() const { return m_isMasked; }
+const Amg::Vector3D& MdtCalibInput::globalPos() const { return m_globPos; }
+const Amg::Vector3D& MdtCalibInput::closestApproach() const {return m_approach; }
+void MdtCalibInput::setClosestApproach(const Amg::Vector3D& approach) {
+ m_approach = approach;
+ releaseSurface();
+}
+std::unique_ptr<Trk::StraightLineSurface> MdtCalibInput::releaseSurface() {
+ return m_saggedSurf.release();
+}
+const Amg::Vector3D& MdtCalibInput::trackDirection() const { return m_trackDir; }
+void MdtCalibInput::setTrackDirection(const Amg::Vector3D& trackDir) { m_trackDir = trackDir; }
+double MdtCalibInput::timeOfFlight() const { return m_ToF; }
+void MdtCalibInput::setTimeOfFlight(const double toF) { m_ToF = toF; }
+
+double MdtCalibInput::triggerTime() const { return m_trigTime; }
+void MdtCalibInput::setTriggerTime(const double trigTime) { m_trigTime = trigTime; }
+
+const Amg::Vector3D& MdtCalibInput::surfaceCenter() const {
+ return m_legRE->surface(identify()).center();
+}
+const Amg::Vector3D& MdtCalibInput::saggedSurfCenter() const { return saggedSurface().center();}
+
+Amg::Vector2D MdtCalibInput::projectMagneticField(const Amg::Vector3D& fieldInGlob) const {
+ /// Rotate the B-field into the rest frame of the tube (Z-axis along the wire)
+ const Amg::Vector3D locBField = m_globToLoc.linear() * fieldInGlob;
+ /// In the local coordinate system, the wire points along the z-axis
+ const Amg::Vector3D locTrkDir = m_globToLoc.linear() * trackDirection();
+
+ const double perpendComp = locTrkDir.block<2,1>(0,0).dot(locBField.block<2,1>(0,0))
+ / locTrkDir.perp();
+ const double paralelComp = locBField.z();
+ /// Convert kilo tesla into tesla... Waaait whaat?
+ return 1000. * Amg::Vector2D{paralelComp, perpendComp};
+}
+const Trk::SaggedLineSurface& MdtCalibInput::idealSurface() const {
+ if (!m_legRE) {
+ std::stringstream except{};
+ except<<__FILE__<<":"<<__LINE__<<" idealSurface() can only be called together with the legacy readout geometry";
+ throw std::runtime_error(except.str());
+ }
+ return m_legRE->surface(identify());
+}
+const Trk::StraightLineSurface& MdtCalibInput::saggedSurface() const {
+ if (!m_legRE) {
+ std::stringstream except{};
+ except<<__FILE__<<":"<<__LINE__<<" saggedSurface() can only be called together with the legacy readout geometry";
+ throw std::runtime_error(except.str());
+ }
+ if (!m_saggedSurf) {
+ const Trk::SaggedLineSurface& surf{idealSurface()};
+ const Trk::Surface& baseSurf{surf};
+ std::optional<Amg::Vector2D> locApproach = baseSurf.globalToLocal(closestApproach(),1000.);
+ if (!locApproach) {
+ return surf;
+ }
+ std::unique_ptr<Trk::StraightLineSurface> sagged{surf.correctedSurface(*locApproach)};
+ if (!sagged) {
+ return surf;
+ }
+ return (*m_saggedSurf.set(std::move(sagged)));
+ }
+ return (*m_saggedSurf);
+}
+double MdtCalibInput::signalPropagationDistance() const {
+ double propDist{0.};
+ if (m_legRE) {
+ const double distToRO = m_legRE->distanceFromRO(closestApproach(), identify());
+ propDist = distToRO - m_legRE->RODistanceFromTubeCentre(identify());
+ } else if (m_RE) {
+ return m_RE->distanceToReadout(*m_gctx, identify(), closestApproach());
+ }
+ return propDist;
+}
+double MdtCalibInput::distanceToTrack() const { return m_distToTrack; }
+
+double MdtCalibInput::tubeLength() const {
+ if (m_legRE) return m_legRE->tubeLength(identify());
+ else if (m_RE) return m_RE->tubeLength(m_hash);
+ return 0.;
+ }
+double MdtCalibInput::readOutSide() const {
+ /// By convention the new readout geometry points along the negative z-axis
+ if (m_legRE) return m_legRE->tubeFrame_localROPos(identify()).z() > 0. ? 1. : -1.;
+ else if (m_RE) return -1.;
+ return 0.;
+}
diff --git a/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibInterfaces/src/MdtCalibOutput.cxx b/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibInterfaces/src/MdtCalibOutput.cxx
new file mode 100644
index 00000000000..c423bc2aebd
--- /dev/null
+++ b/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibInterfaces/src/MdtCalibOutput.cxx
@@ -0,0 +1,56 @@
+/*
+ Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
+*/
+#include <MdtCalibInterfaces/MdtCalibOutput.h>
+
+using MdtDriftCircleStatus = MdtCalibOutput::MdtDriftCircleStatus;
+
+std::ostream& operator<<(std::ostream& ostr, const MdtCalibOutput& calibResult){
+ ostr<<"drift radius: "<<calibResult.driftRadius()<<" pm "<<calibResult.driftRadiusUncert()<<", ";
+ ostr<<"drift time: "<<calibResult.driftTime()<<", ";
+ ostr<<"t0 "<<calibResult.tubeT0()<<", ";
+ ostr<<"slewing time: "<<calibResult.slewingTime()<<", ";
+ ostr<<"lorentz time: "<<calibResult.lorentzTime()<<", ";
+ ostr<<"propagation time: "<<calibResult.signalPropagationTime()<<", ";
+ ostr<<"calib status: "<<calibResult.status();
+ return ostr;
+}
+
+double MdtCalibOutput::driftRadius() const { return m_driftR; }
+double MdtCalibOutput::driftRadiusUncert() const { return m_driftUncert; }
+
+void MdtCalibOutput::setDriftRadius(const double radius,
+ const double uncert){
+ m_driftR = radius;
+ m_driftUncert = uncert;
+}
+
+double MdtCalibOutput::driftTime() const { return m_driftTime; }
+void MdtCalibOutput::setDriftTime(const double driftTime) { m_driftTime = driftTime; }
+
+double MdtCalibOutput::slewingTime() const { return m_slewingTime ;}
+void MdtCalibOutput::setSlewingTime(const double slewTime) { m_slewingTime = slewTime; }
+
+double MdtCalibOutput::lorentzTime() const { return m_lorentzTime; }
+void MdtCalibOutput::setLorentzTime(const double time) { m_lorentzTime = time; }
+
+double MdtCalibOutput::temperatureTime() const { return m_tempTime; }
+void MdtCalibOutput::setTemperatureTime(const double tempTime) { m_tempTime = tempTime; }
+
+MdtDriftCircleStatus MdtCalibOutput::status() const { return m_status; }
+void MdtCalibOutput::setStatus(const MdtDriftCircleStatus stat) { m_status = stat; }
+
+double MdtCalibOutput::tubeT0() const { return m_tubeT0; }
+void MdtCalibOutput::setTubeT0(const double T0) { m_tubeT0 = T0; }
+
+void MdtCalibOutput::setPropagationTime(const double propTime) { m_sigPropTime = propTime; }
+double MdtCalibOutput::signalPropagationTime() const { return m_sigPropTime; }
+
+void MdtCalibOutput::setMeanAdc(const double adc) { m_meanAdc = adc ;}
+double MdtCalibOutput::meanAdc() const { return m_meanAdc; }
+
+double MdtCalibOutput::backgroundTime() const{ return m_bkgTime; }
+void MdtCalibOutput::setBackgroundTime(const double bkgTime) { m_bkgTime = bkgTime ;}
+
+double MdtCalibOutput::saggingTime() const{ return m_sagTime; }
+void MdtCalibOutput::setSaggingTime(const double sagTime) { m_sagTime = sagTime; }
diff --git a/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibInterfaces/src/MdtCalibTwinOutput.cxx b/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibInterfaces/src/MdtCalibTwinOutput.cxx
new file mode 100644
index 00000000000..f4b873128eb
--- /dev/null
+++ b/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibInterfaces/src/MdtCalibTwinOutput.cxx
@@ -0,0 +1,55 @@
+/*
+ Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
+*/
+#include <MdtCalibInterfaces/MdtCalibTwinOutput.h>
+
+using MdtDriftCircleStatus = MdtCalibTwinOutput::MdtDriftCircleStatus;
+std::ostream& operator<<(std::ostream& ostr, const MdtCalibTwinOutput& output) {
+ ostr <<"primary tdc: "<<output.primaryTdc()<<",";
+ ostr<<"twin td: "<<output.twinTdc()<<", ";
+ ostr<<"primary adc: "<<output.primaryAdc()<<", ";
+ ostr<<"twin adc: "<<output.twinAdc()<<", ";
+ ostr<<"primary drift R: "<<output.primaryDriftR()<<" pm "<<output.uncertPrimaryR()<<", ";
+ ostr<<"twin drift R: "<<output.twinDriftR()<<" pm "<<output.uncertTwinR()<<", ";
+ ostr<<"local Z: "<<output.locZ()<<" pm "<<output.sigmaZ()<<", ";
+ return ostr;
+}
+MdtCalibTwinOutput::MdtCalibTwinOutput(const MdtCalibInput& primHit,
+ const MdtCalibInput& twinHit,
+ const MdtCalibOutput& primRes,
+ const MdtCalibOutput& twinRes):
+ m_primId{primHit.identify()},
+ m_primAdc{primHit.adc()},
+ m_primTdc{primHit.tdc()},
+ m_primDriftR{primRes.driftRadius()},
+ m_primDriftUncert{primRes.driftRadiusUncert()},
+ m_primStatus{primRes.status()},
+ m_twinId{twinHit.identify()},
+ m_twinAdc{twinHit.adc()},
+ m_twinTdc{twinHit.tdc()},
+ m_twinDriftR{twinRes.driftRadius()},
+ m_twinDriftUncert{twinRes.driftRadiusUncert()},
+ m_twinStatus{twinRes.status()}{}
+
+int MdtCalibTwinOutput::primaryAdc() const{ return m_primAdc; }
+int MdtCalibTwinOutput::primaryTdc() const { return m_primTdc; }
+
+int MdtCalibTwinOutput::twinAdc() const{ return m_twinAdc; }
+int MdtCalibTwinOutput::twinTdc() const { return m_twinTdc; }
+
+Identifier MdtCalibTwinOutput::primaryID() const { return m_primId; }
+Identifier MdtCalibTwinOutput::twinID() const { return m_twinId; }
+
+void MdtCalibTwinOutput::setLocZ(const double locZ, const double locZuncert) {
+ m_locZ = locZ;
+ m_locZuncert = locZuncert;
+}
+
+double MdtCalibTwinOutput::locZ() const { return m_locZ; }
+double MdtCalibTwinOutput::sigmaZ() const { return m_locZuncert; }
+double MdtCalibTwinOutput::primaryDriftR() const { return m_primDriftR; }
+double MdtCalibTwinOutput::twinDriftR() const { return m_twinDriftR;}
+double MdtCalibTwinOutput::uncertPrimaryR() const { return m_primDriftUncert; }
+double MdtCalibTwinOutput::uncertTwinR() const { return m_twinDriftUncert; }
+MdtDriftCircleStatus MdtCalibTwinOutput::primaryStatus() const {return m_primStatus;}
+MdtDriftCircleStatus MdtCalibTwinOutput::twinStatus() const {return m_twinStatus;}
\ No newline at end of file
diff --git a/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibSvc/CMakeLists.txt b/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibSvc/CMakeLists.txt
index 7357b3e14ae..a5eaca1d99a 100644
--- a/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibSvc/CMakeLists.txt
+++ b/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibSvc/CMakeLists.txt
@@ -7,7 +7,11 @@ atlas_subdir( MdtCalibSvc )
atlas_add_library( MdtCalibSvcLib
src/*.cxx
PUBLIC_HEADERS MdtCalibSvc
- LINK_LIBRARIES AthenaBaseComps AthenaKernel MuonReadoutGeometry Identifier GaudiKernel MdtCalibData MuonCalibIdentifier MuonPrepRawData StoreGateLib MuonIdHelpersLib PathResolver MagFieldElements MagFieldConditions MuonCablingData MdtCalibInterfacesLib MuonCalibEvent )
+ LINK_LIBRARIES AthenaBaseComps AthenaKernel MuonReadoutGeometry Identifier
+ GaudiKernel MdtCalibData MuonCalibIdentifier MuonPrepRawData
+ StoreGateLib MuonIdHelpersLib PathResolver MagFieldElements
+ MagFieldConditions MuonCablingData MdtCalibInterfacesLib
+ MuonCalibEvent)
atlas_add_component( MdtCalibSvc
src/components/*.cxx
diff --git a/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibSvc/MdtCalibSvc/MdtCalibrationDbTool.h b/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibSvc/MdtCalibSvc/MdtCalibrationDbTool.h
deleted file mode 100644
index ed763ffc186..00000000000
--- a/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibSvc/MdtCalibSvc/MdtCalibrationDbTool.h
+++ /dev/null
@@ -1,98 +0,0 @@
-/*
- Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
-*/
-
-#ifndef MDTCALIBSVC_MDTCALIBRATIONDBTOOL_H
-#define MDTCALIBSVC_MDTCALIBRATIONDBTOOL_H
-
-#include "AthenaBaseComps/AthAlgTool.h"
-#include "GaudiKernel/ServiceHandle.h"
-
-#include "MdtCalibData/MdtRtRelationCollection.h"
-#include "MdtCalibData/MdtTubeCalibContainerCollection.h"
-#include "MdtCalibData/MdtCorFuncSetCollection.h"
-#include "StoreGate/ReadCondHandleKey.h"
-#include "MuonIdHelpers/IMuonIdHelperSvc.h"
-
-#include <string>
-
-class MdtCalibrationRegionSvc;
-
-namespace MuonCalib{
- class IMdtCalibDBTool;
- struct MdtFullCalibData;
-}
-
-/** handles the retreival of constants from the DB: it uses a Tool
- * derived from MuonCalib::IMdtCalibDBTool to access different types of DB
- * (currently implemented ASCII files and COOL CLOBS)*/
-
-class MdtCalibrationDbTool : public extends<AthAlgTool, IInterface> {
-public:
- /** constructor */
- MdtCalibrationDbTool(const std::string& type, const std::string &name, const IInterface* parent);
-
- /** destructor */
- virtual ~MdtCalibrationDbTool()=default;
- /** IInterface implementation */
- static const InterfaceID &interfaceID() {
- static InterfaceID s_iID("MdtCalibrationDbTool", 1, 0);
- return s_iID;
- }
-
- /** initialization */
- virtual StatusCode initialize();
-
- /** Access to calibration constants per calibration region/chamber */
- MuonCalib::MdtFullCalibData getCalibration( const Identifier &id ) const;
-
- /** Access to RT calibration constants per calibration region/chamber directly using the hashes */
- // MuonCalib::MdtFullCalibData getCalibration( const IdentifierHash &chamberHash, const IdentifierHash &detElHash ) const;
- MuonCalib::MdtFullCalibData getCalibration( const IdentifierHash &chamberHash, const IdentifierHash &mlhash ) const;
-
- /** Access to RT calibration constants per calibration region/chamber */
- const MuonCalib::MdtRtRelation* getRtCalibration( const Identifier &id ) const;
-
- /** Access to calibration constants per calibration region/chamber by hash */
- const MuonCalib::MdtRtRelation* getRtCalibration( const IdentifierHash &detElHash ) const;
-
- /** Access to Tube calibration constants per calibration region/chamber */
- const MuonCalib::MdtTubeCalibContainer* getTubeCalibContainer( const Identifier &id ) const;
-
- /** Access to Tube calibration constants per calibration region/chamber by hash */
- const MuonCalib::MdtTubeCalibContainer* getTubeCalibContainer( const IdentifierHash &chamberHash ) const;
-
- /** Access to corrections to calibration constants per calibration
- * region/chamber */
- const MuonCalib::MdtCorFuncSet* getCorFunctions( const Identifier &id ) const;
-
- /** Access to corrections to calibration constants per calibration
- * region/chamber by hash */
- const MuonCalib::MdtCorFuncSet* getCorFunctions( const IdentifierHash &detElHash ) const;
-
-private:
- /** handle to region service */
- ServiceHandle<MdtCalibrationRegionSvc> m_regionSvc;
- ServiceHandle<Muon::IMuonIdHelperSvc> m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"};
-
- /** create the correction functions */
- void initialize_B_correction(MuonCalib::MdtCorFuncSet *funcSet,
- const MuonCalib::MdtRtRelation *rt);
- void initializeSagCorrection(MuonCalib::MdtCorFuncSet *funcSet);
-
- /** Properties: */
- bool m_create_b_field_function; //<! flag to switch on loading of B field correction
- bool m_createWireSagFunction; //<! flag to switch on loading of wire sag correction
- bool m_createSlewingFunction; //<! flag to switch on loading of slewing correction
-
- bool m_getTubeConstants; //<! flag to switch off loading of tube constants
- bool m_getCorrections; //<! flag to switch off loading of correction function constants
-
- SG::ReadCondHandleKey<MdtRtRelationCollection> m_readKeyRt{this,"MdtRtRelationCollection","MdtRtRelationCollection","MDT RT relations"};
- SG::ReadCondHandleKey<MdtTubeCalibContainerCollection> m_readKeyTube{this,"MdtTubeCalibContainerCollection","MdtTubeCalibContainerCollection","MDT tube calib"};
- SG::ReadCondHandleKey<MdtCorFuncSetCollection> m_readKeyCor{this,"MdtCorFuncSetCollection","MdtCorFuncSetCollection","MDT cor Funcs"};
-
- Gaudi::Property<bool> m_wasConfigured {this,"WasConfigured",false,"This tool is too complicated to rely on defaults. Will fail if not configured."};
-};
-
-#endif // MDTCALIBSVC_MDTCALIBRATIONDBTOOL_H
diff --git a/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibSvc/MdtCalibSvc/MdtCalibrationRegionSvc.h b/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibSvc/MdtCalibSvc/MdtCalibrationRegionSvc.h
deleted file mode 100644
index 7400f0fc19e..00000000000
--- a/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibSvc/MdtCalibSvc/MdtCalibrationRegionSvc.h
+++ /dev/null
@@ -1,98 +0,0 @@
-/*
- Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
-*/
-
-#ifndef MUONCALIB_MDTCALIBRATIONREGIONSVC_H
-#define MUONCALIB_MDTCALIBRATIONREGIONSVC_H
-
-#include "AthenaBaseComps/AthService.h"
-#include "GaudiKernel/IInterface.h"
-
-#include <vector>
-
-// Type of RT/Correction function regions, set in remapRtRegions()
-// MdtCalibDbCoolStrTool uses these regions to load RTs from COOL into m_rtGate (pointer to DetStore)
-// MdtCalibrationDBSvc uses these regions to access the constants in m_rtGate
-enum MdtRegionType { ONERT, ONEPERCHAMBER, ONEPERMULTILAYER };
-
-// For ONERT and ONEPERCHAMBER m_regionHash stores the index of every chamber's RT in m_rtData.
-// In this case m_regionHash should be accessed with the chamber hash from m_mdtIdHelper->get_hash()
-// For ONERT only 1 RT is put in m_rtData so the index in m_regionHash is 0 for all chambers
-// For ONEPERCHAMBER each chamber RT will be put in m_rtData so there will be m_mdtIdHelper->module_hash_max() RTs.
-// For ONEPERMULTILAYER option m_regionHash stores the index of every ML RT.
-// In this case m_regionHash should be accessed with the ML hash from m_mdtIdHelper->get_detectorElement_hash()
-// Initially m_rtData is filled with RTs for each chamber (treating chamber RTs as ML1 RTs).
-// Initially the number of RTs in m_rtData is m_mdtIdHelper->module_hash_max(), the same as for ONEPERCHAMBER
-// If ML2 RTs are read from COOL they are added at the end of m_rtData in MdtCalibrationDBStrTool and
-// the index of the ML2 RT in m_rtData is written into m_regionHash. Hence, addition memory for ML2 RTs
-// is only required if ML2 RTs are loaded into COOL.
-
-class MdtIdHelper;
-
-class MdtCalibrationRegionSvc : public AthService, virtual public IInterface {
-public:
- /** constructor */
- MdtCalibrationRegionSvc(const std::string &name,ISvcLocator *sl);
-
- /** destructor */
- virtual ~MdtCalibrationRegionSvc()=default;
-
- /** IInterface implementation */
- static const InterfaceID &interfaceID() {
- static const InterfaceID s_iID("MdtCalibrationRegionSvc", 1, 0);
- return s_iID;
- }
-
- /** IInterface implementation */
- virtual StatusCode queryInterface(const InterfaceID &riid,void **ppvIF);
-
- /** initialization */
- virtual StatusCode initialize(void);
-
- // Currently 3 types of mappings are defined: "OneRt", "OnePerChamber", and "OnePerMultilayer"
- // and this method can be used to switch between one and the other.
- virtual void remapRtRegions(std::string mapName);
-
- /** get type of regions being used */
- virtual MdtRegionType RegionType() const;
-
- /** number of regions */
- virtual unsigned int numberOfRegions() const;
-
- /** get hash to use for ML2 (works for ML1 too) */
- // mlHash is from m_mdtIdHelper->get_detectorElement_hash( athenaId, mlHash )
- virtual unsigned int getRegionHash(const unsigned int mlHash) const;
-
- /** set hash for ML2 */
- virtual unsigned int setRegionHash(const unsigned int mlHash);
-
-private:
- const MdtIdHelper *m_mdtIdHelper;
- MdtRegionType m_regionType;
- unsigned int m_numberOfRegions;//number of RTs stored in m_rtData
- std::vector<int> m_regionHash; //stores hash to use for ML2 (which is ML1 hash by default)
-};
-
-inline MdtRegionType MdtCalibrationRegionSvc::RegionType() const {
- return m_regionType;
-}
-
-inline unsigned int MdtCalibrationRegionSvc::numberOfRegions() const {
- return m_numberOfRegions;
-}
-
-inline unsigned int MdtCalibrationRegionSvc::getRegionHash(const unsigned int mlHash) const {
- return m_regionHash[mlHash];
-}
-
-// Add a new ML2 region hash.
-// ML2 RT will added to the end of m_rtData in MdtCalibDbCoolStrTool if an ML2 RT is read from COOL
-// Store the index of this RT in m_rtData in m_regionHash[mlHash]
-// Increase the count of RTs in m_rtData
-inline unsigned int MdtCalibrationRegionSvc::setRegionHash(const unsigned int mlHash) {
- m_regionHash[mlHash] = m_numberOfRegions;
- m_numberOfRegions++;
- return m_numberOfRegions;
-}
-
-#endif
diff --git a/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibSvc/MdtCalibSvc/MdtCalibrationSvcInput.h b/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibSvc/MdtCalibSvc/MdtCalibrationSvcInput.h
deleted file mode 100644
index c59abf1e5d1..00000000000
--- a/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibSvc/MdtCalibSvc/MdtCalibrationSvcInput.h
+++ /dev/null
@@ -1,41 +0,0 @@
-/*
- Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
-*/
-
-#ifndef MDTCALIBSVC_MDTCALIBRATIONSVCINPUT_H
-#define MDTCALIBSVC_MDTCALIBRATIONSVCINPUT_H
-
-/*
- *
- * Authors Niels van Eldik & Martin Woudstra
- *
- */
-
-#include "GeoPrimitives/GeoPrimitives.h"
-
-namespace Trk {
- class StraightLineSurface;
-}
-
-/**
- @class MdtCalibrationSvcInput
- This class contains all possible input for the MdtCalibrationSvc.
- Not all fields have to be filled to perform a calibration but if some fields
- are missing one might not get the optimal resolution.
- @author Martin Woudstra, Niels van Eldik
-*/
-class MdtCalibrationSvcInput {
-public:
- MdtCalibrationSvcInput() :
- tof(0.),triggerOffset(0.),pointOfClosestApproach(0),trackDirection(0),
- nominalWireSurface(0),wireSurface(0) {
- }
- double tof;
- double triggerOffset;
- const Amg::Vector3D *pointOfClosestApproach;
- const Amg::Vector3D *trackDirection;
- const Trk::StraightLineSurface *nominalWireSurface;
- const Trk::StraightLineSurface *wireSurface;
-};
-
-#endif
diff --git a/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibSvc/MdtCalibSvc/MdtCalibrationSvcSettings.h b/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibSvc/MdtCalibSvc/MdtCalibrationSvcSettings.h
deleted file mode 100644
index 630f8cd302d..00000000000
--- a/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibSvc/MdtCalibSvc/MdtCalibrationSvcSettings.h
+++ /dev/null
@@ -1,159 +0,0 @@
-/*
- Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
-*/
-
-#ifndef MDTCALIBSVC_MDTCALIBRATIONSVCSETTINGS_H
-#define MDTCALIBSVC_MDTCALIBRATIONSVCSETTINGS_H
-
-/*
- *
- * Authors Niels van Eldik & Martin Woudstra
- *
- */
-
-#include <cmath>
-
-/**
- @class MdtCalibrationSvcSettings
- This class is used to select which type of corrections should be applied by the calibration service.
- @author Martin Woudstra, Niels van Eldik
-*/
-class MdtCalibrationSvcSettings {
-public:
-
- static const int dummyTimeWindow = -1000000;
-
- MdtCalibrationSvcSettings() :
- windowSetting(1),windowLowerBound(dummyTimeWindow),windowUpperBound(dummyTimeWindow),
- doTof(true),doProp(true),doTemp(false),doField(false),
- doWireSag(false),doSlew(false),doBkg(false) {
- }
-
- /** Initialization function.
- This should be called after setting the window upper and lower bounds
- to their desired values. If they are set and the class is not (re-)initialized,
- unexpected behaviour may result.
- If either window is already set (by hand or otherwise),
- it will not be modified, but this->windowSetting will be set to 0 if inconsistencies are found.
- */
- void initialize() {
- // Check if either of the window values are already set,
- // in which case they will not be modified by this function.
- bool setLower = timeWindowSetToValue(windowLowerBound);
- bool setUpper = timeWindowSetToValue(windowUpperBound);
-
- double valueLower = 0.;
- double valueUpper = 0.;
-
- switch (windowSetting) {
- case 0:
- break;
- case 1:
- valueLower = 1000.;
- valueUpper = 2000.;
- break;
- case 2:
- valueLower = 20.;
- valueUpper = 30.;
- break;
- case 3:
- valueLower = 10.;
- valueUpper = 30.;
- break;
- case 4:
- valueLower = 50.;
- valueUpper = 100.;
- break;
- default:
- // Index out of range: do not change any member variables
- // Note the return statement, not break
- return;
- } // End of switch
-
- if (setLower) {
- // Change the lower bound
- windowLowerBound = valueLower;
- } else {
- // Don't touch the lower bound, but check if its value is correct
- if (!timeWindowSetToValue(windowLowerBound, valueLower)) {
- windowSetting = 0;
- }
- }
-
- if (setUpper) {
- // Change the upper bound
- windowUpperBound = valueUpper;
- } else {
- // Don't touch the upper bound, but check if its value is correct
- if (!timeWindowSetToValue(windowUpperBound, valueUpper)) {
- windowSetting = 0;
- }
- }
- }
-
- /** Internal method to check consistency of time window values.
- */
- bool timeWindowSetToValue(double &window, double value = dummyTimeWindow) const {
- return std::abs(window - value) < 1e-3;
- }
-
- /** const access to configuration */
-
- /** returns the integer value of the time window.
- */
- double timeWindowSetting() const {
- return windowSetting;
- }
-
- /** returns the lower bound of the matching window used in the calibration service.
- The number should be positive.
- */
- double timeWindowLowerBound() const {
- return windowLowerBound;
- }
-
- /** returns the upper bound of the matching window used in the calibration service.
- The number should be positive.
- */
- double timeWindowUpperBound() const {
- return windowUpperBound;
- }
-
- /** toggle on/off tof correction */
- bool doTofCorrection() const { return doTof; }
-
- /** toggle on/off propagation correction */
- bool doPropCorrection() const { return doProp; }
-
- /** toggle on/off time corrections, returns the OR of all corrections */
- bool doCorrections() const { return doWireSag || doField || doTemp || doSlew || doBkg; }
-
- /** toggle on/off temperature correction */
- bool doTemperatureCorrection() const { return doTemp; }
-
- /** toggle on/off magnetic fieldcorrection */
- bool doMagneticFieldCorrection() const { return doField; }
-
- /** toggle on/off wire sag correction */
- bool doWireSagCorrection() const { return doWireSag; }
-
- /** toggle on/off slewing correction */
- bool doSlewingCorrection() const { return doSlew; }
-
- /** toggle on/off background correction */
- bool doBackgroundCorrection() const { return doBkg; }
-
- /** data members */
- int windowSetting;
- double windowLowerBound; //!< After setting, make sure to call MdtCalibrationSvcSettings::initialize()!!!
- double windowUpperBound; //!< After setting, make sure to call MdtCalibrationSvcSettings::initialize()!!!
- bool doTof;
- bool doProp;
- bool doTemp;
- bool doField;
- bool doWireSag;
- bool doSlew;
- bool doBkg;
-};
-
-#endif
diff --git a/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibSvc/MdtCalibSvc/MdtCalibrationTool.h b/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibSvc/MdtCalibSvc/MdtCalibrationTool.h
deleted file mode 100644
index 1ee60108648..00000000000
--- a/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibSvc/MdtCalibSvc/MdtCalibrationTool.h
+++ /dev/null
@@ -1,131 +0,0 @@
-/*
- Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
-*/
-
-#ifndef MDTCALIBSVC_MDTCALIBRATIONTOOL_H
-#define MDTCALIBSVC_MDTCALIBRATIONTOOL_H
-
-#include "AthenaBaseComps/AthAlgTool.h"
-#include "GaudiKernel/ServiceHandle.h"
-#include "GaudiKernel/ToolHandle.h"
-
-#include "GaudiKernel/IInterface.h"
-#include "MuonIdHelpers/IMuonIdHelperSvc.h"
-#include "MuonPrepRawData/MdtDriftCircleStatus.h"
-#include "MagFieldConditions/AtlasFieldCacheCondObj.h"
-#include "MdtCalibSvc/MdtCalibrationDbTool.h"
-
-#include <string>
-
-class MdtCalibHit;
-class MdtCalibrationSvcInput;
-class MdtCalibrationSvcSettings;
-
-namespace MuonCalib {
- class MdtRtRelation;
-}
-
-/**
- @class MdtCalibrationTool
- the Mdt Calib Service provides, on request, the drift radius and its
- error, computed applying the proper calibration, for any hit in Mdt chambers
- @author Martin Woudstra, Niels van Eldik
-*/
-
-const static InterfaceID s_iID("MdtCalibrationTool", 1, 0);
-
-class MdtCalibrationTool : public extends<AthAlgTool, IInterface> {
-public:
- /** constructor */
- MdtCalibrationTool(const std::string& type, const std::string &name, const IInterface* parent);
-
- /** destructor */
- virtual ~MdtCalibrationTool();
-
- /** implements IInterface */
- static const InterfaceID &interfaceID() {
- return s_iID;
- }
-
- /** initialization */
- virtual StatusCode initialize();
-
- /** Convert the raw MDT time (+charge) into a drift radius + error.
- It returns whether the conversion was successful.
-
- @param[in,out] hit Hit must have pointer set to the MdtDigit,
- as well as the global hit position (including the position along the tube!)
- @param[in] signedTracklength the track length from the 'triggerpoint' to the hit.
- It is used for the time-of-flight correction.
- This triggerpoint is the I.P. for ATLAS p-p collisions,
- typically scintillators in test-beam and cosmic teststands,
- and not clear yet what is it is for cosmics in ATLAS.
- The sign is for determining the sign of the time-of-flight correction.
- If a muon first passes the triggerpoint, and then the MDT tube, the sign
- should be positive (the case for ATLAS p-p and H8 test-beam).
- If a muon first passes the MDT tube, and then de triggerpoint, the sign
- should be negative (typically the case for cosmic-ray teststands).
- @param[in] triggerTime the time of the 'triggerpoint' in ns. This is the time (measured with
- the same clock as the MDT TDC's) when the muon passed a known point in
- space: the 'triggerpoint'.
- For ATLAS this is 0.0 since the TDC's are synchonised w.r.t. the bunch-crossings.
- For H8 test-beam it is the trigger time, which is time when the muon passed
- the trigger scintillators. For cosmic-ray teststands it is usually also the
- time when the muon passed the trigger scintillators.
- For cosmics in ATLAS it is not clear yet.
- @param[in] resolFromRtrack indicates the method to provide the resolution as a function
- of the distance of the reconstructed track from the anode wire instead of the drift
- radius
- */
- bool driftRadiusFromTime( MdtCalibHit &hit, double signedTrackLength, double triggerTime = 0.0, bool resolFromRtrack=false ) const;
-
- /** Convert the raw MDT time (+charge) into a drift radius + error.
- It returns whether the conversion was successful.
-
- */
- bool driftRadiusFromTime( MdtCalibHit &hit, const MdtCalibrationSvcInput &inputData, const MdtCalibrationSvcSettings &settings, bool resolFromRtrack=false ) const;
-
- /** Convert the raw MDT time (+charge) into a drift radius + error.
- It returns whether the conversion was successful.
-
- */
- bool driftRadiusFromTime( MdtCalibHit &hit, const MdtCalibrationSvcInput &inputData, bool resolFromRtrack=false ) const;
-
- /** TDC bin size. 25/32 ns for all MDT/sMDT */
- double tdcBinSize() const;
-
- /** Convert the raw MDT times of two twin hits into a Twin position (coordinate along tube)
- It returns whether the conversion was successful. */
- bool twinPositionFromTwinHits( MdtCalibHit &hit, MdtCalibHit &twinhit, double signedTrackLength, double twinSignedTrackLength, bool &twinDigitIsPrompt, double triggerTime = 0.0 ) const;
-
- /** Convert the raw MDT times of two twin hits into a Twin position (coordinate along tube)
- It returns whether the conversion was successful. */
- bool twinPositionFromTwinHits( MdtCalibHit &hit, MdtCalibHit &twinhit, const MdtCalibrationSvcInput &inputData, const MdtCalibrationSvcInput &twinInputData, const MdtCalibrationSvcSettings &settings, bool &twinDigitIsPrompt ) const;
-
- /** Return status of drift time: in window, above/below window (with upper/lower bounds described by the settings) or invalid.
- @return @c Muon::MdtDriftCircleStatus saying whether the drift time comes before, during or after the bounds of the drift time spectrum.
- @param[in] driftTime is the drift time of the hit.
- @param[in] rtRelation is used to obtain the upper and lower limits of the r(t) relation.
- @param[in] settings define the extra window around the r(t) relationship bounds that is acceptable.
- */
- Muon::MdtDriftCircleStatus driftTimeStatus( double driftTime, const MuonCalib::MdtRtRelation *rtRelation, const MdtCalibrationSvcSettings &settings ) const;
-
-private:
-
- /// please don't add any data members here!!
- /// they should be added to Imp to keep the class free from data exposed to clients
- class Imp;
- std::unique_ptr<Imp> m_imp;
-
- ToolHandle<MdtCalibrationDbTool> m_dbTool{this,"CalibrationDbTool","MdtCalibrationDbTool"};
-
- // Read handle for conditions object to get the field cache
- // If one wants to avoid that adding of this read handle here, then client tools/algs calling driftRadiusFromTime
- // must implement this to get the AtlasFieldCache which can then be passed through the call to driftRadiusFromTime
- // Note: a readhandle must be in a tool or an alg, and so it cannot be in the class Imp.)
- SG::ReadCondHandleKey<AtlasFieldCacheCondObj> m_fieldCacheCondObjInputKey {this, "AtlasFieldCacheCondObj", "fieldCondObj", "Name of the Magnetic Field conditions object key"};
- ServiceHandle<Muon::IMuonIdHelperSvc> m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"};
-
-};
-
-#endif
diff --git a/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibSvc/src/MdtCalibrationDbTool.cxx b/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibSvc/src/MdtCalibrationDbTool.cxx
deleted file mode 100644
index dc641e3a9d2..00000000000
--- a/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibSvc/src/MdtCalibrationDbTool.cxx
+++ /dev/null
@@ -1,218 +0,0 @@
-/*
- Copyright (C) 2019-2023 CERN for the benefit of the ATLAS collaboration
-*/
-
-#include "MdtCalibSvc/MdtCalibrationDbTool.h"
-
-#include "MdtCalibSvc/MdtCalibrationRegionSvc.h"
-#include "MdtCalibData/MdtFullCalibData.h"
-#include "MdtCalibData/BFieldCorFunc.h"
-#include "MdtCalibData/WireSagCorFunc.h"
-#include "MdtCalibData/MdtSlewCorFuncHardcoded.h"
-#include "MdtCalibData/CalibFunc.h"
-#include <atomic>
-
-MdtCalibrationDbTool::MdtCalibrationDbTool(const std::string& type, const std::string &name, const IInterface* parent)
- : base_class(type, name, parent),
- m_regionSvc("MdtCalibrationRegionSvc", name)
-{
- declareProperty("AccessTubeConstants", m_getTubeConstants = true,
- "configure the Tool to retrieve the constants per tube (t0)");
- declareProperty("AccessCorrections", m_getCorrections = true,
- "configure the Tool to retrieve the parameters of the correction functions");
- declareProperty("CreateBFieldFunctions", m_create_b_field_function = false,
- "If set to true, the B-field correction functions are initialized for each rt-relation that is loaded.");
- declareProperty("CreateWireSagFunctions", m_createWireSagFunction = false,
- "If set to true, the wire sag correction functions are initialized for each rt-relation that is loaded.");
- declareProperty("CreateSlewingFunctions", m_createSlewingFunction = false,
- "If set to true, the slewing correction functions are initialized for each rt-relation that is loaded.");
-}
-
-StatusCode MdtCalibrationDbTool::initialize() {
-
- if ( m_regionSvc.retrieve().isFailure() ) {
- ATH_MSG_ERROR( "Failed to retrieve MdtCalibrationRegionSvc" );
- return StatusCode::FAILURE;
- }
-
- ATH_CHECK(m_idHelperSvc.retrieve());
- ATH_CHECK(m_readKeyRt.initialize());
- ATH_CHECK(m_readKeyTube.initialize());
- ATH_CHECK(m_readKeyCor.initialize (m_createSlewingFunction || m_createWireSagFunction || m_create_b_field_function));
-
- if (!m_wasConfigured){
- ATH_MSG_WARNING( "This tool is too complicated to rely on defaults. Potential configuration issue." );
- }
-
- return StatusCode::SUCCESS;
-} //end MdtCalibrationDbTool::initialize
-
-MuonCalib::MdtFullCalibData MdtCalibrationDbTool::getCalibration( const Identifier &idt ) const {
-
- Identifier id = m_idHelperSvc->mdtIdHelper().elementID( idt );
-
- IdentifierHash mlHash; //hash for ML (needed when using ML-RT functions)
- m_idHelperSvc->mdtIdHelper().get_detectorElement_hash( id, mlHash ); //hash for the ML
-
- IdentifierHash chamberHash;
- IdContext idCont = m_idHelperSvc->mdtIdHelper().module_context();
- m_idHelperSvc->mdtIdHelper().get_hash( id, chamberHash, &idCont );
-
- return getCalibration( chamberHash, mlHash );
-}
-
-MuonCalib::MdtFullCalibData MdtCalibrationDbTool::getCalibration( const IdentifierHash &chamberHash, const IdentifierHash &mlHash ) const {
- const MuonCalib::MdtRtRelation *rt = nullptr;
- const MuonCalib::MdtTubeCalibContainer *tube = nullptr;
- const MuonCalib::MdtCorFuncSet *cor = nullptr;
-
- IdentifierHash tubeHash = chamberHash;
- IdentifierHash rtHash;
- if( m_regionSvc->RegionType()==ONEPERMULTILAYER ) { //if using ML-RTs
- rtHash = m_regionSvc->getRegionHash(mlHash);
- } else {
- rtHash = m_regionSvc->getRegionHash(chamberHash);
- }
- IdentifierHash corHash = rtHash; //correction functions done in same regions as RTs
-
- if( rtHash.is_valid() ) {
- // find rt relation
- rt = getRtCalibration( rtHash );
- if ( !rt ) {
- ATH_MSG_WARNING( "No valid MdtRtRelation found " );
- }
- } else {
- ATH_MSG_WARNING( "--- INVALID RT HASH, cannot access rt calibration constants " );
- }
-
- // find correction functions
- if( m_getCorrections && corHash.is_valid()) {
- cor = getCorFunctions( corHash );
- }
-
- // find t0's
- if( m_getTubeConstants && tubeHash.is_valid() ) {
- tube = getTubeCalibContainer( tubeHash );
- if( !tube ){
- ATH_MSG_WARNING( "Not valid MdtTubeCalibContainer found " );
- }
- }
-
- return MuonCalib::MdtFullCalibData( cor, rt, tube );
-}
-
-const MuonCalib::MdtTubeCalibContainer* MdtCalibrationDbTool::getTubeCalibContainer( const Identifier &idt ) const {
- Identifier id = m_idHelperSvc->mdtIdHelper().elementID( idt );
-
- IdentifierHash hash;
- IdContext idCont = m_idHelperSvc->mdtIdHelper().module_context();
- m_idHelperSvc->mdtIdHelper().get_hash( id, hash, &idCont );
-
- return getTubeCalibContainer( hash );
-}
-
-const MuonCalib::MdtTubeCalibContainer* MdtCalibrationDbTool::getTubeCalibContainer( const IdentifierHash &hash ) const {
- if ( !hash.is_valid() ) {
- ATH_MSG_WARNING( "cannot get tube, invalid hash" );
- return nullptr;
- }
- SG::ReadCondHandle<MdtTubeCalibContainerCollection> readHandleTube{ m_readKeyTube };
- const MdtTubeCalibContainerCollection* readCdoTube{*readHandleTube};
- if ( readCdoTube==nullptr ) {
- ATH_MSG_ERROR("readCdoTube==nullptr");
- return nullptr;
- }
- if ( hash < readCdoTube->size() ) {
- return (*readCdoTube)[ hash ];
- }
- ATH_MSG_WARNING( "cannot get tube, region hash out of range" );
- return nullptr;
-}
-
-const MuonCalib::MdtRtRelation* MdtCalibrationDbTool::getRtCalibration( const Identifier &idt ) const {
- Identifier id = m_idHelperSvc->mdtIdHelper().elementID( idt );
- IdentifierHash hash;
-
- if( m_regionSvc->RegionType()==ONEPERMULTILAYER ) {
- m_idHelperSvc->mdtIdHelper().get_detectorElement_hash( id, hash ); //hash for the ML
- } else {
- IdContext idCont = m_idHelperSvc->mdtIdHelper().module_context();
- m_idHelperSvc->mdtIdHelper().get_hash( id, hash, &idCont ); //hash for the chamber
- }
- hash = m_regionSvc->getRegionHash(hash);
- return getRtCalibration( hash );
-}
-
-const MuonCalib::MdtRtRelation* MdtCalibrationDbTool::getRtCalibration( const IdentifierHash &hash ) const {
- if ( !hash.is_valid() ) {
- ATH_MSG_WARNING( "cannot get rt, invalid hash" );
- return nullptr;
- }
- SG::ReadCondHandle<MdtRtRelationCollection> readHandleRt{ m_readKeyRt };
- const MdtRtRelationCollection* readCdoRt{*readHandleRt};
- if ( readCdoRt==nullptr ) {
- ATH_MSG_ERROR("readCdoRt==nullptr");
- return nullptr;
- }
- // Get the RT using the hash as an index
- if( hash < readCdoRt->size() ) {
- return (*readCdoRt)[ hash ];
- }
- ATH_MSG_WARNING( "cannot get RT, region hash out of range" );
- return nullptr;
-}
-
-const MuonCalib::MdtCorFuncSet* MdtCalibrationDbTool::getCorFunctions( const Identifier &idt ) const {
- Identifier id = m_idHelperSvc->mdtIdHelper().elementID( idt );
- IdentifierHash hash;
-
- if( m_regionSvc->RegionType()==ONEPERMULTILAYER ) {
- m_idHelperSvc->mdtIdHelper().get_detectorElement_hash( id, hash ); //hash for the ML
- } else {
- IdContext idCont = m_idHelperSvc->mdtIdHelper().module_context();
- m_idHelperSvc->mdtIdHelper().get_hash( id, hash, &idCont ); //hash for the chamber
- }
- hash = m_regionSvc->getRegionHash(hash);
- return getCorFunctions( hash );
-}
-
-const MuonCalib::MdtCorFuncSet* MdtCalibrationDbTool::getCorFunctions( const IdentifierHash &hash ) const {
- if ( !hash.is_valid() ){
- ATH_MSG_WARNING( "cannot get cor, invalid hash" );
- return nullptr;
- }
- //in this case the loadRt() was intended to keep m_corData nullptr and getCorFunctions() returned 0 here so
- if( !m_createSlewingFunction && !m_createWireSagFunction && !m_create_b_field_function ){
- return nullptr;
- }
- SG::ReadCondHandle<MdtCorFuncSetCollection> readHandleCor{ m_readKeyCor };
- const MdtCorFuncSetCollection* readCdoCor{*readHandleCor};
- if ( readCdoCor==nullptr ) {
- ATH_MSG_ERROR("readCdoCor==nullptr");
- return nullptr;
- }
- if( hash < readCdoCor->size() ) {
- return (*readCdoCor)[ hash ];
- }
- ATH_MSG_WARNING( "cannot get cor, region hash out of range" );
- return nullptr;
-}
-
-void MdtCalibrationDbTool::initialize_B_correction(MuonCalib::MdtCorFuncSet *funcSet,
- const MuonCalib::MdtRtRelation *rt_rel) {
- if (rt_rel==nullptr) {
- funcSet->setBField(nullptr);
- return;
- }
- ATH_MSG_VERBOSE( "initialize_B_correction..." );
- std::vector<double> corr_params(2);
- corr_params[0] = 3080.0; // high voltage (not correct for sMDT which use 2730V!)
- corr_params[1] = 0.11; // epsilon parameter
- funcSet->setBField(std::make_unique<MuonCalib::BFieldCorFunc>("medium", corr_params, rt_rel->rt()));
-}
-
-void MdtCalibrationDbTool::initializeSagCorrection(MuonCalib::MdtCorFuncSet *funcSet) {
- ATH_MSG_VERBOSE( "initializeSagCorrection..." );
- std::vector<double> corr_params(0);
- funcSet->wireSag(std::make_unique<MuonCalib::WireSagCorFunc>(corr_params));
-}
diff --git a/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibSvc/src/MdtCalibrationRegionSvc.cxx b/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibSvc/src/MdtCalibrationRegionSvc.cxx
deleted file mode 100644
index 8564930f585..00000000000
--- a/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibSvc/src/MdtCalibrationRegionSvc.cxx
+++ /dev/null
@@ -1,98 +0,0 @@
-/*
- Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
-*/
-
-// other packages
-#include "GaudiKernel/ISvcLocator.h"
-#include "GaudiKernel/Bootstrap.h"
-#include "GaudiKernel/IMessageSvc.h"
-
-#include "StoreGate/StoreGateSvc.h"
-#include "MuonIdHelpers/MdtIdHelper.h"
-
-// this package
-#include "MdtCalibSvc/MdtCalibrationRegionSvc.h"
-
-MdtCalibrationRegionSvc::MdtCalibrationRegionSvc(const std::string &name,ISvcLocator *sl)
- : AthService(name,sl), m_mdtIdHelper(nullptr), m_regionType(ONERT), m_numberOfRegions(1) {
-}
-
-// queryInterface
-StatusCode MdtCalibrationRegionSvc::queryInterface(const InterfaceID &riid, void **ppvIF) {
- if( interfaceID().versionMatch(riid) ) {
- *ppvIF = dynamic_cast<MdtCalibrationRegionSvc*>(this);
- } else {
- return AthService::queryInterface(riid, ppvIF);
- }
- addRef();
- return StatusCode::SUCCESS;
-}
-
-StatusCode MdtCalibrationRegionSvc::initialize() {
- ATH_CHECK(AthService::initialize());
-
- // initialize the MdtIdHelper
- ServiceHandle<StoreGateSvc> detStore("StoreGateSvc/DetectorStore", name());
- ATH_CHECK(detStore.retrieve());
-
- ATH_CHECK(detStore->retrieve(m_mdtIdHelper, "MDTIDHELPER"));
-
- // Initialize RT and correction function regions
- remapRtRegions("OneRt");
-
- return StatusCode::SUCCESS;
-} //end MdtCalibrationRegionSvc::initialize
-
-void MdtCalibrationRegionSvc::remapRtRegions(std::string mapName) {
- m_regionHash.resize(0);
-
-// One RT for all chambers
- if (mapName=="OneRt") {
- m_regionType = ONERT;
- m_numberOfRegions = 1;
- MdtIdHelper::const_id_iterator it = m_mdtIdHelper->module_begin();
- MdtIdHelper::const_id_iterator it_end = m_mdtIdHelper->module_end();
- for( int i=0; it!=it_end; ++it, i++ ) {
- m_regionHash.push_back(0); //all chambers use RT 0
- }
-
-// One RT per chamber
-// RT/correction functions are stored using chamber hash as index.
-// Chamber hash is available from
-// m_mdtIdHelper->get_module_hash( *it, hash );
-// or m_mdtIdHelper->get_hash( *it, hash, &idCont );
- } else if (mapName=="OnePerChamber") {
- m_regionType = ONEPERCHAMBER;
- m_numberOfRegions = m_mdtIdHelper->module_hash_max();
- MdtIdHelper::const_id_iterator it = m_mdtIdHelper->module_begin();
- MdtIdHelper::const_id_iterator it_end = m_mdtIdHelper->module_end();
- for( int i=0; it!=it_end; ++it, i++ ) {
- m_regionHash.push_back(i); //Ok, silly since rt region = chamber hash
- }
-
-// One RT per multilayer
-// This is starts out the same as ONEPERCHAMBER except that m_regionHash is used
-// to store the index for m_rtData for each ML. m_regionHash is initialized here
-// for ML2 to use the ML1 RT. In MdtCalibDBStrTool if an ML2 RT is read from COOL
-// then it is added to m_rtData and the hash (index) to for the ML2 is stored in m_regionHash.
- } else if (mapName=="OnePerMultilayer") {
- m_regionType = ONEPERMULTILAYER;
- m_numberOfRegions = m_mdtIdHelper->module_hash_max(); //initial value; may increase of ML2 RTs are read from COOL
- //initialize m_regionHash so ML2 uses ML1 hash (i.e. ML2 uses ML1 RT function)
- //If ML2 RT is read from COOL this is overwritten in MdtCalibDBStrTool
- //The index, i, of the loop below is effectively a loop over (chamber) hashes.
- //m_regionHash is filled in the order of ML hashes
- MdtIdHelper::const_id_iterator it = m_mdtIdHelper->module_begin();
- MdtIdHelper::const_id_iterator it_end = m_mdtIdHelper->module_end();
- for( int i=0; it!=it_end; ++it, i++ ) {
- m_regionHash.push_back(i);
- if( m_mdtIdHelper->numberOfMultilayers(*it) == 2 ) {
- m_regionHash.push_back(i);
- }
- }
-
- } else {
- ATH_MSG_ERROR("Rt Regions Map "<<mapName <<" unknown. Keeping previous map ");
- }
-
-} //end MdtCalibrationRegionSvc::remapRtRegions
diff --git a/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibSvc/src/MdtCalibrationShiftMapBase.cxx b/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibSvc/src/MdtCalibrationShiftMapBase.cxx
index 754c663354d..2d285ccaa70 100644
--- a/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibSvc/src/MdtCalibrationShiftMapBase.cxx
+++ b/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibSvc/src/MdtCalibrationShiftMapBase.cxx
@@ -1,8 +1,8 @@
/*
- Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
+ Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
*/
-#include "MdtCalibSvc/MdtCalibrationShiftMapBase.h"
+#include "MdtCalibrationShiftMapBase.h"
#include "PathResolver/PathResolver.h"
#include <sys/stat.h>
@@ -33,7 +33,7 @@ StatusCode MdtCalibrationShiftMapBase::dumpMapAsFile() {
if (!file.is_open()) {
ATH_MSG_FATAL(
"Cannot open map output file for writing. Tried accessing file at \"./"
- << m_mapFileName.value().c_str() << "\"");
+ << m_mapFileName << "\"");
return StatusCode::FAILURE;
}
diff --git a/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibSvc/MdtCalibSvc/MdtCalibrationShiftMapBase.h b/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibSvc/src/MdtCalibrationShiftMapBase.h
similarity index 96%
rename from MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibSvc/MdtCalibSvc/MdtCalibrationShiftMapBase.h
rename to MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibSvc/src/MdtCalibrationShiftMapBase.h
index b34fd6207f9..be8a1e74615 100644
--- a/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibSvc/MdtCalibSvc/MdtCalibrationShiftMapBase.h
+++ b/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibSvc/src/MdtCalibrationShiftMapBase.h
@@ -1,5 +1,5 @@
/*
- Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
+ Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
*/
#ifndef MDTCALIBSVC_MDTCALIBRATIONSHIFTMAPBASE_H
diff --git a/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibSvc/src/MdtCalibrationT0ShiftTool.cxx b/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibSvc/src/MdtCalibrationT0ShiftTool.cxx
index c19f98651d0..cd1b08a05a7 100644
--- a/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibSvc/src/MdtCalibrationT0ShiftTool.cxx
+++ b/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibSvc/src/MdtCalibrationT0ShiftTool.cxx
@@ -1,8 +1,8 @@
/*
- Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
+ Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
*/
-#include "MdtCalibSvc/MdtCalibrationT0ShiftTool.h"
+#include "MdtCalibrationT0ShiftTool.h"
// TRandom3 for random smearing
// should later be replaced with std
diff --git a/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibSvc/MdtCalibSvc/MdtCalibrationT0ShiftTool.h b/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibSvc/src/MdtCalibrationT0ShiftTool.h
similarity index 85%
rename from MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibSvc/MdtCalibSvc/MdtCalibrationT0ShiftTool.h
rename to MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibSvc/src/MdtCalibrationT0ShiftTool.h
index e476e6312de..eceda51cee0 100644
--- a/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibSvc/MdtCalibSvc/MdtCalibrationT0ShiftTool.h
+++ b/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibSvc/src/MdtCalibrationT0ShiftTool.h
@@ -1,17 +1,18 @@
/*
- Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
+ Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
*/
#ifndef MDTCALIBSVC_MDTCALIBRATIONT0SHIFTTOOL_H
#define MDTCALIBSVC_MDTCALIBRATIONT0SHIFTTOOL_H
-#include "MdtCalibSvc/MdtCalibrationShiftMapBase.h"
+#include "MdtCalibrationShiftMapBase.h"
/**
@class MdtCalibrationT0ShiftTool
Provides a per-tube smearing of the T0 value.
@author Andreas Hoenle
*/
+
class MdtCalibrationT0ShiftTool : virtual public MdtCalibrationShiftMapBase {
public:
/** constructor */
diff --git a/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibSvc/src/MdtCalibrationTMaxShiftTool.cxx b/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibSvc/src/MdtCalibrationTMaxShiftTool.cxx
index 15c56d2bae6..43724131d67 100644
--- a/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibSvc/src/MdtCalibrationTMaxShiftTool.cxx
+++ b/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibSvc/src/MdtCalibrationTMaxShiftTool.cxx
@@ -1,17 +1,15 @@
/*
- Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
+ Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
*/
-#include "MdtCalibSvc/MdtCalibrationTMaxShiftTool.h"
+#include "MdtCalibrationTMaxShiftTool.h"
// TRandom2 for random smearing
// should later be replaced with std
#include "TRandom2.h"
MdtCalibrationTMaxShiftTool::MdtCalibrationTMaxShiftTool(const std::string& type, const std::string& name, const IInterface* parent) :
- MdtCalibrationShiftMapBase(type, name, parent),
- m_tUpper(688.1818) {
-}
+ MdtCalibrationShiftMapBase(type, name, parent) {}
StatusCode MdtCalibrationTMaxShiftTool::initializeMap() {
if (m_mapIsInitialized) {
diff --git a/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibSvc/MdtCalibSvc/MdtCalibrationTMaxShiftTool.h b/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibSvc/src/MdtCalibrationTMaxShiftTool.h
similarity index 85%
rename from MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibSvc/MdtCalibSvc/MdtCalibrationTMaxShiftTool.h
rename to MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibSvc/src/MdtCalibrationTMaxShiftTool.h
index 22eebb865a7..7204be9310e 100644
--- a/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibSvc/MdtCalibSvc/MdtCalibrationTMaxShiftTool.h
+++ b/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibSvc/src/MdtCalibrationTMaxShiftTool.h
@@ -1,11 +1,11 @@
/*
- Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
+ Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
*/
#ifndef MDTCALIBSVC_MDTCALIBRATIONTMAXSHIFTTOOL_H
#define MDTCALIBSVC_MDTCALIBRATIONTMAXSHIFTTOOL_H
-#include "MdtCalibSvc/MdtCalibrationShiftMapBase.h"
+#include "MdtCalibrationShiftMapBase.h"
/*
@class MdtCalibrationTMaxShiftTool
@@ -30,7 +30,7 @@ public:
float getTUpper() const { return m_tUpper; }
private:
- float m_tUpper;
+ float m_tUpper{688.1818};
};
#endif
diff --git a/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibSvc/src/MdtCalibrationTool.cxx b/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibSvc/src/MdtCalibrationTool.cxx
index f17a5225f54..088e185ab33 100644
--- a/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibSvc/src/MdtCalibrationTool.cxx
+++ b/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibSvc/src/MdtCalibrationTool.cxx
@@ -2,12 +2,11 @@
Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
*/
-#include "MdtCalibSvc/MdtCalibrationTool.h"
+#include "MdtCalibrationTool.h"
+#include "GeoPrimitives/GeoPrimitivesToStringConverter.h"
#include "MuonReadoutGeometry/MdtReadoutElement.h"
#include "MuonReadoutGeometry/MuonDetectorManager.h"
-#include "MdtCalibSvc/MdtCalibrationSvcInput.h"
-#include "MdtCalibSvc/MdtCalibrationSvcSettings.h"
#include "MdtCalibData/MdtFullCalibData.h"
#include "MdtCalibData/MdtRtRelation.h"
#include "MdtCalibData/MdtTubeCalibContainer.h"
@@ -21,307 +20,243 @@
#include "MdtCalibData/IRtResolution.h"
#include "MdtCalibData/TrRelation.h"
#include "MdtCalibData/RtScaleFunction.h"
-#include "MdtCalibInterfaces/IShiftMapTools.h"
-#include "GaudiKernel/PhysicalConstants.h"
#include "MagFieldElements/AtlasFieldCache.h"
#include "MuonCalibEvent/MdtCalibHit.h"
namespace {
static double const twoBySqrt12 = 2/std::sqrt(12);
+ static constexpr double TdcBinSize = 0.78125; //25/32; exact number: (1000.0/40.079)/32.0
}
-//
-// private helper functions
-//
-
-class MdtCalibrationTool::Imp {
-public:
-
- Imp();
-
- const MuonGM::MdtReadoutElement* getGeometry( const Identifier &id ) const {
- assert( m_muonGeoManager );
- return m_muonGeoManager->getMdtReadoutElement( id );
- }
-
- double applyCorrections( MagField::AtlasFieldCache& fieldCache,
- MdtCalibHit &hit,
- const MdtCalibrationSvcInput &input,
- const MdtCalibrationSvcSettings &settings,
- double adcCal,
- const MuonCalib::MdtCorFuncSet *corrections,
- const MuonCalib::IRtRelation *rt,
- MsgStream* msgStr, const MdtIdHelper *idHelp) const;
-
- const MuonGM::MuonDetectorManager *m_muonGeoManager{nullptr};
- MdtCalibrationSvcSettings settings;
-
- double m_inverseSpeedOfLight{1./Gaudi::Units::c_light}; // in ns/mm
- double m_inversePropagationSpeed{m_inverseSpeedOfLight/0.85}; // in ns/mm
-
- /* T0 Shift tool -- Per-tube offsets of t0 value */
- ToolHandle<MuonCalib::IShiftMapTools> m_t0ShiftTool{"MdtCalibrationT0ShiftTool"};
- /* TMax Shift tool -- Per-tube offsets of Tmax */
- ToolHandle<MuonCalib::IShiftMapTools> m_tMaxShiftTool{"MdtCalibrationTMaxShiftTool"};
-
- // tools should only be retrieved if they are used
- bool m_doT0Shift{false};
- bool m_doTMaxShift{false};
-
- double m_unphysicalHitRadiusUpperBound{-1.};
- double m_unphysicalHitRadiusLowerBound{-1.};
- double m_resTwin{-1.};
-
-};
-
-MdtCalibrationTool::Imp::Imp() = default;
-
-
+using SingleTubeCalib = MuonCalib::MdtTubeCalibContainer::SingleTubeCalib;
+using MdtDriftCircleStatus = MdtCalibOutput::MdtDriftCircleStatus;
+using ToolSettings = MdtCalibrationTool::ToolSettings;
MdtCalibrationTool::MdtCalibrationTool(const std::string& type, const std::string &name, const IInterface* parent) :
- base_class(type, name, parent),
- m_imp{ std::make_unique<MdtCalibrationTool::Imp>()} {
- // settable properties
- declareProperty("TimeWindowLowerBound",m_imp->settings.windowLowerBound );
- declareProperty("TimeWindowUpperBound",m_imp->settings.windowUpperBound );
- declareProperty("TimeWindowSetting",m_imp->settings.windowSetting );
- declareProperty("DoTofCorrection",m_imp->settings.doTof );
- declareProperty("DoPropagationCorrection",m_imp->settings.doProp );
- declareProperty("DoTemperatureCorrection",m_imp->settings.doTemp );
- declareProperty("DoMagneticFieldCorrection",m_imp->settings.doField );
- declareProperty("DoWireSagCorrection",m_imp->settings.doWireSag );
- declareProperty("DoSlewingCorrection",m_imp->settings.doSlew );
- declareProperty("DoBackgroundCorrection",m_imp->settings.doBkg );
- declareProperty("ResolutionTwinTube", m_imp->m_resTwin = 1.05, "Twin Tube resolution");
- declareProperty("UpperBoundHitRadius", m_imp->m_unphysicalHitRadiusUpperBound = 20. );
- declareProperty("LowerBoundHitRadius", m_imp->m_unphysicalHitRadiusLowerBound = 0. );
- declareProperty("DoT0Shift", m_imp->m_doT0Shift = false );
- declareProperty("DoTMaxShift", m_imp->m_doTMaxShift = false );
+ base_class(type, name, parent) {}
+
+ToolSettings MdtCalibrationTool::getSettings() const {
+ ToolSettings settings{};
+ using Property = ToolSettings::Property;
+ settings.setBit(Property::TofCorrection, m_doTof);
+ settings.setBit(Property::PropCorrection, m_doProp);
+ settings.setBit(Property::TempCorrection, m_doTemp);
+ settings.setBit(Property::MagFieldCorrection, m_doField);
+ settings.setBit(Property::WireSagTimeCorrection, m_doWireSag);
+ settings.setBit(Property::SlewCorrection, m_doSlew);
+ settings.setBit(Property::BackgroundCorrection, m_doBkg);
+ settings.window = static_cast<timeWindowMode>(m_windowSetting.value());
+ return settings;
}
-
-MdtCalibrationTool::~MdtCalibrationTool()= default;
-
-StatusCode MdtCalibrationTool::initialize() {
-
+StatusCode MdtCalibrationTool::initialize() {
ATH_MSG_DEBUG( "Initializing" );
- m_imp->settings.initialize();
- // Read handle for AtlasFieldCacheCondObj
- ATH_CHECK(m_fieldCacheCondObjInputKey.initialize());
+ switch(m_windowSetting.value()) {
+ case timeWindowMode::UserDefined:
+ ATH_MSG_DEBUG("Use predefined user values of "<<m_timeWindowLowerBound<<" & "<<m_timeWindowUpperBound);
+ break;
+ case timeWindowMode::Default:
+ ATH_MSG_DEBUG("Use 1000. & 2000. as the lower and upper time window values ");
+ m_timeWindowLowerBound = 1000.;
+ m_timeWindowUpperBound = 2000.;
+ break;
+ case timeWindowMode::CollisionG4:
+ ATH_MSG_DEBUG("Use Geant4 collision time window of 20-30");
+ m_timeWindowLowerBound = 20.;
+ m_timeWindowUpperBound = 30.;
+ break;
+ case timeWindowMode::CollisionData:
+ ATH_MSG_DEBUG("Use collision data time window of 10 to 30");
+ m_timeWindowLowerBound = 10.;
+ m_timeWindowUpperBound = 30.;
+ break;
+ case timeWindowMode::CollisionFitT0:
+ ATH_MSG_DEBUG("Use collision data time window of 50 to 100 to fit T0 in the end");
+ m_timeWindowLowerBound = 50.;
+ m_timeWindowUpperBound = 100.;
+ break;
+ default:
+ ATH_MSG_FATAL("Unknown time window setting "<<m_windowSetting<<" provided.");
+ return StatusCode::FAILURE;
+ };
ATH_CHECK(m_idHelperSvc.retrieve());
-
- // initialise MuonGeoModel access
- ATH_CHECK(detStore()->retrieve( m_imp->m_muonGeoManager ));
-
- if (m_imp->m_doT0Shift) ATH_CHECK( m_imp->m_t0ShiftTool.retrieve() );
-
- if (m_imp->m_doTMaxShift) ATH_CHECK ( m_imp->m_tMaxShiftTool.retrieve() );
-
- ATH_MSG_DEBUG("Settings:");
- ATH_MSG_DEBUG(" Time window: lower bound " << m_imp->settings.timeWindowLowerBound()
- << " upper bound " << m_imp->settings.timeWindowUpperBound() );
- if( m_imp->settings.doTofCorrection() ) ATH_MSG_DEBUG(" Using TOF ");
- if( m_imp->settings.doPropCorrection() ) ATH_MSG_DEBUG(" Using Prop ");
- if( m_imp->settings.doCorrections() ) ATH_MSG_DEBUG(" Using Cor ");
- if( m_imp->settings.doTemperatureCorrection() ) ATH_MSG_DEBUG(" Using TempCor ");
- if( m_imp->settings.doMagneticFieldCorrection() ) ATH_MSG_DEBUG(" Using MagCor ");
- if( m_imp->settings.doWireSagCorrection() ) ATH_MSG_DEBUG(" Using WireSag ");
- if( m_imp->settings.doSlewingCorrection() ) ATH_MSG_DEBUG(" Using Slew ");
- if( m_imp->settings.doBackgroundCorrection() ) ATH_MSG_DEBUG(" Using BkgCor");
-
+ /// Ensure that the conditions dependency is properly declared
+ ATH_CHECK(m_fieldCacheCondObjInputKey.initialize());
+ ATH_CHECK(m_calibDbKey.initialize());
+ /// Shifting tools to evaluate systematic uncertainties on the T0 timing
+ ATH_CHECK(m_t0ShiftTool.retrieve(EnableTool{m_doT0Shift}));
+ ATH_CHECK(m_tMaxShiftTool.retrieve(EnableTool{m_doTMaxShift}));
+ ATH_MSG_DEBUG("Initialization finalized "<<std::endl
+ <<" TimeWindow: ["<< m_timeWindowLowerBound.value()<<";"<<m_timeWindowUpperBound.value()<<"]"<<std::endl
+ <<" Correct time of flight "<<(m_doTof ? "yay" : "nay")<<std::endl
+ <<" Correct propagation time "<<(m_doProp ? "si" : "no")<<std::endl
+ <<" Correct temperature "<<(m_doTemp ? "si" : "no")<<std::endl
+ <<" Correct magnetic field "<<(m_doField ? "si" : "no")<<std::endl
+ <<" Correct wire sagging "<<(m_doWireSag ? "si" : "no")<<std::endl
+ <<" Correct time slew "<<(m_doSlew ? "si" : "no")<<std::endl
+ <<" Correct background "<<(m_doBkg ? "si" : "no"));
return StatusCode::SUCCESS;
} //end MdtCalibrationTool::initialize
-bool MdtCalibrationTool::driftRadiusFromTime( MdtCalibHit &hit,
- double signedTrackLength,
- double triggerTime,
- bool resolFromRtrack ) const {
- MdtCalibrationSvcInput inputData;
- inputData.tof = signedTrackLength*m_imp->m_inverseSpeedOfLight;
- inputData.triggerOffset = triggerTime;
- return driftRadiusFromTime( hit, inputData, m_imp->settings, resolFromRtrack );
-}
-bool MdtCalibrationTool::driftRadiusFromTime( MdtCalibHit &hit,
- const MdtCalibrationSvcInput &inputData,
- bool resolFromRtrack ) const {
- return driftRadiusFromTime( hit, inputData, m_imp->settings, resolFromRtrack );
-}
-bool MdtCalibrationTool::driftRadiusFromTime( MdtCalibHit &hit,
- const MdtCalibrationSvcInput &inputData,
- const MdtCalibrationSvcSettings &settings,
- bool resolFromRtrack ) const {
+MdtCalibOutput MdtCalibrationTool::calibrate(const EventContext& ctx,
+ const MdtCalibInput& calibIn,
+ bool resolFromRtrack) const {
- if( settings.timeWindowUpperBound() < 0. || settings.timeWindowLowerBound() < 0. ) {
- // Should be an ERROR, but can't return StatusCode::FAILURE
- ATH_MSG_WARNING( "Uninitialized settings object at " << &settings );
- return false;
+ const MdtIdHelper& id_helper{m_idHelperSvc->mdtIdHelper()};
+ /// Get the calibration constatns from the conditions store
+ SG::ReadCondHandle<MuonCalib::MdtCalibDataContainer> readCondHandle{m_calibDbKey, ctx};
+ if (!readCondHandle.isValid()){
+ ATH_MSG_FATAL(__FILE__<<":"<<__LINE__<<" Failed to retrieve the Mdt calibration constants "<<m_calibDbKey.fullKey());
+ throw std::runtime_error("No calibration constants could be retrieved");
}
- if (msgLvl(MSG::VERBOSE)) {
- ATH_MSG_VERBOSE("Input: tof " << inputData.tof << " trigger offset " << inputData.triggerOffset);
- if( inputData.pointOfClosestApproach ) ATH_MSG_VERBOSE(" PointOfClosestApproach");
- if( inputData.trackDirection ) ATH_MSG_VERBOSE(" TrackDirection");
- if( inputData.nominalWireSurface ) ATH_MSG_VERBOSE(" Nom. WireSurface");
- if( inputData.wireSurface ) ATH_MSG_VERBOSE(" Sagged Wiresurface");
- ATH_MSG_VERBOSE("Settings: window " << settings.timeWindowLowerBound() << " " << settings.timeWindowUpperBound());
- if( settings.doTof ) ATH_MSG_VERBOSE(" Tof");
- if( settings.doProp ) ATH_MSG_VERBOSE(" Prop");
- if( settings.doTemp ) ATH_MSG_VERBOSE(" Temp");
- if( settings.doField ) ATH_MSG_VERBOSE(" Field");
- if( settings.doWireSag ) ATH_MSG_VERBOSE(" WireSag");
- if( settings.doSlew ) ATH_MSG_VERBOSE(" Slew");
- if( settings.doBkg ) ATH_MSG_VERBOSE(" Bkg");
- }
+ const Identifier& id{calibIn.identify()};
- const Identifier &id = hit.identify();
- const MuonGM::MdtReadoutElement *geo = hit.geometry();
- // set geometry pointer if not yet set
- if ( !geo ) {
- geo = m_imp->getGeometry( id );
- if ( !geo ) return false;
- hit.setGeometry( geo );
+ const MuonCalib::MdtFullCalibData* calibConstants = readCondHandle->getCalibData(id, msgStream());
+ if (!calibConstants) {
+ ATH_MSG_WARNING("Could not find calibration data for channel "<<m_idHelperSvc->toString(id));
+ return MdtCalibOutput{};
}
-
- // get calibration constants from DbTool
- MuonCalib::MdtFullCalibData data = m_dbTool->getCalibration( geo->identifyHash(),
- geo->detectorElementHash() );
-
+
// require at least the MdtRtRelation to be available
- const MuonCalib::MdtRtRelation *rtRelation = data.rtRelation;
+ const RtRelationPtr& rtRelation{calibConstants->rtRelation};
// Hardcoded MDT tube radius 14.6mm here - not correct for sMDT
// on the other hand it should be rare that a tube does not have an RT
- if( !rtRelation ) {
- ATH_MSG_WARNING( "no rtRelation found, cannot calibrate tube" );
- hit.setDriftRadius(0., twoBySqrt12*geo->innerTubeRadius());
- return false;
+ if(!rtRelation) {
+ ATH_MSG_WARNING("No rtRelation found, cannot calibrate tube "<<m_idHelperSvc->toString(id));
+ return MdtCalibOutput{};
}
- double t0(0.);
- double inversePropSpeed = m_imp->m_inversePropagationSpeed;
- double adcCal(1.);
-
- // access t0 for the given tube
- if ( data.tubeCalib ) {
-
- const int ml = m_idHelperSvc->mdtIdHelper().multilayer(id)-1;
- const int layer = m_idHelperSvc->mdtIdHelper().tubeLayer(id)-1;
- const int tube = m_idHelperSvc->mdtIdHelper().tube(id)-1;
-
- if ( ml<0 || layer<0 || tube<0 ){
- ATH_MSG_WARNING( "Oops negative index....." );
- return false;
- }
-
- // extract calibration constants for single tube
- const MuonCalib::MdtTubeCalibContainer::SingleTubeCalib *singleTubeData =
- data.tubeCalib->getCalib( ml, layer, tube );
- if( singleTubeData ){
- ATH_MSG_DEBUG("Apply the following calibration shift to "<<m_idHelperSvc->toString(id)<<" "<<singleTubeData->t0);
- t0 = singleTubeData->t0;
- inversePropSpeed = singleTubeData->inversePropSpeed;
- adcCal = singleTubeData->adcCal;
- } else {
- ATH_MSG_WARNING("failed to access tubedata for "
- << ml << " " << layer << " " << tube
- << " using defaults.. ");
- if ( geo )
- ATH_MSG_WARNING("detel " << geo->getMultilayer()
- << " lay " << geo->getNLayers()
- << " tubes " << geo->getNtubesperlayer());
- t0 = 800.;
- }
-
- // get t0 shift from tool (default: no shift, value is zero)
- if (m_imp->m_doT0Shift) t0 += m_imp->m_t0ShiftTool->getValue(id);
- } else {
- ATH_MSG_WARNING("MdtTubeCalibContainer not found for " << m_idHelperSvc->toString( id ) << " - Tube cannot be calibrated!");
- return false;
+ if (!calibConstants->tubeCalib) {
+ ATH_MSG_WARNING("Cannot extract the single tube calibrations for tube "<<m_idHelperSvc->toString(id));
+ return MdtCalibOutput{};
}
-
+ /// Retrieve the constants for the specific tube
+ const SingleTubeCalib* singleTubeData = calibConstants->tubeCalib->getCalib(id);
+ if (!singleTubeData) {
+ ATH_MSG_WARNING("Failed to access tubedata for " << m_idHelperSvc->toString(id));
+ return MdtCalibOutput{};
+ }
+
+ MdtCalibOutput calibResult{};
// correct for global t0 of rt-region
- t0 += rtRelation->t0Global();
- hit.setTubeT0(t0);
- hit.setTubeAdcCal(adcCal);
-
- // in order to have clean info in the ntuple set to 0 the
- // corrections which are not used
- /* hit.setSlewingTime( 0 );
- hit.setLorentzTime( 0 );
- hit.setTemperatureTime( 0 );
- hit.setWiresagTime( 0 );*/
+
+ calibResult.setTubeT0(singleTubeData->t0 + rtRelation->t0Global());
+ calibResult.setMeanAdc(singleTubeData->adcCal);
+
// set propagation delay
- double propTime(0.);
- if ( settings.doProp ){
- // set propagation delay w.r.t. centre of tube.
- double distToRO = geo->distanceFromRO( hit.globalPointOfClosestApproach(), id );
- hit.setDistanceToReadout( distToRO );
- double propagationDistance = distToRO - geo->RODistanceFromTubeCentre( id );
- propTime = propagationDistance * inversePropSpeed;
+ if (m_doProp) {
+ const double propagationDistance = calibIn.signalPropagationDistance();
+ calibResult.setPropagationTime(singleTubeData->inversePropSpeed * propagationDistance);
}
- hit.setPropagationTime(propTime);
+
+ /// calculate drift time
+ const double driftTime = calibIn.tdc() * TdcBinSize
+ - (m_doTof ? calibIn.timeOfFlight() : 0.)
+ - calibIn.triggerTime()
+ - calibResult.tubeT0()
+ - calibResult.signalPropagationTime();
+
+ calibResult.setDriftTime(driftTime);
+ // apply corrections
+ double corrTime{0.};
+ const bool doCorrections = m_doField || m_doTemp || m_doBkg || m_doWireSag;
+ if (doCorrections) {
+ const CorrectionPtr& corrections{calibConstants->corrections};
+ const RtRelationPtr& rtRelation{calibConstants->rtRelation};
+ const MuonCalib::IRtRelation* rt = rtRelation->rt();
+ ATH_MSG_VERBOSE("There are correction functions.");
+ /// slewing corrections
+ if (m_doSlew && corrections->slewing()) {
+ double slewTime=corrections->slewing()->correction(calibResult.driftTime(), calibIn.adc());
+ corrTime -= slewTime;
+ calibResult.setSlewingTime(slewTime);
+ }
+
+
+ if (m_doField && corrections->bField()) {
+ MagField::AtlasFieldCache fieldCache{};
- // set time-of-flight
- double triggerTime = inputData.tof + inputData.triggerOffset;
- hit.setTimeOfFlight( settings.doTof ? triggerTime : 0. );
+ SG::ReadCondHandle<AtlasFieldCacheCondObj> readHandle{m_fieldCacheCondObjInputKey, ctx};
+ if (!readHandle.isValid()) {
+ ATH_MSG_FATAL("calibrate: Failed to retrieve AtlasFieldCacheCondObj with key " << m_fieldCacheCondObjInputKey.key());
+ throw std::runtime_error("No magnetic field could be retrieved");
+ }
+ readHandle->getInitializedCache(fieldCache);
+
+ Amg::Vector3D globalB{Amg::Vector3D::Zero()};
+ fieldCache.getField(calibIn.closestApproach().data(), globalB.data());
+ const Amg::Vector2D locBField = calibIn.projectMagneticField(globalB);
+ using BFieldComp = MdtCalibInput::BFieldComp;
+ calibResult.setLorentzTime(corrections->bField()->correction(calibResult.driftTime(),
+ locBField[BFieldComp::alongWire],
+ locBField[BFieldComp::alongTrack]));
+ corrTime -= calibResult.lorentzTime();
+ }
+ if(m_doTemp && rt && rt->HasTmaxDiff()) {
+ const int mL = id_helper.multilayer(id);
+ const double tempTime = MuonCalib::RtScaleFunction(calibResult.driftTime(),
+ mL == 2,
+ *rt);
+ calibResult.setTemperatureTime(tempTime);
+ corrTime-=calibResult.temperatureTime();
+ }
+ // background corrections (I guess this is never active)
+ if (m_doBkg && corrections->background()) {
+ double bgLevel{0.};
+ calibResult.setBackgroundTime(corrections->background()->correction(calibResult.driftTime(), bgLevel ));
+ corrTime += calibResult.backgroundTime();
+ }
+ /// Wire sag corrections
+ if (m_doWireSag && corrections->wireSag()) {
+ /// Retrieve the center of the sagged surface in global coordinates
+ const Amg::Vector3D& saggedSurfPos{calibIn.saggedSurfCenter()};
+ const Amg::Vector3D& nominalSurfPos{calibIn.surfaceCenter()};
+ /// Calculate the sagging as the difference of the point of closest approach to the
+ /// sagged center surface
+ const double deltaY = calibIn.closestApproach().y() - saggedSurfPos.y();
+
+ // sign of drift radius (for sag calculation) is +/- of track passes
+ // above/below wire
+ const double signedDriftRadius = deltaY*(std::abs(calibResult.driftRadius()/deltaY));
- // calculate drift time
- double driftTime = hit.tdcCount() * tdcBinSize() - hit.timeOfFlight()
- - hit.tubeT0() - hit.propagationTime();
- hit.setDriftTime( driftTime );
+ // calculate the magnitude of the wire sag
+ double effectiveSag = nominalSurfPos.y()
+ - saggedSurfPos.y();
- // apply corrections
- double corTime(0.);
- if ( settings.doCorrections() ) {
-
- MagField::AtlasFieldCache fieldCache;
- if (settings.doField) {
- //
- // For the moment, use Gaudi Hive for the event context - would need to be passed in from clients
- SG::ReadCondHandle<AtlasFieldCacheCondObj> readHandle{m_fieldCacheCondObjInputKey, Gaudi::Hive::currentContext()};
- const AtlasFieldCacheCondObj* fieldCondObj{*readHandle};
- if (fieldCondObj == nullptr) {
- ATH_MSG_ERROR("driftRadiusFromTime: Failed to retrieve AtlasFieldCacheCondObj with key " << m_fieldCacheCondObjInputKey.key());
- return false;
+ calibResult.setSaggingTime(corrections->wireSag()->correction(signedDriftRadius, effectiveSag));
+ // apply the correction
+ corrTime += calibResult.saggingTime();
}
- fieldCondObj->getInitializedCache (fieldCache);
- }
- corTime = m_imp->applyCorrections( fieldCache, hit, inputData, settings,
- adcCal, data.corrections, rtRelation->rt(), &msg(), &m_idHelperSvc->mdtIdHelper());
}
+ calibResult.setDriftTime(calibResult.driftTime() + corrTime);
+
// calculate drift radius + error
- double r(0.);
- double reso(1.);
- double t = hit.driftTime();
+ double r{0.}, reso{0.};
+ double t = calibResult.driftTime();
double t_inrange = t;
- bool calibOk = true;
- Muon::MdtDriftCircleStatus timeStatus = driftTimeStatus(t, rtRelation, settings);
- if( rtRelation->rt() ){
-
+ Muon::MdtDriftCircleStatus timeStatus = driftTimeStatus(t, *rtRelation);
+ if(rtRelation->rt()) {
r = rtRelation->rt()->radius(t);
-
// apply tUpper gshift
- if (m_imp->m_doTMaxShift) {
- float tShift = m_imp->m_tMaxShiftTool->getValue(id);
+ if (m_doTMaxShift) {
+ float tShift = m_tMaxShiftTool->getValue(id);
r = rtRelation->rt()->radius( t * (1 + tShift) );
}
-
// check whether drift times are within range, if not fix them to the min/max range
if ( t < rtRelation->rt()->tLower() ) {
t_inrange = rtRelation->rt()->tLower();
double rmin = rtRelation->rt()->radius( t_inrange );
double drdt = (rtRelation->rt()->radius( t_inrange + 30. ) - rmin)/30.;
- // now check whether we are outside the time window
- if ( timeStatus == Muon::MdtStatusBeforeSpectrum ) {
- t = rtRelation->rt()->tLower() - settings.timeWindowLowerBound();
- calibOk = false;
+ /// now check whether we are outside the time window
+ if (timeStatus == Muon::MdtStatusBeforeSpectrum) {
+ t = rtRelation->rt()->tLower() - m_timeWindowLowerBound;
}
-
// if we get here we are outside the rt range but inside the window.
- r = rmin + drdt*(t-t_inrange);
- if( r < m_imp->m_unphysicalHitRadiusLowerBound ) r = m_imp->m_unphysicalHitRadiusLowerBound;
+ r = std::max(rmin + drdt*(t-t_inrange), m_unphysicalHitRadiusLowerBound.value());
} else if( t > rtRelation->rt()->tUpper() ) {
t_inrange = rtRelation->rt()->tUpper();
double rmax = rtRelation->rt()->radius( t_inrange );
@@ -329,543 +264,200 @@ bool MdtCalibrationTool::driftRadiusFromTime( MdtCalibHit &hit,
// now check whether we are outside the time window
if ( timeStatus == Muon::MdtStatusAfterSpectrum ) {
- t = rtRelation->rt()->tUpper() + settings.timeWindowUpperBound();
- calibOk = false;
+ t = rtRelation->rt()->tUpper() + m_timeWindowUpperBound;
}
-
// if we get here we are outside the rt range but inside the window.
r = rmax + drdt*(t-t_inrange);
}
} else {
ATH_MSG_WARNING( "no rt found" );
+ return calibResult;
}
- if ( rtRelation->rtRes() ){
+ if (rtRelation->rtRes()) {
if (!resolFromRtrack) {
reso = rtRelation->rtRes()->resolution( t_inrange );
} else {
- bool out_of_bound_flag;
- reso = rtRelation->rtRes()->resolution(rtRelation->tr()->tFromR(std::abs(hit.signedDistanceToTrack()),
- out_of_bound_flag) );
+ bool boundFlag{false};
+ const double tFromR = rtRelation->tr()->tFromR(std::abs(calibIn.distanceToTrack()),
+ boundFlag);
+ reso = rtRelation->rtRes()->resolution(tFromR);
}
- }else{
+ } else {
ATH_MSG_WARNING( "no rtRes found" );
+ return calibResult;
}
- hit.setDriftRadius( r, reso );
-
+ calibResult.setDriftRadius(r, reso);
+ calibResult.setStatus(timeStatus);
// summary
- ATH_MSG_VERBOSE( "driftRadiusFromTime for tube " << m_idHelperSvc->mdtIdHelper().print_to_string(id)
- << (calibOk ? " OK" : "FAILED") );
- ATH_MSG_VERBOSE( " raw drift time " << hit.tdcCount() * tdcBinSize()
- << " TriggerOffset " << inputData.triggerOffset << endmsg
- << "Tof " << inputData.tof << " Propagation Delay "
- << hit.propagationTime() << " T0 " << hit.tubeT0()
- << " invProp " << inversePropSpeed << endmsg
- << "Drift time after corrections " << driftTime
- << " time cor " << corTime
- << " Drift radius " << hit.driftRadius()
- << " sigma " << hit.sigmaDriftRadius() );
-
-
- return calibOk;
-} //end MdtCalibrationTool::driftRadiusFromTime
-
-// + TWIN TUBES
-bool MdtCalibrationTool::twinPositionFromTwinHits( MdtCalibHit &hit,
- MdtCalibHit &secondHit,
- double signedTrackLength,
- double secondSignedTrackLength,
- bool &secondDigitIsPrompt,
- double triggerTime ) const {
- MdtCalibrationSvcInput inputData;
- inputData.tof = signedTrackLength*m_imp->m_inverseSpeedOfLight;
- inputData.triggerOffset = triggerTime;
-
- MdtCalibrationSvcInput secondInputData;
- secondInputData.tof = secondSignedTrackLength*m_imp->m_inverseSpeedOfLight;
- secondInputData.triggerOffset = triggerTime;
- return twinPositionFromTwinHits( hit, secondHit, inputData,
- secondInputData, m_imp->settings, secondDigitIsPrompt );
-}
-
-bool MdtCalibrationTool::twinPositionFromTwinHits( MdtCalibHit &hit,
- MdtCalibHit &secondHit,
- const MdtCalibrationSvcInput &inputData,
- const MdtCalibrationSvcInput &secondInputData,
- const MdtCalibrationSvcSettings &settings,
- bool &secondDigitIsPrompt ) const {
-
- // 13/02/2009 A.Koutsman: after discussion with P.Kluit rebuilt this function to use the standard way
- // of calibrating a MdtCalibHit with driftRadiusFromTime(...)
-
- driftRadiusFromTime( hit, inputData, settings );
- driftRadiusFromTime( secondHit, secondInputData, settings );
+ ATH_MSG_VERBOSE( "Calibration for tube " << m_idHelperSvc->toString(id)
+ <<" passed. "<<std::endl<<"Input: "<<calibIn<<std::endl<<"Extracted calib constants: "<<calibResult<<std::endl);
+ return calibResult;
+} //end MdtCalibrationTool::calibrate
+
+MdtCalibTwinOutput MdtCalibrationTool::calibrateTwinTubes(const EventContext& ctx,
+ const MdtCalibInput& primHit,
+ const MdtCalibInput& twinHit) const {
+
+ MdtCalibOutput primResult = calibrate(ctx, primHit);
+ MdtCalibOutput twinResult = calibrate(ctx, twinHit);
// get Identifier and MdtReadOutElement for twin tubes
- const Identifier &id = hit.identify();
- const Identifier &idSecond = secondHit.identify();
- const MuonGM::MdtReadoutElement *geo = hit.geometry();
- const MuonGM::MdtReadoutElement *geoSecond = secondHit.geometry();
-
+ const Identifier& primId = primHit.identify();
+ const Identifier& twinId = twinHit.identify();
// get 'raw' drifttimes of twin pair; we don't use timeofFlight or propagationTime cause they are irrelevant for twin coordinate
- double driftTime = hit.tdcCount()*tdcBinSize() - hit.tubeT0();
- double driftTimeSecond = secondHit.tdcCount()*tdcBinSize() - secondHit.tubeT0();
-
- if(!geo) {
- ATH_MSG_WARNING( "Geometry not set for first hit" );
- return false;
- }
- if(!geoSecond) {
- ATH_MSG_WARNING( "Geometry not set for second hit" );
- return false;
+ double primdriftTime = primHit.tdc()*TdcBinSize - primResult.tubeT0();
+ double twinDriftTime = twinHit.tdc()*TdcBinSize - twinResult.tubeT0();
+
+ /// Get the calibration constatns from the conditions store
+ SG::ReadCondHandle<MuonCalib::MdtCalibDataContainer> calibDataContainer{m_calibDbKey, ctx};
+ if (!calibDataContainer.isValid()){
+ ATH_MSG_FATAL(__FILE__<<":"<<__LINE__<<" Failed to retrieve the Mdt calibration constants "<<m_calibDbKey.fullKey());
+ throw std::runtime_error("No calibration constants could be retrieved");
}
// get calibration constants from DbTool
- MuonCalib::MdtFullCalibData data = m_dbTool->getCalibration( geo->identifyHash(), geo->detectorElementHash() );
- MuonCalib::MdtFullCalibData dataSecond = m_dbTool->getCalibration( geoSecond->identifyHash(), geoSecond->detectorElementHash() );
-
- double inversePropSpeed = m_imp->m_inversePropagationSpeed;
- double inversePropSpeedSecond = inversePropSpeed;
-
- // access t0 for the give tube
- if( data.tubeCalib ){
-
- const int ml = m_idHelperSvc->mdtIdHelper().multilayer(id)-1;
- const int layer = m_idHelperSvc->mdtIdHelper().tubeLayer(id)-1;
- const int tube = m_idHelperSvc->mdtIdHelper().tube(id)-1;
-
- if( ml<0 || layer<0 || tube<0 ){
- ATH_MSG_WARNING( "Oops negative index....." );
- return false;
- }
-
- // extract calibration constants for single tube
- const MuonCalib::MdtTubeCalibContainer::SingleTubeCalib *singleTubeData =
- data.tubeCalib->getCalib( ml, layer, tube );
- if ( singleTubeData ){
- inversePropSpeed = singleTubeData->inversePropSpeed;
- } else {
- ATH_MSG_WARNING( "failed to access tubedata for "
- << ml << " " << layer << " " << tube
- << " using defaults.. " );
- if ( geo )
- ATH_MSG_WARNING( "detel "
- << geo->getMultilayer() << " lay " << geo->getNLayers()
- << " tubes " << geo->getNtubesperlayer() );
- }
- } else {
- ATH_MSG_WARNING( "MdtTubeCalibContainer not found for "
- << m_idHelperSvc->mdtIdHelper().print_to_string( id ) );
- ATH_MSG_WARNING( "Tube cannot be calibrated!!" );
- return false;
+ const MuonCalib::MdtFullCalibData* data1st = calibDataContainer->getCalibData(primId, msgStream());
+ const MuonCalib::MdtFullCalibData* data2nd = calibDataContainer->getCalibData(twinId, msgStream());
+ if (!data1st || !data2nd) {
+ ATH_MSG_WARNING(__FILE__<<":"<<__LINE__<<" Failed to access calibration constants for tubes "<<
+ m_idHelperSvc->toString(primId)<<" & "<<m_idHelperSvc->toString(twinId));
+ return MdtCalibTwinOutput{};
}
-
- // access t0 for the given second tube
- if ( dataSecond.tubeCalib ){
- const int mlSecond = m_idHelperSvc->mdtIdHelper().multilayer(idSecond)-1;
- const int layerSecond = m_idHelperSvc->mdtIdHelper().tubeLayer(idSecond)-1;
- const int tubeSecond = m_idHelperSvc->mdtIdHelper().tube(idSecond)-1;
-
- if( mlSecond<0 || layerSecond<0 || tubeSecond<0 ){
- ATH_MSG_WARNING( "Oops negative index for second tube....." );
- return false;
- }
-
- // extract calibration constants for single tube
- const MuonCalib::MdtTubeCalibContainer::SingleTubeCalib *singleTubeDataSecond =
- dataSecond.tubeCalib->getCalib( mlSecond, layerSecond, tubeSecond );
- if ( singleTubeDataSecond ){
- inversePropSpeedSecond = singleTubeDataSecond->inversePropSpeed;
- } else {
- ATH_MSG_WARNING( "failed to access (second) tubedata for " << mlSecond
- << " " << layerSecond << " " << tubeSecond
- << " using defaults.. " );
- if ( geoSecond )
- ATH_MSG_WARNING( "detel " << geoSecond->getMultilayer()
- << " lay " << geoSecond->getNLayers()
- << " tubes " << geoSecond->getNtubesperlayer() );
- }
- } else {
- ATH_MSG_WARNING( "MdtTubeCalibContainer not found for "
- << m_idHelperSvc->mdtIdHelper().print_to_string( idSecond ) );
- ATH_MSG_WARNING( "Second tube cannot be calibrated!!!" );
- return false;
+ const SingleTubeCalib* calibSingleTube1st = data1st->tubeCalib->getCalib(primId);
+ const SingleTubeCalib* calibSingleTube2nd = data2nd->tubeCalib->getCalib(twinId);
+ if (!calibSingleTube1st || !calibSingleTube2nd) {
+ ATH_MSG_WARNING(__FILE__<<":"<<__LINE__<<" Failed to access calibration constants for tubes "<<
+ m_idHelperSvc->toString(primId)<<" & "<<m_idHelperSvc->toString(twinId));
+ return MdtCalibTwinOutput{};
}
- // define twin position and error
- double zTwin(0.);
- double errZTwin(0.);
- double twin_timedif(0.);
+ const double invPropSpeed1st{calibSingleTube1st->inversePropSpeed};
+ const double invPropSpeed2nd{calibSingleTube2nd->inversePropSpeed};
+ // define twin position and error
+ double zTwin{0.}, errZTwin{0.}, twin_timedif{0.};
// find out which tube was the prompt
// (= actually hit by the muon; not hit by the muon = twinhit_)
// in the formula for z_hit_from_twin we take as convention that
// twindif = twin_time - prompt_time
-
- Identifier prompthit_id = id;
- const MuonGM::MdtReadoutElement *prompthit_geo = geo;
- int prompthit_tdc = 0;
- int twinhit_tdc = 0;
- if ( driftTime < driftTimeSecond) {
- twin_timedif = driftTimeSecond - driftTime;
- //prompthit_tdc = hit.tdcCount(); prompthit_adc = adcCal;
- //twinhit_tdc = secondHit.tdcCount(); twinhit_adc = adcCalSecond;
- secondDigitIsPrompt = false;
- } else if (driftTimeSecond <= driftTime){
- prompthit_id = idSecond;
- prompthit_geo = geoSecond;
- twin_timedif = driftTime - driftTimeSecond;
- //prompthit_tdc = secondHit.tdcCount(); prompthit_adc = adcCalSecond;
- //twinhit_tdc = hit.tdcCount(); twinhit_adc = adcCal;
- secondDigitIsPrompt = true;
+ int prompthit_tdc{0}, twinhit_tdc{0};
+ bool firstIsPrompt{true};
+ if ( primdriftTime < twinDriftTime) {
+ twin_timedif = twinDriftTime - primdriftTime;
+ } else {
+ twin_timedif = primdriftTime - twinDriftTime;
+ firstIsPrompt = false;
}
// get tubelength and set HV-delay (~6ns)
-
- double tubelength = prompthit_geo->tubeLength(prompthit_id);
- double HVdelay = 6.;
+ const MdtCalibInput& primaryHit{(firstIsPrompt ? primHit : twinHit)};
+ const double tubelength = primaryHit.tubeLength();
+ constexpr double HVdelay = 6.;
// twin_timedif must be between min and max of possible time-difference
// between prompt and twin signals
- // accounting for 3 std.dev. of twin time resolution
- if ( twin_timedif < (HVdelay - 5.*m_imp->m_resTwin)
- || twin_timedif > (tubelength*inversePropSpeed
- + tubelength*inversePropSpeedSecond
- + HVdelay + 5.*m_imp->m_resTwin)){
- if (msgLvl(MSG::DEBUG)) {
+ // accounting for 5 std.dev. of twin time resolution
+ if ( twin_timedif < (HVdelay - 5.*m_resTwin) ||
+ twin_timedif > (tubelength*(invPropSpeed1st + invPropSpeed2nd)
+ + HVdelay + 5.*m_resTwin)){
ATH_MSG_DEBUG( " TIME DIFFERENCE OF TWIN PAIR OUT OF RANGE("
- << (HVdelay - 5.*m_imp->m_resTwin)
- << "-"
- << (tubelength*inversePropSpeed
- + tubelength*inversePropSpeedSecond
- + HVdelay + 5.*m_imp->m_resTwin)
- << ") time difference = "
- << twin_timedif );
- }
+ << (HVdelay - 5.*m_resTwin)<< "-"
+ << (tubelength*(invPropSpeed1st + invPropSpeed2nd) + HVdelay + 5.*m_resTwin)
+ << ") time difference = " << twin_timedif );
+
}
// Make ONLY a twin PrepData if twin time difference is physical (within tubelength)
- if (twin_timedif < (tubelength*inversePropSpeed
- + tubelength*inversePropSpeedSecond
- + HVdelay + 10.*m_imp->m_resTwin)){
+ if (twin_timedif < (tubelength* (invPropSpeed1st + invPropSpeed2nd)
+ + HVdelay + 10.*m_resTwin)){
//calculate local(!) z of the hit from twin tubes information
-
- double z_hit_sign_from_twin = ( 1 / (inversePropSpeed *2.))
- * (tubelength*inversePropSpeedSecond - twin_timedif + HVdelay) ;
-
- // Put twin hit always inside acceptance
+ double z_hit_sign_from_twin = ( 1 / (invPropSpeed2nd *2.)) *
+ (tubelength*invPropSpeed2nd -
+ twin_timedif + HVdelay) ;
+ /// Put twin hit always inside acceptance
if (z_hit_sign_from_twin < -tubelength/2.) {
- if (msgLvl(MSG::DEBUG)) {
- ATH_MSG_DEBUG( " TWIN HIT outside acceptance with time difference "
- << twin_timedif
- << " Z local hit " << z_hit_sign_from_twin
- << " Z local minimum " << -tubelength/2 );
- }
+ ATH_MSG_DEBUG( " TWIN HIT outside acceptance with time difference "
+ << twin_timedif
+ << " Z local hit " << z_hit_sign_from_twin
+ << " Z local minimum " << -tubelength/2 );
z_hit_sign_from_twin = - tubelength/2.;
}
// do sign management just like in MdtDigitizationTool.cxx
- double distRO = prompthit_geo->tubeFrame_localROPos(prompthit_id).z();
- double sign(-1.);
- if (distRO < 0.) sign = 1.;
-
- double z_hit_geo_from_twin = sign*z_hit_sign_from_twin;
+ const double z_hit_geo_from_twin = primaryHit.readOutSide() *z_hit_sign_from_twin;
zTwin = z_hit_geo_from_twin;
- errZTwin = m_imp->m_resTwin*inversePropSpeed;
-
- if (msgLvl(MSG::VERBOSE)) {
- ATH_MSG_VERBOSE( " TWIN TUBE "
- << " tube: " << m_idHelperSvc->mdtIdHelper().print_to_string(id)
- << " twintube: " << m_idHelperSvc->mdtIdHelper().print_to_string(idSecond)
- );
- ATH_MSG_VERBOSE( " prompthit tdc = " << prompthit_tdc//*TDCbinsize
- << " twinhit tdc = " << twinhit_tdc// *TDCbinsize
- << " tube driftTime = " << driftTime
- << " second tube driftTime = " << driftTimeSecond
- << " TWIN PAIR time difference = " << twin_timedif
- );
- ATH_MSG_VERBOSE( " z_hit_sign_from_twin = " << z_hit_sign_from_twin
- << " z_hit_geo_from_twin = " << z_hit_geo_from_twin
- << " with sign = " << sign
- << " distRO = " << distRO
- );
- }
-
- } // end if(twin_timedif < (tubelength*inversePropSpeed + tubelength*inversePropSpeedSecond + HVdelay + 10.*m_imp->m_resTwin)){
+ errZTwin = m_resTwin*invPropSpeed1st;
+
+ ATH_MSG_VERBOSE( " TWIN TUBE "
+ << " tube: " << m_idHelperSvc->toString(primId)
+ << " twintube: " << m_idHelperSvc->toString(twinId)<<endmsg
+ << " prompthit tdc = " << prompthit_tdc//*TDCbinsize
+ << " twinhit tdc = " << twinhit_tdc// *TDCbinsize
+ << " tube driftTime = " << primResult
+ << " second tube driftTime = " << twinResult
+ << " TWIN PAIR time difference = " << twin_timedif << endmsg
+ << " z_hit_sign_from_twin = " << z_hit_sign_from_twin
+ << " z_hit_geo_from_twin = " << z_hit_geo_from_twin);
+
+ } // end if(twin_timedif < (tubelength*inversePropSpeed + tubelength*inversePropSpeedSecond + HVdelay + 10.*m_resTwin)){
else {
-
- if (msgLvl(MSG::VERBOSE)) {
- ATH_MSG_VERBOSE( " TIME DIFFERENCE OF TWIN PAIR UNPHYSICAL OUT OF RANGE("
- << (HVdelay - 5*m_imp->m_resTwin) << "-"
- << (2*tubelength*inversePropSpeed + HVdelay + 5*m_imp->m_resTwin)
- << ") time difference = "
- << twin_timedif );
- }
+ ATH_MSG_VERBOSE( " TIME DIFFERENCE OF TWIN PAIR UNPHYSICAL OUT OF RANGE("
+ << (HVdelay - 5*m_resTwin) << "-"
+ << (2*tubelength*invPropSpeed1st + HVdelay + 5*m_resTwin)
+ << ") time difference = "
+ << twin_timedif );
zTwin = 0.;
errZTwin = tubelength/2.;
}
- hit.setLocXtwin( zTwin );
- hit.setSigma2LocXtwin( errZTwin*errZTwin );
- secondHit.setLocXtwin( zTwin );
- secondHit.setSigma2LocXtwin( errZTwin*errZTwin );
-
- return true;
-} //end MdtCalibrationTool::twinPositionFromTwinHits
-
-double MdtCalibrationTool::tdcBinSize() const {
- return 0.78125; //25/32; exact number: (1000.0/40.079)/32.0
-}
-
-double MdtCalibrationTool::Imp::applyCorrections(MagField::AtlasFieldCache& fieldCache,
- MdtCalibHit &hit,
- const MdtCalibrationSvcInput &inputData,
- const MdtCalibrationSvcSettings &settings,
- double /*adcCal*/,
- const MuonCalib::MdtCorFuncSet *corrections, const MuonCalib::IRtRelation *rt, MsgStream *msgStr, const MdtIdHelper *idHelp) const {
-
- double corTime(0.);
- // apply corrections
- if ( corrections ){
-
- if (msgStr->level()<=MSG::VERBOSE) *msgStr << MSG::VERBOSE << "There are correction functions." << endmsg;
-
- // slewing corrections
- if ( settings.doSlew && corrections->slewing() ){
- double slew_time=corrections->slewing()->correction( hit.driftTime(), hit.adcCount());
- corTime -=slew_time;
- hit.setSlewingTime(slew_time);
- }
-
- if( settings.doField && corrections->bField()){
- if( inputData.trackDirection && inputData.pointOfClosestApproach ) {
- Amg::Transform3D gToStation = hit.geometry()->GlobalToAmdbLRSTransform();
- double BGXYZ[3];
- double xyz[3] = { (*inputData.pointOfClosestApproach)(0),
- (*inputData.pointOfClosestApproach)(1),
- (*inputData.pointOfClosestApproach)(2) };
- fieldCache.getField(xyz, BGXYZ);
-
- for (double & i : BGXYZ) i *= 1000.; // convert kT to Tesla
- Amg::Vector3D B_global(BGXYZ[0], BGXYZ[1], BGXYZ[2]);
- Amg::Vector3D B_loc(gToStation.linear()*B_global);
- double Bpar = B_loc.x();
- Amg::Vector3D loc_dir(gToStation.linear()*(*(inputData.trackDirection)));
- Amg::Vector3D dir(0.0, loc_dir.y(), loc_dir.z());
- double Bper = B_loc.dot(dir.unit());
- hit.setBFieldPerp(Bper);
- hit.setBFieldPara(Bpar);
- if(msgStr->level()<=MSG::VERBOSE) *msgStr << MSG::VERBOSE << "doing b-field correction" << endmsg;
- if(hit.bFieldPara() != MdtCalibHit::kNoValue && hit.bFieldPerp() != MdtCalibHit::kNoValue) {
- hit.setLorentzTime(corrections->bField()->correction( hit.driftTime(), hit.bFieldPara(), hit.bFieldPerp() ));
- } else {
- hit.setLorentzTime(0);
- }
- corTime -= hit.lorentzTime();
- }
- }
-
- // temperature corrections
- // NOTE: Use this temporarily for ML dependent scaling.
- /* if ( settings.doTemp && corrections->temperature() ){
- if(hit.temperature() != MdtCalibHit::kNoValue)
- {
- hit.setTemperatureTime(corrections->temperature()->correction( hit.driftTime(), hit.temperature()));
- }
- else
- {
- hit.setTemperatureTime(0);
- }
- corTime += hit.TemperatureTime();
- }*/
-
- // Scale RT function from Tmax difference
- if( settings.doTemp && rt && rt->HasTmaxDiff()) {
- float scle_time=MuonCalib::RtScaleFunction(hit.driftTime(), idHelp->multilayer(hit.identify())==2, *rt);
- hit.setTemperatureTime(scle_time);
- corTime-=scle_time;
- } else {
- hit.setTemperatureTime(0);
- }
-
- // background corrections
- if ( settings.doBkg && corrections->background() ){
- double bgLevel = 0.;
- corTime += corrections->background()->correction( hit.driftTime(), bgLevel );
- }
-
- // wire sag corrections
- // First some debug output
- if (msgStr->level()<=MSG::VERBOSE) {
- if ( settings.doWireSag ){
- *msgStr << MSG::VERBOSE << "settings.doWireSag == TRUE" << endmsg;
- } else {
- *msgStr << MSG::VERBOSE << "settings.doWireSag == FALSE" << endmsg;
- }
- if ( corrections->wireSag() ){
- *msgStr << MSG::VERBOSE << "corrections->wireSag() == TRUE" << endmsg;
- } else {
- *msgStr << MSG::VERBOSE << "corrections->wireSag() == FALSE" << endmsg;
- }
- }
- // Wire sag corrections
- if ( settings.doWireSag && corrections->wireSag() ){
-
- if (msgStr->level()<=MSG::VERBOSE) {
- *msgStr << MSG::VERBOSE << "Performing Rt Corrections due to Wire Sag." << endmsg;
-
- if (inputData.pointOfClosestApproach) {
- *msgStr << MSG::VERBOSE << "Have a point of closest approach." << endmsg;
- } else {
- *msgStr << MSG::VERBOSE << "No point of closest approach!" << endmsg;
- }
- if (inputData.trackDirection) {
- *msgStr << MSG::VERBOSE << "Have a track direction." << endmsg;
- } else {
- *msgStr << MSG::VERBOSE << "No track direction!" << endmsg;
- }
- if (inputData.nominalWireSurface) {
- *msgStr << MSG::VERBOSE << "Have a nominal wire surface." << endmsg;
- } else {
- *msgStr << MSG::VERBOSE << "No nominal wire surface!" << endmsg;
- }
- if (inputData.wireSurface) {
- *msgStr << MSG::VERBOSE << "Have a sagged wire surface." << endmsg;
- } else {
- *msgStr << MSG::VERBOSE << "No sagged wire surface!" << endmsg;
- }
- }
-
- const Amg::Vector3D *pointOfClosestApproach = inputData.pointOfClosestApproach;
- const Amg::Vector3D *trackDirection = inputData.trackDirection;
- const Trk::StraightLineSurface *nominalWireSurface = inputData.nominalWireSurface;
- const Trk::StraightLineSurface *wireSurface = inputData.wireSurface;
-
- // check whether all input data is there
- if ( !pointOfClosestApproach || !trackDirection || !nominalWireSurface ){
- *msgStr << MSG::WARNING << " cannot perform wire sag correction: " << endmsg;
- if( !pointOfClosestApproach ) *msgStr << MSG::WARNING << " no pointOfClosestApproach " << endmsg;
- if( !trackDirection ) *msgStr << MSG::WARNING << " no trackDirection " << endmsg;
- if( !nominalWireSurface ) *msgStr << MSG::WARNING << " no nominalWireSurface " << endmsg;
- } else {
-
- if (msgStr->level()<=MSG::VERBOSE) {
- *msgStr << MSG::VERBOSE << "All Necessary Wire Sag data available: " << endmsg;
- *msgStr << MSG::VERBOSE << " pCA = ("
- << pointOfClosestApproach->x() << ", "
- << pointOfClosestApproach->y() << ", "
- << pointOfClosestApproach->z() << ")" << endmsg;
- }
-
- // store pointer to sagged surface as we get ownership if we recalculate it
- const Trk::StraightLineSurface *tempSaggedSurface = nullptr;
-
- // if wire surface is missing, calculate sagged wire position
- if ( !wireSurface ){
- const Trk::SaggedLineSurface *nominalSurf = dynamic_cast<const Trk::SaggedLineSurface*>(nominalWireSurface);
- if ( nominalSurf ){
- // Local position for calculation of position along the tube,
- // used for wire sag treatment
- std::optional<Amg::Vector2D> tempLocOnWire = nominalSurf->Trk::Surface::globalToLocal(*pointOfClosestApproach,1000.);
- if ( !tempLocOnWire ){
- *msgStr << MSG::WARNING << "globalToLocal failed! " << endmsg;
- } else {
- // sagged surface
- wireSurface = nominalSurf->correctedSurface(*tempLocOnWire);
- tempSaggedSurface = wireSurface;
- }
- } else {
- *msgStr << MSG::WARNING << "Nominal wire surface not a SaggedLineSurface,"
- << " cannot perform wire sag correction" << endmsg;
- }
- }
-
- if ( !wireSurface ){
- *msgStr << MSG::WARNING << " cannot perform wire sag correction: no sagged wire surface " << endmsg;
- } else {
-
- // get to transformation matrix from global into the tube frame
- Amg::Transform3D globalToTube = nominalWireSurface->transform().inverse();
-
- // calculate the local position of the nominal and sagged wire
- Amg::Vector3D locNominalPos(0.,0.,0.);
- Amg::Vector3D locSaggedPos = globalToTube*wireSurface->center();
- locSaggedPos[2] = 0.;
-
- // calculate the local track direction
- Amg::Vector3D locTrackDir = globalToTube.linear()*(*trackDirection);
- locTrackDir[2] = 0.;
- locTrackDir = locTrackDir.unit();
-
- // check if point of closest approach has been calculated
- // relative to nominal or sagged wire
-
- Amg::Vector3D locApproachDir(pointOfClosestApproach->x(),
- pointOfClosestApproach->y(),
- pointOfClosestApproach->z());
- double dotProd = locApproachDir.dot(locTrackDir);
- double deltaY = 0.;
- if (dotProd == 0){
- // this means the closest approach was calculated
- // from the nominal position
- deltaY = pointOfClosestApproach->y() - nominalWireSurface->center().y();
- } else {
- // this means the closest approach was calculated
- // from the sagged position
- deltaY = pointOfClosestApproach->y() - wireSurface->center().y();
- }
-
- // sign of drift radius (for sag calculation) is +/- of track passes
- // above/below wire
-
- double signedDriftRadius = deltaY*(std::abs(hit.driftRadius()/deltaY));
-
- // calculate the magnitude of the wire sag
-
- double effectiveSag = nominalWireSurface->center().y()
- - wireSurface->center().y();
-
- // apply the correction
-
- corTime += corrections->wireSag()->correction(signedDriftRadius, effectiveSag);
-
- }
- delete tempSaggedSurface;
- }
- }
-
- }
-
- hit.setDriftTime(hit.driftTime() + corTime);
-
- return corTime;
-} //end MdtCalibrationTool::Imp::applyCorrections
-
-Muon::MdtDriftCircleStatus MdtCalibrationTool::driftTimeStatus( double driftTime, const MuonCalib::MdtRtRelation *rtRelation, const MdtCalibrationSvcSettings &settings ) const {
- if( settings.timeWindowUpperBound() < 0. || settings.timeWindowLowerBound() < 0. ) {
- ATH_MSG_WARNING( " Unphysical time window detected, both ranges should be positive: "
- << " lower bound " << settings.timeWindowLowerBound()
- << " upper bound " << settings.timeWindowUpperBound() );
- }
-
- if( rtRelation && rtRelation->rt() ) {
- if( driftTime < rtRelation->rt()->tLower() - settings.timeWindowLowerBound() ) {
- // Will this produce too much output from ROT creators?
- if (msgLvl(MSG::VERBOSE))
- ATH_MSG_VERBOSE( " drift time outside time window "
- << driftTime << ". Mininum time = "
- << rtRelation->rt()->tLower() - settings.timeWindowLowerBound() );
- return Muon::MdtStatusBeforeSpectrum;
- } else if( driftTime > rtRelation->rt()->tUpper() + settings.timeWindowUpperBound() ) {
- if (msgLvl(MSG::VERBOSE))
- ATH_MSG_VERBOSE( " drift time outside time window "
- << driftTime << ". Maximum time = "
- << rtRelation->rt()->tUpper() + settings.timeWindowUpperBound() );
- return Muon::MdtStatusAfterSpectrum;
+ MdtCalibTwinOutput calibResult{(firstIsPrompt ? primHit : twinHit),
+ (firstIsPrompt ? twinHit : primHit),
+ (firstIsPrompt ? primResult : twinResult),
+ (firstIsPrompt ? twinResult : primResult)};
+
+
+ calibResult.setLocZ(zTwin, errZTwin);
+ return calibResult;
+}
+
+Muon::MdtDriftCircleStatus MdtCalibrationTool::driftTimeStatus(double driftTime,
+ const MuonCalib::MdtRtRelation& rtRelation ) const {
+ if (rtRelation.rt()) {
+ if(driftTime < rtRelation.rt()->tLower() - m_timeWindowLowerBound) {
+ ATH_MSG_VERBOSE( " drift time outside time window "
+ << driftTime << ". Mininum time = "
+ << rtRelation.rt()->tLower() - m_timeWindowLowerBound );
+ return Muon::MdtStatusBeforeSpectrum;
+ } else if (driftTime > rtRelation.rt()->tUpper() + m_timeWindowUpperBound) {
+ ATH_MSG_VERBOSE( " drift time outside time window "
+ << driftTime << ". Maximum time = "
+ << rtRelation.rt()->tUpper() + m_timeWindowUpperBound);
+ return Muon::MdtStatusAfterSpectrum;
}
} else {
ATH_MSG_WARNING( "No valid rt relation supplied for driftTimeStatus method" );
return Muon::MdtStatusUnDefined;
}
return Muon::MdtStatusDriftTime;
-} //end MdtCalibrationTool::driftTimeStatus
+}
+double MdtCalibrationTool::getResolutionFromRt(const EventContext& ctx, const Identifier& moduleID, const double time) const {
+
+ SG::ReadCondHandle<MuonCalib::MdtCalibDataContainer> calibConstants{m_calibDbKey, ctx};
+ if (!calibConstants.isValid()) {
+ ATH_MSG_FATAL("Failed to retrieve the calibration constants "<<m_calibDbKey.fullKey());
+ throw std::runtime_error("Where are my Mdt calibration constants");
+ }
+ const MuonCalib::MdtFullCalibData* moduleConstants = calibConstants->getCalibData(moduleID, msgStream());
+ if (!moduleConstants){
+ ATH_MSG_FATAL("Failed to retrieve set of calibration constants for "<<m_idHelperSvc->toString(moduleID));
+ throw std::runtime_error("No constants for calib container");
+ }
+ const RtRelationPtr& rtRel{moduleConstants->rtRelation};
+ if (!rtRel) {
+ ATH_MSG_FATAL("No rt-relation found for "<<m_idHelperSvc->toString(moduleID));
+ throw std::runtime_error("No rt relation ");
+ }
+ const double t = std::min(std::max(time, rtRel->rt()->tLower()), rtRel->rt()->tUpper());
+ return rtRel->rtRes()->resolution(t);
+}
\ No newline at end of file
diff --git a/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibSvc/src/MdtCalibrationTool.h b/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibSvc/src/MdtCalibrationTool.h
new file mode 100644
index 00000000000..fec29f1d0ab
--- /dev/null
+++ b/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibSvc/src/MdtCalibrationTool.h
@@ -0,0 +1,136 @@
+/*
+ Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef MDTCALIBSVC_MDTCALIBRATIONTOOL_H
+#define MDTCALIBSVC_MDTCALIBRATIONTOOL_H
+
+
+#include "MdtCalibInterfaces/IMdtCalibrationTool.h"
+
+#include "AthenaBaseComps/AthAlgTool.h"
+
+#include "MuonIdHelpers/IMuonIdHelperSvc.h"
+#include "MagFieldConditions/AtlasFieldCacheCondObj.h"
+#include "MdtCalibData/MdtCalibDataContainer.h"
+#include "MdtCalibInterfaces/IShiftMapTools.h"
+#include "GaudiKernel/SystemOfUnits.h"
+#include "GaudiKernel/PhysicalConstants.h"
+class MdtCalibHit;
+class MdtCalibToolInput;
+
+namespace MuonCalib {
+ class MdtRtRelation;
+}
+
+/**
+ @class MdtCalibrationTool
+ the Mdt Calib Service provides, on request, the drift radius and its
+ error, computed applying the proper calibration, for any hit in Mdt chambers
+ @author Martin Woudstra, Niels van Eldik
+*/
+
+
+
+class MdtCalibrationTool : public extends<AthAlgTool, IMdtCalibrationTool> {
+public:
+
+
+ using CorrectionPtr = MuonCalib::MdtFullCalibData::CorrectionPtr;
+ using RtRelationPtr = MuonCalib::MdtFullCalibData::RtRelationPtr;
+ using TubeContainerPtr = MuonCalib::MdtFullCalibData::TubeContainerPtr;
+
+
+ /** constructor */
+ MdtCalibrationTool(const std::string& type, const std::string &name, const IInterface* parent);
+
+ /** destructor */
+ virtual ~MdtCalibrationTool() = default;
+
+ /** initialization */
+ virtual StatusCode initialize() override final;
+
+ /** Convert the raw MDT time (+charge) into a drift radius + error.
+ It returns whether the conversion was successful.
+
+ @param[in,out] hit Hit must have pointer set to the MdtDigit,
+ as well as the global hit position (including the position along the tube!)
+ @param[in] signedTracklength the track length from the 'triggerpoint' to the hit.
+ It is used for the time-of-flight correction.
+ This triggerpoint is the I.P. for ATLAS p-p collisions,
+ typically scintillators in test-beam and cosmic teststands,
+ and not clear yet what is it is for cosmics in ATLAS.
+ The sign is for determining the sign of the time-of-flight correction.
+ If a muon first passes the triggerpoint, and then the MDT tube, the sign
+ should be positive (the case for ATLAS p-p and H8 test-beam).
+ If a muon first passes the MDT tube, and then de triggerpoint, the sign
+ should be negative (typically the case for cosmic-ray teststands).
+ @param[in] triggerTime the time of the 'triggerpoint' in ns. This is the time (measured with
+ the same clock as the MDT TDC's) when the muon passed a known point in
+ space: the 'triggerpoint'.
+ For ATLAS this is 0.0 since the TDC's are synchonised w.r.t. the bunch-crossings.
+ For H8 test-beam it is the trigger time, which is time when the muon passed
+ the trigger scintillators. For cosmic-ray teststands it is usually also the
+ time when the muon passed the trigger scintillators.
+ For cosmics in ATLAS it is not clear yet.
+ @param[in] resolFromRtrack indicates the method to provide the resolution as a function
+ of the distance of the reconstructed track from the anode wire instead of the drift
+ radius
+ */
+ virtual MdtCalibOutput calibrate(const EventContext& ctx,
+ const MdtCalibInput& hit,
+ bool resolFromRtrack=false) const override final;
+
+ /** Convert the raw MDT times of two twin hits into a Twin position (coordinate along tube)
+ It returns whether the conversion was successful. */
+ virtual MdtCalibTwinOutput calibrateTwinTubes(const EventContext& ctx,
+ const MdtCalibInput& hit,
+ const MdtCalibInput& twinHit) const override final;
+
+ virtual double getResolutionFromRt(const EventContext& ctx,
+ const Identifier& module,
+ const double time) const override final;
+ virtual ToolSettings getSettings() const override final;
+private:
+ Muon::MdtDriftCircleStatus driftTimeStatus(double driftTime,
+ const MuonCalib::MdtRtRelation& rtRelation) const;
+
+ Gaudi::Property<int> m_windowSetting{this, "TimeWindowSetting", timeWindowMode::Default};
+ Gaudi::Property<double> m_timeWindowLowerBound{this, "TimeWindowLowerBound", 0.};
+ Gaudi::Property<double> m_timeWindowUpperBound{this, "TimeWindowUpperBound", 0.};
+ Gaudi::Property<bool> m_doTof{this, "DoTofCorrection", true};
+ Gaudi::Property<bool> m_doProp{this, "DoPropagationCorrection", true};
+ Gaudi::Property<bool> m_doTemp{this, "DoTemperatureCorrection", false};
+ Gaudi::Property<bool> m_doField{this,"DoMagneticFieldCorrection", false};
+ Gaudi::Property<bool> m_doWireSag{this, "DoWireSagCorrection", false};
+ Gaudi::Property<bool> m_doSlew{this, "DoSlewingCorrection", false};
+ Gaudi::Property<bool> m_doBkg{this, "DoBackgroundCorrection", false};
+
+ /* T0 Shift tool -- Per-tube offsets of t0 value */
+ ToolHandle<MuonCalib::IShiftMapTools> m_t0ShiftTool{this, "T0ShiftTool", ""};
+ /* TMax Shift tool -- Per-tube offsets of Tmax */
+ ToolHandle<MuonCalib::IShiftMapTools> m_tMaxShiftTool{this, "TShiftMaxTool", ""};
+
+ // tools should only be retrieved if they are used
+ Gaudi::Property<bool> m_doT0Shift{this, "DoT0Shift", false};
+ Gaudi::Property<bool> m_doTMaxShift{this, "DoTMaxShift", false};
+
+ Gaudi::Property<double> m_unphysicalHitRadiusUpperBound{this, "UpperBoundHitRadius", 20.};
+ Gaudi::Property<double> m_unphysicalHitRadiusLowerBound{this, "LowerBoundHitRadius" , 0.};
+ Gaudi::Property<double> m_resTwin{this, "ResolutionTwinTube" , 1.05, "Twin tube resolution"};
+
+
+ SG::ReadCondHandleKey<MuonCalib::MdtCalibDataContainer> m_calibDbKey{this, "CalibDataKey", "MdtCalibConstants",
+ "Conditions object containing the calibrations"};
+
+ // Read handle for conditions object to get the field cache
+ // If one wants to avoid that adding of this read handle here, then client tools/algs calling driftRadiusFromTime
+ // must implement this to get the AtlasFieldCache which can then be passed through the call to driftRadiusFromTime
+ // Note: a readhandle must be in a tool or an alg, and so it cannot be in the class Imp.)
+ SG::ReadCondHandleKey<AtlasFieldCacheCondObj> m_fieldCacheCondObjInputKey {this, "AtlasFieldCacheCondObj", "fieldCondObj",
+ "Name of the Magnetic Field conditions object key"};
+ ServiceHandle<Muon::IMuonIdHelperSvc> m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"};
+
+};
+
+#endif
diff --git a/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibSvc/src/components/MdtCalibSvc_entries.cxx b/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibSvc/src/components/MdtCalibSvc_entries.cxx
index a026c810488..1fd9a920653 100644
--- a/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibSvc/src/components/MdtCalibSvc_entries.cxx
+++ b/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibSvc/src/components/MdtCalibSvc_entries.cxx
@@ -1,16 +1,12 @@
/*
- Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
+ Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
*/
-#include "MdtCalibSvc/MdtCalibrationTool.h"
-#include "MdtCalibSvc/MdtCalibrationRegionSvc.h"
-#include "MdtCalibSvc/MdtCalibrationDbTool.h"
-#include "MdtCalibSvc/MdtCalibrationT0ShiftTool.h"
-#include "MdtCalibSvc/MdtCalibrationTMaxShiftTool.h"
+#include "../MdtCalibrationTool.h"
+#include "../MdtCalibrationT0ShiftTool.h"
+#include "../MdtCalibrationTMaxShiftTool.h"
+
DECLARE_COMPONENT( MdtCalibrationTool )
-DECLARE_COMPONENT( MdtCalibrationRegionSvc )
-DECLARE_COMPONENT( MdtCalibrationDbTool )
DECLARE_COMPONENT( MdtCalibrationT0ShiftTool )
DECLARE_COMPONENT( MdtCalibrationTMaxShiftTool )
-
diff --git a/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibT0/src/T0CalibrationClassic.cxx b/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibT0/src/T0CalibrationClassic.cxx
index c893445f5a1..9dfa077f317 100644
--- a/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibT0/src/T0CalibrationClassic.cxx
+++ b/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibT0/src/T0CalibrationClassic.cxx
@@ -1,5 +1,5 @@
/*
- Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+ Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
*/
#include "MdtCalibT0/T0CalibrationClassic.h"
@@ -67,12 +67,14 @@ namespace MuonCalib {
bool ROside = distanceToRO < 130000.; // this means that there is no selection along the tube
if (ROside) {
const MuonFixedId &id = hit->identify();
-
+ const MdtIdHelper& idHelper{m_result->idHelperSvc()->mdtIdHelper()};
// get the T0 originally subtracted for this hit
int nML = id.mdtMultilayer();
int nL = id.mdtTubeLayer();
int nT = id.mdtTube();
- const MdtTubeFitContainer::SingleTubeCalib *stc = m_result->getCalib(nML - 1, nL - 1, nT - 1);
+ const Identifier tubeId = idHelper.channelID(id.stationNameString(), id.eta(), id.phi(),
+ nML, nL, nT);
+ const MdtTubeFitContainer::SingleTubeCalib *stc = m_result->getCalib(tubeId);
if (!stc) {
MsgStream log(Athena::getMessageSvc(), "T0ClassicSettings");
log << MSG::WARNING << "no Single Tube Calib info found for ML=" << nML << " L=" << nL << " T=" << nT << endmsg;
@@ -119,6 +121,7 @@ namespace MuonCalib {
MsgStream log(Athena::getMessageSvc(), "T0ClassicSettings");
if (log.level() <= MSG::INFO) log << MSG::INFO << "T0CalibrationClassic::analyse iteration " << m_currentItnum << endmsg;
+ const MdtIdHelper& idHelper{m_result->idHelperSvc()->mdtIdHelper()};
// loop over m_histos histograms
for (std::unique_ptr<T0ClassicHistos> &hist : m_histos) {
if (m_settings->fitTime()) {
@@ -132,10 +135,12 @@ namespace MuonCalib {
int nML = fId.mdtMultilayer();
int nL = fId.mdtTubeLayer();
int nT = fId.mdtTube();
-
- bool setInfo = m_result->setCalib(nML - 1, nL - 1, nT - 1, st);
+ const Identifier tubeId = idHelper.channelID(fId.stationNameString(), fId.eta(), fId.phi(),
+ nML, nL, nT);
+
+ bool setInfo = m_result->setCalib(std::move(st), tubeId, log);
if (!setInfo) log << MSG::WARNING << "T0CalibrationClassic::PROBLEM! could not set SingleTubeCalib info " << endmsg;
- setInfo = m_result->setFit(nML - 1, nL - 1, nT - 1, full);
+ setInfo = m_result->setFit(std::move(full), tubeId, log);
if (!setInfo) log << MSG::WARNING << "T0CalibrationClassic::PROBLEM! could not set SingleTubeFullInfo info " << endmsg;
}
}
diff --git a/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibT0/src/T0CalibrationMT.cxx b/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibT0/src/T0CalibrationMT.cxx
index 3bb3abac118..388ea4328cf 100644
--- a/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibT0/src/T0CalibrationMT.cxx
+++ b/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibT0/src/T0CalibrationMT.cxx
@@ -1,5 +1,5 @@
/*
- Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+ Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
*/
#include "MdtCalibT0/T0CalibrationMT.h"
@@ -74,7 +74,12 @@ namespace MuonCalib {
NtupleStationId sid(id);
sid.SetMultilayer(0);
std::map<NtupleStationId, MdtTubeFitContainer *>::const_iterator res_it(m_result.find(sid));
- if (res_it != m_result.end()) stc = res_it->second->getCalib(nML - 1, nL - 1, nT - 1);
+ if (res_it != m_result.end()) {
+ const MdtIdHelper& idHelper{res_it->second->idHelperSvc()->mdtIdHelper()};
+ const Identifier tubeId = idHelper.channelID(id.stationNameString(),
+ id.eta(), id.phi(), nML, nL, nT);
+ stc = res_it->second->getCalib(tubeId);
+ }
double oldT0 = 0;
if (stc)
oldT0 = stc->t0;
@@ -99,6 +104,7 @@ namespace MuonCalib {
}
bool T0CalibrationMT::analyse() {
+ MsgStream log(Athena::getMessageSvc(), "T0CalibrationMT");
std::map<int, MdtTubeFitContainer::SingleTubeFit> full;
std::map<int, MdtTubeFitContainer::SingleTubeCalib> st;
std::map<int, std::string> fit_by;
@@ -117,14 +123,17 @@ namespace MuonCalib {
int nML = fId.mdtMultilayer();
int nL = fId.mdtTubeLayer();
int nT = fId.mdtTube();
- bool setInfo = m_result[sid]->setCalib(nML - 1, nL - 1, nT - 1, stc);
+ const MdtIdHelper& idHelper{m_result[sid]->idHelperSvc()->mdtIdHelper()};
+ const Identifier tubeId = idHelper.channelID(fId.stationNameString(),
+ fId.eta(), fId.phi(), nML, nL, nT);
+
+ bool setInfo = m_result[sid]->setCalib(std::move(stc), tubeId, log);
if (!setInfo) {
- MsgStream log(Athena::getMessageSvc(), "T0CalibrationMT");
log << MSG::WARNING << "T0CalibrationMT::PROBLEM! could not set SingleTubeCalib info" << endmsg;
}
fi.n_hits = m_nhits_per_tube[fId.getIdInt()];
fi.n_hits_above_adc_cut = m_nhits_per_tube[fId.getIdInt()];
- setInfo = m_result[sid]->setFit(nML - 1, nL - 1, nT - 1, fi);
+ setInfo = m_result[sid]->setFit(std::move(fi), tubeId, log);
if (!setInfo) {
MsgStream log(Athena::getMessageSvc(), "T0CalibrationMT");
log << MSG::WARNING << "T0CalibrationMT::PROBLEM! could not set SingleTubeFit info" << endmsg;
diff --git a/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibUtils/MdtCalibUtils/GlobalTimeFitter.h b/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibUtils/MdtCalibUtils/GlobalTimeFitter.h
index c1aebb3fd65..b2b3299ecb3 100644
--- a/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibUtils/MdtCalibUtils/GlobalTimeFitter.h
+++ b/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibUtils/MdtCalibUtils/GlobalTimeFitter.h
@@ -8,7 +8,6 @@
#include <iostream>
#include "MdtCalibData/IRtRelation.h"
-#include "MdtCalibData/MdtCalibrationFactory.h"
#include "MdtCalibInterfaces/IMdtSegmentFitter.h"
#include "MuonCalibEvent/MdtCalibHit.h"
#include "MuonCalibEventBase/MuonCalibSegment.h"
@@ -24,7 +23,7 @@ namespace MuonCalib {
public:
GlobalTimeFitter(const IMdtSegmentFitter *fitter) : m_fitter(fitter) {}
GlobalTimeFitter(const IMdtSegmentFitter *fitter, const IRtRelation *rtRel) : m_fitter(fitter), m_rtRel(rtRel) {}
- ~GlobalTimeFitter() {}
+ ~GlobalTimeFitter() = default;
double GTFit(MuonCalibSegment *seg);
double GTFit2(MuonCalibSegment *seg);
diff --git a/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibUtils/MdtCalibUtils/TubeDataFromFile.h b/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibUtils/MdtCalibUtils/TubeDataFromFile.h
index db637a02b36..3d345867aac 100644
--- a/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibUtils/MdtCalibUtils/TubeDataFromFile.h
+++ b/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibUtils/MdtCalibUtils/TubeDataFromFile.h
@@ -23,10 +23,10 @@ namespace MuonCalib {
class TubeDataFromFile {
public:
- typedef std::vector<const MdtTubeFitContainer*> TubeData;
+ using TubeData = std::vector<const MdtTubeFitContainer*>;
public:
- TubeDataFromFile() : m_regions(0) {}
+ TubeDataFromFile() = default;
~TubeDataFromFile() = default;
/** return number of regions */
@@ -38,7 +38,7 @@ namespace MuonCalib {
MsgStream log(Athena::getMessageSvc(), "MdtTubeFitContainer");
log << MSG::WARNING << "TubeDataFromFile::getTubes: <regionId out of range> " << regionId << " size " << m_regions
<< endmsg;
- return 0;
+ return nullptr;
}
return m_tubeData[regionId];
}
@@ -70,11 +70,11 @@ namespace MuonCalib {
std::ostream& write(std::ostream& os) const;
- void write_forDB(FILE* ftube, int mdt_head, int lowrun, int uprun) const;
+ std::ostream& write_forDB(std::ostream& ftube, int mdt_head, int lowrun, int uprun) const;
private:
/** total number of regions */
- unsigned int m_regions;
+ unsigned int m_regions{0};
/** data */
TubeData m_tubeData;
diff --git a/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibUtils/src/GlobalTimeFitter.cxx b/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibUtils/src/GlobalTimeFitter.cxx
index 342716d059a..7516ae24194 100644
--- a/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibUtils/src/GlobalTimeFitter.cxx
+++ b/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibUtils/src/GlobalTimeFitter.cxx
@@ -3,7 +3,7 @@
*/
#include "MdtCalibUtils/GlobalTimeFitter.h"
-
+#include "MdtCalibData/MdtCalibrationFactory.h"
#include <sstream>
#include <string>
namespace {
diff --git a/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibUtils/src/TubeDataFromFile.cxx b/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibUtils/src/TubeDataFromFile.cxx
index 2d77e4cc2f9..c08085c1475 100644
--- a/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibUtils/src/TubeDataFromFile.cxx
+++ b/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibUtils/src/TubeDataFromFile.cxx
@@ -22,67 +22,54 @@ namespace MuonCalib {
}
os << "v0.0 " << m_regions << " ";
-
- for (unsigned int i = 0; i < m_tubeData.size(); ++i) {
- int eta = 0;
- int phi = 0;
- int technology = 0;
- if (m_tubeData[i]) {
- unsigned int nml = m_tubeData[i]->numMultilayers();
- unsigned int nl = m_tubeData[i]->numLayers();
- unsigned int nt = m_tubeData[i]->numTubes();
- std::string datatype = m_tubeData[i]->name();
- std::string implementation = m_tubeData[i]->implementation();
- // unpack regionKey
- std::string chamberName = m_tubeData[i]->regionKey();
- std::string stnName(chamberName, 0, 3);
- int separator1 = chamberName.find_first_of('_');
- int separator2 = chamberName.find_last_of('_');
- if ((separator2 - separator1) <= 3) {
- std::string stnPhi(chamberName, separator1 + 1, separator2 - separator1 - 1);
- std::string stnEta(chamberName, separator2 + 1, chamberName.size() - separator2 - 1);
- std::istringstream is1, is2;
- is1.str(stnEta);
- is1 >> eta;
- is2.str(stnPhi);
- is2 >> phi;
- } else {
- MsgStream log(Athena::getMessageSvc(), "MdtTubeFitContainer");
- log << MSG::WARNING << "TubeDataFromFile: can't unpack string " << chamberName << endmsg;
- }
-
- os << datatype << " " << implementation << " " << i << " " << nml * nl * nt << std::endl;
- for (unsigned int km = 0; km < nml; ++km) {
- for (unsigned int kl = 0; kl < nl; ++kl) {
- for (unsigned int kt = 0; kt < nt; ++kt) {
- const MdtTubeFitContainer::SingleTubeCalib* stc = m_tubeData[i]->getCalib(km, kl, kt);
- const MdtTubeFitContainer::SingleTubeFit* stf = m_tubeData[i]->getFit(km, kl, kt);
- double t0 = 999.;
- if (stc) {
- t0 = stc->t0;
- if (isnan(t0) != 0) t0 = -99999.;
- }
- os << " " << stnName << " " << phi << " " << eta << " " << technology << " " << km + 1 << " " << kl + 1
- << " " << kt + 1;
- if (stc)
- os
- //<< " " << stc->t0
- << " " << t0 << " " << stc->adcCal << " " << stc->statusCode;
- else
- os << " " << 0 << " " << 0 << " " << 0;
- if (stf)
- os << " " << stf->statistics << " " << stf->chi2Tdc << " " << stf->cov[4] // stf->t0Err
- << " " << stf->par[5] // stf->tMax
- << " " << stf->cov[5] // stf->tMaxErr
- << " " << stf->par[0] // stf->noise
- << " " << stf->cov[0] // stf->noiseErr
- << " " << stf->par[6] // stf->slope
- << " " << stf->cov[6]; // stf->slopeErr;
- else
- os << " " << -1 << " " << 0 << " " << 0 << " " << 0 << " " << 0 << " " << 0 << " " << 0 << " " << 0 << " "
- << 0;
- os << std::endl;
+ unsigned int counter{0};
+ for (const MdtTubeFitContainer* container : m_tubeData) {
+ if (!container) continue;
+ const unsigned int nml = container->numMultilayers();
+ const unsigned int nl = container->numLayers();
+ const unsigned int nt = container->numTubes();
+ const std::string datatype = container->name();
+ const std::string implementation = container->implementation();
+ const int stnEta = container->idHelperSvc()->stationEta(container->identify());
+ const int stnPhi = container->idHelperSvc()->stationPhi(container->identify());
+ const std::string stnName = container->idHelperSvc()->stationNameString(container->identify());
+ os << datatype << " " << implementation << " " << counter << " " << container->size() << std::endl;
+ ++counter;
+ const MdtIdHelper& id_helper{container->idHelperSvc()->mdtIdHelper()};
+ for (unsigned int km = 1; km <= nml; ++km) {
+ for (unsigned int kl = 1; kl <= nl; ++kl) {
+ for (unsigned int kt = 1; kt <= nt; ++kt) {
+ const Identifier chId{id_helper.channelID(container->identify(),km ,kl ,kt)};
+ const MdtTubeFitContainer::SingleTubeCalib* stc = container->getCalib(chId);
+ const MdtTubeFitContainer::SingleTubeFit* stf = container->getFit(chId);
+ double t0 = 999.;
+ if (stc) {
+ t0 = stc->t0;
+ if (std::isnan(t0) != 0) t0 = -99999.;
+ }
+ constexpr int technology = 0;
+ os << " " << stnName << " " << stnPhi << " " << stnEta
+ << " " << technology << " " << km << " " << kl << " " << kt;
+ if (stc) {
+ os << " " << t0 << " " << stc->adcCal << " " << stc->statusCode;
+ } else{
+ os << " " << 0 << " " << 0 << " " << 0;
+
}
+ if (stf)
+ os << " " << stf->statistics << " " << stf->chi2Tdc << " " << stf->cov[4] // stf->t0Err
+ << " " << stf->par[5] // stf->tMax
+ << " " << stf->cov[5] // stf->tMaxErr
+ << " " << stf->par[0] // stf->noise
+ << " " << stf->cov[0] // stf->noiseErr
+ << " " << stf->par[6] // stf->slope
+ << " " << stf->cov[6]; // stf->slopeErr;
+ else {
+ os << " " << -1 << " " << 0 << " " << 0 << " " << 0 << " "
+ << 0 << " " << 0 << " " << 0 << " " << 0 << " "
+ << 0;
+ }
+ os << std::endl;
}
}
}
@@ -90,7 +77,8 @@ namespace MuonCalib {
return os;
}
- void TubeDataFromFile::write_forDB(FILE* ftube, int mdt_head, int lowrun, int uprun) const {
+
+ std::ostream& TubeDataFromFile::write_forDB(std::ostream& ftube, int mdt_head, int lowrun, int uprun) const {
//////////////////////////////////////////////
// write out ascii files for Calibration DB //
//////////////////////////////////////////////
@@ -99,56 +87,43 @@ namespace MuonCalib {
log << MSG::WARNING << "TubeDataFromFile::write_forDB: <inconsistent count>" << endmsg;
}
- MuonFixedId fixId;
- // char * station;
- int tech, ml, l, t, sc, stat;
- double t0, adcm, chi2tdc, t0err, tmax, tmaxerr, noise, noiseerr, slope, sloperr;
- int tube_id, runflag = 0, validflag = 0;
-
- for (const auto *i : m_tubeData) {
- int eta = 0;
- int phi = 0;
- int technology = 0;
- if (i) {
- unsigned int nml = i->numMultilayers();
- unsigned int nl = i->numLayers();
- unsigned int nt = i->numTubes();
- std::string datatype = i->name();
- std::string implementation = i->implementation();
- // unpack regionKey
- std::string chamberName = i->regionKey();
- std::string stnName(chamberName, 0, 3);
- int separator1 = chamberName.find_first_of('_');
- int separator2 = chamberName.find_last_of('_');
- if ((separator2 - separator1) <= 3) {
- std::string stnPhi(chamberName, separator1 + 1, separator2 - separator1 - 1);
- std::string stnEta(chamberName, separator2 + 1, chamberName.size() - separator2 - 1);
- std::istringstream is1, is2;
- is1.str(stnEta);
- is1 >> eta;
- is2.str(stnPhi);
- is2 >> phi;
- } else {
- MsgStream log(Athena::getMessageSvc(), "MdtTubeFitContainer");
- log << MSG::WARNING << "TubeDataFromFile: can't unpack string " << chamberName << endmsg;
- }
-
- for (unsigned int km = 0; km < nml; ++km) {
- for (unsigned int kl = 0; kl < nl; ++kl) {
- for (unsigned int kt = 0; kt < nt; ++kt) {
- const MdtTubeFitContainer::SingleTubeCalib* stc = i->getCalib(km, kl, kt);
- const MdtTubeFitContainer::SingleTubeFit* stf = i->getFit(km, kl, kt);
- tech = technology;
- ml = km + 1;
- l = kl + 1;
- t = kt + 1;
-
- if (!fixId.setTechnology(tech) || !fixId.setStationName(fixId.stationStringToFixedStationNumber(stnName)) ||
- !fixId.setStationEta(eta) || !fixId.setStationPhi(phi) || !fixId.setMdtTube(t) ||
- !fixId.setMdtTubeLayer(l) || !fixId.setMdtMultilayer(ml)) {
- throw std::runtime_error(
- Form("File: %s, Line: %d\nTubeDataFromFile::write_forDB() - Setting identifier failed!", __FILE__,
- __LINE__));
+ for (const MdtTubeFitContainer* container : m_tubeData) {
+ if (!container) continue;
+ const unsigned int nml = container->numMultilayers();
+ const unsigned int nl = container->numLayers();
+ const unsigned int nt = container->numTubes();
+ const std::string datatype = container->name();
+ const std::string implementation = container->implementation();
+ const int stnEta = container->idHelperSvc()->stationEta(container->identify());
+ const int stnPhi = container->idHelperSvc()->stationPhi(container->identify());
+ const std::string stnName = container->idHelperSvc()->stationNameString(container->identify());
+
+ const MdtIdHelper& id_helper{container->idHelperSvc()->mdtIdHelper()};
+ for (unsigned int km = 1; km <= nml; ++km) {
+ for (unsigned int kl = 1; kl <= nl; ++kl) {
+ for (unsigned int kt = 1; kt <= nt; ++kt) {
+ const Identifier chId{id_helper.channelID(container->identify(),km ,kl ,kt)};
+ const MdtTubeFitContainer::SingleTubeCalib* stc = container->getCalib(chId);
+ const MdtTubeFitContainer::SingleTubeFit* stf = container->getFit(chId);
+ constexpr int technology = 0;
+
+ MuonFixedId fixId{};
+ int sc{0}, stat{-1};
+ double t0{0.}, adcm{0.}, chi2tdc{0.}, t0err{0.},
+ tmax{0.}, tmaxerr{0.}, noise{0.}, noiseerr{0.},
+ slope{0.}, sloperr{0.};
+ int tube_id{0}, runflag{0}, validflag{0};
+
+ if (!fixId.setTechnology(technology) ||
+ !fixId.setStationName(fixId.stationStringToFixedStationNumber(stnName)) ||
+ !fixId.setStationEta(stnEta) ||
+ !fixId.setStationPhi(stnPhi) ||
+ !fixId.setMdtTube(kt) ||
+ !fixId.setMdtTubeLayer(kl) ||
+ !fixId.setMdtMultilayer(km)) {
+ std::stringstream except{};
+ except<<__FILE__<<":"<<__LINE__<<"nTubeDataFromFile::write_forDB() - Setting identifier failed!";
+ throw std::runtime_error(except.str());
}
tube_id = fixId.getIdInt();
@@ -156,11 +131,7 @@ namespace MuonCalib {
t0 = stc->t0;
adcm = stc->adcCal;
sc = stc->statusCode;
- } else {
- t0 = 0.;
- adcm = 0;
- sc = 0;
- }
+ }
if (stf) {
stat = stf->statistics;
chi2tdc = stf->chi2Tdc;
@@ -171,57 +142,45 @@ namespace MuonCalib {
noiseerr = stf->cov[0];
slope = stf->par[6];
sloperr = stf->cov[6];
- } else {
- stat = -1;
- chi2tdc = 0;
- t0err = 0;
- tmax = 0;
- tmaxerr = 0;
- noise = 0;
- noiseerr = 0;
- slope = 0;
- sloperr = 0;
- }
+ }
- if (isnan(t0) != 0) t0 = -99999.;
+ if (std::isnan(t0) != 0) t0 = -99999.;
- fprintf(ftube, " %d,%d,%u,%d,%d,%d,%d,%d,%d,", mdt_head, tube_id, fixId.mdtChamberId().getIdInt(), lowrun,
- uprun, runflag, sc, validflag, stat);
+ ftube<<mdt_head<<","<<tube_id<<","<<fixId.mdtChamberId().getIdInt()<<","
+ <<","<<lowrun<<","<<uprun<<","<<runflag<<","<<sc
+ <<validflag<<","<<stat<<",";
for (int ii = -2; ii < 35; ii++) {
if (ii == -2) {
- fprintf(ftube, "%f,", chi2tdc);
+ ftube<<chi2tdc<<",";
} else if (ii == 0) {
- fprintf(ftube, "%f,", noise);
+ ftube<<noise<<",";
} else if (ii == 4) {
- fprintf(ftube, "%f,", t0);
+ ftube<<t0<<",";
} else if (ii == 5) {
- fprintf(ftube, "%f,", tmax);
+ ftube<<tmax<<",";
} else if (ii == 6) {
- fprintf(ftube, "%f,", slope);
+ ftube<<slope<<",";
} else if (ii == 10) {
- fprintf(ftube, "%f,", t0err);
+ ftube<<t0err<<",";
} else if (ii == 11) {
- fprintf(ftube, "%f,", tmaxerr);
+ ftube<<tmaxerr<<",";
} else if (ii == 12) {
- fprintf(ftube, "%f,", noiseerr);
+ ftube<<noiseerr<<",";
} else if (ii == 13) {
- fprintf(ftube, "%f,", sloperr);
+ ftube<<sloperr<<",";
} else if (ii == 14) {
- fprintf(ftube, "%f,", adcm);
+ ftube<<adcm<<",";
} else {
- fprintf(ftube, "%f,", 0.0);
+ ftube<<0.0<<",";
}
}
- fprintf(ftube, "%d,%d,", 0, 0);
- fprintf(ftube, "algoflag,");
- fprintf(ftube, "tubegrpgr\n");
+ ftube<<"0,0,algoflag,tubegrpgr"<<std::endl;
}
}
}
- }
}
- return;
+ return ftube;
}
} // namespace MuonCalib
diff --git a/MuonSpectrometer/MuonCalib/MuonCalibDbOperations/MuonCalibDbOperations/CalibT0DbOperations.h b/MuonSpectrometer/MuonCalib/MuonCalibDbOperations/MuonCalibDbOperations/CalibT0DbOperations.h
index 7b6bf02672b..8fec67028ad 100644
--- a/MuonSpectrometer/MuonCalib/MuonCalibDbOperations/MuonCalibDbOperations/CalibT0DbOperations.h
+++ b/MuonSpectrometer/MuonCalib/MuonCalibDbOperations/MuonCalibDbOperations/CalibT0DbOperations.h
@@ -1,10 +1,13 @@
/*
- Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+ Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
*/
#ifndef CalibT0DbOperations_h
#define CalibT0DbOperations_h
+#include <AthenaBaseComps/AthMessaging.h>
+#include <MuonIdHelpers/IMuonIdHelperSvc.h>
+#include <GaudiKernel/ServiceHandle.h>
#include <string>
#include <vector>
@@ -23,7 +26,7 @@ namespace MuonCalib {
class MuonFixedId;
class IConditionsStorage;
- class CalibT0DbOperations {
+ class CalibT0DbOperations: public AthMessaging {
public:
//=====================constructor - destructor=================================
CalibT0DbOperations(CalibDbConnection &db_conn);
@@ -42,16 +45,17 @@ namespace MuonCalib {
bool ReadForConditions(const std::string& site_name, int head_id, IConditionsStorage &storage);
private:
+ ServiceHandle<Muon::IMuonIdHelperSvc> m_idHelperSvc{"Muon::MuonIdHelperSvc/MuonIdHelperSvc", "CalibT0DbOperations"};
//=====================private data members====================================
// db connection
CalibDbConnection &m_db_conn;
- coral::IQuery *m_query;
+ coral::IQuery *m_query{nullptr};
//=====================private functions=======================================
- inline void initRowBuffer(std::vector<coral::AttributeList> &rowBuffer, const NtupleStationId &id, const int &head_id,
+ inline void initRowBuffer(std::vector<coral::AttributeList> &rowBuffer, const NtupleStationId &id, const int head_id,
const std::string &site_name, const MdtTubeFitContainer *t0);
- inline void fillRowBuffer(std::vector<coral::AttributeList> &rowBuffer, const MdtTubeFitContainer *t0, const int &ml1,
- const int &ly, const int &ml2, const MuonFixedId &fixId);
- bool setValidFlag(const std::string &site_name, const int &head_id, const int &tube_id, const int &new_validflag,
+ inline void fillRowBuffer(std::vector<coral::AttributeList> &rowBuffer, const MdtTubeFitContainer *t0, const int ml1,
+ const int ly, const int ml2, const MuonFixedId &fixId);
+ bool setValidFlag(const std::string &site_name, const int head_id, const int tube_id, const int new_validflag,
coral::ITableDataEditor &editor);
// insert all tubes of chamber
bool insertTubes(const std::string &site_name, int head_id, const NtupleStationId &id, const MdtTubeFitContainer *t0,
@@ -59,7 +63,7 @@ namespace MuonCalib {
bool setValidationFlag(const std::string &site_name, int head_id, const NtupleStationId &id, int from, int to,
coral::ITableDataEditor &editor);
// check if data already existsd in db
- inline bool checkTubesPresent(const int &head_id, const std::string &site_name, const NtupleStationId &id,
+ inline bool checkTubesPresent(const int head_id, const std::string &site_name, const NtupleStationId &id,
const std::vector<int> &validflag);
}; // class
diff --git a/MuonSpectrometer/MuonCalib/MuonCalibDbOperations/src/CalibT0DbOperations.cxx b/MuonSpectrometer/MuonCalib/MuonCalibDbOperations/src/CalibT0DbOperations.cxx
index 87bb166e10c..de550ddc1cd 100644
--- a/MuonSpectrometer/MuonCalib/MuonCalibDbOperations/src/CalibT0DbOperations.cxx
+++ b/MuonSpectrometer/MuonCalib/MuonCalibDbOperations/src/CalibT0DbOperations.cxx
@@ -1,15 +1,13 @@
/*
- Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+ Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
*/
#include "MuonCalibDbOperations/CalibT0DbOperations.h"
-#include "AthenaKernel/getMessageSvc.h"
#include "CoralBase/Attribute.h"
#include "CoralBase/AttributeList.h"
#include "CoralBase/AttributeSpecification.h"
#include "CoralKernel/Context.h"
-#include "GaudiKernel/MsgStream.h"
#include "MdtCalibData/MdtTubeFitContainer.h"
#include "MuonCalibDbOperations/CalibDbConnection.h"
#include "MuonCalibDbOperations/IConditionsStorage.h"
@@ -33,7 +31,10 @@
namespace MuonCalib {
- CalibT0DbOperations::CalibT0DbOperations(CalibDbConnection &db_conn) : m_db_conn(db_conn), m_query(nullptr) {}
+ CalibT0DbOperations::CalibT0DbOperations(CalibDbConnection &db_conn) :
+ AthMessaging{"CalibT0DbOperations"}, m_db_conn(db_conn) {
+ m_idHelperSvc.retrieve().ignore();
+ }
MdtStationT0Container *CalibT0DbOperations::LoadT0Calibration(const NtupleStationId &id, int head_id, std::string &site_name) {
try {
@@ -64,21 +65,20 @@ namespace MuonCalib {
count++;
}
if (count == 0) {
- MsgStream log(Athena::getMessageSvc(), "CalibT0DbOperations");
- log << MSG::WARNING << "No tubes found for " << id.regionId() << " Header " << site_name << head_id << endmsg;
+ ATH_MSG_WARNING( "No tubes found for " << id.regionId() << " Header " << site_name << head_id );
delete ret;
return nullptr;
}
return ret;
} // try
- catch (coral::SchemaException &e) {
- MsgStream log(Athena::getMessageSvc(), "CalibT0DbOperations");
- log << MSG::WARNING << "Schema exception : " << e.what() << endmsg;
+ catch (coral::SchemaException &e) {
+ ATH_MSG_WARNING( "Schema exception : " << e.what() );
return nullptr;
}
}
MdtTubeFitContainer *CalibT0DbOperations::LoadT0Validation(const NtupleStationId &id, int head_id, std::string & /*site_name*/) {
+ const MdtIdHelper& idHelper{m_idHelperSvc->mdtIdHelper()};
try {
m_db_conn.OpenTransaction();
m_query = m_db_conn.GetQuery();
@@ -164,22 +164,24 @@ namespace MuonCalib {
str_set = true;
}
}
+
// create output class
- MdtTubeFitContainer *ret = new MdtTubeFitContainer(id.regionId(), n_ml, n_layers, n_tubes);
- for (std::map<MuonFixedId, MdtTubeFitContainer::SingleTubeFit>::const_iterator it = fits.begin(); it != fits.end(); ++it) {
- int ml = it->first.mdtMultilayer() - 1;
- int ly = it->first.mdtTubeLayer() - 1;
- int tb = it->first.mdtTube() - 1;
- ret->setFit(ml, ly, tb, it->second);
- ret->setCalib(ml, ly, tb, calibs[it->first]);
+ const Identifier moduleID = idHelper.elementID(id.GetStation(), id.GetEta(), id.GetPhi());
+ MdtTubeFitContainer *ret = new MdtTubeFitContainer(m_idHelperSvc.get(), moduleID);
+ for (auto& [tubeId, tubeFit] : fits) {
+ const Identifier id = idHelper.channelID(moduleID,
+ tubeId.mdtMultilayer(),
+ tubeId.mdtTubeLayer(),
+ tubeId.mdtTube());
+ ret->setFit(std::move(tubeFit), id, msg());
+ ret->setCalib(std::move(calibs[tubeId]), id, msg());
}
ret->setGroupBy(tb_grp);
ret->setImplementation(alg_flg);
return ret;
} // try
- catch (coral::SchemaException &e) {
- MsgStream log(Athena::getMessageSvc(), "CalibT0DbOperations");
- log << MSG::WARNING << "Schema exception : " << e.what() << endmsg;
+ catch (coral::SchemaException &e) {
+ ATH_MSG_WARNING( "Schema exception : " << e.what() );
return nullptr;
}
}
@@ -188,10 +190,9 @@ namespace MuonCalib {
int head_id, const std::string &site_name) {
try {
m_db_conn.OpenTransaction();
- if (!checkTubesPresent(head_id, site_name, id, validation_flag)) {
- MsgStream log(Athena::getMessageSvc(), "CalibT0DbOperations");
- log << MSG::WARNING << "Trying to insert data for chamber " << id.regionId() << " header " << head_id << site_name
- << " which already exists!" << endmsg;
+ if (!checkTubesPresent(head_id, site_name, id, validation_flag)) {
+ ATH_MSG_WARNING( "Trying to insert data for chamber " << id.regionId() << " header " << head_id << site_name
+ << " which already exists!" );
m_db_conn.Rollback();
return false;
}
@@ -243,14 +244,14 @@ namespace MuonCalib {
fixId.setStationName(id.GetStation());
fixId.setStationEta(id.GetEta());
fixId.setStationPhi(id.GetPhi());
- for (unsigned int ml = 0; ml < nml; ml++) {
- for (unsigned int ly = 0; ly < nly; ly++) {
- for (unsigned int tb = 0; tb < ntb; tb++) {
- int tb_index = tb + ntb * ly + ntb * nly * ml;
+ for (unsigned int ml = 1; ml <= nml; ml++) {
+ for (unsigned int ly = 1; ly <= nly; ly++) {
+ for (unsigned int tb = 1; tb <= ntb; tb++) {
+ int tb_index = (tb -1) + ntb * (ly -1) + ntb * nly * (ml -1);
if (validation_flag[tb_index] == 3) continue;
- fixId.setMdtTube(tb + 1);
- fixId.setMdtTubeLayer(ly + 1);
- fixId.setMdtMultilayer(ml + 1);
+ fixId.setMdtTube(tb);
+ fixId.setMdtTubeLayer(ly);
+ fixId.setMdtMultilayer(ml);
// new tubes or tubes that are validated bad are inserted
int rowsUpdated;
if (validation_flag[tb_index] == 5)
@@ -259,9 +260,8 @@ namespace MuonCalib {
rowsUpdated = setValidFlag(site_name, head_id, fixId.getIdInt(), 1, *editor[0]);
if (rowsUpdated != 1) {
- MsgStream log(Athena::getMessageSvc(), "CalibT0DbOperations");
- log << MSG::WARNING << id.regionId() << " tb=" << tb << " ly=" << ly << " ml=" << ml << " head_id=" << head_id
- << ": " << rowsUpdated << " Rows to be updated! This is wrong! Check database!" << endmsg;
+ ATH_MSG_WARNING( id.regionId() << " tb=" << tb << " ly=" << ly << " ml=" << ml << " head_id=" << head_id
+ << ": " << rowsUpdated << " Rows to be updated! This is wrong! Check database!" );
m_db_conn.Rollback();
return false;
}
@@ -292,8 +292,7 @@ namespace MuonCalib {
return true;
} // try
catch (coral::SchemaException &e) {
- MsgStream log(Athena::getMessageSvc(), "CalibT0DbOperations");
- log << MSG::WARNING << "Schema exception : " << e.what() << endmsg;
+ ATH_MSG_WARNING( "Schema exception : " << e.what() );
m_db_conn.Rollback();
return false;
}
@@ -360,14 +359,13 @@ namespace MuonCalib {
if (!storage.StoreT0Chamber(old_chamber_id, rows_of_a_chamber)) { return false; }
return true;
} catch (coral::SchemaException &e) {
- MsgStream log(Athena::getMessageSvc(), "CalibT0DbOperations");
- log << MSG::WARNING << "Schema exception : " << e.what() << endmsg;
+ ATH_MSG_WARNING( "Schema exception : " << e.what() );
return false;
}
}
inline void CalibT0DbOperations::initRowBuffer(std::vector<coral::AttributeList> &rowBuffer, const NtupleStationId &id,
- const int &head_id, const std::string & /*site_name*/, const MdtTubeFitContainer *t0) {
+ const int head_id, const std::string & /*site_name*/, const MdtTubeFitContainer *t0) {
for (unsigned int i = 0; i < 3; i++) {
rowBuffer[i].extend<int>("TUBE_ID");
rowBuffer[i].extend<int>("HEAD_ID");
@@ -417,14 +415,20 @@ namespace MuonCalib {
}
inline void CalibT0DbOperations::fillRowBuffer(std::vector<coral::AttributeList> &rowBuffer, const MdtTubeFitContainer *t0,
- const int &ml, const int &ly, const int &tb, const MuonFixedId &fixId) {
+ const int ml, const int ly, const int tb, const MuonFixedId &fixId) {
+ const MdtIdHelper& idHelper{m_idHelperSvc->mdtIdHelper()};
+ const Identifier channelID = idHelper.channelID(fixId.stationName(),
+ fixId.eta(),
+ fixId.phi(),
+ ml, ly, tb);
+
for (unsigned int i = 0; i < 3; i++) { rowBuffer[i]["TUBE_ID"].data<int>() = fixId.getIdInt(); }
- rowBuffer[1]["ENTRIES"].data<int>() = t0->getFit(ml, ly, tb)->statistics;
- rowBuffer[1]["CHISQUARE_1"].data<float>() = t0->getFit(ml, ly, tb)->chi2Tdc;
- rowBuffer[1]["CHISQUARE_2"].data<float>() = t0->getFit(ml, ly, tb)->chi2TdcEnd;
- rowBuffer[1]["TUBE_GROUPING"].data<std::string>() = t0->getFit(ml, ly, tb)->group_by;
+ rowBuffer[1]["ENTRIES"].data<int>() = t0->getFit(channelID)->statistics;
+ rowBuffer[1]["CHISQUARE_1"].data<float>() = t0->getFit(channelID)->chi2Tdc;
+ rowBuffer[1]["CHISQUARE_2"].data<float>() = t0->getFit(channelID)->chi2TdcEnd;
+ rowBuffer[1]["TUBE_GROUPING"].data<std::string>() = t0->getFit(channelID)->group_by;
for (int i = 0; i < 8; i++) {
- double val = t0->getFit(ml, ly, tb)->par[i];
+ double val = t0->getFit(channelID)->par[i];
if (std::isnan(val)) val = -99999.;
std::ostringstream ostr2;
ostr2 << "P" << i;
@@ -433,7 +437,7 @@ namespace MuonCalib {
else
rowBuffer[1][ostr2.str()].data<float>() = val;
ostr2 << "_ERR";
- val = t0->getFit(ml, ly, tb)->cov[i];
+ val = t0->getFit(channelID)->cov[i];
if (std::isnan(val)) val = -99999.;
if (i > 3 && i < 7)
rowBuffer[1][ostr2.str()].data<float>() = val;
@@ -443,19 +447,19 @@ namespace MuonCalib {
for (int i = 0; i < 4; i++) {
std::ostringstream ostr2;
ostr2 << "ADC_" << i;
- rowBuffer[0][ostr2.str()].data<float>() = t0->getFit(ml, ly, tb)->adc_par[i];
+ rowBuffer[0][ostr2.str()].data<float>() = t0->getFit(channelID)->adc_par[i];
ostr2 << "_ERR";
- rowBuffer[2][ostr2.str()].data<float>() = t0->getFit(ml, ly, tb)->adc_err[i];
+ rowBuffer[2][ostr2.str()].data<float>() = t0->getFit(channelID)->adc_err[i];
}
- rowBuffer[2]["ADC_CHISQUARE"].data<float>() = t0->getFit(ml, ly, tb)->adc_chi2;
- rowBuffer[0]["NHITS"].data<int>() = t0->getFit(ml, ly, tb)->n_hits;
- if (t0->getFit(ml, ly, tb)->n_hits > 999999) rowBuffer[0]["NHITS"].data<int>() = 999999;
- rowBuffer[0]["NHITS_ABOVE_ADC_CUT"].data<int>() = t0->getFit(ml, ly, tb)->n_hits_above_adc_cut;
- if (t0->getFit(ml, ly, tb)->n_hits_above_adc_cut > 999999) rowBuffer[0]["NHITS_ABOVE_ADC_CUT"].data<int>() = 999999;
+ rowBuffer[2]["ADC_CHISQUARE"].data<float>() = t0->getFit(channelID)->adc_chi2;
+ rowBuffer[0]["NHITS"].data<int>() = t0->getFit(channelID)->n_hits;
+ if (t0->getFit(channelID)->n_hits > 999999) rowBuffer[0]["NHITS"].data<int>() = 999999;
+ rowBuffer[0]["NHITS_ABOVE_ADC_CUT"].data<int>() = t0->getFit(channelID)->n_hits_above_adc_cut;
+ if (t0->getFit(channelID)->n_hits_above_adc_cut > 999999) rowBuffer[0]["NHITS_ABOVE_ADC_CUT"].data<int>() = 999999;
}
- bool CalibT0DbOperations::setValidFlag(const std::string & /*site_name*/, const int &head_id, const int &tube_id,
- const int &new_validflag, coral::ITableDataEditor &editor) {
+ bool CalibT0DbOperations::setValidFlag(const std::string & /*site_name*/, const int head_id, const int tube_id,
+ const int new_validflag, coral::ITableDataEditor &editor) {
std::string updateAction = "validflag = :newval";
std::string updateCondition = "head_id=:hid and tube_id=:tid and validflag=0";
coral::AttributeList updateData;
@@ -482,10 +486,13 @@ namespace MuonCalib {
unsigned int ntb = t0->numTubes();
// do not insert completely dead chambers
bool all_dead(true);
- for (unsigned int ml = 0; ml < nml; ml++) {
- for (unsigned int ly = 0; ly < nly; ly++) {
- for (unsigned int tb = 0; tb < ntb; tb++) {
- if (t0->getFit(ml, ly, tb)->statistics > 0) {
+ const MdtIdHelper& idHelper{m_idHelperSvc->mdtIdHelper()};
+ const Identifier elementID = idHelper.elementID(id.GetStation(), id.GetEta(), id.GetPhi());
+ for (unsigned int ml = 1; ml <= nml; ml++) {
+ for (unsigned int ly = 1; ly <= nly; ly++) {
+ for (unsigned int tb = 1; tb <= ntb; tb++) {
+ const Identifier channelID = idHelper.channelID(elementID, ml, ly, tb);
+ if (t0->getFit(channelID)->statistics > 0) {
all_dead = false;
break;
}
@@ -493,8 +500,7 @@ namespace MuonCalib {
}
}
if (all_dead) {
- MsgStream log(Athena::getMessageSvc(), "CalibT0DbOperations");
- log << MSG::WARNING << "Refusing to insert completely dead chamber" << endmsg;
+ ATH_MSG_WARNING( "Refusing to insert completely dead chamber" );
return false;
}
MuonFixedId fixId(0);
@@ -502,13 +508,13 @@ namespace MuonCalib {
fixId.setStationName(id.GetStation());
fixId.setStationEta(id.GetEta());
fixId.setStationPhi(id.GetPhi());
- for (unsigned int ml = 0; ml < nml; ml++) {
- for (unsigned int ly = 0; ly < nly; ly++) {
- for (unsigned int tb = 0; tb < ntb; tb++) {
- int tb_index = tb + ntb * ly + ntb * nly * ml;
- fixId.setMdtTube(tb + 1);
- fixId.setMdtTubeLayer(ly + 1);
- fixId.setMdtMultilayer(ml + 1);
+ for (unsigned int ml = 1; ml <= nml; ml++) {
+ for (unsigned int ly = 1; ly <= nly; ly++) {
+ for (unsigned int tb = 1; tb <= ntb; tb++) {
+ int tb_index = (tb -1) + ntb * (ly -1) + ntb * nly * (ml -1);
+ fixId.setMdtTube(tb);
+ fixId.setMdtTubeLayer(ly);
+ fixId.setMdtMultilayer(ml);
int v_flag = 0;
if (static_cast<int>(validation_flag.size()) > tb_index) { v_flag = validation_flag[tb_index]; }
if (!row_buffer_initialized) {
@@ -551,7 +557,7 @@ namespace MuonCalib {
return (rowsUpdated <= 432);
}
- inline bool CalibT0DbOperations::checkTubesPresent(const int &head_id, const std::string & /*site_name*/, const NtupleStationId &id,
+ inline bool CalibT0DbOperations::checkTubesPresent(const int head_id, const std::string & /*site_name*/, const NtupleStationId &id,
const std::vector<int> &validflag) {
m_query = m_db_conn.GetQuery();
// select count(MDT_TUBE.TUBE_ID) as N_TUBES, MDT_TUBE.VALIDFLAG as VALIDFLAG from MDT_TUBE where MDT_TUBE.HEAD_ID = :hid and
diff --git a/MuonSpectrometer/MuonCalib/MuonCalibPatRec/CMakeLists.txt b/MuonSpectrometer/MuonCalib/MuonCalibPatRec/CMakeLists_disabled.txt
similarity index 100%
rename from MuonSpectrometer/MuonCalib/MuonCalibPatRec/CMakeLists.txt
rename to MuonSpectrometer/MuonCalib/MuonCalibPatRec/CMakeLists_disabled.txt
diff --git a/MuonSpectrometer/MuonCalib/MuonCalibStandAlone/MdtCalibIOSvc/CMakeLists.txt b/MuonSpectrometer/MuonCalib/MuonCalibStandAlone/MdtCalibIOSvc/CMakeLists_disabled.txt
similarity index 100%
rename from MuonSpectrometer/MuonCalib/MuonCalibStandAlone/MdtCalibIOSvc/CMakeLists.txt
rename to MuonSpectrometer/MuonCalib/MuonCalibStandAlone/MdtCalibIOSvc/CMakeLists_disabled.txt
diff --git a/MuonSpectrometer/MuonCnv/MuonCnvExample/python/MuonCalibConfig.py b/MuonSpectrometer/MuonCnv/MuonCnvExample/python/MuonCalibConfig.py
index 98445870c5b..0e29df29bee 100644
--- a/MuonSpectrometer/MuonCnv/MuonCnvExample/python/MuonCalibConfig.py
+++ b/MuonSpectrometer/MuonCnv/MuonCnvExample/python/MuonCalibConfig.py
@@ -167,7 +167,7 @@ def setupMdtCondDB():
else:
condSequence.MdtCalibDbAlg.ReadKeyTube = "/MDT/T0" + mdt_folder_name_appendix
condSequence.MdtCalibDbAlg.ReadKeyRt = "/MDT/RT" + mdt_folder_name_appendix
- condSequence.MdtCalibDbAlg.RT_InputFiles = ["Muon_RT_default.data"]
+ condSequence.MdtCalibDbAlg.RT_InputFile = "Muon_RT_default.data"
if globalflags.DataSource == 'data':
condSequence.MdtCalibDbAlg.defaultT0 = 40
elif globalflags.DataSource == 'geant4':
@@ -197,20 +197,9 @@ def MdtCalibrationTool(name="MdtCalibrationTool", **kwargs):
kwargs.setdefault("TimeWindowSetting", mdtCalibWindowNumber('Collision_G4'))
else: # cosmics or single beam
kwargs.setdefault("DoTofCorrection", False)
-
- kwargs.setdefault("CalibrationDbTool", MdtCalibrationDbTool())
return MdtCalibrationTool(name, **kwargs)
-def MdtCalibrationDbTool(name="MdtCalibrationDbTool", **kwargs):
- from MdtCalibSvc.MdtCalibSvcConf import MdtCalibrationDbTool
- kwargs.setdefault("CreateBFieldFunctions", mdtCalibFlags.correctMdtRtForBField())
- kwargs.setdefault("CreateWireSagFunctions", mdtCalibFlags.correctMdtRtWireSag())
- kwargs.setdefault("CreateSlewingFunctions", mdtCalibFlags.correctMdtRtForTimeSlewing())
- kwargs.setdefault("WasConfigured", True)
-
- return MdtCalibrationDbTool(name, **kwargs)
-
# return a list of dictionaires containing the calib config info (keys etc)
def getCalibConfigs():
diff --git a/MuonSpectrometer/MuonCnv/MuonEventTPCnv/MuonEventTPCnv/MuonRIO_OnTrack/MdtDriftCircleOnTrackCnv_p1.h b/MuonSpectrometer/MuonCnv/MuonEventTPCnv/MuonEventTPCnv/MuonRIO_OnTrack/MdtDriftCircleOnTrackCnv_p1.h
index 80b8f38f4be..420220ae05f 100755
--- a/MuonSpectrometer/MuonCnv/MuonEventTPCnv/MuonEventTPCnv/MuonRIO_OnTrack/MdtDriftCircleOnTrackCnv_p1.h
+++ b/MuonSpectrometer/MuonCnv/MuonEventTPCnv/MuonEventTPCnv/MuonRIO_OnTrack/MdtDriftCircleOnTrackCnv_p1.h
@@ -28,7 +28,7 @@ class MdtDriftCircleOnTrackCnv_p1
Muon::MdtDriftCircleOnTrack_p1 >
{
public:
- MdtDriftCircleOnTrackCnv_p1() : m_RIOCnv(0), m_surfCnv(0) {}
+ MdtDriftCircleOnTrackCnv_p1() =default;
void persToTrans( const Muon :: MdtDriftCircleOnTrack_p1 *persObj,
Muon :: MdtDriftCircleOnTrack *transObj,
@@ -38,8 +38,8 @@ public:
MsgStream &log );
protected:
- RIO_OnTrackCnv_p1* m_RIOCnv;
- StraightLineSurfaceCnv_p1* m_surfCnv;
+ RIO_OnTrackCnv_p1* m_RIOCnv{nullptr};
+ StraightLineSurfaceCnv_p1* m_surfCnv{nullptr};
ElementLinkCnv_p1< ElementLinkToIDC_MDT_Container > m_elCnv;
};
diff --git a/MuonSpectrometer/MuonCnv/MuonEventTPCnv/src/MuonRIO_OnTrack/MdtDriftCircleOnTrackCnv_p1.cxx b/MuonSpectrometer/MuonCnv/MuonEventTPCnv/src/MuonRIO_OnTrack/MdtDriftCircleOnTrackCnv_p1.cxx
index dfb1a4a8e38..77447872746 100755
--- a/MuonSpectrometer/MuonCnv/MuonEventTPCnv/src/MuonRIO_OnTrack/MdtDriftCircleOnTrackCnv_p1.cxx
+++ b/MuonSpectrometer/MuonCnv/MuonEventTPCnv/src/MuonRIO_OnTrack/MdtDriftCircleOnTrackCnv_p1.cxx
@@ -1,5 +1,5 @@
/*
- Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+ Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
*/
//-----------------------------------------------------------------------------
@@ -12,7 +12,6 @@
#include "MuonRIO_OnTrack/MuonDriftCircleErrorStrategy.h"
#include "MuonEventTPCnv/MuonRIO_OnTrack/MdtDriftCircleOnTrackCnv_p1.h"
-//nclude "TrkEventTPCnv/helpers/CLHEPHelpers.h"
#include <iostream>
void MdtDriftCircleOnTrackCnv_p1::
@@ -30,7 +29,7 @@ persToTrans( const Muon::MdtDriftCircleOnTrack_p1 *persObj,
if (persObj->m_rotCreationParameters&0x200) errorStrategy.setParameter(Muon::MuonDriftCircleErrorStrategy::WireSagTimeCorrection, true);
ElementLinkToIDC_MDT_Container rio;
- m_elCnv.persToTrans(&persObj->m_prdLink,&rio,log);
+ m_elCnv.persToTrans(&persObj->m_prdLink, &rio, log);
*transObj = Muon::MdtDriftCircleOnTrack (rio,
Trk::LocalParameters(),
@@ -41,10 +40,7 @@ persToTrans( const Muon::MdtDriftCircleOnTrack_p1 *persObj,
static_cast<Trk::DriftCircleStatus>( persObj->m_status ),
persObj->m_positionAlongWire,
persObj->m_localAngle,
- errorStrategy,
- this->createTransFromPStore( &m_surfCnv, persObj->m_saggedSurface, log )
- );
-
+ errorStrategy);
fillTransFromPStore( &m_RIOCnv, persObj->m_RIO, transObj, log );
}
diff --git a/MuonSpectrometer/MuonCnv/MuonEventTPCnv/src/MuonRIO_OnTrack/MdtDriftCircleOnTrackCnv_p2.cxx b/MuonSpectrometer/MuonCnv/MuonEventTPCnv/src/MuonRIO_OnTrack/MdtDriftCircleOnTrackCnv_p2.cxx
index c824a6cfeee..1bceb875838 100644
--- a/MuonSpectrometer/MuonCnv/MuonEventTPCnv/src/MuonRIO_OnTrack/MdtDriftCircleOnTrackCnv_p2.cxx
+++ b/MuonSpectrometer/MuonCnv/MuonEventTPCnv/src/MuonRIO_OnTrack/MdtDriftCircleOnTrackCnv_p2.cxx
@@ -1,5 +1,5 @@
/*
- Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+ Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
*/
//-----------------------------------------------------------------------------
@@ -13,7 +13,6 @@
#include "MuonEventTPCnv/MuonRIO_OnTrack/MdtDriftCircleOnTrackCnv_p2.h"
#include "TrkEventTPCnv/helpers/EigenHelpers.h"
-//nclude "TrkEventTPCnv/helpers/CLHEPHelpers.h"
#include <iostream>
void MdtDriftCircleOnTrackCnv_p2::
@@ -42,16 +41,10 @@ persToTrans( const Muon::MdtDriftCircleOnTrack_p2 *persObj,
static_cast<Trk::DriftCircleStatus>( persObj->m_status ),
persObj->m_positionAlongWire,
persObj->m_localAngle,
- Muon::MuonDriftCircleErrorStrategy (persObj->m_muonDriftCircleErrorStrategy),
- nullptr // surface
- );
-
+ Muon::MuonDriftCircleErrorStrategy (persObj->m_muonDriftCircleErrorStrategy));
// Attempt to call supertool to fill in detElements
m_eventCnvTool->recreateRIO_OnTrack(transObj);
- if (transObj->detectorElement()==nullptr)
- log << MSG::WARNING<<"Unable to reset DetEl for this RIO_OnTrack, "
- << "probably because of a problem with the Identifier/IdentifierHash : ("
- << transObj->identify()<<"/"<<transObj->idDE()<<endmsg;
+
}
void MdtDriftCircleOnTrackCnv_p2::
diff --git a/MuonSpectrometer/MuonCnv/MuonEventTPCnv/test/MdtDriftCircleOnTrackCnv_p2_test.cxx b/MuonSpectrometer/MuonCnv/MuonEventTPCnv/test/MdtDriftCircleOnTrackCnv_p2_test.cxx
index a79dba00b6e..f07d68ff5c5 100644
--- a/MuonSpectrometer/MuonCnv/MuonEventTPCnv/test/MdtDriftCircleOnTrackCnv_p2_test.cxx
+++ b/MuonSpectrometer/MuonCnv/MuonEventTPCnv/test/MdtDriftCircleOnTrackCnv_p2_test.cxx
@@ -151,8 +151,7 @@ void test1 ATLAS_NOT_THREAD_SAFE (const MuonGM::MuonDetectorManager& muo_dd)
Trk::DECIDED,
3.5,
4.5,
- strategy,
- nullptr); // surface
+ strategy); // surface
testit (trans1);
Athena_test::Leakcheck check;
diff --git a/MuonSpectrometer/MuonCnv/MuonMDT_CnvTools/src/MdtRdoToPrepDataToolMT.cxx b/MuonSpectrometer/MuonCnv/MuonMDT_CnvTools/src/MdtRdoToPrepDataToolMT.cxx
index f0c90b6ed26..3209ea4b978 100644
--- a/MuonSpectrometer/MuonCnv/MuonMDT_CnvTools/src/MdtRdoToPrepDataToolMT.cxx
+++ b/MuonSpectrometer/MuonCnv/MuonMDT_CnvTools/src/MdtRdoToPrepDataToolMT.cxx
@@ -10,21 +10,34 @@
#include "GaudiKernel/PhysicalConstants.h"
#include "GaudiKernel/ThreadLocalContext.h"
#include "GeoModelUtilities/GeoGetIds.h"
-#include "MdtCalibSvc/MdtCalibrationSvcInput.h"
#include "MdtRDO_Decoder.h"
-#include "MuonCalibEvent/MdtCalibHit.h"
#include "MuonPrepRawData/MdtTwinPrepData.h"
#include "MuonReadoutGeometry/MdtReadoutElement.h"
#include "MuonReadoutGeometry/MuonStation.h"
+#include "GeoPrimitives/GeoPrimitivesToStringConverter.h"
using namespace MuonGM;
using namespace Trk;
-using namespace Muon;
+
+using MdtDriftCircleStatus = MdtCalibOutput::MdtDriftCircleStatus;
+
namespace {
static constexpr double inverseSpeedOfLight = 1 / Gaudi::Units::c_light; // need 1/299.792458
// the tube number of a tube in a tubeLayer is encoded in the GeoSerialIdentifier (modulo maxNTubesPerLayer)
static constexpr unsigned int maxNTubesPerLayer = MdtIdHelper::maxNTubesPerLayer;
+
+ inline void updateClosestApproachTwin(MdtCalibInput & in) {
+ const MuonGM::MdtReadoutElement* descriptor = in.legacyDescriptor();
+ if (std::abs(descriptor->getStationS()) < std::numeric_limits<double>::epsilon()) {
+ return;
+ }
+ const Amg::Vector3D nominalTubePos = descriptor->tubePos(in.identify());
+ double measuredPerp = std::sqrt(nominalTubePos.perp2() - descriptor->getStationS()* descriptor->getStationS());
+ CxxUtils::sincos tubeSC{nominalTubePos.phi()};
+ Amg::Vector3D measurePos{tubeSC.cs * measuredPerp, tubeSC.sn *measuredPerp, nominalTubePos.z()};
+ in.setClosestApproach(std::move(measurePos));
+ }
} // namespace
namespace Muon {
@@ -63,16 +76,7 @@ namespace Muon {
}
MdtRdoToPrepDataToolMT::MdtRdoToPrepDataToolMT(const std::string& t, const std::string& n, const IInterface* p) :
- base_class(t, n, p) {
- // - TWIN TUBE
- declareProperty("TimeWindowLowerBound", m_mdtCalibSvcSettings->windowLowerBound);
- declareProperty("TimeWindowUpperBound", m_mdtCalibSvcSettings->windowUpperBound);
- declareProperty("TimeWindowSetting", m_mdtCalibSvcSettings->windowSetting = 2);
- declareProperty("DoTofCorrection", m_mdtCalibSvcSettings->doTof = true);
- declareProperty("DoPropagationCorrection", m_mdtCalibSvcSettings->doProp = false);
- /// Update stuff
- declareProperty("MdtPrdContainerCacheKey", m_prdContainerCacheKey, "Optional external cache for the MDT PRD container");
- }
+ base_class(t, n, p) {}
StatusCode MdtRdoToPrepDataToolMT::initialize() {
ATH_CHECK(AthAlgTool::initialize());
@@ -102,7 +106,6 @@ namespace Muon {
} // end if(m_useTwin){
// - TWIN TUBES
- m_mdtCalibSvcSettings->initialize();
m_BMGid = m_idHelperSvc->mdtIdHelper().stationNameIndex("BMG");
m_BMGpresent = m_BMGid != -1;
@@ -196,7 +199,7 @@ namespace Muon {
return false;
}
- if (processCsm(mdtPrepDataContainer, rdoColl, *muDetMgr).isFailure()) {
+ if (processCsm(ctx, mdtPrepDataContainer, rdoColl, *muDetMgr).isFailure()) {
ATH_MSG_WARNING("processCsm failed for RDO id " << m_idHelperSvc->toString(rdoColl->identify()));
return false;
}
@@ -294,8 +297,41 @@ namespace Muon {
ATH_MSG_DEBUG("--------------------------------------------------------------------------------------------");
}
- StatusCode MdtRdoToPrepDataToolMT::processCsm(ModfiablePrdColl& prepDataContainer, const MdtCsm* rdoColl,
- const MuonGM::MuonDetectorManager* muDetMgr) const {
+ std::unique_ptr<MdtPrepData> MdtRdoToPrepDataToolMT::createPrepData(const MdtCalibInput& calibInput,
+ const MdtCalibOutput& calibOutput) const {
+ if (!calibInput.legacyDescriptor() || calibInput.isMasked() || calibInput.adc() < m_adcCut ||
+ calibOutput.status() == MdtDriftCircleStatus::MdtStatusUnDefined) {
+ ATH_MSG_VERBOSE("Do not create calib hit for "<<m_idHelperSvc->toString(calibInput.identify())<<
+ " because it's masked "<<(calibInput.isMasked() ? "si" : "no") <<", "
+ <<"adc: "<<calibInput.adc()<<" vs. "<<m_adcCut<<", calibration bailed out "
+ <<(calibOutput.status() == MdtDriftCircleStatus::MdtStatusUnDefined? "si": "no"));
+ return nullptr;
+ }
+ ATH_MSG_VERBOSE("Calibrated prepdata "<<m_idHelperSvc->toString(calibInput.identify())
+ <<std::endl<<calibInput<<std::endl<<calibOutput);
+
+ Amg::Vector2D driftRadius{Amg::Vector2D::Zero()};
+ Amg::MatrixX cov(1, 1);
+ if (calibOutput.status() == MdtDriftCircleStatus::MdtStatusDriftTime){
+ /// Test by how much do we break frozen Tier0
+ const float r = calibOutput.driftRadius();
+ const float sigR = calibOutput.driftRadiusUncert();
+ driftRadius[0] = r;
+ (cov)(0, 0) = sigR * sigR;
+ } else (cov)(0, 0) = 0;
+
+ return std::make_unique<MdtPrepData>(calibInput.identify(),
+ calibInput.legacyDescriptor()->identifyHash(),
+ std::move(driftRadius),
+ std::move(cov),
+ calibInput.legacyDescriptor(),
+ calibInput.tdc(),
+ calibInput.adc(),
+ calibOutput.status());
+ }
+
+ StatusCode MdtRdoToPrepDataToolMT::processCsm(const EventContext& ctx, ModfiablePrdColl& prepDataContainer, const MdtCsm* rdoColl,
+ const MuonGM::MuonDetectorManager* muDetMgr) const {
const MdtIdHelper& id_helper = m_idHelperSvc->mdtIdHelper();
// first handle the case of twin tubes
if (m_useTwin) {
@@ -306,7 +342,7 @@ namespace Muon {
MuonStationIndex::ChIndex chIndex = m_idHelperSvc->chamberIndex(elementId);
if (chIndex == MuonStationIndex::BOL &&
(m_useAllBOLTwin || (std::abs(id_helper.stationEta(elementId)) == 4 && id_helper.stationPhi(elementId) == 7))) {
- return processCsmTwin(prepDataContainer, rdoColl, muDetMgr);
+ return processCsmTwin(ctx, prepDataContainer, rdoColl, muDetMgr);
}
}
@@ -330,7 +366,6 @@ namespace Muon {
// FIXME: Still use the digit class.
ATH_MSG_VERBOSE("Amt Hit n. " << mc << " tdcId = " << amtHit->tdcId());
std::unique_ptr<MdtDigit> newDigit{m_mdtDecoder->getDigit(amtHit, subdetId, mrodId, csmId)};
-
if (!newDigit) {
ATH_MSG_WARNING("Found issue MDT RDO decoder for subdetId/mrodId/csmId "
<< subdetId << "/" << mrodId << "/" << csmId << " amtHit channelId/tdcId =" << amtHit->channelId() << "/"
@@ -355,23 +390,6 @@ namespace Muon {
ATH_MSG_VERBOSE("got digit with id ext / hash " << m_idHelperSvc->toString(channelId) << " / "
<< driftCircleColl->identifyHash());
- double radius{0.}, errRadius{0.};
- MdtDriftCircleStatus digitStatus = MdtStatusDriftTime;
-
- // do lookup once
- const MdtReadoutElement* descriptor = muDetMgr->getMdtReadoutElement(channelId);
- if (!descriptor) {
- ATH_MSG_WARNING("Detector Element not found for Identifier from the cabling service <" << m_idHelperSvc->toString(channelId)
- << "> =>>ignore this hit");
- continue;
- }
- if (!descriptor->containsId(channelId)) {
- ATH_MSG_WARNING("Detector Element " << m_idHelperSvc->toString(descriptor->identify())
- << " does not contains candidate prd Identifier <" << m_idHelperSvc->toString(channelId)
- << "> =>>ignore this hit");
- continue;
- }
-
// Rescale ADC/TDC of chambers using HPTDC digitization chip
// Must create a new digit from the old one, because MdtDigit has no methods to set ADC/TDC
if (m_idHelperSvc->hasHPTDC(channelId)) {
@@ -382,24 +400,11 @@ namespace Muon {
ATH_MSG_DEBUG("Change HPTDC ADC/TDC " << m_idHelperSvc->toString(channelId) << " Old ADC/TDC=" << adc * 4 << " " << tdc * 4
<< " New=" << adc << " " << tdc);
}
+ const MdtCalibInput calibIn{*newDigit, *muDetMgr};
+ const MdtCalibOutput calibResult{m_calibrationTool->calibrate(ctx, calibIn, false)};
- if (newDigit->is_masked()) {
- digitStatus = MdtStatusMasked;
- } else {
- digitStatus = getMdtDriftRadius(*newDigit, radius, errRadius, descriptor, muDetMgr);
- if (radius < -999) {
- ATH_MSG_WARNING("MDT PrepData with very large, negative radius "
- << " Id is: " << m_idHelperSvc->toString(channelId));
- }
- }
-
- Amg::Vector2D driftRadius(radius, 0);
- Amg::MatrixX cov(1, 1);
- (cov)(0, 0) = errRadius * errRadius;
- // Create new PrepData
-
- std::unique_ptr<MdtPrepData> newPrepData = std::make_unique<MdtPrepData>(channelId, driftCircleColl->identifyHash(), driftRadius, cov, descriptor,
- newDigit->tdc(), newDigit->adc(), digitStatus);
+ std::unique_ptr<MdtPrepData> newPrepData = createPrepData(calibIn, calibResult);
+ if (!newPrepData) continue;
newPrepData->setHashAndIndex(driftCircleColl->identifyHash(), driftCircleColl->size());
driftCircleColl->push_back(std::move(newPrepData));
@@ -409,16 +414,16 @@ namespace Muon {
bool MdtRdoToPrepDataToolMT::deadBMGChannel(const Identifier& channelId) const {
const MdtIdHelper& id_helper = m_idHelperSvc->mdtIdHelper();
if (id_helper.stationName(channelId) != m_BMGid || !m_BMGpresent) return false;
- std::map<Identifier, std::vector<Identifier>>::const_iterator myIt = m_DeadChannels.find(id_helper.multilayerID(channelId));
+ std::map<Identifier, std::set<Identifier>>::const_iterator myIt = m_DeadChannels.find(id_helper.multilayerID(channelId));
if (myIt == m_DeadChannels.end()) { return false; }
- if (std::find((myIt->second).begin(), (myIt->second).end(), channelId) != (myIt->second).end()) {
+ if (myIt->second.count(channelId)) {
ATH_MSG_DEBUG("deadBMGChannel : Deleting BMG digit with identifier" << m_idHelperSvc->toString(channelId));
return true;
}
return false;
}
- StatusCode MdtRdoToPrepDataToolMT::processCsmTwin(ModfiablePrdColl& prepDataContainer, const MdtCsm* rdoColl,
- const MuonGM::MuonDetectorManager* muDetMgr) const {
+ StatusCode MdtRdoToPrepDataToolMT::processCsmTwin(const EventContext& ctx, ModfiablePrdColl& prepDataContainer, const MdtCsm* rdoColl,
+ const MuonGM::MuonDetectorManager* muDetMgr) const {
const MdtIdHelper& id_helper = m_idHelperSvc->mdtIdHelper();
ATH_MSG_DEBUG(" ***************** Start of processCsmTwin");
ATH_MSG_DEBUG(" Number of AmtHit in this Csm " << rdoColl->size());
@@ -531,430 +536,97 @@ namespace Muon {
ATH_MSG_VERBOSE("got digit with id ext / hash " << m_idHelperSvc->toString(channelId) << " / "
<< driftCircleColl->identifyHash());
- double radius{0.}, errRadius{0.};
- MdtDriftCircleStatus digitStatus = MdtStatusDriftTime;
-
- // do lookup once
- const MdtReadoutElement* descriptor = muDetMgr->getMdtReadoutElement(channelId);
- if (!descriptor) {
- ATH_MSG_WARNING("Detector Element not found for Identifier from the cabling service <"
- << m_idHelperSvc->toString(channelId) << "> =>>ignore this hit");
- continue;
- }
-
- if (digit->is_masked()) {
- digitStatus = MdtStatusMasked;
- } else {
- digitStatus = getMdtDriftRadius(*digit, radius, errRadius, descriptor, muDetMgr);
- if (radius < -999) {
- ATH_MSG_WARNING("MDT PrepData with very large, negative radius "
- << " Id is: " << m_idHelperSvc->toString(channelId));
- }
- }
-
- Amg::Vector2D driftRadius(radius, 0);
- Amg::MatrixX cov(1, 1);
- (cov)(0, 0) = errRadius * errRadius;
-
+ const MdtCalibInput mdtCalibIn{*digit, *muDetMgr};
+ const MdtCalibOutput mdtCalibOut{m_calibrationTool->calibrate(ctx, mdtCalibIn, false)};
+
// Create new PrepData
- std::unique_ptr<MdtPrepData> newPrepData = std::make_unique<MdtPrepData>(channelId, driftCircleColl->identifyHash(), driftRadius, cov, descriptor,
- digit->tdc(), digit->adc(), digitStatus);
+ std::unique_ptr<MdtPrepData> newPrepData = createPrepData(mdtCalibIn, mdtCalibOut);
+ if (!newPrepData) continue;
newPrepData->setHashAndIndex(driftCircleColl->identifyHash(), driftCircleColl->size());
driftCircleColl->push_back(std::move(newPrepData));
- ATH_MSG_DEBUG(" MADE ORIGINAL PREPDATA " << m_idHelperSvc->toString(channelId) << " radius = " << radius << " +- "
- << errRadius);
-
- } // end if(!second_digit){
- else {
- // define twin position and error
- double zTwin{0.}, errZTwin{0.}, radius{0.}, errRadius{0.};
- bool secondHitIsPrompt(false);
- // define drift-radius and error
- MdtDriftCircleStatus digitStatus = MdtStatusDriftTime;
- // call the function to calculate radii and twin coordinate
- digitStatus =
- getMdtTwinPosition(*digit, *second_digit, radius, errRadius, zTwin, errZTwin, secondHitIsPrompt, muDetMgr);
- if (zTwin < -99999) {
- ATH_MSG_WARNING("MDT Twin PrepData with very large, negative twin coordinate "
- << zTwin << " Id is: " << m_idHelperSvc->toString(digit->identify())
- << " Twin Id is: " << m_idHelperSvc->toString(second_digit->identify()));
- }
-
- // set the properties of PrepData-object to the tube that was PROMPT (= hit by the muon)
-
- if (secondHitIsPrompt) { std::swap(digit, second_digit); }
- std::unique_ptr<MdtDigit>& promptHit_Digit = digit;
- std::unique_ptr<MdtDigit>& twinHit_Digit = second_digit;
- Identifier promptHit_channelId = digit->identify();
-
- // do lookup once
- const MdtReadoutElement* descriptor = muDetMgr->getMdtReadoutElement(promptHit_channelId);
- if (!descriptor) {
- ATH_MSG_WARNING("Detector Element not found for Identifier from the DetManager <"
- << m_idHelperSvc->toString(promptHit_channelId) << "> =>>ignore this hit");
- continue;
- }
-
- // check if digit is masked
- if (promptHit_Digit->is_masked()) {
- digitStatus = MdtStatusMasked;
- } else if (radius < -999) {
- ATH_MSG_WARNING("MDT Twin PrepData with very large, negative radius "
- << " Id is: " << m_idHelperSvc->toString(promptHit_channelId));
- }
-
- Amg::Vector2D driftRadiusZTwin(radius, zTwin);
- // make a 2x2 matrix with all values initialized at 0
- Amg::MatrixX cov(2, 2);
- (cov)(0, 0) = errRadius * errRadius;
- (cov)(1, 1) = errZTwin * errZTwin;
- (cov)(0, 1) = 0;
- (cov)(1, 0) = 0;
-
- // Create new PrepData either w/ or w/o twin hit info depending on m_use1DPrepDataTwin flag
- if (!m_use1DPrepDataTwin) {
- MdtTwinPrepData* twin_newPrepData =
- new MdtTwinPrepData(promptHit_channelId,
- // promptHit_channelHash,
- driftCircleColl->identifyHash(), driftRadiusZTwin, cov, descriptor, promptHit_Digit->tdc(),
- promptHit_Digit->adc(), twinHit_Digit->tdc(), twinHit_Digit->adc(), digitStatus);
-
- ATH_MSG_DEBUG(" MADE A 2D TWINPREPDATA " << m_idHelperSvc->toString(promptHit_channelId) << " zTwin = " << zTwin
- << " +- " << errZTwin << " radius = " << radius << " +- " << errRadius);
-
- Amg::Vector3D gpos_centertube = twin_newPrepData->globalPosition();
- const MdtReadoutElement* detEl = muDetMgr->getMdtReadoutElement(promptHit_channelId);
- Amg::Vector3D locpos_centertube = zTwin * Amg::Vector3D::UnitZ();
- const Amg::Vector3D gpos_twin = detEl->localToGlobalTransf(promptHit_channelId)*locpos_centertube;
-
- ATH_MSG_DEBUG(" global pos center tube x = " << gpos_centertube.x() << " y = " << gpos_centertube.y()
- << " z = " << gpos_centertube.z());
- ATH_MSG_DEBUG(" local pos center tube w/ TWIN INFO x = "
- << locpos_centertube.x() << " y = " << locpos_centertube.y() << " z = " << locpos_centertube.z());
- ATH_MSG_DEBUG(" global pos w/ TWIN INFO x = " << gpos_twin.x() << " y = " << gpos_twin.y()
- << " z = " << gpos_twin.z());
-
- twin_newPrepData->setHashAndIndex(driftCircleColl->identifyHash(), driftCircleColl->size());
- driftCircleColl->push_back(std::move(twin_newPrepData));
-
- } // end if(!m_use1DPrepDataTwin){
- else {
- Amg::Vector2D driftRadius(radius, 0);
- // make a 2x2 matrix with all values initialized at 0
- Amg::MatrixX cov(1, 1);
- (cov)(0, 0) = errRadius * errRadius;
-
- std::unique_ptr<MdtPrepData> twin_newPrepData =
- std::make_unique<MdtPrepData>(promptHit_channelId, driftCircleColl->identifyHash(), driftRadius, cov, descriptor,
- promptHit_Digit->tdc(), promptHit_Digit->adc(), digitStatus);
-
- ATH_MSG_DEBUG(" MADE A 1D(=original) PREPDATA OUT OF TWINPAIR "
- << " TWIN COORDINATE IS NOT STORED IN PREPDATA " << m_idHelperSvc->toString(promptHit_channelId)
- << " zTwin = " << zTwin << " +- " << errZTwin << " radius = " << radius << " +- " << errRadius);
-
- twin_newPrepData->setHashAndIndex(driftCircleColl->identifyHash(), driftCircleColl->size());
- driftCircleColl->push_back(std::move(twin_newPrepData));
-
- } // end else -- if(!m_use1DPrepDataTwin){
-
- } // end else -- if(!second_digit){
+ ATH_MSG_DEBUG(" MADE ORIGINAL PREPDATA " << m_idHelperSvc->toString(channelId) << " " << mdtCalibOut);
+ continue;
+ }
+ if (digit->is_masked() || second_digit->is_masked()) continue;
+ MdtCalibInput mdtCalib1st{*digit, *muDetMgr};
+ MdtCalibInput mdtCalib2nd{*second_digit, *muDetMgr};
+ updateClosestApproachTwin(mdtCalib1st);
+ updateClosestApproachTwin(mdtCalib2nd);
+
+ const MdtCalibTwinOutput twinCalib = m_calibrationTool->calibrateTwinTubes(ctx, mdtCalib1st, mdtCalib2nd);
+
+ Amg::Vector2D hitPos{twinCalib.primaryDriftR(), twinCalib.locZ()};
+ Amg::MatrixX cov(2, 2);
+ (cov)(0, 0) = twinCalib.uncertPrimaryR() * twinCalib.uncertPrimaryR();
+ (cov)(1, 1) = twinCalib.sigmaZ() * twinCalib.sigmaZ();
+ (cov)(0, 1) = 0;
+ (cov)(1, 0) = 0;
+
+ const MuonGM::MdtReadoutElement* descriptor = mdtCalib1st.legacyDescriptor();
+ std::unique_ptr<MdtTwinPrepData> twin_newPrepData = std::make_unique<MdtTwinPrepData>(twinCalib.primaryID(),
+ descriptor->identifyHash(),
+ std::move(hitPos),
+ std::move(cov),
+ descriptor,
+ twinCalib.primaryTdc(),
+ twinCalib.primaryAdc(),
+ twinCalib.twinTdc(),
+ twinCalib.twinAdc(),
+ twinCalib.primaryStatus());
+
+ ATH_MSG_DEBUG(" MADE A 2D TWINPREPDATA " << m_idHelperSvc->toString(twinCalib.primaryID()) << " & "
+ << m_idHelperSvc->toString(twinCalib.twinID()) << " "<<twinCalib);
+ Amg::Vector3D gpos_centertube = twin_newPrepData->globalPosition();
+
+ Amg::Vector3D locpos_centertube = twinCalib.locZ() * Amg::Vector3D::UnitZ();
+ const Amg::Vector3D gpos_twin = descriptor->localToGlobalTransf(twinCalib.primaryID())*locpos_centertube;
+
+ ATH_MSG_DEBUG("global pos center tube " << Amg::toString(gpos_centertube, 2) << std::endl
+ <<"local pos center tube w/ TWIN INFO "<<Amg::toString(locpos_centertube, 2)<<std::endl
+ <<"global pos w/ TWIN INFO "<<Amg::toString(gpos_twin));
+
+ twin_newPrepData->setHashAndIndex(driftCircleColl->identifyHash(), driftCircleColl->size());
+ driftCircleColl->push_back(std::move(twin_newPrepData));
+
+
} // end -- if(multilayer==1)
else if (multilayer == 2) {
// if multilayer=2, then treat every hit as a separate hit, no twin hit should be present here as the hardware is not
// installed
- if (!second_digit) {
- ATH_MSG_VERBOSE("got digit with id ext / hash " << m_idHelperSvc->toString(channelId) << " / "
- << driftCircleColl->identifyHash());
-
- double radius{0.}, errRadius{0.};
- MdtDriftCircleStatus digitStatus = MdtStatusDriftTime;
-
- // do lookup once
- const MdtReadoutElement* descriptor = muDetMgr->getMdtReadoutElement(channelId);
- if (!descriptor) {
- ATH_MSG_WARNING("Detector Element not found for Identifier from the cabling service <"
- << m_idHelperSvc->toString(channelId) << "> =>>ignore this hit");
- continue;
- }
-
- if (digit->is_masked()) {
- digitStatus = MdtStatusMasked;
- } else {
- digitStatus = getMdtDriftRadius(*digit, radius, errRadius, descriptor, muDetMgr);
- if (radius < -999) {
- ATH_MSG_WARNING("MDT PrepData with very large, negative radius "
- << " Id is: " << m_idHelperSvc->toString(channelId));
- }
- }
-
- Amg::Vector2D driftRadius(radius, 0);
- Amg::MatrixX cov(1, 1);
- (cov)(0, 0) = errRadius * errRadius;
-
- // Create new PrepData
- std::unique_ptr<MdtPrepData> newPrepData = std::make_unique<MdtPrepData>(channelId, driftCircleColl->identifyHash(), driftRadius, cov, descriptor,
- digit->tdc(), digit->adc(), digitStatus);
-
+ const MdtCalibInput calibInput1st{*digit, *muDetMgr};
+ const MdtCalibOutput calibResult1st{m_calibrationTool->calibrate(ctx, calibInput1st, false)};
+ // Create new PrepData
+ std::unique_ptr<MdtPrepData> newPrepData = createPrepData(calibInput1st, calibResult1st);
+ if (newPrepData) {
newPrepData->setHashAndIndex(driftCircleColl->identifyHash(), driftCircleColl->size());
driftCircleColl->push_back(std::move(newPrepData));
-
- ATH_MSG_DEBUG(" MADE ORIGINAL PREPDATA " << m_idHelperSvc->toString(channelId) << " radius = " << radius << " +- "
- << errRadius);
-
- } // end -- if(!second_digit){
- else {
- // Do something with second_digit
- Identifier second_channelId = second_digit->identify();
- ATH_MSG_VERBOSE("got digit with id ext / hash " << m_idHelperSvc->toString(channelId) << " / "
- << driftCircleColl->identifyHash());
-
- // second_digit
- ATH_MSG_VERBOSE("got second_digit with id ext / hash " << m_idHelperSvc->toString(second_channelId) << " / "
- << driftCircleColl->identifyHash());
-
+ ATH_MSG_DEBUG(" MADE ORIGINAL PREPDATA " << m_idHelperSvc->toString(channelId) << " "<<calibResult1st);
+ }
+ if (!second_digit) continue;
// Calculate radius
- double radius{0.}, errRadius{0.};
- MdtDriftCircleStatus digitStatus = MdtStatusDriftTime;
-
- // second_digit
- double second_radius{0.}, second_errRadius{0.};
- MdtDriftCircleStatus second_digitStatus = MdtStatusDriftTime;
-
- // do lookup once
- const MdtReadoutElement* descriptor = muDetMgr->getMdtReadoutElement(channelId);
- if (!descriptor) {
- ATH_MSG_WARNING("Detector Element not found for Identifier from the cabling service <"
- << m_idHelperSvc->toString(channelId) << "> =>>ignore this hit");
- continue;
- }
-
- if (digit->is_masked()) {
- digitStatus = MdtStatusMasked;
- } else {
- digitStatus = getMdtDriftRadius(*digit, radius, errRadius, descriptor, muDetMgr);
- if (radius < -999) {
- ATH_MSG_WARNING("MDT PrepData with very large, negative radius "
- << " Id is: " << m_idHelperSvc->toString(channelId));
- }
- }
-
- const MdtReadoutElement* second_descriptor = muDetMgr->getMdtReadoutElement(second_channelId);
- if (!second_descriptor) {
- ATH_MSG_WARNING("Detector Element not found for Identifier from the cabling service <"
- << m_idHelperSvc->toString(second_channelId) << "> =>>ignore this hit");
- continue;
- }
-
- // second_digit
- if (second_digit->is_masked()) {
- second_digitStatus = MdtStatusMasked;
- } else {
- second_digitStatus = getMdtDriftRadius(*second_digit, second_radius, second_errRadius, second_descriptor, muDetMgr);
- if (second_radius < -999) {
- ATH_MSG_WARNING("MDT PrepData with very large, negative radius "
- << " Id is: " << m_idHelperSvc->toString(second_channelId));
- }
- }
-
- Amg::Vector2D driftRadius(radius, 0);
- Amg::MatrixX cov(1, 1);
- (cov)(0, 0) = errRadius * errRadius;
-
- // second_digit
- Amg::Vector2D second_driftRadius(second_radius, 0);
- auto cov2 = Amg::MatrixX(1, 1);
- (cov2)(0, 0) = second_errRadius * second_errRadius;
-
- // Create new PrepData
- std::unique_ptr<MdtPrepData> newPrepData = std::make_unique<MdtPrepData>(channelId, driftCircleColl->identifyHash(), driftRadius, cov, descriptor,
- digit->tdc(), digit->adc(), digitStatus);
-
- newPrepData->setHashAndIndex(driftCircleColl->identifyHash(), driftCircleColl->size());
- driftCircleColl->push_back(std::move(newPrepData));
-
- // second_digit
- // Create new PrepData
- std::unique_ptr<MdtPrepData> second_newPrepData =
- std::make_unique<MdtPrepData>(second_channelId, driftCircleColl->identifyHash(), second_driftRadius, cov2, second_descriptor,
- second_digit->tdc(), second_digit->adc(), second_digitStatus);
-
- second_newPrepData->setHashAndIndex(driftCircleColl->identifyHash(), driftCircleColl->size());
- driftCircleColl->push_back(std::move(second_newPrepData));
-
- ATH_MSG_DEBUG(" MADE ORIGINAL PREPDATA " << m_idHelperSvc->toString(channelId) << " radius = " << radius << " +- "
- << errRadius);
-
- // second_digit
- ATH_MSG_DEBUG(" MADE ORIGINAL PREPDATA FOR SECOND DIGIT " << m_idHelperSvc->toString(second_channelId) << " radius = "
- << second_radius << " +- " << second_errRadius);
- } // end -- else -- if(!second_digit){
- } else {
- ATH_MSG_DEBUG("Something strange in MdtRdoToPrepDataToolMT, MDT multilayer (must be 1 or 2)= " << multilayer);
+
+ const MdtCalibInput calibInput2nd{*second_digit, *muDetMgr};
+ const MdtCalibOutput calibResult2nd{m_calibrationTool->calibrate(ctx, calibInput2nd, false)};
+
+ // second_digit
+ // Create new PrepData
+ std::unique_ptr<MdtPrepData> second_newPrepData = createPrepData(calibInput2nd, calibResult2nd);
+ if (!second_newPrepData) continue;
+ second_newPrepData->setHashAndIndex(driftCircleColl->identifyHash(), driftCircleColl->size());
+ driftCircleColl->push_back(std::move(second_newPrepData));
+
+ // second_digit
+ ATH_MSG_DEBUG(" MADE ORIGINAL PREPDATA FOR SECOND DIGIT "
+ << m_idHelperSvc->toString(calibInput2nd.identify())
+ << " "<<calibResult2nd);
+
}
-
- } // end for( iter_map = mdtDigitColl.begin(); iter_map != mdtDigitColl.end(); iter_map++ )
+ }
return StatusCode::SUCCESS;
}
-
- MdtDriftCircleStatus MdtRdoToPrepDataToolMT::getMdtDriftRadius(const MdtDigit& digit, double& radius, double& errRadius,
- const MuonGM::MdtReadoutElement* descriptor,
- const MuonGM::MuonDetectorManager* muDetMgr) const {
- ATH_MSG_DEBUG("in getMdtDriftRadius()");
-
- if (m_calibratePrepData) {
- Identifier channelId = digit.identify();
-
- // here check validity
- // if invalid, reset flags
- if (!descriptor->containsId(channelId)) {
- radius = -1000.;
- ATH_MSG_WARNING("Identifier from the cabling service <"
- << m_idHelperSvc->toString(channelId) << "> inconsistent with the geometry of detector element <"
- << m_idHelperSvc->toString(descriptor->identify()) << "> =>>ignore this hit");
- return MdtStatusUnDefined;
- }
-
- // use center (cached) to get the tube position instead of tubepos
- const Amg::Vector3D& position = descriptor->center(channelId);
- MdtCalibHit calibHit(channelId, digit.tdc(), digit.adc(), position, descriptor);
-
- MdtCalibrationSvcInput inputData;
- double signedTrackLength = position.mag();
- inputData.tof = signedTrackLength * inverseSpeedOfLight;
-
- calibHit.setGlobalPointOfClosestApproach(position);
-
- bool drift_ok = m_calibrationTool->driftRadiusFromTime(calibHit, inputData, *m_mdtCalibSvcSettings, false);
- if (!drift_ok) {
- if (calibHit.driftTime() < 0.)
- return MdtStatusBeforeSpectrum;
- else
- return MdtStatusAfterSpectrum;
- }
- radius = calibHit.driftRadius();
- errRadius = calibHit.sigmaDriftRadius();
- ATH_MSG_VERBOSE("Calibrated drift radius is " << radius << "+/-" << errRadius);
- } else {
- Identifier channelId = digit.identify();
- radius = 0.;
- errRadius = muDetMgr->getMdtReadoutElement(channelId)->innerTubeRadius() / std::sqrt(12); // 14.6/sqrt(12)
- }
- return MdtStatusDriftTime;
- }
-
- MdtDriftCircleStatus MdtRdoToPrepDataToolMT::getMdtTwinPosition(const MdtDigit& digit, const MdtDigit& second_digit, double& radius,
- double& errRadius, double& zTwin, double& errZTwin,
- bool& secondHitIsPrompt,
- const MuonGM::MuonDetectorManager* muDetMgr) const {
- ATH_MSG_DEBUG("in getMdtTwinPosition()");
-
- if (m_calibratePrepData) {
- // start digit
- Identifier channelId = digit.identify();
- const MdtReadoutElement* descriptor = muDetMgr->getMdtReadoutElement(channelId);
-
- // here check validity
- // if invalid, reset flags
- if (!descriptor) {
- ATH_MSG_WARNING("getMdtTwinPosition(): Detector Element not found for Identifier from the cabling service <"
- << m_idHelperSvc->toString(channelId) << "> =>>ignore this hit");
- zTwin = -100000.;
- return MdtStatusUnDefined;
- } else if (!descriptor->containsId(channelId)) {
- zTwin = -100000.;
- ATH_MSG_WARNING("getMdtTwinPosition(): Identifier from the cabling service <"
- << m_idHelperSvc->toString(channelId) << "> inconsistent with the geometry of detector element <"
- << m_idHelperSvc->toString(descriptor->identify()) << "> =>>ignore this hit");
- return MdtStatusUnDefined;
- }
-
- Amg::Vector3D position = descriptor->tubePos(channelId);
- double measured_perp = position.perp();
- if (descriptor->getStationS() != 0.) {
- measured_perp = std::sqrt(measured_perp * measured_perp - descriptor->getStationS() * descriptor->getStationS());
- }
- double measured_x = measured_perp * std::cos(position.phi());
- double measured_y = measured_perp * std::sin(position.phi());
- const Amg::Vector3D measured_position(measured_x, measured_y, position.z());
- MdtCalibHit calib_hit = MdtCalibHit(channelId, digit.tdc(), digit.adc(), measured_position, descriptor);
- calib_hit.setGlobalPointOfClosestApproach(measured_position);
- double signedTrackLength = measured_position.mag();
-
- // start second digit
- Identifier second_channelId = second_digit.identify();
- const MdtReadoutElement* second_descriptor = muDetMgr->getMdtReadoutElement(second_channelId);
-
- // here check validity
- // if invalid, reset flags
- if (!second_descriptor) {
- ATH_MSG_WARNING("getMdtTwinPosition(): Detector Element not found for Identifier from the cabling service <"
- << m_idHelperSvc->toString(second_channelId) << "> =>>ignore this hit");
- zTwin = -100000.;
- return MdtStatusUnDefined;
- } else if (!second_descriptor->containsId(second_channelId)) {
- zTwin = -100000.;
- ATH_MSG_WARNING("getMdtTwinPosition(): Identifier from the cabling service <"
- << m_idHelperSvc->toString(second_channelId) << "> inconsistent with the geometry of detector element <"
- << m_idHelperSvc->toString(second_descriptor->identify()) << "> =>>ignore this hit");
- return MdtStatusUnDefined;
- }
-
- Amg::Vector3D second_position = second_descriptor->tubePos(second_channelId);
- double second_measured_perp = second_position.perp();
- if (second_descriptor->getStationS() != 0.) {
- second_measured_perp = std::sqrt(second_measured_perp * second_measured_perp -
- second_descriptor->getStationS() * second_descriptor->getStationS());
- }
- double second_measured_x = second_measured_perp * std::cos(second_position.phi());
- double second_measured_y = second_measured_perp * std::sin(second_position.phi());
- const Amg::Vector3D second_measured_position(second_measured_x, second_measured_y, second_position.z());
- MdtCalibHit second_calib_hit =
- MdtCalibHit(second_channelId, second_digit.tdc(), second_digit.adc(), second_measured_position, second_descriptor);
- double second_signedTrackLength = second_measured_position.mag();
-
- // calculate and calibrate radius for both hits and calculate twin position
- second_calib_hit.setGlobalPointOfClosestApproach(second_measured_position);
-
- bool second_ok = m_calibrationTool->twinPositionFromTwinHits(calib_hit, second_calib_hit, signedTrackLength,
- second_signedTrackLength, secondHitIsPrompt);
- if (!second_ok) {
- if (calib_hit.driftTime() < 0. || second_calib_hit.driftTime() < 0.)
- return MdtStatusBeforeSpectrum;
- else
- return MdtStatusAfterSpectrum;
- }
-
- // set radius and error to the prompt tube (tube that was actually hit by the muon)
- radius = calib_hit.driftRadius();
- errRadius = calib_hit.sigmaDriftRadius();
- if (secondHitIsPrompt) {
- radius = second_calib_hit.driftRadius();
- errRadius = second_calib_hit.sigmaDriftRadius();
- }
-
- zTwin = second_calib_hit.xtwin();
- errZTwin = second_calib_hit.sigmaXtwin();
-
- ATH_MSG_VERBOSE(" Calibrated drift radius of prompt hit (of twin pair) is " << radius << "+/-" << errRadius);
- ATH_MSG_VERBOSE(" Calibrated twin coordinate = " << zTwin << "+/-" << errZTwin);
-
- } // end if(m_calibratePrepData)
- else {
- Identifier channelId = digit.identify();
- radius = 0.;
- const MuonGM::MdtReadoutElement* reElem = muDetMgr->getMdtReadoutElement(channelId);
- errRadius = reElem->innerTubeRadius() / std::sqrt(12); // 14.6/sqrt(12)
- zTwin = 0.;
- double tubelength = reElem->tubeLength(channelId);
- errZTwin = tubelength / 2.;
- }
-
- return MdtStatusDriftTime;
- }
-
void MdtRdoToPrepDataToolMT::initDeadChannels(const MuonGM::MdtReadoutElement* mydetEl) {
PVConstLink cv = mydetEl->getMaterialGeom(); // it is "Multilayer"
int nGrandchildren = cv->getNChildVols();
@@ -964,14 +636,9 @@ namespace Muon {
geoGetIds([&](int id) { tubes.push_back(id); }, &*cv);
std::sort(tubes.begin(), tubes.end());
- Identifier detElId = mydetEl->identify();
-
- int name = m_idHelperSvc->mdtIdHelper().stationName(detElId);
- int eta = m_idHelperSvc->mdtIdHelper().stationEta(detElId);
- int phi = m_idHelperSvc->mdtIdHelper().stationPhi(detElId);
- int ml = m_idHelperSvc->mdtIdHelper().multilayer(detElId);
- std::vector<Identifier> deadTubes;
-
+ const Identifier detElId = mydetEl->identify();
+ const int ml = mydetEl->getMultilayer();
+ std::set<Identifier>& deadTubes{m_DeadChannels[detElId]};
std::vector<int>::iterator it = tubes.begin();
for (int layer = 1; layer <= mydetEl->getNLayers(); layer++) {
for (int tube = 1; tube <= mydetEl->getNtubesperlayer(); tube++) {
@@ -983,17 +650,14 @@ namespace Muon {
if (it != tubes.end() && *it == want_id) {
++it;
} else {
- Identifier deadTubeId = m_idHelperSvc->mdtIdHelper().channelID(name, eta, phi, ml, layer, tube);
- deadTubes.push_back(deadTubeId);
- ATH_MSG_VERBOSE("adding dead tube (" << tube << "), layer(" << layer << "), phi(" << phi << "), eta(" << eta
- << "), name(" << name << "), multilayerId(" << ml << ") and identifier "
- << deadTubeId << " .");
+ Identifier deadTubeId = m_idHelperSvc->mdtIdHelper().channelID(detElId, ml, layer, tube);
+ deadTubes.insert(deadTubeId);
+ ATH_MSG_VERBOSE("adding dead tube "<<m_idHelperSvc->toString(deadTubeId));
}
}
}
}
- std::sort(deadTubes.begin(), deadTubes.end());
- m_DeadChannels[detElId] = std::move(deadTubes);
+
}
MdtRdoToPrepDataToolMT::ModfiablePrdColl MdtRdoToPrepDataToolMT::setupMdtPrepDataContainer(const EventContext& ctx) const {
SG::WriteHandle<MdtPrepDataContainer> handle{m_mdtPrepDataContainerKey, ctx};
diff --git a/MuonSpectrometer/MuonCnv/MuonMDT_CnvTools/src/MdtRdoToPrepDataToolMT.h b/MuonSpectrometer/MuonCnv/MuonMDT_CnvTools/src/MdtRdoToPrepDataToolMT.h
index 50dbbc0a641..34396d92d2a 100644
--- a/MuonSpectrometer/MuonCnv/MuonMDT_CnvTools/src/MdtRdoToPrepDataToolMT.h
+++ b/MuonSpectrometer/MuonCnv/MuonMDT_CnvTools/src/MdtRdoToPrepDataToolMT.h
@@ -10,8 +10,7 @@
#include "AthenaBaseComps/AthAlgTool.h"
#include "GaudiKernel/ServiceHandle.h"
#include "GaudiKernel/ToolHandle.h"
-#include "MdtCalibSvc/MdtCalibrationSvcSettings.h"
-#include "MdtCalibSvc/MdtCalibrationTool.h"
+#include "MdtCalibInterfaces/IMdtCalibrationTool.h"
#include "MuonCablingData/MuonMDT_CablingMap.h"
#include "MuonCnvToolInterfaces/IMuonRawDataProviderTool.h"
#include "MuonCnvToolInterfaces/IMuonRdoToPrepDataTool.h"
@@ -64,9 +63,6 @@ namespace Muon {
protected:
void printPrepDataImpl(const Muon::MdtPrepDataContainer* mdtPrepDataContainer) const;
- Muon::MdtDriftCircleStatus getMdtDriftRadius(const MdtDigit& digit, double& radius, double& errRadius,
- const MuonGM::MdtReadoutElement* descriptor,
- const MuonGM::MuonDetectorManager* muDetMgr) const;
/// method to get the twin tube 2nd coordinate
Muon::MdtDriftCircleStatus getMdtTwinPosition(const MdtDigit& prompt_digit, const MdtDigit& twin_digit, double& radius,
double& errRadius, double& zTwin, double& errZTwin, bool& twinIsPrompt,
@@ -94,12 +90,16 @@ namespace Muon {
PrdCollMap addedCols{};
};
- StatusCode processCsm(ModfiablePrdColl& mdtPrepDataContainer, const MdtCsm* rdoColl,
+ StatusCode processCsm(const EventContext& ctx, ModfiablePrdColl& mdtPrepDataContainer, const MdtCsm* rdoColl,
const MuonGM::MuonDetectorManager* muDetMgr) const;
- StatusCode processCsmTwin(ModfiablePrdColl& mdtPrepDataContainer, const MdtCsm* rdoColll,
+ StatusCode processCsmTwin(const EventContext& ctx, ModfiablePrdColl& mdtPrepDataContainer, const MdtCsm* rdoColll,
const MuonGM::MuonDetectorManager* muDetMgr) const;
-
+
+ /// Creates the Prepdata container
+ std::unique_ptr<MdtPrepData> createPrepData(const MdtCalibInput& calibInput,
+ const MdtCalibOutput& calibOutput) const;
+
/// Creates the prep data container to be written
ModfiablePrdColl setupMdtPrepDataContainer(const EventContext& ctx) const;
/// Is the identifier disabled due to BMG cut outs
@@ -116,8 +116,7 @@ namespace Muon {
ServiceHandle<Muon::IMuonIdHelperSvc> m_idHelperSvc{this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"};
/// MDT calibration service
- ToolHandle<MdtCalibrationTool> m_calibrationTool{this, "CalibrationTool", "MdtCalibrationTool"};
- std::unique_ptr<MdtCalibrationSvcSettings> m_mdtCalibSvcSettings{std::make_unique<MdtCalibrationSvcSettings>()};
+ ToolHandle<IMdtCalibrationTool> m_calibrationTool{this, "CalibrationTool", "MdtCalibrationTool"};
/// MdtPrepRawData containers
SG::WriteHandleKey<Muon::MdtPrepDataContainer> m_mdtPrepDataContainerKey{this, "OutputCollection", "MDT_DriftCircles"};
@@ -125,6 +124,8 @@ namespace Muon {
SG::ReadHandleKey<MdtCsmContainer> m_rdoContainerKey{this, "RDOContainer", "MDTCSM"};
/** member variables for algorithm properties: */
+ Gaudi::Property<int> m_adcCut{this, "AdcCut", 50,
+ "Minimal cut on the adc to convert it into a prepdata object"};
Gaudi::Property<bool> m_calibratePrepData{this, "CalibratePrepData", true}; //!< toggle on/off calibration of MdtPrepData
Gaudi::Property<bool> m_decodeData{this, "DecodeData", true}; //!< toggle on/off the decoding of MDT RDO into MdtPrepData
bool m_sortPrepData = false; //!< Toggle on/off the sorting of the MdtPrepData
@@ -137,14 +138,13 @@ namespace Muon {
// + TWIN TUBE
Gaudi::Property<bool> m_useTwin{this, "UseTwin", true};
Gaudi::Property<bool> m_useAllBOLTwin{this, "UseAllBOLTwin", false};
- Gaudi::Property<bool> m_use1DPrepDataTwin{this, "Use1DPrepDataTwin", false};
Gaudi::Property<bool> m_twinCorrectSlewing{this, "TwinCorrectSlewing", false};
Gaudi::Property<bool> m_discardSecondaryHitTwin{this, "DiscardSecondaryHitTwin", false};
int m_twin_chamber[2][3][36]{};
int m_secondaryHit_twin_chamber[2][3][36]{};
// - TWIN TUBE
- std::map<Identifier, std::vector<Identifier>> m_DeadChannels;
+ std::map<Identifier, std::set<Identifier>> m_DeadChannels{};
void initDeadChannels(const MuonGM::MdtReadoutElement* mydetEl);
SG::ReadCondHandleKey<MuonMDT_CablingMap> m_readKey{this, "ReadKey", "MuonMDT_CablingMap", "Key of MuonMDT_CablingMap"};
@@ -152,7 +152,9 @@ namespace Muon {
SG::ReadCondHandleKey<MuonGM::MuonDetectorManager> m_muDetMgrKey{this, "DetectorManagerKey", "MuonDetectorManager",
"Key of input MuonDetectorManager condition data"};
/// This is the key for the cache for the MDT PRD containers, can be empty
- SG::UpdateHandleKey<MdtPrepDataCollection_Cache> m_prdContainerCacheKey;
+ SG::UpdateHandleKey<MdtPrepDataCollection_Cache> m_prdContainerCacheKey{this, "MdtPrdContainerCacheKey", "",
+ "Optional external cache for the MDT PRD container"};
+
};
} // namespace Muon
diff --git a/MuonSpectrometer/MuonConditions/MuonCondGeneral/MuonCondAlg/MuonCondAlg/MdtCalibDbAlg.h b/MuonSpectrometer/MuonConditions/MuonCondGeneral/MuonCondAlg/MuonCondAlg/MdtCalibDbAlg.h
index a0a54cee815..54f7090d286 100644
--- a/MuonSpectrometer/MuonConditions/MuonCondGeneral/MuonCondAlg/MuonCondAlg/MdtCalibDbAlg.h
+++ b/MuonSpectrometer/MuonConditions/MuonCondGeneral/MuonCondAlg/MuonCondAlg/MdtCalibDbAlg.h
@@ -16,11 +16,8 @@
#include "CLHEP/Random/RandomEngine.h"
#include "CoralBase/Blob.h"
#include "CoralUtilities/blobaccess.h"
-#include "MdtCalibData/MdtCorFuncSetCollection.h"
-#include "MdtCalibData/MdtRtRelationCollection.h"
-#include "MdtCalibData/MdtTubeCalibContainerCollection.h"
+#include "MdtCalibData/MdtCalibDataContainer.h"
#include "MdtCalibData/RtResolutionLookUp.h"
-#include "MdtCalibSvc/MdtCalibrationRegionSvc.h"
#include "MuonCalibITools/IIdToFixedIdTool.h"
#include "MuonCalibMath/SamplePoint.h"
#include "MuonIdHelpers/IMuonIdHelperSvc.h"
@@ -45,13 +42,18 @@ public:
virtual bool isReEntrant() const override { return false;}
private:
- std::unique_ptr<MuonCalib::MdtTubeCalibContainer> buildMdtTubeCalibContainer(const Identifier& id) const;
-
- StatusCode loadRt(const EventContext& ctx) const;
- StatusCode loadTube(const EventContext& ctx) const;
+ StatusCode declareDependency(const EventContext& ctx,
+ SG::WriteCondHandle<MuonCalib::MdtCalibDataContainer>& writeHandle) const;
+ StatusCode loadRt(const EventContext& ctx, MuonCalib::MdtCalibDataContainer& writeCdo) const;
+ StatusCode loadTube(const EventContext& ctx, MuonCalib::MdtCalibDataContainer& writeCdo) const;
+
+ StatusCode defaultT0s(MuonCalib::MdtCalibDataContainer& writeCdoTube) const;
- StatusCode defaultT0s(MdtTubeCalibContainerCollection& writeCdoTube) const;
- StatusCode defaultRt(MdtRtRelationCollection& writeCdoRt) const;
+ using RtRelationPtr = MuonCalib::MdtFullCalibData::RtRelationPtr;
+ using LoadedRtMap = std::map<Identifier, RtRelationPtr>;
+
+ StatusCode defaultRt(MuonCalib::MdtCalibDataContainer& writeCdoRt,
+ LoadedRtMap& loadedRts) const;
std::optional<double> getInnerTubeRadius(const Identifier& id) const;
@@ -63,28 +65,12 @@ private:
ServiceHandle<Muon::IMuonIdHelperSvc> m_idHelperSvc{this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"};
ToolHandle<MuonCalib::IIdToFixedIdTool> m_idToFixedIdTool{this, "IdToFixedIdTool", "MuonCalib::IdToFixedIdTool"};
- ServiceHandle<MdtCalibrationRegionSvc> m_regionSvc{this, "MdtCalibrationRegionSvc", "MdtCalibrationRegionSvc"};
-
+
const MuonGM::MuonDetectorManager* m_detMgr{nullptr};
const MuonGMR4::MuonDetectorManager* m_r4detMgr{nullptr};
Gaudi::Property<bool> m_useNewGeo{this, "UseR4DetMgr", false,
- "Switch between the legacy and the new geometry"};
-
- /// Helper struct to parse the number of total tubes around
- struct chamberDim{
- unsigned int tubes{0};
- unsigned int layers{0};
- unsigned int multilayers{0};
- /// Object is valid if all three quantities are set
- operator bool() const {
- return tubes > 0 && layers >0 && multilayers > 0;
- }
- };
-
- chamberDim getChamberDimension(const Identifier& moduleId) const;
-
-
+ "Switch between the legacy and the new geometry"};
/// only needed to retrieve information on number of tubes etc. (no alignment needed)
@@ -94,15 +80,12 @@ private:
// like MdtCalibrationDbSvc
// for corData in loadRt
- Gaudi::Property<bool> m_create_b_field_function{
- this, "CreateBFieldFunctions", false,
+ Gaudi::Property<bool> m_create_b_field_function{this, "CreateBFieldFunctions", false,
"If set to true, the B-field correction functions are initialized for each rt-relation that is loaded."};
- Gaudi::Property<bool> m_createWireSagFunction{
- this, "CreateWireSagFunctions", false,
+ Gaudi::Property<bool> m_createWireSagFunction{this, "CreateWireSagFunctions", false,
"If set to true, the wire sag correction functions are initialized for each rt-relation that is loaded."};
- Gaudi::Property<bool> m_createSlewingFunction{
- this, "CreateSlewingFunctions", false,
+ Gaudi::Property<bool> m_createSlewingFunction{this, "CreateSlewingFunctions", false,
"If set to true, the slewing correction functions are initialized for each rt-relation that is loaded."};
void initialize_B_correction(MuonCalib::MdtCorFuncSet& funcSet, const MuonCalib::MdtRtRelation& rt) const;
@@ -117,7 +100,7 @@ private:
// have TS-correction. In the default reco-jobs however, this is
// configured by one muonRecFlag, that will be used to set this job-option.
Gaudi::Property<bool> m_TimeSlewingCorrection{this, "TimeSlewingCorrection", false};
- Gaudi::Property<bool> m_UseMLRt{this, "UseMLRt", true, "Enable use of ML-RTs from COOL"};
+ Gaudi::Property<bool> m_UseMLRt{this, "UseMLRt", false, "Enable use of ML-RTs from COOL"};
Gaudi::Property<std::vector<float>> m_MeanCorrectionVsR{this, "MeanCorrectionVsR", {}};
@@ -135,24 +118,16 @@ private:
StringProperty m_randomStream{this, "RandomStream", "MDTCALIBDBALG"};
ATHRNG::RNGWrapper* m_RNGWrapper{nullptr};
- StringArrayProperty m_RTfileNames{this,
- "RT_InputFiles",
- {"DC2_rt_default.dat"},
- "single input ascii file for default RT to be applied in absence of DB information"}; // temporary!!!
+ StringProperty m_RTfileName{this, "RT_InputFile", "DC2_rt_default.dat",
+ "single input ascii file for default RT to be applied in absence of DB information"}; // temporary!!!
- static std::unique_ptr<MuonCalib::RtResolutionLookUp> getRtResolutionInterpolation(const std::vector<MuonCalib::SamplePoint>& sample_points);
-
- StatusCode extractString(std::string& input, std::string& output, const std::string& separator) const;
+ static std::unique_ptr<MuonCalib::RtResolutionLookUp> getRtResolutionInterpolation(const std::vector<MuonCalib::SamplePoint>& sample_points);
SG::ReadCondHandleKey<CondAttrListCollection> m_readKeyRt{this, "ReadKeyRt", "/MDT/RTBLOB", "DB folder containing the RT calibrations"};
- SG::ReadCondHandleKey<CondAttrListCollection> m_readKeyTube{this, "ReadKeyTube", "/MDT/T0BLOB",
- "DB folder containing the tube constants"};
- SG::WriteCondHandleKey<MdtRtRelationCollection> m_writeKeyRt{this, "MdtRtRelationCollection", "MdtRtRelationCollection",
- "MDT RT relations"};
- SG::WriteCondHandleKey<MdtTubeCalibContainerCollection> m_writeKeyTube{this, "MdtTubeCalibContainerCollection",
- "MdtTubeCalibContainerCollection", "MDT tube calib"};
- SG::WriteCondHandleKey<MdtCorFuncSetCollection> m_writeKeyCor{this, "MdtCorFuncSetCollection", "MdtCorFuncSetCollection",
- "MDT cor Funcs"};
+ SG::ReadCondHandleKey<CondAttrListCollection> m_readKeyTube{this, "ReadKeyTube", "/MDT/T0BLOB", "DB folder containing the tube constants"};
+ SG::WriteCondHandleKey<MuonCalib::MdtCalibDataContainer> m_writeKey{this, "WriteKey", "MdtCalibConstants",
+ "Conditions object containing the calibrations"};
+
};
#endif
diff --git a/MuonSpectrometer/MuonConditions/MuonCondGeneral/MuonCondAlg/src/MdtCalibDbAlg.cxx b/MuonSpectrometer/MuonConditions/MuonCondGeneral/MuonCondAlg/src/MdtCalibDbAlg.cxx
index f915cecc0ab..4eeaeaacf59 100644
--- a/MuonSpectrometer/MuonConditions/MuonCondGeneral/MuonCondAlg/src/MdtCalibDbAlg.cxx
+++ b/MuonSpectrometer/MuonConditions/MuonCondGeneral/MuonCondAlg/src/MdtCalibDbAlg.cxx
@@ -4,6 +4,7 @@
#include "MuonCondAlg/MdtCalibDbAlg.h"
+#include "AthenaKernel/IOVInfiniteRange.h"
#include "AthenaKernel/IIOVDbSvc.h"
#include "AthenaKernel/RNGWrapper.h"
#include "AthenaPoolUtilities/AthenaAttributeList.h"
@@ -17,15 +18,11 @@
#include "MdtCalibData/IRtRelation.h"
#include "MdtCalibData/IRtResolution.h"
#include "MdtCalibData/MdtCalibrationFactory.h"
-#include "MdtCalibData/MdtCorFuncSetCollection.h"
#include "MdtCalibData/MdtFullCalibData.h"
-#include "MdtCalibData/MdtRtRelationCollection.h"
#include "MdtCalibData/MdtSlewCorFuncHardcoded.h"
-#include "MdtCalibData/MdtTubeCalibContainerCollection.h"
#include "MdtCalibData/RtFromPoints.h"
#include "MdtCalibData/RtResolutionFromPoints.h"
#include "MdtCalibData/WireSagCorFunc.h"
-#include "MdtCalibSvc/MdtCalibrationRegionSvc.h"
#include "MdtCalibUtils/RtDataFromFile.h"
#include "MuonCalibIdentifier/MdtCalibCreationFlags.h"
#include "MuonCalibIdentifier/MuonFixedId.h"
@@ -37,7 +34,6 @@
#include "PathResolver/PathResolver.h"
#include "SGTools/TransientAddress.h"
-
#include "MuonReadoutGeometryR4/StringUtils.h"
@@ -46,6 +42,11 @@
#include "TFile.h"
#include "TSpline.h"
+using namespace MuonCalib;
+using CorrectionPtr = MdtFullCalibData::CorrectionPtr;
+using TubeContainerPtr = MdtFullCalibData::TubeContainerPtr;
+using RegionGranularity = MdtCalibDataContainer::RegionGranularity;
+
MdtCalibDbAlg::MdtCalibDbAlg(const std::string &name, ISvcLocator *pSvcLocator) :
AthReentrantAlgorithm(name, pSvcLocator) {}
@@ -62,26 +63,12 @@ StatusCode MdtCalibDbAlg::initialize() {
}
ATH_CHECK(m_idHelperSvc.retrieve());
- ATH_CHECK(m_regionSvc.retrieve());
ATH_CHECK(m_idToFixedIdTool.retrieve());
-
- // initialize MdtRtRelationCollection
- // if COOL RT folder is called /MDT/RTUNIQUE then only read one RT from COOL and use for all chambers
- // Not sure this option has ever been used, perhaps could be used for simulated data.
- // Job option RtFolder would need to be set to "/MDT/RTUNIQUE" to make this work.
- if (m_readKeyRt.key() == "/MDT/RTUNIQUE") {
- m_regionSvc->remapRtRegions("OneRt");
- } else if (m_UseMLRt) {
- m_regionSvc->remapRtRegions("OnePerMultilayer");
- } else {
- m_regionSvc->remapRtRegions("OnePerChamber");
- }
-
// initiallize random number generator if doing t0 smearing (for robustness studies)
if (m_t0Spread != 0.) {
ATH_CHECK(m_AthRNGSvc.retrieve());
- ATH_MSG_DEBUG(" initialize Random Number Service: running with t0 shift " << m_t0Shift << " spread " << m_t0Spread << " rt shift "
- << m_rtShift);
+ ATH_MSG_DEBUG(" initialize Random Number Service: running with t0 shift "
+ << m_t0Shift << " spread " << m_t0Spread << " rt shift " << m_rtShift);
// getting our random numbers stream
m_RNGWrapper = m_AthRNGSvc->getEngine(this, m_randomStream);
if (!m_RNGWrapper) {
@@ -100,54 +87,65 @@ StatusCode MdtCalibDbAlg::initialize() {
ATH_CHECK(m_readKeyRt.initialize());
ATH_CHECK(m_readKeyTube.initialize());
- ATH_CHECK(m_writeKeyRt.initialize());
- ATH_CHECK(m_writeKeyTube.initialize());
- ATH_CHECK(m_writeKeyCor.initialize(m_create_b_field_function || m_createWireSagFunction|| m_createSlewingFunction));
-
+ ATH_CHECK(m_writeKey.initialize());
+
if (m_useNewGeo) ATH_CHECK(detStore()->retrieve(m_r4detMgr));
else ATH_CHECK(detStore()->retrieve(m_detMgr));
return StatusCode::SUCCESS;
}
-
+ StatusCode MdtCalibDbAlg::declareDependency(const EventContext& ctx,
+ SG::WriteCondHandle<MuonCalib::MdtCalibDataContainer>& writeHandle) const {
+
+ writeHandle.addDependency(EventIDRange(IOVInfiniteRange::infiniteTime()));
+ for (const SG::ReadCondHandleKey<CondAttrListCollection>& key : {m_readKeyTube, m_readKeyRt}) {
+ if (key.empty()) continue;
+ SG::ReadCondHandle<CondAttrListCollection> readHandle{key, ctx};
+ if (!readHandle.isValid()) {
+ ATH_MSG_FATAL("Failed to retrieve conditions object "<<readHandle.fullKey());
+ return StatusCode::FAILURE;
+ }
+ writeHandle.addDependency(readHandle);
+ ATH_MSG_INFO("Size of CondAttrListCollection " << readHandle.fullKey() << " readCdoRt->size()= " << readHandle->size());
+ ATH_MSG_INFO("Range of input is " << readHandle.getRange());
+ }
+ return StatusCode::SUCCESS;
+}
StatusCode MdtCalibDbAlg::execute(const EventContext& ctx) const {
ATH_MSG_DEBUG("execute " << name());
- ATH_CHECK(loadRt(ctx));
- ATH_CHECK(loadTube(ctx));
+ SG::WriteCondHandle<MuonCalib::MdtCalibDataContainer> writeHandle{m_writeKey, ctx};
+ if (writeHandle.isValid()) {
+ ATH_MSG_DEBUG("CondHandle " << writeHandle.fullKey() << " is already valid."
+ << ". In theory this should not be called, but may happen"
+ << " if multiple concurrent events are being processed out of order.");
+ return StatusCode::SUCCESS;
+ }
+ ATH_CHECK(declareDependency(ctx, writeHandle));
+
+ RegionGranularity gran{RegionGranularity::OnePerChamber};
+ if (m_readKeyRt.key() == "/MDT/RTUNIQUE") {
+ ATH_MSG_DEBUG("Save one set of Rt constants per chamber");
+ gran = RegionGranularity::OneRt;
+ } else if (m_UseMLRt) {
+ ATH_MSG_DEBUG("Save one set of calibration constants per multi layer");
+ gran = RegionGranularity::OnePerMultiLayer;
+ } else ATH_MSG_DEBUG("Save one set of calibration constants per chamber");
+ std::unique_ptr<MuonCalib::MdtCalibDataContainer> writeCdo = std::make_unique<MuonCalib::MdtCalibDataContainer>(m_idHelperSvc.get(), gran);
+
+ ATH_CHECK(loadRt(ctx, *writeCdo));
+ ATH_CHECK(loadTube(ctx, *writeCdo));
+ ATH_CHECK(writeHandle.record(std::move(writeCdo)));
return StatusCode::SUCCESS;
}
-StatusCode MdtCalibDbAlg::defaultRt(MdtRtRelationCollection &writeCdoRt) const {
+StatusCode MdtCalibDbAlg::defaultRt(MuonCalib::MdtCalibDataContainer& writeCdo, LoadedRtMap& loadedRts) const {
ATH_MSG_DEBUG("defaultRt " << name());
-
- // Build the transient structure in StoreGate and load default RT function read from a text file
- // In principle, a list of text files can be specified in the job options, and each text file
- // may potentially contain multiple RT functions. However, only the first valid RT function in
- // the first text file is used as the default for all chambers.
-
- writeCdoRt.resize(m_regionSvc->numberOfRegions());
- ATH_MSG_DEBUG("Created new MdtRtRelationCollection size " << writeCdoRt.size());
-
- // Check that an RT text file has been specified in job options
- const std::vector<std::string>& fileNames {m_RTfileNames.value()};
- if (fileNames.empty()) {
- ATH_MSG_FATAL("No input RT file declared in jobOptions");
- return StatusCode::FAILURE;
- } else if (fileNames.size() > 1) {
- ATH_MSG_WARNING("Only first RT file declared in jobOptions will be used");
- }
-
- // Open the Ascii file with the RT relations
- std::string fileName = PathResolver::find_file(fileNames[0], "DATAPATH");
- if (fileName.empty()) {
- ATH_MSG_ERROR("RT Ascii file \"" << fileNames[0] << "\" not found");
- return StatusCode::FAILURE;
- }
+ std::string fileName = PathResolver::find_file(m_RTfileName, "DATAPATH");
std::ifstream inputFile(fileName);
if (!inputFile) {
- ATH_MSG_ERROR("Unable to open RT Ascii file: " << fileName.c_str());
+ ATH_MSG_ERROR("Unable to open RT Ascii file: " << fileName);
return StatusCode::FAILURE;
}
- ATH_MSG_DEBUG("Opened RT Ascii file: " << fileName.c_str());
+ ATH_MSG_DEBUG("Opened RT Ascii file: " << fileName);
// Read the RTs from the text file
@@ -157,6 +155,7 @@ StatusCode MdtCalibDbAlg::defaultRt(MdtRtRelationCollection &writeCdoRt) const
// Loop over all RTs in the file (but the default file only has 1 RT)
// Use the first valid RT found in the file as the default for all chambers.
+ const MdtIdHelper& idHelper{m_idHelperSvc->mdtIdHelper()};
for (unsigned int n = 0; n < rts.nRts(); ++n) {
std::unique_ptr<MuonCalib::RtDataFromFile::RtRelation> rt(rts.getRt(n));
@@ -218,13 +217,43 @@ StatusCode MdtCalibDbAlg::defaultRt(MdtRtRelationCollection &writeCdoRt) const
// for rtRel, resoRel, and MdtRtRelation
// Loop over RT regions and store the default RT in each
- for (unsigned int iregion = 0; iregion < writeCdoRt.size(); iregion++) {
- ATH_MSG_DEBUG("Inserting default Rt for region " << iregion);
- // create RT and resolution "I" objects, again, so they can all be cleanly deleted later.
- std::unique_ptr<MuonCalib::IRtRelation> rtRelRegion{MuonCalib::MdtCalibrationFactory::createRtRelation("RtRelationLookUp", rtPars)};
- std::unique_ptr<MuonCalib::IRtResolution> resoRelRegion{MuonCalib::MdtCalibrationFactory::createRtResolution("RtResolutionLookUp", resoPars)};
- writeCdoRt[iregion] = std::make_unique<MuonCalib::MdtRtRelation>(std::move(rtRelRegion), std::move(resoRelRegion), 0.);
- } // end loop over RT regions
+ std::unique_ptr<MuonCalib::IRtRelation> rtRelRegion{MuonCalib::MdtCalibrationFactory::createRtRelation("RtRelationLookUp", rtPars)};
+ std::unique_ptr<MuonCalib::IRtResolution> resoRelRegion{MuonCalib::MdtCalibrationFactory::createRtResolution("RtResolutionLookUp", resoPars)};
+ RtRelationPtr MdtRt = std::make_unique<MuonCalib::MdtRtRelation>(std::move(rtRelRegion), std::move(resoRelRegion), 0.);
+
+ for(auto itr = idHelper.detectorElement_begin();
+ itr!= idHelper.detectorElement_end();++itr){
+ const Identifier detElId{*itr};
+ if (writeCdo.hasDataForChannel(detElId, msgStream())) {
+ const MdtFullCalibData* dataObj = writeCdo.getCalibData(detElId, msgStream());
+ if (dataObj->rtRelation) {
+ ATH_MSG_DEBUG("Rt relation constants for "<<m_idHelperSvc->toString(detElId)<<" already exists");
+ continue;
+ }
+ }
+ /// load the calibration constants of the second multilayer from the first one
+ RtRelationPtr storeMe = MdtRt;
+ if (idHelper.multilayer(detElId) == 2) {
+ if (writeCdo.granularity() != RegionGranularity::OnePerMultiLayer) continue;
+ const Identifier firstML = idHelper.multilayerID(detElId, 1);
+ if (writeCdo.hasDataForChannel(firstML, msgStream())) {
+ const MdtFullCalibData* dataObj = writeCdo.getCalibData(firstML, msgStream());
+ if (dataObj->rtRelation) {
+ ATH_MSG_DEBUG("Copy Rt constanst from the first multi layer for "<<m_idHelperSvc->toString(detElId));
+ storeMe = dataObj->rtRelation;
+ }
+ }
+ }
+ ATH_MSG_DEBUG("Add default rt constants for "<<m_idHelperSvc->toString(detElId));
+ if (!writeCdo.storeData(detElId, storeMe, msgStream())) {
+ ATH_MSG_FATAL(__FILE__<<":"<<__LINE__<<" Failed to save default rts for "<<m_idHelperSvc->toString(detElId));
+ return StatusCode::FAILURE;
+ }
+
+ if (!(m_create_b_field_function || m_createWireSagFunction|| m_createSlewingFunction)) continue;
+ loadedRts[detElId] = MdtRt;
+
+ }
// if VERBOSE enabled print out RT function
if (msgLvl(MSG::VERBOSE)) {
@@ -351,31 +380,15 @@ StatusCode MdtCalibDbAlg::legacyRtPayloadToJSON(const coral::AttributeList& attr
return StatusCode::SUCCESS;
}
-StatusCode MdtCalibDbAlg::loadRt(const EventContext& ctx) const {
+StatusCode MdtCalibDbAlg::loadRt(const EventContext& ctx, MuonCalib::MdtCalibDataContainer& writeCdo) const {
ATH_MSG_DEBUG("loadRt " << name());
- SG::WriteCondHandle<MdtRtRelationCollection> writeHandleRt{m_writeKeyRt, ctx};
- if (writeHandleRt.isValid()) {
- ATH_MSG_DEBUG("CondHandle " << writeHandleRt.fullKey() << " is already valid.");
- return StatusCode::SUCCESS;
- }
- std::unique_ptr<MdtRtRelationCollection> writeCdoRt{std::make_unique<MdtRtRelationCollection>()};
-
-
-
- ATH_CHECK(defaultRt(*writeCdoRt));
-
// Read Cond Handle
SG::ReadCondHandle<CondAttrListCollection> readHandleRt{m_readKeyRt, ctx};
if (!readHandleRt.isValid()) {
ATH_MSG_ERROR("readCdoRt==nullptr");
return StatusCode::FAILURE;
}
- writeHandleRt.addDependency(readHandleRt);
-
- ATH_MSG_INFO("Size of CondAttrListCollection " << readHandleRt.fullKey() << " readCdoRt->size()= " << readHandleRt->size());
- ATH_MSG_INFO("Range of input is " << readHandleRt.getRange());
-
// read new-style format 2020
nlohmann::json rtCalibJson = nlohmann::json::array();
@@ -410,7 +423,8 @@ StatusCode MdtCalibDbAlg::loadRt(const EventContext& ctx) const {
ATH_CHECK(legacyRtPayloadToJSON(itr->second, rtCalibJson));
}
}
-
+ /// List of loaded Rt relations to attach the proper corrections later
+ LoadedRtMap loadedRtRel{};
// unpack the strings in the collection and update the writeCdoRt
for (const auto& payload : rtCalibJson) {
const bool rt_ts_applied = payload["appliedRT"];
@@ -419,41 +433,28 @@ StatusCode MdtCalibDbAlg::loadRt(const EventContext& ctx) const {
const Identifier athenaId = idHelper.channelID(stName, payload["eta"], payload["phi"],
payload["ml"], payload["layer"], payload["tube"]);
- std::optional<double> innerTubeRadius = getInnerTubeRadius(m_idHelperSvc->mdtIdHelper().multilayerID(athenaId, 1));
+ std::optional<double> innerTubeRadius = getInnerTubeRadius(idHelper.multilayerID(athenaId, 1));
if (!innerTubeRadius) continue;
const std::vector<double> radii = payload["radii"];
const std::vector<double> times = payload["times"];
const std::vector<double> resolutions = payload["resolutions"];
-
- unsigned int regionId{0};
- // If using chamber RTs skip RTs for ML2 -- use ML1 RT for entire chamber
- if (m_regionSvc->RegionType() == ONEPERCHAMBER && m_idHelperSvc->mdtIdHelper().multilayer(athenaId) == 2) {
- ATH_MSG_VERBOSE("MdtCalibDbAlg::loadRt Ignore ML2 RT for region "
- << regionId << " " << m_idHelperSvc->toString(athenaId)); // TEMP
- continue;
- }
- IdentifierHash hash{0}; // chamber hash
- if (m_idHelperSvc->mdtIdHelper().get_module_hash(athenaId, hash)) {
- ATH_MSG_ERROR("Could not retrieve module hash for identifier " << athenaId.get_compact());
- return StatusCode::FAILURE;
- }
- ATH_MSG_VERBOSE("Fixed region Id " << regionId << " converted into athena Id " << athenaId << " and then into hash " << hash);
- regionId = hash; // reset regionId to chamber hash
- if (regionId >= writeCdoRt->size()) {
- ATH_MSG_ERROR("loadRt() - regionId=" << regionId << " larger than size of MdtRtRelationCollection, skipping...");
- return StatusCode::FAILURE;
+ if (writeCdo.hasDataForChannel(athenaId, msgStream())) {
+ const MdtFullCalibData* dataObj = writeCdo.getCalibData(athenaId, msgStream());
+ if (dataObj->rtRelation) {
+ ATH_MSG_DEBUG("Rt relation constants for "<<m_idHelperSvc->toString(athenaId)<<" already exists");
+ continue;
+ }
}
- MuonCalib::CalibFunc::ParVec rtPars;
- MuonCalib::CalibFunc::ParVec resoPars;
+ MuonCalib::CalibFunc::ParVec rtPars{}, resoPars{};
MuonCalib::SamplePoint tr_point, ts_point; // pairs of numbers; tr = (time,radius); ts = (time,sigma) [sigma=resolution]
std::vector<MuonCalib::SamplePoint> tr_points{}, ts_points{};
/// all the points in time,radius [RT] and time,sigma [resolution func]
- float multilayer_tmax_diff(-9e9);
+ float multilayer_tmax_diff{-std::numeric_limits<float>::max()};
// loop over RT function payload (triplets of radius,time,sigma(=resolution) )
for (unsigned int k = 0; k < radii.size(); ++k) {
@@ -463,8 +464,8 @@ StatusCode MdtCalibDbAlg::loadRt(const EventContext& ctx) const {
// TODO: What is this magic number
float rshift = m_rtShift * 1.87652e-2 * radius * (radius - *innerTubeRadius);
radius = oldradius + rshift;
- ATH_MSG_DEBUG("DEFORM RT: old radius " << oldradius << " new radius " << radius << " shift " << rshift << " max shift "
- << m_rtShift);
+ ATH_MSG_DEBUG("DEFORM RT: old radius " << oldradius << " new radius " << radius << " shift " << rshift
+ << " max shift " << m_rtShift);
}
if (m_rtScale != 1.) {
@@ -512,10 +513,9 @@ StatusCode MdtCalibDbAlg::loadRt(const EventContext& ctx) const {
std::unique_ptr<MuonCalib::IRtResolution> reso = getRtResolutionInterpolation(ts_points);
if (msgLvl(MSG::VERBOSE)) {
ATH_MSG_VERBOSE("Resolution points :");
- for (std::vector<MuonCalib::SamplePoint>::const_iterator it = tr_points.begin(); it != tr_points.end(); ++it) {
- ATH_MSG_VERBOSE(it->x1() << "|" << it->x2() << "|" << it->error());
+ for (const MuonCalib::SamplePoint& point : tr_points) {
+ ATH_MSG_VERBOSE(point.x1() << "|" << point.x2() << "|" << point.error());
}
-
ATH_MSG_DEBUG("Resolution parameters :");
for (unsigned int i = 0; i < reso->nPar(); i++) { ATH_MSG_VERBOSE(i << " " << reso->par(i)); }
}
@@ -524,141 +524,90 @@ StatusCode MdtCalibDbAlg::loadRt(const EventContext& ctx) const {
std::unique_ptr<MuonCalib::IRtRelation> rt = std::make_unique<MuonCalib::RtRelationLookUp>(MuonCalib::RtFromPoints::getRtRelationLookUp(tr_points));
if (!reso || !rt) { continue; }
- if (regionId >= writeCdoRt->size()) {
- ATH_MSG_ERROR("Illegal regionId " << regionId);
- return StatusCode::FAILURE;
- }
if (rt->par(1) == 0.) {
- ATH_MSG_WARNING("Bin size is 0");
+ ATH_MSG_FATAL("Bin size is 0");
for (const MuonCalib::SamplePoint& it: tr_points)
ATH_MSG_WARNING(it.x1() << " " << it.x2() << " " << it.error());
+ return StatusCode::FAILURE;
}
// Save ML difference if it is available
if (multilayer_tmax_diff > -8e8) { rt->SetTmaxDiff(multilayer_tmax_diff); }
// Store RT and resolution functions for this region
- std::unique_ptr<MuonCalib::MdtRtRelation> rt_rel = std::make_unique<MuonCalib::MdtRtRelation>(std::move(rt), std::move(reso), 0.);
- if (m_regionSvc->RegionType() == ONERT) {
- (*writeCdoRt)[0] = std::move(rt_rel);
- break; // only read one RT from COOL for ONERT option.
- // If doing ML2 RTs, and this is a ML2 RT function then add it to the end of writeCdoRt
- } else if (m_regionSvc->RegionType() == ONEPERMULTILAYER && m_idHelperSvc->mdtIdHelper().multilayer(athenaId) == 2) {
- ATH_MSG_VERBOSE("MdtCalibDbAlg::loadRt Load ML2 RT for region "
- << regionId << " " << m_idHelperSvc->toString(athenaId));
- (*writeCdoRt).push_back(std::move(rt_rel));
- IdentifierHash mlHash{0};
- m_idHelperSvc->mdtIdHelper().get_detectorElement_hash(athenaId, mlHash);
- m_regionSvc->setRegionHash(mlHash);
- } else { // store RT for chamber or ML1 if doing ONEPERMULTILAYER
- (*writeCdoRt)[regionId] = std::move(rt_rel);
- }
- } // end loop over itr (strings read from COOL)
- ATH_MSG_INFO("MdtCalibDbAlg::loadRt Read " << m_regionSvc->numberOfRegions() << "RTs from COOL");
+ RtRelationPtr rt_rel = std::make_unique<MuonCalib::MdtRtRelation>(std::move(rt), std::move(reso), 0.);
- // finally record writeCdo
- if (writeCdoRt->empty()) {
- ATH_MSG_ERROR("writeCdoRt.size()==0");
- return StatusCode::FAILURE;
- }
- const MdtRtRelationCollection *writeCdoRtPtr = writeCdoRt.get();
- ATH_CHECK(writeHandleRt.record(std::move(writeCdoRt)));
- ATH_MSG_INFO("recorded new " << writeHandleRt.key() << " with range " << writeHandleRt.getRange() << " into Conditions Store");
+ if (!writeCdo.storeData(athenaId ,rt_rel, msgStream())) return StatusCode::FAILURE;
+ if (!(m_create_b_field_function || m_createWireSagFunction|| m_createSlewingFunction)) continue;
+ loadedRtRel[athenaId] = rt_rel;
+
+ } // end loop over itr (strings read from COOL)
+ ATH_CHECK(defaultRt(writeCdo, loadedRtRel));
- if (m_writeKeyCor.empty()){
+ if (loadedRtRel.empty()) {
return StatusCode::SUCCESS;
}
- SG::WriteCondHandle<MdtCorFuncSetCollection> writeHandleCor{m_writeKeyCor, ctx};
- writeHandleCor.addDependency(readHandleRt);
-
- std::unique_ptr<MdtCorFuncSetCollection> writeCdoCor{std::make_unique<MdtCorFuncSetCollection>()};
- ATH_MSG_DEBUG("Initializing " << writeCdoCor->size() << " b-field functions");
- for (const MuonCalib::MdtRtRelation* rtRelation : * writeCdoRtPtr) {
- std::unique_ptr<MuonCalib::MdtCorFuncSet> corrFuncSet = std::make_unique<MuonCalib::MdtCorFuncSet>();
+
+ ATH_MSG_DEBUG("Initializing " << loadedRtRel.size()<< " b-field functions");
+ for (const auto& [athenaId, rtRelation] : loadedRtRel) {
+ CorrectionPtr corrFuncSet = std::make_unique<MuonCalib::MdtCorFuncSet>();
if (m_create_b_field_function) initialize_B_correction(*corrFuncSet, *rtRelation);
if (m_createWireSagFunction) initializeSagCorrection(*corrFuncSet);
if (m_createSlewingFunction) {
corrFuncSet->setSlewing(std::make_unique<MuonCalib::MdtSlewCorFuncHardcoded>(MuonCalib::CalibFunc::ParVec()));
}
- writeCdoCor->push_back(std::move(corrFuncSet));
+ if (!writeCdo.storeData(athenaId, corrFuncSet, msgStream())) return StatusCode::FAILURE;
}
-
- ATH_CHECK(writeHandleCor.record(std::move(writeCdoCor)));
- ATH_MSG_INFO("recorded new " << writeHandleCor.key() << " with range " << writeHandleCor.getRange() << " into Conditions Store");
+
return StatusCode::SUCCESS;
}
// build the transient structure and load some defaults for T0s
-StatusCode MdtCalibDbAlg::defaultT0s(MdtTubeCalibContainerCollection &writeCdoTube) const {
-
-
- // like MdtCalibDbCoolStrTool::defaultT0s()
- // m_tubeData is writeCdoTube here
+StatusCode MdtCalibDbAlg::defaultT0s(MuonCalib::MdtCalibDataContainer& writeCdo) const {
const MdtIdHelper& id_helper{m_idHelperSvc->mdtIdHelper()};
- writeCdoTube.resize(id_helper.module_hash_max());
- ATH_MSG_DEBUG(" Created new MdtTubeCalibContainerCollection size " << writeCdoTube.size());
-
+
// Inverse of wire propagation speed
- float inversePropSpeed = 1. / (Gaudi::Units::c_light * m_prop_beta);
+ const float inversePropSpeed = 1. / (Gaudi::Units::c_light * m_prop_beta);
// loop over modules (MDT chambers) and create an MdtTubeContainer for each
MdtIdHelper::const_id_iterator it = id_helper.module_begin();
MdtIdHelper::const_id_iterator it_end = id_helper.module_end();
for (; it != it_end; ++it) {
- // create an MdtTubeContainer
- std::unique_ptr<MuonCalib::MdtTubeCalibContainer> tubes = buildMdtTubeCalibContainer(*it);
- if (!tubes) {
- ATH_MSG_VERBOSE("Failed to create tube container for "<<m_idHelperSvc->toString(*it));
- continue;
+
+ if (writeCdo.hasDataForChannel(*it, msgStream())) {
+ const MdtFullCalibData* dataObj = writeCdo.getCalibData(*it, msgStream());
+ if (dataObj->tubeCalib) {
+ ATH_MSG_DEBUG("Rt relation constants for "<<m_idHelperSvc->toString(*it)<<" already exists");
+ continue;
+ }
}
+ // create an MdtTubeContainer
+ TubeContainerPtr tubes = std::make_unique<MuonCalib::MdtTubeCalibContainer>(m_idHelperSvc.get(), *it);
+ if (!writeCdo.storeData(*it, tubes, msgStream())) return StatusCode::FAILURE;
+
// is tubes ever 0? how could that happen?
-
- std::string rName = tubes->regionKey();
double t0 = m_defaultT0;
unsigned int nml = tubes->numMultilayers();
unsigned int nlayers = tubes->numLayers();
unsigned int ntubes = tubes->numTubes();
int size = nml * nlayers * ntubes;
- ATH_MSG_VERBOSE("Adding chamber " << m_idHelperSvc->toString(*it));
- ATH_MSG_VERBOSE(" size " << size << " ml " << nml << " l " << nlayers << " t " << ntubes);
- for (unsigned int ml = 0; ml < nml; ++ml) {
- for (unsigned int l = 0; l < nlayers; ++l) {
- for (unsigned int t = 0; t < ntubes; ++t) {
+
+ ATH_MSG_VERBOSE("Adding chamber " << m_idHelperSvc->toString(*it)
+ <<" size " << size << " ml " << nml << " l " << nlayers << " t " << ntubes);
+ for (unsigned int ml = 1; ml <= nml; ++ml) {
+ for (unsigned int l = 1; l <= nlayers; ++l) {
+ for (unsigned int t = 1; t <= ntubes; ++t) {
MuonCalib::MdtTubeCalibContainer::SingleTubeCalib data;
+ const Identifier tubeId = id_helper.channelID(*it, ml, l, t);
data.t0 = t0;
data.adcCal = 1.;
data.inversePropSpeed = inversePropSpeed;
- tubes->setCalib(ml, l, t, data);
+ tubes->setCalib(std::move(data), tubeId, msgStream());
}
}
}
-
- ATH_MSG_VERBOSE(" set t0's done ");
- IdentifierHash hash{0};
- if (m_idHelperSvc->mdtIdHelper().get_module_hash(*it, hash)) {
- ATH_MSG_ERROR("Could not retrieve module hash for identifier " << m_idHelperSvc->toString(*it));
- return StatusCode::FAILURE;
- }
-
- if (hash < writeCdoTube.size()) {
- writeCdoTube[hash] = std::move(tubes);
- ATH_MSG_VERBOSE(" adding tubes at " << hash << " current size " << writeCdoTube.size());
- // write out string for chamberlist
- if (tubes) {
- int nml = tubes->numMultilayers();
- int nlayers = tubes->numLayers();
- int ntubes = tubes->numTubes();
- ATH_MSG_VERBOSE("CHAMBERLIST: " << m_idHelperSvc->toStringChamber(*it) << " "
- << " " << nml * nlayers * ntubes << " " << nml << " " << nlayers << " " << ntubes << " dummy " << hash);
- }
- } else {
- ATH_MSG_ERROR(" HashId out of range " << hash << " max " << writeCdoTube.size());
- return StatusCode::FAILURE;
- }
}
- ATH_MSG_DEBUG(" Done defaultT0s " << writeCdoTube.size());
-
return StatusCode::SUCCESS;
-} // end MdtCalibDbAlg::defaultT0s
+}
StatusCode MdtCalibDbAlg::legacyTubePayloadToJSON(const coral::AttributeList& attr,nlohmann::json & json) const {
@@ -747,7 +696,7 @@ StatusCode MdtCalibDbAlg::legacyTubePayloadToJSON(const coral::AttributeList& at
const Identifier secondMlID = idHelper.multilayerID(chamID, numMl);
const int tubesPerLay = std::max(idHelper.tubeMax(chamID), idHelper.tubeMax(secondMlID));
const int numLayers = std::max(idHelper.tubeLayerMax(chamID), idHelper.tubeLayerMax(secondMlID));
- if ( m_checkTubes && (numMl * numLayers * tubesPerLay) != nTubes) {
+ if (m_checkTubes && (numMl * numLayers * tubesPerLay) != nTubes) {
ATH_MSG_FATAL("Calibration database differs in terms of number of tubes for chamber "
<<m_idHelperSvc->toStringChamber(chamID)<<". Expected "<<(numMl * numLayers * tubesPerLay)
<<" vs. observed "<<nTubes);
@@ -777,27 +726,12 @@ StatusCode MdtCalibDbAlg::legacyTubePayloadToJSON(const coral::AttributeList& at
json.push_back(channel);
return StatusCode::SUCCESS;
}
-StatusCode MdtCalibDbAlg::loadTube(const EventContext& ctx) const {
+StatusCode MdtCalibDbAlg::loadTube(const EventContext& ctx, MuonCalib::MdtCalibDataContainer& writeCdo) const {
ATH_MSG_DEBUG("loadTube " << name());
const MdtIdHelper& idHelper{m_idHelperSvc->mdtIdHelper()};
- SG::WriteCondHandle<MdtTubeCalibContainerCollection> writeHandleTube{m_writeKeyTube, ctx};
- if (writeHandleTube.isValid()) {
- ATH_MSG_DEBUG("CondHandle " << writeHandleTube.fullKey() << " is already valid.");
- return StatusCode::SUCCESS;
- }
- std::unique_ptr<MdtTubeCalibContainerCollection> writeCdoTube{std::make_unique<MdtTubeCalibContainerCollection>()};
-
- // like MdtCalibDbCoolStrTool::loadTube()
- // m_tubeData is writeCdoTube here
- // atrc is readCdoTube here
- ATH_CHECK(defaultT0s(*writeCdoTube));
-
// Read Cond Handle
SG::ReadCondHandle<CondAttrListCollection> readHandleTube{m_readKeyTube, ctx};
- writeHandleTube.addDependency(readHandleTube);
- ATH_MSG_INFO("Size of CondAttrListCollection " << readHandleTube.fullKey() << " readCdoTube->size()= " << readHandleTube->size());
- ATH_MSG_INFO("Range of input is " << readHandleTube.getRange());
// read new-style format 2020
nlohmann::json t0CalibJson = nlohmann::json::array();
if (m_newFormat2020) {
@@ -832,7 +766,7 @@ StatusCode MdtCalibDbAlg::loadTube(const EventContext& ctx) const {
}
// Inverse of wire propagation speed
- float inversePropSpeed = 1. / (Gaudi::Units::c_light * m_prop_beta);
+ const float inversePropSpeed = 1. / (Gaudi::Units::c_light * m_prop_beta);
// unpack the strings in the collection and update the
// MdtTubeCalibContainers in TDS
@@ -843,7 +777,7 @@ StatusCode MdtCalibDbAlg::loadTube(const EventContext& ctx) const {
const bool t0_ts_applied = chambChannel["appliedT0"];
// need to check validity of Identifier since database contains all Run 2 MDT chambers, e.g. also EI chambers which are
// potentially replaced by NSW
- bool isValid = true; // the elementID takes a bool pointer to check the validity of the Identifier
+ bool isValid{false}; // the elementID takes a bool pointer to check the validity of the Identifier
const Identifier chId = idHelper.elementID(stName, ieta, iphi, isValid);
if (!isValid) {
static std::atomic<bool> idWarningPrinted = false;
@@ -855,37 +789,20 @@ StatusCode MdtCalibDbAlg::loadTube(const EventContext& ctx) const {
continue;
}
- MuonCalib::MdtTubeCalibContainer *tubes = nullptr;
- // get chamber hash
- IdentifierHash hash{0};
- if (m_idHelperSvc->mdtIdHelper().get_module_hash(chId, hash))
- ATH_MSG_WARNING("Retrieving module hash for Identifier " << m_idHelperSvc->toString(chId) << " failed");
-
- // we have to check whether the retrieved Identifier is valid. The problem is that the is_valid() function of the Identifier class
- // does only check for the size of the number, not for the physical validity. The get_detectorElement_hash function of the
- // MuonIdHelper however returns an error in case the Identifier is not part of the vector of physically valid Identifiers (the check
- // could also be done using the module hash) It is important that the methods from MuonIdHelper are called which are not overwritten
- // by the MdtIdHelper
- IdentifierHash detElHash{0};
- if (m_idHelperSvc->mdtIdHelper().MuonIdHelper::get_detectorElement_hash(chId, detElHash)) {
- ATH_MSG_WARNING("Retrieving detector element hash for Identifier "
- << chId.get_compact() << " failed, thus Identifier (original information was name=" << stName << ", eta=" << ieta
- << ", phi=" << iphi << ") is not valid, skipping...");
- continue;
+ if (writeCdo.hasDataForChannel(chId, msgStream())) {
+ const MdtFullCalibData* dataObj = writeCdo.getCalibData(chId, msgStream());
+ if (dataObj->tubeCalib) {
+ ATH_MSG_DEBUG("Rt relation constants for "<<m_idHelperSvc->toString(chId)<<" already exists");
+ continue;
+ }
}
-
- if (hash >= writeCdoTube->size()) {
- ATH_MSG_ERROR("Illegal station (1)! (" << stName << "," << iphi << "," << ieta << ")");
+
+ TubeContainerPtr tubes = std::make_unique<MdtTubeCalibContainer>(m_idHelperSvc.get(), chId);
+ if (!writeCdo.storeData(chId, tubes, msgStream())) {
+ ATH_MSG_FATAL(__FILE__<<":"<<__LINE__<<" Failed to add chamber "<<m_idHelperSvc->toString(chId)
+ <<" ID fields: "<<stName<<","<<ieta<<","<<iphi);
return StatusCode::FAILURE;
}
-
- // retrieve the existing one (created by defaultt0() )
- tubes = (*writeCdoTube)[hash];
-
- if (!tubes) {
- ATH_MSG_INFO("Illegal station (2)! (" << stName << "," << iphi << "," << ieta << ")");
- continue;
- }
nlohmann::json tubeConstants = chambChannel["calibConstants"];
for (const auto& tubeChannel : tubeConstants) {
const int ml = tubeChannel["ml"];
@@ -912,69 +829,17 @@ StatusCode MdtCalibDbAlg::loadTube(const EventContext& ctx) const {
datatube.inversePropSpeed = inversePropSpeed;
datatube.t0 = tzero;
datatube.adcCal = meanAdc;
- tubes->setCalib(ml - 1, l - 1, t - 1, datatube);
+ const Identifier tubeId = idHelper.channelID(chId, ml, l, t);
+ tubes->setCalib(std::move(datatube), tubeId, msgStream());
}
} // end loop over readCdoTube
+ ATH_CHECK(defaultT0s(writeCdo));
// finally record writeCdo
-
- if (writeCdoTube->empty()) {
- ATH_MSG_WARNING("writeCdoTube->size()==0");
- return StatusCode::FAILURE;
- }
- ATH_CHECK(writeHandleTube.record(std::move(writeCdoTube)));
- ATH_MSG_INFO("recorded new " << writeHandleTube.key() << " with range " << writeHandleTube.getRange() << " into Conditions Store");
-
return StatusCode::SUCCESS;
}
-MdtCalibDbAlg::chamberDim MdtCalibDbAlg::getChamberDimension(const Identifier& id) const {
- const MdtIdHelper& id_helper{m_idHelperSvc->mdtIdHelper()};
- chamberDim dim{};
- dim.multilayers = id_helper.numberOfMultilayers(id);
- if (m_detMgr) {
- const MuonGM::MdtReadoutElement* detEl = m_detMgr->getMdtReadoutElement(id_helper.multilayerID(id, 1));
- const MuonGM::MdtReadoutElement* detEl2 = dim.multilayers == 2 ?
- m_detMgr->getMdtReadoutElement(id_helper.multilayerID(id, 2)) : nullptr;
- if (!detEl) return dim;
- dim.layers = std::max(detEl->getNLayers(), detEl2 ? detEl2->getNLayers() : 0);
- dim.tubes = std::max(detEl->getNtubesperlayer(), detEl2 ? detEl2->getNtubesperlayer() : 0);
- } else if (m_r4detMgr) {
- const MuonGMR4::MdtReadoutElement* detEl = m_r4detMgr->getMdtReadoutElement(id_helper.multilayerID(id, 1));
- const MuonGMR4::MdtReadoutElement* detEl2 = dim.multilayers == 2 ?
- m_r4detMgr->getMdtReadoutElement(id_helper.multilayerID(id, 2)) : nullptr;
- if (!detEl) return dim;
- dim.layers = std::max(detEl->numLayers(), detEl2 ? detEl2->numLayers() : 0);
- dim.tubes = std::max(detEl->numTubesInLay(), detEl2 ? detEl2->numTubesInLay() : 0);
- }
- return dim;
-}
-// Build a MuonCalib::MdtTubeCalibContainer for a given Identifier
-std::unique_ptr<MuonCalib::MdtTubeCalibContainer> MdtCalibDbAlg::buildMdtTubeCalibContainer(const Identifier &id) const {
- const MdtIdHelper& id_helper{m_idHelperSvc->mdtIdHelper()};
- const chamberDim dim = getChamberDimension(id);
- if (!dim) {
- static std::atomic<bool> warningPrinted = false;
- if (!warningPrinted) {
- ATH_MSG_WARNING("buildMdtTubeCalibContainer() - Ignoring nonexistant station in calibration DB: "
- << m_idHelperSvc->toString(id) << ", cf. ATLASRECTS-6035");
- warningPrinted = true;
- }
- return nullptr;
- }
- // build the region name in the format STATION_ETA_PHI
- int stName = id_helper.stationName(id);
- int stPhi = id_helper.stationPhi(id);
- int stEta = id_helper.stationEta(id);
-
- std::stringstream rName{};
- rName<<id_helper.stationNameString(stName)<<"_";
- rName<<stPhi<<"_"<<stEta;
- return std::make_unique<MuonCalib::MdtTubeCalibContainer>(rName.str(), dim.multilayers, dim.layers, dim.tubes);
-} // end MdtCalibDbAlg::buildMdtTubeCalibContainer
-
-std::unique_ptr<MuonCalib::RtResolutionLookUp> MdtCalibDbAlg::getRtResolutionInterpolation(
- const std::vector<MuonCalib::SamplePoint> &sample_points) {
+std::unique_ptr<MuonCalib::RtResolutionLookUp> MdtCalibDbAlg::getRtResolutionInterpolation(const std::vector<MuonCalib::SamplePoint> &sample_points) {
///////////////
// VARIABLES //
///////////////
@@ -1008,21 +873,6 @@ std::unique_ptr<MuonCalib::RtResolutionLookUp> MdtCalibDbAlg::getRtResolutionInt
return std::make_unique<MuonCalib::RtResolutionLookUp>(std::move(res_param));
}
-StatusCode MdtCalibDbAlg::extractString(std::string &input, std::string &output, const std::string& separator) const {
- unsigned long int pos = 0;
- std::string::size_type start = input.find_first_not_of(separator.c_str(), pos);
- if (start == std::string::npos) {
- ATH_MSG_ERROR("MdtCalibDbAlg::extractString: Cannot extract string in a proper way!");
- return StatusCode::FAILURE;
- }
- std::string::size_type stop = input.find_first_of(separator.c_str(), start + 1);
- if (stop == std::string::npos) stop = input.size();
- output = input.substr(start, stop - start);
- input.erase(pos, stop - pos);
-
- return StatusCode::SUCCESS;
-}
-
// like MdtCalibrationDbSvc
// for corData in loadRt
void MdtCalibDbAlg::initialize_B_correction(MuonCalib::MdtCorFuncSet& funcSet, const MuonCalib::MdtRtRelation& rt_rel) const {
diff --git a/MuonSpectrometer/MuonConditions/MuonCondGeneral/MuonCondDump/CMakeLists.txt b/MuonSpectrometer/MuonConditions/MuonCondGeneral/MuonCondDump/CMakeLists.txt
index 13433caac65..fcbfdb76d04 100644
--- a/MuonSpectrometer/MuonConditions/MuonCondGeneral/MuonCondDump/CMakeLists.txt
+++ b/MuonSpectrometer/MuonConditions/MuonCondGeneral/MuonCondDump/CMakeLists.txt
@@ -14,7 +14,7 @@ atlas_add_component( MuonCondDump
INCLUDE_DIRS ${ROOT_INCLUDE_DIRS}
LINK_LIBRARIES ${CORAL_LIBRARIES} ${ROOT_LIBRARIES} AthenaBaseComps AthenaKernel CoralUtilitiesLib GaudiKernel
GeoPrimitives Identifier MuonAlignmentData MuonCondData MuonCondInterface MuonCondSvcLib MuonIdHelpersLib
- MuonReadoutGeometry StoreGateLib MuonCablingData )
+ MuonReadoutGeometry StoreGateLib MuonCablingData)
# Install files from the package:
atlas_install_python_modules( python/*.py )
diff --git a/MuonSpectrometer/MuonConfig/python/MDT_DigitizationConfig.py b/MuonSpectrometer/MuonConfig/python/MDT_DigitizationConfig.py
index 598f088f8c8..c64d1ea8346 100644
--- a/MuonSpectrometer/MuonConfig/python/MDT_DigitizationConfig.py
+++ b/MuonSpectrometer/MuonConfig/python/MDT_DigitizationConfig.py
@@ -1,6 +1,6 @@
"""Define methods to construct configured MDT Digitization tools and algorithms
-Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
+Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
"""
from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
from AthenaConfiguration.ComponentFactory import CompFactory
@@ -9,7 +9,6 @@ from OutputStreamAthenaPool.OutputStreamConfig import OutputStreamCfg
from MuonConfig.MuonGeometryConfig import MuonGeoModelCfg
from MuonConfig.MuonByteStreamCnvTestConfig import MdtDigitToMdtRDOCfg
from MuonConfig.MuonCablingConfig import MDTCablingConfigCfg
-from MuonConfig.MuonCalibrationConfig import MdtCalibrationDbToolCfg
from Digitization.TruthDigitizationOutputConfig import TruthDigitizationOutputCfg
from Digitization.PileUpToolsConfig import PileUpToolsCfg
from Digitization.PileUpMergeSvcConfig import PileUpMergeSvcCfg, PileUpXingFolderCfg
@@ -38,10 +37,7 @@ def MDT_RangeCfg(flags, name="MDT_Range", **kwargs):
def RT_Relation_DB_DigiToolCfg(flags, name="RT_Relation_DB_DigiTool", **kwargs):
"""Return an RT_Relation_DB_DigiTool"""
acc = ComponentAccumulator()
- RT_Relation_DB_DigiTool = CompFactory.RT_Relation_DB_DigiTool
- calibDbTool = acc.popToolsAndMerge(MdtCalibrationDbToolCfg(flags))
- kwargs.setdefault("CalibrationDbTool", calibDbTool)
- acc.setPrivateTools(RT_Relation_DB_DigiTool(name, **kwargs))
+ acc.setPrivateTools(CompFactory.RT_Relation_DB_DigiTool(name, **kwargs))
return acc
@@ -58,14 +54,16 @@ def MDT_Response_DigiToolCfg(flags, name="MDT_Response_DigiTool",**kwargs):
def MDT_DigitizationToolCommonCfg(flags, name="MdtDigitizationTool", **kwargs):
"""Return ComponentAccumulator with common MdtDigitizationTool config"""
from MuonConfig.MuonCondAlgConfig import MdtCondDbAlgCfg # MT-safe conditions access
- acc = MdtCondDbAlgCfg(flags)
- calibDbTool = acc.popToolsAndMerge(MdtCalibrationDbToolCfg(flags))
- kwargs.setdefault("CalibrationDbTool", calibDbTool)
+ from MuonConfig.MuonCalibrationConfig import MdtCalibDbAlgCfg
+
+ acc = ComponentAccumulator()
+ acc.merge(MdtCondDbAlgCfg(flags))
+ acc.merge(MdtCalibDbAlgCfg(flags))
+
kwargs.setdefault("DiscardEarlyHits", True)
kwargs.setdefault("UseTof", flags.Beam.Type is not BeamType.Cosmics)
# "RT_Relation_DB_DigiTool" in jobproperties.Digitization.experimentalDigi() not migrated
- digiTool = acc.popToolsAndMerge(MDT_Response_DigiToolCfg(flags))
- kwargs.setdefault("DigitizationTool", digiTool)
+ kwargs.setdefault("DigitizationTool", acc.popToolsAndMerge(MDT_Response_DigiToolCfg(flags)))
QballConfig = (flags.Input.SpecialConfiguration.get("MDT_QballConfig", "False") == "True")
kwargs.setdefault("DoQballCharge", QballConfig)
if flags.Digitization.DoXingByXingPileUp:
@@ -133,6 +131,8 @@ def MDT_DigitizationBasicCfg(flags, **kwargs):
def MDT_OverlayDigitizationBasicCfg(flags, **kwargs):
"""Return ComponentAccumulator with MDT Overlay digitization"""
acc = MuonGeoModelCfg(flags)
+ from MuonConfig.MuonCalibrationConfig import MdtCalibDbAlgCfg
+ acc.merge(MdtCalibDbAlgCfg(flags))
if flags.Common.ProductionStep != ProductionStep.FastChain:
from SGComps.SGInputLoaderConfig import SGInputLoaderCfg
diff --git a/MuonSpectrometer/MuonConfig/python/MuonCalibrationConfig.py b/MuonSpectrometer/MuonConfig/python/MuonCalibrationConfig.py
index aa77be43aef..530f3199377 100644
--- a/MuonSpectrometer/MuonConfig/python/MuonCalibrationConfig.py
+++ b/MuonSpectrometer/MuonConfig/python/MuonCalibrationConfig.py
@@ -79,11 +79,10 @@ def _setupMdtCondDB(flags):
return result, mdt_folder_name_appendix
# end of function setupMdtCondDB()
-def MdtCalibrationToolCfg(flags, **kwargs):
- result=MdtCalibrationDbToolCfg(flags)
- mdt_calibration_db_tool = result.getPrimary()
-
- kwargs.setdefault("CalibrationDbTool", mdt_calibration_db_tool)
+def MdtCalibrationToolCfg(flags, name= "MdtCalibrationTool", **kwargs):
+ result=ComponentAccumulator()
+ result.merge(MdtCalibDbAlgCfg(flags))
+
kwargs.setdefault("DoSlewingCorrection", flags.Muon.Calib.correctMdtRtForTimeSlewing)
kwargs.setdefault("DoTemperatureCorrection", flags.Muon.Calib.applyRtScaling)
kwargs.setdefault("DoWireSagCorrection", flags.Muon.Calib.correctMdtRtWireSag)
@@ -93,30 +92,15 @@ def MdtCalibrationToolCfg(flags, **kwargs):
from MuonConfig.MuonRIO_OnTrackCreatorToolConfig import MdtCalibWindowNumber
kwargs.setdefault("TimeWindowSetting", MdtCalibWindowNumber('Collision_G4'))
- acc = AtlasFieldCacheCondAlgCfg(flags)
- result.merge(acc)
+ result.merge(AtlasFieldCacheCondAlgCfg(flags))
- MdtCalibrationTool = CompFactory.MdtCalibrationTool
- mdt_calibration_tool = MdtCalibrationTool(**kwargs)
+ mdt_calibration_tool = CompFactory.MdtCalibrationTool(name= name, **kwargs)
result.setPrivateTools(mdt_calibration_tool)
return result
-def MdtCalibrationDbToolCfg(flags, **kwargs):
- # We need the conditions objects to have been created.
- result = MdtCalibDbAlgCfg(flags, **kwargs)
-
- kwargs.setdefault("CreateBFieldFunctions", flags.Muon.Calib.correctMdtRtForBField)
- kwargs.setdefault("CreateWireSagFunctions", flags.Muon.Calib.correctMdtRtWireSag)
- kwargs.setdefault("CreateSlewingFunctions", flags.Muon.Calib.correctMdtRtForTimeSlewing)
- kwargs.setdefault("WasConfigured", True)
-
- MdtCalibrationDbTool = CompFactory.MdtCalibrationDbTool
- mdt_calibration_db_tool = MdtCalibrationDbTool(**kwargs)
- result.setPrivateTools(mdt_calibration_db_tool)
- return result
-
def MdtCalibDbAlgCfg(flags,name="MdtCalibDbAlg",**kwargs):
- result = MuonGeoModelCfg(flags)
+ result = ComponentAccumulator()
+ result.merge(MuonGeoModelCfg(flags))
# setup COOL folders
acc, mdt_folder_name_appendix = _setupMdtCondDB(flags)
@@ -129,7 +113,7 @@ def MdtCalibDbAlgCfg(flags,name="MdtCalibDbAlg",**kwargs):
else:
kwargs.setdefault("ReadKeyTube", "/MDT/T0"+ mdt_folder_name_appendix)
kwargs.setdefault("ReadKeyRt", "/MDT/RT"+ mdt_folder_name_appendix)
- kwargs.setdefault("RT_InputFiles" , ["Muon_RT_default.data"])
+ kwargs.setdefault("RT_InputFile" , "Muon_RT_default.data")
if flags.Input.isMC is False: # Should be " if flags.Input.isMC=='data' " ?
kwargs.setdefault("defaultT0", 40)
else:
@@ -148,7 +132,7 @@ def MdtCalibDbAlgCfg(flags,name="MdtCalibDbAlg",**kwargs):
kwargs.setdefault("UseR4DetMgr", flags.Muon.setupGeoModelXML)
alg = CompFactory.MdtCalibDbAlg (name, **kwargs)
- result.addCondAlgo (alg)
+ result.addCondAlgo (alg, primary = True)
return result
def NSWCalibToolCfg(flags, name="NSWCalibTool", **kwargs):
diff --git a/MuonSpectrometer/MuonConfig/python/MuonRIO_OnTrackCreatorToolConfig.py b/MuonSpectrometer/MuonConfig/python/MuonRIO_OnTrackCreatorToolConfig.py
index dfad4304f83..1d0fb371898 100644
--- a/MuonSpectrometer/MuonConfig/python/MuonRIO_OnTrackCreatorToolConfig.py
+++ b/MuonSpectrometer/MuonConfig/python/MuonRIO_OnTrackCreatorToolConfig.py
@@ -3,7 +3,7 @@
from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
from AthenaConfiguration.ComponentFactory import CompFactory
from AthenaConfiguration.Enums import BeamType
-from MuonConfig.MuonCalibrationConfig import MdtCalibrationToolCfg, MdtCalibrationDbToolCfg
+from MuonConfig.MuonCalibrationConfig import MdtCalibrationToolCfg
### Simple function holding connecting names to the different calibration window options
# The window values themselves are defined in C++ in MdtCalibSvc/MdtCalibrationSvcSettings.h
@@ -61,37 +61,36 @@ def CscClusterOnTrackCreatorCfg(flags,name="CscClusterOnTrackCreator", **kwargs)
def MdtDriftCircleOnTrackCreatorCfg(flags,name="MdtDriftCircleOnTrackCreator", **kwargs):
result=ComponentAccumulator()
-
- # setup dependencies missing in C++. TODO: fix in C++
- #
- # acc = MdtCalibrationDbSvcCfg(flags)
- # result.merge(acc)
-
- kwargs.setdefault("CalibrationDbTool", result.popToolsAndMerge( MdtCalibrationDbToolCfg(flags)))
- kwargs.setdefault("CalibrationTool", result.popToolsAndMerge( MdtCalibrationToolCfg(flags)) )
+ margs = dict()
+ margs.setdefault("DoMagneticFieldCorrection", flags.Muon.Calib.correctMdtRtForBField)
+ margs.setdefault("DoWireSagCorrection", flags.Muon.useWireSagCorrections)
+ margs.setdefault("DoSlewingCorrection", flags.Muon.Calib.correctMdtRtForTimeSlewing)
- kwargs.setdefault("DoMagneticFieldCorrection", flags.Muon.Calib.correctMdtRtForBField)
- kwargs.setdefault("DoWireSag", flags.Muon.useWireSagCorrections)
- kwargs.setdefault("DoSlewingCorrection", flags.Muon.Calib.correctMdtRtForTimeSlewing)
if flags.Beam.Type in [BeamType.Cosmics, BeamType.SingleBeam]:
- kwargs.setdefault("DoTofCorrection", False)
+ margs.setdefault("DoTofCorrection", False)
kwargs.setdefault("DoFixedError", True)
kwargs.setdefault("TimingMode", 1)
kwargs.setdefault("UseParametrisedError", True)
kwargs.setdefault("ApplyToF", False)
else: # collisions simulation/data settings
- kwargs.setdefault("DoTofCorrection", True)
+ margs.setdefault("DoTofCorrection", True)
kwargs.setdefault("DoFixedError", False)
kwargs.setdefault("DoErrorScaling", False)
- kwargs.setdefault("TimeWindowSetting", MdtCalibWindowNumber('Collision_data')) # MJW: should this be Collision_G4 ???
+ margs.setdefault("TimeWindowSetting", MdtCalibWindowNumber('Collision_data')) # MJW: should this be Collision_G4 ???
kwargs.setdefault("UseParametrisedError", False)
if not flags.Input.isMC :
kwargs.setdefault("CreateTubeHit", True) # BroadErrors
kwargs.setdefault("UseLooseErrors", flags.Muon.useLooseErrorTuning) # LooseErrors on data
+ calibSettings = ["DoTofCorrection", "TimeWindowSetting"]
+ for cSett in calibSettings:
+ if cSett in kwargs:
+ margs[cSett] = kwargs.pop(cSett)
+
+ kwargs.setdefault("CalibrationTool", result.popToolsAndMerge( MdtCalibrationToolCfg(flags, **margs)) )
kwargs.setdefault("IsMC", flags.Input.isMC)
result.setPrivateTools(CompFactory.Muon.MdtDriftCircleOnTrackCreator(name, WasConfigured=True, **kwargs))
diff --git a/MuonSpectrometer/MuonConfig/python/MuonRdoDecodeConfig.py b/MuonSpectrometer/MuonConfig/python/MuonRdoDecodeConfig.py
index 3c83a527d92..eb722d8a68d 100644
--- a/MuonSpectrometer/MuonConfig/python/MuonRdoDecodeConfig.py
+++ b/MuonSpectrometer/MuonConfig/python/MuonRdoDecodeConfig.py
@@ -210,7 +210,9 @@ def MdtRDODecodeCfg(flags, name="MdtRdoToMdtPrepData", **kwargs):
# Get the RDO -> PRD tool
kwargs.setdefault("DecodingTool", CompFactory.Muon.MdtRdoToPrepDataToolMT(name="MdtPrepDataProviderTool",
UseTwin=True,
- CalibrationTool=acc.popToolsAndMerge(MdtCalibrationToolCfg(flags, TimeWindowSetting = 2))))
+ CalibrationTool=acc.popToolsAndMerge(MdtCalibrationToolCfg(flags,
+ TimeWindowSetting = 2,
+ DoPropagationCorrection = False))))
# add RegSelTool
from RegionSelector.RegSelToolConfig import regSelTool_MDT_Cfg
diff --git a/MuonSpectrometer/MuonConfig/python/MuonSegmentFindingConfig.py b/MuonSpectrometer/MuonConfig/python/MuonSegmentFindingConfig.py
index e5a4cd69d75..f99c926fccf 100644
--- a/MuonSpectrometer/MuonConfig/python/MuonSegmentFindingConfig.py
+++ b/MuonSpectrometer/MuonConfig/python/MuonSegmentFindingConfig.py
@@ -21,7 +21,6 @@ from AthenaConfiguration.Enums import BeamType, Format
# Csc2dSegmentMaker, Csc4dSegmentMaker=CompFactory.getComps("Csc2dSegmentMaker","Csc4dSegmentMaker",)
#Local
-from MuonConfig.MuonCalibrationConfig import MdtCalibrationDbToolCfg
from TrkConfig.TrkGlobalChi2FitterConfig import MCTBFitterCfg, MCTBSLFitterCfg, MCTBSLFitterMaterialFromTrackCfg
from MuonConfig.MuonRecToolsConfig import MuonAmbiProcessorCfg, MuonTrackCleanerCfg, MuonEDMPrinterToolCfg
from MuonConfig.MuonCondAlgConfig import MuonStationIntersectCondAlgCfg
@@ -116,9 +115,7 @@ def MuonSegmentFittingToolCfg(flags, name = "MuonSegmentFittingTool", **kwargs)
return result
def MdtSegmentT0FitterCfg(flags, name="MdtSegmentT0Fitter", **kwargs):
- result = MdtCalibrationDbToolCfg(flags) # Needed by MdtSegmentT0Fitter
- kwargs.setdefault("CalibrationDbTool", result.popPrivateTools())
-
+ result = ComponentAccumulator()
kwargs.setdefault("FloatSegDirection", flags.Beam.Type is BeamType.Cosmics)
result.setPrivateTools(CompFactory.TrkDriftCircleMath.MdtSegmentT0Fitter(name, **kwargs))
return result
diff --git a/MuonSpectrometer/MuonConfig/share/MdtRdoToPrepDataTool_test.ref b/MuonSpectrometer/MuonConfig/share/MdtRdoToPrepDataTool_test.ref
index 442a4c9561a..8b709e5f51c 100644
--- a/MuonSpectrometer/MuonConfig/share/MdtRdoToPrepDataTool_test.ref
+++ b/MuonSpectrometer/MuonConfig/share/MdtRdoToPrepDataTool_test.ref
@@ -1,856 +1,856 @@
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (25), layer(1), phi(6), eta(-1), name(54), multilayerId(1) and identifier 0x7f3d030000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (26), layer(1), phi(6), eta(-1), name(54), multilayerId(1) and identifier 0x7f3d032000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (27), layer(1), phi(6), eta(-1), name(54), multilayerId(1) and identifier 0x7f3d034000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (28), layer(1), phi(6), eta(-1), name(54), multilayerId(1) and identifier 0x7f3d036000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (29), layer(1), phi(6), eta(-1), name(54), multilayerId(1) and identifier 0x7f3d038000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (30), layer(1), phi(6), eta(-1), name(54), multilayerId(1) and identifier 0x7f3d03a000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (24), layer(2), phi(6), eta(-1), name(54), multilayerId(1) and identifier 0x7f3d12e000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (25), layer(2), phi(6), eta(-1), name(54), multilayerId(1) and identifier 0x7f3d130000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (26), layer(2), phi(6), eta(-1), name(54), multilayerId(1) and identifier 0x7f3d132000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (27), layer(2), phi(6), eta(-1), name(54), multilayerId(1) and identifier 0x7f3d134000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (28), layer(2), phi(6), eta(-1), name(54), multilayerId(1) and identifier 0x7f3d136000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (29), layer(2), phi(6), eta(-1), name(54), multilayerId(1) and identifier 0x7f3d138000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (30), layer(2), phi(6), eta(-1), name(54), multilayerId(1) and identifier 0x7f3d13a000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (25), layer(3), phi(6), eta(-1), name(54), multilayerId(1) and identifier 0x7f3d230000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (26), layer(3), phi(6), eta(-1), name(54), multilayerId(1) and identifier 0x7f3d232000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (27), layer(3), phi(6), eta(-1), name(54), multilayerId(1) and identifier 0x7f3d234000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (28), layer(3), phi(6), eta(-1), name(54), multilayerId(1) and identifier 0x7f3d236000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (29), layer(3), phi(6), eta(-1), name(54), multilayerId(1) and identifier 0x7f3d238000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (30), layer(3), phi(6), eta(-1), name(54), multilayerId(1) and identifier 0x7f3d23a000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (31), layer(3), phi(6), eta(-1), name(54), multilayerId(1) and identifier 0x7f3d23c000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (25), layer(4), phi(6), eta(-1), name(54), multilayerId(1) and identifier 0x7f3d330000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (26), layer(4), phi(6), eta(-1), name(54), multilayerId(1) and identifier 0x7f3d332000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (27), layer(4), phi(6), eta(-1), name(54), multilayerId(1) and identifier 0x7f3d334000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (28), layer(4), phi(6), eta(-1), name(54), multilayerId(1) and identifier 0x7f3d336000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (29), layer(4), phi(6), eta(-1), name(54), multilayerId(1) and identifier 0x7f3d338000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (30), layer(4), phi(6), eta(-1), name(54), multilayerId(1) and identifier 0x7f3d33a000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (31), layer(4), phi(6), eta(-1), name(54), multilayerId(1) and identifier 0x7f3d33c000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (31), layer(1), phi(6), eta(-1), name(54), multilayerId(2) and identifier 0x7f3d43c000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (32), layer(1), phi(6), eta(-1), name(54), multilayerId(2) and identifier 0x7f3d43e000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (33), layer(1), phi(6), eta(-1), name(54), multilayerId(2) and identifier 0x7f3d440000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (34), layer(1), phi(6), eta(-1), name(54), multilayerId(2) and identifier 0x7f3d442000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (35), layer(1), phi(6), eta(-1), name(54), multilayerId(2) and identifier 0x7f3d444000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (36), layer(1), phi(6), eta(-1), name(54), multilayerId(2) and identifier 0x7f3d446000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (37), layer(1), phi(6), eta(-1), name(54), multilayerId(2) and identifier 0x7f3d448000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (30), layer(2), phi(6), eta(-1), name(54), multilayerId(2) and identifier 0x7f3d53a000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (31), layer(2), phi(6), eta(-1), name(54), multilayerId(2) and identifier 0x7f3d53c000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (32), layer(2), phi(6), eta(-1), name(54), multilayerId(2) and identifier 0x7f3d53e000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (33), layer(2), phi(6), eta(-1), name(54), multilayerId(2) and identifier 0x7f3d540000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (34), layer(2), phi(6), eta(-1), name(54), multilayerId(2) and identifier 0x7f3d542000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (35), layer(2), phi(6), eta(-1), name(54), multilayerId(2) and identifier 0x7f3d544000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (36), layer(2), phi(6), eta(-1), name(54), multilayerId(2) and identifier 0x7f3d546000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (37), layer(2), phi(6), eta(-1), name(54), multilayerId(2) and identifier 0x7f3d548000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (32), layer(3), phi(6), eta(-1), name(54), multilayerId(2) and identifier 0x7f3d63e000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (33), layer(3), phi(6), eta(-1), name(54), multilayerId(2) and identifier 0x7f3d640000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (34), layer(3), phi(6), eta(-1), name(54), multilayerId(2) and identifier 0x7f3d642000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (35), layer(3), phi(6), eta(-1), name(54), multilayerId(2) and identifier 0x7f3d644000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (36), layer(3), phi(6), eta(-1), name(54), multilayerId(2) and identifier 0x7f3d646000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (37), layer(3), phi(6), eta(-1), name(54), multilayerId(2) and identifier 0x7f3d648000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (38), layer(3), phi(6), eta(-1), name(54), multilayerId(2) and identifier 0x7f3d64a000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (32), layer(4), phi(6), eta(-1), name(54), multilayerId(2) and identifier 0x7f3d73e000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (33), layer(4), phi(6), eta(-1), name(54), multilayerId(2) and identifier 0x7f3d740000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (34), layer(4), phi(6), eta(-1), name(54), multilayerId(2) and identifier 0x7f3d742000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (35), layer(4), phi(6), eta(-1), name(54), multilayerId(2) and identifier 0x7f3d744000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (36), layer(4), phi(6), eta(-1), name(54), multilayerId(2) and identifier 0x7f3d746000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (37), layer(4), phi(6), eta(-1), name(54), multilayerId(2) and identifier 0x7f3d748000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (24), layer(1), phi(6), eta(1), name(54), multilayerId(1) and identifier 0x7f4d02e000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (25), layer(1), phi(6), eta(1), name(54), multilayerId(1) and identifier 0x7f4d030000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (26), layer(1), phi(6), eta(1), name(54), multilayerId(1) and identifier 0x7f4d032000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (27), layer(1), phi(6), eta(1), name(54), multilayerId(1) and identifier 0x7f4d034000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (28), layer(1), phi(6), eta(1), name(54), multilayerId(1) and identifier 0x7f4d036000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (29), layer(1), phi(6), eta(1), name(54), multilayerId(1) and identifier 0x7f4d038000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (30), layer(1), phi(6), eta(1), name(54), multilayerId(1) and identifier 0x7f4d03a000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (25), layer(2), phi(6), eta(1), name(54), multilayerId(1) and identifier 0x7f4d130000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (26), layer(2), phi(6), eta(1), name(54), multilayerId(1) and identifier 0x7f4d132000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (27), layer(2), phi(6), eta(1), name(54), multilayerId(1) and identifier 0x7f4d134000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (28), layer(2), phi(6), eta(1), name(54), multilayerId(1) and identifier 0x7f4d136000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (29), layer(2), phi(6), eta(1), name(54), multilayerId(1) and identifier 0x7f4d138000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (30), layer(2), phi(6), eta(1), name(54), multilayerId(1) and identifier 0x7f4d13a000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (31), layer(2), phi(6), eta(1), name(54), multilayerId(1) and identifier 0x7f4d13c000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (25), layer(3), phi(6), eta(1), name(54), multilayerId(1) and identifier 0x7f4d230000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (26), layer(3), phi(6), eta(1), name(54), multilayerId(1) and identifier 0x7f4d232000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (27), layer(3), phi(6), eta(1), name(54), multilayerId(1) and identifier 0x7f4d234000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (28), layer(3), phi(6), eta(1), name(54), multilayerId(1) and identifier 0x7f4d236000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (29), layer(3), phi(6), eta(1), name(54), multilayerId(1) and identifier 0x7f4d238000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (30), layer(3), phi(6), eta(1), name(54), multilayerId(1) and identifier 0x7f4d23a000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (31), layer(3), phi(6), eta(1), name(54), multilayerId(1) and identifier 0x7f4d23c000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (26), layer(4), phi(6), eta(1), name(54), multilayerId(1) and identifier 0x7f4d332000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (27), layer(4), phi(6), eta(1), name(54), multilayerId(1) and identifier 0x7f4d334000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (28), layer(4), phi(6), eta(1), name(54), multilayerId(1) and identifier 0x7f4d336000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (29), layer(4), phi(6), eta(1), name(54), multilayerId(1) and identifier 0x7f4d338000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (30), layer(4), phi(6), eta(1), name(54), multilayerId(1) and identifier 0x7f4d33a000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (31), layer(4), phi(6), eta(1), name(54), multilayerId(1) and identifier 0x7f4d33c000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (32), layer(4), phi(6), eta(1), name(54), multilayerId(1) and identifier 0x7f4d33e000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (30), layer(1), phi(6), eta(1), name(54), multilayerId(2) and identifier 0x7f4d43a000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (31), layer(1), phi(6), eta(1), name(54), multilayerId(2) and identifier 0x7f4d43c000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (32), layer(1), phi(6), eta(1), name(54), multilayerId(2) and identifier 0x7f4d43e000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (33), layer(1), phi(6), eta(1), name(54), multilayerId(2) and identifier 0x7f4d440000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (34), layer(1), phi(6), eta(1), name(54), multilayerId(2) and identifier 0x7f4d442000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (35), layer(1), phi(6), eta(1), name(54), multilayerId(2) and identifier 0x7f4d444000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (36), layer(1), phi(6), eta(1), name(54), multilayerId(2) and identifier 0x7f4d446000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (31), layer(2), phi(6), eta(1), name(54), multilayerId(2) and identifier 0x7f4d53c000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (32), layer(2), phi(6), eta(1), name(54), multilayerId(2) and identifier 0x7f4d53e000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (33), layer(2), phi(6), eta(1), name(54), multilayerId(2) and identifier 0x7f4d540000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (34), layer(2), phi(6), eta(1), name(54), multilayerId(2) and identifier 0x7f4d542000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (35), layer(2), phi(6), eta(1), name(54), multilayerId(2) and identifier 0x7f4d544000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (36), layer(2), phi(6), eta(1), name(54), multilayerId(2) and identifier 0x7f4d546000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (37), layer(2), phi(6), eta(1), name(54), multilayerId(2) and identifier 0x7f4d548000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (31), layer(3), phi(6), eta(1), name(54), multilayerId(2) and identifier 0x7f4d63c000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (32), layer(3), phi(6), eta(1), name(54), multilayerId(2) and identifier 0x7f4d63e000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (33), layer(3), phi(6), eta(1), name(54), multilayerId(2) and identifier 0x7f4d640000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (34), layer(3), phi(6), eta(1), name(54), multilayerId(2) and identifier 0x7f4d642000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (35), layer(3), phi(6), eta(1), name(54), multilayerId(2) and identifier 0x7f4d644000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (36), layer(3), phi(6), eta(1), name(54), multilayerId(2) and identifier 0x7f4d646000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (37), layer(3), phi(6), eta(1), name(54), multilayerId(2) and identifier 0x7f4d648000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (32), layer(4), phi(6), eta(1), name(54), multilayerId(2) and identifier 0x7f4d73e000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (33), layer(4), phi(6), eta(1), name(54), multilayerId(2) and identifier 0x7f4d740000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (34), layer(4), phi(6), eta(1), name(54), multilayerId(2) and identifier 0x7f4d742000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (35), layer(4), phi(6), eta(1), name(54), multilayerId(2) and identifier 0x7f4d744000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (36), layer(4), phi(6), eta(1), name(54), multilayerId(2) and identifier 0x7f4d746000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (37), layer(4), phi(6), eta(1), name(54), multilayerId(2) and identifier 0x7f4d748000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (38), layer(4), phi(6), eta(1), name(54), multilayerId(2) and identifier 0x7f4d74a000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (14), layer(1), phi(6), eta(-2), name(54), multilayerId(1) and identifier 0x7f3501a000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (15), layer(1), phi(6), eta(-2), name(54), multilayerId(1) and identifier 0x7f3501c000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (16), layer(1), phi(6), eta(-2), name(54), multilayerId(1) and identifier 0x7f3501e000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (17), layer(1), phi(6), eta(-2), name(54), multilayerId(1) and identifier 0x7f35020000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (18), layer(1), phi(6), eta(-2), name(54), multilayerId(1) and identifier 0x7f35022000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (19), layer(1), phi(6), eta(-2), name(54), multilayerId(1) and identifier 0x7f35024000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (20), layer(1), phi(6), eta(-2), name(54), multilayerId(1) and identifier 0x7f35026000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (21), layer(1), phi(6), eta(-2), name(54), multilayerId(1) and identifier 0x7f35028000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (14), layer(2), phi(6), eta(-2), name(54), multilayerId(1) and identifier 0x7f3511a000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (15), layer(2), phi(6), eta(-2), name(54), multilayerId(1) and identifier 0x7f3511c000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (16), layer(2), phi(6), eta(-2), name(54), multilayerId(1) and identifier 0x7f3511e000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (17), layer(2), phi(6), eta(-2), name(54), multilayerId(1) and identifier 0x7f35120000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (18), layer(2), phi(6), eta(-2), name(54), multilayerId(1) and identifier 0x7f35122000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (19), layer(2), phi(6), eta(-2), name(54), multilayerId(1) and identifier 0x7f35124000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (20), layer(2), phi(6), eta(-2), name(54), multilayerId(1) and identifier 0x7f35126000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (21), layer(2), phi(6), eta(-2), name(54), multilayerId(1) and identifier 0x7f35128000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (15), layer(3), phi(6), eta(-2), name(54), multilayerId(1) and identifier 0x7f3521c000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (16), layer(3), phi(6), eta(-2), name(54), multilayerId(1) and identifier 0x7f3521e000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (17), layer(3), phi(6), eta(-2), name(54), multilayerId(1) and identifier 0x7f35220000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (18), layer(3), phi(6), eta(-2), name(54), multilayerId(1) and identifier 0x7f35222000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (19), layer(3), phi(6), eta(-2), name(54), multilayerId(1) and identifier 0x7f35224000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (20), layer(3), phi(6), eta(-2), name(54), multilayerId(1) and identifier 0x7f35226000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (21), layer(3), phi(6), eta(-2), name(54), multilayerId(1) and identifier 0x7f35228000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (22), layer(3), phi(6), eta(-2), name(54), multilayerId(1) and identifier 0x7f3522a000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (23), layer(3), phi(6), eta(-2), name(54), multilayerId(1) and identifier 0x7f3522c000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (16), layer(4), phi(6), eta(-2), name(54), multilayerId(1) and identifier 0x7f3531e000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (17), layer(4), phi(6), eta(-2), name(54), multilayerId(1) and identifier 0x7f35320000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (18), layer(4), phi(6), eta(-2), name(54), multilayerId(1) and identifier 0x7f35322000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (19), layer(4), phi(6), eta(-2), name(54), multilayerId(1) and identifier 0x7f35324000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (20), layer(4), phi(6), eta(-2), name(54), multilayerId(1) and identifier 0x7f35326000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (21), layer(4), phi(6), eta(-2), name(54), multilayerId(1) and identifier 0x7f35328000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (22), layer(4), phi(6), eta(-2), name(54), multilayerId(1) and identifier 0x7f3532a000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (23), layer(4), phi(6), eta(-2), name(54), multilayerId(1) and identifier 0x7f3532c000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (26), layer(1), phi(6), eta(-2), name(54), multilayerId(2) and identifier 0x7f35432000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (27), layer(1), phi(6), eta(-2), name(54), multilayerId(2) and identifier 0x7f35434000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (28), layer(1), phi(6), eta(-2), name(54), multilayerId(2) and identifier 0x7f35436000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (29), layer(1), phi(6), eta(-2), name(54), multilayerId(2) and identifier 0x7f35438000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (30), layer(1), phi(6), eta(-2), name(54), multilayerId(2) and identifier 0x7f3543a000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (31), layer(1), phi(6), eta(-2), name(54), multilayerId(2) and identifier 0x7f3543c000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (32), layer(1), phi(6), eta(-2), name(54), multilayerId(2) and identifier 0x7f3543e000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (33), layer(1), phi(6), eta(-2), name(54), multilayerId(2) and identifier 0x7f35440000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (26), layer(2), phi(6), eta(-2), name(54), multilayerId(2) and identifier 0x7f35532000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (27), layer(2), phi(6), eta(-2), name(54), multilayerId(2) and identifier 0x7f35534000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (28), layer(2), phi(6), eta(-2), name(54), multilayerId(2) and identifier 0x7f35536000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (29), layer(2), phi(6), eta(-2), name(54), multilayerId(2) and identifier 0x7f35538000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (30), layer(2), phi(6), eta(-2), name(54), multilayerId(2) and identifier 0x7f3553a000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (31), layer(2), phi(6), eta(-2), name(54), multilayerId(2) and identifier 0x7f3553c000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (32), layer(2), phi(6), eta(-2), name(54), multilayerId(2) and identifier 0x7f3553e000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (33), layer(2), phi(6), eta(-2), name(54), multilayerId(2) and identifier 0x7f35540000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (28), layer(3), phi(6), eta(-2), name(54), multilayerId(2) and identifier 0x7f35636000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (29), layer(3), phi(6), eta(-2), name(54), multilayerId(2) and identifier 0x7f35638000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (30), layer(3), phi(6), eta(-2), name(54), multilayerId(2) and identifier 0x7f3563a000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (31), layer(3), phi(6), eta(-2), name(54), multilayerId(2) and identifier 0x7f3563c000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (32), layer(3), phi(6), eta(-2), name(54), multilayerId(2) and identifier 0x7f3563e000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (33), layer(3), phi(6), eta(-2), name(54), multilayerId(2) and identifier 0x7f35640000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (34), layer(3), phi(6), eta(-2), name(54), multilayerId(2) and identifier 0x7f35642000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (35), layer(3), phi(6), eta(-2), name(54), multilayerId(2) and identifier 0x7f35644000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (28), layer(4), phi(6), eta(-2), name(54), multilayerId(2) and identifier 0x7f35736000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (29), layer(4), phi(6), eta(-2), name(54), multilayerId(2) and identifier 0x7f35738000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (30), layer(4), phi(6), eta(-2), name(54), multilayerId(2) and identifier 0x7f3573a000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (31), layer(4), phi(6), eta(-2), name(54), multilayerId(2) and identifier 0x7f3573c000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (32), layer(4), phi(6), eta(-2), name(54), multilayerId(2) and identifier 0x7f3573e000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (33), layer(4), phi(6), eta(-2), name(54), multilayerId(2) and identifier 0x7f35740000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (34), layer(4), phi(6), eta(-2), name(54), multilayerId(2) and identifier 0x7f35742000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (35), layer(4), phi(6), eta(-2), name(54), multilayerId(2) and identifier 0x7f35744000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (14), layer(1), phi(6), eta(2), name(54), multilayerId(1) and identifier 0x7f5501a000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (15), layer(1), phi(6), eta(2), name(54), multilayerId(1) and identifier 0x7f5501c000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (16), layer(1), phi(6), eta(2), name(54), multilayerId(1) and identifier 0x7f5501e000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (17), layer(1), phi(6), eta(2), name(54), multilayerId(1) and identifier 0x7f55020000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (18), layer(1), phi(6), eta(2), name(54), multilayerId(1) and identifier 0x7f55022000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (19), layer(1), phi(6), eta(2), name(54), multilayerId(1) and identifier 0x7f55024000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (20), layer(1), phi(6), eta(2), name(54), multilayerId(1) and identifier 0x7f55026000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (21), layer(1), phi(6), eta(2), name(54), multilayerId(1) and identifier 0x7f55028000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (15), layer(2), phi(6), eta(2), name(54), multilayerId(1) and identifier 0x7f5511c000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (16), layer(2), phi(6), eta(2), name(54), multilayerId(1) and identifier 0x7f5511e000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (17), layer(2), phi(6), eta(2), name(54), multilayerId(1) and identifier 0x7f55120000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (18), layer(2), phi(6), eta(2), name(54), multilayerId(1) and identifier 0x7f55122000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (19), layer(2), phi(6), eta(2), name(54), multilayerId(1) and identifier 0x7f55124000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (20), layer(2), phi(6), eta(2), name(54), multilayerId(1) and identifier 0x7f55126000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (21), layer(2), phi(6), eta(2), name(54), multilayerId(1) and identifier 0x7f55128000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (22), layer(2), phi(6), eta(2), name(54), multilayerId(1) and identifier 0x7f5512a000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (15), layer(3), phi(6), eta(2), name(54), multilayerId(1) and identifier 0x7f5521c000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (16), layer(3), phi(6), eta(2), name(54), multilayerId(1) and identifier 0x7f5521e000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (17), layer(3), phi(6), eta(2), name(54), multilayerId(1) and identifier 0x7f55220000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (18), layer(3), phi(6), eta(2), name(54), multilayerId(1) and identifier 0x7f55222000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (19), layer(3), phi(6), eta(2), name(54), multilayerId(1) and identifier 0x7f55224000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (20), layer(3), phi(6), eta(2), name(54), multilayerId(1) and identifier 0x7f55226000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (21), layer(3), phi(6), eta(2), name(54), multilayerId(1) and identifier 0x7f55228000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (22), layer(3), phi(6), eta(2), name(54), multilayerId(1) and identifier 0x7f5522a000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (16), layer(4), phi(6), eta(2), name(54), multilayerId(1) and identifier 0x7f5531e000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (17), layer(4), phi(6), eta(2), name(54), multilayerId(1) and identifier 0x7f55320000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (18), layer(4), phi(6), eta(2), name(54), multilayerId(1) and identifier 0x7f55322000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (19), layer(4), phi(6), eta(2), name(54), multilayerId(1) and identifier 0x7f55324000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (20), layer(4), phi(6), eta(2), name(54), multilayerId(1) and identifier 0x7f55326000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (21), layer(4), phi(6), eta(2), name(54), multilayerId(1) and identifier 0x7f55328000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (22), layer(4), phi(6), eta(2), name(54), multilayerId(1) and identifier 0x7f5532a000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (23), layer(4), phi(6), eta(2), name(54), multilayerId(1) and identifier 0x7f5532c000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (26), layer(1), phi(6), eta(2), name(54), multilayerId(2) and identifier 0x7f55432000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (27), layer(1), phi(6), eta(2), name(54), multilayerId(2) and identifier 0x7f55434000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (28), layer(1), phi(6), eta(2), name(54), multilayerId(2) and identifier 0x7f55436000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (29), layer(1), phi(6), eta(2), name(54), multilayerId(2) and identifier 0x7f55438000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (30), layer(1), phi(6), eta(2), name(54), multilayerId(2) and identifier 0x7f5543a000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (31), layer(1), phi(6), eta(2), name(54), multilayerId(2) and identifier 0x7f5543c000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (32), layer(1), phi(6), eta(2), name(54), multilayerId(2) and identifier 0x7f5543e000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (33), layer(1), phi(6), eta(2), name(54), multilayerId(2) and identifier 0x7f55440000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (27), layer(2), phi(6), eta(2), name(54), multilayerId(2) and identifier 0x7f55534000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (28), layer(2), phi(6), eta(2), name(54), multilayerId(2) and identifier 0x7f55536000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (29), layer(2), phi(6), eta(2), name(54), multilayerId(2) and identifier 0x7f55538000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (30), layer(2), phi(6), eta(2), name(54), multilayerId(2) and identifier 0x7f5553a000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (31), layer(2), phi(6), eta(2), name(54), multilayerId(2) and identifier 0x7f5553c000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (32), layer(2), phi(6), eta(2), name(54), multilayerId(2) and identifier 0x7f5553e000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (33), layer(2), phi(6), eta(2), name(54), multilayerId(2) and identifier 0x7f55540000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (34), layer(2), phi(6), eta(2), name(54), multilayerId(2) and identifier 0x7f55542000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (27), layer(3), phi(6), eta(2), name(54), multilayerId(2) and identifier 0x7f55634000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (28), layer(3), phi(6), eta(2), name(54), multilayerId(2) and identifier 0x7f55636000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (29), layer(3), phi(6), eta(2), name(54), multilayerId(2) and identifier 0x7f55638000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (30), layer(3), phi(6), eta(2), name(54), multilayerId(2) and identifier 0x7f5563a000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (31), layer(3), phi(6), eta(2), name(54), multilayerId(2) and identifier 0x7f5563c000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (32), layer(3), phi(6), eta(2), name(54), multilayerId(2) and identifier 0x7f5563e000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (33), layer(3), phi(6), eta(2), name(54), multilayerId(2) and identifier 0x7f55640000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (34), layer(3), phi(6), eta(2), name(54), multilayerId(2) and identifier 0x7f55642000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (28), layer(4), phi(6), eta(2), name(54), multilayerId(2) and identifier 0x7f55736000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (29), layer(4), phi(6), eta(2), name(54), multilayerId(2) and identifier 0x7f55738000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (30), layer(4), phi(6), eta(2), name(54), multilayerId(2) and identifier 0x7f5573a000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (31), layer(4), phi(6), eta(2), name(54), multilayerId(2) and identifier 0x7f5573c000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (32), layer(4), phi(6), eta(2), name(54), multilayerId(2) and identifier 0x7f5573e000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (33), layer(4), phi(6), eta(2), name(54), multilayerId(2) and identifier 0x7f55740000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (34), layer(4), phi(6), eta(2), name(54), multilayerId(2) and identifier 0x7f55742000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (35), layer(4), phi(6), eta(2), name(54), multilayerId(2) and identifier 0x7f55744000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (16), layer(1), phi(6), eta(-3), name(54), multilayerId(1) and identifier 0x7f2d01e000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (17), layer(1), phi(6), eta(-3), name(54), multilayerId(1) and identifier 0x7f2d020000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (18), layer(1), phi(6), eta(-3), name(54), multilayerId(1) and identifier 0x7f2d022000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (19), layer(1), phi(6), eta(-3), name(54), multilayerId(1) and identifier 0x7f2d024000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (20), layer(1), phi(6), eta(-3), name(54), multilayerId(1) and identifier 0x7f2d026000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (21), layer(1), phi(6), eta(-3), name(54), multilayerId(1) and identifier 0x7f2d028000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (22), layer(1), phi(6), eta(-3), name(54), multilayerId(1) and identifier 0x7f2d02a000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (23), layer(1), phi(6), eta(-3), name(54), multilayerId(1) and identifier 0x7f2d02c000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (24), layer(1), phi(6), eta(-3), name(54), multilayerId(1) and identifier 0x7f2d02e000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (25), layer(1), phi(6), eta(-3), name(54), multilayerId(1) and identifier 0x7f2d030000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (26), layer(1), phi(6), eta(-3), name(54), multilayerId(1) and identifier 0x7f2d032000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (27), layer(1), phi(6), eta(-3), name(54), multilayerId(1) and identifier 0x7f2d034000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (28), layer(1), phi(6), eta(-3), name(54), multilayerId(1) and identifier 0x7f2d036000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (16), layer(2), phi(6), eta(-3), name(54), multilayerId(1) and identifier 0x7f2d11e000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (17), layer(2), phi(6), eta(-3), name(54), multilayerId(1) and identifier 0x7f2d120000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (18), layer(2), phi(6), eta(-3), name(54), multilayerId(1) and identifier 0x7f2d122000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (19), layer(2), phi(6), eta(-3), name(54), multilayerId(1) and identifier 0x7f2d124000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (20), layer(2), phi(6), eta(-3), name(54), multilayerId(1) and identifier 0x7f2d126000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (21), layer(2), phi(6), eta(-3), name(54), multilayerId(1) and identifier 0x7f2d128000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (22), layer(2), phi(6), eta(-3), name(54), multilayerId(1) and identifier 0x7f2d12a000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (23), layer(2), phi(6), eta(-3), name(54), multilayerId(1) and identifier 0x7f2d12c000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (24), layer(2), phi(6), eta(-3), name(54), multilayerId(1) and identifier 0x7f2d12e000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (25), layer(2), phi(6), eta(-3), name(54), multilayerId(1) and identifier 0x7f2d130000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (26), layer(2), phi(6), eta(-3), name(54), multilayerId(1) and identifier 0x7f2d132000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (27), layer(2), phi(6), eta(-3), name(54), multilayerId(1) and identifier 0x7f2d134000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (28), layer(2), phi(6), eta(-3), name(54), multilayerId(1) and identifier 0x7f2d136000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (29), layer(2), phi(6), eta(-3), name(54), multilayerId(1) and identifier 0x7f2d138000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (18), layer(3), phi(6), eta(-3), name(54), multilayerId(1) and identifier 0x7f2d222000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (19), layer(3), phi(6), eta(-3), name(54), multilayerId(1) and identifier 0x7f2d224000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (20), layer(3), phi(6), eta(-3), name(54), multilayerId(1) and identifier 0x7f2d226000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (21), layer(3), phi(6), eta(-3), name(54), multilayerId(1) and identifier 0x7f2d228000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (22), layer(3), phi(6), eta(-3), name(54), multilayerId(1) and identifier 0x7f2d22a000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (23), layer(3), phi(6), eta(-3), name(54), multilayerId(1) and identifier 0x7f2d22c000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (24), layer(3), phi(6), eta(-3), name(54), multilayerId(1) and identifier 0x7f2d22e000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (25), layer(3), phi(6), eta(-3), name(54), multilayerId(1) and identifier 0x7f2d230000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (26), layer(3), phi(6), eta(-3), name(54), multilayerId(1) and identifier 0x7f2d232000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (27), layer(3), phi(6), eta(-3), name(54), multilayerId(1) and identifier 0x7f2d234000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (28), layer(3), phi(6), eta(-3), name(54), multilayerId(1) and identifier 0x7f2d236000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (29), layer(3), phi(6), eta(-3), name(54), multilayerId(1) and identifier 0x7f2d238000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (30), layer(3), phi(6), eta(-3), name(54), multilayerId(1) and identifier 0x7f2d23a000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (18), layer(4), phi(6), eta(-3), name(54), multilayerId(1) and identifier 0x7f2d322000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (19), layer(4), phi(6), eta(-3), name(54), multilayerId(1) and identifier 0x7f2d324000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (20), layer(4), phi(6), eta(-3), name(54), multilayerId(1) and identifier 0x7f2d326000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (21), layer(4), phi(6), eta(-3), name(54), multilayerId(1) and identifier 0x7f2d328000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (22), layer(4), phi(6), eta(-3), name(54), multilayerId(1) and identifier 0x7f2d32a000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (23), layer(4), phi(6), eta(-3), name(54), multilayerId(1) and identifier 0x7f2d32c000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (24), layer(4), phi(6), eta(-3), name(54), multilayerId(1) and identifier 0x7f2d32e000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (25), layer(4), phi(6), eta(-3), name(54), multilayerId(1) and identifier 0x7f2d330000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (26), layer(4), phi(6), eta(-3), name(54), multilayerId(1) and identifier 0x7f2d332000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (27), layer(4), phi(6), eta(-3), name(54), multilayerId(1) and identifier 0x7f2d334000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (28), layer(4), phi(6), eta(-3), name(54), multilayerId(1) and identifier 0x7f2d336000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (29), layer(4), phi(6), eta(-3), name(54), multilayerId(1) and identifier 0x7f2d338000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (30), layer(4), phi(6), eta(-3), name(54), multilayerId(1) and identifier 0x7f2d33a000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (31), layer(4), phi(6), eta(-3), name(54), multilayerId(1) and identifier 0x7f2d33c000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (33), layer(1), phi(6), eta(-3), name(54), multilayerId(2) and identifier 0x7f2d440000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (34), layer(1), phi(6), eta(-3), name(54), multilayerId(2) and identifier 0x7f2d442000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (35), layer(1), phi(6), eta(-3), name(54), multilayerId(2) and identifier 0x7f2d444000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (36), layer(1), phi(6), eta(-3), name(54), multilayerId(2) and identifier 0x7f2d446000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (37), layer(1), phi(6), eta(-3), name(54), multilayerId(2) and identifier 0x7f2d448000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (38), layer(1), phi(6), eta(-3), name(54), multilayerId(2) and identifier 0x7f2d44a000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (39), layer(1), phi(6), eta(-3), name(54), multilayerId(2) and identifier 0x7f2d44c000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (40), layer(1), phi(6), eta(-3), name(54), multilayerId(2) and identifier 0x7f2d44e000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (41), layer(1), phi(6), eta(-3), name(54), multilayerId(2) and identifier 0x7f2d450000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (42), layer(1), phi(6), eta(-3), name(54), multilayerId(2) and identifier 0x7f2d452000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (43), layer(1), phi(6), eta(-3), name(54), multilayerId(2) and identifier 0x7f2d454000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (44), layer(1), phi(6), eta(-3), name(54), multilayerId(2) and identifier 0x7f2d456000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (45), layer(1), phi(6), eta(-3), name(54), multilayerId(2) and identifier 0x7f2d458000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (46), layer(1), phi(6), eta(-3), name(54), multilayerId(2) and identifier 0x7f2d45a000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (33), layer(2), phi(6), eta(-3), name(54), multilayerId(2) and identifier 0x7f2d540000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (34), layer(2), phi(6), eta(-3), name(54), multilayerId(2) and identifier 0x7f2d542000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (35), layer(2), phi(6), eta(-3), name(54), multilayerId(2) and identifier 0x7f2d544000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (36), layer(2), phi(6), eta(-3), name(54), multilayerId(2) and identifier 0x7f2d546000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (37), layer(2), phi(6), eta(-3), name(54), multilayerId(2) and identifier 0x7f2d548000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (38), layer(2), phi(6), eta(-3), name(54), multilayerId(2) and identifier 0x7f2d54a000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (39), layer(2), phi(6), eta(-3), name(54), multilayerId(2) and identifier 0x7f2d54c000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (40), layer(2), phi(6), eta(-3), name(54), multilayerId(2) and identifier 0x7f2d54e000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (41), layer(2), phi(6), eta(-3), name(54), multilayerId(2) and identifier 0x7f2d550000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (42), layer(2), phi(6), eta(-3), name(54), multilayerId(2) and identifier 0x7f2d552000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (43), layer(2), phi(6), eta(-3), name(54), multilayerId(2) and identifier 0x7f2d554000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (44), layer(2), phi(6), eta(-3), name(54), multilayerId(2) and identifier 0x7f2d556000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (45), layer(2), phi(6), eta(-3), name(54), multilayerId(2) and identifier 0x7f2d558000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (46), layer(2), phi(6), eta(-3), name(54), multilayerId(2) and identifier 0x7f2d55a000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (35), layer(3), phi(6), eta(-3), name(54), multilayerId(2) and identifier 0x7f2d644000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (36), layer(3), phi(6), eta(-3), name(54), multilayerId(2) and identifier 0x7f2d646000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (37), layer(3), phi(6), eta(-3), name(54), multilayerId(2) and identifier 0x7f2d648000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (38), layer(3), phi(6), eta(-3), name(54), multilayerId(2) and identifier 0x7f2d64a000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (39), layer(3), phi(6), eta(-3), name(54), multilayerId(2) and identifier 0x7f2d64c000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (40), layer(3), phi(6), eta(-3), name(54), multilayerId(2) and identifier 0x7f2d64e000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (41), layer(3), phi(6), eta(-3), name(54), multilayerId(2) and identifier 0x7f2d650000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (42), layer(3), phi(6), eta(-3), name(54), multilayerId(2) and identifier 0x7f2d652000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (43), layer(3), phi(6), eta(-3), name(54), multilayerId(2) and identifier 0x7f2d654000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (44), layer(3), phi(6), eta(-3), name(54), multilayerId(2) and identifier 0x7f2d656000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (45), layer(3), phi(6), eta(-3), name(54), multilayerId(2) and identifier 0x7f2d658000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (46), layer(3), phi(6), eta(-3), name(54), multilayerId(2) and identifier 0x7f2d65a000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (47), layer(3), phi(6), eta(-3), name(54), multilayerId(2) and identifier 0x7f2d65c000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (48), layer(3), phi(6), eta(-3), name(54), multilayerId(2) and identifier 0x7f2d65e000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (35), layer(4), phi(6), eta(-3), name(54), multilayerId(2) and identifier 0x7f2d744000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (36), layer(4), phi(6), eta(-3), name(54), multilayerId(2) and identifier 0x7f2d746000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (37), layer(4), phi(6), eta(-3), name(54), multilayerId(2) and identifier 0x7f2d748000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (38), layer(4), phi(6), eta(-3), name(54), multilayerId(2) and identifier 0x7f2d74a000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (39), layer(4), phi(6), eta(-3), name(54), multilayerId(2) and identifier 0x7f2d74c000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (40), layer(4), phi(6), eta(-3), name(54), multilayerId(2) and identifier 0x7f2d74e000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (41), layer(4), phi(6), eta(-3), name(54), multilayerId(2) and identifier 0x7f2d750000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (42), layer(4), phi(6), eta(-3), name(54), multilayerId(2) and identifier 0x7f2d752000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (43), layer(4), phi(6), eta(-3), name(54), multilayerId(2) and identifier 0x7f2d754000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (44), layer(4), phi(6), eta(-3), name(54), multilayerId(2) and identifier 0x7f2d756000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (45), layer(4), phi(6), eta(-3), name(54), multilayerId(2) and identifier 0x7f2d758000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (46), layer(4), phi(6), eta(-3), name(54), multilayerId(2) and identifier 0x7f2d75a000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (47), layer(4), phi(6), eta(-3), name(54), multilayerId(2) and identifier 0x7f2d75c000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (48), layer(4), phi(6), eta(-3), name(54), multilayerId(2) and identifier 0x7f2d75e000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (15), layer(1), phi(6), eta(3), name(54), multilayerId(1) and identifier 0x7f5d01c000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (16), layer(1), phi(6), eta(3), name(54), multilayerId(1) and identifier 0x7f5d01e000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (17), layer(1), phi(6), eta(3), name(54), multilayerId(1) and identifier 0x7f5d020000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (18), layer(1), phi(6), eta(3), name(54), multilayerId(1) and identifier 0x7f5d022000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (19), layer(1), phi(6), eta(3), name(54), multilayerId(1) and identifier 0x7f5d024000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (20), layer(1), phi(6), eta(3), name(54), multilayerId(1) and identifier 0x7f5d026000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (21), layer(1), phi(6), eta(3), name(54), multilayerId(1) and identifier 0x7f5d028000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (22), layer(1), phi(6), eta(3), name(54), multilayerId(1) and identifier 0x7f5d02a000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (23), layer(1), phi(6), eta(3), name(54), multilayerId(1) and identifier 0x7f5d02c000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (24), layer(1), phi(6), eta(3), name(54), multilayerId(1) and identifier 0x7f5d02e000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (25), layer(1), phi(6), eta(3), name(54), multilayerId(1) and identifier 0x7f5d030000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (26), layer(1), phi(6), eta(3), name(54), multilayerId(1) and identifier 0x7f5d032000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (27), layer(1), phi(6), eta(3), name(54), multilayerId(1) and identifier 0x7f5d034000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (28), layer(1), phi(6), eta(3), name(54), multilayerId(1) and identifier 0x7f5d036000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (17), layer(2), phi(6), eta(3), name(54), multilayerId(1) and identifier 0x7f5d120000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (18), layer(2), phi(6), eta(3), name(54), multilayerId(1) and identifier 0x7f5d122000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (19), layer(2), phi(6), eta(3), name(54), multilayerId(1) and identifier 0x7f5d124000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (20), layer(2), phi(6), eta(3), name(54), multilayerId(1) and identifier 0x7f5d126000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (21), layer(2), phi(6), eta(3), name(54), multilayerId(1) and identifier 0x7f5d128000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (22), layer(2), phi(6), eta(3), name(54), multilayerId(1) and identifier 0x7f5d12a000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (23), layer(2), phi(6), eta(3), name(54), multilayerId(1) and identifier 0x7f5d12c000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (24), layer(2), phi(6), eta(3), name(54), multilayerId(1) and identifier 0x7f5d12e000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (25), layer(2), phi(6), eta(3), name(54), multilayerId(1) and identifier 0x7f5d130000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (26), layer(2), phi(6), eta(3), name(54), multilayerId(1) and identifier 0x7f5d132000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (27), layer(2), phi(6), eta(3), name(54), multilayerId(1) and identifier 0x7f5d134000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (28), layer(2), phi(6), eta(3), name(54), multilayerId(1) and identifier 0x7f5d136000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (29), layer(2), phi(6), eta(3), name(54), multilayerId(1) and identifier 0x7f5d138000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (30), layer(2), phi(6), eta(3), name(54), multilayerId(1) and identifier 0x7f5d13a000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (17), layer(3), phi(6), eta(3), name(54), multilayerId(1) and identifier 0x7f5d220000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (18), layer(3), phi(6), eta(3), name(54), multilayerId(1) and identifier 0x7f5d222000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (19), layer(3), phi(6), eta(3), name(54), multilayerId(1) and identifier 0x7f5d224000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (20), layer(3), phi(6), eta(3), name(54), multilayerId(1) and identifier 0x7f5d226000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (21), layer(3), phi(6), eta(3), name(54), multilayerId(1) and identifier 0x7f5d228000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (22), layer(3), phi(6), eta(3), name(54), multilayerId(1) and identifier 0x7f5d22a000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (23), layer(3), phi(6), eta(3), name(54), multilayerId(1) and identifier 0x7f5d22c000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (24), layer(3), phi(6), eta(3), name(54), multilayerId(1) and identifier 0x7f5d22e000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (25), layer(3), phi(6), eta(3), name(54), multilayerId(1) and identifier 0x7f5d230000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (26), layer(3), phi(6), eta(3), name(54), multilayerId(1) and identifier 0x7f5d232000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (27), layer(3), phi(6), eta(3), name(54), multilayerId(1) and identifier 0x7f5d234000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (28), layer(3), phi(6), eta(3), name(54), multilayerId(1) and identifier 0x7f5d236000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (29), layer(3), phi(6), eta(3), name(54), multilayerId(1) and identifier 0x7f5d238000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (30), layer(3), phi(6), eta(3), name(54), multilayerId(1) and identifier 0x7f5d23a000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (19), layer(4), phi(6), eta(3), name(54), multilayerId(1) and identifier 0x7f5d324000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (20), layer(4), phi(6), eta(3), name(54), multilayerId(1) and identifier 0x7f5d326000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (21), layer(4), phi(6), eta(3), name(54), multilayerId(1) and identifier 0x7f5d328000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (22), layer(4), phi(6), eta(3), name(54), multilayerId(1) and identifier 0x7f5d32a000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (23), layer(4), phi(6), eta(3), name(54), multilayerId(1) and identifier 0x7f5d32c000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (24), layer(4), phi(6), eta(3), name(54), multilayerId(1) and identifier 0x7f5d32e000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (25), layer(4), phi(6), eta(3), name(54), multilayerId(1) and identifier 0x7f5d330000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (26), layer(4), phi(6), eta(3), name(54), multilayerId(1) and identifier 0x7f5d332000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (27), layer(4), phi(6), eta(3), name(54), multilayerId(1) and identifier 0x7f5d334000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (28), layer(4), phi(6), eta(3), name(54), multilayerId(1) and identifier 0x7f5d336000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (29), layer(4), phi(6), eta(3), name(54), multilayerId(1) and identifier 0x7f5d338000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (30), layer(4), phi(6), eta(3), name(54), multilayerId(1) and identifier 0x7f5d33a000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (31), layer(4), phi(6), eta(3), name(54), multilayerId(1) and identifier 0x7f5d33c000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (32), layer(4), phi(6), eta(3), name(54), multilayerId(1) and identifier 0x7f5d33e000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (32), layer(1), phi(6), eta(3), name(54), multilayerId(2) and identifier 0x7f5d43e000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (33), layer(1), phi(6), eta(3), name(54), multilayerId(2) and identifier 0x7f5d440000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (34), layer(1), phi(6), eta(3), name(54), multilayerId(2) and identifier 0x7f5d442000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (35), layer(1), phi(6), eta(3), name(54), multilayerId(2) and identifier 0x7f5d444000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (36), layer(1), phi(6), eta(3), name(54), multilayerId(2) and identifier 0x7f5d446000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (37), layer(1), phi(6), eta(3), name(54), multilayerId(2) and identifier 0x7f5d448000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (38), layer(1), phi(6), eta(3), name(54), multilayerId(2) and identifier 0x7f5d44a000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (39), layer(1), phi(6), eta(3), name(54), multilayerId(2) and identifier 0x7f5d44c000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (40), layer(1), phi(6), eta(3), name(54), multilayerId(2) and identifier 0x7f5d44e000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (41), layer(1), phi(6), eta(3), name(54), multilayerId(2) and identifier 0x7f5d450000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (42), layer(1), phi(6), eta(3), name(54), multilayerId(2) and identifier 0x7f5d452000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (43), layer(1), phi(6), eta(3), name(54), multilayerId(2) and identifier 0x7f5d454000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (44), layer(1), phi(6), eta(3), name(54), multilayerId(2) and identifier 0x7f5d456000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (45), layer(1), phi(6), eta(3), name(54), multilayerId(2) and identifier 0x7f5d458000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (34), layer(2), phi(6), eta(3), name(54), multilayerId(2) and identifier 0x7f5d542000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (35), layer(2), phi(6), eta(3), name(54), multilayerId(2) and identifier 0x7f5d544000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (36), layer(2), phi(6), eta(3), name(54), multilayerId(2) and identifier 0x7f5d546000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (37), layer(2), phi(6), eta(3), name(54), multilayerId(2) and identifier 0x7f5d548000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (38), layer(2), phi(6), eta(3), name(54), multilayerId(2) and identifier 0x7f5d54a000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (39), layer(2), phi(6), eta(3), name(54), multilayerId(2) and identifier 0x7f5d54c000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (40), layer(2), phi(6), eta(3), name(54), multilayerId(2) and identifier 0x7f5d54e000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (41), layer(2), phi(6), eta(3), name(54), multilayerId(2) and identifier 0x7f5d550000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (42), layer(2), phi(6), eta(3), name(54), multilayerId(2) and identifier 0x7f5d552000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (43), layer(2), phi(6), eta(3), name(54), multilayerId(2) and identifier 0x7f5d554000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (44), layer(2), phi(6), eta(3), name(54), multilayerId(2) and identifier 0x7f5d556000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (45), layer(2), phi(6), eta(3), name(54), multilayerId(2) and identifier 0x7f5d558000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (46), layer(2), phi(6), eta(3), name(54), multilayerId(2) and identifier 0x7f5d55a000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (47), layer(2), phi(6), eta(3), name(54), multilayerId(2) and identifier 0x7f5d55c000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (34), layer(3), phi(6), eta(3), name(54), multilayerId(2) and identifier 0x7f5d642000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (35), layer(3), phi(6), eta(3), name(54), multilayerId(2) and identifier 0x7f5d644000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (36), layer(3), phi(6), eta(3), name(54), multilayerId(2) and identifier 0x7f5d646000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (37), layer(3), phi(6), eta(3), name(54), multilayerId(2) and identifier 0x7f5d648000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (38), layer(3), phi(6), eta(3), name(54), multilayerId(2) and identifier 0x7f5d64a000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (39), layer(3), phi(6), eta(3), name(54), multilayerId(2) and identifier 0x7f5d64c000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (40), layer(3), phi(6), eta(3), name(54), multilayerId(2) and identifier 0x7f5d64e000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (41), layer(3), phi(6), eta(3), name(54), multilayerId(2) and identifier 0x7f5d650000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (42), layer(3), phi(6), eta(3), name(54), multilayerId(2) and identifier 0x7f5d652000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (43), layer(3), phi(6), eta(3), name(54), multilayerId(2) and identifier 0x7f5d654000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (44), layer(3), phi(6), eta(3), name(54), multilayerId(2) and identifier 0x7f5d656000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (45), layer(3), phi(6), eta(3), name(54), multilayerId(2) and identifier 0x7f5d658000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (46), layer(3), phi(6), eta(3), name(54), multilayerId(2) and identifier 0x7f5d65a000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (47), layer(3), phi(6), eta(3), name(54), multilayerId(2) and identifier 0x7f5d65c000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (36), layer(4), phi(6), eta(3), name(54), multilayerId(2) and identifier 0x7f5d746000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (37), layer(4), phi(6), eta(3), name(54), multilayerId(2) and identifier 0x7f5d748000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (38), layer(4), phi(6), eta(3), name(54), multilayerId(2) and identifier 0x7f5d74a000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (39), layer(4), phi(6), eta(3), name(54), multilayerId(2) and identifier 0x7f5d74c000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (40), layer(4), phi(6), eta(3), name(54), multilayerId(2) and identifier 0x7f5d74e000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (41), layer(4), phi(6), eta(3), name(54), multilayerId(2) and identifier 0x7f5d750000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (42), layer(4), phi(6), eta(3), name(54), multilayerId(2) and identifier 0x7f5d752000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (43), layer(4), phi(6), eta(3), name(54), multilayerId(2) and identifier 0x7f5d754000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (44), layer(4), phi(6), eta(3), name(54), multilayerId(2) and identifier 0x7f5d756000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (45), layer(4), phi(6), eta(3), name(54), multilayerId(2) and identifier 0x7f5d758000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (46), layer(4), phi(6), eta(3), name(54), multilayerId(2) and identifier 0x7f5d75a000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (47), layer(4), phi(6), eta(3), name(54), multilayerId(2) and identifier 0x7f5d75c000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (48), layer(4), phi(6), eta(3), name(54), multilayerId(2) and identifier 0x7f5d75e000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (49), layer(4), phi(6), eta(3), name(54), multilayerId(2) and identifier 0x7f5d760000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (24), layer(1), phi(7), eta(-1), name(54), multilayerId(1) and identifier 0x7f3e02e000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (25), layer(1), phi(7), eta(-1), name(54), multilayerId(1) and identifier 0x7f3e030000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (26), layer(1), phi(7), eta(-1), name(54), multilayerId(1) and identifier 0x7f3e032000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (27), layer(1), phi(7), eta(-1), name(54), multilayerId(1) and identifier 0x7f3e034000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (28), layer(1), phi(7), eta(-1), name(54), multilayerId(1) and identifier 0x7f3e036000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (29), layer(1), phi(7), eta(-1), name(54), multilayerId(1) and identifier 0x7f3e038000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (30), layer(1), phi(7), eta(-1), name(54), multilayerId(1) and identifier 0x7f3e03a000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (25), layer(2), phi(7), eta(-1), name(54), multilayerId(1) and identifier 0x7f3e130000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (26), layer(2), phi(7), eta(-1), name(54), multilayerId(1) and identifier 0x7f3e132000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (27), layer(2), phi(7), eta(-1), name(54), multilayerId(1) and identifier 0x7f3e134000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (28), layer(2), phi(7), eta(-1), name(54), multilayerId(1) and identifier 0x7f3e136000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (29), layer(2), phi(7), eta(-1), name(54), multilayerId(1) and identifier 0x7f3e138000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (30), layer(2), phi(7), eta(-1), name(54), multilayerId(1) and identifier 0x7f3e13a000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (31), layer(2), phi(7), eta(-1), name(54), multilayerId(1) and identifier 0x7f3e13c000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (25), layer(3), phi(7), eta(-1), name(54), multilayerId(1) and identifier 0x7f3e230000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (26), layer(3), phi(7), eta(-1), name(54), multilayerId(1) and identifier 0x7f3e232000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (27), layer(3), phi(7), eta(-1), name(54), multilayerId(1) and identifier 0x7f3e234000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (28), layer(3), phi(7), eta(-1), name(54), multilayerId(1) and identifier 0x7f3e236000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (29), layer(3), phi(7), eta(-1), name(54), multilayerId(1) and identifier 0x7f3e238000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (30), layer(3), phi(7), eta(-1), name(54), multilayerId(1) and identifier 0x7f3e23a000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (31), layer(3), phi(7), eta(-1), name(54), multilayerId(1) and identifier 0x7f3e23c000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (26), layer(4), phi(7), eta(-1), name(54), multilayerId(1) and identifier 0x7f3e332000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (27), layer(4), phi(7), eta(-1), name(54), multilayerId(1) and identifier 0x7f3e334000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (28), layer(4), phi(7), eta(-1), name(54), multilayerId(1) and identifier 0x7f3e336000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (29), layer(4), phi(7), eta(-1), name(54), multilayerId(1) and identifier 0x7f3e338000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (30), layer(4), phi(7), eta(-1), name(54), multilayerId(1) and identifier 0x7f3e33a000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (31), layer(4), phi(7), eta(-1), name(54), multilayerId(1) and identifier 0x7f3e33c000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (32), layer(4), phi(7), eta(-1), name(54), multilayerId(1) and identifier 0x7f3e33e000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (30), layer(1), phi(7), eta(-1), name(54), multilayerId(2) and identifier 0x7f3e43a000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (31), layer(1), phi(7), eta(-1), name(54), multilayerId(2) and identifier 0x7f3e43c000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (32), layer(1), phi(7), eta(-1), name(54), multilayerId(2) and identifier 0x7f3e43e000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (33), layer(1), phi(7), eta(-1), name(54), multilayerId(2) and identifier 0x7f3e440000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (34), layer(1), phi(7), eta(-1), name(54), multilayerId(2) and identifier 0x7f3e442000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (35), layer(1), phi(7), eta(-1), name(54), multilayerId(2) and identifier 0x7f3e444000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (36), layer(1), phi(7), eta(-1), name(54), multilayerId(2) and identifier 0x7f3e446000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (31), layer(2), phi(7), eta(-1), name(54), multilayerId(2) and identifier 0x7f3e53c000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (32), layer(2), phi(7), eta(-1), name(54), multilayerId(2) and identifier 0x7f3e53e000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (33), layer(2), phi(7), eta(-1), name(54), multilayerId(2) and identifier 0x7f3e540000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (34), layer(2), phi(7), eta(-1), name(54), multilayerId(2) and identifier 0x7f3e542000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (35), layer(2), phi(7), eta(-1), name(54), multilayerId(2) and identifier 0x7f3e544000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (36), layer(2), phi(7), eta(-1), name(54), multilayerId(2) and identifier 0x7f3e546000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (37), layer(2), phi(7), eta(-1), name(54), multilayerId(2) and identifier 0x7f3e548000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (31), layer(3), phi(7), eta(-1), name(54), multilayerId(2) and identifier 0x7f3e63c000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (32), layer(3), phi(7), eta(-1), name(54), multilayerId(2) and identifier 0x7f3e63e000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (33), layer(3), phi(7), eta(-1), name(54), multilayerId(2) and identifier 0x7f3e640000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (34), layer(3), phi(7), eta(-1), name(54), multilayerId(2) and identifier 0x7f3e642000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (35), layer(3), phi(7), eta(-1), name(54), multilayerId(2) and identifier 0x7f3e644000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (36), layer(3), phi(7), eta(-1), name(54), multilayerId(2) and identifier 0x7f3e646000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (37), layer(3), phi(7), eta(-1), name(54), multilayerId(2) and identifier 0x7f3e648000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (32), layer(4), phi(7), eta(-1), name(54), multilayerId(2) and identifier 0x7f3e73e000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (33), layer(4), phi(7), eta(-1), name(54), multilayerId(2) and identifier 0x7f3e740000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (34), layer(4), phi(7), eta(-1), name(54), multilayerId(2) and identifier 0x7f3e742000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (35), layer(4), phi(7), eta(-1), name(54), multilayerId(2) and identifier 0x7f3e744000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (36), layer(4), phi(7), eta(-1), name(54), multilayerId(2) and identifier 0x7f3e746000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (37), layer(4), phi(7), eta(-1), name(54), multilayerId(2) and identifier 0x7f3e748000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (38), layer(4), phi(7), eta(-1), name(54), multilayerId(2) and identifier 0x7f3e74a000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (25), layer(1), phi(7), eta(1), name(54), multilayerId(1) and identifier 0x7f4e030000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (26), layer(1), phi(7), eta(1), name(54), multilayerId(1) and identifier 0x7f4e032000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (27), layer(1), phi(7), eta(1), name(54), multilayerId(1) and identifier 0x7f4e034000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (28), layer(1), phi(7), eta(1), name(54), multilayerId(1) and identifier 0x7f4e036000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (29), layer(1), phi(7), eta(1), name(54), multilayerId(1) and identifier 0x7f4e038000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (30), layer(1), phi(7), eta(1), name(54), multilayerId(1) and identifier 0x7f4e03a000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (24), layer(2), phi(7), eta(1), name(54), multilayerId(1) and identifier 0x7f4e12e000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (25), layer(2), phi(7), eta(1), name(54), multilayerId(1) and identifier 0x7f4e130000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (26), layer(2), phi(7), eta(1), name(54), multilayerId(1) and identifier 0x7f4e132000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (27), layer(2), phi(7), eta(1), name(54), multilayerId(1) and identifier 0x7f4e134000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (28), layer(2), phi(7), eta(1), name(54), multilayerId(1) and identifier 0x7f4e136000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (29), layer(2), phi(7), eta(1), name(54), multilayerId(1) and identifier 0x7f4e138000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (30), layer(2), phi(7), eta(1), name(54), multilayerId(1) and identifier 0x7f4e13a000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (25), layer(3), phi(7), eta(1), name(54), multilayerId(1) and identifier 0x7f4e230000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (26), layer(3), phi(7), eta(1), name(54), multilayerId(1) and identifier 0x7f4e232000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (27), layer(3), phi(7), eta(1), name(54), multilayerId(1) and identifier 0x7f4e234000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (28), layer(3), phi(7), eta(1), name(54), multilayerId(1) and identifier 0x7f4e236000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (29), layer(3), phi(7), eta(1), name(54), multilayerId(1) and identifier 0x7f4e238000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (30), layer(3), phi(7), eta(1), name(54), multilayerId(1) and identifier 0x7f4e23a000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (31), layer(3), phi(7), eta(1), name(54), multilayerId(1) and identifier 0x7f4e23c000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (25), layer(4), phi(7), eta(1), name(54), multilayerId(1) and identifier 0x7f4e330000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (26), layer(4), phi(7), eta(1), name(54), multilayerId(1) and identifier 0x7f4e332000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (27), layer(4), phi(7), eta(1), name(54), multilayerId(1) and identifier 0x7f4e334000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (28), layer(4), phi(7), eta(1), name(54), multilayerId(1) and identifier 0x7f4e336000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (29), layer(4), phi(7), eta(1), name(54), multilayerId(1) and identifier 0x7f4e338000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (30), layer(4), phi(7), eta(1), name(54), multilayerId(1) and identifier 0x7f4e33a000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (31), layer(4), phi(7), eta(1), name(54), multilayerId(1) and identifier 0x7f4e33c000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (31), layer(1), phi(7), eta(1), name(54), multilayerId(2) and identifier 0x7f4e43c000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (32), layer(1), phi(7), eta(1), name(54), multilayerId(2) and identifier 0x7f4e43e000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (33), layer(1), phi(7), eta(1), name(54), multilayerId(2) and identifier 0x7f4e440000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (34), layer(1), phi(7), eta(1), name(54), multilayerId(2) and identifier 0x7f4e442000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (35), layer(1), phi(7), eta(1), name(54), multilayerId(2) and identifier 0x7f4e444000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (36), layer(1), phi(7), eta(1), name(54), multilayerId(2) and identifier 0x7f4e446000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (37), layer(1), phi(7), eta(1), name(54), multilayerId(2) and identifier 0x7f4e448000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (30), layer(2), phi(7), eta(1), name(54), multilayerId(2) and identifier 0x7f4e53a000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (31), layer(2), phi(7), eta(1), name(54), multilayerId(2) and identifier 0x7f4e53c000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (32), layer(2), phi(7), eta(1), name(54), multilayerId(2) and identifier 0x7f4e53e000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (33), layer(2), phi(7), eta(1), name(54), multilayerId(2) and identifier 0x7f4e540000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (34), layer(2), phi(7), eta(1), name(54), multilayerId(2) and identifier 0x7f4e542000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (35), layer(2), phi(7), eta(1), name(54), multilayerId(2) and identifier 0x7f4e544000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (36), layer(2), phi(7), eta(1), name(54), multilayerId(2) and identifier 0x7f4e546000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (37), layer(2), phi(7), eta(1), name(54), multilayerId(2) and identifier 0x7f4e548000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (32), layer(3), phi(7), eta(1), name(54), multilayerId(2) and identifier 0x7f4e63e000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (33), layer(3), phi(7), eta(1), name(54), multilayerId(2) and identifier 0x7f4e640000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (34), layer(3), phi(7), eta(1), name(54), multilayerId(2) and identifier 0x7f4e642000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (35), layer(3), phi(7), eta(1), name(54), multilayerId(2) and identifier 0x7f4e644000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (36), layer(3), phi(7), eta(1), name(54), multilayerId(2) and identifier 0x7f4e646000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (37), layer(3), phi(7), eta(1), name(54), multilayerId(2) and identifier 0x7f4e648000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (38), layer(3), phi(7), eta(1), name(54), multilayerId(2) and identifier 0x7f4e64a000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (32), layer(4), phi(7), eta(1), name(54), multilayerId(2) and identifier 0x7f4e73e000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (33), layer(4), phi(7), eta(1), name(54), multilayerId(2) and identifier 0x7f4e740000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (34), layer(4), phi(7), eta(1), name(54), multilayerId(2) and identifier 0x7f4e742000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (35), layer(4), phi(7), eta(1), name(54), multilayerId(2) and identifier 0x7f4e744000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (36), layer(4), phi(7), eta(1), name(54), multilayerId(2) and identifier 0x7f4e746000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (37), layer(4), phi(7), eta(1), name(54), multilayerId(2) and identifier 0x7f4e748000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (14), layer(1), phi(7), eta(-2), name(54), multilayerId(1) and identifier 0x7f3601a000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (15), layer(1), phi(7), eta(-2), name(54), multilayerId(1) and identifier 0x7f3601c000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (16), layer(1), phi(7), eta(-2), name(54), multilayerId(1) and identifier 0x7f3601e000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (17), layer(1), phi(7), eta(-2), name(54), multilayerId(1) and identifier 0x7f36020000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (18), layer(1), phi(7), eta(-2), name(54), multilayerId(1) and identifier 0x7f36022000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (19), layer(1), phi(7), eta(-2), name(54), multilayerId(1) and identifier 0x7f36024000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (20), layer(1), phi(7), eta(-2), name(54), multilayerId(1) and identifier 0x7f36026000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (21), layer(1), phi(7), eta(-2), name(54), multilayerId(1) and identifier 0x7f36028000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (15), layer(2), phi(7), eta(-2), name(54), multilayerId(1) and identifier 0x7f3611c000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (16), layer(2), phi(7), eta(-2), name(54), multilayerId(1) and identifier 0x7f3611e000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (17), layer(2), phi(7), eta(-2), name(54), multilayerId(1) and identifier 0x7f36120000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (18), layer(2), phi(7), eta(-2), name(54), multilayerId(1) and identifier 0x7f36122000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (19), layer(2), phi(7), eta(-2), name(54), multilayerId(1) and identifier 0x7f36124000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (20), layer(2), phi(7), eta(-2), name(54), multilayerId(1) and identifier 0x7f36126000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (21), layer(2), phi(7), eta(-2), name(54), multilayerId(1) and identifier 0x7f36128000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (22), layer(2), phi(7), eta(-2), name(54), multilayerId(1) and identifier 0x7f3612a000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (15), layer(3), phi(7), eta(-2), name(54), multilayerId(1) and identifier 0x7f3621c000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (16), layer(3), phi(7), eta(-2), name(54), multilayerId(1) and identifier 0x7f3621e000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (17), layer(3), phi(7), eta(-2), name(54), multilayerId(1) and identifier 0x7f36220000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (18), layer(3), phi(7), eta(-2), name(54), multilayerId(1) and identifier 0x7f36222000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (19), layer(3), phi(7), eta(-2), name(54), multilayerId(1) and identifier 0x7f36224000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (20), layer(3), phi(7), eta(-2), name(54), multilayerId(1) and identifier 0x7f36226000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (21), layer(3), phi(7), eta(-2), name(54), multilayerId(1) and identifier 0x7f36228000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (22), layer(3), phi(7), eta(-2), name(54), multilayerId(1) and identifier 0x7f3622a000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (16), layer(4), phi(7), eta(-2), name(54), multilayerId(1) and identifier 0x7f3631e000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (17), layer(4), phi(7), eta(-2), name(54), multilayerId(1) and identifier 0x7f36320000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (18), layer(4), phi(7), eta(-2), name(54), multilayerId(1) and identifier 0x7f36322000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (19), layer(4), phi(7), eta(-2), name(54), multilayerId(1) and identifier 0x7f36324000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (20), layer(4), phi(7), eta(-2), name(54), multilayerId(1) and identifier 0x7f36326000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (21), layer(4), phi(7), eta(-2), name(54), multilayerId(1) and identifier 0x7f36328000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (22), layer(4), phi(7), eta(-2), name(54), multilayerId(1) and identifier 0x7f3632a000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (23), layer(4), phi(7), eta(-2), name(54), multilayerId(1) and identifier 0x7f3632c000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (26), layer(1), phi(7), eta(-2), name(54), multilayerId(2) and identifier 0x7f36432000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (27), layer(1), phi(7), eta(-2), name(54), multilayerId(2) and identifier 0x7f36434000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (28), layer(1), phi(7), eta(-2), name(54), multilayerId(2) and identifier 0x7f36436000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (29), layer(1), phi(7), eta(-2), name(54), multilayerId(2) and identifier 0x7f36438000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (30), layer(1), phi(7), eta(-2), name(54), multilayerId(2) and identifier 0x7f3643a000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (31), layer(1), phi(7), eta(-2), name(54), multilayerId(2) and identifier 0x7f3643c000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (32), layer(1), phi(7), eta(-2), name(54), multilayerId(2) and identifier 0x7f3643e000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (33), layer(1), phi(7), eta(-2), name(54), multilayerId(2) and identifier 0x7f36440000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (27), layer(2), phi(7), eta(-2), name(54), multilayerId(2) and identifier 0x7f36534000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (28), layer(2), phi(7), eta(-2), name(54), multilayerId(2) and identifier 0x7f36536000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (29), layer(2), phi(7), eta(-2), name(54), multilayerId(2) and identifier 0x7f36538000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (30), layer(2), phi(7), eta(-2), name(54), multilayerId(2) and identifier 0x7f3653a000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (31), layer(2), phi(7), eta(-2), name(54), multilayerId(2) and identifier 0x7f3653c000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (32), layer(2), phi(7), eta(-2), name(54), multilayerId(2) and identifier 0x7f3653e000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (33), layer(2), phi(7), eta(-2), name(54), multilayerId(2) and identifier 0x7f36540000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (34), layer(2), phi(7), eta(-2), name(54), multilayerId(2) and identifier 0x7f36542000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (27), layer(3), phi(7), eta(-2), name(54), multilayerId(2) and identifier 0x7f36634000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (28), layer(3), phi(7), eta(-2), name(54), multilayerId(2) and identifier 0x7f36636000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (29), layer(3), phi(7), eta(-2), name(54), multilayerId(2) and identifier 0x7f36638000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (30), layer(3), phi(7), eta(-2), name(54), multilayerId(2) and identifier 0x7f3663a000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (31), layer(3), phi(7), eta(-2), name(54), multilayerId(2) and identifier 0x7f3663c000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (32), layer(3), phi(7), eta(-2), name(54), multilayerId(2) and identifier 0x7f3663e000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (33), layer(3), phi(7), eta(-2), name(54), multilayerId(2) and identifier 0x7f36640000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (34), layer(3), phi(7), eta(-2), name(54), multilayerId(2) and identifier 0x7f36642000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (28), layer(4), phi(7), eta(-2), name(54), multilayerId(2) and identifier 0x7f36736000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (29), layer(4), phi(7), eta(-2), name(54), multilayerId(2) and identifier 0x7f36738000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (30), layer(4), phi(7), eta(-2), name(54), multilayerId(2) and identifier 0x7f3673a000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (31), layer(4), phi(7), eta(-2), name(54), multilayerId(2) and identifier 0x7f3673c000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (32), layer(4), phi(7), eta(-2), name(54), multilayerId(2) and identifier 0x7f3673e000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (33), layer(4), phi(7), eta(-2), name(54), multilayerId(2) and identifier 0x7f36740000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (34), layer(4), phi(7), eta(-2), name(54), multilayerId(2) and identifier 0x7f36742000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (35), layer(4), phi(7), eta(-2), name(54), multilayerId(2) and identifier 0x7f36744000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (14), layer(1), phi(7), eta(2), name(54), multilayerId(1) and identifier 0x7f5601a000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (15), layer(1), phi(7), eta(2), name(54), multilayerId(1) and identifier 0x7f5601c000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (16), layer(1), phi(7), eta(2), name(54), multilayerId(1) and identifier 0x7f5601e000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (17), layer(1), phi(7), eta(2), name(54), multilayerId(1) and identifier 0x7f56020000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (18), layer(1), phi(7), eta(2), name(54), multilayerId(1) and identifier 0x7f56022000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (19), layer(1), phi(7), eta(2), name(54), multilayerId(1) and identifier 0x7f56024000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (20), layer(1), phi(7), eta(2), name(54), multilayerId(1) and identifier 0x7f56026000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (21), layer(1), phi(7), eta(2), name(54), multilayerId(1) and identifier 0x7f56028000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (14), layer(2), phi(7), eta(2), name(54), multilayerId(1) and identifier 0x7f5611a000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (15), layer(2), phi(7), eta(2), name(54), multilayerId(1) and identifier 0x7f5611c000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (16), layer(2), phi(7), eta(2), name(54), multilayerId(1) and identifier 0x7f5611e000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (17), layer(2), phi(7), eta(2), name(54), multilayerId(1) and identifier 0x7f56120000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (18), layer(2), phi(7), eta(2), name(54), multilayerId(1) and identifier 0x7f56122000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (19), layer(2), phi(7), eta(2), name(54), multilayerId(1) and identifier 0x7f56124000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (20), layer(2), phi(7), eta(2), name(54), multilayerId(1) and identifier 0x7f56126000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (21), layer(2), phi(7), eta(2), name(54), multilayerId(1) and identifier 0x7f56128000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (15), layer(3), phi(7), eta(2), name(54), multilayerId(1) and identifier 0x7f5621c000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (16), layer(3), phi(7), eta(2), name(54), multilayerId(1) and identifier 0x7f5621e000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (17), layer(3), phi(7), eta(2), name(54), multilayerId(1) and identifier 0x7f56220000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (18), layer(3), phi(7), eta(2), name(54), multilayerId(1) and identifier 0x7f56222000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (19), layer(3), phi(7), eta(2), name(54), multilayerId(1) and identifier 0x7f56224000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (20), layer(3), phi(7), eta(2), name(54), multilayerId(1) and identifier 0x7f56226000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (21), layer(3), phi(7), eta(2), name(54), multilayerId(1) and identifier 0x7f56228000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (22), layer(3), phi(7), eta(2), name(54), multilayerId(1) and identifier 0x7f5622a000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (23), layer(3), phi(7), eta(2), name(54), multilayerId(1) and identifier 0x7f5622c000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (16), layer(4), phi(7), eta(2), name(54), multilayerId(1) and identifier 0x7f5631e000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (17), layer(4), phi(7), eta(2), name(54), multilayerId(1) and identifier 0x7f56320000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (18), layer(4), phi(7), eta(2), name(54), multilayerId(1) and identifier 0x7f56322000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (19), layer(4), phi(7), eta(2), name(54), multilayerId(1) and identifier 0x7f56324000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (20), layer(4), phi(7), eta(2), name(54), multilayerId(1) and identifier 0x7f56326000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (21), layer(4), phi(7), eta(2), name(54), multilayerId(1) and identifier 0x7f56328000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (22), layer(4), phi(7), eta(2), name(54), multilayerId(1) and identifier 0x7f5632a000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (23), layer(4), phi(7), eta(2), name(54), multilayerId(1) and identifier 0x7f5632c000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (26), layer(1), phi(7), eta(2), name(54), multilayerId(2) and identifier 0x7f56432000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (27), layer(1), phi(7), eta(2), name(54), multilayerId(2) and identifier 0x7f56434000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (28), layer(1), phi(7), eta(2), name(54), multilayerId(2) and identifier 0x7f56436000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (29), layer(1), phi(7), eta(2), name(54), multilayerId(2) and identifier 0x7f56438000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (30), layer(1), phi(7), eta(2), name(54), multilayerId(2) and identifier 0x7f5643a000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (31), layer(1), phi(7), eta(2), name(54), multilayerId(2) and identifier 0x7f5643c000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (32), layer(1), phi(7), eta(2), name(54), multilayerId(2) and identifier 0x7f5643e000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (33), layer(1), phi(7), eta(2), name(54), multilayerId(2) and identifier 0x7f56440000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (26), layer(2), phi(7), eta(2), name(54), multilayerId(2) and identifier 0x7f56532000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (27), layer(2), phi(7), eta(2), name(54), multilayerId(2) and identifier 0x7f56534000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (28), layer(2), phi(7), eta(2), name(54), multilayerId(2) and identifier 0x7f56536000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (29), layer(2), phi(7), eta(2), name(54), multilayerId(2) and identifier 0x7f56538000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (30), layer(2), phi(7), eta(2), name(54), multilayerId(2) and identifier 0x7f5653a000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (31), layer(2), phi(7), eta(2), name(54), multilayerId(2) and identifier 0x7f5653c000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (32), layer(2), phi(7), eta(2), name(54), multilayerId(2) and identifier 0x7f5653e000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (33), layer(2), phi(7), eta(2), name(54), multilayerId(2) and identifier 0x7f56540000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (28), layer(3), phi(7), eta(2), name(54), multilayerId(2) and identifier 0x7f56636000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (29), layer(3), phi(7), eta(2), name(54), multilayerId(2) and identifier 0x7f56638000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (30), layer(3), phi(7), eta(2), name(54), multilayerId(2) and identifier 0x7f5663a000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (31), layer(3), phi(7), eta(2), name(54), multilayerId(2) and identifier 0x7f5663c000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (32), layer(3), phi(7), eta(2), name(54), multilayerId(2) and identifier 0x7f5663e000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (33), layer(3), phi(7), eta(2), name(54), multilayerId(2) and identifier 0x7f56640000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (34), layer(3), phi(7), eta(2), name(54), multilayerId(2) and identifier 0x7f56642000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (35), layer(3), phi(7), eta(2), name(54), multilayerId(2) and identifier 0x7f56644000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (28), layer(4), phi(7), eta(2), name(54), multilayerId(2) and identifier 0x7f56736000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (29), layer(4), phi(7), eta(2), name(54), multilayerId(2) and identifier 0x7f56738000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (30), layer(4), phi(7), eta(2), name(54), multilayerId(2) and identifier 0x7f5673a000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (31), layer(4), phi(7), eta(2), name(54), multilayerId(2) and identifier 0x7f5673c000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (32), layer(4), phi(7), eta(2), name(54), multilayerId(2) and identifier 0x7f5673e000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (33), layer(4), phi(7), eta(2), name(54), multilayerId(2) and identifier 0x7f56740000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (34), layer(4), phi(7), eta(2), name(54), multilayerId(2) and identifier 0x7f56742000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (35), layer(4), phi(7), eta(2), name(54), multilayerId(2) and identifier 0x7f56744000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (19), layer(1), phi(7), eta(-3), name(54), multilayerId(1) and identifier 0x7f2e024000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (20), layer(1), phi(7), eta(-3), name(54), multilayerId(1) and identifier 0x7f2e026000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (21), layer(1), phi(7), eta(-3), name(54), multilayerId(1) and identifier 0x7f2e028000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (22), layer(1), phi(7), eta(-3), name(54), multilayerId(1) and identifier 0x7f2e02a000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (23), layer(1), phi(7), eta(-3), name(54), multilayerId(1) and identifier 0x7f2e02c000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (24), layer(1), phi(7), eta(-3), name(54), multilayerId(1) and identifier 0x7f2e02e000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (25), layer(1), phi(7), eta(-3), name(54), multilayerId(1) and identifier 0x7f2e030000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (26), layer(1), phi(7), eta(-3), name(54), multilayerId(1) and identifier 0x7f2e032000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (27), layer(1), phi(7), eta(-3), name(54), multilayerId(1) and identifier 0x7f2e034000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (28), layer(1), phi(7), eta(-3), name(54), multilayerId(1) and identifier 0x7f2e036000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (21), layer(2), phi(7), eta(-3), name(54), multilayerId(1) and identifier 0x7f2e128000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (22), layer(2), phi(7), eta(-3), name(54), multilayerId(1) and identifier 0x7f2e12a000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (23), layer(2), phi(7), eta(-3), name(54), multilayerId(1) and identifier 0x7f2e12c000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (24), layer(2), phi(7), eta(-3), name(54), multilayerId(1) and identifier 0x7f2e12e000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (25), layer(2), phi(7), eta(-3), name(54), multilayerId(1) and identifier 0x7f2e130000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (26), layer(2), phi(7), eta(-3), name(54), multilayerId(1) and identifier 0x7f2e132000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (27), layer(2), phi(7), eta(-3), name(54), multilayerId(1) and identifier 0x7f2e134000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (28), layer(2), phi(7), eta(-3), name(54), multilayerId(1) and identifier 0x7f2e136000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (29), layer(2), phi(7), eta(-3), name(54), multilayerId(1) and identifier 0x7f2e138000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (30), layer(2), phi(7), eta(-3), name(54), multilayerId(1) and identifier 0x7f2e13a000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (21), layer(3), phi(7), eta(-3), name(54), multilayerId(1) and identifier 0x7f2e228000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (22), layer(3), phi(7), eta(-3), name(54), multilayerId(1) and identifier 0x7f2e22a000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (23), layer(3), phi(7), eta(-3), name(54), multilayerId(1) and identifier 0x7f2e22c000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (24), layer(3), phi(7), eta(-3), name(54), multilayerId(1) and identifier 0x7f2e22e000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (25), layer(3), phi(7), eta(-3), name(54), multilayerId(1) and identifier 0x7f2e230000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (26), layer(3), phi(7), eta(-3), name(54), multilayerId(1) and identifier 0x7f2e232000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (27), layer(3), phi(7), eta(-3), name(54), multilayerId(1) and identifier 0x7f2e234000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (28), layer(3), phi(7), eta(-3), name(54), multilayerId(1) and identifier 0x7f2e236000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (29), layer(3), phi(7), eta(-3), name(54), multilayerId(1) and identifier 0x7f2e238000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (30), layer(3), phi(7), eta(-3), name(54), multilayerId(1) and identifier 0x7f2e23a000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (23), layer(4), phi(7), eta(-3), name(54), multilayerId(1) and identifier 0x7f2e32c000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (24), layer(4), phi(7), eta(-3), name(54), multilayerId(1) and identifier 0x7f2e32e000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (25), layer(4), phi(7), eta(-3), name(54), multilayerId(1) and identifier 0x7f2e330000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (26), layer(4), phi(7), eta(-3), name(54), multilayerId(1) and identifier 0x7f2e332000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (27), layer(4), phi(7), eta(-3), name(54), multilayerId(1) and identifier 0x7f2e334000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (28), layer(4), phi(7), eta(-3), name(54), multilayerId(1) and identifier 0x7f2e336000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (29), layer(4), phi(7), eta(-3), name(54), multilayerId(1) and identifier 0x7f2e338000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (30), layer(4), phi(7), eta(-3), name(54), multilayerId(1) and identifier 0x7f2e33a000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (31), layer(4), phi(7), eta(-3), name(54), multilayerId(1) and identifier 0x7f2e33c000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (32), layer(4), phi(7), eta(-3), name(54), multilayerId(1) and identifier 0x7f2e33e000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (37), layer(1), phi(7), eta(-3), name(54), multilayerId(2) and identifier 0x7f2e448000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (38), layer(1), phi(7), eta(-3), name(54), multilayerId(2) and identifier 0x7f2e44a000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (39), layer(1), phi(7), eta(-3), name(54), multilayerId(2) and identifier 0x7f2e44c000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (40), layer(1), phi(7), eta(-3), name(54), multilayerId(2) and identifier 0x7f2e44e000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (41), layer(1), phi(7), eta(-3), name(54), multilayerId(2) and identifier 0x7f2e450000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (42), layer(1), phi(7), eta(-3), name(54), multilayerId(2) and identifier 0x7f2e452000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (43), layer(1), phi(7), eta(-3), name(54), multilayerId(2) and identifier 0x7f2e454000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (44), layer(1), phi(7), eta(-3), name(54), multilayerId(2) and identifier 0x7f2e456000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (45), layer(1), phi(7), eta(-3), name(54), multilayerId(2) and identifier 0x7f2e458000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (38), layer(2), phi(7), eta(-3), name(54), multilayerId(2) and identifier 0x7f2e54a000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (39), layer(2), phi(7), eta(-3), name(54), multilayerId(2) and identifier 0x7f2e54c000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (40), layer(2), phi(7), eta(-3), name(54), multilayerId(2) and identifier 0x7f2e54e000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (41), layer(2), phi(7), eta(-3), name(54), multilayerId(2) and identifier 0x7f2e550000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (42), layer(2), phi(7), eta(-3), name(54), multilayerId(2) and identifier 0x7f2e552000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (43), layer(2), phi(7), eta(-3), name(54), multilayerId(2) and identifier 0x7f2e554000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (44), layer(2), phi(7), eta(-3), name(54), multilayerId(2) and identifier 0x7f2e556000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (45), layer(2), phi(7), eta(-3), name(54), multilayerId(2) and identifier 0x7f2e558000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (46), layer(2), phi(7), eta(-3), name(54), multilayerId(2) and identifier 0x7f2e55a000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (47), layer(2), phi(7), eta(-3), name(54), multilayerId(2) and identifier 0x7f2e55c000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (39), layer(3), phi(7), eta(-3), name(54), multilayerId(2) and identifier 0x7f2e64c000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (40), layer(3), phi(7), eta(-3), name(54), multilayerId(2) and identifier 0x7f2e64e000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (41), layer(3), phi(7), eta(-3), name(54), multilayerId(2) and identifier 0x7f2e650000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (42), layer(3), phi(7), eta(-3), name(54), multilayerId(2) and identifier 0x7f2e652000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (43), layer(3), phi(7), eta(-3), name(54), multilayerId(2) and identifier 0x7f2e654000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (44), layer(3), phi(7), eta(-3), name(54), multilayerId(2) and identifier 0x7f2e656000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (45), layer(3), phi(7), eta(-3), name(54), multilayerId(2) and identifier 0x7f2e658000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (46), layer(3), phi(7), eta(-3), name(54), multilayerId(2) and identifier 0x7f2e65a000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (47), layer(3), phi(7), eta(-3), name(54), multilayerId(2) and identifier 0x7f2e65c000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (40), layer(4), phi(7), eta(-3), name(54), multilayerId(2) and identifier 0x7f2e74e000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (41), layer(4), phi(7), eta(-3), name(54), multilayerId(2) and identifier 0x7f2e750000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (42), layer(4), phi(7), eta(-3), name(54), multilayerId(2) and identifier 0x7f2e752000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (43), layer(4), phi(7), eta(-3), name(54), multilayerId(2) and identifier 0x7f2e754000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (44), layer(4), phi(7), eta(-3), name(54), multilayerId(2) and identifier 0x7f2e756000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (45), layer(4), phi(7), eta(-3), name(54), multilayerId(2) and identifier 0x7f2e758000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (46), layer(4), phi(7), eta(-3), name(54), multilayerId(2) and identifier 0x7f2e75a000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (47), layer(4), phi(7), eta(-3), name(54), multilayerId(2) and identifier 0x7f2e75c000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (48), layer(4), phi(7), eta(-3), name(54), multilayerId(2) and identifier 0x7f2e75e000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (49), layer(4), phi(7), eta(-3), name(54), multilayerId(2) and identifier 0x7f2e760000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (20), layer(1), phi(7), eta(3), name(54), multilayerId(1) and identifier 0x7f5e026000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (21), layer(1), phi(7), eta(3), name(54), multilayerId(1) and identifier 0x7f5e028000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (22), layer(1), phi(7), eta(3), name(54), multilayerId(1) and identifier 0x7f5e02a000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (23), layer(1), phi(7), eta(3), name(54), multilayerId(1) and identifier 0x7f5e02c000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (24), layer(1), phi(7), eta(3), name(54), multilayerId(1) and identifier 0x7f5e02e000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (25), layer(1), phi(7), eta(3), name(54), multilayerId(1) and identifier 0x7f5e030000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (26), layer(1), phi(7), eta(3), name(54), multilayerId(1) and identifier 0x7f5e032000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (27), layer(1), phi(7), eta(3), name(54), multilayerId(1) and identifier 0x7f5e034000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (28), layer(1), phi(7), eta(3), name(54), multilayerId(1) and identifier 0x7f5e036000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (20), layer(2), phi(7), eta(3), name(54), multilayerId(1) and identifier 0x7f5e126000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (21), layer(2), phi(7), eta(3), name(54), multilayerId(1) and identifier 0x7f5e128000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (22), layer(2), phi(7), eta(3), name(54), multilayerId(1) and identifier 0x7f5e12a000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (23), layer(2), phi(7), eta(3), name(54), multilayerId(1) and identifier 0x7f5e12c000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (24), layer(2), phi(7), eta(3), name(54), multilayerId(1) and identifier 0x7f5e12e000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (25), layer(2), phi(7), eta(3), name(54), multilayerId(1) and identifier 0x7f5e130000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (26), layer(2), phi(7), eta(3), name(54), multilayerId(1) and identifier 0x7f5e132000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (27), layer(2), phi(7), eta(3), name(54), multilayerId(1) and identifier 0x7f5e134000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (28), layer(2), phi(7), eta(3), name(54), multilayerId(1) and identifier 0x7f5e136000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (29), layer(2), phi(7), eta(3), name(54), multilayerId(1) and identifier 0x7f5e138000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (22), layer(3), phi(7), eta(3), name(54), multilayerId(1) and identifier 0x7f5e22a000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (23), layer(3), phi(7), eta(3), name(54), multilayerId(1) and identifier 0x7f5e22c000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (24), layer(3), phi(7), eta(3), name(54), multilayerId(1) and identifier 0x7f5e22e000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (25), layer(3), phi(7), eta(3), name(54), multilayerId(1) and identifier 0x7f5e230000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (26), layer(3), phi(7), eta(3), name(54), multilayerId(1) and identifier 0x7f5e232000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (27), layer(3), phi(7), eta(3), name(54), multilayerId(1) and identifier 0x7f5e234000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (28), layer(3), phi(7), eta(3), name(54), multilayerId(1) and identifier 0x7f5e236000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (29), layer(3), phi(7), eta(3), name(54), multilayerId(1) and identifier 0x7f5e238000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (30), layer(3), phi(7), eta(3), name(54), multilayerId(1) and identifier 0x7f5e23a000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (22), layer(4), phi(7), eta(3), name(54), multilayerId(1) and identifier 0x7f5e32a000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (23), layer(4), phi(7), eta(3), name(54), multilayerId(1) and identifier 0x7f5e32c000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (24), layer(4), phi(7), eta(3), name(54), multilayerId(1) and identifier 0x7f5e32e000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (25), layer(4), phi(7), eta(3), name(54), multilayerId(1) and identifier 0x7f5e330000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (26), layer(4), phi(7), eta(3), name(54), multilayerId(1) and identifier 0x7f5e332000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (27), layer(4), phi(7), eta(3), name(54), multilayerId(1) and identifier 0x7f5e334000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (28), layer(4), phi(7), eta(3), name(54), multilayerId(1) and identifier 0x7f5e336000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (29), layer(4), phi(7), eta(3), name(54), multilayerId(1) and identifier 0x7f5e338000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (30), layer(4), phi(7), eta(3), name(54), multilayerId(1) and identifier 0x7f5e33a000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (31), layer(4), phi(7), eta(3), name(54), multilayerId(1) and identifier 0x7f5e33c000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (37), layer(1), phi(7), eta(3), name(54), multilayerId(2) and identifier 0x7f5e448000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (38), layer(1), phi(7), eta(3), name(54), multilayerId(2) and identifier 0x7f5e44a000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (39), layer(1), phi(7), eta(3), name(54), multilayerId(2) and identifier 0x7f5e44c000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (40), layer(1), phi(7), eta(3), name(54), multilayerId(2) and identifier 0x7f5e44e000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (41), layer(1), phi(7), eta(3), name(54), multilayerId(2) and identifier 0x7f5e450000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (42), layer(1), phi(7), eta(3), name(54), multilayerId(2) and identifier 0x7f5e452000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (43), layer(1), phi(7), eta(3), name(54), multilayerId(2) and identifier 0x7f5e454000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (44), layer(1), phi(7), eta(3), name(54), multilayerId(2) and identifier 0x7f5e456000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (45), layer(1), phi(7), eta(3), name(54), multilayerId(2) and identifier 0x7f5e458000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (46), layer(1), phi(7), eta(3), name(54), multilayerId(2) and identifier 0x7f5e45a000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (38), layer(2), phi(7), eta(3), name(54), multilayerId(2) and identifier 0x7f5e54a000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (39), layer(2), phi(7), eta(3), name(54), multilayerId(2) and identifier 0x7f5e54c000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (40), layer(2), phi(7), eta(3), name(54), multilayerId(2) and identifier 0x7f5e54e000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (41), layer(2), phi(7), eta(3), name(54), multilayerId(2) and identifier 0x7f5e550000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (42), layer(2), phi(7), eta(3), name(54), multilayerId(2) and identifier 0x7f5e552000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (43), layer(2), phi(7), eta(3), name(54), multilayerId(2) and identifier 0x7f5e554000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (44), layer(2), phi(7), eta(3), name(54), multilayerId(2) and identifier 0x7f5e556000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (45), layer(2), phi(7), eta(3), name(54), multilayerId(2) and identifier 0x7f5e558000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (46), layer(2), phi(7), eta(3), name(54), multilayerId(2) and identifier 0x7f5e55a000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (39), layer(3), phi(7), eta(3), name(54), multilayerId(2) and identifier 0x7f5e64c000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (40), layer(3), phi(7), eta(3), name(54), multilayerId(2) and identifier 0x7f5e64e000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (41), layer(3), phi(7), eta(3), name(54), multilayerId(2) and identifier 0x7f5e650000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (42), layer(3), phi(7), eta(3), name(54), multilayerId(2) and identifier 0x7f5e652000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (43), layer(3), phi(7), eta(3), name(54), multilayerId(2) and identifier 0x7f5e654000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (44), layer(3), phi(7), eta(3), name(54), multilayerId(2) and identifier 0x7f5e656000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (45), layer(3), phi(7), eta(3), name(54), multilayerId(2) and identifier 0x7f5e658000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (46), layer(3), phi(7), eta(3), name(54), multilayerId(2) and identifier 0x7f5e65a000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (47), layer(3), phi(7), eta(3), name(54), multilayerId(2) and identifier 0x7f5e65c000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (48), layer(3), phi(7), eta(3), name(54), multilayerId(2) and identifier 0x7f5e65e000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (40), layer(4), phi(7), eta(3), name(54), multilayerId(2) and identifier 0x7f5e74e000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (41), layer(4), phi(7), eta(3), name(54), multilayerId(2) and identifier 0x7f5e750000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (42), layer(4), phi(7), eta(3), name(54), multilayerId(2) and identifier 0x7f5e752000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (43), layer(4), phi(7), eta(3), name(54), multilayerId(2) and identifier 0x7f5e754000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (44), layer(4), phi(7), eta(3), name(54), multilayerId(2) and identifier 0x7f5e756000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (45), layer(4), phi(7), eta(3), name(54), multilayerId(2) and identifier 0x7f5e758000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (46), layer(4), phi(7), eta(3), name(54), multilayerId(2) and identifier 0x7f5e75a000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (47), layer(4), phi(7), eta(3), name(54), multilayerId(2) and identifier 0x7f5e75c000000000 .
-ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube (48), layer(4), phi(7), eta(3), name(54), multilayerId(2) and identifier 0x7f5e75e000000000 .
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -1 phi 6 ml 1 lay 1 tube 25
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -1 phi 6 ml 1 lay 1 tube 26
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -1 phi 6 ml 1 lay 1 tube 27
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -1 phi 6 ml 1 lay 1 tube 28
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -1 phi 6 ml 1 lay 1 tube 29
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -1 phi 6 ml 1 lay 1 tube 30
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -1 phi 6 ml 1 lay 2 tube 24
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -1 phi 6 ml 1 lay 2 tube 25
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -1 phi 6 ml 1 lay 2 tube 26
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -1 phi 6 ml 1 lay 2 tube 27
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -1 phi 6 ml 1 lay 2 tube 28
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -1 phi 6 ml 1 lay 2 tube 29
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -1 phi 6 ml 1 lay 2 tube 30
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -1 phi 6 ml 1 lay 3 tube 25
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -1 phi 6 ml 1 lay 3 tube 26
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -1 phi 6 ml 1 lay 3 tube 27
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -1 phi 6 ml 1 lay 3 tube 28
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -1 phi 6 ml 1 lay 3 tube 29
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -1 phi 6 ml 1 lay 3 tube 30
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -1 phi 6 ml 1 lay 3 tube 31
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -1 phi 6 ml 1 lay 4 tube 25
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -1 phi 6 ml 1 lay 4 tube 26
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -1 phi 6 ml 1 lay 4 tube 27
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -1 phi 6 ml 1 lay 4 tube 28
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -1 phi 6 ml 1 lay 4 tube 29
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -1 phi 6 ml 1 lay 4 tube 30
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -1 phi 6 ml 1 lay 4 tube 31
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -1 phi 6 ml 2 lay 1 tube 31
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -1 phi 6 ml 2 lay 1 tube 32
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -1 phi 6 ml 2 lay 1 tube 33
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -1 phi 6 ml 2 lay 1 tube 34
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -1 phi 6 ml 2 lay 1 tube 35
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -1 phi 6 ml 2 lay 1 tube 36
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -1 phi 6 ml 2 lay 1 tube 37
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -1 phi 6 ml 2 lay 2 tube 30
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -1 phi 6 ml 2 lay 2 tube 31
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -1 phi 6 ml 2 lay 2 tube 32
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -1 phi 6 ml 2 lay 2 tube 33
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -1 phi 6 ml 2 lay 2 tube 34
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -1 phi 6 ml 2 lay 2 tube 35
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -1 phi 6 ml 2 lay 2 tube 36
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -1 phi 6 ml 2 lay 2 tube 37
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -1 phi 6 ml 2 lay 3 tube 32
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -1 phi 6 ml 2 lay 3 tube 33
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -1 phi 6 ml 2 lay 3 tube 34
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -1 phi 6 ml 2 lay 3 tube 35
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -1 phi 6 ml 2 lay 3 tube 36
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -1 phi 6 ml 2 lay 3 tube 37
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -1 phi 6 ml 2 lay 3 tube 38
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -1 phi 6 ml 2 lay 4 tube 32
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -1 phi 6 ml 2 lay 4 tube 33
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -1 phi 6 ml 2 lay 4 tube 34
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -1 phi 6 ml 2 lay 4 tube 35
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -1 phi 6 ml 2 lay 4 tube 36
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -1 phi 6 ml 2 lay 4 tube 37
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 1 phi 6 ml 1 lay 1 tube 24
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 1 phi 6 ml 1 lay 1 tube 25
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 1 phi 6 ml 1 lay 1 tube 26
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 1 phi 6 ml 1 lay 1 tube 27
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 1 phi 6 ml 1 lay 1 tube 28
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 1 phi 6 ml 1 lay 1 tube 29
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 1 phi 6 ml 1 lay 1 tube 30
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 1 phi 6 ml 1 lay 2 tube 25
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 1 phi 6 ml 1 lay 2 tube 26
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 1 phi 6 ml 1 lay 2 tube 27
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 1 phi 6 ml 1 lay 2 tube 28
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 1 phi 6 ml 1 lay 2 tube 29
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 1 phi 6 ml 1 lay 2 tube 30
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 1 phi 6 ml 1 lay 2 tube 31
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 1 phi 6 ml 1 lay 3 tube 25
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 1 phi 6 ml 1 lay 3 tube 26
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 1 phi 6 ml 1 lay 3 tube 27
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 1 phi 6 ml 1 lay 3 tube 28
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 1 phi 6 ml 1 lay 3 tube 29
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 1 phi 6 ml 1 lay 3 tube 30
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 1 phi 6 ml 1 lay 3 tube 31
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 1 phi 6 ml 1 lay 4 tube 26
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 1 phi 6 ml 1 lay 4 tube 27
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 1 phi 6 ml 1 lay 4 tube 28
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 1 phi 6 ml 1 lay 4 tube 29
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 1 phi 6 ml 1 lay 4 tube 30
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 1 phi 6 ml 1 lay 4 tube 31
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 1 phi 6 ml 1 lay 4 tube 32
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 1 phi 6 ml 2 lay 1 tube 30
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 1 phi 6 ml 2 lay 1 tube 31
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 1 phi 6 ml 2 lay 1 tube 32
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 1 phi 6 ml 2 lay 1 tube 33
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 1 phi 6 ml 2 lay 1 tube 34
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 1 phi 6 ml 2 lay 1 tube 35
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 1 phi 6 ml 2 lay 1 tube 36
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 1 phi 6 ml 2 lay 2 tube 31
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 1 phi 6 ml 2 lay 2 tube 32
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 1 phi 6 ml 2 lay 2 tube 33
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 1 phi 6 ml 2 lay 2 tube 34
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 1 phi 6 ml 2 lay 2 tube 35
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 1 phi 6 ml 2 lay 2 tube 36
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 1 phi 6 ml 2 lay 2 tube 37
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 1 phi 6 ml 2 lay 3 tube 31
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 1 phi 6 ml 2 lay 3 tube 32
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 1 phi 6 ml 2 lay 3 tube 33
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 1 phi 6 ml 2 lay 3 tube 34
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 1 phi 6 ml 2 lay 3 tube 35
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 1 phi 6 ml 2 lay 3 tube 36
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 1 phi 6 ml 2 lay 3 tube 37
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 1 phi 6 ml 2 lay 4 tube 32
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 1 phi 6 ml 2 lay 4 tube 33
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 1 phi 6 ml 2 lay 4 tube 34
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 1 phi 6 ml 2 lay 4 tube 35
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 1 phi 6 ml 2 lay 4 tube 36
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 1 phi 6 ml 2 lay 4 tube 37
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 1 phi 6 ml 2 lay 4 tube 38
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 6 ml 1 lay 1 tube 14
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 6 ml 1 lay 1 tube 15
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 6 ml 1 lay 1 tube 16
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 6 ml 1 lay 1 tube 17
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 6 ml 1 lay 1 tube 18
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 6 ml 1 lay 1 tube 19
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 6 ml 1 lay 1 tube 20
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 6 ml 1 lay 1 tube 21
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 6 ml 1 lay 2 tube 14
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 6 ml 1 lay 2 tube 15
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 6 ml 1 lay 2 tube 16
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 6 ml 1 lay 2 tube 17
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 6 ml 1 lay 2 tube 18
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 6 ml 1 lay 2 tube 19
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 6 ml 1 lay 2 tube 20
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 6 ml 1 lay 2 tube 21
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 6 ml 1 lay 3 tube 15
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 6 ml 1 lay 3 tube 16
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 6 ml 1 lay 3 tube 17
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 6 ml 1 lay 3 tube 18
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 6 ml 1 lay 3 tube 19
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 6 ml 1 lay 3 tube 20
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 6 ml 1 lay 3 tube 21
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 6 ml 1 lay 3 tube 22
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 6 ml 1 lay 3 tube 23
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 6 ml 1 lay 4 tube 16
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 6 ml 1 lay 4 tube 17
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 6 ml 1 lay 4 tube 18
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 6 ml 1 lay 4 tube 19
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 6 ml 1 lay 4 tube 20
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 6 ml 1 lay 4 tube 21
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 6 ml 1 lay 4 tube 22
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 6 ml 1 lay 4 tube 23
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 6 ml 2 lay 1 tube 26
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 6 ml 2 lay 1 tube 27
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 6 ml 2 lay 1 tube 28
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 6 ml 2 lay 1 tube 29
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 6 ml 2 lay 1 tube 30
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 6 ml 2 lay 1 tube 31
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 6 ml 2 lay 1 tube 32
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 6 ml 2 lay 1 tube 33
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 6 ml 2 lay 2 tube 26
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 6 ml 2 lay 2 tube 27
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 6 ml 2 lay 2 tube 28
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 6 ml 2 lay 2 tube 29
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 6 ml 2 lay 2 tube 30
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 6 ml 2 lay 2 tube 31
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 6 ml 2 lay 2 tube 32
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 6 ml 2 lay 2 tube 33
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 6 ml 2 lay 3 tube 28
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 6 ml 2 lay 3 tube 29
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 6 ml 2 lay 3 tube 30
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 6 ml 2 lay 3 tube 31
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 6 ml 2 lay 3 tube 32
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 6 ml 2 lay 3 tube 33
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 6 ml 2 lay 3 tube 34
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 6 ml 2 lay 3 tube 35
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 6 ml 2 lay 4 tube 28
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 6 ml 2 lay 4 tube 29
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 6 ml 2 lay 4 tube 30
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 6 ml 2 lay 4 tube 31
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 6 ml 2 lay 4 tube 32
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 6 ml 2 lay 4 tube 33
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 6 ml 2 lay 4 tube 34
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 6 ml 2 lay 4 tube 35
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 6 ml 1 lay 1 tube 14
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 6 ml 1 lay 1 tube 15
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 6 ml 1 lay 1 tube 16
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 6 ml 1 lay 1 tube 17
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 6 ml 1 lay 1 tube 18
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 6 ml 1 lay 1 tube 19
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 6 ml 1 lay 1 tube 20
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 6 ml 1 lay 1 tube 21
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 6 ml 1 lay 2 tube 15
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 6 ml 1 lay 2 tube 16
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 6 ml 1 lay 2 tube 17
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 6 ml 1 lay 2 tube 18
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 6 ml 1 lay 2 tube 19
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 6 ml 1 lay 2 tube 20
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 6 ml 1 lay 2 tube 21
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 6 ml 1 lay 2 tube 22
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 6 ml 1 lay 3 tube 15
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 6 ml 1 lay 3 tube 16
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 6 ml 1 lay 3 tube 17
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 6 ml 1 lay 3 tube 18
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 6 ml 1 lay 3 tube 19
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 6 ml 1 lay 3 tube 20
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 6 ml 1 lay 3 tube 21
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 6 ml 1 lay 3 tube 22
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 6 ml 1 lay 4 tube 16
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 6 ml 1 lay 4 tube 17
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 6 ml 1 lay 4 tube 18
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 6 ml 1 lay 4 tube 19
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 6 ml 1 lay 4 tube 20
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 6 ml 1 lay 4 tube 21
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 6 ml 1 lay 4 tube 22
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 6 ml 1 lay 4 tube 23
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 6 ml 2 lay 1 tube 26
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 6 ml 2 lay 1 tube 27
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 6 ml 2 lay 1 tube 28
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 6 ml 2 lay 1 tube 29
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 6 ml 2 lay 1 tube 30
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 6 ml 2 lay 1 tube 31
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 6 ml 2 lay 1 tube 32
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 6 ml 2 lay 1 tube 33
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 6 ml 2 lay 2 tube 27
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 6 ml 2 lay 2 tube 28
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 6 ml 2 lay 2 tube 29
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 6 ml 2 lay 2 tube 30
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 6 ml 2 lay 2 tube 31
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 6 ml 2 lay 2 tube 32
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 6 ml 2 lay 2 tube 33
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 6 ml 2 lay 2 tube 34
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 6 ml 2 lay 3 tube 27
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 6 ml 2 lay 3 tube 28
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 6 ml 2 lay 3 tube 29
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 6 ml 2 lay 3 tube 30
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 6 ml 2 lay 3 tube 31
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 6 ml 2 lay 3 tube 32
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 6 ml 2 lay 3 tube 33
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 6 ml 2 lay 3 tube 34
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 6 ml 2 lay 4 tube 28
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 6 ml 2 lay 4 tube 29
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 6 ml 2 lay 4 tube 30
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 6 ml 2 lay 4 tube 31
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 6 ml 2 lay 4 tube 32
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 6 ml 2 lay 4 tube 33
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 6 ml 2 lay 4 tube 34
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 6 ml 2 lay 4 tube 35
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 6 ml 1 lay 1 tube 16
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 6 ml 1 lay 1 tube 17
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 6 ml 1 lay 1 tube 18
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 6 ml 1 lay 1 tube 19
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 6 ml 1 lay 1 tube 20
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 6 ml 1 lay 1 tube 21
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 6 ml 1 lay 1 tube 22
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 6 ml 1 lay 1 tube 23
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 6 ml 1 lay 1 tube 24
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 6 ml 1 lay 1 tube 25
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 6 ml 1 lay 1 tube 26
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 6 ml 1 lay 1 tube 27
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 6 ml 1 lay 1 tube 28
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 6 ml 1 lay 2 tube 16
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 6 ml 1 lay 2 tube 17
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 6 ml 1 lay 2 tube 18
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 6 ml 1 lay 2 tube 19
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 6 ml 1 lay 2 tube 20
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 6 ml 1 lay 2 tube 21
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 6 ml 1 lay 2 tube 22
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 6 ml 1 lay 2 tube 23
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 6 ml 1 lay 2 tube 24
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 6 ml 1 lay 2 tube 25
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 6 ml 1 lay 2 tube 26
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 6 ml 1 lay 2 tube 27
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 6 ml 1 lay 2 tube 28
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 6 ml 1 lay 2 tube 29
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 6 ml 1 lay 3 tube 18
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 6 ml 1 lay 3 tube 19
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 6 ml 1 lay 3 tube 20
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 6 ml 1 lay 3 tube 21
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 6 ml 1 lay 3 tube 22
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 6 ml 1 lay 3 tube 23
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 6 ml 1 lay 3 tube 24
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 6 ml 1 lay 3 tube 25
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 6 ml 1 lay 3 tube 26
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 6 ml 1 lay 3 tube 27
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 6 ml 1 lay 3 tube 28
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 6 ml 1 lay 3 tube 29
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 6 ml 1 lay 3 tube 30
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 6 ml 1 lay 4 tube 18
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 6 ml 1 lay 4 tube 19
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 6 ml 1 lay 4 tube 20
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 6 ml 1 lay 4 tube 21
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 6 ml 1 lay 4 tube 22
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 6 ml 1 lay 4 tube 23
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 6 ml 1 lay 4 tube 24
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 6 ml 1 lay 4 tube 25
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 6 ml 1 lay 4 tube 26
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 6 ml 1 lay 4 tube 27
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 6 ml 1 lay 4 tube 28
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 6 ml 1 lay 4 tube 29
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 6 ml 1 lay 4 tube 30
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 6 ml 1 lay 4 tube 31
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 6 ml 2 lay 1 tube 33
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 6 ml 2 lay 1 tube 34
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 6 ml 2 lay 1 tube 35
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 6 ml 2 lay 1 tube 36
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 6 ml 2 lay 1 tube 37
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 6 ml 2 lay 1 tube 38
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 6 ml 2 lay 1 tube 39
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 6 ml 2 lay 1 tube 40
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 6 ml 2 lay 1 tube 41
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 6 ml 2 lay 1 tube 42
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 6 ml 2 lay 1 tube 43
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 6 ml 2 lay 1 tube 44
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 6 ml 2 lay 1 tube 45
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 6 ml 2 lay 1 tube 46
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 6 ml 2 lay 2 tube 33
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 6 ml 2 lay 2 tube 34
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 6 ml 2 lay 2 tube 35
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 6 ml 2 lay 2 tube 36
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 6 ml 2 lay 2 tube 37
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 6 ml 2 lay 2 tube 38
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 6 ml 2 lay 2 tube 39
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 6 ml 2 lay 2 tube 40
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 6 ml 2 lay 2 tube 41
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 6 ml 2 lay 2 tube 42
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 6 ml 2 lay 2 tube 43
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 6 ml 2 lay 2 tube 44
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 6 ml 2 lay 2 tube 45
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 6 ml 2 lay 2 tube 46
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 6 ml 2 lay 3 tube 35
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 6 ml 2 lay 3 tube 36
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 6 ml 2 lay 3 tube 37
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 6 ml 2 lay 3 tube 38
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 6 ml 2 lay 3 tube 39
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 6 ml 2 lay 3 tube 40
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 6 ml 2 lay 3 tube 41
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 6 ml 2 lay 3 tube 42
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 6 ml 2 lay 3 tube 43
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 6 ml 2 lay 3 tube 44
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 6 ml 2 lay 3 tube 45
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 6 ml 2 lay 3 tube 46
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 6 ml 2 lay 3 tube 47
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 6 ml 2 lay 3 tube 48
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 6 ml 2 lay 4 tube 35
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 6 ml 2 lay 4 tube 36
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 6 ml 2 lay 4 tube 37
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 6 ml 2 lay 4 tube 38
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 6 ml 2 lay 4 tube 39
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 6 ml 2 lay 4 tube 40
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 6 ml 2 lay 4 tube 41
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 6 ml 2 lay 4 tube 42
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 6 ml 2 lay 4 tube 43
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 6 ml 2 lay 4 tube 44
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 6 ml 2 lay 4 tube 45
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 6 ml 2 lay 4 tube 46
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 6 ml 2 lay 4 tube 47
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 6 ml 2 lay 4 tube 48
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 6 ml 1 lay 1 tube 15
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 6 ml 1 lay 1 tube 16
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 6 ml 1 lay 1 tube 17
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 6 ml 1 lay 1 tube 18
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 6 ml 1 lay 1 tube 19
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 6 ml 1 lay 1 tube 20
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 6 ml 1 lay 1 tube 21
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 6 ml 1 lay 1 tube 22
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 6 ml 1 lay 1 tube 23
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 6 ml 1 lay 1 tube 24
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 6 ml 1 lay 1 tube 25
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 6 ml 1 lay 1 tube 26
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 6 ml 1 lay 1 tube 27
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 6 ml 1 lay 1 tube 28
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 6 ml 1 lay 2 tube 17
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 6 ml 1 lay 2 tube 18
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 6 ml 1 lay 2 tube 19
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 6 ml 1 lay 2 tube 20
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 6 ml 1 lay 2 tube 21
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 6 ml 1 lay 2 tube 22
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 6 ml 1 lay 2 tube 23
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 6 ml 1 lay 2 tube 24
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 6 ml 1 lay 2 tube 25
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 6 ml 1 lay 2 tube 26
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 6 ml 1 lay 2 tube 27
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 6 ml 1 lay 2 tube 28
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 6 ml 1 lay 2 tube 29
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 6 ml 1 lay 2 tube 30
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 6 ml 1 lay 3 tube 17
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 6 ml 1 lay 3 tube 18
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 6 ml 1 lay 3 tube 19
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 6 ml 1 lay 3 tube 20
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 6 ml 1 lay 3 tube 21
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 6 ml 1 lay 3 tube 22
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 6 ml 1 lay 3 tube 23
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 6 ml 1 lay 3 tube 24
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 6 ml 1 lay 3 tube 25
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 6 ml 1 lay 3 tube 26
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 6 ml 1 lay 3 tube 27
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 6 ml 1 lay 3 tube 28
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 6 ml 1 lay 3 tube 29
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 6 ml 1 lay 3 tube 30
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 6 ml 1 lay 4 tube 19
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 6 ml 1 lay 4 tube 20
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 6 ml 1 lay 4 tube 21
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 6 ml 1 lay 4 tube 22
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 6 ml 1 lay 4 tube 23
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 6 ml 1 lay 4 tube 24
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 6 ml 1 lay 4 tube 25
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 6 ml 1 lay 4 tube 26
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 6 ml 1 lay 4 tube 27
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 6 ml 1 lay 4 tube 28
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 6 ml 1 lay 4 tube 29
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 6 ml 1 lay 4 tube 30
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 6 ml 1 lay 4 tube 31
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 6 ml 1 lay 4 tube 32
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 6 ml 2 lay 1 tube 32
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 6 ml 2 lay 1 tube 33
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 6 ml 2 lay 1 tube 34
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 6 ml 2 lay 1 tube 35
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 6 ml 2 lay 1 tube 36
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 6 ml 2 lay 1 tube 37
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 6 ml 2 lay 1 tube 38
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 6 ml 2 lay 1 tube 39
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 6 ml 2 lay 1 tube 40
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 6 ml 2 lay 1 tube 41
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 6 ml 2 lay 1 tube 42
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 6 ml 2 lay 1 tube 43
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 6 ml 2 lay 1 tube 44
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 6 ml 2 lay 1 tube 45
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 6 ml 2 lay 2 tube 34
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 6 ml 2 lay 2 tube 35
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 6 ml 2 lay 2 tube 36
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 6 ml 2 lay 2 tube 37
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 6 ml 2 lay 2 tube 38
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 6 ml 2 lay 2 tube 39
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 6 ml 2 lay 2 tube 40
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 6 ml 2 lay 2 tube 41
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 6 ml 2 lay 2 tube 42
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 6 ml 2 lay 2 tube 43
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 6 ml 2 lay 2 tube 44
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 6 ml 2 lay 2 tube 45
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 6 ml 2 lay 2 tube 46
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 6 ml 2 lay 2 tube 47
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 6 ml 2 lay 3 tube 34
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 6 ml 2 lay 3 tube 35
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 6 ml 2 lay 3 tube 36
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 6 ml 2 lay 3 tube 37
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 6 ml 2 lay 3 tube 38
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 6 ml 2 lay 3 tube 39
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 6 ml 2 lay 3 tube 40
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 6 ml 2 lay 3 tube 41
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 6 ml 2 lay 3 tube 42
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 6 ml 2 lay 3 tube 43
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 6 ml 2 lay 3 tube 44
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 6 ml 2 lay 3 tube 45
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 6 ml 2 lay 3 tube 46
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 6 ml 2 lay 3 tube 47
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 6 ml 2 lay 4 tube 36
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 6 ml 2 lay 4 tube 37
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 6 ml 2 lay 4 tube 38
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 6 ml 2 lay 4 tube 39
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 6 ml 2 lay 4 tube 40
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 6 ml 2 lay 4 tube 41
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 6 ml 2 lay 4 tube 42
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 6 ml 2 lay 4 tube 43
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 6 ml 2 lay 4 tube 44
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 6 ml 2 lay 4 tube 45
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 6 ml 2 lay 4 tube 46
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 6 ml 2 lay 4 tube 47
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 6 ml 2 lay 4 tube 48
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 6 ml 2 lay 4 tube 49
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -1 phi 7 ml 1 lay 1 tube 24
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -1 phi 7 ml 1 lay 1 tube 25
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -1 phi 7 ml 1 lay 1 tube 26
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -1 phi 7 ml 1 lay 1 tube 27
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -1 phi 7 ml 1 lay 1 tube 28
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -1 phi 7 ml 1 lay 1 tube 29
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -1 phi 7 ml 1 lay 1 tube 30
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -1 phi 7 ml 1 lay 2 tube 25
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -1 phi 7 ml 1 lay 2 tube 26
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -1 phi 7 ml 1 lay 2 tube 27
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -1 phi 7 ml 1 lay 2 tube 28
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -1 phi 7 ml 1 lay 2 tube 29
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -1 phi 7 ml 1 lay 2 tube 30
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -1 phi 7 ml 1 lay 2 tube 31
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -1 phi 7 ml 1 lay 3 tube 25
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -1 phi 7 ml 1 lay 3 tube 26
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -1 phi 7 ml 1 lay 3 tube 27
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -1 phi 7 ml 1 lay 3 tube 28
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -1 phi 7 ml 1 lay 3 tube 29
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -1 phi 7 ml 1 lay 3 tube 30
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -1 phi 7 ml 1 lay 3 tube 31
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -1 phi 7 ml 1 lay 4 tube 26
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -1 phi 7 ml 1 lay 4 tube 27
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -1 phi 7 ml 1 lay 4 tube 28
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -1 phi 7 ml 1 lay 4 tube 29
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -1 phi 7 ml 1 lay 4 tube 30
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -1 phi 7 ml 1 lay 4 tube 31
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -1 phi 7 ml 1 lay 4 tube 32
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -1 phi 7 ml 2 lay 1 tube 30
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -1 phi 7 ml 2 lay 1 tube 31
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -1 phi 7 ml 2 lay 1 tube 32
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -1 phi 7 ml 2 lay 1 tube 33
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -1 phi 7 ml 2 lay 1 tube 34
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -1 phi 7 ml 2 lay 1 tube 35
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -1 phi 7 ml 2 lay 1 tube 36
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -1 phi 7 ml 2 lay 2 tube 31
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -1 phi 7 ml 2 lay 2 tube 32
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -1 phi 7 ml 2 lay 2 tube 33
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -1 phi 7 ml 2 lay 2 tube 34
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -1 phi 7 ml 2 lay 2 tube 35
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -1 phi 7 ml 2 lay 2 tube 36
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -1 phi 7 ml 2 lay 2 tube 37
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -1 phi 7 ml 2 lay 3 tube 31
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -1 phi 7 ml 2 lay 3 tube 32
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -1 phi 7 ml 2 lay 3 tube 33
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -1 phi 7 ml 2 lay 3 tube 34
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -1 phi 7 ml 2 lay 3 tube 35
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -1 phi 7 ml 2 lay 3 tube 36
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -1 phi 7 ml 2 lay 3 tube 37
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -1 phi 7 ml 2 lay 4 tube 32
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -1 phi 7 ml 2 lay 4 tube 33
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -1 phi 7 ml 2 lay 4 tube 34
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -1 phi 7 ml 2 lay 4 tube 35
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -1 phi 7 ml 2 lay 4 tube 36
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -1 phi 7 ml 2 lay 4 tube 37
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -1 phi 7 ml 2 lay 4 tube 38
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 1 phi 7 ml 1 lay 1 tube 25
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 1 phi 7 ml 1 lay 1 tube 26
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 1 phi 7 ml 1 lay 1 tube 27
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 1 phi 7 ml 1 lay 1 tube 28
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 1 phi 7 ml 1 lay 1 tube 29
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 1 phi 7 ml 1 lay 1 tube 30
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 1 phi 7 ml 1 lay 2 tube 24
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 1 phi 7 ml 1 lay 2 tube 25
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 1 phi 7 ml 1 lay 2 tube 26
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 1 phi 7 ml 1 lay 2 tube 27
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 1 phi 7 ml 1 lay 2 tube 28
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 1 phi 7 ml 1 lay 2 tube 29
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 1 phi 7 ml 1 lay 2 tube 30
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 1 phi 7 ml 1 lay 3 tube 25
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 1 phi 7 ml 1 lay 3 tube 26
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 1 phi 7 ml 1 lay 3 tube 27
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 1 phi 7 ml 1 lay 3 tube 28
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 1 phi 7 ml 1 lay 3 tube 29
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 1 phi 7 ml 1 lay 3 tube 30
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 1 phi 7 ml 1 lay 3 tube 31
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 1 phi 7 ml 1 lay 4 tube 25
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 1 phi 7 ml 1 lay 4 tube 26
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 1 phi 7 ml 1 lay 4 tube 27
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 1 phi 7 ml 1 lay 4 tube 28
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 1 phi 7 ml 1 lay 4 tube 29
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 1 phi 7 ml 1 lay 4 tube 30
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 1 phi 7 ml 1 lay 4 tube 31
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 1 phi 7 ml 2 lay 1 tube 31
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 1 phi 7 ml 2 lay 1 tube 32
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 1 phi 7 ml 2 lay 1 tube 33
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 1 phi 7 ml 2 lay 1 tube 34
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 1 phi 7 ml 2 lay 1 tube 35
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 1 phi 7 ml 2 lay 1 tube 36
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 1 phi 7 ml 2 lay 1 tube 37
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 1 phi 7 ml 2 lay 2 tube 30
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 1 phi 7 ml 2 lay 2 tube 31
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 1 phi 7 ml 2 lay 2 tube 32
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 1 phi 7 ml 2 lay 2 tube 33
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 1 phi 7 ml 2 lay 2 tube 34
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 1 phi 7 ml 2 lay 2 tube 35
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 1 phi 7 ml 2 lay 2 tube 36
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 1 phi 7 ml 2 lay 2 tube 37
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 1 phi 7 ml 2 lay 3 tube 32
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 1 phi 7 ml 2 lay 3 tube 33
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 1 phi 7 ml 2 lay 3 tube 34
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 1 phi 7 ml 2 lay 3 tube 35
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 1 phi 7 ml 2 lay 3 tube 36
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 1 phi 7 ml 2 lay 3 tube 37
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 1 phi 7 ml 2 lay 3 tube 38
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 1 phi 7 ml 2 lay 4 tube 32
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 1 phi 7 ml 2 lay 4 tube 33
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 1 phi 7 ml 2 lay 4 tube 34
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 1 phi 7 ml 2 lay 4 tube 35
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 1 phi 7 ml 2 lay 4 tube 36
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 1 phi 7 ml 2 lay 4 tube 37
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 7 ml 1 lay 1 tube 14
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 7 ml 1 lay 1 tube 15
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 7 ml 1 lay 1 tube 16
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 7 ml 1 lay 1 tube 17
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 7 ml 1 lay 1 tube 18
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 7 ml 1 lay 1 tube 19
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 7 ml 1 lay 1 tube 20
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 7 ml 1 lay 1 tube 21
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 7 ml 1 lay 2 tube 15
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 7 ml 1 lay 2 tube 16
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 7 ml 1 lay 2 tube 17
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 7 ml 1 lay 2 tube 18
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 7 ml 1 lay 2 tube 19
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 7 ml 1 lay 2 tube 20
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 7 ml 1 lay 2 tube 21
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 7 ml 1 lay 2 tube 22
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 7 ml 1 lay 3 tube 15
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 7 ml 1 lay 3 tube 16
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 7 ml 1 lay 3 tube 17
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 7 ml 1 lay 3 tube 18
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 7 ml 1 lay 3 tube 19
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 7 ml 1 lay 3 tube 20
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 7 ml 1 lay 3 tube 21
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 7 ml 1 lay 3 tube 22
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 7 ml 1 lay 4 tube 16
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 7 ml 1 lay 4 tube 17
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 7 ml 1 lay 4 tube 18
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 7 ml 1 lay 4 tube 19
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 7 ml 1 lay 4 tube 20
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 7 ml 1 lay 4 tube 21
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 7 ml 1 lay 4 tube 22
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 7 ml 1 lay 4 tube 23
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 7 ml 2 lay 1 tube 26
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 7 ml 2 lay 1 tube 27
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 7 ml 2 lay 1 tube 28
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 7 ml 2 lay 1 tube 29
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 7 ml 2 lay 1 tube 30
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 7 ml 2 lay 1 tube 31
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 7 ml 2 lay 1 tube 32
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 7 ml 2 lay 1 tube 33
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 7 ml 2 lay 2 tube 27
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 7 ml 2 lay 2 tube 28
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 7 ml 2 lay 2 tube 29
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 7 ml 2 lay 2 tube 30
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 7 ml 2 lay 2 tube 31
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 7 ml 2 lay 2 tube 32
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 7 ml 2 lay 2 tube 33
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 7 ml 2 lay 2 tube 34
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 7 ml 2 lay 3 tube 27
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 7 ml 2 lay 3 tube 28
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 7 ml 2 lay 3 tube 29
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 7 ml 2 lay 3 tube 30
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 7 ml 2 lay 3 tube 31
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 7 ml 2 lay 3 tube 32
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 7 ml 2 lay 3 tube 33
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 7 ml 2 lay 3 tube 34
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 7 ml 2 lay 4 tube 28
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 7 ml 2 lay 4 tube 29
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 7 ml 2 lay 4 tube 30
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 7 ml 2 lay 4 tube 31
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 7 ml 2 lay 4 tube 32
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 7 ml 2 lay 4 tube 33
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 7 ml 2 lay 4 tube 34
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -2 phi 7 ml 2 lay 4 tube 35
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 7 ml 1 lay 1 tube 14
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 7 ml 1 lay 1 tube 15
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 7 ml 1 lay 1 tube 16
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 7 ml 1 lay 1 tube 17
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 7 ml 1 lay 1 tube 18
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 7 ml 1 lay 1 tube 19
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 7 ml 1 lay 1 tube 20
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 7 ml 1 lay 1 tube 21
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 7 ml 1 lay 2 tube 14
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 7 ml 1 lay 2 tube 15
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 7 ml 1 lay 2 tube 16
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 7 ml 1 lay 2 tube 17
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 7 ml 1 lay 2 tube 18
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 7 ml 1 lay 2 tube 19
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 7 ml 1 lay 2 tube 20
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 7 ml 1 lay 2 tube 21
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 7 ml 1 lay 3 tube 15
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 7 ml 1 lay 3 tube 16
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 7 ml 1 lay 3 tube 17
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 7 ml 1 lay 3 tube 18
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 7 ml 1 lay 3 tube 19
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 7 ml 1 lay 3 tube 20
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 7 ml 1 lay 3 tube 21
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 7 ml 1 lay 3 tube 22
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 7 ml 1 lay 3 tube 23
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 7 ml 1 lay 4 tube 16
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 7 ml 1 lay 4 tube 17
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 7 ml 1 lay 4 tube 18
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 7 ml 1 lay 4 tube 19
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 7 ml 1 lay 4 tube 20
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 7 ml 1 lay 4 tube 21
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 7 ml 1 lay 4 tube 22
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 7 ml 1 lay 4 tube 23
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 7 ml 2 lay 1 tube 26
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 7 ml 2 lay 1 tube 27
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 7 ml 2 lay 1 tube 28
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 7 ml 2 lay 1 tube 29
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 7 ml 2 lay 1 tube 30
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 7 ml 2 lay 1 tube 31
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 7 ml 2 lay 1 tube 32
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 7 ml 2 lay 1 tube 33
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 7 ml 2 lay 2 tube 26
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 7 ml 2 lay 2 tube 27
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 7 ml 2 lay 2 tube 28
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 7 ml 2 lay 2 tube 29
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 7 ml 2 lay 2 tube 30
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 7 ml 2 lay 2 tube 31
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 7 ml 2 lay 2 tube 32
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 7 ml 2 lay 2 tube 33
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 7 ml 2 lay 3 tube 28
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 7 ml 2 lay 3 tube 29
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 7 ml 2 lay 3 tube 30
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 7 ml 2 lay 3 tube 31
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 7 ml 2 lay 3 tube 32
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 7 ml 2 lay 3 tube 33
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 7 ml 2 lay 3 tube 34
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 7 ml 2 lay 3 tube 35
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 7 ml 2 lay 4 tube 28
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 7 ml 2 lay 4 tube 29
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 7 ml 2 lay 4 tube 30
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 7 ml 2 lay 4 tube 31
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 7 ml 2 lay 4 tube 32
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 7 ml 2 lay 4 tube 33
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 7 ml 2 lay 4 tube 34
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 2 phi 7 ml 2 lay 4 tube 35
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 7 ml 1 lay 1 tube 19
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 7 ml 1 lay 1 tube 20
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 7 ml 1 lay 1 tube 21
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 7 ml 1 lay 1 tube 22
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 7 ml 1 lay 1 tube 23
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 7 ml 1 lay 1 tube 24
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 7 ml 1 lay 1 tube 25
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 7 ml 1 lay 1 tube 26
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 7 ml 1 lay 1 tube 27
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 7 ml 1 lay 1 tube 28
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 7 ml 1 lay 2 tube 21
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 7 ml 1 lay 2 tube 22
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 7 ml 1 lay 2 tube 23
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 7 ml 1 lay 2 tube 24
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 7 ml 1 lay 2 tube 25
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 7 ml 1 lay 2 tube 26
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 7 ml 1 lay 2 tube 27
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 7 ml 1 lay 2 tube 28
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 7 ml 1 lay 2 tube 29
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 7 ml 1 lay 2 tube 30
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 7 ml 1 lay 3 tube 21
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 7 ml 1 lay 3 tube 22
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 7 ml 1 lay 3 tube 23
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 7 ml 1 lay 3 tube 24
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 7 ml 1 lay 3 tube 25
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 7 ml 1 lay 3 tube 26
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 7 ml 1 lay 3 tube 27
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 7 ml 1 lay 3 tube 28
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 7 ml 1 lay 3 tube 29
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 7 ml 1 lay 3 tube 30
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 7 ml 1 lay 4 tube 23
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 7 ml 1 lay 4 tube 24
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 7 ml 1 lay 4 tube 25
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 7 ml 1 lay 4 tube 26
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 7 ml 1 lay 4 tube 27
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 7 ml 1 lay 4 tube 28
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 7 ml 1 lay 4 tube 29
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 7 ml 1 lay 4 tube 30
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 7 ml 1 lay 4 tube 31
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 7 ml 1 lay 4 tube 32
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 7 ml 2 lay 1 tube 37
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 7 ml 2 lay 1 tube 38
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 7 ml 2 lay 1 tube 39
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 7 ml 2 lay 1 tube 40
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 7 ml 2 lay 1 tube 41
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 7 ml 2 lay 1 tube 42
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 7 ml 2 lay 1 tube 43
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 7 ml 2 lay 1 tube 44
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 7 ml 2 lay 1 tube 45
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 7 ml 2 lay 2 tube 38
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 7 ml 2 lay 2 tube 39
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 7 ml 2 lay 2 tube 40
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 7 ml 2 lay 2 tube 41
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 7 ml 2 lay 2 tube 42
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 7 ml 2 lay 2 tube 43
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 7 ml 2 lay 2 tube 44
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 7 ml 2 lay 2 tube 45
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 7 ml 2 lay 2 tube 46
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 7 ml 2 lay 2 tube 47
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 7 ml 2 lay 3 tube 39
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 7 ml 2 lay 3 tube 40
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 7 ml 2 lay 3 tube 41
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 7 ml 2 lay 3 tube 42
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 7 ml 2 lay 3 tube 43
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 7 ml 2 lay 3 tube 44
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 7 ml 2 lay 3 tube 45
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 7 ml 2 lay 3 tube 46
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 7 ml 2 lay 3 tube 47
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 7 ml 2 lay 4 tube 40
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 7 ml 2 lay 4 tube 41
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 7 ml 2 lay 4 tube 42
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 7 ml 2 lay 4 tube 43
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 7 ml 2 lay 4 tube 44
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 7 ml 2 lay 4 tube 45
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 7 ml 2 lay 4 tube 46
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 7 ml 2 lay 4 tube 47
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 7 ml 2 lay 4 tube 48
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta -3 phi 7 ml 2 lay 4 tube 49
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 7 ml 1 lay 1 tube 20
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 7 ml 1 lay 1 tube 21
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 7 ml 1 lay 1 tube 22
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 7 ml 1 lay 1 tube 23
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 7 ml 1 lay 1 tube 24
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 7 ml 1 lay 1 tube 25
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 7 ml 1 lay 1 tube 26
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 7 ml 1 lay 1 tube 27
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 7 ml 1 lay 1 tube 28
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 7 ml 1 lay 2 tube 20
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 7 ml 1 lay 2 tube 21
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 7 ml 1 lay 2 tube 22
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 7 ml 1 lay 2 tube 23
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 7 ml 1 lay 2 tube 24
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 7 ml 1 lay 2 tube 25
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 7 ml 1 lay 2 tube 26
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 7 ml 1 lay 2 tube 27
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 7 ml 1 lay 2 tube 28
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 7 ml 1 lay 2 tube 29
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 7 ml 1 lay 3 tube 22
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 7 ml 1 lay 3 tube 23
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 7 ml 1 lay 3 tube 24
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 7 ml 1 lay 3 tube 25
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 7 ml 1 lay 3 tube 26
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 7 ml 1 lay 3 tube 27
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 7 ml 1 lay 3 tube 28
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 7 ml 1 lay 3 tube 29
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 7 ml 1 lay 3 tube 30
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 7 ml 1 lay 4 tube 22
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 7 ml 1 lay 4 tube 23
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 7 ml 1 lay 4 tube 24
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 7 ml 1 lay 4 tube 25
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 7 ml 1 lay 4 tube 26
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 7 ml 1 lay 4 tube 27
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 7 ml 1 lay 4 tube 28
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 7 ml 1 lay 4 tube 29
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 7 ml 1 lay 4 tube 30
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 7 ml 1 lay 4 tube 31
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 7 ml 2 lay 1 tube 37
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 7 ml 2 lay 1 tube 38
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 7 ml 2 lay 1 tube 39
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 7 ml 2 lay 1 tube 40
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 7 ml 2 lay 1 tube 41
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 7 ml 2 lay 1 tube 42
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 7 ml 2 lay 1 tube 43
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 7 ml 2 lay 1 tube 44
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 7 ml 2 lay 1 tube 45
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 7 ml 2 lay 1 tube 46
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 7 ml 2 lay 2 tube 38
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 7 ml 2 lay 2 tube 39
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 7 ml 2 lay 2 tube 40
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 7 ml 2 lay 2 tube 41
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 7 ml 2 lay 2 tube 42
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 7 ml 2 lay 2 tube 43
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 7 ml 2 lay 2 tube 44
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 7 ml 2 lay 2 tube 45
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 7 ml 2 lay 2 tube 46
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 7 ml 2 lay 3 tube 39
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 7 ml 2 lay 3 tube 40
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 7 ml 2 lay 3 tube 41
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 7 ml 2 lay 3 tube 42
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 7 ml 2 lay 3 tube 43
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 7 ml 2 lay 3 tube 44
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 7 ml 2 lay 3 tube 45
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 7 ml 2 lay 3 tube 46
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 7 ml 2 lay 3 tube 47
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 7 ml 2 lay 3 tube 48
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 7 ml 2 lay 4 tube 40
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 7 ml 2 lay 4 tube 41
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 7 ml 2 lay 4 tube 42
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 7 ml 2 lay 4 tube 43
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 7 ml 2 lay 4 tube 44
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 7 ml 2 lay 4 tube 45
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 7 ml 2 lay 4 tube 46
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 7 ml 2 lay 4 tube 47
+ToolSvc.Muon__MdtRdoToPrepDataTool VERBOSE adding dead tube MDT BMG eta 3 phi 7 ml 2 lay 4 tube 48
diff --git a/MuonSpectrometer/MuonDigitization/MDT_Digitization/MDT_Digitization/MdtDigitizationTool.h b/MuonSpectrometer/MuonDigitization/MDT_Digitization/MDT_Digitization/MdtDigitizationTool.h
index a9c97bf0df6..b5de2e2428f 100644
--- a/MuonSpectrometer/MuonDigitization/MDT_Digitization/MDT_Digitization/MdtDigitizationTool.h
+++ b/MuonSpectrometer/MuonDigitization/MDT_Digitization/MDT_Digitization/MdtDigitizationTool.h
@@ -49,14 +49,13 @@
#include "MDT_Digitization/IMDT_DigitizationTool.h"
#include "MDT_Digitization/MDT_SortedHitVector.h"
#include "MDT_Response/MDT_Response.h"
-#include "MdtCalibSvc/MdtCalibrationDbTool.h"
#include "MuonCondData/MdtCondDbData.h"
#include "MuonIdHelpers/IMuonIdHelperSvc.h"
#include "MuonSimEvent/MDTSimHit.h"
+#include "MdtCalibData/MdtCalibDataContainer.h"
#include "MuonSimEvent/MDTSimHitCollection.h"
#include "PileUpTools/PileUpMergeSvc.h"
#include "PileUpTools/PileUpToolBase.h"
-#include "xAODEventInfo/EventAuxInfo.h" // NEW EDM
#include "xAODEventInfo/EventInfo.h" // NEW EDM
// Outputs
@@ -134,7 +133,7 @@ private:
bool handleMDTSimhit(const EventContext& ctx, const TimedHitPtr<MDTSimHit>& phit, CLHEP::HepRandomEngine* twinRndmEngine,
CLHEP::HepRandomEngine* toolRndmEngine);
- bool createDigits(Collections_t& collections, MuonSimDataCollection* sdoContainer, CLHEP::HepRandomEngine* rndmEngine);
+ bool createDigits(const EventContext& ctx, Collections_t& collections, MuonSimDataCollection* sdoContainer, CLHEP::HepRandomEngine* rndmEngine);
// calculate local hit position in local sagged wire frame, also returns whether the hit passed above or below the wire
GeoCorOut correctGeometricalWireSag(const MDTSimHit& hit, const Identifier& id, const MuonGM::MdtReadoutElement* element) const;
@@ -223,7 +222,9 @@ protected:
ServiceHandle<IAthRNGSvc> m_rndmSvc{this, "RndmSvc", "AthRNGSvc", ""}; // Random number service
- ToolHandle<MdtCalibrationDbTool> m_calibrationDbTool{this, "CalibrationDbTool", "MdtCalibrationDbTool", ""};
+ SG::ReadCondHandleKey<MuonCalib::MdtCalibDataContainer> m_calibDbKey{this, "CalibDataKey", "MdtCalibConstants",
+ "Conditions object containing the calibrations"};
+
SG::ReadCondHandleKey<MdtCondDbData> m_readKey{this, "ReadKey", "MdtCondDbData", "Key of MdtCondDbData"};
};
diff --git a/MuonSpectrometer/MuonDigitization/MDT_Digitization/MDT_Digitization/RT_Relation_DB_DigiTool.h b/MuonSpectrometer/MuonDigitization/MDT_Digitization/MDT_Digitization/RT_Relation_DB_DigiTool.h
index 36bd46cc33f..bd29cd45fe9 100644
--- a/MuonSpectrometer/MuonDigitization/MDT_Digitization/MDT_Digitization/RT_Relation_DB_DigiTool.h
+++ b/MuonSpectrometer/MuonDigitization/MDT_Digitization/MDT_Digitization/RT_Relation_DB_DigiTool.h
@@ -22,7 +22,7 @@ Adopted from RT_Relation_DigiTool
#include "MdtCalibData/MdtFullCalibData.h"
#include "MdtCalibData/MdtRtRelation.h"
#include "MdtCalibData/TrRelation.h"
-#include "MdtCalibSvc/MdtCalibrationDbTool.h"
+#include "MdtCalibData/MdtCalibDataContainer.h"
namespace MuonGM {
class MuonDetectorManager;
@@ -46,7 +46,8 @@ private:
// Data members
double m_maxRadius{0.};
- ToolHandle<MdtCalibrationDbTool> m_calibrationDbTool{this, "CalibrationDbTool", "MdtCalibrationDbTool"};
+ SG::ReadCondHandleKey<MuonCalib::MdtCalibDataContainer> m_calibDbKey{this, "CalibDataKey", "MdtCalibConstants",
+ "Conditions object containing the calibrations"};
Gaudi::Property<double> m_effRadius{this, "EffectiveRadius", 14.4275};
};
diff --git a/MuonSpectrometer/MuonDigitization/MDT_Digitization/python/MdtDigitizationConfigLegacy.py b/MuonSpectrometer/MuonDigitization/MDT_Digitization/python/MdtDigitizationConfigLegacy.py
index d027068ade3..7d3ec695c7a 100644
--- a/MuonSpectrometer/MuonDigitization/MDT_Digitization/python/MdtDigitizationConfigLegacy.py
+++ b/MuonSpectrometer/MuonDigitization/MDT_Digitization/python/MdtDigitizationConfigLegacy.py
@@ -21,7 +21,7 @@ def MDT_LastXing():
def MdtDigitizationTool(name="MdtDigitizationTool",**kwargs):
import MuonCondAlg.MdtCondDbAlgConfig # noqa: F401 MT-safe conditions access
from MuonCnvExample import MuonCalibConfig
- MuonCalibConfig.setupMdtCondDB() # add MdtCalibDbAlg for MdtCalibrationDbTool
+ MuonCalibConfig.setupMdtCondDB() # add MdtCalibDbAlg
kwargs.setdefault("DiscardEarlyHits", True)
@@ -56,13 +56,8 @@ def MdtDigitizationTool(name="MdtDigitizationTool",**kwargs):
else:
kwargs.setdefault("OutputSDOName", "MDT_SDO")
- kwargs.setdefault("CalibrationDbTool", MuonCalibConfig.MdtCalibrationDbTool())
return CfgMgr.MdtDigitizationTool(name,**kwargs)
- #return CfgMgr.MDT_PileUpTool(name,**kwargs)
- #else:
- # return CfgMgr.MdtDigitizationTool(name,**kwargs)
-
def getMdtRange(name="MdtRange", **kwargs):
# bunch crossing range in ns
diff --git a/MuonSpectrometer/MuonDigitization/MDT_Digitization/src/MdtDigitizationTool.cxx b/MuonSpectrometer/MuonDigitization/MDT_Digitization/src/MdtDigitizationTool.cxx
index ab6bc81f707..83645b30548 100644
--- a/MuonSpectrometer/MuonDigitization/MDT_Digitization/src/MdtDigitizationTool.cxx
+++ b/MuonSpectrometer/MuonDigitization/MDT_Digitization/src/MdtDigitizationTool.cxx
@@ -69,7 +69,6 @@ StatusCode MdtDigitizationTool::initialize() {
ATH_MSG_INFO("Configuration MdtDigitizationTool");
ATH_MSG_INFO("RndmSvc " << m_rndmSvc);
ATH_MSG_INFO("DigitizationTool " << m_digiTool);
- ATH_MSG_INFO("MdtCalibrationDbTool " << m_calibrationDbTool);
ATH_MSG_INFO("OffsetTDC " << m_offsetTDC);
ATH_MSG_INFO("ns2TDCAMT " << m_ns2TDCAMT);
ATH_MSG_INFO("ns2TDCHPTDC " << m_ns2TDCHPTDC);
@@ -122,7 +121,8 @@ StatusCode MdtDigitizationTool::initialize() {
ATH_MSG_DEBUG("Input objects in container : '" << m_inputObjectName << "'");
// Initialize ReadHandleKey
- ATH_CHECK(m_hitsContainerKey.initialize(true));
+ ATH_CHECK(m_hitsContainerKey.initialize());
+ ATH_CHECK(m_calibDbKey.initialize());
// initialize the output WriteHandleKeys
ATH_CHECK(m_outputObjectKey.initialize());
@@ -139,9 +139,6 @@ StatusCode MdtDigitizationTool::initialize() {
ATH_MSG_DEBUG("Retrieved digitization tool!" << m_digiTool);
ATH_CHECK(m_rndmSvc.retrieve());
-
- ATH_CHECK(m_calibrationDbTool.retrieve());
-
ATH_CHECK(m_readKey.initialize(!m_readKey.empty()));
return StatusCode::SUCCESS;
}
@@ -341,7 +338,7 @@ StatusCode MdtDigitizationTool::doDigitization(const EventContext& ctx, Collecti
}
// loop over drift time map entries, convert to tdc value and construct/store the digit
- createDigits(collections, sdoContainer, rndmEngine);
+ createDigits(ctx, collections, sdoContainer, rndmEngine);
// reset hits
m_hits.clear();
@@ -660,7 +657,8 @@ bool MdtDigitizationTool::checkMDTSimHit(const EventContext& ctx, const MDTSimHi
return ok;
}
-bool MdtDigitizationTool::createDigits(Collections_t& collections, MuonSimDataCollection* sdoContainer,
+bool MdtDigitizationTool::createDigits(const EventContext& ctx, Collections_t& collections,
+ MuonSimDataCollection* sdoContainer,
CLHEP::HepRandomEngine* rndmEngine) {
Identifier currentDigitId{0}, currentElementId{0};
@@ -686,6 +684,11 @@ bool MdtDigitizationTool::createDigits(Collections_t& collections, MuonSimDataCo
}
//-ForCosmics
+ SG::ReadCondHandle<MuonCalib::MdtCalibDataContainer> mdtCalibConstants{m_calibDbKey, ctx};
+ if (!mdtCalibConstants.isValid()) {
+ ATH_MSG_FATAL("Failed to retrieve set of calibration constants "<<mdtCalibConstants.fullKey());
+ return false;
+ }
for (; it != m_hits.end(); ++it) {
Identifier idDigit = it->id;
Identifier elementId = m_idHelperSvc->mdtIdHelper().elementID(idDigit);
@@ -749,19 +752,14 @@ bool MdtDigitizationTool::createDigits(Collections_t& collections, MuonSimDataCo
if (insideMatch || insideMask) {
// get calibration constants from DbTool
double t0 = m_offsetTDC;
- const MuonCalib::MdtFullCalibData data = m_calibrationDbTool->getCalibration(geo->identifyHash(), geo->detectorElementHash());
- if (data.tubeCalib) {
- int ml = m_idHelperSvc->mdtIdHelper().multilayer(idDigit) - 1;
- int layer = m_idHelperSvc->mdtIdHelper().tubeLayer(idDigit) - 1;
- int tube = m_idHelperSvc->mdtIdHelper().tube(idDigit) - 1;
- if (ml >= 0 && layer >= 0 && tube >= 0) {
- // extract calibration constants for single tube
- const MuonCalib::MdtTubeCalibContainer::SingleTubeCalib* singleTubeData = data.tubeCalib->getCalib(ml, layer, tube);
- if (singleTubeData) {
- ATH_MSG_DEBUG("Extracted the following calibration constant for "<<m_idHelperSvc->toString(idDigit)<<" "<<singleTubeData->t0);
- t0 = singleTubeData->t0 + m_t0ShiftTuning;
- } else ATH_MSG_WARNING("No calibration data found, using t0=" << m_offsetTDC<<" "<<m_idHelperSvc->toString(idDigit));
- }
+ const MuonCalib::MdtFullCalibData* data{mdtCalibConstants->getCalibData(idDigit, msgStream())};
+ if (data && data->tubeCalib) {
+ // extract calibration constants for single tube
+ const MuonCalib::MdtTubeCalibContainer::SingleTubeCalib* singleTubeData = data->tubeCalib->getCalib(idDigit);
+ if (singleTubeData) {
+ ATH_MSG_DEBUG("Extracted the following calibration constant for "<<m_idHelperSvc->toString(idDigit)<<" "<<singleTubeData->t0);
+ t0 = singleTubeData->t0 + m_t0ShiftTuning;
+ } else ATH_MSG_WARNING("No calibration data found, using t0=" << m_offsetTDC<<" "<<m_idHelperSvc->toString(idDigit));
} else {
ATH_MSG_WARNING("No calibration data found, using t0=" << m_offsetTDC<<" for "<<m_idHelperSvc->toString(idDigit));
}
diff --git a/MuonSpectrometer/MuonDigitization/MDT_Digitization/src/RT_Relation_DB_DigiTool.cxx b/MuonSpectrometer/MuonDigitization/MDT_Digitization/src/RT_Relation_DB_DigiTool.cxx
index ad91f1a6bf2..2726c0ef568 100644
--- a/MuonSpectrometer/MuonDigitization/MDT_Digitization/src/RT_Relation_DB_DigiTool.cxx
+++ b/MuonSpectrometer/MuonDigitization/MDT_Digitization/src/RT_Relation_DB_DigiTool.cxx
@@ -22,7 +22,7 @@ StatusCode RT_Relation_DB_DigiTool::initialize() {
const MuonGM::MuonDetectorManager* detMgr{nullptr};
ATH_CHECK(detStore()->retrieve(detMgr));
m_maxRadius = detMgr->getGenericMdtDescriptor()->innerRadius;
-
+ ATH_CHECK(m_calibDbKey.initialize());
return StatusCode::SUCCESS;
}
@@ -42,20 +42,27 @@ MdtDigiToolOutput RT_Relation_DB_DigiTool::digitize(const MdtDigiToolInput &inpu
double RT_Relation_DB_DigiTool::getDriftTime(double r, Identifier DigitId, CLHEP::HepRandomEngine *rndmEngine) const {
// Get RT relation from DB
- const MuonCalib::MdtRtRelation *data = m_calibrationDbTool->getRtCalibration(DigitId);
+ SG::ReadCondHandle<MuonCalib::MdtCalibDataContainer> calibConstants{m_calibDbKey};
+
+ if (!calibConstants.isValid()) {
+ ATH_MSG_FATAL("Failed to retrieve calib constants "<<m_calibDbKey.fullKey());
+ throw std::runtime_error("No Mdt calibration constants");
+ }
+ using RtRelationPtr = MuonCalib::MdtCalibDataContainer::RtRelationPtr;
+ const RtRelationPtr& data{calibConstants->getCalibData(DigitId, msgStream())->rtRelation};
double time = 0.0;
double t = 0.0;
bool outOfBound = false;
- if (data != nullptr) {
+ if (data) {
// get RT relation and resolution function
const MuonCalib::IRtRelation *rtRelation = data->rt();
const MuonCalib::IRtResolution *rtResolution = data->rtRes();
// get inverse rt and calculate time resolution
const MuonCalib::TrRelation *trRelation = data->tr();
- time = trRelation->tFromR(fabs(r), outOfBound);
+ time = trRelation->tFromR(std::abs(r), outOfBound);
if (time < 0.0) {
time = 0.0;
@@ -88,8 +95,8 @@ double RT_Relation_DB_DigiTool::getDriftTime(double r, Identifier DigitId, CLHEP
trRelation->tFromR(m_maxRadius, outOfBound2); // tmax = tUp+tLow; //means: tmax = (tmax of rt relation) + (one binwidth )
double gaussian;
- const double sqrt_one_over_two_pi = 0.39894228;
- double p1r = 0.8480 * exp(-0.5879 * r);
+ constexpr double sqrt_one_over_two_pi = 0.39894228;
+ double p1r = 0.8480 * std::exp(-0.5879 * r);
int flag = 0;
int cutoff = 0;
@@ -114,23 +121,23 @@ double RT_Relation_DB_DigiTool::getDriftTime(double r, Identifier DigitId, CLHEP
double RT_Relation_DB_DigiTool::getAdcResponse(double radius, CLHEP::HepRandomEngine *rndmEngine) const {
// parametrization of the average adc value with respect to radius
- const double p0 = 57.38141;
- const double p1 = 8.616943;
- const double p2 = 2.497827;
- const double p3 = -1.625900;
- const double p4 = 0.3125281;
- const double p5 = -0.02929554;
- const double p6 = 0.001367115;
- const double p7 = -0.00002541936;
+ constexpr double p0 = 57.38141;
+ constexpr double p1 = 8.616943;
+ constexpr double p2 = 2.497827;
+ constexpr double p3 = -1.625900;
+ constexpr double p4 = 0.3125281;
+ constexpr double p5 = -0.02929554;
+ constexpr double p6 = 0.001367115;
+ constexpr double p7 = -0.00002541936;
double adcfunc = p0 + p1 * radius + p2 * std::pow(radius, 2) + p3 * std::pow(radius, 3) + p4 * std::pow(radius, 4) +
p5 * std::pow(radius, 5) + p6 * std::pow(radius, 6) + p7 * std::pow(radius, 7);
// now the resolution function
- const double g0 = 10.27808;
- const double g1 = -0.3774593;
- const double g2 = 0.02751001;
- const double g3 = -0.0005994742;
+ constexpr double g0 = 10.27808;
+ constexpr double g1 = -0.3774593;
+ constexpr double g2 = 0.02751001;
+ constexpr double g3 = -0.0005994742;
double adcWidth = g0 + g1 * radius + g2 * std::pow(radius, 2) + g3 * std::pow(radius, 3);
diff --git a/MuonSpectrometer/MuonReconstruction/MuonRIO_OnTrackCreators/MdtDriftCircleOnTrackCreator/CMakeLists.txt b/MuonSpectrometer/MuonReconstruction/MuonRIO_OnTrackCreators/MdtDriftCircleOnTrackCreator/CMakeLists.txt
index a171f4524a0..59301f4da41 100644
--- a/MuonSpectrometer/MuonReconstruction/MuonRIO_OnTrackCreators/MdtDriftCircleOnTrackCreator/CMakeLists.txt
+++ b/MuonSpectrometer/MuonReconstruction/MuonRIO_OnTrackCreators/MdtDriftCircleOnTrackCreator/CMakeLists.txt
@@ -8,5 +8,8 @@ atlas_subdir( MdtDriftCircleOnTrackCreator )
atlas_add_component( MdtDriftCircleOnTrackCreator
src/*.cxx
src/components/*.cxx
- LINK_LIBRARIES AthenaBaseComps GaudiKernel MuonRIO_OnTrack MuonRecToolInterfaces TrkEventPrimitives TrkSpaceTimePoint Identifier EventPrimitives MdtCalibData MdtCalibSvcLib MuonCalibEvent MuonReadoutGeometry MuonIdHelpersLib MuonPrepRawData TrkDistortedSurfaces TrkSurfaces TrkParameters )
+ LINK_LIBRARIES AthenaBaseComps GaudiKernel MuonRIO_OnTrack MuonRecToolInterfaces
+ TrkEventPrimitives TrkSpaceTimePoint Identifier EventPrimitives
+ MuonReadoutGeometry MdtCalibInterfacesLib TrkParameters MdtCalibData
+ MuonIdHelpersLib MuonPrepRawData TrkDistortedSurfaces TrkSurfaces)
diff --git a/MuonSpectrometer/MuonReconstruction/MuonRIO_OnTrackCreators/MdtDriftCircleOnTrackCreator/doc/packagedoc.h b/MuonSpectrometer/MuonReconstruction/MuonRIO_OnTrackCreators/MdtDriftCircleOnTrackCreator/doc/packagedoc.h
index 119daa43eca..b9bdcb286cb 100644
--- a/MuonSpectrometer/MuonReconstruction/MuonRIO_OnTrackCreators/MdtDriftCircleOnTrackCreator/doc/packagedoc.h
+++ b/MuonSpectrometer/MuonReconstruction/MuonRIO_OnTrackCreators/MdtDriftCircleOnTrackCreator/doc/packagedoc.h
@@ -4,15 +4,16 @@
/**
-@page MdtDriftCircleOnTrackCreator_page
+@page MdtDriftCircleOnTrackCreator_page
-@section MdtDriftCircleOnTrackCreator_MdtDriftCircleOnTrackCreatorDocIntro Overview
+@section MdtDriftCircleOnTrackCreator_MdtDriftCircleOnTrackCreatorDocIntro
+Overview
This package provides a tool, Muon::MdtDriftCircleOnTrackCreator, which turns
Muon::MdtPrepData into Muon::MdtDriftCircleOnTrack objects
-using a given trajectory prediction.
+using a given trajectory prediction.
-The tool calls the MDT calibration service (MdtCalibrationSvc). This
+The tool calls the MDT calibration service (MdtCalibrationSvc). This
service provides the same functionality which would usually be foreseen
for this tool, i.e. it computes and corrects the drift radius using the
track prediction and calibrates its error estimate.
@@ -21,7 +22,8 @@ More general information on RIO_OnTrackCreation and instructions
how to use these tools can be found under Trk::RIO_OnTrackCreator.
-@section MdtDriftCircleOnTrackCreator_MdtDriftCircleOnTrackCreatorDocMgr Package Managers
-The Muon::MdtDriftCircleOnTrackCreator package is currently maintained by Niels van Eldik
+@section MdtDriftCircleOnTrackCreator_MdtDriftCircleOnTrackCreatorDocMgr Package
+Managers The Muon::MdtDriftCircleOnTrackCreator package is currently maintained
+by Niels van Eldik
*/
diff --git a/MuonSpectrometer/MuonReconstruction/MuonRIO_OnTrackCreators/MdtDriftCircleOnTrackCreator/src/MdtDriftCircleOnTrackCreator.cxx b/MuonSpectrometer/MuonReconstruction/MuonRIO_OnTrackCreators/MdtDriftCircleOnTrackCreator/src/MdtDriftCircleOnTrackCreator.cxx
index 94a4d477326..3f041babfaf 100644
--- a/MuonSpectrometer/MuonReconstruction/MuonRIO_OnTrackCreators/MdtDriftCircleOnTrackCreator/src/MdtDriftCircleOnTrackCreator.cxx
+++ b/MuonSpectrometer/MuonReconstruction/MuonRIO_OnTrackCreators/MdtDriftCircleOnTrackCreator/src/MdtDriftCircleOnTrackCreator.cxx
@@ -1,960 +1,847 @@
/*
- Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+ Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
*/
#include "MdtDriftCircleOnTrackCreator.h"
-#include "MdtCalibSvc/MdtCalibrationSvcInput.h"
-#include "MdtCalibData/MdtRtRelation.h"
-#include "MdtCalibData/MdtFullCalibData.h"
+
+#include "EventPrimitives/EventPrimitivesHelpers.h"
#include "MdtCalibData/IRtRelation.h"
#include "MdtCalibData/IRtResolution.h"
+#include "MdtCalibData/MdtFullCalibData.h"
+#include "MdtCalibData/MdtRtRelation.h"
#include "MdtCalibData/TrRelation.h"
-#include "MuonCalibEvent/MdtCalibHit.h"
-#include "MuonReadoutGeometry/MdtReadoutElement.h"
#include "MuonPrepRawData/MdtPrepData.h"
#include "MuonRIO_OnTrack/MdtDriftCircleOnTrack.h"
#include "MuonRIO_OnTrack/MuonDriftCircleErrorStrategy.h"
-#include "EventPrimitives/EventPrimitivesHelpers.h"
+#include "MuonReadoutGeometry/MdtReadoutElement.h"
+#include "TrkDistortedSurfaces/DistortedSurface.h"
#include "TrkParameters/TrackParameters.h"
#include "TrkSurfaces/StraightLineSurface.h"
-#include "TrkDistortedSurfaces/DistortedSurface.h"
+#include <optional>
+
+namespace Muon {
+
+using MdtRotPtr = MdtDriftCircleOnTrackCreator::MdtRotPtr;
+using CalibrationOutput = MdtDriftCircleOnTrackCreator::CalibrationOutput;
-Muon::MdtDriftCircleOnTrackCreator::MdtDriftCircleOnTrackCreator(const std::string& ty,const std::string& na,const IInterface* pa) :
- AthAlgTool(ty,na,pa) {
+MdtDriftCircleOnTrackCreator::MdtDriftCircleOnTrackCreator(const std::string& ty,
+ const std::string& na,
+ const IInterface* pa)
+ : AthAlgTool(ty, na, pa) {
// algtool interface - necessary!
- declareInterface<IMdtDriftCircleOnTrackCreator>(this);
- declareInterface<IRIO_OnTrackCreator>(this);
-
-
- // configuration of the calibration service settings
- declareProperty("TimeWindowLowerBound",m_mdtCalibSvcSettings->windowLowerBound );
- declareProperty("TimeWindowUpperBound",m_mdtCalibSvcSettings->windowUpperBound );
- declareProperty("TimeWindowSetting",m_mdtCalibSvcSettings->windowSetting );
-
- declareProperty("DoTofCorrection",m_mdtCalibSvcSettings->doTof );
- declareProperty("DoPropagationCorrection",m_mdtCalibSvcSettings->doProp );
- declareProperty("DoTemperatureCorrection",m_mdtCalibSvcSettings->doTemp );
- declareProperty("DoMagneticFieldCorrection",m_mdtCalibSvcSettings->doField );
- declareProperty("DoWireSagCorrection",m_mdtCalibSvcSettings->doWireSag );
- declareProperty("DoSlewingCorrection",m_mdtCalibSvcSettings->doSlew );
- declareProperty("DoBackgroundCorrection",m_mdtCalibSvcSettings->doBkg );
-
+ declareInterface<IMdtDriftCircleOnTrackCreator>(this);
+ declareInterface<IRIO_OnTrackCreator>(this);
}
-StatusCode Muon::MdtDriftCircleOnTrackCreator::initialize()
-{
-
- m_mdtCalibSvcSettings->initialize();
-
- 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::WireSagGeomCorrection, m_doWireSag );
- m_errorStrategy.setParameter(MuonDriftCircleErrorStrategy::TofCorrection, m_mdtCalibSvcSettings->doTof );
- m_errorStrategy.setParameter(MuonDriftCircleErrorStrategy::PropCorrection, m_mdtCalibSvcSettings->doProp );
- m_errorStrategy.setParameter(MuonDriftCircleErrorStrategy::TempCorrection, m_mdtCalibSvcSettings->doTemp );
- m_errorStrategy.setParameter(MuonDriftCircleErrorStrategy::MagFieldCorrection, m_mdtCalibSvcSettings->doField );
- m_errorStrategy.setParameter(MuonDriftCircleErrorStrategy::WireSagTimeCorrection, m_mdtCalibSvcSettings->doWireSag );
- m_errorStrategy.setParameter(MuonDriftCircleErrorStrategy::SlewCorrection, m_mdtCalibSvcSettings->doSlew );
- m_errorStrategy.setParameter(MuonDriftCircleErrorStrategy::BackgroundCorrection, m_mdtCalibSvcSettings->doBkg );
- m_errorStrategy.setParameter(MuonDriftCircleErrorStrategy::Segment, m_doSegments );
- m_errorStrategy.setCalibWindow(m_mdtCalibSvcSettings->timeWindowSetting());
-
- 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);
- }
- 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::WireSagGeomCorrection ) ) ss << " WireG";
- 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::WireSagTimeCorrection ) ) ss << " WireT";
- 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 );
-
- ATH_CHECK( m_idHelperSvc.retrieve() );
-
- if( m_timeCorrectionType == COSMICS_TOF ){
- if( !m_errorStrategy.creationParameter(MuonDriftCircleErrorStrategy::TofCorrection) ){
- ATH_MSG_WARNING( "Detected bad default configuration, using Cosmic TOF witout time of flight corrections does not work" );
+StatusCode MdtDriftCircleOnTrackCreator::initialize() {
+ 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::WireSagGeomCorrection, m_doWireSag);
+ 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::WireSagTimeCorrection,
+ calibSettings.isActive(Property::WireSagTimeCorrection));
+ 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;
}
- }
- 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_WARNING( "This tool is too complicated to rely on defaults. Potential configuration issue." );
- }
-
- return StatusCode::SUCCESS;
-}
-
-
-Muon::MdtDriftCircleOnTrack* Muon::MdtDriftCircleOnTrackCreator::createRIO_OnTrack(
- const MdtPrepData& mdtPrd,
- const Amg::Vector3D& GP,
- const Amg::Vector3D* GD,
- float t0Shift,
- const MuonDriftCircleErrorStrategy* strategy,
- const double beta,
- const double tTrack ) const
-{
- const MuonDriftCircleErrorStrategy* myStrategy = !strategy? &m_errorStrategy : strategy;
-
- const Identifier iD = mdtPrd.identify();
-
- // check whether the MdtPrepData is not a masked hit
- if( m_discardMaskedHits && mdtPrd.status() == Muon::MdtStatusMasked ){
- ATH_MSG_VERBOSE( "Unable to calibrate Masked hit, returning zero: channel "
- << m_idHelperSvc->toString(iD) );
- return nullptr;
- }
-
- // ************************
- // MdtDriftCircleOnTrack production
-
- // surface of nominal wire
- const Trk::SaggedLineSurface* nominalSurf=&mdtPrd.detectorElement()->surface(iD);
-
-
-
- // Local position for calculation of postion along the tube, used for wire sag treatment
- std::optional<Amg::Vector2D> tempLocOnWire = nominalSurf->Trk::Surface::globalToLocal(GP,m_globalToLocalTolerance);
- if( !tempLocOnWire ){
- ATH_MSG_WARNING( "globalToLocal failed! " );
- return nullptr;
- }
-
- // if wire sag is taken into account, cast the surface to StraightLineSurface so it can be added to the ROT
- const Trk::StraightLineSurface* saggedSurf = nullptr;
- if (myStrategy->creationParameter(MuonDriftCircleErrorStrategy::WireSagGeomCorrection)) {
- saggedSurf = nominalSurf->correctedSurface(*tempLocOnWire); // sagged surface
- if( !saggedSurf ){
- ATH_MSG_WARNING( "DistortedSurface failed to create sagged surface, using nominal surface " );
- saggedSurf = nominalSurf;
+ 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::WireSagGeomCorrection))
+ ss << " WireG";
+ 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::WireSagTimeCorrection))
+ ss << " WireT";
+ 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;
}
-
- //set large value for tolerance, to make sure that global position including drift radius is taken to the wire.
- std::optional<Amg::Vector2D> tempLocOnSaggedWire = saggedSurf->Trk::Surface::globalToLocal(GP,m_globalToLocalTolerance);
- if( !tempLocOnSaggedWire ){
- ATH_MSG_WARNING( "globalToLocal failed for sagged surface, not applying sagging! " );
- return nullptr;
- }else{
- // replace tempLocOnWire with tempLocOnSaggedWire
- tempLocOnWire = tempLocOnSaggedWire;
+ 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 witout "
+ <<"time of flight corrections does not work");
+ return StatusCode::FAILURE;
+ }
}
- // PK not needed delete tempLocOnSaggedWire;
- }
-
- double positionAlongWire = (*tempLocOnWire)[Trk::locZ];
- // set driftcirclestatus, NODRIFTTIME if creating tube hits else UNDECIDED
- Trk::DriftCircleStatus dcstatus = m_doMdt ? Trk::UNDECIDED : Trk::NODRIFTTIME;
-
- // ************************
- // calculate local position and local error matrix
- MdtCalibrationSvcInput inputData;
- inputData.pointOfClosestApproach = &GP;
- inputData.trackDirection = GD;
- inputData.nominalWireSurface = nominalSurf;
- inputData.wireSurface = saggedSurf;
- CalibrationOutput calibOutput = getLocalMeasurement( mdtPrd, GP, GD,inputData, myStrategy, t0Shift, beta, tTrack);
- // 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_DEBUG("Unable to perform calibration ");
- delete saggedSurf;
- return nullptr;
- }
-
- MdtDriftCircleOnTrack* rot =nullptr;
- // we have to calculate sign, check whether direction is given
- if( m_doMdt && GD!=nullptr ) {
- // calculate sign using surface
-
- const Trk::StraightLineSurface& surf = saggedSurf ? *saggedSurf : *nominalSurf;
- std::optional<Amg::Vector2D> pos = surf.Trk::Surface::globalToLocal( GP, *GD);
-
- // check this might still fail....
- if( !pos ){
- ATH_MSG_WARNING( "Unexpected globalToLocal failure, cannot create MDT ROT " );
- // clean up memory
- delete saggedSurf;
- return nullptr;
+ 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;
}
-
- // calculate sign
- double sign = (*pos)[Trk::driftRadius] < 0 ? -1.0 : 1.0;
- calibOutput.locPars[Trk::driftRadius]*=sign;
- rot = new MdtDriftCircleOnTrack( &mdtPrd,
- calibOutput.locPars,
- calibOutput.locErr,
- calibOutput.driftTime,
- Trk::DECIDED,
- *GD,
- positionAlongWire,
- *myStrategy,
- saggedSurf );
- // @todo - improve simplistic test below. EJWM.
- // double tolerance=0.01;
- // if ( m_debug && (GP.x()-rot->globalPosition().x())>tolerance
- // && (GP.y()-rot->globalPosition().y())>tolerance
- // && (GP.z()-rot->globalPosition().z())>tolerance ) ATH_MSG_WARNING("Global position differs: before = "<<GP<<"\t after="<<rot->globalPosition() );
- }else{
- // If the track direction is missing, the B-field correction was not applied
- if (inputData.trackDirection) {
- // do not have access to direction, so have to use partial constructor:
- rot = new MdtDriftCircleOnTrack( &mdtPrd,
- calibOutput.locPars,
- calibOutput.locErr,
- calibOutput.driftTime,
- dcstatus,
- positionAlongWire,
- *myStrategy,
- saggedSurf );
- } else {
- MuonDriftCircleErrorStrategy tmpStrategy(myStrategy->getBits());
- tmpStrategy.setParameter(MuonDriftCircleErrorStrategy::MagFieldCorrection, false);
- rot = new MdtDriftCircleOnTrack( &mdtPrd,
- calibOutput.locPars,
- calibOutput.locErr,
- calibOutput.driftTime,
- dcstatus,
- positionAlongWire,
- tmpStrategy,
- saggedSurf );
+
+ if (!m_wasConfigured) {
+ ATH_MSG_ERROR("This tool is too complicated to rely on defaults. Potential configuration issue.");
+ return StatusCode::FAILURE;
}
- }
- ATH_MSG_DEBUG( "MDT ROT: radius = " << rot->localParameters().get(Trk::driftRadius)
- << " error = " << Amg::error(rot->localCovariance(),Trk::locR)
- << " error = " << calibOutput.locErr
- << " ,channel " << m_idHelperSvc->toString(iD) );
-
- return rot;
+ return StatusCode::SUCCESS;
}
-void Muon::MdtDriftCircleOnTrackCreator::updateSign(
- MdtDriftCircleOnTrack& caliDriftCircle,
- Trk::DriftCircleSide si) const
-{
- // ************************
- // 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 );
-}
-
-Muon::MdtDriftCircleOnTrackCreator::CalibrationOutput
-Muon::MdtDriftCircleOnTrackCreator::getLocalMeasurement(const MdtPrepData& DC,
- const Amg::Vector3D& gpos,
- const Amg::Vector3D* /**gdir*/,
- MdtCalibrationSvcInput& inputData,
- const MuonDriftCircleErrorStrategy* strategy,
- float t0Shift,
- const double beta,
- const double tTrack) const
-{
- const MuonDriftCircleErrorStrategy* myStrategy = !strategy?&m_errorStrategy:strategy;
-
- ATH_MSG_VERBOSE( "getLocalMeasurement with m_doMdt="<<m_doMdt<<" and "<<(*myStrategy));
- // ATH_MSG_INFO( "Dumping PRD: "<<DC);
-
- double radius(0.),errRadius(0.),sigmaR(1.),driftTime(0.);
- bool ok = true;
-
- std::unique_ptr<MdtCalibHit> calibHit;
- if ( m_doMdt ) {
- const MuonGM::MdtReadoutElement* detEl = DC.detectorElement();
- if(!detEl){
- ATH_MSG_WARNING( "MdtPrepData without not a MdtReadoutElement" );
-
- Amg::MatrixX localCov(1,1);
- localCov(0,0) = 0.0;
-
- return {Trk::LocalParameters{},localCov,0.,false};
- }
+MdtRotPtr MdtDriftCircleOnTrackCreator::createRIO_OnTrack(const MdtPrepData& mdtPrd,
+ const Amg::Vector3D& GP,
+ const Amg::Vector3D* GD,
+ const double t0Shift,
+ const MuonDriftCircleErrorStrategy* strategy,
+ const double beta,
+ const double tTrack) const {
- // call calibration Service
- calibHit=std::make_unique<MdtCalibHit>();
- calibHit->setIdentifier( DC.identify() );
- calibHit->setTdc( DC.tdc() );
- calibHit->setAdc( DC.adc() );
- calibHit->setGlobalPointOfClosestApproach(gpos);
- calibHit->setGeometry(detEl);
+ const EventContext& ctx{Gaudi::Hive::currentContext()};
- switch (m_timeCorrectionType){
- case ATLTIME:
- // normal time of flight corrections assuming IP + light speed
- inputData.tof = gpos.mag()*m_inverseSpeedOfLight;
- ATH_MSG_VERBOSE( " running in ATLTIME mode, tof: " << inputData.tof );
- break;
- case NO_CORRECTIONS:
- // special case for cosmics taken with scintilator trigger or cosmic simulation without TOF
- inputData.tof = 0.;
- ATH_MSG_VERBOSE( "running in NO_CORRECTIONS mode, tof: " << inputData.tof );
- 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!!!!!!
- inputData.triggerOffset = getTriggerTime();
- ATH_MSG_VERBOSE( " running in COSMICS_TRIGGERTIME mode, triggerOffset: "
- << inputData.triggerOffset );
- break;
- case COSMICS_TOF:
- inputData.tof = timeOfFlight(gpos, beta, tTrack, t0Shift);
- ATH_MSG_VERBOSE( " running in COSMICS_TOF mode, tof: " << inputData.tof<<" 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" );
- inputData.tof = 0.;
- break;
+ 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;
}
- // call the calibration service providing the time when the particle passed the tube
- ok = m_mdtCalibrationTool->driftRadiusFromTime( *calibHit, inputData, *m_mdtCalibSvcSettings );
- driftTime = calibHit->driftTime();
- radius = calibHit->driftRadius(); // copy new values
- errRadius=radius; // Use same value
-
- if ( myStrategy->creationParameter(MuonDriftCircleErrorStrategy::ErrorAtPredictedPosition)){
- std::optional<Amg::Vector2D> myLocalPosition = DC.detectorElement()->surface(DC.identify()).Trk::Surface::globalToLocal(gpos);
- if (myLocalPosition) {
- errRadius = (*myLocalPosition)[Trk::driftRadius];
- } else {
- ATH_MSG_WARNING("ErrorAtPredictedPosition failed because local position transformation didn't succeed. Using measured radius instead.");
- errRadius=radius;
- }
+ 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
+ if (myStrategy.creationParameter(MuonDriftCircleErrorStrategy::WireSagGeomCorrection)) {
+ const Trk::Surface& surf{calibInput.saggedSurface()};
+ // set large value for tolerance, to make sure that global position
+ // including drift radius is taken to the wire.
+ std::optional<Amg::Vector2D> posOnSaggedWire = surf.globalToLocal(GP,
+ m_globalToLocalTolerance);
+ if (!posOnSaggedWire) {
+ ATH_MSG_WARNING(__FILE__<<":"<<__LINE__<<" globalToLocal() failed for sagged surface, not applying sagging! ");
+ return nullptr;
+ }
+ /// replace tempLocOnWire with tempLocOnSaggedWire
+ posOnWire = std::move(*posOnSaggedWire);
+ } else {
+ const Trk::Surface& surf{calibInput.idealSurface()};
+ 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);
}
- }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" );
+
+ 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;
}
- }
-
- // Handle the errors here. Begin by getting the first part of the resolution term
- if (!m_doMdt){
- sigmaR = std::sqrt(DC.localCovariance()(0,0));
- } else if( myStrategy->creationParameter(MuonDriftCircleErrorStrategy::ParameterisedErrors) ){
- if ( myStrategy->strategy()==MuonDriftCircleErrorStrategy::Moore ){
- sigmaR = parametrisedSigma(errRadius);
- ATH_MSG_DEBUG("R= "<<radius<<"\tMoore sigmaR="<<sigmaR);
- } else if ( myStrategy->strategy()==MuonDriftCircleErrorStrategy::Muon ){
- sigmaR = parametrisedSigma(errRadius);
- ATH_MSG_DEBUG("R= "<<radius<<"\tMuon sigmaR="<<sigmaR);
+
+ 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.idealSurface()};
+ 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,
+ calibOutput.locPars,
+ 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,
+ calibOutput.locPars,
+ calibOutput.locErr,
+ calibOutput.driftTime,
+ dcstatus,
+ positionAlongWire,
+ myStrategy);
+ } else {
+ MuonDriftCircleErrorStrategy tmpStrategy(myStrategy.getBits());
+ tmpStrategy.setParameter(MuonDriftCircleErrorStrategy::MagFieldCorrection, false);
+ rot = std::make_unique<MdtDriftCircleOnTrack>(&mdtPrd,
+ calibOutput.locPars,
+ calibOutput.locErr,
+ calibOutput.driftTime,
+ dcstatus,
+ positionAlongWire,
+ tmpStrategy);
+ }
}
- }else{
- // Use calib service errors.
- if(calibHit) sigmaR =std::sqrt(calibHit->sigma2DriftRadius());
- }
- ATH_MSG_DEBUG("Tube : " << m_idHelperSvc->toString(DC.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,DC.identify());
- ATH_MSG_DEBUG("After scaling etc:\t Moore sigmaR2 = "<<sigmaR2);
- } else if ( myStrategy->strategy()==MuonDriftCircleErrorStrategy::Muon ) {
- sigmaR2 = muonErrorStrategy(myStrategy,sigmaR*sigmaR,DC.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
- return { Trk::LocalParameters(std::move(radiusPar)), newLocalCov, driftTime, ok };
+ ATH_MSG_DEBUG("MDT ROT: radius = "
+ << rot->localParameters().get(Trk::driftRadius) << " error = "
+ << Amg::error(rot->localCovariance(), Trk::locR)
+ << " error = " << calibOutput.locErr << " ,channel "
+ << m_idHelperSvc->toString(iD));
+
+ return rot.release();
}
-Muon::MdtDriftCircleOnTrack* Muon::MdtDriftCircleOnTrackCreator::correct(
- const Trk::PrepRawData& prd,
- const Trk::TrackParameters& tp,
- const MuonDriftCircleErrorStrategy* strategy,
- const double beta,
- const double tTrack ) const
-{
- const MdtPrepData* mdtPrd = dynamic_cast<const MdtPrepData*>(&prd);
- if( !mdtPrd ){
- ATH_MSG_WARNING( " Incorrect hit type: Trk::PrepRawData not a Muon::MdtPrepData!! No rot created " );
- return nullptr;
- }
-
- Amg::Vector3D momentum = tp.momentum();
-
- return createRIO_OnTrack(*mdtPrd,tp.position(),&momentum,0,strategy,beta,tTrack);
+void MdtDriftCircleOnTrackCreator::updateSign(MdtDriftCircleOnTrack& caliDriftCircle,
+ Trk::DriftCircleSide si) const {
+ // ************************
+ // 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);
}
+CalibrationOutput MdtDriftCircleOnTrackCreator::getLocalMeasurement(const EventContext& ctx,
+ const MdtPrepData& DC,
+ const MdtCalibInput& calibInput,
+ const MuonDriftCircleErrorStrategy& myStrategy) const {
+
+
+ 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(); /// copy new values
+ errRadius = radius; /// Use same value
+
+ if (myStrategy.creationParameter(MuonDriftCircleErrorStrategy::ErrorAtPredictedPosition)) {
+ const Trk::Surface& surf{calibInput.idealSurface()};
+ 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
-Muon::MdtDriftCircleOnTrack* Muon::MdtDriftCircleOnTrackCreator::correct(
- const Trk::PrepRawData& prd,
- const Trk::TrackParameters& tp ) const
-{
- const MdtPrepData* mdtPrd = dynamic_cast<const MdtPrepData*>(&prd);
- if( !mdtPrd ){
- ATH_MSG_WARNING( " Incorrect hit type: Trk::PrepRawData not a Muon::MdtPrepData!! No rot created " );
- return nullptr;
- }
+ // new radius
+ Trk::DefinedParameter radiusPar(radius, Trk::driftRadius);
- Amg::Vector3D momentum = tp.momentum();
+ // create new error matrix
+ Amg::MatrixX newLocalCov(1, 1);
+ newLocalCov(0, 0) = sigmaR2;
- return createRIO_OnTrack(*mdtPrd,tp.position(),&momentum);
+ // return new values
+ bool ok = true;
+ return {Trk::LocalParameters(std::move(radiusPar)), newLocalCov, driftTime,
+ ok};
}
-
-double Muon::MdtDriftCircleOnTrackCreator::getErrorFromRt(const Muon::MdtDriftCircleOnTrack& DCT) const {
- double t = DCT.driftTime();
- const MuonGM::MdtReadoutElement* detEl = DCT.detectorElement();
-
- MuonCalib::MdtFullCalibData data = m_mdtCalibrationDbTool->getCalibration( detEl->identifyHash(), detEl->detectorElementHash() );
- const MuonCalib::MdtRtRelation* rtRelation = data.rtRelation;
- if( !rtRelation ){
- ATH_MSG_WARNING("no calibration found for tube " << m_idHelperSvc->toString(DCT.identify()));
- return 0; //FIXME!!!
- }
-
- // check whether drift time is within range, if not fix them to the min/max range
- if( rtRelation->rt() ){
- if( t < rtRelation->rt()->tLower() ) t = rtRelation->rt()->tLower();
- else if( t > rtRelation->rt()->tUpper() ) t = rtRelation->rt()->tUpper();
- }else{
- ATH_MSG_WARNING("no rt found for tube " << m_idHelperSvc->toString(DCT.identify()));
- return 0;//FIXME!!!
- }
-
- if( !rtRelation->rtRes() ){
- ATH_MSG_WARNING("no rtRes found for tube " << m_idHelperSvc->toString(DCT.identify()) );
- return 0;//FIXME!!!
- }
-
- return rtRelation->rtRes()->resolution( t );
+MdtRotPtr MdtDriftCircleOnTrackCreator::correct(const MdtPrepData& prd,
+ const Trk::TrackParameters& tp,
+ const MuonDriftCircleErrorStrategy* strategy,
+ const double beta,
+ const double tTrack) const {
+
+ const Amg::Vector3D momentum = tp.momentum();
+ return createRIO_OnTrack(prd, tp.position(), &momentum, 0, strategy, beta, tTrack);
}
-Muon::MdtDriftCircleOnTrack* Muon::MdtDriftCircleOnTrackCreator::updateError(
- const Muon::MdtDriftCircleOnTrack& DCT,
- const Trk::TrackParameters* /**pars*/,
- const MuonDriftCircleErrorStrategy* strategy ) const
-{
- const MuonDriftCircleErrorStrategy* myStrategy = (nullptr==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{
- sigmaR = getErrorFromRt(DCT);
- 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() );
+Trk::RIO_OnTrack* MdtDriftCircleOnTrackCreator::correct(const Trk::PrepRawData& prd,
+ const Trk::TrackParameters& tp) const {
+ if (!prd.type(Trk::PrepRawDataType::MdtPrepData)){
+ ATH_MSG_WARNING(__FILE__<<":"<<__LINE__<<" Incorrect hit type: "
+ <<" Trk::PrepRawData not a MdtPrepData!! No rot created ");
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);
- }
- Muon::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 result
- return rot;
+ Amg::Vector3D momentum = tp.momentum();
+
+ return createRIO_OnTrack(static_cast<const MdtPrepData&>(prd), tp.position(), &momentum);
}
+MdtRotPtr MdtDriftCircleOnTrackCreator::updateError(const MdtDriftCircleOnTrack& DCT,
+ const Trk::TrackParameters* /**pars*/,
+ const MuonDriftCircleErrorStrategy* strategy) const {
+
+ const MuonDriftCircleErrorStrategy& myStrategy = (!strategy) ? m_errorStrategy : *strategy;
-Muon::MdtDriftCircleOnTrack* Muon::MdtDriftCircleOnTrackCreator::updateErrorExternal( const MdtDriftCircleOnTrack& DCT,
- const Trk::TrackParameters* /**pars*/ ,
- const std::map<Identifier,double>* errorlist ) const
-{
- // calculate error
- double sigmaRT(1.), sigmaEXT(1.);
- double t = DCT.driftTime();
-
- const MuonGM::MdtReadoutElement* detEl = DCT.detectorElement();
- if( !detEl ){
- ATH_MSG_WARNING("MdtDriftCircleOnTrack without MdtReadoutElement!");
- return nullptr;
- }
- Identifier detElId = detEl->identify();
-
- sigmaRT = getErrorFromRt(DCT);
-
- if( sigmaRT < 0.0001 || sigmaRT*sigmaRT < 0.0001 ){
- ATH_MSG_WARNING( "Bad obtained from calibration service: error " << m_idHelperSvc->toString(detElId) << " reso " << sigmaRT << " sigma2 " << sigmaRT*sigmaRT
- << " drift time " << t << " original " << DCT.driftTime() << " => Only external error is applied (if any)!" );
- sigmaRT=0.;
- if(!errorlist) {
- ATH_MSG_WARNING("List of external errors also empty: Returning NULL pointer.");
- return nullptr;
- }
- }
-
- if(!errorlist) {
- ATH_MSG_WARNING("List of external errors empty: Applying only error from RT.");
- sigmaEXT = 0.;
- } else {
- if( errorlist->find(DCT.identify()) != errorlist->end() )
- sigmaEXT = errorlist->find(DCT.identify())->second;
- else {
- ATH_MSG_DEBUG("There is no external error stored in the map for " << m_idHelperSvc->toString(detElId) << ". Applying only error from RT.");
- sigmaEXT = 0.;
+ // 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;
}
- }
- Muon::MdtDriftCircleOnTrack* rot = DCT.clone();
- rot->m_localCovariance(0,0) = sigmaRT*sigmaRT + sigmaEXT*sigmaEXT;
+ double radius = DCT.driftRadius();
- ATH_MSG_DEBUG("updated error for " << m_idHelperSvc->toString(DCT.identify()) << " new error " << Amg::error(rot->localCovariance(),Trk::locR)
- << " old error " << Amg::error(DCT.localCovariance(),Trk::locR) << " with RT error " << sigmaRT << " and external error " << sigmaEXT );
+ 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;
+ }
+ }
- return rot;
-}
+ } // end of tube hit check
-Muon::MdtDriftCircleStatus Muon::MdtDriftCircleOnTrackCreator::driftCircleStatus( const Muon::MdtDriftCircleOnTrack& DCT ) const
-{
- const MuonGM::MdtReadoutElement* detEl = DCT.detectorElement();
- if( !detEl ){
- ATH_MSG_WARNING("MdtDriftCircleOnTrack without MdtReadoutElement " << m_idHelperSvc->toString(DCT.identify()));
- return Muon::MdtStatusUnDefined;
- }
-
- // access rt relation
- MuonCalib::MdtFullCalibData data = m_mdtCalibrationDbTool->getCalibration( detEl->identifyHash(), detEl->detectorElementHash() );
- const MuonCalib::MdtRtRelation* rtRelation = data.rtRelation;
- if( !rtRelation ){
- ATH_MSG_WARNING("no calibration found for tube " << m_idHelperSvc->toString(DCT.identify()));
- return Muon::MdtStatusUnDefined;
- }
-
- // check whether drift time is within range, if not fix them to the min/max range
- double t = DCT.driftTime();
- return m_mdtCalibrationTool->driftTimeStatus(t, rtRelation, *m_mdtCalibSvcSettings);
+ 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();
}
-double Muon::MdtDriftCircleOnTrackCreator::timeOfFlight(const Amg::Vector3D& pos, const double beta, const double tTrack, const double tShift) const {
- return m_applyToF *(pos.mag() * m_inverseSpeedOfLight / beta) + tTrack + tShift;
+double MdtDriftCircleOnTrackCreator::timeOfFlight(const Amg::Vector3D& pos,
+ const double beta,
+ const double tTrack,
+ const double tShift) const {
+ return m_applyToF * (pos.mag() * s_inverseSpeedOfLight / beta) +
+ tTrack + tShift;
}
-double Muon::MdtDriftCircleOnTrackCreator::parametrisedSigma( double r ) {
- return 0.23*std::exp(-std::abs(r)/6.06)+0.0362;
+double MdtDriftCircleOnTrackCreator::parametrisedSigma(double r) {
+ /// These are presumably fitted from data but no clue where and how
+ return 0.23 * std::exp(-std::abs(r) / 6.06) + 0.0362;
}
-double Muon::MdtDriftCircleOnTrackCreator::mooreErrorStrategy(const MuonDriftCircleErrorStrategy* myStrategy,
- double sigmaR2, const Identifier& id) const
-{
- if(m_isMC)
- return mooreErrorStrategyMC(myStrategy, sigmaR2, id);
- else{
- if(m_looseErrors)
- return mooreErrorStrategyLoose(myStrategy, sigmaR2, id);
+double MdtDriftCircleOnTrackCreator::mooreErrorStrategy(const MuonDriftCircleErrorStrategy& myStrategy,
+ double sigmaR2,
+ const Identifier& id) const {
+ if (m_isMC)
+ return mooreErrorStrategyMC(myStrategy, sigmaR2, id);
+
+ if (m_looseErrors)
+ return mooreErrorStrategyLoose(myStrategy, sigmaR2, id);
else
- return mooreErrorStrategyTight(myStrategy, sigmaR2, id);
- }
+ return mooreErrorStrategyTight(myStrategy, sigmaR2, id);
+
}
-double Muon::MdtDriftCircleOnTrackCreator::mooreErrorStrategyMC(const MuonDriftCircleErrorStrategy* myStrategy,
- double sigmaR2, const Identifier& id) const {
- 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
- }
- // dead code never reached - should be kept nevertheless to remember default
- // ATH_MSG_VERBOSE(" segment error default ");
- // return sigmaR2;
- }
- // Don't know how to handle other cases - error?
- } else { // Track
- Muon::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( stIndex == MuonStationIndex::BI && m_idHelperSvc->chamberIndex(id) == MuonStationIndex::BIS &&
- std::abs(m_idHelperSvc->stationEta(id)) > 6 ){
- 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 && stIndex == MuonStationIndex::BI && 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
- // static bool first = true;
- // if (first){
- // ATH_MSG_WARNING( "Unknown error strategy combination - check your configuration please! "<<(*myStrategy) );
- // first = false;
- // }
- return sigmaR2;
+double MdtDriftCircleOnTrackCreator::mooreErrorStrategyMC(const MuonDriftCircleErrorStrategy& myStrategy,
+ double sigmaR2,
+ const Identifier& id) const {
+ 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;
}
-double Muon::MdtDriftCircleOnTrackCreator::mooreErrorStrategyLoose(const MuonDriftCircleErrorStrategy* myStrategy,
- double sigmaR2, const Identifier& id) const {
- 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
- }
- // dead code never reached - should be kept nevertheless to remember default
- // ATH_MSG_VERBOSE(" segment error default ");
- // return sigmaR2;
- }
- // Don't know how to handle other cases - error?
- } else { // Track
- Muon::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( stIndex == MuonStationIndex::BI && m_idHelperSvc->chamberIndex(id) == MuonStationIndex::BIS &&
- std::abs(m_idHelperSvc->stationEta(id)) > 6 ){
- 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
- }else if( stIndex == MuonStationIndex::BM && m_idHelperSvc->stationPhi(id) == 7 &&
- (m_idHelperSvc->mdtIdHelper()).stationName(id) == 53 ){
- ATH_MSG_VERBOSE(" track error BME ");
- return 1.44*sigmaR2 + 0.25; // 1.2* + 0.5 mm
- }else if( stIndex == MuonStationIndex::BO && 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 && stIndex == MuonStationIndex::BI && 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 ");
+double MdtDriftCircleOnTrackCreator::mooreErrorStrategyLoose(const MuonDriftCircleErrorStrategy& myStrategy,
+ double sigmaR2,
+ const Identifier& id) const {
+ 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
+ }
}
-
- return 1.44*sigmaR2 + fixedTerm;
- }
- }
- } // End of segment or track
- // static bool first = true;
- // if (first){
- // ATH_MSG_WARNING( "Unknown error strategy combination - check your configuration please! "<<(*myStrategy) );
- // first = false;
- // }
- return sigmaR2;
+ // 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
+ }
+ /// Need to check whether this Identifier is still existent
+ 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;
}
-
-double Muon::MdtDriftCircleOnTrackCreator::mooreErrorStrategyTight(const MuonDriftCircleErrorStrategy* myStrategy,
- double sigmaR2, const Identifier& id) const {
- 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
- }
- // dead code never reached - should be kept nevertheless to remember default
- // ATH_MSG_VERBOSE(" segment error default ");
- // return sigmaR2;
- }
- // Don't know how to handle other cases - error?
- } else { // Track
- Muon::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( stIndex == MuonStationIndex::BI && m_idHelperSvc->chamberIndex(id) == MuonStationIndex::BIS &&
- std::abs(m_idHelperSvc->stationEta(id)) > 6 ){
- 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 + 1.; // 2* + 1. mm
- }else if( stIndex == MuonStationIndex::BM && m_idHelperSvc->stationPhi(id) == 7 &&
- (m_idHelperSvc->mdtIdHelper()).stationName(id) == 53 ){
- ATH_MSG_VERBOSE(" track error BME ");
- return 1.21*sigmaR2 + 0.25; // 1.1* + 0.5 mm
- }else if( stIndex == MuonStationIndex::BO && 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;
- bool isSmall = m_idHelperSvc->isSmallChamber(id);
- if( stIndex == MuonStationIndex::BI||stIndex == MuonStationIndex::BM||stIndex == MuonStationIndex::BO) {
- if( isSmall ) fixedTerm = 0.01;
- else fixedTerm = 0.01;
- }else{
- if( isSmall ) fixedTerm = 0.01;
- else fixedTerm = 0.01;
- }
- if( m_doIndividualChamberReweights ){
- if( stIndex == MuonStationIndex::BI && 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 ");
+double MdtDriftCircleOnTrackCreator::mooreErrorStrategyTight(const MuonDriftCircleErrorStrategy& myStrategy,
+ double sigmaR2,
+ const Identifier& id) const {
+ 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
+ }
}
-
- return 1.21*sigmaR2 + fixedTerm;
- }
- }
- } // End of segment or track
- // static bool first = true;
- // if (first){
- // ATH_MSG_WARNING( "Unknown error strategy combination - check your configuration please! "<<(*myStrategy) );
- // first = false;
- // }
- return sigmaR2;
+ // 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
+ }
+ /// Need to check whether this Identifier is still valid?
+ 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;
}
-double Muon::MdtDriftCircleOnTrackCreator::muonErrorStrategy(const MuonDriftCircleErrorStrategy* myStrategy,
- double sigmaR2, const Identifier& /*id*/) const {
-
-//
-// 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 doesnot 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;
+double MdtDriftCircleOnTrackCreator::muonErrorStrategy(const MuonDriftCircleErrorStrategy& myStrategy,
+ double sigmaR2,
+ const Identifier& /*id*/) const {
+
+ //
+ // 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;
}
+}
\ No newline at end of file
diff --git a/MuonSpectrometer/MuonReconstruction/MuonRIO_OnTrackCreators/MdtDriftCircleOnTrackCreator/src/MdtDriftCircleOnTrackCreator.h b/MuonSpectrometer/MuonReconstruction/MuonRIO_OnTrackCreators/MdtDriftCircleOnTrackCreator/src/MdtDriftCircleOnTrackCreator.h
index e58cbed460f..acba01c37b9 100644
--- a/MuonSpectrometer/MuonReconstruction/MuonRIO_OnTrackCreators/MdtDriftCircleOnTrackCreator/src/MdtDriftCircleOnTrackCreator.h
+++ b/MuonSpectrometer/MuonReconstruction/MuonRIO_OnTrackCreators/MdtDriftCircleOnTrackCreator/src/MdtDriftCircleOnTrackCreator.h
@@ -5,244 +5,285 @@
#ifndef MUON_MDTDRIFTCIRCLEONTRACKCREATOR_H
#define MUON_MDTDRIFTCIRCLEONTRACKCREATOR_H
-#include "MuonRecToolInterfaces/IMdtDriftCircleOnTrackCreator.h"
-#include "AthenaBaseComps/AthAlgTool.h"
-#include "GaudiKernel/ServiceHandle.h"
-#include "GaudiKernel/ToolHandle.h"
+#include <bitset>
+#include <memory>
+#include <string>
-#include "MuonIdHelpers/IMuonIdHelperSvc.h"
+#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 "MdtCalibSvc/MdtCalibrationTool.h"
-#include "MdtCalibSvc/MdtCalibrationDbTool.h"
+#include "MuonRecToolInterfaces/IMdtDriftCircleOnTrackCreator.h"
+#include "StoreGate/ReadCondHandleKey.h"
#include "TrkEventPrimitives/LocalParameters.h"
#include "TrkSpaceTimePoint/SpaceTimePoint.h"
-#include "MdtCalibSvc/MdtCalibrationSvcSettings.h"
-#include <bitset>
-#include <string>
-#include <memory>
-
-class MdtCalibrationSvcInput;
+class MdtCalibToolInput;
namespace Muon {
- class MdtPrepData;
-
- /**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.
- @code const MdtDriftCircleOnTrack* correct ( const Trk::PrepRawData& prd, const Trk::TrackParameters& tp) const @endcode
- - 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.
- @code createRIO_OnTrack(const MdtPrepData& prd, const Trk::GlobalPosition& globalPos) const @endcode
- - Update the side (sign) of the Muon::MdtDriftCircleOnTrack.
- @code updateSign(const MdtDriftCircleOnTrack& rot, const Trk::DriftCircleSide si) const @endcode
-
- 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)
- - DoWireSag: Flag to turn on application of geometrical wire sagging correstions (default = false)
- - CreateTubeHit: Flag to turn on the creation of tube hits (default = false)
+class MdtPrepData;
+
+/**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.
+ @code const MdtRotPtr correct ( const Trk::PrepRawData& prd,
+const Trk::TrackParameters& tp) const @endcode
+ - 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.
+ @code createRIO_OnTrack(const MdtPrepData& prd, const Trk::GlobalPosition&
+globalPos) const @endcode
+ - Update the side (sign) of the Muon::MdtDriftCircleOnTrack.
+ @code updateSign(const MdtDriftCircleOnTrack& rot, const
+Trk::DriftCircleSide si) const @endcode
+
+ 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)
+ - DoWireSag: Flag to turn on application of geometrical wire sagging
+correstions (default = false)
+ - CreateTubeHit: Flag to turn on the creation of tube hits (default = false)
+*/
+class MdtDriftCircleOnTrackCreator: public AthAlgTool, public IMdtDriftCircleOnTrackCreator {
+ public:
+ enum TimingMode {
+ //!< normal time of flight corrections assuming IP + light speed
+ //!< to be used for simulated data and collision data
+ ATLTIME =0,
+ //!< special case for cosmics taken with scintilator trigger or
+ //!< cosmic simulation without TOF
+ NO_CORRECTIONS = 1,
+ //!< 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 = 2,
+ //!< 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 =3,
+
+ NumberOfTimingModes
+ };
+
+ public:
+ MdtDriftCircleOnTrackCreator(const std::string&, const std::string&, const IInterface*);
+ virtual ~MdtDriftCircleOnTrackCreator() = default;
+
+ virtual StatusCode initialize() override final;
+
+ /** @brief 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
+ @param prd MdtPrepData object
+ @param globalPos GlobalPosition (including second coordinate along the tube)
+ @param gdir GlobalDirection of track
+ @param strategy optional drift circle error strategy to override the default
+ @return Fully calibrated MdtDriftCircleOnTrack (the user must delete this
+ object when it is no longer needed)
+ */
+ 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;
+
+ /** @brief 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.
+ @param rot reference to the Muon::MdtDriftCircleOnTrack of which the sign
+ should be updated.
+ @param si Trk::DriftCircleSide indicating whether the muon passed on the
+ left or right side of the wire.
*/
- class MdtDriftCircleOnTrackCreator : public AthAlgTool, virtual public IMdtDriftCircleOnTrackCreator {
- public:
- enum TimingMode { ATLTIME=0, //!< normal time of flight corrections assuming IP + light speed to be used for simulated data and collision data
- NO_CORRECTIONS=1, //!< special case for cosmics taken with scintilator trigger or cosmic simulation without TOF
- COSMICS_TRIGGERTIME=2, //!< 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_TOF=3, //!< 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
- NumberOfTimingModes
- };
-
- public:
-
- MdtDriftCircleOnTrackCreator(const std::string&,const std::string&,const IInterface*);
- virtual ~MdtDriftCircleOnTrackCreator()=default;
- virtual StatusCode initialize();
-
- /** @brief 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
- @param prd MdtPrepData object
- @param globalPos GlobalPosition (including second coordinate along the tube)
- @param gdir GlobalDirection of track
- @param strategy optional drift circle error strategy to override the default
- @return Fully calibrated MdtDriftCircleOnTrack (the user must delete this object when it is no longer needed)
- */
- virtual MdtDriftCircleOnTrack* createRIO_OnTrack( const MdtPrepData& prd,
- const Amg::Vector3D& globalPos,
- const Amg::Vector3D* gdir = 0,
- float t0Shift = 0,
- const MuonDriftCircleErrorStrategy* strategy = 0,
- const double beta = 1,
- const double tTrack = 1 ) const;
-
- /** @brief 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.
- @param rot reference to the Muon::MdtDriftCircleOnTrack of which the sign should be updated.
- @param si Trk::DriftCircleSide indicating whether the muon passed on the left or right side of the wire.
- */
- virtual void updateSign( MdtDriftCircleOnTrack& rot,
- const Trk::DriftCircleSide si) const;
-
- /** @brief Update error of a ROT without changing the drift radius
- @param DCT reference to the Muon::MdtDriftCircleOnTrack of which the sign should be updated.
- @param pars track prediction at DCT used when using the track prediction to update the error
- @param strategy optional drift circle error strategy to override the default
- @return New ROT with updated error. (the user must delete this object when it is no longer needed).
- */
- virtual MdtDriftCircleOnTrack* updateError( const MdtDriftCircleOnTrack& DCT,
- const Trk::TrackParameters* pars = 0,
- const MuonDriftCircleErrorStrategy* strategy = 0 ) const;
-
- /** @brief Update error of a ROT without changing the drift radius
- @param DCT reference to the Muon::MdtDriftCircleOnTrack of which the sign should be updated.
- @param pars track prediction at DCT used when using the track prediction to update the error
- @param errorlist holds the identifier of the chamber/det element and the error to be applied on the DCTs inside
- @return New ROT with updated error. (the user must delete this object when it is no longer needed).
- */
- virtual MdtDriftCircleOnTrack* updateErrorExternal( const MdtDriftCircleOnTrack& DCT,
- const Trk::TrackParameters* pars = 0,
- const std::map<Identifier,double>* errorlist = 0 ) const;
-
- /** @brief Retrieves just the MdtFullCalibData and uses this to get updated MdtRtRelation.*/
- double getErrorFromRt(const Muon::MdtDriftCircleOnTrack& DCT) const ;
-
- /** @brief Returns calibrated MdtDriftCircleOnTrack.
- Implementation of IRIO_OnTrackCreator method
- @param prd Reference to a Trk::PrepRawData object (which should always be a Muon::MdtPrepData in this case)
- @param tp Reference to the extrapolated/predicted TrackParameters at this MdtPrepData
- @return calibrated MdtDriftCircleOnTrack. Memory management is passed to user.
- */
- virtual MdtDriftCircleOnTrack* correct( const Trk::PrepRawData& prd,
- const Trk::TrackParameters& tp,
- const MuonDriftCircleErrorStrategy* strategy,
- const double beta,
- const double tTrack ) const;
-
- /** @brief Base class method for correct. */
- virtual MdtDriftCircleOnTrack* correct( const Trk::PrepRawData& prd,
- const Trk::TrackParameters& tp ) const;
-
- /** @brief Returns the MdtDriftCircleOnTrack for a Muon::MdtDriftCircleOnTrack by comparing its time with the range of the RT relation. */
- MdtDriftCircleStatus driftCircleStatus( const MdtDriftCircleOnTrack& DCT ) const ;
-
- /** @brief Returns the default error strategy object */
- const MuonDriftCircleErrorStrategy& errorStrategy() const { return m_errorStrategy; };
-
- private:
- double timeOfFlight(const Amg::Vector3D& pos, const double beta, const double tTrack, const double tShift) const;
-
- /** struct to hold output of calibration */
- struct CalibrationOutput {
- CalibrationOutput( Trk::LocalParameters lp, //!< localParameters
- Amg::MatrixX le, //!< localErrorMatrix
- double t, //!< drift time
- bool ok
- ) : locPars(lp),locErr(le),driftTime(t),calibOk(ok) {}
+ virtual void updateSign(MdtDriftCircleOnTrack& rot,
+ const Trk::DriftCircleSide si) const override final;
+
+ /** @brief Update error of a ROT without changing the drift radius
+ @param DCT reference to the Muon::MdtDriftCircleOnTrack of which the
+ sign should be updated.
+ @param pars track prediction at DCT used when using the track prediction
+ to update the error
+ @param strategy optional drift circle error strategy to override the default
+ @return New ROT with updated error. (the user must delete this object
+ when it is no longer needed).
+ */
+ virtual MdtRotPtr updateError(const MdtDriftCircleOnTrack& DCT,
+ const Trk::TrackParameters* pars = nullptr,
+ const MuonDriftCircleErrorStrategy* strategy = nullptr) const override;
+
+
+ /** @brief Base class method for correct. */
+ virtual Trk::RIO_OnTrack* correct(const Trk::PrepRawData& prd,
+ const Trk::TrackParameters& tp) const override;
+
+ /** @brief Returns calibrated MdtDriftCircleOnTrack.
+ Implementation of IRIO_OnTrackCreator method
+ @param prd Reference to a Trk::PrepRawData object (which should always be a
+ Muon::MdtPrepData in this case)
+ @param tp Reference to the extrapolated/predicted TrackParameters at this
+ MdtPrepData
+ @return calibrated MdtDriftCircleOnTrack. Memory management is passed to
+ user.
+ */
+ virtual MdtRotPtr correct(const MdtPrepData& prd,
+ const Trk::TrackParameters& tp,
+ const MuonDriftCircleErrorStrategy* strategy,
+ const double beta,
+ const double tTrack) const override final;
+
+ /** @brief Returns the default error strategy object */
+ const MuonDriftCircleErrorStrategy& errorStrategy() const {
+ return m_errorStrategy;
+ };
+
+ /** struct to hold output of calibration */
+ struct CalibrationOutput {
+ CalibrationOutput(Trk::LocalParameters lp, //!< localParameters
+ Amg::MatrixX le, //!< localErrorMatrix
+ double t, //!< drift time
+ bool ok)
+ : locPars(lp), locErr(le), driftTime(t), calibOk(ok) {}
Trk::LocalParameters locPars;
- Amg::MatrixX locErr;
- double driftTime;
- bool calibOk;
- };
-
- /** preform the mdt calibration */
- CalibrationOutput getLocalMeasurement(const MdtPrepData &DC,
- const Amg::Vector3D &gpos,
- const Amg::Vector3D *gdir,
- MdtCalibrationSvcInput &inputData,
- const MuonDriftCircleErrorStrategy *strategy,
- float t0Shift,
- const double beta,
- const double tTrack) const;
-
- /** currently returns 0. */
- double getTriggerTime() const { return 0.; }
-
- /** currently returns 0. */
- double getTriggerTimeTestbeam() 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<MdtCalibrationTool> m_mdtCalibrationTool{this,"CalibrationTool","MdtCalibrationTool"};
- ToolHandle<MdtCalibrationDbTool> m_mdtCalibrationDbTool{this,"CalibrationDbTool","MdtCalibrationDbTool"};
+ Amg::MatrixX locErr;
+ double driftTime;
+ bool calibOk;
+ };
+
+
+
+ private:
- // Configuration variables
- Gaudi::Property<bool> m_doMdt{this, "doMDT", true}; //!< Process MDT ROTs
- //!< Defined in TimingMode enum.
- Gaudi::Property<int> m_timeCorrectionType{this, "TimingMode", 0};
- //!< if set to true, do not create ROTs for masked hits
- Gaudi::Property<bool> m_discardMaskedHits{this, "DiscardMaskedHits", true};
- // Constants for use during calculations
- //!< Error used when m_doFixed error =true or m_scaleErrorManually = true
- Gaudi::Property<double> m_fixedError{this, "FixedError", 1. };
-
- Gaudi::Property<double> m_globalToLocalTolerance{this,"GlobalToLocalTolerance", 1000., "Tolerance used for the Surface::globalToLocal"};
-
- std::unique_ptr<MdtCalibrationSvcSettings> m_mdtCalibSvcSettings{std::make_unique<MdtCalibrationSvcSettings>()};
-
- // Member variables used to fill the default error strategy
- MuonDriftCircleErrorStrategy m_errorStrategy{Muon::MuonDriftCircleErrorStrategyInput()}; //!< Error strategy for created ROTs
-
- //!< Default error strategy for the error strategy object
- Gaudi::Property<std::string> m_defaultStrategy{this, "Moore", "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)
- Gaudi::Property<bool> m_createTubeHits{this, "CreateTubeHit", false};
- //!< Scale ROTs depending on local alignment (i.e. location in detector)
- Gaudi::Property<bool> m_scaleMdtCov{this, "DoErrorScaling", true};
- Gaudi::Property<bool> m_doFixedError{this, "DoFixedError", true}; //!< Fixed error (not tube radius)
- //!< Use parameterised errors
- Gaudi::Property<bool> m_useErrorParametrisation{this, "UseParametrisedError", false};
- //!< 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.
- Gaudi::Property<bool> m_errorAtPredictedPosition{this, "UseErrorAtPredictedPosition", false};
- //!< if set to true, then apply wire sag corrections.
- Gaudi::Property<bool> m_doWireSag{this, "DoWireSag", false };
- //!< Add a term to the error to account for very poorly aligned stations
- Gaudi::Property<bool> m_stationError{this, "DoStationError", false};
- //!< Add a special error to account for the T0 refit
- Gaudi::Property<bool> m_t0Refit{this, "T0RefitError", false};
- //!< Use error strategy for segments by default
- Gaudi::Property<bool> m_doSegments{this, "DoSegmentErrors",true};
- //!< Deweight individual chambers
- Gaudi::Property<bool> m_doIndividualChamberReweights{this, "DeweightIndividualChambers", true};
- //!< toggle between MC and data alignment errors (to be removed in rel. 21!)
- Gaudi::Property<bool> m_isMC{this, "IsMC", false};
- //!< toggle whether the time of flight is included in the t0 shifts
- Gaudi::Property<bool> m_applyToF{this, "ApplyToF", true};
- //!< toggle between loose errors (initial before alignment) and tight after alignment
- 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."};
+ double timeOfFlight(const Amg::Vector3D& pos,
+ const double beta,
+ const double tTrack,
+ const double tShift) const;
+
+ /** preform the mdt calibration */
+ CalibrationOutput getLocalMeasurement(const EventContext& ctx,
+ const MdtPrepData& DC,
+ const MdtCalibInput& calibInput,
+ const MuonDriftCircleErrorStrategy& strategy) const;
+
+ /** currently returns 0. */
+ double getTriggerTime() const { return 0.; }
+
+ // parametrised error function
+ static double parametrisedSigma(double r);
+
+ double mooreErrorStrategy(const MuonDriftCircleErrorStrategy& myStrategy,
+ double sigmaR,
+ const Identifier& id) const;
- static constexpr double m_inverseSpeedOfLight = 1 / Gaudi::Units::c_light;
- };
+ 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}; //!< Process MDT ROTs
+ //!< Defined in TimingMode enum.
+ Gaudi::Property<int> m_timeCorrectionType{this, "TimingMode", 0};
+ // Constants for use during calculations
+ //!< Error used when m_doFixed error =true or m_scaleErrorManually = true
+ 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
+ //!< Error strategy for created ROTs
+ MuonDriftCircleErrorStrategy m_errorStrategy{MuonDriftCircleErrorStrategyInput{}};
+
+ //!< Default error strategy for the error strategy object
+ Gaudi::Property<std::string> m_defaultStrategy{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)
+ Gaudi::Property<bool> m_createTubeHits{this, "CreateTubeHit", false};
+ //!< Scale ROTs depending on local alignment (i.e. location in detector)
+ Gaudi::Property<bool> m_scaleMdtCov{this, "DoErrorScaling", true};
+ //!< Fixed error (not tube radius)
+ Gaudi::Property<bool> m_doFixedError{this, "DoFixedError", true};
+ //!< Use parameterised errors
+ Gaudi::Property<bool> m_useErrorParametrisation{this, "UseParametrisedError", false};
+ //!< 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.
+ Gaudi::Property<bool> m_errorAtPredictedPosition{this, "UseErrorAtPredictedPosition", false};
+ //!< if set to true, then apply wire sag corrections.
+ Gaudi::Property<bool> m_doWireSag{this, "DoWireSag", false};
+ //!< Add a term to the error to account for very poorly aligned stations
+ Gaudi::Property<bool> m_stationError{this, "DoStationError", false};
+ //!< Add a special error to account for the T0 refit
+ Gaudi::Property<bool> m_t0Refit{this, "T0RefitError", false};
+ //!< Use error strategy for segments by default
+ Gaudi::Property<bool> m_doSegments{this, "DoSegmentErrors", true};
+ //!< Deweight individual chambers
+ Gaudi::Property<bool> m_doIndividualChamberReweights{this, "DeweightIndividualChambers", true};
+ //!< toggle between MC and data alignment errors (to be removed in rel. 21!)
+ Gaudi::Property<bool> m_isMC{this, "IsMC", false};
+ //!< toggle whether the time of flight is included in the t0 shifts
+ Gaudi::Property<bool> m_applyToF{this, "ApplyToF", true};
+ //!< toggle between loose errors (initial before alignment) and tight after
+ //!< alignment
+ 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};
+
+};
-} // End of muon namespace
+} // namespace Muon
#endif
diff --git a/MuonSpectrometer/MuonReconstruction/MuonRIO_OnTrackCreators/MdtDriftCircleOnTrackCreator/src/components/MdtDriftCircleOnTrackCreator_entries.cxx b/MuonSpectrometer/MuonReconstruction/MuonRIO_OnTrackCreators/MdtDriftCircleOnTrackCreator/src/components/MdtDriftCircleOnTrackCreator_entries.cxx
index 8e8b3120c2c..9a160fba0d0 100644
--- a/MuonSpectrometer/MuonReconstruction/MuonRIO_OnTrackCreators/MdtDriftCircleOnTrackCreator/src/components/MdtDriftCircleOnTrackCreator_entries.cxx
+++ b/MuonSpectrometer/MuonReconstruction/MuonRIO_OnTrackCreators/MdtDriftCircleOnTrackCreator/src/components/MdtDriftCircleOnTrackCreator_entries.cxx
@@ -1,4 +1,6 @@
+/*
+ Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
+*/
#include "../MdtDriftCircleOnTrackCreator.h"
-DECLARE_COMPONENT( Muon::MdtDriftCircleOnTrackCreator )
-
+DECLARE_COMPONENT(Muon::MdtDriftCircleOnTrackCreator)
diff --git a/MuonSpectrometer/MuonReconstruction/MuonRecEvent/MuonRIO_OnTrack/MuonRIO_OnTrack/MdtDriftCircleOnTrack.h b/MuonSpectrometer/MuonReconstruction/MuonRecEvent/MuonRIO_OnTrack/MuonRIO_OnTrack/MdtDriftCircleOnTrack.h
index 34959e0b9c8..9bc95878fbc 100644
--- a/MuonSpectrometer/MuonReconstruction/MuonRecEvent/MuonRIO_OnTrack/MuonRIO_OnTrack/MdtDriftCircleOnTrack.h
+++ b/MuonSpectrometer/MuonReconstruction/MuonRecEvent/MuonRIO_OnTrack/MuonRIO_OnTrack/MdtDriftCircleOnTrack.h
@@ -1,19 +1,6 @@
/*
- Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
+ Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
*/
-
-///////////////////////////////////////////////////////////////////
-// MdtDriftCircleOnTrack.h
-// Header file for class MdtDriftCircleOnTrack
-///////////////////////////////////////////////////////////////////
-// (c) ATLAS Detector software
-///////////////////////////////////////////////////////////////////
-// /** Class to implement DriftCircle On Track for MDT */
-///////////////////////////////////////////////////////////////////
-// Version 1.0 06/07/2004 Ketevi A. Assamagan
-// adapted from Veronique Boisvert
-///////////////////////////////////////////////////////////////////
-
#ifndef MUONRIO_ONTRACK_MDTDRIFTCIRCLEONTRACK_H
#define MUONRIO_ONTRACK_MDTDRIFTCIRCLEONTRACK_H
@@ -21,7 +8,6 @@
#include "TrkRIO_OnTrack/RIO_OnTrack.h"
#include "MuonPrepRawData/MdtPrepData.h"
-#include "TrkSurfaces/Surface.h"
#include "TrkEventPrimitives/DriftCircleSide.h"
#include "TrkEventPrimitives/DriftCircleStatus.h"
@@ -31,30 +17,24 @@
#include "MuonRIO_OnTrack/MuonDriftCircleErrorStrategy.h"
#include "CxxUtils/CachedUniquePtr.h"
+
#include <cassert>
-typedef ElementLink<Muon::MdtPrepDataContainer> ElementLinkToIDC_MDT_Container;
+using ElementLinkToIDC_MDT_Container = ElementLink<Muon::MdtPrepDataContainer>;
-namespace Trk
-{
+namespace Trk{
class LocalParameters;
- class StraightLineSurface;
-}
-
- namespace Trk
-{
class ITrkEventCnvTool;
}
-namespace Muon
+namespace Muon
{
class MuonEventCnvTool;
class MdtDriftCircleOnTrackCreator;
/** @brief This class represents the corrected MDT measurements,
where the corrections include the effects of wire sag etc.*/
-class MdtDriftCircleOnTrack final: public Trk::RIO_OnTrack
-{
+class MdtDriftCircleOnTrack final: public Trk::RIO_OnTrack {
public:
friend class Trk::ITrkEventCnvTool;
@@ -62,12 +42,13 @@ public:
friend class Muon::MdtDriftCircleOnTrackCreator;
/** @brief Default ctor - for use by POOL only. Do not use yourself!*/
- MdtDriftCircleOnTrack();
-
+ MdtDriftCircleOnTrack() = default;
+
MdtDriftCircleOnTrack(const MdtDriftCircleOnTrack &);
-
MdtDriftCircleOnTrack &operator=(const MdtDriftCircleOnTrack &);
- MdtDriftCircleOnTrack &operator=(MdtDriftCircleOnTrack &&) noexcept;
+
+ MdtDriftCircleOnTrack(MdtDriftCircleOnTrack&&) = default;
+ MdtDriftCircleOnTrack &operator=(MdtDriftCircleOnTrack&&) = default;
@@ -92,16 +73,14 @@ public:
@param [in] creationParameters A bitword containing information about the construction of the ROT.
See m_rotCreationParameters for details.
*/
- MdtDriftCircleOnTrack( const MdtPrepData* RIO,
- const Trk::LocalParameters& locPos,
- const Amg::MatrixX& errDriftRadius,
- const double driftTime,
- const Trk::DriftCircleStatus status,
- const Amg::Vector3D& globDir,
- const double positionAlongWire,
- const MuonDriftCircleErrorStrategy& errorStrategy,
- const Trk::StraightLineSurface* saggedSurface=0
- );
+ MdtDriftCircleOnTrack(const MdtPrepData* RIO,
+ const Trk::LocalParameters& locPos,
+ const Amg::MatrixX& errDriftRadius,
+ const double driftTime,
+ const Trk::DriftCircleStatus status,
+ const Amg::Vector3D& globDir,
+ const double positionAlongWire,
+ const MuonDriftCircleErrorStrategy& errorStrategy);
/** @brief Constructor without global direction for both non-sagged and sagged wire (default is non-sagged, since saggedSurface=0).
This necessarily implies that the DriftCircleStatus is UNDECIDED, since without the GlobalDirection it cannot be worked out.
@@ -124,34 +103,29 @@ public:
@param [in] creationParameters A bitword containing information about the construction of the ROT.
See m_rotCreationParameters for details.
*/
- MdtDriftCircleOnTrack( const MdtPrepData* RIO,
- const Trk::LocalParameters& locPos,
- const Amg::MatrixX& errDriftRadius,
- const double driftTime,
- const Trk::DriftCircleStatus status,
- const double positionAlongWire,
- const MuonDriftCircleErrorStrategy& errorStrategy,
- const Trk::StraightLineSurface* saggedSurface=0
- );
-
-
- // Alternate constructor that doesn't dereference the RIO link.
- MdtDriftCircleOnTrack(
- const ElementLinkToIDC_MDT_Container& RIO,
- const Trk::LocalParameters& locPos,
- const Amg::MatrixX& errDriftRadius,
- const Identifier& id,
- const MuonGM::MdtReadoutElement* detEl,
- const double driftTime,
- const Trk::DriftCircleStatus status,
- double positionAlongWire,
- float localAngle,
- const MuonDriftCircleErrorStrategy& errorStrategy,
- const Trk::StraightLineSurface* surface
- );
+ MdtDriftCircleOnTrack(const MdtPrepData* RIO,
+ const Trk::LocalParameters& locPos,
+ const Amg::MatrixX& errDriftRadius,
+ const double driftTime,
+ const Trk::DriftCircleStatus status,
+ const double positionAlongWire,
+ const MuonDriftCircleErrorStrategy& errorStrategy);
+
+
+ // Alternate constructor that doesn't dereference the RIO link.
+ MdtDriftCircleOnTrack(const ElementLinkToIDC_MDT_Container& RIO,
+ const Trk::LocalParameters& locPos,
+ const Amg::MatrixX& errDriftRadius,
+ const Identifier& id,
+ const MuonGM::MdtReadoutElement* detEl,
+ const double driftTime,
+ const Trk::DriftCircleStatus status,
+ const double positionAlongWire,
+ const double localAngle,
+ const MuonDriftCircleErrorStrategy& errorStrategy);
/** @brief Destructor: */
- virtual ~MdtDriftCircleOnTrack();
+ virtual ~MdtDriftCircleOnTrack() = default;
/** @brief Returns the side on which the drift radius is wrt to the track */
Trk::DriftCircleSide side() const;
@@ -181,7 +155,7 @@ public:
- If hasSaggedSurface()==false, then the surface will be that of the matching Detector Element
- If hasSaggedSurface()==true, then the surface will be a special surface, representing the sagged position
of the wire at the coords of this measurement.*/
- virtual const Trk::Surface& associatedSurface() const override final;
+ virtual const Trk::StraightLineSurface& associatedSurface() const override final;
/** @brief Returns the global Position.
Be aware that this is calculated from the predicted position along
@@ -189,16 +163,10 @@ public:
and so is not a 'true' measurement.*/
virtual const Amg::Vector3D& globalPosition() const override final;
- virtual bool rioType(Trk::RIO_OnTrackType::Type type) const override final
- {
+ virtual bool rioType(Trk::RIO_OnTrackType::Type type) const override final {
return (type == Trk::RIO_OnTrackType::MdtDriftCircle);
}
- /** @brief Returns a boolean indicating if this object was created with a sagged surface (i.e. if sagging corrections have been done.)
- - If true, it means that this surface was created with a sagged surface, i.e. it has been corrected for wire sag.
- - If false, then the associatedSurface() method returns the suface of the detector element (i.e. the nominal surface)*/
- bool hasSaggedSurface() const;
-
/** @brief Returns the value of the drift radius.
Obviously to use this method you need to cast to a MdtDriftCircleOnTrack if you have a pointer or reference
to the base class (Trk::RIO_OnTrack). An alternative is to use:
@@ -214,10 +182,10 @@ public:
double driftTime() const;
/** @brief Returns the position along the wire, as determined by the extrapolation used when creating this Trk::RIO_OnTrack.*/
- float positionAlongWire() const;
+ double positionAlongWire() const;
/** @brief Returns the local angle, as determined by the extrapolation used when creating this Trk::RIO_OnTrack.*/
- float localAngle() const;
+ double localAngle() const;
/** @brief Get information about the creation strategy used by Muon::MdtDriftCircleOnTrackCreator when making this object.*/
const MuonDriftCircleErrorStrategy& errorStrategy() const;
@@ -243,38 +211,34 @@ private:
/** @brief Uses the passed loc3Dframe to calculate and set the global coord of this hit.
If there is a sagged wire defined, this will be used for the transformation, otherwise the detector element surface is used*/
- void setGlobalPosition(HepGeom::Point3D<double>& loc3Dframe) const;
+ void setGlobalPosition(Amg::Vector3D&& loc3Dframe) const;
//Sets the error strategy, only used by the Muon::MdtDriftCircleOnTrackCreator
- void setErrorStrategy(const MuonDriftCircleErrorStrategy* strategy);
+ void setErrorStrategy(const MuonDriftCircleErrorStrategy& strategy);
/**information on the status of the Mdt measurement - see Trk::DriftCircleStatus for definitions*/
- Trk::DriftCircleStatus m_status;
+ Trk::DriftCircleStatus m_status{Trk::DriftCircleStatus::UNDECIDED};
/** the pointer to the MdtPrepData object (mutable because it might need to be recreated when reading tracks)*/
- ElementLinkToIDC_MDT_Container m_rio;
+ ElementLinkToIDC_MDT_Container m_rio{};
/** global position of the measurement. */
- CxxUtils::CachedUniquePtr<const Amg::Vector3D> m_globalPosition;
-
- /** Surface at postion of sagged wire. This is owned by this object, and will be deleted when it
- is.*/
- const Trk::StraightLineSurface* m_saggedSurface;
-
- /** The detector element, associated with this measurement*/
- const MuonGM::MdtReadoutElement* m_detEl;
+ CxxUtils::CachedUniquePtr<Amg::Vector3D> m_globalPosition{};
/** This angle is the position of the point of closest approach in cylindrical coordinates, and is needed to construct the global position*/
- float m_localAngle;
+ double m_localAngle{0.};
/** This is the position of the point of closest approach, in the local z coord (i.e. along the wire), and is needed to construct the global position*/
- float m_positionAlongWire;
+ double m_positionAlongWire{0.};
/** This is the drift time used to obtain the drift radius */
- float m_driftTime;
+ double m_driftTime{0.};
/** Records information about the 'strategy' used by Muon::MdtDriftCircleOnTrackCreator to make this object.*/
- MuonDriftCircleErrorStrategy m_errorStrategy;
+ MuonDriftCircleErrorStrategy m_errorStrategy{};
+
+ /*** Pointer to the detector element. Needed if no prepData is present*/
+ const MuonGM::MdtReadoutElement* m_detEl{nullptr};
};
@@ -282,103 +246,53 @@ private:
// Inline methods:
// /////////////////////////////////////////////////////////////////:
-inline Trk::DriftCircleSide MdtDriftCircleOnTrack::side() const
-{
+inline Trk::DriftCircleSide MdtDriftCircleOnTrack::side() const {
if (m_status == Trk::UNDECIDED) return Trk::NONE;
if (localParameters()[Trk::driftRadius] < 0. ) return Trk::LEFT;
return Trk::RIGHT;
}
-inline Trk::DriftCircleStatus MdtDriftCircleOnTrack::status() const
- {
- return m_status;
- }
-
-
-inline MdtDriftCircleOnTrack* MdtDriftCircleOnTrack::clone() const
-{
- return new MdtDriftCircleOnTrack(*this);
-}
-
-inline const MdtPrepData* MdtDriftCircleOnTrack::prepRawData() const
-{
- if (m_rio.isValid()) return m_rio.cachedElement();
- //std::cout<<"MdtDriftCircleOnTrack::WARNING invalid PRD"<<std::endl;
- return 0;
+inline Trk::DriftCircleStatus MdtDriftCircleOnTrack::status() const { return m_status; }
+inline MdtDriftCircleOnTrack* MdtDriftCircleOnTrack::clone() const { return new MdtDriftCircleOnTrack(*this); }
+inline const MdtPrepData* MdtDriftCircleOnTrack::prepRawData() const {
+ if (m_rio.isValid()) return m_rio.cachedElement();
+ return nullptr;
}
-inline const ElementLinkToIDC_MDT_Container& MdtDriftCircleOnTrack::prepRawDataLink() const
-{
- return m_rio;
-}
+inline const ElementLinkToIDC_MDT_Container& MdtDriftCircleOnTrack::prepRawDataLink() const { return m_rio; }
-inline IdentifierHash MdtDriftCircleOnTrack::collectionHash() const
-{
- const MdtPrepData* prd = prepRawData();
- return prd->collectionHash();
+inline IdentifierHash MdtDriftCircleOnTrack::collectionHash() const {
+ return prepRawData()->collectionHash();
}
-inline const MuonGM::MdtReadoutElement* MdtDriftCircleOnTrack::detectorElement() const
-{
- return m_detEl;
+inline const MuonGM::MdtReadoutElement* MdtDriftCircleOnTrack::detectorElement() const {
+ return prepRawData() ? prepRawData()->detectorElement() : m_detEl;
}
-
-inline const Trk::Surface& MdtDriftCircleOnTrack::associatedSurface() const
-{
- assert(0!=detectorElement());
- if ( hasSaggedSurface() ) return *m_saggedSurface;
+inline const Trk::StraightLineSurface& MdtDriftCircleOnTrack::associatedSurface() const {
return detectorElement()->surface(identify());
}
-inline void MdtDriftCircleOnTrack::setLocalParameters(const Trk::LocalParameters& locParams)
-{
- // update base class values
- m_localParams = locParams;
-}
-
-inline void MdtDriftCircleOnTrack::setErrorStrategy(const MuonDriftCircleErrorStrategy* strategy)
-{
- m_errorStrategy=*strategy;
-}
-
-inline void MdtDriftCircleOnTrack::setValues(const Trk::TrkDetElementBase* detEl,
- const Trk::PrepRawData* /*prd*/)
-{
- m_detEl = dynamic_cast< const MuonGM::MdtReadoutElement* >(detEl);
- //m_rio = dynamic_cast< const MdtPrepData* >(prd);
- assert (m_detEl!=0);
-}
-
-inline bool MdtDriftCircleOnTrack::hasSaggedSurface() const
-{
- if (m_saggedSurface==0) return false;
- return true;
-}
-
-
-inline double MdtDriftCircleOnTrack::driftRadius() const
-{
+inline void MdtDriftCircleOnTrack::setLocalParameters(const Trk::LocalParameters& locParams) { m_localParams = locParams; }
+inline void MdtDriftCircleOnTrack::setErrorStrategy(const MuonDriftCircleErrorStrategy& strategy) { m_errorStrategy= strategy; }
+inline double MdtDriftCircleOnTrack::driftRadius() const {
return localParameters().get(Trk::driftRadius);
}
-
-inline double MdtDriftCircleOnTrack::driftTime() const
-{
- return m_driftTime;
-}
-
-inline float MdtDriftCircleOnTrack::positionAlongWire() const
-{
- return m_positionAlongWire;
-}
-
-inline float MdtDriftCircleOnTrack::localAngle() const
-{
- return m_localAngle;
-}
-
+inline double MdtDriftCircleOnTrack::driftTime() const { return m_driftTime; }
+inline double MdtDriftCircleOnTrack::positionAlongWire() const { return m_positionAlongWire; }
+inline double MdtDriftCircleOnTrack::localAngle() const { return m_localAngle; }
inline const MuonDriftCircleErrorStrategy& MdtDriftCircleOnTrack::errorStrategy() const {
return m_errorStrategy;
}
+inline void MdtDriftCircleOnTrack::setValues(const Trk::TrkDetElementBase* detEl,
+ const Trk::PrepRawData* prd) {
+
+ m_detEl = dynamic_cast<const MuonGM::MdtReadoutElement*>(detEl);
+ if (!prd) return;
+ if (!prd->type(Trk::PrepRawDataType::MdtPrepData)) {
+ throw std::runtime_error("No Mdt prd given to MdtDriftCircleOnTrack");
+ }
+ m_rio.setElement(static_cast<const MdtPrepData*>(prd));
+}
}
diff --git a/MuonSpectrometer/MuonReconstruction/MuonRecEvent/MuonRIO_OnTrack/MuonRIO_OnTrack/MuonDriftCircleErrorStrategy.h b/MuonSpectrometer/MuonReconstruction/MuonRecEvent/MuonRIO_OnTrack/MuonRIO_OnTrack/MuonDriftCircleErrorStrategy.h
index 15bf1f7bbce..77eda2960d4 100644
--- a/MuonSpectrometer/MuonReconstruction/MuonRecEvent/MuonRIO_OnTrack/MuonRIO_OnTrack/MuonDriftCircleErrorStrategy.h
+++ b/MuonSpectrometer/MuonReconstruction/MuonRecEvent/MuonRIO_OnTrack/MuonRIO_OnTrack/MuonDriftCircleErrorStrategy.h
@@ -33,8 +33,8 @@ public:
Segment, //!< Treating a segment or a track
FirstCalibWindowBit //!< First bit recording the calibration configuration
};
- static const std::size_t nCalibWindowBits = 4; //!< Allows up to 16 configurations to be recorded
-
+ static constexpr std::size_t nCalibWindowBits = 4; //!< Allows up to 16 configurations to be recorded
+ MuonDriftCircleErrorStrategy() = default;
MuonDriftCircleErrorStrategy(const MuonDriftCircleErrorStrategyInput& bits):m_bits(bits){} //!< first 3 bits are Strategy, then come CreationParameter, last four are calib window bits
void setStrategy(Strategy); //!< Select the strategy to be used - only one can be set at a time
void setParameter(CreationParameter, bool value);
@@ -47,7 +47,7 @@ public:
const MuonDriftCircleErrorStrategyInput getBits() const { return m_bits; }
private:
- MuonDriftCircleErrorStrategyInput m_bits; //!< 0,1,2 are reserved for Strategy, 3-16 are Creation parameters, 17-20 are calib window bits
+ MuonDriftCircleErrorStrategyInput m_bits{}; //!< 0,1,2 are reserved for Strategy, 3-16 are Creation parameters, 17-20 are calib window bits
};
}
diff --git a/MuonSpectrometer/MuonReconstruction/MuonRecEvent/MuonRIO_OnTrack/src/MdtDriftCircleOnTrack.cxx b/MuonSpectrometer/MuonReconstruction/MuonRecEvent/MuonRIO_OnTrack/src/MdtDriftCircleOnTrack.cxx
index e0b3350d3a9..856ac77ef06 100644
--- a/MuonSpectrometer/MuonReconstruction/MuonRecEvent/MuonRIO_OnTrack/src/MdtDriftCircleOnTrack.cxx
+++ b/MuonSpectrometer/MuonReconstruction/MuonRecEvent/MuonRIO_OnTrack/src/MdtDriftCircleOnTrack.cxx
@@ -1,17 +1,6 @@
/*
Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
*/
-
-///////////////////////////////////////////////////////////////////
-// MdtDriftCircleOnTrack.cxx
-// Implementation file for class MdtDriftCircleOnTrack
-///////////////////////////////////////////////////////////////////
-// (c) ATLAS Detector software
-///////////////////////////////////////////////////////////////////
-// Version 1.0 06/07/2004 Ketevi A. Assamagan
-// adapted from Veronique Boisvert
-///////////////////////////////////////////////////////////////////
-
#include "TrkRIO_OnTrack/RIO_OnTrack.h"
#include "MuonRIO_OnTrack/MdtDriftCircleOnTrack.h"
#include "TrkEventPrimitives/LocalParameters.h"
@@ -23,243 +12,129 @@
// Full Constructor :
-Muon::MdtDriftCircleOnTrack::MdtDriftCircleOnTrack(
- const Muon::MdtPrepData* RIO,
- const Trk::LocalParameters& locPos,
- const Amg::MatrixX& errDriftRadius,
- const double driftTime,
- const Trk::DriftCircleStatus status,
- const Amg::Vector3D& predictedTrackDirection,
- double positionAlongWire,
- const MuonDriftCircleErrorStrategy& errorStrategy,
- const Trk::StraightLineSurface* surface)
- :
- RIO_OnTrack( locPos, errDriftRadius, RIO->identify() ), //call base class constructor
- m_status(status),
- m_globalPosition(),
- m_saggedSurface(surface),
- m_detEl( RIO->detectorElement() ),
- m_localAngle(0.0),
- m_positionAlongWire(positionAlongWire),
- m_driftTime(driftTime),
- m_errorStrategy(errorStrategy)
-{
- assert(RIO!=0); //probably redundant because used to set m_detEl
- assert(m_status!=Trk::UNDECIDED); // use of this constructor implies that the side is decided
-
- const Trk::StraightLineSurface* slsf = dynamic_cast<const Trk::StraightLineSurface*>(&(m_detEl->surface(RIO->identify())));
-
- if (slsf){
- m_globalPosition.store(std::make_unique<const Amg::Vector3D>(
- slsf->localToGlobal(locPos, predictedTrackDirection, positionAlongWire)));
- }
- Amg::Vector3D loc_gDirection = predictedTrackDirection;
+namespace Muon{
+MdtDriftCircleOnTrack::MdtDriftCircleOnTrack(const MdtPrepData* RIO,
+ const Trk::LocalParameters& locPos,
+ const Amg::MatrixX& errDriftRadius,
+ const double driftTime,
+ const Trk::DriftCircleStatus status,
+ const Amg::Vector3D& predictedTrackDirection,
+ const double positionAlongWire,
+ const MuonDriftCircleErrorStrategy& errorStrategy) :
+ Trk::RIO_OnTrack{locPos, errDriftRadius, RIO->identify()},
+ m_status{status},
+ m_positionAlongWire{positionAlongWire},
+ m_driftTime{driftTime},
+ m_errorStrategy{errorStrategy} {
+
+ assert(m_status!=Trk::UNDECIDED); // use of this constructor implies that the side is decided
- //scaling the direction with drift radius
- if(driftRadius() !=0.) {
- // Set loc_gDirection's perpendicular distance equal to driftRadius
- Amg::setPerp(loc_gDirection,driftRadius());
- float ratio = loc_gDirection.x()/driftRadius();
- float calc_angle = (ratio >= 1.) ? 0. : std::acos(ratio);
- m_localAngle = (loc_gDirection.y()<0.) ? 2*M_PI - calc_angle : calc_angle;
- }
- m_rio.setElement(RIO);
+ m_rio.setElement(RIO);
+ m_globalPosition.store(std::make_unique<Amg::Vector3D>(associatedSurface().localToGlobal(locPos, predictedTrackDirection, positionAlongWire)));
+
+ Amg::Vector3D loc_gDirection = predictedTrackDirection;
+
+ ///scaling the direction with drift radius
+ if(driftRadius() > std::numeric_limits<float>::epsilon()) {
+ // Set loc_gDirection's perpendicular distance equal to driftRadius
+ Amg::setPerp(loc_gDirection, std::abs(driftRadius()));
+ const double ratio = loc_gDirection.x() / std::abs(driftRadius());
+ const double calc_angle = std::abs(ratio) >= 1. ? M_PI * (ratio < 0.) : std::acos(ratio);
+ m_localAngle = (loc_gDirection.y()<0.) ? 2*M_PI - calc_angle : calc_angle;
+ }
}
// Partial Constructor :
-Muon::MdtDriftCircleOnTrack::MdtDriftCircleOnTrack(
- const Muon::MdtPrepData* RIO,
- const Trk::LocalParameters& locPos,
- const Amg::MatrixX& errDriftRadius,
- const double driftTime,
- const Trk::DriftCircleStatus status,
- double positionAlongWire,
- const MuonDriftCircleErrorStrategy& errorStrategy,
- const Trk::StraightLineSurface* surface)
- :
- RIO_OnTrack( locPos, errDriftRadius, RIO->identify() ), //call base class constructor
- m_status(status),
- m_globalPosition(),
- m_saggedSurface(surface),
- m_detEl( RIO->detectorElement() ),
- m_localAngle(99.0), // TODO - Remove dummy value,
- m_positionAlongWire(positionAlongWire),
- m_driftTime(driftTime),
- m_errorStrategy(errorStrategy)
-{
- assert(RIO!=0); //probably redundant because used to set m_detEl
+MdtDriftCircleOnTrack::MdtDriftCircleOnTrack(const MdtPrepData* RIO,
+ const Trk::LocalParameters& locPos,
+ const Amg::MatrixX& errDriftRadius,
+ const double driftTime,
+ const Trk::DriftCircleStatus status,
+ const double positionAlongWire,
+ const MuonDriftCircleErrorStrategy& errorStrategy) :
+ Trk::RIO_OnTrack{locPos, errDriftRadius, RIO->identify()},
+ m_status{status},
+ m_positionAlongWire{positionAlongWire},
+ m_driftTime{driftTime},
+ m_errorStrategy{errorStrategy} {
assert(m_status!=Trk::DECIDED); // use of this constructor implies that the side is not decided
m_rio.setElement(RIO);
}
-
-Muon::MdtDriftCircleOnTrack::MdtDriftCircleOnTrack(
- const ElementLinkToIDC_MDT_Container& RIO,
- const Trk::LocalParameters& locPos,
- const Amg::MatrixX& errDriftRadius,
- const Identifier& id,
- const MuonGM::MdtReadoutElement* detEl,
- const double driftTime,
- const Trk::DriftCircleStatus status,
- double positionAlongWire,
- float localAngle,
- const MuonDriftCircleErrorStrategy& errorStrategy,
- const Trk::StraightLineSurface* surface)
- :
- RIO_OnTrack( locPos, errDriftRadius, id ), //call base class constructor
- m_status(status),
- m_rio(RIO),
- m_globalPosition(),
- m_saggedSurface(surface),
- m_detEl( detEl ),
- m_localAngle(localAngle),
- m_positionAlongWire(positionAlongWire),
- m_driftTime(driftTime),
- m_errorStrategy(errorStrategy)
-{
+
+MdtDriftCircleOnTrack::MdtDriftCircleOnTrack(const MdtDriftCircleOnTrack & other):
+ Trk::RIO_OnTrack{ other },
+ m_status{other.m_status},
+ m_rio{other.m_rio},
+ m_localAngle{other.m_localAngle},
+ m_positionAlongWire{other.m_positionAlongWire},
+ m_driftTime{other.m_driftTime},
+ m_errorStrategy{other.m_errorStrategy},
+ m_detEl{other.m_detEl} {
}
-
-// Destructor:
- Muon::MdtDriftCircleOnTrack::~MdtDriftCircleOnTrack()
- {
- // m_rio is owned by SG and so is not deleted.
- // m_detEl is owned by MuonGeoModel and so is not deleted.
- delete m_saggedSurface;
- }
-
-// default constructor:
-Muon::MdtDriftCircleOnTrack::MdtDriftCircleOnTrack()
- :
- RIO_OnTrack(),
- m_status(Trk::UNDECIDED),
- m_rio(),
- m_globalPosition(),
- m_saggedSurface(nullptr),
- m_detEl(nullptr),
- m_localAngle(0.0),
- m_positionAlongWire(0.0),
- m_driftTime(0),
- m_errorStrategy(0)
-{
+MdtDriftCircleOnTrack::MdtDriftCircleOnTrack(const ElementLinkToIDC_MDT_Container& RIO,
+ const Trk::LocalParameters& locPos,
+ const Amg::MatrixX& errDriftRadius,
+ const Identifier& id,
+ const MuonGM::MdtReadoutElement* detEl,
+ const double driftTime,
+ const Trk::DriftCircleStatus status,
+ const double positionAlongWire,
+ const double localAngle,
+ const MuonDriftCircleErrorStrategy& errorStrategy):
+ Trk::RIO_OnTrack{locPos, errDriftRadius, id},
+ m_status{status},
+ m_rio{RIO},
+ m_localAngle{localAngle},
+ m_positionAlongWire{positionAlongWire},
+ m_driftTime{driftTime},
+ m_errorStrategy{errorStrategy},
+ m_detEl{detEl} {}
+
+
+MdtDriftCircleOnTrack & MdtDriftCircleOnTrack::operator=(const MdtDriftCircleOnTrack & other) {
+ if (&other != this){
+ static_cast<Trk::RIO_OnTrack&>(*this) = other;
+ m_status = other.m_status;
+ m_rio = other.m_rio;
+ m_localAngle = other.m_localAngle;
+ m_driftTime = other.m_driftTime;
+ m_errorStrategy = other.m_errorStrategy;
+ m_positionAlongWire = other.m_positionAlongWire;
+ m_detEl = other.m_detEl;
+ m_globalPosition.release();
+ }
+ return *this;
}
-
-//copy constructor:
-Muon::MdtDriftCircleOnTrack::MdtDriftCircleOnTrack( const Muon::MdtDriftCircleOnTrack& rot)
- :
- RIO_OnTrack(rot),
- m_status(rot.m_status),
- m_rio(rot.m_rio),
- m_globalPosition(),
- m_saggedSurface(nullptr),
- m_detEl(rot.m_detEl),
- m_localAngle(rot.m_localAngle),
- m_positionAlongWire(rot.m_positionAlongWire),
- m_driftTime(rot.m_driftTime),
- m_errorStrategy(rot.m_errorStrategy)
-{
- if ( rot.m_globalPosition ) m_globalPosition.store(std::make_unique<const Amg::Vector3D>(*rot.m_globalPosition));
- if ( rot.m_saggedSurface!=nullptr ) m_saggedSurface= new Trk::StraightLineSurface( *(rot.m_saggedSurface) );
-}
-
-//assignment operator:
-Muon::MdtDriftCircleOnTrack& Muon::MdtDriftCircleOnTrack::operator=( const Muon::MdtDriftCircleOnTrack& rot)
-{
- if ( &rot != this)
- {
- Trk::RIO_OnTrack::operator=(rot);//base class ass. op.
- if (rot.m_globalPosition) m_globalPosition.store(std::make_unique<const Amg::Vector3D>(*rot.m_globalPosition));
- else if (m_globalPosition) m_globalPosition.release().reset();
- delete m_saggedSurface;
- if( rot.m_saggedSurface!=nullptr )
- m_saggedSurface= new Trk::StraightLineSurface( *(rot.m_saggedSurface) );
- else
- m_saggedSurface=nullptr;
- m_driftTime = rot.m_driftTime;
- m_status = rot.m_status;
- m_rio = rot.m_rio;
- m_detEl = rot.m_detEl;
- m_localAngle = rot.m_localAngle;
- m_positionAlongWire = rot.m_positionAlongWire;
- m_errorStrategy= rot.m_errorStrategy;
- }
- return *this;
-}
-
-Muon::MdtDriftCircleOnTrack&
-Muon::MdtDriftCircleOnTrack::operator=(
- Muon::MdtDriftCircleOnTrack&& rot) noexcept
-{
- if (&rot != this) {
- Trk::RIO_OnTrack::operator=(rot); // base class ass. op.
- m_globalPosition = std::move(rot.m_globalPosition);
-
- delete m_saggedSurface;
- m_saggedSurface = rot.m_saggedSurface;
- rot.m_saggedSurface = nullptr;
-
- m_driftTime = rot.m_driftTime;
- m_status = rot.m_status;
- m_rio = rot.m_rio;
- m_detEl = rot.m_detEl;
- m_localAngle = rot.m_localAngle;
- m_positionAlongWire = rot.m_positionAlongWire;
- m_errorStrategy = rot.m_errorStrategy;
- }
- return *this;
-}
-
-const Amg::Vector3D& Muon::MdtDriftCircleOnTrack::globalPosition() const
-{
- if (not m_globalPosition){
+const Amg::Vector3D& MdtDriftCircleOnTrack::globalPosition() const {
+ if (!m_globalPosition) {
if (side()==Trk::NONE) {
// side not defined, so we cannot determine the global position better than the position along the wire
- HepGeom::Point3D<double> loc3Dframe(0., 0., m_positionAlongWire);
- setGlobalPosition(loc3Dframe);
+ Amg::Vector3D loc3Dframe = m_positionAlongWire * Amg::Vector3D::UnitZ();
+ setGlobalPosition(std::move(loc3Dframe));
} else {
// get global position where track and drift radius intersect.
double x = driftRadius()*std::sin(m_localAngle);
double y = driftRadius()*std::cos(m_localAngle);
- HepGeom::Point3D<double> loc3Dframe(x, y, m_positionAlongWire);
- setGlobalPosition(loc3Dframe);
+ Amg::Vector3D loc3Dframe(x, y, m_positionAlongWire);
+ setGlobalPosition(std::move(loc3Dframe));
}
}
return *m_globalPosition;
}
-void Muon::MdtDriftCircleOnTrack::setGlobalPosition(HepGeom::Point3D<double>& loc3Dframe) const
-{
- if (nullptr!=m_saggedSurface){
- Amg::Vector3D tempFrame(loc3Dframe.x(), loc3Dframe.y(), loc3Dframe.z());
- m_globalPosition.set(std::make_unique<const Amg::Vector3D>(m_saggedSurface->transform() * tempFrame));
- } else {
- // hack because MdtReadoutElement only returns generic pointer.
- const Trk::StraightLineSurface* slsf = dynamic_cast<const Trk::StraightLineSurface*>( &(associatedSurface()) );
- if (slsf) {
- Amg::Vector3D tempFrame(loc3Dframe.x(), loc3Dframe.y(), loc3Dframe.z());
- m_globalPosition.set(std::make_unique<const Amg::Vector3D>(slsf->transform() * tempFrame));
- }else{
- throw GaudiException( "Dynamic_cast to StraightLineSurface failed!",
- "MdtDriftCircleOnTrack::setGlobalPosition()",
- StatusCode::FAILURE);
- }
- }
+void MdtDriftCircleOnTrack::setGlobalPosition(Amg::Vector3D&& loc3Dframe) const {
+ Amg::Vector3D globPos = associatedSurface().transform() * loc3Dframe;
+ m_globalPosition.set(std::make_unique<Amg::Vector3D>(std::move(globPos)));
}
-MsgStream& Muon::MdtDriftCircleOnTrack::dump( MsgStream& stream) const
+MsgStream& MdtDriftCircleOnTrack::dump( MsgStream& stream) const
{
stream << MSG::INFO<<"MdtDriftCircleOnTrack {"<<std::endl;
Trk::RIO_OnTrack::dump(stream);
stream << "DriftTime: "<<m_driftTime<<std::endl;
stream << "Status: "<<m_status<<std::endl;
- stream << "Global position (x,y,z) = (";
- stream <<this->globalPosition().x()<<", "
- <<this->globalPosition().y()<<", "
- <<this->globalPosition().z()<<")"<<std::endl;
-
- if (m_saggedSurface!=nullptr) {
- stream << "Sagged surface: "<<(*m_saggedSurface)<<std::endl;
- }else{
- stream << "Sagged surface: NONE "<<std::endl;
- }
+ stream << "Global position (x,y,z) = ";
+ stream << Amg::toString(globalPosition(),2)<<std::endl;
stream << "Position along wire: "<<positionAlongWire()<<", \tlocal angle="<<localAngle()<<std::endl;
stream << "Creation strategy: "<<m_errorStrategy;
@@ -267,31 +142,18 @@ MsgStream& Muon::MdtDriftCircleOnTrack::dump( MsgStream& stream) const
return stream;
}
-std::ostream& Muon::MdtDriftCircleOnTrack::dump( std::ostream& stream) const
+std::ostream& MdtDriftCircleOnTrack::dump( std::ostream& stream) const
{
stream << "MdtDriftCircleOnTrack {"<<std::endl;
Trk::RIO_OnTrack::dump(stream);
stream << "DriftTime: "<<m_driftTime<<std::endl;
stream << "Status: "<<m_status<<std::endl;
- //stream << "Global position (x,y,z) = (";
- // if ( &(this->globalPosition() )!=0 ){
- // stream <<this->globalPosition().x()<<", "
- // <<this->globalPosition().y()<<", "
- // <<this->globalPosition().z()<<")"<<std::endl;
- // } else {
- // stream<<"NULL!), "<<std::endl;
- // }
-
- if (m_saggedSurface!=nullptr) {
- stream << "Sagged surface: "<<(*m_saggedSurface)<<std::endl;
- }else{
- stream << "Sagged surface: NONE "<<std::endl;
- }
+
stream << "Position along wire: "<<positionAlongWire()<<", \tlocal angle="<<localAngle()<<std::endl;
// stream << "Creation strategy: "<<m_errorStrategy; //FIXME!
stream<<"}"<<std::endl;
return stream;
}
-
+}
diff --git a/MuonSpectrometer/MuonReconstruction/MuonRecExample/python/MuonRecTools.py b/MuonSpectrometer/MuonReconstruction/MuonRecExample/python/MuonRecTools.py
index aadd2296157..d212fcac7dc 100644
--- a/MuonSpectrometer/MuonReconstruction/MuonRecExample/python/MuonRecTools.py
+++ b/MuonSpectrometer/MuonReconstruction/MuonRecExample/python/MuonRecTools.py
@@ -76,38 +76,41 @@ def MdtDriftCircleOnTrackCreator(name="MdtDriftCircleOnTrackCreator",**kwargs):
MuonCalibConfig.setupMdtCondDB()
from MuonCnvExample.MuonCalibFlags import mdtCalibFlags
mdtCalibFlags.setDefaults()
-
- kwargs.setdefault("DoMagneticFieldCorrection", mdtCalibFlags.correctMdtRtForBField())
- kwargs.setdefault("DoWireSag", muonRecFlags.useWireSagCorrections())
- kwargs.setdefault("DoSlewingCorrection", mdtCalibFlags.correctMdtRtForTimeSlewing())
- kwargs.setdefault("CalibrationTool", MuonCalibConfig.MdtCalibrationTool())
- kwargs.setdefault("CalibrationDbTool", MuonCalibConfig.MdtCalibrationDbTool())
-
- if beamFlags.beamType() == 'cosmics' or beamFlags.beamType() == 'singlebeam' :
- kwargs.setdefault("DoTofCorrection", False)
- kwargs.setdefault("ApplyToF", False)
+
+ margs = dict()
+ margs.setdefault("DoMagneticFieldCorrection", mdtCalibFlags.correctMdtRtForBField())
+ margs.setdefault("DoWireSagCorrection", muonRecFlags.useWireSagCorrections())
+ margs.setdefault("DoSlewingCorrection", mdtCalibFlags.correctMdtRtForTimeSlewing())
+
+
+ if beamFlags.beamType() == 'cosmics' or beamFlags.beamType() == 'singlebeam':
+ margs.setdefault("DoTofCorrection", False)
kwargs.setdefault("DoFixedError", True)
kwargs.setdefault("TimingMode", 1)
kwargs.setdefault("UseParametrisedError", True)
+ kwargs.setdefault("ApplyToF", False)
+
else: # collisions simulation/data settings
- kwargs.setdefault("DoTofCorrection", True)
+ margs.setdefault("DoTofCorrection", True)
kwargs.setdefault("DoFixedError", False)
kwargs.setdefault("DoErrorScaling", False)
- kwargs.setdefault("TimeWindowSetting", mdtCalibWindowNumber('Collision_data')) # MJW: should this be Collision_G4 ???
+ margs.setdefault("TimeWindowSetting", mdtCalibWindowNumber('Collision_data')) # MJW: should this be Collision_G4 ???
kwargs.setdefault("UseParametrisedError", False)
if globalflags.DataSource() == 'data': # collisions real data or simulated first data
kwargs.setdefault("CreateTubeHit", True) # BroadErrors
kwargs.setdefault("UseLooseErrors", muonRecFlags.useLooseErrorTuning()) # LooseErrors on data
-
- if globalflags.DataSource() == 'data':
- kwargs.setdefault("IsMC", False)
- else:
- kwargs.setdefault("IsMC", True)
-
- if ConfigFlags.Muon.MuonTrigger:
- kwargs.setdefault("doMDT", True)
-
+
+ calibSettings = ["DoTofCorrection", "TimeWindowSetting"]
+ for cSett in calibSettings:
+ if cSett in kwargs:
+ margs[cSett] = kwargs.pop(cSett)
+
+ kwargs.setdefault("CalibrationTool", getPrivateToolClone (name+"MdtCalibTool",
+ MuonCalibConfig.MdtCalibrationTool(), **margs))
+
+
+ kwargs.setdefault("IsMC", globalflags.DataSource() != 'data')
return CfgMgr.Muon__MdtDriftCircleOnTrackCreator(name, WasConfigured=True, **kwargs)
# end of factory function MdtDriftCircleOnTrackCreator
@@ -330,7 +333,6 @@ def MdtSegmentT0Fitter(name="MdtSegmentT0Fitter",**kwargs):
from MuonRecExample import MuonAlignConfig # noqa: F401
from MuonCnvExample import MuonCalibConfig # noqa: F401
MuonCalibConfig.setupMdtCondDB()
- kwargs.setdefault("CalibrationDbTool", MuonCalibConfig.MdtCalibrationDbTool())
### Enable floating of segments in the case of cosmic reconstruction
kwargs.setdefault("FloatSegDirection", beamFlags.beamType() != 'collisions')
return CfgMgr.TrkDriftCircleMath__MdtSegmentT0Fitter(name,**kwargs)
diff --git a/MuonSpectrometer/MuonReconstruction/MuonRecTools/MuonRecToolInterfaces/MuonRecToolInterfaces/IMdtDriftCircleOnTrackCreator.h b/MuonSpectrometer/MuonReconstruction/MuonRecTools/MuonRecToolInterfaces/MuonRecToolInterfaces/IMdtDriftCircleOnTrackCreator.h
index f0d801da434..bf81c343519 100755
--- a/MuonSpectrometer/MuonReconstruction/MuonRecTools/MuonRecToolInterfaces/MuonRecToolInterfaces/IMdtDriftCircleOnTrackCreator.h
+++ b/MuonSpectrometer/MuonReconstruction/MuonRecTools/MuonRecToolInterfaces/MuonRecToolInterfaces/IMdtDriftCircleOnTrackCreator.h
@@ -1,5 +1,5 @@
/*
- Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+ Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
*/
#ifndef MUON_IMDTDRIFTCIRCLEONTRACKCREATOR_H
@@ -13,8 +13,7 @@
#include "TrkEventPrimitives/DriftCircleSide.h"
#include "TrkToolInterfaces/IRIO_OnTrackCreator.h"
-static const InterfaceID IID_IMdtDriftCircleOnTrackCreator("Muon::IMdtDriftCircleOnTrackCreator", 1, 0);
-
+#include <memory>
namespace Muon {
class MdtPrepData;
@@ -22,10 +21,12 @@ namespace Muon {
/** @brief Interface for tools calibrating MdtPrepData, turning them into Muon::MdtDriftCircleOnTrack object.
The interface inherits from Trk::IRIO_OnTrackCreator.
*/
- class IMdtDriftCircleOnTrackCreator : virtual public Trk::IRIO_OnTrackCreator {
+ class IMdtDriftCircleOnTrackCreator : public Trk::IRIO_OnTrackCreator {
public:
- static const InterfaceID& interfaceID();
-
+ using MdtRotPtr = MdtDriftCircleOnTrack*;
+ /** @brief Default desructor*/
+ virtual ~IMdtDriftCircleOnTrackCreator() = default;
+ DeclareInterfaceID(Muon::IMdtDriftCircleOnTrackCreator, 1, 0);
/** @brief Calibrate a MdtPrepData object. The result is stored in a new MdtDriftCircleOnTrack object.
Included calibrations:
- Conversion t->r using MdtCalibrationSvc
@@ -36,9 +37,13 @@ namespace Muon {
@param strategy optional drift circle error strategy to override the default
@return Fully calibrated MdtDriftCircleOnTrack (the user must delete this object when it is no longer needed).
*/
- virtual MdtDriftCircleOnTrack* createRIO_OnTrack(const MdtPrepData& DC, const Amg::Vector3D& GP, const Amg::Vector3D* GD = 0,
- float t0Shift = 0, const MuonDriftCircleErrorStrategy* strategy = 0,
- const double beta = 1, const double tTrack = 0) const = 0;
+ virtual MdtRotPtr createRIO_OnTrack(const MdtPrepData& DC,
+ const Amg::Vector3D& GP,
+ const Amg::Vector3D* GD = nullptr,
+ const double t0Shift = 0,
+ const MuonDriftCircleErrorStrategy* strategy = nullptr,
+ const double beta = 1,
+ const double tTrack = 0) const = 0;
/** @brief Update of the sign of the drift radius.
@param DCT reference to the Muon::MdtDriftCircleOnTrack of which the sign should be updated.
@@ -52,17 +57,9 @@ namespace Muon {
@param strategy optional drift circle error strategy to override the default
@return New ROT with updated error. (the user must delete this object when it is no longer needed).
*/
- virtual MdtDriftCircleOnTrack* updateError(const MdtDriftCircleOnTrack& DCT, const Trk::TrackParameters* pars = 0,
- const MuonDriftCircleErrorStrategy* strategy = 0) const = 0;
-
- /** @brief Update error of a ROT without changing the drift radius
- @param DCT reference to the Muon::MdtDriftCircleOnTrack of which the sign should be updated.
- @param tp Reference to the extrapolated/predicted TrackParameters at this MdtPrepData (not used)
- @param errorlist holds the identifier of the chamber/det element and the error to be applied on the DCTs inside
- @return New ROT with updated error. (the user must delete this object when it is no longer needed).
- */
- virtual MdtDriftCircleOnTrack* updateErrorExternal(const MdtDriftCircleOnTrack& DCT, const Trk::TrackParameters* pars = 0,
- const std::map<Identifier, double>* errorlist = 0) const = 0;
+ virtual MdtRotPtr updateError(const MdtDriftCircleOnTrack& DCT,
+ const Trk::TrackParameters* pars = nullptr,
+ const MuonDriftCircleErrorStrategy* strategy = nullptr) const = 0;
/** @brief Returns calibrated MdtDriftCircleOnTrack.
Overrides the IRIO_OnTrackCreator method to add an error strategy object.
@@ -70,23 +67,16 @@ namespace Muon {
@param tp Reference to the extrapolated/predicted TrackParameters at this MdtPrepData
@return calibrated MdtDriftCircleOnTrack. Memory management is passed to user.
*/
- virtual MdtDriftCircleOnTrack* correct(const Trk::PrepRawData& prd, const Trk::TrackParameters& tp,
- const MuonDriftCircleErrorStrategy* strategy, const double beta = 1,
- const double tTrack = 0) const = 0;
-
- /** @brief Keep base class version of correct for use with default error strategy object */
- virtual MdtDriftCircleOnTrack* correct(const Trk::PrepRawData& prd, const Trk::TrackParameters& tp) const = 0;
-
- /** @brief Returns the MdtDriftCircleStatus for a Muon::MdtDriftCircleOnTrack by comparing its time with the range of the RT
- * relation. */
- virtual MdtDriftCircleStatus driftCircleStatus(const MdtDriftCircleOnTrack& DCT) const = 0;
+ using Trk::IRIO_OnTrackCreator::correct;
+ virtual MdtRotPtr correct(const MdtPrepData& prd,
+ const Trk::TrackParameters& tp,
+ const MuonDriftCircleErrorStrategy* strategy,
+ const double beta = 1,
+ const double tTrack = 0) const = 0;
/** @brief Returns the default error strategy object */
virtual const MuonDriftCircleErrorStrategy& errorStrategy() const = 0;
};
-
- inline const InterfaceID& IMdtDriftCircleOnTrackCreator::interfaceID() { return IID_IMdtDriftCircleOnTrackCreator; }
-
} // namespace Muon
#endif // MUON_IMDTDRIFTCIRCLEONTRACKCREATOR_H
diff --git a/MuonSpectrometer/MuonReconstruction/MuonSegmentMakers/MuonSegmentMakerTools/MdtSegmentT0Fitter/MdtSegmentT0Fitter/MdtSegmentT0Fitter.h b/MuonSpectrometer/MuonReconstruction/MuonSegmentMakers/MuonSegmentMakerTools/MdtSegmentT0Fitter/MdtSegmentT0Fitter/MdtSegmentT0Fitter.h
index 913f85b9e60..2db01deb659 100755
--- a/MuonSpectrometer/MuonReconstruction/MuonSegmentMakers/MuonSegmentMakerTools/MdtSegmentT0Fitter/MdtSegmentT0Fitter/MdtSegmentT0Fitter.h
+++ b/MuonSpectrometer/MuonReconstruction/MuonSegmentMakers/MuonSegmentMakerTools/MdtSegmentT0Fitter/MdtSegmentT0Fitter/MdtSegmentT0Fitter.h
@@ -1,5 +1,5 @@
/*
- Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+ Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
*/
// Fitting for in situ calibration of segments
@@ -13,7 +13,8 @@
#include "TrkDriftCircleMath/DCSLFitter.h"
#include "MuonSegmentMakerInterfaces/IDCSLFitProvider.h"
-#include "MdtCalibSvc/MdtCalibrationDbTool.h"
+#include "MdtCalibData/MdtCalibDataContainer.h"
+#include "StoreGate/ReadCondHandleKey.h"
#include <atomic>
#include <vector>
@@ -35,8 +36,12 @@ namespace TrkDriftCircleMath {
virtual const DCSLFitter* getFitter() const override { return this; }
private:
- ToolHandle<MdtCalibrationDbTool> m_calibrationDbTool{this,"CalibrationDbTool","MdtCalibrationDbTool"};
+
+ SG::ReadCondHandleKey<MuonCalib::MdtCalibDataContainer> m_calibDbKey{this, "CalibDataKey", "MdtCalibConstants",
+ "Conditions object containing the calibrations"};
+ ServiceHandle<Muon::IMuonIdHelperSvc> m_idHelperSvc{this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"};
+
Gaudi::Property<bool> m_rejectWeakTopologies{this,"RejectWeakTopologies",true,"reject topolgies that do not have at least one +- combination in one multilayer"};
Gaudi::Property<bool> m_scaleErrors{this,"RescaleErrors",true,"rescale errors in fit"};
Gaudi::Property<bool> m_propagateErrors{this,"PropagateErrors",true,"propagate errors"};
diff --git a/MuonSpectrometer/MuonReconstruction/MuonSegmentMakers/MuonSegmentMakerTools/MdtSegmentT0Fitter/src/MdtSegmentT0Fitter.cxx b/MuonSpectrometer/MuonReconstruction/MuonSegmentMakers/MuonSegmentMakerTools/MdtSegmentT0Fitter/src/MdtSegmentT0Fitter.cxx
index 42db8f4f967..ee19c20a7da 100755
--- a/MuonSpectrometer/MuonReconstruction/MuonSegmentMakers/MuonSegmentMakerTools/MdtSegmentT0Fitter/src/MdtSegmentT0Fitter.cxx
+++ b/MuonSpectrometer/MuonReconstruction/MuonSegmentMakers/MuonSegmentMakerTools/MdtSegmentT0Fitter/src/MdtSegmentT0Fitter.cxx
@@ -4,9 +4,9 @@
#include "MdtSegmentT0Fitter/MdtSegmentT0Fitter.h"
-#include "MdtCalibSvc/MdtCalibrationSvcSettings.h"
#include "MuonReadoutGeometry/MdtReadoutElement.h"
#include "MuonReadoutGeometry/MuonDetectorManager.h"
+#include "StoreGate/ReadCondHandle.h"
#include "MdtCalibData/IRtRelation.h"
#include "MdtCalibData/IRtResolution.h"
@@ -171,7 +171,7 @@ namespace TrkDriftCircleMath {
}
StatusCode MdtSegmentT0Fitter::initialize() {
- ATH_CHECK(m_calibrationDbTool.retrieve());
+ ATH_CHECK(m_calibDbKey.initialize());
return StatusCode::SUCCESS;
}
@@ -191,9 +191,26 @@ namespace TrkDriftCircleMath {
bool MdtSegmentT0Fitter::fit( Segment& result, const Line& line, const DCOnTrackVec& dcs, const HitSelection& selection, double t0Seed ) const {
++m_ntotalCalls;
-
+ const MdtIdHelper& id_helper{m_idHelperSvc->mdtIdHelper()};
ATH_MSG_DEBUG("New seg: ");
-
+ const EventContext& ctx{Gaudi::Hive::currentContext()};
+ SG::ReadCondHandle<MuonCalib::MdtCalibDataContainer> calibData{m_calibDbKey, ctx};
+ if (!calibData.isValid()) {
+ ATH_MSG_FATAL("Failed to retrieve Mdt calibration object "<<m_calibDbKey.fullKey());
+ return false;
+ }
+ std::array<const MuonCalib::MdtRtRelation*, 2> rtRelations{};
+ {
+ unsigned int nRel{0};
+ for (unsigned int i = 0; i < dcs.size() ; ++i) {
+ const Identifier id = dcs[i].rot()->identify();
+ const int mlIdx = id_helper.multilayer(id) -1;
+ if (rtRelations[mlIdx]) continue;
+ rtRelations[mlIdx] = calibData->getCalibData(id, msgStream())->rtRelation.get();
+ ++nRel;
+ if (nRel == 2) break;
+ }
+ }
const DCOnTrackVec& dcs_keep = dcs;
unsigned int N = dcs_keep.size();
@@ -243,7 +260,8 @@ namespace TrkDriftCircleMath {
dcs_new.push_back( dc_new );
if( selection[i] == 0 ){
double t = ds->rot()->driftTime();
- const MuonCalib::MdtRtRelation *rtInfo = m_calibrationDbTool->getRtCalibration(ds->rot()->identify());
+ const unsigned int mlIdx = id_helper.multilayer(ds->rot()->identify()) - 1;
+ const MuonCalib::MdtRtRelation *rtInfo = rtRelations[mlIdx];
double tUp = rtInfo->rt()->tUpper();
double tLow = rtInfo->rt()->tLower();
@@ -287,7 +305,8 @@ namespace TrkDriftCircleMath {
unsigned int ii{0};
for(const DCOnTrack& keep_me : dcs_keep ){
const Muon::MdtDriftCircleOnTrack *roto = keep_me.rot();
- const MuonCalib::MdtRtRelation *rtInfo = m_calibrationDbTool->getRtCalibration(roto->identify());
+ const unsigned int mlIdx = id_helper.multilayer(roto->identify()) - 1;
+ const MuonCalib::MdtRtRelation *rtInfo = rtRelations[mlIdx];
const double newerror = m_scaleErrors ? keep_me.drPrecise() : keep_me.dr();
const double w = newerror >0. ? sq(1./newerror) : 0.;
@@ -419,7 +438,8 @@ namespace TrkDriftCircleMath {
dcs_new.push_back( std::move(dc_new) );
if( selection[i] == 0 ){
double t = ds->rot()->driftTime();
- const MuonCalib::MdtRtRelation *rtInfo = m_calibrationDbTool->getRtCalibration(ds->rot()->identify());
+ const unsigned int mlIdx = id_helper.multilayer(ds->rot()->identify()) - 1;
+ const MuonCalib::MdtRtRelation *rtInfo = rtRelations[mlIdx];
double tUp = rtInfo->rt()->tUpper();
double tLow = rtInfo->rt()->tLower();
if(t<tLow) chi2p += sq(t-tLow)*0.1;
diff --git a/Reconstruction/MuonIdentification/MuonCombinedConfig/python/MuonCombinedRecToolsConfig.py b/Reconstruction/MuonIdentification/MuonCombinedConfig/python/MuonCombinedRecToolsConfig.py
index 6ab811b0c54..85d82046c9b 100644
--- a/Reconstruction/MuonIdentification/MuonCombinedConfig/python/MuonCombinedRecToolsConfig.py
+++ b/Reconstruction/MuonIdentification/MuonCombinedConfig/python/MuonCombinedRecToolsConfig.py
@@ -1081,23 +1081,20 @@ def MuonStauRecoToolCfg(flags, name="MuonStauRecoTool", **kwargs):
from MuonConfig.MuonSegmentFindingConfig import DCMathSegmentMakerCfg, MuonPRDSelectionToolCfg
from MuonConfig.MuonTrackBuildingConfig import MuonChamberHoleRecoveryToolCfg
from MuonConfig.MuonRecToolsConfig import MuonAmbiProcessorCfg, MuonSeededSegmentFinderCfg
- from MuonConfig.MuonCalibrationConfig import MdtCalibrationDbToolCfg
from MuonConfig.MuonRIO_OnTrackCreatorToolConfig import MdtDriftCircleOnTrackCreatorCfg
from MuonConfig.MuonSegmentFindingConfig import MuonLayerHoughAlgCfg
kwargs.setdefault("DoSummary", flags.Muon.printSummary)
kwargs.setdefault("ConsideredPDGs", [13, -13, 1000015, -1000015])
kwargs.setdefault("DoTruth", flags.Input.isMC)
- result = MuonEDMPrinterToolCfg(flags)
+ result = ComponentAccumulator()
result.merge(MuonLayerHoughAlgCfg(flags))
# Not setting up MuonIdHelperSvc nor MuonEDMHelperSvc
- kwargs.setdefault("MuonEDMPrinterTool", result.getPrimary())
- kwargs.setdefault("MuonPRDSelectionTool", result.popToolsAndMerge(
- MuonPRDSelectionToolCfg(flags)))
+ kwargs.setdefault("MuonEDMPrinterTool", result.getPrimaryAndMerge(MuonEDMPrinterToolCfg(flags)))
+ kwargs.setdefault("MuonPRDSelectionTool", result.popToolsAndMerge(MuonPRDSelectionToolCfg(flags)))
# This is going to be used in a few tools below
- staurotcreator = result.popToolsAndMerge(
- MdtDriftCircleOnTrackCreatorStauCfg(flags))
+ staurotcreator = result.popToolsAndMerge(MdtDriftCircleOnTrackCreatorStauCfg(flags))
kwargs.setdefault("MuonPRDSelectionToolStau",
result.popToolsAndMerge(MuonPRDSelectionToolCfg(flags,
"MuonPRDSelectionToolStau",
@@ -1148,9 +1145,6 @@ def MuonStauRecoToolCfg(flags, name="MuonStauRecoTool", **kwargs):
MuonInsideOutRecoToolCfg(flags, name='MuonStauInsideOutRecoTool', MuonCandidateTrackBuilderTool=muoncandidatetrackbuilder)))
# Rest
- kwargs.setdefault("MdtCalibrationDbTool", result.popToolsAndMerge(
- MdtCalibrationDbToolCfg(flags)))
-
tool = CompFactory.MuonCombined.MuonStauRecoTool(name, **kwargs)
result.setPrivateTools(tool)
return result
diff --git a/Reconstruction/MuonIdentification/MuonCombinedRecExample/python/MuGirlTagTool.py b/Reconstruction/MuonIdentification/MuonCombinedRecExample/python/MuGirlTagTool.py
index f7d44cc5d09..c53ae495ee7 100644
--- a/Reconstruction/MuonIdentification/MuonCombinedRecExample/python/MuGirlTagTool.py
+++ b/Reconstruction/MuonIdentification/MuonCombinedRecExample/python/MuGirlTagTool.py
@@ -105,15 +105,13 @@ def MuonStauInsideOutRecoTool( name="MuonStauInsideOutRecoTool", **kwargs ):
return CfgMgr.MuonCombined__MuonInsideOutRecoTool(name,**kwargs )
def MuonStauRecoTool( name="MuonStauRecoTool", **kwargs ):
- from MuonCnvExample.MuonCalibConfig import MdtCalibrationDbTool
-
+
kwargs.setdefault("ConsideredPDGs", [13,-13,1000015,-1000015])
kwargs.setdefault("DoTruth", rec.doTruth() )
kwargs.setdefault("DoSummary", muonCombinedRecFlags.printSummary() )
kwargs.setdefault("MuonSegmentMaker", getPublicTool("DCMathStauSegmentMaker") )
kwargs.setdefault("MuonInsideOutRecoTool", getPublicTool("MuonStauInsideOutRecoTool") )
kwargs.setdefault("TrackAmbiguityProcessor", getPublicTool("MuonAmbiProcessor") )
- kwargs.setdefault("MdtCalibrationDbTool", MdtCalibrationDbTool())
kwargs.setdefault("MuonPRDSelectionTool", getPublicTool("MuonPRDSelectionTool") )
kwargs.setdefault("MuonPRDSelectionToolStau", getPublicTool("MuonPRDSelectionToolStau") )
diff --git a/Reconstruction/MuonIdentification/MuonCombinedTrackFindingTools/src/MuonStauRecoTool.cxx b/Reconstruction/MuonIdentification/MuonCombinedTrackFindingTools/src/MuonStauRecoTool.cxx
index 951bacaa80d..2362e6f131f 100644
--- a/Reconstruction/MuonIdentification/MuonCombinedTrackFindingTools/src/MuonStauRecoTool.cxx
+++ b/Reconstruction/MuonIdentification/MuonCombinedTrackFindingTools/src/MuonStauRecoTool.cxx
@@ -59,7 +59,7 @@ namespace MuonCombined {
ATH_CHECK(m_mdtCreatorStau.retrieve());
ATH_CHECK(m_insideOutRecoTool.retrieve());
ATH_CHECK(m_updator.retrieve());
- ATH_CHECK(m_calibrationDbTool.retrieve());
+ ATH_CHECK(m_calibDbKey.initialize());
ATH_CHECK(m_houghDataPerSectorVecKey.initialize(!m_houghDataPerSectorVecKey.empty()));
if (m_doTruth) {
@@ -253,7 +253,12 @@ namespace MuonCombined {
return !candidates.empty();
}
- void MuonStauRecoTool::extractTimeMeasurementsFromTrack(MuonStauRecoTool::Candidate& candidate) const {
+ void MuonStauRecoTool::extractTimeMeasurementsFromTrack(const EventContext& ctx, MuonStauRecoTool::Candidate& candidate) const {
+ SG::ReadCondHandle<MuonCalib::MdtCalibDataContainer> mdtCalibConstants{m_calibDbKey, ctx};
+ if (!mdtCalibConstants.isValid()) {
+ ATH_MSG_FATAL("Failed to retrieve calibration constants "<<m_calibDbKey.fullKey());
+ throw std::runtime_error("Failed to retrieve calibration constants");
+ }
ATH_MSG_VERBOSE("extractTimeMeasurementsFromTrack for candidate: beta seed " << candidate.betaSeed.beta);
Trk::Track* combinedTrack = candidate.combinedTrack.get();
if (!combinedTrack) return;
@@ -331,9 +336,8 @@ namespace MuonCombined {
float driftTime = mdt->driftTime(); // we need to add beta seed as it was subtracted when calibrating the hits
float locR = pars->parameters()[Trk::locR];
float errR = pars->covariance() ? Amg::error(*pars->covariance(), Trk::locR) : 0.3;
- const auto* detEl = mdt->detectorElement();
- auto data = m_calibrationDbTool->getCalibration(detEl->identifyHash(), detEl->detectorElementHash());
- const auto* rtRelation = data.rtRelation;
+ auto data = mdtCalibConstants->getCalibData(id, msgStream());
+ const auto& rtRelation = data->rtRelation;
bool out_of_bound_flag = false;
float drdt = rtRelation->rt()->driftvelocity(driftTime);
float rres = rtRelation->rtRes()->resolution(driftTime);
@@ -624,9 +628,8 @@ namespace MuonCombined {
float driftTime = calibratedMdt->driftTime(); // we need to add beta seed as it was subtracted when calibrating the hits
float locR = rline;
float errR = dc.errorTrack();
- const auto* detEl = mdt->detectorElement();
- auto data = m_calibrationDbTool->getCalibration(detEl->identifyHash(), detEl->detectorElementHash());
- const auto* rtRelation = data.rtRelation;
+ auto data = mdtCalibConstants->getCalibData(id, msgStream());
+ const auto& rtRelation = data->rtRelation;
bool out_of_bound_flag = false;
float drdt = rtRelation->rt()->driftvelocity(driftTime);
float rres = rtRelation->rtRes()->resolution(driftTime);
@@ -803,7 +806,7 @@ namespace MuonCombined {
candidate->combinedTrack = std::move(result.second);
// extract times form track
- extractTimeMeasurementsFromTrack(*candidate);
+ extractTimeMeasurementsFromTrack(ctx, *candidate);
combinedCandidates.push_back(candidate);
if (!m_recoValidationTool.empty()) m_recoValidationTool->addTimeMeasurements(indetTrackParticle, candidate->stauHits);
}
diff --git a/Reconstruction/MuonIdentification/MuonCombinedTrackFindingTools/src/MuonStauRecoTool.h b/Reconstruction/MuonIdentification/MuonCombinedTrackFindingTools/src/MuonStauRecoTool.h
index 096e3922a02..e1b0adce4b1 100644
--- a/Reconstruction/MuonIdentification/MuonCombinedTrackFindingTools/src/MuonStauRecoTool.h
+++ b/Reconstruction/MuonIdentification/MuonCombinedTrackFindingTools/src/MuonStauRecoTool.h
@@ -1,5 +1,5 @@
/*
- Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
+ Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
*/
#ifndef MUON_MUONSTAURECOTOOL_H
@@ -13,7 +13,7 @@
#include "GaudiKernel/PhysicalConstants.h"
#include "GaudiKernel/ServiceHandle.h"
#include "GaudiKernel/ToolHandle.h"
-#include "MdtCalibSvc/MdtCalibrationDbTool.h"
+#include "MdtCalibData/MdtCalibDataContainer.h"
#include "MuidInterfaces/ICombinedMuonTrackBuilder.h"
#include "MuonClusterization/RpcHitClustering.h"
#include "MuonCombinedEvent/MuGirlLowBetaTag.h"
@@ -60,14 +60,14 @@ namespace MuonCombined {
struct BetaSeed {
BetaSeed(float beta_, float error_) : beta(beta_), error(error_) {}
- float beta;
- float error;
+ float beta{0.f};
+ float error{0.f};
};
struct RpcTimeMeasurement {
std::vector<std::shared_ptr<const Muon::RpcClusterOnTrack>> rpcClusters;
- float time;
- float error;
+ float time{0.f};
+ float error{0.f};
};
typedef std::vector<RpcTimeMeasurement> RpcTimeMeasurementVec;
@@ -196,7 +196,7 @@ namespace MuonCombined {
Trk::SegmentCollection* segments) const;
/** extract time measurements from the track associated with the candidate */
- void extractTimeMeasurementsFromTrack(Candidate& candidate) const;
+ void extractTimeMeasurementsFromTrack(const EventContext& ctx, Candidate& candidate) const;
/** extract truth from the indetTrackParticle */
TruthInfo* getTruth(const xAOD::TrackParticle& indetTrackParticle) const;
@@ -251,7 +251,8 @@ namespace MuonCombined {
ToolHandle<MuonCombined::MuonInsideOutRecoTool> m_insideOutRecoTool{this, "MuonInsideOutRecoTool",
"MuonCombined::MuonInsideOutRecoTool/MuonInsideOutRecoTool"};
ToolHandle<Trk::IUpdator> m_updator{this, "Updator", "Trk::KalmanUpdator/KalmanUpdator"};
- ToolHandle<MdtCalibrationDbTool> m_calibrationDbTool{this, "MdtCalibrationDbTool", "MdtCalibrationDbTool"};
+ SG::ReadCondHandleKey<MuonCalib::MdtCalibDataContainer> m_calibDbKey{this, "CalibDataKey", "MdtCalibConstants",
+ "Conditions object containing the calibrations"};
Muon::MuonSectorMapping m_muonSectorMapping;
diff --git a/Simulation/Digitization/test/test_MC16a_Digi_tf_configuration.py b/Simulation/Digitization/test/test_MC16a_Digi_tf_configuration.py
index 63d124e48cb..1d3df7ed796 100755
--- a/Simulation/Digitization/test/test_MC16a_Digi_tf_configuration.py
+++ b/Simulation/Digitization/test/test_MC16a_Digi_tf_configuration.py
@@ -326,7 +326,7 @@ class TestDigitizationMC16a(unittest.TestCase):
def test___MdtDigitizationTool_properties(self):
tested_configurable_name = 'StandardSignalOnlyTruthPileUpToolsAlg.MdtDigitizationTool'
- expected_property_list = ['CalibrationDbTool', 'DetStore', 'DigitizationTool', 'DiscardEarlyHits', 'DoQballCharge', 'EvtStore', 'ExtraInputs', 'ExtraOutputs', 'FirstXing', 'InputObjectName', 'LastXing', 'MuonIdHelperSvc', 'OutputObjectName', 'OutputSDOName', 'PileUpMergeSvc', 'ReadKey', 'RndmSvc', 'UseTof']
+ expected_property_list = ['CalibDataKey', 'DetStore', 'DigitizationTool', 'DiscardEarlyHits', 'DoQballCharge', 'EvtStore', 'ExtraInputs', 'ExtraOutputs', 'FirstXing', 'InputObjectName', 'LastXing', 'MuonIdHelperSvc', 'OutputObjectName', 'OutputSDOName', 'PileUpMergeSvc', 'ReadKey', 'RndmSvc', 'UseTof']
expected_nonstring_properties = {'LastXing': '150', 'FirstXing': '-800'}
expected_string_properties = {} # Not checking any specific property values
self._detailed_ConfigurablePropertiesCheck(
diff --git a/Tools/PROCTools/data/q442_AOD_digest.ref b/Tools/PROCTools/data/q442_AOD_digest.ref
index 5247b8e2914..6628450cf2a 100644
--- a/Tools/PROCTools/data/q442_AOD_digest.ref
+++ b/Tools/PROCTools/data/q442_AOD_digest.ref
@@ -22,5 +22,5 @@
330470 1183773832 229 209 9 2 0 1 0 1 8 0 8
330470 1183775209 21 0 0 0 0 0 0 0 0 0 0
330470 1183787124 370 384 26 4 1 3 0 3 6 0 6
- 330470 1183787946 262 326 30 4 1 2 0 2 5 0 5
+ 330470 1183787946 262 326 30 4 0 2 0 2 5 0 5
330470 1183795329 376 358 33 5 0 3 0 3 7 0 7
diff --git a/Tools/PROCTools/data/q449_AOD_digest.ref b/Tools/PROCTools/data/q449_AOD_digest.ref
index 2a837001aed..8f443ad5a2e 100644
--- a/Tools/PROCTools/data/q449_AOD_digest.ref
+++ b/Tools/PROCTools/data/q449_AOD_digest.ref
@@ -5,9 +5,9 @@
431493 1096113011 366 400 84 10 0 9 0 9 11 0 11
431493 1096113187 272 317 65 6 1 8 0 8 14 0 14
431493 1096113771 293 401 78 7 0 10 0 10 12 0 12
- 431493 1096114154 361 566 89 7 1 7 0 7 17 0 17
+ 431493 1096114154 361 566 89 7 0 7 0 7 17 0 17
431493 1096114168 133 153 23 5 0 2 0 2 6 0 6
- 431493 1096115980 388 521 137 11 0 21 0 21 22 0 22
+ 431493 1096115980 388 521 137 11 1 21 0 21 22 0 22
431493 1096116200 306 408 35 4 1 4 0 4 12 0 12
431493 1096118782 294 354 91 7 1 11 0 11 23 0 23
431493 1096119418 306 340 84 6 0 5 0 5 9 0 9
@@ -50,7 +50,7 @@
431493 1096146735 320 376 106 11 2 21 0 21 26 0 26
431493 1096147568 385 601 74 7 2 4 0 4 14 0 14
431493 1096150983 270 318 27 6 0 2 0 2 13 0 13
- 431493 1096152978 363 502 93 8 3 9 0 9 11 0 11
+ 431493 1096152978 363 502 93 8 2 9 0 9 11 0 11
431493 1096153967 536 657 102 10 2 7 0 7 33 0 33
431493 1096155046 238 372 23 3 1 1 0 1 3 0 3
431493 1096155387 333 484 75 8 1 7 0 7 15 0 15
@@ -97,5 +97,5 @@
431493 1096209204 401 546 78 9 0 9 0 9 20 0 20
431493 1096211915 327 371 62 6 0 7 0 7 18 0 18
431493 1096218966 301 393 16 2 1 4 0 4 10 0 10
- 431493 1096226529 319 399 101 10 1 11 0 11 14 0 14
+ 431493 1096226529 319 399 101 10 0 11 0 11 14 0 14
431493 1096229568 186 244 65 10 2 5 0 5 16 0 16
diff --git a/Tools/PROCTools/data/q450_AOD_digest.ref b/Tools/PROCTools/data/q450_AOD_digest.ref
index d59a546d351..8b23917e329 100644
--- a/Tools/PROCTools/data/q450_AOD_digest.ref
+++ b/Tools/PROCTools/data/q450_AOD_digest.ref
@@ -20,7 +20,7 @@
421739 11578480 5 0 0 0 1 0 0 0 0 0 0
421739 11578482 4 0 0 0 0 0 0 0 0 0 0
421739 11578505 10 0 0 0 2 0 0 0 0 0 0
- 421739 11578520 7 0 0 0 2 0 0 0 0 0 0
+ 421739 11578520 7 0 0 0 1 0 0 0 0 0 0
421739 11578532 1 0 0 0 0 0 0 0 0 0 0
421739 11578533 4 0 0 0 0 0 0 0 0 0 0
421739 11578542 6 0 0 0 1 0 0 0 0 0 0
diff --git a/Tools/WorkflowTestRunner/python/References.py b/Tools/WorkflowTestRunner/python/References.py
index f42cb575aa9..69f8660e289 100644
--- a/Tools/WorkflowTestRunner/python/References.py
+++ b/Tools/WorkflowTestRunner/python/References.py
@@ -22,10 +22,10 @@ references_map = {
"d1726": "v1",
"d1759": "v3",
# Reco
- "q442": "v20",
- "q443": "v16",
- "q445": "v21",
- "q449": "v24",
+ "q442": "v21",
+ "q443": "v17",
+ "q445": "v22",
+ "q449": "v25",
# Derivations
"data_PHYS_Run2": "v11",
"data_PHYS_Run3": "v10",
diff --git a/Trigger/TrigAlgorithms/TrigL2MuonSA/src/MuFastPatternFinder.cxx b/Trigger/TrigAlgorithms/TrigL2MuonSA/src/MuFastPatternFinder.cxx
index 0e110caa6ed..b63157709ed 100644
--- a/Trigger/TrigAlgorithms/TrigL2MuonSA/src/MuFastPatternFinder.cxx
+++ b/Trigger/TrigAlgorithms/TrigL2MuonSA/src/MuFastPatternFinder.cxx
@@ -1,12 +1,11 @@
/*
- Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
+ Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
*/
#include "MuFastPatternFinder.h"
-
-#include "MuonCalibEvent/MdtCalibHit.h"
#include "xAODTrigMuon/TrigMuonDefs.h"
#include "MdtRegionDefiner.h"
+#include "GeoPrimitives/GeoPrimitivesToStringConverter.h"
// --------------------------------------------------------------------------------
// --------------------------------------------------------------------------------
@@ -52,37 +51,22 @@ void TrigL2MuonSA::MuFastPatternFinder::doMdtCalibration(TrigL2MuonSA::MdtHitDat
double R = mdtHit.R;
// double InCo = mdtHit.cInCo;
- double InCo = std::cos(std::abs(track_phi - phi0))!=0 ? 1./(std::cos(std::abs(track_phi - phi0))): 0;
+ const double cosDphi = std::cos(std::abs(track_phi - phi0));
+ double InCo = cosDphi ? 1./ cosDphi: 0;
double X = (isEndcap)? R*std::cos(track_phi): R*InCo*std::cos(track_phi);
double Y = (isEndcap)? R*std::sin(track_phi): R*InCo*std::sin(track_phi);
double Z = mdtHit.Z;
const Amg::Vector3D point(X,Y,Z);
- const Amg::Vector3D point0(0.,0.,0.);
-
- MdtCalibHit calHit(id, tdcCounts, adcCounts, point, 0 );
- // Need to overwrite uninitialised variables
- calHit.setLocalPos(point0);
- calHit.setLocalPointOfClosestApproach(point0);
- calHit.setGlobalPointOfClosestApproach(point0);
- calHit.setDriftTime(0.);
- calHit.setDriftRadius(0., 0.);
- calHit.setDistanceToTrack(0., 0.);
- calHit.setTimeFromTrackDistance(0., 0.);
- calHit.setDistanceToReadout(0.);
- calHit.setBFieldPerp(0.);
- calHit.setBFieldPara(0.);
- calHit.setTemperature(0.);
- calHit.setLocXtwin(0.);
- calHit.setSigma2LocXtwin(0.);
-
+
+ MdtCalibInput calHit{id, adcCounts,tdcCounts, point};
ATH_MSG_DEBUG("... MDT hit raw digit tdcCounts/adcCounts=" << tdcCounts << "/" << adcCounts);
ATH_MSG_DEBUG("... MDT hit position X/Y/Z/track_phi/Multilayer/Layer/Tube="
- << X << "/" << Y << "/" << Z << "/" << track_phi << "/" << Multilayer << "/" << Layer << "/" << Tube);
+ << Amg::toString(point, 2) << "/" << track_phi << "/" << Multilayer << "/" << Layer << "/" << Tube);
- m_mdtCalibrationTool->driftRadiusFromTime( calHit, point.mag() );
- double driftSpace = calHit.driftRadius();
- double driftSigma = calHit.sigmaDriftRadius();
+ MdtCalibOutput calibOut = m_mdtCalibrationTool->calibrate(Gaudi::Hive::currentContext(), calHit, false);
+ double driftSpace = calibOut.driftRadius();
+ double driftSigma = calibOut.driftRadiusUncert();
ATH_MSG_DEBUG("... MDT hit calibrated driftSpace/driftSigma=" << driftSpace << "/" << driftSigma);
diff --git a/Trigger/TrigAlgorithms/TrigL2MuonSA/src/MuFastPatternFinder.h b/Trigger/TrigAlgorithms/TrigL2MuonSA/src/MuFastPatternFinder.h
index 3c4dc371070..978b5bf748b 100644
--- a/Trigger/TrigAlgorithms/TrigL2MuonSA/src/MuFastPatternFinder.h
+++ b/Trigger/TrigAlgorithms/TrigL2MuonSA/src/MuFastPatternFinder.h
@@ -10,7 +10,7 @@
#include "GaudiKernel/ToolHandle.h"
#include "GeoPrimitives/GeoPrimitives.h"
-#include "MdtCalibSvc/MdtCalibrationTool.h"
+#include "MdtCalibInterfaces/IMdtCalibrationTool.h"
#include "MuonRoad.h"
#include "MdtData.h"
#include "TrackData.h"
@@ -65,7 +65,7 @@ class MuFastPatternFinder: public AthAlgTool
ToolHandle<NswPatternFinder> m_nswPatternFinder {this, "NswPatternFinder", "TrigL2MuonSA::NswPatternFinder"};
// MDT calibration service
- ToolHandle<MdtCalibrationTool> m_mdtCalibrationTool{this, "CalibrationTool", "MdtCalibrationTool"};
+ ToolHandle<IMdtCalibrationTool> m_mdtCalibrationTool{this, "CalibrationTool", "MdtCalibrationTool"};
ServiceHandle<Muon::IMuonIdHelperSvc> m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"};
};
diff --git a/Trigger/TrigValidation/TrigP1Test/share/ref_v1Dev_decodeBS_build.ref b/Trigger/TrigValidation/TrigP1Test/share/ref_v1Dev_decodeBS_build.ref
index 442ec6fd2f2..4856adda7d6 100644
--- a/Trigger/TrigValidation/TrigP1Test/share/ref_v1Dev_decodeBS_build.ref
+++ b/Trigger/TrigValidation/TrigP1Test/share/ref_v1Dev_decodeBS_build.ref
@@ -501,7 +501,7 @@ HLT_2mu3_L12MU3V:
stepCounts:
0: 2
stepFeatures:
- 0: 6
+ 0: 5
HLT_2mu3_L12MU3VF:
eventCount: 0
stepCounts:
@@ -510,72 +510,28 @@ HLT_2mu3_L12MU3VF:
0: 4
HLT_2mu4_11invmAA60_L12MU3V:
eventCount: 0
- stepCounts:
- 0: 1
- stepFeatures:
- 0: 2
HLT_2mu4_11invmAA60_L12MU3VF:
eventCount: 0
- stepCounts:
- 0: 1
- stepFeatures:
- 0: 2
HLT_2mu4_11invmAA60_L1DY-BOX-2MU3VF:
eventCount: 0
- stepCounts:
- 0: 1
- stepFeatures:
- 0: 2
HLT_2mu4_7invmAA9_L12MU3V:
eventCount: 0
- stepCounts:
- 0: 1
- stepFeatures:
- 0: 2
HLT_2mu4_7invmAA9_L12MU3VF:
eventCount: 0
- stepCounts:
- 0: 1
- stepFeatures:
- 0: 2
HLT_2mu4_7invmAA9_L1DY-BOX-2MU3VF:
eventCount: 0
- stepCounts:
- 0: 1
- stepFeatures:
- 0: 2
HLT_2mu4_L12MU3V:
eventCount: 0
- stepCounts:
- 0: 1
- stepFeatures:
- 0: 2
HLT_2mu4_L1BPH-7M11-25DR99-2MU3VF:
eventCount: 0
HLT_2mu4_L1BPH-7M14-0DR25-MU5VFMU3VF:
eventCount: 0
- stepCounts:
- 0: 1
- stepFeatures:
- 0: 2
HLT_2mu4_L1BPH-7M14-2MU3V:
eventCount: 0
- stepCounts:
- 0: 1
- stepFeatures:
- 0: 2
HLT_2mu4_L1BPH-7M14-2MU3VF:
eventCount: 0
- stepCounts:
- 0: 1
- stepFeatures:
- 0: 2
HLT_2mu4_PhysicsTLA_L12MU3V:
eventCount: 0
- stepCounts:
- 0: 1
- stepFeatures:
- 0: 2
HLT_2mu4_PhysicsTLA_L1BPH-7M22-0DR12-2MU3V:
eventCount: 0
HLT_2mu4_PhysicsTLA_L1BPH-7M22-0DR20-2MU3V:
@@ -584,10 +540,6 @@ HLT_2mu4_PhysicsTLA_L1BPH-7M22-0DR20-2MU3VF:
eventCount: 0
HLT_2mu4_PhysicsTLA_L1BPH-7M22-2MU3VF:
eventCount: 0
- stepCounts:
- 0: 1
- stepFeatures:
- 0: 2
HLT_2mu4_b0dRAB127invmAB22vtx20_L1BPH-7M22-0DR12-2MU3V:
eventCount: 0
HLT_2mu4_b0dRAB207invmAB22vtx20_L1BPH-7M22-0DR20-2MU3V:
@@ -596,270 +548,126 @@ HLT_2mu4_b0dRAB207invmAB22vtx20_L1BPH-7M22-0DR20-2MU3VF:
eventCount: 0
HLT_2mu4_b7invmAB22vtx20_L1BPH-7M22-2MU3VF:
eventCount: 0
- stepCounts:
- 0: 1
- stepFeatures:
- 0: 2
HLT_2mu4_bBmumu_L12MU3V:
eventCount: 0
- stepCounts:
- 0: 1
- stepFeatures:
- 0: 2
HLT_2mu4_bBmumu_L12MU3VF:
eventCount: 0
- stepCounts:
- 0: 1
- stepFeatures:
- 0: 2
HLT_2mu4_bBmumu_L1BPH-2M9-0DR15-2MU3V:
eventCount: 0
HLT_2mu4_bBmumu_L1BPH-2M9-0DR15-2MU3VF:
eventCount: 0
HLT_2mu4_bBmumu_Lxy0_L12MU3V:
eventCount: 0
- stepCounts:
- 0: 1
- stepFeatures:
- 0: 2
HLT_2mu4_bBmumu_Lxy0_L12MU3VF:
eventCount: 0
- stepCounts:
- 0: 1
- stepFeatures:
- 0: 2
HLT_2mu4_bBmumu_Lxy0_L1BPH-2M9-0DR15-2MU3V:
eventCount: 0
HLT_2mu4_bBmumu_Lxy0_L1BPH-2M9-0DR15-2MU3VF:
eventCount: 0
HLT_2mu4_bBmumux_BcmumuD0Xloose_L12MU3V:
eventCount: 0
- stepCounts:
- 0: 1
- stepFeatures:
- 0: 2
HLT_2mu4_bBmumux_BcmumuD0Xloose_L12MU3VF:
eventCount: 0
- stepCounts:
- 0: 1
- stepFeatures:
- 0: 2
HLT_2mu4_bBmumux_BcmumuD0Xloose_L1BPH-2M9-0DR15-2MU3V:
eventCount: 0
HLT_2mu4_bBmumux_BcmumuD0Xloose_L1BPH-2M9-0DR15-2MU3VF:
eventCount: 0
HLT_2mu4_bBmumux_BcmumuDploose_L12MU3V:
eventCount: 0
- stepCounts:
- 0: 1
- stepFeatures:
- 0: 2
HLT_2mu4_bBmumux_BcmumuDploose_L12MU3VF:
eventCount: 0
- stepCounts:
- 0: 1
- stepFeatures:
- 0: 2
HLT_2mu4_bBmumux_BcmumuDploose_L1BPH-2M9-0DR15-2MU3V:
eventCount: 0
HLT_2mu4_bBmumux_BcmumuDploose_L1BPH-2M9-0DR15-2MU3VF:
eventCount: 0
HLT_2mu4_bBmumux_BcmumuDsloose_L12MU3V:
eventCount: 0
- stepCounts:
- 0: 1
- stepFeatures:
- 0: 2
HLT_2mu4_bBmumux_BcmumuDsloose_L12MU3VF:
eventCount: 0
- stepCounts:
- 0: 1
- stepFeatures:
- 0: 2
HLT_2mu4_bBmumux_BcmumuDsloose_L1BPH-2M9-0DR15-2MU3V:
eventCount: 0
HLT_2mu4_bBmumux_BcmumuDsloose_L1BPH-2M9-0DR15-2MU3VF:
eventCount: 0
HLT_2mu4_bBmumux_BcmumuDstarloose_L12MU3V:
eventCount: 0
- stepCounts:
- 0: 1
- stepFeatures:
- 0: 2
HLT_2mu4_bBmumux_BcmumuDstarloose_L12MU3VF:
eventCount: 0
- stepCounts:
- 0: 1
- stepFeatures:
- 0: 2
HLT_2mu4_bBmumux_BcmumuDstarloose_L1BPH-2M9-0DR15-2MU3V:
eventCount: 0
HLT_2mu4_bBmumux_BcmumuDstarloose_L1BPH-2M9-0DR15-2MU3VF:
eventCount: 0
HLT_2mu4_bBmumux_BcmumuPi_L12MU3V:
eventCount: 0
- stepCounts:
- 0: 1
- stepFeatures:
- 0: 2
HLT_2mu4_bBmumux_BcmumuPi_L12MU3VF:
eventCount: 0
- stepCounts:
- 0: 1
- stepFeatures:
- 0: 2
HLT_2mu4_bBmumux_BcmumuPi_L1BPH-2M9-0DR15-2MU3V:
eventCount: 0
HLT_2mu4_bBmumux_BcmumuPi_L1BPH-2M9-0DR15-2MU3VF:
eventCount: 0
HLT_2mu4_bBmumux_BdmumuKst_L12MU3V:
eventCount: 0
- stepCounts:
- 0: 1
- stepFeatures:
- 0: 2
HLT_2mu4_bBmumux_BdmumuKst_L12MU3VF:
eventCount: 0
- stepCounts:
- 0: 1
- stepFeatures:
- 0: 2
HLT_2mu4_bBmumux_BdmumuKst_L1BPH-2M9-0DR15-2MU3V:
eventCount: 0
HLT_2mu4_bBmumux_BdmumuKst_L1BPH-2M9-0DR15-2MU3VF:
eventCount: 0
HLT_2mu4_bBmumux_BpmumuKp_L12MU3V:
eventCount: 0
- stepCounts:
- 0: 1
- stepFeatures:
- 0: 2
HLT_2mu4_bBmumux_BpmumuKp_L12MU3VF:
eventCount: 0
- stepCounts:
- 0: 1
- stepFeatures:
- 0: 2
HLT_2mu4_bBmumux_BpmumuKp_L1BPH-2M9-0DR15-2MU3V:
eventCount: 0
HLT_2mu4_bBmumux_BpmumuKp_L1BPH-2M9-0DR15-2MU3VF:
eventCount: 0
HLT_2mu4_bBmumux_BsmumuPhi_L12MU3V:
eventCount: 0
- stepCounts:
- 0: 1
- stepFeatures:
- 0: 2
HLT_2mu4_bBmumux_BsmumuPhi_L12MU3VF:
eventCount: 0
- stepCounts:
- 0: 1
- stepFeatures:
- 0: 2
HLT_2mu4_bBmumux_BsmumuPhi_L1BPH-2M9-0DR15-2MU3V:
eventCount: 0
HLT_2mu4_bBmumux_BsmumuPhi_L1BPH-2M9-0DR15-2MU3VF:
eventCount: 0
HLT_2mu4_bBmumux_LbPqKm_L12MU3V:
eventCount: 0
- stepCounts:
- 0: 1
- stepFeatures:
- 0: 2
HLT_2mu4_bBmumux_LbPqKm_L12MU3VF:
eventCount: 0
- stepCounts:
- 0: 1
- stepFeatures:
- 0: 2
HLT_2mu4_bBmumux_LbPqKm_L1BPH-2M9-0DR15-2MU3V:
eventCount: 0
HLT_2mu4_bBmumux_LbPqKm_L1BPH-2M9-0DR15-2MU3VF:
eventCount: 0
HLT_2mu4_bBmux_BdmuDstarX_L12MU3V:
eventCount: 0
- stepCounts:
- 0: 1
- stepFeatures:
- 0: 2
HLT_2mu4_bBmux_BdmuDstarX_L1BPH-7M11-25DR99-2MU3VF:
eventCount: 0
HLT_2mu4_bBmux_BdmuDstarX_L1BPH-7M14-0DR25-MU5VFMU3VF:
eventCount: 0
- stepCounts:
- 0: 1
- stepFeatures:
- 0: 2
HLT_2mu4_bDimu_L12MU3V:
eventCount: 0
- stepCounts:
- 0: 1
- stepFeatures:
- 0: 2
HLT_2mu4_bDimu_L12MU3VF:
eventCount: 0
- stepCounts:
- 0: 1
- stepFeatures:
- 0: 2
HLT_2mu4_bJpsimumu_L12MU3V:
eventCount: 0
- stepCounts:
- 0: 1
- stepFeatures:
- 0: 2
HLT_2mu4_bJpsimumu_L12MU3VF:
eventCount: 0
- stepCounts:
- 0: 1
- stepFeatures:
- 0: 2
HLT_2mu4_bJpsimumu_Lxy0_L12MU3V:
eventCount: 0
- stepCounts:
- 0: 1
- stepFeatures:
- 0: 2
HLT_2mu4_bJpsimumu_Lxy0_L12MU3VF:
eventCount: 0
- stepCounts:
- 0: 1
- stepFeatures:
- 0: 2
HLT_2mu4_bJpsimumu_Lxy0_L1BPH-2M9-0DR15-2MU3V:
eventCount: 0
HLT_2mu4_bJpsimumu_Lxy0_L1BPH-2M9-0DR15-2MU3VF:
eventCount: 0
HLT_2mu4_bUpsimumu_L12MU3V:
eventCount: 0
- stepCounts:
- 0: 1
- stepFeatures:
- 0: 2
HLT_2mu4_bUpsimumu_L12MU3VF:
eventCount: 0
- stepCounts:
- 0: 1
- stepFeatures:
- 0: 2
HLT_2mu4_ivarloose_L1BPH-7M14-0DR25-MU5VFMU3VF:
eventCount: 0
- stepCounts:
- 0: 1
- stepFeatures:
- 0: 2
HLT_2mu4_l2io_invmDimu_L12MU3V:
eventCount: 0
- stepCounts:
- 0: 1
- stepFeatures:
- 0: 2
HLT_2mu4_l2io_invmDimu_L12MU3VF:
eventCount: 0
- stepCounts:
- 0: 1
- stepFeatures:
- 0: 2
HLT_2mu4_l2io_invmDimu_L1BPH-2M9-0DR15-2MU3V:
eventCount: 0
HLT_2mu4_l2io_invmDimu_L1BPH-2M9-0DR15-2MU3VF:
@@ -868,38 +676,14 @@ HLT_2mu4_l2mt_L1MU4BOM:
eventCount: 0
HLT_2mu4_muonqual_L12MU3V:
eventCount: 0
- stepCounts:
- 0: 1
- stepFeatures:
- 0: 2
HLT_2mu4_noL2Comb_bBmumux_BpmumuKp_L12MU3V:
eventCount: 0
- stepCounts:
- 0: 1
- stepFeatures:
- 0: 2
- 1: 2
HLT_2mu4_noL2Comb_bBmumux_BsmumuPhi_L12MU3V:
eventCount: 0
- stepCounts:
- 0: 1
- stepFeatures:
- 0: 2
- 1: 2
HLT_2mu4_noL2Comb_bBmumux_LbPqKm_L12MU3V:
eventCount: 0
- stepCounts:
- 0: 1
- stepFeatures:
- 0: 2
- 1: 2
HLT_2mu4_noL2Comb_bJpsimumu_L12MU3V:
eventCount: 0
- stepCounts:
- 0: 1
- stepFeatures:
- 0: 2
- 1: 2
HLT_2mu50_msonly_L1MU14FCH:
eventCount: 0
HLT_2mu50_msonly_L1MU18VFCH:
@@ -1013,11 +797,11 @@ HLT_2mu6_l2io_invmDimu_L1LFV-MU5VF:
HLT_2mu6_mu4_bTau_L12MU5VF_3MU3V:
eventCount: 0
stepFeatures:
- 0: 3
+ 0: 2
HLT_2mu6_mu4_bUpsi_L12MU5VF_3MU3V:
eventCount: 0
stepFeatures:
- 0: 3
+ 0: 2
HLT_2mu6_muonqual_L12MU5VF:
eventCount: 0
HLT_3j190_pf_ftf_L1J100:
@@ -7604,7 +7388,7 @@ HLT_mu4_L1MU3V:
2: 5
3: 4
stepFeatures:
- 0: 11
+ 0: 10
1: 8
2: 5
3: 4
@@ -7616,7 +7400,7 @@ HLT_mu4_bJpsimutrk_MuonTrkPEB_L1MU3V:
2: 5
3: 4
stepFeatures:
- 0: 11
+ 0: 10
1: 6
2: 5
3: 4
@@ -7629,7 +7413,7 @@ HLT_mu4_bJpsimutrk_MuonTrkPEB_L1MU3VF:
2: 4
3: 3
stepFeatures:
- 0: 9
+ 0: 8
1: 5
2: 4
3: 3
@@ -7640,78 +7424,48 @@ HLT_mu4_ivarloose_2mu3noL1_L1BPH-7M14-0DR25-MU5VFMU3VF:
0: 1
1: 1
stepFeatures:
- 0: 2
+ 0: 1
1: 1
HLT_mu4_ivarloose_mu4_11invmAB60_L12MU3V:
eventCount: 0
- stepCounts:
- 0: 1
stepFeatures:
- 0: 6
- 1: 2
+ 0: 4
HLT_mu4_ivarloose_mu4_11invmAB60_L1DY-BOX-2MU3VF:
eventCount: 0
- stepCounts:
- 0: 1
stepFeatures:
- 0: 4
- 1: 2
+ 0: 2
HLT_mu4_ivarloose_mu4_7invmAB9_L12MU3V:
eventCount: 0
- stepCounts:
- 0: 1
stepFeatures:
- 0: 6
- 1: 2
+ 0: 4
HLT_mu4_ivarloose_mu4_7invmAB9_L1DY-BOX-2MU3VF:
eventCount: 0
- stepCounts:
- 0: 1
stepFeatures:
- 0: 4
- 1: 2
+ 0: 2
HLT_mu4_ivarloose_mu4_L1BPH-7M14-0DR25-MU5VFMU3VF:
eventCount: 0
- stepCounts:
- 0: 1
stepFeatures:
- 0: 4
- 1: 2
+ 0: 2
HLT_mu4_ivarloose_mu4_b11invmAB60vtx20_L12MU3V:
eventCount: 0
- stepCounts:
- 0: 1
stepFeatures:
- 0: 6
- 1: 2
+ 0: 4
HLT_mu4_ivarloose_mu4_b11invmAB60vtx20_L1DY-BOX-2MU3VF:
eventCount: 0
- stepCounts:
- 0: 1
stepFeatures:
- 0: 4
- 1: 2
+ 0: 2
HLT_mu4_ivarloose_mu4_b7invmAB9vtx20_L12MU3V:
eventCount: 0
- stepCounts:
- 0: 1
stepFeatures:
- 0: 6
- 1: 2
+ 0: 4
HLT_mu4_ivarloose_mu4_b7invmAB9vtx20_L1DY-BOX-2MU3VF:
eventCount: 0
- stepCounts:
- 0: 1
stepFeatures:
- 0: 4
- 1: 2
+ 0: 2
HLT_mu4_ivarloose_mu4_mu3noL1_L1BPH-7M14-0DR25-MU5VFMU3VF:
eventCount: 0
- stepCounts:
- 0: 1
stepFeatures:
- 0: 4
- 1: 2
+ 0: 2
HLT_mu4_j20_0eta290_020jvt_boffperf_pf_ftf_dRAB03_L1MU3V_J15:
eventCount: 0
stepCounts:
@@ -7757,7 +7511,7 @@ HLT_mu4_j20_0eta290_020jvt_boffperf_pf_ftf_dRAB04_L1MU3V:
5: 4
6: 2
stepFeatures:
- 0: 11
+ 0: 10
1: 8
2: 5
3: 4
@@ -7775,7 +7529,7 @@ HLT_mu4_j20_0eta290_boffperf_pf_ftf_dRAB03_L1MU3V:
5: 4
6: 1
stepFeatures:
- 0: 11
+ 0: 10
1: 8
2: 5
3: 4
@@ -7955,26 +7709,18 @@ HLT_mu4_l2io_L1MU3V:
2: 5
3: 4
stepFeatures:
- 0: 11
+ 0: 10
1: 6
2: 5
3: 4
HLT_mu4_mu4_idperf_1invmAB5_L12MU3VF:
eventCount: 0
- stepCounts:
- 0: 1
- 1: 1
stepFeatures:
- 0: 6
- 1: 3
+ 0: 4
HLT_mu4_mu4_idtp_idJpsimumu_L12MU3VF:
eventCount: 0
- stepCounts:
- 0: 1
- 1: 1
stepFeatures:
- 0: 6
- 1: 3
+ 0: 4
HLT_mu50_L1MU14FCH:
eventCount: 0
HLT_mu50_L1MU18VFCH:
@@ -7990,31 +7736,31 @@ HLT_mu60_L1MU18VFCH:
HLT_mu6_2mu4_bDimu2700_L1MU5VF_3MU3V:
eventCount: 0
stepFeatures:
- 0: 4
+ 0: 2
HLT_mu6_2mu4_bDimu2700_L1MU5VF_3MU3VF:
eventCount: 0
HLT_mu6_2mu4_bDimu6000_L1MU5VF_3MU3V:
eventCount: 0
stepFeatures:
- 0: 4
+ 0: 2
HLT_mu6_2mu4_bDimu6000_L1MU5VF_3MU3VF:
eventCount: 0
HLT_mu6_2mu4_bJpsi_L1MU5VF_3MU3V:
eventCount: 0
stepFeatures:
- 0: 4
+ 0: 2
HLT_mu6_2mu4_bJpsi_L1MU5VF_3MU3VF:
eventCount: 0
HLT_mu6_2mu4_bTau_L1MU5VF_3MU3V:
eventCount: 0
stepFeatures:
- 0: 4
+ 0: 2
HLT_mu6_2mu4_bTau_L1MU5VF_3MU3VF:
eventCount: 0
HLT_mu6_2mu4_bUpsi_L1MU5VF_3MU3V:
eventCount: 0
stepFeatures:
- 0: 4
+ 0: 2
HLT_mu6_2mu4_bUpsi_L1MU5VF_3MU3VF:
eventCount: 0
HLT_mu6_LRT_idperf_L1MU5VF:
@@ -8181,268 +7927,198 @@ HLT_mu6_msonly_L1MU5VF:
1: 3
HLT_mu6_mu4_L1BPH-7M14-MU5VFMU3VF:
eventCount: 0
- stepCounts:
- 0: 1
stepFeatures:
- 0: 3
- 1: 2
+ 0: 2
HLT_mu6_mu4_PhysicsTLA_L1BPH-7M22-MU5VFMU3VF:
eventCount: 0
- stepCounts:
- 0: 1
stepFeatures:
- 0: 3
- 1: 2
+ 0: 2
HLT_mu6_mu4_b7invmAB22vtx20_L1BPH-7M22-MU5VFMU3VF:
eventCount: 0
- stepCounts:
- 0: 1
stepFeatures:
- 0: 3
+ 0: 2
HLT_mu6_mu4_bBmumu_L1BPH-2M9-0DR15-C-MU5VFMU3V:
eventCount: 0
HLT_mu6_mu4_bBmumu_L1BPH-2M9-0DR15-MU5VFMU3V:
eventCount: 0
HLT_mu6_mu4_bBmumu_L1MU5VF_2MU3V:
eventCount: 0
- stepCounts:
- 0: 1
stepFeatures:
- 0: 5
+ 0: 4
HLT_mu6_mu4_bBmumu_L1MU5VF_2MU3VF:
eventCount: 0
- stepCounts:
- 0: 1
stepFeatures:
- 0: 5
+ 0: 4
HLT_mu6_mu4_bBmumu_Lxy0_L1BPH-2M9-0DR15-C-MU5VFMU3V:
eventCount: 0
HLT_mu6_mu4_bBmumu_Lxy0_L1BPH-2M9-0DR15-MU5VFMU3V:
eventCount: 0
HLT_mu6_mu4_bBmumu_Lxy0_L1MU5VF_2MU3V:
eventCount: 0
- stepCounts:
- 0: 1
stepFeatures:
- 0: 5
+ 0: 4
HLT_mu6_mu4_bBmumu_Lxy0_L1MU5VF_2MU3VF:
eventCount: 0
- stepCounts:
- 0: 1
stepFeatures:
- 0: 5
+ 0: 4
HLT_mu6_mu4_bBmumux_BcmumuD0Xloose_L1BPH-2M9-0DR15-C-MU5VFMU3V:
eventCount: 0
HLT_mu6_mu4_bBmumux_BcmumuD0Xloose_L1BPH-2M9-0DR15-MU5VFMU3V:
eventCount: 0
HLT_mu6_mu4_bBmumux_BcmumuD0Xloose_L1MU5VF_2MU3V:
eventCount: 0
- stepCounts:
- 0: 1
stepFeatures:
- 0: 5
+ 0: 4
HLT_mu6_mu4_bBmumux_BcmumuD0Xloose_L1MU5VF_2MU3VF:
eventCount: 0
- stepCounts:
- 0: 1
stepFeatures:
- 0: 5
+ 0: 4
HLT_mu6_mu4_bBmumux_BcmumuDploose_L1BPH-2M9-0DR15-C-MU5VFMU3V:
eventCount: 0
HLT_mu6_mu4_bBmumux_BcmumuDploose_L1BPH-2M9-0DR15-MU5VFMU3V:
eventCount: 0
HLT_mu6_mu4_bBmumux_BcmumuDploose_L1MU5VF_2MU3V:
eventCount: 0
- stepCounts:
- 0: 1
stepFeatures:
- 0: 5
+ 0: 4
HLT_mu6_mu4_bBmumux_BcmumuDploose_L1MU5VF_2MU3VF:
eventCount: 0
- stepCounts:
- 0: 1
stepFeatures:
- 0: 5
+ 0: 4
HLT_mu6_mu4_bBmumux_BcmumuDsloose_L1BPH-2M9-0DR15-C-MU5VFMU3V:
eventCount: 0
HLT_mu6_mu4_bBmumux_BcmumuDsloose_L1BPH-2M9-0DR15-MU5VFMU3V:
eventCount: 0
HLT_mu6_mu4_bBmumux_BcmumuDsloose_L1MU5VF_2MU3V:
eventCount: 0
- stepCounts:
- 0: 1
stepFeatures:
- 0: 5
+ 0: 4
HLT_mu6_mu4_bBmumux_BcmumuDsloose_L1MU5VF_2MU3VF:
eventCount: 0
- stepCounts:
- 0: 1
stepFeatures:
- 0: 5
+ 0: 4
HLT_mu6_mu4_bBmumux_BcmumuDstarloose_L1BPH-2M9-0DR15-C-MU5VFMU3V:
eventCount: 0
HLT_mu6_mu4_bBmumux_BcmumuDstarloose_L1BPH-2M9-0DR15-MU5VFMU3V:
eventCount: 0
HLT_mu6_mu4_bBmumux_BcmumuDstarloose_L1MU5VF_2MU3V:
eventCount: 0
- stepCounts:
- 0: 1
stepFeatures:
- 0: 5
+ 0: 4
HLT_mu6_mu4_bBmumux_BcmumuDstarloose_L1MU5VF_2MU3VF:
eventCount: 0
- stepCounts:
- 0: 1
stepFeatures:
- 0: 5
+ 0: 4
HLT_mu6_mu4_bBmumux_BcmumuPi_L1BPH-2M9-0DR15-C-MU5VFMU3V:
eventCount: 0
HLT_mu6_mu4_bBmumux_BcmumuPi_L1BPH-2M9-0DR15-MU5VFMU3V:
eventCount: 0
HLT_mu6_mu4_bBmumux_BcmumuPi_L1MU5VF_2MU3V:
eventCount: 0
- stepCounts:
- 0: 1
stepFeatures:
- 0: 5
+ 0: 4
HLT_mu6_mu4_bBmumux_BcmumuPi_L1MU5VF_2MU3VF:
eventCount: 0
- stepCounts:
- 0: 1
stepFeatures:
- 0: 5
+ 0: 4
HLT_mu6_mu4_bBmumux_BdmumuKst_L1BPH-2M9-0DR15-C-MU5VFMU3V:
eventCount: 0
HLT_mu6_mu4_bBmumux_BdmumuKst_L1BPH-2M9-0DR15-MU5VFMU3V:
eventCount: 0
HLT_mu6_mu4_bBmumux_BdmumuKst_L1MU5VF_2MU3V:
eventCount: 0
- stepCounts:
- 0: 1
stepFeatures:
- 0: 5
+ 0: 4
HLT_mu6_mu4_bBmumux_BdmumuKst_L1MU5VF_2MU3VF:
eventCount: 0
- stepCounts:
- 0: 1
stepFeatures:
- 0: 5
+ 0: 4
HLT_mu6_mu4_bBmumux_BpmumuKp_L1BPH-2M9-0DR15-C-MU5VFMU3V:
eventCount: 0
HLT_mu6_mu4_bBmumux_BpmumuKp_L1BPH-2M9-0DR15-MU5VFMU3V:
eventCount: 0
HLT_mu6_mu4_bBmumux_BpmumuKp_L1MU5VF_2MU3V:
eventCount: 0
- stepCounts:
- 0: 1
stepFeatures:
- 0: 5
+ 0: 4
HLT_mu6_mu4_bBmumux_BpmumuKp_L1MU5VF_2MU3VF:
eventCount: 0
- stepCounts:
- 0: 1
stepFeatures:
- 0: 5
+ 0: 4
HLT_mu6_mu4_bBmumux_BsmumuPhi_L1BPH-2M9-0DR15-C-MU5VFMU3V:
eventCount: 0
HLT_mu6_mu4_bBmumux_BsmumuPhi_L1BPH-2M9-0DR15-MU5VFMU3V:
eventCount: 0
HLT_mu6_mu4_bBmumux_BsmumuPhi_L1MU5VF_2MU3V:
eventCount: 0
- stepCounts:
- 0: 1
stepFeatures:
- 0: 5
+ 0: 4
HLT_mu6_mu4_bBmumux_BsmumuPhi_L1MU5VF_2MU3VF:
eventCount: 0
- stepCounts:
- 0: 1
stepFeatures:
- 0: 5
+ 0: 4
HLT_mu6_mu4_bBmumux_LbPqKm_L1BPH-2M9-0DR15-C-MU5VFMU3V:
eventCount: 0
HLT_mu6_mu4_bBmumux_LbPqKm_L1BPH-2M9-0DR15-MU5VFMU3V:
eventCount: 0
HLT_mu6_mu4_bBmumux_LbPqKm_L1MU5VF_2MU3V:
eventCount: 0
- stepCounts:
- 0: 1
stepFeatures:
- 0: 5
+ 0: 4
HLT_mu6_mu4_bBmumux_LbPqKm_L1MU5VF_2MU3VF:
eventCount: 0
- stepCounts:
- 0: 1
stepFeatures:
- 0: 5
+ 0: 4
HLT_mu6_mu4_bBmux_BdmuDstarX_L1BPH-7M14-0DR25-MU5VFMU3VF:
eventCount: 0
- stepCounts:
- 0: 1
stepFeatures:
- 0: 3
+ 0: 2
HLT_mu6_mu4_bDimu_L1BPH-2M9-0DR15-C-MU5VFMU3V:
eventCount: 0
HLT_mu6_mu4_bDimu_L1BPH-2M9-0DR15-MU5VFMU3V:
eventCount: 0
HLT_mu6_mu4_bDimu_L1MU5VF_2MU3V:
eventCount: 0
- stepCounts:
- 0: 1
stepFeatures:
- 0: 5
+ 0: 4
HLT_mu6_mu4_bDimu_L1MU5VF_2MU3VF:
eventCount: 0
- stepCounts:
- 0: 1
stepFeatures:
- 0: 5
+ 0: 4
HLT_mu6_mu4_bJpsimumu_L1BPH-2M9-0DR15-C-MU5VFMU3V:
eventCount: 0
HLT_mu6_mu4_bJpsimumu_L1BPH-2M9-0DR15-MU5VFMU3V:
eventCount: 0
HLT_mu6_mu4_bJpsimumu_L1MU5VF_2MU3V:
eventCount: 0
- stepCounts:
- 0: 1
stepFeatures:
- 0: 5
+ 0: 4
HLT_mu6_mu4_bJpsimumu_L1MU5VF_2MU3VF:
eventCount: 0
- stepCounts:
- 0: 1
stepFeatures:
- 0: 5
+ 0: 4
HLT_mu6_mu4_bJpsimumu_Lxy0_L1BPH-2M9-0DR15-C-MU5VFMU3V:
eventCount: 0
HLT_mu6_mu4_bJpsimumu_Lxy0_L1BPH-2M9-0DR15-MU5VFMU3V:
eventCount: 0
HLT_mu6_mu4_bJpsimumu_Lxy0_L1MU5VF_2MU3V:
eventCount: 0
- stepCounts:
- 0: 1
stepFeatures:
- 0: 5
+ 0: 4
HLT_mu6_mu4_bJpsimumu_Lxy0_L1MU5VF_2MU3VF:
eventCount: 0
- stepCounts:
- 0: 1
stepFeatures:
- 0: 5
+ 0: 4
HLT_mu6_mu4_bUpsimumu_L1BPH-8M15-0DR22-MU5VFMU3V-BO:
eventCount: 0
HLT_mu6_mu4_bUpsimumu_L1MU5VF_2MU3V:
eventCount: 0
- stepCounts:
- 0: 1
stepFeatures:
- 0: 5
+ 0: 4
HLT_mu6_mu4_bUpsimumu_L1MU5VF_2MU3VF:
eventCount: 0
- stepCounts:
- 0: 1
stepFeatures:
- 0: 5
+ 0: 4
HLT_mu6_mu6noL1_L1MU5VF:
eventCount: 0
stepCounts:
@@ -8457,11 +8133,8 @@ HLT_mu6_mu6noL1_L1MU5VF:
3: 2
HLT_mu6_noL2Comb_mu4_noL2Comb_bJpsimumu_L1MU5VF_2MU3V:
eventCount: 0
- stepCounts:
- 0: 1
stepFeatures:
- 0: 5
- 1: 3
+ 0: 4
HLT_mu6_probe_j20_pf_ftf_JetPEBPhysicsTLA_L1HT190-J15s5pETA21:
eventCount: 0
HLT_mu6_xe30_mht_L1XE30:
diff --git a/graphics/VP1/VP1Systems/VP1TrackSystems/src/TrkObjToString.cxx b/graphics/VP1/VP1Systems/VP1TrackSystems/src/TrkObjToString.cxx
index c9683cb5128..c58c5922b43 100644
--- a/graphics/VP1/VP1Systems/VP1TrackSystems/src/TrkObjToString.cxx
+++ b/graphics/VP1/VP1Systems/VP1TrackSystems/src/TrkObjToString.cxx
@@ -520,7 +520,7 @@ TrkObjToString::addFullInfo(QStringList& info, const Trk::RIO_OnTrack* rot){
case Trk::NODRIFTTIME: { info+="No Drift Time"; break;}
}
info+="Has sagging correction";
- info+=mdt->hasSaggedSurface () ? "True": "False";
+ info+=mdt->errorStrategy().creationParameter(Muon::MuonDriftCircleErrorStrategy::WireSagGeomCorrection) ? "True": "False";
info+="Drift time";
info+=QString::number(mdt->driftTime ())+QString(" [CLHEP::ns]");
//TK: Uncomment timing mode for now due to const issues
--
GitLab