QUESO::AsciiTable< V, M > Class Template Reference

Class for reading ASCII values from a table in a file. More...

#include <AsciiTable.h>

Collaboration diagram for QUESO::AsciiTable< V, M >:

Public Member Functions
Constructor/Destructor methods
	AsciiTable (const BaseEnvironment &env, unsigned int numRows, unsigned int numExtraCols, const std::vector< bool > *extraColIsString, const std::string &fileName)
	Default constructor. More...
	~AsciiTable ()
	Destructor. More...
Property methods
unsigned int	numRows () const
	Returns the number of rows in the table. More...
unsigned int	numCols () const
	Returns the number of columns in the table. More...
const DistArray< std::string > &	stringColumn (unsigned int j) const
	Returns the string stored in column j. More...
const V &	doubleColumn (unsigned int j) const
	Returns the value (double) stored in column j. More...
I/O methods
void	print (std::ostream &os) const
	Prints the table. More...

Private Member Functions
Map *	newMap ()
void	readColumnsFromFile ()
template<>
Map *	newMap ()

Private Attributes
const BaseEnvironment &	m_env
unsigned int	m_numRows
unsigned int	m_numCols
std::vector< bool >	m_colIsString
std::string	m_fileName
const Map *	m_map
std::vector< DistArray < std::string > * >	m_stringColumns
std::vector< V * >	m_doubleColumns

Detailed Description

template<class V, class M>
class QUESO::AsciiTable< V, M >

Class for reading ASCII values from a table in a file.

Definition at line 42 of file AsciiTable.h.

Constructor & Destructor Documentation

template<class V , class M >

QUESO::AsciiTable< V, M >::AsciiTable	(	const BaseEnvironment &	env,
		unsigned int	numRows,
		unsigned int	numExtraCols,
		const std::vector< bool > *	extraColIsString,
		const std::string &	fileName
	)

Default constructor.

This constructor reads the data from file fileName, checking whether the data in each column of the file is or not a string, and whether the data in each row is or not valid.

Definition at line 31 of file AsciiTable.C.

References QUESO::BaseEnvironment::displayVerbosity(), QUESO::AsciiTable< V, M >::m_colIsString, QUESO::AsciiTable< V, M >::m_doubleColumns, QUESO::AsciiTable< V, M >::m_env, QUESO::AsciiTable< V, M >::m_numCols, QUESO::AsciiTable< V, M >::m_stringColumns, QUESO::AsciiTable< V, M >::readColumnsFromFile(), and QUESO::BaseEnvironment::subDisplayFile().

  :
  m_env          (env),
  m_numRows      (numRows),
  m_numCols      (1+numExtraCols),
  m_colIsString  (1,true),
  m_fileName     (fileName),
  m_map          (newMap()),
  m_stringColumns(0),
  m_doubleColumns(0)
{
  if ((m_env.subDisplayFile()) && (m_env.displayVerbosity() >= 5)) {
    *m_env.subDisplayFile() << "Entering AsciiTable<V,M>::constructor()..."
                            << std::endl;
  }

  if (m_numCols > 1) {
    m_colIsString.resize(m_numCols,false);
    if (extraColIsString == NULL) {
      // Nothing extra needs to be done
    }
    else {
      unsigned int maxJ = std::min(numExtraCols,(unsigned int) extraColIsString->size());
      for (unsigned int j = 0; j < maxJ; ++j) {
        m_colIsString[1+j] = (*extraColIsString)[j];
      }
    }
  }
  m_stringColumns.resize(m_numCols,NULL);
  m_doubleColumns.resize(m_numCols,NULL);
  readColumnsFromFile();

  if ((m_env.subDisplayFile()) && (m_env.displayVerbosity() >= 5)) {
    *m_env.subDisplayFile() << "Leaving AsciiTable<V,M>::constructor()"
                            << std::endl;
  }
}

template<class V , class M >

QUESO::AsciiTable< V, M >::~AsciiTable

(

)

Destructor.

Definition at line 76 of file AsciiTable.C.

{
  for (unsigned int j = 0; j < m_doubleColumns.size(); ++j) {
    if (m_doubleColumns[j]) delete m_doubleColumns[j];
  }
  for (unsigned int j = 0; j < m_stringColumns.size(); ++j) {
    if (m_stringColumns[j]) delete m_stringColumns[j];
  }
}

Member Function Documentation

template<class V , class M >

const V & QUESO::AsciiTable< V, M >::doubleColumn

(

unsigned int

j

)

const

Returns the value (double) stored in column j.

Definition at line 299 of file AsciiTable.C.

References UQ_FATAL_TEST_MACRO.

{
  UQ_FATAL_TEST_MACRO(j >= m_numCols,
                      m_env.worldRank(),
                      "AsciiTable<V,M>::doubleColumn()",
                      "invalid j");

  UQ_FATAL_TEST_MACRO(m_doubleColumns[j] == NULL,
                      m_env.worldRank(),
                      "AsciiTable<V,M>::doubleColumn()",
                      "double column is not ready");

  return *m_doubleColumns[j];
}

template<>

Map * QUESO::AsciiTable< class GslVector, class GslMatrix >::newMap ( )

private

Definition at line 31 of file GslAsciiTable.C.

{
  return new Map(m_numRows,0,m_env.selfComm());
}

template<class V , class M >

Map* QUESO::AsciiTable< V, M >::newMap ( )

private

template<class V , class M >

unsigned int QUESO::AsciiTable< V, M >::numCols

(

)

const

Returns the number of columns in the table.

Definition at line 275 of file AsciiTable.C.

{
  return m_numCols;
}

template<class V , class M >

unsigned int QUESO::AsciiTable< V, M >::numRows

(

)

const

Returns the number of rows in the table.

Definition at line 268 of file AsciiTable.C.

{
  return m_numRows;
}

template<class V , class M >

void QUESO::AsciiTable< V, M >::print

(

std::ostream &

os

)

const

Prints the table.

Definition at line 317 of file AsciiTable.C.

References UQ_FATAL_TEST_MACRO.

{
  for (unsigned int j = 0; j < m_numCols; ++j) {
    UQ_FATAL_TEST_MACRO((m_stringColumns[j] != NULL) && (m_doubleColumns[j] != NULL),
                        m_env.worldRank(),
                        "AsciiTable<V,M>::print()",
                        "column is not null on both possible ways");
    UQ_FATAL_TEST_MACRO((m_stringColumns[j] == NULL) && (m_doubleColumns[j] == NULL),
                        m_env.worldRank(),
                        "AsciiTable<V,M>::print()",
                        "column is null on both possible ways");

    os << "\nContents of table '" << m_fileName
       << "', column "            << j
       << ":"
       << std::endl;
    if (m_stringColumns[j] != NULL) {
      os << *m_stringColumns[j];
      //DistArray<std::string>& arrayOfStrings = *m_stringColumns[j];
      //for (unsigned int i = 0; i < m_numRows; ++i) {
      //  os << arrayOfStrings(i,0)
      //     << std::endl;
      //}
    }
    else {
      os << *m_doubleColumns[j];
    }
    os << std::endl;
  }

  return;
}

template<class V , class M >

void QUESO::AsciiTable< V, M >::readColumnsFromFile ( )

private

Definition at line 89 of file AsciiTable.C.

References QUESO::MiscReadCharsAndDoubleFromFile(), QUESO::MiscReadStringAndDoubleFromFile(), and UQ_FATAL_TEST_MACRO.

Referenced by QUESO::AsciiTable< V, M >::AsciiTable().

{
  unsigned int maxCharsPerLine = 512;

  std::ifstream ifs(m_fileName.c_str());
  UQ_FATAL_TEST_MACRO(ifs.is_open() == false,
                      m_env.worldRank(),
                      "AsciiTable<V,M>::readColumnsFromFile()",
                      "file was not found");

  // Determine number of lines
  unsigned int numLines = std::count(std::istreambuf_iterator<char>(ifs),
                                     std::istreambuf_iterator<char>(),
                                     '\n');

  // Determine number of valid lines
  int iRC;
  ifs.seekg(0,std::ios_base::beg);
  unsigned int lineId = 0;
  unsigned int numValidLines = 0;
  std::string tempString;
  while ((lineId < numLines) && (ifs.eof() == false)) {
    iRC = MiscReadStringAndDoubleFromFile(ifs,tempString,NULL);
    UQ_FATAL_TEST_MACRO(iRC,
                        m_env.worldRank(),
                        "AsciiTable<V,M>::readColumnsFromFile()",
                        "failed reading during the determination of the number of valid lines");
    //*m_env.subDisplayFile() << "lineId = "          << lineId
    //                        << ", numValidLines = " << numValidLines
    //                        << ", tempString = "    << tempString
    //                        << std::endl;
    if (tempString[0] != '#') numValidLines++;
    lineId++;
    ifs.ignore(maxCharsPerLine,'\n');
  }
  UQ_FATAL_TEST_MACRO(lineId != numLines,
                      m_env.worldRank(),
                      "AsciiTable<V,M>::readColumnsFromFile()",
                      "the first number of lines read is nonconsistent");
  if (m_numRows != numValidLines) {
    char errorExplanation[512];
    sprintf(errorExplanation,"number of valid lines (%u) in ASCII table file does not match number of rows (%u)",numValidLines,m_numRows);
    UQ_FATAL_TEST_MACRO(true,
                        m_env.worldRank(),
                        "AsciiTable<V,M>::readColumnsFromFile()",
                        errorExplanation);
  }

  if (m_env.subDisplayFile()) {
    *m_env.subDisplayFile() << "ASCII table file '"    << m_fileName
                            << "' has "                << numLines
                            << " lines and specifies " << numValidLines
                            << " valid lines."
                            << std::endl;
  }

  for (unsigned int j=0; j < m_numCols; ++j) {
    if (m_colIsString[j]) {
      if ((m_env.subDisplayFile()) && (m_env.displayVerbosity() >= 5)) {
        *m_env.subDisplayFile() << "Column j = " << j
                                << " is a columns of strings"
                                << std::endl;
      }
      m_stringColumns[j] = new DistArray<std::string>(*m_map,1);
    }
    else {
      if ((m_env.subDisplayFile()) && (m_env.displayVerbosity() >= 5)) {
        *m_env.subDisplayFile() << "Column j = " << j
                                << " is a columns of doubles"
                                << std::endl;
      }
      m_doubleColumns[j] = new V(m_env,*m_map);
    }
  }

  // Read file until End Of File character is reached
  ifs.seekg(0,std::ios_base::beg);
  lineId = 0;
  unsigned int validLineId = 0;
  std::string tmpString;
  while ((lineId < numLines) && (ifs.eof() == false)) {
    //*m_env.subDisplayFile() << "Beginning read of line (in ASCII table file) of id = " << lineId << std::endl;
    bool endOfLineAchieved = false;

    iRC = MiscReadCharsAndDoubleFromFile(ifs, tmpString, NULL, endOfLineAchieved);
    UQ_FATAL_TEST_MACRO(iRC,
                        m_env.worldRank(),
                        "AsciiTable<V,M>::readColumnsFromFile()",
                        "failed reading a first column during the valid lines reading loop");

    lineId++;
    if (tmpString[0] == '#') {
      if (!endOfLineAchieved) ifs.ignore(maxCharsPerLine,'\n');
      continue;
    }

    DistArray<std::string>& firstColumn = *m_stringColumns[0];
    firstColumn(validLineId,0) = tmpString;

    // Check 'validLineId' before setting one more valid line
    if (validLineId >= numValidLines) {
      char errorExplanation[512];
      sprintf(errorExplanation,"validLineId (%u) got too large during reading of ASCII table file",validLineId);
      UQ_FATAL_TEST_MACRO(true,
                          m_env.worldRank(),
                          "AsciiTable<V,M>::readColumnsFromFile()",
                          errorExplanation);
    }

    if ((m_env.subDisplayFile()) && (m_env.displayVerbosity() >= 5)) {
      *m_env.subDisplayFile() << "Just read a string: table[" << validLineId
                              << ","                          << 0 // j=0
                              << "] = "                       << firstColumn(validLineId,0)
                              << std::endl;
    }

    for (unsigned int j=1; j < m_numCols; ++j) {
      UQ_FATAL_TEST_MACRO(endOfLineAchieved,
                          m_env.worldRank(),
                          "AsciiTable<V,M>::readColumnsFromFile()",
                          "failed reading all columns in a valid line");
      if (m_colIsString[j]) {
        DistArray<std::string>& arrayOfStrings = *m_stringColumns[j];
        iRC = MiscReadCharsAndDoubleFromFile(ifs, arrayOfStrings(validLineId,0), NULL, endOfLineAchieved);
        UQ_FATAL_TEST_MACRO(iRC,
                            m_env.worldRank(),
                            "AsciiTable<V,M>::readColumnsFromFile()",
                            "failed reading a string column in a valid line");
        if ((m_env.subDisplayFile()) && (m_env.displayVerbosity() >= 5)) {
          *m_env.subDisplayFile() << "Just read a string: table[" << validLineId
                                  << ","                          << j
                                  << "] = "                       << arrayOfStrings(validLineId,0)
                                  << std::endl;
        }
      }
      else {
        iRC = MiscReadCharsAndDoubleFromFile(ifs, tmpString, &(*m_doubleColumns[j])[validLineId], endOfLineAchieved);
        UQ_FATAL_TEST_MACRO(iRC,
                            m_env.worldRank(),
                            "AsciiTable<V,M>::readColumnsFromFile()",
                            "failed reading a double column in a valid line");
        if ((m_env.subDisplayFile()) && (m_env.displayVerbosity() >= 5)) {
          *m_env.subDisplayFile() << "Just read a double: table[" << validLineId
                                  << ","                          << j
                                  << "] = "                       << (*m_doubleColumns[j])[validLineId]
                                  << std::endl;
        }
      }
    }
    if (!endOfLineAchieved) ifs.ignore(maxCharsPerLine,'\n');

    validLineId++;
  }

  UQ_FATAL_TEST_MACRO(lineId != numLines,
                      m_env.worldRank(),
                      "AsciiTable<V,M>::readColumnsFromFile()",
                      "the second number of lines read is not consistent");
  UQ_FATAL_TEST_MACRO(validLineId != numValidLines,
                      m_env.worldRank(),
                      "AsciiTable<V,M>::readColumnsFromFile()",
                      "the number of valid lines just read is not consistent");

  if (m_env.displayVerbosity() >= 5) {
    if (m_env.subDisplayFile()) {
      *m_env.subDisplayFile() << "Finished reading table '" << m_fileName
                              << "'. Its contents per column are:"
                              << std::endl;
      *m_env.subDisplayFile() << *this; // FIX ME: output might need to be in parallel
      *m_env.subDisplayFile() << std::endl;
    }    
  }

  return;
}

template<class V , class M >

const DistArray< std::string > & QUESO::AsciiTable< V, M >::stringColumn

(

unsigned int

j

)

const

Returns the string stored in column j.

Definition at line 282 of file AsciiTable.C.

References UQ_FATAL_TEST_MACRO.

{
  UQ_FATAL_TEST_MACRO(j >= m_numCols,
                      m_env.worldRank(),
                      "AsciiTable<V,M>::stringColumn()",
                      "invalid j");

  UQ_FATAL_TEST_MACRO(m_stringColumns[j] == NULL,
                      m_env.worldRank(),
                      "AsciiTable<V,M>::stringColumn()",
                      "string column is not ready");

  return *m_stringColumns[j];
}

Member Data Documentation

template<class V , class M >

std::vector<bool> QUESO::AsciiTable< V, M >::m_colIsString

private

Definition at line 85 of file AsciiTable.h.

Referenced by QUESO::AsciiTable< V, M >::AsciiTable().

template<class V , class M >

std::vector<V*> QUESO::AsciiTable< V, M >::m_doubleColumns

private

Definition at line 90 of file AsciiTable.h.

Referenced by QUESO::AsciiTable< V, M >::AsciiTable().

template<class V , class M >

const BaseEnvironment& QUESO::AsciiTable< V, M >::m_env

private

Definition at line 82 of file AsciiTable.h.

Referenced by QUESO::AsciiTable< V, M >::AsciiTable().

template<class V , class M >

std::string QUESO::AsciiTable< V, M >::m_fileName

private

Definition at line 86 of file AsciiTable.h.

template<class V , class M >

const Map* QUESO::AsciiTable< V, M >::m_map

private

Definition at line 88 of file AsciiTable.h.

template<class V , class M >

unsigned int QUESO::AsciiTable< V, M >::m_numCols

private

Definition at line 84 of file AsciiTable.h.

Referenced by QUESO::AsciiTable< V, M >::AsciiTable().

template<class V , class M >

unsigned int QUESO::AsciiTable< V, M >::m_numRows

private

Definition at line 83 of file AsciiTable.h.

template<class V , class M >

std::vector<DistArray<std::string>*> QUESO::AsciiTable< V, M >::m_stringColumns

private

Definition at line 89 of file AsciiTable.h.

Referenced by QUESO::AsciiTable< V, M >::AsciiTable().

---

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

• src/misc/inc/AsciiTable.h
• src/misc/src/AsciiTable.C