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 9.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 // Class G4PropagatorInField                   << 
 27 //                                                 26 //
 28 // class description:                          <<  27 // $Id: G4PropagatorInField.hh,v 1.13 2007/06/08 09:49:34 gcosmo Exp $
                                                   >>  28 // GEANT4 tag $Name: geant4-09-01 $
                                                   >>  29 // 
                                                   >>  30 // class G4PropagatorInField 
                                                   >>  31 //
                                                   >>  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.
 33                                                <<  37 //
                                                   >>  38 // Key Method:
                                                   >>  39 //              ComputeStep(..)
 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"           << 
 50                                                << 
 51 class G4ChordFinder;                               56 class G4ChordFinder; 
 52                                                    57 
 53 class G4Navigator;                                 58 class G4Navigator;
 54 class G4VPhysicalVolume;                           59 class G4VPhysicalVolume;
 55 class G4VCurvedTrajectoryFilter;                   60 class G4VCurvedTrajectoryFilter;
 56                                                    61 
 57 class G4PropagatorInField                          62 class G4PropagatorInField
 58 {                                                  63 {
 59                                                    64 
 60  public:  // with description                      65  public:  // with description
 61                                                    66 
 62    G4PropagatorInField( G4Navigator* theNaviga <<  67    G4PropagatorInField( G4Navigator    *theNavigator, 
 63                         G4FieldManager* detect <<  68                         G4FieldManager *detectorFieldMgr );
 64                         G4VIntersectionLocator << 
 65   ~G4PropagatorInField();                          69   ~G4PropagatorInField();
 66                                                    70 
 67    G4double ComputeStep( G4FieldTrack& pFieldT <<  71    G4double ComputeStep( G4FieldTrack      &pFieldTrack,
 68                          G4double pCurrentProp <<  72                          G4double           pCurrentProposedStepLength,
 69                          G4double& pNewSafety, <<  73                          G4double          &pNewSafety, 
 70                          G4VPhysicalVolume* pP <<  74                          G4VPhysicalVolume *pPhysVol=0 );
 71                          G4bool canRelaxDeltaC << 
 72      // Compute the next geometric Step            75      // Compute the next geometric Step
 73                                                    76 
 74    inline G4ThreeVector EndPosition() const;   <<  77    inline G4ThreeVector  EndPosition() const;       
 75    inline G4ThreeVector EndMomentumDir() const <<  78    inline G4ThreeVector  EndMomentumDir() const;
 76    inline G4bool        IsParticleLooping() co <<  79    inline G4bool         IsParticleLooping() const;
 77      // Return the state after the Step            80      // Return the state after the Step
 78                                                    81 
 79    inline G4double GetEpsilonStep() const;     <<  82    inline G4double  GetEpsilonStep() const;
 80      // Relative accuracy for current Step (Ca     83      // Relative accuracy for current Step (Calc.)
 81    inline void     SetEpsilonStep(G4double new <<  84    inline void      SetEpsilonStep(G4double newEps);
 82      // The ratio DeltaOneStep()/h_current_ste     85      // The ratio DeltaOneStep()/h_current_step
 83                                                    86 
 84    G4FieldManager* FindAndSetFieldManager(G4VP <<  87    inline void SetChargeMomentumMass( G4double charge,     // in e+ units
                                                   >>  88                                       G4double momentum,   // in Geant4 units
                                                   >>  89                                       G4double pMass );  
                                                   >>  90      // Inform this and all associated classes of q, p, m 
                                                   >>  91 
                                                   >>  92    G4FieldManager*  FindAndSetFieldManager(G4VPhysicalVolume* pCurrentPhysVol);
 85      // Set (and return) the correct field man     93      // Set (and return) the correct field manager (global or local), 
 86      // if it exists.                          <<  94      //    if it exists.
 87      // Should be called before ComputeStep is     95      // Should be called before ComputeStep is called;
 88      // Currently, ComputeStep will call it, i <<  96      //   - currently, ComputeStep will call it, if it has not been called.
 89                                                    97  
 90    inline G4ChordFinder* GetChordFinder();         98    inline G4ChordFinder* GetChordFinder();
 91                                                    99 
 92           G4int SetVerboseLevel( G4int verbose << 100           G4int  SetVerboseLevel( G4int verbose );
 93    inline G4int GetVerboseLevel() const;       << 101    inline G4int  GetVerboseLevel() const;
 94    inline G4int Verbose() const;               << 102    inline G4int  Verbose() const;
 95    inline void CheckMode(G4bool mode);         << 103 
 96                                                << 104    inline G4int   GetMaxLoopCount() const;
 97    inline void   SetVerboseTrace( G4bool enabl << 105    inline void    SetMaxLoopCount( G4int new_max );
 98    inline G4bool GetVerboseTrace();            << 106      // A maximum for the number of steps that a (looping) particle can take.
 99    // Tracing key parts of Compute Step        << 107 
100                                                << 108    void printStatus( const G4FieldTrack&        startFT,
101    inline G4int GetMaxLoopCount() const;       << 109                      const G4FieldTrack&        currentFT, 
102    inline void  SetMaxLoopCount( G4int new_max << 110                            G4double             requestStep, 
103      // A maximum for the number of substeps t << 111                            G4double             safety,
104      //   Above this number it is signaled as  << 112                            G4int                step, 
105                                                << 113                            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    114      // Print Method - useful mostly for debugging.
113                                                   115 
114    inline G4FieldTrack GetEndState() const;       116    inline G4FieldTrack GetEndState() const;
115                                                   117 
116    inline G4double GetMinimumEpsilonStep() con << 118    // The following methods are now obsolescent but *for now* will work 
117    inline void     SetMinimumEpsilonStep( G4do << 119    //   They are being replaced by same-name methods in G4FieldManager,
118    inline G4double GetMaximumEpsilonStep() con << 120    //   allowing the specialisation in different volumes. 
119    inline void     SetMaximumEpsilonStep( G4do << 121    //   Their new behaviour is to change the values for the global field manager. 
120      // The 4 above methods are now obsolescen << 122    inline G4double  GetMinimumEpsilonStep() const;
121      // They are being replaced by same-name m << 123    inline void      SetMinimumEpsilonStep( G4double newEpsMin );
122      // allowing the specialisation in differe << 124      // Minimum for Relative accuracy of any Step 
123      // Their new behaviour is to change the v << 
124      // manager                                << 
125                                                << 
126    void     SetLargestAcceptableStep( G4double << 
127    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                                                << 
139    void SetTrajectoryFilter(G4VCurvedTrajector << 
140      // Set the filter that examines & stores  << 
141      // curved trajectory points.  Currently o << 
142                                                << 
143    std::vector<G4ThreeVector>* GimmeTrajectory << 
144      // Access the points which have passed by << 
145      // Responsibility for deleting the points << 
146      // This method MUST BE called exactly ONC << 
147                                                << 
148    void ClearPropagatorState();                << 
149      // Clear all the State of this class and  << 
150      // --> the current field manager & chord  << 
151                                                   125 
152    inline void SetDetectorFieldManager( G4Fiel << 126    inline G4double  GetMaximumEpsilonStep() const;
153      // Update this (dangerous) state -- for t << 127    inline void      SetMaximumEpsilonStep( G4double newEpsMax );
154                                                << 
155    inline void   SetUseSafetyForOptimization(  << 
156    inline G4bool GetUseSafetyForOptimization() << 
157      // Toggle & view parameter for using safe << 
158      // unneccesary calls to navigator (thus ' << 
159    inline G4bool IntersectChord( const G4Three << 
160                                  const G4Three << 
161                                        G4doubl << 
162                                        G4doubl << 
163                                        G4Three << 
164      // Intersect the chord from StartPointA t << 
165      // and return whether an intersection occ << 
166      // NOTE: Safety is changed!               << 
167                                                   128 
168    inline G4bool IsFirstStepInVolume();        << 129    inline void      SetLargestAcceptableStep( G4double newBigDist );
169    inline G4bool IsLastStepInVolume();         << 130    inline G4double  GetLargestAcceptableStep();
170    inline void PrepareNewTrack();              << 
171                                                << 
172    inline G4VIntersectionLocator* GetIntersect << 
173    inline void SetIntersectionLocator(G4VInter << 
174      // Change or get the object which calcula << 
175      // intersection point with the next bound << 
176                                                << 
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                                                   131 
190  public:  // without description               << 132  public:  // with description
191                                                   133 
192    inline G4double GetDeltaIntersection() cons << 134    // The following methods are obsolete and will not work --
193    inline G4double GetDeltaOneStep() const;    << 135    //   as they have been replaced by the same methods in G4FieldManager
                                                   >> 136    //   since Geant4 4.0
                                                   >> 137    inline G4double  GetDeltaIntersection() const;
                                                   >> 138    inline G4double  GetDeltaOneStep() const;
                                                   >> 139    inline void    SetAccuraciesWithDeltaOneStep( G4double deltaOneStep );  
                                                   >> 140    inline void    SetDeltaIntersection( G4double deltaIntersection );
                                                   >> 141    inline void    SetDeltaOneStep( G4double deltaOneStep );  
                                                   >> 142 
                                                   >> 143  public:  // without description
194                                                   144 
195    inline G4FieldManager* GetCurrentFieldManag << 145    inline G4FieldManager*  GetCurrentFieldManager();
196    inline G4EquationOfMotion* GetCurrentEquati << 146    inline void             SetNavigatorForPropagating( G4Navigator *SimpleOrMultiNavigator ); 
197       // Auxiliary methods - their results can << 147    inline G4Navigator*     GetNavigatorForPropagating(); 
198                                                   148 
199    inline void SetNavigatorForPropagating(G4Na << 149  public:  // no description
200    inline G4Navigator* GetNavigatorForPropagat << 
201                                                   150 
202    inline void SetThresholdNoZeroStep( G4int n    151    inline void SetThresholdNoZeroStep( G4int noAct,
203                                        G4int n    152                                        G4int noHarsh,
204                                        G4int n    153                                        G4int noAbandon );
205    inline G4int GetThresholdNoZeroSteps( G4int    154    inline G4int GetThresholdNoZeroSteps( G4int i ); 
206                                                   155 
207    inline G4double GetZeroStepThreshold();     << 156  public:  // with description
208    inline void     SetZeroStepThreshold( G4dou << 157   // 
209                                                << 158   void SetTrajectoryFilter(G4VCurvedTrajectoryFilter* filter);
210    void RefreshIntersectionLocator();          << 159   // Set the filter that examines & stores 'intermediate' 
211      // Update the Locator with parameters fro << 160   //  curved trajectory points.  Currently only position is stored.
212      // and from current field manager         << 161 
                                                   >> 162   std::vector<G4ThreeVector>* GimmeTrajectoryVectorAndForgetIt() const;
                                                   >> 163   // Access the points which have passed by the filter.
                                                   >> 164   // Responsibility for deleting the points lies with the client.
                                                   >> 165   // This method MUST BE called exactly ONCE per step. 
                                                   >> 166 
                                                   >> 167   void ClearPropagatorState();
                                                   >> 168   // Clear all the State of this class and its current associates
                                                   >> 169   //   --> the current field manager & chord finder will also be called
                                                   >> 170 
                                                   >> 171   inline void SetDetectorFieldManager( G4FieldManager* newGlobalFieldManager );
                                                   >> 172       // Update this (dangerous) state -- for the time being
                                                   >> 173   
                                                   >> 174   inline void   SetUseSafetyForOptimization( G4bool );
                                                   >> 175   inline G4bool GetUseSafetyForOptimization();
                                                   >> 176       // Toggle & view parameter for using safety to discard 
                                                   >> 177       //   unneccesary calls to navigator (thus 'optimising' performance)
                                                   >> 178 
                                                   >> 179  protected:  // with description
                                                   >> 180 
                                                   >> 181    G4bool LocateIntersectionPoint( 
                                                   >> 182         const  G4FieldTrack&       curveStartPointTangent,  //  A
                                                   >> 183         const  G4FieldTrack&       curveEndPointTangent,    //  B
                                                   >> 184         const  G4ThreeVector&      trialPoint,              //  E
                                                   >> 185                G4FieldTrack&       intersectPointTangent,   // Output
                                                   >> 186                G4bool&             recalculatedEndPoint);   // Out: 
                                                   >> 187 
                                                   >> 188      // If such an intersection exists, this function 
                                                   >> 189      // calculate the intersection point of the true path of the particle 
                                                   >> 190      // with the surface of the current volume (or of one of its daughters). 
                                                   >> 191      // (Should use lateral displacement as measure of convergence). 
                                                   >> 192 
                                                   >> 193    G4bool IntersectChord( G4ThreeVector  StartPointA, 
                                                   >> 194                           G4ThreeVector  EndPointB,
                                                   >> 195                           G4double      &NewSafety,
                                                   >> 196                           G4double      &LinearStepLength,
                                                   >> 197                           G4ThreeVector &IntersectionPoint);
                                                   >> 198      // Intersect the chord from StartPointA to EndPointB
                                                   >> 199      // and return whether an intersection occurred
213                                                   200 
214  protected:  // without description            << 201    G4FieldTrack ReEstimateEndpoint( const G4FieldTrack &CurrentStateA,  
                                                   >> 202                                     const G4FieldTrack &EstimtdEndStateB,
                                                   >> 203                                           G4double      linearDistSq,
                                                   >> 204                                           G4double      curveDist);
                                                   >> 205      // Return new estimate for state after curveDist 
                                                   >> 206      // starting from CurrentStateA,  to replace EstimtdEndStateB,
                                                   >> 207      // (and report displacement -- if field is compiled verbose.)
215                                                   208 
216    void PrintStepLengthDiagnostic( G4double       209    void PrintStepLengthDiagnostic( G4double      currentProposedStepLength,
217                                    G4double       210                                    G4double      decreaseFactor,
218                                    G4double       211                                    G4double      stepTrial,
219                              const G4FieldTrac    212                              const G4FieldTrack& aFieldTrack);
                                                   >> 213  private:
220                                                   214 
221    void ReportLoopingParticle( G4int count,  G << 215   // ----------------------------------------------------------------------
222                                G4double stepRe << 216   //  DATA Members
223                                const G4ThreeVe << 217   // ----------------------------------------------------------------------
224                                G4VPhysicalVolu << 
225    void ReportStuckParticle(G4int noZeroSteps, << 
226                             G4double lastTried << 
227                                                   218 
228  private:                                      << 219    G4FieldManager *fDetectorFieldMgr; 
                                                   >> 220      // The  Field Manager of the whole Detector.  (default)
                                                   >> 221 
                                                   >> 222    G4FieldManager *fCurrentFieldMgr;
                                                   >> 223      // The  Field Manager of the current volume (may be the one above.)
                                                   >> 224 
                                                   >> 225    G4Navigator   *fNavigator;
                                                   >> 226 
                                                   >> 227    //  STATE information
                                                   >> 228    //  -----------------
                                                   >> 229 
                                                   >> 230    G4double    fEpsilonStep;
                                                   >> 231      // Relative accuracy for current Step (Calc.)
                                                   >> 232 
                                                   >> 233    G4FieldTrack    End_PointAndTangent;
                                                   >> 234      // End point storage
229                                                   235 
230    // ---------------------------------------- << 236    G4bool      fParticleIsLooping;
231    //  DATA Members                            << 
232    // ---------------------------------------- << 
233                                                   237 
234    //  ======================================= << 238    G4int  fVerboseLevel;
235    //  INVARIANTS - Must not change during tra << 239      // For debuging purposes
236                                                   240 
237    //  ** PARAMETERS -----------               << 241    G4int  fMax_loop_count;
238    G4int fMax_loop_count = 1000;               << 
239      // Limit for the number of sub-steps take    242      // Limit for the number of sub-steps taken in one call to ComputeStep
240    G4int fIncreaseChordDistanceThreshold = 100 << 
241    G4bool fUseSafetyForOptimisation = true;    << 
242      // (false) is less sensitive to incorrect << 
243                                                   243 
244    //  Thresholds for identifying "abnormal" c << 244    //  Variables to keep track of "abnormal" case - which causes loop
245    //                                             245    //
246    G4int fActionThreshold_NoZeroSteps = 2;     << 246    G4int     fNoZeroStep;                        //  Counter of zeroStep
247    G4int fSevereActionThreshold_NoZeroSteps =  << 247    G4int     fActionThreshold_NoZeroSteps;       //  Threshold: above this - act
248    G4int fAbandonThreshold_NoZeroSteps = 50;   << 248    G4int     fSevereActionThreshold_NoZeroSteps; //  Threshold to act harshly
249    G4double fZeroStepThreshold = 0.0;          << 249    G4int     fAbandonThreshold_NoZeroSteps;      //  Threshold to abandon
250      // Threshold *length* for counting of tin << 250 
251                                                << 251    G4double  fFull_CurveLen_of_LastAttempt; 
252    // Parameters related to handling of very l << 252    G4double  fLast_ProposedStepLength; 
253    //   occur typically in large volumes with  << 253    G4double  fLargestAcceptableStep;
254    G4double fLargestAcceptableStep;            << 254 
255      // Maximum size of a step - for optimizat << 255    G4double  fCharge, fInitialMomentumModulus, fMass;
256    G4double fMaxStepSizeMultiplier = 3;        << 256 
257      // Multiplier for directional exit distan << 257    G4ThreeVector  fPreviousSftOrigin;
258    G4double fMinBigDistance= 100. ; // * CLHEP << 258    G4double       fPreviousSafety; 
259      // Minimum distance added to directional  << 259    G4bool         fUseSafetyForOptimisation;
260    //  ** End of PARAMETERS -----              << 260      // Last safety origin & value: for optimisation
261                                                << 
262    G4double kCarTolerance;                     << 
263        // Geometrical tolerance defining surfa << 
264                                                << 
265    G4bool fAllocatedLocator;                   << 
266                                                << 
267    //  --------------------------------------- << 
268    //  ** Dependent Objects - to which work is << 
269                                                << 
270    G4FieldManager* fDetectorFieldMgr;          << 
271        // The  Field Manager of the whole Dete << 
272                                                << 
273    G4VIntersectionLocator* fIntersectionLocato << 
274      // Refines candidate intersection         << 
275                                                << 
276    G4VCurvedTrajectoryFilter* fpTrajectoryFilt << 
277      // The filter encapsulates the algorithm  << 
278      // intermediate points should be stored i << 
279      // When it is NULL, no intermediate point << 
280      // Else PIF::ComputeStep must submit (all << 
281      // points it calculates, to this filter.  << 
282                                                   261 
283    G4Navigator* fNavigator;                    << 262    G4bool fSetFieldMgr; 
284      // Set externally - only by tracking / ru << 263      // Flag whether field manager has been set for the current step
285    //                                          << 
286    //  ** End of Dependent Objects ----------- << 
287                                                   264 
288    //  End of INVARIANTS                       << 265    G4double  kCarTolerance;
289    //  ======================================= << 266      // Geometrical tolerance defining surface thickness
290                                                   267 
291    //  STATE information                       << 268 private:
292    //  -----------------                       << 
293    G4FieldManager* fCurrentFieldMgr;           << 
294      // The  Field Manager of the current volu << 
295    G4bool fSetFieldMgr = false;  // Has it bee << 
296                                                << 
297    // Parameters of current step               << 
298    G4double fEpsilonStep;            // Relati << 
299    G4FieldTrack End_PointAndTangent; // End po << 
300    G4bool fParticleIsLooping = false;          << 
301    G4int fNoZeroStep = 0;            // Count  << 
302                                                << 
303    // State used for Optimisation              << 
304    G4double fFull_CurveLen_of_LastAttempt = -1 << 
305    G4double fLast_ProposedStepLength = -1;     << 
306      // Previous step information -- for use i << 
307    G4ThreeVector fPreviousSftOrigin;           << 
308    G4double fPreviousSafety = 0.0;             << 
309      // Last safety origin & value: for optimi << 
310                                                   269 
311    G4int fVerboseLevel = 0;                    << 270    static const G4int max_depth=4;
312    G4bool fVerbTracePiF = false;               << 271    G4FieldTrack* ptrInterMedFT[max_depth+1];
313    G4bool fCheck = false;                      << 272      // Used to store intermediate values of tracks in case of
314      // For debugging purposes                 << 273      // too slow progress
315                                                << 274 
316    G4bool fFirstStepInVolume = true;           << 275 private:
317    G4bool fLastStepInVolume = true;            << 276 
318    G4bool fNewTrack = true;                    << 277   G4VCurvedTrajectoryFilter* fpTrajectoryFilter;
                                                   >> 278     // The filter encapsulates the algorithm which selects which
                                                   >> 279     // intermediate points should be stored in a trajectory. 
                                                   >> 280     // When it is NULL, no intermediate points will be stored.
                                                   >> 281     // Else PIF::ComputeStep must submit (all) intermediate
                                                   >> 282     // points it calculates, to this filter.  (jacek 04/11/2002)
319 };                                                283 };
320                                                   284 
321 // Inline methods                              << 285 // ********************************************************************
322 //                                             << 286 // Inline methods.
                                                   >> 287 // ********************************************************************
                                                   >> 288 
323 #include "G4PropagatorInField.icc"                289 #include "G4PropagatorInField.icc"
324                                                   290 
325 #endif                                            291 #endif 
326                                                   292