Merge branch 'AddSimHitSorting' into 'main'

MuonG4R4 - Add muon sim hit sorting algorithm

See merge request !66243

MuonSpectrometer/MuonG4/MuonG4SD/python/MuonG4SDConfig.py

@@ -42,4 +42,22 @@ def SetupSensitiveDetectorsCfg(flags):
         tools += [ result.popToolsAndMerge(MicromegasSensitiveDetectorCfg(flags)) ]
 
     result.setPrivateTools(tools)
-    return result
\ No newline at end of file
+    return result
+
+
+def SimHitContainerListCfg(flags):
+    simHitContainers = []
+    if flags.Detector.EnableMDT:
+        simHitContainers+=[("MDTSimHitCollection", "MDT_Hits")]
+    if flags.Detector.EnableRPC:
+        simHitContainers+=[("RPCSimHitCollection", "RPC_Hits")]
+    if flags.Detector.EnableTGC:
+        simHitContainers+=[("TGCSimHitCollection", "TGC_Hits")]
+    if flags.Detector.EnableMM:
+        simHitContainers+=[("MMSimHitCollection", "MM_Hits")]
+    if flags.Detector.EnablesTGC:
+        simHitContainers+=[("sTGCSimHitCollection", "sTGC_Hits")]
+    if flags.Detector.EnableCSC:
+        simHitContainers+=[("CSCSimHitCollection", "CSC_Hits")]
+    return simHitContainers
+

MuonSpectrometer/MuonPhaseII/MuonDetDescr/MuonGeoModelTestR4/python/testSensitiveDetectors.py

@@ -11,11 +11,14 @@ def setupTestOutputCfg(flags,**kwargs):
     # =============================
     # Define contents of the format
     # =============================
-    container_items = ["xAOD::MuonSimHitContainer#",
-                       "xAOD::MuonSimHitAuxContainer#",
-                       "xAOD::TruthParticleContainer#",
+    sim_containers = ["xMdtSimHits"]
+    container_items = ["xAOD::TruthParticleContainer#",
                        "xAOD::TruthParticleAuxContainer#",
                        "McEventCollection#"]
+    for cont in sim_containers:
+        container_items +=[ "xAOD::MuonSimHitContainer#{cont}".format(cont = cont),
+                            "xAOD::MuonSimHitAuxContainer#{cont}Aux.".format(cont = cont)]
+   
     from OutputStreamAthenaPool.OutputStreamConfig import OutputStreamCfg
     kwargs.setdefault("ItemList", container_items)
     result.merge(OutputStreamCfg(flags, **kwargs))
@@ -35,11 +38,11 @@ if __name__=="__main__":
     from G4AtlasAlg.G4AtlasAlgConfig import G4AtlasAlgCfg
     cfg.merge(G4AtlasAlgCfg(flags))
     ### Keep the Volume debugger commented for the moment
-    from G4DebuggingTools.PostIncludes import VolumeDebuggerAtlas
-    cfg.merge(VolumeDebuggerAtlas(flags, name="G4UA::UserActionSvc", 
-                                         PrintGeometry = True,
-                                         TargetVolume="BIS7_RPC26_7_0_1_1_1"
-                                        ))
+    #from G4DebuggingTools.PostIncludes import VolumeDebuggerAtlas
+    #cfg.merge(VolumeDebuggerAtlas(flags, name="G4UA::UserActionSvc", 
+    #                                     PrintGeometry = True,
+    #                                     TargetVolume="BIS7_RPC26_7_0_1_1_1"
+    #                                    ))
     
     ## xAOD TruthParticle conversion
     from xAODEventInfoCnv.xAODEventInfoCnvConfig import EventInfoCnvAlgCfg

MuonSpectrometer/MuonPhaseII/MuonG4/MuonSensitiveDetectorsR4/python/SensitiveDetectorsCfg.py

@@ -4,16 +4,26 @@ from AthenaConfiguration.ComponentFactory import CompFactory
 
 def MdtSensitiveDetectorToolCfg(flags, name = "MdtSensitiveDetector", **kwargs):
     result = ComponentAccumulator()
-    kwargs.setdefault("OutputCollectionNames", [ "xMdtSimHits"])
+    kwargs.setdefault("OutputCollectionNames", [ "xRawMdtSimHits"])
     kwargs.setdefault("LogicalVolumeNames", ["MuonR4::MDTDriftGas"])
     the_tool = CompFactory.MuonG4R4.MdtSensitiveDetectorTool(name, **kwargs)
+    from MuonSimHitSorting.MuonSimHitSortingCfg import MuonSimHitSortingAlgCfg
+    result.merge(MuonSimHitSortingAlgCfg(flags,name="MdtSimHitSorterAlg",
+                                               InContainers=["xRawMdtSimHits"],
+                                               OutContainer ="xMdtSimHits",
+                                               deepCopy = True))
     result.setPrivateTools(the_tool)
     return result
 
 def RpcSensitiveDetectorToolCfg(flags, name = "RpcSensitiveDetector", **kwargs):
     result = ComponentAccumulator()
-    kwargs.setdefault("OutputCollectionNames", [ "xRpcSimHits"])
+    kwargs.setdefault("OutputCollectionNames", [ "xRawRpcSimHits"])
     kwargs.setdefault("LogicalVolumeNames", ["MuonR4::RpcGasGap"])
+    from MuonSimHitSorting.MuonSimHitSortingCfg import MuonSimHitSortingAlgCfg
+    result.merge(MuonSimHitSortingAlgCfg(flags,name="RpcSimHitSorterAlg",
+                                               InContainers=["xRawRpcSimHits"],
+                                               OutContainer ="xRpcSimHits",
+                                               deepCopy = True))
     the_tool = CompFactory.MuonG4R4.RpcSensitiveDetectorTool(name, **kwargs)
     result.setPrivateTools(the_tool)
     return result
@@ -29,4 +39,12 @@ def SetupSensitiveDetectorsCfg(flags):
         tools += [result.popToolsAndMerge(RpcSensitiveDetectorToolCfg(flags))]
 
     result.setPrivateTools(tools)
-    return result
\ No newline at end of file
+    return result
+
+def SimHitContainerListCfg(flags):
+    simHitContainers = []
+    if flags.Detector.EnableMDT:
+        simHitContainers+=[("xAOD::MuonSimHitContainer", "xRawMdtSimHits")]
+    if flags.Detector.EnableRPC:
+        simHitContainers+=[("xAOD::MuonSimHitContainer", "xRawRpcSimHits")]
+    return simHitContainers
\ No newline at end of file

MuonSpectrometer/MuonPhaseII/MuonG4/MuonSimHitSorting/CMakeLists.txt

+################################################################################
+# Package: MuonSensitiveDetectors
+################################################################################
+
+# Declare the package name:
+atlas_subdir( MuonSimHitSorting )
+
+
+atlas_add_library( MuonSimHitSortingLib
+                   src/*.cxx
+                   OBJECT
+                   NO_PUBLIC_HEADERS MuonSimHitSorting
+                   LINK_LIBRARIES GaudiKernel StoreGateLib xAODMuonSimHit MuonIdHelpersLib)
+
+# Component(s) in the package:
+atlas_add_component( MuonSimHitSorting
+                     src/components/*.cxx                  
+                     PRIVATE_LINK_LIBRARIES MuonSimHitSortingLib )
+
+# Install files from the package:
+atlas_install_python_modules( python/*.py POST_BUILD_CMD ${ATLAS_FLAKE8} )
+

MuonSpectrometer/MuonPhaseII/MuonG4/MuonSimHitSorting/python/MuonSimHitSortingCfg.py

+# Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
+from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
+from AthenaConfiguration.ComponentFactory import CompFactory
+
+def MuonSimHitSortingAlgCfg(flags, name="MuonSimHitSortingAlg", **kwargs):
+    result = ComponentAccumulator()
+    the_alg = CompFactory.MuonSimHitSortingAlg(name, **kwargs)
+    result.addEventAlgo(the_alg, primary = True)
+    return result
\ No newline at end of file

MuonSpectrometer/MuonPhaseII/MuonG4/MuonSimHitSorting/src/MuonSimHitSortingAlg.cxx

+/*
+   Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
+*/
+#include "MuonSimHitSortingAlg.h"
+
+
+#include <AthenaBaseComps/AthReentrantAlgorithm.h>
+#include <StoreGate/ReadHandle.h>
+#include <StoreGate/WriteHandle.h>
+#include <xAODMuonSimHit/MuonSimHitAuxContainer.h>
+#include <AthContainers/ConstDataVector.h>
+
+
+MuonSimHitSortingAlg::MuonSimHitSortingAlg(const std::string& name, ISvcLocator* pSvcLocator):
+    AthReentrantAlgorithm{name, pSvcLocator} {}
+
+StatusCode MuonSimHitSortingAlg::initialize() {
+    if (m_readKeys.empty()) {
+        ATH_MSG_FATAL("Please provide at least one container to sort");
+        return StatusCode::FAILURE;
+    }
+    ATH_CHECK(m_readKeys.initialize());
+    ATH_CHECK(m_writeKey.initialize());
+    ATH_CHECK(m_idHelperSvc.retrieve());
+    return StatusCode::SUCCESS;
+}
+StatusCode MuonSimHitSortingAlg::execute(const EventContext& ctx) const {
+    ConstDataVector<xAOD::MuonSimHitContainer> allSimHits{SG::VIEW_ELEMENTS};
+    for (const SG::ReadHandleKey<xAOD::MuonSimHitContainer>& inKey : m_readKeys) {
+         SG::ReadHandle<xAOD::MuonSimHitContainer> readHandle{inKey, ctx};
+         if(!readHandle.isValid()) {
+            ATH_MSG_FATAL("Failed to retrieve "<<inKey.fullKey());
+            return StatusCode::FAILURE;
+         }
+         std::copy(readHandle->begin(), readHandle->end(), std::back_inserter(allSimHits));
+    }
+    std::stable_sort(allSimHits.begin(), allSimHits.end(),
+                    [this](const xAOD::MuonSimHit* a, const xAOD::MuonSimHit* b){
+                        return m_idHelperSvc->detElementHash(a->identify()) < 
+                               m_idHelperSvc->detElementHash(b->identify());
+                    });
+    SG::WriteHandle<xAOD::MuonSimHitContainer> writeHandle{m_writeKey, ctx};
+    if (m_writeDeepCopy) {
+        ATH_CHECK(writeHandle.record(std::make_unique<xAOD::MuonSimHitContainer>(),
+                                     std::make_unique<xAOD::MuonSimHitAuxContainer>()));
+        for (const xAOD::MuonSimHit* copy_me : allSimHits) {
+            xAOD::MuonSimHit* newHit = new xAOD::MuonSimHit();
+            writeHandle->push_back(newHit);
+            newHit->setLocalDirection(copy_me->localDirection());
+            newHit->setLocalPosition(copy_me->localPosition());
+            newHit->setStepLength(copy_me->stepLength());
+            newHit->setGlobalTime(copy_me->globalTime());
+            newHit->setPdgId(copy_me->pdgId());
+            newHit->setIdentifier(copy_me->identify());
+            newHit->setEnergyDeposit(copy_me->energyDeposit());
+            newHit->setKineticEnergy(copy_me->kineticEnergy());
+            newHit->setGenParticleLink(copy_me->genParticleLink());
+        }
+    } else {
+        ATH_CHECK(writeHandle.record(std::make_unique<xAOD::MuonSimHitContainer>(*allSimHits.asDataVector())));
+     }
+    return StatusCode::SUCCESS;    
+}

MuonSpectrometer/MuonPhaseII/MuonG4/MuonSimHitSorting/src/MuonSimHitSortingAlg.h

+/*
+   Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
+*/
+#ifndef MUONSIMHITSORTING_MUONSIMHITSORTINGALG_H
+#define MUONSIMHITSORTING_MUONSIMHITSORTINGALG_H
+
+#include <AthenaBaseComps/AthReentrantAlgorithm.h>
+#include <StoreGate/ReadHandleKeyArray.h>
+#include <StoreGate/WriteHandleKey.h>
+#include <xAODMuonSimHit/MuonSimHitContainer.h>
+#include <MuonIdHelpers/IMuonIdHelperSvc.h>
+
+class MuonSimHitSortingAlg: public AthReentrantAlgorithm{
+    public:
+        MuonSimHitSortingAlg(const std::string& name, ISvcLocator* pSvcLocator);
+
+        ~MuonSimHitSortingAlg() = default;
+
+        StatusCode execute(const EventContext& ctx) const override;
+        StatusCode initialize() override;    
+    private:
+        SG::ReadHandleKeyArray<xAOD::MuonSimHitContainer> m_readKeys{this, "InContainers", {}};
+        SG::WriteHandleKey<xAOD::MuonSimHitContainer> m_writeKey{this, "OutContainer", ""};
+
+        ServiceHandle<Muon::IMuonIdHelperSvc> m_idHelperSvc{this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"};
+        Gaudi::Property<bool> m_writeDeepCopy{this, "deepCopy", false, 
+                            "If set to true. A new xAOD container is created instead of a VIEW_ELEMENTS version"};
+};
+
+
+#endif
\ No newline at end of file

MuonSpectrometer/MuonPhaseII/MuonG4/MuonSimHitSorting/src/components/MuonSimHitSorting_entries.cxx

+/*
+   Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
+*/
+#include "../MuonSimHitSortingAlg.h"
+DECLARE_COMPONENT(MuonSimHitSortingAlg)
\ No newline at end of file

Simulation/G4Atlas/G4AtlasAlg/python/G4AtlasAlgConfig.py

@@ -2,7 +2,7 @@
 from G4AtlasServices.G4AtlasServicesConfig import DetectorGeometrySvcCfg, PhysicsListSvcCfg
 from ISF_Services.ISF_ServicesConfig import TruthServiceCfg, InputConverterCfg
 from ISF_Services.ISF_ServicesCoreConfig import GeoIDSvcCfg
-from G4AtlasTools.G4AtlasToolsConfig import SensitiveDetectorMasterToolCfg, FastSimulationMasterToolCfg
+from G4AtlasTools.G4AtlasToolsConfig import SensitiveDetectorMasterToolCfg, FastSimulationMasterToolCfg, SimHitContainerListCfg
 from G4AtlasServices.G4AtlasUserActionConfig import UserActionSvcCfg
 from SimulationConfig.SimulationMetadata import writeSimulationParametersMetadata, readSimulationParameters
 from AthenaConfiguration.ComponentFactory import CompFactory
@@ -26,6 +26,7 @@ def G4AtlasAlgCfg(flags, name="G4AtlasAlg", **kwargs):
 
     ## Don"t drop the GeoModel
     kwargs.setdefault("ReleaseGeoModel", flags.Sim.ReleaseGeoModel)
+    kwargs.setdefault("ExtraOutputs", SimHitContainerListCfg(flags))
 
     ## Record the particle flux during the simulation
     kwargs.setdefault("RecordFlux", flags.Sim.RecordFlux)

Simulation/G4Atlas/G4AtlasTools/python/G4AtlasToolsConfig.py

@@ -205,6 +205,34 @@ def EnvelopeSensitiveDetectorListCfg(flags):
     return result
 
 
+def SimHitContainerListCfg(flags):
+    writtenContainers =[]
+    if flags.Detector.GeometryMuon:
+        if flags.Muon.setupGeoModelXML:
+            from MuonSensitiveDetectorsR4.SensitiveDetectorsCfg import SimHitContainerListCfg
+            writtenContainers+= SimHitContainerListCfg(flags)
+        else:
+            from MuonG4SD.MuonG4SDConfig import SimHitContainerListCfg
+            writtenContainers += SimHitContainerListCfg(flags)
+    if flags.Detector.GeometryLAr:
+        writtenContainers += [("LArHitContainer", "LArHitEMB")]
+        writtenContainers += [("LArHitContainer", "LArHitEMEC")]
+        writtenContainers += [("LArHitContainer", "LArHitFCAL")]
+        writtenContainers += [("LArHitContainer", "LArHitHEC")]
+    if flags.Detector.GeometryTile:
+        writtenContainers += [("TileHitVector", "MBTSHits")]
+        writtenContainers += [("TileHitVector", "TileHitVec")]        
+    if flags.Detector.GeometryTRT:
+         writtenContainers += [("TRTUncompressedHitCollection", "TRTUncompressedHits")]
+    if flags.Detector.EnableBCM:
+       writtenContainers += [("SiHitCollection", "BCMHits")]
+       writtenContainers += [("SiHitCollection", "BLMHits")]
+    if flags.Detector.EnablePixel:
+       writtenContainers += [("SiHitCollection", "PixelHits")]
+    if flags.Detector.EnableSCT:
+       writtenContainers += [("SiHitCollection", "SCT_Hits")]
+    return writtenContainers
+
 def SensitiveDetectorListCfg(flags):
     result = ComponentAccumulator()
     tools = []