Loading...
Searching...
No Matches
XMLMeshFunction.h
// Copyright (C) 2011 Garth N. Wells
//
// This file is part of DOLFIN.
//
// DOLFIN is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// DOLFIN 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 Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with DOLFIN. If not, see <http://www.gnu.org/licenses/>.
//
// Modified by Anders Logg 2011
//
// First added: 2011-06-30
// Last changed: 2011-11-14
#ifndef __XML_MESH_FUNCTION_H
#define __XML_MESH_FUNCTION_H
#include <iomanip>
#include <iostream>
#include <ostream>
#include <string>
#include "pugixml.hpp"
#include <dolfin/mesh/LocalMeshValueCollection.h>
#include <dolfin/mesh/Mesh.h>
#include <dolfin/mesh/MeshFunction.h>
#include <dolfin/mesh/MeshValueCollection.h>
#include "XMLMesh.h"
#include "XMLMeshValueCollection.h"
#include <dolfin/common/Timer.h>
namespace dolfin
{
class XMLMeshFunction
{
public:
template <typename T>
static void read(MeshFunction<T>& mesh_function, const std::string type,
const pugi::xml_node xml_mesh);
template <typename T>
static void read(MeshValueCollection<T>& mesh_value_collection,
const std::string type, const pugi::xml_node xml_mesh);
template<typename T>
static void write(const MeshFunction<T>& mesh_function,
const std::string type, pugi::xml_node xml_node,
bool write_mesh=true);
};
//---------------------------------------------------------------------------
template <typename T>
inline void XMLMeshFunction::read(MeshFunction<T>& mesh_function,
const std::string type,
const pugi::xml_node xml_mesh)
{
bool new_format = false;
pugi::xml_node xml_meshfunction;
if (std::string(xml_mesh.name()) == "mesh_function")
{
// XML node is a mesh function
new_format = true;
xml_meshfunction = xml_mesh;
}
else
{
// Tag
std::string tag_name = "mesh_function";
// Check for old tag
if (xml_mesh.child("meshfunction"))
{
warning("The XML tag <meshfunction> has been changed to <mesh_function>. "
"I'll be nice and read your XML data anyway, for now, but you will "
"need to update your XML files (a simple search and replace) to use "
"future versions of DOLFIN.");
tag_name = "meshfunction";
}
// Get XML node
xml_meshfunction = xml_mesh.child(tag_name.c_str());
// Read main tag
if (!xml_meshfunction)
std::cout << "Not a DOLFIN MeshFunction XML file." << std::endl;
if (xml_meshfunction.attributes_begin() == xml_meshfunction.attributes_end())
new_format = true;
}
// Check for new (MeshValueCollection) / old storage
if (new_format)
{
// Read new-style MeshFunction
MeshValueCollection<T> mesh_value_collection(mesh_function.mesh());
XMLMeshValueCollection::read<T>(mesh_value_collection, type,
xml_meshfunction);
// Assign collection to mesh function (this is a local
// operation) and attach name
mesh_function = mesh_value_collection;
mesh_function.rename(mesh_value_collection.name(),
mesh_value_collection.label());
}
else
{
// Get type and size
const std::string file_data_type = xml_meshfunction.attribute("type").value();
const std::size_t dim = xml_meshfunction.attribute("dim").as_uint();
const std::size_t size = xml_meshfunction.attribute("size").as_uint();
// Check that types match
if (type != file_data_type)
{
dolfin_error("XMLMeshFunction.h",
"read mesh function from XML file",
"Type mismatch reading XML MeshFunction. MeshFunction type is \"%s\", but file type is \"%s\"",
type.c_str(), file_data_type.c_str());
}
// Initialise MeshFunction
mesh_function.init(dim, size);
// Iterate over entries (choose data type)
if (type == "uint")
{
for (pugi::xml_node_iterator it = xml_meshfunction.begin();
it != xml_meshfunction.end(); ++it)
{
const std::size_t index = it->attribute("index").as_uint();
dolfin_assert(index < size);
mesh_function[index] = it->attribute("value").as_uint();
}
}
else if (type == "int")
{
for (pugi::xml_node_iterator it = xml_meshfunction.begin();
it != xml_meshfunction.end(); ++it)
{
const std::size_t index = it->attribute("index").as_uint();
dolfin_assert(index < size);
mesh_function[index] = it->attribute("value").as_int();
}
}
else if (type == "double")
{
for (pugi::xml_node_iterator it = xml_meshfunction.begin();
it != xml_meshfunction.end(); ++it)
{
const std::size_t index = it->attribute("index").as_uint();
dolfin_assert(index < size);
mesh_function[index] = it->attribute("value").as_double();
}
}
else if (type == "bool")
{
for (pugi::xml_node_iterator it = xml_meshfunction.begin();
it != xml_meshfunction.end(); ++it)
{
const std::size_t index = it->attribute("index").as_uint();
dolfin_assert(index < size);
mesh_function[index] = it->attribute("value").as_bool();
}
}
else
{
dolfin_error("XMLMeshFunction.h",
"read mesh function from XML file",
"Unknown value type (\"%s\")", type.c_str());
}
}
}
//---------------------------------------------------------------------------
template <typename T>
inline void XMLMeshFunction::read(MeshValueCollection<T>& mesh_value_collection,
const std::string type,
const pugi::xml_node xml_mesh)
{
// Check for old tag
std::string tag_name("mesh_function");
if (xml_mesh.child("meshfunction"))
{
warning("The XML tag <meshfunction> has been changed to <mesh_function>. "
"I'll be nice and read your XML data anyway, for now, but you will "
"need to update your XML files (a simple search and replace) to use "
"future versions of DOLFIN.");
tag_name = "meshfunction";
}
// Read main tag
const pugi::xml_node xml_meshfunction = xml_mesh.child(tag_name.c_str());
if (!xml_meshfunction)
std::cout << "Not a DOLFIN MeshFunction XML file." << std::endl;
// Check for new (MeshValueCollection) / old storage
if (xml_meshfunction.attributes_begin() == xml_meshfunction.attributes_end())
{
// Read new-style MeshFunction
XMLMeshValueCollection::read<T>(mesh_value_collection, type,
xml_meshfunction);
}
else
{
dolfin_error("XMLMeshFunction.h",
"read mesh function from XML file",
"Cannot read old-style MeshFunction XML files as a MeshValueCollection");
}
}
//---------------------------------------------------------------------------
template<typename T>
void XMLMeshFunction::write(const MeshFunction<T>& mesh_function,
const std::string type, pugi::xml_node xml_node,
bool write_mesh)
{
not_working_in_parallel("MeshFunction XML output");
// Write mesh if requested
if (write_mesh)
XMLMesh::write(*mesh_function.mesh(), xml_node);
// Add mesh function node and attributes
pugi::xml_node mf_node = xml_node.append_child("mesh_function");
// Create MeshValueCollection for output
MeshValueCollection<T> mesh_value_collection(mesh_function);
mesh_value_collection.rename(mesh_function.name(), mesh_function.label());
// Write MeshValueCollection
XMLMeshValueCollection::write(mesh_value_collection, type, mf_node);
}
//---------------------------------------------------------------------------
}
#endif
dolfin::MeshFunction
Definition MeshFunction.h:58
dolfin::MeshFunction::mesh
std::shared_ptr< const Mesh > mesh() const
Definition MeshFunction.h:491
dolfin::MeshFunction::init
void init(std::size_t dim)
Definition MeshFunction.h:572
dolfin::MeshValueCollection
Definition MeshValueCollection.h:51
dolfin::Variable::label
std::string label() const
Return label (description).
Definition Variable.cpp:76
dolfin::Variable::name
std::string name() const
Return name.
Definition Variable.cpp:71
dolfin::Variable::rename
void rename(const std::string name, const std::string label)
Rename variable.
Definition Variable.cpp:65
dolfin::XMLMeshFunction
I/O of XML representation of MeshFunction.
Definition XMLMeshFunction.h:47
dolfin::XMLMeshFunction::write
static void write(const MeshFunction< T > &mesh_function, const std::string type, pugi::xml_node xml_node, bool write_mesh=true)
Write the XML file.
Definition XMLMeshFunction.h:228
dolfin::XMLMeshFunction::read
static void read(MeshFunction< T > &mesh_function, const std::string type, const pugi::xml_node xml_mesh)
Read XML MeshFunction.
Definition XMLMeshFunction.h:70
dolfin::XMLMeshValueCollection::read
static void read(MeshValueCollection< T > &mesh_value_collection, const std::string type, const pugi::xml_node xml_node)
Read mesh value collection from XML file.
Definition XMLMeshValueCollection.h:56
dolfin::XMLMeshValueCollection::write
static void write(const MeshValueCollection< T > &mesh_value_collection, const std::string type, pugi::xml_node xml_node)
Write mesh value collection to XML file.
Definition XMLMeshValueCollection.h:146
dolfin::XMLMesh::write
static void write(const Mesh &mesh, pugi::xml_node mesh_node)
Write mesh to XML.
Definition XMLMesh.cpp:73
dolfin
Definition adapt.h:30
dolfin::not_working_in_parallel
void not_working_in_parallel(std::string what)
Definition log.cpp:205
dolfin::warning
void warning(std::string msg,...)
Print warning.
Definition log.cpp:115
dolfin::dolfin_error
void dolfin_error(std::string location, std::string task, std::string reason,...)
Definition log.cpp:129