source: trunk/source/particles/management/src/G4ParticleTable.cc @ 1340

Last change on this file since 1340 was 1340, checked in by garnier, 14 years ago

update ti head

File size: 12.8 KB
Line 
1//
2// ********************************************************************
3// * License and Disclaimer                                           *
4// *                                                                  *
5// * The  Geant4 software  is  copyright of the Copyright Holders  of *
6// * the Geant4 Collaboration.  It is provided  under  the terms  and *
7// * conditions of the Geant4 Software License,  included in the file *
8// * LICENSE and available at  http://cern.ch/geant4/license .  These *
9// * include a list of copyright holders.                             *
10// *                                                                  *
11// * Neither the authors of this software system, nor their employing *
12// * institutes,nor the agencies providing financial support for this *
13// * work  make  any representation or  warranty, express or implied, *
14// * regarding  this  software system or assume any liability for its *
15// * use.  Please see the license in the file  LICENSE  and URL above *
16// * for the full disclaimer and the limitation of liability.         *
17// *                                                                  *
18// * This  code  implementation is the result of  the  scientific and *
19// * technical work of the GEANT4 collaboration.                      *
20// * By using,  copying,  modifying or  distributing the software (or *
21// * any work based  on the software)  you  agree  to acknowledge its *
22// * use  in  resulting  scientific  publications,  and indicate your *
23// * acceptance of all terms of the Geant4 Software license.          *
24// ********************************************************************
25//
26//
27// $Id: G4ParticleTable.cc,v 1.37 2010/10/30 07:55:00 kurasige Exp $
28// GEANT4 tag $Name: particles-V09-03-15 $
29//
30// class G4ParticleTable
31//
32// Implementation
33//
34// History:
35//      modified                                Apr., 97 H.Kurashige
36//      added fParticleMessenger             14 Nov., 97 H.Kurashige
37//      added GetParticle()                  13 Dec., 97 H.Kurashige
38//      added IonTable and ShortLivedTable   27 June, 98 H.Kurashige
39//      modified FindIon                     02 Aug., 98 H.Kurashige
40//      added dictionary for encoding    24 Sep., 98 H.Kurashige
41//      fixed bugs in destruction of IonTable 08 Nov.,98 H.Kurashige
42//      commented out G4cout/G4cout in the constructor 10 Nov.,98 H.Kurashige
43//         --------------------------------
44//      modified destructor for STL interface 18 May 1999
45//      fixed  some improper codings     08 Apr., 99 H.Kurashige
46//      modified FindIon/GetIon methods  17 AUg., 99 H.Kurashige
47//      implement new version for using STL map instaed of
48//      RW PtrHashedDictionary           28 ct., 99  H.Kurashige
49
50
51#include "G4ios.hh"
52#include "globals.hh"
53#include "G4ParticleTable.hh"
54#include "G4UImessenger.hh"
55#include "G4ParticleMessenger.hh"
56#include "G4IonTable.hh"
57#include "G4ShortLivedTable.hh"
58
59////////////////////
60G4ParticleTable::G4ParticleTable()
61     :verboseLevel(1),fParticleMessenger(0),
62      noName(" "),
63      readyToUse(false)
64{
65  fDictionary = new G4PTblDictionary();
66  fIterator   = new G4PTblDicIterator( *fDictionary );
67  fEncodingDictionary = new G4PTblEncodingDictionary();
68
69 // Ion Table
70  fIonTable = new G4IonTable();
71
72  // short lived table
73  fShortLivedTable = new G4ShortLivedTable();
74}
75
76
77////////////////////
78G4ParticleTable::~G4ParticleTable()
79{
80 
81   // remove all items from G4ParticleTable
82   RemoveAllParticles();
83
84  // delete Short Lived table
85  if (fShortLivedTable!=0) delete fShortLivedTable;
86  fShortLivedTable =0;
87
88
89  //delete Ion Table
90  if (fIonTable!=0) delete fIonTable;
91  fIonTable =0;
92
93  // delete dictionary for encoding
94  if (fEncodingDictionary!=0){
95    fEncodingDictionary -> clear();
96    delete fEncodingDictionary;
97    fEncodingDictionary =0;
98  }
99
100  if(fDictionary){
101    if (fIterator!=0 )delete fIterator;
102    fIterator =0;
103
104    fDictionary->clear();
105    delete fDictionary;
106    fDictionary =0;
107  }
108
109  if (fParticleMessenger!=0) delete fParticleMessenger; 
110  fParticleMessenger =0;
111
112  fgParticleTable =0;
113
114}
115
116////////////////////
117G4ParticleTable::G4ParticleTable(const G4ParticleTable &right)
118  :verboseLevel(1),fParticleMessenger(0),
119   noName(" "),
120   readyToUse(false)
121{
122  G4Exception("G4ParticleTable::G4ParticleTable()",
123              "illegal constructor call", JustWarning,
124              "you call copy constructor of G4ParticleTable");   
125  fDictionary = new G4PTblDictionary(*(right.fDictionary));
126  fIterator   = new G4PTblDicIterator(*fDictionary);
127}
128
129
130
131// Static class variable: ptr to single instance of class
132G4ParticleTable* G4ParticleTable::fgParticleTable =0;
133
134////////////////////
135G4ParticleTable* G4ParticleTable::GetParticleTable()
136{
137    static G4ParticleTable theParticleTable;
138    if (!fgParticleTable){
139      fgParticleTable =  &theParticleTable;
140    }
141    return fgParticleTable;
142}
143
144////////////////////
145G4UImessenger* G4ParticleTable::CreateMessenger()
146{
147  if (fParticleMessenger== 0) {
148    //UI messenger
149    fParticleMessenger = new G4ParticleMessenger(this);
150  }
151  return fParticleMessenger;
152}
153
154////////////////////
155void G4ParticleTable::DeleteMessenger()
156{
157  if (fParticleMessenger!= 0) {
158    //UI messenger
159    delete fParticleMessenger;
160    fParticleMessenger= 0;
161  }
162
163}
164
165////////////////////
166void G4ParticleTable::DeleteAllParticles()
167{
168
169#ifdef G4VERBOSE
170  if (verboseLevel>1){
171    G4cout << "G4ParticleTable::DeleteAllParticles() " << G4endl;
172  }
173#endif
174
175  // delete all particles
176  G4PTblDicIterator *piter = fIterator; 
177  piter -> reset();
178  while( (*piter)() ){
179#ifdef G4VERBOSE
180    if (verboseLevel>2){
181      G4cout << "Delete " << (piter->value())->GetParticleName() 
182             << " " << (piter->value()) << G4endl;
183    }
184#endif
185    delete (piter->value());
186  }
187
188  RemoveAllParticles();
189}
190
191////////////////////
192void G4ParticleTable::RemoveAllParticles()
193{
194
195#ifdef G4VERBOSE
196  if (verboseLevel>1){
197    G4cout << "G4ParticleTable::RemoveAllParticles() " << G4endl;
198  }
199#endif
200
201  //remove all contnts in Ion Table
202  if (fIonTable!=0) {
203    fIonTable->clear();
204  }
205
206  // remomve all contents in hort Lived table
207  if (fShortLivedTable!=0) {
208    fShortLivedTable->clear();
209  }
210
211  // clear dictionary for encoding
212  if (fEncodingDictionary) {
213      fEncodingDictionary->clear();
214  }
215
216  // clear dictionary
217  if (fDictionary) {
218    fDictionary->clear();
219  }
220}
221
222////////////////////
223G4ParticleDefinition* G4ParticleTable::Insert(G4ParticleDefinition *particle)
224{
225
226  // check particle name
227  if ((particle == 0) || (GetKey(particle).isNull())) {
228#ifdef G4VERBOSE
229    if (verboseLevel>0){
230      G4cerr << "The particle[Addr:" << particle << "] has no name "<< G4endl;
231    }
232#endif
233    return 0;
234
235  }else { 
236
237    if (contains(particle)) {
238#ifdef G4VERBOSE
239      if (verboseLevel>0){
240        G4cerr << "The particle " << particle->GetParticleName() 
241               << "has been already registered in the Particle Table "<< G4endl;
242      }
243      if (verboseLevel>1){
244        FindParticle(particle) -> DumpTable();
245      }
246#endif
247      return  FindParticle(particle);
248
249    } else {
250      G4PTblDictionary *pdic =  fDictionary;
251      G4PTblEncodingDictionary *pedic =  fEncodingDictionary; 
252
253      // insert into Dictionary
254      pdic->insert( std::pair<G4String, G4ParticleDefinition*>(GetKey(particle), particle) );
255
256      // insert into EncodingDictionary
257      G4int code = particle->GetPDGEncoding();
258      if (code !=0 ) {
259        pedic->insert( std::pair<G4int, G4ParticleDefinition*>(code ,particle) );
260      }       
261
262      // insert it in IonTable if "nucleus"
263      if (fIonTable->IsIon(particle) ){
264        fIonTable->Insert(particle);
265      }
266
267      // insert it in ShortLivedTable if "shortlived"
268      if (particle->IsShortLived() ){
269        fShortLivedTable->Insert(particle);
270      }
271
272      // set Verbose Level same as ParticleTable
273      particle->SetVerboseLevel(verboseLevel);
274
275#ifdef G4VERBOSE
276      if (verboseLevel>3){
277        G4cout << "The particle "<< particle->GetParticleName() 
278               << " is inserted in the ParticleTable " << G4endl;
279      }
280#endif
281
282      return particle;
283    }
284  }
285}
286
287
288////////////////////
289G4ParticleDefinition* G4ParticleTable::Remove(G4ParticleDefinition* particle)
290{
291  G4PTblDictionary::iterator it =  fDictionary->find(GetKey(particle));
292  if (it != fDictionary->end()) {
293    fDictionary->erase(it);
294    // remove from EncodingDictionary
295    G4int code = particle->GetPDGEncoding();
296    if (code !=0 ) {
297      fEncodingDictionary->erase(fEncodingDictionary->find(code)); 
298    }
299  } else {
300    return 0;
301  }
302
303  // remove it from IonTable if "nucleus"
304  if (fIonTable->IsIon(particle) ){
305    fIonTable->Remove(particle);
306  }
307 
308  // Remove it from ShortLivedTable if "shortlived"
309  if (particle->IsShortLived() ){
310    fShortLivedTable->Remove(particle);
311  }
312
313#ifdef G4VERBOSE
314  if (verboseLevel>3){
315    G4cout << "The particle "<< particle->GetParticleName()
316           << " is removed from the ParticleTable " << G4endl;
317  }
318#endif
319
320  return particle;
321}
322
323////////////////////
324G4ParticleDefinition* G4ParticleTable::FindIon(G4int Z, G4int A, G4int , G4int )
325{
326   CheckReadiness();
327   if (Z<=0) return 0;
328   if (A<Z) return 0;
329   return fIonTable->GetIon(Z, A);
330}
331
332////////////////////
333G4ParticleDefinition* G4ParticleTable::GetIon(G4int Z, G4int A, G4double E)
334{
335   CheckReadiness();
336   if (Z<=0) return 0;
337   if (A<Z) return 0;
338   if (E<0.) return 0;
339   return fIonTable->GetIon(Z, A, E);
340}
341
342////////////////////
343G4ParticleDefinition* G4ParticleTable::GetIon(G4int Z, G4int A, G4int L, G4double E)
344{
345   CheckReadiness();
346   if (Z<=0) return 0;
347   if (A-L<Z) return 0;
348   if (L<0) return 0; 
349   if (E<0.) return 0;
350   return fIonTable->GetIon(Z, A, L, E);
351}
352
353////////////////////
354G4ParticleDefinition* G4ParticleTable::FindIon(G4int Z, G4int A, G4double E)
355{
356   CheckReadiness();
357   if (Z<=0) return 0;
358   if (A<Z) return 0;
359   if (E<0.) return 0;
360   return fIonTable->FindIon(Z, A, E);
361}
362
363////////////////////
364G4ParticleDefinition* G4ParticleTable::FindIon(G4int Z, G4int A, G4int L, G4double E)
365{
366   CheckReadiness();
367   if (Z<=0) return 0;
368   if (A-L<Z) return 0;
369   if (L<0) return 0;
370   if (E<0.) return 0;
371   return fIonTable->FindIon(Z, A, L, E);
372}
373
374////////////////////
375G4ParticleDefinition* G4ParticleTable::GetParticle(G4int index)
376{
377   CheckReadiness();
378  if ( (index >=0) && (index < entries()) ) {
379    G4PTblDicIterator *piter = fIterator; 
380    piter -> reset();
381    G4int counter = 0;
382    while( (*piter)() ){
383      if ( counter == index ) return piter->value();
384      counter++;
385    }
386  } 
387#ifdef G4VERBOSE
388  if (verboseLevel>1){
389    G4cerr << " G4ParticleTable::GetParticle"
390           << " invalid index (=" << index << ")" << G4endl;
391  }
392#endif
393  return 0;
394}
395
396////////////////////
397G4ParticleDefinition* G4ParticleTable::FindParticle(const G4ParticleDefinition *particle)
398{
399  CheckReadiness();
400  G4String key = GetKey(particle);
401  return FindParticle(key);
402}
403
404////////////////////
405G4ParticleDefinition* G4ParticleTable::FindParticle(G4int aPDGEncoding )
406{
407   CheckReadiness();
408    // check aPDGEncoding is valid
409    if (aPDGEncoding == 0){ 
410#ifdef G4VERBOSE
411      if (verboseLevel>1){
412        G4cerr << "PDGEncoding  [" <<  aPDGEncoding << "] is not valid " << G4endl;
413      }
414#endif
415      return 0;
416    }
417   
418    G4PTblEncodingDictionary *pedic =  fEncodingDictionary;
419    G4ParticleDefinition* particle =0; 
420
421    G4PTblEncodingDictionary::iterator it =  pedic->find(aPDGEncoding );
422    if (it != pedic->end()) {
423      particle = (*it).second;
424    }
425
426#ifdef G4VERBOSE
427    if ((particle == 0) && (verboseLevel>1) ){
428      G4cerr << "CODE:" << aPDGEncoding << " does not exist in ParticleTable " << G4endl;
429    }
430#endif
431    return particle;
432}
433
434////////////////////
435void G4ParticleTable::DumpTable(const G4String &particle_name) 
436{
437  CheckReadiness();
438  if (( particle_name == "ALL" ) || (particle_name == "all")){
439    // dump all particles
440    G4PTblDicIterator *piter = fIterator; 
441    piter -> reset();
442    while( (*piter)() ){
443      (piter->value())->DumpTable();
444    }
445  } else {
446    // dump only particle with name of  particle_name
447    G4ParticleDefinition *ptr;
448    ptr = FindParticle(particle_name);
449    if ( ptr != 0) {
450      ptr->DumpTable();
451    } else { 
452      G4cerr << " G4ParticleTable::DumpTable : " 
453             << particle_name << " does not exist in ParticleTable " <<G4endl;
454    }
455  }
456}
457
458void G4ParticleTable::CheckReadiness()
459{
460  if(!readyToUse) {
461   G4String msg;
462   msg = " Access to G4ParticleTable for finding a particle or equivalent\n";
463   msg += "operation occurs before G4VUserPhysicsList is instantiated and\n";
464   msg += "assigned to G4RunManager. Such an access is prohibited by\n";
465   msg += "Geant4 version 8.0. To fix this problem, please make sure that\n";
466   msg += "your main() instantiates G4VUserPhysicsList and set it to\n";
467   msg += "G4RunManager before instantiating other user classes such as\n";
468   msg += "G4VUserPrimaryParticleGeneratorAction.";
469   G4Exception("G4ParticleTable::CheckReadiness()",
470              "PartMan0000",FatalException,msg);
471  }
472}
473
474
475
476
477
478
479
Note: See TracBrowser for help on using the repository browser.