#include <G4OpBoundaryProcess.hh>

Inheritance diagram for G4OpBoundaryProcess:

Public Member Functions
virtual G4VParticleChange *	AlongStepDoIt (const G4Track &, const G4Step &)

virtual G4double	AlongStepGetPhysicalInteractionLength (const G4Track &, G4double, G4double, G4double &, G4GPILSelection *)

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

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

virtual G4double	AtRestGetPhysicalInteractionLength (const G4Track &, G4ForceCondition *)

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

virtual void	BuildPhysicsTable (const G4ParticleDefinition &)

virtual void	BuildWorkerPhysicsTable (const G4ParticleDefinition &part)

virtual void	DumpInfo () const

virtual void	EndTracking ()

	G4OpBoundaryProcess (const G4String &processName="OpBoundary", G4ProcessType type=fOptical)

G4double	GetCurrentInteractionLength () const

const G4VProcess *	GetMasterProcess () const

virtual G4double	GetMeanFreePath (const G4Track &, G4double, G4ForceCondition *condition) override

G4double	GetNumberOfInteractionLengthLeft () const

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

G4double	GetPILfactor () const

virtual const G4ProcessManager *	GetProcessManager ()

const G4String &	GetProcessName () const

G4int	GetProcessSubType () const

G4ProcessType	GetProcessType () const

virtual G4OpBoundaryProcessStatus	GetStatus () const

G4double	GetTotalNumberOfInteractionLengthTraversed () const

G4int	GetVerboseLevel () const

virtual void	Initialise ()

G4bool	isAlongStepDoItIsEnabled () const

virtual G4bool	IsApplicable (const G4ParticleDefinition &aParticleType) override

G4bool	isAtRestDoItIsEnabled () const

G4bool	isPostStepDoItIsEnabled () const

G4bool	operator!= (const G4VProcess &right) const

G4bool	operator== (const G4VProcess &right) const

G4VParticleChange *	PostStepDoIt (const G4Track &aTrack, const G4Step &aStep) override

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

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

virtual void	PreparePhysicsTable (const G4ParticleDefinition &) override

virtual void	PrepareWorkerPhysicsTable (const G4ParticleDefinition &)

virtual void	ProcessDescription (std::ostream &outfile) const

virtual void	ResetNumberOfInteractionLengthLeft ()

virtual G4bool	RetrievePhysicsTable (const G4ParticleDefinition *, const G4String &, G4bool)

virtual void	SetInvokeSD (G4bool)

virtual void	SetMasterProcess (G4VProcess *masterP)

void	SetPILfactor (G4double value)

virtual void	SetProcessManager (const G4ProcessManager *)

void	SetProcessSubType (G4int)

void	SetProcessType (G4ProcessType)

void	SetVerboseLevel (G4int)

virtual void	StartTracking (G4Track *)

virtual G4bool	StorePhysicsTable (const G4ParticleDefinition *, const G4String &, G4bool)

virtual	~G4OpBoundaryProcess ()

Static Public Member Functions
static const G4String &	GetProcessTypeName (G4ProcessType)

Protected Member Functions
void	ClearNumberOfInteractionLengthLeft ()

void	SubtractNumberOfInteractionLengthLeft (G4double prevStepSize)

Protected Attributes
G4ParticleChange	aParticleChange

const G4ProcessManager *	aProcessManager = nullptr

G4double	currentInteractionLength = -1.0

G4bool	enableAlongStepDoIt = true

G4bool	enableAtRestDoIt = true

G4bool	enablePostStepDoIt = true

G4VParticleChange *	pParticleChange = nullptr

G4double	theInitialNumberOfInteractionLength = -1.0

G4double	theNumberOfInteractionLengthLeft = -1.0

G4String	thePhysicsTableFileName

G4double	thePILfactor = 1.0

G4String	theProcessName

G4int	theProcessSubType = -1

G4ProcessType	theProcessType = fNotDefined

G4int	verboseLevel = 0

Private Member Functions
void	BoundaryProcessVerbose (void) const

void	CalculateReflectivity (void)

void	ChooseReflection ()

void	DielectricDichroic ()

void	DielectricDielectric ()

void	DielectricLUT ()

void	DielectricLUTDAVIS ()

void	DielectricMetal ()

void	DoAbsorption ()

void	DoReflection ()

G4bool	G4BooleanRand (const G4double prob) const

	G4OpBoundaryProcess (const G4OpBoundaryProcess &right)=delete

G4ThreeVector	GetFacetNormal (const G4ThreeVector &Momentum, const G4ThreeVector &Normal) const

G4double	GetIncidentAngle ()

G4double	GetReflectivity (G4double E1_perp, G4double E1_parl, G4double incidentangle, G4double RealRindex, G4double ImaginaryRindex)

G4bool	InvokeSD (const G4Step *step)

G4OpBoundaryProcess &	operator= (const G4OpBoundaryProcess &right)=delete

Private Attributes
G4int	f_iTE

G4int	f_iTM

G4double	fCarTolerance

G4Physics2DVector *	fDichroicVector

G4double	fEfficiency

G4ThreeVector	fFacetNormal

G4OpticalSurfaceFinish	fFinish

G4ThreeVector	fGlobalNormal

G4MaterialPropertyVector *	fImagRIndexMPV

G4bool	fInvokeSD

G4Material *	fMaterial1

G4Material *	fMaterial2

G4OpticalSurfaceModel	fModel

G4ThreeVector	fNewMomentum

G4ThreeVector	fNewPolarization

G4ThreeVector	fOldMomentum

G4ThreeVector	fOldPolarization

G4OpticalSurface *	fOpticalSurface

G4double	fPhotonMomentum

G4double	fProb_bs

G4double	fProb_sl

G4double	fProb_ss

G4ProcessTable *	fProcessTable = nullptr

G4MaterialPropertyVector *	fRealRIndexMPV

G4double	fReflectivity

G4double	fRindex1

G4double	fRindex2

G4double	fSint1

G4OpBoundaryProcessStatus	fStatus

G4double	fSurfaceRoughness

G4double	fTransmittance

size_t	idx_back = 0

size_t	idx_dichroicX = 0

size_t	idx_dichroicY = 0

size_t	idx_eff = 0

size_t	idx_groupvel = 0

size_t	idx_irindex = 0

size_t	idx_lobe = 0

size_t	idx_reflect = 0

size_t	idx_rindex1 = 0

size_t	idx_rindex2 = 0

size_t	idx_rindex_surface = 0

size_t	idx_rrindex = 0

size_t	idx_spike = 0

size_t	idx_trans = 0

G4VProcess *	masterProcessShadow = nullptr

Detailed Description

Definition at line 116 of file G4OpBoundaryProcess.hh.

Constructor & Destructor Documentation

◆ G4OpBoundaryProcess() [1/2]

G4OpBoundaryProcess::G4OpBoundaryProcess	(	const G4String &	processName = `"OpBoundary"`,
		G4ProcessType	type = `fOptical`
	)

explicit

Definition at line 91 of file G4OpBoundaryProcess.cc.

  : G4VDiscreteProcess(processName, type)
{
  Initialise();
 
  if(verboseLevel > 0)
  {
    G4cout << GetProcessName() << " is created " << G4endl;
  }
  SetProcessSubType(fOpBoundary);
 
  fStatus           = Undefined;
  fModel            = glisur;
  fFinish           = polished;
  fReflectivity     = 1.;
  fEfficiency       = 0.;
  fTransmittance    = 0.;
  fSurfaceRoughness = 0.;
  fProb_sl          = 0.;
  fProb_ss          = 0.;
  fProb_bs          = 0.;
 
  fRealRIndexMPV  = nullptr;
  fImagRIndexMPV  = nullptr;
  fMaterial1      = nullptr;
  fMaterial2      = nullptr;
  fOpticalSurface = nullptr;
  fCarTolerance   = G4GeometryTolerance::GetInstance()->GetSurfaceTolerance();
 
  f_iTE = f_iTM   = 0;
  fPhotonMomentum = 0.;
  fRindex1 = fRindex2 = 1.;
  fSint1              = 0.;
  fDichroicVector     = nullptr;
}

References f_iTE, f_iTM, fCarTolerance, fDichroicVector, fEfficiency, fFinish, fImagRIndexMPV, fMaterial1, fMaterial2, fModel, fOpBoundary, fOpticalSurface, fPhotonMomentum, fProb_bs, fProb_sl, fProb_ss, fRealRIndexMPV, fReflectivity, fRindex1, fRindex2, fSint1, fStatus, fSurfaceRoughness, fTransmittance, G4cout, G4endl, G4GeometryTolerance::GetInstance(), G4VProcess::GetProcessName(), G4GeometryTolerance::GetSurfaceTolerance(), glisur, Initialise(), polished, G4VProcess::SetProcessSubType(), Undefined, and G4VProcess::verboseLevel.

◆ ~G4OpBoundaryProcess()

G4OpBoundaryProcess::~G4OpBoundaryProcess ( )

virtual

Definition at line 129 of file G4OpBoundaryProcess.cc.

129{}

◆ G4OpBoundaryProcess() [2/2]

G4OpBoundaryProcess::G4OpBoundaryProcess ( const G4OpBoundaryProcess & right )

privatedelete

Member Function Documentation

◆ AlongStepDoIt()

virtual G4VParticleChange * G4VDiscreteProcess::AlongStepDoIt	(	const G4Track &	,
		const G4Step &
	)

inlinevirtualinherited

Implements G4VProcess.

Reimplemented in G4NuclearStopping.

Definition at line 90 of file G4VDiscreteProcess.hh.

93 { return 0; }

◆ AlongStepGetPhysicalInteractionLength()

virtual G4double G4VDiscreteProcess::AlongStepGetPhysicalInteractionLength	(	const G4Track &	,
		G4double	,
		G4double	,
		G4double &	,
		G4GPILSelection *
	)

inlinevirtualinherited

Implements G4VProcess.

Reimplemented in G4NuclearStopping.

Definition at line 70 of file G4VDiscreteProcess.hh.

76 { return -1.0; }

◆ AlongStepGPIL()

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

inlineinherited

Definition at line 461 of file G4VProcess.hh.

{
  return AlongStepGetPhysicalInteractionLength(track, previousStepSize,
                             currentMinimumStep, proposedSafety, selection);
}

References G4VProcess::AlongStepGetPhysicalInteractionLength().

Referenced by G4SteppingManager::DefinePhysicalStepLength(), and G4ITStepProcessor::DoDefinePhysicalStepLength().

◆ AtRestDoIt()

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

inlinevirtualinherited

Implements G4VProcess.

Reimplemented in G4HadronStoppingProcess, and G4eplusAnnihilation.

Definition at line 85 of file G4VDiscreteProcess.hh.

88 { return 0; }

◆ AtRestGetPhysicalInteractionLength()

virtual G4double G4VDiscreteProcess::AtRestGetPhysicalInteractionLength	(	const G4Track &	,
		G4ForceCondition *
	)

inlinevirtualinherited

Implements G4VProcess.

Reimplemented in G4HadronStoppingProcess, and G4eplusAnnihilation.

Definition at line 78 of file G4VDiscreteProcess.hh.

81 { return -1.0; }

◆ AtRestGPIL()

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

inlineinherited

Definition at line 472 of file G4VProcess.hh.

{
  return thePILfactor * AtRestGetPhysicalInteractionLength(track, condition);
}

References G4VProcess::AtRestGetPhysicalInteractionLength(), condition(), and G4VProcess::thePILfactor.

Referenced by G4ITStepProcessor::GetAtRestIL(), and G4SteppingManager::InvokeAtRestDoItProcs().

◆ BoundaryProcessVerbose()

void G4OpBoundaryProcess::BoundaryProcessVerbose ( void ) const

private

Definition at line 530 of file G4OpBoundaryProcess.cc.

{
  G4cout << " *** ";
  if(fStatus == Undefined)
    G4cout << "Undefined";
  else if(fStatus == Transmission)
    G4cout << "Transmission";
  else if(fStatus == FresnelRefraction)
    G4cout << "FresnelRefraction";
  else if(fStatus == FresnelReflection)
    G4cout << "FresnelReflection";
  else if(fStatus == TotalInternalReflection)
    G4cout << "TotalInternalReflection";
  else if(fStatus == LambertianReflection)
    G4cout << "LambertianReflection";
  else if(fStatus == LobeReflection)
    G4cout << "LobeReflection";
  else if(fStatus == SpikeReflection)
    G4cout << "SpikeReflection";
  else if(fStatus == BackScattering)
    G4cout << "BackScattering";
  else if(fStatus == PolishedLumirrorAirReflection)
    G4cout << "PolishedLumirrorAirReflection";
  else if(fStatus == PolishedLumirrorGlueReflection)
    G4cout << "PolishedLumirrorGlueReflection";
  else if(fStatus == PolishedAirReflection)
    G4cout << "PolishedAirReflection";
  else if(fStatus == PolishedTeflonAirReflection)
    G4cout << "PolishedTeflonAirReflection";
  else if(fStatus == PolishedTiOAirReflection)
    G4cout << "PolishedTiOAirReflection";
  else if(fStatus == PolishedTyvekAirReflection)
    G4cout << "PolishedTyvekAirReflection";
  else if(fStatus == PolishedVM2000AirReflection)
    G4cout << "PolishedVM2000AirReflection";
  else if(fStatus == PolishedVM2000GlueReflection)
    G4cout << "PolishedVM2000GlueReflection";
  else if(fStatus == EtchedLumirrorAirReflection)
    G4cout << "EtchedLumirrorAirReflection";
  else if(fStatus == EtchedLumirrorGlueReflection)
    G4cout << "EtchedLumirrorGlueReflection";
  else if(fStatus == EtchedAirReflection)
    G4cout << "EtchedAirReflection";
  else if(fStatus == EtchedTeflonAirReflection)
    G4cout << "EtchedTeflonAirReflection";
  else if(fStatus == EtchedTiOAirReflection)
    G4cout << "EtchedTiOAirReflection";
  else if(fStatus == EtchedTyvekAirReflection)
    G4cout << "EtchedTyvekAirReflection";
  else if(fStatus == EtchedVM2000AirReflection)
    G4cout << "EtchedVM2000AirReflection";
  else if(fStatus == EtchedVM2000GlueReflection)
    G4cout << "EtchedVM2000GlueReflection";
  else if(fStatus == GroundLumirrorAirReflection)
    G4cout << "GroundLumirrorAirReflection";
  else if(fStatus == GroundLumirrorGlueReflection)
    G4cout << "GroundLumirrorGlueReflection";
  else if(fStatus == GroundAirReflection)
    G4cout << "GroundAirReflection";
  else if(fStatus == GroundTeflonAirReflection)
    G4cout << "GroundTeflonAirReflection";
  else if(fStatus == GroundTiOAirReflection)
    G4cout << "GroundTiOAirReflection";
  else if(fStatus == GroundTyvekAirReflection)
    G4cout << "GroundTyvekAirReflection";
  else if(fStatus == GroundVM2000AirReflection)
    G4cout << "GroundVM2000AirReflection";
  else if(fStatus == GroundVM2000GlueReflection)
    G4cout << "GroundVM2000GlueReflection";
  else if(fStatus == Absorption)
    G4cout << "Absorption";
  else if(fStatus == Detection)
    G4cout << "Detection";
  else if(fStatus == NotAtBoundary)
    G4cout << "NotAtBoundary";
  else if(fStatus == SameMaterial)
    G4cout << "SameMaterial";
  else if(fStatus == StepTooSmall)
    G4cout << "StepTooSmall";
  else if(fStatus == NoRINDEX)
    G4cout << "NoRINDEX";
  else if(fStatus == Dichroic)
    G4cout << "Dichroic Transmission";
  G4cout << " ***" << G4endl;
}

References Absorption, BackScattering, Detection, Dichroic, EtchedAirReflection, EtchedLumirrorAirReflection, EtchedLumirrorGlueReflection, EtchedTeflonAirReflection, EtchedTiOAirReflection, EtchedTyvekAirReflection, EtchedVM2000AirReflection, EtchedVM2000GlueReflection, FresnelReflection, FresnelRefraction, fStatus, G4cout, G4endl, GroundAirReflection, GroundLumirrorAirReflection, GroundLumirrorGlueReflection, GroundTeflonAirReflection, GroundTiOAirReflection, GroundTyvekAirReflection, GroundVM2000AirReflection, GroundVM2000GlueReflection, LambertianReflection, LobeReflection, NoRINDEX, NotAtBoundary, PolishedAirReflection, PolishedLumirrorAirReflection, PolishedLumirrorGlueReflection, PolishedTeflonAirReflection, PolishedTiOAirReflection, PolishedTyvekAirReflection, PolishedVM2000AirReflection, PolishedVM2000GlueReflection, SameMaterial, SpikeReflection, StepTooSmall, TotalInternalReflection, Transmission, and Undefined.

Referenced by PostStepDoIt().

◆ BuildPhysicsTable()

virtual void G4VProcess::BuildPhysicsTable ( const G4ParticleDefinition & )

inlinevirtualinherited

Reimplemented in G4ITTransportation, G4VITProcess, G4DNABrownianTransportation, G4DNASecondOrderReaction, G4RadioactiveDecay, G4HadronStoppingProcess, G4MuonMinusAtomicCapture, G4WrapperProcess, G4Channeling, G4GammaGeneralProcess, G4Decay, G4UnknownDecay, G4AdjointForcedInteractionForGamma, G4AdjointProcessEquivalentToDirectProcess, G4VAdjointReverseReaction, G4DNAElectronHoleRecombination, G4DNAScavengerProcess, G4AnnihiToMuPair, G4GammaConversionToMuons, G4LowECapture, G4MicroElecSurface, G4PolarizedAnnihilation, G4PolarizedCompton, G4PolarizedIonisation, G4VEmProcess, G4VEnergyLossProcess, G4VMultipleScattering, G4SynchrotronRadiation, G4VXTRenergyLoss, G4HadronicProcess, G4hImpactIonisation, G4ChargeExchangeProcess, G4Cerenkov, G4Scintillation, G4OpRayleigh, G4OpWLS, G4OpWLS2, and G4BiasingProcessInterface.

Definition at line 187 of file G4VProcess.hh.

187{}

Referenced by G4VUserPhysicsList::BuildIntegralPhysicsTable(), G4WrapperProcess::BuildPhysicsTable(), G4AdjointProcessEquivalentToDirectProcess::BuildPhysicsTable(), G4BiasingProcessInterface::BuildPhysicsTable(), G4VProcess::BuildWorkerPhysicsTable(), and export_G4VProcess().

◆ BuildWorkerPhysicsTable()

void G4VProcess::BuildWorkerPhysicsTable ( const G4ParticleDefinition & part )

virtualinherited

Reimplemented in G4BiasingProcessInterface.

Definition at line 200 of file G4VProcess.cc.

{
  BuildPhysicsTable(part);
}

References G4VProcess::BuildPhysicsTable().

Referenced by G4BiasingProcessInterface::BuildWorkerPhysicsTable().

◆ CalculateReflectivity()

void G4OpBoundaryProcess::CalculateReflectivity ( void )

private

Definition at line 1396 of file G4OpBoundaryProcess.cc.

{
  G4double realRindex = fRealRIndexMPV->Value(fPhotonMomentum, idx_rrindex);
  G4double imaginaryRindex =
    fImagRIndexMPV->Value(fPhotonMomentum, idx_irindex);
 
  // calculate FacetNormal
  if(fFinish == ground)
  {
    fFacetNormal = GetFacetNormal(fOldMomentum, fGlobalNormal);
  }
  else
  {
    fFacetNormal = fGlobalNormal;
  }
 
  G4double cost1 = -fOldMomentum * fFacetNormal;
  if(std::abs(cost1) < 1.0 - fCarTolerance)
  {
    fSint1 = std::sqrt(1. - cost1 * cost1);
  }
  else
  {
    fSint1 = 0.0;
  }
 
  G4ThreeVector A_trans, A_paral, E1pp, E1pl;
  G4double E1_perp, E1_parl;
 
  if(fSint1 > 0.0)
  {
    A_trans = (fOldMomentum.cross(fFacetNormal)).unit();
    E1_perp = fOldPolarization * A_trans;
    E1pp    = E1_perp * A_trans;
    E1pl    = fOldPolarization - E1pp;
    E1_parl = E1pl.mag();
  }
  else
  {
    A_trans = fOldPolarization;
    // Here we Follow Jackson's conventions and we set the parallel
    // component = 1 in case of a ray perpendicular to the surface
    E1_perp = 0.0;
    E1_parl = 1.0;
  }
 
  G4double incidentangle = GetIncidentAngle();
 
  // calculate the reflectivity depending on incident angle,
  // polarization and complex refractive
  fReflectivity = GetReflectivity(E1_perp, E1_parl, incidentangle, realRindex,
                                  imaginaryRindex);
}

References CLHEP::Hep3Vector::cross(), fCarTolerance, fFacetNormal, fFinish, fGlobalNormal, fImagRIndexMPV, fOldMomentum, fOldPolarization, fPhotonMomentum, fRealRIndexMPV, fReflectivity, fSint1, GetFacetNormal(), GetIncidentAngle(), GetReflectivity(), ground, idx_irindex, idx_rrindex, CLHEP::Hep3Vector::mag(), and G4PhysicsVector::Value().

Referenced by DielectricMetal(), and PostStepDoIt().

◆ ChooseReflection()

void G4OpBoundaryProcess::ChooseReflection ( )

inlineprivate

Definition at line 262 of file G4OpBoundaryProcess.hh.

{
  G4double rand = G4UniformRand();
  if(rand < fProb_ss)
  {
    fStatus      = SpikeReflection;
    fFacetNormal = fGlobalNormal;
  }
  else if(rand < fProb_ss + fProb_sl)
  {
    fStatus = LobeReflection;
  }
  else if(rand < fProb_ss + fProb_sl + fProb_bs)
  {
    fStatus = BackScattering;
  }
  else
  {
    fStatus = LambertianReflection;
  }
}

References BackScattering, fFacetNormal, fGlobalNormal, fProb_bs, fProb_sl, fProb_ss, fStatus, G4UniformRand, LambertianReflection, LobeReflection, and SpikeReflection.

Referenced by DielectricDichroic(), DielectricDielectric(), and DielectricMetal().

◆ ClearNumberOfInteractionLengthLeft()

void G4VProcess::ClearNumberOfInteractionLengthLeft ( )

inlineprotectedinherited

Definition at line 424 of file G4VProcess.hh.

{
  theInitialNumberOfInteractionLength = -1.0; 
  theNumberOfInteractionLengthLeft =  -1.0;
}

References G4VProcess::theInitialNumberOfInteractionLength, and G4VProcess::theNumberOfInteractionLengthLeft.

◆ DielectricDichroic()

void G4OpBoundaryProcess::DielectricDichroic ( )

private

Definition at line 952 of file G4OpBoundaryProcess.cc.

{
  // Calculate Angle between Normal and Photon Momentum
  G4double anglePhotonToNormal = fOldMomentum.angle(-fGlobalNormal);
 
  // Round it to closest integer
  G4double angleIncident = std::floor(180. / pi * anglePhotonToNormal + 0.5);
 
  if(!fDichroicVector)
  {
    if(fOpticalSurface)
      fDichroicVector = fOpticalSurface->GetDichroicVector();
  }
 
  if(fDichroicVector)
  {
    G4double wavelength = h_Planck * c_light / fPhotonMomentum;
    fTransmittance      = fDichroicVector->Value(wavelength / nm, angleIncident,
                                            idx_dichroicX, idx_dichroicY) *
                     perCent;
    //   G4cout << "wavelength: " << std::floor(wavelength/nm)
    //                            << "nm" << G4endl;
    //   G4cout << "Incident angle: " << angleIncident << "deg" << G4endl;
    //   G4cout << "Transmittance: "
    //          << std::floor(fTransmittance/perCent) << "%" << G4endl;
  }
  else
  {
    G4ExceptionDescription ed;
    ed << " G4OpBoundaryProcess/DielectricDichroic(): "
       << " The dichroic surface has no G4Physics2DVector" << G4endl;
    G4Exception("G4OpBoundaryProcess::DielectricDichroic", "OpBoun03",
                FatalException, ed,
                "A dichroic surface must have an associated G4Physics2DVector");
  }
 
  if(!G4BooleanRand(fTransmittance))
  {  // Not transmitted, so reflect
    if(fModel == glisur || fFinish == polished)
    {
      DoReflection();
    }
    else
    {
      ChooseReflection();
      if(fStatus == LambertianReflection)
      {
        DoReflection();
      }
      else if(fStatus == BackScattering)
      {
        fNewMomentum     = -fOldMomentum;
        fNewPolarization = -fOldPolarization;
      }
      else
      {
        G4double PdotN, EdotN;
        do
        {
          if(fStatus == LobeReflection)
          {
            fFacetNormal = GetFacetNormal(fOldMomentum, fGlobalNormal);
          }
          PdotN        = fOldMomentum * fFacetNormal;
          fNewMomentum = fOldMomentum - (2. * PdotN) * fFacetNormal;
          // Loop checking, 13-Aug-2015, Peter Gumplinger
        } while(fNewMomentum * fGlobalNormal <= 0.0);
 
        EdotN            = fOldPolarization * fFacetNormal;
        fNewPolarization = -fOldPolarization + (2. * EdotN) * fFacetNormal;
      }
    }
  }
  else
  {
    fStatus          = Dichroic;
    fNewMomentum     = fOldMomentum;
    fNewPolarization = fOldPolarization;
  }
}

References CLHEP::Hep3Vector::angle(), BackScattering, source.hepunit::c_light, ChooseReflection(), Dichroic, DoReflection(), FatalException, fDichroicVector, fFacetNormal, fFinish, fGlobalNormal, fModel, fNewMomentum, fNewPolarization, fOldMomentum, fOldPolarization, fOpticalSurface, fPhotonMomentum, fStatus, fTransmittance, G4BooleanRand(), G4endl, G4Exception(), G4OpticalSurface::GetDichroicVector(), GetFacetNormal(), glisur, source.hepunit::h_Planck, idx_dichroicX, idx_dichroicY, LambertianReflection, LobeReflection, nm, perCent, pi, polished, and G4Physics2DVector::Value().

Referenced by PostStepDoIt().

◆ DielectricDielectric()

void G4OpBoundaryProcess::DielectricDielectric ( )

private

Definition at line 1034 of file G4OpBoundaryProcess.cc.

{
  G4bool inside = false;
  G4bool swap   = false;
 
  if(fFinish == polished)
  {
    fFacetNormal = fGlobalNormal;
  }
  else
  {
    fFacetNormal = GetFacetNormal(fOldMomentum, fGlobalNormal);
  }
  G4double cost1 = -fOldMomentum * fFacetNormal;
  G4double cost2 = 0.;
  G4double sint2 = 0.;
 
  G4bool surfaceRoughnessCriterionPass = true;
  if(fSurfaceRoughness != 0. && fRindex1 > fRindex2)
  {
    G4double wavelength                = h_Planck * c_light / fPhotonMomentum;
    G4double surfaceRoughnessCriterion = std::exp(-std::pow(
      (4. * pi * fSurfaceRoughness * fRindex1 * cost1 / wavelength), 2));
    surfaceRoughnessCriterionPass = G4BooleanRand(surfaceRoughnessCriterion);
  }
 
leap:
 
  G4bool through = false;
  G4bool done    = false;
 
  G4ThreeVector A_trans, A_paral, E1pp, E1pl;
  G4double E1_perp, E1_parl;
  G4double s1, s2, E2_perp, E2_parl, E2_total, transCoeff;
  G4double E2_abs, C_parl, C_perp;
  G4double alpha;
 
  do
  {
    if(through)
    {
      swap          = !swap;
      through       = false;
      fGlobalNormal = -fGlobalNormal;
      G4SwapPtr(fMaterial1, fMaterial2);
      G4SwapObj(&fRindex1, &fRindex2);
    }
 
    if(fFinish == polished)
    {
      fFacetNormal = fGlobalNormal;
    }
    else
    {
      fFacetNormal = GetFacetNormal(fOldMomentum, fGlobalNormal);
    }
 
    cost1 = -fOldMomentum * fFacetNormal;
    if(std::abs(cost1) < 1.0 - fCarTolerance)
    {
      fSint1 = std::sqrt(1. - cost1 * cost1);
      sint2  = fSint1 * fRindex1 / fRindex2;  // *** Snell's Law ***
      // this isn't a sine as we might expect from the name; can be > 1
    }
    else
    {
      fSint1 = 0.0;
      sint2  = 0.0;
    }
 
    // TOTAL INTERNAL REFLECTION
    if(sint2 >= 1.0)
    {
      swap = false;
 
      fStatus = TotalInternalReflection;
      if(!surfaceRoughnessCriterionPass)
        fStatus = LambertianReflection;
      if(fModel == unified && fFinish != polished)
        ChooseReflection();
      if(fStatus == LambertianReflection)
      {
        DoReflection();
      }
      else if(fStatus == BackScattering)
      {
        fNewMomentum     = -fOldMomentum;
        fNewPolarization = -fOldPolarization;
      }
      else
      {
        fNewMomentum =
          fOldMomentum - 2. * fOldMomentum * fFacetNormal * fFacetNormal;
        fNewPolarization = -fOldPolarization + (2. * fOldPolarization *
                                                fFacetNormal * fFacetNormal);
      }
    }
    // NOT TIR
    else if(sint2 < 1.0)
    {
      // Calculate amplitude for transmission (Q = P x N)
      if(cost1 > 0.0)
      {
        cost2 = std::sqrt(1. - sint2 * sint2);
      }
      else
      {
        cost2 = -std::sqrt(1. - sint2 * sint2);
      }
 
      if(fSint1 > 0.0)
      {
        A_trans = (fOldMomentum.cross(fFacetNormal)).unit();
        E1_perp = fOldPolarization * A_trans;
        E1pp    = E1_perp * A_trans;
        E1pl    = fOldPolarization - E1pp;
        E1_parl = E1pl.mag();
      }
      else
      {
        A_trans = fOldPolarization;
        // Here we Follow Jackson's conventions and set the parallel
        // component = 1 in case of a ray perpendicular to the surface
        E1_perp = 0.0;
        E1_parl = 1.0;
      }
 
      s1       = fRindex1 * cost1;
      E2_perp  = 2. * s1 * E1_perp / (fRindex1 * cost1 + fRindex2 * cost2);
      E2_parl  = 2. * s1 * E1_parl / (fRindex2 * cost1 + fRindex1 * cost2);
      E2_total = E2_perp * E2_perp + E2_parl * E2_parl;
      s2       = fRindex2 * cost2 * E2_total;
 
      if(fTransmittance > 0.)
        transCoeff = fTransmittance;
      else if(cost1 != 0.0)
        transCoeff = s2 / s1;
      else
        transCoeff = 0.0;
 
      // NOT TIR: REFLECTION
      if(!G4BooleanRand(transCoeff))
      {
        swap    = false;
        fStatus = FresnelReflection;
 
        if(!surfaceRoughnessCriterionPass)
          fStatus = LambertianReflection;
        if(fModel == unified && fFinish != polished)
          ChooseReflection();
        if(fStatus == LambertianReflection)
        {
          DoReflection();
        }
        else if(fStatus == BackScattering)
        {
          fNewMomentum     = -fOldMomentum;
          fNewPolarization = -fOldPolarization;
        }
        else
        {
          fNewMomentum =
            fOldMomentum - 2. * fOldMomentum * fFacetNormal * fFacetNormal;
          if(fSint1 > 0.0)
          {  // incident ray oblique
            E2_parl  = fRindex2 * E2_parl / fRindex1 - E1_parl;
            E2_perp  = E2_perp - E1_perp;
            E2_total = E2_perp * E2_perp + E2_parl * E2_parl;
            A_paral  = (fNewMomentum.cross(A_trans)).unit();
            E2_abs   = std::sqrt(E2_total);
            C_parl   = E2_parl / E2_abs;
            C_perp   = E2_perp / E2_abs;
 
            fNewPolarization = C_parl * A_paral + C_perp * A_trans;
          }
          else
          {  // incident ray perpendicular
            if(fRindex2 > fRindex1)
            {
              fNewPolarization = -fOldPolarization;
            }
            else
            {
              fNewPolarization = fOldPolarization;
            }
          }
        }
      }
      // NOT TIR: TRANSMISSION
      else
      {
        inside  = !inside;
        through = true;
        fStatus = FresnelRefraction;
 
        if(fSint1 > 0.0)
        {  // incident ray oblique
          alpha        = cost1 - cost2 * (fRindex2 / fRindex1);
          fNewMomentum = (fOldMomentum + alpha * fFacetNormal).unit();
          A_paral      = (fNewMomentum.cross(A_trans)).unit();
          E2_abs       = std::sqrt(E2_total);
          C_parl       = E2_parl / E2_abs;
          C_perp       = E2_perp / E2_abs;
 
          fNewPolarization = C_parl * A_paral + C_perp * A_trans;
        }
        else
        {  // incident ray perpendicular
          fNewMomentum     = fOldMomentum;
          fNewPolarization = fOldPolarization;
        }
      }
    }
 
    fOldMomentum     = fNewMomentum.unit();
    fOldPolarization = fNewPolarization.unit();
 
    if(fStatus == FresnelRefraction)
    {
      done = (fNewMomentum * fGlobalNormal <= 0.0);
    }
    else
    {
      done = (fNewMomentum * fGlobalNormal >= -fCarTolerance);
    }
    // Loop checking, 13-Aug-2015, Peter Gumplinger
  } while(!done);
 
  if(inside && !swap)
  {
    if(fFinish == polishedbackpainted || fFinish == groundbackpainted)
    {
      G4double rand = G4UniformRand();
      if(rand > fReflectivity + fTransmittance)
      {
        DoAbsorption();
      }
      else if(rand > fReflectivity)
      {
        fStatus          = Transmission;
        fNewMomentum     = fOldMomentum;
        fNewPolarization = fOldPolarization;
      }
      else
      {
        if(fStatus != FresnelRefraction)
        {
          fGlobalNormal = -fGlobalNormal;
        }
        else
        {
          swap = !swap;
          G4SwapPtr(fMaterial1, fMaterial2);
          G4SwapObj(&fRindex1, &fRindex2);
        }
        if(fFinish == groundbackpainted)
          fStatus = LambertianReflection;
 
        DoReflection();
 
        fGlobalNormal = -fGlobalNormal;
        fOldMomentum  = fNewMomentum;
 
        goto leap;
      }
    }
  }
}

References alpha, BackScattering, source.hepunit::c_light, ChooseReflection(), CLHEP::Hep3Vector::cross(), DoAbsorption(), DoReflection(), fCarTolerance, fFacetNormal, fFinish, fGlobalNormal, fMaterial1, fMaterial2, fModel, fNewMomentum, fNewPolarization, fOldMomentum, fOldPolarization, fPhotonMomentum, fReflectivity, FresnelReflection, FresnelRefraction, fRindex1, fRindex2, fSint1, fStatus, fSurfaceRoughness, fTransmittance, G4BooleanRand(), G4SwapObj(), G4SwapPtr(), G4UniformRand, GetFacetNormal(), groundbackpainted, source.hepunit::h_Planck, LambertianReflection, CLHEP::Hep3Vector::mag(), pi, polished, polishedbackpainted, TotalInternalReflection, Transmission, unified, and CLHEP::Hep3Vector::unit().

Referenced by PostStepDoIt().

◆ DielectricLUT()

void G4OpBoundaryProcess::DielectricLUT ( )

private

Definition at line 778 of file G4OpBoundaryProcess.cc.

{
  G4int thetaIndex, phiIndex;
  G4double angularDistVal, thetaRad, phiRad;
  G4ThreeVector perpVectorTheta, perpVectorPhi;
 
  fStatus = G4OpBoundaryProcessStatus(
    G4int(fFinish) + (G4int(NoRINDEX) - G4int(groundbackpainted)));
 
  G4int thetaIndexMax = fOpticalSurface->GetThetaIndexMax();
  G4int phiIndexMax   = fOpticalSurface->GetPhiIndexMax();
 
  G4double rand;
 
  do
  {
    rand = G4UniformRand();
    if(rand > fReflectivity)
    {
      if(rand > fReflectivity + fTransmittance)
      {
        DoAbsorption();
      }
      else
      {
        fStatus          = Transmission;
        fNewMomentum     = fOldMomentum;
        fNewPolarization = fOldPolarization;
      }
      break;
    }
    else
    {
      // Calculate Angle between Normal and Photon Momentum
      G4double anglePhotonToNormal = fOldMomentum.angle(-fGlobalNormal);
      // Round to closest integer: LBNL model array has 91 values
      G4int angleIncident = std::lrint(anglePhotonToNormal / CLHEP::deg);
 
      // Take random angles THETA and PHI,
      // and see if below Probability - if not - Redo
      do
      {
        thetaIndex = G4RandFlat::shootInt(thetaIndexMax - 1);
        phiIndex   = G4RandFlat::shootInt(phiIndexMax - 1);
        // Find probability with the new indeces from LUT
        angularDistVal = fOpticalSurface->GetAngularDistributionValue(
          angleIncident, thetaIndex, phiIndex);
        // Loop checking, 13-Aug-2015, Peter Gumplinger
      } while(!G4BooleanRand(angularDistVal));
 
      thetaRad = G4double(-90 + 4 * thetaIndex) * pi / 180.;
      phiRad   = G4double(-90 + 5 * phiIndex) * pi / 180.;
      // Rotate Photon Momentum in Theta, then in Phi
      fNewMomentum = -fOldMomentum;
 
      perpVectorTheta = fNewMomentum.cross(fGlobalNormal);
      if(perpVectorTheta.mag() < fCarTolerance)
      {
        perpVectorTheta = fNewMomentum.orthogonal();
      }
      fNewMomentum =
        fNewMomentum.rotate(anglePhotonToNormal - thetaRad, perpVectorTheta);
      perpVectorPhi = perpVectorTheta.cross(fNewMomentum);
      fNewMomentum  = fNewMomentum.rotate(-phiRad, perpVectorPhi);
 
      // Rotate Polarization too:
      fFacetNormal     = (fNewMomentum - fOldMomentum).unit();
      fNewPolarization = -fOldPolarization +
                         (2. * fOldPolarization * fFacetNormal * fFacetNormal);
    }
    // Loop checking, 13-Aug-2015, Peter Gumplinger
  } while(fNewMomentum * fGlobalNormal <= 0.0);
}

References CLHEP::Hep3Vector::angle(), CLHEP::Hep3Vector::cross(), CLHEP::deg, DoAbsorption(), fCarTolerance, fFacetNormal, fFinish, fGlobalNormal, fNewMomentum, fNewPolarization, fOldMomentum, fOldPolarization, fOpticalSurface, fReflectivity, fStatus, fTransmittance, G4BooleanRand(), G4UniformRand, G4OpticalSurface::GetAngularDistributionValue(), G4OpticalSurface::GetPhiIndexMax(), G4OpticalSurface::GetThetaIndexMax(), groundbackpainted, CLHEP::Hep3Vector::mag(), NoRINDEX, CLHEP::Hep3Vector::orthogonal(), pi, CLHEP::Hep3Vector::rotate(), and Transmission.

Referenced by PostStepDoIt().

◆ DielectricLUTDAVIS()

void G4OpBoundaryProcess::DielectricLUTDAVIS ( )

private

Definition at line 853 of file G4OpBoundaryProcess.cc.

{
  G4int angindex, random, angleIncident;
  G4double reflectivityValue, elevation, azimuth;
  G4double anglePhotonToNormal;
 
  G4int lutbin  = fOpticalSurface->GetLUTbins();
  G4double rand = G4UniformRand();
 
  G4double sinEl;
  G4ThreeVector u, vNorm, w;
 
  do
  {
    anglePhotonToNormal = fOldMomentum.angle(-fGlobalNormal);
 
    // Davis model has 90 reflection bins: round down
    // don't allow angleIncident to be 90 for anglePhotonToNormal close to 90
    angleIncident = std::min(static_cast<G4int>(
      std::floor(anglePhotonToNormal / CLHEP::deg)), 89);
    reflectivityValue = fOpticalSurface->GetReflectivityLUTValue(angleIncident);
 
    if(rand > reflectivityValue)
    {
      if(fEfficiency > 0.)
      {
        DoAbsorption();
        break;
      }
      else
      {
        fStatus = Transmission;
 
        if(angleIncident <= 0.01)
        {
          fNewMomentum = fOldMomentum;
          break;
        }
 
        do
        {
          random = G4RandFlat::shootInt(1, lutbin + 1);
          angindex =
            (((random * 2) - 1)) + angleIncident * lutbin * 2 + 3640000;
 
          azimuth =
            fOpticalSurface->GetAngularDistributionValueLUT(angindex - 1);
          elevation = fOpticalSurface->GetAngularDistributionValueLUT(angindex);
        } while(elevation == 0. && azimuth == 0.);
 
        sinEl = std::sin(elevation);
        vNorm = (fGlobalNormal.cross(fOldMomentum)).unit();
        u     = vNorm.cross(fGlobalNormal) * (sinEl * std::cos(azimuth));
        vNorm *= (sinEl * std::sin(azimuth));
        // fGlobalNormal shouldn't be modified here
        w            = (fGlobalNormal *= std::cos(elevation));
        fNewMomentum = u + vNorm + w;
 
        // Rotate Polarization too:
        fFacetNormal     = (fNewMomentum - fOldMomentum).unit();
        fNewPolarization = -fOldPolarization + (2. * fOldPolarization *
                                                fFacetNormal * fFacetNormal);
      }
    }
    else
    {
      fStatus = LobeReflection;
 
      if(angleIncident == 0)
      {
        fNewMomentum = -fOldMomentum;
        break;
      }
 
      do
      {
        random   = G4RandFlat::shootInt(1, lutbin + 1);
        angindex = (((random * 2) - 1)) + (angleIncident - 1) * lutbin * 2;
 
        azimuth = fOpticalSurface->GetAngularDistributionValueLUT(angindex - 1);
        elevation = fOpticalSurface->GetAngularDistributionValueLUT(angindex);
      } while(elevation == 0. && azimuth == 0.);
 
      sinEl = std::sin(elevation);
      vNorm = (fGlobalNormal.cross(fOldMomentum)).unit();
      u     = vNorm.cross(fGlobalNormal) * (sinEl * std::cos(azimuth));
      vNorm *= (sinEl * std::sin(azimuth));
      // fGlobalNormal shouldn't be modified here
      w = (fGlobalNormal *= std::cos(elevation));
 
      fNewMomentum = u + vNorm + w;
 
      // Rotate Polarization too: (needs revision)
      fNewPolarization = fOldPolarization;
    }
  } while(fNewMomentum * fGlobalNormal <= 0.0);
}

References CLHEP::Hep3Vector::angle(), CLHEP::Hep3Vector::cross(), CLHEP::deg, DoAbsorption(), fEfficiency, fFacetNormal, fGlobalNormal, fNewMomentum, fNewPolarization, fOldMomentum, fOldPolarization, fOpticalSurface, fStatus, G4UniformRand, G4OpticalSurface::GetAngularDistributionValueLUT(), G4OpticalSurface::GetLUTbins(), G4OpticalSurface::GetReflectivityLUTValue(), LobeReflection, G4INCL::Math::min(), and Transmission.

Referenced by PostStepDoIt().

◆ DielectricMetal()

void G4OpBoundaryProcess::DielectricMetal ( )

private

Definition at line 682 of file G4OpBoundaryProcess.cc.

{
  G4int n = 0;
  G4double rand;
  G4ThreeVector A_trans;
 
  do
  {
    ++n;
    rand = G4UniformRand();
    if(rand > fReflectivity && n == 1)
    {
      if(rand > fReflectivity + fTransmittance)
      {
        DoAbsorption();
      }
      else
      {
        fStatus          = Transmission;
        fNewMomentum     = fOldMomentum;
        fNewPolarization = fOldPolarization;
      }
      break;
    }
    else
    {
      if(fRealRIndexMPV && fImagRIndexMPV)
      {
        if(n > 1)
        {
          CalculateReflectivity();
          if(!G4BooleanRand(fReflectivity))
          {
            DoAbsorption();
            break;
          }
        }
      }
      if(fModel == glisur || fFinish == polished)
      {
        DoReflection();
      }
      else
      {
        if(n == 1)
          ChooseReflection();
        if(fStatus == LambertianReflection)
        {
          DoReflection();
        }
        else if(fStatus == BackScattering)
        {
          fNewMomentum     = -fOldMomentum;
          fNewPolarization = -fOldPolarization;
        }
        else
        {
          if(fStatus == LobeReflection)
          {
            if(!fRealRIndexMPV || !fImagRIndexMPV)
            {
              fFacetNormal = GetFacetNormal(fOldMomentum, fGlobalNormal);
            }
            //else
            //  case of complex rindex needs to be implemented
          }
          fNewMomentum =
            fOldMomentum - 2. * fOldMomentum * fFacetNormal * fFacetNormal;
 
          if(f_iTE > 0 && f_iTM > 0)
          {
            fNewPolarization =
              -fOldPolarization +
              (2. * fOldPolarization * fFacetNormal * fFacetNormal);
          }
          else if(f_iTE > 0)
          {
            A_trans = (fSint1 > 0.0) ? fOldMomentum.cross(fFacetNormal).unit()
                                     : fOldPolarization;
            fNewPolarization = -A_trans;
          }
          else if(f_iTM > 0)
          {
            fNewPolarization =
              -fNewMomentum.cross(A_trans).unit();  // = -A_paral
          }
        }
      }
      fOldMomentum     = fNewMomentum;
      fOldPolarization = fNewPolarization;
    }
    // Loop checking, 13-Aug-2015, Peter Gumplinger
  } while(fNewMomentum * fGlobalNormal < 0.0);
}

References BackScattering, CalculateReflectivity(), ChooseReflection(), CLHEP::Hep3Vector::cross(), DoAbsorption(), DoReflection(), f_iTE, f_iTM, fFacetNormal, fFinish, fGlobalNormal, fImagRIndexMPV, fModel, fNewMomentum, fNewPolarization, fOldMomentum, fOldPolarization, fRealRIndexMPV, fReflectivity, fSint1, fStatus, fTransmittance, G4BooleanRand(), G4UniformRand, GetFacetNormal(), glisur, LambertianReflection, LobeReflection, CLHEP::detail::n, polished, Transmission, and CLHEP::Hep3Vector::unit().

Referenced by PostStepDoIt().

◆ DoAbsorption()

void G4OpBoundaryProcess::DoAbsorption ( )

inlineprivate

Definition at line 284 of file G4OpBoundaryProcess.hh.

{
  fStatus = Absorption;
 
  if(G4BooleanRand(fEfficiency))
  {
    // EnergyDeposited =/= 0 means: photon has been detected
    fStatus = Detection;
    aParticleChange.ProposeLocalEnergyDeposit(fPhotonMomentum);
  }
  else
  {
    aParticleChange.ProposeLocalEnergyDeposit(0.0);
  }
 
  fNewMomentum     = fOldMomentum;
  fNewPolarization = fOldPolarization;
 
  aParticleChange.ProposeTrackStatus(fStopAndKill);
}

References Absorption, G4VProcess::aParticleChange, Detection, fEfficiency, fNewMomentum, fNewPolarization, fOldMomentum, fOldPolarization, fPhotonMomentum, fStatus, fStopAndKill, G4BooleanRand(), G4VParticleChange::ProposeLocalEnergyDeposit(), and G4VParticleChange::ProposeTrackStatus().

Referenced by DielectricDielectric(), DielectricLUT(), DielectricLUTDAVIS(), DielectricMetal(), and PostStepDoIt().

◆ DoReflection()

void G4OpBoundaryProcess::DoReflection ( )

inlineprivate

Definition at line 305 of file G4OpBoundaryProcess.hh.

{
  if(fStatus == LambertianReflection)
  {
    fNewMomentum = G4LambertianRand(fGlobalNormal);
    fFacetNormal = (fNewMomentum - fOldMomentum).unit();
  }
  else if(fFinish == ground)
  {
    fStatus = LobeReflection;
    if(!fRealRIndexMPV || !fImagRIndexMPV)
    {
      fFacetNormal = GetFacetNormal(fOldMomentum, fGlobalNormal);
    }
    // else
      // complex ref. index to be implemented
    fNewMomentum =
      fOldMomentum - (2. * fOldMomentum * fFacetNormal * fFacetNormal);
  }
  else
  {
    fStatus      = SpikeReflection;
    fFacetNormal = fGlobalNormal;
    fNewMomentum =
      fOldMomentum - (2. * fOldMomentum * fFacetNormal * fFacetNormal);
  }
  fNewPolarization =
    -fOldPolarization + (2. * fOldPolarization * fFacetNormal * fFacetNormal);
}

References fFacetNormal, fFinish, fGlobalNormal, fImagRIndexMPV, fNewMomentum, fNewPolarization, fOldMomentum, fOldPolarization, fRealRIndexMPV, fStatus, G4LambertianRand(), GetFacetNormal(), ground, LambertianReflection, LobeReflection, and SpikeReflection.

Referenced by DielectricDichroic(), DielectricDielectric(), DielectricMetal(), and PostStepDoIt().

◆ DumpInfo()

void G4VProcess::DumpInfo ( ) const

virtualinherited

Reimplemented in G4AdjointAlongStepWeightCorrection, G4AdjointForcedInteractionForGamma, G4AdjointhMultipleScattering, G4ContinuousGainOfEnergy, G4eAdjointMultipleScattering, G4eInverseBremsstrahlung, G4eInverseCompton, G4eInverseIonisation, G4InversePEEffect, G4IonInverseIonisation, G4PolarizedAnnihilation, G4PolarizedBremsstrahlung, G4PolarizedCompton, G4PolarizedGammaConversion, G4PolarizedIonisation, G4PolarizedPhotoElectric, G4Cerenkov, G4ForwardXrayTR, G4GammaXTRadiator, G4GaussXTRadiator, G4RegularXTRadiator, G4Scintillation, G4StrawTubeXTRadiator, G4SynchrotronRadiation, G4TransitionRadiation, G4TransparentRegXTRadiator, G4VTransitionRadiation, G4VXTRenergyLoss, G4XTRGammaRadModel, G4XTRRegularRadModel, and G4XTRTransparentRegRadModel.

Definition at line 167 of file G4VProcess.cc.

{
  G4cout << "Process Name " << theProcessName ;
  G4cout << " : Type[" << GetProcessTypeName(theProcessType) << "]";
  G4cout << " : SubType[" << theProcessSubType << "]"<< G4endl;
}

References G4cout, G4endl, G4VProcess::GetProcessTypeName(), G4VProcess::theProcessName, G4VProcess::theProcessSubType, and G4VProcess::theProcessType.

Referenced by G4ProcessTable::DumpInfo(), export_G4VProcess(), G4Scintillation::ProcessDescription(), G4Cerenkov::ProcessDescription(), and G4ProcessManagerMessenger::SetNewValue().

◆ EndTracking()

void G4VProcess::EndTracking ( )

virtualinherited

Reimplemented in G4BiasingProcessInterface, G4ParallelGeometriesLimiterProcess, G4WrapperProcess, G4FastSimulationManagerProcess, G4VPhononProcess, G4CoupledTransportation, G4Decay, and G4AdjointProcessEquivalentToDirectProcess.

Definition at line 102 of file G4VProcess.cc.

{
#ifdef G4VERBOSE
  if (verboseLevel>2)
  {
    G4cout << "G4VProcess::EndTracking() - [" << theProcessName << "]"
           << G4endl;
  }
#endif
  theNumberOfInteractionLengthLeft = -1.0;
  currentInteractionLength = -1.0;
  theInitialNumberOfInteractionLength=-1.0;
}

References G4VProcess::currentInteractionLength, G4cout, G4endl, G4VProcess::theInitialNumberOfInteractionLength, G4VProcess::theNumberOfInteractionLengthLeft, G4VProcess::theProcessName, and G4VProcess::verboseLevel.

Referenced by G4BiasingProcessInterface::EndTracking(), G4WrapperProcess::EndTracking(), G4VPhononProcess::EndTracking(), and G4AdjointProcessEquivalentToDirectProcess::EndTracking().

◆ G4BooleanRand()

G4bool G4OpBoundaryProcess::G4BooleanRand ( const G4double prob ) const

inlineprivate

Definition at line 245 of file G4OpBoundaryProcess.hh.

{
  // Returns a random boolean variable with the specified probability
  return (G4UniformRand() < prob);
}

References G4UniformRand.

Referenced by DielectricDichroic(), DielectricDielectric(), DielectricLUT(), DielectricMetal(), and DoAbsorption().

◆ GetCurrentInteractionLength()

G4double G4VProcess::GetCurrentInteractionLength ( ) const

inlineinherited

Definition at line 443 of file G4VProcess.hh.

{
  return currentInteractionLength;
}

References G4VProcess::currentInteractionLength.

Referenced by G4BiasingProcessInterface::InvokeWrappedProcessPostStepGPIL(), G4ChannelingOptrChangeCrossSection::ProposeOccurenceBiasingOperation(), and G4BOptrForceCollision::ProposeOccurenceBiasingOperation().

◆ GetFacetNormal()

G4ThreeVector G4OpBoundaryProcess::GetFacetNormal	(	const G4ThreeVector &	Momentum,
		const G4ThreeVector &	Normal
	)		const

private

Definition at line 617 of file G4OpBoundaryProcess.cc.

{
  G4ThreeVector facetNormal;
  if(fModel == unified || fModel == LUT || fModel == DAVIS)
  {
    /* This function codes alpha to a random value taken from the
    distribution p(alpha) = g(alpha; 0, sigma_alpha)*std::sin(alpha),
    for alpha > 0 and alpha < 90, where g(alpha; 0, sigma_alpha) is a
    gaussian distribution with mean 0 and standard deviation sigma_alpha.  */
 
    G4double sigma_alpha = 0.0;
    if(fOpticalSurface)
      sigma_alpha = fOpticalSurface->GetSigmaAlpha();
    if(sigma_alpha == 0.0)
    {
      return normal;
    }
 
    G4double f_max = std::min(1.0, 4. * sigma_alpha);
    G4double alpha, phi, sinAlpha;
 
    do
    {  // Loop checking, 13-Aug-2015, Peter Gumplinger
      do
      {  // Loop checking, 13-Aug-2015, Peter Gumplinger
        alpha    = G4RandGauss::shoot(0.0, sigma_alpha);
        sinAlpha = std::sin(alpha);
      } while(G4UniformRand() * f_max > sinAlpha || alpha >= halfpi);
 
      phi = G4UniformRand() * twopi;
      facetNormal.set(sinAlpha * std::cos(phi), sinAlpha * std::sin(phi),
                      std::cos(alpha));
      facetNormal.rotateUz(normal);
    } while(momentum * facetNormal >= 0.0);
  }
  else
  {
    G4double polish = 1.0;
    if(fOpticalSurface)
      polish = fOpticalSurface->GetPolish();
    if(polish < 1.0)
    {
      do
      {  // Loop checking, 13-Aug-2015, Peter Gumplinger
        G4ThreeVector smear;
        do
        {  // Loop checking, 13-Aug-2015, Peter Gumplinger
          smear.setX(2. * G4UniformRand() - 1.);
          smear.setY(2. * G4UniformRand() - 1.);
          smear.setZ(2. * G4UniformRand() - 1.);
        } while(smear.mag2() > 1.0);
        facetNormal = normal + (1. - polish) * smear;
      } while(momentum * facetNormal >= 0.0);
      facetNormal = facetNormal.unit();
    }
    else
    {
      facetNormal = normal;
    }
  }
  return facetNormal;
}

References alpha, DAVIS, fModel, fOpticalSurface, G4UniformRand, G4OpticalSurface::GetPolish(), G4OpticalSurface::GetSigmaAlpha(), halfpi, LUT, CLHEP::Hep3Vector::mag2(), G4INCL::Math::min(), CLHEP::normal(), CLHEP::Hep3Vector::rotateUz(), CLHEP::Hep3Vector::set(), CLHEP::Hep3Vector::setX(), CLHEP::Hep3Vector::setY(), CLHEP::Hep3Vector::setZ(), G4INCL::DeJongSpin::shoot(), twopi, unified, and CLHEP::Hep3Vector::unit().

Referenced by CalculateReflectivity(), DielectricDichroic(), DielectricDielectric(), DielectricMetal(), and DoReflection().

◆ GetIncidentAngle()

G4double G4OpBoundaryProcess::GetIncidentAngle ( )

private

Definition at line 1312 of file G4OpBoundaryProcess.cc.

{
  return pi - std::acos(fOldMomentum * fFacetNormal /
                        (fOldMomentum.mag() * fFacetNormal.mag()));
}

References fFacetNormal, fOldMomentum, CLHEP::Hep3Vector::mag(), and pi.

Referenced by CalculateReflectivity().

◆ GetMasterProcess()

const G4VProcess * G4VProcess::GetMasterProcess ( ) const

inlineinherited

Definition at line 518 of file G4VProcess.hh.

{
  return masterProcessShadow;
}

References G4VProcess::masterProcessShadow.

Referenced by G4PolarizedCompton::BuildPhysicsTable(), G4PolarizedIonisation::BuildPhysicsTable(), G4VEmProcess::BuildPhysicsTable(), G4VEnergyLossProcess::BuildPhysicsTable(), G4VMultipleScattering::BuildPhysicsTable(), G4BiasingProcessInterface::SetMasterProcess(), and G4VMultipleScattering::StorePhysicsTable().

◆ GetMeanFreePath()

G4double G4OpBoundaryProcess::GetMeanFreePath	(	const G4Track &	,
		G4double	,
		G4ForceCondition *	condition
	)

overridevirtual

Implements G4VDiscreteProcess.

Definition at line 1304 of file G4OpBoundaryProcess.cc.

{
  *condition = Forced;
  return DBL_MAX;
}

References condition(), DBL_MAX, and Forced.

◆ GetNumberOfInteractionLengthLeft()

G4double G4VProcess::GetNumberOfInteractionLengthLeft ( ) const

inlineinherited

Definition at line 431 of file G4VProcess.hh.

{
  return theNumberOfInteractionLengthLeft;
}

References G4VProcess::theNumberOfInteractionLengthLeft.

◆ GetPhysicsTableFileName()

const G4String & G4VProcess::GetPhysicsTableFileName	(	const G4ParticleDefinition *	particle,
		const G4String &	directory,
		const G4String &	tableName,
		G4bool	ascii = `false`
	)

inherited

Definition at line 181 of file G4VProcess.cc.

{
  G4String thePhysicsTableFileExt;
  if (ascii) thePhysicsTableFileExt = ".asc";
  else       thePhysicsTableFileExt = ".dat";
 
  thePhysicsTableFileName = directory + "/";
  thePhysicsTableFileName += tableName + "." +  theProcessName + ".";
  thePhysicsTableFileName += particle->GetParticleName()
                           + thePhysicsTableFileExt;
  
  return thePhysicsTableFileName;
}

References G4ParticleDefinition::GetParticleName(), G4VProcess::thePhysicsTableFileName, and G4VProcess::theProcessName.

Referenced by export_G4VProcess(), G4GammaGeneralProcess::RetrievePhysicsTable(), G4VEmProcess::RetrievePhysicsTable(), G4VEnergyLossProcess::RetrieveTable(), G4GammaGeneralProcess::StorePhysicsTable(), G4VEmProcess::StorePhysicsTable(), G4VMultipleScattering::StorePhysicsTable(), and G4VEnergyLossProcess::StoreTable().

◆ GetPILfactor()

G4double G4VProcess::GetPILfactor ( ) const

inlineinherited

Definition at line 455 of file G4VProcess.hh.

{
  return thePILfactor;
}

References G4VProcess::thePILfactor.

Referenced by export_G4VProcess().

◆ GetProcessManager()

const G4ProcessManager * G4VProcess::GetProcessManager ( )

inlinevirtualinherited

Reimplemented in G4BiasingProcessInterface, and G4WrapperProcess.

Definition at line 494 of file G4VProcess.hh.

{
  return aProcessManager; 
}

References G4VProcess::aProcessManager.

Referenced by G4BiasingProcessInterface::GetProcessManager(), and G4WrapperProcess::GetProcessManager().

◆ GetProcessName()

const G4String & G4VProcess::GetProcessName ( ) const

inlineinherited

Definition at line 382 of file G4VProcess.hh.

{
  return theProcessName;
}

References G4VProcess::theProcessName.

◆ GetProcessSubType()

G4int G4VProcess::GetProcessSubType ( ) const

inlineinherited

Definition at line 400 of file G4VProcess.hh.

{
  return theProcessSubType;
}

References G4VProcess::theProcessSubType.

Referenced by G4GammaGeneralProcess::AddEmProcess(), G4DNABrownianTransportation::BuildPhysicsTable(), G4HadronicProcessStore::FindProcess(), G4BiasingProcessInterface::G4BiasingProcessInterface(), G4HadronicProcessStore::GetCrossSectionPerAtom(), G4HadronicProcessStore::GetCrossSectionPerVolume(), G4GammaGeneralProcess::GetSubProcessSubType(), G4VEmProcess::PostStepDoIt(), G4VEmProcess::PreparePhysicsTable(), G4VEnergyLossProcess::PreparePhysicsTable(), G4HadronicProcessStore::Print(), G4AnnihiToMuPair::PrintInfoDefinition(), G4GammaConversionToMuons::PrintInfoDefinition(), G4PhysicsListHelper::RegisterProcess(), G4ElectronIonPair::ResidualeChargePostStep(), G4EmConfigurator::SetModelForRegion(), G4ChannelingOptrChangeCrossSection::StartRun(), G4VEnergyLossProcess::StreamInfo(), G4VEmProcess::StreamInfo(), and G4VMultipleScattering::StreamInfo().

◆ GetProcessType()

G4ProcessType G4VProcess::GetProcessType ( ) const

inlineinherited

Definition at line 388 of file G4VProcess.hh.

{
  return theProcessType;
}

References G4VProcess::theProcessType.

Referenced by G4BiasingHelper::ActivatePhysicsBiasing(), G4RichTrajectory::CreateAttValues(), G4RichTrajectoryPoint::CreateAttValues(), G4SteppingManager::DefinePhysicalStepLength(), export_G4VProcess(), G4ProcessTable::Find(), G4AdjointProcessEquivalentToDirectProcess::G4AdjointProcessEquivalentToDirectProcess(), G4WrapperProcess::RegisterProcess(), G4PhysicsListHelper::RegisterProcess(), G4ProcessTableMessenger::SetNewValue(), G4ProcessTable::SetProcessActivation(), and G4ChannelingOptrChangeCrossSection::StartRun().

◆ GetProcessTypeName()

const G4String & G4VProcess::GetProcessTypeName ( G4ProcessType aType )

staticinherited

Definition at line 134 of file G4VProcess.cc.

{
  switch (aType)
  {
    case fNotDefined:         return typeNotDefined; break;
    case fTransportation:     return typeTransportation; break;
    case fElectromagnetic:    return typeElectromagnetic; break;
    case fOptical:            return typeOptical; break;
    case fHadronic:           return typeHadronic; break;
    case fPhotolepton_hadron: return typePhotolepton_hadron; break;
    case fDecay:              return typeDecay; break;
    case fGeneral:            return typeGeneral; break;
    case fParameterisation:   return typeParameterisation; break;
    case fUserDefined:        return typeUserDefined; break;
    case fPhonon:             return typePhonon; break;
    default: ;
  }
  return noType;  
}

Referenced by G4RichTrajectory::CreateAttValues(), G4RichTrajectoryPoint::CreateAttValues(), G4ProcessManager::DumpInfo(), G4VProcess::DumpInfo(), G4ProcessTableMessenger::G4ProcessTableMessenger(), G4ProcessTableMessenger::GetProcessType(), G4ProcessTableMessenger::GetProcessTypeName(), and G4ProcessTableMessenger::SetNumberOfProcessType().

◆ GetReflectivity()

G4double G4OpBoundaryProcess::GetReflectivity	(	G4double	E1_perp,
		G4double	E1_parl,
		G4double	incidentangle,
		G4double	RealRindex,
		G4double	ImaginaryRindex
	)

private

Definition at line 1319 of file G4OpBoundaryProcess.cc.

{
  G4complex reflectivity, reflectivity_TE, reflectivity_TM;
  G4complex N1(fRindex1, 0.), N2(realRindex, imaginaryRindex);
  G4complex cosPhi;
 
  G4complex u(1., 0.);  // unit number 1
 
  G4complex numeratorTE;  // E1_perp=1 E1_parl=0 -> TE polarization
  G4complex numeratorTM;  // E1_parl=1 E1_perp=0 -> TM polarization
  G4complex denominatorTE, denominatorTM;
  G4complex rTM, rTE;
 
  G4MaterialPropertiesTable* MPT = fMaterial1->GetMaterialPropertiesTable();
  G4MaterialPropertyVector* ppR  = MPT->GetProperty(kREALRINDEX);
  G4MaterialPropertyVector* ppI  = MPT->GetProperty(kIMAGINARYRINDEX);
  if(ppR && ppI)
  {
    G4double rRindex = ppR->Value(fPhotonMomentum, idx_rrindex);
    G4double iRindex = ppI->Value(fPhotonMomentum, idx_irindex);
    N1               = G4complex(rRindex, iRindex);
  }
 
  // Following two equations, rTM and rTE, are from: "Introduction To Modern
  // Optics" written by Fowles
  cosPhi = std::sqrt(u - ((std::sin(incidentangle) * std::sin(incidentangle)) *
                          (N1 * N1) / (N2 * N2)));
 
  numeratorTE   = N1 * std::cos(incidentangle) - N2 * cosPhi;
  denominatorTE = N1 * std::cos(incidentangle) + N2 * cosPhi;
  rTE           = numeratorTE / denominatorTE;
 
  numeratorTM   = N2 * std::cos(incidentangle) - N1 * cosPhi;
  denominatorTM = N2 * std::cos(incidentangle) + N1 * cosPhi;
  rTM           = numeratorTM / denominatorTM;
 
  // This is my (PG) calculaton for reflectivity on a metallic surface
  // depending on the fraction of TE and TM polarization
  // when TE polarization, E1_parl=0 and E1_perp=1, R=abs(rTE)^2 and
  // when TM polarization, E1_parl=1 and E1_perp=0, R=abs(rTM)^2
 
  reflectivity_TE = (rTE * conj(rTE)) * (E1_perp * E1_perp) /
                    (E1_perp * E1_perp + E1_parl * E1_parl);
  reflectivity_TM = (rTM * conj(rTM)) * (E1_parl * E1_parl) /
                    (E1_perp * E1_perp + E1_parl * E1_parl);
  reflectivity = reflectivity_TE + reflectivity_TM;
 
  do
  {
    if(G4UniformRand() * real(reflectivity) > real(reflectivity_TE))
    {
      f_iTE = -1;
    }
    else
    {
      f_iTE = 1;
    }
    if(G4UniformRand() * real(reflectivity) > real(reflectivity_TM))
    {
      f_iTM = -1;
    }
    else
    {
      f_iTM = 1;
    }
    // Loop checking, 13-Aug-2015, Peter Gumplinger
  } while(f_iTE < 0 && f_iTM < 0);
 
  return real(reflectivity);
}

References f_iTE, f_iTM, fMaterial1, fPhotonMomentum, fRindex1, G4UniformRand, G4Material::GetMaterialPropertiesTable(), G4MaterialPropertiesTable::GetProperty(), idx_irindex, idx_rrindex, kIMAGINARYRINDEX, kREALRINDEX, and G4PhysicsVector::Value().

Referenced by CalculateReflectivity().

◆ GetStatus()

G4OpBoundaryProcessStatus G4OpBoundaryProcess::GetStatus ( ) const

inlinevirtual

Definition at line 257 of file G4OpBoundaryProcess.hh.

{
  return fStatus;
}

References fStatus.

◆ GetTotalNumberOfInteractionLengthTraversed()

G4double G4VProcess::GetTotalNumberOfInteractionLengthTraversed ( ) const

inlineinherited

Definition at line 437 of file G4VProcess.hh.

{
  return theInitialNumberOfInteractionLength - theNumberOfInteractionLengthLeft;
}

References G4VProcess::theInitialNumberOfInteractionLength, and G4VProcess::theNumberOfInteractionLengthLeft.

Referenced by G4HadronicProcess::XBiasSecondaryWeight(), and G4HadronicProcess::XBiasSurvivalProbability().

◆ GetVerboseLevel()

G4int G4VProcess::GetVerboseLevel ( ) const

inlineinherited

Definition at line 418 of file G4VProcess.hh.

{
  return  verboseLevel;
}

References G4VProcess::verboseLevel.

Referenced by G4MuonMinusAtomicCapture::AtRestDoIt(), G4Decay::DecayIt(), G4UnknownDecay::DecayIt(), G4ProcessTable::DumpInfo(), export_G4VProcess(), G4Decay::G4Decay(), G4UnknownDecay::G4UnknownDecay(), G4Decay::GetMeanFreePath(), G4Decay::GetMeanLifeTime(), and G4DecayWithSpin::Spin_Precession().

◆ Initialise()

void G4OpBoundaryProcess::Initialise ( )

virtual

Definition at line 138 of file G4OpBoundaryProcess.cc.

{
  G4OpticalParameters* params = G4OpticalParameters::Instance();
  SetInvokeSD(params->GetBoundaryInvokeSD());
  SetVerboseLevel(params->GetBoundaryVerboseLevel());
}

References G4OpticalParameters::GetBoundaryInvokeSD(), G4OpticalParameters::GetBoundaryVerboseLevel(), G4OpticalParameters::Instance(), SetInvokeSD(), and SetVerboseLevel().

Referenced by G4OpBoundaryProcess(), and PreparePhysicsTable().

◆ InvokeSD()

G4bool G4OpBoundaryProcess::InvokeSD ( const G4Step * step )

private

Definition at line 1451 of file G4OpBoundaryProcess.cc.

{
  G4Step aStep = *pStep;
  aStep.AddTotalEnergyDeposit(fPhotonMomentum);
 
  G4VSensitiveDetector* sd = aStep.GetPostStepPoint()->GetSensitiveDetector();
  if(sd != nullptr)
    return sd->Hit(&aStep);
  else
    return false;
}

References G4Step::AddTotalEnergyDeposit(), fPhotonMomentum, G4Step::GetPostStepPoint(), G4StepPoint::GetSensitiveDetector(), and G4VSensitiveDetector::Hit().

Referenced by PostStepDoIt().

◆ isAlongStepDoItIsEnabled()

G4bool G4VProcess::isAlongStepDoItIsEnabled ( ) const

inlineinherited

Definition at line 506 of file G4VProcess.hh.

{
  return enableAlongStepDoIt;
}

References G4VProcess::enableAlongStepDoIt.

Referenced by G4ProcessManager::CheckOrderingParameters().

◆ IsApplicable()

G4bool G4OpBoundaryProcess::IsApplicable ( const G4ParticleDefinition & aParticleType )

inlineoverridevirtual

Reimplemented from G4VProcess.

Definition at line 251 of file G4OpBoundaryProcess.hh.

{
  return (&aParticleType == G4OpticalPhoton::OpticalPhoton());
}

References G4OpticalPhoton::OpticalPhoton().

Referenced by G4OpticalPhysics::ConstructProcess().

◆ isAtRestDoItIsEnabled()

G4bool G4VProcess::isAtRestDoItIsEnabled ( ) const

inlineinherited

Definition at line 500 of file G4VProcess.hh.

{
  return enableAtRestDoIt;
}

References G4VProcess::enableAtRestDoIt.

Referenced by G4ProcessManager::CheckOrderingParameters().

◆ isPostStepDoItIsEnabled()

G4bool G4VProcess::isPostStepDoItIsEnabled ( ) const

inlineinherited

Definition at line 512 of file G4VProcess.hh.

{
  return enablePostStepDoIt;
}

References G4VProcess::enablePostStepDoIt.

Referenced by G4ProcessManager::CheckOrderingParameters().

◆ operator!=()

G4bool G4VProcess::operator!= ( const G4VProcess & right ) const

inherited

Definition at line 161 of file G4VProcess.cc.

{
  return (this !=  &right);
}

◆ operator=()

G4OpBoundaryProcess & G4OpBoundaryProcess::operator= ( const G4OpBoundaryProcess & right )

privatedelete

◆ operator==()

G4bool G4VProcess::operator== ( const G4VProcess & right ) const

inherited

Definition at line 155 of file G4VProcess.cc.

{
  return (this == &right);
}

◆ PostStepDoIt()

G4VParticleChange * G4OpBoundaryProcess::PostStepDoIt	(	const G4Track &	aTrack,
		const G4Step &	aStep
	)

overridevirtual

Reimplemented from G4VDiscreteProcess.

Definition at line 146 of file G4OpBoundaryProcess.cc.

{
  fStatus = Undefined;
  aParticleChange.Initialize(aTrack);
  aParticleChange.ProposeVelocity(aTrack.GetVelocity());
 
  // Get hyperStep from  G4ParallelWorldProcess
  //  NOTE: PostSetpDoIt of this process to be invoked after
  //  G4ParallelWorldProcess!
  const G4Step* pStep = &aStep;
  const G4Step* hStep = G4ParallelWorldProcess::GetHyperStep();
  if(hStep != nullptr)
    pStep = hStep;
 
  if(pStep->GetPostStepPoint()->GetStepStatus() == fGeomBoundary)
  {
    fMaterial1 = pStep->GetPreStepPoint()->GetMaterial();
    fMaterial2 = pStep->GetPostStepPoint()->GetMaterial();
  }
  else
  {
    fStatus = NotAtBoundary;
    if(verboseLevel > 1)
      BoundaryProcessVerbose();
    return G4VDiscreteProcess::PostStepDoIt(aTrack, aStep);
  }
 
  G4VPhysicalVolume* thePrePV  = pStep->GetPreStepPoint()->GetPhysicalVolume();
  G4VPhysicalVolume* thePostPV = pStep->GetPostStepPoint()->GetPhysicalVolume();
 
  if(verboseLevel > 1)
  {
    G4cout << " Photon at Boundary! " << G4endl;
    if(thePrePV != nullptr)
      G4cout << " thePrePV:  " << thePrePV->GetName() << G4endl;
    if(thePostPV != nullptr)
      G4cout << " thePostPV: " << thePostPV->GetName() << G4endl;
  }
 
  if(aTrack.GetStepLength() <= fCarTolerance)
  {
    fStatus = StepTooSmall;
    if(verboseLevel > 1)
      BoundaryProcessVerbose();
 
    G4MaterialPropertyVector* groupvel = nullptr;
    G4MaterialPropertiesTable* aMPT = fMaterial2->GetMaterialPropertiesTable();
    if(aMPT != nullptr)
    {
      groupvel = aMPT->GetProperty(kGROUPVEL);
    }
    if(groupvel != nullptr)
    {
      aParticleChange.ProposeVelocity(
        groupvel->Value(fPhotonMomentum, idx_groupvel));
    }
    return G4VDiscreteProcess::PostStepDoIt(aTrack, aStep);
  }
 
  const G4DynamicParticle* aParticle = aTrack.GetDynamicParticle();
 
  fPhotonMomentum  = aParticle->GetTotalMomentum();
  fOldMomentum     = aParticle->GetMomentumDirection();
  fOldPolarization = aParticle->GetPolarization();
 
  if(verboseLevel > 1)
  {
    G4cout << " Old Momentum Direction: " << fOldMomentum << G4endl
           << " Old Polarization:       " << fOldPolarization << G4endl;
  }
 
  G4ThreeVector theGlobalPoint = pStep->GetPostStepPoint()->GetPosition();
  G4bool valid;
 
  // ID of Navigator which limits step
  G4int hNavId = G4ParallelWorldProcess::GetHypNavigatorID();
  auto iNav    = G4TransportationManager::GetTransportationManager()
                ->GetActiveNavigatorsIterator();
  fGlobalNormal = (iNav[hNavId])->GetGlobalExitNormal(theGlobalPoint, &valid);
 
  if(valid)
  {
    fGlobalNormal = -fGlobalNormal;
  }
  else
  {
    G4ExceptionDescription ed;
    ed << " G4OpBoundaryProcess/PostStepDoIt(): "
       << " The Navigator reports that it returned an invalid normal" << G4endl;
    G4Exception(
      "G4OpBoundaryProcess::PostStepDoIt", "OpBoun01", EventMustBeAborted, ed,
      "Invalid Surface Normal - Geometry must return valid surface normal");
  }
 
  if(fOldMomentum * fGlobalNormal > 0.0)
  {
#ifdef G4OPTICAL_DEBUG
    G4ExceptionDescription ed;
    ed << " G4OpBoundaryProcess/PostStepDoIt(): fGlobalNormal points in a "
          "wrong direction. "
       << G4endl
       << "   The momentum of the photon arriving at interface (oldMomentum)"
       << "   must exit the volume cross in the step. " << G4endl
       << "   So it MUST have dot < 0 with the normal that Exits the new "
          "volume (globalNormal)."
       << G4endl << "   >> The dot product of oldMomentum and global Normal is "
       << fOldMomentum * fGlobalNormal << G4endl
       << "     Old Momentum  (during step)     = " << fOldMomentum << G4endl
       << "     Global Normal (Exiting New Vol) = " << fGlobalNormal << G4endl
       << G4endl;
    G4Exception("G4OpBoundaryProcess::PostStepDoIt", "OpBoun02",
                EventMustBeAborted,  // Or JustWarning to see if it happens
                                     // repeatedly on one ray
                ed,
                "Invalid Surface Normal - Geometry must return valid surface "
                "normal pointing in the right direction");
#else
    fGlobalNormal = -fGlobalNormal;
#endif
  }
 
  G4MaterialPropertyVector* rIndexMPV = nullptr;
  G4MaterialPropertiesTable* MPT = fMaterial1->GetMaterialPropertiesTable();
  if(MPT != nullptr)
  {
    rIndexMPV = MPT->GetProperty(kRINDEX);
  }
  if(rIndexMPV != nullptr)
  {
    fRindex1 = rIndexMPV->Value(fPhotonMomentum, idx_rindex1);
  }
  else
  {
    fStatus = NoRINDEX;
    if(verboseLevel > 1)
      BoundaryProcessVerbose();
    aParticleChange.ProposeLocalEnergyDeposit(fPhotonMomentum);
    aParticleChange.ProposeTrackStatus(fStopAndKill);
    return G4VDiscreteProcess::PostStepDoIt(aTrack, aStep);
  }
 
  fReflectivity      = 1.;
  fEfficiency        = 0.;
  fTransmittance     = 0.;
  fSurfaceRoughness  = 0.;
  fModel             = glisur;
  fFinish            = polished;
  G4SurfaceType type = dielectric_dielectric;
 
  rIndexMPV       = nullptr;
  fOpticalSurface = nullptr;
 
  G4LogicalSurface* surface =
    G4LogicalBorderSurface::GetSurface(thePrePV, thePostPV);
  if(surface == nullptr)
  {
    if(thePostPV->GetMotherLogical() == thePrePV->GetLogicalVolume())
    {
      surface = G4LogicalSkinSurface::GetSurface(thePostPV->GetLogicalVolume());
      if(surface == nullptr)
      {
        surface =
          G4LogicalSkinSurface::GetSurface(thePrePV->GetLogicalVolume());
      }
    }
    else
    {
      surface = G4LogicalSkinSurface::GetSurface(thePrePV->GetLogicalVolume());
      if(surface == nullptr)
      {
        surface =
          G4LogicalSkinSurface::GetSurface(thePostPV->GetLogicalVolume());
      }
    }
  }
 
  if(surface != nullptr)
  {
    fOpticalSurface =
      dynamic_cast<G4OpticalSurface*>(surface->GetSurfaceProperty());
  }
  if(fOpticalSurface != nullptr)
  {
    type    = fOpticalSurface->GetType();
    fModel  = fOpticalSurface->GetModel();
    fFinish = fOpticalSurface->GetFinish();
 
    G4MaterialPropertiesTable* sMPT =
      fOpticalSurface->GetMaterialPropertiesTable();
    if(sMPT != nullptr)
    {
      if(fFinish == polishedbackpainted || fFinish == groundbackpainted)
      {
        rIndexMPV = sMPT->GetProperty(kRINDEX);
        if(rIndexMPV != nullptr)
        {
          fRindex2 = rIndexMPV->Value(fPhotonMomentum, idx_rindex_surface);
        }
        else
        {
          fStatus = NoRINDEX;
          if(verboseLevel > 1)
            BoundaryProcessVerbose();
          aParticleChange.ProposeLocalEnergyDeposit(fPhotonMomentum);
          aParticleChange.ProposeTrackStatus(fStopAndKill);
          return G4VDiscreteProcess::PostStepDoIt(aTrack, aStep);
        }
      }
 
      fRealRIndexMPV = sMPT->GetProperty(kREALRINDEX);
      fImagRIndexMPV = sMPT->GetProperty(kIMAGINARYRINDEX);
      f_iTE = f_iTM = 1;
 
      G4MaterialPropertyVector* pp;
      if((pp = sMPT->GetProperty(kREFLECTIVITY)))
      {
        fReflectivity = pp->Value(fPhotonMomentum, idx_reflect);
      }
      else if(fRealRIndexMPV && fImagRIndexMPV)
      {
        CalculateReflectivity();
      }
 
      if((pp = sMPT->GetProperty(kEFFICIENCY)))
      {
        fEfficiency = pp->Value(fPhotonMomentum, idx_eff);
      }
      if((pp = sMPT->GetProperty(kTRANSMITTANCE)))
      {
        fTransmittance = pp->Value(fPhotonMomentum, idx_trans);
      }
      if(sMPT->ConstPropertyExists(kSURFACEROUGHNESS))
      {
        fSurfaceRoughness = sMPT->GetConstProperty(kSURFACEROUGHNESS);
      }
 
      if(fModel == unified)
      {
        fProb_sl = (pp = sMPT->GetProperty(kSPECULARLOBECONSTANT))
                     ? pp->Value(fPhotonMomentum, idx_lobe)
                     : 0.;
        fProb_ss = (pp = sMPT->GetProperty(kSPECULARSPIKECONSTANT))
                     ? pp->Value(fPhotonMomentum, idx_spike)
                     : 0.;
        fProb_bs = (pp = sMPT->GetProperty(kBACKSCATTERCONSTANT))
                     ? pp->Value(fPhotonMomentum, idx_back)
                     : 0.;
      }
    }  // end of if(sMPT)
    else if(fFinish == polishedbackpainted || fFinish == groundbackpainted)
    {
      aParticleChange.ProposeLocalEnergyDeposit(fPhotonMomentum);
      aParticleChange.ProposeTrackStatus(fStopAndKill);
      return G4VDiscreteProcess::PostStepDoIt(aTrack, aStep);
    }
  }  // end of if(fOpticalSurface)
 
  //  DIELECTRIC-DIELECTRIC
  if(type == dielectric_dielectric)
  {
    if(fFinish == polished || fFinish == ground)
    {
      if(fMaterial1 == fMaterial2)
      {
        fStatus = SameMaterial;
        if(verboseLevel > 1)
          BoundaryProcessVerbose();
        return G4VDiscreteProcess::PostStepDoIt(aTrack, aStep);
      }
      MPT = fMaterial2->GetMaterialPropertiesTable();
      rIndexMPV = nullptr;
      if(MPT != nullptr)
      {
        rIndexMPV = MPT->GetProperty(kRINDEX);
      }
      if(rIndexMPV != nullptr)
      {
        fRindex2 = rIndexMPV->Value(fPhotonMomentum, idx_rindex2);
      }
      else
      {
        fStatus = NoRINDEX;
        if(verboseLevel > 1)
          BoundaryProcessVerbose();
        aParticleChange.ProposeLocalEnergyDeposit(fPhotonMomentum);
        aParticleChange.ProposeTrackStatus(fStopAndKill);
        return G4VDiscreteProcess::PostStepDoIt(aTrack, aStep);
      }
    }
    if(fFinish == polishedbackpainted || fFinish == groundbackpainted)
    {
      DielectricDielectric();
    }
    else
    {
      G4double rand = G4UniformRand();
      if(rand > fReflectivity + fTransmittance)
      {
        DoAbsorption();
      }
      else if(rand > fReflectivity)
      {
        fStatus          = Transmission;
        fNewMomentum     = fOldMomentum;
        fNewPolarization = fOldPolarization;
      }
      else
      {
        if(fFinish == polishedfrontpainted)
        {
          DoReflection();
        }
        else if(fFinish == groundfrontpainted)
        {
          fStatus = LambertianReflection;
          DoReflection();
        }
        else
        {
          DielectricDielectric();
        }
      }
    }
  }
  else if(type == dielectric_metal)
  {
    DielectricMetal();
  }
  else if(type == dielectric_LUT)
  {
    DielectricLUT();
  }
  else if(type == dielectric_LUTDAVIS)
  {
    DielectricLUTDAVIS();
  }
  else if(type == dielectric_dichroic)
  {
    DielectricDichroic();
  }
  else
  {
    G4ExceptionDescription ed;
    ed << " PostStepDoIt(): Illegal boundary type." << G4endl;
    G4Exception("G4OpBoundaryProcess", "OpBoun04", JustWarning, ed);
    return G4VDiscreteProcess::PostStepDoIt(aTrack, aStep);
  }
 
  fNewMomentum     = fNewMomentum.unit();
  fNewPolarization = fNewPolarization.unit();
 
  if(verboseLevel > 1)
  {
    G4cout << " New Momentum Direction: " << fNewMomentum << G4endl
           << " New Polarization:       " << fNewPolarization << G4endl;
    BoundaryProcessVerbose();
  }
 
  aParticleChange.ProposeMomentumDirection(fNewMomentum);
  aParticleChange.ProposePolarization(fNewPolarization);
 
  if(fStatus == FresnelRefraction || fStatus == Transmission)
  {
    // not all surface types check that fMaterial2 has an MPT
    G4MaterialPropertiesTable* aMPT = fMaterial2->GetMaterialPropertiesTable();
    G4MaterialPropertyVector* groupvel = nullptr;
    if(aMPT != nullptr)
    {
      groupvel = aMPT->GetProperty(kGROUPVEL);
    }
    if(groupvel != nullptr)
    {
      aParticleChange.ProposeVelocity(
        groupvel->Value(fPhotonMomentum, idx_groupvel));
    }
  }
 
  if(fStatus == Detection && fInvokeSD)
    InvokeSD(pStep);
  return G4VDiscreteProcess::PostStepDoIt(aTrack, aStep);
}

References G4VProcess::aParticleChange, BoundaryProcessVerbose(), CalculateReflectivity(), G4MaterialPropertiesTable::ConstPropertyExists(), Detection, dielectric_dichroic, dielectric_dielectric, dielectric_LUT, dielectric_LUTDAVIS, dielectric_metal, DielectricDichroic(), DielectricDielectric(), DielectricLUT(), DielectricLUTDAVIS(), DielectricMetal(), DoAbsorption(), DoReflection(), EventMustBeAborted, f_iTE, f_iTM, fCarTolerance, fEfficiency, fFinish, fGeomBoundary, fGlobalNormal, fImagRIndexMPV, fInvokeSD, fMaterial1, fMaterial2, fModel, fNewMomentum, fNewPolarization, fOldMomentum, fOldPolarization, fOpticalSurface, fPhotonMomentum, fProb_bs, fProb_sl, fProb_ss, fRealRIndexMPV, fReflectivity, FresnelRefraction, fRindex1, fRindex2, fStatus, fStopAndKill, fSurfaceRoughness, fTransmittance, G4cout, G4endl, G4Exception(), G4UniformRand, G4TransportationManager::GetActiveNavigatorsIterator(), G4MaterialPropertiesTable::GetConstProperty(), G4Track::GetDynamicParticle(), G4OpticalSurface::GetFinish(), G4ParallelWorldProcess::GetHyperStep(), G4ParallelWorldProcess::GetHypNavigatorID(), G4VPhysicalVolume::GetLogicalVolume(), G4StepPoint::GetMaterial(), G4Material::GetMaterialPropertiesTable(), G4OpticalSurface::GetMaterialPropertiesTable(), G4OpticalSurface::GetModel(), G4DynamicParticle::GetMomentumDirection(), G4VPhysicalVolume::GetMotherLogical(), G4VPhysicalVolume::GetName(), G4StepPoint::GetPhysicalVolume(), G4DynamicParticle::GetPolarization(), G4StepPoint::GetPosition(), G4Step::GetPostStepPoint(), G4Step::GetPreStepPoint(), G4MaterialPropertiesTable::GetProperty(), G4Track::GetStepLength(), G4StepPoint::GetStepStatus(), G4LogicalSkinSurface::GetSurface(), G4LogicalBorderSurface::GetSurface(), G4LogicalSurface::GetSurfaceProperty(), G4DynamicParticle::GetTotalMomentum(), G4TransportationManager::GetTransportationManager(), G4SurfaceProperty::GetType(), G4Track::GetVelocity(), glisur, ground, groundbackpainted, groundfrontpainted, idx_back, idx_eff, idx_groupvel, idx_lobe, idx_reflect, idx_rindex1, idx_rindex2, idx_rindex_surface, idx_spike, idx_trans, G4ParticleChange::Initialize(), InvokeSD(), JustWarning, kBACKSCATTERCONSTANT, kEFFICIENCY, kGROUPVEL, kIMAGINARYRINDEX, kREALRINDEX, kREFLECTIVITY, kRINDEX, kSPECULARLOBECONSTANT, kSPECULARSPIKECONSTANT, kSURFACEROUGHNESS, kTRANSMITTANCE, LambertianReflection, NoRINDEX, NotAtBoundary, polished, polishedbackpainted, polishedfrontpainted, G4VDiscreteProcess::PostStepDoIt(), G4InuclParticleNames::pp, G4VParticleChange::ProposeLocalEnergyDeposit(), G4ParticleChange::ProposeMomentumDirection(), G4ParticleChange::ProposePolarization(), G4VParticleChange::ProposeTrackStatus(), G4ParticleChange::ProposeVelocity(), SameMaterial, StepTooSmall, Transmission, Undefined, unified, CLHEP::Hep3Vector::unit(), G4PhysicsVector::Value(), and G4VProcess::verboseLevel.

◆ PostStepGetPhysicalInteractionLength()

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

virtualinherited

Implements G4VProcess.

Reimplemented in G4ErrorMagFieldLimitProcess, G4ErrorStepLengthLimitProcess, G4ErrorTrackLengthTarget, G4HadronStoppingProcess, G4NeutronKiller, G4GammaGeneralProcess, G4UnknownDecay, G4PolarizedAnnihilation, G4PolarizedCompton, G4VEmProcess, G4VErrorLimitProcess, and G4LowECapture.

Definition at line 70 of file G4VDiscreteProcess.cc.

{
  if ( (previousStepSize < 0.0) || (theNumberOfInteractionLengthLeft<=0.0))
  {
    // beginning of tracking (or just after DoIt() of this process)
    ResetNumberOfInteractionLengthLeft();
  }
  else if ( previousStepSize > 0.0)
  {
    // subtract NumberOfInteractionLengthLeft 
    SubtractNumberOfInteractionLengthLeft(previousStepSize);
  }
  else
  {
    // zero step
    // DO NOTHING
  }
 
  // condition is set to "Not Forced"
  *condition = NotForced;
 
  // get mean free path
  currentInteractionLength = GetMeanFreePath(track, previousStepSize, condition);
 
  G4double value;
  if (currentInteractionLength < DBL_MAX)
  {
    value = theNumberOfInteractionLengthLeft * currentInteractionLength;
  }
  else
  {
    value = DBL_MAX;
  }
#ifdef G4VERBOSE
  if (verboseLevel>1)
  {
    G4cout << "G4VDiscreteProcess::PostStepGetPhysicalInteractionLength() - ";
    G4cout << "[ " << GetProcessName() << "]" <<G4endl;
    track.GetDynamicParticle()->DumpInfo();
    G4cout << " in Material  " <<  track.GetMaterial()->GetName() <<G4endl;
    G4cout << "InteractionLength= " << value/cm <<"[cm] " <<G4endl;
  }
#endif
  return value;
}

References cm, condition(), G4VProcess::currentInteractionLength, DBL_MAX, G4DynamicParticle::DumpInfo(), G4cout, G4endl, G4Track::GetDynamicParticle(), G4Track::GetMaterial(), G4VDiscreteProcess::GetMeanFreePath(), G4Material::GetName(), G4VProcess::GetProcessName(), NotForced, G4VProcess::ResetNumberOfInteractionLengthLeft(), G4VProcess::SubtractNumberOfInteractionLengthLeft(), G4VProcess::theNumberOfInteractionLengthLeft, and G4VProcess::verboseLevel.

◆ PostStepGPIL()

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

inlineinherited

Definition at line 479 of file G4VProcess.hh.

{
  return thePILfactor *
      PostStepGetPhysicalInteractionLength(track, previousStepSize, condition);
}

References condition(), G4VProcess::PostStepGetPhysicalInteractionLength(), and G4VProcess::thePILfactor.

Referenced by G4SteppingManager::DefinePhysicalStepLength(), and G4ITStepProcessor::DoDefinePhysicalStepLength().

◆ PreparePhysicsTable()

void G4OpBoundaryProcess::PreparePhysicsTable ( const G4ParticleDefinition & )

overridevirtual

Reimplemented from G4VProcess.

Definition at line 132 of file G4OpBoundaryProcess.cc.

{
  Initialise();
}

References Initialise().

◆ PrepareWorkerPhysicsTable()

void G4VProcess::PrepareWorkerPhysicsTable ( const G4ParticleDefinition & part )

virtualinherited

Reimplemented in G4BiasingProcessInterface.

Definition at line 206 of file G4VProcess.cc.

{
  PreparePhysicsTable(part);
}

References G4VProcess::PreparePhysicsTable().

Referenced by G4BiasingProcessInterface::PrepareWorkerPhysicsTable().

◆ ProcessDescription()

void G4VProcess::ProcessDescription ( std::ostream & outfile ) const

virtualinherited

Reimplemented in G4AdjointAlongStepWeightCorrection, G4AdjointForcedInteractionForGamma, G4AdjointhMultipleScattering, G4ContinuousGainOfEnergy, G4eAdjointMultipleScattering, G4eInverseBremsstrahlung, G4eInverseCompton, G4eInverseIonisation, G4InversePEEffect, G4IonInverseIonisation, G4eeToHadrons, G4hBremsstrahlung, G4hhIonisation, G4hPairProduction, G4mplIonisation, G4RayleighScattering, G4ePairProduction, G4MuBremsstrahlung, G4MuIonisation, G4MuMultipleScattering, G4MuPairProduction, G4PolarizedAnnihilation, G4PolarizedBremsstrahlung, G4PolarizedCompton, G4PolarizedGammaConversion, G4PolarizedIonisation, G4PolarizedPhotoElectric, G4ComptonScattering, G4CoulombScattering, G4eBremsstrahlung, G4eIonisation, G4eMultipleScattering, G4eplusAnnihilation, G4GammaConversion, G4hIonisation, G4hMultipleScattering, G4ionIonisation, G4NuclearStopping, G4PhotoElectricEffect, G4ForwardXrayTR, G4GammaXTRadiator, G4GaussXTRadiator, G4RegularXTRadiator, G4Scintillation, G4StrawTubeXTRadiator, G4SynchrotronRadiation, G4TransitionRadiation, G4TransparentRegXTRadiator, G4VTransitionRadiation, G4VXTRenergyLoss, G4XTRGammaRadModel, G4XTRRegularRadModel, G4XTRTransparentRegRadModel, G4Cerenkov, G4Radioactivation, G4RadioactiveDecay, G4ElectronNuclearProcess, G4MuonNuclearProcess, G4NeutrinoElectronProcess, G4NeutronFissionProcess, G4PositronNuclearProcess, G4HadronicAbsorptionBertini, G4HadronicAbsorptionFritiof, G4HadronicAbsorptionFritiofWithBinaryCascade, G4HadronStoppingProcess, G4MuonicAtomDecay, G4MuonMinusAtomicCapture, G4MuonMinusCapture, G4Transportation, G4NeutronCaptureProcess, G4GammaGeneralProcess, G4Decay, G4DecayWithSpin, G4PionDecayMakeSpin, G4UnknownDecay, G4VEmProcess, G4VEnergyLossProcess, G4VMultipleScattering, G4HadronicProcess, G4ElNeutrinoNucleusProcess, G4HadronElasticProcess, and G4MuNeutrinoNucleusProcess.

Definition at line 175 of file G4VProcess.cc.

{
  outFile << "This process has not yet been described\n";
}

Referenced by G4LossTableManager::DumpHtml(), G4HadronicProcessStore::PrintHtml(), and G4GammaGeneralProcess::ProcessDescription().

◆ ResetNumberOfInteractionLengthLeft()

void G4VProcess::ResetNumberOfInteractionLengthLeft ( )

virtualinherited

Reimplemented in G4BiasingProcessInterface, G4VITProcess, G4WrapperProcess, and G4AdjointProcessEquivalentToDirectProcess.

Definition at line 80 of file G4VProcess.cc.

{
  theNumberOfInteractionLengthLeft =  -1.*G4Log( G4UniformRand() );
  theInitialNumberOfInteractionLength = theNumberOfInteractionLengthLeft; 
}

References G4Log(), G4UniformRand, G4VProcess::theInitialNumberOfInteractionLength, and G4VProcess::theNumberOfInteractionLengthLeft.

◆ RetrievePhysicsTable()

virtual G4bool G4VProcess::RetrievePhysicsTable	(	const G4ParticleDefinition *	,
		const G4String &	,
		G4bool
	)

inlinevirtualinherited

Reimplemented in G4GammaGeneralProcess, G4VEmProcess, G4VEnergyLossProcess, G4VMultipleScattering, G4WrapperProcess, G4AdjointProcessEquivalentToDirectProcess, and G4BiasingProcessInterface.

Definition at line 211 of file G4VProcess.hh.

212 { return false; }

Referenced by export_G4VProcess(), G4WrapperProcess::RetrievePhysicsTable(), G4AdjointProcessEquivalentToDirectProcess::RetrievePhysicsTable(), and G4BiasingProcessInterface::RetrievePhysicsTable().

◆ SetInvokeSD()

void G4OpBoundaryProcess::SetInvokeSD ( G4bool flag )

inlinevirtual

Definition at line 1464 of file G4OpBoundaryProcess.cc.

{
  fInvokeSD = flag;
  G4OpticalParameters::Instance()->SetBoundaryInvokeSD(fInvokeSD);
}

References fInvokeSD, G4OpticalParameters::Instance(), and G4OpticalParameters::SetBoundaryInvokeSD().

Referenced by Initialise().

◆ SetMasterProcess()

void G4VProcess::SetMasterProcess ( G4VProcess * masterP )

virtualinherited

Reimplemented in G4BiasingProcessInterface, and G4WrapperProcess.

Definition at line 212 of file G4VProcess.cc.

{
  masterProcessShadow = masterP;
}

References G4VProcess::masterProcessShadow.

Referenced by G4BiasingProcessInterface::SetMasterProcess(), and G4WrapperProcess::SetMasterProcess().

◆ SetPILfactor()

void G4VProcess::SetPILfactor ( G4double value )

inlineinherited

Definition at line 449 of file G4VProcess.hh.

{
  if (value>0.) { thePILfactor = value; }
}

References G4VProcess::thePILfactor.

Referenced by export_G4VProcess().

◆ SetProcessManager()

void G4VProcess::SetProcessManager ( const G4ProcessManager * procMan )

inlinevirtualinherited

Reimplemented in G4BiasingProcessInterface, G4ParallelGeometriesLimiterProcess, and G4WrapperProcess.

Definition at line 488 of file G4VProcess.hh.

{
  aProcessManager = procMan; 
}

References G4VProcess::aProcessManager.

Referenced by G4ProcessManager::AddProcess(), G4BiasingProcessInterface::SetProcessManager(), and G4WrapperProcess::SetProcessManager().

◆ SetProcessSubType()

void G4VProcess::SetProcessSubType ( G4int value )

inlineinherited

Definition at line 406 of file G4VProcess.hh.

{
  theProcessSubType = value;
}

References G4VProcess::theProcessSubType.

Referenced by G4DNAElectronHoleRecombination::Create(), G4DNASecondOrderReaction::Create(), G4AnnihiToMuPair::G4AnnihiToMuPair(), G4BiasingProcessInterface::G4BiasingProcessInterface(), G4Cerenkov::G4Cerenkov(), G4ComptonScattering::G4ComptonScattering(), G4CoulombScattering::G4CoulombScattering(), G4CoupledTransportation::G4CoupledTransportation(), G4Decay::G4Decay(), G4DecayWithSpin::G4DecayWithSpin(), G4DNAAttachment::G4DNAAttachment(), G4DNABrownianTransportation::G4DNABrownianTransportation(), G4DNAChargeDecrease::G4DNAChargeDecrease(), G4DNAChargeIncrease::G4DNAChargeIncrease(), G4DNAElastic::G4DNAElastic(), G4DNAElectronSolvation::G4DNAElectronSolvation(), G4DNAExcitation::G4DNAExcitation(), G4DNAIonisation::G4DNAIonisation(), G4DNAMolecularDissociation::G4DNAMolecularDissociation(), G4DNAScavengerProcess::G4DNAScavengerProcess(), G4DNAVibExcitation::G4DNAVibExcitation(), G4eBremsstrahlung::G4eBremsstrahlung(), G4eeToHadrons::G4eeToHadrons(), G4eIonisation::G4eIonisation(), G4ePairProduction::G4ePairProduction(), G4eplusAnnihilation::G4eplusAnnihilation(), G4FastSimulationManagerProcess::G4FastSimulationManagerProcess(), G4GammaConversion::G4GammaConversion(), G4GammaConversionToMuons::G4GammaConversionToMuons(), G4GammaGeneralProcess::G4GammaGeneralProcess(), G4HadronicProcess::G4HadronicProcess(), G4hhIonisation::G4hhIonisation(), G4hIonisation::G4hIonisation(), G4ionIonisation::G4ionIonisation(), G4ITTransportation::G4ITTransportation(), G4JAEAElasticScattering::G4JAEAElasticScattering(), G4MicroElecElastic::G4MicroElecElastic(), G4MicroElecInelastic::G4MicroElecInelastic(), G4MicroElecLOPhononScattering::G4MicroElecLOPhononScattering(), G4MicroElecSurface::G4MicroElecSurface(), G4mplIonisation::G4mplIonisation(), G4MuBremsstrahlung::G4MuBremsstrahlung(), G4MuIonisation::G4MuIonisation(), G4MuonMinusAtomicCapture::G4MuonMinusAtomicCapture(), G4MuPairProduction::G4MuPairProduction(), G4NeutronKiller::G4NeutronKiller(), G4NuclearStopping::G4NuclearStopping(), G4OpAbsorption::G4OpAbsorption(), G4OpBoundaryProcess(), G4OpMieHG::G4OpMieHG(), G4OpRayleigh::G4OpRayleigh(), G4OpWLS::G4OpWLS(), G4OpWLS2::G4OpWLS2(), G4ParallelWorldProcess::G4ParallelWorldProcess(), G4PhotoElectricEffect::G4PhotoElectricEffect(), G4PionDecayMakeSpin::G4PionDecayMakeSpin(), G4PolarizedCompton::G4PolarizedCompton(), G4PolarizedGammaConversion::G4PolarizedGammaConversion(), G4PolarizedIonisation::G4PolarizedIonisation(), G4PolarizedPhotoElectric::G4PolarizedPhotoElectric(), G4RadioactiveDecay::G4RadioactiveDecay(), G4RayleighScattering::G4RayleighScattering(), G4Scintillation::G4Scintillation(), G4StepLimiter::G4StepLimiter(), G4SynchrotronRadiation::G4SynchrotronRadiation(), G4SynchrotronRadiationInMat::G4SynchrotronRadiationInMat(), G4TransitionRadiation::G4TransitionRadiation(), G4Transportation::G4Transportation(), G4UCNAbsorption::G4UCNAbsorption(), G4UCNBoundaryProcess::G4UCNBoundaryProcess(), G4UCNLoss::G4UCNLoss(), G4UCNMultiScattering::G4UCNMultiScattering(), G4UnknownDecay::G4UnknownDecay(), G4UserSpecialCuts::G4UserSpecialCuts(), G4VMultipleScattering::G4VMultipleScattering(), G4VTransitionRadiation::G4VTransitionRadiation(), G4VXTRenergyLoss::G4VXTRenergyLoss(), and G4Decay::SetExtDecayer().

◆ SetProcessType()

void G4VProcess::SetProcessType ( G4ProcessType aType )

inlineinherited

Definition at line 394 of file G4VProcess.hh.

{
  theProcessType = aType;
}

References G4VProcess::theProcessType.

Referenced by G4MaxTimeCuts::G4MaxTimeCuts(), and G4MinEkineCuts::G4MinEkineCuts().

◆ SetVerboseLevel()

void G4OpBoundaryProcess::SetVerboseLevel ( G4int verbose )

Definition at line 1471 of file G4OpBoundaryProcess.cc.

{
  verboseLevel = verbose;
  G4OpticalParameters::Instance()->SetBoundaryVerboseLevel(verboseLevel);
}

References G4OpticalParameters::Instance(), G4OpticalParameters::SetBoundaryVerboseLevel(), and G4VProcess::verboseLevel.

Referenced by LBE::ConstructOp(), and Initialise().

◆ StartTracking()

void G4VProcess::StartTracking ( G4Track * )

virtualinherited

Reimplemented in G4ParallelGeometriesLimiterProcess, G4ImportanceProcess, G4WeightCutOffProcess, G4WeightWindowProcess, G4VITProcess, G4DNASecondOrderReaction, G4WrapperProcess, G4FastSimulationManagerProcess, G4ParallelWorldProcess, G4ParallelWorldScoringProcess, G4ScoreSplittingProcess, G4GammaGeneralProcess, G4Decay, G4AdjointProcessEquivalentToDirectProcess, G4eAdjointMultipleScattering, G4DNAElectronHoleRecombination, G4DNAScavengerProcess, G4VEmProcess, G4VEnergyLossProcess, G4VMultipleScattering, G4ITTransportation, G4DNABrownianTransportation, G4CoupledTransportation, G4Transportation, G4BiasingProcessInterface, and G4VPhononProcess.

Definition at line 87 of file G4VProcess.cc.

{
  currentInteractionLength = -1.0;
  theNumberOfInteractionLengthLeft = -1.0;
  theInitialNumberOfInteractionLength = -1.0;
#ifdef G4VERBOSE
  if (verboseLevel>2)
  {
    G4cout << "G4VProcess::StartTracking() - [" << theProcessName << "]"
           << G4endl;
  }
#endif
}

References G4VProcess::currentInteractionLength, G4cout, G4endl, G4VProcess::theInitialNumberOfInteractionLength, G4VProcess::theNumberOfInteractionLengthLeft, G4VProcess::theProcessName, and G4VProcess::verboseLevel.

Referenced by G4DNASecondOrderReaction::StartTracking(), G4WrapperProcess::StartTracking(), G4AdjointProcessEquivalentToDirectProcess::StartTracking(), G4DNAElectronHoleRecombination::StartTracking(), G4DNAScavengerProcess::StartTracking(), G4ITTransportation::StartTracking(), G4Transportation::StartTracking(), G4BiasingProcessInterface::StartTracking(), and G4VPhononProcess::StartTracking().

◆ StorePhysicsTable()

virtual G4bool G4VProcess::StorePhysicsTable	(	const G4ParticleDefinition *	,
		const G4String &	,
		G4bool
	)

inlinevirtualinherited

Reimplemented in G4WrapperProcess, G4GammaGeneralProcess, G4AdjointProcessEquivalentToDirectProcess, G4VEmProcess, G4VEnergyLossProcess, G4VMultipleScattering, and G4BiasingProcessInterface.

Definition at line 206 of file G4VProcess.hh.

207 { return true; }

Referenced by export_G4VProcess(), G4WrapperProcess::StorePhysicsTable(), G4AdjointProcessEquivalentToDirectProcess::StorePhysicsTable(), and G4BiasingProcessInterface::StorePhysicsTable().

◆ SubtractNumberOfInteractionLengthLeft()

void G4VProcess::SubtractNumberOfInteractionLengthLeft ( G4double prevStepSize )

inlineprotectedinherited

Definition at line 524 of file G4VProcess.hh.

{
  if (currentInteractionLength>0.0)
  {
    theNumberOfInteractionLengthLeft -= prevStepSize/currentInteractionLength;
    if(theNumberOfInteractionLengthLeft<0.)
    {
       theNumberOfInteractionLengthLeft=CLHEP::perMillion;
    }
  }
  else
  {
#ifdef G4VERBOSE
    if (verboseLevel>0)
    {
      G4cerr << "G4VProcess::SubtractNumberOfInteractionLengthLeft()";
      G4cerr << " [" << theProcessName << "]" <<G4endl;
      G4cerr << " currentInteractionLength = "
             << currentInteractionLength << " [mm]";
      G4cerr << " previousStepSize = " << prevStepSize << " [mm]";
      G4cerr << G4endl;
    }
#endif
    G4String msg = "Negative currentInteractionLength for ";
    msg += theProcessName;
    G4Exception("G4VProcess::SubtractNumberOfInteractionLengthLeft()",
                "ProcMan201", EventMustBeAborted, msg);
  }
}

References G4VProcess::currentInteractionLength, EventMustBeAborted, G4cerr, G4endl, G4Exception(), CLHEP::perMillion, G4VProcess::theNumberOfInteractionLengthLeft, G4VProcess::theProcessName, and G4VProcess::verboseLevel.

Referenced by G4VContinuousDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VRestContinuousDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VRestDiscreteProcess::PostStepGetPhysicalInteractionLength(), and G4Decay::PostStepGetPhysicalInteractionLength().

Field Documentation

◆ aParticleChange

G4ParticleChange G4VProcess::aParticleChange

protectedinherited

Definition at line 327 of file G4VProcess.hh.

◆ aProcessManager

const G4ProcessManager* G4VProcess::aProcessManager = nullptr

protectedinherited

Definition at line 319 of file G4VProcess.hh.

Referenced by G4VProcess::GetProcessManager(), and G4VProcess::SetProcessManager().

◆ currentInteractionLength

G4double G4VProcess::currentInteractionLength = -1.0

protectedinherited

Definition at line 335 of file G4VProcess.hh.

◆ enableAlongStepDoIt

G4bool G4VProcess::enableAlongStepDoIt = true

protectedinherited

Definition at line 360 of file G4VProcess.hh.

Referenced by G4DNAElectronHoleRecombination::Create(), G4DNASecondOrderReaction::Create(), G4DNAMolecularDissociation::G4DNAMolecularDissociation(), G4DNAScavengerProcess::G4DNAScavengerProcess(), G4ITTransportation::G4ITTransportation(), G4NuclearStopping::G4NuclearStopping(), G4VDiscreteProcess::G4VDiscreteProcess(), G4VITDiscreteProcess::G4VITDiscreteProcess(), G4VITRestDiscreteProcess::G4VITRestDiscreteProcess(), G4VITRestProcess::G4VITRestProcess(), G4VRestDiscreteProcess::G4VRestDiscreteProcess(), G4VRestProcess::G4VRestProcess(), and G4VProcess::isAlongStepDoItIsEnabled().

◆ enableAtRestDoIt

G4bool G4VProcess::enableAtRestDoIt = true

protectedinherited

Definition at line 359 of file G4VProcess.hh.

Referenced by G4DNAElectronHoleRecombination::Create(), G4DNASecondOrderReaction::Create(), G4DNAMolecularDissociation::G4DNAMolecularDissociation(), G4DNAScavengerProcess::G4DNAScavengerProcess(), G4eplusAnnihilation::G4eplusAnnihilation(), G4HadronStoppingProcess::G4HadronStoppingProcess(), G4ITTransportation::G4ITTransportation(), G4MuonicAtomDecay::G4MuonicAtomDecay(), G4VContinuousDiscreteProcess::G4VContinuousDiscreteProcess(), G4VContinuousProcess::G4VContinuousProcess(), G4VDiscreteProcess::G4VDiscreteProcess(), G4VITDiscreteProcess::G4VITDiscreteProcess(), and G4VProcess::isAtRestDoItIsEnabled().

◆ enablePostStepDoIt

G4bool G4VProcess::enablePostStepDoIt = true

protectedinherited

Definition at line 361 of file G4VProcess.hh.

Referenced by G4DNAElectronHoleRecombination::Create(), G4DNASecondOrderReaction::Create(), G4DNAMolecularDissociation::G4DNAMolecularDissociation(), G4DNAScavengerProcess::G4DNAScavengerProcess(), G4HadronStoppingProcess::G4HadronStoppingProcess(), G4ITTransportation::G4ITTransportation(), G4MuonicAtomDecay::G4MuonicAtomDecay(), G4NuclearStopping::G4NuclearStopping(), G4VContinuousProcess::G4VContinuousProcess(), G4VITRestProcess::G4VITRestProcess(), G4VRestContinuousProcess::G4VRestContinuousProcess(), G4VRestProcess::G4VRestProcess(), and G4VProcess::isPostStepDoItIsEnabled().

◆ f_iTE

G4int G4OpBoundaryProcess::f_iTE

private

Definition at line 221 of file G4OpBoundaryProcess.hh.

Referenced by DielectricMetal(), G4OpBoundaryProcess(), GetReflectivity(), and PostStepDoIt().

◆ f_iTM

G4int G4OpBoundaryProcess::f_iTM

private

Definition at line 221 of file G4OpBoundaryProcess.hh.

Referenced by DielectricMetal(), G4OpBoundaryProcess(), GetReflectivity(), and PostStepDoIt().

◆ fCarTolerance

G4double G4OpBoundaryProcess::fCarTolerance

private

Definition at line 215 of file G4OpBoundaryProcess.hh.

Referenced by CalculateReflectivity(), DielectricDielectric(), DielectricLUT(), G4OpBoundaryProcess(), and PostStepDoIt().

◆ fDichroicVector

G4Physics2DVector* G4OpBoundaryProcess::fDichroicVector

private

Definition at line 201 of file G4OpBoundaryProcess.hh.

Referenced by DielectricDichroic(), and G4OpBoundaryProcess().

◆ fEfficiency

G4double G4OpBoundaryProcess::fEfficiency

private

Definition at line 210 of file G4OpBoundaryProcess.hh.

Referenced by DielectricLUTDAVIS(), DoAbsorption(), G4OpBoundaryProcess(), and PostStepDoIt().

◆ fFacetNormal

G4ThreeVector G4OpBoundaryProcess::fFacetNormal

private

Definition at line 192 of file G4OpBoundaryProcess.hh.

Referenced by CalculateReflectivity(), ChooseReflection(), DielectricDichroic(), DielectricDielectric(), DielectricLUT(), DielectricLUTDAVIS(), DielectricMetal(), DoReflection(), and GetIncidentAngle().

◆ fFinish

G4OpticalSurfaceFinish G4OpBoundaryProcess::fFinish

private

Definition at line 219 of file G4OpBoundaryProcess.hh.

Referenced by CalculateReflectivity(), DielectricDichroic(), DielectricDielectric(), DielectricLUT(), DielectricMetal(), DoReflection(), G4OpBoundaryProcess(), and PostStepDoIt().

◆ fGlobalNormal

G4ThreeVector G4OpBoundaryProcess::fGlobalNormal

private

Definition at line 191 of file G4OpBoundaryProcess.hh.

Referenced by CalculateReflectivity(), ChooseReflection(), DielectricDichroic(), DielectricDielectric(), DielectricLUT(), DielectricLUTDAVIS(), DielectricMetal(), DoReflection(), and PostStepDoIt().

◆ fImagRIndexMPV

G4MaterialPropertyVector* G4OpBoundaryProcess::fImagRIndexMPV

private

Definition at line 200 of file G4OpBoundaryProcess.hh.

Referenced by CalculateReflectivity(), DielectricMetal(), DoReflection(), G4OpBoundaryProcess(), and PostStepDoIt().

◆ fInvokeSD

G4bool G4OpBoundaryProcess::fInvokeSD

private

Definition at line 238 of file G4OpBoundaryProcess.hh.

Referenced by PostStepDoIt(), and SetInvokeSD().

◆ fMaterial1

G4Material* G4OpBoundaryProcess::fMaterial1

private

Definition at line 194 of file G4OpBoundaryProcess.hh.

Referenced by DielectricDielectric(), G4OpBoundaryProcess(), GetReflectivity(), and PostStepDoIt().

◆ fMaterial2

G4Material* G4OpBoundaryProcess::fMaterial2

private

Definition at line 195 of file G4OpBoundaryProcess.hh.

Referenced by DielectricDielectric(), G4OpBoundaryProcess(), and PostStepDoIt().

◆ fModel

G4OpticalSurfaceModel G4OpBoundaryProcess::fModel

private

Definition at line 218 of file G4OpBoundaryProcess.hh.

Referenced by DielectricDichroic(), DielectricDielectric(), DielectricMetal(), G4OpBoundaryProcess(), GetFacetNormal(), and PostStepDoIt().

◆ fNewMomentum

G4ThreeVector G4OpBoundaryProcess::fNewMomentum

private

Definition at line 188 of file G4OpBoundaryProcess.hh.

Referenced by DielectricDichroic(), DielectricDielectric(), DielectricLUT(), DielectricLUTDAVIS(), DielectricMetal(), DoAbsorption(), DoReflection(), and PostStepDoIt().

◆ fNewPolarization

G4ThreeVector G4OpBoundaryProcess::fNewPolarization

private

Definition at line 189 of file G4OpBoundaryProcess.hh.

Referenced by DielectricDichroic(), DielectricDielectric(), DielectricLUT(), DielectricLUTDAVIS(), DielectricMetal(), DoAbsorption(), DoReflection(), and PostStepDoIt().

◆ fOldMomentum

G4ThreeVector G4OpBoundaryProcess::fOldMomentum

private

Definition at line 185 of file G4OpBoundaryProcess.hh.

Referenced by CalculateReflectivity(), DielectricDichroic(), DielectricDielectric(), DielectricLUT(), DielectricLUTDAVIS(), DielectricMetal(), DoAbsorption(), DoReflection(), GetIncidentAngle(), and PostStepDoIt().

◆ fOldPolarization

G4ThreeVector G4OpBoundaryProcess::fOldPolarization

private

Definition at line 186 of file G4OpBoundaryProcess.hh.

Referenced by CalculateReflectivity(), DielectricDichroic(), DielectricDielectric(), DielectricLUT(), DielectricLUTDAVIS(), DielectricMetal(), DoAbsorption(), DoReflection(), and PostStepDoIt().

◆ fOpticalSurface

G4OpticalSurface* G4OpBoundaryProcess::fOpticalSurface

private

Definition at line 197 of file G4OpBoundaryProcess.hh.

Referenced by DielectricDichroic(), DielectricLUT(), DielectricLUTDAVIS(), G4OpBoundaryProcess(), GetFacetNormal(), and PostStepDoIt().

◆ fPhotonMomentum

G4double G4OpBoundaryProcess::fPhotonMomentum

private

Definition at line 203 of file G4OpBoundaryProcess.hh.

Referenced by CalculateReflectivity(), DielectricDichroic(), DielectricDielectric(), DoAbsorption(), G4OpBoundaryProcess(), GetReflectivity(), InvokeSD(), and PostStepDoIt().

◆ fProb_bs

G4double G4OpBoundaryProcess::fProb_bs

private

Definition at line 214 of file G4OpBoundaryProcess.hh.

Referenced by ChooseReflection(), G4OpBoundaryProcess(), and PostStepDoIt().

◆ fProb_sl

G4double G4OpBoundaryProcess::fProb_sl

private

Definition at line 214 of file G4OpBoundaryProcess.hh.

Referenced by ChooseReflection(), G4OpBoundaryProcess(), and PostStepDoIt().

◆ fProb_ss

G4double G4OpBoundaryProcess::fProb_ss

private

Definition at line 214 of file G4OpBoundaryProcess.hh.

Referenced by ChooseReflection(), G4OpBoundaryProcess(), and PostStepDoIt().

◆ fProcessTable

G4ProcessTable* G4VProcess::fProcessTable = nullptr

privateinherited

Definition at line 374 of file G4VProcess.hh.

Referenced by G4VProcess::G4VProcess(), and G4VProcess::~G4VProcess().

◆ fRealRIndexMPV

G4MaterialPropertyVector* G4OpBoundaryProcess::fRealRIndexMPV

private

Definition at line 199 of file G4OpBoundaryProcess.hh.

Referenced by CalculateReflectivity(), DielectricMetal(), DoReflection(), G4OpBoundaryProcess(), and PostStepDoIt().

◆ fReflectivity

G4double G4OpBoundaryProcess::fReflectivity

private

Definition at line 209 of file G4OpBoundaryProcess.hh.

Referenced by CalculateReflectivity(), DielectricDielectric(), DielectricLUT(), DielectricMetal(), G4OpBoundaryProcess(), and PostStepDoIt().

◆ fRindex1

G4double G4OpBoundaryProcess::fRindex1

private

Definition at line 204 of file G4OpBoundaryProcess.hh.

Referenced by DielectricDielectric(), G4OpBoundaryProcess(), GetReflectivity(), and PostStepDoIt().

◆ fRindex2

G4double G4OpBoundaryProcess::fRindex2

private

Definition at line 205 of file G4OpBoundaryProcess.hh.

Referenced by DielectricDielectric(), G4OpBoundaryProcess(), and PostStepDoIt().

◆ fSint1

G4double G4OpBoundaryProcess::fSint1

private

Definition at line 207 of file G4OpBoundaryProcess.hh.

Referenced by CalculateReflectivity(), DielectricDielectric(), DielectricMetal(), and G4OpBoundaryProcess().

◆ fStatus

G4OpBoundaryProcessStatus G4OpBoundaryProcess::fStatus

private

Definition at line 217 of file G4OpBoundaryProcess.hh.

Referenced by BoundaryProcessVerbose(), ChooseReflection(), DielectricDichroic(), DielectricDielectric(), DielectricLUT(), DielectricLUTDAVIS(), DielectricMetal(), DoAbsorption(), DoReflection(), G4OpBoundaryProcess(), GetStatus(), and PostStepDoIt().

◆ fSurfaceRoughness

G4double G4OpBoundaryProcess::fSurfaceRoughness

private

Definition at line 212 of file G4OpBoundaryProcess.hh.

Referenced by DielectricDielectric(), G4OpBoundaryProcess(), and PostStepDoIt().

◆ fTransmittance

G4double G4OpBoundaryProcess::fTransmittance

private

Definition at line 211 of file G4OpBoundaryProcess.hh.

Referenced by DielectricDichroic(), DielectricDielectric(), DielectricLUT(), DielectricMetal(), G4OpBoundaryProcess(), and PostStepDoIt().

◆ idx_back

size_t G4OpBoundaryProcess::idx_back = 0

private

Definition at line 232 of file G4OpBoundaryProcess.hh.

Referenced by PostStepDoIt().

◆ idx_dichroicX

size_t G4OpBoundaryProcess::idx_dichroicX = 0

private

Definition at line 223 of file G4OpBoundaryProcess.hh.

Referenced by DielectricDichroic().

◆ idx_dichroicY

size_t G4OpBoundaryProcess::idx_dichroicY = 0

private

Definition at line 224 of file G4OpBoundaryProcess.hh.

Referenced by DielectricDichroic().

◆ idx_eff

size_t G4OpBoundaryProcess::idx_eff = 0

private

Definition at line 228 of file G4OpBoundaryProcess.hh.

Referenced by PostStepDoIt().

◆ idx_groupvel

size_t G4OpBoundaryProcess::idx_groupvel = 0

private

Definition at line 234 of file G4OpBoundaryProcess.hh.

Referenced by PostStepDoIt().

◆ idx_irindex

size_t G4OpBoundaryProcess::idx_irindex = 0

private

Definition at line 236 of file G4OpBoundaryProcess.hh.

Referenced by CalculateReflectivity(), and GetReflectivity().

◆ idx_lobe

size_t G4OpBoundaryProcess::idx_lobe = 0

private

Definition at line 230 of file G4OpBoundaryProcess.hh.

Referenced by PostStepDoIt().

◆ idx_reflect

size_t G4OpBoundaryProcess::idx_reflect = 0

private

Definition at line 227 of file G4OpBoundaryProcess.hh.

Referenced by PostStepDoIt().

◆ idx_rindex1

size_t G4OpBoundaryProcess::idx_rindex1 = 0

private

Definition at line 225 of file G4OpBoundaryProcess.hh.

Referenced by PostStepDoIt().

◆ idx_rindex2

size_t G4OpBoundaryProcess::idx_rindex2 = 0

private

Definition at line 233 of file G4OpBoundaryProcess.hh.

Referenced by PostStepDoIt().

◆ idx_rindex_surface

size_t G4OpBoundaryProcess::idx_rindex_surface = 0

private

Definition at line 226 of file G4OpBoundaryProcess.hh.

Referenced by PostStepDoIt().

◆ idx_rrindex

size_t G4OpBoundaryProcess::idx_rrindex = 0

private

Definition at line 235 of file G4OpBoundaryProcess.hh.

Referenced by CalculateReflectivity(), and GetReflectivity().

◆ idx_spike

size_t G4OpBoundaryProcess::idx_spike = 0

private

Definition at line 231 of file G4OpBoundaryProcess.hh.

Referenced by PostStepDoIt().

◆ idx_trans

size_t G4OpBoundaryProcess::idx_trans = 0

private

Definition at line 229 of file G4OpBoundaryProcess.hh.

Referenced by PostStepDoIt().

◆ masterProcessShadow

G4VProcess* G4VProcess::masterProcessShadow = nullptr

privateinherited

Definition at line 370 of file G4VProcess.hh.

Referenced by G4VProcess::GetMasterProcess(), and G4VProcess::SetMasterProcess().

◆ pParticleChange

G4VParticleChange* G4VProcess::pParticleChange = nullptr

protectedinherited

Definition at line 321 of file G4VProcess.hh.

◆ theInitialNumberOfInteractionLength

G4double G4VProcess::theInitialNumberOfInteractionLength = -1.0

protectedinherited

Definition at line 338 of file G4VProcess.hh.

Referenced by G4VProcess::ClearNumberOfInteractionLengthLeft(), G4VProcess::EndTracking(), G4VProcess::GetTotalNumberOfInteractionLengthTraversed(), G4GammaGeneralProcess::PostStepGetPhysicalInteractionLength(), G4AdjointForcedInteractionForGamma::PostStepGetPhysicalInteractionLength(), G4VEmProcess::PostStepGetPhysicalInteractionLength(), G4VEnergyLossProcess::PostStepGetPhysicalInteractionLength(), G4VProcess::ResetNumberOfInteractionLengthLeft(), and G4VProcess::StartTracking().

◆ theNumberOfInteractionLengthLeft

G4double G4VProcess::theNumberOfInteractionLengthLeft = -1.0

protectedinherited

Definition at line 331 of file G4VProcess.hh.

◆ thePhysicsTableFileName

G4String G4VProcess::thePhysicsTableFileName

protectedinherited

Definition at line 344 of file G4VProcess.hh.

Referenced by G4VProcess::GetPhysicsTableFileName().

◆ thePILfactor

G4double G4VProcess::thePILfactor = 1.0

protectedinherited

Definition at line 352 of file G4VProcess.hh.

Referenced by G4VProcess::AtRestGPIL(), G4VProcess::GetPILfactor(), G4VProcess::PostStepGPIL(), and G4VProcess::SetPILfactor().

◆ theProcessName

G4String G4VProcess::theProcessName

protectedinherited

Definition at line 341 of file G4VProcess.hh.

Referenced by G4VProcess::DumpInfo(), G4VProcess::EndTracking(), G4ImportanceProcess::GetName(), G4WeightCutOffProcess::GetName(), G4VProcess::GetPhysicsTableFileName(), G4VProcess::GetProcessName(), G4WrapperProcess::RegisterProcess(), G4VProcess::StartTracking(), G4VITProcess::SubtractNumberOfInteractionLengthLeft(), and G4VProcess::SubtractNumberOfInteractionLengthLeft().

◆ theProcessSubType

G4int G4VProcess::theProcessSubType = -1

protectedinherited

Definition at line 349 of file G4VProcess.hh.

Referenced by G4VProcess::DumpInfo(), G4MuonicAtomDecay::G4MuonicAtomDecay(), G4VProcess::GetProcessSubType(), and G4VProcess::SetProcessSubType().

◆ theProcessType

G4ProcessType G4VProcess::theProcessType = fNotDefined

protectedinherited

Definition at line 346 of file G4VProcess.hh.

Referenced by G4VProcess::DumpInfo(), G4AdjointProcessEquivalentToDirectProcess::G4AdjointProcessEquivalentToDirectProcess(), G4VProcess::GetProcessType(), G4WrapperProcess::RegisterProcess(), and G4VProcess::SetProcessType().

◆ verboseLevel

G4int G4VProcess::verboseLevel = 0

protectedinherited

Definition at line 356 of file G4VProcess.hh.

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

source/processes/optical/include/G4OpBoundaryProcess.hh
source/processes/optical/src/G4OpBoundaryProcess.cc

Public Member Functions

Static Public Member Functions

Protected Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ G4OpBoundaryProcess() [1/2]

◆ ~G4OpBoundaryProcess()

◆ G4OpBoundaryProcess() [2/2]

Member Function Documentation

◆ AlongStepDoIt()

◆ AlongStepGetPhysicalInteractionLength()

◆ AlongStepGPIL()

◆ AtRestDoIt()

◆ AtRestGetPhysicalInteractionLength()

◆ AtRestGPIL()

◆ BoundaryProcessVerbose()

◆ BuildPhysicsTable()

◆ BuildWorkerPhysicsTable()

◆ CalculateReflectivity()

◆ ChooseReflection()

◆ ClearNumberOfInteractionLengthLeft()

◆ DielectricDichroic()

◆ DielectricDielectric()

◆ DielectricLUT()

◆ DielectricLUTDAVIS()

◆ DielectricMetal()

◆ DoAbsorption()

◆ DoReflection()

◆ DumpInfo()

◆ EndTracking()

◆ G4BooleanRand()

◆ GetCurrentInteractionLength()

◆ GetFacetNormal()

◆ GetIncidentAngle()

◆ GetMasterProcess()

◆ GetMeanFreePath()

◆ GetNumberOfInteractionLengthLeft()

◆ GetPhysicsTableFileName()

◆ GetPILfactor()

◆ GetProcessManager()

◆ GetProcessName()

◆ GetProcessSubType()

◆ GetProcessType()

◆ GetProcessTypeName()

◆ GetReflectivity()

◆ GetStatus()

◆ GetTotalNumberOfInteractionLengthTraversed()

◆ GetVerboseLevel()

◆ Initialise()

◆ InvokeSD()

◆ isAlongStepDoItIsEnabled()

◆ IsApplicable()

◆ isAtRestDoItIsEnabled()

◆ isPostStepDoItIsEnabled()

◆ operator!=()

◆ operator=()

◆ operator==()

◆ PostStepDoIt()

◆ PostStepGetPhysicalInteractionLength()

◆ PostStepGPIL()

◆ PreparePhysicsTable()

◆ PrepareWorkerPhysicsTable()

◆ ProcessDescription()

◆ ResetNumberOfInteractionLengthLeft()

◆ RetrievePhysicsTable()

◆ SetInvokeSD()

◆ SetMasterProcess()

◆ SetPILfactor()

◆ SetProcessManager()

◆ SetProcessSubType()

◆ SetProcessType()

◆ SetVerboseLevel()

◆ StartTracking()

◆ StorePhysicsTable()

◆ SubtractNumberOfInteractionLengthLeft()

Field Documentation

◆ aParticleChange