InnerDetector/InDetCalibAlgs/PixelCalibAlgs/share/HitMapBuilder.py

+#!/usr/bin/env python
+# -*- coding: utf-8 -*
+# Filename: HitMapBuilder.py
+# Author: Pixel DQ
+# Author: Yosuke Takubo (Yosuke.Takubo at cern.ch)
+# Project: Hit Map Tool
+# Description: ATHENA Jop Options for HitMapBuilder.py
+# Date: Jul. 2019
+# Input: inputfilelist (A list of byte stream files or pool files)
+#           or athena.py arguments --filesInput
+#           or RAW files in current directory
+# Output: A ROOT file
+###############################################################
+
+#==============================================================
+# Job options file
+#==============================================================
+doClusterization = False
+doMonitoring     = False
+doValidate       = False
+filelist         = 'inputfilelist'
+nevents          = -1
+
+from AthenaCommon.AppMgr import theApp
+from AthenaCommon.AppMgr import ServiceMgr
+from AthenaCommon.AlgSequence import AlgSequence
+topSequence = AlgSequence()
+from AthenaCommon.AppMgr import ToolSvc
+from AthenaCommon.AthenaCommonFlags import athenaCommonFlags
+
+#------------------------------------------
+# Input files
+#------------------------------------------
+import glob
+collection = []
+if len(athenaCommonFlags.FilesInput.get_Value()) != 0: # athena.py argument --filesInput ...
+    collection = athenaCommonFlags.FilesInput.get_Value()
+elif os.path.isfile(filelist): # inputfilelist
+    for line in open(filelist):
+        if line[0] != '#':
+            collection.append(line.strip())
+    athenaCommonFlags.FilesInput = collection
+elif len(glob.glob("data*TeV*RAW*")) != 0:
+    collection = glob.glob("data*TeV*RAW*") # Find data file from current directory for pathena
+    athenaCommonFlags.FilesInput = collection
+else:
+    errmess="### Unable to open input filelist: '%s'! or --FilesInput not set! or cannot find data file on current directory!" % filelist
+    raise RuntimeError(errmess)
+
+#------------------------------------------
+# DetFlags
+#------------------------------------------
+from AthenaCommon.DetFlags import DetFlags
+DetFlags.all_setOff()
+DetFlags.pixel_setOn()
+DetFlags.Print()
+
+#------------------------------------------
+# PixelDist
+#------------------------------------------
+# Conditions sequence for Athena MT
+from AthenaCommon.AlgSequence import AthSequencer
+condSeq = AthSequencer("AthCondSeq")
+
+from PixelConditionsAlgorithms.PixelConditionsAlgorithmsConf import PixelConfigCondAlg
+alg = PixelConfigCondAlg(name="PixelConfigCondAlg")
+PixelConfigCondAlg.DistortionInputSource = 0 
+alg.DistortionWriteToFile = False
+condSeq += alg
+
+print(alg)
+
+from PixelConditionsAlgorithms.PixelConditionsAlgorithmsConf import PixelDistortionAlg
+condSeq += PixelDistortionAlg(name="PixelDistortionAlg")
+#------------------------------------------
+# GlobalFlags
+#------------------------------------------
+from AthenaCommon.GlobalFlags import globalflags
+globalflags.DetDescrVersion = "ATLAS-R2-2016-01-00-01" # [SGS] how to know exact version (e.g. AMI) ?
+globalflags.DetGeo = 'atlas'
+globalflags.DataSource = 'data'
+
+# set InputFormat
+import PyUtils.AthFile as AthFile
+inputfile = AthFile.fopen( collection[0] )
+
+if inputfile.fileinfos['file_type'] == 'bs':
+    globalflags.InputFormat = 'bytestream'
+elif inputfile.fileinfos['file_type'] == 'pool':
+    globalflags.InputFormat = 'pool'
+else:
+    raise RuntimeError("Unable to read input file (format not supported)")
+
+
+# show debug info [SGS]
+print('## globalflags.InputFormat = %s' % globalflags.InputFormat)
+
+if globalflags.InputFormat() == 'pool':
+    globalflags.DetDescrVersion = inputfile.fileinfos['geometry']
+else:
+    globalflags.ConditionsTag = 'CONDBR2-BLKPA-RUN2-07'
+    globalflags.DatabaseInstance = 'CONDBR2'
+
+globalflags.print_JobProperties()
+
+#------------------------------------------
+# GeoModel
+#------------------------------------------
+from AtlasGeoModel import SetGeometryVersion
+from AtlasGeoModel import GeoModelInit
+
+#------------------------------------------
+# ByteStream
+#------------------------------------------
+include( "InDetRecExample/InDetReadBS_jobOptions.py" )
+from ByteStreamCnvSvc import ReadByteStream
+ServiceMgr.EventSelector.Input = collection
+
+from PixelReadoutGeometry.PixelReadoutGeometryConf import InDetDD__PixelReadoutManager
+PixelReadoutManager = InDetDD__PixelReadoutManager("PixelReadoutManager")
+ServiceMgr += PixelReadoutManager
+
+#------------------------------------------
+# Offline Condition
+#------------------------------------------
+if globalflags.InputFormat() == 'bytestream':
+    if len(globalflags.ConditionsTag())!=0:
+        conddb.setGlobalTag(globalflags.ConditionsTag())
+
+
+#------------------------------------------
+# histo service
+#------------------------------------------
+from GaudiSvc.GaudiSvcConf import THistSvc
+if not hasattr(ServiceMgr, 'THistSvc'):
+    ServiceMgr += THistSvc()
+THistSvc = ServiceMgr.THistSvc
+THistSvc.Output += ["histfile DATAFILE='HitMap.root' OPT='RECREATE'"]
+
+#------------------------------------------
+# HitMapBuilder algorithm
+#------------------------------------------
+from PixelCalibAlgs.PixelCalibAlgsConf import HitMapBuilder
+HitMapBuilder = HitMapBuilder()
+HitMapBuilder.LBMin = 0
+HitMapBuilder.LBMax = -1
+print(HitMapBuilder)
+topSequence += HitMapBuilder
+
+#--------------------------------------------------------------
+# Number of events
+#--------------------------------------------------------------
+#ServiceMgr.EventSelector.SkipEvents = 0
+theApp.EvtMax = nevents
+
+#--------------------------------------------------------------
+# MessageSvc
+#--------------------------------------------------------------
+ServiceMgr.MessageSvc.Format = "% F%50W%S%7W%R%T %0W%M"
+ServiceMgr.MessageSvc.defaultLimit = 9999999 # all messages
+ServiceMgr.MessageSvc.useColors = True
+
+#--------------------------------------------------------------
+# Message service output level threshold
+# (1=VERBOSE, 2=DEBUG, 3=INFO, 4=WARNING, 5=ERROR, 6=FATAL )
+#--------------------------------------------------------------
+ServiceMgr.MessageSvc.OutputLevel  = INFO
+
+#==============================================================
+# End of job options file
+#==============================================================
+

InnerDetector/InDetCalibAlgs/PixelCalibAlgs/src/components/PixelCalibAlgs_entries.cxx

 #include "PixelCalibAlgs/PixelChargeToTConversion.h"
-#include "PixelCalibAlgs/OccupancyMapMaker.h"
+#include "PixelCalibAlgs/HitMapBuilder.h"
 
 DECLARE_COMPONENT( PixelChargeToTConversion )
-DECLARE_COMPONENT( OccupancyMapMaker )
+DECLARE_COMPONENT( HitMapBuilder )
 

LArCalorimeter/LArExample/LArCalibProcessing/python/LArCalib_PhysWavePredictionConfig.py

+# Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
+
+from AthenaConfiguration.ComponentFactory import CompFactory 
+from AthenaConfiguration.MainServicesConfig import MainServicesCfg
+
+def LArPhysWavePredictionCfg(flags):
+
+    #Get basic services and cond-algos
+    from LArCalibProcessing.LArCalibBaseConfig import LArCalibBaseCfg
+    result=LArCalibBaseCfg(flags)
+
+    from LArCalibProcessing.utils import FolderTagResolver
+    FolderTagResolver._globalTag=flags.LArCalib.GlobalTag
+    rs=FolderTagResolver()
+    CaliWaveTag=rs.getFolderTag(flags.LArCalib.CaliWave.Folder)
+    DetCellParamsTag=rs.getFolderTag(flags.LArCalib.DetCellParams.Folder)
+    CaliPulseParamsTag=rs.getFolderTag(flags.LArCalib.CaliPulseParams.Folder)
+    MphysOverMcalTag=rs.getFolderTag(flags.LArCalib.MPhysOverMCal.Folder)
+    PhysWaveTag=rs.getFolderTag(flags.LArCalib.PhysWave.Folder)
+    del rs #Close database
+
+    #Retrieve inputs 
+    from IOVDbSvc.IOVDbSvcConfig import addFolders
+    result.merge(addFolders(flags,flags.LArCalib.CaliWave.Folder,detDb=flags.LArCalib.Input.Database, tag=CaliWaveTag))
+    result.merge(addFolders(flags,flags.LArCalib.CaliPulseParams.Folder,detDb=flags.LArCalib.Input.Database, tag=CaliPulseParamsTag))
+    result.merge(addFolders(flags,flags.LArCalib.DetCellParams.Folder,detDb=flags.LArCalib.Input.Database, tag=DetCellParamsTag))
+    result.merge(addFolders(flags,"/LAR/ElecCalibOfl/Tdrift/Computed",detDb="LAR_OFL",tag="LARElecCalibOflTdriftComputed-calib-03"))
+    
+
+    if flags.LArCalib.Input.SubDet == "HEC":
+        result.merge(addFolders(flags,"/LAR/ElecCalibOfl/PhysWaves/HECIdeal",detDb="LAR_OFL",db="COMP200",tag="LARElecCalibOflPhysWavesHECIdeal-calib-02"))
+
+
+    LArPhysWavePredictor = CompFactory.LArPhysWavePredictor( "LArPhysWavePredictor" )
+    LArPhysWavePredictor.ProblemsToMask= ["deadCalib","deadReadout","deadPhys","almostDead","short"]
+    LArPhysWavePredictor.TestMode      = False
+    LArPhysWavePredictor.isSC          = flags.LArCalib.isSC
+    LArPhysWavePredictor.KeyCaliList   =  [ "LArCaliWave" ]
+    LArPhysWavePredictor.UseCaliPulseParamsFromJO = False
+    LArPhysWavePredictor.UseDetCellParamsFromJO   = False
+    LArPhysWavePredictor.UseTdriftFromJO          = False
+    #LArPhysWavePredictor.Tdrift	              = TdriftVector
+    LArPhysWavePredictor.UseDoubleTriangle        = False
+    #LArPhysWavePredictor.Tdrift2	              = TdriftVector2
+    #LArPhysWavePredictor.WeightTriangle2          = TdriftWeight2
+    LArPhysWavePredictor.UseTimeShiftFromJO       = True
+    LArPhysWavePredictor.GroupingType             = flags.LArCalib.GroupingType
+    LArPhysWavePredictor.NormalizeCali	          = flags.LArCalib.Input.SubDet != "HEC"
+    LArPhysWavePredictor.KeyMphysMcali	          = "LArMphysOverMcal"
+    LArPhysWavePredictor.DumpMphysMcali           = False # set to True to dump on a ASCII file
+    LArPhysWavePredictor.KeyPhys                  = "LArPhysWave"
+    LArPhysWavePredictor.isHEC                    = flags.LArCalib.Input.SubDet == "HEC"
+
+    result.addEventAlgo(LArPhysWavePredictor)
+    
+    if (flags.LArCalib.Input.SubDet == "HEC"):
+        LArPhysWaveHECTool=CompFactory.LArPhysWaveHECTool()
+        LArPhysWaveHECTool.NormalizeCali     = False  
+        LArPhysWaveHECTool.TimeOriginShift   = False
+        LArPhysWaveHECTool.SubtractBaseline  = False
+        result.addPublicTool(LArPhysWaveHECTool)
+
+
+    else: #not HEC but EM:
+        LArPhysWaveTool=CompFactory.LArPhysWaveTool()
+        LArPhysWaveTool.NormalizeCali     = False # this is taken care by LArPhysWavePredictor
+        LArPhysWaveTool.TimeOriginShift   = False
+        LArPhysWaveTool.SubtractBaseline  = False
+        LArPhysWaveTool.InjPointCorrLayer = [ 1, 1, 1, 1 ]
+        LArPhysWaveTool.InjPointUseTauR   = [ 1, 1, 1, 1 ]
+        result.addPublicTool(LArPhysWaveTool)
+   
+ 
+    rootfile=flags.LArCalib.Output.ROOTFile
+    if rootfile != "":
+      LArPhysWaves2Ntuple              = CompFactory.LArPhysWaves2Ntuple("LArPhysWaves2Ntuple")
+      LArPhysWaves2Ntuple.NtupleName   = "PHYSWAVE" 
+      LArPhysWaves2Ntuple.AddFEBTempInfo   = False  
+      LArPhysWaves2Ntuple.KeyList      = [ "LArPhysWave"  ]
+      LArPhysWaves2Ntuple.isSC = flags.LArCalib.isSC
+      result.addEventAlgo(LArPhysWaves2Ntuple)
+
+      LArMphysOverMcal2Ntuple                = CompFactory.LArMphysOverMcal2Ntuple( "LArMphysOverMcal2Ntuple" )
+      LArMphysOverMcal2Ntuple.ContainerKey   = "LArMphysOverMcal"
+      LArMphysOverMcal2Ntuple.AddFEBTempInfo   = False
+      LArMphysOverMcal2Ntuple.isSC = flags.LArCalib.isSC
+      result.addEventAlgo(LArMphysOverMcal2Ntuple)
+
+      import os
+      if os.path.exists(rootfile):
+          os.remove(rootfile)
+      result.addService(CompFactory.NTupleSvc(Output = [ "FILE1 DATAFILE='"+rootfile+"' OPT='NEW'" ]))
+      result.setAppProperty("HistogramPersistency","ROOT")
+    pass # end if ROOT ntuple writing
+    
+
+    from RegistrationServices.OutputConditionsAlgConfig import OutputConditionsAlgCfg
+    result.merge(OutputConditionsAlgCfg(flags,
+                                        outputFile=flags.LArCalib.Output.POOLFile,
+                                        ObjectList=["LArPhysWaveContainer#LArPhysWave#"+flags.LArCalib.PhysWave.Folder,
+                                                    "LArMphysOverMcalComplete#LArMphysOverMcal#"+flags.LArCalib.MPhysOverMCal.Folder,],
+                                        IOVTagList=[PhysWaveTag,MphysOverMcalTag]
+                                    ))
+
+    #RegistrationSvc    
+    result.addService(CompFactory.IOVRegistrationSvc(RecreateFolders = False))
+    result.getService("IOVDbSvc").DBInstance=""
+
+    #MC Event selector since we have no input data file 
+    mcCnvSvc = CompFactory.McCnvSvc()
+    cfg.addService(mcCnvSvc)
+    cfg.addService(CompFactory.EvtPersistencySvc("EventPersistencySvc",CnvServices=[mcCnvSvc.getFullJobOptName(),]))
+    eventSelector=CompFactory.McEventSelector("EventSelector",
+                                              RunNumber = flags.LArCalib.Input.RunNumbers[0],
+                                              EventsPerRun      = 1,
+                                              FirstEvent	       = 0,
+                                              InitialTimeStamp  = 0,
+                                              TimeStampInterval = 1
+                                          )
+
+    result.addService(eventSelector)
+    return result
+
+
+
+if __name__ == "__main__":
+
+
+    from AthenaConfiguration.AllConfigFlags import ConfigFlags
+    from LArCalibProcessing.LArCalibConfigFlags import addLArCalibFlags
+    addLArCalibFlags(ConfigFlags)
+
+
+
+    ConfigFlags.LArCalib.Input.RunNumbers=[401351,]
+    ConfigFlags.LArCalib.Input.Database="/home/wlampl/calibTest/00400939_00400943_00400945_Barrel-EMB-EMEC_HIGH_40_21.0.20_1/poolFiles/myDB200_00400939_00400943_00400945_EB-EMBA_one.db_Delay"
+    ConfigFlags.LArCalib.Input.SubDet="EM"
+    ConfigFlags.LArCalib.BadChannelDB="/home/wlampl/calibTest/00400939_00400943_00400945_Barrel-EMB-EMEC_HIGH_40_21.0.20_1/poolFiles/SnapshotBadChannel_00400939_00400943_00400945_EB-EMBA.db"
+    ConfigFlags.LArCalib.BadChannelTag="-RUN2-UPD3-00"
+    ConfigFlags.LArCalib.Output.ROOTFile="physwave.root"
+    ConfigFlags.IOVDb.DatabaseInstance="CONDBR2"
+    ConfigFlags.IOVDb.DBConnection="sqlite://;schema=output.sqlite;dbname=CONDDBR2"
+    ConfigFlags.IOVDb.GlobalTag="LARCALIB-RUN2-02"
+    #ConfigFlags.Exec.OutputLevel=1
+
+    cfg=MainServicesCfg(ConfigFlags)
+    cfg.merge(LArPhysWavePredictionCfg(ConfigFlags))
+
+    print("Start running...")
+    cfg.run(1)

MuonSpectrometer/MuonConfig/python/MuonRIO_OnTrackCreatorConfig.py

@@ -98,7 +98,7 @@ def MdtDriftCircleOnTrackCreatorCfg(flags,name="MdtDriftCircleOnTrackCreator", *
     
     kwargs.setdefault("IsMC", flags.Input.isMC)
 
-    result.addPublicTool(Muon__MdtDriftCircleOnTrackCreator(name, WasConfigured=True, **kwargs),primary=True)
+    result.setPrivateTools(Muon__MdtDriftCircleOnTrackCreator(name, WasConfigured=True, **kwargs))
     return result
     
 def MuonClusterOnTrackCreatorCfg(flags,name="MuonClusterOnTrackCreator", **kwargs):
@@ -109,7 +109,7 @@ def MuonClusterOnTrackCreatorCfg(flags,name="MuonClusterOnTrackCreator", **kwarg
         kwargs.setdefault("FixedErrorTgcEta", 15.)
     
     muon_cluster_rot_creator = Muon__MuonClusterOnTrackCreator(name, **kwargs)
-    result.addPublicTool(muon_cluster_rot_creator, primary=True)
+    result.setPrivateTools(muon_cluster_rot_creator)
     return result
 
     
@@ -144,6 +144,6 @@ def MuonRotCreatorCfg(flags, name="MuonRotCreator", **kwargs):
     kwargs.setdefault("Mode", 'muon' )
     
     muon_rot_creator = Trk__RIO_OnTrackCreator(name, **kwargs)
-    result.addPublicTool(muon_rot_creator,primary=True)
+    result.setPrivateTools(muon_rot_creator)
     return result
     

MuonSpectrometer/MuonConfig/python/MuonSegmentFindingConfig.py

@@ -183,8 +183,7 @@ def DCMathSegmentMakerCfg(flags, **kwargs):
     if doSegmentT0Fit:
         mdt_dcot_CA = MdtDriftCircleOnTrackCreatorCfg(flags, name="MdtDriftCircleOnTrackCreatorAdjustableT0", TimingMode=3, \
                    DoTofCorrection=True, TimeWindowSetting=MdtCalibWindowNumber('Collision_data'))
-        result.merge(mdt_dcot_CA)
-        kwargs.setdefault("MdtCreatorT0", mdt_dcot_CA.getPrimary()) # TODO - is this correct? 
+        kwargs.setdefault("MdtCreatorT0", result.getPrimaryAndMerge(mdt_dcot_CA)) # TODO - is this correct? 
         mdt_math_segment_finder = result.popToolsAndMerge(MdtMathSegmentFinderCfg(flags, doSegmentT0Fit=True))
     else:
         mdt_math_segment_finder = result.popToolsAndMerge(MdtMathSegmentFinderCfg(flags))
@@ -208,9 +207,7 @@ def DCMathSegmentMakerCfg(flags, **kwargs):
     kwargs.setdefault("MuonStationIntersectSvc", muon_station_intersect_svc)
 
     acc=MdtDriftCircleOnTrackCreatorCfg(flags)
-    kwargs.setdefault("MdtCreator", acc.getPrimary())
-    result.merge(acc)
-
+    kwargs.setdefault("MdtCreator", result.getPrimaryAndMerge(acc))
     
     acc=MuonClusterOnTrackCreatorCfg(flags)
     muon_cluster_creator=acc.getPrimary()
@@ -272,8 +269,7 @@ def MuonPatternSegmentMakerCfg(flags, **kwargs):
             # I think we need to configure a 'default' version of the MdtDriftCircleOnTrackCreator here
             acc=MdtDriftCircleOnTrackCreatorCfg(flags)
 
-        result.merge(acc)
-        kwargs.setdefault('MdtCreator', acc.getPrimary())
+        kwargs.setdefault('MdtCreator', result.getPrimaryAndMerge(acc))
     #else:
     # TODO work out what to do here
     

MuonSpectrometer/MuonGeoModel/MuonGeoModel/MuonDetectorFactory001.h

@@ -5,9 +5,9 @@
 #ifndef MuonDetectorFactory001_H
 #define MuonDetectorFactory001_H
 
-#include "GeoModelKernel/GeoVDetectorFactory.h"
 #include "MuonReadoutGeometry/MuonDetectorManager.h"
-
+///
+#include "GeoModelKernel/GeoVDetectorFactory.h"
 #include <string>
 
 class GeoPhysVol;
@@ -35,13 +35,13 @@ namespace MuonGM {
         virtual const MuonDetectorManager *getDetectorManager() const override;
         MuonDetectorManager *getDetectorManager();
 
-        inline void setDBAtlasVersion(const std::string& v);
-        inline void setDBMuonVersion(const std::string& v);
-        inline void setDBkey(const std::string& v);
-        inline void setDBnode(const std::string& v);
+        inline void setDBAtlasVersion(const std::string&v);
+        inline void setDBMuonVersion(const std::string&v);
+        inline void setDBkey(const std::string&v);
+        inline void setDBnode(const std::string&v);
 
         inline void setAmdcDb(bool value);
-        inline void setLayout(const std::string&);
+        inline void setLayout(const std::string& str);
         inline void setCutoutsFlag(int);
         inline void setCutoutsBogFlag(int);
         inline void setCtbBisFlag(int);
@@ -70,55 +70,60 @@ namespace MuonGM {
         inline void setABLinesAsciiSideC(const std::string &);
 
       private:
-        std::string m_DBAtlasVersion;
-        std::string m_DBMuonVersion;
-        std::string m_DBkey;
-        std::string m_DBnode;
-
-        bool m_isAmdcDb;
-        std::string m_layout;
-        int m_includeCutouts;
-        int m_includeCutoutsBog;
-        int m_includeCtbBis;
-        int m_rdb;
-        int m_controlAlines;
-        int m_minimalGeoFlag;
-        int m_controlCscIntAlines;
-        bool m_dumpAlines;
-        bool m_dumpCscIntAlines;
-        bool m_useCscIntAlinesFromGM;
-
-        int m_caching;
-        int m_cacheFillingFlag;
-        int m_mdtDeformationFlag;
+
+    
+        std::string m_DBAtlasVersion{};
+        std::string m_DBMuonVersion{};
+        std::string m_DBkey{};
+        std::string m_DBnode{};
+
+        bool m_isAmdcDb{false};
+        std::string m_layout{};
+        int m_includeCutouts{0};
+        int m_includeCutoutsBog{0};
+        int m_includeCtbBis{0};
+        int m_rdb{1};
+        int m_controlAlines{0};
+        int m_minimalGeoFlag{0};
+        int m_controlCscIntAlines{0};
+        bool m_dumpAlines{false};
+        bool m_dumpCscIntAlines{false};
+        bool m_useCscIntAlinesFromGM{true};
+
+    
+    
+
+        int m_caching{0};
+        int m_cacheFillingFlag{0};
+        int m_mdtDeformationFlag{0};
         int m_mdtAsBuiltParaFlag;
-        bool m_dumpMemoryBreakDown;
-        int m_enableFineClashFixing;
-        bool m_hasCSC;
-        bool m_hasSTgc;
-        bool m_hasMM;
+        bool m_dumpMemoryBreakDown{false};
+        int m_enableFineClashFixing{0};
+        bool m_hasCSC{true};
+        bool m_hasSTgc{true};
+        bool m_hasMM{true};
 
-        std::string m_NSWABLinesSideA;
-        std::string m_NSWABLinesSideC;
+        std::string m_NSWABLinesSideA{};
+        std::string m_NSWABLinesSideC{};
 
         std::vector<std::string> m_selectedStations;
         std::vector<int> m_selectedStEta;
         std::vector<int> m_selectedStPhi;
 
-        MuonSystemDescription *m_muon;
-        MuonDetectorManager *m_manager;
-        StoreGateSvc *m_pDetStore;
-        IRDBAccessSvc *m_pRDBAccess;
-        AltAsciiDBMap m_altAsciiDBMap;
+        std::unique_ptr<MuonSystemDescription> m_muon;
+        MuonDetectorManager* m_manager{nullptr};
+        StoreGateSvc *m_pDetStore{nullptr};
+        IRDBAccessSvc *m_pRDBAccess{nullptr};
+        AltAsciiDBMap m_altAsciiDBMap{};
     };
 
-    void MuonDetectorFactory001::setDBAtlasVersion(const std::string& v) { m_DBAtlasVersion = v; }
-    void MuonDetectorFactory001::setDBMuonVersion(const std::string& v) { m_DBMuonVersion = v; }
-    void MuonDetectorFactory001::setDBkey(const std::string& v) { m_DBkey = v; }
-    void MuonDetectorFactory001::setDBnode(const std::string& v) { m_DBnode = v; }
+    void MuonDetectorFactory001::setDBAtlasVersion(const std::string&v) { m_DBAtlasVersion = v; }
+    void MuonDetectorFactory001::setDBMuonVersion(const std::string&v) { m_DBMuonVersion = v; }
+    void MuonDetectorFactory001::setDBkey(const std::string&v) { m_DBkey = v; }
+    void MuonDetectorFactory001::setDBnode(const std::string&v) { m_DBnode = v; }
 
     void MuonDetectorFactory001::setAmdcDb(bool value) { m_isAmdcDb = value; }
-    void MuonDetectorFactory001::setLayout(const std::string& str) { m_layout = str; }
+    void MuonDetectorFactory001::setLayout(const std::string&str) { m_layout = str; }
     void MuonDetectorFactory001::setCutoutsFlag(int flag) { m_includeCutouts = flag; }
     void MuonDetectorFactory001::setCutoutsBogFlag(int flag) { m_includeCutoutsBog = flag; }
     void MuonDetectorFactory001::setCtbBisFlag(int flag) { m_includeCtbBis = flag; }

MuonSpectrometer/MuonGeoModel/src/MuonDetectorFactory001.cxx

@@ -72,11 +72,9 @@ using namespace GeoXF;
 
 namespace MuonGM {
 
-    MuonDetectorFactory001::MuonDetectorFactory001(StoreGateSvc *pDetStore)
-        : m_includeCutouts(0), m_includeCutoutsBog(0), m_includeCtbBis(0), m_rdb(1), m_controlAlines(0), m_minimalGeoFlag(0), m_controlCscIntAlines(0), m_dumpAlines(false),
-          m_dumpCscIntAlines(false), m_useCscIntAlinesFromGM(true), m_caching(0), m_cacheFillingFlag(0), m_mdtDeformationFlag(0), m_mdtAsBuiltParaFlag(0),
-          m_dumpMemoryBreakDown(false), m_hasCSC(true), m_hasSTgc(true), m_hasMM(true), m_muon(NULL), m_manager(NULL), m_pDetStore(pDetStore), m_pRDBAccess(0) {
-        m_muon = new MuonSystemDescription("MuonSystem");
+    MuonDetectorFactory001::MuonDetectorFactory001(StoreGateSvc *pDetStore):
+        m_pDetStore{pDetStore} {
+        m_muon = std::make_unique< MuonSystemDescription>("MuonSystem");
         m_muon->barrelInnerRadius = 4.30 * Gaudi::Units::m;
         m_muon->innerRadius = 0.07 * Gaudi::Units::m;
         m_muon->outerRadius = 13.00 * Gaudi::Units::m;
@@ -87,18 +85,12 @@ namespace MuonGM {
         m_muon->extraZ = 12.9 * Gaudi::Units::m;
         m_muon->extraR = 12.5 * Gaudi::Units::m;
 
-        m_selectedStations = std::vector<std::string>(0);
-        m_selectedStEta = std::vector<int>(0);
-        m_selectedStPhi = std::vector<int>(0);
-
-        m_enableFineClashFixing = 0;
-
         MsgStream log(Athena::getMessageSvc(), "MuonGeoModel");
         log << MSG::INFO << "MuonDetectorFactory - constructor "
             << " MuonSystem OuterRadius " << m_muon->outerRadius << " Length " << m_muon->length << endmsg;
     }
 
-    MuonDetectorFactory001::~MuonDetectorFactory001() { delete m_muon; }
+    MuonDetectorFactory001::~MuonDetectorFactory001() =default;
 
     const MuonDetectorManager *MuonDetectorFactory001::getDetectorManager() const { return m_manager; }
     MuonDetectorManager *MuonDetectorFactory001::getDetectorManager() { return m_manager; }
@@ -127,7 +119,7 @@ namespace MuonGM {
         } // if (m_dumpMemoryBreakDown) {
 
         if (!m_manager)
-            m_manager = new MuonDetectorManager();
+            m_manager = new  MuonDetectorManager();
 
         // check consistency of flags coming from the tool
         m_includeCutouts = 1;
@@ -241,7 +233,7 @@ namespace MuonGM {
         if (log.level() <= MSG::DEBUG)
             log << MSG::DEBUG << "calling RDBReaderAtlas with m_altAsciiDBMap" << endmsg;
 
-        RDBReaderAtlas *dbr = new RDBReaderAtlas(m_pDetStore, m_pRDBAccess, OracleTag, OracleNode, m_dumpAlines, m_useCscIntAlinesFromGM, m_dumpCscIntAlines, &m_altAsciiDBMap);
+        std::unique_ptr<RDBReaderAtlas> dbr =std::make_unique< RDBReaderAtlas>(m_pDetStore, m_pRDBAccess, OracleTag, OracleNode, m_dumpAlines, m_useCscIntAlinesFromGM, m_dumpCscIntAlines, &m_altAsciiDBMap);
 
         dbr->setControlCscIntAlines(m_controlCscIntAlines);
 
@@ -255,16 +247,13 @@ namespace MuonGM {
         mysql->setControlAlines(m_controlAlines);
 
         dbr->setGeometryVersion(m_layout);
-        dbr->setManager(m_manager);
+        dbr->setManager(getDetectorManager());
         sc = dbr->ProcessDB(*mysql);
         if (sc != StatusCode::SUCCESS) {
             log << MSG::ERROR << " FAILURE in DB access; Muon node will not be built" << endmsg;
             return;
         }
-        // release memory
-        delete dbr;
-        dbr = nullptr;
-
+       
         if (m_dumpMemoryBreakDown) {
             umem = GeoPerfUtils::getMem();
             ucpu = int(GeoPerfUtils::getCpu() / 100.);
@@ -462,13 +451,13 @@ namespace MuonGM {
         log << MSG::INFO << " Muon Layout " << m_layout << endmsg;
 
         std::vector<std::string> slist;
-        if (m_selectedStations.size() <= 0)
+        if (m_selectedStations.empty())
             slist.push_back("*");
         else
             slist = m_selectedStations;
 
         // create the fullphysvol map to allow cloning and save memory
-        FPVMAP *savemem = new FPVMAP();
+        std::unique_ptr<FPVMAP> savemem = std::make_unique< FPVMAP>();
 
         int nstat_ss = 0;
         int ntpos_ss = 0;
@@ -504,7 +493,7 @@ namespace MuonGM {
                 isAssembly = true;
 
             MuonChamber l(*mysql, station); // here is where we start to create a MuonChamber with all readoutelements
-            l.setFPVMAP(savemem);
+            l.setFPVMAP(savemem.get());
             l.setFineClashFixingFlag(m_enableFineClashFixing);
 
             PositionIterator pit;
@@ -567,7 +556,7 @@ namespace MuonGM {
                     isAssembly = true;
 
                 // CSL because coffin shape of the station mother volume
-                GeoVPhysVol *pv = l.build(*theMaterialManager, *mysql, m_manager, zi, fi, is_mirrored, isAssembly);
+                GeoVPhysVol *pv = l.build(*theMaterialManager, *mysql, getDetectorManager(), zi, fi, is_mirrored, isAssembly);
                 if (isAssembly)
                     nAssemblies++;
 
@@ -602,7 +591,7 @@ namespace MuonGM {
 
                 // alignment issues and readout geometry for station
                 MuonStation *mst = m_manager->getMuonStation(station->GetName(), zi, fi + 1);
-                if (mst == NULL) {
+                if (!mst) {
                     log << MSG::WARNING << "For Station with nameTag=<" << station->GetName() << "> at zi/fi = " << zi << "/" << fi
                         << " no MuonStation found => no possibility to align" << endmsg;
                     continue;
@@ -689,10 +678,7 @@ namespace MuonGM {
             cpu = ucpu;
         }
 
-        // delete the fullphysvol map
-        delete savemem;
-        savemem = nullptr;
-
+      
         // delete the station and technology map
         delete mysql.get();
 

PhysicsAnalysis/Algorithms/AsgAnalysisAlgorithms/AsgAnalysisAlgorithms/AsgClassificationDecorationAlg.h

@@ -8,8 +8,8 @@
 #define ASG_ANALYSIS_ALGORITHMS__ASG_CLASSIFICATION_DECORATION_ALG_H
 
 #include <AnaAlgorithm/AnaAlgorithm.h>
-#include <SystematicsHandles/SysCopyHandle.h>
 #include <SystematicsHandles/SysListHandle.h>
+#include <SystematicsHandles/SysReadHandle.h>
 #include <xAODBase/IParticle.h>
 #include <xAODBase/IParticleContainer.h>
 
@@ -46,7 +46,7 @@ private:
 
   /// \brief particles container handle
 private:
-  CP::SysCopyHandle<xAOD::IParticleContainer> m_particlesHandle {
+  CP::SysReadHandle<xAOD::IParticleContainer> m_particlesHandle {
     this, "particles", "", "the container to use"};
 
   /// \brief the decoration for the truth classification
@@ -55,7 +55,7 @@ private:
 
   /// \brief the accessor for \ref m_truthClassificationDecoration
 private:
-  std::unique_ptr<const SG::AuxElement::Accessor<unsigned int> > m_classificationAccessor {};
+  std::unique_ptr<const SG::AuxElement::Decorator<unsigned int> > m_classificationDecorator {};
 };
 
 } // namespace CP

PhysicsAnalysis/Algorithms/AsgAnalysisAlgorithms/AsgAnalysisAlgorithms/AsgEventScaleFactorAlg.h

@@ -56,6 +56,11 @@ namespace CP
     SelectionReadHandle m_preselection {
       this, "preselection", "", "the preselection to apply"};
 
+    /// \brief the decoration for reading systematically aware preselection
+  private:
+    SysReadDecorHandle<char> m_inputSelectionDecoration {
+      this, "inputSelectionDecoration", "", "the decoration for the input selection flag"};
+
     /// \brief the decoration for reading the scale factor
   private:
     SysReadDecorHandle<float> m_scaleFactorInputDecoration {

PhysicsAnalysis/Algorithms/AsgAnalysisAlgorithms/AsgAnalysisAlgorithms/AsgLeptonTrackSelectionAlg.h

@@ -13,8 +13,9 @@
 #include <PATCore/IAsgSelectionTool.h>
 #include <SelectionHelpers/ISelectionAccessor.h>
 #include <SelectionHelpers/SelectionReadHandle.h>
-#include <SystematicsHandles/SysCopyHandle.h>
 #include <SystematicsHandles/SysListHandle.h>
+#include <SystematicsHandles/SysReadHandle.h>
+#include <xAODBase/IParticleContainer.h>
 
 namespace CP
 {
@@ -69,7 +70,7 @@ namespace CP
 
     /// \brief the particle continer we run on
   private:
-    SysCopyHandle<xAOD::IParticleContainer> m_particlesHandle {
+    SysReadHandle<xAOD::IParticleContainer> m_particlesHandle {
       this, "particles", "", "the asg collection to run on"};
 
     /// \brief the preselection we apply to our input

PhysicsAnalysis/Algorithms/AsgAnalysisAlgorithms/AsgAnalysisAlgorithms/AsgxAODNTupleMakerAlg.h

@@ -14,6 +14,7 @@
 
 // Framework include(s):
 #include "AsgMessaging/AsgMessaging.h"
+#include "AsgServices/ServiceHandle.h"
 #include "AnaAlgorithm/AnaAlgorithm.h"
 #include "SystematicsHandles/SysListHandle.h"
 
@@ -356,8 +357,8 @@ namespace CP {
       ///
       bool m_isInitialized = false;
 
-      /// The systematic list to consider during execution
-      SysListHandle m_systematicsList{ this };
+      /// \brief the handle for the systematics service
+      ServiceHandle<ISystematicsSvc> m_systematicsService {"SystematicsSvc", ""};
 
       /// @}
 

PhysicsAnalysis/Algorithms/AsgAnalysisAlgorithms/AsgAnalysisAlgorithms/OverlapRemovalAlg.h

@@ -12,6 +12,7 @@
 #include <AssociationUtils/ToolBox.h>
 #include <SystematicsHandles/SysCopyHandle.h>
 #include <SystematicsHandles/SysListHandle.h>
+#include <SystematicsHandles/SysWriteDecorHandle.h>
 
 namespace CP
 {
@@ -55,6 +56,30 @@ namespace CP
       this, "photons", "", "the photons container to use"};
     SysCopyHandle<xAOD::JetContainer> m_fatJetsHandle {
       this, "fatJets", "", "the fat jets container to use"};
+
+    /// \brief the decoration for the overlap removal status
+  private:
+    SysWriteDecorHandle<char> m_electronsDecoration {
+      this, "electronsDecoration", "", "the decoration for the electron overlap removal selection"};
+    SysWriteDecorHandle<char> m_muonsDecoration {
+      this, "muonsDecoration", "", "the decoration for the muon overlap removal selection"};
+    SysWriteDecorHandle<char> m_jetsDecoration {
+      this, "jetsDecoration", "", "the decoration for the jet overlap removal selection"};
+    SysWriteDecorHandle<char> m_tausDecoration {
+      this, "tausDecoration", "", "the decoration for the tau overlap removal selection"};
+    SysWriteDecorHandle<char> m_photonsDecoration {
+      this, "photonsDecoration", "", "the decoration for the photon overlap removal selection"};
+    SysWriteDecorHandle<char> m_fatJetsDecoration {
+      this, "fatJetsDecoration", "", "the decoration for the fat jet overlap removal selection"};
+
+    /// \brief the tool output decoration for the overlap removal status
+  private:
+    std::string m_overlapRemovalDecoration;
+
+    /// \brief the accessor for \ref m_overlapRemovalDecoration
+  private:
+    std::unique_ptr<const SG::AuxElement::Accessor<char> > m_overlapRemovalAccessor;
+
   };
 }
 

PhysicsAnalysis/Algorithms/AsgAnalysisAlgorithms/Root/AsgClassificationDecorationAlg.cxx

@@ -29,7 +29,7 @@ StatusCode AsgClassificationDecorationAlg::initialize()
     return StatusCode::FAILURE;
   }
 
-  m_classificationAccessor = std::make_unique<SG::AuxElement::Accessor<unsigned int> > (m_classificationDecoration);
+  m_classificationDecorator = std::make_unique<SG::AuxElement::Decorator<unsigned int> > (m_classificationDecoration);
 
   ANA_CHECK (m_particlesHandle.initialize (m_systematicsList));
   ANA_CHECK(m_systematicsList.initialize());
@@ -45,13 +45,14 @@ StatusCode AsgClassificationDecorationAlg::execute()
 {
   for (const auto& sys : m_systematicsList.systematicsVector())
   {
-    xAOD::IParticleContainer *particles{};
-    ANA_CHECK(m_particlesHandle.getCopy(particles, sys));
+    const xAOD::IParticleContainer *particles{};
+    ANA_CHECK(m_particlesHandle.retrieve(particles, sys));
 
-    for (xAOD::IParticle *particle : *particles) {
+    for (const xAOD::IParticle *particle : *particles)
+    {
       unsigned int classification{};
       ANA_CHECK(m_tool->classify(*particle, classification));
-      (*m_classificationAccessor)(*particle) = classification;
+      (*m_classificationDecorator)(*particle) = classification;
     }
   }
   return StatusCode::SUCCESS;

PhysicsAnalysis/Algorithms/AsgAnalysisAlgorithms/Root/AsgEventScaleFactorAlg.cxx

@@ -11,8 +11,6 @@
 
 #include <AsgAnalysisAlgorithms/AsgEventScaleFactorAlg.h>
 
-// #include <SelectionHelpers/SelectionHelpers.h>
-
 //
 // method implementations
 //
@@ -39,6 +37,7 @@ namespace CP
 
     ANA_CHECK (m_eventInfoHandle.initialize (m_systematicsList));
     ANA_CHECK (m_particleHandle.initialize (m_systematicsList));
+    ANA_CHECK (m_inputSelectionDecoration.initialize (m_systematicsList, m_particleHandle, SG::AllowEmpty));
     ANA_CHECK (m_scaleFactorInputDecoration.initialize (m_systematicsList, m_particleHandle));
     ANA_CHECK (m_scaleFactorOutputDecoration.initialize (m_systematicsList, m_eventInfoHandle));
     ANA_CHECK (m_systematicsList.initialize());
@@ -65,6 +64,9 @@ namespace CP
       {
         if (m_preselection.getBool (*particle))
         {
+          if (m_inputSelectionDecoration && m_inputSelectionDecoration.get (*particle, sys) == 0)
+            continue;
+
           scaleFactor *= m_scaleFactorInputDecoration.get (*particle, sys);
         }
       }

PhysicsAnalysis/Algorithms/AsgAnalysisAlgorithms/Root/AsgLeptonTrackSelectionAlg.cxx

@@ -116,9 +116,9 @@ namespace CP
 
     for (const auto& sys : m_systematicsList.systematicsVector())
     {
-      xAOD::IParticleContainer *particles = nullptr;
-      ANA_CHECK (m_particlesHandle.getCopy (particles, sys));
-      for (xAOD::IParticle *particle : *particles)
+      const xAOD::IParticleContainer *particles = nullptr;
+      ANA_CHECK (m_particlesHandle.retrieve (particles, sys));
+      for (const xAOD::IParticle *particle : *particles)
       {
         asg::AcceptData acceptData (&m_accept);
 
@@ -127,9 +127,9 @@ namespace CP
           std::size_t cutIndex {0};
 
           const xAOD::TrackParticle *track {nullptr};
-          if (const xAOD::Muon *muon = dynamic_cast<xAOD::Muon*>(particle))
+          if (const xAOD::Muon *muon = dynamic_cast<const xAOD::Muon *>(particle))
             track = muon->primaryTrackParticle();
-          else if (const xAOD::Electron *electron = dynamic_cast<xAOD::Electron*>(particle))
+          else if (const xAOD::Electron *electron = dynamic_cast<const xAOD::Electron *>(particle))
             track = electron->trackParticle();
           else
           {

PhysicsAnalysis/Algorithms/AsgAnalysisAlgorithms/Root/AsgxAODNTupleMakerAlg.cxx

@@ -308,6 +308,8 @@ namespace CP {
                        "Name of the tree to write" );
       declareProperty( "Branches", m_branches,
                        "Branches to write to the output tree" );
+      declareProperty( "systematicsService", m_systematicsService,
+                       "systematics service" );
    }
 
    StatusCode AsgxAODNTupleMakerAlg::initialize() {
@@ -319,7 +321,7 @@ namespace CP {
       }
 
       // Set up the systematics list.
-      ATH_CHECK( m_systematicsList.initialize() );
+      ATH_CHECK( m_systematicsService.retrieve() );
 
       // Reset the initialisation flag:
       m_isInitialized = false;
@@ -396,7 +398,7 @@ namespace CP {
       }
 
       // Consider all systematics but skip the nominal one
-      for( const auto& sys : m_systematicsList.systematicsVector() ) {
+      for( const auto& sys : m_systematicsService->makeSystematicsVector() ) {
          // Nominal already processed
          if( sys.empty() ) {
             continue;
@@ -439,18 +441,56 @@ namespace CP {
 
       // Check if we are running nominal
       bool nominal = sys.empty();
+      // Check if we are affected by the systematics
+      bool systematicsContainer{false};
+      bool systematicsDecoration{false};
+      bool affectedContainer{true};
+      bool affectedDecoration{true};
 
       // Event store key for the object under consideration.
-      std::string key;
-      ANA_CHECK (m_systematicsList.service().makeSystematicsName( key, match[ 1 ], sys ));
+      std::string key = match[ 1 ];
+      if( key.find( "%SYS%" ) != std::string::npos )
+      {
+         systematicsContainer = true;
+         const CP::SystematicSet affecting = m_systematicsService->getObjectSystematics( key );
+         CP::SystematicSet matching;
+         ANA_CHECK( SystematicSet::filterForAffectingSystematics( sys, affecting, matching ) );
+         if( !nominal && matching.empty() ) {
+            ATH_MSG_VERBOSE( "Container \"" << key << "\" is not affected by systematics \"" << sys.name() << "\"" );
+            affectedContainer = false;
+         }
+         ANA_CHECK( m_systematicsService->makeSystematicsName( key, match[ 1 ], matching ) );
+      }
       // Auxiliary variable name for the object under consideration.
-      std::string auxName;
-      ANA_CHECK (m_systematicsList.service().makeSystematicsName( auxName, match[ 2 ],
-                                                                  sys ));
+      std::string auxName = match[ 2 ];
+      if( auxName.find( "%SYS%" ) != std::string::npos )
+      {
+         systematicsDecoration = true;
+         const CP::SystematicSet affecting = m_systematicsService->getDecorSystematics( match[ 1 ], auxName );
+         CP::SystematicSet matching;
+         ANA_CHECK( SystematicSet::filterForAffectingSystematics( sys, affecting, matching ) );
+         if( !nominal && matching.empty() ) {
+            ATH_MSG_VERBOSE( "Decoration \"" << auxName << "\" is not affected by systematics \"" << sys.name() << "\"" );
+            affectedDecoration = false;
+         }
+         ANA_CHECK( m_systematicsService->makeSystematicsName( auxName, match[ 2 ], matching ) );
+      }
+
+      // Ignore the branch if neither container nor decoration are affected by the systematic
+      if( !nominal
+       && ( ( systematicsContainer && systematicsDecoration && !affectedContainer && !affectedDecoration )
+         || ( !systematicsContainer && systematicsDecoration && !affectedDecoration )
+         || ( systematicsContainer && !systematicsDecoration && !affectedContainer ) ) )
+      {
+         ANA_MSG_VERBOSE( "Neither container nor decoration are affected by systematics \"" << sys.name() << "\""
+                          << " for branch rule \"" << branchDecl << "\"" );
+         return StatusCode::SUCCESS;
+      }
+
       // Branch name for the variable.
-      std::string brName;
-      ANA_CHECK (m_systematicsList.service().makeSystematicsName( brName, match[ 3 ],
-                                                                  sys ));
+      std::string brName = match[ 3 ];
+      if( brName.find( "%SYS%" ) != std::string::npos )
+         ANA_CHECK (m_systematicsService->makeSystematicsName( brName, match[ 3 ], sys ));
 
       // If the %SYS% pattern was not used in this setup, then stop
       // on non-nominal systematic.
@@ -499,10 +539,10 @@ namespace CP {
                               ALLOW_MISSING, msg() ) ) {
          bool created = false;
          ATH_CHECK( m_elements[ key ].addBranch( *m_tree,
-                                                   auxName,
-                                                   brName,
-                                                   ALLOW_MISSING,
-                                                   created ) );
+                                                 auxName,
+                                                 brName,
+                                                 ALLOW_MISSING,
+                                                 created ) );
          if( created ) {
             ATH_MSG_DEBUG( "Writing branch \"" << brName
                            << "\" from object/variable \"" << key
@@ -520,9 +560,11 @@ namespace CP {
       }
 
       // Check if the rule was meaningful or not:
-      if( nominal && ! branchCreated && key == match[ 1 ] ) {
+      if( ! branchCreated ) {
          ATH_MSG_ERROR( "No branch was created for rule: \""
-                        << branchDecl << "\"" );
+                        << branchDecl << "\""
+                        << " and systematics: \""
+                        << sys.name() << "\"" );
          return StatusCode::FAILURE;
       }
 

PhysicsAnalysis/Algorithms/AsgAnalysisAlgorithms/Root/OverlapRemovalAlg.cxx

@@ -23,6 +23,7 @@ namespace CP
     : AnaAlgorithm (name, pSvcLocator)
   {
     declareProperty ("overlapTool", m_overlapTool);
+    declareProperty ("OutputLabel", m_overlapRemovalDecoration, "the decoration for the overlap removal tool output");
   }
 
 
@@ -30,13 +31,27 @@ namespace CP
   StatusCode OverlapRemovalAlg ::
   initialize ()
   {
+    if (m_overlapRemovalDecoration.empty())
+    {
+      ANA_MSG_ERROR ("no overlap removal decoration name set");
+      return StatusCode::FAILURE;
+    }
+
+    m_overlapRemovalAccessor = std::make_unique<SG::AuxElement::Accessor<char> > (m_overlapRemovalDecoration);
+
     ANA_CHECK (m_overlapTool.retrieve());
     ANA_CHECK (m_electronsHandle.initialize (m_systematicsList, SG::AllowEmpty));
+    ANA_CHECK (m_electronsDecoration.initialize (m_systematicsList, m_electronsHandle, SG::AllowEmpty));
     ANA_CHECK (m_muonsHandle.initialize (m_systematicsList, SG::AllowEmpty));
+    ANA_CHECK (m_muonsDecoration.initialize (m_systematicsList, m_muonsHandle, SG::AllowEmpty));
     ANA_CHECK (m_jetsHandle.initialize (m_systematicsList, SG::AllowEmpty));
+    ANA_CHECK (m_jetsDecoration.initialize (m_systematicsList, m_jetsHandle, SG::AllowEmpty));
     ANA_CHECK (m_tausHandle.initialize (m_systematicsList, SG::AllowEmpty));
+    ANA_CHECK (m_tausDecoration.initialize (m_systematicsList, m_tausHandle, SG::AllowEmpty));
     ANA_CHECK (m_photonsHandle.initialize (m_systematicsList, SG::AllowEmpty));
+    ANA_CHECK (m_photonsDecoration.initialize (m_systematicsList, m_photonsHandle, SG::AllowEmpty));
     ANA_CHECK (m_fatJetsHandle.initialize (m_systematicsList, SG::AllowEmpty));
+    ANA_CHECK (m_fatJetsDecoration.initialize (m_systematicsList, m_fatJetsHandle, SG::AllowEmpty));
     ANA_CHECK (m_systematicsList.initialize());
     return StatusCode::SUCCESS;
   }
@@ -48,27 +63,62 @@ namespace CP
   {
     for (const auto& sys : m_systematicsList.systematicsVector())
     {
+      std::unordered_map<const xAOD::IParticleContainer *, const SysWriteDecorHandle<char> *> decorationsMap;
+
       xAOD::ElectronContainer *electrons {nullptr};
       if (m_electronsHandle)
+      {
         ANA_CHECK (m_electronsHandle.getCopy (electrons, sys));
+        if (m_electronsDecoration)
+          decorationsMap.emplace(electrons, &m_electronsDecoration);
+      }
       xAOD::MuonContainer *muons {nullptr};
       if (m_muonsHandle)
+      {
         ANA_CHECK (m_muonsHandle.getCopy (muons, sys));
+        if (m_muonsDecoration)
+          decorationsMap.emplace(muons, &m_muonsDecoration);
+      }
       xAOD::JetContainer *jets {nullptr};
       if (m_jetsHandle)
+      {
         ANA_CHECK (m_jetsHandle.getCopy (jets, sys));
+        if (m_jetsDecoration)
+          decorationsMap.emplace(jets, &m_jetsDecoration);
+      }
       xAOD::TauJetContainer *taus {nullptr};
       if (m_tausHandle)
+      {
         ANA_CHECK (m_tausHandle.getCopy (taus, sys));
+        if (m_tausDecoration)
+          decorationsMap.emplace(taus, &m_tausDecoration);
+      }
       xAOD::PhotonContainer *photons {nullptr};
       if (m_photonsHandle)
+      {
         ANA_CHECK (m_photonsHandle.getCopy (photons, sys));
+        if (m_photonsDecoration)
+          decorationsMap.emplace(photons, &m_photonsDecoration);
+      }
       xAOD::JetContainer *fatJets {nullptr};
       if (m_fatJetsHandle)
+      {
         ANA_CHECK (m_fatJetsHandle.getCopy (fatJets, sys));
+        if (m_fatJetsDecoration)
+          decorationsMap.emplace(fatJets, &m_fatJetsDecoration);
+      }
 
       ATH_CHECK (m_overlapTool->removeOverlaps (electrons, muons, jets, taus,
                                                 photons, fatJets));
+
+      // Re-decorate if needed
+      for (const auto &pair : decorationsMap)
+      {
+        for (const xAOD::IParticle *particle : *(pair.first))
+        {
+          (*(pair.second)).set (*particle, (*m_overlapRemovalAccessor) (*particle), sys);
+        }
+      }
     }
 
     return StatusCode::SUCCESS;

PhysicsAnalysis/Algorithms/AsgAnalysisAlgorithms/python/OverlapAnalysisSequence.py

@@ -14,6 +14,7 @@ def makeOverlapAnalysisSequence( dataType,
                                  bJetLabel = '',
                                  boostedLeptons = False,
                                  postfix = '',
+                                 shallowViewOutput = True,
                                  enableCutflow = False ):
     """Function creating the overlap removal algorithm sequence
 
@@ -66,6 +67,7 @@ def makeOverlapAnalysisSequence( dataType,
       bJetLabel -- Flag to select b-jets with. If left empty, no b-jets are used
                    in the overlap removal.
       boostedLeptons -- Set to True to enable boosted lepton overlap removal
+      shallowViewOutput -- Create a view container if required
       enableCutflow -- Whether or not to dump the cutflow
     """
 
@@ -77,6 +79,14 @@ def makeOverlapAnalysisSequence( dataType,
 
     # Create the overlap removal algorithm:
     alg = createAlgorithm( 'CP::OverlapRemovalAlg', 'OverlapRemovalAlg' + postfix )
+    alg.OutputLabel = outputLabel
+    if not shallowViewOutput:
+        alg.electronsDecoration = outputLabel + '_%SYS%'
+        alg.muonsDecoration = outputLabel + '_%SYS%'
+        alg.tausDecoration = outputLabel + '_%SYS%'
+        alg.jetsDecoration = outputLabel + '_%SYS%'
+        alg.photonsDecoration = outputLabel + '_%SYS%'
+        alg.fatJetsDecoration = outputLabel + '_%SYS%'
 
     # Create its main tool, and set its basic properties:
     addPrivateTool( alg, 'overlapTool', 'ORUtils::OverlapRemovalTool' )
@@ -235,52 +245,64 @@ def makeOverlapAnalysisSequence( dataType,
         pass
 
     # Add the algorithm to the analysis sequence.
-    seq.append( alg,
-                inputPropName = { 'electrons' : 'electrons',
-                                  'muons'     : 'muons',
-                                  'jets'      : 'jets',
-                                  'taus'      : 'taus',
-                                  'photons'   : 'photons',
-                                  'fatJets'   : 'fatJets' },
-                outputPropName = { 'electrons' : 'electronsOut',
-                                   'muons'     : 'muonsOut',
-                                   'jets'      : 'jetsOut',
-                                   'taus'      : 'tausOut',
-                                   'photons'   : 'photonsOut',
-                                   'fatJets'   : 'fatJetsOut' } )
+    if shallowViewOutput:
+        seq.append( alg,
+                    inputPropName = { 'electrons' : 'electrons',
+                                      'muons'     : 'muons',
+                                      'jets'      : 'jets',
+                                      'taus'      : 'taus',
+                                      'photons'   : 'photons',
+                                      'fatJets'   : 'fatJets' },
+                    outputPropName = { 'electrons' : 'electronsOut',
+                                       'muons'     : 'muonsOut',
+                                       'jets'      : 'jetsOut',
+                                       'taus'      : 'tausOut',
+                                       'photons'   : 'photonsOut',
+                                       'fatJets'   : 'fatJetsOut' } )
+        pass
+    else:
+        seq.append( alg,
+                    inputPropName = { 'electrons' : 'electrons',
+                                      'muons'     : 'muons',
+                                      'jets'      : 'jets',
+                                      'taus'      : 'taus',
+                                      'photons'   : 'photons',
+                                      'fatJets'   : 'fatJets' } )
+        pass
 
     # Add view container creation algorithms for all types.
-    for container in [ ( 'electrons', doElectrons ),
-                       ( 'muons',     doMuons ),
-                       ( 'jets',      doJets ),
-                       ( 'taus',      doTaus ),
-                       ( 'photons',   doPhotons ),
-                       ( 'fatJets',   doFatJets ) ]:
+    if shallowViewOutput:
+        for container in [ ( 'electrons', doElectrons ),
+                           ( 'muons',     doMuons ),
+                           ( 'jets',      doJets ),
+                           ( 'taus',      doTaus ),
+                           ( 'photons',   doPhotons ),
+                           ( 'fatJets',   doFatJets ) ]:
 
-        # Skip setting up a view container if the type is not being processed.
-        if not container[ 1 ]:
-            continue
+            # Skip setting up a view container if the type is not being processed.
+            if not container[ 1 ]:
+                continue
 
-        # Set up a cutflow alg.
-        if enableCutflow:
-            alg = createAlgorithm( 'CP::ObjectCutFlowHistAlg',
-                                   'OverlapRemovalCutFlowDumperAlg_%s' % container[ 0 ] + postfix )
-            alg.histPattern = container[ 0 ] + postfix + '_OR_cflow_%SYS%'
-            if inputLabel:
-                alg.selection = [ '%s,as_char' % inputLabel,
-                                  '%s,as_char' % outputLabel ]
-                alg.selectionNCuts = [1, 1]
-            else:
-                alg.selection = [ '%s,as_char' % outputLabel ]
-                alg.selectionNCuts = [1]
-            seq.append( alg, inputPropName = { container[ 0 ] : 'input' } )
+            # Set up a cutflow alg.
+            if enableCutflow:
+                alg = createAlgorithm( 'CP::ObjectCutFlowHistAlg',
+                                       'OverlapRemovalCutFlowDumperAlg_%s' % container[ 0 ] + postfix )
+                alg.histPattern = container[ 0 ] + postfix + '_OR_cflow_%SYS%'
+                if inputLabel:
+                    alg.selection = [ '%s,as_char' % inputLabel,
+                                      '%s,as_char' % outputLabel ]
+                    alg.selectionNCuts = [1, 1]
+                else:
+                    alg.selection = [ '%s,as_char' % outputLabel ]
+                    alg.selectionNCuts = [1]
+                seq.append( alg, inputPropName = { container[ 0 ] : 'input' } )
 
-        # Set up a view container for the type.
-        alg = createAlgorithm( 'CP::AsgViewFromSelectionAlg',
-                               'OverlapRemovalViewMaker_%s' % container[ 0 ] + postfix )
-        alg.selection = [ '%s,as_char' % outputLabel ]
-        seq.append( alg, inputPropName = { container[ 0 ] : 'input' },
-                    outputPropName = { container[ 0 ] : 'output' } )
+            # Set up a view container for the type.
+            alg = createAlgorithm( 'CP::AsgViewFromSelectionAlg',
+                                   'OverlapRemovalViewMaker_%s' % container[ 0 ] + postfix )
+            alg.selection = [ '%s,as_char' % outputLabel ]
+            seq.append( alg, inputPropName = { container[ 0 ] : 'input' },
+                        outputPropName = { container[ 0 ] : 'output' } )
         pass
 
     # Return the sequence:

PhysicsAnalysis/Algorithms/EgammaAnalysisAlgorithms/EgammaAnalysisAlgorithms/EgammaIsolationSelectionAlg.h

@@ -15,8 +15,8 @@
 #include <SelectionHelpers/ISelectionAccessor.h>
 #include <SelectionHelpers/OutOfValidityHelper.h>
 #include <SelectionHelpers/SelectionReadHandle.h>
-#include <SystematicsHandles/SysCopyHandle.h>
 #include <SystematicsHandles/SysListHandle.h>
+#include <SystematicsHandles/SysReadHandle.h>
 
 namespace CP
 {
@@ -53,7 +53,7 @@ namespace CP
 
     /// \brief the particle continer we run on
   private:
-    SysCopyHandle<xAOD::EgammaContainer> m_egammasHandle {
+    SysReadHandle<xAOD::EgammaContainer> m_egammasHandle {
       this, "egammas", "Electrons", "the egamma collection to run on"};
 
     /// \brief the decoration for the asg selection