BunchFilling separate class, store it in RunContext

Moved bunch filling used for simulation to new o2::BunchFilling class;
The digitization-flow will save the used BunchFilling in the RunContext, together with the
assumed mu per BC (info may be needed by particular digitizers for QED handling)

Author: shahor02

DataFormats/common/CMakeLists.txt

@@ -4,12 +4,14 @@ O2_SETUP(NAME ${MODULE_NAME})
 
 set(SRCS
   src/InteractionRecord.cxx
+  src/BunchFilling.cxx
 )
 
 Set(HEADERS
   include/${MODULE_NAME}/TimeStamp.h
   include/${MODULE_NAME}/EvIndex.h
   include/${MODULE_NAME}/InteractionRecord.h
+  include/${MODULE_NAME}/BunchFilling.h  
 )
 
 Set(LINKDEF src/CommonDataFormatLinkDef.h)

DataFormats/common/include/CommonDataFormat/BunchFilling.h

@@ -0,0 +1,45 @@
+// Copyright CERN and copyright holders of ALICE O2. This software is
+// distributed under the terms of the GNU General Public License v3 (GPL
+// Version 3), copied verbatim in the file "COPYING".
+//
+// See http://alice-o2.web.cern.ch/license for full licensing information.
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// @brief pattern of filled (interacting) bunches
+
+#ifndef ALICEO2_BUNCHFILLING_H
+#define ALICEO2_BUNCHFILLING_H
+
+#include "CommonConstants/LHCConstants.h"
+#include <bitset>
+
+namespace o2
+{
+class BunchFilling
+{
+ public:
+  int getNBunches() const { return mPattern.count(); }
+  bool testBC(int bcID) const { return mPattern[bcID]; }
+  void setBC(int bcID, bool active = true);
+  void setBCTrain(int nBC, int bcSpacing, int firstBC);
+  void setBCTrains(int nTrains, int trainSpacingInBC, int nBC, int bcSpacing, int firstBC);
+  void print(int bcPerLine = 100) const;
+  const auto& getPattern() const { return mPattern; }
+  // set BC filling a la TPC TDR, 12 50ns trains of 48 BCs
+  // but instead of uniform train spacing we add 96empty BCs after each train
+  void setDefault()
+  {
+    setBCTrains(12, 96, 48, 2, 0);
+  }
+
+ private:
+  std::bitset<o2::constants::lhc::LHCMaxBunches> mPattern;
+
+  ClassDefNV(BunchFilling, 1);
+};
+}
+
+#endif

DataFormats/common/src/BunchFilling.cxx

@@ -0,0 +1,65 @@
+// Copyright CERN and copyright holders of ALICE O2. This software is
+// distributed under the terms of the GNU General Public License v3 (GPL
+// Version 3), copied verbatim in the file "COPYING".
+//
+// See http://alice-o2.web.cern.ch/license for full licensing information.
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include "FairLogger.h"
+#include "CommonDataFormat/BunchFilling.h"
+
+using namespace o2;
+
+//_________________________________________________
+void BunchFilling::setBC(int bcID, bool active)
+{
+  // add interacting BC slot
+  if (bcID >= o2::constants::lhc::LHCMaxBunches) {
+    LOG(FATAL) << "BCid is limited to " << 0 << '-' << o2::constants::lhc::LHCMaxBunches - 1
+               << FairLogger::endl;
+  }
+  mPattern.set(bcID, active);
+}
+
+//_________________________________________________
+void BunchFilling::setBCTrain(int nBC, int bcSpacing, int firstBC)
+{
+  // add interacting BC train with given spacing starting at given place, i.e.
+  // train with 25ns spacing should have bcSpacing = 1
+  for (int i = 0; i < nBC; i++) {
+    setBC(firstBC);
+    firstBC += bcSpacing;
+  }
+}
+
+//_________________________________________________
+void BunchFilling::setBCTrains(int nTrains, int trainSpacingInBC, int nBC, int bcSpacing, int firstBC)
+{
+  // add nTrains trains of interacting BCs with bcSpacing within the train and trainSpacingInBC empty slots
+  // between the trains
+  for (int it = 0; it < nTrains; it++) {
+    setBCTrain(nBC, bcSpacing, firstBC);
+    firstBC += nBC * bcSpacing + trainSpacingInBC;
+  }
+}
+
+//_________________________________________________
+void BunchFilling::print(int bcPerLine) const
+{
+  bool endlOK = false;
+  for (int i = 0; i < o2::constants::lhc::LHCMaxBunches; i++) {
+    printf("%c", mPattern[i] ? '+' : '-');
+    if (((i + 1) % bcPerLine) == 0) {
+      printf("\n");
+      endlOK = true;
+    } else {
+      endlOK = false;
+    }
+  }
+  if (!endlOK) {
+    printf("\n");
+  }
+}

DataFormats/common/src/CommonDataFormatLinkDef.h

@@ -31,5 +31,6 @@
 
 #pragma link C++ class o2::dataformats::EvIndex < int, int > +;
 #pragma link C++ class o2::InteractionRecord + ;
+#pragma link C++ class o2::BunchFilling + ;
 
 #endif

DataFormats/simulation/CMakeLists.txt

@@ -6,6 +6,7 @@ set(SRCS
   src/Stack.cxx
   src/MCTrack.cxx
   src/MCCompLabel.cxx
+  src/RunContext.cxx
 )
 
 Set(HEADERS

DataFormats/simulation/include/SimulationDataFormat/RunContext.h

@@ -15,6 +15,7 @@
 #include <TChain.h>
 #include <TBranch.h>
 #include "CommonDataFormat/InteractionRecord.h"
+#include "CommonDataFormat/BunchFilling.h"
 
 namespace o2
 {
@@ -40,15 +41,6 @@ class RunContext
  public:
   RunContext() : mNofEntries{ 0 }, mMaxPartNumber{ 0 }, mEventRecords(), mEventParts() {}
 
-  // RS Do we needs this?
-  TBranch* getBranch(std::string_view name, int sourceid = 0) const
-  {
-    if (mChains[sourceid]) {
-      return mChains[sourceid]->GetBranch(name.data());
-    }
-    return nullptr;
-  }
-
   int getNCollisions() const { return mNofEntries; }
   void setNCollisions(int n) { mNofEntries = n; }
 
@@ -57,26 +49,33 @@ class RunContext
 
   std::vector<o2::InteractionRecord>& getEventRecords() { return mEventRecords; }
   std::vector<std::vector<o2::steer::EventPart>>& getEventParts() { return mEventParts; }
-  std::vector<TChain*>& getChains() { return mChains; }
 
   const std::vector<o2::InteractionRecord>& getEventRecords() const { return mEventRecords; }
   const std::vector<std::vector<o2::steer::EventPart>>& getEventParts() const { return mEventParts; }
-  const std::vector<TChain*>& getChains() const { return mChains; }
+
+  o2::BunchFilling& getBunchFilling() { return mBCFilling; }
+  const o2::BunchFilling& getBunchFilling() const { return (const o2::BunchFilling&)mBCFilling; }
+
+  void setMuPerBC(float m) { mMuBC = m; }
+  float getMuPerBC() const { return mMuBC; }
 
   void printCollisionSummary() const;
 
  private:
   int mNofEntries = 0;
   int mMaxPartNumber = 0; // max number of parts in any given collision
+  float mMuBC;            // probability of hadronic interaction per bunch
+
   std::vector<o2::InteractionRecord> mEventRecords;
   // for each collision we record the constituents (which shall not exceed mMaxPartNumber)
   std::vector<std::vector<o2::steer::EventPart>> mEventParts;
-  std::vector<TChain*> mChains; //! pointers to input chains
+
+  o2::BunchFilling mBCFilling; // patter of active BCs
 
   // it would also be appropriate to record the filenames
   // that went into the chain
 
-  ClassDefNV(RunContext, 1);
+  ClassDefNV(RunContext, 2);
 };
 }
 }

DataFormats/simulation/src/RunContext.cxx

@@ -0,0 +1,27 @@
+// Copyright CERN and copyright holders of ALICE O2. This software is
+// distributed under the terms of the GNU General Public License v3 (GPL
+// Version 3), copied verbatim in the file "COPYING".
+//
+// See http://alice-o2.web.cern.ch/license for full licensing information.
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include "SimulationDataFormat/RunContext.h"
+#include <iostream>
+
+using namespace o2::steer;
+
+void RunContext::printCollisionSummary() const
+{
+  std::cout << "Summary of RunContext --\n";
+  std::cout << "Number of Collisions " << mEventRecords.size() << "\n";
+  for (int i = 0; i < mEventRecords.size(); ++i) {
+    std::cout << "Collision " << i << " TIME " << mEventRecords[i].timeNS;
+    for (auto& e : mEventParts[i]) {
+      std::cout << " (" << e.sourceID << " , " << e.entryID << ")";
+    }
+    std::cout << "\n";
+  }
+}

Steer/include/Steer/HitProcessingManager.h

@@ -49,7 +49,8 @@ class HitProcessingManager
 
   void setGeometryFile(std::string const& geomfile) { mGeometryFile = geomfile; }
 
-  void setInteractionSampler();
+  o2::steer::InteractionSampler& getInteractionSampler() { return mInteractionSampler; }
+
   void sampleCollisionTimes();
   void sampleCollisionConstituents();
 
@@ -92,6 +93,8 @@ inline void HitProcessingManager::sampleCollisionTimes()
 {
   mRunContext.getEventRecords().resize(mRunContext.getNCollisions());
   mInteractionSampler.generateCollisionTimes(mRunContext.getEventRecords());
+  mRunContext.getBunchFilling() = mInteractionSampler.getBunchFilling();
+  mRunContext.setMuPerBC(mInteractionSampler.getMuPerBC());
 }
 
 inline void HitProcessingManager::sampleCollisionConstituents()
@@ -157,25 +160,6 @@ inline void HitProcessingManager::run()
   }
 }
 
-template <typename HitType, typename Task_t>
-std::function<void(const o2::steer::RunContext&)> defaultRunFunction(Task_t& task, std::string_view brname)
-{
-  //  using HitType = Task_t::InputType;
-  return [&task, brname](const o2::steer::RunContext& c) {
-    HitType* hittype = nullptr;
-    auto br = c.getBranch(brname.data());
-    assert(br);
-    br->SetAddress(&hittype);
-    for (auto entry = 0; entry < c.getNCollisions(); ++entry) {
-      br->GetEntry(entry);
-      task.setData(hittype, &c);
-      task.Exec("");
-    }
-    task.FinishTask();
-    // delete hittype
-  };
-}
-
 inline void HitProcessingManager::registerRunFunction(RunFunct_t&& f) { mRegisteredRunFunctions.emplace_back(f); }
 
 inline void HitProcessingManager::addInputFile(std::string_view simfilename)

Steer/include/Steer/InteractionSampler.h

@@ -16,9 +16,9 @@
 #include <Rtypes.h>
 #include <TMath.h>
 #include <TRandom.h>
-#include <bitset>
 #include <vector>
 #include "CommonDataFormat/InteractionRecord.h"
+#include "CommonDataFormat/BunchFilling.h"
 #include "CommonConstants/LHCConstants.h"
 
 namespace o2
@@ -28,56 +28,47 @@ namespace steer
 class InteractionSampler
 {
  public:
-  static constexpr double Sec2NanoSec = 1.e9;   // s->ns conversion
-
-  using BunchFilling = std::bitset<o2::constants::lhc::LHCMaxBunches>;
+  static constexpr float Sec2NanoSec = 1.e9; // s->ns conversion
 
   o2::InteractionRecord generateCollisionTime();
   void generateCollisionTimes(std::vector<o2::InteractionRecord>& dest);
 
   void init();
 
-  void setInteractionRate(double rateHz) { mIntRate = rateHz; }
-  double getInteractionRate() const { return mIntRate; }
-  void setMuPerBC(double mu) { mMuBC = mu; }
-  double getMuPerBC() const { return mMuBC; }
-  void setBCTimeRMS(double tNS = 0.2) { mBCTimeRMS = tNS; }
-  double getBCTimeRMS() const { return mBCTimeRMS; }
+  void setInteractionRate(float rateHz) { mIntRate = rateHz; }
+  float getInteractionRate() const { return mIntRate; }
+  void setMuPerBC(float mu) { mMuBC = mu; }
+  float getMuPerBC() const { return mMuBC; }
+  void setBCTimeRMS(float tNS = 0.2) { mBCTimeRMS = tNS; }
+  float getBCTimeRMS() const { return mBCTimeRMS; }
   const BunchFilling& getBunchFilling() const { return mBCFilling; }
   BunchFilling& getBunchFilling() { return mBCFilling; }
-  int getNCollidingBC() const { return mBCFilling.count(); }
   int getBCMin() const { return mBCMin; }
   int getBCMax() const { return mBCMax; }
-  bool getBC(int bcID) const { return mBCFilling.test(bcID); }
-  void setBC(int bcID, bool active = true);
-  void setBCTrain(int nBC, int bcSpacing, int firstBC);
-  void setBCTrains(int nTrains, int trainSpacingInBC, int nBC, int bcSpacing, int firstBC);
-  void setDefaultBunchFilling();
 
   void print() const;
-  void printBunchFilling(int bcPerLine = 100) const;
 
  protected:
   int simulateInteractingBC();
   int genPoissonZT();
   void nextCollidingBC();
+  void warnOrbitWrapped() const;
 
   int mIntBCCache = 0;            ///< N interactions left for current BC
   int mBCCurrent = 0;             ///< current BC
-  int mOrbit = 0;                 ///< current orbit
-  int mPeriod = 0;                ///< current period
+  unsigned int mOrbit = 0;        ///< current orbit
   int mBCMin = 0;                 ///< 1st filled BCID
   int mBCMax = -1;                ///< last filled BCID
-  double mIntRate = -1.;          ///< total interaction rate in Hz
-  double mBCTimeRMS = 0.2;        ///< BC time spread in NANOSECONDS
-  double mMuBC = -1.;             ///< interaction probability per BC
-  double mProbNoInteraction = 1.; ///< probability of BC w/o interaction
-  double mMuBCZTRed = 0;          ///< reduced mu for fast zero-truncated Poisson derivation
+  float mIntRate = -1.;           ///< total interaction rate in Hz
+  float mBCTimeRMS = 0.2;         ///< BC time spread in NANOSECONDS
+  float mMuBC = -1.;              ///< interaction probability per BC
+  float mProbNoInteraction = 1.;  ///< probability of BC w/o interaction
+  float mMuBCZTRed = 0;           ///< reduced mu for fast zero-truncated Poisson derivation
 
-  BunchFilling mBCFilling;       ///< patter of active BCs
-  std::vector<double> mTimeInBC; ///< interaction times within single BC
+  o2::BunchFilling mBCFilling;  ///< patter of active BCs
+  std::vector<float> mTimeInBC; ///< interaction times within single BC
 
-  static constexpr double DefIntRate = 50e3; ///< default interaction rate
+  static constexpr float DefIntRate = 50e3; ///< default interaction rate
 
   ClassDefNV(InteractionSampler, 1);
 };
@@ -99,12 +90,12 @@ inline void InteractionSampler::nextCollidingBC()
   do {
     if (++mBCCurrent > mBCMax) { // did we exhaust full orbit?
       mBCCurrent = mBCMin;
-      if (++mOrbit >= o2::constants::lhc::MaxNOrbits) { // did we exhaust full period?
+      if (++mOrbit >= o2::constants::lhc::MaxNOrbits) { // wrap orbit (should not happen in run3)
+        warnOrbitWrapped();
         mOrbit = 0;
-        mPeriod++;
       }
     }
-  } while (!mBCFilling[mBCCurrent]);
+  } while (!mBCFilling.testBC(mBCCurrent));
 }
 
 //_________________________________________________