diff --git a/Trigger/TrigHypothesis/TrigCaloHypo/TrigCaloHypo/TrigL2JetHypo.h b/Trigger/TrigHypothesis/TrigCaloHypo/TrigCaloHypo/TrigL2JetHypo.h
new file mode 100644
index 0000000000000000000000000000000000000000..c1d0fff500e9365f02a83e0bdd43aa1345f391d6
--- /dev/null
+++ b/Trigger/TrigHypothesis/TrigCaloHypo/TrigCaloHypo/TrigL2JetHypo.h
@@ -0,0 +1,115 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef TRIGL2JETHYPO_H
+#define TRIGL2JETHYPO_H
+/////////////////////////////////////////////////////////////////////////////////////////////////////
+/// Name : TrigL2JetHypo.h
+/// Package : Trigger/TrigHypothesis/TrigCaloHypo/
+/// Author : Ester Segura (segura@ifae.es)
+/// Created : June 2006
+///
+/// DESCRIPTION: simple hypo algorithms for Lvl2 Jet, cut on energy
+///
+///////////////////////////////////////////////////////////////////////////////////////////////////////
+#include <vector>
+
+#include "TrigInterfaces/HypoAlgo.h"
+#include "TrigTimeAlgs/TrigTimerSvc.h"
+
+class StoreGateSvc;
+class TriggerElement;
+
+class TrigL2JetHypo : public HLT::HypoAlgo {
+
+ public:
+
+ TrigL2JetHypo(const std::string& name, ISvcLocator* pSvcLocator);
+ ~TrigL2JetHypo();
+
+ HLT::ErrorCode hltInitialize();
+ HLT::ErrorCode hltFinalize();
+ HLT::ErrorCode hltExecute(const HLT::TriggerElement* outputTE, bool& pass);
+
+
+ private:
+
+ // define the properties:
+ //----------------------------
+
+ // Cuts to be applied:
+
+ double m_EtCut_L2;
+
+ int m_accepted_L2;
+ int m_rejected_L2;
+ int m_errors_L2;
+
+ // Switch to accept all the events.
+
+ bool m_acceptAll;
+
+ // Switch on Monitoring:
+
+ bool m_doMonitoring;
+
+ // cleaning:
+ // ---------
+ // flags (do specific jet cleaning or don't):
+ bool m_doHECfnLeadingCellsCleaning;
+ bool m_doEMfJetQualityCleaning;
+ bool m_doHECfJetQualityCleaning;
+ bool m_doTimeQualityCleaning;
+ bool m_doEMfCleaningHighEta;
+ bool m_doEMfCleaningLowEta;
+ bool m_applyCleaningToHighEtJets;
+ bool m_applyCleaningToLowEtJets;
+ // depending on the flags m_applyCleaningToHighEtJets and m_applyCleaningToLowEtJets, the cleaning
+ // is only applied to jets with Et > cleaningLowEtThreshold and/or Et < cleaningHighEtThreshold.
+ float m_cleaningLowEtThreshold; // in MeV
+ float m_cleaningHighEtThreshold; // in MeV
+ // thresholds for cleaning cuts:
+ int m_leadingCellsThr; // threshold for number of leading cells in hecf > m_leadingCellsThr && nLeadingCells <= m_leadingCellsThr cut
+ float m_hecfThrN; // hecf threshold for cut in combination with nLeadingCells (i.e. hecf > m_leadingCellsThr && nLeadingCells <= m_leadingCellsThr)
+ float m_hecfThrQ; // hecf threshold for cut in combination with jet Quality (i.e. hecf > m_hecfThrQ && |quality| > m_jetQualityThrH)
+ float m_jetQualityThrH; // quality threshold for cut in combination with hecf (i.e. hecf > m_hecfThrQ && |quality| > m_jetQualityThrH)
+ float m_jetQualityThrE; // quality threshold for cut in combination with emf (i.e. emf > m_emfThrQ && |quality| > m_jetQualityThrE && |eta| < m_etaThrEmfQ)
+ float m_emfThrQ; // emf threshold for cut in combination with m_jetQualityThrE (i.e. emf > m_emfThrQ && |quality| > m_jetQualityThrE && |eta| < m_etaThrEmfQ)
+ float m_etaThrEmfQ; // eta threshold for cut in combination with m_jetQualityThrE (i.e. emf > m_emfThrQ && |quality| > m_jetQualityThrE && |eta| < m_etaThrEmfQ)
+ float m_emfThrEmfHighEta; // emf threshold for cut at high eta (i.e. emf < m_emfThrEmfHighEta && |eta| >= m_etaThrEmfHighEta)
+ float m_etaThrEmfHighEta; // eta threshold for cut at high eta (i.e. emf < m_emfThrEmfHighEta && |eta| >= m_etaThrEmfHighEta)
+ float m_emfThrEmfLowEta; // emf threshold for cut at low eta (i.e. emf < m_emfThrEmfLowEta && |eta| < m_etaThrEmfLowEta)
+ float m_etaThrEmfLowEta; // eta threshold for cut at low eta (i.e. emf < m_emfThrEmfLowEta && |eta| < m_etaThrEmfLowEta)
+ float m_timeThrTimeQuality; // time threshold for identification of out-of-time jets (i.e. |time| > m_timeThrTimeQuality && |quality| > m_qualityThrTimeQuality)
+ float m_qualityThrTimeQuality; // quality threshold for identification of out-of-time jets (i.e. |time| > m_timeThrTimeQuality && |quality| > m_qualityThrTimeQuality)
+
+ // basic cleaning default for every chain
+ bool m_doBasicCleaning;
+ float m_n90Threshold;
+ float m_presamplerThreshold;
+ float m_negativeEThreshold;
+
+ int m_cutCounter;
+ double m_e; // total energy of the jet after calibration
+ double m_et;
+ double m_eta;
+ double m_phi;
+ // cleaning:
+ float m_hecf;
+ int m_nLeadingCells;
+ float m_emf;
+ float m_jetQuality;
+ float m_jetTimeCells;
+
+ // Histogram Service:
+ //IHistogramSvc* m_histsvc;
+
+ //StoreGateSvc* m_storeGate;
+
+ // Timing:
+
+ ITrigTimerSvc* m_timersvc;
+ std::vector<TrigTimer*> m_timers;
+};
+#endif
diff --git a/Trigger/TrigHypothesis/TrigCaloHypo/python/TrigCaloHypoConfig.py b/Trigger/TrigHypothesis/TrigCaloHypo/python/TrigCaloHypoConfig.py
index ecc372f6ab96dc1626a3afcf5beedbea225d6981..c70c6b8101a9913de882d5b77c379b765df21444 100644
--- a/Trigger/TrigHypothesis/TrigCaloHypo/python/TrigCaloHypoConfig.py
+++ b/Trigger/TrigHypothesis/TrigCaloHypo/python/TrigCaloHypoConfig.py
@@ -14,3 +14,36 @@ class EFCaloHypoNoiseConfig (TrigEFCaloHypoNoise):
self.BadFEBCut=3
theLArNoisyROTool=LArNoisyROTool(SaturatedCellTightCut=20,MNBLooseCut=5,MNBTightCut=17)
self.NoiseTool = theLArNoisyROTool
+
+from TrigJetHypo.TrigJetHypoConf import TrigL2JetHypo
+
+class L2JetHypoBase (TrigL2JetHypo):
+ __slots__ = []
+ def __init__(self, name):
+ super( L2JetHypoBase, self ).__init__( name )
+
+ #validation = TrigL2JetHypoValidationMonitoring()
+ #online = TrigL2JetHypoOnlineMonitoring()
+ #cosmic = TrigL2JetHypoCosmicMonitoring()
+
+ from TrigTimeMonitor.TrigTimeHistToolConfig import TrigTimeHistToolConfig
+ time = TrigTimeHistToolConfig("L2JetHypo_Time")
+
+ self.AthenaMonTools = [ time ]
+
+ # switch on basic cleaning by default for all chains
+ self.n90CleaningThreshold = 2
+ self.presamplerCleaningThreshold = 0.9
+
+class L2JetHypo (L2JetHypoBase):
+ __slots__ = []
+ def __init__(self, name = "L2JetHypo",l2_thr=20*GeV):
+ super( L2JetHypo, self ).__init__( name )
+
+ self.Etcut_L2 = l2_thr
+ self.doHECfnLeadingCellsCleaning = False
+ self.doEMfJetQualityCleaning = False
+ self.doHECfJetQualityCleaning = False
+ self.doTimeQualityCleaning = False
+ self.doEMfCleaningHighEta = False
+ self.doEMfCleaningLowEta = False
diff --git a/Trigger/TrigHypothesis/TrigCaloHypo/src/TrigL2JetHypo.cxx b/Trigger/TrigHypothesis/TrigCaloHypo/src/TrigL2JetHypo.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..a7447e5d71918288d273d0a7ee7f472edeee9739
--- /dev/null
+++ b/Trigger/TrigHypothesis/TrigCaloHypo/src/TrigL2JetHypo.cxx
@@ -0,0 +1,336 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+// ********************************************************************
+//
+// NAME: TrigL2JetHypo.cxx
+// PACKAGE: Trigger/TrigHypothesis/TrigCaloHypo
+//
+// AUTHOR:
+//
+// ********************************************************************
+
+#include "GaudiKernel/MsgStream.h"
+#include "GaudiKernel/IToolSvc.h"
+#include "GaudiKernel/StatusCode.h"
+
+//#include "TrigSteeringEvent/TriggerElement.h"
+
+#include "TrigSteeringEvent/TrigRoiDescriptor.h"
+
+#include "TrigCaloEvent/TrigT2Jet.h"
+//#include "TrigCaloEvent/TrigT2JetContainer.h" // Not needed anymore
+
+#include "TrigCaloHypo/TrigL2JetHypo.h"
+
+#include "CLHEP/Units/SystemOfUnits.h"
+
+class ISvcLocator;
+
+/////////////////////////////////////////////////////////////////////
+// CONSTRUCTOR:
+/////////////////////////////////////////////////////////////////////
+//
+TrigL2JetHypo::TrigL2JetHypo(const std::string& name, ISvcLocator* pSvcLocator):
+ HLT::HypoAlgo(name, pSvcLocator) {
+
+ declareProperty("Etcut_L2", m_EtCut_L2 = 20*CLHEP::GeV, "cut value for L2 jet et"); // Default: 20 GeV
+ declareProperty("doMonitoring_L2", m_doMonitoring = false, "switch on/off monitoring" );
+ declareProperty("AcceptAll", m_acceptAll=false);
+ //declareProperty("histoPath", m_path = "/stat/Monitoring/EventFilter" );
+
+ // cleaning:
+ // --------
+ // flags to set which jet cleaning cuts are to be applied
+ declareProperty("doHECfnLeadingCellsCleaning", m_doHECfnLeadingCellsCleaning = false);
+ declareProperty("doEMfJetQualityCleaning", m_doEMfJetQualityCleaning = false);
+ declareProperty("doHECfJetQualityCleaning", m_doHECfJetQualityCleaning = false);
+ declareProperty("doTimeQualityCleaning", m_doTimeQualityCleaning = false);
+ declareProperty("doEMfCleaningHighEta", m_doEMfCleaningHighEta = false);
+ declareProperty("doEMfCleaningLowEta", m_doEMfCleaningLowEta = false);
+ declareProperty("applyCleaningToHighEtJets", m_applyCleaningToHighEtJets = true);
+ declareProperty("applyCleaningToLowEtJets", m_applyCleaningToLowEtJets = true);
+ // Et-threshold: if(applyCleaningToHighEtJets==false) then don't apply cleaning cuts to jets with Et > highEtThreshold:
+ declareProperty("cleaningHighEtThreshold", m_cleaningHighEtThreshold = 1000.*CLHEP::GeV);
+ // Et-threshold: if(applyCleaningToLowEtJets==false) then don't apply cleaning cuts to jets with Et < lowEtThreshold:
+ declareProperty("cleaningLowEtThreshold", m_cleaningLowEtThreshold = 20.*CLHEP::GeV);
+ // threshold for number of leading cells in hecf > m_leadingCellsThr && nLeadingCells <= m_leadingCellsThr cut:
+ declareProperty("leadingCellsThr", m_leadingCellsThr = 1);
+ // hecf threshold for cut in combination with nLeadingCells (i.e. hecf > m_hecfThrN && nLeadingCells <= m_leadingCellsThr):
+ declareProperty("hecfThrN", m_hecfThrN = 0.9);
+ // hecf threshold for cut in combination with jet Quality (i.e. hecf > m_hecfThrQ && |quality| > m_jetQualityThrH):
+ declareProperty("hecfThrQ", m_hecfThrQ = 0.8);
+ // quality threshold for cut in combination with hecf (i.e. hecf > m_hecfThrQ && |quality| > m_jetQualityThrH):
+ declareProperty("jetQualityThrH", m_jetQualityThrH= 0.8);
+ // quality threshold for cut in combination with emf (i.e. emf > m_emfThrQ && |quality| > m_jetQualityThrE):
+ declareProperty("jetQualityThrE", m_jetQualityThrE = 0.9);
+ // emf threshold for cut in combination with m_jetQualityThrE (i.e. emf > m_emfThrQ && |quality| > m_jetQualityThrE):
+ declareProperty("emfThrQ", m_emfThrQ = 0.99);
+ // eta threshold for cut in combination with m_jetQualityThrE (i.e. emf > m_emfThrQ && |quality| > m_jetQualityThrE && |eta| < m_etaThrEmfQ)
+ declareProperty("etaThrEmfQ", m_etaThrEmfQ = 2.7);
+ // emf threshold for emf cut at high eta (i.e. emf < m_emfThrE && |eta| >= m_etaThrEemf):
+ declareProperty("emfThrEmfHighEta", m_emfThrEmfHighEta = 0.02);
+ // eta threshold for emf cut at high eta (i.e. emf < m_emfThrE && |eta| >= m_etaThrEemf):
+ declareProperty("etaThrEmfHighEta", m_etaThrEmfHighEta = 2.1);
+ // emf threshold for emf cut at low eta (i.e. emf < m_emfThrE && |eta| < m_etaThrEemf):
+ declareProperty("emfThrEmfLowEta", m_emfThrEmfLowEta = 0.01);
+ // eta threshold for emf cut at low eta (i.e. emf < m_emfThrE && |eta| < m_etaThrEemf):
+ declareProperty("etaThrEmfLowEta", m_etaThrEmfLowEta = 2.1);
+ // time threshold for identification of out-of-time jets (i.e. |time| > m_timeThrTimeQuality && |quality| > m_qualityThrTimeQuality):
+ declareProperty("timeThrTimeQuality", m_timeThrTimeQuality = 35.);
+ // quality threshold for identification of out-of-time jets (i.e. |time| > m_timeThrTimeQuality && |quality| > m_qualityThrTimeQuality):
+ declareProperty("qualityThrTimeQuality", m_qualityThrTimeQuality = 0.5);
+
+ // basic cleaning
+ declareProperty("doBasicCleaning", m_doBasicCleaning = false );
+
+ declareProperty("n90CleaningThreshold", m_n90Threshold = 2 );
+ declareProperty("presamplerCleaningThreshold", m_presamplerThreshold = 0.9 );
+ declareProperty("negativeECleaningThreshold", m_negativeEThreshold = -60e3 ); // 60 GeV
+
+
+ declareMonitoredVariable("CutCounter", m_cutCounter);
+ declareMonitoredVariable("E", m_e);
+ declareMonitoredVariable("Et", m_et);
+ declareMonitoredVariable("Eta", m_eta);
+ declareMonitoredVariable("Phi", m_phi);
+ // cleaning:
+ declareMonitoredVariable("HECf", m_hecf);
+ declareMonitoredVariable("nLeadingCells", m_nLeadingCells);
+ declareMonitoredVariable("EMf", m_emf);
+ declareMonitoredVariable("jetQuality", m_jetQuality);
+ declareMonitoredVariable("jetTimeCells", m_jetTimeCells);
+
+}
+/////////////////////////////////////////////////////////////////////
+// DESTRUCTOR:
+/////////////////////////////////////////////////////////////////////
+//
+TrigL2JetHypo::~TrigL2JetHypo()
+{ }
+
+// ----------------------------------------------------------------------
+HLT::ErrorCode TrigL2JetHypo::hltInitialize()
+// ----------------------------------------------------------------------
+{
+ msg() << MSG::INFO << "in initialize()" << endmsg;
+
+ // Initialize timing service
+ //------------------------------
+ if( service( "TrigTimerSvc", m_timersvc).isFailure() ) {
+ msg() << MSG::WARNING << name()
+ << ": Unable to locate TrigTimer Service" << endmsg;
+ }
+ if (m_timersvc) {
+
+ TrigTimer* tmp = m_timersvc->addItem("TrigL2JetHypo.TrigL2JetHypoTot");
+ m_timers.push_back(tmp);
+ }
+
+ m_accepted_L2=0;
+ m_rejected_L2=0;
+ m_errors_L2=0;
+
+ return HLT::OK;
+}
+
+// ----------------------------------------------------------------------
+HLT::ErrorCode TrigL2JetHypo::hltFinalize(){
+// ----------------------------------------------------------------------
+
+ msg() << MSG::INFO << "in finalize()" << endmsg;
+ msg() << MSG::INFO << "Events (Lvl2) accepted/rejected/errors: "<< m_accepted_L2 <<" / "<<m_rejected_L2<< " / "<< m_errors_L2<< endmsg;
+
+ return HLT::OK;
+}
+
+// ----------------------------------------------------------------------
+HLT::ErrorCode TrigL2JetHypo::hltExecute(const HLT::TriggerElement* outputTE, bool& pass) {
+// ----------------------------------------------------------------------
+
+ // Time total TrigL2JetHypo execution time.
+
+ if (m_timersvc) m_timers[0]->start();
+
+ m_cutCounter = -1;
+ m_e = -99;
+ m_et = -99;
+ m_eta = -99;
+ m_phi = -99;
+ m_hecf = -99;
+ m_nLeadingCells = -99;
+ m_emf = -99;
+ m_jetQuality = -99;
+ m_jetTimeCells = -999;
+
+ pass=false;
+
+ // get the trigger element and extract the RoI information
+
+ if(msgLvl() <= MSG::DEBUG) { // pure debug purposes...
+ const TrigRoiDescriptor* roiDescriptor = 0;
+ if ( getFeature(outputTE, roiDescriptor, "a_label")==HLT::OK ) {
+ if ( roiDescriptor ) {
+ msg() << MSG::DEBUG << "REGTEST: RoI id " << roiDescriptor->roiId()
+ << " located at phi = " << roiDescriptor->phi() << ", eta = " << roiDescriptor->eta() << endmsg;
+ } else {
+ msg() << MSG::DEBUG << "Failed to find RoiDescriptor " << endmsg;
+ }
+ } else {
+ msg() << MSG::DEBUG << "Failed to find RoiDescriptor " << endmsg;
+ }
+ }
+
+ std::vector<const TrigT2Jet*> vectorOfJets;
+
+ HLT::ErrorCode ec = getFeatures(outputTE, vectorOfJets);
+
+ if(ec!=HLT::OK) {
+ msg() << MSG::WARNING << " Failed to get the L2 Jets " << endmsg;
+ if (m_timersvc) m_timers[0]->stop();
+ return ec;
+ }
+
+ m_cutCounter = 0;
+
+ // Check that there is only one JETROI.
+ // We only expect ONE input RoI.
+ if (vectorOfJets.size() != 1){
+ msg() << MSG::ERROR << "The number of Jets attached to the TE is not 1" << endmsg;
+ m_errors_L2++;
+ if (m_acceptAll) m_cutCounter = 1;
+ if (m_timersvc) m_timers[0]->stop();
+ return HLT::OK;
+ }
+
+ // Get first (and only) RoI:
+ const TrigT2Jet* pJet = vectorOfJets.back();
+ if(!pJet){
+ msg() << MSG::ERROR << "Retrieval of RoI from vector failed" << endmsg;
+ m_errors_L2++;
+ if (m_acceptAll) m_cutCounter = 1;
+ if (m_timersvc) m_timers[0]->stop();
+ return HLT::OK;
+ }
+
+ // Build the "uses" relation for the outputTE to the Cluster:
+ //sc = writeHistoryOfTE(outputTE, uses, pJet);
+ /*if (!sc){
+ log << MSG::ERROR
+ << "Write of TrigT2Jet into outputTE failed"
+ << endmsg;
+ return StatusCode::FAILURE;
+ } */ // Not used anymore.
+
+ //double etjet = pJet->e();
+ double etjet = pJet->et();
+
+ if(msgLvl() <= MSG::DEBUG) msg() << MSG::DEBUG << "Jet energy (L2): " << etjet << endmsg;
+
+ // ---------------------------------------------------------
+ // jet cleaning:
+ // =============
+ // global flag cleaningVeto: if this flag is set to true,
+ // the hypo will reject the event (if in addition m_acceptAll == false)
+ bool cleaningVeto = false;
+
+ // depending on the values of the two flags applyCleaningToHighEtJets and applyCleaningToLowEtJets, the cleaning
+ // is only applied to jets with Et > cleaningLowEtThreshold and/or Et < cleaningHighEtThreshold.
+ bool applyCleaning = true;
+
+ if(m_applyCleaningToHighEtJets == false && etjet > m_cleaningHighEtThreshold){
+ applyCleaning = false;
+ }
+ else if(m_applyCleaningToLowEtJets == false && etjet < m_cleaningLowEtThreshold){ // else if construct for performance
+ applyCleaning = false;
+ }
+
+ if(applyCleaning == true){
+ // n90 and hecfraction cut:
+ if( m_doHECfnLeadingCellsCleaning == true && pJet->nLeadingCells() <= m_leadingCellsThr && pJet->hecf() > m_hecfThrN ){
+ cleaningVeto = true;
+ }
+ // else if constructs for performance (once cleaning veto is true, the decision to reject the jet is taken)
+ // bad quality in EMC:
+ else if( m_doEMfJetQualityCleaning == true &&
+ pJet->emf() > m_emfThrQ && fabs(pJet->jetQuality()) > m_jetQualityThrE && fabs(pJet->eta()) < m_etaThrEmfQ ){
+ cleaningVeto = true;
+ }
+ // bad quality in HEC
+ else if( m_doHECfJetQualityCleaning == true && pJet->hecf() > m_hecfThrQ && fabs(pJet->jetQuality()) > m_jetQualityThrH ){
+ cleaningVeto = true;
+ }
+ // out-of-time jets
+ else if( m_doTimeQualityCleaning == true &&
+ fabs(pJet->jetTimeCells()) > m_timeThrTimeQuality && fabs(pJet->jetQuality()) > m_qualityThrTimeQuality ){
+ cleaningVeto = true;
+ }
+ // very small fraction of energy in EMC at high eta:
+ else if(m_doEMfCleaningHighEta == true && pJet->emf() < m_emfThrEmfHighEta && fabs(pJet->eta()) >= m_etaThrEmfHighEta ){
+ cleaningVeto = true;
+ }
+ // very small fraction of energy in EMC at low eta:
+ else if(m_doEMfCleaningLowEta == true && pJet->emf() < m_emfThrEmfLowEta && fabs(pJet->eta()) < m_etaThrEmfLowEta ){
+ cleaningVeto = true;
+ }
+ }
+
+ if(m_doBasicCleaning)
+ {
+ if(pJet->nLeadingCells() < m_n90Threshold)
+ {
+ msg() << MSG::DEBUG << " L2 basic jet cleaning: n90 < " << m_n90Threshold << endmsg;
+ cleaningVeto = true;
+ }
+
+/* if(pJet->presamplerFraction() > m_presamplerThreshold)
+ {
+ msg() << MSG::DEBUG << " L2 basic jet cleaning: presampler fraction > " << m_presamplerThreshold << endmsg;
+ cleaningVeto = true;
+ }
+
+ if(pJet->?() < m_negativeEThreshold)
+ {
+ msg() << MSG::DEBUG << " EF jet cleaning: Negative energy < " << m_negativeEThreshold << endmsg;
+ cleaningVeto = true;
+ }*/
+ }
+ // end of jet cleaning
+ // ---------------------------------------------------------
+
+ // Et and Jet Quality Cut
+ if( (etjet > m_EtCut_L2 && cleaningVeto == false) || m_acceptAll) {
+ pass = true;
+ m_accepted_L2++;
+ m_cutCounter=1;
+
+ if ( etjet > m_EtCut_L2 && cleaningVeto == false) {
+ m_e = pJet->e();
+ m_eta = pJet->eta();
+ m_phi = pJet->phi();
+ m_et = m_e/cosh(m_eta);
+ // monitor cleaning variables:
+ m_emf = pJet->emf();
+ m_hecf = pJet->hecf();
+ m_nLeadingCells = pJet->nLeadingCells();
+ m_jetQuality = pJet-> jetQuality();
+ m_jetTimeCells = pJet-> jetTimeCells();
+ }
+
+ if(msgLvl() <= MSG::DEBUG) msg() << MSG::DEBUG << " Event accepted ! " << endmsg;
+ } else {
+ m_rejected_L2++;
+ if(msgLvl() <= MSG::DEBUG) msg() << MSG::DEBUG << " Event rejected !" << endmsg;
+ }
+
+ //m_cutCounter>1 not yet implemented
+
+ // Time total TrigL2JetHypo execution time.
+ // -------------------------------------
+
+ if (m_timersvc) m_timers[0]->stop();
+
+ return HLT::OK;
+
+}
diff --git a/Trigger/TrigHypothesis/TrigCaloHypo/src/components/TrigCaloHypo_entries.cxx b/Trigger/TrigHypothesis/TrigCaloHypo/src/components/TrigCaloHypo_entries.cxx
index c189df1945ec9e697b35441a9314d0dbd1c2cfcb..856b1564af2f88ad5ee649c269fb70737c91cb7c 100644
--- a/Trigger/TrigHypothesis/TrigCaloHypo/src/components/TrigCaloHypo_entries.cxx
+++ b/Trigger/TrigHypothesis/TrigCaloHypo/src/components/TrigCaloHypo_entries.cxx
@@ -1,12 +1,15 @@
#include "TrigCaloHypo/TrigEFCaloHypoNoise.h"
+#include "TrigCaloHypo/TrigL2JetHypo.h"
#include "GaudiKernel/DeclareFactoryEntries.h"
DECLARE_ALGORITHM_FACTORY( TrigEFCaloHypoNoise )
+DECLARE_ALGORITHM_FACTORY( TrigL2JetHypo )
DECLARE_FACTORY_ENTRIES( TrigCaloHypo ) {
DECLARE_ALGORITHM( TrigEFCaloHypoNoise )
+ DECLARE_ALGORITHM( TrigL2JetHypo )
}