Initialize at openlb-1-3

1 files changed, 329 insertions, 0 deletions

diff --git a/src/io/xmlReader.cpp b/src/io/xmlReader.cpp
new file mode 100644
index 0000000..302a93c
--- /dev/null
+++ b/src/io/xmlReader.cpp
@@ -0,0 +1,329 @@
+/*  This file is part of the OpenLB library
+ *
+ *  Copyright (C) 2010 Jonas Latt, Jonas Fietz, Mathias Krause
+ *  E-mail contact: info@openlb.net
+ *  The most recent release of OpenLB can be downloaded at
+ *  <http://www.openlb.net/>
+ *
+ *  This program is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU General Public License
+ *  as published by the Free Software Foundation; either version 2
+ *  of the License, or (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public
+ *  License along with this program; if not, write to the Free
+ *  Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ *  Boston, MA  02110-1301, USA.
+*/
+
+/** \file
+ * Input/Output in XML format -- non-generic code.
+ */
+
+#include "io/xmlReader.h"
+#include <algorithm>
+#include <cctype>
+#include <iostream>
+#include "communication/mpiManager.h"
+
+
+namespace olb {
+
+XMLreader XMLreader::_notFound;
+
+XMLreader::XMLreader()
+  : clout(std::cout,"XMLreader")
+{
+  _name = "XML node not found";
+  _warningsOn = true;
+}
+
+XMLreader::XMLreader( TiXmlNode* pParent)
+  : clout(std::cout,"XMLreader")
+{
+  _warningsOn = true;
+  if (singleton::mpi().isMainProcessor()) {
+    mainProcessorIni(pParent);
+  } else {
+    slaveProcessorIni();
+  }
+}
+
+XMLreader::XMLreader(const std::string& fName)
+  : clout("XMLreader")
+{
+  _warningsOn = true;
+  TiXmlDocument* doc = nullptr;
+  int loadOK = false;
+#ifdef PARALLEL_MODE_MPI  // parallel program execution
+  if (singleton::mpi().isMainProcessor()) {
+#endif
+    doc = new TiXmlDocument(fName.c_str());
+    loadOK = doc->LoadFile();
+    if (!loadOK) {
+      clout << std::string("Problem processing input XML file ") << fName << std::endl;
+    }
+#ifdef PARALLEL_MODE_MPI  // parallel program execution
+  }
+  if (singleton::mpi().isMainProcessor()) {
+#endif
+    mainProcessorIni(doc);
+    delete doc;
+#ifdef PARALLEL_MODE_MPI  // parallel program execution
+  } else {
+    slaveProcessorIni();
+  }
+#endif
+}
+
+XMLreader::~XMLreader()
+{
+  for (unsigned int iNode=0; iNode<_children.size(); ++iNode) {
+    delete _children[iNode];
+  }
+}
+
+void XMLreader::mainProcessorIni( TiXmlNode* pParent )
+{
+  assert (pParent->Type()==TiXmlNode::TINYXML_DOCUMENT || pParent->Type()==TiXmlNode::TINYXML_ELEMENT );
+  if (pParent->Type() == TiXmlNode::TINYXML_DOCUMENT) {
+    // ignore the surrounding PARAM-block
+    pParent = pParent->FirstChildElement();
+  }
+
+  _name = pParent->ValueStr();
+#ifdef PARALLEL_MODE_MPI  // parallel program execution
+  singleton::mpi().bCast(&_name,1);
+#endif
+
+  TiXmlAttribute* attr = pParent->ToElement()->FirstAttribute();
+  while (attr != nullptr) {
+#ifdef PARALLEL_MODE_MPI  // parallel program execution
+    int size = 0;
+    std::string* key = const_cast<std::string*>(&attr->NameTStr());
+    singleton::mpi().bCast(key, size);
+    std::string* value = const_cast<std::string*>(&attr->ValueStr());
+    singleton::mpi().bCast(value, size);
+#endif
+    _attributes[attr->NameTStr()] = attr->ValueStr();
+    attr = attr->Next();
+  }
+#ifdef PARALLEL_MODE_MPI  // parallel program execution
+  std::string tmpstr = "";
+  int size = 0;
+  singleton::mpi().bCast(&tmpstr, size);
+  singleton::mpi().bCast(&tmpstr, size);
+#endif
+
+
+  TiXmlNode * pChild;
+  int type = 0;
+  for ( pChild = pParent->FirstChild(); pChild != nullptr; pChild = pChild->NextSibling()) {
+    type = pChild->Type();
+#ifdef PARALLEL_MODE_MPI  // parallel program execution
+    singleton::mpi().bCast(&type, 1);
+#endif
+    if ( type==TiXmlNode::TINYXML_ELEMENT ) {
+      _children.push_back( new XMLreader( pChild ) );
+    } else if ( type==TiXmlNode::TINYXML_TEXT ) {
+      _text = pChild->ToText()->ValueStr();
+#ifdef PARALLEL_MODE_MPI  // parallel program execution
+      singleton::mpi().bCast(&_text,1);
+#endif
+    }
+  }
+  type = TiXmlNode::TINYXML_UNKNOWN;
+#ifdef PARALLEL_MODE_MPI  // parallel program execution
+  singleton::mpi().bCast(&type, 1);
+#endif
+}
+
+void XMLreader::slaveProcessorIni()
+{
+#ifdef PARALLEL_MODE_MPI  // parallel program execution
+
+  singleton::mpi().bCast(&_name,1);
+  std::string key = "";
+  std::string value = "";
+  int size = int();
+  do {
+    singleton::mpi().bCast(&key, size);
+    singleton::mpi().bCast(&value, size);
+    _attributes[key] = value;
+  } while (key != "");
+#endif
+
+  int type=0;
+  do {
+#ifdef PARALLEL_MODE_MPI  // parallel program execution
+    singleton::mpi().bCast(&type, 1);
+#endif
+    if ( type==TiXmlNode::TINYXML_ELEMENT ) {
+      _children.push_back( new XMLreader( nullptr ) );
+    } else if ( type==TiXmlNode::TINYXML_TEXT ) {
+#ifdef PARALLEL_MODE_MPI  // parallel program execution
+      singleton::mpi().bCast(&_text,1);
+#endif
+    }
+  } while (type != TiXmlNode::TINYXML_UNKNOWN);
+}
+
+void XMLreader::print(int indent) const
+{
+  std::string indentStr(indent, ' ');
+  clout << indentStr << "[" << _name << "]" << std::endl;
+  if (!_text.empty()) {
+    clout << indentStr << "  " << _text << std::endl;
+  }
+  for (unsigned int iNode=0; iNode<_children.size(); ++iNode) {
+    _children[iNode]->print(indent+2);
+  }
+}
+
+XMLreader const& XMLreader::operator[] (std::string fName) const
+{
+  for (unsigned int iNode=0; iNode<_children.size(); ++iNode) {
+    if (_children[iNode]->_name == fName) {
+      return *_children[iNode];
+    }
+  }
+  if ( _warningsOn ) {
+    clout << "Warning: cannot read value from node \"" << _name << "\"" << ", \"" << fName <<"\"" << std::endl;
+  }
+  return _notFound;
+}
+
+std::vector<XMLreader*>::const_iterator XMLreader::begin() const
+{
+  return _children.begin();
+}
+
+std::vector<XMLreader*>::const_iterator XMLreader::end() const
+{
+  return _children.end();
+}
+
+std::string XMLreader::getName() const
+{
+  return _name;
+}
+
+void XMLreader::setWarningsOn(bool warnings) const
+{
+  _warningsOn = warnings;
+  for (unsigned int iNode=0; iNode<_children.size(); ++iNode) {
+    _children[iNode]->setWarningsOn(warnings);
+  }
+}
+
+// template specialization for T=bool
+template <>
+bool XMLreader::read<bool>(bool& value, bool verboseOn, bool exitIfMissing) const
+{
+  std::stringstream valueStr(_text);
+  std::string word;
+  valueStr >> word;
+  // Transform to lower-case, so that "true" and "false" are case-insensitive.
+  std::transform(word.begin(), word.end(), word.begin(), ::tolower);
+  if (!word.compare("true") || (word=="1")) {
+    value = true;
+    return true;
+  } else if (!word.compare("false") || (word=="0")) {
+    value=false;
+    return true;
+  } else {
+    if ( verboseOn ) {
+      std::stringstream ss;
+      ss << ( value ? "true" : "false" );
+      printWarning("bool", ss.str(),  verboseOn, exitIfMissing);
+    }
+  }
+  return false;
+}
+
+// template specialization for T=int
+template <>
+bool XMLreader::read<int>(int& value, bool verboseOn, bool exitIfMissing) const
+{
+  std::stringstream valueStr(_text);
+  int tmp = int();
+  if (!(valueStr >> tmp)) {
+    std::stringstream ss;
+    ss << value;
+    printWarning("int", ss.str(), verboseOn, exitIfMissing);
+    return false;
+  }
+  value = tmp;
+  return true;
+}
+
+// template specialization for T=double
+template <>
+bool XMLreader::read<double>(double& value, bool verboseOn, bool exitIfMissing) const
+{
+  std::stringstream valueStr(_text);
+  double tmp = double();
+  if (!(valueStr >> tmp)) {
+    std::stringstream ss;
+    ss << value;
+    printWarning("double", ss.str(), verboseOn, exitIfMissing);
+    return false;
+  }
+  value = tmp;
+  return true;
+}
+
+template <>
+bool XMLreader::read<std::string>(std::string& entry, bool verboseOn, bool exitIfMissing) const
+{
+  if (_name == "XML node not found") {
+    return false;
+  }
+  std::stringstream valueStr(_text);
+  std::string tmp = std::string();
+   if (!(valueStr >> tmp)) {
+      std::stringstream ss;
+      ss << entry;
+      printWarning("string", ss.str(), verboseOn, exitIfMissing);
+      return false;
+    }
+
+  entry = _text;
+  return true;
+}
+
+std::string XMLreader::getAttribute(const std::string& aName) const
+{
+  std::map<std::string, std::string>::const_iterator it = _attributes.find(aName);
+  if ( it == _attributes.end()) {
+    return "Attribute not found.";
+  }
+  return it->second;
+  //return attributes[aName];
+}
+
+
+/// print warning if verbose mode is on and exit, if exItMissing is true
+void XMLreader::printWarning(std::string typeName, std::string value, bool verboseOn, bool exitIfMissing) const
+{
+
+  if ( verboseOn ) {
+    clout << "Warning: Cannot read " << typeName << " value from XML element " << _name << "." << std::endl;
+    if ( ! value.empty() ) {
+      clout << "         Setting default value = " << value << std::endl;
+    }
+  }
+  if ( exitIfMissing ) {
+    clout << "Error: This program cannot continue without \"" << _name << "\". Optimization aborted." << std::endl;
+    exit(1);
+  }
+}
+
+
+
+}  // namespace olb