fix: use thread-local fastjet AreaDefinition to avoid contention (#2451)

### Briefly, what does this PR introduce?
This PR fixes the ghosts in the jet machine. It was a bit surprising to
see fastjet take up this much time in the janatop listing, but it starts
to make sense when you read the headers. Also, @veprbl correctly
identified that ghosts were the cause. By default, fastjet runs with a
single static and locked random generator. The
[header](https://gitlab.com/fastjet/fastjet/-/blob/master/include/fastjet/GhostedAreaSpec.hh?ref_type=heads)
has some guildelines about how to specify a fixed seed for each event
and run with a thread-local area definition. This implements that
approach.

Note: due to the changing seeds, this will change the jet collections,
but they should still be statistically consistent, and they should be
identical between ST and MT running.

### What kind of change does this PR introduce?
- [x] Bug fix (issue: too much time spent in jet reconstruction, even
accounting for combinatorics)
- [ ] New feature (issue #__)
- [ ] Documentation update
- [ ] Other: __

### Please check if this PR fulfills the following:
- [ ] Tests for the changes have been added
- [ ] Documentation has been added / updated
- [ ] Changes have been communicated to collaborators

### Does this PR introduce breaking changes? What changes might users
need to make to their code?
No.

### Does this PR change default behavior?
Yes, jet collections will be different but statistically consistent.

---------

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

Author: wdconinc

src/algorithms/reco/JetReconstruction.cc

@@ -103,8 +103,8 @@ void JetReconstruction<InputT>::process(
     const typename JetReconstructionAlgorithm<InputT>::Input& input,
     const typename JetReconstructionAlgorithm<InputT>::Output& output) const {
   // Grab input collections
-  const auto [input_collection] = input;
-  auto [jet_collection]         = output;
+  const auto [headers, input_collection] = input;
+  auto [jet_collection]                  = output;
 
   // extract input momenta and collect into pseudojets
   std::vector<PseudoJet> particles;
@@ -130,9 +130,16 @@ void JetReconstruction<InputT>::process(
   }
   this->trace("  Number of particles: {}", particles.size());
 
+  // Create per-event AreaDefinition with reproducible seed
+  // This avoids contention on fastjet's static random generator
+  auto seed                    = m_uid.getUniqueID(*headers, this->name());
+  std::vector<int> seed_vector = {static_cast<int>(seed & 0xFFFFFFFF),
+                                  static_cast<int>((seed >> 32) & 0xFFFFFFFF)};
+  auto local_area_def          = m_area_def->with_fixed_seed(seed_vector);
+
   // Run the clustering, extract the jets
-  fastjet::ClusterSequenceArea m_clus_seq(particles, *m_jet_def, *m_area_def);
-  std::vector<PseudoJet> jets = sorted_by_pt(m_clus_seq.inclusive_jets(m_cfg.minJetPt));
+  fastjet::ClusterSequenceArea clus_seq(particles, *m_jet_def, local_area_def);
+  std::vector<PseudoJet> jets = sorted_by_pt(clus_seq.inclusive_jets(m_cfg.minJetPt));
 
   // Print out some infos
   this->trace("  Clustering with : {}", m_jet_def->description());

src/algorithms/reco/JetReconstruction.h

@@ -5,6 +5,7 @@
 
 #include <algorithms/algorithm.h>
 #include <edm4eic/ReconstructedParticleCollection.h>
+#include <edm4hep/EventHeaderCollection.h>
 #include <fastjet/AreaDefinition.hh>
 #include <fastjet/JetDefinition.hh>
 #include <map>
@@ -16,13 +17,14 @@
 #include "JetReconstructionConfig.h"
 // for algorithm configuration
 #include "algorithms/interfaces/WithPodConfig.h"
+#include "algorithms/interfaces/UniqueIDGenSvc.h"
 
 namespace eicrecon {
 
 template <typename InputT>
-using JetReconstructionAlgorithm =
-    algorithms::Algorithm<algorithms::Input<typename InputT::collection_type>,
-                          algorithms::Output<edm4eic::ReconstructedParticleCollection>>;
+using JetReconstructionAlgorithm = algorithms::Algorithm<
+    algorithms::Input<edm4hep::EventHeaderCollection, typename InputT::collection_type>,
+    algorithms::Output<edm4eic::ReconstructedParticleCollection>>;
 
 template <typename InputT>
 class JetReconstruction : public JetReconstructionAlgorithm<InputT>,
@@ -32,7 +34,7 @@ class JetReconstruction : public JetReconstructionAlgorithm<InputT>,
   JetReconstruction(std::string_view name)
       : JetReconstructionAlgorithm<InputT>{
             name,
-            {"inputReconstructedParticles"},
+            {"eventHeaderCollection", "inputReconstructedParticles"},
             {"outputReconstructedParticles"},
             "Performs jet reconstruction using a FastJet algorithm."} {}
 
@@ -86,6 +88,9 @@ class JetReconstruction : public JetReconstructionAlgorithm<InputT>,
     std::string areaType;
   } m_defaultFastjetOpts = {"antikt_algorithm", "E_scheme", "active_area"};
 
+  // unique ID service for generating reproducible seeds
+  const algorithms::UniqueIDGenSvc& m_uid = algorithms::UniqueIDGenSvc::instance();
+
 }; // end JetReconstruction definition
 
 } // namespace eicrecon

src/factories/reco/JetReconstruction_factory.h

@@ -22,7 +22,8 @@ class JetReconstruction_factory
 private:
   std::unique_ptr<Algo> m_algo;
 
-  // input collection
+  // input collections
+  typename FactoryT::template PodioInput<edm4hep::EventHeader> m_event_header_input{this};
   typename FactoryT::template PodioInput<InputT> m_input{this};
 
   // output collection
@@ -59,7 +60,7 @@ class JetReconstruction_factory
   }
 
   void Process(int32_t /* run_number */, uint64_t /* event_number */) {
-    m_algo->process({m_input()}, {m_output().get()});
+    m_algo->process({m_event_header_input(), m_input()}, {m_output().get()});
   }
 
 }; // end JetReconstruction_factory definition

src/global/reco/reco.cc

@@ -142,20 +142,22 @@ void InitPlugin(JApplication* app) {
       app));
 
   app->Add(new JOmniFactoryGeneratorT<JetReconstruction_factory<edm4eic::ReconstructedParticle>>(
-      "GeneratedJets", {"GeneratedParticles"}, {"GeneratedJets"}, {}, app));
+      "GeneratedJets", {"EventHeader", "GeneratedParticles"}, {"GeneratedJets"}, {}, app));
 
   app->Add(new JOmniFactoryGeneratorT<JetReconstruction_factory<edm4eic::ReconstructedParticle>>(
-      "ReconstructedJets", {"ReconstructedParticles"}, {"ReconstructedJets"}, {}, app));
+      "ReconstructedJets", {"EventHeader", "ReconstructedParticles"}, {"ReconstructedJets"}, {},
+      app));
 
   app->Add(new JOmniFactoryGeneratorT<ChargedReconstructedParticleSelector_factory>(
       "GeneratedChargedParticles", {"GeneratedParticles"}, {"GeneratedChargedParticles"}, app));
 
   app->Add(new JOmniFactoryGeneratorT<JetReconstruction_factory<edm4eic::ReconstructedParticle>>(
-      "GeneratedChargedJets", {"GeneratedChargedParticles"}, {"GeneratedChargedJets"}, {}, app));
+      "GeneratedChargedJets", {"EventHeader", "GeneratedChargedParticles"},
+      {"GeneratedChargedJets"}, {}, app));
 
   app->Add(new JOmniFactoryGeneratorT<JetReconstruction_factory<edm4eic::ReconstructedParticle>>(
-      "ReconstructedChargedJets", {"ReconstructedChargedParticles"}, {"ReconstructedChargedJets"},
-      {}, app));
+      "ReconstructedChargedJets", {"EventHeader", "ReconstructedChargedParticles"},
+      {"ReconstructedChargedJets"}, {}, app));
 
   app->Add(new JOmniFactoryGeneratorT<ScatteredElectronsTruth_factory>(
       "ScatteredElectronsTruth",
@@ -247,11 +249,12 @@ void InitPlugin(JApplication* app) {
       {"GeneratedBreitFrameParticles"}, {}, app));
 
   app->Add(new JOmniFactoryGeneratorT<JetReconstruction_factory<edm4eic::ReconstructedParticle>>(
-      "GeneratedCentauroJets", {"GeneratedBreitFrameParticles"}, {"GeneratedCentauroJets"},
+      "GeneratedCentauroJets", {"EventHeader", "GeneratedBreitFrameParticles"},
+      {"GeneratedCentauroJets"},
       {.rJet = 0.8, .jetAlgo = "plugin_algorithm", .jetContribAlgo = "Centauro"}, app));
 
   app->Add(new JOmniFactoryGeneratorT<JetReconstruction_factory<edm4eic::ReconstructedParticle>>(
-      "ReconstructedCentauroJets", {"ReconstructedBreitFrameParticles"},
+      "ReconstructedCentauroJets", {"EventHeader", "ReconstructedBreitFrameParticles"},
       {"ReconstructedCentauroJets"},
       {.rJet = 0.8, .jetAlgo = "plugin_algorithm", .jetContribAlgo = "Centauro"}, app));