#include <G4UCNBoundaryProcess.hh>

Inheritance diagram for G4UCNBoundaryProcess:

Collaboration diagram for G4UCNBoundaryProcess:

Public Member Functions
	G4UCNBoundaryProcess (const G4String &processName="UCNBoundaryProcess", G4ProcessType type=fUCN)

virtual	~G4UCNBoundaryProcess ()

G4bool	IsApplicable (const G4ParticleDefinition &aParticleType)

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

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

G4ThreeVector	MRreflect (G4double, G4ThreeVector, G4ThreeVector, G4double, G4double)

G4ThreeVector	MRreflectHigh (G4double, G4double, G4double, G4ThreeVector, G4ThreeVector, G4double, G4double, G4double &)

void	SetMicroRoughness (G4bool)

G4bool	GetMicroRoughness ()

G4UCNBoundaryProcessStatus	GetStatus () const

void	BoundaryProcessSummary () const

void	SetMaterialPropertiesTable1 (G4UCNMaterialPropertiesTable *MPT)

void	SetMaterialPropertiesTable2 (G4UCNMaterialPropertiesTable *MPT)

G4double	GetTheta_o ()

G4double	GetPhi_o ()

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
	G4UCNBoundaryProcess (const G4UCNBoundaryProcess &right)

G4UCNBoundaryProcess &	operator= (const G4UCNBoundaryProcess &right)

G4bool	High (G4double, G4double)

G4bool	Loss (G4double, G4double, G4double)

G4bool	SpinFlip (G4double)

G4double	Reflectivity (G4double, G4double)

G4ThreeVector	Reflect (G4double, G4ThreeVector, G4ThreeVector)

G4double	Transmit (G4double, G4double)

G4ThreeVector	LDiffRefl (G4ThreeVector)

G4ThreeVector	MRDiffRefl (G4ThreeVector, G4double, G4double, G4ThreeVector, G4double)

G4ThreeVector	MRDiffTrans (G4ThreeVector, G4double, G4double, G4ThreeVector, G4double)

G4RotationMatrix	GetCoordinateTransformMatrix (G4ThreeVector, G4ThreeVector)

void	BoundaryProcessVerbose () const

G4bool	InvokeSD (const G4Step *step)

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 83 of file G4UCNBoundaryProcess.hh.

Constructor & Destructor Documentation

◆ G4UCNBoundaryProcess() [1/2]

G4UCNBoundaryProcess::G4UCNBoundaryProcess	(	const G4String &	processName = `"UCNBoundaryProcess"`,
		G4ProcessType	type = `fUCN`
	)

Definition at line 68 of file G4UCNBoundaryProcess.cc.

   : G4VDiscreteProcess(processName, type)
 {
 
   if (verboseLevel > 0) G4cout << GetProcessName() << " is created " << G4endl;
 
   SetProcessSubType(fUCNBoundary);
 
   theStatus = Undefined;
 
   fMessenger = new G4UCNBoundaryProcessMessenger(this);
 
   neV = 1.0e-9*eV;
 
   kCarTolerance = G4GeometryTolerance::GetInstance()
                   ->GetSurfaceTolerance();
 
   Material1 = NULL;
   Material2 = NULL;
 
   aMaterialPropertiesTable1 = NULL;
   aMaterialPropertiesTable2 = NULL;
 
   UseMicroRoughnessReflection = false;
   DoMicroRoughnessReflection  = false;
 
   nNoMPT = nNoMRT = nNoMRCondition = 0;
   nAbsorption = nEzero = nFlip = 0;
   aSpecularReflection = bSpecularReflection = 0;
   bLambertianReflection = 0;
   aMRDiffuseReflection = bMRDiffuseReflection = 0;
   nSnellTransmit = mSnellTransmit = 0;
   aMRDiffuseTransmit = 0;
   ftheta_o = fphi_o = 0;
 }

Here is the call graph for this function:

◆ ~G4UCNBoundaryProcess()

G4UCNBoundaryProcess::~G4UCNBoundaryProcess ( )

virtual

Definition at line 105 of file G4UCNBoundaryProcess.cc.

 {
    delete fMessenger;
 } 

◆ G4UCNBoundaryProcess() [2/2]

G4UCNBoundaryProcess::G4UCNBoundaryProcess ( const G4UCNBoundaryProcess & right )

private

Member Function Documentation

◆ BoundaryProcessSummary()

void G4UCNBoundaryProcess::BoundaryProcessSummary ( void ) const

Definition at line 944 of file G4UCNBoundaryProcess.cc.

 {
   G4cout << "Sum NoMT:                            "
          << nNoMPT << G4endl;
   G4cout << "Sum NoMRT:                           "
          << nNoMRT << G4endl;
   G4cout << "Sum NoMRCondition:                   "
          << nNoMRCondition << G4endl;
   G4cout << "Sum No. E < V Loss:                  "
          << nAbsorption << G4endl;
   G4cout << "Sum No. E > V Ezero:                 "
          << nEzero << G4endl;
   G4cout << "Sum No. E < V SpinFlip:              "
          << nFlip << G4endl;
   G4cout << "Sum No. E > V Specular Reflection:   "
          << aSpecularReflection << G4endl;
   G4cout << "Sum No. E < V Specular Reflection:   "
          << bSpecularReflection << G4endl;
   G4cout << "Sum No. E < V Lambertian Reflection: "
          << bLambertianReflection << G4endl;
   G4cout << "Sum No. E > V MR DiffuseReflection:  "
          << aMRDiffuseReflection << G4endl;
   G4cout << "Sum No. E < V MR DiffuseReflection:  "
          << bMRDiffuseReflection << G4endl;
   G4cout << "Sum No. E > V SnellTransmit:         "
          << nSnellTransmit << G4endl;
   G4cout << "Sum No. E > V MR SnellTransmit:      "
          << mSnellTransmit << G4endl;
   G4cout << "Sum No. E > V DiffuseTransmit:       "
          << aMRDiffuseTransmit << G4endl;
   G4cout << "                                     " << G4endl;
 }

Here is the caller graph for this function:

◆ BoundaryProcessVerbose()

void G4UCNBoundaryProcess::BoundaryProcessVerbose ( ) const

private

Definition at line 910 of file G4UCNBoundaryProcess.cc.

 {
   if ( theStatus == Undefined )
      G4cout << " *** Undefined *** " << G4endl;
   if ( theStatus == NotAtBoundary )
      G4cout << " *** NotAtBoundary *** " << G4endl;
   if ( theStatus == SameMaterial )
      G4cout << " *** SameMaterial *** " << G4endl;
   if ( theStatus == StepTooSmall )
      G4cout << " *** StepTooSmall *** " << G4endl;
   if ( theStatus == NoMPT )
      G4cout << " *** No G4UCNMaterialPropertiesTable *** " << G4endl;
   if ( theStatus == NoMRT )
      G4cout << " *** No MicroRoughness Table *** " << G4endl;
   if ( theStatus == NoMRCondition )
      G4cout << " *** MicroRoughness Condition not satisfied *** " << G4endl;
   if ( theStatus == Absorption )
      G4cout << " *** Loss on Surface *** " << G4endl;
   if ( theStatus == Ezero )
      G4cout << " *** Ezero on Surface *** " << G4endl;
   if ( theStatus == Flip )
      G4cout << " *** Spin Flip on Surface *** " << G4endl;
   if ( theStatus == SpecularReflection )
      G4cout << " *** Specular Reflection *** " << G4endl;
   if ( theStatus == LambertianReflection )
      G4cout << " *** LambertianR Reflection *** " << G4endl;
   if ( theStatus == MRDiffuseReflection )
      G4cout << " *** MR Model Diffuse Reflection *** " << G4endl;
   if ( theStatus == SnellTransmit )
      G4cout << " *** Snell Transmission *** " << G4endl;
   if ( theStatus == MRDiffuseTransmit )
      G4cout << " *** MR Model Diffuse Transmission *** " << G4endl;
 }

Here is the caller graph for this function:

◆ GetCoordinateTransformMatrix()

G4RotationMatrix G4UCNBoundaryProcess::GetCoordinateTransformMatrix	(	G4ThreeVector	Normal,
		G4ThreeVector	direction
	)

private

Definition at line 879 of file G4UCNBoundaryProcess.cc.

 {
    // Definition of the local coordinate system (c.s. of the reflection)
 
   G4ThreeVector  es1, es2, es3;
 
   // z-Coordinate is the surface normal, has already length 1
 
   es3 = Normal;
 
   // Perpendicular part of incident direction w.r.t. normal
   es1 = direction.perpPart(Normal);
 
   // Set to unit length: x-Coordinate
 
   es1.setMag(1.);
   es2 = es1;
 
   // y-Coordinate is the pi/2-rotation of x-axis around z-axis
 
   es2.rotate(90.*degree, es3);
 
   // Transformation matrix consists just of the three coordinate vectors
   // as the global coordinate system is the 'standard' coordinate system
 
   G4RotationMatrix matrix(es1, es2, es3);
 
   return matrix;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetMeanFreePath()

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

virtual

Implements G4VDiscreteProcess.

Definition at line 457 of file G4UCNBoundaryProcess.cc.

 {
   *condition = Forced;
 
   return DBL_MAX;
 }

◆ GetMicroRoughness()

G4bool G4UCNBoundaryProcess::GetMicroRoughness ( )

inline

Definition at line 248 of file G4UCNBoundaryProcess.hh.

 {
   return UseMicroRoughnessReflection;
 }

◆ GetPhi_o()

G4double G4UCNBoundaryProcess::GetPhi_o ( )

inline

Definition at line 213 of file G4UCNBoundaryProcess.hh.

213 {return fphi_o;};

G4UCNBoundaryProcess::fphi_o

G4double fphi_o

Definition: G4UCNBoundaryProcess.hh:195

◆ GetStatus()

G4UCNBoundaryProcessStatus G4UCNBoundaryProcess::GetStatus ( ) const

inline

Definition at line 228 of file G4UCNBoundaryProcess.hh.

 {
   return theStatus;
 }

◆ GetTheta_o()

G4double G4UCNBoundaryProcess::GetTheta_o ( )

inline

Definition at line 212 of file G4UCNBoundaryProcess.hh.

212 {return ftheta_o;};

G4UCNBoundaryProcess::ftheta_o

G4double ftheta_o

Definition: G4UCNBoundaryProcess.hh:195

◆ High()

G4bool G4UCNBoundaryProcess::High	(	G4double	Energy,
		G4double	FermiPotDiff
	)

inlineprivate

Definition at line 234 of file G4UCNBoundaryProcess.hh.

 {
   // Returns true for Energy > Fermi Potential Difference
 
   return (Energy > FermiPotDiff);
 }

Here is the caller graph for this function:

◆ InvokeSD()

G4bool G4UCNBoundaryProcess::InvokeSD ( const G4Step * step )

private

Definition at line 977 of file G4UCNBoundaryProcess.cc.

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

Here is the call graph for this function:

◆ IsApplicable()

G4bool G4UCNBoundaryProcess::IsApplicable ( const G4ParticleDefinition & aParticleType )

inlinevirtual

Reimplemented from G4VProcess.

Definition at line 222 of file G4UCNBoundaryProcess.hh.

 {
   return ( &aParticleType == G4Neutron::NeutronDefinition() );
 }

Here is the call graph for this function:

◆ LDiffRefl()

G4ThreeVector G4UCNBoundaryProcess::LDiffRefl ( G4ThreeVector Normal )

private

Definition at line 861 of file G4UCNBoundaryProcess.cc.

 {
   G4ThreeVector momentum;
 
   // cosine distribution - Lambert's law
 
   momentum.setRThetaPhi(1., std::acos(std::sqrt(G4UniformRand())), 2.*pi*G4UniformRand());
   momentum.rotateUz(Normal);
 
   if (momentum*Normal < 0) {
      momentum*=-1;
      G4cout << "G4UCNBoundaryProcess::LDiffRefl: !" << G4endl;
   }
 
   return momentum.unit();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Loss()

G4bool G4UCNBoundaryProcess::Loss	(	G4double	pUpScatter,
		G4double	theVelocityNormal,
		G4double	FermiPot
	)

private

Definition at line 466 of file G4UCNBoundaryProcess.cc.

 {
   // The surface roughness is not taken into account here.
   // One could use e.g. ultracold neutrons, R. Golub, p.35,
   // where mu is increased by roughness parameters sigma and
   // omega, which are related to the height and the distance of
   // "disturbances" on the surface
 
   G4double vBound = std::sqrt(2.*FermiPot/neutron_mass_c2*c_squared);
   G4double vRatio = theVelocityNormal/vBound;
 
   G4double pLoss = (2*pUpScatter*vRatio)/(std::sqrt(1-(vRatio*vRatio)));
 
   // Check, if enhancement for surface roughness should be done
 
   if (DoMicroRoughnessReflection) {
      if (aMaterialPropertiesTable2) {
         const G4double hdm = hbar_Planck*c_squared/neutron_mass_c2;
         G4double b = aMaterialPropertiesTable2->GetRMS();
         G4double w = aMaterialPropertiesTable2->GetCorrLen();
 
         // cf. Golub's book p. 35, eq. 2.103
 
         pLoss *= std::sqrt(1+2*b*b*vBound*vBound/
                     (hdm*hdm+0.85*hdm*vBound*w+2*vBound*vBound*w*w));
      }
   }
 
   return (G4UniformRand() <= std::fabs(pLoss));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ MRDiffRefl()

G4ThreeVector G4UCNBoundaryProcess::MRDiffRefl	(	G4ThreeVector	Normal,
		G4double	Energy,
		G4double	FermiPot,
		G4ThreeVector	OldMomentum,
		G4double	pDiffuse
	)

private

Definition at line 696 of file G4UCNBoundaryProcess.cc.

 {
   G4bool accepted = false;
 
   G4double theta_o, phi_o;
 
   // Polar angle of incidence
 
   G4double theta_i = OldMomentum.polarAngle(-Normal);
 
   // Azimuthal angle of incidence
 
   //  G4double phi_i = -OldMomentum.azimAngle(-Normal);
 
   // accept-reject method for MR-reflection
 
   G4int count = 0;
   while (!accepted) {
         theta_o = G4UniformRand()*pi/2;
         phi_o = G4UniformRand()*pi*2-pi;
         // Box over distribution is increased by 50% to ensure no value is above
         if (1.5*G4UniformRand()*
            aMaterialPropertiesTable2->
              GetMRMaxProbability(theta_i, Energy)/pDiffuse <=
            aMaterialPropertiesTable2->
              GetMRProbability(theta_i,Energy,FermiPot,theta_o,phi_o)/pDiffuse)
 
            accepted = true;
 
          // For the case that the box is nevertheless exceeded
 
         if (aMaterialPropertiesTable2->
              GetMRProbability(theta_i, Energy, FermiPot, theta_o, phi_o)/
              (1.5*aMaterialPropertiesTable2->
                               GetMRMaxProbability(theta_i, Energy)) > 1) {
             G4cout << "MRMax Wahrscheinlichkeitsueberschreitung!" << G4endl;
             G4cout << aMaterialPropertiesTable2->
                    GetMRProbability(theta_i, Energy, FermiPot, theta_o, phi_o)/
                    (1.5*aMaterialPropertiesTable2->
                                GetMRMaxProbability(theta_i, Energy)) << G4endl;
             aMaterialPropertiesTable2->
                SetMRMaxProbability(theta_i, Energy,
                                    aMaterialPropertiesTable2->
                                     GetMRProbability(theta_i, Energy, 
                                                      FermiPot, theta_o, phi_o));
         }
     // Loop checking, 31-Aug-2015, Vladimir Ivanchenko
     if(++count > 10000) { accepted = true; }
   }
 
   // Creates vector in the local coordinate system of the reflection
 
   G4ThreeVector localmomentum;
   localmomentum.setRThetaPhi(1., theta_o, phi_o);
 
   ftheta_o = theta_o;
   fphi_o = phi_o;
 
   // Get coordinate transform matrix
 
   G4RotationMatrix TransCoord = 
       GetCoordinateTransformMatrix(Normal, OldMomentum);
 
   //transfer to the coordinates of the global system
 
   G4ThreeVector momentum = TransCoord*localmomentum;
 
   //momentum.rotateUz(Normal);
 
   if (momentum * Normal<0) {
      momentum*=-1;
      // something has gone wrong...
      G4cout << "G4UCNBoundaryProcess::MRDiffRefl: !" << G4endl;
   }
 
   return momentum.unit();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ MRDiffTrans()

G4ThreeVector G4UCNBoundaryProcess::MRDiffTrans	(	G4ThreeVector	Normal,
		G4double	Energy,
		G4double	FermiPot,
		G4ThreeVector	OldMomentum,
		G4double	pDiffuseTrans
	)

private

Definition at line 778 of file G4UCNBoundaryProcess.cc.

 {
   G4bool accepted = false;
 
   G4double theta_o, phi_o;
 
   // Polar angle of incidence
 
   G4double theta_i = OldMomentum.polarAngle(-Normal);
 
   // azimuthal angle of incidence
 
   //  G4double phi_i = -OldMomentum.azimAngle(-Normal);
 
   G4int count = 0;
   while (!accepted) {
     theta_o = G4UniformRand()*pi/2;
     phi_o = G4UniformRand()*pi*2-pi;
 
     // Box over distribution is increased by 50% to ensure no value is above
 
     if (1.5*G4UniformRand()*
         aMaterialPropertiesTable2->
           GetMRMaxTransProbability(theta_i, Energy)/pDiffuseTrans <=
         aMaterialPropertiesTable2->
           GetMRTransProbability(theta_i,Energy,FermiPot,theta_o,phi_o)/
                                                           pDiffuseTrans)
 
         accepted=true;
 
     // For the case that the box is nevertheless exceeded
 
     if(aMaterialPropertiesTable2->
         GetMRTransProbability(theta_i, Energy, FermiPot, theta_o, phi_o)/
         (1.5*aMaterialPropertiesTable2->
                          GetMRMaxTransProbability(theta_i, Energy)) > 1) {
         G4cout << "MRMaxTrans Wahrscheinlichkeitsueberschreitung!" << G4endl;
         G4cout << aMaterialPropertiesTable2->
                GetMRTransProbability(theta_i, Energy, FermiPot, theta_o, phi_o)/
                (1.5*aMaterialPropertiesTable2->
                            GetMRMaxTransProbability(theta_i, Energy)) << G4endl;
         aMaterialPropertiesTable2->
            SetMRMaxTransProbability(theta_i, Energy,
                                aMaterialPropertiesTable2->
                                 GetMRTransProbability(theta_i, Energy,
                                                  FermiPot, theta_o, phi_o));
     }
     // Loop checking, 31-Aug-2015, Vladimir Ivanchenko
     if(++count > 10000) { accepted = true; }
   }
 
   // Creates vector in the local coordinate system of the reflection
 
   G4ThreeVector localmomentum;
   localmomentum.setRThetaPhi(1., pi-theta_o, phi_o);
 
   // Get coordinate transform matrix
 
   G4RotationMatrix TransCoord = 
     GetCoordinateTransformMatrix(Normal, OldMomentum);
 
   // Transfer to the coordinates of the global system
 
   G4ThreeVector momentum = TransCoord*localmomentum;
 
   if (momentum*Normal<0) {
      // something has gone wrong... 
      momentum*=-1;
      G4cout << "G4UCNBoundaryProcess::MRDiffTrans: !" << G4endl;
   }
 
   return momentum.unit();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ MRreflect()

G4ThreeVector G4UCNBoundaryProcess::MRreflect	(	G4double	pDiffuse,
		G4ThreeVector	OldMomentum,
		G4ThreeVector	Normal,
		G4double	Energy,
		G4double	FermiPot
	)

Definition at line 543 of file G4UCNBoundaryProcess.cc.

 {
   // Only for Enormal <= VFermi
 
   G4ThreeVector NewMomentum;
 
   // Checks if the reflection should be non-specular
 
   if (G4UniformRand() <= pDiffuse) {
 
       // Reflect diffuse
 
       // Determines the angles of the non-specular reflection
 
       NewMomentum =
              MRDiffRefl(Normal, Energy, FermiPot, OldMomentum, pDiffuse);
 
       bMRDiffuseReflection++;
       theStatus = MRDiffuseReflection;
       if ( verboseLevel > 0 ) BoundaryProcessVerbose();
 
       return NewMomentum;
 
   } else {
 
       // Reflect specular
 
       G4double PdotN = OldMomentum * Normal;
 
       NewMomentum = OldMomentum - (2.*PdotN)*Normal;
       NewMomentum.unit();
 
       bSpecularReflection++;
       theStatus = SpecularReflection;
       if ( verboseLevel > 0 ) BoundaryProcessVerbose();
 
       return NewMomentum;
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ MRreflectHigh()

G4ThreeVector G4UCNBoundaryProcess::MRreflectHigh	(	G4double	pDiffuse,
		G4double	pDiffuseTrans,
		G4double	pLoss,
		G4ThreeVector	OldMomentum,
		G4ThreeVector	Normal,
		G4double	Energy,
		G4double	FermiPot,
		G4double &	Enew
	)

Definition at line 587 of file G4UCNBoundaryProcess.cc.

 {
   // Only for Enormal > VFermi
 
   G4double costheta = OldMomentum*Normal;
 
   G4double Enormal = Energy * (costheta*costheta);
 
 //  G4double pSpecular = Reflectivity(Enormal,FermiPot)*
   G4double pSpecular = Reflectivity(FermiPot,Enormal)*
                                          (1.-pDiffuse-pDiffuseTrans-pLoss);
 
   G4ThreeVector NewMomentum;
 
   G4double decide = G4UniformRand();
 
   if (decide < pSpecular) {
 
      // Reflect specularly
 
      G4double PdotN = OldMomentum * Normal;
      NewMomentum = OldMomentum - (2.*PdotN)*Normal;
      NewMomentum.unit();
 
      Enew = Energy;
 
      aSpecularReflection++;
      theStatus = SpecularReflection;
      if ( verboseLevel ) BoundaryProcessVerbose();
 
      return NewMomentum;
   }
 
   if (decide < pSpecular + pDiffuse) {
 
      // Reflect diffusely
 
       // Determines the angles of the non-specular reflection
 
       NewMomentum =
           MRDiffRefl(Normal, Energy, FermiPot, OldMomentum, pDiffuse);
 
       if (verboseLevel > 0) G4cout << "Diffuse normal " << Normal
                                    << ", " << NewMomentum << G4endl;
       Enew = Energy;
 
       aMRDiffuseReflection++;
       theStatus = MRDiffuseReflection;
       if ( verboseLevel ) BoundaryProcessVerbose();
 
       return NewMomentum;
   }
 
   if (decide < pSpecular + pDiffuse + pDiffuseTrans) {
 
      // Transmit diffusely
 
      // Determines the angles of the non-specular transmission
 
      NewMomentum =
       MRDiffTrans(Normal, Energy, FermiPot, OldMomentum, pDiffuseTrans);
 
      Enew = Energy - FermiPot;
 
      aMRDiffuseTransmit++;
      theStatus = MRDiffuseTransmit;
      if ( verboseLevel ) BoundaryProcessVerbose();
 
      return NewMomentum;
   }
 
   if (decide < pSpecular + pDiffuse + pDiffuseTrans + pLoss) {
 
      // Loss
 
      Enew = 0.;
 
      nEzero++;
      theStatus = Ezero;
      if ( verboseLevel > 0 ) BoundaryProcessVerbose();
 
      return NewMomentum;
   }
 
   // last case: Refractive transmission
 
   Enew = Energy - FermiPot;
 
   G4double palt = std::sqrt(2*neutron_mass_c2/c_squared*Energy);
   G4double produ = OldMomentum * Normal;
 
   NewMomentum = palt*OldMomentum-
                 (palt*produ+std::sqrt(palt*palt*produ*produ-2*neutron_mass_c2/
                       c_squared*FermiPot))*Normal;
 
   mSnellTransmit++;
   theStatus = SnellTransmit;
   if ( verboseLevel > 0 ) BoundaryProcessVerbose();
 
   return NewMomentum.unit();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ operator=()

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

private

◆ PostStepDoIt()

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

virtual

Reimplemented from G4VDiscreteProcess.

Definition at line 111 of file G4UCNBoundaryProcess.cc.

 {
   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 > 1 ) BoundaryProcessVerbose();
      return G4VDiscreteProcess::PostStepDoIt(aTrack, aStep);
   }
 
   if (aTrack.GetStepLength()<=kCarTolerance/2) {
      theStatus = StepTooSmall;
      if ( verboseLevel > 0 ) BoundaryProcessVerbose();
      return G4VDiscreteProcess::PostStepDoIt(aTrack, aStep);
   }
 
   aMaterialPropertiesTable1 = (G4UCNMaterialPropertiesTable*)Material1->
                                                  GetMaterialPropertiesTable();
   aMaterialPropertiesTable2 = (G4UCNMaterialPropertiesTable*)Material2->
                                                  GetMaterialPropertiesTable();
 
   G4String volnam1 = pStep->GetPreStepPoint() ->GetPhysicalVolume()->GetName();
   G4String volnam2 = pStep->GetPostStepPoint()->GetPhysicalVolume()->GetName();
 
   if (verboseLevel > 0) {
      G4cout << " UCN at Boundary! " << G4endl;
      G4cout << " vol1: " << volnam1 << ", vol2: " << volnam2 << G4endl;
      G4cout << " Ekin:     " << aTrack.GetKineticEnergy()/neV <<"neV"<< G4endl;
      G4cout << " MomDir:   " << aTrack.GetMomentumDirection() << G4endl;
   }
 
   if (Material1 == Material2) {
      theStatus = SameMaterial;
      if ( verboseLevel > 0 ) BoundaryProcessVerbose();
      return G4VDiscreteProcess::PostStepDoIt(aTrack, aStep);
   }
 
   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();
 
   G4ThreeVector theGlobalNormal =
              (iNav[hNavId])->GetGlobalExitNormal(theGlobalPoint,&valid);
 
   if (valid) {
      theGlobalNormal = -theGlobalNormal;
   }
   else
   {
      G4ExceptionDescription ed;
      ed << " G4UCNBoundaryProcess/PostStepDoIt(): "
         << " The Navigator reports that it returned an invalid normal"
         << G4endl;
      G4Exception("G4UCNBoundaryProcess::PostStepDoIt", "UCNBoun01",
                  EventMustBeAborted,ed,
                  "Invalid Surface Normal - Geometry must return valid surface normal");
   }
 
   const G4DynamicParticle* aParticle = aTrack.GetDynamicParticle();
 
   G4ThreeVector OldMomentum = aParticle->GetMomentumDirection();
 
   if (OldMomentum * theGlobalNormal > 0.0) {
 #ifdef G4OPTICAL_DEBUG
      G4ExceptionDescription ed;
      ed << " G4UCNBoundaryProcess/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("G4UCNBoundaryProcess::PostStepDoIt", "UCNBoun02",
                  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
   }
 
   G4ThreeVector theNeutronMomentum = aTrack.GetMomentum();
 
   G4double theMomentumNormal = theNeutronMomentum*theGlobalNormal;
   G4double theVelocityNormal = aTrack.GetVelocity() * 
                                              (OldMomentum * theGlobalNormal);
 
   G4double Enormal = theMomentumNormal*theMomentumNormal/2./neutron_mass_c2;
   G4double Energy  = aTrack.GetKineticEnergy();
    
   G4double FermiPot2  = 0.;
   G4double pDiffuse   = 0.;
   G4double pSpinFlip  = 0.;
   G4double pUpScatter = 0.;
 
   if (aMaterialPropertiesTable2) {
      FermiPot2  = aMaterialPropertiesTable2->GetConstProperty("FERMIPOT")*neV;
      pDiffuse   = aMaterialPropertiesTable2->GetConstProperty("DIFFUSION");
      pSpinFlip  = aMaterialPropertiesTable2->GetConstProperty("SPINFLIP");
      pUpScatter = aMaterialPropertiesTable2->GetConstProperty("LOSS");
   }
 
   G4double FermiPot1 = 0.;
   if (aMaterialPropertiesTable1)
      FermiPot1 = aMaterialPropertiesTable1->GetConstProperty("FERMIPOT")*neV;
 
   G4double FermiPotDiff = FermiPot2 - FermiPot1;
 
   if ( verboseLevel > 1 )
      G4cout << "UCNBoundaryProcess: new FermiPot: " << FermiPot2/neV 
             << "neV, old FermiPot:" << FermiPot1/neV << "neV" << G4endl;
   
   // Use microroughness diffuse reflection behavior if activated
 
   DoMicroRoughnessReflection = UseMicroRoughnessReflection;
 
   G4double theta_i = 0.;
 
   if (!aMaterialPropertiesTable2) {
 
      nNoMPT++;
      theStatus = NoMPT;
      if ( verboseLevel > 0 ) BoundaryProcessVerbose();
      DoMicroRoughnessReflection = false;
 
   } else {
 
       if (!aMaterialPropertiesTable2->GetMicroRoughnessTable()) {
 
          nNoMRT++;
          theStatus = NoMRT;
          if ( verboseLevel > 0 ) BoundaryProcessVerbose();
 
          DoMicroRoughnessReflection = false;
       }
 
       // Angle theta_in between surface and momentum direction,
       // Phi_in is defined to be 0
 
       theta_i = OldMomentum.angle(-theGlobalNormal);
 
       // Checks the MR-conditions
 
       if (!aMaterialPropertiesTable2-> 
                     ConditionsValid(Energy, FermiPotDiff, theta_i)) {
 
          nNoMRCondition++;
          theStatus = NoMRCondition;
          if ( verboseLevel > 0 ) BoundaryProcessVerbose();
 
           DoMicroRoughnessReflection = false;
       }
   }
 
   G4double MRpDiffuse = 0.;
   G4double MRpDiffuseTrans = 0.;
 
   // If microroughness is available and active for material in question
 
   if (DoMicroRoughnessReflection) {
 
       // Integral probability for non-specular reflection with microroughness
 
       MRpDiffuse = aMaterialPropertiesTable2->
                                           GetMRIntProbability(theta_i, Energy);
 
       // Integral probability for non-specular transmission with microroughness
 
       MRpDiffuseTrans = aMaterialPropertiesTable2->
                                      GetMRIntTransProbability(theta_i, Energy);
 
       if ( verboseLevel > 1 ) {
          G4cout << "theta: " << theta_i/degree << "degree" << G4endl;
          G4cout << "Energy: " << Energy/neV << "neV"
                 << ", Enormal: " << Enormal/neV << "neV" << G4endl;
          G4cout << "FermiPotDiff: " << FermiPotDiff/neV << "neV " << G4endl;
          G4cout << "Reflection_prob: " << MRpDiffuse 
                 << ", Transmission_prob: " << MRpDiffuseTrans << G4endl;
       }
   }
 
   if (!High(Enormal, FermiPotDiff)) {
 
      // Below critical velocity
 
      if (verboseLevel > 0) G4cout << "G4UCNBoundaryProcess -> BELOW critical velocity" << G4endl;
 
      // Loss on reflection
 
      if (Loss(pUpScatter, theVelocityNormal, FermiPotDiff)) {
 
         // kill it.
         aParticleChange.ProposeTrackStatus(fStopAndKill);
         aParticleChange.ProposeLocalEnergyDeposit(Energy);
 
         nAbsorption++;
         theStatus = Absorption;
         if ( verboseLevel > 0 ) BoundaryProcessVerbose();
 
         return G4VDiscreteProcess::PostStepDoIt(aTrack, aStep);
      }
 
      // spinflips
 
      if (SpinFlip(pSpinFlip)) {
         nFlip++;
         theStatus = Flip;
         if ( verboseLevel > 0 ) BoundaryProcessVerbose();
 
         G4ThreeVector NewPolarization = -1. * aParticle->GetPolarization();
         aParticleChange.ProposePolarization(NewPolarization);
      }
 
      // Reflect from surface
 
      G4ThreeVector NewMomentum;
 
      // If microroughness is available and active - do non-specular reflection
 
      if (DoMicroRoughnessReflection)
         NewMomentum = MRreflect(MRpDiffuse, OldMomentum, theGlobalNormal,
                                 Energy, FermiPotDiff);
      else
 
         // Else do it with the Lambert model as implemented by Peter Fierlinger
 
         NewMomentum = Reflect(pDiffuse, OldMomentum, theGlobalNormal);
 
      aParticleChange.ProposeMomentumDirection(NewMomentum);
     
   } else {
 
      // Above critical velocity
 
      if (verboseLevel > 0) G4cout << "G4UCNBoundaryProcess -> ABOVE critical velocity" << G4endl;
 
      // If it is faster than the criticial velocity,
      // there is a probability to be still reflected.
      // This formula is (only) valid for low loss materials
 
      // If microroughness available and active, do reflection with it
 
      G4ThreeVector NewMomentum;
 
      if (DoMicroRoughnessReflection) {
 
         G4double Enew;
 
         NewMomentum = 
                MRreflectHigh(MRpDiffuse, MRpDiffuseTrans, 0., OldMomentum,
                              theGlobalNormal, Energy, FermiPotDiff, Enew);
 
         if (Enew == 0.) {
           aParticleChange.ProposeTrackStatus(fStopAndKill);
           aParticleChange.ProposeLocalEnergyDeposit(Energy);
           return G4VDiscreteProcess::PostStepDoIt(aTrack, aStep);
         } else {
           aParticleChange.ProposeEnergy(Enew);
           aParticleChange.ProposeMomentumDirection(NewMomentum);
           aParticleChange.ProposeVelocity(sqrt(2*Enew/neutron_mass_c2)*c_light);
           aParticleChange.ProposeLocalEnergyDeposit(Energy-Enew);
         }
 
      } else {
 
         G4double reflectivity = Reflectivity(FermiPotDiff, Enormal);
 
         if ( verboseLevel > 1 ) G4cout << "UCNBoundaryProcess: reflectivity "
                                        << reflectivity << G4endl;
 
         if (G4UniformRand() < reflectivity) { 
 
           // Reflect from surface
 
           NewMomentum = Reflect(pDiffuse, OldMomentum, theGlobalNormal);
           aParticleChange.ProposeMomentumDirection(NewMomentum);
 
         } else {
 
           // --- Transmission because it is faster than the critical velocity 
 
           G4double Enew = Transmit(FermiPotDiff, Energy);
 
           // --- Change of the normal momentum component
           //     p = sqrt(2*m*Ekin)
 
           G4double mass = -std::sqrt(theMomentumNormal*theMomentumNormal - 
                                 neutron_mass_c2*2.*FermiPotDiff);
 
           // --- Momentum direction in new media
 
           NewMomentum = 
                theNeutronMomentum - (theMomentumNormal-mass)*theGlobalNormal;
 
           nSnellTransmit++;
           theStatus = SnellTransmit;
           if ( verboseLevel > 0 ) BoundaryProcessVerbose();
 
           aParticleChange.ProposeEnergy(Enew);
           aParticleChange.ProposeMomentumDirection(NewMomentum.unit());
           aParticleChange.ProposeVelocity(sqrt(2*Enew/neutron_mass_c2)*c_light);
           aParticleChange.ProposeLocalEnergyDeposit(Energy-Enew);
 
           if (verboseLevel > 1) { 
              G4cout << "Energy: " << Energy/neV << "neV, Enormal: " 
                     << Enormal/neV << "neV, fpdiff " << FermiPotDiff/neV 
                     << "neV, Enew " << Enew/neV << "neV" << G4endl;
          G4cout << "UCNBoundaryProcess: Transmit and set the new Energy "
                     << aParticleChange.GetEnergy()/neV << "neV" << G4endl;
           }
         }
      }
   }
 
   return G4VDiscreteProcess::PostStepDoIt(aTrack, aStep);
 }

Here is the call graph for this function:

◆ Reflect()

G4ThreeVector G4UCNBoundaryProcess::Reflect	(	G4double	pDiffuse,
		G4ThreeVector	OldMomentum,
		G4ThreeVector	Normal
	)

private

Definition at line 512 of file G4UCNBoundaryProcess.cc.

 {
   G4double PdotN = OldMomentum * Normal;
 
   G4ThreeVector NewMomentum = OldMomentum - (2.*PdotN)*Normal;
   NewMomentum.unit();
 
   // Reflect diffuse
 
   if (NewMomentum == OldMomentum || G4UniformRand() < pDiffuse) {
 
      NewMomentum = LDiffRefl(Normal);
 
      bLambertianReflection++;
      theStatus = LambertianReflection;
      if ( verboseLevel > 0 ) BoundaryProcessVerbose();
 
      return NewMomentum;
   }
 
   // Reflect specular
 
   bSpecularReflection++;
   theStatus = SpecularReflection;
   if ( verboseLevel > 0 ) BoundaryProcessVerbose();
 
   return NewMomentum;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Reflectivity()

G4double G4UCNBoundaryProcess::Reflectivity	(	G4double	FermiPot,
		G4double	Enormal
	)

private

Definition at line 504 of file G4UCNBoundaryProcess.cc.

 {
   G4double r = (std::sqrt(Enormal) - std::sqrt(Enormal - FermiPot)) /
                (std::sqrt(Enormal) + std::sqrt(Enormal - FermiPot));
 
   return r*r;
 } 

Here is the caller graph for this function:

◆ SetMaterialPropertiesTable1()

void G4UCNBoundaryProcess::SetMaterialPropertiesTable1 ( G4UCNMaterialPropertiesTable * MPT )

inline

Definition at line 206 of file G4UCNBoundaryProcess.hh.

207 {aMaterialPropertiesTable1 = MPT;}

G4UCNBoundaryProcess::aMaterialPropertiesTable1

G4UCNMaterialPropertiesTable * aMaterialPropertiesTable1

Definition: G4UCNBoundaryProcess.hh:136

◆ SetMaterialPropertiesTable2()

void G4UCNBoundaryProcess::SetMaterialPropertiesTable2 ( G4UCNMaterialPropertiesTable * MPT )

inline

Definition at line 209 of file G4UCNBoundaryProcess.hh.

210 {aMaterialPropertiesTable2 = MPT;}

G4UCNBoundaryProcess::aMaterialPropertiesTable2

G4UCNMaterialPropertiesTable * aMaterialPropertiesTable2

Definition: G4UCNBoundaryProcess.hh:138

◆ SetMicroRoughness()

void G4UCNBoundaryProcess::SetMicroRoughness ( G4bool active )

inline

Definition at line 242 of file G4UCNBoundaryProcess.hh.

 {
    UseMicroRoughnessReflection = active;
 }

Here is the caller graph for this function:

◆ SpinFlip()

G4bool G4UCNBoundaryProcess::SpinFlip ( G4double pSpinFlip )

private

Definition at line 499 of file G4UCNBoundaryProcess.cc.

 {
   return (G4UniformRand() <= pSpinFlip);
 }

Here is the caller graph for this function:

◆ Transmit()

G4double G4UCNBoundaryProcess::Transmit	(	G4double	FermiPot,
		G4double	Energy
	)

private

Definition at line 856 of file G4UCNBoundaryProcess.cc.

 {
   return (Energy - FermiPot);
 }

Here is the caller graph for this function:

Member Data Documentation

◆ aMaterialPropertiesTable1

G4UCNMaterialPropertiesTable* G4UCNBoundaryProcess::aMaterialPropertiesTable1

private

Definition at line 136 of file G4UCNBoundaryProcess.hh.

◆ aMaterialPropertiesTable2

G4UCNMaterialPropertiesTable* G4UCNBoundaryProcess::aMaterialPropertiesTable2

private

Definition at line 138 of file G4UCNBoundaryProcess.hh.

◆ aMRDiffuseReflection

G4int G4UCNBoundaryProcess::aMRDiffuseReflection

private

Definition at line 191 of file G4UCNBoundaryProcess.hh.

◆ aMRDiffuseTransmit

G4int G4UCNBoundaryProcess::aMRDiffuseTransmit

private

Definition at line 193 of file G4UCNBoundaryProcess.hh.

◆ aSpecularReflection

G4int G4UCNBoundaryProcess::aSpecularReflection

private

Definition at line 189 of file G4UCNBoundaryProcess.hh.

◆ bLambertianReflection

G4int G4UCNBoundaryProcess::bLambertianReflection

private

Definition at line 190 of file G4UCNBoundaryProcess.hh.

◆ bMRDiffuseReflection

G4int G4UCNBoundaryProcess::bMRDiffuseReflection

private

Definition at line 191 of file G4UCNBoundaryProcess.hh.

◆ bSpecularReflection

G4int G4UCNBoundaryProcess::bSpecularReflection

private

Definition at line 189 of file G4UCNBoundaryProcess.hh.

◆ DoMicroRoughnessReflection

G4bool G4UCNBoundaryProcess::DoMicroRoughnessReflection

private

Definition at line 141 of file G4UCNBoundaryProcess.hh.

◆ fMessenger

G4UCNBoundaryProcessMessenger* G4UCNBoundaryProcess::fMessenger

private

Definition at line 124 of file G4UCNBoundaryProcess.hh.

◆ fphi_o

G4double G4UCNBoundaryProcess::fphi_o

private

Definition at line 195 of file G4UCNBoundaryProcess.hh.

◆ ftheta_o

G4double G4UCNBoundaryProcess::ftheta_o

private

Definition at line 195 of file G4UCNBoundaryProcess.hh.

◆ kCarTolerance

G4double G4UCNBoundaryProcess::kCarTolerance

private

Definition at line 128 of file G4UCNBoundaryProcess.hh.

◆ Material1

G4Material* G4UCNBoundaryProcess::Material1

private

Definition at line 132 of file G4UCNBoundaryProcess.hh.

◆ Material2

G4Material* G4UCNBoundaryProcess::Material2

private

Definition at line 133 of file G4UCNBoundaryProcess.hh.

◆ mSnellTransmit

G4int G4UCNBoundaryProcess::mSnellTransmit

private

Definition at line 192 of file G4UCNBoundaryProcess.hh.

◆ nAbsorption

G4int G4UCNBoundaryProcess::nAbsorption

private

Definition at line 188 of file G4UCNBoundaryProcess.hh.

◆ neV

G4double G4UCNBoundaryProcess::neV

private

Definition at line 126 of file G4UCNBoundaryProcess.hh.

◆ nEzero

G4int G4UCNBoundaryProcess::nEzero

private

Definition at line 188 of file G4UCNBoundaryProcess.hh.

◆ nFlip

G4int G4UCNBoundaryProcess::nFlip

private

Definition at line 188 of file G4UCNBoundaryProcess.hh.

◆ nNoMPT

G4int G4UCNBoundaryProcess::nNoMPT

private

Definition at line 187 of file G4UCNBoundaryProcess.hh.

◆ nNoMRCondition

G4int G4UCNBoundaryProcess::nNoMRCondition

private

Definition at line 187 of file G4UCNBoundaryProcess.hh.

◆ nNoMRT

G4int G4UCNBoundaryProcess::nNoMRT

private

Definition at line 187 of file G4UCNBoundaryProcess.hh.

◆ nSnellTransmit

G4int G4UCNBoundaryProcess::nSnellTransmit

private

Definition at line 192 of file G4UCNBoundaryProcess.hh.

◆ theStatus

G4UCNBoundaryProcessStatus G4UCNBoundaryProcess::theStatus

private

Definition at line 130 of file G4UCNBoundaryProcess.hh.

◆ UseMicroRoughnessReflection

G4bool G4UCNBoundaryProcess::UseMicroRoughnessReflection

private

Definition at line 140 of file G4UCNBoundaryProcess.hh.

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

Private Attributes
G4UCNBoundaryProcessMessenger *	fMessenger

G4double	neV

G4double	kCarTolerance

G4UCNBoundaryProcessStatus	theStatus

G4Material *	Material1

G4Material *	Material2

G4UCNMaterialPropertiesTable *	aMaterialPropertiesTable1

G4UCNMaterialPropertiesTable *	aMaterialPropertiesTable2

G4bool	UseMicroRoughnessReflection

G4bool	DoMicroRoughnessReflection

G4int	nNoMPT

G4int	nNoMRT

G4int	nNoMRCondition

G4int	nAbsorption

G4int	nEzero

G4int	nFlip

G4int	aSpecularReflection

G4int	bSpecularReflection

G4int	bLambertianReflection

G4int	aMRDiffuseReflection

G4int	bMRDiffuseReflection

G4int	nSnellTransmit

G4int	mSnellTransmit

G4int	aMRDiffuseTransmit

G4double	ftheta_o

G4double	fphi_o

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ G4UCNBoundaryProcess() [1/2]

◆ ~G4UCNBoundaryProcess()

◆ G4UCNBoundaryProcess() [2/2]

Member Function Documentation

◆ BoundaryProcessSummary()

◆ BoundaryProcessVerbose()

◆ GetCoordinateTransformMatrix()

◆ GetMeanFreePath()

◆ GetMicroRoughness()

◆ GetPhi_o()

◆ GetStatus()

◆ GetTheta_o()

◆ High()

◆ InvokeSD()

◆ IsApplicable()

◆ LDiffRefl()

◆ Loss()

◆ MRDiffRefl()

◆ MRDiffTrans()

◆ MRreflect()

◆ MRreflectHigh()

◆ operator=()

◆ PostStepDoIt()

◆ Reflect()

◆ Reflectivity()

◆ SetMaterialPropertiesTable1()

◆ SetMaterialPropertiesTable2()

◆ SetMicroRoughness()

◆ SpinFlip()

◆ Transmit()

Member Data Documentation

◆ aMaterialPropertiesTable1

◆ aMaterialPropertiesTable2

◆ aMRDiffuseReflection

◆ aMRDiffuseTransmit

◆ aSpecularReflection

◆ bLambertianReflection

◆ bMRDiffuseReflection

◆ bSpecularReflection

◆ DoMicroRoughnessReflection

◆ fMessenger

◆ fphi_o

◆ ftheta_o

◆ kCarTolerance

◆ Material1

◆ Material2

◆ mSnellTransmit

◆ nAbsorption

◆ neV

◆ nEzero

◆ nFlip

◆ nNoMPT

◆ nNoMRCondition

◆ nNoMRT

◆ nSnellTransmit

◆ theStatus

◆ UseMicroRoughnessReflection