From 89cbd614f54ca6f85eb44c592966bb3678b169cb Mon Sep 17 00:00:00 2001
From: James Beacham <j.beacham@cern.ch>
Date: Sat, 14 Oct 2017 21:19:44 +0200
Subject: [PATCH] Revert "Merge branch 'FCS_StepInfoSDs_ATLASSIM-3443_21.0'
into '21.0'"
This reverts commit ae10fb168d7791e0e193676c57cfc2e636e9b4ca [formerly c946c5c2d7fa22229e1fc820834b5009ddf819f3], reversing
changes made to 1000a1cfbad79703c734143c20e1375279e92a3c [formerly d57d58cd9ec70419f96e1a5459267738957d1b30].
Former-commit-id: 1acee8606e12a4a94717e5a701df3c1875435769
---
.../G4Atlas/G4AtlasApps/python/SimFlags.py | 8 -
.../G4AtlasTools/python/G4AtlasToolsConfig.py | 3 -
.../ISF/ISF_Example/python/ISF_Output.py | 2 +-
...stCaloSimParametrization_SimPostInclude.py | 20 --
...loSimParametrization_SimPostInclude_1mm.py | 8 -
...astCaloSimParametrization_SimPreInclude.py | 20 +-
...aloSimParametrization_SimPreInclude_1mm.py | 6 +
.../ISF_FastCaloSimSD/CMakeLists.txt | 41 ---
.../python/ISF_FastCaloSimSDConfig.py | 31 --
.../python/ISF_FastCaloSimSDConfigDb.py | 5 -
.../ISF_FastCaloSimSD/src/FCS_StepInfoSD.cxx | 227 --------------
.../ISF_FastCaloSimSD/src/FCS_StepInfoSD.h | 143 ---------
.../src/FCS_StepInfoSDTool.cxx | 290 ------------------
.../src/FCS_StepInfoSDTool.h | 123 --------
.../src/LArFCS_StepInfoSD.cxx | 274 -----------------
.../ISF_FastCaloSimSD/src/LArFCS_StepInfoSD.h | 51 ---
.../ISF_FastCaloSimSD/src/SDWrapper.cxx | 101 ------
.../ISF_FastCaloSimSD/src/SDWrapper.h | 94 ------
.../src/TileFCS_StepInfoSD.cxx | 100 ------
.../src/TileFCS_StepInfoSD.h | 48 ---
.../components/ISF_FastCaloSimSD_entries.cxx | 5 -
21 files changed, 26 insertions(+), 1574 deletions(-)
delete mode 100644 Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimParametrization/share/ISF_FastCaloSimParametrization_SimPostInclude_1mm.py
create mode 100644 Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimParametrization/share/ISF_FastCaloSimParametrization_SimPreInclude_1mm.py
delete mode 100644 Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimSD/CMakeLists.txt
delete mode 100644 Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimSD/python/ISF_FastCaloSimSDConfig.py
delete mode 100644 Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimSD/python/ISF_FastCaloSimSDConfigDb.py
delete mode 100644 Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimSD/src/FCS_StepInfoSD.cxx
delete mode 100644 Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimSD/src/FCS_StepInfoSD.h
delete mode 100644 Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimSD/src/FCS_StepInfoSDTool.cxx
delete mode 100644 Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimSD/src/FCS_StepInfoSDTool.h
delete mode 100644 Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimSD/src/LArFCS_StepInfoSD.cxx
delete mode 100644 Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimSD/src/LArFCS_StepInfoSD.h
delete mode 100644 Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimSD/src/SDWrapper.cxx
delete mode 100644 Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimSD/src/SDWrapper.h
delete mode 100644 Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimSD/src/TileFCS_StepInfoSD.cxx
delete mode 100644 Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimSD/src/TileFCS_StepInfoSD.h
delete mode 100644 Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimSD/src/components/ISF_FastCaloSimSD_entries.cxx
diff --git a/Simulation/G4Atlas/G4AtlasApps/python/SimFlags.py b/Simulation/G4Atlas/G4AtlasApps/python/SimFlags.py
index 46d7a160d2e..f5f64f01e04 100644
--- a/Simulation/G4Atlas/G4AtlasApps/python/SimFlags.py
+++ b/Simulation/G4Atlas/G4AtlasApps/python/SimFlags.py
@@ -639,14 +639,6 @@ class ParticleID(JobProperty):
allowedTypes = ['bool']
StoredValue = False
-class RecordStepInfo(JobProperty):
- """
- Should FCS_StepInfoCollections be recorded
- """
- statusOn = True
- allowedTypes = ['bool']
- StoredValue = False
-
class RecordFlux(JobProperty):
"""
Record flux through the entirety of the detector
diff --git a/Simulation/G4Atlas/G4AtlasTools/python/G4AtlasToolsConfig.py b/Simulation/G4Atlas/G4AtlasTools/python/G4AtlasToolsConfig.py
index 337d297ff19..5d5439468b7 100644
--- a/Simulation/G4Atlas/G4AtlasTools/python/G4AtlasToolsConfig.py
+++ b/Simulation/G4Atlas/G4AtlasTools/python/G4AtlasToolsConfig.py
@@ -112,9 +112,6 @@ def generateCaloSensitiveDetectorList():
SensitiveDetectorList += [ 'TileGeoG4CalibSD' ] # mode 1 : With CaloCalibrationHits
else:
SensitiveDetectorList += [ 'TileGeoG4SD' ] # mode 0 : No CaloCalibrationHits
- from G4AtlasApps.SimFlags import simFlags
- if simFlags.RecordStepInfo.get_Value():
- SensitiveDetectorList += [ 'FCS_StepInfoSensitiveDetector' ]
return SensitiveDetectorList
def generateMuonSensitiveDetectorList():
diff --git a/Simulation/ISF/ISF_Example/python/ISF_Output.py b/Simulation/ISF/ISF_Example/python/ISF_Output.py
index 74c397b07b3..fcb2bc11861 100644
--- a/Simulation/ISF/ISF_Example/python/ISF_Output.py
+++ b/Simulation/ISF/ISF_Example/python/ISF_Output.py
@@ -70,7 +70,7 @@ def getHITSStreamItemList():
## TimingAlg
hitsItemList +=["RecoTimingObj#EVNTtoHITS_timings"]
- if simFlags.RecordStepInfo.get_Value():
+ if 'G4UA::FastCaloSimParamActionTool' in simFlags.OptionalUserActionList.get_Value()['Step']:
hitsItemList +=["ISF_FCS_Parametrization::FCS_StepInfoCollection#MergedEventSteps"]
## add xAOD::TrackParticles output collection Parametric Simulation
diff --git a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimParametrization/share/ISF_FastCaloSimParametrization_SimPostInclude.py b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimParametrization/share/ISF_FastCaloSimParametrization_SimPostInclude.py
index a59ee537a7a..67017a344bb 100644
--- a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimParametrization/share/ISF_FastCaloSimParametrization_SimPostInclude.py
+++ b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimParametrization/share/ISF_FastCaloSimParametrization_SimPostInclude.py
@@ -1,23 +1,3 @@
from ISF_FastCaloSimParametrization.ISF_FastCaloSimParametrizationConf import FastCaloSimParamAlg
topSeq += FastCaloSimParamAlg()
ISF_HITSStream.stream1.ItemList += ["ISF_FCS_Parametrization::FCS_StepInfoCollection#MergedEventSteps"]
-from AthenaCommon.CfgGetter import getPublicTool
-stepInfoSDTool = getPublicTool("SensitiveDetectorMasterTool").SensitiveDetectors['FCS_StepInfoSensitiveDetector']
-stepInfoSDTool.shift_lar_subhit=True
-stepInfoSDTool.shorten_lar_step=True
-
-stepInfoSDTool.maxEtaPS=1
-stepInfoSDTool.maxPhiPS=5
-stepInfoSDTool.maxrPS=0
-
-stepInfoSDTool.maxEtaEM1=1
-stepInfoSDTool.maxPhiEM1=5
-stepInfoSDTool.maxrEM1=15
-
-stepInfoSDTool.maxEtaEM2=1
-stepInfoSDTool.maxPhiEM2=5
-stepInfoSDTool.maxrEM2=60
-
-stepInfoSDTool.maxEtaEM3=1
-stepInfoSDTool.maxPhiEM3=5
-stepInfoSDTool.maxrEM3=8
diff --git a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimParametrization/share/ISF_FastCaloSimParametrization_SimPostInclude_1mm.py b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimParametrization/share/ISF_FastCaloSimParametrization_SimPostInclude_1mm.py
deleted file mode 100644
index b42cd82a47b..00000000000
--- a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimParametrization/share/ISF_FastCaloSimParametrization_SimPostInclude_1mm.py
+++ /dev/null
@@ -1,8 +0,0 @@
-from ISF_FastCaloSimParametrization.ISF_FastCaloSimParametrizationConf import FastCaloSimParamAlg
-topSeq += FastCaloSimParamAlg()
-ISF_HITSStream.stream1.ItemList += ["ISF_FCS_Parametrization::FCS_StepInfoCollection#MergedEventSteps"]
-from AthenaCommon.CfgGetter import getPublicTool
-stepInfoSDTool = getPublicTool("SensitiveDetectorMasterTool").SensitiveDetectors['FCS_StepInfoSensitiveDetector']
-stepInfoSDTool.shift_lar_subhit=True
-stepInfoSDTool.shorten_lar_step=True
-stepInfoSDTool.maxRadiusLAr=1
diff --git a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimParametrization/share/ISF_FastCaloSimParametrization_SimPreInclude.py b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimParametrization/share/ISF_FastCaloSimParametrization_SimPreInclude.py
index ed3a162c17b..b10f924dd25 100644
--- a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimParametrization/share/ISF_FastCaloSimParametrization_SimPreInclude.py
+++ b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimParametrization/share/ISF_FastCaloSimParametrization_SimPreInclude.py
@@ -1,2 +1,20 @@
from G4AtlasApps.SimFlags import simFlags
-simFlags.RecordStepInfo=True
+simFlags.OptionalUserActionList.addAction('G4UA::FastCaloSimParamActionTool',['BeginOfEvent','EndOfEvent','BeginOfRun','EndOfRun','Step'])
+simFlags.UserActionConfig.addConfig('G4UA::FastCaloSimParamActionTool',"shift_lar_subhit",True)
+simFlags.UserActionConfig.addConfig('G4UA::FastCaloSimParamActionTool',"shorten_lar_step",True)
+# optimised merging scheme parameters
+simFlags.UserActionConfig.addConfig('G4UA::FastCaloSimParamActionTool',"maxEtaPS",1)
+simFlags.UserActionConfig.addConfig('G4UA::FastCaloSimParamActionTool',"maxPhiPS",5)
+simFlags.UserActionConfig.addConfig('G4UA::FastCaloSimParamActionTool',"maxrPS",0)
+
+simFlags.UserActionConfig.addConfig('G4UA::FastCaloSimParamActionTool',"maxEtaEM1",1)
+simFlags.UserActionConfig.addConfig('G4UA::FastCaloSimParamActionTool',"maxPhiEM1",5)
+simFlags.UserActionConfig.addConfig('G4UA::FastCaloSimParamActionTool',"maxrEM1",15)
+
+simFlags.UserActionConfig.addConfig('G4UA::FastCaloSimParamActionTool',"maxEtaEM2",1)
+simFlags.UserActionConfig.addConfig('G4UA::FastCaloSimParamActionTool',"maxPhiEM2",5)
+simFlags.UserActionConfig.addConfig('G4UA::FastCaloSimParamActionTool',"maxrEM2",60)
+
+simFlags.UserActionConfig.addConfig('G4UA::FastCaloSimParamActionTool',"maxEtaEM3",1)
+simFlags.UserActionConfig.addConfig('G4UA::FastCaloSimParamActionTool',"maxPhiEM3",5)
+simFlags.UserActionConfig.addConfig('G4UA::FastCaloSimParamActionTool',"maxrEM3",8)
diff --git a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimParametrization/share/ISF_FastCaloSimParametrization_SimPreInclude_1mm.py b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimParametrization/share/ISF_FastCaloSimParametrization_SimPreInclude_1mm.py
new file mode 100644
index 00000000000..d4c0a586f46
--- /dev/null
+++ b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimParametrization/share/ISF_FastCaloSimParametrization_SimPreInclude_1mm.py
@@ -0,0 +1,6 @@
+from G4AtlasApps.SimFlags import simFlags
+simFlags.OptionalUserActionList.addAction('G4UA::FastCaloSimParamActionTool',['BeginOfEvent','EndOfEvent','BeginOfRun','EndOfRun','Step'])
+simFlags.UserActionConfig.addConfig('G4UA::FastCaloSimParamActionTool',"shift_lar_subhit",True)
+simFlags.UserActionConfig.addConfig('G4UA::FastCaloSimParamActionTool',"shorten_lar_step",True)
+simFlags.UserActionConfig.addConfig('G4UA::FastCaloSimParamActionTool',"maxRadiusLAr",1)
+# optimised merging scheme parameters are not required for 1mm merging
diff --git a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimSD/CMakeLists.txt b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimSD/CMakeLists.txt
deleted file mode 100644
index 4c03c106111..00000000000
--- a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimSD/CMakeLists.txt
+++ /dev/null
@@ -1,41 +0,0 @@
-################################################################################
-# Package: ISF_FastCaloSimSD
-################################################################################
-
-# Declare the package name:
-atlas_subdir( ISF_FastCaloSimSD )
-
-# Declare the package's dependencies:
-atlas_depends_on_subdirs( PUBLIC
- Control/StoreGate
- GaudiKernel
- Simulation/G4Atlas/G4AtlasInterfaces
- Simulation/G4Atlas/G4AtlasTools
- TileCalorimeter/TileG4/TileG4Interfaces
- PRIVATE
- Calorimeter/CaloDetDescr
- Calorimeter/CaloIdentifier
- Control/CxxUtils
- Control/AthenaBaseComps
- Generators/GeneratorObjects
- LArCalorimeter/LArG4/LArG4Code
- Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent
- DetectorDescription/Identifier )
-
-# External dependencies:
-find_package( CLHEP )
-find_package( Geant4 )
-find_package( ROOT COMPONENTS Core Tree MathCore Hist RIO pthread )
-find_package( XercesC )
-
-# Component(s) in the package:
-atlas_add_component( ISF_FastCaloSimSD
- src/*.cxx
- src/components/*.cxx
- INCLUDE_DIRS ${ROOT_INCLUDE_DIRS} ${XERCESC_INCLUDE_DIRS} ${GEANT4_INCLUDE_DIRS} ${CLHEP_INCLUDE_DIRS}
- LINK_LIBRARIES ${ROOT_LIBRARIES} ${XERCESC_LIBRARIES} ${GEANT4_LIBRARIES} ${CLHEP_LIBRARIES} StoreGateLib SGtests GaudiKernel G4AtlasInterfaces G4AtlasToolsLib CaloDetDescrLib CaloIdentifier CxxUtils GeneratorObjects LArG4Code ISF_FastCaloSimEvent Identifier )
-
-# Install files from the package:
-atlas_install_headers( ISF_FastCaloSimSD )
-atlas_install_python_modules( python/*.py )
-
diff --git a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimSD/python/ISF_FastCaloSimSDConfig.py b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimSD/python/ISF_FastCaloSimSDConfig.py
deleted file mode 100644
index a8dc3f98ead..00000000000
--- a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimSD/python/ISF_FastCaloSimSDConfig.py
+++ /dev/null
@@ -1,31 +0,0 @@
-# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
-
-from AthenaCommon import CfgMgr
-
-def getFCS_StepInfoSensitiveDetector(name="FCS_StepInfoSensitiveDetector", **kwargs):
- ## Main configuration
- kwargs.setdefault("StacVolumes",["LArMgr::LAr::EMB::STAC"])
- kwargs.setdefault("PresamplerVolumes",["LArMgr::LAr::Barrel::Presampler::Module"])
- kwargs.setdefault("NegIWVolumes",["LArMgr::LAr::EMEC::Neg::InnerWheel"])
- kwargs.setdefault("NegOWVolumes",["LArMgr::LAr::EMEC::Neg::OuterWheel"])
- kwargs.setdefault("BOBarretteVolumes",["LArMgr::LAr::EMEC::BackOuterBarrette::Module::Phidiv"])
- kwargs.setdefault("MiniVolumes",["LArMgr::MiniFCAL::Wafer"])
- kwargs.setdefault("PosIWVolumes",["LArMgr::LAr::EMEC::Pos::InnerWheel"])
- kwargs.setdefault("PosOWVolumes",["LArMgr::LAr::EMEC::Pos::OuterWheel"])
- kwargs.setdefault("PresVolumes", ["LArMgr::LAr::Endcap::Presampler::LiquidArgon"])
- kwargs.setdefault("SliceVolumes",["LArMgr::LAr::HEC::Module::Depth::Slice"])
- kwargs.setdefault("FCAL1Volumes",["LArMgr::LAr::FCAL::Module1::Gap"])
- kwargs.setdefault("FCAL2Volumes",["LArMgr::LAr::FCAL::Module2::Gap"])
- kwargs.setdefault("FCAL3Volumes",["LArMgr::LAr::FCAL::Module3::Gap"])
- kwargs.setdefault("TileVolumes",["Tile::Scintillator"])
- kwargs.setdefault("OutputCollectionNames", ["EventSteps"])
- # TODO Add extra configuration here!!
- return CfgMgr.FCS_Param__FCS_StepInfoSDTool(name, **kwargs)
-
-##def getFastCaloSimParamActionTool(name='G4UA::FastCaloSimParamActionTool', **kwargs):
-## from G4AtlasApps.SimFlags import simFlags
-## # example custom configuration
-## if name in simFlags.UserActionConfig.get_Value().keys():
-## for prop,value in simFlags.UserActionConfig.get_Value()[name].iteritems():
-## kwargs.setdefault(prop,value)
-## return CfgMgr.G4UA__FastCaloSimParamActionTool(name,**kwargs)
diff --git a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimSD/python/ISF_FastCaloSimSDConfigDb.py b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimSD/python/ISF_FastCaloSimSDConfigDb.py
deleted file mode 100644
index 4c205253ba0..00000000000
--- a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimSD/python/ISF_FastCaloSimSDConfigDb.py
+++ /dev/null
@@ -1,5 +0,0 @@
-# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
-
-from AthenaCommon.CfgGetter import addTool
-
-addTool("ISF_FastCaloSimSD.ISF_FastCaloSimSDConfig.getFCS_StepInfoSensitiveDetector", "FCS_StepInfoSensitiveDetector")
diff --git a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimSD/src/FCS_StepInfoSD.cxx b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimSD/src/FCS_StepInfoSD.cxx
deleted file mode 100644
index 9e46bd508c0..00000000000
--- a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimSD/src/FCS_StepInfoSD.cxx
+++ /dev/null
@@ -1,227 +0,0 @@
-/*
- Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
-*/
-
-#include "FCS_StepInfoSD.h"
-
-#include "CaloIdentifier/CaloIdManager.h"
-#include "CaloIdentifier/LArID_Exception.h"
-#include "CaloIdentifier/LArEM_ID.h"
-#include "CaloIdentifier/LArFCAL_ID.h"
-#include "CaloIdentifier/LArHEC_ID.h"
-#include "CaloIdentifier/LArMiniFCAL_ID.h"
-#include "CaloDetDescr/CaloDetDescrManager.h"
-#include "CaloDetDescr/CaloDetDescrElement.h"
-
-#include "G4Step.hh"
-#include "G4ThreeVector.hh"
-
-FCS_StepInfoSD::FCS_StepInfoSD(G4String a_name, const FCS_Param::Config& config)
- : G4VSensitiveDetector(a_name)
- , m_config(config)
- , m_larEmID(nullptr)
- , m_larFcalID(nullptr)
- , m_larHecID(nullptr)
- , m_larMiniFcalID(nullptr)
- , m_calo_dd_man(nullptr)
-{
- m_calo_dd_man = CaloDetDescrManager::instance(); //FIXME Move somewhere else!!
-}
-
-FCS_StepInfoSD::~FCS_StepInfoSD()
-{
-}
-
-G4bool FCS_StepInfoSD::ProcessHits(G4Step*,G4TouchableHistory*)
-{
- G4ExceptionDescription description;
- description << "ProcessHits: Base class method should not be called!!!";
- G4Exception("FCS_StepInfoSD", "FCSBadCall", FatalException, description);
- abort();
- return false;
-}
-
-inline double FCS_StepInfoSD::getMaxTime(const CaloCell_ID::CaloSample& layer) const
-{
- /// NB The result of this function should actually be constant for each SD
- if (layer >= CaloCell_ID::PreSamplerB && layer <= CaloCell_ID::EME3) {
- return m_config.m_maxTimeLAr;
- }
- if (layer >= CaloCell_ID::HEC0 && layer <= CaloCell_ID::HEC3) {
- return m_config.m_maxTimeHEC;
- }
- if (layer >=CaloCell_ID::FCAL0 && layer <= CaloCell_ID::FCAL2) {
- return m_config.m_maxTimeFCAL;
- }
- return m_config.m_maxTime;
-}
-
-inline double FCS_StepInfoSD::getMaxRadius(const CaloCell_ID::CaloSample& layer) const
-{
- /// NB The result of this function should actually be constant for each SD
- if (layer >= CaloCell_ID::PreSamplerB && layer <= CaloCell_ID::EME3) {
- return m_config.m_maxRadiusLAr;
- }
- if (layer >= CaloCell_ID::HEC0 && layer <= CaloCell_ID::HEC3) {
- return m_config.m_maxRadiusHEC;
- }
- if (layer >=CaloCell_ID::FCAL0 && layer <= CaloCell_ID::FCAL2) {
- return m_config.m_maxRadiusFCAL;
- }
- return m_config.m_maxRadius;
-}
-
-inline double FCS_StepInfoSD::getMaxDeltaR(const CaloCell_ID::CaloSample& layer) const
-{
- /// NB The result of this function should actually be constant for each SD
- if(m_config.m_maxRadiusLAr != 25) return 999.;
- if (layer >= CaloCell_ID::PreSamplerB && layer <= CaloCell_ID::EME3) {
- if (layer==CaloCell_ID::PreSamplerB || layer==CaloCell_ID::PreSamplerE) {
- // PS default is 1mm in eta, 5mm in phi, no cut in r
- return m_config.m_maxrPS;
- }
- else if (layer==CaloCell_ID::EMB1 || layer==CaloCell_ID::EME1) {
- // EM1 default is 1mm in eta, 5mm in phi, 15mm in r
- return m_config.m_maxrEM1;
- }
- else if (layer==CaloCell_ID::EMB2 || layer==CaloCell_ID::EME2) {
- // EM2 default is 1mm in eta, 5mm in phi, 60mm in r
- return m_config.m_maxrEM2;
- }
- else if (layer==CaloCell_ID::EMB3 || layer==CaloCell_ID::EME3) {
- // EM3 default is 1mm in eta, 5mm in phi, 8mm in r
- return m_config.m_maxrEM3;
- }
- }
- return 999.;
-}
-
-inline double FCS_StepInfoSD::getMaxDeltaEta(const CaloCell_ID::CaloSample& layer) const
-{
- /// NB The result of this function should actually be constant for each SD
- if(m_config.m_maxRadiusLAr != 25) return 999.;
- if (layer >= CaloCell_ID::PreSamplerB && layer <= CaloCell_ID::EME3) {
- if (layer==CaloCell_ID::PreSamplerB || layer==CaloCell_ID::PreSamplerE) {
- // PS default is 1mm in eta, 5mm in phi, no cut in r
- return m_config.m_maxEtaPS;
- }
- else if (layer==CaloCell_ID::EMB1 || layer==CaloCell_ID::EME1) {
- // EM1 default is 1mm in eta, 5mm in phi, 15mm in r
- return m_config.m_maxEtaEM1;
- }
- else if (layer==CaloCell_ID::EMB2 || layer==CaloCell_ID::EME2) {
- // EM2 default is 1mm in eta, 5mm in phi, 60mm in r
- return m_config.m_maxEtaEM2;
- }
- else if (layer==CaloCell_ID::EMB3 || layer==CaloCell_ID::EME3) {
- // EM3 default is 1mm in eta, 5mm in phi, 8mm in r
- return m_config.m_maxEtaEM3;
- }
- }
- return 999.;
-}
-
-inline double FCS_StepInfoSD::getMaxDeltaPhi(const CaloCell_ID::CaloSample& layer) const
-{
- /// NB The result of this function should actually be constant for each SD
- if(m_config.m_maxRadiusLAr != 25) return 999.;
- if (layer >= CaloCell_ID::PreSamplerB && layer <= CaloCell_ID::EME3) {
- if (layer==CaloCell_ID::PreSamplerB || layer==CaloCell_ID::PreSamplerE) {
- // PS default is 1mm in eta, 5mm in phi, no cut in r
- return m_config.m_maxPhiPS;
- }
- else if (layer==CaloCell_ID::EMB1 || layer==CaloCell_ID::EME1) {
- // EM1 default is 1mm in eta, 5mm in phi, 15mm in r
- return m_config.m_maxPhiEM1;
- }
- else if (layer==CaloCell_ID::EMB2 || layer==CaloCell_ID::EME2) {
- // EM2 default is 1mm in eta, 5mm in phi, 60mm in r
- return m_config.m_maxPhiEM2;
- }
- else if (layer==CaloCell_ID::EMB3 || layer==CaloCell_ID::EME3) {
- // EM3 default is 1mm in eta, 5mm in phi, 8mm in r
- return m_config.m_maxPhiEM3;
- }
- }
- return 999.;
-}
-
-void FCS_StepInfoSD::update_map(const CLHEP::Hep3Vector & l_vec, const Identifier & l_cell, double l_energy, double l_time, bool l_valid, int l_detector)
-{
- // Drop any hits that don't have a good identifier attached
- if (!m_calo_dd_man->get_element(l_cell)) { return; }
-
- auto map_item = m_hit_map.find( l_cell );
- if (map_item==m_hit_map.end()) {
- m_hit_map[l_cell] = new std::vector< ISF_FCS_Parametrization::FCS_StepInfo* >;
- m_hit_map[l_cell]->reserve(200);
- m_hit_map[l_cell]->push_back( new ISF_FCS_Parametrization::FCS_StepInfo( l_vec , l_cell , l_energy , l_time , l_valid , l_detector ) );
- }
- else {
-
- // Get the appropriate merging limits
- const CaloCell_ID::CaloSample& layer = m_calo_dd_man->get_element(l_cell)->getSampling();
- const double tsame(this->getMaxTime(layer));
- const double maxRadius(this->getMaxRadius(layer));
- const double maxDeltaR(this->getMaxDeltaR(layer));
- const double maxDeltaEta(this->getMaxDeltaEta(layer));
- const double maxDeltaPhi(this->getMaxDeltaPhi(layer));
- bool match = false;
- for (auto map_it : * map_item->second) {
- // Time check is straightforward
- const double delta_t = std::fabs(map_it->time()-l_time);
- if ( delta_t >= tsame ) { continue; }
-
- // Distance check is less straightforward
- const CLHEP::Hep3Vector & currentPosition = map_it->position();
- const double hit_diff2 = currentPosition.diff2( l_vec );
-
- // Overall merging scheme
- if (layer >= CaloCell_ID::PreSamplerB && layer <= CaloCell_ID::EME3) {
- // Customized merging scheme for LAr barrel and endcap, use only if we're not changing maxRadiusLAr value
- if(m_config.m_maxRadiusLAr == 25) {
- const CLHEP::Hep3Vector a_diff = l_vec - currentPosition;
- const double a_diffmag(a_diff.mag());
- const double a_inv_length = 1./a_diffmag;
- const double delta_r = std::fabs(a_diff.dot( l_vec ) * a_inv_length);
- if (delta_r >= maxDeltaR) { continue; }
- const double delta_eta = std::fabs(std::sin(l_vec.theta()-currentPosition.theta())*a_diffmag);
- if (delta_eta >= maxDeltaEta) { continue; }
- const double delta_phi = std::fabs(std::sin(l_vec.phi()-currentPosition.phi())*a_diffmag);
- if (delta_phi >= maxDeltaPhi) { continue; }
- }
- else {
- if ( hit_diff2 >= maxRadius ) { continue; }
- }
- }
- else if ( hit_diff2 >= maxRadius ) { continue; }
- // Found a match. Make a temporary that will be deleted!
- const ISF_FCS_Parametrization::FCS_StepInfo my_info( l_vec , l_cell , l_energy , l_time , l_valid , l_detector );
- *map_it += my_info;
- match = true;
- break;
- } // End of search for match in time and space
- if (!match) {
- map_item->second->push_back( new ISF_FCS_Parametrization::FCS_StepInfo( l_vec , l_cell , l_energy , l_time , l_valid , l_detector ) );
- } // Didn't match
- } // ID already in the map
- return;
-} // That's it for updating the map!
-
-void FCS_StepInfoSD::EndOfAthenaEvent( ISF_FCS_Parametrization::FCS_StepInfoCollection* hitContainer )
-{
- // Unpack map into vector
- for (auto it : m_hit_map) {
- for (auto a_s : * it.second) {
- // Giving away ownership of the objects!
- hitContainer->push_back( a_s );
- }
- it.second->clear();
- delete it.second;
- } // Vector of IDs in the map
- m_hit_map.clear();
- if (m_config.verboseLevel > 4) {
- G4cout <<this->GetName()<< " DEBUG EndOfAthenaEvent: After initial cleanup, N=" << hitContainer->size() << G4endl;
- }
- return;
-}
diff --git a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimSD/src/FCS_StepInfoSD.h b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimSD/src/FCS_StepInfoSD.h
deleted file mode 100644
index 1a4c3410976..00000000000
--- a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimSD/src/FCS_StepInfoSD.h
+++ /dev/null
@@ -1,143 +0,0 @@
-/*
- Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
-*/
-
-#ifndef ISF_FASTCALOSIM_FCS_STEPINFOSD_H
-#define ISF_FASTCALOSIM_FCS_STEPINFOSD_H
-
-#include "G4VSensitiveDetector.hh"
-
-#include "CaloIdentifier/CaloCell_ID.h" // For CaloCell_ID::CaloSample
-#include "LArG4Code/LArG4Identifier.h"
-
-#include "LArSimEvent/LArHit.h"
-#include "CLHEP/Units/SystemOfUnits.h"
-
-#include "ISF_FastCaloSimEvent/FCS_StepInfoCollection.h"
-
-#include <map>
-#include <vector>
-
-// Forward declarations
-class G4Step;
-class G4TouchableHistory;
-
-class LArEM_ID;
-class LArFCAL_ID;
-class LArHEC_ID;
-class LArMiniFCAL_ID;
-class CaloDetDescrManager;
-
-class ILArCalculatorSvc;
-class ITileCalculator;
-class LArHitContainer;
-
-class StoreGateSvc;
-
-namespace FCS_Param {
-
- struct Config
- {
- /** Helper to keep the same verbosity everywhere */
- int verboseLevel=0;
- bool shift_lar_subhit=true;
- bool shorten_lar_step=false;
-
- // Merging properties
- double m_maxRadius=25.; //!< property, see @link LArG4GenShowerLib::LArG4GenShowerLib @endlink
- double m_maxRadiusLAr=25.; //!< property, see @link LArG4GenShowerLib::LArG4GenShowerLib @endlink
- double m_maxRadiusHEC=100.; //!< property, see @link LArG4GenShowerLib::LArG4GenShowerLib @endlink
- double m_maxRadiusFCAL=100.; //!< property, see @link LArG4GenShowerLib::LArG4GenShowerLib @endlink
- double m_maxRadiusTile=100.; //!< property, see @link LArG4GenShowerLib::LArG4GenShowerLib @endlink
-
- double m_maxTime=25.;
- double m_maxTimeLAr=25.;
- double m_maxTimeHEC=25.;
- double m_maxTimeFCAL=25.;
- double m_maxTimeTile=25.;
-
- // Optimised merging scheme
- double m_maxEtaPS=1.;
- double m_maxPhiPS=5.;
- double m_maxrPS=0.;
-
- double m_maxEtaEM1=1.;
- double m_maxPhiEM1=5.;
- double m_maxrEM1=15.;
-
- double m_maxEtaEM2=1.;
- double m_maxPhiEM2=5.;
- double m_maxrEM2=60.;
-
- double m_maxEtaEM3=1.;
- double m_maxPhiEM3=5.;
- double m_maxrEM3=8.;
-
- ILArCalculatorSvc *m_LArCalculator=nullptr;
- ITileCalculator *m_TileCalculator=nullptr;
- };
-
-}
-
-/// @class FCS_StepInfoSD
-/// @brief Common sensitive detector class for LAr systems.
-///
-/// This SD implementation saves the standard LArHits.
-/// See LArG4CalibSD for an SD that handles calibration hits.
-///
-class FCS_StepInfoSD : public G4VSensitiveDetector
-{
-public:
-
- /// Constructor
- FCS_StepInfoSD(G4String a_name, const FCS_Param::Config& config);
-
- /// Destructor
- virtual ~FCS_StepInfoSD();
-
- /// Main processing method
- G4bool ProcessHits(G4Step* a_step, G4TouchableHistory*) override;
-
- /// End of athena event processing
- void EndOfAthenaEvent( ISF_FCS_Parametrization::FCS_StepInfoCollection* hitContnainer );
-
- /// Sets the ID helper pointers
- void setupHelpers( const LArEM_ID* EM ,
- const LArFCAL_ID* FCAL ,
- const LArHEC_ID* HEC ,
- const LArMiniFCAL_ID* mini ) {
- m_larEmID = EM;
- m_larFcalID = FCAL;
- m_larHecID = HEC;
- m_larMiniFcalID = mini;
- }
-
-protected:
- /// Keep a map instead of trying to keep the full vector.
- /// At the end of the event we'll push the map back into the
- /// FCS_StepInfoCollection in StoreGate.
- virtual void update_map(const CLHEP::Hep3Vector & l_vec, const Identifier & l_cell, double l_energy, double l_time, bool l_valid, int l_detector);
- FCS_Param::Config m_config;
- /// Pointers to the identifier helpers
- const LArEM_ID* m_larEmID;
- const LArFCAL_ID* m_larFcalID;
- const LArHEC_ID* m_larHecID;
- const LArMiniFCAL_ID* m_larMiniFcalID;
- const CaloDetDescrManager *m_calo_dd_man;
- std::map< Identifier , std::vector< ISF_FCS_Parametrization::FCS_StepInfo* >* > m_hit_map;
-
-private:
- ///
- double getMaxTime(const CaloCell_ID::CaloSample& layer) const;
- ///
- double getMaxRadius(const CaloCell_ID::CaloSample& layer) const;
- ///
- double getMaxDeltaR(const CaloCell_ID::CaloSample& layer) const;
- ///
- double getMaxDeltaEta(const CaloCell_ID::CaloSample& layer) const;
- ///
- double getMaxDeltaPhi(const CaloCell_ID::CaloSample& layer) const;
-
-};
-
-#endif // ISF_FASTCALOSIM_FCS_STEPINFOSD_H
diff --git a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimSD/src/FCS_StepInfoSDTool.cxx b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimSD/src/FCS_StepInfoSDTool.cxx
deleted file mode 100644
index a4e4660568e..00000000000
--- a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimSD/src/FCS_StepInfoSDTool.cxx
+++ /dev/null
@@ -1,290 +0,0 @@
-/*
- Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
-*/
-
-#include "FCS_StepInfoSDTool.h"
-
-#include <memory>
-
-// External includes
-#include "CLHEP/Units/SystemOfUnits.h"
-
-// Athena includes
-#include "CaloIdentifier/CaloIdManager.h"
-#include "CaloIdentifier/LArEM_ID.h"
-#include "CaloIdentifier/LArFCAL_ID.h"
-#include "CaloIdentifier/LArHEC_ID.h"
-#include "CaloIdentifier/LArMiniFCAL_ID.h"
-#include "LArG4Code/ILArCalculatorSvc.h"
-#include "LArG4Code/VolumeUtils.h"
-#include "TileG4Interfaces/ITileCalculator.h"
-
-// Local includes
-#include "LArFCS_StepInfoSD.h"
-#include "TileFCS_StepInfoSD.h"
-#include "SDWrapper.h"
-
-/// Template instantiation for FCS_StepInfoSD
-using FCS_StepInfoSDWrapper = FCS_Param::detail::SDWrapper<FCS_StepInfoSD, ISF_FCS_Parametrization::FCS_StepInfoCollection>;
-
-namespace FCS_Param
-{
-
- //---------------------------------------------------------------------------
- // Tool constructor
- //---------------------------------------------------------------------------
- FCS_StepInfoSDTool::FCS_StepInfoSDTool(const std::string& type, const std::string& name,
- const IInterface* parent)
- : SensitiveDetectorBase(type, name, parent)
- , m_hitCollName("EventSteps")
- , m_bpsmodcalc("EMBPresamplerCalculator", name)
- , m_embcalc("EMBCalculator", name)
- , m_emepiwcalc("EMECPosInnerWheelCalculator", name)
- , m_emeniwcalc("EMECNegInnerWheelCalculator", name)
- , m_emepowcalc("EMECPosOuterWheelCalculator", name)
- , m_emenowcalc("EMECNegOuterWheelCalculator", name)
- , m_emepscalc("EMECPresamplerCalculator", name)
- , m_emeobarcalc("EMECBackOuterBarretteCalculator", name)
- , m_heccalc("HECWheelCalculator", name)
- , m_fcal1calc("FCAL1Calculator", name)
- , m_fcal2calc("FCAL2Calculator", name)
- , m_fcal3calc("FCAL3Calculator", name)
- , m_minfcalcalc("MiniFCALCalculator", name)
- , m_tileCalculator("TileGeoG4SDCalc", name)
- , m_larEmID(nullptr)
- , m_larFcalID(nullptr)
- , m_larHecID(nullptr)
- , m_larMiniFcalID(nullptr)
- , m_config()
- {
- declareProperty("HitCollectionName", m_hitCollName);
- declareProperty("StacVolumes", m_stacVolumes);
- declareProperty("PresamplerVolumes", m_presBarVolumes);
- declareProperty("PosIWVolumes", m_posIWVolumes);
- declareProperty("NegIWVolumes", m_negIWVolumes);
- declareProperty("PosOWVolumes", m_posOWVolumes);
- declareProperty("NegOWVolumes", m_negOWVolumes);
- declareProperty("PresVolumes", m_presECVolumes);
- declareProperty("BOBarretteVolumes", m_bobVolumes);
- declareProperty("FCAL1Volumes", m_fcal1Volumes);
- declareProperty("FCAL2Volumes", m_fcal2Volumes);
- declareProperty("FCAL3Volumes", m_fcal3Volumes);
- declareProperty("SliceVolumes", m_sliceVolumes);
- declareProperty("MiniVolumes", m_miniVolumes);
- declareProperty("TileVolumes", m_tileVolumes);
-
- declareProperty("EMBPSCalibrationCalculator",m_bpsmodcalc);
- declareProperty("EMBCalibrationCalculator",m_embcalc);
- declareProperty("EMECPosIWCalibrationCalculator",m_emepiwcalc);
- declareProperty("EMECNegIWCalibrationCalculator",m_emeniwcalc);
- declareProperty("EMECPosOWCalibrationCalculator",m_emepowcalc);
- declareProperty("EMECNegOWCalibrationCalculator",m_emenowcalc);
- declareProperty("EMECPSCalibrationCalculator",m_emepscalc);
- declareProperty("EMECBOBCalibrationCalculator",m_emeobarcalc);
- declareProperty("HECWActiveCalculator",m_heccalc);
- declareProperty("FCAL1CalibCalculator",m_fcal1calc);
- declareProperty("FCAL2CalibCalculator",m_fcal2calc);
- declareProperty("FCAL3CalibCalculator",m_fcal3calc);
- declareProperty("MiniFCALActiveCalibrationCalculator",m_minfcalcalc);
- declareProperty("TileCalculator", m_tileCalculator);
-
- declareProperty("shift_lar_subhit",m_config.shift_lar_subhit, "");
- declareProperty("shorten_lar_step",m_config.shorten_lar_step, "");
-
- declareProperty("maxRadius",m_config.m_maxRadius, "");
- declareProperty("maxRadiusLAr",m_config.m_maxRadiusLAr, "");
- declareProperty("maxRadiusHEC",m_config.m_maxRadiusHEC, "");
- declareProperty("maxRadiusFCAL",m_config.m_maxRadiusFCAL, "");
- declareProperty("maxRadiusTile",m_config.m_maxRadiusTile, "");
-
- declareProperty("maxTime",m_config.m_maxTime, "");
- declareProperty("maxTimeLAr",m_config.m_maxTimeLAr, "");
- declareProperty("maxTimeHEC",m_config.m_maxTimeHEC, "");
- declareProperty("maxTimeFCAL",m_config.m_maxTimeFCAL, "");
- declareProperty("maxTimeTile",m_config.m_maxTimeTile, "");
-
- declareProperty("maxEtaPS", m_config.m_maxEtaPS, "");
- declareProperty("maxPhiPS", m_config.m_maxPhiPS, "");
- declareProperty("maxrPS", m_config.m_maxrPS, "");
-
- declareProperty("maxEtaEM1", m_config.m_maxEtaEM1, "");
- declareProperty("maxPhiEM1", m_config.m_maxPhiEM1, "");
- declareProperty("maxrEM1", m_config.m_maxrEM1, "");
-
- declareProperty("maxEtaEM2", m_config.m_maxEtaEM2, "");
- declareProperty("maxPhiEM2", m_config.m_maxPhiEM2, "");
- declareProperty("maxrEM2", m_config.m_maxrEM2, "");
-
- declareProperty("maxEtaEM3", m_config.m_maxEtaEM3, "");
- declareProperty("maxPhiEM3", m_config.m_maxPhiEM3, "");
- declareProperty("maxrEM3", m_config.m_maxrEM3, "");
- }
-
- //---------------------------------------------------------------------------
- // Initialize the tool
- //---------------------------------------------------------------------------
- StatusCode FCS_StepInfoSDTool::initialize()
- {
- ATH_MSG_DEBUG( "Initializing " << name() );
-
- const CaloIdManager* idMgr = nullptr;
- CHECK( detStore()->retrieve(idMgr) );
- if( (m_larEmID = idMgr->getEM_ID()) == nullptr) {
- ATH_MSG_ERROR("Invalid LAr EM ID helper");
- return StatusCode::FAILURE;
- }
- if( (m_larFcalID = idMgr->getFCAL_ID()) == nullptr) {
- ATH_MSG_ERROR("Invalid LAr FCAL ID helper");
- return StatusCode::FAILURE;
- }
- if( (m_larHecID = idMgr->getHEC_ID()) == nullptr) {
- ATH_MSG_ERROR("Invalid LAr HEC ID helper");
- return StatusCode::FAILURE;
- }
- if( (m_larMiniFcalID = idMgr->getMiniFCAL_ID()) == nullptr) {
- ATH_MSG_ERROR("Invalid LAr Mini FCAL ID helper");
- return StatusCode::FAILURE;
- }
-
- // No general volume list for SensitiveDetectorBase
- m_noVolumes = true;
-
- ATH_CHECK(this->initializeCalculators());
-
- return StatusCode::SUCCESS;
- }
-
- //---------------------------------------------------------------------------
- // Initialization of Athena-components
- //---------------------------------------------------------------------------
- StatusCode FCS_StepInfoSDTool::initializeCalculators()
- {
- // Lots of calculators !!!
- ATH_CHECK(m_bpsmodcalc.retrieve());
- ATH_CHECK(m_embcalc.retrieve());
- ATH_CHECK(m_emepiwcalc.retrieve());
- ATH_CHECK(m_emeniwcalc.retrieve());
- ATH_CHECK(m_emepowcalc.retrieve());
- ATH_CHECK(m_emenowcalc.retrieve());
- ATH_CHECK(m_emepscalc.retrieve());
- ATH_CHECK(m_emeobarcalc.retrieve());
- ATH_CHECK(m_heccalc.retrieve());
- ATH_CHECK(m_fcal1calc.retrieve());
- ATH_CHECK(m_fcal2calc.retrieve());
- ATH_CHECK(m_fcal3calc.retrieve());
- ATH_CHECK(m_minfcalcalc.retrieve());
- ATH_CHECK(m_tileCalculator.retrieve());
-
- return StatusCode::SUCCESS;
- }
-
- //---------------------------------------------------------------------------
- // Collect hits for this event
- //---------------------------------------------------------------------------
- StatusCode FCS_StepInfoSDTool::Gather()
- {
- ATH_MSG_DEBUG("Gathering hits to write out in " << name());
- auto sdWrapper = dynamic_cast<FCS_StepInfoSDWrapper*>( getSD() );
- if(!sdWrapper) {
- ATH_MSG_ERROR("Failed to cast SD to FCS_StepInfoSDWrapper");
- return StatusCode::FAILURE;
- }
- sdWrapper->EndOfAthenaEvent();
- return StatusCode::SUCCESS;
- }
-
- //---------------------------------------------------------------------------
- // Create SD wrapper for current thread
- //---------------------------------------------------------------------------
- G4VSensitiveDetector* FCS_StepInfoSDTool::makeSD()
- {
- // Create the wrapper
- auto sdWrapper = new FCS_StepInfoSDWrapper("FCS_StepInfoSDWrapper", m_hitCollName);
-
- // Create the SDs.
- sdWrapper->addSD( makeOneLArSD( "Barrel::Presampler::Module::StepInfo", &*m_bpsmodcalc, m_presBarVolumes ) );
- sdWrapper->addSD( makeOneLArSD( "EMB::STAC::StepInfo", &*m_embcalc, m_stacVolumes ) );
- sdWrapper->addSD( makeOneLArSD( "EMEC::Pos::InnerWheel::StepInfo", &*m_emepiwcalc, m_posIWVolumes ) );
- sdWrapper->addSD( makeOneLArSD( "EMEC::Neg::InnerWheel::StepInfo", &*m_emeniwcalc, m_negIWVolumes ) );
- sdWrapper->addSD( makeOneLArSD( "EMEC::Pos::OuterWheel::StepInfo", &*m_emepowcalc, m_posOWVolumes ) );
- sdWrapper->addSD( makeOneLArSD( "EMEC::Neg::OuterWheel::StepInfo", &*m_emenowcalc, m_negOWVolumes ) );
- sdWrapper->addSD( makeOneLArSD( "Endcap::Presampler::LiquidArgon::StepInfo", &*m_emepscalc, m_presECVolumes ) );
- sdWrapper->addSD( makeOneLArSD( "EMEC::BackOuterBarrette::StepInfo", &*m_emeobarcalc, m_bobVolumes ) );
- sdWrapper->addSD( makeOneLArSD( "FCAL::Module1::Gap::StepInfo", &*m_fcal1calc, m_fcal1Volumes ) );
- sdWrapper->addSD( makeOneLArSD( "FCAL::Module2::Gap::StepInfo", &*m_fcal2calc, m_fcal2Volumes ) );
- sdWrapper->addSD( makeOneLArSD( "FCAL::Module3::Gap::StepInfo", &*m_fcal3calc, m_fcal3Volumes ) );
- sdWrapper->addSD( makeOneLArSD( "HEC::Module::Depth::Slice::Wheel::StepInfo", &*m_heccalc, m_sliceVolumes ) );
- sdWrapper->addSD( makeOneLArSD( "MiniFCAL::Wafer::StepInfo", &*m_minfcalcalc, m_miniVolumes ) );
- sdWrapper->addSD( makeOneTileSD( "Tile::Scintillator::StepInfo", &*m_tileCalculator, m_tileVolumes ) );
-
- return sdWrapper;
- }
-
- //---------------------------------------------------------------------------
- // Create one LAr SD
- //---------------------------------------------------------------------------
- std::unique_ptr<FCS_StepInfoSD>
- FCS_StepInfoSDTool::makeOneLArSD(const std::string& sdName, ILArCalculatorSvc* calc,
- const std::vector<std::string>& volumes) const
- {
- ATH_MSG_VERBOSE( name() << " makeOneSD" );
-
- // Parse the wildcard patterns for existing volume names
- auto parsedVolumes = LArG4::findLogicalVolumes(volumes, msg()); // from LArG4Code/VolumeUtils.h
-
- // Inject the Calculator into m_config
- FCS_Param::Config config(m_config);
- config.m_LArCalculator = calc;
- if(!calc) {
- throw GaudiException("nullptr for ILArCalculatorSvc provided to constructor for: " + sdName,
- name(), StatusCode::FAILURE);
- }
- if(msgLvl(MSG::VERBOSE)) { config.verboseLevel = 10; }
- else if(msgLvl(MSG::DEBUG)) { config.verboseLevel = 5; }
- // Create the simple SD
- std::unique_ptr<FCS_StepInfoSD> sd =
- std::make_unique<LArFCS_StepInfoSD>(sdName, config);
- sd->setupHelpers(m_larEmID, m_larFcalID, m_larHecID, m_larMiniFcalID);
-
- // Assign the volumes to the SD
- if( this->assignSD( sd.get(), parsedVolumes ).isFailure() ) {
- // TODO: can I just return NULL here?
- throw GaudiException("Failed to assign sd: " + sdName,
- name(), StatusCode::FAILURE);
- }
- return std::move(sd);
- }
-
- //---------------------------------------------------------------------------
- // Create one Tile SD
- //---------------------------------------------------------------------------
- std::unique_ptr<FCS_StepInfoSD>
- FCS_StepInfoSDTool::makeOneTileSD(const std::string& sdName, ITileCalculator* calc,
- const std::vector<std::string>& volumes) const
- {
- ATH_MSG_VERBOSE( name() << " makeOneSD" );
-
- // Inject the Calculator into m_config
- FCS_Param::Config config(m_config);
- config.m_TileCalculator = calc;
- if(!calc) {
- throw GaudiException("nullptr for ITileCalculator provided to constructor for: " + sdName,
- name(), StatusCode::FAILURE);
- }
- if(msgLvl(MSG::VERBOSE)) { config.verboseLevel = 10; }
- else if(msgLvl(MSG::DEBUG)) { config.verboseLevel = 5; }
- // Create the simple SD
- std::unique_ptr<FCS_StepInfoSD> sd =
- std::make_unique<TileFCS_StepInfoSD>(sdName, config);
- sd->setupHelpers(m_larEmID, m_larFcalID, m_larHecID, m_larMiniFcalID);
-
- // Assign the volumes to the SD
- if( this->assignSD( sd.get(), volumes ).isFailure() ) {
- // TODO: can I just return NULL here?
- throw GaudiException("Failed to assign sd: " + sdName,
- name(), StatusCode::FAILURE);
- }
- return std::move(sd);
- }
-
-} // namespace FCS_Param
diff --git a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimSD/src/FCS_StepInfoSDTool.h b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimSD/src/FCS_StepInfoSDTool.h
deleted file mode 100644
index 1bd88ab1e4b..00000000000
--- a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimSD/src/FCS_StepInfoSDTool.h
+++ /dev/null
@@ -1,123 +0,0 @@
-/*
- Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
-*/
-
-#ifndef ISF_FASTCALOSIMSD_FCS_STEPINFOSDTOOL_H
-#define ISF_FASTCALOSIMSD_FCS_STEPINFOSDTOOL_H
-
-/// @file FCS_StepInfoSDTool.h
-/// @brief Defines the FCS_StepInfoSDTool class
-/// @author Steve Farrell <Steven.Farrell@cern.ch>
-/// @date 2016-03-26
-
-// System includes
-#include <string>
-#include <vector>
-
-// G4Atlas includes
-#include "G4AtlasTools/SensitiveDetectorBase.h"
-
-// Local includes
-#include "FCS_StepInfoSD.h"
-
-// Forward declarations
-class ILArCalculatorSvc;
-class LArEM_ID;
-class LArFCAL_ID;
-class LArHEC_ID;
-class LArMiniFCAL_ID;
-class ITileCalculator;
-
-namespace FCS_Param
-{
-
- /// @class FCS_StepInfoSDTool
- /// @brief A base class for tools that manage FCS_StepInfoSDs.
- ///
- /// @todo Add more details.
- ///
- /// @author Steve Farrell <Steven.Farrell@cern.ch>
- ///
- class FCS_StepInfoSDTool : public SensitiveDetectorBase
- {
-
- public:
-
- /// Constructor
- FCS_StepInfoSDTool(const std::string& type, const std::string& name,
- const IInterface* parent);
-
- /// Initialize the tool
- StatusCode initialize() override final;
-
- /// Calls down to all the SDs to pack their hits into one collection
- StatusCode Gather() override final;
-
- private:
-
- /// Create the SD wrapper for current worker thread
- G4VSensitiveDetector* makeSD() override final;
-
- /// Initialize Calculator Services
- virtual StatusCode initializeCalculators();
-
- /// Helper method to create one SD
- std::unique_ptr<FCS_StepInfoSD>
- makeOneLArSD(const std::string& name, ILArCalculatorSvc* calc,
- const std::vector<std::string>& volumes) const;
-
- /// Helper method to create one SD
- std::unique_ptr<FCS_StepInfoSD>
- makeOneTileSD(const std::string& name, ITileCalculator* calc,
- const std::vector<std::string>& volumes) const;
-
- /// Hit collection name
- std::string m_hitCollName;
-
- /// @name SD volumes
- /// @{
- std::vector<std::string> m_stacVolumes;
- std::vector<std::string> m_presBarVolumes;
- std::vector<std::string> m_posIWVolumes;
- std::vector<std::string> m_negIWVolumes;
- std::vector<std::string> m_posOWVolumes;
- std::vector<std::string> m_negOWVolumes;
- std::vector<std::string> m_presECVolumes;
- std::vector<std::string> m_bobVolumes;
- std::vector<std::string> m_fcal1Volumes;
- std::vector<std::string> m_fcal2Volumes;
- std::vector<std::string> m_fcal3Volumes;
- std::vector<std::string> m_sliceVolumes;
- std::vector<std::string> m_miniVolumes;
- std::vector<std::string> m_tileVolumes;
- /// @}
-
- ServiceHandle<ILArCalculatorSvc> m_bpsmodcalc; //LArG4::BarrelPresampler::CalibrationCalculator
- ServiceHandle<ILArCalculatorSvc> m_embcalc; //LArG4::Barrel::CalibrationCalculator
- ServiceHandle<ILArCalculatorSvc> m_emepiwcalc; //LArG4::EC::CalibrationCalculator(LArWheelCalculator::InnerAbsorberWheel, 1)
- ServiceHandle<ILArCalculatorSvc> m_emeniwcalc; //LArG4::EC::CalibrationCalculator(LArWheelCalculator::InnerAbsorberWheel, -1)
- ServiceHandle<ILArCalculatorSvc> m_emepowcalc; //LArG4::EC::CalibrationCalculator(LArWheelCalculator::OuterAbsorberWheel, 1)
- ServiceHandle<ILArCalculatorSvc> m_emenowcalc; //LArG4::EC::CalibrationCalculator(LArWheelCalculator::OuterAbsorberWheel, -1)
- ServiceHandle<ILArCalculatorSvc> m_emepscalc; //LArG4::EC::PresamplerCalibrationCalculator
- ServiceHandle<ILArCalculatorSvc> m_emeobarcalc; //LArG4::EC::CalibrationCalculator(LArWheelCalculator::BackOuterBarretteWheelCalib, 1)
- ServiceHandle<ILArCalculatorSvc> m_heccalc; //LArG4::HEC::LArHECCalibrationWheelCalculator(LArG4::HEC::kWheelActive)
- ServiceHandle<ILArCalculatorSvc> m_fcal1calc;
- ServiceHandle<ILArCalculatorSvc> m_fcal2calc;
- ServiceHandle<ILArCalculatorSvc> m_fcal3calc;
- ServiceHandle<ILArCalculatorSvc> m_minfcalcalc; //LArG4::MiniFCAL::MiniFCALCalibrationCalculator(LArG4::MiniFCAL::kActive)
- ServiceHandle<ITileCalculator> m_tileCalculator;
-
- /// @name Calo identifier helpers
- /// @{
- const LArEM_ID* m_larEmID;
- const LArFCAL_ID* m_larFcalID;
- const LArHEC_ID* m_larHecID;
- const LArMiniFCAL_ID* m_larMiniFcalID;
- /// @}
- FCS_Param::Config m_config;
-
- }; // class FCS_StepInfoSDTool
-
-} // namespace FCS_Param
-
-#endif
diff --git a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimSD/src/LArFCS_StepInfoSD.cxx b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimSD/src/LArFCS_StepInfoSD.cxx
deleted file mode 100644
index db100722682..00000000000
--- a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimSD/src/LArFCS_StepInfoSD.cxx
+++ /dev/null
@@ -1,274 +0,0 @@
-/*
- Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
-*/
-
-// class header
-#include "LArFCS_StepInfoSD.h"
-/// Geant4 headers
-#include "G4Step.hh"
-#include "G4ThreeVector.hh"
-#include "G4TouchableHistory.hh"
-
-/// Athena headers
-#include "CaloDetDescr/CaloDetDescrManager.h"
-#include "CaloDetDescr/CaloDetDescrElement.h"
-#include "LArG4Code/ILArCalculatorSvc.h"
-
-LArFCS_StepInfoSD::LArFCS_StepInfoSD(G4String a_name, const FCS_Param::Config& config)
- : FCS_StepInfoSD(a_name, config)
- , m_calculator(m_config.m_LArCalculator)
-{
-}
-
-LArFCS_StepInfoSD::~LArFCS_StepInfoSD()
-{
-}
-
-G4bool LArFCS_StepInfoSD::ProcessHits(G4Step* a_step,G4TouchableHistory*)
-{
- G4bool result(false);
- // If there's no energy, there's no hit. (Aside: Isn't this energy
- // the same as the energy from the calculator? Not necessarily.
- // The calculator may include detector effects such as
- // charge-collection which are not modeled by Geant4.)
- if(a_step->GetTotalEnergyDeposit() <= 0.) { return result; }
-
- if (m_calculator) {
- const double StepLength = a_step->GetStepLength()/ CLHEP::mm;
- const G4ThreeVector preStepPosition = a_step->GetPreStepPoint()->GetPosition(); //pre step is the position we're interested in
- const G4ThreeVector postStepPosition = a_step->GetPostStepPoint()->GetPosition();
- double et(0.); // Total collected charge
- std::vector<const G4Step*> steps;
- bool madeSubSteps(false);
- if (m_config.shorten_lar_step && StepLength>0.2) {
- //create smaller substeps instead
- G4int nsub_step=(int) (StepLength/0.2) + 1;
- G4double delta=1./((double) nsub_step);
- //G4cout <<"Orig prestep: "<<preStepPosition<<std::endl;
- for (G4int i=0;i<nsub_step;i++) {
- G4double fraction1 = ((G4double) i)*delta;
- G4double fraction2 = (((G4double) i) + 1.)*delta;
- G4ThreeVector subpoint1=preStepPosition*(1-fraction1) + postStepPosition*fraction1;
- G4ThreeVector subpoint2=preStepPosition*(1-fraction2) + postStepPosition*fraction2;
- G4StepPoint *startpoint = new G4StepPoint(*(a_step->GetPreStepPoint()));
- G4StepPoint *endpoint = new G4StepPoint(*(a_step->GetPostStepPoint()));
- startpoint->SetPosition(subpoint1);
- endpoint->SetPosition(subpoint2);
-
- G4Step* newstep = new G4Step(*a_step);
- newstep->SetPreStepPoint(startpoint);
- newstep->SetPostStepPoint(endpoint);
- newstep->SetStepLength( (subpoint1-subpoint2).mag());
- newstep->SetTotalEnergyDeposit(a_step->GetTotalEnergyDeposit()/nsub_step);
- steps.push_back(newstep);
- madeSubSteps=true;
- }
- }
- else {
- steps.push_back(a_step);
- }
-
- for (const G4Step* substep : steps) {
- G4ThreeVector stepPosition = 0.5*(substep->GetPreStepPoint()->GetPosition()+substep->GetPostStepPoint()->GetPosition());
- std::vector<LArHitData> processedHits;
- if (m_calculator->Process(substep, processedHits)) {
- for (const auto& larhit: processedHits) {
- et += larhit.energy;
- }
- }
- else {
- if (m_config.verboseLevel > 4) {
- //Maybe 0 hits or something like that...
- G4cout << this->GetName()<<" WARNING ProcessHits: Call to ILArCalculatorSvc::Process failed! Details:" << G4endl
- << " " << "Volume: "<< a_step->GetPreStepPoint()->GetPhysicalVolume()->GetName()<<" "<<m_calculator<< " position: "<<stepPosition<<" SL: "<<StepLength<<G4endl
- << " " << "Orig position: "<<substep->GetPreStepPoint()->GetPosition()<<" / "<<substep->GetPostStepPoint()->GetPosition()<<G4endl
- << " " << "StepLength: "<<StepLength<<" step: "<<preStepPosition<<" / "<<postStepPosition<<G4endl;
- }
- return result;
- }
-
- // drop hits with zero deposited energy (could still happen with negative corrections from calculator)
- //Or if total energy is <0
- if (et <= 0.) {
- if (m_config.verboseLevel > 4) {
- G4cout << this->GetName()<<" WARNING ProcessHits: Total negative energy: " << et << " not processing..." << G4endl;
- }
- return result;
- }
-
- const size_t numberOfProcessedHits = processedHits.size();
- const G4ThreeVector originalStepPosition = stepPosition;
- double maxSubHitEnergy = -999.;
- int maxSubHitEnergyindex =-1;
- if (numberOfProcessedHits>0) {
- maxSubHitEnergy = processedHits[0].energy;
- maxSubHitEnergyindex = 0;
- }
- //Figure out the subhit with most energy
- for (size_t i=1; i<numberOfProcessedHits; ++i) {
- if (maxSubHitEnergy<processedHits[i].energy) {
- maxSubHitEnergy = processedHits[i].energy;
- maxSubHitEnergyindex = i;
- }
- }
- //Identifier for the subhit with max energy
- Identifier maxEnergyIdentifier = this->ConvertID(processedHits[maxSubHitEnergyindex].id);
- CaloDetDescrElement *maxEnergyCell = m_calo_dd_man->get_element(maxEnergyIdentifier);
-
- Identifier invalidIdentifier;
- //for (size_t i=0; i<numberOfProcessedHits; ++i) {
- for (const auto& larhit: processedHits) {
- Identifier id = this->ConvertID(larhit.id);
- if (id == invalidIdentifier) {
- G4cout << this->GetName()<<" WARNING ProcessHits: Something wrong with LArG4Identifier: "<<(std::string) larhit.id<<G4endl
- <<" "<<id<<G4endl
- <<" "<<id.getString()<<G4endl
- <<" "<< a_step->GetPreStepPoint()->GetPhysicalVolume()->GetLogicalVolume()->GetName()<<G4endl
- <<" numberOfProcessedHits: "<<numberOfProcessedHits<<G4endl;
- G4cout <<" "<<invalidIdentifier<<G4endl;
- }
- //need to get the cell information
- if (numberOfProcessedHits>1) {
- if (!m_larEmID->is_em_barrel(id)) {
- //It didn't seem to happen outside em_barrel, so flag up if it does:
- G4cout << this->GetName()<<" WARNING ProcessHits: Outside LAr barrel, but numberOfProcessedHits="<<numberOfProcessedHits
- <<", LArG4Identifier: "<<(std::string) larhit.id<<G4endl;
- }
- else {
- if (m_config.shift_lar_subhit) {
- //find subhit with largest energy
- if (maxSubHitEnergyindex == -1) {
- G4cout << this->GetName()<<" WARNING ProcessHits: no subhit index with e>-999??? "<<G4endl;
- return result;
- }
- if(m_config.verboseLevel > 9) {
- G4cout << this->GetName()<<" VERBOSE ProcessHits: shifting subhits: largest energy subhit index is "<<maxSubHitEnergyindex<<" E: "<<maxSubHitEnergy<<" identifier: "<<maxEnergyIdentifier.getString()<<G4endl;
- }
- //from identifier
- CaloDetDescrElement *thiscell = m_calo_dd_man->get_element(id);
- if (!maxEnergyCell) {
- //How often does this happen? Do not shift.
- G4cout << this->GetName()<<" WARNING ProcessHits: maxEnergyCell failed: "<<maxEnergyIdentifier.getString()<<G4endl
- <<" "<<m_calo_dd_man->get_element(id)->getSampling()<<G4endl
- <<" "<<originalStepPosition.eta()<<G4endl
- <<" "<< originalStepPosition.phi()<<G4endl;
- stepPosition = originalStepPosition;
- }
- else if (maxEnergyCell == thiscell) {
- //The cells match, so do not shift this hit.
- if(m_config.verboseLevel > 9) {
- G4cout << this->GetName()<<" VERBOSE ProcessHits: Original step position: "<<originalStepPosition.x()<<" "<<originalStepPosition.y()<<" "<<originalStepPosition.z()<<G4endl
- <<" "<<"This cell: "<<thiscell->x()<<" "<<thiscell->y()<<" "<<thiscell->z()<<G4endl
- <<" "<<"No shift"<<G4endl;
- }
- stepPosition = originalStepPosition;
- }
- else {
- //the two cells do not match => shift
- G4ThreeVector diff(thiscell->x()-maxEnergyCell->x(), thiscell->y()-maxEnergyCell->y(), thiscell->z()-maxEnergyCell->z());
- stepPosition = originalStepPosition+diff;
- if(m_config.verboseLevel > 9) {
- CaloDetDescrElement *bestcell = m_calo_dd_man->get_element(m_calo_dd_man->get_element(id)->getSampling(),originalStepPosition.eta(), originalStepPosition.phi());
- G4cout << this->GetName()<<" VERBOSE ProcessHits: Original step position: "<<originalStepPosition.x()<<" "<<originalStepPosition.y()<<" "<<originalStepPosition.z()<<G4endl
- <<" "<<"This cell: "<<thiscell->x()<<" "<<thiscell->y()<<" "<<thiscell->z()<<G4endl
- <<" "<<"Highest E cell: "<<maxEnergyCell->x()<<" "<<maxEnergyCell->y()<<" "<<maxEnergyCell->z()<<G4endl
- <<" "<<"(Best cell: "<<bestcell->x()<<" "<<bestcell->y()<<" "<<bestcell->z()<<")"<<G4endl
- <<" "<<"Shifted step position: "<<stepPosition.x()<<" "<<stepPosition.y()<<" "<<stepPosition.z()<<G4endl;
- }
- }
- }
- }
- }
- //Finalize time for LAr hits?: NO
- //double time = larhit.energy)==0 ? 0. : (double) larhit.time/larhit.energy/CLHEP::ns;
- double time = larhit.time;
- double energy = larhit.energy/CLHEP::MeV;
- this->update_map(stepPosition, id, energy, time, true, numberOfProcessedHits); //store numberOfProcessedHits as info
- }//numberOfProcessedHits
- } //istep
- if (madeSubSteps) {
- //only delete steps when doing substeps. Do not delete the original G4Step!
- while(!steps.empty()) { delete steps.back(); steps.pop_back(); }
- }
- }
- return result;
-}
-
-Identifier LArFCS_StepInfoSD::ConvertID(const LArG4Identifier& a_ident) const
-{
- Identifier id;
- if(a_ident[0]==4) {
- // is LAr
- if(a_ident[1]==1) {
- //is LAr EM
- try {
- id = m_larEmID->channel_id(a_ident[2], // barrel_ec
- a_ident[3], // sampling
- a_ident[4], // region
- a_ident[5], // eta
- a_ident[6]); // phi
- }
- catch (LArID_Exception& e) {
- G4ExceptionDescription description;
- description << "ConvertID: LArEM_ID error code " << e.code() << " "
- << (std::string) e;
- G4Exception("LArFCS_StepInfoSD", "ConvertIDEM", FatalException, description);
- abort();
- }
- }
- else if(a_ident[1]==2) {
- //is EM HEC
- try {
- id = m_larHecID->channel_id(a_ident[2], // zSide
- a_ident[3], // sampling
- a_ident[4], // region
- a_ident[5], // eta
- a_ident[6]); // phi
- }
- catch(LArID_Exception& e) {
- G4ExceptionDescription description;
- description << "ConvertID: LArHEC_ID error code " << e.code() << " "
- << (std::string) e;
- G4Exception("LArFCS_StepInfoSD", "ConvertIDHEC", FatalException, description);
- abort();
- }
- }
- else if(a_ident[1]==3) {
- // FCAL
- if(a_ident[3]>0) {
- //is EM FCAL
- try {
- id = m_larFcalID->channel_id(a_ident[2], // zSide
- a_ident[3], // sampling
- a_ident[4], // eta
- a_ident[5]); // phi
- }
- catch(LArID_Exception& e) {
- G4ExceptionDescription description;
- description << "ConvertID: LArFCAL_ID error code " << e.code() << " "
- << (std::string) e;
- G4Exception("LArFCS_StepInfoSD", "ConvertIDFCAL", FatalException, description);
- abort();
- }
- }
- else {
- //is Mini FCAL
- try {
- id = m_larMiniFcalID->channel_id(a_ident[2], // zSide
- a_ident[3], // module
- a_ident[4], // depth
- a_ident[5], // eta
- a_ident[6]); // phi
- }
- catch(LArID_Exception& e) {
- G4ExceptionDescription description;
- description << "ConvertID: LArMiniFCAL_ID error code " << e.code() << " "
- << (std::string) e;
- G4Exception("LArFCS_StepInfoSD", "ConvertIDMiniFCAL", FatalException, description);
- abort();
- }
- }
- }
- }
- return id;
-}
diff --git a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimSD/src/LArFCS_StepInfoSD.h b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimSD/src/LArFCS_StepInfoSD.h
deleted file mode 100644
index e5756d43a11..00000000000
--- a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimSD/src/LArFCS_StepInfoSD.h
+++ /dev/null
@@ -1,51 +0,0 @@
-/*
- Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
-*/
-
-#ifndef ISF_FASTCALOSIM_LARFCS_STEPINFOSD_H
-#define ISF_FASTCALOSIM_LARFCS_STEPINFOSD_H
-
-// Base class header
-#include "FCS_StepInfoSD.h"
-
-#include "LArG4Code/LArG4Identifier.h"
-
-// Forward declarations
-class LArEM_ID;
-class LArFCAL_ID;
-class LArHEC_ID;
-class LArMiniFCAL_ID;
-class CaloDetDescrManager;
-
-class G4Step;
-class G4TouchableHistory;
-class ILArCalculatorSvc;
-
-/// @class FCS_StepInfoSD
-/// @brief Common sensitive detector class for LAr systems.
-///
-/// This SD implementation saves the standard LArHits.
-/// See LArG4CalibSD for an SD that handles calibration hits.
-///
-class LArFCS_StepInfoSD : public FCS_StepInfoSD
-{
-public:
-
- /// Constructor
- LArFCS_StepInfoSD(G4String a_name, const FCS_Param::Config& config);
-
- /// Destructor
- virtual ~LArFCS_StepInfoSD();
-
- /// Main processing method
- G4bool ProcessHits(G4Step* a_step, G4TouchableHistory*) override;
-
-private:
- /// Helper function for making "real" identifiers from LArG4Identifiers
- Identifier ConvertID(const LArG4Identifier& a_ident) const;
-
- /// Member variable - the calculator we'll use
- ILArCalculatorSvc * m_calculator;
-};
-
-#endif // ISF_FASTCALOSIM_LARFCS_STEPINFOSD_H
diff --git a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimSD/src/SDWrapper.cxx b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimSD/src/SDWrapper.cxx
deleted file mode 100644
index 7df4b9c974d..00000000000
--- a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimSD/src/SDWrapper.cxx
+++ /dev/null
@@ -1,101 +0,0 @@
-/*
- Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
-*/
-
-#include "SDWrapper.h"
-
-// Geant4 includes
-#include "G4SDManager.hh"
-
-// Framework utilities
-#include "CxxUtils/make_unique.h"
-
-// Project includes
-#include "ISF_FastCaloSimEvent/FCS_StepInfoCollection.h"
-
-// Local includes
-#include "FCS_StepInfoSD.h"
-
-namespace FCS_Param
-{
-
- namespace detail
- {
-
- //-------------------------------------------------------------------------
- // Construct with a hit collection name
- //-------------------------------------------------------------------------
- template<class SDType, class HitContainerType>
- SDWrapper<SDType, HitContainerType>::
- SDWrapper(const std::string& name, const std::string& hitCollectionName)
- : G4VSensitiveDetector(name),
- m_hitCollName(hitCollectionName),
- m_hitColl(hitCollectionName)
- {}
-
- //-------------------------------------------------------------------------
- // Add a unique SD to the list
- //-------------------------------------------------------------------------
- template<class SDType, class HitContainerType>
- void SDWrapper<SDType, HitContainerType>::
- addSD(std::unique_ptr<SDType> sd)
- {
- m_sdList.push_back( std::move(sd) );
- }
-
- //-------------------------------------------------------------------------
- // Initialize the hit collection at the beginning of the G4 event
- //-------------------------------------------------------------------------
- template<class SDType, class HitContainerType>
- void SDWrapper<SDType, HitContainerType>::
- Initialize(G4HCofThisEvent*)
- {
- if(!m_hitColl.isValid()) {
- if(verboseLevel >= 5) {
- G4cout << GetName() << " \tDEBUG\t" << "Initializing hit container: "
- << m_hitCollName << G4endl;
- }
- m_hitColl = CxxUtils::make_unique<HitContainerType>();
- }
- }
-
- //-------------------------------------------------------------------------
- // This should not be called
- //-------------------------------------------------------------------------
- template<class SDType, class HitContainerType>
- bool SDWrapper<SDType, HitContainerType>::
- ProcessHits(G4Step*, G4TouchableHistory*)
- {
- G4ExceptionDescription description;
- description << "ProcessHits: this SD shouldn't be assigned to volumes!";
- G4Exception(GetName(), "SDError", FatalException, description);
- return false;
- }
-
- //-------------------------------------------------------------------------
- // Gather the hits into the WriteHandle from all the SDs
- //-------------------------------------------------------------------------
- template<class SDType, class HitContainerType>
- void SDWrapper<SDType, HitContainerType>::
- EndOfAthenaEvent()
- {
- if(!m_hitColl.isValid()) {
- G4cerr << GetName() << " \tERROR\t" << "Hit collection WriteHandle is "
- << "invalid!" << G4endl;
- throw std::runtime_error("Invalid hit container WriteHandle: " +
- m_hitColl.name());
- }
- // Loop over each SD and fill the container
- for(auto& sd : m_sdList) {
- sd->EndOfAthenaEvent( &*m_hitColl );
- }
- }
-
- //-------------------------------------------------------------------------
- // Explit template instantiations
- //-------------------------------------------------------------------------
- template class SDWrapper<FCS_StepInfoSD, ISF_FCS_Parametrization::FCS_StepInfoCollection>;
-
- } // namespace detail
-
-} // namespace FCS_Param
diff --git a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimSD/src/SDWrapper.h b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimSD/src/SDWrapper.h
deleted file mode 100644
index ef3a248cf71..00000000000
--- a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimSD/src/SDWrapper.h
+++ /dev/null
@@ -1,94 +0,0 @@
-/*
- Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
-*/
-
-#ifndef ISF_FASTCALOSIMSD_SDWRAPPER_H
-#define ISF_FASTCALOSIMSD_SDWRAPPER_H
-
-// System includes
-#include <string>
-#include <vector>
-#include <memory>
-
-// External includes
-#include "G4VSensitiveDetector.hh"
-
-// Framework includes
-#include "StoreGate/WriteHandle.h"
-
-
-// Forward declarations
-class FCS_StepInfoSD;
-namespace ISF_FCS_Parametrization {
- class FCS_StepInfoCollection;
-}
-namespace FCS_Param
-{
-
- namespace detail
- {
-
- /// @class SDWrapper
- /// @brief A template class which wraps multiple sensitive detectors.
- ///
- /// Allows for SD tools to manage several SDs which collaborate to fill one
- /// hit container in a multi-threading-friendly way. The wrapper owns the
- /// WriteHandle for the hit container and gathers hits from each SD at the
- /// end of an event.
- ///
- /// The inheritance from G4VSensitiveDetector is merely a trick so the SD
- /// tool can save this object in the SensitiveDetectorBase thread-local
- /// container. It also allows to create the hit container at the right time
- /// via the SD Initialize method invoked by Geant4.
- ///
- /// Clients shouldn't use this generic template directly, but should use
- /// the explicitly allowed specializations given below.
- ///
- /// @author Steve Farrell <Steven.Farrell@cern.ch>
- ///
- template<class SDType, class HitContainerType>
- class SDWrapper : public G4VSensitiveDetector
- {
-
- public:
-
- /// Alias to the SD list type
- using SDList_t = std::vector< std::unique_ptr<SDType> >;
-
- /// Construct the wrapper from the output collection name
- SDWrapper(const std::string& name, const std::string& hitCollectionName);
-
- /// Add an SD to this wrapper
- void addSD(std::unique_ptr<SDType> sd);
-
- /// Beginning of G4 event; initialize the hit collection.
- virtual void Initialize(G4HCofThisEvent*) override final;
-
- /// This method should not be called. It will throw.
- virtual bool ProcessHits(G4Step*, G4TouchableHistory*) override final;
-
- /// Gather the hits into the WriteHandle from all the SDs
- void EndOfAthenaEvent();
-
- private:
-
- /// The hit container name
- std::string m_hitCollName;
-
- /// The hit container handle
- SG::WriteHandle<HitContainerType> m_hitColl;
-
- /// The list of sensitive detectors that I own and manage
- SDList_t m_sdList;
-
- }; // class SDWrapper
-
- } // namespace detail
-
-
- /// Template instantiation for LArG4SimpleSD
- using FCS_StepInfoSDWrapper = detail::SDWrapper<FCS_StepInfoSD, ISF_FCS_Parametrization::FCS_StepInfoCollection>;
-
-} // namespace FCS_Param
-
-#endif
diff --git a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimSD/src/TileFCS_StepInfoSD.cxx b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimSD/src/TileFCS_StepInfoSD.cxx
deleted file mode 100644
index 41ca1bd2cbc..00000000000
--- a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimSD/src/TileFCS_StepInfoSD.cxx
+++ /dev/null
@@ -1,100 +0,0 @@
-/*
- Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
-*/
-
-//************************************************************
-//
-// Class TileFCS_StepInfoSD
-// Sensitive detector for TileCal G4 simulations with TileGeoModel
-//
-// Author: Vakho Tsulaia <Vakhtang.Tsulaia@cern.ch>
-//
-// Major updates: July, 2013 (Sergey)
-//
-//************************************************************
-
-// class header
-#include "TileFCS_StepInfoSD.h"
-/// Geant4 headers
-#include "G4Step.hh"
-#include "G4ThreeVector.hh"
-#include "G4TouchableHistory.hh"
-
-/// Athena headers
-#include "CaloDetDescr/CaloDetDescrManager.h"
-#include "TileG4Interfaces/ITileCalculator.h"
-
-TileFCS_StepInfoSD::TileFCS_StepInfoSD(G4String name, const FCS_Param::Config & config)
- : FCS_StepInfoSD(name, config)
- , m_calculator(config.m_TileCalculator)
-{
-}
-
-TileFCS_StepInfoSD::~TileFCS_StepInfoSD() {
-}
-
-G4bool TileFCS_StepInfoSD::ProcessHits(G4Step* a_step, G4TouchableHistory* /*ROhist*/) {
- G4bool result(false);
- // If there's no energy, there's no hit. (Aside: Isn't this energy
- // the same as the energy from the calculator? Not necessarily.
- // The calculator may include detector effects such as
- // charge-collection which are not modeled by Geant4.)
- if(a_step->GetTotalEnergyDeposit() <= 0.) { return result; }
-
- if (m_calculator) {
- //calculation of MicroHit with a_step
- TileHitData hitData;
- TileMicroHit micHit = m_calculator->GetTileMicroHit(a_step, hitData);
- Identifier m_invalid_id;
-
- //Check if MicroHit is not in scintillator
- if ((micHit.pmt_up == m_invalid_id) && (micHit.pmt_down == m_invalid_id)) {
- G4cout <<this->GetName()<<" WARNING ProcessHits: Invalid hit in Tile??"<<G4endl;
- return result;
- }
- else {
- // Store TileHits Information
- if ((micHit.pmt_up == m_invalid_id) || (micHit.pmt_down == m_invalid_id)) {
- G4cout <<this->GetName()<<" WARNING ProcessHits: Something wrong in identifier: One tile pmt: "<<micHit.pmt_up<<" "<<micHit.pmt_down<<std::endl;
- G4cout <<this->GetName()<<" WARNING ProcessHits: E up: "<<micHit.e_up<<" E down: "<<micHit.e_down<<" T up: "<<micHit.time_up<<" T down: "<<micHit.time_down<<std::endl;
- }
- const G4ThreeVector pos = 0.5*(a_step->GetPreStepPoint()->GetPosition()+a_step->GetPostStepPoint()->GetPosition());
-
- this->update_map(pos, micHit.pmt_up, micHit.e_up, micHit.time_up, true,1);
- this->update_map(pos, micHit.pmt_down, micHit.e_down,micHit.time_down , true,1);
- }
- }
- return true;
-}
-
-void TileFCS_StepInfoSD::update_map(const CLHEP::Hep3Vector & l_vec, const Identifier & l_cell, double l_energy, double l_time, bool l_valid, int l_detector)
-{
- // Drop any hits that don't have a good identifier attached
- if (!m_calo_dd_man->get_element(l_cell)) { return; }
-
- auto map_item = m_hit_map.find( l_cell );
- if (map_item==m_hit_map.end()) {
- m_hit_map[l_cell] = new std::vector< ISF_FCS_Parametrization::FCS_StepInfo* >;
- m_hit_map[l_cell]->push_back( new ISF_FCS_Parametrization::FCS_StepInfo( l_vec , l_cell , l_energy , l_time , l_valid , l_detector ) );
- }
- else {
- bool match = false;
- for (auto map_it : * map_item->second) {
- // Time check
- const double delta_t = std::fabs(map_it->time()-l_time);
- if ( delta_t >= m_config.m_maxTimeTile ) { continue; }
- // Distance check
- const double hit_diff2 = map_it->position().diff2( l_vec );
- if ( hit_diff2 >= m_config.m_maxRadiusTile ) { continue; }
- // Found a match. Make a temporary that will be deleted!
- const ISF_FCS_Parametrization::FCS_StepInfo my_info( l_vec , l_cell , l_energy , l_time , l_valid , l_detector );
- *map_it += my_info;
- match = true;
- break;
- } // End of search for match in time and space
- if (!match) {
- map_item->second->push_back( new ISF_FCS_Parametrization::FCS_StepInfo( l_vec , l_cell , l_energy , l_time , l_valid , l_detector ) );
- } // Didn't match
- } // ID already in the map
-
-} // That's it for updating the map!
diff --git a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimSD/src/TileFCS_StepInfoSD.h b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimSD/src/TileFCS_StepInfoSD.h
deleted file mode 100644
index 7664e789390..00000000000
--- a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimSD/src/TileFCS_StepInfoSD.h
+++ /dev/null
@@ -1,48 +0,0 @@
-/*
- Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
-*/
-
-//************************************************************
-//
-// Class TileFCS_StepInfoSD
-// Sensitive detector for TileCal G4 simulations using TileGeoModel
-//
-// Author: Vakho Tsulaia <Vakhtang.Tsulaia@cern.ch>
-//
-// Major updates: July, 2013 (Sergey)
-//
-//************************************************************
-
-#ifndef ISF_FASTCALOSIMSD_TILEFCS_STEPINFOSD_H
-#define ISF_FASTCALOSIMSD_TILEFCS_STEPINFOSD_H
-
-// Base class header
-#include "FCS_StepInfoSD.h"
-
-class G4Step;
-class G4TouchableHistory;
-class ITileCalculator;
-
-class TileFCS_StepInfoSD: public FCS_StepInfoSD {
-public:
- TileFCS_StepInfoSD(G4String name, const FCS_Param::Config& config);
- ~TileFCS_StepInfoSD();
-
- G4bool ProcessHits(G4Step*, G4TouchableHistory*) override final;
-
- // Don't leave copy constructors or assignment operators around
- TileFCS_StepInfoSD(const TileFCS_StepInfoSD&) = delete;
- TileFCS_StepInfoSD& operator=(const TileFCS_StepInfoSD&) = delete;
-
-protected:
- /// Keep a map instead of trying to keep the full vector.
- /// At the end of the event we'll push the map back into the
- /// FCS_StepInfoCollection in StoreGate.
- virtual void update_map(const CLHEP::Hep3Vector & l_vec, const Identifier & l_cell, double l_energy, double l_time, bool l_valid, int l_detector) override final;
-
-private:
- ITileCalculator* m_calculator;
-};
-
-#endif // ISF_FASTCALOSIMSD_TILEFCS_STEPINFOSD_H
-
diff --git a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimSD/src/components/ISF_FastCaloSimSD_entries.cxx b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimSD/src/components/ISF_FastCaloSimSD_entries.cxx
deleted file mode 100644
index 0da3aea9972..00000000000
--- a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimSD/src/components/ISF_FastCaloSimSD_entries.cxx
+++ /dev/null
@@ -1,5 +0,0 @@
-#include "GaudiKernel/DeclareFactoryEntries.h"
-
-#include "../FCS_StepInfoSDTool.h"
-
-DECLARE_TOOL_FACTORY( FCS_Param::FCS_StepInfoSDTool )
--
GitLab