G4OpticalSurface Class Reference

#include <G4OpticalSurface.hh>

Inheritance diagram for G4OpticalSurface:

Collaboration 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	ReadLUTFile (void)
G4double	GetAngularDistributionValue (G4int, G4int, G4int)
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
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 113 of file G4OpticalSurface.hh.

Constructor & Destructor Documentation

G4OpticalSurface::G4OpticalSurface

(

const G4OpticalSurface &

right

)

Definition at line 136 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->DichroicVector) delete DichroicVector;
       this->DichroicVector = new G4Physics2DVector();
       *(this->DichroicVector) = *(right.DichroicVector);
}

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(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 if ( model == dichroic ) {
                sigma_alpha = value;
                polish = 0.0;
        }
    else {
                G4Exception("G4OpticalSurface::G4OpticalSurface()", "mat309",
                            FatalException,
                "Constructor called with INVALID model.");
    }

        AngularDistribution = NULL;
        DichroicVector      = NULL;

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

        if (type == dielectric_dichroic) {
           DichroicVector = new G4Physics2DVector();
           ReadDichroicFile();
        }
}

Here is the call graph for this function:

G4OpticalSurface::~G4OpticalSurface ( )

virtual

Definition at line 130 of file G4OpticalSurface.cc.

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

Member Function Documentation

void G4OpticalSurface::DumpInfo

(

)

const

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

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

inline

Definition at line 230 of file G4OpticalSurface.hh.

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

G4Physics2DVector * G4OpticalSurface::GetDichroicVector ( )

inline

Definition at line 240 of file G4OpticalSurface.hh.

{
  return DichroicVector;
}

G4OpticalSurfaceFinish G4OpticalSurface::GetFinish ( ) const

inline

Definition at line 155 of file G4OpticalSurface.hh.

{ return theFinish; }

Here is the caller graph for this function:

G4MaterialPropertiesTable* G4OpticalSurface::GetMaterialPropertiesTable ( ) const

inline

Definition at line 176 of file G4OpticalSurface.hh.

                       { return theMaterialPropertiesTable; }

G4OpticalSurfaceModel G4OpticalSurface::GetModel ( ) const

inline

Definition at line 160 of file G4OpticalSurface.hh.

{ return theModel; }

Here is the caller graph for this function:

G4int G4OpticalSurface::GetPhiIndexMax ( void  ) const

inline

Definition at line 194 of file G4OpticalSurface.hh.

{ return phiIndexMax; }

G4double G4OpticalSurface::GetPolish ( ) const

inline

Definition at line 171 of file G4OpticalSurface.hh.

{ return polish; }

Here is the caller graph for this function:

G4double G4OpticalSurface::GetSigmaAlpha ( ) const

inline

Definition at line 166 of file G4OpticalSurface.hh.

{ return sigma_alpha; }

Here is the caller graph for this function:

G4int G4OpticalSurface::GetThetaIndexMax ( void  ) const

inline

Definition at line 193 of file G4OpticalSurface.hh.

{ return thetaIndexMax; }

G4int G4OpticalSurface::operator!=

(

const G4OpticalSurface &

right

)

const

Definition at line 161 of file G4OpticalSurface.cc.

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

G4OpticalSurface & G4OpticalSurface::operator=

(

const G4OpticalSurface &

right

)

Definition at line 57 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 (DichroicVector) delete DichroicVector;
      DichroicVector = new G4Physics2DVector();
      *DichroicVector            = *(right.DichroicVector);
     } 
  return *this;
}

G4int G4OpticalSurface::operator==

(

const G4OpticalSurface &

right

)

const

Definition at line 156 of file G4OpticalSurface.cc.

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

void G4OpticalSurface::ReadDichroicFile

(

void

)

Definition at line 332 of file G4OpticalSurface.cc.

{
  const char* datadir = 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;
     }
  }

//  G4int idx, idy;

//  for(G4int j = 0; j<numberOfYNodes-1; ++j) {
//     G4double y = (yVector[j] + yVector[j+1])/2.;
//     for(G4int i = 0; i<numberOfXNodes-1; ++i) {
//        G4double x = (xVector[i] + xVector[i+1])/2.;
//        G4cout << " x: " << x << " y: " << y << " "
//               << DichroicVector->Value(x,y,idx,idy) << G4endl;
//     }
//  }

}

Here is the call graph for this function:

Here is the caller graph for this function:

void G4OpticalSurface::ReadLUTFile

(

void

)

Definition at line 223 of file G4OpticalSurface.cc.

{
  G4String readLUTFileName = " ";

  if (theFinish == polishedlumirrorglue) {
     readLUTFileName = "PolishedLumirrorGlue.dat";
  }
  else if (theFinish == polishedlumirrorair) {
     readLUTFileName = "PolishedLumirror.dat";
  }
  else if (theFinish == polishedteflonair) {
     readLUTFileName = "PolishedTeflon.dat";
  }
  else if (theFinish == polishedtioair) {
     readLUTFileName = "PolishedTiO.dat";
  }
  else if (theFinish == polishedtyvekair) {
     readLUTFileName = "PolishedTyvek.dat";
  }
  else if (theFinish == polishedvm2000glue) {
     readLUTFileName = "PolishedVM2000Glue.dat";
  }
  else if (theFinish == polishedvm2000air) {
     readLUTFileName = "PolishedVM2000.dat";
  }
  else if (theFinish == etchedlumirrorglue) {
     readLUTFileName = "EtchedLumirrorGlue.dat";
  }
  else if (theFinish == etchedlumirrorair) {
     readLUTFileName = "EtchedLumirror.dat";
  }
  else if (theFinish == etchedteflonair) {
     readLUTFileName = "EtchedTeflon.dat";
  }
  else if (theFinish == etchedtioair) {
     readLUTFileName = "EtchedTiO.dat";
  }
  else if (theFinish == etchedtyvekair) {
     readLUTFileName = "EtchedTyvek.dat";
  }
  else if (theFinish == etchedvm2000glue) {
     readLUTFileName = "EtchedVM2000Glue.dat";
  }
  else if (theFinish == etchedvm2000air) {
     readLUTFileName = "EtchedVM2000.dat";
  }
  else if (theFinish == groundlumirrorglue) {
     readLUTFileName = "GroundLumirrorGlue.dat";
  }
  else if (theFinish == groundlumirrorair) {
     readLUTFileName = "GroundLumirror.dat";
  }
  else if (theFinish == groundteflonair) {
     readLUTFileName = "GroundTeflon.dat";
  }
  else if (theFinish == groundtioair) {
     readLUTFileName = "GroundTiO.dat";
  }
  else if (theFinish == groundtyvekair) {
     readLUTFileName = "GroundTyvek.dat";
  }
  else if (theFinish == groundvm2000glue) {
     readLUTFileName = "GroundVM2000Glue.dat";
  }
  else if (theFinish == groundvm2000air) {
     readLUTFileName = "GroundVM2000.dat";
  }

  if (readLUTFileName == " ") return;

  char* path = getenv("G4REALSURFACEDATA");
  if (!path) {
     G4String excep =
        "G4OpBoundaryProcess - G4REALSURFACEDATA environment variable not set";
     G4Exception("G4OpticalSurface::ReadLUTFile()", "mat310",
                 FatalException, excep);
     return;
  }
  G4String pathString(path);

  readLUTFileName = pathString + "/" + readLUTFileName;

  std::ifstream readLUTFileHandle(readLUTFileName, std::ios::in);

  if (readLUTFileHandle) {
     G4int idxmax = incidentIndexMax*thetaIndexMax*phiIndexMax;
     for (G4int i = 0; i<idxmax; i++) {
       if (readLUTFileHandle.eof()) break;
       readLUTFileHandle >> AngularDistribution[i];
     }
     if (!readLUTFileHandle.bad()) {
        G4cout <<"LUT - data file: "<< readLUTFileName <<" read in! "<< G4endl;
     }
     else {
        G4String excep="LUT - data file: "+readLUTFileName+" not read propery";
        G4Exception("G4OpticalSurface::ReadLUTFile()", "mat312",
                    FatalException, excep);
        return;
     }
  }
  else {
     G4String excep ="LUT - data file: "+readLUTFileName+" not found";
     G4Exception("G4OpticalSurface::ReadLUTFile()", "mat311",
                 FatalException, excep);
     return;
  }
  readLUTFileHandle.close();
}

Here is the call graph for this function:

Here is the caller graph for this function:

void G4OpticalSurface::SetFinish

(

const G4OpticalSurfaceFinish

finish

)

Definition at line 209 of file G4OpticalSurface.cc.

{
  theFinish = finish;
  if (theType == dielectric_LUT) {
     if (!AngularDistribution) AngularDistribution =
                       new G4float[incidentIndexMax*thetaIndexMax*phiIndexMax];
     ReadLUTFile();
  }
  if (theType == dielectric_dichroic) {
     if (!DichroicVector) DichroicVector = new G4Physics2DVector();
     ReadDichroicFile();
  }
}

Here is the call graph for this function:

void G4OpticalSurface::SetMaterialPropertiesTable ( G4MaterialPropertiesTable *  anMPT )

inline

Definition at line 181 of file G4OpticalSurface.hh.

                       { theMaterialPropertiesTable = anMPT; }

void G4OpticalSurface::SetModel ( const G4OpticalSurfaceModel  model )

inline

Definition at line 162 of file G4OpticalSurface.hh.

                                                      { theModel = model; }

void G4OpticalSurface::SetPolish ( const G4double  plsh )

inline

Definition at line 173 of file G4OpticalSurface.hh.

{ polish=plsh; }

void G4OpticalSurface::SetSigmaAlpha ( const G4double  s_a )

inline

Definition at line 168 of file G4OpticalSurface.hh.

{ sigma_alpha = s_a; }

void G4OpticalSurface::SetType

(

const G4SurfaceType &

type

)

Definition at line 195 of file G4OpticalSurface.cc.

{
  theType = type;
  if (type == dielectric_LUT) {
     if (!AngularDistribution) AngularDistribution =
                       new G4float[incidentIndexMax*thetaIndexMax*phiIndexMax];
     ReadLUTFile();
  }
  if (type == dielectric_dichroic) {
     if (!DichroicVector) DichroicVector = new G4Physics2DVector();
     ReadDichroicFile();
  }
}

Here is the call graph for this function:

---

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

• geant4.10.03.p01/source/materials/include/G4OpticalSurface.hh
• geant4.10.03.p01/source/materials/src/G4OpticalSurface.cc