QuirkTransportation Class Reference

#include <QuirkTransportation.h>

Inheritance diagram for QuirkTransportation:

Collaboration diagram for QuirkTransportation:

Public Member Functions
	QuirkTransportation (G4int verbosityLevel=1)
	~QuirkTransportation ()
G4double	AlongStepGetPhysicalInteractionLength (const G4Track &track, G4double previousStepSize, G4double currentMinimumStep, G4double &currentSafety, G4GPILSelection *selection)
G4VParticleChange *	AlongStepDoIt (const G4Track &track, const G4Step &stepData)
G4VParticleChange *	PostStepDoIt (const G4Track &track, const G4Step &stepData)
G4double	PostStepGetPhysicalInteractionLength (const G4Track &, G4double previousStepSize, G4ForceCondition *pForceCond)
G4PropagatorInField *	GetPropagatorInField ()
void	SetPropagatorInField (G4PropagatorInField *pFieldPropagator)
void	SetVerboseLevel (G4int verboseLevel)
G4int	GetVerboseLevel () const
G4double	GetThresholdWarningEnergy () const
G4double	GetThresholdImportantEnergy () const
G4int	GetThresholdTrials () const
void	SetThresholdWarningEnergy (G4double newEnWarn)
void	SetThresholdImportantEnergy (G4double newEnImp)
void	SetThresholdTrials (G4int newMaxTrials)
G4double	GetMaxEnergyKilled () const
G4double	GetSumEnergyKilled () const
void	ResetKilledStatistics (G4int report=1)
void	EnableShortStepOptimisation (G4bool optimise=true)
G4double	AtRestGetPhysicalInteractionLength (const G4Track &, G4ForceCondition *)
G4VParticleChange *	AtRestDoIt (const G4Track &, const G4Step &)
void	StartTracking (G4Track *aTrack)

Protected Member Functions
G4bool	DoesGlobalFieldExist ()

Private Attributes
G4Navigator *	m_linearNavigator
G4PropagatorInField *	m_fieldPropagator
G4ThreeVector	m_transportEndPosition
G4ThreeVector	m_transportEndMomentumDir
G4double	m_transportEndKineticEnergy
G4ThreeVector	m_transportEndSpin
G4bool	m_momentumChanged
G4double	m_candidateEndGlobalTime
G4bool	m_particleIsLooping
G4TouchableHandle	m_currentTouchableHandle
G4bool	m_geometryLimitedStep
G4ThreeVector	m_previousSftOrigin
G4double	m_previousSafety
G4ParticleChangeForTransport	m_particleChange
G4double	m_endpointDistance
G4double	m_threshold_Warning_Energy
G4double	m_threshold_Important_Energy
G4int	m_thresholdTrials
G4int	m_noLooperTrials
G4double	m_sumEnergyKilled
G4double	m_maxEnergyKilled
G4bool	m_shortStepOptimisation
G4SafetyHelper *	m_safetyHelper
G4int	m_verboseLevel

Detailed Description

Definition at line 59 of file QuirkTransportation.h.

Constructor & Destructor Documentation

QuirkTransportation()

QuirkTransportation::QuirkTransportation

(

G4int

verbosityLevel = 1

)

Definition at line 79 of file QuirkTransportation.cxx.

  : G4VProcess( G4String("QuirkTransportation"), fTransportation ),
    m_transportEndKineticEnergy( 0.0 ),
    m_momentumChanged( false ),
    m_particleIsLooping( false ),
    m_currentTouchableHandle(),  // Points to (G4VTouchable*) 0
    m_geometryLimitedStep( false ),
    m_previousSftOrigin (0.,0.,0.),
    m_previousSafety    ( 0.0 ),
    m_endpointDistance( 0.0 ),
    m_threshold_Warning_Energy( 100 * CLHEP::MeV ),  
    m_threshold_Important_Energy( 250 * CLHEP::MeV ), 
    m_thresholdTrials( 10 ), 
    m_noLooperTrials(0),
    m_sumEnergyKilled( 0.0 ), m_maxEnergyKilled( 0.0 ), 
    m_shortStepOptimisation(false),    // Old default: true (=fast short steps)
    m_verboseLevel( verboseLevel )
{
  G4TransportationManager* transportMgr ; 
 
  transportMgr = G4TransportationManager::GetTransportationManager() ; 
 
  m_linearNavigator = transportMgr->GetNavigatorForTracking() ; 
 
  // fGlobalFieldMgr = transportMgr->GetFieldManager() ;
 
  m_fieldPropagator = transportMgr->GetPropagatorInField() ;
 
  m_safetyHelper =   transportMgr->GetSafetyHelper();  // New 
 
  // Cannot determine whether a field exists here, as it would 
  //  depend on the relative order of creating the detector's 
  //  field and this process. That order is not guaranted.
  // Instead later the method DoesGlobalFieldExist() is called
 
  m_candidateEndGlobalTime = 0;
}

~QuirkTransportation()

QuirkTransportation::~QuirkTransportation

(

)

Definition at line 119 of file QuirkTransportation.cxx.

{
  if( (m_verboseLevel > 0) && (m_sumEnergyKilled > 0.0 ) ){ 
    G4cout << " QuirkTransportation: Statistics for looping particles " << G4endl;
    G4cout << "   Sum of energy of loopers killed: " <<  m_sumEnergyKilled << G4endl;
    G4cout << "   Max energy of loopers killed: " <<  m_maxEnergyKilled << G4endl;
  } 
}

Member Function Documentation

AlongStepDoIt()

G4VParticleChange * QuirkTransportation::AlongStepDoIt	(	const G4Track &	track,
		const G4Step &	stepData
	)

Definition at line 353 of file QuirkTransportation.cxx.

{
#ifdef G4VERBOSE
  static std::atomic<G4int> noCalls=0;
  noCalls++;
#endif
 
  m_particleChange.Initialize(track) ;
 
  //  Code for specific process 
  //
  m_particleChange.ProposePosition(m_transportEndPosition) ;
  m_particleChange.ProposeMomentumDirection(m_transportEndMomentumDir) ;
  m_particleChange.ProposeEnergy(m_transportEndKineticEnergy) ;
  m_particleChange.SetMomentumChanged(m_momentumChanged) ;
 
  m_particleChange.ProposePolarization(m_transportEndSpin);
  
  // Calculate  Lab Time of Flight (ONLY if field Equations used it!)
     // G4double endTime   = m_candidateEndGlobalTime;
     // G4double delta_time = endTime - startTime;
 
  G4double startTime = track.GetGlobalTime() ;
  G4double deltaTime = m_candidateEndGlobalTime - startTime ;
  m_particleChange.ProposeGlobalTime( m_candidateEndGlobalTime ) ;
 
  // Now Correct by Lorentz factor to get "proper" deltaTime
  
  G4double  restMass       = track.GetDynamicParticle()->GetMass() ;
  G4double deltaProperTime = deltaTime*( restMass/track.GetTotalEnergy() ) ;
 
  m_particleChange.ProposeProperTime(track.GetProperTime() + deltaProperTime) ;
  //m_particleChange. ProposeTrueStepLength( track.GetStepLength() ) ;
 
  // If the particle is caught looping or is stuck (in very difficult
  // boundaries) in a magnetic field (doing many steps) 
  //   THEN this kills it ...
  //
  if ( m_particleIsLooping )
  {
      G4double endEnergy= m_transportEndKineticEnergy;
 
      if( (endEnergy < m_threshold_Important_Energy) 
      || (m_noLooperTrials >= m_thresholdTrials ) ){
    // Kill the looping particle 
    //
    m_particleChange.ProposeTrackStatus( fStopAndKill )  ;
 
        // 'Bare' statistics
        m_sumEnergyKilled += endEnergy; 
    if( endEnergy > m_maxEnergyKilled) { m_maxEnergyKilled= endEnergy; }
 
#ifdef G4VERBOSE
    if( (m_verboseLevel > 1) || 
        ( endEnergy > m_threshold_Warning_Energy )  ) { 
      G4cout << " QuirkTransportation is killing track that is looping or stuck "
         << G4endl
         << "   This track has " << track.GetKineticEnergy() / CLHEP::MeV
         << " MeV energy." << G4endl;
      G4cout << "   Number of trials = " << m_noLooperTrials 
         << "   No of calls to AlongStepDoIt = " << noCalls 
         << G4endl;
    }
#endif
    m_noLooperTrials=0; 
      }
      else{
    m_noLooperTrials ++; 
#ifdef G4VERBOSE
    if( (m_verboseLevel > 2) ){
      G4cout << "   QuirkTransportation::AlongStepDoIt(): Particle looping -  "
         << "   Number of trials = " << m_noLooperTrials 
         << "   No of calls to  = " << noCalls 
         << G4endl;
    }
#endif
      }
  }else{
      m_noLooperTrials=0; 
  }
 
  // Another (sometimes better way) is to use a user-limit maximum Step size
  // to alleviate this problem .. 
 
  // Introduce smooth curved trajectories to particle-change
  //
  m_particleChange.SetPointerToVectorOfAuxiliaryPoints
    (m_fieldPropagator->GimmeTrajectoryVectorAndForgetIt() );
 
  return &m_particleChange ;
}

AlongStepGetPhysicalInteractionLength()

G4double QuirkTransportation::AlongStepGetPhysicalInteractionLength	(	const G4Track &	track,
		G4double	previousStepSize,
		G4double	currentMinimumStep,
		G4double &	currentSafety,
		G4GPILSelection *	selection
	)

Definition at line 135 of file QuirkTransportation.cxx.

{
  G4double geometryStepLength; 
  m_particleIsLooping = false ;
 
  // Initial actions moved to  StartTrack()   
  // --------------------------------------
  // Note: in case another process changes touchable handle
  //    it will be necessary to add here (for all steps)   
  // m_currentTouchableHandle = aTrack->GetTouchableHandle();
 
  // GPILSelection is set to defaule value of CandidateForSelection
  // It is a return value
  //
  *selection = CandidateForSelection ;
 
  // Get initial Energy/Momentum of the track
  //
  const G4DynamicParticle*    pParticle  = track.GetDynamicParticle() ;
  G4ParticleDefinition* pParticleDef   = pParticle->GetDefinition() ;
  G4ThreeVector startPosition          = track.GetPosition() ;
 
  // G4double   theTime        = track.GetGlobalTime() ;
 
  // The Step Point safety can be limited by other geometries and/or the 
  // assumptions of any process - it's not always the geometrical safety.
  // We calculate the starting point's isotropic safety here.
  //
  G4ThreeVector OriginShift = startPosition - m_previousSftOrigin ;
  G4double      MagSqShift  = OriginShift.mag2() ;
  if( MagSqShift >= sqr(m_previousSafety) )
  {
     currentSafety = 0.0 ;
  }
  else
  {
     currentSafety = m_previousSafety - std::sqrt(MagSqShift) ;
  }
 
  // Is the particle charged ?
  //
  G4double              particleCharge = pParticle->GetCharge() ; 
 
  // There is no need to locate the current volume. It is Done elsewhere:
  //   On track construction 
  //   By the tracking, after all AlongStepDoIts, in "Relocation"
 
  // Set up field manager
  G4FieldManager* fieldMgr = m_fieldPropagator->FindAndSetFieldManager( track.GetVolume() ); 
  if (fieldMgr != 0) {
     // Message the field Manager, to configure it for this track
     fieldMgr->ConfigureForTrack( &track );
  } else {
     G4Exception("QuirkTransportation::AlongStepGetPhysicalInteractionLength", "QuirkNoFieldMgr", RunMustBeAborted, "no field manager");
  }
 
  // Set up stepper to calculate quirk trajectory
  Quirk* quirkDef = dynamic_cast<Quirk*>(pParticleDef);
  if (quirkDef == 0) {
     G4Exception("QuirkTransportation::AlongStepGetPhysicalInteractionLength", "NonQuirk", FatalErrorInArgument, "QuirkTransportation run on non-quirk particle");
     std::abort();
  }
  HyperbolaStepper quirkStepper(
     quirkDef->GetStringIn(),
     track,
     fieldMgr->DoesFieldExist() ? fieldMgr->GetDetectorField() : 0
  );
 
  // Switch out chord finder with quirk chord finder
  G4ChordFinder* oldChordFinder = fieldMgr->GetChordFinder();
  G4ChordFinder quirkChordFinder(
     new G4MagInt_Driver(0.0, &quirkStepper, quirkStepper.GetNumberOfVariables())
  );
  fieldMgr->SetChordFinder(&quirkChordFinder);
 
  G4double       momentumMagnitude = pParticle->GetTotalMomentum() ;
  G4ThreeVector  EndUnitMomentum ;
  G4double       restMass = pParticleDef->GetPDGMass() ;
 
#if G4VERSION_NUMBER > 1009
  //FIXME untested!!!
  G4ChargeState chargeState(particleCharge,    // in e+ units
                            quirkDef->GetPDGSpin(),
                            0,
                            0,
                            0); //no magnetic charge?
  G4EquationOfMotion* equationOfMotion = (m_fieldPropagator->GetChordFinder()->GetIntegrationDriver()->GetStepper())->GetEquationOfMotion();
  equationOfMotion->SetChargeMomentumMass( chargeState,
                                           momentumMagnitude, // in Mev/c 
                                           restMass           ) ;  
#else
  m_fieldPropagator->SetChargeMomentumMass( particleCharge,    // in e+ units
                                           momentumMagnitude, // in Mev/c 
                                           restMass           ) ;  
#endif
 
  G4ThreeVector spin        = track.GetPolarization() ;
  G4FieldTrack  aFieldTrack = G4FieldTrack( startPosition, 
                                            track.GetMomentumDirection(),
                                            0.0, 
                                            track.GetKineticEnergy(),
                                            restMass,
                                            track.GetVelocity(),
                                            track.GetGlobalTime(), // Lab.
                                            0.0,                   // substituting step length for proper time
                                            &spin                  ) ;
 
  //if (currentMinimumStep <= 0) {
  //   G4cout << "QuirkTransportation: currentMinimumStep = " << currentMinimumStep << G4endl;
  //   G4Exception(
  //       "QuirkTransportation::AlongStepGetPhysicalInteractionLength",
  //       "BadMinimumStep",
  //       EventMustBeAborted,
  //       "QuirkTransportation: currentMinimumStep <= 0"
  //   );
  //}
  G4bool dbg = false; //(track.GetCurrentStepNumber() % 1000000 == 0);
  quirkStepper.SetDebug(dbg);
  if (dbg) G4cout << "QuirkTransportation: start = " << aFieldTrack.GetPosition() << G4endl;
  if (dbg) G4cout << "QuirkTransportation: currentMinimumStep = " << currentMinimumStep << G4endl;
  if (dbg) G4cout << "QuirkTransportation: maxlength = " << quirkStepper.GetMaxLength() << G4endl;
  currentMinimumStep = std::min(currentMinimumStep, quirkStepper.GetMaxLength());
  if (dbg) G4cout << "QuirkTransportation: currentMinimumStep = " << currentMinimumStep << G4endl;
  if( currentMinimumStep > 0 )
  {
     // Call field propagator to handle boundary crossings
     G4double lengthAlongCurve = m_fieldPropagator->ComputeStep( aFieldTrack,
                                                                currentMinimumStep, 
                                                                currentSafety,
                                                                track.GetVolume() ) ;
     if (dbg) G4cout << "QuirkTransportation: moved " << lengthAlongCurve << G4endl;
     m_geometryLimitedStep = lengthAlongCurve < currentMinimumStep;
     if( m_geometryLimitedStep ) {
        geometryStepLength   = lengthAlongCurve ;
     } else {
        geometryStepLength   = currentMinimumStep ;
     }
     // Update stepper, string vectors with step length from field propagator
     quirkStepper.Update(aFieldTrack, aFieldTrack.GetCurveLength() == 0 && !m_geometryLimitedStep);
  }
  else
  {
     geometryStepLength   = 0.0 ;
     m_geometryLimitedStep = false ;
  }
  if (dbg) G4cout << "QuirkTransportation: moved " << aFieldTrack.GetCurveLength() << G4endl;
  if (dbg) G4cout << "QuirkTransportation: end = " << aFieldTrack.GetPosition() << " [" << aFieldTrack.GetProperTimeOfFlight() << "]" << G4endl;
 
  // Remember last safety origin & value.
  //
  m_previousSftOrigin = startPosition ;
  m_previousSafety    = currentSafety ;         
  // m_safetyHelper->SetCurrentSafety( newSafety, startPosition);
 
  // Get end-of-step quantities
  geometryStepLength = aFieldTrack.GetCurveLength();
  m_transportEndPosition = aFieldTrack.GetPosition() ;
  m_momentumChanged         = true ; 
  m_transportEndMomentumDir = aFieldTrack.GetMomentumDir() ;
  m_transportEndKineticEnergy  = aFieldTrack.GetKineticEnergy() ; 
  m_candidateEndGlobalTime   = aFieldTrack.GetLabTimeOfFlight();
  m_transportEndSpin  = aFieldTrack.GetSpin();
  m_particleIsLooping = m_fieldPropagator->IsParticleLooping() ;
  m_endpointDistance   = (m_transportEndPosition - startPosition).mag() ;
 
  // If we are asked to go a step length of 0, and we are on a boundary
  // then a boundary will also limit the step -> we must flag this.
  //
  if( currentMinimumStep == 0.0 ) 
  {
      if( currentSafety == 0.0 )  m_geometryLimitedStep = true ;
  }
 
  // Update the safety starting from the end-point,
  // if it will become negative at the end-point.
  //
  if( currentSafety < m_endpointDistance ) 
  {
       G4double endSafety =
            m_linearNavigator->ComputeSafety( m_transportEndPosition) ;
       currentSafety      = endSafety ;
       m_previousSftOrigin = m_transportEndPosition ;
       m_previousSafety    = currentSafety ; 
       m_safetyHelper->SetCurrentSafety( currentSafety, m_transportEndPosition);
 
       // Because the Stepping Manager assumes it is from the start point, 
       //  add the StepLength
       //
       currentSafety     += m_endpointDistance ;
 
#ifdef G4DEBUG_TRANSPORT 
       G4cout.precision(12) ;
       G4cout << "***QuirkTransportation::AlongStepGPIL ** " << G4endl  ;
       G4cout << "  Called Navigator->ComputeSafety at " << m_transportEndPosition
              << "    and it returned safety= " << endSafety << G4endl ; 
       G4cout << "  Adding endpoint distance " << m_endpointDistance 
              << "   to obtain pseudo-safety= " << currentSafety << G4endl ; 
#endif
  }            
 
  m_particleChange.ProposeTrueStepLength(geometryStepLength) ;
 
  // Restore original stepper
  fieldMgr->SetChordFinder(oldChordFinder);
 
  return geometryStepLength ;
}

AtRestDoIt()

G4VParticleChange* QuirkTransportation::AtRestDoIt ( const G4Track &  , const G4Step &    )

inline

Definition at line 133 of file QuirkTransportation.h.

                              {return 0;};

AtRestGetPhysicalInteractionLength()

G4double QuirkTransportation::AtRestGetPhysicalInteractionLength ( const G4Track &  , G4ForceCondition *    )

inline

Definition at line 127 of file QuirkTransportation.h.

                              { return -1.0; };

DoesGlobalFieldExist()

G4bool QuirkTransportation::DoesGlobalFieldExist ( )

protected

EnableShortStepOptimisation()

void QuirkTransportation::EnableShortStepOptimisation ( G4bool  optimise = true )

inline

GetMaxEnergyKilled()

G4double QuirkTransportation::GetMaxEnergyKilled ( ) const

inline

GetPropagatorInField()

G4PropagatorInField* QuirkTransportation::GetPropagatorInField

(

)

GetSumEnergyKilled()

G4double QuirkTransportation::GetSumEnergyKilled ( ) const

inline

GetThresholdImportantEnergy()

G4double QuirkTransportation::GetThresholdImportantEnergy ( ) const

inline

GetThresholdTrials()

G4int QuirkTransportation::GetThresholdTrials ( ) const

inline

GetThresholdWarningEnergy()

G4double QuirkTransportation::GetThresholdWarningEnergy ( ) const

inline

GetVerboseLevel()

G4int QuirkTransportation::GetVerboseLevel ( ) const

inline

PostStepDoIt()

G4VParticleChange * QuirkTransportation::PostStepDoIt	(	const G4Track &	track,
		const G4Step &	stepData
	)

Definition at line 464 of file QuirkTransportation.cxx.

{
   G4TouchableHandle retCurrentTouchable ;   // The one to return
   G4bool isLastStep= false; 
 
  // Initialize ParticleChange  (by setting all its members equal
  //                             to corresponding members in G4Track)
  // m_particleChange.Initialize(track) ;  // To initialise TouchableChange
 
  m_particleChange.ProposeTrackStatus(track.GetTrackStatus()) ;
 
  // If the Step was determined by the volume boundary,
  // logically relocate the particle
 
  if(m_geometryLimitedStep)
  {  
    // fCurrentTouchable will now become the previous touchable, 
    // and what was the previous will be freed.
    // (Needed because the preStepPoint can point to the previous touchable)
 
    m_linearNavigator->SetGeometricallyLimitedStep() ;
    m_linearNavigator->
    LocateGlobalPointAndUpdateTouchableHandle( track.GetPosition(),
                                               track.GetMomentumDirection(),
                                               m_currentTouchableHandle,
                                               true                      ) ;
    // Check whether the particle is out of the world volume 
    // If so it has exited and must be killed.
    //
    if( m_currentTouchableHandle->GetVolume() == 0 )
    {
       m_particleChange.ProposeTrackStatus( fStopAndKill ) ;
       G4cout << "QuirkTransportation: number of steps = " << track.GetCurrentStepNumber() << G4endl;
    }
    retCurrentTouchable = m_currentTouchableHandle ;
    m_particleChange.SetTouchableHandle( m_currentTouchableHandle ) ;
 
    // Update the Step flag which identifies the Last Step in a volume
    isLastStep =  m_linearNavigator->ExitedMotherVolume() 
                       || m_linearNavigator->EnteredDaughterVolume() ;
 
#ifdef G4DEBUG_TRANSPORT
    //  Checking first implementation of flagging Last Step in Volume
    G4bool exiting =  m_linearNavigator->ExitedMotherVolume();
    G4bool entering = m_linearNavigator->EnteredDaughterVolume();
    if( ! (exiting || entering) ) { 
    G4cout << " Transport> :  Proposed isLastStep= " << isLastStep 
           << " Exiting "  << m_linearNavigator->ExitedMotherVolume()          
       << " Entering " << m_linearNavigator->EnteredDaughterVolume() 
       << G4endl;
    } 
#endif
  }
  else                 // m_geometryLimitedStep  is false
  {                    
    // This serves only to move the Navigator's location
    //
    m_linearNavigator->LocateGlobalPointWithinVolume( track.GetPosition() ) ;
 
    // The value of the track's current Touchable is retained. 
    // (and it must be correct because we must use it below to
    // overwrite the (unset) one in particle change)
    //  It must be fCurrentTouchable too ??
    //
    m_particleChange.SetTouchableHandle( track.GetTouchableHandle() ) ;
    retCurrentTouchable = track.GetTouchableHandle() ;
 
    isLastStep= false;
#ifdef G4DEBUG_TRANSPORT
    //  Checking first implementation of flagging Last Step in Volume
    G4cout << " Transport> Proposed isLastStep= " << isLastStep
       << " Geometry did not limit step. " << G4endl;
#endif
  }         // endif ( m_geometryLimitedStep ) 
 
  m_particleChange.ProposeLastStepInVolume(isLastStep);    
 
  const G4VPhysicalVolume* pNewVol = retCurrentTouchable->GetVolume() ;
  G4Material* pNewMaterial   = 0 ;
  G4VSensitiveDetector* pNewSensitiveDetector   = 0 ;
                                                                                       
  if( pNewVol != 0 )
  {
    pNewMaterial= pNewVol->GetLogicalVolume()->GetMaterial();
    pNewSensitiveDetector= pNewVol->GetLogicalVolume()->GetSensitiveDetector();
  }
 
  // ( <const_cast> pNewMaterial ) ;
  // ( <const_cast> pNewSensitiveDetector) ;
 
  m_particleChange.SetMaterialInTouchable( pNewMaterial ) ;
  m_particleChange.SetSensitiveDetectorInTouchable( pNewSensitiveDetector ) ;
 
  const G4MaterialCutsCouple* pNewMaterialCutsCouple = 0;
  if( pNewVol != 0 )
  {
    pNewMaterialCutsCouple=pNewVol->GetLogicalVolume()->GetMaterialCutsCouple();
  }
 
  if( pNewVol!=0 && pNewMaterialCutsCouple!=0 && pNewMaterialCutsCouple->GetMaterial()!=pNewMaterial )
  {
    // for parametrized volume
    //
    pNewMaterialCutsCouple =
      G4ProductionCutsTable::GetProductionCutsTable()
                             ->GetMaterialCutsCouple(pNewMaterial,
                               pNewMaterialCutsCouple->GetProductionCuts());
  }
  m_particleChange.SetMaterialCutsCoupleInTouchable( pNewMaterialCutsCouple );
 
  // temporarily until Get/Set Material of ParticleChange, 
  // and StepPoint can be made const. 
  // Set the touchable in ParticleChange
  // this must always be done because the particle change always
  // uses this value to overwrite the current touchable pointer.
  //
  m_particleChange.SetTouchableHandle(retCurrentTouchable) ;
 
  return &m_particleChange ;
}

PostStepGetPhysicalInteractionLength()

G4double QuirkTransportation::PostStepGetPhysicalInteractionLength	(	const G4Track &	,
		G4double	previousStepSize,
		G4ForceCondition *	pForceCond
	)

Definition at line 452 of file QuirkTransportation.cxx.

{ 
  *pForceCond = Forced ; 
  return DBL_MAX ;  // was kInfinity ; but convention now is DBL_MAX
}

ResetKilledStatistics()

void QuirkTransportation::ResetKilledStatistics ( G4int  report = 1 )

inline

SetPropagatorInField()

void QuirkTransportation::SetPropagatorInField

(

G4PropagatorInField *

pFieldPropagator

)

SetThresholdImportantEnergy()

void QuirkTransportation::SetThresholdImportantEnergy ( G4double  newEnImp )

inline

SetThresholdTrials()

void QuirkTransportation::SetThresholdTrials ( G4int  newMaxTrials )

inline

SetThresholdWarningEnergy()

void QuirkTransportation::SetThresholdWarningEnergy ( G4double  newEnWarn )

inline

SetVerboseLevel()

void QuirkTransportation::SetVerboseLevel ( G4int  verboseLevel )

inline

StartTracking()

void QuirkTransportation::StartTracking

(

G4Track *

aTrack

)

Definition at line 590 of file QuirkTransportation.cxx.

{
  G4VProcess::StartTracking(aTrack);
 
// The actions here are those that were taken in AlongStepGPIL
//   when track.GetCurrentStepNumber()==1
 
  // reset safety value and center
  //
  m_previousSafety    = 0.0 ; 
  m_previousSftOrigin = G4ThreeVector(0.,0.,0.) ;
  
  // reset looping counter -- for motion in field
  m_noLooperTrials= 0; 
  // Must clear this state .. else it depends on last track's value
  //  --> a better solution would set this from state of suspended track TODO ? 
  // Was if( aTrack->GetCurrentStepNumber()==1 ) { .. }
 
  // ChordFinder reset internal state
  //
  m_fieldPropagator->ClearPropagatorState();   
    // Resets all state of field propagator class (ONLY)
    //  including safety values (in case of overlaps and to wipe for first track).
 
  // G4ChordFinder* chordF= m_fieldPropagator->GetChordFinder();
  // if( chordF ) chordF->ResetStepEstimate();
 
  // Make sure to clear the chord finders of all fields (ie managers)
  G4FieldManagerStore::GetInstance()->ClearAllChordFindersState();
 
  // Update the current touchable handle  (from the track's)
  //
  m_currentTouchableHandle = aTrack->GetTouchableHandle();
 
  // Initialize infracolor string
  auto part_nc ATLAS_THREAD_SAFE =  // aTrack is non-const but GetParticleDefinition only returns const
    const_cast<G4ParticleDefinition*>(aTrack->GetParticleDefinition());
  Quirk* quirkDef = dynamic_cast<Quirk*>(part_nc);
  if (quirkDef == 0) {
     G4Exception("QuirkTransportation::StartTracking", "NonQuirk", FatalErrorInArgument, "QuirkTransportation run on non-quirk particle");
     std::abort();
  }
  quirkDef->GetStringIn().StartTracking(aTrack);
}

Member Data Documentation

m_candidateEndGlobalTime

G4double QuirkTransportation::m_candidateEndGlobalTime

private

Definition at line 161 of file QuirkTransportation.h.

m_currentTouchableHandle

G4TouchableHandle QuirkTransportation::m_currentTouchableHandle

private

Definition at line 166 of file QuirkTransportation.h.

m_endpointDistance

G4double QuirkTransportation::m_endpointDistance

private

Definition at line 183 of file QuirkTransportation.h.

m_fieldPropagator

G4PropagatorInField* QuirkTransportation::m_fieldPropagator

private

Definition at line 150 of file QuirkTransportation.h.

m_geometryLimitedStep

G4bool QuirkTransportation::m_geometryLimitedStep

private

Definition at line 173 of file QuirkTransportation.h.

m_linearNavigator

G4Navigator* QuirkTransportation::m_linearNavigator

private

Definition at line 149 of file QuirkTransportation.h.

m_maxEnergyKilled

G4double QuirkTransportation::m_maxEnergyKilled

private

Definition at line 196 of file QuirkTransportation.h.

m_momentumChanged

G4bool QuirkTransportation::m_momentumChanged

private

Definition at line 160 of file QuirkTransportation.h.

m_noLooperTrials

G4int QuirkTransportation::m_noLooperTrials

private

Definition at line 193 of file QuirkTransportation.h.

m_particleChange

G4ParticleChangeForTransport QuirkTransportation::m_particleChange

private

Definition at line 180 of file QuirkTransportation.h.

m_particleIsLooping

G4bool QuirkTransportation::m_particleIsLooping

private

Definition at line 164 of file QuirkTransportation.h.

m_previousSafety

G4double QuirkTransportation::m_previousSafety

private

Definition at line 177 of file QuirkTransportation.h.

m_previousSftOrigin

G4ThreeVector QuirkTransportation::m_previousSftOrigin

private

Definition at line 176 of file QuirkTransportation.h.

m_safetyHelper

G4SafetyHelper* QuirkTransportation::m_safetyHelper

private

Definition at line 202 of file QuirkTransportation.h.

m_shortStepOptimisation

G4bool QuirkTransportation::m_shortStepOptimisation

private

Definition at line 200 of file QuirkTransportation.h.

m_sumEnergyKilled

G4double QuirkTransportation::m_sumEnergyKilled

private

Definition at line 195 of file QuirkTransportation.h.

m_threshold_Important_Energy

G4double QuirkTransportation::m_threshold_Important_Energy

private

Definition at line 188 of file QuirkTransportation.h.

m_threshold_Warning_Energy

G4double QuirkTransportation::m_threshold_Warning_Energy

private

Definition at line 187 of file QuirkTransportation.h.

m_thresholdTrials

G4int QuirkTransportation::m_thresholdTrials

private

Definition at line 189 of file QuirkTransportation.h.

m_transportEndKineticEnergy

G4double QuirkTransportation::m_transportEndKineticEnergy

private

Definition at line 158 of file QuirkTransportation.h.

m_transportEndMomentumDir

G4ThreeVector QuirkTransportation::m_transportEndMomentumDir

private

Definition at line 157 of file QuirkTransportation.h.

m_transportEndPosition

G4ThreeVector QuirkTransportation::m_transportEndPosition

private

Definition at line 156 of file QuirkTransportation.h.

m_transportEndSpin

G4ThreeVector QuirkTransportation::m_transportEndSpin

private

Definition at line 159 of file QuirkTransportation.h.

m_verboseLevel

G4int QuirkTransportation::m_verboseLevel

private

Definition at line 205 of file QuirkTransportation.h.

---

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

• QuirkTransportation.h
• QuirkTransportation.cxx