resolved all doxygen/sphinx warnings

Former-commit-id: 00c2b208

code/include/fluxes/upwindflux.h

@@ -34,8 +34,7 @@ class UpwindFlux : public 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
      */
     Vector Flux( const Matrix AxPlus,
                  const Matrix AxMinus,
@@ -50,12 +49,12 @@ class UpwindFlux : public NumericalFlux
     /**
      * @brief Flux       Computes "VanLeer" 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 Ax         Flux jacobian in x direction
+     * @param AxAbs      Absolute value of the flux jacobian in x direction
+     * @param Ay         Flux jacobian in y direction
+     * @param AyAbs      Absolute value of the flux jacobian in y direction
+     * @param Az         Flux jacobian in z direction
+     * @param AzAbs      Absolute value 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

code/include/quadratures/qgausschebyshev1D.h

@@ -28,20 +28,19 @@ 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.
-     *  @returns double result: result of the quadrature rule */
-    double Integrate( double( f )( double x0, double x1, double x2 ) ) override;
+     *  @param f density function that depends on a three spatial dimensions.
+     *  @returns result of the quadrature rule */
+    double Integrate( double ( *f )( double, double, double ) ) override;
 
     /*! @brief Integrates f(x,y,z) with the quadrature.
-     *  @param double(f)( double my, double phi ) : density function that depends on a spherical coordinates.
-     *  @returns double result: result of the quadrature rule */
-    double IntegrateSpherical( double( f )( double my, double phi ) ) override;
+     *  @param f density function that depends on a spherical coordinates.
+     *  @returns result of the quadrature rule */
+    double IntegrateSpherical( double ( *f )( double, double ) ) override;
 
     /*! @brief Integrates vector valued f(x,y,z) with the quadrature. Each dimension is integrated by itself.
-     *  @param : double(f)( double x0, double x1, double x2 ) : density function that depends on a three spatial dimensions.
-     *  @param :  len : lenght of vector
-     *  @returns double result: result of the quadrature rule (vector valued) */
-    std::vector<double> Integrate( std::vector<double>( f )( double x0, double x1, double x2 ), unsigned /* len */ ) override;
+     *  @param f density function that depends on a three spatial dimensions.
+     *  @returns result of the quadrature rule (vector valued) */
+    std::vector<double> Integrate( std::vector<double> ( *f )( double, double, double ), unsigned /* len */ ) override;
 };
 
 #endif    // QGAUSSCHEBYSHEV_H

code/include/quadratures/qgausslegendre1D.h

@@ -29,20 +29,19 @@ class QGaussLegendre1D : 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.
-     *  @returns double result: result of the quadrature rule */
-    double Integrate( double( f )( double x0, double x1, double x2 ) ) override;
+     *  @param f density function that depends on a three spatial dimensions.
+     *  @returns result of the quadrature rule */
+    double Integrate( double ( *f )( double, double, double ) ) override;
 
     /*! @brief Integrates f(x,y,z) with the quadrature.
-     *  @param double(f)( double my, double phi ) : density function that depends on a spherical coordinates.
-     *  @returns double result: result of the quadrature rule */
-    double IntegrateSpherical( double( f )( double my, double phi ) ) override;
+     *  @param f density function that depends on a spherical coordinates.
+     *  @returns result of the quadrature rule */
+    double IntegrateSpherical( double ( *f )( double, double ) ) override;
 
     /*! @brief Integrates vector valued f(x,y,z) with the quadrature. Each dimension is integrated by itself.
-     *  @param : double(f)( double x0, double x1, double x2 ) : density function that depends on a three spatial dimensions.
-     *  @param :  len : lenght of vector
-     *  @returns double result: result of the quadrature rule (vector valued) */
-    std::vector<double> Integrate( std::vector<double>( f )( double x0, double x1, double x2 ), unsigned /* len */ ) override;
+     *  @param f density function that depends on a three spatial dimensions.
+     *  @returns result of the quadrature rule (vector valued) */
+    std::vector<double> Integrate( std::vector<double> ( *f )( double, double, double ), unsigned /* len */ ) override;
 };
 
 #endif    // QGAUSSLEGENDRE1D_H

code/include/quadratures/quadraturebase.h

@@ -15,7 +15,7 @@ class QuadratureBase
 {
   public:
     /*! @brief Constructor using settings class. This is the recommended constructor.
-     *  @param Config* settings: Settings class storing all important options.
+     *  @param settings Settings class storing all important options.
      */
     QuadratureBase( Config* settings );
     /*! @brief Constructor using directly the order of the quadrature. Not applicable for GaussLegendre, that need additional options.
@@ -33,20 +33,20 @@ class QuadratureBase
     double SumUpWeights();
 
     /*! @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.
-     *  @returns double result: result of the quadrature rule */
-    virtual double Integrate( double( f )( double x0, double x1, double x2 ) );
+     *  @param f density function that depends on a three spatial dimensions.
+     *  @returns result of the quadrature rule */
+    virtual double Integrate( double ( *f )( double, double, double ) );
 
     /*! @brief Integrates f(x,y,z) with the quadrature.
-     *  @param double(f)( double my, double phi ) : density function that depends on a spherical coordinates.
-     *  @returns double result: result of the quadrature rule */
-    virtual double IntegrateSpherical( double( f )( double my, double phi ) );
+     *  @param f density function that depends on a spherical coordinates.
+     *  @returns result of the quadrature rule */
+    virtual double IntegrateSpherical( double ( *f )( double, double ) );
 
     /*! @brief Integrates vector valued f(x,y,z) with the quadrature. Each dimension is integrated by itself.
-     *  @param : double(f)( double x0, double x1, double x2 ) : density function that depends on a three spatial dimensions.
-     *  @param :  len : lenght of vector
-     *  @returns double result: result of the quadrature rule (vector valued) */
-    virtual std::vector<double> Integrate( std::vector<double>( f )( double x0, double x1, double x2 ), unsigned len );
+     *  @param f density function that depends on a three spatial dimensions.
+     *  @param len lenght of vector
+     *  @returns result of the quadrature rule (vector valued) */
+    virtual std::vector<double> Integrate( std::vector<double> ( *f )( double, double, double ), unsigned len );
 
     // Quadrature Hub
     /*! @brief Creates a quadrature rule with a given name and a given order.
@@ -55,9 +55,9 @@ class QuadratureBase
     static QuadratureBase* Create( Config* settings );
 
     /*! @brief Creates a quadrature rule with a given name and a given order.
-     *  @param name: name of quadrature as enum
-     *  @param quadOrder: order of quadrature
-     *  @returns Quadrature* quadrature: returns pointer to instance of the given derived quadrature class */
+     *  @param name name of quadrature as enum
+     *  @param quadOrder order of quadrature
+     *  @returns pointer to instance of the given derived quadrature class */
     static QuadratureBase* Create( QUAD_NAME name, unsigned quadOrder );
 
     // Getter

code/include/toolboxes/reconstructor.h

@@ -30,22 +30,14 @@ class Reconstructor
 
     /*! Method 1: structured developing
      * @brief Slope of angular flux psi inside a given cell
-     * @param Omega fixed ordinate for flux computation
-     * @param psiL left solution state
-     * @param psiR right solution state
-     * @param n scaled normal vector of given edge
+     * @param uL left solution state
+     * @param uC center solution state
+     * @param uR right solution state
+     * @param dxL left slope
+     * @param dxR right slope
+     * @param limiter name of the applied limiter (invalid argument results in disabled limiter)
      * @return reconstructed slope
      */
-
-    /** Method 2: unstructured developing
-     * @brief Slope of angular flux psi inside a given cell
-     * @param Omega fixed ordinate for flux computation
-     * @param psiL left solution state
-     * @param psiR right solution state
-     * @param n scaled normal vector of given edge
-     * @return reconstructed slope
-     */
-
     virtual double ReconstructSlopeStruct( double uL, double uC, double uR, double dxL, double dxR, std::string limiter ) const;
 };
 

code/include/toolboxes/sphericalbase.h

@@ -18,24 +18,25 @@ class SphericalBase
     virtual ~SphericalBase() {}
 
     /*! @brief Create a set of basis functions on the unit sphere defined in settings
-     *  @param Pointer to the config file
-     *  @returns: Pointer to the createt basis class */
+     *  @param settings pointer to the config object
+     *  @returns Pointer to the createt basis class
+     */
     static SphericalBase* Create( Config* settings );
 
-    /*! @brief  : Computes all N 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
+    /*! @brief  Computes all N 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
      */
     virtual Vector ComputeSphericalBasis( double my, double phi ) = 0;
 
-    /*! @brief  : Computes all 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
+    /*! @brief  Computes all 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
      */
     virtual Vector ComputeSphericalBasis( double x, double y, double z ) = 0;
 
-    /*! @brief : Return size of complete Basisvector */
+    /*! @brief Return size of complete Basisvector */
     virtual unsigned GetBasisSize() = 0;
 
     /*! @brief Return number of basis functions with degree equals to currDegree

code/include/toolboxes/sphericalharmonics.h

@@ -52,7 +52,7 @@ class SphericalHarmonics : public SphericalBase
     unsigned GetBasisSize() override;
 
     /*! @brief Return number of basis functions with degree equals to currDegree
-     *  @param currDegreeL = degree of polynomials that are counted   */
+     *  @param currDegree 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
@@ -102,7 +102,7 @@ class SphericalHarmonics : public SphericalBase
 
     /*! @brief Computes the spherical harmonics basis function up to degree _LmaxDegree at
      *          polar coordinates (theta, psi) and stores the result in _YBasis;
-     *  @param spherical coordinate phi
+     *  @param phi spherical coordinate
      */
     void ComputeYBasis( const double phi );
 };

code/include/toolboxes/sphericalmonomials.h

@@ -14,24 +14,24 @@
 class SphericalMonomials : public SphericalBase
 {
   public:
-    /*! @brief : Sets up class for monomial basis on sphere up to degree L.
+    /*! @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
+     *  @param L_degree maximum degree of spherical harmonics basis, 0 <= L <= 1000 (upper bound
      *                      due to numerical stability)
      * */
     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
+     *  @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
+     *  @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
+     *  @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;
@@ -56,8 +56,8 @@ class SphericalMonomials : public SphericalBase
     unsigned GetCurrDegreeSize( unsigned currDegreeL ) override;
 
     /*! @brief Computes global index of basis vector depending on order k and degree l
-     *  @param l = degree of polynomials l = 0,1,2,3,...
-     *  @param k = order of element of degree l. 0 <=k <=GetCurrDegreeSize(l) */
+     *  @param l_degree degree of polynomials l = 0,1,2,3,...
+     *  @param k_order order of element of degree l. 0 <=k <=GetCurrDegreeSize(l) */
     unsigned GetGlobalIndexBasis( int l_degree, int k_order ) override;
 
   private:

code/include/toolboxes/textprocessingtoolbox.h

@@ -14,15 +14,15 @@
 namespace TextProcessingToolbox {
 
 /*!
- * \brief utility function for converting strings to uppercase
- * \param[in,out] str - string we want to convert
+ * @brief utility function for converting strings to uppercase
+ * @param str - string to be converted
  */
 inline void StringToUpperCase( std::string& str ) { std::transform( str.begin(), str.end(), str.begin(), ::toupper ); }
 
 /*!
- * \brief utility function for splitting strings to at delimiter
- * \param [in] str - string we want to split, delimiter - delimiter character
- *        [out] vector of string tokens that were separated by the delimiter
+ * @brief utility function for splitting strings to at delimiter
+ * @param s string to be split
+ * @param delimiter delimiter character
  */
 inline std::vector<std::string> Split( const std::string& s, char delimiter ) {
     std::vector<std::string> tokens;
@@ -35,14 +35,8 @@ inline std::vector<std::string> Split( const std::string& s, char delimiter ) {
 }
 
 /*!
- * \brief utility function for getting walltime
- * \param  [in,out] V
- */
-// TODO
-
-/*!
- * \brief utility function for printing a VectorVector
- * \param vectorIn VectorVector we want to print
+ * @brief utility function for printing a VectorVector
+ * @param vectorIn VectorVector we want to print
  */
 inline void PrintVectorVector( const VectorVector vectorIn ) {
     unsigned dimOuter = vectorIn.size();
@@ -60,15 +54,15 @@ inline void PrintVectorVector( const VectorVector vectorIn ) {
 }
 
 /*!
- * \brief utility function for returning the last number in a string
- * \param str string to be checked
+ * @brief utility function for returning the last number in a string
+ * @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 value string to be checked
- * \param ending string to be checked for
+ * @brief utility function for checking if a string has a certain ending
+ * @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/common/config.cpp

@@ -216,8 +216,9 @@ void Config::SetConfigOptions() {
     AddStringOption( "CT_FILE", _ctFile, string( "../tests/input/phantom.png" ) );
 
     // Quadrature relatated options
-    /*! @brief QUAD_TYPE \n DESCRIPTION: Type of Quadrature rule \n Options: see @link QUAD_NAME \endlink \n DEFAULT: QUAD_MonteCarlo \ingroup
-     * Config*/
+    /*! @brief QUAD_TYPE \n DESCRIPTION: Type of Quadrature rule \n Options: see @link QUAD_NAME \endlink \n DEFAULT: QUAD_MonteCarlo
+     * \ingroup Config
+     */
     AddEnumOption( "QUAD_TYPE", _quadName, Quadrature_Map, QUAD_MonteCarlo );
     /*!\brief QUAD_ORDER \n DESCRIPTION: Order of Quadrature rule \n DEFAULT 2 \ingroup Config.*/
     AddUnsignedShortOption( "QUAD_ORDER", _quadOrder, 1 );
@@ -278,8 +279,8 @@ void Config::SetConfigOptions() {
     AddUnsignedLongOption( "NEWTON_ITER", _newtonIter, 100 );
     /*! @brief Step Size Newton Optmizers \n DESCRIPTION: Step size for Newton optimizer \n DEFAULT 10 \ingroup Config */
     AddDoubleOption( "NEWTON_STEP_SIZE", _newtonStepSize, 0.1 );
-    /*! @brief Max Iter for line search in Newton Optmizers \n DESCRIPTION: Max number of line search iter for newton optimizer \n DEFAULT 10 \ingroup
-     * Config */
+    /*! @brief Max Iter for line search in Newton Optmizers \n DESCRIPTION: Max number of line search iter for newton optimizer \n DEFAULT 10
+     * \ingroup Config */
     AddUnsignedLongOption( "NEWTON_LINE_SEARCH_ITER", _newtonLineSearchIter, 100 );
     /*! @brief Newton Fast mode \n DESCRIPTION:  If true, we skip the Newton optimizer for Quadratic entropy and set alpha = u \n DEFAULT false
      * \ingroup Config */

code/src/fluxes/upwindflux.cpp

@@ -12,21 +12,6 @@ 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
- *                    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.
- */
-
 Vector UpwindFlux::Flux( const Matrix AxPlus,
                          const Matrix AxMinus,
                          const Matrix AyPlus,
@@ -57,21 +42,6 @@ Vector UpwindFlux::Flux( const Matrix AxPlus,
     return resultFlux;
 }
 
-/**
- * @brief Flux       Computes <VanLeer> 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
- * @param resultFlux Vector with resulting flux.
- * @return           void
- */
 void UpwindFlux::FluxVanLeer( const Matrix& Ax,
                               const Matrix& AxAbs,
                               const Matrix& /*Ay*/,

code/src/quadratures/qgausschebyshev1D.cpp

@@ -40,7 +40,7 @@ bool QGaussChebyshev1D::CheckOrder() {
     return true;    // All orders viable
 }
 
-double QGaussChebyshev1D::Integrate( double( f )( double x0, double x1, double x2 ) ) {    // Not Safe!
+double QGaussChebyshev1D::Integrate( double ( *f )( double, double, double ) ) {    // Not Safe!
     double result = 0.0;
     double x      = 0.0;
     double y      = 0.0;
@@ -54,12 +54,12 @@ double QGaussChebyshev1D::Integrate( double( f )( double x0, double x1, double x
     return result;
 }
 
-double QGaussChebyshev1D::IntegrateSpherical( double( f )( double my, double phi ) ) {
+double QGaussChebyshev1D::IntegrateSpherical( double ( *f )( double, double ) ) {
     ErrorMessages::Error( "This method is not applicable for 1D quadratures.\n", CURRENT_FUNCTION );
     return f( 0, 0 );
 }
 
-std::vector<double> QGaussChebyshev1D::Integrate( std::vector<double>( f )( double x0, double x1, double x2 ), unsigned /* len */ ) {
+std::vector<double> QGaussChebyshev1D::Integrate( std::vector<double> ( *f )( double, double, double ), unsigned /* len */ ) {
     ErrorMessages::Error( "This method is not applicable for 1D quadratures.\n", CURRENT_FUNCTION );
     return { f( 0, 0, 0 ) };
 }

code/src/quadratures/qgausslegendre1D.cpp

@@ -144,7 +144,7 @@ bool QGaussLegendre1D::CheckOrder() {
     return true;    // All orders viable
 }
 
-double QGaussLegendre1D::Integrate( double( f )( double x0, double x1, double x2 ) ) {    // Not Safe!
+double QGaussLegendre1D::Integrate( double ( *f )( double, double, double ) ) {    // Not Safe!
     double result = 0.0;
     double x      = 0.0;
     double y      = 0.0;
@@ -158,12 +158,12 @@ double QGaussLegendre1D::Integrate( double( f )( double x0, double x1, double x2
     return result;
 }
 
-double QGaussLegendre1D::IntegrateSpherical( double( f )( double my, double phi ) ) {
+double QGaussLegendre1D::IntegrateSpherical( double ( *f )( double, double ) ) {
     ErrorMessages::Error( "This method is not applicable for 1D quadratures.\n", CURRENT_FUNCTION );
     return f( 0, 0 );
 }
 
-std::vector<double> QGaussLegendre1D::Integrate( std::vector<double>( f )( double x0, double x1, double x2 ), unsigned /* len */ ) {
+std::vector<double> QGaussLegendre1D::Integrate( std::vector<double> ( *f )( double, double, double ), unsigned /* len */ ) {
     ErrorMessages::Error( "This method is not applicable for 1D quadratures.\n", CURRENT_FUNCTION );
     return { f( 0, 0, 0 ) };
 }

code/src/quadratures/quadraturebase.cpp

@@ -52,7 +52,7 @@ QuadratureBase* QuadratureBase::Create( QUAD_NAME name, unsigned quadOrder ) {
     return nullptr;
 }
 
-double QuadratureBase::Integrate( double( f )( double x0, double x1, double x2 ) ) {
+double QuadratureBase::Integrate( double ( *f )( double, double, double ) ) {
     double result = 0.0;
     for( unsigned i = 0; i < _nq; i++ ) {
         result += _weights[i] * f( _points[i][0], _points[i][1], _points[i][2] );
@@ -60,7 +60,7 @@ double QuadratureBase::Integrate( double( f )( double x0, double x1, double x2 )
     return result;
 }
 
-double QuadratureBase::IntegrateSpherical( double( f )( double my, double phi ) ) {
+double QuadratureBase::IntegrateSpherical( double ( *f )( double, double ) ) {
     double result = 0.0;
     for( unsigned i = 0; i < _nq; i++ ) {
         result += _weights[i] * f( _pointsSphere[i][0], _pointsSphere[i][1] );
@@ -68,7 +68,7 @@ double QuadratureBase::IntegrateSpherical( double( f )( double my, double phi )
     return result;
 }
 
-std::vector<double> QuadratureBase::Integrate( std::vector<double>( f )( double x0, double x1, double x2 ), unsigned len ) {
+std::vector<double> QuadratureBase::Integrate( std::vector<double> ( *f )( double, double, double ), unsigned len ) {
     std::vector<double> result( len, 0.0 );
     std::vector<double> funcEval( len, 0.0 );
 

doc/problems/phantom2d.rst

 Phantom2D
-======
+=========
 
 .. doxygenclass:: Phantom2D
    :members:

doc/solvers/index.rst

@@ -14,4 +14,3 @@ Solvers
    mnsolver
    pnsolver
    snsolver
-   snsolvermpi

doc/solvers/snsolvermpi.rst

-SNSolverMPI
-===========
-
-.. doxygenclass:: SNSolverMPI
-   :members:
-   :protected-members:
-   :private-members:

doc/toolboxes/index.rst

@@ -6,6 +6,5 @@ Toolboxes
 
    errormessages
    interpolation
-   physics
    reconstructor
    sphericalharmonics

doc/toolboxes/physics.rst

-Physics
-=======
-
-.. doxygenclass:: Physics
-   :members:
-   :protected-members:
-   :private-members: