G4LatticeReader Class Reference

#include <G4LatticeReader.hh>

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

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

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

Static Private Attributes
static const G4String	fDataDir

Detailed Description

Definition at line 42 of file G4LatticeReader.hh.

Constructor & Destructor Documentation

G4LatticeReader()

G4LatticeReader::G4LatticeReader

(

G4int

vb = 0

)

Definition at line 54 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 58 of file G4LatticeReader.cc.

                                  {
  delete psLatfile; psLatfile = 0;
}

References psLatfile.

Member Function Documentation

CloseFile()

void G4LatticeReader::CloseFile ( )

protected

Definition at line 125 of file G4LatticeReader.cc.

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

References psLatfile.

Referenced by MakeLattice(), and OpenFile().

MakeLattice()

G4LatticeLogical * G4LatticeReader::MakeLattice

(

const G4String &

filepath

)

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

References CloseFile(), FatalException, G4cout, G4endl, G4Exception(), OpenFile(), pLattice, ProcessToken(), psLatfile, and verboseLevel.

Referenced by G4LatticeManager::LoadLattice().

OpenFile()

G4bool G4LatticeReader::OpenFile ( const G4String &  filepath )

protected

Definition at line 99 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.rfind('/');
  if (lastdir == std::string::npos) fMapPath = "."; // No path at all
  else fMapPath = filepath.substr(0,lastdir);
 
  return true;
}

References CloseFile(), fDataDir, fMapPath, G4cout, G4endl, psLatfile, and verboseLevel.

Referenced by MakeLattice().

ProcessConstants()

G4bool G4LatticeReader::ProcessConstants ( )

protected

Definition at line 184 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();
}

References anonymous_namespace{G4PionRadiativeDecayChannel.cc}::beta, G4cout, G4endl, G4InuclParticleNames::lambda, pLattice, psLatfile, G4LatticeLogical::SetDynamicalConstants(), and verboseLevel.

Referenced by ProcessToken().

ProcessMap()

G4bool G4LatticeReader::ProcessMap ( )

protected

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

References fMap, fNX, fNY, fPol, G4cerr, G4endl, G4LatticeLogical::LoadMap(), pLattice, and ReadMapInfo().

Referenced by ProcessToken().

ProcessNMap()

G4bool G4LatticeReader::ProcessNMap ( )

protected

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

References fMap, fNX, fNY, fPol, G4cerr, G4endl, G4LatticeLogical::Load_NMap(), pLattice, and ReadMapInfo().

Referenced by ProcessToken().

ProcessToken()

G4bool G4LatticeReader::ProcessToken ( )

protected

Definition at line 134 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;
 
  G4StrUtil::to_lower(fToken);
  if (G4StrUtil::contains(fToken, '#')) 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
}

References G4StrUtil::contains(), fToken, G4cout, G4endl, ProcessConstants(), ProcessMap(), ProcessNMap(), ProcessValue(), psLatfile, SkipComments(), G4StrUtil::to_lower(), and verboseLevel.

Referenced by MakeLattice().

ProcessValue()

G4bool G4LatticeReader::ProcessValue ( const G4String &  name )

protected

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

References fValue, G4cerr, G4cout, G4endl, G4InuclParticleNames::name(), pLattice, psLatfile, s, G4LatticeLogical::SetAnhDecConstant(), G4LatticeLogical::SetFTDOS(), G4LatticeLogical::SetLDOS(), G4LatticeLogical::SetScatteringConstant(), G4LatticeLogical::SetSTDOS(), and verboseLevel.

Referenced by ProcessToken().

ReadMapInfo()

G4bool G4LatticeReader::ReadMapInfo ( )

protected

Definition at line 197 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
  G4StrUtil::to_lower(fsPol);
  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;
}

References fMap, fMapPath, fNX, fNY, fPol, fsPol, G4cerr, G4cout, G4endl, G4LatticeLogical::MAXRES, psLatfile, G4StrUtil::to_lower(), and verboseLevel.

Referenced by ProcessMap(), and ProcessNMap().

SetVerboseLevel()

void G4LatticeReader::SetVerboseLevel ( G4int  vb )

inline

Definition at line 47 of file G4LatticeReader.hh.

{ verboseLevel = vb; }

References verboseLevel.

SkipComments()

G4bool G4LatticeReader::SkipComments ( )

protected

Definition at line 151 of file G4LatticeReader.cc.

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

References G4INCL::Math::max(), and psLatfile.

Referenced by ProcessToken().

Field Documentation

fDataDir

const G4String G4LatticeReader::fDataDir

staticprivate

Initial value:

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

Definition at line 74 of file G4LatticeReader.hh.

Referenced by OpenFile().

fMap

G4String G4LatticeReader::fMap

private

Definition at line 71 of file G4LatticeReader.hh.

Referenced by ProcessMap(), ProcessNMap(), and ReadMapInfo().

fMapPath

G4String G4LatticeReader::fMapPath

private

Definition at line 68 of file G4LatticeReader.hh.

Referenced by OpenFile(), and ReadMapInfo().

fNX

G4int G4LatticeReader::fNX

private

Definition at line 72 of file G4LatticeReader.hh.

Referenced by ProcessMap(), ProcessNMap(), and ReadMapInfo().

fNY

G4int G4LatticeReader::fNY

private

Definition at line 72 of file G4LatticeReader.hh.

Referenced by ProcessMap(), ProcessNMap(), and ReadMapInfo().

fPol

G4int G4LatticeReader::fPol

private

Definition at line 72 of file G4LatticeReader.hh.

Referenced by ProcessMap(), ProcessNMap(), and ReadMapInfo().

fsPol

G4String G4LatticeReader::fsPol

private

Definition at line 71 of file G4LatticeReader.hh.

Referenced by ReadMapInfo().

fToken

G4String G4LatticeReader::fToken

private

Definition at line 69 of file G4LatticeReader.hh.

Referenced by ProcessToken().

fValue

G4double G4LatticeReader::fValue

private

Definition at line 70 of file G4LatticeReader.hh.

Referenced by ProcessValue().

pLattice

G4LatticeLogical* G4LatticeReader::pLattice

private

Definition at line 66 of file G4LatticeReader.hh.

Referenced by MakeLattice(), ProcessConstants(), ProcessMap(), ProcessNMap(), and ProcessValue().

psLatfile

std::ifstream* G4LatticeReader::psLatfile

private

Definition at line 65 of file G4LatticeReader.hh.

Referenced by CloseFile(), MakeLattice(), OpenFile(), ProcessConstants(), ProcessToken(), ProcessValue(), ReadMapInfo(), SkipComments(), and ~G4LatticeReader().

verboseLevel

G4int G4LatticeReader::verboseLevel

private

Definition at line 63 of file G4LatticeReader.hh.

Referenced by MakeLattice(), OpenFile(), ProcessConstants(), ProcessToken(), ProcessValue(), ReadMapInfo(), and SetVerboseLevel().

---

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

• source/processes/solidstate/phonon/include/G4LatticeReader.hh
• source/processes/solidstate/phonon/src/G4LatticeReader.cc