G4UCNBoundaryProcess Class Reference

#include <G4UCNBoundaryProcess.hh>

Inheritance 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 &aName, G4ProcessType aType=fNotDefined)
	G4VDiscreteProcess (G4VDiscreteProcess &)
virtual	~G4VDiscreteProcess ()
G4VDiscreteProcess &	operator= (const G4VDiscreteProcess &)=delete
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 &)
virtual G4double	GetCrossSection (const G4double, const G4MaterialCutsCouple *)
virtual G4double	MinPrimaryEnergy (const G4ParticleDefinition *, const G4Material *)
Public Member Functions inherited from G4VProcess
	G4VProcess (const G4String &aName="NoName", G4ProcessType aType=fNotDefined)
	G4VProcess (const G4VProcess &right)
virtual	~G4VProcess ()
G4VProcess &	operator= (const G4VProcess &)=delete
G4bool	operator== (const G4VProcess &right) const
G4bool	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 const G4VProcess *	GetCreatorProcess () const
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
virtual void	ProcessDescription (std::ostream &outfile) 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 &)

Additional Inherited Members
Static Public Member Functions inherited from G4VProcess
static const G4String &	GetProcessTypeName (G4ProcessType)
Protected Member Functions inherited from G4VDiscreteProcess
Protected Member Functions inherited from G4VProcess
void	SubtractNumberOfInteractionLengthLeft (G4double prevStepSize)
void	ClearNumberOfInteractionLengthLeft ()
Protected Attributes inherited from G4VProcess
const G4ProcessManager *	aProcessManager = nullptr
G4VParticleChange *	pParticleChange = nullptr
G4ParticleChange	aParticleChange
G4double	theNumberOfInteractionLengthLeft = -1.0
G4double	currentInteractionLength = -1.0
G4double	theInitialNumberOfInteractionLength = -1.0
G4String	theProcessName
G4String	thePhysicsTableFileName
G4ProcessType	theProcessType = fNotDefined
G4int	theProcessSubType = -1
G4double	thePILfactor = 1.0
G4int	verboseLevel = 0
G4bool	enableAtRestDoIt = true
G4bool	enableAlongStepDoIt = true
G4bool	enablePostStepDoIt = true

Detailed Description

Definition at line 82 of file G4UCNBoundaryProcess.hh.

Constructor & Destructor Documentation

G4UCNBoundaryProcess()

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

Definition at line 67 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;
}

~G4UCNBoundaryProcess()

G4UCNBoundaryProcess::~G4UCNBoundaryProcess ( )

virtual

Definition at line 104 of file G4UCNBoundaryProcess.cc.

{
   delete fMessenger;
} 

Member Function Documentation

BoundaryProcessSummary()

void G4UCNBoundaryProcess::BoundaryProcessSummary

(

void

)

const

Definition at line 943 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;
}

GetMeanFreePath()

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

virtual

Implements G4VDiscreteProcess.

Definition at line 456 of file G4UCNBoundaryProcess.cc.

{
  *condition = Forced;
 
  return DBL_MAX;
}

GetMicroRoughness()

G4bool G4UCNBoundaryProcess::GetMicroRoughness ( )

inline

Definition at line 247 of file G4UCNBoundaryProcess.hh.

{
  return UseMicroRoughnessReflection;
}

GetPhi_o()

G4double G4UCNBoundaryProcess::GetPhi_o ( )

inline

Definition at line 212 of file G4UCNBoundaryProcess.hh.

{return fphi_o;};

GetStatus()

G4UCNBoundaryProcessStatus G4UCNBoundaryProcess::GetStatus ( ) const

inline

Definition at line 227 of file G4UCNBoundaryProcess.hh.

{
  return theStatus;
}

GetTheta_o()

G4double G4UCNBoundaryProcess::GetTheta_o ( )

inline

Definition at line 211 of file G4UCNBoundaryProcess.hh.

{return ftheta_o;};

IsApplicable()

G4bool G4UCNBoundaryProcess::IsApplicable ( const G4ParticleDefinition & aParticleType )

inlinevirtual

Reimplemented from G4VProcess.

Definition at line 221 of file G4UCNBoundaryProcess.hh.

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

MRreflect()

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

Definition at line 542 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;
  }
}

Referenced by PostStepDoIt().

MRreflectHigh()

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

Definition at line 586 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();
}

Referenced by PostStepDoIt().

PostStepDoIt()

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

virtual

Reimplemented from G4VDiscreteProcess.

Definition at line 110 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(std::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(std::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);
}

SetMaterialPropertiesTable1()

void G4UCNBoundaryProcess::SetMaterialPropertiesTable1 ( G4UCNMaterialPropertiesTable * MPT )

inline

Definition at line 205 of file G4UCNBoundaryProcess.hh.

             {aMaterialPropertiesTable1 = MPT;}

SetMaterialPropertiesTable2()

void G4UCNBoundaryProcess::SetMaterialPropertiesTable2 ( G4UCNMaterialPropertiesTable * MPT )

inline

Definition at line 208 of file G4UCNBoundaryProcess.hh.

             {aMaterialPropertiesTable2 = MPT;}

SetMicroRoughness()

void G4UCNBoundaryProcess::SetMicroRoughness ( G4bool active )

inline

Definition at line 241 of file G4UCNBoundaryProcess.hh.

{
   UseMicroRoughnessReflection = active;
}

---

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

• G4UCNBoundaryProcess.hh
• G4UCNBoundaryProcess.cc