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 ()

GenLumiInfoHeader *	getGenLumiInfoHeader () const override

bool	initializeForInternalPartons ()

bool	readSettings (int)

bool	residualDecay ()

	SherpaHadronizer (const edm::ParameterSet &params)

void	statistics ()

	~SherpaHadronizer ()

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

void	cleanLHE ()

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

edm::Event &	getEDMEvent () const

HepMC::GenEvent *	getGenEvent ()

GenEventInfoProduct *	getGenEventInfo ()

GenRunInfoProduct &	getGenRunInfo ()

const boost::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 (HepMC::GenEvent *event)

void	resetEventInfo (GenEventInfoProduct *eventInfo)

virtual bool	select (HepMC::GenEvent *) const

void	setEDMEvent (edm::Event &event)

void	setLHEEvent (lhef::LHEEvent *event)

void	setLHERunInfo (lhef::LHERunInfo *runInfo)

void	setRandomEngine (CLHEP::HepRandomEngine *v)

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

	~BaseHadronizer ()

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::auto_ptr< HepMC::GenEvent > &	event ()

std::auto_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 41 of file SherpaHadronizer.cc.

Constructor & Destructor Documentation

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

Definition at line 118 of file SherpaHadronizer.cc.

References arguments, edm::hlt::Exception, edm::ParameterSet::exists(), spf::SherpackFetcher::Fetch(), edm::ParameterSet::getParameter(), 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 ( )

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 57 of file SherpaHadronizer.cc.

57 { return "SherpaHadronizer"; }

bool SherpaHadronizer::decay ( )

Definition at line 334 of file SherpaHadronizer.cc.

 {
    return true;
 }

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

inline

Definition at line 49 of file SherpaHadronizer.cc.

49 { return true; }

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

Definition at line 231 of file SherpaHadronizer.cc.

 {
   return false;
 }

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

overrideprivatevirtual

Reimplemented from gen::BaseHadronizer.

Definition at line 99 of file SherpaHadronizer.cc.

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

                                                                 {
   CMS_SHERPA_RNG* cmsSherpaRng = dynamic_cast<CMS_SHERPA_RNG*>(ATOOLS::ran->GetExternalRng());
   //~ assert(cmsSherpaRng != nullptr);
   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 344 of file SherpaHadronizer.cc.

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

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

bool SherpaHadronizer::generatePartonsAndHadronize ( )

Definition at line 252 of file SherpaHadronizer.cc.

References dtNoiseDBValidation_cfg::cerr, HTMLExport::elem(), edm::hlt::Exception, relval_steps::gen(), i, 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
     HepMC::GenEvent* evt = new 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(evt);
     return true;
   }
   else {
     return false;
   }
 }

GenLumiInfoHeader * SherpaHadronizer::getGenLumiInfoHeader ( ) const

overridevirtual

Reimplemented from gen::BaseHadronizer.

Definition at line 375 of file SherpaHadronizer.cc.

References i, rearrangeWeights, variationweightlist, weightlist, and GenLumiInfoHeader::weightNames().

                                                                 {
   GenLumiInfoHeader *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 213 of file SherpaHadronizer.cc.

References dir2webdir::argc, arguments, getDQMSummary::argv, isInitialized, and prof2calltree::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();
       #ifdef USING__MPI
         MPI::Init();
       #endif
       Generator->InitializeTheRun(argc,argv);
       Generator->InitializeTheEventHandler();
       isInitialized=true;
   }
   return true;
 }

bool SherpaHadronizer::readSettings ( int )

inline

Definition at line 46 of file SherpaHadronizer.cc.

46 { return true; }

bool SherpaHadronizer::residualDecay ( )

Definition at line 339 of file SherpaHadronizer.cc.

 {
    return true;
 }

void SherpaHadronizer::statistics ( )

Definition at line 237 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));
 
 }