Herwig7.cxx

Go to the documentation of this file.

// -*- C++ -*-
/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
 

 
#include "Herwig7_i/Herwig7.h"
 
#include "ThePEG/Repository/EventGenerator.h"
#include "ThePEG/Repository/Repository.h"
#include "ThePEG/Persistency/PersistentIStream.h"
#include "ThePEG/Utilities/DynamicLoader.h"
#include "ThePEG/Utilities/Debug.h"
#include "ThePEG/EventRecord/Event.h"
#include "ThePEG/EventRecord/SubProcess.h"
#include "ThePEG/Handlers/XComb.h"
#include "ThePEG/Handlers/EventHandler.h"
#include "ThePEG/PDF/PartonExtractor.h"
#include "ThePEG/PDF/PDF.h"
 
#include "Herwig/API/HerwigAPI.h"
#include "Herwig/Utilities/HerwigStrategy.h"
 
#include <cstdlib>
#include <fstream>
#include <thread>
#include <chrono>
#include <filesystem>
#include <ranges>
#include <system_error>
 
void   convert_to_HepMC(const ThePEG::Event & m_event, HepMC::GenEvent & evt, bool nocopies,ThePEG::Energy eunit, ThePEG::Length lunit);
 
 
// Constructor
Herwig7::Herwig7(const std::string& name, ISvcLocator* pSvcLocator) :
  GenModule(name, pSvcLocator),
  m_use_seed_from_generatetf(false),
  m_seed_from_generatetf(0),
  m_pdfname_me("UNKNOWN"), m_pdfname_mpi("UNKNOWN") // m_pdfname_ps("UNKONWN"),
{
  declareProperty("RunFile", m_runfile="Herwig7");
  declareProperty("RunSettings", m_runSettings="");
  declareProperty("Repository", m_repository="");
  declareProperty("SetupFile", m_setupfile="");
 
  declareProperty("UseRandomSeedFromGeneratetf", m_use_seed_from_generatetf);
  declareProperty("RandomSeedFromGeneratetf", m_seed_from_generatetf);
 
  declareProperty("PDFNameME", m_pdfname_me);
  // declareProperty("PDFNamePS", m_pdfname_ps);
  declareProperty("PDFNameMPI", m_pdfname_mpi);
 
  declareProperty("CrossSectionScaleFactor", m_xsscale=1.0);
 
  declareProperty("CleanupHerwigScratch", m_cleanup_herwig_scratch);
 
  declareProperty("Dsid", m_dsid);
}

StatusCode Herwig7::genInitialize() {
  ATH_MSG_INFO("Herwig7 initialising...");
 
  ATH_CHECK(m_evtInfoKey.initialize());
 
  // Get random number seeds from Atlas RNG service, and pass them as Hw7 RNG
  // default seeds (they can be overridden with an explicit Hw7 set command in the JO)
  CLHEP::HepRandomEngine* engine = this->getRandomEngineDuringInitialize("Herwig7", m_randomSeed); // conditionsRun=1, lbn=1
  const long* seeds = engine->getSeeds();
  // The RNG service supplies two seeds, but Hw7 only uses one. To avoid the situation
  // where varying one seed has no effect (this already stung us in pre-production
  // job transform tests), we multiply the two seeds and let them wrap around the long
  // type MAX_SIZE:
  int32_t combined_seed = std::abs(seeds[0] * seeds[1]);
  // Represent the combined seed as a string, so the config system can parse it back to a long ;)
  std::ostringstream ss_seed;
  ss_seed << combined_seed;
  // Configure the API and print the seed to the log
  if (m_use_seed_from_generatetf){
    ATH_MSG_INFO("Using the random number seed " + std::to_string(m_seed_from_generatetf) + " provided via Generate_tf.py");
    m_api.seed(m_seed_from_generatetf);
  } else {
    ATH_MSG_INFO("Using the random number seed " + ss_seed.str() + " provided by athena");
    m_api.seed(combined_seed);
  }
 
  // Change repo log level and make sure that config errors result in a program exit
  //ThePEG::Debug::level = 10000;
  ThePEG::Repository::exitOnError() = 1;
 
  // Use everything from $DATAPATH and $LD_LIBRARY_PATH:
  const char* datapath = getenv( "DATAPATH" );
  std::vector<std::string> datapaths;
  if (datapath) {
      std::string datapath_str(datapath);
      for (auto part : std::views::split(datapath_str, ':')) {
          datapaths.emplace_back(part.begin(), part.end());
      }
  }
  for( const std::string& p : datapaths ) {
    ThePEG::Repository::appendReadDir( p );
  }
  const char* ldpath = getenv( "LD_LIBRARY_PATH" );
  std::vector<std::string> ldpaths;
  if (ldpath) {
      std::string ldpath_str(ldpath);
      for (auto part : ldpath_str | std::views::split(':')) {
          ldpaths.emplace_back(std::string(part.begin(), part.end()));
      }
  }
  for( const std::string& p : ldpaths ) {
    ThePEG::DynamicLoader::appendPath( p );
  }
 
  ATH_MSG_DEBUG("Num of library search paths = " << ThePEG::DynamicLoader::allPaths().size());
 
  if (!m_runSettings.empty()) {
    const std::filesystem::path repository_path(m_repository);
    std::error_code repository_error;
    if (repository_path.empty() ||
        !std::filesystem::is_regular_file(repository_path, repository_error)) {
      ATH_MSG_ERROR("Configured Herwig repository does not exist: '" <<
                    repository_path.string() << "'");
      return StatusCode::FAILURE;
    }
 
    ATH_MSG_DEBUG("Using Herwig default repo from " << repository_path);
    m_api.repository(repository_path.string());
    ATH_CHECK(writeRunFileFromText(repository_path.parent_path().string()));
  }
 
  ATH_MSG_INFO("Setting runfile name '"+m_runfile+"'");
  m_api.inputfile(m_runfile);
 
  ATH_MSG_INFO("starting to prepare the run from runfile '"+m_runfile+"'...");
 
  m_runinfo = std::make_shared<HepMC3::GenRunInfo>();
  struct HepMC3::GenRunInfo::ToolInfo generator={std::string("Herwig7"), Herwig::HerwigStrategy::version, std::string("Used generator")};
  m_runinfo->tools().push_back(std::move(generator));  
  // read in a Herwig runfile and obtain the event generator
  m_gen = Herwig::API::prepareRun(m_api);
  ATH_MSG_DEBUG("preparing the run...");
 
  return StatusCode::SUCCESS;
}
 
 
StatusCode Herwig7::writeRunFileFromText(const std::string& share_path) {
  if (m_runSettings.empty()) {
    return StatusCode::SUCCESS;
  }
 
  std::string inputfile_name = m_runfile;
  const std::string runfile_suffix = ".run";
  const auto suffix_pos = inputfile_name.rfind(runfile_suffix);
  if (suffix_pos != std::string::npos) {
    inputfile_name.replace(suffix_pos, runfile_suffix.size(), ".in");
  } else {
    std::filesystem::path inputfile_path(m_runfile);
    inputfile_path.replace_extension(".in");
    inputfile_name = inputfile_path.string();
  }
 
  ATH_MSG_INFO("Writing CA infile text to '"+inputfile_name+"'");
  std::ofstream infile_stream(inputfile_name);
  infile_stream << m_runSettings;
  infile_stream.close();
  if (!infile_stream) {
    ATH_MSG_ERROR("Failed to write CA infile text to '"+inputfile_name+"'");
    return StatusCode::FAILURE;
  }
 
  if (share_path.empty()) {
    ATH_MSG_ERROR("Could not determine the Herwig share path for CA infile materialisation");
    return StatusCode::FAILURE;
  }
 
  ATH_MSG_INFO("Preparing Herwig runfile from CA infile '"+inputfile_name+"'");
  m_api.prependReadDirectory(share_path);
  m_api.inputfile(inputfile_name);
  Herwig::API::read(m_api);
  ATH_MSG_INFO("Finished materialising runfile '"+m_runfile+"'");
  return StatusCode::SUCCESS;
}
 
 

StatusCode Herwig7::callGenerator() {
  ATH_MSG_DEBUG("Herwig7 generating an event");
  assert(m_gen);
  m_event = m_gen->shoot();
  return StatusCode::SUCCESS;
}
 
 

StatusCode Herwig7::fillEvt(HepMC::GenEvent* evt) {
  // Convert the Herwig event into the HepMC GenEvent
  ATH_MSG_DEBUG("Converting ThePEG::Event to HepMC::GenEvent");
  if (!evt->run_info()) evt->set_run_info(m_runinfo);
  evt->set_units(HepMC3::Units::MEV, HepMC3::Units::MM);
  convert_to_HepMC(*m_event, *evt, false, ThePEG::MeV, ThePEG::millimeter);
  ATH_MSG_DEBUG("Converted ThePEG::Event to HepMC::GenEvent");
 
  // Fill the event number into HepMC event record
  SG::ReadHandle<xAOD::EventInfo> evtInfo(m_evtInfoKey);
  evt->set_event_number(evtInfo->eventNumber());
 
  // Fill event with random seeds from Atlas RNG service
  const EventContext& ctx = Gaudi::Hive::currentContext();
  const long* s = this->getRandomEngine("Herwig7", ctx)->getSeeds();
  std::vector<long> seeds(s, s+2);
  ATH_MSG_DEBUG("Random seeds: " << seeds[0] << ", " << seeds[1]);
  HepMC::set_random_states(evt,seeds);
 
  // Add a unit entry to the event weight vector if it's currently empty
  if (evt->weights().empty()) {
    evt->weights().push_back(m_event->weight());
  }
 
  // Add PDF info manually (for now, until natively supported in the ThePEG converter)
  ATH_MSG_DEBUG("Adding PDF info to HepMC");
  // IDs of the partons going into the primary sub process
  ThePEG::tSubProPtr sub = m_event->primarySubProcess();
  int id1 = sub->incoming().first ->id();
  int id2 = sub->incoming().second->id();
  // Get the event handler
  ThePEG::tcEHPtr eh = ThePEG::dynamic_ptr_cast<ThePEG::tcEHPtr>(m_event->handler());
  // Get the values of x
  double x1 = eh->lastX1();
  double x2 = eh->lastX2();
  // Get the pdfs
  std::pair<ThePEG::PDF,ThePEG::PDF> pdfs;
  pdfs.first  = eh->pdf<ThePEG::PDF>(sub->incoming().first);
  pdfs.second = eh->pdf<ThePEG::PDF>(sub->incoming().second);
  // Get the scale
  ThePEG::Energy2 scale = eh->lastScale();
  double Q = std::sqrt(scale/ThePEG::GeV2);
  // Get the values of the pdfs
  double pdf1 = pdfs.first.xfx(sub->incoming().first ->dataPtr(), scale, x1);
  double pdf2 = pdfs.first.xfx(sub->incoming().second->dataPtr(), scale, x2);
  // Create the PDFinfo object
  HepMC3::GenPdfInfoPtr pdfi = std::make_shared<HepMC3::GenPdfInfo>();
  pdfi->set(id1, id2, x1, x2, Q, pdf1, pdf2);
  evt->set_pdf_info(std::move(pdfi));
  ATH_MSG_DEBUG("Added PDF info to HepMC");
 
//uncomment to list HepMC events
//    std::cout << " print::listing Herwig7 " << std::endl;
//    HepMC3::Print::listing(std::cout, *evt);
 
  return StatusCode::SUCCESS;
}
 
 

StatusCode Herwig7::genFinalize() {
  ATH_MSG_INFO("Herwig7 finalizing.");
  assert(m_gen);
  ATH_MSG_INFO( "MetaData: generator = Herwig7 " << HWVERSION ); 
  ATH_MSG_INFO( std::scientific << std::setprecision(5) << "MetaData: cross-section (nb) = " << m_gen->eventHandler()->integratedXSec()*m_xsscale/ThePEG::nanobarn); 
  // ATH_MSG_INFO( "MetaData: PDF = " << m_pdfname_me << " (ME); " << m_pdfname_ps << " (shower); " << m_pdfname_mpi << " (MPI)" ); 
  ATH_MSG_INFO("MetaData: PDF = " << m_pdfname_me << " (ME); " << m_pdfname_mpi << " (shower/MPI)");
  m_gen->finalize();
  ThePEG::Repository::cleanup();
 
  // possibly tidy up working directory
  if (m_cleanup_herwig_scratch && (std::filesystem::is_directory("Herwig-scratch") || std::filesystem::is_directory("Herwig-cache"))){
 
    ATH_MSG_INFO("removing Herwig-scratch/Herwig-cache folder from "+std::filesystem::current_path().string());
 
    // sleep for some time to allow all access to terminate
    std::this_thread::sleep_for(std::chrono::seconds(5)); 
 
    // in case the folder can't be deleted continue with warning
    try {
      (std::filesystem::remove_all("Herwig-scratch") || std::filesystem::remove_all("Herwig-cache"));
    } 
    catch (const std::exception& e) {
      ATH_MSG_WARNING("Failed to delete the folder 'Herwig-scratch': "+std::string(e.what()));
    }
 
  }
 
  return StatusCode::SUCCESS;
}