Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/geometry/navigation/include/G4PropagatorInField.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 /geometry/navigation/include/G4PropagatorInField.hh (Version 11.3.0) and /geometry/navigation/include/G4PropagatorInField.hh (Version 10.0.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 // 
                                                   >>  27 // $Id: G4PropagatorInField.hh 69711 2013-05-13 09:22:17Z gcosmo $
                                                   >>  28 //
                                                   >>  29 //
 26 // Class G4PropagatorInField                       30 // Class G4PropagatorInField 
 27 //                                                 31 //
 28 // class description:                              32 // class description:
 29 //                                                 33 // 
 30 // This class performs the navigation/propagat     34 // This class performs the navigation/propagation of a particle/track 
 31 // in a magnetic field. The field is in genera     35 // in a magnetic field. The field is in general non-uniform.
 32 // For the calculation of the path, it relies      36 // For the calculation of the path, it relies on the class G4ChordFinder.
                                                   >>  37 //
                                                   >>  38 // Key Method: ComputeStep(..)
 33                                                    39 
 34 // History:                                        40 // History:
 35 // -------                                         41 // -------
 36 // 25.10.96 John Apostolakis,  design and impl     42 // 25.10.96 John Apostolakis,  design and implementation 
 37 // 25.03.97 John Apostolakis,  adaptation for      43 // 25.03.97 John Apostolakis,  adaptation for G4Transportation and cleanup
 38 //  8.11.02 John Apostolakis,  changes to enab     44 //  8.11.02 John Apostolakis,  changes to enable use of safety in intersecting
 39 // -------------------------------------------     45 // ---------------------------------------------------------------------------
                                                   >>  46 
 40 #ifndef G4PropagatorInField_hh                     47 #ifndef G4PropagatorInField_hh 
 41 #define G4PropagatorInField_hh  1                  48 #define G4PropagatorInField_hh  1
 42                                                    49 
 43 #include "G4Types.hh"                              50 #include "G4Types.hh"
 44                                                    51 
 45 #include <vector>                                  52 #include <vector>
 46                                                    53 
 47 #include "G4FieldTrack.hh"                         54 #include "G4FieldTrack.hh"
 48 #include "G4FieldManager.hh"                       55 #include "G4FieldManager.hh"
 49 #include "G4VIntersectionLocator.hh"               56 #include "G4VIntersectionLocator.hh"
 50                                                    57 
 51 class G4ChordFinder;                               58 class G4ChordFinder; 
 52                                                    59 
 53 class G4Navigator;                                 60 class G4Navigator;
 54 class G4VPhysicalVolume;                           61 class G4VPhysicalVolume;
 55 class G4VCurvedTrajectoryFilter;                   62 class G4VCurvedTrajectoryFilter;
 56                                                    63 
 57 class G4PropagatorInField                          64 class G4PropagatorInField
 58 {                                                  65 {
 59                                                    66 
 60  public:  // with description                      67  public:  // with description
 61                                                    68 
 62    G4PropagatorInField( G4Navigator* theNaviga <<  69    G4PropagatorInField( G4Navigator    *theNavigator, 
 63                         G4FieldManager* detect <<  70                         G4FieldManager *detectorFieldMgr,
 64                         G4VIntersectionLocator <<  71                         G4VIntersectionLocator *vLocator=0 );
 65   ~G4PropagatorInField();                          72   ~G4PropagatorInField();
 66                                                    73 
 67    G4double ComputeStep( G4FieldTrack& pFieldT <<  74    G4double ComputeStep( G4FieldTrack      &pFieldTrack,
 68                          G4double pCurrentProp <<  75                          G4double           pCurrentProposedStepLength,
 69                          G4double& pNewSafety, <<  76                          G4double          &pNewSafety, 
 70                          G4VPhysicalVolume* pP <<  77                          G4VPhysicalVolume *pPhysVol=0 );
 71                          G4bool canRelaxDeltaC << 
 72      // Compute the next geometric Step            78      // Compute the next geometric Step
 73                                                    79 
 74    inline G4ThreeVector EndPosition() const;   <<  80    inline G4ThreeVector  EndPosition() const;       
 75    inline G4ThreeVector EndMomentumDir() const <<  81    inline G4ThreeVector  EndMomentumDir() const;
 76    inline G4bool        IsParticleLooping() co <<  82    inline G4bool         IsParticleLooping() const;
 77      // Return the state after the Step            83      // Return the state after the Step
 78                                                    84 
 79    inline G4double GetEpsilonStep() const;     <<  85    inline G4double  GetEpsilonStep() const;
 80      // Relative accuracy for current Step (Ca     86      // Relative accuracy for current Step (Calc.)
 81    inline void     SetEpsilonStep(G4double new <<  87    inline void      SetEpsilonStep(G4double newEps);
 82      // The ratio DeltaOneStep()/h_current_ste     88      // The ratio DeltaOneStep()/h_current_step
 83                                                    89 
 84    G4FieldManager* FindAndSetFieldManager(G4VP <<  90    G4FieldManager*  FindAndSetFieldManager(G4VPhysicalVolume* pCurrentPhysVol);
 85      // Set (and return) the correct field man     91      // Set (and return) the correct field manager (global or local), 
 86      // if it exists.                          <<  92      //    if it exists.
 87      // Should be called before ComputeStep is     93      // Should be called before ComputeStep is called;
 88      // Currently, ComputeStep will call it, i <<  94      //   - currently, ComputeStep will call it, if it has not been called.
 89                                                    95  
 90    inline G4ChordFinder* GetChordFinder();         96    inline G4ChordFinder* GetChordFinder();
 91                                                    97 
 92           G4int SetVerboseLevel( G4int verbose <<  98           G4int  SetVerboseLevel( G4int verbose );
 93    inline G4int GetVerboseLevel() const;       <<  99    inline G4int  GetVerboseLevel() const;
 94    inline G4int Verbose() const;               << 100    inline G4int  Verbose() const;
 95    inline void CheckMode(G4bool mode);         << 101 
 96                                                << 102    inline G4int   GetMaxLoopCount() const;
 97    inline void   SetVerboseTrace( G4bool enabl << 103    inline void    SetMaxLoopCount( G4int new_max );
 98    inline G4bool GetVerboseTrace();            << 104      // A maximum for the number of steps that a (looping) particle can take.
 99    // Tracing key parts of Compute Step        << 105 
100                                                << 106    void printStatus( const G4FieldTrack&        startFT,
101    inline G4int GetMaxLoopCount() const;       << 107                      const G4FieldTrack&        currentFT, 
102    inline void  SetMaxLoopCount( G4int new_max << 108                            G4double             requestStep, 
103      // A maximum for the number of substeps t << 109                            G4double             safety,
104      //   Above this number it is signaled as  << 110                            G4int                step, 
105                                                << 111                            G4VPhysicalVolume*   startVolume);
106    void printStatus( const G4FieldTrack&       << 
107                      const G4FieldTrack&       << 
108                            G4double            << 
109                            G4double            << 
110                            G4int               << 
111                            G4VPhysicalVolume*  << 
112      // Print Method - useful mostly for debug    112      // Print Method - useful mostly for debugging.
113                                                   113 
114    inline G4FieldTrack GetEndState() const;       114    inline G4FieldTrack GetEndState() const;
115                                                   115 
116    inline G4double GetMinimumEpsilonStep() con << 116    inline G4double  GetMinimumEpsilonStep() const;  // Min for relative accuracy 
117    inline void     SetMinimumEpsilonStep( G4do << 117    inline void      SetMinimumEpsilonStep( G4double newEpsMin ); //  of any step
118    inline G4double GetMaximumEpsilonStep() con << 118    inline G4double  GetMaximumEpsilonStep() const;
119    inline void     SetMaximumEpsilonStep( G4do << 119    inline void      SetMaximumEpsilonStep( G4double newEpsMax );
120      // The 4 above methods are now obsolescen    120      // The 4 above methods are now obsolescent but *for now* will work 
121      // They are being replaced by same-name m    121      // They are being replaced by same-name methods in G4FieldManager,
122      // allowing the specialisation in differe    122      // allowing the specialisation in different volumes. 
123      // Their new behaviour is to change the v    123      // Their new behaviour is to change the values for the global field
124      // manager                                   124      // manager
125                                                   125 
126    void     SetLargestAcceptableStep( G4double << 126    inline void      SetLargestAcceptableStep( G4double newBigDist );
127    G4double GetLargestAcceptableStep();        << 127    inline G4double  GetLargestAcceptableStep();
128    void     ResetLargestAcceptableStep();      << 
129      // Obtain / change the size of the larges << 
130      // Reset method uses the world volume's   << 
131                                                << 
132    G4double GetMaxStepSizeMultiplier();        << 
133    void     SetMaxStepSizeMultiplier(G4double  << 
134      // Control extra Multiplier parameter for << 
135    G4double GetMinBigDistance();               << 
136    void     SetMinBigDistance(G4double val);   << 
137      // Control minimum 'directional' distance << 
138                                                   128 
139    void SetTrajectoryFilter(G4VCurvedTrajector    129    void SetTrajectoryFilter(G4VCurvedTrajectoryFilter* filter);
140      // Set the filter that examines & stores     130      // Set the filter that examines & stores 'intermediate' 
141      // curved trajectory points.  Currently o << 131      //  curved trajectory points.  Currently only position is stored.
142                                                   132 
143    std::vector<G4ThreeVector>* GimmeTrajectory    133    std::vector<G4ThreeVector>* GimmeTrajectoryVectorAndForgetIt() const;
144      // Access the points which have passed by    134      // Access the points which have passed by the filter.
145      // Responsibility for deleting the points    135      // Responsibility for deleting the points lies with the client.
146      // This method MUST BE called exactly ONC    136      // This method MUST BE called exactly ONCE per step. 
147                                                   137 
148    void ClearPropagatorState();                   138    void ClearPropagatorState();
149      // Clear all the State of this class and     139      // Clear all the State of this class and its current associates
150      // --> the current field manager & chord  << 140      //   --> the current field manager & chord finder will also be called
151                                                   141 
152    inline void SetDetectorFieldManager( G4Fiel    142    inline void SetDetectorFieldManager( G4FieldManager* newGlobalFieldManager );
153      // Update this (dangerous) state -- for t    143      // Update this (dangerous) state -- for the time being
154                                                   144   
155    inline void   SetUseSafetyForOptimization(     145    inline void   SetUseSafetyForOptimization( G4bool );
156    inline G4bool GetUseSafetyForOptimization()    146    inline G4bool GetUseSafetyForOptimization();
157      // Toggle & view parameter for using safe    147      // Toggle & view parameter for using safety to discard 
158      // unneccesary calls to navigator (thus ' << 148      //   unneccesary calls to navigator (thus 'optimising' performance)
159    inline G4bool IntersectChord( const G4Three << 149    inline G4bool IntersectChord( const G4ThreeVector&  StartPointA,
160                                  const G4Three << 150                                  const G4ThreeVector&  EndPointB,
161                                        G4doubl << 151                                  G4double      &NewSafety,
162                                        G4doubl << 152                                  G4double      &LinearStepLength,
163                                        G4Three << 153                                  G4ThreeVector &IntersectionPoint);
164      // Intersect the chord from StartPointA t    154      // Intersect the chord from StartPointA to EndPointB
165      // and return whether an intersection occ    155      // and return whether an intersection occurred
166      // NOTE: Safety is changed!               << 156      // NOTE : SAFETY IS CHANGED
167                                                   157 
168    inline G4bool IsFirstStepInVolume();        << 
169    inline G4bool IsLastStepInVolume();         << 
170    inline void PrepareNewTrack();              << 
171                                                << 
172    inline G4VIntersectionLocator* GetIntersect    158    inline G4VIntersectionLocator* GetIntersectionLocator();
173    inline void SetIntersectionLocator(G4VInter << 159    inline void SetIntersectionLocator(G4VIntersectionLocator *pLocator );
174      // Change or get the object which calcula    160      // Change or get the object which calculates the exact 
175      // intersection point with the next bound << 161      //  intersection point with the next boundary
176                                                << 162  
177    inline G4int GetIterationsToIncreaseChordDi << 
178    inline void  SetIterationsToIncreaseChordDi << 
179      // Control the parameter which enables th << 
180      //   which ensures that chord segments ar << 
181      //   their sagitta is small than delta-ch << 
182      // The Set method increases the value of  << 
183      //   doubling it once the number of itera << 
184      //   value of 'IncreaseChordDistanceThres << 
185      //   again every time the iteration count << 
186      //   value.                               << 
187      // Note: delta-chord is reset to its orig << 
188      //   each call to ComputeStep.            << 
189                                                << 
190  public:  // without description                  163  public:  // without description
191                                                   164 
192    inline G4double GetDeltaIntersection() cons << 165    inline G4double  GetDeltaIntersection() const;
193    inline G4double GetDeltaOneStep() const;    << 166    inline G4double  GetDeltaOneStep() const;
194                                                << 
195    inline G4FieldManager* GetCurrentFieldManag << 
196    inline G4EquationOfMotion* GetCurrentEquati << 
197       // Auxiliary methods - their results can << 
198                                                   167 
199    inline void SetNavigatorForPropagating(G4Na << 168    inline G4FieldManager*  GetCurrentFieldManager();
200    inline G4Navigator* GetNavigatorForPropagat << 169    inline void             SetNavigatorForPropagating( G4Navigator *SimpleOrMultiNavigator ); 
                                                   >> 170    inline G4Navigator*     GetNavigatorForPropagating(); 
201                                                   171 
202    inline void SetThresholdNoZeroStep( G4int n    172    inline void SetThresholdNoZeroStep( G4int noAct,
203                                        G4int n    173                                        G4int noHarsh,
204                                        G4int n    174                                        G4int noAbandon );
205    inline G4int GetThresholdNoZeroSteps( G4int    175    inline G4int GetThresholdNoZeroSteps( G4int i ); 
206                                                   176 
207    inline G4double GetZeroStepThreshold();     << 177    inline G4double  GetZeroStepThreshold(); 
208    inline void     SetZeroStepThreshold( G4dou << 178    inline void      SetZeroStepThreshold( G4double newLength ); 
209                                                << 179 
210    void RefreshIntersectionLocator();             180    void RefreshIntersectionLocator(); 
211      // Update the Locator with parameters fro    181      // Update the Locator with parameters from this class
212      // and from current field manager         << 182      //    and from current field manager
213                                                   183 
214  protected:  // without description            << 184  protected:  // with description
215                                                   185 
216    void PrintStepLengthDiagnostic( G4double       186    void PrintStepLengthDiagnostic( G4double      currentProposedStepLength,
217                                    G4double       187                                    G4double      decreaseFactor,
218                                    G4double       188                                    G4double      stepTrial,
219                              const G4FieldTrac    189                              const G4FieldTrack& aFieldTrack);
220                                                << 
221    void ReportLoopingParticle( G4int count,  G << 
222                                G4double stepRe << 
223                                const G4ThreeVe << 
224                                G4VPhysicalVolu << 
225    void ReportStuckParticle(G4int noZeroSteps, << 
226                             G4double lastTried << 
227                                                << 
228  private:                                         190  private:
229                                                << 
230    // ----------------------------------------    191    // ----------------------------------------------------------------------
231    //  DATA Members                               192    //  DATA Members
232    // ----------------------------------------    193    // ----------------------------------------------------------------------
233                                                   194 
234    //  =======================================    195    //  ==================================================================
235    //  INVARIANTS - Must not change during tra    196    //  INVARIANTS - Must not change during tracking
236                                                   197 
237    //  ** PARAMETERS -----------                  198    //  ** PARAMETERS -----------
238    G4int fMax_loop_count = 1000;               << 199    G4int    fMax_loop_count;
239      // Limit for the number of sub-steps take << 200        // Limit for the number of sub-steps taken in one call to ComputeStep
240    G4int fIncreaseChordDistanceThreshold = 100 << 201    G4bool   fUseSafetyForOptimisation;
241    G4bool fUseSafetyForOptimisation = true;    << 202 
242      // (false) is less sensitive to incorrect << 203     //  Thresholds for identifying "abnormal" cases - which cause looping
243                                                << 204    G4int    fActionThreshold_NoZeroSteps;       //  Threshold # - above it act
244    //  Thresholds for identifying "abnormal" c << 205    G4int    fSevereActionThreshold_NoZeroSteps; //  Threshold # to act harshly
245    //                                          << 206    G4int    fAbandonThreshold_NoZeroSteps;      //  Threshold # to abandon
246    G4int fActionThreshold_NoZeroSteps = 2;     << 207    G4double fZeroStepThreshold; 
247    G4int fSevereActionThreshold_NoZeroSteps =  << 208        // Threshold *length* for counting of tiny or 'zero' steps 
248    G4int fAbandonThreshold_NoZeroSteps = 50;   << 209  
249    G4double fZeroStepThreshold = 0.0;          << 
250      // Threshold *length* for counting of tin << 
251                                                << 
252    // Parameters related to handling of very l << 
253    //   occur typically in large volumes with  << 
254    G4double fLargestAcceptableStep;               210    G4double fLargestAcceptableStep;
255      // Maximum size of a step - for optimizat << 211        // Maximum size of a step - for optimization (and to avoid problems)
256    G4double fMaxStepSizeMultiplier = 3;        << 
257      // Multiplier for directional exit distan << 
258    G4double fMinBigDistance= 100. ; // * CLHEP << 
259      // Minimum distance added to directional  << 
260    //  ** End of PARAMETERS -----                 212    //  ** End of PARAMETERS -----
261                                                   213 
262    G4double kCarTolerance;                        214    G4double kCarTolerance;
263        // Geometrical tolerance defining surfa    215        // Geometrical tolerance defining surface thickness
264                                                   216 
265    G4bool fAllocatedLocator;                   << 217    G4bool   fAllocatedLocator;                    //  Book-keeping
266                                                   218 
267    //  ---------------------------------------    219    //  --------------------------------------------------------
268    //  ** Dependent Objects - to which work is    220    //  ** Dependent Objects - to which work is delegated 
269                                                   221 
270    G4FieldManager* fDetectorFieldMgr;          << 222    G4FieldManager         *fDetectorFieldMgr; 
271        // The  Field Manager of the whole Dete    223        // The  Field Manager of the whole Detector.  (default)
272                                                   224 
273    G4VIntersectionLocator* fIntersectionLocato << 225    G4VIntersectionLocator *fIntersectionLocator;
274      // Refines candidate intersection            226      // Refines candidate intersection
275                                                   227 
276    G4VCurvedTrajectoryFilter* fpTrajectoryFilt << 228    G4VCurvedTrajectoryFilter* fpTrajectoryFilter;
277      // The filter encapsulates the algorithm     229      // The filter encapsulates the algorithm which selects which
278      // intermediate points should be stored i    230      // intermediate points should be stored in a trajectory. 
279      // When it is NULL, no intermediate point    231      // When it is NULL, no intermediate points will be stored.
280      // Else PIF::ComputeStep must submit (all    232      // Else PIF::ComputeStep must submit (all) intermediate
281      // points it calculates, to this filter.     233      // points it calculates, to this filter.  (jacek 04/11/2002)
282                                                   234 
283    G4Navigator* fNavigator;                    << 235    G4Navigator            *fNavigator;
284      // Set externally - only by tracking / ru    236      // Set externally - only by tracking / run manager
285    //                                             237    //
286    //  ** End of Dependent Objects -----------    238    //  ** End of Dependent Objects ----------------------------
287                                                   239 
288    //  End of INVARIANTS                          240    //  End of INVARIANTS 
289    //  =======================================    241    //  ==================================================================
290                                                   242 
291    //  STATE information                          243    //  STATE information
292    //  -----------------                          244    //  -----------------
293    G4FieldManager* fCurrentFieldMgr;           << 245    G4FieldManager *fCurrentFieldMgr;
294      // The  Field Manager of the current volu << 246       // The  Field Manager of the current volume (may be the global)
295    G4bool fSetFieldMgr = false;  // Has it bee << 247    G4bool         fSetFieldMgr;  // Has it been set for the current step
296                                                   248 
297    // Parameters of current step                  249    // Parameters of current step
298    G4double fEpsilonStep;            // Relati << 250    G4double       fEpsilonStep;        // Relative accuracy of current Step
299    G4FieldTrack End_PointAndTangent; // End po << 251    G4FieldTrack   End_PointAndTangent; // End point storage
300    G4bool fParticleIsLooping = false;          << 252    G4bool         fParticleIsLooping;
301    G4int fNoZeroStep = 0;            // Count  << 253    G4int          fNoZeroStep;         //  Count of zero Steps
302                                                   254 
303    // State used for Optimisation                 255    // State used for Optimisation
304    G4double fFull_CurveLen_of_LastAttempt = -1 << 256    G4double       fFull_CurveLen_of_LastAttempt; 
305    G4double fLast_ProposedStepLength = -1;     << 257    G4double       fLast_ProposedStepLength; 
306      // Previous step information -- for use i << 258        // Previous step information -- for use in adjust step size
307    G4ThreeVector fPreviousSftOrigin;           << 259    G4ThreeVector  fPreviousSftOrigin;
308    G4double fPreviousSafety = 0.0;             << 260    G4double       fPreviousSafety; 
309      // Last safety origin & value: for optimi << 261        // Last safety origin & value: for optimisation
310                                                << 262 
311    G4int fVerboseLevel = 0;                    << 263    G4int          fVerboseLevel;
312    G4bool fVerbTracePiF = false;               << 264        // For debuging purposes
313    G4bool fCheck = false;                      << 265 
314      // For debugging purposes                 << 266  private:
315                                                << 
316    G4bool fFirstStepInVolume = true;           << 
317    G4bool fLastStepInVolume = true;            << 
318    G4bool fNewTrack = true;                    << 
319 };                                                267 };
320                                                   268 
321 // Inline methods                              << 269 // Inline methods.
322 //                                             << 270 // *******************************
                                                   >> 271 
323 #include "G4PropagatorInField.icc"                272 #include "G4PropagatorInField.icc"
324                                                   273 
325 #endif                                            274 #endif 
326                                                   275