Cleaned and improved generator

Header files folders are now directly included in the ROOT_INCLUDE_PATHs via the recipes

Author: jackal1-66

MC/config/examples/herwig/generator_Herwig.C

@@ -1,110 +1,48 @@
-// Set include paths for ThePEG headers
-R__ADD_INCLUDE_PATH($THEPEG_ROOT/include/)
-R__ADD_INCLUDE_PATH($THEPEG_ROOT/../../GSL/latest/include/)
-R__ADD_INCLUDE_PATH($HEPMC3_ROOT/include/)
-R__ADD_INCLUDE_PATH($HERWIG_ROOT/include/)
 #define SKIP_HEPMC_CONVERSION 1
 #define HAVE_HEPMC3 1
-#define ThePEG_DEBUG_LEVEL 1
 
 // O2DPG and ROOT includes
 #include "FairGenerator.h"
 #include "FairPrimaryGenerator.h"
 #include "fairlogger/Logger.h"
-#include "TRandom3.h"
 #include "TParticle.h"
-#include "TParticlePDG.h"
-#include "TDatabasePDG.h"
 #include "TLorentzVector.h"
-#include "TMath.h"
-#include <fstream>
 #include <iostream>
 #include <vector>
 #include <string>
-#include <memory>
-
-// Undefine conflicting macros before including ThePEG headers
-#ifdef B0
-#undef B0
-#endif
-#ifdef B50
-#undef B50
-#endif
-#ifdef B75
-#undef B75
-#endif
-#ifdef B110
-#undef B110
-#endif
-#ifdef B134
-#undef B134
-#endif
-#ifdef B150
-#undef B150
-#endif
-#ifdef B200
-#undef B200
-#endif
-#ifdef B300
-#undef B300
-#endif
-#ifdef B600
-#undef B600
-#endif
-#ifdef B1200
-#undef B1200
-#endif
-#ifdef B1800
-#undef B1800
-#endif
-#ifdef B2400
-#undef B2400
-#endif
-#ifdef B4800
-#undef B4800
-#endif
-#ifdef B9600
-#undef B9600
-#endif
-#ifdef B19200
-#undef B19200
-#endif
-#ifdef B38400
-#undef B38400
-#endif
-
-// ThePEG and Herwig includes
+
+// ThePEG
 #include "ThePEG/Repository/EventGenerator.h"
 #include "ThePEG/EventRecord/Event.h"
 #include "ThePEG/EventRecord/Particle.h"
 #include "ThePEG/EventRecord/Step.h"
 #include "ThePEG/Config/ThePEG.h"
 #include "ThePEG/PDT/ParticleData.h"
-#include "ThePEG/Vectors/HepMCConverter.h"
 #include "ThePEG/Repository/Repository.h"
-#include "ThePEG/Repository/BaseRepository.h"
-#include "ThePEG/Utilities/DynamicLoader.h"
-#include "ThePEG/Persistency/PersistentIStream.h"
 
-// Herwig specific includes
+// Herwig
 #include "Herwig/API/HerwigAPI.h"
 #include "Herwig/API/HerwigUI.h"
 
-// Subclass of HerwigUI to provide minimal implementation for our use case
+// Subclass of HerwigUI to provide minimal implementation of the abstract class
 class SimpleHerwigUI : public Herwig::HerwigUI
 {
 public:
   SimpleHerwigUI(const std::string &inFile,
-                 Herwig::RunMode::Mode mode = Herwig::RunMode::READ)
+                 Herwig::RunMode::Mode mode = Herwig::RunMode::READ, int seed = 0)
       : m_inFile(inFile), m_mode(mode),
-        m_in(inFile), m_out(std::cout), m_err(std::cerr)
+        m_in(inFile), m_out(std::cout), m_err(std::cerr), mSeed(seed)
   {
     if (!m_in)
-      throw std::runtime_error("Cannot open Herwig input file: " + inFile);
-    Dirs.reserve(5);
+    {
+      LOG(fatal) << "Cannot open Herwig input file: " << inFile;
+      exit(1);
+    }
     std::string hDir = std::getenv("HERWIG_ROOT");
     if (!hDir.empty())
+    {
       Dirs.push_back(hDir + "/share/Herwig");
+    }
   }
 
   Herwig::RunMode::Mode runMode() const override { return m_mode; }
@@ -132,8 +70,8 @@ public:
     return empty;
   }
 
-  long N() const override { return 10; } // number of events
-  int seed() const override { return 1234; }
+  long N() const override { return 1; } // number of events
+  int seed() const override { return mSeed; }
   int jobs() const override { return 1; }
   unsigned int jobSize() const override { return 1; }
   unsigned int maxJobs() const override { return 1; }
@@ -152,6 +90,7 @@ private:
   std::ostream &m_out;
   std::ostream &m_err;
   std::vector<std::string> Dirs;
+  int mSeed = 0;
 };
 
 namespace o2
@@ -161,52 +100,51 @@ namespace eventgen
 
 /// HERWIG7 event generator using ThePEG interface
 /// Author: Marco Giacalone (marco.giacalone@cern.ch)
-/// Based on the O2DPG external generator patterns
+/// Based on the O2DPG external generator configurations
 class GeneratorHerwig : public Generator
 {
 public:
   /// Default constructor
-  GeneratorHerwig(const std::string& configFile = "LHC.in")
+  GeneratorHerwig(const std::string& configFile = "LHC.in", int seed = -1)
     : mConfigFile(configFile)
     , mEventGenerator(nullptr)
   {
-    LOG(info) << "HERWIG7 Generator initialized";
+    LOG(info) << "HERWIG7 Generator construction";
     LOG(info) << "Config file: " << mConfigFile;
     std::string extension = mConfigFile.substr(mConfigFile.find_last_of("."));
     if( extension == ".in" ) {
       mIsInputFile = true;
       LOG(info) << "Using input file for configuration";
-    } else if(std::find(mConfigFile.end()-4, mConfigFile.end(), '.run') != mConfigFile.end()) {
+    } else if(extension == ".run") {
       mIsInputFile = false;
       LOG(info) << "Using run file for configuration";
     } else {
       LOG(fatal) << "No file extension found in config file: " << mConfigFile;
       exit(1);
     }
+    if (seed == -1)
+    {
+      auto &conf = o2::conf::SimConfig::Instance();
+      mSeed = gRandom->Integer(conf.getStartSeed());
+    } else {
+      mSeed = seed;
+    }
+    LOG(info) << "Using seed: " << mSeed << " for HERWIG simulation";
   }
 
   /// Destructor
-  ~GeneratorHerwig(){
-    delete mEventGenerator;
-  };
+  ~GeneratorHerwig() = default;
 
   /// Initialize the generator
   Bool_t Init() override
   {
     LOG(info) << "Initializing HERWIG7 Generator";
-    
-    try {
-      if (mIsInputFile) {
-        // Process .in file
-        return initFromInputFile();
-      } else {
-        // Process .run file directly
-        return initFromRunFile();
-      }
-      
-    } catch (const std::exception& e) {
-      LOG(fatal) << "Exception during HERWIG7 initialization: " << e.what();
-      return kFALSE;
+    if (mIsInputFile) {
+      // Process .in file
+      return initFromInputFile();
+    } else {
+      // Process .run file directly
+      return initFromRunFile();
     }
   }
 
@@ -217,28 +155,23 @@ public:
       LOG(error) << "Event generator not initialized";
       return kFALSE;
     }
-    try {
-      // Clear previous event particles
-      hParticles.clear();
-      
-      // Generate the event
-      ThePEG::EventPtr event = mEventGenerator->shoot();
-      
-      if (!event) {
-        LOG(error) << "Failed to generate event";
-        return kFALSE;
-      }
-      
-      // Convert ThePEG event to TParticle format
-      convertEvent(event);
-      LOG(debug) << "Herwig7 generated " << hParticles.size();
+    // Clear previous event particles
+    hParticles.clear();
 
-      return kTRUE;
-      
-    } catch (const std::exception& e) {
-      LOG(error) << "Exception during event generation: " << e.what();
+    // Generate the event
+    mPEGEvent = mEventGenerator->shoot();
+
+    if (!mPEGEvent)
+    {
+      LOG(error) << "Failed to generate event";
       return kFALSE;
     }
+
+    // Convert ThePEG event to TParticle format
+    convertEvent(mPEGEvent);
+    LOG(debug) << "Herwig7 generated " << hParticles.size() << " particles";
+
+    return kTRUE;
   }
 
   /// Import particles for transport
@@ -259,9 +192,11 @@ public:
 
 private:
   std::string mConfigFile;                           ///< HERWIG config file (.in or .run)
-  Bool_t mIsInputFile = false;                               ///< True for .in files, false for .run files
+  Bool_t mIsInputFile = false;                       ///< True for .in files, false for .run files
   ThePEG::EGPtr mEventGenerator;                     ///< ThePEG event generator
   std::vector<TParticle> hParticles;                 ///< Generated Herwig particles
+  ThePEG::EventPtr mPEGEvent;                        ///< Pointer to Current event
+  int mSeed = 0;                                     ///< Random seed for Herwig
 
   void printHerwigSearchPaths()
   {
@@ -277,61 +212,48 @@ private:
   {
     LOG(info) << "Initializing from .in file: " << mConfigFile;
 
-    try {
-      using namespace ThePEG;
-      SimpleHerwigUI ui(mConfigFile, Herwig::RunMode::READ);
-
-      Herwig::API::read(ui);
-      printHerwigSearchPaths();
-      std::string runFile = mConfigFile;
-      size_t pos = runFile.find_last_of('.');
-      runFile.replace(pos, 4, ".run");
-      mConfigFile = runFile;
-      LOG(info) << "Generated run file: " << runFile;
-      auto res = initFromRunFile();
-      if (!res) {
-        LOG(error) << "Failed to initialize from generated run file";
-        return kFALSE;
-      }  
-      return kTRUE;
-    }
-    catch (const std::exception &e)
-    {
-      std::cerr << "Exception: " << e.what() << std::endl;
+    using namespace ThePEG;
+    SimpleHerwigUI ui(mConfigFile, Herwig::RunMode::READ, mSeed);
+    Herwig::API::read(ui);
+    // For debugging, print the search paths
+    // printHerwigSearchPaths();
+    std::string runFile = mConfigFile;
+    size_t pos = runFile.find_last_of('.');
+    runFile.replace(pos, 4, ".run");
+    mConfigFile = runFile;
+    LOG(info) << "Generated run file: " << runFile;
+    auto res = initFromRunFile();
+    if (!res) {
+      LOG(error) << "Failed to initialize from generated run file";
       return kFALSE;
     }
+    return kTRUE;
   }
 
   /// Initialize from .run file
   Bool_t initFromRunFile()
   {
     LOG(info) << "Initializing from .run file: " << mConfigFile;
 
-    try {
-      using namespace ThePEG;
-
-      if (!std::ifstream(mConfigFile))
-      {
-        LOG(info) << "Run file does not exist: " << mConfigFile;
-        return kFALSE;
-      }
-      SimpleHerwigUI runui(mConfigFile, Herwig::RunMode::RUN);
-      // Prepare the generator
-      mEventGenerator = Herwig::API::prepareRun(runui);
-      if (!mEventGenerator)
-      {
-        std::cerr << "Error: prepareRun() returned null." << std::endl;
-        return kFALSE;
-      }
-
-      mEventGenerator->initialize();
-      std::cout << "Herwig generator initialized successfully." << std::endl;
-      return kTRUE;
+    using namespace ThePEG;
+
+    if (!std::ifstream(mConfigFile))
+    {
+      LOG(info) << "Run file does not exist: " << mConfigFile;
+      return kFALSE;
     }
-    catch (const std::exception &ex) {
-      LOG(error) << "Standard exception: " << ex.what();
+    SimpleHerwigUI runui(mConfigFile, Herwig::RunMode::RUN, mSeed);
+    // Prepare the generator
+    mEventGenerator = Herwig::API::prepareRun(runui);
+    if (!mEventGenerator)
+    {
+      LOG(fatal) << "Error: prepareRun() returned null.";
       return kFALSE;
     }
+
+    mEventGenerator->initialize();
+    LOG(info) << "Herwig generator initialized successfully.";
+    return kTRUE;
   }
 
   /// Convert ThePEG event to TParticle format
@@ -396,10 +318,10 @@ private:
 } // namespace eventgen
 } // namespace o2
 
-/// Factory function to create HERWIG7 generator from .in file
-/// @param inputFile HERWIG input/run file (e.g., "LHC.in"/"LHC.run")
-FairGenerator* generateHerwig7(const std::string& inputFile = "LHC.in")
+/// HERWIG7 generator from .in/.run file. If seed is -1, a random seed is chosen
+/// based on the SimConfig starting seed.
+FairGenerator* generateHerwig7(const std::string& inputFile = "LHC.in", int seed = -1)
 {
-  auto generator = new o2::eventgen::GeneratorHerwig(inputFile);
+  auto generator = new o2::eventgen::GeneratorHerwig(inputFile, seed);
   return generator;
 }