G4PropagatorInField Class Reference

#include <G4PropagatorInField.hh>

Public Member Functions
	G4PropagatorInField (G4Navigator *theNavigator, G4FieldManager *detectorFieldMgr, G4VIntersectionLocator *vLocator=0)
	~G4PropagatorInField ()
G4double	ComputeStep (G4FieldTrack &pFieldTrack, G4double pCurrentProposedStepLength, G4double &pNewSafety, G4VPhysicalVolume *pPhysVol=0)
G4ThreeVector	EndPosition () const
G4ThreeVector	EndMomentumDir () const
G4bool	IsParticleLooping () const
G4double	GetEpsilonStep () const
void	SetEpsilonStep (G4double newEps)
void	SetChargeMomentumMass (G4double charge, G4double momentum, G4double pMass)
G4FieldManager *	FindAndSetFieldManager (G4VPhysicalVolume *pCurrentPhysVol)
G4ChordFinder *	GetChordFinder ()
G4int	SetVerboseLevel (G4int verbose)
G4int	GetVerboseLevel () const
G4int	Verbose () const
G4int	GetMaxLoopCount () const
void	SetMaxLoopCount (G4int new_max)
void	printStatus (const G4FieldTrack &startFT, const G4FieldTrack &currentFT, G4double requestStep, G4double safety, G4int step, G4VPhysicalVolume *startVolume)
G4FieldTrack	GetEndState () const
G4double	GetMinimumEpsilonStep () const
void	SetMinimumEpsilonStep (G4double newEpsMin)
G4double	GetMaximumEpsilonStep () const
void	SetMaximumEpsilonStep (G4double newEpsMax)
void	SetLargestAcceptableStep (G4double newBigDist)
G4double	GetLargestAcceptableStep ()
void	SetTrajectoryFilter (G4VCurvedTrajectoryFilter *filter)
std::vector< G4ThreeVector > *	GimmeTrajectoryVectorAndForgetIt () const
void	ClearPropagatorState ()
void	SetDetectorFieldManager (G4FieldManager *newGlobalFieldManager)
void	SetUseSafetyForOptimization (G4bool)
G4bool	GetUseSafetyForOptimization ()
G4bool	IntersectChord (const G4ThreeVector &StartPointA, const G4ThreeVector &EndPointB, G4double &NewSafety, G4double &LinearStepLength, G4ThreeVector &IntersectionPoint)
G4VIntersectionLocator *	GetIntersectionLocator ()
void	SetIntersectionLocator (G4VIntersectionLocator *pLocator)
G4double	GetDeltaIntersection () const
G4double	GetDeltaOneStep () const
G4FieldManager *	GetCurrentFieldManager ()
void	SetNavigatorForPropagating (G4Navigator *SimpleOrMultiNavigator)
G4Navigator *	GetNavigatorForPropagating ()
void	SetThresholdNoZeroStep (G4int noAct, G4int noHarsh, G4int noAbandon)
G4int	GetThresholdNoZeroSteps (G4int i)
G4double	GetZeroStepThreshold ()
void	SetZeroStepThreshold (G4double newLength)
void	RefreshIntersectionLocator ()
Protected Member Functions
void	PrintStepLengthDiagnostic (G4double currentProposedStepLength, G4double decreaseFactor, G4double stepTrial, const G4FieldTrack &aFieldTrack)

---

Detailed Description

Definition at line 64 of file G4PropagatorInField.hh.

---

Constructor & Destructor Documentation

G4PropagatorInField::G4PropagatorInField	(	G4Navigator *	theNavigator,
		G4FieldManager *	detectorFieldMgr,
		G4VIntersectionLocator *	vLocator = 0
	)

Definition at line 59 of file G4PropagatorInField.cc.

References G4cout, G4endl, G4GeometryTolerance::GetInstance(), G4FieldManager::GetMaximumEpsilonStep(), G4GeometryTolerance::GetSurfaceTolerance(), and RefreshIntersectionLocator().

  : 
    fMax_loop_count(1000),
    fUseSafetyForOptimisation(true),   // (false) is less sensitive to incorrect safety
    fZeroStepThreshold( 0.0 ),         // length of what is recognised as 'zero' step
    fDetectorFieldMgr(detectorFieldMgr), 
    fpTrajectoryFilter( 0 ),
    fNavigator(theNavigator),
    fCurrentFieldMgr(detectorFieldMgr),
    fSetFieldMgr(false),
    fCharge(0.0), fInitialMomentumModulus(0.0), fMass(0.0),
    End_PointAndTangent(G4ThreeVector(0.,0.,0.),
                        G4ThreeVector(0.,0.,0.),0.0,0.0,0.0,0.0,0.0),
    fParticleIsLooping(false),
    fNoZeroStep(0), 
    fVerboseLevel(0)
{
  if(fDetectorFieldMgr) { fEpsilonStep = fDetectorFieldMgr->GetMaximumEpsilonStep();}
  else                  { fEpsilonStep= 1.0e-5; } 
  fActionThreshold_NoZeroSteps = 2; 
  fSevereActionThreshold_NoZeroSteps = 10; 
  fAbandonThreshold_NoZeroSteps = 50; 
  fFull_CurveLen_of_LastAttempt = -1; 
  fLast_ProposedStepLength = -1;
  fLargestAcceptableStep = 1000.0 * meter;

  fPreviousSftOrigin= G4ThreeVector(0.,0.,0.);
  fPreviousSafety= 0.0;
  kCarTolerance = G4GeometryTolerance::GetInstance()->GetSurfaceTolerance();
  fZeroStepThreshold= std::max( 1.0e5 * kCarTolerance, 1.0e-1 * micrometer );

#ifdef G4DEBUG_FIELD
  G4cout << " PiF: Zero Step Threshold set to "
         << fZeroStepThreshold / millimeter
         << " mm." << G4endl;
  G4cout << " PiF:   Value of kCarTolerance = "
         << kCarTolerance / millimeter 
         << " mm. " << G4endl;
#endif 

  // Definding Intersection Locator and his parameters
  if(vLocator==0){
    fIntersectionLocator= new G4MultiLevelLocator(theNavigator);
    fAllocatedLocator=true;
  }else{
    fIntersectionLocator=vLocator;
    fAllocatedLocator=false;
  }
  RefreshIntersectionLocator();  //  Copy all relevant parameters 
}

G4PropagatorInField::~G4PropagatorInField

(

)

Definition at line 112 of file G4PropagatorInField.cc.

{
  if(fAllocatedLocator)delete  fIntersectionLocator; 
}

---

Member Function Documentation

void G4PropagatorInField::ClearPropagatorState

(

)

Definition at line 619 of file G4PropagatorInField.cc.

Referenced by G4Transportation::StartTracking(), G4ITTransportation::StartTracking(), and G4CoupledTransportation::StartTracking().

{
  // Goal: Clear all memory of previous steps,  cached information

  fParticleIsLooping= false;
  fNoZeroStep= 0;

  End_PointAndTangent= G4FieldTrack( G4ThreeVector(0.,0.,0.),
                                     G4ThreeVector(0.,0.,0.),
                                     0.0,0.0,0.0,0.0,0.0); 
  fFull_CurveLen_of_LastAttempt = -1; 
  fLast_ProposedStepLength = -1;

  fPreviousSftOrigin= G4ThreeVector(0.,0.,0.);
  fPreviousSafety= 0.0;
}

G4double G4PropagatorInField::ComputeStep	(	G4FieldTrack &	pFieldTrack,
		G4double	pCurrentProposedStepLength,
		G4double &	pNewSafety,
		G4VPhysicalVolume *	pPhysVol = 0
	)

Definition at line 131 of file G4PropagatorInField.cc.

References G4ChordFinder::AdvanceChordLimited(), G4VCurvedTrajectoryFilter::CreateNewTrajectorySegment(), FatalException, FindAndSetFieldManager(), G4cout, G4endl, G4Exception(), GetChordFinder(), G4FieldTrack::GetCurveLength(), G4FieldManager::GetDeltaOneStep(), G4VPhysicalVolume::GetLogicalVolume(), G4FieldManager::GetMaximumEpsilonStep(), G4FieldManager::GetMinimumEpsilonStep(), G4FieldTrack::GetMomentumDir(), G4VPhysicalVolume::GetName(), G4FieldTrack::GetPosition(), G4Navigator::GetWorldVolume(), IntersectChord(), JustWarning, G4Navigator::LocateGlobalPointWithinVolume(), printStatus(), PrintStepLengthDiagnostic(), RefreshIntersectionLocator(), G4ChordFinder::SetChargeMomentumMass(), SetEpsilonStep(), and G4VCurvedTrajectoryFilter::TakeIntermediatePoint().

Referenced by G4Transportation::AlongStepGetPhysicalInteractionLength(), and G4PathFinder::DoNextCurvedStep().

{  
  // If CurrentProposedStepLength is too small for finding Chords
  // then return with no action (for now - TODO: some action)
  //
  if(CurrentProposedStepLength<kCarTolerance)
  {
    return kInfinity;
  }

  // Introducing smooth trajectory display (jacek 01/11/2002)
  //
  if (fpTrajectoryFilter)
  {
    fpTrajectoryFilter->CreateNewTrajectorySegment();
  }

  // Parameters for adaptive Runge-Kutta integration
  
  G4double      h_TrialStepSize;        // 1st Step Size 
  G4double      TruePathLength = CurrentProposedStepLength;
  G4double      StepTaken = 0.0; 
  G4double      s_length_taken, epsilon ; 
  G4bool        intersects;
  G4bool        first_substep = true;

  G4double      NewSafety;
  fParticleIsLooping = false;

  // If not yet done, 
  //   Set the field manager to the local  one if the volume has one, 
  //                      or to the global one if not
  //
  if( !fSetFieldMgr ) fCurrentFieldMgr= FindAndSetFieldManager( pPhysVol ); 
  // For the next call, the field manager must again be set
  fSetFieldMgr= false;

  GetChordFinder()->SetChargeMomentumMass(fCharge,fInitialMomentumModulus,fMass);

 // Values for Intersection Locator has to be updated on each call for the
 // case that CurrentFieldManager has changed from the one of previous step
  RefreshIntersectionLocator();

  G4FieldTrack  CurrentState(pFieldTrack);
  G4FieldTrack  OriginalState = CurrentState;

  // If the Step length is "infinite", then an approximate-maximum Step
  // length (used to calculate the relative accuracy) must be guessed.
  //
  if( CurrentProposedStepLength >= fLargestAcceptableStep )
  {
    G4ThreeVector StartPointA, VelocityUnit;
    StartPointA  = pFieldTrack.GetPosition();
    VelocityUnit = pFieldTrack.GetMomentumDir();

    G4double trialProposedStep = 1.e2 * ( 10.0 * cm + 
      fNavigator->GetWorldVolume()->GetLogicalVolume()->
                  GetSolid()->DistanceToOut(StartPointA, VelocityUnit) );
    CurrentProposedStepLength= std::min( trialProposedStep,
                                           fLargestAcceptableStep ); 
  }
  epsilon = fCurrentFieldMgr->GetDeltaOneStep() / CurrentProposedStepLength;
  // G4double raw_epsilon= epsilon;
  G4double epsilonMin= fCurrentFieldMgr->GetMinimumEpsilonStep();
  G4double epsilonMax= fCurrentFieldMgr->GetMaximumEpsilonStep();; 
  if( epsilon < epsilonMin ) epsilon = epsilonMin;
  if( epsilon > epsilonMax ) epsilon = epsilonMax;
  SetEpsilonStep( epsilon );

  // G4cout << "G4PiF: Epsilon of current step - raw= " << raw_epsilon
  //        << " final= " << epsilon << G4endl;

  //  Shorten the proposed step in case of earlier problems (zero steps)
  // 
  if( fNoZeroStep > fActionThreshold_NoZeroSteps )
  {
    G4double stepTrial;

    stepTrial= fFull_CurveLen_of_LastAttempt; 
    if( (stepTrial <= 0.0) && (fLast_ProposedStepLength > 0.0) ) 
      stepTrial= fLast_ProposedStepLength; 

    G4double decreaseFactor = 0.9; // Unused default
    if(   (fNoZeroStep < fSevereActionThreshold_NoZeroSteps)
       && (stepTrial > 100.0*fZeroStepThreshold) )
    {
      // Attempt quick convergence
      //
      decreaseFactor= 0.25;
    } 
    else
    {
      // We are in significant difficulties, probably at a boundary that
      // is either geometrically sharp or between very different materials.
      // Careful decreases to cope with tolerance are required.
      //
      if( stepTrial > 100.0*fZeroStepThreshold )
        decreaseFactor = 0.35;     // Try decreasing slower
      else if( stepTrial > 30.0*fZeroStepThreshold )
        decreaseFactor= 0.5;       // Try yet slower decrease
      else if( stepTrial > 10.0*fZeroStepThreshold )
        decreaseFactor= 0.75;      // Try even slower decreases
      else
        decreaseFactor= 0.9;       // Try very slow decreases
     }
     stepTrial *= decreaseFactor;

#ifdef G4DEBUG_FIELD
     G4cout << " G4PropagatorInField::ComputeStep(): " << G4endl
            << "  Decreasing step -  " 
            << " decreaseFactor= " << std::setw(8) << decreaseFactor 
            << " stepTrial = "     << std::setw(18) << stepTrial << " "
            << " fZeroStepThreshold = " << fZeroStepThreshold << G4endl;
     PrintStepLengthDiagnostic(CurrentProposedStepLength, decreaseFactor,
                               stepTrial, pFieldTrack);
#endif
     if( stepTrial == 0.0 )  //  Change to make it < 0.1 * kCarTolerance ??
     {
       std::ostringstream message;
       message << "Particle abandoned due to lack of progress in field."
               << G4endl
               << "  Properties : " << pFieldTrack << G4endl
               << "  Attempting a zero step = " << stepTrial << G4endl
               << "  while attempting to progress after " << fNoZeroStep
               << " trial steps. Will abandon step.";
       G4Exception("G4PropagatorInField::ComputeStep()", "GeomNav1002",
                   JustWarning, message);
       fParticleIsLooping= true;
       return 0;  // = stepTrial;
     }
     if( stepTrial < CurrentProposedStepLength )
       CurrentProposedStepLength = stepTrial;
  }
  fLast_ProposedStepLength = CurrentProposedStepLength;

  G4int do_loop_count = 0; 
  do
  { 
    G4FieldTrack SubStepStartState = CurrentState;
    G4ThreeVector SubStartPoint = CurrentState.GetPosition(); 

    if( !first_substep) {
      fNavigator->LocateGlobalPointWithinVolume( SubStartPoint );
    }

    // How far to attempt to move the particle !
    //
    h_TrialStepSize = CurrentProposedStepLength - StepTaken;

    // Integrate as far as "chord miss" rule allows.
    //
    s_length_taken = GetChordFinder()->AdvanceChordLimited( 
                             CurrentState,    // Position & velocity
                             h_TrialStepSize,
                             fEpsilonStep,
                             fPreviousSftOrigin,
                             fPreviousSafety
                             );
    //  CurrentState is now updated with the final position and velocity. 

    fFull_CurveLen_of_LastAttempt = s_length_taken;

    G4ThreeVector  EndPointB = CurrentState.GetPosition(); 
    G4ThreeVector  InterSectionPointE;
    G4double       LinearStepLength;
 
    // Intersect chord AB with geometry
    intersects= IntersectChord( SubStartPoint, EndPointB, 
                                NewSafety,     LinearStepLength, 
                                InterSectionPointE );
    // E <- Intersection Point of chord AB and either volume A's surface 
    //                                  or a daughter volume's surface ..

    if( first_substep ) { 
       currentSafety = NewSafety;
    } // Updating safety in other steps is potential future extention

    if( intersects )
    {
       G4FieldTrack IntersectPointVelct_G(CurrentState);  // FT-Def-Construct

       // Find the intersection point of AB true path with the surface
       //   of vol(A), if it exists. Start with point E as first "estimate".
       G4bool recalculatedEndPt= false;
       
         G4bool found_intersection = fIntersectionLocator->
         EstimateIntersectionPoint( SubStepStartState, CurrentState, 
                                  InterSectionPointE, IntersectPointVelct_G,
                                  recalculatedEndPt,fPreviousSafety,fPreviousSftOrigin);
       intersects = intersects && found_intersection;
       if( found_intersection ) {        
          End_PointAndTangent= IntersectPointVelct_G;  // G is our EndPoint ...
          StepTaken = TruePathLength = IntersectPointVelct_G.GetCurveLength()
                                      - OriginalState.GetCurveLength();
       } else {
          // intersects= false;          // "Minor" chords do not intersect
          if( recalculatedEndPt ){
             CurrentState= IntersectPointVelct_G; 
          }
       }
    }
    if( !intersects )
    {
      StepTaken += s_length_taken; 
      // For smooth trajectory display (jacek 01/11/2002)
      if (fpTrajectoryFilter) {
        fpTrajectoryFilter->TakeIntermediatePoint(CurrentState.GetPosition());
      }
    }
    first_substep = false;

#ifdef G4DEBUG_FIELD
    if( fNoZeroStep > fActionThreshold_NoZeroSteps ) {
      printStatus( SubStepStartState,  // or OriginalState,
                   CurrentState,  CurrentProposedStepLength, 
                   NewSafety,     do_loop_count,  pPhysVol );
    }
    if( (fVerboseLevel > 1) && (do_loop_count > fMax_loop_count-10 )) {
      if( do_loop_count == fMax_loop_count-9 ){
        G4cout << " G4PropagatorInField::ComputeStep(): " << G4endl
               << "  Difficult track - taking many sub steps." << G4endl;
      }
      printStatus( SubStepStartState, CurrentState, CurrentProposedStepLength, 
                   NewSafety, do_loop_count, pPhysVol );
    }
#endif

    do_loop_count++;

  } while( (!intersects )
        && (StepTaken + kCarTolerance < CurrentProposedStepLength)  
        && ( do_loop_count < fMax_loop_count ) );

  if( do_loop_count >= fMax_loop_count  )
  {
    fParticleIsLooping = true;

    if ( fVerboseLevel > 0 )
    {
       G4cout << " G4PropagateInField::ComputeStep(): " << G4endl
              << "  Killing looping particle " 
              // << " of " << energy  << " energy "
              << " after " << do_loop_count << " field substeps "
              << " totaling " << StepTaken / mm << " mm " ;
       if( pPhysVol )
          G4cout << " in volume " << pPhysVol->GetName() ; 
       else
         G4cout << " in unknown or null volume. " ; 
       G4cout << G4endl;
    }
  }

  if( !intersects )
  {
    // Chord AB or "minor chords" do not intersect
    // B is the endpoint Step of the current Step.
    //
    End_PointAndTangent = CurrentState; 
    TruePathLength = StepTaken;
  }
  
  // Set pFieldTrack to the return value
  //
  pFieldTrack = End_PointAndTangent;

#ifdef G4VERBOSE
  // Check that "s" is correct
  //
  if( std::fabs(OriginalState.GetCurveLength() + TruePathLength 
      - End_PointAndTangent.GetCurveLength()) > 3.e-4 * TruePathLength )
  {
    std::ostringstream message;
    message << "Curve length mis-match between original state "
            << "and proposed endpoint of propagation." << G4endl
            << "  The curve length of the endpoint should be: " 
            << OriginalState.GetCurveLength() + TruePathLength << G4endl
            << "  and it is instead: "
            << End_PointAndTangent.GetCurveLength() << "." << G4endl
            << "  A difference of: "
            << OriginalState.GetCurveLength() + TruePathLength 
               - End_PointAndTangent.GetCurveLength() << G4endl
            << "  Original state = " << OriginalState   << G4endl
            << "  Proposed state = " << End_PointAndTangent;
    G4Exception("G4PropagatorInField::ComputeStep()",
                "GeomNav0003", FatalException, message);
  }
#endif

  // In particular anomalous cases, we can get repeated zero steps
  // In order to correct this efficiently, we identify these cases
  // and only take corrective action when they occur.
  // 
  if( ( (TruePathLength < fZeroStepThreshold) 
        && ( TruePathLength+kCarTolerance < CurrentProposedStepLength  ) 
        ) 
      || ( TruePathLength < 0.5*kCarTolerance )
    )
  {
    fNoZeroStep++;
  }
  else{
    fNoZeroStep = 0;
  }

  if( fNoZeroStep > fAbandonThreshold_NoZeroSteps )
  { 
     fParticleIsLooping = true;
     std::ostringstream message;
     message << "Particle is stuck; it will be killed." << G4endl
             << "  Zero progress for "  << fNoZeroStep << " attempted steps." 
             << G4endl
             << "  Proposed Step is " << CurrentProposedStepLength
             << " but Step Taken is "<< fFull_CurveLen_of_LastAttempt << G4endl
             << "  For Particle with Charge = " << fCharge
             << " Momentum = "<< fInitialMomentumModulus
             << " Mass = " << fMass << G4endl;
     if( pPhysVol )
       message << " in volume " << pPhysVol->GetName() ; 
     else
       message << " in unknown or null volume. " ; 
     G4Exception("G4PropagatorInField::ComputeStep()",
                 "GeomNav1002", JustWarning, message);
     fNoZeroStep = 0; 
  }
 
  return TruePathLength;
}

G4ThreeVector G4PropagatorInField::EndMomentumDir

(

)

const [inline]

Definition at line 76 of file G4PropagatorInField.icc.

References G4FieldTrack::GetMomentumDir().

{
  return   End_PointAndTangent.GetMomentumDir(); 
}

G4ThreeVector G4PropagatorInField::EndPosition

(

)

const [inline]

Definition at line 70 of file G4PropagatorInField.icc.

References G4FieldTrack::GetPosition().

{
  return   End_PointAndTangent.GetPosition(); 
}

G4FieldManager * G4PropagatorInField::FindAndSetFieldManager

(

G4VPhysicalVolume *

pCurrentPhysVol

)

Definition at line 637 of file G4PropagatorInField.cc.

References G4LogicalVolume::GetFieldManager(), G4Region::GetFieldManager(), G4VPhysicalVolume::GetLogicalVolume(), and G4LogicalVolume::GetRegion().

Referenced by G4Transportation::AlongStepGetPhysicalInteractionLength(), G4ITTransportation::AlongStepGetPhysicalInteractionLength(), G4CoupledTransportation::AlongStepGetPhysicalInteractionLength(), ComputeStep(), G4PathFinder::ComputeStep(), G4SynchrotronRadiationInMat::GetMeanFreePath(), G4SynchrotronRadiation::GetMeanFreePath(), G4SynchrotronRadiationInMat::GetPhotonEnergy(), G4QSynchRad::GetRadius(), G4SynchrotronRadiationInMat::PostStepDoIt(), and G4SynchrotronRadiation::PostStepDoIt().

{
  G4FieldManager* currentFieldMgr;

  currentFieldMgr = fDetectorFieldMgr;
  if( pCurrentPhysicalVolume)
  {
     G4FieldManager *pRegionFieldMgr= 0, *localFieldMgr = 0;
     G4LogicalVolume* pLogicalVol= pCurrentPhysicalVolume->GetLogicalVolume();

     if( pLogicalVol ) { 
        // Value for Region, if any, Overrides 
        G4Region*  pRegion= pLogicalVol->GetRegion();
        if( pRegion ) { 
           pRegionFieldMgr= pRegion->GetFieldManager();
           if( pRegionFieldMgr ) 
             currentFieldMgr= pRegionFieldMgr;
        }

        // 'Local' Value from logical volume, if any, Overrides 
        localFieldMgr= pLogicalVol->GetFieldManager();
        if ( localFieldMgr ) 
           currentFieldMgr = localFieldMgr;
     }
  }
  fCurrentFieldMgr= currentFieldMgr;

  // Flag that field manager has been set.
  fSetFieldMgr= true;

  return currentFieldMgr;
}

G4ChordFinder * G4PropagatorInField::GetChordFinder

(

)

[inline]

Definition at line 45 of file G4PropagatorInField.icc.

References G4FieldManager::GetChordFinder().

Referenced by ComputeStep(), RefreshIntersectionLocator(), SetVerboseLevel(), and G4CoupledTransportation::StartTracking().

{
  // The "Chord Finder" of the current Field Mgr is used
  //    -- this could be of the global field manager
  //        or that of another, from the current volume 
  return fCurrentFieldMgr->GetChordFinder(); 
}

G4FieldManager * G4PropagatorInField::GetCurrentFieldManager

(

)

[inline]

Definition at line 184 of file G4PropagatorInField.icc.

Referenced by G4Transportation::AlongStepGetPhysicalInteractionLength(), G4CoupledTransportation::AlongStepGetPhysicalInteractionLength(), and G4DecayWithSpin::DecayIt().

{
  return fCurrentFieldMgr;
} 

G4double G4PropagatorInField::GetDeltaIntersection

(

)

const [inline]

Definition at line 113 of file G4PropagatorInField.icc.

References G4FieldManager::GetDeltaIntersection().

{
  return fCurrentFieldMgr->GetDeltaIntersection();
} 

G4double G4PropagatorInField::GetDeltaOneStep

(

)

const [inline]

Definition at line 119 of file G4PropagatorInField.icc.

References G4FieldManager::GetDeltaOneStep().

{
  return fCurrentFieldMgr->GetDeltaOneStep();
}

G4FieldTrack G4PropagatorInField::GetEndState

(

)

const [inline]

Definition at line 137 of file G4PropagatorInField.icc.

{
  return End_PointAndTangent;
}

G4double G4PropagatorInField::GetEpsilonStep

(

)

const [inline]

Definition at line 82 of file G4PropagatorInField.icc.

{ 
  return fEpsilonStep; 
}

G4VIntersectionLocator * G4PropagatorInField::GetIntersectionLocator

(

)

[inline]

Definition at line 271 of file G4PropagatorInField.icc.

{
  return fIntersectionLocator;
} 

G4double G4PropagatorInField::GetLargestAcceptableStep

(

)

[inline]

Definition at line 178 of file G4PropagatorInField.icc.

{
  return fLargestAcceptableStep;
}

G4double G4PropagatorInField::GetMaximumEpsilonStep

(

)

const [inline]

Definition at line 157 of file G4PropagatorInField.icc.

References G4FieldManager::GetMaximumEpsilonStep().

{
  return fDetectorFieldMgr->GetMaximumEpsilonStep();
}

G4int G4PropagatorInField::GetMaxLoopCount

(

)

const [inline]

Definition at line 100 of file G4PropagatorInField.icc.

{
  return fMax_loop_count;
}

G4double G4PropagatorInField::GetMinimumEpsilonStep

(

)

const [inline]

Definition at line 144 of file G4PropagatorInField.icc.

References G4FieldManager::GetMinimumEpsilonStep().

{
  return fDetectorFieldMgr->GetMinimumEpsilonStep();
}

G4Navigator * G4PropagatorInField::GetNavigatorForPropagating

(

)

[inline]

Definition at line 258 of file G4PropagatorInField.icc.

{
  return fNavigator;
} 

G4int G4PropagatorInField::GetThresholdNoZeroSteps

(

G4int

i

)

[inline]

Definition at line 209 of file G4PropagatorInField.icc.

{
   G4int t=0;
   if( i==0 )     { t = 3; }     // No of parameters
   else if (i==1) { t = fActionThreshold_NoZeroSteps; }
   else if (i==2) { t = fSevereActionThreshold_NoZeroSteps; }
   else if (i==3) { t = fAbandonThreshold_NoZeroSteps; }

   return t;
}

G4bool G4PropagatorInField::GetUseSafetyForOptimization

(

)

[inline]

Definition at line 240 of file G4PropagatorInField.icc.

{ 
   return fUseSafetyForOptimisation; 
}

G4int G4PropagatorInField::GetVerboseLevel

(

)

const [inline]

Definition at line 126 of file G4PropagatorInField.icc.

Referenced by Verbose().

{
  return fVerboseLevel;
}

G4double G4PropagatorInField::GetZeroStepThreshold

(

)

[inline]

Definition at line 220 of file G4PropagatorInField.icc.

{ return fZeroStepThreshold; }

std::vector< G4ThreeVector > * G4PropagatorInField::GimmeTrajectoryVectorAndForgetIt

(

)

const

Definition at line 598 of file G4PropagatorInField.cc.

References G4VCurvedTrajectoryFilter::GimmeThePointsAndForgetThem().

Referenced by G4Transportation::AlongStepDoIt(), and G4ITTransportation::AlongStepDoIt().

{
  // NB, GimmeThePointsAndForgetThem really forgets them, so it can
  // only be called (exactly) once for each step.

  if (fpTrajectoryFilter)
  {
    return fpTrajectoryFilter->GimmeThePointsAndForgetThem();
  }
  else
  {
    return 0;
  }
}

G4bool G4PropagatorInField::IntersectChord	(	const G4ThreeVector &	StartPointA,
		const G4ThreeVector &	EndPointB,
		G4double &	NewSafety,
		G4double &	LinearStepLength,
		G4ThreeVector &	IntersectionPoint
	)			[inline]

Definition at line 277 of file G4PropagatorInField.icc.

References G4VIntersectionLocator::IntersectChord().

Referenced by ComputeStep().

{
  // Calculate the direction and length of the chord AB
  //
  return fIntersectionLocator
         ->IntersectChord(StartPointA,EndPointB,NewSafety,
                          fPreviousSafety,fPreviousSftOrigin,
                          LinearStepLength,IntersectionPoint);
}

G4bool G4PropagatorInField::IsParticleLooping

(

)

const [inline]

Definition at line 94 of file G4PropagatorInField.icc.

Referenced by G4Transportation::AlongStepGetPhysicalInteractionLength(), and G4CoupledTransportation::AlongStepGetPhysicalInteractionLength().

{
  return fParticleIsLooping;
}

void G4PropagatorInField::printStatus	(	const G4FieldTrack &	startFT,
		const G4FieldTrack &	currentFT,
		G4double	requestStep,
		G4double	safety,
		G4int	step,
		G4VPhysicalVolume *	startVolume
	)

Definition at line 468 of file G4PropagatorInField.cc.

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

Referenced by ComputeStep().

{
  const G4int verboseLevel=fVerboseLevel;
  const G4ThreeVector StartPosition       = StartFT.GetPosition();
  const G4ThreeVector StartUnitVelocity   = StartFT.GetMomentumDir();
  const G4ThreeVector CurrentPosition     = CurrentFT.GetPosition();
  const G4ThreeVector CurrentUnitVelocity = CurrentFT.GetMomentumDir();

  G4double step_len = CurrentFT.GetCurveLength() - StartFT.GetCurveLength();

  G4int oldprec;   // cout/cerr precision settings
      
  if( ((stepNo == 0) && (verboseLevel <3)) || (verboseLevel >= 3) )
  {
    oldprec = G4cout.precision(4);
    G4cout << std::setw( 6)  << " " 
           << std::setw( 25) << " Current Position  and  Direction" << " "
           << G4endl; 
    G4cout << std::setw( 5) << "Step#" 
           << std::setw(10) << "  s  " << " "
           << std::setw(10) << "X(mm)" << " "
           << std::setw(10) << "Y(mm)" << " "  
           << std::setw(10) << "Z(mm)" << " "
           << std::setw( 7) << " N_x " << " "
           << std::setw( 7) << " N_y " << " "
           << std::setw( 7) << " N_z " << " " ;
    G4cout << std::setw( 7) << " Delta|N|" << " "
           << std::setw( 9) << "StepLen" << " "  
           << std::setw(12) << "StartSafety" << " "  
           << std::setw( 9) << "PhsStep" << " ";  
    if( startVolume )
      { G4cout << std::setw(18) << "NextVolume" << " "; }
    G4cout.precision(oldprec);
    G4cout << G4endl;
  }
  if((stepNo == 0) && (verboseLevel <=3))
  {
    // Recurse to print the start values
    //
    printStatus( StartFT, StartFT, -1.0, safety, -1, startVolume);
  }
  if( verboseLevel <= 3 )
  {
    if( stepNo >= 0)
      { G4cout << std::setw( 4) << stepNo << " "; }
    else
      { G4cout << std::setw( 5) << "Start" ; }
    oldprec = G4cout.precision(8);
    G4cout << std::setw(10) << CurrentFT.GetCurveLength() << " "; 
    G4cout.precision(8);
    G4cout << std::setw(10) << CurrentPosition.x() << " "
           << std::setw(10) << CurrentPosition.y() << " "
           << std::setw(10) << CurrentPosition.z() << " ";
    G4cout.precision(4);
    G4cout << std::setw( 7) << CurrentUnitVelocity.x() << " "
           << std::setw( 7) << CurrentUnitVelocity.y() << " "
           << std::setw( 7) << CurrentUnitVelocity.z() << " ";
    G4cout.precision(3); 
    G4cout << std::setw( 7)
           << CurrentFT.GetMomentum().mag()-StartFT.GetMomentum().mag() << " "; 
    G4cout << std::setw( 9) << step_len << " "; 
    G4cout << std::setw(12) << safety << " ";
    if( requestStep != -1.0 ) 
      { G4cout << std::setw( 9) << requestStep << " "; }
    else
      { G4cout << std::setw( 9) << "Init/NotKnown" << " "; }
    if( startVolume != 0)
      { G4cout << std::setw(12) << startVolume->GetName() << " "; }
    G4cout.precision(oldprec);
    G4cout << G4endl;
  }
  else // if( verboseLevel > 3 )
  {
    //  Multi-line output
      
    G4cout << "Step taken was " << step_len  
           << " out of PhysicalStep = " <<  requestStep << G4endl;
    G4cout << "Final safety is: " << safety << G4endl;
    G4cout << "Chord length = " << (CurrentPosition-StartPosition).mag()
           << G4endl;
    G4cout << G4endl; 
  }
}

void G4PropagatorInField::PrintStepLengthDiagnostic	(	G4double	currentProposedStepLength,
		G4double	decreaseFactor,
		G4double	stepTrial,
		const G4FieldTrack &	aFieldTrack
	)			[protected]

Definition at line 562 of file G4PropagatorInField.cc.

References G4cout, and G4endl.

Referenced by ComputeStep().

{
  G4int  iprec= G4cout.precision(8); 
  G4cout << " " << std::setw(12) << " PiF: NoZeroStep " 
         << " " << std::setw(20) << " CurrentProposed len " 
         << " " << std::setw(18) << " Full_curvelen_last" 
         << " " << std::setw(18) << " last proposed len " 
         << " " << std::setw(18) << " decrease factor   " 
         << " " << std::setw(15) << " step trial  " 
         << G4endl;

  G4cout << " " << std::setw(10) << fNoZeroStep << "  "
         << " " << std::setw(20) << CurrentProposedStepLength
         << " " << std::setw(18) << fFull_CurveLen_of_LastAttempt
         << " " << std::setw(18) << fLast_ProposedStepLength 
         << " " << std::setw(18) << decreaseFactor
         << " " << std::setw(15) << stepTrial
         << G4endl;
  G4cout.precision( iprec ); 

}

void G4PropagatorInField::RefreshIntersectionLocator

(

)

Definition at line 119 of file G4PropagatorInField.cc.

References GetChordFinder(), G4FieldManager::GetDeltaIntersection(), G4VIntersectionLocator::SetChordFinderFor(), G4VIntersectionLocator::SetDeltaIntersectionFor(), G4VIntersectionLocator::SetEpsilonStepFor(), and G4VIntersectionLocator::SetSafetyParametersFor().

Referenced by ComputeStep(), and G4PropagatorInField().

{
  fIntersectionLocator->SetEpsilonStepFor(fEpsilonStep);
  fIntersectionLocator->SetDeltaIntersectionFor(fCurrentFieldMgr->GetDeltaIntersection());
  fIntersectionLocator->SetChordFinderFor(GetChordFinder());
  fIntersectionLocator->SetSafetyParametersFor( fUseSafetyForOptimisation);
}

void G4PropagatorInField::SetChargeMomentumMass	(	G4double	charge,
		G4double	momentum,
		G4double	pMass
	)			[inline]

Definition at line 54 of file G4PropagatorInField.icc.

Referenced by G4Transportation::AlongStepGetPhysicalInteractionLength(), and G4CoupledTransportation::AlongStepGetPhysicalInteractionLength().

{
  // GetChordFinder()->SetChargeMomentumMass(Charge, Momentum, Mass);
  //  --> Not needed anymore, as it is done in ComputeStep for the 
  //       ChordFinder of the current step (which is known only then).
  fCharge = Charge;
  fInitialMomentumModulus = Momentum;
  fMass = Mass; 
}

void G4PropagatorInField::SetDetectorFieldManager

(

G4FieldManager *

newGlobalFieldManager

)

[inline]

Definition at line 227 of file G4PropagatorInField.icc.

{
   fDetectorFieldMgr = newDetectorFieldManager; 
}

void G4PropagatorInField::SetEpsilonStep

(

G4double

newEps

)

[inline]

Definition at line 88 of file G4PropagatorInField.icc.

Referenced by ComputeStep().

{
  fEpsilonStep=newEps;
}

void G4PropagatorInField::SetIntersectionLocator

(

G4VIntersectionLocator *

pLocator

)

[inline]

Definition at line 265 of file G4PropagatorInField.icc.

{
  if(pIntLoc)  { fIntersectionLocator= pIntLoc; }
}

void G4PropagatorInField::SetLargestAcceptableStep

(

G4double

newBigDist

)

[inline]

Definition at line 169 of file G4PropagatorInField.icc.

{
  if( fLargestAcceptableStep>0.0 )
  {
    fLargestAcceptableStep = newBigDist;
  }
}

void G4PropagatorInField::SetMaximumEpsilonStep

(

G4double

newEpsMax

)

[inline]

Definition at line 163 of file G4PropagatorInField.icc.

References G4FieldManager::SetMaximumEpsilonStep().

{
  fDetectorFieldMgr->SetMaximumEpsilonStep( newEpsMax );
}

void G4PropagatorInField::SetMaxLoopCount

(

G4int

new_max

)

[inline]

Definition at line 106 of file G4PropagatorInField.icc.

{
  fMax_loop_count = new_max;
}

void G4PropagatorInField::SetMinimumEpsilonStep

(

G4double

newEpsMin

)

[inline]

Definition at line 150 of file G4PropagatorInField.icc.

References G4FieldManager::SetMinimumEpsilonStep().

{
  fDetectorFieldMgr->SetMinimumEpsilonStep(newEpsMin);
}

void G4PropagatorInField::SetNavigatorForPropagating

(

G4Navigator *

SimpleOrMultiNavigator

)

[inline]

Definition at line 247 of file G4PropagatorInField.icc.

References G4VIntersectionLocator::SetNavigatorFor().

Referenced by G4PathFinder::EnableParallelNavigation().

{
  if(SimpleOrMultiNavigator)  { 
     fNavigator= SimpleOrMultiNavigator; 
     if( fIntersectionLocator ) {
         fIntersectionLocator->SetNavigatorFor( SimpleOrMultiNavigator );
     }
  }
}

void G4PropagatorInField::SetThresholdNoZeroStep	(	G4int	noAct,
		G4int	noHarsh,
		G4int	noAbandon
	)			[inline]

Definition at line 190 of file G4PropagatorInField.icc.

{
  if( noAct>0 ) 
    fActionThreshold_NoZeroSteps = noAct; 

  if( noHarsh > fActionThreshold_NoZeroSteps )
    fSevereActionThreshold_NoZeroSteps = noHarsh; 
  else
    fSevereActionThreshold_NoZeroSteps = 2*(fActionThreshold_NoZeroSteps+1);

  if( noAbandon > fSevereActionThreshold_NoZeroSteps+5 )
    fAbandonThreshold_NoZeroSteps = noAbandon; 
  else
    fAbandonThreshold_NoZeroSteps = 2*(fSevereActionThreshold_NoZeroSteps+3); 
}

void G4PropagatorInField::SetTrajectoryFilter

(

G4VCurvedTrajectoryFilter *

filter

)

Definition at line 614 of file G4PropagatorInField.cc.

Referenced by G4VisCommandSceneAddTrajectories::SetNewValue().

{
  fpTrajectoryFilter = filter;
}

void G4PropagatorInField::SetUseSafetyForOptimization

(

G4bool

)

[inline]

Definition at line 234 of file G4PropagatorInField.icc.

{
   fUseSafetyForOptimisation= value;
}

G4int G4PropagatorInField::SetVerboseLevel

(

G4int

verbose

)

Definition at line 670 of file G4PropagatorInField.cc.

References G4cout, G4endl, GetChordFinder(), G4ChordFinder::GetIntegrationDriver(), and G4MagInt_Driver::SetVerboseLevel().

{
  G4int oldval= fVerboseLevel;
  fVerboseLevel= level;

  // Forward the verbose level 'reduced' to ChordFinder,
  // MagIntegratorDriver ... ? 
  //
  G4MagInt_Driver* integrDriver= GetChordFinder()->GetIntegrationDriver(); 
  integrDriver->SetVerboseLevel( fVerboseLevel - 2 );
  G4cout << "Set Driver verbosity to " << fVerboseLevel - 2 << G4endl;

  return oldval;
}

void G4PropagatorInField::SetZeroStepThreshold

(

G4double

newLength

)

[inline]

Definition at line 221 of file G4PropagatorInField.icc.

{ 
  fZeroStepThreshold= newLength;
}

G4int G4PropagatorInField::Verbose

(

)

const [inline]

Definition at line 131 of file G4PropagatorInField.icc.

References GetVerboseLevel().

{
  return GetVerboseLevel();
}

---

The documentation for this class was generated from the following files:

• G4PropagatorInField.hh
• G4PropagatorInField.icc
• G4PropagatorInField.cc

---