| Geant4 Cross Reference |
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 // G4ProcessManager inline function members implementation
27 //
28 // - 02.12.1995, G.Cosmo - First implementation, based on object model
29 // --------------------------------------------------------------------
30
31 inline
32 void G4ProcessManager::SetParticleType(const G4ParticleDefinition* aParticle)
33 {
34 theParticleType = aParticle;
35 }
36
37 inline
38 G4ProcessVector* G4ProcessManager::GetProcessList() const
39 {
40 return theProcessList;
41 }
42
43 inline
44 G4int G4ProcessManager::GetProcessListLength() const
45 {
46 return numberOfProcesses;
47 }
48
49 inline
50 G4int G4ProcessManager::GetProcessIndex(G4VProcess* aProcess) const
51 {
52 G4int idx = G4int(theProcessList->index(aProcess));
53 if (idx>=numberOfProcesses) idx = -1;
54 return idx;
55 }
56
57 inline
58 G4int G4ProcessManager::GetProcessVectorId(G4ProcessVectorDoItIndex idx,
59 G4ProcessVectorTypeIndex typ) const
60 {
61 if ( idx == idxAtRest )
62 {
63 if (typ == typeGPIL) { return 0; }
64 else { return 1; }
65 }
66 else if ( idx == idxAlongStep )
67 {
68 if (typ == typeGPIL) { return 2; }
69 else { return 3; }
70 }
71 else if ( idx == idxPostStep )
72 {
73 if (typ == typeGPIL) { return 4; }
74 else { return 5; }
75 }
76 else
77 {
78 return -1;
79 }
80 }
81
82 inline
83 G4ProcessVector* G4ProcessManager::GetProcessVector(
84 G4ProcessVectorDoItIndex idx,
85 G4ProcessVectorTypeIndex typ
86 ) const
87 {
88 G4int ivec = GetProcessVectorId(idx, typ);
89 if ( ivec >=0 )
90 {
91 return theProcVector[ivec];
92 }
93 else
94 {
95 return nullptr;
96 }
97 }
98
99 inline
100 G4ProcessVector*
101 G4ProcessManager::GetAtRestProcessVector(G4ProcessVectorTypeIndex typ) const
102 {
103 if (typ == typeGPIL) { return theProcVector[0]; }
104 else { return theProcVector[1]; }
105 }
106
107 inline
108 G4ProcessVector*
109 G4ProcessManager::GetAlongStepProcessVector(G4ProcessVectorTypeIndex typ) const
110 {
111 if (typ == typeGPIL) { return theProcVector[2]; }
112 else { return theProcVector[3]; }
113 }
114
115 inline
116 G4ProcessVector*
117 G4ProcessManager::GetPostStepProcessVector(G4ProcessVectorTypeIndex typ) const
118 {
119 if (typ == typeGPIL) { return theProcVector[4]; }
120 else { return theProcVector[5]; }
121 }
122
123 inline
124 G4int G4ProcessManager::GetAtRestIndex(
125 G4VProcess* aProcess,
126 G4ProcessVectorTypeIndex typ
127 ) const
128 {
129 return GetProcessVectorIndex(aProcess, idxAtRest, typ);
130 }
131
132 inline
133 G4int G4ProcessManager::GetAlongStepIndex(
134 G4VProcess* aProcess,
135 G4ProcessVectorTypeIndex typ
136 ) const
137 {
138 return GetProcessVectorIndex(aProcess, idxAlongStep, typ);
139 }
140
141 inline
142 G4int G4ProcessManager::GetPostStepIndex(
143 G4VProcess* aProcess,
144 G4ProcessVectorTypeIndex typ
145 ) const
146 {
147 return GetProcessVectorIndex(aProcess, idxPostStep, typ);
148 }
149
150 inline
151 G4int G4ProcessManager::AddRestProcess(G4VProcess* aProcess, G4int ord)
152 {
153 return AddProcess(aProcess, ord, ordInActive, ordInActive);
154 }
155
156 inline
157 G4int G4ProcessManager::AddContinuousProcess(G4VProcess* aProcess, G4int ord)
158 {
159 return AddProcess(aProcess, ordInActive, ord, ordInActive);
160 }
161
162 inline
163 G4int G4ProcessManager::AddDiscreteProcess(G4VProcess* aProcess, G4int ord)
164 {
165 return AddProcess(aProcess, ordInActive, ordInActive, ord);
166 }
167
168 inline
169 G4ParticleDefinition* G4ProcessManager::GetParticleType() const
170 {
171 return (G4ParticleDefinition*)theParticleType;
172 }
173
174 inline
175 void G4ProcessManager::SetVerboseLevel(G4int value)
176 {
177 verboseLevel = value;
178 }
179
180 inline
181 G4int G4ProcessManager::GetVerboseLevel() const
182 {
183 return verboseLevel;
184 }
185