ErrorEstimator

Section: C Library Functions (3) Updated: Thu Apr 7 2011 Local index Up

NAME

ErrorEstimator -

SYNOPSIS

Inherited by AdjointResidualErrorEstimator, ExactErrorEstimator, JumpErrorEstimator, PatchRecoveryErrorEstimator, and UniformRefinementEstimator.

Public Types

typedef std::map< std::pair< const System *, unsigned int >, ErrorVector * > ErrorMap

Public Member Functions

ErrorEstimator ()

virtual ~ErrorEstimator ()

virtual void estimate_error (const System &system, ErrorVector &error_per_cell, const NumericVector< Number > *solution_vector=NULL, bool estimate_parent_error=false)=0

virtual void estimate_errors (const EquationSystems &equation_systems, ErrorVector &error_per_cell, const std::map< const System *, SystemNorm > &error_norms, const std::map< const System *, const NumericVector< Number > * > *solution_vectors=NULL, bool estimate_parent_error=false)

virtual void estimate_errors (const EquationSystems &equation_systems, ErrorMap &errors_per_cell, const std::map< const System *, const NumericVector< Number > * > *solution_vectors=NULL, bool estimate_parent_error=false)

Public Attributes

SystemNorm error_norm

Protected Member Functions

void reduce_error (std::vector< float > &error_per_cell) const

Detailed Description

This class holds functions that will estimate the error in a finite element solution on a given mesh. These error estimates can be useful in their own right, or may be used to guide adaptive mesh refinement. Note that in general the computed errors are stored as floats rather than doubles since the required precision is low.

Author:

: Benjamin S. Kirk, 2003.

Definition at line 50 of file error_estimator.h.

Member Typedef Documentation

typedef std::map<std::pair<const System, unsigned int>, ErrorVector> ErrorEstimator::ErrorMapWhen calculating many error vectors at once, we need a data structure to hold them all

Definition at line 105 of file error_estimator.h.

Constructor & Destructor Documentation

ErrorEstimator::ErrorEstimator () [inline]Constructor. Empty. Derived classes should reset error_norm as appropriate.

Definition at line 58 of file error_estimator.h.

: error_norm() {}

virtual ErrorEstimator::~ErrorEstimator () [inline, virtual]Destructor.

Definition at line 63 of file error_estimator.h.

{}

Member Function Documentation

virtual void ErrorEstimator::estimate_error (const System &system, ErrorVector &error_per_cell, const NumericVector< Number > *solution_vector = NULL, boolestimate_parent_error = false) [pure virtual]This pure virtual function must be redefined in derived classes to compute the error for each active element and place it in the 'error_per_cell' vector.

If solution_vector is not NULL, the estimator will (if able) attempt to estimate an error in that field instead of in system.solution.

If estimate_parent_error is not false, the estimator will (if able) attempt to give a consistent estimate of errors in parent elements that would be generated by coarsening.

Implemented in AdjointResidualErrorEstimator, ExactErrorEstimator, JumpErrorEstimator, PatchRecoveryErrorEstimator, and UniformRefinementEstimator.

Referenced by estimate_errors().

void ErrorEstimator::estimate_errors (const EquationSystems &equation_systems, ErrorVector &error_per_cell, const std::map< const System , SystemNorm > &error_norms, const std::map< const System , const NumericVector< Number > * > *solution_vectors = NULL, boolestimate_parent_error = false) [virtual]This virtual function can be redefined in derived classes, but by default computes the sum of the error_per_cell for each system in the equation_systems.

Currently this function ignores the error_norm member variable, and uses the function argument error_norms instead.

This function is named estimate_errors instead of estimate_error because otherwise C++ can get confused.

Reimplemented in UniformRefinementEstimator.

Definition at line 46 of file error_estimator.C.

References error_norm, estimate_error(), EquationSystems::get_system(), and EquationSystems::n_systems().

{
  SystemNorm old_error_norm = this->error_norm;

  // Sum the error values from each system
  for (unsigned int s = 0; s != equation_systems.n_systems(); ++s)
    {
      ErrorVector system_error_per_cell;
      const System &sys = equation_systems.get_system(s);
      if (error_norms.find(&sys) == error_norms.end())
        this->error_norm = old_error_norm;
      else
        this->error_norm = error_norms.find(&sys)->second;

      const NumericVector<Number>* solution_vector = NULL;
      if (solution_vectors &&
          solution_vectors->find(&sys) != solution_vectors->end())
        solution_vector = solution_vectors->find(&sys)->second;

      this->estimate_error(sys, system_error_per_cell,
                           solution_vector, estimate_parent_error);

      if (s)
        {
          libmesh_assert(error_per_cell.size() == system_error_per_cell.size());
          for (unsigned int i=0; i != error_per_cell.size(); ++i)
            error_per_cell[i] += system_error_per_cell[i];
        }
      else
        error_per_cell = system_error_per_cell;
    }

  // Restore our old state before returning
  this->error_norm = old_error_norm;
}

void ErrorEstimator::estimate_errors (const EquationSystems &equation_systems, ErrorMap &errors_per_cell, const std::map< const System , const NumericVector< Number > > *solution_vectors = NULL, boolestimate_parent_error = false) [virtual]This virtual function can be redefined in derived classes, but by default it calls estimate_error repeatedly to calculate the requested error vectors.

Currently this function ignores the error_norm.weight() values because it calculates each variable's error individually, unscaled.

The user selects which errors get computed by filling a map with error vectors: If errors_per_cell[&system][v] exists, it will be filled with the error values in variable v of system

FIXME: This is a default implementation - derived classes should reimplement it for efficiency.

Reimplemented in UniformRefinementEstimator.

Definition at line 92 of file error_estimator.C.

References error_norm, estimate_error(), EquationSystems::get_system(), EquationSystems::n_systems(), System::n_vars(), and SystemNorm::type().

{
  SystemNorm old_error_norm = this->error_norm;

  // Find the requested error values from each system
  for (unsigned int s = 0; s != equation_systems.n_systems(); ++s)
    {
      const System &sys = equation_systems.get_system(s);

      unsigned int n_vars = sys.n_vars();

      for (unsigned int v = 0; v != n_vars; ++v)
        {
          // Only fill in ErrorVectors the user asks for
          if (errors_per_cell.find(std::make_pair(&sys, v)) ==
              errors_per_cell.end())
            continue;

          // Calculate error in only one variable
          std::vector<Real> weights(n_vars, 0.0);
          weights[v] = 1.0;
          this->error_norm =
            SystemNorm(std::vector<FEMNormType>(n_vars, old_error_norm.type(0)),
                       weights);

          const NumericVector<Number>* solution_vector = NULL;
          if (solution_vectors &&
              solution_vectors->find(&sys) != solution_vectors->end())
            solution_vector = solution_vectors->find(&sys)->second;

          this->estimate_error
            (sys, *errors_per_cell[std::make_pair(&sys, v)],
             solution_vector, estimate_parent_error);
        }
    }

  // Restore our old state before returning
  this->error_norm = old_error_norm;
}

void ErrorEstimator::reduce_error (std::vector< float > &error_per_cell) const [protected]This method takes the local error contributions in error_per_cell from each processor and combines them to get the global error vector.

Definition at line 32 of file error_estimator.C.

Referenced by UniformRefinementEstimator::_estimate_error(), PatchRecoveryErrorEstimator::estimate_error(), and JumpErrorEstimator::estimate_error().

{
  // This function must be run on all processors at once
  parallel_only();

  // Each processor has now computed the error contribuions
  // for its local elements.  We may need to sum the vector to
  // recover the error for each element.
  
  Parallel::sum(error_per_cell);
}

Member Data Documentation

SystemNorm ErrorEstimator::error_normWhen estimating the error in a single system, the error_norm is used to control the scaling and norm choice for each variable. Not all estimators will support all norm choices. The default scaling is for all variables to be weighted equally. The default norm choice depends on the error estimator.

Part of this functionality was supported via component_scale and sobolev_order in older libMesh versions, and a small part was supported via component_mask in even older versions. Hopefully the encapsulation here will allow us to avoid changing this API again.

Definition at line 137 of file error_estimator.h.

Referenced by UniformRefinementEstimator::_estimate_error(), KellyErrorEstimator::boundary_side_integration(), DiscontinuityMeasure::boundary_side_integration(), DiscontinuityMeasure::DiscontinuityMeasure(), JumpErrorEstimator::estimate_error(), estimate_errors(), ExactErrorEstimator::ExactErrorEstimator(), ExactErrorEstimator::find_squared_element_error(), KellyErrorEstimator::internal_side_integration(), LaplacianErrorEstimator::internal_side_integration(), DiscontinuityMeasure::internal_side_integration(), KellyErrorEstimator::KellyErrorEstimator(), LaplacianErrorEstimator::LaplacianErrorEstimator(), PatchRecoveryErrorEstimator::EstimateError::operator()(), PatchRecoveryErrorEstimator::PatchRecoveryErrorEstimator(), and UniformRefinementEstimator::UniformRefinementEstimator().