Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/processes/parameterisation/include/G4FastStep.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 /processes/parameterisation/include/G4FastStep.hh (Version 11.3.0) and /processes/parameterisation/include/G4FastStep.hh (Version 11.1)


  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 //                                                 26 //
 27 //                                                 27 //
 28 //                                             <<  28 // 
 29 //--------------------------------------------     29 //---------------------------------------------------------------
 30 //                                                 30 //
 31 //  G4FastStep.hh                                  31 //  G4FastStep.hh
 32 //                                                 32 //
 33 //  Description:                                   33 //  Description:
 34 //    The G4FastStep class insures a friendly      34 //    The G4FastStep class insures a friendly interface
 35 //    to manage the primary/secondaries final  <<  35 //    to manage the primary/secondaries final state for 
 36 //    Fast Simulation Models. This includes fi     36 //    Fast Simulation Models. This includes final states of parent
 37 //    particle (normalized direction of the mo <<  37 //    particle (normalized direction of the momentum, energy, etc) and 
 38 //    secondary particles generated by the par     38 //    secondary particles generated by the parameterisation.
 39 //                                                 39 //
 40 //    The G4FastStep class acts also as the G4     40 //    The G4FastStep class acts also as the G4ParticleChange
 41 //    for the Fast Simulation Process. So it i <<  41 //    for the Fast Simulation Process. So it inherites from 
 42 //    the G4VParticleChange class and redefine <<  42 //    the G4VParticleChange class and redefines the four virtual 
 43 //    methods :                                    43 //    methods :
 44 //                                                 44 //
 45 //     virtual G4Step* UpdateStepForAtRest(G4S     45 //     virtual G4Step* UpdateStepForAtRest(G4Step* Step);
 46 //     virtual G4Step* UpdateStepForAlongStep(     46 //     virtual G4Step* UpdateStepForAlongStep(G4Step* Step);
 47 //     virtual G4Step* UpdateStepForPostStep(G     47 //     virtual G4Step* UpdateStepForPostStep(G4Step* Step);
 48 //     virtual void Initialize(const G4Track&)     48 //     virtual void Initialize(const G4Track&);
 49 //                                                 49 //
 50 //  History:                                       50 //  History:
 51 //    Oct 97: Verderi && MoraDeFreitas - First     51 //    Oct 97: Verderi && MoraDeFreitas - First Implementation.
 52 //    Dec 97: Verderi - ForceSteppingHitInvoca     52 //    Dec 97: Verderi - ForceSteppingHitInvocation(),
 53 //                      Set/GetTotalEnergyDepo     53 //                      Set/GetTotalEnergyDeposited() methods.
 54 //    Apr 98: MoraDeFreitas - G4FastStep becom     54 //    Apr 98: MoraDeFreitas - G4FastStep becomes the G4ParticleChange
 55 //                      for the Fast Simulatio     55 //                      for the Fast Simulation Process.
 56 //    Nov 04: Verderi - Add ProposeXXX methods     56 //    Nov 04: Verderi - Add ProposeXXX methods. SetXXX ones are kept
 57 //                      for backward compatibi <<  57 //                      for backward compatibility. 
 58 //                                                 58 //
 59 //--------------------------------------------     59 //---------------------------------------------------------------
 60                                                    60 
                                                   >>  61 
 61 #ifndef G4FastStep_h                               62 #ifndef G4FastStep_h
 62 #define G4FastStep_h                               63 #define G4FastStep_h
 63                                                    64 
 64 #include "G4ParticleMomentum.hh"               << 
 65 #include "G4ThreeVector.hh"                    << 
 66 #include "G4ios.hh"                            << 
 67 #include "globals.hh"                              65 #include "globals.hh"
                                                   >>  66 #include "G4ios.hh"
                                                   >>  67 #include "G4ThreeVector.hh"
                                                   >>  68 #include "G4ParticleMomentum.hh"
 68 class G4DynamicParticle;                           69 class G4DynamicParticle;
 69 #include "G4FastTrack.hh"                      << 
 70 #include "G4VParticleChange.hh"                    70 #include "G4VParticleChange.hh"
                                                   >>  71 #include "G4FastTrack.hh"
 71                                                    72 
 72 //-------------------------------------------      73 //-------------------------------------------
 73 //                                                 74 //
 74 //        G4FastStep class                         75 //        G4FastStep class
 75 //                                                 76 //
 76 //-------------------------------------------      77 //-------------------------------------------
 77                                                    78 
 78 // Class Description:                              79 // Class Description:
 79 //  The final state of the particles after par <<  80 //  The final state of the particles after parameterisation has to be returned through a G4FastStep 
 80 //  reference. This final state is described a <<  81 //  reference. This final state is described as "requests" the tracking will apply after your 
 81 //  parameterisation has been invoked.             82 //  parameterisation has been invoked.
 82 //                                                 83 //
 83 //  To facilitate the developers work, changes <<  84 //  To facilitate the developers work, changes of position/normalized direction of the 
 84 //  momentum/polarization can be specified in  <<  85 //  momentum/polarization can be specified in the local coordinate system of the envelope or in the 
 85 //  global one.                                    86 //  global one.
 86 //  The default is local system coordinates.       87 //  The default is local system coordinates.
 87 //                                                 88 //
 88                                                    89 
 89 class G4FastStep : public G4VParticleChange    <<  90 class G4FastStep: public G4VParticleChange
 90 {                                                  91 {
 91   public:  // Without description              <<  92 public: // with Description
 92     //------------------------                 <<  93   void KillPrimaryTrack();
 93     // Constructor/Destructor                  <<  94   // Set the kinetic energy of the primary to zero, and set the "fStopAndKill" signal
 94     //------------------------                 <<  95   // used by the stepping.
 95     G4FastStep() = default;                    <<  96 
 96     ~G4FastStep() override = default;          <<  97   // -- Methods used to change the position, normalized direction of 
 97                                                <<  98   // the momentum, time etc... of the primary.
 98     G4FastStep(const G4FastStep& right) = dele <<  99   // .. space and time:
 99     G4FastStep& operator=(const G4FastStep& ri << 100   void ProposePrimaryTrackFinalPosition (const G4ThreeVector &, 
100                                                << 101            G4bool localCoordinates = true);
101     // Set the kinetic energy of the primary t << 102   // Set the primary track final position.
102     // used by the stepping.                   << 103   void     SetPrimaryTrackFinalPosition (const G4ThreeVector &, 
103     void KillPrimaryTrack();                   << 104            G4bool localCoordinates = true);
104                                                << 105   // Set the primary track final position -- maintained for backward compatibility.
105     // -- Methods used to change the position, << 106   
106     // the momentum, time etc... of the primar << 107   
107     // .. space and time:                      << 108   void ProposePrimaryTrackFinalTime (G4double);
108                                                << 109   // Set the primary track final time.
109     // Set the primary track final position.   << 110   void    SetPrimaryTrackFinalTime (G4double);
110     void ProposePrimaryTrackFinalPosition(cons << 111   // Set the primary track final time -- maintained for backward compatibility.
111                                                << 112 
112     // Set the primary track final position -- << 113 
113     [[deprecated("use ProposePrimaryTrackFinal << 114   void ProposePrimaryTrackFinalProperTime (G4double);
114     void SetPrimaryTrackFinalPosition(const G4 << 115   // Set the primary final track Proper Time.
115                                                << 116   void     SetPrimaryTrackFinalProperTime (G4double);
116     // Set the primary track final time.       << 117   // Set the primary final track Proper Time -- maintained for backward compatibility.
117     void ProposePrimaryTrackFinalTime(G4double << 118 
118                                                << 119 
119     // Set the primary track final time -- mai << 120   // .. dynamics:
120     [[deprecated("use ProposePrimaryTrackFinal << 121   void ProposePrimaryTrackFinalMomentumDirection (const G4ThreeVector &, 
121     void SetPrimaryTrackFinalTime(G4double);   << 122               G4bool localCoordinates = true);
122                                                << 123   // Be careful: the Track Final Momentum means the normalized direction 
123     // Set the primary final track Proper Time << 124   // of the momentum!
124     void ProposePrimaryTrackFinalProperTime(G4 << 125   void     SetPrimaryTrackFinalMomentum          (const G4ThreeVector &, 
125                                                << 126               G4bool localCoordinates = true);
126     // Set the primary final track Proper Time << 127   // Set the primary track final momentum -- maintained for backward compatibility. Same as ProposePrimaryTrackMomentumDirection(...)
127     [[deprecated("use ProposePrimaryTrackPrope << 128 
128     void SetPrimaryTrackFinalProperTime(G4doub << 129 
129                                                << 130   void ProposePrimaryTrackFinalKineticEnergy (G4double);
130     // .. dynamics:                            << 131   // Set the primary track final kinetic energy.
131                                                << 132   void     SetPrimaryTrackFinalKineticEnergy (G4double);
132     // Be careful: the Track Final Momentum me << 133   // Set the primary track final kinetic energy-- maintained for backward compatibility.
133     // of the momentum!                        << 134 
134     void ProposePrimaryTrackFinalMomentumDirec << 135 
135                                                << 136   void ProposePrimaryTrackFinalKineticEnergyAndDirection(G4double, 
136                                                << 137                const G4ThreeVector &, 
137     // Set the primary track final momentum -- << 138                G4bool localCoordinates 
138     // ProposePrimaryTrackMomentumDirection(.. << 139                = true);
139     [[deprecated("use ProposePrimaryTrackMomen << 140   // Set the primary track final kinetic energy and direction.
140     void SetPrimaryTrackFinalMomentum(const G4 << 141   void     SetPrimaryTrackFinalKineticEnergyAndDirection(G4double, 
141                                                << 142                const G4ThreeVector &, 
142     // Set the primary track final kinetic ene << 143                G4bool localCoordinates 
143     void ProposePrimaryTrackFinalKineticEnergy << 144                = true);
144                                                << 145   // Set the primary track final kinetic energy and direction -- maintained for backward compatibility.
145     // Set the primary track final kinetic ene << 146 
146     [[deprecated("use ProposePrimaryTrackFinal << 147 
147     void SetPrimaryTrackFinalKineticEnergy(G4d << 148 
148                                                << 149   void ProposePrimaryTrackFinalPolarization(const G4ThreeVector &, 
149     // Set the primary track final kinetic ene << 150               G4bool localCoordinates = true);
150     void ProposePrimaryTrackFinalKineticEnergy << 151   // Set the primary track final polarization.
151                                                << 152   void     SetPrimaryTrackFinalPolarization(const G4ThreeVector &, 
152                                                << 153               G4bool localCoordinates = true);
153     // Set the primary track final kinetic ene << 154   // Set the primary track final polarization.
154     // compatibility.                          << 155 
155     [[deprecated("use ProposePrimaryTrackFinal << 156 
156     void SetPrimaryTrackFinalKineticEnergyAndD << 157   void ProposePrimaryTrackPathLength (G4double);
157                                                << 158   // Set the true path length of the primary track during the step.
158                                                << 159   void     SetPrimaryTrackPathLength (G4double);
159     // Set the primary track final polarizatio << 160   // Set the true path length of the primary track during the step -- maintained for backward compatibility.
160     void ProposePrimaryTrackFinalPolarization( << 161 
161                                                << 162   void ProposePrimaryTrackFinalEventBiasingWeight (G4double);
162     // Set the primary track final polarizatio << 163   // Set the weight applied for event biasing mechanism.
163     [[deprecated("use ProposePrimaryTrackFinal << 164   void     SetPrimaryTrackFinalEventBiasingWeight (G4double);
164     void SetPrimaryTrackFinalPolarization(cons << 165   // Set the weight applied for event biasing mechanism -- kept for backward compatibility.
165                                                << 166 
166     // Set the true path length of the primary << 167   // ------------------------------
167     void ProposePrimaryTrackPathLength(G4doubl << 168   // -- Management of secondaries:
168                                                << 169   // ------------------------------
169     // Set the true path length of the primary << 170 
170     // compatibility.                          << 171   // ----------------------------------------------------
171     [[deprecated("use ProposePrimaryTrackPathL << 172   // -- The creation of secondaries is Done in two steps:
172     void SetPrimaryTrackPathLength(G4double);  << 173   // --      1) Give the total number of secondaries
173                                                << 174   // --         that the FastStep returns
174     // Set the weight applied for event biasin << 175   // --         to the tracking using:
175     void ProposePrimaryTrackFinalEventBiasingW << 176   // --         SetNumberOfSecondaryTracks()
176                                                << 177   // --
177     // Set the weight applied for event biasin << 178   // --      2) Invoke the CreateSecondaryTrack() method
178     [[deprecated("use ProposePrimaryTrackFinal << 179   // --         to create one secondary at each time.
179     void SetPrimaryTrackFinalEventBiasingWeigh << 180   // ----------------------------------------------------
180                                                << 181 
181     // ------------------------------          << 182   // -- Total Number of secondaries to be created,
182     // -- Management of secondaries:           << 183   // -- (to be called first)
183     // ------------------------------          << 184   void SetNumberOfSecondaryTracks(G4int);
184                                                << 185   // Set the total number of secondaries that will be created.
185     // --------------------------------------- << 186 
186     // -- The creation of secondaries is Done  << 187   // -- Number of secondaries effectively stored:
187     // --      1) Give the total number of sec << 188   // -- (incremented at each CreateSecondaryTrack()
188     // --         that the FastStep returns    << 189   // -- call)
189     // --         to the tracking using:       << 190   G4int GetNumberOfSecondaryTracks();
190     // --         SetNumberOfSecondaryTracks() << 191   // Returns the number of secondaries effectively stored.
191     // --                                      << 192 
192     // --      2) Invoke the CreateSecondaryTr << 193   // -- Create a secondary: the arguments are:
193     // --         to create one secondary at e << 194   // --     * G4DynamicsParticle: see header file, many constructors exist
194     // --------------------------------------- << 195   // --                           (allow to set particle type + energy + 
195                                                << 196   // -- the normalized direction of momentum...)
196     // Set the total number of secondaries tha << 197   // --     * G4ThreeVector     : Polarization (not in G4ParticleChange constructor)
197     // -- Total Number of secondaries to be cr << 198   // --     * G4ThreeVector     : Position
198     // -- (to be called first)                 << 199   // --     * G4double          : Time
199     void SetNumberOfSecondaryTracks(G4int);    << 200   // --     * G4bool            : says if Position/Momentum are given in the
200                                                << 201   // --                           local coordinate system (true by default)
201     // Returns the number of secondaries effec << 202   // -- Returned value: pointer to the track created.
202     // -- Number of secondaries effectively st << 203   G4Track* CreateSecondaryTrack(const G4DynamicParticle&,
203     // -- (incremented at each CreateSecondary << 204         G4ThreeVector,
204     // -- call)                                << 205         G4ThreeVector,
205     G4int GetNumberOfSecondaryTracks();        << 206         G4double,
206                                                << 207         G4bool localCoordinates=true);
207     // -- Create a secondary: the arguments ar << 208   // Create a secondary. The arguments are:
208     // --     * G4DynamicsParticle: see header << 209   // 
209     // --                           (allow to  << 210   //   G4DynamicsParticle: see the G4DynamicsParticle reference, many constructors exist
210     // -- the normalized direction of momentum << 211   //                       (allow to set particle type + energy + the normalized direction of 
211     // --     * G4ThreeVector     : Polarizati << 212   //                       momentum...);
212     // --     * G4ThreeVector     : Position   << 213   //   G4ThreeVector     : Polarization;
213     // --     * G4double          : Time       << 214   //   G4ThreeVector     : Position;
214     // --     * G4bool            : says if Po << 215   //   G4double          : Time;
215     // --                           local coor << 216   //   G4bool            : says if Position/Momentum are given in the local envelope coordinate 
216     // -- Returned value: pointer to the track << 217   //                       system (true by default).
217     G4Track* CreateSecondaryTrack(const G4Dyna << 218   //
218                                   G4bool local << 219   // Returned value: pointer to the track created.
219                                                << 220   //
220     //-- Create a secondary: the difference wi << 221   
221     //-- is that the Polarization is not given << 222   //-- Create a secondary: the difference with he above declaration
222     //-- in the G4DynamicParticle.             << 223   //-- is that the Polarization is not given and is assumed already set
223     //-- Returned value: pointer to the track  << 224   //-- in the G4DynamicParticle.
224     G4Track* CreateSecondaryTrack(const G4Dyna << 225   //-- Returned value: pointer to the track created
225                                   G4bool local << 226   G4Track* CreateSecondaryTrack(const G4DynamicParticle&,
226                                                << 227         G4ThreeVector,
227     // Returns a pointer on the i-th secondary << 228         G4double,
228     G4Track* GetSecondaryTrack(G4int);         << 229         G4bool localCoordinates=true);
229                                                << 230   //  Create a secondary. The difference with he above declaration is that the Polarization is not 
230     //---------------------------------------- << 231   //  given and is assumed already set in the G4DynamicParticle.
231     //                                         << 232   //
232     //   Total energy deposit in the "fast Ste << 233   //  Returned value: pointer to the track created
233     //   (a default should be provided in futu << 234 
234     //    which can be:                        << 235   
235     //      delta energy of primary -          << 236 
236     //      energy of the secondaries)         << 237   G4Track* GetSecondaryTrack(G4int);
237     //   This allow the user to Store a consis << 238   // Returns a pointer on the i-th secondary track created.
238     //   information in the G4Trajectory.      << 239 
239     //                                         << 240   //------------------------------------------------
240     //---------------------------------------- << 241   //
241     // Set the total energy deposited.         << 242   //   Total energy deposit in the "fast Step"
242     void ProposeTotalEnergyDeposited(G4double  << 243   //   (a default should be provided in future,
243                                                << 244   //    which can be:
244     // Set the total energy deposited -- kept  << 245   //      delta energy of primary -
245     // It should be the delta energy of primar << 246   //      energy of the secondaries)
246     [[deprecated("use ProposeTotalEnergyDeposi << 247   //   This allow the user to Store a consistent
247     void SetTotalEnergyDeposited(G4double anEn << 248   //   information in the G4Trajectory.
248                                                << 249   //
249     // Returns the total energy deposited.     << 250   //------------------------------------------------
250     G4double GetTotalEnergyDeposited() const;  << 251    void ProposeTotalEnergyDeposited(G4double anEnergyPart);
251                                                << 252   // Set the total energy deposited.
252     // Control of the stepping manager Hit inv << 253   void      SetTotalEnergyDeposited(G4double anEnergyPart);
253     //                                         << 254   // Set the total energy deposited -- kept for backward compatibility.
254     // In a usual parameterisation, the contro << 255   // It should be the delta energy of primary less the energy of the secondaries.
255     // responsability in his G4VFastSimulation << 256 
256     //                                         << 257   G4double GetTotalEnergyDeposited() const;
257     // However, in the particular case the G4F << 258   // Returns the total energy deposited.
258     // replacement only (ie replaces all the * << 259 
259     // G4Step), the user can delegate to the G << 260   void ForceSteppingHitInvocation();
260     // the Hit()method of the current sensitiv << 261   // Control of the stepping manager Hit invocation.
261     //                                         << 262   //
262     // By default, the G4SteppingManager is as << 263   // In a usual parameterisation, the control of the hits production is under the user
263     // parameterisation is invoked.            << 264   // responsability in his G4VFastSimulationModel (he generally produces several hits at once.)
264     void ForceSteppingHitInvocation();         << 265   //
265                                                << 266   // However, in the particular case the G4FastSimulation user's model acts as the physics
266     // ======================================= << 267   // replacement only (ie replaces all the ***DoIt() and leads to the construction of a meaningful
267     // Stepping interface.                     << 268   // G4Step), the user can delegate to the G4SteppingManager the responsability to invoke
268     // ======================================= << 269   // the Hit()method of the current sensitive if any.
269     // --- the following methods are for updat << 270   //
270     // Return the pointer to the G4Step after  << 271   // By default, the G4SteppingManager is asked to NOT invoke this Hit() method when parameterisation
271     // by using final state information of the << 272   // is invoked.
272     //                                         << 273   //   
273     // The Fast Simulation Mechanism doesn't c << 274 
274     // state on the AlongDoIt loop, so the def << 275 
275     // virtual G4Step* UpdateStepForAlongStep( << 276 public: // Without description
276                                                << 277   //=======================================================
277     G4Step* UpdateStepForAtRest(G4Step* Step)  << 278   // Implementation section and kernel interfaces.
278     G4Step* UpdateStepForPostStep(G4Step* Step << 279   //=======================================================
279                                                << 280   //------------------------
280     // A Model gives the final state of the pa << 281   // Constructor/Destructor
281     // based on information of G4FastTrack. So << 282   //------------------------
282     // Initialize method is an interface to th << 283   G4FastStep();
283     // G4FastSimulationManager to Initialize t << 284   virtual ~G4FastStep();
284     // G4FastStep.                             << 285   
285                                                << 286   G4FastStep (const G4FastStep &right) = delete;
286     void Initialize(const G4FastTrack&);       << 287   G4FastStep & operator= (const G4FastStep &right) = delete;
287                                                << 288 
288     // for Debug                               << 289 public:
289     void DumpInfo() const override;            << 290   // ===============================================
290     G4bool CheckIt(const G4Track&) override;   << 291   // Stepping interface.
291                                                << 292   // ===============================================
292   private:                                     << 293   // --- the following methods are for updating G4Step -----   
293     //======================================== << 294   // Return the pointer to the G4Step after updating the Step information
294     // Private Internal methods (implementatio << 295   // by using final state information of the track given by a Model.
295     //======================================== << 296   //
296                                                << 297   // The Fast Simulation Mechanism doesn't change the track's final 
297     // G4FastStep should never be Initialized  << 298   // state on the AlongDoIt loop, so the default one all we need.
298     // but we must define it to avoid compiler << 299   //virtual G4Step* UpdateStepForAlongStep(G4Step* Step);
299     void Initialize(const G4Track&) override;  << 300 
300                                                << 301   G4Step* UpdateStepForAtRest(G4Step* Step);
301     //  -- Utility functions --                << 302   G4Step* UpdateStepForPostStep(G4Step* Step);
302     //--- methods to keep information of the f << 303 
303     //  IMPORTANT NOTE: Although the name of t << 304   // A Model gives the final state of the particle 
304     //   "Change", what it stores (and returns << 305   // based on information of G4FastTrack. So the
305     //   values of the Position, the normalize << 306   // Initialize method is an interface to the 
306     //   etc.                                  << 307   // G4FastSimulationManager to Initialize the 
307                                                << 308   // G4FastStep.
308     // Set theMomentumChange vector: it is the << 309 
309     // direction.                              << 310   void Initialize(const G4FastTrack&);
310     void SetMomentumChange(G4double Px, G4doub << 311 
311     void SetMomentumChange(const G4ThreeVector << 312   // for Debug 
312                                                << 313   void DumpInfo() const;
313     //======================================== << 314   G4bool CheckIt(const G4Track&);
314     // Data members.                           << 315 
315     //======================================== << 316 private:
316     //  theMomentumChange is the vector contai << 317   //===================================================
317     //  direction after the invoked process. T << 318   // Private Internal methods (implementation).
318     //  of the momentum direction of the parti << 319   //===================================================
319     //  The responsibility to apply the change << 320 
320     //  which invoked the process.             << 321   // G4FastStep should never be Initialized in this way
321     G4ParticleMomentum theMomentumChange;      << 322   // but we must define it to avoid compiler warnings.
322                                                << 323   void Initialize(const G4Track&);
323     //  The changed (final) polarization of a  << 324 
324     G4ThreeVector thePolarizationChange;       << 325   //  -- Utility functions --
325                                                << 326   //--- methods to keep information of the final state--
326     //  The final kinetic energy of the curren << 327   //  IMPORTANT NOTE: Although the name of the class and methods are
327     G4double theEnergyChange = 0.0;            << 328   //   "Change", what it stores (and returns in get) are the "FINAL" 
328                                                << 329   //   values of the Position, the normalized direction of Momentum, 
329     //  The changed (final) position of a give << 330   //   etc.
330     G4ThreeVector thePositionChange;           << 331   
331                                                << 332   // Set theMomentumChange vector: it is the final unitary momentum 
332     //  The changed (final) global time of a g << 333   // direction.
333     G4double theTimeChange = 0.0;              << 334   void SetMomentumChange(G4double Px, G4double Py, G4double Pz);
                                                   >> 335   void SetMomentumChange(const G4ThreeVector& Pfinal);
                                                   >> 336   
                                                   >> 337   //=====================================================
                                                   >> 338   // Data members.
                                                   >> 339   //=====================================================
                                                   >> 340   //  theMomentumChange is the vector containing the final momentum 
                                                   >> 341   //  direction after the invoked process. The application of the change
                                                   >> 342   //  of the momentum direction of the particle is not Done here.
                                                   >> 343   //  The responsibility to apply the change is up the entity
                                                   >> 344   //  which invoked the process.
                                                   >> 345   G4ParticleMomentum theMomentumChange;
                                                   >> 346 
                                                   >> 347   //  The changed (final) polarization of a given particle.
                                                   >> 348   G4ThreeVector thePolarizationChange;
                                                   >> 349 
                                                   >> 350   //  The final kinetic energy of the current particle.
                                                   >> 351   G4double theEnergyChange = 0.0;
                                                   >> 352 
                                                   >> 353   //  The changed (final) position of a given particle.
                                                   >> 354   G4ThreeVector thePositionChange;
                                                   >> 355 
                                                   >> 356   //  The changed (final) global time of a given particle.
                                                   >> 357   G4double theTimeChange = 0.0;
334                                                   358 
335     //  The changed (final) proper time of a g << 359   //  The changed (final) proper time of a given particle.
336     G4double theProperTimeChange = 0.0;        << 360   G4double theProperTimeChange = 0.0;
337                                                   361 
338     // The reference G4FastTrack               << 362   // The reference G4FastTrack
339     const G4FastTrack* fFastTrack = nullptr;   << 363   const G4FastTrack* fFastTrack = nullptr;
340                                                   364 
341     // weight for event biasing mechanism:     << 365   // weight for event biasing mechanism:
342     G4double theWeightChange = 0.0;            << 366   G4double theWeightChange = 0.0;
343 };                                                367 };
344                                                   368 
345 //********************************************    369 //*******************************************************************
346 //                                                370 //
347 //  Inline functions                              371 //  Inline functions
348 //                                                372 //
349 //********************************************    373 //*******************************************************************
350                                                   374 
351 #include "G4FastStep.icc"                         375 #include "G4FastStep.icc"
352                                                   376 
353 #endif                                            377 #endif
354                                                   378