}

  }

  if (transporters2) {

    xmlNodePtr tr2_xml = xmlNewChild(xmlwall, NULL, BAD_CAST "transporters2", NULL); 

    for (int i=0;i<Cell::NChem();i++) {

      xmlNodePtr tr2_val_xml = xmlNewChild(tr2_xml, NULL, BAD_CAST "val", NULL);

      { 

	ostringstream text;

	text << transporters2[i];

	xmlNewProp(tr2_val_xml, BAD_CAST "v", BAD_CAST text.str().c_str());

      }

    }

  }

/*  if (apoplast) {

    xmlNodePtr apo_xml = xmlNewChild(xmlwall, NULL, BAD_CAST "apoplast", NULL); 

    for (int i=0;i<Cell::NChem();i++) {

      xmlNodePtr apo_val_xml = xmlNewChild(apo_xml, NULL, BAD_CAST "val", NULL);

      { 

	ostringstream text;

	text << transporters2[i];

	xmlNewProp(apo_val_xml, BAD_CAST "v", BAD_CAST text.str().c_str());

      }

    }

  } */

}

vector<double> XMLIO::XMLReadValArray(xmlNode *cur)

{

  vector<double> result;

  QLocale standardlocale(QLocale::C);

  bool ok;

  xmlNode *valarray_node = cur->xmlChildrenNode;

  while (valarray_node!=NULL) {

    if (!xmlStrcmp(valarray_node->name, (const xmlChar *)"val")) {

      xmlChar *vc = xmlGetProp(valarray_node, BAD_CAST "v");

      if (vc) {

	//result.push_back(strtod( (const char *)vc, 0));

	result.push_back(standardlocale.toDouble((char *)vc, &ok));

	if (!ok) MyWarning::error("Could not convert \"%s\" to double in XMLRead.",(char *)vc);

	xmlFree(vc);

      }

    }

    valarray_node = valarray_node->next;

  }

  return result;

}

void Mesh::XMLSave(const char *docname, xmlNode *options) const

{

  // based on libxml2 example code "tree2.c"

  xmlDocPtr doc = NULL;       /* document pointer */

  xmlNodePtr root_node = NULL;/* node pointers */

  //xmlDtdPtr dtd = NULL;       /* DTD pointer */

  //  LIBXML_TEST_VERSION;

  /* 

   * Creates a new document, a node and set it as a root node

   */

  doc = xmlNewDoc(BAD_CAST "1.0");

  root_node = xmlNewNode(NULL, BAD_CAST "leaf");

  xmlDocSetRootElement(doc, root_node);

  /* 

   * xmlNewProp() creates attributes, which is "attached" to an node.

   * It returns xmlAttrPtr, which isn't used here.

   */

  xmlNewProp(root_node, BAD_CAST "name", BAD_CAST docname);

  time_t t;

  std::time(&t);

  char *tstring = strdup(asctime(localtime(&t))); // but this does

  // replace "end of line character by '\0'

  char *eol=strchr(tstring,'\n');

  if (eol!=NULL)

    *eol='\0';

  xmlNewProp(root_node, BAD_CAST "date", BAD_CAST tstring);

  free(tstring);

  QString simtime = QString("%1").arg(time);

  xmlNewProp(root_node, BAD_CAST "simtime", BAD_CAST simtime.toStdString().c_str()); 

  /*

   * Creates a DTD declaration. Isn't mandatory. 

   */

  par.XMLAdd(root_node);

  xmlNodePtr xmlnodes = xmlNewChild(root_node, NULL, BAD_CAST "nodes",NULL);

  { ostringstream text;

    text << NNodes();

    xmlNewProp(xmlnodes, BAD_CAST "n", BAD_CAST text.str().c_str());

  }

  { ostringstream text;

    text << Node::target_length;

    xmlNewProp(xmlnodes, BAD_CAST "target_length", BAD_CAST text.str().c_str());

  }

  for (vector<Node *>::const_iterator i=nodes.begin(); i!=nodes.end(); i++) {

    (*i)->XMLAdd(xmlnodes) ;

  }

  /* 

   * xmlNewChild() creates a new node, which is "attached" as child node

   * of root_node node. 

   */

  xmlNodePtr xmlcells = xmlNewChild(root_node, NULL, BAD_CAST "cells",NULL);

  {

    ostringstream text;

    text << NCells();

    xmlNewProp(xmlcells, BAD_CAST "n", BAD_CAST text.str().c_str());

  }

  {

    ostringstream text;

    text << Cell::offset[0];

    xmlNewProp(xmlcells, BAD_CAST "offsetx", BAD_CAST text.str().c_str());

  }

  {

    ostringstream text;

    text << Cell::offset[1];

    xmlNewProp(xmlcells, BAD_CAST "offsety", BAD_CAST text.str().c_str());

  }

  {

    ostringstream text;

    text << Cell::factor;

    xmlNewProp(xmlcells, BAD_CAST "magnification", BAD_CAST text.str().c_str());

  }

  {

    ostringstream text;

    text << cells.front()->BaseArea();

    xmlNewProp(xmlcells, BAD_CAST "base_area", BAD_CAST text.str().c_str());

  }

  { 

    ostringstream text;

    text << Cell::NChem();

    xmlNewProp(xmlcells, BAD_CAST "nchem", BAD_CAST text.str().c_str());

  }

  for (vector<Cell *>::const_iterator i=cells.begin(); i!=cells.end(); i++) {

    (*i)->XMLAdd(xmlcells) ;

  }

  boundary_polygon->XMLAdd(xmlcells);

  xmlNodePtr xmlwalls = xmlNewChild(root_node, NULL, BAD_CAST "walls",NULL);

  { 

    ostringstream text;

    text << walls.size();

    xmlNewProp(xmlwalls, BAD_CAST "n", BAD_CAST text.str().c_str());

  }

  for (list<Wall *>::const_iterator i=walls.begin(); i!=walls.end(); i++) {

    (*i)->XMLAdd(xmlwalls) ;

  }

  xmlNodePtr xmlnodesets = xmlNewChild(root_node, NULL, BAD_CAST "nodesets",NULL);

  { 

    ostringstream text;

    text << node_sets.size();

    xmlNewProp(xmlnodesets, BAD_CAST "n", BAD_CAST text.str().c_str());

  }

  for_each( node_sets.begin(), node_sets.end(), bind2nd ( mem_fun( &NodeSet::XMLAdd ), xmlnodesets ) );

  // Add option tree for interactive application

  if (options) {

    xmlAddChild(root_node, options);

  }

  /* 

   * Dumping document to stdio or file

   */

  xmlSaveFormatFileEnc(docname, doc, "UTF-8", 1);

  /*free the document */

  xmlFreeDoc(doc);

  /*

   *Free the global variables that may

   *have been allocated by the parser.

   */

  xmlCleanupParser();

  /*

   * this is to debug memory for regression tests

   */

}

void Mesh::XMLReadSimtime(const xmlNode *a_node)

{

  xmlNode *root_node;

  root_node = (xmlNode *)a_node;

  xmlChar *strsimtime = xmlGetProp(root_node, BAD_CAST "simtime");

  if (strsimtime) {

    QLocale standardlocale(QLocale::C);

    bool ok;

    double simtime=standardlocale.toDouble((char *)strsimtime, &ok);

    if (!ok) MyWarning::error("Could not convert \"%s\" to double in XMLRead.",(char *)strsimtime);

    time = simtime;

#ifdef QDEBUG

    qDebug() << "Simtime = " << strsimtime << endl;

#endif

  } else {

#ifdef QDEBUG

    qDebug() << "No simtime found in file." << endl;

#endif

    time =0;

  }	

}

void Mesh::XMLReadPars(const xmlNode * a_node)

{

  xmlNode *root_node;

  root_node = (xmlNode *)a_node;

  par.XMLRead(root_node);

  Seed(par.rseed);

  MakeDir(par.datadir);

}

void Mesh::XMLReadGeometry(const xmlNode * a_node)

{

  xmlNode *root_node;

  root_node = (xmlNode *)a_node;

  xmlNode *cur;

  QLocale standardlocale(QLocale::C);

  bool ok;

  // allocate Nodes

  cur = root_node->xmlChildrenNode;

  while (cur!=NULL) {

    if ((!xmlStrcmp(cur->name, (const xmlChar *)"nodes"))){

      XMLReadNodes(cur);

    }

    cur=cur->next;

  }

  cur = root_node->xmlChildrenNode;

  while (cur!=NULL) {

    if ((!xmlStrcmp(cur->name, (const xmlChar *)"nodesets"))) {

      XMLReadNodeSets(cur);

    }

    cur=cur->next;

  }

  cur=root_node->xmlChildrenNode;

  while (cur!=NULL) {

    if ((!xmlStrcmp(cur->name, (const xmlChar *)"nodes"))) {

      XMLReadNodeSetsToNodes(cur);

    }

    cur = cur->next;

  }

  // allocate Cells

  cur = root_node;

  // allocate Cells

  cur = cur->xmlChildrenNode;

  while (cur!=NULL) {

    if ((!xmlStrcmp(cur->name, (const xmlChar *)"cells"))){

      xmlChar *offsetxc = xmlGetProp(cur, BAD_CAST "offsetx");

      xmlChar *offsetyc = xmlGetProp(cur, BAD_CAST "offsety");

      double ox=standardlocale.toDouble((const char *)offsetxc, &ok);

      if (!ok) MyWarning::error("Could not convert \"%s\" to double in XMLRead.",(const char *)offsetxc);

      double oy=standardlocale.toDouble((const char *)offsetyc, &ok);

      if (!ok) MyWarning::error("Could not convert \"%s\" to double in XMLRead.",(const char *)offsetyc);

      Cell::setOffset(ox, oy);

      xmlFree(offsetxc);

      xmlFree(offsetyc);

      xmlChar *magnificationc = xmlGetProp(cur, BAD_CAST "magnification");

      Cell::SetMagnification(standardlocale.toDouble((const char *)magnificationc, &ok));

      if (!ok) MyWarning::error("Could not convert \"%s\" to double in XMLRead.",(const char *)magnificationc);

      xmlFree(magnificationc);

      xmlChar *baseareac = xmlGetProp(cur, BAD_CAST "base_area");

      Cell::BaseArea() = standardlocale.toDouble((const char *)baseareac, &ok);

      if (!ok) MyWarning::error("Could not convert \"%s\" to double in XMLRead.",(const char *)baseareac);

      xmlFree(baseareac);

      XMLReadCells(cur);

    }

    cur=cur->next;

  }

  // allocate Walls (we need to have read the cells before constructing walls)

  vector <Wall *> tmp_walls;

  cur = root_node->xmlChildrenNode;

  while (cur!=NULL) {

    if ((!xmlStrcmp(cur->name, (const xmlChar *)"walls"))){

      XMLReadWalls(cur, &tmp_walls);

    }

    cur=cur->next;

  }

  // read walls to cells and boundary_polygon

  cur = root_node->xmlChildrenNode;

  while (cur!=NULL) {

    if ((!xmlStrcmp(cur->name, (const xmlChar *)"cells"))) {

      XMLReadWallsToCells(cur, &tmp_walls);

    }

    cur=cur->next;

  }

  boundary_polygon->ConstructNeighborList();

  boundary_polygon->ConstructConnections();

  for (vector<Cell *>::iterator c=cells.begin(); c!=cells.end(); c++) {

    (*c)->ConstructNeighborList();

    (*c)->ConstructConnections();

  }

  shuffled_cells.clear();

  shuffled_cells = cells;

  MyUrand r(shuffled_cells.size());

  random_shuffle(shuffled_cells.begin(),shuffled_cells.end(),r);

}

void Mesh::XMLParseTree(const xmlNode *root_node)

{

  XMLReadSimtime(root_node);

  XMLReadPars(root_node);

  XMLReadGeometry(root_node);

}

void Mesh::XMLReadNodes(xmlNode *root)

{

  QLocale standardlocale(QLocale::C);

  bool ok;

  xmlNode *cur = root;

  cur = cur->xmlChildrenNode;

  for (vector<Node *>::iterator i=nodes.begin(); i!=nodes.end(); i++) {

    delete *i;

  }

  nodes.clear();

  Node::nnodes=0;

  xmlChar *tlc = xmlGetProp(root, BAD_CAST "target_length");

  if (tlc != 0) {

    Node::target_length = standardlocale.toDouble((const char *)tlc, &ok);

    if (!ok) MyWarning::error("Could not convert \"%s\" to double in XMLRead.",(const char *)tlc);

    xmlFree(tlc);

  } else {

    // note that libxml2 also defines a token "warning"