Control/AthenaExamples/DevTutorialWriteAlgAndTool/CMakeLists.txt

+atlas_subdir( DevTutorialWriteAlgAndTool )
+
+atlas_depends_on_subdirs( PUBLIC
+                          GaudiKernel
+                          PRIVATE
+                          Control/AthenaBaseComps
+                          Event/xAOD/xAODTracking )
+
+atlas_add_component( DevTutorialWriteAlgAndTool
+                     src/*.cxx
+                     src/components/*.cxx 
+                     LINK_LIBRARIES GaudiKernel AthenaBaseComps xAODTracking )
+
+atlas_install_python_modules( python/*.py )

Control/AthenaExamples/DevTutorialWriteAlgAndTool/DevTutorialWriteAlgAndTool/IMyAlgTool.h

+/*
+  Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef MYNEWPACKAGE_IMYALGTOOL_H
+#define MYNEWPACKAGE_IMYALGTOOL_H
+#include "GaudiKernel/IAlgTool.h"
+#include "xAODTracking/TrackParticle.h"
+
+static const InterfaceID IID_IMyAlgTool("IMyAlgTool", 1, 0);
+
+/** @class IMyAlgTool
+    @brief Interface to demonstrate how to make an interface which actually does something useful.
+*/
+
+class IMyAlgTool : virtual public IAlgTool {
+  public:
+  static const InterfaceID& interfaceID( );
+  virtual bool selectTrackParticle( const xAOD::TrackParticle& particle) const = 0 ;
+};
+
+inline const InterfaceID& IMyAlgTool::interfaceID()
+{ 
+	return IID_IMyAlgTool; 
+}
+
+#endif 
+

Control/AthenaExamples/DevTutorialWriteAlgAndTool/python/ExampleAlgConfig.py

+# Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+
+from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
+from AthenaCommon.Constants import VERBOSE
+from DevTutorialWriteAlgAndTool.DevTutorialWriteAlgAndToolConf import ExampleAlg
+from TrkExTools.AtlasExtrapolatorConfig import AtlasExtrapolatorCfg
+
+def ExampleAlgCfg(configFlags, **kwargs):
+    result=ComponentAccumulator()
+    alg = ExampleAlg(**kwargs )
+    result.addEventAlgo(alg)
+    return result
+
+if __name__=="__main__":
+    from AthenaCommon.Configurable import Configurable
+    from AthenaCommon.Logging import log
+    from AthenaConfiguration.AllConfigFlags import ConfigFlags
+    from AthenaConfiguration.MainServicesConfig import MainServicesThreadedCfg    
+    from AthenaPoolCnvSvc.PoolReadConfig import PoolReadCfg
+
+    Configurable.configurableRun3Behavior=1
+
+    from AthenaConfiguration.TestDefaults import defaultTestFiles
+    ConfigFlags.Input.Files = defaultTestFiles.ESD
+
+    ConfigFlags.Detector.GeometryPixel = True     
+    ConfigFlags.Detector.GeometrySCT   = True 
+    ConfigFlags.Detector.GeometryTRT   = True
+    ConfigFlags.Concurrency.NumThreads = 1
+    ConfigFlags.Concurrency.NumConcurrentEvents = 1
+
+    ConfigFlags.lock()
+
+    cfg=MainServicesThreadedCfg(ConfigFlags)
+    
+    cfg.merge(PoolReadCfg(ConfigFlags))
+    
+    from AthenaCommon.Constants import VERBOSE
+    acc=ExampleAlgCfg(ConfigFlags, OutputLevel=VERBOSE)
+    cfg.merge(acc)
+
+    cfg.run(10)
+
+
+

Control/AthenaExamples/DevTutorialWriteAlgAndTool/python/ExampleAlgConfig_step2.py

+# Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+
+from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
+from AthenaCommon.Constants import VERBOSE
+from DevTutorialWriteAlgAndTool.DevTutorialWriteAlgAndToolConf import ExampleAlg_step1 as ExampleAlg
+from TrkExTools.AtlasExtrapolatorConfig import AtlasExtrapolatorCfg
+
+def ExampleAlgCfg(configFlags, **kwargs):
+    result=ComponentAccumulator()
+    alg = ExampleAlg(**kwargs )
+    result.addEventAlgo(alg)
+    return result
+
+if __name__=="__main__":
+    from AthenaCommon.Configurable import Configurable
+    from AthenaCommon.Logging import log
+    from AthenaConfiguration.AllConfigFlags import ConfigFlags
+    from AthenaConfiguration.MainServicesConfig import MainServicesThreadedCfg    
+    from AthenaPoolCnvSvc.PoolReadConfig import PoolReadCfg
+
+    Configurable.configurableRun3Behavior=1
+
+    from AthenaConfiguration.TestDefaults import defaultTestFiles
+    ConfigFlags.Input.Files = defaultTestFiles.ESD
+
+    ConfigFlags.Detector.GeometryPixel = True     
+    ConfigFlags.Detector.GeometrySCT   = True 
+    ConfigFlags.Detector.GeometryTRT   = True
+    ConfigFlags.Concurrency.NumThreads = 8
+    ConfigFlags.Concurrency.NumConcurrentEvents = 8
+
+
+    ConfigFlags.lock()
+
+    cfg=MainServicesThreadedCfg(ConfigFlags)
+    
+    cfg.merge(PoolReadCfg(ConfigFlags))
+    
+    from AthenaCommon.Constants import VERBOSE
+    acc=ExampleAlgCfg(ConfigFlags, OutputLevel=VERBOSE)
+    cfg.merge(acc)
+
+    cfg.run(10)
+
+
+

Control/AthenaExamples/DevTutorialWriteAlgAndTool/python/ExampleAlgConfig_step4.py

+# Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+
+from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
+from AthenaCommon.Constants import VERBOSE
+from DevTutorialWriteAlgAndTool.DevTutorialWriteAlgAndToolConf import ExampleAlg_step4 as ExampleAlg
+from TrkExTools.AtlasExtrapolatorConfig import AtlasExtrapolatorCfg
+
+def ExampleAlgCfg(configFlags, **kwargs):
+    result=ComponentAccumulator()
+    alg = ExampleAlg(**kwargs )
+    result.addEventAlgo(alg)
+    return result
+
+if __name__=="__main__":
+    from AthenaCommon.Configurable import Configurable
+    from AthenaCommon.Logging import log
+    from AthenaConfiguration.AllConfigFlags import ConfigFlags
+    from AthenaConfiguration.MainServicesConfig import MainServicesThreadedCfg    
+    from AthenaPoolCnvSvc.PoolReadConfig import PoolReadCfg
+
+    Configurable.configurableRun3Behavior=1
+
+    from AthenaConfiguration.TestDefaults import defaultTestFiles
+    ConfigFlags.Input.Files = defaultTestFiles.ESD
+
+    ConfigFlags.Detector.GeometryPixel = True     
+    ConfigFlags.Detector.GeometrySCT   = True 
+    ConfigFlags.Detector.GeometryTRT   = True
+    ConfigFlags.Concurrency.NumThreads = 8
+    ConfigFlags.Concurrency.NumConcurrentEvents = 8
+
+
+    ConfigFlags.lock()
+
+    cfg=MainServicesThreadedCfg(ConfigFlags)
+    
+    cfg.merge(PoolReadCfg(ConfigFlags))
+    
+    from AthenaCommon.Constants import VERBOSE
+    acc=ExampleAlgCfg(ConfigFlags, OutputLevel=VERBOSE)
+    cfg.merge(acc)
+
+    cfg.run(10)
+
+
+

Control/AthenaExamples/DevTutorialWriteAlgAndTool/src/ExampleAlg.cxx

+/*
+  Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+*/
+
+#include "ExampleAlg.h"
+
+StatusCode ExampleAlg::initialize()
+{
+  ATH_CHECK( m_trackParticleKey.initialize());
+  ATH_CHECK( m_algTool.retrieve() );
+  return StatusCode::SUCCESS;
+}
+
+StatusCode ExampleAlg::execute(const EventContext& ctx) const
+{
+  SG::ReadHandle<xAOD::TrackParticleContainer> handle(m_trackParticleKey, ctx);
+  ATH_MSG_VERBOSE(ctx<< " Got back "<<handle->size()<<" trackparticles");
+  unsigned int count=0;
+  for (auto tp : *handle) {
+    if ( m_algTool->selectTrackParticle( *tp ) ) count++;
+  }
+  ATH_MSG_VERBOSE(ctx << " " << count << " pass selection");
+  
+  return StatusCode::SUCCESS;
+}

Control/AthenaExamples/DevTutorialWriteAlgAndTool/src/ExampleAlg.h

+/*
+  Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+*/
+#ifndef MYNEWPACKAGE_EXAMPLEALG_H
+#define MYNEWPACKAGE_EXAMPLEALG_H
+
+#include "AthenaBaseComps/AthReentrantAlgorithm.h"
+#include "xAODTracking/TrackParticleContainer.h"
+#include "DevTutorialWriteAlgAndTool/IMyAlgTool.h"
+
+/** An example algorithm that reads and writes objects from the event store
+ using handles.*/
+class ExampleAlg
+  : public AthReentrantAlgorithm
+{
+public:
+  using AthReentrantAlgorithm::AthReentrantAlgorithm;
+  virtual StatusCode initialize() override;
+  virtual StatusCode execute (const EventContext& ctx) const override;
+private:
+  SG::ReadHandleKey<xAOD::TrackParticleContainer>   m_trackParticleKey
+     { this, "TrackParticleContainerKey", "InDetTrackParticles", "Key for TrackParticle Containers" };
+  
+  ToolHandle<IMyAlgTool> m_algTool {this, "SelectionTool", "MyAlgTool", "The selection tool"};
+};
+#endif

Control/AthenaExamples/DevTutorialWriteAlgAndTool/src/ExampleAlg_step1.cxx

+/*
+  Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+*/
+
+#include "ExampleAlg_step1.h"
+
+StatusCode ExampleAlg_step1::initialize()
+{
+  return StatusCode::SUCCESS;
+}
+
+StatusCode ExampleAlg_step1::execute(const EventContext& ctx) const
+{
+  ATH_MSG_VERBOSE("Events processed: "<<ctx.evt());
+  return StatusCode::SUCCESS;
+}

Control/AthenaExamples/DevTutorialWriteAlgAndTool/src/ExampleAlg_step1.h

+/*
+  Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+*/
+#ifndef MYNEWPACKAGE_EXAMPLEALG_STEP1_H
+#define MYNEWPACKAGE_EXAMPLEALG_STEP1_H
+
+#include "AthenaBaseComps/AthReentrantAlgorithm.h"
+
+/** An example algorithm that reads and writes objects from the event store
+ using handles.*/
+class ExampleAlg_step1
+  : public AthReentrantAlgorithm
+{
+public:
+  using AthReentrantAlgorithm::AthReentrantAlgorithm;
+  virtual StatusCode initialize() override;
+  virtual StatusCode execute (const EventContext& ctx) const override;
+private:
+};
+#endif

Control/AthenaExamples/DevTutorialWriteAlgAndTool/src/ExampleAlg_step3.cxx

+/*
+  Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+*/
+
+#include "ExampleAlg_step3.h"
+
+StatusCode ExampleAlg_step3::initialize()
+{
+  ATH_CHECK( m_trackParticleKey.initialize());
+  return StatusCode::SUCCESS;
+}
+
+StatusCode ExampleAlg_step3::execute(const EventContext& ctx) const
+{
+  ATH_MSG_VERBOSE("Events processed: "<<ctx.evt());
+  SG::ReadHandle<xAOD::TrackParticleContainer> handle(m_trackParticleKey, ctx);
+  ATH_MSG_VERBOSE("Got back  "<<handle->size());
+  return StatusCode::SUCCESS;
+}

Control/AthenaExamples/DevTutorialWriteAlgAndTool/src/ExampleAlg_step3.h

+/*
+  Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+*/
+#ifndef MYNEWPACKAGE_ExampleAlg_STEP3_H
+#define MYNEWPACKAGE_ExampleAlg_STEP3_H
+
+#include "AthenaBaseComps/AthReentrantAlgorithm.h"
+#include "xAODTracking/TrackParticleContainer.h"
+
+/** An example algorithm that reads and writes objects from the event store
+ using handles.*/
+class ExampleAlg_step3
+  : public AthReentrantAlgorithm
+{
+public:
+  using AthReentrantAlgorithm::AthReentrantAlgorithm;
+  virtual StatusCode initialize() override;
+  virtual StatusCode execute (const EventContext& ctx) const override;
+private:
+  /// 
+  SG::ReadHandleKey<xAOD::TrackParticleContainer>   m_trackParticleKey
+     { this, "TrackParticleContainerKey", "InDetTrackParticles", "Key for TrackParticle Containers" };
+};
+#endif

Control/AthenaExamples/DevTutorialWriteAlgAndTool/src/ExampleAlg_step4.cxx

+/*
+  Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+*/
+
+#include "ExampleAlg_step4.h"
+
+StatusCode ExampleAlg_step4::initialize()
+{
+  ATH_CHECK( m_trackParticleKey.initialize());
+  ATH_CHECK( m_algTool.retrieve() );
+  return StatusCode::SUCCESS;
+}
+
+StatusCode ExampleAlg_step4::execute(const EventContext& ctx) const
+{
+  ATH_MSG_VERBOSE("Event slot: "<<ctx.evt());
+  SG::ReadHandle<xAOD::TrackParticleContainer> handle(m_trackParticleKey, ctx);
+  ATH_MSG_VERBOSE("Got back  "<<handle->size()<<" trackparticles");
+  return StatusCode::SUCCESS;
+}

Control/AthenaExamples/DevTutorialWriteAlgAndTool/src/ExampleAlg_step4.h

+/*
+  Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+*/
+#ifndef MYNEWPACKAGE_EXAMPLEALG_STEP4_H
+#define MYNEWPACKAGE_EXAMPLEALG_STEP4_H
+
+#include "AthenaBaseComps/AthReentrantAlgorithm.h"
+#include "xAODTracking/TrackParticleContainer.h"
+#include "DevTutorialWriteAlgAndTool/IMyAlgTool.h"
+
+/** An example algorithm that reads and writes objects from the event store
+ using handles.*/
+class ExampleAlg_step4
+  : public AthReentrantAlgorithm
+{
+public:
+  using AthReentrantAlgorithm::AthReentrantAlgorithm;
+  virtual StatusCode initialize() override;
+  virtual StatusCode execute (const EventContext& ctx) const override;
+private:
+  SG::ReadHandleKey<xAOD::TrackParticleContainer>   m_trackParticleKey
+     { this, "TrackParticleContainerKey", "InDetTrackParticles", "Key for TrackParticle Containers" };
+  
+  ToolHandle<IMyAlgTool> m_algTool {this, "SelectionTool", "MyAlgTool", "The selection tool"};
+};
+#endif

Control/AthenaExamples/DevTutorialWriteAlgAndTool/src/MyAlgTool.cxx

+/*
+  Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+*/
+
+#include "MyAlgTool.h"
+
+MyAlgTool::MyAlgTool(const std::string& t, const std::string& n,  const IInterface* p ) :
+AthAlgTool(t,n,p)
+{
+  declareInterface<IMyAlgTool>(this);
+}
+
+bool MyAlgTool::selectTrackParticle( const xAOD::TrackParticle& particle) const {
+  return particle.pt()>2.0;
+}

Control/AthenaExamples/DevTutorialWriteAlgAndTool/src/MyAlgTool.h

+/*
+  Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef MYNEWPACKAGE_MYALGTOOL_H
+#define MYNEWPACKAGE_MYALGTOOL_H
+
+#include "AthenaBaseComps/AthAlgTool.h"
+#include "DevTutorialWriteAlgAndTool/IMyAlgTool.h"
+
+class MyAlgTool : public AthAlgTool, virtual public IMyAlgTool {
+public:
+      MyAlgTool(const std::string&,const std::string&,const IInterface*);
+      MyAlgTool& operator= (const MyAlgTool& ) = delete;
+        
+      bool selectTrackParticle( const xAOD::TrackParticle& particle) const override;
+};
+
+#endif

Control/AthenaExamples/DevTutorialWriteAlgAndTool/src/components/MyNewPackage_entries.cxx

+#include "../ExampleAlg.h"
+#include "../ExampleAlg_step1.h"
+#include "../ExampleAlg_step3.h"
+#include "../ExampleAlg_step4.h"
+#include "../MyAlgTool.h"
+DECLARE_COMPONENT( ExampleAlg )
+DECLARE_COMPONENT( ExampleAlg_step1 )
+DECLARE_COMPONENT( ExampleAlg_step3 )
+DECLARE_COMPONENT( ExampleAlg_step4 )
+DECLARE_COMPONENT( MyAlgTool )

MuonSpectrometer/MuonConfig/python/MuonRIO_OnTrackCreatorConfig.py

@@ -17,7 +17,6 @@ def TriggerChamberClusterOnTrackCreatorCfg(flags, **kwargs):
     result.setPrivateTools(Muon__TriggerChamberClusterOnTrackCreator(**kwargs))
     return result
 
-
 def CscClusterOnTrackCreatorCfg(flags,**kwargs):
     from MuonConfig.MuonSegmentFindingConfig import QratCscClusterFitterCfg, CscClusterUtilToolCfg
 

MuonSpectrometer/MuonConfig/python/MuonRecToolsConfig.py

@@ -29,10 +29,13 @@ def MuonSeededSegmentFinderCfg(flags,name="MuonSeededSegmentFinder", **kwargs):
         kwargs.setdefault("SegmentMakerNoHoles", seg_maker) #FIXME. Just remove one.
     if not flags.Detector.GeometryCSC:
         kwargs.setdefault("CscPrepDataContainer","")
-    else:
+    if not flags.Detector.GeometrysTGC:
         kwargs.setdefault("sTgcPrepDataContainer","")
+    if not flags.Detector.GeometryMM:
         kwargs.setdefault("MMPrepDataContainer","")
     
+    kwargs.setdefault('TgcPrepDataContainer', 'TGC_MeasurementsAllBCs' if not flags.Muon.useTGCPriorNextBC and not flags.Muon.useTGCPriorNextBC else 'TGC_Measurements')
+    
     muon_seeded_segment_finder = Muon__MuonSeededSegmentFinder(name, **kwargs)
     result.setPrivateTools(muon_seeded_segment_finder)
     return result

MuonSpectrometer/MuonConfig/python/MuonSegmentFindingConfig.py

@@ -511,19 +511,19 @@ def MooSegmentFinderCfg(flags, name='MooSegmentFinder', **kwargs):
         csc_2d_segment_maker=None
         csc_4d_segment_maker=None
     
-    segment_finder_tool = Muon__MooSegmentCombinationFinder(name=name, 
-        SegmentCombiner = muon_curved_segment_combiner_tool,
-        SegmentCombinationCleaner = muon_segment_combination_cleaner_tool,
-        HoughPatternFinder =muon_pattern_finder_tool,
-        MdtSegmentMaker=muon_pattern_segment_maker,
-        DoSegmentCombinations=False,
-        DoSegmentCombinationCleaning=False,
-        DoCscSegments = flags.Muon.doCSCs,
-        DoMdtSegments = flags.Muon.doMDTs,   
-        Csc2dSegmentMaker = csc_2d_segment_maker,
-        Csc4dSegmentMaker = csc_4d_segment_maker,
-        DoSummary = flags.Muon.printSummary
-        )
+    kwargs.setdefault('SegmentCombiner', muon_curved_segment_combiner_tool)
+    kwargs.setdefault('SegmentCombinationCleaner', muon_segment_combination_cleaner_tool)
+    kwargs.setdefault('HoughPatternFinder', muon_pattern_finder_tool)
+    kwargs.setdefault('MdtSegmentMaker', muon_pattern_segment_maker)
+    kwargs.setdefault('DoSegmentCombinations', False)
+    kwargs.setdefault('DoSegmentCombinationCleaning', False)
+    kwargs.setdefault('DoCscSegments', flags.Muon.doCSCs)
+    kwargs.setdefault('DoMdtSegments', flags.Muon.doMDTs)
+    kwargs.setdefault('Csc2dSegmentMaker', csc_2d_segment_maker)
+    kwargs.setdefault('Csc4dSegmentMaker', csc_4d_segment_maker)
+    kwargs.setdefault('DoSummary', flags.Muon.printSummary)
+    
+    segment_finder_tool = Muon__MooSegmentCombinationFinder(name=name, **kwargs)
     
     result.setPrivateTools(segment_finder_tool)
     return result
@@ -638,6 +638,7 @@ def MooSegmentFinderAlgCfg(flags, name = "MuonSegmentMaker",  **kwargs):
     kwargs.setdefault('MuonSegmentOutputLocation', "ThirdChainSegments" if flags.Muon.segmentOrigin=="TruthTracking" else "MuonSegments")
     
     moo_segment_finder_alg = MooSegmentFinderAlg( name=name, **kwargs )
+    moo_segment_finder_alg.Cardinality=10
     result.addEventAlgo( moo_segment_finder_alg )
         
     return result
@@ -658,7 +659,9 @@ def MooSegmentFinderAlg_NCBCfg(flags, name = "MuonSegmentMaker_NCB", **kwargs):
     csc_4d_segment_maker = acc.getPrimary()
     result.merge(acc)
     
-    acc  = MooSegmentFinderCfg(flags, name='MooSegmentFinder_NCB', Csc2dSegmentMaker=csc_2d_segment_maker, Csc4dSegmentMaker=csc_4d_segment_maker)
+    acc  = MooSegmentFinderCfg(flags, name='MooSegmentFinder_NCB', Csc2dSegmentMaker=csc_2d_segment_maker, 
+                               Csc4dSegmentMaker=csc_4d_segment_maker, 
+                               DoMdtSegments=False,DoSegmentCombinations=False,DoSegmentCombinationCleaning=False)
     segment_finder_tool=(acc.popPrivateTools())
     result.addPublicTool(segment_finder_tool)
     result.merge(acc)
@@ -701,14 +704,33 @@ def MuonSegmentFindingCfg(flags):
     result.merge(acc)
     return result
 
-if __name__=="__main__":
+if __name__=="__main__":                        
     # To run this, do e.g. 
-    # python ../athena/MuonSpectrometer/MuonConfig/python/MuonSegmentFindingConfig.py
+    # python -m MuonConfig.MuonSegmentFindingConfig --run --threads=1
+    
+    from argparse import ArgumentParser
+    
+    parser = ArgumentParser()
+    parser.add_argument("-t", "--threads", dest="threads", type=int,
+                        help="number of threads", default=1)
+                        
+    parser.add_argument("-o", "--output", dest="output", default='newESD.pool.root',
+                        help="write ESD to FILE", metavar="FILE")
+                        
+    parser.add_argument("--run", help="Run directly from the python. If false, just stop once the pickle is written.",
+                        action="store_true")
+                        
+    args = parser.parse_args()
+    
     from AthenaCommon.Configurable import Configurable
+
     from AthenaConfiguration.AllConfigFlags import ConfigFlags
     from AthenaCommon.Logging import log
     from AthenaConfiguration.TestDefaults import defaultTestFiles
 
+    ConfigFlags.Concurrency.NumThreads=args.threads
+    ConfigFlags.Concurrency.NumConcurrentEvents=args.threads # Might change this later, but good enough for the moment.
+
     Configurable.configurableRun3Behavior=1
 
     ConfigFlags.Detector.GeometryMDT   = True 
@@ -717,41 +739,55 @@ if __name__=="__main__":
     ConfigFlags.Detector.GeometryRPC   = True 
     
     ConfigFlags.Input.Files = defaultTestFiles.ESD
-    ConfigFlags.Output.ESDFileName='newESD.pool.root'
+    ConfigFlags.Output.ESDFileName=args.output
     
-    # from AthenaCommon.Constants import DEBUG
-    #log.setLevel(DEBUG)
+    from AthenaCommon.Constants import DEBUG
+    log.setLevel(DEBUG)
     log.debug('About to set up Segment Finding.')
     
     ConfigFlags.Input.isMC = True
     ConfigFlags.lock()
-    
-    # import pdb; pdb.set_trace()
-    
-    from AthenaConfiguration.MainServicesConfig import MainServicesThreadedCfg
-    cfg = MainServicesThreadedCfg(ConfigFlags)
+    ConfigFlags.dump()
+        
+    # When running from a pickled file, athena inserts some services automatically. So only use this if running now.
+    if args.run:
+        from AthenaConfiguration.MainServicesConfig import MainServicesThreadedCfg
+        cfg = MainServicesThreadedCfg(ConfigFlags)
+    else:
+        cfg=ComponentAccumulator()
 
     from AthenaPoolCnvSvc.PoolReadConfig import PoolReadCfg
     cfg.merge(PoolReadCfg(ConfigFlags))
 
     cfg.merge(MuonSegmentFindingCfg(ConfigFlags))
 
-    # from OutputStreamAthenaPool.OutputStreamConfig import OutputStreamCfg
-    # itemsToRecord = ["Trk::SegmentCollection#MuonSegments"]
-    #
-    # cfg.merge( OutputStreamCfg( ConfigFlags, 'ESD', ItemList=itemsToRecord) )
-    # outstream = cfg.getEventAlgo("OutputStreamESD")
-    # outstream.OutputLevel=DEBUG
-    # outstream.ForceRead = True
+    # This is a temporary fix - it should go someplace central as it replaces the functionality of addInputRename from here:
+    # https://gitlab.cern.ch/atlas/athena/blob/master/Control/SGComps/python/AddressRemappingSvc.py
+    from SGComps.SGCompsConf import AddressRemappingSvc, ProxyProviderSvc
+    pps = ProxyProviderSvc()
+    ars=AddressRemappingSvc()
+    pps.ProviderNames += [ 'AddressRemappingSvc' ]
+    ars.TypeKeyRenameMaps += [ '%s#%s->%s' % ("Trk::SegmentCollection", "MuonSegments", "MuonSegments_old") ]
+    ars.TypeKeyRenameMaps += [ '%s#%s->%s' % ("Trk::SegmentCollection", "MuonSegments_NCB", "MuonSegments_NCB_old") ]
+    
+    cfg.addService(pps)
+    cfg.addService(ars)
+    
+    # Set up output
+    from OutputStreamAthenaPool.OutputStreamConfig import OutputStreamCfg
+    itemsToRecord = ["Trk::SegmentCollection#MuonSegments", "Trk::SegmentCollection#NCB_MuonSegments"]
 
-    ConfigFlags.dump()
-    cfg.printConfig()
+    cfg.merge( OutputStreamCfg( ConfigFlags, 'ESD', ItemList=itemsToRecord) )
+    outstream = cfg.getEventAlgo("OutputStreamESD")
+    outstream.OutputLevel=DEBUG
+    outstream.ForceRead = True
 
     # cfg.getService("StoreGateSvc").Dump = True
-    
+    cfg.printConfig()
     f=open("MuonSegmentFinding.pkl","w")
     cfg.store(f)
     f.close()
 
-    # cfg.run()
+    if args.run:
+        cfg.run(20)