G4OpticalSurface Class Reference

#include <G4OpticalSurface.hh>

Inheritance diagram for G4OpticalSurface:

Public Member Functions
	G4OpticalSurface (const G4String &name, G4OpticalSurfaceModel model=glisur, G4OpticalSurfaceFinish finish=polished, G4SurfaceType type=dielectric_dielectric, G4double value=1.0)
	~G4OpticalSurface () override
	G4OpticalSurface (const G4OpticalSurface &right)
G4OpticalSurface &	operator= (const G4OpticalSurface &right)
G4bool	operator== (const G4OpticalSurface &right) const
G4bool	operator!= (const G4OpticalSurface &right) const
void	SetType (const G4SurfaceType &type) override
G4OpticalSurfaceFinish	GetFinish () const
void	SetFinish (const G4OpticalSurfaceFinish)
G4OpticalSurfaceModel	GetModel () const
void	SetModel (const G4OpticalSurfaceModel model)
G4double	GetSigmaAlpha () const
void	SetSigmaAlpha (const G4double s_a)
G4double	GetPolish () const
void	SetPolish (const G4double plsh)
G4MaterialPropertiesTable *	GetMaterialPropertiesTable () const
void	SetMaterialPropertiesTable (G4MaterialPropertiesTable *anMPT)
void	DumpInfo () const
void	ReadDataFile ()
void	ReadCompressedFile (const G4String &, std::istringstream &)
void	ReadLUTFile ()
G4double	GetAngularDistributionValue (G4int, G4int, G4int)
G4double	GetAngularDistributionValueLUT (G4int)
void	ReadLUTDAVISFile ()
void	ReadReflectivityLUTFile ()
G4double	GetReflectivityLUTValue (G4int)
G4int	GetInmax () const
G4int	GetLUTbins () const
G4int	GetRefMax () const
G4int	GetThetaIndexMax () const
G4int	GetPhiIndexMax () const
void	ReadDichroicFile ()
G4Physics2DVector *	GetDichroicVector ()
Public Member Functions inherited from G4SurfaceProperty
	G4SurfaceProperty ()
	G4SurfaceProperty (const G4String &name, G4SurfaceType type=x_ray)
virtual	~G4SurfaceProperty ()=default
const G4String &	GetName () const
void	SetName (const G4String &name)
const G4SurfaceType &	GetType () const

Additional Inherited Members
Static Public Member Functions inherited from G4SurfaceProperty
static void	CleanSurfacePropertyTable ()
static const G4SurfacePropertyTable *	GetSurfacePropertyTable ()
static size_t	GetNumberOfSurfaceProperties ()
static void	DumpTableInfo ()
Protected Attributes inherited from G4SurfaceProperty
G4String	theName
G4SurfaceType	theType
Static Protected Attributes inherited from G4SurfaceProperty
static G4SurfacePropertyTable	theSurfacePropertyTable

Detailed Description

Definition at line 119 of file G4OpticalSurface.hh.

Constructor & Destructor Documentation

G4OpticalSurface() [1/2]

G4OpticalSurface::G4OpticalSurface	(	const G4String &	name,
		G4OpticalSurfaceModel	model = glisur,
		G4OpticalSurfaceFinish	finish = polished,
		G4SurfaceType	type = dielectric_dielectric,
		G4double	value = 1.0 )

Definition at line 77 of file G4OpticalSurface.cc.

  : G4SurfaceProperty(name, type), theModel(model), theFinish(finish)
{
  AngularDistribution = nullptr;
 
  AngularDistributionLUT = nullptr;
  Reflectivity = nullptr;
 
  DichroicVector = nullptr;
 
  switch (theModel) {
    case glisur:
      polish = value;
      sigma_alpha = 0.0;
      break;
    case LUT:
    case dichroic:
    case DAVIS:
      ReadDataFile();
      // fall through
    case unified:
      sigma_alpha = value;
      polish = 0.0;
      break;
    default:
      G4Exception("G4OpticalSurface::G4OpticalSurface()", "mat309", FatalException,
        "Constructor called with INVALID model.");
  }
}

Referenced by G4OpticalSurface(), operator!=(), operator=(), and operator==().

~G4OpticalSurface()

G4OpticalSurface::~G4OpticalSurface ( )

override

Definition at line 108 of file G4OpticalSurface.cc.

{
  delete[] AngularDistribution;
 
  delete[] AngularDistributionLUT;
 
  delete[] Reflectivity;
 
  delete DichroicVector;
}

G4OpticalSurface() [2/2]

G4OpticalSurface::G4OpticalSurface

(

const G4OpticalSurface &

right

)

Definition at line 119 of file G4OpticalSurface.cc.

  : G4SurfaceProperty(right.theName, right.theType)
{
  *this = right;
  this->theName = right.theName;
  this->theType = right.theType;
  this->theModel = right.theModel;
  this->theFinish = right.theFinish;
  this->sigma_alpha = right.sigma_alpha;
  this->polish = right.polish;
  this->theMaterialPropertiesTable = right.theMaterialPropertiesTable;
 
  delete[] AngularDistribution;
  this->AngularDistribution = new G4float[incidentIndexMax * thetaIndexMax * phiIndexMax];
  *(this->AngularDistribution) = *(right.AngularDistribution);
 
  delete[] AngularDistributionLUT;
  this->AngularDistributionLUT = new G4float[indexmax];
  *(this->AngularDistributionLUT) = *(right.AngularDistributionLUT);
 
  delete[] Reflectivity;
  this->Reflectivity = new G4float[RefMax];
  *(this->Reflectivity) = *(right.Reflectivity);
 
  delete DichroicVector;
  this->DichroicVector = new G4Physics2DVector();
  *(this->DichroicVector) = *(right.DichroicVector);
}

Member Function Documentation

DumpInfo()

void G4OpticalSurface::DumpInfo

(

)

const

Definition at line 168 of file G4OpticalSurface.cc.

{
  // Dump info for surface
 
  G4cout << "  Surface type   = " << G4int(theType) << G4endl
         << "  Surface finish = " << G4int(theFinish) << G4endl
         << "  Surface model  = " << G4int(theModel) << G4endl << G4endl << "  Surface parameter "
         << G4endl << "  ----------------- " << G4endl;
 
  if (theModel == glisur) {
    G4cout << " polish: " << polish << G4endl;
  }
  else {
    G4cout << " sigma_alpha: " << sigma_alpha << G4endl;
  }
  G4cout << G4endl;
}

GetAngularDistributionValue()

G4double G4OpticalSurface::GetAngularDistributionValue ( G4int angleIncident, G4int thetaIndex, G4int phiIndex )

inline

Definition at line 246 of file G4OpticalSurface.hh.

{
  G4int product = angleIncident * thetaIndex * phiIndex;
  if (product < 0 || product >= incidentIndexMax * thetaIndexMax * phiIndexMax) {
    G4ExceptionDescription ed;
    ed << "Index angleIncident: " << angleIncident << " thetaIndex: " << thetaIndex
       << " phiIndex: " << phiIndex << " out of range!";
    G4Exception("G4OpticalSurface::GetAngularDistributionValue", "mat317", FatalException, ed);
    return 0.;
  }
  return (G4double)AngularDistribution[angleIncident + thetaIndex * incidentIndexMax +
                                       phiIndex * thetaIndexMax * incidentIndexMax];
}

GetAngularDistributionValueLUT()

G4double G4OpticalSurface::GetAngularDistributionValueLUT ( G4int i )

inline

Definition at line 261 of file G4OpticalSurface.hh.

{
  if (i < 0 || i >= indexmax) {
    G4ExceptionDescription ed;
    ed << "Index " << i << " out of range!";
    G4Exception("G4OpticalSurface::GetAngularDistributionValueLUT", "mat318", FatalException, ed);
    return 0.;
  }
  return (G4double)AngularDistributionLUT[i];
}

GetDichroicVector()

G4Physics2DVector * G4OpticalSurface::GetDichroicVector ( )

inline

Definition at line 283 of file G4OpticalSurface.hh.

{ return DichroicVector; }

GetFinish()

G4OpticalSurfaceFinish G4OpticalSurface::GetFinish ( ) const

inline

Definition at line 138 of file G4OpticalSurface.hh.

{ return theFinish; }

Referenced by G4GDMLWriteSolids::OpticalSurfaceWrite().

GetInmax()

G4int G4OpticalSurface::GetInmax

(

)

const

Definition at line 158 of file G4OpticalSurface.cc.

{ return indexmax; }

GetLUTbins()

G4int G4OpticalSurface::GetLUTbins

(

)

const

Definition at line 160 of file G4OpticalSurface.cc.

{ return LUTbins; }

GetMaterialPropertiesTable()

G4MaterialPropertiesTable * G4OpticalSurface::GetMaterialPropertiesTable ( ) const

inline

Definition at line 163 of file G4OpticalSurface.hh.

  {
    return theMaterialPropertiesTable;
  }

Referenced by G4GDMLWriteSolids::OpticalSurfaceWrite(), G4GDMLReadSolids::PropertyRead(), and G4GDMLWriteSolids::PropertyWrite().

GetModel()

G4OpticalSurfaceModel G4OpticalSurface::GetModel ( ) const

inline

Definition at line 144 of file G4OpticalSurface.hh.

{ return theModel; }

Referenced by G4GDMLWriteSolids::OpticalSurfaceWrite().

GetPhiIndexMax()

G4int G4OpticalSurface::GetPhiIndexMax

(

)

const

Definition at line 166 of file G4OpticalSurface.cc.

{ return phiIndexMax; }

GetPolish()

G4double G4OpticalSurface::GetPolish ( ) const

inline

Definition at line 156 of file G4OpticalSurface.hh.

{ return polish; }

Referenced by G4GDMLWriteSolids::OpticalSurfaceWrite().

GetReflectivityLUTValue()

G4double G4OpticalSurface::GetReflectivityLUTValue ( G4int i )

inline

Definition at line 272 of file G4OpticalSurface.hh.

{
  if (i < 0 || i >= RefMax) {
    G4ExceptionDescription ed;
    ed << "Index " << i << " out of range!";
    G4Exception("G4OpticalSurface::GetReflectivityLUTValue", "mat319", FatalException, ed);
    return 0.;
  }
  return (G4double)Reflectivity[i];
}

GetRefMax()

G4int G4OpticalSurface::GetRefMax

(

)

const

Definition at line 162 of file G4OpticalSurface.cc.

{ return RefMax; }

GetSigmaAlpha()

G4double G4OpticalSurface::GetSigmaAlpha ( ) const

inline

Definition at line 150 of file G4OpticalSurface.hh.

{ return sigma_alpha; }

Referenced by G4GDMLWriteSolids::OpticalSurfaceWrite().

GetThetaIndexMax()

G4int G4OpticalSurface::GetThetaIndexMax

(

)

const

Definition at line 164 of file G4OpticalSurface.cc.

{ return thetaIndexMax; }

operator!=()

G4bool G4OpticalSurface::operator!=

(

const G4OpticalSurface &

right

)

const

Definition at line 153 of file G4OpticalSurface.cc.

{
  return (this != (G4OpticalSurface*)&right);
}

operator=()

G4OpticalSurface & G4OpticalSurface::operator=

(

const G4OpticalSurface &

right

)

Definition at line 47 of file G4OpticalSurface.cc.

{
  if (this != &right) {
    theName = right.theName;
    theType = right.theType;
    theModel = right.theModel;
    theFinish = right.theFinish;
    sigma_alpha = right.sigma_alpha;
    polish = right.polish;
    theMaterialPropertiesTable = right.theMaterialPropertiesTable;
 
    delete[] AngularDistribution;
    AngularDistribution = new G4float[incidentIndexMax * thetaIndexMax * phiIndexMax];
    *(AngularDistribution) = *(right.AngularDistribution);
 
    delete[] AngularDistributionLUT;
    AngularDistributionLUT = new G4float[indexmax];
    *(AngularDistributionLUT) = *(right.AngularDistributionLUT);
 
    delete[] Reflectivity;
    Reflectivity = new G4float[RefMax];
    *(Reflectivity) = *(right.Reflectivity);
 
    delete DichroicVector;
    DichroicVector = new G4Physics2DVector();
    *DichroicVector = *(right.DichroicVector);
  }
  return *this;
}

operator==()

G4bool G4OpticalSurface::operator==

(

const G4OpticalSurface &

right

)

const

Definition at line 148 of file G4OpticalSurface.cc.

{
  return (this == (G4OpticalSurface*)&right);
}

ReadCompressedFile()

void G4OpticalSurface::ReadCompressedFile	(	const G4String &	filename,
		std::istringstream &	iss )

Definition at line 405 of file G4OpticalSurface.cc.

{
  G4String* dataString = nullptr;
  G4String path = G4FindDataDir("G4REALSURFACEDATA");
  G4String compfilename = path + "/" + filename;
  // create input stream with binary mode operation and position at end of file
  std::ifstream in(compfilename, std::ios::binary | std::ios::ate);
  if (in.good()) {
    // get current position in the stream (was set to the end)
    G4int fileSize = (G4int)in.tellg();
    // set current position being the beginning of the stream
    in.seekg(0, std::ios::beg);
    // create (zlib) byte buffer for the data
    auto compdata = new Bytef[fileSize];
    while (in) {
      in.read((char*)compdata, fileSize);
    }
    // create (zlib) byte buffer for the uncompressed data
    auto complen = (uLongf)(fileSize * 4);
    auto uncompdata = new Bytef[complen];
    while (Z_OK != uncompress(uncompdata, &complen, compdata, fileSize)) {
      // increase uncompressed byte buffer
      delete[] uncompdata;
      complen *= 2;
      uncompdata = new Bytef[complen];
    }
    // delete the compressed data buffer
    delete[] compdata;
    // create a string from uncompressed data (will be deallocated by caller)
    dataString = new G4String((char*)uncompdata, (long)complen);
    // delete the uncompressed data buffer
    delete[] uncompdata;
  }
  else {
    G4ExceptionDescription ed;
    ed << "Problem while trying to read " + compfilename + " data file.\n";
    G4Exception("G4OpticalSurface::ReadCompressedFile", "mat316", FatalException, ed);
    return;
  }
  // create the input string stream from the data string
  if (dataString != nullptr) {
    iss.str(*dataString);
    in.close();
    delete dataString;
    G4cout << "G4OpticalSurface: data file " << compfilename << " successfully read in." << G4endl;
  }
}

Referenced by ReadLUTDAVISFile(), ReadLUTFile(), and ReadReflectivityLUTFile().

ReadDataFile()

void G4OpticalSurface::ReadDataFile

(

)

Definition at line 198 of file G4OpticalSurface.cc.

{
  // type and finish can be set in either order. Thus, we can't check
  // for consistency. Need to read file on setting either type or finish.
  switch (theType) {
    case dielectric_LUT:
      if (AngularDistribution == nullptr) {
        AngularDistribution = new G4float[incidentIndexMax * thetaIndexMax * phiIndexMax];
      }
      ReadLUTFile();
      break;
    case dielectric_LUTDAVIS:
      if (AngularDistributionLUT == nullptr) {
        AngularDistributionLUT = new G4float[indexmax];
      }
      ReadLUTDAVISFile();
 
      if (Reflectivity == nullptr) {
        Reflectivity = new G4float[RefMax];
      }
      ReadReflectivityLUTFile();
      break;
    case dielectric_dichroic:
      if (DichroicVector == nullptr) {
        DichroicVector = new G4Physics2DVector();
      }
      ReadDichroicFile();
      break;
    default:
      break;
  }
}

Referenced by G4OpticalSurface(), SetFinish(), and SetType().

ReadDichroicFile()

void G4OpticalSurface::ReadDichroicFile

(

)

Definition at line 453 of file G4OpticalSurface.cc.

{
  const char* datadir = G4FindDataDir("G4DICHROICDATA");
 
  if (datadir == nullptr) {
    G4Exception("G4OpticalSurface::ReadDichroicFile()", "mat313", FatalException,
      "Environment variable G4DICHROICDATA not defined");
    return;
  }
 
  std::ostringstream ost;
  ost << datadir;
  std::ifstream fin(ost.str().c_str());
  if (! fin.is_open()) {
    G4ExceptionDescription ed;
    ed << "Dichroic surface data file <" << ost.str().c_str() << "> is not opened!" << G4endl;
    G4Exception("G4OpticalSurface::ReadDichroicFile()", "mat314", FatalException, ed, " ");
    return;
  }
 
  if (! (DichroicVector->Retrieve(fin))) {
    G4ExceptionDescription ed;
    ed << "Dichroic surface data file <" << ost.str().c_str() << "> is not opened!" << G4endl;
    G4Exception("G4OpticalSurface::ReadDichroicFile()", "mat315", FatalException, ed, " ");
    return;
  }
 
  //  DichroicVector->SetBicubicInterpolation(true);
 
  G4cout << " *** Dichroic surface data file *** " << G4endl;
 
  auto numberOfXNodes = (G4int)DichroicVector->GetLengthX();
  auto numberOfYNodes = (G4int)DichroicVector->GetLengthY();
 
  G4cout << "numberOfXNodes: " << numberOfXNodes << G4endl;
  G4cout << "numberOfYNodes: " << numberOfYNodes << G4endl;
 
  if (0 > numberOfXNodes || numberOfXNodes >= INT_MAX) {
    numberOfXNodes = 0;
  }
  if (0 > numberOfYNodes || numberOfYNodes >= INT_MAX) {
    numberOfYNodes = 0;
  }
 
  G4PV2DDataVector xVector;
  G4PV2DDataVector yVector;
 
  xVector.resize(numberOfXNodes, 0.);
  yVector.resize(numberOfYNodes, 0.);
 
  for (G4int i = 0; i < numberOfXNodes; ++i) {
    G4cout << "i: " << DichroicVector->GetX(i) << G4endl;
    xVector[i] = DichroicVector->GetX(i);
  }
  for (G4int j = 0; j < numberOfYNodes; ++j) {
    G4cout << "j: " << DichroicVector->GetY(j) << G4endl;
    yVector[j] = DichroicVector->GetY(j);
  }
 
  for (G4int j = 0; j < numberOfYNodes; ++j) {
    for (G4int i = 0; i < numberOfXNodes; ++i) {
      G4cout << " i: " << i << " j: " << j << " " << DichroicVector->GetValue(i, j) << G4endl;
    }
  }
}

Referenced by ReadDataFile().

ReadLUTDAVISFile()

void G4OpticalSurface::ReadLUTDAVISFile

(

)

Definition at line 313 of file G4OpticalSurface.cc.

{
  G4String readLUTDAVISFileName;
 
  switch (theFinish) {
    case Rough_LUT:
      readLUTDAVISFileName = "Rough_LUT.z";
      break;
    case RoughTeflon_LUT:
      readLUTDAVISFileName = "RoughTeflon_LUT.z";
      break;
    case RoughESR_LUT:
      readLUTDAVISFileName = "RoughESR_LUT.z";
      break;
    case RoughESRGrease_LUT:
      readLUTDAVISFileName = "RoughESRGrease_LUT.z";
      break;
    case Polished_LUT:
      readLUTDAVISFileName = "Polished_LUT.z";
      break;
    case PolishedTeflon_LUT:
      readLUTDAVISFileName = "PolishedTeflon_LUT.z";
      break;
    case PolishedESR_LUT:
      readLUTDAVISFileName = "PolishedESR_LUT.z";
      break;
    case PolishedESRGrease_LUT:
      readLUTDAVISFileName = "PolishedESRGrease_LUT.z";
      break;
    case Detector_LUT:
      readLUTDAVISFileName = "Detector_LUT.z";
      break;
    default:
      return;
  }
 
  std::istringstream iss;
  ReadCompressedFile(readLUTDAVISFileName, iss);
 
  for (size_t i = 0; i < indexmax; ++i) {
    iss >> AngularDistributionLUT[i];
  }
  G4cout << "LUT DAVIS - data file: " << readLUTDAVISFileName << " read in! " << G4endl;
}

Referenced by ReadDataFile().

ReadLUTFile()

void G4OpticalSurface::ReadLUTFile

(

)

Definition at line 231 of file G4OpticalSurface.cc.

{
  G4String readLUTFileName;
 
  switch (theFinish) {
    case polishedlumirrorglue:
      readLUTFileName = "PolishedLumirrorGlue.z";
      break;
    case polishedlumirrorair:
      readLUTFileName = "PolishedLumirror.z";
      break;
    case polishedteflonair:
      readLUTFileName = "PolishedTeflon.z";
      break;
    case polishedtioair:
      readLUTFileName = "PolishedTiO.z";
      break;
    case polishedtyvekair:
      readLUTFileName = "PolishedTyvek.z";
      break;
    case polishedvm2000glue:
      readLUTFileName = "PolishedVM2000Glue.z";
      break;
    case polishedvm2000air:
      readLUTFileName = "PolishedVM2000.z";
      break;
    case etchedlumirrorglue:
      readLUTFileName = "EtchedLumirrorGlue.z";
      break;
    case etchedlumirrorair:
      readLUTFileName = "EtchedLumirror.z";
      break;
    case etchedteflonair:
      readLUTFileName = "EtchedTeflon.z";
      break;
    case etchedtioair:
      readLUTFileName = "EtchedTiO.z";
      break;
    case etchedtyvekair:
      readLUTFileName = "EtchedTyvek.z";
      break;
    case etchedvm2000glue:
      readLUTFileName = "EtchedVM2000Glue.z";
      break;
    case etchedvm2000air:
      readLUTFileName = "EtchedVM2000.z";
      break;
    case groundlumirrorglue:
      readLUTFileName = "GroundLumirrorGlue.z";
      break;
    case groundlumirrorair:
      readLUTFileName = "GroundLumirror.z";
      break;
    case groundteflonair:
      readLUTFileName = "GroundTeflon.z";
      break;
    case groundtioair:
      readLUTFileName = "GroundTiO.z";
      break;
    case groundtyvekair:
      readLUTFileName = "GroundTyvek.z";
      break;
    case groundvm2000glue:
      readLUTFileName = "GroundVM2000Glue.z";
      break;
    case groundvm2000air:
      readLUTFileName = "GroundVM2000.z";
      break;
    default:
      return;
  }
 
  std::istringstream iss;
  ReadCompressedFile(readLUTFileName, iss);
 
  size_t idxmax = incidentIndexMax * thetaIndexMax * phiIndexMax;
  for (size_t i = 0; i < idxmax; ++i) {
    iss >> AngularDistribution[i];
  }
  G4cout << "LUT - data file: " << readLUTFileName << " read in! " << G4endl;
}

Referenced by ReadDataFile().

ReadReflectivityLUTFile()

void G4OpticalSurface::ReadReflectivityLUTFile

(

)

Definition at line 358 of file G4OpticalSurface.cc.

{
  G4String readReflectivityLUTFileName;
 
  switch (theFinish) {
    case Rough_LUT:
      readReflectivityLUTFileName = "Rough_LUTR.z";
      break;
    case RoughTeflon_LUT:
      readReflectivityLUTFileName = "RoughTeflon_LUTR.z";
      break;
    case RoughESR_LUT:
      readReflectivityLUTFileName = "RoughESR_LUTR.z";
      break;
    case RoughESRGrease_LUT:
      readReflectivityLUTFileName = "RoughESRGrease_LUTR.z";
      break;
    case Polished_LUT:
      readReflectivityLUTFileName = "Polished_LUTR.z";
      break;
    case PolishedTeflon_LUT:
      readReflectivityLUTFileName = "PolishedTeflon_LUTR.z";
      break;
    case PolishedESR_LUT:
      readReflectivityLUTFileName = "PolishedESR_LUTR.z";
      break;
    case PolishedESRGrease_LUT:
      readReflectivityLUTFileName = "PolishedESRGrease_LUTR.z";
      break;
    case Detector_LUT:
      readReflectivityLUTFileName = "Detector_LUTR.z";
      break;
    default:
      return;
  }
 
  std::istringstream iss;
  ReadCompressedFile(readReflectivityLUTFileName, iss);
 
  for (size_t i = 0; i < RefMax; ++i) {
    iss >> Reflectivity[i];
  }
  G4cout << "LUT DAVIS - reflectivity data file: " << readReflectivityLUTFileName << " read in! "
         << G4endl;
}

Referenced by ReadDataFile().

SetFinish()

void G4OpticalSurface::SetFinish

(

const G4OpticalSurfaceFinish

finish

)

Definition at line 192 of file G4OpticalSurface.cc.

{
  theFinish = finish;
  ReadDataFile();
}

SetMaterialPropertiesTable()

void G4OpticalSurface::SetMaterialPropertiesTable ( G4MaterialPropertiesTable * anMPT )

inline

Definition at line 169 of file G4OpticalSurface.hh.

  {
    theMaterialPropertiesTable = anMPT;
  }

Referenced by G4GDMLReadSolids::PropertyRead().

SetModel()

void G4OpticalSurface::SetModel ( const G4OpticalSurfaceModel model )

inline

Definition at line 147 of file G4OpticalSurface.hh.

{ theModel = model; }

SetPolish()

void G4OpticalSurface::SetPolish ( const G4double plsh )

inline

Definition at line 159 of file G4OpticalSurface.hh.

{ polish = plsh; }

SetSigmaAlpha()

void G4OpticalSurface::SetSigmaAlpha ( const G4double s_a )

inline

Definition at line 153 of file G4OpticalSurface.hh.

{ sigma_alpha = s_a; }

SetType()

void G4OpticalSurface::SetType ( const G4SurfaceType & type )

overridevirtual

Reimplemented from G4SurfaceProperty.

Definition at line 186 of file G4OpticalSurface.cc.

{
  theType = type;
  ReadDataFile();
}

---

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

• G4OpticalSurface.hh
• G4OpticalSurface.cc