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

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

virtual GenLumiInfoHeader *	getGenLumiInfoHeader () const

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

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

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

SHERPA::Sherpa	Generator

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

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

Constructor & Destructor Documentation

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

Definition at line 109 of file SherpaHadronizer.cc.

References arguments, gather_cfg::cout, edm::ParameterSet::exists(), edm::ParameterSet::getParameter(), i, isInitialized, maxEventsToPrint, SherpaDefaultWeight, SherpaParameterSet, SherpaPath, SherpaPathPiece, SherpaProcess, SherpaResultDir, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                 :
   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");
 
 
   spf::SherpackFetcher Fetcher(params);
   int retval=Fetcher.Fetch();
   if (retval != 0) {
    std::cout << "SherpaHadronizer: Preparation of Sherpack failed ... " << std::endl;
    std::cout << "SherpaHadronizer: Error code: " << retval << std::endl;
    std::terminate();
 
   }
   // 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]);
     std::cout << "Write Sherpa parameter set " << setNames[i] <<" to "<<setNames[i]<<".dat "<<std::endl;
     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.c_str());
   arguments.push_back(shPath.c_str());
   arguments.push_back(shPathPiece.c_str());
   arguments.push_back(shRes.c_str());
   arguments.push_back(shRng.c_str());
   isInitialized=false;
  //initialization of Sherpa moved to initializeForInternalPartons
 }

SherpaHadronizer::~SherpaHadronizer ( )

Definition at line 174 of file SherpaHadronizer.cc.

175 {

176 }

Member Function Documentation

const char* SherpaHadronizer::classname ( ) const

inline

Definition at line 51 of file SherpaHadronizer.cc.

51 { return "SherpaHadronizer"; }

bool SherpaHadronizer::decay ( )

Definition at line 274 of file SherpaHadronizer.cc.

 {
    return true;
 }

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

inline

Definition at line 45 of file SherpaHadronizer.cc.

45 { return true; }

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

Definition at line 201 of file SherpaHadronizer.cc.

 {
 #if 0
   for(std::vector<int>::const_iterator iter = pdgIds.begin();
       iter != pdgIds.end(); ++iter)
     if (!markStable(*iter))
       return false;
 
   return true;
 #else
   return false;
 #endif
 }

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

overrideprivatevirtual

Reimplemented from gen::BaseHadronizer.

Definition at line 90 of file SherpaHadronizer.cc.

References gather_cfg::cout, 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;
         std::cout << "Store assigned reference of the randomEngine" << std::endl; 
      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 284 of file SherpaHadronizer.cc.

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

 {
 #if 0
    for(HepMC::GenEvent::particle_iterator iter = event->particles_begin();
        iter != event->particles_end(); iter++)
       (*iter)->set_status(getStatus(*iter));
 #endif
    //******** Verbosity *******
    if (maxEventsToPrint > 0) {
       maxEventsToPrint--;
       event()->print();
    }
 }

bool SherpaHadronizer::generatePartonsAndHadronize ( )

Definition at line 231 of file SherpaHadronizer.cc.

References ecal_dqm_sourceclient-live_cfg::cerr, relval_steps::gen(), and gen::BaseHadronizer::resetEvent().

 {
   //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
     if(ATOOLS::ToType<int>(ATOOLS::rpa->gen.Variable("EVENT_GENERATION_MODE")) == 1){
       if (evt->weights().size()>2) {
         evt->weights()[0]/=evt->weights()[2];
       }
     }
     resetEvent(evt);
     return true;
   }
   else {
     return false;
   }
 }

bool SherpaHadronizer::initializeForInternalPartons ( )

Definition at line 178 of file SherpaHadronizer.cc.

References dir2webdir::argc, arguments, cmsStageWithFailover::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;
 }

bool SherpaHadronizer::readSettings ( int )

inline

Definition at line 42 of file SherpaHadronizer.cc.

42 { return true; }

bool SherpaHadronizer::residualDecay ( )

Definition at line 279 of file SherpaHadronizer.cc.

 {
    return true;
 }

void SherpaHadronizer::statistics ( )

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