Inheritance diagram for SherpaHadronizer:

Public Member Functions
const char *	classname () const

bool	decay ()

bool	declareSpecialSettings (const std::vector< std::string > &)

bool	declareStableParticles (const std::vector< int > &pdgIds)

void	finalizeEvent ()

bool	generatePartonsAndHadronize ()

std::unique_ptr< GenLumiInfoHeader >	getGenLumiInfoHeader () const override

bool	initializeForInternalPartons ()

bool	readSettings (int)

bool	residualDecay ()

	SherpaHadronizer (const edm::ParameterSet &params)

void	statistics ()

	~SherpaHadronizer () override

Public Member Functions inherited from gen::BaseHadronizer
	BaseHadronizer (edm::ParameterSet const &ps)

void	cleanLHE ()

void	generateLHE (edm::LuminosityBlock const &lumi, CLHEP::HepRandomEngine *rengine, unsigned int ncpu)

edm::Event &	getEDMEvent () const

std::unique_ptr< HepMC::GenEvent >	getGenEvent ()

std::unique_ptr< GenEventInfoProduct >	getGenEventInfo ()

GenRunInfoProduct &	getGenRunInfo ()

std::unique_ptr< lhef::LHEEvent >	getLHEEvent ()

const std::shared_ptr< lhef::LHERunInfo > &	getLHERunInfo () const

const std::string &	gridpackPath () const

int	randomIndex () const

const std::string &	randomInitConfigDescription () const

void	randomizeIndex (edm::LuminosityBlock const &lumi, CLHEP::HepRandomEngine *rengine)

void	resetEvent (std::unique_ptr< HepMC::GenEvent > event)

void	resetEventInfo (std::unique_ptr< GenEventInfoProduct > eventInfo)

virtual bool	select (HepMC::GenEvent *) const

void	setEDMEvent (edm::Event &event)

void	setLHEEvent (std::unique_ptr< lhef::LHEEvent > event)

void	setLHERunInfo (std::unique_ptr< lhef::LHERunInfo > runInfo)

void	setRandomEngine (CLHEP::HepRandomEngine *v)

std::vector< std::string > const &	sharedResources () const

virtual	~BaseHadronizer () noexcept(false)

Public Attributes
bool	rearrangeWeights

Private Member Functions
void	doSetRandomEngine (CLHEP::HepRandomEngine *v) override

Private Attributes
std::vector< std::string >	arguments

SHERPA::Sherpa *	Generator = new SHERPA::Sherpa()

bool	isInitialized

bool	isRNGinitialized

unsigned int	maxEventsToPrint

std::string	SherpaChecksum

double	SherpaDefaultWeight

edm::ParameterSet	SherpaParameterSet

std::string	SherpaPath

std::string	SherpaPathPiece

std::string	SherpaProcess

std::string	SherpaResultDir

std::vector< std::string >	variationweightlist

std::vector< std::string >	weightlist

Additional Inherited Members
Protected Member Functions inherited from gen::BaseHadronizer
std::unique_ptr< HepMC::GenEvent > &	event ()

std::unique_ptr< GenEventInfoProduct > &	eventInfo ()

lhef::LHEEvent *	lheEvent ()

lhef::LHERunInfo *	lheRunInfo ()

GenRunInfoProduct &	runInfo ()

Protected Attributes inherited from gen::BaseHadronizer
std::string	lheFile_

int	randomIndex_

Detailed Description

Definition at line 38 of file SherpaHadronizer.cc.

Constructor & Destructor Documentation

◆ SherpaHadronizer()

SherpaHadronizer::SherpaHadronizer ( const edm::ParameterSet & params )

Definition at line 106 of file SherpaHadronizer.cc.

     : BaseHadronizer(params),
       SherpaParameterSet(params.getParameter<edm::ParameterSet>("SherpaParameters")),
       isRNGinitialized(false) {
   if (!params.exists("SherpaProcess"))
     SherpaProcess = "";
   else
     SherpaProcess = params.getParameter<std::string>("SherpaProcess");
   if (!params.exists("SherpaPath"))
     SherpaPath = "";
   else
     SherpaPath = params.getParameter<std::string>("SherpaPath");
   if (!params.exists("SherpaPathPiece"))
     SherpaPathPiece = "";
   else
     SherpaPathPiece = params.getParameter<std::string>("SherpaPathPiece");
   if (!params.exists("SherpaResultDir"))
     SherpaResultDir = "Result";
   else
     SherpaResultDir = params.getParameter<std::string>("SherpaResultDir");
   if (!params.exists("SherpaDefaultWeight"))
     SherpaDefaultWeight = 1.;
   else
     SherpaDefaultWeight = params.getParameter<double>("SherpaDefaultWeight");
   if (!params.exists("maxEventsToPrint"))
     maxEventsToPrint = 0;
   else
     maxEventsToPrint = params.getParameter<int>("maxEventsToPrint");
   // if hepmcextendedweights is used the event weights have to be reordered ( unordered list can be accessed via event->weights().write() )
   // two lists have to be provided:
   // 1) SherpaWeights
   // - containing nominal event weight, combined matrix element and phase space weight, event normalization, and possibly other sherpa weights
   // 2) SherpaVariationsWeights
   // - containing weights from scale and PDF variations ( have to be defined in the runcard )
   // - in case of unweighted events these weights are also divided by the event normalization (see list 1 )
   // Sherpa Documentation: http://sherpa.hepforge.org/doc/SHERPA-MC-2.2.0.html#Scale-and-PDF-variations
   if (!params.exists("SherpaWeightsBlock")) {
     rearrangeWeights = false;
   } else {
     rearrangeWeights = true;
     edm::ParameterSet WeightsBlock = params.getParameter<edm::ParameterSet>("SherpaWeightsBlock");
     if (WeightsBlock.exists("SherpaWeights"))
       weightlist = WeightsBlock.getParameter<std::vector<std::string> >("SherpaWeights");
     else
       throw cms::Exception("SherpaInterface") << "SherpaWeights does not exists in SherpaWeightsBlock" << std::endl;
     if (WeightsBlock.exists("SherpaVariationWeights"))
       variationweightlist = WeightsBlock.getParameter<std::vector<std::string> >("SherpaVariationWeights");
     else
       throw cms::Exception("SherpaInterface")
           << "SherpaVariationWeights does not exists in SherpaWeightsBlock" << std::endl;
     edm::LogVerbatim("SherpaHadronizer") << "SherpaHadronizer will try rearrange the event weights according to "
                                             "SherpaWeights and SherpaVariationWeights";
   }
  
   spf::SherpackFetcher Fetcher(params);
   int retval = Fetcher.Fetch();
   if (retval != 0) {
     throw cms::Exception("SherpaInterface") << "SherpaHadronizer: Preparation of Sherpack failed ... ";
   }
   // The ids (names) of parameter sets to be read (Analysis,Run) to create Analysis.dat, Run.dat
   //They are given as a vstring.
   std::vector<std::string> setNames = SherpaParameterSet.getParameter<std::vector<std::string> >("parameterSets");
   //Loop all set names...
   for (unsigned i = 0; i < setNames.size(); ++i) {
     // ...and read the parameters for each set given in vstrings
     std::vector<std::string> pars = SherpaParameterSet.getParameter<std::vector<std::string> >(setNames[i]);
     edm::LogVerbatim("SherpaHadronizer") << "Write Sherpa parameter set " << setNames[i] << " to " << setNames[i]
                                          << ".dat ";
     std::string datfile = SherpaPath + "/" + setNames[i] + ".dat";
     std::ofstream os(datfile.c_str());
     // Loop over all strings and write the according *.dat
     for (std::vector<std::string>::const_iterator itPar = pars.begin(); itPar != pars.end(); ++itPar) {
       os << (*itPar) << std::endl;
     }
   }
  
   //To be conform to the default Sherpa usage create a command line:
   //name of executable  (only for demonstration, could also be empty)
   std::string shRun = "./Sherpa";
   //Path where the Sherpa libraries are stored
   std::string shPath = "PATH=" + SherpaPath;
   // new for Sherpa 1.3.0, suggested by authors
   std::string shPathPiece = "PATH_PIECE=" + SherpaPathPiece;
   //Path where results are stored
   std::string shRes = "RESULT_DIRECTORY=" + SherpaResultDir;  // from Sherpa 1.2.0 on
   //Name of the external random number class
   std::string shRng = "EXTERNAL_RNG=CMS_SHERPA_RNG";
  
   //create the command line
   arguments.push_back(shRun);
   arguments.push_back(shPath);
   arguments.push_back(shPathPiece);
   arguments.push_back(shRes);
   arguments.push_back(shRng);
   isInitialized = false;
   //initialization of Sherpa moved to initializeForInternalPartons
 }

References arguments, Exception, edm::ParameterSet::exists(), spf::SherpackFetcher::Fetch(), edm::ParameterSet::getParameter(), mps_fire::i, isInitialized, maxEventsToPrint, CalibrationSummaryClient_cfi::params, rearrangeWeights, SherpaDefaultWeight, SherpaParameterSet, SherpaPath, SherpaPathPiece, SherpaProcess, SherpaResultDir, AlCaHLTBitMon_QueryRunRegistry::string, variationweightlist, and weightlist.

◆ ~SherpaHadronizer()

SherpaHadronizer::~SherpaHadronizer ( )

override

Definition at line 204 of file SherpaHadronizer.cc.

                                     {
   Generator->~Sherpa();
 #ifdef USING__MPI
   MPI::Finalize();
 #endif
 }

Member Function Documentation

◆ classname()

const char* SherpaHadronizer::classname ( ) const

inline

Definition at line 54 of file SherpaHadronizer.cc.

54 { return "SherpaHadronizer"; }

◆ decay()

bool SherpaHadronizer::decay ( )

Definition at line 323 of file SherpaHadronizer.cc.

323 { return true; }

◆ declareSpecialSettings()

bool SherpaHadronizer::declareSpecialSettings ( const std::vector< std::string > & )

inline

Definition at line 46 of file SherpaHadronizer.cc.

46 { return true; }

◆ declareStableParticles()

bool SherpaHadronizer::declareStableParticles ( const std::vector< int > & pdgIds )

Definition at line 228 of file SherpaHadronizer.cc.

228 { return false; }

◆ doSetRandomEngine()

void SherpaHadronizer::doSetRandomEngine ( CLHEP::HepRandomEngine * v )

overrideprivatevirtual

Reimplemented from gen::BaseHadronizer.

Definition at line 88 of file SherpaHadronizer.cc.

                                                                 {
   CMS_SHERPA_RNG *cmsSherpaRng = dynamic_cast<CMS_SHERPA_RNG *>(ATOOLS::ran->GetExternalRng());
   if (cmsSherpaRng == nullptr) {
     //First time call to this function makes the interface store the reference in the unnamed namespace
     if (!isRNGinitialized) {
       isRNGinitialized = true;
       edm::LogVerbatim("SherpaHadronizer") << "Store assigned reference of the randomEngine";
       SetExternalEngine(v);
       // Throw exception if there is no reference to an external RNG and it is not the first call!
     } else {
       throw edm::Exception(edm::errors::LogicError) << "The Sherpa interface got a randomEngine reference but there is "
                                                        "no reference to the external RNG to hand it over to\n";
     }
   } else {
     cmsSherpaRng->setRandomEngine(v);
   }
 }

References Exception, isRNGinitialized, edm::errors::LogicError, summarizeEdmComparisonLogfiles::ran, CMS_SHERPA_RNG::setRandomEngine(), and findQualityFiles::v.

◆ finalizeEvent()

void SherpaHadronizer::finalizeEvent ( )

Definition at line 327 of file SherpaHadronizer.cc.

                                      {
   //******** Verbosity *******
   if (maxEventsToPrint > 0) {
     maxEventsToPrint--;
     event()->print();
   }
 }

References gen::BaseHadronizer::event(), and maxEventsToPrint.

◆ generatePartonsAndHadronize()

bool SherpaHadronizer::generatePartonsAndHadronize ( )

Definition at line 242 of file SherpaHadronizer.cc.

                                                    {
   //get the next event and check if it produced
   bool rc = false;
   int itry = 0;
   bool gen_event = true;
   while ((itry < 3) && gen_event) {
     try {
       rc = Generator->GenerateOneEvent();
       gen_event = false;
     } catch (...) {
       ++itry;
       std::cerr << "Exception from Generator->GenerateOneEvent() catch. Call # " << itry << " for this event\n";
     }
   }
   if (rc) {
     //convert it to HepMC2
     auto evt = std::make_unique<HepMC::GenEvent>();
     Generator->FillHepMCEvent(*evt);
  
     // in case of unweighted events sherpa puts the max weight as event weight.
     // this is not optimal, we want 1 for unweighted events, so we check
     // whether we are producing unweighted events ("EVENT_GENERATION_MODE" == "1")
     // the information about the weights to the HepMC weight vector:
     // [0] event weight
     // [1] combined matrix element and phase space weight (missing only PDF information, thus directly suitable for PDF reweighting)
     // [2] event weight normalisation (in case of unweighted events event weights of ~ +/-1 can be obtained by (event weight)/(event weight normalisation))
     // [3] number of trials.
     // see also: https://sherpa.hepforge.org/doc/SHERPA-MC-2.1.0.html#Event-output-formats
     bool unweighted = false;
     double weight_normalization = -1;
     if (ATOOLS::ToType<int>(ATOOLS::rpa->gen.Variable("EVENT_GENERATION_MODE")) == 1) {
       if (evt->weights().size() > 2) {
         unweighted = true;
         weight_normalization = evt->weights()[2];
       } else {
         throw cms::Exception("SherpaInterface")
             << "Requested unweighted production. Missing normalization weight." << std::endl;
       }
     }
  
     // vector to fill new weights in correct order
     std::vector<double> newWeights;
     if (rearrangeWeights) {
       for (auto &i : weightlist) {
         if (evt->weights().has_key(i)) {
           newWeights.push_back(evt->weights()[i]);
         } else {
           throw cms::Exception("SherpaInterface")
               << "Missing weights! Key " << i << " not found, please check the weight definition!" << std::endl;
         }
       }
       for (auto &i : variationweightlist) {
         if (evt->weights().has_key(i)) {
           if (unweighted) {
             newWeights.push_back(evt->weights()[i] / weight_normalization);
           } else {
             newWeights.push_back(evt->weights()[i]);
           }
         } else {
           throw cms::Exception("SherpaInterface")
               << "Missing weights! Key " << i << " not found, please check the weight definition!" << std::endl;
         }
       }
  
       //Change original weights for reordered ones
       evt->weights().clear();
       for (auto &elem : newWeights) {
         evt->weights().push_back(elem);
       }
     }
  
     if (unweighted) {
       evt->weights()[0] /= weight_normalization;
     }
     resetEvent(std::move(evt));
     return true;
   } else {
     return false;
   }
 }

References beam_dqm_sourceclient-live_cfg::cerr, Exception, mps_fire::i, eostools::move(), rearrangeWeights, gen::BaseHadronizer::resetEvent(), variationweightlist, and weightlist.

◆ getGenLumiInfoHeader()

std::unique_ptr< GenLumiInfoHeader > SherpaHadronizer::getGenLumiInfoHeader ( ) const

overridevirtual

Reimplemented from gen::BaseHadronizer.

Definition at line 357 of file SherpaHadronizer.cc.

                                                                               {
   auto genLumiInfoHeader = BaseHadronizer::getGenLumiInfoHeader();
  
   if (rearrangeWeights) {
     edm::LogPrint("SherpaHadronizer") << "The order of event weights was changed!";
     for (auto &i : weightlist) {
       genLumiInfoHeader->weightNames().push_back(i);
       edm::LogVerbatim("SherpaHadronizer") << i;
     }
     for (auto &i : variationweightlist) {
       genLumiInfoHeader->weightNames().push_back(i);
       edm::LogVerbatim("SherpaHadronizer") << i;
     }
   }
   return genLumiInfoHeader;
 }

References nano_cff::genLumiInfoHeader, mps_fire::i, rearrangeWeights, variationweightlist, and weightlist.

◆ initializeForInternalPartons()

bool SherpaHadronizer::initializeForInternalPartons ( )

Definition at line 211 of file SherpaHadronizer.cc.

                                                     {
   //initialize Sherpa but only once
   if (!isInitialized) {
     int argc = arguments.size();
     char *argv[argc];
     for (int l = 0; l < argc; l++)
       argv[l] = (char *)arguments[l].c_str();
 #ifdef USING__MPI
     MPI::Init();
 #endif
     Generator->InitializeTheRun(argc, argv);
     Generator->InitializeTheEventHandler();
     isInitialized = true;
   }
   return true;
 }

References dir2webdir::argc, arguments, cmsBatch::argv, isInitialized, and cmsLHEtoEOSManager::l.

◆ readSettings()

bool SherpaHadronizer::readSettings ( int )

inline

Definition at line 43 of file SherpaHadronizer.cc.

43 { return true; }

◆ residualDecay()

bool SherpaHadronizer::residualDecay ( )

Definition at line 325 of file SherpaHadronizer.cc.

325 { return true; }

◆ statistics()

void SherpaHadronizer::statistics ( )

Definition at line 230 of file SherpaHadronizer.cc.

                                   {
   //calculate statistics
   Generator->SummarizeRun();
  
   //get the xsec & err
   double xsec_val = Generator->TotalXS();
   double xsec_err = Generator->TotalErr();
  
   //set the internal cross section in pb in GenRunInfoProduct
   runInfo().setInternalXSec(GenRunInfoProduct::XSec(xsec_val, xsec_err));
 }

References gen::BaseHadronizer::runInfo(), and GenRunInfoProduct::setInternalXSec().

Member Data Documentation

◆ arguments

std::vector<std::string> SherpaHadronizer::arguments

private

Definition at line 67 of file SherpaHadronizer.cc.

Referenced by initializeForInternalPartons(), and SherpaHadronizer().

◆ Generator

SHERPA::Sherpa* SherpaHadronizer::Generator = new SHERPA::Sherpa()

private

Definition at line 68 of file SherpaHadronizer.cc.

◆ isInitialized

bool SherpaHadronizer::isInitialized

private

Definition at line 69 of file SherpaHadronizer.cc.

Referenced by initializeForInternalPartons(), and SherpaHadronizer().

◆ isRNGinitialized

bool SherpaHadronizer::isRNGinitialized

private

Definition at line 70 of file SherpaHadronizer.cc.

Referenced by doSetRandomEngine().

◆ maxEventsToPrint

unsigned int SherpaHadronizer::maxEventsToPrint

private

Definition at line 66 of file SherpaHadronizer.cc.

Referenced by finalizeEvent(), and SherpaHadronizer().

◆ rearrangeWeights

bool SherpaHadronizer::rearrangeWeights

Definition at line 50 of file SherpaHadronizer.cc.

Referenced by generatePartonsAndHadronize(), getGenLumiInfoHeader(), and SherpaHadronizer().

◆ SherpaChecksum

std::string SherpaHadronizer::SherpaChecksum

private

Definition at line 60 of file SherpaHadronizer.cc.

◆ SherpaDefaultWeight

double SherpaHadronizer::SherpaDefaultWeight

private

Definition at line 64 of file SherpaHadronizer.cc.

Referenced by SherpaHadronizer().

◆ SherpaParameterSet

edm::ParameterSet SherpaHadronizer::SherpaParameterSet

private

Definition at line 65 of file SherpaHadronizer.cc.

Referenced by SherpaHadronizer().

◆ SherpaPath

std::string SherpaHadronizer::SherpaPath

private

Definition at line 61 of file SherpaHadronizer.cc.

Referenced by SherpaHadronizer().

◆ SherpaPathPiece

std::string SherpaHadronizer::SherpaPathPiece

private

Definition at line 62 of file SherpaHadronizer.cc.

Referenced by SherpaHadronizer().

◆ SherpaProcess

std::string SherpaHadronizer::SherpaProcess

private

Definition at line 59 of file SherpaHadronizer.cc.

Referenced by SherpaHadronizer().

◆ SherpaResultDir

std::string SherpaHadronizer::SherpaResultDir

private

Definition at line 63 of file SherpaHadronizer.cc.

Referenced by SherpaHadronizer().

◆ variationweightlist

std::vector<std::string> SherpaHadronizer::variationweightlist

private

Definition at line 72 of file SherpaHadronizer.cc.

Referenced by generatePartonsAndHadronize(), getGenLumiInfoHeader(), and SherpaHadronizer().

◆ weightlist

std::vector<std::string> SherpaHadronizer::weightlist

private

Definition at line 71 of file SherpaHadronizer.cc.

Referenced by generatePartonsAndHadronize(), getGenLumiInfoHeader(), and SherpaHadronizer().

Public Member Functions

Public Attributes

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ SherpaHadronizer()

◆ ~SherpaHadronizer()

Member Function Documentation

◆ classname()

◆ decay()

◆ declareSpecialSettings()

◆ declareStableParticles()

◆ doSetRandomEngine()

◆ finalizeEvent()

◆ generatePartonsAndHadronize()

◆ getGenLumiInfoHeader()

◆ initializeForInternalPartons()

◆ readSettings()

◆ residualDecay()

◆ statistics()

Member Data Documentation

◆ arguments

◆ Generator

◆ isInitialized

◆ isRNGinitialized

◆ maxEventsToPrint

◆ rearrangeWeights

◆ SherpaChecksum

◆ SherpaDefaultWeight

◆ SherpaParameterSet

◆ SherpaPath

◆ SherpaPathPiece

◆ SherpaProcess

◆ SherpaResultDir

◆ variationweightlist

◆ weightlist