diff --git a/Control/CalypsoExample/GeoModelTest/CMakeLists.txt b/Control/CalypsoExample/GeoModelTest/CMakeLists.txt
index 5e1e09ed0ace5925babadb107fb7c37094d13ded..1c5a6a250d17d322d65921bc2b0e57a691830961 100644
--- a/Control/CalypsoExample/GeoModelTest/CMakeLists.txt
+++ b/Control/CalypsoExample/GeoModelTest/CMakeLists.txt
@@ -32,5 +32,5 @@ atlas_add_test( GeoModelCheck
# Install files from the package:
#atlas_install_headers( GeoModelTest )
-atlas_install_joboptions( share/*.py )
+#atlas_install_joboptions( share/*.py )
atlas_install_python_modules( python/*.py )
diff --git a/Control/CalypsoExample/GeoModelTest/python/GeoModelTestConfig.py b/Control/CalypsoExample/GeoModelTest/python/GeoModelTestConfig.py
index ed0dd9fc5bcbc8b4f8a3b4e6128e93527f06a4c7..cf1c0cb22074e149daf4588ce88b5eca433da14d 100644
--- a/Control/CalypsoExample/GeoModelTest/python/GeoModelTestConfig.py
+++ b/Control/CalypsoExample/GeoModelTest/python/GeoModelTestConfig.py
@@ -1,6 +1,5 @@
#!/usr/bin/env python
import sys
-from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
def GeoModelTestCfg(flags):
@@ -20,7 +19,7 @@ def GeoModelTestCfg(flags):
if __name__ == "__main__":
# from AthenaCommon.Logging import log, logging
- from AthenaCommon.Constants import VERBOSE, INFO
+ #from AthenaCommon.Constants import VERBOSE, INFO
# log.setLevel(VERBOSE)
from AthenaCommon.Configurable import Configurable
@@ -28,6 +27,8 @@ if __name__ == "__main__":
# Flag definition
from CalypsoConfiguration.AllConfigFlags import ConfigFlags
# Flag specification
+ ConfigFlags.Input.isMC = True
+ ConfigFlags.IOVDb.GlobalTag = "OFLCOND-MC16-SDR-14" # Always needed, does nothing
ConfigFlags.GeoModel.FaserVersion = "FASER-00"
ConfigFlags.GeoModel.GeoExportFile = "faserGeo.db"
ConfigFlags.GeoModel.Align.Dynamic = False
@@ -46,6 +47,7 @@ if __name__ == "__main__":
acc = MainServicesSerialCfg()
# acc.merge(PoolReadCfg(ConfigFlags))
acc.merge(GeoModelTestCfg(ConfigFlags))
+ acc.getService("PoolSvc").SortReplicas = False # protects against random failures to find sqlite file
# logging.getLogger('forcomps').setLevel(VERBOSE)
# acc.foreach_component("*").OutputLevel = VERBOSE
# acc.foreach_component("*ClassID*").OutputLevel = INFO
diff --git a/Control/CalypsoExample/GeoModelTest/share/geoDebug.py b/Control/CalypsoExample/GeoModelTest/share/geoDebug.py
deleted file mode 100644
index 825ac57b6482edb4261c838111afa42df226856b..0000000000000000000000000000000000000000
--- a/Control/CalypsoExample/GeoModelTest/share/geoDebug.py
+++ /dev/null
@@ -1,52 +0,0 @@
-MessageSvc.OutputLevel = VERBOSE
-
-from AthenaCommon.GlobalFlags import globalflags
-
-globalflags.DetDescrVersion.set_Value_and_Lock( "FASER-00" )
-
-#globalflags.ConditionsTag.set_Value_and_Lock( "OFLCOND-MC16-SDR-14" )
-
-#from IOVDbSvc.CondDB import conddb
-#conddb.setGlobalTag(globalflags.ConditionsTag())
-
-#from AthenaCommon.DetFlags import DetFlags
-
-#DetFlags.geometry.SCT_setOn()
-#DetFlags.detdescr.SCT_setOn()
-
-#include('ISF_Config/AllDet_detDescr.py')
-
-from FaserGeoModel import SetGeometryVersion
-from FaserGeoModel import GeoModelInit
-
-from GeoModelSvc.GeoModelSvcConf import GeoModelSvc
-GeoModelSvc = GeoModelSvc()
-GeoModelSvc.PrintMaterials = True
-GeoModelSvc.GeoExportFile = "faserGeo.db"
-
-#DetFlags.Print()
-
-from AthenaCommon.AlgSequence import AlgSequence
-topSequence = AlgSequence()
-
-from GeoModelTest.GeoModelTestConf import GeoModelTestAlg
-topSequence += GeoModelTestAlg()
-
-from AthenaCommon.AppMgr import theApp
-
-theApp.EvtMax = 1
-
-# Uses SQLite by default (if available)
-# These lines suppress SQLite for geometry
-#from DBReplicaSvc.DBReplicaSvcConf import DBReplicaSvc
-#
-#DBReplicaSvc.UseGeomSQLite = False
-
-# This only affects conditions, not geometry
-#include('PyJobTransforms/UseFrontier.py')
-
-# Quiet some very spammy (on VERBOSE) components we don't care about
-from AthenaCommon.AppMgr import ServiceMgr as svcMgr
-svcMgr.ClassIDSvc.OutputLevel = INFO
-svcMgr.AthenaSealSvc.OutputLevel = INFO
-svcMgr.IncidentSvc.OutputLevel = INFO
diff --git a/Database/ConnectionManagement/FaserAuthentication/data/dblookup.xml b/Database/ConnectionManagement/FaserAuthentication/data/dblookup.xml
index 6254c5493c2078e11b7e906a0eb7b830d8765bde..a74612ac707da709d3c33ff514bf5a746a676511 100644
--- a/Database/ConnectionManagement/FaserAuthentication/data/dblookup.xml
+++ b/Database/ConnectionManagement/FaserAuthentication/data/dblookup.xml
@@ -6,4 +6,14 @@
<service name="sqlite_file:DetectorDescription/GeoModel/FaserGeoModel/geomDB_sqlite" accessMode="read" />
</logicalservice>
+<logicalservice name="COOLOFL_SCT">
+ <service name="sqlite_file:data/ALLP200.db" accessMode="read" />
+ <service name="sqlite_file:Tracker/TrackerConditions/FaserSCT_ConditionsData/ALLP200.db" accessMode="read" />
+</logicalservice>
+
+<logicalservice name="COOLOFL_DCS">
+ <service name="sqlite_file:data/ALLP200.db" accessMode="read" />
+ <service name="sqlite_file:Tracker/TrackerConditions/FaserSCT_ConditionsData/ALLP200.db" accessMode="read" />
+</logicalservice>
+
</servicelist>
diff --git a/DetectorDescription/GeoModel/FaserGeoModel/data/geomDB.sql b/DetectorDescription/GeoModel/FaserGeoModel/data/geomDB.sql
index 419bd4e25c8f8fa7fb2e1d50bdfab7678249d77f..d90ea5f44671336f787dba7a577bf44200c4191f 100644
--- a/DetectorDescription/GeoModel/FaserGeoModel/data/geomDB.sql
+++ b/DetectorDescription/GeoModel/FaserGeoModel/data/geomDB.sql
@@ -319,6 +319,7 @@ INSERT INTO "HVS_NODE" VALUES (213, "SctFaserGeneral", 21, 0, NULL);
INSERT INTO "HVS_NODE" VALUES (214, "SctSwitches", 21, 0, NULL);
INSERT INTO "HVS_NODE" VALUES (215, "SCTMaterials", 21, 0, NULL);
INSERT INTO "HVS_NODE" VALUES (216, "SCTMatComponents", 21, 0, NULL);
+INSERT INTO "HVS_NODE" VALUES (217, "SctConditions", 21, 0, NULL);
INSERT INTO "HVS_NODE" VALUES (220, "DipoleTopLevel", 22, 0, NULL);
INSERT INTO "HVS_NODE" VALUES (221, "DipoleGeneral", 22, 0, NULL);
INSERT INTO "HVS_NODE" VALUES (224, "DipoleSwitches", 22, 0, NULL);
@@ -356,6 +357,7 @@ INSERT INTO "HVS_TAG2NODE" VALUES (213, "SctFaserGeneral-00", 106789, NULL, 0, 0
INSERT INTO "HVS_TAG2NODE" VALUES (214, "SctSwitches-00", 107782, NULL, 0, 0, 1567987200000000000, NULL, 22);
INSERT INTO "HVS_TAG2NODE" VALUES (215, "SctMaterials-00", 107777, NULL, 0, 0, 1567987200000000000, NULL, 22);
INSERT INTO "HVS_TAG2NODE" VALUES (216, "SctMatComponents-00", 107778, NULL, 0, 0, 1567987200000000000, NULL, 22);
+INSERT INTO "HVS_TAG2NODE" VALUES (217, "SctConditions-00", 107779, NULL, 0, 0, 1579564800000000000, NULL, 22);
INSERT INTO "HVS_TAG2NODE" VALUES (220, "DipoleTopLevel-00", 100029, NULL, 0, 0, 1568678400000000000, NULL, 22);
INSERT INTO "HVS_TAG2NODE" VALUES (221, "DipoleGeneral-00", 100004, NULL, 0, 0, 1568678400000000000, NULL, 22);
INSERT INTO "HVS_TAG2NODE" VALUES (224, "DipoleSwitches-00", 100028, NULL, 0, 0, 1568678400000000000, NULL, 22);
@@ -404,6 +406,7 @@ INSERT INTO "HVS_LTAG2LTAG" VALUES (21, 100026, 213, 106789);
INSERT INTO "HVS_LTAG2LTAG" VALUES (21, 100026, 214, 107782);
INSERT INTO "HVS_LTAG2LTAG" VALUES (21, 100026, 215, 107777);
INSERT INTO "HVS_LTAG2LTAG" VALUES (21, 100026, 216, 107778);
+INSERT INTO "HVS_LTAG2LTAG" VALUES (21, 100026, 217, 107779);
INSERT INTO "HVS_LTAG2LTAG" VALUES (2, 100002, 22, 100027);
INSERT INTO "HVS_LTAG2LTAG" VALUES (22, 100027, 220, 100029);
INSERT INTO "HVS_LTAG2LTAG" VALUES (22, 100027, 221, 100004);
@@ -430,6 +433,7 @@ INSERT INTO "HVS_TAGCACHE" VALUES ("FASER-00", "SctFaserGeneral", "SCTFaserGe
INSERT INTO "HVS_TAGCACHE" VALUES ("FASER-00", "SctSwitches", "SCTSwitches-00", 107782);
INSERT INTO "HVS_TAGCACHE" VALUES ("FASER-00", "SCTMaterials", "SCTMaterials-00", 107777);
INSERT INTO "HVS_TAGCACHE" VALUES ("FASER-00", "SCTMatComponents", "SCTMatComponents-00", 107778);
+INSERT INTO "HVS_TAGCACHE" VALUES ("FASER-00", "SctConditions", "SctConditions-00", 107779);
INSERT INTO "HVS_TAGCACHE" VALUES ("FASER-00", "Dipole", "Dipole-00", 100027);
INSERT INTO "HVS_TAGCACHE" VALUES ("FASER-00", "DipoleTopLevel", "DipoleTopLevel-00", 100029);
INSERT INTO "HVS_TAGCACHE" VALUES ("FASER-00", "DipoleGeneral", "DipoleGeneral-00", 100004);
@@ -1092,6 +1096,14 @@ CREATE TABLE "SCTSWITCHES_DATA2TAG" ( "SCTSWITCHES_TAG_ID" SLONGLONG ,"SCTSWITCH
INSERT INTO "SCTSWITCHES_DATA2TAG" VALUES(107782,0);
--
--
+DROP TABLE IF EXISTS "SCTCONDITIONS_DATA";
+CREATE TABLE "SCTCONDITIONS_DATA" ( "SCTCONDITIONS_DATA_ID" SLONGLONG, "TEMPERATURE" DOUBLE, "BIASVOLT" DOUBLE, "DEPLETIONVOLT" DOUBLE, "USECONDDB" INT, UNIQUE ( "SCTCONDITIONS_DATA_ID" ) );
+INSERT INTO "SCTCONDITIONS_DATA" VALUES(0, 4.6, 70.0, 150.0, 0);
+DROP TABLE IF EXISTS "SCTCONDITIONS_DATA2TAG";
+CREATE TABLE "SCTCONDITIONS_DATA2TAG" ( "SCTCONDITIONS_TAG_ID" SLONGSLONG , "SCTCONDITIONS_DATA_ID" SLONGLONG );
+INSERT INTO "SCTCONDITIONS_DATA2TAG" VALUES(107779, 0);
+--
+--
DROP TABLE IF EXISTS "DIPOLESWITCHES_DATA";
CREATE TABLE "DIPOLESWITCHES_DATA" ( "DIPOLESWITCHES_DATA_ID" SLONGLONG ,"DETECTORNAME" TEXT ,"G3COMPATIBLE" INT ,"G3DIGITSCOMPATIBLE" INT ,"DC2GEOMETRY" INT ,"USEMAGFIELDSVC" INT ,"COSMICLAYOUT" INT ,"VERSIONNAME" TEXT ,"LAYOUT" TEXT ,"DESCRIPTION" TEXT , UNIQUE ( "DIPOLESWITCHES_DATA_ID" ) );
INSERT INTO "DIPOLESWITCHES_DATA" VALUES(0,'Dipole',0,0,0,1,0,'GEO','Prelim','Faser Geometry 2019');
diff --git a/MagneticField/MagFieldServices/python/MagFieldServicesConfig.py b/MagneticField/MagFieldServices/python/MagFieldServicesConfig.py
index 6a0cf5e1e103e72557cedb6a685c105a7df44499..0b8f79633199ce2e03379685dab535430f84fbb5 100644
--- a/MagneticField/MagFieldServices/python/MagFieldServicesConfig.py
+++ b/MagneticField/MagFieldServices/python/MagFieldServicesConfig.py
@@ -28,11 +28,11 @@ def MagneticFieldSvcCfg(flags, **kwargs):
result=ComponentAccumulator()
# initialise required conditions DB folders
- # from IOVDbSvc.IOVDbSvcConfig import addFolders
+ from IOVDbSvc.IOVDbSvcConfig import addFolders
- # # This handles addFolderSplitMC https://gitlab.cern.ch/atlas/athena/blob/master/Database/IOVDbSvc/python/CondDB.py#L240
- # # i.e. replaces conddb.addFolderSplitMC('GLOBAL','/GLOBAL/BField/Maps <noover/>','/GLOBAL/BField/Maps <noover/>')
- # # def addFolders(configFlags,folderstrings,detDb=None,className=None):
+ # This handles addFolderSplitMC https://gitlab.cern.ch/atlas/athena/blob/master/Database/IOVDbSvc/python/CondDB.py#L240
+ # i.e. replaces conddb.addFolderSplitMC('GLOBAL','/GLOBAL/BField/Maps <noover/>','/GLOBAL/BField/Maps <noover/>')
+ # def addFolders(configFlags,folderstrings,detDb=None,className=None):
# if flags.Input.isMC:
# db='GLOBAL_OFL'
# else:
@@ -40,9 +40,14 @@ def MagneticFieldSvcCfg(flags, **kwargs):
# result.merge(addFolders(flags,['/GLOBAL/BField/Maps <noover/>'],detDb=db) )
- # if not flags.Common.isOnline:
- # result.merge(addFolders(flags, ['/EXT/DCS/MAGNETS/SENSORDATA'], detDb='DCS_OFL', className="CondAttrListCollection") )
-
+ if not flags.Common.isOnline:
+ result.merge(addFolders(flags, ['/EXT/DCS/MAGNETS/SENSORDATA'], detDb='DCS_OFL', className="CondAttrListCollection") )
+
+ # if flags.Common.isOnline:
+ # kwargs.setdefault( "UseDCS", False )
+ # else:
+ # kwargs.setdefault( "UseDCS", True )
+
mag_field_svc = GetFieldSvc("FaserFieldSvc",**kwargs)
result.addService(mag_field_svc,primary=True)
return result
diff --git a/Simulation/G4Faser/G4FaserApp/test/runG4.py b/Simulation/G4Faser/G4FaserApp/test/runG4.py
index ed4ded1d9fc89f994614798905fc60ee89522b99..57d4d541b057a200286e37ba0815f93fcb1bb14e 100644
--- a/Simulation/G4Faser/G4FaserApp/test/runG4.py
+++ b/Simulation/G4Faser/G4FaserApp/test/runG4.py
@@ -129,6 +129,8 @@ if __name__ == "__main__":
acc.merge(veto)
acc.merge(sct)
acc.addService(G4GeometryNotifierSvcCfg(ConfigFlags, ActivateLVNotifier=True))
+ acc.getService("PoolSvc").SortReplicas = False # protects against random failures to find sqlite file
+
#
# Verbosity
#
diff --git a/Tracker/TrackerConditions/FaserSCT_ConditionsAlgorithms/CMakeLists.txt b/Tracker/TrackerConditions/FaserSCT_ConditionsAlgorithms/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..1e538ae9e78c57784276dccfdae89be2bd2ea8bd
--- /dev/null
+++ b/Tracker/TrackerConditions/FaserSCT_ConditionsAlgorithms/CMakeLists.txt
@@ -0,0 +1,107 @@
+###############################################################################
+# Package: FaserSCT_ConditionsAlgorithms
+################################################################################
+
+# Declare the package name:
+atlas_subdir( FaserSCT_ConditionsAlgorithms )
+
+# Declare the package's dependencies:
+atlas_depends_on_subdirs( PUBLIC
+ Control/AthenaBaseComps
+ Control/AthenaKernel
+ Control/StoreGate
+ Database/AthenaPOOL/AthenaPoolUtilities
+ DetectorDescription/Identifier
+ DetectorDescription/DetDescrCond/DetDescrConditions
+ DetectorDescription/GeoModel/GeoModelUtilities
+ DetectorDescription/GeoModel/GeoModelFaserUtilities
+ DetectorDescription/GeoPrimitives
+ GaudiKernel
+ InnerDetector/InDetConditions/InDetConditionsSummaryService
+ Tracker/TrackerConditions/FaserSCT_ConditionsData
+ InnerDetector/InDetConditions/SCT_ConditionsTools
+ InnerDetector/InDetDetDescr/SCT_Cabling
+ PRIVATE
+ Tracker/TrackerDetDescr/TrackerIdentifier
+ Tracker/TrackerDetDescr/TrackerReadoutGeometry
+ Tracking/TrkDetDescr/TrkGeometry )
+
+# External dependencies:
+find_package( Boost COMPONENTS filesystem thread system )
+
+# Component(s) in the package:
+atlas_add_component( FaserSCT_ConditionsAlgorithms
+ src/*.cxx
+ src/components/*.cxx
+ INCLUDE_DIRS ${Boost_INCLUDE_DIRS}
+ LINK_LIBRARIES ${Boost_LIBRARIES} AthenaBaseComps AthenaKernel StoreGateLib SGtests Identifier DetDescrConditions GeoModelUtilities GeoModelFaserUtilities GaudiKernel FaserSCT_ConditionsData SCT_CablingLib AthenaPoolUtilities TrackerIdentifier TrackerReadoutGeometry TrkGeometry SCT_ConditionsToolsLib )
+
+#atlas_add_test( TestCalibChipRead
+# SCRIPT athena.py --threads=5 SCT_ConditionsAlgorithms/testCalibChipRead.py
+# PROPERTIES TIMEOUT 600
+# ENVIRONMENT THREADS=5 )
+#atlas_add_test( TestCalibRead
+# SCRIPT athena.py --threads=5 SCT_ConditionsAlgorithms/testCalibRead.py
+# PROPERTIES TIMEOUT 600
+# ENVIRONMENT THREADS=5 )
+#atlas_add_test( TestConfig
+# SCRIPT athena.py --threads=5 SCT_ConditionsAlgorithms/testConfig.py
+# PROPERTIES TIMEOUT 600
+# ENVIRONMENT THREADS=5 )
+#atlas_add_test( TestDCSConditions
+# SCRIPT athena.py --threads=5 SCT_ConditionsAlgorithms/testDCSConditions.py
+# PROPERTIES TIMEOUT 600
+# ENVIRONMENT THREADS=5 )
+#atlas_add_test( TestLinkMasking
+# SCRIPT share/TestLinkMasking.sh
+# PROPERTIES TIMEOUT 600
+# ENVIRONMENT THREADS=5 )
+#atlas_add_test( TestMajority
+# SCRIPT athena.py --threads=5 SCT_ConditionsAlgorithms/testMajority.py
+# PROPERTIES TIMEOUT 600
+# ENVIRONMENT THREADS=5 )
+#atlas_add_test( TestModuleVeto
+# SCRIPT athena.py --threads=5 SCT_ConditionsAlgorithms/testModuleVeto.py
+# PROPERTIES TIMEOUT 600
+# ENVIRONMENT THREADS=5 )
+#atlas_add_test( TestMonRead
+# SCRIPT athena.py --threads=5 SCT_ConditionsAlgorithms/testMonRead.py
+# PROPERTIES TIMEOUT 600
+# ENVIRONMENT THREADS=5 )
+#atlas_add_test( TestParameters
+# SCRIPT athena.py --threads=5 SCT_ConditionsAlgorithms/testParameters.py
+# PROPERTIES TIMEOUT 600
+# ENVIRONMENT THREADS=5 )
+#atlas_add_test( TestReadout
+# SCRIPT athena.py --threads=5 SCT_ConditionsAlgorithms/testReadout.py
+# PROPERTIES TIMEOUT 600
+# ENVIRONMENT THREADS=5 )
+#atlas_add_test( TestRodVeto
+# SCRIPT athena.py --threads=5 SCT_ConditionsAlgorithms/testRodVeto.py
+# PROPERTIES TIMEOUT 600
+# ENVIRONMENT THREADS=5 )
+#atlas_add_test( TestSensors
+# SCRIPT athena.py --threads=5 SCT_ConditionsAlgorithms/testSensors.py
+# PROPERTIES TIMEOUT 600
+# ENVIRONMENT THREADS=5 )
+#atlas_add_test( TestSilicon
+# SCRIPT athena.py --threads=5 SCT_ConditionsAlgorithms/testSilicon.py
+# PROPERTIES TIMEOUT 600
+# ENVIRONMENT THREADS=5 )
+#atlas_add_test( TestStripVeto
+# SCRIPT athena.py --threads=5 SCT_ConditionsAlgorithms/testStripVeto.py
+# PROPERTIES TIMEOUT 600
+# ENVIRONMENT THREADS=5 )
+#atlas_add_test( TestSummary
+# SCRIPT athena.py --threads=5 SCT_ConditionsAlgorithms/testSummary.py
+# PROPERTIES TIMEOUT 600
+# ENVIRONMENT THREADS=5 )
+#atlas_add_test( TestTdaqEnabled
+# SCRIPT athena.py --threads=5 SCT_ConditionsAlgorithms/testTdaqEnabled.py
+# PROPERTIES TIMEOUT 720
+# ENVIRONMENT THREADS=5 )
+
+# Install files from the package:
+atlas_install_joboptions( share/*.py )
+atlas_install_python_modules( python/*.py )
+atlas_install_scripts( share/*.sh )
diff --git a/Tracker/TrackerConditions/FaserSCT_ConditionsAlgorithms/src/FaserSCT_AlignCondAlg.cxx b/Tracker/TrackerConditions/FaserSCT_ConditionsAlgorithms/src/FaserSCT_AlignCondAlg.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..46b420679f476da454bc8539c3f5eb926ef08405
--- /dev/null
+++ b/Tracker/TrackerConditions/FaserSCT_ConditionsAlgorithms/src/FaserSCT_AlignCondAlg.cxx
@@ -0,0 +1,163 @@
+/*
+ Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+*/
+
+#include "FaserSCT_AlignCondAlg.h"
+
+#include "TrackerReadoutGeometry/SCT_DetectorManager.h"
+#include "TrackerReadoutGeometry/SiDetectorElement.h"
+
+#include <memory>
+
+FaserSCT_AlignCondAlg::FaserSCT_AlignCondAlg(const std::string& name, ISvcLocator* pSvcLocator)
+ : ::AthAlgorithm(name, pSvcLocator)
+ , m_writeKey{"SCTAlignmentStore", "SCTAlignmentStore"}
+{
+ declareProperty("WriteKey", m_writeKey);
+}
+
+StatusCode FaserSCT_AlignCondAlg::initialize()
+{
+ ATH_MSG_DEBUG("initialize " << name());
+
+ // CondSvc
+ ATH_CHECK(m_condSvc.retrieve());
+
+ // Read Handles
+ // Static
+ ATH_CHECK(m_readKeyStatic.initialize(!m_useDynamicAlignFolders.value()));
+ // Dynamic
+// ATH_CHECK(m_readKeyDynamicL1.initialize(m_useDynamicAlignFolders.value()));
+// ATH_CHECK(m_readKeyDynamicL2.initialize(m_useDynamicAlignFolders.value()));
+// ATH_CHECK(m_readKeyDynamicL3.initialize(m_useDynamicAlignFolders.value()));
+
+ // Write Handles
+ ATH_CHECK(m_writeKey.initialize());
+
+ // Register write handle
+ ATH_CHECK(m_condSvc->regHandle(this, m_writeKey));
+
+ ATH_CHECK(detStore()->retrieve(m_detManager, "SCT"));
+
+ return StatusCode::SUCCESS;
+}
+
+StatusCode FaserSCT_AlignCondAlg::execute()
+{
+ ATH_MSG_DEBUG("execute " << name());
+
+ // ____________ Construct Write Cond Handle and check its validity ____________
+ SG::WriteCondHandle<GeoAlignmentStore> writeHandle{m_writeKey};
+
+ // Do we have a valid Write Cond Handle for current time?
+ 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;
+ }
+
+ // Get SiDetectorElements
+ const TrackerDD::SiDetectorElementCollection* oldColl{m_detManager->getDetectorElementCollection()};
+ if (oldColl==nullptr) {
+ ATH_MSG_FATAL("Null pointer is returned by getDetectorElementCollection()");
+ return StatusCode::FAILURE;
+ }
+
+ // ____________ Construct new Write Cond Object ____________
+ std::unique_ptr<GeoAlignmentStore> writeCdo{std::make_unique<GeoAlignmentStore>()};
+ EventIDRange rangeW;
+
+ if (not m_useDynamicAlignFolders.value()) { // Static
+ // ____________ Get Read Cond Object ____________
+ SG::ReadCondHandle<AlignableTransformContainer> readHandleStatic{m_readKeyStatic};
+ const AlignableTransformContainer* readCdoStatic{*readHandleStatic};
+ if (readCdoStatic==nullptr) {
+ ATH_MSG_FATAL("Null pointer to the read conditions object of " << m_readKeyStatic.key());
+ return StatusCode::FAILURE;
+ }
+ // ____________ Apply alignments to SCT GeoModel ____________
+ // Construct Container for read CDO.
+ TrackerDD::RawAlignmentObjects readCdoContainerStatic;
+ readCdoContainerStatic.emplace(m_readKeyStatic.key(), readCdoStatic);
+ ATH_CHECK(m_detManager->align(readCdoContainerStatic, writeCdo.get()));
+
+ // Define validity of the output cond object and record it
+ if (not readHandleStatic.range(rangeW)) {
+ ATH_MSG_FATAL("Failed to retrieve validity range for " << readHandleStatic.key());
+ return StatusCode::FAILURE;
+ }
+ } else { // Dynamic
+ ATH_MSG_FATAL("Dynamic alignment not supported");
+ // // ____________ Get Read Cond Object ____________
+ // SG::ReadCondHandle<CondAttrListCollection> readHandleDynamicL1{m_readKeyDynamicL1};
+ // const CondAttrListCollection* readCdoDynamicL1{*readHandleDynamicL1};
+ // if (readCdoDynamicL1==nullptr) {
+ // ATH_MSG_FATAL("Null pointer to the read conditions object of " << m_readKeyDynamicL1.key());
+ // return StatusCode::FAILURE;
+ // }
+ // SG::ReadCondHandle<CondAttrListCollection> readHandleDynamicL2{m_readKeyDynamicL2};
+ // const CondAttrListCollection* readCdoDynamicL2{*readHandleDynamicL2};
+ // if (readCdoDynamicL2==nullptr) {
+ // ATH_MSG_FATAL("Null pointer to the read conditions object of " << readHandleDynamicL2.key());
+ // return StatusCode::FAILURE;
+ // }
+ // SG::ReadCondHandle<AlignableTransformContainer> readHandleDynamicL3{m_readKeyDynamicL3};
+ // const AlignableTransformContainer* readCdoDynamicL3{*readHandleDynamicL3};
+ // if (readCdoDynamicL3==nullptr) {
+ // ATH_MSG_FATAL("Null pointer to the read conditions object of " << readHandleDynamicL3.key());
+ // return StatusCode::FAILURE;
+ // }
+ // // ____________ Apply alignments to SCT GeoModel ____________
+ // // Construct Container for read CDO-s.
+ // TrackerDD::RawAlignmentObjects readCdoContainerDynamicL1;
+ // readCdoContainerDynamicL1.emplace(m_readKeyDynamicL1.key(), readCdoDynamicL1);
+ // ATH_CHECK(m_detManager->align(readCdoContainerDynamicL1, writeCdo.get()));
+ // TrackerDD::RawAlignmentObjects readCdoContainerDynamicL2;
+ // readCdoContainerDynamicL2.emplace(m_readKeyDynamicL2.key(), readCdoDynamicL2);
+ // ATH_CHECK(m_detManager->align(readCdoContainerDynamicL2, writeCdo.get()));
+ // TrackerDD::RawAlignmentObjects readCdoContainerDynamicL3;
+ // readCdoContainerDynamicL3.emplace(m_readKeyDynamicL3.key(), readCdoDynamicL3);
+ // ATH_CHECK(m_detManager->align(readCdoContainerDynamicL3, writeCdo.get()));
+
+ // // Define validity of the output cond object and record it
+ // EventIDRange rangeWL1;
+ // if (not readHandleDynamicL1.range(rangeWL1)) {
+ // ATH_MSG_FATAL("Failed to retrieve validity range for " << readHandleDynamicL1.key());
+ // return StatusCode::FAILURE;
+ // }
+ // EventIDRange rangeWL2;
+ // if (not readHandleDynamicL2.range(rangeWL2)) {
+ // ATH_MSG_FATAL("Failed to retrieve validity range for " << readHandleDynamicL2.key());
+ // return StatusCode::FAILURE;
+ // }
+ // EventIDRange rangeWL3;
+ // if (not readHandleDynamicL3.range(rangeWL3)) {
+ // ATH_MSG_FATAL("Failed to retrieve validity range for " << readHandleDynamicL3.key());
+ // return StatusCode::FAILURE;
+ // }
+ // rangeW = EventIDRange::intersect(rangeWL1, rangeWL2, rangeWL3);
+ }
+
+ // Set (default) absolute transforms in alignment store by calling them.
+ for (const TrackerDD::SiDetectorElement* oldEl: *oldColl) {
+ oldEl->getMaterialGeom()->getAbsoluteTransform(writeCdo.get());
+ oldEl->getMaterialGeom()->getDefAbsoluteTransform(writeCdo.get());
+ }
+
+ if (writeHandle.record(rangeW, std::move(writeCdo)).isFailure()) {
+ ATH_MSG_FATAL("Could not record GeoAlignmentStore " << writeHandle.key()
+ << " with EventRange " << rangeW
+ << " into Conditions Store");
+ return StatusCode::FAILURE;
+ }
+ ATH_MSG_INFO("recorded new CDO " << writeHandle.key() << " with range " << rangeW << " into Conditions Store");
+
+ return StatusCode::SUCCESS;
+}
+
+StatusCode FaserSCT_AlignCondAlg::finalize()
+{
+ ATH_MSG_DEBUG("finalize " << name());
+ return StatusCode::SUCCESS;
+}
diff --git a/Tracker/TrackerConditions/FaserSCT_ConditionsAlgorithms/src/FaserSCT_AlignCondAlg.h b/Tracker/TrackerConditions/FaserSCT_ConditionsAlgorithms/src/FaserSCT_AlignCondAlg.h
new file mode 100644
index 0000000000000000000000000000000000000000..2e2ef9446debc4eac1c696a286d9e6ad3ce142ca
--- /dev/null
+++ b/Tracker/TrackerConditions/FaserSCT_ConditionsAlgorithms/src/FaserSCT_AlignCondAlg.h
@@ -0,0 +1,61 @@
+// -*- C++ -*-
+
+/*
+ Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef FASERSCT_CONDITIONSALGORITHMS_SCT_ALIGNCONDALG_H
+#define FASERSCT_CONDITIONSALGORITHMS_SCT_ALIGNCONDALG_H
+
+#include "AthenaBaseComps/AthAlgorithm.h"
+#include "StoreGate/ReadCondHandleKey.h"
+#include "StoreGate/WriteCondHandleKey.h"
+
+#include "GaudiKernel/ICondSvc.h"
+
+#include "DetDescrConditions/AlignableTransformContainer.h"
+#include "AthenaPoolUtilities/CondAttrListCollection.h"
+#include "GeoModelUtilities/GeoAlignmentStore.h"
+
+namespace TrackerDD {
+ class SCT_DetectorManager;
+}
+
+// SCT_AlignCondAlg cannot inherit AthReentrantAlgorithm.
+// SCT_AlignCondAlg::execute uses the following methods.
+// InDetDD::InDetDetectorManager::align
+// InDetDD::InDetDetectorManager::processAlignmentContainer
+// InDetDD::InDetDetectorManager::processKey
+// InDetDD::SCT_DetectorManager::setAlignableTransformDelta
+// InDetDD::SiDetectorElement::defModuleTransform
+// InDetDD::SiDetectorElement::defTransform
+// InDetDD::SiDetectorElement::defTransformCLHEP
+// GeoVFullPhysVol::getDefAbsoluteTransform
+// GeoVFullPhysVol::getDefAbsoluteTransform is used without argument.
+// To be thread-safe, we need to pass non-const GeoVAlignmentStore pointer.
+// However, we cannot give non-const pointer for SiDetectorElement
+// in SCT_DetectorManager in the above chain.
+
+class FaserSCT_AlignCondAlg : public AthAlgorithm
+{
+ public:
+ FaserSCT_AlignCondAlg(const std::string& name, ISvcLocator* pSvcLocator);
+ virtual ~FaserSCT_AlignCondAlg() override = default;
+
+ virtual StatusCode initialize() override;
+ virtual StatusCode execute() override;
+ virtual StatusCode finalize() override;
+
+ private:
+ BooleanProperty m_useDynamicAlignFolders{this, "UseDynamicAlignFolders", false, "Flag of dynamic or static ID alignment folders"};
+ SG::ReadCondHandleKey<AlignableTransformContainer> m_readKeyStatic{this, "ReadKeyStatic", "/Tracker/Align", "Key for the static alignment folder"};
+// SG::ReadCondHandleKey<CondAttrListCollection> m_readKeyDynamicL1{this, "ReadKeyDynamicL1", "/Indet/AlignL1/ID", "Key for the dynamic L1 alignment folder"};
+// SG::ReadCondHandleKey<CondAttrListCollection> m_readKeyDynamicL2{this, "ReadKeyDynamicL2", "/Indet/AlignL2/SCT", "Key for the dynamic L2 alignment folder"};
+// SG::ReadCondHandleKey<AlignableTransformContainer> m_readKeyDynamicL3{this, "ReadKeyDynamicL3", "/Indet/AlignL3", "Key for the dynamic L3 alignment folder"};
+ SG::WriteCondHandleKey<GeoAlignmentStore> m_writeKey;
+
+ ServiceHandle<ICondSvc> m_condSvc{this, "CondSvc", "CondSvc"};
+ const TrackerDD::SCT_DetectorManager* m_detManager{nullptr};
+};
+
+#endif // FASERSCT_CONDITIONSALGORITHMS_SCT_ALIGNCONDALG_H
diff --git a/Tracker/TrackerConditions/FaserSCT_ConditionsAlgorithms/src/FaserSCT_DCSConditionsHVCondAlg.cxx b/Tracker/TrackerConditions/FaserSCT_ConditionsAlgorithms/src/FaserSCT_DCSConditionsHVCondAlg.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..6beec5bb6a7ebc184f8e688c0c1163dc83471e69
--- /dev/null
+++ b/Tracker/TrackerConditions/FaserSCT_ConditionsAlgorithms/src/FaserSCT_DCSConditionsHVCondAlg.cxx
@@ -0,0 +1,107 @@
+/*
+ Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+*/
+
+#include "FaserSCT_DCSConditionsHVCondAlg.h"
+
+#include "Identifier/IdentifierHash.h"
+
+#include "GaudiKernel/EventIDRange.h"
+
+#include <memory>
+
+FaserSCT_DCSConditionsHVCondAlg::FaserSCT_DCSConditionsHVCondAlg(const std::string& name, ISvcLocator* pSvcLocator)
+ : ::AthReentrantAlgorithm(name, pSvcLocator)
+{
+}
+
+StatusCode FaserSCT_DCSConditionsHVCondAlg::initialize() {
+ ATH_MSG_DEBUG("initialize " << name());
+
+ // CondSvc
+ ATH_CHECK(m_condSvc.retrieve());
+
+ if (m_returnHVTemp.value()) {
+ // Read Cond Handle
+ ATH_CHECK(m_readKey.initialize());
+ // Write Cond Handle
+ ATH_CHECK(m_writeKey.initialize());
+ if (m_condSvc->regHandle(this, m_writeKey).isFailure()) {
+ ATH_MSG_FATAL("unable to register WriteCondHandle " << m_writeKey.fullKey() << " with CondSvc");
+ return StatusCode::FAILURE;
+ }
+ }
+
+ return StatusCode::SUCCESS;
+}
+
+StatusCode FaserSCT_DCSConditionsHVCondAlg::execute(const EventContext& ctx) const {
+ ATH_MSG_DEBUG("execute " << name());
+
+ if (not m_returnHVTemp.value()) {
+ return StatusCode::SUCCESS;
+ }
+
+ // Write Cond Handle
+ SG::WriteCondHandle<FaserSCT_DCSFloatCondData> writeHandle{m_writeKey, ctx};
+ // Do we have a valid Write Cond Handle for current time?
+ 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;
+ }
+
+ // Read Cond Handle
+ SG::ReadCondHandle<CondAttrListCollection> readHandle{m_readKey, ctx};
+ const CondAttrListCollection* readCdo{*readHandle};
+ if (readCdo==nullptr) {
+ ATH_MSG_FATAL("Null pointer to the read conditions object");
+ return StatusCode::FAILURE;
+ }
+ // Get the validitiy range
+ EventIDRange rangeW;
+ if (not readHandle.range(rangeW)) {
+ ATH_MSG_FATAL("Failed to retrieve validity range for " << readHandle.key());
+ return StatusCode::FAILURE;
+ }
+ ATH_MSG_INFO("Size of CondAttrListCollection " << readHandle.fullKey() << " readCdo->size()= " << readCdo->size());
+ ATH_MSG_INFO("Range of input is " << rangeW);
+
+ // Construct the output Cond Object and fill it in
+ std::unique_ptr<FaserSCT_DCSFloatCondData> writeCdo{std::make_unique<FaserSCT_DCSFloatCondData>()};
+
+ // Read temperature info
+ std::string param{"HVCHVOLT_RECV"};
+ CondAttrListCollection::const_iterator attrList{readCdo->begin()};
+ CondAttrListCollection::const_iterator end{readCdo->end()};
+ // CondAttrListCollection doesn't support C++11 type loops, no generic 'begin'
+ for (; attrList!=end; ++attrList) {
+ // A CondAttrListCollection is a map of ChanNum and AttributeList
+ CondAttrListCollection::ChanNum channelNumber{attrList->first};
+ const CondAttrListCollection::AttributeList &payload{attrList->second};
+ if (payload.exists(param) and not payload[param].isNull()) {
+ float val{payload[param].data<float>()};
+ writeCdo->setValue(channelNumber, val);
+ } else {
+ ATH_MSG_WARNING(param << " does not exist for ChanNum " << channelNumber);
+ }
+ }
+
+ // Record the output cond object
+ if (writeHandle.record(rangeW, std::move(writeCdo)).isFailure()) {
+ ATH_MSG_FATAL("Could not record FaserSCT_DCSFloatCondData " << writeHandle.key()
+ << " with EventRange " << rangeW
+ << " into Conditions Store");
+ return StatusCode::FAILURE;
+ }
+ ATH_MSG_INFO("recorded new CDO " << writeHandle.key() << " with range " << rangeW << " into Conditions Store");
+
+ return StatusCode::SUCCESS;
+}
+
+StatusCode FaserSCT_DCSConditionsHVCondAlg::finalize()
+{
+ ATH_MSG_DEBUG("finalize " << name());
+ return StatusCode::SUCCESS;
+}
diff --git a/Tracker/TrackerConditions/FaserSCT_ConditionsAlgorithms/src/FaserSCT_DCSConditionsHVCondAlg.h b/Tracker/TrackerConditions/FaserSCT_ConditionsAlgorithms/src/FaserSCT_DCSConditionsHVCondAlg.h
new file mode 100644
index 0000000000000000000000000000000000000000..81a6e954df1006f37d0580ef700db465c01cde78
--- /dev/null
+++ b/Tracker/TrackerConditions/FaserSCT_ConditionsAlgorithms/src/FaserSCT_DCSConditionsHVCondAlg.h
@@ -0,0 +1,40 @@
+// -*- C++ -*-
+
+/*
+ Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef FASERSCT_DCSCONDITIONSHVCONDALG
+#define FASERSCT_DCSCONDITIONSHVCONDALG
+
+#include "AthenaBaseComps/AthReentrantAlgorithm.h"
+
+#include "AthenaPoolUtilities/CondAttrListCollection.h"
+#include "FaserSCT_ConditionsData/FaserSCT_DCSFloatCondData.h"
+#include "StoreGate/ReadCondHandleKey.h"
+#include "StoreGate/WriteCondHandleKey.h"
+
+#include "GaudiKernel/ICondSvc.h"
+#include "GaudiKernel/Property.h"
+
+class FaserSCT_DCSConditionsHVCondAlg : public AthReentrantAlgorithm
+{
+ public:
+ FaserSCT_DCSConditionsHVCondAlg(const std::string& name, ISvcLocator* pSvcLocator);
+ virtual ~FaserSCT_DCSConditionsHVCondAlg() = default;
+ virtual StatusCode initialize() override;
+ virtual StatusCode execute(const EventContext& ctx) const override;
+ virtual StatusCode finalize() override;
+ /** Make this algorithm clonable. */
+ virtual bool isClonable() const override { return true; };
+
+ private:
+ SG::ReadCondHandleKey<CondAttrListCollection> m_readKey{this, "ReadKey", "/SCT/DCS/HV", "Key of input (raw) HV conditions folder"};
+ SG::WriteCondHandleKey<FaserSCT_DCSFloatCondData> m_writeKey{this, "WriteKey", "SCT_DCSHVCondData", "Key of output (derived) HV conditions data"};
+
+ ServiceHandle<ICondSvc> m_condSvc{this, "CondSvc", "CondSvc"};
+
+ BooleanProperty m_returnHVTemp{this, "ReturnHVTemp", true};
+};
+
+#endif // SCT_DCSCONDITIONSHVCONDALG
diff --git a/Tracker/TrackerConditions/FaserSCT_ConditionsAlgorithms/src/FaserSCT_DCSConditionsStatCondAlg.cxx b/Tracker/TrackerConditions/FaserSCT_ConditionsAlgorithms/src/FaserSCT_DCSConditionsStatCondAlg.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..d86d9434a58cfd6d58f798e1fa97011ba0b5eeef
--- /dev/null
+++ b/Tracker/TrackerConditions/FaserSCT_ConditionsAlgorithms/src/FaserSCT_DCSConditionsStatCondAlg.cxx
@@ -0,0 +1,177 @@
+/*
+ Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+*/
+
+#include "FaserSCT_DCSConditionsStatCondAlg.h"
+
+#include "Identifier/IdentifierHash.h"
+
+#include "GaudiKernel/EventIDRange.h"
+
+#include <memory>
+
+FaserSCT_DCSConditionsStatCondAlg::FaserSCT_DCSConditionsStatCondAlg(const std::string& name, ISvcLocator* pSvcLocator)
+ : ::AthReentrantAlgorithm(name, pSvcLocator)
+{
+}
+
+StatusCode FaserSCT_DCSConditionsStatCondAlg::initialize() {
+ ATH_MSG_DEBUG("initialize " << name());
+
+ m_doState = ((m_readAllDBFolders.value() and m_returnHVTemp.value()) or (not m_readAllDBFolders.value() and not m_returnHVTemp.value()));
+
+ // CondSvc
+ ATH_CHECK(m_condSvc.retrieve());
+
+ if (m_returnHVTemp.value()) {
+ // Read Cond Handle (HV)
+ ATH_CHECK(m_readKeyHV.initialize());
+ }
+
+ if (m_doState) {
+ // Read Cond Handle (state)
+ ATH_CHECK(m_readKeyState.initialize());
+ // Write Cond Handle
+ ATH_CHECK(m_writeKeyState.initialize());
+ if (m_condSvc->regHandle(this, m_writeKeyState).isFailure()) {
+ ATH_MSG_FATAL("unable to register WriteCondHandle " << m_writeKeyState.fullKey() << " with CondSvc");
+ return StatusCode::FAILURE;
+ }
+ }
+
+ if (m_useHV.value()) {
+ m_hvLowLimit = m_useHVLowLimit;
+ m_hvUpLimit = m_useHVUpLimit;
+ m_chanstatCut = m_useHVChanCut;
+ ATH_MSG_INFO("Using HV and Chanstat"<< m_chanstatCut << " for marking modules bad. >=Hvlow: "
+ << m_hvLowLimit<< " and <=Hv Up: " << m_hvUpLimit <<
+ ". Note: UseHV Overrides hv limit and chanstat values in joboptions!!");
+ }
+
+ return StatusCode::SUCCESS;
+}
+
+StatusCode FaserSCT_DCSConditionsStatCondAlg::execute(const EventContext& ctx) const {
+ ATH_MSG_DEBUG("execute " << name());
+
+ if (not m_doState) {
+ return StatusCode::SUCCESS;
+ }
+
+ // Write Cond Handle (state)
+ SG::WriteCondHandle<FaserSCT_DCSStatCondData> writeHandle{m_writeKeyState, ctx};
+ // Do we have a valid Write Cond Handle for current time?
+ 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;
+ }
+
+ // Read Cond Handle (state)
+ SG::ReadCondHandle<CondAttrListCollection> readHandleState{m_readKeyState, ctx};
+ const CondAttrListCollection* readCdoState{*readHandleState};
+ if (readCdoState==nullptr) {
+ ATH_MSG_FATAL("Null pointer to the read conditions object (state)");
+ return StatusCode::FAILURE;
+ }
+ // Get the validitiy range (state)
+ EventIDRange rangeState;
+ if (not readHandleState.range(rangeState)) {
+ ATH_MSG_FATAL("Failed to retrieve validity range for " << readHandleState.key());
+ return StatusCode::FAILURE;
+ }
+ ATH_MSG_INFO("Size of CondAttrListCollection " << readHandleState.fullKey() << " readCdo->size()= " << readCdoState->size());
+ ATH_MSG_INFO("Range of state input is " << rangeState);
+
+ // Construct the output Cond Object and fill it in
+ std::unique_ptr<FaserSCT_DCSStatCondData> writeCdoState{std::make_unique<FaserSCT_DCSStatCondData>()};
+
+ // Read state info
+ std::string paramState{"STATE"};
+ CondAttrListCollection::const_iterator attrListState{readCdoState->begin()};
+ CondAttrListCollection::const_iterator endState{readCdoState->end()};
+ // CondAttrListCollection doesn't support C++11 type loops, no generic 'begin'
+ for (; attrListState!=endState; ++attrListState) {
+ // A CondAttrListCollection is a map of ChanNum and AttributeList
+ CondAttrListCollection::ChanNum channelNumber{attrListState->first};
+ const CondAttrListCollection::AttributeList &payload{attrListState->second};
+ if (payload.exists(paramState) and not payload[paramState].isNull()) {
+ unsigned int val{payload[paramState].data<unsigned int>()};
+ unsigned int hvstate{val bitand 240};
+ unsigned int lvstate{val bitand 15};
+ if ( ( (m_chanstatCut=="NORM") and not ((hvstate==16 or hvstate==48) and (lvstate==1 or lvstate==3)) )
+ or ( (m_chanstatCut=="NSTBY") and not ((hvstate==16 or hvstate==48 or hvstate==32) and (lvstate==1 or lvstate==3 or lvstate==2)) )
+ or ( (m_chanstatCut=="LOOSE") and not ((hvstate==16 or hvstate==48 or hvstate==32 or hvstate==128) and (lvstate==1 or lvstate==3 or lvstate==2 or lvstate==8)) )) {
+ writeCdoState->fill(channelNumber, paramState);
+ } else {
+ writeCdoState->remove(channelNumber, paramState);
+ }
+ } else {
+ ATH_MSG_WARNING(paramState << " does not exist for ChanNum " << channelNumber);
+ }
+ }
+
+ if (m_returnHVTemp.value()) {
+ // Read Cond Handle
+ SG::ReadCondHandle<CondAttrListCollection> readHandleHV{m_readKeyHV, ctx};
+ const CondAttrListCollection* readCdoHV{*readHandleHV};
+ if (readCdoHV==nullptr) {
+ ATH_MSG_FATAL("Null pointer to the read conditions object (HV)");
+ return StatusCode::FAILURE;
+ }
+ // Get the validitiy range (HV)
+ EventIDRange rangeHV;
+ if (not readHandleHV.range(rangeHV)) {
+ ATH_MSG_FATAL("Failed to retrieve validity range for " << readHandleHV.key());
+ return StatusCode::FAILURE;
+ }
+ ATH_MSG_INFO("Size of CondAttrListCollection " << readHandleHV.fullKey() << " readCdo->size()= " << readCdoHV->size());
+ ATH_MSG_INFO("Range of HV input is " << rangeHV);
+
+ // Combined the validity ranges of state and range
+ EventIDRange rangeIntersection{EventIDRange::intersect(rangeState, rangeHV)};
+ if (rangeIntersection.stop().isValid() and rangeIntersection.start()>rangeIntersection.stop()) {
+ ATH_MSG_FATAL("Invalid intersection range: " << rangeIntersection);
+ return StatusCode::FAILURE;
+ }
+ rangeState = rangeIntersection;
+
+ std::string paramHV{"HVCHVOLT_RECV"};
+ CondAttrListCollection::const_iterator attrListHV{readCdoHV->begin()};
+ CondAttrListCollection::const_iterator endHV{readCdoHV->end()};
+ // CondAttrListCollection doesn't support C++11 type loops, no generic 'begin'
+ for (; attrListHV!=endHV; ++attrListHV) {
+ // A CondAttrListCollection is a map of ChanNum and AttributeList
+ CondAttrListCollection::ChanNum channelNumber{attrListHV->first};
+ const CondAttrListCollection::AttributeList &payload{attrListHV->second};
+ if (payload.exists(paramHV) and not payload[paramHV].isNull()) {
+ float hvval{payload[paramHV].data<float>()};
+ if ((hvval<m_hvLowLimit) or (hvval>m_hvUpLimit)) {
+ writeCdoState->fill(channelNumber, paramHV);
+ } else {
+ writeCdoState->remove(channelNumber, paramHV);
+ }
+ } else {
+ ATH_MSG_WARNING(paramHV << " does not exist for ChanNum " << channelNumber);
+ }
+ }
+ }
+
+ // Record the output cond object
+ if (writeHandle.record(rangeState, std::move(writeCdoState)).isFailure()) {
+ ATH_MSG_FATAL("Could not record FaserSCT_DCSStatCondData " << writeHandle.key()
+ << " with EventRange " << rangeState
+ << " into Conditions Store");
+ return StatusCode::FAILURE;
+ }
+ ATH_MSG_INFO("recorded new CDO " << writeHandle.key() << " with range " << rangeState << " into Conditions Store");
+
+ return StatusCode::SUCCESS;
+}
+
+StatusCode FaserSCT_DCSConditionsStatCondAlg::finalize()
+{
+ ATH_MSG_DEBUG("finalize " << name());
+ return StatusCode::SUCCESS;
+}
diff --git a/Tracker/TrackerConditions/FaserSCT_ConditionsAlgorithms/src/FaserSCT_DCSConditionsStatCondAlg.h b/Tracker/TrackerConditions/FaserSCT_ConditionsAlgorithms/src/FaserSCT_DCSConditionsStatCondAlg.h
new file mode 100644
index 0000000000000000000000000000000000000000..f9fa50788323857263c622def0b215719b7b3202
--- /dev/null
+++ b/Tracker/TrackerConditions/FaserSCT_ConditionsAlgorithms/src/FaserSCT_DCSConditionsStatCondAlg.h
@@ -0,0 +1,51 @@
+// -*- C++ -*-
+
+/*
+ Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef FASERSCT_DCSCONDITIONSSTATCONDALG
+#define FASERSCT_DCSCONDITIONSSTATCONDALG
+
+#include "AthenaBaseComps/AthReentrantAlgorithm.h"
+
+#include "StoreGate/ReadCondHandleKey.h"
+#include "AthenaPoolUtilities/CondAttrListCollection.h"
+
+#include "StoreGate/WriteCondHandleKey.h"
+#include "FaserSCT_ConditionsData/FaserSCT_DCSStatCondData.h"
+
+#include "GaudiKernel/ICondSvc.h"
+#include "GaudiKernel/Property.h"
+
+class FaserSCT_DCSConditionsStatCondAlg : public AthReentrantAlgorithm
+{
+ public:
+ FaserSCT_DCSConditionsStatCondAlg(const std::string& name, ISvcLocator* pSvcLocator);
+ virtual ~FaserSCT_DCSConditionsStatCondAlg() = default;
+ virtual StatusCode initialize() override;
+ virtual StatusCode execute(const EventContext& ctx) const override;
+ virtual StatusCode finalize() override;
+ /** Make this algorithm clonable. */
+ virtual bool isClonable() const override { return true; }
+
+ private:
+ SG::ReadCondHandleKey<CondAttrListCollection> m_readKeyHV{this, "ReadKeyHV", "/SCT/DCS/HV", "Key of input (raw) HV conditions folder"};
+ SG::ReadCondHandleKey<CondAttrListCollection> m_readKeyState{this, "ReadKeyState", "/SCT/DCS/CHANSTAT", "Key of input (raw) State conditions folder"};
+ SG::WriteCondHandleKey<FaserSCT_DCSStatCondData> m_writeKeyState{this, "WriteKeyState", "SCT_DCSStatCondData", "Key of output (derived) State conditions data"};
+
+ ServiceHandle<ICondSvc> m_condSvc{this, "CondSvc", "CondSvc"};
+
+ bool m_doState{true};
+ BooleanProperty m_readAllDBFolders{this, "ReadAllDBFolders", true};
+ BooleanProperty m_returnHVTemp{this, "ReturnHVTemp", true};
+ StringProperty m_chanstatCut{this, "StateCut", "NORM"};
+ FloatProperty m_hvLowLimit{this, "HVCutLow", 0.0};
+ FloatProperty m_hvUpLimit{this, "HVCutUp", 1000000.0};
+ BooleanProperty m_useHV{this, "UseDefaultHV", false};
+ FloatProperty m_useHVLowLimit{this, "useHVLow", 19.};
+ FloatProperty m_useHVUpLimit{this, "useHVUp", 1000000.0};
+ StringProperty m_useHVChanCut{this, "useHVChan", "LOOSE"};
+};
+
+#endif // FASERSCT_DCSCONDITIONSSTATCONDALG
diff --git a/Tracker/TrackerConditions/FaserSCT_ConditionsAlgorithms/src/FaserSCT_DCSConditionsTempCondAlg.cxx b/Tracker/TrackerConditions/FaserSCT_ConditionsAlgorithms/src/FaserSCT_DCSConditionsTempCondAlg.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..2e73250d269ed02c62914fd6d5cd83bca155bf1b
--- /dev/null
+++ b/Tracker/TrackerConditions/FaserSCT_ConditionsAlgorithms/src/FaserSCT_DCSConditionsTempCondAlg.cxx
@@ -0,0 +1,107 @@
+/*
+ Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+*/
+
+#include "FaserSCT_DCSConditionsTempCondAlg.h"
+
+#include "Identifier/IdentifierHash.h"
+
+#include "GaudiKernel/EventIDRange.h"
+
+#include <memory>
+
+FaserSCT_DCSConditionsTempCondAlg::FaserSCT_DCSConditionsTempCondAlg(const std::string& name, ISvcLocator* pSvcLocator)
+ : ::AthReentrantAlgorithm(name, pSvcLocator)
+{
+}
+
+StatusCode FaserSCT_DCSConditionsTempCondAlg::initialize() {
+ ATH_MSG_DEBUG("initialize " << name());
+
+ // CondSvc
+ ATH_CHECK(m_condSvc.retrieve());
+
+ if (m_returnHVTemp.value()) {
+ // Read Cond Handle
+ ATH_CHECK(m_readKey.initialize());
+ // Write Cond Handles
+ ATH_CHECK(m_writeKey.initialize());
+ if (m_condSvc->regHandle(this, m_writeKey).isFailure()) {
+ ATH_MSG_FATAL("unable to register WriteCondHandle " << m_writeKey.fullKey() << " with CondSvc");
+ return StatusCode::FAILURE;
+ }
+ }
+
+ return StatusCode::SUCCESS;
+}
+
+StatusCode FaserSCT_DCSConditionsTempCondAlg::execute(const EventContext& ctx) const {
+ ATH_MSG_DEBUG("execute " << name());
+
+ if (not m_returnHVTemp.value()) {
+ return StatusCode::SUCCESS;
+ }
+
+ // Write Cond Handle
+ SG::WriteCondHandle<FaserSCT_DCSFloatCondData> writeHandle{m_writeKey, ctx};
+ // Do we have a valid Write Cond Handle for current time?
+ 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;
+ }
+
+ // Read Cond Handle
+ SG::ReadCondHandle<CondAttrListCollection> readHandle{m_readKey, ctx};
+ const CondAttrListCollection* readCdo{*readHandle};
+ if (readCdo==nullptr) {
+ ATH_MSG_FATAL("Null pointer to the read conditions object");
+ return StatusCode::FAILURE;
+ }
+ // Get the validitiy range
+ EventIDRange rangeW;
+ if (not readHandle.range(rangeW)) {
+ ATH_MSG_FATAL("Failed to retrieve validity range for " << readHandle.key());
+ return StatusCode::FAILURE;
+ }
+ ATH_MSG_INFO("Size of CondAttrListCollection " << readHandle.fullKey() << " readCdo->size()= " << readCdo->size());
+ ATH_MSG_INFO("Range of input is " << rangeW);
+
+ // Construct the output Cond Object and fill it in
+ std::unique_ptr<FaserSCT_DCSFloatCondData> writeCdo{std::make_unique<FaserSCT_DCSFloatCondData>()};
+
+ // Read temperature info
+ std::string param{"MOCH_TM0_RECV"};
+ CondAttrListCollection::const_iterator attrList{readCdo->begin()};
+ CondAttrListCollection::const_iterator end{readCdo->end()};
+ // CondAttrListCollection doesn't support C++11 type loops, no generic 'begin'
+ for (; attrList!=end; ++attrList) {
+ // A CondAttrListCollection is a map of ChanNum and AttributeList
+ CondAttrListCollection::ChanNum channelNumber{attrList->first};
+ const CondAttrListCollection::AttributeList &payload{attrList->second};
+ if (payload.exists(param) and not payload[param].isNull()) {
+ float val{payload[param].data<float>()};
+ writeCdo->setValue(channelNumber, val);
+ } else {
+ ATH_MSG_WARNING(param << " does not exist for ChanNum " << channelNumber);
+ }
+ }
+
+ // Record the output cond object
+ if (writeHandle.record(rangeW, std::move(writeCdo)).isFailure()) {
+ ATH_MSG_FATAL("Could not record FaserSCT_DCSFloatCondData " << writeHandle.key()
+ << " with EventRange " << rangeW
+ << " into Conditions Store");
+ return StatusCode::FAILURE;
+ }
+ ATH_MSG_INFO("recorded new CDO " << writeHandle.key() << " with range " << rangeW << " into Conditions Store");
+
+ return StatusCode::SUCCESS;
+}
+
+StatusCode FaserSCT_DCSConditionsTempCondAlg::finalize()
+{
+ ATH_MSG_DEBUG("finalize " << name());
+ return StatusCode::SUCCESS;
+}
diff --git a/Tracker/TrackerConditions/FaserSCT_ConditionsAlgorithms/src/FaserSCT_DCSConditionsTempCondAlg.h b/Tracker/TrackerConditions/FaserSCT_ConditionsAlgorithms/src/FaserSCT_DCSConditionsTempCondAlg.h
new file mode 100644
index 0000000000000000000000000000000000000000..b82a5ed15c2d28062b8ae32f858f0e58f0cf37cd
--- /dev/null
+++ b/Tracker/TrackerConditions/FaserSCT_ConditionsAlgorithms/src/FaserSCT_DCSConditionsTempCondAlg.h
@@ -0,0 +1,40 @@
+// -*- C++ -*-
+
+/*
+ Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef FASERSCT_DCSCONDITIONSTEMPCONDALG
+#define FASERSCT_DCSCONDITIONSTEMPCONDALG
+
+#include "AthenaBaseComps/AthReentrantAlgorithm.h"
+
+#include "AthenaPoolUtilities/CondAttrListCollection.h"
+#include "FaserSCT_ConditionsData/FaserSCT_DCSFloatCondData.h"
+#include "StoreGate/ReadCondHandleKey.h"
+#include "StoreGate/WriteCondHandleKey.h"
+
+#include "GaudiKernel/ICondSvc.h"
+#include "GaudiKernel/Property.h"
+
+class FaserSCT_DCSConditionsTempCondAlg : public AthReentrantAlgorithm
+{
+ public:
+ FaserSCT_DCSConditionsTempCondAlg(const std::string& name, ISvcLocator* pSvcLocator);
+ virtual ~FaserSCT_DCSConditionsTempCondAlg() = default;
+ virtual StatusCode initialize() override;
+ virtual StatusCode execute(const EventContext& ctx) const override;
+ virtual StatusCode finalize() override;
+ /** Make this algorithm clonable. */
+ virtual bool isClonable() const override { return true; };
+
+ private:
+ SG::ReadCondHandleKey<CondAttrListCollection> m_readKey{this, "ReadKey", "/SCT/DCS/MODTEMP", "Key of input (raw) temperature conditions folder"};
+ SG::WriteCondHandleKey<FaserSCT_DCSFloatCondData> m_writeKey{this, "WriteKey", "SCT_DCSTemp0CondData", "Key of output (derived) temperature conditions data"};
+
+ ServiceHandle<ICondSvc> m_condSvc{this, "CondSvc", "CondSvc"};
+
+ BooleanProperty m_returnHVTemp{this, "ReturnHVTemp", true};
+};
+
+#endif // FASERSCT_DCSCONDITIONSTEMPCONDALG
diff --git a/Tracker/TrackerConditions/FaserSCT_ConditionsAlgorithms/src/FaserSCT_DetectorElementCondAlg.cxx b/Tracker/TrackerConditions/FaserSCT_ConditionsAlgorithms/src/FaserSCT_DetectorElementCondAlg.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..6d71e231438ec37aff4dfb403dcc8a3891dfc7a3
--- /dev/null
+++ b/Tracker/TrackerConditions/FaserSCT_ConditionsAlgorithms/src/FaserSCT_DetectorElementCondAlg.cxx
@@ -0,0 +1,137 @@
+/*
+ Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+*/
+
+#include "FaserSCT_DetectorElementCondAlg.h"
+
+#include "TrackerReadoutGeometry/SCT_DetectorManager.h"
+#include "TrackerReadoutGeometry/SiDetectorElement.h"
+#include "TrkGeometry/Layer.h"
+#include "TrkSurfaces/Surface.h"
+
+#include <map>
+
+FaserSCT_DetectorElementCondAlg::FaserSCT_DetectorElementCondAlg(const std::string& name, ISvcLocator* pSvcLocator)
+ : ::AthReentrantAlgorithm(name, pSvcLocator)
+ , m_readKey{"SCTAlignmentStore", "SCTAlignmentStore"}
+{
+ declareProperty("ReadKey", m_readKey);
+}
+
+StatusCode FaserSCT_DetectorElementCondAlg::initialize()
+{
+ ATH_MSG_DEBUG("initialize " << name());
+
+ // Read Handle
+ ATH_CHECK(m_readKey.initialize());
+
+ // Write Handle
+ ATH_CHECK(m_writeKey.initialize());
+ // CondSvc
+ ATH_CHECK(m_condSvc.retrieve());
+ // Register write handle
+ ATH_CHECK(m_condSvc->regHandle(this, m_writeKey));
+
+ ATH_CHECK(detStore()->retrieve(m_detManager, "SCT"));
+
+ return StatusCode::SUCCESS;
+}
+
+StatusCode FaserSCT_DetectorElementCondAlg::execute(const EventContext& ctx) const
+{
+ ATH_MSG_DEBUG("execute " << name());
+
+ // ____________ Construct Write Cond Handle and check its validity ____________
+ SG::WriteCondHandle<TrackerDD::SiDetectorElementCollection> writeHandle{m_writeKey, ctx};
+
+ // Do we have a valid Write Cond Handle for current time?
+ 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;
+ }
+
+ const TrackerDD::SiDetectorElementCollection* oldColl{m_detManager->getDetectorElementCollection()};
+ if (oldColl==nullptr) {
+ ATH_MSG_FATAL("Null pointer is returned by getDetectorElementCollection()");
+ return StatusCode::FAILURE;
+ }
+
+ // ____________ Construct new Write Cond Object ____________
+ std::unique_ptr<TrackerDD::SiDetectorElementCollection> writeCdo{std::make_unique<TrackerDD::SiDetectorElementCollection>()};
+ EventIDRange rangeW;
+
+ // ____________ Get Read Cond Object ____________
+ SG::ReadCondHandle<GeoAlignmentStore> readHandle{m_readKey, ctx};
+ const GeoAlignmentStore* readCdo{*readHandle};
+ if (readCdo==nullptr) {
+ ATH_MSG_FATAL("Null pointer to the read conditions object of " << m_readKey.key());
+ return StatusCode::FAILURE;
+ }
+
+ // Define validity of the output cond object and record it
+ if (not readHandle.range(rangeW)) {
+ ATH_MSG_FATAL("Failed to retrieve validity range for " << readHandle.key());
+ return StatusCode::FAILURE;
+ }
+
+ // ____________ Update writeCdo using readCdo ____________
+ std::map<const TrackerDD::SiDetectorElement*, const TrackerDD::SiDetectorElement*> oldToNewMap;
+ oldToNewMap[nullptr] = nullptr;
+ writeCdo->resize(oldColl->size(), nullptr);
+ TrackerDD::SiDetectorElementCollection::iterator newEl{writeCdo->begin()};
+ for (const TrackerDD::SiDetectorElement* oldEl: *oldColl) {
+ *newEl = new TrackerDD::SiDetectorElement(oldEl->identify(),
+ &(oldEl->design()),
+ oldEl->GeoVDetectorElement::getMaterialGeom(),
+ oldEl->getCommonItems(),
+ readCdo);
+ oldToNewMap[oldEl] = *newEl;
+ newEl++;
+ }
+
+ // Set neighbours and other side
+ // Set layer to surface
+ TrackerDD::SiDetectorElementCollection::const_iterator oldIt{oldColl->begin()};
+ for (TrackerDD::SiDetectorElement* newEl: *writeCdo) {
+ if (oldToNewMap[(*oldIt)]!=newEl) {
+ ATH_MSG_ERROR("Old and new elements are not synchronized!");
+ }
+ newEl->setNextInEta(oldToNewMap[(*oldIt)->nextInEta()]);
+ newEl->setPrevInEta(oldToNewMap[(*oldIt)->prevInEta()]);
+ newEl->setNextInPhi(oldToNewMap[(*oldIt)->nextInPhi()]);
+ newEl->setPrevInPhi(oldToNewMap[(*oldIt)->prevInPhi()]);
+ newEl->setOtherSide(oldToNewMap[(*oldIt)->otherSide()]);
+ // Layer of old element is set by InDet::SiLayerBuilder::registerSurfacesToLayer.
+ const Trk::Layer* layer{(*oldIt)->surface().associatedLayer()};
+ if (layer) {
+ newEl->surface().associateLayer(*layer);
+ }
+ oldIt++;
+ }
+
+ // Apply alignment using readCdo passed to SiDetectorElement
+ for (TrackerDD::SiDetectorElement* newEl: *writeCdo) {
+ newEl->setCache();
+ }
+
+ // Record WriteCondHandle
+ const std::size_t size{writeCdo->size()};
+ if (writeHandle.record(rangeW, std::move(writeCdo)).isFailure()) {
+ ATH_MSG_FATAL("Could not record " << writeHandle.key()
+ << " with EventRange " << rangeW
+ << " into Conditions Store");
+ return StatusCode::FAILURE;
+ }
+ ATH_MSG_INFO("recorded new CDO " << writeHandle.key() << " with range " << rangeW << " with size of " << size << " into Conditions Store");
+
+ return StatusCode::SUCCESS;
+}
+
+StatusCode FaserSCT_DetectorElementCondAlg::finalize()
+{
+ ATH_MSG_DEBUG("finalize " << name());
+
+ return StatusCode::SUCCESS;
+}
diff --git a/Tracker/TrackerConditions/FaserSCT_ConditionsAlgorithms/src/FaserSCT_DetectorElementCondAlg.h b/Tracker/TrackerConditions/FaserSCT_ConditionsAlgorithms/src/FaserSCT_DetectorElementCondAlg.h
new file mode 100644
index 0000000000000000000000000000000000000000..262adca71babeac37539bb67ca32aa6bf880f226
--- /dev/null
+++ b/Tracker/TrackerConditions/FaserSCT_ConditionsAlgorithms/src/FaserSCT_DetectorElementCondAlg.h
@@ -0,0 +1,44 @@
+// -*- C++ -*-
+
+/*
+ Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef FASERSCT_CONDITIONSALGORITHMS_SCT_DETECTORELEMENTCONDALG_H
+#define FASERSCT_CONDITIONSALGORITHMS_SCT_DETECTORELEMENTCONDALG_H
+
+#include "AthenaBaseComps/AthReentrantAlgorithm.h"
+
+#include "GeoPrimitives/GeoPrimitives.h"
+#include "GeoModelUtilities/GeoAlignmentStore.h"
+#include "TrackerReadoutGeometry/SiDetectorElementCollection.h"
+#include "StoreGate/ReadCondHandleKey.h"
+#include "StoreGate/WriteCondHandleKey.h"
+
+#include "GaudiKernel/ICondSvc.h"
+
+namespace TrackerDD {
+ class SCT_DetectorManager;
+}
+
+class FaserSCT_DetectorElementCondAlg : public AthReentrantAlgorithm
+{
+ public:
+ FaserSCT_DetectorElementCondAlg(const std::string& name, ISvcLocator* pSvcLocator);
+ virtual ~FaserSCT_DetectorElementCondAlg() override = default;
+
+ virtual StatusCode initialize() override;
+ virtual StatusCode execute(const EventContext& ctx) const override;
+ virtual StatusCode finalize() override;
+ /** Make this algorithm clonable. */
+ virtual bool isClonable() const override { return true; };
+
+ private:
+ SG::ReadCondHandleKey<GeoAlignmentStore> m_readKey;
+ SG::WriteCondHandleKey<TrackerDD::SiDetectorElementCollection> m_writeKey{this, "WriteKey", "SCT_DetectorElementCollection", "Key of output SiDetectorElementCollection for SCT"};
+
+ ServiceHandle<ICondSvc> m_condSvc{this, "CondSvc", "CondSvc"};
+ const TrackerDD::SCT_DetectorManager* m_detManager{nullptr};
+};
+
+#endif // FASERSCT_CONDITIONSALGORITHMS_SCT_DETECTORELEMENTCONDALG_H
diff --git a/Tracker/TrackerConditions/FaserSCT_ConditionsAlgorithms/src/FaserSCT_ReadCalibChipGainCondAlg.cxx b/Tracker/TrackerConditions/FaserSCT_ConditionsAlgorithms/src/FaserSCT_ReadCalibChipGainCondAlg.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..fa7e08687dec16e6f7f504db1d940792b85fc30b
--- /dev/null
+++ b/Tracker/TrackerConditions/FaserSCT_ConditionsAlgorithms/src/FaserSCT_ReadCalibChipGainCondAlg.cxx
@@ -0,0 +1,127 @@
+/*
+ Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+*/
+
+#include "FaserSCT_ReadCalibChipGainCondAlg.h"
+
+#include "Identifier/IdentifierHash.h"
+#include "TrackerIdentifier/FaserSCT_ID.h"
+#include "FaserSCT_ConditionsData/FaserSCT_ConditionsParameters.h"
+#include "SCT_ConditionsTools/SCT_ReadCalibChipUtilities.h"
+
+#include "GaudiKernel/EventIDRange.h"
+
+#include <memory>
+
+using namespace FaserSCT_ConditionsData;
+using namespace SCT_ReadCalibChipUtilities;
+
+FaserSCT_ReadCalibChipGainCondAlg::FaserSCT_ReadCalibChipGainCondAlg(const std::string& name, ISvcLocator* pSvcLocator)
+ : ::AthReentrantAlgorithm(name, pSvcLocator)
+{
+}
+
+StatusCode FaserSCT_ReadCalibChipGainCondAlg::initialize() {
+ ATH_MSG_DEBUG("initialize " << name());
+
+ // CondSvc
+ ATH_CHECK(m_condSvc.retrieve());
+
+ // Get SCT helper
+ ATH_CHECK(detStore()->retrieve(m_id_sct, "FaserSCT_ID"));
+
+ // Read Cond Handle
+ ATH_CHECK(m_readKey.initialize());
+ // Write Cond Handle
+ ATH_CHECK(m_writeKey.initialize());
+ if (m_condSvc->regHandle(this, m_writeKey).isFailure()) {
+ ATH_MSG_FATAL("unable to register WriteCondHandle " << m_writeKey.fullKey() << " with CondSvc");
+ return StatusCode::FAILURE;
+ }
+
+ return StatusCode::SUCCESS;
+}
+
+StatusCode FaserSCT_ReadCalibChipGainCondAlg::execute(const EventContext& ctx) const {
+ ATH_MSG_DEBUG("execute " << name());
+
+ // Write Cond Handle
+ SG::WriteCondHandle<FaserSCT_GainCalibData> writeHandle{m_writeKey, ctx};
+ // Do we have a valid Write Cond Handle for current time?
+ 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;
+ }
+
+ // Read Cond Handle
+ SG::ReadCondHandle<CondAttrListCollection> readHandle{m_readKey, ctx};
+ const CondAttrListCollection* readCdo{*readHandle};
+ if (readCdo==nullptr) {
+ ATH_MSG_FATAL("Null pointer to the read conditions object");
+ return StatusCode::FAILURE;
+ }
+ // Get the validitiy range
+ EventIDRange rangeW;
+ if (not readHandle.range(rangeW)) {
+ ATH_MSG_FATAL("Failed to retrieve validity range for " << readHandle.key());
+ return StatusCode::FAILURE;
+ }
+ ATH_MSG_INFO("Size of CondAttrListCollection " << readHandle.fullKey() << " readCdo->size()= " << readCdo->size());
+ ATH_MSG_INFO("Range of input is " << rangeW);
+
+ // Construct the output Cond Object and fill it in
+ std::unique_ptr<FaserSCT_GainCalibData> writeCdo{std::make_unique<FaserSCT_GainCalibData>()};
+
+ // Initialization
+ const float errVal{std::numeric_limits<float>::quiet_NaN()};
+ for (int m{0}; m!=NUMBER_OF_MODULES; ++m) {
+ for (int p{0}; p!=N_NPTGAIN; ++p) {
+ for (int c{0}; c!=CHIPS_PER_MODULE; ++c) {
+ (*writeCdo)[m][p][c]=errVal;
+ }
+ }
+ }
+
+ // loop over collection
+ CondAttrListCollection::const_iterator itLoop{readCdo->begin()};
+ CondAttrListCollection::const_iterator itLoop_end{readCdo->end()};
+ for (; itLoop!=itLoop_end; ++itLoop) {
+ CondAttrListCollection::ChanNum chanNum{itLoop->first};
+ const coral::AttributeList &anAttrList{itLoop->second};
+ // Convert chanNum=offlineID into identifier
+ Identifier32 moduleId{chanNum};
+ //find the corresponding hash
+ const IdentifierHash hashId{m_id_sct->wafer_hash(moduleId)};
+ //find the index to the module (hash is for each side), to use as index into array
+ const unsigned int moduleIdx{hashId/SIDES_PER_MODULE};
+ FaserSCT_ModuleGainCalibData& theseCalibData{(*writeCdo)[moduleIdx]};
+ insertNptGainFolderData(theseCalibData, anAttrList);
+ }
+
+ // Record the output cond object
+ if (writeHandle.record(rangeW, std::move(writeCdo)).isFailure()) {
+ ATH_MSG_FATAL("Could not record FaserSCT_GainCalibData " << writeHandle.key()
+ << " with EventRange " << rangeW
+ << " into Conditions Store");
+ return StatusCode::FAILURE;
+ }
+ ATH_MSG_INFO("recorded new CDO " << writeHandle.key() << " with range " << rangeW << " into Conditions Store");
+
+ return StatusCode::SUCCESS;
+}
+
+StatusCode FaserSCT_ReadCalibChipGainCondAlg::finalize() {
+ ATH_MSG_DEBUG("finalize " << name());
+ return StatusCode::SUCCESS;
+}
+
+void
+FaserSCT_ReadCalibChipGainCondAlg::insertNptGainFolderData(FaserSCT_ModuleGainCalibData& theseCalibData, const coral::AttributeList& folderData) const {
+ for (int i{0}; i!=N_NPTGAIN; ++i) {
+ FaserSCT_ModuleCalibParameter& datavec{theseCalibData[i]};
+ const std::string &dbData{((folderData)[nPtGainDbParameterNames[i]]).data<std::string>()};
+ fillFromString(dbData, datavec);
+ }
+}
diff --git a/Tracker/TrackerConditions/FaserSCT_ConditionsAlgorithms/src/FaserSCT_ReadCalibChipGainCondAlg.h b/Tracker/TrackerConditions/FaserSCT_ConditionsAlgorithms/src/FaserSCT_ReadCalibChipGainCondAlg.h
new file mode 100644
index 0000000000000000000000000000000000000000..3ce3427da1ea6df0662f377ea74f3ec3610967a1
--- /dev/null
+++ b/Tracker/TrackerConditions/FaserSCT_ConditionsAlgorithms/src/FaserSCT_ReadCalibChipGainCondAlg.h
@@ -0,0 +1,49 @@
+// -*- C++ -*-
+
+/*
+ Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef FaserSCT_ReadCalibChipGainCondAlg_h
+#define FaserSCT_ReadCalibChipGainCondAlg_h
+
+// Include parent class
+#include "AthenaBaseComps/AthReentrantAlgorithm.h"
+
+// Include Gaudi classes
+#include "GaudiKernel/ICondSvc.h"
+#include "GaudiKernel/Property.h"
+
+// Include Athena classes
+#include "StoreGate/ReadCondHandleKey.h"
+#include "StoreGate/WriteCondHandleKey.h"
+#include "AthenaPoolUtilities/CondAttrListCollection.h"
+#include "FaserSCT_ConditionsData/FaserSCT_GainCalibData.h"
+
+// Include boost stuff
+#include "boost/array.hpp"
+
+// Forward declarations
+class FaserSCT_ID;
+
+class FaserSCT_ReadCalibChipGainCondAlg : public AthReentrantAlgorithm
+{
+ public:
+ FaserSCT_ReadCalibChipGainCondAlg(const std::string& name, ISvcLocator* pSvcLocator);
+ virtual ~FaserSCT_ReadCalibChipGainCondAlg() = default;
+ virtual StatusCode initialize() override;
+ virtual StatusCode execute(const EventContext& ctx) const override;
+ virtual StatusCode finalize() override;
+ /** Make this algorithm clonable. */
+ virtual bool isClonable() const override { return true; };
+
+ private:
+ void insertNptGainFolderData(FaserSCT_ModuleGainCalibData& theseCalibData, const coral::AttributeList& folderData) const;
+
+ SG::ReadCondHandleKey<CondAttrListCollection> m_readKey{this, "ReadKey", "/SCT/DAQ/Calibration/ChipGain", "Key of input (raw) gain conditions folder"};
+ SG::WriteCondHandleKey<FaserSCT_GainCalibData> m_writeKey{this, "WriteKey", "SCT_GainCalibData", "Key of output (derived) gain conditions data"};
+ ServiceHandle<ICondSvc> m_condSvc{this, "CondSvc", "CondSvc"};
+ const FaserSCT_ID* m_id_sct{nullptr}; //!< Handle to FaserSCT ID helper
+};
+
+#endif // FaserSCT_ReadCalibChipGainCondAlg_h
diff --git a/Tracker/TrackerConditions/FaserSCT_ConditionsAlgorithms/src/FaserSCT_ReadCalibChipNoiseCondAlg.cxx b/Tracker/TrackerConditions/FaserSCT_ConditionsAlgorithms/src/FaserSCT_ReadCalibChipNoiseCondAlg.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..bd2e3603c68b283d3d7e138cc991c03053528533
--- /dev/null
+++ b/Tracker/TrackerConditions/FaserSCT_ConditionsAlgorithms/src/FaserSCT_ReadCalibChipNoiseCondAlg.cxx
@@ -0,0 +1,128 @@
+/*
+ Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+*/
+
+#include "FaserSCT_ReadCalibChipNoiseCondAlg.h"
+
+#include "Identifier/IdentifierHash.h"
+#include "TrackerIdentifier/FaserSCT_ID.h"
+#include "FaserSCT_ConditionsData/FaserSCT_ConditionsParameters.h"
+#include "SCT_ConditionsTools/SCT_ReadCalibChipUtilities.h"
+
+#include "GaudiKernel/EventIDRange.h"
+
+#include <limits>
+#include <memory>
+
+using namespace FaserSCT_ConditionsData;
+using namespace SCT_ReadCalibChipUtilities;
+
+FaserSCT_ReadCalibChipNoiseCondAlg::FaserSCT_ReadCalibChipNoiseCondAlg(const std::string& name, ISvcLocator* pSvcLocator)
+ : ::AthReentrantAlgorithm(name, pSvcLocator)
+{
+}
+
+StatusCode FaserSCT_ReadCalibChipNoiseCondAlg::initialize() {
+ ATH_MSG_DEBUG("initialize " << name());
+
+ // CondSvc
+ ATH_CHECK(m_condSvc.retrieve());
+
+ // Get SCT helper
+ ATH_CHECK(detStore()->retrieve(m_id_sct, "FaserSCT_ID"));
+
+ // Read Cond Handle
+ ATH_CHECK(m_readKey.initialize());
+ // Write Cond Handle
+ ATH_CHECK(m_writeKey.initialize());
+ if (m_condSvc->regHandle(this, m_writeKey).isFailure()) {
+ ATH_MSG_FATAL("unable to register WriteCondHandle " << m_writeKey.fullKey() << " with CondSvc");
+ return StatusCode::FAILURE;
+ }
+
+ return StatusCode::SUCCESS;
+}
+
+StatusCode FaserSCT_ReadCalibChipNoiseCondAlg::execute(const EventContext& ctx) const {
+ ATH_MSG_DEBUG("execute " << name());
+
+ // Write Cond Handle
+ SG::WriteCondHandle<FaserSCT_NoiseCalibData> writeHandle{m_writeKey, ctx};
+ // Do we have a valid Write Cond Handle for current time?
+ 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;
+ }
+
+ // Read Cond Handle
+ SG::ReadCondHandle<CondAttrListCollection> readHandle{m_readKey, ctx};
+ const CondAttrListCollection* readCdo{*readHandle};
+ if (readCdo==nullptr) {
+ ATH_MSG_FATAL("Null pointer to the read conditions object");
+ return StatusCode::FAILURE;
+ }
+ // Get the validitiy range
+ EventIDRange rangeW;
+ if (not readHandle.range(rangeW)) {
+ ATH_MSG_FATAL("Failed to retrieve validity range for " << readHandle.key());
+ return StatusCode::FAILURE;
+ }
+ ATH_MSG_INFO("Size of CondAttrListCollection " << readHandle.fullKey() << " readCdo->size()= " << readCdo->size());
+ ATH_MSG_INFO("Range of input is " << rangeW);
+
+ // Construct the output Cond Object and fill it in
+ std::unique_ptr<FaserSCT_NoiseCalibData> writeCdo{std::make_unique<FaserSCT_NoiseCalibData>()};
+
+ // Initialization
+ const float errVal{std::numeric_limits<float>::quiet_NaN()};
+ for (unsigned int m{0}; m!=NUMBER_OF_MODULES; ++m) {
+ for (unsigned int p{0}; p!=N_NOISEOCC; ++p) {
+ for (unsigned int c{0}; c!=CHIPS_PER_MODULE; ++c) {
+ (*writeCdo)[m][p][c]=errVal;
+ }
+ }
+ }
+
+ // loop over collection
+ CondAttrListCollection::const_iterator itLoop{readCdo->begin()};
+ CondAttrListCollection::const_iterator itLoop_end{readCdo->end()};
+ for (; itLoop!=itLoop_end; ++itLoop) {
+ CondAttrListCollection::ChanNum chanNum{itLoop->first};
+ const coral::AttributeList& anAttrList{itLoop->second};
+ // Convert chanNum=offlineID into identifier
+ Identifier32 moduleId{chanNum};
+ //find the corresponding hash
+ const IdentifierHash hashId{m_id_sct->wafer_hash(moduleId)};
+ //find the index to the module (hash is for each side), to use as index into array
+ const unsigned int moduleIdx{hashId/SIDES_PER_MODULE};
+ FaserSCT_ModuleNoiseCalibData& theseCalibData{(*writeCdo)[moduleIdx]};
+ insertNoiseOccFolderData(theseCalibData, anAttrList);
+ }
+
+ // Record the output cond object
+ if (writeHandle.record(rangeW, std::move(writeCdo)).isFailure()) {
+ ATH_MSG_FATAL("Could not record FaserSCT_NoiseCalibData " << writeHandle.key()
+ << " with EventRange " << rangeW
+ << " into Conditions Store");
+ return StatusCode::FAILURE;
+ }
+ ATH_MSG_INFO("recorded new CDO " << writeHandle.key() << " with range " << rangeW << " into Conditions Store");
+
+ return StatusCode::SUCCESS;
+}
+
+StatusCode FaserSCT_ReadCalibChipNoiseCondAlg::finalize() {
+ ATH_MSG_DEBUG("finalize " << name());
+ return StatusCode::SUCCESS;
+}
+
+void
+FaserSCT_ReadCalibChipNoiseCondAlg::insertNoiseOccFolderData(FaserSCT_ModuleNoiseCalibData& theseCalibData, const coral::AttributeList& folderData) const {
+ for (int i{0}; i!=N_NOISEOCC; ++i) {
+ FaserSCT_ModuleCalibParameter& datavec{theseCalibData[i]};
+ std::string dbData{((folderData)[noiseOccDbParameterNames[i]]).data<std::string>()};
+ fillFromString(dbData, datavec);
+ }
+}
diff --git a/Tracker/TrackerConditions/FaserSCT_ConditionsAlgorithms/src/FaserSCT_ReadCalibChipNoiseCondAlg.h b/Tracker/TrackerConditions/FaserSCT_ConditionsAlgorithms/src/FaserSCT_ReadCalibChipNoiseCondAlg.h
new file mode 100644
index 0000000000000000000000000000000000000000..fd2602032dde27181de0facd99f8e2d8e29d7109
--- /dev/null
+++ b/Tracker/TrackerConditions/FaserSCT_ConditionsAlgorithms/src/FaserSCT_ReadCalibChipNoiseCondAlg.h
@@ -0,0 +1,49 @@
+// -*- C++ -*-
+
+/*
+ Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef FaserSCT_ReadCalibChipNoiseCondAlg_h
+#define FaserSCT_ReadCalibChipNoiseCondAlg_h
+
+// Include parent class
+#include "AthenaBaseComps/AthReentrantAlgorithm.h"
+
+// Include Athena classes
+#include "AthenaPoolUtilities/CondAttrListCollection.h"
+#include "FaserSCT_ConditionsData/FaserSCT_NoiseCalibData.h"
+#include "StoreGate/ReadCondHandleKey.h"
+#include "StoreGate/WriteCondHandleKey.h"
+
+// Include Gaudi classes
+#include "GaudiKernel/ICondSvc.h"
+#include "GaudiKernel/Property.h"
+
+// Include boost stuff
+#include "boost/array.hpp"
+
+// Forward declarations
+class FaserSCT_ID;
+
+class FaserSCT_ReadCalibChipNoiseCondAlg : public AthReentrantAlgorithm
+{
+ public:
+ FaserSCT_ReadCalibChipNoiseCondAlg(const std::string& name, ISvcLocator* pSvcLocator);
+ virtual ~FaserSCT_ReadCalibChipNoiseCondAlg() = default;
+ virtual StatusCode initialize() override;
+ virtual StatusCode execute(const EventContext& ctx) const override;
+ virtual StatusCode finalize() override;
+ /** Make this algorithm clonable. */
+ virtual bool isClonable() const override { return true; };
+
+ private:
+ void insertNoiseOccFolderData(FaserSCT_ModuleNoiseCalibData& theseCalibData, const coral::AttributeList& folderData) const;
+
+ SG::ReadCondHandleKey<CondAttrListCollection> m_readKey{this, "ReadKey", "/SCT/DAQ/Calibration/ChipNoise", "Key of input (raw) noise conditions folder"};
+ SG::WriteCondHandleKey<FaserSCT_NoiseCalibData> m_writeKey{this, "WriteKey", "SCT_NoiseCalibData", "Key of output (derived) noise conditions data"};
+ ServiceHandle<ICondSvc> m_condSvc{this, "CondSvc", "CondSvc"};
+ const FaserSCT_ID* m_id_sct{nullptr}; //!< Handle to SCT ID helper
+};
+
+#endif // FaserSCT_ReadCalibChipNoiseCondAlg_h
diff --git a/Tracker/TrackerConditions/FaserSCT_ConditionsAlgorithms/src/FaserSCT_SiliconHVCondAlg.cxx b/Tracker/TrackerConditions/FaserSCT_ConditionsAlgorithms/src/FaserSCT_SiliconHVCondAlg.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..6634c5449ec315a957c633ad98ffaf6513b0991d
--- /dev/null
+++ b/Tracker/TrackerConditions/FaserSCT_ConditionsAlgorithms/src/FaserSCT_SiliconHVCondAlg.cxx
@@ -0,0 +1,119 @@
+/*
+ Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+*/
+
+#include "FaserSCT_SiliconHVCondAlg.h"
+
+#include "Identifier/IdentifierHash.h"
+#include "TrackerIdentifier/FaserSCT_ID.h"
+
+#include "GaudiKernel/EventIDRange.h"
+
+#include <memory>
+
+FaserSCT_SiliconHVCondAlg::FaserSCT_SiliconHVCondAlg(const std::string& name, ISvcLocator* pSvcLocator)
+ : ::AthReentrantAlgorithm(name, pSvcLocator)
+{
+}
+
+StatusCode FaserSCT_SiliconHVCondAlg::initialize() {
+ ATH_MSG_DEBUG("initialize " << name());
+
+ // SCT DCS tool
+ ATH_CHECK(m_sctDCSTool.retrieve());
+ // SCT ID helper
+ ATH_CHECK(detStore()->retrieve(m_pHelper, "FaserSCT_ID"));
+
+ // CondSvc
+ ATH_CHECK(m_condSvc.retrieve());
+ // Read Cond Handles
+ if (m_useState.value()) {
+ ATH_CHECK(m_readKeyState.initialize());
+ }
+ ATH_CHECK(m_readKeyHV.initialize());
+ // Write Cond Handle
+ ATH_CHECK(m_writeKey.initialize());
+ if (m_condSvc->regHandle(this, m_writeKey).isFailure()) {
+ ATH_MSG_FATAL("unable to register WriteCondHandle " << m_writeKey.fullKey() << " with CondSvc");
+ return StatusCode::FAILURE;
+ }
+
+ return StatusCode::SUCCESS;
+}
+
+StatusCode FaserSCT_SiliconHVCondAlg::execute(const EventContext& ctx) const {
+ ATH_MSG_DEBUG("execute " << name());
+
+ // Write Cond Handle
+ SG::WriteCondHandle<FaserSCT_DCSFloatCondData> writeHandle{m_writeKey, ctx};
+ // Do we have a valid Write Cond Handle for current time?
+ 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;
+ }
+
+ // Read Cond Handle (HV)
+ SG::ReadCondHandle<FaserSCT_DCSFloatCondData> readHandleHV{m_readKeyHV, ctx};
+ const FaserSCT_DCSFloatCondData* readCdoHV{*readHandleHV};
+ if (readCdoHV==nullptr) {
+ ATH_MSG_FATAL("Null pointer to the read conditions object");
+ return StatusCode::FAILURE;
+ }
+ EventIDRange rangeHV;
+ if (not readHandleHV.range(rangeHV)) {
+ ATH_MSG_FATAL("Failed to retrieve validity range for " << readHandleHV.key());
+ return StatusCode::FAILURE;
+ }
+ ATH_MSG_INFO("Input is " << readHandleHV.fullKey() << " with the range of " << rangeHV);
+
+ EventIDRange rangeW{rangeHV};
+
+ if (m_useState.value()) {
+ // Read Cond Handle (state)
+ SG::ReadCondHandle<FaserSCT_DCSStatCondData> readHandleState{m_readKeyState, ctx};
+ const FaserSCT_DCSStatCondData* readCdoState{*readHandleState};
+ if (readCdoState==nullptr) {
+ ATH_MSG_FATAL("Null pointer to the read conditions object");
+ return StatusCode::FAILURE;
+ }
+ EventIDRange rangeState;
+ if (not readHandleState.range(rangeState)) {
+ ATH_MSG_FATAL("Failed to retrieve validity range for " << readHandleState.key());
+ return StatusCode::FAILURE;
+ }
+ ATH_MSG_INFO("Input is " << readHandleState.fullKey() << " with the range of " << rangeState);
+
+ // Combined the validity ranges of state and range
+ rangeW = EventIDRange::intersect(rangeState, rangeHV);
+ if (rangeW.stop().isValid() and rangeW.start()>rangeW.stop()) {
+ ATH_MSG_FATAL("Invalid intersection range: " << rangeW);
+ return StatusCode::FAILURE;
+ }
+ }
+
+ // Construct the output Cond Object and fill it in
+ std::unique_ptr<FaserSCT_DCSFloatCondData> writeCdo{std::make_unique<FaserSCT_DCSFloatCondData>()};
+ const FaserSCT_ID::size_type wafer_hash_max{m_pHelper->wafer_hash_max()};
+ for (FaserSCT_ID::size_type hash{0}; hash<wafer_hash_max; hash++) {
+ writeCdo->setValue(hash, m_sctDCSTool->modHV(IdentifierHash(hash), ctx));
+ }
+
+ // Record the output cond object
+ if (writeHandle.record(rangeW, std::move(writeCdo)).isFailure()) {
+ ATH_MSG_FATAL("Could not record FaserSCT_DCSFloatCondData " << writeHandle.key()
+ << " with EventRange " << rangeW
+ << " into Conditions Store");
+ return StatusCode::FAILURE;
+ }
+ ATH_MSG_INFO("recorded new CDO " << writeHandle.key() << " with range " << rangeW << " into Conditions Store");
+
+ return StatusCode::SUCCESS;
+}
+
+StatusCode FaserSCT_SiliconHVCondAlg::finalize()
+{
+ ATH_MSG_DEBUG("finalize " << name());
+ return StatusCode::SUCCESS;
+}
diff --git a/Tracker/TrackerConditions/FaserSCT_ConditionsAlgorithms/src/FaserSCT_SiliconHVCondAlg.h b/Tracker/TrackerConditions/FaserSCT_ConditionsAlgorithms/src/FaserSCT_SiliconHVCondAlg.h
new file mode 100644
index 0000000000000000000000000000000000000000..0807e65e233bfa4012ed9acde51b8fbe8ba19fe3
--- /dev/null
+++ b/Tracker/TrackerConditions/FaserSCT_ConditionsAlgorithms/src/FaserSCT_SiliconHVCondAlg.h
@@ -0,0 +1,41 @@
+/*
+ Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef FASERSCT_SILICONHVCONDALG
+#define FASERSCT_SILICONHVCONDALG
+
+#include "AthenaBaseComps/AthReentrantAlgorithm.h"
+
+#include "StoreGate/ReadCondHandleKey.h"
+#include "StoreGate/WriteCondHandleKey.h"
+#include "FaserSCT_ConditionsData/FaserSCT_DCSStatCondData.h"
+#include "FaserSCT_ConditionsData/FaserSCT_DCSFloatCondData.h"
+#include "SCT_ConditionsTools/ISCT_DCSConditionsTool.h"
+
+#include "GaudiKernel/ICondSvc.h"
+
+class FaserSCT_ID;
+
+class FaserSCT_SiliconHVCondAlg : public AthReentrantAlgorithm
+{
+ public:
+ FaserSCT_SiliconHVCondAlg(const std::string& name, ISvcLocator* pSvcLocator);
+ virtual ~FaserSCT_SiliconHVCondAlg() = default;
+ virtual StatusCode initialize() override;
+ virtual StatusCode execute(const EventContext& ctx) const override;
+ virtual StatusCode finalize() override;
+ /** Make this algorithm clonable. */
+ virtual bool isClonable() const override { return true; };
+
+ private:
+ BooleanProperty m_useState{this, "UseState", true, "Flag to use state conditions folder"};
+ SG::ReadCondHandleKey<FaserSCT_DCSStatCondData> m_readKeyState{this, "ReadKeyState", "SCT_DCSStatCondData", "Key of input state conditions data"};
+ SG::ReadCondHandleKey<FaserSCT_DCSFloatCondData> m_readKeyHV{this, "ReadKeyHV", "SCT_DCSHVCondData", "Key of input HV conditions data"};
+ SG::WriteCondHandleKey<FaserSCT_DCSFloatCondData> m_writeKey{this, "WriteKey", "SCT_SiliconBiasVoltCondData", "Key of output bias voltage conditions data"};
+ ServiceHandle<ICondSvc> m_condSvc{this, "CondSvc", "CondSvc"};
+ ToolHandle<ISCT_DCSConditionsTool> m_sctDCSTool{this, "DCSConditionsTool", "TrackerSCT_DCSConditionsTool", "Tool to retrived SCT DCS information"};
+ const FaserSCT_ID* m_pHelper{nullptr};//!< ID helper for FaserSCT
+};
+
+#endif // FaserSCT_SILICONHVCONDALG
diff --git a/Tracker/TrackerConditions/FaserSCT_ConditionsAlgorithms/src/FaserSCT_SiliconTempCondAlg.cxx b/Tracker/TrackerConditions/FaserSCT_ConditionsAlgorithms/src/FaserSCT_SiliconTempCondAlg.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..f7b8757a306935f90d52a9e1200e8cd01463f3c5
--- /dev/null
+++ b/Tracker/TrackerConditions/FaserSCT_ConditionsAlgorithms/src/FaserSCT_SiliconTempCondAlg.cxx
@@ -0,0 +1,119 @@
+/*
+ Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+*/
+
+#include "FaserSCT_SiliconTempCondAlg.h"
+
+#include "Identifier/IdentifierHash.h"
+#include "TrackerIdentifier/FaserSCT_ID.h"
+
+#include "GaudiKernel/EventIDRange.h"
+
+#include <memory>
+
+FaserSCT_SiliconTempCondAlg::FaserSCT_SiliconTempCondAlg(const std::string& name, ISvcLocator* pSvcLocator)
+ : ::AthReentrantAlgorithm(name, pSvcLocator)
+{
+}
+
+StatusCode FaserSCT_SiliconTempCondAlg::initialize() {
+ ATH_MSG_DEBUG("initialize " << name());
+
+ // SCT DCS tool
+ ATH_CHECK(m_sctDCSTool.retrieve());
+ // SCT ID helper
+ ATH_CHECK(detStore()->retrieve(m_pHelper, "FaserSCT_ID"));
+
+ // CondSvc
+ ATH_CHECK(m_condSvc.retrieve());
+ // Read Cond Handle
+ if (m_useState.value()) {
+ ATH_CHECK(m_readKeyState.initialize());
+ }
+ ATH_CHECK(m_readKeyTemp0.initialize());
+ // Write Cond Handles
+ ATH_CHECK(m_writeKey.initialize());
+ if (m_condSvc->regHandle(this, m_writeKey).isFailure()) {
+ ATH_MSG_FATAL("unable to register WriteCondHandle " << m_writeKey.fullKey() << " with CondSvc");
+ return StatusCode::FAILURE;
+ }
+
+ return StatusCode::SUCCESS;
+}
+
+StatusCode FaserSCT_SiliconTempCondAlg::execute(const EventContext& ctx) const {
+ ATH_MSG_DEBUG("execute " << name());
+
+ // Write Cond Handle
+ SG::WriteCondHandle<FaserSCT_DCSFloatCondData> writeHandle{m_writeKey, ctx};
+ // Do we have a valid Write Cond Handle for current time?
+ 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;
+ }
+
+ // Read Cond Handle (temperature)
+ SG::ReadCondHandle<FaserSCT_DCSFloatCondData> readHandleTemp0{m_readKeyTemp0, ctx};
+ const FaserSCT_DCSFloatCondData* readCdoTemp0{*readHandleTemp0};
+ if (readCdoTemp0==nullptr) {
+ ATH_MSG_FATAL("Null pointer to the read conditions object");
+ return StatusCode::FAILURE;
+ }
+ EventIDRange rangeTemp0;
+ if (not readHandleTemp0.range(rangeTemp0)) {
+ ATH_MSG_FATAL("Failed to retrieve validity range for " << readHandleTemp0.key());
+ return StatusCode::FAILURE;
+ }
+ ATH_MSG_INFO("Input is " << readHandleTemp0.fullKey() << " with the range of " << rangeTemp0);
+
+ EventIDRange rangeW{rangeTemp0};
+
+ if (m_useState.value()) {
+ // Read Cond Handle (state)
+ SG::ReadCondHandle<FaserSCT_DCSStatCondData> readHandleState{m_readKeyState, ctx};
+ const FaserSCT_DCSStatCondData* readCdoState{*readHandleState};
+ if (readCdoState==nullptr) {
+ ATH_MSG_FATAL("Null pointer to the read conditions object");
+ return StatusCode::FAILURE;
+ }
+ EventIDRange rangeState;
+ if (not readHandleState.range(rangeState)) {
+ ATH_MSG_FATAL("Failed to retrieve validity range for " << readHandleState.key());
+ return StatusCode::FAILURE;
+ }
+ ATH_MSG_INFO("Input is " << readHandleState.fullKey() << " with the range of " << rangeState);
+
+ // Combined the validity ranges of state and range
+ rangeW = EventIDRange::intersect(rangeState, rangeTemp0);
+ if (rangeW.stop().isValid() and rangeW.start()>rangeW.stop()) {
+ ATH_MSG_FATAL("Invalid intersection range: " << rangeW);
+ return StatusCode::FAILURE;
+ }
+ }
+
+ // Construct the output Cond Object and fill it in
+ std::unique_ptr<FaserSCT_DCSFloatCondData> writeCdo{std::make_unique<FaserSCT_DCSFloatCondData>()};
+ const FaserSCT_ID::size_type wafer_hash_max{m_pHelper->wafer_hash_max()};
+ for (FaserSCT_ID::size_type hash{0}; hash<wafer_hash_max; hash++) {
+ writeCdo->setValue(hash, m_sctDCSTool->sensorTemperature(IdentifierHash(hash), ctx));
+ }
+
+ // Record the output cond object
+ if (writeHandle.record(rangeW, std::move(writeCdo)).isFailure()) {
+ ATH_MSG_FATAL("Could not record FaserSCT_DCSFloatCondData " << writeHandle.key()
+ << " with EventRange " << rangeW
+ << " into Conditions Store");
+ return StatusCode::FAILURE;
+ }
+ ATH_MSG_INFO("recorded new CDO " << writeHandle.key() << " with range " << rangeW << " into Conditions Store");
+
+ return StatusCode::SUCCESS;
+}
+
+StatusCode FaserSCT_SiliconTempCondAlg::finalize()
+{
+ ATH_MSG_DEBUG("finalize " << name());
+ return StatusCode::SUCCESS;
+}
diff --git a/Tracker/TrackerConditions/FaserSCT_ConditionsAlgorithms/src/FaserSCT_SiliconTempCondAlg.h b/Tracker/TrackerConditions/FaserSCT_ConditionsAlgorithms/src/FaserSCT_SiliconTempCondAlg.h
new file mode 100644
index 0000000000000000000000000000000000000000..4bb0d561ec5d165f34e86c211737f2991df65d32
--- /dev/null
+++ b/Tracker/TrackerConditions/FaserSCT_ConditionsAlgorithms/src/FaserSCT_SiliconTempCondAlg.h
@@ -0,0 +1,41 @@
+/*
+ Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef FASERSCT_SILICONTEMPCONDALG
+#define FASERSCT_SILICONTEMPCONDALG
+
+#include "AthenaBaseComps/AthReentrantAlgorithm.h"
+
+#include "FaserSCT_ConditionsData/FaserSCT_DCSStatCondData.h"
+#include "FaserSCT_ConditionsData/FaserSCT_DCSFloatCondData.h"
+#include "SCT_ConditionsTools/ISCT_DCSConditionsTool.h"
+#include "StoreGate/ReadCondHandleKey.h"
+#include "StoreGate/WriteCondHandleKey.h"
+
+#include "GaudiKernel/ICondSvc.h"
+
+class FaserSCT_ID;
+
+class FaserSCT_SiliconTempCondAlg : public AthReentrantAlgorithm
+{
+ public:
+ FaserSCT_SiliconTempCondAlg(const std::string& name, ISvcLocator* pSvcLocator);
+ virtual ~FaserSCT_SiliconTempCondAlg() = default;
+ virtual StatusCode initialize() override;
+ virtual StatusCode execute(const EventContext& ctx) const override;
+ virtual StatusCode finalize() override;
+ /** Make this algorithm clonable. */
+ virtual bool isClonable() const override { return true; };
+
+ private:
+ BooleanProperty m_useState{this, "UseState", true, "Flag to use state conditions folder"};
+ SG::ReadCondHandleKey<FaserSCT_DCSStatCondData> m_readKeyState{this, "ReadKeyState", "SCT_DCSStatCondData", "Key of input state conditions data"};
+ SG::ReadCondHandleKey<FaserSCT_DCSFloatCondData> m_readKeyTemp0{this, "ReadKeyTemp", "SCT_DCSTemp0CondData", "Key of input (hybrid) temperature conditions data"};
+ SG::WriteCondHandleKey<FaserSCT_DCSFloatCondData> m_writeKey{this, "WriteKey", "SCT_SiliconTempCondData", "Key of output (sensor) temperature conditions data"};
+ ServiceHandle<ICondSvc> m_condSvc{this, "CondSvc", "CondSvc"};
+ ToolHandle<ISCT_DCSConditionsTool> m_sctDCSTool{this, "DCSConditionsTool", "TrackerSCT_DCSConditionsTool", "Tool to retrived SCT DCS information"};
+ const FaserSCT_ID* m_pHelper{nullptr}; //!< ID helper for FaserSCT
+};
+
+#endif // FASERSCT_SILICONTEMPCONDALG
diff --git a/Tracker/TrackerConditions/FaserSCT_ConditionsAlgorithms/src/components/FaserSCT_ConditionsAlgorithms_entries.cxx b/Tracker/TrackerConditions/FaserSCT_ConditionsAlgorithms/src/components/FaserSCT_ConditionsAlgorithms_entries.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..f8b127e85d0a477d87019556c48cc0873a19eee8
--- /dev/null
+++ b/Tracker/TrackerConditions/FaserSCT_ConditionsAlgorithms/src/components/FaserSCT_ConditionsAlgorithms_entries.cxx
@@ -0,0 +1,73 @@
+#include "../FaserSCT_AlignCondAlg.h"
+// #include "../SCT_ByteStreamErrorsTestAlg.h"
+// #include "../SCT_ConditionsParameterCondAlg.h"
+// #include "../SCT_ConditionsParameterTestAlg.h"
+// #include "../SCT_ConditionsSummaryTestAlg.h"
+// #include "../SCT_ConfigurationCondAlg.h"
+// #include "../SCT_ConfigurationConditionsTestAlg.h"
+#include "../FaserSCT_DCSConditionsHVCondAlg.h"
+#include "../FaserSCT_DCSConditionsStatCondAlg.h"
+#include "../FaserSCT_DCSConditionsTempCondAlg.h"
+// #include "../SCT_DCSConditionsTestAlg.h"
+#include "../FaserSCT_DetectorElementCondAlg.h"
+// #include "../SCT_LinkMaskingCondAlg.h"
+// #include "../SCT_LinkMaskingTestAlg.h"
+// #include "../SCT_MajorityCondAlg.h"
+// #include "../SCT_MajorityConditionsTestAlg.h"
+// #include "../SCT_ModuleVetoCondAlg.h"
+// #include "../SCT_ModuleVetoTestAlg.h"
+// #include "../SCT_MonitorCondAlg.h"
+// #include "../SCT_MonitorConditionsTestAlg.h"
+// #include "../SCT_ReadCalibChipDataTestAlg.h"
+#include "../FaserSCT_ReadCalibChipGainCondAlg.h"
+#include "../FaserSCT_ReadCalibChipNoiseCondAlg.h"
+// #include "../SCT_ReadCalibDataCondAlg.h"
+// #include "../SCT_ReadCalibDataTestAlg.h"
+// #include "../SCT_ReadoutTestAlg.h"
+// #include "../SCT_RODVetoCondAlg.h"
+// #include "../SCT_RODVetoTestAlg.h"
+// #include "../SCT_SensorsCondAlg.h"
+// #include "../SCT_SensorsTestAlg.h"
+// #include "../SCT_SiliconConditionsTestAlg.h"
+#include "../FaserSCT_SiliconHVCondAlg.h"
+#include "../FaserSCT_SiliconTempCondAlg.h"
+// #include "../SCT_StripVetoTestAlg.h"
+// #include "../SCT_TdaqEnabledCondAlg.h"
+// #include "../SCT_TdaqEnabledTestAlg.h"
+
+DECLARE_COMPONENT( FaserSCT_AlignCondAlg )
+// DECLARE_COMPONENT( SCT_ByteStreamErrorsTestAlg )
+// DECLARE_COMPONENT( SCT_ConditionsParameterCondAlg )
+// DECLARE_COMPONENT( SCT_ConditionsParameterTestAlg )
+// DECLARE_COMPONENT( SCT_ConditionsSummaryTestAlg )
+// DECLARE_COMPONENT( SCT_ConfigurationCondAlg )
+// DECLARE_COMPONENT( SCT_ConfigurationConditionsTestAlg )
+DECLARE_COMPONENT( FaserSCT_DCSConditionsHVCondAlg )
+DECLARE_COMPONENT( FaserSCT_DCSConditionsStatCondAlg )
+DECLARE_COMPONENT( FaserSCT_DCSConditionsTempCondAlg )
+// DECLARE_COMPONENT( SCT_DCSConditionsTestAlg )
+DECLARE_COMPONENT( FaserSCT_DetectorElementCondAlg )
+// DECLARE_COMPONENT( SCT_LinkMaskingCondAlg )
+// DECLARE_COMPONENT( SCT_LinkMaskingTestAlg )
+// DECLARE_COMPONENT( SCT_MajorityCondAlg )
+// DECLARE_COMPONENT( SCT_MajorityConditionsTestAlg )
+// DECLARE_COMPONENT( SCT_ModuleVetoCondAlg )
+// DECLARE_COMPONENT( SCT_ModuleVetoTestAlg )
+// DECLARE_COMPONENT( SCT_MonitorCondAlg )
+// DECLARE_COMPONENT( SCT_MonitorConditionsTestAlg )
+// DECLARE_COMPONENT( SCT_ReadCalibChipDataTestAlg )
+DECLARE_COMPONENT( FaserSCT_ReadCalibChipGainCondAlg )
+DECLARE_COMPONENT( FaserSCT_ReadCalibChipNoiseCondAlg )
+// DECLARE_COMPONENT( SCT_ReadCalibDataCondAlg )
+// DECLARE_COMPONENT( SCT_ReadCalibDataTestAlg )
+// DECLARE_COMPONENT( SCT_ReadoutTestAlg )
+// DECLARE_COMPONENT( SCT_RODVetoCondAlg )
+// DECLARE_COMPONENT( SCT_RODVetoTestAlg )
+// DECLARE_COMPONENT( SCT_SensorsCondAlg )
+// DECLARE_COMPONENT( SCT_SensorsTestAlg )
+// DECLARE_COMPONENT( SCT_SiliconConditionsTestAlg )
+DECLARE_COMPONENT( FaserSCT_SiliconHVCondAlg )
+DECLARE_COMPONENT( FaserSCT_SiliconTempCondAlg )
+// DECLARE_COMPONENT( SCT_StripVetoTestAlg )
+// DECLARE_COMPONENT( SCT_TdaqEnabledCondAlg )
+// DECLARE_COMPONENT( SCT_TdaqEnabledTestAlg )
diff --git a/Tracker/TrackerConditions/FaserSCT_ConditionsData/CMakeLists.txt b/Tracker/TrackerConditions/FaserSCT_ConditionsData/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..bee3a568e8fb7b6ce9800513d1f6e5521b2a6b36
--- /dev/null
+++ b/Tracker/TrackerConditions/FaserSCT_ConditionsData/CMakeLists.txt
@@ -0,0 +1,33 @@
+################################################################################
+# Package: FaserSCT_ConditionsData
+################################################################################
+
+# Declare the package name:
+atlas_subdir( FaserSCT_ConditionsData )
+
+# Declare the package's dependencies:
+atlas_depends_on_subdirs( PUBLIC
+ Control/AthenaBaseComps
+ Control/AthenaKernel
+ Database/AthenaPOOL/AthenaPoolUtilities
+ DetectorDescription/Identifier )
+
+# Component(s) in the package:
+atlas_add_library( FaserSCT_ConditionsData
+ src/*.cxx
+ PUBLIC_HEADERS FaserSCT_ConditionsData
+ LINK_LIBRARIES AthenaPoolUtilities Identifier )
+
+add_custom_command (
+ OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/ALLP200.db
+ DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/data/SCT_Conditions.py
+ COMMAND python ${CMAKE_CURRENT_SOURCE_DIR}/data/SCT_Conditions.py
+ WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
+ )
+
+add_custom_target( ALLP200 ALL DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/ALLP200.db )
+
+# Install the generated file:
+install( FILES ${CMAKE_CURRENT_BINARY_DIR}/ALLP200.db
+ DESTINATION ${CMAKE_INSTALL_DATADIR} )
+
diff --git a/Tracker/TrackerConditions/FaserSCT_ConditionsData/FaserSCT_ConditionsData/ATLAS_CHECK_THREAD_SAFETY b/Tracker/TrackerConditions/FaserSCT_ConditionsData/FaserSCT_ConditionsData/ATLAS_CHECK_THREAD_SAFETY
new file mode 100644
index 0000000000000000000000000000000000000000..04573fa279c183f077bd1b2e99072d011c67395a
--- /dev/null
+++ b/Tracker/TrackerConditions/FaserSCT_ConditionsData/FaserSCT_ConditionsData/ATLAS_CHECK_THREAD_SAFETY
@@ -0,0 +1 @@
+Tracker/TrackerConditions/FaserSCT_ConditionsData
\ No newline at end of file
diff --git a/Tracker/TrackerConditions/FaserSCT_ConditionsData/FaserSCT_ConditionsData/FaserSCT_ConditionsParameters.h b/Tracker/TrackerConditions/FaserSCT_ConditionsData/FaserSCT_ConditionsData/FaserSCT_ConditionsParameters.h
new file mode 100644
index 0000000000000000000000000000000000000000..04f4bbabdbda7758963400fc133affb96b9332bf
--- /dev/null
+++ b/Tracker/TrackerConditions/FaserSCT_ConditionsData/FaserSCT_ConditionsData/FaserSCT_ConditionsParameters.h
@@ -0,0 +1,32 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+/**
+ * @file FaserSCT_ConditionsParameters.h
+ * header file containing enumerated type of parameters which may be retrieved
+ * by the ISCT_ConditionsParameterSvc, and their string interpretation
+ * @author shaun.roe@cern.ch
+**/
+
+#ifndef FASERSCT_CONDITIONSDATA_SCT_CONDITIONSPARAMETERS_H
+#define FASERSCT_CONDITIONSDATA_SCT_CONDITIONSPARAMETERS_H
+
+#include <string>
+
+namespace FaserSCT_ConditionsData{
+ // Include possible interface detector in the count to future-proof this hard-coding...
+ enum NumberOfElements{SIDES_PER_MODULE=2, CHIPS_PER_SIDE=6, CHIPS_PER_MODULE=12, NUMBER_OF_MODULES=96, STRIPS_PER_WAFER=768, NUMBER_OF_WAFERS=192};
+ enum NumberOfCalibrationData{N_NPTGAIN=6, N_NOISEOCC=4};
+ enum MajorityParameters{HighAndLowVoltageOK=17, /* 17 = 0x11 -> majority state for both LV and HV. */
+ OVERALL=110,
+ // BARREL=111,
+ // ECA=114,
+ // ECC=115,
+ N_REGIONS=4,
+ INDEX_HVfraction=1,
+ INDEX_MajorityState=3};
+// enum Bec{bec_ECC=-2, bec_BARREL=0, bec_ECA=+2};
+}
+
+#endif // FASERSCT_CONDITIONSDATA_SCT_CONDITIONSPARAMETERS_H
diff --git a/Tracker/TrackerConditions/FaserSCT_ConditionsData/FaserSCT_ConditionsData/FaserSCT_DCSFloatCondData.h b/Tracker/TrackerConditions/FaserSCT_ConditionsData/FaserSCT_ConditionsData/FaserSCT_DCSFloatCondData.h
new file mode 100644
index 0000000000000000000000000000000000000000..adcac6c2b40f873ef12118ec1c2aab09f052d5fa
--- /dev/null
+++ b/Tracker/TrackerConditions/FaserSCT_ConditionsData/FaserSCT_ConditionsData/FaserSCT_DCSFloatCondData.h
@@ -0,0 +1,46 @@
+/*
+ Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+*/
+
+/**
+ * FaserSCT_DCSFloatCondData.h
+ * @file header file for data object
+ * @author Susumu Oda - 11/08/17
+ **/
+
+#ifndef FASERSCT_DCSFLOATCONDDATA_H
+#define FASERSCT_DCSFLOATCONDDATA_H
+
+#include "AthenaKernel/CLASS_DEF.h"
+#include "AthenaPoolUtilities/CondAttrListCollection.h"
+#include <map>
+
+class FaserSCT_DCSFloatCondData {
+public:
+ //constructor
+ FaserSCT_DCSFloatCondData();
+
+ //destructor
+ virtual ~FaserSCT_DCSFloatCondData() = default;
+ //@name main methods
+ //@{
+ /// set a float value for a channel
+ void setValue(const CondAttrListCollection::ChanNum& chanNum, const float value);
+ /// get the float value for a channel
+ bool getValue(const CondAttrListCollection::ChanNum& chanNum, float& value) const;
+ /// clear the m_channelValues
+ void clear();
+ //@}
+
+private:
+ typedef std::map<CondAttrListCollection::ChanNum, float> FloatConditions;
+ FloatConditions m_channelValues;
+};
+
+CLASS_DEF( FaserSCT_DCSFloatCondData , 196115995 , 1 )
+
+#include "AthenaKernel/CondCont.h"
+CONDCONT_DEF( FaserSCT_DCSFloatCondData, 149642607 );
+
+
+#endif // FASERSCT_DCSFLOATCONDDATA_H
diff --git a/Tracker/TrackerConditions/FaserSCT_ConditionsData/FaserSCT_ConditionsData/FaserSCT_DCSStatCondData.h b/Tracker/TrackerConditions/FaserSCT_ConditionsData/FaserSCT_ConditionsData/FaserSCT_DCSStatCondData.h
new file mode 100644
index 0000000000000000000000000000000000000000..813bbcd6868ba3710272ba885cef6ab16acb9a0e
--- /dev/null
+++ b/Tracker/TrackerConditions/FaserSCT_ConditionsData/FaserSCT_ConditionsData/FaserSCT_DCSStatCondData.h
@@ -0,0 +1,50 @@
+/*
+ Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+*/
+
+/**
+ * FaserSCT_DCSStatCondData.h
+ * @file header file for data object
+ * @author A. Robichaud-Veronneau - 23/02/07
+ **/
+
+#ifndef FASERSCT_DCSSTATCONDDATA_H
+#define FASERSCT_DCSSTATCONDDATA_H
+
+#include "AthenaKernel/CLASS_DEF.h"
+#include "AthenaPoolUtilities/CondAttrListCollection.h"
+#include <map>
+#include <vector>
+#include <string>
+
+class FaserSCT_DCSStatCondData {
+public:
+ //constructor
+ FaserSCT_DCSStatCondData();
+
+ //destructor
+ virtual ~FaserSCT_DCSStatCondData() = default;
+ //@name main methods
+ //@{
+ /// add defect
+ void fill(const CondAttrListCollection::ChanNum& chanNum, const std::string param);
+ /// remove a defect
+ void remove(const CondAttrListCollection::ChanNum& chanNum, const std::string param);
+ /// copy all defects to a users vector, the return value is the size
+ int output(const CondAttrListCollection::ChanNum& chanNum, std::vector<std::string>& usersVector) const;
+ ///
+ int output(const CondAttrListCollection::ChanNum & chanNum) const;
+ //@}
+
+private:
+ typedef std::map<CondAttrListCollection::ChanNum, std::vector<std::string> > DCSConditions;
+ DCSConditions m_bad_channels;
+};
+
+CLASS_DEF( FaserSCT_DCSStatCondData , 167371458 , 1 )
+
+#include "AthenaKernel/CondCont.h"
+CONDCONT_DEF( FaserSCT_DCSStatCondData, 63295326 );
+
+
+#endif // FASERSCT_DCSSTATCONDDATA_H
diff --git a/Tracker/TrackerConditions/FaserSCT_ConditionsData/FaserSCT_ConditionsData/FaserSCT_GainCalibData.h b/Tracker/TrackerConditions/FaserSCT_ConditionsData/FaserSCT_ConditionsData/FaserSCT_GainCalibData.h
new file mode 100644
index 0000000000000000000000000000000000000000..30dc97c2c0469720d318567cf0bf63de5cd182bf
--- /dev/null
+++ b/Tracker/TrackerConditions/FaserSCT_ConditionsData/FaserSCT_ConditionsData/FaserSCT_GainCalibData.h
@@ -0,0 +1,28 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+/**
+ * FaserSCT_GainCalibData.h
+ * @file header file for data object for gain parameters for all modules
+ * @author Susumu Oda - 12/10/17
+ **/
+
+#ifndef FASERSCT_GAINCALIBDATA_H
+#define FASERSCT_GAINCALIBDATA_H
+
+#include "FaserSCT_ConditionsData/FaserSCT_ModuleGainCalibData.h"
+
+// Definition of the number of elements
+#include "FaserSCT_ConditionsData/FaserSCT_ConditionsParameters.h"
+
+typedef boost::array<FaserSCT_ModuleGainCalibData, FaserSCT_ConditionsData::NUMBER_OF_MODULES> FaserSCT_GainCalibData;
+
+// Class definition
+#include "AthenaKernel/CLASS_DEF.h"
+CLASS_DEF( FaserSCT_GainCalibData , 6442222 , 1 )
+
+#include "AthenaKernel/CondCont.h"
+CONDCONT_DEF( FaserSCT_GainCalibData, 111415994 );
+
+#endif // FASERSCT_GAINCALIBDATA_H
diff --git a/Tracker/TrackerConditions/FaserSCT_ConditionsData/FaserSCT_ConditionsData/FaserSCT_ModuleCalibParameter.h b/Tracker/TrackerConditions/FaserSCT_ConditionsData/FaserSCT_ConditionsData/FaserSCT_ModuleCalibParameter.h
new file mode 100644
index 0000000000000000000000000000000000000000..8adcccb1ec1d4c5bfaa099f4514914a498108fe6
--- /dev/null
+++ b/Tracker/TrackerConditions/FaserSCT_ConditionsData/FaserSCT_ConditionsData/FaserSCT_ModuleCalibParameter.h
@@ -0,0 +1,26 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+/**
+ * FaserSCT_ModuleCalibParameter.h
+ * @file header file for data object for a calibration parameter per chip of a module
+ * @author Susumu Oda - 12/10/17
+ **/
+
+#ifndef FASERSCT_MODULECALIBPARAMETER_H
+#define FASERSCT_MODULECALIBPARAMETER_H
+
+// Include boost stuff
+#include "boost/array.hpp"
+
+// Definition of the number of elements
+#include "FaserSCT_ConditionsData/FaserSCT_ConditionsParameters.h"
+
+typedef boost::array<float, FaserSCT_ConditionsData::CHIPS_PER_MODULE> FaserSCT_ModuleCalibParameter;
+
+// Class definition
+#include "AthenaKernel/CLASS_DEF.h"
+CLASS_DEF( FaserSCT_ModuleCalibParameter , 52360049 , 1 )
+
+#endif // FASERSCT_MODULECALIBPARAMETER_H
diff --git a/Tracker/TrackerConditions/FaserSCT_ConditionsData/FaserSCT_ConditionsData/FaserSCT_ModuleGainCalibData.h b/Tracker/TrackerConditions/FaserSCT_ConditionsData/FaserSCT_ConditionsData/FaserSCT_ModuleGainCalibData.h
new file mode 100644
index 0000000000000000000000000000000000000000..3dfd310fc6ca7c29b87b400e775b64d521c4816d
--- /dev/null
+++ b/Tracker/TrackerConditions/FaserSCT_ConditionsData/FaserSCT_ConditionsData/FaserSCT_ModuleGainCalibData.h
@@ -0,0 +1,25 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+/**
+ * FaserSCT_ModuleGainCalibData.h
+ * @file header file for data object for gain parameters per module
+ * @author Susumu Oda - 12/10/17
+ **/
+
+#ifndef FASERSCT_MODULEGAINCALIBDATA_H
+#define FASERSCT_MODULEGAINCALIBDATA_H
+
+#include "FaserSCT_ConditionsData/FaserSCT_ModuleCalibParameter.h"
+
+// Definition of the number of elements
+#include "FaserSCT_ConditionsData/FaserSCT_ConditionsParameters.h"
+
+typedef boost::array<FaserSCT_ModuleCalibParameter, FaserSCT_ConditionsData::N_NPTGAIN> FaserSCT_ModuleGainCalibData;
+
+// Class definition
+#include "AthenaKernel/CLASS_DEF.h"
+CLASS_DEF( FaserSCT_ModuleGainCalibData , 145481824 , 1 )
+
+#endif // FASERSCT_MODULEGAINCALIBDATA_H
diff --git a/Tracker/TrackerConditions/FaserSCT_ConditionsData/FaserSCT_ConditionsData/FaserSCT_ModuleNoiseCalibData.h b/Tracker/TrackerConditions/FaserSCT_ConditionsData/FaserSCT_ConditionsData/FaserSCT_ModuleNoiseCalibData.h
new file mode 100644
index 0000000000000000000000000000000000000000..a0cc091604c27cd1316fc4389bb092fa835c5adc
--- /dev/null
+++ b/Tracker/TrackerConditions/FaserSCT_ConditionsData/FaserSCT_ConditionsData/FaserSCT_ModuleNoiseCalibData.h
@@ -0,0 +1,25 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+/**
+ * FaserSCT_ModuleNoiseCalibData.h
+ * @file header file for data object for noise parameters per module
+ * @author Susumu Oda - 12/10/17
+ **/
+
+#ifndef FASERSCT_MODULENOISECALIBDATA_H
+#define FASERSCT_MODULENOISECALIBDATA_H
+
+#include "FaserSCT_ConditionsData/FaserSCT_ModuleCalibParameter.h"
+
+// Definition of the number of elements
+#include "FaserSCT_ConditionsData/FaserSCT_ConditionsParameters.h"
+
+typedef boost::array<FaserSCT_ModuleCalibParameter, FaserSCT_ConditionsData::N_NOISEOCC> FaserSCT_ModuleNoiseCalibData;
+
+// Class definition
+#include "AthenaKernel/CLASS_DEF.h"
+CLASS_DEF( FaserSCT_ModuleNoiseCalibData , 48618992 , 1 )
+
+#endif // FASERSCT_MODULENOISECALIBDATA_H
diff --git a/Tracker/TrackerConditions/FaserSCT_ConditionsData/FaserSCT_ConditionsData/FaserSCT_NoiseCalibData.h b/Tracker/TrackerConditions/FaserSCT_ConditionsData/FaserSCT_ConditionsData/FaserSCT_NoiseCalibData.h
new file mode 100644
index 0000000000000000000000000000000000000000..58fdd0bcc214dfcf8246a8ed7f3ca50d1fe53b46
--- /dev/null
+++ b/Tracker/TrackerConditions/FaserSCT_ConditionsData/FaserSCT_ConditionsData/FaserSCT_NoiseCalibData.h
@@ -0,0 +1,28 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+/**
+ * FaserSCT_NoiseCalibData.h
+ * @file header file for data object for noise parameters for all modules
+ * @author Susumu Oda - 12/10/17
+ **/
+
+#ifndef FASERSCT_NOISECALIBDATA_H
+#define FASERSCT_NOISECALIBDATA_H
+
+#include "FaserSCT_ConditionsData/FaserSCT_ModuleNoiseCalibData.h"
+
+// Definition of the number of elements
+#include "FaserSCT_ConditionsData/FaserSCT_ConditionsParameters.h"
+
+typedef boost::array<FaserSCT_ModuleNoiseCalibData, FaserSCT_ConditionsData::NUMBER_OF_MODULES> FaserSCT_NoiseCalibData;
+
+// Class definition
+#include "AthenaKernel/CLASS_DEF.h"
+CLASS_DEF( FaserSCT_NoiseCalibData , 26585486 , 1 )
+
+#include "AthenaKernel/CondCont.h"
+CONDCONT_DEF( FaserSCT_NoiseCalibData , 44705704 );
+
+#endif // FASERSCT_NOISECALIBDATA_H
diff --git a/Tracker/TrackerConditions/FaserSCT_ConditionsData/data/SCT_Conditions.py b/Tracker/TrackerConditions/FaserSCT_ConditionsData/data/SCT_Conditions.py
new file mode 100644
index 0000000000000000000000000000000000000000..f490cb12eedebcb8ca7645625b94659c8f0e922f
--- /dev/null
+++ b/Tracker/TrackerConditions/FaserSCT_ConditionsData/data/SCT_Conditions.py
@@ -0,0 +1,210 @@
+#!/bin/env python
+
+sctChannels = ['1073741824 ', '1075838976 ', '1077936128 ', '1080033280 ', '1082130432 ', '1084227584 ', '1086324736 ', '1088421888 ', '1090519040 ', '1092616192 ', '1094713344 ', '1096810496 ', '1098907648 ', '1101004800 ', '1103101952 ', '1105199104 ', '1107296256 ', '1109393408 ', '1111490560 ', '1113587712 ', '1115684864 ', '1117782016 ', '1119879168 ', '1121976320 ', '1124073472 ', '1126170624 ', '1128267776 ', '1130364928 ', '1132462080 ', '1134559232 ', '1136656384 ', '1138753536 ', '1140850688 ', '1142947840 ', '1145044992 ', '1147142144 ', '1149239296 ', '1151336448 ', '1153433600 ', '1155530752 ', '1157627904 ', '1159725056 ', '1161822208 ', '1163919360 ', '1166016512 ', '1168113664 ', '1170210816 ', '1172307968 ', '1207959552 ', '1210056704 ', '1212153856 ', '1214251008 ', '1216348160 ', '1218445312 ', '1220542464 ', '1222639616 ', '1224736768 ', '1226833920 ', '1228931072 ', '1231028224 ', '1233125376 ', '1235222528 ', '1237319680 ', '1239416832 ', '1241513984 ', '1243611136 ', '1245708288 ', '1247805440 ', '1249902592 ', '1251999744 ', '1254096896 ', '1256194048 ', '1258291200 ', '1260388352 ', '1262485504 ', '1264582656 ', '1266679808 ', '1268776960 ', '1270874112 ', '1272971264 ', '1275068416 ', '1277165568 ', '1279262720 ', '1281359872 ', '1283457024 ', '1285554176 ', '1287651328 ', '1289748480 ', '1291845632 ', '1293942784 ', '1296039936 ', '1298137088 ', '1300234240 ', '1302331392 ', '1304428544 ', '1306525696 ', '1342177280 ', '1344274432 ', '1346371584 ', '1348468736 ', '1350565888 ', '1352663040 ', '1354760192 ', '1356857344 ', '1358954496 ', '1361051648 ', '1363148800 ', '1365245952 ', '1367343104 ', '1369440256 ', '1371537408 ', '1373634560 ', '1375731712 ', '1377828864 ', '1379926016 ', '1382023168 ', '1384120320 ', '1386217472 ', '1388314624 ', '1390411776 ', '1392508928 ', '1394606080 ', '1396703232 ', '1398800384 ', '1400897536 ', '1402994688 ', '1405091840 ', '1407188992 ', '1409286144 ', '1411383296 ', '1413480448 ', '1415577600 ', '1417674752 ', '1419771904 ', '1421869056 ', '1423966208 ', '1426063360 ', '1428160512 ', '1430257664 ', '1432354816 ', '1434451968 ', '1436549120 ', '1438646272 ', '1440743424 ']
+
+description = '<timeStamp>run-lumi</timeStamp><addrHeader><address_header clid="1238547719" service_type="71" /></addrHeader><typeName>CondAttrListCollection</typeName>'
+
+descriptionDCS = '<timeStamp>time</timeStamp><addrHeader><address_header service_type="71" clid="1238547719" /></addrHeader><typeName>CondAttrListCollection</typeName><cache>600</cache>'
+
+descriptionAlign = '<timeStamp>run-lumi</timeStamp><addrHeader><address_header service_type="71" clid="1170039409" /></addrHeader><typeName>AlignableTransformContainer</typeName>'
+
+descriptionMagnet = '<timeStamp>time</timeStamp><addrHeader><address_header service_type="71" clid="1238547719" /></addrHeader><typeName>CondAttrListCollection</typeName><cache>600</cache><named/>'
+
+from PyCool import cool, coral
+
+dbSvc = cool.DatabaseSvcFactory.databaseService()
+connectString = 'sqlite://;schema=ALLP200.db;dbname=OFLP200'
+
+print 'recreating database'
+dbSvc.dropDatabase( connectString )
+db = dbSvc.createDatabase( connectString )
+
+alignSpec = cool.RecordSpecification()
+alignSpec.extend( 'PoolRef', cool.StorageType.String4k )
+
+alignRecord = cool.Record(alignSpec)
+
+alignFolderSpec = cool.FolderSpecification(alignSpec)
+alignFolder = db.createFolder('/Tracker/Align', alignFolderSpec, descriptionAlign, True)
+
+alignRecord[ 'PoolRef' ] = '[DB=D0709FD7-6A55-E011-925D-002481043EC0][CNT=CollectionTreeAlignableTransform][CLID=E779C6B5-3F2A-473E-B35E-6CCB345E0665][TECH=00000202][OID=00000003-00000000]'
+alignFolder.storeObject( cool.ValidityKeyMin, cool.ValidityKeyMax, alignRecord, 0)
+alignRecord[ 'PoolRef' ] = '[DB=D0709FD7-6A55-E011-925D-002481043EC0][CNT=CollectionTreeAlignableTransform][CLID=E779C6B5-3F2A-473E-B35E-6CCB345E0665][TECH=00000202][OID=00000003-00000001]'
+alignFolder.storeObject( cool.ValidityKeyMin, cool.ValidityKeyMax, alignRecord, 100)
+alignRecord[ 'PoolRef' ] = '[DB=D0709FD7-6A55-E011-925D-002481043EC0][CNT=CollectionTreeAlignableTransform][CLID=E779C6B5-3F2A-473E-B35E-6CCB345E0665][TECH=00000202][OID=00000003-00000002]'
+alignFolder.storeObject( cool.ValidityKeyMin, cool.ValidityKeyMax, alignRecord, 101)
+alignRecord[ 'PoolRef' ] = '[DB=D0709FD7-6A55-E011-925D-002481043EC0][CNT=CollectionTreeAlignableTransform][CLID=E779C6B5-3F2A-473E-B35E-6CCB345E0665][TECH=00000202][OID=00000003-00000003]'
+alignFolder.storeObject( cool.ValidityKeyMin, cool.ValidityKeyMax, alignRecord, 200)
+alignRecord[ 'PoolRef' ] = '[DB=D0709FD7-6A55-E011-925D-002481043EC0][CNT=CollectionTreeAlignableTransform][CLID=E779C6B5-3F2A-473E-B35E-6CCB345E0665][TECH=00000202][OID=00000003-00000004]'
+alignFolder.storeObject( cool.ValidityKeyMin, cool.ValidityKeyMax, alignRecord, 201)
+alignRecord[ 'PoolRef' ] = '[DB=D0709FD7-6A55-E011-925D-002481043EC0][CNT=CollectionTreeAlignableTransform][CLID=E779C6B5-3F2A-473E-B35E-6CCB345E0665][TECH=00000202][OID=00000003-00000005]'
+alignFolder.storeObject( cool.ValidityKeyMin, cool.ValidityKeyMax, alignRecord, 202)
+alignRecord[ 'PoolRef' ] = '[DB=D0709FD7-6A55-E011-925D-002481043EC0][CNT=CollectionTreeAlignableTransform][CLID=E779C6B5-3F2A-473E-B35E-6CCB345E0665][TECH=00000202][OID=00000003-00000006]'
+alignFolder.storeObject( cool.ValidityKeyMin, cool.ValidityKeyMax, alignRecord, 203)
+alignRecord[ 'PoolRef' ] = '[DB=D0709FD7-6A55-E011-925D-002481043EC0][CNT=CollectionTreeAlignableTransform][CLID=E779C6B5-3F2A-473E-B35E-6CCB345E0665][TECH=00000202][OID=00000003-00000007]'
+alignFolder.storeObject( cool.ValidityKeyMin, cool.ValidityKeyMax, alignRecord, 204)
+alignRecord[ 'PoolRef' ] = '[DB=D0709FD7-6A55-E011-925D-002481043EC0][CNT=CollectionTreeAlignableTransform][CLID=E779C6B5-3F2A-473E-B35E-6CCB345E0665][TECH=00000202][OID=00000003-00000008]'
+alignFolder.storeObject( cool.ValidityKeyMin, cool.ValidityKeyMax, alignRecord, 205)
+alignRecord[ 'PoolRef' ] = '[DB=D0709FD7-6A55-E011-925D-002481043EC0][CNT=CollectionTreeAlignableTransform][CLID=E779C6B5-3F2A-473E-B35E-6CCB345E0665][TECH=00000202][OID=00000003-00000009]'
+alignFolder.storeObject( cool.ValidityKeyMin, cool.ValidityKeyMax, alignRecord, 206)
+alignRecord[ 'PoolRef' ] = '[DB=D0709FD7-6A55-E011-925D-002481043EC0][CNT=CollectionTreeAlignableTransform][CLID=E779C6B5-3F2A-473E-B35E-6CCB345E0665][TECH=00000202][OID=00000003-0000000A]'
+alignFolder.storeObject( cool.ValidityKeyMin, cool.ValidityKeyMax, alignRecord, 207)
+alignRecord[ 'PoolRef' ] = '[DB=D0709FD7-6A55-E011-925D-002481043EC0][CNT=CollectionTreeAlignableTransform][CLID=E779C6B5-3F2A-473E-B35E-6CCB345E0665][TECH=00000202][OID=00000003-0000000B]'
+alignFolder.storeObject( cool.ValidityKeyMin, cool.ValidityKeyMax, alignRecord, 208)
+alignRecord[ 'PoolRef' ] = '[DB=D0709FD7-6A55-E011-925D-002481043EC0][CNT=CollectionTreeAlignableTransform][CLID=E779C6B5-3F2A-473E-B35E-6CCB345E0665][TECH=00000202][OID=00000003-0000000C]'
+alignFolder.storeObject( cool.ValidityKeyMin, cool.ValidityKeyMax, alignRecord, 209)
+alignRecord[ 'PoolRef' ] = '[DB=D0709FD7-6A55-E011-925D-002481043EC0][CNT=CollectionTreeAlignableTransform][CLID=E779C6B5-3F2A-473E-B35E-6CCB345E0665][TECH=00000202][OID=00000003-0000000D]'
+alignFolder.storeObject( cool.ValidityKeyMin, cool.ValidityKeyMax, alignRecord, 210)
+alignRecord[ 'PoolRef' ] = '[DB=D0709FD7-6A55-E011-925D-002481043EC0][CNT=CollectionTreeAlignableTransform][CLID=E779C6B5-3F2A-473E-B35E-6CCB345E0665][TECH=00000202][OID=00000003-0000000E]'
+alignFolder.storeObject( cool.ValidityKeyMin, cool.ValidityKeyMax, alignRecord, 211)
+alignRecord[ 'PoolRef' ] = '[DB=D0709FD7-6A55-E011-925D-002481043EC0][CNT=CollectionTreeAlignableTransform][CLID=E779C6B5-3F2A-473E-B35E-6CCB345E0665][TECH=00000202][OID=00000003-0000000F]'
+alignFolder.storeObject( cool.ValidityKeyMin, cool.ValidityKeyMax, alignRecord, 212)
+alignRecord[ 'PoolRef' ] = '[DB=D0709FD7-6A55-E011-925D-002481043EC0][CNT=CollectionTreeAlignableTransform][CLID=E779C6B5-3F2A-473E-B35E-6CCB345E0665][TECH=00000202][OID=00000003-00000010]'
+alignFolder.storeObject( cool.ValidityKeyMin, cool.ValidityKeyMax, alignRecord, 213)
+alignRecord[ 'PoolRef' ] = '[DB=D0709FD7-6A55-E011-925D-002481043EC0][CNT=CollectionTreeAlignableTransform][CLID=E779C6B5-3F2A-473E-B35E-6CCB345E0665][TECH=00000202][OID=00000003-00000011]'
+alignFolder.storeObject( cool.ValidityKeyMin, cool.ValidityKeyMax, alignRecord, 214)
+alignRecord[ 'PoolRef' ] = '[DB=D0709FD7-6A55-E011-925D-002481043EC0][CNT=CollectionTreeAlignableTransform][CLID=E779C6B5-3F2A-473E-B35E-6CCB345E0665][TECH=00000202][OID=00000003-00000012]'
+alignFolder.storeObject( cool.ValidityKeyMin, cool.ValidityKeyMax, alignRecord, 215)
+alignRecord[ 'PoolRef' ] = '[DB=D0709FD7-6A55-E011-925D-002481043EC0][CNT=CollectionTreeAlignableTransform][CLID=E779C6B5-3F2A-473E-B35E-6CCB345E0665][TECH=00000202][OID=00000003-00000013]'
+alignFolder.storeObject( cool.ValidityKeyMin, cool.ValidityKeyMax, alignRecord, 216)
+alignRecord[ 'PoolRef' ] = '[DB=D0709FD7-6A55-E011-925D-002481043EC0][CNT=CollectionTreeAlignableTransform][CLID=E779C6B5-3F2A-473E-B35E-6CCB345E0665][TECH=00000202][OID=00000003-00000014]'
+alignFolder.storeObject( cool.ValidityKeyMin, cool.ValidityKeyMax, alignRecord, 217)
+alignRecord[ 'PoolRef' ] = '[DB=D0709FD7-6A55-E011-925D-002481043EC0][CNT=CollectionTreeAlignableTransform][CLID=E779C6B5-3F2A-473E-B35E-6CCB345E0665][TECH=00000202][OID=00000003-00000015]'
+alignFolder.storeObject( cool.ValidityKeyMin, cool.ValidityKeyMax, alignRecord, 218)
+alignRecord[ 'PoolRef' ] = '[DB=D0709FD7-6A55-E011-925D-002481043EC0][CNT=CollectionTreeAlignableTransform][CLID=E779C6B5-3F2A-473E-B35E-6CCB345E0665][TECH=00000202][OID=00000003-00000016]'
+alignFolder.storeObject( cool.ValidityKeyMin, cool.ValidityKeyMax, alignRecord, 219)
+alignRecord[ 'PoolRef' ] = '[DB=D0709FD7-6A55-E011-925D-002481043EC0][CNT=CollectionTreeAlignableTransform][CLID=E779C6B5-3F2A-473E-B35E-6CCB345E0665][TECH=00000202][OID=00000003-00000017]'
+alignFolder.storeObject( cool.ValidityKeyMin, cool.ValidityKeyMax, alignRecord, 220)
+alignRecord[ 'PoolRef' ] = '[DB=D0709FD7-6A55-E011-925D-002481043EC0][CNT=CollectionTreeAlignableTransform][CLID=E779C6B5-3F2A-473E-B35E-6CCB345E0665][TECH=00000202][OID=00000003-00000018]'
+alignFolder.storeObject( cool.ValidityKeyMin, cool.ValidityKeyMax, alignRecord, 221)
+alignRecord[ 'PoolRef' ] = '[DB=D0709FD7-6A55-E011-925D-002481043EC0][CNT=CollectionTreeAlignableTransform][CLID=E779C6B5-3F2A-473E-B35E-6CCB345E0665][TECH=00000202][OID=00000003-00000019]'
+alignFolder.storeObject( cool.ValidityKeyMin, cool.ValidityKeyMax, alignRecord, 222)
+alignRecord[ 'PoolRef' ] = '[DB=D0709FD7-6A55-E011-925D-002481043EC0][CNT=CollectionTreeAlignableTransform][CLID=E779C6B5-3F2A-473E-B35E-6CCB345E0665][TECH=00000202][OID=00000003-0000001A]'
+alignFolder.storeObject( cool.ValidityKeyMin, cool.ValidityKeyMax, alignRecord, 223)
+alignRecord[ 'PoolRef' ] = '[DB=D0709FD7-6A55-E011-925D-002481043EC0][CNT=CollectionTreeAlignableTransform][CLID=E779C6B5-3F2A-473E-B35E-6CCB345E0665][TECH=00000202][OID=00000003-0000001B]'
+alignFolder.storeObject( cool.ValidityKeyMin, cool.ValidityKeyMax, alignRecord, 224)
+alignRecord[ 'PoolRef' ] = '[DB=D0709FD7-6A55-E011-925D-002481043EC0][CNT=CollectionTreeAlignableTransform][CLID=E779C6B5-3F2A-473E-B35E-6CCB345E0665][TECH=00000202][OID=00000003-0000001C]'
+alignFolder.storeObject( cool.ValidityKeyMin, cool.ValidityKeyMax, alignRecord, 225)
+alignRecord[ 'PoolRef' ] = '[DB=D0709FD7-6A55-E011-925D-002481043EC0][CNT=CollectionTreeAlignableTransform][CLID=E779C6B5-3F2A-473E-B35E-6CCB345E0665][TECH=00000202][OID=00000003-0000001D]'
+alignFolder.storeObject( cool.ValidityKeyMin, cool.ValidityKeyMax, alignRecord, 226)
+alignRecord[ 'PoolRef' ] = '[DB=D0709FD7-6A55-E011-925D-002481043EC0][CNT=CollectionTreeAlignableTransform][CLID=E779C6B5-3F2A-473E-B35E-6CCB345E0665][TECH=00000202][OID=00000003-0000001E]'
+alignFolder.storeObject( cool.ValidityKeyMin, cool.ValidityKeyMax, alignRecord, 227)
+alignRecord[ 'PoolRef' ] = '[DB=D0709FD7-6A55-E011-925D-002481043EC0][CNT=CollectionTreeAlignableTransform][CLID=E779C6B5-3F2A-473E-B35E-6CCB345E0665][TECH=00000202][OID=00000003-0000001F]'
+alignFolder.storeObject( cool.ValidityKeyMin, cool.ValidityKeyMax, alignRecord, 228)
+alignRecord[ 'PoolRef' ] = '[DB=D0709FD7-6A55-E011-925D-002481043EC0][CNT=CollectionTreeAlignableTransform][CLID=E779C6B5-3F2A-473E-B35E-6CCB345E0665][TECH=00000202][OID=00000003-00000020]'
+alignFolder.storeObject( cool.ValidityKeyMin, cool.ValidityKeyMax, alignRecord, 229)
+alignRecord[ 'PoolRef' ] = '[DB=D0709FD7-6A55-E011-925D-002481043EC0][CNT=CollectionTreeAlignableTransform][CLID=E779C6B5-3F2A-473E-B35E-6CCB345E0665][TECH=00000202][OID=00000003-00000021]'
+alignFolder.storeObject( cool.ValidityKeyMin, cool.ValidityKeyMax, alignRecord, 230)
+
+
+gainSpec = cool.RecordSpecification()
+gainSpec.extend( 'serialNumber' , cool.StorageType.UInt63 )
+gainSpec.extend( 'runNumber' , cool.StorageType.UInt32 )
+gainSpec.extend( 'scanNumber' , cool.StorageType.UInt32 )
+gainSpec.extend( 'gainByChip' , cool.StorageType.String4k )
+gainSpec.extend( 'gainRMSByChip' , cool.StorageType.String4k )
+gainSpec.extend( 'offsetByChip' , cool.StorageType.String4k )
+gainSpec.extend( 'offsetRMSByChip' , cool.StorageType.String4k )
+gainSpec.extend( 'noiseByChip' , cool.StorageType.String4k )
+gainSpec.extend( 'noiseRMSByChip' , cool.StorageType.String4k )
+
+gainRecord = cool.Record(gainSpec)
+gainRecord[ 'serialNumber' ] = 0
+gainRecord[ 'runNumber' ] = 0
+gainRecord[ 'scanNumber' ] = 0
+gainRecord[ 'gainByChip' ] = '52.0 52.0 52.0 52.0 52.0 52.0 52.0 52.0 52.0 52.0 52.0 52.0'
+gainRecord[ 'gainRMSByChip' ] = '1.25 1.25 1.25 1.25 1.25 1.25 1.25 1.25 1.25 1.25 1.25 1.25'
+gainRecord[ 'offsetByChip' ] = '45.0 45.0 45.0 45.0 45.0 45.0 45.0 45.0 45.0 45.0 45.0 45.0'
+gainRecord[ 'offsetRMSByChip' ] = '1.75 1.75 1.75 1.75 1.75 1.75 1.75 1.75 1.75 1.75 1.75 1.75'
+gainRecord[ 'noiseByChip' ] = '1600.0 1600.0 1600.0 1600.0 1600.0 1600.0 1600.0 1600.0 1600.0 1600.0 1600.0 1600.0'
+gainRecord[ 'noiseRMSByChip' ] = '45.0 45.0 45.0 45.0 45.0 45.0 45.0 45.0 45.0 45.0 45.0 45.0'
+
+gainFolderSpec = cool.FolderSpecification(gainSpec)
+gainFolder = db.createFolder('/SCT/DAQ/Calibration/ChipGain', gainFolderSpec, description, True)
+
+for channel in sctChannels:
+ gainFolder.storeObject( cool.ValidityKeyMin, cool.ValidityKeyMax, gainRecord, int(channel) )
+
+noiseSpec = cool.RecordSpecification()
+noiseSpec.extend( 'serialNumber' , cool.StorageType.UInt63 )
+noiseSpec.extend( 'runNumber' , cool.StorageType.UInt32 )
+noiseSpec.extend( 'scanNumber' , cool.StorageType.UInt32 )
+noiseSpec.extend( 'offsetByChip' , cool.StorageType.String4k )
+noiseSpec.extend( 'occupancyByChip' , cool.StorageType.String4k )
+noiseSpec.extend( 'occupancyRMSByChip' , cool.StorageType.String4k )
+noiseSpec.extend( 'noiseByChip' , cool.StorageType.String4k )
+
+noiseRecord = cool.Record(noiseSpec)
+noiseRecord[ 'serialNumber' ] = 0
+noiseRecord[ 'runNumber' ] = 0
+noiseRecord[ 'scanNumber' ] = 0
+noiseRecord[ 'offsetByChip' ] = '60.0 60.0 60.0 60.0 60.0 60.0 60.0 60.0 60.0 60.0 60.0 60.0'
+noiseRecord[ 'occupancyByChip' ] = '3.50e-05 3.50e-05 3.50e-05 3.50e-05 3.50e-05 3.50e-05 3.50e-05 3.50e-05 3.50e-05 3.50e-05 3.50e-05 3.50e-05 3.50e-05'
+noiseRecord[ 'occupancyRMSByChip' ] = '2.50e-05 2.50e-05 2.50e-05 2.50e-05 2.50e-05 2.50e-05 2.50e-05 2.50e-05 2.50e-05 2.50e-05 2.50e-05 2.50e-05 2.50e-05'
+
+noiseFolderSpec = cool.FolderSpecification(noiseSpec)
+noiseFolder = db.createFolder('/SCT/DAQ/Calibration/ChipNoise', noiseFolderSpec, description, True)
+
+for channel in sctChannels:
+ noiseFolder.storeObject( cool.ValidityKeyMin, cool.ValidityKeyMax, noiseRecord, int(channel) )
+
+magnetSpec = cool.RecordSpecification()
+magnetSpec.extend( 'value' , cool.StorageType.Float )
+magnetSpec.extend( 'quality_invalid' , cool.StorageType.Bool )
+
+magnetRecord = cool.Record(magnetSpec)
+magnetRecord[ 'quality_invalid'] = 1
+
+magnetFolderSpec = cool.FolderSpecification(magnetSpec)
+magnetFolder = db.createFolder('/EXT/DCS/MAGNETS/SENSORDATA', magnetFolderSpec, descriptionMagnet, True)
+
+magnetRecord[ 'value' ] = 7730.0
+magnetFolder.storeObject( cool.ValidityKeyMin, cool.ValidityKeyMax, magnetRecord, 1)
+magnetFolder.storeObject( cool.ValidityKeyMin, cool.ValidityKeyMax, magnetRecord, 2)
+magnetRecord[ 'value' ] = 20400.0
+magnetFolder.storeObject( cool.ValidityKeyMin, cool.ValidityKeyMax, magnetRecord, 3)
+magnetFolder.storeObject( cool.ValidityKeyMin, cool.ValidityKeyMax, magnetRecord, 4)
+
+chanstatSpec = cool.RecordSpecification()
+chanstatSpec.extend( 'LVCHSTAT_RECV' , cool.StorageType.Int32 )
+chanstatSpec.extend( 'STATE' , cool.StorageType.UInt32 )
+
+chanstatRecord = cool.Record(chanstatSpec)
+chanstatRecord[ 'LVCHSTAT_RECV' ] = 209
+chanstatRecord[ 'STATE' ] = 17
+
+chanstatFolderSpec = cool.FolderSpecification(chanstatSpec)
+chanstatFolder = db.createFolder('/SCT/DCS/CHANSTAT', chanstatFolderSpec, descriptionDCS, True)
+
+for channel in sctChannels:
+ chanstatFolder.storeObject( cool.ValidityKeyMin, cool.ValidityKeyMax, chanstatRecord, int(channel) )
+
+hvSpec = cool.RecordSpecification()
+hvSpec.extend( 'HVCHVOLT_RECV' , cool.StorageType.Float )
+hvSpec.extend( 'HVCHCURR_RECV' , cool.StorageType.Float )
+
+hvRecord = cool.Record(hvSpec)
+hvRecord[ 'HVCHVOLT_RECV' ] = 150.0
+hvRecord[ 'HVCHCURR_RECV' ] = 10.0
+
+hvFolderSpec = cool.FolderSpecification(hvSpec)
+hvFolder = db.createFolder('/SCT/DCS/HV', hvFolderSpec, descriptionDCS, True)
+
+for channel in sctChannels:
+ hvFolder.storeObject( cool.ValidityKeyMin, cool.ValidityKeyMax, hvRecord, int(channel) )
+
+modtempSpec = cool.RecordSpecification()
+modtempSpec.extend( 'MOCH_TM0_RECV' , cool.StorageType.Float )
+modtempSpec.extend( 'MOCH_TM1_RECV' , cool.StorageType.Float )
+
+modtempRecord = cool.Record(modtempSpec)
+modtempRecord[ 'MOCH_TM0_RECV' ] = 7.0
+modtempRecord[ 'MOCH_TM1_RECV' ] = 7.0
+
+modtempFolderSpec = cool.FolderSpecification(modtempSpec)
+modtempFolder = db.createFolder('/SCT/DCS/MODTEMP', modtempFolderSpec, descriptionDCS, True)
+
+for channel in sctChannels:
+ modtempFolder.storeObject( cool.ValidityKeyMin, cool.ValidityKeyMax, modtempRecord, int(channel) )
+
+db.closeDatabase()
diff --git a/Tracker/TrackerConditions/FaserSCT_ConditionsData/src/FaserSCT_DCSFloatCondData.cxx b/Tracker/TrackerConditions/FaserSCT_ConditionsData/src/FaserSCT_DCSFloatCondData.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..4f572e6302adb0687de96717843e5206b302f049
--- /dev/null
+++ b/Tracker/TrackerConditions/FaserSCT_ConditionsData/src/FaserSCT_DCSFloatCondData.cxx
@@ -0,0 +1,39 @@
+/*
+ Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+*/
+
+// Implementation file for the SCT DCS float data object class for HV and temperature
+// The object is a map of channel number <-> float
+
+#include "FaserSCT_ConditionsData/FaserSCT_DCSFloatCondData.h"
+
+//////////////////////////////////
+// constructor
+FaserSCT_DCSFloatCondData::FaserSCT_DCSFloatCondData():
+ m_channelValues{}
+{
+}
+
+//////////////////////////////////
+// set a float value for a channel
+void FaserSCT_DCSFloatCondData::setValue(const CondAttrListCollection::ChanNum& chanNum, const float value) {
+ m_channelValues[chanNum] = value;
+}
+
+//////////////////////////////////
+// get the float value for a channel
+bool FaserSCT_DCSFloatCondData::getValue(const CondAttrListCollection::ChanNum& chanNum, float& value) const {
+ auto itr{m_channelValues.find(chanNum)};
+ if(itr!=m_channelValues.end()) {
+ value = itr->second;
+ return true;
+ }
+ // the channel is not found.
+ return false;
+}
+
+//////////////////////////////////
+// clear
+void FaserSCT_DCSFloatCondData::clear() {
+ m_channelValues.clear();
+}
diff --git a/Tracker/TrackerConditions/FaserSCT_ConditionsData/src/FaserSCT_DCSStatCondData.cxx b/Tracker/TrackerConditions/FaserSCT_ConditionsData/src/FaserSCT_DCSStatCondData.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..428595fe6a67f3915919fdd059c74600c708a4b9
--- /dev/null
+++ b/Tracker/TrackerConditions/FaserSCT_ConditionsData/src/FaserSCT_DCSStatCondData.cxx
@@ -0,0 +1,72 @@
+/*
+ Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+*/
+
+//Implementation file for the data object class
+//The object is a map of channel number<->vector<string>
+//Each string is the name of the guilty DCS parameter
+
+#include "FaserSCT_ConditionsData/FaserSCT_DCSStatCondData.h"
+
+#include <iostream>
+#include <algorithm>
+using namespace std;
+
+//////////////////////////////////
+//constructor
+FaserSCT_DCSStatCondData::FaserSCT_DCSStatCondData():
+ m_bad_channels{}
+{
+}
+//////////////////////////////////
+//add map entries
+void FaserSCT_DCSStatCondData::fill(const CondAttrListCollection::ChanNum& chanNum, const string param) {
+ if (m_bad_channels.find(chanNum)!=m_bad_channels.end()) {
+ // chan num has an entry already
+ //get the parameter list for this chan num
+
+ vector<string> par{(*m_bad_channels.find(chanNum)).second};
+
+ vector<string>::iterator par_itr{find(par.begin(), par.end(), param)};
+ if (par_itr==par.end()) {
+ // if this parameter (hv, chanstat etc) doesn't exist in the list add it to the param vector
+ par.push_back(param);
+ //don't insert! not a new map entry, just update the vector
+ (*m_bad_channels.find(chanNum)).second = par;
+ }
+ } else {
+ // no entry yet for this chan num, so start fresh
+ vector<string> par;
+ par.push_back(param);
+ pair<map<CondAttrListCollection::ChanNum, vector<string> >::iterator, bool> successfulInsert{m_bad_channels.insert(make_pair(chanNum, par))};
+ if (not successfulInsert.second) cout << "WARNING: FaserSCT_ConditionsData map insert failed" << endl;
+ }
+}
+//////////////////////////////////
+//remove entries in map vector
+void FaserSCT_DCSStatCondData::remove(const CondAttrListCollection::ChanNum& chanNum, const string param) {
+ map<CondAttrListCollection::ChanNum, vector<string> >::iterator itr{m_bad_channels.find(chanNum)};
+ if (itr!=m_bad_channels.end()) {
+ vector<string>::iterator vec_itr{find((*itr).second.begin(), (*itr).second.end(), param)};
+ if (vec_itr!=(*itr).second.end()) {
+ if ((*itr).second.size()>1) (*itr).second.erase(vec_itr);
+ else m_bad_channels.erase(itr);
+ }
+ }
+}
+//////////////////////////////////
+//output map vector
+int FaserSCT_DCSStatCondData::output(const CondAttrListCollection::ChanNum& chanNum, vector<string>& usersVector) const {
+ DCSConditions::const_iterator pPair{m_bad_channels.find(chanNum)};
+ if (pPair!=m_bad_channels.end()) {
+ const vector<string>& v{pPair->second};
+ usersVector.insert(usersVector.begin(), v.begin(), v.end());
+ }
+ return usersVector.size();
+}
+//////////////////////////////////
+//output map size
+int FaserSCT_DCSStatCondData::output(const CondAttrListCollection::ChanNum& chanNum) const {
+ DCSConditions::const_iterator pPair{m_bad_channels.find(chanNum)};
+ return (pPair!=m_bad_channels.end()) ? (pPair->second.size()) : 0;
+}
diff --git a/Tracker/TrackerConditions/FaserSCT_ConditionsTools/CMakeLists.txt b/Tracker/TrackerConditions/FaserSCT_ConditionsTools/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..dde73faa954e3ad6d8b0215205ae21db46b0ba5b
--- /dev/null
+++ b/Tracker/TrackerConditions/FaserSCT_ConditionsTools/CMakeLists.txt
@@ -0,0 +1,68 @@
+###############################################################################
+# Package: FaserSCT_ConditionsTools
+################################################################################
+
+# Declare the package name:
+atlas_subdir( FaserSCT_ConditionsTools )
+
+# Declare the package's dependencies:
+atlas_depends_on_subdirs( PUBLIC
+ Control/AthenaKernel
+ DetectorDescription/Identifier
+ GaudiKernel
+ InnerDetector/InDetConditions/InDetConditionsSummaryService
+ Tracker/TrackerConditions/FaserSCT_ConditionsData
+ InnerDetector/InDetConditions/SCT_ConditionsTools
+ PRIVATE
+ Control/AthenaBaseComps
+ Control/StoreGate
+ Event/xAOD/xAODEventInfo
+ Event/EventContainers
+ Database/RDBAccessSvc
+ DetectorDescription/GeoModel/GeoModelInterfaces
+ DetectorDescription/GeoModel/GeoModelUtilities
+ DetectorDescription/GeoModel/GeoModelFaserUtilities
+ InnerDetector/InDetConditions/InDetByteStreamErrors
+ Tracker/TrackerConditions/FaserSiPropertiesTool
+ Tracker/TrackerDetDescr/TrackerIdentifier
+ Tracker/TrackerDetDescr/TrackerReadoutGeometry
+ InnerDetector/InDetDetDescr/SCT_Cabling
+ AtlasTest/TestTools )
+
+# External dependencies:
+find_package( CLHEP )
+find_package( ROOT COMPONENTS Core Tree MathCore Hist RIO pthread )
+find_package( GTest )
+find_package( GMock )
+
+# Component(s) in the package:
+atlas_add_component ( FaserSCT_ConditionsTools
+ src/components/*.cxx
+ src/*.cxx
+ INCLUDE_DIRS ${ROOT_INCLUDE_DIRS} ${CLHEP_INCLUDE_DIRS}
+ LINK_LIBRARIES ${ROOT_LIBRARIES} ${CLHEP_LIBRARIES} AthenaKernel Identifier GeoModelUtilities GeoModelFaserUtilities GaudiKernel AthenaBaseComps StoreGateLib SGtests xAODEventInfo FaserSCT_ConditionsData InDetByteStreamErrors TrackerIdentifier TrackerReadoutGeometry SCT_CablingLib FaserSiPropertiesToolLib SCT_ConditionsToolsLib )
+
+
+#atlas_add_library( FaserSCT_ConditionsToolsLib
+# src/*.cxx
+# #PUBLIC_HEADERS FaserSCT_ConditionsTools
+# NO_PUBLIC_HEADERS
+# INCLUDE_DIRS ${ROOT_INCLUDE_DIRS} ${CLHEP_INCLUDE_DIRS}
+# LINK_LIBRARIES ${ROOT_LIBRARIES} ${CLHEP_LIBRARIES} AthenaKernel Identifier GeoModelUtilities GeoModelFaserUtilities GaudiKernel AthenaBaseComps StoreGateLib SGtests xAODEventInfo FaserSCT_ConditionsData SCT_ConditionsTools FaserSiPropertiesToolLib InDetByteStreamErrors TrackerIdentifier TrackerReadoutGeometry SCT_CablingLib EventContainers)
+
+# Add unit tests
+#atlas_add_test( SCT_RODVetoTool_test
+# SOURCES test/SCT_RODVetoTool_test.cxx
+# INCLUDE_DIRS ${GTEST_INCLUDE_DIRS} ${GMOCK_INCLUDE_DIRS}
+# LINK_LIBRARIES TestTools SCT_ConditionsToolsLib ${GTEST_LIBRARIES} ${GMOCK_LIBRARIES}
+# ENVIRONMENT "JOBOPTSEARCHPATH=${CMAKE_CURRENT_SOURCE_DIR}/share" )
+
+#atlas_add_test( SCT_ConditionsConfig_test
+# SCRIPT test/SCT_ConditionsConfig_test.py
+# PROPERTIES TIMEOUT 300 )
+
+# Install files from the package:
+#atlas_install_headers( FaserSCT_ConditionsTools )
+atlas_install_python_modules( python/*.py )
+atlas_install_scripts( share/*.py )
+
diff --git a/Tracker/TrackerConditions/FaserSCT_ConditionsTools/python/FaserSCT_DCSConditionsConfig.py b/Tracker/TrackerConditions/FaserSCT_ConditionsTools/python/FaserSCT_DCSConditionsConfig.py
new file mode 100644
index 0000000000000000000000000000000000000000..cc1ddf6c99661d1fdbace11d74e7c3785e90be9e
--- /dev/null
+++ b/Tracker/TrackerConditions/FaserSCT_ConditionsTools/python/FaserSCT_DCSConditionsConfig.py
@@ -0,0 +1,50 @@
+"""Define methods to configure SCT_DCSConditions
+
+Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+"""
+from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
+from AthenaConfiguration.ComponentFactory import CompFactory
+from IOVDbSvc.IOVDbSvcConfig import addFolders
+FaserSCT_DCSConditionsTool=CompFactory.FaserSCT_DCSConditionsTool
+FaserSCT_DCSConditionsStatCondAlg=CompFactory.FaserSCT_DCSConditionsStatCondAlg
+FaserSCT_DCSConditionsHVCondAlg=CompFactory.FaserSCT_DCSConditionsHVCondAlg
+FaserSCT_DCSConditionsTempCondAlg=CompFactory.FaserSCT_DCSConditionsTempCondAlg
+
+def FaserSCT_DCSConditionsToolCfg(flags, name="TrackerSCT_DCSConditionsTool", **kwargs):
+ """Return a configured FaserSCT_DCSConditionsTool"""
+ kwargs.setdefault("ReadAllDBFolders", True)
+ kwargs.setdefault("ReturnHVTemp", True)
+ return FaserSCT_DCSConditionsTool(name, **kwargs)
+
+def FaserSCT_DCSConditionsCfg(flags, name="TrackerSCT_DCSConditions", **kwargs):
+ """Return configured ComponentAccumulator and tool for FaserSCT_DCSConditions
+
+ DCSConditionsTool may be provided in kwargs
+ """
+ acc = ComponentAccumulator()
+ tool = kwargs.get("DCSConditionsTool", FaserSCT_DCSConditionsToolCfg(flags))
+ # folder arguments
+ dbInstance = kwargs.get("dbInstance", "DCS_OFL")
+ hvFolder = kwargs.get("hvFolder", "/SCT/DCS/HV")
+ tempFolder = kwargs.get("tempFolder", "/SCT/DCS/MODTEMP")
+ stateFolder = kwargs.get("stateFolder", "/SCT/DCS/CHANSTAT")
+ if tool.ReadAllDBFolders == tool.ReturnHVTemp:
+ acc.merge(addFolders(flags, stateFolder, dbInstance, className="CondAttrListCollection"))
+ # algo
+ statArgs = {
+ "name": name + "StatCondAlg",
+ "ReturnHVTemp": tool.ReturnHVTemp,
+ "ReadKeyHV": hvFolder,
+ "ReadKeyState": stateFolder,
+ }
+ statAlg = FaserSCT_DCSConditionsStatCondAlg(**statArgs)
+ acc.addCondAlgo(statAlg)
+ if tool.ReturnHVTemp:
+ acc.merge(addFolders(flags, [hvFolder, tempFolder], dbInstance, className="CondAttrListCollection"))
+ hvAlg = FaserSCT_DCSConditionsHVCondAlg(name=name + "HVCondAlg", ReadKey=hvFolder)
+ acc.addCondAlgo(hvAlg)
+ tempAlg = FaserSCT_DCSConditionsTempCondAlg(name=name + "TempCondAlg", ReadKey=tempFolder)
+ acc.addCondAlgo(tempAlg)
+ acc.setPrivateTools(tool)
+ return acc
+
diff --git a/Tracker/TrackerConditions/FaserSCT_ConditionsTools/python/FaserSCT_ReadCalibChipDataConfig.py b/Tracker/TrackerConditions/FaserSCT_ConditionsTools/python/FaserSCT_ReadCalibChipDataConfig.py
new file mode 100644
index 0000000000000000000000000000000000000000..1ea69808544262b9ef5eb0878046579f184011ec
--- /dev/null
+++ b/Tracker/TrackerConditions/FaserSCT_ConditionsTools/python/FaserSCT_ReadCalibChipDataConfig.py
@@ -0,0 +1,35 @@
+"""Define methods to configure ReadCalibChipDataTool
+
+Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+"""
+from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
+from AthenaConfiguration.ComponentFactory import CompFactory
+from IOVDbSvc.IOVDbSvcConfig import addFoldersSplitOnline
+FaserSCT_ReadCalibChipDataTool=CompFactory.FaserSCT_ReadCalibChipDataTool
+FaserSCT_ReadCalibChipNoiseCondAlg=CompFactory.FaserSCT_ReadCalibChipNoiseCondAlg
+FaserSCT_ReadCalibChipGainCondAlg=CompFactory.FaserSCT_ReadCalibChipGainCondAlg
+
+def FaserSCT_ReadCalibChipDataToolCfg(flags, name="TrackerSCT_ReadCalibChipDataTool", **kwargs):
+ """Return a ReadCalibChipDataTool configured for FaserSCT"""
+ return FaserSCT_ReadCalibChipDataTool(name, **kwargs)
+
+def FaserSCT_ReadCalibChipDataCfg(flags, name="FaserSCT_ReadCalibChip", **kwargs):
+ """Return configured ComponentAccumulator with FaserSCT_ReadCalibChipDataCfg tool
+
+ Accepts optional noiseFolder and gainFolder keyword arguments
+ """
+ acc = ComponentAccumulator()
+ # folders
+ noiseFolder = kwargs.get("noiseFolder", "/SCT/DAQ/Calibration/ChipNoise")
+ acc.merge(addFoldersSplitOnline(flags, "SCT", noiseFolder, noiseFolder, "CondAttrListCollection"))
+ gainFolder = kwargs.get("gainFolder", "/SCT/DAQ/Calibration/ChipGain")
+ acc.merge(addFoldersSplitOnline(flags, "SCT", gainFolder, gainFolder, "CondAttrListCollection"))
+ # Algorithms
+ noiseAlg = FaserSCT_ReadCalibChipNoiseCondAlg(name=name + "NoiseCondAlg", ReadKey=noiseFolder)
+ acc.addCondAlgo(noiseAlg)
+ gainAlg = FaserSCT_ReadCalibChipGainCondAlg(name=name + "GainCondAlg", ReadKey=gainFolder)
+ acc.addCondAlgo(gainAlg)
+ tool = kwargs.get("ReadCalibChipDataTool", FaserSCT_ReadCalibChipDataToolCfg(flags))
+ acc.setPrivateTools(tool)
+ return acc
+
diff --git a/Tracker/TrackerConditions/FaserSCT_ConditionsTools/python/FaserSCT_SiliconConditionsConfig.py b/Tracker/TrackerConditions/FaserSCT_ConditionsTools/python/FaserSCT_SiliconConditionsConfig.py
new file mode 100644
index 0000000000000000000000000000000000000000..ae60a15981abbee666aef5bd5aaeafa1a7ec4b02
--- /dev/null
+++ b/Tracker/TrackerConditions/FaserSCT_ConditionsTools/python/FaserSCT_SiliconConditionsConfig.py
@@ -0,0 +1,31 @@
+"""Define methods to configure SiPropertiesTool
+
+Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+"""
+from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
+from AthenaConfiguration.ComponentFactory import CompFactory
+FaserSCT_SiliconHVCondAlg=CompFactory.FaserSCT_SiliconHVCondAlg
+FaserSCT_SiliconTempCondAlg=CompFactory.FaserSCT_SiliconTempCondAlg
+FaserSCT_SiliconConditionsTool=CompFactory.FaserSCT_SiliconConditionsTool
+
+def FaserSCT_SiliconConditionsToolCfg(flags, name="FaserSCT_SiliconConditionsTool", **kwargs):
+ """Return a configured FaserSCT_SiliconConditionsTool (a.k.a. SiConditionsTool)"""
+ kwargs.setdefault("UseDB", True)
+ kwargs.setdefault("ForceUseGeoModel", False)
+ return FaserSCT_SiliconConditionsTool(name, **kwargs)
+
+def FaserSCT_SiliconConditionsCfg(flags, name="FaserSCT_Silicon", **kwargs):
+ """Return a ComponentAccumulator configured for SiliconConditions DB
+
+ DCSConditionsTool may be provided in kwargs
+ """
+ acc = ComponentAccumulator()
+ CondArgs = {}
+ DCSConditionsTool = kwargs.get("DCSConditionsTool")
+ if DCSConditionsTool:
+ CondArgs["UseState"] = DCSConditionsTool.ReadAllDBFolders
+ CondArgs["DCSConditionsTool"] = DCSConditionsTool
+ acc.addCondAlgo(FaserSCT_SiliconHVCondAlg(name=name + "HVCondAlg", **CondArgs))
+ acc.addCondAlgo(FaserSCT_SiliconTempCondAlg(name=name + "TempCondAlg", **CondArgs))
+ return acc
+
diff --git a/Tracker/TrackerConditions/FaserSCT_ConditionsTools/src/FaserSCT_DCSConditionsTool.cxx b/Tracker/TrackerConditions/FaserSCT_ConditionsTools/src/FaserSCT_DCSConditionsTool.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..82f26169341ee9c6d5e35eea096eb816c3dbc941
--- /dev/null
+++ b/Tracker/TrackerConditions/FaserSCT_ConditionsTools/src/FaserSCT_DCSConditionsTool.cxx
@@ -0,0 +1,228 @@
+/*
+ Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+*/
+
+// New FaserSCT_DCSConditions Tool, based on existing tool in SCT_ConditionsAlgs
+// A. R-Veronneau 26/02/08
+
+#include "FaserSCT_DCSConditionsTool.h"
+#include "TrackerIdentifier/FaserSCT_ID.h"
+
+#include "GaudiKernel/ThreadLocalContext.h"
+
+#include "FaserSCT_IdConverter.h"
+using FaserSCT_ConditionsTools::castId;
+
+const Identifier FaserSCT_DCSConditionsTool::s_invalidId;
+const float FaserSCT_DCSConditionsTool::s_defaultHV{-30.};
+const float FaserSCT_DCSConditionsTool::s_defaultTemperature{-40.};
+
+FaserSCT_DCSConditionsTool::FaserSCT_DCSConditionsTool(const std::string& type, const std::string& name, const IInterface* parent) :
+ base_class(type, name, parent)
+{
+}
+
+StatusCode FaserSCT_DCSConditionsTool::initialize() {
+ if (detStore()->retrieve(m_pHelper,"FaserSCT_ID").isFailure()) {
+ ATH_MSG_ERROR("FaserSCT helper failed to retrieve ");
+ return StatusCode::FAILURE;
+ }
+
+ // Read Cond Handle Keys
+ if ((m_readAllDBFolders and m_returnHVTemp) or m_returnHVTemp) {
+ ATH_CHECK(m_condKeyHV.initialize());
+ ATH_CHECK(m_condKeyTemp0.initialize());
+ }
+ if ((m_readAllDBFolders and m_returnHVTemp) or (not m_readAllDBFolders and not m_returnHVTemp)) {
+ ATH_CHECK(m_condKeyState.initialize());
+ }
+
+ return StatusCode::SUCCESS;
+}
+
+StatusCode FaserSCT_DCSConditionsTool::finalize() {
+ return StatusCode::SUCCESS;
+}
+
+//Can report about the module as a whole or the wafer
+bool FaserSCT_DCSConditionsTool::canReportAbout(InDetConditions::Hierarchy h) const {
+ return (h==InDetConditions::SCT_MODULE or h==InDetConditions::SCT_SIDE or h==InDetConditions::SCT_STRIP);
+}
+
+//returns the module ID (int), or returns -1 if not able to report
+Identifier FaserSCT_DCSConditionsTool::getModuleID(const Identifier& elementId, InDetConditions::Hierarchy h) const {
+ if (not canReportAbout(h)) return s_invalidId;
+
+ Identifier moduleId;
+
+ if (h==InDetConditions::SCT_MODULE) {
+ moduleId = elementId;
+ } else if (h==InDetConditions::SCT_SIDE) {
+ moduleId = m_pHelper->module_id(elementId);
+ } else if (h==InDetConditions::SCT_STRIP) {
+ Identifier waferId = m_pHelper->wafer_id(elementId);
+ moduleId = m_pHelper->module_id(waferId);
+ }
+ return moduleId;
+}
+
+//Returns if element Id is good or bad
+bool FaserSCT_DCSConditionsTool::isGood(const Identifier& elementId, const EventContext& ctx, InDetConditions::Hierarchy h) const {
+ Identifier moduleId{getModuleID(elementId, h)};
+ if (not moduleId.is_valid()) return true; // not canreportabout
+
+ if ((m_readAllDBFolders and m_returnHVTemp) or (not m_readAllDBFolders and not m_returnHVTemp)) {
+ const FaserSCT_DCSStatCondData* condDataState{getCondDataState(ctx)};
+ if (!condDataState) return false; // no cond data
+ else if (condDataState->output(castId(moduleId))==0) return true; //No params are listed as bad
+ else return false;
+ } else {
+ return true;
+ }
+}
+
+bool FaserSCT_DCSConditionsTool::isGood(const Identifier& elementId, InDetConditions::Hierarchy h) const {
+ const EventContext& ctx{Gaudi::Hive::currentContext()};
+ return isGood(elementId, ctx, h);
+}
+
+//Does the same for hashIds
+bool FaserSCT_DCSConditionsTool::isGood(const IdentifierHash& hashId, const EventContext& ctx) const {
+ Identifier waferId{m_pHelper->wafer_id(hashId)};
+ Identifier moduleId{m_pHelper->module_id(waferId)};
+ return isGood(moduleId, ctx, InDetConditions::SCT_MODULE);
+}
+
+bool FaserSCT_DCSConditionsTool::isGood(const IdentifierHash& hashId) const {
+ const EventContext& ctx{Gaudi::Hive::currentContext()};
+ return isGood(hashId, ctx);
+}
+
+///////////////////////////////////
+
+// some lame helper methods:
+// returns HV (s_defaultHV(-30) if there is no information)
+float FaserSCT_DCSConditionsTool::modHV(const Identifier& elementId, const EventContext& ctx, InDetConditions::Hierarchy h) const {
+ Identifier moduleId{getModuleID(elementId, h)};
+ if (not moduleId.is_valid()) return s_defaultHV; // not canreportabout, return s_defaultHV(-30)
+
+ const FaserSCT_DCSFloatCondData* condDataHV{getCondDataHV(ctx)};
+ if (!condDataHV) return s_defaultHV; // no cond data
+
+ float hvval{s_defaultHV};
+ if (condDataHV->getValue(castId(moduleId), hvval) and isGood(elementId, h)) {
+ return hvval;
+ }
+ return s_defaultHV; //didn't find the module, return s_defaultHV(-30)
+}
+
+float FaserSCT_DCSConditionsTool::modHV(const Identifier& elementId, InDetConditions::Hierarchy h) const {
+ const EventContext& ctx{Gaudi::Hive::currentContext()};
+ return modHV(elementId, ctx, h);
+}
+
+//Does the same for hashIds
+float FaserSCT_DCSConditionsTool::modHV(const IdentifierHash& hashId, const EventContext& ctx) const {
+ Identifier waferId{m_pHelper->wafer_id(hashId)};
+ Identifier moduleId{m_pHelper->module_id(waferId)};
+ return modHV(moduleId, ctx, InDetConditions::SCT_MODULE);
+}
+
+float FaserSCT_DCSConditionsTool::modHV(const IdentifierHash& hashId) const {
+ const EventContext& ctx{Gaudi::Hive::currentContext()};
+ return modHV(hashId, ctx);
+}
+
+//Returns temp0 (s_defaultTemperature(-40) if there is no information)
+float FaserSCT_DCSConditionsTool::hybridTemperature(const Identifier& elementId, const EventContext& ctx, InDetConditions::Hierarchy h) const {
+ Identifier moduleId{getModuleID(elementId, h)};
+ if (not moduleId.is_valid()) return s_defaultTemperature; // not canreportabout
+
+ const FaserSCT_DCSFloatCondData* condDataTemp0{getCondDataTemp0(ctx)};
+ if (!condDataTemp0) return s_defaultTemperature; // no cond data
+
+ float temperature{s_defaultTemperature};
+ if (condDataTemp0->getValue(castId(moduleId), temperature) and isGood(elementId, h)) {
+ return temperature;
+ }
+ return s_defaultTemperature;//didn't find the module, return -40.
+}
+
+float FaserSCT_DCSConditionsTool::hybridTemperature(const Identifier& elementId, InDetConditions::Hierarchy h) const {
+ const EventContext& ctx{Gaudi::Hive::currentContext()};
+ return hybridTemperature(elementId, ctx, h);
+}
+
+//Does the same for hashIds
+float FaserSCT_DCSConditionsTool::hybridTemperature(const IdentifierHash& hashId, const EventContext& ctx) const {
+ Identifier waferId{m_pHelper->wafer_id(hashId)};
+ Identifier moduleId{m_pHelper->module_id(waferId)};
+ return hybridTemperature(moduleId, ctx, InDetConditions::SCT_MODULE);
+}
+
+float FaserSCT_DCSConditionsTool::hybridTemperature(const IdentifierHash& hashId) const {
+ const EventContext& ctx{Gaudi::Hive::currentContext()};
+ return hybridTemperature(hashId, ctx);
+}
+
+//Returns temp0 + correction for Lorentz angle calculation (s_defaultTemperature(-40) if there is no information)
+float FaserSCT_DCSConditionsTool::sensorTemperature(const Identifier& elementId, const EventContext& ctx, InDetConditions::Hierarchy h) const {
+ Identifier moduleId{getModuleID(elementId, h)};
+ if (not moduleId.is_valid()) return s_defaultTemperature; // not canreportabout
+
+ const FaserSCT_DCSFloatCondData* condDataTemp0{getCondDataTemp0(ctx)};
+ if (!condDataTemp0) return s_defaultTemperature; // no cond data
+
+ float temperature{s_defaultTemperature};
+ if (condDataTemp0->getValue(castId(moduleId), temperature) and isGood(elementId, h)) {
+ // int bec{m_pHelper->station(moduleId)};
+ // if (bec==0) { // Barrel
+ return ( temperature + m_barrel_correction); //return the temp+correction
+ // } else { // Endcaps
+ // int modeta{m_pHelper->eta_module(moduleId)};
+ // if (modeta==2) {
+ // return (temperature + m_ecInner_correction); //return the temp+correction
+ // } else {
+ // return (temperature + m_ecOuter_correction); //return the temp+correction
+ // }
+ // }
+ }
+ return s_defaultTemperature; //didn't find the module, return s_defaultTemperature(-40).
+}
+
+float FaserSCT_DCSConditionsTool::sensorTemperature(const Identifier& elementId, InDetConditions::Hierarchy h) const {
+ const EventContext& ctx{Gaudi::Hive::currentContext()};
+ return sensorTemperature(elementId, ctx, h);
+}
+
+//Does the same for hashIds
+float FaserSCT_DCSConditionsTool::sensorTemperature(const IdentifierHash& hashId, const EventContext& ctx) const {
+ Identifier waferId{m_pHelper->wafer_id(hashId)};
+ Identifier moduleId{m_pHelper->module_id(waferId)};
+ return sensorTemperature(moduleId, ctx, InDetConditions::SCT_MODULE);
+}
+
+float FaserSCT_DCSConditionsTool::sensorTemperature(const IdentifierHash& hashId) const {
+ const EventContext& ctx{Gaudi::Hive::currentContext()};
+ return sensorTemperature(hashId, ctx);
+}
+
+///////////////////////////////////
+
+const FaserSCT_DCSStatCondData*
+FaserSCT_DCSConditionsTool::getCondDataState(const EventContext& ctx) const {
+ SG::ReadCondHandle<FaserSCT_DCSStatCondData> condData{m_condKeyState, ctx};
+ return condData.retrieve();
+}
+
+const FaserSCT_DCSFloatCondData*
+FaserSCT_DCSConditionsTool::getCondDataHV(const EventContext& ctx) const {
+ SG::ReadCondHandle<FaserSCT_DCSFloatCondData> condData{m_condKeyHV, ctx};
+ return condData.retrieve();
+}
+
+const FaserSCT_DCSFloatCondData*
+FaserSCT_DCSConditionsTool::getCondDataTemp0(const EventContext& ctx) const {
+ SG::ReadCondHandle<FaserSCT_DCSFloatCondData> condData{m_condKeyTemp0, ctx};
+ return condData.retrieve();
+}
diff --git a/Tracker/TrackerConditions/FaserSCT_ConditionsTools/src/FaserSCT_DCSConditionsTool.h b/Tracker/TrackerConditions/FaserSCT_ConditionsTools/src/FaserSCT_DCSConditionsTool.h
new file mode 100644
index 0000000000000000000000000000000000000000..c3ef130e4bc2731170164850bece478b69b75ff7
--- /dev/null
+++ b/Tracker/TrackerConditions/FaserSCT_ConditionsTools/src/FaserSCT_DCSConditionsTool.h
@@ -0,0 +1,99 @@
+// -*- C++ -*-
+
+/*
+ Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef FASERSCT_DCSConditionsTool_h
+#define FASERSCT_DCSConditionsTool_h
+/**
+ * @file FaserSCT_DCSConditionsTool.h
+ *
+ * @brief Header file for the FaserSCT_DCSConditionsTool class
+ * in package FaserSCT_ConditionsTools
+ *
+ * @author A. R-Veronneau 26/02/07, Shaun Roe 4/4/2008
+ **/
+
+// Athena
+#include "AthenaBaseComps/AthAlgTool.h"
+#include "SCT_ConditionsTools/ISCT_DCSConditionsTool.h"
+
+#include "InDetConditionsSummaryService/InDetHierarchy.h"
+#include "Identifier/Identifier.h"
+#include "Identifier/IdentifierHash.h"
+#include "FaserSCT_ConditionsData/FaserSCT_DCSFloatCondData.h"
+#include "FaserSCT_ConditionsData/FaserSCT_DCSStatCondData.h"
+
+// Gaudi
+#include "GaudiKernel/Property.h"
+#include "GaudiKernel/EventContext.h"
+
+// STL
+#include <string>
+
+class FaserSCT_ID;
+
+/**
+ * Class to provide DCS information about modules from the COOL database
+ **/
+class FaserSCT_DCSConditionsTool: public extends<AthAlgTool, ISCT_DCSConditionsTool> {
+
+public:
+ FaserSCT_DCSConditionsTool(const std::string& type, const std::string& name, const IInterface* parent);
+ virtual ~FaserSCT_DCSConditionsTool() = default;
+ virtual StatusCode initialize() override;
+ virtual StatusCode finalize() override;
+
+ /// @name Methods to be implemented from virtual baseclass methods, when introduced
+ //@{
+ ///Return whether this service can report on the hierarchy level (e.g. module, chip...)
+ virtual bool canReportAbout(InDetConditions::Hierarchy h) const override;
+ //returns the module ID (int), or returns 9999 (not a valid module number) if not able to report
+ virtual Identifier getModuleID(const Identifier& elementId, InDetConditions::Hierarchy h) const;
+ ///Summarise the result from the service as good/bad
+ virtual bool isGood(const Identifier& elementId, const EventContext& ctx, InDetConditions::Hierarchy h=InDetConditions::DEFAULT) const override;
+ virtual bool isGood(const Identifier& elementId, InDetConditions::Hierarchy h=InDetConditions::DEFAULT) const override;
+ ///is it good?, using wafer hash
+ virtual bool isGood(const IdentifierHash& hashId, const EventContext& ctx) const override;
+ virtual bool isGood(const IdentifierHash& hashId) const override;
+ //Returns HV (0 if there is no information)
+ virtual float modHV(const Identifier& elementId, const EventContext& ctx, InDetConditions::Hierarchy h=InDetConditions::DEFAULT) const override;
+ virtual float modHV(const Identifier& elementId, InDetConditions::Hierarchy h=InDetConditions::DEFAULT) const override;
+ //Does the same for hashIds
+ virtual float modHV(const IdentifierHash& hashId, const EventContext& ctx) const override;
+ virtual float modHV(const IdentifierHash& hashId) const override;
+ //Returns temp0 (0 if there is no information)
+ virtual float hybridTemperature(const Identifier& elementId, const EventContext& ctx, InDetConditions::Hierarchy h=InDetConditions::DEFAULT) const override;
+ virtual float hybridTemperature(const Identifier& elementId, InDetConditions::Hierarchy h=InDetConditions::DEFAULT) const override;
+ //Does the same for hashIds
+ virtual float hybridTemperature(const IdentifierHash& hashId, const EventContext& ctx) const override;
+ virtual float hybridTemperature(const IdentifierHash& hashId) const override;
+ //Returns temp0 + correction for Lorentz angle calculation (0 if there is no information)
+ virtual float sensorTemperature(const Identifier& elementId, const EventContext& ctx, InDetConditions::Hierarchy h=InDetConditions::DEFAULT) const override;
+ virtual float sensorTemperature(const Identifier& elementId, InDetConditions::Hierarchy h=InDetConditions::DEFAULT) const override;
+ //Does the same for hashIds
+ virtual float sensorTemperature(const IdentifierHash& hashId, const EventContext& ctx) const override;
+ virtual float sensorTemperature(const IdentifierHash& hashId) const override;
+ //@}
+
+private:
+ //Key for DataHandle
+ BooleanProperty m_readAllDBFolders{this, "ReadAllDBFolders", true};
+ BooleanProperty m_returnHVTemp{this, "ReturnHVTemp", true};
+ FloatProperty m_barrel_correction{this, "TempBarrelCorrection", -3.7};
+ FloatProperty m_ecInner_correction{this, "TempEcInnerCorrection", -13.1};
+ FloatProperty m_ecOuter_correction{this, "TempEcOuterCorrection", -15.5};
+ SG::ReadCondHandleKey<FaserSCT_DCSStatCondData> m_condKeyState{this, "CondKeyState", "SCT_DCSStatCondData", "SCT DCS state"};
+ SG::ReadCondHandleKey<FaserSCT_DCSFloatCondData> m_condKeyHV{this, "CondKeyHV", "SCT_DCSHVCondData", "SCT DCS HV"};
+ SG::ReadCondHandleKey<FaserSCT_DCSFloatCondData> m_condKeyTemp0{this, "CondKeyTemp0", "SCT_DCSTemp0CondData", "SCT DCS temperature on side 0"};
+ const FaserSCT_ID* m_pHelper{nullptr};
+ static const Identifier s_invalidId;
+ static const float s_defaultHV;
+ static const float s_defaultTemperature;
+ const FaserSCT_DCSStatCondData* getCondDataState(const EventContext& ctx) const;
+ const FaserSCT_DCSFloatCondData* getCondDataHV(const EventContext& ctx) const;
+ const FaserSCT_DCSFloatCondData* getCondDataTemp0(const EventContext& ctx) const;
+};
+
+#endif // FaserSCT_DCSConditionsTool_h
diff --git a/Tracker/TrackerConditions/FaserSCT_ConditionsTools/src/FaserSCT_IdConverter.h b/Tracker/TrackerConditions/FaserSCT_ConditionsTools/src/FaserSCT_IdConverter.h
new file mode 100644
index 0000000000000000000000000000000000000000..4b4afdb5b421ba9c30693bf7c8656ae0b9b1293f
--- /dev/null
+++ b/Tracker/TrackerConditions/FaserSCT_ConditionsTools/src/FaserSCT_IdConverter.h
@@ -0,0 +1,16 @@
+/*
+ Copyright (C) 2002-2018 CERN for the benefit of the ATLAS collaboration
+*/
+
+/**
+ * FaserSCT_IdConverter.h
+ * @file Header file for converter functions for Identifiers 64 / 32 bit
+ * @author Shaun Roe (shaun.roe@cern.ch)
+ **/
+#include "Identifier/Identifier.h"
+
+namespace FaserSCT_ConditionsTools {
+ inline unsigned int castId(const Identifier& identifier) {
+ return identifier.get_identifier32().get_compact();
+ }
+} //end of namespace
diff --git a/Tracker/TrackerConditions/FaserSCT_ConditionsTools/src/FaserSCT_ReadCalibChipDataTool.cxx b/Tracker/TrackerConditions/FaserSCT_ConditionsTools/src/FaserSCT_ReadCalibChipDataTool.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..e880dd8260c863baf15d3bda41cf6f64f8b55453
--- /dev/null
+++ b/Tracker/TrackerConditions/FaserSCT_ConditionsTools/src/FaserSCT_ReadCalibChipDataTool.cxx
@@ -0,0 +1,247 @@
+/*
+ Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+*/
+
+/** @file FaserSCT_ReadCalibChipDataTool.cxx Implementation file for FaserSCT_ReadCalibChipDataTool.
+ @author Per Johansson (23/03/09), Shaun Roe (17/2/2010)
+*/
+
+#include "FaserSCT_ReadCalibChipDataTool.h"
+
+// Include Athena stuff
+#include "Identifier/Identifier.h"
+#include "TrackerIdentifier/FaserSCT_ID.h"
+#include "FaserSCT_ConditionsData/FaserSCT_ModuleCalibParameter.h"
+#include "FaserSCT_ConditionsData/FaserSCT_ModuleGainCalibData.h"
+#include "FaserSCT_ConditionsData/FaserSCT_ModuleNoiseCalibData.h"
+#include "SCT_ConditionsTools/SCT_ReadCalibChipUtilities.h"
+
+using namespace FaserSCT_ConditionsData;
+using namespace SCT_ReadCalibChipUtilities;
+
+//----------------------------------------------------------------------
+FaserSCT_ReadCalibChipDataTool::FaserSCT_ReadCalibChipDataTool (const std::string& type, const std::string& name, const IInterface* parent) :
+ base_class(type, name, parent)
+{
+}
+
+//----------------------------------------------------------------------
+StatusCode
+FaserSCT_ReadCalibChipDataTool::initialize() {
+ // Get SCT helper
+ ATH_CHECK(detStore()->retrieve(m_id_sct, "FaserSCT_ID"));
+
+ // Read Cond Handle Key
+ ATH_CHECK(m_condKeyGain.initialize());
+ ATH_CHECK(m_condKeyNoise.initialize());
+
+ return StatusCode::SUCCESS;
+} // SCT_ReadCalibChipDataTool::initialize()
+
+//----------------------------------------------------------------------
+StatusCode
+FaserSCT_ReadCalibChipDataTool::finalize() {
+ // Print where you are
+ return StatusCode::SUCCESS;
+} // SCT_ReadCalibChipDataTool::finalize()
+
+//----------------------------------------------------------------------
+//Can only report good/bad at side level
+bool
+FaserSCT_ReadCalibChipDataTool::canReportAbout(InDetConditions::Hierarchy h) const {
+ return (h==InDetConditions::SCT_SIDE);
+}
+
+//----------------------------------------------------------------------
+// Returns a bool summary of the data
+bool
+FaserSCT_ReadCalibChipDataTool::isGood(const IdentifierHash& elementHashId, const EventContext& ctx) const {
+ // Retrieve FaserSCT_NoiseCalibData pointer
+ const FaserSCT_NoiseCalibData* condDataNoise{getCondDataNoise(ctx)};
+ if (condDataNoise==nullptr) {
+ ATH_MSG_ERROR("In isGood, FaserSCT_NoiseCalibData cannot be retrieved");
+ return true;
+ }
+
+ const unsigned int moduleIdx{elementHashId/SIDES_PER_MODULE};
+ // Retrieve defect data from map
+ const FaserSCT_ModuleNoiseCalibData& noiseOccData{(*condDataNoise)[moduleIdx]};
+
+ // Retrieve the data
+ const int i{noiseOccIndex("NoiseByChip")};
+ if (i<0) {
+ ATH_MSG_ERROR("This NoiseOccupancy noise data does not exist");
+ return true;
+ }
+ const FaserSCT_ModuleCalibParameter& moduleNoiseData{noiseOccData[i]};
+
+ // Calcuate module status
+ // For now just simple check NO mean noise level
+ // Chip could be 0 if bypassed, need to check
+ const int side{static_cast<int>(elementHashId%2)};
+ int chip{side*CHIPS_PER_SIDE};
+ const int endChip{CHIPS_PER_SIDE+chip};
+ int nChips{0};
+ float sum{0.0};
+ for (; chip!=endChip; ++chip) {
+ float chipNoise{moduleNoiseData[chip]};
+ if (chipNoise!=0.0) {
+ sum+=chipNoise;
+ ++nChips;
+ }
+ }
+ const float meanNoiseValue{sum/nChips};
+ ATH_MSG_DEBUG("Module mean noise: " << meanNoiseValue);
+ return (meanNoiseValue < m_noiseLevel);
+} //FaserSCT_ReadCalibChipDataTool::summary()
+
+bool
+FaserSCT_ReadCalibChipDataTool::isGood(const IdentifierHash& elementHashId) const {
+ const EventContext& ctx{Gaudi::Hive::currentContext()};
+
+ return isGood(elementHashId, ctx);
+}
+
+//----------------------------------------------------------------------
+// Returns a bool summary of the data
+bool
+FaserSCT_ReadCalibChipDataTool::isGood(const Identifier& elementId, const EventContext& ctx, InDetConditions::Hierarchy h) const {
+ if (h==InDetConditions::SCT_SIDE) { //Could do by chip too
+ const IdentifierHash elementIdHash{m_id_sct->wafer_hash(elementId)};
+ return isGood(elementIdHash, ctx);
+ } else{
+ // Not applicable for Calibration data
+ ATH_MSG_WARNING("summary(): " << h << "good/bad is not applicable for Calibration data");
+ return true;
+ }
+}
+
+bool
+FaserSCT_ReadCalibChipDataTool::isGood(const Identifier& elementId, InDetConditions::Hierarchy h) const {
+ const EventContext& ctx{Gaudi::Hive::currentContext()};
+
+ return isGood(elementId, ctx, h);
+}
+
+//----------------------------------------------------------------------
+std::vector<float>
+FaserSCT_ReadCalibChipDataTool::getNPtGainData(const Identifier& moduleId, const int side, const std::string& datatype, const EventContext& ctx) const {
+ // Print where you are
+ ATH_MSG_DEBUG("in getNPtGainData()");
+ std::vector<float> waferData;
+
+ // Retrieve FaserSCT_GainCalibData pointer
+ const FaserSCT_GainCalibData* condDataGain{getCondDataGain(ctx)};
+ if (condDataGain==nullptr) {
+ ATH_MSG_ERROR("In getNPtGainData, FaserSCT_GainCalibData cannot be retrieved");
+ return waferData;
+ }
+
+ //find hash
+ const IdentifierHash hashId{m_id_sct->wafer_hash(moduleId)};
+ //make index
+ const unsigned int idx{hashId/SIDES_PER_MODULE};
+ //Retrieve defect data from map
+ try {
+ const FaserSCT_ModuleGainCalibData& wantedNPGData{condDataGain->at(idx)};
+ //find the correct index for the required data
+ const int dataIdx{nPtGainIndex(datatype)};
+ if (dataIdx<0) {
+ ATH_MSG_ERROR("This N-point gain data: " << datatype << " does not exist");
+ return waferData;
+ }
+ const FaserSCT_ModuleCalibParameter& moduleGains{wantedNPGData[dataIdx]};
+ const int startOffset{side*CHIPS_PER_SIDE};
+ const int endOffset{CHIPS_PER_SIDE+startOffset};
+ FaserSCT_ModuleCalibParameter::const_iterator it{moduleGains.begin() + startOffset};
+ FaserSCT_ModuleCalibParameter::const_iterator end{moduleGains.begin() + endOffset};
+ // Returns the data for the wanted wafer
+ if (*it != *it) return waferData;
+ //could use signaling NaN here and catch the exception instead, would be quicker: NO!
+ //see: http://stackoverflow.com/questions/235386/using-nan-in-c
+ waferData.assign(it, end);
+ return waferData;
+ } catch (const std::out_of_range& e) {
+ return waferData;
+ }
+} //FaserSCT_ReadCalibChipDataTool::getNPtGainData()
+
+std::vector<float>
+FaserSCT_ReadCalibChipDataTool::getNPtGainData(const Identifier& moduleId, const int side, const std::string& datatype) const {
+ const EventContext& ctx{Gaudi::Hive::currentContext()};
+ return getNPtGainData(moduleId, side, datatype, ctx);
+}
+
+//----------------------------------------------------------------------
+std::vector<float>
+FaserSCT_ReadCalibChipDataTool::getNoiseOccupancyData(const Identifier& moduleId, const int side, const std::string& datatype, const EventContext& ctx) const {
+ // Print where you are
+ ATH_MSG_DEBUG("in getNoiseOccupancyData()");
+ std::vector<float> waferData;
+
+ // Retrieve FaserSCT_NoiseCalibData pointer
+ const FaserSCT_NoiseCalibData* condDataNoise{getCondDataNoise(ctx)};
+ if (condDataNoise==nullptr) {
+ ATH_MSG_ERROR("In getNPtNoiseData, FaserSCT_NoiseCalibData cannot be retrieved");
+ return waferData;
+ }
+
+ //find hash
+ const IdentifierHash hashId{m_id_sct->wafer_hash(moduleId)};
+ //make index
+ const unsigned int idx{hashId/SIDES_PER_MODULE};
+ try {
+ //Retrieve defect data from array
+ const FaserSCT_ModuleNoiseCalibData& wantedNoiseData{condDataNoise->at(idx)};
+
+ //find the correct index for the required data
+ const int dataIdx{noiseOccIndex(datatype)};
+ if (dataIdx<0) {
+ ATH_MSG_ERROR("This Noise Occupancy data: " << datatype << " does not exist");
+ return waferData;
+ }
+ const FaserSCT_ModuleCalibParameter& moduleNoise{wantedNoiseData[dataIdx]};
+ const int startOffset{side*CHIPS_PER_SIDE};
+ const int endOffset{CHIPS_PER_SIDE+startOffset};
+ FaserSCT_ModuleCalibParameter::const_iterator it{moduleNoise.begin() + startOffset};
+ FaserSCT_ModuleCalibParameter::const_iterator end{moduleNoise.begin() + endOffset};
+ // Returns the data for the wanted wafer
+ if (*it != *it) return waferData;
+ waferData.assign(it, end);
+ return waferData;
+ } catch (const std::out_of_range& e) {
+ return waferData;
+ }
+} // FaserSCT_ReadCalibChipDataTool::getNoiseOccupancyData()
+
+std::vector<float>
+FaserSCT_ReadCalibChipDataTool::getNoiseOccupancyData(const Identifier& moduleId, const int side, const std::string& datatype) const {
+ const EventContext& ctx{Gaudi::Hive::currentContext()};
+ return getNoiseOccupancyData(moduleId, side, datatype, ctx);
+}
+
+int
+FaserSCT_ReadCalibChipDataTool::nPtGainIndex(const std::string& dataName) const {
+ int i{N_NPTGAIN};
+ while (i--) if (dataName==nPtGainParameterNames[i]) break;
+ return i;
+}
+
+int
+FaserSCT_ReadCalibChipDataTool::noiseOccIndex(const std::string& dataName) const {
+ int i{N_NOISEOCC};
+ while (i--) if (dataName==noiseOccParameterNames[i]) break;
+ return i;
+}
+
+const FaserSCT_GainCalibData*
+FaserSCT_ReadCalibChipDataTool::getCondDataGain(const EventContext& ctx) const {
+ SG::ReadCondHandle<FaserSCT_GainCalibData> condData{m_condKeyGain, ctx};
+ return condData.retrieve();
+}
+
+const FaserSCT_NoiseCalibData*
+FaserSCT_ReadCalibChipDataTool::getCondDataNoise(const EventContext& ctx) const {
+ SG::ReadCondHandle<FaserSCT_NoiseCalibData> condData{m_condKeyNoise, ctx};
+ return condData.retrieve();
+}
diff --git a/Tracker/TrackerConditions/FaserSCT_ConditionsTools/src/FaserSCT_ReadCalibChipDataTool.h b/Tracker/TrackerConditions/FaserSCT_ConditionsTools/src/FaserSCT_ReadCalibChipDataTool.h
new file mode 100644
index 0000000000000000000000000000000000000000..5ab77816cd31f49f2810f7aec92b78b79fcf5942
--- /dev/null
+++ b/Tracker/TrackerConditions/FaserSCT_ConditionsTools/src/FaserSCT_ReadCalibChipDataTool.h
@@ -0,0 +1,86 @@
+// -*- C++ -*-
+
+/*
+ Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+*/
+
+/** @file FaserSCT_ReadCalibChipDataTool.h Header file for FaserSCT_ReadCalibChipDataTool.
+ @author Per Johansson, 23/03/09
+*/
+
+// Multiple inclusion protection
+#ifndef FASERSCT_READ_CALIB_CHIP_DATA_TOOL
+#define FASERSCT_READ_CALIB_CHIP_DATA_TOOL
+
+// Include interface class
+#include "AthenaBaseComps/AthAlgTool.h"
+#include "SCT_ConditionsTools/ISCT_ReadCalibChipDataTool.h"
+
+// Include Athena stuff
+#include "FaserSCT_ConditionsData/FaserSCT_ConditionsParameters.h"
+#include "FaserSCT_ConditionsData/FaserSCT_GainCalibData.h"
+#include "FaserSCT_ConditionsData/FaserSCT_NoiseCalibData.h"
+
+// Include Gaudi classes
+#include "GaudiKernel/EventContext.h"
+
+// Forward declarations
+class FaserSCT_ID;
+
+/** This class contains a Tool that reads SCT calibration data and makes it available to
+ other algorithms. The current implementation reads the data from a COOL database.
+*/
+
+class FaserSCT_ReadCalibChipDataTool: public extends<AthAlgTool, ISCT_ReadCalibChipDataTool> {
+
+ public:
+ //----------Public Member Functions----------//
+ // Structors
+ FaserSCT_ReadCalibChipDataTool(const std::string& type, const std::string& name, const IInterface* parent); //!< Constructor
+ virtual ~FaserSCT_ReadCalibChipDataTool() = default; //!< Destructor
+
+ // Standard Gaudi functions
+ virtual StatusCode initialize() override; //!< Gaudi initialiser
+ virtual StatusCode finalize() override; //!< Gaudi finaliser
+
+ /// @name Methods to be implemented from virtual baseclass methods, when introduced
+ ///Return whether this service can report on the hierarchy level (e.g. module, chip...)
+ virtual bool canReportAbout(InDetConditions::Hierarchy h) const override;
+ ///Summarise the result from the service as good/bad
+ virtual bool isGood(const Identifier& elementId, const EventContext& ctx, InDetConditions::Hierarchy h=InDetConditions::DEFAULT) const override;
+ virtual bool isGood(const Identifier& elementId, InDetConditions::Hierarchy h=InDetConditions::DEFAULT) const override;
+ ///same thing with id hash, introduced by shaun with dummy method for now
+ virtual bool isGood(const IdentifierHash& hashId, const EventContext& ctx) const override;
+ virtual bool isGood(const IdentifierHash& hashId) const override;
+ //@}
+
+ // Methods to return calibration data
+ virtual std::vector<float> getNPtGainData(const Identifier& moduleId, const int side, const std::string& datatype, const EventContext& ctx) const override; //!<Get NPtGain data per wafer
+ virtual std::vector<float> getNPtGainData(const Identifier& moduleId, const int side, const std::string& datatype) const override; //!<Get NPtGain data per wafer
+ virtual std::vector<float> getNoiseOccupancyData(const Identifier& moduleId, const int side, const std::string& datatype, const EventContext& ctx) const override; //!<Get NoiseOccupancy data wafer
+ virtual std::vector<float> getNoiseOccupancyData(const Identifier& moduleId, const int side, const std::string& datatype) const override; //!<Get NoiseOccupancy data wafer
+
+ private:
+ // Private enums
+ enum FolderType {NPTGAIN, NOISEOCC, UNKNOWN_FOLDER, N_FOLDERTYPES};
+
+ // Private methods
+ int nPtGainIndex(const std::string& dataName) const;
+ int noiseOccIndex(const std::string& dataName) const;
+
+ const FaserSCT_GainCalibData* getCondDataGain(const EventContext& ctx) const;
+ const FaserSCT_NoiseCalibData* getCondDataNoise(const EventContext& ctx) const;
+
+ //----------Private Attributes----------//
+ const FaserSCT_ID* m_id_sct{nullptr}; //!< Handle to FaserSCT ID helper
+
+ // Read Cond Handles
+ SG::ReadCondHandleKey<FaserSCT_GainCalibData> m_condKeyGain{this, "CondKeyGain", "SCT_GainCalibData", "SCT calibration data of gains of chips"};
+ SG::ReadCondHandleKey<FaserSCT_NoiseCalibData> m_condKeyNoise{this, "CondKeyNoise", "SCT_NoiseCalibData", "SCT calibration data of noises of chips"};
+
+ // Noise level for isGood::Side
+ FloatProperty m_noiseLevel{this, "NoiseLevel", 1800.0, "Noise Level for isGood if ever used"};
+};
+
+//----------------------------------------------------------------------
+#endif // FASERSCT_READ_CALIB_CHIP_DATA_TOOL
diff --git a/Tracker/TrackerConditions/FaserSCT_ConditionsTools/src/FaserSCT_SiliconConditionsTool.cxx b/Tracker/TrackerConditions/FaserSCT_ConditionsTools/src/FaserSCT_SiliconConditionsTool.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..91e5000c7061d257d1569e3d29044fa305271c37
--- /dev/null
+++ b/Tracker/TrackerConditions/FaserSCT_ConditionsTools/src/FaserSCT_SiliconConditionsTool.cxx
@@ -0,0 +1,177 @@
+/*
+ Copyright (C) 2002-2018 CERN for the benefit of the ATLAS collaboration
+*/
+
+#include "FaserSCT_SiliconConditionsTool.h"
+
+#include "GeoModelInterfaces/IGeoModelSvc.h"
+#include "GeoModelFaserUtilities/DecodeFaserVersionKey.h"
+#include "RDBAccessSvc/IRDBAccessSvc.h"
+#include "RDBAccessSvc/IRDBRecord.h"
+#include "RDBAccessSvc/IRDBRecordset.h"
+#include "TrackerIdentifier/FaserSCT_ID.h"
+
+// Constructor
+FaserSCT_SiliconConditionsTool::FaserSCT_SiliconConditionsTool(const std::string& type, const std::string& name, const IInterface* parent):
+ base_class(type, name, parent)
+{
+ // These will get overwritten if used but give them some initial value anyway.
+ m_geoModelTemperature = m_defaultTemperature;
+ m_geoModelBiasVoltage = m_defaultBiasVoltage;
+ m_geoModelDepletionVoltage = m_defaultDepletionVoltage;
+}
+
+// Initialize
+StatusCode FaserSCT_SiliconConditionsTool::initialize() {
+ ATH_MSG_DEBUG("FaserSCT_SiliconConditionsTool::initialize()");
+
+ if (m_checkGeoModel or m_forceUseGeoModel) {
+ m_useGeoModel = setConditionsFromGeoModel();
+ if (m_useGeoModel) {
+ ATH_MSG_INFO("Default conditions come from GeoModel.");
+ } else {
+ ATH_MSG_INFO("GeoModel requests to use Conditions DB.");
+ }
+ }
+ if (not m_useGeoModel) {
+ ATH_MSG_INFO("Will use temperature and voltages from this service (not from GeoModel).");
+
+ // Get from Conditions database. Register callback, etc.
+ if (m_useDB) {
+ ATH_CHECK(m_condKeyHV.initialize());
+ ATH_CHECK(m_condKeyTemp.initialize());
+ ATH_CHECK(detStore()->retrieve(m_sct_id, "FaserSCT_ID"));
+
+ ATH_MSG_INFO("SCTDCSSvc retrieved");
+ }
+ } else {
+ // Otherwise we use the GeoModel values
+ m_defaultTemperature = m_geoModelTemperature;
+ m_defaultBiasVoltage = m_geoModelBiasVoltage;
+ m_defaultDepletionVoltage = m_geoModelDepletionVoltage;
+ }
+ return StatusCode::SUCCESS;
+}
+
+// Finalize
+StatusCode FaserSCT_SiliconConditionsTool::finalize() {
+ ATH_MSG_DEBUG("FaserSCT_SiliconConditionsTool::finalize()");
+ return StatusCode::SUCCESS;
+}
+
+// Silicon temperature (by Identifier)
+float FaserSCT_SiliconConditionsTool::temperature(const Identifier& elementId) const {
+ const IdentifierHash elementHash{m_sct_id->wafer_hash(elementId)};
+ return temperature(elementHash);
+}
+
+// Silicon bias voltage (by Identifier)
+float FaserSCT_SiliconConditionsTool::biasVoltage(const Identifier& elementId) const {
+ const IdentifierHash elementHash{m_sct_id->wafer_hash(elementId)};
+ return biasVoltage(elementHash);
+}
+
+// Silicon depletion voltage (by Identifier)
+float FaserSCT_SiliconConditionsTool::depletionVoltage(const Identifier& /*elementId*/) const {
+ return m_defaultDepletionVoltage;
+}
+
+// Silicon temperature (by IdentifierHash)
+float FaserSCT_SiliconConditionsTool::temperature(const IdentifierHash& elementHash) const {
+ if (m_useDB and (not m_useGeoModel)) {
+ const FaserSCT_DCSFloatCondData* data{getCondDataTemp()};
+ if (data==nullptr) return m_defaultTemperature;
+ float temperature{m_defaultTemperature};
+ if (not data->getValue(elementHash, temperature)) return m_defaultTemperature;
+ if (temperature <= -30.){
+ ATH_MSG_DEBUG( "Sensor temperature: "<< temperature <<" < -30 ");
+ return m_defaultTemperature;
+ }
+ return temperature;
+ }
+ return m_defaultTemperature;
+}
+
+// Silicon bias voltage (by IdentifierHash)
+float FaserSCT_SiliconConditionsTool::biasVoltage(const IdentifierHash& elementHash) const {
+
+ if (m_useDB and (not m_useGeoModel)) {
+ const FaserSCT_DCSFloatCondData* data{getCondDataHV()};
+ if (data==nullptr) return m_defaultBiasVoltage;
+ float hv{m_defaultBiasVoltage};
+ if (not data->getValue(elementHash, hv)) return m_defaultBiasVoltage;
+ if (hv < 0.) {
+ ATH_MSG_DEBUG("HV: "<< hv <<" < 0 ");
+ return m_defaultBiasVoltage;
+ }
+ return hv;
+ }
+ return m_defaultBiasVoltage;
+}
+
+// Silicon deplition voltage (by IdentifierHash)
+float FaserSCT_SiliconConditionsTool::depletionVoltage(const IdentifierHash& /*elementHash*/) const {
+ return m_defaultDepletionVoltage;
+}
+
+bool
+FaserSCT_SiliconConditionsTool::setConditionsFromGeoModel()
+{
+ bool conditionsPresent{false};
+ bool useCondDB{false};
+
+ if (m_rdbSvc.retrieve().isFailure()) {
+ ATH_MSG_ERROR("Could not locate RDBAccessSvc");
+ return false;
+ }
+
+ if (m_geoModelSvc.retrieve().isFailure()) {
+ ATH_MSG_ERROR("Could not locate GeoModelSvc");
+ return false;
+ }
+ DecodeFaserVersionKey versionKey{&*m_geoModelSvc, "SCT"};
+ ATH_MSG_DEBUG("Checking GeoModel Version Tag: "<< versionKey.tag() << " at Node: " << versionKey.node());
+
+ IRDBRecordset_ptr sctConditionsSet{m_rdbSvc->getRecordsetPtr("SctConditions", versionKey.tag(), versionKey.node(), "FASERDD")};
+ if (sctConditionsSet->size()) {
+ ATH_MSG_DEBUG("Default conditions available from GeoModel.");
+ const IRDBRecord* defaultConditions{(*sctConditionsSet)[0]};
+ m_geoModelTemperature = defaultConditions->getDouble("TEMPERATURE");
+ m_geoModelBiasVoltage = defaultConditions->getDouble("BIASVOLT");
+ m_geoModelDepletionVoltage = defaultConditions->getDouble("DEPLETIONVOLT");
+ conditionsPresent = true;
+ // If m_forceUseGeoModel set then we ignore the USECONDDB column and
+ // keep useCondDB = false
+ if ((not m_forceUseGeoModel) and (not defaultConditions->isFieldNull("USECONDDB"))) { // USECONDDB Not present in old SCT tables
+ useCondDB = (defaultConditions->getInt("USECONDDB"));
+ }
+ } else {
+ ATH_MSG_WARNING("Default conditions NOT available in GeoModel database. Using old GeoModel defaults");
+ // These are pre DC3 geometries. Probably never will be used.
+ m_geoModelTemperature = -7;
+ m_geoModelBiasVoltage = 100;
+ m_geoModelDepletionVoltage = 20;
+ conditionsPresent = true;
+ }
+
+ return ((not useCondDB) and conditionsPresent);
+
+}
+
+const FaserSCT_DCSFloatCondData* FaserSCT_SiliconConditionsTool::getCondDataHV() const {
+ SG::ReadCondHandle<FaserSCT_DCSFloatCondData> condData{m_condKeyHV};
+ if (not condData.isValid()) {
+ ATH_MSG_ERROR("Failed to get " << m_condKeyHV.key());
+ return nullptr;
+ }
+ return *condData;
+}
+
+const FaserSCT_DCSFloatCondData* FaserSCT_SiliconConditionsTool::getCondDataTemp() const {
+ SG::ReadCondHandle<FaserSCT_DCSFloatCondData> condData{m_condKeyTemp};
+ if (not condData.isValid()) {
+ ATH_MSG_ERROR("Failed to get " << m_condKeyTemp.key());
+ return nullptr;
+ }
+ return *condData;
+}
diff --git a/Tracker/TrackerConditions/FaserSCT_ConditionsTools/src/FaserSCT_SiliconConditionsTool.h b/Tracker/TrackerConditions/FaserSCT_ConditionsTools/src/FaserSCT_SiliconConditionsTool.h
new file mode 100644
index 0000000000000000000000000000000000000000..91dd8de1afab1915363369d93a6911cb8060d418
--- /dev/null
+++ b/Tracker/TrackerConditions/FaserSCT_ConditionsTools/src/FaserSCT_SiliconConditionsTool.h
@@ -0,0 +1,91 @@
+// -*- C++ -*-
+
+/*
+ Copyright (C) 2002-2018 CERN for the benefit of the ATLAS collaboration
+*/
+
+/**
+ * @file FaserSCT_SiliconConditionsTool.h
+ *
+ * Header file for the FaserSCT_SiliconConditionsTool class which implements the ISiliconConditionsTool interface
+ *
+ * @author Carl Gwilliam <gwilliam@mail.cern.ch>
+ **/
+
+#ifndef FaserSCT_SiliconConditionsTool_h
+#define FaserSCT_SiliconConditionsTool_h
+
+#include "AthenaBaseComps/AthAlgTool.h"
+#include "GaudiKernel/ServiceHandle.h"
+#include "InDetConditionsSummaryService/ISiliconConditionsTool.h"
+
+#include "FaserSCT_ConditionsData/FaserSCT_DCSFloatCondData.h"
+#include "StoreGate/ReadCondHandleKey.h"
+#include "GeoModelInterfaces/IGeoModelSvc.h"
+#include "RDBAccessSvc/IRDBAccessSvc.h"
+
+class FaserSCT_ID;
+
+/**
+ * @class FaserSCT_SiliconConditionsTool
+ * Class for conditions data about the SCT silicon
+ * Allows one to obtain temperature and bias + depletion voltages
+ * These are currenlty static values but in future will be obtained for the DB
+ **/
+
+class FaserSCT_SiliconConditionsTool: public extends<AthAlgTool, ISiliconConditionsTool> {
+ public:
+
+ /** Constructor */
+ FaserSCT_SiliconConditionsTool(const std::string& type, const std::string& name, const IInterface* parent);
+ /** Destructor */
+ virtual ~FaserSCT_SiliconConditionsTool() = default;
+
+ /** Initialise */
+ virtual StatusCode initialize() override;
+ /** Finalise */
+ virtual StatusCode finalize() override;
+
+ /** Silicon temperature by Identifier */
+ virtual float temperature(const Identifier& elementId) const override;
+ /** Silicon bias voltage by Identifier */
+ virtual float biasVoltage(const Identifier& elementId) const override;
+ /** Silicon depletion voltage by Identifier */
+ virtual float depletionVoltage(const Identifier& elementId) const override;
+
+ /** Silicon temperature by IdentifierHash */
+ virtual float temperature(const IdentifierHash& elementHash) const override;
+ /** Silicon bias voltage by IdentifierHash */
+ virtual float biasVoltage(const IdentifierHash& elementHash) const override;
+ /** Silicon depletion voltage by IdentifierHash */
+ virtual float depletionVoltage(const IdentifierHash& elementHash) const override;
+
+ private:
+
+ bool setConditionsFromGeoModel();
+
+ FloatProperty m_defaultTemperature{this, "Temperature", 10., "Default temperature (non-DB)"};
+ FloatProperty m_defaultBiasVoltage{this, "BiasVoltage", 150., "Default bias voltage (non-DB)"};
+ FloatProperty m_defaultDepletionVoltage{this, "DepletionVoltage", 70., "Default depletion voltage (non-DB)"};
+ BooleanProperty m_useDB{this, "UseDB", true, "Whether to used the conditions DB or not"};
+ BooleanProperty m_checkGeoModel{this, "CheckGeoModel", true};
+ BooleanProperty m_forceUseGeoModel{this, "ForceUseGeoModel", false};
+
+ ServiceHandle<IGeoModelSvc> m_geoModelSvc{this, "GeoModelSvc", "GeoModelSvc"};
+ ServiceHandle<IRDBAccessSvc> m_rdbSvc{this, "RDBAccessSvc", "RDBAccessSvc"};
+
+ float m_geoModelTemperature;
+ float m_geoModelBiasVoltage;
+ float m_geoModelDepletionVoltage;
+ bool m_useGeoModel{false};
+
+ SG::ReadCondHandleKey<FaserSCT_DCSFloatCondData> m_condKeyHV{this, "CondKeyHV", "SCT_SiliconBiasVoltCondData", "SCT silicon bias voltage"};
+ SG::ReadCondHandleKey<FaserSCT_DCSFloatCondData> m_condKeyTemp{this, "CondKeyTemp", "SCT_SiliconTempCondData", "SCT silicon temperature"};
+
+ const FaserSCT_ID* m_sct_id{nullptr};
+
+ const FaserSCT_DCSFloatCondData* getCondDataHV() const;
+ const FaserSCT_DCSFloatCondData* getCondDataTemp() const;
+ };
+
+#endif // FaserSCT_SiliconConditionsTool_h
diff --git a/Tracker/TrackerConditions/FaserSCT_ConditionsTools/src/components/FaserSCT_ConditionsTools_entries.cxx b/Tracker/TrackerConditions/FaserSCT_ConditionsTools/src/components/FaserSCT_ConditionsTools_entries.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..5cf6ed934a7efda6c107717ff2eb41a70237fa8d
--- /dev/null
+++ b/Tracker/TrackerConditions/FaserSCT_ConditionsTools/src/components/FaserSCT_ConditionsTools_entries.cxx
@@ -0,0 +1,43 @@
+// #include "../SCT_ByteStreamErrorsTool.h"
+// #include "../SCT_ChargeTrappingTool.h"
+// #include "../SCT_ConditionsParameterTool.h"
+// #include "../SCT_ConditionsSummaryTool.h"
+// #include "../SCT_ConfigurationConditionsTool.h"
+#include "../FaserSCT_DCSConditionsTool.h"
+// #include "../SCT_ElectricFieldTool.h"
+// #include "../SCT_FlaggedConditionTool.h"
+// #include "../SCT_LinkMaskingTool.h"
+// #include "../SCT_MajorityConditionsTool.h"
+// #include "../SCT_ModuleVetoTool.h"
+// #include "../SCT_MonitorConditionsTool.h"
+// #include "../SCT_RadDamageSummaryTool.h"
+#include "../FaserSCT_ReadCalibChipDataTool.h"
+// #include "../SCT_ReadCalibDataTool.h"
+// #include "../SCT_ReadoutTool.h"
+// #include "../SCT_RODVetoTool.h"
+// #include "../SCT_SensorsTool.h"
+#include "../FaserSCT_SiliconConditionsTool.h"
+// #include "../SCT_StripVetoTool.h"
+// #include "../SCT_TdaqEnabledTool.h"
+
+// DECLARE_COMPONENT( SCT_ByteStreamErrorsTool )
+// DECLARE_COMPONENT( SCT_ChargeTrappingTool )
+// DECLARE_COMPONENT( SCT_ConditionsParameterTool )
+// DECLARE_COMPONENT( SCT_ConditionsSummaryTool )
+// DECLARE_COMPONENT( SCT_ConfigurationConditionsTool )
+DECLARE_COMPONENT( FaserSCT_DCSConditionsTool )
+// DECLARE_COMPONENT( SCT_ElectricFieldTool )
+// DECLARE_COMPONENT( SCT_FlaggedConditionTool )
+// DECLARE_COMPONENT( SCT_LinkMaskingTool )
+// DECLARE_COMPONENT( SCT_MajorityConditionsTool )
+// DECLARE_COMPONENT( SCT_ModuleVetoTool )
+// DECLARE_COMPONENT( SCT_MonitorConditionsTool )
+// DECLARE_COMPONENT( SCT_RadDamageSummaryTool )
+DECLARE_COMPONENT( FaserSCT_ReadCalibChipDataTool )
+// DECLARE_COMPONENT( SCT_ReadCalibDataTool )
+// DECLARE_COMPONENT( SCT_ReadoutTool )
+// DECLARE_COMPONENT( SCT_RODVetoTool )
+// DECLARE_COMPONENT( SCT_SensorsTool )
+DECLARE_COMPONENT( FaserSCT_SiliconConditionsTool )
+// DECLARE_COMPONENT( SCT_StripVetoTool )
+// DECLARE_COMPONENT( SCT_TdaqEnabledTool )
diff --git a/Tracker/TrackerConditions/FaserSiLorentzAngleTool/CMakeLists.txt b/Tracker/TrackerConditions/FaserSiLorentzAngleTool/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..5ce3bdfcd0e3eea4f718a62ad32455b764162278
--- /dev/null
+++ b/Tracker/TrackerConditions/FaserSiLorentzAngleTool/CMakeLists.txt
@@ -0,0 +1,50 @@
+################################################################################
+# Package: FaserSiLorentzAngleTool
+################################################################################
+
+# Declare the package name:
+atlas_subdir( FaserSiLorentzAngleTool )
+
+# Declare the package's dependencies:
+atlas_depends_on_subdirs( PUBLIC
+ Control/AthenaBaseComps
+ Control/AthenaKernel
+ Control/StoreGate
+ DetectorDescription/GeoPrimitives
+ GaudiKernel
+ InnerDetector/InDetConditions/InDetCondTools
+ Tracker/TrackerConditions/FaserSiPropertiesTool
+ Tracker/TrackerConditions/FaserSCT_ConditionsData
+ InnerDetector/InDetConditions/SiLorentzAngleTool
+ MagneticField/MagFieldInterfaces
+ PRIVATE
+ Database/AthenaPOOL/AthenaPoolUtilities
+ DetectorDescription/Identifier
+ InnerDetector/InDetConditions/InDetConditionsSummaryService
+ Tracker/TrackerDetDescr/TrackerIdentifier
+ Tracker/TrackerDetDescr/TrackerReadoutGeometry )
+
+# External dependencies:
+find_package( Eigen )
+
+# Component(s) in the package:
+atlas_add_component( FaserSiLorentzAngleTool
+ src/*.cxx
+ src/components/*.cxx
+ INCLUDE_DIRS ${EIGEN_INCLUDE_DIRS}
+ LINK_LIBRARIES ${EIGEN_LIBRARIES} AthenaBaseComps AthenaKernel StoreGateLib SGtests GeoPrimitives GaudiKernel FaserSiPropertiesToolLib MagFieldInterfaces AthenaPoolUtilities Identifier TrackerIdentifier TrackerReadoutGeometry )
+
+# Run tests:
+#atlas_add_test( TestSCTLorentzAngle
+# SCRIPT athena.py --threads=5 SiLorentzAngleTool/testSCTLorentzAngle.py
+# PROPERTIES TIMEOUT 300
+# ENVIRONMENT THREADS=5 )
+
+#atlas_add_test( SiLorentzAngleConfig_test
+# SCRIPT test/SiLorentzAngleConfig_test.py
+# PROPERTIES TIMEOUT 30 )
+
+# Install files from the package:
+#atlas_install_headers( FaserSiLorentzAngleTool )
+atlas_install_python_modules( python/*.py )
+atlas_install_joboptions( share/*.py )
diff --git a/Tracker/TrackerConditions/FaserSiLorentzAngleTool/FaserSiLorentzAngleTool/ATLAS_CHECK_THREAD_SAFETY b/Tracker/TrackerConditions/FaserSiLorentzAngleTool/FaserSiLorentzAngleTool/ATLAS_CHECK_THREAD_SAFETY
new file mode 100644
index 0000000000000000000000000000000000000000..f44995170ec20c303bc14d8a78357aaf2cb762cf
--- /dev/null
+++ b/Tracker/TrackerConditions/FaserSiLorentzAngleTool/FaserSiLorentzAngleTool/ATLAS_CHECK_THREAD_SAFETY
@@ -0,0 +1 @@
+Tracker/TrackerConditions/FaserSiLorentzAngleTool
\ No newline at end of file
diff --git a/Tracker/TrackerConditions/FaserSiLorentzAngleTool/FaserSiLorentzAngleTool/FaserSiLorentzAngleCondData.h b/Tracker/TrackerConditions/FaserSiLorentzAngleTool/FaserSiLorentzAngleTool/FaserSiLorentzAngleCondData.h
new file mode 100644
index 0000000000000000000000000000000000000000..bd1725729117b9282962eb390cb044c4d196f315
--- /dev/null
+++ b/Tracker/TrackerConditions/FaserSiLorentzAngleTool/FaserSiLorentzAngleTool/FaserSiLorentzAngleCondData.h
@@ -0,0 +1,106 @@
+/*
+ Copyright (C) 2002-2018 CERN for the benefit of the ATLAS collaboration
+*/
+
+/**
+ * @file FaserSiLorentzAngleCondData.h
+ * @author Susumu.Oda@cern.ch
+**/
+#ifndef FaserSiLorentzAngleCondData_h
+#define FaserSiLorentzAngleCondData_h
+
+#include <vector>
+#include "AthenaKernel/CLASS_DEF.h"
+#include "Identifier/IdentifierHash.h"
+
+/**
+ * @class FaserSiLorentzAngleCondData
+ * Concrete class for Lorentz angle conditions data
+ * for each detector element.
+**/
+
+class FaserSiLorentzAngleCondData {
+public:
+ // Constructor
+ FaserSiLorentzAngleCondData();
+ // Destructor
+ virtual ~FaserSiLorentzAngleCondData() = default;
+
+ /** Reszie the data members */
+ void resize(const unsigned int size);
+
+ /** Get the Lorentz shift correction in the local x (phiDist) direction
+ Assumes the center of the detector and is generally cached. */
+ double getLorentzShift(const IdentifierHash& elementHash) const;
+
+ /** Get the Lorentz shift correction in the local y (etaDist) direction
+ Assumes the center of the detector and is generally cached. */
+ double getLorentzShiftEta(const IdentifierHash& elementHash) const;
+
+ /** Get tan af the Lorentz angle in the local x (phiDist) direction
+ Assumes the center of the detector and is generally cached. */
+ double getTanLorentzAngle(const IdentifierHash& elementHash) const;
+
+ /** Get tan af the Lorentz angle in the local y (etaDist) direction
+ Assumes the center of the detector and is generally cached. */
+ double getTanLorentzAngleEta(const IdentifierHash& elementHash) const;
+
+ /** Get bias voltage */
+ double getBiasVoltage(const IdentifierHash& elementHash) const;
+
+ /** Get temperature */
+ double getTemperature(const IdentifierHash& elementHash) const;
+
+ /** Get depletion voltage */
+ double getDepletionVoltage(const IdentifierHash& elementHash) const;
+
+ /** Get correction factor */
+ double getCorrectionFactor() const;
+
+ /** Set the Lorentz shift correction in the local x (phiDist) direction
+ Assumes the center of the detector and is generally cached. */
+ void setLorentzShift(const IdentifierHash& elementHash, const double lorentzShift);
+
+ /** Set the Lorentz shift correction in the local y (etaDist) direction
+ Assumes the center of the detector and is generally cached. */
+ void setLorentzShiftEta(const IdentifierHash& elementHash, const double lorentzShiftEta);
+
+ /** Set tan af the Lorentz angle in the local x (phiDist) direction
+ Assumes the center of the detector and is generally cached. */
+ void setTanLorentzAngle(const IdentifierHash& elementHash, const double tanLorentzAngle);
+
+ /** Set tan af the Lorentz angle in the local y (etaDist) direction
+ Assumes the center of the detector and is generally cached. */
+ void setTanLorentzAngleEta(const IdentifierHash& elementHash, const double tanLorentzAngleEta);
+
+ /** Set bias voltage */
+ void setBiasVoltage(const IdentifierHash& elementHash, const double biasVoltage);
+
+ /** Set temperature */
+ void setTemperature(const IdentifierHash& elementHash, const double temperature);
+
+ /** Set depletion voltage */
+ void setDepletionVoltage(const IdentifierHash& elementHash, const double depletionVoltage);
+
+ /** Set correction factor */
+ void setCorrectionFactor(const double correctionFactor);
+
+private:
+ std::vector<double> m_lorentzShift;
+ std::vector<double> m_lorentzShiftEta;
+ std::vector<double> m_tanLorentzAngle;
+ std::vector<double> m_tanLorentzAngleEta;
+ std::vector<double> m_monitorBiasVoltage;
+ std::vector<double> m_monitorTemperature;
+ std::vector<double> m_monitorDepletionVoltage;
+ double m_correctionFactor;
+
+ static const double s_invalidValue;
+};
+
+CLASS_DEF(FaserSiLorentzAngleCondData, 16377661, 1)
+
+#include "AthenaKernel/CondCont.h"
+CONDCONT_DEF(FaserSiLorentzAngleCondData, 60915253);
+
+#endif // FaserSiLorentzAngleCondData_h
diff --git a/Tracker/TrackerConditions/FaserSiLorentzAngleTool/python/FaserSCT_LorentzAngleConfig.py b/Tracker/TrackerConditions/FaserSiLorentzAngleTool/python/FaserSCT_LorentzAngleConfig.py
new file mode 100644
index 0000000000000000000000000000000000000000..69fd84e59f1276ae1c6b63145af4f647d032593f
--- /dev/null
+++ b/Tracker/TrackerConditions/FaserSiLorentzAngleTool/python/FaserSCT_LorentzAngleConfig.py
@@ -0,0 +1,52 @@
+"""Define methods to configure FaserSCTLorentzAngleTool
+
+Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+"""
+from AthenaCommon import Logging
+from AthenaConfiguration.ComponentFactory import CompFactory
+FaserSiLorentzAngleTool=CompFactory.FaserSiLorentzAngleTool
+FaserSCT_SiLorentzAngleCondAlg=CompFactory.FaserSCT_SiLorentzAngleCondAlg
+from FaserSCT_ConditionsTools.FaserSCT_DCSConditionsConfig import FaserSCT_DCSConditionsCfg
+from FaserSCT_ConditionsTools.FaserSCT_SiliconConditionsConfig import FaserSCT_SiliconConditionsCfg
+from MagFieldServices.MagFieldServicesConfig import MagneticFieldSvcCfg
+
+def FaserSCT_LorentzAngleToolCfg(flags, name="FaserSCT_LorentzAngleTool", **kwargs):
+ """Return a SiLorentzAngleTool configured for FaserSCT"""
+ kwargs.setdefault("DetectorName", "SCT")
+ kwargs.setdefault("SiLorentzAngleCondData", "SCTSiLorentzAngleCondData")
+ kwargs.setdefault("UseMagFieldSvc", True)
+ return FaserSiLorentzAngleTool(name, **kwargs)
+
+def FaserSCT_LorentzAngleCfg(flags, name="FaserSCT_SiLorentzAngleCondAlg",
+ forceUseDB=False, forceUseGeoModel=False, **kwargs):
+ """Return configured ComponentAccumulator and tool for FaserSCT_LorentzAngle
+
+ SiLorentzAngleTool may be provided in kwargs
+ """
+ if forceUseDB and forceUseGeoModel:
+ msg = Logging.logging.getLogger("FaserSCT_LorentzAngleCfg")
+ msg.error("Setting is wrong: both forceUseDB and forceUseGeoModel cannot be True at the same time")
+ # construct with field services
+ acc = MagneticFieldSvcCfg(flags)
+ tool = kwargs.get("SiLorentzAngleTool", FaserSCT_LorentzAngleToolCfg(flags))
+ if not forceUseGeoModel:
+ DCSkwargs = {}
+ # For HLT
+ if flags.Common.isOnline and not flags.Input.isMC:
+ dcs_folder = "/SCT/HLT/DCS"
+ DCSkwargs["dbInstance"] = "SCT"
+ DCSkwargs["hvFolder"] = dcs_folder + "/HV"
+ DCSkwargs["tempFolder"] = dcs_folder + "/MODTEMP"
+ DCSkwargs["stateFolder"] = dcs_folder + "/CHANSTAT"
+ DCSAcc = FaserSCT_DCSConditionsCfg(flags, **DCSkwargs)
+ SCAcc = FaserSCT_SiliconConditionsCfg(flags, DCSConditionsTool=DCSAcc.popPrivateTools())
+ acc.merge(DCSAcc)
+ acc.merge(SCAcc)
+ # set up FaserSCT_SiLorentzAngleCondAlg
+ kwargs.setdefault("UseMagFieldSvc", tool.UseMagFieldSvc)
+ kwargs.setdefault("UseMagFieldDcs", not flags.Common.isOnline)
+ kwargs.setdefault("UseGeoModel", forceUseGeoModel)
+ kwargs.setdefault("useSctDefaults", False)
+ acc.addCondAlgo(FaserSCT_SiLorentzAngleCondAlg(name, **kwargs))
+ acc.setPrivateTools(tool)
+ return acc
diff --git a/Tracker/TrackerConditions/FaserSiLorentzAngleTool/src/FaserSCT_SiLorentzAngleCondAlg.cxx b/Tracker/TrackerConditions/FaserSiLorentzAngleTool/src/FaserSCT_SiLorentzAngleCondAlg.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..6328ed948c1f3a346f04497ae9db886de5546378
--- /dev/null
+++ b/Tracker/TrackerConditions/FaserSiLorentzAngleTool/src/FaserSCT_SiLorentzAngleCondAlg.cxx
@@ -0,0 +1,309 @@
+/*
+ Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+*/
+
+/**
+ * @file SCTSiLorentzAngleCondAlg.cxx
+ * @author Susumu.Oda@cern.ch
+ **/
+
+// Local include
+#include "FaserSCT_SiLorentzAngleCondAlg.h"
+
+// Athena includes
+#include "TrackerIdentifier/FaserSCT_ID.h"
+#include "TrackerReadoutGeometry/SiDetectorElement.h"
+#include "MagFieldInterfaces/IMagFieldSvc.h"
+#include "FaserSiPropertiesTool/FaserSiliconProperties.h"
+
+// Gaudi include
+#include "GaudiKernel/PhysicalConstants.h"
+
+// STL include
+
+FaserSCT_SiLorentzAngleCondAlg::FaserSCT_SiLorentzAngleCondAlg(const std::string& name, ISvcLocator* pSvcLocator):
+ ::AthReentrantAlgorithm(name, pSvcLocator),
+ m_condSvc{"CondSvc", name},
+ m_magFieldSvc{"FaserFieldSvc", name},
+ m_maxHash{0}
+{
+ declareProperty("MagFieldSvc", m_magFieldSvc);
+}
+
+StatusCode FaserSCT_SiLorentzAngleCondAlg::initialize()
+{
+ if (m_siConditionsTool.empty()) m_sctDefaults.setValue(true);
+
+ if (not m_sctDefaults.value()) {
+ // FaserSCT_SiliconConditionsTool
+ ATH_CHECK(m_siConditionsTool.retrieve());
+ // Read Cond handle
+ if (not m_useGeoModel.value()) {
+ ATH_CHECK(m_readKeyTemp.initialize());
+ ATH_CHECK(m_readKeyHV.initialize());
+ }
+ } else {
+ m_siConditionsTool.disable();
+ }
+
+ if (m_useMagFieldSvc.value()) {
+ // MagFieldSvc
+ ATH_CHECK(m_magFieldSvc.retrieve());
+ // Read Cond handle
+ if (m_useMagFieldDcs.value()) {
+ ATH_CHECK(m_readKeyBFieldSensor.initialize());
+ }
+ else {
+ ATH_CHECK(m_readKeyBFieldSensor.initialize(false));
+ }
+ }
+
+ ATH_CHECK(m_SCTDetEleCollKey.initialize());
+
+ // Write Cond Handle
+ ATH_CHECK(m_condSvc.retrieve());
+ ATH_CHECK(m_writeKey.initialize());
+ if (m_condSvc->regHandle(this, m_writeKey).isFailure()) {
+ ATH_MSG_FATAL("unable to register WriteCondHandle " << m_writeKey.fullKey() << " with CondSvc");
+ return StatusCode::FAILURE;
+ }
+
+ // Get maximum hash for vector sizes. We need the idhelper for this.
+ const FaserSCT_ID* idHelper{nullptr};
+ ATH_CHECK(detStore()->retrieve(idHelper, "FaserSCT_ID"));
+ m_maxHash = idHelper->wafer_hash_max();
+
+ return StatusCode::SUCCESS;
+}
+
+StatusCode FaserSCT_SiLorentzAngleCondAlg::execute(const EventContext& ctx) const
+{
+ // Write Cond Handle
+ SG::WriteCondHandle<FaserSiLorentzAngleCondData> writeHandle{m_writeKey, ctx};
+ // Do we have a valid Write Cond Handle for current time?
+ 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;
+ }
+
+ EventIDBase eidStart;
+ eidStart.set_time_stamp(0);
+ eidStart.set_time_stamp_ns_offset(0);
+ EventIDBase eidStop;
+ eidStop.set_time_stamp(EventIDBase::UNDEFNUM);
+ eidStop.set_time_stamp_ns_offset(EventIDBase::UNDEFNUM);
+ EventIDRange rangeSCT{eidStart, eidStop};
+ EventIDRange rangeBField{eidStart, eidStop};
+
+ // Get SCT_DetectorElementCollection
+ SG::ReadCondHandle<TrackerDD::SiDetectorElementCollection> sctDetEle(m_SCTDetEleCollKey, ctx);
+ const TrackerDD::SiDetectorElementCollection* elements(sctDetEle.retrieve());
+ if (elements==nullptr) {
+ ATH_MSG_FATAL(m_SCTDetEleCollKey.fullKey() << " could not be retrieved");
+ return StatusCode::FAILURE;
+ }
+ EventIDRange rangeDetEle; // Run-LB IOV
+ if (not sctDetEle.range(rangeDetEle)) {
+ ATH_MSG_FATAL("Failed to retrieve validity range for " << m_SCTDetEleCollKey.key());
+ return StatusCode::FAILURE;
+ }
+
+ bool validSCT{false};
+ if ((not m_sctDefaults.value()) and (not m_useGeoModel.value())) {
+ // Read Cond Handle (temperature)
+ SG::ReadCondHandle<FaserSCT_DCSFloatCondData> readHandleTemp{m_readKeyTemp, ctx};
+ const FaserSCT_DCSFloatCondData* readCdoTemp{*readHandleTemp};
+ if (readCdoTemp==nullptr) {
+ ATH_MSG_FATAL("Null pointer to the read conditions object");
+ return StatusCode::FAILURE;
+ }
+ EventIDRange rangeTemp;
+ if (not readHandleTemp.range(rangeTemp)) {
+ ATH_MSG_FATAL("Failed to retrieve validity range for " << readHandleTemp.key());
+ return StatusCode::FAILURE;
+ }
+ ATH_MSG_INFO("Input is " << readHandleTemp.fullKey() << " with the range of " << rangeTemp);
+
+ // Read Cond Handle (HV)
+ SG::ReadCondHandle<FaserSCT_DCSFloatCondData> readHandleHV{m_readKeyHV, ctx};
+ const FaserSCT_DCSFloatCondData* readCdoHV{*readHandleHV};
+ if (readCdoHV==nullptr) {
+ ATH_MSG_FATAL("Null pointer to the read conditions object");
+ return StatusCode::FAILURE;
+ }
+ EventIDRange rangeHV;
+ if (not readHandleHV.range(rangeHV)) {
+ ATH_MSG_FATAL("Failed to retrieve validity range for " << readHandleHV.key());
+ return StatusCode::FAILURE;
+ }
+ ATH_MSG_INFO("Input is " << readHandleHV.fullKey() << " with the range of " << rangeHV);
+
+ // Combined the validity ranges of temp and HV
+ rangeSCT = EventIDRange::intersect(rangeTemp, rangeHV);
+ if (rangeSCT.stop().isValid() and rangeSCT.start()>rangeSCT.stop()) {
+ ATH_MSG_FATAL("Invalid intersection rangeSCT: " << rangeSCT);
+ return StatusCode::FAILURE;
+ }
+ validSCT = true;
+ }
+
+ bool validBField{false};
+ if (m_useMagFieldSvc.value()) {
+ if (m_useMagFieldDcs.value()) {
+ // Read Cond Handle (B field sensor)
+ SG::ReadCondHandle<CondAttrListCollection> readHandleBFieldSensor{m_readKeyBFieldSensor, ctx};
+ const CondAttrListCollection* readCdoBFieldSensor{*readHandleBFieldSensor};
+ if (readCdoBFieldSensor==nullptr) {
+ ATH_MSG_FATAL("Null pointer to the read conditions object");
+ return StatusCode::FAILURE;
+ }
+ EventIDRange rangeBFieldSensor;
+ if (not readHandleBFieldSensor.range(rangeBFieldSensor)) {
+ ATH_MSG_FATAL("Failed to retrieve validity range for " << readHandleBFieldSensor.key());
+ return StatusCode::FAILURE;
+ }
+ ATH_MSG_INFO("Input is " << readHandleBFieldSensor.fullKey() << " with the range of " << rangeBFieldSensor);
+
+ // Set the validity ranges of sensor
+ rangeBField = rangeBFieldSensor;
+ if (rangeBField.stop().isValid() and rangeBField.start()>rangeBField.stop()) {
+ ATH_MSG_FATAL("Invalid intersection rangeBField: " << rangeBField);
+ return StatusCode::FAILURE;
+ }
+ validBField = true;
+ }
+ }
+
+ // Combined the validity ranges of temp and HV
+ EventIDRange rangeW{rangeBField};
+ if (validSCT) {
+ if (validBField) rangeW = EventIDRange::intersect(rangeSCT, rangeBField);
+ else rangeW = rangeSCT;
+ }
+ if (rangeW.stop().isValid() and rangeW.start()>rangeW.stop()) {
+ ATH_MSG_FATAL("Invalid intersection rangeW: " << rangeW);
+ return StatusCode::FAILURE;
+ }
+
+ // Construct the output Cond Object and fill it in
+ std::unique_ptr<FaserSiLorentzAngleCondData> writeCdo{std::make_unique<FaserSiLorentzAngleCondData>()};
+ writeCdo->resize(m_maxHash);
+ // FaserSiLorentzAngleCondData myData;
+
+ for (unsigned int hash{0}; hash<m_maxHash; hash++) {
+ const IdentifierHash elementHash{hash};
+
+ double temperatureC{0.0};
+ double deplVoltage{0.0};
+ double biasVoltage{0.0};
+
+ if (m_sctDefaults.value()) {
+ temperatureC = m_temperature.value();
+ deplVoltage = m_deplVoltage.value() * CLHEP::volt;
+ biasVoltage = m_biasVoltage.value() * CLHEP::volt;
+ } else {
+ temperatureC = m_siConditionsTool->temperature(elementHash);
+ deplVoltage = m_siConditionsTool->depletionVoltage(elementHash) * CLHEP::volt;
+ biasVoltage = m_siConditionsTool->biasVoltage(elementHash) * CLHEP::volt;
+ ATH_MSG_DEBUG("SCT Hash = " << elementHash << " Temperature = " << temperatureC << " [deg C], BiasV = " << biasVoltage << " DeplV = " << deplVoltage);
+ }
+
+ // Protect against invalid temperature
+ if (not ((temperatureC>m_temperatureMin) and (temperatureC<m_temperatureMax))) {
+ temperatureC = m_temperature.value();
+ ATH_MSG_DEBUG("Invalid temperature: " << temperatureC << " C. " << "Setting to " << m_temperature.value() << " C. " << "Detector element hash: " << elementHash);
+ }
+ double temperature{temperatureC + Gaudi::Units::STP_Temperature}; // C -> K
+
+ // Calculate depletion depth. If biasVoltage is less than depletionVoltage
+ // the detector is not fully depleted and we need to take this into account.
+ // We take absolute values just in case voltages are signed.
+ const TrackerDD::SiDetectorElement* element{elements->getDetectorElement(elementHash)};
+ double depletionDepth{element->thickness()};
+ if (deplVoltage==0.0) {
+ ATH_MSG_WARNING("Depletion voltage in "<<__FILE__<<" is zero, which might be a bug.");
+ }
+ if (std::abs(biasVoltage) < std::abs(deplVoltage)) {
+ depletionDepth *= sqrt(std::abs(biasVoltage / deplVoltage));
+ }
+
+ double meanElectricField{0.};
+ if (depletionDepth>0.) {
+ meanElectricField = biasVoltage / depletionDepth;
+ }
+ Tracker::FaserSiliconProperties siProperties;
+ siProperties.setConditions(temperature, meanElectricField);
+ double mobility{siProperties.signedHallMobility(element->carrierType())};
+
+ // Get magnetic field. This first checks that field cache is valid.
+ Amg::Vector3D magneticField{getMagneticField(element)};
+
+ // The angles are in the hit frame. This is because that is what is needed by the digization and also
+ // gives a more physical sign of the angle (ie dosen't flip sign when the detector is flipped).
+ // The hit depth axis is pointing from the readout side to the backside if m_design->readoutSide() < 0
+ // The hit depth axis is pointing from the backside to the readout side if m_design->readoutSide() > 0
+ double tanLorentzAnglePhi{element->design().readoutSide() * mobility * element->hitDepthDirection()
+ * element->hitPhiDirection() * (element->normal().cross(magneticField)).dot(element->phiAxis())};
+ writeCdo->setTanLorentzAngle(elementHash, tanLorentzAnglePhi);
+
+ // This gives the effective correction in the reconstruction frame hence the extra hitPhiDirection()
+ // as the angle above is in the hit frame.
+ double lorentzCorrectionPhi{-0.5 * element->hitPhiDirection() * tanLorentzAnglePhi * depletionDepth};
+ writeCdo->setLorentzShift(elementHash, lorentzCorrectionPhi);
+
+ // The Lorentz eta shift very small and so can be ignored, but we include it for completeness.
+ // In the SCT its largest in the stereo side of the barrel modules where it is about 0.3 micron along the strip.
+ double tanLorentzAngleEta{element->design().readoutSide() * mobility * element->hitDepthDirection()
+ * element->hitEtaDirection() * (element->normal().cross(magneticField)).dot(element->etaAxis())};
+ writeCdo->setTanLorentzAngleEta(elementHash, tanLorentzAngleEta);
+ double lorentzCorrectionEta{-0.5 * element->hitPhiDirection() * tanLorentzAngleEta * depletionDepth};
+ writeCdo->setLorentzShiftEta(elementHash, lorentzCorrectionEta);
+
+ // Monitoring value
+ writeCdo->setBiasVoltage(elementHash, biasVoltage/CLHEP::volt);
+ writeCdo->setTemperature(elementHash, temperatureC);
+ writeCdo->setDepletionVoltage(elementHash, deplVoltage/CLHEP::volt);
+
+ ATH_MSG_DEBUG("Hash = " << elementHash << " tanPhi = " << lorentzCorrectionPhi << " shiftPhi = " << writeCdo->getLorentzShift(elementHash) << "Depletion depth = " << depletionDepth);
+ ATH_MSG_VERBOSE("Temperature (C), bias voltage, depletion voltage: " << temperatureC << ", " << biasVoltage/CLHEP::volt << ", " << deplVoltage/CLHEP::volt);
+ ATH_MSG_VERBOSE("Depletion depth: " << depletionDepth/CLHEP::mm);
+ ATH_MSG_VERBOSE("Mobility (cm2/V/s): " << mobility/(CLHEP::cm2/CLHEP::volt/CLHEP::s));
+ ATH_MSG_VERBOSE("Magnetic Field (tesla): " << "(" << magneticField.x()/CLHEP::tesla << "," << magneticField.y()/CLHEP::tesla << "," << magneticField.z()/CLHEP::tesla << ")");
+ ATH_MSG_VERBOSE("LorentzShift, tanLorentzAngle = " << writeCdo->getLorentzShift(elementHash) << ", " << writeCdo->getTanLorentzAngle(elementHash));
+ ATH_MSG_VERBOSE("LorentzShiftEta, tanLorentzAngleEta = " << writeCdo->getLorentzShiftEta(elementHash) << ", " << writeCdo->getTanLorentzAngleEta(elementHash));
+ }
+
+ // Record the output cond object
+ if (writeHandle.record(rangeW, std::move(writeCdo)).isFailure()) {
+ ATH_MSG_FATAL("Could not record FaserSiLorentzAngleCondData " << writeHandle.key()
+ << " with EventRange " << rangeW << " into Conditions Store");
+ return StatusCode::FAILURE;
+ }
+ ATH_MSG_INFO("recorded new CDO " << writeHandle.key() << " with range " << rangeW << " into Conditions Store");
+
+ return StatusCode::SUCCESS;
+}
+
+StatusCode FaserSCT_SiLorentzAngleCondAlg::finalize()
+{
+ return StatusCode::SUCCESS;
+}
+
+Amg::Vector3D FaserSCT_SiLorentzAngleCondAlg::getMagneticField(const TrackerDD::SiDetectorElement* element) const {
+ if (m_useMagFieldSvc.value()) {
+ Amg::Vector3D pointvec{element->center()};
+ ATH_MSG_VERBOSE("Getting magnetic field from magnetic field service.");
+ double point[3];
+ point[0] = pointvec[0];
+ point[1] = pointvec[1];
+ point[2] = pointvec[2];
+ double field[3];
+ m_magFieldSvc->getField(point, field);
+ return Amg::Vector3D(field[0], field[1], field[2]);
+ } else {
+ ATH_MSG_VERBOSE("Using Nominal Field");
+ return Amg::Vector3D(0., 0., m_nominalField);
+ }
+}
diff --git a/Tracker/TrackerConditions/FaserSiLorentzAngleTool/src/FaserSCT_SiLorentzAngleCondAlg.h b/Tracker/TrackerConditions/FaserSiLorentzAngleTool/src/FaserSCT_SiLorentzAngleCondAlg.h
new file mode 100644
index 0000000000000000000000000000000000000000..362edc6f5e87785e41c44b1e0b08a6870072e3e8
--- /dev/null
+++ b/Tracker/TrackerConditions/FaserSiLorentzAngleTool/src/FaserSCT_SiLorentzAngleCondAlg.h
@@ -0,0 +1,83 @@
+/*
+ Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+*/
+
+/**
+ * @file FaserSCT_SiLorentzAngleCondAlg.h
+ * @author Susumu.Oda@cern.ch
+ **/
+#ifndef FaserSCTSiLorentzAngleCondAlg_h
+#define FaserSCTSiLorentzAngleCondAlg_h
+
+// Athena includes
+#include "AthenaBaseComps/AthReentrantAlgorithm.h"
+
+#include "AthenaPoolUtilities/CondAttrListCollection.h"
+#include "GeoPrimitives/GeoPrimitives.h"
+#include "InDetConditionsSummaryService/ISiliconConditionsTool.h"
+#include "TrackerReadoutGeometry/SiDetectorElementCollection.h"
+#include "FaserSCT_ConditionsData/FaserSCT_DCSFloatCondData.h"
+#include "FaserSiLorentzAngleTool/FaserSiLorentzAngleCondData.h"
+#include "StoreGate/ReadCondHandleKey.h"
+#include "StoreGate/WriteCondHandleKey.h"
+
+// Gaudi includes
+#include "GaudiKernel/ICondSvc.h"
+#include "GaudiKernel/ServiceHandle.h"
+#include "GaudiKernel/SystemOfUnits.h"
+#include "GaudiKernel/ToolHandle.h"
+
+// forward declarations
+// namespace MagField {
+// class IMagFieldSvc;
+// }
+#include "MagFieldInterfaces/IMagFieldSvc.h"
+
+/**
+ * @class FaserSCTSiLorentzAngleCondAlg
+ * This class prepares SiLorentAngleCondData using FaserSCT_SiliconConditionsTool
+ **/
+
+class FaserSCT_SiLorentzAngleCondAlg: public AthReentrantAlgorithm
+{
+ public:
+ FaserSCT_SiLorentzAngleCondAlg(const std::string& name, ISvcLocator* pSvcLocator);
+ virtual ~FaserSCT_SiLorentzAngleCondAlg() = default;
+ virtual StatusCode initialize() override;
+ virtual StatusCode execute(const EventContext& ctx) const override;
+ virtual StatusCode finalize() override;
+ /** Make this algorithm clonable. */
+ virtual bool isClonable() const override { return true; };
+
+ private:
+ SG::ReadCondHandleKey<FaserSCT_DCSFloatCondData> m_readKeyTemp{this, "ReadKeyTemp", "SCT_SiliconTempCondData", "Key of input SCT temperature"};
+ SG::ReadCondHandleKey<FaserSCT_DCSFloatCondData> m_readKeyHV{this, "ReadKeyHV", "SCT_SiliconBiasVoltCondData", "Key of input SCT HV"};
+ SG::ReadCondHandleKey<CondAttrListCollection> m_readKeyBFieldSensor{this, "ReadKeyBFieldSensor", "/EXT/DCS/MAGNETS/SENSORDATA", "Key of input B-field sensor"};
+ // The /GLOBAL/BField/Maps folder is run-lumi folder and has just one IOV. The folder is not used for IOV determination.
+ SG::ReadCondHandleKey<TrackerDD::SiDetectorElementCollection> m_SCTDetEleCollKey{this, "SCTDetEleCollKey", "SCT_DetectorElementCollection", "Key of SiDetectorElementCollection for SCT"};
+ SG::WriteCondHandleKey<FaserSiLorentzAngleCondData> m_writeKey{this, "WriteKey", "SCTSiLorentzAngleCondData", "Key of output SiLorentzAngleCondData"};
+
+ // needed services
+ ServiceHandle<ICondSvc> m_condSvc;
+ ServiceHandle<MagField::IMagFieldSvc> m_magFieldSvc;
+
+ ToolHandle<ISiliconConditionsTool> m_siConditionsTool{this, "SiConditionsTool", "FaserSCT_SiliconConditionsTool", "Tool to retrieve SCT silicon information"};
+
+ // Properties
+ // YOU NEED TO USE THE SAME PROPERTIES AS USED IN SCTLorentzAngleTool!!!
+ DoubleProperty m_temperature{this, "Temperature", -7., "Default temperature in Celcius."};
+ DoubleProperty m_temperatureMin{this, "TemperatureMin", -80., "Minimum temperature allowed in Celcius."};
+ DoubleProperty m_temperatureMax{this, "TemperatureMax", 100., "Maximum temperature allowed in Celcius."};
+ DoubleProperty m_deplVoltage{this, "DepletionVoltage", 70., "Default depletion voltage in Volt."};
+ DoubleProperty m_biasVoltage{this, "BiasVoltage", 150., "Default bias voltage in Volt."};
+ DoubleProperty m_nominalField{this, "NominalField", 2.0834*Gaudi::Units::tesla};
+ BooleanProperty m_useMagFieldSvc{this, "UseMagFieldSvc", true};
+ BooleanProperty m_useMagFieldDcs{this, "UseMagFieldDcs", true};
+ BooleanProperty m_sctDefaults{this, "useSctDefaults", false};
+ BooleanProperty m_useGeoModel{this, "UseGeoModel", false};
+ unsigned int m_maxHash;
+
+ Amg::Vector3D getMagneticField(const TrackerDD::SiDetectorElement* element) const;
+};
+
+#endif // FaserSCTSiLorentzAngleCondAlg_h
diff --git a/Tracker/TrackerConditions/FaserSiLorentzAngleTool/src/FaserSiLorentzAngleCondData.cxx b/Tracker/TrackerConditions/FaserSiLorentzAngleTool/src/FaserSiLorentzAngleCondData.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..eda5831ac718c8a7e6a5078fd248c98c0af4d117
--- /dev/null
+++ b/Tracker/TrackerConditions/FaserSiLorentzAngleTool/src/FaserSiLorentzAngleCondData.cxx
@@ -0,0 +1,131 @@
+/*
+ Copyright (C) 2002-2018 CERN for the benefit of the ATLAS collaboration
+*/
+
+/**
+ * @file FaserSiLorentzAngleCondData.cxx
+ * @author Susumu.Oda@cern.ch
+**/
+
+#include "FaserSiLorentzAngleTool/FaserSiLorentzAngleCondData.h"
+
+#include <limits>
+
+const double FaserSiLorentzAngleCondData::s_invalidValue{std::numeric_limits<double>::quiet_NaN()};
+
+FaserSiLorentzAngleCondData::FaserSiLorentzAngleCondData():
+ m_lorentzShift{},
+ m_lorentzShiftEta{},
+ m_tanLorentzAngle{},
+ m_tanLorentzAngleEta{},
+ m_monitorBiasVoltage{},
+ m_monitorTemperature{},
+ m_monitorDepletionVoltage{},
+ m_correctionFactor{1.}
+{
+}
+
+void FaserSiLorentzAngleCondData::resize(const unsigned int size)
+{
+ m_lorentzShift.resize(size, s_invalidValue);
+ m_lorentzShiftEta.resize(size, s_invalidValue);
+ m_tanLorentzAngle.resize(size, s_invalidValue);
+ m_tanLorentzAngleEta.resize(size, s_invalidValue);
+ m_monitorBiasVoltage.resize(size, s_invalidValue);
+ m_monitorTemperature.resize(size, s_invalidValue);
+ m_monitorDepletionVoltage.resize(size, s_invalidValue);
+}
+
+double FaserSiLorentzAngleCondData::getLorentzShift(const IdentifierHash& elementHash) const
+{
+ if (m_lorentzShift.size()<=elementHash) return s_invalidValue;
+ return m_lorentzShift[elementHash];
+}
+
+double FaserSiLorentzAngleCondData::getLorentzShiftEta(const IdentifierHash& elementHash) const
+{
+ if (m_lorentzShiftEta.size()<=elementHash) return s_invalidValue;
+ return m_lorentzShiftEta[elementHash];
+}
+
+double FaserSiLorentzAngleCondData::getTanLorentzAngle(const IdentifierHash& elementHash) const
+{
+ if (m_tanLorentzAngle.size()<=elementHash) return s_invalidValue;
+ return m_tanLorentzAngle[elementHash];
+}
+
+double FaserSiLorentzAngleCondData::getTanLorentzAngleEta(const IdentifierHash& elementHash) const
+{
+ if (m_tanLorentzAngleEta.size()<=elementHash) return s_invalidValue;
+ return m_tanLorentzAngleEta[elementHash];
+}
+
+double FaserSiLorentzAngleCondData::getBiasVoltage(const IdentifierHash& elementHash) const
+{
+ if (m_monitorBiasVoltage.size()<=elementHash) return s_invalidValue;
+ return m_monitorBiasVoltage[elementHash];
+}
+
+double FaserSiLorentzAngleCondData::getTemperature(const IdentifierHash& elementHash) const
+{
+ if (m_monitorTemperature.size()<=elementHash) return s_invalidValue;
+ return m_monitorTemperature[elementHash];
+}
+
+double FaserSiLorentzAngleCondData::getDepletionVoltage(const IdentifierHash& elementHash) const
+{
+ if (m_monitorDepletionVoltage.size()<=elementHash) return s_invalidValue;
+ return m_monitorDepletionVoltage[elementHash];
+}
+
+double FaserSiLorentzAngleCondData::getCorrectionFactor() const
+{
+ return m_correctionFactor;
+}
+
+void FaserSiLorentzAngleCondData::setLorentzShift(const IdentifierHash& elementHash, const double lorentzShift)
+{
+ if (m_lorentzShift.size()<=elementHash) m_lorentzShift.resize(elementHash+1, s_invalidValue);
+ m_lorentzShift[elementHash] = lorentzShift;
+}
+
+void FaserSiLorentzAngleCondData::setLorentzShiftEta(const IdentifierHash& elementHash, const double lorentzShiftEta)
+{
+ if (m_lorentzShiftEta.size()<=elementHash) m_lorentzShiftEta.resize(elementHash+1, s_invalidValue);
+ m_lorentzShiftEta[elementHash] = lorentzShiftEta;
+}
+
+void FaserSiLorentzAngleCondData::setTanLorentzAngle(const IdentifierHash& elementHash, const double tanLorentzAngle)
+{
+ if (m_tanLorentzAngle.size()<=elementHash) m_tanLorentzAngle.resize(elementHash+1, s_invalidValue);
+ m_tanLorentzAngle[elementHash] = tanLorentzAngle;
+}
+
+void FaserSiLorentzAngleCondData::setTanLorentzAngleEta(const IdentifierHash& elementHash, const double tanLorentzAngleEta)
+{
+ if (m_tanLorentzAngleEta.size()<=elementHash) m_tanLorentzAngleEta.resize(elementHash+1, s_invalidValue);
+ m_tanLorentzAngleEta[elementHash] = tanLorentzAngleEta;
+}
+
+void FaserSiLorentzAngleCondData::setBiasVoltage(const IdentifierHash& elementHash, const double biasVoltage)
+{
+ if (m_monitorBiasVoltage.size()<=elementHash) m_monitorBiasVoltage.resize(elementHash+1, s_invalidValue);
+ m_monitorBiasVoltage[elementHash] = biasVoltage;
+}
+
+void FaserSiLorentzAngleCondData::setTemperature(const IdentifierHash& elementHash, const double temperature)
+{
+ if (m_monitorTemperature.size()<=elementHash) m_monitorTemperature.resize(elementHash+1, s_invalidValue);
+ m_monitorTemperature[elementHash] = temperature;
+}
+
+void FaserSiLorentzAngleCondData::setDepletionVoltage(const IdentifierHash& elementHash, const double depletionVoltage)
+{
+ if (m_monitorDepletionVoltage.size()<=elementHash) m_monitorDepletionVoltage.resize(elementHash+1, s_invalidValue);
+ m_monitorDepletionVoltage[elementHash] = depletionVoltage;
+}
+
+void FaserSiLorentzAngleCondData::setCorrectionFactor(const double correctionFactor)
+{
+ m_correctionFactor = correctionFactor;
+}
diff --git a/Tracker/TrackerConditions/FaserSiLorentzAngleTool/src/FaserSiLorentzAngleTool.cxx b/Tracker/TrackerConditions/FaserSiLorentzAngleTool/src/FaserSiLorentzAngleTool.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..43c47c4ac49f9198a532b79d11c10ec3edba2d28
--- /dev/null
+++ b/Tracker/TrackerConditions/FaserSiLorentzAngleTool/src/FaserSiLorentzAngleTool.cxx
@@ -0,0 +1,250 @@
+/*
+ Copyright (C) 2002-2018 CERN for the benefit of the ATLAS collaboration
+*/
+
+#include "FaserSiLorentzAngleTool.h"
+
+#include <algorithm>
+#include <limits>
+
+#include "GaudiKernel/SystemOfUnits.h"
+
+#include "AthenaPoolUtilities/AthenaAttributeList.h"
+#include "Identifier/IdentifierHash.h"
+#include "TrackerReadoutGeometry/SiDetectorElement.h"
+#include "FaserSiPropertiesTool/FaserSiliconProperties.h"
+
+FaserSiLorentzAngleTool::FaserSiLorentzAngleTool(const std::string& type, const std::string& name, const IInterface* parent):
+ base_class(type, name, parent),
+ m_condData{"SCTSiLorentzAngleCondData"},
+ m_magFieldSvc{"FaserFieldSvc", name}
+{
+ declareProperty("IgnoreLocalPos", m_ignoreLocalPos = false,
+ "Treat methods that take a local position as if one called the methods without a local position");
+ // IF SCT, YOU NEED TO USE THE SAME PROPERTIES AS USED IN SCTSiLorentzAngleCondAlg!!!
+ declareProperty("DetectorName", m_detectorName="SCT", "Detector name (SCT)");
+ declareProperty("MagFieldSvc", m_magFieldSvc);
+ declareProperty("NominalField", m_nominalField = 2.0834*Gaudi::Units::tesla);
+ declareProperty("UseMagFieldSvc", m_useMagFieldSvc = true);
+ declareProperty("SiLorentzAngleCondData", m_condData, "Key of input FaserSiLorentzAngleCondData");
+}
+
+StatusCode FaserSiLorentzAngleTool::initialize() {
+
+ ATH_MSG_DEBUG("FaserSiLorentzAngleTool Initialized");
+
+ if (m_detectorName not_eq "SCT") {
+ ATH_MSG_FATAL("Invalid detector name: " << m_detectorName << ". Must be SCT.");
+ return StatusCode::FAILURE;
+ }
+
+ // Read Cond Handle
+ ATH_CHECK(m_condData.initialize());
+ ATH_CHECK(m_detEleCollKey.initialize());
+
+ // MagneticFieldSvc handles updates itself
+ if (not m_useMagFieldSvc) {
+ ATH_MSG_DEBUG("Not using MagneticFieldSvc - Will be using Nominal Field!");
+ } else if (m_magFieldSvc.retrieve().isFailure()) {
+ ATH_MSG_WARNING("Could not retrieve MagneticFieldSvc - Will be using Nominal Field!");
+ m_useMagFieldSvc = false;
+ }
+
+ return StatusCode::SUCCESS;
+}
+
+StatusCode FaserSiLorentzAngleTool::finalize() {
+ return StatusCode::SUCCESS;
+}
+
+double FaserSiLorentzAngleTool::getLorentzShift(const IdentifierHash& elementHash) const {
+ const FaserSiLorentzAngleCondData* condData{getCondData()};
+ if (condData) {
+ return condData->getLorentzShift(elementHash);
+ }
+ return s_invalidValue;
+}
+
+double FaserSiLorentzAngleTool::getLorentzShift(const IdentifierHash& elementHash, const Amg::Vector2D& locPos) const {
+ if (m_ignoreLocalPos) return getLorentzShift(elementHash);
+ // The cache is used to store the results. The cache is therefore invalidated if we specify a position.
+ return getValue(elementHash, locPos, LorentzShift);
+}
+
+double FaserSiLorentzAngleTool::getLorentzShiftEta(const IdentifierHash& elementHash) const {
+ const FaserSiLorentzAngleCondData* condData{getCondData()};
+ if (condData) {
+ return condData->getLorentzShiftEta(elementHash);
+ }
+ return s_invalidValue;
+}
+
+double FaserSiLorentzAngleTool::getLorentzShiftEta(const IdentifierHash& elementHash, const Amg::Vector2D& locPos) const {
+ if (m_ignoreLocalPos) return getLorentzShiftEta(elementHash);
+ // The cache is used to store the results. The cache is therefore invalidated if we specify a position.
+ return getValue(elementHash, locPos, LorentzShiftEta);
+}
+
+double FaserSiLorentzAngleTool::getTanLorentzAngle(const IdentifierHash& elementHash) const {
+ const FaserSiLorentzAngleCondData* condData{getCondData()};
+ if (condData) {
+ return condData->getTanLorentzAngle(elementHash);
+ }
+ return s_invalidValue;
+}
+
+double FaserSiLorentzAngleTool::getTanLorentzAngle(const IdentifierHash& elementHash, const Amg::Vector2D& locPos) const {
+ if (m_ignoreLocalPos) return getTanLorentzAngle(elementHash);
+ // The cache is used to store the results. The cache is therefore invalidated if we specify a position.
+ return getValue(elementHash, locPos, TanLorentzAngle);
+}
+
+double FaserSiLorentzAngleTool::getTanLorentzAngleEta(const IdentifierHash& elementHash) const {
+ const FaserSiLorentzAngleCondData* condData{getCondData()};
+ if (condData) {
+ return condData->getTanLorentzAngleEta(elementHash);
+ }
+ return s_invalidValue;
+}
+
+double FaserSiLorentzAngleTool::getTanLorentzAngleEta(const IdentifierHash& elementHash, const Amg::Vector2D& locPos) const {
+ if (m_ignoreLocalPos) return getTanLorentzAngleEta(elementHash);
+ // The cache is used to store the results. The cache is therefore invalidated if we specify a position.
+ return getValue(elementHash, locPos, TanLorentzAngleEta);
+}
+
+double FaserSiLorentzAngleTool::getBiasVoltage(const IdentifierHash& elementHash) const {
+ const FaserSiLorentzAngleCondData* condData{getCondData()};
+ if (condData) {
+ return condData->getBiasVoltage(elementHash);
+ }
+ return s_invalidValue;
+}
+
+double FaserSiLorentzAngleTool::getTemperature(const IdentifierHash& elementHash) const {
+ const FaserSiLorentzAngleCondData* condData{getCondData()};
+ if (condData) {
+ return condData->getTemperature(elementHash);
+ }
+ return s_invalidValue;
+}
+
+double FaserSiLorentzAngleTool::getDepletionVoltage(const IdentifierHash& elementHash) const {
+ const FaserSiLorentzAngleCondData* condData{getCondData()};
+ if (condData) {
+ return condData->getDepletionVoltage(elementHash);
+ }
+ return s_invalidValue;
+}
+
+double FaserSiLorentzAngleTool::getValue(const IdentifierHash& elementHash, const Amg::Vector2D& locPos, Variable variable) const {
+ if (not (variable==TanLorentzAngle or variable==LorentzShift or variable==TanLorentzAngleEta or variable==LorentzShiftEta)) {
+ ATH_MSG_WARNING("getValue with Variable=" << variable << " is not available");
+ return s_invalidValue;
+ }
+
+ double temperature{getTemperature(elementHash)};
+ double deplVoltage{getDepletionVoltage(elementHash)};
+ double biasVoltage{getBiasVoltage(elementHash)};
+
+ // Calculate depletion depth. If biasVoltage is less than depletionVoltage
+ // the detector is not fully depleted and we need to take this into account.
+ // We take absolute values just in case voltages are signed.
+ const TrackerDD::SiDetectorElement* element{getDetectorElement(elementHash)};
+ double depletionDepth{element->thickness()};
+ if (deplVoltage==0.0) ATH_MSG_WARNING("Depletion voltage in "<<__FILE__<<" is zero, which might be a bug.");
+ if (std::abs(biasVoltage) < std::abs(deplVoltage)) {
+ depletionDepth *= sqrt(std::abs(biasVoltage / deplVoltage));
+ }
+ double meanElectricField{0.};
+ if (depletionDepth) {
+ meanElectricField = biasVoltage / depletionDepth;
+ }
+ double mobility{0.};
+ Tracker::FaserSiliconProperties siProperties;
+ siProperties.setConditions(temperature, meanElectricField);
+ mobility = siProperties.signedHallMobility(element->carrierType());
+ // Get magnetic field.
+ Amg::Vector3D pointvec{element->globalPosition(locPos)};
+ Amg::Vector3D magneticField{getMagneticField(pointvec)};
+
+ double correctionFactor{getCorrectionFactor()};
+
+ // The angles are in the hit frame. This is because that is what is needed by the digization and also
+ // gives a more physical sign of the angle (ie dosen't flip sign when the detector is flipped).
+ // The hit depth axis is pointing from the readout side to the backside if m_design->readoutSide() < 0
+ // The hit depth axis is pointing from the backside to the readout side if m_design->readoutSide() > 0
+ if (variable==TanLorentzAngle or variable==LorentzShift) {
+ double tanLorentzAnglePhi{element->design().readoutSide()*mobility*element->hitDepthDirection()*element->hitPhiDirection()*(element->normal().cross(magneticField)).dot(element->phiAxis())};
+ if (variable==TanLorentzAngle) {
+ return correctionFactor*tanLorentzAnglePhi;
+ }
+ // This gives the effective correction in the reconstruction frame hence the extra hitPhiDirection()
+ // as the angle above is in the hit frame.
+ double lorentzCorrectionPhi{-0.5*element->hitPhiDirection()*tanLorentzAnglePhi*depletionDepth};
+ return correctionFactor*lorentzCorrectionPhi;
+ }
+
+ // The Lorentz eta shift very small and so can be ignored, but we include it for completeness.
+ // It is < ~0.1 um in the pixel.
+ // In the SCT its largest in the stereo side of the barrel modules where it is about 0.3 micron along the strip.
+ if (variable==TanLorentzAngleEta or variable==LorentzShiftEta) {
+ double tanLorentzAngleEta{element->design().readoutSide()*mobility*element->hitDepthDirection()*element->hitEtaDirection()*(element->normal().cross(magneticField)).dot(element->etaAxis())};
+ if (variable==TanLorentzAngleEta) {
+ return correctionFactor*tanLorentzAngleEta;
+ }
+ double lorentzCorrectionEta{-0.5*element->hitPhiDirection()*tanLorentzAngleEta*depletionDepth};
+ return correctionFactor*lorentzCorrectionEta;
+ }
+
+ ATH_MSG_WARNING("You should not see this message. Something is wrong in getValue");
+ return s_invalidValue;
+}
+
+double FaserSiLorentzAngleTool::getCorrectionFactor() const
+{
+ const FaserSiLorentzAngleCondData* condData{getCondData()};
+ if (condData) {
+ return condData->getCorrectionFactor();
+ }
+ return s_invalidValue;
+}
+
+Amg::Vector3D FaserSiLorentzAngleTool::getMagneticField(const Amg::Vector3D& pointvec) const {
+ // Get the magnetic field.
+ if (m_useMagFieldSvc) {
+ ATH_MSG_VERBOSE("Getting magnetic field from magnetic field service.");
+ double field[3];
+ double point[3];
+ point[0] = pointvec[0];
+ point[1] = pointvec[1];
+ point[2] = pointvec[2];
+ m_magFieldSvc->getField(point, field);
+ return Amg::Vector3D(field[0], field[1], field[2]);
+ } else {
+ ATH_MSG_VERBOSE("Using Nominal Field");
+ return Amg::Vector3D(0., 0., m_nominalField);
+ }
+}
+
+const FaserSiLorentzAngleCondData* FaserSiLorentzAngleTool::getCondData() const {
+ SG::ReadCondHandle<FaserSiLorentzAngleCondData> handle{m_condData};
+ if (handle.isValid()) {
+ const FaserSiLorentzAngleCondData* data{*handle};
+ return data;
+ }
+ ATH_MSG_WARNING(m_condData.key() << " cannot be retrieved.");
+ return nullptr;
+}
+
+const TrackerDD::SiDetectorElement* FaserSiLorentzAngleTool::getDetectorElement(const IdentifierHash& waferHash) const {
+ SG::ReadCondHandle<TrackerDD::SiDetectorElementCollection> handle{m_detEleCollKey};
+ const TrackerDD::SiDetectorElementCollection* elements{nullptr};
+ if (handle.isValid()) elements = *handle;
+ if (elements!=nullptr) return elements->getDetectorElement(waferHash);
+
+ ATH_MSG_WARNING(m_detEleCollKey.key() << " cannot be retrieved.");
+ return nullptr;
+}
+
+const double FaserSiLorentzAngleTool::s_invalidValue{std::numeric_limits<double>::quiet_NaN()};
diff --git a/Tracker/TrackerConditions/FaserSiLorentzAngleTool/src/FaserSiLorentzAngleTool.h b/Tracker/TrackerConditions/FaserSiLorentzAngleTool/src/FaserSiLorentzAngleTool.h
new file mode 100644
index 0000000000000000000000000000000000000000..1c280b2fd95e2536249dcaa1de66a82ac44b1717
--- /dev/null
+++ b/Tracker/TrackerConditions/FaserSiLorentzAngleTool/src/FaserSiLorentzAngleTool.h
@@ -0,0 +1,109 @@
+/*
+ Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+*/
+
+/**
+ * @file FaserSiLorentzAngleTool.h
+ * @author Susumu.Oda@cern.ch
+**/
+#ifndef FaserSiLorentzAngleTool_h
+#define FaserSiLorentzAngleTool_h
+
+#include "InDetCondTools/ISiLorentzAngleTool.h"
+#include "AthenaBaseComps/AthAlgTool.h"
+
+#include "GeoPrimitives/GeoPrimitives.h"
+#include "TrackerReadoutGeometry/SiDetectorElementCollection.h"
+#include "MagFieldInterfaces/IMagFieldSvc.h"
+#include "FaserSiLorentzAngleTool/FaserSiLorentzAngleCondData.h"
+#include "StoreGate/ReadCondHandleKey.h"
+
+//Gaudi Includes
+#include "GaudiKernel/ServiceHandle.h"
+
+class IdentifierHash;
+namespace TrackerDD {
+ class SiDetectorElement;
+}
+
+/**
+ * @class FaserSiLorentzAngleTool
+ * Concrete class for tool providing Lorentz angle (and the corresponding correction for the shift of the measurement)
+ * for each detector element.
+**/
+
+class FaserSiLorentzAngleTool: public extends<AthAlgTool, ISiLorentzAngleTool>
+{
+public:
+
+ FaserSiLorentzAngleTool(const std::string& type, const std::string& name, const IInterface* parent);
+ virtual ~FaserSiLorentzAngleTool() = default;
+
+ virtual StatusCode initialize() override; //!< Service init
+ virtual StatusCode finalize() override; //!< Service finalize
+
+ /** Get the Lorentz shift correction in the local x (phiDist) direction
+ Assumes the center of the detector and is generally cached. */
+ virtual double getLorentzShift(const IdentifierHash& elementHash) const override;
+
+ /** As above, but provide the local position.
+ More accurate but slower. */
+ virtual double getLorentzShift(const IdentifierHash& elementHash, const Amg::Vector2D& locPos) const override;
+
+ /**Get the Lorentz shift correction in the local y (etaDist) direction
+ Assumes the center of the detector and is generally cached. */
+ virtual double getLorentzShiftEta(const IdentifierHash& elementHash) const override;
+
+ /** As above, but provide the local position.
+ More accurate but slower. */
+ virtual double getLorentzShiftEta(const IdentifierHash& elementHash, const Amg::Vector2D& locPos) const override;
+
+ /** Get tan af the Lorentz angle in the local x (phiDist) direction
+ Assumes the center of the detector and is generally cached. */
+ virtual double getTanLorentzAngle(const IdentifierHash& elementHash) const override;
+
+ /** As above, but provide the local position.
+ More accurate but slower. */
+ virtual double getTanLorentzAngle(const IdentifierHash& elementHash, const Amg::Vector2D& locPos) const override;
+
+ /** Get tan af the Lorentz angle in the local y (etaDist) direction
+ Assumes the center of the detector and is generally cached. */
+ virtual double getTanLorentzAngleEta(const IdentifierHash& elementHash) const override;
+
+ /** As above, but provide the local position.
+ More accurate but slower. */
+ virtual double getTanLorentzAngleEta(const IdentifierHash& elementHash, const Amg::Vector2D& locPos) const override;
+
+ /** Get bias voltage */
+ virtual double getBiasVoltage(const IdentifierHash& elementHash) const override;
+
+ /** Get temperature */
+ virtual double getTemperature(const IdentifierHash& elementHash) const override;
+
+ /** Get depletion voltage */
+ virtual double getDepletionVoltage(const IdentifierHash& elementHash) const override;
+
+private:
+ enum Variable {LorentzShift, LorentzShiftEta, TanLorentzAngle, TanLorentzAngleEta};
+
+ double getValue(const IdentifierHash& elementHash, const Amg::Vector2D& locPos, Variable variable) const;
+ double getCorrectionFactor() const;
+ Amg::Vector3D getMagneticField(const Amg::Vector3D& pointvec) const;
+ const FaserSiLorentzAngleCondData* getCondData() const;
+ const TrackerDD::SiDetectorElement* getDetectorElement(const IdentifierHash& waferHash) const;
+
+ // Properties
+ std::string m_detectorName;
+ double m_nominalField;
+ bool m_useMagFieldSvc;
+ bool m_ignoreLocalPos; // Makes methods using localPosition behave as method without passing localPosition.
+ SG::ReadCondHandleKey<FaserSiLorentzAngleCondData> m_condData;
+ SG::ReadCondHandleKey<TrackerDD::SiDetectorElementCollection> m_detEleCollKey{this, "DetEleCollKey", "SCT_DetectorElementCollection", "Key of SiDetectorElementCollection for SCT"};
+
+ // needed services
+ ServiceHandle<MagField::IMagFieldSvc> m_magFieldSvc;
+
+ static const double s_invalidValue;
+};
+
+#endif // FaserSiLorentzAngleTool_h
diff --git a/Tracker/TrackerConditions/FaserSiLorentzAngleTool/src/components/FaserSiLorentzAngleTool_entries.cxx b/Tracker/TrackerConditions/FaserSiLorentzAngleTool/src/components/FaserSiLorentzAngleTool_entries.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..92f8bb88437c3281c96175aace68da3b666908b8
--- /dev/null
+++ b/Tracker/TrackerConditions/FaserSiLorentzAngleTool/src/components/FaserSiLorentzAngleTool_entries.cxx
@@ -0,0 +1,10 @@
+#include "../FaserSiLorentzAngleTool.h"
+#include "../FaserSCT_SiLorentzAngleCondAlg.h"
+// #include "../SCTSiLorentzAngleTestAlg.h"
+// #include "../PixelSiLorentzAngleCondAlg.h"
+
+DECLARE_COMPONENT( FaserSiLorentzAngleTool )
+DECLARE_COMPONENT( FaserSCT_SiLorentzAngleCondAlg )
+// DECLARE_COMPONENT( SCTSiLorentzAngleTestAlg )
+// DECLARE_COMPONENT( PixelSiLorentzAngleCondAlg )
+
diff --git a/Tracker/TrackerConditions/FaserSiPropertiesTool/CMakeLists.txt b/Tracker/TrackerConditions/FaserSiPropertiesTool/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..a771c637f2236b21e5400431e524559aac20518b
--- /dev/null
+++ b/Tracker/TrackerConditions/FaserSiPropertiesTool/CMakeLists.txt
@@ -0,0 +1,51 @@
+################################################################################
+# Package: FaserSiPropertiesTool
+################################################################################
+
+# Declare the package name:
+atlas_subdir( FaserSiPropertiesTool )
+
+# Declare the package's dependencies:
+atlas_depends_on_subdirs( PUBLIC
+ Control/AthenaBaseComps
+ Control/AthenaKernel
+ GaudiKernel
+ Tracker/TrackerDetDescr/TrackerReadoutGeometry
+ PRIVATE
+ Control/StoreGate
+ DetectorDescription/Identifier
+ InnerDetector/InDetConditions/InDetConditionsSummaryService
+ Tracker/TrackerDetDescr/TrackerIdentifier
+ Tracker/TrackerConditions/FaserSCT_ConditionsData )
+
+# External dependencies:
+find_package( CLHEP )
+
+# Component(s) in the package:
+atlas_add_library( FaserSiPropertiesToolLib
+ src/*.cxx
+ PUBLIC_HEADERS FaserSiPropertiesTool
+ PRIVATE_INCLUDE_DIRS ${CLHEP_INCLUDE_DIRS}
+ PRIVATE_DEFINITIONS ${CLHEP_DEFINITIONS}
+ LINK_LIBRARIES AthenaBaseComps AthenaKernel GaudiKernel TrackerReadoutGeometry FaserSCT_ConditionsData StoreGateLib SGtests
+ PRIVATE_LINK_LIBRARIES ${CLHEP_LIBRARIES} Identifier TrackerIdentifier )
+
+atlas_add_component( FaserSiPropertiesTool
+ src/components/*.cxx
+ INCLUDE_DIRS ${CLHEP_INCLUDE_DIRS}
+ LINK_LIBRARIES ${CLHEP_LIBRARIES} AthenaBaseComps AthenaKernel GaudiKernel TrackerReadoutGeometry FaserSCT_ConditionsData StoreGateLib SGtests Identifier TrackerIdentifier FaserSiPropertiesToolLib)
+
+# Run tests:
+#atlas_add_test( TestSCTProperties
+# SCRIPT athena.py --threads=5 SiPropertiesTool/testSCTProperties.py
+# PROPERTIES TIMEOUT 300
+# ENVIRONMENT THREADS=5 )
+
+#atlas_add_test( SiPropertiesConfig_test
+# SCRIPT test/SiPropertiesConfig_test.py
+# PROPERTIES TIMEOUT 300 )
+
+# Install files from the package:
+atlas_install_python_modules( python/*.py )
+atlas_install_joboptions( share/*.py )
+
diff --git a/Tracker/TrackerConditions/FaserSiPropertiesTool/FaserSiPropertiesTool/ATLAS_CHECK_THREAD_SAFETY b/Tracker/TrackerConditions/FaserSiPropertiesTool/FaserSiPropertiesTool/ATLAS_CHECK_THREAD_SAFETY
new file mode 100644
index 0000000000000000000000000000000000000000..95e6413b9b668d327e4377fb227bf178a8da6dec
--- /dev/null
+++ b/Tracker/TrackerConditions/FaserSiPropertiesTool/FaserSiPropertiesTool/ATLAS_CHECK_THREAD_SAFETY
@@ -0,0 +1 @@
+Tracker/TrackerConditions/FaserSiPropertiesTool
\ No newline at end of file
diff --git a/Tracker/TrackerConditions/FaserSiPropertiesTool/FaserSiPropertiesTool/FaserSiliconProperties.h b/Tracker/TrackerConditions/FaserSiPropertiesTool/FaserSiPropertiesTool/FaserSiliconProperties.h
new file mode 100644
index 0000000000000000000000000000000000000000..36b5e03228318f8a9903fca5efd73b5f62396e01
--- /dev/null
+++ b/Tracker/TrackerConditions/FaserSiPropertiesTool/FaserSiPropertiesTool/FaserSiliconProperties.h
@@ -0,0 +1,93 @@
+/*
+ Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef FASERSIPROPERTIESTOOL_FASERSILICONPROPERTIES_H
+#define FASERSIPROPERTIESTOOL_FASERSILICONPROPERTIES_H
+
+///////////////////////////////////////////////////////////////////
+// Header file for class SiliconProperties
+///////////////////////////////////////////////////////////////////
+// (c) ATLAS Detector software
+///////////////////////////////////////////////////////////////////
+// Class to hold silicon properties such as mobility, etc.
+// Quantities are in CLHEP units.
+///////////////////////////////////////////////////////////////////
+// Authors: Grant Gorfine
+///////////////////////////////////////////////////////////////////
+
+#include "TrackerReadoutGeometry/TrackerDD_Defs.h"
+
+namespace Tracker {
+
+class FaserSiliconProperties
+{
+public:
+
+
+ FaserSiliconProperties();
+ FaserSiliconProperties(double temperature, double electricField);
+
+ void setConditions(double temperature, double electricField);
+
+ double electronDriftMobility() const;
+ double holeDriftMobility() const;
+ double electronHallMobility() const;
+ double holeHallMobility() const;
+ double electronDiffusionConstant() const;
+ double holeDiffusionConstant() const;
+ double electronSaturationVelocity() const;
+ double holeSaturationVelocity() const;
+
+ double electronHolePairsPerEnergy() const;
+
+ double driftMobility(TrackerDD::CarrierType carrier) const;
+ double hallMobility(TrackerDD::CarrierType carrier) const;
+ double signedHallMobility(TrackerDD::CarrierType carrier) const; // signed by the charge of the carrier.
+ double diffusionConstant(TrackerDD::CarrierType carrier) const;
+ double charge(TrackerDD::CarrierType carrier) const;
+
+
+ // These are mainly for use internally but are left public
+ double calcElectronHallFactor(double temperature) const;
+ double calcHoleHallFactor(double temperature) const;
+ double calcDriftMobility(double electricField, double electricField_critical,
+ double saturationVelocity, double beta) const;
+ double calcElectronDriftMobility(double temperature, double electricField) const;
+ double calcHoleDriftMobility(double temperature, double electricField) const;
+ double calcElectronHallMobility(double temperature, double mobility) const;
+ double calcHoleHallMobility(double temperature, double mobility) const;
+ double calcDiffusionConstant(double temperature, double mobility) const;
+
+ // Allow overriding calculated quantities.
+ // Setting any one (other than setElectronHolePairsPerEnergy) will disable recalculations
+ // ie setConditions(temperature, electricField) will have no further effect.
+ void setElectronDriftMobility(double mobility);
+ void setHoleDriftMobility(double mobility);
+ void setElectronHallMobility(double mobility);
+ void setHoleHallMobility(double mobility);
+ void setElectronDiffusionConstant(double diffusionConstant);
+ void setHoleDiffusionConstant(double diffusionConstant);
+ void setElectronSaturationVelocity(double electronSaturationVelocity);
+ void setHoleSaturationVelocity(double holeSaturationVelocity);
+ void setElectronHolePairsPerEnergy(double ehPairsPerEnergy);
+
+private:
+ double m_electronDriftMobility;
+ double m_holeDriftMobility;
+ double m_electronHallMobility;
+ double m_holeHallMobility;
+ double m_electronDiffusionConstant;
+ double m_holeDiffusionConstant;
+ double m_electronSaturationVelocity;
+ double m_holeSaturationVelocity;
+ double m_ehPairsPerEnergy;
+
+ bool m_override; // signal that quantities are overriden and recalculation are disabled.
+
+ const static double s_ehPairsPerEnergyDefault;
+};
+
+} // namespace Tracker
+
+#endif // FASERSIPROPERTIESTOOL_FASERSILICONPROPERTIES_H
diff --git a/Tracker/TrackerConditions/FaserSiPropertiesTool/FaserSiPropertiesTool/FaserSiliconPropertiesVector.h b/Tracker/TrackerConditions/FaserSiPropertiesTool/FaserSiPropertiesTool/FaserSiliconPropertiesVector.h
new file mode 100644
index 0000000000000000000000000000000000000000..54fe6c1bdafe6fbf6e72e43cd3182a12ed2b916b
--- /dev/null
+++ b/Tracker/TrackerConditions/FaserSiPropertiesTool/FaserSiPropertiesTool/FaserSiliconPropertiesVector.h
@@ -0,0 +1,42 @@
+/*
+ Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef FASERSIPROPERTIESTOOL_FASERSILICONPROPERTIESVECTOR_H
+#define FASERSIPROPERTIESTOOL_FASERSILICONPROPERTIESVECTOR_H
+
+///////////////////////////////////////////////////////////////////
+// Header file for class SiliconPropertiesVector for SiPropertiesTool
+///////////////////////////////////////////////////////////////////
+
+#include <vector>
+#include "FaserSiPropertiesTool/FaserSiliconProperties.h"
+#include "Identifier/IdentifierHash.h"
+#include "AthenaKernel/CLASS_DEF.h"
+
+namespace Tracker {
+
+class FaserSiliconPropertiesVector
+{
+public:
+
+ FaserSiliconPropertiesVector();
+ ~FaserSiliconPropertiesVector();
+
+ void resize(IdentifierHash::value_type size);
+ const Tracker::FaserSiliconProperties& getSiProperties(const IdentifierHash& elementHash) const;
+ void setConditions(const IdentifierHash& elementHash, const double temperature, const double electricField);
+
+private:
+ std::vector<Tracker::FaserSiliconProperties> m_data;
+ Tracker::FaserSiliconProperties m_defaultProperties;
+};
+
+} // namespace Tracker
+
+CLASS_DEF(Tracker::FaserSiliconPropertiesVector, 26711649 , 1)
+
+#include "AthenaKernel/CondCont.h"
+CONDCONT_DEF(Tracker::FaserSiliconPropertiesVector, 142567857);
+
+#endif // FASERSIPROPERTIESTOOL_FASERSILICONPROPERTIESVECTOR_H
diff --git a/Tracker/TrackerConditions/FaserSiPropertiesTool/FaserSiPropertiesTool/IFaserSiPropertiesTool.h b/Tracker/TrackerConditions/FaserSiPropertiesTool/FaserSiPropertiesTool/IFaserSiPropertiesTool.h
new file mode 100644
index 0000000000000000000000000000000000000000..91827d6f9354598308049da58d9bfaa19b70b830
--- /dev/null
+++ b/Tracker/TrackerConditions/FaserSiPropertiesTool/FaserSiPropertiesTool/IFaserSiPropertiesTool.h
@@ -0,0 +1,35 @@
+/*
+ Copyright (C) 2002-2018 CERN for the benefit of the ATLAS collaboration
+*/
+
+/**
+ * @file IFaserSiPropertiesTool.h
+ * @author Susumu.Oda@cern.ch
+ **/
+#ifndef IFaserSiPropertiesTool_h
+#define IFaserSiPropertiesTool_h
+
+//Gaudi Includes
+#include "GaudiKernel/IAlgTool.h"
+#include "FaserSiPropertiesTool/FaserSiliconProperties.h"
+#include "Identifier/IdentifierHash.h"
+
+/**
+ * @class IFaserSiPropertiesTool
+ * Interface class for tool providing silicon properties (mobility, etc).
+ * for each detector element. These depend on conditions such as temperature.
+ **/
+
+class IFaserSiPropertiesTool: virtual public IAlgTool
+{
+ public:
+ virtual ~IFaserSiPropertiesTool() = default;
+
+ /// Creates the InterfaceID and interfaceID() method
+ DeclareInterfaceID(IFaserSiPropertiesTool, 1, 0);
+
+ /// Get Silicon properties for a given detector element.
+ virtual const Tracker::FaserSiliconProperties& getSiProperties(const IdentifierHash& elementHash) const = 0;
+};
+
+#endif // IFaserSiPropertiesTool_h
diff --git a/Tracker/TrackerConditions/FaserSiPropertiesTool/python/FaserSCT_SiPropertiesConfig.py b/Tracker/TrackerConditions/FaserSiPropertiesTool/python/FaserSCT_SiPropertiesConfig.py
new file mode 100644
index 0000000000000000000000000000000000000000..cfb2ab0eeab5e3244204803d717012cb4166c9e5
--- /dev/null
+++ b/Tracker/TrackerConditions/FaserSiPropertiesTool/python/FaserSCT_SiPropertiesConfig.py
@@ -0,0 +1,27 @@
+"""Define methods to configure SCT SiProperties
+
+Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+"""
+from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
+from AthenaConfiguration.ComponentFactory import CompFactory
+FaserSiPropertiesTool=CompFactory.FaserSiPropertiesTool
+FaserSCT_SiPropertiesCondAlg=CompFactory.FaserSCT_SiPropertiesCondAlg
+
+def FaserSCT_SiPropertiesToolCfg(flags, name="FaserSCT_SiPropertiesTool", **kwargs):
+ """Return a SiPropertiesTool configured for SCT"""
+ kwargs.setdefault("DetectorName", "SCT")
+ kwargs.setdefault("ReadKey", "SCTSiliconPropertiesVector")
+ return FaserSiPropertiesTool(name=name, **kwargs)
+
+def FaserSCT_SiPropertiesCfg(flags, name="FaserSCT_SiPropertiesCondAlg", **kwargs):
+ """Return configured ComponentAccumulator and tool for SCT_SiProperties
+
+ SiConditionsTool and/or SiPropertiesTool may be provided in kwargs
+ """
+ acc = ComponentAccumulator()
+ tool = kwargs.get("SiPropertiesTool", FaserSCT_SiPropertiesToolCfg(flags))
+ alg = FaserSCT_SiPropertiesCondAlg(name, **kwargs)
+ acc.addCondAlgo(alg)
+ acc.setPrivateTools(tool)
+ return acc
+
diff --git a/Tracker/TrackerConditions/FaserSiPropertiesTool/src/FaserSCT_SiPropertiesCondAlg.cxx b/Tracker/TrackerConditions/FaserSiPropertiesTool/src/FaserSCT_SiPropertiesCondAlg.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..fab907731e7f2a26ded0d61c10cb3b0c1e3633f0
--- /dev/null
+++ b/Tracker/TrackerConditions/FaserSiPropertiesTool/src/FaserSCT_SiPropertiesCondAlg.cxx
@@ -0,0 +1,159 @@
+/*
+ Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+*/
+
+#include "FaserSCT_SiPropertiesCondAlg.h"
+
+#include "Identifier/IdentifierHash.h"
+#include "TrackerIdentifier/FaserSCT_ID.h"
+#include "TrackerReadoutGeometry/SiDetectorElement.h"
+
+#include "GaudiKernel/EventIDRange.h"
+
+#include <cmath>
+#include <memory>
+
+FaserSCT_SiPropertiesCondAlg::FaserSCT_SiPropertiesCondAlg(const std::string& name, ISvcLocator* pSvcLocator)
+ : ::AthReentrantAlgorithm(name, pSvcLocator)
+ , m_condSvc{"CondSvc", name}
+ , m_pHelper{nullptr}
+{
+}
+
+StatusCode FaserSCT_SiPropertiesCondAlg::initialize() {
+ ATH_MSG_DEBUG("initialize " << name());
+
+ // SCT silicon conditions tool
+ ATH_CHECK(m_siCondTool.retrieve());
+
+ // SCT ID helper
+ ATH_CHECK(detStore()->retrieve(m_pHelper, "FaserSCT_ID"));
+
+ // CondSvc
+ ATH_CHECK(m_condSvc.retrieve());
+ // Read Cond Handles
+ ATH_CHECK(m_readKeyTemp.initialize());
+ ATH_CHECK(m_readKeyHV.initialize());
+ ATH_CHECK(m_SCTDetEleCollKey.initialize());
+ // Write Cond Handle
+ ATH_CHECK(m_writeKey.initialize());
+ if (m_condSvc->regHandle(this, m_writeKey).isFailure()) {
+ ATH_MSG_FATAL("unable to register WriteCondHandle " << m_writeKey.fullKey() << " with CondSvc");
+ return StatusCode::FAILURE;
+ }
+
+ return StatusCode::SUCCESS;
+}
+
+StatusCode FaserSCT_SiPropertiesCondAlg::execute(const EventContext& ctx) const {
+ ATH_MSG_DEBUG("execute " << name());
+
+ // Write Cond Handle
+ SG::WriteCondHandle<Tracker::FaserSiliconPropertiesVector> writeHandle{m_writeKey, ctx};
+ // Do we have a valid Write Cond Handle for current time?
+ 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;
+ }
+
+ // Read Cond Handle (temperature)
+ SG::ReadCondHandle<FaserSCT_DCSFloatCondData> readHandleTemp{m_readKeyTemp, ctx};
+ const FaserSCT_DCSFloatCondData* readCdoTemp{*readHandleTemp};
+ if (readCdoTemp==nullptr) {
+ ATH_MSG_FATAL("Null pointer to the read conditions object");
+ return StatusCode::FAILURE;
+ }
+ EventIDRange rangeTemp;
+ if (not readHandleTemp.range(rangeTemp)) {
+ ATH_MSG_FATAL("Failed to retrieve validity range for " << readHandleTemp.key());
+ return StatusCode::FAILURE;
+ }
+ ATH_MSG_INFO("Input is " << readHandleTemp.fullKey() << " with the range of " << rangeTemp);
+
+ // Read Cond Handle (HV)
+ SG::ReadCondHandle<FaserSCT_DCSFloatCondData> readHandleHV{m_readKeyHV, ctx};
+ const FaserSCT_DCSFloatCondData* readCdoHV{*readHandleHV};
+ if (readCdoHV==nullptr) {
+ ATH_MSG_FATAL("Null pointer to the read conditions object");
+ return StatusCode::FAILURE;
+ }
+ EventIDRange rangeHV;
+ if (not readHandleHV.range(rangeHV)) {
+ ATH_MSG_FATAL("Failed to retrieve validity range for " << readHandleHV.key());
+ return StatusCode::FAILURE;
+ }
+ ATH_MSG_INFO("Input is " << readHandleHV.fullKey() << " with the range of " << rangeHV);
+
+ // Combined the validity ranges of temp and HV (timestamp IOV)
+ EventIDRange rangeW{EventIDRange::intersect(rangeTemp, rangeHV)};
+ if (rangeW.stop().isValid() and rangeW.start()>rangeW.stop()) {
+ ATH_MSG_FATAL("Invalid intersection range: " << rangeW);
+ return StatusCode::FAILURE;
+ }
+
+ // Get SCT_DetectorElementCollection
+ SG::ReadCondHandle<TrackerDD::SiDetectorElementCollection> sctDetEle(m_SCTDetEleCollKey, ctx);
+ const TrackerDD::SiDetectorElementCollection* elements(sctDetEle.retrieve());
+ if (elements==nullptr) {
+ ATH_MSG_FATAL(m_SCTDetEleCollKey.fullKey() << " could not be retrieved");
+ return StatusCode::FAILURE;
+ }
+ EventIDRange rangeDetEle; // Run-LB IOV
+ if (not sctDetEle.range(rangeDetEle)) {
+ ATH_MSG_FATAL("Failed to retrieve validity range for " << m_SCTDetEleCollKey.key());
+ return StatusCode::FAILURE;
+ }
+
+ // Construct the output Cond Object and fill it in
+ std::unique_ptr<Tracker::FaserSiliconPropertiesVector> writeCdo{std::make_unique<Tracker::FaserSiliconPropertiesVector>()};
+ const FaserSCT_ID::size_type wafer_hash_max{m_pHelper->wafer_hash_max()};
+ writeCdo->resize(wafer_hash_max);
+ for (FaserSCT_ID::size_type hash{0}; hash<wafer_hash_max; hash++) {
+ const IdentifierHash elementHash{static_cast<IdentifierHash::value_type>(hash)};
+
+ double temperatureC{m_siCondTool->temperature(elementHash)};
+
+ if (not ((temperatureC>m_temperatureMin) and (temperatureC<m_temperatureMax))) {
+ ATH_MSG_DEBUG("Invalid temperature: "
+ << temperatureC << " C. "
+ << "Setting to " << m_temperatureDefault << " C. "
+ << "Detector element hash: " << elementHash);
+ temperatureC = m_temperatureDefault;
+ }
+
+ double temperature{temperatureC + 273.15};
+ double deplVoltage{m_siCondTool->depletionVoltage(elementHash) * CLHEP::volt};
+ double biasVoltage{m_siCondTool->biasVoltage(elementHash) * CLHEP::volt};
+
+ const TrackerDD::SiDetectorElement* element{elements->getDetectorElement(elementHash)};
+ double depletionDepth{element->thickness()};
+ if (std::abs(biasVoltage)<std::abs(deplVoltage)) {
+ depletionDepth *= sqrt(std::abs(biasVoltage/deplVoltage));
+ }
+ double meanElectricField{0.};
+ if (depletionDepth>0.) {
+ meanElectricField = biasVoltage/depletionDepth;
+ }
+
+ writeCdo->setConditions(hash, temperature, meanElectricField);
+ }
+
+ // Record the output cond object
+ if (writeHandle.record(rangeW, std::move(writeCdo)).isFailure()) {
+ ATH_MSG_FATAL("Could not record SCT_DCSFloatCondData " << writeHandle.key()
+ << " with EventRange " << rangeW
+ << " into Conditions Store");
+ return StatusCode::FAILURE;
+ }
+ ATH_MSG_INFO("recorded new CDO " << writeHandle.key() << " with range " << rangeW << " into Conditions Store");
+
+ return StatusCode::SUCCESS;
+}
+
+StatusCode FaserSCT_SiPropertiesCondAlg::finalize()
+{
+ ATH_MSG_DEBUG("finalize " << name());
+ return StatusCode::SUCCESS;
+}
diff --git a/Tracker/TrackerConditions/FaserSiPropertiesTool/src/FaserSCT_SiPropertiesCondAlg.h b/Tracker/TrackerConditions/FaserSiPropertiesTool/src/FaserSCT_SiPropertiesCondAlg.h
new file mode 100644
index 0000000000000000000000000000000000000000..b61f7f53152ddbaefdc192372e34096be94a087b
--- /dev/null
+++ b/Tracker/TrackerConditions/FaserSiPropertiesTool/src/FaserSCT_SiPropertiesCondAlg.h
@@ -0,0 +1,47 @@
+/*
+ Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef FASERSCT_SIPROPERTIESCONDALG
+#define FASERSCT_SIPROPERTIESCONDALG
+
+#include "AthenaBaseComps/AthReentrantAlgorithm.h"
+
+#include "InDetConditionsSummaryService/ISiliconConditionsTool.h"
+#include "TrackerReadoutGeometry/SiDetectorElementCollection.h"
+#include "FaserSCT_ConditionsData/FaserSCT_DCSFloatCondData.h"
+#include "FaserSiPropertiesTool/FaserSiliconPropertiesVector.h"
+#include "StoreGate/ReadCondHandleKey.h"
+#include "StoreGate/WriteCondHandleKey.h"
+
+#include "GaudiKernel/ICondSvc.h"
+#include "GaudiKernel/ServiceHandle.h"
+#include "GaudiKernel/ToolHandle.h"
+
+class FaserSCT_ID;
+
+class FaserSCT_SiPropertiesCondAlg : public AthReentrantAlgorithm
+{
+ public:
+ FaserSCT_SiPropertiesCondAlg(const std::string& name, ISvcLocator* pSvcLocator);
+ virtual ~FaserSCT_SiPropertiesCondAlg() = default;
+ virtual StatusCode initialize() override;
+ virtual StatusCode execute(const EventContext& ctx) const override;
+ virtual StatusCode finalize() override;
+ /** Make this algorithm clonable. */
+ virtual bool isClonable() const override { return true; };
+
+ private:
+ DoubleProperty m_temperatureMin{this, "TemperatureMin", -80., "Minimum temperature allowed in Celcius."};
+ DoubleProperty m_temperatureMax{this, "TemperatureMax", 100., "Maximum temperature allowed in Celcius."};
+ DoubleProperty m_temperatureDefault{this, "TemperatureDefault", -7., "Default temperature in Celcius."};
+ SG::ReadCondHandleKey<FaserSCT_DCSFloatCondData> m_readKeyTemp{this, "ReadKeyeTemp", "SCT_SiliconTempCondData", "Key of input sensor temperature conditions folder"};
+ SG::ReadCondHandleKey<FaserSCT_DCSFloatCondData> m_readKeyHV{this, "ReadKeyHV", "SCT_SiliconBiasVoltCondData", "Key of input bias voltage conditions folder"};
+ SG::ReadCondHandleKey<TrackerDD::SiDetectorElementCollection> m_SCTDetEleCollKey{this, "SCTDetEleCollKey", "SCT_DetectorElementCollection", "Key of SiDetectorElementCollection for SCT"};
+ SG::WriteCondHandleKey<Tracker::FaserSiliconPropertiesVector> m_writeKey{this, "WriteKey", "SCTSiliconPropertiesVector", "Key of output silicon properties conditions folder"};
+ ServiceHandle<ICondSvc> m_condSvc;
+ ToolHandle<ISiliconConditionsTool> m_siCondTool{this, "SiConditionsTool", "SCT_SiliconConditionsTool", "SiConditionsTool to be used"};
+ const FaserSCT_ID* m_pHelper; //!< ID helper for FaserSCT
+};
+
+#endif // FASERSCT_SIPROPERTIESCONDALG
diff --git a/Tracker/TrackerConditions/FaserSiPropertiesTool/src/FaserSiPropertiesTool.cxx b/Tracker/TrackerConditions/FaserSiPropertiesTool/src/FaserSiPropertiesTool.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..d889c3f29d42d573049063c02afbb9b7e1e9baee
--- /dev/null
+++ b/Tracker/TrackerConditions/FaserSiPropertiesTool/src/FaserSiPropertiesTool.cxx
@@ -0,0 +1,51 @@
+/*
+ Copyright (C) 2002-2018 CERN for the benefit of the ATLAS collaboration
+*/
+
+#include "FaserSiPropertiesTool.h"
+
+FaserSiPropertiesTool::FaserSiPropertiesTool(const std::string& type, const std::string& name, const IInterface* parent) :
+ base_class(type, name, parent),
+ m_propertiesVector{"SCTSiliconPropertiesVector"}
+{
+ declareProperty("DetectorName", m_detectorName="SCT", "Dectector name: SCT");
+ declareProperty("ReadKey", m_propertiesVector, "Key of SiliconPropertiesVector");
+}
+
+StatusCode
+FaserSiPropertiesTool::initialize()
+{
+ ATH_MSG_INFO("FaserSiPropertiesTool Initialized");
+
+ if (m_detectorName != "SCT") {
+ ATH_MSG_FATAL("Invalid detector name: " << m_detectorName << ". Must be SCT.");
+ return StatusCode::FAILURE;
+ }
+ ATH_CHECK(m_propertiesVector.initialize());
+
+ return StatusCode::SUCCESS;
+}
+
+StatusCode
+FaserSiPropertiesTool::finalize()
+{
+ return StatusCode::SUCCESS;
+}
+
+const Tracker::FaserSiliconProperties&
+FaserSiPropertiesTool::getSiProperties(const IdentifierHash& elementHash) const {
+ SG::ReadCondHandle<Tracker::FaserSiliconPropertiesVector> handle{m_propertiesVector};
+ if (handle.isValid()) {
+ const Tracker::FaserSiliconPropertiesVector* vector{*handle};
+ if (vector) {
+ return vector->getSiProperties(elementHash);
+ }
+ }
+
+ ATH_MSG_WARNING("SG::ReadCondHandle<Tracker::FaserSiliconPropertiesVector> is not valid. " <<
+ "Return default Tracker::SiliconProperties for IdentifierHash of " <<
+ elementHash);
+ return s_defaultProperties;
+}
+
+const Tracker::FaserSiliconProperties FaserSiPropertiesTool::s_defaultProperties{};
diff --git a/Tracker/TrackerConditions/FaserSiPropertiesTool/src/FaserSiPropertiesTool.h b/Tracker/TrackerConditions/FaserSiPropertiesTool/src/FaserSiPropertiesTool.h
new file mode 100644
index 0000000000000000000000000000000000000000..b737bf78f1e6d18abb5ddc17479465a1b9698fbe
--- /dev/null
+++ b/Tracker/TrackerConditions/FaserSiPropertiesTool/src/FaserSiPropertiesTool.h
@@ -0,0 +1,43 @@
+/*
+ Copyright (C) 2002-2018 CERN for the benefit of the ATLAS collaboration
+*/
+
+/**
+ * @file FaserSiPropertiesTool.h
+ * @author Susumu.Oda@cern.ch
+**/
+#ifndef FaserSiPropertiesTool_h
+#define FaserSiPropertiesTool_h
+
+#include "FaserSiPropertiesTool/IFaserSiPropertiesTool.h"
+
+#include "AthenaBaseComps/AthAlgTool.h"
+#include "FaserSiPropertiesTool/FaserSiliconPropertiesVector.h"
+#include "StoreGate/ReadCondHandleKey.h"
+
+/**
+ * @class FaserSiPropertiesTool
+ * Concrete class for service providing silicon properties (mobility, etc).
+ * for each detector element. These depend on conditions such as temperature.
+**/
+class FaserSiPropertiesTool: public extends<AthAlgTool, IFaserSiPropertiesTool>
+{
+public:
+ FaserSiPropertiesTool(const std::string& type, const std::string& name, const IInterface* parent);
+ virtual ~FaserSiPropertiesTool() = default;
+
+ virtual StatusCode initialize() override;
+ virtual StatusCode finalize() override;
+
+ /// Get properties for the detector element.
+ virtual const Tracker::FaserSiliconProperties& getSiProperties(const IdentifierHash& elementHash) const override;
+
+private:
+ // Properties
+ std::string m_detectorName;
+ SG::ReadCondHandleKey<Tracker::FaserSiliconPropertiesVector> m_propertiesVector;
+
+ static const Tracker::FaserSiliconProperties s_defaultProperties;
+};
+
+#endif // FaserSiPropertiesTool_h
diff --git a/Tracker/TrackerConditions/FaserSiPropertiesTool/src/FaserSiliconProperties.cxx b/Tracker/TrackerConditions/FaserSiPropertiesTool/src/FaserSiliconProperties.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..b141a05ab5b94405683d50668f2209d736a7cdd1
--- /dev/null
+++ b/Tracker/TrackerConditions/FaserSiPropertiesTool/src/FaserSiliconProperties.cxx
@@ -0,0 +1,243 @@
+/*
+ Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+*/
+
+#include "FaserSiPropertiesTool/FaserSiliconProperties.h"
+#include "CLHEP/Units/PhysicalConstants.h"
+
+#include <cmath>
+#include <iostream>
+
+namespace Tracker {
+
+using TrackerDD::CarrierType;
+using TrackerDD::holes;
+using TrackerDD::electrons;
+
+// This value for the number of eh pairs per deposited energy is fairly standard I think.
+// In reality there is some temperture dependence but for the temperature ranges we deal with
+// I don't think variations are too signifcant.
+const double FaserSiliconProperties::s_ehPairsPerEnergyDefault = 1. / (3.62 * CLHEP::eV); // 1 eh pair per 3.62 CLHEP::eV.
+
+// Constants used in the formula
+const double elecHallFactZero = 1.13;
+const double elecHallFact_drdt = 8e-4;
+const double elecV_sat_0 = 1.53e9 * CLHEP::cm/CLHEP::s;
+const double elecV_sat_exp = -0.87;
+const double elecE_crit_0 = 1.01 * CLHEP::volt/CLHEP::cm;
+const double elecE_crit_exp = 1.55;
+const double elecBeta_0 = 2.57e-2;
+const double elecBeta_exp = 0.66;
+
+const double holeHallFactZero = 0.72;
+const double holeHallFact_drdt = -5e-4;
+const double holeV_sat_0 = 1.62e8 * CLHEP::cm/CLHEP::s;
+const double holeV_sat_exp = -0.52;
+const double holeE_crit_0 = 1.24 * CLHEP::volt/CLHEP::cm;
+const double holeE_crit_exp = 1.68;
+const double holeBeta_0 = 0.46;
+const double holeBeta_exp = 0.17;
+
+const double temperatureZero = 273.15 * CLHEP::kelvin;
+
+FaserSiliconProperties::FaserSiliconProperties()
+ : m_electronDriftMobility(0),
+ m_holeDriftMobility(0),
+ m_electronHallMobility(0),
+ m_holeHallMobility(0),
+ m_electronDiffusionConstant(0),
+ m_holeDiffusionConstant(0),
+ m_electronSaturationVelocity(0),
+ m_holeSaturationVelocity(0),
+ m_ehPairsPerEnergy(s_ehPairsPerEnergyDefault),
+ m_override(false)
+{}
+
+FaserSiliconProperties::FaserSiliconProperties(double temperature, double electricField)
+ : m_electronDriftMobility(0),
+ m_holeDriftMobility(0),
+ m_electronHallMobility(0),
+ m_holeHallMobility(0),
+ m_electronDiffusionConstant(0),
+ m_holeDiffusionConstant(0),
+ m_electronSaturationVelocity(0),
+ m_holeSaturationVelocity(0),
+ m_ehPairsPerEnergy(s_ehPairsPerEnergyDefault),
+ m_override(false)
+{
+ setConditions(temperature, electricField);
+}
+
+void FaserSiliconProperties::setConditions(double temperature, double electricField) {
+
+ if (m_electronSaturationVelocity==0.0) { m_electronSaturationVelocity=elecV_sat_0; }
+ if (m_holeSaturationVelocity==0.0) { m_holeSaturationVelocity=holeV_sat_0; }
+
+ if (!m_override) {
+ m_electronDriftMobility = calcElectronDriftMobility(temperature, electricField);
+ m_holeDriftMobility = calcHoleDriftMobility(temperature, electricField);
+ m_electronHallMobility = calcElectronHallFactor(temperature) * m_electronDriftMobility;
+ m_holeHallMobility = calcHoleHallFactor(temperature) * m_holeDriftMobility;
+ m_electronDiffusionConstant = calcDiffusionConstant(temperature, m_electronDriftMobility);
+ m_holeDiffusionConstant = calcDiffusionConstant(temperature, m_holeDriftMobility);
+ }
+}
+
+double FaserSiliconProperties::driftMobility(CarrierType carrierType) const {
+ if (carrierType == holes) {
+ return holeDriftMobility();
+ } else {
+ return electronDriftMobility();
+ }
+}
+
+double FaserSiliconProperties::hallMobility(CarrierType carrierType) const {
+ if (carrierType == holes) {
+ return holeHallMobility();
+ } else {
+ return electronHallMobility();
+ }
+}
+
+double FaserSiliconProperties::diffusionConstant(CarrierType carrierType) const {
+ if (carrierType == holes) {
+ return holeDiffusionConstant();
+ } else {
+ return electronDiffusionConstant();
+ }
+}
+
+double FaserSiliconProperties::charge(CarrierType carrierType) const {
+ return (carrierType == holes) ? +1 : -1;
+}
+
+double FaserSiliconProperties::signedHallMobility(CarrierType carrierType) const {
+ if (carrierType == holes) {
+ return holeHallMobility();
+ } else {
+ return -electronHallMobility();
+ }
+}
+
+double FaserSiliconProperties::calcElectronHallFactor(double temperature) const {
+ // Equation from ATL-INDET-2001-004
+ return elecHallFactZero + elecHallFact_drdt * (temperature - temperatureZero);
+}
+
+double FaserSiliconProperties::calcHoleHallFactor(double temperature) const {
+ // Equation from ATL-INDET-2001-004
+ return holeHallFactZero + holeHallFact_drdt * (temperature - temperatureZero);
+}
+
+// driftMobility
+double FaserSiliconProperties::calcDriftMobility(double electricField, double electricField_critical, double saturationVelocity, double beta) const {
+ // Equation from ATL-INDET-2001-004
+ return saturationVelocity / electricField_critical /
+ pow(std::abs(1. + pow(std::abs(electricField/electricField_critical), beta)), 1./beta);
+}
+
+double FaserSiliconProperties::calcElectronDriftMobility(double temperature, double electricField) const {
+ // Equations from ATL-INDET-2001-004
+// double saturationVelocity = elecV_sat_0 * pow(temperature, elecV_sat_exp);
+ double saturationVelocity = m_electronSaturationVelocity*pow(temperature, elecV_sat_exp);
+ double electricField_critical = elecE_crit_0 * pow(temperature, elecE_crit_exp);
+ double beta = elecBeta_0 * pow(temperature, elecBeta_exp);
+ return calcDriftMobility(electricField, electricField_critical, saturationVelocity, beta);
+}
+
+double FaserSiliconProperties::calcHoleDriftMobility(double temperature, double electricField) const {
+ // Equations from ATL-INDET-2001-004
+// double saturationVelocity = holeV_sat_0 * pow(temperature, holeV_sat_exp);
+ double saturationVelocity = m_holeSaturationVelocity*pow(temperature, holeV_sat_exp);
+ double electricField_critical = holeE_crit_0 * pow(temperature, holeE_crit_exp);
+ double beta = holeBeta_0 * pow(temperature, holeBeta_exp);
+ return calcDriftMobility(electricField, electricField_critical, saturationVelocity, beta);
+}
+
+
+double FaserSiliconProperties::calcDiffusionConstant(double temperature, double mobility) const {
+ // Einstein's relationship (in many text books)
+ return -CLHEP::k_Boltzmann * temperature / CLHEP::electron_charge * mobility; // CLHEP::k_Boltzmann and CLHEP::electron_charge
+}
+
+double FaserSiliconProperties::electronDriftMobility() const {
+ return m_electronDriftMobility;
+}
+
+double FaserSiliconProperties::holeDriftMobility() const {
+ return m_holeDriftMobility;
+}
+
+double FaserSiliconProperties::electronHallMobility() const {
+ return m_electronHallMobility;
+}
+
+double FaserSiliconProperties::holeHallMobility() const {
+ return m_holeHallMobility;
+}
+
+double FaserSiliconProperties::electronDiffusionConstant() const {
+ return m_electronDiffusionConstant;
+}
+
+double FaserSiliconProperties::holeDiffusionConstant() const {
+ return m_holeDiffusionConstant;
+}
+
+double FaserSiliconProperties::electronSaturationVelocity() const {
+ return m_electronSaturationVelocity;
+}
+
+double FaserSiliconProperties::holeSaturationVelocity() const {
+ return m_holeSaturationVelocity;
+}
+
+void FaserSiliconProperties::setElectronDriftMobility(double mobility) {
+ m_override = true;
+ m_electronDriftMobility = mobility;
+}
+
+void FaserSiliconProperties::setHoleDriftMobility(double mobility) {
+ m_override = true;
+ m_holeDriftMobility = mobility;
+}
+
+void FaserSiliconProperties::setElectronHallMobility(double mobility) {
+ m_override = true;
+ m_electronHallMobility = mobility;
+}
+
+void FaserSiliconProperties::setHoleHallMobility(double mobility) {
+ m_override = true;
+ m_holeHallMobility = mobility;
+}
+
+void FaserSiliconProperties::setElectronDiffusionConstant(double diffusionConstant) {
+ m_override = true;
+ m_electronDiffusionConstant = diffusionConstant;
+}
+
+void FaserSiliconProperties::setHoleDiffusionConstant(double diffusionConstant) {
+ m_override = true;
+ m_holeDiffusionConstant = diffusionConstant;
+}
+
+void FaserSiliconProperties::setElectronSaturationVelocity(double electronSaturationVelocity) {
+ m_electronSaturationVelocity = electronSaturationVelocity;
+}
+
+void FaserSiliconProperties::setHoleSaturationVelocity(double holeSaturationVelocity) {
+ m_holeSaturationVelocity = holeSaturationVelocity;
+}
+
+void FaserSiliconProperties::setElectronHolePairsPerEnergy(double ehPairsPerEnergy) {
+ m_ehPairsPerEnergy = ehPairsPerEnergy;
+}
+
+double FaserSiliconProperties::electronHolePairsPerEnergy() const {
+ return m_ehPairsPerEnergy;
+}
+
+
+
+} // namespace Tracker
diff --git a/Tracker/TrackerConditions/FaserSiPropertiesTool/src/FaserSiliconPropertiesVector.cxx b/Tracker/TrackerConditions/FaserSiPropertiesTool/src/FaserSiliconPropertiesVector.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..ace30a36306170f4459749eba1be6a51529d01bd
--- /dev/null
+++ b/Tracker/TrackerConditions/FaserSiPropertiesTool/src/FaserSiliconPropertiesVector.cxx
@@ -0,0 +1,36 @@
+/*
+ Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+*/
+
+///////////////////////////////////////////////////////////////////
+// Source file for class SiliconPropertiesVector for SiPropertiesTool
+///////////////////////////////////////////////////////////////////
+
+#include "FaserSiPropertiesTool/FaserSiliconPropertiesVector.h"
+
+namespace Tracker {
+
+ FaserSiliconPropertiesVector::FaserSiliconPropertiesVector():
+ m_data{},
+ m_defaultProperties{}
+ {
+ }
+
+ FaserSiliconPropertiesVector::~FaserSiliconPropertiesVector() {
+ }
+
+ void FaserSiliconPropertiesVector::resize(IdentifierHash::value_type size) {
+ m_data.resize(size);
+ }
+
+ const Tracker::FaserSiliconProperties& FaserSiliconPropertiesVector::getSiProperties(const IdentifierHash& elementHash) const {
+ if (m_data.size()<elementHash) return m_defaultProperties;
+ return m_data[elementHash];
+ }
+
+ void FaserSiliconPropertiesVector::setConditions(const IdentifierHash& elementHash, const double temperature, const double electricField) {
+ if (m_data.size()<elementHash) m_data.resize(elementHash);
+ m_data[elementHash].setConditions(temperature, electricField);
+ }
+
+} // namespace Tracker
diff --git a/Tracker/TrackerConditions/FaserSiPropertiesTool/src/components/FaserSiPropertiesTool_entries.cxx b/Tracker/TrackerConditions/FaserSiPropertiesTool/src/components/FaserSiPropertiesTool_entries.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..46cc439bf0f87ec3855e2fbf431913edd4caf9e3
--- /dev/null
+++ b/Tracker/TrackerConditions/FaserSiPropertiesTool/src/components/FaserSiPropertiesTool_entries.cxx
@@ -0,0 +1,10 @@
+#include "../FaserSiPropertiesTool.h"
+#include "../FaserSCT_SiPropertiesCondAlg.h"
+// #include "../SCTSiPropertiesTestAlg.h"
+// #include "../PixelSiPropertiesCondAlg.h"
+
+DECLARE_COMPONENT( FaserSiPropertiesTool )
+DECLARE_COMPONENT( FaserSCT_SiPropertiesCondAlg )
+// DECLARE_COMPONENT( SCTSiPropertiesTestAlg )
+// DECLARE_COMPONENT( PixelSiPropertiesCondAlg )
+
diff --git a/Tracker/TrackerDetDescr/FaserSCT_GeoModel/FaserSCT_GeoModel/FaserSCT_DetectorTool.h b/Tracker/TrackerDetDescr/FaserSCT_GeoModel/FaserSCT_GeoModel/FaserSCT_DetectorTool.h
index 4b63e9d9261ed5c6ec8b9e8ec3400271de8e80ee..c4cc0f8eb6e753ac51d20377110d1fcedd1ce498 100644
--- a/Tracker/TrackerDetDescr/FaserSCT_GeoModel/FaserSCT_GeoModel/FaserSCT_DetectorTool.h
+++ b/Tracker/TrackerDetDescr/FaserSCT_GeoModel/FaserSCT_GeoModel/FaserSCT_DetectorTool.h
@@ -49,10 +49,11 @@ private:
ServiceHandle< IRDBAccessSvc > m_rdbAccessSvc;
ServiceHandle< IGeometryDBSvc > m_geometryDBSvc;
- StringProperty m_run1Folder{this, "Run1Folder", "/Indet/Align"};
- StringProperty m_run2L1Folder{this, "Run2L1Folder", "/Indet/AlignL1/ID"};
- StringProperty m_run2L2Folder{this, "Run2L2Folder", "/Indet/AlignL2/SCT"};
- StringProperty m_run2L3Folder{this, "Run2L3Folder", "/Indet/AlignL3"};
+ StringProperty m_run1Folder{this, "Run1Folder", "/Tracker/Align"};
+ // StringProperty m_run1Folder{this, "Run1Folder", "/Indet/Align"};
+ // StringProperty m_run2L1Folder{this, "Run2L1Folder", "/Indet/AlignL1/ID"};
+ // StringProperty m_run2L2Folder{this, "Run2L2Folder", "/Indet/AlignL2/SCT"};
+ // StringProperty m_run2L3Folder{this, "Run2L3Folder", "/Indet/AlignL3"};
};
#endif // FASERSCT_GEOMODEL_SCT_DETECTORTOOL_H
diff --git a/Tracker/TrackerDetDescr/FaserSCT_GeoModel/python/FaserSCT_GeoModelConfig.py b/Tracker/TrackerDetDescr/FaserSCT_GeoModel/python/FaserSCT_GeoModelConfig.py
index 7c8e771ce4ba573bce6ecc35d779cec5584500be..753fb6ebd3be32e2b47b948f0fad83f9c1565005 100644
--- a/Tracker/TrackerDetDescr/FaserSCT_GeoModel/python/FaserSCT_GeoModelConfig.py
+++ b/Tracker/TrackerDetDescr/FaserSCT_GeoModel/python/FaserSCT_GeoModelConfig.py
@@ -1,6 +1,7 @@
# Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
from AthenaCommon import CfgMgr
+from AthenaConfiguration.ComponentFactory import CompFactory
def getFaserSCT_DetectorTool(name="FaserSCT_DetectorTool", **kwargs):
kwargs.setdefault("DetectorName", "SCT")
@@ -27,28 +28,29 @@ def FaserSCT_GeometryCfg( flags ):
from DBReplicaSvc.DBReplicaSvcConf import DBReplicaSvc
acc.addService(DBReplicaSvc("DBReplicaSvc"))
- from FaserSCT_GeoModel.FaserSCT_GeoModelConf import FaserSCT_DetectorTool
+ FaserSCT_DetectorTool = CompFactory.FaserSCT_DetectorTool
sctDetectorTool = FaserSCT_DetectorTool()
sctDetectorTool.useDynamicAlignFolders = flags.GeoModel.Align.Dynamic
geoModelSvc.DetectorTools += [ sctDetectorTool ]
- # if flags.GeoModel.Align.Dynamic:
- # acc.merge(addFoldersSplitOnline(flags,"INDET","/Indet/Onl/AlignL1/ID","/Indet/AlignL1/ID",className="CondAttrListCollection"))
- # acc.merge(addFoldersSplitOnline(flags,"INDET","/Indet/Onl/AlignL2/SCT","/Indet/AlignL2/SCT",className="CondAttrListCollection"))
- # acc.merge(addFoldersSplitOnline(flags,"INDET","/Indet/Onl/AlignL3","/Indet/AlignL3",className="AlignableTransformContainer"))
- # else:
- # if (not flags.Detector.SimulateFaserSCT) or flags.Detector.OverlaySCT:
- # acc.merge(addFoldersSplitOnline(flags,"INDET","/Indet/Onl/Align","/Indet/Align",className="AlignableTransformContainer"))
- # else:
- # acc.merge(addFoldersSplitOnline(flags,"INDET","/Indet/Onl/Align","/Indet/Align"))
- # if flags.Common.Project is not "AthSimulation": # Protection for AthSimulation builds
- # if (not flags.Detector.SimulateFaserSCT) or flags.Detector.OverlaySCT:
- # from SCT_ConditionsAlgorithms.SCT_ConditionsAlgorithmsConf import SCT_AlignCondAlg
- # sctAlignCondAlg = SCT_AlignCondAlg(name = "SCT_AlignCondAlg",
- # UseDynamicAlignFolders = flags.GeoModel.Align.Dynamic)
- # acc.addCondAlgo(sctAlignCondAlg)
- # from SCT_ConditionsAlgorithms.SCT_ConditionsAlgorithmsConf import SCT_DetectorElementCondAlg
- # sctDetectorElementCondAlg = SCT_DetectorElementCondAlg(name = "SCT_DetectorElementCondAlg")
- # acc.addCondAlgo(sctDetectorElementCondAlg)
+ if flags.GeoModel.Align.Dynamic:
+ # acc.merge(addFoldersSplitOnline(flags,"INDET","/Indet/Onl/AlignL1/ID","/Indet/AlignL1/ID",className="CondAttrListCollection"))
+ # acc.merge(addFoldersSplitOnline(flags,"INDET","/Indet/Onl/AlignL2/SCT","/Indet/AlignL2/SCT",className="CondAttrListCollection"))
+ # acc.merge(addFoldersSplitOnline(flags,"INDET","/Indet/Onl/AlignL3","/Indet/AlignL3",className="AlignableTransformContainer"))
+ print "FaserSCT dynamic align flag is not supported!"
+ else:
+ if (not flags.Detector.SimulateFaserSCT) or flags.Detector.OverlaySCT:
+ acc.merge(addFoldersSplitOnline(flags,"SCT","/Tracker/Onl/Align","/Tracker/Align",className="AlignableTransformContainer"))
+ # else:
+ # acc.merge(addFoldersSplitOnline(flags,"INDET","/Indet/Onl/Align","/Indet/Align"))
+ if flags.Common.Project is not "AthSimulation": # Protection for AthSimulation builds
+ if (not flags.Detector.SimulateFaserSCT) or flags.Detector.OverlaySCT:
+ FaserSCT_AlignCondAlg = CompFactory.FaserSCT_AlignCondAlg
+ sctAlignCondAlg = FaserSCT_AlignCondAlg(name = "FaserSCT_AlignCondAlg",
+ UseDynamicAlignFolders = flags.GeoModel.Align.Dynamic)
+ acc.addCondAlgo(sctAlignCondAlg)
+ FaserSCT_DetectorElementCondAlg = CompFactory.FaserSCT_DetectorElementCondAlg
+ sctDetectorElementCondAlg = FaserSCT_DetectorElementCondAlg(name = "FaserSCT_DetectorElementCondAlg")
+ acc.addCondAlgo(sctDetectorElementCondAlg)
return acc
diff --git a/Tracker/TrackerDetDescr/FaserSCT_GeoModel/src/FaserSCT_DetectorTool.cxx b/Tracker/TrackerDetDescr/FaserSCT_GeoModel/src/FaserSCT_DetectorTool.cxx
index d459b373f20fa6f5e87e29cccc9818796f14f786..4cac04e0c4d74bb3068712121ac3f51f077cfce4 100644
--- a/Tracker/TrackerDetDescr/FaserSCT_GeoModel/src/FaserSCT_DetectorTool.cxx
+++ b/Tracker/TrackerDetDescr/FaserSCT_GeoModel/src/FaserSCT_DetectorTool.cxx
@@ -166,36 +166,36 @@ FaserSCT_DetectorTool::registerCallback ATLAS_NOT_THREAD_SAFE ()
StatusCode sc{StatusCode::FAILURE, true};
if (m_alignable.value()) {
if (m_useDynamicAlignFolders.value()) {
-
- if (detStore()->contains<CondAttrListCollection>(m_run2L1Folder.value())) {
- ATH_MSG_DEBUG("Registering callback on global Container with folder " << m_run2L1Folder.value());
- const DataHandle<CondAttrListCollection> calc;
- ATH_CHECK(detStore()->regFcn(&IGeoModelTool::align, dynamic_cast<IGeoModelTool*>(this), calc, m_run2L1Folder.value()));
- sc = StatusCode::SUCCESS;
- } else {
- ATH_MSG_WARNING("Unable to register callback on global Container with folder " << m_run2L1Folder.value());
- return StatusCode::FAILURE;
- }
-
- if (detStore()->contains<CondAttrListCollection>(m_run2L2Folder.value())) {
- ATH_MSG_DEBUG("Registering callback on global Container with folder " << m_run2L2Folder.value());
- const DataHandle<CondAttrListCollection> calc;
- ATH_CHECK(detStore()->regFcn(&IGeoModelTool::align, dynamic_cast<IGeoModelTool*>(this), calc, m_run2L2Folder.value()));
- sc = StatusCode::SUCCESS;
- } else {
- ATH_MSG_WARNING("Unable to register callback on global Container with folder " << m_run2L2Folder.value());
- return StatusCode::FAILURE;
- }
-
- if (detStore()->contains<AlignableTransformContainer>(m_run2L3Folder.value())) {
- ATH_MSG_DEBUG("Registering callback on AlignableTransformContainer with folder " << m_run2L3Folder.value());
- const DataHandle<AlignableTransformContainer> atc;
- ATH_CHECK(detStore()->regFcn(&IGeoModelTool::align, dynamic_cast<IGeoModelTool*>(this), atc, m_run2L3Folder.value()));
- sc = StatusCode::SUCCESS;
- } else {
- ATH_MSG_WARNING("Unable to register callback on AlignableTransformContainer with folder " << m_run2L3Folder.value());
- return StatusCode::FAILURE;
- }
+ ATH_MSG_FATAL("Dynamic alignment not supported.");
+ // if (detStore()->contains<CondAttrListCollection>(m_run2L1Folder.value())) {
+ // ATH_MSG_DEBUG("Registering callback on global Container with folder " << m_run2L1Folder.value());
+ // const DataHandle<CondAttrListCollection> calc;
+ // ATH_CHECK(detStore()->regFcn(&IGeoModelTool::align, dynamic_cast<IGeoModelTool*>(this), calc, m_run2L1Folder.value()));
+ // sc = StatusCode::SUCCESS;
+ // } else {
+ // ATH_MSG_WARNING("Unable to register callback on global Container with folder " << m_run2L1Folder.value());
+ // return StatusCode::FAILURE;
+ // }
+
+ // if (detStore()->contains<CondAttrListCollection>(m_run2L2Folder.value())) {
+ // ATH_MSG_DEBUG("Registering callback on global Container with folder " << m_run2L2Folder.value());
+ // const DataHandle<CondAttrListCollection> calc;
+ // ATH_CHECK(detStore()->regFcn(&IGeoModelTool::align, dynamic_cast<IGeoModelTool*>(this), calc, m_run2L2Folder.value()));
+ // sc = StatusCode::SUCCESS;
+ // } else {
+ // ATH_MSG_WARNING("Unable to register callback on global Container with folder " << m_run2L2Folder.value());
+ // return StatusCode::FAILURE;
+ // }
+
+ // if (detStore()->contains<AlignableTransformContainer>(m_run2L3Folder.value())) {
+ // ATH_MSG_DEBUG("Registering callback on AlignableTransformContainer with folder " << m_run2L3Folder.value());
+ // const DataHandle<AlignableTransformContainer> atc;
+ // ATH_CHECK(detStore()->regFcn(&IGeoModelTool::align, dynamic_cast<IGeoModelTool*>(this), atc, m_run2L3Folder.value()));
+ // sc = StatusCode::SUCCESS;
+ // } else {
+ // ATH_MSG_WARNING("Unable to register callback on AlignableTransformContainer with folder " << m_run2L3Folder.value());
+ // return StatusCode::FAILURE;
+ // }
} else {
diff --git a/Tracker/TrackerDetDescr/FaserSCT_GeoModel/src/SCT_DetectorFactory.cxx b/Tracker/TrackerDetDescr/FaserSCT_GeoModel/src/SCT_DetectorFactory.cxx
index bd1efc0e3babcd830449a99433e4af100d45ff00..c13d6942ed5a0ea351b5250033b3d7cc0133aad0 100644
--- a/Tracker/TrackerDetDescr/FaserSCT_GeoModel/src/SCT_DetectorFactory.cxx
+++ b/Tracker/TrackerDetDescr/FaserSCT_GeoModel/src/SCT_DetectorFactory.cxx
@@ -70,6 +70,7 @@ SCT_DetectorFactory::SCT_DetectorFactory(const SCT_GeoModelAthenaComps * athenaC
// Create the detector manager
m_detectorManager = new SCT_DetectorManager(detStore());
+ m_detectorManager->msg(MSG::Level::VERBOSE).setLevel(MSG::Level::VERBOSE);
// Create the database
m_db = new SCT_DataBase{athenaComps};
@@ -169,6 +170,89 @@ void SCT_DetectorFactory::create(GeoPhysVol *world)
m_detectorManager->numerology().setMaxNumPhiCells(m_detectorManager->getSCT_Design(iDesign)->cells());
}
+ // Register the keys and the level corresponding to the key
+ // and whether it expects a global or local shift.
+ // level 0: sensor, level 1: module, level 2, layer/disc, level 3: whole barrel/enccap
+
+
+ if (!m_useDynamicAlignFolders){
+
+ m_detectorManager->addAlignFolderType(TrackerDD::static_run1);
+ m_detectorManager->addFolder("/Tracker/Align");
+ m_detectorManager->addChannel("/Tracker/Align/Tracker", 3, TrackerDD::global);
+ // m_detectorManager->addFolder("/Indet/Align");
+ // m_detectorManager->addChannel("/Indet/Align/ID",3,InDetDD::global);
+ // m_detectorManager->addChannel("/Indet/Align/SCT",2,InDetDD::global);
+
+ // if (barrelPresent) {
+ // m_detectorManager->addChannel("/Indet/Align/SCTB1",1,InDetDD::local);
+ // m_detectorManager->addChannel("/Indet/Align/SCTB2",1,InDetDD::local);
+ // m_detectorManager->addChannel("/Indet/Align/SCTB3",1,InDetDD::local);
+ // m_detectorManager->addChannel("/Indet/Align/SCTB4",1,InDetDD::local);
+ // }
+ // if (forwardPlusPresent) {
+ // m_detectorManager->addChannel("/Indet/Align/SCTEA1",1,InDetDD::local);
+ // m_detectorManager->addChannel("/Indet/Align/SCTEA2",1,InDetDD::local);
+ // m_detectorManager->addChannel("/Indet/Align/SCTEA3",1,InDetDD::local);
+ // m_detectorManager->addChannel("/Indet/Align/SCTEA4",1,InDetDD::local);
+ // m_detectorManager->addChannel("/Indet/Align/SCTEA5",1,InDetDD::local);
+ // m_detectorManager->addChannel("/Indet/Align/SCTEA6",1,InDetDD::local);
+ // m_detectorManager->addChannel("/Indet/Align/SCTEA7",1,InDetDD::local);
+ // m_detectorManager->addChannel("/Indet/Align/SCTEA8",1,InDetDD::local);
+ // m_detectorManager->addChannel("/Indet/Align/SCTEA9",1,InDetDD::local);
+ // }
+ // if (forwardMinusPresent) {
+ // m_detectorManager->addChannel("/Indet/Align/SCTEC1",1,InDetDD::local);
+ // m_detectorManager->addChannel("/Indet/Align/SCTEC2",1,InDetDD::local);
+ // m_detectorManager->addChannel("/Indet/Align/SCTEC3",1,InDetDD::local);
+ // m_detectorManager->addChannel("/Indet/Align/SCTEC4",1,InDetDD::local);
+ // m_detectorManager->addChannel("/Indet/Align/SCTEC5",1,InDetDD::local);
+ // m_detectorManager->addChannel("/Indet/Align/SCTEC6",1,InDetDD::local);
+ // m_detectorManager->addChannel("/Indet/Align/SCTEC7",1,InDetDD::local);
+ // m_detectorManager->addChannel("/Indet/Align/SCTEC8",1,InDetDD::local);
+ // m_detectorManager->addChannel("/Indet/Align/SCTEC9",1,InDetDD::local);
+ // }
+ }
+
+ else {
+ msg(MSG::FATAL) << "Dynamic alignment not supported." << endmsg;
+ // m_detectorManager->addAlignFolderType(TrackerDD::timedependent_run2);
+ // m_detectorManager->addGlobalFolder("/Indet/AlignL1/ID");
+ // m_detectorManager->addGlobalFolder("/Indet/AlignL2/SCT");
+ // m_detectorManager->addChannel("/Indet/AlignL1/ID",3,InDetDD::global);
+ // m_detectorManager->addChannel("/Indet/AlignL2/SCT",2,InDetDD::global);
+ // m_detectorManager->addFolder("/Indet/AlignL3");
+
+ // if (barrelPresent) {
+ // m_detectorManager->addChannel("/Indet/AlignL3/SCTB1",1,InDetDD::local);
+ // m_detectorManager->addChannel("/Indet/AlignL3/SCTB2",1,InDetDD::local);
+ // m_detectorManager->addChannel("/Indet/AlignL3/SCTB3",1,InDetDD::local);
+ // m_detectorManager->addChannel("/Indet/AlignL3/SCTB4",1,InDetDD::local);
+ // }
+ // if (forwardPlusPresent) {
+ // m_detectorManager->addChannel("/Indet/AlignL3/SCTEA1",1,InDetDD::local);
+ // m_detectorManager->addChannel("/Indet/AlignL3/SCTEA2",1,InDetDD::local);
+ // m_detectorManager->addChannel("/Indet/AlignL3/SCTEA3",1,InDetDD::local);
+ // m_detectorManager->addChannel("/Indet/AlignL3/SCTEA4",1,InDetDD::local);
+ // m_detectorManager->addChannel("/Indet/AlignL3/SCTEA5",1,InDetDD::local);
+ // m_detectorManager->addChannel("/Indet/AlignL3/SCTEA6",1,InDetDD::local);
+ // m_detectorManager->addChannel("/Indet/AlignL3/SCTEA7",1,InDetDD::local);
+ // m_detectorManager->addChannel("/Indet/AlignL3/SCTEA8",1,InDetDD::local);
+ // m_detectorManager->addChannel("/Indet/AlignL3/SCTEA9",1,InDetDD::local);
+ // }
+ // if (forwardMinusPresent) {
+ // m_detectorManager->addChannel("/Indet/AlignL3/SCTEC1",1,InDetDD::local);
+ // m_detectorManager->addChannel("/Indet/AlignL3/SCTEC2",1,InDetDD::local);
+ // m_detectorManager->addChannel("/Indet/AlignL3/SCTEC3",1,InDetDD::local);
+ // m_detectorManager->addChannel("/Indet/AlignL3/SCTEC4",1,InDetDD::local);
+ // m_detectorManager->addChannel("/Indet/AlignL3/SCTEC5",1,InDetDD::local);
+ // m_detectorManager->addChannel("/Indet/AlignL3/SCTEC6",1,InDetDD::local);
+ // m_detectorManager->addChannel("/Indet/AlignL3/SCTEC7",1,InDetDD::local);
+ // m_detectorManager->addChannel("/Indet/AlignL3/SCTEC8",1,InDetDD::local);
+ // m_detectorManager->addChannel("/Indet/AlignL3/SCTEC9",1,InDetDD::local);
+ // }
+ }
+
// Return precision to its original value
std::cout.precision(oldPrecision);
diff --git a/Tracker/TrackerDigitization/FaserSCT_Digitization/CMakeLists.txt b/Tracker/TrackerDigitization/FaserSCT_Digitization/CMakeLists.txt
index d0965e8dc9ed2520312a1eab0fc8b8cb0ead9e8a..73035d82bba531194e66a79598f1a3764c7696f4 100644
--- a/Tracker/TrackerDigitization/FaserSCT_Digitization/CMakeLists.txt
+++ b/Tracker/TrackerDigitization/FaserSCT_Digitization/CMakeLists.txt
@@ -14,21 +14,22 @@ atlas_depends_on_subdirs( PUBLIC
DetectorDescription/Identifier
Event/xAOD/xAODEventInfo
GaudiKernel
- InnerDetector/InDetConditions/InDetCondTools
+ Tracker/TrackerConditions/TrackerCondTools
Tracker/TrackerDigitization/FaserSiDigitization
- InnerDetector/InDetRawEvent/InDetRawData
+ Tracker/TrackerRawEvent/TrackerRawData
Tracker/TrackerSimEvent
Simulation/HitManagement
PRIVATE
Control/StoreGate
Generators/GeneratorObjects
- #InnerDetector/InDetConditions/InDetConditionsSummaryService
- #InnerDetector/InDetConditions/SCT_ConditionsTools
- InnerDetector/InDetConditions/SiPropertiesTool
+ InnerDetector/InDetConditions/InDetConditionsSummaryService
+ InnerDetector/InDetConditions/SCT_ConditionsTools # for interfaces
+ Tracker/TrackerConditions/FaserSCT_ConditionsTools
+ Tracker/TrackerConditions/FaserSiPropertiesTool
Tracker/TrackerDetDescr/TrackerIdentifier
Tracker/TrackerDetDescr/TrackerReadoutGeometry
#InnerDetector/InDetDetDescr/SCT_ModuleDistortions
- InnerDetector/InDetRawEvent/InDetSimData )
+ Tracker/TrackerRawEvent/TrackerSimData )
# External dependencies:
find_package( Boost COMPONENTS filesystem thread system )
@@ -40,8 +41,8 @@ atlas_add_component( FaserSCT_Digitization
src/*.cxx
src/components/*.cxx
INCLUDE_DIRS ${ROOT_INCLUDE_DIRS} ${Boost_INCLUDE_DIRS} ${CLHEP_INCLUDE_DIRS}
- LINK_LIBRARIES ${ROOT_LIBRARIES} ${Boost_LIBRARIES} ${CLHEP_LIBRARIES} AthenaBaseComps AthenaKernel PileUpToolsLib Identifier xAODEventInfo GaudiKernel FaserSiDigitization InDetRawData TrackerSimEvent HitManagement GeneratorObjects SiPropertiesToolLib TrackerIdentifier TrackerReadoutGeometry InDetSimData )
-# LINK_LIBRARIES ${ROOT_LIBRARIES} ${Boost_LIBRARIES} ${CLHEP_LIBRARIES} CommissionEvent AthenaBaseComps AthenaKernel PileUpToolsLib Identifier xAODEventInfo GaudiKernel SiDigitization InDetRawData InDetSimEvent HitManagement GeneratorObjects SiPropertiesToolLib InDetIdentifier InDetReadoutGeometry InDetSimData )
+ LINK_LIBRARIES ${ROOT_LIBRARIES} ${Boost_LIBRARIES} ${CLHEP_LIBRARIES} AthenaBaseComps AthenaKernel PileUpToolsLib Identifier xAODEventInfo GaudiKernel FaserSiDigitization TrackerRawData TrackerSimEvent HitManagement GeneratorObjects FaserSiPropertiesToolLib TrackerIdentifier TrackerReadoutGeometry TrackerSimData )
+# LINK_LIBRARIES ${ROOT_LIBRARIES} ${Boost_LIBRARIES} ${CLHEP_LIBRARIES} CommissionEvent AthenaBaseComps AthenaKernel PileUpToolsLib Identifier xAODEventInfo GaudiKernel SiDigitization InDetRawData InDetSimEvent HitManagement GeneratorObjects FaserSiPropertiesToolLib InDetIdentifier InDetReadoutGeometry InDetSimData )
#atlas_add_test( SCT_DigitizationMT_test
# SCRIPT Digi_tf.py --inputHITSFile /cvmfs/atlas-nightlies.cern.ch/repo/data/data-art/DigitizationTests/HITS.04919495._001041.pool.root.1 --conditionsTag default:OFLCOND-RUN12-SDR-25 --digiSeedOffset1 170 --digiSeedOffset2 170 --geometryVersion ATLAS-R2-2015-03-01-00 --DataRunNumber 222525 --outputRDOFile mc15_2015_ttbar.RDO.pool.root --preInclude HITtoRDO:SimulationJobOptions/preInclude.SCTOnlyConfig.py,Digitization/ForceUseOfAlgorithms.py --postInclude Digitization/FixDataDependenciesForMT.py --skipEvents 0 --maxEvents 100 --athenaopts=--threads=10
diff --git a/Tracker/TrackerDigitization/FaserSCT_Digitization/python/FaserSCT_DigitizationConfig.py b/Tracker/TrackerDigitization/FaserSCT_Digitization/python/FaserSCT_DigitizationConfig.py
index 42b92ef195088b1390cbae4fd21e455f02d1151b..efeba22b22474a433802cec7a2560523e6058f5f 100644
--- a/Tracker/TrackerDigitization/FaserSCT_Digitization/python/FaserSCT_DigitizationConfig.py
+++ b/Tracker/TrackerDigitization/FaserSCT_Digitization/python/FaserSCT_DigitizationConfig.py
@@ -3,36 +3,36 @@
from AthenaCommon import CfgMgr
# The earliest bunch crossing time for which interactions will be sent
# to the SCT Digitization code.
-def SCT_FirstXing():
+def FaserSCT_FirstXing():
return -50
# The latest bunch crossing time for which interactions will be sent
# to the SCT Digitization code.
-def SCT_LastXing():
+def FaserSCT_LastXing():
return 25
######################################################################################
-def getSCT_RandomDisabledCellGenerator(name="SCT_RandomDisabledCellGenerator", **kwargs):
+def getFaserSCT_RandomDisabledCellGenerator(name="FaserSCT_RandomDisabledCellGenerator", **kwargs):
kwargs.setdefault("TotalBadChannels", 0.01)
- from FaserSCT_Digitization.FaserSCT_DigitizationConf import SCT_RandomDisabledCellGenerator
- return SCT_RandomDisabledCellGenerator(name, **kwargs)
+ from FaserSCT_Digitization.FaserSCT_DigitizationConf import FaserSCT_RandomDisabledCellGenerator
+ return FaserSCT_RandomDisabledCellGenerator(name, **kwargs)
######################################################################################
-def getSCT_Amp(name="SCT_Amp", **kwargs):
+def getFaserSCT_Amp(name="FaserSCT_Amp", **kwargs):
kwargs.setdefault("CrossFactor2sides", 0.1)
kwargs.setdefault("CrossFactorBack", 0.07)
kwargs.setdefault("PeakTime", 21)
kwargs.setdefault("deltaT", 1.0)
kwargs.setdefault("Tmin", -25.0)
kwargs.setdefault("Tmax", 150.0)
- from FaserSCT_Digitization.FaserSCT_DigitizationConf import SCT_Amp
- return SCT_Amp(name, **kwargs)
+ from FaserSCT_Digitization.FaserSCT_DigitizationConf import FaserSCT_Amp
+ return FaserSCT_Amp(name, **kwargs)
######################################################################################
-def getSCT_SurfaceChargesGenerator(name="SCT_SurfaceChargesGenerator", **kwargs):
+def getFaserSCT_SurfaceChargesGenerator(name="FaserSCT_SurfaceChargesGenerator", **kwargs):
## Set up services used by SCT_SurfaceChargesGenerator
# Set up SCT_DCSConditiosnTool
from SCT_ConditionsTools.SCT_DCSConditionsToolSetup import SCT_DCSConditionsToolSetup
@@ -44,8 +44,8 @@ def getSCT_SurfaceChargesGenerator(name="SCT_SurfaceChargesGenerator", **kwargs)
sct_SiliconConditionsToolSetup.setDcsTool(sct_DCSConditionsToolSetup.getTool())
sct_SiliconConditionsToolSetup.setup()
# Set up SCT_SiPropertiesTool
- from SiPropertiesTool.SCT_SiPropertiesToolSetup import SCT_SiPropertiesToolSetup
- sct_SiPropertiesToolSetup = SCT_SiPropertiesToolSetup()
+ from FaserSiPropertiesTool.FaserSCT_SiPropertiesToolSetup import FaserSCT_SiPropertiesToolSetup
+ sct_SiPropertiesToolSetup = FaserSCT_SiPropertiesToolSetup()
sct_SiPropertiesToolSetup.setSiliconTool(sct_SiliconConditionsToolSetup.getTool())
sct_SiPropertiesToolSetup.setup()
## Charge trapping tool - used by SCT_SurfaceChargesGenerator
@@ -68,24 +68,24 @@ def getSCT_SurfaceChargesGenerator(name="SCT_SurfaceChargesGenerator", **kwargs)
# kwargs.setdefault("doTrapping", True) # ATL-INDET-INT-2016-019
- from Digitization.DigitizationFlags import digitizationFlags
- if 'doDetailedSurfChargesGen' in digitizationFlags.experimentalDigi():
- kwargs.setdefault("ChargeDriftModel", 1)
- kwargs.setdefault("EFieldModel", 2)
- kwargs.setdefault("MagneticField", -2.0)
- kwargs.setdefault("SensorTemperature", 273.15)
- kwargs.setdefault("TransportTimeStep", 0.25)
- kwargs.setdefault("TransportTimeMax", 25.0)
- from FaserSCT_Digitization.FaserSCT_DigitizationConf import SCT_DetailedSurfaceChargesGenerator
- return SCT_DetailedSurfaceChargesGenerator(name, **kwargs)
- else:
- from SCT_ConditionsTools.SCT_ConditionsToolsConf import SCT_RadDamageSummaryTool
- kwargs.setdefault("RadDamageSummaryTool", SCT_RadDamageSummaryTool(name = "InDetSCT_RadDamageSummaryTool"))
- from FaserSCT_Digitization.FaserSCT_DigitizationConf import SCT_SurfaceChargesGenerator
- return SCT_SurfaceChargesGenerator(name, **kwargs)
+ # from Digitization.DigitizationFlags import digitizationFlags
+ # if 'doDetailedSurfChargesGen' in digitizationFlags.experimentalDigi():
+ # kwargs.setdefault("ChargeDriftModel", 1)
+ # kwargs.setdefault("EFieldModel", 2)
+ # kwargs.setdefault("MagneticField", -2.0)
+ # kwargs.setdefault("SensorTemperature", 273.15)
+ # kwargs.setdefault("TransportTimeStep", 0.25)
+ # kwargs.setdefault("TransportTimeMax", 25.0)
+ # from FaserSCT_Digitization.FaserSCT_DigitizationConf import SCT_DetailedSurfaceChargesGenerator
+ # return SCT_DetailedSurfaceChargesGenerator(name, **kwargs)
+ # else:
+ # from SCT_ConditionsTools.SCT_ConditionsToolsConf import SCT_RadDamageSummaryTool
+ # kwargs.setdefault("RadDamageSummaryTool", SCT_RadDamageSummaryTool(name = "InDetSCT_RadDamageSummaryTool"))
+ from FaserSCT_Digitization.FaserSCT_DigitizationConf import FaserSCT_SurfaceChargesGenerator
+ return FaserSCT_SurfaceChargesGenerator(name, **kwargs)
######################################################################################
-def getSCT_FrontEnd(name="SCT_FrontEnd", **kwargs):
+def getFaserSCT_FrontEnd(name="FaserSCT_FrontEnd", **kwargs):
from Digitization.DigitizationFlags import digitizationFlags
#Setup noise treament in SCT_FrontEnd
# To set the mean noise values for the different module types
@@ -105,7 +105,7 @@ def getSCT_FrontEnd(name="SCT_FrontEnd", **kwargs):
# If noise is turned off:
if not digitizationFlags.doInDetNoise.get_Value():
###kwargs.setdefault("OnlyHitElements", True)
- print('SCT_Digitization:::: Turned off Noise in SCT_FrontEnd')
+ print('FaserSCT_Digitization:::: Turned off Noise in FaserSCT_FrontEnd')
kwargs.setdefault("NoiseOn", False)
kwargs.setdefault("AnalogueNoiseOn", False)
else:
@@ -139,11 +139,11 @@ def getSCT_FrontEnd(name="SCT_FrontEnd", **kwargs):
kwargs.setdefault("DataReadOutMode", 0)
else:
kwargs.setdefault("DataReadOutMode", 1)
- from FaserSCT_Digitization.FaserSCT_DigitizationConf import SCT_FrontEnd
- return SCT_FrontEnd(name, **kwargs)
+ from FaserSCT_Digitization.FaserSCT_DigitizationConf import FaserSCT_FrontEnd
+ return FaserSCT_FrontEnd(name, **kwargs)
######################################################################################
-def getPileupSCT_FrontEnd(name="PileupSCT_FrontEnd", **kwargs):
+def getPileupFaserSCT_FrontEnd(name="PileupFaserSCT_FrontEnd", **kwargs):
kwargs.setdefault("NoiseBarrel", 0.0)
kwargs.setdefault("NoiseBarrel3", 0.0)
@@ -159,12 +159,12 @@ def getPileupSCT_FrontEnd(name="PileupSCT_FrontEnd", **kwargs):
kwargs.setdefault("NOOuters", 0.0)
kwargs.setdefault("NoiseOn", False)
- return getSCT_FrontEnd(name, **kwargs)
+ return getFaserSCT_FrontEnd(name, **kwargs)
######################################################################################
-def commonSCT_DigitizationConfig(name,**kwargs):
+def commonFaserSCT_DigitizationConfig(name,**kwargs):
from Digitization.DigitizationFlags import digitizationFlags
# If noise is turned off:
@@ -192,14 +192,14 @@ def commonSCT_DigitizationConfig(name,**kwargs):
kwargs.setdefault("LastXing", SCT_LastXing() )
from AthenaCommon import CfgMgr
- return CfgMgr.SCT_DigitizationTool(name,**kwargs)
+ return CfgMgr.FaserSCT_DigitizationTool(name,**kwargs)
# else:
# from AthenaCommon import CfgMgr
# return CfgMgr.SCT_Digitization(name, **kwargs)
######################################################################################
-def SCT_DigitizationTool(name="SCT_DigitizationTool", **kwargs):
+def FaserSCT_DigitizationTool(name="FaserSCT_DigitizationTool", **kwargs):
from Digitization.DigitizationFlags import digitizationFlags
if digitizationFlags.PileUpPremixing and 'OverlayMT' in digitizationFlags.experimentalDigi():
from OverlayCommonAlgs.OverlayFlags import overlayFlags
@@ -209,47 +209,47 @@ def SCT_DigitizationTool(name="SCT_DigitizationTool", **kwargs):
kwargs.setdefault("OutputObjectName", "SCT_RDOs")
kwargs.setdefault("OutputSDOName", "SCT_SDO_Map")
- kwargs.setdefault("HardScatterSplittingMode", 0)
- return commonSCT_DigitizationConfig(name,**kwargs)
+ # kwargs.setdefault("HardScatterSplittingMode", 0)
+ return commonFaserSCT_DigitizationConfig(name,**kwargs)
######################################################################################
-def SCT_GeantinoTruthDigitizationTool(name="SCT_GeantinoTruthDigitizationTool", **kwargs):
+def FaserSCT_GeantinoTruthDigitizationTool(name="FaserSCT_GeantinoTruthDigitizationTool", **kwargs):
kwargs.setdefault("ParticleBarcodeVeto", 0)
- return SCT_DigitizationTool(name,**kwargs)
+ return FaserSCT_DigitizationTool(name,**kwargs)
######################################################################################
-def SCT_DigitizationToolHS(name="SCT_DigitizationToolHS",**kwargs):
+def FaserSCT_DigitizationToolHS(name="FaserSCT_DigitizationToolHS",**kwargs):
kwargs.setdefault("OutputObjectName", "SCT_RDOs")
kwargs.setdefault("OutputSDOName", "SCT_SDO_Map")
- kwargs.setdefault("HardScatterSplittingMode", 1)
- return commonSCT_DigitizationConfig(name,**kwargs)
+ # kwargs.setdefault("HardScatterSplittingMode", 1)
+ return commonFaserSCT_DigitizationConfig(name,**kwargs)
######################################################################################
-def SCT_DigitizationToolPU(name="SCT_DigitizationToolPU",**kwargs):
+def FaserSCT_DigitizationToolPU(name="FaserSCT_DigitizationToolPU",**kwargs):
kwargs.setdefault("OutputObjectName", "SCT_PU_RDOs")
kwargs.setdefault("OutputSDOName", "SCT_PU_SDO_Map")
- kwargs.setdefault("HardScatterSplittingMode", 2)
- return commonSCT_DigitizationConfig(name,**kwargs)
+ # kwargs.setdefault("HardScatterSplittingMode", 2)
+ return commonFaserSCT_DigitizationConfig(name,**kwargs)
######################################################################################
-def SCT_DigitizationToolSplitNoMergePU(name="SCT_DigitizationToolSplitNoMergePU",**kwargs):
+def FaserSCT_DigitizationToolSplitNoMergePU(name="FaserSCT_DigitizationToolSplitNoMergePU",**kwargs):
kwargs.setdefault("InputObjectName", "PileupSCT_Hits")
- kwargs.setdefault("HardScatterSplittingMode", 0)
+ # kwargs.setdefault("HardScatterSplittingMode", 0)
kwargs.setdefault("OutputObjectName", "SCT_PU_RDOs")
kwargs.setdefault("OutputSDOName", "SCT_PU_SDO_Map")
kwargs.setdefault("OnlyHitElements", True)
- kwargs.setdefault("FrontEnd", "PileupSCT_FrontEnd")
+ kwargs.setdefault("FrontEnd", "PileupFaserSCT_FrontEnd")
- return commonSCT_DigitizationConfig(name,**kwargs)
+ return commonFaserSCT_DigitizationConfig(name,**kwargs)
######################################################################################
-def SCT_OverlayDigitizationTool(name="SCT_OverlayDigitizationTool",**kwargs):
+def FaserSCT_OverlayDigitizationTool(name="FaserSCT_OverlayDigitizationTool",**kwargs):
from OverlayCommonAlgs.OverlayFlags import overlayFlags
if overlayFlags.isOverlayMT():
kwargs.setdefault("OnlyUseContainerName", False)
@@ -258,40 +258,40 @@ def SCT_OverlayDigitizationTool(name="SCT_OverlayDigitizationTool",**kwargs):
else:
kwargs.setdefault("OutputObjectName", overlayFlags.evtStore() + "+SCT_RDOs")
kwargs.setdefault("OutputSDOName", overlayFlags.evtStore() + "+SCT_SDO_Map")
- kwargs.setdefault("HardScatterSplittingMode", 0)
- return commonSCT_DigitizationConfig(name,**kwargs)
+ # kwargs.setdefault("HardScatterSplittingMode", 0)
+ return commonFaserSCT_DigitizationConfig(name,**kwargs)
######################################################################################
-def getSiliconRange(name="SiliconRange" , **kwargs):
+def getFaserSiliconRange(name="FaserSiliconRange" , **kwargs):
#this is the time of the xing in ns
- kwargs.setdefault('FirstXing', SCT_FirstXing() )
- kwargs.setdefault('LastXing', SCT_LastXing() )
+ kwargs.setdefault('FirstXing', FaserSCT_FirstXing() )
+ kwargs.setdefault('LastXing', FaserSCT_LastXing() )
kwargs.setdefault('CacheRefreshFrequency', 1.0 ) #default 0 no dataproxy reset
- kwargs.setdefault('ItemList', ["SiHitCollection#SCT_Hits"] )
+ kwargs.setdefault('ItemList', ["FaserSiHitCollection#SCT_Hits"] )
return CfgMgr.PileUpXingFolder(name, **kwargs)
######################################################################################
-def SCT_DigitizationHS(name="SCT_DigitizationHS",**kwargs):
- kwargs.setdefault("DigitizationTool", "SCT_DigitizationToolHS")
- from FaserSCT_Digitization.FaserSCT_DigitizationConf import SCT_Digitization
- return SCT_Digitization(name,**kwargs)
+def FaserSCT_DigitizationHS(name="FaserSCT_DigitizationHS",**kwargs):
+ kwargs.setdefault("DigitizationTool", "FaserSCT_DigitizationToolHS")
+ from FaserSCT_Digitization.FaserSCT_DigitizationConf import FaserSCT_Digitization
+ return FaserSCT_Digitization(name,**kwargs)
######################################################################################
-def SCT_DigitizationPU(name="SCT_DigitizationPU",**kwargs):
- kwargs.setdefault("DigitizationTool", "SCT_DigitizationToolPU")
- return CfgMgr.SCT_Digitization(name,**kwargs)
+def FaserSCT_DigitizationPU(name="FaserSCT_DigitizationPU",**kwargs):
+ kwargs.setdefault("DigitizationTool", "FaserSCT_DigitizationToolPU")
+ return CfgMgr.FaserSCT_Digitization(name,**kwargs)
######################################################################################
-def SCT_OverlayDigitization(name="SCT_OverlayDigitization",**kwargs):
- kwargs.setdefault("DigitizationTool", "SCT_OverlayDigitizationTool")
+def FaserSCT_OverlayDigitization(name="FaserSCT_OverlayDigitization",**kwargs):
+ kwargs.setdefault("DigitizationTool", "FaserSCT_OverlayDigitizationTool")
# Multi-threading settinggs
from AthenaCommon.ConcurrencyFlags import jobproperties as concurrencyProps
is_hive = (concurrencyProps.ConcurrencyFlags.NumThreads() > 0)
if is_hive:
kwargs.setdefault('Cardinality', concurrencyProps.ConcurrencyFlags.NumThreads())
- return CfgMgr.SCT_Digitization(name,**kwargs)
+ return CfgMgr.FaserSCT_Digitization(name,**kwargs)
diff --git a/Tracker/TrackerDigitization/FaserSCT_Digitization/python/FaserSCT_DigitizationConfigDb.py b/Tracker/TrackerDigitization/FaserSCT_Digitization/python/FaserSCT_DigitizationConfigDb.py
index 11d8480f3c69a0e2c8e0b93a1844e522b24443e1..7bb90e227ca96d2d34da31c54f9c969b2040ecd7 100644
--- a/Tracker/TrackerDigitization/FaserSCT_Digitization/python/FaserSCT_DigitizationConfigDb.py
+++ b/Tracker/TrackerDigitization/FaserSCT_Digitization/python/FaserSCT_DigitizationConfigDb.py
@@ -1,18 +1,18 @@
# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
from AthenaCommon.CfgGetter import addTool,addService,addAlgorithm
-addTool("FaserSCT_Digitization.FaserSCT_DigitizationConfig.SCT_DigitizationTool" , "SCT_DigitizationTool")
-addTool("FaserSCT_Digitization.FaserSCT_DigitizationConfig.SCT_GeantinoTruthDigitizationTool" , "SCT_GeantinoTruthDigitizationTool")
-addTool("FaserSCT_Digitization.FaserSCT_DigitizationConfig.SCT_DigitizationToolHS" , "SCT_DigitizationToolHS")
-addTool("FaserSCT_Digitization.FaserSCT_DigitizationConfig.SCT_DigitizationToolPU" , "SCT_DigitizationToolPU")
-addTool("FaserSCT_Digitization.FaserSCT_DigitizationConfig.SCT_DigitizationToolSplitNoMergePU", "SCT_DigitizationToolSplitNoMergePU")
-addAlgorithm("FaserSCT_Digitization.FaserSCT_DigitizationConfig.SCT_DigitizationHS" , "SCT_DigitizationHS")
-addAlgorithm("FaserSCT_Digitization.FaserSCT_DigitizationConfig.SCT_DigitizationPU" , "SCT_DigitizationPU")
-addTool("FaserSCT_Digitization.FaserSCT_DigitizationConfig.getSiliconRange" , "SiliconRange" )
-addTool("FaserSCT_Digitization.FaserSCT_DigitizationConfig.getSCT_RandomDisabledCellGenerator", "SCT_RandomDisabledCellGenerator")
-addTool("FaserSCT_Digitization.FaserSCT_DigitizationConfig.getSCT_Amp", "SCT_Amp" )
-addTool("FaserSCT_Digitization.FaserSCT_DigitizationConfig.getSCT_FrontEnd" , "SCT_FrontEnd" )
-addTool("FaserSCT_Digitization.FaserSCT_DigitizationConfig.getPileupSCT_FrontEnd" , "PileupSCT_FrontEnd" )
-addTool("FaserSCT_Digitization.FaserSCT_DigitizationConfig.getSCT_SurfaceChargesGenerator", "SCT_SurfaceChargesGenerator" )
-addTool("FaserSCT_Digitization.FaserSCT_DigitizationConfig.SCT_OverlayDigitizationTool", "SCT_OverlayDigitizationTool")
-addAlgorithm("FaserSCT_Digitization.FaserSCT_DigitizationConfig.SCT_OverlayDigitization", "SCT_OverlayDigitization")
+addTool("FaserSCT_Digitization.FaserSCT_DigitizationConfig.FaserSCT_DigitizationTool" , "FaserSCT_DigitizationTool")
+addTool("FaserSCT_Digitization.FaserSCT_DigitizationConfig.FaserSCT_GeantinoTruthDigitizationTool" , "FaserSCT_GeantinoTruthDigitizationTool")
+addTool("FaserSCT_Digitization.FaserSCT_DigitizationConfig.FaserSCT_DigitizationToolHS" , "FaserSCT_DigitizationToolHS")
+addTool("FaserSCT_Digitization.FaserSCT_DigitizationConfig.FaserSCT_DigitizationToolPU" , "FaserSCT_DigitizationToolPU")
+addTool("FaserSCT_Digitization.FaserSCT_DigitizationConfig.FaserSCT_DigitizationToolSplitNoMergePU", "FaserSCT_DigitizationToolSplitNoMergePU")
+addAlgorithm("FaserSCT_Digitization.FaserSCT_DigitizationConfig.FaserSCT_DigitizationHS" , "FaserSCT_DigitizationHS")
+addAlgorithm("FaserSCT_Digitization.FaserSCT_DigitizationConfig.FaserSCT_DigitizationPU" , "FaserSCT_DigitizationPU")
+addTool("FaserSCT_Digitization.FaserSCT_DigitizationConfig.getFaserSiliconRange" , "FaserSiliconRange" )
+addTool("FaserSCT_Digitization.FaserSCT_DigitizationConfig.getFaserSCT_RandomDisabledCellGenerator", "FaserSCT_RandomDisabledCellGenerator")
+addTool("FaserSCT_Digitization.FaserSCT_DigitizationConfig.getFaserSCT_Amp", "FaserSCT_Amp" )
+addTool("FaserSCT_Digitization.FaserSCT_DigitizationConfig.getFaserSCT_FrontEnd" , "FaserSCT_FrontEnd" )
+addTool("FaserSCT_Digitization.FaserSCT_DigitizationConfig.getFaserPileupSCT_FrontEnd" , "PileupFaserSCT_FrontEnd" )
+addTool("FaserSCT_Digitization.FaserSCT_DigitizationConfig.getFaserSCT_SurfaceChargesGenerator", "FaserSCT_SurfaceChargesGenerator" )
+addTool("FaserSCT_Digitization.FaserSCT_DigitizationConfig.FaserSCT_OverlayDigitizationTool", "FaserSCT_OverlayDigitizationTool")
+addAlgorithm("FaserSCT_Digitization.FaserSCT_DigitizationConfig.FaserSCT_OverlayDigitization", "FaserSCT_OverlayDigitization")
diff --git a/Tracker/TrackerDigitization/FaserSCT_Digitization/python/FaserSCT_DigitizationConfigNew.py b/Tracker/TrackerDigitization/FaserSCT_Digitization/python/FaserSCT_DigitizationConfigNew.py
index 92b74cad966602cd7e9b9046cba428534805f7fd..a0108cf58b15244f4b59452752dbaa9d9b26122d 100644
--- a/Tracker/TrackerDigitization/FaserSCT_Digitization/python/FaserSCT_DigitizationConfigNew.py
+++ b/Tracker/TrackerDigitization/FaserSCT_Digitization/python/FaserSCT_DigitizationConfigNew.py
@@ -6,39 +6,41 @@ from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
from AthenaConfiguration.ComponentFactory import CompFactory
from AthenaCommon.Logging import logging
from FaserSCT_Digitization.FaserSCT_DigitizationConf import (
- SCT_RandomDisabledCellGenerator,
- SCT_Amp,
- SCT_SurfaceChargesGenerator,
- SCT_FrontEnd,
- SCT_DigitizationTool,
- SCT_Digitization,
+ FaserSCT_RandomDisabledCellGenerator,
+ FaserSCT_Amp,
+ FaserSCT_SurfaceChargesGenerator,
+ FaserSCT_FrontEnd,
+ FaserSCT_DigitizationTool,
+ FaserSCT_Digitization
)
PileUpXingFolder=CompFactory.PileUpXingFolder
from OutputStreamAthenaPool.OutputStreamConfig import OutputStreamCfg
#SCT_RadDamageSummaryTool=CompFactory.SCT_RadDamageSummaryTool
-from FaserSCT_GeoModel.FaserSCT_GeoModelConfig import FaserSCT_GeometryCfg
-from SCT_ConditionsTools.SCT_DCSConditionsConfig import SCT_DCSConditionsCfg
-from SCT_ConditionsTools.SCT_SiliconConditionsConfig import SCT_SiliconConditionsToolCfg, SCT_SiliconConditionsCfg
-from SCT_ConditionsTools.SCT_ReadCalibChipDataConfig import SCT_ReadCalibChipDataCfg
-from SiPropertiesTool.SCT_SiPropertiesConfig import SCT_SiPropertiesCfg
-from SiLorentzAngleTool.SCT_LorentzAngleConfig import SCT_LorentzAngleCfg
+from FaserGeoModel.SCTGMConfig import SctGeometryCfg
+
+from FaserSCT_ConditionsTools.FaserSCT_DCSConditionsConfig import FaserSCT_DCSConditionsCfg
+from FaserSCT_ConditionsTools.FaserSCT_SiliconConditionsConfig import FaserSCT_SiliconConditionsToolCfg, FaserSCT_SiliconConditionsCfg
+from FaserSCT_ConditionsTools.FaserSCT_ReadCalibChipDataConfig import FaserSCT_ReadCalibChipDataCfg
+from FaserSiPropertiesTool.FaserSCT_SiPropertiesConfig import FaserSCT_SiPropertiesCfg
+from FaserSiLorentzAngleTool.FaserSCT_LorentzAngleConfig import FaserSCT_LorentzAngleCfg
from Digitization.TruthDigitizationOutputConfig import TruthDigitizationOutputCfg
from Digitization.PileUpToolsConfig import PileUpToolsCfg
# The earliest and last bunch crossing times for which interactions will be sent
# to the SCT Digitization code
-def SCT_FirstXing():
+def FaserSCT_FirstXing():
return -50
-def SCT_LastXing():
+def FaserSCT_LastXing():
return 25
-def SCT_DigitizationCommonCfg(flags, name="SCT_DigitizationToolCommon", **kwargs):
- """Return ComponentAccumulator with common SCT digitization tool config"""
- acc = FaserSCT_GeometryCfg(flags)
+def FaserSCT_DigitizationCommonCfg(flags, name="FaserSCT_DigitizationToolCommon", **kwargs):
+ """Return ComponentAccumulator with common FaserSCT digitization tool config"""
+ acc = SctGeometryCfg(flags)
+
if not flags.Digitization.DoInnerDetectorNoise:
kwargs.setdefault("OnlyHitElements", True)
kwargs.setdefault("InputObjectName", "SCT_Hits")
@@ -49,19 +51,19 @@ def SCT_DigitizationCommonCfg(flags, name="SCT_DigitizationToolCommon", **kwargs
kwargs.setdefault("CosmicsRun", True)
kwargs.setdefault("FixedTime", 10)
if flags.Digitization.DoXingByXingPileUp:
- kwargs.setdefault("FirstXing", SCT_FirstXing())
- kwargs.setdefault("LastXing", SCT_LastXing() )
- tool = SCT_DigitizationTool(name, **kwargs)
+ kwargs.setdefault("FirstXing", FaserSCT_FirstXing())
+ kwargs.setdefault("LastXing", FaserSCT_LastXing() )
+ tool = FaserSCT_DigitizationTool(name, **kwargs)
# attach ToolHandles
- tool.FrontEnd = acc.popToolsAndMerge(SCT_FrontEndCfg(flags))
- tool.SurfaceChargesGenerator = acc.popToolsAndMerge(SCT_SurfaceChargesGeneratorCfg(flags))
- tool.RandomDisabledCellGenerator = SCT_RandomDisabledCellGeneratorCfg(flags)
+ tool.FrontEnd = acc.popToolsAndMerge(FaserSCT_FrontEndCfg(flags))
+ tool.SurfaceChargesGenerator = acc.popToolsAndMerge(FaserSCT_SurfaceChargesGeneratorCfg(flags))
+ tool.RandomDisabledCellGenerator = FaserSCT_RandomDisabledCellGeneratorCfg(flags)
acc.setPrivateTools(tool)
return acc
-def SCT_DigitizationToolCfg(flags, name="SCT_DigitizationTool", **kwargs):
- """Return ComponentAccumulator with configured SCT digitization tool"""
+def FaserSCT_DigitizationToolCfg(flags, name="FaserSCT_DigitizationTool", **kwargs):
+ """Return ComponentAccumulator with configured FaserSCT digitization tool"""
if flags.Digitization.PileUpPremixing:
kwargs.setdefault("OutputObjectName", flags.Overlay.BkgPrefix + "SCT_RDOs")
kwargs.setdefault("OutputSDOName", flags.Overlay.BkgPrefix + "SCT_SDO_Map")
@@ -69,61 +71,61 @@ def SCT_DigitizationToolCfg(flags, name="SCT_DigitizationTool", **kwargs):
kwargs.setdefault("OutputObjectName", "SCT_RDOs")
kwargs.setdefault("OutputSDOName", "SCT_SDO_Map")
#kwargs.setdefault("HardScatterSplittingMode", 0)
- return SCT_DigitizationCommonCfg(flags, name, **kwargs)
+ return FaserSCT_DigitizationCommonCfg(flags, name, **kwargs)
-def SCT_DigitizationHSToolCfg(flags, name="SCT_DigitizationHSTool", **kwargs):
- """Return ComponentAccumulator with hard scatter configured SCT digitization tool"""
+def FaserSCT_DigitizationHSToolCfg(flags, name="FaserSCT_DigitizationHSTool", **kwargs):
+ """Return ComponentAccumulator with hard scatter configured FaserSCT digitization tool"""
kwargs.setdefault("OutputObjectName", "SCT_RDOs")
kwargs.setdefault("OutputSDOName", "SCT_SDO_Map")
#kwargs.setdefault("HardScatterSplittingMode", 1)
- return SCT_DigitizationCommonCfg(flags, name, **kwargs)
+ return FaserSCT_DigitizationCommonCfg(flags, name, **kwargs)
-def SCT_DigitizationPUToolCfg(flags, name="SCT_DigitizationPUTool",**kwargs):
- """Return ComponentAccumulator with pileup configured SCT digitization tool"""
+def FaserSCT_DigitizationPUToolCfg(flags, name="FaserSCT_DigitizationPUTool",**kwargs):
+ """Return ComponentAccumulator with pileup configured FaserSCT digitization tool"""
kwargs.setdefault("OutputObjectName", "SCT_PU_RDOs")
kwargs.setdefault("OutputSDOName", "SCT_PU_SDO_Map")
#kwargs.setdefault("HardScatterSplittingMode", 2)
- return SCT_DigitizationCommonCfg(flags, name, **kwargs)
+ return FaserSCT_DigitizationCommonCfg(flags, name, **kwargs)
-def SCT_OverlayDigitizationToolCfg(flags, name="SCT_OverlayDigitizationTool",**kwargs):
- """Return ComponentAccumulator with overlay configured SCT digitization tool"""
+def FaserSCT_OverlayDigitizationToolCfg(flags, name="FaserSCT_OverlayDigitizationTool",**kwargs):
+ """Return ComponentAccumulator with overlay configured FaserSCT digitization tool"""
acc = ComponentAccumulator()
kwargs.setdefault("OnlyUseContainerName", False)
kwargs.setdefault("OutputObjectName", "StoreGateSvc+" + flags.Overlay.SigPrefix + "SCT_RDOs")
kwargs.setdefault("OutputSDOName", "StoreGateSvc+" + flags.Overlay.SigPrefix + "SCT_SDO_Map")
#kwargs.setdefault("HardScatterSplittingMode", 0)
- tool = acc.popToolsAndMerge(SCT_DigitizationCommonCfg(flags, name, **kwargs))
+ tool = acc.popToolsAndMerge(FaserSCT_DigitizationCommonCfg(flags, name, **kwargs))
acc.setPrivateTools(tool)
return acc
-def SCT_DigitizationToolSplitNoMergePUCfg(flags, name="SCT_DigitizationToolSplitNoMergePU",**kwargs):
- """Return ComponentAccumulator with merged pileup configured SCT digitization tool"""
+def FaserSCT_DigitizationToolSplitNoMergePUCfg(flags, name="FaserSCT_DigitizationToolSplitNoMergePU",**kwargs):
+ """Return ComponentAccumulator with merged pileup configured FaserSCT digitization tool"""
kwargs.setdefault("InputObjectName", "PileupSCT_Hits")
#kwargs.setdefault("HardScatterSplittingMode", 0)
kwargs.setdefault("OutputObjectName", "SCT_PU_RDOs")
kwargs.setdefault("OutputSDOName", "SCT_PU_SDO_Map")
kwargs.setdefault("OnlyHitElements", True)
- kwargs.setdefault("FrontEnd", "PileupSCT_FrontEnd")
- return SCT_DigitizationCommonCfg(flags, name, **kwargs)
+ kwargs.setdefault("FrontEnd", "PileupFaserSCT_FrontEnd")
+ return FaserSCT_DigitizationCommonCfg(flags, name, **kwargs)
-def SCT_DigitizationToolGeantinoTruthCfg(flags, name="SCT_GeantinoTruthDigitizationTool", **kwargs):
+def FaserSCT_DigitizationToolGeantinoTruthCfg(flags, name="FaserSCT_GeantinoTruthDigitizationTool", **kwargs):
"""Return Geantino truth configured digitization tool"""
kwargs.setdefault("ParticleBarcodeVeto", 0)
- return SCT_DigitizationToolCfg(flags, name, **kwargs)
+ return FaserSCT_DigitizationToolCfg(flags, name, **kwargs)
-def SCT_RandomDisabledCellGeneratorCfg(flags, name="SCT_RandomDisabledCellGenerator", **kwargs):
+def FaserSCT_RandomDisabledCellGeneratorCfg(flags, name="FaserSCT_RandomDisabledCellGenerator", **kwargs):
"""Return configured random cell disabling tool"""
kwargs.setdefault("TotalBadChannels", 0.01)
- return SCT_RandomDisabledCellGenerator(name, **kwargs)
+ return FaserSCT_RandomDisabledCellGenerator(name, **kwargs)
-def SCT_AmpCfg(flags, name="SCT_Amp", **kwargs):
+def FaserSCT_AmpCfg(flags, name="FaserSCT_Amp", **kwargs):
"""Return configured amplifier and shaper tool"""
kwargs.setdefault("CrossFactor2sides", 0.1)
kwargs.setdefault("CrossFactorBack", 0.07)
@@ -131,10 +133,10 @@ def SCT_AmpCfg(flags, name="SCT_Amp", **kwargs):
kwargs.setdefault("deltaT", 1.0)
kwargs.setdefault("Tmin", -25.0)
kwargs.setdefault("Tmax", 150.0)
- return SCT_Amp(name, **kwargs)
+ return FaserSCT_Amp(name, **kwargs)
-def SCT_SurfaceChargesGeneratorCfg(flags, name="SCT_SurfaceChargesGenerator", **kwargs):
+def FaserSCT_SurfaceChargesGeneratorCfg(flags, name="FaserSCT_SurfaceChargesGenerator", **kwargs):
"""Return ComponentAccumulator with configured surface charges tool"""
acc = ComponentAccumulator()
kwargs.setdefault("FixedTime", -999)
@@ -147,23 +149,23 @@ def SCT_SurfaceChargesGeneratorCfg(flags, name="SCT_SurfaceChargesGenerator", **
kwargs.setdefault("isOverlay", flags.Detector.Overlay)
# kwargs.setdefault("doTrapping", True) # ATL-INDET-INT-2016-019
# experimental SCT_DetailedSurfaceChargesGenerator config dropped here
- tool = SCT_SurfaceChargesGenerator(name, **kwargs)
+ tool = FaserSCT_SurfaceChargesGenerator(name, **kwargs)
#tool.RadDamageSummaryTool = SCT_RadDamageSummaryTool()
- DCSCondTool = acc.popToolsAndMerge(SCT_DCSConditionsCfg(flags))
- SiliCondTool = SCT_SiliconConditionsToolCfg(flags)
- SiliCondAcc = SCT_SiliconConditionsCfg(flags, DCSConditionsTool=DCSCondTool)
- SiliPropsAcc = SCT_SiPropertiesCfg(flags, SiConditionsTool=SiliCondTool)
+ DCSCondTool = acc.popToolsAndMerge(FaserSCT_DCSConditionsCfg(flags))
+ SiliCondTool = FaserSCT_SiliconConditionsToolCfg(flags)
+ SiliCondAcc = FaserSCT_SiliconConditionsCfg(flags, DCSConditionsTool=DCSCondTool)
+ SiliPropsAcc = FaserSCT_SiPropertiesCfg(flags, SiConditionsTool=SiliCondTool)
acc.merge(SiliCondAcc)
- #tool.SiConditionsTool = SiliCondTool
+ tool.SiConditionsTool = SiliCondTool
tool.SiPropertiesTool = acc.popToolsAndMerge(SiliPropsAcc)
- tool.LorentzAngleTool = acc.popToolsAndMerge(SCT_LorentzAngleCfg(flags))
+ tool.LorentzAngleTool = acc.popToolsAndMerge(FaserSCT_LorentzAngleCfg(flags))
acc.setPrivateTools(tool)
return acc
-def SCT_FrontEndCfg(flags, name="SCT_FrontEnd", **kwargs):
+def FaserSCT_FrontEndCfg(flags, name="FaserSCT_FrontEnd", **kwargs):
"""Return ComponentAccumulator with configured front-end electronics tool"""
- # Setup noise treament in SCT_FrontEnd
+ # Setup noise treament in FaserSCT_FrontEnd
# To set the mean noise values for the different module types
# Default values set at 0 degrees, plus/minus ~5 enc per plus/minus degree
kwargs.setdefault("NoiseBarrel", 1500.0)
@@ -179,8 +181,8 @@ def SCT_FrontEndCfg(flags, name="SCT_FrontEnd", **kwargs):
kwargs.setdefault("NOShortMiddles", 2.0e-9)
kwargs.setdefault("NOOuters", 3.5e-5)
if not flags.Digitization.DoInnerDetectorNoise:
- log = logging.getLogger("SCT_FrontEndCfg")
- log.info("SCT_Digitization:::: Turned off Noise in SCT_FrontEnd")
+ log = logging.getLogger("FaserSCT_FrontEndCfg")
+ log.info("FaserSCT_Digitization:::: Turned off Noise in FaserSCT_FrontEnd")
kwargs.setdefault("NoiseOn", False)
kwargs.setdefault("AnalogueNoiseOn", False)
else:
@@ -193,9 +195,8 @@ def SCT_FrontEndCfg(flags, name="SCT_FrontEnd", **kwargs):
# Use Calibration data from Conditions DB, still for testing purposes only
kwargs.setdefault("UseCalibData", True)
# Setup the ReadCalibChip folders and Svc
- acc = SCT_ReadCalibChipDataCfg(flags)
- garbage = acc.popPrivateTools()
- #kwargs.setdefault("SCT_ReadCalibChipDataTool", acc.popPrivateTools())
+ acc = FaserSCT_ReadCalibChipDataCfg(flags)
+ kwargs.setdefault("SCT_ReadCalibChipDataTool", acc.popPrivateTools())
# DataCompressionMode: 1 is level mode x1x (default), 2 is edge mode 01x, 3 is expanded any hit xxx
if flags.Digitization.PileUpPremixing:
kwargs.setdefault("DataCompressionMode", 3)
@@ -210,11 +211,11 @@ def SCT_FrontEndCfg(flags, name="SCT_FrontEnd", **kwargs):
kwargs.setdefault("DataReadOutMode", 0)
else:
kwargs.setdefault("DataReadOutMode", 1)
- acc.setPrivateTools(SCT_FrontEnd(name, **kwargs))
+ acc.setPrivateTools(FaserSCT_FrontEnd(name, **kwargs))
return acc
-def SCT_FrontEndPileupCfg(flags, name="PileupSCT_FrontEnd", **kwargs):
+def FaserSCT_FrontEndPileupCfg(flags, name="PileupFaserSCT_FrontEnd", **kwargs):
"""Return ComponentAccumulator with pileup-configured front-end electronics tool"""
kwargs.setdefault("NoiseBarrel", 0.0)
kwargs.setdefault("NoiseBarrel3", 0.0)
@@ -229,77 +230,77 @@ def SCT_FrontEndPileupCfg(flags, name="PileupSCT_FrontEnd", **kwargs):
kwargs.setdefault("NOShortMiddles", 0.0)
kwargs.setdefault("NOOuters", 0.0)
kwargs.setdefault("NoiseOn", False)
- return SCT_FrontEndCfg(flags, name, **kwargs)
+ return FaserSCT_FrontEndCfg(flags, name, **kwargs)
-def SCT_RangeCfg(flags, name="SiliconRange", **kwargs):
- """Return an SCT configured PileUpXingFolder tool"""
- kwargs.setdefault("FirstXing", SCT_FirstXing())
- kwargs.setdefault("LastXing", SCT_LastXing())
+def FaserSCT_RangeCfg(flags, name="SiliconRange", **kwargs):
+ """Return a FaserSCT configured PileUpXingFolder tool"""
+ kwargs.setdefault("FirstXing", FaserSCT_FirstXing())
+ kwargs.setdefault("LastXing", FaserSCT_LastXing())
kwargs.setdefault("CacheRefreshFrequency", 1.0) # default 0 no dataproxy reset
kwargs.setdefault("ItemList", ["FaserSiHitCollection#SCT_Hits"] )
return PileUpXingFolder(name, **kwargs)
-def SCT_OutputCfg(flags):
+def FaserSCT_OutputCfg(flags):
"""Return ComponentAccumulator with Output for SCT. Not standalone."""
acc = ComponentAccumulator()
- ItemList = ["SCT_RDO_Container#*"]
+ ItemList = ["FaserSCT_RDO_Container#*"]
if flags.Digitization.TruthOutput:
- ItemList += ["InDetSimDataCollection#*"]
+ ItemList += ["TrackerSimDataCollection#*"]
acc.merge(TruthDigitizationOutputCfg(flags))
acc.merge(OutputStreamCfg(flags, "RDO", ItemList))
return acc
-def SCT_DigitizationBasicCfg(flags, **kwargs):
- """Return ComponentAccumulator for SCT digitization"""
+def FaserSCT_DigitizationBasicCfg(flags, **kwargs):
+ """Return ComponentAccumulator for FaserSCT digitization"""
acc = ComponentAccumulator()
if "PileUpTools" not in kwargs:
- PileUpTools = acc.popToolsAndMerge(SCT_DigitizationToolCfg(flags))
+ PileUpTools = acc.popToolsAndMerge(FaserSCT_DigitizationToolCfg(flags))
kwargs["PileUpTools"] = PileUpTools
acc.merge(PileUpToolsCfg(flags, **kwargs))
return acc
-def SCT_OverlayDigitizationBasicCfg(flags, **kwargs):
- """Return ComponentAccumulator with SCT Overlay digitization"""
+def FaserSCT_OverlayDigitizationBasicCfg(flags, **kwargs):
+ """Return ComponentAccumulator with FaserSCT Overlay digitization"""
acc = ComponentAccumulator()
if "DigitizationTool" not in kwargs:
- tool = acc.popToolsAndMerge(SCT_OverlayDigitizationToolCfg(flags))
+ tool = acc.popToolsAndMerge(FaserSCT_OverlayDigitizationToolCfg(flags))
kwargs["DigitizationTool"] = tool
- acc.addEventAlgo(SCT_Digitization(**kwargs))
+ acc.addEventAlgo(FaserSCT_Digitization(**kwargs))
return acc
# with output defaults
-def SCT_DigitizationCfg(flags, **kwargs):
+def FaserSCT_DigitizationCfg(flags, **kwargs):
"""Return ComponentAccumulator for SCT digitization and Output"""
- acc = SCT_DigitizationBasicCfg(flags, **kwargs)
- acc.merge(SCT_OutputCfg(flags))
+ acc = FaserSCT_DigitizationBasicCfg(flags, **kwargs)
+ acc.merge(FaserSCT_OutputCfg(flags))
return acc
-def SCT_OverlayDigitizationCfg(flags, **kwargs):
- """Return ComponentAccumulator with SCT Overlay digitization and Output"""
- acc = SCT_OverlayDigitizationBasicCfg(flags, **kwargs)
- acc.merge(SCT_OutputCfg(flags))
+def FaserSCT_OverlayDigitizationCfg(flags, **kwargs):
+ """Return ComponentAccumulator with FaserSCT Overlay digitization and Output"""
+ acc = FaserSCT_OverlayDigitizationBasicCfg(flags, **kwargs)
+ acc.merge(FaserSCT_OutputCfg(flags))
return acc
# additional specialisations
-def SCT_DigitizationHSCfg(flags, name="SCT_DigitizationHS", **kwargs):
- """Return ComponentAccumulator for Hard-Scatter-only SCT digitization and Output"""
- acc = SCT_DigitizationHSToolCfg(flags)
+def FaserSCT_DigitizationHSCfg(flags, name="FaserSCT_DigitizationHS", **kwargs):
+ """Return ComponentAccumulator for Hard-Scatter-only FaserSCT digitization and Output"""
+ acc = FaserSCT_DigitizationHSToolCfg(flags)
kwargs["PileUpTools"] = acc.popPrivateTools()
- acc = SCT_DigitizationBasicCfg(flags, name=name, **kwargs)
- acc.merge(SCT_OutputCfg(flags))
+ acc = FaserSCT_DigitizationBasicCfg(flags, name=name, **kwargs)
+ acc.merge(FaserSCT_OutputCfg(flags))
return acc
-def SCT_DigitizationPUCfg(flags, name="SCT_DigitizationPU", **kwargs):
+def FaserSCT_DigitizationPUCfg(flags, name="FaserSCT_DigitizationPU", **kwargs):
"""Return ComponentAccumulator with Pile-up-only SCT digitization and Output"""
- acc = SCT_DigitizationPUToolCfg(flags)
+ acc = FaserSCT_DigitizationPUToolCfg(flags)
kwargs["PileUpTools"] = acc.popPrivateTools()
- acc = SCT_DigitizationBasicCfg(flags, name=name, **kwargs)
- acc.merge(SCT_OutputCfg(flags))
+ acc = FaserSCT_DigitizationBasicCfg(flags, name=name, **kwargs)
+ acc.merge(FaserSCT_OutputCfg(flags))
return acc
diff --git a/Tracker/TrackerDigitization/FaserSCT_Digitization/src/SCT_Amp.cxx b/Tracker/TrackerDigitization/FaserSCT_Digitization/src/FaserSCT_Amp.cxx
similarity index 84%
rename from Tracker/TrackerDigitization/FaserSCT_Digitization/src/SCT_Amp.cxx
rename to Tracker/TrackerDigitization/FaserSCT_Digitization/src/FaserSCT_Amp.cxx
index 22352b26451489fee9f36c56a1a5c756397942ec..dc48f4373c06f75bbc0f4644d9444cf34839ef44 100644
--- a/Tracker/TrackerDigitization/FaserSCT_Digitization/src/SCT_Amp.cxx
+++ b/Tracker/TrackerDigitization/FaserSCT_Digitization/src/FaserSCT_Amp.cxx
@@ -2,7 +2,7 @@
Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
*/
-#include "SCT_Amp.h"
+#include "FaserSCT_Amp.h"
// CLHEP
#include "CLHEP/Units/SystemOfUnits.h"
@@ -14,7 +14,7 @@
//#define SCT_DIG_DEBUG
// constructor
-SCT_Amp::SCT_Amp(const std::string& type, const std::string& name, const IInterface* parent)
+FaserSCT_Amp::FaserSCT_Amp(const std::string& type, const std::string& name, const IInterface* parent)
: base_class(type, name, parent)
{
}
@@ -22,14 +22,14 @@ SCT_Amp::SCT_Amp(const std::string& type, const std::string& name, const IInterf
//----------------------------------------------------------------------
// Initialize
//----------------------------------------------------------------------
-StatusCode SCT_Amp::initialize() {
+StatusCode FaserSCT_Amp::initialize() {
StatusCode sc{AthAlgTool::initialize()};
if (sc.isFailure()) {
- ATH_MSG_FATAL("SCT_Amp::initialize() failed");
+ ATH_MSG_FATAL("FaserSCT_Amp::initialize() failed");
return sc;
}
- ATH_MSG_DEBUG("SCT_Amp::initialize()");
+ ATH_MSG_DEBUG("FaserSCT_Amp::initialize()");
/** CHLEP Units */
m_PeakTime.setValue(m_PeakTime.value() * CLHEP::ns);
@@ -56,20 +56,20 @@ StatusCode SCT_Amp::initialize() {
//----------------------------------------------------------------------
// Finalize
//----------------------------------------------------------------------
-StatusCode SCT_Amp::finalize() {
+StatusCode FaserSCT_Amp::finalize() {
StatusCode sc{AthAlgTool::finalize()};
if (sc.isFailure()) {
- ATH_MSG_FATAL("SCT_Amp::finalize() failed");
+ ATH_MSG_FATAL("FaserSCT_Amp::finalize() failed");
return sc;
}
- ATH_MSG_DEBUG("SCT_Amp::finalize()");
+ ATH_MSG_DEBUG("FaserSCT_Amp::finalize()");
return sc;
}
//----------------------------------------------------------------------
// Electronique response is now CR-RC^3 of the charge diode
//----------------------------------------------------------------------
-float SCT_Amp::response(const list_t& Charges, const float timeOfThreshold) const {
+float FaserSCT_Amp::response(const list_t& Charges, const float timeOfThreshold) const {
float resp{0.0};
float tp{static_cast<float>(m_PeakTime/3.0)}; // for CR-RC^3
for (const SiCharge& charge: Charges) {
@@ -83,7 +83,7 @@ float SCT_Amp::response(const list_t& Charges, const float timeOfThreshold) cons
return resp*m_NormConstCentral;
}
-void SCT_Amp::response(const list_t& Charges, const float timeOfThreshold, std::vector<float>& response) const {
+void FaserSCT_Amp::response(const list_t& Charges, const float timeOfThreshold, std::vector<float>& response) const {
short bin_max{static_cast<short>(response.size())};
std::fill(response.begin(), response.end(), 0.0);
float tp{static_cast<float>(m_PeakTime/3.0)}; // for CR-RC^3
@@ -107,7 +107,7 @@ void SCT_Amp::response(const list_t& Charges, const float timeOfThreshold, std::
//----------------------------------------------------------------------
// differenciated and scaled pulse on the neighbour strip!
//----------------------------------------------------------------------
-float SCT_Amp::crosstalk(const list_t& Charges, const float timeOfThreshold) const {
+float FaserSCT_Amp::crosstalk(const list_t& Charges, const float timeOfThreshold) const {
float resp{0};
float tp{static_cast<float>(m_PeakTime/3.0)}; // for CR-RC^3
for (const SiCharge& charge: Charges) {
@@ -121,7 +121,7 @@ float SCT_Amp::crosstalk(const list_t& Charges, const float timeOfThreshold) con
return resp*m_NormConstNeigh;
}
-void SCT_Amp::crosstalk(const list_t& Charges, const float timeOfThreshold, std::vector<float>& response) const {
+void FaserSCT_Amp::crosstalk(const list_t& Charges, const float timeOfThreshold, std::vector<float>& response) const {
short bin_max{static_cast<short>(response.size())};
std::fill(response.begin(), response.end(), 0.0);
float tp{static_cast<float>(m_PeakTime/3.0)}; // for CR-RC^3
diff --git a/Tracker/TrackerDigitization/FaserSCT_Digitization/src/SCT_Amp.h b/Tracker/TrackerDigitization/FaserSCT_Digitization/src/FaserSCT_Amp.h
similarity index 86%
rename from Tracker/TrackerDigitization/FaserSCT_Digitization/src/SCT_Amp.h
rename to Tracker/TrackerDigitization/FaserSCT_Digitization/src/FaserSCT_Amp.h
index d066e194758804bcce453f97b8b11522831b9aa6..8b2b8ed3986a3266d032bad6dfeffc32ea81c9ab 100644
--- a/Tracker/TrackerDigitization/FaserSCT_Digitization/src/SCT_Amp.h
+++ b/Tracker/TrackerDigitization/FaserSCT_Digitization/src/FaserSCT_Amp.h
@@ -5,7 +5,7 @@
*/
/**
- * Header file for SCT_Amp Class
+ * Header file for FaserSCT_Amp Class
* @brief A class to model an SCT amplifier and shaper. Gives a CRRC response to a
* list of charges with times. Also calculates average input and output for
* diagnostic purposes. Questions/comments to Szymon.Gadomski@cern.ch
@@ -16,21 +16,21 @@
* - Conversion of the SCT_Amp code AlgTool
*/
-#ifndef FASERSCT_DIGITIZATION_SCTAMP_H
-#define FASERSCT_DIGITIZATION_SCTAMP_H
+#ifndef FASERSCT_DIGITIZATION_FASERSCTAMP_H
+#define FASERSCT_DIGITIZATION_FASERSCTAMP_H
#include "AthenaBaseComps/AthAlgTool.h"
#include "FaserSCT_Digitization/ISCT_Amp.h"
#include "TrackerSimEvent/SiCharge.h"
-class SCT_Amp : public extends<AthAlgTool, ISCT_Amp> {
+class FaserSCT_Amp : public extends<AthAlgTool, ISCT_Amp> {
public:
/** constructor */
- SCT_Amp(const std::string& type, const std::string& name, const IInterface* parent);
+ FaserSCT_Amp(const std::string& type, const std::string& name, const IInterface* parent);
/** Destructor */
- virtual ~SCT_Amp() = default;
+ virtual ~FaserSCT_Amp() = default;
/** AlgTool initialize */
virtual StatusCode initialize() override;
/** AlgTool finalize */
@@ -66,4 +66,4 @@ private:
float m_NormConstNeigh{0.};
};
-#endif // FASERSCT_DIGITIZATION_SCTAMP_H
+#endif // FASERSCT_DIGITIZATION_FASERSCTAMP_H
diff --git a/Tracker/TrackerDigitization/FaserSCT_Digitization/src/SCT_Digitization.cxx b/Tracker/TrackerDigitization/FaserSCT_Digitization/src/FaserSCT_Digitization.cxx
similarity index 73%
rename from Tracker/TrackerDigitization/FaserSCT_Digitization/src/SCT_Digitization.cxx
rename to Tracker/TrackerDigitization/FaserSCT_Digitization/src/FaserSCT_Digitization.cxx
index f30bbd62b14fd201ca98a739de49894bafe9c6bc..507e3bbd08e3e9ff67bff0cbc6ea9fbf33085397 100644
--- a/Tracker/TrackerDigitization/FaserSCT_Digitization/src/SCT_Digitization.cxx
+++ b/Tracker/TrackerDigitization/FaserSCT_Digitization/src/FaserSCT_Digitization.cxx
@@ -2,13 +2,13 @@
Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
*/
-#include "SCT_Digitization.h"
+#include "FaserSCT_Digitization.h"
#include "PileUpTools/IPileUpTool.h"
//----------------------------------------------------------------------
// Constructor with parameters:
//----------------------------------------------------------------------
-SCT_Digitization::SCT_Digitization(const std::string& name, ISvcLocator* pSvcLocator) :
+FaserSCT_Digitization::FaserSCT_Digitization(const std::string& name, ISvcLocator* pSvcLocator) :
AthAlgorithm(name, pSvcLocator)
{
}
@@ -16,8 +16,8 @@ SCT_Digitization::SCT_Digitization(const std::string& name, ISvcLocator* pSvcLoc
//----------------------------------------------------------------------
// Initialize method:
//----------------------------------------------------------------------
-StatusCode SCT_Digitization::initialize() {
- ATH_MSG_DEBUG("SCT_Digitization::initialize()");
+StatusCode FaserSCT_Digitization::initialize() {
+ ATH_MSG_DEBUG("FaserSCT_Digitization::initialize()");
return StatusCode::SUCCESS ;
}
@@ -25,7 +25,7 @@ StatusCode SCT_Digitization::initialize() {
// Execute method:
//----------------------------------------------------------------------
-StatusCode SCT_Digitization::execute() {
+StatusCode FaserSCT_Digitization::execute() {
ATH_MSG_DEBUG("execute()");
return m_sctDigitizationTool->processAllSubEvents();
}
diff --git a/Tracker/TrackerDigitization/FaserSCT_Digitization/src/SCT_Digitization.h b/Tracker/TrackerDigitization/FaserSCT_Digitization/src/FaserSCT_Digitization.h
similarity index 66%
rename from Tracker/TrackerDigitization/FaserSCT_Digitization/src/SCT_Digitization.h
rename to Tracker/TrackerDigitization/FaserSCT_Digitization/src/FaserSCT_Digitization.h
index 3f32cdf0734f555ef6e64b1b476c07218201a534..60874fc1836f3ae476718cb31432f0540b74e82c 100644
--- a/Tracker/TrackerDigitization/FaserSCT_Digitization/src/SCT_Digitization.h
+++ b/Tracker/TrackerDigitization/FaserSCT_Digitization/src/FaserSCT_Digitization.h
@@ -4,7 +4,7 @@
Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
*/
-/** @file SCT_Digitization.h Header file for SCT_Digitization class.
+/** @file FaserSCT_Digitization.h Header file for FaserSCT_Digitization class.
* @author Szymon.Gadomski@cern.ch, Awatif.Belymam@cern.ch, Davide.Costanzo@cern.ch,
* tgcornel@nikhef.nl, Grant.Gorfine@cern.ch, Paul.Bell@cern.ch,
* Jorgen.Dalmau@cern.ch, Kondo.Gnanvo@cern.ch, and others
@@ -13,8 +13,8 @@
*/
// Multiple inclusion protection
-#ifndef FASERSCT_DIGITIZATION_SCT_DIGITIZATION_H
-#define FASERSCT_DIGITIZATION_SCT_DIGITIZATION_H
+#ifndef FASERSCT_DIGITIZATION_FASERSCT_DIGITIZATION_H
+#define FASERSCT_DIGITIZATION_FASERSCT_DIGITIZATION_H
// Base class
#include "AthenaBaseComps/AthAlgorithm.h"
@@ -24,15 +24,15 @@
class IPileUpTool;
/** Top algorithm class for SCT digitization */
-class SCT_Digitization : public AthAlgorithm {
+class FaserSCT_Digitization : public AthAlgorithm {
public:
/** Constructor with parameters */
- SCT_Digitization(const std::string& name, ISvcLocator* pSvcLocator);
+ FaserSCT_Digitization(const std::string& name, ISvcLocator* pSvcLocator);
/** Destructor */
- virtual ~SCT_Digitization() = default;
+ virtual ~FaserSCT_Digitization() = default;
/** Basic algorithm methods */
virtual StatusCode initialize() override final;
@@ -41,8 +41,8 @@ class SCT_Digitization : public AthAlgorithm {
private:
- ToolHandle<IPileUpTool> m_sctDigitizationTool{this, "DigitizationTool", "SCT_DigitizationTool", "SCT_DigitizationTool name"};
+ ToolHandle<IPileUpTool> m_sctDigitizationTool{this, "DigitizationTool", "FaserSCT_DigitizationTool", "SCT_DigitizationTool name"};
};
-#endif // FASERSCT_DIGITIZATION_SCT_DIGITIZATION_H
+#endif // FASERSCT_DIGITIZATION_FASERSCT_DIGITIZATION_H
diff --git a/Tracker/TrackerDigitization/FaserSCT_Digitization/src/SCT_DigitizationTool.cxx b/Tracker/TrackerDigitization/FaserSCT_Digitization/src/FaserSCT_DigitizationTool.cxx
similarity index 87%
rename from Tracker/TrackerDigitization/FaserSCT_Digitization/src/SCT_DigitizationTool.cxx
rename to Tracker/TrackerDigitization/FaserSCT_Digitization/src/FaserSCT_DigitizationTool.cxx
index 981e3e97d98de8da7c12d9c5f15c91406255d8ee..41e5d7ef6b5f9ecdad576a78f6d8c44e287ffc78 100644
--- a/Tracker/TrackerDigitization/FaserSCT_Digitization/src/SCT_DigitizationTool.cxx
+++ b/Tracker/TrackerDigitization/FaserSCT_Digitization/src/FaserSCT_DigitizationTool.cxx
@@ -2,15 +2,15 @@
Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
*/
-#include "SCT_DigitizationTool.h"
+#include "FaserSCT_DigitizationTool.h"
// Mother Package includes
#include "FaserSiDigitization/SiHelper.h"
#include "FaserSiDigitization/SiChargedDiodeCollection.h"
// EDM includes
-#include "InDetRawData/SCT1_RawData.h"
-#include "InDetRawData/SCT3_RawData.h"
+#include "TrackerRawData/FaserSCT1_RawData.h"
+#include "TrackerRawData/FaserSCT3_RawData.h"
// Hit class includes
#include "TrackerSimEvent/FaserSiHit.h"
@@ -36,14 +36,14 @@
using TrackerDD::SiCellId;
-SCT_DigitizationTool::SCT_DigitizationTool(const std::string& type,
- const std::string& name,
- const IInterface* parent) :
+FaserSCT_DigitizationTool::FaserSCT_DigitizationTool(const std::string& type,
+ const std::string& name,
+ const IInterface* parent) :
base_class(type, name, parent) {
- m_WriteSCT1_RawData.declareUpdateHandler(&SCT_DigitizationTool::SetupRdoOutputType, this);
+ m_WriteSCT1_RawData.declareUpdateHandler(&FaserSCT_DigitizationTool::SetupRdoOutputType, this);
}
-SCT_DigitizationTool::~SCT_DigitizationTool() {
+FaserSCT_DigitizationTool::~FaserSCT_DigitizationTool() {
delete m_thpcsi;
for (FaserSiHitCollection* hit: m_hitCollPtrs) {
hit->Clear();
@@ -55,8 +55,8 @@ SCT_DigitizationTool::~SCT_DigitizationTool() {
// ----------------------------------------------------------------------
// Initialize method:
// ----------------------------------------------------------------------
-StatusCode SCT_DigitizationTool::initialize() {
- ATH_MSG_DEBUG("SCT_DigitizationTool::initialize()");
+StatusCode FaserSCT_DigitizationTool::initialize() {
+ ATH_MSG_DEBUG("FaserSCT_DigitizationTool::initialize()");
// +++ Init the services
ATH_CHECK(initServices());
@@ -95,7 +95,7 @@ StatusCode SCT_DigitizationTool::initialize() {
// Initialize ReadCondHandleKey
ATH_CHECK(m_SCTDetEleCollKey.initialize());
- ATH_MSG_DEBUG("SiDigitizationTool::initialize() complete");
+ ATH_MSG_DEBUG("FaserSCT_DigitizationTool::initialize() complete");
return StatusCode::SUCCESS;
}
@@ -133,7 +133,7 @@ namespace {
// ----------------------------------------------------------------------
// Initialise the surface charge generator Tool
// ----------------------------------------------------------------------
-StatusCode SCT_DigitizationTool::initSurfaceChargesGeneratorTool() {
+StatusCode FaserSCT_DigitizationTool::initSurfaceChargesGeneratorTool() {
ATH_CHECK(m_sct_SurfaceChargesGenerator.retrieve());
if (m_cosmicsRun and m_tfix > -998) {
@@ -149,7 +149,7 @@ StatusCode SCT_DigitizationTool::initSurfaceChargesGeneratorTool() {
// ----------------------------------------------------------------------
// Initialise the Front End electronics Tool
// ----------------------------------------------------------------------
-StatusCode SCT_DigitizationTool::initFrontEndTool() {
+StatusCode FaserSCT_DigitizationTool::initFrontEndTool() {
ATH_CHECK(m_sct_FrontEnd.retrieve());
storeTool(&(*m_sct_FrontEnd));
@@ -161,7 +161,7 @@ StatusCode SCT_DigitizationTool::initFrontEndTool() {
// ----------------------------------------------------------------------
// Initialize the different services
// ----------------------------------------------------------------------
-StatusCode SCT_DigitizationTool::initServices() {
+StatusCode FaserSCT_DigitizationTool::initServices() {
// Get SCT ID helper for hash function and Store them using methods from the
// SiDigitization.
ATH_CHECK(detStore()->retrieve(m_detID, "FaserSCT_ID"));
@@ -175,7 +175,7 @@ StatusCode SCT_DigitizationTool::initServices() {
// ----------------------------------------------------------------------
// Initialize the disabled cells for cosmics or CTB cases
// ----------------------------------------------------------------------
-StatusCode SCT_DigitizationTool::initDisabledCells() {
+StatusCode FaserSCT_DigitizationTool::initDisabledCells() {
// +++ Retrieve the SCT_RandomDisabledCellGenerator
ATH_CHECK(m_sct_RandomDisabledCellGenerator.retrieve());
@@ -185,7 +185,7 @@ StatusCode SCT_DigitizationTool::initDisabledCells() {
return StatusCode::SUCCESS;
}
-StatusCode SCT_DigitizationTool::processAllSubEvents() {
+StatusCode FaserSCT_DigitizationTool::processAllSubEvents() {
if (prepareEvent(0).isFailure()) {
return StatusCode::FAILURE;
}
@@ -218,16 +218,16 @@ StatusCode SCT_DigitizationTool::processAllSubEvents() {
// ======================================================================
// prepareEvent
// ======================================================================
-StatusCode SCT_DigitizationTool::prepareEvent(unsigned int /*index*/) {
- ATH_MSG_VERBOSE("SCT_DigitizationTool::prepareEvent()");
+StatusCode FaserSCT_DigitizationTool::prepareEvent(unsigned int /*index*/) {
+ ATH_MSG_VERBOSE("FaserSCT_DigitizationTool::prepareEvent()");
// Create the IdentifiableContainer to contain the digit collections Create
// a new RDO container
m_rdoContainer = SG::makeHandle(m_rdoContainerKey);
- ATH_CHECK(m_rdoContainer.record(std::make_unique<SCT_RDO_Container>(m_detID->wafer_hash_max())));
+ ATH_CHECK(m_rdoContainer.record(std::make_unique<FaserSCT_RDO_Container>(m_detID->wafer_hash_max())));
// Create a map for the SDO and register it into StoreGate
m_simDataCollMap = SG::makeHandle(m_simDataCollMapKey);
- ATH_CHECK(m_simDataCollMap.record(std::make_unique<InDetSimDataCollection>()));
+ ATH_CHECK(m_simDataCollMap.record(std::make_unique<TrackerSimDataCollection>()));
m_processedElements.clear();
m_processedElements.resize(m_detID->wafer_hash_max(), false);
@@ -240,8 +240,8 @@ StatusCode SCT_DigitizationTool::prepareEvent(unsigned int /*index*/) {
// =========================================================================
// mergeEvent
// =========================================================================
-StatusCode SCT_DigitizationTool::mergeEvent() {
- ATH_MSG_VERBOSE("SCT_DigitizationTool::mergeEvent()");
+StatusCode FaserSCT_DigitizationTool::mergeEvent() {
+ ATH_MSG_VERBOSE("FaserSCT_DigitizationTool::mergeEvent()");
// Set the RNG to use for this event.
ATHRNG::RNGWrapper* rngWrapper = m_rndmSvc->getEngine(this);
@@ -269,7 +269,7 @@ StatusCode SCT_DigitizationTool::mergeEvent() {
return StatusCode::SUCCESS;
}
-void SCT_DigitizationTool::digitizeAllHits(SG::WriteHandle<SCT_RDO_Container>* rdoContainer, SG::WriteHandle<InDetSimDataCollection>* simDataCollMap, std::vector<bool>* processedElements, TimedHitCollection<FaserSiHit>* thpcsi, CLHEP::HepRandomEngine * rndmEngine) const {
+void FaserSCT_DigitizationTool::digitizeAllHits(SG::WriteHandle<FaserSCT_RDO_Container>* rdoContainer, SG::WriteHandle<TrackerSimDataCollection>* simDataCollMap, std::vector<bool>* processedElements, TimedHitCollection<FaserSiHit>* thpcsi, CLHEP::HepRandomEngine * rndmEngine) const {
/////////////////////////////////////////////////
//
// In order to process all element rather than just those with hits we
@@ -320,7 +320,7 @@ void SCT_DigitizationTool::digitizeAllHits(SG::WriteHandle<SCT_RDO_Container>* r
}
// digitize elements without hits
-void SCT_DigitizationTool::digitizeNonHits(SG::WriteHandle<SCT_RDO_Container>* rdoContainer, SG::WriteHandle<InDetSimDataCollection>* simDataCollMap, const std::vector<bool>* processedElements, CLHEP::HepRandomEngine * rndmEngine) const {
+void FaserSCT_DigitizationTool::digitizeNonHits(SG::WriteHandle<FaserSCT_RDO_Container>* rdoContainer, SG::WriteHandle<TrackerSimDataCollection>* simDataCollMap, const std::vector<bool>* processedElements, CLHEP::HepRandomEngine * rndmEngine) const {
// Get SCT_DetectorElementCollection
SG::ReadCondHandle<TrackerDD::SiDetectorElementCollection> sctDetEle(m_SCTDetEleCollKey);
const TrackerDD::SiDetectorElementCollection* elements{sctDetEle.retrieve()};
@@ -369,7 +369,7 @@ void SCT_DigitizationTool::digitizeNonHits(SG::WriteHandle<SCT_RDO_Container>* r
return;
}
-bool SCT_DigitizationTool::digitizeElement(SiChargedDiodeCollection* chargedDiodes, TimedHitCollection<FaserSiHit>*& thpcsi, CLHEP::HepRandomEngine * rndmEngine) const {
+bool FaserSCT_DigitizationTool::digitizeElement(SiChargedDiodeCollection* chargedDiodes, TimedHitCollection<FaserSiHit>*& thpcsi, CLHEP::HepRandomEngine * rndmEngine) const {
if (nullptr == thpcsi) {
ATH_MSG_ERROR("thpcsi should not be nullptr!");
@@ -437,7 +437,7 @@ bool SCT_DigitizationTool::digitizeElement(SiChargedDiodeCollection* chargedDiod
// -----------------------------------------------------------------------------
// Applies processors to the current detector element for the current element:
// -----------------------------------------------------------------------------
-void SCT_DigitizationTool::applyProcessorTools(SiChargedDiodeCollection* chargedDiodes, CLHEP::HepRandomEngine * rndmEngine) const {
+void FaserSCT_DigitizationTool::applyProcessorTools(SiChargedDiodeCollection* chargedDiodes, CLHEP::HepRandomEngine * rndmEngine) const {
ATH_MSG_DEBUG("applyProcessorTools()");
int processorNumber{0};
@@ -449,10 +449,10 @@ void SCT_DigitizationTool::applyProcessorTools(SiChargedDiodeCollection* charged
}
}
-StatusCode SCT_DigitizationTool::processBunchXing(int bunchXing,
+StatusCode FaserSCT_DigitizationTool::processBunchXing(int bunchXing,
SubEventIterator bSubEvents,
SubEventIterator eSubEvents) {
- ATH_MSG_VERBOSE("SCT_DigitizationTool::processBunchXing() " << bunchXing);
+ ATH_MSG_VERBOSE("FaserSCT_DigitizationTool::processBunchXing() " << bunchXing);
typedef PileUpMergeSvc::TimedList<FaserSiHitCollection>::type TimedHitCollList;
TimedHitCollList hitCollList;
@@ -487,7 +487,7 @@ StatusCode SCT_DigitizationTool::processBunchXing(int bunchXing,
// =========================================================================
// property handlers
// =========================================================================
-void SCT_DigitizationTool::SetupRdoOutputType(Property &) {
+void FaserSCT_DigitizationTool::SetupRdoOutputType(Property &) {
}
// Does nothing, but required by Gaudi
@@ -524,10 +524,10 @@ private:
// ----------------------------------------------------------------------//
// createAndStoreRDO //
// ----------------------------------------------------------------------//
-StatusCode SCT_DigitizationTool::createAndStoreRDO(SiChargedDiodeCollection* chDiodeCollection, SG::WriteHandle<SCT_RDO_Container>* rdoContainer) const {
+StatusCode FaserSCT_DigitizationTool::createAndStoreRDO(SiChargedDiodeCollection* chDiodeCollection, SG::WriteHandle<FaserSCT_RDO_Container>* rdoContainer) const {
// Create the RDO collection
- SCT_RDO_Collection* RDOColl{createRDO(chDiodeCollection)};
+ FaserSCT_RDO_Collection* RDOColl{createRDO(chDiodeCollection)};
// Add it to storegate
if ((*rdoContainer)->addCollection(RDOColl, RDOColl->identifyHash()).isFailure()) {
@@ -542,24 +542,24 @@ StatusCode SCT_DigitizationTool::createAndStoreRDO(SiChargedDiodeCollection* chD
// ----------------------------------------------------------------------
// createRDO
// ----------------------------------------------------------------------
-SCT_RDO_Collection* SCT_DigitizationTool::createRDO(SiChargedDiodeCollection* collection) const {
+FaserSCT_RDO_Collection* FaserSCT_DigitizationTool::createRDO(SiChargedDiodeCollection* collection) const {
// create a new SCT RDO collection
- SCT_RDO_Collection* p_rdocoll{nullptr};
+ FaserSCT_RDO_Collection* p_rdocoll{nullptr};
// need the DE identifier
const Identifier id_de{collection->identify()};
IdentifierHash idHash_de{collection->identifyHash()};
try {
- p_rdocoll = new SCT_RDO_Collection(idHash_de);
+ p_rdocoll = new FaserSCT_RDO_Collection(idHash_de);
} catch (const std::bad_alloc&) {
- ATH_MSG_FATAL("Could not create a new SCT_RDORawDataCollection !");
+ ATH_MSG_FATAL("Could not create a new FaserSCT_RDORawDataCollection !");
}
p_rdocoll->setIdentifier(id_de);
SiChargedDiodeIterator i_chargedDiode{collection->begin()};
SiChargedDiodeIterator i_chargedDiode_end{collection->end()};
- // Choice of producing SCT1_RawData or SCT3_RawData
+ // Choice of producing FaserSCT1_RawData or FaserSCT3_RawData
if (m_WriteSCT1_RawData.value()) {
for (; i_chargedDiode != i_chargedDiode_end; ++i_chargedDiode) {
unsigned int flagmask{static_cast<unsigned int>((*i_chargedDiode).second.flag() & 0xFE)};
@@ -611,7 +611,7 @@ SCT_RDO_Collection* SCT_DigitizationTool::createRDO(SiChargedDiodeCollection* co
}
}
unsigned int SCT_Word{strip_rdo | size_rdo};
- SCT1_RawData* p_rdo{new SCT1_RawData(id_readout, SCT_Word)};
+ FaserSCT1_RawData* p_rdo{new FaserSCT1_RawData(id_readout, SCT_Word)};
if (p_rdo) {
p_rdocoll->push_back(p_rdo);
}
@@ -671,7 +671,7 @@ SCT_RDO_Collection* SCT_DigitizationTool::createRDO(SiChargedDiodeCollection* co
}
unsigned int SCT_Word{static_cast<unsigned int>(groupSize | (stripIn11bits << 11) | (tbin << 22) | (ERRORS << 25))};
- SCT3_RawData *p_rdo{new SCT3_RawData(id_readout, SCT_Word, &dummyvector)};
+ FaserSCT3_RawData *p_rdo{new FaserSCT3_RawData(id_readout, SCT_Word, &dummyvector)};
if (p_rdo) {
p_rdocoll->push_back(p_rdo);
}
@@ -684,8 +684,8 @@ SCT_RDO_Collection* SCT_DigitizationTool::createRDO(SiChargedDiodeCollection* co
// ------------------------------------------------------------
// Get next event and extract collection of hit collections:
// ------------------------------------------------------------
-StatusCode SCT_DigitizationTool::getNextEvent() {
- ATH_MSG_DEBUG("SCT_DigitizationTool::getNextEvent()");
+StatusCode FaserSCT_DigitizationTool::getNextEvent() {
+ ATH_MSG_DEBUG("FaserSCT_DigitizationTool::getNextEvent()");
// get the container(s)
typedef PileUpMergeSvc::TimedList<FaserSiHitCollection>::type TimedHitCollList;
// this is a list<pair<time_t, DataLink<SiHitCollection> >
@@ -727,11 +727,11 @@ StatusCode SCT_DigitizationTool::getNextEvent() {
}
// -----------------------------------------------------------------------------------------------
-// Convert a SiTotalCharge to a InDetSimData, and store it.
+// Convert a SiTotalCharge to a TrackerSimData, and store it.
// -----------------------------------------------------------------------------------------------
-void SCT_DigitizationTool::addSDO(SiChargedDiodeCollection* collection, SG::WriteHandle<InDetSimDataCollection>* simDataCollMap) const {
+void FaserSCT_DigitizationTool::addSDO(SiChargedDiodeCollection* collection, SG::WriteHandle<TrackerSimDataCollection>* simDataCollMap) const {
typedef SiTotalCharge::list_t list_t;
- std::vector<InDetSimData::Deposit> deposits;
+ std::vector<TrackerSimData::Deposit> deposits;
deposits.reserve(5); // no idea what a reasonable number for this would be
// with pileup
// loop over the charged diodes
@@ -764,9 +764,9 @@ void SCT_DigitizationTool::addSDO(SiChargedDiodeCollection* collection, SG::Writ
}
}
// check if this track number has been already used.
- std::vector<InDetSimData::Deposit>::reverse_iterator theDeposit{deposits.rend()}; // dummy value
- std::vector<InDetSimData::Deposit>::reverse_iterator depositsR_end{deposits.rend()};
- std::vector<InDetSimData::Deposit>::reverse_iterator i_Deposit{deposits.rbegin()};
+ std::vector<TrackerSimData::Deposit>::reverse_iterator theDeposit{deposits.rend()}; // dummy value
+ std::vector<TrackerSimData::Deposit>::reverse_iterator depositsR_end{deposits.rend()};
+ std::vector<TrackerSimData::Deposit>::reverse_iterator i_Deposit{deposits.rbegin()};
for (; i_Deposit != depositsR_end; ++i_Deposit) {
if ((*i_Deposit).first == trkLink) {
theDeposit = i_Deposit;
@@ -778,7 +778,7 @@ void SCT_DigitizationTool::addSDO(SiChargedDiodeCollection* collection, SG::Writ
if (theDeposit != depositsR_end) {
(*theDeposit).second += i_ListOfCharges->charge();
} else { // create a new deposit
- InDetSimData::Deposit deposit(trkLink, i_ListOfCharges->charge());
+ TrackerSimData::Deposit deposit(trkLink, i_ListOfCharges->charge());
deposits.push_back(deposit);
}
}
@@ -789,7 +789,7 @@ void SCT_DigitizationTool::addSDO(SiChargedDiodeCollection* collection, SG::Writ
int strip{roCell.strip()};
Identifier id_readout;
id_readout = m_detID->strip_id(collection->identify(),strip);
- (*simDataCollMap)->insert(std::make_pair(id_readout, InDetSimData(deposits, (*i_chargedDiode).second.flag())));
+ (*simDataCollMap)->insert(std::make_pair(id_readout, TrackerSimData(deposits, (*i_chargedDiode).second.flag())));
}
}
}
diff --git a/Tracker/TrackerDigitization/FaserSCT_Digitization/src/SCT_DigitizationTool.h b/Tracker/TrackerDigitization/FaserSCT_Digitization/src/FaserSCT_DigitizationTool.h
similarity index 70%
rename from Tracker/TrackerDigitization/FaserSCT_Digitization/src/SCT_DigitizationTool.h
rename to Tracker/TrackerDigitization/FaserSCT_Digitization/src/FaserSCT_DigitizationTool.h
index f34d0619d4bb0538d63e4ded88df576d5b175f44..b96a8c21efb42a21bc4d65e7dd6bcf186b184ba7 100644
--- a/Tracker/TrackerDigitization/FaserSCT_Digitization/src/SCT_DigitizationTool.h
+++ b/Tracker/TrackerDigitization/FaserSCT_Digitization/src/FaserSCT_DigitizationTool.h
@@ -4,11 +4,11 @@
Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
*/
-#ifndef FASERSCT_DIGITZATION_SCT_DIGITZATIONTOOL_H
-#define FASERSCT_DIGITZATION_SCT_DIGITZATIONTOOL_H
-/** @file SCT_DigitizationTool.h
+#ifndef FASERSCT_DIGITZATION_FASERSCT_DIGITZATIONTOOL_H
+#define FASERSCT_DIGITZATION_FASERSCT_DIGITZATIONTOOL_H
+/** @file FaserSCT_DigitizationTool.h
* @brief Digitize the SCT using an implementation of IPileUpTool
- * $Id: SCT_DigitizationTool.h,v 1.0 2009-09-22 18:34:42 jchapman Exp $
+ * $Id: FaserSCT_DigitizationTool.h,v 1.0 2009-09-22 18:34:42 jchapman Exp $
* @author John Chapman - ATLAS Collaboration
*/
@@ -18,9 +18,9 @@
// Athena headers
#include "AthenaKernel/IAthRNGSvc.h"
#include "HitManagement/TimedHitCollection.h"
-#include "InDetRawData/SCT_RDO_Container.h"
+#include "TrackerRawData/FaserSCT_RDO_Container.h"
#include "TrackerReadoutGeometry/SiDetectorElementCollection.h"
-#include "InDetSimData/InDetSimDataCollection.h"
+#include "TrackerSimData/TrackerSimDataCollection.h"
#include "TrackerSimEvent/FaserSiHitCollection.h"
#include "PileUpTools/PileUpMergeSvc.h"
#include "FaserSCT_Digitization/ISCT_FrontEnd.h"
@@ -49,14 +49,14 @@ namespace CLHEP
class HepRandomEngine;
}
-class SCT_DigitizationTool : public extends<PileUpToolBase, IPileUpTool>
+class FaserSCT_DigitizationTool : public extends<PileUpToolBase, IPileUpTool>
{
public:
static const InterfaceID& interfaceID();
- SCT_DigitizationTool(const std::string& type,
+ FaserSCT_DigitizationTool(const std::string& type,
const std::string& name,
const IInterface* parent);
- virtual ~SCT_DigitizationTool();
+ virtual ~FaserSCT_DigitizationTool();
/**
@brief Called before processing physics events
*/
@@ -73,7 +73,7 @@ protected:
bool digitizeElement(SiChargedDiodeCollection* chargedDiodes, TimedHitCollection<FaserSiHit>*& thpcsi, CLHEP::HepRandomEngine * rndmEngine) const ; //!
void applyProcessorTools(SiChargedDiodeCollection* chargedDiodes, CLHEP::HepRandomEngine * rndmEngine) const; //!
- void addSDO(SiChargedDiodeCollection* collection, SG::WriteHandle<InDetSimDataCollection>* simDataCollMap) const;
+ void addSDO(SiChargedDiodeCollection* collection, SG::WriteHandle<TrackerSimDataCollection>* simDataCollMap) const;
void storeTool(ISiChargedDiodesProcessorTool* p_processor) {m_diodeCollectionTools.push_back(p_processor);}
@@ -101,16 +101,16 @@ private:
@brief Create RDOs from the SiChargedDiodeCollection for the current wafer and save to StoreGate
@param chDiodeCollection list of the SiChargedDiodes on the current wafer
*/
- StatusCode createAndStoreRDO(SiChargedDiodeCollection* chDiodeCollection, SG::WriteHandle<SCT_RDO_Container>* rdoContainer) const;
+ StatusCode createAndStoreRDO(SiChargedDiodeCollection* chDiodeCollection, SG::WriteHandle<FaserSCT_RDO_Container>* rdoContainer) const;
/**
@brief Create RDOs from the SiChargedDiodeCollection for the current wafer
@param chDiodeCollection list of the SiChargedDiodes on the current wafer
*/
- SCT_RDO_Collection* createRDO(SiChargedDiodeCollection* collection) const;
+ FaserSCT_RDO_Collection* createRDO(SiChargedDiodeCollection* collection) const;
StatusCode getNextEvent();
- void digitizeAllHits(SG::WriteHandle<SCT_RDO_Container>* rdoContainer, SG::WriteHandle<InDetSimDataCollection>* simDataCollMap, std::vector<bool>* processedElements, TimedHitCollection<FaserSiHit>* thpcsi, CLHEP::HepRandomEngine * rndmEngine) const; //!< digitize all hits
- void digitizeNonHits(SG::WriteHandle<SCT_RDO_Container>* rdoContainer, SG::WriteHandle<InDetSimDataCollection>* simDataCollMap, const std::vector<bool>* processedElements, CLHEP::HepRandomEngine * rndmEngine) const; //!< digitize SCT without hits
+ void digitizeAllHits(SG::WriteHandle<FaserSCT_RDO_Container>* rdoContainer, SG::WriteHandle<TrackerSimDataCollection>* simDataCollMap, std::vector<bool>* processedElements, TimedHitCollection<FaserSiHit>* thpcsi, CLHEP::HepRandomEngine * rndmEngine) const; //!< digitize all hits
+ void digitizeNonHits(SG::WriteHandle<FaserSCT_RDO_Container>* rdoContainer, SG::WriteHandle<TrackerSimDataCollection>* simDataCollMap, const std::vector<bool>* processedElements, CLHEP::HepRandomEngine * rndmEngine) const; //!< digitize SCT without hits
/**
@brief Called when m_WriteSCT1_RawData is altered. Does nothing, but required by Gaudi.
@@ -129,15 +129,15 @@ private:
SG::ReadHandleKey<FaserSiHitCollection> m_hitsContainerKey{this, "InputObjectName", "SCT_Hits", "Input HITS collection name"};
std::string m_inputObjectName{""};
- SG::WriteHandleKey<SCT_RDO_Container> m_rdoContainerKey{this, "OutputObjectName", "SCT_RDOs", "Output Object name"};
- SG::WriteHandle<SCT_RDO_Container> m_rdoContainer; //!< RDO container handle
- SG::WriteHandleKey<InDetSimDataCollection> m_simDataCollMapKey{this, "OutputSDOName", "SCT_SDO_Map", "Output SDO container name"};
- SG::WriteHandle<InDetSimDataCollection> m_simDataCollMap; //!< SDO Map handle
+ SG::WriteHandleKey<FaserSCT_RDO_Container> m_rdoContainerKey{this, "OutputObjectName", "SCT_RDOs", "Output Object name"};
+ SG::WriteHandle<FaserSCT_RDO_Container> m_rdoContainer; //!< RDO container handle
+ SG::WriteHandleKey<TrackerSimDataCollection> m_simDataCollMapKey{this, "OutputSDOName", "SCT_SDO_Map", "Output SDO container name"};
+ SG::WriteHandle<TrackerSimDataCollection> m_simDataCollMap; //!< SDO Map handle
SG::ReadCondHandleKey<TrackerDD::SiDetectorElementCollection> m_SCTDetEleCollKey{this, "SCTDetEleCollKey", "SCT_DetectorElementCollection", "Key of SiDetectorElementCollection for SCT"};
- ToolHandle<ISCT_FrontEnd> m_sct_FrontEnd{this, "FrontEnd", "SCT_FrontEnd", "Handle the Front End Electronic tool"};
- ToolHandle<ISCT_SurfaceChargesGenerator> m_sct_SurfaceChargesGenerator{this, "SurfaceChargesGenerator", "SCT_SurfaceChargesGenerator", "Choice of using a more detailed charge drift model"};
- ToolHandle<ISCT_RandomDisabledCellGenerator> m_sct_RandomDisabledCellGenerator{this, "RandomDisabledCellGenerator", "SCT_RandomDisabledCellGenerator", ""};
+ ToolHandle<ISCT_FrontEnd> m_sct_FrontEnd{this, "FrontEnd", "FaserSCT_FrontEnd", "Handle the Front End Electronic tool"};
+ ToolHandle<ISCT_SurfaceChargesGenerator> m_sct_SurfaceChargesGenerator{this, "SurfaceChargesGenerator", "FaserSCT_SurfaceChargesGenerator", "Choice of using a more detailed charge drift model"};
+ ToolHandle<ISCT_RandomDisabledCellGenerator> m_sct_RandomDisabledCellGenerator{this, "RandomDisabledCellGenerator", "FaserSCT_RandomDisabledCellGenerator", ""};
ServiceHandle<IAthRNGSvc> m_rndmSvc{this, "RndmSvc", "AthRNGSvc", ""}; //!< Random number service
ServiceHandle <PileUpMergeSvc> m_mergeSvc{this, "MergeSvc", "PileUpMergeSvc", "Merge service used in Pixel & SCT digitization"}; //!
@@ -148,9 +148,9 @@ private:
std::vector<FaserSiHitCollection*> m_hitCollPtrs;
};
-static const InterfaceID IID_ISCT_DigitizationTool("SCT_DigitizationTool", 1, 0);
-inline const InterfaceID& SCT_DigitizationTool::interfaceID() {
+static const InterfaceID IID_ISCT_DigitizationTool("FaserSCT_DigitizationTool", 1, 0);
+inline const InterfaceID& FaserSCT_DigitizationTool::interfaceID() {
return IID_ISCT_DigitizationTool;
}
-#endif // FASERSCT_DIGITZATION_SCT_DIGITZATIONTOOL_H
+#endif // FASERSCT_DIGITZATION_FASERSCT_DIGITZATIONTOOL_H
diff --git a/Tracker/TrackerDigitization/FaserSCT_Digitization/src/SCT_FrontEnd.cxx b/Tracker/TrackerDigitization/FaserSCT_Digitization/src/FaserSCT_FrontEnd.cxx
similarity index 71%
rename from Tracker/TrackerDigitization/FaserSCT_Digitization/src/SCT_FrontEnd.cxx
rename to Tracker/TrackerDigitization/FaserSCT_Digitization/src/FaserSCT_FrontEnd.cxx
index 50d06c46c2dceb839ae362a89b6eea8c92320a38..bab2918225746cf1277a59f0779e5e69f72c1d85 100644
--- a/Tracker/TrackerDigitization/FaserSCT_Digitization/src/SCT_FrontEnd.cxx
+++ b/Tracker/TrackerDigitization/FaserSCT_Digitization/src/FaserSCT_FrontEnd.cxx
@@ -2,7 +2,7 @@
Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
*/
-#include "SCT_FrontEnd.h"
+#include "FaserSCT_FrontEnd.h"
// Random number
#include "CLHEP/Random/RandFlat.h"
@@ -28,20 +28,20 @@ using namespace std;
using namespace TrackerDD;
// constructor
-SCT_FrontEnd::SCT_FrontEnd(const std::string& type, const std::string& name, const IInterface* parent)
+FaserSCT_FrontEnd::FaserSCT_FrontEnd(const std::string& type, const std::string& name, const IInterface* parent)
: base_class(type, name, parent) {
}
// ----------------------------------------------------------------------
// Initialize
// ----------------------------------------------------------------------
-StatusCode SCT_FrontEnd::initialize() {
+StatusCode FaserSCT_FrontEnd::initialize() {
if (m_NoiseOn and (not m_analogueNoiseOn)) {
ATH_MSG_FATAL("AnalogueNoiseOn/m_analogueNoiseOn should be true if NoiseOn/m_NoiseOn is true.");
return StatusCode::FAILURE;
}
- ATH_MSG_DEBUG("SCT_FrontEnd::initialize()");
+ ATH_MSG_DEBUG("FaserSCT_FrontEnd::initialize()");
// Get SCT helper
ATH_CHECK(detStore()->retrieve(m_sct_id, "FaserSCT_ID"));
// Get SCT detector manager
@@ -52,11 +52,11 @@ StatusCode SCT_FrontEnd::initialize() {
// Get the SCT_ReadCaliDataSvc
if (m_useCalibData) {
- // ATH_CHECK(m_ReadCalibChipDataTool.retrieve());
- // ATH_MSG_DEBUG("CalibChipData Service located ");
- ATH_MSG_FATAL("Use of calibration data not supported.");
+ ATH_CHECK(m_ReadCalibChipDataTool.retrieve());
+ ATH_MSG_DEBUG("CalibChipData Service located ");
+ // ATH_MSG_FATAL("Use of calibration data not supported.");
} else {
- // m_ReadCalibChipDataTool.disable();
+ m_ReadCalibChipDataTool.disable();
}
// Get the maximum number of strips of any module
@@ -81,9 +81,9 @@ StatusCode SCT_FrontEnd::initialize() {
return StatusCode::SUCCESS;
}
-StatusCode SCT_FrontEnd::finalize() {
+StatusCode FaserSCT_FrontEnd::finalize() {
#ifdef SCT_DIG_DEBUG
- ATH_MSG_INFO("SCT_FrontEnd::finalize()");
+ ATH_MSG_INFO("FaserSCT_FrontEnd::finalize()");
#endif
return StatusCode::SUCCESS;
}
@@ -91,7 +91,7 @@ StatusCode SCT_FrontEnd::finalize() {
// ----------------------------------------------------------------------
// Init the class variable vectors
// ----------------------------------------------------------------------
-StatusCode SCT_FrontEnd::initVectors(int strips, SCT_FrontEndData& data) const {
+StatusCode FaserSCT_FrontEnd::initVectors(int strips, SCT_FrontEndData& data) const {
data.m_Offset.assign(strips, 0.0);
data.m_GainFactor.assign(strips, 0.0);
data.m_NoiseFactor.assign(strips, 0.0);
@@ -116,7 +116,7 @@ StatusCode SCT_FrontEnd::initVectors(int strips, SCT_FrontEndData& data) const {
// ----------------------------------------------------------------------
// prepare gain and offset for the strips for a given module
// ----------------------------------------------------------------------
-StatusCode SCT_FrontEnd::prepareGainAndOffset(SiChargedDiodeCollection& collection, /*const Identifier& moduleId,*/ CLHEP::HepRandomEngine * rndmEngine, SCT_FrontEndData& data) const {
+StatusCode FaserSCT_FrontEnd::prepareGainAndOffset(SiChargedDiodeCollection& collection, /*const Identifier& moduleId,*/ CLHEP::HepRandomEngine * rndmEngine, SCT_FrontEndData& data) const {
// now we need to generate gain and offset channel by channel: some algebra
// for generation of partially correlated random numbers
float W = m_OGcorr * m_GainRMS * m_Ospread / (m_GainRMS * m_GainRMS - m_Ospread * m_Ospread);
@@ -219,128 +219,128 @@ StatusCode SCT_FrontEnd::prepareGainAndOffset(SiChargedDiodeCollection& collecti
// prepare gain and offset for the strips for a given module using
// Cond Db data to get the chip calibration data
// ----------------------------------------------------------------------
-// StatusCode SCT_FrontEnd::prepareGainAndOffset(SiChargedDiodeCollection& collection, int side, const Identifier& moduleId, CLHEP::HepRandomEngine * rndmEngine, SCT_FrontEndData& data) const {
-// // Get chip data from calib DB
-// std::vector<float> gainByChipVect = m_ReadCalibChipDataTool->getNPtGainData(moduleId, side, "GainByChip");
-// std::vector<float> gainRMSByChipVect = m_ReadCalibChipDataTool->getNPtGainData(moduleId, side, "GainRMSByChip");
-// std::vector<float> offsetByChipVect = m_ReadCalibChipDataTool->getNPtGainData(moduleId, side, "OffsetByChip");
-// std::vector<float> offsetRMSByChipVect = m_ReadCalibChipDataTool->getNPtGainData(moduleId, side, "OffsetRMSByChip");
-// std::vector<float> noiseByChipVect(6, 0.0);
-
-// if (m_analogueNoiseOn) { // Check if noise should be on or off
-// noiseByChipVect = m_ReadCalibChipDataTool->getNPtGainData(moduleId, side, "NoiseByChip");
-// }
+StatusCode FaserSCT_FrontEnd::prepareGainAndOffset(SiChargedDiodeCollection& collection, int side, const Identifier& moduleId, CLHEP::HepRandomEngine * rndmEngine, SCT_FrontEndData& data) const {
+ // Get chip data from calib DB
+ std::vector<float> gainByChipVect = m_ReadCalibChipDataTool->getNPtGainData(moduleId, side, "GainByChip");
+ std::vector<float> gainRMSByChipVect = m_ReadCalibChipDataTool->getNPtGainData(moduleId, side, "GainRMSByChip");
+ std::vector<float> offsetByChipVect = m_ReadCalibChipDataTool->getNPtGainData(moduleId, side, "OffsetByChip");
+ std::vector<float> offsetRMSByChipVect = m_ReadCalibChipDataTool->getNPtGainData(moduleId, side, "OffsetRMSByChip");
+ std::vector<float> noiseByChipVect(6, 0.0);
+
+ if (m_analogueNoiseOn) { // Check if noise should be on or off
+ noiseByChipVect = m_ReadCalibChipDataTool->getNPtGainData(moduleId, side, "NoiseByChip");
+ }
-// // Need to check if empty, most should have data, but a few old DEAD modules don't
-// if (gainByChipVect.empty() or noiseByChipVect.empty()) {
-// ATH_MSG_DEBUG("No calibration data in cond DB for module " << moduleId << " using JO values");
-// if (StatusCode::SUCCESS != prepareGainAndOffset(collection, moduleId, rndmEngine, data)) {
-// return StatusCode::FAILURE;
-// } else {
-// return StatusCode::SUCCESS;
-// }
-// }
+ // Need to check if empty, most should have data, but a few old DEAD modules don't
+ if (gainByChipVect.empty() or noiseByChipVect.empty()) {
+ ATH_MSG_DEBUG("No calibration data in cond DB for module " << moduleId << " using JO values");
+ if (StatusCode::SUCCESS != prepareGainAndOffset(collection, /*moduleId,*/ rndmEngine, data)) {
+ return StatusCode::FAILURE;
+ } else {
+ return StatusCode::SUCCESS;
+ }
+ }
-// // Don't really need to set up values for each chip...
-// float gainMeanValue = meanValue(gainByChipVect);
-// if (gainMeanValue < 0.0) {
-// ATH_MSG_DEBUG("All chip gain values are 0 for module " << moduleId << " using JO values");
-// if (StatusCode::SUCCESS != prepareGainAndOffset(collection, moduleId, rndmEngine, data)) {
-// return StatusCode::FAILURE;
-// } else {
-// return StatusCode::SUCCESS;
-// }
-// }
+ // Don't really need to set up values for each chip...
+ float gainMeanValue = meanValue(gainByChipVect);
+ if (gainMeanValue < 0.0) {
+ ATH_MSG_DEBUG("All chip gain values are 0 for module " << moduleId << " using JO values");
+ if (StatusCode::SUCCESS != prepareGainAndOffset(collection, /*moduleId,*/ rndmEngine, data)) {
+ return StatusCode::FAILURE;
+ } else {
+ return StatusCode::SUCCESS;
+ }
+ }
-// std::vector<float> gain(6, 0.0);
-// std::vector<float> offset(6, 0.0);
-// std::vector<float> S1(6, 0.0);
-// std::vector<float> S2(6, 0.0);
-// std::vector<float> sinfi(6, 0.0);
-// std::vector<float> cosfi(6, 0.0);
-// float gainRMS = 0.0;
-// float offsetRMS = 0.0;
-
-// for (int i = 0; i < 6; ++i) {
-// // Some very few chips have 0 values, dead/bypassed/etc, so check and use some fixed values instead
-// if (gainByChipVect[i] > 0.1) {
-// gain[i] = gainByChipVect[i] / gainMeanValue;
-// offset[i] = offsetByChipVect[i] / m_Threshold;
-// gainRMS = gainRMSByChipVect[i] / gainMeanValue;
-// offsetRMS = offsetRMSByChipVect[i] / m_Threshold;
-// } else {
-// gain[i] = 55.0 / gainMeanValue;
-// offset[i] = 42.0 / m_Threshold;
-// gainRMS = 1.3 / gainMeanValue;
-// offsetRMS = 2.0 / m_Threshold;
-// }
+ std::vector<float> gain(6, 0.0);
+ std::vector<float> offset(6, 0.0);
+ std::vector<float> S1(6, 0.0);
+ std::vector<float> S2(6, 0.0);
+ std::vector<float> sinfi(6, 0.0);
+ std::vector<float> cosfi(6, 0.0);
+ float gainRMS = 0.0;
+ float offsetRMS = 0.0;
+
+ for (int i = 0; i < 6; ++i) {
+ // Some very few chips have 0 values, dead/bypassed/etc, so check and use some fixed values instead
+ if (gainByChipVect[i] > 0.1) {
+ gain[i] = gainByChipVect[i] / gainMeanValue;
+ offset[i] = offsetByChipVect[i] / m_Threshold;
+ gainRMS = gainRMSByChipVect[i] / gainMeanValue;
+ offsetRMS = offsetRMSByChipVect[i] / m_Threshold;
+ } else {
+ gain[i] = 55.0 / gainMeanValue;
+ offset[i] = 42.0 / m_Threshold;
+ gainRMS = 1.3 / gainMeanValue;
+ offsetRMS = 2.0 / m_Threshold;
+ }
-// float W = m_OGcorr * gainRMS * offsetRMS / (gainRMS * gainRMS - offsetRMS * offsetRMS);
-// float A = 4 * W * W + 1.0;
-// float x1 = (A - sqrt(A)) / (2.0 * A);
-// sinfi[i] = sqrt(x1);
-// cosfi[i] = sqrt(1.0 - x1);
-// sinfi[i] = sinfi[i] * m_OGcorr / fabs(m_OGcorr);
-// float S = gainRMS * gainRMS + offsetRMS * offsetRMS;
-// float D = (gainRMS * gainRMS - offsetRMS * offsetRMS) / (cosfi[i] * cosfi[i] - sinfi[i] * sinfi[i]);
-// S1[i] = sqrt((S + D) / 2.0);
-// S2[i] = sqrt((S - D) / 2.0);
-// }
+ float W = m_OGcorr * gainRMS * offsetRMS / (gainRMS * gainRMS - offsetRMS * offsetRMS);
+ float A = 4 * W * W + 1.0;
+ float x1 = (A - sqrt(A)) / (2.0 * A);
+ sinfi[i] = sqrt(x1);
+ cosfi[i] = sqrt(1.0 - x1);
+ sinfi[i] = sinfi[i] * m_OGcorr / fabs(m_OGcorr);
+ float S = gainRMS * gainRMS + offsetRMS * offsetRMS;
+ float D = (gainRMS * gainRMS - offsetRMS * offsetRMS) / (cosfi[i] * cosfi[i] - sinfi[i] * sinfi[i]);
+ S1[i] = sqrt((S + D) / 2.0);
+ S2[i] = sqrt((S - D) / 2.0);
+ }
-// // Loop over collection and setup gain/offset/noise for the hit and neighbouring strips
-// SiChargedDiodeIterator i_chargedDiode = collection.begin();
-// SiChargedDiodeIterator i_chargedDiode_end = collection.end();
-
-// for (; i_chargedDiode != i_chargedDiode_end; ++i_chargedDiode) {
-// SiChargedDiode diode = (*i_chargedDiode).second;
-// // should be const as we aren't trying to change it here - but getReadoutCell() is not a const method...
-// unsigned int flagmask = diode.flag() & 0xFE;
-// // Get the flag for this diode ( if flagmask = 1 If diode is disconnected/disabled skip it)
-// if (!flagmask) { // If the diode is OK (not flagged)
-// const SiReadoutCellId roCell = diode.getReadoutCell();
-
-// if (roCell.isValid()) {
-// int strip = roCell.strip();
-// int i = std::max(strip - 1, 0);
-// int i_end = std::min(strip + 2, m_strip_max.load());
-
-// // loop over strips
-// for (; i < i_end; i++) {
-// // Need to check if strip is already setup
-// if (data.m_Analogue[1][i] <= 0.0) {
-// // Values depends on which chip the strip is on (complex when strip is on chip edge)
-// int chip = i / 128;
-// float g = CLHEP::RandGaussZiggurat::shoot(rndmEngine, 0.0, S1[chip]);
-// float o = CLHEP::RandGaussZiggurat::shoot(rndmEngine, 0.0, S2[chip]);
-
-// data.m_GainFactor[i] = gain[chip] + (cosfi[chip] * g + sinfi[chip] * o);
-// data.m_Offset[i] = offset[chip] + (cosfi[chip] * o - sinfi[chip] * g);
-// data.m_NoiseFactor[i] = noiseByChipVect[chip];
-
-// // Fill the noise and offset values into the Analogue
-// if (m_data_compression_mode == 1 and m_data_readout_mode == 0) { // level mode x1x
-// data.m_Analogue[1][i] = data.m_Offset[i] + data.m_NoiseFactor[i] * CLHEP::RandGaussZiggurat::shoot(rndmEngine);
-// } else if (m_data_compression_mode == 2 and m_data_readout_mode == 0) { // edge mode 01x
-// data.m_Analogue[0][i] = data.m_Offset[i] + data.m_NoiseFactor[i] * CLHEP::RandGaussZiggurat::shoot(rndmEngine);
-// data.m_Analogue[1][i] = data.m_Offset[i] + data.m_NoiseFactor[i] * CLHEP::RandGaussZiggurat::shoot(rndmEngine);
-// } else if (m_data_compression_mode == 3 or m_data_readout_mode == 1) { // any hit mode xxx or expanded read out mode
-// data.m_Analogue[0][i] = data.m_Offset[i] + data.m_NoiseFactor[i] * CLHEP::RandGaussZiggurat::shoot(rndmEngine);
-// data.m_Analogue[1][i] = data.m_Offset[i] + data.m_NoiseFactor[i] * CLHEP::RandGaussZiggurat::shoot(rndmEngine);
-// data.m_Analogue[2][i] = data.m_Offset[i] + data.m_NoiseFactor[i] * CLHEP::RandGaussZiggurat::shoot(rndmEngine);
-// }
-// }
-// }
-// }
-// }
-// }
+ // Loop over collection and setup gain/offset/noise for the hit and neighbouring strips
+ SiChargedDiodeIterator i_chargedDiode = collection.begin();
+ SiChargedDiodeIterator i_chargedDiode_end = collection.end();
-// return StatusCode::SUCCESS;
-// }
+ for (; i_chargedDiode != i_chargedDiode_end; ++i_chargedDiode) {
+ SiChargedDiode diode = (*i_chargedDiode).second;
+ // should be const as we aren't trying to change it here - but getReadoutCell() is not a const method...
+ unsigned int flagmask = diode.flag() & 0xFE;
+ // Get the flag for this diode ( if flagmask = 1 If diode is disconnected/disabled skip it)
+ if (!flagmask) { // If the diode is OK (not flagged)
+ const SiReadoutCellId roCell = diode.getReadoutCell();
+
+ if (roCell.isValid()) {
+ int strip = roCell.strip();
+ int i = std::max(strip - 1, 0);
+ int i_end = std::min(strip + 2, m_strip_max.load());
+
+ // loop over strips
+ for (; i < i_end; i++) {
+ // Need to check if strip is already setup
+ if (data.m_Analogue[1][i] <= 0.0) {
+ // Values depends on which chip the strip is on (complex when strip is on chip edge)
+ int chip = i / 128;
+ float g = CLHEP::RandGaussZiggurat::shoot(rndmEngine, 0.0, S1[chip]);
+ float o = CLHEP::RandGaussZiggurat::shoot(rndmEngine, 0.0, S2[chip]);
+
+ data.m_GainFactor[i] = gain[chip] + (cosfi[chip] * g + sinfi[chip] * o);
+ data.m_Offset[i] = offset[chip] + (cosfi[chip] * o - sinfi[chip] * g);
+ data.m_NoiseFactor[i] = noiseByChipVect[chip];
+
+ // Fill the noise and offset values into the Analogue
+ if (m_data_compression_mode == 1 and m_data_readout_mode == 0) { // level mode x1x
+ data.m_Analogue[1][i] = data.m_Offset[i] + data.m_NoiseFactor[i] * CLHEP::RandGaussZiggurat::shoot(rndmEngine);
+ } else if (m_data_compression_mode == 2 and m_data_readout_mode == 0) { // edge mode 01x
+ data.m_Analogue[0][i] = data.m_Offset[i] + data.m_NoiseFactor[i] * CLHEP::RandGaussZiggurat::shoot(rndmEngine);
+ data.m_Analogue[1][i] = data.m_Offset[i] + data.m_NoiseFactor[i] * CLHEP::RandGaussZiggurat::shoot(rndmEngine);
+ } else if (m_data_compression_mode == 3 or m_data_readout_mode == 1) { // any hit mode xxx or expanded read out mode
+ data.m_Analogue[0][i] = data.m_Offset[i] + data.m_NoiseFactor[i] * CLHEP::RandGaussZiggurat::shoot(rndmEngine);
+ data.m_Analogue[1][i] = data.m_Offset[i] + data.m_NoiseFactor[i] * CLHEP::RandGaussZiggurat::shoot(rndmEngine);
+ data.m_Analogue[2][i] = data.m_Offset[i] + data.m_NoiseFactor[i] * CLHEP::RandGaussZiggurat::shoot(rndmEngine);
+ }
+ }
+ }
+ }
+ }
+ }
+
+ return StatusCode::SUCCESS;
+}
// ----------------------------------------------------------------------
//
// ----------------------------------------------------------------------
-StatusCode SCT_FrontEnd::randomNoise(SiChargedDiodeCollection& collection, /*const Identifier& moduleId,*/ CLHEP::HepRandomEngine * rndmEngine, SCT_FrontEndData& data) const {
+StatusCode FaserSCT_FrontEnd::randomNoise(SiChargedDiodeCollection& collection, /*const Identifier& moduleId,*/ CLHEP::HepRandomEngine * rndmEngine, SCT_FrontEndData& data) const {
// Add random noise
double occupancy = 0.0;
@@ -460,109 +460,109 @@ StatusCode SCT_FrontEnd::randomNoise(SiChargedDiodeCollection& collection, /*con
// ----------------------------------------------------------------------
//
// ----------------------------------------------------------------------
-// StatusCode SCT_FrontEnd::randomNoise(SiChargedDiodeCollection& collection, const Identifier& moduleId, int side, CLHEP::HepRandomEngine * rndmEngine, SCT_FrontEndData& data) const {
-// const int n_chips = 6;
-// const int chipStripmax = m_strip_max / n_chips;
-// std::vector<float> NOByChipVect(n_chips, 0.0);
-// std::vector<float> ENCByChipVect(n_chips, 0.0);
-// std::vector<int> nNoisyStrips(n_chips, 0);
-// double mode = 1.;
-
-// const bool noise_expanded_mode = (m_data_compression_mode == 3 and m_data_readout_mode == 1);
-
-// // Will give 3 times as much noise occupancy if running in any hit expanded mode
-// if (noise_expanded_mode) {
-// mode = 3.;
-// }
+StatusCode FaserSCT_FrontEnd::randomNoise(SiChargedDiodeCollection& collection, const Identifier& moduleId, int side, CLHEP::HepRandomEngine * rndmEngine, SCT_FrontEndData& data) const {
+ const int n_chips = 6;
+ const int chipStripmax = m_strip_max / n_chips;
+ std::vector<float> NOByChipVect(n_chips, 0.0);
+ std::vector<float> ENCByChipVect(n_chips, 0.0);
+ std::vector<int> nNoisyStrips(n_chips, 0);
+ double mode = 1.;
-// // Get chip data from calib DB
-// NOByChipVect = m_ReadCalibChipDataTool->getNoiseOccupancyData(moduleId, side, "OccupancyByChip");
-// ENCByChipVect = m_ReadCalibChipDataTool->getNPtGainData(moduleId, side, "NoiseByChip");
+ const bool noise_expanded_mode = (m_data_compression_mode == 3 and m_data_readout_mode == 1);
-// // Need to check if empty, most should have data, but a few old DEAD modules don't, and 9C...
-// if (NOByChipVect.empty()) {
-// ATH_MSG_DEBUG("No calibration data in cond DB for module " << moduleId << " using JO values");
-// if (StatusCode::SUCCESS != randomNoise(collection, moduleId, rndmEngine, data)) {
-// return StatusCode::FAILURE;
-// } else {
-// return StatusCode::SUCCESS;
-// }
-// } else {
-// for (int i = 0; i < n_chips; i++) {
-// // A 0 value can mean two things now, chip out of config for long time and no value was uploaded
-// // or its short middles and inners and the value is for all purposes 0! so ok.
-
-// // Modify the occupancy if threshold is not 1.0 fC
-// if (m_Threshold > 6242.3 or m_Threshold < 6242.1) {
-// constexpr float fC = 6242.2;
-// NOByChipVect[i] = NOByChipVect[i] * exp(-(0.5 / (ENCByChipVect[i]*ENCByChipVect[i]) * (m_Threshold*m_Threshold - fC*fC)));
-// }
+ // Will give 3 times as much noise occupancy if running in any hit expanded mode
+ if (noise_expanded_mode) {
+ mode = 3.;
+ }
-// nNoisyStrips[i] = CLHEP::RandPoisson::shoot(rndmEngine, chipStripmax * NOByChipVect[i] * mode);
-// }
-// }
+ // Get chip data from calib DB
+ NOByChipVect = m_ReadCalibChipDataTool->getNoiseOccupancyData(moduleId, side, "OccupancyByChip");
+ ENCByChipVect = m_ReadCalibChipDataTool->getNPtGainData(moduleId, side, "NoiseByChip");
+
+ // Need to check if empty, most should have data, but a few old DEAD modules don't, and 9C...
+ if (NOByChipVect.empty()) {
+ ATH_MSG_DEBUG("No calibration data in cond DB for module " << moduleId << " using JO values");
+ if (StatusCode::SUCCESS != randomNoise(collection, /*moduleId,*/ rndmEngine, data)) {
+ return StatusCode::FAILURE;
+ } else {
+ return StatusCode::SUCCESS;
+ }
+ } else {
+ for (int i = 0; i < n_chips; i++) {
+ // A 0 value can mean two things now, chip out of config for long time and no value was uploaded
+ // or its short middles and inners and the value is for all purposes 0! so ok.
+
+ // Modify the occupancy if threshold is not 1.0 fC
+ if (m_Threshold > 6242.3 or m_Threshold < 6242.1) {
+ constexpr float fC = 6242.2;
+ NOByChipVect[i] = NOByChipVect[i] * exp(-(0.5 / (ENCByChipVect[i]*ENCByChipVect[i]) * (m_Threshold*m_Threshold - fC*fC)));
+ }
-// // Loop over the chips on the wafer
-// for (int chip_index = 0; chip_index < n_chips; ++chip_index) {
-// int chip_strip_offset = chipStripmax * chip_index; // First strip number on chip
-
-// // Calculate the number of "free strips" on this chip
-// int nEmptyStripsOnChip = 0;
-// std::vector<int> emptyStripsOnChip;
-// emptyStripsOnChip.reserve(chipStripmax);
-// for (int i = 0; i < chipStripmax; i++) {
-// if (data.m_StripHitsOnWafer[i + chip_strip_offset] == 0) {
-// emptyStripsOnChip.push_back(i);
-// ++nEmptyStripsOnChip;
-// }
-// }
+ nNoisyStrips[i] = CLHEP::RandPoisson::shoot(rndmEngine, chipStripmax * NOByChipVect[i] * mode);
+ }
+ }
-// // if no empty strips on chip do nothing
-// if (nEmptyStripsOnChip != 0) {
-// // Check and adapt the number of noisy strips to the number of free strips
-// if (nEmptyStripsOnChip < nNoisyStrips[chip_index]) {
-// nNoisyStrips[chip_index] = nEmptyStripsOnChip;
-// }
+ // Loop over the chips on the wafer
+ for (int chip_index = 0; chip_index < n_chips; ++chip_index) {
+ int chip_strip_offset = chipStripmax * chip_index; // First strip number on chip
+
+ // Calculate the number of "free strips" on this chip
+ int nEmptyStripsOnChip = 0;
+ std::vector<int> emptyStripsOnChip;
+ emptyStripsOnChip.reserve(chipStripmax);
+ for (int i = 0; i < chipStripmax; i++) {
+ if (data.m_StripHitsOnWafer[i + chip_strip_offset] == 0) {
+ emptyStripsOnChip.push_back(i);
+ ++nEmptyStripsOnChip;
+ }
+ }
-// // Find random strips to get noise hits
-// for (int i = 0; i < nNoisyStrips[chip_index]; i++) {
-// int index = CLHEP::RandFlat::shootInt(rndmEngine, nEmptyStripsOnChip - i);
-// int strip_on_chip = emptyStripsOnChip.at(index);
-// emptyStripsOnChip.erase(emptyStripsOnChip.begin()+index); // Erase it not to use it again
-// int strip = strip_on_chip + chip_strip_offset;
-// if (data.m_StripHitsOnWafer[strip]!=0) {
-// ATH_MSG_ERROR(index << "-th empty strip, strip " << strip << " should be empty but is not empty! Something is wrong!");
-// }
-// data.m_StripHitsOnWafer[strip] = 3; // !< Random Noise hit
-// // Add tbin info to noise diode
-// if (noise_expanded_mode) { // !< if any hit mode, any time bin
-// // !< otherwise fixed tbin=2
-// int noise_tbin = CLHEP::RandFlat::shootInt(rndmEngine, 3);
-// // !< random number 0, 1 or 2
-// if (noise_tbin == 0) {
-// noise_tbin = 4; // !< now 1, 2 or 4
-// }
-// if (StatusCode::SUCCESS != addNoiseDiode(collection, strip, noise_tbin)) {
-// ATH_MSG_ERROR("Can't add noise hit diode to collection");
-// }
-// } else {
-// if (StatusCode::SUCCESS != addNoiseDiode(collection, strip, 2)) {
-// ATH_MSG_ERROR("Can't add noise hit diode to collection");
-// }
-// }
-// }
-// }
-// }
+ // if no empty strips on chip do nothing
+ if (nEmptyStripsOnChip != 0) {
+ // Check and adapt the number of noisy strips to the number of free strips
+ if (nEmptyStripsOnChip < nNoisyStrips[chip_index]) {
+ nNoisyStrips[chip_index] = nEmptyStripsOnChip;
+ }
-// return StatusCode::SUCCESS;
-// }
+ // Find random strips to get noise hits
+ for (int i = 0; i < nNoisyStrips[chip_index]; i++) {
+ int index = CLHEP::RandFlat::shootInt(rndmEngine, nEmptyStripsOnChip - i);
+ int strip_on_chip = emptyStripsOnChip.at(index);
+ emptyStripsOnChip.erase(emptyStripsOnChip.begin()+index); // Erase it not to use it again
+ int strip = strip_on_chip + chip_strip_offset;
+ if (data.m_StripHitsOnWafer[strip]!=0) {
+ ATH_MSG_ERROR(index << "-th empty strip, strip " << strip << " should be empty but is not empty! Something is wrong!");
+ }
+ data.m_StripHitsOnWafer[strip] = 3; // !< Random Noise hit
+ // Add tbin info to noise diode
+ if (noise_expanded_mode) { // !< if any hit mode, any time bin
+ // !< otherwise fixed tbin=2
+ int noise_tbin = CLHEP::RandFlat::shootInt(rndmEngine, 3);
+ // !< random number 0, 1 or 2
+ if (noise_tbin == 0) {
+ noise_tbin = 4; // !< now 1, 2 or 4
+ }
+ if (StatusCode::SUCCESS != addNoiseDiode(collection, strip, noise_tbin)) {
+ ATH_MSG_ERROR("Can't add noise hit diode to collection");
+ }
+ } else {
+ if (StatusCode::SUCCESS != addNoiseDiode(collection, strip, 2)) {
+ ATH_MSG_ERROR("Can't add noise hit diode to collection");
+ }
+ }
+ }
+ }
+ }
+
+ return StatusCode::SUCCESS;
+}
// ----------------------------------------------------------------------
// process the collection of pre digits this will need to go through
// all single-strip pre-digits calculate the amplifier response add noise
// (this could be moved elsewhere later) apply threshold do clustering
// ----------------------------------------------------------------------
-void SCT_FrontEnd::process(SiChargedDiodeCollection& collection, CLHEP::HepRandomEngine * rndmEngine) const {
+void FaserSCT_FrontEnd::process(SiChargedDiodeCollection& collection, CLHEP::HepRandomEngine * rndmEngine) const {
// get SCT module side design and check it
const SCT_ModuleSideDesign *p_design = dynamic_cast<const SCT_ModuleSideDesign*>(&(collection.design()));
@@ -604,18 +604,18 @@ void SCT_FrontEnd::process(SiChargedDiodeCollection& collection, CLHEP::HepRando
}
// Get wafer, moduleId and side
-// Identifier waferId = collection.identify();
-// Identifier moduleId = m_sct_id->module_id(waferId);
-// const int side = m_sct_id->side(waferId);
+ Identifier waferId = collection.identify();
+ Identifier moduleId = m_sct_id->module_id(waferId);
+ const int side = m_sct_id->side(waferId);
// Check if collection empty
if (not collection.empty()) {
// Setup gain/offset/noise to the hit and neighbouring strips
if (m_useCalibData) { // Use calib cond DB data
- ATH_MSG_FATAL("Use of calibration data not supported.");
- // if (StatusCode::SUCCESS != prepareGainAndOffset(collection, side, moduleId, rndmEngine, data)) {
- // ATH_MSG_ERROR("\tCan't prepare Gain and Offset");
- // }
+ // ATH_MSG_FATAL("Use of calibration data not supported.");
+ if (StatusCode::SUCCESS != prepareGainAndOffset(collection, side, moduleId, rndmEngine, data)) {
+ ATH_MSG_ERROR("\tCan't prepare Gain and Offset");
+ }
} else { // Use JO values
if (StatusCode::SUCCESS != prepareGainAndOffset(collection, /*moduleId,*/ rndmEngine, data)) {
ATH_MSG_ERROR("\tCan't prepare Gain and Offset");
@@ -637,10 +637,10 @@ void SCT_FrontEnd::process(SiChargedDiodeCollection& collection, CLHEP::HepRando
if (m_NoiseOn) {
if (m_useCalibData) { // Check if using DB or not
- ATH_MSG_FATAL("Use of calibration data not supported.");
- // if (StatusCode::SUCCESS != randomNoise(collection, moduleId, side, rndmEngine, data)) {
- // ATH_MSG_ERROR("\tCan't do random noise on wafer?!");
- // }
+ // ATH_MSG_FATAL("Use of calibration data not supported.");
+ if (StatusCode::SUCCESS != randomNoise(collection, moduleId, side, rndmEngine, data)) {
+ ATH_MSG_ERROR("\tCan't do random noise on wafer?!");
+ }
} else { // Use JO fixed values
if (StatusCode::SUCCESS != randomNoise(collection, /*moduleId,*/ rndmEngine, data)) {
ATH_MSG_ERROR("\tCan't do random noise on wafer?!");
@@ -654,7 +654,7 @@ void SCT_FrontEnd::process(SiChargedDiodeCollection& collection, CLHEP::HepRando
}
}
-StatusCode SCT_FrontEnd::doSignalChargeForHits(SiChargedDiodeCollection& collection, SCT_FrontEndData& data) const {
+StatusCode FaserSCT_FrontEnd::doSignalChargeForHits(SiChargedDiodeCollection& collection, SCT_FrontEndData& data) const {
typedef SiTotalCharge::list_t list_t;
// *****************************************************************************
@@ -741,7 +741,7 @@ StatusCode SCT_FrontEnd::doSignalChargeForHits(SiChargedDiodeCollection& collect
return StatusCode::SUCCESS;
}
-StatusCode SCT_FrontEnd::doThresholdCheckForRealHits(SiChargedDiodeCollection& collection, SCT_FrontEndData& data) const {
+StatusCode FaserSCT_FrontEnd::doThresholdCheckForRealHits(SiChargedDiodeCollection& collection, SCT_FrontEndData& data) const {
// **********************************************************************************
// Flag strips below threshold and flag the threshold check into data.m_StripHitsOnWafer
// **********************************************************************************
@@ -830,7 +830,7 @@ StatusCode SCT_FrontEnd::doThresholdCheckForRealHits(SiChargedDiodeCollection& c
// ----------------------------------------------------------------------
//
// ----------------------------------------------------------------------
-StatusCode SCT_FrontEnd::doThresholdCheckForCrosstalkHits(SiChargedDiodeCollection& collection, SCT_FrontEndData& data) const {
+StatusCode FaserSCT_FrontEnd::doThresholdCheckForCrosstalkHits(SiChargedDiodeCollection& collection, SCT_FrontEndData& data) const {
// Check for noise+crosstalk strips above threshold
// data.m_StripHitsOnWafer: real hits above threshold == 1 or below/disconnected
// == -1
@@ -914,7 +914,7 @@ StatusCode SCT_FrontEnd::doThresholdCheckForCrosstalkHits(SiChargedDiodeCollecti
return StatusCode::SUCCESS;
}
-StatusCode SCT_FrontEnd::doClustering(SiChargedDiodeCollection& collection, SCT_FrontEndData& data) const {
+StatusCode FaserSCT_FrontEnd::doClustering(SiChargedDiodeCollection& collection, SCT_FrontEndData& data) const {
// ********************************
// now do clustering
// ********************************
@@ -1008,7 +1008,7 @@ StatusCode SCT_FrontEnd::doClustering(SiChargedDiodeCollection& collection, SCT_
return StatusCode::SUCCESS;
}
-StatusCode SCT_FrontEnd::addNoiseDiode(SiChargedDiodeCollection& collection, int strip, int tbin) const {
+StatusCode FaserSCT_FrontEnd::addNoiseDiode(SiChargedDiodeCollection& collection, int strip, int tbin) const {
const SiCellId ndiode(strip); // !< create a new diode
const SiCharge noiseCharge(2 * m_Threshold, 0, SiCharge::noise); // !< add some noise to it
collection.add(ndiode, noiseCharge); // !< add it to the collection
@@ -1024,7 +1024,7 @@ StatusCode SCT_FrontEnd::addNoiseDiode(SiChargedDiodeCollection& collection, int
return StatusCode::SUCCESS;
}
-float SCT_FrontEnd::meanValue(std::vector<float>& calibDataVect) const {
+float FaserSCT_FrontEnd::meanValue(std::vector<float>& calibDataVect) const {
float mean_value = 0.0;
int nData = 0;
const unsigned int vec_size = calibDataVect.size();
diff --git a/Tracker/TrackerDigitization/FaserSCT_Digitization/src/SCT_FrontEnd.h b/Tracker/TrackerDigitization/FaserSCT_Digitization/src/FaserSCT_FrontEnd.h
similarity index 85%
rename from Tracker/TrackerDigitization/FaserSCT_Digitization/src/SCT_FrontEnd.h
rename to Tracker/TrackerDigitization/FaserSCT_Digitization/src/FaserSCT_FrontEnd.h
index 03f34b2c9c1681ff32f919bde33c80f6ef7a1b0f..5fd95c66e8c2ff8835d1df59291243e36402871b 100644
--- a/Tracker/TrackerDigitization/FaserSCT_Digitization/src/SCT_FrontEnd.h
+++ b/Tracker/TrackerDigitization/FaserSCT_Digitization/src/FaserSCT_FrontEnd.h
@@ -5,7 +5,7 @@
*/
/**
- * Header file for SCT_FrontEnd Class
+ * Header file for FaserSCT_FrontEnd Class
* @brief simulation of the SCT front-end electronics
* working as a SiPreDigitsProcessor
* models response of ABCD chip amplifiers to
@@ -24,8 +24,8 @@
* - Conversion of the SCT_Front code Al gTool
*/
-#ifndef FASERSCT_DIGITIZATION_SCT_FRONTEND_H
-#define FASERSCT_DIGITIZATION_SCT_FRONTEND_H
+#ifndef FASERSCT_DIGITIZATION_FASERSCT_FRONTEND_H
+#define FASERSCT_DIGITIZATION_FASERSCT_FRONTEND_H
// Inheritance
#include "AthenaBaseComps/AthAlgTool.h"
@@ -33,7 +33,7 @@
// Athena
#include "FaserSiDigitization/SiChargedDiodeCollection.h"
-// #include "SCT_ConditionsTools/ISCT_ReadCalibChipDataTool.h"
+#include "SCT_ConditionsTools/ISCT_ReadCalibChipDataTool.h"
// Gaudi
#include "GaudiKernel/ToolHandle.h"
@@ -69,14 +69,14 @@ struct SCT_FrontEndData {
std::vector<int> m_StripHitsOnWafer; //!< Info about which strips are above threshold
};
-class SCT_FrontEnd : public extends<AthAlgTool, ISCT_FrontEnd> {
+class FaserSCT_FrontEnd : public extends<AthAlgTool, ISCT_FrontEnd> {
public:
/** constructor */
- SCT_FrontEnd(const std::string& type, const std::string& name, const IInterface* parent);
+ FaserSCT_FrontEnd(const std::string& type, const std::string& name, const IInterface* parent);
/** Destructor */
- virtual ~SCT_FrontEnd() = default;
+ virtual ~FaserSCT_FrontEnd() = default;
//PJ not needed after merging?!
/** AlgTool InterfaceID */
//static const InterfaceID& interfaceID();
@@ -96,9 +96,9 @@ class SCT_FrontEnd : public extends<AthAlgTool, ISCT_FrontEnd> {
StatusCode doThresholdCheckForCrosstalkHits(SiChargedDiodeCollection& collection, SCT_FrontEndData& data) const;
StatusCode doClustering(SiChargedDiodeCollection& collection, SCT_FrontEndData& data) const;
StatusCode prepareGainAndOffset(SiChargedDiodeCollection& collection, /*const Identifier& moduleId,*/ CLHEP::HepRandomEngine* rndmEngine, SCT_FrontEndData& data) const;
-// StatusCode prepareGainAndOffset(SiChargedDiodeCollection& collection, int side, const Identifier& moduleId, CLHEP::HepRandomEngine* rndmEngine, SCT_FrontEndData& data) const;
+ StatusCode prepareGainAndOffset(SiChargedDiodeCollection& collection, int side, const Identifier& moduleId, CLHEP::HepRandomEngine* rndmEngine, SCT_FrontEndData& data) const;
StatusCode randomNoise(SiChargedDiodeCollection& collection, /*const Identifier& moduleId,*/ CLHEP::HepRandomEngine* rndmEngine, SCT_FrontEndData& data) const;
-// StatusCode randomNoise(SiChargedDiodeCollection& collection, const Identifier& moduleId, int side, CLHEP::HepRandomEngine* rndmEngine, SCT_FrontEndData& data) const;
+ StatusCode randomNoise(SiChargedDiodeCollection& collection, const Identifier& moduleId, int side, CLHEP::HepRandomEngine* rndmEngine, SCT_FrontEndData& data) const;
StatusCode addNoiseDiode(SiChargedDiodeCollection& collection, int strip, int tbin) const;
float meanValue(std::vector<float>& calibDataVect) const;
StatusCode initVectors(int strips, SCT_FrontEndData& data) const;
@@ -128,8 +128,8 @@ class SCT_FrontEnd : public extends<AthAlgTool, ISCT_FrontEnd> {
ShortProperty m_data_readout_mode{this, "DataReadOutMode", 0, "Front End Data Read out mode Mode"};
BooleanProperty m_useCalibData{this, "UseCalibData", false, "Flag to set the use of calibration data for noise, Gain,offset etc."}; // was true in ATLAS
- ToolHandle<ISCT_Amp> m_sct_amplifier{this, "SCT_Amp", "SCT_Amp", "Handle the Amplifier tool"}; //!< Handle the Amplifier tool
-// ToolHandle<ISCT_ReadCalibChipDataTool> m_ReadCalibChipDataTool{this, "SCT_ReadCalibChipDataTool", "SCT_ReadCalibChipDataTool", "Tool to retrieve chip calibration information"}; //!< Handle to the Calibration ConditionsTool
+ ToolHandle<ISCT_Amp> m_sct_amplifier{this, "SCT_Amp", "FaserSCT_Amp", "Handle the Amplifier tool"}; //!< Handle the Amplifier tool
+ ToolHandle<ISCT_ReadCalibChipDataTool> m_ReadCalibChipDataTool{this, "SCT_ReadCalibChipDataTool", "SCT_ReadCalibChipDataTool", "Tool to retrieve chip calibration information"}; //!< Handle to the Calibration ConditionsTool
const TrackerDD::SCT_DetectorManager* m_SCTdetMgr{nullptr}; //!< Handle to SCT detector manager
const FaserSCT_ID* m_sct_id{nullptr}; //!< Handle to SCT ID helper
@@ -137,4 +137,4 @@ class SCT_FrontEnd : public extends<AthAlgTool, ISCT_FrontEnd> {
mutable std::atomic_int m_strip_max{768}; //!< For SLHC studies
};
-#endif //SCT_FRONTEND_H
+#endif //FASERSCT_FRONTEND_H
diff --git a/Tracker/TrackerDigitization/FaserSCT_Digitization/src/SCT_RandomDisabledCellGenerator.cxx b/Tracker/TrackerDigitization/FaserSCT_Digitization/src/FaserSCT_RandomDisabledCellGenerator.cxx
similarity index 59%
rename from Tracker/TrackerDigitization/FaserSCT_Digitization/src/SCT_RandomDisabledCellGenerator.cxx
rename to Tracker/TrackerDigitization/FaserSCT_Digitization/src/FaserSCT_RandomDisabledCellGenerator.cxx
index b170bd10f5c166e02e8258d5138f0fdd7fc23cac..12bfa50486018fe26d6ddc9ae331c038ae00bc90 100644
--- a/Tracker/TrackerDigitization/FaserSCT_Digitization/src/SCT_RandomDisabledCellGenerator.cxx
+++ b/Tracker/TrackerDigitization/FaserSCT_Digitization/src/FaserSCT_RandomDisabledCellGenerator.cxx
@@ -2,7 +2,7 @@
Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
*/
-#include "SCT_RandomDisabledCellGenerator.h"
+#include "FaserSCT_RandomDisabledCellGenerator.h"
#include "FaserSiDigitization/SiChargedDiodeCollection.h"
@@ -12,24 +12,24 @@
#include "CLHEP/Random/RandFlat.h"
// constructor
-SCT_RandomDisabledCellGenerator::SCT_RandomDisabledCellGenerator(const std::string& type, const std::string& name, const IInterface* parent)
+FaserSCT_RandomDisabledCellGenerator::FaserSCT_RandomDisabledCellGenerator(const std::string& type, const std::string& name, const IInterface* parent)
: base_class(type, name, parent)
{
}
-StatusCode SCT_RandomDisabledCellGenerator::initialize() {
- ATH_MSG_DEBUG("SCT_RandomDisabledCellGenerator::initialize()");
+StatusCode FaserSCT_RandomDisabledCellGenerator::initialize() {
+ ATH_MSG_DEBUG("FaserSCT_RandomDisabledCellGenerator::initialize()");
ATH_MSG_INFO("\tCreating missing bond generator with "<<m_disableProbability<<" probability");
return StatusCode::SUCCESS;
}
-StatusCode SCT_RandomDisabledCellGenerator::finalize() {
- ATH_MSG_INFO("SCT_RandomDisabledCellGenerator::finalize()");
+StatusCode FaserSCT_RandomDisabledCellGenerator::finalize() {
+ ATH_MSG_INFO("FaserSCT_RandomDisabledCellGenerator::finalize()");
return StatusCode::SUCCESS;
}
// process the collection
-void SCT_RandomDisabledCellGenerator::process(SiChargedDiodeCollection& collection, CLHEP::HepRandomEngine * rndmEngine) const {
+void FaserSCT_RandomDisabledCellGenerator::process(SiChargedDiodeCollection& collection, CLHEP::HepRandomEngine * rndmEngine) const {
// disabling is applied to all cells even unconnected or below threshold ones to be able to use these cells as well
// loop on all charged diodes
for (std::pair<const TrackerDD::SiCellId, SiChargedDiode>& chargedDiode: collection) {
diff --git a/Tracker/TrackerDigitization/FaserSCT_Digitization/src/SCT_RandomDisabledCellGenerator.h b/Tracker/TrackerDigitization/FaserSCT_Digitization/src/FaserSCT_RandomDisabledCellGenerator.h
similarity index 74%
rename from Tracker/TrackerDigitization/FaserSCT_Digitization/src/SCT_RandomDisabledCellGenerator.h
rename to Tracker/TrackerDigitization/FaserSCT_Digitization/src/FaserSCT_RandomDisabledCellGenerator.h
index 1ea27123d73228fb6fd62fb6960ed8daa24472be..1754db0b968a7f9394ca03e6bc6481e91a7d3f8a 100644
--- a/Tracker/TrackerDigitization/FaserSCT_Digitization/src/SCT_RandomDisabledCellGenerator.h
+++ b/Tracker/TrackerDigitization/FaserSCT_Digitization/src/FaserSCT_RandomDisabledCellGenerator.h
@@ -5,8 +5,8 @@
*/
///////////////////////////////////////////////////////////////////
-// SCT_RandomDisabledCellGenerator.h
-// Header file for class SCT_RandomDisabledCellGenerator
+// FaserSCT_RandomDisabledCellGenerator.h
+// Header file for class FaserSCT_RandomDisabledCellGenerator
///////////////////////////////////////////////////////////////////
// Class to randomly disable cells for SCT
///////////////////////////////////////////////////////////////////
@@ -18,8 +18,8 @@
// This can be used for disabling, disconnecting, and flagging bad_tot
///////////////////////////////////////////////////////////////////
-#ifndef FASERSCT_DIGITIZATION_SCT_RANDOMDISABLEDCELLGENERATOR_H
-#define FASERSCT_DIGITIZATION_SCT_RANDOMDISABLEDCELLGENERATOR_H
+#ifndef FASERSCT_DIGITIZATION_FASERSCT_RANDOMDISABLEDCELLGENERATOR_H
+#define FASERSCT_DIGITIZATION_FASERSCT_RANDOMDISABLEDCELLGENERATOR_H
//Inheritance
#include "AthenaBaseComps/AthAlgTool.h"
@@ -32,7 +32,7 @@ namespace CLHEP {
class HepRandomEngine;
}
-class SCT_RandomDisabledCellGenerator : public extends<AthAlgTool, ISCT_RandomDisabledCellGenerator> {
+class FaserSCT_RandomDisabledCellGenerator : public extends<AthAlgTool, ISCT_RandomDisabledCellGenerator> {
///////////////////////////////////////////////////////////////////
// Public methods:
@@ -41,10 +41,10 @@ class SCT_RandomDisabledCellGenerator : public extends<AthAlgTool, ISCT_RandomDi
public:
/** constructor */
- SCT_RandomDisabledCellGenerator(const std::string& type, const std::string& name, const IInterface* parent) ;
+ FaserSCT_RandomDisabledCellGenerator(const std::string& type, const std::string& name, const IInterface* parent) ;
/** Destructor */
- virtual ~SCT_RandomDisabledCellGenerator() = default;
+ virtual ~FaserSCT_RandomDisabledCellGenerator() = default;
/** AlgTool initialize */
virtual StatusCode initialize() override;
@@ -64,4 +64,4 @@ class SCT_RandomDisabledCellGenerator : public extends<AthAlgTool, ISCT_RandomDi
};
-#endif //FASERSCT_DIGITIZATION_SCT_RANDOMDISABLEDCELLGENERATOR_H
+#endif //FASERSCT_DIGITIZATION_FASERSCT_RANDOMDISABLEDCELLGENERATOR_H
diff --git a/Tracker/TrackerDigitization/FaserSCT_Digitization/src/SCT_SurfaceChargesGenerator.cxx b/Tracker/TrackerDigitization/FaserSCT_Digitization/src/FaserSCT_SurfaceChargesGenerator.cxx
similarity index 91%
rename from Tracker/TrackerDigitization/FaserSCT_Digitization/src/SCT_SurfaceChargesGenerator.cxx
rename to Tracker/TrackerDigitization/FaserSCT_Digitization/src/FaserSCT_SurfaceChargesGenerator.cxx
index b05cd7b4468a07ce90afc0346eeb6f07ed77d442..3978d87d8c8e896b5230b6ccaa1de6eca6f8793f 100644
--- a/Tracker/TrackerDigitization/FaserSCT_Digitization/src/SCT_SurfaceChargesGenerator.cxx
+++ b/Tracker/TrackerDigitization/FaserSCT_Digitization/src/FaserSCT_SurfaceChargesGenerator.cxx
@@ -2,7 +2,7 @@
Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
*/
-#include "SCT_SurfaceChargesGenerator.h"
+#include "FaserSCT_SurfaceChargesGenerator.h"
// DD
#include "TrackerReadoutGeometry/SiDetectorElement.h"
@@ -14,9 +14,9 @@
#include "HitManagement/TimedHitPtr.h" // for TimedHitPtr
// ROOT
-#include "TH1.h" // for TH1F
-#include "TH2.h" // for TH2F
-#include "TProfile.h" // for TProfile
+// #include "TH1.h" // for TH1F
+// #include "TH2.h" // for TH2F
+// #include "TProfile.h" // for TProfile
// CLHEP
#include "CLHEP/Geometry/Point3D.h"
@@ -34,7 +34,7 @@ using TrackerDD::SiLocalPosition;
using namespace std;
// constructor
-SCT_SurfaceChargesGenerator::SCT_SurfaceChargesGenerator(const std::string& type,
+FaserSCT_SurfaceChargesGenerator::FaserSCT_SurfaceChargesGenerator(const std::string& type,
const std::string& name,
const IInterface* parent)
: base_class(type, name, parent) {
@@ -43,14 +43,14 @@ SCT_SurfaceChargesGenerator::SCT_SurfaceChargesGenerator(const std::string& type
// ----------------------------------------------------------------------
// Initialize
// ----------------------------------------------------------------------
-StatusCode SCT_SurfaceChargesGenerator::initialize() {
- ATH_MSG_DEBUG("SCT_SurfaceChargesGenerator::initialize()");
+StatusCode FaserSCT_SurfaceChargesGenerator::initialize() {
+ ATH_MSG_DEBUG("FaserSCT_SurfaceChargesGenerator::initialize()");
- // Get ISiPropertiesTool
+ // Get IFaserSiPropertiesTool
ATH_CHECK(m_siPropertiesTool.retrieve());
// Get ISiliconConditionsSvc
-// ATH_CHECK(m_siConditionsTool.retrieve());
+ ATH_CHECK(m_siConditionsTool.retrieve());
if (m_doTrapping) {
// -- Get Radiation Damage Tool
@@ -168,22 +168,22 @@ StatusCode SCT_SurfaceChargesGenerator::initialize() {
// ----------------------------------------------------------------------
// finalize
// ----------------------------------------------------------------------
-StatusCode SCT_SurfaceChargesGenerator::finalize() {
- ATH_MSG_DEBUG("SCT_SurfaceChargesGenerator::finalize()");
+StatusCode FaserSCT_SurfaceChargesGenerator::finalize() {
+ ATH_MSG_DEBUG("FaserSCT_SurfaceChargesGenerator::finalize()");
return StatusCode::SUCCESS;
}
// ----------------------------------------------------------------------
// perpandicular Drift time calculation
// ----------------------------------------------------------------------
-float SCT_SurfaceChargesGenerator::driftTime(float zhit, const SiDetectorElement* element) const {
+float FaserSCT_SurfaceChargesGenerator::driftTime(float zhit, const SiDetectorElement* element) const {
if (element==nullptr) {
- ATH_MSG_ERROR("SCT_SurfaceChargesGenerator::process element is nullptr");
+ ATH_MSG_ERROR("FaserSCT_SurfaceChargesGenerator::process element is nullptr");
return -2.0;
}
const SCT_ModuleSideDesign* design{dynamic_cast<const SCT_ModuleSideDesign*>(&(element->design()))};
if (design==nullptr) {
- ATH_MSG_ERROR("SCT_SurfaceChargesGenerator::process can not get " << design);
+ ATH_MSG_ERROR("FaserSCT_SurfaceChargesGenerator::process can not get " << design);
return -2.0;
}
const double thickness{design->thickness()};
@@ -197,9 +197,9 @@ float SCT_SurfaceChargesGenerator::driftTime(float zhit, const SiDetectorElement
float depletionVoltage{0.};
float biasVoltage{0.};
if (m_useSiCondDB) {
- ATH_MSG_FATAL("Conditions DB voltages not supported.");
- // depletionVoltage = m_siConditionsTool->depletionVoltage(hashId) * CLHEP::volt;
- // biasVoltage = m_siConditionsTool->biasVoltage(hashId) * CLHEP::volt;
+ // ATH_MSG_FATAL("Conditions DB voltages not supported.");
+ depletionVoltage = m_siConditionsTool->depletionVoltage(hashId) * CLHEP::volt;
+ biasVoltage = m_siConditionsTool->biasVoltage(hashId) * CLHEP::volt;
} else {
depletionVoltage = m_vdepl * CLHEP::volt;
biasVoltage = m_vbias * CLHEP::volt;
@@ -226,9 +226,9 @@ float SCT_SurfaceChargesGenerator::driftTime(float zhit, const SiDetectorElement
// ----------------------------------------------------------------------
// Sigma diffusion calculation
// ----------------------------------------------------------------------
-float SCT_SurfaceChargesGenerator::diffusionSigma(float zhit, const SiDetectorElement* element) const {
+float FaserSCT_SurfaceChargesGenerator::diffusionSigma(float zhit, const SiDetectorElement* element) const {
if (element==nullptr) {
- ATH_MSG_ERROR("SCT_SurfaceChargesGenerator::diffusionSigma element is nullptr");
+ ATH_MSG_ERROR("FaserSCT_SurfaceChargesGenerator::diffusionSigma element is nullptr");
return 0.0;
}
const IdentifierHash hashId{element->identifyHash()};
@@ -245,7 +245,7 @@ float SCT_SurfaceChargesGenerator::diffusionSigma(float zhit, const SiDetectorEl
// ----------------------------------------------------------------------
// Maximum drift time
// ----------------------------------------------------------------------
-float SCT_SurfaceChargesGenerator::maxDriftTime(const SiDetectorElement* element) const {
+float FaserSCT_SurfaceChargesGenerator::maxDriftTime(const SiDetectorElement* element) const {
if (element) {
const float sensorThickness{static_cast<float>(element->thickness())};
return driftTime(sensorThickness, element);
@@ -258,7 +258,7 @@ float SCT_SurfaceChargesGenerator::maxDriftTime(const SiDetectorElement* element
// ----------------------------------------------------------------------
// Maximum Sigma difusion
// ----------------------------------------------------------------------
-float SCT_SurfaceChargesGenerator::maxDiffusionSigma(const SiDetectorElement* element) const {
+float FaserSCT_SurfaceChargesGenerator::maxDiffusionSigma(const SiDetectorElement* element) const {
if (element) {
const float sensorThickness{static_cast<float>(element->thickness())};
return diffusionSigma(sensorThickness, element);
@@ -272,7 +272,7 @@ float SCT_SurfaceChargesGenerator::maxDiffusionSigma(const SiDetectorElement* el
// Calculating the surface drift time but I should confess that
// I haven't found out yet where the calculation come from
// ----------------------------------------------------------------------
-float SCT_SurfaceChargesGenerator::surfaceDriftTime(float ysurf) const {
+float FaserSCT_SurfaceChargesGenerator::surfaceDriftTime(float ysurf) const {
if (m_SurfaceDriftFlag) {
if ((ysurf >= 0.0) and (ysurf <= m_distInterStrip)) {
float t_surfaceDrift{0.};
@@ -297,10 +297,10 @@ float SCT_SurfaceChargesGenerator::surfaceDriftTime(float ysurf) const {
// create a list of surface charges from a hit - called from SCT_Digitization
// AthAlgorithm
// -------------------------------------------------------------------------------------------
-void SCT_SurfaceChargesGenerator::process(const SiDetectorElement* element,
+void FaserSCT_SurfaceChargesGenerator::process(const SiDetectorElement* element,
const TimedHitPtr<FaserSiHit>& phit,
const ISiSurfaceChargesInserter& inserter, CLHEP::HepRandomEngine * rndmEngine) const {
- ATH_MSG_VERBOSE("SCT_SurfaceChargesGenerator::process starts");
+ ATH_MSG_VERBOSE("FaserSCT_SurfaceChargesGenerator::process starts");
processSiHit(element, *phit, inserter, phit.eventTime(), phit.eventId(), rndmEngine);
return;
}
@@ -309,14 +309,14 @@ void SCT_SurfaceChargesGenerator::process(const SiDetectorElement* element,
// create a list of surface charges from a hit - called from both AthAlgorithm
// and PileUpTool
// -------------------------------------------------------------------------------------------
-void SCT_SurfaceChargesGenerator::processSiHit(const SiDetectorElement* element,
+void FaserSCT_SurfaceChargesGenerator::processSiHit(const SiDetectorElement* element,
const FaserSiHit& phit,
const ISiSurfaceChargesInserter& inserter,
float p_eventTime,
unsigned short p_eventId, CLHEP::HepRandomEngine * rndmEngine) const {
const SCT_ModuleSideDesign* design{dynamic_cast<const SCT_ModuleSideDesign*>(&(element->design()))};
if (design==nullptr) {
- ATH_MSG_ERROR("SCT_SurfaceChargesGenerator::process can not get " << design);
+ ATH_MSG_ERROR("FaserSCT_SurfaceChargesGenerator::process can not get " << design);
return;
}
@@ -438,13 +438,13 @@ void SCT_SurfaceChargesGenerator::processSiHit(const SiDetectorElement* element,
const float yd{y1 + sigma * ry};
// For charge trapping with Ramo potential
- const double stripPitch{0.080}; // mm
- double dstrip{y1 / stripPitch}; // mm
- if (dstrip > 0.) {
- dstrip -= static_cast<double>(static_cast<int>(dstrip));
- } else {
- dstrip -= static_cast<double>(static_cast<int>(dstrip)) + 1;
- }
+ // const double stripPitch{0.080}; // mm
+ // double dstrip{y1 / stripPitch}; // mm
+ // if (dstrip > 0.) {
+ // dstrip -= static_cast<double>(static_cast<int>(dstrip));
+ // } else {
+ // dstrip -= static_cast<double>(static_cast<int>(dstrip)) + 1;
+ // }
// now y will be x and z will be y ....just to make sure to confuse everebody
// double y0{dstrip * stripPitch}; // mm
@@ -500,7 +500,7 @@ void SCT_SurfaceChargesGenerator::processSiHit(const SiDetectorElement* element,
// } // chargeIsTrapped()
// } // m_doTrapping==true
- if (not m_doRamo) {
+ // if (not m_doRamo) {
const SiLocalPosition position{element->hitLocalToLocal(xd, yd)};
if (design->inActiveArea(position)) {
const float sdist{static_cast<float>(design->scaledDistanceToNearestDiode(position))}; // !< dist on the surface from the hit point to the nearest strip (diode)
@@ -512,7 +512,7 @@ void SCT_SurfaceChargesGenerator::processSiHit(const SiDetectorElement* element,
<< position.xPhi() << ", " << position.xEta() << ", " << position.xDepth()
<< ") of the element is out of active area, charge = " << q1);
}
- } // end of loop on charges
+ // } // end of loop on charges
}
}
}
diff --git a/Tracker/TrackerDigitization/FaserSCT_Digitization/src/SCT_SurfaceChargesGenerator.h b/Tracker/TrackerDigitization/FaserSCT_Digitization/src/FaserSCT_SurfaceChargesGenerator.h
similarity index 73%
rename from Tracker/TrackerDigitization/FaserSCT_Digitization/src/SCT_SurfaceChargesGenerator.h
rename to Tracker/TrackerDigitization/FaserSCT_Digitization/src/FaserSCT_SurfaceChargesGenerator.h
index f9ae5fcda18638ec41925745fc52f710fb0ad804..d43fdb8917a26fcc0c6028901fa7abd6ce12d731 100644
--- a/Tracker/TrackerDigitization/FaserSCT_Digitization/src/SCT_SurfaceChargesGenerator.h
+++ b/Tracker/TrackerDigitization/FaserSCT_Digitization/src/FaserSCT_SurfaceChargesGenerator.h
@@ -5,7 +5,7 @@
*/
/**
- * Header file for SCT_SurfaceChargesGenerator Class
+ * Header file for FaserSCT_SurfaceChargesGenerator Class
* @brief Class to drift the charged hits to the sensor surface for SCT
* version 1.0a Szymon Gadomski 31.05.2001
* @author Szymon.Gadomski@cern.ch, Awatif.Belymam@cern.ch, Davide.Costanzo@cern.ch,
@@ -29,19 +29,19 @@
* - Conversion of the SCT_SurfaceChargesGenerator code Al gTool
*/
-#ifndef FASERSCT_DIGITIZATION_SCT_SURFACECHARGESGENERATOR_H
-#define FASERSCT_DIGITIZATION_SCT_SURFACECHARGESGENERATOR_H
+#ifndef FASERSCT_DIGITIZATION_FASERSCT_SURFACECHARGESGENERATOR_H
+#define FASERSCT_DIGITIZATION_FASERSCT_SURFACECHARGESGENERATOR_H
//Inheritance
#include "AthenaBaseComps/AthAlgTool.h"
#include "FaserSCT_Digitization/ISCT_SurfaceChargesGenerator.h"
#include "Identifier/IdentifierHash.h"
-// #include "InDetConditionsSummaryService/ISiliconConditionsTool.h"
+#include "InDetConditionsSummaryService/ISiliconConditionsTool.h"
#include "InDetCondTools/ISiLorentzAngleTool.h"
// #include "SCT_ConditionsTools/ISCT_RadDamageSummaryTool.h"
// #include "SCT_ModuleDistortions/ISCT_ModuleDistortionsTool.h"
-#include "SiPropertiesTool/ISiPropertiesTool.h"
+#include "FaserSiPropertiesTool/IFaserSiPropertiesTool.h"
// Gaudi
#include "GaudiKernel/ITHistSvc.h" // for ITHistSvc
@@ -70,14 +70,14 @@ namespace CLHEP {
template <class HIT> class TimedHitPtr;
-class SCT_SurfaceChargesGenerator : public extends<AthAlgTool, ISCT_SurfaceChargesGenerator> {
+class FaserSCT_SurfaceChargesGenerator : public extends<AthAlgTool, ISCT_SurfaceChargesGenerator> {
public:
/** constructor */
- SCT_SurfaceChargesGenerator(const std::string& type, const std::string& name, const IInterface* parent);
+ FaserSCT_SurfaceChargesGenerator(const std::string& type, const std::string& name, const IInterface* parent);
/** Destructor */
- virtual ~SCT_SurfaceChargesGenerator() = default;
+ virtual ~FaserSCT_SurfaceChargesGenerator() = default;
/** AlgTool initialize */
virtual StatusCode initialize();
@@ -118,17 +118,17 @@ class SCT_SurfaceChargesGenerator : public extends<AthAlgTool, ISCT_SurfaceCharg
FloatProperty m_vbias{this, "BiasVoltage", 150., "bias voltage, default 150V"};
BooleanProperty m_doTrapping{this, "doTrapping", false, "Flag to set Charge Trapping"};
// BooleanProperty m_doHistoTrap{this, "doHistoTrap", false, "Histogram the charge trapping effect"};
- BooleanProperty m_doRamo{this, "doRamo", false, "Ramo Potential for charge trapping effect"};
+// BooleanProperty m_doRamo{this, "doRamo", false, "Ramo Potential for charge trapping effect"};
BooleanProperty m_isOverlay{this, "isOverlay", false, "flag for overlay"};
//ToolHandles
// ToolHandle<ISCT_ModuleDistortionsTool> m_distortionsTool{this, "SCTDistortionsTool", "SCT_DistortionsTool", "Tool to retrieve SCT distortions"};
- ToolHandle<ISiPropertiesTool> m_siPropertiesTool{this, "SiPropertiesTool", "SCT_SiPropertiesTool", "Tool to retrieve SCT silicon properties"};
+ ToolHandle<IFaserSiPropertiesTool> m_siPropertiesTool{this, "SiPropertiesTool", "FaserSCT_SiPropertiesTool", "Tool to retrieve SCT silicon properties"};
// ToolHandle<ISCT_RadDamageSummaryTool> m_radDamageTool{this, "RadDamageSummaryTool", "SCT_RadDamageSummaryTool", "Tool to retrieve SCT radiation damages"};
-// ToolHandle<ISiliconConditionsTool> m_siConditionsTool{this, "SiConditionsTool", "SCT_SiliconConditionsTool", "Tool to retrieve SCT silicon information"};
- ToolHandle<ISiLorentzAngleTool> m_lorentzAngleTool{this, "LorentzAngleTool", "SiLorentzAngleTool/SCTLorentzAngleTool", "Tool to retreive Lorentz angle"};
+ ToolHandle<ISiliconConditionsTool> m_siConditionsTool{this, "SiConditionsTool", "FaserSCT_SiliconConditionsTool", "Tool to retrieve SCT silicon information"};
+ ToolHandle<ISiLorentzAngleTool> m_lorentzAngleTool{this, "LorentzAngleTool", "SiLorentzAngleTool/FaserSCTLorentzAngleTool", "Tool to retreive Lorentz angle"};
- ServiceHandle<ITHistSvc> m_thistSvc{this, "THistSvc", "THistSvc"};
+ // ServiceHandle<ITHistSvc> m_thistSvc{this, "THistSvc", "THistSvc"};
float m_tHalfwayDrift{0.}; //!< Surface drift time
float m_distInterStrip{1.0}; //!< Inter strip distance normalized to 1
@@ -137,28 +137,28 @@ class SCT_SurfaceChargesGenerator : public extends<AthAlgTool, ISCT_SurfaceCharg
bool m_SurfaceDriftFlag{false}; //!< surface drift ON/OFF
// -- Histograms
- TProfile* m_h_efieldz{nullptr};
- TH1F* m_h_efield{nullptr};
- TH1F* m_h_spess{nullptr};
- TH1F* m_h_depD{nullptr};
- TH2F* m_h_drift_electrode{nullptr};
- TH1F* m_h_ztrap{nullptr};
- TH1F* m_h_drift_time{nullptr};
- TH1F* m_h_t_electrode{nullptr};
- TH1F* m_h_zhit{nullptr};
- TH1F* m_h_ztrap_tot{nullptr};
- TH1F* m_h_no_ztrap{nullptr};
- TH1F* m_h_trap_drift_t{nullptr};
- TH1F* m_h_notrap_drift_t{nullptr};
- TProfile* m_h_mob_Char{nullptr};
- TProfile* m_h_vel{nullptr};
- TProfile* m_h_drift1{nullptr};
- TProfile* m_h_gen{nullptr};
- TProfile* m_h_gen1{nullptr};
- TProfile* m_h_gen2{nullptr};
- TProfile* m_h_velocity_trap{nullptr};
- TProfile* m_h_mobility_trap{nullptr};
- TH1F* m_h_trap_pos{nullptr};
+ // TProfile* m_h_efieldz{nullptr};
+ // TH1F* m_h_efield{nullptr};
+ // TH1F* m_h_spess{nullptr};
+ // TH1F* m_h_depD{nullptr};
+ // TH2F* m_h_drift_electrode{nullptr};
+ // TH1F* m_h_ztrap{nullptr};
+ // TH1F* m_h_drift_time{nullptr};
+ // TH1F* m_h_t_electrode{nullptr};
+ // TH1F* m_h_zhit{nullptr};
+ // TH1F* m_h_ztrap_tot{nullptr};
+ // TH1F* m_h_no_ztrap{nullptr};
+ // TH1F* m_h_trap_drift_t{nullptr};
+ // TH1F* m_h_notrap_drift_t{nullptr};
+ // TProfile* m_h_mob_Char{nullptr};
+ // TProfile* m_h_vel{nullptr};
+ // TProfile* m_h_drift1{nullptr};
+ // TProfile* m_h_gen{nullptr};
+ // TProfile* m_h_gen1{nullptr};
+ // TProfile* m_h_gen2{nullptr};
+ // TProfile* m_h_velocity_trap{nullptr};
+ // TProfile* m_h_mobility_trap{nullptr};
+ // TH1F* m_h_trap_pos{nullptr};
};
-#endif // SCT_SURFACECHARGESGENERATOR_H
+#endif // FASERSCT_SURFACECHARGESGENERATOR_H
diff --git a/Tracker/TrackerDigitization/FaserSCT_Digitization/src/components/FaserSCT_Digitization_entries.cxx b/Tracker/TrackerDigitization/FaserSCT_Digitization/src/components/FaserSCT_Digitization_entries.cxx
index ea833080bce266204197ea69cdccc4c0752bf83d..6e8f319aabd8ca28d57e3c6643a99935489f4ce7 100644
--- a/Tracker/TrackerDigitization/FaserSCT_Digitization/src/components/FaserSCT_Digitization_entries.cxx
+++ b/Tracker/TrackerDigitization/FaserSCT_Digitization/src/components/FaserSCT_Digitization_entries.cxx
@@ -1,18 +1,18 @@
-#include "../SCT_Amp.h"
-#include "../SCT_FrontEnd.h"
-#include "../SCT_Digitization.h"
-#include "../SCT_DigitizationTool.h"
-#include "../SCT_SurfaceChargesGenerator.h"
-#include "../SCT_RandomDisabledCellGenerator.h"
+#include "../FaserSCT_Amp.h"
+#include "../FaserSCT_FrontEnd.h"
+#include "../FaserSCT_Digitization.h"
+#include "../FaserSCT_DigitizationTool.h"
+#include "../FaserSCT_SurfaceChargesGenerator.h"
+#include "../FaserSCT_RandomDisabledCellGenerator.h"
// Unused by ATLAS
// #include "../SCT_DetailedSurfaceChargesGenerator.h"
-DECLARE_COMPONENT( SCT_Amp )
-DECLARE_COMPONENT( SCT_FrontEnd )
-DECLARE_COMPONENT( SCT_Digitization )
-DECLARE_COMPONENT( SCT_DigitizationTool )
-DECLARE_COMPONENT( SCT_SurfaceChargesGenerator )
-DECLARE_COMPONENT( SCT_RandomDisabledCellGenerator )
+DECLARE_COMPONENT( FaserSCT_Amp )
+DECLARE_COMPONENT( FaserSCT_FrontEnd )
+DECLARE_COMPONENT( FaserSCT_Digitization )
+DECLARE_COMPONENT( FaserSCT_DigitizationTool )
+DECLARE_COMPONENT( FaserSCT_SurfaceChargesGenerator )
+DECLARE_COMPONENT( FaserSCT_RandomDisabledCellGenerator )
// Unused by ATLAS
// DECLARE_COMPONENT( SCT_DetailedSurfaceChargesGenerator )
diff --git a/Tracker/TrackerDigitization/FaserSCT_Digitization/test/FaserSCT_DigitizationDbg.py b/Tracker/TrackerDigitization/FaserSCT_Digitization/test/FaserSCT_DigitizationDbg.py
index dd51e8f88249c522103f5288ec363256114a02a5..7590aec0f51dc18282ee5a305e44b9afce5b6b53 100644
--- a/Tracker/TrackerDigitization/FaserSCT_Digitization/test/FaserSCT_DigitizationDbg.py
+++ b/Tracker/TrackerDigitization/FaserSCT_Digitization/test/FaserSCT_DigitizationDbg.py
@@ -1,58 +1,62 @@
-#!/usr/bin/env python
-"""Test various ComponentAccumulator Digitization configuration modules
-
-Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+#!/usr/bin/env python
+"""Test various ComponentAccumulator Digitization configuration modules
+
+Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
"""
import sys
-from AthenaCommon.Logging import log
-from AthenaCommon.Constants import DEBUG
+from AthenaCommon.Logging import log, logging
+from AthenaCommon.Constants import DEBUG, VERBOSE, INFO
from AthenaCommon.Configurable import Configurable
from CalypsoConfiguration.AllConfigFlags import ConfigFlags
-from AthenaConfiguration.AllConfigFlags import ConfigFlags
from AthenaConfiguration.TestDefaults import defaultTestFiles
from AthenaConfiguration.MainServicesConfig import MainServicesSerialCfg
from AthenaPoolCnvSvc.PoolReadConfig import PoolReadCfg
from AthenaPoolCnvSvc.PoolWriteConfig import PoolWriteCfg
-#from Digitization.DigitizationParametersConfig import writeDigitizationMetadata
-from FaserSCT_Digitization.FaserSCT_DigitizationConfigNew import SCT_DigitizationCfg
-#from MCTruthSimAlgs.RecoTimingConfig import MergeRecoTimingObjCfg
+#from Digitization.DigitizationParametersConfig import writeDigitizationMetadata
+from FaserSCT_Digitization.FaserSCT_DigitizationConfigNew import FaserSCT_DigitizationCfg
+#from MCTruthSimAlgs.RecoTimingConfig import MergeRecoTimingObjCfg
-# Set up logging and new style config
+# Set up logging and new style config
log.setLevel(DEBUG)
Configurable.configurableRun3Behavior = True
-# Configure
+# Configure
ConfigFlags.Input.Files = ['g4.HITS.root']
ConfigFlags.Output.RDOFileName = "myRDO.pool.root"
-ConfigFlags.IOVDb.GlobalTag = "OFLCOND-MC16-SDR-14"
+ConfigFlags.IOVDb.GlobalTag = "OFLCOND-MC16-SDR-16"
ConfigFlags.GeoModel.Align.Dynamic = False
ConfigFlags.Concurrency.NumThreads = 1
ConfigFlags.Beam.NumberOfCollisions = 0.
+#ConfigFlags.Detector.SimulateFaserSCT = True
-ConfigFlags.GeoModel.FaserVersion = "FASER-00" # Always needed
-ConfigFlags.GeoModel.AtlasVersion = "ATLAS-R2-2016-01-00-01" # Always needed to fool autoconfig
+ConfigFlags.GeoModel.FaserVersion = "FASER-00" # Always needed
+ConfigFlags.GeoModel.AtlasVersion = "ATLAS-R2-2016-01-00-01" # Always needed to fool autoconfig
ConfigFlags.lock()
-# Core components
+# Core components
acc = MainServicesSerialCfg()
acc.merge(PoolReadCfg(ConfigFlags))
acc.merge(PoolWriteCfg(ConfigFlags))
-#acc.merge(writeDigitizationMetadata(ConfigFlags))
+#acc.merge(writeDigitizationMetadata(ConfigFlags))
-# Inner Detector
-acc.merge(SCT_DigitizationCfg(ConfigFlags))
+# Inner Detector
+acc.merge(FaserSCT_DigitizationCfg(ConfigFlags))
-# Timing
-#acc.merge(MergeRecoTimingObjCfg(ConfigFlags))
+# Timing
+#acc.merge(MergeRecoTimingObjCfg(ConfigFlags))
-# Dump config
+# Dump config
+logging.getLogger('forcomps').setLevel(VERBOSE)
+acc.foreach_component("*").OutputLevel = VERBOSE
+acc.foreach_component("*ClassID*").OutputLevel = INFO
+acc.getCondAlgo("FaserSCT_AlignCondAlg").OutputLevel = VERBOSE
+acc.getService("PoolSvc").SortReplicas = False
acc.getService("StoreGateSvc").Dump = True
acc.getService("ConditionStore").Dump = True
acc.printConfig(withDetails=True)
ConfigFlags.dump()
-# Execute and finish
-sc = acc.run(maxEvents=3)
-# Success should be 0
+# Execute and finish
+sc = acc.run(maxEvents=5)
+# Success should be 0
sys.exit(not sc.isSuccess())
-
diff --git a/Tracker/TrackerDigitization/FaserSCT_Digitization/test/SCT_DigitizationConfigNew_test.py b/Tracker/TrackerDigitization/FaserSCT_Digitization/test/SCT_DigitizationConfigNew_test.py
index 4fbd20f575761bc28029c4139df6b5cbd4abd382..0c3c321943e9ed4ae814350b9ee3578dd8a4fdc9 100644
--- a/Tracker/TrackerDigitization/FaserSCT_Digitization/test/SCT_DigitizationConfigNew_test.py
+++ b/Tracker/TrackerDigitization/FaserSCT_Digitization/test/SCT_DigitizationConfigNew_test.py
@@ -12,7 +12,7 @@ from AthenaConfiguration.MainServicesConfig import MainServicesSerialCfg
from AthenaConfiguration.TestDefaults import defaultTestFiles
from AthenaPoolCnvSvc.PoolReadConfig import PoolReadCfg
from AtlasGeoModel.InDetGMConfig import InDetGeometryCfg
-from FaserSCT_Digitization.FaserSCT_DigitizationConfigNew import SCT_DigitizationHSCfg
+from FaserSCT_Digitization.FaserSCT_DigitizationConfigNew import FaserSCT_DigitizationHSCfg
# Set up logging and new style config
log.setLevel(DEBUG)
@@ -26,7 +26,7 @@ ConfigFlags.lock()
# Construct our accumulator to run
acc = MainServicesSerialCfg()
acc.merge(PoolReadCfg(ConfigFlags))
-acc.merge(SCT_DigitizationHSCfg(ConfigFlags))
+acc.merge(FaserSCT_DigitizationHSCfg(ConfigFlags))
# Dump config
acc.getService("StoreGateSvc").Dump = True
acc.getService("ConditionStore").Dump = True
diff --git a/Tracker/TrackerDigitization/FaserSiDigitization/FaserSiDigitization/SiChargedDiode.h b/Tracker/TrackerDigitization/FaserSiDigitization/FaserSiDigitization/SiChargedDiode.h
index fadd13e4555c63976bee38629119e80f179a0755..a67720c67b4e2cb55df7967b8908661ec81ad568 100644
--- a/Tracker/TrackerDigitization/FaserSiDigitization/FaserSiDigitization/SiChargedDiode.h
+++ b/Tracker/TrackerDigitization/FaserSiDigitization/FaserSiDigitization/SiChargedDiode.h
@@ -90,7 +90,7 @@ private:
// the pointed SiDiode is owned by the SiChargedDiode
SiTotalCharge m_totalCharge; // total charge and its composition
TrackerDD::SiReadoutCellId m_readoutCell; //Readout cell associated to this diode
- int m_word; // a flag for noise etc etc as in InDetSimData
+ int m_word; // a flag for noise etc etc as in TrackerSimData
SiChargedDiode * m_nextInCluster; //the next strip to navigate to - allows traversing clusters since the SiChargedDiodeCollection is not guaranteed to be contiguous
};
diff --git a/Tracker/TrackerEventCnv/TrackerEventAthenaPool/CMakeLists.txt b/Tracker/TrackerEventCnv/TrackerEventAthenaPool/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e319b1fca11b9a0b3f57168dab9a5b77db98e94d
--- /dev/null
+++ b/Tracker/TrackerEventCnv/TrackerEventAthenaPool/CMakeLists.txt
@@ -0,0 +1,75 @@
+# $Id: CMakeLists.txt 749562 2016-05-25 04:45:43Z krasznaa $
+################################################################################
+# Package: TrackerEventAthenaPool
+################################################################################
+
+# Declare the package name:
+atlas_subdir( TrackerEventAthenaPool )
+
+# Declare the package's dependencies:
+atlas_depends_on_subdirs(
+ PUBLIC
+ DetectorDescription/Identifier
+ Generators/GeneratorObjectsTPCnv
+ PRIVATE
+ AtlasTest/TestTools
+ Control/AthContainers
+ Control/AthenaBaseComps
+ Control/AthenaKernel
+ Control/SGTools
+ Control/StoreGate
+ Database/AthenaPOOL/AthenaPoolCnvSvc
+ Database/AthenaPOOL/AthenaPoolUtilities
+ Database/AtlasSealCLHEP
+ GaudiKernel
+# Tracker/TrackerConditions/FaserSCT_ConditionsData
+ Tracker/TrackerDetDescr/TrackerIdentifier
+ Tracker/TrackerDetDescr/TrackerReadoutGeometry
+# Tracker/TrackerEventCnv/TrackerEventTPCnv
+ Tracker/TrackerRawEvent/TrackerRawData
+ Tracker/TrackerRawEvent/TrackerSimData
+# Tracker/TrackerRecEvent/TrackerPrepRawData
+# Tracking/TrkEvent/TrkTrack
+ )
+
+# Component(s) in the package:
+atlas_add_poolcnv_library( TrackerEventAthenaPoolPoolCnv
+ TrackerEventAthenaPool/*.h src/*.h src/*.cxx
+ FILES TrackerRawData/FaserSCT_RDO_Container.h
+# TrackerPrepRawData/FaserSCT_ClusterContainer.h
+# src/InDetTrack.h
+ TrackerSimData/TrackerSimDataCollection.h
+# FaserSCT_ConditionsData/FaserSCT_FlaggedCondData.h
+ LINK_LIBRARIES Identifier GeneratorObjectsTPCnv AthAllocators AthContainers
+ AthenaBaseComps AthenaKernel SGTools StoreGateLib AthenaPoolCnvSvcLib
+ AthenaPoolUtilities AtlasSealCLHEP GaudiKernel TrackerIdentifier
+ TrackerReadoutGeometry
+# TrackerEventTPCnv
+ TrackerRawData TrackerSimData
+# TrackerPrepRawData
+# FaserSCT_ConditionsData TrkTrack
+ )
+
+atlas_add_dictionary( TrackerEventAthenaPoolCnvDict
+ TrackerEventAthenaPool/TrackerEventAthenaPoolCnvDict.h
+ TrackerEventAthenaPool/selection.xml
+ LINK_LIBRARIES Identifier GeneratorObjectsTPCnv )
+
+# Install files from the package:
+atlas_install_headers( TrackerEventAthenaPool )
+atlas_install_joboptions( share/*.py )
+
+# Set up (a) test(s) for the converter(s):
+#if( IS_DIRECTORY ${CMAKE_SOURCE_DIR}/Database/AthenaPOOL/AthenaPoolUtilities )
+# set( AthenaPoolUtilitiesTest_DIR
+# ${CMAKE_SOURCE_DIR}/Database/AthenaPOOL/AthenaPoolUtilities/cmake )
+#endif()
+#find_package( AthenaPoolUtilitiesTest )
+#if( ATHENAPOOLUTILITIESTEST_FOUND )
+# set( TRACKEREVENTATHENAPOOL_REFERENCE_TAG
+# TrackerEventAthenaPoolReference-01-00-00 )
+# run_tpcnv_legacy_test( TrackerEventTPCnv_16.6.2.1 ESD-16.6.2.1
+# REFERENCE_TAG ${TRACKEREVENTATHENAPOOL_REFERENCE_TAG} )
+#else()
+# message( WARNING "Couldn't find AthenaPoolUtilitiesTest. No test(s) set up." )
+#endif()
diff --git a/Tracker/TrackerEventCnv/TrackerEventAthenaPool/TrackerEventAthenaPool/ATLAS_CHECK_THREAD_SAFETY b/Tracker/TrackerEventCnv/TrackerEventAthenaPool/TrackerEventAthenaPool/ATLAS_CHECK_THREAD_SAFETY
new file mode 100644
index 0000000000000000000000000000000000000000..a8a8a12d95055d267959b24183da1cf28a535aae
--- /dev/null
+++ b/Tracker/TrackerEventCnv/TrackerEventAthenaPool/TrackerEventAthenaPool/ATLAS_CHECK_THREAD_SAFETY
@@ -0,0 +1 @@
+Tracker/TrackerEventCnv/TrackerEventAthenaPool
\ No newline at end of file
diff --git a/Tracker/TrackerEventCnv/TrackerEventAthenaPool/TrackerEventAthenaPool/FaserSCT3_RawData_p4.h b/Tracker/TrackerEventCnv/TrackerEventAthenaPool/TrackerEventAthenaPool/FaserSCT3_RawData_p4.h
new file mode 100644
index 0000000000000000000000000000000000000000..6f49d15c067593b09025a9ffc5ee907ee96167fc
--- /dev/null
+++ b/Tracker/TrackerEventCnv/TrackerEventAthenaPool/TrackerEventAthenaPool/FaserSCT3_RawData_p4.h
@@ -0,0 +1,38 @@
+/*
+ Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+*/
+
+/** S.Oda, Oct 2018
+ * replace unsigned int by unsigned short for
+ for the premixing samples for Overlay MC. */
+
+#ifndef FASERSCT3_RAWDATA_P4_H
+#define FASERSCT3_RAWDATA_P4_H
+
+#include "Identifier/Identifier.h"
+
+class FaserSCT3_RawData_p4 {
+ public:
+ FaserSCT3_RawData_p4() {};
+// List of Cnv classes that convert this into Rdo objects
+ friend class FaserSCT3_RawDataCnv_p4;
+ //private:
+ unsigned short m_rowStrip; // row and strip numbers from Identifier. Bits 0-12 for strip, Bits 13-15 for row
+ unsigned short m_word; // raw data word. Bits 0-10 for group size, Bits 11-13 for time bin
+
+ void setRowStrip(const int row, const int strip) {
+ m_rowStrip = (static_cast<unsigned int>(strip) & 0x1FFF);
+ m_rowStrip |= ((static_cast<unsigned int>(row) & 0x7) << 13);
+ }
+
+ int getRow() const {
+ return ((m_rowStrip >> 13) & 0x7);
+ }
+
+ int getStrip() const {
+ return (m_rowStrip & 0x1FFF);
+ }
+
+};
+
+#endif // FASERSCT3_RAWDATA_P4_H
diff --git a/Tracker/TrackerEventCnv/TrackerEventAthenaPool/TrackerEventAthenaPool/FaserSCT_RawDataContainer_p4.h b/Tracker/TrackerEventCnv/TrackerEventAthenaPool/TrackerEventAthenaPool/FaserSCT_RawDataContainer_p4.h
new file mode 100644
index 0000000000000000000000000000000000000000..73bb683c2ee206954131cc4ba13f989fe03f46dd
--- /dev/null
+++ b/Tracker/TrackerEventCnv/TrackerEventAthenaPool/TrackerEventAthenaPool/FaserSCT_RawDataContainer_p4.h
@@ -0,0 +1,45 @@
+/*
+ Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef FASERSCT_RAWDATACONTAINER_P4_H
+#define FASERSCT_RAWDATACONTAINER_P4_H
+
+/**
+
+* Persistent represenation of an FaserSCT_RawDataContainer.
+* New version to deal with FaserSCT_RawData_p4
+* Susumu Oda Oct 2018.
+
+*/
+
+#include <vector>
+#include <string>
+#include "TrackerEventAthenaPool/FaserSCT3_RawData_p4.h"
+#include "TrackerEventAthenaPool/TrackerRawData_p2.h"
+#include "TrackerEventAthenaPool/TrackerRawDataCollection_p1.h"
+
+
+class FaserSCT_RawDataContainer_p4
+{
+ public:
+/// Default constructor
+ FaserSCT_RawDataContainer_p4();
+ friend class FaserSCT_RawDataContainerCnv_p4;
+ private:
+ std::vector<TrackerRawDataCollection_p1> m_collections;
+ std::vector<TrackerRawData_p2> m_rawdata;
+ std::vector<FaserSCT3_RawData_p4> m_sct3data;
+ /** because ROOT isn't good at storing vectors of vectors,
+ * store the individual strip errors in the persistent container
+ * rather than in the persistent SCT3_RawData_p4 itself..
+ */
+};
+
+
+/** inlines */
+
+inline
+FaserSCT_RawDataContainer_p4::FaserSCT_RawDataContainer_p4() {}
+
+#endif // FASERSCT_RAWDATACONTAINER_P4_H
diff --git a/Tracker/TrackerEventCnv/TrackerEventAthenaPool/TrackerEventAthenaPool/TrackerEventAthenaPoolCnvDict.h b/Tracker/TrackerEventCnv/TrackerEventAthenaPool/TrackerEventAthenaPool/TrackerEventAthenaPoolCnvDict.h
new file mode 100644
index 0000000000000000000000000000000000000000..03cab952376cf4f4752b9d509d534767c4e63118
--- /dev/null
+++ b/Tracker/TrackerEventCnv/TrackerEventAthenaPool/TrackerEventAthenaPool/TrackerEventAthenaPoolCnvDict.h
@@ -0,0 +1,35 @@
+/*
+ Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef TRACKEREVENTATHENAPOOLCNVDICT_H
+#define TRACKEREVENTATHENAPOOLCNVDICT_H
+
+// #include "TrackerEventAthenaPool/TrackerSimData_p1.h"
+#include "TrackerEventAthenaPool/TrackerSimData_p2.h"
+// #include "TrackerEventAthenaPool/TrackerSimDataCollection_p1.h"
+// #include "TrackerEventAthenaPool/TrackerSimDataCollection_p2.h"
+#include "TrackerEventAthenaPool/TrackerSimDataCollection_p3.h"
+#include "TrackerEventAthenaPool/TrackerRawData_p1.h"
+// #include "TrackerEventAthenaPool/FaserSCT3_RawData_p1.h"
+// #include "TrackerEventAthenaPool/FaserSCT3_RawData_p2.h"
+// #include "TrackerEventAthenaPool/FaserSCT3_RawData_p3.h"
+#include "TrackerEventAthenaPool/FaserSCT3_RawData_p4.h"
+#include "TrackerEventAthenaPool/TrackerRawDataCollection_p1.h"
+// #include "TrackerEventAthenaPool/TrackerRawDataContainer_p1.h"
+#include "TrackerEventAthenaPool/TrackerRawDataContainer_p2.h"
+// #include "TrackerEventAthenaPool/FaserSCT_RawDataContainer_p1.h"
+// #include "TrackerEventAthenaPool/FaserSCT_RawDataContainer_p2.h"
+// #include "TrackerEventAthenaPool/FaserSCT_RawDataContainer_p3.h"
+#include "TrackerEventAthenaPool/FaserSCT_RawDataContainer_p4.h"
+// #include "TrackerEventAthenaPool/SCT_FlaggedCondData_p1.h"
+
+namespace TrackerEventAthenaPoolCnvDict
+{
+ std::pair<unsigned int, TrackerSimData_p2> t1;
+ std::pair<unsigned long long, TrackerSimData_p2> t2;
+ std::vector<std::pair<unsigned int, TrackerSimData_p2> > t3;
+ std::vector<std::pair<unsigned long long, TrackerSimData_p2> > t4;
+}
+
+#endif
diff --git a/Tracker/TrackerEventCnv/TrackerEventAthenaPool/TrackerEventAthenaPool/TrackerRawDataCollection_p1.h b/Tracker/TrackerEventCnv/TrackerEventAthenaPool/TrackerEventAthenaPool/TrackerRawDataCollection_p1.h
new file mode 100644
index 0000000000000000000000000000000000000000..8403addfc3174c8e3a238c5691de84c88eb1ec6d
--- /dev/null
+++ b/Tracker/TrackerEventCnv/TrackerEventAthenaPool/TrackerEventAthenaPool/TrackerRawDataCollection_p1.h
@@ -0,0 +1,46 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef TRACKERRAWDATACOLLECTION_P1_H
+#define TRACKERRAWDATACOLLECTION_P1_H
+
+#include <vector>
+#include "Identifier/Identifier.h"
+#include "Identifier/IdentifierHash.h"
+
+class TrackerRawDataCollection_p1
+{
+
+
+public:
+
+ TrackerRawDataCollection_p1()
+ :
+ m_id(0),
+ m_hashId(0),
+ m_begin(0),
+ m_end(0)
+ { } ;
+
+ // container cnv does conversion
+ friend class TrackerRawDataContainerCnv_p1;
+
+ //private:
+
+ // Identifier of this collection
+ Identifier32::value_type m_id;
+
+ // Hash Identifier of this collection
+ // (write this one as well, so we don't rely on the IdHelper for it)
+ IdentifierHash::value_type m_hashId;
+
+ // Begin index into master collection
+ unsigned int m_begin;
+
+ // End index into master collection
+ unsigned int m_end;
+
+};
+
+#endif
diff --git a/Tracker/TrackerEventCnv/TrackerEventAthenaPool/TrackerEventAthenaPool/TrackerRawDataContainer_p2.h b/Tracker/TrackerEventCnv/TrackerEventAthenaPool/TrackerEventAthenaPool/TrackerRawDataContainer_p2.h
new file mode 100644
index 0000000000000000000000000000000000000000..085dbfef55be33c1f3f53ede6f086e8ff9ebfd37
--- /dev/null
+++ b/Tracker/TrackerEventCnv/TrackerEventAthenaPool/TrackerEventAthenaPool/TrackerRawDataContainer_p2.h
@@ -0,0 +1,47 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef TRACKERRAWDATACONTAINER_P2_H
+#define TRACKERRAWDATACONTAINER_P2_H
+
+/*
+
+Persistent represenation of an TrackerRawDataContainer.
+This is used for all the RDO conainers with base RDO objects.
+The converter will take care of creating TRT/SCT/Pixel
+RDO containers out of it.
+
+The assumption is that objects contained in a container
+are all of the same type, eg containers are hompgeneous.
+This persistent container should only be used for objects
+that contain TrackerRawData_p2.
+
+Author: Davide Costanzo
+
+*/
+
+#include <vector>
+#include <string>
+#include "TrackerEventAthenaPool/TrackerRawData_p2.h"
+#include "TrackerEventAthenaPool/TrackerRawDataCollection_p1.h"
+
+
+class TrackerRawDataContainer_p2
+{
+ public:
+/// Default constructor
+ TrackerRawDataContainer_p2 ();
+ friend class FaserSCT1_RawDataContainerCnv_p2;
+ private:
+ std::vector<TrackerRawDataCollection_p1> m_collections;
+ std::vector<TrackerRawData_p2> m_rawdata;
+};
+
+
+// inlines
+
+inline
+TrackerRawDataContainer_p2::TrackerRawDataContainer_p2 () {}
+
+#endif
diff --git a/Tracker/TrackerEventCnv/TrackerEventAthenaPool/TrackerEventAthenaPool/TrackerRawData_p1.h b/Tracker/TrackerEventCnv/TrackerEventAthenaPool/TrackerEventAthenaPool/TrackerRawData_p1.h
new file mode 100644
index 0000000000000000000000000000000000000000..606e47f06ee8dffc8fa14fb72403ea4320470561
--- /dev/null
+++ b/Tracker/TrackerEventCnv/TrackerEventAthenaPool/TrackerEventAthenaPool/TrackerRawData_p1.h
@@ -0,0 +1,20 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef TRACKERRAWDATA_P1_H
+#define TRACKERRAWDATA_P1_H
+
+#include "Identifier/Identifier.h"
+
+class TrackerRawData_p1 {
+ public:
+ TrackerRawData_p1():m_rdoId(0), m_word(0) {};
+// List of Cnv classes that convert this into Rdo objects
+ friend class FaserSCT1_RawDataCnv_p1;
+ private:
+ Identifier32::value_type m_rdoId; //Offline ID for readout channel
+ unsigned int m_word; // raw data word
+};
+
+#endif
diff --git a/Tracker/TrackerEventCnv/TrackerEventAthenaPool/TrackerEventAthenaPool/TrackerRawData_p2.h b/Tracker/TrackerEventCnv/TrackerEventAthenaPool/TrackerEventAthenaPool/TrackerRawData_p2.h
new file mode 100644
index 0000000000000000000000000000000000000000..8d09cfba84e099a39033090539775b42d1909801
--- /dev/null
+++ b/Tracker/TrackerEventCnv/TrackerEventAthenaPool/TrackerEventAthenaPool/TrackerRawData_p2.h
@@ -0,0 +1,20 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef TRACKERRAWDATA_P2_H
+#define TRACKERRAWDATA_P2_H
+
+#include "Identifier/Identifier.h"
+
+class TrackerRawData_p2 {
+ public:
+ TrackerRawData_p2():m_rdoId(0),m_word(0) {};
+// List of Cnv classes that convert this into Rdo objects
+ friend class FaserSCT1_RawDataCnv_p2;
+ private:
+ Identifier::value_type m_rdoId; //Offline ID for readout channel
+ unsigned int m_word; // raw data word
+};
+
+#endif
diff --git a/Tracker/TrackerEventCnv/TrackerEventAthenaPool/TrackerEventAthenaPool/TrackerSimDataCollection_p3.h b/Tracker/TrackerEventCnv/TrackerEventAthenaPool/TrackerEventAthenaPool/TrackerSimDataCollection_p3.h
new file mode 100644
index 0000000000000000000000000000000000000000..dc640a301e5bc0df1f2cf0bf2ad3e81d7089e12a
--- /dev/null
+++ b/Tracker/TrackerEventCnv/TrackerEventAthenaPool/TrackerEventAthenaPool/TrackerSimDataCollection_p3.h
@@ -0,0 +1,28 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef TRACKERSIMDATACOLLECTION_P3_H
+#define TRACKERSIMDATACOLLECTION_P3_H
+
+#include <vector>
+#include "TrackerEventAthenaPool/TrackerSimData_p2.h"
+#include "Identifier/Identifier.h"
+
+class TrackerSimDataCollection_p3
+{
+
+
+public:
+
+ TrackerSimDataCollection_p3()
+ { } ;
+
+ // container cnv does conversion
+ friend class TrackerSimDataCollectionCnv_p3;
+
+private:
+ std::vector<std::pair<Identifier::value_type, TrackerSimData_p2> > m_simdata;
+};
+
+#endif
diff --git a/Tracker/TrackerEventCnv/TrackerEventAthenaPool/TrackerEventAthenaPool/TrackerSimData_p2.h b/Tracker/TrackerEventCnv/TrackerEventAthenaPool/TrackerEventAthenaPool/TrackerSimData_p2.h
new file mode 100644
index 0000000000000000000000000000000000000000..4cf07a4016ec020e7423ef73f55a5668b40b51af
--- /dev/null
+++ b/Tracker/TrackerEventCnv/TrackerEventAthenaPool/TrackerEventAthenaPool/TrackerSimData_p2.h
@@ -0,0 +1,22 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef TRACKERSIMDATA_P2_H
+#define TRACKERSIMDATA_P2_H
+
+#include <vector>
+#include "GeneratorObjectsTPCnv/HepMcParticleLink_p2.h"
+
+class TrackerSimData_p2 {
+ public:
+ TrackerSimData_p2():m_word(0), m_links{}, m_enDeposits{} {};
+// List of Cnv classes that convert this into SimData objects
+ friend class TrackerSimDataCnv_p2;
+ private:
+ unsigned int m_word; // sim data word
+ std::vector<HepMcParticleLink_p2> m_links; // HepMCPLs
+ std::vector<float> m_enDeposits; // energy deposits
+};
+
+#endif
diff --git a/Tracker/TrackerEventCnv/TrackerEventAthenaPool/TrackerEventAthenaPool/selection.xml b/Tracker/TrackerEventCnv/TrackerEventAthenaPool/TrackerEventAthenaPool/selection.xml
new file mode 100644
index 0000000000000000000000000000000000000000..6fccd719e53bd74da4a9e37beee36999ef409182
--- /dev/null
+++ b/Tracker/TrackerEventCnv/TrackerEventAthenaPool/TrackerEventAthenaPool/selection.xml
@@ -0,0 +1,22 @@
+<lcgdict>
+ <class name="std::vector<HepMcParticleLink_p2>" />
+ <class name="TrackerSimData_p2" />
+ <class pattern="std::*pair*<unsigned int, TrackerSimData_p2>" />
+ <class name="std::vector<std::pair<unsigned int, TrackerSimData_p2> >" />
+ <class pattern="std::*pair*<unsigned long long, TrackerSimData_p2>" />
+ <class name="std::vector<std::pair<unsigned long long, TrackerSimData_p2> >" />
+ <!-- <class name="InDetSimDataCollection_p3" id="1430AA7B-EE92-5A41-92F3-5DD5367D6BAA" /> -->
+ <class name="TrackerSimDataCollection_p3" id="E25FFB08-56F4-4594-B005-45200A725CD4" />
+ <!-- <class name="TrackerRawData_p1" /> -->
+ <class name="TrackerRawData_p2" />
+ <class name="FaserSCT3_RawData_p4" />
+ <class name="TrackerRawDataCollection_p1" />
+ <!-- <class name="std::vector<TrackerRawData_p1>" /> -->
+ <class name="std::vector<TrackerRawData_p2>" />
+ <class name="std::vector<FaserSCT3_RawData_p4>" />
+ <!-- <class name="InDetRawDataContainer_p2" id="7138342E-0A80-4A32-A387-2842A01C2539" /> -->
+ <class name="TrackerRawDataContainer_p2" id="41607916-86F6-45A3-B857-4DAFA0EF4518" />
+ <!-- <class name="SCT_RawDataContainer_p4" id="6C7540BE-E85C-4777-BC1C-A9FF11460F54" /> -->
+ <class name="FaserSCT_RawDataContainer_p4" id="45BE54C2-46EF-4B43-AF87-7F10B52F9487" />
+ <class name="std::vector<TrackerRawDataCollection_p1>" />
+</lcgdict>
diff --git a/Tracker/TrackerEventCnv/TrackerEventAthenaPool/src/FaserSCT1_RawDataCnv_p2.cxx b/Tracker/TrackerEventCnv/TrackerEventAthenaPool/src/FaserSCT1_RawDataCnv_p2.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..7e3b5ae79293521c89d2dafcda639cbae0f4a5e6
--- /dev/null
+++ b/Tracker/TrackerEventCnv/TrackerEventAthenaPool/src/FaserSCT1_RawDataCnv_p2.cxx
@@ -0,0 +1,31 @@
+/*
+ Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+*/
+
+#include "TrackerRawData/FaserSCT1_RawData.h"
+#include "MsgUtil.h"
+
+// Persistent class and converter header file
+#include "TrackerEventAthenaPool/TrackerRawData_p2.h"
+#include "FaserSCT1_RawDataCnv_p2.h"
+
+// Other stuff
+#include "Identifier/Identifier.h"
+
+
+
+void
+FaserSCT1_RawDataCnv_p2::persToTrans(const TrackerRawData_p2* persObj, FaserSCT1_RawData* transObj, MsgStream& log)
+{
+ MSG_VERBOSE(log,"FaserSCT1_RawDataCnv_p2::persToTrans called ");
+ *transObj = FaserSCT1_RawData(Identifier(persObj->m_rdoId),
+ persObj->m_word);
+}
+
+void
+FaserSCT1_RawDataCnv_p2::transToPers(const FaserSCT1_RawData* transObj, TrackerRawData_p2* persObj, MsgStream& log)
+{
+ MSG_VERBOSE(log,"FaserSCT1_RawDataCnv_p2::transToPers called ");
+ persObj->m_rdoId = transObj->identify().get_compact();
+ persObj->m_word = transObj->getWord();
+}
diff --git a/Tracker/TrackerEventCnv/TrackerEventAthenaPool/src/FaserSCT1_RawDataCnv_p2.h b/Tracker/TrackerEventCnv/TrackerEventAthenaPool/src/FaserSCT1_RawDataCnv_p2.h
new file mode 100644
index 0000000000000000000000000000000000000000..f999c66447ad92357ca8f036f99f002ad0930349
--- /dev/null
+++ b/Tracker/TrackerEventCnv/TrackerEventAthenaPool/src/FaserSCT1_RawDataCnv_p2.h
@@ -0,0 +1,32 @@
+/*
+ Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef FASERSCT1_RAWDATACNV_P2_H
+#define FASERSCT1_RAWDATACNV_P2_H
+
+/*
+Transient/Persistent converter for SCT1_RawData class
+Author: Davide Costanzo
+*/
+
+#include "AthenaPoolCnvSvc/T_AthenaPoolTPConverter.h"
+
+#include "TrackerRawData/FaserSCT1_RawData.h"
+#include "TrackerEventAthenaPool/TrackerRawData_p2.h"
+
+class MsgStream;
+
+
+class FaserSCT1_RawDataCnv_p2 : public T_AthenaPoolTPCnvBase<FaserSCT1_RawData, TrackerRawData_p2>
+{
+public:
+
+ FaserSCT1_RawDataCnv_p2() {}
+ virtual void persToTrans(const TrackerRawData_p2* persObj, FaserSCT1_RawData* transObj, MsgStream& log);
+ virtual void transToPers(const FaserSCT1_RawData* transObj, TrackerRawData_p2* persObj, MsgStream& log);
+};
+
+
+#endif
+
diff --git a/Tracker/TrackerEventCnv/TrackerEventAthenaPool/src/FaserSCT3_RawDataCnv_p4.cxx b/Tracker/TrackerEventCnv/TrackerEventAthenaPool/src/FaserSCT3_RawDataCnv_p4.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..a08179bcba8dc75d380297b82c3f8d4c9254a23b
--- /dev/null
+++ b/Tracker/TrackerEventCnv/TrackerEventAthenaPool/src/FaserSCT3_RawDataCnv_p4.cxx
@@ -0,0 +1,48 @@
+/*
+ Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+*/
+
+#include "FaserSCT3_RawDataCnv_p4.h"
+
+#include "MsgUtil.h"
+
+#include "TrackerEventAthenaPool/FaserSCT3_RawData_p4.h"
+#include "TrackerIdentifier/FaserSCT_ID.h"
+#include "TrackerRawData/FaserSCT3_RawData.h"
+
+#include <vector>
+
+void
+FaserSCT3_RawDataCnv_p4::persToTrans(const FaserSCT3_RawData_p4* persObj, FaserSCT3_RawData* transObj, MsgStream& log)
+{
+ MSG_DEBUG(log, "FaserSCT3_RawDataCnv_p4::persToTrans called");
+
+ // Convert unsigned short to unsigned int
+ // P: Bits 0-10 for group size, Bits 11-13 for time bin
+ // T: Bits 0-10 for group size, Bits 22-24 for time bin
+ unsigned int word = static_cast<unsigned int>(persObj->m_word);
+ word = ((word & 0x7FF) | (((word >> 11) & 0x7) << 22));
+
+ // Convert row and strip numbers to strip Identifeir using wafer Identifer
+ Identifier stripId = m_sctId->strip_id(m_waferId,
+ persObj->getRow(),
+ persObj->getStrip());
+
+ *transObj = FaserSCT3_RawData(stripId, word, std::vector<int>());
+}
+
+void
+FaserSCT3_RawDataCnv_p4::transToPers(const FaserSCT3_RawData* transObj, FaserSCT3_RawData_p4* persObj, MsgStream& log)
+{
+ MSG_DEBUG(log, "FaserSCT3_RawDataCnv_p4::transToPers called");
+
+ // Set row and strip numbers
+ persObj->setRowStrip(m_sctId->row(transObj->identify()), m_sctId->strip(transObj->identify()));
+
+ // Convert unsigned int to unsigned short
+ // T: Bits 0-10 for group size, Bits 22-24 for time bin
+ // P: Bits 0-10 for group size, Bits 11-13 for time bin
+ unsigned int word = transObj->getWord();
+ word = ((word & 0x7FF) | (((word >> 22) & 0x7) << 11));
+ persObj->m_word = static_cast<unsigned short>(word);
+}
diff --git a/Tracker/TrackerEventCnv/TrackerEventAthenaPool/src/FaserSCT3_RawDataCnv_p4.h b/Tracker/TrackerEventCnv/TrackerEventAthenaPool/src/FaserSCT3_RawDataCnv_p4.h
new file mode 100644
index 0000000000000000000000000000000000000000..129fbb5d1d27e41c43dde0fe060d08c4c96b6572
--- /dev/null
+++ b/Tracker/TrackerEventCnv/TrackerEventAthenaPool/src/FaserSCT3_RawDataCnv_p4.h
@@ -0,0 +1,33 @@
+/*
+ Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef FASERSCT3_RAWDATACNV_P4_H
+#define FASERSCT3_RAWDATACNV_P4_H
+
+/*
+ Transient/Persistent converter for FaserSCT3_RawData class
+*/
+
+#include "AthenaPoolCnvSvc/T_AthenaPoolTPConverter.h"
+
+#include "Identifier/Identifier.h"
+#include "TrackerRawData/FaserSCT3_RawData.h"
+#include "TrackerEventAthenaPool/FaserSCT3_RawData_p4.h"
+
+class MsgStream;
+class FaserSCT_ID;
+
+class FaserSCT3_RawDataCnv_p4 : public T_AthenaPoolTPCnvBase<FaserSCT3_RawData, FaserSCT3_RawData_p4>
+{
+ public:
+ FaserSCT3_RawDataCnv_p4(const FaserSCT_ID* sctId) { m_sctId = sctId; }
+ virtual void persToTrans(const FaserSCT3_RawData_p4* persObj, FaserSCT3_RawData* transObj, MsgStream& log);
+ virtual void transToPers(const FaserSCT3_RawData* transObj, FaserSCT3_RawData_p4* persObj, MsgStream& log);
+ void setWaferId(const Identifier waferId) { m_waferId = waferId; }
+ private:
+ const FaserSCT_ID* m_sctId;
+ Identifier m_waferId;
+};
+
+#endif // FASERSCT3_RAWDATACNV_P4_H
diff --git a/Tracker/TrackerEventCnv/TrackerEventAthenaPool/src/FaserSCT_RDO_ContainerCnv.cxx b/Tracker/TrackerEventCnv/TrackerEventAthenaPool/src/FaserSCT_RDO_ContainerCnv.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..1b98d8f479c59d28cc673379d874956780e666ff
--- /dev/null
+++ b/Tracker/TrackerEventCnv/TrackerEventAthenaPool/src/FaserSCT_RDO_ContainerCnv.cxx
@@ -0,0 +1,238 @@
+/*
+ Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+*/
+
+#include "FaserSCT_RDO_ContainerCnv.h"
+
+#include "TrackerIdentifier/FaserSCT_ID.h"
+
+#include <memory>
+
+#include <iostream>
+
+
+//================================================================
+namespace {
+#ifdef SCT_DEBUG
+ std::string shortPrint(const FaserSCT_RDO_Container* main_input_SCT, unsigned maxprint=25) {
+ std::ostringstream os;
+ if (main_input_SCT) {
+ for (unsigned i=0; i<maxprint; i++) {
+ FaserSCT_RDO_Container::const_iterator p = main_input_SCT->indexFind(i);
+ if (p != main_input_SCT->end()) {
+ os<<" "<< (*p)->size();
+ }
+ else {
+ os<<" *";
+ }
+ }
+ }
+ else {
+ os<<" [FaserSCT_RDO_Container==NULL]";
+ }
+ return os.str();
+ }
+#endif
+}
+
+FaserSCT_RDO_ContainerCnv::FaserSCT_RDO_ContainerCnv (ISvcLocator* svcloc)
+ : FaserSCT_RDO_ContainerCnvBase(svcloc, "FaserSCT_RDO_ContainerCnv"),
+ m_converter_p0(),
+ m_storeGate(nullptr)
+{}
+
+//================================================================
+StatusCode FaserSCT_RDO_ContainerCnv::initialize() {
+ StatusCode sc = FaserSCT_RDO_ContainerCnvBase::initialize();
+ if (sc.isFailure()) {
+ ATH_MSG_FATAL("FaserSCT_RDO_ContainerCnvBase::initialize() returned failure !");
+ return StatusCode::FAILURE;
+ }
+
+ ATH_MSG_DEBUG("FaserSCT_RDO_ContainerCnv::initialize()");
+
+ // get StoreGate service. This is needed only for clients
+ // that register collections directly to the SG instead of adding
+ // them to the container.
+ sc = service("StoreGateSvc", m_storeGate);
+ if (sc.isFailure()) {
+ ATH_MSG_FATAL("StoreGate service not found !");
+ return StatusCode::FAILURE;
+ }
+
+ // get DetectorStore service
+ StoreGateSvc* detStore(nullptr);
+ if (service("DetectorStore", detStore).isFailure()) {
+ ATH_MSG_FATAL("DetectorStore service not found !");
+ return StatusCode::FAILURE;
+ } else {
+ ATH_MSG_DEBUG("Found DetectorStore.");
+ }
+
+ // Get the sct helper from the detector store
+ const FaserSCT_ID* idhelper(nullptr);
+ if (detStore->retrieve(idhelper, "FaserSCT_ID").isFailure()) {
+ ATH_MSG_FATAL("Could not get FaserSCT_ID helper !");
+ return StatusCode::FAILURE;
+ } else {
+ ATH_MSG_DEBUG("Found the FaserSCT_ID helper.");
+ }
+
+ m_converter_p0.initialize(idhelper);
+// m_converter_TP1.initialize(idhelper);
+// m_converter_SCT_TP1.initialize(idhelper);
+// m_converter_SCT_TP2.initialize(idhelper);
+// m_converter_SCT_TP3.initialize(idhelper);
+ m_converter_SCT_TP4.initialize(idhelper);
+ m_converter_PERS.initialize(idhelper);
+
+ // ATH_MSG_DEBUG("Converter initialized");
+
+ return StatusCode::SUCCESS;
+}
+
+//================================================================
+FaserSCT_RDO_Container_PERS* FaserSCT_RDO_ContainerCnv::createPersistent(FaserSCT_RDO_Container* transCont) {
+
+#ifdef SCT_DEBUG
+ ATH_MSG_DEBUG("createPersistent(): main converter. TRANS = "<<shortPrint(transCont));
+#endif
+ // converter_num is a switch to determine which persistent type to use
+ // 1: if concrete type private data is equivalent to TrackerRawData_p1
+ // 3: for cosmic/TB
+ //
+ unsigned int converter_num(1);
+ FaserSCT_RDO_Container::const_iterator it_Coll = transCont->begin();
+ FaserSCT_RDO_Container::const_iterator it_CollEnd = transCont->end();
+ // check one element of the container. The container can't be empty for this...
+ if (it_Coll != it_CollEnd) {
+ while (it_Coll != it_CollEnd && (*it_Coll)->size() == 0) it_Coll++;
+ if (it_Coll != it_CollEnd) {
+ const FaserSCT_RDORawData* test((**it_Coll)[0]);
+ if (dynamic_cast<const FaserSCT1_RawData*>(test) != nullptr) {
+ //ATH_MSG_DEBUG("Found container with FaserSCT1_RawData concrete type objects");
+ converter_num=1;
+ } else if (dynamic_cast<const FaserSCT3_RawData*>(test) != nullptr) {
+ //ATH_MSG_DEBUG("Found container with FaserSCT3_RawData concrete type objects");
+ converter_num=3;
+ } else {
+ ATH_MSG_FATAL("Converter not implemented for this concrete type ");
+ throw "Converter not implemented";
+ }
+ } else {
+ ATH_MSG_WARNING("Container has only empty collections. Using TP1 converter");
+ }
+ } else {
+ ATH_MSG_WARNING("Empty container. Using TP1 converter");
+ }
+ // Switch facility depending on the concrete data type of the contained objects
+ // Should do by getting the type_info of one of the contained objects
+ FaserSCT_RDO_Container_PERS* persObj(nullptr);
+ if (converter_num == 1 || converter_num == 3) {
+ m_converter_PERS.setType(converter_num);
+ persObj = m_converter_PERS.createPersistent( transCont, msg() );
+ } else {
+ ATH_MSG_FATAL("This shouldn't happen!! ");
+ }
+#ifdef SCT_DEBUG
+ ATH_MSG_DEBUG("Success");
+#endif
+ return persObj;
+}
+
+//================================================================
+FaserSCT_RDO_Container* FaserSCT_RDO_ContainerCnv::createTransient() {
+
+ static const pool::Guid p0_guid("F884804E-E87B-42BE-9DD0-1571A1508F25"); // with SCT1_RawData
+// static const pool::Guid TP1_guid("DA76970C-E019-43D2-B2F9-25660DCECD9D"); // for t/p separated version with InDetRawDataContainer_p1
+// static const pool::Guid p0_guid("B82A1D11-3F86-4F07-B380-B61BA2DAF3A9"); // with SCT1_RawData
+// static const pool::Guid TP1_guid("DA76970C-E019-43D2-B2F9-25660DCECD9D"); // for t/p separated version with InDetRawDataContainer_p1
+// static const pool::Guid SCT_TP1_guid("8E13963E-13E5-4D10-AA8B-73F00AFF8FA8"); // for t/p separated version with SCT_RawDataContainer_p1
+// static const pool::Guid SCT_TP2_guid("D1258125-2CBA-476E-8578-E09D54F477E1"); // for t/p separated version with SCT_RawDataContainer_p2
+// static const pool::Guid SCT_TP3_guid("5FBC8D4D-7B4D-433A-8487-0EA0C870CBDB"); // for t/p separated version with SCT_RawDataContainer_p3
+// static const pool::Guid SCT_TP4_guid("6C7540BE-E85C-4777-BC1C-A9FF11460F54"); // for t/p separated version with SCT_RawDataContainer_p4
+ static const pool::Guid SCT_TP4_guid("45BE54C2-46EF-4B43-AF87-7F10B52F9487"); // for t/p separated version with SCT_RawDataContainer_p4
+
+#ifdef SCT_DEBUG
+ ATH_MSG_DEBUG("createTransient(): main converter");
+#endif
+ if ( compareClassGuid(SCT_TP4_guid) ) {
+#ifdef SCT_DEBUG
+ ATH_MSG_DEBUG("createTransient(): New TP version - TP4 branch");
+#endif
+
+ std::unique_ptr< FaserSCT_RawDataContainer_p4 > col_vect( poolReadObject< FaserSCT_RawDataContainer_p4 >() );
+ FaserSCT_RDO_Container* res = m_converter_SCT_TP4.createTransient( col_vect.get(), msg() );
+#ifdef SCT_DEBUG
+ ATH_MSG_DEBUG("createTransient(), TP4 branch: returns TRANS = "<<shortPrint(res));
+#endif
+ return res;
+
+ }
+// else if ( compareClassGuid(SCT_TP3_guid) ) {
+// #ifdef SCT_DEBUG
+// ATH_MSG_DEBUG("createTransient(): New TP version - TP3 branch");
+// #endif
+
+// std::unique_ptr< SCT_RawDataContainer_p3 > col_vect( poolReadObject< SCT_RawDataContainer_p3 >() );
+// SCT_RDO_Container* res = m_converter_SCT_TP3.createTransient( col_vect.get(), msg() );
+// #ifdef SCT_DEBUG
+// ATH_MSG_DEBUG("createTransient(), TP3 branch: returns TRANS = "<<shortPrint(res));
+// #endif
+// return res;
+
+// }
+// else if ( compareClassGuid(SCT_TP2_guid) ) {
+// #ifdef SCT_DEBUG
+// ATH_MSG_DEBUG("createTransient(): New TP version - TP2 branch");
+// #endif
+
+// std::unique_ptr< SCT_RawDataContainer_p2 > col_vect( poolReadObject< SCT_RawDataContainer_p2 >() );
+// SCT_RDO_Container* res = m_converter_SCT_TP2.createTransient( col_vect.get(), msg() );
+// #ifdef SCT_DEBUG
+// ATH_MSG_DEBUG("createTransient(), TP2 branch: returns TRANS = "<<shortPrint(res));
+// #endif
+// return res;
+
+// }
+// else if ( compareClassGuid(SCT_TP1_guid) ) {
+// #ifdef SCT_DEBUG
+// ATH_MSG_DEBUG("createTransient(): New TP version - TP1 branch");
+// #endif
+// std::unique_ptr< SCT_RawDataContainer_p1 > col_vect( poolReadObject< SCT_RawDataContainer_p1 >() );
+// SCT_RDO_Container* res = m_converter_SCT_TP1.createTransient( col_vect.get(), msg() );
+// #ifdef SCT_DEBUG
+// ATH_MSG_DEBUG("createTransient(), TP1 branch: returns TRANS = "<<shortPrint(res));
+// #endif
+// return res;
+
+
+// }
+// else if ( compareClassGuid(TP1_guid) ) {
+// ATH_MSG_DEBUG("createTransient(): New TP version - TP1 branch");
+
+// std::unique_ptr< InDetRawDataContainer_p1 > col_vect( poolReadObject< InDetRawDataContainer_p1 >() );
+// SCT_RDO_Container* res = m_converter_TP1.createTransient( col_vect.get(), msg() );
+// #ifdef SCT_DEBUG
+// ATH_MSG_DEBUG("createTransient(), TP1 branch: returns TRANS = "<<shortPrint(res));
+// #endif
+// return res;
+
+
+// }
+ else if ( compareClassGuid(p0_guid) ) {
+#ifdef SCT_DEBUG
+ ATH_MSG_DEBUG("createTransient(): Old input file - p0 branch");
+#endif
+ std::unique_ptr< FaserSCT_RDO_Container_p0 > col_vect( poolReadObject< FaserSCT_RDO_Container_p0 >() );
+ FaserSCT_RDO_Container* res = m_converter_p0.createTransient( col_vect.get(), msg() );
+#ifdef SCT_DEBUG
+ ATH_MSG_DEBUG("createTransient(), p0 branch: returns TRANS = "<<shortPrint(res));
+#endif
+ return res;
+ }
+
+ throw std::runtime_error("Unsupported persistent version of FaserSCT_RDO_Container");
+}
+
+//================================================================
diff --git a/Tracker/TrackerEventCnv/TrackerEventAthenaPool/src/FaserSCT_RDO_ContainerCnv.h b/Tracker/TrackerEventCnv/TrackerEventAthenaPool/src/FaserSCT_RDO_ContainerCnv.h
new file mode 100644
index 0000000000000000000000000000000000000000..b71b966f1a1b52716616d73012f6843feb4061b6
--- /dev/null
+++ b/Tracker/TrackerEventCnv/TrackerEventAthenaPool/src/FaserSCT_RDO_ContainerCnv.h
@@ -0,0 +1,54 @@
+/*
+ Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef FASERSCT_RDO_CONTAINERCNV_H
+#define FASERSCT_RDO_CONTAINERCNV_H
+
+#include "AthenaPoolCnvSvc/T_AthenaPoolCustomCnv.h"
+
+// #include "SCT_RawDataContainerCnv_p1.h"
+// #include "SCT_RawDataContainerCnv_p2.h"
+// #include "SCT_RawDataContainerCnv_p3.h"
+#include "FaserSCT_RawDataContainerCnv_p4.h"
+#include "FaserSCT_RDO_ContainerCnv_p0.h"
+// #include "FaserSCT1_RawDataContainerCnv_p1.h"
+
+#include "TrackerRawData/FaserSCT_RDO_Container.h"
+#include "TrackerRawData/FaserSCT_RDO_Collection.h"
+#include "StoreGate/StoreGateSvc.h"
+
+// the latest persistent representation type of DataCollection:
+typedef FaserSCT_RawDataContainer_p4 FaserSCT_RDO_Container_PERS;
+typedef FaserSCT_RawDataContainerCnv_p4 FaserSCT_RDO_ContainerCnv_PERS;
+
+typedef T_AthenaPoolCustomCnv<FaserSCT_RDO_Container, FaserSCT_RDO_Container_PERS> FaserSCT_RDO_ContainerCnvBase;
+
+class FaserSCT_RDO_ContainerCnv : public FaserSCT_RDO_ContainerCnvBase {
+ friend class CnvFactory<FaserSCT_RDO_ContainerCnv>;
+
+ // Converters need to be initialized (use ID helpers)
+ // Thus they can't be local
+ FaserSCT_RDO_ContainerCnv_p0 m_converter_p0;
+// FaserSCT1_RawDataContainerCnv_p1 m_converter_TP1;
+// SCT_RawDataContainerCnv_p1 m_converter_SCT_TP1;
+// SCT_RawDataContainerCnv_p2 m_converter_SCT_TP2;
+// SCT_RawDataContainerCnv_p3 m_converter_SCT_TP3;
+ FaserSCT_RawDataContainerCnv_p4 m_converter_SCT_TP4;
+ FaserSCT_RDO_ContainerCnv_PERS m_converter_PERS;
+
+ // Should not be needed at some point.
+ StoreGateSvc* m_storeGate;
+
+ protected:
+ public:
+ FaserSCT_RDO_ContainerCnv (ISvcLocator* svcloc);
+ protected:
+ virtual FaserSCT_RDO_Container_PERS* createPersistent (FaserSCT_RDO_Container* transCont);
+ virtual FaserSCT_RDO_Container* createTransient ();
+
+ // Must initialize ID helpers
+ virtual StatusCode initialize();
+};
+
+#endif
diff --git a/Tracker/TrackerEventCnv/TrackerEventAthenaPool/src/FaserSCT_RDO_ContainerCnv_p0.cxx b/Tracker/TrackerEventCnv/TrackerEventAthenaPool/src/FaserSCT_RDO_ContainerCnv_p0.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..969feedb131614cad58e99560bd314630df0185c
--- /dev/null
+++ b/Tracker/TrackerEventCnv/TrackerEventAthenaPool/src/FaserSCT_RDO_ContainerCnv_p0.cxx
@@ -0,0 +1,41 @@
+/*
+ Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+*/
+
+#include "FaserSCT_RDO_ContainerCnv_p0.h"
+
+
+
+#include "TrackerIdentifier/FaserSCT_ID.h"
+#include "TrackerRawData/FaserSCT_RDO_Container.h"
+#include "TrackerRawData/FaserSCT_RDO_Collection.h"
+
+//================================================================
+FaserSCT_RDO_Container* FaserSCT_RDO_ContainerCnv_p0::createTransient(const FaserSCT_RDO_Container_p0* persObj, MsgStream& log) {
+ std::unique_ptr<FaserSCT_RDO_Container> trans(std::make_unique<FaserSCT_RDO_Container>(m_sctId->wafer_hash_max()));
+
+ FaserSCT_RDO_Container_p0::const_iterator it = persObj->begin();
+ FaserSCT_RDO_Container_p0::const_iterator last = persObj->end();
+ for (; it != last; ++it) {
+
+ // Old persistent format used collection templated on the specific raw data type
+ const TrackerRawDataCollection<FaserSCT1_RawData>* rdoCollOld = *it;
+
+ if (rdoCollOld==nullptr) {
+ throw std::runtime_error("Got NULL collection reading old format FaserSCT_RDO_Container");
+ }
+
+ // Ugly cast... The new format does not need it in its converters.
+ const TrackerRawDataCollection<FaserSCT_RDORawData>* rdoColl = reinterpret_cast<const TrackerRawDataCollection<FaserSCT_RDORawData> *>(rdoCollOld);
+
+ // Add to the container
+ if (trans->addCollection( rdoColl, rdoColl->identifyHash() ).isFailure()) {
+ log << MSG::FATAL << "[p0] SCT RDOs could not be added to the container!" << endmsg;
+ throw std::runtime_error("FaserSCT_RDO_ContainerCnv_p0::createTransient(): SCT RDOs could not be added to the container!");
+ }
+ }
+
+ return trans.release();
+}
+
+//================================================================
diff --git a/Tracker/TrackerEventCnv/TrackerEventAthenaPool/src/FaserSCT_RDO_ContainerCnv_p0.h b/Tracker/TrackerEventCnv/TrackerEventAthenaPool/src/FaserSCT_RDO_ContainerCnv_p0.h
new file mode 100644
index 0000000000000000000000000000000000000000..b0e7a2d0b67399d4bc9ad2afcf54648642cb24a7
--- /dev/null
+++ b/Tracker/TrackerEventCnv/TrackerEventAthenaPool/src/FaserSCT_RDO_ContainerCnv_p0.h
@@ -0,0 +1,36 @@
+/*
+ Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef FASERSCT_RDO_CONTAINERCNV_P0_H
+#define FASERSCT_RDO_CONTAINERCNV_P0_H
+
+#include "AthContainers/DataVector.h"
+
+#include "TrackerRawData/FaserSCT_RDO_Container.h"
+#include "AthenaPoolCnvSvc/T_AthenaPoolTPConverter.h"
+#include "TrackerRawData/FaserSCT1_RawData.h"
+
+class FaserSCT_ID;
+
+typedef DataVector<TrackerRawDataCollection< FaserSCT1_RawData > > FaserSCT_RDO_Container_p0;
+
+class MsgStream;
+class FaserSCT_RDO_ContainerCnv_p0 : public T_AthenaPoolTPCnvBase<FaserSCT_RDO_Container, FaserSCT_RDO_Container_p0> {
+ const FaserSCT_ID* m_sctId{nullptr};
+public:
+ virtual void persToTrans(const FaserSCT_RDO_Container_p0*, FaserSCT_RDO_Container*, MsgStream&) {
+ // everything is done in createTransient()
+ }
+
+ virtual void transToPers(const FaserSCT_RDO_Container*, FaserSCT_RDO_Container_p0*, MsgStream&) {
+ throw std::runtime_error("Writing SCT RDOs in the old format is not supported");
+ }
+
+ virtual FaserSCT_RDO_Container* createTransient(const FaserSCT_RDO_Container_p0* persObj, MsgStream& log);
+
+ // ID helper can't be used in the constructor, need initialize()
+ void initialize(const FaserSCT_ID* idhelper) { m_sctId = idhelper; }
+};
+
+#endif/*FASERSCT_RDO_CONTAINERCNV_P0_H*/
diff --git a/Tracker/TrackerEventCnv/TrackerEventAthenaPool/src/FaserSCT_RawDataContainerCnv_p4.cxx b/Tracker/TrackerEventCnv/TrackerEventAthenaPool/src/FaserSCT_RawDataContainerCnv_p4.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..df7afe7d10807505cf9e182c553cd5dbb60a58fb
--- /dev/null
+++ b/Tracker/TrackerEventCnv/TrackerEventAthenaPool/src/FaserSCT_RawDataContainerCnv_p4.cxx
@@ -0,0 +1,185 @@
+/*
+ Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+*/
+
+#include "FaserSCT_RawDataContainerCnv_p4.h"
+
+
+#include "MsgUtil.h"
+#include "FaserSCT1_RawDataCnv_p2.h"
+#include "FaserSCT3_RawDataCnv_p4.h"
+
+#include "TrackerIdentifier/FaserSCT_ID.h"
+#include "TrackerEventAthenaPool/FaserSCT3_RawData_p4.h"
+#include "TrackerEventAthenaPool/TrackerRawDataCollection_p1.h"
+#include "TrackerRawData/FaserSCT_RDO_Container.h"
+#include "TrackerRawData/FaserSCT_RDO_Collection.h"
+#include "TrackerRawData/FaserSCT3_RawData.h"
+
+#include <memory>
+
+//#define SCT_DEBUG
+
+void FaserSCT_RawDataContainerCnv_p4::transToPers(const FaserSCT_RDO_Container* transCont, FaserSCT_RawDataContainer_p4* persCont, MsgStream& log)
+{
+
+ /// The transient model has a container holding collections and the
+ /// collections hold channels.
+ ///
+ /// The persistent model flattens this so that the persistent
+ /// container has two vectors:
+ /// 1) all collections, and
+ /// 2) all RDO
+ ///
+ /// The persistent collections, then only maintain indexes into the
+ /// container's vector of all channels.
+ ///
+ /// So here we loop over all collection and add their channels
+ /// to the container's vector, saving the indexes in the
+ /// collection.
+
+ typedef FaserSCT_RDO_Container TRANS;
+
+ FaserSCT1_RawDataCnv_p2 chan1Cnv;
+ FaserSCT3_RawDataCnv_p4 chan3Cnv(m_sctId);
+ TRANS::const_iterator it_Coll = transCont->begin();
+ TRANS::const_iterator it_CollEnd = transCont->end();
+ unsigned int collIndex;
+ unsigned int chanBegin = 0;
+ unsigned int chanEnd = 0;
+ int numColl = transCont->numberOfCollections();
+ persCont->m_collections.resize(numColl);
+#ifdef SCT_DEBUG
+ MSG_DEBUG(log,"FaserSCT_RawDataContainerCnv_p4 Preparing " << persCont->m_collections.size() << "Collections");
+#endif
+
+ /** we're going to store all the strip errors from each RDO
+ * in vectors in the collection */
+
+ for (collIndex = 0; it_Coll != it_CollEnd; ++collIndex, it_Coll++) {
+ /** Add in new collection */
+ const FaserSCT_RDO_Collection& collection = (**it_Coll);
+ chanBegin = chanEnd;
+ chanEnd += collection.size();
+ TrackerRawDataCollection_p1& pcollection = persCont->m_collections[collIndex];
+ pcollection.m_id = collection.identify().get_identifier32().get_compact();
+ pcollection.m_hashId = static_cast<unsigned int>(collection.identifyHash());
+ pcollection.m_begin = chanBegin;
+ pcollection.m_end = chanEnd;
+#ifdef SCT_DEBUG
+ MSG_DEBUG(log,"Writing collection number " << collIndex << " with hash" << pcollection.m_hashId);
+#endif
+ /** Add in channels */
+ if (m_type == 1) {
+#ifdef SCT_DEBUG
+ MSG_DEBUG(log,"FaserSCT_RawDataContainerCnv_p4 m_type is 1");
+#endif
+ persCont->m_rawdata.resize(chanEnd);
+ for (unsigned int i = 0; i < collection.size(); ++i) {
+ TrackerRawData_p2* pchan = &(persCont->m_rawdata[i + chanBegin]);
+ const FaserSCT1_RawData* chan = dynamic_cast<const FaserSCT1_RawData*>(collection[i]);
+ chan1Cnv.transToPers(chan, pchan, log);
+ }
+ } else if (m_type == 3) {
+#ifdef SCT_DEBUG
+ MSG_DEBUG(log,"FaserSCT_RawDataContainerCnv_p4 m_type is 3");
+#endif
+ persCont->m_sct3data.resize(chanEnd);
+ for (unsigned int i = 0; i < collection.size(); ++i) {
+ FaserSCT3_RawData_p4* pchan = &(persCont->m_sct3data[i + chanBegin]);
+ const FaserSCT3_RawData* chan = dynamic_cast<const FaserSCT3_RawData*>(collection[i]);
+ if (nullptr == chan) throw std::runtime_error("FaserSCT_RawDataContainerCnv_p4::transToPers: *** UNABLE TO DYNAMIC CAST TO FaserSCT3_RawData");
+ chan3Cnv.transToPers(chan, pchan, log);
+ }
+ }
+ }
+#ifdef SCT_DEBUG
+ MSG_DEBUG(log," *** Writing FaserSCT_RDO_Container (SCT1/3_RawData concrete type)");
+#endif
+}
+
+void FaserSCT_RawDataContainerCnv_p4::persToTrans(const FaserSCT_RawDataContainer_p4* persCont, FaserSCT_RDO_Container* transCont, MsgStream& log)
+{
+
+ /// The transient model has a container holding collections and the
+ /// collections hold channels.
+ ///
+ /// The persistent model flattens this so that the persistent
+ /// container has two vectors:
+ /// 1) all collections, and
+ /// 2) all channels
+ ///
+ /// The persistent collections, then only maintain indexes into the
+ /// container's vector of all channels.
+ ///
+ /// So here we loop over all collection and extract their channels
+ /// from the vector.
+
+
+ FaserSCT1_RawDataCnv_p2 chan1Cnv;
+ FaserSCT3_RawDataCnv_p4 chan3Cnv(m_sctId);
+ /** check for the type of the contained objects: */
+
+ if (persCont->m_rawdata.size() !=0 && persCont->m_sct3data.size() != 0) {
+ log << MSG::FATAL << "The collection has mixed SCT1 and SCT3 elements, this is not allowed " << endmsg;
+ }
+ if (persCont->m_rawdata.size() != 0 ) m_type = 1;
+ if (persCont->m_sct3data.size() != 0 ) m_type = 3;
+#ifdef SCT_DEBUG
+ MSG_DEBUG(log," Reading " << persCont->m_collections.size() << " Collections");
+#endif
+ for (unsigned int icoll = 0; icoll < persCont->m_collections.size(); ++icoll) {
+
+ /** Create trans collection - in NOT owner of SCT_RDO_RawData (SG::VIEW_ELEMENTS)
+ * IDet collection don't have the Ownership policy c'tor */
+ const TrackerRawDataCollection_p1& pcoll = persCont->m_collections[icoll];
+ Identifier collID(pcoll.m_id);
+ chan3Cnv.setWaferId(collID);
+ IdentifierHash collIDHash(pcoll.m_hashId);
+ std::unique_ptr<FaserSCT_RDO_Collection> coll = std::make_unique<FaserSCT_RDO_Collection>(IdentifierHash(collIDHash));
+ coll->setIdentifier(collID);
+ unsigned int nchans = pcoll.m_end - pcoll.m_begin;
+
+ coll->resize(nchans);
+#ifdef SCT_DEBUG
+ MSG_DEBUG(log,"Reading collection with id = " << pcoll.m_id << " id hash= " << pcoll.m_hashId
+ << " and num el= " << nchans << " m_type is "<<m_type);
+#endif
+ // Fill with channels
+ for (unsigned int ichan = 0; ichan < nchans; ++ ichan) {
+ if (m_type == 1) {
+ const TrackerRawData_p2* pchan = &(persCont->m_rawdata[ichan + pcoll.m_begin]);
+ std::unique_ptr<FaserSCT1_RawData> chan = std::make_unique<FaserSCT1_RawData>();
+ chan1Cnv.persToTrans(pchan, chan.get(), log);
+ (*coll)[ichan] = chan.release();
+ } else if (m_type == 3) {
+ const FaserSCT3_RawData_p4* pchan = &(persCont->m_sct3data[ichan + pcoll.m_begin]);
+ std::unique_ptr<FaserSCT3_RawData> chan = std::make_unique<FaserSCT3_RawData>();
+ chan3Cnv.persToTrans(pchan, chan.get(), log);
+ (*coll)[ichan] = chan.release();
+ }
+ }
+
+ // register the rdo collection in IDC with hash - faster addCollection
+ StatusCode sc = transCont->addCollection(coll.release(), collIDHash);
+ if (sc.isFailure()) {
+ throw std::runtime_error("Failed to add collection to ID Container");
+ }
+ MSG_VERBOSE(log,"AthenaPoolTPCnvIDCont::persToTrans, collection, hash_id/coll id = "
+ << collIDHash.value() << " / " << collID.get_compact() << ", added to Identifiable container.");
+
+ }
+#ifdef SCT_DEBUG
+ MSG_DEBUG(log," *** Reading FaserSCT_RDO_Container (SCT1/3_RawData concrete type)");
+#endif
+}
+
+//================================================================
+FaserSCT_RDO_Container* FaserSCT_RawDataContainerCnv_p4::createTransient(const FaserSCT_RawDataContainer_p4* persObj, MsgStream& log) {
+#ifdef SCT_DEBUG
+ MSG_DEBUG(log,"creating transient FaserSCT_RDO_Container");
+#endif
+ std::unique_ptr<FaserSCT_RDO_Container> trans(std::make_unique<FaserSCT_RDO_Container>(m_sctId->wafer_hash_max()));
+ persToTrans(persObj, trans.get(), log);
+ return trans.release();
+}
diff --git a/Tracker/TrackerEventCnv/TrackerEventAthenaPool/src/FaserSCT_RawDataContainerCnv_p4.h b/Tracker/TrackerEventCnv/TrackerEventAthenaPool/src/FaserSCT_RawDataContainerCnv_p4.h
new file mode 100644
index 0000000000000000000000000000000000000000..d888a833b8af69e32eb802d52d0d5cdc1e7b9be1
--- /dev/null
+++ b/Tracker/TrackerEventCnv/TrackerEventAthenaPool/src/FaserSCT_RawDataContainerCnv_p4.h
@@ -0,0 +1,47 @@
+/*
+ Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef FASERSCT_RAWDATACONTAINERCNV_P4_H
+#define FASERSCT_RAWDATACONTAINERCNV_P4_H
+
+// FaserSCT_RawDataContainerCnv_p4, T/P separation of SCT Raw data
+// author Susumu Oda <Susumu.Oda@cern.ch>
+
+#include "AthenaPoolCnvSvc/T_AthenaPoolTPConverter.h"
+
+#include "TrackerEventAthenaPool/FaserSCT_RawDataContainer_p4.h"
+#include "TrackerRawData/FaserSCT_RDO_Container.h"
+
+class FaserSCT_ID;
+
+// We do NOT use T_AthenaPoolTPCnvIDCont because we do all of the
+// conversion in the .cxx. Same as for the LAr Raw Channels
+// Note that this is used for a container of SCT Raw Data
+// that containes only SCR1_RawData concrete types
+// FaserSCT_RDO_ContainerCnv.cxx delegates the conversion to this
+// converter if the objects are of the correct type
+
+
+class FaserSCT_RawDataContainerCnv_p4 : public T_AthenaPoolTPCnvBase<FaserSCT_RDO_Container, FaserSCT_RawDataContainer_p4>
+{
+ private:
+ const FaserSCT_ID* m_sctId;
+ int m_type;
+ public:
+ FaserSCT_RawDataContainerCnv_p4() : m_sctId(nullptr), m_type(0) {};
+
+ virtual void persToTrans(const FaserSCT_RawDataContainer_p4* persCont,
+ FaserSCT_RDO_Container* transCont,
+ MsgStream& log);
+ virtual void transToPers(const FaserSCT_RDO_Container* transCont,
+ FaserSCT_RawDataContainer_p4* persCont,
+ MsgStream& log);
+ virtual FaserSCT_RDO_Container* createTransient(const FaserSCT_RawDataContainer_p4* persObj, MsgStream& log);
+
+ // ID helper can't be used in the constructor, need initialize()
+ void initialize(const FaserSCT_ID* idhelper) { m_sctId = idhelper; }
+ void setType(int type) { m_type = type; }
+};
+
+#endif // FASERSCT_RAWDATACONTAINERCNV_P4_H
diff --git a/Tracker/TrackerEventCnv/TrackerEventAthenaPool/src/MsgUtil.h b/Tracker/TrackerEventCnv/TrackerEventAthenaPool/src/MsgUtil.h
new file mode 100644
index 0000000000000000000000000000000000000000..8a8e3927b0827c22ec685c632a4daeaae90c2e45
--- /dev/null
+++ b/Tracker/TrackerEventCnv/TrackerEventAthenaPool/src/MsgUtil.h
@@ -0,0 +1,20 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef TRACKEREVENTATHENAPOOL_MSGFIX
+#define TRACKEREVENTATHENAPOOL_MSGFIX
+
+//Defines similar to ATH_MSG_DEBUG and ATH_MSG_VERBOSE which accepts the MsgStream as an argument:
+#ifdef MSG_DEBUG
+#undef MSG_DEBUG
+#endif
+#ifdef MSG_VERBOSE
+#undef MSG_VERBOSE
+#endif
+#define MSG_DEBUG(log, x) \
+ do { if (log.level()<=MSG::DEBUG) { log << MSG::DEBUG << x << endmsg; } } while (0)
+#define MSG_VERBOSE(log, x) \
+ do { if (log.level()<=MSG::VERBOSE) { log << MSG::VERBOSE << x << endmsg; } } while (0)
+
+#endif
diff --git a/Tracker/TrackerEventCnv/TrackerEventAthenaPool/src/TrackerSimDataCnv_p2.cxx b/Tracker/TrackerEventCnv/TrackerEventAthenaPool/src/TrackerSimDataCnv_p2.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..9c48a5ea80e4bbc0770caa508604db358f08a345
--- /dev/null
+++ b/Tracker/TrackerEventCnv/TrackerEventAthenaPool/src/TrackerSimDataCnv_p2.cxx
@@ -0,0 +1,58 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#include "TrackerSimData/TrackerSimData.h"
+#include "MsgUtil.h"
+
+// Persistent class and converter header file
+#include "TrackerEventAthenaPool/TrackerSimData_p2.h"
+#include "TrackerSimDataCnv_p2.h"
+#include "AthenaBaseComps/AthMessaging.h"
+
+
+typedef std::vector<TrackerSimData::Deposit>::const_iterator depositIterator;
+
+TrackerSimDataCnv_p2::TrackerSimDataCnv_p2()
+ : m_sg(nullptr)
+{
+}
+
+
+void
+TrackerSimDataCnv_p2::persToTrans(const TrackerSimData_p2* persObj, TrackerSimData* transObj, MsgStream &log)
+{
+ MSG_VERBOSE(log,"TrackerSimDataCnv_p2::persToTrans called ");
+ std::vector<TrackerSimData::Deposit> deposits;
+ deposits.reserve( persObj->m_enDeposits.size() );
+ for (unsigned int icount=0; icount < persObj->m_enDeposits.size(); icount++) {
+ HepMcParticleLink mcLink (m_sg);
+ HepMcPLCnv.persToTrans(&(persObj->m_links[icount]),&mcLink, log);
+ deposits.emplace_back (mcLink, persObj->m_enDeposits[icount]);
+ }
+
+ *transObj = TrackerSimData (std::move(deposits),
+ persObj->m_word);
+}
+
+void
+TrackerSimDataCnv_p2::transToPers(const TrackerSimData* transObj, TrackerSimData_p2* persObj, MsgStream &log)
+{
+ MSG_VERBOSE(log,"TrackerSimDataCnv_p2::transToPers called ");
+ HepMcParticleLinkCnv_p2 HepMcPLCnv;
+
+ persObj->m_word = transObj->word();
+ const std::vector<TrackerSimData::Deposit> &dep(transObj->getdeposits());
+ persObj->m_links.resize(dep.size() );
+ persObj->m_enDeposits.resize(dep.size() );
+ depositIterator it=dep.begin();
+ for (int icount=0; it != dep.end(); it++, icount++) {
+ HepMcPLCnv.transToPers(&(dep[icount].first), &(persObj->m_links[icount]), log);
+ persObj->m_enDeposits[icount] = dep[icount].second;
+ }
+}
+
+void TrackerSimDataCnv_p2::setCurrentStore (IProxyDict* store)
+{
+ m_sg = store;
+}
\ No newline at end of file
diff --git a/Tracker/TrackerEventCnv/TrackerEventAthenaPool/src/TrackerSimDataCnv_p2.h b/Tracker/TrackerEventCnv/TrackerEventAthenaPool/src/TrackerSimDataCnv_p2.h
new file mode 100644
index 0000000000000000000000000000000000000000..baed0abdbf2dfeb85b0553c9ffb7d50bd090f604
--- /dev/null
+++ b/Tracker/TrackerEventCnv/TrackerEventAthenaPool/src/TrackerSimDataCnv_p2.h
@@ -0,0 +1,38 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef TRACKERSIMDATACNV_P2_H
+#define TRACKERSIMDATACNV_P2_H
+
+/*
+ Transient/Persistent converter for TrackerSimData class
+ Author: Davide Costanzo
+*/
+
+#include "TrackerSimData/TrackerSimData.h"
+#include "TrackerEventAthenaPool/TrackerSimData_p2.h"
+
+#include "AthenaPoolCnvSvc/T_AthenaPoolTPConverter.h"
+#include "GeneratorObjectsTPCnv/HepMcParticleLinkCnv_p2.h"
+
+class MsgStream;
+class IProxyDict;
+
+class TrackerSimDataCnv_p2 : public T_AthenaPoolTPCnvBase<TrackerSimData, TrackerSimData_p2>
+{
+public:
+
+ TrackerSimDataCnv_p2();
+ virtual void persToTrans(const TrackerSimData_p2* persObj, TrackerSimData* transObj, MsgStream &log);
+ virtual void transToPers(const TrackerSimData* transObj, TrackerSimData_p2* persObj, MsgStream &log);
+ void setCurrentStore (IProxyDict* store);
+
+private:
+ IProxyDict* m_sg;
+ HepMcParticleLinkCnv_p2 HepMcPLCnv;
+};
+
+
+#endif
+
diff --git a/Tracker/TrackerEventCnv/TrackerEventAthenaPool/src/TrackerSimDataCollectionCnv.cxx b/Tracker/TrackerEventCnv/TrackerEventAthenaPool/src/TrackerSimDataCollectionCnv.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..93fdf0a0165c7b6630c5ec9d02d85ed3d48d17df
--- /dev/null
+++ b/Tracker/TrackerEventCnv/TrackerEventAthenaPool/src/TrackerSimDataCollectionCnv.cxx
@@ -0,0 +1,49 @@
+/*
+ Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+*/
+
+#include "TrackerSimDataCollectionCnv.h"
+
+
+TrackerSimDataCollection_PERS* TrackerSimDataCollectionCnv::createPersistent(TrackerSimDataCollection* transCont) {
+ MsgStream mlog(msgSvc(), "TrackerSimDataCollectionCnv" );
+ TrackerSimDataCollectionCnv_PERS converter;
+ TrackerSimDataCollection_PERS *persObj = converter.createPersistent( transCont, mlog );
+ return persObj;
+}
+
+
+TrackerSimDataCollection* TrackerSimDataCollectionCnv::createTransient() {
+ MsgStream mlog(msgSvc(), "TrackerSimDataCollection" );
+ // TrackerSimDataCollectionCnv_p1 converter_p1;
+ // TrackerSimDataCollectionCnv_p2 converter_p2;
+ TrackerSimDataCollectionCnv_p3 converter_p3;
+
+ TrackerSimDataCollection *trans_cont(0);
+ static const pool::Guid p3_guid("E25FFB08-56F4-4594-B005-45200A725CD4");
+ // static const pool::Guid p3_guid("1430AA7B-EE92-5A41-92F3-5DD5367D6BAA");
+ // static const pool::Guid p2_guid("C648CA66-013D-44AC-B0D9-99BFB0060E84");
+ // static const pool::Guid p1_guid("333EF996-1672-4AB8-917D-187F908F1EDE");
+ // static const pool::Guid old_guid("5A50C32E-C036-4A49-AE97-716D53210BE1");
+ static const pool::Guid old_guid("DF5775E8-8C33-4B82-8322-58B7671BF678");
+
+ if( this->compareClassGuid(p3_guid)) {
+ std::unique_ptr< TrackerSimDataCollection_p3 > col_vect( this->poolReadObject< TrackerSimDataCollection_p3 >() );
+ trans_cont = converter_p3.createTransient( col_vect.get(), mlog );
+ }
+ // else if( this->compareClassGuid(p2_guid)) {
+ // std::unique_ptr< TrackerSimDataCollection_p2 > col_vect( this->poolReadObject< TrackerSimDataCollection_p2 >() );
+ // trans_cont = converter_p2.createTransient( col_vect.get(), mlog );
+ // }
+ // else if( this->compareClassGuid(p1_guid)) {
+ // std::unique_ptr< TrackerSimDataCollection_p1 > col_vect( this->poolReadObject< TrackerSimDataCollection_p1 >() );
+ // trans_cont = converter_p1.createTransient( col_vect.get(), mlog );
+ // }
+ else if( this->compareClassGuid(old_guid)) {
+ // old version from before TP separation, just return it
+ trans_cont = this->poolReadObject<TrackerSimDataCollection>();
+ } else {
+ throw std::runtime_error("Unsupported persistent version of Data container");
+ }
+ return trans_cont;
+}
\ No newline at end of file
diff --git a/Tracker/TrackerEventCnv/TrackerEventAthenaPool/src/TrackerSimDataCollectionCnv.h b/Tracker/TrackerEventCnv/TrackerEventAthenaPool/src/TrackerSimDataCollectionCnv.h
new file mode 100644
index 0000000000000000000000000000000000000000..e5ffb5f6e914a26ba2f4e0ed87a857c16a641a4c
--- /dev/null
+++ b/Tracker/TrackerEventCnv/TrackerEventAthenaPool/src/TrackerSimDataCollectionCnv.h
@@ -0,0 +1,35 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef TRACKERSIMDATACOLLECTIONCNV_H
+#define TRACKERSIMDATACOLLECTIONCNV_H
+
+#include "AthenaPoolCnvSvc/T_AthenaPoolCustomCnv.h"
+
+#include "TrackerSimData/TrackerSimDataCollection.h"
+// #include "TrackerSimDataCollectionCnv_p1.h"
+// #include "TrackerSimDataCollectionCnv_p2.h"
+#include "TrackerSimDataCollectionCnv_p3.h"
+
+// Gaudi
+#include "GaudiKernel/MsgStream.h"
+// typedef to the latest persistent version
+typedef TrackerSimDataCollection_p3 TrackerSimDataCollection_PERS;
+typedef TrackerSimDataCollectionCnv_p3 TrackerSimDataCollectionCnv_PERS;
+
+// base class
+typedef T_AthenaPoolCustomCnv<TrackerSimDataCollection, TrackerSimDataCollection_PERS > TrackerSimDataCollectionCnvBase;
+
+class TrackerSimDataCollectionCnv : public TrackerSimDataCollectionCnvBase {
+ friend class CnvFactory<TrackerSimDataCollectionCnv >;
+
+protected:
+public:
+ TrackerSimDataCollectionCnv (ISvcLocator* svcloc) : TrackerSimDataCollectionCnvBase(svcloc) {}
+protected:
+ virtual TrackerSimDataCollection_PERS* createPersistent (TrackerSimDataCollection* transCont);
+ virtual TrackerSimDataCollection* createTransient ();
+};
+
+#endif
diff --git a/Tracker/TrackerEventCnv/TrackerEventAthenaPool/src/TrackerSimDataCollectionCnv_p3.cxx b/Tracker/TrackerEventCnv/TrackerEventAthenaPool/src/TrackerSimDataCollectionCnv_p3.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..626ddcdb7aa88f8a1a42691f117d2f93f8f8fe8c
--- /dev/null
+++ b/Tracker/TrackerEventCnv/TrackerEventAthenaPool/src/TrackerSimDataCollectionCnv_p3.cxx
@@ -0,0 +1,55 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#include "TrackerSimData/TrackerSimData.h"
+#include "TrackerSimData/TrackerSimDataCollection.h"
+#include "TrackerEventAthenaPool/TrackerSimDataCollection_p3.h"
+#include "TrackerSimDataCollectionCnv_p3.h"
+#include "TrackerSimDataCnv_p2.h"
+#include "Identifier/Identifier.h"
+#include "SGTools/CurrentEventStore.h"
+#include "MsgUtil.h"
+
+void TrackerSimDataCollectionCnv_p3::transToPers(const TrackerSimDataCollection* transCont, TrackerSimDataCollection_p3* persCont, MsgStream &log)
+{
+
+
+ typedef TrackerSimDataCollection TRANS;
+
+ TrackerSimDataCnv_p2 simDataCnv;
+
+ TRANS::const_iterator it_Coll = transCont->begin();
+ TRANS::const_iterator it_CollEnd = transCont->end();
+ persCont->m_simdata.resize(transCont->size());
+ MSG_DEBUG(log," Preparing " << persCont->m_simdata.size() << "Collections");
+ for (int collIndex=0 ; it_Coll != it_CollEnd; it_Coll++, collIndex++) {
+ // Add in new collection
+ (persCont->m_simdata[collIndex]).first = (*it_Coll).first.get_compact();
+ const TrackerSimData& simData = (*it_Coll).second;
+ TrackerSimData_p2& psimData = persCont->m_simdata[collIndex].second;
+ simDataCnv.transToPers(&simData,&psimData,log);
+ }
+ MSG_DEBUG(log," *** Writing TrackerSimdataCollection");
+}
+
+void TrackerSimDataCollectionCnv_p3::persToTrans(const TrackerSimDataCollection_p3* persCont, TrackerSimDataCollection* transCont, MsgStream &log)
+{
+
+ typedef std::vector<std::pair<Identifier::value_type, TrackerSimData_p2 > >::const_iterator COLLITER;
+ TrackerSimDataCnv_p2 simDataCnv;
+
+ COLLITER it_Coll = persCont->m_simdata.begin();
+ COLLITER it_CollEnd = persCont->m_simdata.end();
+ MSG_DEBUG(log," Preparing " << persCont->m_simdata.size() << "Collections");
+ simDataCnv.setCurrentStore (SG::CurrentEventStore::store());
+ for (int collIndex=0 ; it_Coll != it_CollEnd; it_Coll++, collIndex++) {
+ // Add in new collection
+ const TrackerSimData_p2& psimData = persCont->m_simdata[collIndex].second;
+ TrackerSimData simData;
+ simDataCnv.persToTrans(&psimData,&simData,log);
+ transCont->insert( transCont->end(), std :: make_pair( Identifier( it_Coll->first ), simData ) );
+ }
+ MSG_DEBUG(log," *** Reading TrackerSimdataCollection");
+
+}
\ No newline at end of file
diff --git a/Tracker/TrackerEventCnv/TrackerEventAthenaPool/src/TrackerSimDataCollectionCnv_p3.h b/Tracker/TrackerEventCnv/TrackerEventAthenaPool/src/TrackerSimDataCollectionCnv_p3.h
new file mode 100644
index 0000000000000000000000000000000000000000..d785b7fce0d7d106f9533d23ef12b053608d9e03
--- /dev/null
+++ b/Tracker/TrackerEventCnv/TrackerEventAthenaPool/src/TrackerSimDataCollectionCnv_p3.h
@@ -0,0 +1,30 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef TRACKERSIMDATACOLLECTIONCNV_P3_H
+#define TRACKERSIMDATACOLLECTIONCNV_P3_H
+
+// TrackerSimDataCollectionCnv_p3, T/P separation of TrackerSimData
+// author D.Costanzo <davide.costanzo@cern.ch>,O.Arnaez <olivier.arnaez@cern.ch>
+
+#include "TrackerSimData/TrackerSimDataCollection.h"
+#include "TrackerEventAthenaPool/TrackerSimDataCollection_p3.h"
+#include "AthenaPoolCnvSvc/T_AthenaPoolTPConverter.h"
+
+
+class TrackerSimDataCollectionCnv_p3 : public T_AthenaPoolTPCnvBase<TrackerSimDataCollection, TrackerSimDataCollection_p3>
+{
+ public:
+ TrackerSimDataCollectionCnv_p3() {};
+
+ virtual void persToTrans(const TrackerSimDataCollection_p3* persCont,
+ TrackerSimDataCollection* transCont,
+ MsgStream &log) ;
+ virtual void transToPers(const TrackerSimDataCollection* transCont,
+ TrackerSimDataCollection_p3* persCont,
+ MsgStream &log) ;
+
+};
+
+#endif
diff --git a/Tracker/TrackerEventCnv/TrackerEventTPCnv/CMakeLists.txtIgnore b/Tracker/TrackerEventCnv/TrackerEventTPCnv/CMakeLists.txtIgnore
new file mode 100644
index 0000000000000000000000000000000000000000..b01b52100c8333b2dc0e64e9db935199db91c57a
--- /dev/null
+++ b/Tracker/TrackerEventCnv/TrackerEventTPCnv/CMakeLists.txtIgnore
@@ -0,0 +1,79 @@
+# $Id: CMakeLists.txt 730306 2016-03-16 10:26:06Z krasznaa $
+################################################################################
+# Package: TrackerEventTPCnv
+################################################################################
+
+# Declare the package name:
+atlas_subdir( TrackerEventTPCnv )
+
+# Declare the package's dependencies:
+atlas_depends_on_subdirs(
+ PUBLIC
+ Control/AthAllocators
+ Control/AthLinks
+ Control/DataModelAthenaPool
+ Control/StoreGate
+ Database/AthenaPOOL/AthenaPoolCnvSvc
+ Database/AthenaPOOL/AthenaPoolUtilities
+ DetectorDescription/Identifier
+ GaudiKernel
+ Tracker/TrackerDetDescr/TrackerIdentifier
+ #InnerDetector/InDetRecEvent/InDetCompetingRIOsOnTrack
+ #Tracker/TrackerRecEvent/TrackerPrepRawData
+ #Tracker/TrackerRecEvent/TrackerRIO_OnTrack
+ Tracking/TrkEventCnv/TrkEventCnvTools
+ Tracking/TrkEventCnv/TrkEventTPCnv
+ PRIVATE
+ AtlasTest/TestTools
+ Control/AthenaBaseComps
+ Control/AthenaKernel
+ Control/SGTools
+ DetectorDescription/IdDictParser
+ Event/EventPrimitives
+ Tracker/TrackerDetDescr/TrackerReadoutGeometry
+ Tracking/TrkDetDescr/TrkSurfaces
+ Tracking/TrkEvent/TrkEventPrimitives
+ Tracking/TrkEvent/TrkMeasurementBase
+ Tracking/TrkEvent/TrkRIO_OnTrack )
+
+# Component(s) in the package:
+atlas_add_tpcnv_library( TrackerEventTPCnv
+ TrackerEventTPCnv/*.h src/*.cxx
+# TrackerEventTPCnv/TrackerRIO_OnTrack/*.h src/TrackerRIO_OnTrack/*.cxx
+# TrackerEventTPCnv/TrackerPrepRawData/*.h src/TrackerPrepRawData/*.cxx
+# TrackerEventTPCnv/InDetCompetingRIOsOnTrack/*.h
+# src/InDetCompetingRIOsOnTrack/*.cxx
+ PUBLIC_HEADERS TrackerEventTPCnv
+ LINK_LIBRARIES AthAllocators AthLinks DataModelAthenaPoolLib StoreGateLib
+ AthenaPoolCnvSvcLib AthenaPoolUtilities Identifier GaudiKernel
+ TrackerIdentifier
+# InDetCompetingRIOsOnTrack
+# TrackerPrepRawData TrackerRIO_OnTrack
+ TrkEventTPCnv
+ PRIVATE_LINK_LIBRARIES AthenaBaseComps AthenaKernel
+ EventPrimitives TrackerReadoutGeometry TrkSurfaces TrkEventPrimitives
+ TrkMeasurementBase TrkRIO_OnTrack )
+
+atlas_add_dictionary( TrackerEventTPCnvDict
+ TrackerEventTPCnv/TrackerEventTPCnvDict.h TrackerEventTPCnv/selection.xml
+ LINK_LIBRARIES TrackerEventTPCnv )
+
+# A helper variable:
+set( _jobOPath "${CMAKE_CURRENT_SOURCE_DIR}/share" )
+set( _jobOPath "${_jobOPath}:${CMAKE_JOBOPT_OUTPUT_DIRECTORY}" )
+set( _jobOPath "${_jobOPath}:$ENV{JOBOPTSEARCHPATH}" )
+
+# Set up all the tests in the package:
+#foreach( name SiWidthCnv_p1_test SiWidthCnv_p2_test
+# SCT_ClusterContainerCnv_p2_test
+# SCT_ClusterContainerCnv_p3_test
+# SCT_ClusterCnv_p1_test SCT_ClusterCnv_p2_test SCT_ClusterCnv_p3_test
+# )
+#
+# atlas_add_test( ${name}
+# SOURCES test/${name}.cxx
+# LINK_LIBRARIES TrackerEventTPCnv GaudiKernel IdDictParser
+# SGTools TrackerReadoutGeometry TestTools TrackerIdentifier
+# ENVIRONMENT "JOBOPTSEARCHPATH=${_jobOPath}" )
+
+endforeach()
diff --git a/Tracker/TrackerEventCnv/TrackerEventTPCnv/TrackerEventTPCnv/ATLAS_CHECK_THREAD_SAFETY b/Tracker/TrackerEventCnv/TrackerEventTPCnv/TrackerEventTPCnv/ATLAS_CHECK_THREAD_SAFETY
new file mode 100644
index 0000000000000000000000000000000000000000..0390090264501f47b8d616dd34d12c3594400cbc
--- /dev/null
+++ b/Tracker/TrackerEventCnv/TrackerEventTPCnv/TrackerEventTPCnv/ATLAS_CHECK_THREAD_SAFETY
@@ -0,0 +1 @@
+Tracker/TrackerEventCnv/TrackerEventTPCnv
\ No newline at end of file
diff --git a/Tracker/TrackerEventCnv/TrackerEventTPCnv/TrackerEventTPCnv/TrackerEventTPCnvDict.h b/Tracker/TrackerEventCnv/TrackerEventTPCnv/TrackerEventTPCnv/TrackerEventTPCnvDict.h
new file mode 100644
index 0000000000000000000000000000000000000000..95960147ef2739fcf1805a8c9cc5fd85541ce771
--- /dev/null
+++ b/Tracker/TrackerEventCnv/TrackerEventTPCnv/TrackerEventTPCnv/TrackerEventTPCnvDict.h
@@ -0,0 +1,62 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef TRACKEREVENTTPCNV_TRACKEREVENTTPCNVDICT_H
+#define TRACKEREVENTTPCNV_TRACKEREVENTTPCNVDICT_H
+
+//-----------------------------------------------------------------------------
+//
+// file: TrackerEventTPCnvDict_p1.h
+//
+//-----------------------------------------------------------------------------
+
+#include "InDetEventTPCnv/InDetTrack_tlp1.h"
+#include "InDetEventTPCnv/InDetTrack_tlp2.h"
+#include "InDetEventTPCnv/PixelClusterContainer_tlp1.h"
+#include "InDetEventTPCnv/InDetPrepRawData/SiCluster_p1.h"
+#include "InDetEventTPCnv/InDetPrepRawData/InDetPRD_Collection_p1.h"
+#include "InDetEventTPCnv/InDetPrepRawData/InDetPRD_Container_p1.h"
+#include "InDetEventTPCnv/InDetPrepRawData/PixelCluster_p1.h"
+#include "InDetEventTPCnv/InDetPrepRawData/PixelCluster_p2.h"
+#include "InDetEventTPCnv/InDetPrepRawData/PixelCluster_p3.h"
+#include "InDetEventTPCnv/InDetPrepRawData/SCT_Cluster_p1.h"
+#include "InDetEventTPCnv/InDetPrepRawData/TRT_DriftCircle_p1.h"
+#include "InDetEventTPCnv/InDetPrepRawData/TRT_DriftCircle_p2.h"
+#include "InDetEventTPCnv/TRT_DriftCircleContainer_p2.h"
+#include "InDetEventTPCnv/PixelClusterContainer_p2.h"
+#include "InDetEventTPCnv/PixelClusterContainer_p3.h"
+#include "InDetEventTPCnv/SCT_ClusterContainer_p2.h"
+#include "InDetEventTPCnv/SCT_ClusterContainer_p3.h"
+#include "InDetEventTPCnv/PixelClusterContainer_tlp1.h"
+#include "InDetEventTPCnv/SCT_ClusterContainer_tlp1.h"
+#include "InDetEventTPCnv/TRT_DriftCircleContainer_tlp1.h"
+#include "InDetEventTPCnv/InDetPrepRawData/PixelGangedClusterAmbiguities_p1.h"
+#include "InDetEventTPCnv/TRT_DriftCircleContainer_tlp1.h"
+#include "InDetEventTPCnv/InDetCompetingRIOsOnTrack/CompetingPixelClustersOnTrack_p1.h"
+#include "InDetEventTPCnv/InDetCompetingRIOsOnTrack/CompetingSCT_ClustersOnTrack_p1.h"
+#include "InDetEventTPCnv/InDetCompetingRIOsOnTrack/CompetingTRT_DriftCirclesOnTrack_p1.h"
+#include "InDetEventTPCnv/InDetLowBetaInfo/InDetLowBetaCandidate_p1.h"
+#include "InDetEventTPCnv/InDetLowBetaInfo/InDetLowBetaContainer_p1.h"
+#include "InDetEventTPCnv/InDetLowBetaInfo/InDetLowBetaCandidate_tlp1.h"
+#include "InDetEventTPCnv/InDetLowBetaInfo/InDetLowBetaContainer_tlp1.h"
+
+namespace InDetEventTPCnvDict {
+ struct tmp
+{
+ std::vector< InDet::PixelCluster_p1> m_v1;
+ std::vector< InDet::SCT_Cluster_p1> m_v2;
+ std::vector< InDet::SCT_Cluster_p3> m_v2a;
+ std::vector< InDet::SiCluster_p1> m_v3;
+ std::vector< InDet::TRT_DriftCircle_p1 > m_v6;
+ std::vector< InDet::TRT_DriftCircle_p2 > m_v6a;
+ std::vector< InDet::InDetPRD_Collection_p1 > m_v7;
+ std::vector< InDet::InDetPRD_Container_p1 > m_v8;
+ std::vector< InDet::CompetingPixelClustersOnTrack_p1> m_v9;
+ std::vector< InDet::CompetingSCT_ClustersOnTrack_p1> m_v10;
+ std::vector< InDet::CompetingTRT_DriftCirclesOnTrack_p1> m_v11;
+ std::vector< InDetLowBetaCandidate_p1> m_v12;
+ };
+} //> namespace InDetEventTPCnvDict
+
+#endif // INDETEVENTTPCNV_INDETEVENTTPCNVDICT_H
diff --git a/Tracker/TrackerRawEvent/TrackerRawData/CMakeLists.txt b/Tracker/TrackerRawEvent/TrackerRawData/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..d4892a5b8264a3d493a6c73aaf7626683f4cc169
--- /dev/null
+++ b/Tracker/TrackerRawEvent/TrackerRawData/CMakeLists.txt
@@ -0,0 +1,34 @@
+################################################################################
+# Package: TrackerRawData
+################################################################################
+
+# Declare the package name:
+atlas_subdir( TrackerRawData )
+
+# Declare the package's dependencies:
+atlas_depends_on_subdirs( PUBLIC
+ Control/AthContainers
+ Control/AthLinks
+ Control/AthenaKernel
+ DetectorDescription/Identifier
+ Event/EventContainers
+ PRIVATE
+ GaudiKernel )
+
+# External dependencies:
+find_package( ROOT COMPONENTS Core Tree MathCore Hist RIO pthread )
+
+# Component(s) in the package:
+atlas_add_library( TrackerRawData
+ src/*.cxx
+ PUBLIC_HEADERS TrackerRawData
+ PRIVATE_INCLUDE_DIRS ${ROOT_INCLUDE_DIRS}
+ LINK_LIBRARIES AthenaKernel AthContainers AthLinks Identifier EventContainers
+ PRIVATE_LINK_LIBRARIES ${ROOT_LIBRARIES} GaudiKernel )
+
+atlas_add_dictionary( TrackerRawDataDict
+ TrackerRawData/TrackerRawDataCLASS_DEF.h
+ TrackerRawData/selection.xml
+ INCLUDE_DIRS ${ROOT_INCLUDE_DIRS}
+ LINK_LIBRARIES ${ROOT_LIBRARIES} AthContainers AthLinks Identifier GaudiKernel TrackerRawData EventContainers )
+
diff --git a/Tracker/TrackerRawEvent/TrackerRawData/TrackerRawData/ATLAS_CHECK_THREAD_SAFETY b/Tracker/TrackerRawEvent/TrackerRawData/TrackerRawData/ATLAS_CHECK_THREAD_SAFETY
new file mode 100644
index 0000000000000000000000000000000000000000..8002df1664e262dad2ba3a3368f71995f75fd83e
--- /dev/null
+++ b/Tracker/TrackerRawEvent/TrackerRawData/TrackerRawData/ATLAS_CHECK_THREAD_SAFETY
@@ -0,0 +1 @@
+Tracker/TrackerRawEvent/TrackerRawData
\ No newline at end of file
diff --git a/Tracker/TrackerRawEvent/TrackerRawData/TrackerRawData/FaserSCT1_RawData.h b/Tracker/TrackerRawEvent/TrackerRawData/TrackerRawData/FaserSCT1_RawData.h
new file mode 100644
index 0000000000000000000000000000000000000000..a31ae1209ca2fb43d764b365eb14f3009ee527b8
--- /dev/null
+++ b/Tracker/TrackerRawEvent/TrackerRawData/TrackerRawData/FaserSCT1_RawData.h
@@ -0,0 +1,87 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+///////////////////////////////////////////////////////////////////
+// FaserSCT1_RawData.h
+// Header file for class FaserSCT1_RawData
+///////////////////////////////////////////////////////////////////
+// (c) ATLAS Detector software
+///////////////////////////////////////////////////////////////////
+// Class to implement RawData for SCT, using method 1 for decoding word
+///////////////////////////////////////////////////////////////////
+// Version 1.0 13/08/2002 Veronique Boisvert
+///////////////////////////////////////////////////////////////////
+
+#ifndef TRACKERRAWDATA_FASERSCT1_RAWDATA_H
+#define TRACKERRAWDATA_FASERSCT1_RAWDATA_H
+
+// Base class
+#include "TrackerRawData/FaserSCT_RDORawData.h"
+
+
+// Data members classes
+
+
+
+class FaserSCT1_RawData : public FaserSCT_RDORawData{
+
+ ///////////////////////////////////////////////////////////////////
+ // Public methods:
+ ///////////////////////////////////////////////////////////////////
+public:
+
+ // Constructor with parameters:
+ // offline hash Id, last, word
+ FaserSCT1_RawData(const Identifier rdoId, const unsigned int word);
+
+ // Destructor:
+ virtual ~FaserSCT1_RawData() = default;
+
+ ///////////////////////////////////////////////////////////////////
+ // Virtual methods
+ ///////////////////////////////////////////////////////////////////
+
+
+ // decode group of strips
+ virtual int getGroupSize() const;
+
+
+
+ // Create a new FaserSCT1_RawData and return a pointer to it:
+ // static FaserSCT1_RawData *newObject(const Identifier rdoId, const unsigned int word);
+
+public:
+ // public default constructor needed for I/O, but should not be
+ // called from an alg
+ FaserSCT1_RawData();
+
+ // Default copy constructor
+ FaserSCT1_RawData(const FaserSCT1_RawData&) = default;
+ // Default assignment operator
+ FaserSCT1_RawData& operator=(const FaserSCT1_RawData&) = default;
+ // Default move constructor
+ FaserSCT1_RawData(FaserSCT1_RawData&&) = default;
+ // Default move assignment operator
+ FaserSCT1_RawData& operator=(FaserSCT1_RawData&&) = default;
+
+ ///////////////////////////////////////////////////////////////////
+ // Private data:
+ ///////////////////////////////////////////////////////////////////
+private:
+
+
+};
+
+///////////////////////////////////////////////////////////////////
+// Inline methods:
+///////////////////////////////////////////////////////////////////
+// decode size of group of strips information (from Calvet RawData class)
+inline int FaserSCT1_RawData::getGroupSize() const
+{
+// Temporary mask, should be fixed later
+ return (m_word & 0xFFFF);
+}
+
+
+#endif // TRACKERRAWDATA_SCT1_RAWDATA_H
diff --git a/Tracker/TrackerRawEvent/TrackerRawData/TrackerRawData/FaserSCT3_RawData.h b/Tracker/TrackerRawEvent/TrackerRawData/TrackerRawData/FaserSCT3_RawData.h
new file mode 100644
index 0000000000000000000000000000000000000000..e60febdc01d66d5030441030c4beac8e25afa084
--- /dev/null
+++ b/Tracker/TrackerRawEvent/TrackerRawData/TrackerRawData/FaserSCT3_RawData.h
@@ -0,0 +1,141 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+///////////////////////////////////////////////////////////////////
+// SCT3_RawData.h
+// Header file for class SCT3_RawData
+///////////////////////////////////////////////////////////////////
+// (c) ATLAS Detector software
+///////////////////////////////////////////////////////////////////
+// Class to implement RawData for SCT
+///////////////////////////////////////////////////////////////////
+// Version 1.0 07/06/2005 MJ Costa
+///////////////////////////////////////////////////////////////////
+
+#ifndef TRACKERRAWDATA_FASERSCT3_RAWDATA_H
+#define TRACKERRAWDATA_FASERSCT3_RAWDATA_H
+
+// Base class
+#include "TrackerRawData/FaserSCT_RDORawData.h"
+#include <vector>
+
+
+class FaserSCT3_RawData : public FaserSCT_RDORawData{
+
+ ///////////////////////////////////////////////////////////////////
+ // Public methods:
+ ///////////////////////////////////////////////////////////////////
+public:
+
+ // Constructor with parameters:
+ FaserSCT3_RawData(const Identifier rdoId, const unsigned int word,
+ const std::vector<int>* errorHit);
+
+ FaserSCT3_RawData(const Identifier rdoId, const unsigned int word,
+ std::vector<int>&& errorHit);
+
+ // Destructor:
+ virtual ~FaserSCT3_RawData() = default;
+
+ ///////////////////////////////////////////////////////////////////
+ // Virtual methods
+ ///////////////////////////////////////////////////////////////////
+
+ // decode group of strips
+ virtual int getGroupSize() const;
+
+ // decode time bin information for the 3 consecutive bunch crossings
+ // This information is stored in 3 bits where the most significant bit
+ // corresponds to BC-1. So the 3 bit pattern is: (BC-1), BC, (BC+1)
+ int getTimeBin() const;
+
+
+ int getErrors() const;
+
+ bool OnTime() const;
+
+ bool FirstHitError() const;
+ bool SecondHitError() const;
+
+ const std::vector<int>& getErrorCondensedHit() const;
+
+public:
+ // public default constructor needed for I/O, but should not be
+ // called from an alg
+ FaserSCT3_RawData();
+
+ // Default copy constructor
+ FaserSCT3_RawData(const FaserSCT3_RawData&) = default;
+ // Default assignment operator
+ FaserSCT3_RawData& operator=(const FaserSCT3_RawData&) = default;
+ // Default move constructor
+ FaserSCT3_RawData(FaserSCT3_RawData&&) = default;
+ // Default move assignment operator
+ FaserSCT3_RawData& operator=(FaserSCT3_RawData&&) = default;
+
+ ///////////////////////////////////////////////////////////////////
+ // Private data:
+ ///////////////////////////////////////////////////////////////////
+private:
+
+ std::vector<int> m_errorCondensedHit;
+
+};
+
+///////////////////////////////////////////////////////////////////
+// Inline methods:
+///////////////////////////////////////////////////////////////////
+// decode size of group of strips information
+inline int FaserSCT3_RawData::getGroupSize() const
+{
+ return (m_word & 0x7FF);
+}
+
+//decode time bin information
+inline int FaserSCT3_RawData::getTimeBin() const
+{
+ return ((m_word >> 22) & 0x7);
+}
+
+//returns a word incoding the errors
+// bit 4: error in condensed mode 1rst hit
+// bit 5: error in condensed mode 2nd hit
+inline int FaserSCT3_RawData::getErrors() const
+{
+ return ((m_word >> 25) & 0x7);
+}
+
+// returns true if the time bin corresponding to the present BC is on
+inline bool FaserSCT3_RawData::OnTime() const
+{
+ bool isOnTime = false;
+ if ((m_word >> 23) & 0x1) isOnTime = true;
+ return isOnTime;
+}
+
+// returns true if there is an error in the first hit's data
+inline bool FaserSCT3_RawData::FirstHitError() const
+{
+ bool isError = false;
+ if ((m_word >> 29) & 0x1) isError = true;
+ return isError;
+}
+
+// returns true if there is an error in the second hit's data
+inline bool FaserSCT3_RawData::SecondHitError() const
+{
+ bool isError = false;
+ if ((m_word >> 30) & 0x1) isError = true;
+ return isError;
+}
+
+// returns a vector where each element is a number of the strip in
+// that group (starting at zero) with an error in:
+
+inline const std::vector<int>& FaserSCT3_RawData::getErrorCondensedHit() const
+{
+ return m_errorCondensedHit;
+}
+
+#endif // TRACKERRAWDATA_FASERSCT3_RAWDATA_H
diff --git a/Tracker/TrackerRawEvent/TrackerRawData/TrackerRawData/FaserSCT_RDORawData.h b/Tracker/TrackerRawEvent/TrackerRawData/TrackerRawData/FaserSCT_RDORawData.h
new file mode 100644
index 0000000000000000000000000000000000000000..864fcda7c769d13d46f445b4256a55c4509eb6ea
--- /dev/null
+++ b/Tracker/TrackerRawEvent/TrackerRawData/TrackerRawData/FaserSCT_RDORawData.h
@@ -0,0 +1,81 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+///////////////////////////////////////////////////////////////////
+// FaserSCT_RawData.h
+// Header file for class FaserSCT_RawData
+///////////////////////////////////////////////////////////////////
+// (c) ATLAS Detector software
+///////////////////////////////////////////////////////////////////
+// Class to implement RawData for SCT
+///////////////////////////////////////////////////////////////////
+// Version 1.0 13/08/2002 Veronique Boisvert
+///////////////////////////////////////////////////////////////////
+
+#ifndef TRACKERRAWDATA_FASERSCT_RDORAWDATA_H
+#define TRACKERRAWDATA_FASERSCT_RDORAWDATA_H
+
+// Base class
+#include "TrackerRawData/TrackerRawData.h"
+
+
+
+class FaserSCT_RDORawData : public TrackerRawData{
+
+
+ ///////////////////////////////////////////////////////////////////
+ // Public methods:
+ ///////////////////////////////////////////////////////////////////
+public:
+
+ // Constructor with parameters:
+ // offline hash Id, last, word
+ FaserSCT_RDORawData(const Identifier rdoId, const unsigned int word);
+
+ // Destructor:
+ virtual ~FaserSCT_RDORawData() = default;
+
+ ///////////////////////////////////////////////////////////////////
+ // Virtual methods
+ ///////////////////////////////////////////////////////////////////
+
+ // pure virtual
+ virtual int getGroupSize() const = 0;
+
+ ///////////////////////////////////////////////////////////////////
+ // Static methods:
+ ///////////////////////////////////////////////////////////////////
+
+ // Default copy constructor
+ FaserSCT_RDORawData(const FaserSCT_RDORawData&) = default;
+ // Default assignment operator
+ FaserSCT_RDORawData& operator=(const FaserSCT_RDORawData&) = default;
+ // Default move constructor
+ FaserSCT_RDORawData(FaserSCT_RDORawData&&) = default;
+ // Default move assignment operator
+ FaserSCT_RDORawData& operator=(FaserSCT_RDORawData&&) = default;
+
+ // Create a new FaserSCT_RawData and return a pointer to it:
+ // static FaserSCT_RawData *newObject(const Identifier rdoId, const unsigned int word);
+ ///////////////////////////////////////////////////////////////////
+ // Private methods:
+ ///////////////////////////////////////////////////////////////////
+private:
+
+
+ FaserSCT_RDORawData();
+
+ ///////////////////////////////////////////////////////////////////
+ // Private data:
+ ///////////////////////////////////////////////////////////////////
+private:
+
+
+};
+
+///////////////////////////////////////////////////////////////////
+// Inline methods:
+///////////////////////////////////////////////////////////////////
+
+#endif // TRACKERAWDATA_FASERSCT_RDORAWDATA_H
diff --git a/Tracker/TrackerRawEvent/TrackerRawData/TrackerRawData/FaserSCT_RDO_Collection.h b/Tracker/TrackerRawEvent/TrackerRawData/TrackerRawData/FaserSCT_RDO_Collection.h
new file mode 100644
index 0000000000000000000000000000000000000000..831b881675a08b1435cd04375712e3ee7a8d6d4e
--- /dev/null
+++ b/Tracker/TrackerRawEvent/TrackerRawData/TrackerRawData/FaserSCT_RDO_Collection.h
@@ -0,0 +1,59 @@
+/*
+ Copyright (C) 2002-2018 CERN for the benefit of the ATLAS collaboration
+*/
+
+/***************************************************************************
+ TrackerRawData package
+ -----------------------------------------
+ ***************************************************************************/
+
+//<doc><file> $Id: Tracker_RDO_Collection.h,v 1.9 2007-05-28 12:47:23 kgnanvo Exp $
+//<version> $Name: not supported by cvs2svn $
+
+#ifndef TRACKERRAWDATA_SCT_RDO_COLLECTION_H
+#define TRACKERRAWDATA_SCT_RDO_COLLECTION_H
+
+#include "AthenaKernel/CLASS_DEF.h"
+#include "TrackerRawData/TrackerRawDataCollection.h"
+#include "TrackerRawData/FaserSCT1_RawData.h"
+#include "TrackerRawData/FaserSCT3_RawData.h"
+class MsgStream;
+
+typedef TrackerRawDataCollection< FaserSCT_RDORawData >
+ FaserSCT_RDO_Collection;
+
+CLASS_DEF(FaserSCT_RDO_Collection, 1077697857, 1)
+
+/**Overload of << operator for MsgStream for debug output*/
+MsgStream& operator << ( MsgStream& sl, const FaserSCT_RDO_Collection& coll);
+
+/**Overload of << operator for std::ostream for debug output*/
+std::ostream& operator << ( std::ostream& sl, const FaserSCT_RDO_Collection& coll);
+
+
+// typedef InDetRawDataCollection< SCT_TB03_RawData >
+// SCT_RDO_TB03_Collection;
+
+// CLASS_DEF(SCT_RDO_TB03_Collection, 1234089640, 1)
+
+// typedef InDetRawDataCollection< SCT_TB04_RawData >
+// SCT_RDO_TB04_Collection;
+
+// CLASS_DEF(SCT_RDO_TB04_Collection, 1278514121 , 1)
+
+typedef TrackerRawDataCollection< FaserSCT3_RawData >
+ FaserSCT3_RDO_Collection;
+
+CLASS_DEF(FaserSCT3_RDO_Collection, 1102069697 , 1)
+
+// Class needed only for persistency - we add CLASS_DEF only to
+// instantiate the template.
+// typedef DataVector<InDetRawDataCollection< SCT1_RawData > > SCT_RDO_vector;
+
+// CLASS_DEF( SCT_RDO_vector, 1241152074, 1 )
+
+// typedef DataVector<const InDetRawDataCollection< SCT1_RawData > > SCT_RDO_constvector;
+
+//CLASS_DEF( SCT_RDO_constvector, 1159798379, 1 )
+
+#endif // TRACKERRAWDATA_FASERSCT_RDO_COLLECTION_H
diff --git a/Tracker/TrackerRawEvent/TrackerRawData/TrackerRawData/FaserSCT_RDO_Container.h b/Tracker/TrackerRawEvent/TrackerRawData/TrackerRawData/FaserSCT_RDO_Container.h
new file mode 100644
index 0000000000000000000000000000000000000000..4af8b992b57f3bae70224ff1ca392339fe5c2731
--- /dev/null
+++ b/Tracker/TrackerRawEvent/TrackerRawData/TrackerRawData/FaserSCT_RDO_Container.h
@@ -0,0 +1,33 @@
+/*
+ Copyright (C) 2002-2018 CERN for the benefit of the ATLAS collaboration
+*/
+
+/***************************************************************************
+ TrackerRawData package
+ -----------------------------------------
+ ***************************************************************************/
+
+//<doc><file> $Id: SCT_RDO_Container.h,v 1.6 2008-01-05 18:53:00 ssnyder Exp $
+//<version> $Name: not supported by cvs2svn $
+
+#ifndef TRACKERRAWDATA_SCT_RDO_CONTAINER_H
+#define TRACKERRAWDATA_SCT_RDO_CONTAINER_H
+
+#include "AthenaKernel/CLASS_DEF.h"
+#include "TrackerRawData/TrackerRawDataContainer.h"
+#include "TrackerRawData/TrackerRawDataCollection.h"
+#include "TrackerRawData/FaserSCT_RDORawData.h"
+#include "TrackerRawData/FaserSCT_RDO_Collection.h" // Needed to pick up CLID.
+
+typedef TrackerRawDataContainer<TrackerRawDataCollection<FaserSCT_RDORawData> >
+ FaserSCT_RDO_Container;
+
+CLASS_DEF(FaserSCT_RDO_Container,1333462013,1)
+
+typedef EventContainers::IdentifiableCache< TrackerRawDataCollection<FaserSCT_RDORawData> > FaserSCT_RDO_Cache;
+
+CLASS_DEF( FaserSCT_RDO_Cache , 55085602 , 1 )
+
+typedef EventContainers::IIdentifiableCont<TrackerRawDataCollection<FaserSCT_RDORawData>> ISCT_RDO_Container;//Interface only, do not place in storegate
+
+#endif // TRACKERRAWDATA_FASERSCT_RDO_CONTAINER_H
diff --git a/Tracker/TrackerRawEvent/TrackerRawData/TrackerRawData/TrackerRawData.h b/Tracker/TrackerRawEvent/TrackerRawData/TrackerRawData/TrackerRawData.h
new file mode 100644
index 0000000000000000000000000000000000000000..72bd8538ebe9c5e37dc50068e505c79fc3f55321
--- /dev/null
+++ b/Tracker/TrackerRawEvent/TrackerRawData/TrackerRawData/TrackerRawData.h
@@ -0,0 +1,78 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+///////////////////////////////////////////////////////////////////
+// TrackerRawData.h
+// Header file for class TrackerRawData
+///////////////////////////////////////////////////////////////////
+// (c) ATLAS Detector software
+///////////////////////////////////////////////////////////////////
+// Class to handle raw data objects for Pixel and SCT and TRT
+///////////////////////////////////////////////////////////////////
+// Version 1.0 13/08/2002 Veronique Boisvert
+///////////////////////////////////////////////////////////////////
+
+#ifndef TRACKERRAWDATA_TRACKERRAWDATA_H
+#define TRACKERRAWDATA_TRACKERRAWDATA_H
+
+// Base class
+#include "Identifier/Identifiable.h"
+#include "Identifier/Identifier.h"
+class MsgStream;
+
+
+class TrackerRawData : public Identifiable {
+
+ ///////////////////////////////////////////////////////////////////
+ // Public methods:
+ ///////////////////////////////////////////////////////////////////
+public:
+
+ // Constructor with parameters:
+ // offline compact identifier of the readout channel
+ TrackerRawData(const Identifier rdoId, const unsigned int word);
+
+ // Destructor:
+ virtual ~TrackerRawData();
+
+ ///////////////////////////////////////////////////////////////////
+ // Virtual methods:
+ ///////////////////////////////////////////////////////////////////
+
+ virtual Identifier identify() const override final;
+
+
+ virtual unsigned int getWord() const;
+
+ ///////////////////////////////////////////////////////////////////
+ // Clients should not use default constructor, rather use the one
+ // above. It must be public for pool I/O.
+ ///////////////////////////////////////////////////////////////////
+ TrackerRawData();
+
+ // OR the data word from OTHER into our data word.
+ void merge (const TrackerRawData& other);
+
+ ///////////////////////////////////////////////////////////////////
+ // Private data:
+ ///////////////////////////////////////////////////////////////////
+private:
+ Identifier m_rdoId; //Offline ID for readout channel
+
+protected:
+ unsigned int m_word; // raw data word
+};
+
+/**Overload of << operator for MsgStream for debug output*/
+MsgStream& operator << ( MsgStream& sl, const TrackerRawData& rdo);
+
+/**Overload of << operator for std::ostream for debug output*/
+std::ostream& operator << ( std::ostream& sl, const TrackerRawData& rdo);
+
+///////////////////////////////////////////////////////////////////
+// Inline methods:
+///////////////////////////////////////////////////////////////////
+
+#endif // TRACKERRAWDATA_TRACKERRAWDATA_H
+
diff --git a/Tracker/TrackerRawEvent/TrackerRawData/TrackerRawData/TrackerRawDataCLASS_DEF.h b/Tracker/TrackerRawEvent/TrackerRawData/TrackerRawData/TrackerRawDataCLASS_DEF.h
new file mode 100644
index 0000000000000000000000000000000000000000..62f3705dad2775aadd64326145688505a12811d0
--- /dev/null
+++ b/Tracker/TrackerRawEvent/TrackerRawData/TrackerRawData/TrackerRawDataCLASS_DEF.h
@@ -0,0 +1,34 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+///////////////////////////////////////////////////////////////////
+// TrackerRawDataCLASS_DEF.h
+// Header file for class TrackerRawDataCLASS_DEF
+///////////////////////////////////////////////////////////////////
+// (c) ATLAS Detector software
+///////////////////////////////////////////////////////////////////
+// Class to contain all the CLASS_DEF for Containers and Collections
+///////////////////////////////////////////////////////////////////
+// Version 1.0 25/09/2002 Veronique Boisvert
+///////////////////////////////////////////////////////////////////
+
+#ifndef TRACKERRAWDATA_TRACKERRAWDATACLASS_DEF_H
+#define TRACKERRAWDATA_TRACKERRAWDATACLASS_DEF_H
+
+// Include all headers here - just the containers and collections are
+// enough
+#include "TrackerRawData/FaserSCT_RDO_Container.h"
+
+#include "TrackerRawData/FaserSCT_RDO_Collection.h"
+
+namespace {
+ // Need this to read old data to create the dict entries
+ DataVector<TrackerRawDataCollection<FaserSCT1_RawData> > type2;
+ DataVector<FaserSCT1_RawData> type4;
+ TrackerRawDataCollection< FaserSCT1_RawData > type6;
+ TrackerRawDataCollection< FaserSCT_RDORawData > type7;
+}
+
+
+#endif // TRACKERRAWDATA_TRACKERRAWDATACLASS_DEF_H
diff --git a/Tracker/TrackerRawEvent/TrackerRawData/TrackerRawData/TrackerRawDataCollection.h b/Tracker/TrackerRawEvent/TrackerRawData/TrackerRawData/TrackerRawDataCollection.h
new file mode 100644
index 0000000000000000000000000000000000000000..b91c80a0e87eeaffee425689bdc286643c9200c9
--- /dev/null
+++ b/Tracker/TrackerRawEvent/TrackerRawData/TrackerRawData/TrackerRawDataCollection.h
@@ -0,0 +1,91 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+///////////////////////////////////////////////////////////////////
+// TrackerRawDataCollection.h
+// Header file for class TrackerRawDataCollection
+///////////////////////////////////////////////////////////////////
+// (c) ATLAS Detector software
+///////////////////////////////////////////////////////////////////
+// Class to contain all the RawDataObject of a detector element:
+// wafer for SCT
+///////////////////////////////////////////////////////////////////
+// Version 1.0 13/08/2002 Veronique Boisvert
+///////////////////////////////////////////////////////////////////
+
+#ifndef TRACKERRAWDATA_TRACKERRAWDATACOLLECTION_H
+#define TRACKERRAWDATA_TRACKERRAWDATACOLLECTION_H
+
+// Base classes
+#include "Identifier/Identifiable.h"
+#include "Identifier/Identifier.h"
+#include "Identifier/IdentifierHash.h"
+#include "AthContainers/DataVector.h"
+
+
+// Needed class
+#include "TrackerRawData/TrackerRawData.h"
+
+template< class RawDataT >
+class TrackerRawDataCollection : public Identifiable, public DataVector< RawDataT > {
+
+ ///////////////////////////////////////////////////////////////////
+ // Public methods:
+ ///////////////////////////////////////////////////////////////////
+public:
+
+ // Constructor with parameters:
+ // Hashed offline identifier of the DE
+ TrackerRawDataCollection(const IdentifierHash idHash);
+
+ // Destructor:
+ virtual ~TrackerRawDataCollection();
+
+
+ ///////////////////////////////////////////////////////////////////
+ // Const methods:
+ ///////////////////////////////////////////////////////////////////
+
+ virtual Identifier identify() const override final;
+
+ virtual IdentifierHash identifyHash() const override final;
+
+ void setIdentifier(Identifier id);
+
+ ///////////////////////////////////////////////////////////////////
+ // Private methods:
+ ///////////////////////////////////////////////////////////////////
+private:
+
+ TrackerRawDataCollection(const TrackerRawDataCollection&);
+ TrackerRawDataCollection &operator=(const TrackerRawDataCollection&);
+
+public:
+ // public default constructor needed for I/O, but should not be
+ // called from an alg
+ TrackerRawDataCollection();
+
+ ///////////////////////////////////////////////////////////////////
+ // Private data:
+ ///////////////////////////////////////////////////////////////////
+private:
+ const IdentifierHash m_idHash;
+ Identifier m_id; // identifier of the DE
+};
+
+/**Overload of << operator for MsgStream for debug output*/
+template< class RawDataT >
+MsgStream& operator << ( MsgStream& sl, const TrackerRawDataCollection< RawDataT >& coll);
+
+/**Overload of << operator for std::ostream for debug output*/
+template< class RawDataT >
+std::ostream& operator << ( std::ostream& sl, const TrackerRawDataCollection< RawDataT >& coll);
+
+// member functions that use Collection T
+#include"TrackerRawData/TrackerRawDataCollection.icc"
+///////////////////////////////////////////////////////////////////
+// Inline methods:
+///////////////////////////////////////////////////////////////////
+
+#endif // TRACKERRAWDATA_TRACKERRAWDATACOLLECTION_H
diff --git a/Tracker/TrackerRawEvent/TrackerRawData/TrackerRawData/TrackerRawDataCollection.icc b/Tracker/TrackerRawEvent/TrackerRawData/TrackerRawData/TrackerRawDataCollection.icc
new file mode 100644
index 0000000000000000000000000000000000000000..3817599d96c32d6c8c7a23a823269480b91462ca
--- /dev/null
+++ b/Tracker/TrackerRawEvent/TrackerRawData/TrackerRawData/TrackerRawDataCollection.icc
@@ -0,0 +1,75 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+///////////////////////////////////////////////////////////////////
+// TrackerRawDataCollection.icc
+// Implementation file for class TrackerRawDataCollection
+///////////////////////////////////////////////////////////////////
+// (c) ATLAS Detector software
+///////////////////////////////////////////////////////////////////
+// Version 1.0 13/08/2002 Veronique Boisvert
+///////////////////////////////////////////////////////////////////
+
+//#include "TrackerRawData/TrackerRawDataCollection.h"
+
+template< class RawDataT >
+// Constructor with parameters:
+TrackerRawDataCollection< RawDataT >::TrackerRawDataCollection(const
+ IdentifierHash idHash) :
+ m_idHash(idHash),
+ m_id()
+{}
+
+template< class RawDataT >
+// Constructor with parameters:
+TrackerRawDataCollection< RawDataT >::TrackerRawDataCollection()
+{}
+
+// Destructor:
+template< class RawDataT >
+TrackerRawDataCollection< RawDataT >::~TrackerRawDataCollection()
+{ }
+
+template< class RawDataT >
+Identifier TrackerRawDataCollection< RawDataT >::identify() const
+{
+ return m_id;
+}
+
+template< class RawDataT >
+IdentifierHash TrackerRawDataCollection< RawDataT >::identifyHash() const
+{
+ return m_idHash;
+}
+
+template< class RawDataT >
+void TrackerRawDataCollection< RawDataT >::setIdentifier(Identifier id)
+{
+ m_id = id;
+}
+
+
+template< class RawDataT >
+MsgStream& operator << ( MsgStream& sl, const TrackerRawDataCollection< RawDataT >& coll){
+ sl << "TrackerRawDataCollection "
+ << "identify()="<< coll.identify()
+ << ", RDO=[";
+ typename TrackerRawDataCollection< RawDataT >::const_iterator it = coll.begin();
+ typename TrackerRawDataCollection< RawDataT >::const_iterator itEnd = coll.end();
+ for (;it!=itEnd;++it) sl<< (**it)<<", ";
+ sl <<" ]"<<std::endl;
+ return sl;
+}
+
+template< class RawDataT >
+std::ostream& operator << ( std::ostream& sl, const TrackerRawDataCollection< RawDataT >& coll) {
+ sl << "TrackerRawDataCollection "
+ << "identify()="<< coll.identify()
+ << ", RDO=[";
+ typename TrackerRawDataCollection< RawDataT >::const_iterator it = coll.begin();
+ typename TrackerRawDataCollection< RawDataT >::const_iterator itEnd = coll.end();
+ for (;it!=itEnd;++it) sl<< (**it)<<", ";
+ sl <<" ]"<<std::endl;
+ return sl;
+}
diff --git a/Tracker/TrackerRawEvent/TrackerRawData/TrackerRawData/TrackerRawDataContainer.h b/Tracker/TrackerRawEvent/TrackerRawData/TrackerRawData/TrackerRawDataContainer.h
new file mode 100644
index 0000000000000000000000000000000000000000..6e4de6c49db053aed5cc411c24d44955b417f29b
--- /dev/null
+++ b/Tracker/TrackerRawEvent/TrackerRawData/TrackerRawData/TrackerRawDataContainer.h
@@ -0,0 +1,86 @@
+/*
+ Copyright (C) 2002-2018 CERN for the benefit of the ATLAS collaboration
+*/
+
+///////////////////////////////////////////////////////////////////
+// TrackerRawDataContainer.h
+// Header file for class TrackerRawDataContainer
+///////////////////////////////////////////////////////////////////
+// (c) ATLAS Detector software
+///////////////////////////////////////////////////////////////////
+// Container for Raw Data Objects collections for Pixel, SCT and TRT
+///////////////////////////////////////////////////////////////////
+// Version 1.0 13/08/2002 Veronique Boisvert
+///////////////////////////////////////////////////////////////////
+
+#ifndef TRACKERRAWDATA_TRACKERRAWDATACONTAINER_H
+#define TRACKERRAWDATA_TRACKERRAWDATACONTAINER_H
+
+// Base classes
+#include "EventContainers/IdentifiableContainer.h"
+//Needed Classes
+#include "TrackerRawData/TrackerRawDataCollection.h"
+#include "AthenaKernel/CLASS_DEF.h"
+
+template<class CollectionT>
+class TrackerRawDataContainer
+: public IdentifiableContainer<CollectionT>{
+
+ ///////////////////////////////////////////////////////////////////
+ // Public methods:
+ ///////////////////////////////////////////////////////////////////
+public:
+
+ // Constructor with parameters:
+ TrackerRawDataContainer(unsigned int max);
+
+ TrackerRawDataContainer(EventContainers::IdentifiableCache<CollectionT>*);
+
+ // Destructor:
+ virtual ~TrackerRawDataContainer();
+
+ /** return class ID */
+ static const CLID& classID()
+ {
+ return ClassID_traits< TrackerRawDataContainer <CollectionT> > ::ID();
+ }
+
+ /** return class ID */
+ virtual const CLID& clID() const
+ {
+ return classID();
+ }
+
+
+ ///////////////////////////////////////////////////////////////////
+ // Const methods:
+ ///////////////////////////////////////////////////////////////////
+
+
+ ///////////////////////////////////////////////////////////////////
+ // Non-const methods:
+ ///////////////////////////////////////////////////////////////////
+
+
+
+ ///////////////////////////////////////////////////////////////////
+ // Private methods:
+ ///////////////////////////////////////////////////////////////////
+private:
+
+ TrackerRawDataContainer(const TrackerRawDataContainer&);
+ TrackerRawDataContainer &operator=(const TrackerRawDataContainer&);
+
+ ///////////////////////////////////////////////////////////////////
+ // Private data:
+ ///////////////////////////////////////////////////////////////////
+private:
+
+};
+// member functions that use Collection T
+#include"TrackerRawData/TrackerRawDataContainer.icc"
+///////////////////////////////////////////////////////////////////
+// Inline methods:
+///////////////////////////////////////////////////////////////////
+
+#endif // TRACKERRAWDATA_TRACKERRAWDATACONTAINER_H
diff --git a/Tracker/TrackerRawEvent/TrackerRawData/TrackerRawData/TrackerRawDataContainer.icc b/Tracker/TrackerRawEvent/TrackerRawData/TrackerRawData/TrackerRawDataContainer.icc
new file mode 100644
index 0000000000000000000000000000000000000000..854e8d225c68892ee62bd3c3f150cd1307c62484
--- /dev/null
+++ b/Tracker/TrackerRawEvent/TrackerRawData/TrackerRawData/TrackerRawDataContainer.icc
@@ -0,0 +1,35 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+///////////////////////////////////////////////////////////////////
+// TrackerRawDataContainer.icc
+// Implementation file for class TrackerRawDataContainer
+///////////////////////////////////////////////////////////////////
+// (c) ATLAS Detector software
+///////////////////////////////////////////////////////////////////
+// Version 1.0 13/08/2002 Veronique Boisvert
+///////////////////////////////////////////////////////////////////
+
+//#include "TrackerRawData/TrackerRawDataContainer.h"
+
+template< class CollectionT>
+// Constructor with parameters:
+TrackerRawDataContainer< CollectionT>::TrackerRawDataContainer(unsigned int max) :
+ IdentifiableContainer<CollectionT>(max)
+{
+}
+
+template< class CollectionT>
+TrackerRawDataContainer< CollectionT>::TrackerRawDataContainer(EventContainers::IdentifiableCache<CollectionT> *cache) :
+ IdentifiableContainer<CollectionT>(cache)
+{
+}
+
+
+template< class CollectionT>
+// Destructor:
+TrackerRawDataContainer< CollectionT>::~TrackerRawDataContainer()
+{
+}
+
diff --git a/Tracker/TrackerRawEvent/TrackerRawData/TrackerRawData/selection.xml b/Tracker/TrackerRawEvent/TrackerRawData/TrackerRawData/selection.xml
new file mode 100644
index 0000000000000000000000000000000000000000..2d916304fa66d2362792651bd68ef94c40c40760
--- /dev/null
+++ b/Tracker/TrackerRawEvent/TrackerRawData/TrackerRawData/selection.xml
@@ -0,0 +1,31 @@
+<lcgdict>
+ <class name="TrackerRawData" />
+ <class name="FaserSCT1_RawData" />
+ <class name="FaserSCT_RDORawData" />
+
+ <class name="DataVector<FaserSCT1_RawData>" />
+ <class name="std::vector<FaserSCT1_RawData*>" />
+ <class name="std::vector<FaserSCT_RDORawData*>" />
+
+ <class name="IdentifiableContainer<TrackerRawDataCollection<FaserSCT_RDORawData> >" />
+
+ <class name="DataLinkVector<TrackerRawDataCollection<FaserSCT_RDORawData> >" >
+ <field name="m_last" transient="true" />
+ <field name="m_vect" transient="true" />
+ </class>
+
+ <class name="TrackerRawDataCollection< FaserSCT1_RawData >" />
+ <class name="TrackerRawDataCollection< FaserSCT_RDORawData >" />
+
+
+ <class name="TrackerRawDataContainer<TrackerRawDataCollection<FaserSCT_RDORawData> >" />
+
+
+ <!-- Need this to read old data -->
+ <class name="std::vector<TrackerRawDataCollection< FaserSCT1_RawData >* >" />
+ <!-- <class name="DataVector<InDetRawDataCollection< SCT1_RawData > >" id="B82A1D11-3F86-4F07-B380-B61BA2DAF3A9" /> -->
+ <class name="DataVector<TrackerRawDataCollection< FaserSCT1_RawData > >" id="F884804E-E87B-42BE-9DD0-1571A1508F25" />
+
+
+</lcgdict>
+
diff --git a/Tracker/TrackerRawEvent/TrackerRawData/src/FaserSCT1_RawData.cxx b/Tracker/TrackerRawEvent/TrackerRawData/src/FaserSCT1_RawData.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..48b44745808254fadb7d64a7f9a83b1f7875d667
--- /dev/null
+++ b/Tracker/TrackerRawEvent/TrackerRawData/src/FaserSCT1_RawData.cxx
@@ -0,0 +1,42 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+///////////////////////////////////////////////////////////////////
+// FaserSCT1_RawData.cxx
+// Implementation file for class FaserSCT1_RawData
+///////////////////////////////////////////////////////////////////
+// (c) ATLAS Detector software
+///////////////////////////////////////////////////////////////////
+// Version 1.0 13/08/2002 Veronique Boisvert
+///////////////////////////////////////////////////////////////////
+
+#include <new>
+#include "TrackerRawData/FaserSCT1_RawData.h"
+#include "TrackerRawData/FaserSCT_RDORawData.h"
+
+// default constructor
+FaserSCT1_RawData::FaserSCT1_RawData() :
+ FaserSCT_RDORawData(Identifier(), 0) //call base-class constructor
+{}
+
+// Constructor with parameters:
+FaserSCT1_RawData::FaserSCT1_RawData(const Identifier rdoId,
+ const unsigned int word) :
+ FaserSCT_RDORawData( rdoId, word) //call base-class constructor
+{}
+
+
+//SCT1_RawData *SCT1_RawData::newObject(const Identifier rdoId, const unsigned int word)
+//{
+// SCT1_RawData *p_rdo=0;
+
+ // create a new object and check
+// try {
+// p_rdo=new SCT1_RawData(rdoId, word);
+// } catch (...) {
+// p_rdo=0;
+// }
+// return p_rdo;
+//}
+
diff --git a/Tracker/TrackerRawEvent/TrackerRawData/src/FaserSCT3_RawData.cxx b/Tracker/TrackerRawEvent/TrackerRawData/src/FaserSCT3_RawData.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..8e36302af5a4834f27482a117511712ea741ba26
--- /dev/null
+++ b/Tracker/TrackerRawEvent/TrackerRawData/src/FaserSCT3_RawData.cxx
@@ -0,0 +1,36 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+///////////////////////////////////////////////////////////////////
+// FaserSCT3_RawData.cxx
+// Implementation file for class FaserSCT3_RawData
+///////////////////////////////////////////////////////////////////
+// (c) ATLAS Detector software
+///////////////////////////////////////////////////////////////////
+// Version 1.0 11/12/2004 MJ Costa
+///////////////////////////////////////////////////////////////////
+
+#include <new>
+#include "TrackerRawData/FaserSCT3_RawData.h"
+#include "TrackerRawData/FaserSCT_RDORawData.h"
+
+// default constructor
+FaserSCT3_RawData::FaserSCT3_RawData() :
+ FaserSCT_RDORawData(Identifier(), 0) //call base-class constructor
+{}
+
+// Constructor with parameters:
+FaserSCT3_RawData::FaserSCT3_RawData(const Identifier rdoId, const unsigned int word, const std::vector<int>* errorhit) :
+ FaserSCT_RDORawData( rdoId, word), //call base-class constructor
+ m_errorCondensedHit (*errorhit)
+{
+}
+
+FaserSCT3_RawData::FaserSCT3_RawData(const Identifier rdoId,
+ const unsigned int word,
+ std::vector<int>&& errorhit)
+ : FaserSCT_RDORawData( rdoId, word),
+ m_errorCondensedHit (std::move(errorhit))
+{
+}
diff --git a/Tracker/TrackerRawEvent/TrackerRawData/src/FaserSCT_RDOCollection.cxx b/Tracker/TrackerRawEvent/TrackerRawData/src/FaserSCT_RDOCollection.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..e9d6dc36d4d1b360cc83e1e5d80630896f98f364
--- /dev/null
+++ b/Tracker/TrackerRawEvent/TrackerRawData/src/FaserSCT_RDOCollection.cxx
@@ -0,0 +1,32 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#include "TrackerRawData/FaserSCT_RDO_Collection.h"
+#include "GaudiKernel/MsgStream.h"
+
+MsgStream& operator << ( MsgStream& sl, const FaserSCT_RDO_Collection& coll)
+{
+ sl << "FaserSCT_RDO_Collection: "
+ << "identify()="<< coll.identify()
+ // << ", identifyHash()="<< coll.identifyHash()
+ << ", RDO=[";
+ FaserSCT_RDO_Collection::const_iterator it = coll.begin();
+ FaserSCT_RDO_Collection::const_iterator itEnd = coll.end();
+ for (;it!=itEnd;++it) sl<< (**it)<<", ";
+ sl <<" ]"<<std::endl;
+ return sl;
+}
+
+std::ostream& operator << ( std::ostream& sl, const FaserSCT_RDO_Collection& coll)
+{
+ sl << "FaserSCT_RDO_Collection: "
+ << "identify()="<< coll.identify()
+ // << ", identifyHash()="<< coll.identifyHash()
+ << ", RDO=[";
+ FaserSCT_RDO_Collection::const_iterator it = coll.begin();
+ FaserSCT_RDO_Collection::const_iterator itEnd = coll.end();
+ for (;it!=itEnd;++it) sl<< (**it)<<", ";
+ sl <<" ]"<<std::endl;
+ return sl;
+}
diff --git a/Tracker/TrackerRawEvent/TrackerRawData/src/FaserSCT_RDORawData.cxx b/Tracker/TrackerRawEvent/TrackerRawData/src/FaserSCT_RDORawData.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..8f91e6d665bbc6e8f95aa978359cf3e50e6283df
--- /dev/null
+++ b/Tracker/TrackerRawEvent/TrackerRawData/src/FaserSCT_RDORawData.cxx
@@ -0,0 +1,22 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+///////////////////////////////////////////////////////////////////
+// FaserSCT_RDORawData.cxx
+// Implementation file for class FaserSCT_RDORawData
+///////////////////////////////////////////////////////////////////
+// (c) ATLAS Detector software
+///////////////////////////////////////////////////////////////////
+// Version 1.0 13/08/2002 Veronique Boisvert
+///////////////////////////////////////////////////////////////////
+
+#include <new>
+#include "TrackerRawData/FaserSCT_RDORawData.h"
+#include "TrackerRawData/TrackerRawData.h"
+
+// Constructor with parameters:
+FaserSCT_RDORawData::FaserSCT_RDORawData(const Identifier rdoId,
+ const unsigned int word) :
+ TrackerRawData(rdoId, word) //call base class constructor
+{}
diff --git a/Tracker/TrackerRawEvent/TrackerRawData/src/TrackerRawData.cxx b/Tracker/TrackerRawEvent/TrackerRawData/src/TrackerRawData.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..e5b28dd45e54af5427d49cf42feee2cd8250939f
--- /dev/null
+++ b/Tracker/TrackerRawEvent/TrackerRawData/src/TrackerRawData.cxx
@@ -0,0 +1,61 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+///////////////////////////////////////////////////////////////////
+// TrackerRawData.cxx
+// Implementation file for class TrackerRawData
+///////////////////////////////////////////////////////////////////
+// (c) ATLAS Detector software
+///////////////////////////////////////////////////////////////////
+// Version 1.0 13/08/2002 Veronique Boisvert
+///////////////////////////////////////////////////////////////////
+
+#include "TrackerRawData/TrackerRawData.h"
+#include "GaudiKernel/MsgStream.h"
+
+TrackerRawData::TrackerRawData():
+ m_word(0)
+{}
+
+// Constructor with parameters:
+TrackerRawData::TrackerRawData(const Identifier rdoId, const unsigned int word) :
+ Identifiable(),
+ m_rdoId(rdoId),
+ m_word(word)
+{
+
+}
+
+// Destructor:
+TrackerRawData::~TrackerRawData()
+{
+
+}
+
+Identifier TrackerRawData::identify() const
+{
+ return m_rdoId;
+
+}
+unsigned int TrackerRawData::getWord() const
+{
+ return m_word;
+}
+
+
+void TrackerRawData::merge (const TrackerRawData& other)
+{
+ m_word |= other.m_word;
+}
+
+
+MsgStream& operator << ( MsgStream& sl, const TrackerRawData& rdo) {
+ sl << " Identifier " << rdo.identify() << " word " << rdo.getWord();
+ return sl;
+}
+
+std::ostream& operator << ( std::ostream& sl, const TrackerRawData& rdo) {
+ sl << " Identifier " << rdo.identify() << " word " << rdo.getWord();
+ return sl;
+}
diff --git a/Tracker/TrackerRawEvent/TrackerSimData/CMakeLists.txt b/Tracker/TrackerRawEvent/TrackerSimData/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..ab5d15204b8cc0a7595f72bd38e2f998805b3ccc
--- /dev/null
+++ b/Tracker/TrackerRawEvent/TrackerSimData/CMakeLists.txt
@@ -0,0 +1,31 @@
+################################################################################
+# Package: TrackerSimData
+################################################################################
+
+# Declare the package name:
+atlas_subdir( TrackerSimData )
+
+# Declare the package's dependencies:
+atlas_depends_on_subdirs( PUBLIC
+ Control/AthenaKernel
+ DetectorDescription/Identifier
+ Generators/GeneratorObjects )
+
+# External dependencies:
+find_package( ROOT COMPONENTS Core Tree MathCore Hist RIO pthread )
+
+# Component(s) in the package:
+atlas_add_library( TrackerSimData
+ src/TrackerSimData.cxx
+ src/TrackerSimDataCollection.cxx
+ PUBLIC_HEADERS TrackerSimData
+ PRIVATE_INCLUDE_DIRS ${ROOT_INCLUDE_DIRS}
+ LINK_LIBRARIES AthenaKernel Identifier GeneratorObjects
+ PRIVATE_LINK_LIBRARIES ${ROOT_LIBRARIES} )
+
+atlas_add_dictionary( TrackerSimDataDict
+ TrackerSimData/TrackerSimDataDict.h
+ TrackerSimData/selection.xml
+ INCLUDE_DIRS ${ROOT_INCLUDE_DIRS}
+ LINK_LIBRARIES ${ROOT_LIBRARIES} Identifier GeneratorObjects TrackerSimData )
+
diff --git a/Tracker/TrackerRawEvent/TrackerSimData/TrackerSimData/ATLAS_CHECK_THREAD_SAFETY b/Tracker/TrackerRawEvent/TrackerSimData/TrackerSimData/ATLAS_CHECK_THREAD_SAFETY
new file mode 100644
index 0000000000000000000000000000000000000000..816784b63ba661959336be7fa0013dde12d734a7
--- /dev/null
+++ b/Tracker/TrackerRawEvent/TrackerSimData/TrackerSimData/ATLAS_CHECK_THREAD_SAFETY
@@ -0,0 +1 @@
+Tracker/TrackerRawEvent/TrackerSimData
\ No newline at end of file
diff --git a/Tracker/TrackerRawEvent/TrackerSimData/TrackerSimData/FaserSCT_SimHelper.h b/Tracker/TrackerRawEvent/TrackerSimData/TrackerSimData/FaserSCT_SimHelper.h
new file mode 100644
index 0000000000000000000000000000000000000000..ea21fba69c891ac4256481a4b6d8665d7cfbb9e1
--- /dev/null
+++ b/Tracker/TrackerRawEvent/TrackerSimData/TrackerSimData/FaserSCT_SimHelper.h
@@ -0,0 +1,132 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+/***************************************************************************
+ TrackerSimData helper for SCT
+ This is based on the G3/RD-event. The digitization packages may permit or
+ require more possibilities
+ ------------------------------
+ ATLAS Collaboration
+ ***************************************************************************/
+
+// $Id: FaserSCT_SimHelper.h,v 1.2 2003-02-21 09:59:12 schaffer Exp $
+
+#ifndef TRACKERSIMDATA_FASERSCT_SIMHELPER_H
+#define TRACKERSIMDATA_FASERSCT_SIMHELPER_H
+
+//<<<<<< INCLUDES >>>>>>
+#include "TrackerSimData/TrackerSimData.h"
+//<<<<<< PUBLIC DEFINES >>>>>>
+//<<<<<< PUBLIC CONSTANTS >>>>>>
+//<<<<<< PUBLIC TYPES >>>>>>
+//<<<<<< PUBLIC VARIABLES >>>>>>
+//<<<<<< PUBLIC FUNCTIONS >>>>>>
+//<<<<<< CLASS DECLARATIONS >>>>>>
+
+class FaserSCT_SimHelper
+{
+public:
+ // methods to set characteristics of a new object
+ static void noise(TrackerSimData& sdo, bool flag);
+ static void belowThreshold(TrackerSimData& sdo, bool flag);
+ static void disabled(TrackerSimData& sdo, bool flag);
+
+ // methods for clients
+ static bool isNoise(const TrackerSimData& sdo);
+ static bool isBelowThreshold(const TrackerSimData& sdo);
+ static bool isDisabled(const TrackerSimData& sdo);
+ static bool isRejected(const TrackerSimData& sdo,
+ bool rejectOutOfBunch,
+ bool rejectUnconnected,
+ bool rejectBelowThreshold,
+ bool rejectDisabled,
+ bool rejectLostInReadout,
+ bool rejectNotTrack,
+ bool rejectExtraNoise);
+
+private:
+ enum
+ {
+ NOISE_SET = 0x1, NOISE_CLEAR = 0xfffffffe,
+ BT_SET = 0x2, BT_CLEAR = 0xfffffffd,
+ DISABLED_SET = 0x4, DISABLED_CLEAR = 0xfffffffb
+ };
+};
+
+inline void FaserSCT_SimHelper::noise(TrackerSimData& sdo, bool flag)
+{
+ if (flag)
+ {
+ sdo.m_word |= NOISE_SET;
+ }
+ else
+ {
+ sdo.m_word &= NOISE_CLEAR;
+ };
+}
+
+inline void FaserSCT_SimHelper::belowThreshold(TrackerSimData& sdo, bool flag)
+{
+ if (flag)
+ {
+ sdo.m_word |= BT_SET;
+ }
+ else
+ {
+ sdo.m_word &= BT_CLEAR;
+ };
+}
+
+inline void FaserSCT_SimHelper::disabled(TrackerSimData& sdo, bool flag)
+{
+ if (flag)
+ {
+ sdo.m_word |= DISABLED_SET;
+ }
+ else
+ {
+ sdo.m_word &= DISABLED_CLEAR;
+ };
+}
+
+inline bool FaserSCT_SimHelper::isNoise(const TrackerSimData& sdo)
+{
+ return (sdo.m_word&NOISE_SET) != 0;
+}
+
+inline bool FaserSCT_SimHelper::isBelowThreshold(const TrackerSimData& sdo)
+{
+ return (sdo.m_word&BT_SET) != 0;
+}
+
+inline bool FaserSCT_SimHelper::isDisabled(const TrackerSimData& sdo)
+{
+ return (sdo.m_word&DISABLED_SET) != 0;
+}
+
+inline bool FaserSCT_SimHelper::isRejected(const TrackerSimData& sdo,
+ bool /*rejectOutOfBunch*/,
+ bool /*rejectUnconnected*/,
+ bool rejectBelowThreshold,
+ bool rejectDisabled,
+ bool /*rejectLostInReadout*/,
+ bool /*rejectNotTrack*/,
+ bool rejectExtraNoise)
+{
+ // rejectOutOfBunch not implemented
+ // rejectUnconnected not implemented
+ if (rejectBelowThreshold && isBelowThreshold(sdo) && !isNoise(sdo))
+ return true; // as in previous SCT_DigitTDR_Cnv
+ if (rejectDisabled && isDisabled(sdo)) return true;
+ // rejectLostInReadout not implemented
+ // rejectNotTrack not implemented
+ if (rejectExtraNoise && isNoise(sdo) && isBelowThreshold(sdo))
+ return true;
+ return false;
+}
+
+//<<<<<< INLINE PUBLIC FUNCTIONS >>>>>>
+//<<<<<< INLINE MEMBER FUNCTIONS >>>>>>
+
+#endif // TRACKERSIMDATA_FASERSCT_SIMHELPER_H
diff --git a/Tracker/TrackerRawEvent/TrackerSimData/TrackerSimData/TrackerSimData.h b/Tracker/TrackerRawEvent/TrackerSimData/TrackerSimData/TrackerSimData.h
new file mode 100644
index 0000000000000000000000000000000000000000..debb638bbffa1b591a399a6b85542be7c910fef5
--- /dev/null
+++ b/Tracker/TrackerRawEvent/TrackerSimData/TrackerSimData/TrackerSimData.h
@@ -0,0 +1,80 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+/***************************************************************************
+ Simulation data object associated with an TrackerRawData object
+ ------------------------------------------------------
+ ATLAS Collaboration
+ ***************************************************************************
+ An object of this class stores the simulation information associated with
+ a RawData object, in two data members.
+
+ One is an integer, the "simulation data word", in which is packed
+ information summarizing the digitization. Its interpretation may depend on
+ which of the three subdetectors is concerned, but will typically contain
+ bit-flags for "noise", "lost in readout", etc.
+
+ The other consists of a number (normally only one) of pair<int, float>
+ specifying the barcode and energy (charge) deposited by a charged particle,
+ or rather that part of the charge attributed to the corresponding RDO.
+ Encoding and decoding methods will be supplied outside this class.
+
+ The implementation emphasizes compactness in memory, at the expense of speed,
+ because objects of this class will be persistent, but will not be accessed
+ in real production running.
+
+ ***************************************************************************/
+
+// $Id: TrackerSimData.h,v 1.15 2004-07-08 20:57:03 costanzo Exp $
+
+#ifndef TRACKERSIMDATA_TrackerSimData_H
+#define TRACKERSIMDATA_TrackerSimData_H
+
+#include <utility>
+#include <vector>
+#include "GeneratorObjects/HepMcParticleLink.h"
+
+
+class TrackerSimData
+{
+ friend class FaserSCT_SimHelper;
+
+public:
+ typedef std::pair<HepMcParticleLink, float> Deposit; // A particle link, and the
+ // energy (charge) which its hits contribute to the current RDO.
+ TrackerSimData();
+ TrackerSimData (const std::vector< Deposit >& deposits, int simDataWord = 0);
+ TrackerSimData (std::vector< Deposit >&& deposits, int simDataWord = 0);
+ TrackerSimData (const TrackerSimData& other);
+ TrackerSimData &operator=(const TrackerSimData& other);
+ TrackerSimData &operator=(TrackerSimData&& other);
+ virtual ~TrackerSimData();
+ int word() const; // Get the packed simdata word
+ void deposits(std::vector<Deposit>& deposits) const; // Get the Deposits
+ const std::vector< Deposit >& getdeposits() const;
+
+private:
+ int m_word;
+ // Deposit* m_p_deposits; but use vector meantime, needs more work
+ std::vector<Deposit> m_deposits;
+};
+
+inline int TrackerSimData::word() const
+{
+ return m_word & 0x1fffffff;
+}
+
+inline const std::vector< TrackerSimData::Deposit >& TrackerSimData::getdeposits() const
+{
+ return m_deposits;
+}
+
+inline void TrackerSimData::deposits(std::vector< TrackerSimData::Deposit>& deposits) const
+{
+ // I really don't understand what the point of this is ... it does EXACTLY the same as the getdeposits() method, just in a different way. EJWM
+ deposits = m_deposits;
+ return;
+}
+
+#endif // TRACKERSIMDATA_TrackerSimData_H
diff --git a/Tracker/TrackerRawEvent/TrackerSimData/TrackerSimData/TrackerSimDataCollection.h b/Tracker/TrackerRawEvent/TrackerSimData/TrackerSimData/TrackerSimDataCollection.h
new file mode 100644
index 0000000000000000000000000000000000000000..c9fc014948540ee1b641a9b229a55146daeec793
--- /dev/null
+++ b/Tracker/TrackerRawEvent/TrackerSimData/TrackerSimData/TrackerSimDataCollection.h
@@ -0,0 +1,40 @@
+/*
+ Copyright (C) 2002-2018 CERN for the benefit of the ATLAS collaboration
+*/
+
+/***************************************************************************
+ CLASS_DEF for TrackerSimData map
+ ------------------------------
+ ATLAS Collaboration
+ ***************************************************************************/
+
+// $Id: TrackerSimDataCollection.h,v 1.3 2004-04-05 23:16:07 costanzo Exp $
+
+#ifndef TRACKERSIMDATA_TRACKERSIMDATACOLLECTION_H
+# define TRACKERSIMDATA_TRACKERSIMDATACOLLECTION_H
+
+//<<<<<< INCLUDES >>>>>>
+#include "AthenaKernel/CLASS_DEF.h"
+#include "TrackerSimData/TrackerSimData.h"
+#include "Identifier/Identifier.h"
+#include <map>
+
+//<<<<<< PUBLIC DEFINES >>>>>>
+//<<<<<< PUBLIC CONSTANTS >>>>>>
+//<<<<<< PUBLIC TYPES >>>>>>
+//<<<<<< PUBLIC VARIABLES >>>>>>
+//<<<<<< PUBLIC FUNCTIONS >>>>>>
+//<<<<<< CLASS DECLARATIONS >>>>>>
+
+class TrackerSimDataCollection : public std::map<Identifier,TrackerSimData> {
+ public:
+ TrackerSimDataCollection();
+ virtual ~TrackerSimDataCollection();
+};
+CLASS_DEF(TrackerSimDataCollection, 1180099465, 1)
+
+
+//<<<<<< INLINE PUBLIC FUNCTIONS >>>>>>
+//<<<<<< INLINE MEMBER FUNCTIONS >>>>>>
+
+#endif // TRACKERSIMDATA_TRACKERSIMDATACOLLECTION_H
\ No newline at end of file
diff --git a/Tracker/TrackerRawEvent/TrackerSimData/TrackerSimData/TrackerSimDataDict.h b/Tracker/TrackerRawEvent/TrackerSimData/TrackerSimData/TrackerSimDataDict.h
new file mode 100644
index 0000000000000000000000000000000000000000..e15bd3b87104c1ee563a2b5e78779947e4ebc26a
--- /dev/null
+++ b/Tracker/TrackerRawEvent/TrackerSimData/TrackerSimData/TrackerSimDataDict.h
@@ -0,0 +1,16 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef TRACKERSIMEVENT_TRACKERSIMDATADICT_H
+#define TRACKERSIMEVENT_TRACKERSIMDATADICT_H
+
+#include "TrackerSimData/TrackerSimDataCollection.h"
+
+namespace AthenaPoolTestDataDict
+{
+ std::pair< HepMcParticleLink , float> d_pair;
+}
+
+
+#endif
diff --git a/Tracker/TrackerRawEvent/TrackerSimData/TrackerSimData/selection.xml b/Tracker/TrackerRawEvent/TrackerSimData/TrackerSimData/selection.xml
new file mode 100644
index 0000000000000000000000000000000000000000..b720847392c8d30fbf01f4befceb0f20ef8e629f
--- /dev/null
+++ b/Tracker/TrackerRawEvent/TrackerSimData/TrackerSimData/selection.xml
@@ -0,0 +1,10 @@
+<lcgdict>
+ <!--<class name="TrackerSimDataCollection" id="5A50C32E-C036-4A49-AE97-716D53210BE1" /> -->
+ <class name="TrackerSimDataCollection" id="DF5775E8-8C33-4B82-8322-58B7671BF678" />
+ <class name="TrackerSimData" />
+ <!-- Duplicated by ATLAS version (InDetSimData) -->
+ <!-- <class pattern="*pair*<HepMcParticleLink*float>" />
+ <class name="std::vector<std::pair< HepMcParticleLink , float> >" /> -->
+ <class name="std::map<Identifier,TrackerSimData>" />
+</lcgdict>
+
diff --git a/Tracker/TrackerRawEvent/TrackerSimData/src/TrackerSimData.cxx b/Tracker/TrackerRawEvent/TrackerSimData/src/TrackerSimData.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..01321303e95ab0d107c61e03b02265bf70604472
--- /dev/null
+++ b/Tracker/TrackerRawEvent/TrackerSimData/src/TrackerSimData.cxx
@@ -0,0 +1,82 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+/***************************************************************************
+ Simulation data associated with an TrackerRawData object
+ ------------------------------------------------------
+ ATLAS Collaboration
+ ***************************************************************************/
+
+// $Id: TrackerSimData.cxx,v 1.4 2004-03-01 22:07:07 costanzo Exp $
+
+
+#include "TrackerSimData/TrackerSimData.h"
+#include <iostream>
+
+
+
+TrackerSimData::TrackerSimData() :
+ m_word(0)
+{
+
+}
+
+TrackerSimData::TrackerSimData (const std::vector<Deposit>& deposits,
+ int simDataWord)
+ : m_word((deposits.size()<<29 & 0xe0000000) | (simDataWord & 0x1fffffff))
+{
+ //above we pack deposits.size() and the simDataWord into a single unsigned int (m_word).
+ //The first 3 bits are used for deposits.size() and the last 29 are used for the simDataWord.
+
+ /*
+
+ m_p_deposits = new Deposit[deposits.size()];
+
+ for (unsigned int i = 0; i!= deposits.size(); i++)
+ {
+ m_p_deposits[i] = deposits[i];
+ }
+ */
+
+ m_deposits = deposits;
+}
+
+TrackerSimData::TrackerSimData (std::vector<Deposit>&& deposits,
+ int simDataWord)
+ : m_deposits (std::move (deposits))
+{
+ m_word = (m_deposits.size()<<29 & 0xe0000000) | (simDataWord & 0x1fffffff);
+}
+
+TrackerSimData::TrackerSimData (const TrackerSimData& other)
+ :m_word(other.m_word),
+ m_deposits(other.m_deposits)
+{
+
+}
+
+TrackerSimData &TrackerSimData::operator=(const TrackerSimData& other)
+{
+ if(&other != this)
+ {
+ m_word=other.m_word;
+ m_deposits=other.m_deposits;
+ }
+ return *this;
+}
+
+TrackerSimData &TrackerSimData::operator=(TrackerSimData&& other)
+{
+ if(&other != this)
+ {
+ m_word=other.m_word;
+ m_deposits=std::move(other.m_deposits);
+ }
+ return *this;
+}
+
+TrackerSimData::~TrackerSimData()
+{
+ // delete[] m_p_deposits;
+}
diff --git a/Tracker/TrackerRawEvent/TrackerSimData/src/TrackerSimDataCollection.cxx b/Tracker/TrackerRawEvent/TrackerSimData/src/TrackerSimDataCollection.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..16709cc482851ff187bc02d373cf38677a903e0c
--- /dev/null
+++ b/Tracker/TrackerRawEvent/TrackerSimData/src/TrackerSimDataCollection.cxx
@@ -0,0 +1,17 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+
+#include "TrackerSimData/TrackerSimDataCollection.h"
+
+TrackerSimDataCollection::TrackerSimDataCollection()
+{
+
+}
+
+TrackerSimDataCollection::~TrackerSimDataCollection()
+{
+
+}
+
diff --git a/Tracker/TrackerSimEvent/TrackerSimEvent/FaserSiHit.h b/Tracker/TrackerSimEvent/TrackerSimEvent/FaserSiHit.h
index b17acf1db85d63a4fc006c450a34164a08be833d..6ef2f73bfc3090061ff41a111fc54d0f01db0460 100644
--- a/Tracker/TrackerSimEvent/TrackerSimEvent/FaserSiHit.h
+++ b/Tracker/TrackerSimEvent/TrackerSimEvent/FaserSiHit.h
@@ -142,7 +142,7 @@ private:
unsigned int m_ID;
public:
enum
- { xDep = 2, xPhi = 0, xEta = 1};
+ { xDep = 0, xPhi = 1, xEta = 2};
};