Ignore:
Timestamp:
Dec 22, 2010, 3:52:27 PM (14 years ago)
Author:
garnier
Message:

geant4 tag 9.4

Location:
trunk/source/geometry/navigation
Files:
80 edited

Legend:

Unmodified
Added
Removed

  • trunk/source/geometry/navigation/GNUmakefile

    r831 r1347  
    1 # $Id: GNUmakefile,v 1.5 2007/11/23 13:30:47 gcosmo Exp $
     1# $Id: GNUmakefile,v 1.7 2010/10/27 07:34:32 gcosmo Exp $
    22# --------------------------------------------------------------------
    33# GNUmakefile for geometry/volumes library.  Gabriele Cosmo, 16/11/96.

  • trunk/source/geometry/navigation/History

    r1315 r1347  
    1 $Id: History,v 1.139 2010/03/08 13:57:48 gcosmo Exp $
     1$Id: History,v 1.152 2010/12/15 13:47:10 gcosmo Exp $
    22-------------------------------------------------------------------
    33
    … …  
    1717     * Reverse chronological order (last date on top), please *
    1818     ----------------------------------------------------------
     19
     20December 15th, 2010 - G.Cosmo (geomnav-V09-03-10)
     21-----------------------------
     22- Added inline method for creation of a touchable-history given a navigation
     23  history as argument. Required for clients like G4ScoreSplittingProcess, to
     24  avoid external symbols exporting on generation of DLLs.
     25
     26November 19th, 2010 - G.Cosmo (geomnav-V09-03-09)
     27-----------------------------
     28- Removed unused variable in G4RegularNavigation.
     29
     30November 15th, 2010 - G.Cosmo (geomnav-V09-03-08)
     31-----------------------------
     32- Restored trials for zero steps to 10 in G4Navigator, as originally.
     33
     34November 12th, 2010 - G.Cosmo (geomnav-V09-03-07)
     35-----------------------------
     36- Cleared compilation warnings for unused parameters; temporarily commented out.
     37
     38November 11th, 2010 - G.Cosmo (geomnav-V09-03-06)
     39-----------------------------
     40- Set trials for zero steps to 5 before activating push in G4Navigator;
     41  increased unit value to 100 times kCarTolerance to make push more effective.
     42
     43November 10th, 2010 - G.Cosmo (geomnav-V09-03-05)
     44-----------------------------
     45- Reduced trials for zero steps from 10 to 3 for activating tolerance push
     46  in G4Navigator.
     47- Added possibility to switch off push notifications in G4Navigator; also
     48  added related UI command.
     49
     50November 9th, 2010 - P.Arce
     51---------------------------
     52- Added new class G4PartialPhantomParameterisation allowing for envelopes
     53  of different types other than box for regular geometries, so that relaxing
     54  the restriction for voxels to completely fill the envelope container.
     55  Adapted G4PhantomParameterisation, G4RegularNavigation and G4Navigator
     56  accordingly.
     57
     58November 4th, 2010 - G.Cosmo
     59----------------------------
     60- Added new class G4NavigationLogger for "check-mode" verbosity. Reorganised
     61  verbosity formatting for voxel and normal navigation.
     62
     63November 3rd, 2010 - J.Apostolakis
     64----------------------------------
     65- Added prototype class G4VoxelSafety for computation of exact safety.
     66
     67September 6th, 2010 - G.Cosmo (geomnav-V09-03-04)
     68-----------------------------
     69- Added missing initialization for 'fNewSafety' and 'fTrueMinStep' in
     70  G4MultiNavigator constructor.
     71
     72September 3rd, 2010 - G.Cosmo (geomnav-V09-03-03)
     73-----------------------------
     74- Fixed typo in signature of ComputeStepSkippingEqualMaterials() in
     75  G4RegularNavigation.
     76
     77August 19th, 2010 - T.Nikitina (geomnav-V09-03-02)
     78------------------------------
     79- Fix in G4GeomTestSegment::FindSomePoints(), to address problem report #980.
     80
     81July 12th, 2010 - G.Cosmo (geomnav-V09-03-01)
     82-------------------------
     83- Fixed array out of bound error in G4MultipleNavigator and G4PathFinder
     84  constructors (J.Apostolakis).
     85- Fixed cout precision restoring in G4BrentLocator, G4PropagatorInField,
     86  G4SimpleLocator, G4VIntersectionLocator and G4MultiLevelLocator.
     87- Removed unused private data members in G4MultiLevelLocator.
     88- Replaced use of DBL_MAX for distances with kInfinity in G4MultiNavigator
     89  and G4Navigator internals.
     90- Exchanged conditions for initialization of members in G4TransportationManager
     91  constructor.
     92- Added dummy initialisation of members in constructors in G4MultiNavigator,
     93  G4ParameterisedNavigation, G4PathFinder, G4PhantomParameterisation,
     94  G4RegularNavigation.
    1995
    2096March 8th, 2010 - G.Cosmo (geomnav-V09-03-00)

  • trunk/source/geometry/navigation/include/G4AuxiliaryNavServices.hh

    r1337 r1347  
    2626//
    2727// $Id: G4AuxiliaryNavServices.hh,v 1.4 2007/05/22 07:48:08 gcosmo Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     28// GEANT4 tag $Name: geant4-09-04-ref-00 $
    2929//
    3030//

  • trunk/source/geometry/navigation/include/G4AuxiliaryNavServices.icc

    r1337 r1347  
    2626//
    2727// $Id: G4AuxiliaryNavServices.icc,v 1.4 2007/05/22 07:48:08 gcosmo Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     28// GEANT4 tag $Name: geant4-09-04-ref-00 $
    2929//
    3030//

  • trunk/source/geometry/navigation/include/G4BrentLocator.hh

    r1337 r1347  
    2626//
    2727// $Id: G4BrentLocator.hh,v 1.2 2008/10/29 14:31:55 gcosmo Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     28// GEANT4 tag $Name: geant4-09-04-ref-00 $
    2929//
    3030// Class G4BrentLocator

  • trunk/source/geometry/navigation/include/G4DrawVoxels.hh

    r1337 r1347  
    2626//
    2727// $Id: G4DrawVoxels.hh,v 1.3 2006/06/29 18:35:36 gunter Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     28// GEANT4 tag $Name: geant4-09-04-ref-00 $
    2929//
    3030//

  • trunk/source/geometry/navigation/include/G4ErrorPropagationNavigator.hh

    r1337 r1347  
    2626//
    2727// $Id: G4ErrorPropagationNavigator.hh,v 1.2 2008/10/24 14:00:03 gcosmo Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     28// GEANT4 tag $Name: geant4-09-04-ref-00 $
    2929//
    3030//

  • trunk/source/geometry/navigation/include/G4GeomTestErrorList.hh

    r1337 r1347  
    2626//
    2727// $Id: G4GeomTestErrorList.hh,v 1.3 2006/06/29 18:35:38 gunter Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     28// GEANT4 tag $Name: geant4-09-04-ref-00 $
    2929//
    3030// --------------------------------------------------------------------

  • trunk/source/geometry/navigation/include/G4GeomTestLogger.hh

    r1337 r1347  
    2626//
    2727// $Id: G4GeomTestLogger.hh,v 1.3 2006/06/29 18:35:40 gunter Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     28// GEANT4 tag $Name: geant4-09-04-ref-00 $
    2929//
    3030// --------------------------------------------------------------------

  • trunk/source/geometry/navigation/include/G4GeomTestOverlapList.hh

    r1337 r1347  
    2626//
    2727// $Id: G4GeomTestOverlapList.hh,v 1.3 2006/06/29 18:35:43 gunter Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     28// GEANT4 tag $Name: geant4-09-04-ref-00 $
    2929//
    3030// --------------------------------------------------------------------

  • trunk/source/geometry/navigation/include/G4GeomTestOvershootList.hh

    r1337 r1347  
    2626//
    2727// $Id: G4GeomTestOvershootList.hh,v 1.3 2006/06/29 18:35:45 gunter Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     28// GEANT4 tag $Name: geant4-09-04-ref-00 $
    2929//
    3030// --------------------------------------------------------------------

  • trunk/source/geometry/navigation/include/G4GeomTestPoint.hh

    r1337 r1347  
    2626//
    2727// $Id: G4GeomTestPoint.hh,v 1.3 2006/06/29 18:35:48 gunter Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     28// GEANT4 tag $Name: geant4-09-04-ref-00 $
    2929//
    3030// --------------------------------------------------------------------

  • trunk/source/geometry/navigation/include/G4GeomTestSegment.hh

    r1337 r1347  
    2626//
    2727// $Id: G4GeomTestSegment.hh,v 1.4 2007/05/11 13:43:59 gcosmo Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     28// GEANT4 tag $Name: geant4-09-04-ref-00 $
    2929//
    3030// --------------------------------------------------------------------

  • trunk/source/geometry/navigation/include/G4GeomTestStreamLogger.hh

    r1337 r1347  
    2626//
    2727// $Id: G4GeomTestStreamLogger.hh,v 1.3 2006/06/29 18:35:52 gunter Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     28// GEANT4 tag $Name: geant4-09-04-ref-00 $
    2929//
    3030// --------------------------------------------------------------------

  • trunk/source/geometry/navigation/include/G4GeomTestVolPoint.hh

    r1337 r1347  
    2626//
    2727// $Id: G4GeomTestVolPoint.hh,v 1.3 2006/06/29 18:35:55 gunter Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     28// GEANT4 tag $Name: geant4-09-04-ref-00 $
    2929//
    3030// --------------------------------------------------------------------

  • trunk/source/geometry/navigation/include/G4GeomTestVolume.hh

    r1337 r1347  
    2626//
    2727// $Id: G4GeomTestVolume.hh,v 1.3 2006/06/29 18:35:57 gunter Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     28// GEANT4 tag $Name: geant4-09-04-ref-00 $
    2929//
    3030// --------------------------------------------------------------------

  • trunk/source/geometry/navigation/include/G4GeometryMessenger.hh

    r1337 r1347  
    2525//
    2626//
    27 // $Id: G4GeometryMessenger.hh,v 1.4 2006/06/29 18:35:59 gunter Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     27// $Id: G4GeometryMessenger.hh,v 1.5 2010/11/10 14:06:40 gcosmo Exp $
     28// GEANT4 tag $Name: geant4-09-04-ref-00 $
    2929//
    3030// --------------------------------------------------------------------
    … …  
    7878    void SetVerbosity(G4String newValue);
    7979    void SetCheckMode(G4String newValue);
     80    void SetPushFlag(G4String newValue);
    8081    void LineTest();
    8182    void RecursiveLineTest();
    … …  
    8889    G4UIcmdWith3VectorAndUnit *posCmd, *dirCmd;
    8990    G4UIcmdWith3Vector        *grzCmd, *cyzCmd;
    90     G4UIcmdWithABool          *chkCmd, *linCmd, *grdCmd, *cylCmd, *runCmd;
     91    G4UIcmdWithABool          *chkCmd, *pchkCmd, *linCmd,
     92                              *grdCmd, *cylCmd, *runCmd;
    9193    G4UIcmdWithoutParameter   *recCmd, *resCmd;
    9294    G4UIcmdWithADoubleAndUnit *tolCmd;

  • trunk/source/geometry/navigation/include/G4MultiLevelLocator.hh

    r1337 r1347  
    2525//
    2626//
    27 // $Id: G4MultiLevelLocator.hh,v 1.2 2008/10/29 14:31:55 gcosmo Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     27// $Id: G4MultiLevelLocator.hh,v 1.3 2010/07/13 15:59:42 gcosmo Exp $
     28// GEANT4 tag $Name: geant4-09-04-ref-00 $
    2929//
    3030//
    … …  
    7878     G4FieldTrack* ptrInterMedFT[max_depth+1];
    7979       // Used to store intermediate tracks values in case of too slow progress
    80 
    81      G4int maxNumberOfStepsForIntersection;
    82      G4int maxNumberOfCallsToReIntegration;
    83      G4int maxNumberOfCallsToReIntegration_depth;
    84        //  Counters for Statistics about Location and ReIntegrations
    8580};
    8681

  • trunk/source/geometry/navigation/include/G4MultiNavigator.hh

    r1337 r1347  
    2626//
    2727// $Id: G4MultiNavigator.hh,v 1.5 2008/10/24 14:00:03 gcosmo Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     28// GEANT4 tag $Name: geant4-09-04-ref-00 $
    2929//
    3030//

  • trunk/source/geometry/navigation/include/G4Navigator.hh

    r1337 r1347  
    2525//
    2626//
    27 // $Id: G4Navigator.hh,v 1.29 2009/11/30 11:59:52 japost Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     27// $Id: G4Navigator.hh,v 1.34 2010/12/15 13:46:39 gcosmo Exp $
     28// GEANT4 tag $Name: geant4-09-04-ref-00 $
    2929//
    3030//
    … …  
    200200  inline G4GRSSolid* CreateGRSSolid() const;
    201201  inline G4TouchableHistory* CreateTouchableHistory() const;
     202  inline G4TouchableHistory* CreateTouchableHistory(const G4NavigationHistory*) const;
    202203    // `Touchable' creation methods: caller has deletion responsibility.
    203204
    … …  
    241242    // verifications and more strict correctness conditions.
    242243    // Is effective only with G4VERBOSE set.
    243   inline G4bool IsCheckModeActive() { return fCheck; }
     244  inline G4bool IsCheckModeActive() const;
     245  inline void   SetPushVerbosity(G4bool mode);
     246    // Set/unset verbosity for pushed tracks (default is true).
    244247
    245248  void PrintState() const;
    … …  
    263266    //         9 (ready to abandon), 10 (abandoned)
    264267
    265   // inline
    266268  void SetSavedState();
    267   // ( fValidExitNormal, fExitNormal, fExiting, fEntering,
    268   //   fBlockedPhysicalVolume, fBlockedReplicaNo, fLastStepWasZero);
    269   // inline
     269    // ( fValidExitNormal, fExitNormal, fExiting, fEntering,
     270    //   fBlockedPhysicalVolume, fBlockedReplicaNo, fLastStepWasZero);
    270271  void RestoreSavedState();
    271272    // Copy aspects of the state, to enable a non-state changing
    272273    //  call to ComputeStep
    273 
    274  public:  // with description
    275274
    276275  inline G4ThreeVector GetCurrentLocalCoordinate() const;
    … …  
    283282    // Compute+return the local->global translation/rotation of current volume.
    284283
     284  inline void EnableBestSafety( G4bool value= false );
     285    // Enable best-possible evaluation of isotropic safety
     286
    285287 protected:  // with description
     288
    286289  inline G4ThreeVector ComputeLocalPoint(const G4ThreeVector& rGlobPoint) const;
    287290    // Return position vector in local coordinate system, given a position
    … …  
    310313    // o Recompute transforms and/or solids of replicated/parameterised
    311314    //   volumes.
     315
     316 private:
     317
     318  void ComputeStepLog(const G4ThreeVector& pGlobalpoint,
     319                            G4double moveLenSq) const;
     320    // Log and checks for steps larger than the tolerance
    312321
    313322 protected:  // without description
    … …  
    434443  G4bool fCheck;
    435444    // Check-mode flag  [if true, more strict checks are performed].
    436   G4bool fPushed;
    437     // Push flag  [if true, means a stuck particle has been pushed].
     445  G4bool fPushed, fWarnPush;
     446    // Push flags  [if true, means a stuck particle has been pushed].
    438447
    439448  // Helpers/Utility classes

  • trunk/source/geometry/navigation/include/G4Navigator.icc

    r1337 r1347  
    2525//
    2626//
    27 // $Id: G4Navigator.icc,v 1.15 2007/10/18 14:18:36 gcosmo Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     27// $Id: G4Navigator.icc,v 1.18 2010/12/15 13:46:39 gcosmo Exp $
     28// GEANT4 tag $Name: geant4-09-04-ref-00 $
    2929//
    3030//
    … …  
    308308
    309309// ********************************************************************
     310// CreateTouchableHistory(history)
     311//
     312// `Touchable' creation method: caller has deletion responsibility
     313// ********************************************************************
     314//
     315inline
     316G4TouchableHistory*
     317G4Navigator::CreateTouchableHistory(const G4NavigationHistory* history) const
     318{
     319  return new G4TouchableHistory(*history);
     320}
     321
     322// ********************************************************************
    310323// LocateGlobalPointAndUpdateTouchableHandle
    311324// ********************************************************************
    … …  
    450463
    451464// ********************************************************************
     465// IsCheckModeActive
     466// ********************************************************************
     467//
     468inline
     469G4bool G4Navigator::IsCheckModeActive() const
     470{
     471  return fCheck;
     472}
     473
     474// ********************************************************************
     475// SetPushVerbosity
     476// ********************************************************************
     477//
     478inline
     479void G4Navigator::SetPushVerbosity(G4bool mode)
     480{
     481  fWarnPush = mode;
     482}
     483
     484// ********************************************************************
    452485// SeverityOfZeroStepping
    453486//
    … …  
    485518  return severity;
    486519}
     520
     521// ********************************************************************
     522// EnableBestSafety
     523// ********************************************************************
     524//
     525inline void G4Navigator::EnableBestSafety( G4bool value )
     526{
     527  fvoxelNav.EnableBestSafety( value );
     528}

  • trunk/source/geometry/navigation/include/G4NormalNavigation.hh

    r1337 r1347  
    2525//
    2626//
    27 // $Id: G4NormalNavigation.hh,v 1.4 2006/06/29 18:36:06 gunter Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     27// $Id: G4NormalNavigation.hh,v 1.6 2010/11/04 08:57:56 gcosmo Exp $
     28// GEANT4 tag $Name: geant4-09-04-ref-00 $
    2929//
    3030//
    … …  
    4242#define G4NORMALNAVIGATION_HH
    4343
     44#include <iomanip>
     45
    4446#include "G4NavigationHistory.hh"
     47#include "G4NavigationLogger.hh"
    4548#include "G4VPhysicalVolume.hh"
    4649#include "G4LogicalVolume.hh"
    … …  
    8992                            const G4double pMaxLength=DBL_MAX );
    9093
    91     inline G4int GetVerboseLevel();
     94    inline G4int GetVerboseLevel() const;
    9295    inline void  SetVerboseLevel(G4int level);
    9396      // Get/Set Verbose(ness) level.
    … …  
    102105
    103106    G4bool fCheck;
    104     G4int  fVerbose;
     107    G4NavigationLogger* fLogger;
    105108};
    106109

  • trunk/source/geometry/navigation/include/G4NormalNavigation.icc

    r1337 r1347  
    2525//
    2626//
    27 // $Id: G4NormalNavigation.icc,v 1.4 2006/06/29 18:36:08 gunter Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     27// $Id: G4NormalNavigation.icc,v 1.5 2010/11/04 08:57:56 gcosmo Exp $
     28// GEANT4 tag $Name: geant4-09-04-ref-00 $
    2929//
    3030//
    … …  
    9494}
    9595
     96// ********************************************************************
     97// GetVerboseLevel
     98// ********************************************************************
     99//
    96100inline
    97 G4int G4NormalNavigation::GetVerboseLevel()
     101G4int G4NormalNavigation::GetVerboseLevel() const
    98102{
    99   return fVerbose;
     103  return fLogger->GetVerboseLevel();
    100104}
    101105
     106// ********************************************************************
     107// SetVerboseLevel
     108// ********************************************************************
     109//
    102110inline
    103111void G4NormalNavigation::SetVerboseLevel(G4int level)
    104112{
    105   fVerbose = level;
     113  fLogger->SetVerboseLevel(level);
    106114}
    107115
     116// ********************************************************************
     117// CheckMode
     118// ********************************************************************
     119//
    108120inline
    109121void G4NormalNavigation::CheckMode(G4bool mode)

  • trunk/source/geometry/navigation/include/G4ParameterisedNavigation.hh

    r1337 r1347  
    2626//
    2727// $Id: G4ParameterisedNavigation.hh,v 1.6 2007/11/09 16:06:02 gcosmo Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     28// GEANT4 tag $Name: geant4-09-04-ref-00 $
    2929//
    3030//

  • trunk/source/geometry/navigation/include/G4ParameterisedNavigation.icc

    r1337 r1347  
    2626//
    2727// $Id: G4ParameterisedNavigation.icc,v 1.7 2007/11/09 16:06:02 gcosmo Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     28// GEANT4 tag $Name: geant4-09-04-ref-00 $
    2929//
    3030//

  • trunk/source/geometry/navigation/include/G4PathFinder.hh

    r1337 r1347  
    2424// ********************************************************************
    2525//
    26 // $Id: G4PathFinder.hh,v 1.34 2007/11/02 12:28:31 japost Exp $
    27 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     26// $Id: G4PathFinder.hh,v 1.35 2010/07/13 15:59:42 gcosmo Exp $
     27// GEANT4 tag $Name: geant4-09-04-ref-00 $
    2828//
    2929// class G4PathFinder
    … …  
    259259   // State for Step numbers
    260260   G4int         fLastStepNo, fCurrentStepNo;
    261    G4bool        fParticleIsLooping;
    262261
    263262   G4int         fVerboseLevel;            // For debuging purposes
    264 
    265    G4int         fMax_loop_count;
    266      // Limit for the number of sub-steps taken in one call to ComputeStep
    267263
    268264   G4TransportationManager* fpTransportManager; // Cache for frequent use

  • trunk/source/geometry/navigation/include/G4PhantomParameterisation.hh

    r1337 r1347  
    2525//
    2626//
    27 // $Id: G4PhantomParameterisation.hh,v 1.5 2009/05/19 18:27:03 arce Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     27// $Id: G4PhantomParameterisation.hh,v 1.6 2010/11/09 15:43:15 arce Exp $
     28// GEANT4 tag $Name: geant4-09-04-ref-00 $
    2929//
    3030//
    … …  
    117117      // voxels fill it completely.
    118118
    119     G4int GetReplicaNo( const G4ThreeVector& localPoint,
     119    virtual G4int GetReplicaNo( const G4ThreeVector& localPoint,
    120120                        const G4ThreeVector& localDir );
    121121      // Get the voxel number corresponding to the point in the container
    … …  
    167167      // Check that the copy number is within limits.
    168168
    169   private:
     169  protected:
    170170
    171171    G4double fVoxelHalfX,fVoxelHalfY,fVoxelHalfZ;

  • trunk/source/geometry/navigation/include/G4PhantomParameterisation.icc

    r1337 r1347  
    2626//
    2727// $Id: G4PhantomParameterisation.icc,v 1.1 2007/10/17 19:13:58 arce Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     28// GEANT4 tag $Name: geant4-09-04-ref-00 $
    2929//
    3030//--------------------------------------------------------------------

  • trunk/source/geometry/navigation/include/G4PropagatorInField.hh

    r1337 r1347  
    2626//
    2727// $Id: G4PropagatorInField.hh,v 1.19 2009/11/13 17:34:26 japost Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     28// GEANT4 tag $Name: geant4-09-04-ref-00 $
    2929//
    3030//

  • trunk/source/geometry/navigation/include/G4PropagatorInField.icc

    r1337 r1347  
    2626//
    2727// $Id: G4PropagatorInField.icc,v 1.16 2009/11/13 17:34:26 japost Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     28// GEANT4 tag $Name: geant4-09-04-ref-00 $
    2929//
    3030//

  • trunk/source/geometry/navigation/include/G4RegularNavigation.hh

    r1337 r1347  
    2525//
    2626//
    27 // $Id: G4RegularNavigation.hh,v 1.2 2007/10/18 14:18:36 gcosmo Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     27// $Id: G4RegularNavigation.hh,v 1.4 2010/09/03 16:29:43 gcosmo Exp $
     28// GEANT4 tag $Name: geant4-09-04-ref-00 $
    2929//
    3030//
    … …  
    8787 
    8888    G4double ComputeStepSkippingEqualMaterials(
    89                           const G4ThreeVector localPoint,
     89                                G4ThreeVector& localPoint,
    9090                          const G4ThreeVector& globalDirection,
    9191                          const G4double currentProposedStepLength,
    … …  
    116116    // Set and Get methods
    117117
    118     void SetVerboseLevel(G4int level) { fVerbose = level; }
    119     void CheckMode(G4bool mode) { fCheck = mode; }
     118    void SetVerboseLevel(G4int level) { fverbose = level; }
     119    void CheckMode(G4bool mode) { fcheck = mode; }
    120120    void SetNormalNavigation( G4NormalNavigation* fnormnav )
    121121      { fnormalNav = fnormnav; }
    … …  
    123123  private:
    124124
    125     G4int fVerbose;
    126     G4bool fCheck;
     125    G4int fverbose;
     126    G4bool fcheck;
    127127
    128128    G4NormalNavigation* fnormalNav;

  • trunk/source/geometry/navigation/include/G4RegularNavigationHelper.hh

    r1337 r1347  
    2626//
    2727// $Id: G4RegularNavigationHelper.hh,v 1.1 2009/01/27 09:31:29 gcosmo Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     28// GEANT4 tag $Name: geant4-09-04-ref-00 $
    2929//
    3030// --------------------------------------------------------------------

  • trunk/source/geometry/navigation/include/G4ReplicaNavigation.hh

    r1337 r1347  
    2626//
    2727// $Id: G4ReplicaNavigation.hh,v 1.6 2007/05/18 07:31:09 gcosmo Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     28// GEANT4 tag $Name: geant4-09-04-ref-00 $
    2929//
    3030//

  • trunk/source/geometry/navigation/include/G4ReplicaNavigation.icc

    r1337 r1347  
    2626//
    2727// $Id: G4ReplicaNavigation.icc,v 1.5 2006/06/29 18:36:22 gunter Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     28// GEANT4 tag $Name: geant4-09-04-ref-00 $
    2929//
    3030//

  • trunk/source/geometry/navigation/include/G4SafetyHelper.hh

    r1337 r1347  
    2626//
    2727// $Id: G4SafetyHelper.hh,v 1.7 2007/05/02 15:32:13 japost Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     28// GEANT4 tag $Name: geant4-09-04-ref-00 $
    2929//
    3030//

  • trunk/source/geometry/navigation/include/G4SimpleLocator.hh

    r1337 r1347  
    2626//
    2727// $Id: G4SimpleLocator.hh,v 1.2 2008/10/29 14:31:55 gcosmo Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     28// GEANT4 tag $Name: geant4-09-04-ref-00 $
    2929//
    3030//

  • trunk/source/geometry/navigation/include/G4TransportationManager.hh

    r1337 r1347  
    2626//
    2727// $Id: G4TransportationManager.hh,v 1.12 2007/04/20 15:28:37 gcosmo Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     28// GEANT4 tag $Name: geant4-09-04-ref-00 $
    2929//
    3030// class G4TransportationManager

  • trunk/source/geometry/navigation/include/G4TransportationManager.icc

    r1337 r1347  
    2626//
    2727// $Id: G4TransportationManager.icc,v 1.10 2007/04/20 15:28:37 gcosmo Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     28// GEANT4 tag $Name: geant4-09-04-ref-00 $
    2929// ------------------------------------------------------------
    3030//  GEANT 4  inlined function members implementation

  • trunk/source/geometry/navigation/include/G4VIntersectionLocator.hh

    r1337 r1347  
    2626//
    2727// $Id: G4VIntersectionLocator.hh,v 1.6 2009/11/30 11:39:15 japost Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     28// GEANT4 tag $Name: geant4-09-04-ref-00 $
    2929//
    3030//

  • trunk/source/geometry/navigation/include/G4VIntersectionLocator.icc

    r1337 r1347  
    2626//
    2727// $Id: G4VIntersectionLocator.icc,v 1.3 2008/11/14 18:26:35 gcosmo Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     28// GEANT4 tag $Name: geant4-09-04-ref-00 $
    2929//
    3030//

  • trunk/source/geometry/navigation/include/G4VoxelNavigation.hh

    r1337 r1347  
    2525//
    2626//
    27 // $Id: G4VoxelNavigation.hh,v 1.5 2007/05/11 13:43:59 gcosmo Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     27// $Id: G4VoxelNavigation.hh,v 1.8 2010/11/04 12:13:30 japost Exp $
     28// GEANT4 tag $Name: geant4-09-04-ref-00 $
    2929//
    3030//
    … …  
    4444#include "geomdefs.hh"
    4545#include "G4NavigationHistory.hh"
     46#include "G4NavigationLogger.hh"
    4647#include "G4AffineTransform.hh"
    4748#include "G4VPhysicalVolume.hh"
    … …  
    5152
    5253#include "G4BlockingList.hh"
     54
     55class G4VoxelSafety;
    5356
    5457// Required for inline implementation
    … …  
    98101
    99102    inline G4int GetVerboseLevel() const;
    100     inline void  SetVerboseLevel(G4int level);
     103    void  SetVerboseLevel(G4int level);
    101104      // Get/Set Verbose(ness) level.
    102105      // [if level>0 && G4VERBOSE, printout can occur]
    … …  
    107110      // Is effective only with G4VERBOSE set.
    108111
     112    inline void  EnableBestSafety( G4bool flag= false );
     113      // Enable best-possible evaluation of isotropic safety
     114
    109115  protected:
    110116
    … …  
    113119                            const G4ThreeVector& localDirection,
    114120                            const G4double currentStep );
     121
     122    G4SmartVoxelNode* VoxelLocateLight( G4SmartVoxelHeader* pHead,
     123                                        const G4ThreeVector& localPoint ) const;
     124
     125  private:  // Logging functions
     126
     127    void PreComputeStepLog  (const G4VPhysicalVolume* motherPhysical,
     128                                   G4double motherSafety,
     129                             const G4ThreeVector& localPoint);
     130    void AlongComputeStepLog(const G4VSolid* sampleSolid,
     131                             const G4ThreeVector& samplePoint,
     132                             const G4ThreeVector& sampleDirection,
     133                             const G4ThreeVector& localDirection,
     134                                   G4double sampleSafety,
     135                                   G4double sampleStep);
     136    void PostComputeStepLog (const G4VSolid* motherSolid,
     137                             const G4ThreeVector& localPoint,
     138                             const G4ThreeVector& localDirection,
     139                                   G4double motherStep,
     140                                   G4double motherSafety);
     141    void ComputeSafetyLog   (const G4VSolid* solid,
     142                             const G4ThreeVector& point,
     143                                   G4double safety,
     144                                   G4bool banner);
     145    inline void PrintDaughterLog (const G4VSolid* sampleSolid,
     146                                  const G4ThreeVector& samplePoint,
     147                                        G4double sampleSafety,
     148                                        G4double sampleStep);   
     149  protected:
    115150
    116151    G4BlockingList fBList;
    … …  
    147182    //
    148183
     184    G4VoxelSafety  *fpVoxelSafety;
     185    //  Helper object for Voxel Safety
     186
    149187    G4bool fCheck;
    150     G4int  fVerbose;
    151     G4double kCarTolerance;
     188    G4bool fBestSafety;
     189
     190    G4NavigationLogger* fLogger;
     191      // Verbosity logger
    152192};
    153193

  • trunk/source/geometry/navigation/include/G4VoxelNavigation.icc

    r1337 r1347  
    2525//
    2626//
    27 // $Id: G4VoxelNavigation.icc,v 1.4 2006/06/29 18:36:30 gunter Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     27// $Id: G4VoxelNavigation.icc,v 1.7 2010/11/04 17:38:17 japost Exp $
     28// GEANT4 tag $Name: geant4-09-04-ref-00 $
    2929//
    3030//
    … …  
    6767    }
    6868    else if ( targetNodeNo>=targetHeaderNoSlices )
    69          {
    70            targetNodeNo = targetHeaderNoSlices-1;
    71          }
     69    {
     70      targetNodeNo = targetHeaderNoSlices-1;
     71    }
    7272    // Stack info for stepping
    7373    //
    … …  
    169169G4int G4VoxelNavigation::GetVerboseLevel() const
    170170{
    171   return fVerbose;
    172 }
    173 
    174 // ********************************************************************
    175 // SetVerboseLevel
    176 // ********************************************************************
    177 //
    178 inline
    179 void  G4VoxelNavigation::SetVerboseLevel(G4int level)
    180 {
    181   fVerbose = level;
     171  return fLogger->GetVerboseLevel();
    182172}
    183173
    … …  
    191181  fCheck = mode;
    192182}
     183
     184// ********************************************************************
     185// EnableBestSafety
     186// ********************************************************************
     187//
     188inline
     189void  G4VoxelNavigation::EnableBestSafety(G4bool flag)
     190{
     191  fBestSafety = flag;
     192}

  • trunk/source/geometry/navigation/src/G4AuxiliaryNavServices.cc

    r1337 r1347  
    2525//
    2626// $Id: G4AuxiliaryNavServices.cc,v 1.3 2006/06/29 18:36:32 gunter Exp $
    27 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     27// GEANT4 tag $Name: geant4-09-04-ref-00 $
    2828//
    2929// --------------------------------------------------------------------

  • trunk/source/geometry/navigation/src/G4BrentLocator.cc

    r1337 r1347  
    2424// ********************************************************************
    2525//
    26 // $Id: G4BrentLocator.cc,v 1.8 2009/05/15 12:55:48 tnikitin Exp $
    27 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     26// $Id: G4BrentLocator.cc,v 1.9 2010/07/13 15:59:42 gcosmo Exp $
     27// GEANT4 tag $Name: geant4-09-04-ref-00 $
    2828//
    2929// Class G4BrentLocator implementation
    … …  
    142142  G4bool restoredFullEndpoint = false;
    143143
     144  G4int oldprc;  // cout, cerr precision
    144145  G4int substep_no = 0;
    145146   
    … …  
    505506                   << GetEpsilonStepFor() << G4endl;
    506507          }
    507           G4cerr.precision(20);
     508          oldprc = G4cerr.precision(20);
    508509          G4cerr << " Point A (Curve start)     is " << CurveStartPointVelocity
    509510                 << G4endl;
    … …  
    529530                 << GetEpsilonStepFor() <<" DeltaInters= "
    530531                 << GetDeltaIntersectionFor() << G4endl;
     532          G4cerr.precision( oldprc );
    531533
    532534          G4Exception("G4BrentLocator::EstimateIntersectionPoint()",
    … …  
    728730                 -1.0, NewSafety, substep_no);
    729731    G4cout << G4endl;
    730     G4cout.precision( 10 );
     732    oldprc = G4cout.precision( 10 );
    731733    G4double done_len = CurrentA_PointVelocity.GetCurveLength();
    732734    G4double full_len = CurveEndPointVelocity.GetCurveLength();
    … …  
    736738           << " out of " << full_len << " required." << G4endl;
    737739    G4cout << "        Remaining length = " << full_len - done_len << G4endl;
     740    G4cout.precision( oldprc );
    738741
    739742    G4Exception("G4BrentLocator::EstimateIntersectionPoint()",
    … …  
    743746  else if( substep_no >= warn_substeps )
    744747  { 
    745     G4int oldprc= G4cout.precision( 10 );
     748    oldprc= G4cout.precision( 10 );
    746749    G4cout << "WARNING - G4BrentLocator::EstimateIntersectionPoint()"
    747750           << G4endl

  • trunk/source/geometry/navigation/src/G4DrawVoxels.cc

    r1337 r1347  
    2626//
    2727// $Id: G4DrawVoxels.cc,v 1.4 2006/06/29 18:36:34 gunter Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     28// GEANT4 tag $Name: geant4-09-04-ref-00 $
    2929//
    3030//

  • trunk/source/geometry/navigation/src/G4ErrorPropagationNavigator.cc

    r1337 r1347  
    2626//
    2727// $Id: G4ErrorPropagationNavigator.cc,v 1.2 2008/10/24 14:00:03 gcosmo Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     28// GEANT4 tag $Name: geant4-09-04-ref-00 $
    2929//
    3030//

  • trunk/source/geometry/navigation/src/G4GeomTestErrorList.cc

    r1337 r1347  
    2626//
    2727// $Id: G4GeomTestErrorList.cc,v 1.3 2006/06/29 18:36:36 gunter Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     28// GEANT4 tag $Name: geant4-09-04-ref-00 $
    2929//
    3030// --------------------------------------------------------------------

  • trunk/source/geometry/navigation/src/G4GeomTestOverlapList.cc

    r1337 r1347  
    2626//
    2727// $Id: G4GeomTestOverlapList.cc,v 1.3 2006/06/29 18:36:39 gunter Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     28// GEANT4 tag $Name: geant4-09-04-ref-00 $
    2929//
    3030// --------------------------------------------------------------------

  • trunk/source/geometry/navigation/src/G4GeomTestOvershootList.cc

    r1337 r1347  
    2626//
    2727// $Id: G4GeomTestOvershootList.cc,v 1.3 2006/06/29 18:36:41 gunter Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     28// GEANT4 tag $Name: geant4-09-04-ref-00 $
    2929//
    3030// --------------------------------------------------------------------

  • trunk/source/geometry/navigation/src/G4GeomTestPoint.cc

    r1337 r1347  
    2626//
    2727// $Id: G4GeomTestPoint.cc,v 1.3 2006/06/29 18:36:44 gunter Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     28// GEANT4 tag $Name: geant4-09-04-ref-00 $
    2929//
    3030// --------------------------------------------------------------------

  • trunk/source/geometry/navigation/src/G4GeomTestSegment.cc

    r1337 r1347  
    2525//
    2626//
    27 // $Id: G4GeomTestSegment.cc,v 1.11 2007/11/16 09:39:14 gcosmo Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     27// $Id: G4GeomTestSegment.cc,v 1.13 2010/08/20 09:03:54 gcosmo Exp $
     28// GEANT4 tag $Name: geant4-09-04-ref-00 $
    2929//
    3030// --------------------------------------------------------------------
    … …  
    275275  G4bool entering;
    276276  G4double vSurfN;
    277   // G4cout<<"Entering Find Some Points vSearch="<<vSearch<<" p="<<p<<G4endl;
    278   //
     277 
    279278  // Look for nearest intersection point in the specified
    280279  // direction and return if there isn't one
    … …  
    283282  switch(solid->Inside(p)) {
    284283    case kInside:
    285        dist = solid->DistanceToOut(p,vSearch);
    286        // G4cout<<"Inside DistToOut="<<dist<<G4endl;
     284      dist = solid->DistanceToOut(p,vSearch);
    287285      if (dist >= kInfinity) {
    288286        logger->SolidProblem( solid,
    … …  
    290288        return;
    291289      }
    292      
    293290      s += sign*dist;
    294291      entering = false;
    … …  
    296293    case kOutside:
    297294      dist = solid->DistanceToIn(p,vSearch);
    298       //G4cout<<"Outside DistToIn="<<dist<<G4endl;
    299295      if (dist >= kInfinity) return;
    300      
    301296      s += sign*dist;
    302297      entering = true;
    303298      break;
    304299    case kSurface:
    305       vSurfN=vSearch.dot(solid->SurfaceNormal(p));
    306       if(std::abs(vSurfN)<kCarTolerance)vSurfN=0;
     300      vSurfN=v.dot(solid->SurfaceNormal(p));
     301      if(std::fabs(vSurfN)<kCarTolerance)vSurfN=0;
    307302      entering = (vSurfN < 0);
    308       //G4cout<<"Surface SurfN="<<solid->SurfaceNormal(p)<<" v.dotN="<<vSurfN<<" entering="<<entering<<G4endl;
    309303      break;
    310304    default:
    … …  
    361355      //
    362356      points.push_back( G4GeomTestPoint( p, s, entering==forward ) );
    363       //G4cout<<"Add point p"<<p<<" s="<<s<<" entering="<<entering<<G4endl;
     357     
    364358    }
    365359   
    … …  
    369363    if (entering) {
    370364      dist = solid->DistanceToOut(p,vSearch);
    371       //G4cout<<"if entering distToOut="<<dist<<G4endl;
    372365      if (dist >= kInfinity) {
    373366        logger->SolidProblem( solid,
    … …  
    389382        return;
    390383      }
    391 
    392        if(std::abs(dist)<=kCarTolerance){
    393           G4double push = 1E-6;
    394           s += sign*push;
    395           p = p0 + s*v;
    396           EInside inside = solid->Inside(p);
    397           if (inside == kOutside) {
    398           entering = false;
    399           break;
    400         }
    401       }
    402 
    403      
     384           
    404385      entering = false;
    405386    }
    406387    else {
    407388      dist = solid->DistanceToIn(p,vSearch);
    408       //G4cout<<"if exiting distToIn="<<dist<<G4endl;
    409389      if (dist >= kInfinity) return;
    410390     

  • trunk/source/geometry/navigation/src/G4GeomTestStreamLogger.cc

    r1337 r1347  
    2626//
    2727// $Id: G4GeomTestStreamLogger.cc,v 1.3 2006/06/29 18:36:49 gunter Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     28// GEANT4 tag $Name: geant4-09-04-ref-00 $
    2929//
    3030// --------------------------------------------------------------------

  • trunk/source/geometry/navigation/src/G4GeomTestVolPoint.cc

    r1337 r1347  
    2626//
    2727// $Id: G4GeomTestVolPoint.cc,v 1.3 2006/06/29 18:36:52 gunter Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     28// GEANT4 tag $Name: geant4-09-04-ref-00 $
    2929//
    3030// --------------------------------------------------------------------

  • trunk/source/geometry/navigation/src/G4GeomTestVolume.cc

    r1337 r1347  
    2626//
    2727// $Id: G4GeomTestVolume.cc,v 1.6 2007/11/16 09:39:14 gcosmo Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     28// GEANT4 tag $Name: geant4-09-04-ref-00 $
    2929//
    3030// --------------------------------------------------------------------

  • trunk/source/geometry/navigation/src/G4GeometryMessenger.cc

    r1337 r1347  
    2525//
    2626//
    27 // $Id: G4GeometryMessenger.cc,v 1.5 2006/06/29 18:36:57 gunter Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     27// $Id: G4GeometryMessenger.cc,v 1.6 2010/11/10 14:06:40 gcosmo Exp $
     28// GEANT4 tag $Name: geant4-09-04-ref-00 $
    2929//
    3030// --------------------------------------------------------------------
    … …  
    106106  chkCmd->AvailableForStates(G4State_Idle);
    107107
     108  pchkCmd = new G4UIcmdWithABool( "/geometry/navigator/push_notify", this );
     109  pchkCmd->SetGuidance( "Set navigator verbosity push notifications." );
     110  pchkCmd->SetGuidance( "This allows to disable/re-enable verbosity in" );
     111  pchkCmd->SetGuidance( "navigation, when tracks may get stuck and require" );
     112  pchkCmd->SetGuidance( "one artificial push along the direction by the" );
     113  pchkCmd->SetGuidance( "navigator. Notification is active by default." );
     114  pchkCmd->SetGuidance( "NOTE: this command has effect -only- if Geant4 has" );
     115  pchkCmd->SetGuidance( "      been installed with the G4VERBOSE flag set!" );
     116  pchkCmd->SetParameterName("pushFlag",true);
     117  pchkCmd->SetDefaultValue(true);
     118  pchkCmd->AvailableForStates(G4State_Idle);
     119
    108120  //
    109121  // Geometry verification test commands
    … …  
    244256  delete cyzCmd; delete cfzCmd; delete cfrCmd; delete cylCmd;
    245257  delete tolCmd;
    246   delete resCmd; delete verbCmd; delete chkCmd;
     258  delete resCmd; delete verbCmd; delete pchkCmd; delete chkCmd;
    247259  delete geodir; delete navdir; delete testdir;
    248260  delete tvolume; delete tlogger;
    … …  
    423435  G4Navigator* navigator = tmanager->GetNavigatorForTracking();
    424436  navigator->CheckMode(mode);
     437}
     438
     439//
     440// Set navigator verbosity for push notifications
     441//
     442void
     443G4GeometryMessenger::SetPushFlag(G4String input)
     444{
     445  G4bool mode = pchkCmd->GetNewBoolValue(input);
     446  G4Navigator* navigator = tmanager->GetNavigatorForTracking();
     447  navigator->SetPushVerbosity(mode);
    425448}
    426449

  • trunk/source/geometry/navigation/src/G4MultiLevelLocator.cc

    r1337 r1347  
    2424// ********************************************************************
    2525//
    26 // $Id: G4MultiLevelLocator.cc,v 1.5 2008/12/11 10:01:02 tnikitin Exp $
    27 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     26// $Id: G4MultiLevelLocator.cc,v 1.6 2010/07/13 15:59:42 gcosmo Exp $
     27// GEANT4 tag $Name: geant4-09-04-ref-00 $
    2828//
    2929// Class G4MultiLevelLocator implementation
    … …  
    120120
    121121  G4int substep_no = 0;
    122    
     122
     123  G4int oldprc;   // cout/cerr precision settings
     124
    123125  // Limits for substep number
    124126  //
    … …  
    156158
    157159#ifdef G4DEBUG_FIELD
    158   static G4double tolerance= 1.0e-8;
     160  static const G4double tolerance = 1.0e-8 * mm;
    159161  G4ThreeVector  StartPosition= CurveStartPointVelocity.GetPosition();
    160   if( (TrialPoint - StartPosition).mag() < tolerance * mm )
     162  if( (TrialPoint - StartPosition).mag() < tolerance)
    161163  {
    162164     G4cerr << "WARNING - G4MultiLevelLocator::EstimateIntersectionPoint()"
    … …  
    455457                   << GetEpsilonStepFor() << G4endl;
    456458          }
    457           G4cerr.precision(20);
     459          oldprc = G4cerr.precision(20);
    458460          G4cerr << " Point A (Curve start)   is " << CurveStartPointVelocity
    459461                 << G4endl;
    … …  
    474476          G4cerr << "        Substep depth no= "<< substep_no_p  << " Depth= "
    475477                 << depth << G4endl;
     478          G4cerr.precision(oldprc);
    476479
    477480          G4Exception("G4MultiLevelLocator::EstimateIntersectionPoint()",
    … …  
    691694#endif
    692695
    693     G4cout.precision( 10 );
     696    oldprc = G4cout.precision( 10 );
    694697    G4double done_len = CurrentA_PointVelocity.GetCurveLength();
    695698    G4double full_len = CurveEndPointVelocity.GetCurveLength();
    … …  
    699702           << " out of " << full_len << " required." << G4endl;
    700703    G4cout << "        Remaining length = " << full_len - done_len << G4endl;
     704    G4cout.precision( oldprc );
    701705
    702706    G4Exception("G4MultiLevelLocator::EstimateIntersectionPoint()",
    … …  
    706710  else if( substep_no >= warn_substeps )
    707711  { 
    708     G4int oldprc= G4cout.precision( 10 );
     712    oldprc = G4cout.precision( 10 );
    709713    G4cout << "WARNING - G4MultiLevelLocator::EstimateIntersectionPoint()"
    710714           << G4endl

  • trunk/source/geometry/navigation/src/G4MultiNavigator.cc

    r921 r1347  
    2525//
    2626//
    27 // $Id: G4MultiNavigator.cc,v 1.8 2008/10/24 14:00:03 gcosmo Exp $
     27// $Id: G4MultiNavigator.cc,v 1.11 2010/09/06 09:49:15 gcosmo Exp $
    2828// GEANT4 tag $ Name:  $
    2929//
    … …  
    4848//
    4949G4MultiNavigator::G4MultiNavigator()
    50   : G4Navigator()
     50  : G4Navigator(), fLastMassWorld(0)
    5151{
    5252  fNoActiveNavigators= 0;
    53   G4ThreeVector Big3Vector( DBL_MAX, DBL_MAX, DBL_MAX );
     53  G4ThreeVector Big3Vector( kInfinity, kInfinity, kInfinity );
    5454  fLastLocatedPosition = Big3Vector;
    5555  fSafetyLocation  = Big3Vector;
    … …  
    5858  fMinSafety_PreStepPt=  -1.0;
    5959  fMinSafety_atSafLocation= -1.0;
    60   fMinSafety= -DBL_MAX; 
    61   fMinStep=   -DBL_MAX; 
    62 
    63   for(register int num=0; num<= fMaxNav; ++num )
     60  fMinSafety= -kInfinity; 
     61  fTrueMinStep= fMinStep= -kInfinity; 
     62
     63  for(register int num=0; num< fMaxNav; ++num )
    6464  {
    6565    fpNavigator[num] =  0;   
    6666    fLimitTruth[num] = false;
    6767    fLimitedStep[num] = kUndefLimited;
    68     fCurrentStepSize[num] = -1.0;
     68    fCurrentStepSize[num] = fNewSafety[num] = -1.0;
    6969    fLocatedVolume[num] = 0;
    7070  }
    … …  
    9494{
    9595  G4double safety= 0.0, step=0.0;
    96   G4double minSafety= DBL_MAX, minStep= DBL_MAX;
     96  G4double minSafety= kInfinity, minStep= kInfinity;
    9797
    9898#ifdef G4DEBUG_NAVIGATION
    … …  
    115115  for( register int num=0; num< fNoActiveNavigators; ++pNavigatorIter,++num )
    116116  {
    117      safety= DBL_MAX;
     117     safety= kInfinity;
    118118
    119119     step= (*pNavigatorIter)->ComputeStep( initialPosition,
    … …  
    189189                                   ELimited &limitedStep)
    190190{
    191   G4int navigatorNo=-1;
    192 
    193   if( navigatorId <= fNoActiveNavigators )
    194   {
    195      navigatorNo= navigatorId;
    196   }
    197   else
     191  if( navigatorId > fNoActiveNavigators )
    198192  {
    199193     G4cerr << "ERROR - G4MultiNavigator::ObtainFinalStep()"
    … …  
    206200
    207201  // Prepare the information to return
    208   pNewSafety  = fNewSafety[ navigatorNo ];
    209   limitedStep = fLimitedStep[ navigatorNo ];
     202  //
     203  pNewSafety  = fNewSafety[ navigatorId ];
     204  limitedStep = fLimitedStep[ navigatorId ];
    210205  minStep= fMinStep;
    211206
    212   // if( (minStep==kInfinity) || (fVerbose > 1) ){
    213 #ifdef G4DEBUG_NAVIGATION
    214   if( fVerbose > 1 ){
    215      G4cout << " G4MultiNavigator::ComputeStep returns " << fCurrentStepSize[ navigatorNo ]
    216             << " for Navigator " << navigatorNo << " Limited step = " << limitedStep
     207#ifdef G4DEBUG_NAVIGATION
     208  if( fVerbose > 1 )
     209  {
     210     G4cout << " G4MultiNavigator::ComputeStep returns "
     211            << fCurrentStepSize[ navigatorId ]
     212            << " for Navigator " << navigatorId
     213            << " Limited step = " << limitedStep
    217214            << " Safety(mm) = " << pNewSafety / mm << G4endl;
    218215  }
    219216#endif
    220217
    221   return fCurrentStepSize[ navigatorNo ];
     218  return fCurrentStepSize[ navigatorId ];
    222219}
    223220
    … …  
    428425    // Recompute safety for the relevant point
    429426
    430     G4double minSafety = DBL_MAX, safety = DBL_MAX;
     427    G4double minSafety = kInfinity, safety = kInfinity;
    431428 
    432429    std::vector<G4Navigator*>::iterator pNavigatorIter;

  • trunk/source/geometry/navigation/src/G4Navigator.cc

    r1058 r1347  
    2525//
    2626//
    27 // $Id: G4Navigator.cc,v 1.39 2009/05/08 06:47:32 tnikitin Exp $
     27// $Id: G4Navigator.cc,v 1.46 2010/11/15 14:03:27 gcosmo Exp $
    2828// GEANT4 tag $ Name:  $
    2929//
    … …  
    4747G4Navigator::G4Navigator()
    4848  : fWasLimitedByGeometry(false), fVerbose(0),
    49     fTopPhysical(0), fCheck(false), fPushed(false)
     49    fTopPhysical(0), fCheck(false), fPushed(false), fWarnPush(true)
    5050{
    5151  fActive= false;
    … …  
    128128
    129129#ifdef G4VERBOSE
    130   G4int oldcoutPrec = G4cout.precision(8);
    131130  if( fVerbose > 2 )
    132131  {
     132    G4int oldcoutPrec = G4cout.precision(8);
    133133    G4cout << "*** G4Navigator::LocateGlobalPointAndSetup: ***" << G4endl;
    134134    G4cout << "    Called with arguments: " << G4endl
    … …  
    140140      PrintState();
    141141    }
     142    G4cout.precision(oldcoutPrec);
    142143  }
    143144#endif
    … …  
    195196              break;
    196197            case kParameterised:
    197               if( fBlockedPhysicalVolume->GetRegularStructureId() != 1 )
     198              if( fBlockedPhysicalVolume->GetRegularStructureId() == 0 )
    198199              {
    199200                G4VSolid *pSolid;
    … …  
    360361    //
    361362    targetPhysical = fHistory.GetTopVolume();
     363    if (!targetPhysical) { break; }
    362364    targetLogical = targetPhysical->GetLogicalVolume();
    363365    switch( CharacteriseDaughters(targetLogical) )
    … …  
    452454  if( fVerbose == 4 )
    453455  {
    454     G4cout.precision(6);
     456    G4int oldcoutPrec = G4cout.precision(8);
    455457    G4String curPhysVol_Name("None");
    456     if (targetPhysical!=0)
    457     {
    458       curPhysVol_Name = targetPhysical->GetName();
    459     }
     458    if (targetPhysical)  { curPhysVol_Name = targetPhysical->GetName(); }
    460459    G4cout << "    Return value = new volume = " << curPhysVol_Name << G4endl;
    461460    G4cout << "    ----- Upon exiting:" << G4endl;
    … …  
    465464    G4cout << "    History = " << G4endl << fHistory << G4endl << G4endl;
    466465#endif
    467   }
    468   G4cout.precision(oldcoutPrec);
     466    G4cout.precision(oldcoutPrec);
     467  }
    469468#endif
    470469
    … …  
    627626{
    628627  G4ThreeVector localDirection = ComputeLocalAxis(pDirection);
    629   G4double Step = DBL_MAX;
     628  G4double Step = kInfinity;
    630629  G4VPhysicalVolume  *motherPhysical = fHistory.GetTopVolume();
    631630  G4LogicalVolume *motherLogical = motherPhysical->GetLogicalVolume();
    … …  
    635634
    636635#ifdef G4VERBOSE
    637   G4int oldcoutPrec= G4cout.precision(8);
    638   G4int oldcerrPrec= G4cerr.precision(10);
    639636  if( fVerbose > 0 )
    640637  {
    … …  
    654651#endif
    655652  }
    656 
    657   static G4double fAccuracyForWarning   = kCarTolerance,
    658                   fAccuracyForException = 1000*kCarTolerance;
    659653#endif
    660654
    … …  
    670664    {
    671665#ifdef G4VERBOSE
    672       //  The following checks only make sense if the move is larger
    673       //  than the tolerance.
    674       //
    675       G4ThreeVector OriginalGlobalpoint =
    676                     fHistory.GetTopTransform().Inverse().
    677                     TransformPoint(fLastLocatedPointLocal);
    678 
    679       G4double shiftOriginSafSq = (fPreviousSftOrigin-pGlobalpoint).mag2();
    680 
    681       // Check that the starting point of this step is
    682       // within the isotropic safety sphere of the last point
    683       // to a accuracy/precision  given by fAccuracyForWarning.
    684       //   If so give warning.
    685       //   If it fails by more than fAccuracyForException exit with error.
    686       //
    687       if( shiftOriginSafSq >= sqr(fPreviousSafety) )
    688       {
    689         G4double shiftOrigin = std::sqrt(shiftOriginSafSq);
    690         G4double diffShiftSaf = shiftOrigin - fPreviousSafety;
    691 
    692         if( diffShiftSaf > fAccuracyForWarning )
    693         {
    694           G4Exception("G4Navigator::ComputeStep()",
    695                       "UnexpectedPositionShift", JustWarning,
    696                       "Accuracy ERROR or slightly inaccurate position shift.");
    697           G4cerr << "     The Step's starting point has moved "
    698                  << std::sqrt(moveLenSq)/mm << " mm " << G4endl
    699                  << "     since the last call to a Locate method." << G4endl;
    700           G4cerr << "     This has resulted in moving "
    701                  << shiftOrigin/mm << " mm "
    702                  << " from the last point at which the safety "
    703                  << "     was calculated " << G4endl;
    704           G4cerr << "     which is more than the computed safety= "
    705                  << fPreviousSafety/mm << " mm  at that point." << G4endl;
    706           G4cerr << "     This difference is "
    707                  << diffShiftSaf/mm << " mm." << G4endl
    708                  << "     The tolerated accuracy is "
    709                  << fAccuracyForException/mm << " mm." << G4endl;
    710 
    711           static G4int warnNow = 0;
    712           if( ((++warnNow % 100) == 1) )
    713           {
    714             G4cerr << "  This problem can be due to either " << G4endl;
    715             G4cerr << "    - a process that has proposed a displacement"
    716                    << " larger than the current safety , or" << G4endl;
    717             G4cerr << "    - inaccuracy in the computation of the safety"
    718                    << G4endl;
    719             G4cerr << "  We suggest that you " << G4endl
    720                    << "   - find i) what particle is being tracked, and "
    721                    << " ii) through what part of your geometry " << G4endl
    722                    << "      for example by re-running this event with "
    723                    << G4endl
    724                    << "         /tracking/verbose 1 "  << G4endl
    725                    << "    - check which processes you declare for"
    726                    << " this particle (and look at non-standard ones)"
    727                    << G4endl
    728                    << "   - in case, create a detailed logfile"
    729                    << " of this event using:" << G4endl
    730                    << "         /tracking/verbose 6 "
    731                    << G4endl;
    732           }
    733         }
    734 #ifdef G4DEBUG_NAVIGATION
    735         else
    736         {
    737           G4cerr << "WARNING - G4Navigator::ComputeStep()" << G4endl
    738                  << "          The Step's starting point has moved "
    739                  << std::sqrt(moveLenSq) << "," << G4endl
    740                  << "          which has taken it to the limit of"
    741                  << " the current safety. " << G4endl;
    742         }
    743 #endif
    744       }
    745       G4double safetyPlus = fPreviousSafety + fAccuracyForException;
    746       if ( shiftOriginSafSq > sqr(safetyPlus) )
    747       {
    748         G4cerr << "ERROR - G4Navigator::ComputeStep()" << G4endl
    749                << "        Position has shifted considerably without"
    750                << " notifying the navigator !" << G4endl
    751                << "        Tolerated safety: " << safetyPlus << G4endl
    752                << "        Computed shift  : " << shiftOriginSafSq << G4endl;
    753         G4Exception("G4Navigator::ComputeStep()",
    754                     "SignificantPositionShift", JustWarning,
    755                     "May lead to a crash or unreliable results.");
    756       }
    757 #endif  // end G4VERBOSE
    758 
     666      ComputeStepLog(pGlobalpoint, moveLenSq);
     667#endif
    759668      // Relocate the point within the same volume
    760669      //
    … …  
    784693        else
    785694        {
    786           if( motherPhysical->GetRegularStructureId() != 1 )
     695          if( motherPhysical->GetRegularStructureId() == 0 )
    787696          {
    788697            Step = fnormalNav.ComputeStep(fLastLocatedPointLocal,
    … …  
    811720            // reset the history topvolume to world.
    812721            //
    813             if(fHistory.GetTopVolume()->GetRegularStructureId() != 1 )
     722            if(fHistory.GetTopVolume()->GetRegularStructureId() == 0 )
    814723            {
    815724              G4Exception("G4Navigator::ComputeStep()",
    … …  
    944853       // Act to recover this stuck track. Pushing it along direction
    945854       //
    946        Step += 0.9*kCarTolerance;
     855       Step += 100*kCarTolerance;
    947856#ifdef G4VERBOSE
    948        if (!fPushed)
     857       if ((!fPushed) && (fWarnPush))
    949858       {
    950859         G4cerr << "WARNING - G4Navigator::ComputeStep()" << G4endl
    … …  
    1048957    G4cout << "    Safety = " << pNewSafety << G4endl;
    1049958  }
    1050   G4cout.precision(oldcoutPrec);
    1051   G4cerr.precision(oldcerrPrec);
    1052959#endif
    1053960
    … …  
    11121019  fBlockedReplicaNo      = -1;
    11131020
    1114   fLastLocatedPointLocal = G4ThreeVector( DBL_MAX, -DBL_MAX, 0.0 );
     1021  fLastLocatedPointLocal = G4ThreeVector( kInfinity, -kInfinity, 0.0 );
    11151022  fLocatedOutsideWorld   = false;
    11161023}
    … …  
    11321039  G4VPVParameterisation *pParam;
    11331040
    1134   mother = fHistory.GetVolume(0);
    11351041  for ( i=1; i<=cdepth; i++ )
    11361042  {
    … …  
    14081314
    14091315// ********************************************************************
     1316// ComputeStepLog
     1317// ********************************************************************
     1318//
     1319void G4Navigator::ComputeStepLog(const G4ThreeVector& pGlobalpoint,
     1320                                       G4double moveLenSq) const
     1321{
     1322  //  The following checks only make sense if the move is larger
     1323  //  than the tolerance.
     1324
     1325  static const G4double fAccuracyForWarning   = kCarTolerance,
     1326                        fAccuracyForException = 1000*kCarTolerance;
     1327
     1328  G4ThreeVector OriginalGlobalpoint = fHistory.GetTopTransform().Inverse().
     1329                                      TransformPoint(fLastLocatedPointLocal);
     1330
     1331  G4double shiftOriginSafSq = (fPreviousSftOrigin-pGlobalpoint).mag2();
     1332
     1333  // Check that the starting point of this step is
     1334  // within the isotropic safety sphere of the last point
     1335  // to a accuracy/precision  given by fAccuracyForWarning.
     1336  //   If so give warning.
     1337  //   If it fails by more than fAccuracyForException exit with error.
     1338  //
     1339  if( shiftOriginSafSq >= sqr(fPreviousSafety) )
     1340  {
     1341    G4double shiftOrigin = std::sqrt(shiftOriginSafSq);
     1342    G4double diffShiftSaf = shiftOrigin - fPreviousSafety;
     1343
     1344    if( diffShiftSaf > fAccuracyForWarning )
     1345    {
     1346      G4int oldcoutPrec= G4cout.precision(8);
     1347      G4int oldcerrPrec= G4cerr.precision(10);
     1348      G4Exception("G4Navigator::ComputeStep()",
     1349                  "UnexpectedPositionShift", JustWarning,
     1350                  "Accuracy error or slightly inaccurate position shift.");
     1351      G4cerr << "     The Step's starting point has moved "
     1352             << std::sqrt(moveLenSq)/mm << " mm " << G4endl
     1353             << "     since the last call to a Locate method." << G4endl;
     1354      G4cerr << "     This has resulted in moving "
     1355             << shiftOrigin/mm << " mm "
     1356             << " from the last point at which the safety "
     1357             << "     was calculated " << G4endl;
     1358      G4cerr << "     which is more than the computed safety= "
     1359             << fPreviousSafety/mm << " mm  at that point." << G4endl;
     1360      G4cerr << "     This difference is "
     1361             << diffShiftSaf/mm << " mm." << G4endl
     1362             << "     The tolerated accuracy is "
     1363             << fAccuracyForException/mm << " mm." << G4endl;
     1364
     1365      static G4int warnNow = 0;
     1366      if( ((++warnNow % 100) == 1) )
     1367      {
     1368        G4cerr << "  This problem can be due to either " << G4endl;
     1369        G4cerr << "    - a process that has proposed a displacement"
     1370               << " larger than the current safety , or" << G4endl;
     1371        G4cerr << "    - inaccuracy in the computation of the safety"
     1372                   << G4endl;
     1373        G4cerr << "  We suggest that you " << G4endl
     1374               << "   - find i) what particle is being tracked, and "
     1375               << " ii) through what part of your geometry " << G4endl
     1376               << "      for example by re-running this event with "
     1377               << G4endl
     1378               << "         /tracking/verbose 1 "  << G4endl
     1379               << "    - check which processes you declare for"
     1380               << " this particle (and look at non-standard ones)"
     1381               << G4endl
     1382               << "   - in case, create a detailed logfile"
     1383               << " of this event using:" << G4endl
     1384               << "         /tracking/verbose 6 "
     1385               << G4endl;
     1386      }
     1387      G4cout.precision(oldcoutPrec);
     1388      G4cerr.precision(oldcerrPrec);
     1389    }
     1390#ifdef G4DEBUG_NAVIGATION
     1391    else
     1392    {
     1393      G4cerr << "WARNING - G4Navigator::ComputeStep()" << G4endl
     1394             << "          The Step's starting point has moved "
     1395             << std::sqrt(moveLenSq) << "," << G4endl
     1396             << "          which has taken it to the limit of"
     1397             << " the current safety. " << G4endl;
     1398    }
     1399#endif
     1400  }
     1401  G4double safetyPlus = fPreviousSafety + fAccuracyForException;
     1402  if ( shiftOriginSafSq > sqr(safetyPlus) )
     1403  {
     1404    G4cerr << "ERROR - G4Navigator::ComputeStep()" << G4endl
     1405           << "        Position has shifted considerably without"
     1406           << " notifying the navigator !" << G4endl
     1407           << "        Tolerated safety: " << safetyPlus << G4endl
     1408           << "        Computed shift  : " << shiftOriginSafSq << G4endl;
     1409    G4Exception("G4Navigator::ComputeStep()",
     1410                "SignificantPositionShift", JustWarning,
     1411                "May lead to a crash or unreliable results.");
     1412  }
     1413}
     1414
     1415// ********************************************************************
    14101416// Operator <<
    14111417// ********************************************************************

  • trunk/source/geometry/navigation/src/G4NormalNavigation.cc

    r1337 r1347  
    2525//
    2626//
    27 // $Id: G4NormalNavigation.cc,v 1.9 2007/05/11 13:43:59 gcosmo Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     27// $Id: G4NormalNavigation.cc,v 1.11 2010/11/04 08:57:56 gcosmo Exp $
     28// GEANT4 tag $Name: geant4-09-04-ref-00 $
    2929//
    3030//
    … …  
    3838#include "G4AffineTransform.hh"
    3939
    40 #include <iomanip>
    41 
    4240// ********************************************************************
    4341// Constructor
    … …  
    4543//
    4644G4NormalNavigation::G4NormalNavigation()
    47   : fCheck(false), fVerbose(0)
    48 {
     45  : fCheck(false)
     46{
     47  fLogger = new G4NavigationLogger("G4NormalNavigation");
    4948}
    5049
    … …  
    5453//
    5554G4NormalNavigation::~G4NormalNavigation()
    56 {;}
     55{
     56  delete fLogger;
     57}
    5758
    5859// ********************************************************************
    … …  
    9091 
    9192#ifdef G4VERBOSE
    92   static G4int precVerf= 20;  // Precision
    9393  if ( fCheck )
    9494  {
    95     if( fVerbose == 1 )
    96     {
    97       G4cout << "*** G4NormalNavigation::ComputeStep(): ***" << G4endl
    98              << "    Invoked DistanceToOut(p) for mother solid: "
    99              << motherSolid->GetName()
    100              << ". Solid replied: " << motherSafety << G4endl
    101              << "    For local point p: " << localPoint << G4endl
    102              << "    To be considered as 'mother safety'." << G4endl;
    103     }
    104     if ( motherSafety < 0.0 )
    105     {
    106       G4cerr << "ERROR - G4NormalNavigation::ComputeStep()" << G4endl
    107              << "        Current solid " << motherSolid->GetName()
    108              << " gave negative safety: " << motherSafety << G4endl
    109              << "        for the current (local) point " << localPoint
    110              << G4endl;
    111       motherSolid->DumpInfo();
    112       G4Exception("G4NormalNavigation::ComputeStep()",
    113                   "NegativeSafetyMotherVol", FatalException,
    114                   "Negative Safety In Voxel Navigation !" );
    115     }
    116     if( motherSolid->Inside(localPoint)==kOutside )
    117     {
    118       G4cout << "WARNING - G4NormalNavigation::ComputeStep()" << G4endl
    119              << "          Point " << localPoint
    120              << " is outside current volume " << motherPhysical->GetName()
    121              << G4endl;
    122       G4double estDistToSolid= motherSolid->DistanceToIn(localPoint);
    123       G4cout << "          Estimated isotropic distance to solid (distToIn)= "
    124              << estDistToSolid << G4endl;
    125       if( estDistToSolid > 100.0 * motherSolid->GetTolerance() )
    126       {
    127         motherSolid->DumpInfo();
    128         G4Exception("G4NormalNavigation::ComputeStep()",
    129                     "FarOutsideCurrentVolume", FatalException,
    130                     "Point is far outside Current Volume !" );
    131       }
    132       else
    133         G4Exception("G4NormalNavigation::ComputeStep()", "OutsideCurrentVolume",
    134                     JustWarning, "Point is a little outside Current Volume.");
    135     }
    136 
    137     // Verification / verbosity
    138     //
    139     if ( fVerbose > 1 )
    140     {
    141       G4int oldprec = G4cout.precision(precVerf);
    142       G4cout << " G4NormalNavigation::ComputeStep()"
    143              << " - Information on mother / key daughters ..." << G4endl;
    144       G4cout << " Type   " << std::setw(12) << "Solid-Name"   << " "
    145              << std::setw(3*(6+precVerf))   << " local point" << " "
    146              << std::setw(4+precVerf)       << "solid-Safety" << " "
    147              << std::setw(4+precVerf)       << "solid-Step"   << " "
    148              << std::setw(17)               << "distance Method "
    149              << std::setw(3*(6+precVerf))   << " local direction" << " "
    150              << G4endl;
    151       G4cout << " Mother " << std::setw(12) << motherSolid->GetName() << " "
    152              << std::setw(4+precVerf)       << localPoint   << " "
    153              << std::setw(4+precVerf)       << motherSafety << " "
    154              << G4endl;
    155       G4cout.precision(oldprec);
    156     }
    157 
     95    fLogger->PreComputeStepLog(motherPhysical, motherSafety, localPoint);
    15896  }
    15997#endif
    … …  
    193131      const G4double sampleSafety =
    194132              sampleSolid->DistanceToIn(samplePoint);
     133#ifdef G4VERBOSE
     134      if( fCheck )
     135      {
     136        fLogger->PrintDaughterLog(sampleSolid, samplePoint, sampleSafety, 0);
     137      }
     138#endif
    195139      if ( sampleSafety<ourSafety )
    196140      {
    … …  
    202146        const G4double sampleStep =
    203147                sampleSolid->DistanceToIn(samplePoint,sampleDirection);
    204 #ifdef G4VERBOSE
    205         if(( fCheck ) && ( fVerbose == 1 ))
     148
     149#ifdef G4VERBOSE
     150        if( fCheck )
    206151        {
    207           G4cout << "*** G4NormalNavigation::ComputeStep(): ***" << G4endl
    208                  << "    Invoked DistanceToIn(p,v) for daughter solid: "
    209                  << sampleSolid->GetName()
    210                  << ". Solid replied: " << sampleStep << G4endl
    211                  << "    For local point p: " << samplePoint << G4endl
    212                  << "    Direction v: " << sampleDirection
    213                  << ", to be considered as 'daughter step'." << G4endl;
     152          fLogger->PrintDaughterLog(sampleSolid, samplePoint,
     153                                    sampleSafety, sampleStep);
    214154        }
    215155#endif
    … …  
    221161          *pBlockedPhysical = samplePhysical;
    222162          blockedReplicaNo  = -1;
    223 
    224 #ifdef G4VERBOSE
    225           // Check to see that the resulting point is indeed in/on volume.
    226           // This check could eventually be made only for successful candidate.
    227 
    228           if ( ( fCheck ) && ( sampleStep < kInfinity ) )
     163#ifdef G4VERBOSE
     164          if( fCheck )
    229165          {
    230             G4ThreeVector intersectionPoint;
    231             intersectionPoint= samplePoint + sampleStep * sampleDirection;
    232             EInside insideIntPt= sampleSolid->Inside(intersectionPoint);
    233             G4String solidResponse = "-kInside-";
    234             if (insideIntPt == kOutside)
    235               solidResponse = "-kOutside-";
    236             else if (insideIntPt == kSurface)
    237               solidResponse = "-kSurface-";
    238             if( fVerbose == 1 )
    239             {
    240               G4cout << "*** G4NormalNavigation::ComputeStep(): ***" << G4endl
    241                      << "    Invoked Inside() for solid: "
    242                      << sampleSolid->GetName()
    243                      << ". Solid replied: " << solidResponse << G4endl
    244                      << "    For point p: " << intersectionPoint
    245                      << ", considered as 'intersection' point." << G4endl;
    246             }
    247             if ( insideIntPt != kSurface )
    248             {
    249               G4int oldcoutPrec = G4cout.precision(16);
    250               G4cout << "WARNING - G4NormalNavigation::ComputeStep()" << G4endl
    251                      << "          Inaccurate DistanceToIn for solid "
    252                      << sampleSolid->GetName() << G4endl;
    253               G4cout << "          Solid gave DistanceToIn = " << sampleStep
    254                      << " yet returns " << solidResponse
    255                      << " for this point !" << G4endl;
    256               G4cout << "          Point = " << intersectionPoint << G4endl;
    257               if ( insideIntPt != kInside )
    258                 G4cout << "        DistanceToIn(p) = "
    259                        << sampleSolid->DistanceToIn(intersectionPoint)
    260                        << G4endl;
    261               if ( insideIntPt != kOutside )
    262                 G4cout << "        DistanceToOut(p) = "
    263                        << sampleSolid->DistanceToOut(intersectionPoint)
    264                        << G4endl;
    265               G4Exception("G4NormalNavigation::ComputeStep()",
    266                           "InaccurateDistanceToIn", JustWarning,
    267                           "Navigator gets conflicting response from Solid.");
    268               G4cout.precision(oldcoutPrec);
    269             }
    270           }
    271 
    272           // Verification / verbosity
    273           //
    274           if ( fVerbose > 1 )
    275           {
    276             G4int oldprec = G4cout.precision(precVerf);
    277             G4cout << " Daught "
    278                    << std::setw(12)         << sampleSolid->GetName() << " "
    279                    << std::setw(4+precVerf) << samplePoint  << " "
    280                    << std::setw(4+precVerf) << sampleSafety << " "
    281                    << std::setw(4+precVerf) << sampleStep   << " "
    282                    << std::setw(16)         << "distanceToIn" << " "
    283                    << std::setw(4+precVerf) << localDirection << " "
    284                    << G4endl;
    285             G4cout.precision(oldprec);
     166            fLogger->AlongComputeStepLog(sampleSolid, samplePoint,
     167              sampleDirection, localDirection, sampleSafety, sampleStep);
    286168          }
    287169#endif
    … …  
    313195      if ( fCheck )
    314196      {
    315         if( fVerbose == 1 )
    316         {
    317           G4cout << "*** G4NormalNavigation::ComputeStep(): ***" << G4endl
    318                  << "    Invoked DistanceToOut(p,v,...) for mother solid: "
    319                  << motherSolid->GetName()
    320                  << ". Solid replied: " << motherStep << G4endl
    321                  << "    For local point p: " << localPoint << G4endl
    322                  << "    Direction v: " << localDirection
    323                  << ", to be considered as 'mother step'." << G4endl;
    324         }
    325         if( ( motherStep < 0.0 ) || ( motherStep >= kInfinity) )
    326         {
    327           G4cerr << "ERROR - G4NormalNavigation::ComputeStep()" << G4endl
    328                  << "        Problem in Navigation"  << G4endl
    329                  << "        Point (local coordinates): "
    330                  << localPoint << G4endl
    331                  << "        Local Direction: " << localDirection << G4endl
    332                  << "        Solid: " << motherSolid->GetName() << G4endl;
    333           motherSolid->DumpInfo();
    334           G4Exception("G4NormalNavigation::ComputeStep()",
    335                       "PointDistOutInvalid", FatalException,
    336                       "Current point is outside the current solid !");
    337         }
    338       }
    339       if ( fVerbose > 1 )
    340       {
    341         G4int oldprec = G4cout.precision(precVerf);
    342         G4cout << " Mother " << std::setw(12) << motherSolid->GetName() << " "
    343                << std::setw(4+precVerf)       << localPoint   << " "
    344                << std::setw(4+precVerf)       << motherSafety << " "
    345                << std::setw(4+precVerf)       << motherStep   << " "
    346                << std::setw(16)               << "distanceToOut" << " "
    347                << std::setw(4+precVerf)       << localDirection << " "
    348                << G4endl;
    349         G4cout.precision(oldprec);     
     197        fLogger->PostComputeStepLog(motherSolid, localPoint, localDirection,
     198                                    motherStep, motherSafety);
    350199      }
    351200#endif
    … …  
    399248
    400249#ifdef G4VERBOSE
    401   if(( fCheck ) && ( fVerbose == 1 ))
    402   {
    403     G4cout << "*** G4NormalNavigation::ComputeSafety(): ***" << G4endl
    404            << "    Invoked DistanceToOut(p) for mother solid: "
    405            << motherSolid->GetName()
    406            << ". Solid replied: " << motherSafety << G4endl
    407            << "    For local point p: " << localPoint
    408            << ", to be considered as 'mother safety'." << G4endl;
     250  if( fCheck )
     251  {
     252    fLogger->ComputeSafetyLog(motherSolid, localPoint, motherSafety, true);
    409253  }
    410254#endif
    … …  
    430274    }
    431275#ifdef G4VERBOSE
    432     if(( fCheck ) && ( fVerbose == 1 ))
    433     {
    434       G4cout << "*** G4NormalNavigation::ComputeSafety(): ***" << G4endl
    435              << "    Invoked DistanceToIn(p) for daughter solid: "
    436              << sampleSolid->GetName()
    437              << ". Solid replied: " << sampleSafety << G4endl
    438              << "    For local point p: " << samplePoint
    439              << ", to be considered as 'daughter safety'." << G4endl;
     276    if(fCheck)
     277    {
     278      fLogger->ComputeSafetyLog(sampleSolid, samplePoint, sampleSafety, false);
    440279    }
    441280#endif

  • trunk/source/geometry/navigation/src/G4ParameterisedNavigation.cc

    r1337 r1347  
    2525//
    2626//
    27 // $Id: G4ParameterisedNavigation.cc,v 1.12 2007/11/09 16:06:02 gcosmo Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     27// $Id: G4ParameterisedNavigation.cc,v 1.13 2010/07/13 15:59:42 gcosmo Exp $
     28// GEANT4 tag $Name: geant4-09-04-ref-00 $
    2929//
    3030//
    … …  
    5858//
    5959G4ParameterisedNavigation::G4ParameterisedNavigation()
    60   : fVoxelHeader(0)
     60  : fVoxelAxis(kUndefined), fVoxelNoSlices(0), fVoxelSliceWidth(0.),
     61    fVoxelNodeNo(0), fVoxelHeader(0)
    6162{
    6263}

  • trunk/source/geometry/navigation/src/G4PathFinder.cc

    r1058 r1347  
    2525//
    2626//
    27 // $Id: G4PathFinder.cc,v 1.62 2009/05/13 23:20:54 japost Exp $
     27// $Id: G4PathFinder.cc,v 1.64 2010/07/13 15:59:42 gcosmo Exp $
    2828// GEANT4 tag $ Name:  $
    2929//
    … …  
    6969G4PathFinder::G4PathFinder()
    7070  : fEndState( G4ThreeVector(), G4ThreeVector(), 0., 0., 0., 0., 0.),
     71    fFieldExertedForce(false),
    7172    fRelocatedPoint(true),
    72     fLastStepNo(-1),
     73    fLastStepNo(-1), fCurrentStepNo(-1),
    7374    fVerboseLevel(0)
    7475{
    … …  
    9192   fMinSafety_atSafLocation= -1.0;
    9293   fMinStep=   -1.0;
     94   fTrueMinStep= -1.0;
     95   fPreStepCenterRenewed= false;
    9396   fNewTrack= false;
    9497   fNoGeometriesLimiting= 0;
    9598
    96    for( register int num=0; num<= fMaxNav; ++num )
     99   for( register int num=0; num< fMaxNav; ++num )
    97100   {
    98101      fpNavigator[num] =  0;   

  • trunk/source/geometry/navigation/src/G4PhantomParameterisation.cc

    r1058 r1347  
    2525//
    2626//
    27 // $Id: G4PhantomParameterisation.cc,v 1.6 2009/05/20 08:27:10 gcosmo Exp $
     27// $Id: G4PhantomParameterisation.cc,v 1.7 2010/07/13 15:59:42 gcosmo Exp $
    2828// GEANT4 tag $ Name:$
    2929//
    … …  
    4545//------------------------------------------------------------------
    4646G4PhantomParameterisation::G4PhantomParameterisation()
    47 {
    48   // Initialise data
    49   //
    50   fMaterialIndices = 0;
    51   fContainerWallX = 0.;
    52   fContainerWallY = 0.;
    53   fContainerWallZ = 0.;
    54 
     47  : fVoxelHalfX(0.), fVoxelHalfY(0.), fVoxelHalfZ(0.),
     48    fNoVoxelX(0), fNoVoxelY(0), fNoVoxelZ(0), fNoVoxelXY(0), fNoVoxel(0),
     49    fMaterialIndices(0), fContainerSolid(0),
     50    fContainerWallX(0.), fContainerWallY(0.), fContainerWallZ(0.),
     51    bSkipEqualMaterials(true)
     52{
    5553  kCarTolerance = G4GeometryTolerance::GetInstance()->GetSurfaceTolerance();
    56 
    57   bSkipEqualMaterials = 1;
    5854}
    5955

  • trunk/source/geometry/navigation/src/G4PropagatorInField.cc

    r1315 r1347  
    3636// 17.03.97 John Apostolakis,   renaming new set functions being added
    3737//
    38 // $Id: G4PropagatorInField.cc,v 1.51 2010/03/08 13:57:34 gcosmo Exp $
     38// $Id: G4PropagatorInField.cc,v 1.52 2010/07/13 15:59:42 gcosmo Exp $
    3939// GEANT4 tag $ Name:  $
    4040// ---------------------------------------------------------------------------
    … …  
    470470                                        G4VPhysicalVolume*   startVolume)
    471471{
    472   const G4int verboseLevel= fVerboseLevel;
     472  const G4int verboseLevel=fVerboseLevel;
    473473  const G4ThreeVector StartPosition       = StartFT.GetPosition();
    474474  const G4ThreeVector StartUnitVelocity   = StartFT.GetMomentumDir();
    … …  
    477477
    478478  G4double step_len = CurrentFT.GetCurveLength() - StartFT.GetCurveLength();
     479
     480  G4int oldprec;   // cout/cerr precision settings
    479481     
    480   if( ((stepNo == 0) && (verboseLevel <3))
    481       || (verboseLevel >= 3) )
    482   {
    483     static G4int noPrecision= 4;
    484     G4cout.precision(noPrecision);
    485     // G4cout.setf(ios_base::fixed,ios_base::floatfield);
     482  if( ((stepNo == 0) && (verboseLevel <3)) || (verboseLevel >= 3) )
     483  {
     484    oldprec = G4cout.precision(4);
    486485    G4cout << std::setw( 6)  << " "
    487486           << std::setw( 25) << " Current Position  and  Direction" << " "
    … …  
    495494           << std::setw( 7) << " N_y " << " "
    496495           << std::setw( 7) << " N_z " << " " ;
    497     //            << G4endl;
    498     G4cout     // << " >>> "
    499            << std::setw( 7) << " Delta|N|" << " "
    500       //   << std::setw( 7) << " Delta(N_z) " << " "
     496    G4cout << std::setw( 7) << " Delta|N|" << " "
    501497           << std::setw( 9) << "StepLen" << " " 
    502498           << std::setw(12) << "StartSafety" << " " 
    503499           << std::setw( 9) << "PhsStep" << " "; 
    504     if( startVolume ) {
    505       G4cout << std::setw(18) << "NextVolume" << " ";
    506     }
     500    if( startVolume )
     501      { G4cout << std::setw(18) << "NextVolume" << " "; }
     502    G4cout.precision(oldprec);
    507503    G4cout << G4endl;
    508504  }
    509   if((stepNo == 0) && (verboseLevel <=3)){
    510      // Recurse to print the start values
    511      //
    512      printStatus( StartFT, StartFT, -1.0, safety, -1, startVolume);
    513    }
    514    if( verboseLevel <= 3 )
    515    {
    516      if( stepNo >= 0)
    517        G4cout << std::setw( 4) << stepNo << " ";
    518      else
    519        G4cout << std::setw( 5) << "Start" ;
    520      G4cout.precision(8);
    521      G4cout << std::setw(10) << CurrentFT.GetCurveLength() << " ";
    522      G4cout.precision(8);
    523      G4cout << std::setw(10) << CurrentPosition.x() << " "
    524             << std::setw(10) << CurrentPosition.y() << " "
    525             << std::setw(10) << CurrentPosition.z() << " ";
    526      G4cout.precision(4);
    527      G4cout << std::setw( 7) << CurrentUnitVelocity.x() << " "
    528             << std::setw( 7) << CurrentUnitVelocity.y() << " "
    529             << std::setw( 7) << CurrentUnitVelocity.z() << " ";
    530      //  G4cout << G4endl;
    531      //     G4cout << " >>> " ;
    532      G4cout.precision(3);
    533      G4cout << std::setw( 7) << CurrentFT.GetMomentum().mag()- StartFT.GetMomentum().mag() << " ";
    534      //   << std::setw( 7) << CurrentUnitVelocity.z() - InitialUnitVelocity.z() << " ";
    535      G4cout << std::setw( 9) << step_len << " ";
    536      G4cout << std::setw(12) << safety << " ";
    537      if( requestStep != -1.0 )
    538        G4cout << std::setw( 9) << requestStep << " ";
    539      else
    540        G4cout << std::setw( 9) << "Init/NotKnown" << " ";
    541 
    542      if( startVolume != 0)
    543      {
    544        G4cout << std::setw(12) << startVolume->GetName() << " ";
    545      }
    546 #if 0
    547      else
    548      {
    549        if( step_len != -1 )
    550          G4cout << std::setw(12) << "OutOfWorld" << " ";
    551        else
    552          G4cout << std::setw(12) << "NotGiven" << " ";
    553      }
    554 #endif
    555 
    556      G4cout << G4endl;
    557    }
    558    else // if( verboseLevel > 3 )
    559    {
    560      //  Multi-line output
    561        
    562      G4cout << "Step taken was " << step_len 
    563             << " out of PhysicalStep = " <<  requestStep << G4endl;
    564      G4cout << "Final safety is: " << safety << G4endl;
    565 
    566      G4cout << "Chord length = " << (CurrentPosition-StartPosition).mag()
    567             << G4endl;
    568      G4cout << G4endl;
    569    }
     505  if((stepNo == 0) && (verboseLevel <=3))
     506  {
     507    // Recurse to print the start values
     508    //
     509    printStatus( StartFT, StartFT, -1.0, safety, -1, startVolume);
     510  }
     511  if( verboseLevel <= 3 )
     512  {
     513    if( stepNo >= 0)
     514      { G4cout << std::setw( 4) << stepNo << " "; }
     515    else
     516      { G4cout << std::setw( 5) << "Start" ; }
     517    oldprec = G4cout.precision(8);
     518    G4cout << std::setw(10) << CurrentFT.GetCurveLength() << " ";
     519    G4cout.precision(8);
     520    G4cout << std::setw(10) << CurrentPosition.x() << " "
     521           << std::setw(10) << CurrentPosition.y() << " "
     522           << std::setw(10) << CurrentPosition.z() << " ";
     523    G4cout.precision(4);
     524    G4cout << std::setw( 7) << CurrentUnitVelocity.x() << " "
     525           << std::setw( 7) << CurrentUnitVelocity.y() << " "
     526           << std::setw( 7) << CurrentUnitVelocity.z() << " ";
     527    G4cout.precision(3);
     528    G4cout << std::setw( 7)
     529           << CurrentFT.GetMomentum().mag()-StartFT.GetMomentum().mag() << " ";
     530    G4cout << std::setw( 9) << step_len << " ";
     531    G4cout << std::setw(12) << safety << " ";
     532    if( requestStep != -1.0 )
     533      { G4cout << std::setw( 9) << requestStep << " "; }
     534    else
     535      { G4cout << std::setw( 9) << "Init/NotKnown" << " "; }
     536    if( startVolume != 0)
     537      { G4cout << std::setw(12) << startVolume->GetName() << " "; }
     538    G4cout.precision(oldprec);
     539    G4cout << G4endl;
     540  }
     541  else // if( verboseLevel > 3 )
     542  {
     543    //  Multi-line output
     544     
     545    G4cout << "Step taken was " << step_len 
     546           << " out of PhysicalStep = " <<  requestStep << G4endl;
     547    G4cout << "Final safety is: " << safety << G4endl;
     548    G4cout << "Chord length = " << (CurrentPosition-StartPosition).mag()
     549           << G4endl;
     550    G4cout << G4endl;
     551  }
    570552}
    571553

  • trunk/source/geometry/navigation/src/G4RegularNavigation.cc

    r1058 r1347  
    2525//
    2626//
    27 // $Id: G4RegularNavigation.cc,v 1.9 2009/01/27 09:31:29 gcosmo Exp $
     27// $Id: G4RegularNavigation.cc,v 1.15 2010/11/19 15:13:39 gcosmo Exp $
    2828// GEANT4 tag $ Name:$
    2929//
    … …  
    4545//------------------------------------------------------------------
    4646G4RegularNavigation::G4RegularNavigation()
    47   : fVerbose(1), fCheck(true)
     47  : fverbose(false), fcheck(false), fnormalNav(0)
    4848{
    4949  kCarTolerance = G4GeometryTolerance::GetInstance()->GetSurfaceTolerance();
    … …  
    122122//------------------------------------------------------------------
    123123G4double G4RegularNavigation::ComputeStepSkippingEqualMaterials(
    124                                 G4ThreeVector localPoint,
     124                                      G4ThreeVector& localPoint,
    125125                                const G4ThreeVector& localDirection,
    126126                                const G4double currentProposedStepLength,
    … …  
    291291                                  const G4ThreeVector& globalPoint,
    292292                                  const G4ThreeVector* globalDirection,
    293                                   const G4bool pLocatedOnEdge,
     293                                  const G4bool, // pLocatedOnEdge,
    294294                                  G4ThreeVector& localPoint )
    295295{
    296   G4SmartVoxelHeader *motherVoxelHeader;
    297296  G4VPhysicalVolume *motherPhysical, *pPhysical;
    298297  G4PhantomParameterisation *pParam;
    299298  G4LogicalVolume *motherLogical;
    300   G4VSolid *pSolid;
    301299  G4ThreeVector localDir;
    302300  G4int replicaNo;
    … …  
    304302  motherPhysical = history.GetTopVolume();
    305303  motherLogical = motherPhysical->GetLogicalVolume();
    306   motherVoxelHeader = motherLogical->GetVoxelHeader();
    307304 
    308305  pPhysical = motherLogical->GetDaughter(0);
    309306  pParam = (G4PhantomParameterisation*)(pPhysical->GetParameterisation());
    310307 
    311   pSolid = pParam->GetContainerSolid();
    312  
    313308  // Save parent history in touchable history
    314309  // ... for use as parent t-h in ComputeMaterial method of param
    … …  
    327322  }
    328323
    329   // Check that track is not on the surface and check that track is not
    330   // exiting the voxel parent volume
    331   //
    332   if ( !G4AuxiliaryNavServices::CheckPointOnSurface(pSolid, localPoint,
    333           globalDirection, history.GetTopTransform(), pLocatedOnEdge)
    334      || G4AuxiliaryNavServices::CheckPointExiting(pSolid, localPoint,
    335           globalDirection, history.GetTopTransform() ) )
    336   {
    337   }
    338   else
    339   {
    340     // Enter this daughter
    341     //
    342     replicaNo = pParam->GetReplicaNo( localPoint, localDir );
    343 
    344     if( replicaNo < 0 || replicaNo >= G4int(pParam->GetNoVoxel()) )
    345     {
    346       return false;
    347     }
    348 
    349     // Set the correct copy number in physical
    350     //
    351     pPhysical->SetCopyNo(replicaNo);
    352     pParam->ComputeTransformation(replicaNo,pPhysical);
    353 
    354     history.NewLevel(pPhysical, kParameterised, replicaNo );
    355     localPoint = history.GetTopTransform().TransformPoint(globalPoint);
    356 
    357     // Set the correct solid and material in Logical Volume
    358     //
    359     G4LogicalVolume *pLogical = pPhysical->GetLogicalVolume();
     324  // Enter this daughter
     325  //
     326  replicaNo = pParam->GetReplicaNo( localPoint, localDir );
     327
     328  if( replicaNo < 0 || replicaNo >= G4int(pParam->GetNoVoxel()) )
     329  {
     330    return false;
     331  }
     332
     333  // Set the correct copy number in physical
     334  //
     335  pPhysical->SetCopyNo(replicaNo);
     336  pParam->ComputeTransformation(replicaNo,pPhysical);
     337
     338  history.NewLevel(pPhysical, kParameterised, replicaNo );
     339  localPoint = history.GetTopTransform().TransformPoint(globalPoint);
     340
     341  // Set the correct solid and material in Logical Volume
     342  //
     343  G4LogicalVolume *pLogical = pPhysical->GetLogicalVolume();
    360344     
    361     pLogical->UpdateMaterial(pParam->ComputeMaterial(replicaNo,
    362                              pPhysical, &parentTouchable) );
    363     return true;
    364   }
    365 
    366   return false;
    367 }
     345  pLogical->UpdateMaterial(pParam->ComputeMaterial(replicaNo,
     346                           pPhysical, &parentTouchable) );
     347  return true;
     348}

  • trunk/source/geometry/navigation/src/G4ReplicaNavigation.cc

    r1337 r1347  
    2525//
    2626//
    27 // $Id: G4ReplicaNavigation.cc,v 1.19 2008/04/28 15:39:55 gcosmo Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     27// $Id: G4ReplicaNavigation.cc,v 1.20 2010/07/13 15:59:42 gcosmo Exp $
     28// GEANT4 tag $Name: geant4-09-04-ref-00 $
    2929//
    3030//
    … …  
    10391039    G4Exception("G4ReplicaNavigation::BackLocate()", "InvalidSetup",
    10401040                FatalException, "The World volume must be a Placement!");
     1041    return kInside;
    10411042  }
    10421043

  • trunk/source/geometry/navigation/src/G4SimpleLocator.cc

    r1337 r1347  
    2424// ********************************************************************
    2525//
    26 // $Id: G4SimpleLocator.cc,v 1.5 2008/12/11 10:27:58 tnikitin Exp $
    27 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     26// $Id: G4SimpleLocator.cc,v 1.6 2010/07/13 15:59:42 gcosmo Exp $
     27// GEANT4 tag $Name: geant4-09-04-ref-00 $
    2828//
    2929// Class G4SimpleLocator implementation
    … …  
    105105
    106106  G4int substep_no = 0;
     107
     108  G4int oldprc;  // cout/cerr precision settings
    107109
    108110  // Limits for substep number
    … …  
    358360                  << GetEpsilonStepFor() << G4endl;
    359361         }
    360          G4cerr.precision(20);
     362         oldprc = G4cerr.precision(20);
    361363         G4cerr << " Point A (Curve start)   is " << CurveStartPointVelocity
    362364                << G4endl;
    … …  
    373375         G4cerr << "        LocateIntersection parameters are : Substep no= "
    374376                << substep_no << G4endl;
     377         G4cerr.precision(oldprc);
    375378
    376379         G4Exception("G4SimpleLocator::EstimateIntersectionPoint()",
    … …  
    452455                 -1.0, NewSafety, substep_no);
    453456    G4cout << G4endl;
    454     G4cout.precision( 10 );
     457    oldprc = G4cout.precision(10);
    455458    G4double done_len = CurrentA_PointVelocity.GetCurveLength();
    456459    G4double full_len = CurveEndPointVelocity.GetCurveLength();
    … …  
    460463           << " out of " << full_len << " required." << G4endl;
    461464    G4cout << "        Remaining length = " << full_len - done_len << G4endl;
     465    G4cout.precision(oldprc);
    462466
    463467    G4Exception("G4SimpleLocator::EstimateIntersectionPoint()",
    … …  
    467471  else if( substep_no >= warn_substeps )
    468472  { 
    469     G4int oldprc= G4cout.precision( 10 );
     473    oldprc= G4cout.precision(10);
    470474    G4cout << "WARNING - G4SimpleLocator::EstimateIntersectionPoint()"
    471475           << G4endl
    … …  
    475479           << "          Warning level = " << warn_substeps
    476480           << " and maximum substeps = " << max_substeps << G4endl;
     481    G4cout.precision(oldprc);
    477482    G4Exception("G4SimpleLocator::EstimateIntersectionPoint()",
    478483                "DifficultyToLocateIntersection", JustWarning,
    479484                "Many substeps while trying to locate intersection.");
    480     G4cout.precision( oldprc );
    481485  }
    482486  return  !there_is_no_intersection; //  Success or failure

  • trunk/source/geometry/navigation/src/G4TransportationManager.cc

    r1337 r1347  
    2525//
    2626//
    27 // $Id: G4TransportationManager.cc,v 1.15 2007/04/12 11:51:48 vnivanch Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     27// $Id: G4TransportationManager.cc,v 1.16 2010/07/13 15:59:42 gcosmo Exp $
     28// GEANT4 tag $Name: geant4-09-04-ref-00 $
    2929//
    3030//
    … …  
    5656G4TransportationManager::G4TransportationManager()
    5757{
    58   if (!fTransportationManager)
    59   {
    60     // Create the navigator for tracking and activate it; add to collections
    61     //
    62     G4Navigator* trackingNavigator = new G4Navigator();
    63     trackingNavigator->Activate(true);
    64     fNavigators.push_back(trackingNavigator);
    65     fActiveNavigators.push_back(trackingNavigator);
    66     fWorlds.push_back(trackingNavigator->GetWorldVolume()); // NULL registered
    67 
    68     fGeomMessenger     = new G4GeometryMessenger(this);
    69     fFieldManager      = new G4FieldManager();
    70     fPropagatorInField = new G4PropagatorInField(trackingNavigator,
    71                                                  fFieldManager);
    72     fSafetyHelper      = new G4SafetyHelper();
    73   }
    74   else
     58  if (fTransportationManager)
    7559  {
    7660    G4cerr << "Only ONE instance of G4TransportationManager is allowed!"
    … …  
    8064                "Only ONE instance of G4TransportationManager is allowed!");
    8165  }
     66
     67  // Create the navigator for tracking and activate it; add to collections
     68  //
     69  G4Navigator* trackingNavigator = new G4Navigator();
     70  trackingNavigator->Activate(true);
     71  fNavigators.push_back(trackingNavigator);
     72  fActiveNavigators.push_back(trackingNavigator);
     73  fWorlds.push_back(trackingNavigator->GetWorldVolume()); // NULL registered
     74
     75  fGeomMessenger    = new G4GeometryMessenger(this);
     76  fFieldManager     = new G4FieldManager();
     77  fPropagatorInField= new G4PropagatorInField(trackingNavigator,fFieldManager);
     78  fSafetyHelper     = new G4SafetyHelper();
    8279}
    8380
    … …  
    329326   std::vector<G4Navigator*>::iterator pNav =
    330327     std::find(fNavigators.begin(), fNavigators.end(), aNavigator);
    331    if (pNav == fNavigators.end())
     328   if (pNav != fNavigators.end())
     329   {
     330      (*pNav)->Activate(false);
     331   }
     332   else
    332333   {
    333334      G4String message
    … …  
    337338                  "NoEffect", JustWarning, message);
    338339   }
    339    else
    340    {
    341       (*pNav)->Activate(false);
    342    }
     340
    343341   std::vector<G4Navigator*>::iterator pActiveNav =
    344342     std::find(fActiveNavigators.begin(), fActiveNavigators.end(), aNavigator);

  • trunk/source/geometry/navigation/src/G4VIntersectionLocator.cc

    r1337 r1347  
    2424// ********************************************************************
    2525//
    26 // $Id: G4VIntersectionLocator.cc,v 1.7 2009/11/27 15:21:59 japost Exp $
    27 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     26// $Id: G4VIntersectionLocator.cc,v 1.8 2010/07/13 15:59:42 gcosmo Exp $
     27// GEANT4 tag $Name: geant4-09-04-ref-00 $
    2828//
    2929// Class G4VIntersectionLocator implementation
    … …  
    8383
    8484  G4double step_len = CurrentFT.GetCurveLength() - StartFT.GetCurveLength();
    85      
     85  G4int oldprc;  // cout/cerr precision settings
     86
    8687  if( ((stepNo == 0) && (verboseLevel <3)) || (verboseLevel >= 3) )
    8788  {
    88     static G4int noPrecision= 4;
    89     G4cout.precision(noPrecision);
    90     // G4cout.setf(ios_base::fixed,ios_base::floatfield);
     89    oldprc = G4cout.precision(4);
    9190    G4cout << std::setw( 6)  << " "
    9291           << std::setw( 25) << " Current Position  and  Direction" << " "
    … …  
    10099           << std::setw( 7) << " N_y " << " "
    101100           << std::setw( 7) << " N_z " << " " ;
    102     //            << G4endl;
    103     G4cout     // << " >>> "
    104            << std::setw( 7) << " Delta|N|" << " "
    105       //   << std::setw( 7) << " Delta(N_z) " << " "
     101    G4cout << std::setw( 7) << " Delta|N|" << " "
    106102           << std::setw( 9) << "StepLen" << " " 
    107103           << std::setw(12) << "StartSafety" << " " 
    108104           << std::setw( 9) << "PhsStep" << " "; 
    109  
    110105    G4cout << G4endl;
     106    G4cout.precision(oldprc);
    111107  }
    112108  if((stepNo == 0) && (verboseLevel <=3))
    … …  
    126122       G4cout << std::setw( 5) << "Start" ;
    127123    }
    128     G4cout.precision(8);
     124    oldprc = G4cout.precision(8);
    129125    G4cout << std::setw(10) << CurrentFT.GetCurveLength() << " ";
    130     G4cout.precision(8);
    131126    G4cout << std::setw(10) << CurrentPosition.x() << " "
    132127           << std::setw(10) << CurrentPosition.y() << " "
    … …  
    136131           << std::setw( 7) << CurrentUnitVelocity.y() << " "
    137132           << std::setw( 7) << CurrentUnitVelocity.z() << " ";
    138      //  G4cout << G4endl;
    139      //     G4cout << " >>> " ;
    140      G4cout.precision(3);
    141      G4cout << std::setw( 7)
    142             << CurrentFT.GetMomentum().mag()- StartFT.GetMomentum().mag()
    143             << " ";
    144      //   << std::setw( 7)
    145      //   << CurrentUnitVelocity.z() - InitialUnitVelocity.z() << " ";
    146      G4cout << std::setw( 9) << step_len << " ";
    147      G4cout << std::setw(12) << safety << " ";
    148      if( requestStep != -1.0 )
    149      {
    150        G4cout << std::setw( 9) << requestStep << " ";
    151      }
    152      else
    153      {
    154        G4cout << std::setw( 9) << "Init/NotKnown" << " ";
    155      }
    156      G4cout << G4endl;
    157    }
    158    else // if( verboseLevel > 3 )
    159    {
    160      //  Multi-line output
     133    G4cout.precision(3);
     134    G4cout << std::setw( 7)
     135           << CurrentFT.GetMomentum().mag()- StartFT.GetMomentum().mag()
     136           << " ";
     137    G4cout << std::setw( 9) << step_len << " ";
     138    G4cout << std::setw(12) << safety << " ";
     139    if( requestStep != -1.0 )
     140    {
     141      G4cout << std::setw( 9) << requestStep << " ";
     142    }
     143    else
     144    {
     145      G4cout << std::setw( 9) << "Init/NotKnown" << " ";
     146    }
     147    G4cout << G4endl;
     148    G4cout.precision(oldprc);
     149  }
     150  else // if( verboseLevel > 3 )
     151  {
     152    //  Multi-line output
    161153       
    162      G4cout << "Step taken was " << step_len 
    163             << " out of PhysicalStep= " <<  requestStep << G4endl;
    164      G4cout << "Final safety is: " << safety << G4endl;
    165 
    166      G4cout << "Chord length = " << (CurrentPosition-StartPosition).mag()
    167             << G4endl;
    168      G4cout << G4endl;
    169    }
     154    G4cout << "Step taken was " << step_len 
     155           << " out of PhysicalStep= " <<  requestStep << G4endl;
     156    G4cout << "Final safety is: " << safety << G4endl;
     157    G4cout << "Chord length = " << (CurrentPosition-StartPosition).mag()
     158           << G4endl;
     159    G4cout << G4endl;
     160  }
    170161}
    171162

  • trunk/source/geometry/navigation/src/G4VoxelNavigation.cc

    r1337 r1347  
    2525//
    2626//
    27 // $Id: G4VoxelNavigation.cc,v 1.9 2008/11/14 18:26:35 gcosmo Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     27// $Id: G4VoxelNavigation.cc,v 1.13 2010/11/04 18:18:00 japost Exp $
     28// GEANT4 tag $Name: geant4-09-04-ref-00 $
    2929//
    3030//
    … …  
    3737#include "G4VoxelNavigation.hh"
    3838#include "G4GeometryTolerance.hh"
     39#include "G4VoxelSafety.hh"
    3940
    4041// ********************************************************************
    … …  
    4344//
    4445G4VoxelNavigation::G4VoxelNavigation()
    45   : fVoxelDepth(-1),
     46  : fBList(), fVoxelDepth(-1),
    4647    fVoxelAxisStack(kNavigatorVoxelStackMax,kXAxis),
    4748    fVoxelNoSlicesStack(kNavigatorVoxelStackMax,0),
    … …  
    4950    fVoxelNodeNoStack(kNavigatorVoxelStackMax,0),
    5051    fVoxelHeaderStack(kNavigatorVoxelStackMax,(G4SmartVoxelHeader*)0),
    51     fVoxelNode(0),
    52     fCheck(false),
    53     fVerbose(0)
     52    fVoxelNode(0), fpVoxelSafety(0), fCheck(false), fBestSafety(false)
    5453{
    55   kCarTolerance = G4GeometryTolerance::GetInstance()->GetSurfaceTolerance();
     54  fLogger = new G4NavigationLogger("G4VoxelNavigation");
     55  fpVoxelSafety = new G4VoxelSafety ();
    5656}
    5757
    … …  
    6262G4VoxelNavigation::~G4VoxelNavigation()
    6363{
    64 #ifdef G4DEBUG_NAVIGATION
    65   G4cout << "G4VoxelNavigation::~G4VoxelNavigation() called." << G4endl;
    66 #endif
     64  delete fpVoxelSafety;
     65  delete fLogger;
    6766}
    6867
    … …  
    110109  if ( fCheck )
    111110  {
    112     if(fVerbose == 1 )
    113     {
    114       G4cout << "*** G4VoxelNavigation::ComputeStep(): ***" << G4endl
    115              << "    Invoked DistanceToOut(p) for mother solid: "
    116              << motherSolid->GetName()
    117              << ". Solid replied: " << motherSafety << G4endl
    118              << "    For local point p: " << localPoint
    119              << ", to be considered as 'mother safety'." << G4endl;
    120     }
    121     if( motherSafety < 0.0 )
    122     {
    123       G4cout << "ERROR - G4VoxelNavigation::ComputeStep()" << G4endl
    124              << "        Current solid " << motherSolid->GetName()
    125              << " gave negative safety: " << motherSafety << G4endl
    126              << "        for the current (local) point " << localPoint
    127              << G4endl;
    128       motherSolid->DumpInfo();
    129       G4Exception("G4VoxelNavigation::ComputeStep()",
    130                   "NegativeSafetyMotherVol", FatalException,
    131                   "Negative Safety In Voxel Navigation !" );
    132     }
    133     if( motherSolid->Inside(localPoint)==kOutside )
    134     {
    135       G4cout << "WARNING - G4VoxelNavigation::ComputeStep()" << G4endl
    136              << "          Point " << localPoint
    137              << " is outside current volume " << motherPhysical->GetName()
    138              << G4endl;
    139       G4double  estDistToSolid= motherSolid->DistanceToIn(localPoint);
    140       G4cout << "          Estimated isotropic distance to solid (distToIn)= "
    141              << estDistToSolid << G4endl;
    142       if( estDistToSolid > 100.0 * kCarTolerance )
    143       {
    144         motherSolid->DumpInfo();
    145         G4Exception("G4VoxelNavigation::ComputeStep()",
    146                     "FarOutsideCurrentVolume", FatalException,
    147                     "Point is far outside Current Volume !");
    148       }
    149       else
    150         G4Exception("G4VoxelNavigation::ComputeStep()", "OutsideCurrentVolume",
    151                     JustWarning, "Point is a little outside Current Volume.");
    152     }
     111    fLogger->PreComputeStepLog (motherPhysical, motherSafety, localPoint);
    153112  }
    154113#endif
    … …  
    204163                     sampleSolid->DistanceToIn(samplePoint);
    205164#ifdef G4VERBOSE
    206           if(( fCheck ) && ( fVerbose == 1 ))
     165          if( fCheck )
    207166          {
    208             G4cout << "*** G4VoxelNavigation::ComputeStep(): ***" << G4endl
    209                    << "    Invoked DistanceToIn(p) for daughter solid: "
    210                    << sampleSolid->GetName()
    211                    << ". Solid replied: " << sampleSafety << G4endl
    212                    << "    For local point p: " << samplePoint
    213                    << ", to be considered as 'daughter safety'." << G4endl;
     167            fLogger->PrintDaughterLog(sampleSolid,samplePoint,sampleSafety,0);
    214168          }
    215169#endif
    … …  
    224178                     sampleSolid->DistanceToIn(samplePoint, sampleDirection);
    225179#ifdef G4VERBOSE
    226             if(( fCheck ) && ( fVerbose == 1 ))
     180            if( fCheck )
    227181            {
    228               G4cout << "*** G4VoxelNavigation::ComputeStep(): ***" << G4endl
    229                      << "    Invoked DistanceToIn(p,v) for daughter solid: "
    230                      << sampleSolid->GetName()
    231                      << ". Solid replied: " << sampleStep << G4endl
    232                      << "    For local point p: " << samplePoint << G4endl
    233                      << "    Direction v: " << sampleDirection
    234                      << ", to be considered as 'daughter step'." << G4endl;
     182              fLogger->PrintDaughterLog(sampleSolid, samplePoint,
     183                                        sampleSafety, sampleStep);
    235184            }
    236185#endif
    … …  
    247196              // candidate.
    248197
    249               if ( ( fCheck ) && ( sampleStep < kInfinity ) )
     198              if ( fCheck )
    250199              {
    251                 G4ThreeVector intersectionPoint;
    252                 intersectionPoint= samplePoint + sampleStep * sampleDirection;
    253                 EInside insideIntPt= sampleSolid->Inside(intersectionPoint);
    254                 G4String solidResponse = "-kInside-";
    255                 if (insideIntPt == kOutside)
    256                   { solidResponse = "-kOutside-"; }
    257                 else if (insideIntPt == kSurface)
    258                   { solidResponse = "-kSurface-"; }
    259                 if( fVerbose == 1 )
    260                 {
    261                   G4cout << "*** G4VoxelNavigation::ComputeStep(): ***"<<G4endl
    262                          << "    Invoked Inside() for solid: "
    263                          << sampleSolid->GetName()
    264                          << ". Solid replied: " << solidResponse << G4endl
    265                          << "    For point p: " << intersectionPoint
    266                          << ", considered as 'intersection' point." << G4endl;
    267                 }
    268                 G4double safetyIn= -1, safetyOut= -1;  //  Set to invalid values
    269                 G4double newDistIn= -1,  newDistOut= -1;
    270                 if( insideIntPt != kInside )
    271                 {
    272                   safetyIn= sampleSolid->DistanceToIn(intersectionPoint);
    273                   newDistIn= sampleSolid->DistanceToIn(intersectionPoint,
    274                                                        sampleDirection);
    275                 }
    276                 if( insideIntPt != kOutside )
    277                 {
    278                   safetyOut= sampleSolid->DistanceToOut(intersectionPoint);
    279                   newDistOut= sampleSolid->DistanceToOut(intersectionPoint,
    280                                                          sampleDirection);
    281                 }
    282                 if( insideIntPt != kSurface )
    283                 {
    284                   G4int oldcoutPrec = G4cout.precision(16);
    285                   G4cout << "WARNING - G4VoxelNavigation::ComputeStep()"
    286                          << G4endl
    287                          << "          Inaccurate solid DistanceToIn"
    288                          << " for solid " << sampleSolid->GetName() << G4endl;
    289                   G4cout << "          Solid gave DistanceToIn = "
    290                          << sampleStep << " yet returns " << solidResponse
    291                          << " for this point !" << G4endl;
    292                   G4cout << "          Point = " << intersectionPoint << G4endl;
    293                   G4cout << "          Safety values: " << G4endl;
    294                   if ( insideIntPt != kInside )
    295                   {
    296                     G4cout << "          DistanceToIn(p)  = " << safetyIn
    297                            << G4endl;
    298                   }
    299                   if ( insideIntPt != kOutside )
    300                   {
    301                     G4cout << "          DistanceToOut(p) = " << safetyOut
    302                            << G4endl;
    303                   }
    304                   G4Exception("G4VoxelNavigation::ComputeStep()",
    305                               "InaccurateDistanceToIn", JustWarning,
    306                               "Conflicting response from Solid.");
    307                   G4cout.precision(oldcoutPrec);
    308                 }
    309                 else
    310                 { 
    311                   // If it is on the surface, *ensure* that either DistanceToIn
    312                   // or DistanceToOut returns a finite value ( >= Tolerance).
    313                   //
    314                   if( std::max( newDistIn, newDistOut ) <= kCarTolerance )
    315                   {
    316                     G4cout << "ERROR - G4VoxelNavigation::ComputeStep()"
    317                        << G4endl
    318                        << "  Identified point for which the solid "
    319                        << sampleSolid->GetName() << G4endl
    320                        << "  has MAJOR problem:  " << G4endl
    321                        << "  --> Both DistanceToIn(p,v) and DistanceToOut(p,v) "
    322                        << "return Zero, an equivalent value or negative value."
    323                        << G4endl;
    324                     G4cout << "    Solid: " << sampleSolid << G4endl;
    325                     G4cout << "    Point p= " << intersectionPoint << G4endl;
    326                     G4cout << "    Direction v= " << sampleDirection << G4endl;
    327                     G4cout << "    DistanceToIn(p,v)     = " << newDistIn
    328                            << G4endl;
    329                     G4cout << "    DistanceToOut(p,v,..) = " << newDistOut
    330                            << G4endl;
    331                     G4cout << "    Safety values: " << G4endl;
    332                     G4cout << "      DistanceToIn(p)  = " << safetyIn
    333                            << G4endl;
    334                     G4cout << "      DistanceToOut(p) = " << safetyOut
    335                            << G4endl;
    336                     G4Exception("G4VoxelNavigation::ComputeStep()",
    337                               "DistanceToInAndOutAreZero", FatalException,
    338                               "Zero from both Solid DistanceIn and Out(p,v).");
    339                   }
    340                 }
     200                fLogger->AlongComputeStepLog (sampleSolid, samplePoint,
     201                  sampleDirection, localDirection, sampleSafety, sampleStep);
    341202              }
    342203#endif
    … …  
    378239          if ( fCheck )
    379240          {
    380             if(fVerbose == 1)
    381             {
    382               G4cout << "*** G4VoxelNavigation::ComputeStep(): ***" << G4endl
    383                      << "    Invoked DistanceToOut(p,v,...) for mother solid: "
    384                      << motherSolid->GetName()
    385                      << ". Solid replied: " << motherStep << G4endl
    386                      << "    For local point p: " << localPoint << G4endl
    387                      << "    Direction v: " << localDirection
    388                      << ", to be considered as 'mother step'." << G4endl;
    389             }
    390             if( ( motherStep < 0.0 ) || ( motherStep >= kInfinity) )
    391             {
    392               G4int oldPrOut= G4cout.precision(16);
    393               G4int oldPrErr= G4cerr.precision(16);
    394               G4cerr << "ERROR - G4VoxelNavigation::ComputeStep()" << G4endl
    395                      << "        Problem in Navigation"  << G4endl
    396                      << "        Point (local coordinates): "
    397                      << localPoint << G4endl
    398                      << "        Local Direction: " << localDirection << G4endl
    399                      << "        Solid: " << motherSolid->GetName() << G4endl;
    400               motherSolid->DumpInfo();
    401               G4Exception("G4VoxelNavigation::ComputeStep()",
    402                           "PointOutsideCurrentVolume", FatalException,
    403                           "Current point is outside the current solid !");
    404               G4cout.precision(oldPrOut);
    405               G4cerr.precision(oldPrErr);
    406             }
     241            fLogger->PostComputeStepLog(motherSolid, localPoint, localDirection,
     242                                        motherStep, motherSafety);
    407243          }
    408244#endif
    … …  
    480316  }
    481317  else if (maxCurNodeNoDelta < minCurNodeNoDelta)
    482        {
    483          voxelSafety = maxCurNodeNoDelta*curNodeWidth;
    484          voxelSafety += maxCurCommonDelta;
    485         }
    486         else    // (maxCurNodeNoDelta == minCurNodeNoDelta)
    487         {
    488           voxelSafety = minCurNodeNoDelta*curNodeWidth;
    489           voxelSafety += std::min(minCurCommonDelta,maxCurCommonDelta);
    490         }
     318  {
     319    voxelSafety = maxCurNodeNoDelta*curNodeWidth;
     320    voxelSafety += maxCurCommonDelta;
     321  }
     322  else    // (maxCurNodeNoDelta == minCurNodeNoDelta)
     323  {
     324    voxelSafety = minCurNodeNoDelta*curNodeWidth;
     325    voxelSafety += std::min(minCurCommonDelta,maxCurCommonDelta);
     326  }
    491327
    492328  // Compute isotropic safety to boundaries of previous levels
    … …  
    552388 
    553389  G4double currentDistance = currentStep;
     390  static const G4double sigma = 0.5*G4GeometryTolerance::GetInstance()
     391                                    ->GetSurfaceTolerance();
    554392
    555393  // Determine if end of Step within current voxel
    … …  
    567405    minVal = workMinExtent+workNodeNo*workNodeWidth;
    568406
    569     if ( minVal<=workCoord+kCarTolerance*0.5 )
     407    if ( minVal<=workCoord+sigma )
    570408    {
    571409      maxVal = minVal+workNodeWidth;
    572       if ( maxVal<=workCoord-kCarTolerance*0.5 )
     410      if ( maxVal<=workCoord-sigma )
    573411      {
    574412        // Must consider next voxel
    … …  
    607445    minVal = workMinExtent+fVoxelNode->GetMinEquivalentSliceNo()*workNodeWidth;
    608446
    609     if ( minVal<=workCoord+kCarTolerance*0.5 )
     447    if ( minVal<=workCoord+sigma )
    610448    {
    611449      maxVal = workMinExtent+(fVoxelNode->GetMaxEquivalentSliceNo()+1)
    612450                            *workNodeWidth;
    613       if ( maxVal<=workCoord-kCarTolerance*0.5 )
     451      if ( maxVal<=workCoord-sigma )
    614452      {
    615453        newNodeNo = fVoxelNode->GetMaxEquivalentSliceNo()+1;
    … …  
    710548G4VoxelNavigation::ComputeSafety(const G4ThreeVector& localPoint,
    711549                                 const G4NavigationHistory& history,
    712                                  const G4double )
     550                                 const G4double       maxLength)
    713551{
    714552  G4VPhysicalVolume *motherPhysical, *samplePhysical;
    … …  
    725563  motherSolid = motherLogical->GetSolid();
    726564
     565  if( fBestSafety )
     566  {
     567    return fpVoxelSafety->ComputeSafety( localPoint,*motherPhysical,maxLength );
     568  }
     569
    727570  //
    728571  // Compute mother safety
    … …  
    733576
    734577#ifdef G4VERBOSE
    735   if(( fCheck ) && ( fVerbose == 1 ))
    736   {
    737     G4cout << "*** G4VoxelNavigation::ComputeSafety(): ***" << G4endl
    738            << "    Invoked DistanceToOut(p) for mother solid: "
    739            << motherSolid->GetName()
    740            << ". Solid replied: " << motherSafety << G4endl
    741            << "    For local point p: " << localPoint
    742            << ", to be considered as 'mother safety'." << G4endl;
     578  if( fCheck )
     579  {
     580    fLogger->ComputeSafetyLog (motherSolid, localPoint, motherSafety, true);
    743581  }
    744582#endif
    … …  
    772610    }
    773611#ifdef G4VERBOSE
    774     if(( fCheck ) && ( fVerbose == 1 ))
    775     {
    776       G4cout << "*** G4VoxelNavigation::ComputeSafety(): ***" << G4endl
    777              << "    Invoked DistanceToIn(p) for daughter solid: "
    778              << sampleSolid->GetName()
    779              << ". Solid replied: " << sampleSafety << G4endl
    780              << "    For local point p: " << samplePoint
    781              << ", to be considered as 'daughter safety'." << G4endl;
     612    if( fCheck )
     613    {
     614      fLogger->ComputeSafetyLog (sampleSolid,samplePoint,sampleSafety,false);
    782615    }
    783616#endif
    … …  
    790623  return ourSafety;
    791624}
     625
     626// ********************************************************************
     627// SetVerboseLevel
     628// ********************************************************************
     629//
     630void  G4VoxelNavigation::SetVerboseLevel(G4int level)
     631{
     632  if( fLogger )       fLogger->SetVerboseLevel(level);
     633  if( fpVoxelSafety)  fpVoxelSafety->SetVerboseLevel( level );
     634}

  • trunk/source/geometry/navigation/test/ApproxEqual.hh

    r1316 r1347  
    2626//
    2727// $Id: ApproxEqual.hh,v 1.4 2006/06/29 18:37:15 gunter Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-cand-01 $
     28// GEANT4 tag $Name: geant4-09-04-ref-00 $
    2929//
    3030

  • trunk/source/geometry/navigation/test/MyMultiNavigator.hh

    r1316 r1347  
    2626//
    2727// $Id: MyMultiNavigator.hh,v 1.1 2006/11/11 01:35:38 japost Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-cand-01 $
     28// GEANT4 tag $Name: geant4-09-04-ref-00 $
    2929//
    3030// Class to help test Multi-navigator geometry

  • trunk/source/geometry/navigation/test/testG4MultiNavigator1.cc

    r1316 r1347  
    2626//
    2727// $Id: testG4MultiNavigator1.cc,v 1.1 2006/11/11 01:35:38 japost Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-cand-01 $
     28// GEANT4 tag $Name: geant4-09-04-ref-00 $
    2929//
    3030//

  • trunk/source/geometry/navigation/test/testG4Navigator1.cc

    r1316 r1347  
    2626//
    2727// $Id: testG4Navigator1.cc,v 1.5 2006/06/29 18:37:17 gunter Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-cand-01 $
     28// GEANT4 tag $Name: geant4-09-04-ref-00 $
    2929//
    3030//

  • trunk/source/geometry/navigation/test/testG4Navigator2.cc

    r1316 r1347  
    2626//
    2727// $Id: testG4Navigator2.cc,v 1.6 2007/03/23 18:33:08 japost Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-cand-01 $
     28// GEANT4 tag $Name: geant4-09-04-ref-00 $
    2929//
    3030//

  • trunk/source/geometry/navigation/test/testG4Navigator3.cc

    r1316 r1347  
    2626//
    2727// $Id: testG4Navigator3.cc,v 1.5 2006/06/29 18:37:21 gunter Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-cand-01 $
     28// GEANT4 tag $Name: geant4-09-04-ref-00 $
    2929//
    3030//

  • trunk/source/geometry/navigation/test/testG4Navigator4.cc

    r1316 r1347  
    2626//
    2727// $Id: testG4Navigator4.cc,v 1.5 2006/06/29 18:37:23 gunter Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-cand-01 $
     28// GEANT4 tag $Name: geant4-09-04-ref-00 $
    2929//
    3030//

  • trunk/source/geometry/navigation/test/testG4Navigator5.cc

    r1316 r1347  
    2626//
    2727// $Id: testG4Navigator5.cc,v 1.6 2006/06/29 18:37:26 gunter Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-cand-01 $
     28// GEANT4 tag $Name: geant4-09-04-ref-00 $
    2929//
    3030//

  • trunk/source/geometry/navigation/test/testG4Navigator6.cc

    r1316 r1347  
    2626//
    2727// $Id: testG4Navigator6.cc,v 1.5 2006/06/29 18:37:28 gunter Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-cand-01 $
     28// GEANT4 tag $Name: geant4-09-04-ref-00 $
    2929//
    3030//

  • trunk/source/geometry/navigation/test/testG4NestedParameterisedNav.cc

    r1316 r1347  
    2626//
    2727// $Id: testG4NestedParameterisedNav.cc,v 1.6 2006/06/29 18:37:30 gunter Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-cand-01 $
     28// GEANT4 tag $Name: geant4-09-04-ref-00 $
    2929//
    3030//

  • trunk/source/geometry/navigation/test/testG4PathFinder.cc

    r1316 r1347  
    2626//
    2727// $Id: testG4PathFinder.cc,v 1.8 2007/02/13 16:15:34 japost Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-cand-01 $
     28// GEANT4 tag $Name: geant4-09-04-ref-00 $
    2929//
    3030//
Note: See TracChangeset for help on using the changeset viewer.