G4OrderedTable Class Reference

#include <G4OrderedTable.hh>

Inheritance diagram for G4OrderedTable:

Public Member Functions
	G4OrderedTable ()=default
	G4OrderedTable (std::size_t cap)
virtual	~G4OrderedTable ()=default
void	clearAndDestroy ()
G4bool	Store (const G4String &filename, G4bool ascii=false)
G4bool	Retrieve (const G4String &filename, G4bool ascii=false)

Friends
std::ostream &	operator<< (std::ostream &out, G4OrderedTable &table)

Detailed Description

Definition at line 43 of file G4OrderedTable.hh.

Constructor & Destructor Documentation

G4OrderedTable() [1/2]

G4OrderedTable::G4OrderedTable ( )

default

G4OrderedTable() [2/2]

G4OrderedTable::G4OrderedTable ( std::size_t  cap )

explicit

Definition at line 40 of file G4OrderedTable.cc.

  : std::vector<G4DataVector*>(cap, (G4DataVector*) nullptr)
{}

~G4OrderedTable()

virtual G4OrderedTable::~G4OrderedTable ( )

virtualdefault

Member Function Documentation

clearAndDestroy()

void G4OrderedTable::clearAndDestroy

(

)

Definition at line 45 of file G4OrderedTable.cc.

{
  G4DataVector* a = nullptr;
  while(!empty())
  {
    a = back();
    pop_back();
    for(auto i = cbegin(); i != cend(); ++i)
    {
      if(*i == a)
      {
        erase(i);
        --i;
      }
    }
 
    delete a;
  }
}

Referenced by Retrieve(), and G4SandiaTable::~G4SandiaTable().

Retrieve()

G4bool G4OrderedTable::Retrieve	(	const G4String &	filename,
		G4bool	ascii = false
	)

Definition at line 119 of file G4OrderedTable.cc.

{
  std::ifstream fIn;
  // open input file //
  if(!ascii)
  {
    fIn.open(fileName, std::ios::in | std::ios::binary);
  }
  else
  {
    fIn.open(fileName, std::ios::in);
  }
 
  // check if the file has been opened successfully
  if(!fIn)
  {
#ifdef G4VERBOSE
    G4cerr << "G4OrderedTable::Retrieve():";
    G4cerr << " Cannot open file: " << fileName << G4endl;
#endif
    fIn.close();
    return false;
  }
 
  // clear
  clearAndDestroy();
 
  // Number of elements
  G4int tableSize = 0;
  if(!ascii)
  {
    fIn.read((char*) (&tableSize), sizeof tableSize);
  }
  else
  {
    fIn >> tableSize;
  }
  if(tableSize <= 0)
  {
#ifdef G4VERBOSE
    G4cerr << "G4OrderedTable::Retrieve():";
    G4cerr << " Invalid table size: " << tableSize << G4endl;
#endif
    return false;
  }
  reserve(tableSize);
 
  // Physics Vector
  for(G4int idx = 0; idx < tableSize; ++idx)
  {
    G4int vType = 0;
    if(!ascii)
    {
      fIn.read((char*) (&vType), sizeof vType);
    }
    else
    {
      fIn >> vType;
    }
    if(vType != G4DataVector::T_G4DataVector)
    {
#ifdef G4VERBOSE
      G4cerr << "G4OrderedTable::Retrieve():";
      G4cerr << " Illegal Data Vector type: " << vType << " in  ";
      G4cerr << fileName << G4endl;
#endif
      fIn.close();
      return false;
    }
 
    auto* pVec = new G4DataVector;
 
    if(!(pVec->Retrieve(fIn, ascii)))
    {
#ifdef G4VERBOSE
      G4cerr << "G4OrderedTable::Retrieve(): ";
      G4cerr << " Error in retreiving " << idx
             << "-th Physics Vector from file: ";
      G4cerr << fileName << G4endl;
#endif
      fIn.close();
      delete pVec;
      return false;
    }
 
    // add a PhysicsVector to this OrderedTable
    push_back(pVec);
  }
  fIn.close();
  return true;
}

Store()

G4bool G4OrderedTable::Store	(	const G4String &	filename,
		G4bool	ascii = false
	)

Definition at line 66 of file G4OrderedTable.cc.

{
  std::ofstream fOut;
 
  // open output file //
  if(!ascii)
  {
    fOut.open(fileName, std::ios::out | std::ios::binary);
  }
  else
  {
    fOut.open(fileName, std::ios::out);
  }
 
  // check if the file has been opened successfully
  if(!fOut)
  {
#ifdef G4VERBOSE
    G4cerr << "G4OrderedTable::::Store():";
    G4cerr << " Cannot open file: " << fileName << G4endl;
#endif
    fOut.close();
    return false;
  }
 
  G4int tableSize = G4int(size());  // Number of elements
  if(!ascii)
  {
    fOut.write((char*) (&tableSize), sizeof tableSize);
  }
  else
  {
    fOut << tableSize << G4endl;
  }
 
  G4int vType = G4DataVector::T_G4DataVector;  // Data Vector
  for(const auto itr : *this)
  {
    if(!ascii)
    {
      fOut.write((char*) (&vType), sizeof vType);
    }
    else
    {
      fOut << vType << G4endl;
    }
    itr->Store(fOut, ascii);
  }
  fOut.close();
  return true;
}

Friends And Related Function Documentation

operator<<

std::ostream & operator<< ( std::ostream &  out, G4OrderedTable &  table  )

friend

Definition at line 212 of file G4OrderedTable.cc.

{
  // Printout Data Vector
  std::size_t i = 0;
  for(const auto itr : right)
  {
    out << std::setw(8) << i << "-th Vector   ";
    out << ": Type    " << G4DataVector::T_G4DataVector << G4endl;
    out << *itr;
    i += 1;
  }
  out << G4endl;
  return out;
}

---

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

• G4OrderedTable.hh
• G4OrderedTable.cc