G4LatticeReader Class Reference

#include <G4LatticeReader.hh>

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 ()

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

Member Function Documentation

CloseFile()

void G4LatticeReader::CloseFile ( )

protected

Definition at line 125 of file G4LatticeReader.cc.

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

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
}

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

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

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

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

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

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

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

Referenced by ProcessMap(), and ProcessNMap().

SetVerboseLevel()

void G4LatticeReader::SetVerboseLevel ( G4int  vb )

inline

Definition at line 47 of file G4LatticeReader.hh.

{ verboseLevel = vb; }

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
}

Referenced by ProcessToken().

---

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

• G4LatticeReader.hh
• G4LatticeReader.cc