#include <ExhumeHadronizer.h>

Inheritance diagram for gen::ExhumeHadronizer:

Public Member Functions
const char *	classname () const

bool	decay ()

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

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

	ExhumeHadronizer (edm::ParameterSet const &ps)

void	finalizeEvent ()

bool	generatePartonsAndHadronize ()

bool	hadronize ()

bool	initializeForExternalPartons ()

bool	initializeForInternalPartons ()

bool	readSettings (int)

bool	residualDecay ()

void	statistics ()

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

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

virtual	~BaseHadronizer ()(false)

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

std::vector< std::string > const &	doSharedResources () const override

Private Attributes
double	comEnergy_

bool	convertToPDG_

Exhume::Event *	exhumeEvent_

Exhume::CrossSection *	exhumeProcess_

bool	hepMCVerbosity_

unsigned int	maxEventsToPrint_

edm::ParameterSet	myPSet_

Pythia6Service *	pythia6Service_

unsigned int	pythiaListVerbosity_

CLHEP::HepRandomEngine *	randomEngine_

Static Private Attributes
static const std::vector< std::string >	theSharedResources

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 ExhumeHadronizer.h.

Constructor & Destructor Documentation

gen::ExhumeHadronizer::ExhumeHadronizer ( edm::ParameterSet const & ps )

Definition at line 78 of file ExhumeHadronizer.cc.

References convertToPDG_, edm::ParameterSet::exists(), and edm::ParameterSet::getParameter().

    : BaseHadronizer(pset),
      pythia6Service_(new Pythia6Service(pset)),
      randomEngine_(nullptr),
      comEnergy_(pset.getParameter<double>("comEnergy")),
      myPSet_(pset),
      hepMCVerbosity_(pset.getUntrackedParameter<bool>("pythiaHepMCVerbosity",false)),
      maxEventsToPrint_(pset.getUntrackedParameter<int>("maxEventsToPrint", 0)),
      pythiaListVerbosity_(pset.getUntrackedParameter<int>("pythiaPylistVerbosity", 0)),
      exhumeEvent_(nullptr)
 { 
 
    convertToPDG_ = false;
    if ( pset.exists( "doPDGConvert" ) )
    {
       convertToPDG_ = pset.getParameter<bool>("doPDGConvert");
    }
    
    //pythia6Hadronizer_ = new Pythia6Hadronizer(pset);  
 }

gen::ExhumeHadronizer::~ExhumeHadronizer ( )

override

Definition at line 99 of file ExhumeHadronizer.cc.

References exhumeEvent_, exhumeProcess_, and pythia6Service_.

                                    {
    //delete pythia6Hadronizer_;
    delete pythia6Service_;
    delete exhumeEvent_;
    delete exhumeProcess_;
 }

Member Function Documentation

const char * gen::ExhumeHadronizer::classname ( ) const

Definition at line 301 of file ExhumeHadronizer.cc.

 {
    return "gen::ExhumeHadronizer";
 }

bool gen::ExhumeHadronizer::decay ( )

Definition at line 181 of file ExhumeHadronizer.cc.

 {
    return true;
 }

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

Definition at line 273 of file ExhumeHadronizer.cc.

 {
    return true;
 }

bool gen::ExhumeHadronizer::declareStableParticles ( const std::vector< int > & _pdg )

Definition at line 255 of file ExhumeHadronizer.cc.

References gen::call_pygive(), gather_cfg::cout, mps_fire::i, and pycomp.

 {
    std::vector<int> pdg = _pdg;
    //return pythia6Hadronizer_->declareStableParticles(pdg);
 
    for ( size_t i=0; i < pdg.size(); i++ )
    {
       int pyCode = pycomp( pdg[i] );
       std::ostringstream pyCard ;
       pyCard << "MDCY(" << pyCode << ",1)=0";
       std::cout << pyCard.str() << std::endl;
       call_pygive( pyCard.str() );
    }
    
    return true;
 
 }

void gen::ExhumeHadronizer::doSetRandomEngine ( CLHEP::HepRandomEngine * v )

overrideprivatevirtual

Reimplemented from gen::BaseHadronizer.

Definition at line 106 of file ExhumeHadronizer.cc.

References exhumeEvent_, pythia6Service_, randomEngine_, Exhume::Event::SetRandomEngine(), gen::Pythia6Service::setRandomEngine(), and gen::v.

 {
    pythia6Service_->setRandomEngine(v);
    randomEngine_ = v;
    if(exhumeEvent_) {
      exhumeEvent_->SetRandomEngine(v);
    }
 }

std::vector<std::string> const& gen::ExhumeHadronizer::doSharedResources ( ) const

inlineoverrideprivatevirtual

Reimplemented from gen::BaseHadronizer.

Definition at line 68 of file ExhumeHadronizer.h.

68 { return theSharedResources; }

gen::ExhumeHadronizer::theSharedResources

static const std::vector< std::string > theSharedResources

Definition: ExhumeHadronizer.h:70

void gen::ExhumeHadronizer::finalizeEvent ( )

Definition at line 115 of file ExhumeHadronizer.cc.

References gen::call_pylist(), convertToPDG_, gather_cfg::cout, gen::BaseHadronizer::event(), hepMCVerbosity_, maxEventsToPrint_, pyint1, pypars, and pythiaListVerbosity_.

 {
    //pythia6Hadronizer_->finalizeEvent();
 
    event()->set_signal_process_id( pypars.msti[0] );
    event()->set_event_scale( pypars.pari[16] );
 
    HepMC::PdfInfo pdf;
    pdf.set_id1( pyint1.mint[14] == 21 ? 0 : pyint1.mint[14] );
    pdf.set_id2( pyint1.mint[15] == 21 ? 0 : pyint1.mint[15] );
    pdf.set_x1( pyint1.vint[40] );
    pdf.set_x2( pyint1.vint[41] );
    pdf.set_pdf1( pyint1.vint[38] / pyint1.vint[40] );
    pdf.set_pdf2( pyint1.vint[39] / pyint1.vint[41] );
    pdf.set_scalePDF( pyint1.vint[50] );
 
    event()->set_pdf_info( pdf ) ;
 
    event()->weights().push_back( pyint1.vint[96] );
 
    // convert particle IDs Py6->PDG, if requested
    if(convertToPDG_) {
       for ( HepMC::GenEvent::particle_iterator part = event()->particles_begin(); 
                                                part != event()->particles_end(); ++part) {
          (*part)->set_pdg_id(HepPID::translatePythiatoPDT((*part)->pdg_id()));
       }
    }
 
    // service printouts, if requested
    //
    if (maxEventsToPrint_ > 0) 
    {
       --maxEventsToPrint_;
       if (pythiaListVerbosity_) call_pylist(pythiaListVerbosity_);
       if (hepMCVerbosity_) 
       {
          std::cout << "Event process = " << pypars.msti[0] << std::endl 
           << "----------------------" << std::endl;
          event()->print();
       }
    }
 
    return;
 }

bool gen::ExhumeHadronizer::generatePartonsAndHadronize ( )

Definition at line 160 of file ExhumeHadronizer.cc.

References conv, gen::BaseHadronizer::event(), exhumeEvent_, exhumeProcess_, Exhume::Event::Generate(), gen::FortranCallback::getInstance(), Exhume::CrossSection::Hadronise(), pythia6Service_, and gen::FortranCallback::resetIterationsPerEvent().

 {
    Pythia6Service::InstanceWrapper guard(pythia6Service_);
 
    FortranCallback::getInstance()->resetIterationsPerEvent();
    
    // generate event
    
    exhumeEvent_->Generate();
    exhumeProcess_->Hadronise();
 
    event().reset( conv.read_next_event() );
    
    return true;
 }

bool gen::ExhumeHadronizer::hadronize ( )

Definition at line 176 of file ExhumeHadronizer.cc.

 {
    return false;
 }

bool gen::ExhumeHadronizer::initializeForExternalPartons ( )

Definition at line 191 of file ExhumeHadronizer.cc.

 {
    return false;
 }

bool gen::ExhumeHadronizer::initializeForInternalPartons ( )

Definition at line 207 of file ExhumeHadronizer.cc.

References edm::errors::Configuration, Exception, exhumeEvent_, exhumeProcess_, edm::ParameterSet::getParameter(), myPSet_, pypars, pythia6Service_, randomEngine_, Exhume::Event::SetMassRange(), Exhume::Event::SetParameterSpace(), and AlCaHLTBitMon_QueryRunRegistry::string.

 {
    Pythia6Service::InstanceWrapper guard(pythia6Service_);
 
    // pythia6Service_->setGeneralParams();
  
    //Exhume Initialization
    edm::ParameterSet processPSet = myPSet_.getParameter<edm::ParameterSet>("ExhumeProcess");
    std::string processType = processPSet.getParameter<std::string>("ProcessType");
    int sigID = -1;
    if(processType == "Higgs"){
       exhumeProcess_ = new Exhume::Higgs(myPSet_);
       int higgsDecay = processPSet.getParameter<int>("HiggsDecay");
       (static_cast<Exhume::Higgs*>(exhumeProcess_))->SetHiggsDecay(higgsDecay);
       sigID = 100 + higgsDecay;
    } else if(processType == "QQ"){  
       exhumeProcess_ = new Exhume::QQ(myPSet_);
       int quarkType = processPSet.getParameter<int>("QuarkType");
       double thetaMin = processPSet.getParameter<double>("ThetaMin");
       ((Exhume::QQ*)exhumeProcess_)->SetQuarkType(quarkType);
       (static_cast<Exhume::QQ*>(exhumeProcess_))->SetThetaMin(thetaMin);
       sigID = 200 + quarkType;
    } else if(processType == "GG"){
       exhumeProcess_ = new Exhume::GG(myPSet_);
       double thetaMin = processPSet.getParameter<double>("ThetaMin");
       (static_cast<Exhume::GG*>(exhumeProcess_))->SetThetaMin(thetaMin);
       sigID = 300;
    } else if(processType == "DiPhoton"){
       exhumeProcess_ = new Exhume::DiPhoton(myPSet_);
       double thetaMin = processPSet.getParameter<double>("ThetaMin");
       (static_cast<Exhume::DiPhoton*>(exhumeProcess_))->SetThetaMin(thetaMin);
       sigID = 400;
    } else{
       sigID = -1;
       throw edm::Exception(edm::errors::Configuration,"ExhumeError") <<" No valid Exhume Process";
    }
     
    pypars.msti[0] = sigID;
    exhumeEvent_ = new Exhume::Event(*exhumeProcess_, randomEngine_);
 
    double massRangeLow = processPSet.getParameter<double>("MassRangeLow");
    double massRangeHigh = processPSet.getParameter<double>("MassRangeHigh");
    exhumeEvent_->SetMassRange(massRangeLow,massRangeHigh);
    exhumeEvent_->SetParameterSpace();
 
    return true;
 }

bool gen::ExhumeHadronizer::readSettings ( int )

Definition at line 196 of file ExhumeHadronizer.cc.

References pythia6Service_, and gen::Pythia6Service::setGeneralParams().

 {
 
    Pythia6Service::InstanceWrapper guard(pythia6Service_);
 
    pythia6Service_->setGeneralParams();
 
    return true;
 
 }

bool gen::ExhumeHadronizer::residualDecay ( )

Definition at line 186 of file ExhumeHadronizer.cc.

 {
    return true;
 }

void gen::ExhumeHadronizer::statistics ( )

Definition at line 278 of file ExhumeHadronizer.cc.

References Exhume::Event::CrossSectionCalculation(), fwrapper::cs, exhumeEvent_, exhumeProcess_, Exhume::Event::GetEfficiency(), Exhume::CrossSection::GetName(), dataset::name, gen::BaseHadronizer::runInfo(), GenRunInfoProduct::setInternalXSec(), and AlCaHLTBitMon_QueryRunRegistry::string.

 {
   std::ostringstream footer_str;
 
   double cs = exhumeEvent_->CrossSectionCalculation();
   double eff = exhumeEvent_->GetEfficiency();
   std::string name = exhumeProcess_->GetName();
 
   footer_str << "\n" <<"   You have just been ExHuMEd." << "\n" << "\n";
   footer_str << "   The cross section for process " << name
              << " is " << cs << " fb" << "\n" << "\n";
   footer_str << "   The efficiency of event generation was " << eff << "%" << "\n" << "\n";
 
   edm::LogInfo("") << footer_str.str();
 
   if ( !runInfo().internalXSec() )
   {
      runInfo().setInternalXSec( cs );
   }
 
   return;
 }