Merge branch 'cherry-pick-6e356f3d-21.3' into '21.3'

Sweeping !43648 from 21.9 to 21.3.
TrigL0GepPerf: Add custom jet algorithm functionality

See merge request atlas/athena!44549

Trigger/TrigL0GepPerf/TrigL0GepPerf/CaloCellsHandler.h

 /*
- *   Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+ *   Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
  */
 
-#ifndef CaloCellsHandler_H
-#define CaloCellsHandler_H
+#ifndef TRIGL0GEPPERF_CaloCellsHandler_H
+#define TRIGL0GEPPERF_CaloCellsHandler_H
 
 #include "CaloEvent/CaloCellContainer.h"
 #include "CaloEvent/CaloCell.h"
@@ -27,14 +27,14 @@ class CaloCellsHandler{
   void passNoiseTool(ToolHandle<ICalorimeterNoiseTool> m_noiseTool) { noiseTool_cells = m_noiseTool; }
   void passCaloCellIDTool( const CaloCell_ID* ccIdHelper) { m_ccIdHelper = ccIdHelper; }  
 
-  CustomCaloCell getCaloCell(unsigned int id) { return m_caloCells[id]; }
-  std::map<unsigned int,CustomCaloCell> getCaloCellsMap(){ return m_caloCells; }
+  Gep::CustomCaloCell getCaloCell(unsigned int id) { return m_caloCells[id]; }
+  std::map<unsigned int,Gep::CustomCaloCell> getCaloCellsMap(){ return m_caloCells; }
 
 
 
  private:
 
-  std::map<unsigned int,CustomCaloCell> m_caloCells; 
+  std::map<unsigned int,Gep::CustomCaloCell> m_caloCells; 
   ToolHandle<ICalorimeterNoiseTool> noiseTool_cells;
   const mutable CaloCell_ID* m_ccIdHelper;
   std::vector<unsigned int> getNeighbours(const CaloCellContainer* allcells, const CaloCell* acell);

Trigger/TrigL0GepPerf/TrigL0GepPerf/CustomCaloCell.h

 /*
- *   Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+ *   Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
  */
 
-#ifndef CUSTOMCALOCELL_H
-#define CUSTOMCALOCELL_H
+#ifndef TRIGL0GEPPERF_CUSTOMCALOCELL_H
+#define TRIGL0GEPPERF_CUSTOMCALOCELL_H
 
 #include <vector>
 #include <iostream>
 
-class CustomCaloCell
-{
+namespace Gep{
+  class CustomCaloCell
+  {
+    
+  public:
+    CustomCaloCell() {}
+    ~CustomCaloCell() {}
+    
+    float e;
+    float et;
+    float time;
+    unsigned int quality;
+    unsigned int provenance;
+    float totalNoise;
+    float electronicNoise;
+    float sigma;
+    bool isBad;
+    float eta;
+    float phi;
+    float etaMin;
+    float etaMax;
+    float phiMin;
+    float phiMax;
+    float etaGranularity;
+    float phiGranularity;
+    float sinTh;
+    float cosTh;
+    float sinPhi;
+    float cosPhi;
+    float cotTh;
+    float x;
+    float y;
+    float z;
+    int layer;
+    bool isEM;
+    bool isEM_barrel;
+    bool isEM_endCap;
+    bool isEM_barrelPos;
+    bool isEM_barrelNeg;
+    bool isFCAL;
+    bool isHEC;
+    bool isTile;
+    unsigned int sampling;
+    unsigned int id;
+    std::string detName;
+    std::vector<unsigned int> neighbours;
+    
+    bool isBadCell() const {return isBad;}
+    
+    
+  private:
+    
+  };
+}
 
- public:
-  CustomCaloCell() {}
-  ~CustomCaloCell() {}
-
-  float e;
-  float et;
-  float time;
-  unsigned int quality;
-  unsigned int provenance;
-  float totalNoise;
-  float electronicNoise;
-  float sigma;
-  bool isBad;
-  float eta;
-  float phi;
-  float etaMin;
-  float etaMax;
-  float phiMin;
-  float phiMax;
-  float etaGranularity;
-  float phiGranularity;
-  float sinTh;
-  float cosTh;
-  float sinPhi;
-  float cosPhi;
-  float cotTh;
-  float x;
-  float y;
-  float z;
-  int layer;
-  bool isEM;
-  bool isEM_barrel;
-  bool isEM_endCap;
-  bool isEM_barrelPos;
-  bool isEM_barrelNeg;
-  bool isFCAL;
-  bool isHEC;
-  bool isTile;
-  unsigned int sampling;
-  unsigned int id;
-  std::string detName;
-  std::vector<unsigned int> neighbours;
-
-  bool isBadCell() const {return isBad;}
-
-
- private:
-
-};
-#endif //CUSTOMCALOCELL_H
+#endif //TRIGL0GEPPERF_CUSTOMCALOCELL_H

Trigger/TrigL0GepPerf/TrigL0GepPerf/CustomJet.h

+/*
+ *   Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
+ */
+
+#ifndef TRIGL0GEPPERF_CUSTOMJET_H
+#define TRIGL0GEPPERF_CUSTOMJET_H
+
+#include "TLorentzVector.h"
+
+namespace Gep{
+  struct CustomJet
+  {
+   
+    TLorentzVector vec;    
+    float radius;
+    int nConstituents;
+    
+  };
+}
+
+#endif //TRIGL0GEPPERF_CUSTOMJET_H

Trigger/TrigL0GepPerf/TrigL0GepPerf/CustomTopoCluster.h

 /*
- *   Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+ *   Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
  */
 
-#ifndef CUSTOMTOPOCLUSTER_H
-#define CUSTOMTOPOCLUSTER_H
+#ifndef TRIGL0GEPPERF_CUSTOMTOPOCLUSTER_H
+#define TRIGL0GEPPERF_CUSTOMTOPOCLUSTER_H
 
 #include <vector>
-#include <iostream>
-
-class CustomTopoCluster
-{
-
- public:
-  CustomTopoCluster() {}
-  ~CustomTopoCluster() {}
-
-  void erase() {
-    ncells = 0;
-    e  = 0.0;
-    et = 0.0;
-    time = 0.0;
-    eta = 0.0;
-    phi = 0.0;
-    cell_id = {};
-  }
-  bool isEmptyCluster() const{
-    if (ncells == 0) return true;
-    return false;
-  }
-
-  int ncells;
-  float e;
-  float et;
-  float time;
-  float eta;
-  float phi;
-  std::vector<unsigned int> cell_id;
-
- private:
-
-};
-#endif //CUSTOMTOPOCLUSTER_H
+#include "TLorentzVector.h"
+
+namespace Gep{
+
+  class CustomTopoCluster
+  {
+    
+  public:
+    CustomTopoCluster() {}
+    ~CustomTopoCluster() {}
+    
+    void erase() {
+      ncells = 0;
+      time = 0.;
+      vec.SetPxPyPzE(0.,0.,0.,0.);
+      cell_id = {};
+    }
+    
+    bool isEmptyCluster() const{
+      if (ncells == 0) return true;
+      return false;
+    }
+    
+    int ncells;
+    float time;
+    TLorentzVector vec;
+    std::vector<unsigned int> cell_id;
+    
+  private:
+    
+  };
+}
+
+#endif //TRIGL0GEPPERF_CUSTOMTOPOCLUSTER_H

Trigger/TrigL0GepPerf/TrigL0GepPerf/GepClusteringAlg.h

 /*
- *   Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+ *   Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
  */
 
 #ifndef TRIGL0GEPPERF_GEPCLUSTERINGALG_H
@@ -21,17 +21,9 @@
 class GepClusteringAlg: public ::AthAnalysisAlgorithm { 
  public: 
   GepClusteringAlg( const std::string& name, ISvcLocator* pSvcLocator );
-  virtual ~GepClusteringAlg(); 
-
-                                        //IS EXECUTED:
-  virtual StatusCode  initialize();     //once, before any input is loaded
-  //virtual StatusCode  beginInputFile(); //start of each input file, only metadata loaded
-  //virtual StatusCode  firstExecute();   //once, after first eventdata is loaded (not per file)
-  virtual StatusCode  execute();        //per event
-  //virtual StatusCode  endInputFile();   //end of each input file
-  //virtual StatusCode  metaDataStop();   //when outputMetaStore is populated by MetaDataTools
-  virtual StatusCode  finalize();       //once, after all events processed
-  
+
+  virtual StatusCode  initialize() override;   
+  virtual StatusCode  execute() override;    
 
  private: 
 

Trigger/TrigL0GepPerf/TrigL0GepPerf/GepJetAlg.h

+/*
+ *   Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
+ */
+
+#ifndef TRIGL0GEPPERF_GEPJETALG_H
+#define TRIGL0GEPPERF_GEPJETALG_H 1
+
+#include "AthAnalysisBaseComps/AthAnalysisAlgorithm.h"
+#include "GaudiKernel/ToolHandle.h"
+
+#include "TrigL0GepPerf/CustomTopoCluster.h"
+#include "TrigL0GepPerf/CustomJet.h"
+
+#include <string>
+
+
+class GepJetAlg: public ::AthAnalysisAlgorithm {
+
+ public:
+  GepJetAlg( const std::string& name, ISvcLocator* pSvcLocator );
+  virtual StatusCode  execute() override; 
+
+ private:
+
+  std::string m_jetAlg;
+  std::string m_topoclLabel;
+
+};
+
+#endif //> !TRIGL0GEPPERF_GEPJETALG_H

Trigger/TrigL0GepPerf/TrigL0GepPerf/IJetMaker.h

+/*
+ *   Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
+ */
+
+#ifndef TRIGL0GEPPERF_IJETMAKER_H
+#define TRIGL0GEPPERF_IJETMAKER_H
+
+#include <string>
+
+#include "TrigL0GepPerf/CustomJet.h"
+#include "TrigL0GepPerf/CustomTopoCluster.h"
+
+namespace Gep{
+  class IJetMaker
+  {
+  public:
+    
+    virtual std::vector<Gep::CustomJet> makeJet(const std::vector<Gep::CustomTopoCluster> &clusters) = 0;
+    virtual std::string getName() const = 0;
+    
+    virtual ~IJetMaker() {}
+    
+  };
+}
+
+#endif

Trigger/TrigL0GepPerf/TrigL0GepPerf/ITopoClusterMaker.h

+/*
+ *   Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
+ */
+
+#ifndef TRIGL0GEPPERF_ITOPOCLUSTERMAKER_H
+#define TRIGL0GEPPERF_ITOPOCLUSTERMAKER_H
+
+#include <map> 
+#include <string>
+
+#include "TrigL0GepPerf/CustomTopoCluster.h"
+#include "TrigL0GepPerf/CustomCaloCell.h"
+
+namespace Gep{
+  class ITopoClusterMaker
+  {
+  public:
+    
+    virtual std::vector<Gep::CustomTopoCluster>  makeTopoCluster(const std::map<unsigned int,Gep::CustomCaloCell> &caloCellsMap) = 0;
+    virtual std::string getName() const = 0;
+    
+    virtual ~ITopoClusterMaker() {}
+    
+  };
+}
+
+
+#endif

Trigger/TrigL0GepPerf/TrigL0GepPerf/TopoClusterMaker_Base.h

-/*
- *   Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
- */
-
-#ifndef TOPOCLUSTERMAKER_BASE_H
-#define TOPOCLUSTERMAKER_BASE_H
-
-#include <map> 
-#include <string>
-
-#include "TrigL0GepPerf/CustomTopoCluster.h"
-#include "TrigL0GepPerf/CustomCaloCell.h"
-
-class TopoClusterMaker_Base
-{
- public:
-
-  virtual std::vector<CustomTopoCluster>  makeTopoCluster(const std::map<unsigned int,CustomCaloCell> &caloCellsMap) = 0;
-  virtual std::string getName() const = 0;
-  
-  virtual ~TopoClusterMaker_Base() {}
-
-};
-
-
-#endif

Trigger/TrigL0GepPerf/python/L0GepSimulationSequence.py

@@ -10,6 +10,7 @@ def setupL0GepSimulationSequence():
 
     from TrigL0GepPerf.JetBuilder import addStandardJets, modifyClusters, modifyJets
     from TrigL0GepPerfConf import GepClusteringAlg
+    from TrigL0GepPerfConf import GepJetAlg
     from TrigL0GepPerfConf import ClusterTiming
     from TrigL0GepPerfConf import MissingETGepCl
     from TrigL0GepPerfConf import MissingETGepPufit
@@ -37,14 +38,17 @@ def setupL0GepSimulationSequence():
     topoclAlgs = ['CaloCal','Calo420','Calo422']
     # pileup suppression
     puSupprAlgs = ['', 'Vor', 'SK', 'VorSK']
-
+    # jet reconstruction
+    jetAlgs = ['AntiKt4']
 
     for topoMaker in topoclAlgs:
 
-        # run topoclustering algorithm
+        # topoclusters
         if( topoMaker == 'CaloCal' or topoMaker == 'Calo420' or topoMaker == 'Calo422'):
-            log.info('\n No topoclustering algorithm given. Using '+topoMaker+'TopoClusters')
+            # use existing topoclusters
+            log.info('\n Using '+topoMaker+'TopoClusters')
         else:
+            # run custom topoclustering 
             log.info('\n Running '+topoMaker+' topoclustering \n')
             topSequence += GepClusteringAlg( topoMaker, TopoclAlg=topoMaker, CaloNoiseTool=theCaloNoiseTool )
 
@@ -53,17 +57,25 @@ def setupL0GepSimulationSequence():
 
         for puSupAlg in puSupprAlgs:            
 
-            clusterAlgs = topoMaker+puSupAlg
-            inputClusterName = clusterAlgs+'TopoClusters' 
-            # run AntiKt4 jet reconstruction
-            modifyJets( clusterAlgs )      
+            topoclLabel = topoMaker+puSupAlg
+
+            # jets
+            for jetAlg in jetAlgs:
+                if jetAlg=='AntiKt4':
+                    # run Athena AntiKt4 jet reconstruction
+                    modifyJets( topoclLabel )      
+                else:
+                    # run custom jet algorithm
+                    topSequence += GepJetAlg( jetAlg+topoclLabel, TopoclLabel=topoclLabel, JetAlg=jetAlg)
 
             # get MET
-            outputMETName = 'cluster'+clusterAlgs
-            topSequence += MissingETGepCl(outputMETName,inputClusters=inputClusterName,outputMET=outputMETName) 
+            inputTopoclName = topoclLabel+'TopoClusters' 
+            outputMETName = 'cluster'+topoclLabel
+            topSequence += MissingETGepCl(outputMETName,inputClusters=inputTopoclName,outputMET=outputMETName) 
             # get MET with pufit
-            outputMETPufitName = 'pufit'+clusterAlgs
-            topSequence += MissingETGepPufit(outputMETPufitName,inputClusters=inputClusterName,outputMET=outputMETPufitName); 
+            outputMETPufitName = 'pufit'+topoclLabel
+            topSequence += MissingETGepPufit(outputMETPufitName,inputClusters=inputTopoclName,outputMET=outputMETPufitName); 
+
 
 
     # ClusterTiming currently cannot run on custom clusters

Trigger/TrigL0GepPerf/src/CaloCellsHandler.cxx

 /*
- *   Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+ *   Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
  */
 
 #include <vector>
@@ -33,7 +33,7 @@ void CaloCellsHandler::fillCellsInformation(const CaloCellContainer* cells){
   m_caloCells.clear();  
 
   for(auto cell: *cells){
-    CustomCaloCell caloCell; 
+    Gep::CustomCaloCell caloCell; 
     
     caloCell.e          = cell->energy();
     caloCell.et         = cell->energy() * 1.0/TMath::CosH(cell->eta());
@@ -109,7 +109,7 @@ void CaloCellsHandler::fillCellsInformation(const CaloCellContainer* cells){
     caloCell.phiGranularity = dphi;
     
     // store cells map    
-    m_caloCells.insert(std::pair<unsigned int, CustomCaloCell>(caloCell.id, caloCell));
+    m_caloCells.insert(std::pair<unsigned int, Gep::CustomCaloCell>(caloCell.id, caloCell));
     
   }
 }

Trigger/TrigL0GepPerf/src/GepClusteringAlg.cxx

 /*
- *   Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+ *   Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
  */
 
 #include "TrigL0GepPerf/GepClusteringAlg.h"
 
 // Base class 
-#include "TrigL0GepPerf/TopoClusterMaker_Base.h"
+#include "TrigL0GepPerf/ITopoClusterMaker.h"
 
 // *** Include custom topoclustering classes inherited from base class ***
 
@@ -20,7 +20,6 @@
 #include "JetEDM/PseudoJetVector.h"
 
 
-
 GepClusteringAlg::GepClusteringAlg( const std::string& name, ISvcLocator* pSvcLocator ) : 
   AthAnalysisAlgorithm( name, pSvcLocator ),
   m_topoclAlg ("TopoclAlg")
@@ -32,9 +31,6 @@ GepClusteringAlg::GepClusteringAlg( const std::string& name, ISvcLocator* pSvcLo
 }
 
 
-GepClusteringAlg::~GepClusteringAlg() {}
-
-
 StatusCode GepClusteringAlg::initialize() {
   ATH_MSG_INFO ("Initializing " << name() << "...");
   //
@@ -64,14 +60,7 @@ StatusCode GepClusteringAlg::initialize() {
   return StatusCode::SUCCESS;
 }
 
-StatusCode GepClusteringAlg::finalize() {
-  ATH_MSG_INFO ("Finalizing " << name() << "...");
-  //
-  //Things that happen once at the end of the event loop go here
-  //
 
-return StatusCode::SUCCESS;
-}
 
 StatusCode GepClusteringAlg::execute() {  
   ATH_MSG_DEBUG ("Executing " << name() << "...");
@@ -82,14 +71,14 @@ StatusCode GepClusteringAlg::execute() {
     return StatusCode::FAILURE;
   }
   else {
-    ATH_MSG_INFO("Noise tool retrieved");
+    ATH_MSG_DEBUG("Noise tool retrieved");
   }
 
 
 
   const xAOD::EventInfo* ei = 0;
   CHECK( evtStore()->retrieve( ei , "EventInfo" ) );
-  ATH_MSG_INFO("eventNumber=" << ei->eventNumber() );
+  ATH_MSG_DEBUG("eventNumber=" << ei->eventNumber() );
 
 
   //
@@ -109,7 +98,7 @@ StatusCode GepClusteringAlg::execute() {
 
   //
   // Run topoclustering algorithm
-  std::unique_ptr<TopoClusterMaker_Base> topoMaker{};
+  std::unique_ptr<Gep::ITopoClusterMaker> topoMaker{};
 
   // *** Instantiate custom topoclustering classes ***
 
@@ -119,11 +108,11 @@ StatusCode GepClusteringAlg::execute() {
     return StatusCode::FAILURE;
   }
 
-  ATH_MSG_INFO( "Running " << topoMaker->getName() << " topoclustering algorithm." );
+  ATH_MSG_DEBUG( "Running " << topoMaker->getName() << " topoclustering algorithm." );
 
-  std::vector<CustomTopoCluster> customClusters = topoMaker->makeTopoCluster( m_cch.getCaloCellsMap() );
+  std::vector<Gep::CustomTopoCluster> customClusters = topoMaker->makeTopoCluster( m_cch.getCaloCellsMap() );
 
-  ATH_MSG_INFO( "Topoclustering completed." );
+  ATH_MSG_DEBUG( "Topoclustering completed." );
 
   
   // create the new container and its auxiliary store.
@@ -139,16 +128,16 @@ StatusCode GepClusteringAlg::execute() {
     xAOD::CaloCluster* iclus = athenaCluster.get();
     athenaTopoClusters->push_back(std::move(athenaCluster));
 
-    iclus->setE(iClust.e);
-    iclus->setEta(iClust.eta);
-    iclus->setPhi(iClust.phi);
+    iclus->setE(iClust.vec.E());
+    iclus->setEta(iClust.vec.Eta());
+    iclus->setPhi(iClust.vec.Phi());
     iclus->setTime(iClust.time);
   }
 
   std::string clustersName = m_topoclAlg + "TopoClusters";
   std::string clustersNameAux = clustersName + "Aux.";
 
-  ATH_MSG_INFO( "Storing " << clustersName );
+  ATH_MSG_DEBUG( "Storing " << clustersName );
   CHECK( evtStore()->record(std::move(athenaTopoClusters),clustersName) ); 
   CHECK( evtStore()->record(std::move(athenaTopoClustersAux),clustersNameAux) );
 

Trigger/TrigL0GepPerf/src/GepJetAlg.cxx

+/*
+ *   Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
+ */
+
+#include "TrigL0GepPerf/GepJetAlg.h"
+
+// Base class
+#include "TrigL0GepPerf/IJetMaker.h"
+
+// *** Include derived jet algorithm classes ***
+
+
+
+#include "xAODEventInfo/EventInfo.h"
+#include "xAODCaloEvent/CaloClusterContainer.h"
+#include "xAODCaloEvent/CaloClusterAuxContainer.h"
+#include "xAODCaloEvent/CaloCluster.h"
+
+#include "xAODTrigger/JetRoI.h"
+#include "xAODTrigger/JetRoIAuxContainer.h"
+#include "xAODJet/JetContainer.h"
+#include "xAODJet/JetAuxContainer.h"
+#include "xAODTrigger/JetRoIContainer.h"
+
+
+
+
+GepJetAlg::GepJetAlg( const std::string& name, ISvcLocator* pSvcLocator ) :
+  AthAnalysisAlgorithm( name, pSvcLocator ),
+  m_jetAlg ("JetAlg"),
+  m_topoclLabel ("TopoclLabel")
+{
+
+  declareProperty("JetAlg", m_jetAlg, "Custom jet algorithm label. New custom jets will be named m_jetAlg + m_topoclLabel +\"Jets\".");
+  declareProperty("TopoclLabel", m_topoclLabel, "Topoclusters label");
+
+}
+
+
+
+StatusCode GepJetAlg::execute() {
+  ATH_MSG_DEBUG ("Executing " << name() << "...");
+
+
+  // get clusters
+  std::string topoclName = m_topoclLabel + "TopoClusters";
+  const xAOD::CaloClusterContainer* clusters = nullptr;
+  CHECK(evtStore()->retrieve(clusters,topoclName));
+
+
+  std::vector<Gep::CustomTopoCluster> customClusters;
+  for( auto iClus: *clusters){
+    Gep::CustomTopoCluster clus;
+    clus.vec.SetPxPyPzE(iClus->p4().Px(), iClus->p4().Py(),
+                          iClus->p4().Pz(), iClus->e());
+    customClusters.push_back(clus);
+  }
+
+
+  // run jet algorithm
+  std::unique_ptr<Gep::IJetMaker> jetMaker{};
+
+
+  // *** instantiate custom jet algorithm classes ***
+
+
+
+  if( !jetMaker ){
+    ATH_MSG_ERROR( "JetMaker is a null pointer." );
+    return StatusCode::FAILURE;
+  }
+  ATH_MSG_DEBUG( "Running " << jetMaker->getName() << " jet algorithm." );
+
+  std::vector<Gep::CustomJet> customJets = jetMaker->makeJet( customClusters );
+
+
+  // create the new container and its auxiliary store
+  auto athenaJets = std::make_unique<xAOD::JetContainer>();
+  auto athenaJetsAux = std::make_unique<xAOD::JetAuxContainer>();
+
+  athenaJets->setStore(athenaJetsAux.get()); //< connect the two
+
+
+  // store custom jets in athena format
+  for(const auto& iJet: customJets){
+
+    std::unique_ptr<xAOD::Jet> athenaJet{new xAOD::Jet()};
+    xAOD::Jet* ijet = athenaJet.get();
+    athenaJets->push_back(std::move(athenaJet));
+
+    xAOD::JetFourMom_t P4;
+    P4.SetPt(iJet.vec.Pt());
+    P4.SetEta(iJet.vec.Eta());
+    P4.SetPhi(iJet.vec.Phi());
+    P4.SetM(iJet.vec.M());
+
+    ijet->setJetP4( P4 );
+
+  }
+
+  std::string jetsName = m_jetAlg + m_topoclLabel + "Jets";
+  std::string jetsNameAux = jetsName + "Aux.";
+
+  ATH_MSG_DEBUG( "Storing " << jetsName );
+  CHECK( evtStore()->record(std::move(athenaJets),jetsName) );
+  CHECK( evtStore()->record(std::move(athenaJetsAux),jetsNameAux) );
+
+
+  return StatusCode::SUCCESS;
+}

Trigger/TrigL0GepPerf/src/components/TrigL0GepPerf_entries.cxx

@@ -5,6 +5,9 @@
 #include "TrigL0GepPerf/GepClusteringAlg.h"
 DECLARE_ALGORITHM_FACTORY( GepClusteringAlg )
 
+#include "TrigL0GepPerf/GepJetAlg.h"
+DECLARE_ALGORITHM_FACTORY( GepJetAlg )
+
 #include "TrigL0GepPerf/MissingETGepCl.h"
 DECLARE_ALGORITHM_FACTORY( MissingETGepCl )
 
@@ -17,6 +20,7 @@ DECLARE_ALGORITHM_FACTORY( MissingETGepPufit )
 DECLARE_FACTORY_ENTRIES( TrigL0GepPerf ) 
 {
   DECLARE_ALGORITHM( GepClusteringAlg );
+  DECLARE_ALGORITHM( GepJetAlg );
   DECLARE_ALGORITHM( ClusterTiming );
   DECLARE_ALGORITHM( MissingETGepPufit );
   DECLARE_ALGORITHM( MissingETGepCl );