diff --git a/python/Allocate.hpp b/python/Allocate.hpp
index 922ee90..f3861a9 100644
--- a/python/Allocate.hpp
+++ b/python/Allocate.hpp
@@ -1,37 +1,37 @@
 /**
  * @file
  * @copyright Copyright 2017. Tom de Geus. All rights reserved.
- * \license This project is released under the GNU Public License (GPLv3).
+ * @license This project is released under the GNU Public License (GPLv3).
  */
 
 #include <GooseFEM/Allocate.h>
 #include <pybind11/pybind11.h>
 #include <xtensor-python/pyarray.hpp>
 
 namespace py = pybind11;
 
 void init_Allocate(py::module& m)
 {
     m.def(
         "AsTensor",
         static_cast<xt::xarray<double> (*)(const xt::pyarray<double>&, const std::vector<size_t>&)>(
             &GooseFEM::AsTensor),
         "See :cpp:func:`GooseFEM::AsTensor`.",
         py::arg("arg"),
         py::arg("shape"));
 
     m.def(
         "AsTensor",
         static_cast<xt::xarray<double> (*)(size_t, const xt::pyarray<double>&, size_t)>(
             &GooseFEM::AsTensor),
         "See :cpp:func:`GooseFEM::AsTensor`.",
         py::arg("rank"),
         py::arg("arg"),
         py::arg("n"));
 
     m.def(
         "as3d",
         &GooseFEM::as3d<xt::pyarray<double>>,
         "See :cpp:func:`GooseFEM::as3d`.",
         py::arg("arg"));
 }
diff --git a/python/Element.hpp b/python/Element.hpp
index 3800ed5..5c6078a 100644
--- a/python/Element.hpp
+++ b/python/Element.hpp
@@ -1,182 +1,182 @@
 /**
  * @file
  * @copyright Copyright 2017. Tom de Geus. All rights reserved.
- * \license This project is released under the GNU Public License (GPLv3).
+ * @license This project is released under the GNU Public License (GPLv3).
  */
 
 #ifndef PYGOOSEFEM_ELEMENT_H
 #define PYGOOSEFEM_ELEMENT_H
 
 #include <GooseFEM/Element.h>
 #include <pybind11/pybind11.h>
 #include <pybind11/stl.h>
 #include <xtensor-python/pyarray.hpp>
 #include <xtensor-python/pytensor.hpp>
 
 namespace py = pybind11;
 
 template <class C, class P>
 void register_Mesh_QuadratureBase(P& cls)
 {
     cls.def_property_readonly("nelem", &C::nelem, "Number of elements");
     cls.def_property_readonly("nne", &C::nne, "Number of nodes per element");
     cls.def_property_readonly("ndim", &C::ndim, "Number of spatial dimensions");
     cls.def_property_readonly("tdim", &C::tdim, "Number of spatial dimensions for tensors");
     cls.def_property_readonly("nip", &C::nip, "Number of integration points per element");
 
     // todo: https://github.com/xtensor-stack/xtensor-python/issues/265
     // cls.def("asTensor",
     //         static_cast<void (C::*)(const xt::pyarray<double>&, xt::pyarray<double>&)
     //         const>(&C::asTensor), "Convert 'qscalar' to 'qtensor' of certain rank",
     //         py::arg("qscalar"),
     //         py::arg("qtensor"));
 
     cls.def(
         "AsTensor",
         static_cast<xt::xarray<double> (C::*)(size_t, const xt::pyarray<double>&) const>(
             &C::AsTensor),
         py::arg("rank"),
         py::arg("qscalar"));
 
     cls.def("shape_elemvec", static_cast<std::array<size_t, 3> (C::*)() const>(&C::shape_elemvec));
 
     cls.def(
         "shape_elemvec",
         static_cast<std::array<size_t, 3> (C::*)(size_t) const>(&C::shape_elemvec),
         py::arg("tdim"));
 
     cls.def("shape_elemmat", &C::shape_elemmat);
 
     cls.def(
         "shape_qtensor",
         static_cast<std::vector<size_t> (C::*)(size_t) const>(&C::shape_qtensor),
         py::arg("rank"));
 
     cls.def(
         "shape_qtensor",
         static_cast<std::vector<size_t> (C::*)(size_t, size_t) const>(&C::shape_qtensor),
         py::arg("rank"),
         py::arg("tdim"));
 
     cls.def("shape_qscalar", &C::shape_qscalar);
 
     cls.def("shape_qvector", static_cast<std::array<size_t, 3> (C::*)() const>(&C::shape_qvector));
 
     cls.def(
         "shape_qvector",
         static_cast<std::array<size_t, 3> (C::*)(size_t) const>(&C::shape_qvector),
         py::arg("tdim"));
 }
 
 template <class C, class P>
 void register_Mesh_QuadratureBaseCartesian(P& cls)
 {
     cls.def("update_x", &C::template update_x<xt::pytensor<double, 3>>, py::arg("x"));
 
     cls.def_property_readonly("dV", &C::dV, "Integration point volume (qscalar)");
 
     cls.def(
         "InterpQuad_vector",
         &C::template InterpQuad_vector<xt::pytensor<double, 3>>,
         py::arg("elemvec"));
 
     cls.def(
         "interpQuad_vector",
         &C::template interpQuad_vector<xt::pytensor<double, 3>, xt::pytensor<double, 3>>,
         py::arg("elemvec"),
         py::arg("qvector"));
 
     cls.def("GradN_vector", &C::template GradN_vector<xt::pytensor<double, 3>>, py::arg("elemvec"));
 
     cls.def(
         "gradN_vector",
         &C::template gradN_vector<xt::pytensor<double, 3>, xt::pytensor<double, 4>>,
         py::arg("elemvec"),
         py::arg("qtensor"));
 
     cls.def(
         "GradN_vector_T", &C::template GradN_vector_T<xt::pytensor<double, 3>>, py::arg("elemvec"));
 
     cls.def(
         "gradN_vector_T",
         &C::template gradN_vector_T<xt::pytensor<double, 3>, xt::pytensor<double, 4>>,
         py::arg("elemvec"),
         py::arg("qtensor"));
 
     cls.def(
         "SymGradN_vector",
         &C::template SymGradN_vector<xt::pytensor<double, 3>>,
         py::arg("elemvec"));
 
     cls.def(
         "symGradN_vector",
         &C::template symGradN_vector<xt::pytensor<double, 3>, xt::pytensor<double, 4>>,
         py::arg("elemvec"),
         py::arg("qtensor"));
 
     cls.def(
         "Int_N_vector_dV",
         &C::template Int_N_vector_dV<xt::pytensor<double, 3>>,
         py::arg("qvector"));
 
     cls.def(
         "int_N_vector_dV",
         &C::template int_N_vector_dV<xt::pytensor<double, 3>, xt::pytensor<double, 3>>,
         py::arg("qvector"),
         py::arg("elemvec"));
 
     cls.def(
         "Int_N_scalar_NT_dV",
         &C::template Int_N_scalar_NT_dV<xt::pytensor<double, 2>>,
         py::arg("qscalar"));
 
     cls.def(
         "int_N_scalar_NT_dV",
         &C::template int_N_scalar_NT_dV<xt::pytensor<double, 2>, xt::pytensor<double, 3>>,
         py::arg("qscalar"),
         py::arg("elemmat"));
 
     cls.def(
         "Int_gradN_dot_tensor2_dV",
         &C::template Int_gradN_dot_tensor2_dV<xt::pytensor<double, 4>>,
         py::arg("qtensor"));
 
     cls.def(
         "int_gradN_dot_tensor2_dV",
         &C::template int_gradN_dot_tensor2_dV<xt::pytensor<double, 4>, xt::pytensor<double, 3>>,
         py::arg("qtensor"),
         py::arg("elemvec"));
 
     cls.def(
         "Int_gradN_dot_tensor4_dot_gradNT_dV",
         &C::template Int_gradN_dot_tensor4_dot_gradNT_dV<xt::pytensor<double, 6>>,
         py::arg("qtensor"));
 
     cls.def(
         "int_gradN_dot_tensor4_dot_gradNT_dV",
         &C::template int_gradN_dot_tensor4_dot_gradNT_dV<
             xt::pytensor<double, 6>,
             xt::pytensor<double, 3>>,
         py::arg("qtensor"),
         py::arg("elemmat"));
 }
 
 void init_Element(py::module& m)
 {
 
     m.def(
         "asElementVector",
         &GooseFEM::Element::asElementVector,
         "See :cpp:func:`GooseFEM::Element::asElementVector`.",
         py::arg("conn"),
         py::arg("nodevec"));
 
     m.def(
         "assembleElementVector",
         &GooseFEM::Element::assembleNodeVector,
         "See :cpp:func:`GooseFEM::Element::assembleNodeVector`.",
         py::arg("conn"),
         py::arg("elemvec"));
 }
 
 #endif
diff --git a/python/ElementHex8.hpp b/python/ElementHex8.hpp
index 8054087..8dbfb38 100644
--- a/python/ElementHex8.hpp
+++ b/python/ElementHex8.hpp
@@ -1,64 +1,64 @@
 /**
  * @file
  * @copyright Copyright 2017. Tom de Geus. All rights reserved.
- * \license This project is released under the GNU Public License (GPLv3).
+ * @license This project is released under the GNU Public License (GPLv3).
  */
 
 #ifndef PYGOOSEFEM_ELEMENTHEX8_H
 #define PYGOOSEFEM_ELEMENTHEX8_H
 
 #include <GooseFEM/ElementHex8.h>
 #include <pybind11/pybind11.h>
 #include <xtensor-python/pytensor.hpp>
 
 #include "Element.hpp"
 
 namespace py = pybind11;
 
 void init_ElementHex8(py::module& m)
 {
     py::class_<GooseFEM::Element::Hex8::Quadrature> cls(m, "Quadrature");
 
     cls.def(
         py::init<const xt::pytensor<double, 3>&>(),
         "See :cpp:class:`GooseFEM::Element::Hex8::Quadrature`.",
         py::arg("x"));
 
     cls.def(
         py::init<
             const xt::pytensor<double, 3>&,
             const xt::pytensor<double, 2>&,
             const xt::pytensor<double, 1>&>(),
         "See :cpp:class:`GooseFEM::Element::Hex8::Quadrature`.",
         py::arg("x"),
         py::arg("xi"),
         py::arg("w"));
 
     register_Mesh_QuadratureBase<GooseFEM::Element::Hex8::Quadrature>(cls);
     register_Mesh_QuadratureBaseCartesian<GooseFEM::Element::Hex8::Quadrature>(cls);
 
     cls.def_property_readonly(
         "GradN",
         &GooseFEM::Element::Hex8::Quadrature::GradN,
         "Shape function gradients  [nelem, nip, nne, ndim]");
 
     cls.def("__repr__", [](const GooseFEM::Element::Hex8::Quadrature&) {
         return "<GooseFEM.Element.Hex8.Quadrature>";
     });
 }
 
 void init_ElementHex8Gauss(py::module& m)
 {
     m.def("nip", &GooseFEM::Element::Hex8::Gauss::nip);
     m.def("xi", &GooseFEM::Element::Hex8::Gauss::xi);
     m.def("w", &GooseFEM::Element::Hex8::Gauss::w);
 }
 
 void init_ElementHex8Nodal(py::module& m)
 {
     m.def("nip", &GooseFEM::Element::Hex8::Nodal::nip);
     m.def("xi", &GooseFEM::Element::Hex8::Nodal::xi);
     m.def("w", &GooseFEM::Element::Hex8::Nodal::w);
 }
 
 #endif
diff --git a/python/ElementQuad4.hpp b/python/ElementQuad4.hpp
index f7e9791..98830d7 100644
--- a/python/ElementQuad4.hpp
+++ b/python/ElementQuad4.hpp
@@ -1,71 +1,71 @@
 /**
  * @file
  * @copyright Copyright 2017. Tom de Geus. All rights reserved.
- * \license This project is released under the GNU Public License (GPLv3).
+ * @license This project is released under the GNU Public License (GPLv3).
  */
 
 #ifndef PYGOOSEFEM_ELEMENTQUAD4_H
 #define PYGOOSEFEM_ELEMENTQUAD4_H
 
 #include <GooseFEM/ElementQuad4.h>
 #include <pybind11/pybind11.h>
 #include <xtensor-python/pytensor.hpp>
 
 #include "Element.hpp"
 
 namespace py = pybind11;
 
 void init_ElementQuad4(py::module& m)
 {
     py::class_<GooseFEM::Element::Quad4::Quadrature> cls(m, "Quadrature");
 
     cls.def(
         py::init<const xt::pytensor<double, 3>&>(),
         "See :cpp:class:`GooseFEM::Element::Quad4::Quadrature`.",
         py::arg("x"));
 
     cls.def(
         py::init<
             const xt::pytensor<double, 3>&,
             const xt::pytensor<double, 2>&,
             const xt::pytensor<double, 1>&>(),
         "See :cpp:class:`GooseFEM::Element::Quad4::Quadrature`.",
         py::arg("x"),
         py::arg("xi"),
         py::arg("w"));
 
     register_Mesh_QuadratureBase<GooseFEM::Element::Quad4::Quadrature>(cls);
     register_Mesh_QuadratureBaseCartesian<GooseFEM::Element::Quad4::Quadrature>(cls);
 
     cls.def_property_readonly(
         "GradN",
         &GooseFEM::Element::Quad4::Quadrature::GradN,
         "Shape function gradients [nelem, nip, nne, ndim]");
 
     cls.def("__repr__", [](const GooseFEM::Element::Quad4::Quadrature&) {
         return "<GooseFEM.Element.Quad4.Quadrature>";
     });
 }
 
 void init_ElementQuad4Gauss(py::module& m)
 {
     m.def("nip", &GooseFEM::Element::Quad4::Gauss::nip);
     m.def("xi", &GooseFEM::Element::Quad4::Gauss::xi);
     m.def("w", &GooseFEM::Element::Quad4::Gauss::w);
 }
 
 void init_ElementQuad4Nodal(py::module& m)
 {
     m.def("nip", &GooseFEM::Element::Quad4::Nodal::nip);
     m.def("xi", &GooseFEM::Element::Quad4::Nodal::xi);
     m.def("w", &GooseFEM::Element::Quad4::Nodal::w);
 }
 
 void init_ElementQuad4MidPoint(py::module& m)
 {
     m.def("nip", &GooseFEM::Element::Quad4::MidPoint::nip);
     m.def("xi", &GooseFEM::Element::Quad4::MidPoint::xi);
     m.def("w", &GooseFEM::Element::Quad4::MidPoint::w);
 }
 
 #endif
diff --git a/python/ElementQuad4Axisymmetric.hpp b/python/ElementQuad4Axisymmetric.hpp
index 1e3ddb3..8a11166 100644
--- a/python/ElementQuad4Axisymmetric.hpp
+++ b/python/ElementQuad4Axisymmetric.hpp
@@ -1,50 +1,50 @@
 /**
  * @file
  * @copyright Copyright 2017. Tom de Geus. All rights reserved.
- * \license This project is released under the GNU Public License (GPLv3).
+ * @license This project is released under the GNU Public License (GPLv3).
  */
 
 #ifndef PYGOOSEFEM_ELEMENTQUAD4AXISYMMETRIC_H
 #define PYGOOSEFEM_ELEMENTQUAD4AXISYMMETRIC_H
 
 #include <GooseFEM/ElementQuad4Axisymmetric.h>
 #include <pybind11/pybind11.h>
 #include <xtensor-python/pytensor.hpp>
 
 #include "Element.hpp"
 
 namespace py = pybind11;
 
 void init_ElementQuad4Axisymmetric(py::module& m)
 {
     py::class_<GooseFEM::Element::Quad4::QuadratureAxisymmetric> cls(m, "QuadratureAxisymmetric");
 
     cls.def(
         py::init<const xt::pytensor<double, 3>&>(),
         "See :cpp:class:`GooseFEM::Element::Quad4::QuadratureAxisymmetric`.",
         py::arg("x"));
 
     cls.def(
         py::init<
             const xt::pytensor<double, 3>&,
             const xt::pytensor<double, 2>&,
             const xt::pytensor<double, 1>&>(),
         "See :cpp:class:`GooseFEM::Element::Quad4::QuadratureAxisymmetric`.",
         py::arg("x"),
         py::arg("xi"),
         py::arg("w"));
 
     register_Mesh_QuadratureBase<GooseFEM::Element::Quad4::QuadratureAxisymmetric>(cls);
     register_Mesh_QuadratureBaseCartesian<GooseFEM::Element::Quad4::QuadratureAxisymmetric>(cls);
 
     cls.def_property_readonly(
         "B",
         &GooseFEM::Element::Quad4::QuadratureAxisymmetric::B,
         "B-matrix (shape function gradients) [nelem, nne, tdim, tdim, tdim]");
 
     cls.def("__repr__", [](const GooseFEM::Element::Quad4::QuadratureAxisymmetric&) {
         return "<GooseFEM.Element.Quad4.QuadratureAxisymmetric>";
     });
 }
 
 #endif
diff --git a/python/ElementQuad4Planar.hpp b/python/ElementQuad4Planar.hpp
index 603e09b..3c18780 100644
--- a/python/ElementQuad4Planar.hpp
+++ b/python/ElementQuad4Planar.hpp
@@ -1,53 +1,53 @@
 /**
  * @file
  * @copyright Copyright 2017. Tom de Geus. All rights reserved.
- * \license This project is released under the GNU Public License (GPLv3).
+ * @license This project is released under the GNU Public License (GPLv3).
  */
 
 #ifndef PYGOOSEFEM_ELEMENTQUAD4PLANAR_H
 #define PYGOOSEFEM_ELEMENTQUAD4PLANAR_H
 
 #include <GooseFEM/ElementQuad4Planar.h>
 #include <pybind11/pybind11.h>
 #include <xtensor-python/pytensor.hpp>
 
 #include "Element.hpp"
 
 namespace py = pybind11;
 
 void init_ElementQuad4Planar(py::module& m)
 {
     py::class_<GooseFEM::Element::Quad4::QuadraturePlanar> cls(m, "QuadraturePlanar");
 
     cls.def(
         py::init<const xt::pytensor<double, 3>&, double>(),
         "See :cpp:class:`GooseFEM::Element::Quad4::QuadraturePlanar`.",
         py::arg("x"),
         py::arg("thick") = 1.0);
 
     cls.def(
         py::init<
             const xt::pytensor<double, 3>&,
             const xt::pytensor<double, 2>&,
             const xt::pytensor<double, 1>&,
             double>(),
         "See :cpp:class:`GooseFEM::Element::Quad4::QuadraturePlanar`.",
         py::arg("x"),
         py::arg("xi"),
         py::arg("w"),
         py::arg("thick") = 1.0);
 
     register_Mesh_QuadratureBase<GooseFEM::Element::Quad4::QuadraturePlanar>(cls);
     register_Mesh_QuadratureBaseCartesian<GooseFEM::Element::Quad4::QuadraturePlanar>(cls);
 
     cls.def_property_readonly(
         "GradN",
         &GooseFEM::Element::Quad4::QuadraturePlanar::GradN,
         "Shape function gradients [nelem, nip, nne, ndim]");
 
     cls.def("__repr__", [](const GooseFEM::Element::Quad4::QuadraturePlanar&) {
         return "<GooseFEM.Element.Quad4.QuadraturePlanar>";
     });
 }
 
 #endif
diff --git a/python/Iterate.hpp b/python/Iterate.hpp
index 1898e2a..2e22efe 100644
--- a/python/Iterate.hpp
+++ b/python/Iterate.hpp
@@ -1,33 +1,33 @@
 /**
  * @file
  * @copyright Copyright 2017. Tom de Geus. All rights reserved.
- * \license This project is released under the GNU Public License (GPLv3).
+ * @license This project is released under the GNU Public License (GPLv3).
  */
 
 #ifndef PYGOOSEFEM_ITERATE_H
 #define PYGOOSEFEM_ITERATE_H
 
 #include <GooseFEM/Iterate.h>
 #include <pybind11/pybind11.h>
 #include <pybind11/stl.h>
 
 namespace py = pybind11;
 
 void init_Iterate(py::module& mod)
 {
     py::class_<GooseFEM::Iterate::StopList> cls(mod, "StopList");
 
     cls.def(py::init<size_t>(), "See :cpp:class:`GooseFEM::Iterate::StopList`.", py::arg("n") = 1);
 
     cls.def("reset", py::overload_cast<>(&GooseFEM::Iterate::StopList::reset));
     cls.def("roll_insert", &GooseFEM::Iterate::StopList::roll_insert, py::arg("res"));
     cls.def("descending", &GooseFEM::Iterate::StopList::descending);
     cls.def("all_less", &GooseFEM::Iterate::StopList::all_less, py::arg("tol"));
     cls.def_property_readonly("data", &GooseFEM::Iterate::StopList::data);
 
     cls.def("__repr__", [](const GooseFEM::Iterate::StopList&) {
         return "<GooseFEM.Iterate.StopList>";
     });
 }
 
 #endif
diff --git a/python/Matrix.hpp b/python/Matrix.hpp
index 86c7b77..2f36cbe 100644
--- a/python/Matrix.hpp
+++ b/python/Matrix.hpp
@@ -1,224 +1,224 @@
 /**
  * @file
  * @copyright Copyright 2017. Tom de Geus. All rights reserved.
- * \license This project is released under the GNU Public License (GPLv3).
+ * @license This project is released under the GNU Public License (GPLv3).
  */
 
 #ifndef PYGOOSEFEM_MATRIX_H
 #define PYGOOSEFEM_MATRIX_H
 
 #include <Eigen/Eigen>
 #include <GooseFEM/Matrix.h>
 #include <pybind11/eigen.h>
 #include <pybind11/pybind11.h>
 #include <xtensor-python/pyarray.hpp>
 #include <xtensor-python/pytensor.hpp>
 
 namespace py = pybind11;
 
 template <class C, class P>
 void register_Matrix_MatrixBase(P& cls)
 {
     cls.def_property_readonly("nelem", &C::nelem, "Number of elements");
     cls.def_property_readonly("nne", &C::nne, "Number of nodes per element");
     cls.def_property_readonly("nnode", &C::nnode, "Number of nodes");
     cls.def_property_readonly("ndim", &C::ndim, "Number of dimensions");
     cls.def_property_readonly("ndof", &C::ndof, "Number of DOFs");
     cls.def_property_readonly("dofs", &C::dofs, "DOFs [nnode, ndim]");
     cls.def_property_readonly("conn", &C::conn, "Connectivity [nelem, nne]");
 
     cls.def(
         "assemble",
         &C::template assemble<xt::pytensor<double, 3>>,
         "Assemble from elemmat",
         py::arg("elemmat"));
 
     cls.def("Todense", &C::Todense, "Return a dense matrix (copy)");
 
     cls.def(
         "todense",
         &C::template todense<xt::pytensor<double, 2>>,
         "Dense matrix (write to ret)",
         py::arg("ret"));
 
     cls.def(
         "Dot",
         py::overload_cast<const xt::pytensor<double, 1>&>(&C::Dot, py::const_),
         "Dot product.",
         py::arg("x"));
 
     cls.def(
         "Dot",
         py::overload_cast<const xt::pytensor<double, 2>&>(&C::Dot, py::const_),
         "Dot product.",
         py::arg("x"));
 
     cls.def(
         "dot",
         py::overload_cast<const xt::pytensor<double, 1>&, xt::pytensor<double, 1>&>(
             &C::dot, py::const_),
         "Dot product (write to b).",
         py::arg("x"),
         py::arg("b"));
 
     cls.def(
         "dot",
         py::overload_cast<const xt::pytensor<double, 2>&, xt::pytensor<double, 2>&>(
             &C::dot, py::const_),
         "Dot product (write to b).",
         py::arg("x"),
         py::arg("b"));
 }
 
 template <class C, class P>
 void register_Matrix_MatrixPartitionedBase(P& cls)
 {
     cls.def_property_readonly("nnu", &C::nnu, "Number of unknown DOFs");
     cls.def_property_readonly("nnp", &C::nnp, "Number of prescribed DOFs");
     cls.def_property_readonly("iiu", &C::iiu, "Unknown DOFs");
     cls.def_property_readonly("iip", &C::iip, "Prescribed DOFs");
 
     cls.def(
         "Reaction",
         py::overload_cast<const xt::pytensor<double, 1>&, const xt::pytensor<double, 1>&>(
             &C::Reaction, py::const_),
         "Return ``b`` with correct right-hand-side",
         py::arg("x"),
         py::arg("b"));
 
     cls.def(
         "Reaction",
         py::overload_cast<const xt::pytensor<double, 2>&, const xt::pytensor<double, 2>&>(
             &C::Reaction, py::const_),
         "Return ``b`` with correct right-hand-side",
         py::arg("x"),
         py::arg("b"));
 
     cls.def(
         "reaction",
         py::overload_cast<const xt::pytensor<double, 1>&, xt::pytensor<double, 1>&>(
             &C::reaction, py::const_),
         "Update ``b`` with correct right-hand-side",
         py::arg("x"),
         py::arg("b"));
 
     cls.def(
         "reaction",
         py::overload_cast<const xt::pytensor<double, 2>&, xt::pytensor<double, 2>&>(
             &C::reaction, py::const_),
         "Update ``b`` with correct right-hand-side",
         py::arg("x"),
         py::arg("b"));
 
     cls.def(
         "Reaction_p",
         py::overload_cast<const xt::pytensor<double, 1>&, const xt::pytensor<double, 1>&>(
             &C::Reaction_p, py::const_),
         "Return ``b_p``",
         py::arg("x_u"),
         py::arg("x_p"));
 }
 
 template <class C, class P>
 void register_Matrix_MatrixPartitionedTyingsBase(P& cls)
 {
     cls.def_property_readonly("nni", &C::nnu, "Number of independent DOFs");
     cls.def_property_readonly("nnd", &C::nnp, "Number of dependent DOFs");
     cls.def_property_readonly("iii", &C::iiu, "Independent DOFs");
     cls.def_property_readonly("iid", &C::iip, "Dependent DOFs");
 }
 
 template <class C, class M, class P>
 void register_MatrixSolver_MatrixSolverBase(P& cls)
 {
     cls.def(
         "solve",
         py::overload_cast<M&, const xt::pytensor<double, 1>&, xt::pytensor<double, 1>&>(
             &C::template solve<M>),
         "Solve system.",
         py::arg("A"),
         py::arg("b"),
         py::arg("x"));
 
     cls.def(
         "solve",
         py::overload_cast<M&, const xt::pytensor<double, 2>&, xt::pytensor<double, 2>&>(
             &C::template solve<M>),
         "Solve system.",
         py::arg("A"),
         py::arg("b"),
         py::arg("x"));
 }
 
 template <class C, class M, class P>
 void register_MatrixSolver_MatrixSolverSingleBase(P& cls)
 {
     cls.def(
         "Solve",
         py::overload_cast<M&, const xt::pytensor<double, 1>&>(&C::template Solve<M>),
         "Solve system.",
         py::arg("A"),
         py::arg("b"));
 
     cls.def(
         "Solve",
         py::overload_cast<M&, const xt::pytensor<double, 2>&>(&C::template Solve<M>),
         "Solve system.",
         py::arg("A"),
         py::arg("b"));
 }
 
 template <class C, class M, class P>
 void register_MatrixSolver_MatrixSolverPartitionedBase(P& cls)
 {
     cls.def(
         "Solve",
         py::overload_cast<M&, const xt::pytensor<double, 1>&, const xt::pytensor<double, 1>&>(
             &C::template Solve<M>),
         "Solve system.",
         py::arg("A"),
         py::arg("b"),
         py::arg("x"));
 
     cls.def(
         "Solve",
         py::overload_cast<M&, const xt::pytensor<double, 2>&, const xt::pytensor<double, 2>&>(
             &C::template Solve<M>),
         "Solve system.",
         py::arg("A"),
         py::arg("b"),
         py::arg("x"));
 }
 
 void init_Matrix(py::module& m)
 {
     // ---
 
     py::class_<GooseFEM::Matrix> cls(m, "Matrix");
     register_Matrix_MatrixBase<GooseFEM::Matrix>(cls);
 
     cls.def(
         py::init<const xt::pytensor<size_t, 2>&, const xt::pytensor<size_t, 2>&>(),
         "See :cpp:class:`GooseFEM::Matrix`.",
         py::arg("conn"),
         py::arg("dofs"));
 
     cls.def_property_readonly("data", &GooseFEM::Matrix::data);
 
     cls.def("set", &GooseFEM::Matrix::set, py::arg("rows"), py::arg("cols"), py::arg("matrix"));
     cls.def("add", &GooseFEM::Matrix::add, py::arg("rows"), py::arg("cols"), py::arg("matrix"));
 
     cls.def("__repr__", [](const GooseFEM::Matrix&) { return "<GooseFEM.Matrix>"; });
 
     // ---
 
     py::class_<GooseFEM::MatrixSolver<>> slv(m, "MatrixSolver");
     register_MatrixSolver_MatrixSolverBase<GooseFEM::MatrixSolver<>, GooseFEM::Matrix>(slv);
     register_MatrixSolver_MatrixSolverSingleBase<GooseFEM::MatrixSolver<>, GooseFEM::Matrix>(slv);
 
     slv.def(py::init<>(), "See :cpp:class:`GooseFEM::MatrixSolver`.");
 
     slv.def("__repr__", [](const GooseFEM::MatrixSolver<>&) { return "<GooseFEM.MatrixSolver>"; });
 }
 
 #endif
diff --git a/python/MatrixDiagonal.hpp b/python/MatrixDiagonal.hpp
index 530a455..e19f4f7 100644
--- a/python/MatrixDiagonal.hpp
+++ b/python/MatrixDiagonal.hpp
@@ -1,68 +1,68 @@
 /**
  * @file
  * @copyright Copyright 2017. Tom de Geus. All rights reserved.
- * \license This project is released under the GNU Public License (GPLv3).
+ * @license This project is released under the GNU Public License (GPLv3).
  */
 
 #ifndef PYGOOSEFEM_MATRIXDIAGONAL_H
 #define PYGOOSEFEM_MATRIXDIAGONAL_H
 
 #include <GooseFEM/GooseFEM.h>
 #include <pybind11/pybind11.h>
 #include <xtensor-python/pyarray.hpp>
 #include <xtensor-python/pytensor.hpp>
 
 #include "Matrix.hpp"
 
 namespace py = pybind11;
 
 template <class C, class P>
 void register_Matrix_MatrixDiagonalBase(P& cls)
 {
     cls.def(
         "Solve",
         py::overload_cast<const xt::pytensor<double, 1>&>(&C::Solve),
         "Solve",
         py::arg("b"));
 
     cls.def(
         "Solve",
         py::overload_cast<const xt::pytensor<double, 2>&>(&C::Solve),
         "Solve",
         py::arg("b"));
 
     cls.def(
         "solve",
         py::overload_cast<const xt::pytensor<double, 1>&, xt::pytensor<double, 1>&>(&C::solve),
         "Solve (write to x)",
         py::arg("b"),
         py::arg("x"));
 
     cls.def(
         "solve",
         py::overload_cast<const xt::pytensor<double, 2>&, xt::pytensor<double, 2>&>(&C::solve),
         "Solve (write to x)",
         py::arg("b"),
         py::arg("x"));
 }
 
 void init_MatrixDiagonal(py::module& m)
 {
     py::class_<GooseFEM::MatrixDiagonal> cls(m, "MatrixDiagonal");
     register_Matrix_MatrixBase<GooseFEM::MatrixDiagonal>(cls);
     register_Matrix_MatrixDiagonalBase<GooseFEM::MatrixDiagonal>(cls);
 
     cls.def(
         py::init<const xt::pytensor<size_t, 2>&, const xt::pytensor<size_t, 2>&>(),
         "See :cpp:class:`GooseFEM::MatrixDiagonal`.",
         py::arg("conn"),
         py::arg("dofs"));
 
     cls.def("set", &GooseFEM::MatrixDiagonal::set, py::arg("A"));
     cls.def_property_readonly("data", &GooseFEM::MatrixDiagonal::data);
 
     cls.def(
         "__repr__", [](const GooseFEM::MatrixDiagonal&) { return "<GooseFEM.MatrixDiagonal>"; });
 }
 
 #endif
diff --git a/python/MatrixDiagonalPartitioned.hpp b/python/MatrixDiagonalPartitioned.hpp
index 48cb25f..fb74570 100644
--- a/python/MatrixDiagonalPartitioned.hpp
+++ b/python/MatrixDiagonalPartitioned.hpp
@@ -1,58 +1,58 @@
 /**
  * @file
  * @copyright Copyright 2017. Tom de Geus. All rights reserved.
- * \license This project is released under the GNU Public License (GPLv3).
+ * @license This project is released under the GNU Public License (GPLv3).
  */
 
 #include <GooseFEM/MatrixDiagonalPartitioned.h>
 #include <pybind11/pybind11.h>
 #include <xtensor-python/pyarray.hpp>
 #include <xtensor-python/pytensor.hpp>
 
 namespace py = pybind11;
 
 void init_MatrixDiagonalPartitioned(py::module& m)
 {
     py::class_<GooseFEM::MatrixDiagonalPartitioned> cls(m, "MatrixDiagonalPartitioned");
     register_Matrix_MatrixBase<GooseFEM::MatrixDiagonalPartitioned>(cls);
     register_Matrix_MatrixPartitionedBase<GooseFEM::MatrixDiagonalPartitioned>(cls);
 
     cls.def(
         py::init<
             const xt::pytensor<size_t, 2>&,
             const xt::pytensor<size_t, 2>&,
             const xt::pytensor<size_t, 1>&>(),
         "See :cpp:class:`GooseFEM::MatrixDiagonalPartitioned`.",
         py::arg("conn"),
         py::arg("dofs"),
         py::arg("iip"));
 
     cls.def("data", &GooseFEM::MatrixDiagonalPartitioned::data, "Copy to assemble diagonal matrix");
     cls.def_property_readonly("data_uu", &GooseFEM::MatrixDiagonalPartitioned::data_uu);
     cls.def_property_readonly("data_pp", &GooseFEM::MatrixDiagonalPartitioned::data_pp);
 
     cls.def(
         "Dot_u",
         py::overload_cast<const xt::pytensor<double, 1>&, const xt::pytensor<double, 1>&>(
             &GooseFEM::MatrixDiagonalPartitioned::Dot_u, py::const_),
         py::arg("x_u"),
         py::arg("x_p"));
 
     cls.def(
         "Dot_p",
         py::overload_cast<const xt::pytensor<double, 1>&, const xt::pytensor<double, 1>&>(
             &GooseFEM::MatrixDiagonalPartitioned::Dot_p, py::const_),
         py::arg("x_u"),
         py::arg("x_p"));
 
     cls.def(
         "Solve_u",
         py::overload_cast<const xt::pytensor<double, 1>&, const xt::pytensor<double, 1>&>(
             &GooseFEM::MatrixDiagonalPartitioned::Solve_u),
         py::arg("b_u"),
         py::arg("x_p"));
 
     cls.def("__repr__", [](const GooseFEM::MatrixDiagonalPartitioned&) {
         return "<GooseFEM.MatrixDiagonalPartitioned>";
     });
 }
diff --git a/python/MatrixPartitioned.hpp b/python/MatrixPartitioned.hpp
index 2d4ca41..c0bac2f 100644
--- a/python/MatrixPartitioned.hpp
+++ b/python/MatrixPartitioned.hpp
@@ -1,75 +1,75 @@
 /**
  * @file
  * @copyright Copyright 2017. Tom de Geus. All rights reserved.
- * \license This project is released under the GNU Public License (GPLv3).
+ * @license This project is released under the GNU Public License (GPLv3).
  */
 
 #include <Eigen/Eigen>
 #include <GooseFEM/MatrixPartitioned.h>
 #include <pybind11/eigen.h>
 #include <pybind11/pybind11.h>
 #include <xtensor-python/pyarray.hpp>
 #include <xtensor-python/pytensor.hpp>
 
 #include "Matrix.hpp"
 
 namespace py = pybind11;
 
 void init_MatrixPartitioned(py::module& m)
 {
     py::class_<GooseFEM::MatrixPartitioned> cls(m, "MatrixPartitioned");
     register_Matrix_MatrixBase<GooseFEM::MatrixPartitioned>(cls);
     register_Matrix_MatrixPartitionedBase<GooseFEM::MatrixPartitioned>(cls);
 
     cls.def(
         py::init<
             const xt::pytensor<size_t, 2>&,
             const xt::pytensor<size_t, 2>&,
             const xt::pytensor<size_t, 1>&>(),
         "See :cpp:class:`GooseFEM::MatrixPartitioned`.",
         py::arg("conn"),
         py::arg("dofs"),
         py::arg("iip"));
 
     cls.def_property_readonly("data_uu", &GooseFEM::MatrixPartitioned::data_uu);
     cls.def_property_readonly("data_up", &GooseFEM::MatrixPartitioned::data_up);
     cls.def_property_readonly("data_pu", &GooseFEM::MatrixPartitioned::data_pu);
     cls.def_property_readonly("data_pp", &GooseFEM::MatrixPartitioned::data_pp);
 
     cls.def("__repr__", [](const GooseFEM::MatrixPartitioned&) {
         return "<GooseFEM.MatrixPartitioned>";
     });
 
     py::class_<GooseFEM::MatrixPartitionedSolver<>> slv(m, "MatrixPartitionedSolver");
 
     register_MatrixSolver_MatrixSolverBase<
         GooseFEM::MatrixPartitionedSolver<>,
         GooseFEM::MatrixPartitioned>(slv);
 
     register_MatrixSolver_MatrixSolverPartitionedBase<
         GooseFEM::MatrixPartitionedSolver<>,
         GooseFEM::MatrixPartitioned>(slv);
 
     slv.def(py::init<>(), "See :cpp:class:`GooseFEM::MatrixPartitionedSolver`.");
 
     slv.def(
         "Solve_u",
         &GooseFEM::MatrixPartitionedSolver<>::template Solve_u<GooseFEM::MatrixPartitioned>,
         "Solve system.",
         py::arg("A"),
         py::arg("b_u"),
         py::arg("x_p"));
 
     slv.def(
         "solve_u",
         &GooseFEM::MatrixPartitionedSolver<>::template solve_u<GooseFEM::MatrixPartitioned>,
         "Solve system.",
         py::arg("A"),
         py::arg("b_u"),
         py::arg("x_p"),
         py::arg("x_u"));
 
     slv.def("__repr__", [](const GooseFEM::MatrixPartitionedSolver<>&) {
         return "<GooseFEM.MatrixPartitionedSolver>";
     });
 }
diff --git a/python/MatrixPartitionedTyings.hpp b/python/MatrixPartitionedTyings.hpp
index 821f906..b4d7d4c 100644
--- a/python/MatrixPartitionedTyings.hpp
+++ b/python/MatrixPartitionedTyings.hpp
@@ -1,93 +1,93 @@
 /**
  * @file
  * @copyright Copyright 2017. Tom de Geus. All rights reserved.
- * \license This project is released under the GNU Public License (GPLv3).
+ * @license This project is released under the GNU Public License (GPLv3).
  */
 
 #include <Eigen/Eigen>
 #include <GooseFEM/GooseFEM.h>
 #include <pybind11/eigen.h>
 #include <pybind11/pybind11.h>
 #include <xtensor-python/pyarray.hpp>
 #include <xtensor-python/pytensor.hpp>
 
 #include "Matrix.hpp"
 
 namespace py = pybind11;
 
 void init_MatrixPartitionedTyings(py::module& m)
 {
 
     py::class_<GooseFEM::MatrixPartitionedTyings> cls(m, "MatrixPartitionedTyings");
     register_Matrix_MatrixBase<GooseFEM::MatrixPartitionedTyings>(cls);
     register_Matrix_MatrixPartitionedBase<GooseFEM::MatrixPartitionedTyings>(cls);
     register_Matrix_MatrixPartitionedTyingsBase<GooseFEM::MatrixPartitionedTyings>(cls);
 
     cls.def(
         py::init<
             const xt::pytensor<size_t, 2>&,
             const xt::pytensor<size_t, 2>&,
             const Eigen::SparseMatrix<double>&,
             const Eigen::SparseMatrix<double>&>(),
         "See :cpp:class:`GooseFEM::MatrixPartitionedTyings`.",
         py::arg("conn"),
         py::arg("dofs"),
         py::arg("Cdu"),
         py::arg("Cdp"));
 
     cls.def_property_readonly("data_uu", &GooseFEM::MatrixPartitionedTyings::data_uu);
     cls.def_property_readonly("data_up", &GooseFEM::MatrixPartitionedTyings::data_up);
     cls.def_property_readonly("data_pu", &GooseFEM::MatrixPartitionedTyings::data_pu);
     cls.def_property_readonly("data_pp", &GooseFEM::MatrixPartitionedTyings::data_pp);
     cls.def_property_readonly("data_ud", &GooseFEM::MatrixPartitionedTyings::data_ud);
     cls.def_property_readonly("data_pd", &GooseFEM::MatrixPartitionedTyings::data_pd);
     cls.def_property_readonly("data_du", &GooseFEM::MatrixPartitionedTyings::data_du);
     cls.def_property_readonly("data_dp", &GooseFEM::MatrixPartitionedTyings::data_dp);
     cls.def_property_readonly("data_dd", &GooseFEM::MatrixPartitionedTyings::data_dd);
 
     cls.def("__repr__", [](const GooseFEM::MatrixPartitionedTyings&) {
         return "<GooseFEM.MatrixPartitionedTyings>";
     });
 
     py::class_<GooseFEM::MatrixPartitionedTyingsSolver<>> slv(m, "MatrixPartitionedTyingsSolver");
 
     register_MatrixSolver_MatrixSolverBase<
         GooseFEM::MatrixPartitionedTyingsSolver<>,
         GooseFEM::MatrixPartitionedTyings>(slv);
 
     register_MatrixSolver_MatrixSolverPartitionedBase<
         GooseFEM::MatrixPartitionedTyingsSolver<>,
         GooseFEM::MatrixPartitionedTyings>(slv);
 
     slv.def(py::init<>(), "See :cpp:class:`GooseFEM::MatrixPartitionedTyingsSolver`.");
 
     slv.def(
         "Solve_u",
         py::overload_cast<
             GooseFEM::MatrixPartitionedTyings&,
             const xt::pytensor<double, 1>&,
             const xt::pytensor<double, 1>&,
             const xt::pytensor<double, 1>&>(&GooseFEM::MatrixPartitionedTyingsSolver<>::Solve_u),
         py::arg("matrix"),
         py::arg("b_u"),
         py::arg("b_d"),
         py::arg("x_p"));
 
     slv.def(
         "solve_u",
         py::overload_cast<
             GooseFEM::MatrixPartitionedTyings&,
             const xt::pytensor<double, 1>&,
             const xt::pytensor<double, 1>&,
             const xt::pytensor<double, 1>&,
             xt::pytensor<double, 1>&>(&GooseFEM::MatrixPartitionedTyingsSolver<>::solve_u),
         py::arg("matrix"),
         py::arg("b_u"),
         py::arg("b_d"),
         py::arg("x_p"),
         py::arg("x_u"));
 
     slv.def("__repr__", [](const GooseFEM::MatrixPartitionedTyingsSolver<>&) {
         return "<GooseFEM.MatrixPartitionedTyingsSolver>";
     });
 }
diff --git a/python/Mesh.hpp b/python/Mesh.hpp
index 66d44ec..1761dd9 100644
--- a/python/Mesh.hpp
+++ b/python/Mesh.hpp
@@ -1,545 +1,545 @@
 /**
  * @file
  * @copyright Copyright 2017. Tom de Geus. All rights reserved.
- * \license This project is released under the GNU Public License (GPLv3).
+ * @license This project is released under the GNU Public License (GPLv3).
  */
 
 #ifndef PYGOOSEFEM_MESH_H
 #define PYGOOSEFEM_MESH_H
 
 #include <GooseFEM/Mesh.h>
 #include <pybind11/pybind11.h>
 #include <pybind11/stl.h>
 #include <xtensor-python/pyarray.hpp>
 #include <xtensor-python/pytensor.hpp>
 
 namespace py = pybind11;
 
 template <class C, class P>
 void register_Mesh_RegularBase(P& cls)
 {
     cls.def_property_readonly("nelem", &C::nelem);
     cls.def_property_readonly("nnode", &C::nnode);
     cls.def_property_readonly("nne", &C::nne);
     cls.def_property_readonly("ndim", &C::ndim);
     cls.def_property_readonly("nelx", &C::nelx);
     cls.def_property_readonly("nely", &C::nely);
     cls.def_property_readonly("h", &C::h);
     cls.def_property_readonly("elementType", &C::getElementType);
     cls.def("coor", &C::coor);
     cls.def("conn", &C::conn);
     cls.def("dofs", &C::dofs);
     cls.def("dofsPeriodic", &C::dofsPeriodic);
     cls.def("nodesPeriodic", &C::nodesPeriodic);
     cls.def("nodesOrigin", &C::nodesOrigin);
 }
 
 template <class C, class P>
 void register_Mesh_RegularBase2d(P& cls)
 {
     cls.def("nodesBottomEdge", &C::nodesBottomEdge);
     cls.def("nodesTopEdge", &C::nodesTopEdge);
     cls.def("nodesLeftEdge", &C::nodesLeftEdge);
     cls.def("nodesRightEdge", &C::nodesRightEdge);
     cls.def("nodesBottomOpenEdge", &C::nodesBottomOpenEdge);
     cls.def("nodesTopOpenEdge", &C::nodesTopOpenEdge);
     cls.def("nodesLeftOpenEdge", &C::nodesLeftOpenEdge);
     cls.def("nodesRightOpenEdge", &C::nodesRightOpenEdge);
     cls.def("nodesBottomLeftCorner", &C::nodesBottomLeftCorner);
     cls.def("nodesBottomRightCorner", &C::nodesBottomRightCorner);
     cls.def("nodesTopLeftCorner", &C::nodesTopLeftCorner);
     cls.def("nodesTopRightCorner", &C::nodesTopRightCorner);
     cls.def("nodesLeftBottomCorner", &C::nodesLeftBottomCorner);
     cls.def("nodesLeftTopCorner", &C::nodesLeftTopCorner);
     cls.def("nodesRightBottomCorner", &C::nodesRightBottomCorner);
     cls.def("nodesRightTopCorner", &C::nodesRightTopCorner);
 }
 
 template <class C, class P>
 void register_Mesh_RegularBase3d(P& cls)
 {
     cls.def("nodesFront", &C::nodesFront);
     cls.def("nodesBack", &C::nodesBack);
     cls.def("nodesLeft", &C::nodesLeft);
     cls.def("nodesRight", &C::nodesRight);
     cls.def("nodesBottom", &C::nodesBottom);
     cls.def("nodesTop", &C::nodesTop);
     cls.def("nodesFrontFace", &C::nodesFrontFace);
     cls.def("nodesBackFace", &C::nodesBackFace);
     cls.def("nodesLeftFace", &C::nodesLeftFace);
     cls.def("nodesRightFace", &C::nodesRightFace);
     cls.def("nodesBottomFace", &C::nodesBottomFace);
     cls.def("nodesTopFace", &C::nodesTopFace);
     cls.def("nodesFrontBottomEdge", &C::nodesFrontBottomEdge);
     cls.def("nodesFrontTopEdge", &C::nodesFrontTopEdge);
     cls.def("nodesFrontLeftEdge", &C::nodesFrontLeftEdge);
     cls.def("nodesFrontRightEdge", &C::nodesFrontRightEdge);
     cls.def("nodesBackBottomEdge", &C::nodesBackBottomEdge);
     cls.def("nodesBackTopEdge", &C::nodesBackTopEdge);
     cls.def("nodesBackLeftEdge", &C::nodesBackLeftEdge);
     cls.def("nodesBackRightEdge", &C::nodesBackRightEdge);
     cls.def("nodesBottomLeftEdge", &C::nodesBottomLeftEdge);
     cls.def("nodesBottomRightEdge", &C::nodesBottomRightEdge);
     cls.def("nodesTopLeftEdge", &C::nodesTopLeftEdge);
     cls.def("nodesTopRightEdge", &C::nodesTopRightEdge);
     cls.def("nodesBottomFrontEdge", &C::nodesBottomFrontEdge);
     cls.def("nodesBottomBackEdge", &C::nodesBottomBackEdge);
     cls.def("nodesTopFrontEdge", &C::nodesTopFrontEdge);
     cls.def("nodesTopBackEdge", &C::nodesTopBackEdge);
     cls.def("nodesLeftBottomEdge", &C::nodesLeftBottomEdge);
     cls.def("nodesLeftFrontEdge", &C::nodesLeftFrontEdge);
     cls.def("nodesLeftBackEdge", &C::nodesLeftBackEdge);
     cls.def("nodesLeftTopEdge", &C::nodesLeftTopEdge);
     cls.def("nodesRightBottomEdge", &C::nodesRightBottomEdge);
     cls.def("nodesRightTopEdge", &C::nodesRightTopEdge);
     cls.def("nodesRightFrontEdge", &C::nodesRightFrontEdge);
     cls.def("nodesRightBackEdge", &C::nodesRightBackEdge);
     cls.def("nodesFrontBottomOpenEdge", &C::nodesFrontBottomOpenEdge);
     cls.def("nodesFrontTopOpenEdge", &C::nodesFrontTopOpenEdge);
     cls.def("nodesFrontLeftOpenEdge", &C::nodesFrontLeftOpenEdge);
     cls.def("nodesFrontRightOpenEdge", &C::nodesFrontRightOpenEdge);
     cls.def("nodesBackBottomOpenEdge", &C::nodesBackBottomOpenEdge);
     cls.def("nodesBackTopOpenEdge", &C::nodesBackTopOpenEdge);
     cls.def("nodesBackLeftOpenEdge", &C::nodesBackLeftOpenEdge);
     cls.def("nodesBackRightOpenEdge", &C::nodesBackRightOpenEdge);
     cls.def("nodesBottomLeftOpenEdge", &C::nodesBottomLeftOpenEdge);
     cls.def("nodesBottomRightOpenEdge", &C::nodesBottomRightOpenEdge);
     cls.def("nodesTopLeftOpenEdge", &C::nodesTopLeftOpenEdge);
     cls.def("nodesTopRightOpenEdge", &C::nodesTopRightOpenEdge);
     cls.def("nodesBottomFrontOpenEdge", &C::nodesBottomFrontOpenEdge);
     cls.def("nodesBottomBackOpenEdge", &C::nodesBottomBackOpenEdge);
     cls.def("nodesTopFrontOpenEdge", &C::nodesTopFrontOpenEdge);
     cls.def("nodesTopBackOpenEdge", &C::nodesTopBackOpenEdge);
     cls.def("nodesLeftBottomOpenEdge", &C::nodesLeftBottomOpenEdge);
     cls.def("nodesLeftFrontOpenEdge", &C::nodesLeftFrontOpenEdge);
     cls.def("nodesLeftBackOpenEdge", &C::nodesLeftBackOpenEdge);
     cls.def("nodesLeftTopOpenEdge", &C::nodesLeftTopOpenEdge);
     cls.def("nodesRightBottomOpenEdge", &C::nodesRightBottomOpenEdge);
     cls.def("nodesRightTopOpenEdge", &C::nodesRightTopOpenEdge);
     cls.def("nodesRightFrontOpenEdge", &C::nodesRightFrontOpenEdge);
     cls.def("nodesRightBackOpenEdge", &C::nodesRightBackOpenEdge);
     cls.def("nodesFrontBottomLeftCorner", &C::nodesFrontBottomLeftCorner);
     cls.def("nodesFrontBottomRightCorner", &C::nodesFrontBottomRightCorner);
     cls.def("nodesFrontTopLeftCorner", &C::nodesFrontTopLeftCorner);
     cls.def("nodesFrontTopRightCorner", &C::nodesFrontTopRightCorner);
     cls.def("nodesBackBottomLeftCorner", &C::nodesBackBottomLeftCorner);
     cls.def("nodesBackBottomRightCorner", &C::nodesBackBottomRightCorner);
     cls.def("nodesBackTopLeftCorner", &C::nodesBackTopLeftCorner);
     cls.def("nodesBackTopRightCorner", &C::nodesBackTopRightCorner);
     cls.def("nodesFrontLeftBottomCorner", &C::nodesFrontLeftBottomCorner);
     cls.def("nodesBottomFrontLeftCorner", &C::nodesBottomFrontLeftCorner);
     cls.def("nodesBottomLeftFrontCorner", &C::nodesBottomLeftFrontCorner);
     cls.def("nodesLeftFrontBottomCorner", &C::nodesLeftFrontBottomCorner);
     cls.def("nodesLeftBottomFrontCorner", &C::nodesLeftBottomFrontCorner);
     cls.def("nodesFrontRightBottomCorner", &C::nodesFrontRightBottomCorner);
     cls.def("nodesBottomFrontRightCorner", &C::nodesBottomFrontRightCorner);
     cls.def("nodesBottomRightFrontCorner", &C::nodesBottomRightFrontCorner);
     cls.def("nodesRightFrontBottomCorner", &C::nodesRightFrontBottomCorner);
     cls.def("nodesRightBottomFrontCorner", &C::nodesRightBottomFrontCorner);
     cls.def("nodesFrontLeftTopCorner", &C::nodesFrontLeftTopCorner);
     cls.def("nodesTopFrontLeftCorner", &C::nodesTopFrontLeftCorner);
     cls.def("nodesTopLeftFrontCorner", &C::nodesTopLeftFrontCorner);
     cls.def("nodesLeftFrontTopCorner", &C::nodesLeftFrontTopCorner);
     cls.def("nodesLeftTopFrontCorner", &C::nodesLeftTopFrontCorner);
     cls.def("nodesFrontRightTopCorner", &C::nodesFrontRightTopCorner);
     cls.def("nodesTopFrontRightCorner", &C::nodesTopFrontRightCorner);
     cls.def("nodesTopRightFrontCorner", &C::nodesTopRightFrontCorner);
     cls.def("nodesRightFrontTopCorner", &C::nodesRightFrontTopCorner);
     cls.def("nodesRightTopFrontCorner", &C::nodesRightTopFrontCorner);
     cls.def("nodesBackLeftBottomCorner", &C::nodesBackLeftBottomCorner);
     cls.def("nodesBottomBackLeftCorner", &C::nodesBottomBackLeftCorner);
     cls.def("nodesBottomLeftBackCorner", &C::nodesBottomLeftBackCorner);
     cls.def("nodesLeftBackBottomCorner", &C::nodesLeftBackBottomCorner);
     cls.def("nodesLeftBottomBackCorner", &C::nodesLeftBottomBackCorner);
     cls.def("nodesBackRightBottomCorner", &C::nodesBackRightBottomCorner);
     cls.def("nodesBottomBackRightCorner", &C::nodesBottomBackRightCorner);
     cls.def("nodesBottomRightBackCorner", &C::nodesBottomRightBackCorner);
     cls.def("nodesRightBackBottomCorner", &C::nodesRightBackBottomCorner);
     cls.def("nodesRightBottomBackCorner", &C::nodesRightBottomBackCorner);
     cls.def("nodesBackLeftTopCorner", &C::nodesBackLeftTopCorner);
     cls.def("nodesTopBackLeftCorner", &C::nodesTopBackLeftCorner);
     cls.def("nodesTopLeftBackCorner", &C::nodesTopLeftBackCorner);
     cls.def("nodesLeftBackTopCorner", &C::nodesLeftBackTopCorner);
     cls.def("nodesLeftTopBackCorner", &C::nodesLeftTopBackCorner);
     cls.def("nodesBackRightTopCorner", &C::nodesBackRightTopCorner);
     cls.def("nodesTopBackRightCorner", &C::nodesTopBackRightCorner);
     cls.def("nodesTopRightBackCorner", &C::nodesTopRightBackCorner);
     cls.def("nodesRightBackTopCorner", &C::nodesRightBackTopCorner);
     cls.def("nodesRightTopBackCorner", &C::nodesRightTopBackCorner);
 }
 
 void init_Mesh(py::module& mod)
 {
     py::enum_<GooseFEM::Mesh::ElementType>(
         mod, "ElementType", "See :cpp:enum:`GooseFEM::Mesh::ElementType`.")
         .value("Unknown", GooseFEM::Mesh::ElementType::Unknown)
         .value("Tri3", GooseFEM::Mesh::ElementType::Tri3)
         .value("Quad4", GooseFEM::Mesh::ElementType::Quad4)
         .value("Hex8", GooseFEM::Mesh::ElementType::Hex8)
         .export_values();
 
     mod.def(
         "overlapping",
         &GooseFEM::Mesh::overlapping<xt::pytensor<double, 2>, xt::pytensor<double, 2>>,
         "See :cpp:func:`GooseFEM::Mesh::overlapping`.",
         py::arg("coor_a"),
         py::arg("coor_b"),
         py::arg("rtol") = 1e-5,
         py::arg("atol") = 1e-8);
 
     py::class_<GooseFEM::Mesh::ManualStitch>(mod, "ManualStitch")
 
         .def(
             py::init<
                 const xt::pytensor<double, 2>&,
                 const xt::pytensor<size_t, 2>&,
                 const xt::pytensor<size_t, 1>&,
                 const xt::pytensor<double, 2>&,
                 const xt::pytensor<size_t, 2>&,
                 const xt::pytensor<size_t, 1>&,
                 bool,
                 double,
                 double>(),
             "See :cpp:class:`GooseFEM::Mesh::ManualStitch`.",
             py::arg("coor_a"),
             py::arg("conn_a"),
             py::arg("overlapping_nodes_a"),
             py::arg("coor_b"),
             py::arg("conn_b"),
             py::arg("overlapping_nodes_b"),
             py::arg("check_position") = true,
             py::arg("rtol") = 1e-5,
             py::arg("atol") = 1e-8)
 
         .def_property_readonly("nmesh", &GooseFEM::Mesh::ManualStitch::nmesh)
         .def_property_readonly("nnode", &GooseFEM::Mesh::ManualStitch::nnode)
         .def_property_readonly("nelem", &GooseFEM::Mesh::ManualStitch::nelem)
         .def_property_readonly("ndim", &GooseFEM::Mesh::ManualStitch::ndim)
         .def_property_readonly("nne", &GooseFEM::Mesh::ManualStitch::nne)
         .def_property_readonly("coor", &GooseFEM::Mesh::ManualStitch::coor)
         .def_property_readonly("conn", &GooseFEM::Mesh::ManualStitch::conn)
         .def("dofs", &GooseFEM::Mesh::ManualStitch::dofs)
         .def("nodemap", py::overload_cast<>(&GooseFEM::Mesh::ManualStitch::nodemap, py::const_))
         .def("elemmap", py::overload_cast<>(&GooseFEM::Mesh::ManualStitch::elemmap, py::const_))
 
         .def(
             "nodemap",
             py::overload_cast<size_t>(&GooseFEM::Mesh::ManualStitch::nodemap, py::const_),
             py::arg("mesh_index"))
 
         .def(
             "elemmap",
             py::overload_cast<size_t>(&GooseFEM::Mesh::ManualStitch::elemmap, py::const_),
             py::arg("mesh_index"))
 
         .def(
             "nodeset",
             &GooseFEM::Mesh::ManualStitch::nodeset<xt::pytensor<size_t, 1>>,
             py::arg("set"),
             py::arg("mesh_index"))
 
         .def(
             "elemset",
             &GooseFEM::Mesh::ManualStitch::elemset<xt::pytensor<size_t, 1>>,
             py::arg("set"),
             py::arg("mesh_index"))
 
         .def("__repr__", [](const GooseFEM::Mesh::ManualStitch&) {
             return "<GooseFEM.Mesh.ManualStitch>";
         });
 
     py::class_<GooseFEM::Mesh::Stitch>(mod, "Stitch")
 
         .def(
             py::init<double, double>(),
             "See :cpp:class:`GooseFEM::Mesh::Stitch`.",
             py::arg("rtol") = 1e-5,
             py::arg("atol") = 1e-8)
 
         .def(
             "push_back",
             &GooseFEM::Mesh::Stitch::push_back<xt::pytensor<double, 2>, xt::pytensor<size_t, 2>>,
             py::arg("coor"),
             py::arg("conn"))
 
         .def_property_readonly("nmesh", &GooseFEM::Mesh::Stitch::nmesh)
         .def_property_readonly("nnode", &GooseFEM::Mesh::Stitch::nnode)
         .def_property_readonly("nelem", &GooseFEM::Mesh::Stitch::nelem)
         .def_property_readonly("ndim", &GooseFEM::Mesh::Stitch::ndim)
         .def_property_readonly("nne", &GooseFEM::Mesh::Stitch::nne)
         .def_property_readonly("coor", &GooseFEM::Mesh::Stitch::coor)
         .def_property_readonly("conn", &GooseFEM::Mesh::Stitch::conn)
         .def("dofs", &GooseFEM::Mesh::Stitch::dofs)
         .def("nodemap", py::overload_cast<>(&GooseFEM::Mesh::Stitch::nodemap, py::const_))
         .def("elemmap", py::overload_cast<>(&GooseFEM::Mesh::Stitch::elemmap, py::const_))
 
         .def(
             "nodemap",
             py::overload_cast<size_t>(&GooseFEM::Mesh::Stitch::nodemap, py::const_),
             py::arg("mesh_index"))
 
         .def(
             "elemmap",
             py::overload_cast<size_t>(&GooseFEM::Mesh::Stitch::elemmap, py::const_),
             py::arg("mesh_index"))
 
         .def(
             "nodeset",
             static_cast<xt::pytensor<size_t, 1> (GooseFEM::Mesh::Stitch::*)(
                 const xt::pytensor<size_t, 1>&, size_t) const>(&GooseFEM::Mesh::Stitch::nodeset),
             py::arg("set"),
             py::arg("mesh_index"))
 
         .def(
             "elemset",
             static_cast<xt::pytensor<size_t, 1> (GooseFEM::Mesh::Stitch::*)(
                 const xt::pytensor<size_t, 1>&, size_t) const>(&GooseFEM::Mesh::Stitch::elemset),
             py::arg("set"),
             py::arg("mesh_index"))
 
         .def(
             "nodeset",
             static_cast<xt::pytensor<size_t, 1> (GooseFEM::Mesh::Stitch::*)(
                 const std::vector<xt::pytensor<size_t, 1>>&) const>(
                 &GooseFEM::Mesh::Stitch::nodeset),
             py::arg("set"))
 
         .def(
             "elemset",
             static_cast<xt::pytensor<size_t, 1> (GooseFEM::Mesh::Stitch::*)(
                 const std::vector<xt::pytensor<size_t, 1>>&) const>(
                 &GooseFEM::Mesh::Stitch::elemset),
             py::arg("set"))
 
         .def("__repr__", [](const GooseFEM::Mesh::Stitch&) { return "<GooseFEM.Mesh.Stitch>"; });
 
     py::class_<GooseFEM::Mesh::Vstack, GooseFEM::Mesh::Stitch>(mod, "Vstack")
 
         .def(
             py::init<bool, double, double>(),
             "See :cpp:class:`GooseFEM::Mesh::Vstack`.",
             py::arg("check_overlap") = true,
             py::arg("rtol") = 1e-5,
             py::arg("atol") = 1e-8)
 
         .def(
             "push_back",
             &GooseFEM::Mesh::Vstack::push_back<
                 xt::pytensor<double, 2>,
                 xt::pytensor<size_t, 2>,
                 xt::pytensor<size_t, 1>>,
             py::arg("coor"),
             py::arg("conn"),
             py::arg("nodes_bottom"),
             py::arg("nodes_top"))
 
         .def("__repr__", [](const GooseFEM::Mesh::Vstack&) { return "<GooseFEM.Mesh.Vstack>"; });
 
     py::class_<GooseFEM::Mesh::Renumber>(mod, "Renumber")
 
         .def(
             py::init<const xt::pyarray<size_t>&>(),
             "See :cpp:class:`GooseFEM::Mesh::Renumber`.",
             py::arg("dofs"))
 
         .def("apply", &GooseFEM::Mesh::Renumber::apply<xt::pyarray<size_t>>)
         .def_property_readonly("index", &GooseFEM::Mesh::Renumber::index)
 
         .def(
             "__repr__", [](const GooseFEM::Mesh::Renumber&) { return "<GooseFEM.Mesh.Renumber>"; });
 
     py::class_<GooseFEM::Mesh::Reorder>(mod, "Reorder")
 
         .def(
             py::init([](xt::pytensor<size_t, 1>& a) { return new GooseFEM::Mesh::Reorder({a}); }),
             "See :cpp:class:`GooseFEM::Mesh::Reorder`.")
 
         .def(
             py::init([](xt::pytensor<size_t, 1>& a, xt::pytensor<size_t, 1>& b) {
                 return new GooseFEM::Mesh::Reorder({a, b});
             }),
             "See :cpp:class:`GooseFEM::Mesh::Reorder`.")
 
         .def(
             py::init([](xt::pytensor<size_t, 1>& a,
                         xt::pytensor<size_t, 1>& b,
                         xt::pytensor<size_t, 1>& c) {
                 return new GooseFEM::Mesh::Reorder({a, b, c});
             }),
             "See :cpp:class:`GooseFEM::Mesh::Reorder`.")
 
         .def(
             py::init([](xt::pytensor<size_t, 1>& a,
                         xt::pytensor<size_t, 1>& b,
                         xt::pytensor<size_t, 1>& c,
                         xt::pytensor<size_t, 1>& d) {
                 return new GooseFEM::Mesh::Reorder({a, b, c, d});
             }),
             "See :cpp:class:`GooseFEM::Mesh::Reorder`.")
 
         .def("apply", &GooseFEM::Mesh::Reorder::apply<xt::pyarray<size_t>>)
         .def_property_readonly("index", &GooseFEM::Mesh::Reorder::index)
 
         .def("__repr__", [](const GooseFEM::Mesh::Reorder&) { return "<GooseFEM.Mesh.Reorder>"; });
 
     mod.def(
         "dofs",
         &GooseFEM::Mesh::dofs,
         "See :cpp:func:`GooseFEM::Mesh::dofs`.",
         py::arg("nnode"),
         py::arg("ndim"));
 
     mod.def(
         "nodaltyings",
         &GooseFEM::Mesh::nodaltyings<xt::pytensor<size_t, 2>>,
         "See :cpp:func:`GooseFEM::Mesh::nodaltyings`.",
         py::arg("dofs"));
 
     mod.def(
         "renumber",
         &GooseFEM::Mesh::renumber<xt::pytensor<size_t, 2>>,
         "See :cpp:func:`GooseFEM::Mesh::renumber`.",
         py::arg("dofs"));
 
     mod.def(
         "coordination",
         &GooseFEM::Mesh::coordination<xt::pytensor<size_t, 2>>,
         "See :cpp:func:`GooseFEM::Mesh::coordination`.",
         py::arg("conn"));
 
     mod.def(
         "node2dof",
         &GooseFEM::Mesh::node2dof<xt::pytensor<size_t, 2>>,
         "See :cpp:func:`GooseFEM::Mesh::node2dof`.",
         py::arg("dofs"),
         py::arg("sorted") = true);
 
     mod.def(
         "elem2node",
         py::overload_cast<const xt::pytensor<size_t, 2>&, bool>(
             &GooseFEM::Mesh::elem2node<xt::pytensor<size_t, 2>>),
         "See :cpp:func:`GooseFEM::Mesh::elem2node`.",
         py::arg("conn"),
         py::arg("sorted") = true);
 
     mod.def(
         "elem2node",
         py::overload_cast<const xt::pytensor<size_t, 2>&, const xt::pytensor<size_t, 2>&, bool>(
             &GooseFEM::Mesh::elem2node<xt::pytensor<size_t, 2>, xt::pytensor<size_t, 2>>),
         "See :cpp:func:`GooseFEM::Mesh::elem2node`.",
         py::arg("conn"),
         py::arg("dofs"),
         py::arg("sorted") = true);
 
     mod.def(
         "edgesize",
         py::overload_cast<const xt::pytensor<double, 2>&, const xt::pytensor<size_t, 2>&>(
             &GooseFEM::Mesh::edgesize<xt::pytensor<double, 2>, xt::pytensor<size_t, 2>>),
         "See :cpp:func:`GooseFEM::Mesh::edgesize`.",
         py::arg("coor"),
         py::arg("conn"));
 
     mod.def(
         "edgesize",
         py::overload_cast<
             const xt::pytensor<double, 2>&,
             const xt::pytensor<size_t, 2>&,
             GooseFEM::Mesh::ElementType>(
             &GooseFEM::Mesh::edgesize<xt::pytensor<double, 2>, xt::pytensor<size_t, 2>>),
         "See :cpp:func:`GooseFEM::Mesh::edgesize`.",
         py::arg("coor"),
         py::arg("conn"),
         py::arg("type"));
 
     mod.def(
         "centers",
         py::overload_cast<const xt::pytensor<double, 2>&, const xt::pytensor<size_t, 2>&>(
             &GooseFEM::Mesh::centers<xt::pytensor<double, 2>, xt::pytensor<size_t, 2>>),
         "See :cpp:func:`GooseFEM::Mesh::centers`.",
         py::arg("coor"),
         py::arg("conn"));
 
     mod.def(
         "centers",
         py::overload_cast<
             const xt::pytensor<double, 2>&,
             const xt::pytensor<size_t, 2>&,
             GooseFEM::Mesh::ElementType>(
             &GooseFEM::Mesh::centers<xt::pytensor<double, 2>, xt::pytensor<size_t, 2>>),
         "See :cpp:func:`GooseFEM::Mesh::centers`.",
         py::arg("coor"),
         py::arg("conn"),
         py::arg("type"));
 
     mod.def(
         "elemmap2nodemap",
         py::overload_cast<
             const xt::pytensor<size_t, 1>&,
             const xt::pytensor<double, 2>&,
             const xt::pytensor<size_t, 2>&>(&GooseFEM::Mesh::elemmap2nodemap<
                                             xt::pytensor<size_t, 1>,
                                             xt::pytensor<double, 2>,
                                             xt::pytensor<size_t, 2>>),
         "See :cpp:func:`GooseFEM::Mesh::elemmap2nodemap`.",
         py::arg("elem_map"),
         py::arg("coor"),
         py::arg("conn"));
 
     mod.def(
         "elemmap2nodemap",
         py::overload_cast<
             const xt::pytensor<size_t, 1>&,
             const xt::pytensor<double, 2>&,
             const xt::pytensor<size_t, 2>&,
             GooseFEM::Mesh::ElementType>(&GooseFEM::Mesh::elemmap2nodemap<
                                          xt::pytensor<size_t, 1>,
                                          xt::pytensor<double, 2>,
                                          xt::pytensor<size_t, 2>>),
         "See :cpp:func:`GooseFEM::Mesh::elemmap2nodemap`.",
         py::arg("elem_map"),
         py::arg("coor"),
         py::arg("conn"),
         py::arg("type"));
 
     mod.def(
         "nodal_mass",
         py::overload_cast<const xt::pytensor<double, 2>&, const xt::pytensor<size_t, 2>&>(
             &GooseFEM::Mesh::nodal_mass<xt::pytensor<double, 2>, xt::pytensor<size_t, 2>>),
         "See :cpp:func:`GooseFEM::Mesh::nodal_mass`.",
         py::arg("coor"),
         py::arg("conn"));
 
     mod.def(
         "nodal_mass",
         py::overload_cast<
             const xt::pytensor<double, 2>&,
             const xt::pytensor<size_t, 2>&,
             GooseFEM::Mesh::ElementType>(
             &GooseFEM::Mesh::nodal_mass<xt::pytensor<double, 2>, xt::pytensor<size_t, 2>>),
         "See :cpp:func:`GooseFEM::Mesh::nodal_mass`.",
         py::arg("coor"),
         py::arg("conn"),
         py::arg("type"));
 
     mod.def(
         "center_of_gravity",
         py::overload_cast<const xt::pytensor<double, 2>&, const xt::pytensor<size_t, 2>&>(
             &GooseFEM::Mesh::center_of_gravity<xt::pytensor<double, 2>, xt::pytensor<size_t, 2>>),
         "See :cpp:func:`GooseFEM::Mesh::center_of_gravity`.",
         py::arg("coor"),
         py::arg("conn"));
 
     mod.def(
         "center_of_gravity",
         py::overload_cast<
             const xt::pytensor<double, 2>&,
             const xt::pytensor<size_t, 2>&,
             GooseFEM::Mesh::ElementType>(
             &GooseFEM::Mesh::center_of_gravity<xt::pytensor<double, 2>, xt::pytensor<size_t, 2>>),
         "See :cpp:func:`GooseFEM::Mesh::center_of_gravity`.",
         py::arg("coor"),
         py::arg("conn"),
         py::arg("type"));
 }
 
 #endif
diff --git a/python/MeshHex8.hpp b/python/MeshHex8.hpp
index 6c59545..2d7566e 100644
--- a/python/MeshHex8.hpp
+++ b/python/MeshHex8.hpp
@@ -1,61 +1,61 @@
 /**
  * @file
  * @copyright Copyright 2017. Tom de Geus. All rights reserved.
- * \license This project is released under the GNU Public License (GPLv3).
+ * @license This project is released under the GNU Public License (GPLv3).
  */
 
 #ifndef PYGOOSEFEM_MESHHEX8_H
 #define PYGOOSEFEM_MESHHEX8_H
 
 #include <GooseFEM/MeshHex8.h>
 #include <pybind11/pybind11.h>
 #include <pybind11/stl.h>
 #include <xtensor-python/pyarray.hpp>
 #include <xtensor-python/pytensor.hpp>
 
 #include "Mesh.hpp"
 
 namespace py = pybind11;
 
 void init_MeshHex8(py::module& mod)
 {
     {
         py::class_<GooseFEM::Mesh::Hex8::Regular> cls(mod, "Regular");
 
         cls.def(
             py::init<size_t, size_t, size_t, double>(),
             "See :cpp:class:`GooseFEM::Mesh::Hex8::Regular`.",
             py::arg("nx"),
             py::arg("ny"),
             py::arg("nz"),
             py::arg("h") = 1.);
 
         register_Mesh_RegularBase<GooseFEM::Mesh::Hex8::Regular>(cls);
         register_Mesh_RegularBase3d<GooseFEM::Mesh::Hex8::Regular>(cls);
 
         cls.def("__repr__", [](const GooseFEM::Mesh::Hex8::Regular&) {
             return "<GooseFEM.Mesh.Hex8.Regular>";
         });
     }
 
     {
         py::class_<GooseFEM::Mesh::Hex8::FineLayer> cls(mod, "FineLayer");
 
         cls.def(
             py::init<size_t, size_t, size_t, double, size_t>(),
             "See :cpp:class:`GooseFEM::Mesh::Hex8::FineLayer`.",
             py::arg("nx"),
             py::arg("ny"),
             py::arg("nz"),
             py::arg("h") = 1.0,
             py::arg("nfine") = 1);
 
         cls.def("elementsMiddleLayer", &GooseFEM::Mesh::Hex8::FineLayer::elementsMiddleLayer);
 
         cls.def("__repr__", [](const GooseFEM::Mesh::Hex8::FineLayer&) {
             return "<GooseFEM.Mesh.Hex8.FineLayer>";
         });
     }
 }
 
 #endif
diff --git a/python/MeshQuad4.hpp b/python/MeshQuad4.hpp
index 2f9d041..c5831e4 100644
--- a/python/MeshQuad4.hpp
+++ b/python/MeshQuad4.hpp
@@ -1,234 +1,234 @@
 /**
  * @file
  * @copyright Copyright 2017. Tom de Geus. All rights reserved.
- * \license This project is released under the GNU Public License (GPLv3).
+ * @license This project is released under the GNU Public License (GPLv3).
  */
 
 #ifndef PYGOOSEFEM_MESHQUAD4_H
 #define PYGOOSEFEM_MESHQUAD4_H
 
 #include <GooseFEM/MeshQuad4.h>
 #include <pybind11/pybind11.h>
 #include <pybind11/stl.h>
 #include <xtensor-python/pyarray.hpp>
 #include <xtensor-python/pytensor.hpp>
 
 #include "Mesh.hpp"
 
 namespace py = pybind11;
 
 void init_MeshQuad4(py::module& m)
 {
     {
         py::class_<GooseFEM::Mesh::Quad4::Regular> cls(m, "Regular");
 
         cls.def(
             py::init<size_t, size_t, double>(),
             "See :cpp:class:`GooseFEM::Mesh::Quad4::Regular`.",
             py::arg("nx"),
             py::arg("ny"),
             py::arg("h") = 1.0);
 
         register_Mesh_RegularBase<GooseFEM::Mesh::Quad4::Regular>(cls);
         register_Mesh_RegularBase2d<GooseFEM::Mesh::Quad4::Regular>(cls);
 
         cls.def("elementgrid", &GooseFEM::Mesh::Quad4::Regular::elementgrid);
 
         cls.def("__repr__", [](const GooseFEM::Mesh::Quad4::Regular&) {
             return "<GooseFEM.Mesh.Quad4.Regular>";
         });
     }
 
     {
         py::class_<GooseFEM::Mesh::Quad4::FineLayer> cls(m, "FineLayer");
 
         cls.def(
             py::init<size_t, size_t, double, size_t>(),
             "See :cpp:class:`GooseFEM::Mesh::Quad4::FineLayer`.",
             py::arg("nx"),
             py::arg("ny"),
             py::arg("h") = 1.,
             py::arg("nfine") = 1);
 
         cls.def(
             py::init<const xt::pytensor<double, 2>&, const xt::pytensor<size_t, 2>&>(),
             "See :cpp:class:`GooseFEM::Mesh::Quad4::FineLayer`.",
             py::arg("coor"),
             py::arg("conn"));
 
         register_Mesh_RegularBase<GooseFEM::Mesh::Quad4::FineLayer>(cls);
         register_Mesh_RegularBase2d<GooseFEM::Mesh::Quad4::FineLayer>(cls);
 
         cls.def_property_readonly("elemrow_nhx", &GooseFEM::Mesh::Quad4::FineLayer::elemrow_nhx);
         cls.def_property_readonly("elemrow_nhy", &GooseFEM::Mesh::Quad4::FineLayer::elemrow_nhy);
         cls.def_property_readonly("elemrow_type", &GooseFEM::Mesh::Quad4::FineLayer::elemrow_type);
         cls.def_property_readonly(
             "elemrow_nelem", &GooseFEM::Mesh::Quad4::FineLayer::elemrow_nelem);
 
         cls.def("elementsMiddleLayer", &GooseFEM::Mesh::Quad4::FineLayer::elementsMiddleLayer);
 
         cls.def(
             "elementsLayer", &GooseFEM::Mesh::Quad4::FineLayer::elementsLayer, py::arg("layer"));
 
         cls.def(
             "elementgrid_ravel",
             &GooseFEM::Mesh::Quad4::FineLayer::elementgrid_ravel,
             py::arg("rows_range"),
             py::arg("cols_range"));
 
         cls.def(
             "elementgrid_around_ravel",
             &GooseFEM::Mesh::Quad4::FineLayer::elementgrid_around_ravel,
             py::arg("element"),
             py::arg("size"),
             py::arg("periodic") = true);
 
         cls.def(
             "elementgrid_leftright",
             &GooseFEM::Mesh::Quad4::FineLayer::elementgrid_leftright,
             py::arg("element"),
             py::arg("left"),
             py::arg("right"),
             py::arg("periodic") = true);
 
         cls.def("roll", &GooseFEM::Mesh::Quad4::FineLayer::roll);
 
         cls.def("__repr__", [](const GooseFEM::Mesh::Quad4::FineLayer&) {
             return "<GooseFEM.Mesh.Quad4.FineLayer>";
         });
     }
 }
 
 void init_MeshQuad4Map(py::module& m)
 {
 
     py::class_<GooseFEM::Mesh::Quad4::Map::RefineRegular>(m, "RefineRegular")
 
         .def(
             py::init<const GooseFEM::Mesh::Quad4::Regular&, size_t, size_t>(),
             "See :cpp:class:`GooseFEM::Mesh::Quad4::Map::RefineRegular`.",
             py::arg("mesh"),
             py::arg("nx"),
             py::arg("ny"))
 
         .def_property_readonly("coarseMesh", &GooseFEM::Mesh::Quad4::Map::RefineRegular::coarseMesh)
 
         .def_property_readonly("fineMesh", &GooseFEM::Mesh::Quad4::Map::RefineRegular::fineMesh)
         .def_property_readonly("map", &GooseFEM::Mesh::Quad4::Map::RefineRegular::map)
 
         .def(
             "meanToCoarse",
             py::overload_cast<const xt::pytensor<double, 1>&>(
                 &GooseFEM::Mesh::Quad4::Map::RefineRegular::meanToCoarse<double, 1>, py::const_))
 
         .def(
             "meanToCoarse",
             py::overload_cast<const xt::pytensor<double, 2>&>(
                 &GooseFEM::Mesh::Quad4::Map::RefineRegular::meanToCoarse<double, 2>, py::const_))
 
         .def(
             "meanToCoarse",
             py::overload_cast<const xt::pytensor<double, 3>&>(
                 &GooseFEM::Mesh::Quad4::Map::RefineRegular::meanToCoarse<double, 3>, py::const_))
 
         .def(
             "meanToCoarse",
             py::overload_cast<const xt::pytensor<double, 4>&>(
                 &GooseFEM::Mesh::Quad4::Map::RefineRegular::meanToCoarse<double, 4>, py::const_))
 
         .def(
             "averageToCoarse",
             py::overload_cast<const xt::pytensor<double, 1>&, const xt::pytensor<double, 1>&>(
                 &GooseFEM::Mesh::Quad4::Map::RefineRegular::averageToCoarse<double, 1, double>,
                 py::const_))
 
         .def(
             "averageToCoarse",
             py::overload_cast<const xt::pytensor<double, 2>&, const xt::pytensor<double, 2>&>(
                 &GooseFEM::Mesh::Quad4::Map::RefineRegular::averageToCoarse<double, 2, double>,
                 py::const_))
 
         .def(
             "averageToCoarse",
             py::overload_cast<const xt::pytensor<double, 3>&, const xt::pytensor<double, 3>&>(
                 &GooseFEM::Mesh::Quad4::Map::RefineRegular::averageToCoarse<double, 3, double>,
                 py::const_))
 
         .def(
             "averageToCoarse",
             py::overload_cast<const xt::pytensor<double, 4>&, const xt::pytensor<double, 4>&>(
                 &GooseFEM::Mesh::Quad4::Map::RefineRegular::averageToCoarse<double, 4, double>,
                 py::const_))
 
         .def(
             "mapToFine",
             py::overload_cast<const xt::pytensor<double, 1>&>(
                 &GooseFEM::Mesh::Quad4::Map::RefineRegular::mapToFine<double, 1>, py::const_))
 
         .def(
             "mapToFine",
             py::overload_cast<const xt::pytensor<double, 2>&>(
                 &GooseFEM::Mesh::Quad4::Map::RefineRegular::mapToFine<double, 2>, py::const_))
 
         .def(
             "mapToFine",
             py::overload_cast<const xt::pytensor<double, 3>&>(
                 &GooseFEM::Mesh::Quad4::Map::RefineRegular::mapToFine<double, 3>, py::const_))
 
         .def(
             "mapToFine",
             py::overload_cast<const xt::pytensor<double, 4>&>(
                 &GooseFEM::Mesh::Quad4::Map::RefineRegular::mapToFine<double, 4>, py::const_))
 
         .def("__repr__", [](const GooseFEM::Mesh::Quad4::Map::RefineRegular&) {
             return "<GooseFEM.Mesh.Quad4.Map.RefineRegular>";
         });
 
     py::class_<GooseFEM::Mesh::Quad4::Map::FineLayer2Regular>(m, "FineLayer2Regular")
 
         .def(
             py::init<const GooseFEM::Mesh::Quad4::FineLayer&>(),
             "See :cpp:class:`GooseFEM::Mesh::Quad4::Map::FineLayer2Regular`.",
             py::arg("mesh"))
 
         .def_property_readonly(
             "regularMesh", &GooseFEM::Mesh::Quad4::Map::FineLayer2Regular::regularMesh)
 
         .def_property_readonly(
             "fineLayerMesh", &GooseFEM::Mesh::Quad4::Map::FineLayer2Regular::fineLayerMesh)
 
         .def_property_readonly("map", &GooseFEM::Mesh::Quad4::Map::FineLayer2Regular::map)
 
         .def_property_readonly(
             "mapFraction", &GooseFEM::Mesh::Quad4::Map::FineLayer2Regular::mapFraction)
 
         .def(
             "mapToRegular",
             py::overload_cast<const xt::pytensor<double, 1>&>(
                 &GooseFEM::Mesh::Quad4::Map::FineLayer2Regular::mapToRegular<double, 1>,
                 py::const_))
 
         .def(
             "mapToRegular",
             py::overload_cast<const xt::pytensor<double, 2>&>(
                 &GooseFEM::Mesh::Quad4::Map::FineLayer2Regular::mapToRegular<double, 2>,
                 py::const_))
 
         .def(
             "mapToRegular",
             py::overload_cast<const xt::pytensor<double, 3>&>(
                 &GooseFEM::Mesh::Quad4::Map::FineLayer2Regular::mapToRegular<double, 3>,
                 py::const_))
 
         .def(
             "mapToRegular",
             py::overload_cast<const xt::pytensor<double, 4>&>(
                 &GooseFEM::Mesh::Quad4::Map::FineLayer2Regular::mapToRegular<double, 4>,
                 py::const_))
 
         .def("__repr__", [](const GooseFEM::Mesh::Quad4::Map::FineLayer2Regular&) {
             return "<GooseFEM.Mesh.Quad4.Map.FineLayer2Regular>";
         });
 }
 
 #endif
diff --git a/python/MeshTri3.hpp b/python/MeshTri3.hpp
index 57bc760..13ce541 100644
--- a/python/MeshTri3.hpp
+++ b/python/MeshTri3.hpp
@@ -1,68 +1,68 @@
 /**
  * @file
  * @copyright Copyright 2017. Tom de Geus. All rights reserved.
- * \license This project is released under the GNU Public License (GPLv3).
+ * @license This project is released under the GNU Public License (GPLv3).
  */
 
 #ifndef PYGOOSEFEM_MESHTRI3_H
 #define PYGOOSEFEM_MESHTRI3_H
 
 #include <GooseFEM/MeshTri3.h>
 #include <pybind11/pybind11.h>
 #include <pybind11/stl.h>
 #include <xtensor-python/pyarray.hpp>
 #include <xtensor-python/pytensor.hpp>
 
 #include "Mesh.hpp"
 
 namespace py = pybind11;
 
 void init_MeshTri3(py::module& mod)
 {
     py::class_<GooseFEM::Mesh::Tri3::Regular> cls(mod, "Regular");
 
     cls.def(
         py::init<size_t, size_t, double>(),
         "See :cpp:class:`GooseFEM::Mesh::Tri3::Regular`.",
         py::arg("nx"),
         py::arg("ny"),
         py::arg("h") = 1.);
 
     register_Mesh_RegularBase<GooseFEM::Mesh::Tri3::Regular>(cls);
     register_Mesh_RegularBase2d<GooseFEM::Mesh::Tri3::Regular>(cls);
 
     cls.def("__repr__", [](const GooseFEM::Mesh::Tri3::Regular&) {
         return "<GooseFEM.Mesh.Tri3.Regular>";
     });
 
     mod.def(
         "getOrientation",
         &GooseFEM::Mesh::Tri3::getOrientation,
         "See :cpp:func:`GooseFEM::Mesh::Tri3::getOrientation`.",
         py::arg("coor"),
         py::arg("conn"));
 
     mod.def(
         "setOrientation",
         py::overload_cast<const xt::pytensor<double, 2>&, const xt::pytensor<size_t, 2>&, int>(
             &GooseFEM::Mesh::Tri3::setOrientation),
         "See :cpp:func:`GooseFEM::Mesh::Tri3::setOrientation`.",
         py::arg("coor"),
         py::arg("conn"),
         py::arg("orientation"));
 
     mod.def(
         "setOrientation",
         py::overload_cast<
             const xt::pytensor<double, 2>&,
             const xt::pytensor<size_t, 2>&,
             const xt::pytensor<int, 1>&,
             int>(&GooseFEM::Mesh::Tri3::setOrientation),
         "See :cpp:func:`GooseFEM::Mesh::Tri3::setOrientation`.",
         py::arg("coor"),
         py::arg("conn"),
         py::arg("val"),
         py::arg("orientation"));
 }
 
 #endif
diff --git a/python/TyingsPeriodic.hpp b/python/TyingsPeriodic.hpp
index 04201ab..5541bce 100644
--- a/python/TyingsPeriodic.hpp
+++ b/python/TyingsPeriodic.hpp
@@ -1,89 +1,89 @@
 /**
  * @file
  * @copyright Copyright 2017. Tom de Geus. All rights reserved.
- * \license This project is released under the GNU Public License (GPLv3).
+ * @license This project is released under the GNU Public License (GPLv3).
  */
 
 #ifndef PYGOOSEFEM_TYINGSPERIODIC_H
 #define PYGOOSEFEM_TYINGSPERIODIC_H
 
 #include <GooseFEM/TyingsPeriodic.h>
 #include <pybind11/pybind11.h>
 #include <pybind11/stl.h>
 #include <xtensor-python/pyarray.hpp>
 #include <xtensor-python/pytensor.hpp>
 
 namespace py = pybind11;
 
 void init_TyingsPeriodic(py::module& mod)
 {
     {
         py::class_<GooseFEM::Tyings::Periodic> cls(mod, "Periodic");
 
         cls.def(
             py::init<
                 const xt::pytensor<double, 2>&,
                 const xt::pytensor<size_t, 2>&,
                 const xt::pytensor<size_t, 2>&,
                 const xt::pytensor<size_t, 2>&>(),
             "See :cpp:class:`GooseFEM::Tyings::Periodic`.",
             py::arg("coor"),
             py::arg("dofs"),
             py::arg("control_dofs"),
             py::arg("nodal_tyings"));
 
         cls.def(
             py::init<
                 const xt::pytensor<double, 2>&,
                 const xt::pytensor<size_t, 2>&,
                 const xt::pytensor<size_t, 2>&,
                 const xt::pytensor<size_t, 2>&,
                 const xt::pytensor<size_t, 1>&>(),
             "See :cpp:class:`GooseFEM::Tyings::Periodic`.",
             py::arg("coor"),
             py::arg("dofs"),
             py::arg("control_dofs"),
             py::arg("nodal_tyings"),
             py::arg("iip"));
 
         cls.def_property_readonly("nnd", &GooseFEM::Tyings::Periodic::nnd);
         cls.def_property_readonly("nni", &GooseFEM::Tyings::Periodic::nni);
         cls.def_property_readonly("nnu", &GooseFEM::Tyings::Periodic::nnu);
         cls.def_property_readonly("nnp", &GooseFEM::Tyings::Periodic::nnp);
         cls.def_property_readonly("dofs", &GooseFEM::Tyings::Periodic::dofs);
         cls.def_property_readonly("control", &GooseFEM::Tyings::Periodic::control);
         cls.def_property_readonly("nodal_tyings", &GooseFEM::Tyings::Periodic::nodal_tyings);
         cls.def("iid", &GooseFEM::Tyings::Periodic::iid);
         cls.def("iii", &GooseFEM::Tyings::Periodic::iii);
         cls.def("iiu", &GooseFEM::Tyings::Periodic::iiu);
         cls.def("iip", &GooseFEM::Tyings::Periodic::iip);
         cls.def("Cdi", &GooseFEM::Tyings::Periodic::Cdi);
         cls.def("Cdu", &GooseFEM::Tyings::Periodic::Cdu);
         cls.def("Cdp", &GooseFEM::Tyings::Periodic::Cdp);
 
         cls.def("__repr__", [](const GooseFEM::Tyings::Periodic&) {
             return "<GooseFEM.Tyings.Periodic>";
         });
     }
 
     {
         py::class_<GooseFEM::Tyings::Control> cls(mod, "Control");
 
         cls.def(
             py::init<const xt::pytensor<double, 2>&, const xt::pytensor<size_t, 2>&>(),
             "See :cpp:class:`GooseFEM::Tyings::Control`.",
             py::arg("coor"),
             py::arg("dofs"));
 
         cls.def_property_readonly("coor", &GooseFEM::Tyings::Control::coor);
         cls.def_property_readonly("dofs", &GooseFEM::Tyings::Control::dofs);
         cls.def_property_readonly("controlDofs", &GooseFEM::Tyings::Control::controlDofs);
         cls.def_property_readonly("controlNodes", &GooseFEM::Tyings::Control::controlNodes);
 
         cls.def("__repr__", [](const GooseFEM::Tyings::Control&) {
             return "<GooseFEM.Tyings.Control>";
         });
     }
 }
 
 #endif
diff --git a/python/Vector.hpp b/python/Vector.hpp
index 89e00b8..02b0fe2 100644
--- a/python/Vector.hpp
+++ b/python/Vector.hpp
@@ -1,121 +1,121 @@
 /**
  * @file
  * @copyright Copyright 2017. Tom de Geus. All rights reserved.
- * \license This project is released under the GNU Public License (GPLv3).
+ * @license This project is released under the GNU Public License (GPLv3).
  */
 
 #include <GooseFEM/Vector.h>
 #include <pybind11/pybind11.h>
 #include <xtensor-python/pyarray.hpp>
 #include <xtensor-python/pytensor.hpp>
 
 namespace py = pybind11;
 
 void init_Vector(py::module& m)
 {
 
     py::class_<GooseFEM::Vector>(m, "Vector")
 
         .def(
             py::init<const xt::pytensor<size_t, 2>&, const xt::pytensor<size_t, 2>&>(),
             "See :cpp:class:`GooseFEM::Vector`.",
             py::arg("conn"),
             py::arg("dofs"))
 
         .def_property_readonly("nelem", &GooseFEM::Vector::nelem)
         .def_property_readonly("nne", &GooseFEM::Vector::nne)
         .def_property_readonly("nnode", &GooseFEM::Vector::nnode)
         .def_property_readonly("ndim", &GooseFEM::Vector::ndim)
         .def_property_readonly("ndof", &GooseFEM::Vector::ndof)
         .def_property_readonly("conn", &GooseFEM::Vector::conn)
         .def_property_readonly("dofs", &GooseFEM::Vector::dofs)
 
         .def(
             "copy",
             &GooseFEM::Vector::copy<xt::pyarray<double>>,
             py::arg("nodevec_src"),
             py::arg("nodevec_dest"))
 
         .def(
             "Copy",
             &GooseFEM::Vector::Copy<xt::pyarray<double>>,
             py::arg("nodevec_src"),
             py::arg("nodevec_dest"))
 
         .def("AsDofs", &GooseFEM::Vector::AsDofs<xt::pyarray<double>>, py::arg("arg"))
 
         .def(
             "asDofs",
             &GooseFEM::Vector::asDofs<xt::pyarray<double>, xt::pytensor<double, 1>>,
             py::arg("arg"),
             py::arg("ret"))
 
         .def("AsNode", &GooseFEM::Vector::AsNode<xt::pyarray<double>>, py::arg("arg"))
 
         .def(
             "asNode",
             &GooseFEM::Vector::asNode<xt::pyarray<double>, xt::pytensor<double, 2>>,
             py::arg("arg"),
             py::arg("ret"))
 
         .def("AsElement", &GooseFEM::Vector::AsElement<xt::pyarray<double>>, py::arg("arg"))
 
         .def(
             "asElement",
             &GooseFEM::Vector::asElement<xt::pyarray<double>, xt::pytensor<double, 3>>,
             py::arg("arg"),
             py::arg("ret"))
 
         .def("AssembleDofs", &GooseFEM::Vector::AssembleDofs<xt::pyarray<double>>, py::arg("arg"))
 
         .def(
             "assembleDofs",
             &GooseFEM::Vector::assembleDofs<xt::pyarray<double>, xt::pytensor<double, 1>>,
             py::arg("arg"),
             py::arg("ret"))
 
         .def("AssembleNode", &GooseFEM::Vector::AssembleNode<xt::pyarray<double>>, py::arg("arg"))
 
         .def(
             "assembleNode",
             &GooseFEM::Vector::assembleNode<xt::pyarray<double>, xt::pytensor<double, 2>>,
             py::arg("arg"),
             py::arg("ret"))
 
         .def("shape_dofval", &GooseFEM::Vector::shape_dofval)
         .def("shape_nodevec", &GooseFEM::Vector::shape_nodevec)
         .def("shape_elemvec", &GooseFEM::Vector::shape_elemvec)
         .def("shape_elemmat", &GooseFEM::Vector::shape_elemmat)
 
         .def("allocate_dofval", py::overload_cast<>(&GooseFEM::Vector::allocate_dofval, py::const_))
 
         .def(
             "allocate_dofval",
             py::overload_cast<double>(&GooseFEM::Vector::allocate_dofval, py::const_))
 
         .def(
             "allocate_nodevec",
             py::overload_cast<>(&GooseFEM::Vector::allocate_nodevec, py::const_))
 
         .def(
             "allocate_nodevec",
             py::overload_cast<double>(&GooseFEM::Vector::allocate_nodevec, py::const_))
 
         .def(
             "allocate_elemvec",
             py::overload_cast<>(&GooseFEM::Vector::allocate_elemvec, py::const_))
 
         .def(
             "allocate_elemvec",
             py::overload_cast<double>(&GooseFEM::Vector::allocate_elemvec, py::const_))
 
         .def(
             "allocate_elemmat",
             py::overload_cast<>(&GooseFEM::Vector::allocate_elemmat, py::const_))
 
         .def(
             "allocate_elemmat",
             py::overload_cast<double>(&GooseFEM::Vector::allocate_elemmat, py::const_))
 
         .def("__repr__", [](const GooseFEM::Vector&) { return "<GooseFEM.Vector>"; });
 }
diff --git a/python/VectorPartitioned.hpp b/python/VectorPartitioned.hpp
index d7b7324..a0161b8 100644
--- a/python/VectorPartitioned.hpp
+++ b/python/VectorPartitioned.hpp
@@ -1,105 +1,105 @@
 /**
  * @file
  * @copyright Copyright 2017. Tom de Geus. All rights reserved.
- * \license This project is released under the GNU Public License (GPLv3).
+ * @license This project is released under the GNU Public License (GPLv3).
  */
 
 #include <GooseFEM/GooseFEM.h>
 #include <pybind11/pybind11.h>
 #include <xtensor-python/pyarray.hpp>
 #include <xtensor-python/pytensor.hpp>
 
 namespace py = pybind11;
 
 void init_VectorPartitioned(py::module& m)
 {
 
     py::class_<GooseFEM::VectorPartitioned, GooseFEM::Vector>(m, "VectorPartitioned")
 
         .def(
             py::init<
                 const xt::pytensor<size_t, 2>&,
                 const xt::pytensor<size_t, 2>&,
                 const xt::pytensor<size_t, 1>&>(),
             "See :cpp:class:`GooseFEM::VectorPartitioned`.",
             py::arg("conn"),
             py::arg("dofs"),
             py::arg("iip"))
 
         .def_property_readonly("nnu", &GooseFEM::VectorPartitioned::nnu)
         .def_property_readonly("nnp", &GooseFEM::VectorPartitioned::nnp)
         .def_property_readonly("iiu", &GooseFEM::VectorPartitioned::iiu)
         .def_property_readonly("iip", &GooseFEM::VectorPartitioned::iip)
         .def("dofs_is_u", &GooseFEM::VectorPartitioned::dofs_is_u)
         .def("dofs_is_p", &GooseFEM::VectorPartitioned::dofs_is_p)
 
         .def(
             "DofsFromParitioned",
             py::overload_cast<const xt::pytensor<double, 1>&, const xt::pytensor<double, 1>&>(
                 &GooseFEM::VectorPartitioned::DofsFromParitioned, py::const_),
             py::arg("dofval_u"),
             py::arg("dofval_p"))
 
         .def(
             "AsDofs_u",
             py::overload_cast<const xt::pytensor<double, 2>&>(
                 &GooseFEM::VectorPartitioned::AsDofs_u, py::const_),
             py::arg("nodevec"))
 
         .def(
             "AsDofs_u",
             py::overload_cast<const xt::pytensor<double, 3>&>(
                 &GooseFEM::VectorPartitioned::AsDofs_u, py::const_),
             py::arg("elemvec"))
 
         .def(
             "AsDofs_p",
             py::overload_cast<const xt::pytensor<double, 2>&>(
                 &GooseFEM::VectorPartitioned::AsDofs_p, py::const_),
             py::arg("nodevec"))
 
         .def(
             "AsDofs_p",
             py::overload_cast<const xt::pytensor<double, 3>&>(
                 &GooseFEM::VectorPartitioned::AsDofs_p, py::const_),
             py::arg("elemvec"))
 
         .def(
             "NodeFromPartitioned",
             py::overload_cast<const xt::pytensor<double, 1>&, const xt::pytensor<double, 1>&>(
                 &GooseFEM::VectorPartitioned::NodeFromPartitioned, py::const_),
             py::arg("dofval_u"),
             py::arg("dofval_p"))
 
         .def(
             "ElementFromPartitioned",
             py::overload_cast<const xt::pytensor<double, 1>&, const xt::pytensor<double, 1>&>(
                 &GooseFEM::VectorPartitioned::ElementFromPartitioned, py::const_),
             py::arg("dofval_u"),
             py::arg("dofval_p"))
 
         .def(
             "Copy_u",
             &GooseFEM::VectorPartitioned::Copy_u,
             py::arg("nodevec_src"),
             py::arg("nodevec_dest"))
         .def(
             "Copy_p",
             &GooseFEM::VectorPartitioned::Copy_p,
             py::arg("nodevec_src"),
             py::arg("nodevec_dest"))
         .def(
             "copy_u",
             &GooseFEM::VectorPartitioned::copy_u,
             py::arg("nodevec_src"),
             py::arg("nodevec_dest"))
         .def(
             "copy_p",
             &GooseFEM::VectorPartitioned::copy_p,
             py::arg("nodevec_src"),
             py::arg("nodevec_dest"))
 
         .def("__repr__", [](const GooseFEM::VectorPartitioned&) {
             return "<GooseFEM.VectorPartitioned>";
         });
 }
diff --git a/python/VectorPartitionedTyings.hpp b/python/VectorPartitionedTyings.hpp
index 13d5369..06763e8 100644
--- a/python/VectorPartitionedTyings.hpp
+++ b/python/VectorPartitionedTyings.hpp
@@ -1,64 +1,64 @@
 /**
  * @file
  * @copyright Copyright 2017. Tom de Geus. All rights reserved.
- * \license This project is released under the GNU Public License (GPLv3).
+ * @license This project is released under the GNU Public License (GPLv3).
  */
 
 #include <GooseFEM/GooseFEM.h>
 #include <pybind11/pybind11.h>
 #include <xtensor-python/pyarray.hpp>
 #include <xtensor-python/pytensor.hpp>
 
 namespace py = pybind11;
 
 void init_VectorPartitionedTyings(py::module& m)
 {
 
     py::class_<GooseFEM::VectorPartitionedTyings, GooseFEM::Vector>(m, "VectorPartitionedTyings")
 
         .def(
             py::init<
                 const xt::pytensor<size_t, 2>&,
                 const xt::pytensor<size_t, 2>&,
                 const Eigen::SparseMatrix<double>&,
                 const Eigen::SparseMatrix<double>&,
                 const Eigen::SparseMatrix<double>&>(),
             "See :cpp:class:`GooseFEM::VectorPartitionedTyings`.",
             py::arg("conn"),
             py::arg("dofs"),
             py::arg("Cdu"),
             py::arg("Cdp"),
             py::arg("Cdi"))
 
         .def_property_readonly("nnu", &GooseFEM::VectorPartitionedTyings::nnu)
         .def_property_readonly("nnp", &GooseFEM::VectorPartitionedTyings::nnp)
         .def_property_readonly("nni", &GooseFEM::VectorPartitionedTyings::nni)
         .def_property_readonly("nnd", &GooseFEM::VectorPartitionedTyings::nnd)
         .def_property_readonly("iiu", &GooseFEM::VectorPartitionedTyings::iiu)
         .def_property_readonly("iip", &GooseFEM::VectorPartitionedTyings::iip)
         .def_property_readonly("iii", &GooseFEM::VectorPartitionedTyings::iii)
         .def_property_readonly("iid", &GooseFEM::VectorPartitionedTyings::iid)
 
         .def(
             "copy_p",
             &GooseFEM::VectorPartitionedTyings::copy_p<xt::pytensor<double, 1>>,
             py::arg("dofval_src"),
             py::arg("dofval_dest"))
 
         .def(
             "asDofs_i",
             &GooseFEM::VectorPartitionedTyings::
                 asDofs_i<xt::pytensor<double, 2>, xt::pytensor<double, 1>>,
             py::arg("nodevec"),
             py::arg("dofval_i"),
             py::arg("apply_tyings") = true)
 
         .def(
             "AsDofs_i",
             &GooseFEM::VectorPartitionedTyings::AsDofs_i<xt::pytensor<double, 2>>,
             py::arg("nodevec"))
 
         .def("__repr__", [](const GooseFEM::VectorPartitionedTyings&) {
             return "<GooseFEM.VectorPartitionedTyings>";
         });
 }
diff --git a/python/assertions.hpp b/python/assertions.hpp
index e52f2bd..7f65cee 100644
--- a/python/assertions.hpp
+++ b/python/assertions.hpp
@@ -1,20 +1,20 @@
 /**
  * @file
  * @copyright Copyright 2017. Tom de Geus. All rights reserved.
- * \license This project is released under the GNU Public License (GPLv3).
+ * @license This project is released under the GNU Public License (GPLv3).
  */
 
 #include <GooseFEM/assertions.h>
 #include <pybind11/pybind11.h>
 #include <xtensor-python/pyarray.hpp>
 
 namespace py = pybind11;
 
 void init_assertions(py::module& mod)
 {
     mod.def(
         "is_unique",
         &GooseFEM::is_unique<xt::pyarray<long>>,
         "See :cpp:func:`GooseFEM::is_unique`.",
         py::arg("a"));
 }
diff --git a/python/version.hpp b/python/version.hpp
index a289798..010d89c 100644
--- a/python/version.hpp
+++ b/python/version.hpp
@@ -1,21 +1,21 @@
 /**
  * @file
  * @copyright Copyright 2017. Tom de Geus. All rights reserved.
- * \license This project is released under the GNU Public License (GPLv3).
+ * @license This project is released under the GNU Public License (GPLv3).
  */
 
 #include <GooseFEM/version.h>
 #include <pybind11/pybind11.h>
 
 namespace py = pybind11;
 
 void init_version(py::module& m)
 {
 
     m.def("version", &GooseFEM::version, "See :cpp:func:`GooseFEM::version`.");
 
     m.def(
         "version_dependencies",
         &GooseFEM::version_dependencies,
         "See :cpp:func:`GooseFEM::version_dependencies`.");
 }