diff --git a/src/io/new_dumpers/hdf5_file.hh b/src/io/new_dumpers/hdf5_file.hh
index a4a14fc03..c50344aad 100644
--- a/src/io/new_dumpers/hdf5_file.hh
+++ b/src/io/new_dumpers/hdf5_file.hh
@@ -1,254 +1,306 @@
/**
* @file dumper_hdf5.cc
*
* @author Nicolas Richart
*
* @date creation Tue Oct 03 2017
*
* @brief Dump data in xdmf format
*
* @section LICENSE
*
* Copyright (©) 2010-2011 EPFL (Ecole Polytechnique Fédérale de Lausanne)
* Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
*
* Akantu 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.
*
* Akantu 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 Akantu. If not, see .
*
*/
/* -------------------------------------------------------------------------- */
#include "aka_iterators.hh"
#include "dumper_field.hh"
#include "dumper_file_base.hh"
#include "support.hh"
/* -------------------------------------------------------------------------- */
#include
#include
#include
#include
#include
/* -------------------------------------------------------------------------- */
#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
#define ENDIANNESS(x) (x##LE)
#elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
#define ENDIANNESS(x) (x##BE)
#else
#error "Does not know from which end to open the eggs"
#endif
namespace akantu {
namespace dumper {
namespace {
#define TIDX(x) std::type_index(typeid(x))
hid_t datatype_id_out(const std::type_index & type_idx) {
const static std::unordered_map type_ids{
{TIDX(int), sizeof(int) == 4 ? ENDIANNESS(H5T_STD_I32)
: ENDIANNESS(H5T_STD_I64)},
{TIDX(unsigned int), sizeof(int) == 4 ? ENDIANNESS(H5T_STD_U32)
: ENDIANNESS(H5T_STD_U64)},
{TIDX(int32_t), ENDIANNESS(H5T_STD_I32)},
{TIDX(int64_t), ENDIANNESS(H5T_STD_I64)},
{TIDX(uint32_t), ENDIANNESS(H5T_STD_U32)},
{TIDX(uint64_t), ENDIANNESS(H5T_STD_U64)},
{TIDX(bool), ENDIANNESS(H5T_STD_U8)},
{TIDX(float), ENDIANNESS(H5T_IEEE_F32)},
{TIDX(double), ENDIANNESS(H5T_IEEE_F64)},
};
return type_ids.at(type_idx);
}
hid_t datatype_id_in(const std::type_index & type_idx) {
const static std::unordered_map type_ids{
{TIDX(int), H5T_NATIVE_INT},
{TIDX(unsigned int), H5T_NATIVE_UINT},
{TIDX(int32_t), H5T_NATIVE_INT32},
{TIDX(int64_t), H5T_NATIVE_INT64},
{TIDX(uint32_t), H5T_NATIVE_UINT32},
{TIDX(uint64_t), H5T_NATIVE_UINT64},
{TIDX(bool), H5T_NATIVE_CHAR},
{TIDX(float), H5T_NATIVE_FLOAT},
{TIDX(double), H5T_NATIVE_DOUBLE},
};
return type_ids.at(type_idx);
}
#undef TIDX
} // namespace
namespace HDF5 {
namespace fs = boost::filesystem;
- enum class EntityType { _group, _dataset, _file, _dataspace };
+ enum class EntityType { _group, _dataset, _file, _dataspace, _link };
struct Entity {
hid_t id;
fs::path path;
EntityType type;
Entity(const fs::path & path, EntityType type)
: path(path), type(std::move(type)) {}
~Entity() {
switch (type) {
case EntityType::_group:
H5Gclose(id);
break;
case EntityType::_file:
H5Fclose(id);
break;
case EntityType::_dataset:
H5Dclose(id);
break;
case EntityType::_dataspace:
H5Sclose(id);
break;
+ case EntityType::_link:
+ break;
}
}
};
class File : public FileBase {
public:
File(SupportBase & support, const fs::path & path) : FileBase(support) {
auto path_wof = path;
path_wof.remove_filename();
if (not fs::exists(path_wof)) {
fs::create_directories(path_wof);
}
auto file = std::make_unique("/", EntityType::_file);
file->id =
H5Fcreate(path.c_str(), H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
support.addProperty("hdf5_file", path.string());
entities.push_back(std::move(file));
/* Turn off error handling */
H5Eset_auto(H5E_DEFAULT, NULL, NULL);
}
~File() override = default;
protected:
auto & openGroup(const std::string & path) {
auto & group = *entities.back();
auto && new_group =
std::make_unique(group.path, EntityType::_group);
new_group->path /= path;
auto status =
H5Oexists_by_name(group.id, new_group->path.c_str(), H5P_DEFAULT);
if (status <= 0) {
AKANTU_DEBUG_INFO("DumperHDF5: creating group " << path);
new_group->id = H5Gcreate(group.id, new_group->path.c_str(),
H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
} else {
AKANTU_DEBUG_INFO("DumperHDF5: opening group " << path << " in "
<< group.path);
new_group->id =
H5Gopen(group.id, new_group->path.c_str(), H5P_DEFAULT);
}
entities.push_back(std::move(new_group));
return *entities.back();
}
+ auto & createSymlink(const std::string & path, const std::string & link) {
+ auto & group = *entities.back();
+
+ auto && new_link =
+ std::make_unique(group.path, EntityType::_link);
+ new_link->path /= path;
+
+ auto status =
+ H5Lcreate_soft(link.c_str(), group.id, new_link->path.c_str(),
+ H5P_DEFAULT, H5P_DEFAULT);
+
+ AKANTU_DEBUG_ASSERT(status >= 0, "Could not create HDF5 link "
+ << new_link->path.c_str() << " -> "
+ << link.c_str()
+ << ", status=" << status);
+
+ entities.push_back(std::move(new_link));
+ return *entities.back();
+ }
+
protected:
void dump(FieldArrayBase & field) override {
auto & group = *entities.back();
auto data_set =
std::make_unique(group.path, EntityType::_dataset);
data_set->path /= field.getName();
auto status =
H5Oexists_by_name(group.id, data_set->path.c_str(), H5P_DEFAULT);
decltype(data_set) data_space;
if (status <= 0) {
hsize_t dims[2];
dims[0] = field.size();
dims[1] = field.getNbComponent();
data_space = std::make_unique("", EntityType::_dataspace);
data_space->id = H5Screate_simple(2, dims, NULL);
AKANTU_DEBUG_INFO("DumperHDF5: creating dataset "
<< field.getName() << " in "
<< group.path.generic_string());
data_set->id = H5Dcreate(
group.id, data_set->path.c_str(), datatype_id_out(field.type()),
data_space->id, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
field.addProperty("hdf5_path", data_set->path.generic_string());
} else {
AKANTU_DEBUG_INFO("HDF5: opening existing dataset "
<< data_set->path);
data_set->id = H5Dopen(group.id, data_set->path.c_str(), H5P_DEFAULT);
}
AKANTU_DEBUG_INFO("HDF5: writing dataset " << data_set->path);
H5Dwrite(data_set->id, datatype_id_in(field.type()), H5S_ALL, H5S_ALL,
H5P_DEFAULT, field.data());
}
void dump(FieldElementMapArrayBase & field) override {
auto & group = openGroup(field.getName());
field.addProperty("hdf5_path", group.path.generic_string());
for (auto && type : field.elementTypes()) {
dump(field.array(type));
}
entities.pop_back();
}
void dump(Support & support) override {
+ if (support.hasProperty("hdf5_release") and
+ support.getRelease() == support.getProperty("hdf5_release")) {
+ auto & link = createSymlink(
+ support.getName(), support.getProperty("hdf5_path"));
+ entities.pop_back();
+ }
+
auto & group = openGroup(support.getName());
support.addProperty("hdf5_path", group.path.generic_string());
openGroup("nodes");
auto && nodes = support.getNodes();
dump(nodes);
entities.pop_back();
auto && connectivities = support.getConnectivities();
dump(connectivities);
+ support.addProperty("hdf5_release", support.getRelease());
+
// auto && data_grp = Group(loc_id, path_ + "/data");
openGroup("groups");
for (auto && support : support.getSubSupports()) {
dump(*support.second);
}
+
+ // groups
+ entities.pop_back();
+
+ // mesh
entities.pop_back();
}
void dump(Support & support) override {
const auto & parent_support = support.getParentSupport();
auto & group = openGroup(support.getName());
support.addProperty("hdf5_path", group.path.generic_string());
support.addProperty(
"hdf5_file", parent_support.getProperty("hdf5_file"));
dump(support.getElements());
entities.pop_back();
}
void dump(SupportBase & support) override { FileBase::dump(support); }
+ void dump() override {
+ auto & group = openGroup("steps");
+
+ if (support.hasProperty("time")) {
+ auto & group =
+ openGroup(std::to_string(support.getProperty("time")));
+ }
+
+ FileBase::dump(support);
+
+ if (support.hasProperty("time")) {
+ entities.pop_back();
+ }
+ entities.pop_back();
+ }
+
private:
std::vector> entities;
};
} // namespace HDF5
} // namespace dumper
} // namespace akantu
diff --git a/src/io/new_dumpers/xdmf_file.hh b/src/io/new_dumpers/xdmf_file.hh
index c2a6aa545..1b2e7b2d4 100644
--- a/src/io/new_dumpers/xdmf_file.hh
+++ b/src/io/new_dumpers/xdmf_file.hh
@@ -1,338 +1,404 @@
/**
* @file xdmf_file.hh
*
* @author Nicolas Richart
*
* @date creation Thu Oct 12 2017
*
* @brief A Documented file.
*
* @section LICENSE
*
* Copyright (©) 2010-2011 EPFL (Ecole Polytechnique Fédérale de Lausanne)
* Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
*
* Akantu 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.
*
* Akantu 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 Akantu. If not, see .
*
*/
/* -------------------------------------------------------------------------- */
#include "dumper_file_base.hh"
#include "xml_helper.hh"
/* -------------------------------------------------------------------------- */
#include
#include
#include
#include
#include
/* -------------------------------------------------------------------------- */
namespace {
#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
static const auto ENDIAN{"Little"};
#elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
static const auto ENDIAN{"Big"};
#else
#error "Does not know from which end to open the eggs"
#endif
} // namespace
#ifndef __AKANTU_XDMF_FILE_HH__
#define __AKANTU_XDMF_FILE_HH__
namespace akantu {
namespace dumper {
namespace {
std::string xdmf_type(const ElementType & type) {
static std::map element_map{
{_triangle_3, "Triangle"}, {_quadrangle_4, "Quadrilateral"},
{_tetrahedron_4, "Tetrahedron"}, {_pentahedron_6, "Wedge"},
{_hexahedron_8, "Hexahedron"}, {_triangle_6, "Tri_6"},
{_quadrangle_8, "Quad_8"}, {_tetrahedron_10, "Tet_10"},
{_pentahedron_15, "Wedge_15"}, {_hexahedron_20, "Hex_20"}};
return element_map[type];
}
#define TIDX(x) std::type_index(typeid(x))
auto xdmf_datatype(const std::type_index & type_idx) {
const static std::unordered_map>
type_ids{
{TIDX(int), {"Int", 4}}, {TIDX(unsigned int), {"UInt", 4}},
{TIDX(int32_t), {"Int", 4}}, {TIDX(int64_t), {"Int", 8}},
{TIDX(uint32_t), {"UInt", 4}}, {TIDX(uint64_t), {"Int", 8}},
{TIDX(bool), {"UChar", 1}}, {TIDX(float), {"Float", 4}},
{TIDX(double), {"Float", 8}},
};
return type_ids.at(type_idx);
}
std::string xdmf_geometry(char dim) {
switch (dim) {
case 1:
//[[gnu::fallthrougth]];
case 2:
return "XY";
case 3:
return "XYZ";
default:
AKANTU_EXCEPTION("Dim " << dim << " is not a recognized geometry");
}
}
} // namespace
namespace XDMF {
namespace fs = boost::filesystem;
class File : public XML::File, public dumper::FileBase {
using Tag = XML::Tag;
using CloseTag = XML::CloseTag;
public:
/* ----------------------------------------------------------------------
*/
File(SupportBase & support, const boost::filesystem::path & path)
: XML::File(path), FileBase(support), path(path) {
- *this << "\n";
+ *this << "\n";
*this << "\n";
- *this << Tag("Xdmf")("Version", "2.0")(
+
+ current_xdmf_element.push_back(1);
+
+ *this << Tag("Xdmf")("Version", "3.0")(
"xmlns:xi", "http://www.w3.org/2001/XInclude");
*this << Tag("Domain");
support.addProperty("xdmf_file", path.string());
if (not support.hasProperty("dump_count"))
return;
auto mesh_name = support.getName();
*this << Tag("Grid")("Name", mesh_name + ":all")(
"GridType", "Collection")("CollectionType", "Temporal");
}
/* -------------------------------------------------------------------- */
File(SupportBase & support, const boost::filesystem::path & path,
- const std::vector & current_xdmf_path)
+ const std::vector & current_xdmf_path,
+ const std::vector & current_xdmf_element)
: XML::File(path), FileBase(support), include(true),
- current_xdmf_path(current_xdmf_path), path(path) {}
+ current_xdmf_path(current_xdmf_path),
+ current_xdmf_element(current_xdmf_element), path(path) {}
/* -------------------------------------------------------------------- */
~File() = default;
/* -------------------------------------------------------------------- */
XML::File & operator<<(const std::string & str) override {
return XML::File::operator<<(str);
}
/* -------------------------------------------------------------------- */
XML::File & operator<<(const Tag & tag) override {
XML::File::operator<<(tag);
if (tag.autoclosing()) {
+ if (not current_xdmf_element.empty()) {
+ ++(current_xdmf_element.back());
+ }
+
return *this;
}
auto tag_ = tag.tag();
if (tag.hasProperty("Name")) {
tag_ += "[@Name=\"" + tag.getProperty("Name") + "\"]";
}
+
current_xdmf_path.push_back(tag_);
+ current_xdmf_element.push_back(1);
+
+ //*this << "\n";
return *this;
}
/* -------------------------------------------------------------------- */
XML::File & operator<<(const CloseTag & tag) override {
XML::File::operator<<(tag);
current_xdmf_path.pop_back();
+ current_xdmf_element.pop_back();
+ if (not current_xdmf_element.empty()) {
+ ++(current_xdmf_element.back());
+ }
return *this;
}
/* -------------------------------------------------------------------- */
void dump() override {
- if (include) {
- auto count = support.getProperty("dump_count");
- *this << Tag("Grid")("CollectionType", "Spatial")(
- "GridType", "Collection")("Name",
- "model_" + std::to_string(count));
- if (support.hasProperty("time")) {
- *this << Tag("Time", true)("TimeType", "Single")(
- "Value", support.getProperty("time"));
- }
+ // if (include) {
+ auto count = support.getProperty("dump_count");
+ *this << Tag("Grid")("CollectionType", "Spatial")(
+ "GridType", "Collection")("Name", "model_" + std::to_string(count));
- FileBase::dump();
- return;
+ if (support.hasProperty("time")) {
+ *this << Tag("Information", true)("Name", "Time")(
+ "Value", support.getProperty("time"));
}
- auto count = support.getProperty("dump_count");
- auto include_path = getIncludeFilename(count);
+ FileBase::dump();
+
+ *this << CloseTag{};
+ // return;
+ // }
+
+ // auto count = support.getProperty("dump_count");
+ // auto include_path = getIncludeFilename(count);
- File xdmf_include(support, include_path, current_xdmf_path);
- xdmf_include.dump();
+ // File xdmf_include(support, include_path, current_xdmf_path);
+ // xdmf_include.dump();
- auto sub_path =
- fs::relative(include_path, fs::path(path).remove_filename());
- *this << Tag("xi:include", true)("href", sub_path.string());
+ // auto sub_path =
+ // fs::relative(include_path, fs::path(path).remove_filename());
+ // *this << Tag("xi:include", true)("href", sub_path.string());
}
private:
fs::path getIncludeFilename(std::size_t num) {
std::stringstream sstr;
sstr << std::setw(5) << std::setfill('0') << num;
auto include_path = path;
include_path.remove_filename();
include_path /= "xmfs";
include_path /=
path.stem().string() + '_' + sstr.str() + path.extension().string();
return include_path;
}
std::string currentXMFPath() const {
auto tmp = fs::path("/");
for (auto && tag : current_xdmf_path) {
tmp /= tag;
}
return tmp.generic_string();
}
+ std::string currentXMFElement() const {
+ auto tmp = fs::path("/");
+ auto copy = current_xdmf_element;
+ copy.pop_back();
+ for (auto && tag : copy) {
+ tmp /= std::to_string(tag);
+ }
+
+ return tmp.generic_string();
+ }
+
std::string getName(const ID & name,
const Qualified & type) const {
std::stringstream sstr;
sstr << name << ":" << type.type;
if (type.ghost_type != _not_ghost) {
sstr << ":" << type.ghost_type;
}
return sstr.str();
}
protected:
/* -------------------------------------------------------------------- */
void dump(FieldArrayBase & field) override {
auto && support = field.getSupport();
auto && tag = Tag("DataItem");
-
- // if (reference and field.hasProperty("xdmf_path")) {
- // *this << tag("Reference", "XML");
- // *this << (field.getProperty("xdmf_path")) << "\n";
- // } else
- if (field.hasProperty("hdf5_path")) {
+ if (field.hasProperty("xdmf_element")) {
+ *this << Tag("xi:include", true)(
+ "xpointer", "element(" +
+ field.getProperty("xdmf_element") +
+ ")");
+ //*this << tag("Reference", "XML");
+ //*this << (field.getProperty("xdmf_path")) << "\n";
+ } else if (field.hasProperty("hdf5_path")) {
auto && dims = std::make_tuple(field.size(), field.getNbComponent());
auto && hdf5_path =
fs::relative(
fs::path(support.getProperty("hdf5_file")),
fs::path(support.getProperty("xdmf_file"))
.remove_filename())
.string() +
":" + field.getProperty("hdf5_path");
auto && xdmf_datatype_ = xdmf_datatype(field.type());
/* clang-format off */
*this << tag("Name", field.getName())
("Dimensions", dims)
("Format", "HDF")
("NumberType", xdmf_datatype_.first)
("Precision", xdmf_datatype_.second)
("Endian", ENDIAN);
/* clang-format on */
*this << hdf5_path << "\n";
field.addProperty("xdmf_path", currentXMFPath());
+ field.addProperty("xdmf_element", currentXMFElement());
} else {
AKANTU_EXCEPTION("The XML and Binary format are not implemented yet");
}
*this << CloseTag{};
}
/* -------------------------------------------------------------------- */
void dump(FieldElementMapArrayBase & /*field*/) override {}
/* -------------------------------------------------------------------- */
void dump(Support & support) override {
auto && mesh_name = support.getName();
auto && nodes = support.getNodes();
- *this << Tag("Grid")("CollectionType", "Spatial")(
- "GridType", "Collection")("Name", mesh_name);
-
- support.addProperty("xdmf_path", currentXMFPath());
-
- for (auto && type : support.elementTypes()) {
- auto & connectivities = support.getConnectivities();
- auto & conn = connectivities.array(type);
- auto && conn_name = getName(mesh_name, type);
-
- *this << Tag("Grid")("Name", conn_name)("GridType", "Uniform");
-
- // Topology
- *this << Tag("Topology")("TopologyType", xdmf_type(type))(
- "NumberOfElements", conn.size());
- dump(conn);
- *this << CloseTag{};
-
- // Geometry
- *this << Tag("Geometry")("GeometryType",
- xdmf_geometry(nodes.getNbComponent()));
- dump(nodes);
- *this << CloseTag{};
+ if (support.hasProperty("xdmf_element")) {
+ auto element = support.getProperty("xdmf_element");
+ *this << Tag("xi:include", true)("xpointer",
+ "element(" + element + ")");
+ } else {
+ *this << Tag("Grid")("CollectionType", "Spatial")(
+ "GridType", "Collection")("Name", mesh_name);
+ support.addProperty("xdmf_path", currentXMFPath());
+ support.addProperty("xdmf_element", currentXMFElement());
+
+ for (auto && type : support.elementTypes()) {
+ auto & connectivities = support.getConnectivities();
+ auto & conn = connectivities.array(type);
+ auto && conn_name = getName(mesh_name, type);
+
+ *this << Tag("Grid")("Name", conn_name)("GridType", "Uniform");
+
+ // Topology
+ if (conn.hasProperty("xdmf_element")) {
+ auto element =
+ fs::path(conn.getProperty("xdmf_element"))
+ .parent_path()
+ .string();
+ *this << Tag("xi:include", true)("xpointer",
+ "element(" + element + ")");
+ } else {
+ *this << Tag("Topology")("TopologyType", xdmf_type(type))(
+ "NumberOfElements", conn.size());
+ dump(conn);
+ *this << CloseTag{};
+ }
+
+ // Geometry
+ if (nodes.hasProperty("xdmf_element")) {
+ auto element =
+ fs::path(nodes.getProperty("xdmf_element"))
+ .parent_path()
+ .string();
+ *this << Tag("xi:include", true)("xpointer",
+ "element(" + element + ")");
+ } else {
+ *this << Tag("Geometry")("GeometryType",
+ xdmf_geometry(nodes.getNbComponent()));
+ dump(nodes);
+ *this << CloseTag{};
+ }
+
+ *this << CloseTag{};
+ }
*this << CloseTag{};
}
- *this << CloseTag{};
for (auto && support : support.getSubSupports()) {
dump(*support.second);
}
}
- /* ------------------------------------------------------------------------
- */
+ /* -------------------------------------------------------------------- */
void dump(Support & support) override {
const auto & parent_support = support.getParentSupport();
fs::path xdmf_parent =
parent_support.getProperty("xdmf_path");
auto parent_name = parent_support.getName();
auto name = parent_name + ":" + support.getName();
+ if (support.hasProperty("xdmf_element")) {
+ auto element = support.getProperty("xdmf_element");
+ *this << Tag("xi:include", true)("xpointer",
+ "element(" + element + ")");
+ return;
+ }
+
*this << Tag("Grid")("Name", name)("GridType", "Collection")(
"CollectionType", "Spatial");
support.addProperty("xdmf_path", currentXMFPath());
+ support.addProperty("xdmf_element", currentXMFElement());
support.addProperty(
"xdmf_file", parent_support.getProperty("xdmf_file"));
auto & elements = support.getElements();
for (auto && type : support.elementTypes()) {
auto xdmf_path = xdmf_parent;
auto && name = getName(support.getName(), type);
*this << Tag("Grid")("Name", name)("GridType", "Subset")("Section",
"DataItem");
dump(elements.array(type));
*this << Tag("Grid")("Name", "Target")("Reference", "XML");
xdmf_path /= "Grid[@Name=\"" + getName(parent_name, type) + "\"]";
*this << xdmf_path.generic_string() << "\n";
*this << CloseTag{};
*this << CloseTag{};
}
*this << CloseTag{};
}
void dump(SupportBase & support) override { FileBase::dump(support); }
public:
bool include{false};
std::vector current_xdmf_path;
+ std::vector current_xdmf_element;
boost::filesystem::path path;
};
} // namespace XDMF
} // namespace dumper
} // namespace akantu
#endif /* __AKANTU_XDMF_FILE_HH__ */
diff --git a/src/io/new_dumpers/xml_helper.hh b/src/io/new_dumpers/xml_helper.hh
index ce720bd53..9df53039e 100644
--- a/src/io/new_dumpers/xml_helper.hh
+++ b/src/io/new_dumpers/xml_helper.hh
@@ -1,251 +1,246 @@
/**
* @file xml_helper.hh
*
* @author Nicolas Richart
*
* @date creation Mon Oct 09 2017
*
* @brief A Documented file.
*
* @section LICENSE
*
* Copyright (©) 2010-2011 EPFL (Ecole Polytechnique Fédérale de Lausanne)
* Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
*
* Akantu 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.
*
* Akantu 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 Akantu. If not, see .
*
*/
/* -------------------------------------------------------------------------- */
#include
#include
#include
#include