Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/track/include/G4VParticleChange.hh

Version: [ ReleaseNotes ] [ 1.0 ] [ 1.1 ] [ 2.0 ] [ 3.0 ] [ 3.1 ] [ 3.2 ] [ 4.0 ] [ 4.0.p1 ] [ 4.0.p2 ] [ 4.1 ] [ 4.1.p1 ] [ 5.0 ] [ 5.0.p1 ] [ 5.1 ] [ 5.1.p1 ] [ 5.2 ] [ 5.2.p1 ] [ 5.2.p2 ] [ 6.0 ] [ 6.0.p1 ] [ 6.1 ] [ 6.2 ] [ 6.2.p1 ] [ 6.2.p2 ] [ 7.0 ] [ 7.0.p1 ] [ 7.1 ] [ 7.1.p1 ] [ 8.0 ] [ 8.0.p1 ] [ 8.1 ] [ 8.1.p1 ] [ 8.1.p2 ] [ 8.2 ] [ 8.2.p1 ] [ 8.3 ] [ 8.3.p1 ] [ 8.3.p2 ] [ 9.0 ] [ 9.0.p1 ] [ 9.0.p2 ] [ 9.1 ] [ 9.1.p1 ] [ 9.1.p2 ] [ 9.1.p3 ] [ 9.2 ] [ 9.2.p1 ] [ 9.2.p2 ] [ 9.2.p3 ] [ 9.2.p4 ] [ 9.3 ] [ 9.3.p1 ] [ 9.3.p2 ] [ 9.4 ] [ 9.4.p1 ] [ 9.4.p2 ] [ 9.4.p3 ] [ 9.4.p4 ] [ 9.5 ] [ 9.5.p1 ] [ 9.5.p2 ] [ 9.6 ] [ 9.6.p1 ] [ 9.6.p2 ] [ 9.6.p3 ] [ 9.6.p4 ] [ 10.0 ] [ 10.0.p1 ] [ 10.0.p2 ] [ 10.0.p3 ] [ 10.0.p4 ] [ 10.1 ] [ 10.1.p1 ] [ 10.1.p2 ] [ 10.1.p3 ] [ 10.2 ] [ 10.2.p1 ] [ 10.2.p2 ] [ 10.2.p3 ] [ 10.3 ] [ 10.3.p1 ] [ 10.3.p2 ] [ 10.3.p3 ] [ 10.4 ] [ 10.4.p1 ] [ 10.4.p2 ] [ 10.4.p3 ] [ 10.5 ] [ 10.5.p1 ] [ 10.6 ] [ 10.6.p1 ] [ 10.6.p2 ] [ 10.6.p3 ] [ 10.7 ] [ 10.7.p1 ] [ 10.7.p2 ] [ 10.7.p3 ] [ 10.7.p4 ] [ 11.0 ] [ 11.0.p1 ] [ 11.0.p2 ] [ 11.0.p3, ] [ 11.0.p4 ] [ 11.1 ] [ 11.1.1 ] [ 11.1.2 ] [ 11.1.3 ] [ 11.2 ] [ 11.2.1 ] [ 11.2.2 ] [ 11.3.0 ]

Diff markup

Differences between /track/include/G4VParticleChange.hh (Version 11.3.0) and /track/include/G4VParticleChange.hh (Version 8.3.p2)


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