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< HepMC3::GenEvent >	getGenEvent3 ()

std::unique_ptr< GenEventInfoProduct >	getGenEventInfo ()

std::unique_ptr< GenEventInfoProduct3 >	getGenEventInfo3 ()

GenRunInfoProduct &	getGenRunInfo ()

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

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

unsigned int	getVHepMC ()

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	resetEvent3 (std::unique_ptr< HepMC3::GenEvent > event3)

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

void	resetEventInfo3 (std::unique_ptr< GenEventInfoProduct3 > 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< HepMC3::GenEvent > &	event3 ()

std::unique_ptr< GenEventInfoProduct > &	eventInfo ()

std::unique_ptr< GenEventInfoProduct3 > &	eventInfo3 ()

lhef::LHEEvent *	lheEvent ()

lhef::LHERunInfo *	lheRunInfo ()

GenRunInfoProduct &	runInfo ()

Protected Attributes inherited from gen::BaseHadronizer
unsigned int	ivhepmc = 2

std::string	lheFile_

int	randomIndex_

Detailed Description

Definition at line 40 of file SherpaHadronizer.cc.

Constructor & Destructor Documentation

◆ SherpaHadronizer()

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

Definition at line 111 of file SherpaHadronizer.cc.

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

     : 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
 #ifdef USING__MPI
   MPI::Init();
 #endif
 }

◆ ~SherpaHadronizer()

SherpaHadronizer::~SherpaHadronizer ( )

override

Definition at line 212 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 56 of file SherpaHadronizer.cc.

56 { return "SherpaHadronizer"; }

◆ decay()

bool SherpaHadronizer::decay ( )

Definition at line 328 of file SherpaHadronizer.cc.

328 { return true; }

◆ declareSpecialSettings()

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

inline

Definition at line 48 of file SherpaHadronizer.cc.

48 { return true; }

◆ declareStableParticles()

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

Definition at line 233 of file SherpaHadronizer.cc.

233 { return false; }

◆ doSetRandomEngine()

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

overrideprivatevirtual

Reimplemented from gen::BaseHadronizer.

Definition at line 90 of file SherpaHadronizer.cc.

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

                                                                 {
   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 {
       if (isInitialized and v != nullptr) {
         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);
   }
 }

◆ finalizeEvent()

void SherpaHadronizer::finalizeEvent ( )

Definition at line 332 of file SherpaHadronizer.cc.

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

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

◆ generatePartonsAndHadronize()

bool SherpaHadronizer::generatePartonsAndHadronize ( )

Definition at line 247 of file SherpaHadronizer.cc.

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

                                                    {
   //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;
   }
 }

◆ getGenLumiInfoHeader()

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

overridevirtual

Reimplemented from gen::BaseHadronizer.

Definition at line 362 of file SherpaHadronizer.cc.

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

                                                                               {
   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;
 }

◆ initializeForInternalPartons()

bool SherpaHadronizer::initializeForInternalPartons ( )

Definition at line 219 of file SherpaHadronizer.cc.

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

                                                     {
   //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();
     Generator->InitializeTheRun(argc, argv);
     Generator->InitializeTheEventHandler();
     isInitialized = true;
   }
   return true;
 }

◆ readSettings()

bool SherpaHadronizer::readSettings ( int )

inline

Definition at line 45 of file SherpaHadronizer.cc.

45 { return true; }

◆ residualDecay()

bool SherpaHadronizer::residualDecay ( )

Definition at line 330 of file SherpaHadronizer.cc.

330 { return true; }

◆ statistics()

void SherpaHadronizer::statistics ( )

Definition at line 235 of file SherpaHadronizer.cc.

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

                                   {
   //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));
 }

Member Data Documentation

◆ arguments

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

private

Definition at line 69 of file SherpaHadronizer.cc.

Referenced by initializeForInternalPartons(), and SherpaHadronizer().

◆ Generator

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

private

Definition at line 70 of file SherpaHadronizer.cc.

◆ isInitialized

bool SherpaHadronizer::isInitialized

private

Definition at line 71 of file SherpaHadronizer.cc.

Referenced by doSetRandomEngine(), initializeForInternalPartons(), and SherpaHadronizer().

◆ isRNGinitialized

bool SherpaHadronizer::isRNGinitialized

private

Definition at line 72 of file SherpaHadronizer.cc.

Referenced by doSetRandomEngine().

◆ maxEventsToPrint

unsigned int SherpaHadronizer::maxEventsToPrint

private

Definition at line 68 of file SherpaHadronizer.cc.

Referenced by finalizeEvent(), and SherpaHadronizer().

◆ rearrangeWeights

bool SherpaHadronizer::rearrangeWeights

Definition at line 52 of file SherpaHadronizer.cc.

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

◆ SherpaChecksum

std::string SherpaHadronizer::SherpaChecksum

private

Definition at line 62 of file SherpaHadronizer.cc.

◆ SherpaDefaultWeight

double SherpaHadronizer::SherpaDefaultWeight

private

Definition at line 66 of file SherpaHadronizer.cc.

Referenced by SherpaHadronizer().

◆ SherpaParameterSet

edm::ParameterSet SherpaHadronizer::SherpaParameterSet

private

Definition at line 67 of file SherpaHadronizer.cc.

Referenced by SherpaHadronizer().

◆ SherpaPath

std::string SherpaHadronizer::SherpaPath

private

Definition at line 63 of file SherpaHadronizer.cc.

Referenced by SherpaHadronizer().

◆ SherpaPathPiece

std::string SherpaHadronizer::SherpaPathPiece

private

Definition at line 64 of file SherpaHadronizer.cc.

Referenced by SherpaHadronizer().

◆ SherpaProcess

std::string SherpaHadronizer::SherpaProcess

private

Definition at line 61 of file SherpaHadronizer.cc.

Referenced by SherpaHadronizer().

◆ SherpaResultDir

std::string SherpaHadronizer::SherpaResultDir

private

Definition at line 65 of file SherpaHadronizer.cc.

Referenced by SherpaHadronizer().

◆ variationweightlist

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

private

Definition at line 74 of file SherpaHadronizer.cc.

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

◆ weightlist

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

private

Definition at line 73 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