Updated algorithm structure for MT. Python scripts now set up TauProcessorAlg,...

Updated algorithm structure for MT. Python scripts now set up TauProcessorAlg, which then calls the tools - effectively what TauBuilderTool did is now in TauProcessorAlg


Former-commit-id: c3b33c79

Reconstruction/tauRec/python/TauRecBuilder.py

@@ -71,16 +71,19 @@ class TauRecCoreBuilder ( TauRecConfigured ) :
         # create the taus
         try:
             from tauRec.tauRecFlags import tauFlags
-            from tauRecTools.tauRecToolsConf import TauBuilderTool
-            self._TauBuilderToolHandle = TauBuilderTool(
-                name = self.name,
-                SeedContainer            = _jet_collection,
-                TauContainer             = _outputKey,
-                TauAuxContainer          = _outputAuxKey,
+            #from tauRecTools.tauRecToolsConf import TauBuilderTool
+            #self._TauBuilderToolHandle = TauBuilderTool(
+            #    name = self.name,
+            #    SeedContainer            = _jet_collection,
+            #    TauContainer             = _outputKey,
+            #    TauAuxContainer          = _outputAuxKey,
+            #    Key_jetInputContainer="AntiKt4LCTopoJets", 
+            #    Key_tauOutputContainer="TauJets", 
+            #    Key_tauTrackOutputContainer="TauTracks",
                 #MaxEta = 2.5,
-                MaxEta = tauFlags.tauRecSeedMaxEta(),
-                MinPt = 10.*GeV,
-                doCreateTauContainers = True)
+            #    MaxEta = tauFlags.tauRecSeedMaxEta(),
+            #    MinPt = 10.*GeV,
+            #    doCreateTauContainers = True)
         except Exception:
             mlog.error("could not get handle to TauBuilder")
             print traceback.format_exc()
@@ -98,48 +101,48 @@ class TauRecCoreBuilder ( TauRecConfigured ) :
             tools.append(taualgs.getJetSeedBuilder(_jet_collection))
 
             # run vertex finder only in case vertexing is available. This check can also be done in TauAlgorithmsHolder instead doing it here. 
-            from InDetRecExample.InDetJobProperties import InDetFlags
-            from tauRec.tauRecFlags import jobproperties
-            doMVATrackClassification = jobproperties.tauRecFlags.tauRecMVATrackClassification()
+            #from InDetRecExample.InDetJobProperties import InDetFlags
+            #from tauRec.tauRecFlags import jobproperties
+            #doMVATrackClassification = jobproperties.tauRecFlags.tauRecMVATrackClassification()
 
-            if InDetFlags.doVertexFinding():
-                tools.append(taualgs.getTauVertexFinder(doUseTJVA=self.do_TJVA)) 
-            tools.append(taualgs.getTauAxis())
-            tools.append(taualgs.getTauTrackFinder(removeDuplicateTracks=(not doMVATrackClassification) ))
-            if doMVATrackClassification : tools.append(taualgs.getTauTrackClassifier())
-            tools.append(taualgs.getEnergyCalibrationLC(correctEnergy=True, correctAxis=False, postfix='_onlyEnergy'))
-            tools.append(taualgs.getCellVariables())
-            tools.append(taualgs.getElectronVetoVars())
+            #if InDetFlags.doVertexFinding():
+            #    tools.append(taualgs.getTauVertexFinder(doUseTJVA=self.do_TJVA)) 
+            #tools.append(taualgs.getTauAxis())
+            #tools.append(taualgs.getTauTrackFinder(removeDuplicateTracks=(not doMVATrackClassification) ))
+            #if doMVATrackClassification : tools.append(taualgs.getTauTrackClassifier())
+            #tools.append(taualgs.getEnergyCalibrationLC(correctEnergy=True, correctAxis=False, postfix='_onlyEnergy'))
+            #tools.append(taualgs.getCellVariables())
+            #tools.append(taualgs.getElectronVetoVars())
             #
-            tools.append(taualgs.getTauTrackFilter())
-            tools.append(taualgs.getTauGenericPi0Cone())
+            #tools.append(taualgs.getTauTrackFilter())
+            #tools.append(taualgs.getTauGenericPi0Cone())
             #
-            #tools.append(taualgs.getPi0EflowCreateROI())
-            tools.append(taualgs.getTauShotFinder()) 
-            if self.doPi0Clus:
-                tools.append(taualgs.getPi0ClusterFinder())
+            ### already commented out#tools.append(taualgs.getPi0EflowCreateROI())
+            #tools.append(taualgs.getTauShotFinder()) 
+            #if self.doPi0Clus:
+            #    tools.append(taualgs.getPi0ClusterFinder())
 
             #####################################################################
             ## Tau Conversation Finder (found no one talking here...)
             ## TODO: talk with KG about the status of the new PhotonConversionFinder 
             ## new PhotonConversionFinder is currently disabled (time consumption!)
             ## old one is still in use
-            import tauRec.TauConversionAlgorithms
-            from tauRec.tauRecFlags import jobproperties
-            if jobproperties.tauRecFlags.useNewPIDBasedConvFinder():
+            #import tauRec.TauConversionAlgorithms
+            #from tauRec.tauRecFlags import jobproperties
+            #if jobproperties.tauRecFlags.useNewPIDBasedConvFinder():
                 #Needs to run alone
-                tools.append(tauRec.TauConversionAlgorithms.getTauConversionTaggerTool())
-            else:
+                #tools.append(tauRec.TauConversionAlgorithms.getTauConversionTaggerTool())
+            #else:
                 #Need to run together, they will select either PID or vertex based on another flag
-                tools.append(tauRec.TauConversionAlgorithms.getPhotonConversionTool())
-                tools.append(tauRec.TauConversionAlgorithms.getTauConversionFinderTool())
+                #tools.append(tauRec.TauConversionAlgorithms.getPhotonConversionTool())
+                #tools.append(tauRec.TauConversionAlgorithms.getTauConversionFinderTool())
             
-            #tools.append(taualgs.getContainerLock())
+            ##already commented out#tools.append(taualgs.getContainerLock())
             
             from tauRec.tauRecFlags import tauFlags
             tools+=tauFlags.tauRecToolsDevToolList()
             TauRecConfigured.AddToolsToToolSvc(self, tools)
-            self.TauBuilderToolHandle().Tools = tools
+            #self.TauBuilderToolHandle().Tools = tools
             
         except Exception:
             mlog.error("could not append tools to TauBuilder")
@@ -147,7 +150,7 @@ class TauRecCoreBuilder ( TauRecConfigured ) :
             return False
         
         # run first part of Tau Builder
-        TauRecConfigured.WrapTauRecToolExecHandle(self, tool=self.TauBuilderToolHandle())
+        TauRecConfigured.WrapTauRecToolExecHandle(self, tool=tools)
         return True
         
     # Helpers 

Reconstruction/tauRec/python/TauRecConfigured.py

@@ -14,6 +14,7 @@
 ################################################################################
 
 from RecExConfig.Configured import Configured
+from AthenaCommon.SystemOfUnits import *
 
 ################################################################################
 ## @class TauRecConfigured
@@ -28,24 +29,49 @@ class TauRecConfigured ( Configured ) :
         self.name = name
         self.msglevel = msglevel
         from tauRec.tauRecConf import TauProcessorAlg 
-        self._TauProcessorAlgHandle = TauProcessorAlg ( name=self.name+'Alg')
+        from tauRec.tauRecFlags import tauFlags
+        self._TauProcessorAlgHandle = TauProcessorAlg ( name=self.name+'Alg',
+                                                        Key_jetInputContainer="AntiKt4LCTopoJets",
+                                                        Key_tauOutputContainer="TauJets",
+                                                        Key_tauTrackOutputContainer="TauTracks",
+                                                        #MaxEta = 2.5,                                                                         
+                                                        MaxEta = tauFlags.tauRecSeedMaxEta(),
+                                                        MinPt = 10.*GeV,
+                                                        doCreateTauContainers = True)
+
         Configured.__init__(self, ignoreExistingDataObject=ignoreExistingDataObject)
 
 
     def WrapTauRecToolExecHandle(self, tool=None ):
-        self.TauProcessorAlgHandle().Tools = [tool]
+        self.TauProcessorAlgHandle().Tools = tool
         #self.TauProcessorAlgHandle().name = tool.name+'Alg'
         from AthenaCommon.AlgSequence import AlgSequence
+
         topSequence = AlgSequence()
+
+        from SGComps.SGCompsConf import SGInputLoader
+        # not needed? There by default now?
+        topSequence += SGInputLoader()
+        topSequence.SGInputLoader.Load = [ ('xAOD::JetContainer','AntiKt4LCTopoJets'), ('xAOD::VertexContainer', 'PrimaryVertices'),
+                                           ('xAOD::TrackParticleContainer','InDetTrackParticles'), ('CaloCellContainer','AllCalo') ]
         topSequence += self.TauProcessorAlgHandle()
 
     def WrapTauRecToolExecHandles(self, tools=[]):
         self.TauProcessorAlgHandle().Tools = tools
-        #self.TauProcessorAlgHandle().name = name
+        for tool in tools:
+            self.TauProcessorAlghandle().tool.getFullName = tool
+
         from AthenaCommon.AlgSequence import AlgSequence
         topSequence = AlgSequence()
+
+        from SGComps.SGCompsConf import SGInputLoader
+        # not needed? There by default now?
+        topSequence += SGInputLoader(OutputLevel=INFO)
+        topSequence.SGInputLoader.Load = [ ('xAOD::JetContainer','AntiKt4LCTopoJets'), ('xAOD::VertexContainer', 'PrimaryVertices'),
+                                           ('xAOD::TrackParticleContainer','InDetTrackParticles'), ('CaloCellContainer','AllCalo') ]
         topSequence += self.TauProcessorAlgHandle()
 
+
     def AddToolsToToolSvc(self, tools=[]):
         from AthenaCommon.AppMgr import ToolSvc
         from tauRec.tauRecFlags import tauFlags

Reconstruction/tauRec/share/run_tau_standalone.py

+# minimal set of job options to run tau reco on an ESD file
+# uses main TauRecRunner script
+
+#from GaudiHive.GaudiHiveConf import ForwardSchedulerSvc
+# Check for unmet data dependencies
+
+#svcMgr += ForwardSchedulerSvc()
+#svcMgr.ForwardSchedulerSvc.CheckDependencies = True
+
+# MT-specific code
+# Get number of processes and threads
+from AthenaCommon.ConcurrencyFlags import jobproperties as jp
+nThreads = jp.ConcurrencyFlags.NumThreads()
+nProc = jp.ConcurrencyFlags.NumProcs()
+
+theApp.EvtMax = 10
+
+if nThreads >=1 :
+   # Support for the MT-MP hybrid mode
+   if (nProc > 0) :
+
+      from AthenaCommon.Logging import log as msg
+      if (theApp.EvtMax == -1) :
+         msg.fatal('EvtMax must be >0 for hybrid configuration')
+         sys.exit(AthenaCommon.ExitCodes.CONFIGURATION_ERROR)
+
+         if ( theApp.EvtMax % nProc != 0 ) :
+            msg.warning('EvtMax[%s] is not divisible by nProcs[%s]: MP Workers will not process all requested events',theApp.EvtMax,nProc)
+
+         chunkSize = int (theApp.EvtMax / nProc)
+
+         from AthenaMP.AthenaMPFlags import jobproperties as jps
+         jps.AthenaMPFlags.ChunkSize= chunkSize
+
+         msg.info('AthenaMP workers will process %s events each',chunkSize)
+
+# Set input files
+from AthenaCommon.AthenaCommonFlags import athenaCommonFlags
+athenaCommonFlags.FilesInput=["/afs/cern.ch/work/a/adbailey/public/ESD/mc16_13TeV.301046.PowhegPythia8EvtGen_AZNLOCTEQ6L1_DYtautau_1000M1250.recon.ESD.e3649_s3170_r9466/ESD.11318157._000005.pool.root.1"]
+
+# and add to svcMgr
+import AthenaPoolCnvSvc.ReadAthenaPool
+svcMgr.EventSelector.InputCollections = athenaCommonFlags.FilesInput()
+
+### This can go into config file  ###
+
+# Magnetic Field
+from AthenaCommon.GlobalFlags import globalflags
+globalflags.DetGeo = 'atlas'
+from AthenaCommon.DetFlags import DetFlags
+DetFlags.detdescr.Calo_setOn()
+DetFlags.detdescr.ID_setOn()
+if hasattr(DetFlags,'BField_on'): DetFlags.BField_setOn()
+from TrkDetDescrSvc.AtlasTrackingGeometrySvc import AtlasTrackingGeometrySvc
+AtlasTrackingGeometrySvc  = svcMgr.AtlasTrackingGeometrySvc
+include('RecExCond/AllDet_detDescr.py')
+#Magnetic field is now setup
+
+# Detector Description
+from AthenaCommon.GlobalFlags import globalflags
+globalflags.DetGeo = 'atlas'
+from AthenaCommon.DetFlags import DetFlags
+DetFlags.detdescr.all_setOff()
+DetFlags.detdescr.Muon_setOn()
+if hasattr(DetFlags,'BField_on'): DetFlags.BField_setOn()
+from TrkDetDescrSvc.AtlasTrackingGeometrySvc import AtlasTrackingGeometrySvc
+AtlasTrackingGeometrySvc  = svcMgr.AtlasTrackingGeometrySvc
+include('RecExCond/AllDet_detDescr.py')
+
+from AtlasGeoModel import SetGeometryVersion
+from AtlasGeoModel import GeoModelInit
+
+# RecEx config
+from RecExConfig.RecFlags import rec
+rec.AutoConfiguration = ['everything']
+import RecExConfig.AutoConfiguration as auto
+auto.ConfigureFromListOfKeys(rec.AutoConfiguration())
+
+from AthenaCommon.BeamFlags import jobproperties
+from AthenaCommon.GlobalFlags import globalflags
+import AthenaCommon.SystemOfUnits as Units
+from tauRec.tauRecFlags import jobproperties as taujp
+
+rec.doEgamma.set_Value_and_Lock(False)
+rec.doMuon.set_Value_and_Lock(False)
+
+# CaloRec config
+from CaloRec.CaloRecFlags import jobproperties
+jobproperties.CaloRecFlags.Enabled.set_Value_and_Lock(False)
+jobproperties.CaloRecFlags.doCaloCluster.set_Value_and_Lock(False)
+jobproperties.CaloRecFlags.doCaloTopoCluster.set_Value_and_Lock(False)
+
+### End into config file  ###
+
+# use Tau Jet Vertex Association Tool
+# each Tau candidate gets its own primary vertex
+# and the tracks are selected accroding to this vertex
+_doTJVA = True
+
+# Pi0-finding algorithm
+_doPi0Clus = taujp.tauRecFlags.doPi0() #False by default
+_doPi0Clus = True
+
+# the TauCoreBuilder
+from tauRec.TauRecBuilder import TauRecCoreBuilder
+TauRecCoreBuilder(doPi0Clus=_doPi0Clus, doTJVA=_doTJVA)
+
+#include("tauRec/Pi0ClusterMaker_Crakow_jobOptions.py")
+#if _doPi0Clus:
+#    include("tauRec/Pi0ClusterMaker_jobOptions.py")
+
+
+# minimal set of job options to run tau reco on an ESD file
+# uses main TauRecRunner script
+
+#from GaudiHive.GaudiHiveConf import ForwardSchedulerSvc
+# Check for unmet data dependencies
+
+#svcMgr += ForwardSchedulerSvc()
+#svcMgr.ForwardSchedulerSvc.CheckDependencies = True

Reconstruction/tauRec/share/tauRec_jobOptions.py

@@ -32,10 +32,10 @@ TauRecCoreBuilder(doPi0Clus=_doPi0Clus, doTJVA=_doTJVA)
 if _doPi0Clus:
     include("tauRec/Pi0ClusterMaker_jobOptions.py")
 
-from tauRec.TauRecBuilder import TauRecPi0EflowProcessor
-TauRecPi0EflowProcessor(doPi0Clus=_doPi0Clus)
+#from tauRec.TauRecBuilder import TauRecPi0EflowProcessor
+#TauRecPi0EflowProcessor(doPi0Clus=_doPi0Clus)
 
-from tauRec.TauRecBuilder import TauRecVariablesProcessor
-TauRecVariablesProcessor(doPi0Clus=_doPi0Clus)
+#from tauRec.TauRecBuilder import TauRecVariablesProcessor
+#TauRecVariablesProcessor(doPi0Clus=_doPi0Clus)
 
 

Reconstruction/tauRec/src/TauProcessorAlg.cxx

@@ -6,15 +6,36 @@
 
 #include "tauRec/TauProcessorAlg.h"
 
+#include "xAODJet/Jet.h"
+#include "xAODJet/JetContainer.h"
+
+
+#include "xAODTau/TauJetContainer.h"
+#include "xAODTau/TauJetAuxContainer.h"
+#include "xAODTau/TauDefs.h"
+#include "xAODTau/TauTrackContainer.h"
+#include "xAODTau/TauTrackAuxContainer.h"
+
+#include "StoreGate/ReadHandle.h"
+#include "StoreGate/WriteHandle.h"
+
+
 //-----------------------------------------------------------------------------
 // Constructor
 //-----------------------------------------------------------------------------
 TauProcessorAlg::TauProcessorAlg(const std::string &name,
     ISvcLocator * pSvcLocator) :
 AthAlgorithm(name, pSvcLocator),
-m_tools(this) //make tools private
+m_tools(this), //make tools private
+m_maxEta(2.5),
+m_minPt(10000),
+m_doCreateTauContainers(false),
+m_data()
 {
   declareProperty("Tools", m_tools);
+  declareProperty("MaxEta", m_maxEta);
+  declareProperty("MinPt", m_minPt);
+  declareProperty("doCreateTauContainers", m_doCreateTauContainers);
 }
 
 //-----------------------------------------------------------------------------
@@ -40,15 +61,17 @@ StatusCode TauProcessorAlg::initialize() {
     }
 
     StatusCode sc;
-    
+
+
     //-------------------------------------------------------------------------
     // Allocate tools
     //-------------------------------------------------------------------------
-    ToolHandleArray<ITauToolExecBase> ::iterator itT = m_tools.begin();
-    ToolHandleArray<ITauToolExecBase> ::iterator itTE = m_tools.end();
+    ToolHandleArray<ITauToolBase> ::iterator itT = m_tools.begin();
+    ToolHandleArray<ITauToolBase> ::iterator itTE = m_tools.end();
     ATH_MSG_INFO("List of tools in execution sequence:");
     ATH_MSG_INFO("------------------------------------");
 
+
     unsigned int tool_count = 0;
 
     for (; itT != itTE; ++itT) {
@@ -59,7 +82,8 @@ StatusCode TauProcessorAlg::initialize() {
         } else {
             ++tool_count;
             ATH_MSG_INFO((*itT)->type() << " - " << (*itT)->name());
-        }
+	    (*itT)->setTauEventData(&m_data);
+	}
     }
     ATH_MSG_INFO(" ");
     ATH_MSG_INFO("------------------------------------");
@@ -71,6 +95,10 @@ StatusCode TauProcessorAlg::initialize() {
 
     ///////////////////////////////////////////////////////////////////////////
 
+    ATH_CHECK( m_jetInputContainer.initialize() );
+    ATH_CHECK( m_tauOutputContainer.initialize() );
+    ATH_CHECK( m_tauTrackOutputContainer.initialize() );
+
     return StatusCode::SUCCESS;
 }
 
@@ -84,8 +112,8 @@ StatusCode TauProcessorAlg::finalize() {
   //-----------------------------------------------------------------
   // Loop stops when Failure indicated by one of the tools
   //-----------------------------------------------------------------
-  ToolHandleArray<ITauToolExecBase> ::iterator itT = m_tools.begin();
-  ToolHandleArray<ITauToolExecBase> ::iterator itTE = m_tools.end();
+  ToolHandleArray<ITauToolBase> ::iterator itT = m_tools.begin();
+  ToolHandleArray<ITauToolBase> ::iterator itTE = m_tools.end();
   for (; itT != itTE; ++itT) {
     ATH_MSG_VERBOSE("Invoking tool " << (*itT)->name());
     sc = (*itT)->finalize();
@@ -111,17 +139,149 @@ StatusCode TauProcessorAlg::execute() {
   
   StatusCode sc;
 
-  //-----------------------------------------------------------------
-  // Loop stops when Failure indicated by one of the tools
-  //-----------------------------------------------------------------
-  ToolHandleArray<ITauToolExecBase> ::iterator itT = m_tools.begin();
-  ToolHandleArray<ITauToolExecBase> ::iterator itTE = m_tools.end();
-  for (; itT != itTE; ++itT) {
-    ATH_MSG_VERBOSE("Invoking tool " << (*itT)->name());
-    sc = (*itT)->execute();
-    if (sc.isFailure())
-      break;
-  }
+  
+    // Declare containers                                                                                                                                          
+    xAOD::TauJetContainer * pContainer = 0;
+    xAOD::TauJetAuxContainer* pAuxContainer = 0;
+    xAOD::TauTrackContainer* pTracks = 0;
+    xAOD::TauTrackAuxContainer* pAuxTracks = 0;
+
+    // Declare write handles                                                                                                                                       
+    SG::WriteHandle<xAOD::TauJetContainer> tauHandle( m_tauOutputContainer );
+    ATH_MSG_INFO("  write: " << tauHandle.key() << " = " << "..." );
+    SG::WriteHandle<xAOD::TauTrackContainer> tauTrackHandle( m_tauTrackOutputContainer );
+    ATH_MSG_INFO("  write: " << tauTrackHandle.key() << " = " << "..." );
+
+    if (m_doCreateTauContainers) {
+      //-------------------------------------------------------------------------                         
+      // Create and Record containers
+      //-------------------------------------------------------------------------                 
+      pContainer = new xAOD::TauJetContainer();
+      pAuxContainer = new xAOD::TauJetAuxContainer();
+      pContainer->setStore( pAuxContainer );
+
+
+      pTracks = new xAOD::TauTrackContainer();
+      pAuxTracks = new xAOD::TauTrackAuxContainer();
+      pTracks->setStore( pAuxTracks );
+
+
+    } else {
+      //-------------------------------------------------------------------------                                             
+      // retrieve Tau Containers from StoreGate                                                                                     
+      //-------------------------------------------------------------------------                                    
+      // replace with read handles
+      sc = evtStore()->retrieve(pContainer, "TauJets");
+      if (sc.isFailure()) {
+	ATH_MSG_FATAL("Failed to retrieve " << "TauJets");
+	return StatusCode::FAILURE;
+      }
+    }
+
+
+    //-------------------------------------------------------------------------                        
+    // Initialize tools for this event
+    //-------------------------------------------------------------------------                                                      
+    ToolHandleArray<ITauToolBase> ::iterator itT = m_tools.begin();
+    ToolHandleArray<ITauToolBase> ::iterator itTE = m_tools.end();
+    for (; itT != itTE; ++itT) {
+      sc = (*itT)->eventInitialize();
+      if (sc != StatusCode::SUCCESS)
+	return StatusCode::FAILURE;
+    }
+
+
+    //---------------------------------------------------------------------                                                    
+    // Retrieve seed Container from TDS, return `failure if no                                        
+    // existing                                                                                                                        
+    //---------------------------------------------------------------------                                                       
+    SG::ReadHandle<xAOD::JetContainer> jetHandle( m_jetInputContainer );
+    if (!jetHandle.isValid()) {
+      ATH_MSG_ERROR ("Could not retrieve HiveDataObj with key " << jetHandle.key());
+      return StatusCode::FAILURE;
+    }
+    const xAOD::JetContainer *pSeedContainer = 0;
+    pSeedContainer = jetHandle.cptr();
+
+
+    
+
+    //---------------------------------------------------------------------                                                        
+    // Loop over seeds
+    //---------------------------------------------------------------------                                                 
+    xAOD::JetContainer::const_iterator itS = pSeedContainer->begin();
+    xAOD::JetContainer::const_iterator itSE = pSeedContainer->end();
+
+    ATH_MSG_VERBOSE("Number of seeds in the container: " << pSeedContainer->size());
+
+    for (; itS != itSE; ++itS) {
+
+      const xAOD::Jet *pSeed = (*itS);
+      ATH_MSG_VERBOSE("Seeds eta:" << pSeed->eta() << ", pt:" << pSeed->pt());
+
+      if (fabs(pSeed->eta()) > m_maxEta) {
+	ATH_MSG_VERBOSE("--> Seed rejected, eta out of range!");
+	continue;
+      }
+
+      if (fabs(pSeed->pt()) < m_minPt) {
+	ATH_MSG_VERBOSE("--> Seed rejected, pt out of range!");
+	continue;
+      }
+
+      //-----------------------------------------------------------------                                                                 
+      // Seed passed cuts --> create tau candidate
+      //-----------------------------------------------------------------                                                                           
+      xAOD::TauJet* pTau = new xAOD::TauJet();
+      pContainer->push_back( pTau );
+      pTau->setJet(pSeedContainer, pSeed);
+
+      //-----------------------------------------------------------------
+      // Loop stops when Failure indicated by one of the tools
+      //-----------------------------------------------------------------
+      ToolHandleArray<ITauToolBase> ::iterator itT = m_tools.begin();
+      ToolHandleArray<ITauToolBase> ::iterator itTE = m_tools.end();
+      for (; itT != itTE; ++itT) {
+	ATH_MSG_INFO("ProcessorAlg Invoking tool " << (*itT)->name());
+	sc = (*itT)->execute(*pTau);
+	if (sc.isFailure())
+	  break;
+      }
+      
+      if (sc.isSuccess()) {
+
+	ATH_MSG_VERBOSE("The tau candidate has been registered");
+     
+      } else if (!sc.isSuccess()) {
+	//remove orphaned tracks before tau is deleted via pop_back
+	xAOD::TauJet* bad_tau = pContainer->back();
+	ATH_MSG_DEBUG("Deleting " << bad_tau->nAllTracks() << "Tracks associated with tau: ");
+	pTracks->erase(pTracks->end()-bad_tau->nAllTracks(), pTracks->end());
+
+	//m_data.xAODTauContainer->pop_back();
+	pContainer->pop_back();
+      } else{
+
+	//remove orphaned tracks before tau is deleted via pop_back
+	xAOD::TauJet* bad_tau = pContainer->back();
+	ATH_MSG_DEBUG("Deleting " << bad_tau->nAllTracks() << "Tracks associated with tau: ");
+	pTracks->erase(pTracks->end()-bad_tau->nAllTracks(), pTracks->end());
+
+	//m_data.xAODTauContainer->pop_back();
+	pContainer->pop_back();
+      }
+
+
+    }// loop through seeds
+
+    itT = m_tools.begin();
+    itTE = m_tools.end();
+    for (; itT != itTE; ++itT) {
+      sc = (*itT)->eventFinalize();
+      if (sc != StatusCode::SUCCESS)
+	return StatusCode::FAILURE;
+    }
+
 
   if (sc.isSuccess()) {
     ATH_MSG_VERBOSE("The tau candidate container has been modified");
@@ -129,6 +289,8 @@ StatusCode TauProcessorAlg::execute() {
   } else  {
   }
 
+  ATH_CHECK(tauHandle.record(std::unique_ptr<xAOD::TauJetContainer>{pContainer}, std::unique_ptr<xAOD::TauJetAuxContainer>{pAuxContainer}));
+  ATH_CHECK(tauTrackHandle.record(std::unique_ptr<xAOD::TauTrackContainer>{pTracks}, std::unique_ptr<xAOD::TauTrackAuxContainer>{pAuxTracks}));
 
   return StatusCode::SUCCESS;
 }

Reconstruction/tauRec/tauRec/TauProcessorAlg.h

@@ -8,6 +8,12 @@
 #include "GaudiKernel/ToolHandle.h"
 #include "AthenaBaseComps/AthAlgorithm.h"
 #include "tauRecTools/ITauToolExecBase.h"
+#include "tauRecTools/ITauToolBase.h"
+
+#include "tauRecTools/TauEventData.h"
+
+#include "StoreGate/ReadHandle.h"
+#include "StoreGate/WriteHandle.h"
 
 /**
  * @brief       Main class for tau candidate processing.
@@ -30,7 +36,22 @@ class TauProcessorAlg: public AthAlgorithm
         virtual StatusCode finalize();
 
     private:
-        ToolHandleArray<ITauToolExecBase>  m_tools;
+       
+	ToolHandleArray<ITauToolBase>  m_tools;
+
+	double m_maxEta; //!< only build taus with eta_seed < m_maxeta
+	double m_minPt;  //!< only build taus with pt_seed > m_minpt
+
+	bool m_doCreateTauContainers;
+
+        //ToolHandleArray<ITauToolExecBase>  m_tools;
+	TauEventData m_data;
+
+	SG::ReadHandleKey<xAOD::JetContainer> m_jetInputContainer{this,"Key_jetInputContainer","AntiKt4LCTopoJets","input jet key"};
+	SG::WriteHandleKey<xAOD::TauJetContainer> m_tauOutputContainer{this,"Key_tauOutputContainer","TauJets","output tau data key"};
+	SG::WriteHandleKey<xAOD::TauTrackContainer> m_tauTrackOutputContainer{this,"Key_tauTrackOutputContainer","TauTracks","output tau tracks data key"};
+
+	
 };
 
 #endif // TAUREC_TAUPROCESSORALG_H

Reconstruction/tauRecTools/src/JetSeedBuilder.cxx

@@ -95,34 +95,6 @@ StatusCode JetSeedBuilder::execute(xAOD::TauJet& pTau) {
 
 	const xAOD::JetContainer *pJetColl;
 
-	if (sc.isSuccess() && inTrigger) {
-		// called by Trigger
-		// retrieve JetCollection for trigger
-		ATH_MSG_DEBUG("Try to retrieve object from DataContainer");
-		//sc = tauEventData()->getObject("JetCollection", pJetColl);
-		// Try a different approach: grab it directly
-		sc = StatusCode::SUCCESS;
-		pJetColl = tauEventData()->seedContainer;
-		if (sc.isFailure() || !pJetColl) {
-			ATH_MSG_DEBUG("no JetCollection for trigger available");
-			ATH_MSG_DEBUG("retrieve standard JetCollection <" << m_jetCollectionName << ">");
-			// retrieve standard jet collection
-			sc = evtStore()->retrieve(pJetColl, m_jetCollectionName);
-			if (sc.isFailure()) {
-				ATH_MSG_WARNING("no JetCollection retrieved");
-				return StatusCode::FAILURE;
-			}
-		}
-	} else {
-		// called by offline tauRec
-		// retrieve standard jet collection
-		sc = evtStore()->retrieve(pJetColl, m_jetCollectionName);
-		if (sc.isFailure()) {
-			ATH_MSG_WARNING("no JetCollection retrieved");
-			return StatusCode::FAILURE;
-		}
-	}
-
 	ATH_MSG_DEBUG("Pulling out the seed");
 
 	const xAOD::Jet* pJetSeed = 0;
@@ -139,27 +111,6 @@ StatusCode JetSeedBuilder::execute(xAOD::TauJet& pTau) {
 			<< " phi=" << pJetSeed->phi()
 	);
 
-	xAOD::TauJetContainer* pContainer = tauEventData()->xAODTauContainer;
-	if(pContainer==0){
-	  pContainer = static_cast<xAOD::TauJetContainer*> (pTau.container());
-	}
-	if(pContainer==0) {
-	  ATH_MSG_FATAL("Can't find tau Container");
-	  return StatusCode::FAILURE;
-	}
-	
-	xAOD::TauJetContainer::iterator itTau = pContainer->begin();
-	xAOD::TauJetContainer::iterator itTauE = pContainer->end();
-
-	for (; itTau != itTauE; ++itTau) {
-	  if( (*itTau) == &pTau ) continue;
-		if ( (*itTau)->jetLink().isValid() ) {
-			if ( pJetSeed == ( * (*itTau)->jetLink() ) ) {
-				ATH_MSG_DEBUG("seed already used");
-				return StatusCode::FAILURE;
-			}
-		}
-	}
 
 	///XXX need to decide whether to remove this, because there's no author flag in xAOD::TauJet