diff --git a/FunctionSpace/Basis.h b/FunctionSpace/Basis.h index 71742ae3d8cb872bba1eeec0c9caabfae6b18102..e3b6647aeca08f551aaeae40ca46a1d38351c461 100644 --- a/FunctionSpace/Basis.h +++ b/FunctionSpace/Basis.h @@ -2,13 +2,16 @@ #define _BASIS_H_ /** - @class Basis - @brief Mother class of all Basis + @interface Basis + @brief Common Interface of all Basis - This class is the @em mother (by @em inheritence) of all Basis.@n + This class is the @em common @em interface for all Basis.@n A Basis is @em set of @em linearly @em independent Polynomial%s (or Vector%s of Polynomial%s).@n + + @note + A Basis is an @em interface, so it @em can't be instanciated */ class Basis{ @@ -52,7 +55,6 @@ class Basis{ //! @li 1 for 1-form //! @li 2 for 2-form //! @li 3 for 3-form - //! @todo Check if the 'form numbering' is good int getType(void) const; //! @return Returns the @em dimension @@ -80,8 +82,10 @@ class Basis{ int getSize(void) const; protected: + //! @internal //! Instantiate a new Basis - //! @warning Users can't instantiate a Basis + //! + //! @endinternal Basis(void); }; diff --git a/FunctionSpace/BasisGenerator.cpp b/FunctionSpace/BasisGenerator.cpp index 454c403a1199e524fa09a6f50e14f9658274e106..15645c4a5b108f5010b1a5812261ca37cab572e0 100644 --- a/FunctionSpace/BasisGenerator.cpp +++ b/FunctionSpace/BasisGenerator.cpp @@ -23,16 +23,16 @@ Basis* BasisGenerator::generate(int elementType, int basisType, int order){ switch(elementType){ - case TYPE_TRI: return TriGen(basisType, order); - case TYPE_QUA: return QuaGen(basisType, order); - case TYPE_HEX: return HexGen(basisType, order); + case TYPE_TRI: return triGen(basisType, order); + case TYPE_QUA: return quaGen(basisType, order); + case TYPE_HEX: return hexGen(basisType, order); default: throw Exception("Unknown Element Type (%d) for Basis Generation", elementType); } } -Basis* BasisGenerator::TriGen(int basisType, +Basis* BasisGenerator::triGen(int basisType, int order){ switch(basisType){ case 0: return new TriNodeBasis(order); @@ -47,7 +47,7 @@ Basis* BasisGenerator::TriGen(int basisType, } } -Basis* BasisGenerator::QuaGen(int basisType, +Basis* BasisGenerator::quaGen(int basisType, int order){ switch(basisType){ case 0: return new QuadNodeBasis(order); @@ -59,7 +59,7 @@ Basis* BasisGenerator::QuaGen(int basisType, } } -Basis* BasisGenerator::HexGen(int basisType, +Basis* BasisGenerator::hexGen(int basisType, int order){ switch(basisType){ case 0: return new HexNodeBasis(order); diff --git a/FunctionSpace/BasisGenerator.h b/FunctionSpace/BasisGenerator.h index b524b25ce9bbac88bd62630387c21649c133d1ea..38401febedb01fb6bfde6c2f9bcc41f3accf40a3 100644 --- a/FunctionSpace/BasisGenerator.h +++ b/FunctionSpace/BasisGenerator.h @@ -3,11 +3,16 @@ #include "Basis.h" -/** +/** @class BasisGenerator - @brief A bunch of static method to generate basis + @brief A bunch of class method to generate a Basis - A bunch of static method to generate basis + A BasisGenerator is a bunch of @em class + methods to generate a Basis. + + @note + A BasisGenerator got @em only @em class @em methods, + so it is not required to instanciate it. */ class BasisGenerator{ @@ -19,9 +24,98 @@ class BasisGenerator{ int basisType, int order); - static Basis* TriGen(int basisType, int order); - static Basis* QuaGen(int basisType, int order); - static Basis* HexGen(int basisType, int order); + static Basis* triGen(int basisType, int order); + static Basis* quaGen(int basisType, int order); + static Basis* hexGen(int basisType, int order); }; + +/** + @fn BasisGenerator::BasisGenerator + Instantiates a new BasisGenerator + + @note + A BasisGenerator got @em only @em class @em methods, + so it is not required to instanciate it. + ** + + @fn BasisGenerator::~BasisGenerator + Deletes this BasisGenerator + ** + + @fn BasisGenerator::generate + @param elementType The type of the element, + on which the requested Basis will be created + @param basisType The Basis type + @param order The order or the requested Basis + + This method will @em instanciate the requested Basis + + @return Returns a @em pointer to a newly + @em instantiated Basis + + @note Element types are: + @li @c TYPE_TRI for Triangles + @li @c TYPE_QUA for Quadrangles + @li @c TYPE_HEX for Hexahedrons + + @note Basis types are: + @li @c 0 for 0-Form + @li @c 1 for 1-Form + @li @c 2 for 2-Form + @li @c 3 for 3-Form + ** + + @fn BasisGenerator::triGen + @param basisType The Basis type + @param order The order or the requested Basis + + This method will @em instanciate the requested Basis, + with a @em Triangle for support + + @return Returns a @em pointer to a newly + @em instantiated Basis + + @note Basis types are: + @li @c 0 for 0-Form + @li @c 1 for 1-Form + @li @c 2 for 2-Form + @li @c 3 for 3-Form + ** + + @fn BasisGenerator::quaGen + @param basisType The Basis type + @param order The order or the requested Basis + + This method will @em instanciate the requested Basis, + with a @em Quadrangle for support + + @return Returns a @em pointer to a newly + @em instantiated Basis + + @note Basis types are: + @li @c 0 for 0-Form + @li @c 1 for 1-Form + @li @c 2 for 2-Form + @li @c 3 for 3-Form + ** + + @fn BasisGenerator::hexGen + @param basisType The Basis type + @param order The order or the requested Basis + + This method will @em instanciate the requested Basis, + with a @em Hexahedron for support + + @return Returns a @em pointer to a newly + @em instantiated Basis + + @note Basis types are: + @li @c 0 for 0-Form + @li @c 1 for 1-Form + @li @c 2 for 2-Form + @li @c 3 for 3-Form + ** + */ + #endif diff --git a/FunctionSpace/BasisScalar.h b/FunctionSpace/BasisScalar.h index 74c19e667011025236f498fd23326907ff542044..a5bd26afdf62f8599832f84c834d4d81c5b5c238 100644 --- a/FunctionSpace/BasisScalar.h +++ b/FunctionSpace/BasisScalar.h @@ -6,12 +6,16 @@ #include "Polynomial.h" /** - @class BasisScalar - @brief Mother class of all - @em scalar Basis + @interface BasisScalar + @brief Common Interface for all + @em Scalar Basis - This class is the @em mother (by @em inheritence) - of all @em scalar Basis.@n + This class is the @em common @em interface for all + @em scalar Basis.@n + + @note + A BasisScalar is an @em interface, + so it @em can't be instanciated */ class BasisScalar: public Basis{ @@ -28,8 +32,10 @@ class BasisScalar: public Basis{ const std::vector<Polynomial>& getFunctions(void) const; protected: - //! Instantiate a new BasisScalar - //! @warning Users can't instantiate a BasisScalar + //! @internal + //! Instantiates a new BasisScalar + //! + //! @endinternal BasisScalar(void); }; diff --git a/FunctionSpace/BasisTest.cpp b/FunctionSpace/BasisTest.cpp index 8723e2538c4ebd57412f8e1b679f2375d1e9838a..441f800ed56b83b7779595cc0ae334aa15c09302 100644 --- a/FunctionSpace/BasisTest.cpp +++ b/FunctionSpace/BasisTest.cpp @@ -34,7 +34,7 @@ int ain(int argc, char** argv){ // Plot Basis // HexNodeBasis b(1); - PlotBasis plot(goe, b, writer); + PlotBasis plot(b, goe, writer); plot.plot("basis"); // Stop Gmsh // diff --git a/FunctionSpace/BasisVector.h b/FunctionSpace/BasisVector.h index 77329e2f9901a3ff6c64bd0e35fdfbc581dc10c5..32ef5b91939e8f75376e7c62298a9d6190cafe01 100644 --- a/FunctionSpace/BasisVector.h +++ b/FunctionSpace/BasisVector.h @@ -6,12 +6,16 @@ #include "Polynomial.h" /** - @class BasisVector - @brief Mother class of all - @em vectorial Basis + @interface BasisVector + @brief Common Interface for all + @em Vectorial Basis - This class is the @em mother (by @em inheritence) - of all @em vectorial Basis.@n + This class is the @em common @em interface for all + @em vectorial Basis.@n + + @note + A BasisVector is an @em interface, + so it @em can't be instanciated */ class BasisVector: public Basis{ @@ -28,8 +32,10 @@ class BasisVector: public Basis{ const std::vector<std::vector<Polynomial> >& getFunctions(void) const; protected: + //! @internal //! Instantiate a new BasisVector - //! @warning Users can't instantiate a BasisVector + //! + //! @endinternal BasisVector(void); }; diff --git a/FunctionSpace/FunctionSpace.cpp b/FunctionSpace/FunctionSpace.cpp index e88528b4556ca54567b8f7425977b9a9595d33fd..538bc66cd04c80d72c1bf85ff898a92e6a2c6f22 100644 --- a/FunctionSpace/FunctionSpace.cpp +++ b/FunctionSpace/FunctionSpace.cpp @@ -139,75 +139,3 @@ int FunctionSpace::getElementType(const Dof& dof) const{ return 3; } -int FunctionSpace::getElementGlobalId(const Dof& dof) const{ - return dof.getEntity(); -} - - -/* -#include "Polynomial.h" -#include "BasisScalar.h" -#include "fullMatrix.h" -#include "Mapper.h" -#include "Exception.h" -void FunctionSpace:: -interpolateAtNodes(const MElement& elem, - const vector<double>& coef, - std::vector<double>& nodeValue) const{ - // Check - unsigned int wS = coef.size(); - unsigned int bS = basis->getSize(); - - if(wS < bS) - throw Exception - ("Not enough coefs for interpolation:\nBasis: %d -- coefs: %d", - bS, wS); - - if(wS > bS) - throw Exception - ("Too much coefs for interpolation:\nBasis: %d -- coefs: %d", - bS, wS); - - // Get Nodes - MElement& element = const_cast<MElement&>(elem); - - vector<MVertex*> node; - element.getVertices(node); - unsigned int N = node.size(); - - // Get Functions - const vector<Polynomial>& fun = - static_cast<const BasisScalar*>(basis)->getBasis(); - - // Init some stuff - fullMatrix<double> invJac(3, 3); - fullVector<double> xyz(3); - fullVector<double> origin(3); - - origin(0) = node[0]->x(); - origin(1) = node[0]->y(); - origin(2) = node[0]->z(); - - // Interpolate - for(unsigned int n = 0; n < N; n++){ - // Map from physical to reference space - xyz(0) = node[n]->x(); - xyz(1) = node[n]->y(); - xyz(2) = node[n]->z(); - - element.getJacobian(xyz(0), xyz(1), xyz(2), invJac); - invJac.invertInPlace(); - - const fullVector<double> uvw = - Mapper::invMap(xyz, origin, invJac); - - printf("(%lf\t%lf\t%lf)\n", uvw(0), uvw(1), uvw(2)); - - // Interpolate - const int id = node[n]->getNum() - 1; - - for(unsigned int i = 0; i < bS; i++) - nodeValue[id] += fun[i].at(uvw(0), uvw(1), uvw(2)) * coef[i]; - } -} -*/ diff --git a/FunctionSpace/FunctionSpace.h b/FunctionSpace/FunctionSpace.h index 4b4ce0e00580e26ebd9b92e3d7495c50eefc4acf..45664d422de925ce4a6fc94c30d746a53228eb03 100644 --- a/FunctionSpace/FunctionSpace.h +++ b/FunctionSpace/FunctionSpace.h @@ -14,14 +14,24 @@ #include "MEdge.h" #include "MFace.h" -/** - @class FunctionSpace - @brief A Function Space +/** + @interface FunctionSpace + @brief Common Interface of all Function Spaces - This class represents a Function Space + This is the @em common @em interface of + all Function Spaces.@n + A FunctionSpace is defined on a @em support, + which is a collection of MElement%s (GroupOfElement).@n + + Those MElement%s @em must belong to the @em same Mesh. + + @note + A FunctionSpace is an @em interface, so it + can't be instantiated. + @todo - Hybrid Mesh@n + Allow Hybrid Mesh */ class FunctionSpace{ @@ -48,20 +58,136 @@ class FunctionSpace{ unsigned int getNFunctionPerCell(const MElement& element) const; std::vector<Dof> getKeys(const MElement& element) const; - std::vector<Dof> getKeys(const MVertex& element) const; - std::vector<Dof> getKeys(const MEdge& element) const; - std::vector<Dof> getKeys(const MFace& element) const; + std::vector<Dof> getKeys(const MVertex& vertex) const; + std::vector<Dof> getKeys(const MEdge& edge) const; + std::vector<Dof> getKeys(const MFace& face) const; int getElementType(const Dof& dof) const; int getElementGlobalId(const Dof& dof) const; protected: - FunctionSpace(); + FunctionSpace(void); void build(const GroupOfElement& goe, int basisType, int order); }; + +/** + @internal + @fn FunctionSpace::FunctionSpace + Instatiate a new FunctionSpace + @endinternal + ** + + @fn FunctionSpace::~FunctionSpace + Deletes this FunctionSpace + ** + + @fn FunctionSpace::getSupport + @return Returns the support of this + FunctionSpace + ** + + @fn FunctionSpace::getType + @return Return the @em type of + the Basis functions composing + this Function Space. + @see Basis::getType() + ** + + @fn FunctionSpace::getNFunctionPerVertex + @param element A MElement of the support + @return Returns the number of @em Vertex Based + Basis Functions, defined on the given element + ** + + @fn FunctionSpace::getNFunctionPerEdge + @param element A MElement of the support + @return Returns the number of @em Edge Based + Basis Functions, defined on the given element + ** + + @fn FunctionSpace::getNFunctionPerFace + @param element A MElement of the support + @return Returns the number of @em Face Based + Basis Functions, defined on the given element + ** + + @fn FunctionSpace::getNFunctionPerCell + @param element A MElement of the support + @return Returns the number of @em Cell Based + Basis Functions, defined on the given element + ** + + @fn vector<Dof> FunctionSpace::getKeys(const MElement& element) const + @param element A MElement + @return Returns all the Dof%s associated to the given MElement + ** + + @fn vector<Dof> FunctionSpace::getKeys(const MVertex& vertex) const + @param vertex A MVertex + @return Returns all the Dof%s associated to the given MVertex + ** + + @fn vector<Dof> FunctionSpace::getKeys(const MEdge& edge) const + @param edge A MEdge + @return Returns all the Dof%s associated to the given MEdge + ** + + @fn vector<Dof> FunctionSpace::getKeys(const MFace& face) const + @param face A MFace + @return Returns all the Dof%s associated to the given MFace + ** + + @fn FunctionSpace::getElementType + @param dof A Dof + @return Returns the @em type of the @em element, + to which the given Dof is @em associated + + @note + Type is equal to: + @li @c 0, if the element is a @em Vertex + @li @c 1, if the element is an @em Edge + @li @c 2, if the element is a @em Face + @li @c 3, if the element is a @em Cell + + @warning + There are no error recovery if + the Element is not in the Mesh + + @todo + Error recovery if + the Element is not in the Mesh + ** + + @fn FunctionSpace::getElementGlobalId + @param dof A Dof + @return Returns the @em Mesh @em Global @em @c ID of + the Element, to which the given Dof is @em associated + + @warning + There are no error recovery if + the Element is not in the Mesh + + @todo + Error recovery if + the Element is not in the Mesh + ** + + @internal + @fn FunctionSpace::build + @param goe The GroupOfElement defining the support + of this FunctionSpace + @param basisType The Type of the Basis to use to build + this FunctionSpace + @param order The order of this FunctionSpace + + Initializes a FunctionSpace with the given parameters + @endinternal +*/ + + ////////////////////// // Inline Functions // ////////////////////// @@ -90,4 +216,8 @@ inline unsigned int FunctionSpace::getNFunctionPerCell(const MElement& element) return fPerCell; } +inline int FunctionSpace::getElementGlobalId(const Dof& dof) const{ + return dof.getEntity(); +} + #endif diff --git a/FunctionSpace/FunctionSpaceEdge.h b/FunctionSpace/FunctionSpaceEdge.h index 877289a27cdf81fe3e1ee33dcd25cf7b315b0d08..bc03737d2c7987355ab1953011f57db575788829 100644 --- a/FunctionSpace/FunctionSpaceEdge.h +++ b/FunctionSpace/FunctionSpaceEdge.h @@ -3,6 +3,14 @@ #include "FunctionSpaceVector.h" +/** + @class FunctionSpaceEdge + @brief An Edge based Function Space + + This class is an Edge based (1-Form) Function Space. +*/ + + class FunctionSpaceEdge : public FunctionSpaceVector{ public: FunctionSpaceEdge(const GroupOfElement& goe, int order); @@ -15,4 +23,20 @@ class FunctionSpaceEdge : public FunctionSpaceVector{ const fullVector<double>& xyz) const; }; + +/** + @fn FunctionSpaceEdge::FunctionSpaceEdge + @param goe The GroupOfElement defining the + @em support of this FunctionSpace + @param order The order of this FunctionSpace + + Instantiates a new Edge based Function Space + (FunctionSpaceEdge) with the given parameters + ** + + @fn FunctionSpaceEdge::~FunctionSpaceEdge + Deletes this FunctionSpaceEdge + ** + */ + #endif diff --git a/FunctionSpace/FunctionSpaceNode.h b/FunctionSpace/FunctionSpaceNode.h index 5b1cfd8ac1798e412479f971b76bfad982a5f1b4..59655bcd4839e8a287b1461b2b725d2db5a649c1 100644 --- a/FunctionSpace/FunctionSpaceNode.h +++ b/FunctionSpace/FunctionSpaceNode.h @@ -3,6 +3,14 @@ #include "FunctionSpaceScalar.h" +/** + @class FunctionSpaceNode + @brief A Nodal Function Space + + This class is a Nodal (0-Form) Function Space. +*/ + + class FunctionSpaceNode : public FunctionSpaceScalar{ public: FunctionSpaceNode(const GroupOfElement& goe, int order); @@ -15,4 +23,20 @@ class FunctionSpaceNode : public FunctionSpaceScalar{ const fullVector<double>& xyz) const; }; + +/** + @fn FunctionSpaceNode::FunctionSpaceNode + @param goe The GroupOfElement defining the + @em support of this FunctionSpace + @param order The order of this FunctionSpace + + Instantiates a new Nodal Function Space + (FunctionSpaceNode) with the given parameters + ** + + @fn FunctionSpaceNode::~FunctionSpaceNode + Deletes this FunctionSpaceNode + ** + */ + #endif diff --git a/FunctionSpace/FunctionSpaceScalar.h b/FunctionSpace/FunctionSpaceScalar.h index 7587672ed9eac6cf6e530f560f0d4a8d4c88130a..68956590166f6ff1a4867be18d0273190ddae96c 100644 --- a/FunctionSpace/FunctionSpaceScalar.h +++ b/FunctionSpace/FunctionSpaceScalar.h @@ -5,6 +5,21 @@ #include "BasisScalar.h" #include "FunctionSpace.h" +/** + @interface FunctionSpaceScalar + @brief Common Interface of all Scalar FunctionSpaces + + This is the @em common @em interface of + all @em Scalar FunctionSpaces.@n + + A FunctionSpaceScalar can be @em interpolated. + + @note + A ScalarFunctionSpace is an @em interface, so it + can't be instantiated. +*/ + + class FunctionSpaceScalar : public FunctionSpace{ public: virtual ~FunctionSpaceScalar(void); @@ -18,6 +33,38 @@ class FunctionSpaceScalar : public FunctionSpace{ }; +/** + @fn FunctionSpaceScalar::~FunctionSpaceScalar + Deletes this FunctionSpaceScalar + ** + + @fn FunctionSpaceScalar::interpolate + @param element The MElement to interpolate on + @param coef The coefficients of the interpolation + @param xyz The coordinate + (of point @em inside the given @c element) + of the interpolation + + @return Returns the (scalar) interpolated value + + @warning + If the given coordinate are not in the given + @c element @em Bad @em Things may happend + + @todo + If the given coordinate are not in the given + @c element @em Bad @em Things may happend + ---> check + ** + + @fn FunctionSpaceScalar::getBasis + @param element A MElement of the support + of this FunctionSpace + @return Returns the Basis (BasisScalar) associated + to the given MElement + */ + + ////////////////////// // Inline Functions // ////////////////////// diff --git a/FunctionSpace/FunctionSpaceVector.h b/FunctionSpace/FunctionSpaceVector.h index b1bb914eaa38e5e16da4b0c5efbcf22883a69ecd..edb168f1ad6590bc6e408130a3832444714264b0 100644 --- a/FunctionSpace/FunctionSpaceVector.h +++ b/FunctionSpace/FunctionSpaceVector.h @@ -5,6 +5,21 @@ #include "BasisVector.h" #include "FunctionSpace.h" +/** + @interface FunctionSpaceVector + @brief Common Interface of all Vectorial FunctionSpaces + + This is the @em common @em interface of + all @em Vectorial FunctionSpaces.@n + + A FunctionSpaceVector can be @em interpolated. + + @note + A VectorFunctionSpace is an @em interface, so it + can't be instantiated. +*/ + + class FunctionSpaceVector : public FunctionSpace{ public: virtual ~FunctionSpaceVector(void); @@ -18,6 +33,38 @@ class FunctionSpaceVector : public FunctionSpace{ }; +/** + @fn FunctionSpaceVector::~FunctionSpaceVector + Deletes this FunctionSpaceVector + ** + + @fn FunctionSpaceVector::interpolate + @param element The MElement to interpolate on + @param coef The coefficients of the interpolation + @param xyz The coordinate + (of point @em inside the given @c element) + of the interpolation + + @return Returns the (vectorial) interpolated value + + @warning + If the given coordinate are not in the given + @c element @em Bad @em Things may happend + + @todo + If the given coordinate are not in the given + @c element @em Bad @em Things may happend + ---> check + ** + + @fn FunctionSpaceVector::getBasis + @param element A MElement of the support + of this FunctionSpace + @return Returns the Basis (BasisVector) associated + to the given MElement + */ + + ////////////////////// // Inline Functions // ////////////////////// diff --git a/FunctionSpace/HexEdgeBasis.h b/FunctionSpace/HexEdgeBasis.h index 88a19601e11a33afa8415b8a0f127a764c977712..29a2bc3ea274810cb9ca58b13628ceef8f994e77 100644 --- a/FunctionSpace/HexEdgeBasis.h +++ b/FunctionSpace/HexEdgeBasis.h @@ -5,7 +5,7 @@ /** @class HexEdgeBasis - @brief An Edge-Basis for Hexahedrons + @brief An Edge Basis for Hexahedrons This class can instantiate an Edge-Based Basis (high or low order) for Hexahedrons.@n @@ -17,8 +17,9 @@ class HexEdgeBasis: public BasisVector{ public: - //! Returns a new Edge-Basis for Hexahedrons of the given order //! @param order The order of the Basis + //! + //! Returns a new Edge-Basis for Hexahedrons of the given order HexEdgeBasis(const int order); //! Deletes this Basis diff --git a/FunctionSpace/HexNodeBasis.h b/FunctionSpace/HexNodeBasis.h index d25a05617cb96a86c196556dc38094d39b69ee84..d6439e4b9b8d31403d57b9d9890ec57458f5c01a 100644 --- a/FunctionSpace/HexNodeBasis.h +++ b/FunctionSpace/HexNodeBasis.h @@ -5,7 +5,7 @@ /** @class HexNodeBasis - @brief A Node-Basis for Hexahedrons + @brief A Node Basis for Hexahedrons This class can instantiate a Node-Based Basis (high or low order) for Hexahedrons.@n @@ -17,8 +17,9 @@ class HexNodeBasis: public BasisScalar{ public: - //! Returns a new Node-Basis for Hexahedrons of the given order //! @param order The order of the Basis + //! + //! Returns a new Node-Basis for Hexahedrons of the given order HexNodeBasis(const int order); //! @return Deletes this Basis diff --git a/FunctionSpace/QuadEdgeBasis.h b/FunctionSpace/QuadEdgeBasis.h index 84d089cedbb07694d5c8b998ecab5d59c0decf84..0d16fdfe3af6621cc7add66a478c8b43e474fb55 100644 --- a/FunctionSpace/QuadEdgeBasis.h +++ b/FunctionSpace/QuadEdgeBasis.h @@ -5,7 +5,7 @@ /** @class QuadEdgeBasis - @brief An Edge-Basis for Quads + @brief An Edge Basis for Quads This class can instantiate an Edge-Based Basis (high or low order) for Quads.@n @@ -17,8 +17,9 @@ class QuadEdgeBasis: public BasisVector{ public: - //! Returns a new Edge-Basis for Quads of the given order //! @param order The order of the Basis + //! + //! Returns a new Edge-Basis for Quads of the given order QuadEdgeBasis(const int order); //! Deletes this Basis diff --git a/FunctionSpace/QuadNodeBasis.h b/FunctionSpace/QuadNodeBasis.h index 33b7bb57f455070054b6839bd9c71e877cb510a3..9ae85cfee6dffec4985f17fb0a8b99071dd6beea 100644 --- a/FunctionSpace/QuadNodeBasis.h +++ b/FunctionSpace/QuadNodeBasis.h @@ -5,7 +5,7 @@ /** @class QuadNodeBasis - @brief A Node-Basis for Quads + @brief A Node Basis for Quads This class can instantiate a Node-Based Basis (high or low order) for Quads.@n @@ -17,8 +17,9 @@ class QuadNodeBasis: public BasisScalar{ public: - //! Returns a new Node-Basis for Quads of the given order //! @param order The order of the Basis + //! + //! Returns a new Node-Basis for Quads of the given order QuadNodeBasis(const int order); //! @return Deletes this Basis diff --git a/FunctionSpace/TriEdgeBasis.h b/FunctionSpace/TriEdgeBasis.h index 120ed864fc72a68e469b8ad93de3b083cbb4c885..48b5f0be4cdd45e73c30c2459888aadf9e19f15e 100644 --- a/FunctionSpace/TriEdgeBasis.h +++ b/FunctionSpace/TriEdgeBasis.h @@ -5,7 +5,7 @@ /** @class TriEdgeBasis - @brief An Edge-Basis for Triangles + @brief An Edge Basis for Triangles This class can instantiate an Edge-Based Basis (high or low order) for Triangles.@n @@ -17,8 +17,9 @@ class TriEdgeBasis: public BasisVector{ public: - //! Returns a new Edge-Basis for Triangles of the given order //! @param order The order of the Basis + //! + //! Returns a new Edge-Basis for Triangles of the given order TriEdgeBasis(const int order); //! Deletes this Basis diff --git a/FunctionSpace/TriNodeBasis.h b/FunctionSpace/TriNodeBasis.h index b3e85528f6157f68f80548421a564db72069807f..8746838d8c9d5f518b0bbd4a71c3d88e396f7a82 100644 --- a/FunctionSpace/TriNodeBasis.h +++ b/FunctionSpace/TriNodeBasis.h @@ -5,7 +5,7 @@ /** @class TriNodeBasis - @brief A Node-Basis for Triangles + @brief A Node Basis for Triangles This class can instantiate a Node-Based Basis (high or low order) for Triangles.@n @@ -17,8 +17,9 @@ class TriNodeBasis: public BasisScalar{ public: - //! Returns a new Node-Basis for Triangles of the given order //! @param order The order of the Basis + //! + //! Returns a new Node-Basis for Triangles of the given order TriNodeBasis(const int order); //! Deletes this Basis