SimpleResidualEstimator ready and documented.

AMDiS/CMakeLists.txt

@@ -92,7 +92,6 @@ SET(AMDIS_SRC ${SOURCE_DIR}/AdaptBase.cc
 	      ${SOURCE_DIR}/Element.cc
 	      ${SOURCE_DIR}/ElementData.cc
 	      ${SOURCE_DIR}/ElementDofIterator.cc
-	      ${SOURCE_DIR}/Estimator.cc
 	      ${SOURCE_DIR}/FiniteElemSpace.cc
 	      ${SOURCE_DIR}/FirstOrderAssembler.cc
 	      ${SOURCE_DIR}/FirstOrderTerm.cc
@@ -123,12 +122,10 @@ SET(AMDIS_SRC ${SOURCE_DIR}/AdaptBase.cc
 	      ${SOURCE_DIR}/Quadrature.cc
 	      ${SOURCE_DIR}/RCNeighbourList.cc
 	      ${SOURCE_DIR}/Recovery.cc
-	      ${SOURCE_DIR}/RecoveryEstimator.cc
 	      ${SOURCE_DIR}/RefinementManager.cc
 	      ${SOURCE_DIR}/RefinementManager1d.cc
 	      ${SOURCE_DIR}/RefinementManager2d.cc
 	      ${SOURCE_DIR}/RefinementManager3d.cc
-	      ${SOURCE_DIR}/ResidualEstimator.cc
 	      ${SOURCE_DIR}/RobinBC.cc
 	      ${SOURCE_DIR}/ScalableQuadrature.cc
 	      ${SOURCE_DIR}/SecondOrderAssembler.cc
@@ -147,6 +144,10 @@ SET(AMDIS_SRC ${SOURCE_DIR}/AdaptBase.cc
 	      ${SOURCE_DIR}/VertexVector.cc
 	      ${SOURCE_DIR}/ZeroOrderAssembler.cc
 	      ${SOURCE_DIR}/ZeroOrderTerm.cc
+	      ${SOURCE_DIR}/est/Estimator.cc
+	      ${SOURCE_DIR}/est/RecoveryEstimator.cc
+	      ${SOURCE_DIR}/est/ResidualEstimator.cc
+	      ${SOURCE_DIR}/est/SimpleResidualEstimator.cc
 	      ${SOURCE_DIR}/io/ArhReader.cc
 	      ${SOURCE_DIR}/io/ArhWriter.cc
 	      ${SOURCE_DIR}/io/DataCollector.cc
@@ -345,6 +346,11 @@ INSTALL(FILES ${HEADERS}
 	DESTINATION include/amdis/nonlin/)
 list(APPEND deb_add_dirs "include/amdis/nonlin")
 
+FILE(GLOB HEADERS "${SOURCE_DIR}/est/*.h")
+INSTALL(FILES ${HEADERS} 
+	DESTINATION include/amdis/est/)
+list(APPEND deb_add_dirs "include/amdis/est")
+
 FILE(GLOB HEADERS "${SOURCE_DIR}/time/*.h")
 INSTALL(FILES ${HEADERS} 
 	DESTINATION include/amdis/time/)

AMDiS/src/AMDiS.h

@@ -59,7 +59,6 @@
 #include "Element.h"
 #include "ElementDofIterator.h"
 #include "Error.h"
-#include "Estimator.h"
 #include "FiniteElemSpace.h"
 #include "FirstOrderTerm.h"
 #include "FixVec.h"
@@ -112,6 +111,8 @@
 #include "VertexVector.h"
 #include "ZeroOrderTerm.h"
 
+#include "est/Estimator.h"
+
 #include "io/ArhReader.h"
 #include "io/ArhWriter.h"
 #include "io/FileWriter.h"

AMDiS/src/AdaptInstationary.cc

@@ -12,7 +12,7 @@
 
 #include "AdaptInstationary.h"
 #include "Initfile.h"
-#include "Estimator.h"
+#include "est/Estimator.h"
 #include "ProblemIterationInterface.h"
 #include "ProblemTimeInterface.h"
 #include "Serializer.h"

AMDiS/src/AdaptStationary.cc

@@ -12,7 +12,7 @@
 
 #include "AdaptStationary.h"
 #include "Initfile.h"
-#include "Estimator.h"
+#include "est/Estimator.h"
 #include "ProblemIterationInterface.h"
 #include <math.h>
 

AMDiS/src/Assembler.cc

@@ -69,7 +69,7 @@ namespace AMDiS {
 	return;
       }
     }
- 
+
     ElementMatrix& mat = rememberElMat ? elementMatrix : userMat;
 
     if (secondOrderAssembler)
@@ -315,8 +315,8 @@ namespace AMDiS {
     FUNCNAME("Assembler::matVecAssemble()");
 
     Element *el = elInfo->getElement(); 
-    ElementVector uhOldLoc(operat->uhOld->getFeSpace() == rowFeSpace ? nRow : nCol);
-
+    ElementVector uhOldLoc(operat->uhOld->getFeSpace() == rowFeSpace ? 
+			   nRow : nCol);
     operat->uhOld->getLocalVector(el, uhOldLoc);
     
     if (el != lastMatEl) {

AMDiS/src/CreatorMap.cc

@@ -17,14 +17,15 @@
 #include "ITL_Preconditioner.h"
 #include "MatrixVector.h"
 #include "SystemVector.h"
-#include "Estimator.h"
-#include "RecoveryEstimator.h"
-#include "ResidualEstimator.h"
+#include "est/Estimator.h"
 #include "LeafData.h"
 #include "SurfaceRegion_ED.h"
 #include "ElementRegion_ED.h"
 #include "DOFMatrix.h"
 #include "UmfPackSolver.h"
+#include "est/RecoveryEstimator.h"
+#include "est/ResidualEstimator.h"
+#include "est/SimpleResidualEstimator.h"
 #include "time/RosenbrockMethod.h"
 #include "nonlin/NonLinSolver.h"
 
@@ -102,6 +103,9 @@ namespace AMDiS {
     creator = new ResidualEstimator::Creator;
     addCreator("residual", creator);
 
+    creator = new SimpleResidualEstimator::Creator;
+    addCreator("simple-residual", creator);
+
     creator = new RecoveryEstimator::Creator;
     addCreator("recovery", creator);
   }

AMDiS/src/ElInfo.cc

@@ -56,10 +56,12 @@ namespace AMDiS {
 
     dimOfWorld = Global::getGeo(WORLD);
   }
+ 
 
   ElInfo::~ElInfo()
   {}
 
+
   void ElInfo::coordToWorld(const DimVec<double>& l, 
 			    WorldVector<double>& w) const
 
@@ -80,12 +82,14 @@ namespace AMDiS {
     }
   }
 
+
   double ElInfo::calcDet() const
   {
     testFlag(Mesh::FILL_COORDS);
     return calcDet(coord);
   }
 
+
   double ElInfo::calcDet(const FixVec<WorldVector<double>, VERTEX> &coords) const
   {
     FUNCNAME("ElInfo::calcDet()");
@@ -114,10 +118,8 @@ namespace AMDiS {
 	det = norm(&e1);
 
       } else {
-
 	det = (coords[1][0] - coords[0][0]) * (coords[2][1] - coords[0][1]) - 
 	  (coords[1][1] - coords[0][1]) * (coords[2][0] - coords[0][0]);
-
       }
       break;
     case 3: 

AMDiS/src/ElInfo2d.cc

@@ -735,13 +735,13 @@ namespace AMDiS {
       vectorProduct(elementNormal, e0, normal);
     }
 
-    double det = norm(&normal);
+    double detn = norm(&normal);
 
-    TEST_EXIT_DBG(det > 1.e-30)("det = 0 on face %d\n", side);
+    TEST_EXIT_DBG(detn > 1.e-30)("det = 0 on face %d\n", side);
 
-    normal *= 1.0 / det;
+    normal *= 1.0 / detn;
     
-    return det;
+    return detn;
   }
 
 
@@ -762,13 +762,13 @@ namespace AMDiS {
 
     vectorProduct(e0, e1, elementNormal);
 
-    double det = norm(&elementNormal);
+    double detn = norm(&elementNormal);
 
-    TEST_EXIT_DBG(det > 1.e-30)("det = 0");
+    TEST_EXIT_DBG(detn > 1.e-30)("det = 0");
 
-    elementNormal *= 1.0 / det;
+    elementNormal *= 1.0 / detn;
     
-    return det;
+    return detn;
   }
 
 

AMDiS/src/ProblemInstat.cc

@@ -16,8 +16,8 @@
 #include "ProblemInstat.h"
 #include "AdaptStationary.h"
 #include "AdaptInstationary.h"
-#include "Estimator.h"
 #include "StandardProblemIteration.h"
+#include "est/Estimator.h"
 #include "io/FileWriter.h"
 
 namespace AMDiS {

AMDiS/src/ProblemStat.cc

@@ -14,14 +14,12 @@
 #include <boost/lexical_cast.hpp>
 
 #include "ProblemStat.h"
-#include "RecoveryEstimator.h"
 #include "Serializer.h"
 #include "AbstractFunction.h"
 #include "Operator.h"
 #include "SystemVector.h"
 #include "DOFMatrix.h"
 #include "FiniteElemSpace.h"
-#include "Estimator.h"
 #include "Marker.h"
 #include "AdaptInfo.h"
 #include "io/FileWriter.h"
@@ -35,6 +33,7 @@
 #include "PeriodicBC.h"
 #include "Lagrange.h"
 #include "Flag.h"
+#include "est/Estimator.h"
 #include "io/VtkWriter.h"
 #include "io/ValueReader.h"
 #include "ProblemStatDbg.h"
@@ -790,6 +789,8 @@ namespace AMDiS {
 	if (matrix)
 	  nnz += matrix->getBaseMatrix().nnz();
       }
+      
+
 
       // And now assemble boundary conditions on the vectors
       assembleBoundaryConditions(rhs->getDOFVector(i),

AMDiS/src/RobinBC.cc

@@ -11,11 +11,12 @@
 
 
 #include "RobinBC.h"
-#include "Estimator.h"
 #include "Assembler.h"
 #include "DOFVector.h"
 #include "DOFMatrix.h"
 #include "SurfaceOperator.h"
+#include "est/Estimator.h"
+
 #include <math.h>
 
 namespace AMDiS {

AMDiS/src/RobinBC.hh

@@ -10,8 +10,8 @@
 // See also license.opensource.txt in the distribution.
 
 
-#include "Estimator.h"
 #include "Assembler.h"
+#include "est/Estimator.h"
 
 template<typename T>
 void RobinBC<T>::fillLocalBC(DOFVector<T>* vector, 

AMDiS/src/SecondOrderAssembler.cc

@@ -77,9 +77,9 @@ namespace AMDiS {
       newAssembler = new Stand2(op, assembler, quad);
     } else {
       if (pwConst) {
-	newAssembler = new Pre2(op, assembler, quad);
+    	newAssembler = new Pre2(op, assembler, quad);
       } else {
-	newAssembler = new Quad2(op, assembler, quad);
+    	newAssembler = new Quad2(op, assembler, quad);
       }
     }
 
@@ -330,7 +330,7 @@ namespace AMDiS {
 	for (int i = 0; i < nRow; i++) {
 	  (*(psi->getGrdPhi(i)))(quadrature->getLambda(iq), grdPsi);
 	  for (int j = 0; j < nCol; j++) {
-	    tmpVec = (LALt[iq] * grdPhi[j]);
+	    tmpVec = (LALt[iq] * grdPhi[j]);	 
 	    mat[i][j] += quadrature->getWeight(iq) * dot(grdPsi, tmpVec);
 	  }
 	}

AMDiS/src/SecondOrderTerm.h

@@ -132,7 +132,8 @@ namespace AMDiS {
     }
 
     /// Implements SecondOrderTerm::getLALt().
-    inline void getLALt(const ElInfo *elInfo, vector<mtl::dense2D<double> > &LALt) const
+    inline void getLALt(const ElInfo *elInfo, 
+			vector<mtl::dense2D<double> > &LALt) const
     {
       const DimVec<WorldVector<double> > &grdLambda = elInfo->getGrdLambda();
       const int nPoints = static_cast<int>(LALt.size());

AMDiS/src/Triangle.cc

@@ -52,16 +52,16 @@ namespace AMDiS {
   }
 
   const FixVec<int, WORLD>& Triangle::sortFaceIndices(int face, 
-						      FixVec<int,WORLD> *vec) const
+						      FixVec<int, WORLD> *vec) const
   {
-    static MatrixOfFixVecs<FixVec<int,WORLD> > *sorted_2d = NULL;
+    static MatrixOfFixVecs<FixVec<int, WORLD> > *sorted_2d = NULL;
 
     int no = 0;
-    FixVec<int,WORLD> *val = NULL;
+    FixVec<int, WORLD> *val = NULL;
     const int *vof = vertexOfEdge[face];
 
     if (NULL == sorted_2d) {
-      sorted_2d = new MatrixOfFixVecs<FixVec<int,WORLD> >(2, 3, 2, NO_INIT);
+      sorted_2d = new MatrixOfFixVecs<FixVec<int, WORLD> >(2, 3, 2, NO_INIT);
 
       (*sorted_2d)[1][0][1] = (*sorted_2d)[1][1][0] =
 	(*sorted_2d)[2][0][0] = (*sorted_2d)[2][1][1] = 0;
@@ -83,7 +83,7 @@ namespace AMDiS {
       val = &((*sorted_2d)[face][no]);
     }
 
-    return *(const_cast<const FixVec<int,WORLD>* >(val));
+    return *(const_cast<const FixVec<int, WORLD>* >(val));
   }
 
 

AMDiS/src/Triangle.h

@@ -95,7 +95,7 @@ namespace AMDiS {
     bool hasSide(Element* sideElem) const;
 
     /// implements Element::sortFaceIndices
-    const FixVec<int,WORLD>& sortFaceIndices(int face, FixVec<int,WORLD> *vec) const;
+    const FixVec<int, WORLD>& sortFaceIndices(int face, FixVec<int, WORLD> *vec) const;
 
     /// implements Element::isLine. Returns false because this element is a Triangle
     inline bool isLine() const 

AMDiS/src/ResidualEstimator.cc → AMDiS/src/est/ResidualEstimator.cc

@@ -322,7 +322,7 @@ namespace AMDiS {
 	    }
 	    if (D2uhqp == NULL && degree > 2 && (*it)->secondOrderTerms()) { 
 	      D2uhqp = new WorldMatrix<double>[nPoints];
-	      uh[system]->getD2AtQPs(elInfo, NULL, quadFast[system], D2uhqp);	    
+	      uh[system]->getD2AtQPs(elInfo, NULL, quadFast[system], D2uhqp);  
 	    }
 	  }
 	}
@@ -533,11 +533,13 @@ namespace AMDiS {
 
       if (factor) {
 	if (D2UhIq)
-	  (*it)->evalSecondOrder(nPoints, uhIq, grdUhIq, D2UhIq, result, -factor);	
+	  (*it)->evalSecondOrder(nPoints, uhIq, grdUhIq, D2UhIq, result, -factor);
 
 	if (grdUhIq) {
-	  (*it)->evalFirstOrderGrdPsi(nPoints, uhIq, grdUhIq, D2UhIq, result, factor);
-	  (*it)->evalFirstOrderGrdPhi(nPoints, uhIq, grdUhIq, D2UhIq, result, factor);
+	  (*it)->evalFirstOrderGrdPsi(nPoints, uhIq, grdUhIq, D2UhIq, 
+				      result, factor);
+	  (*it)->evalFirstOrderGrdPhi(nPoints, uhIq, grdUhIq, D2UhIq, 
+				      result, factor);
 	}
 	
 	if (num_rows(uhIq) > 0)

AMDiS/src/ResidualEstimator.h → AMDiS/src/est/ResidualEstimator.h

@@ -59,7 +59,7 @@ namespace AMDiS {
    * \ingroup Estimator
    * 
    * \brief
-   * Estimator for scalar problems.
+   * Residual estimator.
    */
   class ResidualEstimator : public Estimator
   {
@@ -88,8 +88,8 @@ namespace AMDiS {
     virtual void init(double timestep);
 
     /** \brief
-     * Estimates the error on an element. For more information about the parameter,
-     * see the description \ref Estimator::estimateElement.
+     * Estimates the error on an element. For more information about the
+     * parameter, see the description \ref Estimator::estimateElement.
      */
     virtual void estimateElement(ElInfo *elInfo, DualElInfo *dualElInfo = NULL);
 

AMDiS/src/est/SimpleResidualEstimator.h

+// ============================================================================
+// ==                                                                        ==
+// == AMDiS - Adaptive multidimensional simulations                          ==
+// ==                                                                        ==
+// ==  http://www.amdis-fem.org                                              ==
+// ==                                                                        ==
+// ============================================================================
+//
+// Software License for AMDiS
+//
+// Copyright (c) 2010 Dresden University of Technology 
+// All rights reserved.
+// Authors: Simon Vey, Thomas Witkowski et al.
+//
+// This file is part of AMDiS
+//
+// See also license.opensource.txt in the distribution.
+
+
+
+/** \file SimpleResidualEstimator.h */
+
+/** \defgroup Estimator Estimator module
+ * @{ <img src="estimator.png"> @}
+ */
+
+#ifndef AMDIS_SIMPLE_RESIDUAL_ESTIMATOR_H
+#define AMDIS_SIMPLE_RESIDUAL_ESTIMATOR_H
+
+#include "Estimator.h"
+#include "FixVec.h"
+
+namespace AMDiS {
+
+  /**
+   * \ingroup Estimator
+   * 
+   * \brief
+   * Simple Residual estimator.
+   *
+   * The restrictions for using the simple residual estimator are the following:
+   *   - no system of PDEs, thus a PDE with only one unknown
+   *   - no first order terms
+   *   - no time dependent terms
+   */
+  class SimpleResidualEstimator : public Estimator
+  {
+  public:
+    /// Creator class used in the OEMSolverMap.
+    class Creator : public EstimatorCreator
+    {
+    public:
+      Creator() 
+	: EstimatorCreator() 
+      {}
+
+      virtual ~Creator() 
+      {}
+
+      /// Returns a new ODirSolver object.
+      Estimator* create() 
+      { 
+	return new SimpleResidualEstimator(name);
+      }
+    };
+  
+    /// Constructor.
+    SimpleResidualEstimator(std::string name);
+
+    /// Init the error estimator.
+    void init(double);
+
+    /// Run estimator on one element. 
+    /// \param[in]   elInfo      Info object for the element to be estimated.
+    /// \param[in]   dualElInfo  Not used here. In general, this may be used for
+    ///                          estimating with the multi-mesh technique.
+    void estimateElement(ElInfo *elInfo, DualElInfo *dualElInfo = NULL);
+
+    /// Finalize the error estimator, i.e., delete all temporary data structures.
+    void exit(bool output = true);
+
+    /// Returns pow(det,2.0/dim).
+    inline double h2_from_det(double det, int dim) 
+    {
+      return pow(det, 2.0 / dim);
+    }
+
+  protected:
+    /// Computes the element residual for a given element.
+    double computeElementResidual(ElInfo *elInfo);
+
+    /// Computes the jump residual for a given element.
+    double computeJumpResidual(ElInfo *elInfo);
+
+    /** \brief
+     * Returns residual square at quadrature point. Not Member of
+     * Estimator to avoid multiple instantiation.
+     *
+     * \param[in]  elInfo   Current element information object.
+     * \param[in]  nPoints  Number of quadrature points on this element.
+     * \param[in]  uhIq     Solution vector on element quadrature points.
+     * \param[in]  D2UhIq   Second derivations of the solution vector on
+     *                      element quadrature points.
+     * \param[in]  A        Matrix that contains the left hand side operators.
+     * \param[in]  fh       Vector that contains the right hand side operators.
+     * \param[in]  quad     Object for numerical quadrature.
+     * \param[out] result   Vector containing the residual on the quadrature 
+     *                      points.
+     */
+    void r(const ElInfo *elInfo,
+	   int nPoints,
+	   const ElementVector& uhIq,
+	   const WorldMatrix<double> *D2UhIq,
+	   DOFMatrix *A, 
+	   DOFVector<double> *fh,
+	   Quadrature *quad,
+	   ElementVector& result);
+ 
+  protected:
+    /// Constant in front of element residual.
+    double C0;
+ 
+    /// Constant in front of edge/face residual.
+    double C1;
+
+    /// Number of quadrature points.
+    int nPoints;
+
+    /// Dimension of the mesh.
+    int dim;
+
+    /// Polynomial degree.
+    int degree;
+
+    /// Object for numerical quadrature
+    Quadrature *quad;
+
+    /// Object for fast numerical quadrature
+    FastQuadrature *quadFast;
+
+    /// Pointer to the basis functions of the FE space.
+    const BasisFunction *basFcts;
+
+    /// Vector that stores all global DOFs of one element.
+    ElementVector uhEl;
+
+    /// Vector that stores all global DOFs of one element.
+    ElementVector uhNeigh;
+
+    /// Vector that stores values on all quadrature points (QP) on one element.
+    ElementVector uhQP;
+
+    /// Matrix that stores the second derivations on all quadrature points
+    /// on one element.
+    WorldMatrix<double> *D2uhqp; 
+
+    /// Stores the element residual computed at the quadrature points of 
+    /// the element.
+    ElementVector riq;
+
+    /// Pointer to the information object of some neighbouring element.
+    ElInfo *neighInfo;
+
+    /// Surface quadrature object, used for computing the jump residual.
+    Quadrature *surfaceQuad;
+
+    /// Number of quadrature points of the surface quadrature object.
+    int nPointsSurface;
+
+    /// Stores on all surface quadrature points the gradient of a function.
+    std::vector<WorldVector<double> > grdUhEl;
+
+    /// Stores on all surface quadrature points the gradient of a function.
+    std::vector<WorldVector<double> > grdUhNeigh;
+
+    /// Stores on all surface quadrature points the jump of a function.
+    std::vector<WorldVector<double> > jump;
+
+    /// Stores on all surface quadrature points the jump of a function.
+    std::vector<WorldVector<double> > localJump;
+
+    /// Vector to store, for a given element, all its neighbouring element indices.
+    WorldVector<int> faceIndEl;
+
+    /// Vector to store, for a given element, all its neighbouring element indices.
+    WorldVector<int> faceIndNeigh;
+
+    DimVec<WorldVector<double> > *lambdaNeigh;
+    
+    DimVec<double> *lambda;
+
+    /// Maximal number of neighbours an element may have in the used dimension.
+    int nNeighbours;
+  };
+}
+
+#endif // AMDIS_SIMPLE_RESIDUAL_ESTIMATOR_H

AMDiS/src/io/MacroReader.cc

@@ -1270,6 +1270,7 @@ namespace AMDiS {
     }
   }
 
+
   int MacroReader::basicCheckFct(ElInfo* elinfo, Mesh *mesh)
   {
     FUNCNAME("MacroReader::basicCheckFct()");