Changeset 1347 for trunk/source/geometry/navigation/src/G4NormalNavigation.cc

Timestamp:

Dec 22, 2010, 3:52:27 PM (13 years ago)

Author:

garnier

Message:

geant4 tag 9.4

File:

• trunk/source/geometry/navigation/src/G4NormalNavigation.cc (modified) (11 diffs)

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

@@ -25 +25 @@
 //
 //
-// $Id: G4NormalNavigation.cc,v 1.9 2007/05/11 13:43:59 gcosmo Exp $
-// GEANT4 tag $Name: geant4-09-04-beta-01 $
+// $Id: G4NormalNavigation.cc,v 1.11 2010/11/04 08:57:56 gcosmo Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 //
@@ -38 +38 @@
 #include "G4AffineTransform.hh"
 
-#include <iomanip>
-
 // ********************************************************************
 // Constructor
@@ -45 +43 @@
 //
 G4NormalNavigation::G4NormalNavigation()
-  : fCheck(false), fVerbose(0)
-{
+  : fCheck(false)
+{
+  fLogger = new G4NavigationLogger("G4NormalNavigation");
 }
 
@@ -54 +53 @@
 //
 G4NormalNavigation::~G4NormalNavigation()
-{;}
+{
+  delete fLogger;
+}
 
 // ********************************************************************
@@ -90 +91 @@
   
 #ifdef G4VERBOSE
-  static G4int precVerf= 20;  // Precision 
   if ( fCheck )
   {
-    if( fVerbose == 1 )
-    {
-      G4cout << "*** G4NormalNavigation::ComputeStep(): ***" << G4endl
-             << "    Invoked DistanceToOut(p) for mother solid: "
-             << motherSolid->GetName()
-             << ". Solid replied: " << motherSafety << G4endl
-             << "    For local point p: " << localPoint << G4endl
-             << "    To be considered as 'mother safety'." << G4endl;
-    }
-    if ( motherSafety < 0.0 )
-    {
-      G4cerr << "ERROR - G4NormalNavigation::ComputeStep()" << G4endl
-             << "        Current solid " << motherSolid->GetName()
-             << " gave negative safety: " << motherSafety << G4endl
-             << "        for the current (local) point " << localPoint
-             << G4endl;
-      motherSolid->DumpInfo();
-      G4Exception("G4NormalNavigation::ComputeStep()",
-                  "NegativeSafetyMotherVol", FatalException,
-                  "Negative Safety In Voxel Navigation !" );
-    }
-    if( motherSolid->Inside(localPoint)==kOutside )
-    {
-      G4cout << "WARNING - G4NormalNavigation::ComputeStep()" << G4endl
-             << "          Point " << localPoint
-             << " is outside current volume " << motherPhysical->GetName()
-             << G4endl;
-      G4double estDistToSolid= motherSolid->DistanceToIn(localPoint); 
-      G4cout << "          Estimated isotropic distance to solid (distToIn)= " 
-             << estDistToSolid << G4endl;
-      if( estDistToSolid > 100.0 * motherSolid->GetTolerance() )
-      {
-        motherSolid->DumpInfo();
-        G4Exception("G4NormalNavigation::ComputeStep()",
-                    "FarOutsideCurrentVolume", FatalException,
-                    "Point is far outside Current Volume !" ); 
-      }
-      else
-        G4Exception("G4NormalNavigation::ComputeStep()", "OutsideCurrentVolume", 
-                    JustWarning, "Point is a little outside Current Volume."); 
-    }
-
-    // Verification / verbosity
-    //
-    if ( fVerbose > 1 )
-    {
-      G4int oldprec = G4cout.precision(precVerf);
-      G4cout << " G4NormalNavigation::ComputeStep()"
-             << " - Information on mother / key daughters ..." << G4endl;
-      G4cout << " Type   " << std::setw(12) << "Solid-Name"   << " " 
-             << std::setw(3*(6+precVerf))   << " local point" << " "
-             << std::setw(4+precVerf)       << "solid-Safety" << " "
-             << std::setw(4+precVerf)       << "solid-Step"   << " "
-             << std::setw(17)               << "distance Method "
-             << std::setw(3*(6+precVerf))   << " local direction" << " "
-             << G4endl;
-      G4cout << " Mother " << std::setw(12) << motherSolid->GetName() << " "
-             << std::setw(4+precVerf)       << localPoint   << " "
-             << std::setw(4+precVerf)       << motherSafety << " "
-             << G4endl;
-      G4cout.precision(oldprec);
-    }
-
+    fLogger->PreComputeStepLog(motherPhysical, motherSafety, localPoint);
   }
 #endif
@@ -193 +131 @@
       const G4double sampleSafety =
               sampleSolid->DistanceToIn(samplePoint);
+#ifdef G4VERBOSE
+      if( fCheck )
+      {
+        fLogger->PrintDaughterLog(sampleSolid, samplePoint, sampleSafety, 0);
+      }
+#endif
       if ( sampleSafety<ourSafety )
       {
@@ -202 +146 @@
         const G4double sampleStep =
                 sampleSolid->DistanceToIn(samplePoint,sampleDirection);
-#ifdef G4VERBOSE
-        if(( fCheck ) && ( fVerbose == 1 ))
+
+#ifdef G4VERBOSE
+        if( fCheck )
         {
-          G4cout << "*** G4NormalNavigation::ComputeStep(): ***" << G4endl
-                 << "    Invoked DistanceToIn(p,v) for daughter solid: "
-                 << sampleSolid->GetName()
-                 << ". Solid replied: " << sampleStep << G4endl
-                 << "    For local point p: " << samplePoint << G4endl
-                 << "    Direction v: " << sampleDirection
-                 << ", to be considered as 'daughter step'." << G4endl;
+          fLogger->PrintDaughterLog(sampleSolid, samplePoint,
+                                    sampleSafety, sampleStep);
         }
 #endif
@@ -221 +161 @@
           *pBlockedPhysical = samplePhysical;
           blockedReplicaNo  = -1;
-
-#ifdef G4VERBOSE
-          // Check to see that the resulting point is indeed in/on volume.
-          // This check could eventually be made only for successful candidate.
-
-          if ( ( fCheck ) && ( sampleStep < kInfinity ) )
+#ifdef G4VERBOSE
+          if( fCheck )
           {
-            G4ThreeVector intersectionPoint;
-            intersectionPoint= samplePoint + sampleStep * sampleDirection;
-            EInside insideIntPt= sampleSolid->Inside(intersectionPoint); 
-            G4String solidResponse = "-kInside-";
-            if (insideIntPt == kOutside)
-              solidResponse = "-kOutside-";
-            else if (insideIntPt == kSurface)
-              solidResponse = "-kSurface-";
-            if( fVerbose == 1 )
-            {
-              G4cout << "*** G4NormalNavigation::ComputeStep(): ***" << G4endl
-                     << "    Invoked Inside() for solid: "
-                     << sampleSolid->GetName()
-                     << ". Solid replied: " << solidResponse << G4endl
-                     << "    For point p: " << intersectionPoint
-                     << ", considered as 'intersection' point." << G4endl;
-            }
-            if ( insideIntPt != kSurface )
-            {
-              G4int oldcoutPrec = G4cout.precision(16); 
-              G4cout << "WARNING - G4NormalNavigation::ComputeStep()" << G4endl
-                     << "          Inaccurate DistanceToIn for solid "
-                     << sampleSolid->GetName() << G4endl;
-              G4cout << "          Solid gave DistanceToIn = " << sampleStep
-                     << " yet returns " << solidResponse
-                     << " for this point !" << G4endl; 
-              G4cout << "          Point = " << intersectionPoint << G4endl;
-              if ( insideIntPt != kInside )
-                G4cout << "        DistanceToIn(p) = " 
-                       << sampleSolid->DistanceToIn(intersectionPoint)
-                       << G4endl;
-              if ( insideIntPt != kOutside ) 
-                G4cout << "        DistanceToOut(p) = " 
-                       << sampleSolid->DistanceToOut(intersectionPoint)
-                       << G4endl;
-              G4Exception("G4NormalNavigation::ComputeStep()", 
-                          "InaccurateDistanceToIn", JustWarning,
-                          "Navigator gets conflicting response from Solid."); 
-              G4cout.precision(oldcoutPrec);
-            }
-          }
-
-          // Verification / verbosity
-          //
-          if ( fVerbose > 1 )
-          {
-            G4int oldprec = G4cout.precision(precVerf);
-            G4cout << " Daught "
-                   << std::setw(12)         << sampleSolid->GetName() << " "
-                   << std::setw(4+precVerf) << samplePoint  << " "
-                   << std::setw(4+precVerf) << sampleSafety << " "
-                   << std::setw(4+precVerf) << sampleStep   << " "
-                   << std::setw(16)         << "distanceToIn" << " "
-                   << std::setw(4+precVerf) << localDirection << " "
-                   << G4endl;
-            G4cout.precision(oldprec);
+            fLogger->AlongComputeStepLog(sampleSolid, samplePoint,
+              sampleDirection, localDirection, sampleSafety, sampleStep);
           }
 #endif
@@ -313 +195 @@
       if ( fCheck )
       {
-        if( fVerbose == 1 )
-        {
-          G4cout << "*** G4NormalNavigation::ComputeStep(): ***" << G4endl
-                 << "    Invoked DistanceToOut(p,v,...) for mother solid: "
-                 << motherSolid->GetName()
-                 << ". Solid replied: " << motherStep << G4endl
-                 << "    For local point p: " << localPoint << G4endl
-                 << "    Direction v: " << localDirection
-                 << ", to be considered as 'mother step'." << G4endl;
-        }
-        if( ( motherStep < 0.0 ) || ( motherStep >= kInfinity) )
-        {
-          G4cerr << "ERROR - G4NormalNavigation::ComputeStep()" << G4endl
-                 << "        Problem in Navigation"  << G4endl
-                 << "        Point (local coordinates): "
-                 << localPoint << G4endl
-                 << "        Local Direction: " << localDirection << G4endl
-                 << "        Solid: " << motherSolid->GetName() << G4endl; 
-          motherSolid->DumpInfo();
-          G4Exception("G4NormalNavigation::ComputeStep()",
-                      "PointDistOutInvalid", FatalException,
-                      "Current point is outside the current solid !");
-        }
-      }
-      if ( fVerbose > 1 )
-      {
-        G4int oldprec = G4cout.precision(precVerf);
-        G4cout << " Mother " << std::setw(12) << motherSolid->GetName() << " "
-               << std::setw(4+precVerf)       << localPoint   << " "
-               << std::setw(4+precVerf)       << motherSafety << " "
-               << std::setw(4+precVerf)       << motherStep   << " "
-               << std::setw(16)               << "distanceToOut" << " "
-               << std::setw(4+precVerf)       << localDirection << " "
-               << G4endl;
-        G4cout.precision(oldprec);      
+        fLogger->PostComputeStepLog(motherSolid, localPoint, localDirection,
+                                    motherStep, motherSafety);
       }
 #endif
@@ -399 +248 @@
 
 #ifdef G4VERBOSE
-  if(( fCheck ) && ( fVerbose == 1 ))
-  {
-    G4cout << "*** G4NormalNavigation::ComputeSafety(): ***" << G4endl
-           << "    Invoked DistanceToOut(p) for mother solid: "
-           << motherSolid->GetName()
-           << ". Solid replied: " << motherSafety << G4endl
-           << "    For local point p: " << localPoint
-           << ", to be considered as 'mother safety'." << G4endl;
+  if( fCheck )
+  {
+    fLogger->ComputeSafetyLog(motherSolid, localPoint, motherSafety, true);
   }
 #endif
@@ -430 +274 @@
     }
 #ifdef G4VERBOSE
-    if(( fCheck ) && ( fVerbose == 1 ))
-    {
-      G4cout << "*** G4NormalNavigation::ComputeSafety(): ***" << G4endl
-             << "    Invoked DistanceToIn(p) for daughter solid: "
-             << sampleSolid->GetName()
-             << ". Solid replied: " << sampleSafety << G4endl
-             << "    For local point p: " << samplePoint
-             << ", to be considered as 'daughter safety'." << G4endl;
+    if(fCheck)
+    {
+      fLogger->ComputeSafetyLog(sampleSolid, samplePoint, sampleSafety, false);
     }
 #endif