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

References right, G4SurfaceProperty::theName, and G4SurfaceProperty::theType.

  : 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;
       this->AngularDistribution = right.AngularDistribution;
       this->readLUTFileHandle = right.readLUTFileHandle;
       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 78 of file G4OpticalSurface.cc.

References dichroic, dielectric_dichroic, dielectric_LUT, FatalException, G4Exception(), glisur, LUT, ReadDichroicFile(), ReadLUTFile(), and unified.

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

        readLUTFileHandle   = NULL;

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

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

G4OpticalSurface::~G4OpticalSurface ( )

virtual

Definition at line 127 of file G4OpticalSurface.cc.

{
        if (AngularDistribution) delete AngularDistribution;
        if (DichroicVector) delete DichroicVector;

        if (readLUTFileHandle) delete readLUTFileHandle;
}

Member Function Documentation

void G4OpticalSurface::DumpInfo

(

)

const

Definition at line 164 of file G4OpticalSurface.cc.

References G4cout, G4endl, glisur, LUT, and G4SurfaceProperty::theType.

Referenced by OpNoviceDetectorConstruction::Construct().

{

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

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

G4Physics2DVector * G4OpticalSurface::GetDichroicVector ( )

inline

Definition at line 243 of file G4OpticalSurface.hh.

{
  return DichroicVector;
}

G4OpticalSurfaceFinish G4OpticalSurface::GetFinish ( ) const

inline

Definition at line 155 of file G4OpticalSurface.hh.

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

{ return theFinish; }

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.

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

{ return theModel; }

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.

Referenced by G4GDMLWriteSolids::OpticalSurfaceWrite().

{ return polish; }

G4double G4OpticalSurface::GetSigmaAlpha ( ) const

inline

Definition at line 166 of file G4OpticalSurface.hh.

Referenced by G4GDMLWriteSolids::OpticalSurfaceWrite().

{ return sigma_alpha; }

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

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

G4OpticalSurface & G4OpticalSurface::operator=

(

const G4OpticalSurface &

right

)

Definition at line 54 of file G4OpticalSurface.cc.

References G4SurfaceProperty::theName, G4SurfaceProperty::theSurfacePropertyTable, and G4SurfaceProperty::theType.

{
  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;
      readLUTFileHandle          = right.readLUTFileHandle;
      DichroicVector             = right.DichroicVector;

      theSurfacePropertyTable    = right.theSurfacePropertyTable;
     } 
  return *this;
}

G4int G4OpticalSurface::operator==

(

const G4OpticalSurface &

right

)

const

Definition at line 151 of file G4OpticalSurface.cc.

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

void G4OpticalSurface::ReadDichroicFile

(

void

)

Definition at line 328 of file G4OpticalSurface.cc.

References FatalException, G4cout, G4endl, G4Exception(), G4Physics2DVector::GetLengthX(), G4Physics2DVector::GetLengthY(), G4Physics2DVector::GetValue(), G4Physics2DVector::GetX(), G4Physics2DVector::GetY(), and G4Physics2DVector::Retrieve().

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

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

  size_t numberOfXNodes = DichroicVector->GetLengthX();
  size_t numberOfYNodes = DichroicVector->GetLengthY();

  G4cout << "numberOfXNodes: " << numberOfXNodes << G4endl;
  G4cout << "numberOfYNodes: " << numberOfYNodes << G4endl;

  G4PV2DDataVector  xVector;
  G4PV2DDataVector  yVector;

  xVector.resize(numberOfXNodes,0.);
  yVector.resize(numberOfYNodes,0.);

  for(size_t i = 0; i<numberOfXNodes; ++i) {
     G4cout << "i: " << DichroicVector->GetX(i) << G4endl;
     xVector[i] = DichroicVector->GetX(i);
  }
  for(size_t j = 0; j<numberOfYNodes; ++j) {
     G4cout << "j: " << DichroicVector->GetY(j) << G4endl;
     yVector[j] = DichroicVector->GetY(j);
  }

  for(size_t j = 0; j<numberOfYNodes; ++j) {
     for(size_t i = 0; i<numberOfXNodes; ++i) {
        G4cout << " i: " << i << " j: " << j << " "
               << DichroicVector->GetValue(i,j) << G4endl;
     }
  }

//  size_t idx, idy;

//  for(size_t j = 0; j<numberOfYNodes-1; ++j) {
//     G4double y = (yVector[j] + yVector[j+1])/2.;
//     for(size_t 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;
//     }
//  }

}

void G4OpticalSurface::ReadLUTFile

(

void

)

Definition at line 218 of file G4OpticalSurface.cc.

References etchedlumirrorair, etchedlumirrorglue, etchedteflonair, etchedtioair, etchedtyvekair, etchedvm2000air, etchedvm2000glue, FatalException, G4cout, G4endl, G4Exception(), groundlumirrorair, groundlumirrorglue, groundteflonair, groundtioair, groundtyvekair, groundvm2000air, groundvm2000glue, polishedlumirrorair, polishedlumirrorglue, polishedteflonair, polishedtioair, polishedtyvekair, polishedvm2000air, and polishedvm2000glue.

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

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

  readLUTFileHandle = fopen(readLUTFileName,"r");

  if (readLUTFileHandle) {
     G4int ncols;
     G4int idxmax = incidentIndexMax*thetaIndexMax*phiIndexMax;
     for (G4int i = 0; i<idxmax; i++) {
       ncols = fscanf(readLUTFileHandle,"%6f", &AngularDistribution[i]);
       if (ncols < 0) break;
     }
     if (ncols >= 0) {
        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;
  }
  fclose(readLUTFileHandle);
}

void G4OpticalSurface::SetFinish

(

const G4OpticalSurfaceFinish

finish

)

Definition at line 204 of file G4OpticalSurface.cc.

References dielectric_dichroic, dielectric_LUT, ReadDichroicFile(), ReadLUTFile(), and G4SurfaceProperty::theType.

Referenced by OpNoviceDetectorConstruction::Construct().

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

void G4OpticalSurface::SetMaterialPropertiesTable ( G4MaterialPropertiesTable *  anMPT )

inline

Definition at line 181 of file G4OpticalSurface.hh.

Referenced by OpNoviceDetectorConstruction::Construct(), and DMXDetectorConstruction::Construct().

                       { theMaterialPropertiesTable = anMPT; }

void G4OpticalSurface::SetModel ( const G4OpticalSurfaceModel  model )

inline

Definition at line 162 of file G4OpticalSurface.hh.

Referenced by OpNoviceDetectorConstruction::Construct().

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

References dielectric_dichroic, dielectric_LUT, ReadDichroicFile(), ReadLUTFile(), and G4SurfaceProperty::theType.

Referenced by OpNoviceDetectorConstruction::Construct().

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

---

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

• G4OpticalSurface.hh
• G4OpticalSurface.cc