improved doxygen documentation for common decoupled 1p stuff

git-svn-id: svn://svn.iws.uni-stuttgart.de/DUMUX/dumux/trunk@7802 2fb0f335-1f38-0410-981e-8018bf24f1b0

dumux/decoupled/1p/1pindices.hh

@@ -23,7 +23,7 @@
 /*!
  * \file
  *
- * \brief Defines the indices required for the two-phase box model.
+ * \brief Defines the indices required for the decoupled one-phase model.
  */
 #ifndef DUMUX_DECOUPLED_1P_INDICES_HH
 #define DUMUX_DECOUPLED_1P_INDICES_HH
@@ -31,7 +31,7 @@
 namespace Dumux
 {
 /*!
- * \ingroup IMPES
+ * \ingroup OnePhase
  */
 // \{
 
@@ -41,7 +41,7 @@ namespace Dumux
 struct DecoupledOnePCommonIndices
 {
     // Formulations
-    static const int pressEqIdx = 0;
+    static const int pressEqIdx = 0;//!< Index of the pressure equation
 };
 
 // \}

dumux/decoupled/1p/1pproperties.hh

@@ -65,8 +65,8 @@ NEW_TYPE_TAG(DecoupledOneP, INHERITS_FROM(DecoupledModel));
 NEW_PROP_TAG( SpatialParameters ); //!< The type of the spatial parameters object
 NEW_PROP_TAG( EnableGravity); //!< Returns whether gravity is considered in the problem
 NEW_PROP_TAG( Fluid ); //!< The fluid for one-phase models
-NEW_PROP_TAG( Indices );
-NEW_PROP_TAG( CellData );
+NEW_PROP_TAG( Indices ); //!< Set of indices for the one-phase model
+NEW_PROP_TAG( CellData ); //!< The cell data storage class
 }
 }
 
@@ -83,16 +83,22 @@ namespace Properties
 // Properties
 //////////////////////////////////////////////////////////////////
 
+//! Set number of equations to 1 for isothermal one-phase models
 SET_INT_PROP(DecoupledOneP, NumEq, 1);
 
-SET_INT_PROP(DecoupledOneP, NumPhases, 1)//!< Single phase system
+//! Set number of phases to 1 for one-phase models
+SET_INT_PROP(DecoupledOneP, NumPhases, 1)
 ;
-SET_INT_PROP(DecoupledOneP, NumComponents, 1); //!< Each phase consists of 1 pure component
+//!< Each phase consists of 1 pure component
+SET_INT_PROP(DecoupledOneP, NumComponents, 1);
 
+//! Chose the set of indices for the one-phase formulation
 SET_TYPE_PROP(DecoupledOneP, Indices, DecoupledOnePCommonIndices);
 
+//! Set general decoupled VariableClass as default
 SET_TYPE_PROP(DecoupledOneP, Variables, VariableClass<TypeTag>);
 
+//! Set standart CellData of immiscible one-phase models as default
 SET_TYPE_PROP(DecoupledOneP, CellData, CellData1P<TypeTag>);
 }
 }

dumux/decoupled/1p/cellData1p.hh

@@ -27,7 +27,7 @@
 
 /**
  * @file
- * @brief  Class including the variables and data of discretized data of the constitutive relations for one element
+ * @brief  Class including data of one grid cell
  * @author Markus Wolff
  */
 
@@ -37,15 +37,13 @@ template<class TypeTag>
 class FluxData1P;
 
 /*!
- * \ingroup IMPES
+ * \ingroup OnePhase
  */
-//! Class including the variables and data of discretized data of the constitutive relations for one element.
-/*! The variables of two-phase flow, which are one pressure and one saturation are stored in this class.
- * Additionally, a velocity needed in the transport part of the decoupled two-phase flow is stored, as well as discretized data of constitutive relationships like
- * mobilities, fractional flow functions and capillary pressure. Thus, they have to be callculated just once in every time step or every iteration step.
+//! Class including data of one grid cell.
+/*! The variables of one-phase flow, which are the pressure as well as additional data assigned to cell-cell interfaces, so-called flux-data, are stored.
  *
- * @tparam TypeTag The Type Tag
- 1*/
+ * \tparam TypeTag The problem TypeTag
+ */
 template<class TypeTag>
 class CellData1P
 {
@@ -59,21 +57,17 @@ private:
 
 public:
 
-    //! Constructs a VariableClass object
-    /**
-     *  @param gridView a DUNE gridview object corresponding to diffusion and transport equation
-     */
-
+    //! Constructs a CellData1P object
     CellData1P() :
         pressure_(0.0)
     {
     }
-
+    //! Returns the flux data of the cell
     FluxData& fluxData()
     {
         return fluxData_;
     }
-
+    //! Returns the flux data of the cell
     const FluxData& fluxData() const
     {
         return fluxData_;
@@ -83,17 +77,17 @@ public:
     // functions returning primary variables
     ////////////////////////////////////////////////////////////
 
-
+    //!\brief Returns the cell pressure
     Scalar pressure()
     {
         return pressure_;
     }
-
+    //!\brief Returns the cell pressure
     Scalar pressure() const
     {
         return pressure_;
     }
-
+    //!Sets the cell pressure
     void setPressure(Scalar press)
     {
         pressure_ = press;

dumux/decoupled/1p/fluxData1p.hh

@@ -26,22 +26,20 @@
 
 /**
  * @file
- * @brief  Class including the variables and data of discretized data of the constitutive relations
+ * @brief  Class storing data assigned to a cell-cell interfaces, so-called flux-data
  * @author Markus Wolff
  */
 
 namespace Dumux
 {
 /*!
- * \ingroup IMPES
+ * \ingroup OnePhase
  */
-//! Class including the variables and data of discretized data of the constitutive relations.
-/*! The variables of two-phase flow, which are one pressure and one saturation are stored in this class.
- * Additionally, a velocity needed in the transport part of the decoupled two-phase flow is stored, as well as discretized data of constitutive relationships like
- * mobilities, fractional flow functions and capillary pressure. Thus, they have to be callculated just once in every time step or every iteration step.
- *
- * @tparam TypeTag The Type Tag
- 1*/
+//! Class storing data assigned to a cell-cell interfaces, so-called flux-data.
+/*! Stores velocities and potentials at cell-cell interfaces. Further it provides methods which interpret stored phase potentials for upwind decisions.
+*
+* @tparam TypeTag The problem TypeTag
+*/
 template<class TypeTag>
 class FluxData1P
 {
@@ -65,11 +63,7 @@ private:
 
 public:
 
-    //! Constructs a FluxData object
-    /**
-     *
-     */
-
+    //! Constructs a FluxData1P object
     FluxData1P()
     {
         for (int face = 0;  face < 2*dim; face++)
@@ -84,67 +78,112 @@ public:
     // functions returning the vectors of the primary variables
     ////////////////////////////////////////////////////////////
 
-    //! Return the velocity
+    /*! \brief Returns the velocity vector at a cell-cell interface
+     *
+     * \param indexInInside Index of the cell-cell interface in this cell
+     */
     const FieldVector& velocity(int indexInInside)
     {
         return velocity_[indexInInside];
     }
-
+    /*! \brief Returns the velocity vector at a cell-cell interface
+     *
+     * \param indexInInside Index of the cell-cell interface in this cell
+     */
     const FieldVector& velocity(int indexInInside) const
     {
         return velocity_[indexInInside];
     }
-
+    /*! \brief Sets the velocity vector at a cell-cell interface
+     *
+     * \param indexInInside Index of the cell-cell interface in this cell
+     * \param velocity Velocity vector which is stored
+     */
     void setVelocity(int indexInInside, FieldVector& velocity)
     {
         velocity_[indexInInside] = velocity;
     }
-
+    //!Resets velocities and potentials
     void resetVelocity()
     {
         for (int i = 0; i < 2 * dim; i++)
         {
             velocity_[i] = 0.;
+            potential_[i] = 0.;
             velocityMarker_[i] = false;
         }
     }
 
+    /*! \brief Sets the velocity marker at a cell-cell interface
+     * This marker can be used to check if a velocity has already been stored for this interface
+     *
+     * \param indexInInside Index of the cell-cell interface in this cell
+     */
     void setVelocityMarker(int indexInInside)
     {
         velocityMarker_[indexInInside] = true;
     }
 
+    /*! \brief Check the velocity marker
+     * Returns <tt>true</tt> if a velocity marker was set, otherwise <tt>false</tt>
+     *
+     * \param indexInInside Index of the cell-cell interface in this cell
+     */
     bool haveVelocity(int indexInInside)
     {
         return velocityMarker_[indexInInside];
     }
 
+    //!Resets the velocity marker
     void resetVelocityMarker()
     {
         for (int i = 0; i < 2*dim; i++)
             velocityMarker_[i] = false;
     }
 
+    /*! \brief Checks for upwind direction
+     *Returns <tt>true</tt> if the cell is the upwind cell, otherwise <tt>false</tt>
+     *
+     * \param indexInInside Index of the cell-cell interface in this cell
+     */
     bool isUpwindCell(int indexInInside)
     {
         return (potential_[indexInInside] >= 0.);
     }
 
+    /*! \brief Checks for upwind direction
+     *Returns <tt>true</tt> if the cell is the upwind cell, otherwise <tt>false</tt>
+     *
+     * \param indexInInside Index of the cell-cell interface in this cell
+     */
     bool isUpwindCell(int indexInInside) const
     {
         return (potential_[indexInInside] >= 0.);
     }
 
+    /*! \brief Returns the potential at a cell-cell interface
+     *
+     * \param indexInInside Index of the cell-cell interface in this cell
+     */
     Scalar potential(int indexInInside)
     {
         return potential_[indexInInside];
     }
 
+    /*! \brief Returns the potential at a cell-cell interface
+     *
+     * \param indexInInside Index of the cell-cell interface in this cell
+     */
     Scalar potential(int indexInInside) const
     {
         return potential_[indexInInside];
     }
 
+    /*! \brief Sets the potential at a cell-cell interface
+     *
+     * \param indexInInside Index of the cell-cell interface in this cell
+     * \param pot Phase potential which is stored
+     */
     void setPotential(int indexInInside, Scalar pot)
     {
         potential_[indexInInside] = pot;