#include <G4OpBoundaryProcess.hh>

Inheritance diagram for G4OpBoundaryProcess:

Collaboration diagram for G4OpBoundaryProcess:

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

	~G4OpBoundaryProcess ()

G4bool	IsApplicable (const G4ParticleDefinition &aParticleType)

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

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

G4OpBoundaryProcessStatus	GetStatus () const

Public Member Functions inherited from G4VDiscreteProcess
	G4VDiscreteProcess (const G4String &, G4ProcessType aType=fNotDefined)

	G4VDiscreteProcess (G4VDiscreteProcess &)

virtual	~G4VDiscreteProcess ()

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

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

virtual G4double	AtRestGetPhysicalInteractionLength (const G4Track &, G4ForceCondition *)

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

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

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

	G4VProcess (const G4VProcess &right)

virtual	~G4VProcess ()

G4int	operator== (const G4VProcess &right) const

G4int	operator!= (const G4VProcess &right) const

G4double	GetCurrentInteractionLength () const

void	SetPILfactor (G4double value)

G4double	GetPILfactor () const

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

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

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

virtual void	BuildPhysicsTable (const G4ParticleDefinition &)

virtual void	PreparePhysicsTable (const G4ParticleDefinition &)

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

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

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

const G4String &	GetProcessName () const

G4ProcessType	GetProcessType () const

void	SetProcessType (G4ProcessType)

G4int	GetProcessSubType () const

void	SetProcessSubType (G4int)

virtual void	StartTracking (G4Track *)

virtual void	EndTracking ()

virtual void	SetProcessManager (const G4ProcessManager *)

virtual const G4ProcessManager *	GetProcessManager ()

virtual void	ResetNumberOfInteractionLengthLeft ()

G4double	GetNumberOfInteractionLengthLeft () const

G4double	GetTotalNumberOfInteractionLengthTraversed () const

G4bool	isAtRestDoItIsEnabled () const

G4bool	isAlongStepDoItIsEnabled () const

G4bool	isPostStepDoItIsEnabled () const

virtual void	DumpInfo () const

void	SetVerboseLevel (G4int value)

G4int	GetVerboseLevel () const

virtual void	SetMasterProcess (G4VProcess *masterP)

const G4VProcess *	GetMasterProcess () const

virtual void	BuildWorkerPhysicsTable (const G4ParticleDefinition &part)

virtual void	PrepareWorkerPhysicsTable (const G4ParticleDefinition &)

Private Member Functions
	G4OpBoundaryProcess (const G4OpBoundaryProcess &right)

G4OpBoundaryProcess &	operator= (const G4OpBoundaryProcess &right)

G4bool	G4BooleanRand (const G4double prob) const

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

void	DielectricMetal ()

void	DielectricDielectric ()

void	DielectricLUT ()

void	DielectricDichroic ()

void	ChooseReflection ()

void	DoAbsorption ()

void	DoReflection ()

G4double	GetIncidentAngle ()

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

void	CalculateReflectivity (void)

void	BoundaryProcessVerbose (void) const

G4bool	InvokeSD (const G4Step *step)

Private Attributes
G4double	thePhotonMomentum

G4ThreeVector	OldMomentum

G4ThreeVector	OldPolarization

G4ThreeVector	NewMomentum

G4ThreeVector	NewPolarization

G4ThreeVector	theGlobalNormal

G4ThreeVector	theFacetNormal

G4Material *	Material1

G4Material *	Material2

G4OpticalSurface *	OpticalSurface

G4MaterialPropertyVector *	PropertyPointer

G4MaterialPropertyVector *	PropertyPointer1

G4MaterialPropertyVector *	PropertyPointer2

G4double	Rindex1

G4double	Rindex2

G4double	cost1

G4double	cost2

G4double	sint1

G4double	sint2

G4OpBoundaryProcessStatus	theStatus

G4OpticalSurfaceModel	theModel

G4OpticalSurfaceFinish	theFinish

G4double	theReflectivity

G4double	theEfficiency

G4double	theTransmittance

G4double	theSurfaceRoughness

G4double	prob_sl

G4double	prob_ss

G4double	prob_bs

G4int	iTE

G4int	iTM

G4double	kCarTolerance

size_t	idx

size_t	idy

G4Physics2DVector *	DichroicVector

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

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

void	ClearNumberOfInteractionLengthLeft ()

Protected Attributes inherited from G4VProcess
const G4ProcessManager *	aProcessManager

G4VParticleChange *	pParticleChange

G4ParticleChange	aParticleChange

G4double	theNumberOfInteractionLengthLeft

G4double	currentInteractionLength

G4double	theInitialNumberOfInteractionLength

G4String	theProcessName

G4String	thePhysicsTableFileName

G4ProcessType	theProcessType

G4int	theProcessSubType

G4double	thePILfactor

G4bool	enableAtRestDoIt

G4bool	enableAlongStepDoIt

G4bool	enablePostStepDoIt

G4int	verboseLevel

Detailed Description

Definition at line 131 of file G4OpBoundaryProcess.hh.

Constructor & Destructor Documentation

◆ G4OpBoundaryProcess() [1/2]

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

Definition at line 103 of file G4OpBoundaryProcess.cc.

              : G4VDiscreteProcess(processName, type)
 {
         if ( verboseLevel > 0) {
            G4cout << GetProcessName() << " is created " << G4endl;
         }
 
         SetProcessSubType(fOpBoundary);
 
     theStatus = Undefined;
     theModel = glisur;
     theFinish = polished;
         theReflectivity =  1.;
         theEfficiency   =  0.;
         theTransmittance = 0.;
 
         theSurfaceRoughness = 0.;
 
         prob_sl = 0.;
         prob_ss = 0.;
         prob_bs = 0.;
 
         PropertyPointer  = NULL;
         PropertyPointer1 = NULL;
         PropertyPointer2 = NULL;
 
         Material1 = NULL;
         Material2 = NULL;
 
         OpticalSurface = NULL;
 
         kCarTolerance = G4GeometryTolerance::GetInstance()
                         ->GetSurfaceTolerance();
 
         iTE = iTM = 0;
         thePhotonMomentum = 0.;
         Rindex1 = Rindex2 = 1.;
         cost1 = cost2 = sint1 = sint2 = 0.;
 
         idx = idy = 0;
         DichroicVector = NULL;
 }

Here is the call graph for this function:

◆ ~G4OpBoundaryProcess()

G4OpBoundaryProcess::~G4OpBoundaryProcess ( )

Definition at line 155 of file G4OpBoundaryProcess.cc.

155 {}

◆ G4OpBoundaryProcess() [2/2]

G4OpBoundaryProcess::G4OpBoundaryProcess ( const G4OpBoundaryProcess & right )

private

Member Function Documentation

◆ BoundaryProcessVerbose()

void G4OpBoundaryProcess::BoundaryProcessVerbose ( void ) const

private

Definition at line 545 of file G4OpBoundaryProcess.cc.

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

Here is the caller graph for this function:

◆ CalculateReflectivity()

void G4OpBoundaryProcess::CalculateReflectivity ( void )

private

Definition at line 1286 of file G4OpBoundaryProcess.cc.

 {
   G4double RealRindex =
            PropertyPointer1->Value(thePhotonMomentum);
   G4double ImaginaryRindex =
            PropertyPointer2->Value(thePhotonMomentum);
 
   // calculate FacetNormal
   if ( theFinish == ground ) {
      theFacetNormal =
                GetFacetNormal(OldMomentum, theGlobalNormal);
   } else {
      theFacetNormal = theGlobalNormal;
   }
 
   G4double PdotN = OldMomentum * theFacetNormal;
   cost1 = -PdotN;
 
   if (std::abs(cost1) < 1.0 - kCarTolerance) {
      sint1 = std::sqrt(1. - cost1*cost1);
   } else {
      sint1 = 0.0;
   }
 
   G4ThreeVector A_trans, A_paral, E1pp, E1pl;
   G4double E1_perp, E1_parl;
 
   if (sint1 > 0.0 ) {
      A_trans = OldMomentum.cross(theFacetNormal);
      A_trans = A_trans.unit();
      E1_perp = OldPolarization * A_trans;
      E1pp    = E1_perp * A_trans;
      E1pl    = OldPolarization - E1pp;
      E1_parl = E1pl.mag();
   }
   else {
      A_trans  = OldPolarization;
      // 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;
   }
 
   //calculate incident angle
   G4double incidentangle = GetIncidentAngle();
 
   //calculate the reflectivity depending on incident angle,
   //polarization and complex refractive
 
   theReflectivity =
              GetReflectivity(E1_perp, E1_parl, incidentangle,
                                                  RealRindex, ImaginaryRindex);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ChooseReflection()

void G4OpBoundaryProcess::ChooseReflection ( )

inlineprivate

Definition at line 286 of file G4OpBoundaryProcess.hh.

 {
                  G4double rand = G4UniformRand();
                  if ( rand >= 0.0 && rand < prob_ss ) {
                     theStatus = SpikeReflection;
                     theFacetNormal = theGlobalNormal;
                  }
                  else if ( rand >= prob_ss &&
                            rand <= prob_ss+prob_sl) {
                     theStatus = LobeReflection;
                  }
                  else if ( rand > prob_ss+prob_sl &&
                            rand < prob_ss+prob_sl+prob_bs ) {
                     theStatus = BackScattering;
                  }
                  else {
                     theStatus = LambertianReflection;
                  }
 }

Here is the caller graph for this function:

◆ DielectricDichroic()

void G4OpBoundaryProcess::DielectricDichroic ( )

private

Definition at line 872 of file G4OpBoundaryProcess.cc.

 {
         // Calculate Angle between Normal and Photon Momentum
         G4double anglePhotonToNormal = OldMomentum.angle(-theGlobalNormal);
 
         // Round it to closest integer
         G4double angleIncident = std::floor(180/pi*anglePhotonToNormal+0.5);
 
         if (!DichroicVector) {
            if (OpticalSurface) DichroicVector = OpticalSurface->GetDichroicVector();
         }
 
 
         if (DichroicVector) {
            G4double wavelength = h_Planck*c_light/thePhotonMomentum;
            theTransmittance =
              DichroicVector->Value(wavelength/nm,angleIncident,idx,idy)*perCent;
 //            G4cout << "wavelength: " << std::floor(wavelength/nm) 
 //                                     << "nm" << G4endl;
 //            G4cout << "Incident angle: " << angleIncident << "deg" << G4endl;
 //            G4cout << "Transmittance: " 
 //                   << std::floor(theTransmittance/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(theTransmittance) ) { // Not transmitted, so reflect
 
            if ( theModel == glisur || theFinish == polished ) {
               DoReflection();
            } else {
               ChooseReflection();
               if ( theStatus == LambertianReflection ) {
                  DoReflection();
               } else if ( theStatus == BackScattering ) {
                  NewMomentum = -OldMomentum;
                  NewPolarization = -OldPolarization;
               } else {
                 G4double PdotN, EdotN;
                 do {
                    if (theStatus==LobeReflection)
                       theFacetNormal = GetFacetNormal(OldMomentum,theGlobalNormal);
                    PdotN = OldMomentum * theFacetNormal;
                    NewMomentum = OldMomentum - (2.*PdotN)*theFacetNormal;
                   // Loop checking, 13-Aug-2015, Peter Gumplinger
                 } while (NewMomentum * theGlobalNormal <= 0.0);
                 EdotN = OldPolarization * theFacetNormal;
                 NewPolarization = -OldPolarization + (2.*EdotN)*theFacetNormal;
               }
            }
 
         } else {
 
            theStatus = Dichroic;
            NewMomentum = OldMomentum;
            NewPolarization = OldPolarization;
 
         }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DielectricDielectric()

void G4OpBoundaryProcess::DielectricDielectric ( )

private

Definition at line 938 of file G4OpBoundaryProcess.cc.

 {
     G4bool Inside = false;
     G4bool Swap = false;
 
         G4bool SurfaceRoughnessCriterionPass = 1;
         if (theSurfaceRoughness != 0. && Rindex1 > Rindex2) {
            G4double wavelength = h_Planck*c_light/thePhotonMomentum;
            G4double SurfaceRoughnessCriterion =
              std::exp(-std::pow((4*pi*theSurfaceRoughness*Rindex1*cost1/wavelength),2));
            SurfaceRoughnessCriterionPass = 
                                      G4BooleanRand(SurfaceRoughnessCriterion);
         }
 
     leap:
 
         G4bool Through = false;
     G4bool Done = false;
 
         G4double PdotN, EdotN;
 
         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;
           theGlobalNormal = -theGlobalNormal;
           G4SwapPtr(Material1,Material2);
           G4SwapObj(&Rindex1,&Rindex2);
        }
     
        if ( theFinish == polished ) {
             theFacetNormal = theGlobalNormal;
        }
        else {
             theFacetNormal =
                          GetFacetNormal(OldMomentum,theGlobalNormal);
        }
 
        PdotN = OldMomentum * theFacetNormal;
        EdotN = OldPolarization * theFacetNormal;
 
        cost1 = - PdotN;
        if (std::abs(cost1) < 1.0-kCarTolerance){
           sint1 = std::sqrt(1.-cost1*cost1);
           sint2 = sint1*Rindex1/Rindex2;     // *** Snell's Law ***
        }
        else {
           sint1 = 0.0;
           sint2 = 0.0;
        }
 
        if (sint2 >= 1.0) {
 
           // Simulate total internal reflection
 
           if (Swap) Swap = !Swap;
 
               theStatus = TotalInternalReflection;
 
               if ( !SurfaceRoughnessCriterionPass ) theStatus =
                                                        LambertianReflection;
 
           if ( theModel == unified && theFinish != polished )
                              ChooseReflection();
 
           if ( theStatus == LambertianReflection ) {
          DoReflection();
           }
           else if ( theStatus == BackScattering ) {
          NewMomentum = -OldMomentum;
          NewPolarization = -OldPolarization;
           }
           else {
 
                  PdotN = OldMomentum * theFacetNormal;
          NewMomentum = OldMomentum - (2.*PdotN)*theFacetNormal;
          EdotN = OldPolarization * theFacetNormal;
          NewPolarization = -OldPolarization + (2.*EdotN)*theFacetNormal;
 
           }
        }
        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 (sint1 > 0.0) {
              A_trans = OldMomentum.cross(theFacetNormal);
                  A_trans = A_trans.unit();
              E1_perp = OldPolarization * A_trans;
                  E1pp    = E1_perp * A_trans;
                  E1pl    = OldPolarization - E1pp;
                  E1_parl = E1pl.mag();
               }
           else {
              A_trans  = OldPolarization;
              // 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;
           }
 
               s1 = Rindex1*cost1;
               E2_perp = 2.*s1*E1_perp/(Rindex1*cost1+Rindex2*cost2);
               E2_parl = 2.*s1*E1_parl/(Rindex2*cost1+Rindex1*cost2);
               E2_total = E2_perp*E2_perp + E2_parl*E2_parl;
               s2 = Rindex2*cost2*E2_total;
 
               if (theTransmittance > 0) TransCoeff = theTransmittance;
               else if (cost1 != 0.0) TransCoeff = s2/s1;
               else TransCoeff = 0.0;
 
           if ( !G4BooleanRand(TransCoeff) ) {
 
              // Simulate reflection
 
                  if (Swap) Swap = !Swap;
 
          theStatus = FresnelReflection;
 
                  if ( !SurfaceRoughnessCriterionPass ) theStatus =
                                                           LambertianReflection;
 
          if ( theModel == unified && theFinish != polished )
                              ChooseReflection();
 
          if ( theStatus == LambertianReflection ) {
             DoReflection();
          }
          else if ( theStatus == BackScattering ) {
             NewMomentum = -OldMomentum;
             NewPolarization = -OldPolarization;
          }
          else {
 
                     PdotN = OldMomentum * theFacetNormal;
                 NewMomentum = OldMomentum - (2.*PdotN)*theFacetNormal;
 
                 if (sint1 > 0.0) {   // incident ray oblique
 
                E2_parl   = Rindex2*E2_parl/Rindex1 - E1_parl;
                E2_perp   = E2_perp - E1_perp;
                E2_total  = E2_perp*E2_perp + E2_parl*E2_parl;
                        A_paral   = NewMomentum.cross(A_trans);
                        A_paral   = A_paral.unit();
                E2_abs    = std::sqrt(E2_total);
                C_parl    = E2_parl/E2_abs;
                C_perp    = E2_perp/E2_abs;
 
                        NewPolarization = C_parl*A_paral + C_perp*A_trans;
 
                 }
 
                 else {               // incident ray perpendicular
 
                    if (Rindex2 > Rindex1) {
                   NewPolarization = - OldPolarization;
                    }
                    else {
                       NewPolarization =   OldPolarization;
                    }
 
                 }
              }
           }
           else { // photon gets transmitted
 
              // Simulate transmission/refraction
 
          Inside = !Inside;
          Through = true;
          theStatus = FresnelRefraction;
 
              if (sint1 > 0.0) {      // incident ray oblique
 
             alpha = cost1 - cost2*(Rindex2/Rindex1);
             NewMomentum = OldMomentum + alpha*theFacetNormal;
             NewMomentum = NewMomentum.unit();
 //                    PdotN = -cost2;
                     A_paral = NewMomentum.cross(A_trans);
                     A_paral = A_paral.unit();
             E2_abs     = std::sqrt(E2_total);
             C_parl     = E2_parl/E2_abs;
             C_perp     = E2_perp/E2_abs;
 
                     NewPolarization = C_parl*A_paral + C_perp*A_trans;
 
              }
              else {                  // incident ray perpendicular
 
             NewMomentum = OldMomentum;
             NewPolarization = OldPolarization;
 
              }
           }
        }
 
        OldMomentum = NewMomentum.unit();
        OldPolarization = NewPolarization.unit();
 
        if (theStatus == FresnelRefraction) {
           Done = (NewMomentum * theGlobalNormal <= 0.0);
        } 
        else {
           Done = (NewMomentum * theGlobalNormal >= -kCarTolerance);
        }
 
           // Loop checking, 13-Aug-2015, Peter Gumplinger
     } while (!Done);
 
     if (Inside && !Swap) {
           if( theFinish == polishedbackpainted ||
               theFinish == groundbackpainted ) {
 
               G4double rand = G4UniformRand();
               if ( rand > theReflectivity ) {
                  if (rand > theReflectivity + theTransmittance) {
             DoAbsorption();
                  } else {
                     theStatus = Transmission;
                     NewMomentum = OldMomentum;
                     NewPolarization = OldPolarization;
                  }
               }
           else {
         if (theStatus != FresnelRefraction ) {
            theGlobalNormal = -theGlobalNormal;
             }
             else {
            Swap = !Swap;
            G4SwapPtr(Material1,Material2);
            G4SwapObj(&Rindex1,&Rindex2);
             }
         if ( theFinish == groundbackpainted )
                     theStatus = LambertianReflection;
 
             DoReflection();
 
             theGlobalNormal = -theGlobalNormal;
         OldMomentum = NewMomentum;
 
             goto leap;
           }
       }
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DielectricLUT()

void G4OpBoundaryProcess::DielectricLUT ( )

private

Definition at line 802 of file G4OpBoundaryProcess.cc.

 {
         G4int thetaIndex, phiIndex;
         G4double AngularDistributionValue, thetaRad, phiRad, EdotN;
         G4ThreeVector PerpendicularVectorTheta, PerpendicularVectorPhi;
 
         theStatus = G4OpBoundaryProcessStatus(G4int(theFinish) + 
                            (G4int(NoRINDEX)-G4int(groundbackpainted)));
 
         G4int thetaIndexMax = OpticalSurface->GetThetaIndexMax();
         G4int phiIndexMax   = OpticalSurface->GetPhiIndexMax();
 
         G4double rand;
 
         do {
            rand = G4UniformRand();
            if ( rand > theReflectivity ) {
               if (rand > theReflectivity + theTransmittance) {
                  DoAbsorption();
               } else {
                  theStatus = Transmission;
                  NewMomentum = OldMomentum;
                  NewPolarization = OldPolarization;
               }
               break;
            }
            else {
               // Calculate Angle between Normal and Photon Momentum
               G4double anglePhotonToNormal = 
                                           OldMomentum.angle(-theGlobalNormal);
               // Round it to closest integer
               G4int angleIncident = G4int(std::floor(180/pi*anglePhotonToNormal+0.5));
 
               // 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
                  AngularDistributionValue = OpticalSurface -> 
                    GetAngularDistributionValue(angleIncident,
                                                thetaIndex,
                                                phiIndex);
                 // Loop checking, 13-Aug-2015, Peter Gumplinger
               } while ( !G4BooleanRand(AngularDistributionValue) );
 
               thetaRad = (-90 + 4*thetaIndex)*pi/180;
               phiRad = (-90 + 5*phiIndex)*pi/180;
               // Rotate Photon Momentum in Theta, then in Phi
               NewMomentum = -OldMomentum;
 
               PerpendicularVectorTheta = NewMomentum.cross(theGlobalNormal);
               if (PerpendicularVectorTheta.mag() < kCarTolerance )
                           PerpendicularVectorTheta = NewMomentum.orthogonal();
               NewMomentum =
                  NewMomentum.rotate(anglePhotonToNormal-thetaRad,
                                     PerpendicularVectorTheta);
               PerpendicularVectorPhi = 
                                   PerpendicularVectorTheta.cross(NewMomentum);
               NewMomentum = NewMomentum.rotate(-phiRad,PerpendicularVectorPhi);
 
               // Rotate Polarization too:
               theFacetNormal = (NewMomentum - OldMomentum).unit();
               EdotN = OldPolarization * theFacetNormal;
               NewPolarization = -OldPolarization + (2.*EdotN)*theFacetNormal;
            }
           // Loop checking, 13-Aug-2015, Peter Gumplinger
         } while (NewMomentum * theGlobalNormal <= 0.0);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DielectricMetal()

void G4OpBoundaryProcess::DielectricMetal ( )

private

Definition at line 709 of file G4OpBoundaryProcess.cc.

 {
         G4int n = 0;
         G4double rand, PdotN, EdotN;
         G4ThreeVector A_trans, A_paral;
 
     do {
 
            n++;
 
            rand = G4UniformRand();
            if ( rand > theReflectivity && n == 1 ) {
               if (rand > theReflectivity + theTransmittance) {
                 DoAbsorption();
               } else {
                 theStatus = Transmission;
                 NewMomentum = OldMomentum;
                 NewPolarization = OldPolarization;
               }
               break;
            }
            else {
 
              if (PropertyPointer1 && PropertyPointer2) {
                 if ( n > 1 ) {
                    CalculateReflectivity();
                    if ( !G4BooleanRand(theReflectivity) ) {
                       DoAbsorption();
                       break;
                    }
                 }
              }
 
              if ( theModel == glisur || theFinish == polished ) {
 
                 DoReflection();
 
              } else {
 
                 if ( n == 1 ) ChooseReflection();
                                                                                 
                 if ( theStatus == LambertianReflection ) {
                    DoReflection();
                 }
                 else if ( theStatus == BackScattering ) {
                    NewMomentum = -OldMomentum;
                    NewPolarization = -OldPolarization;
                 }
                 else {
 
                    if(theStatus==LobeReflection){
                      if ( PropertyPointer1 && PropertyPointer2 ){
                      } else {
                         theFacetNormal =
                             GetFacetNormal(OldMomentum,theGlobalNormal);
                      }
                    }
 
                    PdotN = OldMomentum * theFacetNormal;
                    NewMomentum = OldMomentum - (2.*PdotN)*theFacetNormal;
                    EdotN = OldPolarization * theFacetNormal;
 
                    if (sint1 > 0.0 ) {
                       A_trans = OldMomentum.cross(theFacetNormal);
                       A_trans = A_trans.unit();
                    } else {
                       A_trans  = OldPolarization;
                    }
                    A_paral   = NewMomentum.cross(A_trans);
                    A_paral   = A_paral.unit();
 
                    if(iTE>0&&iTM>0) {
                      NewPolarization = 
                            -OldPolarization + (2.*EdotN)*theFacetNormal;
                    } else if (iTE>0) {
                      NewPolarization = -A_trans;
                    } else if (iTM>0) {
                      NewPolarization = -A_paral;
                    }
 
                 }
 
              }
 
              OldMomentum = NewMomentum;
              OldPolarization = NewPolarization;
 
        }
 
           // Loop checking, 13-Aug-2015, Peter Gumplinger
     } while (NewMomentum * theGlobalNormal < 0.0);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DoAbsorption()

void G4OpBoundaryProcess::DoAbsorption ( )

inlineprivate

Definition at line 307 of file G4OpBoundaryProcess.hh.

 {
               theStatus = Absorption;
 
               if ( G4BooleanRand(theEfficiency) ) {
         
                  // EnergyDeposited =/= 0 means: photon has been detected
                  theStatus = Detection;
                  aParticleChange.ProposeLocalEnergyDeposit(thePhotonMomentum);
               }
               else {
                  aParticleChange.ProposeLocalEnergyDeposit(0.0);
               }
 
               NewMomentum = OldMomentum;
               NewPolarization = OldPolarization;
 
 //              aParticleChange.ProposeEnergy(0.0);
               aParticleChange.ProposeTrackStatus(fStopAndKill);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DoReflection()

void G4OpBoundaryProcess::DoReflection ( )

inlineprivate

Definition at line 329 of file G4OpBoundaryProcess.hh.

 {
         if ( theStatus == LambertianReflection ) {
 
           NewMomentum = G4LambertianRand(theGlobalNormal);
           theFacetNormal = (NewMomentum - OldMomentum).unit();
 
         }
         else if ( theFinish == ground ) {
 
       theStatus = LobeReflection;
           if ( PropertyPointer1 && PropertyPointer2 ){
           } else {
              theFacetNormal =
                  GetFacetNormal(OldMomentum,theGlobalNormal);
           }
           G4double PdotN = OldMomentum * theFacetNormal;
           NewMomentum = OldMomentum - (2.*PdotN)*theFacetNormal;
 
         }
         else {
 
           theStatus = SpikeReflection;
           theFacetNormal = theGlobalNormal;
           G4double PdotN = OldMomentum * theFacetNormal;
           NewMomentum = OldMomentum - (2.*PdotN)*theFacetNormal;
 
         }
         G4double EdotN = OldPolarization * theFacetNormal;
         NewPolarization = -OldPolarization + (2.*EdotN)*theFacetNormal;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ G4BooleanRand()

G4bool G4OpBoundaryProcess::G4BooleanRand ( const G4double prob ) const

inlineprivate

Definition at line 265 of file G4OpBoundaryProcess.hh.

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

Here is the caller graph for this function:

◆ GetFacetNormal()

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

private

Definition at line 630 of file G4OpBoundaryProcess.cc.

 {
         G4ThreeVector FacetNormal;
 
     if (theModel == unified || theModel == LUT) {
 
     /* This function code 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 alpha;
 
        G4double sigma_alpha = 0.0;
        if (OpticalSurface) sigma_alpha = OpticalSurface->GetSigmaAlpha();
 
            if (sigma_alpha == 0.0) return FacetNormal = Normal;
 
        G4double f_max = std::min(1.0,4.*sigma_alpha);
 
            G4double phi, SinAlpha, CosAlpha, SinPhi, CosPhi, unit_x, unit_y, unit_z;
            G4ThreeVector tmpNormal;
 
            do {
           do {
              alpha = G4RandGauss::shoot(0.0,sigma_alpha);
                 // Loop checking, 13-Aug-2015, Peter Gumplinger
           } while (G4UniformRand()*f_max > std::sin(alpha) || alpha >= halfpi );
 
           phi = G4UniformRand()*twopi;
 
           SinAlpha = std::sin(alpha);
           CosAlpha = std::cos(alpha);
               SinPhi = std::sin(phi);
               CosPhi = std::cos(phi);
 
               unit_x = SinAlpha * CosPhi;
               unit_y = SinAlpha * SinPhi;
               unit_z = CosAlpha;
 
           FacetNormal.setX(unit_x);
           FacetNormal.setY(unit_y);
           FacetNormal.setZ(unit_z);
 
               tmpNormal = Normal;
 
           FacetNormal.rotateUz(tmpNormal);
              // Loop checking, 13-Aug-2015, Peter Gumplinger
        } while (Momentum * FacetNormal >= 0.0);
     }
     else {
 
        G4double  polish = 1.0;
        if (OpticalSurface) polish = OpticalSurface->GetPolish();
 
            if (polish < 1.0) {
               do {
                  G4ThreeVector smear;
                  do {
                     smear.setX(2.*G4UniformRand()-1.0);
                     smear.setY(2.*G4UniformRand()-1.0);
                     smear.setZ(2.*G4UniformRand()-1.0);
                    // Loop checking, 13-Aug-2015, Peter Gumplinger
                  } while (smear.mag()>1.0);
                  smear = (1.-polish) * smear;
                  FacetNormal = Normal + smear;
                 // Loop checking, 13-Aug-2015, Peter Gumplinger
               } while (Momentum * FacetNormal >= 0.0);
               FacetNormal = FacetNormal.unit();
        }
            else {
               FacetNormal = Normal;
            }
     }
     return FacetNormal;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetIncidentAngle()

G4double G4OpBoundaryProcess::GetIncidentAngle ( )

private

Definition at line 1211 of file G4OpBoundaryProcess.cc.

 {
     G4double PdotN = OldMomentum * theFacetNormal;
     G4double magP= OldMomentum.mag();
     G4double magN= theFacetNormal.mag();
     G4double incidentangle = pi - std::acos(PdotN/(magP*magN));
 
     return incidentangle;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetMeanFreePath()

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

virtual

Implements G4VDiscreteProcess.

Definition at line 1202 of file G4OpBoundaryProcess.cc.

 {
     *condition = Forced;
 
     return DBL_MAX;
 }

◆ GetReflectivity()

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

private

Definition at line 1221 of file G4OpBoundaryProcess.cc.

 {
   G4complex Reflectivity, Reflectivity_TE, Reflectivity_TM;
   G4complex N1(Rindex1, 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* aMaterialPropertiesTable =
                                     Material1->GetMaterialPropertiesTable();
   G4MaterialPropertyVector* aPropertyPointerR =
                       aMaterialPropertiesTable->GetProperty("REALRINDEX");
   G4MaterialPropertyVector* aPropertyPointerI =
                       aMaterialPropertiesTable->GetProperty("IMAGINARYRINDEX");
   if (aPropertyPointerR && aPropertyPointerI) {
      G4double RRindex = aPropertyPointerR->Value(thePhotonMomentum);
      G4double IRindex = aPropertyPointerI->Value(thePhotonMomentum);
      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 calculaton for reflectivity on a metalic 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))
        {iTE = -1;}else{iTE = 1;}
      if(G4UniformRand()*real(Reflectivity) > real(Reflectivity_TM))
        {iTM = -1;}else{iTM = 1;}
     // Loop checking, 13-Aug-2015, Peter Gumplinger
   } while(iTE<0&&iTM<0);
 
   return real(Reflectivity);
 
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetStatus()

G4OpBoundaryProcessStatus G4OpBoundaryProcess::GetStatus ( ) const

inline

Definition at line 280 of file G4OpBoundaryProcess.hh.

 {
    return theStatus;
 }

Here is the caller graph for this function:

◆ InvokeSD()

G4bool G4OpBoundaryProcess::InvokeSD ( const G4Step * step )

private

Definition at line 1341 of file G4OpBoundaryProcess.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ IsApplicable()

G4bool G4OpBoundaryProcess::IsApplicable ( const G4ParticleDefinition & aParticleType )

inlinevirtual

Reimplemented from G4VProcess.

Definition at line 273 of file G4OpBoundaryProcess.hh.

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

Here is the call graph for this function:

◆ operator=()

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

private

◆ PostStepDoIt()

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

virtual

Reimplemented from G4VDiscreteProcess.

Definition at line 166 of file G4OpBoundaryProcess.cc.

 {
         theStatus = Undefined;
 
         aParticleChange.Initialize(aTrack);
         aParticleChange.ProposeVelocity(aTrack.GetVelocity());
 
         // Get hyperStep from  G4ParallelWorldProcess
         //  NOTE: PostSetpDoIt of this process should be
         //        invoked after G4ParallelWorldProcess!
 
         const G4Step* pStep = &aStep;
 
         const G4Step* hStep = G4ParallelWorldProcess::GetHyperStep();
         
         if (hStep) pStep = hStep;
 
         G4bool isOnBoundary =
                 (pStep->GetPostStepPoint()->GetStepStatus() == fGeomBoundary);
 
         if (isOnBoundary) {
            Material1 = pStep->GetPreStepPoint()->GetMaterial();
            Material2 = pStep->GetPostStepPoint()->GetMaterial();
         } else {
            theStatus = NotAtBoundary;
            if ( verboseLevel > 0) BoundaryProcessVerbose();
            return G4VDiscreteProcess::PostStepDoIt(aTrack, aStep);
         }
 
         G4VPhysicalVolume* thePrePV  =
                                pStep->GetPreStepPoint() ->GetPhysicalVolume();
         G4VPhysicalVolume* thePostPV =
                                pStep->GetPostStepPoint()->GetPhysicalVolume();
 
         if ( verboseLevel > 0 ) {
            G4cout << " Photon at Boundary! " << G4endl;
            if (thePrePV)  G4cout << " thePrePV:  " << thePrePV->GetName()  << G4endl;
            if (thePostPV) G4cout << " thePostPV: " << thePostPV->GetName() << G4endl;
         }
 
     if (aTrack.GetStepLength()<=kCarTolerance/2){
             theStatus = StepTooSmall;
                 if ( verboseLevel > 0) BoundaryProcessVerbose();
             return G4VDiscreteProcess::PostStepDoIt(aTrack, aStep);
     }
 
         const G4DynamicParticle* aParticle = aTrack.GetDynamicParticle();
 
     thePhotonMomentum = aParticle->GetTotalMomentum();
         OldMomentum       = aParticle->GetMomentumDirection();
     OldPolarization   = aParticle->GetPolarization();
 
         if ( verboseLevel > 0 ) {
            G4cout << " Old Momentum Direction: " << OldMomentum     << G4endl;
            G4cout << " Old Polarization:       " << OldPolarization << G4endl;
         }
 
         G4ThreeVector theGlobalPoint = pStep->GetPostStepPoint()->GetPosition();
 
         G4bool valid;
         //  Use the new method for Exit Normal in global coordinates,
         //    which provides the normal more reliably.
 
         // ID of Navigator which limits step
 
         G4int hNavId = G4ParallelWorldProcess::GetHypNavigatorID();
         std::vector<G4Navigator*>::iterator iNav =
                 G4TransportationManager::GetTransportationManager()->
                                          GetActiveNavigatorsIterator();
         theGlobalNormal =
                    (iNav[hNavId])->GetGlobalExitNormal(theGlobalPoint,&valid);
 
         if (valid) {
           theGlobalNormal = -theGlobalNormal;
         }
         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 (OldMomentum * theGlobalNormal > 0.0) {
 #ifdef G4OPTICAL_DEBUG
            G4ExceptionDescription ed;
            ed << " G4OpBoundaryProcess/PostStepDoIt(): "
               << " theGlobalNormal points in a wrong direction. "
               << G4endl;
            ed << "    The momentum of the photon arriving at interface (oldMomentum)"
               << " must exit the volume cross in the step. " << G4endl;
            ed << "  So it MUST have dot < 0 with the normal that Exits the new volume (globalNormal)." << G4endl;
            ed << "  >> The dot product of oldMomentum and global Normal is " << OldMomentum*theGlobalNormal << G4endl;
            ed << "     Old Momentum  (during step)     = " << OldMomentum << G4endl;
            ed << "     Global Normal (Exiting New Vol) = " << theGlobalNormal << G4endl;
            ed << G4endl;
            G4Exception("G4OpBoundaryProcess::PostStepDoIt", "OpBoun02",
                        EventMustBeAborted,  // Or JustWarning to see if it happens repeatedbly on one ray
                        ed,
                       "Invalid Surface Normal - Geometry must return valid surface normal pointing in the right direction");
 #else
            theGlobalNormal = -theGlobalNormal;
 #endif
         }
 
     G4MaterialPropertiesTable* aMaterialPropertiesTable;
         G4MaterialPropertyVector* Rindex;
 
     aMaterialPropertiesTable = Material1->GetMaterialPropertiesTable();
         if (aMaterialPropertiesTable) {
         Rindex = aMaterialPropertiesTable->GetProperty("RINDEX");
     }
     else {
             theStatus = NoRINDEX;
                 if ( verboseLevel > 0) BoundaryProcessVerbose();
                 aParticleChange.ProposeLocalEnergyDeposit(thePhotonMomentum);
         aParticleChange.ProposeTrackStatus(fStopAndKill);
         return G4VDiscreteProcess::PostStepDoIt(aTrack, aStep);
     }
 
         if (Rindex) {
         Rindex1 = Rindex->Value(thePhotonMomentum);
     }
     else {
             theStatus = NoRINDEX;
                 if ( verboseLevel > 0) BoundaryProcessVerbose();
                 aParticleChange.ProposeLocalEnergyDeposit(thePhotonMomentum);
         aParticleChange.ProposeTrackStatus(fStopAndKill);
         return G4VDiscreteProcess::PostStepDoIt(aTrack, aStep);
     }
 
         theReflectivity =  1.;
         theEfficiency   =  0.;
         theTransmittance = 0.;
 
         theSurfaceRoughness = 0.;
 
         theModel = glisur;
         theFinish = polished;
 
         G4SurfaceType type = dielectric_dielectric;
 
         Rindex = NULL;
         OpticalSurface = NULL;
 
         G4LogicalSurface* Surface = NULL;
 
         Surface = G4LogicalBorderSurface::GetSurface(thePrePV, thePostPV);
 
         if (Surface == NULL){
           G4bool enteredDaughter= (thePostPV->GetMotherLogical() ==
                                    thePrePV ->GetLogicalVolume());
       if(enteredDaughter){
         Surface = 
               G4LogicalSkinSurface::GetSurface(thePostPV->GetLogicalVolume());
         if(Surface == NULL)
           Surface =
                 G4LogicalSkinSurface::GetSurface(thePrePV->GetLogicalVolume());
       }
       else {
         Surface =
               G4LogicalSkinSurface::GetSurface(thePrePV->GetLogicalVolume());
         if(Surface == NULL)
           Surface =
                 G4LogicalSkinSurface::GetSurface(thePostPV->GetLogicalVolume());
       }
     }
 
     if (Surface) OpticalSurface = 
            dynamic_cast <G4OpticalSurface*> (Surface->GetSurfaceProperty());
 
     if (OpticalSurface) {
 
            type      = OpticalSurface->GetType();
        theModel  = OpticalSurface->GetModel();
        theFinish = OpticalSurface->GetFinish();
 
        aMaterialPropertiesTable = OpticalSurface->
                     GetMaterialPropertiesTable();
 
            if (aMaterialPropertiesTable) {
 
               if (theFinish == polishedbackpainted ||
                   theFinish == groundbackpainted ) {
                   Rindex = aMaterialPropertiesTable->GetProperty("RINDEX");
               if (Rindex) {
                      Rindex2 = Rindex->Value(thePhotonMomentum);
                   }
                   else {
              theStatus = NoRINDEX;
                      if ( verboseLevel > 0) BoundaryProcessVerbose();
                      aParticleChange.ProposeLocalEnergyDeposit(thePhotonMomentum);
                      aParticleChange.ProposeTrackStatus(fStopAndKill);
                      return G4VDiscreteProcess::PostStepDoIt(aTrack, aStep);
                   }
               }
 
               PropertyPointer =
                       aMaterialPropertiesTable->GetProperty("REFLECTIVITY");
               PropertyPointer1 =
                       aMaterialPropertiesTable->GetProperty("REALRINDEX");
               PropertyPointer2 =
                       aMaterialPropertiesTable->GetProperty("IMAGINARYRINDEX");
 
               iTE = 1;
               iTM = 1;
 
               if (PropertyPointer) {
 
                  theReflectivity =
                           PropertyPointer->Value(thePhotonMomentum);
 
               } else if (PropertyPointer1 && PropertyPointer2) {
 
                  CalculateReflectivity();
 
               }
 
               PropertyPointer =
               aMaterialPropertiesTable->GetProperty("EFFICIENCY");
               if (PropertyPointer) {
                       theEfficiency =
                       PropertyPointer->Value(thePhotonMomentum);
               }
 
               PropertyPointer =
               aMaterialPropertiesTable->GetProperty("TRANSMITTANCE");
               if (PropertyPointer) {
                       theTransmittance =
                       PropertyPointer->Value(thePhotonMomentum);
               }
 
               if (aMaterialPropertiesTable->
                                      ConstPropertyExists("SURFACEROUGHNESS"))
                  theSurfaceRoughness = aMaterialPropertiesTable->
                                          GetConstProperty("SURFACEROUGHNESS");
 
           if ( theModel == unified ) {
             PropertyPointer =
         aMaterialPropertiesTable->GetProperty("SPECULARLOBECONSTANT");
             if (PropertyPointer) {
                          prob_sl =
              PropertyPointer->Value(thePhotonMomentum);
                 } else {
                          prob_sl = 0.0;
                 }
 
             PropertyPointer =
         aMaterialPropertiesTable->GetProperty("SPECULARSPIKECONSTANT");
             if (PropertyPointer) {
                          prob_ss =
              PropertyPointer->Value(thePhotonMomentum);
                 } else {
                          prob_ss = 0.0;
                 }
 
             PropertyPointer =
         aMaterialPropertiesTable->GetProperty("BACKSCATTERCONSTANT");
             if (PropertyPointer) {
                          prob_bs =
              PropertyPointer->Value(thePhotonMomentum);
                 } else {
                          prob_bs = 0.0;
                 }
           }
        }
            else if (theFinish == polishedbackpainted ||
                     theFinish == groundbackpainted ) {
                       aParticleChange.ProposeLocalEnergyDeposit(thePhotonMomentum);
                       aParticleChange.ProposeTrackStatus(fStopAndKill);
                       return G4VDiscreteProcess::PostStepDoIt(aTrack, aStep);
            }
         }
 
         if (type == dielectric_dielectric ) {
            if (theFinish == polished || theFinish == ground ) {
 
           if (Material1 == Material2){
          theStatus = SameMaterial;
                  if ( verboseLevel > 0) BoundaryProcessVerbose();
          return G4VDiscreteProcess::PostStepDoIt(aTrack, aStep);
           }
               aMaterialPropertiesTable =
                      Material2->GetMaterialPropertiesTable();
               if (aMaterialPropertiesTable)
                  Rindex = aMaterialPropertiesTable->GetProperty("RINDEX");
               if (Rindex) {
                  Rindex2 = Rindex->Value(thePhotonMomentum);
               }
               else {
          theStatus = NoRINDEX;
                  if ( verboseLevel > 0) BoundaryProcessVerbose();
                  aParticleChange.ProposeLocalEnergyDeposit(thePhotonMomentum);
                  aParticleChange.ProposeTrackStatus(fStopAndKill);
                  return G4VDiscreteProcess::PostStepDoIt(aTrack, aStep);
           }
            }
         }
 
     if (type == dielectric_metal) {
 
       DielectricMetal();
 
     }
         else if (type == dielectric_LUT) {
 
           DielectricLUT();
 
         }
         else if (type == dielectric_dichroic) {
 
           DielectricDichroic();
 
         }
         else if (type == dielectric_dielectric) {
 
           if ( theFinish == polishedbackpainted ||
                theFinish == groundbackpainted ) {
              DielectricDielectric();
           }
           else {
              G4double rand = G4UniformRand();
              if ( rand > theReflectivity ) {
                 if (rand > theReflectivity + theTransmittance) {
                    DoAbsorption();
                 } else {
                    theStatus = Transmission;
                    NewMomentum = OldMomentum;
                    NewPolarization = OldPolarization;
                 }
              }
              else {
                 if ( theFinish == polishedfrontpainted ) {
                    DoReflection();
                 }
                 else if ( theFinish == groundfrontpainted ) {
                    theStatus = LambertianReflection;
                    DoReflection();
                 }
                 else {
                    DielectricDielectric();
                 }
              }
           }
         }
         else {
 
           G4cerr << " Error: G4BoundaryProcess: illegal boundary type " << G4endl;
           return G4VDiscreteProcess::PostStepDoIt(aTrack, aStep);
 
         }
 
         NewMomentum = NewMomentum.unit();
         NewPolarization = NewPolarization.unit();
 
         if ( verboseLevel > 0) {
            G4cout << " New Momentum Direction: " << NewMomentum     << G4endl;
            G4cout << " New Polarization:       " << NewPolarization << G4endl;
            BoundaryProcessVerbose();
         }
 
         aParticleChange.ProposeMomentumDirection(NewMomentum);
         aParticleChange.ProposePolarization(NewPolarization);
 
         if ( theStatus == FresnelRefraction || theStatus == Transmission ) {
            G4MaterialPropertyVector* groupvel =
            Material2->GetMaterialPropertiesTable()->GetProperty("GROUPVEL");
            G4double finalVelocity = groupvel->Value(thePhotonMomentum);
            aParticleChange.ProposeVelocity(finalVelocity);
         }
 
         if ( theStatus == Detection ) InvokeSD(pStep);
 
         return G4VDiscreteProcess::PostStepDoIt(aTrack, aStep);
 }

Here is the call graph for this function:

Member Data Documentation

◆ cost1

G4double G4OpBoundaryProcess::cost1

private

Definition at line 236 of file G4OpBoundaryProcess.hh.

◆ cost2

G4double G4OpBoundaryProcess::cost2

private

Definition at line 236 of file G4OpBoundaryProcess.hh.

◆ DichroicVector

G4Physics2DVector* G4OpBoundaryProcess::DichroicVector

private

Definition at line 257 of file G4OpBoundaryProcess.hh.

◆ idx

size_t G4OpBoundaryProcess::idx

private

Definition at line 256 of file G4OpBoundaryProcess.hh.

◆ idy

size_t G4OpBoundaryProcess::idy

private

Definition at line 256 of file G4OpBoundaryProcess.hh.

◆ iTE

G4int G4OpBoundaryProcess::iTE

private

Definition at line 252 of file G4OpBoundaryProcess.hh.

◆ iTM

G4int G4OpBoundaryProcess::iTM

private

Definition at line 252 of file G4OpBoundaryProcess.hh.

◆ kCarTolerance

G4double G4OpBoundaryProcess::kCarTolerance

private

Definition at line 254 of file G4OpBoundaryProcess.hh.

◆ Material1

G4Material* G4OpBoundaryProcess::Material1

private

Definition at line 224 of file G4OpBoundaryProcess.hh.

◆ Material2

G4Material* G4OpBoundaryProcess::Material2

private

Definition at line 225 of file G4OpBoundaryProcess.hh.

◆ NewMomentum

G4ThreeVector G4OpBoundaryProcess::NewMomentum

private

Definition at line 218 of file G4OpBoundaryProcess.hh.

◆ NewPolarization

G4ThreeVector G4OpBoundaryProcess::NewPolarization

private

Definition at line 219 of file G4OpBoundaryProcess.hh.

◆ OldMomentum

G4ThreeVector G4OpBoundaryProcess::OldMomentum

private

Definition at line 215 of file G4OpBoundaryProcess.hh.

◆ OldPolarization

G4ThreeVector G4OpBoundaryProcess::OldPolarization

private

Definition at line 216 of file G4OpBoundaryProcess.hh.

◆ OpticalSurface

G4OpticalSurface* G4OpBoundaryProcess::OpticalSurface

private

Definition at line 227 of file G4OpBoundaryProcess.hh.

◆ prob_bs

G4double G4OpBoundaryProcess::prob_bs

private

Definition at line 250 of file G4OpBoundaryProcess.hh.

◆ prob_sl

G4double G4OpBoundaryProcess::prob_sl

private

Definition at line 250 of file G4OpBoundaryProcess.hh.

◆ prob_ss

G4double G4OpBoundaryProcess::prob_ss

private

Definition at line 250 of file G4OpBoundaryProcess.hh.

◆ PropertyPointer

G4MaterialPropertyVector* G4OpBoundaryProcess::PropertyPointer

private

Definition at line 229 of file G4OpBoundaryProcess.hh.

◆ PropertyPointer1

G4MaterialPropertyVector* G4OpBoundaryProcess::PropertyPointer1

private

Definition at line 230 of file G4OpBoundaryProcess.hh.

◆ PropertyPointer2

G4MaterialPropertyVector* G4OpBoundaryProcess::PropertyPointer2

private

Definition at line 231 of file G4OpBoundaryProcess.hh.

◆ Rindex1

G4double G4OpBoundaryProcess::Rindex1

private

Definition at line 233 of file G4OpBoundaryProcess.hh.

◆ Rindex2

G4double G4OpBoundaryProcess::Rindex2

private

Definition at line 234 of file G4OpBoundaryProcess.hh.

◆ sint1

G4double G4OpBoundaryProcess::sint1

private

Definition at line 236 of file G4OpBoundaryProcess.hh.

◆ sint2

G4double G4OpBoundaryProcess::sint2

private

Definition at line 236 of file G4OpBoundaryProcess.hh.

◆ theEfficiency

G4double G4OpBoundaryProcess::theEfficiency

private

Definition at line 245 of file G4OpBoundaryProcess.hh.

◆ theFacetNormal

G4ThreeVector G4OpBoundaryProcess::theFacetNormal

private

Definition at line 222 of file G4OpBoundaryProcess.hh.

◆ theFinish

G4OpticalSurfaceFinish G4OpBoundaryProcess::theFinish

private

Definition at line 242 of file G4OpBoundaryProcess.hh.

◆ theGlobalNormal

G4ThreeVector G4OpBoundaryProcess::theGlobalNormal

private

Definition at line 221 of file G4OpBoundaryProcess.hh.

◆ theModel

G4OpticalSurfaceModel G4OpBoundaryProcess::theModel

private

Definition at line 240 of file G4OpBoundaryProcess.hh.

◆ thePhotonMomentum

G4double G4OpBoundaryProcess::thePhotonMomentum

private

Definition at line 213 of file G4OpBoundaryProcess.hh.

◆ theReflectivity

G4double G4OpBoundaryProcess::theReflectivity

private

Definition at line 244 of file G4OpBoundaryProcess.hh.

◆ theStatus

G4OpBoundaryProcessStatus G4OpBoundaryProcess::theStatus

private

Definition at line 238 of file G4OpBoundaryProcess.hh.

◆ theSurfaceRoughness

G4double G4OpBoundaryProcess::theSurfaceRoughness

private

Definition at line 248 of file G4OpBoundaryProcess.hh.

◆ theTransmittance

G4double G4OpBoundaryProcess::theTransmittance

private

Definition at line 246 of file G4OpBoundaryProcess.hh.

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

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ G4OpBoundaryProcess() [1/2]

◆ ~G4OpBoundaryProcess()

◆ G4OpBoundaryProcess() [2/2]

Member Function Documentation

◆ BoundaryProcessVerbose()

◆ CalculateReflectivity()

◆ ChooseReflection()

◆ DielectricDichroic()

◆ DielectricDielectric()

◆ DielectricLUT()

◆ DielectricMetal()

◆ DoAbsorption()

◆ DoReflection()

◆ G4BooleanRand()

◆ GetFacetNormal()

◆ GetIncidentAngle()

◆ GetMeanFreePath()

◆ GetReflectivity()

◆ GetStatus()

◆ InvokeSD()

◆ IsApplicable()

◆ operator=()

◆ PostStepDoIt()

Member Data Documentation

◆ cost1

◆ cost2

◆ DichroicVector

◆ idx

◆ idy

◆ iTE

◆ iTM

◆ kCarTolerance

◆ Material1

◆ Material2

◆ NewMomentum

◆ NewPolarization

◆ OldMomentum

◆ OldPolarization

◆ OpticalSurface

◆ prob_bs

◆ prob_sl

◆ prob_ss

◆ PropertyPointer

◆ PropertyPointer1

◆ PropertyPointer2

◆ Rindex1

◆ Rindex2

◆ sint1

◆ sint2

◆ theEfficiency

◆ theFacetNormal

◆ theFinish

◆ theGlobalNormal

◆ theModel

◆ thePhotonMomentum

◆ theReflectivity

◆ theStatus

◆ theSurfaceRoughness

◆ theTransmittance