| 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 // G4VParticleChange << 8 // $Id: G4VParticleChange.hh,v 1.4 1999/11/07 16:32:05 kurasige Exp $
>> 9 // GEANT4 tag $Name: geant4-02-00 $
27 // 10 //
28 // Class description: << 11 //
>> 12 // ------------------------------------------------------------
>> 13 // GEANT 4 class header file
29 // 14 //
30 // Abstract class for "Particle Change". << 15 // For information related to this code contact:
>> 16 // CERN, CN Division, ASD group
31 // 17 //
32 // The ParticleChange class contains the resul << 18 // ------------------------------------------------------------
33 // of a physics process. This includes final s << 19 // Implemented for the new scheme 23 Mar. 1998 H.Kurahige
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 // 20 //
41 // This abstract class has following four virt << 21 // Class Description
>> 22 // This class is the abstract class for ParticleChange.
>> 23 //-
>> 24 // The ParticleChange class ontains the results after invocation
>> 25 // of a physics process. This includes final states of parent
>> 26 // particle (momentum, energy, etc) and secondary particles generated
>> 27 // by the interaction.
>> 28 // The tracking assumes that all the values of energy and
>> 29 // momentum are in global reference system, therefore all the
>> 30 // needed Lorentz transformations must have been already Done
>> 31 // when filling the data-members of this class.
>> 32 //-
>> 33 //-
>> 34 // This abstract class has following four virtual methods
42 // virtual G4Step* UpdateStepForAtRest(G4S 35 // virtual G4Step* UpdateStepForAtRest(G4Step* Step);
43 // virtual G4Step* UpdateStepForAlongStep( 36 // virtual G4Step* UpdateStepForAlongStep(G4Step* Step);
44 // virtual G4Step* UpdateStepForPostStep(G 37 // virtual G4Step* UpdateStepForPostStep(G4Step* Step);
45 // virtual void Initialize(const G4Track&) 38 // virtual void Initialize(const G4Track&);
46 // The UpdateStep methods return the pointer t << 39 // The UpdateStep methods return the pointer to the G4Step
47 // the given Step information by using final s << 40 // after updating the given Step information by using final state
48 // given by a physics process. << 41 // information of the track given by a physics process.
49 // User must add methods to keep the final sta << 42 // User must add methods to keep the final state information
50 // class as well as implement UpdateStep() met << 43 // in his derived class as well as implement UpdateStep methods
51 // << 44 // which he want to use.
52 // The Initialize() methods are provided to re << 45 //-
53 // information and should be called by each pr << 46 // The Initialize methods is provided to refresh the final
54 << 47 // state information and should be called by each process
55 // Author: Hisaya Kurashige, 23 March 1998 << 48 // at the beginning of DoIt.
56 // ------------------------------------------- << 49 //
57 #ifndef G4VParticleChange_hh << 50 // ------------------------------------------------------------
58 #define G4VParticleChange_hh 1 << 51 // Implement Event Biasing Scheme 9 Nov.,98 H.Kurashige
>> 52 // add CheckIt 13 Apr.,99 H.Kurashige
>> 53 // add accuracy leveles 5 May, 99 H.Kurashige
>> 54 #ifndef G4VParticleChange_h
>> 55 #define G4VParticleChange_h 1
59 56
60 #include <vector> <<
61 #include "globals.hh" 57 #include "globals.hh"
62 #include "G4ios.hh" 58 #include "G4ios.hh"
>> 59
>> 60 class G4Track;
>> 61 class G4Step;
>> 62 class G4VEvtBiasMechanism;
>> 63
>> 64 #include "G4TrackFastVector.hh"
63 #include "G4TrackStatus.hh" 65 #include "G4TrackStatus.hh"
64 #include "G4SteppingControl.hh" 66 #include "G4SteppingControl.hh"
65 #include "G4Step.hh" <<
66 #include "G4Track.hh" <<
67 67
68 class G4VParticleChange << 68
>> 69 class G4VParticleChange
69 { 70 {
70 public: 71 public:
71 << 72 // default constructor
72 G4VParticleChange(); 73 G4VParticleChange();
>> 74 G4VParticleChange(G4bool useEvtBiasing);
73 75
74 virtual ~G4VParticleChange() = default; << 76 // destructor
75 << 77 virtual ~G4VParticleChange();
76 G4VParticleChange(const G4VParticleChange& <<
77 G4VParticleChange& operator=(const G4VPart <<
78 78
79 // --- the following methods are for updatin << 79 // equal/unequal operator
>> 80 G4bool operator==(const G4VParticleChange &right) const;
>> 81 G4bool operator!=(const G4VParticleChange &right) const;
>> 82 // "equal" means that teo objects have the same pointer.
80 83
>> 84 protected:
>> 85 // hide copy constructor and assignment operaor as protected
>> 86 G4VParticleChange(const G4VParticleChange &right);
>> 87 G4VParticleChange & operator=(const G4VParticleChange &right);
>> 88
>> 89 public: // with description
>> 90 // --- the following methods are for updating G4Step -----
81 virtual G4Step* UpdateStepForAtRest(G4Step 91 virtual G4Step* UpdateStepForAtRest(G4Step* Step);
82 virtual G4Step* UpdateStepForAlongStep(G4S 92 virtual G4Step* UpdateStepForAlongStep(G4Step* Step);
83 virtual G4Step* UpdateStepForPostStep(G4St 93 virtual G4Step* UpdateStepForPostStep(G4Step* Step);
84 // Return the pointer to the G4Step afte << 94 // Return the pointer to the G4Step after updating the Step information
85 // by using final state information of t << 95 // by using final state information of the track given by a physics
86 // process << 96 // process
87 << 97
88 virtual void Initialize(const G4Track&); << 98 protected: // with description
89 // This methods will be called by each p << 99 G4Step* UpdateStepInfo(G4Step* Step);
90 // of DoIt() if necessary << 100 // Update the G4Step specific attributes
91 << 101 // (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 <<
125 // --- the following methods are for managem <<
126 <<
127 inline G4bool GetFirstStepInVolume() const <<
128 inline G4bool GetLastStepInVolume() const; <<
129 inline void ProposeFirstStepInVolume(G4boo <<
130 inline void ProposeLastStepInVolume(G4bool <<
131 <<
132 // --- the following methods are for managem <<
133 <<
134 inline void Clear(); <<
135 // Clear the contents of this objects <<
136 // This method should be called after th <<
137 // manager removes all secondaries in th <<
138 102
139 inline void SetNumberOfSecondaries(G4int t <<
140 // SetNumberOfSecondaries must be called <<
141 // in order to secure memory space for t <<
142 // This method resets theNumberOfSeconda <<
143 // (that will be incremented at every Ad <<
144 103
145 inline G4int GetNumberOfSecondaries() cons << 104 public: // with description
146 // Returns the number of secondaries cur << 105 virtual void Initialize(const G4Track&);
>> 106 // This methods will be called by each process at the beginning of DoIt
>> 107 // if necessary.
147 108
148 inline G4Track* GetSecondary(G4int anIndex << 109 protected:
149 // Returns the pointer to the generated << 110 void InitializeTrueStepLength(const G4Track&);
150 // which is specified by an Index, no ch << 111 void InitializeLocalEnergyDeposit(const G4Track&);
>> 112 void InitializeSteppingControl(const G4Track&);
>> 113 void InitializeParentWeight(const G4Track&);
>> 114
>> 115 void InitializeStatusChange(const G4Track&);
>> 116 void InitializeSecondaries(const G4Track&);
>> 117 // ------------------------------------------------------
>> 118
>> 119 public: // with description
>> 120 //---- the following methods are for TruePathLength ----
>> 121 G4double GetTrueStepLength() const;
>> 122 void SetTrueStepLength(G4double truePathLength);
>> 123 // Get/Set theTrueStepLength
>> 124
>> 125 //---- the following methods are for LocalEnergyDeposit ----
>> 126 G4double GetLocalEnergyDeposit() const;
>> 127 void SetLocalEnergyDeposit(G4double anEnergyPart);
>> 128 // Get/Set the locally deposited energy
>> 129
>> 130 //---- the following methods are for TrackStatus -----
>> 131 G4TrackStatus GetStatusChange() const;
>> 132 void SetStatusChange(G4TrackStatus status);
>> 133 // Get/Set the final TrackStatus of the current particle.
>> 134 // ------------------------------------------------------
>> 135
>> 136 //---- the following methods are for managements of SteppingControl --
>> 137 G4SteppingControl GetSteppingControl() const;
>> 138 void SetSteppingControl(G4SteppingControl StepControlFlag);
>> 139 // Set/Get a flag to control stepping manager behavier
>> 140 // ------------------------------------------------------
>> 141
>> 142 //---- the following methods are for managements of secondaries --
>> 143 void Clear();
>> 144 // Clear the contents of this objects
>> 145 // This method should be called after the Tracking(Stepping)
>> 146 // manager removes all secondaries in theListOfSecondaries
>> 147
>> 148 void SetNumberOfSecondaries(G4int totSecondaries);
>> 149 // SetNumberOfSecondaries must be called just before AddSecondary()
>> 150 // in order to secure memory space for theListOfSecondaries
>> 151 // This method resets theNumberOfSecondaries to 0
>> 152 // (that will be incremented at every AddSecondary() call).
>> 153
>> 154 G4int GetNumberOfSecondaries() const;
>> 155 // Returns the number of secondaries current stored in
>> 156 // G4TrackFastVector.
>> 157
>> 158 G4Track* GetSecondary(G4int anIndex) const;
>> 159 // Returns the pointer to the generated secondary particle
>> 160 // which is specified by an Index.
151 161
152 void AddSecondary(G4Track* aSecondary); 162 void AddSecondary(G4Track* aSecondary);
153 // Adds a secondary particle to theListO << 163 // Add a secondary particle to theListOfSecondaries.
154 << 164 // ------------------------------------------------------
155 // --- the following methods are for managem <<
156 165
157 inline G4double GetWeight() const; << 166 G4double GetParentWeight() const ;
158 inline G4double GetParentWeight() const; <<
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 <<
186 // --- Dump and debug methods --- <<
187 167
188 virtual void DumpInfo() const; 168 virtual void DumpInfo() const;
189 // Print out information << 169 // Print out information
190 <<
191 inline void SetVerboseLevel(G4int vLevel); <<
192 inline G4int GetVerboseLevel() const; <<
193 <<
194 virtual G4bool CheckIt(const G4Track&); <<
195 // CheckIt method for general control in <<
196 170
197 inline void ClearDebugFlag(); << 171 void SetVerboseLevel(G4int vLevel);
198 inline void SetDebugFlag(); << 172 G4int GetVerboseLevel() const;
199 inline G4bool GetDebugFlag() const; <<
200 // CheckIt method is activated if debug <<
201 // and 'G4VERBOSE' is defined <<
202 173
203 protected: 174 protected:
204 175
205 G4Step* UpdateStepInfo(G4Step* Step); << 176 G4TrackFastVector* theListOfSecondaries;
206 // Update the G4Step specific attributes << 177 // The vector of secondaries.
207 // (i.e. SteppingControl, LocalEnergyDep <<
208 178
209 inline void InitializeLocalEnergyDeposit() << 179 G4int theNumberOfSecondaries;
210 inline void InitializeSteppingControl(); << 180 // The total number of secondaries produced by each process.
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&); <<
219 // CheckSecondary method is provided to <<
220 // in debug regime <<
221 181
222 G4double GetAccuracyForWarning() const; << 182 G4int theSizeOftheListOfSecondaries;
223 G4double GetAccuracyForException() const; << 183 // TheSizeOftheListOfSecondaries;
224 184
225 protected: << 185 G4TrackStatus theStatusChange;
>> 186 // The changed (final) track status of a given particle.
>> 187
>> 188 G4SteppingControl theSteppingControlFlag;
>> 189 // a flag to control stepping manager behavior
>> 190
>> 191 G4double theLocalEnergyDeposit;
>> 192 // It represents the part of the energy lost for discrete
>> 193 // or semi-continuous processes which is due to secondaries
>> 194 // not generated because they would have been below their cut
>> 195 // threshold.
>> 196 // The sum of the locally deposited energy + the delta-energy
>> 197 // coming from the continuous processes gives the
>> 198 // total energy loss localized in the current Step.
>> 199
>> 200 G4double theTrueStepLength;
>> 201 // The value of "True" Step Length
>> 202
>> 203 G4int verboseLevel;
>> 204 // The Verbose level
226 205
>> 206 public: // with description
>> 207 // CheckIt method is provided for debug
>> 208 virtual G4bool CheckIt(const G4Track&);
>> 209
>> 210 // CheckIt method is activated
>> 211 // if debug flag is set and 'G4VERBOSE' is defined
>> 212 void ClearDebugFlag();
>> 213 void SetDebugFlag();
>> 214 G4bool GetDebugFlag() const;
>> 215
>> 216 protected:
>> 217 G4bool debugFlag;
>> 218
>> 219 // accuracy levels
227 static const G4double accuracyForWarning; 220 static const G4double accuracyForWarning;
228 static const G4double accuracyForException << 221 static const G4double accuracyForException;
229 static const G4int maxError; << 222
230 // accuracy levels << 223 public: // with description
>> 224 //---- following methods and members are used for Event Biasing
>> 225 virtual void RegisterEBMechanism(G4VEvtBiasMechanism* );
>> 226 virtual void SwOnEB();
>> 227 virtual void SwOffEB();
>> 228 virtual G4bool IsEBActive() const;
>> 229 virtual G4VEvtBiasMechanism* GetEBMechanism();
>> 230
>> 231 protected:
>> 232 G4VEvtBiasMechanism* theEBMechanism;
>> 233 G4bool fUseEB;
>> 234 G4double theParentWeight;
>> 235
>> 236 };
231 237
232 const G4Track* theCurrentTrack = nullptr; << 238 #include "G4Step.hh"
>> 239 #include "G4Track.hh"
>> 240 #include "G4VEvtBiasMechanism.hh"
>> 241 #include "G4VParticleChange.icc"
233 242
234 G4TrackStatus theStatusChange = fAlive; << 243 #endif
235 // The changed (final) track status of a <<
236 244
237 G4SteppingControl theSteppingControlFlag = <<
238 // A flag to control stepping manager be <<
239 245
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 246
249 G4double theNonIonizingEnergyDeposit = 0.0 <<
250 // Non-ionizing energu deposit is define <<
251 // energy deposit, which does not cause <<
252 247
253 G4double theTrueStepLength = 0.0; <<
254 // The value of "True" Step Length <<
255 248
256 G4double theParentWeight = 1.0; <<
257 // Weight ofparent track <<
258 249
259 G4double theParentGlobalTime = 0.0; <<
260 // Global time of the parent. <<
261 // This is used only for checking <<
262 250
263 G4int theNumberOfSecondaries = 0; <<
264 // The total number of secondaries produ <<
265 251
266 G4int theSizeOftheListOfSecondaries = 0; <<
267 // TheSizeOftheListOfSecondaries; <<
268 252
269 G4int verboseLevel = 1; <<
270 // The Verbose level <<
271 253
272 G4int nError = 0; <<
273 254
274 G4bool theFirstStepInVolume = false; <<
275 G4bool theLastStepInVolume = false; <<
276 // Flag for initial/last step <<
277 255
278 G4bool isParentWeightProposed = false; <<
279 // Flag for Weight of parent track <<
280 G4bool fSetSecondaryWeightByProcess = fals <<
281 // Flag for setting weight of secondarie <<
282 256
283 G4bool debugFlag = false; <<
284 257
285 std::vector<G4Track*> theListOfSecondaries <<
286 // The vector of secondaries <<
287 }; <<
288 258
289 #include "G4VParticleChange.icc" <<
290 259
291 #endif <<
292 260