G4VIntersectionLocator Class Reference

#include <G4VIntersectionLocator.hh>

Inheritance diagram for G4VIntersectionLocator:

G4BrentLocator G4MultiLevelLocator G4SimpleLocator

Public Member Functions

 G4VIntersectionLocator (G4Navigator *theNavigator)
virtual ~G4VIntersectionLocator ()
virtual G4bool EstimateIntersectionPoint (const G4FieldTrack &curveStartPointTangent, const G4FieldTrack &curveEndPointTangent, const G4ThreeVector &trialPoint, G4FieldTrack &intersectPointTangent, G4bool &recalculatedEndPoint, G4double &fPreviousSafety, G4ThreeVector &fPreviousSftOrigin)=0
void printStatus (const G4FieldTrack &startFT, const G4FieldTrack &currentFT, G4double requestStep, G4double safety, G4int step)
G4bool IntersectChord (const G4ThreeVector &StartPointA, const G4ThreeVector &EndPointB, G4double &NewSafety, G4double &PreviousSafety, G4ThreeVector &PreviousSftOrigin, G4double &LinearStepLength, G4ThreeVector &IntersectionPoint, G4bool *calledNavigator=0)
void SetEpsilonStepFor (G4double EpsilonStep)
void SetDeltaIntersectionFor (G4double deltaIntersection)
void SetNavigatorFor (G4Navigator *fNavigator)
void SetChordFinderFor (G4ChordFinder *fCFinder)
void SetVerboseFor (G4int fVerbose)
G4int GetVerboseFor ()
G4double GetDeltaIntersectionFor ()
G4double GetEpsilonStepFor ()
G4NavigatorGetNavigatorFor ()
G4ChordFinderGetChordFinderFor ()
void SetSafetyParametersFor (G4bool UseSafety)
void AddAdjustementOfFoundIntersection (G4bool UseCorrection)
G4bool GetAdjustementOfFoundIntersection ()
void AdjustIntersections (G4bool UseCorrection)
G4bool AreIntersectionsAdjusted ()

Protected Member Functions

G4FieldTrack ReEstimateEndpoint (const G4FieldTrack &CurrentStateA, const G4FieldTrack &EstimtdEndStateB, G4double linearDistSq, G4double curveDist)
G4ThreeVector GetSurfaceNormal (const G4ThreeVector &CurrentInt_Point, G4bool &validNormal)
G4ThreeVector GetGlobalSurfaceNormal (const G4ThreeVector &CurrentE_Point, G4bool &validNormal)
G4bool AdjustmentOfFoundIntersection (const G4ThreeVector &A, const G4ThreeVector &CurrentE_Point, const G4ThreeVector &CurrentF_Point, const G4ThreeVector &MomentumDir, const G4bool IntersectAF, G4ThreeVector &IntersectionPoint, G4double &NewSafety, G4double &fPrevSafety, G4ThreeVector &fPrevSftOrigin)
void ReportTrialStep (G4int step_no, const G4ThreeVector &ChordAB_v, const G4ThreeVector &ChordEF_v, const G4ThreeVector &NewMomentumDir, const G4ThreeVector &NormalAtEntry, G4bool validNormal)

Protected Attributes

G4double kCarTolerance
G4int fVerboseLevel
G4bool fUseNormalCorrection
G4NavigatorfiNavigator
G4ChordFinderfiChordFinder
G4double fiEpsilonStep
G4double fiDeltaIntersection
G4bool fiUseSafety
G4NavigatorfHelpingNavigator
G4TouchableHistoryfpTouchable

Detailed Description

Definition at line 56 of file G4VIntersectionLocator.hh.


Constructor & Destructor Documentation

G4VIntersectionLocator::G4VIntersectionLocator ( G4Navigator theNavigator  ) 

Definition at line 46 of file G4VIntersectionLocator.cc.

References fHelpingNavigator, fVerboseLevel, G4GeometryTolerance::GetInstance(), G4GeometryTolerance::GetSurfaceTolerance(), and kCarTolerance.

00046                                                                         : 
00047   fUseNormalCorrection(false), 
00048   fiNavigator( theNavigator ),
00049   fiChordFinder( 0 ),            // Not set - overridden at each step
00050   fiEpsilonStep( -1.0 ),         // Out of range - overridden at each step
00051   fiDeltaIntersection( -1.0 ),   // Out of range - overridden at each step
00052   fiUseSafety(false),            // Default - overridden at each step
00053   fpTouchable(0)           
00054 {
00055   kCarTolerance = G4GeometryTolerance::GetInstance()->GetSurfaceTolerance();
00056   fVerboseLevel = 0;
00057   fHelpingNavigator = new G4Navigator();
00058 }      

G4VIntersectionLocator::~G4VIntersectionLocator (  )  [virtual]

Definition at line 64 of file G4VIntersectionLocator.cc.

References fHelpingNavigator, and fpTouchable.

00065 {
00066   delete fHelpingNavigator;
00067   delete fpTouchable;
00068 }


Member Function Documentation

void G4VIntersectionLocator::AddAdjustementOfFoundIntersection ( G4bool  UseCorrection  )  [inline]

Definition at line 66 of file G4VIntersectionLocator.icc.

References fUseNormalCorrection.

00067 {
00068   fUseNormalCorrection=UseCorrection;
00069 }

void G4VIntersectionLocator::AdjustIntersections ( G4bool  UseCorrection  )  [inline]

G4bool G4VIntersectionLocator::AdjustmentOfFoundIntersection ( const G4ThreeVector A,
const G4ThreeVector CurrentE_Point,
const G4ThreeVector CurrentF_Point,
const G4ThreeVector MomentumDir,
const G4bool  IntersectAF,
G4ThreeVector IntersectionPoint,
G4double NewSafety,
G4double fPrevSafety,
G4ThreeVector fPrevSftOrigin 
) [protected]

Definition at line 348 of file G4VIntersectionLocator.cc.

References fVerboseLevel, G4cerr, G4endl, GetGlobalSurfaceNormal(), GetNavigatorFor(), IntersectChord(), kCarTolerance, G4InuclParticleNames::lambda, and G4Navigator::LocateGlobalPointWithinVolume().

Referenced by G4SimpleLocator::EstimateIntersectionPoint(), G4MultiLevelLocator::EstimateIntersectionPoint(), and G4BrentLocator::EstimateIntersectionPoint().

00357 {     
00358   G4double dist,lambda;
00359   G4ThreeVector Normal, NewPoint, Point_G;
00360   G4bool goodAdjust=false, Intersects_FP=false, validNormal=false;
00361 
00362   // Get SurfaceNormal of Intersecting Solid
00363   //
00364   Normal = GetGlobalSurfaceNormal(CurrentE_Point,validNormal);
00365   if(!validNormal) { return false; }
00366 
00367   // Intersection between Line and Plane
00368   //
00369   G4double n_d_m = Normal.dot(MomentumDir);
00370   if ( std::abs(n_d_m)>kCarTolerance )
00371   {
00372 #ifdef G4VERBOSE
00373     if ( fVerboseLevel>1 )
00374     {
00375       G4cerr << "WARNING - "
00376              << "G4VIntersectionLocator::AdjustementOfFoundIntersection()"
00377              << G4endl
00378              << "        No intersection. Parallels lines!" << G4endl;
00379     }
00380 #endif
00381     lambda =- Normal.dot(CurrentF_Point-CurrentE_Point)/n_d_m;
00382 
00383     // New candidate for Intersection
00384     //
00385     NewPoint = CurrentF_Point+lambda*MomentumDir;
00386 
00387     // Distance from CurrentF to Calculated Intersection
00388     //
00389     dist = std::abs(lambda);
00390 
00391     if ( dist<kCarTolerance*0.001 )  { return false; }
00392 
00393     // Calculation of new intersection point on the path.
00394     //
00395     if ( IntersectAF )  //  First part intersects
00396     {
00397       G4double stepLengthFP; 
00398       G4ThreeVector Point_P = CurrentA_Point;
00399       GetNavigatorFor()->LocateGlobalPointWithinVolume(Point_P);
00400       Intersects_FP = IntersectChord( Point_P, NewPoint, NewSafety,
00401                                       fPreviousSafety, fPreviousSftOrigin,
00402                                       stepLengthFP, Point_G );
00403 
00404     }
00405     else   // Second part intersects
00406     {      
00407       G4double stepLengthFP; 
00408       GetNavigatorFor()->LocateGlobalPointWithinVolume(CurrentF_Point );
00409       Intersects_FP = IntersectChord( CurrentF_Point, NewPoint, NewSafety,
00410                                       fPreviousSafety, fPreviousSftOrigin,
00411                                       stepLengthFP, Point_G );
00412     }
00413     if ( Intersects_FP )
00414     {
00415       goodAdjust = true;
00416       IntersectionPoint = Point_G;              
00417     }
00418   }
00419 
00420   return goodAdjust;
00421 }

G4bool G4VIntersectionLocator::AreIntersectionsAdjusted (  )  [inline]

Definition at line 125 of file G4VIntersectionLocator.hh.

References fUseNormalCorrection.

00125 { return fUseNormalCorrection; }  

virtual G4bool G4VIntersectionLocator::EstimateIntersectionPoint ( const G4FieldTrack curveStartPointTangent,
const G4FieldTrack curveEndPointTangent,
const G4ThreeVector trialPoint,
G4FieldTrack intersectPointTangent,
G4bool recalculatedEndPoint,
G4double fPreviousSafety,
G4ThreeVector fPreviousSftOrigin 
) [pure virtual]

Implemented in G4BrentLocator, G4MultiLevelLocator, and G4SimpleLocator.

G4bool G4VIntersectionLocator::GetAdjustementOfFoundIntersection (  )  [inline]

Definition at line 60 of file G4VIntersectionLocator.icc.

References fUseNormalCorrection.

Referenced by G4SimpleLocator::EstimateIntersectionPoint(), G4MultiLevelLocator::EstimateIntersectionPoint(), and G4BrentLocator::EstimateIntersectionPoint().

00061 {
00062   return fUseNormalCorrection;
00063 }

G4ChordFinder * G4VIntersectionLocator::GetChordFinderFor (  )  [inline]

Definition at line 50 of file G4VIntersectionLocator.icc.

References fiChordFinder.

Referenced by G4SimpleLocator::EstimateIntersectionPoint(), G4MultiLevelLocator::EstimateIntersectionPoint(), G4BrentLocator::EstimateIntersectionPoint(), and ReEstimateEndpoint().

00051 {
00052   return fiChordFinder;
00053 }

G4double G4VIntersectionLocator::GetDeltaIntersectionFor (  )  [inline]

Definition at line 35 of file G4VIntersectionLocator.icc.

References fiDeltaIntersection.

Referenced by G4BrentLocator::EstimateIntersectionPoint().

00036 {
00037   return fiDeltaIntersection;
00038 } 

G4double G4VIntersectionLocator::GetEpsilonStepFor (  )  [inline]

Definition at line 40 of file G4VIntersectionLocator.icc.

References fiEpsilonStep.

Referenced by G4SimpleLocator::EstimateIntersectionPoint(), G4MultiLevelLocator::EstimateIntersectionPoint(), G4BrentLocator::EstimateIntersectionPoint(), and ReEstimateEndpoint().

00041 {
00042   return fiEpsilonStep;
00043 }

G4ThreeVector G4VIntersectionLocator::GetGlobalSurfaceNormal ( const G4ThreeVector CurrentE_Point,
G4bool validNormal 
) [protected]

Definition at line 467 of file G4VIntersectionLocator.cc.

References fHelpingNavigator, G4endl, G4Exception(), G4Navigator::GetLocalToGlobalTransform(), JustWarning, G4AffineTransform::NetRotation(), G4AffineTransform::NetTranslation(), and G4AffineTransform::TransformAxis().

Referenced by AdjustmentOfFoundIntersection().

00469 {
00470   G4ThreeVector     localNormal=
00471       GetLocalSurfaceNormal( CurrentE_Point, validNormal );
00472   G4AffineTransform localToGlobal=           //  Must use the same Navigator !!
00473       fHelpingNavigator->GetLocalToGlobalTransform();
00474   G4ThreeVector     globalNormal =
00475     localToGlobal.TransformAxis( localNormal );
00476 
00477 #ifdef G4DEBUG_FIELD
00478   if( validNormal && ( std::fabs(globalNormal.mag2() - 1.0) > perThousand ) ) 
00479   {
00480     std::ostringstream message; 
00481     message << "**************************************************************"
00482             << G4endl;
00483     message << " Bad Normal in G4VIntersectionLocator::GetGlobalSurfaceNormal "
00484             << G4endl;
00485     message << "  * Constituents: " << G4endl;
00486     message << "    Local  Normal= " << localNormal << G4endl;
00487     message << "    Transform: " << G4endl
00488             << "      Net Translation= " << localToGlobal.NetTranslation()
00489             << G4endl
00490             << "      Net Rotation   = " << localToGlobal.NetRotation()
00491             << G4endl;
00492     message << "  * Result: " << G4endl;
00493     message << "     Global Normal= " << localNormal << G4endl;
00494     message << "**************************************************************"
00495             << G4endl;
00496     G4Exception("G4VIntersectionLocator::GetGlobalSurfaceNormal()",
00497                 "GeomNav1002", JustWarning, message);
00498   }
00499 #endif
00500 
00501   return globalNormal;
00502 }

G4Navigator * G4VIntersectionLocator::GetNavigatorFor (  )  [inline]

Definition at line 45 of file G4VIntersectionLocator.icc.

References fiNavigator.

Referenced by AdjustmentOfFoundIntersection(), G4SimpleLocator::EstimateIntersectionPoint(), G4MultiLevelLocator::EstimateIntersectionPoint(), G4BrentLocator::EstimateIntersectionPoint(), and IntersectChord().

00046 {
00047   return fiNavigator;
00048 }

G4ThreeVector G4VIntersectionLocator::GetSurfaceNormal ( const G4ThreeVector CurrentInt_Point,
G4bool validNormal 
) [protected]

Definition at line 424 of file G4VIntersectionLocator.cc.

References G4endl, G4Exception(), and JustWarning.

Referenced by G4SimpleLocator::EstimateIntersectionPoint(), G4MultiLevelLocator::EstimateIntersectionPoint(), and G4BrentLocator::EstimateIntersectionPoint().

00426 {
00427   G4ThreeVector NormalAtEntry; // ( -10. , -10., -10. ); 
00428 
00429   G4ThreeVector NormalAtEntryLast, NormalAtEntryGlobal, diffNormals;
00430   G4bool validNormalLast; 
00431 
00432   // Relies on a call to Navigator::ComputeStep in IntersectChord before
00433   // this call
00434   //
00435   NormalAtEntryLast = GetLastSurfaceNormal( CurrentInt_Point, validNormalLast );
00436     // May return valid=false in cases, including
00437     //  - if the candidate volume was not found (eg exiting world), or
00438     //  - a replica was involved -- determined the step size.
00439     // (This list is not complete.) 
00440 
00441 #ifdef G4DEBUG_FIELD
00442   if  ( validNormalLast
00443    && ( std::fabs(NormalAtEntryLast.mag2() - 1.0) > perThousand ) )
00444   {
00445     std::ostringstream message; 
00446     message << "G4VIntersectionLocator::GetSurfaceNormal -- identified problem."
00447             << G4endl;
00448     message << "PROBLEM: Normal is not unit - magnitude = "
00449             << NormalAtEntryLast.mag() << G4endl; 
00450     message << "   at trial intersection point " << CurrentInt_Point << G4endl;
00451     message << "   Obtained from Get *Last* Surface Normal." << G4endl; 
00452     G4Exception("G4VIntersectionLocator::GetGlobalSurfaceNormal()",
00453                 "GeomNav1002", JustWarning, message);
00454   }
00455 #endif
00456 
00457   if( validNormalLast ) 
00458   {
00459     NormalAtEntry=NormalAtEntryLast;  
00460   }
00461   validNormal  = validNormalLast;
00462 
00463   return NormalAtEntry;
00464 }

G4int G4VIntersectionLocator::GetVerboseFor (  )  [inline]

Definition at line 55 of file G4VIntersectionLocator.icc.

References fVerboseLevel.

00056 {
00057   return fVerboseLevel;
00058 }

G4bool G4VIntersectionLocator::IntersectChord ( const G4ThreeVector StartPointA,
const G4ThreeVector EndPointB,
G4double NewSafety,
G4double PreviousSafety,
G4ThreeVector PreviousSftOrigin,
G4double LinearStepLength,
G4ThreeVector IntersectionPoint,
G4bool calledNavigator = 0 
) [inline]

Definition at line 103 of file G4VIntersectionLocator.icc.

References G4Navigator::ComputeStep(), fiUseSafety, GetNavigatorFor(), and sqr().

Referenced by AdjustmentOfFoundIntersection(), G4SimpleLocator::EstimateIntersectionPoint(), G4MultiLevelLocator::EstimateIntersectionPoint(), G4BrentLocator::EstimateIntersectionPoint(), and G4PropagatorInField::IntersectChord().

00111 {
00112   G4bool CalledNavigator = false; 
00113 
00114   // Calculate the direction and length of the chord AB
00115 
00116   G4ThreeVector  ChordAB_Vector = EndPointB - StartPointA;
00117   G4double       ChordAB_Length = ChordAB_Vector.mag();  // Magnitude (norm)
00118   G4ThreeVector  ChordAB_Dir =    ChordAB_Vector.unit();
00119   G4bool intersects;
00120   G4ThreeVector OriginShift = StartPointA -  PreviousSftOrigin ;
00121   G4double      MagSqShift  = OriginShift.mag2() ;
00122   G4double      currentSafety;
00123 
00124   if( MagSqShift >= sqr(PreviousSafety) )
00125   {
00126     currentSafety = 0.0 ;
00127   }
00128   else
00129   {
00130     currentSafety = PreviousSafety - std::sqrt(MagSqShift) ;
00131   }
00132 
00133   if( fiUseSafety && (ChordAB_Length <= currentSafety) )
00134   {
00135     // The Step is guaranteed to be taken
00136 
00137     LinearStepLength = ChordAB_Length;
00138     intersects = false;
00139     NewSafety= currentSafety;
00140     CalledNavigator= false;
00141     // G4cout << " IntersectChord> Step 'guaranteed' taken:  safety= " << currentSafety << " chordAB-len= " << ChordAB_Length << G4endl;
00142   }
00143   else
00144   {
00145     // G4cout << " IntersectChord> Step asking Navigator:    safety= " << currentSafety << " chordAB-len= " << ChordAB_Length << G4endl;
00146     
00147     // Check whether any volumes are encountered by the chord AB
00148 
00149     LinearStepLength = GetNavigatorFor()->ComputeStep( StartPointA,
00150                                  ChordAB_Dir, ChordAB_Length, NewSafety );
00151     intersects = (LinearStepLength <= ChordAB_Length); 
00152        // G4Navigator contracts to return k_infinity if len==asked
00153        // and it did not find a surface boundary at that length
00154     
00155     // G4cout << "G4VIntersectionLocator:  intersect= " << intersects
00156     //       << " step= " << LinearStepLength << " Chord length= " << ChordAB_Length;
00157 
00158     LinearStepLength = std::min( LinearStepLength, ChordAB_Length);
00159     CalledNavigator = true; 
00160 
00161     // Save the last calculated safety!
00162 
00163     PreviousSftOrigin = StartPointA;
00164     PreviousSafety    = NewSafety;
00165 
00166     if( intersects )
00167     {
00168        // Intersection Point of chord AB and either volume A's surface 
00169        //                                or a daughter volume's surface ..
00170        IntersectionPoint = StartPointA + LinearStepLength * ChordAB_Dir;
00171     }
00172   }
00173   if( ptrCalledNavigator )
00174   { 
00175     *ptrCalledNavigator = CalledNavigator; 
00176   }
00177 
00178   return intersects;
00179 }

void G4VIntersectionLocator::printStatus ( const G4FieldTrack startFT,
const G4FieldTrack currentFT,
G4double  requestStep,
G4double  safety,
G4int  step 
)

Definition at line 75 of file G4VIntersectionLocator.cc.

References fVerboseLevel, G4cout, G4endl, G4FieldTrack::GetCurveLength(), G4FieldTrack::GetMomentum(), G4FieldTrack::GetMomentumDir(), and G4FieldTrack::GetPosition().

Referenced by G4SimpleLocator::EstimateIntersectionPoint(), G4MultiLevelLocator::EstimateIntersectionPoint(), and G4BrentLocator::EstimateIntersectionPoint().

00080 {
00081   const G4int verboseLevel= fVerboseLevel;
00082   const G4ThreeVector StartPosition       = StartFT.GetPosition();
00083   const G4ThreeVector StartUnitVelocity   = StartFT.GetMomentumDir();
00084   const G4ThreeVector CurrentPosition     = CurrentFT.GetPosition();
00085   const G4ThreeVector CurrentUnitVelocity = CurrentFT.GetMomentumDir();
00086 
00087   G4double step_len = CurrentFT.GetCurveLength() - StartFT.GetCurveLength();
00088   G4int oldprc;  // cout/cerr precision settings
00089 
00090   if( ((stepNo == 0) && (verboseLevel <3)) || (verboseLevel >= 3) )
00091   {
00092     oldprc = G4cout.precision(4);
00093     G4cout << std::setw( 6)  << " " 
00094            << std::setw( 25) << " Current Position  and  Direction" << " "
00095            << G4endl; 
00096     G4cout << std::setw( 5) << "Step#" 
00097            << std::setw(10) << "  s  " << " "
00098            << std::setw(10) << "X(mm)" << " "
00099            << std::setw(10) << "Y(mm)" << " "  
00100            << std::setw(10) << "Z(mm)" << " "
00101            << std::setw( 7) << " N_x " << " "
00102            << std::setw( 7) << " N_y " << " "
00103            << std::setw( 7) << " N_z " << " " ;
00104     G4cout << std::setw( 7) << " Delta|N|" << " "
00105            << std::setw( 9) << "StepLen" << " "  
00106            << std::setw(12) << "StartSafety" << " "  
00107            << std::setw( 9) << "PhsStep" << " ";  
00108     G4cout << G4endl;
00109     G4cout.precision(oldprc);
00110   }
00111   if((stepNo == 0) && (verboseLevel <=3))
00112   {
00113     // Recurse to print the start values
00114     //
00115     printStatus( StartFT, StartFT, -1.0, safety, -1);
00116   }
00117   if( verboseLevel <= 3 )
00118   {
00119     if( stepNo >= 0)
00120     {
00121        G4cout << std::setw( 4) << stepNo << " ";
00122     }
00123     else
00124     {
00125        G4cout << std::setw( 5) << "Start" ;
00126     }
00127     oldprc = G4cout.precision(8);
00128     G4cout << std::setw(10) << CurrentFT.GetCurveLength() << " "; 
00129     G4cout << std::setw(10) << CurrentPosition.x() << " "
00130            << std::setw(10) << CurrentPosition.y() << " "
00131            << std::setw(10) << CurrentPosition.z() << " ";
00132     G4cout.precision(4);
00133     G4cout << std::setw( 7) << CurrentUnitVelocity.x() << " "
00134            << std::setw( 7) << CurrentUnitVelocity.y() << " "
00135            << std::setw( 7) << CurrentUnitVelocity.z() << " ";
00136     G4cout.precision(3); 
00137     G4cout << std::setw( 7)
00138            << CurrentFT.GetMomentum().mag()- StartFT.GetMomentum().mag()
00139            << " "; 
00140     G4cout << std::setw( 9) << step_len << " "; 
00141     G4cout << std::setw(12) << safety << " ";
00142     if( requestStep != -1.0 )
00143     {
00144       G4cout << std::setw( 9) << requestStep << " ";
00145     }
00146     else
00147     {
00148       G4cout << std::setw( 9) << "Init/NotKnown" << " "; 
00149     }
00150     G4cout << G4endl;
00151     G4cout.precision(oldprc);
00152   }
00153   else // if( verboseLevel > 3 )
00154   {
00155     //  Multi-line output
00156        
00157     G4cout << "Step taken was " << step_len  
00158            << " out of PhysicalStep= " <<  requestStep << G4endl;
00159     G4cout << "Final safety is: " << safety << G4endl;
00160     G4cout << "Chord length = " << (CurrentPosition-StartPosition).mag()
00161            << G4endl;
00162     G4cout << G4endl; 
00163   }
00164 }

G4FieldTrack G4VIntersectionLocator::ReEstimateEndpoint ( const G4FieldTrack CurrentStateA,
const G4FieldTrack EstimtdEndStateB,
G4double  linearDistSq,
G4double  curveDist 
) [protected]

Definition at line 171 of file G4VIntersectionLocator.cc.

References G4MagInt_Driver::AccurateAdvance(), fVerboseLevel, G4cerr, G4cout, G4endl, GetChordFinderFor(), G4FieldTrack::GetCurveLength(), GetEpsilonStepFor(), G4ChordFinder::GetIntegrationDriver(), G4FieldTrack::GetPosition(), and kCarTolerance.

Referenced by G4SimpleLocator::EstimateIntersectionPoint(), G4MultiLevelLocator::EstimateIntersectionPoint(), and G4BrentLocator::EstimateIntersectionPoint().

00175 {  
00176   G4FieldTrack newEndPoint( CurrentStateA );
00177   G4MagInt_Driver* integrDriver= GetChordFinderFor()->GetIntegrationDriver(); 
00178 
00179   G4FieldTrack retEndPoint( CurrentStateA );
00180   G4bool goodAdvance;
00181   G4int  itrial=0;
00182   const G4int no_trials= 20;
00183 
00184   G4double endCurveLen= EstimatedEndStateB.GetCurveLength();
00185   do
00186   {
00187      G4double currentCurveLen= newEndPoint.GetCurveLength();
00188      G4double advanceLength= endCurveLen - currentCurveLen ; 
00189      if (std::abs(advanceLength)<kCarTolerance)
00190      {
00191        goodAdvance=true;
00192      }
00193      else{
00194      goodAdvance= 
00195        integrDriver->AccurateAdvance(newEndPoint, advanceLength,
00196                                      GetEpsilonStepFor());
00197      }
00198   }
00199   while( !goodAdvance && (++itrial < no_trials) );
00200 
00201   if( goodAdvance )
00202   {
00203     retEndPoint= newEndPoint; 
00204   }
00205   else
00206   {
00207     retEndPoint= EstimatedEndStateB; // Could not improve without major work !!
00208   }
00209 
00210   //  All the work is done
00211   //  below are some diagnostics only -- before the return!
00212   // 
00213   static const G4String MethodName("G4VIntersectionLocator::ReEstimateEndpoint");
00214 
00215 #ifdef G4VERBOSE
00216   G4int  latest_good_trials=0;
00217   if( itrial > 1)
00218   {
00219     if( fVerboseLevel > 0 )
00220     {
00221       G4cout << MethodName << " called - goodAdv= " << goodAdvance
00222              << " trials = " << itrial
00223              << " previous good= " << latest_good_trials
00224              << G4endl;
00225     }
00226     latest_good_trials=0; 
00227   }
00228   else
00229   {   
00230     latest_good_trials++; 
00231   }
00232 #endif
00233 
00234 #ifdef G4DEBUG_FIELD
00235   G4double lengthDone = newEndPoint.GetCurveLength() 
00236                       - CurrentStateA.GetCurveLength(); 
00237   if( !goodAdvance )
00238   {
00239     if( fVerboseLevel >= 3 )
00240     {
00241       G4cout << MethodName << "> AccurateAdvance failed " ;
00242       G4cout << " in " << itrial << " integration trials/steps. " << G4endl;
00243       G4cout << " It went only " << lengthDone << " instead of " << curveDist
00244              << " -- a difference of " << curveDist - lengthDone  << G4endl;
00245       G4cout << " ReEstimateEndpoint> Reset endPoint to original value!"
00246              << G4endl;
00247     }
00248   }
00249 
00250   static G4int noInaccuracyWarnings = 0; 
00251   G4int maxNoWarnings = 10;
00252   if (  (noInaccuracyWarnings < maxNoWarnings ) 
00253        || (fVerboseLevel > 1) )
00254     {
00255       G4cerr << "G4PropagatorInField::LocateIntersectionPoint():"
00256              << G4endl
00257              << " Warning: Integration inaccuracy requires" 
00258              <<   " an adjustment in the step's endpoint."  << G4endl
00259              << "   Two mid-points are further apart than their"
00260              <<   " curve length difference"                << G4endl 
00261              << "   Dist = "       << std::sqrt(linearDistSq)
00262              << " curve length = " << curveDist             << G4endl; 
00263       G4cerr << " Correction applied is " 
00264              << (newEndPoint.GetPosition()-EstimatedEndStateB.GetPosition()).mag()
00265              << G4endl;
00266     }
00267 #else
00268   // Statistics on the RMS value of the corrections
00269 
00270   static G4int    noCorrections=0;
00271   static G4double sumCorrectionsSq = 0;
00272   noCorrections++; 
00273   if( goodAdvance )
00274   {
00275     sumCorrectionsSq += (EstimatedEndStateB.GetPosition() - 
00276                          newEndPoint.GetPosition()).mag2();
00277   }
00278   linearDistSq -= curveDist; // To use linearDistSq ... !
00279 #endif
00280 
00281   return retEndPoint;
00282 }

void G4VIntersectionLocator::ReportTrialStep ( G4int  step_no,
const G4ThreeVector ChordAB_v,
const G4ThreeVector ChordEF_v,
const G4ThreeVector NewMomentumDir,
const G4ThreeVector NormalAtEntry,
G4bool  validNormal 
) [protected]

Definition at line 516 of file G4VIntersectionLocator.cc.

References G4cerr, G4cout, and G4endl.

Referenced by G4SimpleLocator::EstimateIntersectionPoint(), G4MultiLevelLocator::EstimateIntersectionPoint(), and G4BrentLocator::EstimateIntersectionPoint().

00522 {
00523   G4double       ABchord_length  = ChordAB_v.mag(); 
00524   G4double       MomDir_dot_Norm = NewMomentumDir.dot( NormalAtEntry ) ;
00525   G4double       MomDir_dot_ABchord;
00526   MomDir_dot_ABchord= (1.0 / ABchord_length) * NewMomentumDir.dot( ChordAB_v );
00527 
00528   std::ostringstream  outStream; 
00529   outStream // G4cout 
00530     << std::setw(6)  << " Step# "
00531     << std::setw(17) << " |ChordEF|(mag)" << "  "
00532     << std::setw(18) << " uMomentum.Normal" << "  "
00533     << std::setw(18) << " uMomentum.ABdir " << "  " 
00534     << std::setw(16) << " AB-dist         " << " " 
00535     << " Chord Vector (EF) " 
00536     << G4endl;
00537   outStream.precision(7); 
00538   outStream  // G4cout 
00539     << " " << std::setw(5)  << step_no           
00540     << " " << std::setw(18) << ChordEF_v.mag() 
00541     << " " << std::setw(18) << MomDir_dot_Norm    
00542     << " " << std::setw(18) << MomDir_dot_ABchord 
00543     << " " << std::setw(12) << ABchord_length     
00544     << " " << ChordEF_v
00545     << G4endl;
00546   outStream  // G4cout
00547     << " MomentumDir= " << " " << NewMomentumDir 
00548     << " Normal at Entry E= " << NormalAtEntry
00549     << " AB chord =   " << ChordAB_v
00550     << G4endl;
00551   G4cout << outStream.str();  // ostr_verbose;
00552 
00553   if( ( std::fabs(NormalAtEntry.mag2() - 1.0) > perThousand ) ) 
00554   {
00555     G4cerr << " PROBLEM in G4VIntersectionLocator::ReportTrialStep " << G4endl
00556            << "         Normal is not unit - mag=" <<  NormalAtEntry.mag() 
00557            << "         ValidNormalAtE = " << validNormal
00558            << G4endl; 
00559   }
00560   return; 
00561 }

void G4VIntersectionLocator::SetChordFinderFor ( G4ChordFinder fCFinder  )  [inline]

Definition at line 87 of file G4VIntersectionLocator.icc.

References fiChordFinder.

Referenced by G4PropagatorInField::RefreshIntersectionLocator().

00088 {
00089   fiChordFinder=fCFinder;
00090 }

void G4VIntersectionLocator::SetDeltaIntersectionFor ( G4double  deltaIntersection  )  [inline]

Definition at line 77 of file G4VIntersectionLocator.icc.

References fiDeltaIntersection.

Referenced by G4PropagatorInField::RefreshIntersectionLocator().

00078 {
00079   fiDeltaIntersection=deltaIntersection;
00080 }

void G4VIntersectionLocator::SetEpsilonStepFor ( G4double  EpsilonStep  )  [inline]

Definition at line 71 of file G4VIntersectionLocator.icc.

References fiEpsilonStep.

Referenced by G4PropagatorInField::RefreshIntersectionLocator().

00072 {
00073   fiEpsilonStep=EpsilonStep;
00074 }

void G4VIntersectionLocator::SetNavigatorFor ( G4Navigator fNavigator  )  [inline]

Definition at line 82 of file G4VIntersectionLocator.icc.

References fiNavigator.

Referenced by G4PropagatorInField::SetNavigatorForPropagating().

00083 {
00084   fiNavigator=fNavigator;
00085 }

void G4VIntersectionLocator::SetSafetyParametersFor ( G4bool  UseSafety  )  [inline]

Definition at line 92 of file G4VIntersectionLocator.icc.

References fiUseSafety.

Referenced by G4PropagatorInField::RefreshIntersectionLocator().

00093 {
00094   fiUseSafety=UseSafety;
00095 }

void G4VIntersectionLocator::SetVerboseFor ( G4int  fVerbose  )  [inline]

Definition at line 97 of file G4VIntersectionLocator.icc.

References fVerboseLevel.

00098 {
00099   fVerboseLevel=fVerbose;
00100 }


Field Documentation

G4Navigator* G4VIntersectionLocator::fHelpingNavigator [protected]

Definition at line 203 of file G4VIntersectionLocator.hh.

Referenced by G4VIntersectionLocator(), GetGlobalSurfaceNormal(), and ~G4VIntersectionLocator().

G4ChordFinder* G4VIntersectionLocator::fiChordFinder [protected]

Definition at line 196 of file G4VIntersectionLocator.hh.

Referenced by GetChordFinderFor(), and SetChordFinderFor().

G4double G4VIntersectionLocator::fiDeltaIntersection [protected]

Definition at line 198 of file G4VIntersectionLocator.hh.

Referenced by G4SimpleLocator::EstimateIntersectionPoint(), G4MultiLevelLocator::EstimateIntersectionPoint(), G4BrentLocator::EstimateIntersectionPoint(), GetDeltaIntersectionFor(), and SetDeltaIntersectionFor().

G4double G4VIntersectionLocator::fiEpsilonStep [protected]

Definition at line 197 of file G4VIntersectionLocator.hh.

Referenced by GetEpsilonStepFor(), and SetEpsilonStepFor().

G4Navigator* G4VIntersectionLocator::fiNavigator [protected]

Definition at line 194 of file G4VIntersectionLocator.hh.

Referenced by GetNavigatorFor(), and SetNavigatorFor().

G4bool G4VIntersectionLocator::fiUseSafety [protected]

Definition at line 199 of file G4VIntersectionLocator.hh.

Referenced by IntersectChord(), and SetSafetyParametersFor().

G4TouchableHistory* G4VIntersectionLocator::fpTouchable [protected]

Definition at line 206 of file G4VIntersectionLocator.hh.

Referenced by ~G4VIntersectionLocator().

G4bool G4VIntersectionLocator::fUseNormalCorrection [protected]

Definition at line 192 of file G4VIntersectionLocator.hh.

Referenced by AddAdjustementOfFoundIntersection(), AreIntersectionsAdjusted(), and GetAdjustementOfFoundIntersection().

G4int G4VIntersectionLocator::fVerboseLevel [protected]

Definition at line 191 of file G4VIntersectionLocator.hh.

Referenced by AdjustmentOfFoundIntersection(), G4SimpleLocator::EstimateIntersectionPoint(), G4MultiLevelLocator::EstimateIntersectionPoint(), G4BrentLocator::EstimateIntersectionPoint(), G4VIntersectionLocator(), GetVerboseFor(), printStatus(), ReEstimateEndpoint(), SetVerboseFor(), and G4BrentLocator::~G4BrentLocator().

G4double G4VIntersectionLocator::kCarTolerance [protected]

Definition at line 189 of file G4VIntersectionLocator.hh.

Referenced by AdjustmentOfFoundIntersection(), G4SimpleLocator::EstimateIntersectionPoint(), G4MultiLevelLocator::EstimateIntersectionPoint(), G4BrentLocator::EstimateIntersectionPoint(), G4VIntersectionLocator(), and ReEstimateEndpoint().


The documentation for this class was generated from the following files:
Generated on Mon May 27 17:53:44 2013 for Geant4 by  doxygen 1.4.7