| Geant4 Cross Reference |
>> 1 // This code implementation is the intellectual property of
>> 2 // the GEANT4 collaboration.
1 // 3 //
2 // ******************************************* << 4 // By copying, distributing or modifying the Program (or any work
3 // * License and Disclaimer << 5 // based on the Program) you indicate your acceptance of this statement,
4 // * << 6 // and all its terms.
5 // * The Geant4 software is copyright of th <<
6 // * the Geant4 Collaboration. It is provided <<
7 // * conditions of the Geant4 Software License <<
8 // * LICENSE and available at http://cern.ch/ <<
9 // * include a list of copyright holders. <<
10 // * <<
11 // * Neither the authors of this software syst <<
12 // * institutes,nor the agencies providing fin <<
13 // * work make any representation or warran <<
14 // * regarding this software system or assum <<
15 // * use. Please see the license in the file <<
16 // * for the full disclaimer and the limitatio <<
17 // * <<
18 // * This code implementation is the result <<
19 // * technical work of the GEANT4 collaboratio <<
20 // * By using, copying, modifying or distri <<
21 // * any work based on the software) you ag <<
22 // * use in resulting scientific publicati <<
23 // * acceptance of all terms of the Geant4 Sof <<
24 // ******************************************* <<
25 // 7 //
26 // G4ProcessTable inline methods implementatio << 8 // $Id: G4ProcessTable.icc,v 1.3 2000/03/02 01:16:05 kurasige Exp $
>> 9 // GEANT4 tag $Name: geant4-02-00 $
27 // 10 //
28 // Author: H.Kurashige, 4 August 1998 << 11 // History:
29 // ------------------------------------------- << 12 // Use STL vector instead of RW vector 1. Mar 00 H.Kurashige
30 <<
31 // ------------------------------------------- <<
32 // 13 //
>> 14 #include "G4ParticleTable.hh"
>> 15
>> 16 //////////////////////////
33 inline 17 inline
34 void G4ProcessTable::SetVerboseLevel(G4int val << 18 void G4ProcessTable::SetVerboseLevel(G4int value)
35 { 19 {
36 verboseLevel = value; 20 verboseLevel = value;
37 } 21 }
38 22
39 // ------------------------------------------- << 23 //////////////////////////
40 // <<
41 inline 24 inline
42 G4int G4ProcessTable::GetVerboseLevel() const << 25 G4int G4ProcessTable::GetVerboseLevel() const
43 { 26 {
44 return verboseLevel; 27 return verboseLevel;
45 } 28 }
46 29
47 // ------------------------------------------- << 30 //////////////////////////
48 // <<
49 inline 31 inline
50 G4int G4ProcessTable::Length() const << 32 G4int G4ProcessTable::Length() const
51 { 33 {
52 return G4int(fProcTblVector->size()); << 34 return fProcTblVector->size();
53 } 35 }
54 36
55 // ------------------------------------------- << 37 //////////////////////////
56 // <<
57 inline 38 inline
58 G4ProcessTable::G4ProcNameVector* G4ProcessTab << 39 G4ProcessTable::G4ProcNameVector* G4ProcessTable::GetNameList()
59 { 40 {
60 return fProcNameVector; << 41 return fProcNameVector;
61 } 42 }
62 43
63 // ------------------------------------------- << 44 //////////////////////////
64 // <<
65 inline 45 inline
66 G4ProcessTable::G4ProcTableVector* G4ProcessTa << 46 G4ProcessTable::G4ProcTableVector* G4ProcessTable::GetProcTableVector()
67 { 47 {
68 return fProcTblVector; 48 return fProcTblVector;
69 } 49 }
70 50
71 // ------------------------------------------- <<
72 // <<
73 inline <<
74 G4VProcess* <<
75 G4ProcessTable::FindProcess(const G4String& pr <<
76 const G4ParticleDe <<
77 { <<
78 return (particle) ? <<
79 FindProcess(processName, particle->GetProc <<
80 } <<
81 <<
82 // ------------------------------------------- <<
83 // <<
84 inline <<
85 void G4ProcessTable::SetProcessActivation(cons <<
86 cons <<
87 <<
88 { <<
89 if ( particle != nullptr ) <<
90 { <<
91 SetProcessActivation(processName, particle <<
92 } <<
93 } <<
94 51
95 // ------------------------------------------- << 52 //////////////////////////
96 // <<
97 inline 53 inline
98 void G4ProcessTable::SetProcessActivation(G4Pr << 54 G4VProcess* G4ProcessTable::FindProcess(const G4String& processName,
99 cons << 55 const G4ParticleDefinition* particle)
100 << 56 const
101 { <<
102 if ( particle != nullptr ) <<
103 { <<
104 SetProcessActivation(processType, particle <<
105 } <<
106 } <<
107 <<
108 // ------------------------------------------- <<
109 // <<
110 inline <<
111 G4ProcessVector* G4ProcessTable::FindProcesses <<
112 { 57 {
113 return ExtractProcesses(fProcTblVector); << 58 if ( particle == 0 ) return 0;
>> 59 else return FindProcess(processName, particle->GetProcessManager());
114 } 60 }
115 61
116 // ------------------------------------------- << 62 //////////////////////////
117 // << 63 inline
118 inline << 64 G4VProcess* G4ProcessTable::FindProcess(const G4String& processName,
119 G4ProcessVector* << 65 const G4String& particleName) const
120 G4ProcessTable::FindProcesses( const G4Process <<
121 { 66 {
122 G4ProcessVector* procList = pManager->GetPro << 67 return FindProcess(processName,
123 return new G4ProcessVector(*procList); << 68 G4ParticleTable::GetParticleTable()->FindParticle(particleName));
124 } 69 }
125 70
126 // ------------------------------------------- << 71
127 // << 72 //////////////////////////
128 inline << 73 inline
129 G4ProcessVector* G4ProcessTable::FindProcesses << 74 void G4ProcessTable::SetProcessActivation(
130 { << 75 const G4String& processName,
131 G4ProcTableVector* pTblVector = Find(process << 76 G4ParticleDefinition* particle,
132 return ExtractProcesses(pTblVector); << 77 G4bool fActive)
>> 78 {
>> 79 if ( particle != 0 ) {
>> 80 SetProcessActivation(processName, particle->GetProcessManager(), fActive);
>> 81 }
>> 82 }
>> 83 //////////////////////////
>> 84 inline
>> 85 void G4ProcessTable::SetProcessActivation(
>> 86 const G4String& processName,
>> 87 const G4String& particleName,
>> 88 G4bool fActive )
>> 89 {
>> 90 if (particleName == "ALL" ) {
>> 91 SetProcessActivation( processName , fActive);
>> 92 } else {
>> 93 SetProcessActivation(
>> 94 processName,
>> 95 G4ParticleTable::GetParticleTable()->FindParticle(particleName),
>> 96 fActive );
>> 97 }
133 } 98 }
134 99
135 // ------------------------------------------- << 100 //////////////////////////
136 // << 101 inline
137 inline << 102 void G4ProcessTable::SetProcessActivation(
138 G4ProcessVector* G4ProcessTable::FindProcesses << 103 G4ProcessType processType,
139 { << 104 G4ParticleDefinition* particle,
140 G4ProcTableVector* pTblVector = Find(process << 105 G4bool fActive)
141 return ExtractProcesses(pTblVector); << 106 {
>> 107 if ( particle != 0 ) {
>> 108 SetProcessActivation( processType, particle->GetProcessManager(), fActive);
>> 109 }
>> 110 }
>> 111
>> 112 //////////////////////////
>> 113 inline
>> 114 void G4ProcessTable::SetProcessActivation(
>> 115 G4ProcessType processType,
>> 116 const G4String& particleName ,
>> 117 G4bool fActive)
>> 118 {
>> 119 if ((particleName == "ALL" )||(particleName == "all" )) {
>> 120 SetProcessActivation( processType, fActive );
>> 121 } else {
>> 122 SetProcessActivation(
>> 123 processType,
>> 124 G4ParticleTable::GetParticleTable()->FindParticle(particleName),
>> 125 fActive );
>> 126 }
142 } 127 }
>> 128
143 129