First working implementation of json configuration file in hybrid generator

Author: jackal1-66

Generators/include/Generators/GeneratorHybrid.h

@@ -31,6 +31,9 @@
 #include "FairGenerator.h"
 #include <DetectorsBase/Stack.h>
 #include <SimConfig/SimConfig.h>
+#include <rapidjson/document.h>
+#include <rapidjson/error/en.h>
+#include <rapidjson/istreamwrapper.h>
 
 namespace o2
 {
@@ -42,17 +45,20 @@ class GeneratorHybrid : public Generator
 
  public:
   GeneratorHybrid() = default;
-  GeneratorHybrid(const std::vector<std::string>& gens);
+  GeneratorHybrid(const std::string& inputgens);
   ~GeneratorHybrid() = default;
 
   Bool_t Init() override;
   Bool_t generateEvent() override;
   Bool_t importParticles() override;
+  
+  Bool_t parseJSON(const std::string& path);
 
  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"};
+  std::vector<std::string> mInputGens;
   std::vector<std::string> mGens;
   std::vector<std::string> mConfigs;
   std::vector<std::string> mConfsPythia8;

Generators/include/Generators/GeneratorHybridParam.h

@@ -29,10 +29,8 @@ namespace eventgen
  **/
 
 struct GeneratorHybridParam : public o2::conf::ConfigurableParamHelper<GeneratorHybridParam> {
-  std::string generators = ""; // generators to be used in the cocktail, each divided by a comma
-  std::string configs = "";    // configurations for the generators, each divided by a colon 
+  std::string configFile = "";    // JSON configuration file for the generators 
   bool randomize = false;      // randomize the order of the generators, if not generator using fractions
-  std::string fractions = "";  // events fractions for each generator, works only for sequence
   O2ParamDef(GeneratorHybridParam, "GeneratorHybrid");
 };
 

Generators/src/GeneratorFactory.cxx

@@ -245,15 +245,18 @@ void GeneratorFactory::setPrimaryGenerator(o2::conf::SimConfig const& conf, Fair
   } else if (genconfig.compare("hybrid") == 0) { // hybrid using multiple generators
     LOG(info) << "Init hybrid generator";
     auto& hybridparam = GeneratorHybridParam::Instance();
-    std::string genslist = hybridparam.generators;
-    LOG(info) << "Generators list: " << genslist;
-    std::vector<std::string> generators;
-    std::stringstream ss(genslist);
-    std::string item;
-    while (std::getline(ss, item, ',')) {
-      generators.push_back(item);
+    std::string config = hybridparam.configFile;
+    //check if config string points to an existing file and not empty
+    if (config.empty()) {
+      LOG(fatal) << "No configuration file provided for hybrid generator";
+      return;
+    }
+    // check if file named config exists and it's not empty
+    else if (gSystem->AccessPathName(config.c_str())) {
+      LOG(fatal) << "Configuration file for hybrid generator does not exist";
+      return;
     }
-    auto hybrid = new o2::eventgen::GeneratorHybrid(generators);
+    auto hybrid = new o2::eventgen::GeneratorHybrid(config);
     primGen->AddGenerator(hybrid);
   } else {
     LOG(fatal) << "Invalid generator";

Generators/src/GeneratorHybrid.cxx

@@ -12,60 +12,40 @@
 #include "Generators/GeneratorHybrid.h"
 #include <fairlogger/Logger.h>
 #include <algorithm>
-#include <FairPrimaryGenerator.h>
 
 namespace o2
 {
   namespace eventgen
   {
-  GeneratorHybrid::GeneratorHybrid(const std::vector<std::string>& inputgens)
+  GeneratorHybrid::GeneratorHybrid(const std::string& inputgens)
   {
-    auto configs = GeneratorHybridParam::Instance().configs;
-    mRandomize = GeneratorHybridParam::Instance().randomize;
-    std::stringstream ss(configs);
-    std::string conf;
-    while (std::getline(ss, conf, ':')) {
-      mConfigs.push_back(conf);
+    if (!parseJSON(inputgens)) {
+      LOG(fatal) << "Failed to parse JSON configuration from input generators";
+      exit(1);
     }
-    if(mConfigs.size() != inputgens.size()){
+    mRandomize = GeneratorHybridParam::Instance().randomize;
+    if (mConfigs.size() != mInputGens.size()) {
       LOG(fatal) << "Number of configurations does not match the number of generators";
+      exit(1);
     }
-    if(mConfigs.size() == 0){
-      for(auto gen : inputgens){
+    if (mConfigs.size() == 0){
+      for(auto gen : mInputGens){
         mConfigs.push_back("");
       }
     }
     int index = 0;
     if (!mRandomize) {
-      std::string fractions = GeneratorHybridParam::Instance().fractions;
-      if(fractions.compare("") == 0){
-        for (auto gen : inputgens) {
-          mFractions.push_back(1);
-        }
+      if (mFractions.size() != mInputGens.size()) {
+        LOG(fatal) << "Number of fractions does not match the number of generators";
+        return;
+      }
+      // Check if all elements of mFractions are 0
+      if (std::all_of(mFractions.begin(), mFractions.end(), [](int i){ return i == 0; })) {
+        LOG(fatal) << "All fractions provided are 0, no simulation will be performed";
+        return;
       }
-      else{
-        std::stringstream streamfrac(fractions);
-        std::string frac;
-        while (std::getline(streamfrac, frac, ',')) {
-          if(frac.compare("") == 0)
-            mFractions.push_back(1);
-          else
-            mFractions.push_back(std::stoi(frac));
-        }
-        if(mFractions.size() != inputgens.size()){
-          LOG(fatal) << "Number of fractions does not match the number of generators";
-          return;
-        }
-        // Check if all elements of mFractions are 0
-        if (std::all_of(mFractions.begin(), mFractions.end(), [](int i){ return i == 0; })) {
-          LOG(fatal) << "All fractions provided are 0, no simulation will be performed";
-          return;
-        }
-        
-      }  
     }
-    for(auto gen : inputgens)
-    {
+    for (auto gen : mInputGens) {
       // Search if the generator name is inside generatorNames (which is a vector of strings)
       LOG(info) << "Checking if generator " << gen << " is in the list of available generators \n";
       if (std::find(generatorNames.begin(), generatorNames.end(), gen) != generatorNames.end())
@@ -133,7 +113,7 @@ namespace o2
             }
       }
       index++;
-    }  
+    }
   }
 
   Bool_t GeneratorHybrid::Init()
@@ -208,7 +188,68 @@ namespace o2
     }
 
     return true;
-  }     
+  }
+
+  Bool_t GeneratorHybrid::parseJSON(const std::string& path)
+  {
+    // Parse JSON file to build map
+    std::ifstream fileStream(path, std::ios::in);
+    if (!fileStream.is_open()) {
+      LOG(error) << "Cannot open " << path;
+      return false;
+    }
+    rapidjson::IStreamWrapper isw(fileStream);
+    rapidjson::Document doc;
+    doc.ParseStream(isw);
+    if (doc.HasParseError()) {
+      LOG(error) << "Error parsing provided json file " << path;
+      LOG(error) << "  - Error -> " << rapidjson::GetParseError_En(doc.GetParseError());
+      LOG(error) << "  - Offset -> " << doc.GetErrorOffset();
+      return false;
+    }
+
+    // Put the generator names in mInputGens
+    if (doc.HasMember("generators")) {
+      const auto& gens = doc["generators"];
+      for (const auto& gen : gens.GetArray()) {
+        // push in mInputGens the "name" of the generator
+        mInputGens.push_back(gen["name"].GetString());
+        if (gen.HasMember("config")) {
+          //Check if config is an array
+          if (gen["config"].IsArray()) {
+            std::string config = "";
+            for (const auto& conf : gen["config"].GetArray()) {
+              config += conf.GetString();
+              config += ",";
+            }
+            mConfigs.push_back(config);
+          } else {
+            mConfigs.push_back(gen["config"].GetString());
+          }
+        }
+        else {
+          mConfigs.push_back("");
+        }
+      }
+    }
+
+    // Get fractions and put them in mFractions
+    if (doc.HasMember("fractions")) {
+      const auto& fractions = doc["fractions"];
+      for (const auto& frac : fractions.GetArray()) {
+        mFractions.push_back(frac.GetInt());
+      }
+    } 
+    else {
+      // Set fractions to unity for all generators in case they are not provided
+      const auto& gens = doc["generators"];
+      for (const auto& gen : gens.GetArray()) {
+        mFractions.push_back(1);
+      }
+    }
+
+    return true;
+  }
 
   } // namespace eventgen
 } // namespace o2