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 ()(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 ( const edm::ParameterSet & params )

Definition at line 106 of file SherpaHadronizer.cc.

References arguments, Exception, edm::ParameterSet::exists(), spf::SherpackFetcher::Fetch(), edm::ParameterSet::getParameter(), mps_fire::i, isInitialized, maxEventsToPrint, 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
 }

SherpaHadronizer::~SherpaHadronizer ( )

override

Definition at line 204 of file SherpaHadronizer.cc.

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

Member Function Documentation

const char* SherpaHadronizer::classname ( ) const

inline

Definition at line 54 of file SherpaHadronizer.cc.

References doSetRandomEngine(), and findQualityFiles::v.

54 { return "SherpaHadronizer"; }

bool SherpaHadronizer::decay ( )

Definition at line 323 of file SherpaHadronizer.cc.

Referenced by declareSpecialSettings().

323 { return true; }

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

inline

Definition at line 46 of file SherpaHadronizer.cc.

References decay(), generatePartonsAndHadronize(), and statistics().

46 { return true; }

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

Definition at line 228 of file SherpaHadronizer.cc.

Referenced by readSettings().

228 { return false; }

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

overrideprivatevirtual

Reimplemented from gen::BaseHadronizer.

Definition at line 88 of file SherpaHadronizer.cc.

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

Referenced by classname().

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

void SherpaHadronizer::finalizeEvent ( )

Definition at line 327 of file SherpaHadronizer.cc.

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

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

bool SherpaHadronizer::generatePartonsAndHadronize ( )

Definition at line 242 of file SherpaHadronizer.cc.

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

Referenced by declareSpecialSettings().

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

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

overridevirtual

Reimplemented from gen::BaseHadronizer.

Definition at line 357 of file SherpaHadronizer.cc.

References nano_cff::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;
 }

bool SherpaHadronizer::initializeForInternalPartons ( )

Definition at line 211 of file SherpaHadronizer.cc.

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

Referenced by readSettings().

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

bool SherpaHadronizer::readSettings ( int )

inline

Definition at line 43 of file SherpaHadronizer.cc.

References declareStableParticles(), initializeForInternalPartons(), and CosmicGenFilterHelix_cfi::pdgIds.

43 { return true; }

bool SherpaHadronizer::residualDecay ( )

Definition at line 325 of file SherpaHadronizer.cc.

325 { return true; }

void SherpaHadronizer::statistics ( )

Definition at line 230 of file SherpaHadronizer.cc.

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

Referenced by declareSpecialSettings().

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