more documentation

Former-commit-id: 5a43eebe

code/include/common/globalconstants.h

 /*!
  * \file globalconstants.h
  * \brief All global defined (physical) constants, enums etc
- * \author <blank>
  * \version 0.0
  *
  */

code/include/common/mesh.h

@@ -122,7 +122,7 @@ class Mesh
     // Not used
     void ComputeSlopes( unsigned nq, VectorVector& psiDerX, VectorVector& psiDerY, const VectorVector& psi ) const;
 
-    /*! @briefStructured mesh slope reconstruction with flux limiters.
+    /*! @brief Structured mesh slope reconstruction with flux limiters.
      *  @param nq is number of quadrature points
      *  @param psiDerX is slope in x direction (gets computed. Slope is stored here)
      *  @param psiDerY is slope in y direction (gets computed. Slope is stored here)

code/include/entropies/entropybase.h

@@ -24,22 +24,15 @@ class EntropyBase
     virtual double EntropyPrime( double z ) = 0;
 
     /*! @brief computes the dual of the  entropy functional
-     *  @param z = point where the dual of the functional should be evaluated.
-     *          z must be in domain of the duaö functional
+     *  @param y point where the dual of the functional should be evaluated.
+     *          y must be in domain of the duaö functional
      *  @returns: value of entropy functional at z */
     virtual double EntropyDual( double y ) = 0;
 
-    // /*! @brief computes m*eta_*'(alpha*m). alpha*m must be in domain of the functional
-    //  *          alpha, m and grad must be of same size.
-    //  *  @param alpha = point where the derivative should be evaluated.
-    //  *  @param m = moment vector
-    //  *  @param grad: vector in which the resulting gradient is stored */
-    // virtual void EntropyPrimeDual( Vector& alpha, Vector& m, Vector& grad ) = 0;
-
     /*! @brief computes eta_*'(y).
      *  @param y = point where the derivative should be evaluated.
      *  @returns: value of the derivative of the  entropy functional at y */
-    virtual double EntropyPrimeDual( double z ) = 0;
+    virtual double EntropyPrimeDual( double y ) = 0;
 
     /*! @brief computes the hessian of the dual entropy functional
      *  @param y = point where the hessian should be evaluated;

code/include/fluxes/numericalflux.h

@@ -31,8 +31,7 @@ class NumericalFlux
      * @param psiL       Solution state of left hand side control volume
      * @param psiR       Solution state of right hand side control volume
      * @param n          Normal vector at the edge between left and right control volume
-     * @param resultFlux Vector with resulting flux.
-     * @return           void
+     * @return           Vector with resulting flux.
      */
     virtual Vector Flux( const Matrix AxPlus,
                          const Matrix AxMinus,
@@ -40,8 +39,8 @@ class NumericalFlux
                          const Matrix AyMinus,
                          const Matrix AzPlus,
                          const Matrix AzMinus,
-                         const Vector,
-                         const Vector,
+                         const Vector psiL,
+                         const Vector psiR,
                          const Vector n ) const = 0;
 
     virtual void FluxVanLeer( const Matrix& Ax,

code/include/optimizers/mloptimizer.h

@@ -16,22 +16,22 @@ class MLOptimizer : public OptimizerBase
 
     inline ~MLOptimizer();
 
-    void Solve( Vector& lambda, Vector& u, const VectorVector& moments, unsigned idx_cell = 0 ) override;
-    void SolveMultiCell( VectorVector& lambda, VectorVector& u, const VectorVector& moments ) override;
+    void Solve( Vector& alpha, Vector& u, const VectorVector& moments, unsigned idx_cell = 0 ) override;
+    void SolveMultiCell( VectorVector& alpha, VectorVector& u, const VectorVector& moments ) override;
 
   private:
     /*! @brief Calls the tensorflow neural network for the entropy closure
-     *  @param inputDim : dimension of moment vector for a single cell
-     *  @param double* nnInput : moment vector as double array
-     *  @return Lagrange multiplyer alpha with size input_size
+     *  @param inputDim  dimension of moment vector for a single cell
+     *  @param nnInput  moment vector as double array (input to the neural network)
+     *  @return alpha Lagrange multiplyer  with size input_size
      */
     double* callNetwork( const unsigned inputDim, double* nnInput );
 
     /*! @brief Calls the tensorflow neural network for the entropy closure for the whole mesh
-     *  @param batchSize : number of cells in the mesh ==> batchsize for the network
-     *  @param inputDim : dimension of moment vector for a single cell
-     *  @param double* nnInput : moment vector as double array
-     *  @return Lagrange multiplyer alpha with size input_size
+     *  @param batchSize  number of cells in the mesh ==> batchsize for the network
+     *  @param inputDim  dimension of moment vector for a single cell
+     *  @param nnInput moment vector as double array (input to the neural network)
+     *  @return alpha Lagrange multiplyer  with size input_size
      */
     double* callNetworkMultiCell( const unsigned batchSize, const unsigned inputDim, double* nnInput );
 

code/include/optimizers/optimizerbase.h

@@ -23,16 +23,22 @@ class OptimizerBase
     /*! @brief Optimizer creator: Depending on the chosen option, this function creates an object of the chosen child class of OptimizerBase */
     static OptimizerBase* Create( Config* settings );
 
-    /*! @brief   Computes the optimal Lagrange multilpiers for the dual entropy minimization problem
-     *  @param   Vector  u = pointer to vector of given moments. // Maybe use pointer for performance?
-     *  @return  Vector  alpha = optimal lagrange multipliers. Has the same length as Vector u. */
-    virtual void Solve( Vector& lambda, Vector& u, const VectorVector& moments, unsigned idx_cell = 0 ) = 0;
+    /*! @brief  Computes the optimal Lagrange multilpiers for the dual entropy minimization problem
+     *  @param  alpha vector where the solution Lagrange multipliers are saved to.
+     *  @param  u  moment vector
+     *  @param  moments  VectorVector to the moment basis evaluated at all quadpoints
+     *  @param idx_cell index of the cell where alpha should be computed (out of u) */
+    virtual void Solve( Vector& alpha, Vector& u, const VectorVector& moments, unsigned idx_cell = 0 ) = 0;
 
-    virtual void SolveMultiCell( VectorVector& lambda, VectorVector& u, const VectorVector& moments ) = 0;
+    /*! @brief   Computes the optimal Lagrange multilpiers for the dual entropy minimization problem
+     *  @param   alpha vector where the solution Lagrange multipliers are saved to.
+     *  @param   u  moment vector
+     *  @param   moments  VectorVector to the moment basis evaluated at all quadpoints    */
+    virtual void SolveMultiCell( VectorVector& alpha, VectorVector& u, const VectorVector& moments ) = 0;
 
   protected:
     EntropyBase* _entropy; /*!< @brief Class to handle entropy functional evaluations */
-    Config* _settings;     /*!< @biref: Pointer to settings class of the solver */
+    Config* _settings;     /*!< @brief Pointer to settings class of the solver */
 };
 
 #endif    // OPTIMIZERBASE_H

code/include/problems/electronrt.h

@@ -20,13 +20,18 @@ class ElectronRT : public ProblemBase
     ElectronRT( Config* settings, Mesh* mesh );
     virtual ~ElectronRT();
 
-    virtual VectorVector GetScatteringXS( const Vector& energies );
-    virtual VectorVector GetTotalXS( const Vector& energies );
-    virtual std::vector<Matrix> GetScatteringXSE( const Vector& energies, const Matrix& angles );
-    virtual Vector GetTotalXSE( const Vector& energies );
-    virtual std::vector<VectorVector> GetExternalSource( const Vector& energies );
-    virtual VectorVector SetupIC();
-    std::vector<double> GetDensity( const VectorVector& cellMidPoints );
+    VectorVector GetScatteringXS( const Vector& energies ) override;
+    VectorVector GetTotalXS( const Vector& energies ) override;
+    std::vector<Matrix> GetScatteringXSE( const Vector& energies, const Matrix& angles ) override;
+    /**
+     * @brief GetTotalXSE gives back vector of total cross sections for
+     *        energies in vector energy
+     * @param energies is the energy the cross section is queried for
+     */
+    Vector GetTotalXSE( const Vector& energies ) override;
+    std::vector<VectorVector> GetExternalSource( const Vector& energies ) override;
+    VectorVector SetupIC() override;
+    std::vector<double> GetDensity( const VectorVector& cellMidPoints ) override;
 };
 
 #endif    // ELECTRONRT_H

code/include/problems/epics.h

@@ -53,8 +53,6 @@ class EPICS
     /**
      * @brief GetStoppingPower gives back vector of vectors of stopping powers for materials defined by density and energies in vector energy
      * @param energies is vector with energies
-     * @param density is vector with patient densities (at different spatial cells)
-     * @param sH2O is vector of stopping powers in water
      */
     Vector GetStoppingPower( Vector energies );
 

code/include/problems/icru.h

@@ -66,7 +66,7 @@ class ICRU
     double _R1;
 
     Vector _E, /*! @brief User queried Energy  */
-        _QMU;  /*!< @briefUser queried mu */
+        _QMU;  /*!< @brief User queried mu */
 
     std::vector<double> _ET, _ETL;
     std::vector<double> _XMU, /* angular variable mu of dataset */

code/include/problems/linesource.h

@@ -16,27 +16,30 @@ class LineSource : public ProblemBase
 
     ~LineSource();
 
-    /*!< @brief Exact analytical solution for the Line Source Test Case at
-         @param x: x coordinate of exact solution
-                 y: y coordinate of exact solution
-                 t: time of the exact solution
-                 sigma_s: scattering cross section of the exact solution
+    /*! @brief Exact analytical solution for the Line Source Test Case at
+         @param x coordinate of exact solution
+         @param y coordinate of exact solution
+         @param t time of the exact solution
+         @param sigma_s  scattering cross section of the exact solution
          @return exact solution at x,y,t,scatteringXS
     */
     double GetAnalyticalSolution( double x, double y, double t, double sigma_s ) override;
 
   private:
-    /*!< @brief Helper Functions to compute the analytic solution for sigma != 0
+    /*! @brief Helper Functions to compute the analytic solution for sigma != 0
      * (See publication: Garret,Hauck; Momentum Closures for Linear Kinetic Transport Equations)
-         @param R = distance to origin
-         @param t = time
-         @param sigma = R/t
+         @param R distance to origin
+         @param t time
      */
     double HelperIntRho_ptc( double R, double t );
-    double HelperRho_ptc( double R, double t );
-    double HelperRho_ptc1( double R, double t );
-    double HelperRho_ptc2( double R, double t );
-    double HelperIntRho_ptc2( double t, double gamma );
+    double HelperRho_ptc( double R,
+                          double t ); /*!< @brief helper to comput analytic line source solution. @param R distance to origin @param t time */
+    double HelperRho_ptc1( double R,
+                           double t ); /*!< @brief helper to comput analytic line source solution. @param R distance to origin @param t time */
+    double HelperRho_ptc2( double R,
+                           double t ); /*!< @brief helper to comput analytic line source solution. @param R distance to origin @param t time */
+    double HelperIntRho_ptc2( double t,
+                              double gamma ); /*!< @brief helper to comput analytic line source solution @param t time @param gamma equals R/t */
 };
 
 class LineSource_SN : public LineSource
@@ -48,10 +51,10 @@ class LineSource_SN : public LineSource
     LineSource_SN( Config* settings, Mesh* mesh );
     ~LineSource_SN();
 
-    virtual VectorVector GetScatteringXS( const Vector& energies );
-    virtual VectorVector GetTotalXS( const Vector& energies );
-    virtual std::vector<VectorVector> GetExternalSource( const Vector& energies );
-    virtual VectorVector SetupIC();
+    virtual VectorVector GetScatteringXS( const Vector& energies ) override;
+    virtual VectorVector GetTotalXS( const Vector& energies ) override;
+    virtual std::vector<VectorVector> GetExternalSource( const Vector& energies ) override;
+    virtual VectorVector SetupIC() override;
 };
 
 class LineSource_SN_Pseudo1D : public LineSource_SN
@@ -74,6 +77,12 @@ class LineSource_SN_Pseudo1D_Physics : public LineSource_SN_Pseudo1D
     LineSource_SN_Pseudo1D_Physics( Config* settings, Mesh* mesh );
 
     std::vector<Matrix> GetScatteringXSE( const Vector& energies, const Matrix& angles ) override;
+
+    /**
+     * @brief GetTotalXSE gives back vector of total cross sections for
+     *        energies in vector energy
+     * @param energies is the energy the cross section is queried for
+     */
     Vector GetTotalXSE( const Vector& energies ) override;
 };
 

code/include/problems/problembase.h

@@ -27,29 +27,28 @@ class ProblemBase
      * @brief GetScatteringXS gives back vector (each energy) of vectors (each grid cell)
      *        of scattering cross sections for materials defined by density and energies
      *        in vector energy
-     * @param energy is the energy the cross section is queried for
+     * @param energies is the energy the cross section is queried for
      */
     virtual VectorVector GetScatteringXS( const Vector& energies ) = 0;
 
     /**
      * @brief GetTotalXS gives back vector of vectors of total cross sections for
      *        materials defined by density and energies in vector energy
-     * @param energy is the energy the cross section is queried for
-     * @param density is vector with patient densities (at different spatial cells)
+     * @param energies is the energy the cross section is queried for
      */
     virtual VectorVector GetTotalXS( const Vector& energies ) = 0;
 
     /**
      * @brief GetTotalXSE gives back vector of total cross sections for
      *        energies in vector energy
-     * @param energy is the energy the cross section is queried for
      */
     virtual Vector GetTotalXSE( const Vector& /*energies*/ ) { return Vector( 1 ); }
 
     /**
      * @brief GetScatteringXSE gives back vector (each energy) of scattering cross sections for energies
      *        in vector energy
-     * @param energy is the energy the cross section is queried for
+     * @param energies is the energy the cross section is queried for
+     * @param angles are the queried angles
      */
     virtual std::vector<Matrix> GetScatteringXSE( const Vector& energies, const Matrix& angles ) {
         return std::vector<Matrix>( energies.size(), Matrix( angles.rows(), angles.columns() ) );
@@ -58,14 +57,15 @@ class ProblemBase
     /**
      * @brief GetScatteringXSE gives back vector (each energy) of scattering cross sections for energies
      *        in vector energy
-     * @param energy is the energy the cross section is queried for
+     * @param energies is the energy the cross section is queried for
+     * @param angles are the queried angles
      */
     virtual VectorVector GetScatteringXSE( const Vector& energies, const Vector& angles );
 
     /**
      * @brief GetExternalSource gives back vector of vectors of source terms for each
      *        energy, cell and angle
-     * @param energies is vector with energies
+     * @param energies is the energy the cross section is queried for
      */
     virtual std::vector<VectorVector> GetExternalSource( const Vector& energies ) = 0;
 
@@ -87,11 +87,7 @@ class ProblemBase
      */
     virtual VectorVector SetupIC() = 0;
 
-    /*! @brief Exact analytical solution for the Line Source Test Case at
-        @param x: x coordinate of exact solution
-                y: y coordinate of exact solution
-                t: time of the exact solution
-                scatteringXS: scattering cross section of the exact solution
+    /*! @brief Exact analytical solution for the Line Source Test Case. Returns 0 for all other test cases.
          @return exact solution at x,y,t,scatteringXS
     */ // Default is set to 0. ~> if no analytical solution is available.
     double virtual GetAnalyticalSolution( double /*x*/, double /*y*/, double /*t*/, double /*scatteringXS*/ ) { return 0.0; }
@@ -99,6 +95,7 @@ class ProblemBase
     /**
      * @brief Physics constructor
      * @param settings stores all needed user information
+     * @param mesh for the test case
      */
     ProblemBase( Config* settings, Mesh* mesh );
     virtual ~ProblemBase();
@@ -106,7 +103,8 @@ class ProblemBase
     /**
      * @brief Create constructor
      * @param settings stores all needed information
-     * @return pointer to Physics
+     * @param mesh for the test case
+     * @return pointer to ProblemBase
      */
     static ProblemBase* Create( Config* settings, Mesh* mesh );
 };

code/include/quadratures/qgausschebyshev1D.h

@@ -28,7 +28,7 @@ class QGaussChebyshev1D : public QuadratureBase
     void SetConnectivity() override;
 
     /*! @brief Integrates f(x,y,z) with the quadrature.
-     *  @param double(f)( double x0, double x1, double x2 ) : density function that depends on a three spatial dimensions.
+     *  @param double (f)( double x0, double x1, double x2 ) : density function that depends on a three spatial dimensions.
      *  @returns double result: result of the quadrature rule */
     double Integrate( double( f )( double x0, double x1, double x2 ) ) override;
 

code/include/quadratures/quadraturebase.h

@@ -50,7 +50,7 @@ class QuadratureBase
 
     // Quadrature Hub
     /*! @brief Creates a quadrature rule with a given name and a given order.
-     *  @param Config* settings: Settings to handle quadrature options
+     *  @param  settings  Settings to handle quadrature options
      *  @returns Quadrature* quadrature: returns pointer to instance of the given derived quadrature class */
     static QuadratureBase* Create( Config* settings );
 

code/include/toolboxes/datageneratorbase.h

@@ -27,8 +27,8 @@ class DataGeneratorBase
     ~DataGeneratorBase();
 
     /*! @brief Create a datagenerator (1D or 3D)
-     *  @param Pointer to the config file
-     *  @returns: Pointer to the createt basis class */
+     *  @param settings Pointer to the config file
+     *  @returns Pointer to the createt basis class */
     static DataGeneratorBase* Create( Config* settings );
 
     /*! @brief computes the training data set.

code/include/toolboxes/interpolation.h

@@ -14,9 +14,10 @@ class Interpolation
 
   private:
     unsigned _dim;
-    Vector _x, _y;
-    Matrix _data;
-    TYPE _type;
+    Vector _x;    /*!< @brief x input data */
+    Vector _y;    /*!< @brief y input data */
+    Matrix _data; /*!< @brief data matrix w.r.t. x and y grid */
+    TYPE _type;   /*!< @brief type of interpolation (linear, loglinear, cubic) */
 
     Interpolation() = delete;
 
@@ -53,9 +54,10 @@ class Interpolation
 
     /*!
      * @brief constructor cubic interpolation
-     * @param[in] x - table values for x
-     * @param[in] y - table values for y
-     * @param[in] type - linear or cubic interpolation
+     * @param[in] x table values for x
+     * @param[in] y table values for y
+     * @param[in] data matrix w.r.t x y grid
+     * @param[in] type of interpolation  (linear, loglinear, cubic)
      */
     Interpolation( const Vector& x, const Vector& y, const Matrix& data, TYPE type = cubic );
 
@@ -63,21 +65,21 @@ class Interpolation
     /*!
      * @brief defines one dimensional interpolation at x
      * @param[in] x - value at which to interpolate
-     * @param[out] y - corresponding interpolated y value
+     * @returns y - corresponding interpolated y value
      */
     double operator()( double x ) const;
 
     /*!
      * @brief defines interpolation for a Vector of values
      * @param[in] v - values at which to interpolate
-     * @param[out] y - corresponding interpolated values
+     * @returns y - corresponding interpolated values
      */
     Vector operator()( Vector v ) const;
 
     /*!
      * @brief defines interpolation for a std::vector of values
      * @param[in] v - values at which to interpolate
-     * @param[out] y - corresponding interpolated values
+     * @returns y - corresponding interpolated values
      */
     std::vector<double> operator()( std::vector<double> v ) const;
 
@@ -85,7 +87,7 @@ class Interpolation
      * @brief defines 2D interpolation at x and y
      * @param[in] x - value at which to interpolate
      * @param[in] y - value at which to interpolate
-     * @param[out] data - corresponding interpolated value
+     * @returns data - corresponding interpolated value
      */
     double operator()( double x, double y ) const;
 };

code/include/toolboxes/sphericalharmonics.h

@@ -18,31 +18,33 @@
 class SphericalHarmonics : public SphericalBase
 {
   public:
-    /*! @brief : Sets up class for spherical harmonics basis based on legendre
-     *           polynoms and associated legendre polynoms up to degree L.
-     *           The basis then consists of N = L² +2L basis functions.
-     *  @param : L_degree - maximum degree of spherical harmonics basis, 0 <= L <= 1000 (upper bound
+    /*! @brief Sets up class for spherical harmonics basis based on legendre
+     *         polynoms and associated legendre polynoms up to degree L.
+     *         The basis then consists of N = L² +2L basis functions.
+     *  @param L_degree - maximum degree of spherical harmonics basis, 0 <= L <= 1000 (upper bound
      *                      due to numerical stability)
      * */
     SphericalHarmonics( unsigned L_degree );
 
-    /*! @brief  : Computes all N = L² +2L basis functions at point (my, phi)
-     *  @param  : my = cos(theta) - spherical coordinate, -1 <= x <= 1
-     *  @param  : phi - spherical coordinate, 0 <= phi <= 2*pi
-     *  @return : vector of basis functions at point (my, phi) with size N = L² +2L
+    /*! @brief  Computes all N = L² +2L basis functions at point (my, phi)
+     *  @param  my = cos(theta) - spherical coordinate, -1 <= x <= 1
+     *  @param  phi - spherical coordinate, 0 <= phi <= 2*pi
+     *  @return vector of basis functions at point (my, phi) with size N = L² +2L
      */
     Vector ComputeSphericalBasis( double my, double phi ) override;
 
-    /*! @brief  : Computes all N = L² +2L basis functions at point (x, y, z) on the unit sphere
-     *  @param  : x,y,z = coordinates on unit sphere
-     *  @return : vector of basis functions at point (x,y,z) with size N = L² +2L
+    /*! @brief   Computes all N = L² +2L basis functions at point (x, y, z) on the unit sphere
+     *  @param   x coordinates on unit sphere
+     *  @param   y coordinates on unit sphere
+     *  @param   z coordinates on unit sphere
+     *  @return  vector of basis functions at point (x,y,z) with size N = L² +2L
      */
     Vector ComputeSphericalBasis( double x, double y, double z ) override;
 
-    /*! @brief : Computes an entire set of (komplex congjugate) P_l^k and stores
-     *           it in the vector _assLegendreP
-     *  @param : my = cos(theta)  - spherical coordinate, -1 <=  my <= 1
-     *  @return : Associated Legendre Polynomial at my for all l and k
+    /*! @brief  Computes an entire set of (komplex congjugate) P_l^k and stores
+     *          it in the vector _assLegendreP
+     *  @param  my = cos(theta)  - spherical coordinate, -1 <=  my <= 1
+     *  @return  Associated Legendre Polynomial at my for all l and k
      */
     std::vector<double> GetAssLegendrePoly( const double my );
 
@@ -53,10 +55,10 @@ class SphericalHarmonics : public SphericalBase
      *  @param currDegreeL = degree of polynomials that are counted   */
     unsigned GetCurrDegreeSize( unsigned currDegree ) override;
 
-    /*! @brief : helper function to get the global index for given k and l of
-     *           the basis function Y_k^l.
-     *  @param : l_degree - current degree of basis function, 0 <= l <= L
-     *  @param : k_order  - current order of basis function,  -l <= k <= l      */
+    /*! @brief  helper function to get the global index for given k and l of
+     *          the basis function Y_k^l.
+     *  @param  l_degree - current degree of basis function, 0 <= l <= L
+     *  @param  k_order  - current order of basis function,  -l <= k <= l      */
     unsigned GetGlobalIndexBasis( int l_degree, int k_order ) override;
 
   private:
@@ -81,20 +83,20 @@ class SphericalHarmonics : public SphericalBase
      */
     Vector _YBasis;
 
-    /*! @brief : helper function to get the global index for given k and l of
-     *           the associated legendre polynomial P_k^l.
-     *  @param : l_degree - current degree of basis function, 0 <= l <= L
-     *  @param : k_order  - current order of basis function,  0 <= k <= l
+    /*! @brief  helper function to get the global index for given k and l of
+     *          the associated legendre polynomial P_k^l.
+     *  @param  l_degree - current degree of basis function, 0 <= l <= L
+     *  @param  k_order  - current order of basis function,  0 <= k <= l
      */
     unsigned inline GlobalIdxAssLegendreP( unsigned l_degree, unsigned k_order ) { return k_order + ( l_degree * ( l_degree + 1 ) ) / 2; }
 
-    /*! @brief : computes values of a_param and b_param
+    /*! @brief  computes values of a_param and b_param
      */
     void ComputeCoefficients();
 
-    /*! @brief : Computes an entire set of (komplex congjugate) P_l^k and stores
-     *           it in the vector _assLegendreP
-     *  @param : my = cos(theta)  - spherical coordinate, -1 <=  my <= 1
+    /*! @brief  Computes an entire set of (komplex congjugate) P_l^k and stores
+     *          it in the vector _assLegendreP
+     *  @param  my  equals cos(theta)  - spherical coordinate, -1 <=  my <= 1
      */
     void ComputeAssLegendrePoly( const double my );
 

code/include/toolboxes/sphericalmonomials.h

@@ -21,24 +21,26 @@ class SphericalMonomials : public SphericalBase
      * */
     SphericalMonomials( unsigned L_degree );
 
-    /*! @brief : Sets up class for monomial basis on sphere up to degree L.
-     *           The basis then consists of N = L.
-     *  @param : L_degree - maximum degree of spherical harmonics basis, 0 <= L <= 1000 (upper bound
-     *                      due to numerical stability)
-     *  @param : spatialDim - spatial dimensioniality of the simulation
+    /*! @brief Sets up class for monomial basis on sphere up to degree L.
+     *         The basis then consists of N = L.
+     *  @param L_degree - maximum degree of spherical harmonics basis, 0 <= L <= 1000 (upper bound
+     *                    due to numerical stability)
+     *  @param spatialDim - spatial dimensioniality of the simulation
      * */
     SphericalMonomials( unsigned L_degree, unsigned short spatialDim );
 
-    /*! @brief  : Computes all N = L² +2L basis functions at point (my, phi)
-     *  @param  : my = cos(theta) - spherical coordinate, -1 <= x <= 1
-     *  @param  : phi - spherical coordinate, 0 <= phi <= 2*pi
-     *  @return : vector of basis functions at point (my, phi) with size N = L² +2L
+    /*! @brief  Computes all N = L² +2L basis functions at point (my, phi)
+     *  @param  my = cos(theta) - spherical coordinate, -1 <= x <= 1
+     *  @param  phi - spherical coordinate, 0 <= phi <= 2*pi
+     *  @return vector of basis functions at point (my, phi) with size N = L² +2L
      */
     Vector ComputeSphericalBasis( double my, double phi ) override;
 
-    /*! @brief  : Computes all N = L² +2L basis functions at point (x, y, z) on the unit sphere
-     *  @param  : x,y,z = coordinates on unit sphere
-     *  @return : vector of basis functions at point (x,y,z) with size N = L² +2L
+    /*! @brief Computes all N = L² +2L basis functions at point (x, y, z) on the unit sphere
+     *  @param x = coordinates on unit sphere
+     *  @param y = coordinates on unit sphere
+     *  @param z = coordinates on unit sphere
+     *  @return vector of basis functions at point (x,y,z) with size N = L² +2L
      */
     Vector ComputeSphericalBasis( double x, double y, double z ) override;
 

code/include/toolboxes/textprocessingtoolbox.h

@@ -42,7 +42,7 @@ inline std::vector<std::string> Split( const std::string& s, char delimiter ) {
 
 /*!
  * \brief utility function for printing a VectorVector
- * \param [in] VectorVector we want to print
+ * \param vectorIn VectorVector we want to print
  */
 inline void PrintVectorVector( const VectorVector vectorIn ) {
     unsigned dimOuter = vectorIn.size();
@@ -61,14 +61,14 @@ inline void PrintVectorVector( const VectorVector vectorIn ) {
 
 /*!
  * \brief utility function for returning the last number in a string
- * \param [in] string to be checked
+ * \param str string to be checked
  */
 inline int GetTrailingNumber( std::string const& str ) { return std::stoi( str.substr( str.find_first_of( "0123456789" ), str.length() - 1 ) ); }
 
 /*!
  * \brief utility function for checking if a string has a certain ending
- * \param [in] string to be checked
- * \param [in] ending to be checked for
+ * \param value string to be checked
+ * \param ending string to be checked for
  */
 inline bool StringEndsWith( std::string const& value, std::string const& ending ) {
     if( ending.size() > value.size() ) return false;

code/src/fluxes/upwindflux.cpp

@@ -13,18 +13,18 @@ double UpwindFlux::Flux( const Vector& Omega, double psiL, double psiR, const Ve
 }
 
 /**
- * @brief Flux      : Computes <Linear> upwinding scheme for given flux jacobians of the PN Solver at a given edge and stores it in
+ * @brief Flux        Computes <Linear> upwinding scheme for given flux jacobians of the PN Solver at a given edge and stores it in
  *                    resultFlux
- * @param AxPlus    : Positive part of the flux jacobian in x direction
- * @param AxMinus   : Negative part of the flux jacobian in x direction
- * @param AyPlus    : Positive part of the flux jacobian in y direction
- * @param AyMinus   : Negative part of the flux jacobian in y direction
- * @param AzPlus    : Positive part of the flux jacobian in z direction
- * @param AzMinus   : Negative part of the flux jacobian in z direction
- * @param psiL      : Solution state of left hand side control volume
- * @param psiR      : Solution state of right hand side control volume
- * @param n         : Normal vector at the edge between left and right control volume
- * @return resultFlux: Vector with resulting flux.
+ * @param AxPlus      Positive part of the flux jacobian in x direction
+ * @param AxMinus     Negative part of the flux jacobian in x direction
+ * @param AyPlus      Positive part of the flux jacobian in y direction
+ * @param AyMinus     Negative part of the flux jacobian in y direction
+ * @param AzPlus      Positive part of the flux jacobian in z direction
+ * @param AzMinus     Negative part of the flux jacobian in z direction
+ * @param psiL        Solution state of left hand side control volume