Merge 1e7eb11 into sapling-pr-archive-ktf

Author: ktf

Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx

@@ -71,7 +71,7 @@ void TrackerTraits::computeLayerTracklets(const int iteration, int iROFslice, in
   const Vertex diamondVert({mTrkParams[iteration].Diamond[0], mTrkParams[iteration].Diamond[1], mTrkParams[iteration].Diamond[2]}, {25.e-6f, 0.f, 0.f, 25.e-6f, 0.f, 36.f}, 1, 1.f);
   gsl::span<const Vertex> diamondSpan(&diamondVert, 1);
   int startROF{mTrkParams[iteration].nROFsPerIterations > 0 ? iROFslice * mTrkParams[iteration].nROFsPerIterations : 0};
-  int endROF{mTrkParams[iteration].nROFsPerIterations > 0 ? (iROFslice + 1) * mTrkParams[iteration].nROFsPerIterations + mTrkParams[iteration].DeltaROF : tf->getNrof()};
+  int endROF{gpu::GPUCommonMath::Min(mTrkParams[iteration].nROFsPerIterations > 0 ? (iROFslice + 1) * mTrkParams[iteration].nROFsPerIterations + mTrkParams[iteration].DeltaROF : tf->getNrof(), tf->getNrof())};
   for (int rof0{startROF}; rof0 < endROF; ++rof0) {
     gsl::span<const Vertex> primaryVertices = mTrkParams[iteration].UseDiamond ? diamondSpan : tf->getPrimaryVertices(rof0);
     const int startVtx{iVertex >= 0 ? iVertex : 0};

Detectors/MUON/MCH/Geometry/CMakeLists.txt

@@ -12,7 +12,7 @@
 add_subdirectory(MisAligner)
 add_subdirectory(Transformer)
 add_subdirectory(Creator)
-if (BUILD_TESTING)
+if (BUILD_TESTING AND GLFW_FOUND)
 add_subdirectory(Test)
 endif()
 

Framework/Core/include/Framework/ASoA.h

@@ -1451,12 +1451,7 @@ using PresliceOptional = PresliceBase<T, true, true>;
 
 namespace o2::soa
 {
-template <typename T>
-class FilteredBase;
-template <typename T>
-class Filtered;
-
-template <typename T>
+template <soa::is_table T>
 class FilteredBase;
 template <typename T>
 class Filtered;
@@ -1728,7 +1723,8 @@ class Table
     using columns_t = typename Parent::columns_t;
     using external_index_columns_t = typename Parent::external_index_columns_t;
     using bindings_pack_t = decltype([]<typename... C>(framework::pack<C...>) -> framework::pack<typename C::binding_t...> {}(external_index_columns_t{}));
-    static constexpr const std::array<TableRef, sizeof...(T)> originals{T::ref...};
+    // static constexpr const std::array<TableRef, sizeof...(T)> originals{T::ref...};
+    static constexpr auto originals = Parent::originals;
     using policy_t = IP;
     using parent_t = Parent;
 
@@ -1741,7 +1737,7 @@ class Table
 
     template <typename P, typename... Os>
     TableIteratorBase& operator=(TableIteratorBase<IP, P, Os...> other)
-      requires(P::ref::signature == Parent::ref::signature)
+      requires(P::ref.desc_hash == Parent::ref.desc_hash)
     {
       static_cast<base_iterator<IP>&>(*this) = static_cast<base_iterator<IP>>(other);
       return *this;
@@ -1762,16 +1758,16 @@ class Table
       return *this;
     }
 
-    template <typename P, typename... Os>
-    TableIteratorBase(TableIteratorBase<IP, P, Os...> const& other)
-      requires(P::ref::signature == Parent::ref::signature)
+    template <typename P, typename O1, typename... Os>
+    TableIteratorBase(TableIteratorBase<IP, P, O1, Os...> const& other)
+      requires(P::ref.desc_hash == Parent::ref.desc_hash)
     {
       *this = other;
     }
 
-    template <typename P, typename... Os>
-    TableIteratorBase(TableIteratorBase<IP, P, Os...>&& other) noexcept
-      requires(P::ref::signature == Parent::ref::signature)
+    template <typename P, typename O1, typename... Os>
+    TableIteratorBase(TableIteratorBase<IP, P, O1, Os...>&& other) noexcept
+      requires(P::ref.desc_hash == Parent::ref.desc_hash)
     {
       *this = other;
     }
@@ -2503,7 +2499,7 @@ consteval auto getIndexTargets()
         for (auto const& i : *mColumnIterator) {                                                         \
           auto pos = mBinding.get<T>()->isInSelectedRows(i);                                             \
           if (pos > 0) {                                                                                 \
-            result.push_back(mBinding.get<T>()->iteratorAt(pos));                                        \
+            result.emplace_back(mBinding.get<T>()->iteratorAt(pos));                                     \
           }                                                                                              \
         }                                                                                                \
         return result;                                                                                   \
@@ -3061,9 +3057,6 @@ consteval auto getIndexTargets()
 
 namespace o2::soa
 {
-// template <typename T>
-// class FilteredBase;
-
 template <typename D, typename... Ts>
 struct JoinFull : Table<o2::aod::Hash<"JOIN"_h>, D, o2::aod::Hash<"JOIN"_h>, Ts...> {
   using base = Table<o2::aod::Hash<"JOIN"_h>, D, o2::aod::Hash<"JOIN"_h>, Ts...>;
@@ -3201,7 +3194,7 @@ constexpr auto concat(Ts const&... t)
   return Concat<Ts...>{t...};
 }
 
-template <typename T>
+template <soa::is_table T>
 class FilteredBase : public T
 {
  public:
@@ -3473,7 +3466,8 @@ class Filtered : public FilteredBase<T>
  public:
   using base_t = T;
   using self_t = Filtered<T>;
-  using table_t = typename FilteredBase<T>::table_t;
+  using table_t = typename T::table_t;
+  using columns_t = typename T::columns_t;
 
   using iterator = T::template iterator_template_o<FilteredIndexPolicy, self_t>;
   using unfiltered_iterator = T::template iterator_template_o<DefaultIndexPolicy, self_t>;
@@ -3633,9 +3627,10 @@ class Filtered<Filtered<T>> : public FilteredBase<typename T::table_t>
   using self_t = Filtered<Filtered<T>>;
   using base_t = T;
   using table_t = typename FilteredBase<typename T::table_t>::table_t;
+  using columns_t = typename T::columns_t;
 
-  using iterator = FilteredBase<typename T::table_t>::iterator;
-  using unfiltered_iterator = FilteredBase<typename T::table_t>::unfiltered_iterator;
+  using iterator = typename T::template iterator_template_o<FilteredIndexPolicy, self_t>;
+  using unfiltered_iterator = typename T::template iterator_template_o<DefaultIndexPolicy, self_t>;
   using const_iterator = iterator;
 
   iterator begin()

Framework/Core/test/test_GroupSlicer.cxx

@@ -10,10 +10,12 @@
 // or submit itself to any jurisdiction.
 
 #include "Framework/ASoA.h"
+#include "Framework/AnalysisDataModel.h"
 #include "Framework/TableBuilder.h"
 #include "Framework/GroupSlicer.h"
 #include "Framework/ArrowTableSlicingCache.h"
 #include <arrow/util/config.h>
+#include <iostream>
 
 #include <catch_amalgamated.hpp>
 
@@ -85,6 +87,13 @@ DECLARE_SOA_COLUMN(Lst, lst, std::vector<double>);
 DECLARE_SOA_TABLE(EventExtra, "AOD", "EVTSXTRA", test::Arr, test::Boo, test::Lst);
 
 } // namespace o2::aod
+TEST_CASE("RelatedByIndex")
+{
+  using Trks = soa::Join<aod::Tracks, aod::TracksExtra>;
+  CHECK(soa::relatedByIndex<aod::Collision, Trks>() == true);
+  CHECK(soa::relatedByIndex<aod::Collision, aod::Tracks>() == true);
+}
+
 TEST_CASE("GroupSlicerOneAssociated")
 {
   TableBuilder builderE;

Generators/include/Generators/GeneratorFromFile.h

@@ -17,12 +17,14 @@
 #include "FairGenerator.h"
 #include "Generators/Generator.h"
 #include "Generators/GeneratorFromO2KineParam.h"
+#include "SimulationDataFormat/MCEventHeader.h"
 #include <TRandom3.h>
-#include <TGrid.h>
+#include <random>
 
 class TBranch;
 class TFile;
 class TParticle;
+class TGrid;
 
 namespace o2
 {
@@ -109,6 +111,52 @@ class GeneratorFromO2Kine : public o2::eventgen::Generator
   ClassDefOverride(GeneratorFromO2Kine, 2);
 };
 
+/// Special generator for event pools.
+/// What do we like to have:
+/// - ability to give a file which contains the list of files to read
+/// - ability to give directly a file to read the event from
+/// - ability to give a pool path and to find the top N list of files closest to myself
+/// - ability to select itself one file from the pool
+class GeneratorFromEventPool : public o2::eventgen::Generator
+{
+ public:
+  constexpr static std::string_view eventpool_filename = "evtpool.root";
+  constexpr static std::string_view alien_protocol_prefix = "alien://";
+
+  GeneratorFromEventPool() = default; // mainly for ROOT IO
+  GeneratorFromEventPool(EventPoolGenConfig const& pars);
+
+  bool Init() override;
+
+  // the o2 Generator interface methods
+  bool generateEvent() override
+  { /* trivial - actual work in importParticles */
+    return mO2KineGenerator->generateEvent();
+  }
+  bool importParticles() override
+  {
+    auto import_good = mO2KineGenerator->importParticles();
+    // transfer the particles (could be avoided)
+    mParticles = mO2KineGenerator->getParticles();
+    return import_good;
+  }
+
+  // determine the collection of available files
+  std::vector<std::string> setupFileUniverse(std::string const& path) const;
+
+  std::vector<std::string> const& getFileUniverse() const { return mPoolFilesAvailable; }
+
+ private:
+  EventPoolGenConfig mConfig;                                                    //! Configuration object
+  std::unique_ptr<o2::eventgen::GeneratorFromO2Kine> mO2KineGenerator = nullptr; //! actual generator doing the work
+  std::vector<std::string> mPoolFilesAvailable;                                  //! container keeping the collection of files in the event pool
+  std::string mFileChosen;                                                       //! the file chosen for the pool
+  // random number generator to determine a concrete file name
+  std::mt19937 mRandomEngine; //!
+
+  ClassDefOverride(GeneratorFromEventPool, 1);
+};
+
 } // end namespace eventgen
 } // end namespace o2
 

Generators/include/Generators/GeneratorFromO2KineParam.h

@@ -49,6 +49,22 @@ struct O2KineGenConfig {
   std::string fileName = ""; // filename to read from - takes precedence over SimConfig if given
 };
 
+struct EventPoolGenConfig {
+  std::string eventPoolPath = ""; // In that order: The path where an event pool can be found ;
+                                  // or .. a local file containing a list of files to use
+                                  // or .. a concrete file path to a kinematics file
+  bool skipNonTrackable = true;   // <--- do we need this?
+  bool roundRobin = false;        // read events with period boundary conditions
+  bool randomize = true;          // randomize the order of events
+  unsigned int rngseed = 0;       // randomizer seed, 0 for random value
+  bool randomphi = false;         // randomize phi angle; rotates tracks in events by some phi-angle
+};
+
+// construct a configurable param singleton out of the
+struct GeneratorEventPoolParam : public o2::conf::ConfigurableParamPromoter<GeneratorEventPoolParam, EventPoolGenConfig> {
+  O2ParamDef(GeneratorEventPoolParam, "GeneratorEventPool");
+};
+
 } // end namespace eventgen
 } // end namespace o2
 

Generators/include/Generators/GeneratorHybrid.h

@@ -63,7 +63,7 @@ class GeneratorHybrid : public Generator
  private:
   o2::eventgen::Generator* currentgen = nullptr;
   std::vector<std::unique_ptr<o2::eventgen::Generator>> gens;
-  const std::vector<std::string> generatorNames = {"extkinO2", "boxgen", "external", "hepmc", "pythia8", "pythia8pp", "pythia8hi", "pythia8hf", "pythia8powheg"};
+  const std::vector<std::string> generatorNames = {"extkinO2", "evtpool", "boxgen", "external", "hepmc", "pythia8", "pythia8pp", "pythia8hi", "pythia8hf", "pythia8powheg"};
   std::vector<std::string> mInputGens;
   std::vector<std::string> mGens;
   std::vector<std::string> mConfigs;
@@ -73,12 +73,14 @@ class GeneratorHybrid : public Generator
   std::vector<std::unique_ptr<o2::eventgen::BoxGenConfig>> mBoxGenConfigs;
   std::vector<std::unique_ptr<o2::eventgen::Pythia8GenConfig>> mPythia8GenConfigs;
   std::vector<std::unique_ptr<o2::eventgen::O2KineGenConfig>> mO2KineGenConfigs;
+  std::vector<o2::eventgen::EventPoolGenConfig> mEventPoolConfigs;
   std::vector<std::unique_ptr<o2::eventgen::ExternalGenConfig>> mExternalGenConfigs;
   std::vector<std::unique_ptr<o2::eventgen::FileOrCmdGenConfig>> mFileOrCmdGenConfigs;
   std::vector<std::unique_ptr<o2::eventgen::HepMCGenConfig>> mHepMCGenConfigs;
 
   bool mRandomize = false;
   std::vector<int> mFractions;
+  std::vector<float> mRngFractions;
   int mseqCounter = 0;
   int mCurrentFraction = 0;
   int mIndex = 0;

Generators/src/GeneratorFactory.cxx

@@ -175,6 +175,13 @@ void GeneratorFactory::setPrimaryGenerator(o2::conf::SimConfig const& conf, Fair
       }
     }
     LOG(info) << "using external O2 kinematics";
+  } else if (genconfig.compare("evtpool") == 0) {
+    // case of an "event-pool" which is a specialization of extkinO2
+    // with some additional logic in file management and less configurability
+    // and not features such as "continue transport"
+    auto extGen = new o2::eventgen::GeneratorFromEventPool(o2::eventgen::GeneratorEventPoolParam::Instance().detach());
+    primGen->AddGenerator(extGen);
+    LOG(info) << "using the eventpool generator";
   } else if (genconfig.compare("tparticle") == 0) {
     // External ROOT file(s) with tree of TParticle in clones array,
     // or external program generating such a file