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 43 of file G4LatticeReader.hh.

Constructor & Destructor Documentation

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

(

)

Definition at line 59 of file G4LatticeReader.cc.

                                  {
  delete psLatfile; psLatfile = 0;
}

Member Function Documentation

void G4LatticeReader::CloseFile ( )

protected

Definition at line 126 of file G4LatticeReader.cc.

Referenced by MakeLattice(), and OpenFile().

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

G4LatticeLogical * G4LatticeReader::MakeLattice

(

const G4String &

filepath

)

Definition at line 66 of file G4LatticeReader.cc.

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

Referenced by G4LatticeManager::LoadLattice().

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

G4bool G4LatticeReader::OpenFile ( const G4String &  filepath )

protected

Definition at line 100 of file G4LatticeReader.cc.

References CloseFile(), G4cout, G4endl, and G4String::last().

Referenced by MakeLattice().

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

G4bool G4LatticeReader::ProcessConstants ( )

protected

Definition at line 185 of file G4LatticeReader.cc.

References G4cout, G4endl, G4InuclParticleNames::lambda, and G4LatticeLogical::SetDynamicalConstants().

Referenced by ProcessToken().

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

G4bool G4LatticeReader::ProcessMap ( )

protected

Definition at line 232 of file G4LatticeReader.cc.

References G4cerr, G4endl, G4LatticeLogical::LoadMap(), and ReadMapInfo().

Referenced by ProcessToken().

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

G4bool G4LatticeReader::ProcessNMap ( )

protected

Definition at line 241 of file G4LatticeReader.cc.

References G4cerr, G4endl, G4LatticeLogical::Load_NMap(), and ReadMapInfo().

Referenced by ProcessToken().

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

G4bool G4LatticeReader::ProcessToken ( )

protected

Definition at line 135 of file G4LatticeReader.cc.

References G4cout, G4endl, ProcessConstants(), ProcessMap(), ProcessNMap(), ProcessValue(), and SkipComments().

Referenced by MakeLattice().

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

G4bool G4LatticeReader::ProcessValue ( const G4String &  name )

protected

Definition at line 159 of file G4LatticeReader.cc.

References G4cerr, G4cout, G4endl, G4LatticeLogical::SetAnhDecConstant(), G4LatticeLogical::SetFTDOS(), G4LatticeLogical::SetLDOS(), G4LatticeLogical::SetScatteringConstant(), and G4LatticeLogical::SetSTDOS().

Referenced by ProcessToken().

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

G4bool G4LatticeReader::ReadMapInfo ( )

protected

Definition at line 198 of file G4LatticeReader.cc.

References G4cerr, G4cout, G4endl, G4LatticeLogical::MAXRES, and G4String::toLower().

Referenced by ProcessMap(), and ProcessNMap().

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

void G4LatticeReader::SetVerboseLevel ( G4int  vb )

inline

Definition at line 48 of file G4LatticeReader.hh.

{ verboseLevel = vb; }

G4bool G4LatticeReader::SkipComments ( )

protected

Definition at line 152 of file G4LatticeReader.cc.

References G4INCL::Math::max().

Referenced by ProcessToken().

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

---

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

• G4LatticeReader.hh
• G4LatticeReader.cc