diff --git a/Applications/DataExplorer/VtkVis/VtkCompositeFilter.h b/Applications/DataExplorer/VtkVis/VtkCompositeFilter.h
index 49cadaf8953e01056b3bd852714de6c0a053b08b..a6ff40976c5b71c25b66224106f60eaaccd14f37 100644
--- a/Applications/DataExplorer/VtkVis/VtkCompositeFilter.h
+++ b/Applications/DataExplorer/VtkVis/VtkCompositeFilter.h
@@ -19,7 +19,7 @@
class vtkAlgorithm;
/**
- * @brief Is used to combine several filter in one VtkVisPipelineItem. You can
+ * \brief Is used to combine several filter in one VtkVisPipelineItem. You can
* use vtk filter and custom filter. To subclass this you have to implement the
* init() function. There you combine the filters. Make sure to set the members
* _inputDataObjectType, _outputDataObjectType and _outputAlgorithm. Make also
@@ -33,10 +33,10 @@ class vtkAlgorithm;
* ...(do something here)
* _outputAlgorithm = lastFilter;
*
- * Create user properties with `ogsUserPropertyMacro` or `ogsUserVecxPropertyMacro`
- * and initialize these properties inside the constructor with
- * `this->Set[Property Name](value)`.
- * See VtkCompositeThresholdFilter for an example.
+ * Create user properties with `ogsUserPropertyMacro` or
+ * `ogsUserVecxPropertyMacro` and initialize these properties inside the
+ * constructor with `this->Set[Property Name](value)`. See
+ * VtkCompositeThresholdFilter for an example.
*/
class VtkCompositeFilter : public VtkAlgorithmProperties
{
diff --git a/Applications/FileIO/Gmsh/GmshReader.h b/Applications/FileIO/Gmsh/GmshReader.h
index 573bf083963778f20f1a9ee79f7b7d858920fde6..51dbbbb40851eb848ff63361b47b4ef2ff8c6fba 100644
--- a/Applications/FileIO/Gmsh/GmshReader.h
+++ b/Applications/FileIO/Gmsh/GmshReader.h
@@ -22,16 +22,16 @@ namespace GMSH
/**
* checks if there is a GMSH mesh file header
- * @param fname the file name of the mesh (including the path)
- * @return true, if the file seems to be a valid GMSH file, else false
+ * \param fname the file name of the mesh (including the path)
+ * \return true, if the file seems to be a valid GMSH file, else false
*/
bool isGMSHMeshFile(const std::string& fname);
/**
* reads a mesh created by GMSH - this implementation is based on the former
* function GMSH2MSH
- * @param fname the file name of the mesh (including the path)
- * @return
+ * \param fname the file name of the mesh (including the path)
+ * \return
*/
MeshLib::Mesh* readGMSHMesh(std::string const& fname);
diff --git a/Applications/FileIO/GocadIO/GocadSGridReader.cpp b/Applications/FileIO/GocadIO/GocadSGridReader.cpp
index 931855b6ff60dfa37093d15d4ecbce8c32974a3a..3a3523b310578c50a39ff95fde338437d6417be0 100644
--- a/Applications/FileIO/GocadIO/GocadSGridReader.cpp
+++ b/Applications/FileIO/GocadIO/GocadSGridReader.cpp
@@ -280,8 +280,8 @@ void GocadSGridReader::parseFileName(std::string const& line,
}
/**
- * @param line input/output
- * @param in input stream containing the face set
+ * \param line input/output
+ * \param in input stream containing the face set
*/
void GocadSGridReader::parseFaceSet(std::string& line, std::istream& in)
{
diff --git a/Documentation/Namespaces.dox b/Documentation/Namespaces.dox
index 42c9b5e8d1e8034404d481e14f319f82fbc460df..c15aad7f00f11ca64a77a2ce43ef79310af4f302 100644
--- a/Documentation/Namespaces.dox
+++ b/Documentation/Namespaces.dox
@@ -17,14 +17,14 @@ namespace AssemblerLib {
}
/**
- * @namespace BaseLib
+ * \namespace BaseLib
* Basic algorithms and helper functions provided for all other libraries.
*/
namespace BaseLib {
}
/**
- * @namespace FileIO
+ * \namespace FileIO
* Contains the interfaces for all file types that can be read and/or written using
* OpenGeoSys.
*
@@ -34,7 +34,7 @@ namespace BaseLib {
namespace FileIO {
/**
- * @namespace FileIO::GMSH
+ * \namespace FileIO::GMSH
* Sub-namespace containing all functionality needed for reading and writing GMSH files.
*
* \sa GMSHInterface
@@ -43,7 +43,7 @@ namespace FileIO {
}
/**
- * @namespace FileIO::Legacy
+ * \namespace FileIO::Legacy
* Includes the interfaces to OGS legacy file formats (OGS-5 and below).
*/
namespace Legacy {
@@ -51,13 +51,13 @@ namespace FileIO {
}
/**
- * @namespace FiniteElement
+ * \namespace FiniteElement
*/
namespace FiniteElement {
}
/**
- * @namespace GeoLib
+ * \namespace GeoLib
* Contains all functionality concerned with defining and obtaining information
* about geometric objects such as points, (poly-)lines, polygones, surfaces, etc.
* Also includes additional algorithms for modifying such data.
@@ -66,7 +66,7 @@ namespace GeoLib {
}
/**
- * @namespace MathLib
+ * \namespace MathLib
* Contains all mathematical functionality used in OpenGeoSys, from defining a vector
* or calculating a norm to integration schemes and matrix preconditioners.
*
@@ -74,14 +74,14 @@ namespace GeoLib {
*/
namespace MathLib {
/**
- * @namespace MathLib::detail
+ * \namespace MathLib::detail
*/
namespace detail {
}
}
/**
- * @namespace MeshLib
+ * \namespace MeshLib
* Contains all functionality concerned with defining and obtaining information
* about meshes and their components (nodes, elements). Also includes additional
* algorithms for generating and modifying meshes and elements.
@@ -90,7 +90,7 @@ namespace MathLib {
*/
namespace MeshLib {
/**
- * @namespace MeshLib::MeshGenerator
+ * \namespace MeshLib::MeshGenerator
* Functionality for generating meshing.
*/
namespace MeshGenerator {
@@ -98,12 +98,12 @@ namespace MeshLib {
}
/**
- * @namespace NumLib
+ * \namespace NumLib
* The numerical algorithms used in OpenGeoSys
*/
namespace NumLib {
/**
- * @namespace NumLib::detail
+ * \namespace NumLib::detail
*/
namespace detail {
}
diff --git a/GeoLib/AnalyticalGeometry.h b/GeoLib/AnalyticalGeometry.h
index 95843224648c9c5fa75e5e5fc02fd5e79b80ca83..c4f2ba6c2f0cc88a61fce8eef3af539ad866608b 100644
--- a/GeoLib/AnalyticalGeometry.h
+++ b/GeoLib/AnalyticalGeometry.h
@@ -45,13 +45,16 @@ Orientation getOrientationFast(MathLib::Point3d const& p0,
MathLib::Point3d const& p1,
MathLib::Point3d const& p2);
/**
- * compute a supporting plane (represented by plane_normal and the value d) for the polygon
- * Let \f$n\f$ be the plane normal and \f$d\f$ a parameter. Then for all points \f$p \in R^3\f$ of the plane
- * it holds \f$ n \cdot p + d = 0\f$. The Newell algorithm is described in
- * \cite Ericson:2004:RCD:1121584 .
- * @param pnts_begin Iterator pointing to the initial point of a closed polyline describing a polygon
- * @param pnts_end Iterator pointing to the element following the last point of a closed polyline describing a polygon
- * @return pair of plane_normal and the parameter d: the normal of the plane the
+ * Compute a supporting plane (represented by plane_normal and the value d) for
+ * the polygon.
+ * Let \f$n\f$ be the plane normal and \f$d\f$ a parameter. Then for all points
+ * \f$p \in R^3\f$ of the plane it holds \f$ n \cdot p + d = 0\f$.
+ * The Newell algorithm is described in \cite Ericson:2004:RCD:1121584 .
+ * \param pnts_begin Iterator pointing to the initial point of a closed polyline
+ * describing a polygon
+ * \param pnts_end Iterator pointing to the element following the last point of
+ * a closed polyline describing a polygon
+ * \return pair of plane_normal and the parameter d: the normal of the plane the
* polygon is located in, d parameter from the plane equation
*/
template <typename InputIterator>
@@ -59,12 +62,13 @@ std::pair<Eigen::Vector3d, double> getNewellPlane(InputIterator pnts_begin,
InputIterator pnts_end);
/**
- * compute a supporting plane (represented by plane_normal and the value d) for the polygon
- * Let \f$n\f$ be the plane normal and \f$d\f$ a parameter. Then for all points \f$p \in R^3\f$ of the plane
- * it holds \f$ n \cdot p + d = 0\f$. The Newell algorithm is described in
- * \cite Ericson:2004:RCD:1121584 .
- * @param pnts points of a closed polyline describing a polygon
- * @return pair of plane_normal and the parameter d: the normal of the plane the
+ * Compute a supporting plane (represented by plane_normal and the value d) for
+ * the polygon.
+ * Let \f$n\f$ be the plane normal and \f$d\f$ a parameter. Then for all points
+ * \f$p \in R^3\f$ of the plane it holds \f$ n \cdot p + d = 0\f$.
+ * The Newell algorithm is described in \cite Ericson:2004:RCD:1121584 .
+ * \param pnts points of a closed polyline describing a polygon
+ * \return pair of plane_normal and the parameter d: the normal of the plane the
* polygon is located in, parameter d from the plane equation
*/
template <class T_POINT>
@@ -80,32 +84,35 @@ std::pair<Eigen::Vector3d, double> getNewellPlane(
/**
* Computes a rotation matrix that rotates the given 2D normal vector parallel
* to X-axis
- * @param v a 2D normal vector to be rotated
- * @return a 3x3 rotation matrix where the upper, left, 2x2 block
+ * \param v a 2D normal vector to be rotated
+ * \return a 3x3 rotation matrix where the upper, left, 2x2 block
* contains the entries necessary for the 2D rotation
*/
Eigen::Matrix3d compute2DRotationMatrixToX(Eigen::Vector3d const& v);
/**
- * Computes a rotation matrix that rotates the given 3D normal vector parallel to X-axis
- * @param v a 3D normal vector to be rotated
- * @return a 3x3 rotation matrix
+ * Computes a rotation matrix that rotates the given 3D normal vector parallel
+ * to X-axis.
+ * \param v a 3D normal vector to be rotated
+ * \return a 3x3 rotation matrix
*/
Eigen::Matrix3d compute3DRotationMatrixToX(Eigen::Vector3d const& v);
/**
* Method computes the rotation matrix that rotates the given vector parallel to
* the \f$z\f$ axis.
- * @param n the (3d) vector that is rotated parallel to the \f$z\f$ axis
- * @return rot_mat 3x3 rotation matrix
+ * \param n the (3d) vector that is rotated parallel to the \f$z\f$ axis
+ * \return rot_mat 3x3 rotation matrix
*/
Eigen::Matrix3d computeRotationMatrixToXY(Eigen::Vector3d const& n);
/**
* rotate points according to the rotation matrix
- * @param rot_mat 3x3 dimensional rotation matrix
- * @param pnts_begin Iterator pointing to the initial element in a vector of points to be rotated
- * @param pnts_end Iterator pointing to the element following the last element in a vector of points to be rotated
+ * \param rot_mat 3x3 dimensional rotation matrix
+ * \param pnts_begin Iterator pointing to the initial element in a vector of
+ * points to be rotated
+ * \param pnts_end Iterator pointing to the element following the last element
+ * in a vector of points to be rotated
*/
template <typename InputIterator>
void rotatePoints(Eigen::Matrix3d const& rot_mat, InputIterator pnts_begin,
@@ -113,28 +120,33 @@ void rotatePoints(Eigen::Matrix3d const& rot_mat, InputIterator pnts_begin,
/**
* rotate points according to the rotation matrix
- * @param rot_mat 3x3 dimensional rotation matrix
- * @param pnts vector of points
+ * \param rot_mat 3x3 dimensional rotation matrix
+ * \param pnts vector of points
*/
template <typename P>
void rotatePoints(Eigen::Matrix3d const& rot_mat, std::vector<P*> const& pnts);
/**
* rotate points to X-Y plane
- * @param pnts a vector of points with a minimum length of three.
- * Points are rotated using a rotation matrix computed from the first three points
- * in the vector. Point coordinates are modified as a result of the rotation.
+ * \param pnts a vector of points with a minimum length of three.
+ * Points are rotated using a rotation matrix computed from the first three
+ * points in the vector. Point coordinates are modified as a result of the
+ * rotation.
*/
Eigen::Matrix3d rotatePointsToXY(std::vector<Point*>& pnts);
/**
* rotate points to X-Y plane
- * @param p_pnts_begin Iterator pointing to the initial element in a vector of points used for computing a rotation matrix
- * @param p_pnts_end Iterator pointing to the element following the last point in a vector of points used for computing a rotation matrix
- * @param r_pnts_begin Iterator pointing to the initial element in a vector of points to be rotated
- * @param r_pnts_end Iterator pointing to the element following the last point in a vector of points to be rotated
- * Points are rotated using a rotation matrix computed from the first three points
- * in the vector. Point coordinates are modified as a result of the rotation.
+ * \param p_pnts_begin Iterator pointing to the initial element in a vector of
+ * points used for computing a rotation matrix
+ * \param p_pnts_end Iterator pointing to the element following the last point
+ * in a vector of points used for computing a rotation matrix
+ * \param r_pnts_begin Iterator pointing to the initial element in a vector of
+ * points to be rotated
+ * \param r_pnts_end Iterator pointing to the element following the last point
+ * in a vector of points to be rotated Points are rotated using a rotation
+ * matrix computed from the first three points in the vector. Point coordinates
+ * are modified as a result of the rotation.
*/
template <typename InputIterator1, typename InputIterator2>
Eigen::Matrix3d rotatePointsToXY(InputIterator1 p_pnts_begin,
@@ -144,11 +156,13 @@ Eigen::Matrix3d rotatePointsToXY(InputIterator1 p_pnts_begin,
/**
* test for intersections of the line segments of the Polyline
- * @param ply the polyline
- * @param seg_it0 iterator pointing to the first segment that has an intersection
- * @param seg_it1 iterator pointing to the second segment that has an intersection
- * @param intersection_pnt the intersection point if the segments intersect
- * @return true, if the polyline contains intersections
+ * \param ply the polyline
+ * \param seg_it0 iterator pointing to the first segment that has an
+ * intersection
+ * \param seg_it1 iterator pointing to the second segment that has an
+ * intersection
+ * \param intersection_pnt the intersection point if the segments intersect
+ * \return true, if the polyline contains intersections
*/
bool lineSegmentsIntersect(const Polyline* ply,
Polyline::SegmentIterator& seg_it0,
@@ -157,19 +171,19 @@ bool lineSegmentsIntersect(const Polyline* ply,
/**
* Check if the two vectors \f$v, w \in R^3\f$ are in parallel
- * @param v first vector
- * @param w second vector
- * @return true if the vectors are in parallel, else false
-*/
+ * \param v first vector
+ * \param w second vector
+ * \return true if the vectors are in parallel, else false
+ */
bool parallel(Eigen::Vector3d v, Eigen::Vector3d w);
/**
* A line segment is given by its two end-points. The function checks,
* if the two line segments (ab) and (cd) intersects.
- * @param s0 the first line segment.
- * @param s1 the second line segment.
- * @param s the intersection point if the segments do intersect
- * @return true, if the line segments intersect, else false
+ * \param s0 the first line segment.
+ * \param s1 the second line segment.
+ * \param s the intersection point if the segments do intersect
+ * \return true, if the line segments intersect, else false
*/
bool lineSegmentIntersect(LineSegment const& s0, LineSegment const& s1,
Point& s);
@@ -189,7 +203,7 @@ std::vector<MathLib::Point3d> lineSegmentIntersect2d(
/**
* Calculates the intersection points of a line PQ and a triangle ABC.
* This method requires ABC to be counterclockwise and PQ to point downward.
- * @return Intersection point or nullptr if there is no intersection.
+ * \return Intersection point or nullptr if there is no intersection.
*/
std::unique_ptr<Point> triangleLineIntersection(
MathLib::Point3d const& a, MathLib::Point3d const& b,
@@ -211,8 +225,8 @@ void computeAndInsertAllIntersectionPoints(PointVec& pnt_vec,
* (getNewellPlane()) and the points are rotated, (3) for accuracy reasons the
* \f$z\f$ coordinates of the rotated points are set to zero
* \see getNewellPlane()
- * @param polygon_in a copy of the polygon_in polygon will be rotated
- * @return vector of rotated points and normal based on the original Newell
+ * \param polygon_in a copy of the polygon_in polygon will be rotated
+ * \return vector of rotated points and normal based on the original Newell
* plane
*/
std::tuple<std::vector<GeoLib::Point*>, Eigen::Vector3d>
diff --git a/GeoLib/IO/TINInterface.h b/GeoLib/IO/TINInterface.h
index 8d89fd45809767ca9d0d8ec53942c0f06cb2ce99..00351b30e93f4f797d8aff710190a42d8b165935 100644
--- a/GeoLib/IO/TINInterface.h
+++ b/GeoLib/IO/TINInterface.h
@@ -30,10 +30,11 @@ class TINInterface
public:
/**
* Reads TIN file
- * @param fname TIN file name
- * @param pnt_vec a point vector to which triangle vertices are added
- * @param errors a vector of error messages
- * @return a pointer to a GeoLib::Surface object created from TIN data. nullptr is returned if it fails to read the file.
+ * \param fname TIN file name
+ * \param pnt_vec a point vector to which triangle vertices are added
+ * \param errors a vector of error messages
+ * \return a pointer to a GeoLib::Surface object created from TIN data.
+ * nullptr is returned if it fails to read the file.
*/
static GeoLib::Surface* readTIN(std::string const& fname,
GeoLib::PointVec &pnt_vec,
@@ -41,8 +42,8 @@ public:
/**
* Writes surface data into TIN file
- * @param surface surface object
- * @param file_name TIN file name
+ * \param surface surface object
+ * \param file_name TIN file name
*/
static void writeSurfaceAsTIN(GeoLib::Surface const& surface, std::string const& file_name);
};
diff --git a/GeoLib/Polygon.cpp b/GeoLib/Polygon.cpp
index 138a798c09735fc0c288f9646e7c5c5c974ee381..583a8eb20b957f3080882310b616e718127c8610 100644
--- a/GeoLib/Polygon.cpp
+++ b/GeoLib/Polygon.cpp
@@ -48,10 +48,10 @@ enum class EdgeType
* of the point relative to the line segment specified by the points source and
* destination. (literature reference:
* Computational Geometry and Computer Graphics in C++; Michael J. Laszlo)
- * @param source the first point of the line segment
- * @param destination the end point of the line segment
- * @param pnt the test point
- * @return a value of enum Location
+ * \param source the first point of the line segment
+ * \param destination the end point of the line segment
+ * \param pnt the test point
+ * \return a value of enum Location
*/
Location getLocationOfPoint(MathLib::Point3d const& source,
MathLib::Point3d const& destination,
@@ -95,10 +95,10 @@ Location getLocationOfPoint(MathLib::Point3d const& source,
/**
* from book: Computational Geometry and Computer Graphics in C++, page 119
* get the type of edge with respect to the given point (2d method!)
- * @param a first point of line segment
- * @param b last point of line segment
- * @param pnt point that is edge type computed for
- * @return a value of enum EdgeType
+ * \param a first point of line segment
+ * \param b last point of line segment
+ * \param pnt point that is edge type computed for
+ * \return a value of enum EdgeType
*/
EdgeType getEdgeType(MathLib::Point3d const& a,
MathLib::Point3d const& b,
@@ -183,9 +183,9 @@ bool Polygon::initialise()
/**
* Computes all intersections of the straight line segment and the polyline
* boundary
- * @param polygon the polygon the segment line segment that will be processed
- * @param segment the line segment that will be processed
- * @return a possible empty vector containing the intersection points
+ * \param polygon the polygon the segment line segment that will be processed
+ * \param segment the line segment that will be processed
+ * \return a possible empty vector containing the intersection points
*/
std::vector<GeoLib::Point> getAllIntersectionPoints(
Polygon const& polygon, GeoLib::LineSegment const& segment)
diff --git a/GeoLib/Polygon.h b/GeoLib/Polygon.h
index 3c52fa5fd4f3b4bc3b30e40175a66bb3ae444d81..950adbf4b97312e269c94d5523c5bdf063780605 100644
--- a/GeoLib/Polygon.h
+++ b/GeoLib/Polygon.h
@@ -36,8 +36,8 @@ public:
/**
* constructor checks if the given polyline is closed,
* and assures that the orientation is clock wise.
- * @param ply closed Polyline
- * @param init if true, check if polyline is closed, calculate bounding box
+ * \param ply closed Polyline
+ * \param init if true, check if polyline is closed, calculate bounding box
*/
explicit Polygon(const Polyline& ply, bool init = true);
@@ -51,39 +51,43 @@ public:
/**
* Method checks if the given point is inside the polygon.
* The method requires that the polygon has clock wise orientation.
- * @param pnt the Point
- * @return if point is inside the polygon true, else false
+ * \param pnt the Point
+ * \return if point is inside the polygon true, else false
*/
bool isPntInPolygon(MathLib::Point3d const& pnt) const;
/**
* Checks if the straight line segment is contained within the polygon.
- * @param segment the straight line segment that is checked with
- * @return true if the straight line segment is within the polygon, else false
+ * \param segment the straight line segment that is checked with
+ * \return true if the straight line segment is within the polygon, else
+ * false
*/
bool containsSegment(GeoLib::LineSegment const& segment) const;
/**
- * Method checks if all points of the polyline ply are inside of the polygon.
- * @param ply the polyline that should be checked
+ * Method checks if all points of the polyline ply are inside of the
+ * polygon.
+ * \param ply the polyline that should be checked
*/
bool isPolylineInPolygon (const Polyline& ply) const;
/**
- * Method checks first if at least one (end!) point of a line segment of the polyline
- * is inside of the polygon. If this test fails each line segment of the polyline will
- * be tested against each polygon segment for intersection.
- * @param ply the polyline that should be checked
- * @return true if a part of the polyline is within the polygon
+ * Method checks first if at least one (end!) point of a line segment of the
+ * polyline is inside of the polygon. If this test fails each line segment
+ * of the polyline will be tested against each polygon segment for
+ * intersection.
+ * \param ply the polyline that should be checked
+ * \return true if a part of the polyline is within the polygon
*/
bool isPartOfPolylineInPolygon (const Polyline& ply) const;
/**
* Calculates the next intersection point between the line segment \c seg
* and the polygon starting with segment \c seg_num.
- * @param seg (input) Line segment to compute intersection.
- * @param intersection_pnt (output) next intersection point
- * @param seg_num (in/out) the number of the polygon segment that is intersecting
- * @return true, if there was an intersection, i.e., the \c intersection_pnt
+ * \param seg (input) Line segment to compute intersection.
+ * \param intersection_pnt (output) next intersection point
+ * \param seg_num (in/out) the number of the polygon segment that is
+ * intersecting
+ * \return true, if there was an intersection, i.e., the \c intersection_pnt
* and \c seg_num contains new valid values
*/
bool getNextIntersectionPointPolygonLine(GeoLib::LineSegment const& seg,
@@ -108,9 +112,9 @@ private:
/**
* comparison operator for polygons
- * @param lhs the first polygon
- * @param rhs the second polygon
- * @return true, if the polygons describe the same geometrical object
+ * \param lhs the first polygon
+ * \param rhs the second polygon
+ * \return true, if the polygons describe the same geometrical object
*/
bool operator==(Polygon const& lhs, Polygon const& rhs);
diff --git a/GeoLib/Polyline.h b/GeoLib/Polyline.h
index 2968639857145a719772e899c87db650e2bb1f7b..214245890b867ffab88fbc0ca7b5ea5bae48c483 100644
--- a/GeoLib/Polyline.h
+++ b/GeoLib/Polyline.h
@@ -92,7 +92,7 @@ public:
explicit Polyline(const std::vector<Point*>& pnt_vec);
/**
* Copy constructor
- * @param ply Polyline
+ * \param ply Polyline
*/
Polyline(const Polyline& ply);
Polyline& operator=(Polyline const& other) = delete;
@@ -106,7 +106,7 @@ public:
* Adds an id of a point at the end of the polyline if and only if the
* resulting segment won't be empty. The id have to be inside the (internal)
* \c _ply_pnts vector the polyline is based on.
- * @return If the point could be added the return value is \c true. If the
+ * \return If the point could be added the return value is \c true. If the
* addition of the point would result in empty line segment \c false is
* returned.
*/
@@ -116,19 +116,19 @@ public:
* Method inserts a new point (that have to be inside the _ply_pnts vector)
* at the given position in the polyline if and only if the resulting
* segments won't be empty.
- * @param pos the position in the polyline, pos have to be a value into the
+ * \param pos the position in the polyline, pos have to be a value into the
* interval [0, number of points)
- * @param pnt_id the id of the new point in the vector of points the
+ * \param pnt_id the id of the new point in the vector of points the
* polyline is based on
- * @return true if the point could be inserted, else false (if empty line
+ * \return true if the point could be inserted, else false (if empty line
* segments would be created).
*/
virtual bool insertPoint(std::size_t pos, std::size_t pnt_id);
/**
- * Method removes a point from the polyline. The connecting line segments will
- * be removed and the length of the polyline will be changed.
- * @param pos a valid position within the polyline
+ * Method removes a point from the polyline. The connecting line segments
+ * will be removed and the length of the polyline will be changed.
+ * \param pos a valid position within the polyline
*/
void removePoint(std::size_t pos);
@@ -157,10 +157,10 @@ public:
bool isCoplanar() const;
/**
- * Method tests if the given id of a point (within the vector of points the polyline is
- * based on) is inside the polyline.
- * @param pnt_id the id of the point
- * @return true if the point is part of the polyline, else false
+ * Method tests if the given id of a point (within the vector of points the
+ * polyline is based on) is inside the polyline.
+ * \param pnt_id the id of the point
+ * \return true if the point is part of the polyline, else false
*/
bool isPointIDInPolyline(std::size_t pnt_id) const;
@@ -172,8 +172,8 @@ public:
/**
* Changes a point index for one point in a line
- * @param idx Index of point in line
- * @param id ID of point in PointVec object
+ * \param idx Index of point in line
+ * \param id ID of point in PointVec object
*/
void setPointID(std::size_t idx, std::size_t id);
@@ -195,11 +195,13 @@ public:
std::vector<Point*> const& getPointsVec () const;
/**
- * returns the distance along the polyline from the beginning of the polyline
- * @param pnt the point on the polyline
- * @param epsilon_radius the epsilon
- * @return the distance along the polyline between the given point and the beginning of the polyline.
- * If the given point is not on the polyine, negative value is returned.
+ * returns the distance along the polyline from the beginning of the
+ * polyline
+ * \param pnt the point on the polyline
+ * \param epsilon_radius the epsilon
+ * \return the distance along the polyline between the given point and the
+ * beginning of the polyline. If the given point is not on the
+ * polyine, negative value is returned.
*/
double getDistanceAlongPolyline(const MathLib::Point3d& pnt,
const double epsilon_radius) const;
@@ -227,9 +229,9 @@ bool containsEdge (const Polyline& ply, std::size_t id0, std::size_t id1);
/**
* comparison operator
- * @param lhs first polyline
- * @param rhs second polyline
- * @return true, if the polylines consists of the same sequence of line segments
+ * \param lhs first polyline
+ * \param rhs second polyline
+ * \return true, if the polylines consists of the same sequence of line segments
*/
bool operator==(Polyline const& lhs, Polyline const& rhs);
diff --git a/GeoLib/Raster.h b/GeoLib/Raster.h
index 1dc6b96bc95c558e4a3510f02ecf8dc4cadbdae5..50035193d7e4a285da62e6dce317b06564ab10b5 100644
--- a/GeoLib/Raster.h
+++ b/GeoLib/Raster.h
@@ -36,7 +36,7 @@ struct RasterHeader final
};
/**
- * @brief Class Raster is used for managing raster data.
+ * \brief Class Raster is used for managing raster data.
*
* A raster consists of the meta data like number of columns and rows, the
* lower left point, the size of a raster pixel and a value for invalid data
@@ -48,13 +48,13 @@ class Raster final
{
public:
/**
- * @brief Constructor for an object of class Raster. The raster data
+ * \brief Constructor for an object of class Raster. The raster data
* have to be handed over via input iterators. Deploying iterators has
* the advantage that the use of the class is independent from the input
* container.
- * @param header meta-information about the raster (height, width, etc.)
- * @param begin input iterator pointing to the first element of the data
- * @param end input iterator pointing to the last element of the data,
+ * \param header meta-information about the raster (height, width, etc.)
+ * \param begin input iterator pointing to the first element of the data
+ * \param end input iterator pointing to the last element of the data,
* end have to be reachable from begin
*/
template <typename InputIterator>
@@ -90,7 +90,7 @@ public:
/**
* Constant iterator that is pointing to the first raster pixel value.
- * @return constant iterator
+ * \return constant iterator
*/
std::vector<double>::const_iterator begin() const
{
@@ -100,7 +100,7 @@ public:
/**
* Iterator to the element following the last pixel element of the
* raster
- * @return constant iterator
+ * \return constant iterator
*/
std::vector<double>::const_iterator end() const
{
diff --git a/GeoLib/TemplateVec.h b/GeoLib/TemplateVec.h
index 841781debf794cc29bda31e4f8d3e6f3a7b9f7b4..d992719206e3f41993c2a05db9e545f8e45d51c3 100644
--- a/GeoLib/TemplateVec.h
+++ b/GeoLib/TemplateVec.h
@@ -45,13 +45,13 @@ public:
/**
* Constructor of class TemlateVec.
- * @param name unique name of the project the elements belonging to.
+ * \param name unique name of the project the elements belonging to.
* In order to access the data elements a unique name is required.
- * @param data_vec Vector of data elements.
- * @attention{TemplateVec will take the ownership of the vector
+ * \param data_vec Vector of data elements.
+ * \attention{TemplateVec will take the ownership of the vector
* and also its elements,
* i.e. delete its elements and delete the vector itself!}
- * @param elem_name_map Names of data elements can be given by a
+ * \param elem_name_map Names of data elements can be given by a
* std::map<std::string, std::size_t>. Here the std::string is the name
* of the element and the value for std::size_t stands for an index in
* the data_vec.
@@ -81,7 +81,7 @@ public:
void setName(const std::string& n) { _name = n; }
/**
* the name, the data element belonging to
- * @return the name of the object
+ * \return the name of the object
*/
std::string getName() const { return _name; }
@@ -98,21 +98,21 @@ public:
}
/**
- * @return the number of data elements
+ * \return the number of data elements
*/
std::size_t size() const { return _data_vec.size(); }
/**
* get a pointer to a standard vector containing the data elements
- * @return the data elements
+ * \return the data elements
*/
std::vector<T*> const& getVector() const { return _data_vec; }
/**
* search the vector of names for the ID of the geometric element with the
* given name
- * @param name the name of the geometric element
- * @param id the id of the geometric element
+ * \param name the name of the geometric element
+ * \param id the id of the geometric element
*/
bool getElementIDByName(const std::string& name, std::size_t& id) const
{
@@ -142,10 +142,10 @@ public:
/**
* The method returns true if there is a name associated
* with the given id, else method returns false.
- * @param id the id
- * @param element_name if a name associated with the id
+ * \param id the id
+ * \param element_name if a name associated with the id
* is found name is assigned to element_name
- * @return if there is name associated with the given id:
+ * \return if there is name associated with the given id:
* true, else false
*/
bool getNameOfElementByID(std::size_t id, std::string& element_name) const
@@ -169,10 +169,10 @@ public:
/**
* The method returns true if the given element of type T
* can be found and the element has a name, else method returns false.
- * @param data the data element, one wants to know the name
- * @param name the name of the data element (if the data element is
+ * \param data the data element, one wants to know the name
+ * \param name the name of the data element (if the data element is
* found and the data element has a name)
- * @return if element is found and has a name: true, else false
+ * \return if element is found and has a name: true, else false
*/
bool getNameOfElement(const T* data, std::string& name) const
{
diff --git a/MaterialLib/Fluid/Density/LinearConcentrationAndPressureDependentDensity.h b/MaterialLib/Fluid/Density/LinearConcentrationAndPressureDependentDensity.h
index e1453cf9bf12f6d4197a06f30dbcb569e51abd4a..694538d998925808e79211e4f3fc6e4b96ba010d 100644
--- a/MaterialLib/Fluid/Density/LinearConcentrationAndPressureDependentDensity.h
+++ b/MaterialLib/Fluid/Density/LinearConcentrationAndPressureDependentDensity.h
@@ -32,12 +32,12 @@ class LinearConcentrationAndPressureDependentDensity final
{
public:
/**
- * @param reference_density \f$\rho_0\f$
- * @param reference_concentration \f$C_0\f$
- * @param fluid_density_concentration_difference_ratio \f$ \bar \alpha \f$
+ * \param reference_density \f$\rho_0\f$
+ * \param reference_concentration \f$C_0\f$
+ * \param fluid_density_concentration_difference_ratio \f$ \bar \alpha \f$
* in reference
- * @param reference_pressure \f$p_0\f$
- * @param fluid_density_pressure_difference_ratio \f$ \bar \beta \f$ in
+ * \param reference_pressure \f$p_0\f$
+ * \param fluid_density_pressure_difference_ratio \f$ \bar \beta \f$ in
* reference Coupled groundwater flow and transport: 2. Thermohaline and 3D
* convection systems
*/
diff --git a/MaterialLib/Fluid/Density/LinearConcentrationDependentDensity.h b/MaterialLib/Fluid/Density/LinearConcentrationDependentDensity.h
index 49007caea3f11389d32df54ae6a23e7e164a803f..053a822c6439f0ba30c53a9752a4a11051d02e56 100644
--- a/MaterialLib/Fluid/Density/LinearConcentrationDependentDensity.h
+++ b/MaterialLib/Fluid/Density/LinearConcentrationDependentDensity.h
@@ -29,9 +29,9 @@ class LinearConcentrationDependentDensity final : public FluidProperty
{
public:
/**
- * @param reference_density \f$\rho_0\f$
- * @param reference_concentration \f$C_0\f$
- * @param fluid_density_difference_ratio \f$ \bar \alpha \f$ in reference
+ * \param reference_density \f$\rho_0\f$
+ * \param reference_concentration \f$C_0\f$
+ * \param fluid_density_difference_ratio \f$ \bar \alpha \f$ in reference
* Coupled groundwater flow and transport: 2. Thermohaline and 3D convection
* systems
*/
diff --git a/MaterialLib/Fluid/GibbsFreeEnergy/DimensionlessGibbsFreeEnergyRegion2.h b/MaterialLib/Fluid/GibbsFreeEnergy/DimensionlessGibbsFreeEnergyRegion2.h
index 4827948b0454b6e90a068d615b13a1313220db7c..ff8263ad9a656c3a2eca8069411999898903c078 100644
--- a/MaterialLib/Fluid/GibbsFreeEnergy/DimensionlessGibbsFreeEnergyRegion2.h
+++ b/MaterialLib/Fluid/GibbsFreeEnergy/DimensionlessGibbsFreeEnergyRegion2.h
@@ -20,8 +20,8 @@ namespace Fluid
namespace DimensionlessGibbsFreeEnergyRegion2
{
/**
- * @param pi Dimensionless temperature
- * @param tau Dimensionless pressure
+ * \param pi Dimensionless temperature
+ * \param tau Dimensionless pressure
*/
double getGamma(const double tau, const double pi);
diff --git a/MaterialLib/MPL/Utils/FormKelvinVector.h b/MaterialLib/MPL/Utils/FormKelvinVector.h
index a7db805b7fe2fbd4aa3cd542ad93e6458bfb5ee1..6a12b7f79fb1a0c15cdd2f8121015d695454252e 100644
--- a/MaterialLib/MPL/Utils/FormKelvinVector.h
+++ b/MaterialLib/MPL/Utils/FormKelvinVector.h
@@ -27,9 +27,9 @@ namespace MaterialPropertyLib
* three element vector or a 3 x 3 matrix for anisotropic properties, to
* get a Kelvin vector for strain or stress.
*
- * @param values: e.g., Thermal expansivity, which can be scalar number, a three
+ * \param values: e.g., Thermal expansivity, which can be scalar number, a three
* element vector or a 3 x 3 matrix.
- * @return Kelvin vector type property.
+ * \return Kelvin vector type property.
*/
template <int GlobalDim>
MathLib::KelvinVector::KelvinVectorType<GlobalDim> formKelvinVector(
diff --git a/MaterialLib/PorousMedium/Permeability/createPermeabilityModel.h b/MaterialLib/PorousMedium/Permeability/createPermeabilityModel.h
index bebdb42ee082e4effe6864355bd71c3a55a63088..f8cfb12c99f6169220aef2ff61d64903f562362e 100644
--- a/MaterialLib/PorousMedium/Permeability/createPermeabilityModel.h
+++ b/MaterialLib/PorousMedium/Permeability/createPermeabilityModel.h
@@ -26,10 +26,10 @@ namespace MaterialLib
namespace PorousMedium
{
/** Create a porosity model
- * @param config ConfigTree object has a tag of `<permeability>` that
+ * \param config ConfigTree object has a tag of `<permeability>` that
* describes the permeability relationsship and contains the name of the
* parameter
- * @param parameters a vector containing the available parameters
+ * \param parameters a vector containing the available parameters
*/
std::unique_ptr<Permeability> createPermeabilityModel(
BaseLib::ConfigTree const& config,
diff --git a/MathLib/GeometricBasics.h b/MathLib/GeometricBasics.h
index 8ab15c4cd6e159221ddc52406a5a3107dc1e1ed7..634b5c1a3d0ef5899b1437bebdc812418fcce571 100644
--- a/MathLib/GeometricBasics.h
+++ b/MathLib/GeometricBasics.h
@@ -25,11 +25,11 @@ enum TriangleTest
/**
* Checks if a point p is on the left or right side of a plane spanned by three
* points a, b, c.
- * @param p point to test
- * @param a first point on plane
- * @param b second point on plane
- * @param c third point on plane
- * @return If the triangle abc is ordered counterclockwise when viewed from p,
+ * \param p point to test
+ * \param a first point on plane
+ * \param b second point on plane
+ * \param c third point on plane
+ * \return If the triangle abc is ordered counterclockwise when viewed from p,
* the method will return a negative value,
* otherwise it will return a positive value. If p is coplanar with abc, the
* function will return 0.
@@ -63,14 +63,14 @@ double calcTriangleArea(MathLib::Point3d const& a, MathLib::Point3d const& b,
* coplanar) the function
* will return false because there is no meaningful concept of "inside" for such
* elements.
- * @param p test point
- * @param a edge node of tetrahedron
- * @param b edge node of tetrahedron
- * @param c edge node of tetrahedron
- * @param d edge node of tetrahedron
- * @param eps Accounts for numerical inaccuracies by allowing a point to be
+ * \param p test point
+ * \param a edge node of tetrahedron
+ * \param b edge node of tetrahedron
+ * \param c edge node of tetrahedron
+ * \param d edge node of tetrahedron
+ * \param eps Accounts for numerical inaccuracies by allowing a point to be
* slightly outside of the element and still be regarded as inside.
- * @return true if the test point p is not located outside of abcd (i.e. inside
+ * \return true if the test point p is not located outside of abcd (i.e. inside
* or on a plane/edge).
*/
bool isPointInTetrahedron(MathLib::Point3d const& p, MathLib::Point3d const& a,
@@ -83,16 +83,16 @@ bool isPointInTetrahedron(MathLib::Point3d const& p, MathLib::Point3d const& a,
* a, b and c.Using two eps-values it is possible to test an 'epsilon'
* neighbourhood around the triangle as well as an 'epsilon' outside the
* triangles plane.
- * @param p test point
- * @param a edge node of triangle
- * @param b edge node of triangle
- * @param c edge node of triangle
- * @param eps_pnt_out_of_plane eps allowing for p to be slightly off the plane
+ * \param p test point
+ * \param a edge node of triangle
+ * \param b edge node of triangle
+ * \param c edge node of triangle
+ * \param eps_pnt_out_of_plane eps allowing for p to be slightly off the plane
* spanned by abc
- * @param eps_pnt_out_of_tri eps allowing for p to be slightly off outside of
+ * \param eps_pnt_out_of_tri eps allowing for p to be slightly off outside of
* abc
- * @param algorithm defines the method to use
- * @return true if the test point p is within the 'epsilon'-neighbourhood of the
+ * \param algorithm defines the method to use
+ * \return true if the test point p is within the 'epsilon'-neighbourhood of the
* triangle
*/
bool isPointInTriangle(
@@ -110,15 +110,15 @@ bool isPointInTriangle(
* Using two eps-values it is possible to test an 'epsilon' neighbourhood around
* the triangle
* as well as an 'epsilon' outside the triangles plane.
- * @param q test point
- * @param a edge node of triangle
- * @param b edge node of triangle
- * @param c edge node of triangle
- * @param eps_pnt_out_of_plane eps allowing for p to be slightly off the plane
+ * \param q test point
+ * \param a edge node of triangle
+ * \param b edge node of triangle
+ * \param c edge node of triangle
+ * \param eps_pnt_out_of_plane eps allowing for p to be slightly off the plane
* spanned by abc ((orthogonal distance to the plane spaned by triangle)
- * @param eps_pnt_out_of_tri eps allowing for p to be slightly off outside of
+ * \param eps_pnt_out_of_tri eps allowing for p to be slightly off outside of
* abc
- * @return true if the test point p is within the 'epsilon'-neighbourhood of the
+ * \return true if the test point p is within the 'epsilon'-neighbourhood of the
* triangle
*/
bool gaussPointInTriangle(
@@ -134,15 +134,15 @@ bool gaussPointInTriangle(
* the triangle
* as well as an 'epsilon' outside the triangles plane.
* Algorithm based on "Fundamentals of Computer Graphics" by Peter Shirley.
- * @param p test point
- * @param a edge node of triangle
- * @param b edge node of triangle
- * @param c edge node of triangle
- * @param eps_pnt_out_of_plane eps allowing for p to be slightly off the plane
+ * \param p test point
+ * \param a edge node of triangle
+ * \param b edge node of triangle
+ * \param c edge node of triangle
+ * \param eps_pnt_out_of_plane eps allowing for p to be slightly off the plane
* spanned by abc
- * @param eps_pnt_out_of_tri eps allowing for p to be slightly off outside of
+ * \param eps_pnt_out_of_tri eps allowing for p to be slightly off outside of
* abc
- * @return true if the test point p is within the 'epsilon'-neighbourhood of the
+ * \return true if the test point p is within the 'epsilon'-neighbourhood of the
* triangle
*/
bool barycentricPointInTriangle(
@@ -162,11 +162,11 @@ MathLib::Point3d const& b, MathLib::Point3d const& c);
* Checks if a and b can be placed on a plane such that c and d lie on different
* sides of said plane. (In 2D space this checks if c and d are on different
* sides of a line through a and b.)
- * @param a first point on plane
- * @param b second point on plane
- * @param c first point to test
- * @param d second point to test
- * @return true, if such a plane can be found, false otherwise
+ * \param a first point on plane
+ * \param b second point on plane
+ * \param c first point to test
+ * \param d second point to test
+ * \return true, if such a plane can be found, false otherwise
*/
bool dividedByPlane(const MathLib::Point3d& a, const MathLib::Point3d& b,
const MathLib::Point3d& c, const MathLib::Point3d& d);
diff --git a/MathLib/InterpolationAlgorithms/LinearIntervalInterpolation.h b/MathLib/InterpolationAlgorithms/LinearIntervalInterpolation.h
index e678337195dca73d40b515726b7d18ad8110f05a..0e0351d4111a81b4c142b9ff8a9f856cc65f1e90 100644
--- a/MathLib/InterpolationAlgorithms/LinearIntervalInterpolation.h
+++ b/MathLib/InterpolationAlgorithms/LinearIntervalInterpolation.h
@@ -19,12 +19,12 @@
namespace MathLib {
/**
- * @brief Class (template) LinearIntervalInterpolation is a functional object performing
- * an interval mapping \f$f: [a,b] \to [c,d]\f$.
+ * \brief Class (template) LinearIntervalInterpolation is a functional object
+ * performing an interval mapping \f$f: [a,b] \to [c,d]\f$.
*
- * Input numeric type has to be a floating point type and must behave well under the
- * operations addition, subtraction, multiplication and division. Let \f$a, b, c, d\f$
- * objects supporting the mentioned operations. Under the condition
+ * Input numeric type has to be a floating point type and must behave well under
+ * the operations addition, subtraction, multiplication and division. Let \f$a,
+ * b, c, d\f$ objects supporting the mentioned operations. Under the condition
* \f$a \neq b\f$ an instance of the class computes a value within the interval
* \f$[c, d]\f$, i.e., \f$f: [a,b] \to [c,d]\f$.
*/
@@ -35,16 +35,17 @@ public:
* Constructor of class template for a linear map \f$y = m \cdot x + n\f$.
* Under the prerequisite \f$a \neq b\f$ it initializes the coefficients
* \f$m\f$ and \f$n\f$ in a correct way.
- * @param a first endpoint of the first interval
- * @param b second endpoint of the first interval
- * @param c first endpoint of the second interval
- * @param d second endpoint of the second interval
+ * \param a first endpoint of the first interval
+ * \param b second endpoint of the first interval
+ * \param c first endpoint of the second interval
+ * \param d second endpoint of the second interval
*/
LinearIntervalInterpolation(NUMERIC_TYPE a, NUMERIC_TYPE b, NUMERIC_TYPE c, NUMERIC_TYPE d);
/**
- * Method computes the value at point \f$x\f$ obtained by linear interpolation.
- * @param x the point the interpolation value is searched for
- * @return the interpolation value at point \f$x\f$
+ * Method computes the value at point \f$x\f$ obtained by linear
+ * interpolation.
+ * \param x the point the interpolation value is searched for
+ * \return the interpolation value at point \f$x\f$
*/
inline NUMERIC_TYPE operator() (NUMERIC_TYPE x) const;
diff --git a/MathLib/LinAlg/Eigen/EigenTools.h b/MathLib/LinAlg/Eigen/EigenTools.h
index 917d4c63e2b75f10d0d381a105dc9c7322d9eb20..552add71ca238eb43a63dd01f489ead7face9bae 100644
--- a/MathLib/LinAlg/Eigen/EigenTools.h
+++ b/MathLib/LinAlg/Eigen/EigenTools.h
@@ -22,10 +22,10 @@ class EigenVector;
/**
* apply known solutions to a system of linear equations
*
- * @param A Coefficient matrix
- * @param b RHS vector
- * @param vec_knownX_id a vector of known solution entry IDs
- * @param vec_knownX_x a vector of known solutions
+ * \param A Coefficient matrix
+ * \param b RHS vector
+ * \param vec_knownX_id a vector of known solution entry IDs
+ * \param vec_knownX_x a vector of known solutions
*/
void applyKnownSolution(
EigenMatrix& A, EigenVector& b, EigenVector& /*x*/,
diff --git a/MathLib/LinAlg/Lis/LisCheck.h b/MathLib/LinAlg/Lis/LisCheck.h
index 595ea52b5314197808968f616d0c7d85843ed101..150bbc1e6fd8eebc124bec88ab21f7ae532e724a 100644
--- a/MathLib/LinAlg/Lis/LisCheck.h
+++ b/MathLib/LinAlg/Lis/LisCheck.h
@@ -26,8 +26,8 @@ namespace MathLib
/**
* check Lis error codes
*
- * @param err Lis error code
- * @return success or not
+ * \param err Lis error code
+ * \return success or not
*/
inline bool checkLisError(int err)
{
diff --git a/MathLib/MathTools.h b/MathLib/MathTools.h
index 2906713cc724b71288953ee0042e1c90e13b4d26..0dfafc86da3e5b1fc5231b5994f9c8a3be24981f 100644
--- a/MathLib/MathTools.h
+++ b/MathLib/MathTools.h
@@ -37,10 +37,10 @@ double calcProjPntToLineAndDists(MathLib::Point3d const& pp,
/**
* Let \f$p_0, p_1, p_2 \in R^3\f$. The function getAngle
* computes the angle between the edges \f$(p_0,p_1)\f$ and \f$(p_1,p_2)\f$
- * @param p0 start point of edge 0
- * @param p1 end point of edge 0 and start point of edge 1
- * @param p2 end point of edge 1
- * @return the angle between the edges
+ * \param p0 start point of edge 0
+ * \param p1 end point of edge 0 and start point of edge 1
+ * \param p2 end point of edge 1
+ * \return the angle between the edges
*/
double getAngle(Point3d const& p0, Point3d const& p1, Point3d const& p2);
} // namespace MathLib
diff --git a/MathLib/Point3d.h b/MathLib/Point3d.h
index ebb16bf37fd6fa590c1f1f061c42f2e0df9e94e0..a3ac832c38d58bb86d15947589e7ba19a2bb6b45 100644
--- a/MathLib/Point3d.h
+++ b/MathLib/Point3d.h
@@ -31,7 +31,7 @@ public:
/** constructor - constructs a Point3d object
*
- * @param x std::array containing the coordinates of the point
+ * \param x std::array containing the coordinates of the point
*/
explicit Point3d(std::array<double, 3> x);
@@ -80,11 +80,11 @@ inline bool operator<(Point3d const& a, Point3d const& b)
/**
* Lexicographic comparison of points taking an epsilon into account.
*
- * @param a first input point.
- * @param b second input point.
- * @param eps tolerance used in comparison of coordinates.
+ * \param a first input point.
+ * \param b second input point.
+ * \param eps tolerance used in comparison of coordinates.
*
- * @return true, if a is smaller then or equal to b according to the following
+ * \return true, if a is smaller then or equal to b according to the following
* test \f$ |a_i - b_i| > \epsilon \cdot \min (|a_i|, |b_i|) \f$ \b and
* \f$ |a_i - b_i| > \epsilon \f$ for all coordinates \f$ 0 \le i < 3 \f$.
*/
@@ -101,9 +101,9 @@ inline std::ostream& operator<<(std::ostream& os, const Point3d& p)
extern MATHLIB_EXPORT const Point3d ORIGIN;
/**
* rotation of points
- * @param mat a rotation matrix
- * @param p a point to be transformed
- * @return a rotated point
+ * \param mat a rotation matrix
+ * \param p a point to be transformed
+ * \return a rotated point
*/
MathLib::Point3d operator*(Eigen::Matrix3d const& mat,
MathLib::Point3d const& p);
diff --git a/MeshGeoToolsLib/AppendLinesAlongPolyline.h b/MeshGeoToolsLib/AppendLinesAlongPolyline.h
index 3c1c1c693ee721b057dbea31a927217455508a01..2616689519f09880e33f54816c70f3f8210f74a4 100644
--- a/MeshGeoToolsLib/AppendLinesAlongPolyline.h
+++ b/MeshGeoToolsLib/AppendLinesAlongPolyline.h
@@ -29,15 +29,16 @@ namespace MeshGeoToolsLib
/**
* Add line elements to a copy of a given mesh
*
- * The function creates line elements from nodes located along user-provided polylines.
- * New elements will have a distinct material ID for each polyline.
+ * The function creates line elements from nodes located along user-provided
+ * polylines. New elements will have a distinct material ID for each polyline.
*
* \remark The function allows creation of duplicated line elements.
* \remark Line elements may not be placed along edges of existing elements.
*
- * @param mesh original mesh
- * @param ply_vec polyline vector whose nodes are used to create line elements
- * @return a new mesh which is copied from a given mesh and additionally includes line elements
+ * \param mesh original mesh
+ * \param ply_vec polyline vector whose nodes are used to create line elements
+ * \return a new mesh which is copied from a given mesh and additionally
+ * includes line elements
*/
std::unique_ptr<MeshLib::Mesh> appendLinesAlongPolylines(
const MeshLib::Mesh& mesh, const GeoLib::PolylineVec& ply_vec);
diff --git a/MeshLib/Elements/Element.h b/MeshLib/Elements/Element.h
index 7d05ee95fabd28a75121e51b4cff4a1e93b682ea..cf651bba3738bc4c8ea78ea80254b976a3913a41 100644
--- a/MeshLib/Elements/Element.h
+++ b/MeshLib/Elements/Element.h
@@ -49,19 +49,19 @@ public:
/**
* Get node with local index where the local index should be at most the
* number of nodes of the element.
- * @param idx local index of node, at most the number of nodes of the
+ * \param idx local index of node, at most the number of nodes of the
* element that you can obtain with Element::getNumberOfBaseNodes()
- * @return a pointer to the appropriate (and constant, i.e. not
+ * \return a pointer to the appropriate (and constant, i.e. not
* modifiable by the user) instance of class Node or a nullptr
- * @sa getNodeIndex()
+ * \sa getNodeIndex()
*/
virtual const Node* getNode(unsigned idx) const = 0;
virtual Node* getNode(unsigned idx) = 0;
/**
* (Re)Sets the node of the element.
- * @param idx the index of the pointer to a node within the element
- * @param node a pointer to a node
+ * \param idx the index of the pointer to a node within the element
+ * \param node a pointer to a node
*/
virtual void setNode(unsigned idx, Node* node) = 0;
@@ -119,7 +119,7 @@ public:
/**
* Get the type of the element in context of the finite element method.
- * @return a value of the enum FEMElemType::type
+ * \return a value of the enum FEMElemType::type
*/
virtual CellType getCellType() const = 0;
@@ -132,10 +132,10 @@ public:
/**
* Checks if a point is inside the element.
- * @param pnt a 3D MathLib::Point3d object
- * @param eps tolerance for numerical algorithm used or computing the
+ * \param pnt a 3D MathLib::Point3d object
+ * \param eps tolerance for numerical algorithm used or computing the
* property
- * @return true if the point is not outside the element, false otherwise
+ * \return true if the point is not outside the element, false otherwise
*/
virtual bool isPntInElement(
MathLib::Point3d const& pnt,
@@ -153,7 +153,7 @@ public:
* Method clone is a pure virtual method in the abstract base class Element.
* It has to be implemented in the derived classes (for instance in class
* Hex).
- * @return an exact copy of the object
+ * \return an exact copy of the object
*/
virtual Element* clone() const = 0;
@@ -237,13 +237,13 @@ unsigned getNodeIDinElement(Element const& element, const Node* node);
/**
* Get the global node index of the node with the local index idx within the
* element. The index should be at most the number of nodes of the element.
- * @param element The element object that will be searched for the index.
- * @param idx Local index of Node, at most the number of nodes of the
+ * \param element The element object that will be searched for the index.
+ * \param idx Local index of Node, at most the number of nodes of the
* element that you can obtain with Element::getNumberOfBaseNodes().
- * @return the global index if idx < Element::getNumberOfBaseNodes. Otherwise in
+ * \return the global index if idx < Element::getNumberOfBaseNodes. Otherwise in
* debug mode the value std::numeric_limits<unsigned>::max(). In release mode
* the behaviour is undefined.
- * @sa Element::getNode()
+ * \sa Element::getNode()
*/
std::size_t getNodeIndex(Element const& element, unsigned idx);
diff --git a/MeshLib/Elements/HexRule20.h b/MeshLib/Elements/HexRule20.h
index 7b4a6cbd91eec14156090496d22a3a2eada52352..19bb18bacb9a68a9950825d30a2a88f3e3d21362 100644
--- a/MeshLib/Elements/HexRule20.h
+++ b/MeshLib/Elements/HexRule20.h
@@ -20,7 +20,7 @@ namespace MeshLib
/**
* A 20-nodes Hexahedron Element.
- * @code
+ * \code
*
* Hex:
* 14
@@ -41,7 +41,7 @@ namespace MeshLib
* 0-----------1
* 8
*
- * @endcode
+ * \endcode
*/
class HexRule20 : public HexRule8
{
diff --git a/MeshLib/Elements/HexRule8.h b/MeshLib/Elements/HexRule8.h
index 2192763903ba1a0282da66ab512e3a2de69cf7e0..d1501fbfb493bf721591370fe0f4d1f579f783c7 100644
--- a/MeshLib/Elements/HexRule8.h
+++ b/MeshLib/Elements/HexRule8.h
@@ -20,7 +20,7 @@ namespace MeshLib
/**
* A 8-nodes Hexahedron Element.
- * @code
+ * \code
*
* Hex:
* 6
@@ -41,7 +41,7 @@ namespace MeshLib
* 0-----------1
* 0
*
- * @endcode
+ * \endcode
*/
class HexRule8 : public CellRule
{
@@ -81,7 +81,7 @@ public:
/**
* \copydoc MeshLib::Element::isPntInElement()
- * @param nodes the nodes of the element.
+ * \param nodes the nodes of the element.
*/
static bool isPntInElement(Node const* const* nodes,
MathLib::Point3d const& pnt, double eps);
diff --git a/MeshLib/Elements/LineRule2.h b/MeshLib/Elements/LineRule2.h
index bc57d0ac186af68b85fe2bbb4a56285a1e8e20d0..538eb078eeff6daa6afc285b1d1eb810cd4ddbc3 100644
--- a/MeshLib/Elements/LineRule2.h
+++ b/MeshLib/Elements/LineRule2.h
@@ -20,9 +20,9 @@ namespace MeshLib
/**
* A 1d Edge or Line Element.
- * @code
+ * \code
* 0--------1
- * @endcode
+ * \endcode
*/
class LineRule2 : public EdgeRule
{
@@ -50,7 +50,7 @@ public:
/**
* \copydoc MeshLib::Element::isPntInElement()
- * @param nodes the nodes of the element.
+ * \param nodes the nodes of the element.
*/
static bool isPntInElement(Node const* const* nodes,
MathLib::Point3d const& pnt, double eps);
diff --git a/MeshLib/Elements/LineRule3.h b/MeshLib/Elements/LineRule3.h
index bde5a38125e1ed824ad2ae66e56fd73528d196c7..6b4d2259141a68ce563b4b0af0f61e3e0aff2a64 100644
--- a/MeshLib/Elements/LineRule3.h
+++ b/MeshLib/Elements/LineRule3.h
@@ -18,9 +18,9 @@ namespace MeshLib
/**
* A 1d Edge or Line element with 3 nodes.
- * @code
+ * \code
* 0----2----1
- * @endcode
+ * \endcode
*/
class LineRule3 : public LineRule2
{
diff --git a/MeshLib/Elements/PrismRule15.h b/MeshLib/Elements/PrismRule15.h
index 4a9d744456da1dc7e5a86fb82be6cb71bafb336f..a6ae0de9307d10cdfe1ec6af4facd351cc36646f 100644
--- a/MeshLib/Elements/PrismRule15.h
+++ b/MeshLib/Elements/PrismRule15.h
@@ -19,9 +19,10 @@ namespace MeshLib
{
/**
- * This class represents a 3d prism element with 15 nodes. The following sketch shows the node and edge numbering.
- * @anchor PrismNodeAndEdgeNumbering
- * @code
+ * This class represents a 3d prism element with 15 nodes. The following sketch
+ * shows the node and edge numbering.
+ * \anchor PrismNodeAndEdgeNumbering
+ * \code
* 5
* / \
* / : \
@@ -39,7 +40,7 @@ namespace MeshLib
* 0-----------1
* 6
*
- * @endcode
+ * \endcode
*/
class PrismRule15 : public PrismRule6
{
diff --git a/MeshLib/Elements/PrismRule6.h b/MeshLib/Elements/PrismRule6.h
index 0a23f592df6e5d1a1e59b0419e53ba08f35b1c4a..42190daed1c46756ed6c25747060cd102ab87f48 100644
--- a/MeshLib/Elements/PrismRule6.h
+++ b/MeshLib/Elements/PrismRule6.h
@@ -19,9 +19,10 @@ namespace MeshLib
{
/**
- * This class represents a 3d prism element. The following sketch shows the node and edge numbering.
- * @anchor Prism6NodeAndEdgeNumbering
- * @code
+ * This class represents a 3d prism element. The following sketch shows the node
+ * and edge numbering.
+ * \anchor Prism6NodeAndEdgeNumbering
+ * \code
* 5
* / \
* / : \
@@ -39,7 +40,7 @@ namespace MeshLib
* 0-----------1
* 0
*
- * @endcode
+ * \endcode
*/
class PrismRule6 : public CellRule
{
@@ -82,7 +83,7 @@ public:
/**
* \copydoc MeshLib::Element::isPntInElement()
- * @param nodes the nodes of the element.
+ * \param nodes the nodes of the element.
*/
static bool isPntInElement(Node const* const* nodes,
MathLib::Point3d const& pnt, double eps);
diff --git a/MeshLib/Elements/PyramidRule13.h b/MeshLib/Elements/PyramidRule13.h
index b80ad85b19f26aa4e57f4dbe1986bbfb77ea99d7..67fa809c2bdbdacdc91896bb47e8cb8d2fbf77eb 100644
--- a/MeshLib/Elements/PyramidRule13.h
+++ b/MeshLib/Elements/PyramidRule13.h
@@ -20,8 +20,8 @@ namespace MeshLib
/**
* This class represents a 3d pyramid element. The following sketch shows the
node numbering.
- * @anchor Pyramid13NodeNumbering
- * @code
+ * \anchor Pyramid13NodeNumbering
+ * \code
*
* 4
* //|\
@@ -37,7 +37,7 @@ namespace MeshLib
* ./ |/
* 0------------1
* 5
- * @endcode
+ * \endcode
*/
class PyramidRule13 : public PyramidRule5
diff --git a/MeshLib/Elements/PyramidRule5.h b/MeshLib/Elements/PyramidRule5.h
index 336444ae26bdba41952613a5a3fb381ea3b04152..d3d9720595b2c72ebe26e080e24fd0d3451a4aa8 100644
--- a/MeshLib/Elements/PyramidRule5.h
+++ b/MeshLib/Elements/PyramidRule5.h
@@ -19,9 +19,10 @@ namespace MeshLib
{
/**
- * This class represents a 3d pyramid element. The following sketch shows the node and edge numbering.
- * @anchor Pyramid5NodeAndEdgeNumbering
- * @code
+ * This class represents a 3d pyramid element. The following sketch shows the
+ node and edge numbering.
+ * \anchor Pyramid5NodeAndEdgeNumbering
+ * \code
*
* 4
* //|\
@@ -37,7 +38,7 @@ namespace MeshLib
* ./ |/
* 0------------1
* 0
- * @endcode
+ * \endcode
*/
class PyramidRule5 : public CellRule
@@ -81,7 +82,7 @@ public:
/**
* \copydoc MeshLib::Element::isPntInElement()
- * @param nodes the nodes of the element.
+ * \param nodes the nodes of the element.
*/
static bool isPntInElement(Node const* const* nodes,
MathLib::Point3d const& pnt, double eps);
diff --git a/MeshLib/Elements/QuadRule4.h b/MeshLib/Elements/QuadRule4.h
index 3b10b75ba51aa9755da2f0e2c37c368dd2870455..3616c9b09924f24243f367fafbf633bac90ff258 100644
--- a/MeshLib/Elements/QuadRule4.h
+++ b/MeshLib/Elements/QuadRule4.h
@@ -20,9 +20,10 @@ namespace MeshLib
{
/**
- * This class represents a 2d quadrilateral element. The following sketch shows the node and edge numbering.
- * @anchor QuadNodeAndEdgeNumbering
- * @code
+ * This class represents a 2d quadrilateral element. The following sketch shows
+ * the node and edge numbering.
+ * \anchor QuadNodeAndEdgeNumbering
+ * \code
* 2
* 3-----------2
* | |
@@ -32,7 +33,7 @@ namespace MeshLib
* | |
* 0-----------1
* 0
- * @endcode
+ * \endcode
*/
class QuadRule4 : public FaceRule
{
@@ -63,7 +64,7 @@ public:
/**
* \copydoc MeshLib::Element::isPntInElement()
- * @param nodes the nodes of the element.
+ * \param nodes the nodes of the element.
*/
static bool isPntInElement(Node const* const* nodes,
MathLib::Point3d const& pnt, double eps);
diff --git a/MeshLib/Elements/QuadRule8.h b/MeshLib/Elements/QuadRule8.h
index b4b141b84e66cb2668ebd9bebfcb7a71b1107fc6..f25c10834300e6ca75bc36ec8b415a97d5694de2 100644
--- a/MeshLib/Elements/QuadRule8.h
+++ b/MeshLib/Elements/QuadRule8.h
@@ -20,8 +20,8 @@ namespace MeshLib
/**
* This class represents a 2d quadrilateral element with 8 nodes.
* The following sketch shows the node and edge numbering.
- * @anchor Quad8NodeAndEdgeNumbering
- * @code
+ * \anchor Quad8NodeAndEdgeNumbering
+ * \code
* 2
* 3-----6-----2
* | |
@@ -31,7 +31,7 @@ namespace MeshLib
* | |
* 0-----4-----1
* 0
- * @endcode
+ * \endcode
*/
class QuadRule8 : public QuadRule4
{
diff --git a/MeshLib/Elements/QuadRule9.h b/MeshLib/Elements/QuadRule9.h
index bfefe156d52646d78a8069b4876525d18e50e2b5..81fb6e94c41e2f4a3ef7a645331d989a9d87aa9f 100644
--- a/MeshLib/Elements/QuadRule9.h
+++ b/MeshLib/Elements/QuadRule9.h
@@ -19,8 +19,8 @@ namespace MeshLib
/**
* This class represents a 2d quadrilateral element with 9 nodes.
* The following sketch shows the node and edge numbering.
- * @anchor Quad9NodeAndEdgeNumbering
- * @code
+ * \anchor Quad9NodeAndEdgeNumbering
+ * \code
* 2
* 3-----6-----2
* | |
@@ -30,7 +30,7 @@ namespace MeshLib
* | |
* 0-----4-----1
* 0
- * @endcode
+ * \endcode
*/
class QuadRule9 : public QuadRule8
{
diff --git a/MeshLib/Elements/TetRule10.h b/MeshLib/Elements/TetRule10.h
index 6cbb41c5a7b8f03c2800d381e0202446b5648526..3b7a31adbfd93efa690242b6627e376d256bb97f 100644
--- a/MeshLib/Elements/TetRule10.h
+++ b/MeshLib/Elements/TetRule10.h
@@ -19,9 +19,10 @@ namespace MeshLib
{
/**
- * This class represents a 3d tetrahedron element with 10 nodes. The following sketch shows the node and edge numbering.
- * @anchor TetrahedronNodeAndEdgeNumbering
- * @code
+ * This class represents a 3d tetrahedron element with 10 nodes. The following
+ * sketch shows the node and edge numbering.
+ * \anchor TetrahedronNodeAndEdgeNumbering
+ * \code
* 3
* /|\
* / | \
@@ -36,7 +37,7 @@ namespace MeshLib
* \|/
* 1
*
- * @endcode
+ * \endcode
*/
class TetRule10 : public TetRule4
{
diff --git a/MeshLib/Elements/TetRule4.h b/MeshLib/Elements/TetRule4.h
index 02d3203012c2270d6b5e1a064116d90a1beaf241..b5fbd63b3c08f52987b2845c5ddfc8290eff06e9 100644
--- a/MeshLib/Elements/TetRule4.h
+++ b/MeshLib/Elements/TetRule4.h
@@ -19,9 +19,10 @@ namespace MeshLib
{
/**
- * This class represents a 3d tetrahedron element. The following sketch shows the node and edge numbering.
- * @anchor Tetrahedron4NodeAndEdgeNumbering
- * @code
+ * This class represents a 3d tetrahedron element. The following sketch shows
+ * the node and edge numbering.
+ * \anchor Tetrahedron4NodeAndEdgeNumbering
+ * \code
* 3
* /|\
* / | \
@@ -36,7 +37,7 @@ namespace MeshLib
* \|/
* 1
*
- * @endcode
+ * \endcode
*/
class TetRule4 : public CellRule
{
@@ -76,7 +77,7 @@ public:
/**
* \copydoc MeshLib::Element::isPntInElement()
- * @param nodes the nodes of the element.
+ * \param nodes the nodes of the element.
*/
static bool isPntInElement(Node const* const* nodes,
MathLib::Point3d const& pnt, double eps);
diff --git a/MeshLib/Elements/TriRule3.h b/MeshLib/Elements/TriRule3.h
index 0119b73a276ff0f7bfcb3f398d4206c38e4f015d..60f8c565b18f30dad2344bfecd044e9d7920c0d6 100644
--- a/MeshLib/Elements/TriRule3.h
+++ b/MeshLib/Elements/TriRule3.h
@@ -19,9 +19,10 @@ namespace MeshLib
{
/**
- * This class represents a 2d triangle element. The following sketch shows the node and edge numbering.
- * @anchor TriNodeAndEdgeNumbering
- * @code
+ * This class represents a 2d triangle element. The following sketch shows the
+ * node and edge numbering.
+ * \anchor TriNodeAndEdgeNumbering
+ * \code
*
* 2
* o
@@ -33,7 +34,7 @@ namespace MeshLib
* 0-----------1
* 0
*
- * @endcode
+ * \endcode
*/
class TriRule3 : public FaceRule
{
@@ -64,7 +65,7 @@ public:
/**
* \copydoc MeshLib::Element::isPntInElement()
- * @param nodes the nodes of the element.
+ * \param nodes the nodes of the element.
*/
static bool isPntInElement(Node const* const* nodes,
MathLib::Point3d const& pnt, double eps);
diff --git a/MeshLib/Elements/TriRule6.h b/MeshLib/Elements/TriRule6.h
index 8ca4361246d0725199e6cec8ad76acf3de0025f9..77981eee75386802978837d84f193f81f4e471a8 100644
--- a/MeshLib/Elements/TriRule6.h
+++ b/MeshLib/Elements/TriRule6.h
@@ -21,8 +21,8 @@ namespace MeshLib
* This class represents a 2d triangle element with 6 nodes.
*
* The following sketch shows the node and edge numbering.
- * @anchor Tri6NodeAndEdgeNumbering
- * @code
+ * \anchor Tri6NodeAndEdgeNumbering
+ * \code
*
* 2
* o
@@ -34,7 +34,7 @@ namespace MeshLib
* 0-----------1
* 3
*
- * @endcode
+ * \endcode
*/
class TriRule6 : public TriRule3
{
diff --git a/MeshLib/IO/XDMF/transformData.h b/MeshLib/IO/XDMF/transformData.h
index 1d13018045a4dfa3d6df48e82f7e3717712cf6fb..13cf818deabf609a7c14fbdb00914f77ecf5c8c9 100644
--- a/MeshLib/IO/XDMF/transformData.h
+++ b/MeshLib/IO/XDMF/transformData.h
@@ -25,29 +25,29 @@ namespace MeshLib::IO
{
/**
* \brief Create meta data for attributes used for hdf5 and xdmf
- * @param mesh OGS mesh can be mesh or partitionedMesh
- * @param n_files specifies the number of files. If greater than 1 it groups the
+ * \param mesh OGS mesh can be mesh or partitionedMesh
+ * \param n_files specifies the number of files. If greater than 1 it groups the
* data of each process to n_files
- * @return vector of meta data
+ * \return vector of meta data
*/
std::vector<XdmfHdfData> transformAttributes(MeshLib::Mesh const& mesh,
unsigned int n_files);
/**
* \brief Create meta data for geometry used for hdf5 and xdmf
- * @param mesh OGS mesh can be mesh or partitionedMesh
- * @param data_ptr Memory location of geometry values.
- * @param n_files specifies the number of files. If greater than 1 it groups the
+ * \param mesh OGS mesh can be mesh or partitionedMesh
+ * \param data_ptr Memory location of geometry values.
+ * \param n_files specifies the number of files. If greater than 1 it groups the
* data of each process to n_files
- * @return Geometry meta data
+ * \return Geometry meta data
*/
XdmfHdfData transformGeometry(MeshLib::Mesh const& mesh, double const* data_ptr,
unsigned int n_files);
/**
* \brief Create meta data for topology used for HDF5 and XDMF
- * @param values actual topology values to get size and memory location
- * @param n_files specifies the number of files. If greater than 1 it groups the
+ * \param values actual topology values to get size and memory location
+ * \param n_files specifies the number of files. If greater than 1 it groups the
* data of each process to n_files
- * @return Topology meta data
+ * \return Topology meta data
*/
XdmfHdfData transformTopology(std::vector<int> const& values,
unsigned int n_files);
@@ -55,18 +55,18 @@ XdmfHdfData transformTopology(std::vector<int> const& values,
* \brief Copies all node points into a new vector. Contiguous data used for
* writing. Conform with XDMF standard in
* https://xdmf.org/index.php/XDMF_Model_and_Format
- * @param mesh OGS mesh can be mesh or partitionedMesh
- * @return vector containing a copy of the data
+ * \param mesh OGS mesh can be mesh or partitionedMesh
+ * \return vector containing a copy of the data
*/
std::vector<double> transformToXDMFGeometry(MeshLib::Mesh const& mesh);
/**
* \brief Copies all cells into a new vector. Contiguous data used for writing.
* The topology is specific to xdmf because it contains the xdmf cell types!!
* See section topology in https://xdmf.org/index.php/XDMF_Model_and_Format
- * @param mesh OGS mesh can be mesh or partitionedMesh
- * @param offset Local offset to transform local to global cell ID. Offset must
+ * \param mesh OGS mesh can be mesh or partitionedMesh
+ * \param offset Local offset to transform local to global cell ID. Offset must
* be zero in serial and must be defined for each process in parallel execution.
- * @return vector containing a copy of the data
+ * \return vector containing a copy of the data
*/
std::vector<int> transformToXDMFTopology(MeshLib::Mesh const& mesh,
std::size_t const offset);
diff --git a/MeshLib/IO/XDMF/writeXdmf.h b/MeshLib/IO/XDMF/writeXdmf.h
index e6a4df81e427106f83d97ce2ef23940134b26469..824521e8bea0b80a7560859fb116f730bd5bd8d0 100644
--- a/MeshLib/IO/XDMF/writeXdmf.h
+++ b/MeshLib/IO/XDMF/writeXdmf.h
@@ -27,14 +27,14 @@ namespace MeshLib::IO
/**
* \brief Generator function that creates a function capturing the spatial data
* of a mesh Temporal data can later be passed as argument
- * @param geometry Metadata for the geometry (points) of the mesh
- * @param topology Metadata for the topology of the mesh
- * @param variable_attributes Meta data for attributes changing over time
- * @param constant_attributes Meta data for attributes NOT changing over time
- * @param h5filename Name of the file where the actual data was written
- * @param ogs_version OGS Version to be added to XdmfInformation tag
- * @param mesh_name Name of the output mesh
- * @return unary function with vector of time step values, returning XDMF string
+ * \param geometry Metadata for the geometry (points) of the mesh
+ * \param topology Metadata for the topology of the mesh
+ * \param variable_attributes Meta data for attributes changing over time
+ * \param constant_attributes Meta data for attributes NOT changing over time
+ * \param h5filename Name of the file where the actual data was written
+ * \param ogs_version OGS Version to be added to XdmfInformation tag
+ * \param mesh_name Name of the output mesh
+ * \return unary function with vector of time step values, returning XDMF string
*/
std::function<std::string(std::vector<double>)> write_xdmf(
XdmfData const& geometry, XdmfData const& topology,
diff --git a/MeshLib/Utils/DuplicateMeshComponents.h b/MeshLib/Utils/DuplicateMeshComponents.h
index 6707b21edae79ed5f94c91a153b4314fd47941ff..7dcdc3abe068bb23262efb4732aaefb1d66e2794 100644
--- a/MeshLib/Utils/DuplicateMeshComponents.h
+++ b/MeshLib/Utils/DuplicateMeshComponents.h
@@ -25,12 +25,12 @@ class Element;
std::vector<Node*> copyNodeVector(const std::vector<Node*>& nodes);
/** Creates a deep copy of an element vector using the given Node vector.
- * @param elements The element vector that should be duplicated.
- * @param new_nodes The new node vector used for the duplicated element vector.
- * @param node_id_map An optional mapping from the nodes the 'old' elements
+ * \param elements The element vector that should be duplicated.
+ * \param new_nodes The new node vector used for the duplicated element vector.
+ * \param node_id_map An optional mapping from the nodes the 'old' elements
* based on to the new nodes. This should be consistent with the original node
* vector.
- * @return A deep copy of the elements vector using the new nodes vector.
+ * \return A deep copy of the elements vector using the new nodes vector.
*/
std::vector<Element*> copyElementVector(
std::vector<Element*> const& elements,
diff --git a/MeshLib/Utils/GetElementRotationMatrices.h b/MeshLib/Utils/GetElementRotationMatrices.h
index 4a06ab888515ddd6b04f6022bb0675c4d0b9c8d0..ddde50656797f844d7e788378ca04e3a8f32d6d1 100644
--- a/MeshLib/Utils/GetElementRotationMatrices.h
+++ b/MeshLib/Utils/GetElementRotationMatrices.h
@@ -25,10 +25,10 @@ class Element;
* local vector to the global coordinate system. If an element is not inclined,
* the identity matrix is used as its rotation matrix.
*
- * @param space_dimension The space dimension.
- * @param mesh_dimension The mesh dimension.
- * @param elements The mesh elements.
- * @return A vector of rotation matrices of given elements.
+ * \param space_dimension The space dimension.
+ * \param mesh_dimension The mesh dimension.
+ * \param elements The mesh elements.
+ * \return A vector of rotation matrices of given elements.
*/
std::vector<Eigen::MatrixXd> getElementRotationMatrices(
int const space_dimension, int const mesh_dimension,
diff --git a/MeshLib/Utils/SetMeshSpaceDimension.h b/MeshLib/Utils/SetMeshSpaceDimension.h
index 6d5b1dc33e5c42b03be6e13820c19bb05596895c..810df0fedcd0256a4a3d7c5dd981405f2cd31677 100644
--- a/MeshLib/Utils/SetMeshSpaceDimension.h
+++ b/MeshLib/Utils/SetMeshSpaceDimension.h
@@ -30,7 +30,7 @@ class Mesh;
* with higher dimension can be used to discretise the porous medium matrix
* domain.
*
- * @param meshes All meshes include the bulk mesh and the meshes for boundary
+ * \param meshes All meshes include the bulk mesh and the meshes for boundary
* conditions.
*/
void setMeshSpaceDimension(std::vector<std::unique_ptr<Mesh>> const& meshes);
diff --git a/MeshToolsLib/MeshEditing/AddLayerToMesh.cpp b/MeshToolsLib/MeshEditing/AddLayerToMesh.cpp
index ad937901446ea6f7b8d0917eef8dd3b1f00b0659..3296ab5d5ef129b63aa929695dbbdbf2cc4ebebd 100644
--- a/MeshToolsLib/MeshEditing/AddLayerToMesh.cpp
+++ b/MeshToolsLib/MeshEditing/AddLayerToMesh.cpp
@@ -31,14 +31,14 @@ namespace MeshToolsLib
/** Extrudes point, line, triangle or quad elements to its higher dimensional
* versions, i.e. line, quad, prism, hexahedron.
*
- * @param subsfc_nodes the nodes the elements are based on
- * @param sfc_elem the element of the surface that will be extruded
- * @param sfc_to_subsfc_id_map relation between the surface nodes of the surface
+ * \param subsfc_nodes the nodes the elements are based on
+ * \param sfc_elem the element of the surface that will be extruded
+ * \param sfc_to_subsfc_id_map relation between the surface nodes of the surface
* element and the ids of the nodes of the subsurface mesh
- * @param subsfc_sfc_id_map mapping of the surface nodes of the current mesh
+ * \param subsfc_sfc_id_map mapping of the surface nodes of the current mesh
* to the surface nodes of the extruded mesh
*
- * @return extruded element (point -> line, line -> quad, tri -> prism, quad ->
+ * \return extruded element (point -> line, line -> quad, tri -> prism, quad ->
* hexahedron)
*/
MeshLib::Element* extrudeElement(
diff --git a/MeshToolsLib/MeshEditing/FlipElements.h b/MeshToolsLib/MeshEditing/FlipElements.h
index d1ba4a91d6844212b3ef0721b7d6e6c80ea858d4..ad4466f96ab04fb3a1ff3de364f63451adf78acd 100644
--- a/MeshToolsLib/MeshEditing/FlipElements.h
+++ b/MeshToolsLib/MeshEditing/FlipElements.h
@@ -28,9 +28,9 @@ namespace MeshToolsLib
* Creates a copy of an 1d / 2d element where the node order is reversed,
* such that the direction of a line changes and normals of 2D elements
* changes its sign.
- * @param elem original element
- * @param nodes node vector used for the copy of the element
- * @return a flipped copy of the element
+ * \param elem original element
+ * \param nodes node vector used for the copy of the element
+ * \return a flipped copy of the element
*/
std::unique_ptr<MeshLib::Element> createFlippedElement(
MeshLib::Element const& elem, std::vector<MeshLib::Node*> const& nodes);
@@ -39,8 +39,8 @@ std::unique_ptr<MeshLib::Element> createFlippedElement(
* Creates a copy of a 1d / 2d mesh where the node order of all elements
* is reversed such that the direction of lines changes and normals of
* 2D elements changes their sign.
- * @param mesh input mesh
- * @return a flipped copy of the input mesh
+ * \param mesh input mesh
+ * \return a flipped copy of the input mesh
*/
std::unique_ptr<MeshLib::Mesh> createFlippedMesh(MeshLib::Mesh const& mesh);
diff --git a/MeshToolsLib/MeshEditing/RemoveMeshComponents.h b/MeshToolsLib/MeshEditing/RemoveMeshComponents.h
index 3cdff0b6b46a4d4854f9648e75e1f4646ceb659b..9e1286ce1f99ea9eb07985c60622e3198bfdf623 100644
--- a/MeshToolsLib/MeshEditing/RemoveMeshComponents.h
+++ b/MeshToolsLib/MeshEditing/RemoveMeshComponents.h
@@ -26,10 +26,10 @@ namespace MeshToolsLib
/**
* Removes mesh elements and returns a new mesh object. The original mesh is
* kept unchanged.
- * @param mesh an original mesh whose elements are removed
- * @param removed_element_ids a vector of element indices to be removed
- * @param new_mesh_name a new mesh name
- * @return a new mesh object
+ * \param mesh an original mesh whose elements are removed
+ * \param removed_element_ids a vector of element indices to be removed
+ * \param new_mesh_name a new mesh name
+ * \return a new mesh object
*/
MeshLib::Mesh* removeElements(
const MeshLib::Mesh& mesh,
@@ -39,10 +39,10 @@ MeshLib::Mesh* removeElements(
/**
* Removes the mesh nodes (and connected elements) given in the nodes-list from
* the mesh.
- * @param mesh an original mesh whose elements are removed
- * @param del_nodes_idx a vector of node indices to be removed
- * @param new_mesh_name a new mesh name
- * @return a new mesh object
+ * \param mesh an original mesh whose elements are removed
+ * \param del_nodes_idx a vector of node indices to be removed
+ * \param new_mesh_name a new mesh name
+ * \return a new mesh object
*/
MeshLib::Mesh* removeNodes(const MeshLib::Mesh& mesh,
const std::vector<std::size_t>& del_nodes_idx,
diff --git a/MeshToolsLib/MeshEditing/moveMeshNodes.h b/MeshToolsLib/MeshEditing/moveMeshNodes.h
index d4983eece470d4d04b315e1b0557ba57970a8dae..e81aca8a1f77d07fdb83f301e5b95eb73b673200 100644
--- a/MeshToolsLib/MeshEditing/moveMeshNodes.h
+++ b/MeshToolsLib/MeshEditing/moveMeshNodes.h
@@ -25,9 +25,9 @@ namespace MeshToolsLib
* The function iterates over all mesh nodes between the
* begin and the end iterator and moves them using the
* given displacement.
- * @param begin begin iterator
- * @param end end iterator
- * @param displacement the displacement to use
+ * \param begin begin iterator
+ * \param end end iterator
+ * \param displacement the displacement to use
*/
template <typename Iterator>
void moveMeshNodes(Iterator begin,
diff --git a/MeshToolsLib/MeshGenerators/MeshGenerator.h b/MeshToolsLib/MeshGenerators/MeshGenerator.h
index 36a8e417b820e7d247e302c305be2f5b14b3df08..44e147c667f6d686a14628043d23a7a129cf366b 100644
--- a/MeshToolsLib/MeshGenerators/MeshGenerator.h
+++ b/MeshToolsLib/MeshGenerators/MeshGenerator.h
@@ -31,9 +31,9 @@ namespace MeshGenerator
/**
* Generate regularly placed mesh nodes in 3D spaces
- * @param vec_xyz_coords a vector of coordinates in x,y,z directions
- * @param origin coordinates of the left-most point
- * @return a vector of created mesh nodes
+ * \param vec_xyz_coords a vector of coordinates in x,y,z directions
+ * \param origin coordinates of the left-most point
+ * \return a vector of created mesh nodes
*/
std::vector<MeshLib::Node*> generateRegularNodes(
const std::vector<const std::vector<double>*>& vec_xyz_coords,
@@ -41,9 +41,9 @@ std::vector<MeshLib::Node*> generateRegularNodes(
/**
* Generate regularly placed mesh nodes in 1D space
- * @param vec_x_coords a vector of x coordinates
- * @param origin coordinates of the left-most point
- * @return a vector of created mesh nodes
+ * \param vec_x_coords a vector of x coordinates
+ * \param origin coordinates of the left-most point
+ * \return a vector of created mesh nodes
*/
std::vector<MeshLib::Node*> generateRegularNodes(
const std::vector<double>& vec_x_coords,
@@ -51,10 +51,10 @@ std::vector<MeshLib::Node*> generateRegularNodes(
/**
* Generate regularly placed mesh nodes in 1D space
- * @param vec_x_coords a vector of x coordinates
- * @param vec_y_coords a vector of y coordinates
- * @param origin coordinates of the left-most point
- * @return a vector of created mesh nodes
+ * \param vec_x_coords a vector of x coordinates
+ * \param vec_y_coords a vector of y coordinates
+ * \param origin coordinates of the left-most point
+ * \return a vector of created mesh nodes
*/
std::vector<MeshLib::Node*> generateRegularNodes(
std::vector<double>& vec_x_coords,
@@ -63,11 +63,11 @@ std::vector<MeshLib::Node*> generateRegularNodes(
/**
* Generate regularly placed mesh nodes in 1D space
- * @param vec_x_coords a vector of x coordinates
- * @param vec_y_coords a vector of y coordinates
- * @param vec_z_coords a vector of z coordinates
- * @param origin coordinates of the left-most point
- * @return a vector of created mesh nodes
+ * \param vec_x_coords a vector of x coordinates
+ * \param vec_y_coords a vector of y coordinates
+ * \param vec_z_coords a vector of z coordinates
+ * \param origin coordinates of the left-most point
+ * \return a vector of created mesh nodes
*/
std::vector<MeshLib::Node*> generateRegularNodes(
std::vector<double>& vec_x_coords,
@@ -77,10 +77,10 @@ std::vector<MeshLib::Node*> generateRegularNodes(
/**
* Generate regularly placed mesh nodes in 3D spaces
- * @param n_cells an array of the number of cells in x,y,z directions
- * @param cell_size an array of cell sizes in x,y,z directions
- * @param origin coordinates of the left-most point
- * @return a vector of created mesh nodes
+ * \param n_cells an array of the number of cells in x,y,z directions
+ * \param cell_size an array of cell sizes in x,y,z directions
+ * \param origin coordinates of the left-most point
+ * \return a vector of created mesh nodes
*/
std::vector<MeshLib::Node*> generateRegularNodes(
const std::array<unsigned, 3>& n_cells,
diff --git a/MeshToolsLib/MeshGenerators/VoxelGridFromLayeredMeshes.h b/MeshToolsLib/MeshGenerators/VoxelGridFromLayeredMeshes.h
index 576d66c788d6d86e31966c1a0797bdc006bfdb0e..346b33068f18483e4f4c5156564d1bf57005c0f7 100644
--- a/MeshToolsLib/MeshGenerators/VoxelGridFromLayeredMeshes.h
+++ b/MeshToolsLib/MeshGenerators/VoxelGridFromLayeredMeshes.h
@@ -31,13 +31,13 @@ namespace MeshToolsLib::MeshGenerators::VoxelFromLayeredMeshes
/**
* Constructs a VoxelGrid with a specified resolution of a list of
* layered meshes.
- * @param extent The axis-aligned boundary-box (AABB) which is initially
+ * \param extent The axis-aligned boundary-box (AABB) which is initially
* defined.
- * @param layers Containing all the meshes that will be used
+ * \param layers Containing all the meshes that will be used
* to create the VoxelGrid.
- * @param cellsize Contains the resolution of the Voxel (i.e.
+ * \param cellsize Contains the resolution of the Voxel (i.e.
* length in x-,y-,z-directions)
- * @param dilate A flag to set dilate. If dilate is True all Voxels which
+ * \param dilate A flag to set dilate. If dilate is True all Voxels which
* are not fully covered by the meshes are included in the resulting
* VoxelGrid.
*/
diff --git a/MeshToolsLib/MeshQuality/MeshValidation.cpp b/MeshToolsLib/MeshQuality/MeshValidation.cpp
index 5488ab8822b2e50b90a57c34d2c243daebaea7f4..7381bacc4f9d94f8a3360b3fe812a8fa6bbcaf41 100644
--- a/MeshToolsLib/MeshQuality/MeshValidation.cpp
+++ b/MeshToolsLib/MeshQuality/MeshValidation.cpp
@@ -31,10 +31,10 @@ namespace MeshToolsLib
/** Finds all surface elements that can be reached from element. All elements
* that are found in this way are marked in the global sfc_idx vector using the
* current_index.
- * @param element The mesh element from which the search is started
- * @param sfc_idx The global index vector notifying to which surface elements
+ * \param element The mesh element from which the search is started
+ * \param sfc_idx The global index vector notifying to which surface elements
* belong
- * @param current_index The index that all elements reachable from element will
+ * \param current_index The index that all elements reachable from element will
* be assigned in sfc_idx
*/
static void trackSurface(MeshLib::Element const* const element,
diff --git a/MeshToolsLib/convertMeshToGeo.h b/MeshToolsLib/convertMeshToGeo.h
index 4b8a5865c129d4efb151ebbddcbcdf7a75dbbd76..c8b93edec0dcd2d86bfd3c7275567ecd2d6cede6 100644
--- a/MeshToolsLib/convertMeshToGeo.h
+++ b/MeshToolsLib/convertMeshToGeo.h
@@ -43,10 +43,10 @@ bool convertMeshToGeo(const MeshLib::Mesh& mesh,
/**
* Converts a surface into a triangular mesh
- * @param sfc Surface object
- * @param mesh_name New mesh name
- * @param eps Minimum distance for nodes not to be collapsed
- * @return a pointer to a converted mesh object. nullptr is returned if the
+ * \param sfc Surface object
+ * \param mesh_name New mesh name
+ * \param eps Minimum distance for nodes not to be collapsed
+ * \return a pointer to a converted mesh object. nullptr is returned if the
* conversion fails.
*/
MeshLib::Mesh* convertSurfaceToMesh(
diff --git a/NumLib/DOF/ComputeSparsityPattern.h b/NumLib/DOF/ComputeSparsityPattern.h
index ebd5e73f30c7ac85fdba0321136a216ceca70018..a300879db7a8d073fbf3a0d07742dc27679b4fe6 100644
--- a/NumLib/DOF/ComputeSparsityPattern.h
+++ b/NumLib/DOF/ComputeSparsityPattern.h
@@ -24,13 +24,13 @@ namespace NumLib
class LocalToGlobalIndexMap;
/**
- * @brief Computes a sparsity pattern for the given inputs.
+ * \brief Computes a sparsity pattern for the given inputs.
*
- * @param dof_table maps mesh nodes to global indices
- * @param mesh mesh for which the two parameters above are
+ * \param dof_table maps mesh nodes to global indices
+ * \param mesh mesh for which the two parameters above are
* defined
*
- * @return The computed sparsity pattern.
+ * \return The computed sparsity pattern.
*/
GlobalSparsityPattern computeSparsityPattern(
LocalToGlobalIndexMap const& dof_table, MeshLib::Mesh const& mesh);
diff --git a/NumLib/Fem/CoordinatesMapping/NaturalCoordinatesMapping.h b/NumLib/Fem/CoordinatesMapping/NaturalCoordinatesMapping.h
index 04faa37953464e60f00810b9837e3d6883b9a798..352df90cf440e0a334a3f93bfc368d64c1b73673 100644
--- a/NumLib/Fem/CoordinatesMapping/NaturalCoordinatesMapping.h
+++ b/NumLib/Fem/CoordinatesMapping/NaturalCoordinatesMapping.h
@@ -40,8 +40,8 @@ void naturalCoordinatesMappingComputeShapeMatrices(const MeshLib::Element& ele,
* e.g. line elements in 2D space. Details of the mapping method can be found in
* \cite Kolditz2001 .
*
- * @tparam T_SHAPE_FUNC Shape function class
- * @tparam T_SHAPE_MATRICES Shape matrices class
+ * \tparam T_SHAPE_FUNC Shape function class
+ * \tparam T_SHAPE_MATRICES Shape matrices class
*/
template <class T_SHAPE_FUNC, class T_SHAPE_MATRICES>
struct NaturalCoordinatesMapping
@@ -49,11 +49,11 @@ struct NaturalCoordinatesMapping
/**
* compute all mapping matrices at the given location in natural coordinates
*
- * @param ele Mesh element object
- * @param natural_pt Location in natural coordinates (r,s,t)
- * @param shapemat Shape matrix data where calculated shape
+ * \param ele Mesh element object
+ * \param natural_pt Location in natural coordinates (r,s,t)
+ * \param shapemat Shape matrix data where calculated shape
* functions are stored
- * @param global_dim Global dimension
+ * \param global_dim Global dimension
*/
static void computeShapeMatrices(const MeshLib::Element& ele,
const double* natural_pt,
@@ -68,12 +68,12 @@ struct NaturalCoordinatesMapping
* compute specified mapping matrices at the given location in natural
* coordinates
*
- * @tparam T_SHAPE_MATRIX_TYPE Mapping matrix types to be calculated
- * @param ele Mesh element object
- * @param natural_pt Location in natural coordinates (r,s,t)
- * @param shapemat Shape matrix data where calculated shape
+ * \tparam T_SHAPE_MATRIX_TYPE Mapping matrix types to be calculated
+ * \param ele Mesh element object
+ * \param natural_pt Location in natural coordinates (r,s,t)
+ * \param shapemat Shape matrix data where calculated shape
* functions are stored
- * @param global_dim Global dimension
+ * \param global_dim Global dimension
*/
template <ShapeMatrixType T_SHAPE_MATRIX_TYPE>
static void computeShapeMatrices(const MeshLib::Element& ele,
diff --git a/NumLib/ODESolver/TimeDiscretization.h b/NumLib/ODESolver/TimeDiscretization.h
index 1469c910e570ff8df07826780e3b346bc8b1c204..196fa67a2f84c0be75643e29f031d2bb09e0e471 100644
--- a/NumLib/ODESolver/TimeDiscretization.h
+++ b/NumLib/ODESolver/TimeDiscretization.h
@@ -22,10 +22,10 @@ namespace NumLib
* Compute and return the relative change of solutions between two
* successive time steps by \f$ e_n = \|u^{n+1}-u^{n}\|/\|u^{n+1}\| \f$.
*
- * @param x The current solution
- * @param x_old The previous solution
- * @param norm_type The norm type of global vector
- * @return \f$ e_n = \|u^{n+1}-u^{n}\|/\|u^{n+1}\| \f$.
+ * \param x The current solution
+ * \param x_old The previous solution
+ * \param norm_type The norm type of global vector
+ * \return \f$ e_n = \|u^{n+1}-u^{n}\|/\|u^{n+1}\| \f$.
*
*/
double computeRelativeChangeFromPreviousTimestep(
diff --git a/ProcessLib/HeatTransportBHE/BHE/MeshUtils.h b/ProcessLib/HeatTransportBHE/BHE/MeshUtils.h
index 73aaf5e94e00eeb7537417347d9c7b94f2038d8d..b908ba35f03071b54029380c3f1423cce83a8634 100644
--- a/ProcessLib/HeatTransportBHE/BHE/MeshUtils.h
+++ b/ProcessLib/HeatTransportBHE/BHE/MeshUtils.h
@@ -43,7 +43,7 @@ struct BHEMeshData
/**
* get data about fracture and matrix elements/nodes from a mesh
*
- * @param mesh A mesh which includes BHE elements, i.e. 1-dimensional
+ * \param mesh A mesh which includes BHE elements, i.e. 1-dimensional
* elements. It is assumed that elements forming a BHE have a distinct
* material ID.
*/
diff --git a/ProcessLib/LIE/Common/MeshUtils.h b/ProcessLib/LIE/Common/MeshUtils.h
index ba118349685ea00260803d9f39d8c791b1090dfb..0a2b62b795c3e228232fffb5a6e03f0bae584b6f 100644
--- a/ProcessLib/LIE/Common/MeshUtils.h
+++ b/ProcessLib/LIE/Common/MeshUtils.h
@@ -25,20 +25,20 @@ namespace LIE
/**
* get data about fracture and matrix elements/nodes from a mesh
*
- * @param mesh A mesh which includes fracture elements, i.e. lower-dimensional
+ * \param mesh A mesh which includes fracture elements, i.e. lower-dimensional
* elements. It is assumed that elements forming a fracture have a distinct
* material ID.
- * @param vec_matrix_elements a vector of matrix elements
- * @param vec_fracture_mat_IDs fracture material IDs found in the mesh
- * @param vec_fracture_elements a vector of fracture elements (grouped by
+ * \param vec_matrix_elements a vector of matrix elements
+ * \param vec_fracture_mat_IDs fracture material IDs found in the mesh
+ * \param vec_fracture_elements a vector of fracture elements (grouped by
* fracture IDs)
- * @param vec_fracture_matrix_elements a vector of fracture elements and matrix
+ * \param vec_fracture_matrix_elements a vector of fracture elements and matrix
* elements connecting to the fracture (grouped by fracture IDs)
- * @param vec_fracture_nodes a vector of fracture element nodes (grouped by
+ * \param vec_fracture_nodes a vector of fracture element nodes (grouped by
* fracture IDs)
- * @param vec_branch_nodeID_matIDs a vector of branch node IDs found in the
+ * \param vec_branch_nodeID_matIDs a vector of branch node IDs found in the
* mesh (and corresponding fracture material IDs)
- * @param vec_junction_nodeID_matIDs a vector of junction node IDs found in the
+ * \param vec_junction_nodeID_matIDs a vector of junction node IDs found in the
* mesh (and corresponding fracture material IDs)
*/
void getFractureMatrixDataInMesh(
diff --git a/ProcessLib/Output/OutputFormat.cpp b/ProcessLib/Output/OutputFormat.cpp
index 233615e3a6fc1ee909bbf037d7ca2c1905e35aaa..7c54cda07f2bcb06b2795336635f7f94cd3bf6c0 100644
--- a/ProcessLib/Output/OutputFormat.cpp
+++ b/ProcessLib/Output/OutputFormat.cpp
@@ -26,8 +26,8 @@ namespace ProcessLib
{
/**
* Get a reference to the PVDFile corresponding to the given filename
- * @param mesh_name the name of the mesh the PVD file is searched for
- * @return Reference to a PVDFile object
+ * \param mesh_name the name of the mesh the PVD file is searched for
+ * \return Reference to a PVDFile object
*/
MeshLib::IO::PVDFile& OutputVTKFormat::findOrCreatePVDFile(
std::string const& mesh_name) const