ParticleData, which is the top-level class, with 
methods that can be used to interrogate all particle data. It contains 
a map of PDG particle identity numbers [Yao06] onto the relevant 
ParticleDataEntry objects,ParticleDataEntry, which stores the relevant information 
on an individual particle species, andDecayChannel, which stores info on one particular decay 
mode of a particle.Pythia object has a public member 
particleData of the ParticleData class. 
Therefore you access the particle data methods as 
pythia.particleData.command(argument), 
assuming that pythia is an instance of the 
Pythia class. Further, for some of the most frequent user 
tasks, Pythia methods have been defined, so that 
pythia.command(argument) 
would work, see further below. 
 
 
A fundamental difference between the particle data classes and the 
settings ones is that the former are accessed regularly during the 
event generation process, as a new particle is produced and its mass 
need to be set, e.g., while the latter are mainly/only used 
at the initialization stage. Nevertheless, it is not a good idea to 
change data in either of them in mid-run, since this may lead to 
inconsistencies. 
 
 
name: a character string with the name of the 
particle. Particle and antiparticle names are stored separately, 
with void returned when no antiparticle exists.spinType: the spin type, of the form 2 s + 1, 
with special code 0 for entries of unknown or indeterminate spin.chargeType: three times the charge (to make it an 
integer).colType: the colour type, with 0 uncoloured, 1 triplet, 
-1 antitriplet and 2 octet. (A preliminary implementation of colour 
  sextets, available since version 8.150, further uses 3 for a sextet 
  and -3 for an antisextet.) m0: the nominal mass m_0 (in GeV).mWidth: the width Gamma of the Breit-Wigner 
distribution (in GeV).mMin: the lower limit of the allowed mass range 
generated by the Breit-Wigner (in GeV). Has no meaning for particles 
without width, and would typically be 0 there.mMax: the upper limit of the allowed mass range 
generated by the Breit-Wigner (in GeV). If mMax < mMin then 
no upper limit is imposed. Has no meaning for particles without width, 
and would typically be 0 there.tau0: the nominal proper lifetime tau_0 
(in mm/c).tauCalc: a flag telling whether the nominal proper 
lifetime tau_0 should be calculated from the particle width, 
mWidth, at initialization (the default behavior). If set 
false, then the proper lifetime can be varied independently from the 
particle width. This capability is useful for simulating models of 
long-lived particles where the dependence of a signature on the 
particle width is negligible.isResonance: a flag telling whether a particle species 
is considered as a resonance or not. Here 
"resonance" is used as shorthand 
for any massive particle where the decay process should be counted as part 
of the hard process itself, and thus be performed before showers and other 
event aspects are added. Restrictions on allowed decay channels is also 
directly reflected in the cross section of simulated processes, while 
those of normal hadrons and other light particles are not. 
In practice, it is reserved for states above the b bbar 
bound systems in mass, i.e. for W, Z, t, Higgs states, 
supersymmetric states and (most?) other states in any new theory. 
All particles with m0 above 20 GeV are by default 
initialized to be considered as resonances.mayDecay: a flag telling whether a particle species 
may decay or not, offering the main user switch. Whether a given particle 
of this kind then actually will decay also depends on it having allowed 
decay channels, and on other flags for 
particle decays 
(or resonance decays). 
All particles with tau0 below 1000 mm are 
by default initialized to allow decays.doExternalDecays: a flag telling whether a particle 
should be handled by an external decay package or not, with the latter 
default. Can be manipulated as described on this page, but should 
normally not be. Instead the 
Pythia::decayPtr(...) 
method should be provided with the list of relevant particles.isVisible: a flag telling whether a particle species 
is to be considered as visible in a detector or not, as used e.g. in 
analysis routines. By default the invisibles include neutrinos, 
Dark Matter particles (codes 51 - 60) and a few BSM particles (gravitino, 
sneutrinos, neutralinos) that have neither strong nor electromagnetic 
charge, and are not made up of constituents that have it. The value of 
this flag is only relevant if a particle is long-lived enough actually 
to make it to a detector.doForceWidth: a flag applicable only for resonances 
(see isResonance above), whereby it is possible to force 
resonances to retain their assigned width, whatever that is, see 
Resonance Decays for details.onMode: integer code for use or not of channel,bRatio: the branching ratio of the channel 
(with some reservations for resonances, see meMode 
below).meMode: the mode of processing this channel, possibly 
with matrix elements; see the 
particle decays and 
resonance decays 
descriptions for the list of possibilities. 
Notably the default code 0 for a particle means pure phase space 
decays according to the given branching ratios, while for a resonance 
it means that code exists for the dynamic calculations of partial 
widths and thereby branching ratios as a function of the resonance mass 
(which is done e.g. at initialization based on the mass set by the user). 
Then codes 1 - 99 are reserved for various matrix-element-improved 
ordinary particle decays, and 100 - 103 for resonances where the 
partial width of a given channel is calculated from the total width 
and the stored branching ratio. Thus, to enforce a new branching ratio 
for a resonance channel (with its own partial-width calculation code) 
it is not sufficient only to change the bRatio but also 
to set e.g. meMode = 100. multiplicity: the number of decay products of the 
channel. Can be at most 8.product(i): the identity code of the decay products, 
where i runs between 0 and 
multiplicity - 1. Trailing positions are filled with 0. 
Pythia object pythia is created, the 
pythia.particleData member is asked to scan the 
ParticleData.xml file. 
 
 
All lines beginning with <particle are scanned for 
information on a particle species, and all lines beginning with 
<channel are assumed to contain a decay channel of the 
enclosing particle. In both cases XML syntax is used, with attributes 
used to identify the stored properties, and with omitted properties 
defaulting back to 0 where meaningful. The particle and channel 
information may be split over several lines, up to the > endtoken. 
The format of a <particle tag is: 
 
    <particle id="..." name="..." antiName="..." spinType="..." chargeType="..." colType="..." 
       m0="..." mWidth="..." mMin="..." mMax="..." tau0="..."> 
    </particle> 
 
where the fields are the properties already introduced above.  Note 
that tauCalc, isResonance, 
mayDecay, doExternalDecay, 
isVisible and doForceWidth are not set here, 
but are provided with default values by the rules described 
above. Once initialized, also these latter properties can be changed, 
see below.<channel> tag is: 
 
    <channel onMode="..." bRatio="..." meMode="..." products="..." /> 
 
again see properties above. The products are given as a blank-separated 
list of id codes. 
.xml file should not 
be changed, except by the PYTHIA authors. Any changes should be done 
with the help of the methods described below. 
Pythia object and the 
init call for it, you may use the methods of the 
ParticleData class to modify some of the default values. 
Several different approaches can be chosen for this. 
 
 
a) Inside your main program you can directly set values with 
 
    pythia.readString(string); 
 
where both the variable name and the value are contained inside 
the character string, separated by blanks and/or a =, e.g. 
 
    pythia.readString("111:mayDecay = off"); 
 
switches off the decays of the pi^0.name, antiName, 
spinType, chargeType, colType, 
m0, mWidth, mMin, 
mMax, tau0, tauCalc, 
isResonance, mayDecay, 
doExternalDecay, isVisible and 
doForceWidth. All of these names are 
case-insensitive. Names that do not match an existing variable are 
ignored.bool values, the following notation may be used 
interchangeably: true = on = yes = ok = 1, while everything 
else gives false (including but not limited to 
false, off, no and 
0). 
 
 
Particle data often comes in sets of closely related information. 
Therefore some properties expect the value to consist of several 
numbers. These can then be separated by blanks (or by commas). 
A simple example is names, which expects both the 
name and antiname to be given. A more interesting one is the 
all property, 
 
    id:all = name antiName spinType chargeType colType m0 mWidth mMin mMax tau0 
 
where all the current information on the particle itself is replaced, 
but any decay channels are kept unchanged. Using new 
instead of all also removes any previous decay channels. 
If the string contains fewer fields than expected the trailing 
properties are set to vanish ("void", 0 or 0.). Note that such a 
truncated string should not be followed by a comment, since this 
comment would then be read in as if it contained the missing 
properties.  The truncation can be done anywhere, specifically a 
string with only id:new defines a new "empty" particle. 
As before, tauCalc, isResonance, 
mayDecay, doExternalDecay, 
isVisible and doForceWidth are (re)set to 
their default values, and would have to be changed separately if 
required. 
 
 
A further command is rescaleBR, which rescales each of the 
existing branching ratios with a common factor, such that their new 
sum is the provided value. This may be a first step towards adding 
new decay channels, see further below. 
 
 
Alternatively the id code may be followed by another integer, 
which then gives the decay channel number. This then has to be 
followed by the property specific to this channel, either 
onMode, bRatio, meMode or 
products. In the latter case all the products of 
the channel should be given: 
 
    id:channel:products =  product1 product2 .... 
 
The line will be scanned until the end of the line, or until a 
non-number word is encountered, or until the maximum allowed number 
of eight products is encountered, whichever happens first. (Thus the 
multiplicity of a decay channel need not be input; it is automatically 
calculated from the products list.) It is also possible to replace all 
the properties of a channel in a similar way: 
 
    id:channel:all = onMode bRatio meMode product1 product2 .... 
 
To add a new channel at the end, use 
 
    id:addChannel = onMode bRatio meMode product1 product2 .... 
 
 
 
It is currently not possible to remove a channel selectively, but 
setting its branching ratio vanishing is as effective. If you want to 
remove all existing channels and force decays into one new channel 
you can use 
 
    id:oneChannel = onMode bRatio meMode product1 product2 .... 
 
 A first oneChannel command could be followed by 
several subsequent addChannel ones, to build 
up a completely new decay table for an existing particle. 
 
 
When adding new channels or changing branching ratios in general, 
note that, once a particle is to be decayed, the sum of branching 
ratios is always rescaled to unity. Beforehand, rescaleBR 
may be used to rescale an existing branching ratio by the given factor. 
 
 
There are a few commands that will study all the decay channels of the 
given particle, to switch them on or off as desired. The 
 
    id:onMode = onMode 
 
will set the onMode property of all channels to the 
desired value. The 
 
    id:offIfAny   = product1 product2 .... 
    id:onIfAny    = product1 product2 .... 
    id:onPosIfAny = product1 product2 .... 
    id:onNegIfAny = product1 product2 .... 
 
will set the onMode 0, 1, 2 or 3, respectively, for all 
channels which contain any of the enumerated products, where the matching 
to these products is done without distinction of particles and 
antiparticles. Note that "Pos" and "Neg" 
are slightly misleading since it refers to the particle and antiparticle 
of the id species rather than charge, but should still be 
simpler to remember and understand than alternative notations. 
Correspondingly 
 
    id:offIfAll   = product1 product2 .... 
    id:onIfAll    = product1 product2 .... 
    id:onPosIfAll = product1 product2 .... 
    id:onNegIfAll = product1 product2 .... 
 
will set the onMode 0, 1, 2 or 3, respectively, for all 
channels which contain all of the enumerated products, again without 
distinction of particles and antiparticles. If the same product appears 
twice in the list it must also appear twice in the decay channel, and 
so on. The decay channel is allowed to contain further particles, 
beyond the product list. By contrast, 
 
    id:offIfMatch   = product1 product2 .... 
    id:onIfMatch    = product1 product2 .... 
    id:onPosIfMatch = product1 product2 .... 
    id:onNegIfMatch = product1 product2 .... 
 
requires the decay-channel multiplicity to agree with that of the product 
list, but otherwise works as the onIfAll/offIfAll methods. 
 
 
Note that the action of several of the commands depends on the order 
in which they are executed, as one would logically expect. For instance, 
id:oneChannel removes all decay channels of id 
and thus all previous changes in this decay table, while subsequent 
additions or changes would still take effect. Another example would be that 
23:onMode = off followed by 23:onIfAny = 1 2 3 4 5 
would let the Z^0 decay to quarks, while no decays would be 
allowed if the order were to be reversed. 
 
 
b) The Pythia readString(string) method actually 
does not do changes itself, but sends on the string either to the 
ParticleData class or to the Settings one, 
depending on whether the string begins with a digit or a letter. 
If desired, it is possible to communicate directly with the corresponding 
ParticleData method: 
 
    pythia.particleData.readString("111:mayDecay = off"); 
    pythia.particleData.readString("15:2:products = 16 -211"); 
 
In this case, changes intended for Settings would not be 
understood. 
 
 
c) Underlying this are commands for all the individual properties in 
the ParticleData class, one for each. These are 
further described below. Thus, an example now reads 
 
    pythia.particleData.mayDecay(111, false); 
 
Boolean values should here be given as true or 
false. 
 
 
d) A simpler and more useful way is to collect all your changes 
in a separate file, with one line per change, e.g. 
 
    111:mayDecay = off 
 
The file can be read by the 
 
    pythia.readFile(fileName); 
 
method, where fileName is a string, e.g. 
pythia.readFile("main.cmnd") (or an istream 
instead of a fileName). Each line is processed as 
described for the string in 2a). This file can freely mix commands to 
the Settings and ParticleData classes. 
reInit(fileName) is provided, and can be used to 
zero the particle data table and reinitialize it from scratch. 
Such a call might be useful if several subruns are to be made with 
widely different particle data - normally the maps are only built 
from scratch once, namely when the Pythia() object is 
created. Also, there is no other possibility to restore the default 
values, unlike for the settings. 
 
    pythia.particleData.listAll(); 
 
The listing is by increasing id number. It shows the basic 
quantities introduced above. Some are abbreviated in the header to fit on 
the lines: spn = spinType, chg = chargeType, 
col = colType, res = isResonance, 
dec = mayDecay && canDecay (the latter checks that decay 
channels have been defined), ext = doExternalDecay, 
vis = isVisible and wid = doForceWidth. 
    pythia.particleData.listChanged(); 
 
(This info is based on a further hasChanged flag of a particle 
or a channel, set true whenever any of the changing methods are 
used. It is possible to manipulate this value, but this is not recommended.) 
By default the internal initialization of the widths of resonances such as 
gamma^*/Z^0, W^+-, t/tbar, H^0 do not count as changes; if you want 
to list also those changes instead call listChanged(true). 
id code as argument to 
the list(...) function.. To list a restricted set of particles, 
give in their id codes to list(...) as a 
vector<int>. 
<particle and 
<channel lines already described. You use the method 
particleData.listXML(fileName) to produce such an XML 
file and particleData.readXML(fileName) to read it back 
in after editing. 
 
 
b) Fixed/free format, using exactly the same information as illustrated 
for the <particle and <channel lines 
above, but now without any tags. This means that all information fields 
must be provided (if there is no antiparticle then write 
void), in the correct order (while the order is irrelevant 
with XML syntax), and all on one line. Information is written out in 
properly lined-up columns, but the reading is done using free format, 
so fields need only be separated by at least one blank. Each new particle 
is supposed to be separated by (at least) one blank line, whereas no 
blank lines are allowed between the particle line and the subsequent 
decay channel lines, if any.  You use the method 
particleData.listFF(fileName) to produce such a fixed/free 
file and particleData.readFF(fileName) to read it back 
in after editing. 
 
 
As an alternative to the readXML and readFF 
methods you can also use the 
particleData.reInit(fileName, xmlFormat) method, where 
xmlFormat = true (default) corresponds to reading an XML 
file and xmlFormat = false to a fixed/free format one. 
 
 
To check that the new particle and decay tables makes sense, you can use 
the particleData.checkTable() method, either directly or by 
switching it on among the standard 
error checks. 
void and has an extra last argument, 
namely is the input value, while the output method returns a 
quantity of the expected type. 
 
ParticleData object. 
Can be useful when running with multiple Pythia instances. 
Does not include the links to the resonance decay handling set up by 
initWidths(...). 
   
 
 void ParticleData::initPtr(Info* infoPtr, Settings* settingsPtrIn, Rndm* rndmPtrIn, CoupSM* coupSMPtrIn)   Pythia constructor, i.e. is mainly for 
internal use. 
argument startFile   : Pythia constructor the directory is provided by the 
PYTHIA8DATA 
environment variable, if set, else by the argument of this constructor, 
which has the default value "../share/Pythia8/xmldoc". 
   
   
 
 bool ParticleData::init(const ParticleData& particleDataIn   ParticleData instance. 
   
 
 bool ParticleData::init(istream& is   init above this method is not called by the 
Pythia constructor, but is entirely intended for users 
who want to replace the existing particle data with their own. 
argument startFile   : the path and name of file to be read. 
   
argument xmlFormat   : if true read the same kind of XML-style file 
as used by init, if not use an alternative "free format" 
file (i.e. without any XML tags, but with well-defined rules 
specifying in which order properties are stored). 
   
   
 
 void ParticleData::initWidths( vector<ResonanceWidthsPtr> resonancePtrs)   Pythia::init(). 
   
 
 bool ParticleData::readXML(string inFile, bool reset = true)   init and reInit above. 
   
 
 bool ParticleData::readFF(string inFile, bool reset = true)   reInit above. 
   
 
 bool ParticleData::readString(string line, bool warn = true)   Pythia::readString(...) and 
Pythia::readFile(...). 
argument line   :  
the string to be interpreted as an instruction. 
   
argument warn  (default = on) :  
write a warning message or not whenever the instruction does not make 
sense, e.g. if the particle does not exist in the database. 
   
readString commands that 
have been processed by the ParticleData instance, e.g. for 
inspection. Note that ParticleData commands read by 
Pythia::readString and Pythia::readFile 
are interpreted by readString and thus also are listed. 
   
 
 vector<string> ParticleData::getReadHistory(int subrun)   readString commands that 
have been processed by the ParticleData instance, for a 
specific subrun (see the section on  
Main-Program Settings). For subrun = -1, returns the 
readString history common to all subruns. For 
subrun >= 0, returns the history of readString 
commands for that specific subrun (omitting the common part). 
   
 
 void ParticleData::checkTable(int verbosity)   argument verbosity   :  level of checks. 0 is only minimal, 
e.g. if a particle has no open decay channels. 1, which is the level 
of the first method, provides warning if any individual channel is 
closed, except for resonances. 2 also prints the 
branching-ratio-averaged threshold mass. 11 and 12 are like 1 and 2, 
but also include resonances in the detailed checks. 
   
   
 
 void ParticleData::addParticle(int id, string name = " ", int spinType = 0, int chargeType = 0, int colType = 0, double m0 = 0., double mWidth = 0., double mMin = 0., double mMax = 0., double tau0 = 0.)   void). 
   
 
 int ParticleData::antiId(int id)   -id if 
a distinct antiparticle exists, and id otherwise. 
   
 
 void ParticleData::name(int id, string name)   id determines which of the two is returned, with 
void used to indicate the absence of an antiparticle. 
   
 
 void ParticleData::spinType(int id, int spinType)   id. 
   
 
 double ParticleData::charge(int id)   chargeType(id)/3. 
   
 
 void ParticleData::colType(int id, int colType)   id. 
   
 
 void ParticleData::m0(int id, double m0)   mMin() above, except that for particles with 
no width the m0(id) value is returned. 
   
 
 double ParticleData::m0Max(int id)   mMax() above, except that for particles with 
no width the m0(id) value is returned. 
   
 
 void ParticleData::tau0(int id, double tau0)   m0 above 20 GeV are by default 
initialized to be considered as resonances. 
   
 
 void ParticleData::mayDecay(int id, bool mayDecay)   tau0 below 1000 mm are 
by default initialized to allow decays. 
   
 
 void ParticleData::doExternalDecays(int id, bool doExternalDecays)   pythia.decayPtr 
method should be provided with the list of relevant particles. 
   
 
 void ParticleData::isVisible(int id, bool isVisible)   isResonance above), 
whereby it is possible to force resonances to retain their assigned widths, 
whatever that is, see Resonance Decays 
for details. The normal behaviour is false, i.e. the width 
is based on hardcoded calculations whenever available. 
   
 
 void ParticleData::hasChanged(int id, bool hasChanged)   listChanged method to determine 
which particles to list. 
   
 
 bool ParticleData::useBreitWigner(int id)   ParticleData:modeBreitWigner 
switch. 
   
 
 bool ParticleData::varWidth(int id)   HadronWidths class. 
   
 
 double ParticleData::constituentMass(int id)   m0(id) for 
particles without width. 
   
 
 double ParticleData::mRun(int id, double mH)   id when probed at a 
hard mass scale of mH. Only applied to obtain the 
running quark masses; for all other particle the normal fixed mass 
is used. 
   
 
 bool ParticleData::canDecay(int id)   id number, for a hadron. 
   
 
 int ParticleData::baryonNumberType(int id)   newSumBR. 
   
 
 void setResonancePtr(int id, ResonanceWidthsPtr resonancePtr)   ResonanceWidths object.  This is done, from inside 
ParticleData::initWidths, only for resonances, i.e. for 
particles such as Z^0, W^+-, top, Higgs, and new 
unstable states beyond the Standard Model. The presence of such an 
object will allow a more dynamic calculation of partial and total 
widths, as illustrated by the following methods. 
   
 
 void ParticleData::resInit(int id)   resWidth, where only open channels are 
included, but results are not stored in the normal decay table. 
   
 
 double ParticleData::resWidthStore(int id, double mHat, int idInFlav = 0)   resWidth, where only open channels are 
included, and results are stored in the normal decay table. 
   
 
 double ParticleData::resOpenFrac(int id1, int id2 = 0, int id3 = 0)   ParticleDataEntry object. 
The methods in the next section can then be used to manipulate 
this object. 
   
 
 bool ParticleData::getIsInit()   ParticleDataEntry object are almost identical with 
those used above for the ParticleData, except 
that the id argument is no longer needed to find 
the right entry in the table. By and large, this makes direct 
access to the ParticleDataEntry methods superfluous. 
There are a few methods that are unique to each class, however. 
Furthermore, to avoid some naming ambiguities, many methods that 
set values begin with set. 
 
 ParticleDataEntry::ParticleDataEntry(int id = 0, string name = " ", int spinType = 0, int chargeType = 0, int colType = 0, double m0 = 0., double mWidth = 0., double mMin = 0., double mMax = 0., double tau0 = 0.)   void one reverts back to the particle-only case). 
   
 
 ParticleDataEntry& operator=( const ParticleDataEntry& particleDataEntryIn)   ParticleDataEntry 
object. 
   
 
 void ParticleDataEntry::setDefaults()   setAll. 
   
 
 void ParticleDataEntry::initPtr(ParticleData* particleDataPtrIn)   id is needed to distinguish particle/antiparticle. 
   
 
 void ParticleDataEntry::setSpinType(int spinType)   id is needed 
to distinguish particle/antiparticle. 
   
 
 void ParticleDataEntry::setColType(int colType)   id 
is needed to distinguish particle/antiparticle. 
   
 
 void ParticleDataEntry::setM0(double m0)   mMin() above, except that for particles with 
no width the m0(id) value is returned. 
   
 
 double ParticleDataEntry::m0Max()   mMax() above, except that for particles with 
no width the m0(id) value is returned. 
   
 
 void ParticleDataEntry::setTau0(double tau0, bool countAsChanged = true)   m0 above 20 GeV are by default 
initialized to be considered as resonances. 
   
 
 void ParticleDataEntry::setMayDecay(bool mayDecay)   tau0 below 1000 mm are 
by default initialized to allow decays. 
   
 
 void ParticleDataEntry::setDoExternalDecays(bool doExternalDecays)   pythia.decayPtr 
method should be provided with the list of relevant particles. 
   
 
 void ParticleDataEntry::setIsVisible(bool isVisible)   isResonance above), 
whereby it is possible to force resonances to retain their assigned widths, 
whatever that is, see Resonance Decays 
for details. The normal behaviour is false, i.e. the width 
is based on hardcoded calculations whenever available. 
   
 
 void ParticleDataEntry::setVarWidth(bool varWidth)   HadronWidths class. 
   
 
 void ParticleDataEntry::setHasChanged(bool hasChanged)   ParticleData::listChanged method 
to determine which particles to list. 
   
 
 void ParticleDataEntry::initBWmass()   mH. 
For other particles the on-shell mass is given. 
   
 
 bool ParticleDataEntry::useBreitWigner()    
ParticleData:modeBreitWigner switch. 
   
 
 bool ParticleDataEntry::canDecay(int id)   id number, for a hadron. Only the sign of the input 
argument is relevant. 
   
 
 int ParticleDataEntry::baryonNumberType(int id)   newSumBR. 
   
 
 bool ParticleDataEntry::preparePick(int idSgn, double mHat = 0., int idInFlav = 0)   preparePick. 
   
 
 void ParticleDataEntry::setResonancePtr(ResonanceWidthsPtr resonancePtr)   resWidth, where only open channels are 
included, but results are not stored in the normal decay table. 
   
 
 double ParticleDataEntry::resWidthStore(int idSgn, double mHat, int idInFlav = 0)   resWidth, where only open channels are 
included, and results are stored in the normal decay table. 
   
 
 double ParticleDataEntry::resOpenFrac(int idSgn)   DecayChannel object. 
   
 
 void DecayChannel::onMode(int onMode)   onMode of a decay channel,fac. 
   
 
 void DecayChannel::meMode(int meMode)   factor. 
   
 
 void DecayChannel::openSec(int idSgn, double openSecIn)