Commit b288f50d authored by Steffen Schotthöfer's avatar Steffen Schotthöfer
Browse files

more documentation


Former-commit-id: 5a43eebe
parent 218f3f71
/*!
* \file globalconstants.h
* \brief All global defined (physical) constants, enums etc
* \author <blank>
* \version 0.0
*
*/
......
......@@ -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)
......
......@@ -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;
......
......@@ -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,
......
......@@ -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 );
......
......@@ -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
......@@ -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
......@@ -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 );
......
......@@ -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 */
......
......@@ -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;
};
......
......@@ -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 );
};
......
......@@ -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;
......
......@@ -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 );
......
......@@ -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.
......
......@@ -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;
};
......
......@@ -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 );
......
......@@ -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;
......
......@@ -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;
......
......@@ -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