| Geant4 Cross Reference |
1 // 1 //
2 // ******************************************* 2 // ********************************************************************
3 // * License and Disclaimer 3 // * License and Disclaimer *
4 // * 4 // * *
5 // * The Geant4 software is copyright of th 5 // * The Geant4 software is copyright of the Copyright Holders of *
6 // * the Geant4 Collaboration. It is provided 6 // * the Geant4 Collaboration. It is provided under the terms and *
7 // * conditions of the Geant4 Software License 7 // * conditions of the Geant4 Software License, included in the file *
8 // * LICENSE and available at http://cern.ch/ 8 // * LICENSE and available at http://cern.ch/geant4/license . These *
9 // * include a list of copyright holders. 9 // * include a list of copyright holders. *
10 // * 10 // * *
11 // * Neither the authors of this software syst 11 // * Neither the authors of this software system, nor their employing *
12 // * institutes,nor the agencies providing fin 12 // * institutes,nor the agencies providing financial support for this *
13 // * work make any representation or warran 13 // * work make any representation or warranty, express or implied, *
14 // * regarding this software system or assum 14 // * regarding this software system or assume any liability for its *
15 // * use. Please see the license in the file 15 // * use. Please see the license in the file LICENSE and URL above *
16 // * for the full disclaimer and the limitatio 16 // * for the full disclaimer and the limitation of liability. *
17 // * 17 // * *
18 // * This code implementation is the result 18 // * This code implementation is the result of the scientific and *
19 // * technical work of the GEANT4 collaboratio 19 // * technical work of the GEANT4 collaboration. *
20 // * By using, copying, modifying or distri 20 // * By using, copying, modifying or distributing the software (or *
21 // * any work based on the software) you ag 21 // * any work based on the software) you agree to acknowledge its *
22 // * use in resulting scientific publicati 22 // * use in resulting scientific publications, and indicate your *
23 // * acceptance of all terms of the Geant4 Sof 23 // * acceptance of all terms of the Geant4 Software license. *
24 // ******************************************* 24 // ********************************************************************
25 // 25 //
26 // G4VParticleChange <<
27 // 26 //
28 // Class description: << 27 // $Id: G4VParticleChange.hh 68795 2013-04-05 13:24:46Z gcosmo $
29 // 28 //
30 // Abstract class for "Particle Change". << 29 //
>> 30 // ------------------------------------------------------------
>> 31 // GEANT 4 class header file
31 // 32 //
32 // The ParticleChange class contains the resul <<
33 // of a physics process. This includes final s <<
34 // (momentum, energy, etc) and secondary parti <<
35 // interaction. <<
36 // The tracking assumes that all the values of <<
37 // in global reference system, therefore all t <<
38 // transformations must have been already comp <<
39 // data-members of this class. <<
40 // 33 //
41 // This abstract class has following four virt << 34 // ------------------------------------------------------------
>> 35 // Implemented for the new scheme 23 Mar. 1998 H.Kurahige
>> 36 //
>> 37 // Class Description
>> 38 // This class is the abstract class for ParticleChange.
>> 39 //-
>> 40 // The ParticleChange class ontains the results after invocation
>> 41 // of a physics process. This includes final states of parent
>> 42 // particle (momentum, energy, etc) and secondary particles generated
>> 43 // by the interaction.
>> 44 // The tracking assumes that all the values of energy and
>> 45 // momentum are in global reference system, therefore all the
>> 46 // needed Lorentz transformations must have been already Done
>> 47 // when filling the data-members of this class.
>> 48 //-
>> 49 //-
>> 50 // This abstract class has following four virtual methods
42 // virtual G4Step* UpdateStepForAtRest(G4S 51 // virtual G4Step* UpdateStepForAtRest(G4Step* Step);
43 // virtual G4Step* UpdateStepForAlongStep( 52 // virtual G4Step* UpdateStepForAlongStep(G4Step* Step);
44 // virtual G4Step* UpdateStepForPostStep(G 53 // virtual G4Step* UpdateStepForPostStep(G4Step* Step);
45 // virtual void Initialize(const G4Track&) 54 // virtual void Initialize(const G4Track&);
46 // The UpdateStep methods return the pointer t << 55 // The UpdateStep methods return the pointer to the G4Step
47 // the given Step information by using final s << 56 // after updating the given Step information by using final state
48 // given by a physics process. << 57 // information of the track given by a physics process.
49 // User must add methods to keep the final sta << 58 // User must add methods to keep the final state information
50 // class as well as implement UpdateStep() met << 59 // in his derived class as well as implement UpdateStep methods
>> 60 // which he want to use.
>> 61 //-
>> 62 // The Initialize methods is provided to refresh the final
>> 63 // state information and should be called by each process
>> 64 // at the beginning of DoIt.
>> 65 //
>> 66 // ------------------------------------------------------------
>> 67 // Implement Event Biasing Scheme 9 Nov.,98 H.Kurashige
>> 68 // add CheckIt 13 Apr.,99 H.Kurashige
>> 69 // add accuracy leveles 5 May, 99 H.Kurashige
>> 70 // add check secondaries 11 June, 03 H.Kurashige
>> 71 // add new methods of ProposeXXX 08 May, 04 H.Kurashige
>> 72 // remove obsolete methods of SetXXX 19 Sep, 04 H.Kurashige
>> 73 // add flag for first/last step in volume 30 Oct. 2006 H.Kurashige
>> 74 // add nonIonizingEnergyLoss 26 Mar 2007 H.Kurashige
>> 75 // modify/fix bugs related to weight 17 Sep. 2011 H.Kurashige
>> 76 // fix bugs related to weight 29 Apr. 2012 H.Kurashige
51 // 77 //
52 // The Initialize() methods are provided to re <<
53 // information and should be called by each pr <<
54 78
55 // Author: Hisaya Kurashige, 23 March 1998 << 79 #ifndef G4VParticleChange_h
56 // ------------------------------------------- << 80 #define G4VParticleChange_h 1
57 #ifndef G4VParticleChange_hh <<
58 #define G4VParticleChange_hh 1 <<
59 81
60 #include <vector> <<
61 #include "globals.hh" 82 #include "globals.hh"
62 #include "G4ios.hh" 83 #include "G4ios.hh"
>> 84 #include <cmath>
>> 85
>> 86 class G4Track;
>> 87 class G4Step;
>> 88
>> 89 #include "G4TrackFastVector.hh"
63 #include "G4TrackStatus.hh" 90 #include "G4TrackStatus.hh"
64 #include "G4SteppingControl.hh" 91 #include "G4SteppingControl.hh"
65 #include "G4Step.hh" <<
66 #include "G4Track.hh" <<
67 92
68 class G4VParticleChange << 93
>> 94 class G4VParticleChange
69 { 95 {
70 public: 96 public:
71 << 97 // default constructor
72 G4VParticleChange(); 98 G4VParticleChange();
73 99
74 virtual ~G4VParticleChange() = default; << 100 // destructor
>> 101 virtual ~G4VParticleChange();
75 102
76 G4VParticleChange(const G4VParticleChange& << 103 // equal/unequal operator
77 G4VParticleChange& operator=(const G4VPart << 104 G4bool operator==(const G4VParticleChange &right) const;
78 << 105 G4bool operator!=(const G4VParticleChange &right) const;
79 // --- the following methods are for updatin << 106 // "equal" means that teo objects have the same pointer.
80 107
>> 108 protected:
>> 109 // hide copy constructor and assignment operaor as protected
>> 110 G4VParticleChange(const G4VParticleChange &right);
>> 111 G4VParticleChange & operator=(const G4VParticleChange &right);
>> 112
>> 113 public: // with description
>> 114 // --- the following methods are for updating G4Step -----
81 virtual G4Step* UpdateStepForAtRest(G4Step 115 virtual G4Step* UpdateStepForAtRest(G4Step* Step);
82 virtual G4Step* UpdateStepForAlongStep(G4S 116 virtual G4Step* UpdateStepForAlongStep(G4Step* Step);
83 virtual G4Step* UpdateStepForPostStep(G4St 117 virtual G4Step* UpdateStepForPostStep(G4Step* Step);
84 // Return the pointer to the G4Step afte << 118 // Return the pointer to the G4Step after updating the Step information
85 // by using final state information of t << 119 // by using final state information of the track given by a physics
86 // process << 120 // process
87 << 121
88 virtual void Initialize(const G4Track&); << 122 protected: // with description
89 // This methods will be called by each p << 123 G4Step* UpdateStepInfo(G4Step* Step);
90 // of DoIt() if necessary << 124 // Update the G4Step specific attributes
91 << 125 // (i.e. SteppingControl, LocalEnergyDeposit, and TrueStepLength)
92 // --- the following methods are for TruePat <<
93 <<
94 inline G4double GetTrueStepLength() const; <<
95 inline void ProposeTrueStepLength(G4double <<
96 // Get/Propose theTrueStepLength <<
97 <<
98 // --- the following methods are for LocalEn <<
99 <<
100 inline G4double GetLocalEnergyDeposit() co <<
101 inline void ProposeLocalEnergyDeposit(G4do <<
102 // Get/Propose the locally deposited ene <<
103 <<
104 // --- the following methods are for nonIoni <<
105 <<
106 inline G4double GetNonIonizingEnergyDeposi <<
107 inline void ProposeNonIonizingEnergyDeposi <<
108 // Get/Propose the non-ionizing deposite <<
109 <<
110 // --- the following methods are for TrackSt <<
111 <<
112 inline G4TrackStatus GetTrackStatus() cons <<
113 inline void ProposeTrackStatus(G4TrackStat <<
114 // Get/Propose the final TrackStatus of <<
115 <<
116 inline const G4Track* GetCurrentTrack() co <<
117 // Get primary track pointer <<
118 <<
119 // --- the following methods are for managem <<
120 <<
121 inline G4SteppingControl GetSteppingContro <<
122 inline void ProposeSteppingControl(G4Stepp <<
123 // Set/Propose a flag to control steppin <<
124 126
125 // --- the following methods are for managem <<
126 127
127 inline G4bool GetFirstStepInVolume() const << 128 public: // with description
128 inline G4bool GetLastStepInVolume() const; << 129 virtual void Initialize(const G4Track&);
129 inline void ProposeFirstStepInVolume(G4boo << 130 // This methods will be called by each process at the beginning of DoIt
130 inline void ProposeLastStepInVolume(G4bool << 131 // if necessary.
131 132
132 // --- the following methods are for managem << 133 protected:
>> 134 void InitializeTrueStepLength(const G4Track&);
>> 135 void InitializeLocalEnergyDeposit(const G4Track&);
>> 136 void InitializeSteppingControl(const G4Track&);
>> 137 void InitializeParentWeight(const G4Track&);
>> 138 void InitializeParentGlobalTime(const G4Track&);
>> 139
>> 140 void InitializeStatusChange(const G4Track&);
>> 141 void InitializeSecondaries(const G4Track&);
>> 142 void InitializeStepInVolumeFlags(const G4Track&);
>> 143 // ------------------------------------------------------
>> 144
>> 145 public: // with description
>> 146 //---- the following methods are for TruePathLength ----
>> 147 G4double GetTrueStepLength() const;
>> 148 void ProposeTrueStepLength(G4double truePathLength);
>> 149 // Get/Propose theTrueStepLength
>> 150
>> 151 //---- the following methods are for LocalEnergyDeposit ----
>> 152 G4double GetLocalEnergyDeposit() const;
>> 153 void ProposeLocalEnergyDeposit(G4double anEnergyPart);
>> 154 // Get/Propose the locally deposited energy
>> 155
>> 156 //---- the following methods are for nonIonizingEnergyDeposit ----
>> 157 G4double GetNonIonizingEnergyDeposit() const;
>> 158 void ProposeNonIonizingEnergyDeposit(G4double anEnergyPart);
>> 159 // Get/Propose the non-ionizing deposited energy
>> 160
>> 161 //---- the following methods are for TrackStatus -----
>> 162 G4TrackStatus GetTrackStatus() const;
>> 163 void ProposeTrackStatus(G4TrackStatus status);
>> 164 // Get/Propose the final TrackStatus of the current particle.
>> 165 // ------------------------------------------------------
>> 166
>> 167 //---- the following methods are for managements of SteppingControl --
>> 168 G4SteppingControl GetSteppingControl() const;
>> 169 void ProposeSteppingControl(G4SteppingControl StepControlFlag);
>> 170 // Set/Propose a flag to control stepping manager behavier
>> 171 // ------------------------------------------------------
>> 172
>> 173 //---- the following methods are for managements of initial/last step
>> 174 G4bool GetFirstStepInVolume() const;
>> 175 G4bool GetLastStepInVolume() const;
>> 176 void ProposeFirstStepInVolume(G4bool flag);
>> 177 void ProposeLastStepInVolume(G4bool flag);
>> 178
>> 179 //---- the following methods are for managements of secondaries --
>> 180 void Clear();
>> 181 // Clear the contents of this objects
>> 182 // This method should be called after the Tracking(Stepping)
>> 183 // manager removes all secondaries in theListOfSecondaries
>> 184
>> 185 void SetNumberOfSecondaries(G4int totSecondaries);
>> 186 // SetNumberOfSecondaries must be called just before AddSecondary()
>> 187 // in order to secure memory space for theListOfSecondaries
>> 188 // This method resets theNumberOfSecondaries to 0
>> 189 // (that will be incremented at every AddSecondary() call).
>> 190
>> 191 G4int GetNumberOfSecondaries() const;
>> 192 // Returns the number of secondaries current stored in
>> 193 // G4TrackFastVector.
>> 194
>> 195 G4Track* GetSecondary(G4int anIndex) const;
>> 196 // Returns the pointer to the generated secondary particle
>> 197 // which is specified by an Index.
133 198
134 inline void Clear(); << 199 void AddSecondary(G4Track* aSecondary);
135 // Clear the contents of this objects << 200 // Add a secondary particle to theListOfSecondaries.
136 // This method should be called after th << 201 // ------------------------------------------------------
137 // manager removes all secondaries in th <<
138 202
139 inline void SetNumberOfSecondaries(G4int t << 203 G4double GetWeight() const;
140 // SetNumberOfSecondaries must be called << 204 G4double GetParentWeight() const ;
141 // in order to secure memory space for t << 205 // Get weight of the parent (i.e. current) track
142 // This method resets theNumberOfSeconda << 206 void ProposeWeight(G4double finalWeight);
143 // (that will be incremented at every Ad << 207 void ProposeParentWeight(G4double finalWeight);
>> 208 // Propse new weight of the parent (i.e. current) track
>> 209 // As for AlongStepDoIt, the parent weight will be set
>> 210 // in accumulated manner
>> 211 // i.e.) If two processes propose weight of W1 and W2 respectively
>> 212 // for the track with initial weight of W0
>> 213 // the final weight is set to
>> 214 // (W1/W0) * (W2/W0) * W0
>> 215
>> 216 void SetSecondaryWeightByProcess(G4bool);
>> 217 G4bool IsSecondaryWeightSetByProcess() const;
>> 218 // In default (fSecondaryWeightByProcess flag is false),
>> 219 // the weight of secondary tracks will be set to
>> 220 // the parent weight
>> 221 // If fSecondaryWeightByProcess flag is true,
>> 222 // the weight of secondary tracks will not be changed
>> 223 // by the ParticleChange
>> 224 // (i.e. the process determine the secodary weight)
>> 225 // NOTE:
>> 226 // Make sure that only one processe in AlongStepDoIt
>> 227 // proposes the parent weight,
>> 228 // If several processes in AlongStepDoIt proposes
>> 229 // the parent weight and add secondaties with
>> 230 // fSecondaryWeightByProcess is set to false,
>> 231 // secondary weights may be wrong
>> 232
>> 233 void SetParentWeightByProcess(G4bool);
>> 234 G4bool IsParentWeightSetByProcess() const;
>> 235 // Obsolete
144 236
145 inline G4int GetNumberOfSecondaries() cons << 237 virtual void DumpInfo() const;
146 // Returns the number of secondaries cur << 238 // Print out information
147 239
148 inline G4Track* GetSecondary(G4int anIndex << 240 void SetVerboseLevel(G4int vLevel);
149 // Returns the pointer to the generated << 241 G4int GetVerboseLevel() const;
150 // which is specified by an Index, no ch <<
151 242
152 void AddSecondary(G4Track* aSecondary); << 243 protected:
153 // Adds a secondary particle to theListO <<
154 244
155 // --- the following methods are for managem << 245 G4TrackFastVector* theListOfSecondaries;
>> 246 // The vector of secondaries.
156 247
157 inline G4double GetWeight() const; << 248 G4int theNumberOfSecondaries;
158 inline G4double GetParentWeight() const; << 249 // The total number of secondaries produced by each process.
159 // Get weight of the parent (i.e. curren <<
160 <<
161 inline void ProposeWeight(G4double finalWe <<
162 inline void ProposeParentWeight(G4double f <<
163 // Propose new weight of the parent (i.e <<
164 // As for AlongStepDoIt, the parent weig <<
165 // in accumulated manner, i.e. - If two <<
166 // weight of W1 and W2 respectively for <<
167 // weight of W0 the final weight is set <<
168 <<
169 inline void SetSecondaryWeightByProcess(G4 <<
170 inline G4bool IsSecondaryWeightSetByProces <<
171 // In default (fSecondaryWeightByProcess <<
172 // the weight of secondary tracks will b <<
173 // If fSecondaryWeightByProcess flag is <<
174 // tracks will not be changed by the Par <<
175 // determine the secondary weight) <<
176 // NOTE: <<
177 // Make sure that only one process in Al <<
178 // parent weight; if several processes i <<
179 // the parent weight and add secondaties <<
180 // is set to false, secondary weights ma <<
181 <<
182 void SetParentWeightByProcess(G4bool); <<
183 G4bool IsParentWeightSetByProcess() const; <<
184 // Obsolete <<
185 250
186 // --- Dump and debug methods --- << 251 G4int theSizeOftheListOfSecondaries;
>> 252 // TheSizeOftheListOfSecondaries;
187 253
188 virtual void DumpInfo() const; << 254 G4TrackStatus theStatusChange;
189 // Print out information << 255 // The changed (final) track status of a given particle.
>> 256
>> 257 G4SteppingControl theSteppingControlFlag;
>> 258 // a flag to control stepping manager behavior
>> 259
>> 260 G4double theLocalEnergyDeposit;
>> 261 // It represents the part of the energy lost for discrete
>> 262 // or semi-continuous processes which is due to secondaries
>> 263 // not generated because they would have been below their cut
>> 264 // threshold.
>> 265 // The sum of the locally deposited energy + the delta-energy
>> 266 // coming from the continuous processes gives the
>> 267 // total energy loss localized in the current Step.
>> 268
>> 269 G4double theNonIonizingEnergyDeposit;
>> 270 // non-ionizing energu deposit is defined as
>> 271 // a part of local energy deposit, which does not cause
>> 272 // ionization of atoms
>> 273
>> 274 G4double theTrueStepLength;
>> 275 // The value of "True" Step Length
>> 276
>> 277
>> 278 G4bool theFirstStepInVolume;
>> 279 G4bool theLastStepInVolume;
>> 280 // flag for initial/last step
>> 281
>> 282 G4double theParentWeight;
>> 283 // Weight ofparent track
>> 284 G4bool isParentWeightProposed;
>> 285 // flags for Weight ofparent track
>> 286 G4bool fSetSecondaryWeightByProcess;
>> 287 // flag for setting weight of secondaries
>> 288
>> 289 G4double theParentGlobalTime;
>> 290 // global time of the parent.
>> 291 // This is used only for checking
190 292
191 inline void SetVerboseLevel(G4int vLevel); << 293 G4int verboseLevel;
192 inline G4int GetVerboseLevel() const; << 294 // The Verbose level
193 295
>> 296 public: // with description
>> 297 // CheckIt method is provided for debug
194 virtual G4bool CheckIt(const G4Track&); 298 virtual G4bool CheckIt(const G4Track&);
195 // CheckIt method for general control in << 299
196 << 300 // CheckIt method is activated
197 inline void ClearDebugFlag(); << 301 // if debug flag is set and 'G4VERBOSE' is defined
198 inline void SetDebugFlag(); << 302 void ClearDebugFlag();
199 inline G4bool GetDebugFlag() const; << 303 void SetDebugFlag();
200 // CheckIt method is activated if debug << 304 G4bool GetDebugFlag() const;
201 // and 'G4VERBOSE' is defined <<
202 305
203 protected: 306 protected:
204 << 307 // CheckSecondary method is provided for debug
205 G4Step* UpdateStepInfo(G4Step* Step); <<
206 // Update the G4Step specific attributes <<
207 // (i.e. SteppingControl, LocalEnergyDep <<
208 <<
209 inline void InitializeLocalEnergyDeposit() <<
210 inline void InitializeSteppingControl(); <<
211 inline void InitializeParentWeight(const G <<
212 inline void InitializeStatusChange(const G <<
213 inline void InitializeSecondaries(); <<
214 inline void InitializeFromStep(const G4Ste <<
215 <<
216 inline G4double ComputeBeta(G4double kinEn <<
217 <<
218 G4bool CheckSecondary(G4Track&); 308 G4bool CheckSecondary(G4Track&);
219 // CheckSecondary method is provided to << 309
220 // in debug regime <<
221 <<
222 G4double GetAccuracyForWarning() const; 310 G4double GetAccuracyForWarning() const;
223 G4double GetAccuracyForException() const; 311 G4double GetAccuracyForException() const;
224 312
225 protected: << 313 protected:
226 << 314 G4bool debugFlag;
>> 315
>> 316 // accuracy levels
227 static const G4double accuracyForWarning; 317 static const G4double accuracyForWarning;
228 static const G4double accuracyForException << 318 static const G4double accuracyForException;
229 static const G4int maxError; <<
230 // accuracy levels <<
231 <<
232 const G4Track* theCurrentTrack = nullptr; <<
233 <<
234 G4TrackStatus theStatusChange = fAlive; <<
235 // The changed (final) track status of a <<
236 <<
237 G4SteppingControl theSteppingControlFlag = <<
238 // A flag to control stepping manager be <<
239 319
240 G4double theLocalEnergyDeposit = 0.0; <<
241 // It represents the part of the energy <<
242 // or semi-continuous processes which is <<
243 // not generated because they would have <<
244 // threshold. <<
245 // The sum of the locally deposited ener <<
246 // coming from the continuous processes <<
247 // total energy loss localized in the cu <<
248 320
249 G4double theNonIonizingEnergyDeposit = 0.0 <<
250 // Non-ionizing energu deposit is define <<
251 // energy deposit, which does not cause <<
252 <<
253 G4double theTrueStepLength = 0.0; <<
254 // The value of "True" Step Length <<
255 <<
256 G4double theParentWeight = 1.0; <<
257 // Weight ofparent track <<
258 <<
259 G4double theParentGlobalTime = 0.0; <<
260 // Global time of the parent. <<
261 // This is used only for checking <<
262 <<
263 G4int theNumberOfSecondaries = 0; <<
264 // The total number of secondaries produ <<
265 <<
266 G4int theSizeOftheListOfSecondaries = 0; <<
267 // TheSizeOftheListOfSecondaries; <<
268 <<
269 G4int verboseLevel = 1; <<
270 // The Verbose level <<
271 <<
272 G4int nError = 0; <<
273 <<
274 G4bool theFirstStepInVolume = false; <<
275 G4bool theLastStepInVolume = false; <<
276 // Flag for initial/last step <<
277 <<
278 G4bool isParentWeightProposed = false; <<
279 // Flag for Weight of parent track <<
280 G4bool fSetSecondaryWeightByProcess = fals <<
281 // Flag for setting weight of secondarie <<
282 <<
283 G4bool debugFlag = false; <<
284 <<
285 std::vector<G4Track*> theListOfSecondaries <<
286 // The vector of secondaries <<
287 }; 321 };
288 322
>> 323 #include "G4Step.hh"
>> 324 #include "G4Track.hh"
289 #include "G4VParticleChange.icc" 325 #include "G4VParticleChange.icc"
290 326
291 #endif 327 #endif
292 328