Revert "Implemented rate and collision system dependence (default)"

This reverts commit 32c0f31.

Author: sawenzel

Generators/include/Generators/TPCLoopersParam.h

@@ -35,15 +35,11 @@ struct GenTPCLoopersParam : public o2::conf::ConfigurableParamHelper<GenTPCLoope
   std::string gauss = "${O2_ROOT}/share/Generators/egconfig/gaussian_params.csv"; // file with Gaussian parameters
   std::string scaler_pair = "${O2_ROOT}/share/Generators/egconfig/ScalerPairParams.json"; // file with scaler parameters for e+e- pair production
   std::string scaler_compton = "${O2_ROOT}/share/Generators/egconfig/ScalerComptonParams.json"; // file with scaler parameters for Compton scattering
-  std::string nclxrate = "ccdb://Users/m/mgiacalo/ClustersTrackRatio";                          // file with clusters/rate information per orbit
-  std::string colsys = "PbPb";                                                                  // collision system  (PbPb or pp)
-  int intrate = 50000;                                                                          // interaction rate
   bool flat_gas = true; // if true, the gas density is considered flat in the TPC volume
   int nFlatGasLoopers = 500;  // number of loopers to be generated per event in case of flat gas
   float fraction_pairs = 0.08; // fraction of loopers
   float multiplier[2] = {1., 1.}; // multiplier for pairs and compton loopers for Poissonian and Gaussian sampling
   unsigned int fixedNLoopers[2] = {1, 1}; // fixed number of loopers coming from pairs and compton electrons - valid if flat gas is false and both Poisson and Gaussian params files are empty
-  float adjust_flatgas = 0.f; // adjustment for the number of flat gas loopers per orbit (in percentage, e.g. -0.1 = -10%) [-1, inf)]
   O2ParamDef(GenTPCLoopersParam, "GenTPCLoopers");
 };
 

Generators/include/TPCLoopers.h

@@ -17,7 +17,6 @@
 #include <SimulationDataFormat/ParticleStatus.h>
 #include "SimulationDataFormat/MCGenProperties.h"
 #include "TParticle.h"
-#include "TF1.h"
 #include <filesystem>
 
 #ifdef GENERATORS_WITH_TPCLOOPERS
@@ -83,14 +82,10 @@ class GenTPCLoopers
 
         void SetMultiplier(std::array<float, 2> &mult);
 
-        void setFlatGas(Bool_t& flat, const Int_t& number, const Int_t& nloopers_orbit);
+        void setFlatGas(Bool_t &flat, const Int_t &number = -1);
 
         void setFractionPairs(float &fractionPairs);
 
-        void SetRate(const std::string &rateFile, const bool &isPbPb, const int &intRate);
-
-        void SetAdjust(const float &adjust);
-
     private:
         std::unique_ptr<ONNXGenerator> mONNX_pair = nullptr;
         std::unique_ptr<ONNXGenerator> mONNX_compton = nullptr;
@@ -116,7 +111,6 @@ class GenTPCLoopers
         o2::steer::DigitizationContext *mCollisionContext = nullptr;    // Pointer to the digitization context
         std::vector<o2::InteractionTimeRecord> mInteractionTimeRecords; // Interaction time records from collision context
         Bool_t mFlatGas = false;                                        // Flag to indicate if flat gas loopers are used
-        Bool_t mFlatGasOrbit = false;                                   // Flag to indicate if flat gas loopers are per orbit
         Int_t mFlatGasNumber = -1;                                      // Number of flat gas loopers per event
         double mIntTimeRecMean = 1.0;                                   // Average interaction time record used for the reference
         double mTimeLimit = 0.0;                                        // Time limit for the current event

Generators/src/Generator.cxx

@@ -92,7 +92,6 @@ bool Generator::initLoopersGen()
   const auto& loopersParam = o2::eventgen::GenTPCLoopersParam::Instance();
   std::string model_pairs = gSystem->ExpandPathName(loopersParam.model_pairs.c_str());
   std::string model_compton = gSystem->ExpandPathName(loopersParam.model_compton.c_str());
-  std::string nclxrate = gSystem->ExpandPathName(loopersParam.nclxrate.c_str());
   const auto& scaler_pair = gSystem->ExpandPathName(loopersParam.scaler_pair.c_str());
   const auto& scaler_compton = gSystem->ExpandPathName(loopersParam.scaler_compton.c_str());
   const auto& poisson = gSystem->ExpandPathName(loopersParam.poisson.c_str());
@@ -111,10 +110,10 @@ bool Generator::initLoopersGen()
   std::array<float, 2> multiplier = {loopersParam.multiplier[0], loopersParam.multiplier[1]};
   unsigned int nLoopersPairs = loopersParam.fixedNLoopers[0];
   unsigned int nLoopersCompton = loopersParam.fixedNLoopers[1];
-  const std::array<std::string, 3> models = {model_pairs, model_compton, nclxrate};
-  const std::array<std::string, 3> local_names = {"WGANpair.onnx", "WGANcompton.onnx", "nclxrate.root"};
-  const std::array<bool, 3> isAlien = {models[0].starts_with("alien://"), models[1].starts_with("alien://"), models[2].starts_with("alien://")};
-  const std::array<bool, 3> isCCDB = {models[0].starts_with("ccdb://"), models[1].starts_with("ccdb://"), models[2].starts_with("ccdb://")};
+  const std::array<std::string, 2> models = {model_pairs, model_compton};
+  const std::array<std::string, 2> local_names = {"WGANpair.onnx", "WGANcompton.onnx"};
+  const std::array<bool, 2> isAlien = {models[0].starts_with("alien://"), models[1].starts_with("alien://")};
+  const std::array<bool, 2> isCCDB = {models[0].starts_with("ccdb://"), models[1].starts_with("ccdb://")};
   if (std::any_of(isAlien.begin(), isAlien.end(), [](bool v) { return v; })) {
     if (!gGrid) {
       TGrid::Connect("alien://");
@@ -154,25 +153,14 @@ bool Generator::initLoopersGen()
   }
   model_pairs = isAlien[0] || isCCDB[0] ? local_names[0] : model_pairs;
   model_compton = isAlien[1] || isCCDB[1] ? local_names[1] : model_compton;
-  nclxrate = isAlien[2] || isCCDB[2] ? local_names[2] : nclxrate;
   try {
     // Create the TPC loopers generator with the provided parameters
     mLoopersGen = std::make_unique<o2::eventgen::GenTPCLoopers>(model_pairs, model_compton, poisson, gauss, scaler_pair, scaler_compton);
-    auto& colsys = loopersParam.colsys;
-    auto &intrate = loopersParam.intrate;
-    // Configure the generator with flat gas loopers defined per orbit with clusters/track info
+
+    // Configure the generator with flat gas loopers if enabled (default)
     if (flat_gas) {
-      if (colsys != "PbPb" && colsys != "pp") {
-        LOG(fatal) << "Error: collision system must be either 'PbPb' or 'pp'";
-        exit(1);
-      } else {
-        if (intrate <= 0) {
-          LOG(fatal) << "Error: interaction rate must be positive!";
-          exit(1);
-        }
-        mLoopersGen->SetRate(nclxrate, (colsys == "PbPb") ? true : false, intrate);
-        mLoopersGen->SetAdjust(loopersParam.adjust_flatgas);
-      }
+      mLoopersGen->setFlatGas(flat_gas, nFlatGasLoopers);
+      mLoopersGen->setFractionPairs(fraction_pairs);
     } else {
       // Otherwise, Poisson+Gauss sampling or fixed number of loopers will be used
       // Multiplier is applied only with distribution sampling

Generators/src/TPCLoopers.cxx

@@ -197,8 +197,7 @@ Bool_t GenTPCLoopers::generateEvent()
     LOG(debug) << "Current time offset wrt BC: " << mInteractionTimeRecords[mCurrentEvent].getTimeOffsetWrtBC() << " ns";
     mTimeLimit = (mCurrentEvent < mInteractionTimeRecords.size() - 1) ? mInteractionTimeRecords[mCurrentEvent + 1].bc2ns() - mInteractionTimeRecords[mCurrentEvent].bc2ns() : mTimeEnd - mInteractionTimeRecords[mCurrentEvent].bc2ns();
     // With flat gas the number of loopers are adapted based on time interval widths
-    // The denominator is either the LHC orbit (if mFlatGasOrbit is true) or the mean interaction time record interval
-    nLoopers = mFlatGasOrbit ? (mFlatGasNumber * (mTimeLimit / o2::constants::lhc::LHCOrbitNS)) : (mFlatGasNumber * (mTimeLimit / mIntTimeRecMean));
+    nLoopers = mFlatGasNumber * (mTimeLimit / mIntTimeRecMean);
     nLoopersPairs = static_cast<unsigned int>(std::round(nLoopers * mLoopsFractionPairs));
     nLoopersCompton = nLoopers - nLoopersPairs;
     SetNLoopers(nLoopersPairs, nLoopersCompton);
@@ -367,34 +366,22 @@ void GenTPCLoopers::SetMultiplier(std::array<float, 2>& mult)
     }
 }
 
-void GenTPCLoopers::setFlatGas(Bool_t& flat, const Int_t& number = -1, const Int_t& nloopers_orbit = -1)
+void GenTPCLoopers::setFlatGas(Bool_t& flat, const Int_t& number)
 {
   mFlatGas = flat;
   if (mFlatGas) {
-    if (nloopers_orbit > 0) {
-      mFlatGasOrbit = true;
-      mFlatGasNumber = nloopers_orbit;
-      LOG(info) << "Flat gas loopers will be generated using orbit reference.";
+    if (number < 0) {
+      LOG(warn) << "Warning: Number of loopers per event must be non-negative! Switching option off.";
+      mFlatGas = false;
+      mFlatGasNumber = -1;
     } else {
-      mFlatGasOrbit = false;
-      if (number < 0) {
-        LOG(warn) << "Warning: Number of loopers per event must be non-negative! Switching option off.";
-        mFlatGas = false;
-        mFlatGasNumber = -1;
-      } else {
-        mFlatGasNumber = number;
-      }
-    }
-    if (mFlatGas) {
+      mFlatGasNumber = number;
       mContextFile = std::filesystem::exists("collisioncontext.root") ? TFile::Open("collisioncontext.root") : nullptr;
       mCollisionContext = mContextFile ? (o2::steer::DigitizationContext*)mContextFile->Get("DigitizationContext") : nullptr;
       mInteractionTimeRecords = mCollisionContext ? mCollisionContext->getEventRecords() : std::vector<o2::InteractionTimeRecord>{};
       if (mInteractionTimeRecords.empty()) {
         LOG(error) << "Error: No interaction time records found in the collision context!";
         exit(1);
-      } else {
-        LOG(info) << "Interaction Time records has " << mInteractionTimeRecords.size() << " entries.";
-        mCollisionContext->printCollisionSummary();
       }
       for (int c = 0; c < mInteractionTimeRecords.size() - 1; c++) {
         mIntTimeRecMean += mInteractionTimeRecords[c + 1].bc2ns() - mInteractionTimeRecords[c].bc2ns();
@@ -410,7 +397,7 @@ void GenTPCLoopers::setFlatGas(Bool_t& flat, const Int_t& number = -1, const Int
   } else {
     mFlatGasNumber = -1;
   }
-  LOG(info) << "Flat gas loopers: " << (mFlatGas ? "ON" : "OFF") << ", Reference loopers number per " << (mFlatGasOrbit ? "orbit " : "event ") << mFlatGasNumber;
+  LOG(info) << "Flat gas loopers: " << (mFlatGas ? "ON" : "OFF") << ", Reference loopers number per event: " << mFlatGasNumber;
 }
 
 void GenTPCLoopers::setFractionPairs(float& fractionPairs)
@@ -423,40 +410,5 @@ void GenTPCLoopers::setFractionPairs(float& fractionPairs)
   LOG(info) << "Pairs fraction set to: " << mLoopsFractionPairs;
 }
 
-void GenTPCLoopers::SetRate(const std::string &rateFile, const bool &isPbPb = true, const int &intRate = 50000)
-{
-  // Checking if the rate file exists and is not empty
-  TFile rate_file(rateFile.c_str(), "READ");
-  if (!rate_file.IsOpen() || rate_file.IsZombie()) {
-    LOG(fatal) << "Error: Rate file is empty or does not exist!";
-    exit(1);
-  }
-  const char* fitName = isPbPb ? "fitPbPb" : "fitpp";
-  auto fit = (TF1*)rate_file.Get(fitName);
-  if (!fit) {
-    LOG(fatal) << "Error: Could not find fit function '" << fitName << "' in rate file!";
-    exit(1);
-  }
-  auto ref = static_cast<int>(std::floor(fit->Eval(intRate / 1000.))); // fit expects rate in kHz
-  rate_file.Close();
-  if (ref <= 0) {
-    LOG(fatal) << "Computed flat gas number reference per orbit is <=0";
-    exit(1);
-  } else {
-    LOG(info) << "Set flat gas number to " << ref << " loopers per orbit using " << fitName << " from " << intRate << " Hz interaction rate.";
-    auto flat = true;
-    setFlatGas(flat, -1, ref);
-  }
-}
-
-void GenTPCLoopers::SetAdjust(const float& adjust = 0.f)
-{
-  if (mFlatGas && mFlatGasOrbit && adjust >= -1.f && adjust != 0.f) {
-    LOG(info) << "Adjusting flat gas number per orbit by " << adjust * 100.f << "%";
-    mFlatGasNumber = static_cast<int>(std::round(mFlatGasNumber * (1.f + adjust)));
-    LOG(info) << "New flat gas number per orbit: " << mFlatGasNumber;
-  }
-}
-
 } // namespace eventgen
 } // namespace o2