G4XrayReflection Class Reference

#include <G4XrayReflection.hh>

Inheritance diagram for G4XrayReflection:

Public Member Functions
	G4XrayReflection (const G4String &processName="XrayReflection", G4ProcessType type=fElectromagnetic)
	~G4XrayReflection () override=default
G4double	GetMeanFreePath (const G4Track &track, G4double previousStepSize, G4ForceCondition *condition) override
G4VParticleChange *	PostStepDoIt (const G4Track &track, const G4Step &Step) override
G4bool	IsApplicable (const G4ParticleDefinition &) override
void	BuildPhysicsTable (const G4ParticleDefinition &) override
void	ProcessDescription (std::ostream &) const override
void	DumpInfo () const override
void	SetSurfaceRoughness (const G4double value)
G4double	Reflectivity (const G4double GamEner, const G4double SinIncidentAngle, const G4Material *theMat) const
G4int	ReadHenkeXrayData (std::string ElName, std::vector< G4double > &Ephot, std::vector< G4double > &f1, std::vector< G4double > &f2)
void	SaveHenkeDataAsMaterialProperty ()
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	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
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 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 46 of file G4XrayReflection.hh.

Constructor & Destructor Documentation

G4XrayReflection()

G4XrayReflection::G4XrayReflection ( const G4String & processName = "XrayReflection", G4ProcessType type = fElectromagnetic )

explicit

Definition at line 49 of file G4XrayReflection.cc.

  : G4VDiscreteProcess(processName, type)
{
  SetProcessSubType(fGammaReflection);
  SaveHenkeDataAsMaterialProperty();
}

~G4XrayReflection()

G4XrayReflection::~G4XrayReflection ( )

overridedefault

Member Function Documentation

BuildPhysicsTable()

void G4XrayReflection::BuildPhysicsTable ( const G4ParticleDefinition & part )

overridevirtual

Reimplemented from G4VProcess.

Definition at line 197 of file G4XrayReflection.cc.

{
  ProcessDescription(G4cout);
 
  if (GetVerboseLevel() > 2)
    G4cout << std::left << std::setw(12) << __FILE__ << " " << __FUNCTION__ << " line "
           << std::right << std::setw(4) << __LINE__
           << " is gamma=" << (&part == G4Gamma::Definition())
           << " fSurfaceRoughness=" << G4BestUnit(fSurfaceRoughness, "Length") << G4endl;
}

DumpInfo()

void G4XrayReflection::DumpInfo ( ) const

inlineoverridevirtual

Reimplemented from G4VProcess.

Definition at line 62 of file G4XrayReflection.hh.

{ ProcessDescription(G4cout); }

GetMeanFreePath()

G4double G4XrayReflection::GetMeanFreePath ( const G4Track & track, G4double previousStepSize, G4ForceCondition * condition )

overridevirtual

Implements G4VDiscreteProcess.

Definition at line 110 of file G4XrayReflection.cc.

{
  *condition = NotForced;
  G4double GamEner = aTrack.GetDynamicParticle()->GetTotalEnergy();
  if (GamEner < 30. * eV || GamEner > 30. * keV)
    return DBL_MAX;  // do nothing below and above the limits
 
  if (GetVerboseLevel() > 2)
    G4cout << std::left << std::setw(12) << __FILE__ << " " << __FUNCTION__ << " line "
           << std::right << std::setw(4) << __LINE__ << " GamEner=" << GamEner / keV
           << " keV previousStepSize=" << previousStepSize
           << " TrackLength=" << aTrack.GetTrackLength() << " StepLength=" << aTrack.GetStepLength()
           << G4endl;
 
  G4double MeanFreePath = DBL_MAX;  // by default no reflection
  G4VPhysicalVolume* Volume = aTrack.GetVolume();
  if (fLastVolume && Volume != fLastVolume && aTrack.GetTrackLength() > 0) {  // at a boundary
    const G4Material* theLastMat = fLastVolume->GetLogicalVolume()->GetMaterial();
    const G4Material* theMat = Volume->GetLogicalVolume()->GetMaterial();
 
    G4double last_density = theLastMat->GetDensity();
    G4double density = theMat->GetDensity();
    if (density > last_density) {  // density has increased
      G4Navigator* theNavigator =
        G4TransportationManager::GetTransportationManager()->GetNavigatorForTracking();
      G4bool valid = false;
      G4ThreeVector theSurfaceNormal =
        theNavigator->GetGlobalExitNormal(aTrack.GetPosition(), &valid);
      if (valid) fSurfaceNormal = theSurfaceNormal;
      G4double SinIncidentAngle =
        aTrack.GetDynamicParticle()->GetMomentumDirection() * fSurfaceNormal;
      if (G4UniformRand() < Reflectivity(GamEner, SinIncidentAngle, theMat)) {
        MeanFreePath = 0;
      }
      G4ThreeVector Position = aTrack.GetPosition();  // only for info
      const G4VSolid* LastSolid_Volume = fLastVolume->GetLogicalVolume()->GetSolid();  // for info
      if (GetVerboseLevel() > 1 && MeanFreePath == 0)
        G4cout << std::left << std::setw(12) << __FILE__ << " " << __FUNCTION__ << " line "
               << std::right << std::setw(4) << __LINE__
               << " trigger reflection SinIncidentAngle=" << SinIncidentAngle
               << " at z=" << Position.getZ() / meter << " m" << G4endl;
      else if (GetVerboseLevel() > 2)
        G4cout << std::left << std::setw(12) << __FILE__ << " " << __FUNCTION__ << " line "
               << std::right << std::setw(4) << __LINE__ << " volume has changed "
               << " last logical volume name =" << fLastVolume->GetLogicalVolume()->GetName()
               << " last logical volume material name =" << theLastMat->GetName()
               << " last density=" << last_density << " part/cm3 ? "
               << " logical volume name =" << Volume->GetLogicalVolume()->GetName()
               << " logical volume material name =" << theMat->GetName() << " density=" << density
               << " part/cm3 ? "
               << " LastSolid_Volume->Inside(Position)=" << LastSolid_Volume->Inside(Position)
               << " sin(IncidentAngle)=" << SinIncidentAngle << " MeanFreePath=" << MeanFreePath
               << G4endl;
    }
  }
  fLastVolume = Volume;
  return MeanFreePath;
}

IsApplicable()

G4bool G4XrayReflection::IsApplicable ( const G4ParticleDefinition & particle )

overridevirtual

Reimplemented from G4VProcess.

Definition at line 59 of file G4XrayReflection.cc.

{
  return (&particle == G4Gamma::Gamma());  // apply only to gamma
}

PostStepDoIt()

G4VParticleChange * G4XrayReflection::PostStepDoIt ( const G4Track & track, const G4Step & Step )

overridevirtual

Reimplemented from G4VDiscreteProcess.

Definition at line 172 of file G4XrayReflection.cc.

{
  aParticleChange.Initialize(aTrack);  // copy the current position to the changed particle
  G4ThreeVector PhotDir = aTrack.GetDynamicParticle()->GetMomentumDirection();
  G4ThreeVector para_part = (PhotDir * fSurfaceNormal) * fSurfaceNormal;
  G4ThreeVector photon_reflected = PhotDir - 2 * para_part;  // invert the parallel component
  if (GetVerboseLevel() > 1)
    G4cout << std::left << std::setw(12) << __FILE__ << " " << __FUNCTION__ << " line "
           << std::right << std::setw(4) << __LINE__ << " fSurfaceNormal=" << fSurfaceNormal
           << " StepLength=" << aStep.GetStepLength() << " PhotDir=" << PhotDir
           << " photon_reflected=" << photon_reflected << " para_part=" << para_part
           << " aParticleChange.GetTrackStatus()=" << aParticleChange.GetTrackStatus()
           << G4endl;
 
  aParticleChange.ProposeTrackStatus(
    fStopAndKill);  // needed when working with primary gamma to get rid of
  // primary
  auto ReflectedPhoton = new G4DynamicParticle(G4Gamma::Gamma(), photon_reflected,
                                               aTrack.GetDynamicParticle()->GetTotalEnergy());
  aParticleChange.AddSecondary(ReflectedPhoton);
  return &aParticleChange;
}

ProcessDescription()

void G4XrayReflection::ProcessDescription ( std::ostream & out ) const

overridevirtual

Reimplemented from G4VProcess.

Definition at line 210 of file G4XrayReflection.cc.

{
  if (G4Threading::IsMasterThread())
    out << '\n' << GetProcessName() << ": Gamma specular reflection for energies > 30 eV.\n";
}

Referenced by BuildPhysicsTable(), and DumpInfo().

ReadHenkeXrayData()

G4int G4XrayReflection::ReadHenkeXrayData	(	std::string	ElName,
		std::vector< G4double > &	Ephot,
		std::vector< G4double > &	f1,
		std::vector< G4double > &	f2 )

Definition at line 218 of file G4XrayReflection.cc.

{
  std::transform(ElName.begin(), ElName.end(), ElName.begin(),
                 ::tolower);  // henke_physical_reference uses lower case filanames
  const G4String DataDir = G4EmParameters::Instance()->GetDirLEDATA() + "/XRayReflection_data/";
  const G4String InpFname = DataDir + ElName + ".nff";
  std::ifstream infile(InpFname);
  if (!infile.is_open()) {
    G4cout << "ReadHenkeXrayReflData " << InpFname << " not found" << G4endl;
    return 1;  // failure
  }
  std::vector<std::string> VarName(3);
  infile >> VarName[0] >> VarName[1] >> VarName[2];
  if (GetVerboseLevel())
    G4cout << "ReadHenkeXrayData variable names " << VarName[0] << " " << VarName[1] << " "
           << VarName[2] << G4endl;
  G4double E_eV_i, f1_i, f2_i;
  Ephot.resize(0);
  f1.resize(0);
  f2.resize(0);
  for (;;) {
    infile >> E_eV_i >> f1_i >> f2_i;
    if (infile.eof()) break;
    Ephot.push_back(E_eV_i * eV);
    f1.push_back(f1_i);
    f2.push_back(f2_i);
  }
  return 0;  // success
}

Referenced by SaveHenkeDataAsMaterialProperty().

Reflectivity()

G4double G4XrayReflection::Reflectivity	(	const G4double	GamEner,
		const G4double	SinIncidentAngle,
		const G4Material *	theMat ) const

Definition at line 66 of file G4XrayReflection.cc.

{
  G4double theReflectivity = 0;
  const G4MaterialPropertiesTable* theMatProp = theMat->GetMaterialPropertiesTable();
  if (SinIncidentAngle < 0.9 && theMatProp != nullptr)
  {  // avoid perpendicular refl. at straight entry  and require
    // data available
    G4MaterialPropertyVector* RealIndex = theMatProp->GetProperty(kREALRINDEX);
    G4MaterialPropertyVector* ImagIndex = theMatProp->GetProperty(kIMAGINARYRINDEX);
    if (nullptr == RealIndex || nullptr == ImagIndex) { return theReflectivity; }
    const G4double delta = RealIndex->Value(GamEner);
    const G4double beta = ImagIndex->Value(GamEner);
    const G4double sin2 = std::pow(SinIncidentAngle, 2);
    const G4double rho2 =
      0.5 * (sin2 - 2 * delta + std::sqrt(std::pow(sin2 - 2 * delta, 2) + 4 * beta * beta));
    const G4double rho = std::sqrt(rho2);
    const G4double Refl_sigma = (rho2 * std::pow(SinIncidentAngle - rho, 2) + std::pow(beta, 2))
                                / (rho2 * std::pow(SinIncidentAngle + rho, 2) + std::pow(beta, 2));
    const G4double coscot = std::sqrt(1 - sin2) / SinIncidentAngle;
    const G4double pi_over_sigma = (rho2 * std::pow(rho - coscot, 2) + std::pow(beta, 2))
                                   / (rho2 * std::pow(rho + coscot, 2) + std::pow(beta, 2));
    const G4double Refl_pi = Refl_sigma * pi_over_sigma;
    theReflectivity = 0.5 * (Refl_sigma + Refl_pi);  // unpolarized
    G4double RoughAtten = 1;
    if (fSurfaceRoughness > 0) {
      G4double kiz = SinIncidentAngle * GamEner / CLHEP::hbarc;
      G4double kjz = SinIncidentAngle * (1 - delta) * GamEner / CLHEP::hbarc;
      RoughAtten = G4Exp(-2 * kiz * kjz * fSurfaceRoughness * fSurfaceRoughness);  // Nevot–Croce
      theReflectivity *= RoughAtten;
    }
    if (GetVerboseLevel() > 1)
      G4cout << std::left << std::setw(12) << __FILE__ << " " << __FUNCTION__ << " line "
             << std::right << std::setw(4) << __LINE__ << " GamEner=" << GamEner
             << " fSurfaceRoughness=" << G4BestUnit(fSurfaceRoughness, "Length")
             << " RoughAtten=" << RoughAtten << " SinIncidentAngle=" << SinIncidentAngle
             << " delta=" << delta << " beta=" << beta << " Refl_sigma=" << Refl_sigma
             << " Refl_pi=" << Refl_pi << " theReflectivity=" << theReflectivity << G4endl;
  }
  return theReflectivity;
}

Referenced by GetMeanFreePath().

SaveHenkeDataAsMaterialProperty()

void G4XrayReflection::SaveHenkeDataAsMaterialProperty

(

)

Definition at line 251 of file G4XrayReflection.cc.

{
  // loop through the material table and load set up MaterialPropertiesTable
  // with Henke data used to calculate the reflection
  auto materialTable = G4Material::GetMaterialTable();
  for (auto a_material : *materialTable) {
    auto N = a_material->GetTotNbOfAtomsPerVolume();
    if (GetVerboseLevel() > 2)
      if (GetVerboseLevel() > 2)
        G4cout << std::left << std::setw(12) << __FILE__ << " " << __FUNCTION__ << " line "
               << std::right << std::setw(4) << __LINE__ << " " << a_material->GetName()
               << " NbOfAtomsPerVolume()=" << N
               << " NumberOfElements()=" << a_material->GetNumberOfElements() << G4endl;
    // calculate the reflectivity from input data. Implemented for dense
    // materials of a single element
    if (a_material->GetNumberOfElements() == 1 && a_material->GetDensity() > 1) {
      G4double factor = N * CLHEP::classic_electr_radius / CLHEP::twopi;
      std::vector<G4double> Ephot, f1, f2;
      const G4Element* theElement = a_material->GetElement(0);
      G4int iret = ReadHenkeXrayData(theElement->GetName(), Ephot, f1, f2);
      if (iret) {
        if (GetVerboseLevel() > 2)
          G4cout << std::left << std::setw(12) << __FILE__ << " " << __FUNCTION__ << " line "
                 << std::right << std::setw(4) << __LINE__ << " no Henke data found for "
                 << a_material->GetName() << " " << theElement->GetName() << G4endl;
      }
      else {
        std::vector<G4double> RealIndex(Ephot.size()), ImagIndex(Ephot.size());
        for (std::size_t i = 0; i < Ephot.size(); ++i) {
          G4double lambda = CLHEP::twopi * CLHEP::hbarc / Ephot[i];
          G4double lambda_sqr = lambda * lambda;
          RealIndex[i] = std::fmax(0, factor * lambda_sqr * f1[i]);  // delta or 1-RealIndex
          ImagIndex[i] = factor * lambda_sqr * f2[i];  // beta  or  -ImagIndex
          if (GetVerboseLevel() > 2)
            G4cout << "Ephot=" << std::setw(10) << Ephot[i] / eV << " eV delta=" << std::setw(10)
                   << RealIndex[i] << " beta=" << std::setw(10) << ImagIndex[i] << G4endl;
        }  // photon energy
        G4MaterialPropertiesTable* proptab = a_material->GetMaterialPropertiesTable();
        if(proptab == nullptr) {
          proptab = new G4MaterialPropertiesTable();
          a_material->SetMaterialPropertiesTable(proptab);
        }
        proptab->AddProperty("REALRINDEX", Ephot, RealIndex);  // 1-RealIndex
        proptab->AddProperty("IMAGINARYRINDEX", Ephot, ImagIndex);
        if (GetVerboseLevel() > 2)
          G4cout << std::left << std::setw(12) << __FILE__ << " " << __FUNCTION__ << " line "
                 << std::right << std::setw(4) << __LINE__ << " " << a_material->GetName()
                 << " " << theElement->GetName()
                 << " reflection data saved in PropertiesTable" << G4endl;
      }  // data found
    }
  }
}

Referenced by G4XrayReflection().

SetSurfaceRoughness()

void G4XrayReflection::SetSurfaceRoughness

(

const G4double

value

)

Definition at line 307 of file G4XrayReflection.cc.

{
  fSurfaceRoughness = value;
}

---

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

• G4XrayReflection.hh
• G4XrayReflection.cc