#include <G4BiasingProcessInterface.hh>

Inheritance diagram for G4BiasingProcessInterface:

Public Member Functions
	G4BiasingProcessInterface (G4String name="biasWrapper(0)")

	G4BiasingProcessInterface (G4VProcess *wrappedProcess, G4bool wrappedIsAtRest, G4bool wrappedIsAlongStep, G4bool wrappedIsPostStep, G4String useThisName="")

	~G4BiasingProcessInterface ()

G4VProcess *	GetWrappedProcess () const

G4VBiasingOperator *	GetCurrentBiasingOperator () const

G4VBiasingOperator *	GetPreviousBiasingOperator () const

G4VBiasingOperation *	GetCurrentOccurenceBiasingOperation () const

G4VBiasingOperation *	GetPreviousOccurenceBiasingOperation () const

G4VBiasingOperation *	GetCurrentFinalStateBiasingOperation () const

G4VBiasingOperation *	GetPreviousFinalStateBiasingOperation () const

G4VBiasingOperation *	GetCurrentNonPhysicsBiasingOperation () const

G4VBiasingOperation *	GetPreviousNonPhysicsBiasingOperation () const

G4bool	GetIsFirstPostStepGPILInterface (G4bool physOnly=true) const

G4bool	GetIsLastPostStepGPILInterface (G4bool physOnly=true) const

G4bool	GetIsFirstPostStepDoItInterface (G4bool physOnly=true) const

G4bool	GetIsLastPostStepDoItInterface (G4bool physOnly=true) const

G4bool	IsFirstPostStepGPILInterface (G4bool physOnly=true) const

G4bool	IsLastPostStepGPILInterface (G4bool physOnly=true) const

G4bool	IsFirstPostStepDoItInterface (G4bool physOnly=true) const

G4bool	IsLastPostStepDoItInterface (G4bool physOnly=true) const

G4bool	GetWrappedProcessIsAtRest () const

G4bool	GetWrappedProcessIsAlong () const

G4bool	GetWrappedProcessIsPost () const

G4double	GetPreviousStepSize () const

G4double	GetCurrentMinimumStep () const

G4double	GetProposedSafety () const

void	SetProposedSafety (G4double sft)

G4double	GetPostStepGPIL () const

G4double	GetAlongStepGPIL () const

void	StartTracking (G4Track *track)

void	EndTracking ()

virtual G4double	PostStepGetPhysicalInteractionLength (const G4Track &track, G4double previousStepSize, G4ForceCondition *condition)

virtual G4VParticleChange *	PostStepDoIt (const G4Track &track, const G4Step &step)

virtual G4double	AlongStepGetPhysicalInteractionLength (const G4Track &track, G4double previousStepSize, G4double currentMinimumStep, G4double &proposedSafety, G4GPILSelection *selection)

virtual G4VParticleChange *	AlongStepDoIt (const G4Track &track, const G4Step &step)

virtual G4double	AtRestGetPhysicalInteractionLength (const G4Track &, G4ForceCondition *)

virtual G4VParticleChange *	AtRestDoIt (const G4Track &, const G4Step &)

virtual G4bool	IsApplicable (const G4ParticleDefinition &pd)

virtual void	BuildPhysicsTable (const G4ParticleDefinition &pd)

virtual void	PreparePhysicsTable (const G4ParticleDefinition &pd)

virtual G4bool	StorePhysicsTable (const G4ParticleDefinition *pd, const G4String &s, G4bool f)

virtual G4bool	RetrievePhysicsTable (const G4ParticleDefinition *pd, const G4String &s, G4bool f)

virtual void	SetProcessManager (const G4ProcessManager *)

virtual const G4ProcessManager *	GetProcessManager ()

virtual void	ResetNumberOfInteractionLengthLeft ()

virtual void	SetMasterProcess (G4VProcess *masterP)

virtual void	BuildWorkerPhysicsTable (const G4ParticleDefinition &pd)

virtual void	PrepareWorkerPhysicsTable (const G4ParticleDefinition &pd)

Public Member Functions inherited from G4VProcess
	G4VProcess (const G4String &aName="NoName", G4ProcessType aType=fNotDefined)

	G4VProcess (const G4VProcess &right)

virtual	~G4VProcess ()

G4int	operator== (const G4VProcess &right) const

G4int	operator!= (const G4VProcess &right) const

G4double	GetCurrentInteractionLength () const

void	SetPILfactor (G4double value)

G4double	GetPILfactor () const

G4double	AlongStepGPIL (const G4Track &track, G4double previousStepSize, G4double currentMinimumStep, G4double &proposedSafety, G4GPILSelection *selection)

G4double	AtRestGPIL (const G4Track &track, G4ForceCondition *condition)

G4double	PostStepGPIL (const G4Track &track, G4double previousStepSize, G4ForceCondition *condition)

const G4String &	GetPhysicsTableFileName (const G4ParticleDefinition *, const G4String &directory, const G4String &tableName, G4bool ascii=false)

const G4String &	GetProcessName () const

G4ProcessType	GetProcessType () const

void	SetProcessType (G4ProcessType)

G4int	GetProcessSubType () const

void	SetProcessSubType (G4int)

G4double	GetNumberOfInteractionLengthLeft () const

G4double	GetTotalNumberOfInteractionLengthTraversed () const

G4bool	isAtRestDoItIsEnabled () const

G4bool	isAlongStepDoItIsEnabled () const

G4bool	isPostStepDoItIsEnabled () const

virtual void	DumpInfo () const

void	SetVerboseLevel (G4int value)

G4int	GetVerboseLevel () const

const G4VProcess *	GetMasterProcess () const

Additional Inherited Members
Static Public Member Functions inherited from G4VProcess
static const G4String &	GetProcessTypeName (G4ProcessType)

Protected Member Functions inherited from G4VProcess
void	SubtractNumberOfInteractionLengthLeft (G4double previousStepSize)

void	ClearNumberOfInteractionLengthLeft ()

Protected Attributes inherited from G4VProcess
const G4ProcessManager *	aProcessManager

G4VParticleChange *	pParticleChange

G4ParticleChange	aParticleChange

G4double	theNumberOfInteractionLengthLeft

G4double	currentInteractionLength

G4double	theInitialNumberOfInteractionLength

G4String	theProcessName

G4String	thePhysicsTableFileName

G4ProcessType	theProcessType

G4int	theProcessSubType

G4double	thePILfactor

G4bool	enableAtRestDoIt

G4bool	enableAlongStepDoIt

G4bool	enablePostStepDoIt

G4int	verboseLevel

Detailed Description

Definition at line 68 of file G4BiasingProcessInterface.hh.

Constructor & Destructor Documentation

G4BiasingProcessInterface::G4BiasingProcessInterface ( G4String name = "biasWrapper(0)" )

Definition at line 45 of file G4BiasingProcessInterface.cc.

References G4Cache< VALTYPE >::Put().

   :  G4VProcess( name ),
      fCurrentBiasingOperator ( 0 ),
      fPreviousBiasingOperator( 0 ),
      fWrappedProcess        ( 0     ),
      fIsPhysicsBasedBiasing ( false ),
      fWrappedProcessIsAtRest( false ),
      fWrappedProcessIsAlong ( false ),
      fWrappedProcessIsPost  ( false ),
      fWrappedProcessInteractionLength( -1.0 ),
      fBiasingInteractionLaw ( 0 ),
      fPhysicalInteractionLaw( 0 ),
      fOccurenceBiasingParticleChange( 0 ),
      fIamFirstGPIL          ( false )
 {
   for (G4int i = 0 ; i < 8 ; i++)  fFirstLastFlags[i] = false;
     fResetInteractionLaws.Put( true );
     fCommonStart.Put(true);
     fCommonEnd.Put(true);
 }

G4BiasingProcessInterface::G4BiasingProcessInterface	(	G4VProcess *	wrappedProcess,
		G4bool	wrappedIsAtRest,
		G4bool	wrappedIsAlongStep,
		G4bool	wrappedIsPostStep,
		G4String	useThisName = `""`
	)

Definition at line 67 of file G4BiasingProcessInterface.cc.

References G4VProcess::GetProcessName(), G4VProcess::GetProcessSubType(), and G4VProcess::SetProcessSubType().

   : G4VProcess( useThisName != "" ? useThisName : "biasWrapper("+wrappedProcess->GetProcessName()+")",
            wrappedProcess->GetProcessType()),
     fCurrentBiasingOperator ( 0 ),
     fPreviousBiasingOperator( 0 ),
     fWrappedProcess        ( wrappedProcess     ),
     fIsPhysicsBasedBiasing ( true               ),
     fWrappedProcessIsAtRest( wrappedIsAtRest    ),
     fWrappedProcessIsAlong ( wrappedIsAlongStep ),
     fWrappedProcessIsPost  ( wrappedIsPostStep  ),
     fWrappedProcessInteractionLength( -1.0 ),
     fBiasingInteractionLaw ( 0 ),
     fPhysicalInteractionLaw( 0 ),
     fOccurenceBiasingParticleChange( 0 ),
     fIamFirstGPIL          ( false )
 {
   for (G4int i = 0 ; i < 8 ; i++)  fFirstLastFlags[i] = false;
   
   SetProcessSubType(fWrappedProcess->GetProcessSubType());
 
   // -- create physical interaction law:
   fPhysicalInteractionLaw         = new            G4InteractionLawPhysical("PhysicalInteractionLawFor("+GetProcessName()+")");
   // -- instantiate particle change wrapper for occurence biaising:
   fOccurenceBiasingParticleChange = new G4ParticleChangeForOccurenceBiasing("biasingPCfor"+GetProcessName());
   fParticleChange                 = new                    G4ParticleChange();
   // -- instantiate a "do nothing" particle change:
   fDummyParticleChange            = new          G4ParticleChangeForNothing();
 }

G4BiasingProcessInterface::~G4BiasingProcessInterface ( )

Definition at line 100 of file G4BiasingProcessInterface.cc.

 {
   if ( fPhysicalInteractionLaw  != 0   ) delete fPhysicalInteractionLaw;
   if ( fOccurenceBiasingParticleChange ) delete fOccurenceBiasingParticleChange;
   if ( fDummyParticleChange            ) delete fDummyParticleChange;
 }

Member Function Documentation

G4VParticleChange * G4BiasingProcessInterface::AlongStepDoIt	(	const G4Track &	track,
		const G4Step &	step
	)

virtual

Implements G4VProcess.

Definition at line 513 of file G4BiasingProcessInterface.cc.

References G4VBiasingOperation::AlongMoveBy(), G4VProcess::AlongStepDoIt(), G4InteractionLawPhysical::ComputeNonInteractionProbabilityAt(), G4endl, G4Exception(), G4VBiasingInteractionLaw::GetName(), G4Step::GetStepLength(), G4Track::GetTrackStatus(), G4ParticleChangeForNothing::Initialize(), JustWarning, G4VParticleChange::ProposeTrackStatus(), G4ParticleChangeForOccurenceBiasing::SetOccurenceWeightForNonInteraction(), and G4ParticleChangeForOccurenceBiasing::SetWrappedParticleChange().

 {
   // ---------------------------------------
   // -- case outside of volume with biasing:
   // ---------------------------------------
   if ( fCurrentBiasingOperator == 0 )
     {
       if ( fWrappedProcessIsAlong ) return fWrappedProcess->AlongStepDoIt(track, step);
       else
     {
       fDummyParticleChange->Initialize( track );
       return fDummyParticleChange;
     }
     }
   
   // -----------------------------------
   // -- case inside volume with biasing:
   // -----------------------------------
   if ( fWrappedProcessIsAlong ) fOccurenceBiasingParticleChange->SetWrappedParticleChange( fWrappedProcess->AlongStepDoIt(track, step) );
   else  
     {
       fOccurenceBiasingParticleChange->SetWrappedParticleChange ( 0 );
       fOccurenceBiasingParticleChange->ProposeTrackStatus( track.GetTrackStatus() );
     }
   G4double weightForNonInteraction (1.0);
   if ( fBiasingInteractionLaw != 0 ) 
     {
       weightForNonInteraction =
     fPhysicalInteractionLaw->ComputeNonInteractionProbabilityAt(step.GetStepLength()) /
     fBiasingInteractionLaw ->ComputeNonInteractionProbabilityAt(step.GetStepLength());
       
       fOccurenceBiasingOperation->AlongMoveBy( this, &step, weightForNonInteraction );
 
       if ( weightForNonInteraction <= 0. )
     {
       G4ExceptionDescription ed;
       ed << " Negative non interaction weight : w_NI = " << weightForNonInteraction <<
         " p_NI(phys) = " <<  fPhysicalInteractionLaw->ComputeNonInteractionProbabilityAt(step.GetStepLength()) <<
         " p_NI(bias) = " <<  fBiasingInteractionLaw ->ComputeNonInteractionProbabilityAt(step.GetStepLength()) <<
         " step length = "  <<  step.GetStepLength() <<
         " biasing interaction law = `" << fBiasingInteractionLaw->GetName() << "'" << G4endl;
       G4Exception(" G4BiasingProcessInterface::AlongStepDoIt(...)",
               "BIAS.GEN.04",
               JustWarning,
               ed);
     }
       
     }
   
   fOccurenceBiasingParticleChange->SetOccurenceWeightForNonInteraction( weightForNonInteraction );
   
   return fOccurenceBiasingParticleChange;
 
 }

G4double G4BiasingProcessInterface::AlongStepGetPhysicalInteractionLength	(	const G4Track &	track,
		G4double	previousStepSize,
		G4double	currentMinimumStep,
		G4double &	proposedSafety,
		G4GPILSelection *	selection
	)

virtual

Implements G4VProcess.

Definition at line 436 of file G4BiasingProcessInterface.cc.

References G4VProcess::AlongStepGetPhysicalInteractionLength(), DBL_MAX, NotCandidateForSelection, G4VBiasingOperation::ProposeAlongStepLimit(), and G4VBiasingOperation::ProposeGPILSelection().

 {
   // -- for helper methods:
   fCurrentMinimumStep = currentMinimumStep;
   fProposedSafety     = proposedSafety;
   
 
   // -- initialization default case:
   fWrappedProcessAlongStepGPIL =                  DBL_MAX;
   *selection                   = NotCandidateForSelection;
   // ---------------------------------------
   // -- case outside of volume with biasing:
   // ---------------------------------------
   if ( fCurrentBiasingOperator == 0 )
     {
       if ( fWrappedProcessIsAlong ) fWrappedProcessAlongStepGPIL = 
                       fWrappedProcess->AlongStepGetPhysicalInteractionLength(track,
                                                  previousStepSize,
                                                  currentMinimumStep, 
                                                  proposedSafety, 
                                                  selection);
       return fWrappedProcessAlongStepGPIL;
     }
   
   // --------------------------------------------------------------------
   // -- non-physics based biasing: no along operation expected (for now):
   // --------------------------------------------------------------------
   if ( !fIsPhysicsBasedBiasing ) return fWrappedProcessAlongStepGPIL;
   
   // ----------------------
   // -- physics-based case:
   // ----------------------
   if ( fOccurenceBiasingOperation == 0 )
     {
       if ( fWrappedProcessIsAlong ) fWrappedProcessAlongStepGPIL =
                       fWrappedProcess->AlongStepGetPhysicalInteractionLength(track,
                                                  previousStepSize,
                                                  currentMinimumStep, 
                                                  proposedSafety, 
                                                  selection);
       return fWrappedProcessAlongStepGPIL;
     }
 
   
   // ----------------------------------------------------------
   // -- From here we have an valid occurence biasing operation:
   // ----------------------------------------------------------
   // -- Give operation opportunity to shorten step proposed by physics process:
   fBiasingAlongStepGPIL =  fOccurenceBiasingOperation->ProposeAlongStepLimit( this );
   G4double minimumStep  = fBiasingAlongStepGPIL < currentMinimumStep ? fBiasingAlongStepGPIL : currentMinimumStep ;
   // -- wrapped process is called with minimum step ( <= currentMinimumStep passed ) : an along process can not
   // -- have its operation stretched over what it expects:
   if ( fWrappedProcessIsAlong )
     {
       fWrappedProcessAlongStepGPIL = fWrappedProcess->AlongStepGetPhysicalInteractionLength(track,
                                                 previousStepSize,
                                                 minimumStep, 
                                                 proposedSafety, 
                                                 selection);
       fWrappedProcessGPILSelection = *selection;
       fBiasingGPILSelection        = fOccurenceBiasingOperation->ProposeGPILSelection( fWrappedProcessGPILSelection );
     }
   else
     {
       fBiasingGPILSelection        = fOccurenceBiasingOperation->ProposeGPILSelection( NotCandidateForSelection );
       fWrappedProcessAlongStepGPIL = fBiasingAlongStepGPIL;
     }
   
   *selection = fBiasingGPILSelection;
   return fWrappedProcessAlongStepGPIL;
 
 }

G4VParticleChange * G4BiasingProcessInterface::AtRestDoIt	(	const G4Track &	track,
		const G4Step &	step
	)

virtual

Implements G4VProcess.

Definition at line 575 of file G4BiasingProcessInterface.cc.

References G4VProcess::AtRestDoIt().

 {
   return  fWrappedProcess->AtRestDoIt(track, step);
 }

G4double G4BiasingProcessInterface::AtRestGetPhysicalInteractionLength	(	const G4Track &	track,
		G4ForceCondition *	condition
	)

virtual

Implements G4VProcess.

Definition at line 570 of file G4BiasingProcessInterface.cc.

References G4VProcess::AtRestGetPhysicalInteractionLength().

 {
   return  fWrappedProcess->AtRestGetPhysicalInteractionLength(track, condition);
 }

void G4BiasingProcessInterface::BuildPhysicsTable ( const G4ParticleDefinition & pd )

virtual

Reimplemented from G4VProcess.

Definition at line 603 of file G4BiasingProcessInterface.cc.

References G4VProcess::BuildPhysicsTable(), and G4VBiasingOperator::GetBiasingOperators().

 {
   // -- Inform existing operators about start of the run.
   // -- IMPORTANT : as PreparePhysicsTable(...) has been called first for all processes,
   // -- the first/last flags and G4BiasingProcessInterface vector of processes have
   // -- been properly setup.
   if ( fIamFirstGPIL )
     {
       for ( size_t optr = 0 ; optr < ( G4VBiasingOperator::GetBiasingOperators() ).size() ; optr ++)
     ( G4VBiasingOperator::GetBiasingOperators() )[optr]->StartRun( );
     }
   
   if ( fWrappedProcess != 0 )
     {
        fWrappedProcess->BuildPhysicsTable(pd);
     }
 }

void G4BiasingProcessInterface::BuildWorkerPhysicsTable ( const G4ParticleDefinition & pd )

virtual

Reimplemented from G4VProcess.

Definition at line 654 of file G4BiasingProcessInterface.cc.

References G4VProcess::BuildWorkerPhysicsTable(), and G4VBiasingOperator::GetBiasingOperators().

 {
   // -- Inform existing operators about start of the run.
   // -- IMPORTANT : as PreparePhysicsTable(...) has been called first for all processes,
   // -- the first/last flags and G4BiasingProcessInterface vector of processes have
   // -- been properly setup.
   if ( fIamFirstGPIL )
     {
       for ( size_t optr = 0 ; optr < ( G4VBiasingOperator::GetBiasingOperators() ).size() ; optr ++)
     ( G4VBiasingOperator::GetBiasingOperators() )[optr]->StartRun( );
     }
 
   if ( fWrappedProcess != 0 )
     {
       fWrappedProcess->BuildWorkerPhysicsTable(pd);
     }
 }

void G4BiasingProcessInterface::EndTracking ( )

virtual

Reimplemented from G4VProcess.

Definition at line 139 of file G4BiasingProcessInterface.cc.

References G4VProcess::EndTracking(), G4VBiasingOperator::ExitingBiasing(), fKillTrackAndSecondaries, fStopAndKill, G4Cache< VALTYPE >::Get(), G4VBiasingOperator::GetBiasingOperators(), G4BiasingTrackDataStore::GetBiasingTrackData(), G4BiasingTrackDataStore::GetInstance(), G4Step::GetSecondary(), G4Track::GetStep(), G4Track::GetTrackStatus(), and G4Cache< VALTYPE >::Put().

 {
   if ( fIsPhysicsBasedBiasing ) fWrappedProcess->EndTracking();
   if ( fCurrentBiasingOperator) fCurrentBiasingOperator->ExitingBiasing( fCurrentTrack, this ); 
   fCurrentBiasingOperator   = 0;
   fPreviousBiasingOperator  = 0;
   fBiasingInteractionLaw = 0;
   
 
   // -- !! this part might have to be improved : could be time consuming
   // -- !! and assumes all tracks are killed during tracking, which is
   // -- !! not true : stacking operations may kill tracks
   if ( fCommonEnd.Get() )
     {
         fCommonEnd.Put( false );//   = false;
         fCommonStart.Put( true );//  = true;
       
       for ( size_t optr = 0 ; optr < ( G4VBiasingOperator::GetBiasingOperators() ).size() ; optr ++)
     ( G4VBiasingOperator::GetBiasingOperators() )[optr]->EndTracking( );
       
       if ( ( fCurrentTrack->GetTrackStatus() == fStopAndKill ) || ( fCurrentTrack->GetTrackStatus() == fKillTrackAndSecondaries ) )
     {
       G4BiasingTrackData* biasingData = G4BiasingTrackDataStore::GetInstance()->GetBiasingTrackData( fCurrentTrack );
       if ( biasingData ) delete biasingData; // -- this also deregisters the biasing data from the track data store
       if ( fCurrentTrack->GetTrackStatus() == fKillTrackAndSecondaries )
         {
           const G4TrackVector* secondaries = fCurrentTrack->GetStep()->GetSecondary();
           for ( size_t i2nd = 0 ; i2nd < secondaries->size() ; i2nd++ )
         {
           biasingData = G4BiasingTrackDataStore::GetInstance()->GetBiasingTrackData( (*secondaries)[i2nd] );
           if ( biasingData ) delete biasingData;
         }
         }
     }
     }
 }

G4double G4BiasingProcessInterface::GetAlongStepGPIL ( ) const

inline

Definition at line 136 of file G4BiasingProcessInterface.hh.

Referenced by G4BOptnForceCommonTruncatedExp::DenyProcessPostStepDoIt().

136 { return fWrappedProcessAlongStepGPIL; }

G4VBiasingOperator* G4BiasingProcessInterface::GetCurrentBiasingOperator ( ) const

inline

Definition at line 91 of file G4BiasingProcessInterface.hh.

91 {return fCurrentBiasingOperator; }

G4VBiasingOperation* G4BiasingProcessInterface::GetCurrentFinalStateBiasingOperation ( ) const

inline

Definition at line 96 of file G4BiasingProcessInterface.hh.

96 { return fFinalStateBiasingOperation; }

G4double G4BiasingProcessInterface::GetCurrentMinimumStep ( ) const

inline

Definition at line 131 of file G4BiasingProcessInterface.hh.

131 { return fCurrentMinimumStep;}

G4VBiasingOperation* G4BiasingProcessInterface::GetCurrentNonPhysicsBiasingOperation ( ) const

inline

Definition at line 98 of file G4BiasingProcessInterface.hh.

98 { return fNonPhysicsBiasingOperation; }

G4VBiasingOperation* G4BiasingProcessInterface::GetCurrentOccurenceBiasingOperation ( ) const

inline

Definition at line 94 of file G4BiasingProcessInterface.hh.

94 { return fOccurenceBiasingOperation; }

G4bool G4BiasingProcessInterface::GetIsFirstPostStepDoItInterface ( G4bool physOnly = true ) const

Definition at line 696 of file G4BiasingProcessInterface.cc.

 {
   G4int iPhys = ( physOnly ) ? 1 : 0;
   return fFirstLastFlags[IdxFirstLast( 1, 0, iPhys)];
 }

G4bool G4BiasingProcessInterface::GetIsFirstPostStepGPILInterface ( G4bool physOnly = true ) const

Definition at line 686 of file G4BiasingProcessInterface.cc.

 {
   G4int iPhys = ( physOnly ) ? 1 : 0;
   return fFirstLastFlags[IdxFirstLast( 1, 1, iPhys)];
 }

G4bool G4BiasingProcessInterface::GetIsLastPostStepDoItInterface ( G4bool physOnly = true ) const

Definition at line 701 of file G4BiasingProcessInterface.cc.

 {
   G4int iPhys = ( physOnly ) ? 1 : 0;
   return fFirstLastFlags[IdxFirstLast( 0, 0, iPhys)];
 }

G4bool G4BiasingProcessInterface::GetIsLastPostStepGPILInterface ( G4bool physOnly = true ) const

Definition at line 691 of file G4BiasingProcessInterface.cc.

 {
   G4int iPhys = ( physOnly ) ? 1 : 0;
   return fFirstLastFlags[IdxFirstLast( 0, 1, iPhys)];
 }

G4double G4BiasingProcessInterface::GetPostStepGPIL ( ) const

inline

Definition at line 135 of file G4BiasingProcessInterface.hh.

Referenced by G4BOptnForceCommonTruncatedExp::DenyProcessPostStepDoIt().

135 { return fBiasingPostStepGPIL; }

G4VBiasingOperator* G4BiasingProcessInterface::GetPreviousBiasingOperator ( ) const

inline

Definition at line 92 of file G4BiasingProcessInterface.hh.

92 {return fPreviousBiasingOperator; }

G4VBiasingOperation* G4BiasingProcessInterface::GetPreviousFinalStateBiasingOperation ( ) const

inline

Definition at line 97 of file G4BiasingProcessInterface.hh.

97 { return fPreviousFinalStateBiasingOperation; }

G4VBiasingOperation* G4BiasingProcessInterface::GetPreviousNonPhysicsBiasingOperation ( ) const

inline

Definition at line 99 of file G4BiasingProcessInterface.hh.

99 { return fPreviousNonPhysicsBiasingOperation; }

G4VBiasingOperation* G4BiasingProcessInterface::GetPreviousOccurenceBiasingOperation ( ) const

inline

Definition at line 95 of file G4BiasingProcessInterface.hh.

95 { return fPreviousOccurenceBiasingOperation; }

G4double G4BiasingProcessInterface::GetPreviousStepSize ( ) const

inline

Definition at line 130 of file G4BiasingProcessInterface.hh.

130 { return fPreviousStepSize;}

const G4ProcessManager * G4BiasingProcessInterface::GetProcessManager ( )

virtual

Reimplemented from G4VProcess.

Definition at line 649 of file G4BiasingProcessInterface.cc.

References G4VProcess::GetProcessManager().

 {
   if ( fWrappedProcess != 0 ) return fWrappedProcess->GetProcessManager();
   else                        return G4VProcess::GetProcessManager();
 }

G4double G4BiasingProcessInterface::GetProposedSafety ( ) const

inline

Definition at line 132 of file G4BiasingProcessInterface.hh.

132 { return fProposedSafety;}

G4VProcess* G4BiasingProcessInterface::GetWrappedProcess ( ) const

inline

Definition at line 83 of file G4BiasingProcessInterface.hh.

Referenced by G4BOptnForceCommonTruncatedExp::DenyProcessPostStepDoIt(), IsFirstPostStepDoItInterface(), IsFirstPostStepGPILInterface(), IsLastPostStepDoItInterface(), IsLastPostStepGPILInterface(), G4BOptnForceCommonTruncatedExp::ProposeAlongStepLimit(), and SetMasterProcess().

83 {return fWrappedProcess;}

G4bool G4BiasingProcessInterface::GetWrappedProcessIsAlong ( ) const

inline

Definition at line 125 of file G4BiasingProcessInterface.hh.

125 { return fWrappedProcessIsAlong; }

G4bool G4BiasingProcessInterface::GetWrappedProcessIsAtRest ( ) const

inline

Definition at line 124 of file G4BiasingProcessInterface.hh.

124 { return fWrappedProcessIsAtRest; }

G4bool G4BiasingProcessInterface::GetWrappedProcessIsPost ( ) const

inline

Definition at line 126 of file G4BiasingProcessInterface.hh.

126 { return fWrappedProcessIsPost; }

G4bool G4BiasingProcessInterface::IsApplicable ( const G4ParticleDefinition & pd )

virtual

Reimplemented from G4VProcess.

Definition at line 582 of file G4BiasingProcessInterface.cc.

References G4VProcess::IsApplicable().

 {
   if ( fWrappedProcess != 0 ) return fWrappedProcess->IsApplicable(pd);
   else                        return true;
 }

G4bool G4BiasingProcessInterface::IsFirstPostStepDoItInterface ( G4bool physOnly = true ) const

Definition at line 752 of file G4BiasingProcessInterface.cc.

References G4ProcessManager::GetPostStepProcessVector(), GetWrappedProcess(), G4ProcessVector::size(), and typeDoIt.

 {
   G4bool isFirst = true;
   const G4ProcessVector* pv = fProcessManager->GetPostStepProcessVector(typeDoIt);
   G4int thisIdx(-1);
   for (G4int i = 0; i < pv->size(); i++ ) if ( (*pv)(i) == this ) { thisIdx = i; break; }
   for ( size_t i = 0; i < fCoInterfaces->size(); i++ )
     {
       if ( ( (*fCoInterfaces)[i]->GetWrappedProcess() != 0  ) || !physOnly )
     {
       G4int thatIdx(-1);
       for (G4int j = 0; j < pv->size(); j++ ) if ( (*pv)(j) ==  (*fCoInterfaces)[i] ) { thatIdx = j; break; }
       if ( thisIdx >  thatIdx )
         {
           isFirst = false;
           break;
         }
     }
     }
   return isFirst;
 }

G4bool G4BiasingProcessInterface::IsFirstPostStepGPILInterface ( G4bool physOnly = true ) const

Definition at line 708 of file G4BiasingProcessInterface.cc.

References G4ProcessManager::GetPostStepProcessVector(), GetWrappedProcess(), G4ProcessVector::size(), and typeGPIL.

 {
   G4bool isFirst = true;
   const G4ProcessVector* pv = fProcessManager->GetPostStepProcessVector(typeGPIL);
   G4int thisIdx(-1);
   for (G4int i = 0; i < pv->size(); i++ ) if ( (*pv)(i) == this ) { thisIdx = i; break; }
   for ( size_t i = 0; i < fCoInterfaces->size(); i++ )
     {
       if ( ( (*fCoInterfaces)[i]->GetWrappedProcess() != 0 ) || !physOnly )
     {
       G4int thatIdx(-1);
       for (G4int j = 0; j < pv->size(); j++ ) if ( (*pv)(j) ==  (*fCoInterfaces)[i] ) { thatIdx = j; break; }
       if ( thisIdx >  thatIdx )
         {
           isFirst = false;
           break;
         }
     }
     }
   return isFirst;
 }

G4bool G4BiasingProcessInterface::IsLastPostStepDoItInterface ( G4bool physOnly = true ) const

Definition at line 774 of file G4BiasingProcessInterface.cc.

References G4ProcessManager::GetPostStepProcessVector(), GetWrappedProcess(), G4ProcessVector::size(), and typeDoIt.

 {
   G4bool isLast = true;
   const G4ProcessVector* pv = fProcessManager->GetPostStepProcessVector(typeDoIt);
   G4int thisIdx(-1);
   for (G4int i = 0; i < pv->size(); i++ ) if ( (*pv)(i) == this ) { thisIdx = i; break; }
   for ( size_t i = 0; i < fCoInterfaces->size(); i++ )
     {
       if ( ( (*fCoInterfaces)[i]->GetWrappedProcess() != 0  ) || !physOnly )
     {
       G4int thatIdx(-1);
       for (G4int j = 0; j < pv->size(); j++ ) if ( (*pv)(j) ==  (*fCoInterfaces)[i] ) { thatIdx = j; break; }
       if ( thisIdx <  thatIdx )
         {
           isLast = false;
           break;
         }
     }
     }
   return isLast;  
 }

G4bool G4BiasingProcessInterface::IsLastPostStepGPILInterface ( G4bool physOnly = true ) const

Definition at line 730 of file G4BiasingProcessInterface.cc.

References G4ProcessManager::GetPostStepProcessVector(), GetWrappedProcess(), G4ProcessVector::size(), and typeGPIL.

 {
   G4bool isLast = true;
   const G4ProcessVector* pv = fProcessManager->GetPostStepProcessVector(typeGPIL);
   G4int thisIdx(-1);
   for (G4int i = 0; i < pv->size(); i++ ) if ( (*pv)(i) == this ) { thisIdx = i; break; }
   for ( size_t i = 0; i < fCoInterfaces->size(); i++ )
     {
       if ( ( (*fCoInterfaces)[i]->GetWrappedProcess() != 0  ) || !physOnly )
     {
       G4int thatIdx(-1);
       for (G4int j = 0; j < pv->size(); j++ ) if ( (*pv)(j) ==  (*fCoInterfaces)[i] ) { thatIdx = j; break; }
       if ( thisIdx <  thatIdx )
         {
           isLast = false;
           break;
         }
     }
     }
   return isLast;  
 }

G4VParticleChange * G4BiasingProcessInterface::PostStepDoIt	(	const G4Track &	track,
		const G4Step &	step
	)

virtual

Implements G4VProcess.

Definition at line 316 of file G4BiasingProcessInterface.cc.

References G4VBiasingOperation::ApplyFinalStateBiasing(), BAC_DenyInteraction, BAC_FinalState, BAC_None, BAC_NonPhysics, G4InteractionLawPhysical::ComputeEffectiveCrossSectionAt(), G4VBiasingInteractionLaw::ComputeEffectiveCrossSectionAt(), G4VBiasingOperation::DenyProcessPostStepDoIt(), G4endl, G4Exception(), G4VBiasingOperation::GenerateBiasingFinalState(), G4VBiasingOperator::GetProposedFinalStateBiasingOperation(), G4Step::GetStepLength(), G4VParticleChange::GetTrackStatus(), G4Track::GetWeight(), G4ParticleChange::Initialize(), G4VBiasingInteractionLaw::IsEffectiveCrossSectionInfinite(), G4VBiasingInteractionLaw::IsSingular(), JustWarning, G4VProcess::PostStepDoIt(), G4VParticleChange::ProposeParentWeight(), G4VParticleChange::ProposeTrackStatus(), G4VBiasingOperator::ReportOperationApplied(), G4ParticleChangeForOccurenceBiasing::SetOccurenceWeightForInteraction(), G4VParticleChange::SetSecondaryWeightByProcess(), G4ParticleChangeForOccurenceBiasing::SetWrappedParticleChange(), and G4ParticleChangeForOccurenceBiasing::StealSecondaries().

 {
   // ---------------------------------------
   // -- case outside of volume with biasing:
   // ---------------------------------------
   if ( fCurrentBiasingOperator == 0 ) return fWrappedProcess->PostStepDoIt(track, step);
   
   // ----------------------------
   // -- non-physics biasing case:
   // ----------------------------
   if ( !fIsPhysicsBasedBiasing )
     {
       G4VParticleChange* particleChange = fNonPhysicsBiasingOperation->GenerateBiasingFinalState( &track, &step );
       fCurrentBiasingOperator->ReportOperationApplied( this, BAC_NonPhysics, fNonPhysicsBiasingOperation, particleChange );
       return particleChange;
     }
 
   // -- physics biasing case:
   // ------------------------
   // -- It proceeds with the following logic:
   // -- 1) If an occurence biasing operation exists, it makes the
   // --    decision about the interaction to happen or not.
   // --    If the occurence operation refuses the interaction, it
   // --    can only propose a new track weight.
   // -- 2) The interaction is produced by the final state biasing
   // --    operation, if it exists, or by the wrapped process in
   // --    the other case.
   // -- Hence 2) happens if 1) decides so
   //          2) happens if there is no occurence biasing operation
   if ( fOccurenceBiasingOperation != 0 )
     {
       G4double proposedTrackWeight = track.GetWeight();
       if ( fOccurenceBiasingOperation->DenyProcessPostStepDoIt( this, &track, &step, proposedTrackWeight ) )
     {
       fParticleChange->Initialize( track ); // **??** <= might  use a light version for particle change here
       fParticleChange->ProposeParentWeight( proposedTrackWeight );
       fCurrentBiasingOperator->ReportOperationApplied( this, BAC_DenyInteraction, fOccurenceBiasingOperation, fParticleChange );
       return fParticleChange;
     }
     }
 
   
   // -- usual case with generated final state:
   G4VParticleChange*   finalStateParticleChange;
   G4BiasingAppliedCase BAC;
   fFinalStateBiasingOperation = fCurrentBiasingOperator->GetProposedFinalStateBiasingOperation( &track, this );
   if ( fFinalStateBiasingOperation != 0 )
     {
       finalStateParticleChange = fFinalStateBiasingOperation->ApplyFinalStateBiasing( this, &track, &step );
       BAC = BAC_FinalState;
     }
   else
     {
       finalStateParticleChange = fWrappedProcess->PostStepDoIt(track, step);
       BAC =  BAC_None ;
     }
   // -- if no occurence biasing operation, we're done:
   if ( fOccurenceBiasingOperation == 0 )
     {
       fCurrentBiasingOperator->ReportOperationApplied( this, BAC, fFinalStateBiasingOperation, finalStateParticleChange );
       return finalStateParticleChange;
     }
   
   // -- If occurence biasing, applies on top of final state occurence biasing weight correction:
   G4double weightForInteraction = 1.0;
   if ( !fBiasingInteractionLaw->IsSingular() ) weightForInteraction =
                          fPhysicalInteractionLaw->ComputeEffectiveCrossSectionAt(step.GetStepLength()) /
                          fBiasingInteractionLaw ->ComputeEffectiveCrossSectionAt(step.GetStepLength());
   else
     {
       // -- at this point effective XS can only be infinite, if not, there is a logic problem
       if ( !fBiasingInteractionLaw->IsEffectiveCrossSectionInfinite() )
     {
       G4ExceptionDescription ed;
       ed << "Internal inconsistency in cross-section handling. Please report !" << G4endl;
       G4Exception(" G4BiasingProcessInterface::PostStepDoIt(...)",
               "BIAS.GEN.02",
               JustWarning,
               ed);
       // -- if XS is infinite, weight is zero (and will stay zero), but we'll do differently.
       // -- Should foresee in addition something to remember that in case of singular
       // -- distribution, weight can only be partly calculated
     }
     }
   
   if ( weightForInteraction <= 0. )
     {
       G4ExceptionDescription ed;
       ed << " Negative interaction weight : w_I = "
      <<  weightForInteraction <<
     " XS_I(phys) = " << fBiasingInteractionLaw ->ComputeEffectiveCrossSectionAt(step.GetStepLength()) <<
     " XS_I(bias) = " << fPhysicalInteractionLaw->ComputeEffectiveCrossSectionAt(step.GetStepLength()) <<
     " step length = " << step.GetStepLength() <<
     " Interaction law = `" << fBiasingInteractionLaw << "'" <<
     G4endl;
       G4Exception(" G4BiasingProcessInterface::PostStepDoIt(...)",
           "BIAS.GEN.03",
           JustWarning,
           ed);
       
     }
   
   fCurrentBiasingOperator->ReportOperationApplied( this,                        BAC,
                            fOccurenceBiasingOperation,  weightForInteraction,
                            fFinalStateBiasingOperation, finalStateParticleChange );  
 
   fOccurenceBiasingParticleChange->SetOccurenceWeightForInteraction( weightForInteraction );
   fOccurenceBiasingParticleChange->SetSecondaryWeightByProcess( true );
   fOccurenceBiasingParticleChange->SetWrappedParticleChange( finalStateParticleChange );
   fOccurenceBiasingParticleChange->ProposeTrackStatus( finalStateParticleChange->GetTrackStatus() );
   fOccurenceBiasingParticleChange->StealSecondaries(); // -- this also makes weightForInteraction applied to secondaries stolen
 
   // -- finish:
   return fOccurenceBiasingParticleChange;
   
 }

G4double G4BiasingProcessInterface::PostStepGetPhysicalInteractionLength	(	const G4Track &	track,
		G4double	previousStepSize,
		G4ForceCondition *	condition
	)

virtual

Implements G4VProcess.

Definition at line 178 of file G4BiasingProcessInterface.cc.

References condition(), DBL_MAX, G4VBiasingOperation::DistanceToApplyOperation(), G4VBiasingOperator::ExitingBiasing(), fGeomBoundary, G4VBiasingOperator::GetBiasingOperator(), G4VProcess::GetCurrentInteractionLength(), G4Track::GetCurrentStepNumber(), G4VPhysicalVolume::GetLogicalVolume(), G4Step::GetPreStepPoint(), G4VBiasingOperator::GetProposedNonPhysicsBiasingOperation(), G4VBiasingOperator::GetProposedOccurenceBiasingOperation(), G4VBiasingInteractionLaw::GetSampledInteractionLength(), G4Track::GetStep(), G4StepPoint::GetStepStatus(), G4Track::GetVolume(), NotCandidateForSelection, NotForced, G4VProcess::PostStepGetPhysicalInteractionLength(), G4VBiasingOperation::ProposeForceCondition(), G4VBiasingOperation::ProvideOccurenceBiasingInteractionLaw(), G4VProcess::ResetNumberOfInteractionLengthLeft(), and G4InteractionLawPhysical::SetPhysicalCrossSection().

 {
   // -- Remember previous operator and proposed operations, if any, and reset:
   // -------------------------------------------------------------------------
   // -- remember:
   fPreviousBiasingOperator            =     fCurrentBiasingOperator;
   fPreviousOccurenceBiasingOperation  =  fOccurenceBiasingOperation;
   fPreviousFinalStateBiasingOperation = fFinalStateBiasingOperation;
   fPreviousNonPhysicsBiasingOperation = fNonPhysicsBiasingOperation;
   fPreviousBiasingInteractionLaw      =      fBiasingInteractionLaw;
   // -- reset:
   fOccurenceBiasingOperation          =                           0;
   fFinalStateBiasingOperation         =                           0;
   fNonPhysicsBiasingOperation         =                           0;
   fBiasingInteractionLaw              =                           0;
   // -- Physics PostStep and AlongStep GPIL
   fWrappedProcessPostStepGPIL         =                     DBL_MAX;
   fBiasingPostStepGPIL                =                     DBL_MAX;
   fWrappedProcessInteractionLength    =                     DBL_MAX; // -- inverse of analog cross-section, no biasing counter-part in general
   fWrappedProcessForceCondition       =                   NotForced;
   fBiasingForceCondition              =                   NotForced;
   fWrappedProcessAlongStepGPIL        =                     DBL_MAX;
   fBiasingAlongStepGPIL               =                     DBL_MAX;
   fWrappedProcessGPILSelection        =    NotCandidateForSelection;
   fBiasingGPILSelection               =    NotCandidateForSelection;
   // -- for helper:
   fPreviousStepSize                   =            previousStepSize;
 
 
   // -- If new volume, get possible new biasing operator:
   // ----------------------------------------------------
   // -- [Note : bug with this first step ! Does not work if previous step was concurrently limited with geometry]
   G4bool  firstStepInVolume = ( (track.GetStep()->GetPreStepPoint()->GetStepStatus() == fGeomBoundary) || (track.GetCurrentStepNumber() == 1) );
   if ( firstStepInVolume ) fCurrentBiasingOperator = G4VBiasingOperator::GetBiasingOperator( track.GetVolume()->GetLogicalVolume() );
 
   // -----------------------------------
   // -- Previous step was under biasing:
   // -----------------------------------
   if ( fPreviousBiasingOperator != 0 )
     {
       // -- if current step not under same operator, let this operator knows:
       if ( fPreviousBiasingOperator != fCurrentBiasingOperator ) fPreviousBiasingOperator->ExitingBiasing( &track, this ); 
       // -- if biasing does not continue, set process behavior to standard tracking:
       // -- ... and see [*] below...
       if ( fCurrentBiasingOperator == 0 )
     {
       fResetWrappedProcessInteractionLength = true;
       ResetForUnbiasedTracking();
     }
     }
   
   // --------------------------------------------------------------
   // -- no operator : analog tracking if physics-based, or nothing:
   // --------------------------------------------------------------
   if ( fCurrentBiasingOperator == 0 )
     {
       if ( fIsPhysicsBasedBiasing ) 
     {
       // -- [*] this wrapped process has just been ResetForUnbiasedTracking(), it has a fresh #int length, and is
       // -- in a state where it believes it is starting tracking : let it believe hence the previous step
       // -- length was 0.0, as for a normal first step:
       if ( fResetWrappedProcessInteractionLength )
         {
           fResetWrappedProcessInteractionLength = false;
           fWrappedProcess->ResetNumberOfInteractionLengthLeft();
           return fWrappedProcess->PostStepGetPhysicalInteractionLength(track, 0.0, condition);
         }
       return fWrappedProcess->PostStepGetPhysicalInteractionLength(track, previousStepSize, condition);
     }
       else
     {
       *condition = NotForced;
       return DBL_MAX;
     }
     }
 
   
 
   // --------------------------------------------------
   // -- An biasing operator exists. Proceed with
   // -- treating non-physics and physics biasing cases:
   //---------------------------------------------------
   
   // -- non-physics-based biasing case:
   // ----------------------------------
   if ( !fIsPhysicsBasedBiasing )
     {  
       fNonPhysicsBiasingOperation = fCurrentBiasingOperator->GetProposedNonPhysicsBiasingOperation( &track, this );
       if ( fNonPhysicsBiasingOperation == 0 )
     {
       *condition = NotForced;
       return DBL_MAX;
     }
       return fNonPhysicsBiasingOperation->DistanceToApplyOperation(&track, previousStepSize, condition);
     }
   
 
   // -- Physics based biasing case:
   // ------------------------------
   // -- call to underneath physics process PostStepGPIL to update it with current point:
   fWrappedProcessPostStepGPIL   = fWrappedProcess->PostStepGetPhysicalInteractionLength(track, previousStepSize, condition);
   fWrappedProcessForceCondition = *condition;
   // -- **! At this point, might have to be careful of previousStepSize being larger than the previous process
   // -- **! PostStepGPIL proposed: as we disregard this PostStepGPIL value, such situation does happen. Does not
   // -- **! look to have generated problems for now, but might be fragile.
 
   // -- Ask for possible GPIL biasing operation:
   fOccurenceBiasingOperation = fCurrentBiasingOperator->GetProposedOccurenceBiasingOperation( &track, this );
 
   // -- no operation for occurence biasing, analog GPIL returns the wrapped process GPIL and condition values
   // -- (note that condition was set above):
   if ( fOccurenceBiasingOperation == 0 ) return fWrappedProcessPostStepGPIL;
 
   // -- A valid GPIL biasing operation has been proposed:
   // -- 0) remember wrapped process will need to be reset on biasing exit, if particle survives:
   fResetWrappedProcessInteractionLength = true;
   // -- 1) collect/update process interaction length for reference analog interaction law:
   fWrappedProcessInteractionLength = fWrappedProcess->GetCurrentInteractionLength();
   fPhysicalInteractionLaw->SetPhysicalCrossSection( 1.0 / fWrappedProcessInteractionLength );
   // -- 2) Collect biasing interaction law:
   // --    The interaction law pointer is collected as a const pointer to the interaction law object.
   // --    This interaction law will be kept under control of the biasing operation, which is the only
   // --    entity that will change the state of the biasing interaction law.
   fBiasingInteractionLaw            = fOccurenceBiasingOperation->ProvideOccurenceBiasingInteractionLaw( this );
   // -- 3) Ask operation to sample the biasing interaction law:
   fBiasingPostStepGPIL              = fBiasingInteractionLaw->GetSampledInteractionLength();
   fBiasingForceCondition            = fOccurenceBiasingOperation->ProposeForceCondition( fWrappedProcessForceCondition );
 
   // -- finish
   *condition = fBiasingForceCondition;
   return       fBiasingPostStepGPIL;
 
 }

void G4BiasingProcessInterface::PreparePhysicsTable ( const G4ParticleDefinition & pd )

virtual

Reimplemented from G4VProcess.

Definition at line 620 of file G4BiasingProcessInterface.cc.

References G4VProcess::PreparePhysicsTable().

 {
   // -- Let process finding its first/last position in the process manager:
   SetUpFirstLastFlags();
   if ( fWrappedProcess != 0 )
     {
        fWrappedProcess->PreparePhysicsTable(pd);
     }
 }

void G4BiasingProcessInterface::PrepareWorkerPhysicsTable ( const G4ParticleDefinition & pd )

virtual

Reimplemented from G4VProcess.

Definition at line 671 of file G4BiasingProcessInterface.cc.

References G4VProcess::PrepareWorkerPhysicsTable().

 {
  // -- Let process finding its first/last position in the process manager:
   SetUpFirstLastFlags();
   if ( fWrappedProcess != 0 )
     {
       fWrappedProcess->PrepareWorkerPhysicsTable(pd);
     }  
 }

void G4BiasingProcessInterface::ResetNumberOfInteractionLengthLeft ( )

virtual

Reimplemented from G4VProcess.

Definition at line 680 of file G4BiasingProcessInterface.cc.

References G4VProcess::ResetNumberOfInteractionLengthLeft().

 {
   if ( fWrappedProcess != 0 ) fWrappedProcess->ResetNumberOfInteractionLengthLeft();
 }

G4bool G4BiasingProcessInterface::RetrievePhysicsTable	(	const G4ParticleDefinition *	pd,
		const G4String &	s,
		G4bool	f
	)

virtual

Reimplemented from G4VProcess.

Definition at line 634 of file G4BiasingProcessInterface.cc.

References G4VProcess::RetrievePhysicsTable().

 {
   if ( fWrappedProcess != 0 ) return fWrappedProcess->RetrievePhysicsTable(pd, s, f);
   else                        return false;
 }

void G4BiasingProcessInterface::SetMasterProcess ( G4VProcess * masterP )

virtual

Reimplemented from G4VProcess.

Definition at line 589 of file G4BiasingProcessInterface.cc.

References G4VProcess::GetMasterProcess(), GetWrappedProcess(), and G4VProcess::SetMasterProcess().

 {
   // -- Master for this process:
   G4VProcess::SetMasterProcess(masterP);
   // -- Master for wrapped process:
   if ( fWrappedProcess != 0 )
     {
       const G4BiasingProcessInterface* thisWrapperMaster = (const G4BiasingProcessInterface *)GetMasterProcess();
       // -- paranoia check:
       G4VProcess* wrappedMaster = 0;
       wrappedMaster = thisWrapperMaster->GetWrappedProcess();
       fWrappedProcess->SetMasterProcess( wrappedMaster );
     }
 }

void G4BiasingProcessInterface::SetProcessManager ( const G4ProcessManager * mgr )

virtual

Reimplemented from G4VProcess.

Definition at line 640 of file G4BiasingProcessInterface.cc.

References G4VProcess::SetProcessManager().

 {
   if ( fWrappedProcess != 0 ) fWrappedProcess->SetProcessManager(mgr);
   else                        G4VProcess::SetProcessManager(mgr);
   (fManagerInterfaceMap[mgr]).push_back(this);
   fCoInterfaces = &(fManagerInterfaceMap[mgr]);
   fProcessManager = mgr;
 }

void G4BiasingProcessInterface::SetProposedSafety ( G4double sft )

inline

Definition at line 133 of file G4BiasingProcessInterface.hh.

133 { fProposedSafety = sft;}

void G4BiasingProcessInterface::StartTracking ( G4Track * track )

virtual

Reimplemented from G4VProcess.

Definition at line 108 of file G4BiasingProcessInterface.cc.

References G4Cache< VALTYPE >::Get(), G4VBiasingOperator::GetBiasingOperators(), G4Cache< VALTYPE >::Put(), and G4VProcess::StartTracking().

 {
   fCurrentTrack = track;
   if ( fIsPhysicsBasedBiasing ) fWrappedProcess->StartTracking(fCurrentTrack);
   fCurrentBiasingOperator             = 0;
   fPreviousBiasingOperator            = 0;
   fOccurenceBiasingOperation          = 0;
   fPreviousOccurenceBiasingOperation  = 0;
   fFinalStateBiasingOperation         = 0;
   fPreviousFinalStateBiasingOperation = 0;
   fNonPhysicsBiasingOperation         = 0;
   fPreviousNonPhysicsBiasingOperation = 0;
   fBiasingInteractionLaw              = 0;
   fPreviousBiasingInteractionLaw      = 0;
   
   fPreviousStepSize           = -1.0;
   
   
   fResetWrappedProcessInteractionLength = false;
   
   if ( fCommonStart.Get() )
     {
         fCommonStart.Put( false );// = false;
         fCommonEnd.Put(true);//   = true;
       
       for ( size_t optr = 0 ; optr < ( G4VBiasingOperator::GetBiasingOperators() ).size() ; optr ++)
     ( G4VBiasingOperator::GetBiasingOperators() )[optr]->StartTracking( fCurrentTrack );
     }
 }

G4bool G4BiasingProcessInterface::StorePhysicsTable	(	const G4ParticleDefinition *	pd,
		const G4String &	s,
		G4bool	f
	)

virtual

Reimplemented from G4VProcess.

Definition at line 629 of file G4BiasingProcessInterface.cc.

References G4VProcess::StorePhysicsTable().

 {
   if ( fWrappedProcess != 0 ) return fWrappedProcess->StorePhysicsTable(pd, s, f);
   else                        return false;
 }

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

Public Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation