parameterManager_XML.cpp

Go to the documentation of this file.

#include "parameterManager_XML.h"

#include "communicator.h"
#include "evalexpr.h"

#include <fstream>
#include <sstream>
#include <map>

#include "tinyxml2.h"
using namespace tinyxml2;

using std::string;
using Bridge::vout;

const std::string ParameterManager_XML::class_name = "ParameterManager_XML";

namespace {
  template<typename T>
  std::string to_str(const std::vector<T>& v)
  {
    std::ostringstream ss;

    ss << "[ ";
    for (size_t i = 0, n = v.size(); i < n; ++i) {
      if (i != 0) ss << ", ";
      ss << v[i];
    }
    ss << " ]";

    return ss.str();
  }
}

//====================================================================
void ParameterManager_XML::read_params(const std::string& params_file, Parameters *params)
{
  const int io_node = 0;  // node id for file i/o.

  int  filesize = 0;
  char *buf     = 0;

  if (Communicator::nodeid() == io_node) {
    // load and distribute
    std::ifstream fin(params_file.c_str());
    if (!fin) {
      vout.crucial(m_vl, "%s: unable to read parameter file: %s.\n", class_name.c_str(), params_file.c_str());

      Communicator::abort();
    }

    fin.seekg(0, std::ios::end);
    filesize = fin.tellg();
    fin.seekg(0, std::ios::beg);

    int padding = 8 - (filesize % 8);

    vout.paranoiac(m_vl, "%s::%s: filesize = %d, padding = %d\n", class_name.c_str(), __func__, filesize, padding);

    filesize += padding;

    Communicator::broadcast(1, &filesize, io_node);

    buf = new char [filesize];
    memset(buf, 0, filesize);

    fin.read(buf, filesize - padding);

    Communicator::Base::broadcast(filesize, buf, io_node);
  } else {
    // receive from io_node

    Communicator::broadcast(1, &filesize, io_node);

    buf = new char [filesize];
    memset(buf, 0, filesize);

    Communicator::Base::broadcast(filesize, buf, io_node);
  }

  process_params(buf, params);

  delete [] buf;
}


//====================================================================
void ParameterManager_XML::process_params(const char *buf, Parameters *params_top)
{
  XMLDocument doc;

  XMLError err = doc.Parse(buf);

  if (err != XML_NO_ERROR) {
    vout.crucial(m_vl, "%s: parse failed: %s\n", class_name.c_str(), doc.ErrorName());

    const char *err_str1 = doc.GetErrorStr1();
    if (err_str1) {
      vout.crucial(m_vl, "  %s\n", err_str1);
    }
    const char *err_str2 = doc.GetErrorStr2();
    if (err_str2) {
      vout.crucial(m_vl, "  %s\n", err_str2);
    }

    exit(EXIT_FAILURE);
  }

  XMLElement *root = doc.FirstChildElement("Parameters");
  if (!root) {
    vout.crucial(m_vl, "%s: tag \"Parameters\" not found.\n", class_name.c_str());
    exit(EXIT_FAILURE);
  }

  traverse(root, params_top);
}


//====================================================================
void ParameterManager_XML::traverse(const XMLElement *elem, Parameters *params)
{
  if (!elem || !params) return;

  for (const XMLElement *e = elem->FirstChildElement(); e != NULL; e = e->NextSiblingElement()) {
    traverse_item(e, params);
  }
}


//====================================================================
void ParameterManager_XML::traverse_item(const XMLElement *elem, Parameters *params)
{
  if (!elem || !params) return;

  std::string tag(elem->Name());

  vout.paranoiac(m_vl, "%s::%s: tag = \"%s\"\n", class_name.c_str(), __func__, tag.c_str());

  if (params->find_Parameters(tag)) {
    vout.paranoiac(m_vl, "%s::%s: matched entry for parameters.\n", class_name.c_str(), __func__);

    return traverse(elem, params->get_Parameters(tag));
  }

  if (params->find_int(tag)) {
    int val = atoi(elem->GetText());

    vout.paranoiac(m_vl, "%s::%s: matched entry for int. val = %d\n", class_name.c_str(), __func__, val);

    return params->set_int(tag, val);
  }

  if (params->find_double(tag)) {
    double val = EvalExpr(elem->GetText()).parse();

    vout.paranoiac(m_vl, "%s::%s: matched entry for double. expr = %s, val = %20.16e\n", class_name.c_str(), __func__, elem->GetText(), val);

    return params->set_double(tag, val);
  }

  if (params->find_string(tag)) {
    vout.paranoiac(m_vl, "%s::%s: matched entry for string. val = %s\n", class_name.c_str(), __func__, elem->GetText());

    return params->set_string(tag, elem->GetText());
  }

  if (params->find_int_vector(tag)) {
    std::vector<int> val = convert_to_int_vector(elem);

    vout.paranoiac(m_vl, "%s::%s: matched entry for int vector. val = %s\n", class_name.c_str(), __func__, to_str(val).c_str());

    return params->set_int_vector(tag, val);
  }

  if (params->find_double_vector(tag)) {
    std::vector<double> val = convert_to_double_vector(elem);

    vout.paranoiac(m_vl, "%s::%s: matched entry for double vector. val = %s\n", class_name.c_str(), __func__, to_str(val).c_str());

    return params->set_double_vector(tag, val);
  }

  if (tag == "verbose_level") {
    Bridge::VerboseLevel vl = Bridge::BridgeIO::set_verbose_level(elem->GetText());

    vout.paranoiac(m_vl, "%s::%s: matched entry for verbose_level. val = %d\n", class_name.c_str(), __func__, vl);

    return params->set_VerboseLevel(vl);
  }

  // unknown entry. skip
  vout.paranoiac(m_vl, "%s::%s: no match. skipped.\n", class_name.c_str(), __func__);
}


//====================================================================
std::vector<int> ParameterManager_XML::convert_to_int_vector(const XMLElement *elem)
{
  if (!elem) return std::vector<int>();

  const XMLElement *ee = elem->FirstChildElement();
  if (!ee) return std::vector<int>();

  std::map<int, int> array;
  int                max_index = 0;

  if (strcmp(ee->Name(), "value") == 0) {
    vout.paranoiac(m_vl, "%s::%s: plain array.\n", class_name.c_str(), __func__);

    int count = 0;

    for (const XMLElement *e = elem->FirstChildElement(); e != NULL; e = e->NextSiblingElement()) {
      int id = 0;
      if (e->QueryIntAttribute("id", &id) == XML_SUCCESS) {
        --id;  /* id starts from 1 */
      } else {
        vout.general(m_vl, "%s::%s: array index not found.\n", class_name.c_str(), __func__);
        id = count;
      }

      if (id < 0) {
        vout.crucial(m_vl, "%s::%s: inappropriate array index %d.\n", class_name.c_str(), __func__, id);
        exit(EXIT_FAILURE);
      }

      if (id > max_index) {
        max_index = id;
      }

      int val = atoi(e->GetText());

      vout.paranoiac(m_vl, "%s::%s: id = %d, value = %d\n", class_name.c_str(), __func__, id, val);

      array[id] = val;
      ++count;
    }
  } else {
    vout.paranoiac(m_vl, "%s::%s: directional array.\n", class_name.c_str(), __func__);

    for (const XMLElement *e = elem->FirstChildElement(); e != NULL; e = e->NextSiblingElement()) {
      int id = 0;

      std::string tag = std::string(e->Name());

      if (tag == "x") {
        id = 0;
      } else if (tag == "y") {
        id = 1;
      } else if (tag == "z") {
        id = 2;
      } else if (tag == "t") {
        id = 3;
      } else {
        vout.crucial("%s::%s: unknown array index \"%s\".\n", class_name.c_str(), __func__, tag.c_str());
        exit(EXIT_FAILURE);
      }

      if (id > max_index) {
        max_index = id;
      }

      int val = atoi(e->GetText());

      vout.paranoiac(m_vl, "%s::%s: id = %s (%d), value = %d\n", class_name.c_str(), __func__, tag.c_str(), id, val);

      array[id] = val;
    }
  }

  vout.paranoiac(m_vl, "%s::%s: max_index = %d\n", class_name.c_str(), __func__, max_index);

  std::vector<int> v(max_index + 1);

  for (std::map<int, int>::const_iterator p = array.begin(); p != array.end(); ++p) {
    v[p->first] = p->second;
  }

  return v;
}


//====================================================================
std::vector<double> ParameterManager_XML::convert_to_double_vector(const XMLElement *elem)
{
  if (!elem) return std::vector<double>();

  const XMLElement *ee = elem->FirstChildElement();
  if (!ee) return std::vector<double>();

  std::map<int, double> array;
  int max_index = 0;

  if (strcmp(ee->Name(), "value") == 0) {
    vout.paranoiac(m_vl, "%s::%s: plain array.\n", class_name.c_str(), __func__);

    int count = 0;

    for (const XMLElement *e = elem->FirstChildElement(); e != NULL; e = e->NextSiblingElement()) {
      int id = 0;
      if (e->QueryIntAttribute("id", &id) == XML_SUCCESS) {
        --id;  /* id starts from 1 */
      } else {
        vout.general(m_vl, "%s::%s: array index not found.\n", class_name.c_str(), __func__);
        id = count;
      }

      if (id < 0) {
        vout.crucial(m_vl, "%s::%s: inappropriate array index %d.\n", class_name.c_str(), __func__, id);
        exit(EXIT_FAILURE);
      }

      if (id > max_index) {
        max_index = id;
      }

      double val = EvalExpr(e->GetText()).parse();

      vout.paranoiac(m_vl, "%s::%s: id = %d, expr = %s, value = %20.16e\n", class_name.c_str(), __func__, id, e->GetText(), val);

      array[id] = val;
      ++count;
    }
  } else {
    vout.paranoiac(m_vl, "%s::%s: directional array.\n", class_name.c_str(), __func__);

    for (const XMLElement *e = elem->FirstChildElement(); e != NULL; e = e->NextSiblingElement()) {
      int id = 0;

      std::string tag = std::string(e->Name());

      if (tag == "x") {
        id = 0;
      } else if (tag == "y") {
        id = 1;
      } else if (tag == "z") {
        id = 2;
      } else if (tag == "t") {
        id = 3;
      } else {
        vout.crucial("%s::%s: unknown array index \"%s\".\n", class_name.c_str(), __func__, tag.c_str());
        exit(EXIT_FAILURE);
      }

      if (id > max_index) {
        max_index = id;
      }

      double val = EvalExpr(e->GetText()).parse();

      vout.paranoiac(m_vl, "%s::%s: id = %s (%d), expr = %s, value = %20.16e\n", class_name.c_str(), __func__, tag.c_str(), id, e->GetText(), val);

      array[id] = val;
    }
  }

  vout.paranoiac(m_vl, "%s::%s: max_index = %d\n", class_name.c_str(), __func__, max_index);

  std::vector<double> v(max_index + 1);

  for (std::map<int, double>::const_iterator p = array.begin(); p != array.end(); ++p) {
    v[p->first] = p->second;
  }

  return v;
}


//====================================================================
//============================================================END=====