#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)

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

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

G4String	GetIonName (G4int Z, G4int A, G4int nL, G4double E, G4Ions::G4FloatLevelBase flb=G4Ions::G4FloatLevelBase::no_Float) 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 55 of file G4IonTable.hh.

◆ G4IonListIterator

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

Definition at line 56 of file G4IonTable.hh.

Member Enumeration Documentation

◆ anonymous enum

anonymous enum

Enumerator
numberOfElements

Definition at line 249 of file G4IonTable.hh.

    {
      numberOfElements = 118
    };

Constructor & Destructor Documentation

◆ G4IonTable() [1/2]

G4IonTable::G4IonTable ( )

Definition at line 110 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 132 of file G4IonTable.cc.

{
  // delete IsotopeTable if existing
  if (fIsotopeTableList != nullptr) {
    for (const auto fIsotopeTable : *fIsotopeTableList) {
      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 1213 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 ?
    auto 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(), CreateIon(), and GetMuonicAtom().

◆ clear()

void G4IonTable::clear ( )

Definition at line 1068 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 1380 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 1324 of file G4IonTable.cc.

{
  PreloadNuclide();
}

Referenced by G4ParticleMessenger::SetNewValue().

◆ CreateAllIsomer()

void G4IonTable::CreateAllIsomer ( )

Definition at line 1329 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 213 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.
  //
  // clang-format off
  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         );
  // clang-format on
 
  // 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 != nullptr)) {
      G4int nCh = decayTable->entries();
      for (G4int iCh = 0; iCh < nCh; ++iCh) {
        decayTable->GetDecayChannel(iCh)->GetDaughter(0);
      }
    }
  }
#endif
 
  return ion;
}

Referenced by CreateIon(), CreateIon(), CreateIon(), GetIon(), and GetIon().

◆ CreateIon() [2/4]

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

protected

Definition at line 433 of file G4IonTable.cc.

{
  // always create an ion for any lvl
  return CreateIon(Z, A, 0.0, G4Ions::FloatLevelBase(lvl));
}

◆ CreateIon() [3/4]

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

protected

Definition at line 348 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);
 
  // clang-format off
  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         );
  // clang-format on
 
  // 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 439 of file G4IonTable.cc.

{
  return (LL == 0) ? CreateIon(Z, A, 0.0, G4Ions::G4FloatLevelBase(lvl))
                   : CreateIon(Z, A, LL, 0.0, G4Ions::G4FloatLevelBase::no_Float);
}

◆ DestroyWorkerG4IonTable()

void G4IonTable::DestroyWorkerG4IonTable ( )

Definition at line 190 of file G4IonTable.cc.

{
  // delete IsotopeTable if existing
  if (fIsotopeTableList != nullptr) {
    for (auto fIsotopeTable : *fIsotopeTableList) {
      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 1175 of file G4IonTable.cc.

{
  const G4ParticleDefinition* ion;
  for (const auto& idx : *fIonList) {
    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 1400 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 596 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 591 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 601 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);
    const G4ParticleDefinition* ion1 = nullptr;
    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 (nullptr == ion1) ion1 = ion;
        if (((const G4Ions*)(ion))->GetFloatLevelBase() == flb) {
          isFound = true;
          break;
        }
      }
    }
    // rerun search on ground level without check on floating
    if (!isFound && E == 0.0 && nullptr != ion1) {
      isFound = true;
      ion = ion1;
    }
  }
 
  if (isFound) {
    return const_cast<G4ParticleDefinition*>(ion);
  }
 
  return nullptr;
}

◆ FindIon() [4/8]

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

Definition at line 714 of file G4IonTable.cc.

{
  return FindIon(Z, A, 0.0, G4Ions::FloatLevelBase(lvl), 0);
}

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

◆ FindIon() [5/8]

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

Definition at line 664 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 658 of file G4IonTable.cc.

{
  return (LL == 0) ? FindIon(Z, A, E, G4Ions::G4FloatLevelBase::no_Float, J)
                   : 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 670 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);
  }
 
  return nullptr;
}

◆ FindIon() [8/8]

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

Definition at line 719 of file G4IonTable.cc.

{
  return (LL == 0) ? FindIon(Z, A, 0.0, G4Ions::FloatLevelBase(lvl), 0)
                   : FindIon(Z, A, LL, 0.0, G4Ions::G4FloatLevelBase::no_Float, 0);
}

◆ FindIonInMaster() [1/4]

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

protected

Definition at line 1410 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);
  }
 
  return nullptr;
}

◆ FindIonInMaster() [2/4]

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

protected

Definition at line 1473 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);
  }
 
  return nullptr;
}

Referenced by GetIon(), and 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 1440 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);
  }
 
  return nullptr;
}

◆ FindIonInMaster() [4/4]

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

protected

Definition at line 1499 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);
  }
 
  return nullptr;
}

◆ FindIsotope() [1/2]

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

protected

Definition at line 1290 of file G4IonTable.cc.

{
  if (fIsotopeTableList == nullptr) return nullptr;
  if (fIsotopeTableList->empty()) 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 != nullptr) break;
  }
 
  return property;
}

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

◆ FindIsotope() [2/2]

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

protected

Definition at line 1307 of file G4IonTable.cc.

{
  if (fIsotopeTableList == nullptr) return nullptr;
  if (fIsotopeTableList->empty()) 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 != nullptr) break;
  }
 
  return property;
}

◆ GetIon() [1/9]

G4ParticleDefinition * G4IonTable::GetIon ( G4int encoding )

Definition at line 574 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 461 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 456 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 466 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;
  }
  auto flb1 = flb;
 
  // Search ions with A, Z
  G4ParticleDefinition* ion = FindIon(Z, A, E, flb, J);
 
  // find out ground state floating level
  if (ion == nullptr && E == 0.0) {
    const G4IsotopeProperty* fProperty = FindIsotope(Z, A, E, flb);
    if (nullptr != fProperty) {
      flb1 = fProperty->GetFloatLevelBase();
      if (flb != flb1) {
        ion = FindIon(Z, A, E, flb1, J);
      }
    }
  }
 
  // create ion
#ifdef G4MULTITHREADED
  if (ion == nullptr) {
    if (G4Threading::IsWorkerThread()) {
      G4MUTEXLOCK(&G4IonTable::ionTableMutex);
      ion = FindIonInMaster(Z, A, E, flb1, J);
      if (ion == nullptr) ion = CreateIon(Z, A, E, flb1);
      InsertWorker(ion);
      G4MUTEXUNLOCK(&G4IonTable::ionTableMutex);
    }
    else {
      ion = CreateIon(Z, A, E, flb1);
    }
  }
#else
  if (ion == nullptr) ion = CreateIon(Z, A, E, flb1);
#endif
 
  return ion;
}

◆ GetIon() [5/9]

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

Definition at line 445 of file G4IonTable.cc.

{
  return GetIon(Z, A, 0.0, G4Ions::G4FloatLevelBase(lvl), 0);
}

Referenced by G4ParticleHPFinalState::adjust_final_state(), G4ChargeExchange::ApplyYourself(), G4HadronElastic::ApplyYourself(), G4INCLXXInterface::ApplyYourself(), G4LENDElastic::ApplyYourself(), G4LENDModel::ApplyYourself(), G4LightIonQMDReaction::ApplyYourself(), G4LMsdGenerator::ApplyYourself(), G4NeutronHPCaptureFS::ApplyYourself(), G4NeutronRadCapture::ApplyYourself(), G4NeutronRadCaptureHP::ApplyYourself(), G4ParticleHPChannelList::ApplyYourself(), G4ParticleHPFissionFS::ApplyYourself(), G4QMDReaction::ApplyYourself(), G4ParticleHPInelasticBaseFS::BaseApply(), G4ExcitationHandler::BreakItUp(), G4Radioactivation::CalculateChainsFromParent(), G4ParticleHPInelasticCompFS::CompositeApply(), G4Radioactivation::DecayIt(), G4EmCalculator::FindIon(), G4AlphaDecay::G4AlphaDecay(), G4BetaMinusDecay::G4BetaMinusDecay(), G4BetaPlusDecay::G4BetaPlusDecay(), G4ECDecay::G4ECDecay(), G4NeutronDecay::G4NeutronDecay(), G4ProtonDecay::G4ProtonDecay(), G4SFDecay::G4SFDecay(), G4TritonDecay::G4TritonDecay(), G4DiffuseElastic::GetInvCoulombElasticXsc(), G4NuclNuclDiffuseElastic::GetInvCoulombElasticXsc(), G4DiffuseElastic::GetInvElasticSumXsc(), G4NuclNuclDiffuseElastic::GetInvElasticSumXsc(), G4DiffuseElastic::GetInvElasticXsc(), G4NuclNuclDiffuseElastic::GetInvElasticXsc(), GetIon(), GetIon(), GetIon(), GetIon(), GetIon(), GetIon(), GetIon(), GetIon(), GetMuonicAtom(), G4FissionProductYieldDist::GetParticleDefinition(), G4InuclNuclei::makeDefinition(), PreloadNuclide(), G4BetheHeitler5DModel::SampleSecondaries(), G4eCoulombScatteringModel::SampleSecondaries(), G4eSingleCoulombScatteringModel::SampleSecondaries(), G4hCoulombScatteringModel::SampleSecondaries(), G4IonCoulombScatteringModel::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 520 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 515 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 526 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;
  }
  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 450 of file G4IonTable.cc.

{
  return (LL == 0) ? GetIon(Z, A, 0.0, G4Ions::G4FloatLevelBase(lvl), 0)
                   : GetIon(Z, A, LL, 0.0, G4Ions::G4FloatLevelBase::no_Float, 0);
}

◆ GetIonMass()

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

Definition at line 1063 of file G4IonTable.cc.

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

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

◆ GetIonName() [1/4]

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

Definition at line 820 of file G4IonTable.cc.

{
  G4String name = GetIonName(Z, A, 0);
 
  // Excited energy or floating level
  if (E > 0 || flb != G4Ions::G4FloatLevelBase::no_Float) {
    std::ostringstream os;
    os.setf(std::ios::fixed);
    os.precision(3);
    // Excited nucleus
    os << '[' << E / keV;
    if (flb != G4Ions::G4FloatLevelBase::no_Float) {
      os << G4Ions::FloatLevelBaseChar(flb);
    }
    os << ']';
    name += os.str();
  }
 
  return name;
}

◆ GetIonName() [2/4]

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

Definition at line 854 of file G4IonTable.cc.

{
  std::ostringstream os;
 
  // Atomic number
  if ((0 < Z) && (Z <= numberOfElements)) {
    os << elementName[Z - 1];
  }
  else {
    os << "E" << Z << "-";
  }
  // Atomic Mass
  os << A;
 
  if (lvl > 0) {
    // Isomer level for Excited nucelus
    os << '[' << lvl << ']';
  }
  G4String name = os.str();
  return name;
}

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

◆ GetIonName() [3/4]

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

Definition at line 842 of file G4IonTable.cc.

{
  if (LL == 0) return GetIonName(Z, A, E, flb);
  G4String name = "";
  for (G4int i = 0; i < LL; ++i) {
    name += "L";
  }
  name += GetIonName(Z, A, E, flb);
  return name;
}

◆ GetIonName() [4/4]

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

Definition at line 876 of file G4IonTable.cc.

{
  if (LL == 0) return GetIonName(Z, A, lvl);
  G4String name = "";
  for (G4int i = 0; i < LL; ++i) {
    name += "L";
  }
  name += GetIonName(Z, A, lvl);
  return name;
}

◆ GetIonTable()

G4IonTable * G4IonTable::GetIonTable ( )

static

Definition at line 155 of file G4IonTable.cc.

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

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

◆ GetIsomerMass()

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

Definition at line 1058 of file G4IonTable.cc.

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

◆ GetIsotopeTable()

G4VIsotopeTable * G4IonTable::GetIsotopeTable ( std::size_t idx = 0 ) const

Definition at line 1281 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 1527 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 1537 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 1542 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 972 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 944 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 1632 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 1550 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 765 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 786 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 725 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(), CreateIon(), FindIon(), FindIon(), FindIonInMaster(), FindIonInMaster(), FindIonInMaster(), FindIonInMaster(), GetMuonicAtom(), GetNucleusEncoding(), G4LENDManager::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 747 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 1000 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(), CreateIon(), GetIonMass(), and GetIsomerMass().

◆ GetNumberOfElements()

G4int G4IonTable::GetNumberOfElements ( ) const

inline

Definition at line 306 of file G4IonTable.hh.

{
  return numberOfElements;
}

◆ GetParticle()

G4ParticleDefinition * G4IonTable::GetParticle ( G4int index ) const

Definition at line 1356 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 1208 of file G4IonTable.cc.

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

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

◆ InitializeLightIons()

void G4IonTable::InitializeLightIons ( )

Definition at line 184 of file G4IonTable.cc.

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

Referenced by G4RunManagerKernel::SetupPhysics().

◆ Insert()

void G4IonTable::Insert ( const G4ParticleDefinition * particle )

Definition at line 1085 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 1099 of file G4IonTable.cc.

{
  if (particle == nullptr) 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(), and GetIon().

◆ IsAntiIon()

G4bool G4IonTable::IsAntiIon ( const G4ParticleDefinition * particle )

static

Definition at line 907 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)) {
    return particle->GetBaryonNumber() < 0;
  }
 
  // 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 887 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)) {
    return particle->GetBaryonNumber() > 0;
  }
 
  // 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 935 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 927 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 1339 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 1334 of file G4IonTable.cc.

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

Referenced by G4IonTable().

◆ RegisterIsotopeTable()

void G4IonTable::RegisterIsotopeTable ( G4VIsotopeTable * table )

Definition at line 1270 of file G4IonTable.cc.

{
  // check duplication
  G4String name = table->GetName();
  for (const auto fIsotopeTable : *fIsotopeTableList) {
    if (name == fIsotopeTable->GetName()) return;
  }
  // register
  fIsotopeTableList->push_back(table);
}

Referenced by G4IonTable().

◆ Remove()

void G4IonTable::Remove ( const G4ParticleDefinition * particle )

Definition at line 1122 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;
    }
 
#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 1405 of file G4IonTable.cc.

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

Referenced by GetIsotopeTable().

◆ WorkerG4IonTable()

void G4IonTable::WorkerG4IonTable ( )

Definition at line 161 of file G4IonTable.cc.

{
  if (fIonList == nullptr) {
    fIonList = new G4IonList();
  }
  else {
    fIonList->clear();
  }
 
  for (const auto& it : *fIonListShadow) {
    fIonList->insert(it);
  }
 
  // Do not copy Isotope Table to Worker thread
  //
  if (fIsotopeTableList == nullptr) {
    fIsotopeTableList = new std::vector<G4VIsotopeTable*>;
    for (const auto i : *fIsotopeTableListShadow) {
      fIsotopeTableList->push_back(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 1192 of file G4IonTable.hh.

{
  public:
    using G4IonList = std::multimap<G4int, const G4ParticleDefinition*>;
    using G4IonListIterator = std::multimap<G4int, const G4ParticleDefinition*>::iterator;
 
    // Constructor, destructor
    G4IonTable();
    ~G4IonTable();
 
    // Forbidden copy constructor and assignment operator
    G4IonTable(const G4IonTable&) = delete;
    G4IonTable& operator=(const G4IonTable&) = delete;
 
    static G4IonTable* GetIonTable();
 
    // Method is used by each worker thread to copy the content
    // from the master thread.
    void WorkerG4IonTable();
 
    // Destructor for worker
    void DestroyWorkerG4IonTable();
 
    // Get number of elements defined in the IonTable
    G4int GetNumberOfElements() const;
 
    // Register Isotope table
    void RegisterIsotopeTable(G4VIsotopeTable* table);
 
    // G4IonTable asks properties of isotopes to G4VIsotopeTable
    // by using FindIsotope(G4IsotopeProperty* property) method
    G4VIsotopeTable* GetIsotopeTable(std::size_t idx = 0) const;
 
    // All ground state ions are created.
    // Stable ground states are defined in G4NuclearProperty
    void CreateAllIon();
 
    // All excited ions with long life time (>1.0*ns) are created.
    // Isomers are defined in G4VIsotopeTable
    void CreateAllIsomer();
 
    // All nuclide with a life time longer than certain value are created
    // prior to the event loop
    void PrepareNuclideTable();
    void PreloadNuclide();
 
    // --------------------------------------------------------------
    // FindIon/GetIon
    //   FindIon() methods return pointer of ion if it exists.
    //   GetIon() methods also return pointer of ion; the designated
    //   ion is created if it does not exist.
    //
    // !! PDGCharge in G4ParticleDefinition of ions is          !!
    // !! electric charge of nucleus (i.e. fully ionized ions)  !!
    // --------------------------------------------------------------
 
    // Find/Get "ground state" and "excited state"
    //
    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);
    // Z: Atomic Number
    // A: Atomic Mass (nn + np +nlambda)
    // nL: Number of Lambda
    // E: Excitation energy
    // lvl:  Isomer Level 0: ground state)
    // flb:  Floating level base (enum defined in G4Ions.hh)
    // flbChar:  Floating level base denoted by a character
    //           (<null>,X,Y,Z,U,V,W,R,S,T,A,B,C,D,E)
    // J: Total Angular momentum (in unit of 1/2) : not used
 
    // The ion can be retrieved by using PDG encoding
    // !! Only ground state can be obtained .i.e. Isomer = 0
    G4ParticleDefinition* GetIon(G4int encoding);
 
    // Find/Get "excited state"
    //
    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);
    // Z: Atomic Number
    // A: Atomic Mass (nn + np +nlambda)
    // nL: Number of Lambda
    // E: Excitaion energy
    // lvl:  Isomer Level 0: ground state)
    // flb:  Floating level base (enum defined in G4Ions.hh)
    // flbChar:  Floating level base denoted by a character
    //           (<null>,X,Y,Z,U,V,W,R,S,T,A,B,C,D,E)
    // J: Total Angular momentum (in unit of 1/2) : not used
 
    // Return true if the particle is ion
    static G4bool IsIon(const G4ParticleDefinition*);
 
    // Return true if the particle is anti_ion
    static G4bool IsAntiIon(const G4ParticleDefinition*);
 
    // Get ion name
    G4String GetIonName(G4int Z, G4int A, G4int lvl = 0) const;
    G4String GetIonName(G4int Z, G4int A, G4double E,
                        G4Ions::G4FloatLevelBase flb = G4Ions::G4FloatLevelBase::no_Float) const;
    G4String GetIonName(G4int Z, G4int A, G4int nL, G4double E,
                        G4Ions::G4FloatLevelBase flb = G4Ions::G4FloatLevelBase::no_Float) const;
    G4String GetIonName(G4int Z, G4int A, G4int nL, G4int lvl) const;
 
    // Get 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
    static G4int GetNucleusEncoding(G4int Z, G4int A, G4double E = 0.0, G4int lvl = 0);
 
    // 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.
    // nL = nlambda
    // I gives the isomer level, with I = 0 corresponding
    // to the ground state and I >0 to excitations
    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);
    // Energy will not be given even for excited state!!
 
    // These methods returns Nucleus (i.e. full ionized atom) mass, where
    //  Z is Atomic Number (number of protons) and
    //  A is Atomic Number (number of nucleons and hyperons)
    //  nL is number of lambda (A= nn + np + nlambda)
    //  lvl is isomer level
    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;
 
    // Returns a life time of an ion. -1 for stable ion, and -1001 for ion
    // that is not listed in G4NuclideTable
    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);
 
    // Return number of ions in the table
    G4int Entries() const;
 
    // Return the pointer of index-th ion in the table
    G4ParticleDefinition* GetParticle(G4int index) const;
 
    // Return 'true' if the ion exists
    G4bool Contains(const G4ParticleDefinition* particle) const;
 
    // Insert/Remove an ion in the table
    void Insert(const G4ParticleDefinition* particle);
    void Remove(const G4ParticleDefinition* particle);
 
    // Erase all contents in the list (not delete just remove)
    void clear();
 
    // Return number of ions in the table
    G4int size() const;
 
    // Dump information of particles specified by name
    void DumpTable(const G4String& particle_name = "ALL") const;
 
  public:
    // Needed for MT
    void InitializeLightIons();
 
    // It is very important for multithreaded Geant4 to keep only one copy of
    // the particle table pointer and the ion table pointer. However, we try
    // to let each worker thread hold its own copy of the particle dictionary
    // and the ion list. This implementation is equivalent to make the ion
    // table thread private. The two shadow ponters are used by each worker
    // thread to copy the content from the master thread
    static G4ThreadLocal G4IonList* fIonList;
    static G4ThreadLocal std::vector<G4VIsotopeTable*>* fIsotopeTableList;
    static G4IonList* fIonListShadow;
    static std::vector<G4VIsotopeTable*>* fIsotopeTableListShadow;
 
    enum
    {
      numberOfElements = 118
    };
    static const G4String elementName[numberOfElements];
 
#ifdef G4MULTITHREADED
    static G4Mutex ionTableMutex;
#endif
 
  protected:
    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);
 
    // Create Ion
 
    G4IsotopeProperty* FindIsotope(G4int Z, G4int A, G4double E,
                                   G4Ions::G4FloatLevelBase flb) const;
    G4IsotopeProperty* FindIsotope(G4int Z, G4int A, G4int lvl) const;
    // Ask properties of isotopes
 
    G4ParticleDefinition* GetLightIon(G4int Z, G4int A) const;
    G4ParticleDefinition* GetLightAntiIon(G4int Z, G4int A) const;
 
    // Return true if the particle is pre-defined ion
    G4bool IsLightIon(const G4ParticleDefinition*) const;
    G4bool IsLightAntiIon(const G4ParticleDefinition*) const;
 
    // Add process manager to ions with name of 'ionName'
    void AddProcessManager(G4ParticleDefinition*);
 
    // Get Verbose Level defined in G4ParticleTable
    G4int GetVerboseLevel() const;
 
  private:
    G4NuclideTable* pNuclideTable = nullptr;
 
    // Isomer table and flag of creation
    G4bool isIsomerCreated = false;
};
 
// ------------------------
// Inline methods
// ------------------------
 
inline G4int G4IonTable::GetNumberOfElements() const
{
  return numberOfElements;
}
 
#endif

Referenced by GetIonName().

◆ fIonList

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

static

Definition at line 244 of file G4IonTable.hh.

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

◆ fIonListShadow

G4IonTable::G4IonList * G4IonTable::fIonListShadow = nullptr

static

Definition at line 246 of file G4IonTable.hh.

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

◆ fIsotopeTableList

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

static

Definition at line 245 of file G4IonTable.hh.

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

◆ fIsotopeTableListShadow

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

static

Definition at line 247 of file G4IonTable.hh.

Referenced by G4IonTable(), and WorkerG4IonTable().

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

Public Types

Public Member Functions

Static Public Member Functions

Static Public Attributes

Protected Member Functions

Detailed Description

Member Typedef Documentation

◆ G4IonList

◆ G4IonListIterator

Member Enumeration Documentation

◆ anonymous enum

Constructor & Destructor Documentation

◆ G4IonTable() [1/2]

◆ ~G4IonTable()

◆ G4IonTable() [2/2]

Member Function Documentation

◆ AddProcessManager()

◆ clear()

◆ Contains()

◆ CreateAllIon()

◆ CreateAllIsomer()

◆ CreateIon() [1/4]

◆ CreateIon() [2/4]

◆ CreateIon() [3/4]

◆ CreateIon() [4/4]

◆ DestroyWorkerG4IonTable()

◆ DumpTable()

◆ Entries()

◆ FindIon() [1/8]

◆ FindIon() [2/8]

◆ FindIon() [3/8]

◆ FindIon() [4/8]

◆ FindIon() [5/8]

◆ FindIon() [6/8]

◆ FindIon() [7/8]

◆ FindIon() [8/8]

◆ FindIonInMaster() [1/4]

◆ FindIonInMaster() [2/4]

◆ FindIonInMaster() [3/4]

◆ FindIonInMaster() [4/4]

◆ FindIsotope() [1/2]

◆ FindIsotope() [2/2]

◆ GetIon() [1/9]

◆ GetIon() [2/9]

◆ GetIon() [3/9]

◆ GetIon() [4/9]

◆ GetIon() [5/9]

◆ GetIon() [6/9]

◆ GetIon() [7/9]

◆ GetIon() [8/9]

◆ GetIon() [9/9]

◆ GetIonMass()

◆ GetIonName() [1/4]

◆ GetIonName() [2/4]

◆ GetIonName() [3/4]

◆ GetIonName() [4/4]

◆ GetIonTable()

◆ GetIsomerMass()

◆ GetIsotopeTable()

◆ GetLifeTime() [1/3]

◆ GetLifeTime() [2/3]

◆ GetLifeTime() [3/3]

◆ GetLightAntiIon()

◆ GetLightIon()

◆ GetMuonicAtom() [1/2]

◆ GetMuonicAtom() [2/2]

◆ GetNucleusByEncoding() [1/2]

◆ GetNucleusByEncoding() [2/2]

◆ GetNucleusEncoding() [1/2]

◆ GetNucleusEncoding() [2/2]

◆ GetNucleusMass()

◆ GetNumberOfElements()

◆ GetParticle()

◆ GetVerboseLevel()

◆ InitializeLightIons()

◆ Insert()

◆ InsertWorker()

◆ IsAntiIon()

◆ IsIon()

◆ IsLightAntiIon()