G4OpticalSurface Class Reference

#include <G4OpticalSurface.hh>

Inheritance diagram for G4OpticalSurface:

Public Member Functions
	G4OpticalSurface (const G4OpticalSurface &right)
G4OpticalSurface &	operator= (const G4OpticalSurface &right)
G4int	operator== (const G4OpticalSurface &right) const
G4int	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)
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	ReadFile (void)
G4double	GetAngularDistributionValue (G4int, G4int, G4int)
G4int	GetThetaIndexMax (void) const
G4int	GetPhiIndexMax (void) const
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
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 111 of file G4OpticalSurface.hh.

Constructor & Destructor Documentation

G4OpticalSurface() [1/2]

G4OpticalSurface::G4OpticalSurface

(

const G4OpticalSurface &

right

)

Definition at line 117 of file G4OpticalSurface.cc.

  : G4SurfaceProperty(right.theName,right.theType)
{
       *this = right;
       this->theMaterialPropertiesTable = right.theMaterialPropertiesTable;
       this->AngularDistribution = right.AngularDistribution;
       this->readFileHandle = right.readFileHandle;
}

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 75 of file G4OpticalSurface.cc.

                                   : G4SurfaceProperty(name,type),
                     theModel(model),
                     theFinish(finish),
                     theMaterialPropertiesTable(0)
{
    if (model == glisur ){
        polish = value;
        sigma_alpha = 0.0;
    }
    else if ( model == unified ) {
        sigma_alpha = value;
        polish = 0.0;
    }
        else if ( model == LUT ) {
                sigma_alpha = value;
                polish = 0.0;
        }
    else {
                G4Exception("G4OpticalSurface::G4OpticalSurface()", "mat309",
                            FatalException,
                "Constructor called with INVALID model.");
    }
 
        AngularDistribution = NULL;
 
        if (type == dielectric_LUT) {
           AngularDistribution =
                       new G4float[incidentIndexMax*thetaIndexMax*phiIndexMax];
           ReadFile();
        }
}

~G4OpticalSurface()

G4OpticalSurface::~G4OpticalSurface ( )

virtual

Definition at line 112 of file G4OpticalSurface.cc.

{
        if (AngularDistribution) delete AngularDistribution;
}

Member Function Documentation

DumpInfo()

void G4OpticalSurface::DumpInfo

(

)

const

Definition at line 139 of file G4OpticalSurface.cc.

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

GetAngularDistributionValue()

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

inline

Definition at line 224 of file G4OpticalSurface.hh.

{
  return AngularDistribution[angleIncident+
                             thetaIndex*incidentIndexMax+
                             phiIndex*thetaIndexMax*incidentIndexMax];
}

GetFinish()

G4OpticalSurfaceFinish G4OpticalSurface::GetFinish ( ) const

inline

Definition at line 153 of file G4OpticalSurface.hh.

{ return theFinish; }

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

GetMaterialPropertiesTable()

G4MaterialPropertiesTable * G4OpticalSurface::GetMaterialPropertiesTable ( ) const

inline

Definition at line 174 of file G4OpticalSurface.hh.

                       { return theMaterialPropertiesTable; }

GetModel()

G4OpticalSurfaceModel G4OpticalSurface::GetModel ( ) const

inline

Definition at line 158 of file G4OpticalSurface.hh.

{ return theModel; }

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

GetPhiIndexMax()

G4int G4OpticalSurface::GetPhiIndexMax ( void  ) const

inline

Definition at line 192 of file G4OpticalSurface.hh.

{ return phiIndexMax; } 

GetPolish()

G4double G4OpticalSurface::GetPolish ( ) const

inline

Definition at line 169 of file G4OpticalSurface.hh.

{ return polish; }

Referenced by G4GDMLWriteSolids::OpticalSurfaceWrite().

GetSigmaAlpha()

G4double G4OpticalSurface::GetSigmaAlpha ( ) const

inline

Definition at line 164 of file G4OpticalSurface.hh.

{ return sigma_alpha; }

Referenced by G4GDMLWriteSolids::OpticalSurfaceWrite().

GetThetaIndexMax()

G4int G4OpticalSurface::GetThetaIndexMax ( void  ) const

inline

Definition at line 191 of file G4OpticalSurface.hh.

{ return thetaIndexMax; }

operator!=()

G4int G4OpticalSurface::operator!=

(

const G4OpticalSurface &

right

)

const

Definition at line 131 of file G4OpticalSurface.cc.

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

operator=()

G4OpticalSurface & G4OpticalSurface::operator=

(

const G4OpticalSurface &

right

)

Definition at line 54 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;
      AngularDistribution        = right.AngularDistribution;
      readFileHandle             = right.readFileHandle;
     } 
  return *this;
}

operator==()

G4int G4OpticalSurface::operator==

(

const G4OpticalSurface &

right

)

const

Definition at line 126 of file G4OpticalSurface.cc.

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

ReadFile()

void G4OpticalSurface::ReadFile

(

void

)

Definition at line 185 of file G4OpticalSurface.cc.

{
  G4String readFileName = " ";
 
  if (theFinish == polishedlumirrorglue) {
     readFileName = "PolishedLumirrorGlue.dat";
  }
  else if (theFinish == polishedlumirrorair) {
     readFileName = "PolishedLumirror.dat";
  }
  else if (theFinish == polishedteflonair) {
     readFileName = "PolishedTeflon.dat";
  }
  else if (theFinish == polishedtioair) {
     readFileName = "PolishedTiO.dat";
  }
  else if (theFinish == polishedtyvekair) {
     readFileName = "PolishedTyvek.dat";
  }
  else if (theFinish == polishedvm2000glue) {
     readFileName = "PolishedVM2000Glue.dat";
  }
  else if (theFinish == polishedvm2000air) {
     readFileName = "PolishedVM2000.dat";
  }
  else if (theFinish == etchedlumirrorglue) {
     readFileName = "EtchedLumirrorGlue.dat";
  }
  else if (theFinish == etchedlumirrorair) {
     readFileName = "EtchedLumirror.dat";
  }
  else if (theFinish == etchedteflonair) {
     readFileName = "EtchedTeflon.dat";
  }
  else if (theFinish == etchedtioair) {
     readFileName = "EtchedTiO.dat";
  }
  else if (theFinish == etchedtyvekair) {
     readFileName = "EtchedTyvek.dat";
  }
  else if (theFinish == etchedvm2000glue) {
     readFileName = "EtchedVM2000Glue.dat";
  }
  else if (theFinish == etchedvm2000air) {
     readFileName = "EtchedVM2000.dat";
  }
  else if (theFinish == groundlumirrorglue) {
     readFileName = "GroundLumirrorGlue.dat";
  }
  else if (theFinish == groundlumirrorair) {
     readFileName = "GroundLumirror.dat";
  }
  else if (theFinish == groundteflonair) {
     readFileName = "GroundTeflon.dat";
  }
  else if (theFinish == groundtioair) {
     readFileName = "GroundTiO.dat";
  }
  else if (theFinish == groundtyvekair) {
     readFileName = "GroundTyvek.dat";
  }
  else if (theFinish == groundvm2000glue) {
     readFileName = "GroundVM2000Glue.dat";
  }
  else if (theFinish == groundvm2000air) {
     readFileName = "GroundVM2000.dat";
  }
 
  if (readFileName == " ") return;
 
  char* path = getenv("G4REALSURFACEDATA");
  if (!path) {
     G4String excep =
        "G4OpBoundaryProcess - G4REALSURFACEDATA environment variable not set";
     G4Exception("G4OpticalSurface::ReadFile()", "mat310",
                 FatalException, excep);
     return;
  }
  G4String pathString(path);
 
  readFileName = pathString + "/" + readFileName;
 
  readFileHandle = fopen(readFileName,"r");
 
  if (readFileHandle) {
     G4int ncols;
     G4int idxmax = incidentIndexMax*thetaIndexMax*phiIndexMax;
     for (G4int i = 0; i<idxmax; i++) {
       ncols = fscanf(readFileHandle,"%6f", &AngularDistribution[i]);
       if (ncols < 0) break;
     }
     if (ncols >= 0) {
        G4cout << "LUT - data file: " << readFileName << " read in! " << G4endl;
     }
     else {
        G4String excep = "LUT - data file: "+ readFileName +" not read propery";
        G4Exception("G4OpticalSurface::ReadFile()", "mat312",
                    FatalException, excep);
        return;
     }
  }
  else {
     G4String excep = "LUT - data file: " + readFileName + " not found";
     G4Exception("G4OpticalSurface::ReadFile()", "mat311",
                 FatalException, excep);
     return;
  }
  fclose(readFileHandle);
}

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

SetFinish()

void G4OpticalSurface::SetFinish

(

const G4OpticalSurfaceFinish

finish

)

Definition at line 175 of file G4OpticalSurface.cc.

{
  theFinish = finish;
  if (theType == dielectric_LUT) {
     if (!AngularDistribution) AngularDistribution =
                       new G4float[incidentIndexMax*thetaIndexMax*phiIndexMax];
     ReadFile();
  }
}

SetMaterialPropertiesTable()

void G4OpticalSurface::SetMaterialPropertiesTable ( G4MaterialPropertiesTable *  anMPT )

inline

Definition at line 179 of file G4OpticalSurface.hh.

                       { theMaterialPropertiesTable = anMPT; }

SetModel()

void G4OpticalSurface::SetModel ( const G4OpticalSurfaceModel  model )

inline

Definition at line 160 of file G4OpticalSurface.hh.

                                                      { theModel = model; }

SetPolish()

void G4OpticalSurface::SetPolish ( const G4double  plsh )

inline

Definition at line 171 of file G4OpticalSurface.hh.

{ polish=plsh; }

SetSigmaAlpha()

void G4OpticalSurface::SetSigmaAlpha ( const G4double  s_a )

inline

Definition at line 166 of file G4OpticalSurface.hh.

{ sigma_alpha = s_a; }

SetType()

void G4OpticalSurface::SetType

(

const G4SurfaceType &

type

)

Definition at line 165 of file G4OpticalSurface.cc.

{
  theType = type;
  if (type == dielectric_LUT) {
     if (!AngularDistribution) AngularDistribution =
                       new G4float[incidentIndexMax*thetaIndexMax*phiIndexMax];
     ReadFile();
  }
}

---

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

• G4OpticalSurface.hh
• G4OpticalSurface.cc