G4OpticalSurface Class Reference

#include <G4OpticalSurface.hh>

Inheritance diagram for G4OpticalSurface:

Public Member Functions
	G4OpticalSurface (const G4OpticalSurface &right)
G4OpticalSurface &	operator= (const G4OpticalSurface &right)
G4bool	operator== (const G4OpticalSurface &right) const
G4bool	operator!= (const G4OpticalSurface &right) const
	G4OpticalSurface (const G4String &name, G4OpticalSurfaceModel model=glisur, G4OpticalSurfaceFinish finish=polished, G4SurfaceType type=dielectric_dielectric, G4double value=1.0)
virtual	~G4OpticalSurface ()
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)
void	ReadCompressedFile (G4String, std::istringstream &)
void	ReadLUTFile (void)
G4double	GetAngularDistributionValue (G4int, G4int, G4int)
G4double	GetAngularDistributionValueLUT (G4int)
void	ReadLUTDAVISFile (void)
void	ReadReflectivityLUTFile (void)
G4double	GetReflectivityLUTValue (G4int)
G4int	GetInmax (void) const
G4int	GetLUTbins (void) const
G4int	GetRefMax (void) const
G4int	GetThetaIndexMax (void) const
G4int	GetPhiIndexMax (void) const
void	ReadDichroicFile (void)
G4Physics2DVector *	GetDichroicVector ()
Public Member Functions inherited from G4SurfaceProperty
	G4SurfaceProperty (const G4String &name, G4SurfaceType type=x_ray)
	G4SurfaceProperty ()
virtual	~G4SurfaceProperty ()
const G4String &	GetName () const
void	SetName (const G4String &name)
const G4SurfaceType &	GetType () const
virtual void	SetType (const G4SurfaceType &type)

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 121 of file G4OpticalSurface.hh.

Constructor & Destructor Documentation

G4OpticalSurface() [1/2]

G4OpticalSurface::G4OpticalSurface

(

const G4OpticalSurface &

right

)

Definition at line 134 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;
 
  if(this->AngularDistribution)
    delete[] AngularDistribution;
  this->AngularDistribution =
    new G4float[incidentIndexMax * thetaIndexMax * phiIndexMax];
  *(this->AngularDistribution) = *(right.AngularDistribution);
 
  if(this->AngularDistributionLUT)
    delete[] AngularDistributionLUT;
  this->AngularDistributionLUT    = new G4float[indexmax];
  *(this->AngularDistributionLUT) = *(right.AngularDistributionLUT);
  if(this->Reflectivity)
    delete[] Reflectivity;
  this->Reflectivity    = new G4float[RefMax];
  *(this->Reflectivity) = *(right.Reflectivity);
 
  if(this->DichroicVector)
    delete DichroicVector;
  this->DichroicVector    = new G4Physics2DVector();
  *(this->DichroicVector) = *(right.DichroicVector);
}

G4OpticalSurface() [2/2]

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

Definition at line 83 of file G4OpticalSurface.cc.

  : G4SurfaceProperty(name, type)
  , theModel(model)
  , theFinish(finish)
  , theMaterialPropertiesTable(nullptr)
{
  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.");
  }
}

~G4OpticalSurface()

G4OpticalSurface::~G4OpticalSurface ( )

virtual

Definition at line 120 of file G4OpticalSurface.cc.

{
  if(AngularDistribution)
    delete[] AngularDistribution;
 
  if(AngularDistributionLUT)
    delete[] AngularDistributionLUT;
  if(Reflectivity)
    delete[] Reflectivity;
 
  if(DichroicVector)
    delete DichroicVector;
}

Member Function Documentation

DumpInfo()

void G4OpticalSurface::DumpInfo

(

)

const

Definition at line 187 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 265 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 291 of file G4OpticalSurface.hh.

{
  return DichroicVector;
}

GetFinish()

G4OpticalSurfaceFinish G4OpticalSurface::GetFinish ( ) const

inline

Definition at line 140 of file G4OpticalSurface.hh.

{ return theFinish; }

Referenced by G4GDMLWriteSolids::OpticalSurfaceWrite(), and G4OpBoundaryProcess::PostStepDoIt().

GetInmax()

G4int G4OpticalSurface::GetInmax

(

void

)

const

Definition at line 177 of file G4OpticalSurface.cc.

{ return indexmax; }

GetLUTbins()

G4int G4OpticalSurface::GetLUTbins

(

void

)

const

Definition at line 179 of file G4OpticalSurface.cc.

{ return LUTbins; }

GetMaterialPropertiesTable()

G4MaterialPropertiesTable * G4OpticalSurface::GetMaterialPropertiesTable ( ) const

inline

Definition at line 160 of file G4OpticalSurface.hh.

  {
    return theMaterialPropertiesTable;
  }

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

GetModel()

G4OpticalSurfaceModel G4OpticalSurface::GetModel ( ) const

inline

Definition at line 145 of file G4OpticalSurface.hh.

{ return theModel; }

Referenced by G4GDMLWriteSolids::OpticalSurfaceWrite(), and G4OpBoundaryProcess::PostStepDoIt().

GetPhiIndexMax()

G4int G4OpticalSurface::GetPhiIndexMax

(

void

)

const

Definition at line 185 of file G4OpticalSurface.cc.

{ return phiIndexMax; }

GetPolish()

G4double G4OpticalSurface::GetPolish ( ) const

inline

Definition at line 155 of file G4OpticalSurface.hh.

{ return polish; }

Referenced by G4GDMLWriteSolids::OpticalSurfaceWrite().

GetReflectivityLUTValue()

G4double G4OpticalSurface::GetReflectivityLUTValue ( G4int  i )

inline

Definition at line 278 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

(

void

)

const

Definition at line 181 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

(

void

)

const

Definition at line 183 of file G4OpticalSurface.cc.

{ return thetaIndexMax; }

operator!=()

G4bool G4OpticalSurface::operator!=

(

const G4OpticalSurface &

right

)

const

Definition at line 172 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;
 
    if(AngularDistribution)
      delete[] AngularDistribution;
    AngularDistribution =
      new G4float[incidentIndexMax * thetaIndexMax * phiIndexMax];
    *(AngularDistribution) = *(right.AngularDistribution);
 
    if(AngularDistributionLUT)
      delete[] AngularDistributionLUT;
    AngularDistributionLUT    = new G4float[indexmax];
    *(AngularDistributionLUT) = *(right.AngularDistributionLUT);
 
    if(Reflectivity)
      delete[] Reflectivity;
    Reflectivity    = new G4float[RefMax];
    *(Reflectivity) = *(right.Reflectivity);
 
    if(DichroicVector)
      delete DichroicVector;
    DichroicVector  = new G4Physics2DVector();
    *DichroicVector = *(right.DichroicVector);
  }
  return *this;
}

operator==()

G4bool G4OpticalSurface::operator==

(

const G4OpticalSurface &

right

)

const

Definition at line 167 of file G4OpticalSurface.cc.

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

ReadCompressedFile()

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

Definition at line 432 of file G4OpticalSurface.cc.

{
  G4String* dataString  = nullptr;
  G4String path         = std::getenv("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)
    int fileSize = in.tellg();
    // set current position being the beginning of the stream
    in.seekg(0, std::ios::beg);
    // create (zlib) byte buffer for the data
    Bytef* compdata = new Bytef[fileSize];
    while(in)
    {
      in.read((char*) compdata, fileSize);
    }
    // create (zlib) byte buffer for the uncompressed data
    uLongf complen    = (uLongf)(fileSize * 4);
    Bytef* 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)
  {
    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

(

void

)

Definition at line 220 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)
        AngularDistribution =
          new G4float[incidentIndexMax * thetaIndexMax * phiIndexMax];
      ReadLUTFile();
      break;
    case dielectric_LUTDAVIS:
      if(!AngularDistributionLUT)
        AngularDistributionLUT = new G4float[indexmax];
      ReadLUTDAVISFile();
 
      if(!Reflectivity)
        Reflectivity = new G4float[RefMax];
      ReadReflectivityLUTFile();
      break;
    case dielectric_dichroic:
      if(!DichroicVector)
        DichroicVector = new G4Physics2DVector();
      ReadDichroicFile();
      break;
    default:
      break;
  }
}

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

ReadDichroicFile()

void G4OpticalSurface::ReadDichroicFile

(

void

)

Definition at line 488 of file G4OpticalSurface.cc.

{
  const char* datadir = std::getenv("G4DICHROICDATA");
 
  if(!datadir)
  {
    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;
 
  G4int numberOfXNodes = DichroicVector->GetLengthX();
  G4int numberOfYNodes = 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

(

void

)

Definition at line 335 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

(

void

)

Definition at line 251 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

(

void

)

Definition at line 383 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 214 of file G4OpticalSurface.cc.

{
  theFinish = finish;
  ReadDataFile();
}

SetMaterialPropertiesTable()

void G4OpticalSurface::SetMaterialPropertiesTable ( G4MaterialPropertiesTable *  anMPT )

inline

Definition at line 167 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 157 of file G4OpticalSurface.hh.

{ polish = plsh; }

SetSigmaAlpha()

void G4OpticalSurface::SetSigmaAlpha ( const G4double  s_a )

inline

Definition at line 152 of file G4OpticalSurface.hh.

{ sigma_alpha = s_a; }

SetType()

void G4OpticalSurface::SetType ( const G4SurfaceType &  type )

overridevirtual

Reimplemented from G4SurfaceProperty.

Definition at line 208 of file G4OpticalSurface.cc.

{
  theType = type;
  ReadDataFile();
}

---

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

• G4OpticalSurface.hh
• G4OpticalSurface.cc