G4LatticeReader Class Reference

#include <G4LatticeReader.hh>

Collaboration diagram for G4LatticeReader:

Public Member Functions
	G4LatticeReader (G4int vb=0)
	~G4LatticeReader ()
void	SetVerboseLevel (G4int vb)
G4LatticeLogical *	MakeLattice (const G4String &filepath)

Protected Member Functions
G4bool	OpenFile (const G4String &filepath)
G4bool	ProcessToken ()
G4bool	ProcessValue (const G4String &name)
G4bool	ProcessConstants ()
G4bool	ProcessMap ()
G4bool	ProcessNMap ()
G4bool	ReadMapInfo ()
G4bool	SkipComments ()
void	CloseFile ()

Private Attributes
G4int	verboseLevel
std::ifstream *	psLatfile
G4LatticeLogical *	pLattice
G4String	fMapPath
G4String	fToken
G4double	fValue
G4String	fMap
G4String	fsPol
G4int	fPol
G4int	fNX
G4int	fNY

Static Private Attributes
static const G4String	fDataDir

Detailed Description

Definition at line 43 of file G4LatticeReader.hh.

Constructor & Destructor Documentation

G4LatticeReader()

G4LatticeReader::G4LatticeReader

(

G4int

vb = 0

)

Definition at line 55 of file G4LatticeReader.cc.

  : verboseLevel(vb), psLatfile(0), pLattice(0), fMapPath(""),
    fToken(""), fValue(0.), fMap(""), fsPol(""), fPol(-1), fNX(0), fNY(0) {;}

~G4LatticeReader()

G4LatticeReader::~G4LatticeReader

(

)

Definition at line 59 of file G4LatticeReader.cc.

                                  {
  delete psLatfile; psLatfile = 0;
}

Member Function Documentation

CloseFile()

void G4LatticeReader::CloseFile ( )

protected

Definition at line 126 of file G4LatticeReader.cc.

                                {
  if (psLatfile) psLatfile->close();
  delete psLatfile;
  psLatfile = 0;
}

Here is the caller graph for this function:

MakeLattice()

G4LatticeLogical * G4LatticeReader::MakeLattice

(

const G4String &

filepath

)

Definition at line 66 of file G4LatticeReader.cc.

                                                                       {
  if (verboseLevel) G4cout << "G4LatticeReader " << filename << G4endl;

  if (!OpenFile(filename)) {
    G4ExceptionDescription msg;
    msg << "Unable to open " << filename;
    G4Exception("G4LatticeReader::MakeLattice", "Lattice001",
        FatalException, msg);
    return 0;
  }

  pLattice = new G4LatticeLogical;  // Create lattice to be filled

  G4bool goodLattice = true;
  while (!psLatfile->eof()) {
    goodLattice &= ProcessToken();
  }
  CloseFile();

  if (!goodLattice) {
    G4ExceptionDescription msg;
    msg << "Error reading lattice from " << filename;
    G4Exception("G4LatticeReader::MakeLattice", "Lattice002",
        FatalException, msg);
    delete pLattice;
    pLattice = 0;
  }

  return pLattice;  // Lattice complete; return pointer with ownership
}

Here is the call graph for this function:

Here is the caller graph for this function:

OpenFile()

G4bool G4LatticeReader::OpenFile ( const G4String &  filepath )

protected

Definition at line 100 of file G4LatticeReader.cc.

                                                         {
  if (verboseLevel)
    G4cout << "G4LatticeReader::OpenFile " << filename << G4endl;

  G4String filepath = filename;
  psLatfile = new std::ifstream(filepath);
  if (!psLatfile->good()) {         // Local file not found
    filepath = fDataDir + "/" + filename;
    psLatfile->open(filepath);          // Try data directory
    if (!psLatfile->good()) {
      CloseFile();
      return false;
    }
    if (verboseLevel>1) G4cout << " Found file " << filepath << G4endl;
  }

  // Extract path from filename to use in finding .ssv map files
  size_t lastdir = filepath.last('/');
  if (lastdir == std::string::npos) fMapPath = "."; // No path at all
  else fMapPath = filepath(0,lastdir);

  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ProcessConstants()

G4bool G4LatticeReader::ProcessConstants ( )

protected

Definition at line 185 of file G4LatticeReader.cc.

                                         {
  G4double beta=0., gamma=0., lambda=0., mu=0.;
  *psLatfile >> beta >> gamma >> lambda >> mu;
  if (verboseLevel>1)
    G4cout << " ProcessConstants " << beta << " " << gamma
       << " " << lambda << " " << mu << G4endl;

  pLattice->SetDynamicalConstants(beta, gamma, lambda, mu);
  return psLatfile->good();
}

Here is the call graph for this function:

Here is the caller graph for this function:

ProcessMap()

G4bool G4LatticeReader::ProcessMap ( )

protected

Definition at line 232 of file G4LatticeReader.cc.

                                   {
  if (!ReadMapInfo()) {     // Get specific parameters for map to load
    G4cerr << "G4LatticeReader: Unable to process mapfile directive." << G4endl;
    return false;
  }

  return pLattice->LoadMap(fNX, fNY, fPol, fMap);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ProcessNMap()

G4bool G4LatticeReader::ProcessNMap ( )

protected

Definition at line 241 of file G4LatticeReader.cc.

                                    {
  if (!ReadMapInfo()) {     // Get specific parameters for map to load
    G4cerr << "G4LatticeReader: Unable to process mapfile directive." << G4endl;
    return false;
  }

  return pLattice->Load_NMap(fNX, fNY, fPol, fMap);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ProcessToken()

G4bool G4LatticeReader::ProcessToken ( )

protected

Definition at line 135 of file G4LatticeReader.cc.

                                     {
  fToken = "";
  *psLatfile >> fToken;
  if (fToken.empty() || psLatfile->eof()) return true;  // End of file reached

  if (verboseLevel>1) G4cout << " ProcessToken " << fToken << G4endl;

  fToken.toLower();
  if (fToken.contains('#')) return SkipComments();  // Ignore rest of line
  if (fToken == "vdir")     return ProcessNMap();   // Direction vector map
  if (fToken == "vg")       return ProcessMap();    // Velocity magnitudes
  if (fToken == "dyn")      return ProcessConstants();  // Dynamical parameters
  return ProcessValue(fToken);              // Single numeric value
}

Here is the call graph for this function:

Here is the caller graph for this function:

ProcessValue()

G4bool G4LatticeReader::ProcessValue ( const G4String &  name )

protected

Definition at line 159 of file G4LatticeReader.cc.

                                                         {
  *psLatfile >> fValue;
  if (verboseLevel>1) G4cout << " ProcessValue " << fValue << G4endl;

  G4bool good = true;
  /***** NOTE: Individual Set functions not included in Release 10.0
       if (name == "beta")   pLattice->SetBeta(fValue);
  else if (name == "gamma")  pLattice->SetGamma(fValue);
  else if (name == "lambda") pLattice->SetLambda(fValue);
  else if (name == "mu")     pLattice->SetMu(fValue);
  else *****/
       if (name == "scat")   pLattice->SetScatteringConstant(fValue*s*s*s);
  else if (name == "b")      pLattice->SetScatteringConstant(fValue*s*s*s);
  else if (name == "decay")  pLattice->SetAnhDecConstant(fValue*s*s*s*s);
  else if (name == "a")      pLattice->SetAnhDecConstant(fValue*s*s*s*s);
  else if (name == "ldos")   pLattice->SetLDOS(fValue);
  else if (name == "stdos")  pLattice->SetSTDOS(fValue);
  else if (name == "ftdos")  pLattice->SetFTDOS(fValue);
  else {
    G4cerr << "G4LatticeReader: Unrecognized token " << name << G4endl;
    good = false;
  }

  return good;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ReadMapInfo()

G4bool G4LatticeReader::ReadMapInfo ( )

protected

Definition at line 198 of file G4LatticeReader.cc.

                                    {
  *psLatfile >> fMap >> fsPol >> fNX >> fNY;
  if (verboseLevel>1)
    G4cout << " ReadMapInfo " << fMap << " " << fsPol
       << " " << fNX << " " << fNY << G4endl;

  if (fNX < 0 || fNX >= G4LatticeLogical::MAXRES) {
    G4cerr << "G4LatticeReader: Invalid map theta dimension " << fNX << G4endl;
    return false;
  }

  if (fNY < 0 || fNY >= G4LatticeLogical::MAXRES) {
    G4cerr << "G4LatticeReader: Invalid map phi dimension " << fNY << G4endl;
    return false;
  }

  // Prepend path to data files to map filename
  fMap = fMapPath + "/" + fMap;

  // Convert string code (L,ST,LT) to polarization index
  fsPol.toLower();
  fPol = ( (fsPol=="l")  ? 0 :      // Longitudinal
       (fsPol=="st") ? 1 :      // Slow-transverse
       (fsPol=="ft") ? 2 :      // Fast-transverse
       -1 );            // Invalid code

  if (fPol<0 || fPol>2) {
    G4cerr << "G4LatticeReader: Invalid polarization code " << fsPol << G4endl;
    return false;
  }

  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

SetVerboseLevel()

void G4LatticeReader::SetVerboseLevel ( G4int  vb )

inline

Definition at line 48 of file G4LatticeReader.hh.

{ verboseLevel = vb; }

Here is the call graph for this function:

SkipComments()

G4bool G4LatticeReader::SkipComments ( )

protected

Definition at line 152 of file G4LatticeReader.cc.

                                     {
  psLatfile->ignore(std::numeric_limits<std::streamsize>::max(), '\n');
  return true;      // Never fails
}

Here is the caller graph for this function:

Member Data Documentation

fDataDir

const G4String G4LatticeReader::fDataDir

staticprivate

Initial value:

=
  getenv("G4LATTICEDATA") ? (const char*)getenv("G4LATTICEDATA") : "./CrystalMaps"

Definition at line 75 of file G4LatticeReader.hh.

fMap

G4String G4LatticeReader::fMap

private

Definition at line 72 of file G4LatticeReader.hh.

fMapPath

G4String G4LatticeReader::fMapPath

private

Definition at line 69 of file G4LatticeReader.hh.

fNX

G4int G4LatticeReader::fNX

private

Definition at line 73 of file G4LatticeReader.hh.

fNY

G4int G4LatticeReader::fNY

private

Definition at line 73 of file G4LatticeReader.hh.

fPol

G4int G4LatticeReader::fPol

private

Definition at line 73 of file G4LatticeReader.hh.

fsPol

G4String G4LatticeReader::fsPol

private

Definition at line 72 of file G4LatticeReader.hh.

fToken

G4String G4LatticeReader::fToken

private

Definition at line 70 of file G4LatticeReader.hh.

fValue

G4double G4LatticeReader::fValue

private

Definition at line 71 of file G4LatticeReader.hh.

pLattice

G4LatticeLogical* G4LatticeReader::pLattice

private

Definition at line 67 of file G4LatticeReader.hh.

psLatfile

std::ifstream* G4LatticeReader::psLatfile

private

Definition at line 66 of file G4LatticeReader.hh.

verboseLevel

G4int G4LatticeReader::verboseLevel

private

Definition at line 64 of file G4LatticeReader.hh.

---

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

• G4LatticeReader.hh
• G4LatticeReader.cc