G4BOptrForceCollision Class Reference

#include <G4BOptrForceCollision.hh>

Inheritance diagram for G4BOptrForceCollision:

Public Member Functions
void	AttachTo (const G4LogicalVolume *)
virtual void	Configure () final
virtual void	ConfigureForWorker () final
virtual void	EndTracking () final
virtual void	ExitBiasing (const G4Track *, const G4BiasingProcessInterface *) final
void	ExitingBiasing (const G4Track *track, const G4BiasingProcessInterface *callingProcess)
	G4BOptrForceCollision (const G4ParticleDefinition *particleToForce, G4String name="ForceCollision")
	G4BOptrForceCollision (G4String particleToForce, G4String name="ForceCollision")
const G4String	GetName () const
G4BiasingAppliedCase	GetPreviousBiasingAppliedCase () const
const G4VBiasingOperation *	GetPreviousNonPhysicsAppliedOperation ()
G4VBiasingOperation *	GetProposedFinalStateBiasingOperation (const G4Track *track, const G4BiasingProcessInterface *callingProcess)
G4VBiasingOperation *	GetProposedNonPhysicsBiasingOperation (const G4Track *track, const G4BiasingProcessInterface *callingProcess)
G4VBiasingOperation *	GetProposedOccurenceBiasingOperation (const G4Track *track, const G4BiasingProcessInterface *callingProcess)
void	OperationApplied (const G4BiasingProcessInterface *callingProcess, G4BiasingAppliedCase biasingCase, G4VBiasingOperation *occurenceOperationApplied, G4double weightForOccurenceInteraction, G4VBiasingOperation *finalStateOperationApplied, const G4VParticleChange *particleChangeProduced) final
void	OperationApplied (const G4BiasingProcessInterface *callingProcess, G4BiasingAppliedCase biasingCase, G4VBiasingOperation *operationApplied, const G4VParticleChange *particleChangeProduced) final
void	ReportOperationApplied (const G4BiasingProcessInterface *callingProcess, G4BiasingAppliedCase biasingCase, G4VBiasingOperation *occurenceOperationApplied, G4double weightForOccurenceInteraction, G4VBiasingOperation *finalStateOperationApplied, const G4VParticleChange *particleChangeProduced)
void	ReportOperationApplied (const G4BiasingProcessInterface *callingProcess, G4BiasingAppliedCase biasingCase, G4VBiasingOperation *operationApplied, const G4VParticleChange *particleChangeProduced)
virtual void	StartRun () final
virtual void	StartTracking (const G4Track *track) final
	~G4BOptrForceCollision ()

Static Public Member Functions
static G4VBiasingOperator *	GetBiasingOperator (const G4LogicalVolume *)
static const std::vector< G4VBiasingOperator * > &	GetBiasingOperators ()

Private Member Functions
virtual G4VBiasingOperation *	ProposeFinalStateBiasingOperation (const G4Track *track, const G4BiasingProcessInterface *callingProcess) final
virtual G4VBiasingOperation *	ProposeNonPhysicsBiasingOperation (const G4Track *track, const G4BiasingProcessInterface *callingProcess) final
virtual G4VBiasingOperation *	ProposeOccurenceBiasingOperation (const G4Track *track, const G4BiasingProcessInterface *callingProcess) final

Private Attributes
G4BOptnCloning *	fCloningOperation
const G4Track *	fCurrentTrack
G4BOptrForceCollisionTrackData *	fCurrentTrackData
std::map< const G4LogicalVolume *, G4int >	fDepthInTree
G4VBiasingOperation *	fFinalStateBiasingOperation
G4int	fForceCollisionModelID
std::map< const G4BiasingProcessInterface *, G4BOptnForceFreeFlight * >	fFreeFlightOperations
G4double	fInitialTrackWeight
const G4String	fName
G4VBiasingOperation *	fNonPhysicsBiasingOperation
G4VBiasingOperation *	fOccurenceBiasingOperation
const G4ParticleDefinition *	fParticleToBias
const G4VBiasingOperation *	fPreviousAppliedFinalStateBiasingOperation
const G4VBiasingOperation *	fPreviousAppliedNonPhysicsBiasingOperation
const G4VBiasingOperation *	fPreviousAppliedOccurenceBiasingOperation
G4BiasingAppliedCase	fPreviousBiasingAppliedCase
const G4VBiasingOperation *	fPreviousProposedFinalStateBiasingOperation
const G4VBiasingOperation *	fPreviousProposedNonPhysicsBiasingOperation
const G4VBiasingOperation *	fPreviousProposedOccurenceBiasingOperation
std::vector< const G4LogicalVolume * >	fRootVolumes
G4bool	fSetup
G4BOptnForceCommonTruncatedExp *	fSharedForceInteractionOperation

Static Private Attributes
static G4MapCache< const G4LogicalVolume *, G4VBiasingOperator * >	fLogicalToSetupMap
static G4VectorCache< G4VBiasingOperator * >	fOperators
static G4Cache< G4BiasingOperatorStateNotifier * >	fStateNotifier

Detailed Description

Definition at line 58 of file G4BOptrForceCollision.hh.

Constructor & Destructor Documentation

G4BOptrForceCollision() [1/2]

G4BOptrForceCollision::G4BOptrForceCollision	(	G4String	particleToForce,
		G4String	name = "ForceCollision"
	)

Definition at line 46 of file G4BOptrForceCollision.cc.

  : G4VBiasingOperator(name),
    fForceCollisionModelID(G4PhysicsModelCatalog::GetModelID("model_GenBiasForceCollision")),
    fCurrentTrack(nullptr),
    fCurrentTrackData(nullptr),
    fInitialTrackWeight(-1.0),
    fSetup(true)
{
  fSharedForceInteractionOperation = new G4BOptnForceCommonTruncatedExp("SharedForceInteraction");
  fCloningOperation                = new G4BOptnCloning("Cloning");
  fParticleToBias = G4ParticleTable::GetParticleTable()->FindParticle(particleName);
  
  if ( fParticleToBias == 0 )
    {
      G4ExceptionDescription ed;
      ed << " Particle `" << particleName << "' not found !" << G4endl;
      G4Exception(" G4BOptrForceCollision::G4BOptrForceCollision(...)",
          "BIAS.GEN.07",
          JustWarning,
          ed);
    }
}

References fCloningOperation, G4ParticleTable::FindParticle(), fParticleToBias, fSharedForceInteractionOperation, G4endl, G4Exception(), G4ParticleTable::GetParticleTable(), and JustWarning.

G4BOptrForceCollision() [2/2]

G4BOptrForceCollision::G4BOptrForceCollision	(	const G4ParticleDefinition *	particleToForce,
		G4String	name = "ForceCollision"
	)

Definition at line 70 of file G4BOptrForceCollision.cc.

  : G4VBiasingOperator(name),
    fForceCollisionModelID(G4PhysicsModelCatalog::GetModelID("model_GenBiasForceCollision")),
    fCurrentTrack(nullptr),
    fCurrentTrackData(nullptr),
    fInitialTrackWeight(-1.0),
    fSetup(true)
{
  fSharedForceInteractionOperation = new G4BOptnForceCommonTruncatedExp("SharedForceInteraction");
  fCloningOperation                = new G4BOptnCloning("Cloning");
  fParticleToBias                  = particle;
}

References fCloningOperation, fParticleToBias, and fSharedForceInteractionOperation.

~G4BOptrForceCollision()

G4BOptrForceCollision::~G4BOptrForceCollision

(

)

Definition at line 84 of file G4BOptrForceCollision.cc.

{
  for ( std::map< const G4BiasingProcessInterface*, G4BOptnForceFreeFlight* >::iterator it = fFreeFlightOperations.begin() ;
    it != fFreeFlightOperations.end() ;
    it++ ) delete (*it).second;
  delete fSharedForceInteractionOperation;
  delete fCloningOperation;
}

References fCloningOperation, fFreeFlightOperations, and fSharedForceInteractionOperation.

Member Function Documentation

AttachTo()

void G4VBiasingOperator::AttachTo ( const G4LogicalVolume *  logical )

inherited

Definition at line 59 of file G4VBiasingOperator.cc.

{
  G4MapCache< const G4LogicalVolume*, G4VBiasingOperator* >::iterator it;
  it = fLogicalToSetupMap.Find(logical);
  if ( it == fLogicalToSetupMap.End() ) fLogicalToSetupMap[logical] = this;
  else if ( (*it).second != this )
    {
      G4ExceptionDescription ed;
      ed << "Biasing operator `" << GetName() 
     << "' can not be attached to Logical volume `"
     << logical->GetName() << "' which is already used by another operator !" << G4endl;
      G4Exception("G4VBiasingOperator::AttachTo(...)",
          "BIAS.MNG.01",
          JustWarning,
          ed);
    }
}

References G4MapCache< KEYTYPE, VALTYPE >::End(), G4MapCache< KEYTYPE, VALTYPE >::Find(), G4VBiasingOperator::fLogicalToSetupMap, G4endl, G4Exception(), G4LogicalVolume::GetName(), G4VBiasingOperator::GetName(), and JustWarning.

Configure()

void G4BOptrForceCollision::Configure ( )

finalvirtual

Reimplemented from G4VBiasingOperator.

Definition at line 94 of file G4BOptrForceCollision.cc.

{
  // -- build free flight operations:
  ConfigureForWorker();
}

References ConfigureForWorker().

ConfigureForWorker()

void G4BOptrForceCollision::ConfigureForWorker ( )

finalvirtual

Reimplemented from G4VBiasingOperator.

Definition at line 101 of file G4BOptrForceCollision.cc.

{
  // -- start by remembering processes under biasing, and create needed biasing operations:
  if ( fSetup )
    {
      const G4ProcessManager* processManager = fParticleToBias->GetProcessManager();
      const G4BiasingProcessSharedData* interfaceProcessSharedData = G4BiasingProcessInterface::GetSharedData( processManager );
      if ( interfaceProcessSharedData ) // -- sharedData tested, as is can happen a user attaches an operator
                                    // -- to a volume but without defining BiasingProcessInterface processes.
    {
      for ( size_t i = 0 ; i < (interfaceProcessSharedData->GetPhysicsBiasingProcessInterfaces()).size(); i++ )
        {
          const G4BiasingProcessInterface* wrapperProcess =
        (interfaceProcessSharedData->GetPhysicsBiasingProcessInterfaces())[i];
          G4String operationName = "FreeFlight-"+wrapperProcess->GetWrappedProcess()->GetProcessName();
          fFreeFlightOperations[wrapperProcess] = new G4BOptnForceFreeFlight(operationName);
        }
    }
      fSetup = false;
    }
}

References fFreeFlightOperations, fParticleToBias, fSetup, G4BiasingProcessSharedData::GetPhysicsBiasingProcessInterfaces(), G4ParticleDefinition::GetProcessManager(), G4VProcess::GetProcessName(), G4BiasingProcessInterface::GetSharedData(), and G4BiasingProcessInterface::GetWrappedProcess().

Referenced by Configure().

EndTracking()

void G4BOptrForceCollision::EndTracking ( )

finalvirtual

Reimplemented from G4VBiasingOperator.

Definition at line 310 of file G4BOptrForceCollision.cc.

{
  // -- check for consistency, operator should have cleaned the track:
  if ( fCurrentTrackData != nullptr )
    {
      if ( !fCurrentTrackData->IsFreeFromBiasing() )
    {
      if ( (fCurrentTrack->GetTrackStatus() == fStopAndKill) || (fCurrentTrack->GetTrackStatus() == fKillTrackAndSecondaries) )
        {
          G4ExceptionDescription ed;
          ed << "Current track deleted while under biasing by " << GetName() << ". Will result in inconsistencies.";
          G4Exception(" G4BOptrForceCollision::EndTracking()",
              "BIAS.GEN.18",
              JustWarning,
              ed);
        }
    }
    } 
}

References fCurrentTrack, fCurrentTrackData, fKillTrackAndSecondaries, fStopAndKill, G4Exception(), G4VBiasingOperator::GetName(), G4Track::GetTrackStatus(), G4BOptrForceCollisionTrackData::IsFreeFromBiasing(), and JustWarning.

ExitBiasing()

virtual void G4BOptrForceCollision::ExitBiasing ( const G4Track *  , const G4BiasingProcessInterface *    )

inlinefinalvirtual

Reimplemented from G4VBiasingOperator.

Definition at line 75 of file G4BOptrForceCollision.hh.

{};

ExitingBiasing()

void G4VBiasingOperator::ExitingBiasing ( const G4Track *  track, const G4BiasingProcessInterface *  callingProcess  )

inherited

Definition at line 152 of file G4VBiasingOperator.cc.

{
  ExitBiasing( track, callingProcess );
  
  // -- reset all data members:
  fOccurenceBiasingOperation                  = nullptr ;
  fFinalStateBiasingOperation                 = nullptr ;
  fNonPhysicsBiasingOperation                 = nullptr ;
  fPreviousProposedOccurenceBiasingOperation  = nullptr ;
  fPreviousProposedFinalStateBiasingOperation = nullptr ;
  fPreviousProposedNonPhysicsBiasingOperation = nullptr ;
  fPreviousAppliedOccurenceBiasingOperation   = nullptr ;
  fPreviousAppliedFinalStateBiasingOperation  = nullptr ;
  fPreviousAppliedNonPhysicsBiasingOperation  = nullptr ;
  fPreviousBiasingAppliedCase                 = BAC_None ;
}

References BAC_None, G4VBiasingOperator::ExitBiasing(), G4VBiasingOperator::fFinalStateBiasingOperation, G4VBiasingOperator::fNonPhysicsBiasingOperation, G4VBiasingOperator::fOccurenceBiasingOperation, G4VBiasingOperator::fPreviousAppliedFinalStateBiasingOperation, G4VBiasingOperator::fPreviousAppliedNonPhysicsBiasingOperation, G4VBiasingOperator::fPreviousAppliedOccurenceBiasingOperation, G4VBiasingOperator::fPreviousBiasingAppliedCase, G4VBiasingOperator::fPreviousProposedFinalStateBiasingOperation, G4VBiasingOperator::fPreviousProposedNonPhysicsBiasingOperation, and G4VBiasingOperator::fPreviousProposedOccurenceBiasingOperation.

GetBiasingOperator()

G4VBiasingOperator * G4VBiasingOperator::GetBiasingOperator ( const G4LogicalVolume *  logical )

staticinherited

Definition at line 78 of file G4VBiasingOperator.cc.

{
  G4MapCache< const G4LogicalVolume*, G4VBiasingOperator* >::iterator it;
  it = fLogicalToSetupMap.Find(logical);
  if ( it == fLogicalToSetupMap.End() ) return nullptr;
  else return (*it).second;
}

References G4MapCache< KEYTYPE, VALTYPE >::End(), G4MapCache< KEYTYPE, VALTYPE >::Find(), and G4VBiasingOperator::fLogicalToSetupMap.

Referenced by G4BiasingProcessInterface::PostStepGetPhysicalInteractionLength().

GetBiasingOperators()

static const std::vector< G4VBiasingOperator * > & G4VBiasingOperator::GetBiasingOperators ( )

inlinestaticinherited

Definition at line 293 of file G4VBiasingOperator.hh.

{return fOperators.Get();}

References G4VBiasingOperator::fOperators, and G4Cache< VALTYPE >::Get().

Referenced by G4BiasingProcessInterface::BuildPhysicsTable(), G4BiasingProcessInterface::BuildWorkerPhysicsTable(), G4BiasingProcessInterface::EndTracking(), and G4BiasingProcessInterface::StartTracking().

GetName()

const G4String G4VBiasingOperator::GetName ( ) const

inlineinherited

Definition at line 288 of file G4VBiasingOperator.hh.

{return fName;}

References G4VBiasingOperator::fName.

Referenced by G4VBiasingOperator::AttachTo(), EndTracking(), G4BiasingProcessInterface::PostStepGetPhysicalInteractionLength(), G4BOptrForceCollisionTrackData::Print(), and G4BOptrForceCollisionTrackData::~G4BOptrForceCollisionTrackData().

GetPreviousBiasingAppliedCase()

G4BiasingAppliedCase G4VBiasingOperator::GetPreviousBiasingAppliedCase ( ) const

inlineinherited

Definition at line 291 of file G4VBiasingOperator.hh.

{return fPreviousBiasingAppliedCase;}

References G4VBiasingOperator::fPreviousBiasingAppliedCase.

GetPreviousNonPhysicsAppliedOperation()

const G4VBiasingOperation * G4VBiasingOperator::GetPreviousNonPhysicsAppliedOperation ( )

inlineinherited

Definition at line 315 of file G4VBiasingOperator.hh.

{return  fPreviousAppliedNonPhysicsBiasingOperation;}

References G4VBiasingOperator::fPreviousAppliedNonPhysicsBiasingOperation.

GetProposedFinalStateBiasingOperation()

G4VBiasingOperation * G4VBiasingOperator::GetProposedFinalStateBiasingOperation ( const G4Track *  track, const G4BiasingProcessInterface *  callingProcess  )

inherited

Definition at line 92 of file G4VBiasingOperator.cc.

{
  fFinalStateBiasingOperation = ProposeFinalStateBiasingOperation(track, callingProcess); 
  return fFinalStateBiasingOperation;
}

References G4VBiasingOperator::fFinalStateBiasingOperation, and G4VBiasingOperator::ProposeFinalStateBiasingOperation().

GetProposedNonPhysicsBiasingOperation()

G4VBiasingOperation * G4VBiasingOperator::GetProposedNonPhysicsBiasingOperation ( const G4Track *  track, const G4BiasingProcessInterface *  callingProcess  )

inherited

Definition at line 98 of file G4VBiasingOperator.cc.

{
  fNonPhysicsBiasingOperation = ProposeNonPhysicsBiasingOperation(track, callingProcess);
  return fNonPhysicsBiasingOperation;
}

References G4VBiasingOperator::fNonPhysicsBiasingOperation, and G4VBiasingOperator::ProposeNonPhysicsBiasingOperation().

GetProposedOccurenceBiasingOperation()

G4VBiasingOperation * G4VBiasingOperator::GetProposedOccurenceBiasingOperation ( const G4Track *  track, const G4BiasingProcessInterface *  callingProcess  )

inherited

Definition at line 86 of file G4VBiasingOperator.cc.

{
  fOccurenceBiasingOperation = ProposeOccurenceBiasingOperation(track, callingProcess);
  return fOccurenceBiasingOperation;
}

References G4VBiasingOperator::fOccurenceBiasingOperation, and G4VBiasingOperator::ProposeOccurenceBiasingOperation().

Referenced by G4ChannelingOptrMultiParticleChangeCrossSection::ProposeOccurenceBiasingOperation().

OperationApplied() [1/2]

void G4BOptrForceCollision::OperationApplied ( const G4BiasingProcessInterface *  callingProcess, G4BiasingAppliedCase  biasingCase, G4VBiasingOperation *  occurenceOperationApplied, G4double  weightForOccurenceInteraction, G4VBiasingOperation *  finalStateOperationApplied, const G4VParticleChange *  particleChangeProduced  )

finalvirtual

Reimplemented from G4VBiasingOperator.

Definition at line 401 of file G4BOptrForceCollision.cc.

{
  
  if ( fCurrentTrackData->fForceCollisionState == ForceCollisionState::toBeForced )
    {
      if ( finalStateOperationApplied != fSharedForceInteractionOperation )
    {
      G4ExceptionDescription ed;
      ed << " Internal inconsistency : please submit bug report. " << G4endl;
      G4Exception(" G4BOptrForceCollision::OperationApplied(...)",
              "BIAS.GEN.20.5",
              JustWarning,
              ed); 
    }
      if ( fSharedForceInteractionOperation->GetInteractionOccured() ) fCurrentTrackData->Reset(); // -- off biasing for this track
    }
  else
    {
      G4ExceptionDescription ed;
      ed << " Internal inconsistency : please submit bug report. " << G4endl;
      G4Exception(" G4BOptrForceCollision::OperationApplied(...)",
          "BIAS.GEN.20.6",
          JustWarning,
          ed);   
    }
  
}

References fCurrentTrackData, G4BOptrForceCollisionTrackData::fForceCollisionState, fSharedForceInteractionOperation, G4endl, G4Exception(), G4BOptnForceCommonTruncatedExp::GetInteractionOccured(), JustWarning, G4BOptrForceCollisionTrackData::Reset(), and toBeForced.

OperationApplied() [2/2]

void G4BOptrForceCollision::OperationApplied ( const G4BiasingProcessInterface *  callingProcess, G4BiasingAppliedCase  biasingCase, G4VBiasingOperation *  operationApplied, const G4VParticleChange *  particleChangeProduced  )

finalvirtual

Reimplemented from G4VBiasingOperator.

Definition at line 331 of file G4BOptrForceCollision.cc.

{
  
  if ( fCurrentTrackData == nullptr )
    {
      if ( BAC != BAC_None )
    {
      G4ExceptionDescription ed;
      ed << " Internal inconsistency : please submit bug report. " << G4endl;
      G4Exception(" G4BOptrForceCollision::OperationApplied(...)",
              "BIAS.GEN.20.1",
              JustWarning,
              ed); 
    }
      return;
    }
  
  if      ( fCurrentTrackData->fForceCollisionState == ForceCollisionState::toBeCloned )
    {
      fCurrentTrackData->fForceCollisionState = ForceCollisionState::toBeFreeFlight;
      auto cloneData                  = new G4BOptrForceCollisionTrackData( this );
      cloneData->fForceCollisionState = ForceCollisionState::toBeForced;
      fCloningOperation->GetCloneTrack()->SetAuxiliaryTrackInformation(fForceCollisionModelID, cloneData);
    }
  else if ( fCurrentTrackData->fForceCollisionState == ForceCollisionState::toBeFreeFlight )
    {
      if ( fFreeFlightOperations[callingProcess]->OperationComplete() ) fCurrentTrackData->Reset(); // -- off biasing for this track
    }
  else if ( fCurrentTrackData->fForceCollisionState == ForceCollisionState::toBeForced )
    {
      if ( operationApplied != fSharedForceInteractionOperation )
    {
      G4ExceptionDescription ed;
      ed << " Internal inconsistency : please submit bug report. " << G4endl;
      G4Exception(" G4BOptrForceCollision::OperationApplied(...)",
              "BIAS.GEN.20.2",
              JustWarning,
              ed); 
    }
      if ( fSharedForceInteractionOperation->GetInteractionOccured() )
    {
      if ( operationApplied != fSharedForceInteractionOperation )
        {
          G4ExceptionDescription ed;
          ed << " Internal inconsistency : please submit bug report. " << G4endl;
          G4Exception(" G4BOptrForceCollision::OperationApplied(...)",
              "BIAS.GEN.20.3",
              JustWarning,
              ed); 
        } 
    }
    }
  else
    {
      if ( fCurrentTrackData->fForceCollisionState != ForceCollisionState::free )
    {
      G4ExceptionDescription ed;
      ed << " Internal inconsistency : please submit bug report. " << G4endl;
      G4Exception(" G4BOptrForceCollision::OperationApplied(...)",
              "BIAS.GEN.20.4",
              JustWarning,
              ed); 
    }
    }
}

References BAC_None, fCloningOperation, fCurrentTrackData, fForceCollisionModelID, G4BOptrForceCollisionTrackData::fForceCollisionState, fFreeFlightOperations, free, fSharedForceInteractionOperation, G4endl, G4Exception(), G4BOptnCloning::GetCloneTrack(), G4BOptnForceCommonTruncatedExp::GetInteractionOccured(), JustWarning, G4BOptrForceCollisionTrackData::Reset(), G4Track::SetAuxiliaryTrackInformation(), toBeCloned, toBeForced, and toBeFreeFlight.

ProposeFinalStateBiasingOperation()

G4VBiasingOperation * G4BOptrForceCollision::ProposeFinalStateBiasingOperation ( const G4Track *  track, const G4BiasingProcessInterface *  callingProcess  )

finalprivatevirtual

Implements G4VBiasingOperator.

Definition at line 294 of file G4BOptrForceCollision.cc.

{
  // -- Propose at final state generation the same operation which was proposed at GPIL level,
  // -- (which is either the force free flight or the force interaction operation).
  // -- count on the process interface to collect this operation:
  return callingProcess->GetCurrentOccurenceBiasingOperation();
}

References G4BiasingProcessInterface::GetCurrentOccurenceBiasingOperation().

ProposeNonPhysicsBiasingOperation()

G4VBiasingOperation * G4BOptrForceCollision::ProposeNonPhysicsBiasingOperation ( const G4Track *  track, const G4BiasingProcessInterface *  callingProcess  )

finalprivatevirtual

Implements G4VBiasingOperator.

Definition at line 251 of file G4BOptrForceCollision.cc.

{
  if ( track->GetDefinition() != fParticleToBias ) return nullptr;
  
  // -- Apply biasing scheme only to tracks entering the volume.
  // -- A "cloning" is done:
  // --  - the primary will be forced flight under a zero weight up to volume exit,
  // --    where the weight will be restored with proper weight for free flight
  // --  - the clone will be forced to interact in the volume.
  if ( track->GetStep()->GetPreStepPoint()->GetStepStatus() == fGeomBoundary ) // -- §§§ extent to case of a track shoot on the boundary ?
    {
      // -- check that track is free of undergoing biasing scheme ( no biasing data, or no active active )
      // -- Get possible track data:
      fCurrentTrackData = (G4BOptrForceCollisionTrackData*)(track->GetAuxiliaryTrackInformation(fForceCollisionModelID));
      if ( fCurrentTrackData != nullptr )
    {
      if ( fCurrentTrackData->IsFreeFromBiasing() )
        {
          // -- takes "ownership" (some track data created before, left free, reuse it):
          fCurrentTrackData->fForceCollisionOperator = this ;
        }
      else
        {
          // §§§ Would something be really wrong in this case ? Could this be that a process made a zero step ?
        }
    }
      else
    {
      fCurrentTrackData = new G4BOptrForceCollisionTrackData( this );
      track->SetAuxiliaryTrackInformation(fForceCollisionModelID, fCurrentTrackData);
    }
      fCurrentTrackData->fForceCollisionState = ForceCollisionState::toBeCloned;
      fInitialTrackWeight = track->GetWeight();
      fCloningOperation->SetCloneWeights(0.0, fInitialTrackWeight);
      return fCloningOperation;
    }
  
  // -- 
  return nullptr;
}

References fCloningOperation, fCurrentTrackData, fForceCollisionModelID, G4BOptrForceCollisionTrackData::fForceCollisionOperator, G4BOptrForceCollisionTrackData::fForceCollisionState, fGeomBoundary, fInitialTrackWeight, fParticleToBias, G4Track::GetAuxiliaryTrackInformation(), G4Track::GetDefinition(), G4Step::GetPreStepPoint(), G4Track::GetStep(), G4StepPoint::GetStepStatus(), G4Track::GetWeight(), G4BOptrForceCollisionTrackData::IsFreeFromBiasing(), G4Track::SetAuxiliaryTrackInformation(), G4BOptnCloning::SetCloneWeights(), and toBeCloned.

ProposeOccurenceBiasingOperation()

G4VBiasingOperation * G4BOptrForceCollision::ProposeOccurenceBiasingOperation ( const G4Track *  track, const G4BiasingProcessInterface *  callingProcess  )

finalprivatevirtual

Implements G4VBiasingOperator.

Definition at line 129 of file G4BOptrForceCollision.cc.

{
  // -- does nothing if particle is not of requested type:
  if ( track->GetDefinition() != fParticleToBias ) return 0;
 
  // -- trying to get auxiliary track data...
  if ( fCurrentTrackData == nullptr )
    {
      // ... and if the track has no aux. track data, it means its biasing is not started yet (note that cloning is to happen first):
      fCurrentTrackData = (G4BOptrForceCollisionTrackData*)(track->GetAuxiliaryTrackInformation(fForceCollisionModelID));
      if ( fCurrentTrackData == nullptr ) return nullptr;
    }
 
  
  // -- Send force free flight to the callingProcess:
  // ------------------------------------------------
  // -- The track has been cloned in the previous step, it has now to be
  // -- forced for a free flight.
  // -- This track will fly with 0.0 weight during its forced flight:
  // -- it is to forbid the double counting with the force interaction track.
  // -- Its weight is restored at the end of its free flight, this weight
  // -- being its initial weight * the weight for the free flight travel,
  // -- this last one being per process. The initial weight is common, and is
  // -- arbitrary asked to the first operation to take care of it.
  if ( fCurrentTrackData->fForceCollisionState == ForceCollisionState::toBeFreeFlight )
    {
      G4BOptnForceFreeFlight* operation =  fFreeFlightOperations[callingProcess];
      if ( callingProcess->GetWrappedProcess()->GetCurrentInteractionLength() < DBL_MAX/10. )
    {
      // -- the initial track weight will be restored only by the first DoIt free flight:
      operation->ResetInitialTrackWeight(fInitialTrackWeight);
      return operation;
    }
      else
    {
      return nullptr;
    }
    }
 
 
  // -- Send force interaction operation to the callingProcess:
  // ----------------------------------------------------------
  // -- at this level, a copy of the track entering the volume was
  // -- generated (borned) earlier. This copy will make the forced
  // -- interaction in the volume.
  if ( fCurrentTrackData->fForceCollisionState == ForceCollisionState::toBeForced )
    {
      // -- Remember if this calling process is the first of the physics wrapper in
      // -- the PostStepGPIL loop (using default argument of method below):
      G4bool isFirstPhysGPIL = callingProcess-> GetIsFirstPostStepGPILInterface();
      
      // -- [*first process*] Initialize or update force interaction operation:
      if ( isFirstPhysGPIL )
    {
      // -- first step of cloned track, initialize the forced interaction operation:
      if ( track->GetCurrentStepNumber() == 1 ) fSharedForceInteractionOperation->Initialize( track );
      else
        {
          if ( fSharedForceInteractionOperation->GetInitialMomentum() != track->GetMomentum() )
        {
          // -- means that some other physics process, not under control of the forced interaction operation,
          // -- has occured, need to re-initialize the operation as distance to boundary has changed.
          // -- [ Note the re-initialization is only possible for a Markovian law. ]
          fSharedForceInteractionOperation->Initialize( track );
        }
          else
        {
          // -- means that some other non-physics process (biasing or not, like step limit), has occured,
          // -- but track conserves its momentum direction, only need to reduced the maximum distance for
          // -- forced interaction.
          // -- [ Note the update is only possible for a Markovian law. ]
          fSharedForceInteractionOperation->UpdateForStep( track->GetStep() );
        }
        }
    }
      
      // -- [*all processes*] Sanity check : it may happen in limit cases that distance to
      // -- out is zero, weight would be infinite in this case: abort forced interaction
      // -- and abandon biasing.
      if ( fSharedForceInteractionOperation->GetMaximumDistance() < DBL_MIN )
    {
      fCurrentTrackData->Reset();
      return 0;
    }
      
      // -- [* first process*] collect cross-sections and sample force law to determine interaction length
      // -- and winning process:
      if ( isFirstPhysGPIL )
    {
      // -- collect cross-sections:
      // -- ( Remember that the first of the G4BiasingProcessInterface triggers the update
      // --   of these cross-sections )
      const G4BiasingProcessSharedData* sharedData = callingProcess->GetSharedData();
      for ( size_t i = 0 ; i < (sharedData->GetPhysicsBiasingProcessInterfaces()).size() ; i++ )
        {
          const G4BiasingProcessInterface* wrapperProcess = ( sharedData->GetPhysicsBiasingProcessInterfaces() )[i];
          G4double interactionLength = wrapperProcess->GetWrappedProcess()->GetCurrentInteractionLength();
          // -- keep only well defined cross-sections, other processes are ignored. These are not pathological cases
          // -- but cases where a threhold effect par example (eg pair creation) may be at play. (**!**)
          if ( interactionLength < DBL_MAX/10. )
        fSharedForceInteractionOperation->AddCrossSection( wrapperProcess->GetWrappedProcess(),  1.0/interactionLength );
        }
      // -- sample the shared law (interaction length, and winning process):
      if ( fSharedForceInteractionOperation->GetNumberOfSharing() > 0 ) fSharedForceInteractionOperation->Sample();
    }
      
      // -- [*all processes*] Send operation for processes with well defined XS (see "**!**" above):
      G4VBiasingOperation* operationToReturn = nullptr;
      if ( callingProcess->GetWrappedProcess()->GetCurrentInteractionLength() < DBL_MAX/10. ) operationToReturn = fSharedForceInteractionOperation;
      return operationToReturn;
 
 
    } // -- end of "if ( fCurrentTrackData->fForceCollisionState == ForceCollisionState::toBeForced )"
 
  
  // -- other cases here: particle appearing in the volume by some
  // -- previous interaction : we decide to not bias these.
  return 0;
  
}

References G4BOptnForceCommonTruncatedExp::AddCrossSection(), DBL_MAX, DBL_MIN, fCurrentTrackData, fForceCollisionModelID, G4BOptrForceCollisionTrackData::fForceCollisionState, fFreeFlightOperations, fInitialTrackWeight, fParticleToBias, fSharedForceInteractionOperation, G4Track::GetAuxiliaryTrackInformation(), G4VProcess::GetCurrentInteractionLength(), G4Track::GetCurrentStepNumber(), G4Track::GetDefinition(), G4BOptnForceCommonTruncatedExp::GetInitialMomentum(), G4BOptnForceCommonTruncatedExp::GetMaximumDistance(), G4Track::GetMomentum(), G4BOptnForceCommonTruncatedExp::GetNumberOfSharing(), G4BiasingProcessSharedData::GetPhysicsBiasingProcessInterfaces(), G4BiasingProcessInterface::GetSharedData(), G4Track::GetStep(), G4BiasingProcessInterface::GetWrappedProcess(), G4BOptnForceCommonTruncatedExp::Initialize(), G4BOptrForceCollisionTrackData::Reset(), G4BOptnForceFreeFlight::ResetInitialTrackWeight(), G4BOptnForceCommonTruncatedExp::Sample(), toBeForced, toBeFreeFlight, and G4BOptnForceCommonTruncatedExp::UpdateForStep().

ReportOperationApplied() [1/2]

void G4VBiasingOperator::ReportOperationApplied ( const G4BiasingProcessInterface *  callingProcess, G4BiasingAppliedCase  biasingCase, G4VBiasingOperation *  occurenceOperationApplied, G4double  weightForOccurenceInteraction, G4VBiasingOperation *  finalStateOperationApplied, const G4VParticleChange *  particleChangeProduced  )

inherited

Definition at line 138 of file G4VBiasingOperator.cc.

{
  fPreviousBiasingAppliedCase = biasingCase;
  fPreviousAppliedOccurenceBiasingOperation  =  occurenceOperationApplied;
  fPreviousAppliedFinalStateBiasingOperation = finalStateOperationApplied;
  OperationApplied( callingProcess, biasingCase, occurenceOperationApplied, weightForOccurenceInteraction, finalStateOperationApplied, particleChangeProduced );
}

References G4VBiasingOperator::fPreviousAppliedFinalStateBiasingOperation, G4VBiasingOperator::fPreviousAppliedOccurenceBiasingOperation, G4VBiasingOperator::fPreviousBiasingAppliedCase, and G4VBiasingOperator::OperationApplied().

ReportOperationApplied() [2/2]

void G4VBiasingOperator::ReportOperationApplied ( const G4BiasingProcessInterface *  callingProcess, G4BiasingAppliedCase  biasingCase, G4VBiasingOperation *  operationApplied, const G4VParticleChange *  particleChangeProduced  )

inherited

Definition at line 104 of file G4VBiasingOperator.cc.

{
  fPreviousBiasingAppliedCase = biasingCase;
  fPreviousAppliedOccurenceBiasingOperation  = nullptr;
  fPreviousAppliedFinalStateBiasingOperation = nullptr;
  fPreviousAppliedNonPhysicsBiasingOperation = nullptr;
  switch ( biasingCase )
    {
    case BAC_None:
      break;
    case BAC_NonPhysics:
      fPreviousAppliedNonPhysicsBiasingOperation = operationApplied ;
      break;
    case BAC_FinalState:
      fPreviousAppliedFinalStateBiasingOperation = operationApplied;
      break;
    case BAC_Occurence:
      G4Exception("G4VBiasingOperator::ReportOperationApplied(...)",
              "BIAS.MNG.02",
              JustWarning,
          "Internal logic error, please report !");
      break;
    default:
      G4Exception("G4VBiasingOperator::ReportOperationApplied(...)",
          "BIAS.MNG.03",
          JustWarning,
          "Internal logic error, please report !");
    }
  OperationApplied( callingProcess, biasingCase, operationApplied, particleChangeProduced );
}

References BAC_FinalState, BAC_None, BAC_NonPhysics, BAC_Occurence, G4VBiasingOperator::fPreviousAppliedFinalStateBiasingOperation, G4VBiasingOperator::fPreviousAppliedNonPhysicsBiasingOperation, G4VBiasingOperator::fPreviousAppliedOccurenceBiasingOperation, G4VBiasingOperator::fPreviousBiasingAppliedCase, G4Exception(), JustWarning, and G4VBiasingOperator::OperationApplied().

Referenced by G4ChannelingOptrMultiParticleChangeCrossSection::OperationApplied().

StartRun()

void G4BOptrForceCollision::StartRun ( )

finalvirtual

Reimplemented from G4VBiasingOperator.

Definition at line 124 of file G4BOptrForceCollision.cc.

{
}

StartTracking()

void G4BOptrForceCollision::StartTracking ( const G4Track *  track )

finalvirtual

Reimplemented from G4VBiasingOperator.

Definition at line 303 of file G4BOptrForceCollision.cc.

{
  fCurrentTrack     = track;
  fCurrentTrackData = nullptr; 
}

References fCurrentTrack, and fCurrentTrackData.

Field Documentation

fCloningOperation

G4BOptnCloning* G4BOptrForceCollision::fCloningOperation

private

Definition at line 92 of file G4BOptrForceCollision.hh.

Referenced by G4BOptrForceCollision(), OperationApplied(), ProposeNonPhysicsBiasingOperation(), and ~G4BOptrForceCollision().

fCurrentTrack

const G4Track* G4BOptrForceCollision::fCurrentTrack

private

Definition at line 88 of file G4BOptrForceCollision.hh.

Referenced by EndTracking(), and StartTracking().

fCurrentTrackData

G4BOptrForceCollisionTrackData* G4BOptrForceCollision::fCurrentTrackData

private

Definition at line 89 of file G4BOptrForceCollision.hh.

Referenced by EndTracking(), OperationApplied(), ProposeNonPhysicsBiasingOperation(), ProposeOccurenceBiasingOperation(), and StartTracking().

fDepthInTree

std::map< const G4LogicalVolume*, G4int > G4VBiasingOperator::fDepthInTree

privateinherited

Definition at line 333 of file G4VBiasingOperator.hh.

fFinalStateBiasingOperation

G4VBiasingOperation* G4VBiasingOperator::fFinalStateBiasingOperation

privateinherited

Definition at line 337 of file G4VBiasingOperator.hh.

Referenced by G4VBiasingOperator::ExitingBiasing(), and G4VBiasingOperator::GetProposedFinalStateBiasingOperation().

fForceCollisionModelID

G4int G4BOptrForceCollision::fForceCollisionModelID

private

Definition at line 87 of file G4BOptrForceCollision.hh.

Referenced by OperationApplied(), ProposeNonPhysicsBiasingOperation(), and ProposeOccurenceBiasingOperation().

fFreeFlightOperations

std::map< const G4BiasingProcessInterface*, G4BOptnForceFreeFlight* > G4BOptrForceCollision::fFreeFlightOperations

private

Definition at line 90 of file G4BOptrForceCollision.hh.

Referenced by ConfigureForWorker(), OperationApplied(), ProposeOccurenceBiasingOperation(), and ~G4BOptrForceCollision().

fInitialTrackWeight

G4double G4BOptrForceCollision::fInitialTrackWeight

private

Definition at line 93 of file G4BOptrForceCollision.hh.

Referenced by ProposeNonPhysicsBiasingOperation(), and ProposeOccurenceBiasingOperation().

fLogicalToSetupMap

G4MapCache< const G4LogicalVolume *, G4VBiasingOperator * > G4VBiasingOperator::fLogicalToSetupMap

staticprivateinherited

Definition at line 322 of file G4VBiasingOperator.hh.

Referenced by G4VBiasingOperator::AttachTo(), and G4VBiasingOperator::GetBiasingOperator().

fName

const G4String G4VBiasingOperator::fName

privateinherited

Definition at line 319 of file G4VBiasingOperator.hh.

Referenced by G4VBiasingOperator::GetName().

fNonPhysicsBiasingOperation

G4VBiasingOperation* G4VBiasingOperator::fNonPhysicsBiasingOperation

privateinherited

Definition at line 338 of file G4VBiasingOperator.hh.

Referenced by G4VBiasingOperator::ExitingBiasing(), and G4VBiasingOperator::GetProposedNonPhysicsBiasingOperation().

fOccurenceBiasingOperation

G4VBiasingOperation* G4VBiasingOperator::fOccurenceBiasingOperation

privateinherited

Definition at line 336 of file G4VBiasingOperator.hh.

Referenced by G4VBiasingOperator::ExitingBiasing(), and G4VBiasingOperator::GetProposedOccurenceBiasingOperation().

fOperators

G4VectorCache< G4VBiasingOperator * > G4VBiasingOperator::fOperators

staticprivateinherited

Definition at line 324 of file G4VBiasingOperator.hh.

Referenced by G4VBiasingOperator::G4VBiasingOperator(), G4VBiasingOperator::GetBiasingOperators(), and G4BiasingOperatorStateNotifier::Notify().

fParticleToBias

const G4ParticleDefinition* G4BOptrForceCollision::fParticleToBias

private

Definition at line 95 of file G4BOptrForceCollision.hh.

Referenced by ConfigureForWorker(), G4BOptrForceCollision(), ProposeNonPhysicsBiasingOperation(), and ProposeOccurenceBiasingOperation().

fPreviousAppliedFinalStateBiasingOperation

const G4VBiasingOperation* G4VBiasingOperator::fPreviousAppliedFinalStateBiasingOperation

privateinherited

Definition at line 345 of file G4VBiasingOperator.hh.

Referenced by G4VBiasingOperator::ExitingBiasing(), and G4VBiasingOperator::ReportOperationApplied().

fPreviousAppliedNonPhysicsBiasingOperation

const G4VBiasingOperation* G4VBiasingOperator::fPreviousAppliedNonPhysicsBiasingOperation

privateinherited

Definition at line 346 of file G4VBiasingOperator.hh.

Referenced by G4VBiasingOperator::ExitingBiasing(), G4VBiasingOperator::GetPreviousNonPhysicsAppliedOperation(), and G4VBiasingOperator::ReportOperationApplied().

fPreviousAppliedOccurenceBiasingOperation

const G4VBiasingOperation* G4VBiasingOperator::fPreviousAppliedOccurenceBiasingOperation

privateinherited

Definition at line 344 of file G4VBiasingOperator.hh.

Referenced by G4VBiasingOperator::ExitingBiasing(), and G4VBiasingOperator::ReportOperationApplied().

fPreviousBiasingAppliedCase

G4BiasingAppliedCase G4VBiasingOperator::fPreviousBiasingAppliedCase

privateinherited

Definition at line 347 of file G4VBiasingOperator.hh.

Referenced by G4VBiasingOperator::ExitingBiasing(), G4VBiasingOperator::GetPreviousBiasingAppliedCase(), and G4VBiasingOperator::ReportOperationApplied().

fPreviousProposedFinalStateBiasingOperation

const G4VBiasingOperation* G4VBiasingOperator::fPreviousProposedFinalStateBiasingOperation

privateinherited

Definition at line 342 of file G4VBiasingOperator.hh.

Referenced by G4VBiasingOperator::ExitingBiasing().

fPreviousProposedNonPhysicsBiasingOperation

const G4VBiasingOperation* G4VBiasingOperator::fPreviousProposedNonPhysicsBiasingOperation

privateinherited

Definition at line 343 of file G4VBiasingOperator.hh.

Referenced by G4VBiasingOperator::ExitingBiasing().

fPreviousProposedOccurenceBiasingOperation

const G4VBiasingOperation* G4VBiasingOperator::fPreviousProposedOccurenceBiasingOperation

privateinherited

Definition at line 341 of file G4VBiasingOperator.hh.

Referenced by G4VBiasingOperator::ExitingBiasing().

fRootVolumes

std::vector< const G4LogicalVolume* > G4VBiasingOperator::fRootVolumes

privateinherited

Definition at line 332 of file G4VBiasingOperator.hh.

fSetup

G4bool G4BOptrForceCollision::fSetup

private

Definition at line 94 of file G4BOptrForceCollision.hh.

Referenced by ConfigureForWorker().

fSharedForceInteractionOperation

G4BOptnForceCommonTruncatedExp* G4BOptrForceCollision::fSharedForceInteractionOperation

private

Definition at line 91 of file G4BOptrForceCollision.hh.

Referenced by G4BOptrForceCollision(), OperationApplied(), ProposeOccurenceBiasingOperation(), and ~G4BOptrForceCollision().

fStateNotifier

G4Cache< G4BiasingOperatorStateNotifier * > G4VBiasingOperator::fStateNotifier

staticprivateinherited

Definition at line 328 of file G4VBiasingOperator.hh.

Referenced by G4VBiasingOperator::G4VBiasingOperator().

---

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

• source/processes/biasing/generic/include/G4BOptrForceCollision.hh
• source/processes/biasing/generic/src/G4BOptrForceCollision.cc