Commit e43e8013 authored by Thomas Witkowski's avatar Thomas Witkowski

SimpleResidualEstimator ready and documented.

parent 97be72e8
......@@ -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/)
......
......@@ -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"
......
......@@ -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"
......
......@@ -12,7 +12,7 @@
#include "AdaptStationary.h"
#include "Initfile.h"
#include "Estimator.h"
#include "est/Estimator.h"
#include "ProblemIterationInterface.h"
#include <math.h>
......
......@@ -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) {
......
......@@ -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);
}
......
......@@ -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:
......
......@@ -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;
}
......
......@@ -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 {
......
......@@ -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),
......
......@@ -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 {
......
......@@ -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,
......
......@@ -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);
}
}
......
......@@ -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());
......
......@@ -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));
}
......
......@@ -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
......
......@@ -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)
......
......@@ -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);
......
This diff is collapsed.
// ============================================================================
// == ==
// == 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
......@@ -1270,6 +1270,7 @@ namespace AMDiS {
}
}
int MacroReader::basicCheckFct(ElInfo* elinfo, Mesh *mesh)
{
FUNCNAME("MacroReader::basicCheckFct()");
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment