Added prototype for second algorithm, to create shallow copy of temporary...

Added prototype for second algorithm, to create shallow copy of temporary TauJets container, run decoration tools, then write final container. Also added import to Pi0ClusterMaker job options


Former-commit-id: 9316f3d7

Reconstruction/tauRec/python/TauRecRunConfigured.py

+# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+
+################################################################################
+##
+#@file TauRecRunConfigured.py
+#
+#@brief Auxilary class used by TauRec[AOD]Builder.py
+#@brief Main tau algorithms in TauRecBuilder.py are actually tools and not algs
+#@brief this class facilitates an easy method of wrapping the TauRecBuilder tools
+#@brief with a dummy algorithm, TauProcessorAlg.cxx
+#
+#@author J. Griffiths
+#
+################################################################################
+
+from RecExConfig.Configured import Configured
+from AthenaCommon.SystemOfUnits import *
+
+################################################################################
+## @class TauRecRunConfigured
+# Make TauRecXYZ public this class
+################################################################################
+class TauRecRunConfigured ( Configured ) :
+    """Intermediate class which wraps up a ITauToolExecBase
+    into a tauRec/TauProcessorAlg algorithm
+    """
+
+    def __init__(self, name = "TauRecRunConfigured", msglevel=3, ignoreExistingDataObject=True) :
+        self.name = name
+        self.msglevel = msglevel
+        from tauRec.tauRecConf import TauRunnerAlg 
+        from tauRec.tauRecFlags import tauFlags
+        self._TauRunnerAlgHandle = TauRunnerAlg ( name=self.name+'Alg', 
+                                                  Key_tauInputContainer="tmp_TauJets",
+                                                  Key_tauOutputContainer="TauJets")
+                                                                                                
+        Configured.__init__(self, ignoreExistingDataObject=ignoreExistingDataObject)
+
+
+    def WrapTauRecToolExecHandle(self, tool=None ):
+        print "RUN RECRUNNER"
+        self.TauRunnerAlgHandle().Tools = tool
+        from AthenaCommon.AlgSequence import AlgSequence
+
+        topSequence = AlgSequence()
+
+        #from AthenaCommon.AlgScheduler import AlgScheduler
+        #AlgScheduler.ShowDataDependencies(True)
+        #AlgScheduler.ShowControlFlow(True)
+        
+        #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.TauRunnerAlgHandle()
+
+    def AddToolsToToolSvc(self, tools=[]):
+        from AthenaCommon.AppMgr import ToolSvc
+        from tauRec.tauRecFlags import tauFlags
+        for tool in tools :
+            # if tool.__slots__['calibFolder'].count('TauDiscriminant'):
+            #     tool.calibFolder = tauFlags.TauDiscriminantCVMFSPath()
+            # else :
+            #     tool.calibFolder = tauFlags.tauRecToolsCVMFSPath()
+            tool.calibFolder = tauFlags.tauRecToolsCVMFSPath()
+            if tool not in ToolSvc : ToolSvc += tool
+            pass
+
+
+
+    def TauRunnerAlgHandle(self):
+        return self._TauRunnerAlgHandle
+

Reconstruction/tauRec/python/TauRecRunner.py

+# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+
+################################################################################
+##
+#@file TauRecBuilder.py
+#
+#@brief Main steering file to set up the different tau reconstruction steps.
+#
+#@author N. Meyer
+#@author A. Kaczmarska
+#@author Felix Friedrich
+#
+################################################################################
+
+import os, sys, string
+
+from AthenaCommon.Logging import logging
+from AthenaCommon.SystemOfUnits import *
+from AthenaCommon.Constants import *
+from AthenaCommon.BeamFlags import jobproperties
+import traceback
+
+from RecExConfig.Configured import Configured
+from TauRecRunConfigured import TauRecRunConfigured
+
+# global tauRec config keys
+_outputType = "xAOD::TauJetContainer"
+_outputKey = "TauJets"
+_outputAuxType = "xAOD::TauJetAuxContainer"
+_outputAuxKey = "TauJetsAux."
+_track_collection = "InDetTrackParticles"
+_jet_collection = "AntiKt4LCTopoJets"
+
+################################################################################
+## @class TauRecRunner
+# Build proper tau candidates and associate tracks, vertex and cells
+################################################################################
+class TauRecRunner ( TauRecRunConfigured ) :
+    """Build proper tau candidates and associate tracks, vertex and cells. 
+    Calculate properties based on cell informations. 
+    Find clusters used for Pi0 identification and eflow variables.
+    PhotonConversion will be run here too.
+    """
+  
+    _output     = { _outputType:_outputKey , _outputAuxType:_outputAuxKey }
+    
+    def __init__(self, name = "TauRecRunner",doPi0Clus=False, doTJVA=False):
+        self.name = name
+        self.doPi0Clus = doPi0Clus
+        self.do_TJVA = doTJVA
+        TauRecRunConfigured.__init__(self, name)
+
+
+ 
+    def configure(self):
+        mlog = logging.getLogger ('TauRecRunner.py::configure:')
+        mlog.info('entering')
+                
+        from RecExConfig.RecFlags import rec    
+        
+        # xxx ToDo: still needed?        
+        from RecExConfig.ObjKeyStore import objKeyStore
+        objKeyStore.addManyTypesStreamESD(self._output)
+        objKeyStore.addManyTypesStreamAOD(self._output)              
+        
+        import tauRec.TauAlgorithmsHolder as taualgs
+        
+        from tauRec.tauRecFlags import tauFlags
+                
+        
+        tools = []
+        try:
+                        
+            ### TauRecPi0EflowProcessor ###
+            # Tools in this section were originally in TauRecPi0EflowProcessor
+            #if self.doPi0Clus: tools.append(taualgs.getPi0ClusterCreator())
+            
+            ###############################
+
+            ### TauRecVariablesProcessor ###
+            from InDetRecExample.InDetJobProperties import InDetFlags
+            # Tools in this section were originally in TauRecVariablesProcessor
+            if InDetFlags.doVertexFinding():
+                tools.append(taualgs.getTauVertexVariables())
+            
+            #tools.append(taualgs.getTauCommonCalcVars())
+            #tools.append(taualgs.getTauSubstructure())
+
+            #if self.doPi0Clus: 
+             #   tools.append(taualgs.getPi0ClusterScaler())
+              #  tools.append(taualgs.getPi0ScoreCalculator())
+                # SWITCHED OFF SELECTOR< SINCE NO CHARGED PFOS AVAILABLE ATM
+               # tools.append(taualgs.getPi0Selector())
+
+            #tools.append(taualgs.getEnergyCalibrationLC(correctEnergy=False, correctAxis=True, postfix='_onlyAxis'))
+
+            # PanTau:
+            #if tauFlags.doPanTau() :
+             #   import PanTauAlgs.JobOptions_Main_PanTau as pantau
+              #  tools.append(pantau.getPanTau())
+ 
+            # these tools need pantau info
+            #tools.append(taualgs.getCombinedP4FromRecoTaus())
+            #tools.append(taualgs.getMvaTESVariableDecorator())
+            #tools.append(taualgs.getMvaTESEvaluator())
+
+            #if tauFlags.doRunTauDiscriminant():
+                #tools.append(taualgs.getTauIDVarCalculator())
+                #tools.append(taualgs.getTauJetBDTEvaluator("TauJetBDT1P", weightsFile="vars2016_pt_gamma_1p_isofix.root", minNTracks=0, maxNTracks=1)) #update config?
+                #tools.append(taualgs.getTauJetBDTEvaluator("TauJetBDT3P", weightsFile="vars2016_pt_gamma_3p_isofix.root", minNTracks=2, maxNTracks=1000)) #update config?
+                #tools.append(taualgs.getTauWPDecoratorJetBDT())
+                #tools.append(taualgs.getTauJetBDTEvaluator("TauEleBDT_def", weightsFile="", outputVarName="BDTEleScore"))#just inits values
+                #tools.append(taualgs.getTauJetBDTEvaluator("TauEleBDT_bar", 
+                 #                                          weightsFile="EleBDT1PBar.root", minNTracks=1, maxAbsTrackEta=1.37, 
+                  #                                         outputVarName="BDTEleScore")) #update config?
+                #tools.append(taualgs.getTauJetBDTEvaluator("TauEleBDT_end1", 
+                 #                                          weightsFile="EleBDT1PEnd1.root", minNTracks=1, minAbsTrackEta=1.37, 
+                  #                                         maxAbsTrackEta=2.0, outputVarName="BDTEleScore")) #update config?
+                #tools.append(taualgs.getTauJetBDTEvaluator("TauEleBDT_end23", 
+                 #                                          weightsFile="EleBDT1PEnd23.root", minNTracks=1, minAbsTrackEta=2.0, 
+                  #                                         maxAbsTrackEta=3.0, outputVarName="BDTEleScore")) #update config?
+                #tools.append(taualgs.getTauWPDecoratorEleBDT())
+                #tools.append(taualgs.getTauEleOLRDecorator())                
+            
+            ################################
+
+            from tauRec.tauRecFlags import tauFlags
+            tools+=tauFlags.tauRecToolsDevToolList()
+            TauRecRunConfigured.AddToolsToToolSvc(self, tools)
+            #self.TauBuilderToolHandle().Tools = tools
+            
+        except Exception:
+            mlog.error("could not append tools to TauRunner")
+            print traceback.format_exc()
+            return False
+        
+        # run first part of Tau Builder
+        TauRecRunConfigured.WrapTauRecToolExecHandle(self, tool=tools)
+        return True
+        
+
+    def outputKey(self):
+         return self._output[self._outputType]
+    
+    def outputType(self):
+         return self._outputType
+
+
+#end

Reconstruction/tauRec/share/Pi0ClusterMaker_jobOptions.py

@@ -313,4 +313,6 @@ if jobproperties.CaloTopoClusterFlags.doTopoClusterLocalCalib():
         CaloTopoForTausMaker.LocalCalibForTaus.LCClassify.MaxProbability = 0.50
         CaloTopoForTausMaker.LocalCalibForTaus.LCClassify.UseNormalizedEnergyDensity = True
 
+from AthenaCommon.AlgSequence import AlgSequence
+topSequence = AlgSequence()
 topSequence += CaloTopoForTausMaker

Reconstruction/tauRec/src/TauRunnerAlg.cxx

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#include "GaudiKernel/ListItem.h"
+
+#include "tauRec/TauRunnerAlg.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 "xAODCore/ShallowCopy.h"
+
+#include "StoreGate/ReadHandle.h"
+#include "StoreGate/WriteHandle.h"
+
+
+//-----------------------------------------------------------------------------
+// Constructor
+//-----------------------------------------------------------------------------
+TauRunnerAlg::TauRunnerAlg(const std::string &name,
+    ISvcLocator * pSvcLocator) :
+AthAlgorithm(name, pSvcLocator),
+m_tools(this), //make tools private
+m_data()
+{
+  declareProperty("Tools", m_tools);
+}
+
+//-----------------------------------------------------------------------------
+// Destructor
+//-----------------------------------------------------------------------------
+TauRunnerAlg::~TauRunnerAlg() {
+}
+
+//-----------------------------------------------------------------------------
+// Initializer
+//-----------------------------------------------------------------------------
+StatusCode TauRunnerAlg::initialize() {
+
+
+    //ATH_MSG_INFO("FF::TauRunnerAlg :: initialize()");
+
+    //-------------------------------------------------------------------------
+    // No tools allocated!
+    //-------------------------------------------------------------------------
+    if (m_tools.size() == 0) {
+        ATH_MSG_ERROR("no tools given!");
+        return StatusCode::FAILURE;
+    }
+
+    StatusCode sc;
+
+    //-------------------------------------------------------------------------
+    // Allocate tools
+    //-------------------------------------------------------------------------
+    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) {
+        sc = itT->retrieve();
+        if (sc.isFailure()) {
+            ATH_MSG_WARNING("Cannot find tool named <" << *itT << ">");
+	    return StatusCode::FAILURE;
+        } else {
+            ++tool_count;
+            ATH_MSG_INFO((*itT)->type() << " - " << (*itT)->name());
+	    (*itT)->setTauEventData(&m_data);
+	}
+    }
+    ATH_MSG_INFO(" ");
+    ATH_MSG_INFO("------------------------------------");
+
+    if (tool_count == 0) {
+        ATH_MSG_ERROR("could not allocate any tool!");
+        return StatusCode::FAILURE;
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+
+    ATH_CHECK( m_tauInputContainer.initialize() );
+    ATH_CHECK( m_tauOutputContainer.initialize() );
+
+    return StatusCode::SUCCESS;
+}
+
+//-----------------------------------------------------------------------------
+// Finalizer
+//-----------------------------------------------------------------------------
+StatusCode TauRunnerAlg::finalize() {
+
+  StatusCode sc;
+
+  //-----------------------------------------------------------------
+  // 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_VERBOSE("Invoking tool " << (*itT)->name());
+    sc = (*itT)->finalize();
+    if (sc.isFailure())
+      break;
+  }
+
+  if (sc.isSuccess()) {
+    ATH_MSG_VERBOSE("The tau candidate container has been modified");
+  } else if (!sc.isSuccess()) {
+  } else  {
+  }
+
+
+  return StatusCode::SUCCESS;
+
+}
+
+//-----------------------------------------------------------------------------
+// Execution
+//-----------------------------------------------------------------------------
+StatusCode TauRunnerAlg::execute() {
+  
+  StatusCode sc;
+  
+  //-------------------------------------------------------------------------                        
+    // 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;
+    }
+
+    // Declare container
+    const xAOD::TauJetContainer * pTauContainer = 0;
+
+    // Read in tau jets
+    SG::ReadHandle<xAOD::TauJetContainer> tauInputHandle(m_tauInputContainer);
+    if (!tauInputHandle.isValid()) {
+      ATH_MSG_ERROR ("Could not retrieve HiveDataObj with key " << tauInputHandle.key());
+      return StatusCode::FAILURE;
+    }
+    pTauContainer = tauInputHandle.cptr();
+
+    // create shallow copy, write that
+    std::pair< xAOD::TauJetContainer*, xAOD::ShallowAuxContainer* > taus_shallowCopy = xAOD::shallowCopyContainer( *pTauContainer );
+
+    SG::WriteHandle<xAOD::TauJetContainer> outputTauHandle(m_tauOutputContainer);
+    ATH_CHECK( outputTauHandle.record(std::unique_ptr<xAOD::TauJetContainer>(taus_shallowCopy.first), 
+				      std::unique_ptr<xAOD::ShallowAuxContainer>(taus_shallowCopy.second)) );    
+    
+    // iterate over the shallow copy
+    xAOD::TauJetContainer::iterator itTau = (taus_shallowCopy.first)->begin();
+    xAOD::TauJetContainer::iterator itTauE = (taus_shallowCopy.first)->end();
+    for (; itTau != itTauE; ++itTau) {
+
+      xAOD::TauJet* pTau = (*itTau);
+      //-----------------------------------------------------------------
+      // 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("RunnerAlg Invoking tool " << (*itT)->name());
+	sc = (*itT)->execute(*pTau);
+	if (sc.isFailure())
+	  break;
+      }
+
+    } // end iterator over shallow copy
+
+    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");
+  } else if (!sc.isSuccess()) {
+  } else  {
+  }
+  
+  ATH_MSG_INFO("Done Runner alg");
+  return StatusCode::SUCCESS;
+}

Reconstruction/tauRec/src/components/tauRec_entries.cxx

 // #include "tauRec/TauBuilder.h"
 // #include "tauRec/TauProcessor.h"
 #include "tauRec/TauProcessorAlg.h"
+#include "tauRec/TauRunnerAlg.h"
 #include "tauRec/TauTrackSlimmer.h"
 
 
 // DECLARE_COMPONENT( TauBuilder )
 // DECLARE_COMPONENT( TauProcessor )
 DECLARE_COMPONENT( TauProcessorAlg )
+DECLARE_COMPONENT( TauRunnerAlg )
 DECLARE_COMPONENT( TauTrackSlimmer )
 
+

Reconstruction/tauRec/tauRec/TauRunnerAlg.h

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef TAUREC_TAURUNNERALG_H
+#define TAUREC_TAURUNNERALG_H
+
+#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"
+
+#include "xAODPFlow/PFOContainer.h"
+#include "xAODPFlow/PFOAuxContainer.h"
+
+#include "xAODCaloEvent/CaloClusterContainer.h"
+#include "xAODCaloEvent/CaloClusterAuxContainer.h"
+
+
+/**
+ * @brief       Main class for tau candidate processing.
+ */
+
+class TauRunnerAlg: public AthAlgorithm
+{
+    public:
+        //-----------------------------------------------------------------
+        // Contructor and destructor
+        //-----------------------------------------------------------------
+        TauRunnerAlg( const std::string &name, ISvcLocator *pSvcLocator );
+        ~TauRunnerAlg();
+
+        //-----------------------------------------------------------------
+        // Gaudi algorithm hooks
+        //-----------------------------------------------------------------
+        virtual StatusCode initialize();
+        virtual StatusCode execute();
+        virtual StatusCode finalize();
+
+    private:
+       
+	ToolHandleArray<ITauToolBase>  m_tools;
+
+        //ToolHandleArray<ITauToolExecBase>  m_tools;
+	TauEventData m_data;
+
+	SG::ReadHandleKey<xAOD::TauJetContainer> m_tauInputContainer{this,"Key_tauInputContainer","tmp_TauJets","input temp tau key"};
+	SG::WriteHandleKey<xAOD::TauJetContainer> m_tauOutputContainer{this,"Key_tauOutputContainer","TauJets","output tau data key"};	
+	
+};
+
+#endif // TAUREC_TAURUNNERALG_H