Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/geometry/navigation/include/G4Navigator.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/G4Navigator.hh (Version 11.3.0) and /geometry/navigation/include/G4Navigator.hh (Version 8.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 // G4Navigator                                 <<  26 //
                                                   >>  27 // $Id: G4Navigator.hh,v 1.14 2006/06/29 18:36:01 gunter Exp $
                                                   >>  28 // GEANT4 tag $Name: geant4-08-01 $
                                                   >>  29 //
                                                   >>  30 //
                                                   >>  31 // class G4Navigator
 27 //                                                 32 //
 28 // Class description:                              33 // Class description:
 29 //                                                 34 //
 30 // A class for use by the tracking management,     35 // A class for use by the tracking management, able to obtain/calculate
 31 // dynamic tracking time information such as t     36 // dynamic tracking time information such as the distance to the next volume,
 32 // or to find the physical volume containing a     37 // or to find the physical volume containing a given point in the world
 33 // reference system. The navigator maintains a     38 // reference system. The navigator maintains a transformation history and
 34 // other information to optimise the tracking      39 // other information to optimise the tracking time performance.
 35                                                <<  40 //
                                                   >>  41 // History:
 36 // - Created.                                      42 // - Created.                                  Paul Kent,     Jul 95/96
 37 // - Made Navigator Abstract                   << 
 38 // - Added check mode                          << 
 39 // - Zero step protections                         43 // - Zero step protections                     J.A. / G.C.,   Nov  2004
 40 // ------------------------------------------- <<  44 // - Added check mode                          G. Cosmo,      Mar  2004
                                                   >>  45 // - Made Navigator Abstract                   G. Cosmo,      Nov  2003
                                                   >>  46 // *********************************************************************
                                                   >>  47 
 41 #ifndef G4NAVIGATOR_HH                             48 #ifndef G4NAVIGATOR_HH
 42 #define G4NAVIGATOR_HH 1                       <<  49 #define G4NAVIGATOR_HH
 43                                                    50 
 44 #include "geomdefs.hh"                             51 #include "geomdefs.hh"
 45                                                    52 
 46 #include "G4ThreeVector.hh"                        53 #include "G4ThreeVector.hh"
 47 #include "G4AffineTransform.hh"                    54 #include "G4AffineTransform.hh"
 48 #include "G4RotationMatrix.hh"                     55 #include "G4RotationMatrix.hh"
 49                                                    56 
 50 #include "G4LogicalVolume.hh"             // U     57 #include "G4LogicalVolume.hh"             // Used in inline methods
                                                   >>  58 #include "G4GRSVolume.hh"                 //    "         "
                                                   >>  59 #include "G4GRSSolid.hh"                  //    "         "
 51 #include "G4TouchableHandle.hh"           //       60 #include "G4TouchableHandle.hh"           //    "         "
                                                   >>  61 #include "G4TouchableHistoryHandle.hh"
 52                                                    62 
 53 #include "G4NavigationHistory.hh"                  63 #include "G4NavigationHistory.hh"
 54 #include "G4NormalNavigation.hh"                   64 #include "G4NormalNavigation.hh"
 55 #include "G4VoxelNavigation.hh"                    65 #include "G4VoxelNavigation.hh"
 56 #include "G4ParameterisedNavigation.hh"            66 #include "G4ParameterisedNavigation.hh"
 57 #include "G4ReplicaNavigation.hh"                  67 #include "G4ReplicaNavigation.hh"
 58 #include "G4RegularNavigation.hh"              << 
 59 #include "G4VExternalNavigation.hh"            << 
 60                                                    68 
 61 #include <iostream>                                69 #include <iostream>
 62                                                    70 
 63 class G4VPhysicalVolume;                           71 class G4VPhysicalVolume;
 64 class G4SafetyCalculator;                      << 
 65                                                    72 
 66 class G4Navigator                                  73 class G4Navigator
 67 {                                                  74 {
 68   public:                                      <<  75   public:  // with description
 69                                                    76 
 70     friend std::ostream& operator << (std::ost <<  77   friend std::ostream& operator << (std::ostream &os, const G4Navigator &n);
 71                                                    78 
 72     G4Navigator();                             <<  79   G4Navigator();
 73       // Constructor - initialisers and setup. <<  80     // Constructor - initialisers and setup.
 74                                                << 
 75     G4Navigator(const G4Navigator&) = delete;  << 
 76     G4Navigator& operator=(const G4Navigator&) << 
 77       // Copy constructor & assignment operato << 
 78                                                << 
 79     virtual ~G4Navigator();                    << 
 80       // Destructor. No actions.               << 
 81                                                << 
 82     virtual G4double ComputeStep(const G4Three << 
 83                                  const G4Three << 
 84                                  const G4doubl << 
 85                                        G4doubl << 
 86       // Calculate the distance to the next bo << 
 87       // along the specified NORMALISED vector << 
 88       // from the specified point in the globa << 
 89       // system. LocateGlobalPointAndSetup or  << 
 90       // must have been called with the same g << 
 91       // The isotropic distance to the nearest << 
 92       // calculated (usually an underestimate) << 
 93       // proposed Step length is used to avoid << 
 94       // calculations: if it can be determined << 
 95       // boundary is >pCurrentProposedStepLeng << 
 96       // is returned together with the compute << 
 97       // distance. Geometry must be closed.    << 
 98                                                << 
 99     G4double CheckNextStep(const G4ThreeVector << 
100                            const G4ThreeVector << 
101                            const G4double pCur << 
102                                  G4double& pNe << 
103       // Same as above, but do not disturb the << 
104                                                << 
105     virtual                                    << 
106     G4VPhysicalVolume* ResetHierarchyAndLocate << 
107                                                << 
108                                                << 
109                                                << 
110       // Resets the geometrical hierarchy and  << 
111       // in the hierarchy containing the point << 
112       // The direction is used to check if a v << 
113       // The search begin is the geometrical h << 
114       // last located point, or the endpoint o << 
115       // SetGeometricallyLimitedStep() has bee << 
116       //                                       << 
117       // Important Note: In order to call this << 
118                                                << 
119     virtual                                    << 
120     G4VPhysicalVolume* LocateGlobalPointAndSet << 
121                                        const G << 
122                                        const G << 
123                                        const G << 
124       // Search the geometrical hierarchy for  << 
125       // containing the point in the global co << 
126       // are:                                  << 
127       //  i) If pRelativeSearch=false it makes << 
128       //     information. Returns the physical << 
129       //     with all previous mothers correct << 
130       // ii) If pRelativeSearch is set to true << 
131       //     geometrical hierarchy at the loca << 
132       //     or the endpoint of previous Step  << 
133       //     has been called immediately befor << 
134       // The direction is used (to check if a  << 
135       //   - the argument ignoreDirection is f << 
136       //   - the Navigator has determined that << 
137       //     or more volumes.  (This is state  << 
138       //                                       << 
139       // Important Note: In order to call this << 
140                                                << 
141     virtual                                    << 
142     void LocateGlobalPointWithinVolume(const G << 
143       // Notify the Navigator that a track has << 
144       // 'position', that is known to be withi << 
145       // No check is performed to ensure that  << 
146       // This method can be called instead of  << 
147       // the caller is certain that the new gl << 
148       // the same volume as the previous posit << 
149       // Usually this can be guaranteed only i << 
150                                                << 
151     inline void LocateGlobalPointAndUpdateTouc << 
152                   const G4ThreeVector&       p << 
153                   const G4ThreeVector&       d << 
154                         G4TouchableHandle&   o << 
155                   const G4bool               R << 
156       // First, search the geometrical hierarc << 
157       // LocateGlobalPointAndSetup(). Then use << 
158       // navigation history to update the touc << 
159                                                << 
160     inline void LocateGlobalPointAndUpdateTouc << 
161                   const G4ThreeVector&       p << 
162                   const G4ThreeVector&       d << 
163                         G4VTouchable*        t << 
164                   const G4bool               R << 
165       // First, search the geometrical hierarc << 
166       // LocateGlobalPointAndSetup(). Then use << 
167       // navigation history to update the touc << 
168                                                << 
169     inline void LocateGlobalPointAndUpdateTouc << 
170                   const G4ThreeVector&       p << 
171                         G4VTouchable*        t << 
172                   const G4bool               R << 
173       // Same as the method above but missing  << 
174                                                << 
175     inline void SetGeometricallyLimitedStep(); << 
176       // Inform the navigator that the previou << 
177       // by the geometry was taken in its enti << 
178                                                << 
179     virtual G4double ComputeSafety(const G4Thr << 
180                                    const G4dou << 
181                                    const G4boo << 
182       // Calculate the isotropic distance to t << 
183       // specified point in the global coordin << 
184       // The globalpoint utilised must be with << 
185       // The value returned is usually an unde << 
186       // The proposed maximum length is used t << 
187       // calculations.  The geometry must be c << 
188       // To ensure minimum side effects from t << 
189                                                << 
190     inline G4VPhysicalVolume* GetWorldVolume() << 
191       // Return the current  world (`topmost') << 
192                                                << 
193     inline void SetWorldVolume(G4VPhysicalVolu << 
194       // Set the world (`topmost') volume. Thi << 
195       // origin (0,0,0) and unrotated.         << 
196                                                << 
197     inline G4TouchableHistory* CreateTouchable << 
198     inline G4TouchableHistory* CreateTouchable << 
199       // `Touchable' creation methods: caller  << 
200                                                << 
201     virtual G4TouchableHandle CreateTouchableH << 
202       // Returns a reference counted handle to << 
203                                                << 
204     virtual G4ThreeVector GetLocalExitNormal(G << 
205     virtual G4ThreeVector GetLocalExitNormalAn << 
206                                                << 
207     virtual G4ThreeVector GetGlobalExitNormal( << 
208                                                << 
209       // Return Exit Surface Normal and validi << 
210       // Can only be called if the Navigator's << 
211       // volume geometrical boundary.          << 
212       // It returns the Normal to the surface  << 
213       // was left behind and/or into the volum << 
214       // Convention:                           << 
215       //   The *local* normal is in the coordi << 
216       // Restriction:                          << 
217       //   Normals are not available for repli << 
218       // These methods takes full care about h << 
219       // but if the surfaces are not convex it << 
220                                                << 
221     inline G4int GetVerboseLevel() const;      << 
222     inline void  SetVerboseLevel(G4int level); << 
223       // Get/Set Verbose(ness) level.          << 
224       // [if level>0 && G4VERBOSE, printout ca << 
225                                                << 
226     inline G4bool IsActive() const;            << 
227       // Verify if the navigator is active.    << 
228     inline void  Activate(G4bool flag);        << 
229       // Activate/inactivate the navigator.    << 
230                                                << 
231     inline G4bool EnteredDaughterVolume() cons << 
232       // The purpose of this function is to in << 
233       // entering a daughter volume while exit << 
234       // This method returns                   << 
235       // - True only in case 1) above, that is << 
236       //   the track to arrive at a boundary o << 
237       // - False in cases 2), 3) and 4), i.e.  << 
238       // This function is not guaranteed to wo << 
239       // was not called when it should have be << 
240     inline G4bool ExitedMotherVolume() const;  << 
241       // Verify if the step has exited the mot << 
242                                                << 
243     inline void CheckMode(G4bool mode);        << 
244       // Run navigation in "check-mode", there << 
245       // verifications and more strict correct << 
246       // Is effective only with G4VERBOSE set. << 
247     inline G4bool IsCheckModeActive() const;   << 
248     inline void SetPushVerbosity(G4bool mode); << 
249       // Set/unset verbosity for pushed tracks << 
250                                                << 
251     void PrintState() const;                   << 
252       // Print the internal state of the Navig << 
253       // The level of detail is according to t << 
254                                                << 
255     inline const G4AffineTransform& GetGlobalT << 
256     inline const G4AffineTransform  GetLocalTo << 
257       // Obtain the transformations Global/Loc << 
258       // Clients of these methods must copy th << 
259                                                << 
260     G4AffineTransform GetMotherToDaughterTrans << 
261                                                << 
262                                                << 
263       // Obtain mother to daughter transformat << 
264                                                << 
265     inline void ResetStackAndState();          << 
266       // Reset stack and minimum or navigator  << 
267       // as needed by LocalGlobalPointAndSetup << 
268       // Does not perform clears, resizes, or  << 
269                                                << 
270     inline G4int SeverityOfZeroStepping( G4int << 
271       // Report on severity of error and numbe << 
272       // in case Navigator is stuck and is ret << 
273       // Values: 1 (small problem),  5 (correc << 
274       //         9 (ready to abandon), 10 (aba << 
275                                                << 
276     inline G4ThreeVector GetCurrentLocalCoordi << 
277       // Return the local coordinate of the po << 
278       // of its containing volume that was fou << 
279       // The local coordinate of the last loca << 
280                                                << 
281     inline G4ThreeVector NetTranslation() cons << 
282     inline G4RotationMatrix NetRotation() cons << 
283       // Compute+return the local->global tran << 
284                                                << 
285     inline void EnableBestSafety( G4bool value << 
286       // Enable best-possible evaluation of is << 
287                                                << 
288     inline G4VExternalNavigation* GetExternalN << 
289     void SetExternalNavigation(G4VExternalNavi << 
290       // Accessor & modifier for custom extern << 
291                                                << 
292     inline G4VoxelNavigation& GetVoxelNavigato << 
293     void SetVoxelNavigation(G4VoxelNavigation* << 
294       // Alternative navigator for voxel volum << 
295                                                << 
296     inline G4Navigator* Clone() const;         << 
297       // Cloning feature for use in MT applica << 
298       // navigator, including external sub-nav << 
299       // Client has responsibility for ownersh << 
300                                                << 
301     inline G4ThreeVector GetLastStepEndPoint() << 
302       // Get endpoint of last step.            << 
303                                                << 
304     void InformLastStep(G4double lastStep,     << 
305                         G4bool entersDaughtVol << 
306                         G4bool exitsMotherVol  << 
307       // Derived navigators which rely on Loca << 
308       // inform size of step, to maintain logi << 
309       // for challenging cases.                << 
310       // Required in order to cope with multip << 
311       // => Locate with use direction rather t << 
312                                                << 
313   protected:                                   << 
314                                                << 
315     void SetSavedState();                      << 
316       // ( fValidExitNormal, fExitNormal, fExi << 
317       //   fBlockedPhysicalVolume, fBlockedRep << 
318       // Extended to include:                  << 
319       // ( fLastLocatedPointLocal, fLocatedOut << 
320       //   fEnteredDaughter, fExitedMother     << 
321       //   fPreviousSftOrigin, sPreviousSafety << 
322                                                << 
323     void RestoreSavedState();                  << 
324       // Copy aspects of the state, to enable  << 
325       // call to ComputeStep().                << 
326                                                << 
327     virtual void ResetState();                 << 
328       // Utility method to reset the navigator << 
329                                                    81 
330     inline G4ThreeVector ComputeLocalPoint(con <<  82   virtual ~G4Navigator();
331       // Return position vector in local coord <<  83     // Destructor. No actions.
332       // vector in world coordinate system.    <<  84 
333                                                <<  85   virtual G4double ComputeStep(const G4ThreeVector &pGlobalPoint,
334     inline G4ThreeVector ComputeLocalAxis(cons <<  86                                const G4ThreeVector &pDirection,
335       // Return the local direction of the spe <<  87                                const G4double pCurrentProposedStepLength,
336       // system of the volume that was found b <<  88                                      G4double  &pNewSafety);
337       // The Local Coordinates of point in wor <<  89     // Calculate the distance to the next boundary intersected
338                                                <<  90     // along the specified NORMALISED vector direction and
339     inline EVolume VolumeType(const G4VPhysica <<  91     // from the specified point in the global coordinate
340       // Characterise `type' of volume - norma <<  92     // system. LocateGlobalPointAndSetup or LocateGlobalPointWithinVolume 
341                                                <<  93     // must have been called with the same global point prior to this call.
342     inline EVolume CharacteriseDaughters(const <<  94     // The isotropic distance to the nearest boundary is also
343       // Characterise daughter of logical volu <<  95     // calculated (usually an underestimate). The current
344                                                <<  96     // proposed Step length is used to avoid intersection
345     inline G4int GetDaughtersRegularStructureI <<  97     // calculations: if it can be determined that the nearest
346       // Get regular structure ID of first dau <<  98     // boundary is >pCurrentProposedStepLength away, kInfinity
347                                                <<  99     // is returned together with the computed isotropic safety
348     virtual void SetupHierarchy();             << 100     // distance. Geometry must be closed.
349       // Renavigate & reset hierarchy describe << 101 
350       // o Reset volumes and recompute transfo << 102   virtual
351       // replicated/parameterised volumes.     << 103   G4VPhysicalVolume* ResetHierarchyAndLocate(const G4ThreeVector &point,
352                                                << 104                                              const G4ThreeVector &direction,
353     G4bool CheckOverlapsIterative(G4VPhysicalV << 105                                              const G4TouchableHistory &h);
354       // Utility method to trigger overlaps ch << 106 
355       // overlaps ordered by relevance. Used i << 107     // Resets the geometrical hierarchy and search for the volumes deepest
356       // with zero step are detected.          << 108     // in the hierarchy containing the point in the global coordinate space.
357                                                << 109     // The direction is used to check if a volume is entered.
358   private:                                     << 110     // The search begin is the geometrical hierarchy at the location of the
359                                                << 111     // last located point, or the endpoint of the previous Step if
360     void ComputeStepLog(const G4ThreeVector& p << 112     // SetGeometricallyLimitedStep() has been called immediately before.
361                               G4double moveLen << 113     // 
362       // Log and checks for steps larger than  << 114     // Important Note: In order to call this the geometry MUST be closed.
363                                                << 
364   protected:                                   << 
365                                                << 
366     G4double kCarTolerance, fMinStep, fSqTol;  << 
367       // Cached tolerances.                    << 
368                                                << 
369     //                                         << 
370     // BEGIN State information                 << 
371     //                                         << 
372                                                << 
373     G4NavigationHistory fHistory;              << 
374       // Transformation and history of the cur << 
375       // through the geometrical hierarchy.    << 
376                                                << 
377     G4ThreeVector fStepEndPoint;               << 
378       // Endpoint of last ComputeStep          << 
379       // can be used for optimisation (e.g. wh << 
380     G4ThreeVector fLastStepEndPointLocal;      << 
381       // Position of the end-point of the last << 
382       // in last Local coordinates.            << 
383                                                << 
384     G4int fVerbose = 0;                        << 
385       // Verbose(ness) level  [if > 0, printou << 
386                                                << 
387     G4bool fEnteredDaughter;                   << 
388       // A memory of whether in this Step a da << 
389       // (set in Compute & Locate).            << 
390       // After Compute: it expects to enter a  << 
391       // After Locate:  it has entered a daugh << 
392                                                << 
393     G4bool fExitedMother;                      << 
394       // A similar memory whether the Step exi << 
395       // completely, not entering daughter.    << 
396                                                << 
397     G4bool fWasLimitedByGeometry = false;      << 
398       // Set true if last Step was limited by  << 
399                                                << 
400   private:                                     << 
401                                                << 
402     G4ThreeVector fLastLocatedPointLocal;      << 
403       // Position of the last located point re << 
404       //  This is coupled with the bool member << 
405                                                << 
406     G4ThreeVector fExitNormal;                 << 
407       // Leaving volume normal, in the volume  << 
408       // volume's coordinate system.           << 
409       // This is closely coupled with fValidEx << 
410       // we have a (valid) normal for volume w << 
411                                                << 
412     G4ThreeVector fGrandMotherExitNormal;      << 
413       // Leaving volume normal, in its own coo << 
414     G4ThreeVector fExitNormalGlobalFrame;      << 
415       // Leaving volume normal, in the global  << 
416                                                << 
417     G4ThreeVector fPreviousSftOrigin;          << 
418     G4double fPreviousSafety;                  << 
419       // Memory of last safety origin & value. << 
420       // that origin of current Step is in the << 
421       // last relocation.                      << 
422                                                << 
423     G4VPhysicalVolume* fLastMotherPhys = nullp << 
424       // Memory of the mother volume during pr << 
425       // Intended use: inform user in case of  << 
426                                                << 
427     G4VPhysicalVolume* fBlockedPhysicalVolume; << 
428     G4int fBlockedReplicaNo;                   << 
429       // Identifies the volume and copy / repl << 
430       // (after exiting -- because the exit di << 
431       // or a candidate for entry (after compu << 
432                                                << 
433     G4int fNumberZeroSteps;                    << 
434       // Count zero steps, as one or two can o << 
435       // a boundary or at an edge common betwe << 
436       // are likely a problem in the geometry  << 
437       // Number of preceding moves that were Z << 
438     G4int fActionThreshold_NoZeroSteps = 10;   << 
439       // After this many failed/zero steps, ac << 
440     G4int fAbandonThreshold_NoZeroSteps = 25;  << 
441       // After this many failed/zero steps, ab << 
442                                                << 
443     G4bool fActive = false;                    << 
444       // States if the navigator is activated  << 
445                                                << 
446     G4bool fLastTriedStepComputation = false;  << 
447       // Whether ComputeStep() was called sinc << 
448       // Uses: distinguish parts of state whic << 
449       // to ComputeStep() or one of the Locate << 
450       // calls to compute-step (illegal).      << 
451                                                << 
452     G4bool fEntering, fExiting;                << 
453       // Entering/Exiting volumes blocking/set << 
454       // o If exiting, volume ptr & replica nu << 
455       //   used for blocking on redescent of g << 
456       // o If entering, volume ptr & replica n << 
457       //   used by Locate..()) of volume for ' << 
458                                                << 
459     G4bool fValidExitNormal;                   << 
460       // Set true if have leaving volume norma << 
461     G4bool fLastStepWasZero;                   << 
462       // Whether the last ComputeStep moved Ze << 
463     G4bool fLocatedOnEdge;                     << 
464       // Whether the Navigator has detected an << 
465     G4bool fLocatedOutsideWorld;               << 
466       // Whether the last call to Locate metho << 
467                                                << 
468     G4bool  fChangedGrandMotherRefFrame;       << 
469       // Whether frame is changed.             << 
470     G4bool  fCalculatedExitNormal;             << 
471       // Has it been computed since the last c << 
472       // Covers both Global and GrandMother.   << 
473                                                << 
474     // END State information                   << 
475     //                                         << 
476                                                   115 
477     // Optional State information (created/use << 116   G4VPhysicalVolume* LocateGlobalPointAndSetup(const G4ThreeVector& point,
                                                   >> 117                                              const G4ThreeVector* direction=0,
                                                   >> 118                                              const G4bool pRelativeSearch=true,
                                                   >> 119                                              const G4bool ignoreDirection=true);
                                                   >> 120     // Search the geometrical hierarchy for the volumes deepest in the hierarchy
                                                   >> 121     // containing the point in the global coordinate space. Two main cases are:
                                                   >> 122     //  i) If pRelativeSearch=false it makes use of no previous/state
                                                   >> 123     //     information. Returns the physical volume containing the point, 
                                                   >> 124     //     with all previous mothers correctly set up.
                                                   >> 125     // ii) If pRelativeSearch is set to true, the search begin is the
                                                   >> 126     //     geometrical hierarchy at the location of the last located point,
                                                   >> 127     //     or the endpoint of the previous Step if SetGeometricallyLimitedStep()
                                                   >> 128     //     has been called immediately before.
                                                   >> 129     // The direction is used (to check if a volume is entered) if either
                                                   >> 130     //   - the argument ignoreDirection is false, or
                                                   >> 131     //   - the Navigator has determined that it is on an edge shared by two or
                                                   >> 132     //     more volumes.  (This is state information.)
478     //                                            133     // 
479                                                << 134     // Important Note: In order to call this the geometry MUST be closed.
480     // Save key state information (NOT the nav << 
481     //                                         << 
482     struct G4SaveNavigatorState                << 
483     {                                          << 
484        G4ThreeVector sExitNormal;              << 
485        G4bool sValidExitNormal;                << 
486        G4bool sEntering, sExiting;             << 
487        G4VPhysicalVolume* spBlockedPhysicalVol << 
488        G4int sBlockedReplicaNo;                << 
489        G4int sLastStepWasZero;                 << 
490        G4bool sWasLimitedByGeometry;           << 
491                                                << 
492        //  Potentially relevant                << 
493        //                                      << 
494        G4bool sLocatedOutsideWorld;            << 
495        G4ThreeVector sLastLocatedPointLocal;   << 
496        G4bool sEnteredDaughter, sExitedMother; << 
497        G4ThreeVector sPreviousSftOrigin;       << 
498        G4double sPreviousSafety;               << 
499     } fSaveState;                              << 
500                                                << 
501     // BEGIN -- Tracking Invariants            << 
502     // ======================================= << 
503                                                << 
504     G4VPhysicalVolume* fTopPhysical = nullptr; << 
505       // A link to the topmost physical volume << 
506       // Must be positioned at the origin and  << 
507                                                << 
508     // Helpers/Utility classes                 << 
509     //                                         << 
510     G4NormalNavigation fnormalNav;             << 
511     G4VoxelNavigation* fpvoxelNav;             << 
512     G4ParameterisedNavigation fparamNav;       << 
513     G4ReplicaNavigation freplicaNav;           << 
514     G4RegularNavigation fregularNav;           << 
515     G4VExternalNavigation* fpExternalNav = nul << 
516     G4VoxelSafety* fpVoxelSafety;              << 
517     G4SafetyCalculator* fpSafetyCalculator = n << 
518                                                << 
519     // Utility information                     << 
520     //                                         << 
521     G4bool fCheck = false;                     << 
522       // Check-mode flag  [if true, more stric << 
523     G4bool fPushed = false, fWarnPush = true;  << 
524       // Push flags  [if true, means a stuck p << 
525                                                   135 
526     // End -- Tracking Invariants              << 136   virtual void LocateGlobalPointWithinVolume(const G4ThreeVector& position);
                                                   >> 137     // Notify the Navigator that a track has moved to the new Global point
                                                   >> 138     // 'position', that is known to be within the current safety.
                                                   >> 139     // No check is performed to ensure that it is within  the volume. 
                                                   >> 140     // This method can be called instead of LocateGlobalPointAndSetup ONLY if
                                                   >> 141     // the caller is certain that the new global point (position) is inside the
                                                   >> 142     // same volume as the previous position.  Usually this can be guaranteed
                                                   >> 143     // only if the point is within safety.
                                                   >> 144 
                                                   >> 145   virtual void LocateGlobalPointAndUpdateTouchableHandle(
                                                   >> 146                 const G4ThreeVector&       position,
                                                   >> 147                 const G4ThreeVector&       direction,
                                                   >> 148                       G4TouchableHandle&   oldTouchableToUpdate,
                                                   >> 149                 const G4bool               RelativeSearch = true);
                                                   >> 150     // First, search the geometrical hierarchy like the above method
                                                   >> 151     // LocateGlobalPointAndSetup(). Then use the volume found and its
                                                   >> 152     // navigation history to update the touchable.
                                                   >> 153 
                                                   >> 154   inline void LocateGlobalPointAndUpdateTouchable(
                                                   >> 155                 const G4ThreeVector&       position,
                                                   >> 156                 const G4ThreeVector&       direction,
                                                   >> 157                       G4VTouchable*        touchableToUpdate,
                                                   >> 158                 const G4bool               RelativeSearch = true);
                                                   >> 159     // First, search the geometrical hierarchy like the above method
                                                   >> 160     // LocateGlobalPointAndSetup(). Then use the volume found and its
                                                   >> 161     // navigation history to update the touchable.
                                                   >> 162 
                                                   >> 163   inline void LocateGlobalPointAndUpdateTouchable(
                                                   >> 164                 const G4ThreeVector&       position,
                                                   >> 165                       G4VTouchable*        touchableToUpdate,
                                                   >> 166                 const G4bool               RelativeSearch = true);
                                                   >> 167     // Old version (missing direction).
                                                   >> 168     // Not recommended replace with newer version above.
                                                   >> 169 
                                                   >> 170   inline void SetGeometricallyLimitedStep();
                                                   >> 171     // Inform the navigator that the previous Step calculated
                                                   >> 172     // by the geometry was taken in its entirety.
                                                   >> 173 
                                                   >> 174   virtual G4double ComputeSafety(const G4ThreeVector &globalpoint,
                                                   >> 175                                  const G4double pProposedMaxLength = DBL_MAX);
                                                   >> 176     // Calculate the isotropic distance to the nearest boundary from the
                                                   >> 177     // specified point in the global coordinate system. 
                                                   >> 178     // The globalpoint utilised must be within the current volume.
                                                   >> 179     // The value returned is usually an underestimate.  
                                                   >> 180     // The proposed maximum length is used to avoid volume safety
                                                   >> 181     // calculations.  The geometry must be closed.
                                                   >> 182 
                                                   >> 183   inline G4VPhysicalVolume* GetWorldVolume() const;
                                                   >> 184     // Return the current  world (`topmost') volume.
                                                   >> 185 
                                                   >> 186   inline void SetWorldVolume(G4VPhysicalVolume* pWorld);
                                                   >> 187     // Set the world (`topmost') volume. This must be positioned at
                                                   >> 188     // origin (0,0,0) and unrotated.
                                                   >> 189 
                                                   >> 190   inline G4GRSVolume* CreateGRSVolume() const;
                                                   >> 191   inline G4GRSSolid* CreateGRSSolid() const; 
                                                   >> 192   inline G4TouchableHistory* CreateTouchableHistory() const;
                                                   >> 193     // `Touchable' creation methods: caller has deletion responsibility.
                                                   >> 194 
                                                   >> 195   virtual G4TouchableHistoryHandle CreateTouchableHistoryHandle() const;
                                                   >> 196     // Returns a reference counted handle to a touchable history.
                                                   >> 197 
                                                   >> 198   virtual G4ThreeVector GetLocalExitNormal(G4bool* valid);
                                                   >> 199     // Returns Exit Surface Normal and validity too.
                                                   >> 200     // It can only be called if the Navigator's last Step has crossed a
                                                   >> 201     // volume geometrical boundary.
                                                   >> 202     // It returns the Normal to the surface pointing out of the volume that
                                                   >> 203     // was left behind and/or into the volume that was entered.
                                                   >> 204     // (The normal is in the coordinate system of the final volume.)
                                                   >> 205     // This function takes full care about how to calculate this normal,
                                                   >> 206     // but if the surfaces are not convex it will return valid=false.
                                                   >> 207 
                                                   >> 208   inline G4int GetVerboseLevel() const;
                                                   >> 209   inline void  SetVerboseLevel(G4int level);
                                                   >> 210     // Get/Set Verbose(ness) level.
                                                   >> 211     // [if level>0 && G4VERBOSE, printout can occur]
                                                   >> 212 
                                                   >> 213   inline G4bool IsActive() const;
                                                   >> 214     // Verify if the navigator is active.
                                                   >> 215   inline void  Activate(G4bool flag);
                                                   >> 216     // Activate/inactivate the navigator.
                                                   >> 217 
                                                   >> 218   inline void  CheckMode(G4bool mode);
                                                   >> 219     // Run navigation in "check-mode", therefore using additional
                                                   >> 220     // verifications and more strict correctness conditions.
                                                   >> 221     // Is effective only with G4VERBOSE set.
                                                   >> 222 
                                                   >> 223   void PrintState();      
                                                   >> 224     // Print the internal state of the Navigator (for debugging).
                                                   >> 225     // The level of detail is according to the verbosity.
                                                   >> 226 
                                                   >> 227   inline const G4AffineTransform& GetGlobalToLocalTransform() const;
                                                   >> 228   inline const G4AffineTransform  GetLocalToGlobalTransform() const;
                                                   >> 229     // Obtain the transformations Global/Local (and inverse).
                                                   >> 230     // Clients of these methods must copy the data if they need to keep it.
                                                   >> 231 
                                                   >> 232   inline void ResetStackAndState();
                                                   >> 233     // Reset stack and minimum or navigator state machine necessary for reset
                                                   >> 234     // as needed by LocalGlobalPointAndSetup.
                                                   >> 235     // [Does not perform clears, resizes, or reset fLastLocatedPointLocal]
                                                   >> 236 
                                                   >> 237   inline G4int SeverityOfZeroStepping( G4int* noZeroSteps ) const; 
                                                   >> 238     // Report on severity of error and number of zero steps,
                                                   >> 239     // in case Navigator is stuck and is returning zero steps.
                                                   >> 240     // Values: 1 (small problem),  5 (correcting), 
                                                   >> 241     //         9 (ready to abandon), 10 (abandoned)
                                                   >> 242 
                                                   >> 243  protected:  // with description
                                                   >> 244 
                                                   >> 245   inline G4ThreeVector GetCurrentLocalCoordinate() const;
                                                   >> 246     // Return the local coordinate of the point in the reference system
                                                   >> 247     // of its containing volume that was found by LocalGlobalPointAndSetup.
                                                   >> 248     // The local coordinate of the last located track.
                                                   >> 249 
                                                   >> 250   inline G4ThreeVector ComputeLocalPoint(const G4ThreeVector& rGlobPoint) const;
                                                   >> 251     // Return position vector in local coordinate system, given a position
                                                   >> 252     // vector in world coordinate system.
                                                   >> 253 
                                                   >> 254   inline G4ThreeVector ComputeLocalAxis(const G4ThreeVector& pVec) const;
                                                   >> 255     // Return the local direction of the specified vector in the reference
                                                   >> 256     // system of the volume that was found by LocalGlobalPointAndSetup.
                                                   >> 257     // The Local Coordinates of point in world coordinate system.
                                                   >> 258 
                                                   >> 259   inline G4ThreeVector NetTranslation() const;
                                                   >> 260   inline G4RotationMatrix NetRotation() const;
                                                   >> 261     // Compute+return the local->global translation/rotation of current volume.
                                                   >> 262 
                                                   >> 263   inline G4bool EnteredDaughterVolume();
                                                   >> 264     // The purpose of this function is to inform the caller if the track is
                                                   >> 265     // entering a daughter volume while exiting from the current volume.
                                                   >> 266     // This method returns 
                                                   >> 267     // - True only in case 1) above, that is when the Step has caused
                                                   >> 268     //   the track to arrive at a boundary of a daughter.
                                                   >> 269     // - False in cases 2), 3) and 4), i.e. in all other cases.
                                                   >> 270     // This function is not guaranteed to work if SetGeometricallyLimitedStep()
                                                   >> 271     // was not called when it should have been called.
                                                   >> 272 
                                                   >> 273   virtual void ResetState();
                                                   >> 274     // Utility method to reset the navigator state machine.
                                                   >> 275 
                                                   >> 276   inline EVolume VolumeType(const G4VPhysicalVolume *pVol) const;
                                                   >> 277     // Characterise `type' of volume - normal/replicated/parameterised.
                                                   >> 278 
                                                   >> 279   inline EVolume CharacteriseDaughters(const G4LogicalVolume *pLog) const;
                                                   >> 280     // Characterise daughter of logical volume.
                                                   >> 281 
                                                   >> 282   virtual void SetupHierarchy();
                                                   >> 283     // Renavigate & reset hierarchy described by current history
                                                   >> 284     // o Reset volumes
                                                   >> 285     // o Recompute transforms and/or solids of replicated/parameterised
                                                   >> 286     //   volumes.
                                                   >> 287 
                                                   >> 288  private:
                                                   >> 289 
                                                   >> 290   //
                                                   >> 291   // BEGIN State information
                                                   >> 292   //
                                                   >> 293 
                                                   >> 294   G4bool fActive;
                                                   >> 295     // States if the navigator is activated or not.
                                                   >> 296 
                                                   >> 297   G4ThreeVector fLastLocatedPointLocal;
                                                   >> 298     // Position of the last located point relative to its containing volume.
                                                   >> 299 
                                                   >> 300   G4bool fWasLimitedByGeometry;
                                                   >> 301     // Set true if last Step was limited by geometry.
                                                   >> 302   G4bool fEntering,fExiting;
                                                   >> 303     // Entering/Exiting volumes blocking/setup
                                                   >> 304     // o If exiting
                                                   >> 305     //      volume ptr & replica number (set & used by Locate..())
                                                   >> 306     //      used for blocking on redescent of geometry
                                                   >> 307     // o If entering
                                                   >> 308     //      volume ptr & replica number (set by ComputeStep(),used by
                                                   >> 309     //      Locate..()) of volume for `automatic' entry
                                                   >> 310 
                                                   >> 311   G4VPhysicalVolume *fBlockedPhysicalVolume;
                                                   >> 312   G4int fBlockedReplicaNo;
                                                   >> 313 
                                                   >> 314   G4VPhysicalVolume *fCandidatePhysicalVolume;
                                                   >> 315   G4int fCandidateReplicaNo;
                                                   >> 316 
                                                   >> 317   G4bool fEnteredDaughter;    // A memory of whether in this Step a daughter
                                                   >> 318                               //  volume is entered (set in Compute & Locate)
                                                   >> 319                               //  After Compute: it expects to enter a daughter
                                                   >> 320                               //  After Locate:  it has entered a daughter
                                                   >> 321   G4bool fExitedMother;       // A similar memory whether the Step exited 
                                                   >> 322                               //  current "mother" volume completely, 
                                                   >> 323                               //  not entering daughter.
                                                   >> 324   
                                                   >> 325   G4bool fValidExitNormal;    // Set true if have leaving volume normal
                                                   >> 326   G4ThreeVector fExitNormal;  // Leaving volume normal, in the
                                                   >> 327                               // volume containing the exited
                                                   >> 328                               // volume's coordinate system
                                                   >> 329   G4ThreeVector fGrandMotherExitNormal;  // Leaving volume normal, in its 
                                                   >> 330                                          // own coordinate system
                                                   >> 331   G4NavigationHistory fHistory;
                                                   >> 332     // Transformation & `path' history of current path
                                                   >> 333     // through geomtrical hierarchy
                                                   >> 334 
                                                   >> 335   // Count zero steps - as one or two can occur due to changing momentum at
                                                   >> 336   //                    a boundary or at an edge common between volumes
                                                   >> 337   //                  - several are likely a problem in the geometry
                                                   >> 338   //                    description or in the navigation
                                                   >> 339   //
                                                   >> 340   G4bool fLastStepWasZero;
                                                   >> 341     // Whether the last ComputeStep moved Zero. Used to check for edges.
                                                   >> 342 
                                                   >> 343   G4bool fLocatedOnEdge;       
                                                   >> 344     // Whether the Navigator has detected an edge
                                                   >> 345   G4int fNumberZeroSteps;
                                                   >> 346     // Number of preceding moves that were Zero. Reset to 0 after finite step
                                                   >> 347   G4int fActionThreshold_NoZeroSteps;  
                                                   >> 348     // After this many failed/zero steps, act (push etc) 
                                                   >> 349   G4int fAbandonThreshold_NoZeroSteps; 
                                                   >> 350     // After this many failed/zero steps, abandon track
                                                   >> 351 
                                                   >> 352   G4ThreeVector  fPreviousSftOrigin;
                                                   >> 353   G4double       fPreviousSafety; 
                                                   >> 354     // Memory of last safety origin & value. Used in ComputeStep to ensure
                                                   >> 355     // that origin of current Step is in the same volume as the point of the
                                                   >> 356     // last relocation
                                                   >> 357 
                                                   >> 358   //
                                                   >> 359   // END State information
                                                   >> 360   //
                                                   >> 361 
                                                   >> 362   //
                                                   >> 363   // BEGIN Tracking Invariants
                                                   >> 364   //
                                                   >> 365 
                                                   >> 366   G4VPhysicalVolume  *fTopPhysical;
                                                   >> 367     // A link to the topmost physical volume in the detector.
                                                   >> 368     // Must be positioned at the origin and unrotated.
                                                   >> 369 
                                                   >> 370   //
                                                   >> 371   // END Tracking Invariants
                                                   >> 372   //
                                                   >> 373 
                                                   >> 374   //
                                                   >> 375   // BEGIN Utility information
                                                   >> 376   //
                                                   >> 377 
                                                   >> 378   G4bool fCheck;
                                                   >> 379     // Check-mode flag  [if true, more strict checks are performed].
                                                   >> 380   G4bool fPushed;
                                                   >> 381     // Push flag  [if true, means a stuck particle has been pushed].
                                                   >> 382   G4int  fVerbose;
                                                   >> 383     // Verbose(ness) level  [if > 0, printout can occur].
                                                   >> 384 
                                                   >> 385   //
                                                   >> 386   // END Utility Invariants
                                                   >> 387   //
                                                   >> 388 
                                                   >> 389   // 
                                                   >> 390   // Helpers/Utility classes
                                                   >> 391   //
                                                   >> 392   G4NormalNavigation  fnormalNav;
                                                   >> 393   G4VoxelNavigation fvoxelNav;
                                                   >> 394   G4ParameterisedNavigation fparamNav;
                                                   >> 395   G4ReplicaNavigation freplicaNav;
527 };                                                396 };
528                                                   397 
529 #include "G4Navigator.icc"                        398 #include "G4Navigator.icc"
530                                                   399 
531 #endif                                            400 #endif
532                                                   401 
533                                                   402 
534 // NOTES:                                         403 // NOTES:
535 //                                                404 //
536 // The following methods provide detailed info    405 // The following methods provide detailed information when a Step has
537 // arrived at a geometrical boundary.  They di    406 // arrived at a geometrical boundary.  They distinguish between the different
538 // causes that can result in the track leaving    407 // causes that can result in the track leaving its current volume.
539 //                                                408 //
540 // Four cases are possible:                       409 // Four cases are possible:
541 //                                                410 //
542 // 1) The particle has reached a boundary of a    411 // 1) The particle has reached a boundary of a daughter of the current volume:
543 //     (this could cause the relocation to ent    412 //     (this could cause the relocation to enter the daughter itself
544 //     or a potential granddaughter or further    413 //     or a potential granddaughter or further descendant)
545 //                                                414 //     
546 // 2) The particle has reached a boundary of t    415 // 2) The particle has reached a boundary of the current
547 //     volume, exiting into a mother (regardle    416 //     volume, exiting into a mother (regardless the level
548 //     at which it is located in the tree):       417 //     at which it is located in the tree):
549 //                                                418 //
550 // 3) The particle has reached a boundary of t    419 // 3) The particle has reached a boundary of the current
551 //     volume, exiting into a volume which is     420 //     volume, exiting into a volume which is not in its
552 //     parental hierarchy:                        421 //     parental hierarchy:
553 //                                                422 //
554 // 4) The particle is not on a boundary betwee    423 // 4) The particle is not on a boundary between volumes:
555 //     the function returns an exception, and     424 //     the function returns an exception, and the caller is
556 //     reccomended to compare the G4touchables    425 //     reccomended to compare the G4touchables associated
557 //     to the preStepPoint and postStepPoint t    426 //     to the preStepPoint and postStepPoint to handle this case.
558 //                                                427 //
559 //   G4bool        EnteredDaughterVolume()        428 //   G4bool        EnteredDaughterVolume()
560 //   G4bool        IsExitNormalValid()            429 //   G4bool        IsExitNormalValid()
561 //   G4ThreeVector GetLocalExitNormal()           430 //   G4ThreeVector GetLocalExitNormal()
562 //                                                431 //
563 // The expected usefulness of these methods is    432 // The expected usefulness of these methods is to allow the caller to
564 // determine how to compute the surface normal    433 // determine how to compute the surface normal at the volume boundary. The two
565 // possibilities are to obtain the normal from    434 // possibilities are to obtain the normal from:
566 //                                                435 //
567 //   i) the solid associated with the volume o    436 //   i) the solid associated with the volume of the initial point of the Step.
568 //      This is valid for cases 2 and 3.          437 //      This is valid for cases 2 and 3.  
569 //      (Note that the initial point is genera    438 //      (Note that the initial point is generally the PreStepPoint of a Step).
570 //   or                                           439 //   or
571 //                                                440 // 
572 //  ii) the solid of the final point, ie of th    441 //  ii) the solid of the final point, ie of the volume after the relocation.
573 //      This is valid for case 1.                 442 //      This is valid for case 1.
574 //      (Note that the final point is generall    443 //      (Note that the final point is generally the PreStepPoint of a Step).
575 //                                                444 //
576 // This way the caller can always get a valid     445 // This way the caller can always get a valid normal, pointing outside
577 // the solid for which it is computed, that ca    446 // the solid for which it is computed, that can be used at his own
578 // discretion.                                    447 // discretion.
579                                                   448