G4IonTable Class Reference

#include <G4IonTable.hh>

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

Public Member Functions
	G4IonTable ()
	~G4IonTable ()
	G4IonTable (const G4IonTable &)=delete
G4IonTable &	operator= (const G4IonTable &)=delete
void	WorkerG4IonTable ()
void	DestroyWorkerG4IonTable ()
G4int	GetNumberOfElements () const
void	RegisterIsotopeTable (G4VIsotopeTable *table)
G4VIsotopeTable *	GetIsotopeTable (std::size_t idx=0) const
void	CreateAllIon ()
void	CreateAllIsomer ()
void	PrepareNuclideTable ()
void	PreloadNuclide ()
G4ParticleDefinition *	GetIon (G4int Z, G4int A, G4int lvl=0)
G4ParticleDefinition *	GetIon (G4int Z, G4int A, G4int nL, G4int lvl)
G4ParticleDefinition *	GetIon (G4int Z, G4int A, G4double E, G4int J=0)
G4ParticleDefinition *	GetIon (G4int Z, G4int A, G4double E, G4Ions::G4FloatLevelBase flb, G4int J=0)
G4ParticleDefinition *	GetIon (G4int Z, G4int A, G4double E, char flbChar, G4int J=0)
G4ParticleDefinition *	GetIon (G4int Z, G4int A, G4int nL, G4double E, G4int J=0)
G4ParticleDefinition *	GetIon (G4int Z, G4int A, G4int nL, G4double E, G4Ions::G4FloatLevelBase flb, G4int J=0)
G4ParticleDefinition *	GetIon (G4int Z, G4int A, G4int nL, G4double E, char flbChar, G4int J=0)
G4ParticleDefinition *	GetIon (G4int encoding)
G4ParticleDefinition *	FindIon (G4int Z, G4int A, G4int lvl=0)
G4ParticleDefinition *	FindIon (G4int Z, G4int A, G4int nL, G4int lvl)
G4ParticleDefinition *	FindIon (G4int Z, G4int A, G4double E, G4int J=0)
G4ParticleDefinition *	FindIon (G4int Z, G4int A, G4double E, G4Ions::G4FloatLevelBase flb, G4int J=0)
G4ParticleDefinition *	FindIon (G4int Z, G4int A, G4double E, char flbChar, G4int J=0)
G4ParticleDefinition *	FindIon (G4int Z, G4int A, G4int nL, G4double E, G4int J=0)
G4ParticleDefinition *	FindIon (G4int Z, G4int A, G4int nL, G4double E, G4Ions::G4FloatLevelBase flb, G4int J=0)
G4ParticleDefinition *	FindIon (G4int Z, G4int A, G4int nL, G4double E, char flbChar, G4int J=0)
const G4String &	GetIonName (G4int Z, G4int A, G4int lvl=0) const
const G4String &	GetIonName (G4int Z, G4int A, G4double E, G4Ions::G4FloatLevelBase flb=G4Ions::G4FloatLevelBase::no_Float) const
const G4String &	GetIonName (G4int Z, G4int A, G4int nL, G4double E, G4Ions::G4FloatLevelBase flb=G4Ions::G4FloatLevelBase::no_Float) const
const G4String &	GetIonName (G4int Z, G4int A, G4int nL, G4int lvl) const
G4double	GetIonMass (G4int Z, G4int A, G4int nL=0, G4int lvl=0) const
G4double	GetNucleusMass (G4int Z, G4int A, G4int nL=0, G4int lvl=0) const
G4double	GetIsomerMass (G4int Z, G4int A, G4int lvl=0) const
G4double	GetLifeTime (const G4ParticleDefinition *) const
G4double	GetLifeTime (G4int Z, G4int A, G4double E, G4Ions::G4FloatLevelBase flb=G4Ions::G4FloatLevelBase::no_Float) const
G4double	GetLifeTime (G4int Z, G4int A, G4double E, char flbChar) const
G4ParticleDefinition *	GetMuonicAtom (G4Ions const *)
G4ParticleDefinition *	GetMuonicAtom (G4int Z, G4int A)
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 nL, 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 = nullptr
static G4ThreadLocal std::vector< G4VIsotopeTable * > *	fIsotopeTableList = nullptr
static G4IonList *	fIonListShadow = nullptr
static std::vector< G4VIsotopeTable * > *	fIsotopeTableListShadow = nullptr
static const G4String	elementName [numberOfElements]

Protected Member Functions
G4ParticleDefinition *	FindIonInMaster (G4int Z, G4int A, G4int lvl=0)
G4ParticleDefinition *	FindIonInMaster (G4int Z, G4int A, G4int nL, G4int lvl)
G4ParticleDefinition *	FindIonInMaster (G4int Z, G4int A, G4double E, G4Ions::G4FloatLevelBase flb, G4int J=0)
G4ParticleDefinition *	FindIonInMaster (G4int Z, G4int A, G4int nL, G4double E, G4Ions::G4FloatLevelBase flb, G4int J=0)
G4ParticleDefinition *	CreateIon (G4int Z, G4int A, G4double E, G4Ions::G4FloatLevelBase flb)
G4ParticleDefinition *	CreateIon (G4int Z, G4int A, G4int nL, G4double E, G4Ions::G4FloatLevelBase flb)
G4ParticleDefinition *	CreateIon (G4int Z, G4int A, G4int lvl=0)
G4ParticleDefinition *	CreateIon (G4int Z, G4int A, G4int nL, G4int lvl)
void	InsertWorker (const G4ParticleDefinition *particle)
G4IsotopeProperty *	FindIsotope (G4int Z, G4int A, G4double E, G4Ions::G4FloatLevelBase flb) 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 52 of file G4IonTable.hh.

Member Typedef Documentation

G4IonList

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

Definition at line 56 of file G4IonTable.hh.

G4IonListIterator

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

Definition at line 58 of file G4IonTable.hh.

Member Enumeration Documentation

anonymous enum

anonymous enum

Enumerator
numberOfElements

Definition at line 263 of file G4IonTable.hh.

{ numberOfElements = 118};

Constructor & Destructor Documentation

G4IonTable() [1/2]

G4IonTable::G4IonTable

(

)

Definition at line 113 of file G4IonTable.cc.

{
  fIonList = new G4IonList();
 
  // Set up the shadow pointer used by worker threads.
  //
  if (fIonListShadow == nullptr)
  {
    fIonListShadow = fIonList;
  }
 
  fIsotopeTableList = new std::vector<G4VIsotopeTable*>;
 
  // Set up the shadow pointer used by worker threads.
  //
  if (fIsotopeTableListShadow == nullptr)
  {
    fIsotopeTableListShadow = fIsotopeTableList;
  }    
 
  PrepareNuclideTable();
  RegisterIsotopeTable(pNuclideTable);
}

~G4IonTable()

G4IonTable::~G4IonTable

(

)

Definition at line 140 of file G4IonTable.cc.

{
  // delete IsotopeTable if existing
  if (fIsotopeTableList !=  nullptr )
  {
    for (std::size_t i=0; i<fIsotopeTableList->size(); ++i)
    {
      G4VIsotopeTable* fIsotopeTable= (*fIsotopeTableList)[i];
      if( fIsotopeTable != G4NuclideTable::GetNuclideTable() )
      {
        delete fIsotopeTable;
      }
    }
    fIsotopeTableList->clear();
    delete fIsotopeTableList;
  }
  fIsotopeTableList = nullptr;
 
  if (fIonList == nullptr) return;
 
  // remove all contents in the Ion List 
  // No need to delete here because all particles are dynamic objects
  fIonList->clear();
  delete fIonList;
  fIonList = nullptr;
}

G4IonTable() [2/2]

G4IonTable::G4IonTable ( const G4IonTable &  )

delete

Member Function Documentation

AddProcessManager()

void G4IonTable::AddProcessManager ( G4ParticleDefinition *  ion )

protected

Definition at line 1711 of file G4IonTable.cc.

{
  if(ion->IsGeneralIon())
  {
    // Check whether GenericIon has processes
    G4ParticleDefinition* genericIon = 
      G4ParticleTable::GetParticleTable()->GetGenericIon();
 
    G4ProcessManager* pman = nullptr;
    if (genericIon != nullptr) pman = genericIon->GetProcessManager();
    if ((genericIon == nullptr) || (genericIon->GetParticleDefinitionID() < 0)
                                || (pman==nullptr))
    {
      G4String msg = "G4IonTable::AddProcessManager(): cannot create ion of ";
      msg += ion->GetParticleName();
      msg += "\n because GenericIon is not available!!";
      G4Exception("G4IonTable::AddProcessManager()", "PART105",
                  FatalException, msg);
      return;
    }
  
    ion->SetParticleDefinitionID(genericIon->GetParticleDefinitionID());
  }
  else
  {
    // Is this a MuonicAtom ?
    G4MuonicAtom* muatom = dynamic_cast<G4MuonicAtom*> (ion);
 
    if ( muatom != nullptr )
    {
#ifdef G4VERBOSE
      if (GetVerboseLevel()>1)
      {
        G4cout << "G4IonTable::AddProcessManager(): "
               << "MuonicAtom dynamic_cast succeeded for " 
               << ion->GetParticleName() << G4endl;
      }
#endif
      // Check whether GenericMuonicAtom has processes
      G4ParticleDefinition* genericMA = 
        G4ParticleTable::GetParticleTable()->GetGenericMuonicAtom();
 
      G4ProcessManager* pman = nullptr;
      if (genericMA != nullptr) pman = genericMA->GetProcessManager();
      if ((genericMA == nullptr) || (genericMA->GetParticleDefinitionID() < 0)
                                 || (pman==nullptr))
      {
        G4String msg =
               "G4IonTable::AddProcessManager(): cannot create MuonicAtom ";
        msg += ion->GetParticleName();
        msg += "\n because GenericMuonicAtom is not available!!";
        G4Exception("G4IonTable::AddProcessManager()",
                    "PART106", FatalException, msg);
        return;
      }
  
      ion->SetParticleDefinitionID(genericMA->GetParticleDefinitionID());
    }
    else
    {
      G4String msg =
               "G4IonTable::AddProcessManager(): cannot create ";
      msg += ion->GetParticleName();
      msg += "\n because of unsupported particle type !!";
      G4Exception("G4IonTable::AddProcessManager()", "PART107",
                  FatalException, msg);
      return;
    }
  }
  return;
}

Referenced by CreateIon(), and GetMuonicAtom().

clear()

void G4IonTable::clear

(

)

Definition at line 1526 of file G4IonTable.cc.

{
  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 registered =  "; 
    G4cout << fIonList->size() <<  G4endl;
  }
#endif
  fIonList->clear();
}

Referenced by G4ParticleTable::RemoveAllParticles().

Contains()

G4bool G4IonTable::Contains

(

const G4ParticleDefinition *

particle

)

const

Definition at line 1935 of file G4IonTable.cc.

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

Referenced by Insert().

CreateAllIon()

void G4IonTable::CreateAllIon

(

)

Definition at line 1859 of file G4IonTable.cc.

{
  PreloadNuclide();
}

Referenced by G4ParticleMessenger::SetNewValue().

CreateAllIsomer()

void G4IonTable::CreateAllIsomer

(

)

Definition at line 1867 of file G4IonTable.cc.

{
  PreloadNuclide();
}

Referenced by G4ParticleMessenger::SetNewValue().

CreateIon() [1/4]

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

protected

Definition at line 245 of file G4IonTable.cc.

{
  G4ParticleDefinition* ion = nullptr;
 
  // check whether GenericIon has processes
  G4ParticleDefinition* genericIon = 
    G4ParticleTable::GetParticleTable()->GetGenericIon();
  G4ProcessManager* pman = nullptr;
  if (genericIon!= nullptr) { pman = genericIon->GetProcessManager(); }
  if ((genericIon == nullptr) || (genericIon->GetParticleDefinitionID() < 0)
                              || (pman==nullptr))
  {
#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 nullptr;
  }
  
  G4double life = 0.0;
  G4DecayTable* decayTable = nullptr;
  G4bool stable = true;
  G4double mu  = 0.0;
  G4double Eex = 0.0;
  G4int    lvl = 0;
  G4int    J   = 0;
 
  const G4IsotopeProperty* fProperty = FindIsotope(Z, A, E, flb);
  if (fProperty != nullptr )
  {
    Eex  = fProperty->GetEnergy();
    lvl  = fProperty->GetIsomerLevel();
    J    = fProperty->GetiSpin();
    life = fProperty->GetLifeTime();
    mu   = fProperty->GetMagneticMoment();    
    decayTable = fProperty->GetDecayTable();
    stable = (life <= 0.) || (decayTable == nullptr);
    lvl = fProperty->GetIsomerLevel();
    if (lvl <0) lvl=9;
  }
  else
  {
#ifdef G4VERBOSE
    if (GetVerboseLevel()>1)
    {
      G4ExceptionDescription ed;
      ed << "G4IonTable::CreateIon(): G4IsotopeProperty object is not found for"
         << " Z = " << Z << " A = " << A << " E = " << E/keV << " (keV)";
      if(flb!=G4Ions::G4FloatLevelBase::no_Float)
      {
        ed << " FloatingLevel +" << G4Ions::FloatLevelBaseChar(flb); 
      }
      ed << ".\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 temporarily    
    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 && flb==G4Ions::G4FloatLevelBase::no_Float)
    name = GetIonName(Z, A, lvl);
  else
    name = GetIonName(Z, A, Eex, flb);
 
  // PDG encoding 
  G4int encoding = GetNucleusEncoding(Z,A,E,lvl);
 
  // 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);
  static_cast<G4Ions*>(ion)->SetFloatLevelBase(flb);
 
  // 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);
 
#ifdef G4MULTITHREADED
  // Fill decay channels if this method is invoked from worker
  if(G4Threading::IsWorkerThread())
  {
    if(!stable && decayTable)
    {
      G4int nCh = decayTable->entries();
      for(G4int iCh=0; iCh<nCh; ++iCh)
      { 
        decayTable->GetDecayChannel(iCh)->GetDaughter(0); 
      }
    }
  }
#endif
  
  return ion;
}

Referenced by CreateIon(), and GetIon().

CreateIon() [2/4]

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

protected

Definition at line 491 of file G4IonTable.cc.

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

CreateIon() [3/4]

G4ParticleDefinition * G4IonTable::CreateIon ( G4int  Z, G4int  A, G4int  nL, G4double  E, G4Ions::G4FloatLevelBase  flb  )

protected

Definition at line 396 of file G4IonTable.cc.

{
  if (LL==0) return CreateIon(Z,A,E,flb);
  
  // create hyper nucleus
  G4ParticleDefinition* ion = nullptr;
 
  // check whether GenericIon has processes
  G4ParticleDefinition* genericIon = 
    G4ParticleTable::GetParticleTable()->GetGenericIon();
  G4ProcessManager* pman = nullptr;
  if (genericIon != nullptr) pman = genericIon->GetProcessManager();
  if ((genericIon == nullptr) || (genericIon->GetParticleDefinitionID() < 0)
                              || (pman==nullptr))
  {
#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 nullptr;
  }
 
  G4int J = 0;
  G4double life = 0.0;
  G4DecayTable* decayTable = nullptr;
  G4bool stable = true;
 
  // excitation energy
  // G4double Eex = G4NuclideTable::Round(E); 
  G4double Eex = E; 
  G4double mass =  GetNucleusMass(Z, A, LL)+ Eex;
  G4int    lvl = 0;
  // lvl is assigned to 9 temporarily
  if (Eex>0.0) lvl=9;
   
  // PDG encoding 
  G4int encoding = GetNucleusEncoding(Z,A,LL,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, LL, Eex, flb);
  
  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);
  static_cast<G4Ions*>(ion)->SetFloatLevelBase(flb);
 
  // No Anti particle registered
  ion->SetAntiPDGEncoding(0);
  
#ifdef G4VERBOSE
  if (GetVerboseLevel()>1)
  {
    G4cout << "G4IonTable::CreateIon() : create hyper ion of " << name
           << "  " << Z << ", " << A << ", " << LL
           << " 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;
}

CreateIon() [4/4]

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

protected

Definition at line 503 of file G4IonTable.cc.

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

DestroyWorkerG4IonTable()

void G4IonTable::DestroyWorkerG4IonTable

(

)

Definition at line 214 of file G4IonTable.cc.

{
  // delete IsotopeTable if existing
  if (fIsotopeTableList != nullptr )
  {
    for (std::size_t i=0; i<fIsotopeTableList->size(); ++i)
    {
      G4VIsotopeTable* fIsotopeTable= (*fIsotopeTableList)[i];
      if( fIsotopeTable != G4NuclideTable::GetNuclideTable() )
      {
        delete fIsotopeTable;
      }
    }
    fIsotopeTableList->clear();
    delete fIsotopeTableList;
  }
  fIsotopeTableList = nullptr;
 
 
  if (fIonList == nullptr) return;
 
  // remove all contents in the Ion List 
  // No need to delete here because all particles are dynamic objects
  fIonList->clear();
  delete fIonList;
  fIonList = nullptr;
}

Referenced by G4ParticleTable::DestroyWorkerG4ParticleTable().

DumpTable()

void G4IonTable::DumpTable

(

const G4String &

particle_name = "ALL"

)

const

Definition at line 1666 of file G4IonTable.cc.

{
  const G4ParticleDefinition* ion;
  for (auto idx = fIonList->cbegin(); idx!= fIonList->cend(); ++idx)
  {
    ion = idx->second;
    if (( particle_name == "ALL" ) || (particle_name == "all"))
    {
      ion->DumpTable();
    }
    else if ( particle_name == ion->GetParticleName() )
    {
      ion->DumpTable();
    }
  }
}

Entries()

G4int G4IonTable::Entries

(

)

const

Definition at line 1962 of file G4IonTable.cc.

{
  return (G4int)fIonList->size();
}

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

FindIon() [1/8]

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

Definition at line 791 of file G4IonTable.cc.

{ 
  return FindIon(Z,A,E,G4Ions::FloatLevelBase(flbChar),J); 
}

FindIon() [2/8]

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

Definition at line 783 of file G4IonTable.cc.

{ 
  return FindIon(Z,A,E,G4Ions::G4FloatLevelBase::no_Float,J); 
}

FindIon() [3/8]

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

Definition at line 799 of file G4IonTable.cc.

{
  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:" << G4endl
             << " Z =" << Z << "  A = " << A <<  "  E = " << E/keV << G4endl;
    }
#endif
    G4Exception("G4IonTable::FindIon()","PART107",
                JustWarning, "illegal atomic number/mass");
    return nullptr;
  }
  // Search ions with A, Z ,E
  //  !! J is omitted now !!
  const G4ParticleDefinition* ion = nullptr;
  G4bool isFound = false;
 
  // check if light ion
  ion = GetLightIon(Z,A);
  if (ion!= nullptr && E == 0.0)
  { 
    // light ion 
    isFound = true;
  }
  else
  {    
    // -- loop over all particles in Ion table
    G4int encoding = GetNucleusEncoding(Z, A);
    for(auto i = fIonList->find(encoding); i != fIonList->cend(); ++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) < pNuclideTable->GetLevelTolerance())
      {
        if(((const G4Ions*)(ion))->GetFloatLevelBase()==flb)
        {
          isFound = true;
          break;
        }
      }
    }
  }
 
  if ( isFound )
  { 
    return const_cast<G4ParticleDefinition*>(ion);
  }
  else
  {
    return nullptr;
  }
}

FindIon() [4/8]

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

Definition at line 935 of file G4IonTable.cc.

{
  if ( (A<1) || (Z<=0) || (lvl<0) || (A>999) )
  {
#ifdef G4VERBOSE
    if (GetVerboseLevel()>0)
    {
      G4cout << "G4IonTable::FindIon(): illegal atomic number/mass"
             << " or excitation level:" << G4endl 
             << " Z =" << Z << "  A = " << A <<  "  IsoLvl = " << lvl << G4endl;
    }
#endif
    G4Exception("G4IonTable::FindIon()", "PART107",
                JustWarning, "illegal atomic number/mass");
    return nullptr;
  }
  // Search ions with A, Z ,E
  //  !! J is omitted now !!
  const G4ParticleDefinition* ion = nullptr;
  G4bool isFound = false;
 
  // check if light ion
  ion = GetLightIon(Z,A);
  if (ion != nullptr && lvl==0)
  { 
    // light ion 
    isFound = true;
  }
  else
  {    
    // -- loop over all particles in Ion table
    G4int encoding=GetNucleusEncoding(Z, A);
    for(auto i = fIonList->find(encoding); i != fIonList->cend(); ++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 nullptr;
  }
}

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

FindIon() [5/8]

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

Definition at line 870 of file G4IonTable.cc.

{ 
  return FindIon(Z,A,LL,E,G4Ions::FloatLevelBase(flbChar),J); 
}

FindIon() [6/8]

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

Definition at line 862 of file G4IonTable.cc.

{ 
  return FindIon(Z,A,LL,E,G4Ions::G4FloatLevelBase::no_Float,J); 
}

FindIon() [7/8]

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

Definition at line 879 of file G4IonTable.cc.

{
  if (LL==0) return FindIon(Z,A,E,flb,J);
  
  if (A < 2 || Z < 0 || Z > A-LL || LL>A || A>999 )
  {
#ifdef G4VERBOSE
    if (GetVerboseLevel()>0)
    {
      G4cout << "G4IonTable::FindIon(): illegal atomic number/mass"
             << " or excitation level:" << G4endl
             << " Z =" << Z << "  A = " << A << " L = " << LL 
             <<"  E = " << E/keV << G4endl;
    }    
#endif
    G4Exception("G4IonTable::FindIon()", "PART107",
                JustWarning, "illegal atomic number/mass");
    return nullptr;
  }
  // Search ions with A, Z ,E
  //  !! J is omitted now !!
  const G4ParticleDefinition* ion = nullptr;
  G4bool isFound = false;
 
  // -- loop over all particles in Ion table
  G4int encoding=GetNucleusEncoding(Z, A, LL, 0.0, 0);
  for(auto i = fIonList->find(encoding); i != fIonList->cend() ; ++i)
  {
    ion = i->second;
    if ( ( ion->GetAtomicNumber() != Z) || (ion->GetAtomicMass()!=A) ) break;
    if( ion->GetQuarkContent(3) != LL ) break;
    // excitation level
    G4double anExcitaionEnergy = ((const G4Ions*)(ion))->GetExcitationEnergy();
    if (std::fabs(E - anExcitaionEnergy) < pNuclideTable->GetLevelTolerance())
    {
      if(((const G4Ions*)(ion))->GetFloatLevelBase()==flb)
      {
        isFound = true;
        break;
      }
    }
  }
 
  if ( isFound )
  { 
    return const_cast<G4ParticleDefinition*>(ion);
  }
  else
  {
    return nullptr;
  }
}

FindIon() [8/8]

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

Definition at line 998 of file G4IonTable.cc.

{
  if (LL==0) return FindIon(Z,A,lvl);
  
  if (A < 2 || Z < 0 || Z > A-LL || LL>A || A>999 )
  {
#ifdef G4VERBOSE
    if (GetVerboseLevel()>0)
    {
      G4cout << "G4IonTable::FindIon(): illegal atomic number/mass"
             << " or excitation level:" << G4endl
             << " Z =" << Z << "  A = " << A << " L = " << LL 
             <<"  IsomerLvl = " << lvl << G4endl;
    }    
#endif
    G4Exception( "G4IonTable::FindIon()", "PART107",
                 JustWarning, "illegal atomic number/mass");
    return nullptr;
  }
 
  // Search ions with A, Z ,E, lvl
  const G4ParticleDefinition* ion = nullptr;
  G4bool isFound = false;
 
  // -- loop over all particles in Ion table
  G4int encoding=GetNucleusEncoding(Z, A, LL);
  for(auto i = fIonList->find(encoding); i != fIonList->cend() ; ++i)
  {
    ion = i->second;
    if ( (ion->GetAtomicNumber() != Z) || (ion->GetAtomicMass()!=A) ) break;
    if ( ion->GetQuarkContent(3) != LL) 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 nullptr;
  }
}

FindIonInMaster() [1/4]

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

protected

Definition at line 1979 of file G4IonTable.cc.

{
  // Search ions with A, Z ,E
  //  !! J is omitted now !!
  const G4ParticleDefinition* ion = nullptr;
  G4bool isFound = false;
 
  // -- loop over all particles in Ion table
  G4int encoding=GetNucleusEncoding(Z, A);
  for(auto i = fIonListShadow->find(encoding); i != fIonListShadow->cend(); ++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) < pNuclideTable->GetLevelTolerance() )
    {
      if(((const G4Ions*)(ion))->GetFloatLevelBase()==flb)
      {
        isFound = true;
        break;
      }
    }
  }
 
  if ( isFound )
  { 
    return const_cast<G4ParticleDefinition*>(ion);
  }
  else
  {
    return nullptr;
  }
}

FindIonInMaster() [2/4]

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

protected

Definition at line 2061 of file G4IonTable.cc.

{
  // Search ions with A, Z ,E
  //  !! J is omitted now !!
  const G4ParticleDefinition* ion = nullptr;
  G4bool isFound = false;
 
  // -- loop over all particles in Ion table
  G4int encoding=GetNucleusEncoding(Z, A);
  for(auto i = fIonListShadow->find(encoding); i != fIonListShadow->cend(); ++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 nullptr;
  }
}

Referenced by GetIon().

FindIonInMaster() [3/4]

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

protected

Definition at line 2019 of file G4IonTable.cc.

{
  if (LL==0) return FindIon(Z,A,E,flb,J);
  
  // Search ions with A, Z ,E
  //  !! J is omitted now !!
  const G4ParticleDefinition* ion = nullptr;
  G4bool isFound = false;
 
  // -- loop over all particles in Ion table
  G4int encoding = GetNucleusEncoding(Z, A, LL, 0.0, 0);
  for(auto i = fIonListShadow->find(encoding); i != fIonListShadow->cend(); ++i)
  {
    ion = i->second;
    if ( ( ion->GetAtomicNumber() != Z) || (ion->GetAtomicMass()!=A) ) break;
    if(  ion->GetQuarkContent(3) != LL) break;
    // Excitation level
    G4double anExcitaionEnergy = ((const G4Ions*)(ion))->GetExcitationEnergy();
    if (std::fabs(E - anExcitaionEnergy) < pNuclideTable->GetLevelTolerance() )
    {
      if(((const G4Ions*)(ion))->GetFloatLevelBase()==flb)
      {
        isFound = true;
        break;
      }
    }
  }
 
  if ( isFound )
  { 
    return const_cast<G4ParticleDefinition*>(ion);
  }
  else
  {
    return nullptr;
  }
}

FindIonInMaster() [4/4]

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

protected

Definition at line 2096 of file G4IonTable.cc.

{
  if (LL==0) return FindIon(Z,A,lvl);
  
  // Search ions with A, Z ,E, lvl
  const G4ParticleDefinition* ion = nullptr;
  G4bool isFound = false;
 
  // -- loop over all particles in Ion table
  G4int encoding=GetNucleusEncoding(Z, A, LL);
  for(auto i = fIonListShadow->find(encoding); i != fIonListShadow->cend(); ++i)
  {
    ion = i->second;
    if ( ( ion->GetAtomicNumber() != Z) || (ion->GetAtomicMass()!=A) ) break;
    if ( ion->GetQuarkContent(3) != LL) break;
    // excitation level
    if ( ((const G4Ions*)(ion))->GetIsomerLevel() == lvl)
    {
      isFound = true;
      break;
    }
  }
 
  if ( isFound )
  { 
    return const_cast<G4ParticleDefinition*>(ion);
  }
  else
  {
    return nullptr;
  }
}

FindIsotope() [1/2]

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

protected

Definition at line 1815 of file G4IonTable.cc.

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

Referenced by CreateIon(), GetLifeTime(), and GetNucleusMass().

FindIsotope() [2/2]

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

protected

Definition at line 1837 of file G4IonTable.cc.

{
  if (fIsotopeTableList == nullptr) return nullptr;
  if (fIsotopeTableList->size()==0) return nullptr;
  
  G4IsotopeProperty* property = nullptr;
 
  // iterate 
  for (std::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;
}

GetIon() [1/9]

G4ParticleDefinition * G4IonTable::GetIon

(

G4int

encoding

)

Definition at line 759 of file G4IonTable.cc.

{
  G4int Z, A, LL, IsoLvl;
  G4double E;
  if (!GetNucleusByEncoding(encoding,Z,A,LL,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 nullptr;
  }
  return GetIon( Z, A, LL, IsoLvl);
}

GetIon() [2/9]

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

Definition at line 632 of file G4IonTable.cc.

{ 
  return GetIon(Z,A,E,G4Ions::FloatLevelBase(flbChar),J); 
}

GetIon() [3/9]

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

Definition at line 624 of file G4IonTable.cc.

{ 
  return GetIon(Z,A,E,G4Ions::G4FloatLevelBase::no_Float,J); 
}

GetIon() [4/9]

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

Definition at line 639 of file G4IonTable.cc.

{
  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 nullptr;
  }
 
  // Search ions with A, Z 
  G4ParticleDefinition* ion = FindIon(Z,A,E,flb,J);
 
  // create ion
#ifdef G4MULTITHREADED
  if(ion == nullptr )
  {
    if(G4Threading::IsWorkerThread())
    {
      G4MUTEXLOCK(&G4IonTable::ionTableMutex);
      ion = FindIonInMaster(Z,A,E,flb,J);
      if(ion == nullptr) ion = CreateIon(Z,A,E,flb);
      InsertWorker(ion);
      G4MUTEXUNLOCK(&G4IonTable::ionTableMutex);
    }
    else
    { 
      ion = CreateIon(Z,A,E,flb); 
    }
  }
#else
  if (ion == nullptr) ion = CreateIon(Z,A,E,flb);
#endif
 
  return ion;  
}

GetIon() [5/9]

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

Definition at line 522 of file G4IonTable.cc.

{
  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 nullptr;
  }
  if ( lvl == 0 ) return GetIon(Z,A,0.0);
  
  // Search ions with A, Z, lvl 
  G4ParticleDefinition* ion = FindIon(Z,A,lvl);
  
  // create ion
#ifdef G4MULTITHREADED
  if (ion == nullptr )
  {
    if(G4Threading::IsWorkerThread())
    {
      G4MUTEXLOCK(&G4IonTable::ionTableMutex);
      ion = FindIonInMaster(Z,A,lvl);
      if(ion != nullptr ) InsertWorker(ion); 
      G4MUTEXUNLOCK(&G4IonTable::ionTableMutex);
    } 
  }
#endif
  if (ion == nullptr )
  {
    G4Exception( "G4IonTable::GetIon()","PART105", JustWarning, 
      "Ion cannot be created by an isomer level. Use excitation energy.");
  }
  return ion;  
}

Referenced by G4ParticleHPFinalState::adjust_final_state(), G4ParticleHPChannelList::ApplyYourself(), G4LENDElastic::ApplyYourself(), G4LENDFission::ApplyYourself(), G4LENDModel::ApplyYourself(), G4QMDReaction::ApplyYourself(), G4NeutronRadCapture::ApplyYourself(), G4ChargeExchange::ApplyYourself(), G4HadronElastic::ApplyYourself(), G4INCLXXInterface::ApplyYourself(), G4LMsdGenerator::ApplyYourself(), G4ParticleHPCaptureFS::ApplyYourself(), G4ParticleHPFissionFS::ApplyYourself(), G4ParticleHPInelasticBaseFS::BaseApply(), G4ExcitationHandler::BreakItUp(), G4Radioactivation::CalculateChainsFromParent(), G4ParticleHPInelasticCompFS::CompositeApply(), G4Radioactivation::DecayIt(), G4ITDecay::DecayIt(), G4EmCalculator::FindIon(), G4AlphaDecay::G4AlphaDecay(), G4BetaMinusDecay::G4BetaMinusDecay(), G4BetaPlusDecay::G4BetaPlusDecay(), G4ECDecay::G4ECDecay(), G4ITDecay::G4ITDecay(), G4NeutronDecay::G4NeutronDecay(), G4ProtonDecay::G4ProtonDecay(), G4SFDecay::G4SFDecay(), G4TritonDecay::G4TritonDecay(), G4DiffuseElastic::GetInvCoulombElasticXsc(), G4NuclNuclDiffuseElastic::GetInvCoulombElasticXsc(), G4DiffuseElastic::GetInvElasticSumXsc(), G4NuclNuclDiffuseElastic::GetInvElasticSumXsc(), G4DiffuseElastic::GetInvElasticXsc(), G4NuclNuclDiffuseElastic::GetInvElasticXsc(), GetIon(), GetMuonicAtom(), G4FissionProductYieldDist::GetParticleDefinition(), G4InuclNuclei::makeDefinition(), PreloadNuclide(), G4ParticleHPIsotropic::Sample(), G4eSingleCoulombScatteringModel::SampleSecondaries(), G4IonCoulombScatteringModel::SampleSecondaries(), G4eCoulombScatteringModel::SampleSecondaries(), G4hCoulombScatteringModel::SampleSecondaries(), G4BetheHeitler5DModel::SampleSecondaries(), and G4QuasiElasticChannel::Scatter().

GetIon() [6/9]

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

Definition at line 692 of file G4IonTable.cc.

{ 
  return GetIon(Z,A,LL,E,G4Ions::FloatLevelBase(flbChar),J); 
}

GetIon() [7/9]

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

Definition at line 684 of file G4IonTable.cc.

{ 
  return GetIon(Z,A,LL,E,G4Ions::G4FloatLevelBase::no_Float,J); 
}

GetIon() [8/9]

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

Definition at line 701 of file G4IonTable.cc.

{
  if (LL==0) return GetIon(Z,A,E,flb,J);
 
  if (A < 2 || Z < 0 || Z > A-LL || LL>A || A>999 )
  {
#ifdef G4VERBOSE
    if (GetVerboseLevel()>0)
    {
      G4cout << "G4IonTable::GetIon() : illegal atomic number/mass" 
             << " Z =" << Z << "  A = " << A << " L = " << LL 
             <<"  E = " << E/keV << G4endl;
    }
#endif
    return nullptr;
  }
  else if( A==2 )
  {
#ifdef G4VERBOSE
    if (GetVerboseLevel()>0)
    {
      G4cout << "G4IonTable::GetIon() : No boud state for " 
             << " Z =" << Z << "  A = " << A << " L = " << LL 
             <<  "  E = " << E/keV << G4endl;
    }
#endif
    return nullptr;
  }
 
  // Search ions with A, Z 
  G4ParticleDefinition* ion = FindIon(Z,A,LL,E,flb,J);
 
  // create ion
#ifdef G4MULTITHREADED
  if(ion == nullptr ){
    if(G4Threading::IsWorkerThread())
    {
      G4MUTEXLOCK(&G4IonTable::ionTableMutex);
      ion = FindIonInMaster(Z,A,LL,E,flb,J);
      if(ion == nullptr) ion = CreateIon(Z,A,LL,E,flb);
      InsertWorker(ion);
      G4MUTEXUNLOCK(&G4IonTable::ionTableMutex);
    }
    else
    { 
      ion = CreateIon(Z,A,LL,E,flb); 
    }
  }
#else
  if(ion == nullptr) ion = CreateIon(Z,A,LL,E,flb);
#endif
 
  return ion;  
}

GetIon() [9/9]

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

Definition at line 563 of file G4IonTable.cc.

{
  if (LL==0) return GetIon(Z,A,lvl);
 
  if (A < 2 || Z < 0 || Z > A-LL || LL>A || A>999 )
  {
#ifdef G4VERBOSE
    if (GetVerboseLevel()>0)
    {
      G4cout << "G4IonTable::GetIon() : illegal atomic number/mass" 
             << " Z =" << Z << "  A = " << A << " L = " << LL 
             <<"  IsomerLvl = " << lvl << G4endl;
    }
#endif
    return nullptr;
  }
  else if( A==2 )
  {
#ifdef G4VERBOSE
    if (GetVerboseLevel()>0)
    {
      G4cout << "G4IonTable::GetIon() : No boud state for " 
             << " Z =" << Z << "  A = " << A << " L = " << LL 
             <<"  IsomerLvl = " << lvl << G4endl;
    }
#endif
    return nullptr;
  }
 
  // Search ions with A, Z 
  G4ParticleDefinition* ion = FindIon(Z,A,LL,lvl);
 
  // create ion
  if (ion == nullptr)
  {
    if (lvl==0)
    {
#ifdef G4MULTITHREADED
      if(G4Threading::IsWorkerThread())
      {
        G4MUTEXLOCK(&G4IonTable::ionTableMutex);
        ion = FindIonInMaster(Z,A,LL,lvl);
        if(ion == nullptr) ion = CreateIon(Z, A, LL, lvl);
        InsertWorker(ion);
        G4MUTEXUNLOCK(&G4IonTable::ionTableMutex);
      }
      else
      { 
        ion = CreateIon(Z, A, LL, lvl); 
      }
#else
      ion = CreateIon(Z, A, LL, lvl);
#endif
    } 
  }
 
  return ion;  
}

GetIonMass()

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

Definition at line 1517 of file G4IonTable.cc.

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

Referenced by G4QMDReaction::ApplyYourself(), G4BinaryLightIonReaction::ApplyYourself(), G4INCLXXInterface::ApplyYourself(), G4TheoFSGenerator::ApplyYourself(), G4ParticleHPCaptureFS::ApplyYourself(), G4StatMFFragment::GetNuclearMass(), and G4FTFModel::Init().

GetIonName() [1/4]

const G4String & G4IonTable::GetIonName	(	G4int	Z,
		G4int	A,
		G4double	E,
		G4Ions::G4FloatLevelBase	flb = G4Ions::G4FloatLevelBase::no_Float
	)		const

Definition at line 1162 of file G4IonTable.cc.

{
  static G4ThreadLocal G4String* pname = nullptr;
  if ( pname == nullptr )
  {
    pname = new G4String("");
    G4AutoDelete::Register(pname);
  }
  G4String& name = *pname;
 
  static G4ThreadLocal std::ostringstream* os = nullptr;
  if ( os == nullptr )
  {
    os = new std::ostringstream();
    G4AutoDelete::Register(os); 
    os->setf(std::ios::fixed);
    os->precision(3);
  }
 
  name = GetIonName(Z, A);
 
  // Excited energy
  if ( E>0  || flb!=G4Ions::G4FloatLevelBase::no_Float)
  {
    os->str("");
    std::ostringstream& oo = *os;
 
    // Excited nucleus
    oo<<'['<<E/keV;
    if (flb!=G4Ions::G4FloatLevelBase::no_Float)
    {
      oo<<G4Ions::FloatLevelBaseChar(flb);
    }
    oo<< ']';
    name += os->str();
  }
 
  return name;
}

GetIonName() [2/4]

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

Definition at line 1229 of file G4IonTable.cc.

{
  static G4ThreadLocal G4String* pname = nullptr;
  if ( pname == nullptr )
  {
    pname = new G4String("");
    G4AutoDelete::Register(pname);
  }
  G4String& name = *pname;
 
  static G4ThreadLocal std::ostringstream* os = nullptr;
  if ( os == nullptr )
  {
    os = new std::ostringstream();
    G4AutoDelete::Register(os);
    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;
}

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

GetIonName() [3/4]

const G4String & G4IonTable::GetIonName	(	G4int	Z,
		G4int	A,
		G4int	nL,
		G4double	E,
		G4Ions::G4FloatLevelBase	flb = G4Ions::G4FloatLevelBase::no_Float
	)		const

Definition at line 1206 of file G4IonTable.cc.

{
  if (LL==0) return GetIonName(Z, A, E, flb); 
  static G4ThreadLocal G4String* pname = nullptr;
  if (pname == nullptr)
  {
    pname = new G4String("");
    G4AutoDelete::Register(pname);
  }
  G4String& name = *pname;
  name = "";
  for (G4int i=0; i<LL; ++i)
  {
    name +="L";
  }
  name += GetIonName(Z, A, E, flb);
  return name;
}

GetIonName() [4/4]

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

Definition at line 1281 of file G4IonTable.cc.

{
  if (LL==0) return GetIonName(Z, A, lvl); 
  static G4ThreadLocal G4String* pname = nullptr;
  if ( pname == nullptr )
  {
    pname = new G4String("");
    G4AutoDelete::Register(pname);
  }
  G4String &name = *pname;
  for (G4int i=0; i<LL; ++i)
  {
    name +="L";
  }
  name += GetIonName(Z, A, lvl);
  return name;
}

GetIonTable()

G4IonTable * G4IonTable::GetIonTable ( )

static

Definition at line 170 of file G4IonTable.cc.

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

Referenced by G4ParticleHPFinalState::adjust_final_state(), G4NRESP71M03::ApplyMechanismABE(), G4ParticleHPChannelList::ApplyYourself(), G4EMDissociation::ApplyYourself(), G4LENDCapture::ApplyYourself(), G4LENDElastic::ApplyYourself(), G4LENDFission::ApplyYourself(), G4LENDInelastic::ApplyYourself(), G4LENDModel::ApplyYourself(), G4QMDReaction::ApplyYourself(), G4ParticleHPCaptureFS::ApplyYourself(), G4ParticleHPElasticFS::ApplyYourself(), G4ParticleHPFissionFS::ApplyYourself(), G4MuonMinusAtomicCapture::AtRestDoIt(), G4ParticleHPInelasticBaseFS::BaseApply(), G4ParticleHPInelasticCompFS::CompositeApply(), G4BetheHeitler5DModel::G4BetheHeitler5DModel(), G4ParticleHPIsotropic::Sample(), and G4ParticleHPContAngularPar::Sample().

GetIsomerMass()

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

Definition at line 1509 of file G4IonTable.cc.

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

GetIsotopeTable()

G4VIsotopeTable * G4IonTable::GetIsotopeTable

(

std::size_t

idx = 0

)

const

Definition at line 1802 of file G4IonTable.cc.

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

GetLifeTime() [1/3]

G4double G4IonTable::GetLifeTime

(

const G4ParticleDefinition *

particle

)

const

Definition at line 2132 of file G4IonTable.cc.

{
  if((particle->IsGeneralIon()) && (pNuclideTable == nullptr))
  {
   G4Exception("G4IonTable::GetLifeTime()", "ParticleIon1001", FatalException,
               "Method is invoked before G4IonTable is initialized.");
   return 0.;
  } 
  return particle->GetPDGLifeTime();
}

Referenced by GetLifeTime().

GetLifeTime() [2/3]

G4double G4IonTable::GetLifeTime	(	G4int	Z,
		G4int	A,
		G4double	E,
		char	flbChar
	)		const

Definition at line 2147 of file G4IonTable.cc.

{ 
  return GetLifeTime(Z,A,E,G4Ions::FloatLevelBase(flbChar)); 
}

GetLifeTime() [3/3]

G4double G4IonTable::GetLifeTime	(	G4int	Z,
		G4int	A,
		G4double	E,
		G4Ions::G4FloatLevelBase	flb = G4Ions::G4FloatLevelBase::no_Float
	)		const

Definition at line 2155 of file G4IonTable.cc.

{
  G4double life = -1001.0;
  const G4IsotopeProperty* fProperty = FindIsotope(Z, A, E, flb);
  if( fProperty != nullptr ) life = fProperty->GetLifeTime();
  return life;
}

GetLightAntiIon()

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

protected

Definition at line 1406 of file G4IonTable.cc.

{
  // Returns pointer to pre-defined ions 
  const G4ParticleDefinition* ion = nullptr;
  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);
}

GetLightIon()

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

protected

Definition at line 1378 of file G4IonTable.cc.

{
  // Returns pointer to pre-defined ions
  const G4ParticleDefinition* ion = nullptr;
  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);
}

Referenced by FindIon(), and GetNucleusMass().

GetMuonicAtom() [1/2]

G4ParticleDefinition * G4IonTable::GetMuonicAtom	(	G4int	Z,
		G4int	A
	)

Definition at line 2261 of file G4IonTable.cc.

{
  // Need the cast because we need a G4Ions* to pass into the
  // function, but GetIon returns a G4ParticleDefinition* 
  auto base = static_cast<G4Ions const*>(GetIon(Z,A, 0.0));
  return GetMuonicAtom(base);
}

GetMuonicAtom() [2/2]

G4ParticleDefinition * G4IonTable::GetMuonicAtom

(

G4Ions const *

base

)

Definition at line 2167 of file G4IonTable.cc.

{
  if (base==nullptr || !IsIon(base))
  {
    G4Exception("G4IonTable::GetMuonicAtom()", "PART987654321",
                FatalException, "Constructor argument is not a G4Ions");
    return nullptr;
  }
 
  // We're assuming here that we get a base that is actually
  // constructed and unexcited ... strip excitations, Lambdas, and
  // isomers from the encoding
 
  auto const Z = base->GetAtomicNumber();
  auto const A = base->GetAtomicMass();
  auto const baseenc = GetNucleusEncoding(Z,A);
  auto const encoding = baseenc+1000000000;
 
  // We have to do all the MT manipulations manually, because the
  // convenience functions assume a G4Ions with canonical PDG codes;
  // they recalculate the encoding from particle properties rather
  // than using the carried member function values.  Thus, they will
  // do operations on the base ion, rather than the passed in
  // G4MuonicAtom
 
  auto i = fIonList->find(encoding);
  if(i!=fIonList->cend())
  {
    return const_cast<G4ParticleDefinition*>(i->second);
  }
  // not in threadlocal list; check global list ... 
#ifdef G4MULTITHREADED
  if(G4Threading::IsWorkerThread())
  {
    G4MUTEXLOCK(&G4IonTable::ionTableMutex);
    i = fIonListShadow->find(encoding);
    auto end = fIonListShadow->cend();
    G4MUTEXUNLOCK(&G4IonTable::ionTableMutex);
    if(i!=end)
    {
      // we found it, stuff it into the threadlocal list
      fIonList->insert(*i);
      // and then return it ... 
      return const_cast<G4ParticleDefinition*>(i->second);
    }
  }
#endif
 
  // not found in either list; create and potentially insert 
  auto const name = "Mu"+GetIonName(Z,A);
 
  G4MuonicAtom* muatom = 
    G4MuonicAtomHelper::ConstructMuonicAtom(name, encoding, base);
 
  // Not sure this is doing the right thing...
  AddProcessManager(muatom);
 
  // Now, we have to push the muatom into the appropriate IonTables
  // first, recheck global list, in case another thread came along
  // before us and created this same muatom
 
#ifdef G4MULTITHREADED
  if(G4Threading::IsWorkerThread())
  {
    G4MUTEXLOCK(&G4IonTable::ionTableMutex);
    // first, we need to make sure it hasn't been inserted by some
    // other thread
    auto j = fIonListShadow->find(encoding);
    if( j!= fIonListShadow->cend() )
    {
      // oops ... someone else built a copy when we weren't looking;
      // cleanup our instantiation, and take a handle to the one in
      // the global list
      delete muatom;
      muatom = const_cast<G4MuonicAtom*>
               (static_cast<G4MuonicAtom const*>(j->second));
    }
    else
    {
      // otherwise, push onto the global list first
      fIonListShadow->insert(std::make_pair(encoding, muatom));
    }
    G4MUTEXUNLOCK(&G4IonTable::ionTableMutex);
  }
#endif  
  // in either case, push onto the the threadlocal list
  fIonList->insert(std::make_pair(encoding,muatom));
 
  return muatom; 
}

Referenced by G4MuonMinusAtomicCapture::AtRestDoIt(), and GetMuonicAtom().

GetNucleusByEncoding() [1/2]

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

static

Definition at line 1100 of file G4IonTable.cc.

{
  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;
}

Referenced by GetIon().

GetNucleusByEncoding() [2/2]

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

static

Definition at line 1124 of file G4IonTable.cc.

{
  if (encoding <= 0) return false; // anti particle   
 
  if (encoding == 3122)   // Lambda
  {
    Z = 1; A = 1; LL = 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;
  LL = encoding/10000000;
  encoding -= 10000000*LL;
  Z = encoding/10000;
  encoding -= 10000*Z;
  A = encoding/10;
  lvl = encoding % 10;
  return true;
}

GetNucleusEncoding() [1/2]

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

static

Definition at line 1055 of file G4IonTable.cc.

{
  // 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;
}

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

GetNucleusEncoding() [2/2]

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

static

Definition at line 1078 of file G4IonTable.cc.

{
  // 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.
  // LL = 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 (LL==0) return encoding; 
  encoding += LL*  10000000;
  if ( Z==1 && A==1 && E==0.0 ) encoding = 3122; // Lambda 
 
  return encoding;
}

GetNucleusMass()

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

Definition at line 1435 of file G4IonTable.cc.

{
  if ( (A<1)  || (Z<0) || (LL<0) || (lvl<0) || (lvl>9) )
  {
#ifdef G4VERBOSE
    if (GetVerboseLevel()>0)
    {
      G4cout << "G4IonTable::GetNucleusMass() : illegal atomic number/mass:"
             << G4endl
             << " Z =" << Z << "  A = " << A  
             << " L = " << LL << " lvl = " << lvl << G4endl;
    }
#endif
    G4Exception("G4IonTable::GetNucleusMass()","PART107",
                EventMustBeAborted, "illegal atomic number/mass");
    return -1.0;
  }
  
  G4double mass;
  if (LL == 0)
  {
    // calculate nucleus mass
    const G4ParticleDefinition* ion=GetLightIon(Z, A);
    
    if (ion != nullptr)
    {
      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);
      G4bool isFound = false;
      for(auto i = fIonList->find(encoding);i != fIonList->cend() ; ++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 != nullptr ) mass += fProperty->GetEnergy();
      }
    }
  }
  else
  {
    mass = G4HyperNucleiProperties::GetNuclearMass(A, Z, LL);
  }
  return mass;
}

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

GetNumberOfElements()

G4int G4IonTable::GetNumberOfElements ( ) const

inline

Definition at line 321 of file G4IonTable.hh.

{
  return numberOfElements;
}

GetParticle()

G4ParticleDefinition * G4IonTable::GetParticle

(

G4int

index

)

const

Definition at line 1905 of file G4IonTable.cc.

{
  if ( (index >=0) && (index < Entries()) )
  {
    auto idx = fIonList->cbegin();
    G4int counter = 0;
    while( idx != fIonList->cend() ) // Loop checking, 09.08.2015, K.Kurashige
    {
      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 nullptr;
}

Referenced by LBE::ConstructGeneral().

GetVerboseLevel()

G4int G4IonTable::GetVerboseLevel ( ) const

protected

Definition at line 1703 of file G4IonTable.cc.

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

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

InitializeLightIons()

void G4IonTable::InitializeLightIons

(

)

Definition at line 205 of file G4IonTable.cc.

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

Referenced by G4RunManagerKernel::SetupPhysics().

Insert()

void G4IonTable::Insert

(

const G4ParticleDefinition *

particle

)

Definition at line 1548 of file G4IonTable.cc.

{
  if (!IsIon(particle)) return;
  if (Contains(particle)) return;
 
  G4int Z = particle->GetAtomicNumber();
  G4int A = particle->GetAtomicMass();  
  G4int LL = particle->GetQuarkContent(3);  //strangeness 
  G4int encoding=GetNucleusEncoding(Z, A, LL); // encoding of the groud state 
 
  // Register the ion with its encoding of the ground state  
  fIonListShadow->insert( std::pair<const G4int,
                          const G4ParticleDefinition*>(encoding, particle) );
}

Referenced by G4ParticleTable::Insert().

InsertWorker()

void G4IonTable::InsertWorker ( const G4ParticleDefinition *  particle )

protected

Definition at line 1565 of file G4IonTable.cc.

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

Referenced by GetIon().

IsAntiIon()

G4bool G4IonTable::IsAntiIon ( const G4ParticleDefinition *  particle )

static

Definition at line 1328 of file G4IonTable.cc.

{
  // 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;
}

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

IsIon()

G4bool G4IonTable::IsIon ( const G4ParticleDefinition *  particle )

static

Definition at line 1302 of file G4IonTable.cc.

{
  // 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;
}

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

IsLightAntiIon()

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

protected

Definition at line 1366 of file G4IonTable.cc.

{
  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()).c_str())!=names+5;
} 

IsLightIon()

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

protected

Definition at line 1354 of file G4IonTable.cc.

{
  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()).c_str())!=names+5;
} 

operator=()

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

delete

PreloadNuclide()

void G4IonTable::PreloadNuclide

(

)

Definition at line 1884 of file G4IonTable.cc.

{
  if ( isIsomerCreated || !G4Threading::IsMultithreadedApplication() ) return;
 
  pNuclideTable->GenerateNuclide();
 
  for ( std::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;
}

Referenced by CreateAllIon(), and CreateAllIsomer().

PrepareNuclideTable()

void G4IonTable::PrepareNuclideTable

(

)

Definition at line 1875 of file G4IonTable.cc.

{
  if (pNuclideTable == nullptr)
    pNuclideTable = G4NuclideTable::GetNuclideTable();
}

Referenced by G4IonTable().

RegisterIsotopeTable()

void G4IonTable::RegisterIsotopeTable

(

G4VIsotopeTable *

table

)

Definition at line 1786 of file G4IonTable.cc.

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

Referenced by G4IonTable().

Remove()

void G4IonTable::Remove

(

const G4ParticleDefinition *

particle

)

Definition at line 1594 of file G4IonTable.cc.

{
  if(particle == nullptr) 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 LL = particle->GetQuarkContent(3);  // strangeness 
    G4int encoding=GetNucleusEncoding(Z, A, LL);
    if (encoding !=0 )
    {
      for(auto i = fIonListShadow->find(encoding);
               i != fIonListShadow->cend() ; ++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
  }
}

Referenced by G4ParticleTable::Remove().

size()

G4int G4IonTable::size

(

)

const

Definition at line 1970 of file G4IonTable.cc.

{
  return (G4int)fIonList->size();
}

Referenced by GetIsotopeTable().

WorkerG4IonTable()

void G4IonTable::WorkerG4IonTable

(

)

Definition at line 180 of file G4IonTable.cc.

{
  if( fIonList == nullptr ) { fIonList = new G4IonList(); }
  else                      { fIonList->clear(); }
 
  for (auto it = fIonListShadow->cbegin(); it != fIonListShadow->cend(); ++it )
  {
    fIonList->insert(*it);
  }
 
  // Do not copy Isotope Table to Worker thread
  //
  if( fIsotopeTableList == nullptr )
  {
    fIsotopeTableList = new std::vector<G4VIsotopeTable*>; 
    for (std::size_t i = 0; i < fIsotopeTableListShadow->size(); ++i)
    {
      fIsotopeTableList->push_back((*fIsotopeTableListShadow)[i]); 
    }
  }
}

Referenced by G4ParticleTable::WorkerG4ParticleTable().

Member Data Documentation

elementName

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", "Nh", "Fl", "Mc", "Lv", "Ts", "Og"
}

Definition at line 264 of file G4IonTable.hh.

Referenced by GetIonName().

fIonList

G4ThreadLocal G4IonTable::G4IonList * G4IonTable::fIonList = nullptr

static

Definition at line 252 of file G4IonTable.hh.

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

fIonListShadow

G4IonTable::G4IonList * G4IonTable::fIonListShadow = nullptr

static

Definition at line 254 of file G4IonTable.hh.

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

fIsotopeTableList

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

static

Definition at line 253 of file G4IonTable.hh.

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

fIsotopeTableListShadow

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

static

Definition at line 255 of file G4IonTable.hh.

Referenced by G4IonTable(), and WorkerG4IonTable().

---

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

• G4IonTable.hh
• G4IonTable.cc