Doxygen documentation2

Applications/DataExplorer/Base/RecentFiles.h

@@ -48,8 +48,6 @@ class RecentFiles : public QObject
      * \param slot A slot on parent which is called when a recent file is clicked.
      * Use this with Qts SLOT() macro!
      * \param settingsName The setting key
-     * \param programName The name of the program. QSettings of one program
-     * should be stored with the same keys: QSettings("UFZ", programName)
      */
     RecentFiles(QObject* parent, const char* slot, QString settingsName);
     ~RecentFiles();

Applications/DataExplorer/DataView/DiagramView/DiagramView.cpp

@@ -70,7 +70,7 @@ void DiagramView::initialize()
  * It is only necessary to call this if
  *        Qt::AspectRatioMode == Qt::IgnoreAspectRatio.
  * Also, this method is kind of annoying because you have to set the
- * appropriate transform for every single QGraphicsTextItem seperately.
+ * appropriate transform for every single QGraphicsTextItem separately.
  */
 /*
    void DiagramView::keepItemAspectRatio()

Applications/DataExplorer/DataView/GEOModels.h

@@ -74,8 +74,6 @@ public slots:
 
     void addSurfaceVec(std::string const& name);
 
-    /// @brief
-    /// @param surfaces The surface vector.
     void appendSurfaceVec(std::string const& name);
     void removeSurfaceVec(std::string const& name);
 

Applications/DataExplorer/DataView/MshItem.cpp

@@ -15,13 +15,8 @@
 #include "MshItem.h"
 #include "MeshLib/Vtk/VtkMappedMeshSource.h"
 
-/**
- * Constructor.
- * \param data The data associated with each column
- * \param parent The parent item in the tree
- * \param grid The mesh associated with this item
- */
-MshItem::MshItem(const QList<QVariant> &data, TreeItem* parent, const MeshLib::Mesh* mesh)
+MshItem::MshItem(const QList<QVariant>& data, TreeItem* parent,
+                 const MeshLib::Mesh* mesh)
     : TreeItem(data, parent)
 {
     _mesh_source = MeshLib::VtkMappedMeshSource::New();

Applications/DataExplorer/DataView/MshItem.h

@@ -31,7 +31,12 @@ class MshItem : public TreeItem
 {
 public:
     /// Constructor, automatically generates VTK object of the given mesh.
-    MshItem(const QList<QVariant> &data, TreeItem* parent, const MeshLib::Mesh* grid);
+    ///
+    /// \param data The data associated with each column
+    /// \param parent The parent item in the tree
+    /// \param mesh The mesh associated with this item
+    MshItem(const QList<QVariant>& data, TreeItem* parent,
+            const MeshLib::Mesh* mesh);
     ~MshItem();
 
     /// Returns the mesh.

Applications/DataExplorer/VtkVis/VtkColorByHeightFilter.h

@@ -45,7 +45,7 @@ class VtkColorByHeightFilter : public vtkPolyDataAlgorithm, public VtkAlgorithmP
     void PrintSelf(ostream& os, vtkIndent indent);
 
     /// @brief Returns the underlying colour look up table object.
-    vtkGetObjectMacro(ColorLookupTable,VtkColorLookupTable)
+    vtkGetObjectMacro(ColorLookupTable,VtkColorLookupTable);
 
     /// @brief This filter gets updated when the color look-up table was modified.
     virtual unsigned long GetMTime();

Applications/DataExplorer/VtkVis/VtkRaster.h

@@ -50,15 +50,15 @@ class VtkRaster
                                         double& y0,
                                         double& delta);
 private:
+#ifdef GEOTIFF_FOUND
     /**
      * Loads ArcGIS asc-files to a QPixmap object and automatically does a contrast stretching to adjust values to 8 bit greyscale images.
      * \param fileName Filename of the file that should be loaded.
-     * \param raster The QPixmap into which the raster data will be written.
-     * \param origin The upper left corner of the data set
+     * \param x0 X-coordinate of the upper left corner of the data set, the default value is 0.
+     * \param y0 Y-coordinate of the upper left corner of the data set, the default value is 0.
      * \param delta The size of each pixel in the image which is needed for correctly displaying the data.
      * \return A vtkImageImport-object (derived from vtkImageAlgorithm).
      */
-#ifdef GEOTIFF_FOUND
     static vtkImageImport* loadImageFromTIFF(const std::string &fileName,
                                              double& x0, double& y0, double& delta);
 #endif

Applications/FileIO/CsvInterface.h

@@ -138,7 +138,8 @@ class CsvInterface  : public BaseLib::IO::Writer
      * Reads a column of the given name from a CSV file.
      * \param fname        Name of the file to be read
      * \param delim        Deliminator, default is ','
-     * \param data_arary   A vector containing the data read from the file
+     * \param data_array   A vector containing the data read from the file
+     * \param column_name  The column's name to read
      * \return An error code (0 = ok, 0<i<max = number of skipped lines, -1 error reading file)
      */
     template <typename T>

Applications/FileIO/TetGenInterface.h

@@ -106,6 +106,7 @@ class TetGenInterface final
      * Method reads the nodes from stream and stores them in a node vector.
      * For this purpose it uses methods parseNodesFileHeader() and parseNodes().
      * @param input  the input stream
+     * @param nodes  output vector of nodes.
      * @return true, if all information is read, false if the method detects an error
      */
     bool readNodesFromStream(std::ifstream &input,

Applications/Utils/ModelPreparation/PartitionMesh/NodeWiseMeshPartitioner.h

@@ -45,7 +45,6 @@ class NodeWiseMeshPartitioner
 
 public:
     /*!
-     * \param file_name_base The prefix of the file name.
      * \param num_partitions Number of partitions,
      * \param mesh           Pointer to a mesh object.
      */
@@ -61,8 +60,9 @@ class NodeWiseMeshPartitioner
     }
 
     /// Partition by node.
-    /// \param is_mixed_hl_elem Flag to indicate whether the elements of
-    /// a mesh can be used for both linear and high order interpolation
+    /// \param is_mixed_high_order_linear_elems Flag to indicate whether the
+    /// elements of a mesh can be used for both linear and high order
+    /// interpolation
     void partitionByMETIS(const bool is_mixed_high_order_linear_elems);
 
     void resetGlobalNodeIndices();
@@ -107,8 +107,9 @@ class NodeWiseMeshPartitioner
     std::vector<bool> _elements_status;
 
     // Renumber the global indices of nodes,
-    /// \param is_mixed_hl_elem Flag to indicate whether the elements of
-    /// a mesh can be used for both linear and high order interpolation
+    /// \param is_mixed_high_order_linear_elems Flag to indicate whether the
+    /// elements of a mesh can be used for both linear and high order
+    /// interpolation
     void renumberNodeIndices(const bool is_mixed_high_order_linear_elems);
 
     /*!
@@ -118,7 +119,6 @@ class NodeWiseMeshPartitioner
        element type, number of nodes of the element. Therefore
        the total number of the integers in an element vector is
         3 * vector size + sum (number of nodes of each element)
-     \param is_ghost Flag to indicate ghost elements or not
    */
     IntegerType getNumberOfIntegerVariablesOfElements(
         const std::vector<const MeshLib::Element*>& elements) const;

GeoLib/AnalyticalGeometry.h

@@ -195,10 +195,8 @@ bool parallel(MathLib::Vector3 v, MathLib::Vector3 w);
 /**
  * A line segment is given by its two end-points. The function checks,
  * if the two line segments (ab) and (cd) intersects.
- * @param a first end-point of the first line segment
- * @param b second end-point of the first line segment
- * @param c first end-point of the second line segment
- * @param d second end-point of the second line segment
+ * @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
  */

GeoLib/OctTree.h

@@ -86,6 +86,7 @@ class OctTree {
     /// private constructor
     /// @param ll lower left point
     /// @param ur upper right point
+    /// @param eps the euclidean distance as a threshold to make objects unique
     OctTree(MathLib::Point3d const& ll, MathLib::Point3d const& ur, double eps);
 
     enum class Quadrant : std::int8_t {

GeoLib/QuadTree.h

@@ -46,12 +46,13 @@ template <typename POINT> class QuadTree
      * (lower left and the upper right points).
      * @param ll lower left point of the square
      * @param ur upper right point of the square
+     * @param max_points_per_leaf maximum number of points per leaf
      */
-    QuadTree(POINT const& ll, POINT const& ur, std::size_t max_points_per_node) :
+    QuadTree(POINT const& ll, POINT const& ur, std::size_t max_points_per_leaf) :
         _father (nullptr), _ll (ll), _ur (ur), _depth (0), _is_leaf (true),
-        _max_points_per_node (max_points_per_node)
+        _max_points_per_leaf (max_points_per_leaf)
     {
-        assert (_max_points_per_node > 0);
+        assert (_max_points_per_leaf > 0);
 
         // init children
         for (std::size_t k(0); k < 4; k++)
@@ -110,7 +111,7 @@ template <typename POINT> class QuadTree
         else
             return false;
 
-        if (_pnts.size () > _max_points_per_node)
+        if (_pnts.size () > _max_points_per_leaf)
             splitNode ();
         return true;
     }
@@ -362,15 +363,16 @@ template <typename POINT> class QuadTree
      * @param ur upper right point
      * @param father father in the tree
      * @param depth depth of the node
+     * @param max_points_per_leaf maximum number of points per leaf
      * @return
      */
     QuadTree (POINT const& ll,
               POINT const& ur,
               QuadTree* father,
               std::size_t depth,
-              std::size_t max_points_per_node) :
+              std::size_t max_points_per_leaf) :
         _father (father), _ll (ll), _ur (ur), _depth (depth), _is_leaf (true),
-        _max_points_per_node (max_points_per_node)
+        _max_points_per_leaf (max_points_per_leaf)
     {
         // init children
         for (std::size_t k(0); k < 4; k++)
@@ -384,20 +386,20 @@ template <typename POINT> class QuadTree
         mid_point[0] += (_ur[0] - _ll[0]) / 2.0;
         mid_point[1] += (_ur[1] - _ll[1]) / 2.0;
         assert(_children[0] == nullptr);
-        _children[0] = new QuadTree<POINT> (mid_point, _ur, this, _depth + 1, _max_points_per_node); // north east
+        _children[0] = new QuadTree<POINT> (mid_point, _ur, this, _depth + 1, _max_points_per_leaf); // north east
         POINT h_ll(mid_point), h_ur(mid_point);
         h_ll[0] = _ll[0];
         h_ur[1] = _ur[1];
         assert(_children[1] == nullptr);
-        _children[1] = new QuadTree<POINT> (h_ll, h_ur, this, _depth + 1, _max_points_per_node); // north west
+        _children[1] = new QuadTree<POINT> (h_ll, h_ur, this, _depth + 1, _max_points_per_leaf); // north west
         assert(_children[2] == nullptr);
-        _children[2] = new QuadTree<POINT> (_ll, mid_point, this, _depth + 1, _max_points_per_node); // south west
+        _children[2] = new QuadTree<POINT> (_ll, mid_point, this, _depth + 1, _max_points_per_leaf); // south west
         h_ll = _ll;
         h_ll[0] = mid_point[0];
         h_ur = _ur;
         h_ur[1] = mid_point[1];
         assert(_children[3] == nullptr);
-        _children[3] = new QuadTree<POINT> (h_ll, h_ur, this, _depth + 1, _max_points_per_node); // south east
+        _children[3] = new QuadTree<POINT> (h_ll, h_ur, this, _depth + 1, _max_points_per_leaf); // south east
 
         // distribute points to sub quadtrees
         for (std::size_t j(0); j < _pnts.size(); j++) {
@@ -489,7 +491,7 @@ template <typename POINT> class QuadTree
     /**
      * maximum number of points per leaf
      */
-    const std::size_t _max_points_per_node;
+    const std::size_t _max_points_per_leaf;
 };
 }
 

GeoLib/StationBorehole.h

@@ -89,7 +89,7 @@ class StationBorehole : public Station
      * Note: The given coordinates always mark THE END of the soil layer. The reason behind this is
      * that the beginning of the first layer is identical with the position of the borehole. For each
      * layer following the beginning is already given by the end of the last layer. This also saves
-     * a seperate entry in the profile vector for the end of the borehole which in the given notation
+     * a separate entry in the profile vector for the end of the borehole which in the given notation
      * is just the coordinate given for the last soil layer (i.e. the end of that layer).
      */
     void addSoilLayer ( double x, double y, double z, const std::string &soil_name);

MaterialLib/Fluid/Density/LiquidDensity.h

@@ -51,13 +51,6 @@ namespace Fluid
 class LiquidDensity final : public FluidProperty
 {
 public:
-    /**
-     * @param beta \$f \beta \f$
-     * @param rho  \$f \rho_0 \f$
-     * @param T0   \$f T_0 \f$
-     * @param p0   \$f p_0 \f$
-     * @param E    \$f E \f$
-     */
     explicit LiquidDensity(const double beta, const double rho0,
                            const double T0, const double p0, const double E)
         : _beta(beta), _rho0(rho0), _temperature0(T0), _p0(p0), _bulk_modulus(E)

MaterialLib/PorousMedium/UnsaturatedProperty/CapillaryPressure/BrookCoreyCapillaryPressureSaturation.cpp

@@ -5,7 +5,7 @@
  *              See accompanying file LICENSE.txt or
  *              http://www.opengeosys.org/project/license
  *
- * \file   BrookCoreyCapillaryPressure.cpp
+ * \file
  *
  *  Created on November 1, 2016, 9:45 AM
  */

MathLib/InterpolationAlgorithms/PiecewiseLinearInterpolation.h

@@ -54,10 +54,8 @@ class PiecewiseLinearInterpolation final
      * \brief Calculates the interpolation value.
      * @param pnt_to_interpolate The point should be located within the range
      * \f$[x_{\min}, x_{\max}]\f$, where \f$x_{\min} = \min_{1 \le j \le n}
-     * x_j\f$ and
-     * \f$x_{\max} = \max_{1 \le j \le n} x_j\f$. Points outside of this
-     * interval are
-     * set to x_{\min} or x_{\max}.
+     * x_j\f$ and \f$x_{\max} = \max_{1 \le j \le n} x_j\f$. Points outside of
+     * this interval are set to \f$x_{\min}\f$ or \f$x_{\max}\f$.
      * @return The interpolated value.
      */
     double getValue(double pnt_to_interpolate) const;

MathLib/LinAlg/PETSc/PETScMatrix.h

@@ -249,11 +249,12 @@ class PETScMatrix
         PetscInt _end_rank;
 
         /*!
-          \brief Create the matrix, configure memory allocation and set the related member data.
-          \param Number of nonzeros per row in the diagonal portion of local submatrix
-                 (same value is used for all local rows),
-          \param Number of nonzeros per row in the off-diagonal portion of local submatrix
-                 (same value is used for all local rows)
+          \brief Create the matrix, configure memory allocation and set the
+          related member data.
+          \param d_nz Number of nonzeros per row in the diagonal portion of
+                      local submatrix (same value is used for all local rows),
+          \param o_nz Number of nonzeros per row in the off-diagonal portion of
+                      local submatrix (same value is used for all local rows)
         */
         void create(const PetscInt d_nz, const PetscInt o_nz);
 

MathLib/LinAlg/PETSc/PETScTools.h

@@ -27,12 +27,11 @@ namespace MathLib
 /*!
    \brief 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 penalty_scaling value for scaling some matrix and right hand side
-        entries to enforce some conditions
+   \param A              Coefficient matrix
+   \param b              RHS vector
+   \param x              Solution vector
+   \param vec_knownX_id  A vector of known solution entry IDs
+   \param vec_knownX_x   A vector of known solutions
 */
 void applyKnownSolution(PETScMatrix &A, PETScVector &b, PETScVector &x,
                         const std::vector<PetscInt> &vec_knownX_id,

MathLib/LinAlg/PETSc/PETScVector.h

@@ -282,8 +282,6 @@ class PETScVector
 
         /*!
            Get local vector, i.e. entries in the same rank
-           \param loc_vec  Pointer to array where stores the local vector,
-                           memory allocation is not needed
         */
         PetscScalar* getLocalVector() const;
 

MeshGeoToolsLib/HeuristicSearchLength.h

@@ -40,9 +40,11 @@ class HeuristicSearchLength : public SearchLength
     /**
      * Constructor
      * @param mesh  mesh object
-     * @param sampled_len  length type to be sampled
+     * @param length_type  length type to be sampled
      */
-    HeuristicSearchLength(MeshLib::Mesh const& mesh, LengthType length_type = LengthType::Edge);
+    HeuristicSearchLength(MeshLib::Mesh const& mesh,
+                          LengthType length_type = LengthType::Edge);
+
 private:
     MeshLib::Mesh const& _mesh;
 };

MeshGeoToolsLib/MeshNodeSearcher.h

@@ -56,6 +56,9 @@ class MeshNodeSearcher
      * internally used search length from the given MeshLib::Mesh.
      * @param mesh Run search algorithm on this mesh. It is assumed
      * that the mesh does not change its geometry.
+     * @param search_length_algorithm Algorithm to determine the search length.
+     * @param search_all_nodes switch between searching all mesh nodes and
+     * searching the base nodes.
      */
     explicit MeshNodeSearcher(MeshLib::Mesh const& mesh,
         MeshGeoToolsLib::SearchLength const& search_length_algorithm

MeshGeoToolsLib/MeshNodesAlongPolyline.h

@@ -40,12 +40,15 @@ class MeshNodesAlongPolyline
      * Constructor of object, that search mesh nodes along a
      * GeoLib::Polyline polyline within a given search radius. So the polyline
      * is something like a tube.
-     * @param mesh_nodes Nodes the search will be performed on.
+     * @param mesh Mesh the search will be performed on.
      * @param ply Along the GeoLib::Polyline ply the mesh nodes are searched.
      * @param epsilon_radius Search / tube radius
+     * @param search_all_nodes switch between searching all mesh nodes and
+     * searching the base nodes.
      */
     MeshNodesAlongPolyline(MeshLib::Mesh const& mesh,
-            GeoLib::Polyline const& ply, double epsilon_radius, bool search_all_nodes = true);
+                           GeoLib::Polyline const& ply, double epsilon_radius,
+                           bool search_all_nodes = true);
 
     /// return the mesh object
     MeshLib::Mesh const& getMesh() const;

MeshGeoToolsLib/MeshNodesAlongSurface.h

@@ -36,7 +36,7 @@ class MeshNodesAlongSurface
     /**
      * Constructor of object, that search mesh nodes along a
      * GeoLib::Surface object within a given search radius.
-     * @param mesh_nodes Nodes the search will be performed on.
+     * @param mesh Mesh the search will be performed on.
      * @param sfc Along the GeoLib::Surface sfc the mesh nodes are searched.
      * @param epsilon Euclidean distance tolerance value. Is the distance
      * between a mesh node and the surface smaller than that value it is a mesh

MeshLib/MeshEditing/MeshRevision.h

@@ -48,7 +48,7 @@ class MeshRevision {
      * Collapsed all nodes with distance < eps but ignores elements
      * (i.e. elements with collapsed nodes may result)
      * This is implicitely called when calling simplifyMesh(), so it does not need to be
-     * called seperately when using simplifyMesh().
+     * called separately when using simplifyMesh().
      */
     MeshLib::Mesh* collapseNodes(const std::string &new_mesh_name, double eps);