G4INCL::ParticleSpecies Class Reference

#include <G4INCLParticleSpecies.hh>

Collaboration diagram for G4INCL::ParticleSpecies:

Public Member Functions
	ParticleSpecies ()
	Convert a string to a particle species. More...
	ParticleSpecies (std::string const &pS)
	ParticleSpecies (ParticleType const t)
	ParticleSpecies (const G4int A, const G4int Z)

Public Attributes
ParticleType	theType
G4int	theA
G4int	theZ

Private Member Functions
void	parseNuclide (std::string const &pS)
	Parse a nuclide name. More...
G4bool	parseElement (std::string const &pS)
	Parse an element name. More...
G4bool	parseIUPACElement (std::string const &s)
	Parse a IUPAC element name. More...

Detailed Description

Definition at line 53 of file G4INCLParticleSpecies.hh.

Constructor & Destructor Documentation

ParticleSpecies() [1/4]

G4INCL::ParticleSpecies::ParticleSpecies ( )

inline

Convert a string to a particle species.

Definition at line 56 of file G4INCLParticleSpecies.hh.

                        :
        theType(UnknownParticle),
        theA(0),
        theZ(0)
    {}

Here is the call graph for this function:

Here is the caller graph for this function:

ParticleSpecies() [2/4]

G4INCL::ParticleSpecies::ParticleSpecies

(

std::string const &

pS

)

Definition at line 54 of file G4INCLParticleSpecies.cc.

                                                      {
    // Normalise the string to lower case
    if(pS=="p" || pS=="proton") {
      theA = 1;
      theZ = 1;
      theType = G4INCL::Proton;
    } else if(pS=="n" || pS=="neutron") {
      theA = 1;
      theZ = 0;
      theType = G4INCL::Neutron;
    } else if(pS=="delta++" || pS=="deltaplusplus") {
      theA = 1;
      theZ = 2;
      theType = G4INCL::DeltaPlusPlus;
    } else if(pS=="delta+" || pS=="deltaplus") {
      theA = 1;
      theZ = 1;
      theType = G4INCL::DeltaPlus;
    } else if(pS=="delta0" || pS=="deltazero") {
      theA = 1;
      theZ = 0;
      theType = G4INCL::DeltaZero;
    } else if(pS=="delta-" || pS=="deltaminus") {
      theA = 1;
      theZ = -1;
      theType = G4INCL::DeltaMinus;
    } else if(pS=="pi+" || pS=="pion+" || pS=="piplus" || pS=="pionplus") {
      theA = 0;
      theZ = 1;
      theType = G4INCL::PiPlus;
    } else if(pS=="pi0" || pS=="pion0" || pS=="pizero" || pS=="pionzero") {
      theA = 0;
      theZ = 0;
      theType = G4INCL::PiZero;
    } else if(pS=="pi-" || pS=="pion-" || pS=="piminus" || pS=="pionminus") {
      theA = 0;
      theZ = -1;
      theType = G4INCL::PiMinus;
    } else if(pS=="d" || pS=="deuteron") {
      theA = 2;
      theZ = 1;
      theType = G4INCL::Composite;
    } else if(pS=="t" || pS=="triton") {
      theA = 3;
      theZ = 1;
      theType = G4INCL::Composite;
    } else if(pS=="a" || pS=="alpha") {
      theA = 4;
      theZ = 2;
      theType = G4INCL::Composite;
    } else
      parseNuclide(pS);
  }

Here is the call graph for this function:

ParticleSpecies() [3/4]

G4INCL::ParticleSpecies::ParticleSpecies

(

ParticleType const

t

)

Definition at line 108 of file G4INCLParticleSpecies.cc.

                                                       :
    theType(t),
    theA(ParticleTable::getMassNumber(theType)),
    theZ(ParticleTable::getChargeNumber(theType))
  {}

ParticleSpecies() [4/4]

G4INCL::ParticleSpecies::ParticleSpecies	(	const G4int	A,
		const G4int	Z
	)

Definition at line 114 of file G4INCLParticleSpecies.cc.

                                                               :
    theType(Composite),
    theA(A),
    theZ(Z)
  {}

Member Function Documentation

parseElement()

G4bool G4INCL::ParticleSpecies::parseElement ( std::string const &  pS )

private

Parse an element name.

Note: this function is UGLY. Look at it at your own peril.

Parameters

pS	a normalised string (lowercase)

Returns

true if the parsing succeeded

Definition at line 237 of file G4INCLParticleSpecies.cc.

                                                         {
    theZ = ParticleTable::parseElement(s);

    if(theZ<0)
      theZ = ParticleTable::parseIUPACElement(s);

    if(theZ<0)
      return false;
    else
      return true;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

parseIUPACElement()

G4bool G4INCL::ParticleSpecies::parseIUPACElement ( std::string const &  s )

private

Parse a IUPAC element name.

Note: this function is UGLY. Look at it at your own peril.

Parameters

s	a normalised string (lowercase)

Returns

true if the parsing succeeded

Definition at line 249 of file G4INCLParticleSpecies.cc.

                                                              {
    theZ = ParticleTable::parseIUPACElement(s);
    if(theZ==0)
      return false;
    else
      return true;
  }

Here is the call graph for this function:

parseNuclide()

void G4INCL::ParticleSpecies::parseNuclide ( std::string const &  pS )

private

Parse a nuclide name.

Note: this function is UGLY. Look at it at your own peril.

Parameters

pS	a normalised string (lowercase)

Definition at line 120 of file G4INCLParticleSpecies.cc.

                                                        {
    theType = Composite;

    // Allowed characters
    const std::string separators("-_");
    std::string allowed("0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ");
    allowed += separators;

    // There must be at least one character
    if(pS.find_first_not_of(allowed)!=std::string::npos) {
      // Malformed input string
      // Setting unknown particle species
      (*this) = ParticleSpecies(UnknownParticle);
      return;
    }
    if(pS.size()<1) {
      // Malformed input string
      // Setting unknown particle species
      (*this) = ParticleSpecies(UnknownParticle);
      return;
    }

    std::size_t firstSeparator = pS.find_first_of(separators);
    std::size_t lastSeparator = pS.find_last_of(separators);
    if(firstSeparator!=std::string::npos && firstSeparator!=lastSeparator) {
      // Several separators in malformed input string
      // Setting unknown particle species
      (*this) = ParticleSpecies(UnknownParticle);
      return;
    }

    // Identify the type of the first character
    G4int (*predicate)(G4int);
    G4bool startsWithAlpha = std::isalpha(pS.at(0));
    if(startsWithAlpha) {
      predicate=std::isdigit;
    } else if(std::isdigit(pS.at(0))) {
      predicate=std::isalpha;
    } else {
      // Non-alphanumeric character in string
      // Setting unknown particle species
      (*this) = ParticleSpecies(UnknownParticle);
      return;
    }

    G4bool hasIsotope = true;
    size_t endFirstSection, beginSecondSection;
    if(firstSeparator==std::string::npos) {
      // No separator, Fe56 or 56Fe style
      // Identify the end of the first section

      // Find the first character that is not of the same type as the first one
      beginSecondSection = std::find_if(pS.begin()+1, pS.end(), predicate) - pS.begin();

      if(beginSecondSection>=pS.size()) {
        if(startsWithAlpha) {
          // Only alphabetic characters are present -- must be an element name
          hasIsotope = false;
        } else {
          // Only numeric characters in the string
          // Setting unknown particle species
          (*this) = ParticleSpecies(UnknownParticle);
          return;
        }
      }

      endFirstSection = beginSecondSection;

    } else {
      // One separator, Fe-56 or 56-Fe style
      endFirstSection = firstSeparator;
      beginSecondSection = firstSeparator+1;
    }

    std::string firstSection(pS.substr(0,endFirstSection));
    std::string secondSection(pS.substr(beginSecondSection,std::string::npos));
    std::stringstream parsingStream;

    // Parse the sections
    G4bool success;
    if(startsWithAlpha) {
      parsingStream.str(secondSection);
      success = parseElement(firstSection);
    } else {
      parsingStream.str(firstSection);
      success = parseElement(secondSection);
    }
    if(!success) {
      // Couldn't parse the element section
      // Setting unknown particle species
      (*this) = ParticleSpecies(UnknownParticle);
      return;
    }

    if(hasIsotope) {
      parsingStream >> theA;
      if(parsingStream.fail()) {
        // Couldn't parse the mass section
        // Setting unknown particle species
        (*this) = ParticleSpecies(UnknownParticle);
        return;
      }
    } else
      theA = 0;

    // Check that Z<=A
    if(theZ>theA && hasIsotope) {
      // Setting unknown particle species
      (*this) = ParticleSpecies(UnknownParticle);
      return;
    }

    // Special particle type for protons
    if(theZ==1 && theA==1)
      theType = Proton;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

theA

G4int G4INCL::ParticleSpecies::theA

Definition at line 66 of file G4INCLParticleSpecies.hh.

theType

ParticleType G4INCL::ParticleSpecies::theType

Definition at line 65 of file G4INCLParticleSpecies.hh.

theZ

G4int G4INCL::ParticleSpecies::theZ

Definition at line 66 of file G4INCLParticleSpecies.hh.

---

The documentation for this class was generated from the following files:

• G4INCLParticleSpecies.hh
• G4INCLParticleSpecies.cc