#include <G4UCNMaterialPropertiesTable.hh>

Inheritance diagram for G4UCNMaterialPropertiesTable:

Public Member Functions
void	AddConstProperty (const char *key, G4double propertyValue, G4bool createNewKey=false)

void	AddConstProperty (const G4String &key, G4double propertyValue, G4bool createNewKey=false)

void	AddEntry (const char *key, G4double aPhotonEnergy, G4double aPropertyValue)

void	AddEntry (const G4String &key, G4double aPhotonEnergy, G4double aPropertyValue)

G4MaterialPropertyVector *	AddProperty (const char key, G4double photonEnergies, G4double *propertyValues, G4int numEntries, G4bool createNewKey=false, G4bool spline=false)

void	AddProperty (const char key, G4MaterialPropertyVector opv, G4bool createNewKey=false)

void	AddProperty (const G4String &key, const G4String &mat)

G4MaterialPropertyVector *	AddProperty (const G4String &key, const std::vector< G4double > &photonEnergies, const std::vector< G4double > &propertyValues, G4bool createNewKey=false, G4bool spline=false)

void	AddProperty (const G4String &key, G4MaterialPropertyVector *opv, G4bool createNewKey=false)

void	ComputeMicroRoughnessTables ()

G4bool	ConditionsValid (G4double E, G4double VFermi, G4double theta_i)

G4bool	ConstPropertyExists (const char *key) const

G4bool	ConstPropertyExists (const G4int index) const

G4bool	ConstPropertyExists (const G4String &key) const

void	DumpTable () const

	G4UCNMaterialPropertiesTable ()

const std::vector< std::pair< G4double, G4bool > > &	GetConstProperties () const

G4double	GetConstProperty (const char *key) const

G4double	GetConstProperty (const G4int index) const

G4double	GetConstProperty (const G4String &key) const

G4int	GetConstPropertyIndex (const G4String &key) const

G4double	GetCorrLen () const

const std::vector< G4String > &	GetMaterialConstPropertyNames () const

const std::vector< G4String > &	GetMaterialPropertyNames () const

G4double *	GetMicroRoughnessTable ()

G4double *	GetMicroRoughnessTransTable ()

G4double	GetMRIntProbability (G4double, G4double)

G4double	GetMRIntTransProbability (G4double, G4double)

G4double	GetMRMaxProbability (G4double, G4double)

G4double	GetMRMaxTransProbability (G4double, G4double)

G4double	GetMRProbability (G4double, G4double, G4double, G4double, G4double)

G4double	GetMRTransProbability (G4double, G4double, G4double, G4double, G4double)

const std::vector< G4MaterialPropertyVector * > &	GetProperties () const

G4MaterialPropertyVector *	GetProperty (const char *key) const

G4MaterialPropertyVector *	GetProperty (const G4int index) const

G4MaterialPropertyVector *	GetProperty (const G4String &key) const

G4int	GetPropertyIndex (const G4String &key) const

G4double	GetRMS () const

void	InitMicroRoughnessTables ()

void	LoadMicroRoughnessTables (G4double , G4double , G4double , G4double )

void	RemoveConstProperty (const char *key)

void	RemoveConstProperty (const G4String &key)

void	RemoveProperty (const char *key)

void	RemoveProperty (const G4String &key)

void	SetMicroRoughnessParameters (G4double, G4double, G4int, G4int, G4double, G4double, G4double, G4double, G4int, G4int, G4double)

void	SetMRMaxProbability (G4double, G4double, G4double)

void	SetMRMaxTransProbability (G4double, G4double, G4double)

G4bool	TransConditionsValid (G4double E, G4double VFermi, G4double theta_i)

virtual	~G4UCNMaterialPropertiesTable ()

Private Member Functions
G4MaterialPropertyVector *	CalculateGROUPVEL ()

Private Attributes
G4double	AngCut

G4double	b

G4double	E_step

G4double	Emax

G4double	Emin

std::vector< G4String >	fMatConstPropNames

std::vector< G4String >	fMatPropNames

std::vector< std::pair< G4double, G4bool > >	fMCP

std::vector< G4MaterialPropertyVector * >	fMP

G4double *	maxMicroRoughnessTable

G4double *	maxMicroRoughnessTransTable

G4int	no_theta_i

G4int	noE

G4double *	theMicroRoughnessTable

G4double *	theMicroRoughnessTransTable

G4double	theta_i_max

G4double	theta_i_min

G4double	theta_i_step

G4double	w

Detailed Description

Definition at line 51 of file G4UCNMaterialPropertiesTable.hh.

Constructor & Destructor Documentation

◆ G4UCNMaterialPropertiesTable()

G4UCNMaterialPropertiesTable::G4UCNMaterialPropertiesTable ( )

Definition at line 53 of file G4UCNMaterialPropertiesTable.cc.

                             : G4MaterialPropertiesTable() 
{
  theMicroRoughnessTable = nullptr;
  maxMicroRoughnessTable = nullptr;
  theMicroRoughnessTransTable = nullptr;
  maxMicroRoughnessTransTable = nullptr;
 
  theta_i_min =  0.*degree;
  theta_i_max = 90.*degree;
 
  Emin =    0.e-9*eV;
  Emax = 1000.e-9*eV;
 
  no_theta_i = 90;
  noE = 100;
 
  theta_i_step = (theta_i_max-theta_i_min)/(no_theta_i-1);
  E_step = (Emax-Emin)/(noE-1);
 
  b =  1*nm;
  w = 30*nm;
 
  AngCut = 0.01*degree;
}

References AngCut, b, degree, E_step, Emax, Emin, eV, maxMicroRoughnessTable, maxMicroRoughnessTransTable, nm, no_theta_i, noE, theMicroRoughnessTable, theMicroRoughnessTransTable, theta_i_max, theta_i_min, theta_i_step, and w.

◆ ~G4UCNMaterialPropertiesTable()

G4UCNMaterialPropertiesTable::~G4UCNMaterialPropertiesTable ( )

virtual

Definition at line 79 of file G4UCNMaterialPropertiesTable.cc.

{
  if (theMicroRoughnessTable)      delete theMicroRoughnessTable;
  if (maxMicroRoughnessTable)      delete maxMicroRoughnessTable;
  if (theMicroRoughnessTransTable) delete theMicroRoughnessTransTable;
  if (maxMicroRoughnessTransTable) delete maxMicroRoughnessTransTable;
}

References maxMicroRoughnessTable, maxMicroRoughnessTransTable, theMicroRoughnessTable, and theMicroRoughnessTransTable.

Member Function Documentation

◆ AddConstProperty() [1/2]

void G4MaterialPropertiesTable::AddConstProperty	(	const char *	key,
		G4double	propertyValue,
		G4bool	createNewKey = `false`
	)

inherited

Definition at line 446 of file G4MaterialPropertiesTable.cc.

{
  // Provides a way of adding a constant property to the Material Properties
  // Table given a key
  AddConstProperty(G4String(key), propertyValue, createNewKey);
}

References G4MaterialPropertiesTable::AddConstProperty().

◆ AddConstProperty() [2/2]

void G4MaterialPropertiesTable::AddConstProperty	(	const G4String &	key,
		G4double	propertyValue,
		G4bool	createNewKey = `false`
	)

inherited

Definition at line 417 of file G4MaterialPropertiesTable.cc.

{
  // Provides a way of adding a constant property to the Material Properties
  // Table given a key
  if(std::find(fMatConstPropNames.begin(), fMatConstPropNames.end(), key) ==
     fMatConstPropNames.end())
  {
    if(createNewKey)
    {
      fMatConstPropNames.push_back(key);
      fMCP.push_back(std::pair<G4double, G4bool>{ 0., true });
    }
    else
    {
      G4ExceptionDescription ed;
      ed << "Attempting to create a new material constant property key " << key
         << " without setting"
         << " createNewKey parameter of AddProperty to true.";
      G4Exception("G4MaterialPropertiesTable::AddProperty()", "mat207",
                  FatalException, ed);
    }
  }
  G4int index = GetConstPropertyIndex(key);
 
  fMCP[index] = std::pair<G4double, G4bool>{ propertyValue, true };
}

References FatalException, G4MaterialPropertiesTable::fMatConstPropNames, G4MaterialPropertiesTable::fMCP, G4Exception(), and G4MaterialPropertiesTable::GetConstPropertyIndex().

Referenced by G4MaterialPropertiesTable::AddConstProperty(), G4GDMLReadMaterials::PropertyRead(), G4GDMLReadSolids::PropertyRead(), and SetMicroRoughnessParameters().

◆ AddEntry() [1/2]

void G4MaterialPropertiesTable::AddEntry	(	const char *	key,
		G4double	aPhotonEnergy,
		G4double	aPropertyValue
	)

inherited

Definition at line 509 of file G4MaterialPropertiesTable.cc.

{
  AddEntry(G4String(key), aPhotonEnergy, aPropertyValue);
}

References G4MaterialPropertiesTable::AddEntry().

◆ AddEntry() [2/2]

void G4MaterialPropertiesTable::AddEntry	(	const G4String &	key,
		G4double	aPhotonEnergy,
		G4double	aPropertyValue
	)

inherited

Definition at line 479 of file G4MaterialPropertiesTable.cc.

{
  // Allows to add an entry pair directly to the Material Property Vector
  // given a key
  if(std::find(fMatPropNames.begin(), fMatPropNames.end(), key) ==
     fMatPropNames.end())
  {
    G4Exception("G4MaterialPropertiesTable::AddEntry()", "mat214",
                FatalException, "Material Property Vector not found.");
  }
  G4int index = GetPropertyIndex(key);
 
  G4MaterialPropertyVector* targetVector = fMP[index];
  if(targetVector != nullptr)
  {
    targetVector->InsertValues(aPhotonEnergy, aPropertyValue);
  }
  else
  {
    G4Exception("G4MaterialPropertiesTable::AddEntry()", "mat208",
                FatalException, "Material Property Vector not found.");
  }
  if(key == "RINDEX")
  {
    CalculateGROUPVEL();
  }
}

References G4MaterialPropertiesTable::CalculateGROUPVEL(), FatalException, G4MaterialPropertiesTable::fMatPropNames, G4MaterialPropertiesTable::fMP, G4Exception(), G4MaterialPropertiesTable::GetPropertyIndex(), and G4PhysicsFreeVector::InsertValues().

Referenced by G4MaterialPropertiesTable::AddEntry().

◆ AddProperty() [1/5]

G4MaterialPropertyVector * G4MaterialPropertiesTable::AddProperty	(	const char *	key,
		G4double *	photonEnergies,
		G4double *	propertyValues,
		G4int	numEntries,
		G4bool	createNewKey = `false`,
		G4bool	spline = `false`
	)

inherited

Definition at line 351 of file G4MaterialPropertiesTable.cc.

{
 
  // Provides a way of adding a property to the Material Properties
  // Table given a pair of arrays and a key
  G4String k(key);
 
  std::vector<G4double> energies(photonEnergies, photonEnergies + numEntries);
  std::vector<G4double> values(propertyValues, propertyValues + numEntries);
  return AddProperty(k, energies, values, createNewKey, spline);
}

References G4MaterialPropertiesTable::AddProperty().

◆ AddProperty() [2/5]

void G4MaterialPropertiesTable::AddProperty	(	const char *	key,
		G4MaterialPropertyVector *	opv,
		G4bool	createNewKey = `false`
	)

inherited

Definition at line 401 of file G4MaterialPropertiesTable.cc.

{
  AddProperty(G4String(key), mpv, createNewKey);
}

References G4MaterialPropertiesTable::AddProperty().

◆ AddProperty() [3/5]

void G4MaterialPropertiesTable::AddProperty	(	const G4String &	key,
		const G4String &	mat
	)

inherited

Definition at line 408 of file G4MaterialPropertiesTable.cc.

{
  // load a material property vector defined in Geant4 source
  G4MaterialPropertyVector* v =
    G4OpticalMaterialProperties::GetProperty(key, mat);
  AddProperty(key, v);
}

References G4MaterialPropertiesTable::AddProperty(), and G4OpticalMaterialProperties::GetProperty().

◆ AddProperty() [4/5]

G4MaterialPropertyVector * G4MaterialPropertiesTable::AddProperty	(	const G4String &	key,
		const std::vector< G4double > &	photonEnergies,
		const std::vector< G4double > &	propertyValues,
		G4bool	createNewKey = `false`,
		G4bool	spline = `false`
	)

inherited

Definition at line 298 of file G4MaterialPropertiesTable.cc.

{
  if(photonEnergies.size() != propertyValues.size())
  {
    G4ExceptionDescription ed;
    ed << "AddProperty error!";
    G4Exception("G4MaterialPropertiesTable::AddProperty()", "mat204",
                FatalException, ed);
  }
 
  // if the key doesn't exist, add it if requested
  if(std::find(fMatPropNames.begin(), fMatPropNames.end(), key) ==
     fMatPropNames.end())
  {
    if(createNewKey)
    {
      fMatPropNames.push_back(key);
      fMP.push_back(nullptr);
    }
    else
    {
      G4ExceptionDescription ed;
      ed << "Attempting to create a new material property key " << key
         << " without setting\n"
         << "createNewKey parameter of AddProperty to true.";
      G4Exception("G4MaterialPropertiesTable::AddProperty()", "mat205",
                  FatalException, ed);
    }
  }
 
  G4MaterialPropertyVector* mpv =
    new G4MaterialPropertyVector(photonEnergies, propertyValues, spline);
  mpv->SetVerboseLevel(1);
  if(spline)
  {
    mpv->FillSecondDerivatives();
  }
  G4int index = GetPropertyIndex(key);
  fMP[index]  = mpv;
 
  // if key is RINDEX, we calculate GROUPVEL -
  // contribution from Tao Lin (IHEP, the JUNO experiment)
  if(key == "RINDEX")
  {
    CalculateGROUPVEL();
  }
 
  return mpv;
}

References G4MaterialPropertiesTable::CalculateGROUPVEL(), FatalException, G4PhysicsVector::FillSecondDerivatives(), G4MaterialPropertiesTable::fMatPropNames, G4MaterialPropertiesTable::fMP, G4Exception(), G4MaterialPropertiesTable::GetPropertyIndex(), and G4PhysicsVector::SetVerboseLevel().

Referenced by G4MaterialPropertiesTable::AddProperty(), G4MaterialPropertiesTable::CalculateGROUPVEL(), G4GDMLReadMaterials::PropertyRead(), and G4GDMLReadSolids::PropertyRead().

◆ AddProperty() [5/5]

void G4MaterialPropertiesTable::AddProperty	(	const G4String &	key,
		G4MaterialPropertyVector *	opv,
		G4bool	createNewKey = `false`
	)

inherited

Definition at line 365 of file G4MaterialPropertiesTable.cc.

{
  //  Provides a way of adding a property to the Material Properties
  //  Table given an G4MaterialPropertyVector Reference and a key
  // if the key doesn't exist, add it
  if(std::find(fMatPropNames.begin(), fMatPropNames.end(), key) ==
     fMatPropNames.end())
  {
    if(createNewKey)
    {
      fMatPropNames.push_back(key);
      fMP.push_back(nullptr);
    }
    else
    {
      G4ExceptionDescription ed;
      ed << "Attempting to create a new material property key " << key
         << " without setting\n"
         << "createNewKey parameter of AddProperty to true.";
      G4Exception("G4MaterialPropertiesTable::AddProperty()", "mat206",
                  FatalException, ed);
    }
  }
  G4int index = GetPropertyIndex(key);
  fMP[index]  = mpv;
 
  // if key is RINDEX, we calculate GROUPVEL -
  // contribution from Tao Lin (IHEP, the JUNO experiment)
  if(key == "RINDEX")
  {
    CalculateGROUPVEL();
  }
}

References G4MaterialPropertiesTable::CalculateGROUPVEL(), FatalException, G4MaterialPropertiesTable::fMatPropNames, G4MaterialPropertiesTable::fMP, G4Exception(), and G4MaterialPropertiesTable::GetPropertyIndex().

◆ CalculateGROUPVEL()

G4MaterialPropertyVector * G4MaterialPropertiesTable::CalculateGROUPVEL ( )

privateinherited

Definition at line 542 of file G4MaterialPropertiesTable.cc.

{
#ifdef G4MULTITHREADED
  G4AutoLock mptm(&materialPropertyTableMutex);
#endif
 
  // check if "GROUPVEL" already exists. If so, remove it.
  if(fMP[kGROUPVEL] != nullptr)
  {
    this->RemoveProperty("GROUPVEL");
  }
 
  // fetch RINDEX data, give up if unavailable
  G4MaterialPropertyVector* rindex = this->GetProperty(kRINDEX);
  if(rindex == nullptr)
  {
    return nullptr;
  }
 
  // RINDEX exists but has no entries, give up
  if(rindex->GetVectorLength() == 0)
  {
    return nullptr;
  }
 
  // add GROUPVEL vector
  G4MaterialPropertyVector* groupvel = new G4MaterialPropertyVector();
  groupvel->SetVerboseLevel(1);
 
  // fill GROUPVEL vector using RINDEX values
  // rindex built-in "iterator" was advanced to first entry above
  G4double E0 = rindex->Energy(0);
  G4double n0 = (*rindex)[0];
 
  if(E0 <= 0.)
  {
    G4Exception("G4MaterialPropertiesTable::CalculateGROUPVEL()", "mat211",
                FatalException, "Optical Photon Energy <= 0");
  }
 
  if(rindex->GetVectorLength() >= 2)
  {
    // good, we have at least two entries in RINDEX
    // get next energy/value pair
 
    G4double E1 = rindex->Energy(1);
    G4double n1 = (*rindex)[1];
 
    if(E1 <= 0.)
    {
      G4Exception("G4MaterialPropertiesTable::CalculateGROUPVEL()", "mat212",
                  FatalException, "Optical Photon Energy <= 0");
    }
 
    G4double vg;
 
    // add entry at first photon energy
    vg = c_light / (n0 + (n1 - n0) / G4Log(E1 / E0));
 
    // allow only for 'normal dispersion' -> dn/d(logE) > 0
    if((vg < 0) || (vg > c_light / n0))
    {
      vg = c_light / n0;
    }
 
    groupvel->InsertValues(E0, vg);
 
    // add entries at midpoints between remaining photon energies
    for(size_t i = 2; i < rindex->GetVectorLength(); ++i)
    {
      vg = c_light / (0.5 * (n0 + n1) + (n1 - n0) / G4Log(E1 / E0));
 
      // allow only for 'normal dispersion' -> dn/d(logE) > 0
      if((vg < 0) || (vg > c_light / (0.5 * (n0 + n1))))
      {
        vg = c_light / (0.5 * (n0 + n1));
      }
      groupvel->InsertValues(0.5 * (E0 + E1), vg);
 
      // get next energy/value pair, or exit loop
      E0 = E1;
      n0 = n1;
      E1 = rindex->Energy(i);
      n1 = (*rindex)[i];
 
      if(E1 <= 0.)
      {
        G4Exception("G4MaterialPropertiesTable::CalculateGROUPVEL()", "mat213",
                    FatalException, "Optical Photon Energy <= 0");
      }
    }
 
    // add entry at last photon energy
    vg = c_light / (n1 + (n1 - n0) / G4Log(E1 / E0));
 
    // allow only for 'normal dispersion' -> dn/d(logE) > 0
    if((vg < 0) || (vg > c_light / n1))
    {
      vg = c_light / n1;
    }
    groupvel->InsertValues(E1, vg);
  }
  else  // only one entry in RINDEX -- weird!
  {
    groupvel->InsertValues(E0, c_light / n0);
  }
 
  this->AddProperty("GROUPVEL", groupvel);
 
  return groupvel;
}

References G4MaterialPropertiesTable::AddProperty(), source.hepunit::c_light, G4PhysicsVector::Energy(), FatalException, G4MaterialPropertiesTable::fMP, G4Exception(), G4Log(), G4MaterialPropertiesTable::GetProperty(), G4PhysicsVector::GetVectorLength(), G4PhysicsFreeVector::InsertValues(), kGROUPVEL, kRINDEX, G4MaterialPropertiesTable::RemoveProperty(), and G4PhysicsVector::SetVerboseLevel().

Referenced by G4MaterialPropertiesTable::AddEntry(), and G4MaterialPropertiesTable::AddProperty().

◆ ComputeMicroRoughnessTables()

void G4UCNMaterialPropertiesTable::ComputeMicroRoughnessTables ( )

Definition at line 141 of file G4UCNMaterialPropertiesTable.cc.

{
// Reads the parameters for the mr-probability computation from the
// corresponding material properties and stores it in the appropriate
// variables
 
  b = GetConstProperty("MR_RRMS");
  G4double b2 = b*b;
  w = GetConstProperty("MR_CORRLEN");
  G4double w2 = w*w;
 
  no_theta_i = G4int(GetConstProperty("MR_NBTHETA")+0.1);
  //G4cout << "no_theta: " << no_theta_i << G4endl;
  noE = G4int(GetConstProperty("MR_NBE")+0.1);
  //G4cout << "noE:      " << noE << G4endl;
 
  theta_i_min = GetConstProperty("MR_THETAMIN");
  theta_i_max = GetConstProperty("MR_THETAMAX");
  Emin = GetConstProperty("MR_EMIN");
  Emax = GetConstProperty("MR_EMAX");
  G4int AngNoTheta = G4int(GetConstProperty("MR_ANGNOTHETA")+0.1);
  G4int AngNoPhi = G4int(GetConstProperty("MR_ANGNOPHI")+0.1);
  AngCut = GetConstProperty("MR_ANGCUT");
 
  // The Fermi potential was saved in neV by P.F.
 
  G4double fermipot = GetConstProperty("FERMIPOT")*(1.e-9*eV);
 
  //G4cout << "Fermipot: " << fermipot/(1.e-9*eV) << "neV" << G4endl;
 
  G4double theta_i, E;
 
  // Calculates the increment in theta_i in the lookup-table
  theta_i_step = (theta_i_max-theta_i_min)/(no_theta_i-1);
 
  //G4cout << "theta_i_step: " << theta_i_step << G4endl;
 
  // Calculates the increment in energy in the lookup-table
  E_step = (Emax-Emin)/(noE-1);
 
  // Runs the lookup-table memory allocation
  InitMicroRoughnessTables();
 
  G4int counter = 0;
 
  //G4cout << "Calculating Microroughnesstables...";
 
  // Writes the mr-lookup-tables to files for immediate control
 
  std::ofstream dateir("MRrefl.dat",std::ios::out);
  std::ofstream dateit("MRtrans.dat",std::ios::out);
 
  //G4cout << theMicroRoughnessTable << G4endl;
 
  for (theta_i=theta_i_min; theta_i<=theta_i_max+1e-6; theta_i+=theta_i_step) {
      // Calculation for each cell in the lookup-table
      for (E=Emin; E<=Emax; E+=E_step) {
          *(theMicroRoughnessTable+counter) =
                      G4UCNMicroRoughnessHelper::GetInstance() ->
                      IntIplus(E, fermipot, theta_i, AngNoTheta, AngNoPhi,
                               b2, w2, maxMicroRoughnessTable+counter, AngCut);
 
      *(theMicroRoughnessTransTable+counter) =
                      G4UCNMicroRoughnessHelper::GetInstance() -> 
                      IntIminus(E, fermipot, theta_i, AngNoTheta, AngNoPhi,
                                b2, w2, maxMicroRoughnessTransTable+counter,
                                AngCut);
 
          dateir << *(theMicroRoughnessTable+counter)      << G4endl;
          dateit << *(theMicroRoughnessTransTable+counter) << G4endl;
 
          counter++;
 
          //G4cout << counter << G4endl;
      }
  }
 
  dateir.close();
  dateit.close();
 
  // Writes the mr-lookup-tables to files for immediate control
 
  std::ofstream dateic("MRcheck.dat",std::ios::out);
  std::ofstream dateimr("MRmaxrefl.dat",std::ios::out);
  std::ofstream dateimt("MRmaxtrans.dat",std::ios::out);
 
  for (theta_i=theta_i_min; theta_i<=theta_i_max+1e-6; theta_i+=theta_i_step) {
      for (E=Emin; E<=Emax; E+=E_step) {
 
          // tests the GetXXProbability functions by writing the entries
          // of the lookup tables to files
 
          dateic  << GetMRIntProbability(theta_i,E)      << G4endl;
          dateimr << GetMRMaxProbability(theta_i,E)      << G4endl;
          dateimt << GetMRMaxTransProbability(theta_i,E) << G4endl;
      }
  }
 
  dateic.close();
  dateimr.close();
  dateimt.close();
}

References AngCut, b, E_step, Emax, Emin, eV, G4endl, G4MaterialPropertiesTable::GetConstProperty(), G4UCNMicroRoughnessHelper::GetInstance(), GetMRIntProbability(), GetMRMaxProbability(), GetMRMaxTransProbability(), InitMicroRoughnessTables(), maxMicroRoughnessTable, maxMicroRoughnessTransTable, no_theta_i, noE, theMicroRoughnessTable, theMicroRoughnessTransTable, theta_i_max, theta_i_min, theta_i_step, and w.

Referenced by SetMicroRoughnessParameters().

◆ ConditionsValid()

G4bool G4UCNMaterialPropertiesTable::ConditionsValid	(	G4double	E,
		G4double	VFermi,
		G4double	theta_i
	)

Definition at line 413 of file G4UCNMaterialPropertiesTable.cc.

{
  G4double k =   std::sqrt(2*neutron_mass_c2*E      / hbarc_squared);
  G4double k_l = std::sqrt(2*neutron_mass_c2*VFermi / hbarc_squared);
 
  //G4cout << " Energy: " << E/(1.e-9*eV) << "neV"
  //       << " VFermi: " << VFermi/(1.e-9*eV) << "neV"
  //       << " theta:  " << theta_i/degree << "degree" << G4endl;
 
  //G4cout << " Conditions - 2*b*k*cos(theta): " << 2*b*k*cos(theta_i)
  //       << ", 2*b*kl: "                       << 2*b*k_l << G4endl;
 
  // see eq. 17 of the Steyerl paper
 
  if (2*b*k*std::cos(theta_i) < 1 && 2*b*k_l < 1) return true;
  else return false;
}

References b, source.hepunit::hbarc_squared, and source.hepunit::neutron_mass_c2.

◆ ConstPropertyExists() [1/3]

G4bool G4MaterialPropertiesTable::ConstPropertyExists ( const char * key ) const

inherited

Definition at line 253 of file G4MaterialPropertiesTable.cc.

{
  size_t index = std::distance(
    fMatConstPropNames.begin(),
    std::find(fMatConstPropNames.begin(), fMatConstPropNames.end(), key));
  if(index < fMatConstPropNames.size()) // index is type size_t so >= 0
    return ConstPropertyExists(index);
  return false;
}

References G4MaterialPropertiesTable::ConstPropertyExists(), and G4MaterialPropertiesTable::fMatConstPropNames.

◆ ConstPropertyExists() [2/3]

G4bool G4MaterialPropertiesTable::ConstPropertyExists ( const G4int index ) const

inherited

Definition at line 231 of file G4MaterialPropertiesTable.cc.

{
  // Returns true if a const property corresponding to 'index' exists
 
  if(index >= 0 && index < (G4int) fMCP.size() && fMCP[index].second == true)
  {
    return true;
  }
  return false;
}

References G4MaterialPropertiesTable::fMCP.

◆ ConstPropertyExists() [3/3]

G4bool G4MaterialPropertiesTable::ConstPropertyExists ( const G4String & key ) const

inherited

Definition at line 242 of file G4MaterialPropertiesTable.cc.

{
  // Returns true if a const property 'key' exists
  size_t index = std::distance(
    fMatConstPropNames.begin(),
    std::find(fMatConstPropNames.begin(), fMatConstPropNames.end(), key));
  if(index < fMatConstPropNames.size()) // index is type size_t so >= 0
    return ConstPropertyExists(index);
  return false;
}

References G4MaterialPropertiesTable::ConstPropertyExists(), and G4MaterialPropertiesTable::fMatConstPropNames.

Referenced by G4OpRayleigh::CalculateRayleighMeanFreePaths(), G4MaterialPropertiesTable::ConstPropertyExists(), G4Scintillation::GetScintillationYieldByParticleType(), InitMicroRoughnessTables(), G4Scintillation::PostStepDoIt(), G4OpBoundaryProcess::PostStepDoIt(), G4OpWLS::PostStepDoIt(), G4OpWLS2::PostStepDoIt(), and SetMicroRoughnessParameters().

◆ DumpTable()

void G4MaterialPropertiesTable::DumpTable ( ) const

inherited

Definition at line 516 of file G4MaterialPropertiesTable.cc.

{
  // material properties
  G4int j = 0;
  for(const auto& prop : fMP)
  {
    if(prop != nullptr)
    {
      G4cout << j << ": " << fMatPropNames[j] << G4endl;
      prop->DumpValues();
    }
    ++j;
  }
  // material constant properties
  j = 0;
  for(const auto& cprop : fMCP)
  {
    if(cprop.second == true)
    {
      G4cout << j << ": " << fMatConstPropNames[j] << " " << cprop.first
             << G4endl;
    }
    ++j;
  }
}

References G4MaterialPropertiesTable::fMatConstPropNames, G4MaterialPropertiesTable::fMatPropNames, G4MaterialPropertiesTable::fMCP, G4MaterialPropertiesTable::fMP, G4cout, and G4endl.

◆ GetConstProperties()

const std::vector< std::pair< G4double, G4bool > > & G4MaterialPropertiesTable::GetConstProperties ( ) const

inlineinherited

Definition at line 159 of file G4MaterialPropertiesTable.hh.

  {
    return fMCP;
  }

References G4MaterialPropertiesTable::fMCP.

Referenced by G4GDMLWriteMaterials::PropertyWrite(), and G4GDMLWriteSolids::PropertyWrite().

◆ GetConstProperty() [1/3]

G4double G4MaterialPropertiesTable::GetConstProperty ( const char * key ) const

inherited

Definition at line 226 of file G4MaterialPropertiesTable.cc.

{
  return GetConstProperty(GetConstPropertyIndex(G4String(key)));
}

References G4MaterialPropertiesTable::GetConstProperty(), and G4MaterialPropertiesTable::GetConstPropertyIndex().

◆ GetConstProperty() [2/3]

G4double G4MaterialPropertiesTable::GetConstProperty ( const G4int index ) const

inherited

Definition at line 204 of file G4MaterialPropertiesTable.cc.

{
  // Returns the constant material property corresponding to an index
  // fatal exception if property not found
 
  if(index < (G4int) fMCP.size() && fMCP[index].second == true)
    return fMCP[index].first;
  G4ExceptionDescription ed;
  ed << "Constant Material Property Index " << index << " not found.";
  G4Exception("G4MaterialPropertiesTable::GetConstProperty()", "mat202",
              FatalException, ed);
  return 0.;
}

References FatalException, G4MaterialPropertiesTable::fMCP, and G4Exception().

◆ GetConstProperty() [3/3]

G4double G4MaterialPropertiesTable::GetConstProperty ( const G4String & key ) const

inherited

Definition at line 218 of file G4MaterialPropertiesTable.cc.

{
  // Returns the constant material property corresponding to a key
  // fatal exception if property not found
 
  return GetConstProperty(GetConstPropertyIndex(key));
}

References G4MaterialPropertiesTable::GetConstProperty(), and G4MaterialPropertiesTable::GetConstPropertyIndex().

Referenced by G4OpRayleigh::CalculateRayleighMeanFreePaths(), ComputeMicroRoughnessTables(), G4MaterialPropertiesTable::GetConstProperty(), G4UCNAbsorption::GetMeanFreePath(), G4UCNLoss::GetMeanFreePath(), G4UCNMultiScattering::GetMeanFreePath(), G4Scintillation::GetScintillationYieldByParticleType(), InitMicroRoughnessTables(), G4UCNBoundaryProcess::PostStepDoIt(), G4Scintillation::PostStepDoIt(), G4OpBoundaryProcess::PostStepDoIt(), G4OpMieHG::PostStepDoIt(), G4OpWLS::PostStepDoIt(), and G4OpWLS2::PostStepDoIt().

◆ GetConstPropertyIndex()

G4int G4MaterialPropertiesTable::GetConstPropertyIndex ( const G4String & key ) const

inherited

Definition at line 171 of file G4MaterialPropertiesTable.cc.

{
  // Returns the constant material property index corresponding to a key
 
  size_t index = std::distance(
    fMatConstPropNames.begin(),
    std::find(fMatConstPropNames.begin(), fMatConstPropNames.end(), key));
  if(index < fMatConstPropNames.size())
    return index;
 
  G4ExceptionDescription ed;
  ed << "Constant Material Property Index for key " << key << " not found.";
  G4Exception("G4MaterialPropertiesTable::GetConstPropertyIndex()", "mat200",
              FatalException, ed);
  return 0;
}

References FatalException, G4MaterialPropertiesTable::fMatConstPropNames, and G4Exception().

Referenced by G4MaterialPropertiesTable::AddConstProperty(), G4MaterialPropertiesTable::GetConstProperty(), and G4MaterialPropertiesTable::RemoveConstProperty().

◆ GetCorrLen()

G4double G4UCNMaterialPropertiesTable::GetCorrLen ( ) const

inline

Definition at line 181 of file G4UCNMaterialPropertiesTable.hh.

181{return w;}

References w.

Referenced by G4UCNBoundaryProcess::Loss().

◆ GetMaterialConstPropertyNames()

const std::vector< G4String > & G4MaterialPropertiesTable::GetMaterialConstPropertyNames ( ) const

inlineinherited

Definition at line 151 of file G4MaterialPropertiesTable.hh.

  {
    return fMatConstPropNames;
  }

References G4MaterialPropertiesTable::fMatConstPropNames.

Referenced by G4GDMLWriteMaterials::PropertyWrite(), and G4GDMLWriteSolids::PropertyWrite().

◆ GetMaterialPropertyNames()

const std::vector< G4String > & G4MaterialPropertiesTable::GetMaterialPropertyNames ( ) const

inlineinherited

Definition at line 147 of file G4MaterialPropertiesTable.hh.

  {
    return fMatPropNames;
  }

References G4MaterialPropertiesTable::fMatPropNames.

Referenced by G4GDMLWriteMaterials::PropertyWrite(), and G4GDMLWriteSolids::PropertyWrite().

◆ GetMicroRoughnessTable()

G4double * G4UCNMaterialPropertiesTable::GetMicroRoughnessTable ( )

Definition at line 87 of file G4UCNMaterialPropertiesTable.cc.

{
  return theMicroRoughnessTable;
}

References theMicroRoughnessTable.

Referenced by G4UCNBoundaryProcess::PostStepDoIt().

◆ GetMicroRoughnessTransTable()

G4double * G4UCNMaterialPropertiesTable::GetMicroRoughnessTransTable ( )

Definition at line 92 of file G4UCNMaterialPropertiesTable.cc.

{
  return theMicroRoughnessTransTable;
}

References theMicroRoughnessTransTable.

◆ GetMRIntProbability()

G4double G4UCNMaterialPropertiesTable::GetMRIntProbability	(	G4double	theta_i,
		G4double	Energy
	)

Definition at line 244 of file G4UCNMaterialPropertiesTable.cc.

{
  if (!theMicroRoughnessTable) {
     G4cout << "Do not have theMicroRoughnessTable" << G4endl;
     return 0.;
  }
 
  // if theta_i or energy outside the range for which the lookup table is
  // calculated, the probability is set to zero
 
  //G4cout << "theta_i: " << theta_i/degree << "degree"
  //       << " theta_i_min: " << theta_i_min/degree << "degree"
  //       << " theta_i_max: " << theta_i_max/degree << "degree"
  //       << " Energy: " << Energy/(1.e-9*eV) << "neV"
  //       << " Emin: " << Emin/(1.e-9*eV) << "neV"
  //       << " Emax: " << Emax/(1.e-9*eV) << "neV" << G4endl;
 
  if (theta_i<theta_i_min || theta_i>theta_i_max || Energy<Emin || Energy>Emax)
     return 0.;
 
  // Determines the nearest cell in the lookup table which contains
  // the probability
 
  G4int theta_i_pos = G4int((theta_i-theta_i_min)/theta_i_step+0.5);
  G4int E_pos = G4int((Energy-Emin)/E_step+0.5);
 
  // lookup table is onedimensional (1 row), energy is in rows,
  // theta_i in columns
 
  //G4cout << "E_pos: " << E_pos << " theta_i_pos: " << theta_i_pos << G4endl;
  //G4cout << "Probability: " << *(theMicroRoughnessTable+E_pos+theta_i_pos*(noE-1)) << G4endl;
 
  return *(theMicroRoughnessTable+E_pos+theta_i_pos*(noE - 1));
}

References E_step, Emax, Emin, G4cout, G4endl, noE, theMicroRoughnessTable, theta_i_max, theta_i_min, and theta_i_step.

Referenced by ComputeMicroRoughnessTables().

◆ GetMRIntTransProbability()

G4double G4UCNMaterialPropertiesTable::GetMRIntTransProbability	(	G4double	theta_i,
		G4double	Energy
	)

Definition at line 280 of file G4UCNMaterialPropertiesTable.cc.

{
  if (!theMicroRoughnessTransTable) return 0.;
 
  // if theta_i or energy outside the range for which the lookup table
  // is calculated, the probability is set to zero
 
  if (theta_i<theta_i_min || theta_i>theta_i_max || Energy<Emin || Energy>Emax)
     return 0.;
 
  // Determines the nearest cell in the lookup table which contains
  // the probability
 
  G4int theta_i_pos = G4int((theta_i-theta_i_min)/theta_i_step+0.5);
  G4int E_pos = G4int((Energy-Emin)/E_step+0.5);
 
  // lookup table is onedimensional (1 row), energy is in rows,
  // theta_i in columns
 
  return *(theMicroRoughnessTransTable+E_pos+theta_i_pos*(noE - 1));
}

References E_step, Emax, Emin, noE, theMicroRoughnessTransTable, theta_i_max, theta_i_min, and theta_i_step.

◆ GetMRMaxProbability()

G4double G4UCNMaterialPropertiesTable::GetMRMaxProbability	(	G4double	theta_i,
		G4double	Energy
	)

Definition at line 303 of file G4UCNMaterialPropertiesTable.cc.

{
  if (!maxMicroRoughnessTable) return 0.;
 
  // if theta_i or energy outside the range for which the lookup table
  // is calculated, the probability is set to zero
 
  if (theta_i<theta_i_min || theta_i>theta_i_max || Energy<Emin || Energy>Emax)
     return 0.;
 
  // Determines the nearest cell in the lookup table which contains
  // the probability
 
  G4int theta_i_pos = G4int((theta_i-theta_i_min)/theta_i_step+0.5);
  G4int E_pos = G4int((Energy-Emin)/E_step+0.5);
 
  // lookup table is onedimensional (1 row), energy is in rows,
  // theta_i in columns
 
  return *(maxMicroRoughnessTable+E_pos+theta_i_pos*noE);
}

References E_step, Emax, Emin, maxMicroRoughnessTable, noE, theta_i_max, theta_i_min, and theta_i_step.

Referenced by ComputeMicroRoughnessTables().

◆ GetMRMaxTransProbability()

G4double G4UCNMaterialPropertiesTable::GetMRMaxTransProbability	(	G4double	theta_i,
		G4double	Energy
	)

Definition at line 349 of file G4UCNMaterialPropertiesTable.cc.

{
  if (!maxMicroRoughnessTransTable) return 0.;
 
  // if theta_i or energy outside the range for which the lookup table
  // is calculated, the probability is set to zero
 
  if (theta_i<theta_i_min || theta_i>theta_i_max || Energy<Emin || Energy>Emax)
     return 0.;
 
  // Determines the nearest cell in the lookup table which contains
  // the probability
 
  G4int theta_i_pos = G4int((theta_i-theta_i_min)/theta_i_step+0.5);
  G4int E_pos = G4int((Energy-Emin)/E_step+0.5);
 
  // lookup table is onedimensional (1 row), energy is in rows,
  // theta_i in columns
 
  return *(maxMicroRoughnessTransTable+E_pos+theta_i_pos*noE);
}

References E_step, Emax, Emin, maxMicroRoughnessTransTable, noE, theta_i_max, theta_i_min, and theta_i_step.

Referenced by ComputeMicroRoughnessTables().

◆ GetMRProbability()

G4double G4UCNMaterialPropertiesTable::GetMRProbability	(	G4double	theta_i,
		G4double	Energy,
		G4double	fermipot,
		G4double	theta_o,
		G4double	phi_o
	)

Definition at line 395 of file G4UCNMaterialPropertiesTable.cc.

{
  return G4UCNMicroRoughnessHelper::GetInstance()->
          ProbIplus(Energy, fermipot, theta_i, theta_o, phi_o, b, w, AngCut);
}

References AngCut, b, G4UCNMicroRoughnessHelper::GetInstance(), and w.

◆ GetMRTransProbability()

G4double G4UCNMaterialPropertiesTable::GetMRTransProbability	(	G4double	theta_i,
		G4double	Energy,
		G4double	fermipot,
		G4double	theta_o,
		G4double	phi_o
	)

Definition at line 404 of file G4UCNMaterialPropertiesTable.cc.

{
  return G4UCNMicroRoughnessHelper::GetInstance()->
          ProbIminus(Energy, fermipot,theta_i, theta_o, phi_o, b, w, AngCut);
}

References AngCut, b, G4UCNMicroRoughnessHelper::GetInstance(), and w.

◆ GetProperties()

const std::vector< G4MaterialPropertyVector * > & G4MaterialPropertiesTable::GetProperties ( ) const

inlineinherited

Definition at line 155 of file G4MaterialPropertiesTable.hh.

  {
    return fMP;
  }

References G4MaterialPropertiesTable::fMP.

Referenced by G4GDMLWriteMaterials::PropertyWrite(), and G4GDMLWriteSolids::PropertyWrite().

◆ GetProperty() [1/3]

G4MaterialPropertyVector * G4MaterialPropertiesTable::GetProperty ( const char * key ) const

inherited

Definition at line 276 of file G4MaterialPropertiesTable.cc.

{
  if(std::find(fMatPropNames.begin(), fMatPropNames.end(), key) !=
     fMatPropNames.end())
  {
    const G4int index = GetPropertyIndex(G4String(key));
    return GetProperty(index);
  }
  return nullptr;
}

References G4MaterialPropertiesTable::fMatPropNames, G4MaterialPropertiesTable::GetProperty(), and G4MaterialPropertiesTable::GetPropertyIndex().

Referenced by G4Cerenkov::BuildPhysicsTable(), G4Scintillation::BuildPhysicsTable(), G4OpRayleigh::BuildPhysicsTable(), G4OpWLS::BuildPhysicsTable(), G4OpWLS2::BuildPhysicsTable(), G4MaterialPropertiesTable::CalculateGROUPVEL(), G4OpRayleigh::CalculateRayleighMeanFreePaths(), G4Track::CalculateVelocityForOpticalPhoton(), G4OpAbsorption::GetMeanFreePath(), G4OpMieHG::GetMeanFreePath(), G4OpWLS::GetMeanFreePath(), G4OpWLS2::GetMeanFreePath(), G4MaterialPropertiesTable::GetProperty(), G4OpBoundaryProcess::GetReflectivity(), G4Scintillation::GetScintillationYieldByParticleType(), G4Cerenkov::PostStepDoIt(), G4Scintillation::PostStepDoIt(), G4OpBoundaryProcess::PostStepDoIt(), G4OpWLS::PostStepDoIt(), G4OpWLS2::PostStepDoIt(), and G4Cerenkov::PostStepGetPhysicalInteractionLength().

◆ GetProperty() [2/3]

G4MaterialPropertyVector * G4MaterialPropertiesTable::GetProperty ( const G4int index ) const

inherited

Definition at line 288 of file G4MaterialPropertiesTable.cc.

{
  // Returns a Material Property Vector corresponding to an index
  // returns nullptr if the property has not been defined by user
  if(index >= 0 && index < (G4int) fMP.size())
    return fMP[index];
  return nullptr;
}

References G4MaterialPropertiesTable::fMP.

◆ GetProperty() [3/3]

G4MaterialPropertyVector * G4MaterialPropertiesTable::GetProperty ( const G4String & key ) const

inherited

Definition at line 263 of file G4MaterialPropertiesTable.cc.

{
  // Returns a Material Property Vector corresponding to a key
  if(std::find(fMatPropNames.begin(), fMatPropNames.end(), key) !=
     fMatPropNames.end())
  {
    const G4int index = GetPropertyIndex(G4String(key));
    return GetProperty(index);
  }
  return nullptr;
}

References G4MaterialPropertiesTable::fMatPropNames, G4MaterialPropertiesTable::GetProperty(), and G4MaterialPropertiesTable::GetPropertyIndex().

◆ GetPropertyIndex()

G4int G4MaterialPropertiesTable::GetPropertyIndex ( const G4String & key ) const

inherited

Definition at line 189 of file G4MaterialPropertiesTable.cc.

{
  // Returns the material property index corresponding to a key
  size_t index =
    std::distance(fMatPropNames.begin(),
                  std::find(fMatPropNames.begin(), fMatPropNames.end(), key));
  if(index < fMatPropNames.size())
    return index;
  G4ExceptionDescription ed;
  ed << "Material Property Index for key " << key << " not found.";
  G4Exception("G4MaterialPropertiesTable::GetPropertyIndex()", "mat201",
              FatalException, ed);
  return 0;
}

References FatalException, G4MaterialPropertiesTable::fMatPropNames, and G4Exception().

Referenced by G4MaterialPropertiesTable::AddEntry(), G4MaterialPropertiesTable::AddProperty(), G4MaterialPropertiesTable::GetProperty(), and G4MaterialPropertiesTable::RemoveProperty().

◆ GetRMS()

G4double G4UCNMaterialPropertiesTable::GetRMS ( ) const

inline

Definition at line 180 of file G4UCNMaterialPropertiesTable.hh.

180{return b;}

References b.

Referenced by G4UCNBoundaryProcess::Loss().

◆ InitMicroRoughnessTables()

void G4UCNMaterialPropertiesTable::InitMicroRoughnessTables ( )

Definition at line 109 of file G4UCNMaterialPropertiesTable.cc.

{
  G4int NEdim     = 0;
  G4int Nthetadim = 0;
 
  // Checks if the number of angles is available and stores it
 
  if (ConstPropertyExists("MR_NBTHETA"))
     Nthetadim = G4int(GetConstProperty("MR_NBTHETA")+0.1);
 
  // Checks if the number of energies is available and stores it
 
  if (ConstPropertyExists("MR_NBE"))
     NEdim = G4int(GetConstProperty("MR_NBE")+0.1);
 
  //G4cout << "thetadim: " << Nthetadim << " , Edim: " << NEdim << G4endl;
 
  // If both dimensions of the lookup-table are non-trivial:
  // delete old tables if existing and allocate memory for new tables
 
  if (Nthetadim*NEdim > 0) {
     if (theMicroRoughnessTable) delete theMicroRoughnessTable;
     theMicroRoughnessTable = new G4double[Nthetadim*NEdim];
     if (maxMicroRoughnessTable) delete maxMicroRoughnessTable;
     maxMicroRoughnessTable = new G4double[Nthetadim*NEdim];
     if (theMicroRoughnessTransTable) delete theMicroRoughnessTransTable;
     theMicroRoughnessTransTable = new G4double[Nthetadim*NEdim];
     if (maxMicroRoughnessTransTable) delete maxMicroRoughnessTransTable;
     maxMicroRoughnessTransTable = new G4double[Nthetadim*NEdim];
  }
}

References G4MaterialPropertiesTable::ConstPropertyExists(), G4MaterialPropertiesTable::GetConstProperty(), maxMicroRoughnessTable, maxMicroRoughnessTransTable, theMicroRoughnessTable, and theMicroRoughnessTransTable.

Referenced by ComputeMicroRoughnessTables().

◆ LoadMicroRoughnessTables()

void G4UCNMaterialPropertiesTable::LoadMicroRoughnessTables	(	G4double *	pMicroRoughnessTable,
		G4double *	pmaxMicroRoughnessTable,
		G4double *	pMicroRoughnessTransTable,
		G4double *	pmaxMicroRoughnessTransTable
	)

Definition at line 97 of file G4UCNMaterialPropertiesTable.cc.

{
  theMicroRoughnessTable      = pMicroRoughnessTable;
  maxMicroRoughnessTable      = pmaxMicroRoughnessTable;
  theMicroRoughnessTransTable = pMicroRoughnessTransTable;
  maxMicroRoughnessTransTable = pmaxMicroRoughnessTransTable;
}

References maxMicroRoughnessTable, maxMicroRoughnessTransTable, theMicroRoughnessTable, and theMicroRoughnessTransTable.

◆ RemoveConstProperty() [1/2]

void G4MaterialPropertiesTable::RemoveConstProperty ( const char * key )

inherited

Definition at line 462 of file G4MaterialPropertiesTable.cc.

{
  RemoveConstProperty(G4String(key));
}

References G4MaterialPropertiesTable::RemoveConstProperty().

◆ RemoveConstProperty() [2/2]

void G4MaterialPropertiesTable::RemoveConstProperty ( const G4String & key )

inherited

Definition at line 455 of file G4MaterialPropertiesTable.cc.

{
  G4int index = GetConstPropertyIndex(key);
  if(index < (G4int) fMCP.size())
    fMCP[index] = std::pair<G4double, G4bool>{ 0., false };
}

References G4MaterialPropertiesTable::fMCP, and G4MaterialPropertiesTable::GetConstPropertyIndex().

Referenced by G4MaterialPropertiesTable::RemoveConstProperty(), and SetMicroRoughnessParameters().

◆ RemoveProperty() [1/2]

void G4MaterialPropertiesTable::RemoveProperty ( const char * key )

inherited

Definition at line 474 of file G4MaterialPropertiesTable.cc.

{
  RemoveProperty(G4String(key));
}

References G4MaterialPropertiesTable::RemoveProperty().

◆ RemoveProperty() [2/2]

void G4MaterialPropertiesTable::RemoveProperty ( const G4String & key )

inherited

Definition at line 467 of file G4MaterialPropertiesTable.cc.

{
  G4int index = GetPropertyIndex(key);
  delete fMP[index];
  fMP[index] = nullptr;
}

References G4MaterialPropertiesTable::fMP, and G4MaterialPropertiesTable::GetPropertyIndex().

Referenced by G4MaterialPropertiesTable::CalculateGROUPVEL(), and G4MaterialPropertiesTable::RemoveProperty().

◆ SetMicroRoughnessParameters()

void G4UCNMaterialPropertiesTable::SetMicroRoughnessParameters	(	G4double	ww,
		G4double	bb,
		G4int	no_theta,
		G4int	no_E,
		G4double	theta_min,
		G4double	theta_max,
		G4double	E_min,
		G4double	E_max,
		G4int	AngNoTheta,
		G4int	AngNoPhi,
		G4double	AngularCut
	)

Definition at line 453 of file G4UCNMaterialPropertiesTable.cc.

{
  //G4cout << "Setting Microroughness Parameters...";
 
  // Removes an existing RMS roughness
  if (ConstPropertyExists("MR_RRMS")) RemoveConstProperty("MR_RRMS");
 
  // Adds a new RMS roughness
  AddConstProperty("MR_RRMS", bb);
 
  //G4cout << "b: " << bb << G4endl;
 
  // Removes an existing correlation length
  if (ConstPropertyExists("MR_CORRLEN")) RemoveConstProperty("MR_CORRLEN");
 
  // Adds a new correlation length
  AddConstProperty("MR_CORRLEN", ww);
 
  //G4cout << "w: " << ww << G4endl;
 
  // Removes an existing number of thetas
  if (ConstPropertyExists("MR_NBTHETA")) RemoveConstProperty("MR_NBTHETA");
 
  // Adds a new number of thetas
  AddConstProperty("MR_NBTHETA", (G4double)no_theta);
 
  //G4cout << "no_theta: " << no_theta << G4endl;
 
  // Removes an existing number of Energies
  if (ConstPropertyExists("MR_NBE")) RemoveConstProperty("MR_NBE");
 
  // Adds a new number of Energies
  AddConstProperty("MR_NBE", (G4double)no_E);
 
  //G4cout << "no_E: " << no_E << G4endl;
 
  // Removes an existing minimum theta
  if (ConstPropertyExists("MR_THETAMIN")) RemoveConstProperty("MR_THETAMIN");
 
  // Adds a new minimum theta
  AddConstProperty("MR_THETAMIN", theta_min);
 
  //G4cout << "theta_min: " << theta_min << G4endl;
 
  // Removes an existing maximum theta
  if (ConstPropertyExists("MR_THETAMAX")) RemoveConstProperty("MR_THETAMAX");
 
  // Adds a new maximum theta
  AddConstProperty("MR_THETAMAX", theta_max);
 
  //G4cout << "theta_max: " << theta_max << G4endl;
 
  // Removes an existing minimum energy
  if (ConstPropertyExists("MR_EMIN")) RemoveConstProperty("MR_EMIN");
 
  // Adds a new minimum energy
  AddConstProperty("MR_EMIN", E_min);
 
  //G4cout << "Emin: " << E_min << G4endl;
 
  // Removes an existing maximum energy
  if (ConstPropertyExists("MR_EMAX")) RemoveConstProperty("MR_EMAX");
 
  // Adds a new maximum energy
  AddConstProperty("MR_EMAX", E_max);
 
  //G4cout << "Emax: " << E_max << G4endl;
 
  // Removes an existing Theta angle number
  if(ConstPropertyExists("MR_ANGNOTHETA"))RemoveConstProperty("MR_ANGNOTHETA");
 
  // Adds a new Theta angle number
  AddConstProperty("MR_ANGNOTHETA", (G4double)AngNoTheta);
 
  //G4cout << "AngNoTheta: " << AngNoTheta << G4endl;
 
  // Removes an existing Phi angle number
  if (ConstPropertyExists("MR_ANGNOPHI")) RemoveConstProperty("MR_ANGNOPHI");
 
  // Adds a new Phi angle number
  AddConstProperty("MR_ANGNOPHI", (G4double)AngNoPhi);
 
  //G4cout << "AngNoPhi: " << AngNoPhi << G4endl;
 
  // Removes an existing angular cut
  if (ConstPropertyExists("MR_ANGCUT")) RemoveConstProperty("MR_ANGCUT");
 
  // Adds a new angle number
  AddConstProperty("MR_ANGCUT", AngularCut);
 
  //G4cout << "AngularCut: " << AngularCut/degree << "degree" << G4endl;
 
  // Starts the lookup table calculation
 
  ComputeMicroRoughnessTables();
 
  //G4cout << " *** DONE! ***" << G4endl;
}

References G4MaterialPropertiesTable::AddConstProperty(), ComputeMicroRoughnessTables(), G4MaterialPropertiesTable::ConstPropertyExists(), and G4MaterialPropertiesTable::RemoveConstProperty().

◆ SetMRMaxProbability()

void G4UCNMaterialPropertiesTable::SetMRMaxProbability	(	G4double	theta_i,
		G4double	Energy,
		G4double	value
	)

Definition at line 326 of file G4UCNMaterialPropertiesTable.cc.

{
  if (maxMicroRoughnessTable) {
 
     if (theta_i<theta_i_min || theta_i>theta_i_max || 
         Energy<Emin || Energy>Emax) {
     } else {
 
         // Determines the nearest cell in the lookup table which contains
         // the probability
 
         G4int theta_i_pos = G4int((theta_i-theta_i_min)/theta_i_step+0.5);
         G4int E_pos = G4int((Energy-Emin)/E_step+0.5);
 
         // lookup table is onedimensional (1 row), energy is in rows,
         // theta_i in columns
 
         *(maxMicroRoughnessTable+E_pos+theta_i_pos*noE) = value;
     }
  }
}

References E_step, Emax, Emin, maxMicroRoughnessTable, noE, theta_i_max, theta_i_min, and theta_i_step.

◆ SetMRMaxTransProbability()

void G4UCNMaterialPropertiesTable::SetMRMaxTransProbability	(	G4double	theta_i,
		G4double	Energy,
		G4double	value
	)

Definition at line 372 of file G4UCNMaterialPropertiesTable.cc.

{
  if (maxMicroRoughnessTransTable) {
 
     if (theta_i<theta_i_min || theta_i>theta_i_max ||
         Energy<Emin || Energy>Emax) {
     } else {
 
         // Determines the nearest cell in the lookup table which contains
         // the probability
 
         G4int theta_i_pos = G4int((theta_i-theta_i_min)/theta_i_step+0.5);
         G4int E_pos = G4int((Energy-Emin)/E_step+0.5);
 
         // lookup table is onedimensional (1 row), energy is in rows,
         // theta_i in columns
 
         *(maxMicroRoughnessTransTable+E_pos+theta_i_pos*noE) = value;
     }
  }
}

References E_step, Emax, Emin, maxMicroRoughnessTransTable, noE, theta_i_max, theta_i_min, and theta_i_step.

◆ TransConditionsValid()

G4bool G4UCNMaterialPropertiesTable::TransConditionsValid	(	G4double	E,
		G4double	VFermi,
		G4double	theta_i
	)

Definition at line 433 of file G4UCNMaterialPropertiesTable.cc.

{
  G4double k2   = 2*neutron_mass_c2*E      / hbarc_squared;
  G4double k_l2 = 2*neutron_mass_c2*VFermi / hbarc_squared;
 
  if (E*(std::cos(theta_i)*std::cos(theta_i)) < VFermi) return false;
 
  G4double kS2 = k_l2 - k2;
 
  //G4cout << "Conditions; 2bk' cos(theta): " << 2*b*sqrt(kS2)*cos(theta_i) << 
  //          ", 2bk_l: " << 2*b*sqrt(k_l2) << G4endl;
 
  // see eq. 18 of the Steyerl paper
 
  if (2*b*std::sqrt(kS2)*std::cos(theta_i) < 1 && 2*b*std::sqrt(k_l2) < 1) return true;
  else return false;
}