#include <G4ParticleTable.hh>

Public Types
typedef G4ParticleTableIterator < G4String, G4ParticleDefinition * >::Map	G4PTblDictionary

typedef G4ParticleTableIterator < G4String, G4ParticleDefinition * >	G4PTblDicIterator

typedef G4ParticleTableIterator< G4int, G4ParticleDefinition * >::Map	G4PTblEncodingDictionary

typedef G4ParticleTableIterator< G4int, G4ParticleDefinition * >	G4PTblEncodingDicIterator

Public Member Functions
void	SlaveG4ParticleTable ()

void	WorkerG4ParticleTable ()

virtual	~G4ParticleTable ()

G4bool	contains (const G4ParticleDefinition *particle) const

G4bool	contains (const G4String &particle_name) const

G4int	entries () const

G4int	size () const

G4ParticleDefinition *	GetParticle (G4int index) const

const G4String &	GetParticleName (G4int index) const

G4ParticleDefinition *	FindParticle (G4int PDGEncoding)

G4ParticleDefinition *	FindParticle (const G4String &particle_name)

G4ParticleDefinition *	FindParticle (const G4ParticleDefinition *particle)

G4ParticleDefinition *	FindAntiParticle (G4int PDGEncoding)

G4ParticleDefinition *	FindAntiParticle (const G4String &particle_name)

G4ParticleDefinition *	FindAntiParticle (const G4ParticleDefinition *particle)

G4PTblDicIterator *	GetIterator () const

void	DumpTable (const G4String &particle_name="ALL")

G4IonTable *	GetIonTable () const

G4ParticleDefinition *	FindIon (G4int atomicNumber, G4int atomicMass, G4double excitationEnergy)

G4ParticleDefinition *	FindIon (G4int atomicNumber, G4int atomicMass, G4int numberOfLambda, G4double excitationEnergy)

G4ParticleDefinition *	GetIon (G4int atomicNumber, G4int atomicMass, G4double excitationEnergy)

G4ParticleDefinition *	GetIon (G4int atomicNumber, G4int atomicMass, G4int numberOfLambda, G4double excitationEnergy)

G4ParticleDefinition *	GetIon (G4int atomicNumber, G4int atomicMass, G4int level)

G4ParticleDefinition *	FindIon (G4int atomicNumber, G4int atomicMass, G4int dummy1, G4int dummy2)

G4ParticleDefinition *	Insert (G4ParticleDefinition *particle)

G4ParticleDefinition *	Remove (G4ParticleDefinition *particle)

void	RemoveAllParticles ()

void	DeleteAllParticles ()

G4UImessenger *	CreateMessenger ()

void	DeleteMessenger ()

void	SetVerboseLevel (G4int value)

G4int	GetVerboseLevel () const

void	SetReadiness (G4bool val=true)

G4bool	GetReadiness () const

G4ParticleDefinition *	GetGenericIon () const

void	SetGenericIon (G4ParticleDefinition *)

Static Public Member Functions
static G4ParticleTable *	GetParticleTable ()

Static Public Attributes
static G4ThreadLocal G4ParticleMessenger *	fParticleMessenger = 0

static G4ThreadLocal G4PTblDictionary *	fDictionary = 0

static G4ThreadLocal G4PTblDicIterator *	fIterator = 0

static G4ThreadLocal G4PTblEncodingDictionary *	fEncodingDictionary = 0

static G4ParticleTable *	fgParticleTable =0

static G4IonTable *	fIonTable = 0

static G4ParticleMessenger *	fParticleMessengerShadow = 0

static G4PTblDictionary *	fDictionaryShadow = 0

static G4PTblDicIterator *	fIteratorShadow = 0

static G4PTblEncodingDictionary *	fEncodingDictionaryShadow = 0

Protected Member Functions
	G4ParticleTable ()

	G4ParticleTable (const G4ParticleTable &right)

G4ParticleTable &	operator= (const G4ParticleTable &)

const G4PTblDictionary *	GetDictionary () const

const G4String &	GetKey (const G4ParticleDefinition *particle) const

const G4PTblEncodingDictionary *	GetEncodingDictionary () const

Detailed Description

Definition at line 65 of file G4ParticleTable.hh.

Member Typedef Documentation

typedef G4ParticleTableIterator<G4String, G4ParticleDefinition*> G4ParticleTable::G4PTblDicIterator

Definition at line 78 of file G4ParticleTable.hh.

typedef G4ParticleTableIterator<G4String, G4ParticleDefinition*>::Map G4ParticleTable::G4PTblDictionary

Definition at line 77 of file G4ParticleTable.hh.

typedef G4ParticleTableIterator<G4int, G4ParticleDefinition*> G4ParticleTable::G4PTblEncodingDicIterator

Definition at line 80 of file G4ParticleTable.hh.

typedef G4ParticleTableIterator<G4int, G4ParticleDefinition*>::Map G4ParticleTable::G4PTblEncodingDictionary

Definition at line 79 of file G4ParticleTable.hh.

Constructor & Destructor Documentation

G4ParticleTable::G4ParticleTable ( )

protected

Definition at line 110 of file G4ParticleTable.cc.

References fDictionary, fDictionaryShadow, fEncodingDictionary, fEncodingDictionaryShadow, fIonTable, fIterator, and fIteratorShadow.

      :verboseLevel(1),
       noName(" "),
       readyToUse(false),
       genericIon(NULL)
 {
   fDictionary = new G4PTblDictionary();
 
   // Set up the shadow pointer used by worker threads.
   //
   if (fDictionaryShadow == 0)
   {
     fDictionaryShadow = fDictionary;
   }
 
   fIterator   = new G4PTblDicIterator( *fDictionary );
 
   // Set up the shadow pointer used by worker threads.
   //
   if (fIteratorShadow == 0)
   {
     fIteratorShadow = fIterator;
   }
  
   fEncodingDictionary = new G4PTblEncodingDictionary();
   // Set up the shadow pointer used by worker threads.
   //
   if (fEncodingDictionaryShadow == 0)
   {
     fEncodingDictionaryShadow = fEncodingDictionary;
   }
 
 
    // Ion Table
   fIonTable = new G4IonTable();
 
 }

G4ParticleTable::G4ParticleTable ( const G4ParticleTable & right )

protected

Definition at line 236 of file G4ParticleTable.cc.

References FatalException, fDictionary, fIterator, fParticleMessenger, and G4Exception().

   :verboseLevel(1),
    noName(" "),
    readyToUse(false)
 {
   fParticleMessenger = 0 ;
 
   G4Exception("G4ParticleTable::G4ParticleTable()",
           "PART001", FatalException,
           "Illegal call of copy constructor for G4ParticleTable");    
   fDictionary = new G4PTblDictionary(*(right.fDictionary));
   fIterator   = new G4PTblDicIterator(*fDictionary);
 }

G4ParticleTable::~G4ParticleTable ( )

virtual

Definition at line 200 of file G4ParticleTable.cc.

References fDictionary, fEncodingDictionary, fgParticleTable, fIonTable, fIterator, fParticleMessenger, and RemoveAllParticles().

 {
    readyToUse = false;
    
    // remove all items from G4ParticleTable
    RemoveAllParticles();
 
   //delete Ion Table 
   if (fIonTable!=0) delete fIonTable;
   fIonTable =0;
 
   // delete dictionary for encoding
   if (fEncodingDictionary!=0){
     fEncodingDictionary -> clear();
     delete fEncodingDictionary;
     fEncodingDictionary =0;
   }
 
 
   if(fDictionary){
     if (fIterator!=0 )delete fIterator;
     fIterator =0;
 
     fDictionary->clear();
     delete fDictionary;
     fDictionary =0;
   }
 
   if (fParticleMessenger!=0) delete fParticleMessenger;  
   fParticleMessenger =0;
 
   fgParticleTable =0;
 
 }

Member Function Documentation

G4bool G4ParticleTable::contains ( const G4ParticleDefinition * particle ) const

Referenced by Insert(), and G4ProcessTableMessenger::SetNewValue().

G4bool G4ParticleTable::contains ( const G4String & particle_name ) const

Definition at line 732 of file G4ParticleTable.cc.

References fDictionaryShadow.

 {
   G4PTblDictionary::iterator it =  fDictionaryShadow->find(particle_name);
   return (it != fDictionaryShadow->end());
 }

G4UImessenger * G4ParticleTable::CreateMessenger ( )

Definition at line 264 of file G4ParticleTable.cc.

References fParticleMessenger.

Referenced by G4RunManager::G4RunManager().

 {
   if (fParticleMessenger== 0) {
     //UI messenger
     fParticleMessenger = new G4ParticleMessenger(this);
   }
   return fParticleMessenger;
 }

void G4ParticleTable::DeleteAllParticles ( )

Definition at line 285 of file G4ParticleTable.cc.

References fIterator, G4cout, G4endl, GetParticleName(), RemoveAllParticles(), and G4ParticleTableIterator< K, V >::value().

Referenced by G4VUserPhysicsList::~G4VUserPhysicsList().

 {
   //set readyToUse false  
   readyToUse = false;
 
 #ifdef G4VERBOSE
   if (verboseLevel>1){
     G4cout << "G4ParticleTable::DeleteAllParticles() " << G4endl;
   }
 #endif
 
   // delete all particles 
   G4PTblDicIterator *piter = fIterator; 
   piter -> reset();
   while( (*piter)() ){
 #ifdef G4VERBOSE
     if (verboseLevel>2){
       G4cout << "Delete " << (piter->value())->GetParticleName() 
          << " " << (piter->value()) << G4endl;
     }
 #endif
     delete (piter->value());
   }
   RemoveAllParticles();
 }

void G4ParticleTable::DeleteMessenger ( )

Definition at line 274 of file G4ParticleTable.cc.

References fParticleMessenger.

Referenced by G4RunManager::~G4RunManager().

 {
   if (fParticleMessenger!= 0) {
     //UI messenger
     delete fParticleMessenger;
     fParticleMessenger= 0;
   }
 
 }

void G4ParticleTable::DumpTable ( const G4String & particle_name = "ALL" )

Definition at line 666 of file G4ParticleTable.cc.

References G4ParticleDefinition::DumpTable(), FindParticle(), fIterator, G4cout, G4endl, and G4ParticleTableIterator< K, V >::value().

Referenced by export_G4ParticleTable(), Insert(), G4ParticleGunMessenger::SetNewValue(), G4GeneralParticleSourceMessenger::SetNewValue(), and G4RunManagerKernel::SetPhysics().

 {
   CheckReadiness();
   if (( particle_name == "ALL" ) || (particle_name == "all")){
     // dump all particles 
     G4PTblDicIterator *piter = fIterator; 
     piter -> reset();
     while( (*piter)() ){
       (piter->value())->DumpTable();
     }
   } else {
     // dump only particle with name of  particle_name
     G4ParticleDefinition *ptr;
     ptr = FindParticle(particle_name);
     if ( ptr != 0) {
       ptr->DumpTable();
     } else { 
 #ifdef G4VERBOSE
       if (verboseLevel>1) {
     G4cout << " G4ParticleTable::DumpTable : " 
            << particle_name << " does not exist in ParticleTable " <<G4endl;
       }
 #endif
     }
   }
 }

G4int G4ParticleTable::entries ( ) const

Definition at line 738 of file G4ParticleTable.cc.

References fDictionary.

Referenced by export_G4ParticleTable(), G4RunManagerKernel::G4RunManagerKernel(), GetParticle(), G4FastSimulationManager::ListModels(), G4RunManagerKernel::SetPhysics(), and G4GlobalFastSimulationManager::ShowSetup().

 {
   return fDictionary->size();
 }

G4ParticleDefinition* G4ParticleTable::FindAntiParticle ( G4int PDGEncoding )

G4ParticleDefinition* G4ParticleTable::FindAntiParticle ( const G4String & particle_name )

G4ParticleDefinition* G4ParticleTable::FindAntiParticle ( const G4ParticleDefinition * particle )

G4ParticleDefinition * G4ParticleTable::FindIon	(	G4int	atomicNumber,
		G4int	atomicMass,
		G4double	excitationEnergy
	)

Definition at line 524 of file G4ParticleTable.cc.

References G4IonTable::FindIon(), fIonTable, G4Exception(), and JustWarning.

Referenced by G4LENDModel::ApplyYourself(), and G4LENDElastic::ApplyYourself().

 {
    G4Exception("G4ParticleTable::FindIon()","PART11117",JustWarning,
    "This method is obsolete and will be dropped from v10.0. Use G4IonTable::FindIon().");
    CheckReadiness();
    if (Z<=0) return 0;
    if (A<Z) return 0;
    if (E<0.) return 0;
    return fIonTable->FindIon(Z, A, E);
 }

G4ParticleDefinition * G4ParticleTable::FindIon	(	G4int	atomicNumber,
		G4int	atomicMass,
		G4int	numberOfLambda,
		G4double	excitationEnergy
	)

Definition at line 536 of file G4ParticleTable.cc.

References G4IonTable::FindIon(), fIonTable, G4Exception(), and JustWarning.

 {
    G4Exception("G4ParticleTable::FindIon()","PART11117",JustWarning,
    "This method is obsolete and will be dropped from v10.0. Use G4IonTable::FindIon().");
    CheckReadiness();
    if (Z<=0) return 0;
    if (A-L<Z) return 0;
    if (L<0) return 0;
    if (E<0.) return 0;
    return fIonTable->FindIon(Z, A, L, E);
 }

G4ParticleDefinition * G4ParticleTable::FindIon	(	G4int	atomicNumber,
		G4int	atomicMass,
		G4int	dummy1,
		G4int	dummy2
	)

Definition at line 477 of file G4ParticleTable.cc.

References fIonTable, G4Exception(), G4IonTable::GetIon(), and JustWarning.

 {
    G4Exception("G4ParticleTable::FindIon()","PART11117",JustWarning,
    "This method is obsolete and will be dropped from v10.0. Use G4IonTable::FindIon().");
    CheckReadiness();
    if (Z<=0) return 0;
    if (A<Z) return 0;
    return fIonTable->GetIon(Z, A);
 }

G4ParticleDefinition * G4ParticleTable::FindParticle ( G4int PDGEncoding )

Definition at line 620 of file G4ParticleTable.cc.

References fDictionary, fEncodingDictionary, fEncodingDictionaryShadow, G4cout, G4endl, G4MUTEXLOCK, G4MUTEXUNLOCK, GetKey(), and G4Threading::IsWorkerThread().

 {
    CheckReadiness();
     // check aPDGEncoding is valid
     if (aPDGEncoding == 0){ 
 #ifdef G4VERBOSE
       if (verboseLevel>1){
         G4cout << "PDGEncoding  [" <<  aPDGEncoding << "] is not valid " << G4endl;
       }
 #endif
       return 0;
     }
     
     G4PTblEncodingDictionary *pedic =  fEncodingDictionary;
     G4ParticleDefinition* particle =0;  
 
     G4PTblEncodingDictionary::iterator it =  pedic->find(aPDGEncoding );
     if (it != pedic->end()) {
       particle = (*it).second;
     }
 
 #ifdef G4MULTITHREADED
     if(particle == 0 && G4Threading::IsWorkerThread())
     {
       G4MUTEXLOCK(&G4ParticleTable::particleTableMutex);
       G4PTblEncodingDictionary::iterator its = fEncodingDictionaryShadow->find(aPDGEncoding);
       if(its!=fEncodingDictionaryShadow->end())
       {
         particle = (*its).second;
         fEncodingDictionary->insert(*its);
         G4String key = GetKey(particle);
         fDictionary->insert( std::pair<G4String, G4ParticleDefinition*>(key,particle) );
       }
       G4MUTEXUNLOCK(&G4ParticleTable::particleTableMutex);  
     }
 #endif
 
 #ifdef G4VERBOSE
     if ((particle == 0) && (verboseLevel>1) ){
       G4cout << "CODE:" << aPDGEncoding << " does not exist in ParticleTable " << G4endl;
     }
 #endif
     return particle;
 }

G4ParticleDefinition * G4ParticleTable::FindParticle ( const G4String & particle_name )

Definition at line 583 of file G4ParticleTable.cc.

References fDictionary, fDictionaryShadow, fEncodingDictionary, G4MUTEXLOCK, G4MUTEXUNLOCK, G4ParticleDefinition::GetPDGEncoding(), and G4Threading::IsWorkerThread().

 {
   G4PTblDictionary::iterator it =  fDictionary->find(particle_name);
   if (it != fDictionary->end()) {
     return (*it).second;
   } else {
 #ifdef G4MULTITHREADED
     G4ParticleDefinition* ptcl = 0;
     if(G4Threading::IsWorkerThread())
     {
       G4MUTEXLOCK(&G4ParticleTable::particleTableMutex);
       G4PTblDictionary::iterator its = fDictionaryShadow->find(particle_name);
       if(its != fDictionaryShadow->end())
       {
         fDictionary->insert(*its);
         ptcl = (*its).second;
         G4int code = ptcl->GetPDGEncoding();
         if(code!=0) fEncodingDictionary->insert(std::pair<G4int, G4ParticleDefinition*>(code,ptcl) );
       }
       G4MUTEXUNLOCK(&G4ParticleTable::particleTableMutex);
     }
     return ptcl;
 #else
     return 0;
 #endif
   }
 }

G4ParticleDefinition * G4ParticleTable::FindParticle ( const G4ParticleDefinition * particle )

Definition at line 612 of file G4ParticleTable.cc.

References FindParticle(), and GetKey().

 {
   CheckReadiness();
   G4String key = GetKey(particle);
   return FindParticle(key);
 }

const G4ParticleTable::G4PTblDictionary * G4ParticleTable::GetDictionary ( ) const

protected

Definition at line 717 of file G4ParticleTable.cc.

References fDictionary.

 {
   return fDictionary;
 }

const G4ParticleTable::G4PTblEncodingDictionary * G4ParticleTable::GetEncodingDictionary ( ) const

protected

Definition at line 727 of file G4ParticleTable.cc.

References fEncodingDictionary.

 {
   return fEncodingDictionary;
 }

G4ParticleDefinition* G4ParticleTable::GetGenericIon ( ) const

Referenced by G4IonTable::AddProcessManager(), G4IonTable::CreateIon(), G4RunManagerKernel::InitializePhysics(), G4VUserPhysicsList::InitializeProcessManager(), G4StackManager::PushOneTrack(), and G4RunManagerKernel::SetupPhysics().

G4ParticleDefinition * G4ParticleTable::GetIon	(	G4int	atomicNumber,
		G4int	atomicMass,
		G4double	excitationEnergy
	)

Definition at line 488 of file G4ParticleTable.cc.

References fIonTable, G4Exception(), G4IonTable::GetIon(), and JustWarning.

Referenced by export_G4ParticleTable(), G4IonCoulombScatteringModel::SampleSecondaries(), and G4ScreenedCoulombCrossSection::SelectRandomUnweightedTarget().

 {
    G4Exception("G4ParticleTable::FindIon()","PART11117",JustWarning,
    "This method is obsolete and will be dropped from v10.0. Use G4IonTable::FindIon().");
    CheckReadiness();
    if (Z<=0) return 0;
    if (A<Z) return 0;
    if (E<0.) return 0;
    return fIonTable->GetIon(Z, A, E);
 }

G4ParticleDefinition * G4ParticleTable::GetIon	(	G4int	atomicNumber,
		G4int	atomicMass,
		G4int	numberOfLambda,
		G4double	excitationEnergy
	)

Definition at line 500 of file G4ParticleTable.cc.

References fIonTable, G4Exception(), G4IonTable::GetIon(), and JustWarning.

 {
    G4Exception("G4ParticleTable::GetIon()","PART11117",JustWarning,
    "This method is obsolete and will be dropped from v10.0. Use G4IonTable::FindIon().");
    CheckReadiness();
    if (Z<=0) return 0;
    if (A-L<Z) return 0;
    if (L<0) return 0; 
    if (E<0.) return 0;
    return fIonTable->GetIon(Z, A, L, E);
 }

G4ParticleDefinition * G4ParticleTable::GetIon	(	G4int	atomicNumber,
		G4int	atomicMass,
		G4int	level
	)

Definition at line 512 of file G4ParticleTable.cc.

References fIonTable, G4Exception(), G4IonTable::GetIon(), and JustWarning.

 {
    G4Exception("G4ParticleTable::GetIon()","PART11117",JustWarning,
    "This method is obsolete and will be dropped from v10.0. Use G4IonTable::FindIon().");
    CheckReadiness();
    if (Z <= 0) return 0;
    if (A < Z) return 0;
    if (level < 0) return 0;
    return fIonTable->GetIon(Z, A, level);
 }

G4IonTable * G4ParticleTable::GetIonTable ( ) const

Definition at line 712 of file G4ParticleTable.cc.

References fIonTable.

Referenced by G4RadioactiveDecay::AddDecayRateTable(), G4BinaryLightIonReaction::ApplyYourself(), G4HadronElastic::ApplyYourself(), G4ChargeExchange::ApplyYourself(), G4TheoFSGenerator::ApplyYourself(), G4WilsonAblationModel::BreakItUp(), G4CompetitiveFission::BreakUp(), DMXPhysicsList::ConstructGeneral(), G4NuclearDecayChannel::DecayIt(), G4RadioactiveDecay::DecayIt(), G4ParticleDefinition::DumpTable(), G4eCoulombScatteringModel::G4eCoulombScatteringModel(), G4EmCalculator::G4EmCalculator(), G4EmCorrections::G4EmCorrections(), G4eSingleCoulombScatteringModel::G4eSingleCoulombScatteringModel(), G4Evaporation::G4Evaporation(), G4ExcitationHandler::G4ExcitationHandler(), G4hCoulombScatteringModel::G4hCoulombScatteringModel(), G4NeutronRadCapture::G4NeutronRadCapture(), G4ParticleDefinition::G4ParticleDefinition(), G4RadioactiveDecay::G4RadioactiveDecay(), G4GGNuclNuclCrossSection::GetCoulombBarier(), G4ComponentGGNuclNuclXsc::GetCoulombBarier(), G4TripathiCrossSection::GetElementCrossSection(), G4NuclNuclDiffuseElastic::GetInvCoulombElasticXsc(), G4DiffuseElastic::GetInvCoulombElasticXsc(), G4NuclNuclDiffuseElastic::GetInvElasticSumXsc(), G4DiffuseElastic::GetInvElasticSumXsc(), G4NuclNuclDiffuseElastic::GetInvElasticXsc(), G4DiffuseElastic::GetInvElasticXsc(), G4IonTable::GetIonTable(), G4StatMFFragment::GetNuclearMass(), G4FTFModel::Init(), G4INCL::ParticleTable::initialize(), G4RunManagerKernel::InitializePhysics(), G4InuclNuclei::makeDefinition(), G4QuasiElasticChannel::Scatter(), G4VPartonStringModel::Scatter(), G4ParticleMessenger::SetNewValue(), and G4RunManagerKernel::SetupPhysics().

 {
   return fIonTable;
 }

G4ParticleTable::G4PTblDicIterator * G4ParticleTable::GetIterator ( ) const

Definition at line 722 of file G4ParticleTable.cc.

References fIterator.

Referenced by G4ITStepProcessor::ActiveOnlyITProcess(), G4WorkerRunManager::ConstructScoringWorlds(), G4RunManager::ConstructScoringWorlds(), G4VParticlePropertyReporter::FillList(), G4ErrorTrackLengthTarget::G4ErrorTrackLengthTarget(), G4ParticleGunMessenger::G4ParticleGunMessenger(), G4VUserPhysicsList::G4VUserPhysicsList(), G4ProcessTableMessenger::GetCurrentValue(), G4ParticleMessenger::GetCurrentValue(), G4VPCData::initialize(), G4VUPLData::initialize(), G4RunManagerKernel::InitializePhysics(), G4TextPPRetriever::Retrieve(), G4ParticleMessenger::SetNewValue(), G4MTRunManagerKernel::SetUpDecayChannels(), G4RunManagerKernel::SetupPhysics(), G4WorkerRunManagerKernel::SetupShadowProcess(), and G4RunManagerKernel::SetupShadowProcess().

 {
   return fIterator;
 }

const G4String& G4ParticleTable::GetKey ( const G4ParticleDefinition * particle ) const

protected

Referenced by FindParticle(), Insert(), Remove(), and WorkerG4ParticleTable().

G4ParticleDefinition * G4ParticleTable::GetParticle ( G4int index ) const

Definition at line 550 of file G4ParticleTable.cc.

References entries(), fIterator, G4cout, G4endl, and G4ParticleTableIterator< K, V >::value().

Referenced by export_G4ParticleTable(), G4RunManagerKernel::G4RunManagerKernel(), GetParticleName(), G4RunManagerKernel::SetPhysics(), and G4GlobalFastSimulationManager::ShowSetup().

 {
    CheckReadiness();
   if ( (index >=0) && (index < entries()) ) {
     G4PTblDicIterator *piter = fIterator; 
     piter -> reset(false);
     G4int counter = 0;
     while( (*piter)() ){
       if ( counter == index ) return piter->value();
       counter++;
     }
   } 
 #ifdef G4VERBOSE
   if (verboseLevel>1){
     G4cout << " G4ParticleTable::GetParticle"
            << " invalid index (=" << index << ")" << G4endl;
   }
 #endif
   return 0;
 }

const G4String & G4ParticleTable::GetParticleName ( G4int index ) const

Definition at line 572 of file G4ParticleTable.cc.

References GetParticle(), and G4ParticleDefinition::GetParticleName().

Referenced by DeleteAllParticles(), export_G4ParticleTable(), getParticleTable(), and G4FastSimulationManager::ListModels().

 {
   G4ParticleDefinition* aParticle =GetParticle(index);
   if (aParticle != 0) {
     return aParticle->GetParticleName();
   } else {
     return noName;
   }
 }

G4ParticleTable * G4ParticleTable::GetParticleTable ( )

static

Definition at line 95 of file G4ParticleTable.cc.

References fDictionary, fgParticleTable, and WorkerG4ParticleTable().

 {
     static G4ParticleTable theParticleTable;
     if (!fgParticleTable){
       fgParticleTable =  &theParticleTable;
     }
 
     // Here we initialize all thread private data members.
     //
     if (fDictionary == 0) fgParticleTable->WorkerG4ParticleTable();
 
     return fgParticleTable;
 }

G4bool G4ParticleTable::GetReadiness ( ) const

Referenced by G4Dineutron::Definition(), G4Diproton::Definition(), G4UnboundPN::Definition(), and export_G4ParticleTable().

G4int G4ParticleTable::GetVerboseLevel ( ) const

Referenced by export_G4ParticleTable(), G4ParticleDefinition::G4ParticleDefinition(), G4ParticleMessenger::GetCurrentValue(), G4HyperNucleiProperties::GetNuclearMass(), and G4IonTable::GetVerboseLevel().

G4ParticleDefinition * G4ParticleTable::Insert ( G4ParticleDefinition * particle )

Definition at line 339 of file G4ParticleTable.cc.

References contains(), DumpTable(), FatalException, fDictionary, fDictionaryShadow, fEncodingDictionary, fEncodingDictionaryShadow, FindParticle(), fIonTable, G4cout, G4endl, G4Exception(), GetKey(), G4ParticleDefinition::GetParticleName(), G4ParticleDefinition::GetPDGEncoding(), G4IonTable::Insert(), G4IonTable::IsIon(), G4Threading::IsWorkerThread(), and G4ParticleDefinition::SetVerboseLevel().

Referenced by G4ParticleDefinition::G4ParticleDefinition().

 {
 
   // check particle name
   if ((particle == 0) || (GetKey(particle).isNull())) {
     G4Exception("G4ParticleTable::Insert()",
         "PART121", FatalException,
         "Particle witnout name can not be registered.");    
 #ifdef G4VERBOSE
     if (verboseLevel>1){
       G4cout << "The particle[Addr:" << particle << "] has no name "<< G4endl;
     }
 #endif
     return 0;
 
   }else {  
 
     if (contains(particle)) {  
 #ifdef G4VERBOSE
       if (verboseLevel>2){
         FindParticle(particle) -> DumpTable();
       }
 #endif
       G4String msg = "The particle ";
       msg += particle->GetParticleName();
       msg += "  has already been registered in the Particle Table ";
       G4Exception("G4ParticleTable::Insert()",
           "PART122", FatalException,msg);   
 ////////////////////      return  FindParticle(particle);
       return particle;
 
     } else {
       G4PTblDictionary *pdic =  fDictionaryShadow;
 
       // insert into Dictionary
       pdic->insert( std::pair<G4String, G4ParticleDefinition*>(GetKey(particle), particle) );
 #ifdef G4MULTITHREADED
       if(G4Threading::IsWorkerThread())
       { fDictionary->insert( std::pair<G4String, G4ParticleDefinition*>(GetKey(particle), particle) ); }
 #endif
 
       G4PTblEncodingDictionary *pedic =  fEncodingDictionaryShadow;  
       // insert into EncodingDictionary
       G4int code = particle->GetPDGEncoding();
       if (code !=0 ) {
         pedic->insert( std::pair<G4int, G4ParticleDefinition*>(code ,particle) );
 #ifdef G4MULTITHREADED
         if(G4Threading::IsWorkerThread())
         { fEncodingDictionary->insert( std::pair<G4int, G4ParticleDefinition*>(code ,particle) ); }
 #endif
       }       
 
       // insert it in IonTable if "nucleus"
       if (fIonTable->IsIon(particle) ){
         fIonTable->Insert(particle);
       }
 
       // set Verbose Level same as ParticleTable
       particle->SetVerboseLevel(verboseLevel);
 
 #ifdef G4VERBOSE
       if (verboseLevel>3){
         G4cout << "The particle "<< particle->GetParticleName() 
            << " is inserted in the ParticleTable " << G4endl;
       }
 #endif
 
       return particle;
     }
   }
 }

G4ParticleTable & G4ParticleTable::operator= ( const G4ParticleTable & right )

protected

Definition at line 251 of file G4ParticleTable.cc.

References FatalException, fDictionary, fIterator, and G4Exception().

 {
   if (this != &right) {
     G4Exception("G4ParticleTable::G4ParticleTable()",
         "PART001", FatalException,
         "Illegal call of assignment operator for G4ParticleTable");    
     fDictionary = new G4PTblDictionary(*(right.fDictionary));
     fIterator   = new G4PTblDicIterator(*fDictionary);
   }
   return *this;
 }

G4ParticleDefinition * G4ParticleTable::Remove ( G4ParticleDefinition * particle )

Definition at line 412 of file G4ParticleTable.cc.

References fDictionaryShadow, fEncodingDictionaryShadow, fIonTable, G4cout, G4endl, G4Exception(), G4State_PreInit, G4StateManager::GetCurrentState(), GetKey(), G4ParticleDefinition::GetParticleName(), G4ParticleDefinition::GetPDGEncoding(), G4StateManager::GetStateManager(), G4IonTable::IsIon(), G4Threading::IsWorkerThread(), JustWarning, and G4IonTable::Remove().

Referenced by G4Dineutron::Definition(), G4UnboundPN::Definition(), and G4Diproton::Definition().

 {
   if(!particle) return 0;
 #ifdef G4MULTITHREADED
   if(G4Threading::IsWorkerThread()) {
     G4ExceptionDescription ed;
     ed << "Request of removing " << particle->GetParticleName()
        << " is ignored as it is invoked from a worker thread.";
     G4Exception("G4ParticleTable::Remove()","PART10117",JustWarning,ed);
     return 0;
   }
 #endif
   if (readyToUse) {
     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("G4ParticleTable::Remove()",
         "PART117", JustWarning, msg);
       return 0;
     } else {
 #ifdef G4VERBOSE
       if (verboseLevel>0){
     G4cout << particle->GetParticleName()
            << " will be removed from the ParticleTable " << G4endl;
       }
 #endif
     }
   }
   
   G4PTblDictionary::iterator it =  fDictionaryShadow->find(GetKey(particle));
   if (it != fDictionaryShadow->end()) {
     fDictionaryShadow->erase(it);
     // remove from EncodingDictionary
     G4int code = particle->GetPDGEncoding();
     if (code !=0 ) {
       fEncodingDictionaryShadow->erase(fEncodingDictionaryShadow->find(code)); 
     }
   } else {
     return 0;
   }
 
   // remove it from IonTable if "nucleus"
   if (fIonTable->IsIon(particle) ){
     fIonTable->Remove(particle);
   }
   
 #ifdef G4VERBOSE
   if (verboseLevel>3){
     G4cout << "The particle "<< particle->GetParticleName()
            << " is removed from the ParticleTable " << G4endl;
   }
 #endif
 
   return particle;
 }

void G4ParticleTable::RemoveAllParticles ( )

Definition at line 312 of file G4ParticleTable.cc.

References G4IonTable::clear(), fDictionary, fIonTable, G4cout, G4endl, G4Exception(), and JustWarning.

Referenced by DeleteAllParticles(), and ~G4ParticleTable().

 {
   if (readyToUse) {
     G4Exception("G4ParticleTable::RemoveAllParticle()",
         "PART115", JustWarning,
         "No effects because readyToUse is true.");    
     return;
   }
   
 #ifdef G4VERBOSE
   if (verboseLevel>1){
     G4cout << "G4ParticleTable::RemoveAllParticles() " << G4endl;
   }
 #endif
 
   //remove all contnts in Ion Table
   if (fIonTable!=0) {
     fIonTable->clear();
   }
 
   // clear dictionary
   if (fDictionary) {
     fDictionary->clear();
   }
 }

void G4ParticleTable::SetGenericIon ( G4ParticleDefinition * )

Referenced by G4GenericIon::Definition().

void G4ParticleTable::SetReadiness ( G4bool val = true )

Referenced by G4Dineutron::Definition(), G4Diproton::Definition(), G4UnboundPN::Definition(), export_G4ParticleTable(), and G4RunManagerKernel::SetupPhysics().

void G4ParticleTable::SetVerboseLevel ( G4int value )

Referenced by export_G4ParticleTable(), and G4ParticleMessenger::SetNewValue().

G4int G4ParticleTable::size ( ) const

Definition at line 743 of file G4ParticleTable.cc.

References fDictionary.

Referenced by export_G4ParticleTable(), and getParticleTable().

 {
   return fDictionary->size();
 }

void G4ParticleTable::SlaveG4ParticleTable ( )

Definition at line 152 of file G4ParticleTable.cc.

References FatalException, and G4Exception().

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

void G4ParticleTable::WorkerG4ParticleTable ( )

Definition at line 157 of file G4ParticleTable.cc.

References fDictionary, fEncodingDictionary, fIonTable, fIterator, fIteratorShadow, G4MUTEXLOCK, G4MUTEXUNLOCK, GetKey(), G4ParticleDefinition::GetPDGEncoding(), G4ParticleTableIterator< K, V >::reset(), G4ParticleTableIterator< K, V >::value(), and G4IonTable::WorkerG4IonTable().

Referenced by G4WorkerRunManager::G4WorkerRunManager(), and GetParticleTable().

 {
   // The iterator for the shadow particle table is not sharable.
   //
 #ifdef G4MULTITHREADED
   G4MUTEXLOCK(&G4ParticleTable::particleTableMutex);
   G4ParticleTable::lockCount++;
 #endif
   if(fDictionary == 0) { 
     fDictionary = new G4PTblDictionary();   
   } else { 
     fDictionary->clear(); 
   }
 
   if(fEncodingDictionary == 0){
     fEncodingDictionary = new G4PTblEncodingDictionary(); 
   } else { 
     fEncodingDictionary->clear(); 
   }
 
   fIteratorShadow->reset(false);
   while( (*fIteratorShadow)() )
   {
     G4ParticleDefinition* particle = fIteratorShadow->value();
     fDictionary->insert( std::pair<G4String, G4ParticleDefinition*>(GetKey(particle), particle) );
     G4int code = particle->GetPDGEncoding();
     if (code !=0 ) {
       fEncodingDictionary->insert( std::pair<G4int, G4ParticleDefinition*>(code ,particle) );
     }
   }       
   fIterator =  new G4PTblDicIterator( *fDictionary);
 
 #ifdef G4MULTITHREADED
   G4MUTEXUNLOCK(&G4ParticleTable::particleTableMutex);
 #endif
 
   fIonTable->WorkerG4IonTable();
 
 }