#include <G4UCNMaterialPropertiesTable.hh>

Inheritance diagram for G4UCNMaterialPropertiesTable:

Collaboration diagram for G4UCNMaterialPropertiesTable:

Public Member Functions
	G4UCNMaterialPropertiesTable ()

virtual	~G4UCNMaterialPropertiesTable ()

G4double *	GetMicroRoughnessTable ()

G4double *	GetMicroRoughnessTransTable ()

void	LoadMicroRoughnessTables (G4double , G4double , G4double , G4double )

void	InitMicroRoughnessTables ()

void	ComputeMicroRoughnessTables ()

G4double	GetMRIntProbability (G4double, G4double)

G4double	GetMRMaxProbability (G4double, G4double)

void	SetMRMaxProbability (G4double, G4double, G4double)

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

G4double	GetMRIntTransProbability (G4double, G4double)

G4double	GetMRMaxTransProbability (G4double, G4double)

void	SetMRMaxTransProbability (G4double, G4double, G4double)

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

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

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

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

G4double	GetRMS () const

G4double	GetCorrLen () const

Public Member Functions inherited from G4MaterialPropertiesTable
	G4MaterialPropertiesTable ()

virtual	~G4MaterialPropertiesTable ()

void	AddConstProperty (const char *key, G4double PropertyValue)

G4MaterialPropertyVector *	AddProperty (const char key, G4double PhotonEnergies, G4double *PropertyValues, G4int NumEntries)

void	AddProperty (const char key, G4MaterialPropertyVector opv)

void	RemoveConstProperty (const char *key)

void	RemoveProperty (const char *key)

G4double	GetConstProperty (const char *key) const

G4bool	ConstPropertyExists (const char *key) const

G4MaterialPropertyVector *	GetProperty (const char *key)

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

void	DumpTable ()

const std::map< G4String, G4MaterialPropertyVector , std::less< G4String > >	GetPropertiesMap () const

const std::map< G4String, G4double, std::less< G4String > > *	GetPropertiesCMap () const

Detailed Description

Definition at line 51 of file G4UCNMaterialPropertiesTable.hh.

Constructor & Destructor Documentation

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;
 }

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;
 }

Member Function Documentation

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();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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;
 }

G4double G4UCNMaterialPropertiesTable::GetCorrLen ( ) const

inline

Definition at line 181 of file G4UCNMaterialPropertiesTable.hh.

181 {return w;}

G4double * G4UCNMaterialPropertiesTable::GetMicroRoughnessTable ( )

Definition at line 87 of file G4UCNMaterialPropertiesTable.cc.

 {
   return theMicroRoughnessTable;
 }

Here is the caller graph for this function:

G4double * G4UCNMaterialPropertiesTable::GetMicroRoughnessTransTable ( )

Definition at line 92 of file G4UCNMaterialPropertiesTable.cc.

 {
   return theMicroRoughnessTransTable;
 }

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

Definition at line 245 of file G4UCNMaterialPropertiesTable.cc.

 {
   if (!theMicroRoughnessTable) {
      G4cout << "Dont 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));
 }

Here is the caller graph for this function:

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

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

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

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

Here is the caller graph for this function:

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

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

Here is the caller graph for this function:

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

Definition at line 396 of file G4UCNMaterialPropertiesTable.cc.

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

Here is the call graph for this function:

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

Definition at line 405 of file G4UCNMaterialPropertiesTable.cc.

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

Here is the call graph for this function:

G4double G4UCNMaterialPropertiesTable::GetRMS ( ) const

inline

Definition at line 180 of file G4UCNMaterialPropertiesTable.hh.

180 {return b;}

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];
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 98 of file G4UCNMaterialPropertiesTable.cc.

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

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 454 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;
 }

Here is the call graph for this function:

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

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

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

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

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;
 }

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

geant4.10.03.p01/source/materials/include/G4UCNMaterialPropertiesTable.hh
geant4.10.03.p01/source/materials/src/G4UCNMaterialPropertiesTable.cc

Public Member Functions

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation