G4IonTable Class Reference

#include <G4IonTable.hh>

Public Types
enum	{ numberOfElements = 118 }
typedef std::multimap< G4int, const G4ParticleDefinition * >	G4IonList
typedef std::multimap< G4int, const G4ParticleDefinition * > ::iterator	G4IonListIterator

Public Member Functions
	G4IonTable ()
void	SlaveG4IonTable ()
void	WorkerG4IonTable ()
virtual	~G4IonTable ()
G4int	GetNumberOfElements () const
void	RegisterIsotopeTable (G4VIsotopeTable *table)
G4VIsotopeTable *	GetIsotopeTable (size_t idx=0) const
void	CreateAllIon ()
void	CreateAllIsomer ()
void	PreloadNuclide ()
G4ParticleDefinition *	GetIon (G4int Z, G4int A, G4int lvl=0)
G4ParticleDefinition *	GetIon (G4int Z, G4int A, G4int L, G4int lvl)
G4ParticleDefinition *	GetIon (G4int Z, G4int A, G4double E, G4int J=0)
G4ParticleDefinition *	GetIon (G4int Z, G4int A, G4int L, G4double E, G4int J=0)
G4ParticleDefinition *	GetIon (G4int encoding)
G4ParticleDefinition *	FindIon (G4int Z, G4int A, G4int lvl=0)
G4ParticleDefinition *	FindIon (G4int Z, G4int A, G4int L, G4int lvl)
G4ParticleDefinition *	FindIon (G4int Z, G4int A, G4double E, G4int J=0)
G4ParticleDefinition *	FindIon (G4int Z, G4int A, G4int L, G4double E, G4int J=0)
const G4String &	GetIonName (G4int Z, G4int A, G4int lvl=0) const
const G4String &	GetIonName (G4int Z, G4int A, G4double E) const
const G4String &	GetIonName (G4int Z, G4int A, G4int L, G4double E) const
const G4String &	GetIonName (G4int Z, G4int A, G4int L, G4int lvl) const
G4double	GetIonMass (G4int Z, G4int A, G4int L=0, G4int lvl=0) const
G4double	GetNucleusMass (G4int Z, G4int A, G4int L=0, G4int lvl=0) const
G4double	GetIsomerMass (G4int Z, G4int A, G4int lvl=0) const
G4double	GetLifeTime (const G4ParticleDefinition *) const
G4int	Entries () const
G4ParticleDefinition *	GetParticle (G4int index) const
G4bool	Contains (const G4ParticleDefinition *particle) const
void	Insert (const G4ParticleDefinition *particle)
void	Remove (const G4ParticleDefinition *particle)
void	clear ()
G4int	size () const
void	DumpTable (const G4String &particle_name="ALL") const
void	InitializeLightIons ()

Static Public Member Functions
static G4IonTable *	GetIonTable ()
static G4bool	IsIon (const G4ParticleDefinition *)
static G4bool	IsAntiIon (const G4ParticleDefinition *)
static G4int	GetNucleusEncoding (G4int Z, G4int A, G4double E=0.0, G4int lvl=0)
static G4int	GetNucleusEncoding (G4int Z, G4int A, G4int L, G4double E=0.0, G4int lvl=0)
static G4bool	GetNucleusByEncoding (G4int encoding, G4int &Z, G4int &A, G4double &E, G4int &lvl)
static G4bool	GetNucleusByEncoding (G4int encoding, G4int &Z, G4int &A, G4int &L, G4double &E, G4int &lvl)

Static Public Attributes
static G4ThreadLocal G4IonList *	fIonList = 0
static G4ThreadLocal std::vector< G4VIsotopeTable * > *	fIsotopeTableList = 0
static G4IonList *	fIonListShadow = 0
static std::vector < G4VIsotopeTable * > *	fIsotopeTableListShadow = 0
static const G4double	tolerance = 2.0*keV
static const G4String	elementName [numberOfElements]

Protected Member Functions
	G4IonTable (const G4IonTable &right)
G4IonTable &	operator= (const G4IonTable &)
G4ParticleDefinition *	FindIonInMaster (G4int Z, G4int A, G4int lvl=0)
G4ParticleDefinition *	FindIonInMaster (G4int Z, G4int A, G4int L, G4int lvl)
G4ParticleDefinition *	FindIonInMaster (G4int Z, G4int A, G4double E, G4int J=0)
G4ParticleDefinition *	FindIonInMaster (G4int Z, G4int A, G4int L, G4double E, G4int J=0)
G4ParticleDefinition *	CreateIon (G4int Z, G4int A, G4double E)
G4ParticleDefinition *	CreateIon (G4int Z, G4int A, G4int L, G4double E)
G4ParticleDefinition *	CreateIon (G4int Z, G4int A, G4int lvl=0)
G4ParticleDefinition *	CreateIon (G4int Z, G4int A, G4int L, G4int lvl)
void	InsertWorker (const G4ParticleDefinition *particle)
G4IsotopeProperty *	FindIsotope (G4int Z, G4int A, G4double E) const
G4IsotopeProperty *	FindIsotope (G4int Z, G4int A, G4int lvl) const
G4ParticleDefinition *	GetLightIon (G4int Z, G4int A) const
G4ParticleDefinition *	GetLightAntiIon (G4int Z, G4int A) const
G4bool	IsLightIon (const G4ParticleDefinition *) const
G4bool	IsLightAntiIon (const G4ParticleDefinition *) const
void	AddProcessManager (G4ParticleDefinition *)
G4int	GetVerboseLevel () const

Detailed Description

Definition at line 67 of file G4IonTable.hh.

Member Typedef Documentation

typedef std::multimap<G4int, const G4ParticleDefinition*> G4IonTable::G4IonList

Definition at line 76 of file G4IonTable.hh.

typedef std::multimap<G4int, const G4ParticleDefinition*>::iterator G4IonTable::G4IonListIterator

Definition at line 77 of file G4IonTable.hh.

Member Enumeration Documentation

anonymous enum

Enumerator
numberOfElements

Definition at line 301 of file G4IonTable.hh.

{ numberOfElements = 118};

Constructor & Destructor Documentation

G4IonTable::G4IonTable

(

)

Definition at line 120 of file G4IonTable.cc.

References fIonList, fIonListShadow, fIsotopeTableList, and fIsotopeTableListShadow.

  : pIsomerTable(0),pNuclideTable(0),
    isIsomerCreated(false),
    n_error(0)
{
  fIonList = new G4IonList();

  // Set up the shadow pointer used by worker threads.
  //
  if (fIonListShadow == 0)
  {
    fIonListShadow = fIonList;
  }

  fIsotopeTableList = new std::vector<G4VIsotopeTable*>;

  // Set up the shadow pointer used by worker threads.
  //
  if (fIsotopeTableListShadow == 0)
  {
    fIsotopeTableListShadow = fIsotopeTableList;
  }    
}

G4IonTable::G4IonTable ( const G4IonTable &  right )

protected

G4IonTable::~G4IonTable ( )

virtual

Definition at line 185 of file G4IonTable.cc.

References fIonList, fIsotopeTableList, and G4NuclideTable::GetNuclideTable().

{
  // delete IsotopeTable if exists
  if (fIsotopeTableList != 0)
  {
    for (size_t i = 0; i< fIsotopeTableList->size(); ++i)
    {
      G4VIsotopeTable* fIsotopeTable= (*fIsotopeTableList)[i];
      //delete fIsotopeTable;
      if( fIsotopeTable != G4NuclideTable::GetNuclideTable() ) delete fIsotopeTable;
    }
    fIsotopeTableList->clear();
    delete fIsotopeTableList;
  }
  fIsotopeTableList =0;


  if (fIonList ==0) return;
  // remove all contents in the Ion List 
  //  No need to delete here because all particles are dynamic objects
  fIonList->clear();

  delete fIonList;
  fIonList =0;
}

Member Function Documentation

void G4IonTable::AddProcessManager ( G4ParticleDefinition *  ion )

protected

Definition at line 1401 of file G4IonTable.cc.

References FatalException, G4cout, G4endl, G4Exception(), G4ParticleTable::GetGenericIon(), G4ParticleDefinition::GetParticleDefinitionID(), G4ParticleDefinition::GetParticleName(), G4ParticleTable::GetParticleTable(), G4ParticleDefinition::GetProcessManager(), and G4ParticleDefinition::SetParticleDefinitionID().

Referenced by CreateIon().

{
  // check State and do not attach process managaer in event loop
//  G4StateManager* pStateManager = G4StateManager::GetStateManager();
//  G4ApplicationState currentState = pStateManager->GetCurrentState();
//  if (currentState == G4State_EventProc) return;
//  {
//    if (n_error<10)
//    {
//      G4cout << "Defining process manager for " << ion->GetParticleName() << G4endl;
//      G4Exception("G4IonTable::AddProcessManager()", "PART130", JustWarning,
//  "Defining process manager during an event loop is thread unsafe and will be dropped from the next release.");
//      n_error +=1;
//    }
//    return;
//  }

  // check whether GenericIon has processes
  G4ParticleDefinition* genericIon = 
    G4ParticleTable::GetParticleTable()->GetGenericIon();

  G4ProcessManager* pman=0;
  if (genericIon!=0) pman = genericIon->GetProcessManager();
  if ((genericIon ==0) || (genericIon->GetParticleDefinitionID() < 0) || (pman==0)){
    G4cout << "G4IonTable::AddProcessManager() : can not create ion of  " 
           << ion->GetParticleName()
           << "  because GenericIon is not available!!" <<   G4endl;
    G4Exception( "G4IonTable::AddProcessManager()","PART105", FatalException, 
         "Can not create ions because GenericIon is not available");
    return;
  }
  
////////  ion->SetProcessManager(pman);
  ion->SetParticleDefinitionID(genericIon->GetParticleDefinitionID());
}

void G4IonTable::clear

(

void

)

Definition at line 1242 of file G4IonTable.cc.

References fIonList, G4cout, G4endl, G4Exception(), G4ParticleTable::GetParticleTable(), GetVerboseLevel(), and JustWarning.

Referenced by G4ParticleTable::RemoveAllParticles().

{
  if (G4ParticleTable::GetParticleTable()->GetReadiness()) {
    G4Exception("G4IonTable::clear()",
        "PART116", JustWarning,
        "No effects because readyToUse is true.");    
    return;
  }

#ifdef G4VERBOSE
    if (GetVerboseLevel()>2) {
      G4cout << "G4IonTable::Clear() : number of Ion regsitered =  "; 
      G4cout << fIonList->size() <<  G4endl;
    }
#endif
  fIonList->clear();
}

G4bool G4IonTable::Contains

(

const G4ParticleDefinition *

particle

)

const

Definition at line 1562 of file G4IonTable.cc.

References fIonListShadow, G4ParticleDefinition::GetAtomicMass(), G4ParticleDefinition::GetAtomicNumber(), GetNucleusEncoding(), G4ParticleDefinition::GetQuarkContent(), and IsIon().

Referenced by Insert().

{
  if (!IsIon(particle)) return false;

  G4int Z = particle->GetAtomicNumber();
  G4int A = particle->GetAtomicMass();  
  G4int L = particle->GetQuarkContent(3);  //strangeness 
  G4int encoding=GetNucleusEncoding(Z, A, L);
  G4bool found = false;
  if (encoding !=0 ) {
    G4IonList::iterator i = fIonListShadow->find(encoding);
    for( ;i != fIonListShadow->end() ; i++) {
      if (particle == i->second ) {
    found  = true;
    break;
      }
    }
  }
  return found;
}

void G4IonTable::CreateAllIon

(

)

Definition at line 1502 of file G4IonTable.cc.

References PreloadNuclide().

Referenced by G4ParticleMessenger::SetNewValue().

{
  PreloadNuclide();
}

void G4IonTable::CreateAllIsomer

(

)

Definition at line 1508 of file G4IonTable.cc.

References PreloadNuclide().

Referenced by G4RunManagerKernel::InitializePhysics(), and G4ParticleMessenger::SetNewValue().

{
  PreloadNuclide();
}

G4ParticleDefinition * G4IonTable::CreateIon ( G4int  Z, G4int  A, G4double  E  )

protected

Definition at line 215 of file G4IonTable.cc.

References AddProcessManager(), encoding, python.hepunit::eplus, FindIsotope(), G4cout, G4endl, G4Exception(), G4IsotopeProperty::GetDecayTable(), G4IsotopeProperty::GetEnergy(), G4ParticleTable::GetGenericIon(), GetIonName(), G4IsotopeProperty::GetIsomerLevel(), G4IsotopeProperty::GetiSpin(), G4IsotopeProperty::GetLifeTime(), G4IsotopeProperty::GetMagneticMoment(), GetNucleusEncoding(), GetNucleusMass(), G4ParticleDefinition::GetParticleDefinitionID(), G4ParticleTable::GetParticleTable(), G4ParticleDefinition::GetProcessManager(), GetVerboseLevel(), JustWarning, python.hepunit::keV, python.hepunit::MeV, G4NuclideTable::Round(), G4ParticleDefinition::SetAntiPDGEncoding(), and G4ParticleDefinition::SetPDGMagneticMoment().

Referenced by CreateIon(), and GetIon().

{
  G4ParticleDefinition* ion=0;

  // check whether GenericIon has processes
  G4ParticleDefinition* genericIon = 
    G4ParticleTable::GetParticleTable()->GetGenericIon();
  G4ProcessManager* pman=0;
  if (genericIon!=0) pman = genericIon->GetProcessManager();
  if ((genericIon ==0) || (genericIon->GetParticleDefinitionID() < 0) || (pman==0)){
#ifdef G4VERBOSE
    if (GetVerboseLevel()>1) {
      G4cout << "G4IonTable::CreateIon() : can not create ion of  " 
             << " Z =" << Z << "  A = " << A 
             << "  because GenericIon is not ready !!" <<   G4endl;
    }
#endif
    G4Exception( "G4IonTable::CreateIon()","PART105",
         JustWarning, 
         "Can not create ions because GenericIon is not ready");
    return 0;
  }
  
  G4double life = -1.0;
  G4DecayTable* decayTable =0;
  G4bool stable = true;
  G4double mu = 0.0;
  G4double Eex = 0.0;
  G4int    lvl =0;
  G4int    J=0;

  const G4IsotopeProperty*  fProperty = FindIsotope(Z, A, E);
  if (fProperty !=0 ){
    Eex  = fProperty->GetEnergy();
    lvl  = fProperty->GetIsomerLevel();
    J    = fProperty->GetiSpin();
    life = fProperty->GetLifeTime();
    mu   = fProperty->GetMagneticMoment();    
    decayTable = fProperty->GetDecayTable();
    stable = (life <= 0.) || (decayTable ==0);
    lvl = fProperty->GetIsomerLevel();
    if (lvl <0) lvl=9;
  } else {
#ifdef G4VERBOSE
    if (GetVerboseLevel()>1) {
      G4ExceptionDescription ed;
      ed << "G4IonTable::CreateIon() : G4IsotopeProperty object was not found for"
         << " Z = " << Z << " A = " << A << " E = " << E/keV << " (keV).\n"
         << " Physics quantities such as life are not set for this ion.";
      G4Exception( "G4IonTable::CreateIon()","PART70105", JustWarning, ed);
    }
#endif
    // excitation energy
    Eex = E;
    // lvl is assigned to 9 temporally    
    if (Eex>0.0) lvl=9;
  }

  Eex = G4NuclideTable::Round(Eex); 
  if (Eex==0.0) lvl=0;
  // ion name
  G4String name =""; 
  /////////////if (lvl<9) name = GetIonName(Z, A, lvl);
  if (lvl==0) name = GetIonName(Z, A, lvl);
  else       name = GetIonName(Z, A, Eex);

  // PDG encoding 
  G4int encoding = GetNucleusEncoding(Z,A,E,lvl);

//G4cout<<"G4IonTable::CreateIon "<<"Z:"<<Z<<" A:"<<A<<" E:"<<E<<" Eex:"<<Eex<<" lvl:"<<lvl<<" name:"<<name<<" code:"<<encoding<<G4endl;
  // PDG mass
  G4double mass =  GetNucleusMass(Z, A)+ Eex;
 
  // PDG charge is set to one of nucleus
  G4double charge =  G4double(Z)*eplus;
 
  // create an ion
  //   spin, parity, isospin values are fixed

  // Request lock for particle table accesses. Some changes are inside 
  // this critical region.
  //

  ion = new G4Ions(   name,            mass,       0.0*MeV,     charge, 
             J,              +1,             0,          
             0,               0,             0,             
         "nucleus",               0,             A,    encoding,
            stable,            life,    decayTable,       false,
         "generic",               0,
               Eex,             lvl         );

  // Release lock for particle table accesses.
  //

  ion->SetPDGMagneticMoment(mu);

  //No Anti particle registered
  ion->SetAntiPDGEncoding(0);
  
#ifdef G4VERBOSE
  if (GetVerboseLevel()>1) {
    G4cout << "G4IonTable::CreateIon() : create ion of " << name
       << "  " << Z << ", " << A
       << " encoding=" << encoding;
    if (E>0.0) {
      G4cout << " IsomerLVL=" << lvl
         << " excited energy=" << Eex/keV << "[keV]";
    }
    G4cout << G4endl;
  } 
#endif
  
  // Add process manager to the ion
  AddProcessManager(ion);
 
  return ion;
}

G4ParticleDefinition * G4IonTable::CreateIon ( G4int  Z, G4int  A, G4int  L, G4double  E  )

protected

Definition at line 335 of file G4IonTable.cc.

References AddProcessManager(), CreateIon(), encoding, python.hepunit::eplus, G4cout, G4endl, G4Exception(), G4ParticleTable::GetGenericIon(), GetIonName(), GetNucleusEncoding(), GetNucleusMass(), G4ParticleDefinition::GetParticleDefinitionID(), G4ParticleTable::GetParticleTable(), G4ParticleDefinition::GetProcessManager(), GetVerboseLevel(), JustWarning, python.hepunit::keV, python.hepunit::MeV, G4NuclideTable::Round(), G4ParticleDefinition::SetAntiPDGEncoding(), and G4ParticleDefinition::SetPDGMagneticMoment().

{
  if (L==0) return CreateIon(A,Z,E);
  
  // create hyper nucleus
  G4ParticleDefinition* ion=0;

  // check whether GenericIon has processes
  G4ParticleDefinition* genericIon = 
    G4ParticleTable::GetParticleTable()->GetGenericIon();
  G4ProcessManager* pman=0;
  if (genericIon!=0) pman = genericIon->GetProcessManager();
  if ((genericIon ==0) || (genericIon->GetParticleDefinitionID() < 0) || (pman==0)){
#ifdef G4VERBOSE
    if (GetVerboseLevel()>1) {
      G4cout << "G4IonTable::CreateIon() : can not create ion of  " 
             << " Z =" << Z << "  A = " << A 
             << "  because GenericIon is not ready !!" <<   G4endl;
    }
#endif
    G4Exception( "G4IonTable::CreateIon()","PART105", JustWarning, 
         "Can not create ions because GenericIon is not ready");
    return 0;
  }
 
  G4int J=0;
  G4double life = -1.0;
  G4DecayTable* decayTable =0;
  G4bool stable = true;
 
  // excitation energy
  G4double Eex = G4NuclideTable::Round(E); 
  G4double mass =  GetNucleusMass(Z, A, L)+ Eex;
  G4int    lvl = 0;
  // lvl is assigned to 9 temporally
  if (Eex>0.0) lvl=9;
   
  // PDG encoding 
  G4int encoding = GetNucleusEncoding(Z,A,L,E,lvl);

  // PDG charge is set to one of nucleus
  G4double charge =  G4double(Z)*eplus;

  // create an ion
  //   spin, parity, isospin values are fixed
  //
  // get ion name
  G4String name = GetIonName(Z, A, L, Eex);
  
  ion = new G4Ions(   name,            mass,       0.0*MeV,     charge, 
             J,              +1,             0,          
             0,               0,             0,             
         "nucleus",               0,             A,    encoding,
            stable,            life,    decayTable,       false,
          "generic",              0,
              Eex,              lvl         );

  // Release lock for particle table accesses.
  //
 
  G4double mu = 0.0; //  magnetic moment
  ion->SetPDGMagneticMoment(mu);

  //No Anti particle registered
  ion->SetAntiPDGEncoding(0);
  
#ifdef G4VERBOSE
   if (GetVerboseLevel()>1) {
    G4cout << "G4IonTable::CreateIon() : create hyper ion of " << name
       << "  " << Z << ", " << A << ", " << L
       << " encoding=" << encoding;
    if (E>0.0) {
      G4cout << " IsomerLVL=" << lvl
         << " excited energy=" << Eex/keV << "[keV]";
    }
    G4cout << G4endl;
  } 
#endif
  
  // Add process manager to the ion
  AddProcessManager(ion);
      
  return ion;
}

G4ParticleDefinition * G4IonTable::CreateIon ( G4int  Z, G4int  A, G4int  lvl = 0  )

protected

Definition at line 421 of file G4IonTable.cc.

References CreateIon(), G4Exception(), and JustWarning.

{
  if(lvl == 0) return CreateIon(Z,A,0.0);
  G4Exception( "G4IonTable::CreateIon()","PART105", JustWarning, 
      "Ion cannot be created by an isomer level. Use excitation energy.");
  return 0;
}

G4ParticleDefinition * G4IonTable::CreateIon ( G4int  Z, G4int  A, G4int  L, G4int  lvl  )

protected

Definition at line 431 of file G4IonTable.cc.

References CreateIon(), G4Exception(), and JustWarning.

{
  if (L==0) return CreateIon(A,Z,lvl);
  
  if (lvl>0) {
    G4ExceptionDescription ed;
    ed << "Isomer level " << lvl << " is unknown for the isotope (Z="
       << Z << ", A=" << A << ", L=" << L << "). Null pointer is returned.";
    G4Exception( "G4IonTable::GetIon()","PART106", JustWarning, ed);
    return 0;
  }
  
  return CreateIon(A,Z,L,0.0);
}

void G4IonTable::DumpTable

(

const G4String &

particle_name = "ALL"

)

const

Definition at line 1363 of file G4IonTable.cc.

References G4ParticleDefinition::DumpTable(), fIonList, and G4ParticleDefinition::GetParticleName().

{
  const G4ParticleDefinition* ion;
  G4IonList::iterator idx;
  for (idx = fIonList->begin(); idx!= fIonList->end(); ++idx) {
    ion = idx->second;
    if (( particle_name == "ALL" ) || (particle_name == "all")){
      ion->DumpTable();
    } else if ( particle_name == ion->GetParticleName() ) {
      ion->DumpTable();
    }
  }
}

G4int G4IonTable::Entries

(

)

const

Definition at line 1584 of file G4IonTable.cc.

References fIonList.

Referenced by DMXPhysicsList::ConstructGeneral(), and GetParticle().

{
  return fIonList->size();
}

G4ParticleDefinition * G4IonTable::FindIon	(	G4int	Z,
		G4int	A,
		G4int	lvl = 0
	)

Definition at line 754 of file G4IonTable.cc.

References fIonList, G4cout, G4endl, G4Exception(), G4ParticleDefinition::GetAtomicMass(), G4ParticleDefinition::GetAtomicNumber(), GetLightIon(), GetNucleusEncoding(), GetVerboseLevel(), and JustWarning.

Referenced by G4ParticleTable::FindIon(), FindIon(), FindIonInMaster(), and GetIon().

{
  if ( (A<1) || (Z<=0) || (lvl<0) || (A>999) ) {
#ifdef G4VERBOSE
    if (GetVerboseLevel()>0) {
      G4cout << "G4IonTable::FindIon() : illegal atomic number/mass or excitation level " 
             << " Z =" << Z << "  A = " << A <<  "  IsoLvl = " << lvl << G4endl;
    }
#endif
    G4Exception( "G4IonTable::FindIon()","PART107",
         JustWarning, "illegal atomic number/mass");
    return 0;
  }
  // Search ions with A, Z ,E
  //  !! J is omitted now !!
  const G4ParticleDefinition* ion=0;
  G4bool isFound = false;

  // check if light ion
  ion = GetLightIon(Z,A);
  if (ion!=0 && lvl==0) { 
    // light ion 
    isFound = true;
  } else {    
    // -- loop over all particles in Ion table
    G4int encoding=GetNucleusEncoding(Z, A);
    G4IonList::iterator i = fIonList->find(encoding);
    for( ;i != fIonList->end() ; i++) {
      ion = i->second;
      if ( ( ion->GetAtomicNumber() != Z) || (ion->GetAtomicMass()!=A) ) break;
      // excitation level
      if ( ((const G4Ions*)(ion))->GetIsomerLevel() == lvl) {
    isFound = true;
    break;
      }
    } 
  }

  if ( isFound ){ 
    if(lvl==9)
    {
      G4Exception("G4IonTable::FindIon()","PART5107",JustWarning,
        "Isomer level 9 may be ambiguous.");
    }
    return const_cast<G4ParticleDefinition*>(ion);
  } else {
    return 0;
  }
}

G4ParticleDefinition * G4IonTable::FindIon	(	G4int	Z,
		G4int	A,
		G4int	L,
		G4int	lvl
	)

Definition at line 806 of file G4IonTable.cc.

References FindIon(), fIonList, G4cout, G4endl, G4Exception(), G4ParticleDefinition::GetAtomicMass(), G4ParticleDefinition::GetAtomicNumber(), GetNucleusEncoding(), G4ParticleDefinition::GetQuarkContent(), GetVerboseLevel(), and JustWarning.

{
  if (L==0) return FindIon(Z,A,lvl);
  
  if (A < 2 || Z < 0 || Z > A-L || L>A || A>999 ) {
#ifdef G4VERBOSE
    if (GetVerboseLevel()>0) {
      G4cout << "G4IonTable::FindIon() : illegal atomic number/mass or excitation level " 
             << " Z =" << Z << "  A = " << A << " L = " << L 
         <<"  IsomerLvl = " << lvl << G4endl;
    }    
#endif
    G4Exception( "G4IonTable::FindIon()","PART107",
         JustWarning, "illegal atomic number/mass");
    return 0;
  }
  // Search ions with A, Z ,E, lvl
  const G4ParticleDefinition* ion=0;
  G4bool isFound = false;

  // -- loop over all particles in Ion table
  G4int encoding=GetNucleusEncoding(Z, A, L);
  G4IonList::iterator i = fIonList->find(encoding);
  for( ;i != fIonList->end() ; i++) {
    ion = i->second;
    if ( ( ion->GetAtomicNumber() != Z) || (ion->GetAtomicMass()!=A) ) break;
    if ( ion->GetQuarkContent(3) != L) break;
    // excitation level
    if ( ((const G4Ions*)(ion))->GetIsomerLevel() == lvl) {
      isFound = true;
      break;
    }
  }

  if ( isFound ){ 
    if(lvl==9)
    {
      G4Exception("G4IonTable::FindIon()","PART5107",JustWarning,
        "Isomer level 9 may be ambiguous.");
    }
    return const_cast<G4ParticleDefinition*>(ion);
  } else {
    return 0;
  }
}

G4ParticleDefinition * G4IonTable::FindIon	(	G4int	Z,
		G4int	A,
		G4double	E,
		G4int	J = 0
	)

Definition at line 661 of file G4IonTable.cc.

References fIonList, G4cout, G4endl, G4Exception(), G4ParticleDefinition::GetAtomicMass(), G4ParticleDefinition::GetAtomicNumber(), GetLightIon(), GetNucleusEncoding(), GetVerboseLevel(), JustWarning, python.hepunit::keV, and tolerance.

{
  if ( (A<1) || (Z<=0) || (J<0) || (E<0.0) || (A>999) ) {
#ifdef G4VERBOSE
    if (GetVerboseLevel()>0) {
      G4cout << "G4IonTable::FindIon() : illegal atomic number/mass or excitation level " 
             << " Z =" << Z << "  A = " << A <<  "  E = " << E/keV << G4endl;
    }
#endif
    G4Exception( "G4IonTable::FindIon()","PART107",
         JustWarning, "illegal atomic number/mass");
    return 0;
  }
  // Search ions with A, Z ,E
  //  !! J is omitted now !!
  const G4ParticleDefinition* ion=0;
  G4bool isFound = false;

  // check if light ion
  ion = GetLightIon(Z,A);
  if (ion!=0 && E==0.0) { 
    // light ion 
    isFound = true;
  } else {    
    // -- loop over all particles in Ion table
    G4int encoding=GetNucleusEncoding(Z, A);
    G4IonList::iterator i = fIonList->find(encoding);
    for( ;i != fIonList->end() ; i++) {
      ion = i->second;
      if ( ( ion->GetAtomicNumber() != Z) || (ion->GetAtomicMass()!=A) ) break;
      // excitation level
      G4double anExcitaionEnergy = ((const G4Ions*)(ion))->GetExcitationEnergy();
      if ( std::fabs( E - anExcitaionEnergy )< tolerance) {
    isFound = true;
    break;
      }
    }
  }

  if ( isFound ){ 
    return const_cast<G4ParticleDefinition*>(ion);
  } else {
    return 0;
  }
}

G4ParticleDefinition * G4IonTable::FindIon	(	G4int	Z,
		G4int	A,
		G4int	L,
		G4double	E,
		G4int	J = 0
	)

Definition at line 709 of file G4IonTable.cc.

References FindIon(), fIonList, G4cout, G4endl, G4Exception(), G4ParticleDefinition::GetAtomicMass(), G4ParticleDefinition::GetAtomicNumber(), GetNucleusEncoding(), G4ParticleDefinition::GetQuarkContent(), GetVerboseLevel(), JustWarning, python.hepunit::keV, and tolerance.

{
  if (L==0) return FindIon(Z,A,E,J);
  
  if (A < 2 || Z < 0 || Z > A-L || L>A || A>999 ) {
#ifdef G4VERBOSE
    if (GetVerboseLevel()>0) {
      G4cout << "G4IonTable::FindIon() : illegal atomic number/mass or excitation level " 
             << " Z =" << Z << "  A = " << A << " L = " << L 
         <<"  E = " << E/keV << G4endl;
    }    
#endif
    G4Exception( "G4IonTable::FindIon()","PART107",
         JustWarning, "illegal atomic number/mass");
    return 0;
  }
  // Search ions with A, Z ,E
  //  !! J is omitted now !!
  const G4ParticleDefinition* ion=0;
  G4bool isFound = false;

  // -- loop over all particles in Ion table
  G4int encoding=GetNucleusEncoding(Z, A, L, 0.0, 0);
  G4IonList::iterator i = fIonList->find(encoding);
  for( ;i != fIonList->end() ; i++) {
    ion = i->second;
    if ( ( ion->GetAtomicNumber() != Z) || (ion->GetAtomicMass()!=A) ) break;
    if(  ion->GetQuarkContent(3) != L) break;
    // excitation level
    G4double anExcitaionEnergy = ((const G4Ions*)(ion))->GetExcitationEnergy();
    if ( std::fabs( E - anExcitaionEnergy )< tolerance) {
      isFound = true;
      break;
    }
  }

  if ( isFound ){ 
    return const_cast<G4ParticleDefinition*>(ion);
  } else {
    return 0;
  }
}

G4ParticleDefinition * G4IonTable::FindIonInMaster ( G4int  Z, G4int  A, G4int  lvl = 0  )

protected

Definition at line 1660 of file G4IonTable.cc.

References fIonListShadow, G4ParticleDefinition::GetAtomicMass(), G4ParticleDefinition::GetAtomicNumber(), and GetNucleusEncoding().

Referenced by GetIon().

{
  // Search ions with A, Z ,E
  //  !! J is omitted now !!
  const G4ParticleDefinition* ion=0;
  G4bool isFound = false;

  // -- loop over all particles in Ion table
  G4int encoding=GetNucleusEncoding(Z, A);
  G4IonList::iterator i = fIonListShadow->find(encoding);
  for( ;i != fIonListShadow->end() ; i++) {
    ion = i->second;
    if ( ( ion->GetAtomicNumber() != Z) || (ion->GetAtomicMass()!=A) ) break;
    // excitation level
    if ( ((const G4Ions*)(ion))->GetIsomerLevel() == lvl) {
      isFound = true;
      break;
    } 
  }

  if ( isFound ){ 
    return const_cast<G4ParticleDefinition*>(ion);
  } else {
    return 0;
  }
}

G4ParticleDefinition * G4IonTable::FindIonInMaster ( G4int  Z, G4int  A, G4int  L, G4int  lvl  )

protected

Definition at line 1689 of file G4IonTable.cc.

References FindIon(), fIonListShadow, G4ParticleDefinition::GetAtomicMass(), G4ParticleDefinition::GetAtomicNumber(), GetNucleusEncoding(), and G4ParticleDefinition::GetQuarkContent().

{
  if (L==0) return FindIon(Z,A,lvl);
  
  // Search ions with A, Z ,E, lvl
  const G4ParticleDefinition* ion=0;
  G4bool isFound = false;

  // -- loop over all particles in Ion table
  G4int encoding=GetNucleusEncoding(Z, A, L);
  G4IonList::iterator i = fIonListShadow->find(encoding);
  for( ;i != fIonListShadow->end() ; i++) {
    ion = i->second;
    if ( ( ion->GetAtomicNumber() != Z) || (ion->GetAtomicMass()!=A) ) break;
    if ( ion->GetQuarkContent(3) != L) break;
    // excitation level
    if ( ((const G4Ions*)(ion))->GetIsomerLevel() == lvl) {
      isFound = true;
      break;
    }
  }

  if ( isFound ){ 
    return const_cast<G4ParticleDefinition*>(ion);
  } else {
    return 0;
  }
}

G4ParticleDefinition * G4IonTable::FindIonInMaster ( G4int  Z, G4int  A, G4double  E, G4int  J = 0  )

protected

Definition at line 1597 of file G4IonTable.cc.

References fIonListShadow, G4ParticleDefinition::GetAtomicMass(), G4ParticleDefinition::GetAtomicNumber(), GetNucleusEncoding(), and tolerance.

{
  // Search ions with A, Z ,E
  //  !! J is omitted now !!
  const G4ParticleDefinition* ion=0;
  G4bool isFound = false;

  // -- loop over all particles in Ion table
  G4int encoding=GetNucleusEncoding(Z, A);
  G4IonList::iterator i = fIonListShadow->find(encoding);
  for( ;i != fIonListShadow->end() ; i++) {
    ion = i->second;
    if ( ( ion->GetAtomicNumber() != Z) || (ion->GetAtomicMass()!=A) ) break;
    // excitation level
    G4double anExcitaionEnergy = ((const G4Ions*)(ion))->GetExcitationEnergy();
    if ( std::fabs( E - anExcitaionEnergy )< tolerance) {
      isFound = true;
      break;
    }
  }

  if ( isFound ){ 
    return const_cast<G4ParticleDefinition*>(ion);
  } else {
    return 0;
  }
}

G4ParticleDefinition * G4IonTable::FindIonInMaster ( G4int  Z, G4int  A, G4int  L, G4double  E, G4int  J = 0  )

protected

Definition at line 1627 of file G4IonTable.cc.

References FindIon(), fIonListShadow, G4ParticleDefinition::GetAtomicMass(), G4ParticleDefinition::GetAtomicNumber(), GetNucleusEncoding(), G4ParticleDefinition::GetQuarkContent(), and tolerance.

{
  if (L==0) return FindIon(Z,A,E,J);
  
  // Search ions with A, Z ,E
  //  !! J is omitted now !!
  const G4ParticleDefinition* ion=0;
  G4bool isFound = false;

  // -- loop over all particles in Ion table
  G4int encoding=GetNucleusEncoding(Z, A, L, 0.0, 0);
  G4IonList::iterator i = fIonListShadow->find(encoding);
  for( ;i != fIonListShadow->end() ; i++) {
    ion = i->second;
    if ( ( ion->GetAtomicNumber() != Z) || (ion->GetAtomicMass()!=A) ) break;
    if(  ion->GetQuarkContent(3) != L) break;
    // excitation level
    G4double anExcitaionEnergy = ((const G4Ions*)(ion))->GetExcitationEnergy();
    if ( std::fabs( E - anExcitaionEnergy )< tolerance) {
      isFound = true;
      break;
    }
  }

  if ( isFound ){ 
    return const_cast<G4ParticleDefinition*>(ion);
  } else {
    return 0;
  }
}

G4IsotopeProperty * G4IonTable::FindIsotope ( G4int  Z, G4int  A, G4double  E  ) const

protected

Definition at line 1465 of file G4IonTable.cc.

References fIsotopeTableList, and G4VIsotopeTable::GetIsotope().

Referenced by CreateIon(), and GetNucleusMass().

{
  if (fIsotopeTableList ==0) return 0;
  if (fIsotopeTableList->size()==0) return 0;
  
  G4IsotopeProperty* property =0;

  // iterate 
  for (size_t i = 0; i<fIsotopeTableList->size(); ++i) {
    G4VIsotopeTable* fIsotopeTable= (*fIsotopeTableList)[fIsotopeTableList->size()-i-1];
    property = fIsotopeTable->GetIsotope(Z,A,E);
    if(property) break;
  }
  
  return property;
}

G4IsotopeProperty * G4IonTable::FindIsotope ( G4int  Z, G4int  A, G4int  lvl  ) const

protected

Definition at line 1483 of file G4IonTable.cc.

References fIsotopeTableList, and G4VIsotopeTable::GetIsotope().

{
  if (fIsotopeTableList ==0) return 0;
  if (fIsotopeTableList->size()==0) return 0;
  
  G4IsotopeProperty* property =0;

  // iterate 
  for (size_t i = 0; i<fIsotopeTableList->size(); ++i) {
    G4VIsotopeTable* fIsotopeTable= (*fIsotopeTableList)[fIsotopeTableList->size()-i-1];
    property = fIsotopeTable->GetIsotope(Z,A,lvl);
    if(property) break;
  }
  
  return property;
}

G4ParticleDefinition * G4IonTable::GetIon	(	G4int	Z,
		G4int	A,
		G4int	lvl = 0
	)

Definition at line 449 of file G4IonTable.cc.

References CreateIon(), FindIon(), FindIonInMaster(), G4cout, G4endl, G4MUTEXLOCK, G4MUTEXUNLOCK, GetVerboseLevel(), InsertWorker(), and G4Threading::IsWorkerThread().

Referenced by G4RadioactiveDecay::AddDecayRateTable(), G4NeutronHPFinalState::adjust_final_state(), G4NeutronHPFissionFS::ApplyYourself(), G4NeutronHPCaptureFS::ApplyYourself(), G4NeutronHPChannelList::ApplyYourself(), G4HadronElastic::ApplyYourself(), G4NeutronRadCapture::ApplyYourself(), G4ChargeExchange::ApplyYourself(), G4QMDReaction::ApplyYourself(), G4INCLXXInterface::ApplyYourself(), G4NeutronHPInelasticBaseFS::BaseApply(), G4ExcitationHandler::BreakItUp(), G4NeutronHPInelasticCompFS::CompositeApply(), G4NuclearDecayChannel::DecayIt(), G4RadioactiveDecay::DecayIt(), G4ParticleTable::FindIon(), G4EmCalculator::FindIon(), B3PrimaryGeneratorAction::GeneratePrimaries(), G4NuclNuclDiffuseElastic::GetInvCoulombElasticXsc(), G4DiffuseElastic::GetInvCoulombElasticXsc(), G4NuclNuclDiffuseElastic::GetInvElasticSumXsc(), G4DiffuseElastic::GetInvElasticSumXsc(), G4NuclNuclDiffuseElastic::GetInvElasticXsc(), G4DiffuseElastic::GetInvElasticXsc(), GetIon(), G4ParticleTable::GetIon(), G4FissionProductYieldDist::GetParticleDefinition(), G4InuclNuclei::makeDefinition(), PreloadNuclide(), G4hCoulombScatteringModel::SampleSecondaries(), G4eSingleCoulombScatteringModel::SampleSecondaries(), G4eCoulombScatteringModel::SampleSecondaries(), and G4QuasiElasticChannel::Scatter().

{
  if ( (A<1) || (Z<=0) || (lvl<0) || (A>999) ) {
#ifdef G4VERBOSE
    if (GetVerboseLevel()>0) {
      G4cout << "G4IonTable::GetIon() : illegal atomic number/mass" 
             << " Z =" << Z << "  A = " << A <<  "  Lvl = " << lvl << G4endl;
    }
#endif
    return 0;
   }

  // Search ions with A, Z, lvl 
  G4ParticleDefinition* ion = FindIon(Z,A,lvl);

  // create ion
#ifdef G4MULTITHREADED
  if(ion == 0)
  {
    if(G4Threading::IsWorkerThread())
    {
      G4MUTEXLOCK(&G4IonTable::ionTableMutex);
      ion = FindIonInMaster(Z,A,lvl);
      if(ion == 0 && lvl == 0) ion = CreateIon(Z,A,lvl);
      if(ion != 0) InsertWorker(ion); 
      G4MUTEXUNLOCK(&G4IonTable::ionTableMutex);
    }
    else
    { if(lvl == 0) ion = CreateIon(Z,A,lvl); }
  }
#else
  if(ion == 0 && lvl == 0) ion = CreateIon(Z, A, lvl);
#endif

//  if(ion == 0)
//  {
//    G4ExceptionDescription ed;
//    ed << "Isomer level " << lvl << " is unknown for the isotope (Z="
//       << Z << ", A=" << A << "). Null pointer is returned.";
//    G4Exception( "G4IonTable::GetIon()","PART106", JustWarning, ed);
//  }
  return ion;  
}

G4ParticleDefinition * G4IonTable::GetIon	(	G4int	Z,
		G4int	A,
		G4int	L,
		G4int	lvl
	)

Definition at line 495 of file G4IonTable.cc.

References CreateIon(), FindIon(), FindIonInMaster(), G4cout, G4endl, G4MUTEXLOCK, G4MUTEXUNLOCK, GetIon(), GetVerboseLevel(), InsertWorker(), and G4Threading::IsWorkerThread().

{
  if (L==0) return GetIon(Z,A,lvl);

  if (A < 2 || Z < 0 || Z > A-L || L>A || A>999 ) {
#ifdef G4VERBOSE
    if (GetVerboseLevel()>0) {
      G4cout << "G4IonTable::GetIon() : illegal atomic number/mass" 
             << " Z =" << Z << "  A = " << A << " L = " << L 
         <<"  IsomerLvl = " << lvl << G4endl;
    }
#endif
    return 0;
  } else if( A==2 ) {
#ifdef G4VERBOSE
    if (GetVerboseLevel()>0) {
      G4cout << "G4IonTable::GetIon() : No boud state for " 
             << " Z =" << Z << "  A = " << A << " L = " << L 
         <<"  IsomerLvl = " << lvl << G4endl;
    }
#endif
    return 0;
   }

  // Search ions with A, Z 
  G4ParticleDefinition* ion = FindIon(Z,A,L,lvl);

  // create ion
  if (ion == 0) {
    if (lvl==0) {
#ifdef G4MULTITHREADED
      if(G4Threading::IsWorkerThread())
      {
        G4MUTEXLOCK(&G4IonTable::ionTableMutex);
        ion = FindIonInMaster(Z,A,L,lvl);
        if(ion == 0) ion = CreateIon(Z, A, L, lvl);
        InsertWorker(ion);
        G4MUTEXUNLOCK(&G4IonTable::ionTableMutex);
      }
      else
      { ion = CreateIon(Z, A, L, lvl); }
#else
      ion = CreateIon(Z, A, L, lvl);
#endif
    } 
  }

//  if(ion == 0)
//  {
//    G4ExceptionDescription ed;
//    ed << "Isomer level " << lvl << " is unknown for the isotope (Z="
//       << Z << ", A=" << A << ", L=" << L << "). Null pointer is returned.";
//    G4Exception( "G4IonTable::GetIon()","PART106", JustWarning, ed);
//  }
  return ion;  
}

G4ParticleDefinition * G4IonTable::GetIon	(	G4int	Z,
		G4int	A,
		G4double	E,
		G4int	J = 0
	)

Definition at line 553 of file G4IonTable.cc.

References CreateIon(), FindIon(), FindIonInMaster(), G4cout, G4endl, G4MUTEXLOCK, G4MUTEXUNLOCK, GetVerboseLevel(), InsertWorker(), G4Threading::IsWorkerThread(), and python.hepunit::keV.

{
  if ( (A<1) || (Z<=0) || (E<0.0) || (A>999) || (J<0) ) {
#ifdef G4VERBOSE
    if (GetVerboseLevel()>0) {
      G4cout << "G4IonTable::GetIon() : illegal atomic number/mass" 
             << " Z =" << Z << "  A = " << A <<  "  E = " << E/keV << G4endl;
    }
#endif
    return 0;
   }

  // Search ions with A, Z 
  G4ParticleDefinition* ion = FindIon(Z,A,E,J);

  // create ion
#ifdef G4MULTITHREADED
  if(ion == 0)
  {
    if(G4Threading::IsWorkerThread())
    {
      G4MUTEXLOCK(&G4IonTable::ionTableMutex);
      ion = FindIonInMaster(Z,A,E,J);
      if(ion == 0) ion = CreateIon(Z,A,E);
      InsertWorker(ion);
      G4MUTEXUNLOCK(&G4IonTable::ionTableMutex);
    }
    else
    { ion = CreateIon(Z,A,E); }
  }
#else
  if (ion == 0) ion = CreateIon(Z, A, E);
#endif

  return ion;  
}

G4ParticleDefinition * G4IonTable::GetIon	(	G4int	Z,
		G4int	A,
		G4int	L,
		G4double	E,
		G4int	J = 0
	)

Definition at line 591 of file G4IonTable.cc.

References CreateIon(), FindIon(), FindIonInMaster(), G4cout, G4endl, G4MUTEXLOCK, G4MUTEXUNLOCK, GetIon(), GetVerboseLevel(), InsertWorker(), G4Threading::IsWorkerThread(), and python.hepunit::keV.

{
  if (L==0) return GetIon(Z,A,E,J);

  if (A < 2 || Z < 0 || Z > A-L || L>A || A>999 ) {
#ifdef G4VERBOSE
    if (GetVerboseLevel()>0) {
      G4cout << "G4IonTable::GetIon() : illegal atomic number/mass" 
             << " Z =" << Z << "  A = " << A << " L = " << L 
         <<"  E = " << E/keV << G4endl;
    }
#endif
    return 0;
  } else if( A==2 ) {
#ifdef G4VERBOSE
    if (GetVerboseLevel()>0) {
      G4cout << "G4IonTable::GetIon() : No boud state for " 
             << " Z =" << Z << "  A = " << A << " L = " << L 
         <<  "  E = " << E/keV << G4endl;
    }
#endif
    return 0;
   }

  // Search ions with A, Z 
  G4ParticleDefinition* ion = FindIon(Z,A,L,E,J);

  // create ion
#ifdef G4MULTITHREADED
  if(ion == 0)
  {
    if(G4Threading::IsWorkerThread())
    {
      G4MUTEXLOCK(&G4IonTable::ionTableMutex);
      ion = FindIonInMaster(Z,A,L,E,J);
      if(ion == 0) ion = CreateIon(Z,A,L,E);
      InsertWorker(ion);
      G4MUTEXUNLOCK(&G4IonTable::ionTableMutex);
    }
    else
    { ion = CreateIon(Z,A,L,E); }
  }
#else
  if(ion == 0) ion = CreateIon(Z, A, L, E);
#endif

  return ion;  
}

G4ParticleDefinition * G4IonTable::GetIon

(

G4int

encoding

)

Definition at line 641 of file G4IonTable.cc.

References G4cout, G4endl, G4Exception(), GetIon(), GetNucleusByEncoding(), GetVerboseLevel(), and JustWarning.

{
  G4int Z, A, L, IsoLvl;
  G4double E;
  if (!GetNucleusByEncoding(encoding,Z,A,L,E,IsoLvl) ){
#ifdef G4VERBOSE
    if (GetVerboseLevel()>0) {
      G4cout << "G4IonTable::GetIon() : illegal encoding" 
             << " CODE:" << encoding << G4endl;
    }
#endif
    G4Exception( "G4IonTable::GetIon()","PART106",
         JustWarning, "illegal encoding for an ion");
    return 0;
  }
  //
  return GetIon( Z, A, L, IsoLvl);
}

G4double G4IonTable::GetIonMass	(	G4int	Z,
		G4int	A,
		G4int	L = 0,
		G4int	lvl = 0
	)		const

Definition at line 1232 of file G4IonTable.cc.

References GetNucleusMass().

Referenced by G4BinaryLightIonReaction::ApplyYourself(), G4NeutronHPCaptureFS::ApplyYourself(), G4TheoFSGenerator::ApplyYourself(), G4QMDReaction::ApplyYourself(), G4INCLXXInterface::ApplyYourself(), G4CompetitiveFission::BreakUp(), G4GGNuclNuclCrossSection::GetCoulombBarier(), G4ComponentGGNuclNuclXsc::GetCoulombBarier(), G4TripathiCrossSection::GetElementCrossSection(), G4StatMFFragment::GetNuclearMass(), G4FTFModel::Init(), and G4VPartonStringModel::Scatter().

{
  return GetNucleusMass(Z,A,L,lvl);
}

const G4String & G4IonTable::GetIonName	(	G4int	Z,
		G4int	A,
		G4int	lvl = 0
	)		const

Definition at line 992 of file G4IonTable.cc.

References elementName, G4ThreadLocal, numberOfElements, and eplot::pname.

Referenced by G4INCLXXInterface::ApplyYourself(), CreateIon(), GetIonName(), and G4LENDManager::GetLENDTarget().

{
  static G4ThreadLocal G4String *pname = 0;
  if (!pname)  { pname = new G4String(""); }
  G4String &name = *pname;

  static G4ThreadLocal std::ostringstream* os = 0;
  if ( ! os ) {
    os = new std::ostringstream();
    os->setf(std::ios::fixed);
  }

  if ( (0< Z) && (Z <=numberOfElements) ) {
    name = elementName[Z-1];
  } else if (Z > numberOfElements) {
    os->str("");
    os->operator<<(Z);
    name = "E" + os->str() + "-";
  } else {
    name = "?";
    return name;
  }
  // Atomic Mass
  os->str("");
  os->operator<<(A);

  if ( lvl>0 ){
    std::ostringstream& oo = *os;
    // isomer level for Excited nucelus 
    oo<<'['<<lvl << ']';
  }
  name += os->str();

  return name;
}

const G4String & G4IonTable::GetIonName	(	G4int	Z,
		G4int	A,
		G4double	E
	)		const

Definition at line 949 of file G4IonTable.cc.

References G4ThreadLocal, GetIonName(), python.hepunit::keV, and eplot::pname.

{
  static G4ThreadLocal G4String *pname = 0;
  if (!pname)  { pname = new G4String(""); }
  G4String &name = *pname;

  static G4ThreadLocal std::ostringstream* os = 0;
  if ( ! os ) {
    os = new std::ostringstream();
    os->setf(std::ios::fixed);
    os->precision(3);
  }

  name = GetIonName(Z, A);

  //excited energy
  if ( E>0 ){
    os->str("");
    std::ostringstream& oo = *os;
    // Excited nucelus
    oo<<'['<<E/keV << ']';
    name += os->str();
  }

  return name;
}

const G4String & G4IonTable::GetIonName	(	G4int	Z,
		G4int	A,
		G4int	L,
		G4double	E
	)		const

Definition at line 977 of file G4IonTable.cc.

References G4ThreadLocal, GetIonName(), and eplot::pname.

{
  if (L==0) return GetIonName(Z, A, E); 
  static G4ThreadLocal G4String *pname = 0;
  if (!pname)  { pname = new G4String(""); }
  G4String &name = *pname;
  name = "";
  for (int i =0; i<L; i++){
    name +="L";
  }
  name += GetIonName(Z, A, E);
  return name;
}

const G4String & G4IonTable::GetIonName	(	G4int	Z,
		G4int	A,
		G4int	L,
		G4int	lvl
	)		const

Definition at line 1029 of file G4IonTable.cc.

References G4ThreadLocal, GetIonName(), and eplot::pname.

{
  if (L==0) return GetIonName(Z, A, lvl); 
  static G4ThreadLocal G4String *pname = 0;
  if (!pname)  { pname = new G4String(""); }
  G4String &name = *pname;
  for (int i =0; i<L; i++){
    name +="L";
  }
  name += GetIonName(Z, A, lvl);
  return name;
}

static G4IonTable* G4IonTable::GetIonTable ( )

inlinestatic

Definition at line 80 of file G4IonTable.hh.

References G4ParticleTable::GetIonTable(), and G4ParticleTable::GetParticleTable().

Referenced by G4NeutronHPFinalState::adjust_final_state(), G4NeutronHPFissionFS::ApplyYourself(), G4NeutronHPCaptureFS::ApplyYourself(), G4NeutronHPChannelList::ApplyYourself(), G4NeutronHPElasticFS::ApplyYourself(), G4QMDReaction::ApplyYourself(), G4NeutronHPInelasticBaseFS::BaseApply(), G4NeutronHPInelasticCompFS::CompositeApply(), B3PrimaryGeneratorAction::GeneratePrimaries(), G4ParticleDefinition::GetIonLifeTime(), G4NeutronHPIsotropic::Sample(), and G4NeutronHPContAngularPar::Sample().

   { return G4ParticleTable::GetParticleTable()->GetIonTable(); }

G4double G4IonTable::GetIsomerMass	(	G4int	Z,
		G4int	A,
		G4int	lvl = 0
	)		const

Definition at line 1226 of file G4IonTable.cc.

References GetNucleusMass().

{
  return GetNucleusMass(Z,A,0,lvl);
}

G4VIsotopeTable * G4IonTable::GetIsotopeTable

(

size_t

idx = 0

)

const

Definition at line 1454 of file G4IonTable.cc.

References size().

{
   G4VIsotopeTable* fIsotopeTable=0;
   if ( index < fIsotopeTableList->size() ) {
     fIsotopeTable = (*fIsotopeTableList)[index];
   }
   return fIsotopeTable;
}

G4double G4IonTable::GetLifeTime

(

const G4ParticleDefinition *

particle

)

const

Definition at line 1720 of file G4IonTable.cc.

References FatalException, G4Exception(), G4ParticleDefinition::GetAtomicMass(), G4ParticleDefinition::GetAtomicNumber(), G4Ions::GetExcitationEnergy(), G4NuclideTable::GetIsotope(), G4IsotopeProperty::GetLifeTime(), G4ParticleDefinition::GetPDGLifeTime(), and G4ParticleDefinition::IsGeneralIon().

Referenced by G4ParticleDefinition::GetIonLifeTime().

{
  if(!(particle->IsGeneralIon())) return particle->GetPDGLifeTime();

  const G4Ions* ion = static_cast<const G4Ions*>(particle);
  G4double Z = ion->GetAtomicNumber();
  G4double A = ion->GetAtomicMass();
  G4double E = ion->GetExcitationEnergy();

  if(!pNuclideTable)
  {
   G4Exception("G4IonTable::GetLifeTime()","ParticleIon1001",FatalException,
               "Method is invoked before G4IonTable is initialized.");
  }
  G4IsotopeProperty* isoP = pNuclideTable->GetIsotope(Z,A,E);
  if(!isoP) return -1001.0;
  return isoP->GetLifeTime();
}

G4ParticleDefinition * G4IonTable::GetLightAntiIon ( G4int  Z, G4int  A  ) const

protected

Definition at line 1139 of file G4IonTable.cc.

References antilightions::Init().

{
  // returns pointer to pre-defined ions 
  const G4ParticleDefinition* ion=0;
  if ( (Z<=2) ) {
#ifndef G4MULTITHREADED
      //In sequential use lazy-initialization
    antilightions::Init();
#endif
    if ( (Z==1)&&(A==1) ) {
      ion = antilightions::p_proton;
    } else if ( (Z==1)&&(A==2) ) {
      ion = antilightions::p_deuteron;
    } else if ( (Z==1)&&(A==3) ) {
      ion = antilightions::p_triton;
    } else if ( (Z==2)&&(A==4) ) {
      ion = antilightions::p_alpha;
    } else if ( (Z==2)&&(A==3) ) {
      ion = antilightions::p_He3;
    }
  }
  return const_cast<G4ParticleDefinition*>(ion);
}

G4ParticleDefinition * G4IonTable::GetLightIon ( G4int  Z, G4int  A  ) const

protected

Definition at line 1114 of file G4IonTable.cc.

References lightions::Init().

Referenced by FindIon(), and GetNucleusMass().

{
  // returns pointer to pre-defined ions
  const G4ParticleDefinition* ion=0;
  if ( (Z<=2) ) {
#ifndef G4MULTITHREADED
      //In sequential use lazy-initialization
      lightions::Init();
#endif
    if ( (Z==1)&&(A==1) ) {
      ion = lightions::p_proton;
    } else if ( (Z==1)&&(A==2) ) {
        ion = lightions::p_deuteron;
    } else if ( (Z==1)&&(A==3) ) {
      ion = lightions::p_triton;
    } else if ( (Z==2)&&(A==4) ) {
      ion = lightions::p_alpha;
    } else if ( (Z==2)&&(A==3) ) {
      ion = lightions::p_He3;
    }
  }
  return const_cast<G4ParticleDefinition*>(ion);
}

G4bool G4IonTable::GetNucleusByEncoding ( G4int  encoding, G4int &  Z, G4int &  A, G4double &  E, G4int &  lvl  )

static

Definition at line 895 of file G4IonTable.cc.

Referenced by GetIon().

{
  if (encoding <= 0) return false; // anti particle   

  if (encoding == 2212) {  // proton
    Z = 1; A = 1;
    E = 0.0; lvl =0; 
    return true;
  } 

  encoding -= 1000000000;
  Z = encoding/10000;
  encoding -= 10000*Z;
  A = encoding/10;
  lvl = encoding % 10;
  return true;
}

G4bool G4IonTable::GetNucleusByEncoding ( G4int  encoding, G4int &  Z, G4int &  A, G4int &  L, G4double &  E, G4int &  lvl  )

static

!!not supported for excitation states !!!

Definition at line 916 of file G4IonTable.cc.

{
  if (encoding <= 0) return false; // anti particle   

 if (encoding == 3122) {  // Lambda
   Z = 1; A = 1; L = 1;
    E = 0.0; lvl =0; 
    return true;
  } 

  if (encoding % 10 != 0) {
    //!!!not supported for excitation states !!!   
    return false;
  }
  if (encoding < 1000000000) {
    // anti particle   
    return false;
  }

  encoding -= 1000000000;
  L = encoding/10000000;
  encoding -= 10000000*L;
  Z = encoding/10000;
  encoding -= 10000*Z;
  A = encoding/10;
  lvl = encoding % 10;
  return true;
}

G4int G4IonTable::GetNucleusEncoding ( G4int  Z, G4int  A, G4double  E = 0.0, G4int  lvl = 0  )

static

Definition at line 854 of file G4IonTable.cc.

References encoding.

Referenced by Contains(), CreateIon(), FindIon(), FindIonInMaster(), G4LENDManager::GetNucleusEncoding(), GetNucleusEncoding(), GetNucleusMass(), Insert(), InsertWorker(), G4InuclNuclei::makeNuclearFragment(), and Remove().

{
  // PDG code for Ions
  // Nuclear codes are given as 10-digit numbers +-100ZZZAAAI.
  //For a nucleus consisting of np protons and nn neutrons
  // A = np + nn and Z = np.
  // I gives the isomer level, with I = 0 corresponding 
  // to the ground state and I >0 to excitations
  
  if ( Z==1 && A==1 && E==0.0 ) return 2212; // proton
  
  G4int encoding = 1000000000;
  encoding += Z * 10000;
  encoding += A *10;
  if (lvl>0&&lvl<10) encoding +=lvl;       //isomer level
  else if (E>0.0) encoding += 9;  //isomer level
  
  return encoding;
}

G4int G4IonTable::GetNucleusEncoding ( G4int  Z, G4int  A, G4int  L, G4double  E = 0.0, G4int  lvl = 0  )

static

Definition at line 875 of file G4IonTable.cc.

References encoding, and GetNucleusEncoding().

{
  //  get PDG code for Hyper-Nucleus Ions 
  // Nuclear codes are given as 10-digit numbers +-10LZZZAAAI.
  //For a nucleus consisting of np protons and nn neutrons
  // A = np + nn +nlambda and Z = np.
  // L = nlambda
  // I gives the isomer level, with I = 0 corresponding 
  // to the ground state and I >0 to excitations

  G4int encoding = GetNucleusEncoding(Z, A, E, lvl);
  if (L==0) return encoding; 
  encoding += L*  10000000;
  if ( Z==1 && A==1 && E==0.0 ) encoding = 3122; // Lambda 

  return encoding;
}

G4double G4IonTable::GetNucleusMass	(	G4int	Z,
		G4int	A,
		G4int	L = 0,
		G4int	lvl = 0
	)		const

Definition at line 1167 of file G4IonTable.cc.

References EventMustBeAborted, FindIsotope(), fIonList, G4cout, G4endl, G4Exception(), G4ParticleDefinition::GetAtomicMass(), G4ParticleDefinition::GetAtomicNumber(), G4IsotopeProperty::GetEnergy(), GetLightIon(), G4HyperNucleiProperties::GetNuclearMass(), G4NucleiProperties::GetNuclearMass(), GetNucleusEncoding(), G4ParticleDefinition::GetPDGMass(), and GetVerboseLevel().

Referenced by CreateIon(), GetIonMass(), and GetIsomerMass().

{
  if ( (A<1)  || (Z<0) || (L<0) || (lvl<0) || (lvl>9) ){
#ifdef G4VERBOSE
    if (GetVerboseLevel()>0) {
      G4cout << "G4IonTable::GetNucleusMass() : illegal atomic number/mass " 
             << " Z =" << Z << "  A = " << A  
         << " L = " << L << " lvl = " << lvl << G4endl;
    }
#endif
    G4Exception( "G4IonTable::GetNucleusMass()","PART107",
         EventMustBeAborted, "illegal atomic number/mass");
    return -1.0;
  }
  
  G4double mass;
  if (L == 0) {
    // calculate nucleus mass
    const G4ParticleDefinition* ion=GetLightIon(Z, A);
    
    if (ion!=0) {
      mass = ion->GetPDGMass();
    } else {
      // use G4NucleiProperties::GetNuclearMass
      mass = G4NucleiProperties::GetNuclearMass(A, Z);
    }
    
    // Isomer
    if ( lvl>0 ) {
      // -- loop over all particles in Ion table
      G4int encoding=GetNucleusEncoding(Z, A);
      G4IonList::iterator i = fIonList->find(encoding);
      G4bool isFound =false;
      for( ;i != fIonList->end() ; i++) {
    ion = i->second;
    if ( ( ion->GetAtomicNumber() != Z) || (ion->GetAtomicMass()!=A) ) break;
    // excitation level
    if ( ((const G4Ions*)(ion))->GetIsomerLevel() == lvl) {
      isFound = true;
      break;
    }
      }
      if (isFound) {
    // return existing isomer mass
    mass = ion->GetPDGMass();
      } else {
    // Find isomer from IsotopeTable
    const G4IsotopeProperty*  fProperty = FindIsotope(Z, A, lvl);
    if (fProperty !=0 ) mass += fProperty->GetEnergy();
      }
    }

  } else {
    mass = G4HyperNucleiProperties::GetNuclearMass(A, Z, L);
    }
  return mass;
}

G4int G4IonTable::GetNumberOfElements ( ) const

inline

Definition at line 316 of file G4IonTable.hh.

References numberOfElements.

{
  return numberOfElements;
}

G4ParticleDefinition * G4IonTable::GetParticle

(

G4int

index

)

const

Definition at line 1538 of file G4IonTable.cc.

References Entries(), fIonList, G4cout, G4endl, and GetVerboseLevel().

Referenced by DMXPhysicsList::ConstructGeneral().

{
  if ( (index >=0) && (index < Entries()) ) {
    G4IonList::iterator idx = fIonList->begin();
    G4int counter = 0;
    while( idx != fIonList->end() ){
      if ( counter == index ) {
    return const_cast<G4ParticleDefinition*>(idx->second);
      }
      counter++;
      idx++;
    }
  } 
#ifdef G4VERBOSE
  if (GetVerboseLevel()>1){
    G4cout << " G4IonTable::GetParticle"
           << " invalid index (=" << index << ")" 
       << " entries = " << Entries() << G4endl;
  }
#endif
  return 0;
}

G4int G4IonTable::GetVerboseLevel ( ) const

protected

Definition at line 1395 of file G4IonTable.cc.

References G4ParticleTable::GetParticleTable(), and G4ParticleTable::GetVerboseLevel().

Referenced by clear(), CreateIon(), FindIon(), GetIon(), GetNucleusMass(), GetParticle(), and Remove().

{
  return G4ParticleTable::GetParticleTable()->GetVerboseLevel();
}

void G4IonTable::InitializeLightIons

(

)

Definition at line 177 of file G4IonTable.cc.

References lightions::Init(), and antilightions::Init().

Referenced by G4RunManagerKernel::SetupPhysics().

{
  lightions::Init();
  antilightions::Init();
}

void G4IonTable::Insert

(

const G4ParticleDefinition *

particle

)

Definition at line 1260 of file G4IonTable.cc.

References Contains(), fIonListShadow, G4ParticleDefinition::GetAtomicMass(), G4ParticleDefinition::GetAtomicNumber(), GetNucleusEncoding(), G4ParticleDefinition::GetQuarkContent(), and IsIon().

Referenced by G4ParticleTable::Insert().

{
  if (!IsIon(particle)) return;
  if (Contains(particle)) return;
 
  G4int Z = particle->GetAtomicNumber();
  G4int A = particle->GetAtomicMass();  
  G4int L = particle->GetQuarkContent(3);  //strangeness 
  G4int encoding=GetNucleusEncoding(Z, A, L); // encoding of the groud state 

  // regsiter the ion with its encoding of the groud state  
  fIonListShadow->insert( std::pair<const G4int, const G4ParticleDefinition*>(encoding, particle) );

}

void G4IonTable::InsertWorker ( const G4ParticleDefinition *  particle )

protected

Definition at line 1275 of file G4IonTable.cc.

References fIonList, G4ParticleDefinition::GetAtomicMass(), G4ParticleDefinition::GetAtomicNumber(), GetNucleusEncoding(), and G4ParticleDefinition::GetQuarkContent().

Referenced by GetIon().

{
  if(!particle) return;

  G4int Z = particle->GetAtomicNumber();
  G4int A = particle->GetAtomicMass();  
  G4int L = particle->GetQuarkContent(3);  //strangeness 
  G4int encoding=GetNucleusEncoding(Z, A, L);
  G4bool found = false;
  if (encoding !=0 ) {
    G4IonList::iterator i = fIonList->find(encoding);
    for( ;i != fIonList->end() ; i++) {
      if (particle == i->second ) {
    found  = true;
    break;
      }
    }
  }
  if(found) return;
 
  // regsiter the ion with its encoding of the groud state  
  fIonList->insert( std::pair<const G4int, const G4ParticleDefinition*>(encoding, particle) );

}

G4bool G4IonTable::IsAntiIon ( const G4ParticleDefinition *  particle )

static

Definition at line 1069 of file G4IonTable.cc.

References G4ParticleDefinition::GetAtomicMass(), G4ParticleDefinition::GetAtomicNumber(), G4ParticleDefinition::GetBaryonNumber(), G4ParticleDefinition::GetParticleName(), and G4ParticleDefinition::GetParticleType().

Referenced by G4ParticleDefinition::DumpTable(), and G4ParticleDefinition::G4ParticleDefinition().

{
  // return true if the particle is ion

  static const G4String anti_nucleus("anti_nucleus");
  static const G4String anti_proton("anti_proton");

  // anti_neutron is not ion
  if ((particle->GetAtomicMass()>0)   && 
      (particle->GetAtomicNumber()>0) ){
   if (particle->GetBaryonNumber()<0)  return true;
   else return false;
  }

  //  particles derived from G4Ions
  if (particle->GetParticleType() == anti_nucleus) return true;

  // anti_proton (Anti_Hydrogen nucleus)
  if (particle->GetParticleName() == anti_proton) return true;

  return false;
}

G4bool G4IonTable::IsIon ( const G4ParticleDefinition *  particle )

static

Definition at line 1044 of file G4IonTable.cc.

References G4ParticleDefinition::GetAtomicMass(), G4ParticleDefinition::GetAtomicNumber(), G4ParticleDefinition::GetBaryonNumber(), G4ParticleDefinition::GetParticleName(), G4ParticleDefinition::GetParticleType(), and G4InuclParticleNames::proton.

Referenced by G4DynamicParticle::AllocateElectronOccupancy(), Contains(), G4ParticleDefinition::DumpTable(), G4ParticleDefinition::G4ParticleDefinition(), G4ParticleTable::Insert(), Insert(), G4ParticleTable::Remove(), and Remove().

{
  // return true if the particle is ion

  static const G4String nucleus("nucleus");
  static const G4String proton("proton");

  // neutron is not ion
  if ((particle->GetAtomicMass()>0)   && 
      (particle->GetAtomicNumber()>0) ){
   if (particle->GetBaryonNumber()>0)  return true;
   else return false;
  }

   
  //  particles derived from G4Ions
  if (particle->GetParticleType() == nucleus) return true;

  // proton (Hydrogen nucleus)
  if (particle->GetParticleName() == proton) return true;

  return false;
}

G4bool G4IonTable::IsLightAntiIon ( const G4ParticleDefinition *  particle ) const

protected

Definition at line 1104 of file G4IonTable.cc.

References G4ParticleDefinition::GetParticleName().

{
  static const std::string names[] = { "anti_proton", "anti_alpha", "anti_deuteron",
                           "anti_triton", "anti_He3"};

   // return true if the particle is pre-defined ion
  return std::find(names, names+5, particle->GetParticleName())!=names+5;
} 

G4bool G4IonTable::IsLightIon ( const G4ParticleDefinition *  particle ) const

protected

Definition at line 1095 of file G4IonTable.cc.

References G4ParticleDefinition::GetParticleName().

{
  static const std::string names[] = { "proton", "alpha", "deuteron",
                           "triton", "He3"};

   // return true if the particle is pre-defined ion
  return std::find(names, names+5, particle->GetParticleName())!=names+5;
} 

G4IonTable& G4IonTable::operator= ( const G4IonTable &  )

inlineprotected

Definition at line 95 of file G4IonTable.hh.

{return *this;}

void G4IonTable::PreloadNuclide

(

)

Definition at line 1515 of file G4IonTable.cc.

References G4NuclideTable::entries(), G4NuclideTable::GenerateNuclide(), G4IsotopeProperty::GetAtomicMass(), G4IsotopeProperty::GetAtomicNumber(), G4IsotopeProperty::GetEnergy(), GetIon(), G4NuclideTable::GetIsotopeByIndex(), G4NuclideTable::GetNuclideTable(), and RegisterIsotopeTable().

Referenced by CreateAllIon(), and CreateAllIsomer().

{
  if (isIsomerCreated) return;

  if (pNuclideTable==0) {
    pNuclideTable = G4NuclideTable::GetNuclideTable();
    pNuclideTable->GenerateNuclide();
    RegisterIsotopeTable(pNuclideTable);
  }

  for ( size_t i = 0 ; i != pNuclideTable->entries() ; i++ ) {
     const G4IsotopeProperty*  fProperty = pNuclideTable->GetIsotopeByIndex( i );
     G4int Z  = fProperty->GetAtomicNumber();
     G4int A  = fProperty->GetAtomicMass();
     G4double Eex  = fProperty->GetEnergy();
     GetIon(Z,A,Eex);
  }

  isIsomerCreated = true;
}

void G4IonTable::RegisterIsotopeTable

(

G4VIsotopeTable *

table

)

Definition at line 1440 of file G4IonTable.cc.

References fIsotopeTableList, and G4VIsotopeTable::GetName().

Referenced by G4RadioactiveDecay::G4RadioactiveDecay(), and PreloadNuclide().

{
  //check duplication
  G4String name = table->GetName();
  for (size_t i = 0; i< fIsotopeTableList->size(); ++i) {
    G4VIsotopeTable* fIsotopeTable= (*fIsotopeTableList)[i];
    if (name == fIsotopeTable->GetName()) return;
  }

  // register 
  fIsotopeTableList->push_back(table);
}

void G4IonTable::Remove

(

const G4ParticleDefinition *

particle

)

Definition at line 1301 of file G4IonTable.cc.

References fIonListShadow, G4cout, G4endl, G4Exception(), G4State_PreInit, G4ParticleDefinition::GetAtomicMass(), G4ParticleDefinition::GetAtomicNumber(), G4StateManager::GetCurrentState(), GetNucleusEncoding(), G4ParticleDefinition::GetParticleName(), G4ParticleTable::GetParticleTable(), G4ParticleDefinition::GetQuarkContent(), G4StateManager::GetStateManager(), GetVerboseLevel(), IsIon(), G4Threading::IsWorkerThread(), and JustWarning.

Referenced by G4ParticleTable::Remove().

{
  if(!particle) return;
#ifdef G4MULTITHREADED
  if(G4Threading::IsWorkerThread()) {
    G4ExceptionDescription ed;
    ed << "Request of removing " << particle->GetParticleName()
       << " is ignored as it is invoked from a worker thread.";
    G4Exception("G4IonTable::Remove()","PART10117",JustWarning,ed);
    return;
  }
#endif
  if (G4ParticleTable::GetParticleTable()->GetReadiness()) {
    G4StateManager* pStateManager = G4StateManager::GetStateManager();
    G4ApplicationState currentState = pStateManager->GetCurrentState();
    if (currentState != G4State_PreInit) {
      G4String msg = "Request of removing ";
      msg += particle->GetParticleName();  
      msg += " has No effects other than Pre_Init";
      G4Exception("G4IonTable::Remove()",
          "PART117", JustWarning, msg);
      return;
    } else {
#ifdef G4VERBOSE
      if (GetVerboseLevel()>0){
    G4cout << particle->GetParticleName()
           << " will be removed from the IonTable " << G4endl;
      }
#endif
    }
  }

  if (IsIon(particle)) {
    G4int Z = particle->GetAtomicNumber();
    G4int A = particle->GetAtomicMass();  
    G4int L = particle->GetQuarkContent(3);  //strangeness 
    G4int encoding=GetNucleusEncoding(Z, A, L);
    if (encoding !=0 ) {
      G4IonList::iterator i = fIonListShadow->find(encoding);
      for( ;i != fIonListShadow->end() ; i++) {
    if (particle == i->second) {
      fIonListShadow->erase(i);
      break;
    }
      }
    }
  } else {
#ifdef G4VERBOSE
    if (GetVerboseLevel()>1) {
      G4cout << "G4IonTable::Remove :" << particle->GetParticleName() 
             << " is not ions" << G4endl; 
    }
#endif
  }
  
}

G4int G4IonTable::size

(

)

const

Definition at line 1590 of file G4IonTable.cc.

References fIonList.

Referenced by GetIsotopeTable().

{
  return fIonList->size();
}

void G4IonTable::SlaveG4IonTable

(

)

Definition at line 147 of file G4IonTable.cc.

References FatalException, and G4Exception().

{
G4Exception("G4IonTable::SlaveG4ParticleTable()","G4MT0000",FatalException,"Obsolete");
}

void G4IonTable::WorkerG4IonTable

(

)

Definition at line 152 of file G4IonTable.cc.

References fIonList, fIonListShadow, and fIsotopeTableList.

Referenced by G4ParticleTable::WorkerG4ParticleTable().

{
  if( fIonList == 0 )
  { fIonList = new G4IonList(); }
  else
  { fIonList->clear(); }

  G4IonListIterator it;
  for (it = fIonListShadow->begin() ; it != fIonListShadow->end(); it++ ) {
///////////////////////////    G4ParticleDefinition* ion = const_cast<G4ParticleDefinition*>(it->second);
///////////////////////////    if (ion->IsGeneralIon()) AddProcessManager(ion); 
    fIonList->insert(*it);
  }

  // Do not copy Isotoper Table to Worker thread
  //if( fIsotopeTableList == 0 ) {
  //  fIsotopeTableList = new std::vector<G4VIsotopeTable*>; 
  //  for (size_t i = 0; i < fIsotopeTableListShadow->size(); i++){
  //    fIsotopeTableList->push_back((*fIsotopeTableListShadow)[i]); 
  //  }
  //}

  fIsotopeTableList = new std::vector<G4VIsotopeTable*>;
}

Field Documentation

const G4String G4IonTable::elementName

static

Initial value:

= {
  "H",                                                                                                "He", 
  "Li", "Be",                                                             "B",  "C",  "N",  "O", "F", "Ne", 
  "Na", "Mg",                                                             "Al", "Si", "P", "S", "Cl", "Ar", 
  "K", "Ca", "Sc", "Ti", "V", "Cr", "Mn", "Fe", "Co", "Ni", "Cu", "Zn", "Ga", "Ge", "As", "Se", "Br", "Kr", 
  "Rb", "Sr", "Y", "Zr", "Nb", "Mo","Tc", "Ru", "Rh", "Pd", "Ag", "Cd", "In", "Sn", "Sb", "Te", "I",  "Xe", 
  "Cs", "Ba", 
              "La", "Ce", "Pr", "Nd", "Pm", "Sm", "Eu", "Gd", "Tb", "Dy", "Ho", "Er", "Tm", "Yb", "Lu", 
                   "Hf", "Ta", "W", "Re", "Os", "Ir", "Pt", "Au", "Hg", "Tl", "Pb", "Bi", "Po", "At", "Rn", 
  "Fr", "Ra", 
              "Ac", "Th", "Pa",  "U", "Np", "Pu", "Am", "Cm", "Bk", "Cf", "Es", "Fm", "Md", "No", "Lr",
              "Rf", "Db", "Sg", "Bh", "Hs", "Mt", "Ds", "Rg", 
              "Cn", "Uut", "Fl","Uup","Lv","Uus","Uuo"
}

Definition at line 302 of file G4IonTable.hh.

Referenced by GetIonName().

G4ThreadLocal G4IonTable::G4IonList * G4IonTable::fIonList = 0

static

Definition at line 289 of file G4IonTable.hh.

Referenced by clear(), DumpTable(), Entries(), FindIon(), G4IonTable(), GetNucleusMass(), GetParticle(), InsertWorker(), size(), WorkerG4IonTable(), and ~G4IonTable().

G4IonTable::G4IonList * G4IonTable::fIonListShadow = 0

static

Definition at line 291 of file G4IonTable.hh.

Referenced by Contains(), FindIonInMaster(), G4IonTable(), Insert(), Remove(), and WorkerG4IonTable().

G4ThreadLocal std::vector< G4VIsotopeTable * > * G4IonTable::fIsotopeTableList = 0

static

Definition at line 290 of file G4IonTable.hh.

Referenced by FindIsotope(), G4IonTable(), RegisterIsotopeTable(), WorkerG4IonTable(), and ~G4IonTable().

std::vector< G4VIsotopeTable * > * G4IonTable::fIsotopeTableListShadow = 0

static

Definition at line 292 of file G4IonTable.hh.

Referenced by G4IonTable().

const G4double G4IonTable::tolerance = 2.0*keV

static

Definition at line 299 of file G4IonTable.hh.

Referenced by FindIon(), and FindIonInMaster().

---

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

• G4IonTable.hh
• G4IonTable.cc