agile is hosted by Hepforge, IPPP Durham

AlpGenFHerwig Class Reference

#include <AlpGenFHerwig.hh>

Inheritance diagram for AlpGenFHerwig:
Collaboration diagram for AlpGenFHerwig:

List of all members.

Public Types

enum  Result { SUCCESS = 1, FAILURE = 0 }
 

Really just syntactic sugar for bool returns from setParam.

More...

Public Member Functions

 AlpGenFHerwig ()
 Standard constructor.
 ~AlpGenFHerwig ()
 Destructor.
bool setParam (const string &name, const string &value)
 Pass a parameter to the generator.
void makeEvent (HepMC::GenEvent &evt)
 Generate events.
virtual void setGenSpecificInitialState (PdgCode p1=PROTON, double e1=7000.0, PdgCode p2=PROTON, double e2=7000.0)
 Set up initial state from supplied params.
virtual void setSeed (const int value)
 Set the random number generator seed.
virtual bool setParam (const std::string &name, const int &value)
 Pass an int-valued parameter to the generator.
virtual bool setParam (const std::string &name, const unsigned int &value)
 Pass an int-valued parameter to the generator.
virtual bool setParam (const std::string &name, const long &value)
 Pass an int-valued parameter to the generator.
virtual bool setParam (const std::string &name, const unsigned long &value)
 Pass an int-valued parameter to the generator.
virtual bool setParam (const std::string &name, const double &value)
 Pass a double/float-valued parameter to the generator.
virtual bool setParam (const std::string &name, const float &value)
 Pass a double/float-valued parameter to the generator.
virtual bool setParam (const std::string &name, const bool &value)
 Pass a bool-valued parameter to the generator.
virtual bool setParam (const std::string &name, const std::string &value)
 Pass a string-valued parameter to the generator.
virtual void finalize ()
 Tidy up after ourselves.
string getPDFSet (PdgCode pid)
int getPDFMember (PdgCode pid)
 Get the PDF id number for a given particle.
string getPDFScheme (PdgCode pid) const
 Get the PDF scheme used by the generator (LHAPDF or other).
virtual const double getCrossSection ()
 Return the generated cross section in pb.
void setInitialState (int p1=PROTON, double e1=7000.0, int p2=PROTON, double e2=7000.0)
 Define initial state.
virtual const GeneratorStategetState ()
 Get a generator state object.
virtual void setState (const GeneratorState &state)
 Setup the generator from a generator state object.
virtual const std::string getName () const
 Get the generator name.
virtual void setVersion (const std::string &version)
 Set the generator version.
virtual const std::string getVersion ()
 Get the generator version. This implementation is used as a last resort to determine the generator version. Ideally a specific generator will know its own version and overwrite this. Some generators (e.g. FHerwig) don't know this.

Protected Member Functions

virtual void initialize ()
 Set up default params etc.
virtual void fillEvent (HepMC::GenEvent &evt)
 Fill a HepMC event.
LoggetLog () const
 Get named logger.
virtual void clearEvent (HepMC::GenEvent &evt)
 Clear the supplied event.

Protected Attributes

bool _doHadronise
 Flag to determine if the hadronisation process will be run.
bool _unitWeight
 Flag to determine if weighted or unweighted events are to be generated.
bool _iprocset
 Flag to determine if the process code has been set.
double _crossSection
bool _initialstateset
 Flag for detecting whether the setInitialState method has run.
bool _initialized
 Flag for detecting whether the initialization method has run.
map< PdgCode, std::string > _particleNames
 Collection of translated names for particles.
string _myName
 Generator name.

Private Attributes

AlpGen _alpgen

Detailed Description

Abstract base class for AlpGen interface

Author:
Jon Butterworth
Andy Buckley
Date:
2007-10-16

Definition at line 15 of file AlpGenFHerwig.hh.


Member Enumeration Documentation

enum Result [inherited]

Really just syntactic sugar for bool returns from setParam.

Enumerator:
SUCCESS 
FAILURE 

Definition at line 37 of file Generator.hh.

00037 { SUCCESS=1, FAILURE=0 };


Constructor & Destructor Documentation

AlpGenFHerwig (  ) 

Standard constructor.

Definition at line 25 of file AlpGenFHerwig.cc.

References FHerwig::_iprocset, Generator::_myName, FC_AHIO, and FC_HWPROC.

00025                                {
00026     _myName = "AlpGenHerwig";
00027 
00028     // Set flag to read from LHA event file
00029     FC_HWPROC.IPROC = -100;
00030     _iprocset = true;
00031 
00032     // Set the ALPGEN filename to "zhjj" by default
00033     FC_AHIO.FILENAME[0] = 'z';
00034     FC_AHIO.FILENAME[1] = 'h';
00035     FC_AHIO.FILENAME[2] = 'j';
00036     FC_AHIO.FILENAME[3] = 'j';
00037   }

~AlpGenFHerwig (  )  [inline]

Destructor.

Definition at line 21 of file AlpGenFHerwig.hh.

00021 { }


Member Function Documentation

virtual void clearEvent ( HepMC::GenEvent &  evt  )  [inline, protected, virtual, inherited]

Clear the supplied event.

Definition at line 275 of file Generator.hh.

Referenced by Generator::makeEvent(), FHerwigJimmy::makeEvent(), and AlpGenFHerwigJimmy::makeEvent().

00275                                                 {
00276       evt.clear();
00277     }

void fillEvent ( HepMC::GenEvent &  evt  )  [protected, virtual, inherited]

Fill a HepMC event.

Definition at line 564 of file FHerwig.cc.

References FHerwig::_nevt, FHerwig::_unitWeight, FC_HWEVNT, AGILe::fixHepMCUnitsFromGeVmm(), FHerwig::getCrossSection(), MSG_DEBUG, p, and xsec.

Referenced by FHerwigJimmy::makeEvent(), FHerwig::makeEvent(), AlpGenFHerwigJimmy::makeEvent(), and AlpGenFHerwig::makeEvent().

00564                                             {
00565     HepMC::IO_HERWIG hepevt;
00566     hepevt.fill_next_event(&evt);
00567     fixHepMCUnitsFromGeVmm(evt);
00568     evt.set_event_number(_nevt);
00569 
00570     // Set beam particle status = 4
00571     if (evt.valid_beam_particles()) {
00572       evt.beam_particles().first->set_status(4);
00573       evt.beam_particles().second->set_status(4);
00574     }
00575 
00576     // Rewrite status codes to match HepMC standard (2 -> 3, 195-199 -> 2)
00577     for (HepMC::GenEvent::particle_const_iterator p = evt.particles_begin(); p != evt.particles_end(); ++p) {
00578       if ((*p)->status() == 2) (*p)->set_status(3);
00579       if ((*p)->status() >= 195 && (*p)->status() <= 199) (*p)->set_status(2);
00580     }
00581 
00582     //IO_HERWIG::fillEvent does not fill the weight
00583     evt.weights().clear();
00584     if(FC_HWEVNT.NOWGT == 0 || !_unitWeight){
00585       evt.weights().push_back(FC_HWEVNT.EVWGT);
00586     }else{
00587       evt.weights().push_back(1.0);
00588     }
00589 
00590     // Cross-section
00591     #ifdef HEPMC_HAS_CROSS_SECTION
00592     HepMC::GenCrossSection xsec;
00593     const double xsecval = getCrossSection();
00594     const double xsecerr = getCrossSection() / std::sqrt(_nevt);
00595     MSG_DEBUG("Writing cross-section = " << xsecval << " +- " << xsecerr);
00596     xsec.set_cross_section(xsecval, xsecerr);
00597     evt.set_cross_section(xsec);
00598     #endif
00599   }

void finalize (  )  [virtual, inherited]

Tidy up after ourselves.

Tidy up, print out run stats, etc.

Implements Generator.

Reimplemented in FHerwigJimmy.

Definition at line 655 of file FHerwig.cc.

References FC_HWEFIN, and MSG_DEBUG.

00655                          {
00656     MSG_DEBUG("Finalising...");
00657     FC_HWEFIN();
00658   }

const double getCrossSection (  )  [virtual, inherited]

Return the generated cross section in pb.

Reimplemented from Generator.

Definition at line 648 of file FHerwig.cc.

References Generator::_crossSection, and FC_HWEVNT.

Referenced by FHerwig::fillEvent().

00648                                        {
00649     _crossSection = 1000.0 * FC_HWEVNT.WGTSUM / ((float)FC_HWEVNT.NWGTS);
00650     return _crossSection;
00651   }

virtual const std::string getName (  )  const [inline, virtual, inherited]

Get the generator name.

Reimplemented in Ariadne, Cascade, FHerwigJimmy, FPythia, Phojet, and Rapgap.

Definition at line 96 of file Generator.hh.

References Generator::_myName.

Referenced by Generator::getCrossSection(), Generator::getLog(), Generator::getPDFMember(), Generator::getPDFScheme(), Generator::getPDFSet(), and Generator::getState().

00096                                             {
00097       return _myName;
00098     }

int getPDFMember ( PdgCode  pid  )  [virtual, inherited]

Get the PDF id number for a given particle.

Reimplemented from Generator.

Definition at line 633 of file FHerwig.cc.

References FHerwig::_beamNumber(), and FC_HWPRAM.

00633                                       {
00634     const int beamNum = _beamNumber(pid);
00635     if (beamNum < 0) {
00636       throw runtime_error("PDFMember unknown for PDG code "+ pid);
00637     }
00638     const int member = FC_HWPRAM.MODPDF[beamNum];
00639     return member;
00640   }

string getPDFScheme ( PdgCode  pid  )  const [virtual, inherited]

Get the PDF scheme used by the generator (LHAPDF or other).

Reimplemented from Generator.

Definition at line 643 of file FHerwig.cc.

00643                                                 {
00644     return "LHAPDF";
00645   }

string getPDFSet ( PdgCode  pid  )  [virtual, inherited]

Get the PDF set used by the generator, e.g. HWLHAPDF (for herwig) or one of the default sets.

Reimplemented from Generator.

Definition at line 620 of file FHerwig.cc.

References FHerwig::_beamNumber(), and FC_HWPRCH.

00620                                       {
00621     const int beamNum = _beamNumber(pid);
00622     if (beamNum < 0) {
00623       throw runtime_error("PDFSet unknown for PDG code " + pid);
00624     }
00625     string autString = "";
00626     for (size_t ii = 0; ii != AUTPDF_LENGTH; ++ii) {
00627       autString += FC_HWPRCH.AUTPDF[beamNum][ii];
00628     }
00629     return autString;
00630   }

virtual const GeneratorState& getState (  )  [inline, virtual, inherited]

Get a generator state object.

Definition at line 72 of file Generator.hh.

References Generator::_myState, GeneratorState::addPDF(), GeneratorState::getBeams(), Generator::getCrossSection(), Generator::getName(), Generator::getPDFMember(), Generator::getPDFScheme(), Generator::getPDFSet(), Generator::getVersion(), PDF::member, Beam::name, PDF::particleId, PDF::scheme, PDF::set, GeneratorState::setCrossSection(), GeneratorState::setName(), and GeneratorState::setVersion().

00072                                              {
00073       string myName = getName();
00074       _myState.setName(myName);
00075       _myState.setVersion(getVersion());
00076       _myState.setCrossSection(getCrossSection());
00077       PDF pdf;
00078       foreach (Beam b, _myState.getBeams()) {
00079         pdf.particleId = b.name;
00080         pdf.set = getPDFSet(b.name);
00081         pdf.member = getPDFMember(b.name);
00082         pdf.scheme = getPDFScheme(b.name);
00083         _myState.addPDF(pdf);
00084       }
00085       return _myState;
00086     }

virtual const std::string getVersion (  )  [inline, virtual, inherited]

Get the generator version. This implementation is used as a last resort to determine the generator version. Ideally a specific generator will know its own version and overwrite this. Some generators (e.g. FHerwig) don't know this.

Todo:
This getName() doesn't get used polymophically: fix it!

Reimplemented in Ariadne, FPythia, and Phojet.

Definition at line 112 of file Generator.hh.

References Generator::_myVersion, Generator::_versionSet, and MSG_ERROR.

Referenced by Generator::getState().

00112                                          {
00113       if (!_versionSet) {
00115         MSG_ERROR("You asked the generator " //<< getName()
00116                   << " what version it is, but it doesn't know!\n"
00117                   << "You should set the version with a call to setVersion(string)");
00118         throw runtime_error("Version unknown for generator");
00119       }
00120       return _myVersion;
00121     }

void initialize (  )  [protected, virtual, inherited]

Set up default params etc.

Reimplemented from Generator.

Reimplemented in FHerwigJimmy.

Definition at line 75 of file FHerwig.cc.

References Generator::_initialized, FHerwig::_iprocset, FHerwig::_processParams(), FC_HWEINI, FC_HWEVNT, FC_HWIGIN, FC_HWPRAM, FC_HWPROC, and FC_HWUINC.

00075                            {
00076     Generator::initialize();
00077 
00078     // Use QCD 2->2 as the default process
00079     if (!_iprocset) FC_HWPROC.IPROC = 1500;
00080 
00081     // Print banner and initialise common blocks (requires initial state and IPROC to have been set)
00082     FC_HWIGIN();
00083 
00084     // for (size_t idhw = 1; idhw <= 458; ++idhw) {
00085     //  std::cout << idhw << "  " << FC_HWPROP.IDPDG[idhw] << std::endl;
00086     // }
00087 
00088     // Set banner printout control params
00089     FC_HWPRAM.IPRINT = 1; // Type of info to print
00090     FC_HWPRAM.PRNDEF = 1; // Enable/disable ASCII output
00091 
00092     // Set some system params which HWIGIN has initialised to silly values
00093     FC_HWPROC.MAXEV = 10000000; // Maximum number of events (irrelevant!)
00094     FC_HWEVNT.MAXER = 10000000; // Maximum number of allowed errors
00095     FC_HWEVNT.MAXPR = 0; // Number of events to print
00096 
00097     // Apply stored parameters
00098     _processParams();
00099 
00100     // Compute parameter-dependent constants
00101     FC_HWUINC();
00102 
00103     // Initialise elementary process
00104     FC_HWEINI();
00105 
00106     _initialized = true;
00107   }

void makeEvent ( HepMC::GenEvent &  evt  )  [virtual]

Generate events.

Reimplemented from FHerwig.

Definition at line 55 of file AlpGenFHerwig.cc.

References FHerwig::_doHadronise, FC_HWBGEN, FC_HWCDEC, FC_HWCFOR, FC_HWDHAD, FC_HWDHOB, FC_HWDHVY, FC_HWEPRO, FC_HWEVNT, FC_HWMEVT, FC_HWUFNE, FC_HWUINE, FC_UPVETO, FHerwig::fillEvent(), and MSG_DEBUG.

00055                                                   {
00056     Generator::makeEvent(evt);
00057     while (true) {
00058       FC_HWUINE();  // Initialize event
00059       FC_HWEPRO();  // Generate hard subprocess
00060       // Call the matching routine
00061       int imatch = 0;
00062       FC_UPVETO(&imatch);
00063       if (imatch != 0) {
00064         MSG_DEBUG("Event killed by UPVETO");
00065         FC_HWEVNT.IERROR = -1;
00066         FC_HWUFNE();
00067         continue;
00068       }
00069       break;
00070     }
00071     FC_HWBGEN();  // Generate parton cascade
00072     FC_HWDHOB();  // Do heavy quark decays
00073     if (_doHadronise) {
00074       FC_HWCFOR();  // Do cluster formation
00075       FC_HWCDEC();  // Do cluster decays
00076       FC_HWDHAD();  // Do unstable particle decays
00077       FC_HWDHVY();  // Do heavy flavor decays
00078       FC_HWMEVT();  // Add soft underlying event
00079     }
00080     FC_HWUFNE();  // Finish event
00081     fillEvent(evt);
00082     return;
00083   }

void setGenSpecificInitialState ( PdgCode  p1 = PROTON,
double  e1 = 7000.0,
PdgCode  p2 = PROTON,
double  e2 = 7000.0 
) [virtual, inherited]

Set up initial state from supplied params.

Implements Generator.

Definition at line 56 of file FHerwig.cc.

References Generator::_particleNames, AGILe::ANTIPROTON, FC_HWBMCH, FC_HWPROC, MSG_DEBUG, AGILe::NEUTRON, and AGILe::PROTON.

00056                                                                                {
00057     MSG_DEBUG("Setting initial state...");
00058     // Herwig's initial state particles specification must be 8 chars long
00059     for (size_t i = 0; i < 8; ++i) {
00060       FC_HWBMCH.PART1[i] = _particleNames[ParticleName(p1)].c_str()[i];
00061       FC_HWBMCH.PART2[i] = _particleNames[ParticleName(p2)].c_str()[i];
00062     }
00063     // Set momenta / energies
00064     // NB. Beam ordering is significant (segfault if "wrong") for HERA-like initial states
00065     // Subtraction of (very rough!) beam particle masses to get momenta rather than energies
00066     if (p1 == PROTON || p1 == ANTIPROTON || p1 == NEUTRON) e1 = sqrt(e1*e1 - 1.0);
00067     if (p2 == PROTON || p2 == ANTIPROTON || p2 == NEUTRON) e2 = sqrt(e2*e2 - 1.0);
00068     // And set the common block values
00069     FC_HWPROC.PBEAM1 = e1;
00070     FC_HWPROC.PBEAM2 = e2;
00071   }

void setInitialState ( int  p1 = PROTON,
double  e1 = 7000.0,
int  p2 = PROTON,
double  e2 = 7000.0 
) [inline, inherited]

Define initial state.

Todo:
Make sure it was successful - exception handling

Definition at line 54 of file Generator.hh.

References Generator::_initialstateset, Generator::_myState, Beam::energy, Beam::name, Beam::position, GeneratorState::setBeams(), and Generator::setGenSpecificInitialState().

Referenced by Generator::initialize().

00056     {
00057       setGenSpecificInitialState(p1, e1, p2, e2);
00059       _initialstateset = true;
00060       Beam beam1, beam2;
00061       beam1.name = p1;
00062       beam2.name = p2;
00063       beam1.energy = e1;
00064       beam2.energy = e2;
00065       beam1.position = 1;
00066       beam2.position = 2;
00067       _myState.setBeams(beam1, beam2);
00068     }

virtual bool setParam ( const std::string &  name,
const std::string &  value 
) [inline, virtual, inherited]

Pass a string-valued parameter to the generator.

Definition at line 224 of file Generator.hh.

References Generator::_initialized, Generator::_myState, MSG_ERROR, and GeneratorState::setParam().

00224                                                                          {
00225       if (_initialized) {
00226         MSG_ERROR("Can't set parameter " << name << ": generator has already been initialized");
00227         throw runtime_error("Tried to set param after generator initialization");
00228       }
00229       _myState.setParam(name, value);
00230       return true;
00231     }

virtual bool setParam ( const std::string &  name,
const bool &  value 
) [inline, virtual, inherited]

Pass a bool-valued parameter to the generator.

Definition at line 214 of file Generator.hh.

References Generator::_initialized, MSG_ERROR, Generator::setParam(), and AGILe::toString().

00214                                                                     {
00215       if (_initialized) {
00216         MSG_ERROR("Can't set parameter " << name << ": generator has already been initialized");
00217         throw runtime_error("Tried to set param after generator initialization");
00218       }
00219       return setParam(name, toString(value));
00220     }

virtual bool setParam ( const std::string &  name,
const float &  value 
) [inline, virtual, inherited]

Pass a double/float-valued parameter to the generator.

Definition at line 204 of file Generator.hh.

References Generator::_initialized, MSG_ERROR, Generator::setParam(), and AGILe::toString().

00204                                                                      {
00205       if (_initialized) {
00206         MSG_ERROR("Can't set parameter " << name << ": generator has already been initialized");
00207         throw runtime_error("Tried to set param after generator initialization");
00208       }
00209       return setParam(name, toString(value));
00210     }

virtual bool setParam ( const std::string &  name,
const double &  value 
) [inline, virtual, inherited]

Pass a double/float-valued parameter to the generator.

Definition at line 194 of file Generator.hh.

References Generator::_initialized, MSG_ERROR, Generator::setParam(), and AGILe::toString().

00194                                                                       {
00195       if (_initialized) {
00196         MSG_ERROR("Can't set parameter " << name << ": generator has already been initialized");
00197         throw runtime_error("Tried to set param after generator initialization.");
00198       }
00199       return setParam(name, toString(value));
00200     }

virtual bool setParam ( const std::string &  name,
const unsigned long &  value 
) [inline, virtual, inherited]

Pass an int-valued parameter to the generator.

Definition at line 184 of file Generator.hh.

References Generator::_initialized, MSG_ERROR, Generator::setParam(), and AGILe::toString().

00184                                                                              {
00185       if (_initialized) {
00186         MSG_ERROR("Can't set parameter " << name << ": generator has already been initialized");
00187       throw runtime_error("Tried to set param after generator initialization");
00188       }
00189       return setParam(name, toString(value));
00190     }

virtual bool setParam ( const std::string &  name,
const long &  value 
) [inline, virtual, inherited]

Pass an int-valued parameter to the generator.

Definition at line 174 of file Generator.hh.

References Generator::_initialized, MSG_ERROR, Generator::setParam(), and AGILe::toString().

00174                                                                     {
00175       if (_initialized) {
00176         MSG_ERROR("Can't set parameter " << name << ": generator has already been initialized");
00177         throw runtime_error("Tried to set param after generator initialization");
00178       }
00179       return setParam(name, toString(value));
00180     }

virtual bool setParam ( const std::string &  name,
const unsigned int &  value 
) [inline, virtual, inherited]

Pass an int-valued parameter to the generator.

Definition at line 164 of file Generator.hh.

References Generator::_initialized, MSG_ERROR, Generator::setParam(), and AGILe::toString().

00164                                                                             {
00165       if (_initialized) {
00166         MSG_ERROR("Can't set parameter " << name << ": generator has already been initialized");
00167         throw runtime_error("Tried to set param after generator initialization");
00168       }
00169       return setParam(name, toString(value));
00170     }

virtual bool setParam ( const std::string &  name,
const int &  value 
) [inline, virtual, inherited]

Pass an int-valued parameter to the generator.

Definition at line 154 of file Generator.hh.

References Generator::_initialized, MSG_ERROR, and AGILe::toString().

Referenced by Generator::setParam().

00154                                                                    {
00155       if (_initialized) {
00156         MSG_ERROR("Can't set parameter " << name << ": generator has already been initialized");
00157         throw runtime_error("Tried to set param after generator initialization");
00158       }
00159       return setParam(name, toString(value));
00160     }

bool setParam ( const string &  name,
const string &  value 
) [virtual]

Pass a parameter to the generator.

Reimplemented from FHerwig.

Definition at line 41 of file AlpGenFHerwig.cc.

References AlpGenFHerwig::_alpgen, Generator::FAILURE, MSG_ERROR, AlpGen::setParam(), and Generator::SUCCESS.

00041                                                                       {
00042     // Try AlpGen param handling first
00043     bool ok = _alpgen.setParam(name, value);
00044     if (ok) return SUCCESS;
00045     // Fall back to Herwig param handling
00046     ok = FHerwig::setParam(name, value);
00047     if (ok) return SUCCESS;
00048     // Fail
00049     MSG_ERROR("AlpGenHerwig doesn't have a parameter called " << name);
00050     return FAILURE;
00051   }

void setSeed ( const int  value  )  [virtual, inherited]

Set the random number generator seed.

Reimplemented from Generator.

Definition at line 111 of file FHerwig.cc.

References FHerwig::setParam().

00111                                        {
00112     Generator::setSeed(value);
00113     setParam("SEED", value);
00114   }

virtual void setState ( const GeneratorState state  )  [inline, virtual, inherited]

Setup the generator from a generator state object.

Definition at line 90 of file Generator.hh.

00090                                                        {
00091       throw runtime_error("This ain't ready yet, it's just here as an interface placeholder. Sorry.");
00092     }

virtual void setVersion ( const std::string &  version  )  [inline, virtual, inherited]

Set the generator version.

Definition at line 102 of file Generator.hh.

References Generator::_myVersion, and Generator::_versionSet.

Referenced by AGILe::Loader::createGen().

00102                                                       {
00103       _myVersion = version;
00104       _versionSet = true;
00105     }


Member Data Documentation

AlpGen _alpgen [private]

Definition at line 36 of file AlpGenFHerwig.hh.

Referenced by AlpGenFHerwig::setParam().

bool _doHadronise [protected, inherited]

Flag to determine if the hadronisation process will be run.

Definition at line 54 of file FHerwig.hh.

Referenced by FHerwig::_processParams(), FHerwigJimmy::makeEvent(), FHerwig::makeEvent(), AlpGenFHerwigJimmy::makeEvent(), and AlpGenFHerwig::makeEvent().

bool _initialized [protected, inherited]
bool _initialstateset [protected, inherited]

Flag for detecting whether the setInitialState method has run.

Definition at line 285 of file Generator.hh.

Referenced by Generator::initialize(), and Generator::setInitialState().

bool _iprocset [protected, inherited]

Flag to determine if the process code has been set.

Definition at line 60 of file FHerwig.hh.

Referenced by AlpGenFHerwig::AlpGenFHerwig(), AlpGenFHerwigJimmy::AlpGenFHerwigJimmy(), FHerwig::initialize(), and FHerwig::setParam().

bool _unitWeight [protected, inherited]

Flag to determine if weighted or unweighted events are to be generated.

Definition at line 57 of file FHerwig.hh.

Referenced by FHerwig::_processParams(), and FHerwig::fillEvent().


The documentation for this class was generated from the following files:
Generated on Tue Mar 6 10:39:40 2012 for AGILe - A Generator Interface Library (+ executable) by  doxygen 1.6.3