diff --git a/Calorimeter/CaloRec/src/CaloTopoClusterMaker.cxx b/Calorimeter/CaloRec/src/CaloTopoClusterMaker.cxx
index 58ea72a1d36b209991361fda6f6cf3c42fde4a70..27bd406ff9664443b5ab62b963ec193bee3e2079 100644
--- a/Calorimeter/CaloRec/src/CaloTopoClusterMaker.cxx
+++ b/Calorimeter/CaloRec/src/CaloTopoClusterMaker.cxx
@@ -413,7 +413,7 @@ CaloTopoClusterMaker::execute(const EventContext& ctx,
return StatusCode::RECOVERABLE;
}
- const DataLink<CaloCellContainer> cellCollLink (cellColl.name());
+ const DataLink<CaloCellContainer> cellCollLink (cellColl.name(),ctx);
//ATH_MSG_DEBUG("CaloCell container: "<< cellsName
// <<" contains " << cellColl->size() << " cells");
diff --git a/Trigger/TrigAlgorithms/TrigTauRec/CMakeLists.txt b/Trigger/TrigAlgorithms/TrigTauRec/CMakeLists.txt
index 7c4a73ed5677e0af1227f4cc5fd5ba5611d1f315..533b8282cf561e5270da54f1f8c3aed02a46c67f 100644
--- a/Trigger/TrigAlgorithms/TrigTauRec/CMakeLists.txt
+++ b/Trigger/TrigAlgorithms/TrigTauRec/CMakeLists.txt
@@ -9,6 +9,7 @@ atlas_subdir( TrigTauRec )
atlas_depends_on_subdirs( PUBLIC
GaudiKernel
InnerDetector/InDetConditions/BeamSpotConditionsData
+ InnerDetector/InDetConditions/InDetBeamSpotService
LumiBlock/LumiBlockComps
Reconstruction/tauRecTools
Trigger/TrigEvent/TrigParticle
diff --git a/Trigger/TrigAlgorithms/TrigTauRec/python/TrigTauRecConfigMT.py b/Trigger/TrigAlgorithms/TrigTauRec/python/TrigTauRecConfigMT.py
new file mode 100644
index 0000000000000000000000000000000000000000..fa826a5d182109a09dcefa3eebec679a65b6d5b3
--- /dev/null
+++ b/Trigger/TrigAlgorithms/TrigTauRec/python/TrigTauRecConfigMT.py
@@ -0,0 +1,365 @@
+# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+
+
+""" TrigTauRec """
+
+__author__ = 'S.Xella, O.Igonkina, F.Friedrich'
+__version__ =""
+__doc__ ="Configuration of TrigTauRec"
+
+from AthenaCommon.Logging import logging
+from AthenaCommon.SystemOfUnits import *
+from AthenaCommon.Constants import *
+
+from TrigTauRec.TrigTauRecConf import TrigTauRecMergedMT
+from TriggerJobOpts.TriggerFlags import TriggerFlags
+
+from AthenaCommon.AppMgr import ToolSvc
+
+class TrigTauRecMerged_Tau (TrigTauRecMergedMT) :
+ __slots__ = [ '_mytools']
+ def __init__(self, name = "TrigTauRecMerged_Tau"):
+ super( TrigTauRecMerged_Tau , self ).__init__( name )
+ self._mytools = []
+
+ # monitoring part. To switch off do in topOption TriggerFlags.enableMonitoring = []
+ from TrigTauRec.TrigTauRecMonitoring import TrigTauRecValidationMonitoring, TrigTauRecOnlineMonitoring
+ validation = TrigTauRecValidationMonitoring()
+ online = TrigTauRecOnlineMonitoring()
+
+ from TrigTimeMonitor.TrigTimeHistToolConfig import TrigTimeHistToolConfig
+ time = TrigTimeHistToolConfig("Time")
+ self.AthenaMonTools = [ time, validation, online ]
+
+ import TrigTauRec.TrigTauAlgorithmsHolder as taualgs
+ tools = []
+
+ #what should run in trigger???
+ #same as tauRec (but without Pi0 cluster finder)
+ tools.append(taualgs.getJetSeedBuilder())
+ tools.append(taualgs.getTauVertexFinder(doUseTJVA=False)) #don't use TJVA by default
+ tools.append(taualgs.getTauAxis())
+ tools.append(taualgs.getTauTrackFinder())
+ tools.append(taualgs.getEnergyCalibrationLC(correctEnergy=True, correctAxis=False, postfix='_onlyEnergy'))
+ tools.append(taualgs.getCellVariables(cellConeSize=0.4))
+
+ #tools.append(taualgs.getElectronVetoVars()) #needed?
+ #tools.append(taualgs.getEnergyCalibrationEM())
+ ## tools.append(taualgs.getTauEflowTrackMatchCells())
+ ## tools.append(taualgs.getTauEflowAddCaloInfo())
+ ## tools.append(taualgs.getTauEflowVariables())
+
+ tools.append(taualgs.getTauVertexVariables())
+ tools.append(taualgs.getTauCommonCalcVars())
+ tools.append(taualgs.getTauSubstructure())
+ #tools.append(taualgs.getEnergyCalibrationLC(correctEnergy=False, correctAxis=True, postfix='_onlyAxis'))
+
+ for tool in tools:
+ tool.inTrigger = True
+ tool.calibFolder = 'TrigTauRec/00-11-01/'
+ pass
+
+
+ self.Tools = tools
+
+ ## add beam type flag
+ from AthenaCommon.BeamFlags import jobproperties
+ self.BeamType = jobproperties.Beam.beamType()
+
+
+class TrigTauRecMerged_Tau2012 (TrigTauRecMergedMT) :
+ __slots__ = [ '_mytools']
+ def __init__(self, name = "TrigTauRecMerged_Tau2012"):
+ super( TrigTauRecMerged_Tau2012 , self ).__init__( name )
+ self._mytools = []
+
+ # monitoring part. To switch off do in topOption TriggerFlags.enableMonitoring = []
+ from TrigTauRec.TrigTauRecMonitoring import TrigTauRecValidationMonitoring, TrigTauRecOnlineMonitoring
+ validation = TrigTauRecValidationMonitoring()
+ online = TrigTauRecOnlineMonitoring()
+
+ from TrigTimeMonitor.TrigTimeHistToolConfig import TrigTimeHistToolConfig
+ time = TrigTimeHistToolConfig("Time")
+ self.AthenaMonTools = [ time, validation, online ]
+
+ # Don't try to retrieve for now, should be handled globally
+ #if not hasattr(ToolSvc, "LumiBlockMuTool"):
+ # from LumiBlockComps.LumiBlockCompsConf import LumiBlockMuTool
+ # ToolSvc += CfgMgr.LumiBlockMuTool("LumiBlockMuTool")
+
+
+ import TrigTauRec.TrigTauAlgorithmsHolder as taualgs
+ tools = []
+
+ taualgs.setPrefix("TrigTau_")
+
+ #what should run in trigger???
+ #same as tauRec (but without Pi0 cluster finder)
+ tools.append(taualgs.getJetSeedBuilder())
+ tools.append(taualgs.getTauVertexFinder(doUseTJVA=False)) #don't use TJVA by default
+ tools.append(taualgs.getTauAxis())
+ tools.append(taualgs.getTauTrackFinder(applyZ0cut=True, maxDeltaZ0=2, prefix="TrigTau2012_"))
+ tools.append(taualgs.getEnergyCalibrationLC(correctEnergy=True, correctAxis=False, postfix='_onlyEnergy'))
+
+ tools.append(taualgs.getCellVariables(cellConeSize=0.2, prefix="TrigTau2012_")) #cellConeSize 0.2!!
+
+ #tools.append(taualgs.getElectronVetoVars()) #needed?
+ tools.append(taualgs.getTauVertexVariables())
+ tools.append(taualgs.getTauCommonCalcVars())
+ tools.append(taualgs.getTauSubstructure())
+ tools.append(taualgs.getEnergyCalibrationLC(correctEnergy=False, correctAxis=True, postfix='_onlyAxis'))
+
+ for tool in tools:
+ tool.inTrigger = True
+ tool.calibFolder = 'TrigTauRec/00-11-01/'
+ pass
+
+ self.Tools = tools
+
+ #necessary to write out deltaZ0 between tracks and lead trk
+ #self.theTauPVTool = taualgs.getTauPVTrackTool()
+ #self.useTauPVTool = True;
+
+ ## add beam type flag
+ from AthenaCommon.BeamFlags import jobproperties
+ self.BeamType = jobproperties.Beam.beamType()
+
+
+class TrigTauRecMerged_TauPreselection (TrigTauRecMergedMT) :
+ __slots__ = [ '_mytools']
+ def __init__(self, name = "TrigTauRecMerged_TauPreselection"):
+ super( TrigTauRecMerged_TauPreselection , self ).__init__( name )
+ self._mytools = []
+
+ # monitoring part. To switch off do in topOption TriggerFlags.enableMonitoring = []
+ from TrigTauRec.TrigTauRecMonitoring import TrigTauRecValidationMonitoring, TrigTauRecOnlineMonitoring
+ validation = TrigTauRecValidationMonitoring()
+ online = TrigTauRecOnlineMonitoring()
+
+ from TrigTimeMonitor.TrigTimeHistToolConfig import TrigTimeHistToolConfig
+ time = TrigTimeHistToolConfig("Time")
+ self.AthenaMonTools = [ time, validation, online ]
+
+ import TrigTauRec.TrigTauAlgorithmsHolder as taualgs
+ tools = []
+
+ taualgs.setPrefix("TrigTauPreselection_")
+
+ # Collection name
+ self.OutputCollection = "TrigTauRecPreselection"
+
+ # Only include tools needed for pre-selection
+
+ # Set seedcalo energy scale (Full RoI)
+ tools.append(taualgs.getJetSeedBuilder())
+ # Associate RoI vertex or Beamspot to tau - don't use TJVA - no vertices with fast-tracking
+ # tools.append(taualgs.getTauVertexFinder(doUseTJVA=False))
+ # Set LC energy scale (0.2 cone) and intermediate axis (corrected for vertex: useless at trigger)
+ tools.append(taualgs.getTauAxis())
+ # Count tracks with deltaZ0 cut of 2mm -> Need to remove quality criteria for fast-tracks here
+ # Insert bypass later?
+ # Count tracks with deltaZ0 cut of 2mm for 2016 and 1mm for 2017 (see ATR-15845)
+ if TriggerFlags.run2Config == '2016':
+ tools.append(taualgs.getTauTrackFinder(applyZ0cut=True, maxDeltaZ0=2, prefix="TrigTauPreselection_", noSelector=False))
+ else:
+ tools.append(taualgs.getTauTrackFinder(applyZ0cut=True, maxDeltaZ0=1, prefix="TrigTauPreselection_", noSelector=False))
+ # Calibrate to TES
+ tools.append(taualgs.getEnergyCalibrationLC(correctEnergy=True, correctAxis=False, postfix='_onlyEnergy'))
+ # Calculate cell-based quantities: strip variables, EM and Had energies/radii, centFrac, isolFrac and ring energies
+ tools.append(taualgs.getCellVariables(cellConeSize=0.2, prefix="TrigTauPreselection_"))
+ # tools.append(taualgs.getElectronVetoVars())
+ # Variables combining tracking and calorimeter information
+ tools.append(taualgs.getTauCommonCalcVars())
+ # Cluster-based sub-structure, with dRMax also
+ tools.append(taualgs.getTauSubstructure())
+ # tools.append(taualgs.getEnergyCalibrationLC(correctEnergy=False, correctAxis=True, postfix='_onlyAxis'))
+ tools.append(taualgs.getPileUpCorrection())
+
+
+ for tool in tools:
+ tool.inTrigger = True
+ tool.calibFolder = 'TrigTauRec/00-11-01/'
+ pass
+
+ self.Tools = tools
+
+ #necessary to write out deltaZ0 between tracks and lead trk
+ #self.theTauPVTool = taualgs.getTauPVTrackTool()
+ #self.useTauPVTool = True;
+
+ ## add beam type flag
+ from AthenaCommon.BeamFlags import jobproperties
+ self.BeamType = jobproperties.Beam.beamType()
+
+
+class TrigTauRecMerged_TauFTK (TrigTauRecMergedMT) :
+ __slots__ = [ '_mytools']
+ def __init__(self, name = "TrigTauRecMerged_TauFTK"):
+ super( TrigTauRecMerged_TauFTK , self ).__init__( name )
+ self._mytools = []
+
+ # monitoring part. To switch off do in topOption TriggerFlags.enableMonitoring = []
+ from TrigTauRec.TrigTauRecMonitoring import TrigTauRecValidationMonitoring, TrigTauRecOnlineMonitoring
+ validation = TrigTauRecValidationMonitoring()
+ online = TrigTauRecOnlineMonitoring()
+
+ from TrigTimeMonitor.TrigTimeHistToolConfig import TrigTimeHistToolConfig
+ time = TrigTimeHistToolConfig("Time")
+ self.AthenaMonTools = [ time, validation, online ]
+
+ import TrigTauRec.TrigTauAlgorithmsHolder as taualgs
+ tools = []
+
+ taualgs.setPrefix("TrigTauFTK_")
+
+
+ # Collection name
+ self.OutputCollection = "TrigTauRecPreselection"
+
+ # Only include tools needed for pre-selection
+
+ # Set seedcalo energy scale (Full RoI)
+ tools.append(taualgs.getJetSeedBuilder())
+ #use FTK vertices
+ tools.append(taualgs.getTauVertexFinder(doUseTJVA=True))
+ # Set LC energy scale (0.2 cone) and intermediate axis (corrected for vertex: useless at trigger)
+ tools.append(taualgs.getTauAxis())
+ # Count tracks with deltaZ0 cut of 2mm -> Need to remove quality criteria for fast-tracks here
+ # Insert bypass later?
+ tools.append(taualgs.getTauTrackFinder(applyZ0cut=True, maxDeltaZ0=2, prefix="TrigTauFTK_", noSelector = False))
+ # Calibrate to TES
+ tools.append(taualgs.getEnergyCalibrationLC(correctEnergy=True, correctAxis=False, postfix='_onlyEnergy'))
+ # Calculate cell-based quantities: strip variables, EM and Had energies/radii, centFrac, isolFrac and ring energies
+ tools.append(taualgs.getCellVariables(cellConeSize=0.2, prefix="TrigTauFTK_"))
+ # tools.append(taualgs.getElectronVetoVars())
+ # Variables combining tracking and calorimeter information
+ tools.append(taualgs.getTauCommonCalcVars())
+ # Cluster-based sub-structure, with dRMax also
+ tools.append(taualgs.getTauSubstructure())
+ # tools.append(taualgs.getEnergyCalibrationLC(correctEnergy=False, correctAxis=True, postfix='_onlyAxis'))
+ tools.append(taualgs.getPileUpCorrection())
+
+
+ for tool in tools:
+ tool.inTrigger = True
+ tool.calibFolder = 'TrigTauRec/00-11-01/'
+ pass
+
+ self.Tools = tools
+
+ #necessary to write out deltaZ0 between tracks and lead trk
+ #self.theTauPVTool = taualgs.getTauPVTrackTool()
+ #self.useTauPVTool = True;
+
+ ## add beam type flag
+ from AthenaCommon.BeamFlags import jobproperties
+ self.BeamType = jobproperties.Beam.beamType()
+
+class TrigTauRecMerged_TauCaloOnly (TrigTauRecMergedMT) :
+ __slots__ = [ '_mytools']
+ def __init__(self, name = "TrigTauRecMerged_TauCaloOnly"):
+ super( TrigTauRecMerged_TauCaloOnly , self ).__init__( name )
+ self._mytools = []
+
+ # monitoring part. To switch off do in topOption TriggerFlags.enableMonitoring = []
+ from TrigTauRec.TrigTauRecMonitoring import TrigTauRecValidationMonitoring, TrigTauRecOnlineMonitoring
+ validation = TrigTauRecValidationMonitoring()
+ online = TrigTauRecOnlineMonitoring()
+
+ from TrigTimeMonitor.TrigTimeHistToolConfig import TrigTimeHistToolConfig
+ time = TrigTimeHistToolConfig("Time")
+ #self.AthenaMonTools = [ time, validation, online ]
+
+ import TrigTauRec.TrigTauAlgorithmsHolder as taualgs
+ tools = []
+
+ taualgs.setPrefix("TrigTauCaloOnly_")
+
+ # Collection name - not stored
+ self.OutputCollection = "TrigTauRecCaloOnly"
+
+ # Only include tools needed for calo pre-selection
+
+ # Set seedcalo energy scale (Full RoI)
+ tools.append(taualgs.getJetSeedBuilder())
+ # Set LC energy scale (0.2 cone) and intermediate axis (corrected for vertex: useless at trigger)
+ tools.append(taualgs.getTauAxis())
+ # Calibrate to TES
+ tools.append(taualgs.getEnergyCalibrationLC(correctEnergy=True, correctAxis=False, postfix='_onlyEnergy', caloOnly=True))
+ # Calculate cell-based quantities: strip variables, EM and Had energies/radii, centFrac, isolFrac and ring energies
+ tools.append(taualgs.getCellVariables(cellConeSize=0.2, prefix="TrigTauCaloOnly_"))
+
+ for tool in tools:
+ tool.inTrigger = True
+ tool.calibFolder = 'TrigTauRec/00-11-01/'
+ pass
+
+ self.Tools = tools
+
+ ## add beam type flag
+ from AthenaCommon.BeamFlags import jobproperties
+ self.BeamType = jobproperties.Beam.beamType()
+
+
+class TrigTauRecMerged_TauPrecision (TrigTauRecMergedMT) :
+ __slots__ = [ '_mytools']
+ def __init__(self, name = "TrigTauRecMerged_TauPrecision"):
+ super( TrigTauRecMerged_TauPrecision , self ).__init__( name )
+ self._mytools = []
+
+ # monitoring part. To switch off do in topOption TriggerFlags.enableMonitoring = []
+ from TrigTauRec.TrigTauRecMonitoring import TrigTauRecValidationMonitoring, TrigTauRecOnlineMonitoring
+ validation = TrigTauRecValidationMonitoring()
+ online = TrigTauRecOnlineMonitoring()
+
+ from TrigTimeMonitor.TrigTimeHistToolConfig import TrigTimeHistToolConfig
+ time = TrigTimeHistToolConfig("Time")
+ self.AthenaMonTools = [ time, validation, online ]
+
+ import TrigTauRec.TrigTauAlgorithmsHolder as taualgs
+ tools = []
+
+ taualgs.setPrefix("TrigTau_")
+
+ # Collection name
+ self.OutputCollection = "TrigTauRecMerged"
+
+ # Include full set of tools
+
+ # Set seedcalo energy scale (Full RoI)
+ tools.append(taualgs.getJetSeedBuilder())
+ # Associate RoI vertex or Beamspot to tau - don't use TJVA
+ tools.append(taualgs.getTauVertexFinder(doUseTJVA=False)) #don't use TJVA by default
+ # Set LC energy scale (0.2 cone) and intermediate axis (corrected for vertex: useless at trigger)
+ tools.append(taualgs.getTauAxis())
+ # Count tracks with deltaZ0 cut of 2mm for 2016 and 1mm for 2017 (see ATR-15845)
+ if TriggerFlags.run2Config == '2016':
+ tools.append(taualgs.getTauTrackFinder(applyZ0cut=True, maxDeltaZ0=2, prefix="TrigTauPrecision_"))
+ else:
+ tools.append(taualgs.getTauTrackFinder(applyZ0cut=True, maxDeltaZ0=1, prefix="TrigTauPrecision_"))
+ # Calibrate to TES
+ tools.append(taualgs.getEnergyCalibrationLC(correctEnergy=True, correctAxis=False, postfix='_onlyEnergy'))
+ # Calculate cell-based quantities: strip variables, EM and Had energies/radii, centFrac, isolFrac and ring energies
+ tools.append(taualgs.getCellVariables(cellConeSize=0.2, prefix="TrigTauPrecision_"))
+ # tools.append(taualgs.getElectronVetoVars())
+ # Lifetime variables
+ tools.append(taualgs.getTauVertexVariables())
+ # Variables combining tracking and calorimeter information
+ tools.append(taualgs.getTauCommonCalcVars())
+ # Cluster-based sub-structure, with dRMax also
+ tools.append(taualgs.getTauSubstructure())
+ # tools.append(taualgs.getEnergyCalibrationLC(correctEnergy=False, correctAxis=True, postfix='_onlyAxis'))
+ tools.append(taualgs.getPileUpCorrection())
+
+ for tool in tools:
+ tool.inTrigger = True
+ tool.calibFolder = 'TrigTauRec/00-11-01/'
+ pass
+
+ self.Tools = tools
+
+ ## add beam type flag
+ from AthenaCommon.BeamFlags import jobproperties
+ self.BeamType = jobproperties.Beam.beamType()
+
+#end
diff --git a/Trigger/TrigAlgorithms/TrigTauRec/src/TrigTauRecMergedMT.cxx b/Trigger/TrigAlgorithms/TrigTauRec/src/TrigTauRecMergedMT.cxx
new file mode 100755
index 0000000000000000000000000000000000000000..d4b5a359848f80b7405fce12478713fe99b46532
--- /dev/null
+++ b/Trigger/TrigAlgorithms/TrigTauRec/src/TrigTauRecMergedMT.cxx
@@ -0,0 +1,651 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+/********************************************************************
+ *
+ * NAME: TrigTauRecMergedMT.cxx
+ * PACKAGE: Trigger/TrigAlgorithms/TrigTauRecMerged
+ *
+ * AUTHOR: E.Carquin
+ * MODIFIED: Nov 23 2018
+ *
+ * Run a subset of the offline tauRec/tau1p3p routines in the EF
+ *********************************************************************/
+
+//#include "GaudiKernel/IToolSvc.h"
+//#include "GaudiKernel/ListItem.h"
+//#include "GaudiKernel/StatusCode.h"
+//#include "GaudiKernel/Property.h"
+
+#include "TrigT1Interfaces/TrigT1Interfaces_ClassDEF.h"
+#include "TrigSteeringEvent/TrigRoiDescriptor.h"
+
+#include "EventKernel/INavigable4Momentum.h"
+#include "NavFourMom/INavigable4MomentumCollection.h"
+
+#include "CaloEvent/CaloCellContainer.h"
+#include "Particle/TrackParticleContainer.h"
+#include "VxVertex/VxContainer.h"
+
+#include "xAODTracking/TrackParticleContainer.h"
+#include "xAODTracking/VertexContainer.h"
+
+#include "xAODJet/Jet.h"
+#include "xAODJet/JetTrigAuxContainer.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 "LumiBlockComps/ILumiBlockMuTool.h"
+
+#include "TrigTauRecMergedMT.h"
+#include "AthenaMonitoring/MonitoredScope.h"
+
+
+using namespace std;
+
+
+// Invokes base class constructor.
+TrigTauRecMergedMT::TrigTauRecMergedMT(const std::string& name,ISvcLocator* pSvcLocator)
+ :AthAlgorithm(name, pSvcLocator),
+ m_tools(this),
+ m_endtools(this),
+ m_lumiBlockMuTool("LumiBlockMuTool/LumiBlockMuTool"),
+ m_beamSpotSvc("BeamCondSvc", name)
+{
+ declareProperty("Tools", m_tools, "List of ITauToolBase tools" );
+ declareProperty("EndTools", m_endtools, "List of End ITauToolBase tools" );
+ declareProperty("LumiBlockMuTool", m_lumiBlockMuTool, "Luminosity Tool" );
+}
+
+TrigTauRecMergedMT::~TrigTauRecMergedMT()
+{
+}
+
+StatusCode TrigTauRecMergedMT::initialize()
+{
+ ATH_MSG_DEBUG("TrigTauRecMergedMT::initialize()");
+
+ m_tauEventData.setInTrigger(true);
+ if ( m_tools.begin() == m_tools.end() ) {
+ ATH_MSG_DEBUG(" no tools given for this algorithm.");
+ return StatusCode::FAILURE;
+ }
+
+ ToolHandleArray<ITauToolBase> ::iterator p_itT = m_tools.begin();
+ ToolHandleArray<ITauToolBase> ::iterator p_itTE = m_tools.end();
+ ATH_MSG_DEBUG("List of tools in execution sequence:");
+
+ for(; p_itT != p_itTE; ++p_itT ) {
+ StatusCode p_sc = p_itT->retrieve();
+ if( p_sc.isFailure() ) {
+ ATH_MSG_DEBUG("Cannot find tool named <" << *p_itT << ">");
+ return StatusCode::FAILURE;
+ }
+ else {
+ ATH_MSG_DEBUG("Add timer for tool "<< ( *p_itT )->type() <<" "<< ( *p_itT )->name());
+ //if( doTiming() ) m_mytimers.push_back(addTimer((*p_itT)->name())) ;
+ (*p_itT)->setTauEventData(&m_tauEventData);
+ }
+ }
+
+ ToolHandleArray<ITauToolBase> ::iterator p_itTe = m_endtools.begin();
+ ToolHandleArray<ITauToolBase> ::iterator p_itTEe = m_endtools.end();
+
+ for(; p_itTe != p_itTEe; ++p_itTe ) {
+ StatusCode p_sc = p_itTe->retrieve();
+ if( p_sc.isFailure() ) {
+ ATH_MSG_DEBUG("Cannot find tool named <" << *p_itTe << ">");
+ return StatusCode::FAILURE;
+ }
+ else {
+ ATH_MSG_DEBUG(" Add time for end tool "<< ( *p_itTe )->type() <<" "<< ( *p_itTe )->name());
+ //if( doTiming() ) m_mytimers.push_back(addTimer((*p_itTe)->name())) ;
+ ( *p_itTe )->setTauEventData(&m_tauEventData);
+ }
+ }
+
+ if (m_lumiBlockMuTool.retrieve().isFailure()) {
+ ATH_MSG_WARNING("Unable to retrieve LumiBlockMuTool");
+ } else {
+ ATH_MSG_DEBUG("Successfully retrieved LumiBlockMuTool");
+ }
+
+ // Retrieve beam conditions
+ if(m_beamSpotSvc.retrieve().isFailure()) {
+ ATH_MSG_WARNING("Unable to retrieve Beamspot service");
+ } else {
+ ATH_MSG_WARNING("Successfully retrieved Beamspot service");
+ }
+
+ if ( not m_monTool.name().empty() ) {
+ ATH_CHECK( m_monTool.retrieve() );
+ }
+
+ ATH_MSG_DEBUG( "Initialising HandleKeys" );
+ CHECK( m_roIInputKey.initialize() );
+ CHECK( m_L1RoIKey.initialize() );
+ CHECK( m_clustersKey.initialize() );
+ CHECK( m_tracksKey.initialize() );
+ CHECK( m_vertexKey.initialize() );
+ CHECK( m_trigTauJetKey.initialize() );
+ CHECK( m_trigtauSeedOutKey.initialize() );
+ CHECK( m_trigtauRecOutKey.initialize() );
+ CHECK( m_trigtauTrkOutKey.initialize() );
+
+ return StatusCode::SUCCESS;
+}
+
+StatusCode TrigTauRecMergedMT::finalize()
+{
+ return StatusCode::SUCCESS;
+}
+
+StatusCode TrigTauRecMergedMT::execute()
+{
+
+ ATH_MSG_DEBUG("Execution");
+
+ auto ctx = getContext();
+
+ using namespace Monitored;
+ // variables to initialize and keep values for monitoring variables
+ std::vector<unsigned char> calo_errors(0);
+ std::vector<unsigned char> track_errors(0);
+ std::vector<unsigned char> author(0);
+ std::vector<float> deltaZ0coreTrks(0);
+ std::vector<float> deltaZ0wideTrks(0);
+
+ auto nCells = MonitoredScalar::declare<int>("nRoI_EFTauCells", 0);
+ auto nTracks = MonitoredScalar::declare<int>("nRoI_EFTauTracks", -10);
+ auto dEta = MonitoredScalar::declare<float>("dEtaEFTau_RoI", -10.);
+ auto dPhi = MonitoredScalar::declare<float>("dPhiEFTau_RoI", -10.);
+ auto emRadius = MonitoredScalar::declare<float>("EF_EMRadius", -0.099);
+ auto hadRadius = MonitoredScalar::declare<float>("EF_EMRadius", -0.099);
+ auto EtFinal = MonitoredScalar::declare<float>("EF_EtFinal", 0.);
+ auto Et = MonitoredScalar::declare<float>("EF_Et", 0.);
+ auto EtHad = MonitoredScalar::declare<float>("EF_EtHad",-10.);
+ auto EtEm = MonitoredScalar::declare<float>("EF_EtEm",-10.);
+ auto EMFrac = MonitoredScalar::declare<float>("EF_EMFrac",-10.);
+ auto IsoFrac = MonitoredScalar::declare<float>("EF_IsoFrac",-1.);
+ auto centFrac = MonitoredScalar::declare<float>("EF_centFrac",-10.);
+ auto nWideTrk = MonitoredScalar::declare<int>("EF_nWideTrk",0);
+ auto ipSigLeadTrk = MonitoredScalar::declare<float>("EF_ipSigLeadTrk",-1000.);
+ auto trFlightPathSig = MonitoredScalar::declare<float>("EF_trFlightPathSig",-10.);
+ auto massTrkSys = MonitoredScalar::declare<float>("EF_massTrkSys",-10.);
+ auto dRmax = MonitoredScalar::declare<float>("EF_dRmax",-10.);
+ auto numTrack = MonitoredScalar::declare<int>("EF_NTrk", -10);
+ auto trkAvgDist = MonitoredScalar::declare<float>("EF_TrkAvgDist",-1.0);
+ auto etovPtLead = MonitoredScalar::declare<float>("EF_EtovPtLead",-10.);
+ auto PSSFraction = MonitoredScalar::declare<float>("EF_PSSFraction",-999.9);
+ auto EMPOverTrkSysP = MonitoredScalar::declare<float>("EF_EMPOverTrkSysP",-999.9);
+ auto ChPiEMEOverCaloEME = MonitoredScalar::declare<float>("EF_ChPiEMEOverCaloEME",-999.9);
+ auto SumPtTrkFrac = MonitoredScalar::declare<float>("EF_SumPtTrkFrac",-999.9);
+ auto innerTrkAvgDist = MonitoredScalar::declare<float>("EF_innerTrkAvgDist",-1.0);
+ auto Ncand = MonitoredScalar::declare<int>("EF_nCand",0);
+ auto ActualInteractions = MonitoredScalar::declare<float>("EF_ActualInteractions",-999.9);
+ auto AvgInteractions = MonitoredScalar::declare<float>("EF_AvgInteractions",-999.9);
+ auto beamspot_x = MonitoredScalar::declare<float>("EF_beamspot_x",-999.9);
+ auto beamspot_y = MonitoredScalar::declare<float>("EF_beamspot_y",-999.9);
+ auto beamspot_z = MonitoredScalar::declare<float>("EF_beamspot_z",-999.9);
+ auto EtaL1 = MonitoredScalar::declare<float>("EtaL1",-99.9);
+ auto PhiL1 = MonitoredScalar::declare<float>("PhiL1",-99.9);
+ auto EtaEF = MonitoredScalar::declare<float>("EtaEF",-99.9);
+ auto PhiEF = MonitoredScalar::declare<float>("PhiEF",-99.9);
+
+ auto EF_calo_errors = MonitoredCollection::declare("calo_errors",calo_errors);
+ auto EF_track_errors = MonitoredCollection::declare("track_errors",track_errors);
+ auto EF_author = MonitoredCollection::declare("author",author);
+ auto EF_deltaZ0coreTrks = MonitoredCollection::declare("deltaZ0coreTrks",deltaZ0coreTrks);
+ auto EF_deltaZ0wideTrks = MonitoredCollection::declare("deltaZ0wideTrks",deltaZ0wideTrks);
+
+ auto monitorIt = MonitoredScope::declare( m_monTool, nCells, nTracks, dEta, dPhi, emRadius, hadRadius,
+ EtFinal, Et, EtHad, EtEm, EMFrac, IsoFrac, centFrac, nWideTrk, ipSigLeadTrk, trFlightPathSig, massTrkSys,
+ dRmax, numTrack, trkAvgDist, etovPtLead, PSSFraction, EMPOverTrkSysP, ChPiEMEOverCaloEME, SumPtTrkFrac,
+ innerTrkAvgDist, Ncand, ActualInteractions, AvgInteractions, beamspot_x, beamspot_y, beamspot_z, EtaL1,
+ PhiL1, EtaEF, PhiEF );
+
+ // Retrieve store.
+ ATH_MSG_DEBUG("Executing TrigTauRecMergedMT");
+
+ // Get RoiDescriptor
+ SG::ReadHandle< TrigRoiDescriptorCollection > roisHandle = SG::makeHandle( m_roIInputKey, ctx );
+ if(roisHandle->size()==0){
+ ATH_MSG_DEBUG("RoIHandle size = Zero");
+ return StatusCode::SUCCESS;
+ }
+ const TrigRoiDescriptor *roiDescriptor = roisHandle->at(0);
+
+ if ( roiDescriptor!= NULL ) {
+ ATH_MSG_DEBUG("REGTEST: RoI " << *roiDescriptor);
+ }
+ else {
+ ATH_MSG_DEBUG("Failed to find RoiDescriptor ");
+ calo_errors.push_back(NoROIDescr);
+ return StatusCode::SUCCESS;
+ }
+
+ // Retrieve Calocluster container
+ SG::ReadHandle< xAOD::CaloClusterContainer > CCContainerHandle = SG::makeHandle( m_clustersKey,ctx );
+ CHECK( CCContainerHandle.isValid() );
+
+ const xAOD::CaloClusterContainer *RoICaloClusterContainer = CCContainerHandle.get();
+ ATH_MSG_DEBUG( "Found " << RoICaloClusterContainer->size() << " caloClusters, updating the corresponding RoI ... " );
+
+ if(RoICaloClusterContainer != NULL) {
+ ATH_MSG_DEBUG( "REGTEST: Size of vector CaloCluster container is " << RoICaloClusterContainer->size());
+ if(RoICaloClusterContainer->size()==0) {
+ ATH_MSG_DEBUG( "Cannot proceed, size of vector CaloCluster container is " << RoICaloClusterContainer->size());
+ return StatusCode::SUCCESS;
+ }
+ }else {
+ ATH_MSG_DEBUG( "no CaloCluster container found " );
+ return StatusCode::SUCCESS;
+ }
+
+ // get TrackContainer
+ SG::ReadHandle< xAOD::TrackParticleContainer > TPContainerHandle = SG::makeHandle( m_tracksKey,ctx );
+
+ const xAOD::TrackParticleContainer *RoITrackParticleContainer = NULL;
+
+ if ( !TPContainerHandle.isValid() ) {
+ ATH_MSG_INFO("REGTEST: No Track container found.");
+ track_errors.push_back(NoTrkCont);
+ }
+ else {
+ RoITrackParticleContainer=TPContainerHandle.get();
+ ATH_MSG_DEBUG("REGTEST: Size of vector Track container is " << RoITrackParticleContainer->size());
+ if(RoITrackParticleContainer != NULL) nTracks = RoITrackParticleContainer->size();
+ }
+
+ // get Vertex Container
+ SG::ReadHandle< xAOD::VertexContainer > VertexContainerHandle = SG::makeHandle( m_vertexKey,ctx );
+
+ const xAOD::VertexContainer* RoIVxContainer = NULL;
+
+ if( !VertexContainerHandle.isValid() ) {
+ ATH_MSG_INFO(" No VxContainers retrieved for the trigger element");
+ track_errors.push_back(NoVtxCont);
+ }
+ else {
+ RoIVxContainer = VertexContainerHandle.get();
+ ATH_MSG_DEBUG("REGTEST: Size of vector Vertex container " << RoIVxContainer->size());
+ }
+
+ double mu = 0.0;
+ double avg_mu = 0.0;
+ if(m_lumiBlockMuTool){
+ mu = m_lumiBlockMuTool->actualInteractionsPerCrossing(); // (retrieve mu for the current BCID)
+ avg_mu = m_lumiBlockMuTool->averageInteractionsPerCrossing();
+ ActualInteractions = mu;
+ AvgInteractions = avg_mu;
+ ATH_MSG_DEBUG("REGTEST: Retrieved Mu Value : " << mu);
+ ATH_MSG_DEBUG("REGTEST: Average Mu Value : " << avg_mu);
+ }
+
+
+ //-------------------------------------------------------------------------
+ // Get beamspot
+ //-------------------------------------------------------------------------
+
+ // Copy the first vertex from a const object
+ xAOD::Vertex theBeamspot;
+ theBeamspot.makePrivateStore();
+ const xAOD::Vertex* ptrBeamspot = 0;
+
+ if(m_beamSpotSvc){
+
+ // Alter the position of the vertex
+ theBeamspot.setPosition(m_beamSpotSvc->beamPos());
+
+ beamspot_x=theBeamspot.x();
+ beamspot_y=theBeamspot.y();
+ beamspot_z=theBeamspot.z();
+
+ // Create a AmgSymMatrix to alter the vertex covariance mat.
+ AmgSymMatrix(3) cov = m_beamSpotSvc->beamVtx().covariancePosition();
+ theBeamspot.setCovariancePosition(cov);
+
+ ptrBeamspot = &theBeamspot;
+
+ }
+
+
+ //-------------------------------------------------------------------------
+ // Creating jet container used as "tau seed" for tau reconstruction
+ //-------------------------------------------------------------------------
+
+ // Ensure that we are using a TrigAuxContainer
+ xAOD::JetContainer* theJetCollection = new xAOD::JetContainer();
+ xAOD::JetTrigAuxContainer theJetContainer;
+ theJetCollection->setStore(&theJetContainer);
+
+ xAOD::Jet* aJet = new xAOD::Jet();
+
+ theJetCollection->push_back(aJet);
+
+ // Build the jet, also keep track of the kinematics by hand
+ // We are using calibrated clusters, we need to keep track of this
+ aJet->setConstituentsSignalState(xAOD::JetConstitScale::CalibratedJetConstituent);
+
+ // Make a minimal effort to speed things up ;)
+ // Eventually, want to use FastJet here?
+ TLorentzVector myCluster;
+ TLorentzVector TauBarycenter(0., 0., 0., 0.);
+
+ xAOD::CaloClusterContainer::const_iterator clusterIt;
+ for (clusterIt=RoICaloClusterContainer->begin(); clusterIt != RoICaloClusterContainer->end(); ++clusterIt) {
+ ATH_MSG_DEBUG(" Cluster (e, eta, phi) : ("<< (*clusterIt)->e() << " , " <<(*clusterIt)->eta()<<" , "<<(*clusterIt)->phi()<< " )");
+
+ if((*clusterIt)->e() < 0)
+ {
+ ATH_MSG_DEBUG(" Negative energy cluster is rejected");
+ continue;
+ }
+
+ myCluster.SetPtEtaPhiE((*clusterIt)->pt(), (*clusterIt)->eta(), (*clusterIt)->phi(), (*clusterIt)->e());
+ aJet->addConstituent(*clusterIt);
+
+ TauBarycenter += myCluster;
+ }
+
+ aJet->setJetP4(xAOD::JetFourMom_t(TauBarycenter.Pt(), TauBarycenter.Eta(), TauBarycenter.Phi(), TauBarycenter.M() ) );
+
+ ATH_MSG_DEBUG("jet formed"<< aJet->eta() <<" , " << aJet->phi() <<" , " << aJet->pt() << " , "<< aJet->e() );
+
+ // Prepare Outputs
+ std::unique_ptr< xAOD::JetContainer > tauSeedContainer( new xAOD::JetContainer() );
+
+ // Save Outputs
+ SG::WriteHandle< xAOD::JetContainer > outTauSeedHandle = SG::makeHandle( m_trigtauSeedOutKey,ctx );
+ CHECK( outTauSeedHandle.record( std::move( tauSeedContainer ) ) );
+
+ StatusCode processStatus = StatusCode::SUCCESS;
+
+ // Save Outputs
+ SG::WriteHandle<xAOD::TauJetContainer> outTauJetHandle( m_trigtauRecOutKey );
+ SG::WriteHandle<xAOD::TauTrackContainer> outTauTrackHandle( m_trigtauTrkOutKey );
+
+ //-------------------------------------------------------------------------
+ // setup TauCandidate data
+ //-------------------------------------------------------------------------
+ m_tauEventData.clear();
+ xAOD::TauJetContainer *pContainer = new xAOD::TauJetContainer();
+ xAOD::TauJetAuxContainer *pAuxContainer = new xAOD::TauJetAuxContainer();
+
+ xAOD::TauTrackContainer *pTrackContainer = new xAOD::TauTrackContainer();
+ xAOD::TauTrackAuxContainer *pTrackAuxContainer = new xAOD::TauTrackAuxContainer();
+
+ pContainer->setStore(pAuxContainer);
+ pTrackContainer->setStore(pTrackAuxContainer);
+
+ m_tauEventData.setObject("TauTrackContainer", pTrackContainer);
+ m_tauEventData.xAODTauContainer = pContainer;
+ m_tauEventData.tauAuxContainer = pAuxContainer;
+
+ // Set the Objects that we can attach right now
+ m_tauEventData.setObject("TrackContainer", RoITrackParticleContainer);
+ m_tauEventData.setObject("VxPrimaryCandidate", RoIVxContainer);
+ if(m_lumiBlockMuTool) m_tauEventData.setObject("AvgInteractions", avg_mu);
+ if(m_beamSpotSvc) m_tauEventData.setObject("Beamspot", ptrBeamspot);
+ if(m_beamType == ("cosmics")) m_tauEventData.setObject("IsCosmics?", true );
+
+
+ //-------------------------------------------------------------------------
+ // eventInitialize tauRec colls
+ //-------------------------------------------------------------------------
+ ToolHandleArray<ITauToolBase> ::iterator firstTool = m_tools.begin();
+ ToolHandleArray<ITauToolBase> ::iterator lastTool = m_tools.end();
+ for ( ; firstTool != lastTool; firstTool++ ) {
+ processStatus = (*firstTool)->eventInitialize();
+
+ if( processStatus != StatusCode :: SUCCESS ) {
+ ATH_MSG_ERROR("tool "<<(*firstTool)->name()<< "failed in eventInitialize");
+ return StatusCode::FAILURE;
+ }
+ }
+ ATH_MSG_DEBUG(" initialize all good ");
+
+ //-------------------------------------------------------------------------
+ // using Jet collection
+ // setup tau candidate structure
+ //-------------------------------------------------------------------------
+ xAOD::Jet* p_seed = (*theJetCollection->begin()); //there is only one jet stored
+
+ xAOD::TauJet* p_tau = new xAOD::TauJet();
+ pContainer->push_back(p_tau);
+ p_tau->setROIWord(roiDescriptor->roiWord());
+ p_tau->setJet(theJetCollection, p_seed);
+ m_tauEventData.seedContainer = theJetCollection;
+
+ // This sets one track and link. Need to have at least 1 track linked to retrieve track container
+ setEmptyTauTrack(p_tau, pTrackContainer);
+
+ if(p_seed->e()<=0) {
+ msg() << MSG::DEBUG << " Roi: changing eta due to energy " << p_seed->e() << endmsg;
+ p_tau->setP4(p_tau->pt(), roiDescriptor->eta(), roiDescriptor->phi(), p_tau->m());
+
+ msg() << MSG::DEBUG << "Roi: " << roiDescriptor->roiId()
+ << " Tau eta: " << p_tau->eta() << " Tau phi: " << p_tau->phi()
+ << endmsg;
+ }
+
+ ATH_MSG_DEBUG(" roidescriptor roiword " << roiDescriptor->roiWord() << " saved " << p_tau->ROIWord() );
+
+ m_tauEventData.setObject("JetCollection", theJetCollection );
+
+ //-------------------------------------------------------------------------
+ // loop over booked tau tools
+ //-------------------------------------------------------------------------
+ int toolnum = 0;
+ firstTool = m_tools.begin();
+ lastTool = m_tools.end();
+ processStatus = StatusCode::SUCCESS;
+ ATH_MSG_DEBUG("Starting tool loop with seed jet");
+ //std::vector<TrigTimer* >::iterator itimer = m_mytimers.begin();
+ while ( ! processStatus.isFailure() && firstTool != lastTool ) {
+ // loop stops only when Failure indicated by one of the tools
+ ATH_MSG_DEBUG("Starting Tool: " << (*firstTool)->name() );
+ // time in the various tools
+ ++toolnum;
+ //if ( doTiming() && itimer != m_mytimers.end() ) (*itimer)->start();
+
+ processStatus = (*firstTool)->execute( *p_tau );
+ if ( !processStatus.isFailure() ) {
+ ATH_MSG_DEBUG("REGTEST: "<< (*firstTool)->name() << " executed successfully ");
+ ATH_MSG_DEBUG("REGTEST: Roi: " << roiDescriptor->roiId()
+ << " Tau eta: " << p_tau->eta() << " Tau phi: " << p_tau->phi()
+ << " Tau pT : "<< p_tau->pt());
+ }
+ else {
+ ATH_MSG_DEBUG("REGTEST: "<< (*firstTool)->name() << " execution failed ");
+ }
+ ++firstTool;
+ //++itimer;
+ //if ( doTiming() && itimer != m_mytimers.end() ) (*itimer)->stop();
+ }
+
+ //check status
+ if ( !processStatus.isSuccess() ) { // some problem
+ ATH_MSG_DEBUG("the tau object has NOT been registered in the tau container");
+ // ToolHandleArray<ITauToolBase> ::iterator tool = m_tools.begin();
+ // for(; tool != firstTool; ++tool ) (*tool)->cleanup( &m_tauEventData );
+ // (*tool)->cleanup( &m_tauEventData );
+
+ xAOD::TauJet* bad_tau = pContainer->back();
+ ATH_MSG_DEBUG("Deleting " << bad_tau->nAllTracks() << "Tracks associated with tau: ");
+ pTrackContainer->erase(pTrackContainer->end()-bad_tau->nAllTracks(), pTrackContainer->end());
+
+ pContainer->pop_back();
+
+ ATH_MSG_DEBUG("clean up done after jet seed");
+ }
+ else if( processStatus.isSuccess()) {
+
+ float fJetEnergy = (*p_tau->jetLink())->e();
+ ATH_MSG_DEBUG(" Roi: jet e "<< fJetEnergy);
+
+ if( fJetEnergy < 0.00001 ) {
+ ATH_MSG_DEBUG(" Roi: changing eta phi to L1 ones due to energy negative (PxPyPzE flips eta and phi)");
+ ATH_MSG_DEBUG(" Roi: this is probably not needed anymore, method PxPyPzE has been corrected");
+
+ //p_tau->setEta(roiDescriptor->eta0());
+ //p_tau->setPhi(roiDescriptor->phi0());
+ // Direct accessors not available anymore
+ p_tau->setP4(p_tau->pt(), roiDescriptor->eta(), roiDescriptor->phi(), p_tau->m());
+
+ ATH_MSG_DEBUG(" Roi: " << roiDescriptor->roiId()
+ << " Tau eta: " << p_tau->eta()
+ << " Tau phi: " << p_tau->phi()
+ << " Tau pT : "<< p_tau->pt());
+ }
+
+ // loop over end tools
+ ToolHandleArray<ITauToolBase> ::iterator p_itET = m_endtools.begin();
+ ToolHandleArray<ITauToolBase> ::iterator p_itETE = m_endtools.end();
+ for (; p_itET != p_itETE; ++p_itET ) {
+ ATH_MSG_VERBOSE("Invoking endTool " << ( *p_itET )->name() );
+
+ processStatus = ( *p_itET )->execute( *p_tau);
+ if( processStatus.isFailure() ) break;
+ }
+ // Get L1 RoiDescriptor
+ SG::ReadHandle< TrigRoiDescriptorCollection > L1roisHandle = SG::makeHandle( m_L1RoIKey, ctx );
+ const TrigRoiDescriptor *roiL1Descriptor = L1roisHandle->at(0);
+
+ EtaL1 = roiL1Descriptor->eta();
+ PhiL1 = roiL1Descriptor->phi();
+
+ // get tau detail variables for Monitoring
+ numTrack = p_tau->nTracks();
+ nWideTrk = p_tau->nTracksIsolation();
+ p_tau->detail(xAOD::TauJetParameters::trkAvgDist, trkAvgDist);
+ p_tau->detail(xAOD::TauJetParameters::etOverPtLeadTrk, etovPtLead);
+ p_tau->detail(xAOD::TauJetParameters::EMRadius, emRadius);
+ p_tau->detail(xAOD::TauJetParameters::hadRadius, hadRadius);
+ p_tau->detail(xAOD::TauJetParameters::isolFrac, IsoFrac);
+ p_tau->detail(xAOD::TauJetParameters::centFrac, centFrac);
+ p_tau->detail(xAOD::TauJetParameters::ipSigLeadTrk, ipSigLeadTrk);
+ p_tau->detail(xAOD::TauJetParameters::trFlightPathSig, trFlightPathSig);
+ p_tau->detail(xAOD::TauJetParameters::dRmax, dRmax);
+ p_tau->detail(xAOD::TauJetParameters::massTrkSys, massTrkSys);
+
+ p_tau->detail(xAOD::TauJetParameters::PSSFraction, PSSFraction);
+ p_tau->detail(xAOD::TauJetParameters::EMPOverTrkSysP, EMPOverTrkSysP);
+ p_tau->detail(xAOD::TauJetParameters::ChPiEMEOverCaloEME, ChPiEMEOverCaloEME);
+ p_tau->detail(xAOD::TauJetParameters::innerTrkAvgDist, innerTrkAvgDist);
+ p_tau->detail(xAOD::TauJetParameters::SumPtTrkFrac, SumPtTrkFrac);
+
+ massTrkSys /= 1000.; // make GeV
+ p_tau->detail(xAOD::TauJetParameters::etEMAtEMScale, EtEm);
+ EtEm /= 1000.; // make GeV
+ p_tau->detail(xAOD::TauJetParameters::etHadAtEMScale, EtHad);
+ EtHad /= 1000.; // make GeV
+ Et = EtEm + EtHad;
+ EtFinal = p_tau->pt()/1000.;
+
+ EtaEF = p_tau->eta();
+ PhiEF = p_tau->phi();
+
+ if( Et !=0) EMFrac = EtEm/ Et ;
+
+ dEta = EtaEF - roiDescriptor->eta();
+ dPhi = PhiEF - roiDescriptor->phi();
+ if(dPhi<-M_PI) dPhi += 2.0*M_PI;
+ if(dPhi>M_PI) dPhi -= 2.0*M_PI;
+
+ std::vector<const xAOD::TauJetContainer*> tempCaloOnlyContVec;
+
+ // get TauJetContainer
+ SG::ReadHandle< xAOD::TauJetContainer > TJContainerHandle = SG::makeHandle( m_trigTauJetKey,ctx );
+ const xAOD::TauJetContainer *tempCaloOnlyCont=TJContainerHandle.get();
+ tempCaloOnlyContVec.push_back(tempCaloOnlyCont);
+
+ /*if( !tempCaloOnlyContVec.isValid()){
+
+ ATH_MSG_DEBUG( "Can't get container TrigTauRecCaloOnly to copy four-vector");
+
+ } else {*/
+ if (tempCaloOnlyCont) {
+
+ // const xAOD::TauJetContainer* tempCaloOnlyTauCont = tempCaloOnlyContVec.back();
+ // for(xAOD::TauJetContainer::const_iterator tauIt = tempCaloOnlyTauCont->begin(); tauIt != tempCaloOnlyTauCont->end(); tauIt++){
+
+ // const xAOD::TauJetContainer* tempCaloOnlyTauCont = tempCaloOnlyContVec.back();
+
+ for(auto tauIt: *tempCaloOnlyCont){
+ ATH_MSG_DEBUG("On the loop");
+ ATH_MSG_DEBUG("pT(tau) = " << tauIt->pt() << " pT(caloOnly) = " << tauIt->ptTrigCaloOnly() );
+
+ p_tau->setP4(xAOD::TauJetParameters::TrigCaloOnly, tauIt->ptTrigCaloOnly(), tauIt->etaTrigCaloOnly(), tauIt->phiTrigCaloOnly(), tauIt->mTrigCaloOnly());
+
+ }
+
+ //}
+
+ }else{
+ ATH_MSG_WARNING( "TauJetContainer not found :");
+ }
+
+ ATH_MSG_DEBUG("REGTEST: Roi: " << roiDescriptor->roiId()
+ << " Tau being saved eta: " << EtaEF << " Tau phi: " << PhiEF
+ << " wrt L1 dEta "<< dEta<<" dPhi "<<dPhi
+ << " Tau Et (GeV): "<< EtFinal);
+
+ ++Ncand;
+ }
+ else {
+ xAOD::TauJet* bad_tau = pContainer->back();
+ ATH_MSG_DEBUG("Deleting " << bad_tau->nAllTracks() << "Tracks associated with tau: ");
+ pTrackContainer->erase(pTrackContainer->end()-bad_tau->nAllTracks(), pTrackContainer->end());
+ pContainer->pop_back();
+
+ ATH_MSG_DEBUG("deleted tau done after jet seed");
+ }
+
+ // call eventFinalize on the booked tau tools
+ for ( firstTool = m_tools.begin(); firstTool != lastTool; firstTool++ ) {
+ processStatus = (*firstTool)->eventFinalize();
+ if( processStatus != StatusCode :: SUCCESS ) {
+ ATH_MSG_DEBUG("tool "<<(*firstTool)->name()<< "failed in eventFinalize");
+ return StatusCode::FAILURE;
+ }
+ }
+ ATH_MSG_DEBUG("tools succeed in eventFinalize");
+
+
+ //-------------------------------------------------------------------------
+ // all done, register the tau Container in TDS.
+ //-------------------------------------------------------------------------
+
+ ATH_MSG_DEBUG("Output TauJetContainer size:"<< pContainer->size());
+ ATH_MSG_DEBUG("Output TauTrackJetContainer size:"<< pTrackContainer->size());
+
+ CHECK( outTauJetHandle.record(std::unique_ptr<xAOD::TauJetContainer>{pContainer}, std::unique_ptr<xAOD::TauJetAuxContainer>{pAuxContainer}) );
+ CHECK( outTauTrackHandle.record(std::unique_ptr<xAOD::TauTrackContainer>{pTrackContainer}, std::unique_ptr<xAOD::TauTrackAuxContainer>{pTrackAuxContainer}) );
+
+ ATH_MSG_DEBUG("Recorded a tau container: HLT_TrigTauRecMergedMT");
+ ATH_MSG_DEBUG("the tau object has been registered in the tau container");
+
+ // set status of TE to always true for FE algorithms
+ return StatusCode::SUCCESS;
+}
+
+void TrigTauRecMergedMT::setEmptyTauTrack(xAOD::TauJet* &pTau,
+ xAOD::TauTrackContainer* &tauTrackContainer)
+{
+ // Make a new tau track, add to container
+ xAOD::TauTrack* pTrack = new xAOD::TauTrack();
+ tauTrackContainer->push_back(pTrack);
+
+ // Create an element link for that track
+ ElementLink<xAOD::TauTrackContainer> linkToTauTrack;
+ linkToTauTrack.toContainedElement(*tauTrackContainer, pTrack);
+ pTau->addTauTrackLink(linkToTauTrack);
+}
+
diff --git a/Trigger/TrigAlgorithms/TrigTauRec/src/TrigTauRecMergedMT.h b/Trigger/TrigAlgorithms/TrigTauRec/src/TrigTauRecMergedMT.h
new file mode 100755
index 0000000000000000000000000000000000000000..7c528b40f3bba0e149f3668a28fd64d9ddf7a165
--- /dev/null
+++ b/Trigger/TrigAlgorithms/TrigTauRec/src/TrigTauRecMergedMT.h
@@ -0,0 +1,122 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+//
+/********************************************************************
+ *
+ * NAME: TrigTauRecMergedMT.h
+ * PACKAGE: Trigger/TrigAlgorithms/TrigTauRecMerged
+ *
+ * AUTHOR: R. Soluk (based on tauBuilder)
+ * CREATED: Nov 21 2005
+ * MODIFIED: Dec 14 2006 S.Xella
+ * Mar 02 2001 ccuenca
+ *********************************************************************/
+
+#ifndef TRIGTAURECMERGEDMT_H
+#define TRIGTAURECMERGEDMT_H
+
+// general athena stuff
+//#include "GaudiKernel/IToolSvc.h"
+#include "TrigTimeAlgs/TrigTimerSvc.h"
+//#include "TrigTimeAlgs/TrigTimer.h"
+
+//Gaudi
+#include "GaudiKernel/ToolHandle.h"
+#include "GaudiKernel/ServiceHandle.h"
+
+// Base class
+#include "AthenaBaseComps/AthAlgorithm.h"
+#include "StoreGate/ReadHandleKey.h"
+#include "StoreGate/WriteHandleKey.h"
+#include "AthenaMonitoring/GenericMonitoringTool.h"
+
+#include <vector>
+#include "tauRecTools/ITauToolBase.h"
+
+#include "LumiBlockComps/ILuminosityTool.h"
+#include "InDetBeamSpotService/IBeamCondSvc.h"
+
+#include "TrigSteeringEvent/TrigRoiDescriptor.h"
+
+namespace HLT {
+ class TriggerElement;
+}
+
+class ILumiBlockMuTool;
+
+class TrigTauRecMergedMT: public AthAlgorithm {
+
+ public:
+
+ TrigTauRecMergedMT(const std::string& name, ISvcLocator* pSvcLocator);
+ ~TrigTauRecMergedMT();
+
+ virtual StatusCode initialize() override;
+ virtual StatusCode finalize() override;
+ virtual StatusCode execute() override;
+
+
+ private:
+
+ TauEventData m_tauEventData;
+
+ void setEmptyTauTrack( xAOD::TauJet* &tauJet,
+ xAOD::TauTrackContainer* &tauTrackCont);
+
+ enum TAUEFCALOMON{
+ NoROIDescr=0,
+ NoCellCont=1,
+ EmptyCellCont=2,
+ NoClustCont=3,
+ NoClustKey=4,
+ EmptyClustCont=5,
+ NoJetAttach=6,
+ NoHLTtauAttach=7,
+ NoHLTtauDetAttach=8,
+ NoHLTtauXdetAttach=9
+ };
+
+ enum TAUEFTRKMON{
+ NoTrkCont=0,
+ NoVtxCont=1
+ };
+
+
+ /** internal tool store */
+ ToolHandleArray<ITauToolBase> m_tools;
+
+ /** internal tool store */
+ ToolHandleArray<ITauToolBase> m_endtools;
+
+ /** Luminosity Tool */
+ ToolHandle<ILumiBlockMuTool> m_lumiBlockMuTool;
+
+ /** Beam spot service */
+ ServiceHandle<IBeamCondSvc> m_beamSpotSvc;
+
+ /** vector of Timers */
+ std::vector<TrigTimer* > m_mytimers;
+
+ // Monitoring tool
+ ToolHandle< GenericMonitoringTool > m_monTool { this, "MonTool", "", "Monitoring tool" };
+
+ SG::ReadHandleKey< TrigRoiDescriptorCollection > m_roIInputKey {this,"RoIInputKey","Undefined",""};
+ SG::ReadHandleKey< TrigRoiDescriptorCollection > m_L1RoIKey {this, "L1RoIKey","Undefined",""};
+ SG::ReadHandleKey< xAOD::CaloClusterContainer > m_clustersKey { this, "clustersKey", "caloclusters", "caloclusters in view" };
+ SG::ReadHandleKey< xAOD::TrackParticleContainer > m_tracksKey { this, "Key_trackPartInputContainer", "InDetTrackParticles", "input track particle container key"};
+ SG::ReadHandleKey< xAOD::VertexContainer> m_vertexKey {this,"Key_vertexInputContainer", "PrimaryVertices", "input vertex container key"};
+ SG::ReadHandleKey< xAOD::TauJetContainer> m_trigTauJetKey { this, "TrigTauJet", "Undefined", "" };
+ SG::WriteHandleKey< xAOD::JetContainer > m_trigtauSeedOutKey {this,"TrigTauJetOutputKey","seed tau jet","Key for output jets which are seed for tau jets"};
+ SG::WriteHandleKey< xAOD::TauJetContainer > m_trigtauRecOutKey {this,"TrigTauRecOutputKey","output tau jet object","Output taujet container"};
+ SG::WriteHandleKey< xAOD::TauTrackContainer > m_trigtauTrkOutKey {this,"TrigTauTrkOutputKey","output tau track object","Output tautrack container"};
+
+ Gaudi::Property< std::string > m_outputName {this,"OutputCollection","TrigTauRecMerged","Name of output collection"};
+ Gaudi::Property< float > m_maxeta {this,"maxeta",2.5,"max eta for tau"};
+ Gaudi::Property< float > m_minpt {this,"minpt",10000.0,"min pt for tau"};
+ Gaudi::Property< std::string > m_beamType {this,"BeamType","collisions","Beam type"};
+ Gaudi::Property< float > m_trkcone {this,"trkcone",0.2,"max distance track seed from roi center"};
+
+};
+#endif
diff --git a/Trigger/TrigAlgorithms/TrigTauRec/src/components/TrigTauRec_entries.cxx b/Trigger/TrigAlgorithms/TrigTauRec/src/components/TrigTauRec_entries.cxx
index 425f1234be398e4f9f10b8d90054911e34e46126..304a3a20e5eb0d6de77aa1aacc2a449635146c2b 100644
--- a/Trigger/TrigAlgorithms/TrigTauRec/src/components/TrigTauRec_entries.cxx
+++ b/Trigger/TrigAlgorithms/TrigTauRec/src/components/TrigTauRec_entries.cxx
@@ -1,5 +1,7 @@
#include "TrigTauRec/TrigTauRecMerged.h"
+#include "../TrigTauRecMergedMT.h"
DECLARE_COMPONENT( TrigTauRecMerged )
+DECLARE_COMPONENT( TrigTauRecMergedMT )
diff --git a/Trigger/TrigHypothesis/TrigTauHypo/CMakeLists.txt b/Trigger/TrigHypothesis/TrigTauHypo/CMakeLists.txt
index 38107cbb59219e0aaedeed9a09f046767356cdb9..75f835fef84f204feaeface6c60af8e73b8b2791 100644
--- a/Trigger/TrigHypothesis/TrigTauHypo/CMakeLists.txt
+++ b/Trigger/TrigHypothesis/TrigTauHypo/CMakeLists.txt
@@ -8,6 +8,7 @@ atlas_subdir( TrigTauHypo )
# Declare the package's dependencies:
atlas_depends_on_subdirs( PUBLIC
Control/StoreGate
+ Control/AthenaBaseComps
GaudiKernel
Reconstruction/MuonIdentification/MuidEvent
Reconstruction/Particle
@@ -21,11 +22,11 @@ atlas_depends_on_subdirs( PUBLIC
Trigger/TrigEvent/TrigSteeringEvent
Trigger/TrigEvent/TrigTopoEvent
Trigger/TrigSteer/TrigInterfaces
- Event/xAOD/xAODTrigger
+ Event/xAOD/xAODTrigger
PRIVATE
Calorimeter/CaloEvent
+ Control/AthViews
Control/AthContainers
- Control/AthenaBaseComps
Event/EventInfo
Event/xAOD/xAODCaloEvent
Event/xAOD/xAODJet
@@ -36,9 +37,12 @@ atlas_depends_on_subdirs( PUBLIC
Tracking/TrkEvent/TrkTrack
Tracking/TrkEvent/TrkTrackSummary
Trigger/TrigEvent/TrigCaloEvent
- Trigger/TrigEvent/TrigNavStructure )
+ Trigger/TrigEvent/TrigNavStructure
+ Trigger/TrigSteer/DecisionHandling )
# External dependencies:
+find_package( AIDA )
+find_package( CLHEP )
find_package( ROOT COMPONENTS Core Tree MathCore Hist RIO pthread )
# Component(s) in the package:
@@ -47,12 +51,12 @@ atlas_add_library( TrigTauHypoLib
PUBLIC_HEADERS TrigTauHypo
INCLUDE_DIRS ${ROOT_INCLUDE_DIRS}
LINK_LIBRARIES ${ROOT_LIBRARIES} GaudiKernel MuidEvent Particle ITrackToVertex egammaEvent tauEvent xAODTrigger VxVertex TrigInDetEvent TrigMuonEvent TrigParticle TrigSteeringEvent TrigTopoEvent StoreGateLib SGtests TrigInterfacesLib
- PRIVATE_LINK_LIBRARIES CaloEvent AthContainers AthenaBaseComps EventInfo xAODCaloEvent xAODJet xAODTau xAODEgamma xAODTracking PathResolver TrkTrack TrkTrackSummary TrigCaloEvent TrigNavStructure )
+ PRIVATE_LINK_LIBRARIES CaloEvent AthContainers AthenaBaseComps EventInfo xAODCaloEvent xAODJet xAODTau xAODEgamma xAODTracking PathResolver TrkTrack TrkTrackSummary TrigCaloEvent TrigNavStructure DecisionHandlingLib )
atlas_add_component( TrigTauHypo
src/components/*.cxx
INCLUDE_DIRS ${ROOT_INCLUDE_DIRS}
- LINK_LIBRARIES ${ROOT_LIBRARIES} StoreGateLib SGtests GaudiKernel MuidEvent Particle ITrackToVertex egammaEvent tauEvent VxVertex TrigInDetEvent TrigMuonEvent TrigParticle TrigSteeringEvent TrigTopoEvent TrigInterfacesLib CaloEvent AthContainers AthenaBaseComps EventInfo xAODCaloEvent xAODJet xAODTau xAODEgamma xAODTracking PathResolver TrkTrack TrkTrackSummary TrigCaloEvent TrigNavStructure TrigTauHypoLib )
+ LINK_LIBRARIES ${ROOT_LIBRARIES} StoreGateLib SGtests GaudiKernel MuidEvent Particle ITrackToVertex egammaEvent tauEvent VxVertex TrigInDetEvent TrigMuonEvent TrigParticle TrigSteeringEvent TrigTopoEvent TrigInterfacesLib CaloEvent AthContainers AthenaBaseComps EventInfo xAODCaloEvent xAODJet xAODTau xAODEgamma xAODTracking PathResolver TrkTrack TrkTrackSummary TrigCaloEvent TrigNavStructure TrigTauHypoLib DecisionHandlingLib AthViews )
# Install files from the package:
atlas_install_python_modules( python/*.py )
diff --git a/Trigger/TrigHypothesis/TrigTauHypo/python/TrigL2TauHypoTool.py b/Trigger/TrigHypothesis/TrigTauHypo/python/TrigL2TauHypoTool.py
new file mode 100644
index 0000000000000000000000000000000000000000..fff2b2041718f4e111969ebdc88b655b9bddcf96
--- /dev/null
+++ b/Trigger/TrigHypothesis/TrigTauHypo/python/TrigL2TauHypoTool.py
@@ -0,0 +1,33 @@
+
+def TrigTauHypoProvider( name, conf ):
+ part='calo'
+ threshold='25'
+ criteria='medium1'
+ strategy='tracktwo'
+
+ print "TrigL2TauHypoTool: name = ", name
+
+ # Simple implementation of 2015 pre-selection
+ currentHypoKey = 'l2'+part+'_tau'+threshold+'_'+criteria+'_'+strategy
+
+ # Re-define the calo part using the generic hypo
+ if part == 'calo':
+ from TrigTauHypo.TrigTauHypoConf import TrigTauGenericHypoMT
+ currentHypo = TrigTauGenericHypoMT(name)
+ currentHypo.MonTool = ""
+
+ # pT cut always defined: ugly string-to-int-to-string conversion, sorry :)
+ myThreshold = str(int(threshold)*1000.0)
+ theDetails = [int(-1)]
+ theFormulas = ['y > '+myThreshold]
+
+ if strategy =='calo' or strategy == 'caloonly' or strategy == 'tracktwocalo' or strategy == 'trackcalo':
+ # centFrac cut (detail #24: 2nd order fit, turn-off at ~ 55 GeV, 95% efficiency)
+ theDetails += [24]
+ theFormulas += ['x > (0.945 - (1.26e-05*TMath::Min(y, 50000.)) + (1.05e-10*TMath::Min(y, 50000.)*TMath::Min(y, 50000.)))']
+ # centFrac cut (detail #24: 2nd order fit, turn-off at 50 GeV, 90% efficiency)
+ # theFormulas += ['x > TMath::Max(0.936 - (8.5e-06*y) + (6.54e-11*y*y), 0.660)']
+ currentHypo.Details = theDetails
+ currentHypo.Formulas = theFormulas
+
+ return currentHypo
diff --git a/Trigger/TrigHypothesis/TrigTauHypo/src/ITrigTauGenericHypoTool.h b/Trigger/TrigHypothesis/TrigTauHypo/src/ITrigTauGenericHypoTool.h
new file mode 100755
index 0000000000000000000000000000000000000000..4e3cbdc65cedc83f18c4976f0a1091c22c480b82
--- /dev/null
+++ b/Trigger/TrigHypothesis/TrigTauHypo/src/ITrigTauGenericHypoTool.h
@@ -0,0 +1,63 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+#ifndef TRIGTAUHYPO_ITrigTauGenericHypoTool_H
+#define TRIGTAUHYPO_ITrigTauGenericHypoTool_H 1
+
+#include "GaudiKernel/IAlgTool.h"
+
+
+
+
+
+/**
+ * @class Base for tools dooing L2 Calo Hypo selection
+ * @brief
+ **/
+
+class ITrigTauGenericHypoTool
+ : virtual public ::IAlgTool
+{
+
+ public:
+ DeclareInterfaceID(ITrigTauGenericHypoTool, 1, 0);
+ virtual ~ITrigTauGenericHypoTool(){}
+
+ struct ClusterInfo {
+ ClusterInfo( TrigCompositeUtils::Decision* d, const TrigRoiDescriptor* r, const xAOD::TauJetContainer *c,
+ const TrigCompositeUtils::Decision* previousDecision )
+ : decision( d ),
+ roi( r ),
+ taucontainer(c),
+ previousDecisionIDs( TrigCompositeUtils::decisionIDs( previousDecision ).begin(),
+ TrigCompositeUtils::decisionIDs( previousDecision ).end() )
+ {}
+
+ TrigCompositeUtils::Decision* decision;
+ const TrigRoiDescriptor* roi;
+ const xAOD::TauJetContainer* taucontainer;
+ const TrigCompositeUtils::DecisionIDContainer previousDecisionIDs;
+ };
+
+
+ /**
+ * @brief decides upon all clusters
+ * Note it is for a reason a non-virtual method, it is an interface in gaudi sense and implementation.
+ * There will be many tools called often to perform this quick operation and we do not want to pay for polymorphism which we do not need to use.
+ * Will actually see when N obj hypos will enter the scene
+ **/
+ virtual StatusCode decide( std::vector<ClusterInfo>& input ) const = 0;
+
+ /**
+ * @brief Makes a decision for a single object
+ * The decision needs to be returned
+ **/
+ virtual bool decide( const ClusterInfo& i ) const = 0;
+
+ protected:
+
+
+};
+
+
+#endif //> !TRIGTAUHYPO_ITrigTauGenericHypoTool_H
diff --git a/Trigger/TrigHypothesis/TrigTauHypo/src/TrigTauCaloHypoAlgMT.cxx b/Trigger/TrigHypothesis/TrigTauHypo/src/TrigTauCaloHypoAlgMT.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..f0ffaca7778837918475632a96fcc17b35ef1934
--- /dev/null
+++ b/Trigger/TrigHypothesis/TrigTauHypo/src/TrigTauCaloHypoAlgMT.cxx
@@ -0,0 +1,112 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#include "GaudiKernel/Property.h"
+#include "TrigTauCaloHypoAlgMT.h"
+#include "DecisionHandling/HLTIdentifier.h"
+#include "DecisionHandling/TrigCompositeUtils.h"
+#include "AthViews/ViewHelper.h"
+
+using namespace TrigCompositeUtils;
+
+TrigTauCaloHypoAlgMT::TrigTauCaloHypoAlgMT( const std::string& name,
+ ISvcLocator* pSvcLocator ) :
+ ::HypoBase( name, pSvcLocator ) {}
+
+TrigTauCaloHypoAlgMT::~TrigTauCaloHypoAlgMT() {}
+
+StatusCode TrigTauCaloHypoAlgMT::initialize() {
+ ATH_MSG_INFO ( "Initializing " << name() << "..." );
+
+
+ ATH_CHECK( m_hypoTools.retrieve() );
+ std::cout << "After m_hypoTools.retrieve() " << std::endl;
+ ATH_CHECK( m_tauJetKey.initialize() );
+ std::cout << "After m_clusterKey.initialize() " << std::endl;
+ renounce( m_tauJetKey );// clusters are made in views, so they are not in the EvtStore: hide them
+
+ return StatusCode::SUCCESS;
+}
+
+StatusCode TrigTauCaloHypoAlgMT::finalize() {
+ return StatusCode::SUCCESS;
+}
+
+StatusCode TrigTauCaloHypoAlgMT::execute( const EventContext& context ) const {
+ ATH_MSG_DEBUG ( "Executing " << name() << "..." );
+ auto previousDecisionsHandle = SG::makeHandle( decisionInput(), context );
+ if( not previousDecisionsHandle.isValid() ) {//implicit
+ ATH_MSG_DEBUG( "No implicit RH for previous decisions "<< decisionInput().key()<<": is this expected?" );
+ return StatusCode::SUCCESS;
+ }
+
+ ATH_MSG_DEBUG( "Running with "<< previousDecisionsHandle->size() <<" implicit ReadHandles for previous decisions");
+
+
+ // new decisions
+ auto decisions = std::make_unique<DecisionContainer>();
+ auto aux = std::make_unique<DecisionAuxContainer>();
+ decisions->setStore( aux.get() );
+
+ // input for decision
+ std::vector<ITrigTauGenericHypoTool::ClusterInfo> toolInput;
+
+ // loop over previous decisions
+ size_t counter=0;
+ for ( auto previousDecision: *previousDecisionsHandle ) {
+ //get RoI
+ auto roiEL = previousDecision->objectLink<TrigRoiDescriptorCollection>( "initialRoI" );
+ ATH_CHECK( roiEL.isValid() );
+ const TrigRoiDescriptor* roi = *roiEL;
+
+ // get View
+ auto viewEL = previousDecision->objectLink< ViewContainer >( "view" );
+ ATH_CHECK( viewEL.isValid() );
+ auto clusterHandle = ViewHelper::makeHandle( *viewEL, m_tauJetKey, context);
+ ATH_CHECK( clusterHandle.isValid() );
+ ATH_MSG_DEBUG ( "Cluster handle size: " << clusterHandle->size() << "..." );
+
+ // create new decision
+ auto d = newDecisionIn( decisions.get(), name() );
+
+
+ toolInput.emplace_back( d, roi, clusterHandle.cptr(), previousDecision );
+
+ {
+ auto el = ViewHelper::makeLink( *viewEL, clusterHandle, 0 );
+ ATH_CHECK( el.isValid() );
+ d->setObjectLink( "feature", el );
+ }
+ d->setObjectLink( "roi", roiEL );
+ d->setObjectLink( "view", viewEL );
+ TrigCompositeUtils::linkToPrevious( d, decisionInput().key(), counter );
+ ATH_MSG_DEBUG( "Added view, roi, cluster, previous decision to new decision " << counter << " for view " << (*viewEL)->name() );
+ counter++;
+
+ }
+
+ ATH_MSG_DEBUG( "Found "<<toolInput.size()<<" inputs to tools");
+
+
+ for ( auto& tool: m_hypoTools ) {
+ ATH_CHECK( tool->decide( toolInput ) );
+ }
+
+ {// make output handle and debug
+ auto outputHandle = SG::makeHandle(decisionOutput(), context);
+ ATH_CHECK( outputHandle.record( std::move( decisions ), std::move( aux ) ) );
+ ATH_MSG_DEBUG ( "Exit with "<<outputHandle->size() <<" decisions");
+ TrigCompositeUtils::DecisionIDContainer allPassingIDs;
+ if ( outputHandle.isValid() ) {
+ for ( auto decisionObject: *outputHandle ) {
+ TrigCompositeUtils::decisionIDs( decisionObject, allPassingIDs );
+ }
+ for ( TrigCompositeUtils::DecisionID id : allPassingIDs ) {
+ ATH_MSG_DEBUG( " +++ " << HLT::Identifier( id ) );
+ }
+ }
+ }
+
+ return StatusCode::SUCCESS;
+}
diff --git a/Trigger/TrigHypothesis/TrigTauHypo/src/TrigTauCaloHypoAlgMT.h b/Trigger/TrigHypothesis/TrigTauHypo/src/TrigTauCaloHypoAlgMT.h
new file mode 100644
index 0000000000000000000000000000000000000000..b0725c89e4e67dcbad8746ebfdc4beba49c111ef
--- /dev/null
+++ b/Trigger/TrigHypothesis/TrigTauHypo/src/TrigTauCaloHypoAlgMT.h
@@ -0,0 +1,42 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+#ifndef TRIGTAUHYPO_TrigTauCaloHypoAlgMT_H
+#define TRIGTAUHYPO_TrigTauCaloHypoAlgMT_H
+
+#include <string>
+
+#include "AthenaBaseComps/AthReentrantAlgorithm.h"
+#include "AthViews/View.h"
+#include "TrigSteeringEvent/TrigRoiDescriptorCollection.h"
+#include "xAODTau/TauJetContainer.h"
+#include "DecisionHandling/TrigCompositeUtils.h"
+#include "DecisionHandling/HypoBase.h"
+
+#include "ITrigTauGenericHypoTool.h"
+
+/**
+ * @class TrigL2CaloHypoAlgMT
+ * @brief Implements egamma calo selection for the new HLT framework
+ **/
+class TrigTauCaloHypoAlgMT : public ::HypoBase {
+ public:
+
+ TrigTauCaloHypoAlgMT( const std::string& name, ISvcLocator* pSvcLocator );
+
+ virtual ~TrigTauCaloHypoAlgMT();
+
+ virtual StatusCode initialize() override;
+ virtual StatusCode execute( const EventContext& context ) const override;
+ virtual StatusCode finalize() override;
+
+ private:
+ TrigTauCaloHypoAlgMT();
+ ToolHandleArray< ITrigTauGenericHypoTool > m_hypoTools { this, "HypoTools", {}, "Hypo tools" };
+
+ SG::ReadHandleKey< xAOD::TauJetContainer > m_tauJetKey { this, "taujets", "taujets", "taujets in view" };
+
+
+};
+
+#endif //> !TRIGEGAMMAHYPO_TESTTRIGL2TAUCALOHYPOALG_H
diff --git a/Trigger/TrigHypothesis/TrigTauHypo/src/TrigTauCaloRoiUpdaterMT.cxx b/Trigger/TrigHypothesis/TrigTauHypo/src/TrigTauCaloRoiUpdaterMT.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..f8c939aa5f07df7ab542f8094a7112bd6f1b2974
--- /dev/null
+++ b/Trigger/TrigHypothesis/TrigTauHypo/src/TrigTauCaloRoiUpdaterMT.cxx
@@ -0,0 +1,123 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#include "TrigTauCaloRoiUpdaterMT.h"
+
+#include "GaudiKernel/MsgStream.h"
+#include "GaudiKernel/IToolSvc.h"
+#include "GaudiKernel/StatusCode.h"
+#include "StoreGate/StoreGateSvc.h"
+
+#include "TrigSteeringEvent/TrigRoiDescriptor.h"
+#include "TrigSteeringEvent/PhiHelper.h"
+
+#include "TLorentzVector.h"
+
+
+#include "TrigSteeringEvent/PhiHelper.h"
+
+TrigTauCaloRoiUpdaterMT::TrigTauCaloRoiUpdaterMT(const std::string & name, ISvcLocator* pSvcLocator) :
+ AthAlgorithm(name, pSvcLocator) {}
+
+StatusCode TrigTauCaloRoiUpdaterMT::initialize() {
+ ATH_MSG_INFO( "Initializing " << name() << " ... " );
+
+ ATH_MSG_DEBUG( "declareProperty review:" );
+ ATH_MSG_DEBUG( " " << m_dRForCenter );
+
+ ATH_MSG_DEBUG( "Initialising HandleKeys" );
+ CHECK( m_roIInputKey.initialize() );
+ CHECK( m_clustersKey.initialize() );
+ CHECK( m_roIOutputKey.initialize() );
+
+ return StatusCode::SUCCESS;
+}
+
+TrigTauCaloRoiUpdaterMT::~TrigTauCaloRoiUpdaterMT(){}
+
+StatusCode TrigTauCaloRoiUpdaterMT::execute() {
+
+ ATH_MSG_DEBUG( "Running "<< name() <<" ... " );
+ const EventContext& ctx = getContext();
+
+ // Prepare Outputs
+ std::unique_ptr< TrigRoiDescriptorCollection > roICollection( new TrigRoiDescriptorCollection() );
+
+ // Retrieve Input CaloClusterContainer
+ SG::ReadHandle< xAOD::CaloClusterContainer > CCContainerHandle = SG::makeHandle( m_clustersKey,ctx );
+ CHECK( CCContainerHandle.isValid() );
+ const xAOD::CaloClusterContainer *RoICaloClusterContainer = CCContainerHandle.get();
+ ATH_MSG_DEBUG( "Found " << RoICaloClusterContainer->size() << " caloClusters, updating the corresponding RoI ... " );
+
+ if(RoICaloClusterContainer != NULL) {
+ ATH_MSG_DEBUG( "REGTEST: Size of vector CaloCluster container is " << RoICaloClusterContainer->size());
+ if(RoICaloClusterContainer->size()==0) {
+ ATH_MSG_DEBUG( "Cannot proceed, size of vector CaloCluster container is " << RoICaloClusterContainer->size());
+ return StatusCode::SUCCESS;
+ }
+ }else {
+ ATH_MSG_DEBUG( "no CaloCluster container found " );
+ return StatusCode::SUCCESS;
+ }
+
+ //get RoI descriptor
+ SG::ReadHandle< TrigRoiDescriptorCollection > roisHandle = SG::makeHandle( m_roIInputKey, ctx );
+ ATH_MSG_DEBUG("Size of roisHandle: "<<roisHandle->size());
+ const TrigRoiDescriptor *roiDescriptor = roisHandle->at(0);
+
+ ATH_MSG_DEBUG( "; RoI ID = " << roiDescriptor->roiId()
+ << ": Eta = " << roiDescriptor->eta()
+ << ", Phi = " << roiDescriptor->phi() );
+
+ // fill local variables for RoI reference position
+ // Preserve the dEta and dPhi requirements from the original RoI
+ float dEta = fabs(roiDescriptor->etaPlus() - roiDescriptor->eta());
+ float dPhi = fabs(HLT::wrapPhi(roiDescriptor->phiPlus()-roiDescriptor->phi()));
+
+
+ // Make a minimal effort to speed things up ;)
+ TLorentzVector myCluster;
+ TLorentzVector TauBarycenter(0., 0., 0., 0.);
+
+ xAOD::CaloClusterContainer::const_iterator clusterIt;
+ for (clusterIt=RoICaloClusterContainer->begin(); clusterIt != RoICaloClusterContainer->end(); ++clusterIt) {
+ if((*clusterIt)->e() < 0)
+ continue;
+
+ myCluster.SetPtEtaPhiE((*clusterIt)->pt(), (*clusterIt)->eta(), (*clusterIt)->phi(), (*clusterIt)->e());
+ TauBarycenter += myCluster;
+ }
+
+ // Determine the LC tau pT at detector axis
+ TLorentzVector TauDetectorAxis(0.,0.,0.,0.);
+ for (clusterIt=RoICaloClusterContainer->begin(); clusterIt != RoICaloClusterContainer->end(); ++clusterIt) {
+ myCluster.SetPtEtaPhiE((*clusterIt)->pt(), (*clusterIt)->eta(), (*clusterIt)->phi(), (*clusterIt)->e());
+ if(TauBarycenter.DeltaR(myCluster) > m_dRForCenter)
+ continue;
+ TauDetectorAxis += myCluster;
+ } // end loop on clusters
+
+ // Prepare the new RoI
+ TrigRoiDescriptor *outRoi = new TrigRoiDescriptor(roiDescriptor->roiWord(), roiDescriptor->l1Id(), roiDescriptor->roiId(),
+ TauDetectorAxis.Eta(), TauDetectorAxis.Eta()-dEta, TauDetectorAxis.Eta()+dEta,
+ TauDetectorAxis.Phi(), HLT::wrapPhi(TauDetectorAxis.Phi()-dPhi), HLT::wrapPhi(TauDetectorAxis.Phi()+dPhi),
+ roiDescriptor->zed() ,roiDescriptor->zedMinus(), roiDescriptor->zedPlus());
+
+ ATH_MSG_DEBUG("Input RoI " << *roiDescriptor);
+ ATH_MSG_DEBUG("Output RoI " << *outRoi);
+
+ roICollection->push_back(outRoi);
+
+ // Save Outputs
+ ATH_MSG_DEBUG( "Saving RoIs to be used as input to Fast Tracking -- TO BE CHANGED -- ::: " << m_roIOutputKey.key() );
+ SG::WriteHandle< TrigRoiDescriptorCollection > outputRoiHandle = SG::makeHandle( m_roIOutputKey,ctx );
+ CHECK( outputRoiHandle.record( std::move( roICollection ) ) );
+
+ return StatusCode::SUCCESS;
+}
+
+StatusCode TrigTauCaloRoiUpdaterMT::finalize() {
+ ATH_MSG_INFO( "Finalizing " << name() << " ... " );
+ return StatusCode::SUCCESS;
+}
diff --git a/Trigger/TrigHypothesis/TrigTauHypo/src/TrigTauCaloRoiUpdaterMT.h b/Trigger/TrigHypothesis/TrigTauHypo/src/TrigTauCaloRoiUpdaterMT.h
new file mode 100644
index 0000000000000000000000000000000000000000..89eb202b719a3a393a939b3f3a57d7715da0edab
--- /dev/null
+++ b/Trigger/TrigHypothesis/TrigTauHypo/src/TrigTauCaloRoiUpdaterMT.h
@@ -0,0 +1,47 @@
+// emacs: this is -*- c++ -*-
+/*
+ Copyright (C) 2002-2018 CERN for the benefit of the ATLAS collaboration
+*/
+//
+// @file TrigRoiBuilderMT.h
+//
+
+
+#ifndef TrigTauCaloRoiUpdaterMT_H
+#define TrigTauCaloRoiUpdaterMT_H
+
+#include <iostream>
+
+#include "AthenaBaseComps/AthAlgorithm.h"
+#include "GaudiKernel/ToolHandle.h"
+
+#include "xAODCaloEvent/CaloClusterContainer.h"
+//#include "xAODJet/JetContainer.h"
+//#include "xAODJet/JetAuxContainer.h"
+
+#include "TrigSteeringEvent/TrigRoiDescriptor.h"
+
+class TrigTauCaloRoiUpdaterMT : public AthAlgorithm {
+
+ public:
+ TrigTauCaloRoiUpdaterMT(const std::string&, ISvcLocator*);
+ ~TrigTauCaloRoiUpdaterMT();
+
+ StatusCode initialize();
+ StatusCode finalize();
+ StatusCode execute();
+
+ private:
+ Gaudi::Property< float > m_dRForCenter {this,"dRForCenter",0.2,"Delta R from the center of ROI"};
+
+ //SG::ReadHandleKey< xAOD::JetContainer > m_jetInputKey {this,"JetInputKey","TrigJetRec","Input Jet Collection Key, retrieved from reconstructed jets"};
+ SG::ReadHandleKey< TrigRoiDescriptorCollection > m_roIInputKey {this,"RoIInputKey","Undefined",""};
+ SG::ReadHandleKey< xAOD::CaloClusterContainer > m_clustersKey { this, "calocluster_update", "caloclusters", "caloclusters in view" };
+ SG::WriteHandleKey< TrigRoiDescriptorCollection > m_roIOutputKey {this,"RoIOutputKey","EMViewRoIs","Output RoI Collection Key"};
+};
+
+
+#endif
+
+//** ---------------------------------------------------------------------------------------
+
diff --git a/Trigger/TrigHypothesis/TrigTauHypo/src/TrigTauGenericHypoMT.cxx b/Trigger/TrigHypothesis/TrigTauHypo/src/TrigTauGenericHypoMT.cxx
new file mode 100755
index 0000000000000000000000000000000000000000..c3966a5ab5fca30cf54b3509606d9b112929f878
--- /dev/null
+++ b/Trigger/TrigHypothesis/TrigTauHypo/src/TrigTauGenericHypoMT.cxx
@@ -0,0 +1,183 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+/********************************************************************
+ *
+ * NAME: TrigTauGenericHypoMT.cxx
+ * PACKAGE: Trigger/TrigHypothesis/TrigTauHypo
+ *
+ * AUTHORS: P.O. DeViveiros
+ * CREATED: Sometime in early 2015
+ *
+ * DESCRIPTION:
+ *
+ * Generic cut-based hypo
+ *
+ *********************************************************************/
+
+#include <iterator>
+#include <sstream>
+
+//
+#include "TLorentzVector.h"
+#include "TFormula.h"
+
+#include "GaudiKernel/IToolSvc.h"
+#include "GaudiKernel/StatusCode.h"
+#include "GaudiKernel/ListItem.h"
+//
+#include "TrigTauGenericHypoMT.h"
+
+#include "TrigSteeringEvent/TrigRoiDescriptor.h"
+
+#include "xAODJet/Jet.h"
+#include "xAODJet/JetContainer.h"
+#include "xAODCaloEvent/CaloCluster.h"
+#include "xAODCaloEvent/CaloClusterContainer.h"
+
+#include "xAODTau/TauJet.h"
+#include "xAODTau/TauJetContainer.h"
+
+#include "TrkTrack/Track.h"
+#include "TrkTrack/TrackCollection.h"
+
+#include "DecisionHandling/HLTIdentifier.h"
+#include "DecisionHandling/Combinators.h"
+#include "AthenaMonitoring/MonitoredScope.h"
+
+//class ISvcLocator;
+
+using namespace TrigCompositeUtils;
+
+TrigTauGenericHypoMT::TrigTauGenericHypoMT( const std::string& type,
+ const std::string& name,
+ const IInterface* parent )
+ : base_class( type, name, parent ),
+ m_decisionId( HLT::Identifier::fromToolName( name ) )
+{
+ declareProperty("Details", m_member);
+ declareProperty("Formulas", m_formula);
+}
+
+TrigTauGenericHypoMT::~TrigTauGenericHypoMT()
+{}
+
+StatusCode TrigTauGenericHypoMT::initialize()
+{
+
+ if ( !m_monTool.empty() ) CHECK( m_monTool.retrieve() );
+
+ ATH_MSG_DEBUG( "AcceptAll = "
+ << ( m_acceptAll==true ? "True" : "False" ) );
+
+ //m_multiplicity = m_lowerPtCut.size();
+ ATH_MSG_DEBUG( "Tool configured for chain/id: " << m_decisionId );
+
+ ATH_MSG_INFO(" REGTEST: TrigTauGenericHypoMT will cut on ");
+ ATH_MSG_INFO(" REGTEST: ------ ");
+
+ // Here we store the formulas since they need to compile
+ for(unsigned int i=0; i<m_member.size(); i++)
+ {
+ m_store.push_back(TFormula(("TauHypoCut"+m_formula.at(i)).c_str(), m_formula.at(i).c_str()));
+ ATH_MSG_INFO(" REGTEST: " << m_formula.at(i));
+ }
+ ATH_MSG_INFO(" REGTEST: where x is the ID variables, y is Tau pT and z is Tau eta ");
+ ATH_MSG_INFO("Initialization of TrigTauGenericHypoMT completed successfully");
+
+ return StatusCode::SUCCESS;
+}
+
+
+bool TrigTauGenericHypoMT::decide( const ITrigTauGenericHypoTool::ClusterInfo& input ) const {
+
+ bool pass = false;
+
+ using namespace Monitored;
+
+ auto PassedCuts = MonitoredScalar::declare<int>( "CutCounter", -1 );
+ auto monitorIt = MonitoredScope::declare( m_monTool, PassedCuts );
+
+ // when leaving scope it will ship data to monTool
+ PassedCuts = PassedCuts + 1; //got called (data in place)
+
+ if ( m_acceptAll ) {
+ pass = true;
+ ATH_MSG_DEBUG( "AcceptAll property is set: taking all events" );
+ } else {
+ pass = false;
+ ATH_MSG_DEBUG( "AcceptAll property not set: applying selection" );
+ }
+
+ // get tau collection
+ auto pTauCont = input.taucontainer;
+
+ if(pTauCont->size()!=0){
+ ATH_MSG_DEBUG(" Input tau collection has size " << pTauCont->size());
+ }else {
+ ATH_MSG_DEBUG("No taus in input collection: Rejecting");
+ pass=false;
+ return pass;
+ }
+
+ const xAOD::TauJet* aTau = pTauCont->back();
+
+ int hasFailed = 0;
+
+ // We have to implement the cuts here - Eventually, declare the formulas in the initialize
+ for(unsigned int i=0; i<m_member.size(); i++)
+ {
+ float theValue = 0;
+
+ // Detail -1 ignores by convention the ID variables
+ if(m_member.at(i) != -1)
+ {
+ xAOD::TauJetParameters::Detail myDetail = xAOD::TauJetParameters::Detail(m_member.at(i));
+ aTau->detail(myDetail, theValue);
+ }
+
+ // What about upper and lower bounds? can work using x, y, z, t...
+ double theResult = m_store.at(i).Eval(theValue, aTau->pt(), aTau->eta());
+ ATH_MSG_DEBUG(" Evaluating Hypothesis on ID Variable #: " << m_member.at(i) );
+ ATH_MSG_DEBUG(" With Cut = " << m_formula.at(i).c_str() );
+ ATH_MSG_DEBUG(" And value x (ID), y (pT), z (Eta) = " << theValue <<", "<< aTau->pt() << ", " << aTau->eta() );
+ ATH_MSG_DEBUG(" Result = " << (theResult > 0.5) );
+
+ if(theResult < 0.5)
+ {
+ hasFailed = i+1;
+ break;
+ }
+ }
+
+ if (hasFailed)
+ {
+ ATH_MSG_DEBUG(" REGTEST: Cut Number: "
+ << hasFailed-1
+ << " did not pass the threshold");
+ return pass;
+ }
+
+ pass = true;
+
+ ATH_MSG_DEBUG(" REGTEST: TE accepted !! ");
+
+
+ return pass;
+}
+
+
+
+StatusCode TrigTauGenericHypoMT::decide( std::vector<ClusterInfo>& input ) const {
+
+ for ( auto& i: input ) {
+ if ( passed ( m_decisionId.numeric(), i.previousDecisionIDs ) ) {
+ if ( decide( i ) ) {
+ addDecisionID( m_decisionId, i.decision );
+ }
+ }
+ }
+ return StatusCode::SUCCESS;
+}
+
diff --git a/Trigger/TrigHypothesis/TrigTauHypo/src/TrigTauGenericHypoMT.h b/Trigger/TrigHypothesis/TrigTauHypo/src/TrigTauGenericHypoMT.h
new file mode 100755
index 0000000000000000000000000000000000000000..4b44ed10f72af4730af21d960f6f45e6896cd33b
--- /dev/null
+++ b/Trigger/TrigHypothesis/TrigTauHypo/src/TrigTauGenericHypoMT.h
@@ -0,0 +1,76 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef TrigTauGenericHypoMT_H
+#define TrigTauGenericHypoMT_H
+
+/********************************************************************
+ *
+ * NAME: TrigTauGenericHypoMT.h
+ * PACKAGE: Trigger/TrigHypothesis/TrigTauHypo
+ *
+ * AUTHORS: P.O. DeViveiros
+ * CREATED: Sometime in early 2015
+ *
+ * DESCRIPTION:
+ *
+ * Implementation of generic cuts on TauID variables
+ *
+ *********************************************************************/
+
+#include <vector>
+#include "TFormula.h"
+//#include "TrigInterfaces/HypoAlgo.h"
+
+
+#include "GaudiKernel/Property.h"
+#include "CLHEP/Units/SystemOfUnits.h"
+#include "xAODTau/TauJet.h"
+#include "xAODTau/TauJetContainer.h"
+#include "TrigSteeringEvent/TrigRoiDescriptor.h"
+#include "AthenaBaseComps/AthAlgTool.h"
+#include "AthenaMonitoring/GenericMonitoringTool.h"
+#include "DecisionHandling/HLTIdentifier.h"
+#include "DecisionHandling/TrigCompositeUtils.h"
+
+#include "ITrigTauGenericHypoTool.h"
+
+class StoreGateSvc;
+
+namespace HLT {
+ class TriggerElement;
+}
+
+class TrigTauGenericHypoMT : public extends<AthAlgTool, ITrigTauGenericHypoTool> {
+ public:
+ TrigTauGenericHypoMT( const std::string& type,
+ const std::string& name,
+ const IInterface* parent );
+
+ virtual ~TrigTauGenericHypoMT();
+
+ virtual StatusCode initialize() override;
+
+ virtual StatusCode decide( std::vector<ITrigTauGenericHypoTool::ClusterInfo>& input ) const override;
+
+ virtual bool decide( const ITrigTauGenericHypoTool::ClusterInfo& i ) const override;
+
+ private:
+
+ /** Configurables */
+ HLT::Identifier m_decisionId;
+
+ std::vector<int> m_member;
+ std::vector<std::string> m_formula;
+ std::vector<TFormula> m_store;
+
+ Gaudi::Property<bool> m_decisionPerCluster{ this, "DecisionPerCluster", true, "Is multiplicity requirement refering to taus ( false ) or RoIs/clusters with taus ( false ), relevant only in when multiplicity > 1" };
+
+ Gaudi::Property<bool> m_acceptAll{ this, "AcceptAll", false, "Ignore selection" };
+
+ ToolHandle<GenericMonitoringTool> m_monTool{ this, "MonTool", "", "Monitoring tool" };
+
+};
+#endif
+
diff --git a/Trigger/TrigHypothesis/TrigTauHypo/src/components/TrigTauHypo_entries.cxx b/Trigger/TrigHypothesis/TrigTauHypo/src/components/TrigTauHypo_entries.cxx
index 3fa931f5238f983720efbd10547af2c9a03d2b3d..9dc4ce4d67b56c545a8432ab8168a3a882d9e54c 100644
--- a/Trigger/TrigHypothesis/TrigTauHypo/src/components/TrigTauHypo_entries.cxx
+++ b/Trigger/TrigHypothesis/TrigTauHypo/src/components/TrigTauHypo_entries.cxx
@@ -24,6 +24,9 @@
#include "TrigTauHypo/EFTauTopoHypo.h"
#include "TrigTauHypo/EFPhotonTauFex.h"
#include "TrigTauHypo/EFPhotonTauHypo.h"
+#include "../TrigTauCaloRoiUpdaterMT.h"
+#include "../TrigTauGenericHypoMT.h"
+#include "../TrigTauCaloHypoAlgMT.h"
DECLARE_COMPONENT( T2CaloTauHypo )
@@ -52,4 +55,6 @@ DECLARE_COMPONENT( EFTauTopoFex )
DECLARE_COMPONENT( EFTauTopoHypo )
DECLARE_COMPONENT( EFPhotonTauFex )
DECLARE_COMPONENT( EFPhotonTauHypo )
-
+DECLARE_COMPONENT( TrigTauCaloRoiUpdaterMT )
+DECLARE_COMPONENT( TrigTauGenericHypoMT )
+DECLARE_COMPONENT( TrigTauCaloHypoAlgMT )
diff --git a/Trigger/TrigValidation/TrigUpgradeTest/python/tauMenuDefs.py b/Trigger/TrigValidation/TrigUpgradeTest/python/tauMenuDefs.py
index ddce138cf2a364b2c90d6bcefcd855ba164a7134..9e337c0b4e9a3bb2a3087e50439a6d378806da2d 100644
--- a/Trigger/TrigValidation/TrigUpgradeTest/python/tauMenuDefs.py
+++ b/Trigger/TrigValidation/TrigUpgradeTest/python/tauMenuDefs.py
@@ -21,143 +21,63 @@ InDetFlags.doTruth = False
InDetFlags.init()
# PixelLorentzAngleSvc and SCTLorentzAngleSvc
-include("InDetRecExample/InDetRecConditionsAccess.py")
+#include("InDetRecExample/InDetRecConditionsAccess.py")
from InDetRecExample.InDetKeys import InDetKeys
# menu components
from TriggerMenuMT.HLTMenuConfig.Menu.MenuComponents import MenuSequence
# ===============================================================================================
-# L2 Calo
+# First step - Calo Roi Updater
# ===============================================================================================
-# from TrigT2CaloEgamma.TrigT2CaloEgammaConfig import T2CaloEgamma_ReFastAlgo
-# theFastCaloAlgo=T2CaloEgamma_ReFastAlgo("FastCaloAlgo" )
-# theFastCaloAlgo.OutputLevel=VERBOSE
-# theFastCaloAlgo.ClustersName="L2CaloClusters"
-# svcMgr.ToolSvc.TrigDataAccess.ApplyOffsetCorrection=False
-
from TrigCaloRec.TrigCaloRecConfig import TrigCaloCellMakerMT_tau
cellMaker = TrigCaloCellMakerMT_tau("CaloCellMakerTau")
cellMaker.OutputLevel=DEBUG
+
+from TrigCaloRec.TrigCaloRecConfig import TrigCaloClusterMakerMT_topo
+clusMaker = TrigCaloClusterMakerMT_topo("CaloClusMakerTopo")
+clusMaker.OutputLevel=VERBOSE
from AthenaCommon.CFElements import parOR, seqOR, seqAND, stepSeq
from ViewAlgs.ViewAlgsConf import EventViewCreatorAlgorithm
-fastCaloInViewAlgs = seqAND("fastCaloInViewAlgsTau", [cellMaker])
-
-
-
-fastCaloViewsMaker = EventViewCreatorAlgorithm("fastCaloViewsMakerTau", OutputLevel=DEBUG)
+fastCaloViewsMaker = EventViewCreatorAlgorithm("fastCaloViewsMakerTau", OutputLevel=VERBOSE)
fastCaloViewsMaker.ViewFallThrough = True
-fastCaloViewsMaker.RoIsLink = "initialRoI" # -||-
-fastCaloViewsMaker.InViewRoIs = "TAUCaloRoIs" # contract with the fastCalo
+fastCaloViewsMaker.RoIsLink = "initialRoI"
+fastCaloViewsMaker.InViewRoIs = "TAUCaloRoIs"
fastCaloViewsMaker.Views = "TAUCaloViews"
fastCaloViewsMaker.ViewNodeName = "fastCaloInViewAlgsTau"
-cellMaker.RoIs=fastCaloViewsMaker.InViewRoIs
+cellMaker.RoIs = fastCaloViewsMaker.InViewRoIs
-
-# are these needed?
CaloViewVerify = CfgMgr.AthViews__ViewDataVerifier("FastCaloViewDataVerifier")
CaloViewVerify.DataObjects = [('TrigRoiDescriptorCollection' , 'StoreGateSvc+fastCaloViewsMaker_InViewRoIs_out')]
+from TrigTauHypo.TrigTauHypoConf import TrigTauCaloRoiUpdaterMT
+CaloRoiUpdater = TrigTauCaloRoiUpdaterMT("CaloRoiUpdater")
+CaloRoiUpdater.OutputLevel = DEBUG
+CaloRoiUpdater.RoIInputKey = "TAUCaloRoIs"
+CaloRoiUpdater.RoIOutputKey = "RoiForTau"
+from TrigTauRec.TrigTauRecConfigMT import TrigTauRecMerged_TauCaloOnly
+caloRec = TrigTauRecMerged_TauCaloOnly()
+caloRec.OutputLevel = DEBUG
+caloRec.RoIInputKey = "RoiForTau"
+caloRec.L1RoIKey = "TAUCaloRoIs"
+caloRec.clustersKey = "caloclusters"
+caloRec.TrigTauRecOutputKey = "taujets"
+fastCaloInViewAlgs = seqAND("fastCaloInViewAlgsTau", [cellMaker,clusMaker,CaloRoiUpdater,caloRec])
+fastCaloAthSequence = seqAND("fastCaloAthSequenceTau",[fastCaloViewsMaker, fastCaloInViewAlgs])
+from TrigTauHypo.TrigTauHypoConf import TrigTauCaloHypoAlgMT
+fastCaloHypo = TrigTauCaloHypoAlgMT("TauGenericHypoMT")
+fastCaloHypo.OutputLevel = DEBUG
-from TrigEgammaHypo.TrigEgammaHypoConf import TrigL2CaloHypoAlgMT
-theFastCaloHypo = TrigL2CaloHypoAlgMT("L2CaloHypo")
-theFastCaloHypo.OutputLevel = DEBUG
-
-
-
-fastCaloAthSequence = seqAND("fastCaloAthSequenceTau",[fastCaloViewsMaker, fastCaloInViewAlgs ])
-
-from TrigUpgradeTest.TrigUpgradeTestConf import HLTTest__TestHypoAlg
-from TrigUpgradeTest.TrigUpgradeTestConf import HLTTest__TestHypoTool
-
-
-def genCaloHypoToolTau( name, conf ):
- return HLTTest__TestHypoTool("name")
+from TrigTauHypo.TrigL2TauHypoTool import TrigTauHypoProvider
def tauCaloSequence():
return MenuSequence( Sequence = fastCaloAthSequence,
Maker = fastCaloViewsMaker,
- Hypo = HLTTest__TestHypoAlg("DummyTauCaloHypo", Input=""),
- HypoToolGen = genCaloHypoToolTau )
-
-# #########################################
-# # second step: tracking.....
-# #########################################
-# #
-
-
-# from TrigUpgradeTest.InDetSetup import makeInDetAlgs
-
-# (viewAlgs, eventAlgs) = makeInDetAlgs()
-# from TrigFastTrackFinder.TrigFastTrackFinder_Config import TrigFastTrackFinder_eGamma
-
-# theFTF = TrigFastTrackFinder_eGamma()
-# theFTF.isRoI_Seeded = True
-# viewAlgs.append(theFTF)
-
-
-# # A simple algorithm to confirm that data has been inherited from parent view
-# # Required to satisfy data dependencies
-# ViewVerify = CfgMgr.AthViews__ViewDataVerifier("electronViewDataVerifier")
-# ViewVerify.DataObjects = [('xAOD::TrigEMClusterContainer','StoreGateSvc+L2CaloClusters')]
-# ViewVerify.OutputLevel = DEBUG
-# viewAlgs.append(ViewVerify)
-
-# TrackParticlesName = ""
-# for viewAlg in viewAlgs:
-# if viewAlg.name() == "InDetTrigTrackParticleCreatorAlg":
-# TrackParticlesName = viewAlg.TrackParticlesName
-
-
-# from TrigEgammaHypo.TrigL2ElectronFexMTConfig import L2ElectronFex_1
-# theElectronFex= L2ElectronFex_1()
-# theElectronFex.TrigEMClusterName = theFastCaloAlgo.ClustersName
-# theElectronFex.TrackParticlesName = TrackParticlesName
-# theElectronFex.ElectronsName="Electrons"
-# theElectronFex.OutputLevel=VERBOSE
-
-
-# l2ElectronViewsMaker = EventViewCreatorAlgorithm("l2ElectronViewsMaker", OutputLevel=DEBUG)
-# l2ElectronViewsMaker.RoIsLink = "roi" # -||-
-# l2ElectronViewsMaker.InViewRoIs = "EMIDRoIs" # contract with the fastCalo
-# l2ElectronViewsMaker.Views = "EMElectronViews"
-# l2ElectronViewsMaker.ViewFallThrough = True
-
-
-# for viewAlg in viewAlgs:
-# if viewAlg.properties().has_key("RoIs"):
-# viewAlg.RoIs = l2ElectronViewsMaker.InViewRoIs
-# if viewAlg.properties().has_key("roiCollectionName"):
-# viewAlg.roiCollectionName = l2ElectronViewsMaker.InViewRoIs
-# theElectronFex.RoIs = l2ElectronViewsMaker.InViewRoIs
-
-# electronInViewAlgs = parOR("electronInViewAlgs", viewAlgs + [ theElectronFex ])
-
-# l2ElectronViewsMaker.ViewNodeName = "electronInViewAlgs"
-
-
-# from TrigEgammaHypo.TrigEgammaHypoConf import TrigL2ElectronHypoAlgMT
-# theElectronHypo = TrigL2ElectronHypoAlgMT()
-# theElectronHypo.Electrons = theElectronFex.ElectronsName
-# theElectronHypo.RunInView=True
-# theElectronHypo.OutputLevel = VERBOSE
-
-# # this needs to be added:
-# #electronDecisionsDumper = DumpDecisions("electronDecisionsDumper", OutputLevel=DEBUG, Decisions = theElectronHypo.Output )
-
-# electronAthSequence = seqAND("electronAthSequence", eventAlgs + [l2ElectronViewsMaker, electronInViewAlgs ] )
-
-# from TrigEgammaHypo.TrigL2ElectronHypoTool import TrigL2ElectronHypoToolFromName
-
-# def electronSequence():
-# return MenuSequence( Maker = l2ElectronViewsMaker,
-# Sequence = electronAthSequence,
-# Hypo = theElectronHypo,
-# HypoToolGen = TrigL2ElectronHypoToolFromName )
-
+ Hypo = fastCaloHypo,
+ HypoToolGen = TrigTauHypoProvider )
diff --git a/Trigger/TrigValidation/TrigUpgradeTest/python/tauMenuDefs.py.bkup b/Trigger/TrigValidation/TrigUpgradeTest/python/tauMenuDefs.py.bkup
new file mode 100644
index 0000000000000000000000000000000000000000..d97e345e0a658d0a2625a2b179a7f3a3bc81c9c7
--- /dev/null
+++ b/Trigger/TrigValidation/TrigUpgradeTest/python/tauMenuDefs.py.bkup
@@ -0,0 +1,249 @@
+#
+# Copyright (C) 2002-2018 CERN for the benefit of the ATLAS collaboration
+#
+
+from AthenaCommon.Include import include
+from AthenaCommon.Constants import VERBOSE,DEBUG
+from AthenaCommon.AppMgr import ServiceMgr as svcMgr
+import AthenaCommon.CfgMgr as CfgMgr
+
+
+from InDetRecExample.InDetJobProperties import InDetFlags
+InDetFlags.doCaloSeededBrem = False
+InDetFlags.InDet25nsec = True
+InDetFlags.doPrimaryVertex3DFinding = False
+InDetFlags.doPrintConfigurables = False
+InDetFlags.doResolveBackTracks = True
+InDetFlags.doSiSPSeededTrackFinder = True
+InDetFlags.doTRTPhaseCalculation = True
+InDetFlags.doTRTSeededTrackFinder = True
+InDetFlags.doTruth = False
+InDetFlags.init()
+
+# PixelLorentzAngleSvc and SCTLorentzAngleSvc
+include("InDetRecExample/InDetRecConditionsAccess.py")
+from InDetRecExample.InDetKeys import InDetKeys
+
+# menu components
+from TriggerMenuMT.HLTMenuConfig.Menu.MenuComponents import MenuSequence
+
+# ===============================================================================================
+# L2 Calo
+# ===============================================================================================
+
+# from TrigT2CaloEgamma.TrigT2CaloEgammaConfig import T2CaloEgamma_ReFastAlgo
+# theFastCaloAlgo=T2CaloEgamma_ReFastAlgo("FastCaloAlgo" )
+# theFastCaloAlgo.OutputLevel=VERBOSE
+# theFastCaloAlgo.ClustersName="L2CaloClusters"
+# svcMgr.ToolSvc.TrigDataAccess.ApplyOffsetCorrection=False
+
+# ================
+# CellMaker
+# ================
+
+from TrigCaloRec.TrigCaloRecConfig import TrigCaloCellMakerMT_tau
+cellMaker = TrigCaloCellMakerMT_tau("CaloCellMakerTau")
+cellMaker.OutputLevel=DEBUG
+
+from TrigCaloRec.TrigCaloRecConfig import TrigCaloClusterMakerMT_topo
+clusMaker = TrigCaloClusterMakerMT_topo("CaloClusMakerTopo")
+clusMaker.OutputLevel=VERBOSE
+
+from TrigTauRec.TrigTauRecConfig import (TrigTauRecMerged_Tau2012,
+ TrigTauRecMerged_TauCaloOnly,
+ TrigTauRecMerged_TauCaloOnlyMVA,
+ TrigTauRecMerged_TauFTK,
+ TrigTauRecMerged_TauPrecision,
+ TrigTauRecMerged_TauPreselection,
+ TrigTauRecMerged_TauPrecisionMVA)
+
+
+from AthenaCommon.CFElements import parOR, seqOR, seqAND, stepSeq
+from ViewAlgs.ViewAlgsConf import EventViewCreatorAlgorithm
+
+fastCaloViewsMaker = EventViewCreatorAlgorithm("fastCaloViewsMakerTau", OutputLevel=VERBOSE)
+fastCaloViewsMaker.ViewFallThrough = True
+fastCaloViewsMaker.RoIsLink = "initialRoI" # -||-
+fastCaloViewsMaker.InViewRoIs = "TAUCaloRoIs" # contract with the fastCalo
+fastCaloViewsMaker.Views = "TAUCaloViews"
+fastCaloViewsMaker.ViewNodeName = "fastCaloInViewAlgsTau"
+cellMaker.RoIs = fastCaloViewsMaker.InViewRoIs
+
+
+#fastCaloAthSequence = seqAND("fastCaloAthSequenceTau",[fastCaloViewsMaker, fastCaloInViewAlgs])
+
+# are these needed?
+CaloViewVerify = CfgMgr.AthViews__ViewDataVerifier("FastCaloViewDataVerifier")
+CaloViewVerify.DataObjects = [('TrigRoiDescriptorCollection' , 'StoreGateSvc+fastCaloViewsMaker_InViewRoIs_out')]
+
+from TrigTauHypo.TrigTauHypoConf import TrigTauCaloRoiUpdaterMT
+CaloRoiUpdater = TrigTauCaloRoiUpdaterMT("CaloRoiUpdater")
+CaloRoiUpdater.OutputLevel = DEBUG
+CaloRoiUpdater.RoIInputKey = "TAUCaloRoIs"
+CaloRoiUpdater.RoIOutputKey = "RoiForTau" # Default for Fast Tracking Algs
+
+l2TauViewsMaker = EventViewCreatorAlgorithm("l2TauViewsMaker", OutputLevel=DEBUG)
+l2TauViewsMaker.RoIsLink = "roi" # -||-
+l2TauViewsMaker.InViewRoIs = "RoiForCalo" # contract with the fastCalo
+l2TauViewsMaker.Views = "TAUCaloViews"
+l2TauViewsMaker.ViewFallThrough = True
+
+fastCaloInViewAlgs = seqAND("fastCaloInViewAlgsTau", [cellMaker,clusMaker,CaloRoiUpdater])
+
+#for viewAlg in ViewAlgs:
+# if viewAlg.properties().has_key("RoIs"):
+# viewAlg.RoIs = l2TauViewsMaker.InViewRoIs
+# if viewAlg.properties().has_key("roiCollectionName"):
+# viewAlg.roiCollectionName = TauElectronViewsMaker.InViewRoIs
+#CaloRoiUpdater.caloclusters = l2TauViewsMaker.InViewRoIs
+
+#fastCaloAthSequence = seqAND("fastCaloAthSequenceRoIUpdater", [ CaloRoiUpdater ])
+fastCaloAthSequence = seqAND("fastCaloAthSequenceTau",[fastCaloViewsMaker, fastCaloInViewAlgs])
+
+#l2TauViewsMaker.ViewNodeName = "tauInViewAlgs"
+
+#Copying code from here
+#from TrigEgammaHypo.TrigL2ElectronFexMTConfig import L2ElectronFex_1
+#theElectronFex= L2ElectronFex_1()
+#theElectronFex.TrigEMClusterName = theFastCaloAlgo.ClustersName
+#theElectronFex.TrackParticlesName = TrackParticlesName
+#theElectronFex.ElectronsName="Electrons"
+#theElectronFex.OutputLevel=VERBOSE
+
+
+#l2ElectronViewsMaker = EventViewCreatorAlgorithm("l2ElectronViewsMaker", OutputLevel=DEBUG)
+#l2ElectronViewsMaker.RoIsLink = "roi" # -||-
+#l2ElectronViewsMaker.InViewRoIs = "EMIDRoIs" # contract with the fastCalo
+#l2ElectronViewsMaker.Views = "EMElectronViews"
+#l2ElectronViewsMaker.ViewFallThrough = True
+
+
+#for viewAlg in viewAlgs:
+# if viewAlg.properties().has_key("RoIs"):
+# viewAlg.RoIs = l2ElectronViewsMaker.InViewRoIs
+# if viewAlg.properties().has_key("roiCollectionName"):
+# viewAlg.roiCollectionName = l2ElectronViewsMaker.InViewRoIs
+#theElectronFex.RoIs = l2ElectronViewsMaker.InViewRoIs
+
+#electronInViewAlgs = parOR("electronInViewAlgs", viewAlgs + [ theElectronFex ])
+
+#l2ElectronViewsMaker.ViewNodeName = "electronInViewAlgs"
+#to here
+
+
+
+
+
+
+#from TrigUpgradeTest.TrigUpgradeTestConf import HLTTest__TestHypoAlg
+#from TrigUpgradeTest.TrigUpgradeTestConf import HLTTest__TestHypoTool
+
+
+#def genCaloHypoToolTau( name, conf ):
+# return HLTTest__TestHypoTool("name")
+
+#def tauCaloSequence():
+# return MenuSequence( Sequence = fastCaloAthSequence,
+# Maker = fastCaloViewsMaker,
+# Hypo = HLTTest__TestHypoAlg("L2TauCaloHypoAlg", Input=""),
+# HypoToolGen = genCaloHypoToolTau )
+
+#Keep these lines for the future
+from TrigTauHypo.TrigTauHypoConf import TrigL2TauCaloHypoAlgMT
+fastCaloHypo = TrigL2TauCaloHypoAlgMT("L2TauCaloHypo")
+fastCaloHypo.OutputLevel = DEBUG
+
+
+from TrigTauHypo.TrigL2TauHypoTool import TrigL2TauHypoToolFromName
+#from TrigTauHypo.TrigTauHypoBase import
+#from TrigTauHypo.L2TauHypoTool import TrigL2TauHypoTool
+#from TrigUpgradeTest.TrigUpgradeTestConf import HLTTest__TestHypoTool
+
+#def genCaloHypoToolTau( name, conf ):
+# return HLTTest__TestHypoTool("name")
+
+#from TrigTauHypo.TrigL2CaloHypoTool import TrigL2CaloHypoToolFromName
+
+#Will use this later
+def tauCaloSequence():
+ return MenuSequence( Sequence = fastCaloAthSequence,
+ Maker = fastCaloViewsMaker,
+ Hypo = fastCaloHypo,
+ HypoToolGen = TrigL2TauHypoToolFromName )
+
+
+# #########################################
+# # second step: tracking.....
+# #########################################
+# #
+
+
+# from TrigUpgradeTest.InDetSetup import makeInDetAlgs
+
+# (viewAlgs, eventAlgs) = makeInDetAlgs()
+# from TrigFastTrackFinder.TrigFastTrackFinder_Config import TrigFastTrackFinder_eGamma
+
+# theFTF = TrigFastTrackFinder_eGamma()
+# theFTF.isRoI_Seeded = True
+# viewAlgs.append(theFTF)
+
+
+# # A simple algorithm to confirm that data has been inherited from parent view
+# # Required to satisfy data dependencies
+# ViewVerify = CfgMgr.AthViews__ViewDataVerifier("electronViewDataVerifier")
+# ViewVerify.DataObjects = [('xAOD::TrigEMClusterContainer','StoreGateSvc+L2CaloClusters')]
+# ViewVerify.OutputLevel = DEBUG
+# viewAlgs.append(ViewVerify)
+
+# TrackParticlesName = ""
+# for viewAlg in viewAlgs:
+# if viewAlg.name() == "InDetTrigTrackParticleCreatorAlg":
+# TrackParticlesName = viewAlg.TrackParticlesName
+
+
+# from TrigEgammaHypo.TrigL2ElectronFexMTConfig import L2ElectronFex_1
+# theElectronFex= L2ElectronFex_1()
+# theElectronFex.TrigEMClusterName = theFastCaloAlgo.ClustersName
+# theElectronFex.TrackParticlesName = TrackParticlesName
+# theElectronFex.ElectronsName="Electrons"
+# theElectronFex.OutputLevel=VERBOSE
+
+
+# l2ElectronViewsMaker = EventViewCreatorAlgorithm("l2ElectronViewsMaker", OutputLevel=DEBUG)
+# l2ElectronViewsMaker.RoIsLink = "roi" # -||-
+# l2ElectronViewsMaker.InViewRoIs = "EMIDRoIs" # contract with the fastCalo
+# l2ElectronViewsMaker.Views = "EMElectronViews"
+# l2ElectronViewsMaker.ViewFallThrough = True
+
+
+# for viewAlg in viewAlgs:
+# if viewAlg.properties().has_key("RoIs"):
+# viewAlg.RoIs = l2ElectronViewsMaker.InViewRoIs
+# if viewAlg.properties().has_key("roiCollectionName"):
+# viewAlg.roiCollectionName = l2ElectronViewsMaker.InViewRoIs
+# theElectronFex.RoIs = l2ElectronViewsMaker.InViewRoIs
+
+# electronInViewAlgs = parOR("electronInViewAlgs", viewAlgs + [ theElectronFex ])
+
+# l2ElectronViewsMaker.ViewNodeName = "electronInViewAlgs"
+
+
+# from TrigEgammaHypo.TrigEgammaHypoConf import TrigL2ElectronHypoAlgMT
+# theElectronHypo = TrigL2ElectronHypoAlgMT()
+# theElectronHypo.Electrons = theElectronFex.ElectronsName
+# theElectronHypo.RunInView=True
+# theElectronHypo.OutputLevel = VERBOSE
+
+# # this needs to be added:
+# #electronDecisionsDumper = DumpDecisions("electronDecisionsDumper", OutputLevel=DEBUG, Decisions = theElectronHypo.Output )
+
+# electronAthSequence = seqAND("electronAthSequence", eventAlgs + [l2ElectronViewsMaker, electronInViewAlgs ] )
+
+# from TrigEgammaHypo.TrigL2ElectronHypoTool import TrigL2ElectronHypoToolFromName
+
+# def electronSequence():
+# return MenuSequence( Maker = l2ElectronViewsMaker,
+# Sequence = electronAthSequence,
+# Hypo = theElectronHypo,
+# HypoToolGen = TrigL2ElectronHypoToolFromName )
+
diff --git a/Trigger/TrigValidation/TrigUpgradeTest/share/tau.menu.py b/Trigger/TrigValidation/TrigUpgradeTest/share/tau.menu.py
index fe53b1c1d0275f5378a6f7f80b68929ecd752348..52892a7dcfd2c2aa3cffc87600bb27f8094d652d 100644
--- a/Trigger/TrigValidation/TrigUpgradeTest/share/tau.menu.py
+++ b/Trigger/TrigValidation/TrigUpgradeTest/share/tau.menu.py
@@ -24,15 +24,16 @@ from TriggerMenuMT.HLTMenuConfig.Menu.MenuComponents import Chain, ChainStep
# ]
from TrigUpgradeTest.tauMenuDefs import tauCaloSequence
+#, tauCaloRecSequence
step1=ChainStep("Step1_tau", [tauCaloSequence()])
-# step2=ChainStep("Step2_etcut", [electronStep])
+#step2=ChainStep("Step2_taucalorec", [tauCaloRecSequence()])
testChains = [
- Chain(name='HLT_tau8_loose', Seed="L1_TAU8", ChainSteps=[step1] ),
- Chain(name='HLT_tau10_loose', Seed="L1_TAU8", ChainSteps=[step1] ),
+ Chain(name='HLT_tau0_perf_ptonly_L1TAU12', Seed="L1_TAU12", ChainSteps=[step1] ),
+ Chain(name='HLT_tau25_medium1_tracktwo', Seed="L1_TAU12IM", ChainSteps=[step1] ),
]