libMesh::AdjointResidualErrorEstimator Class Reference

#include <adjoint_residual_error_estimator.h>

Inheritance diagram for libMesh::AdjointResidualErrorEstimator:

Public Types

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

Public Member Functions

 AdjointResidualErrorEstimator ()
 
 ~AdjointResidualErrorEstimator ()
 
std::unique_ptr< ErrorEstimator > & primal_error_estimator ()
 
std::unique_ptr< ErrorEstimator > & dual_error_estimator ()
 
QoISetqoi_set ()
 
const QoISetqoi_set () const
 
virtual void estimate_error (const System &system, ErrorVector &error_per_cell, const NumericVector< Number > *solution_vector=libmesh_nullptr, bool estimate_parent_error=false) libmesh_override
 
virtual ErrorEstimatorType type () const libmesh_override
 
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=libmesh_nullptr, 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=libmesh_nullptr, bool estimate_parent_error=false)
 

Public Attributes

std::string error_plot_suffix
 
SystemNorm error_norm
 

Protected Member Functions

void reduce_error (std::vector< ErrorVectorReal > &error_per_cell, const Parallel::Communicator &comm LIBMESH_CAN_DEFAULT_TO_COMMWORLD) const
 

Protected Attributes

std::unique_ptr< ErrorEstimator_primal_error_estimator
 
std::unique_ptr< ErrorEstimator_dual_error_estimator
 
QoISet _qoi_set
 

Detailed Description

This class implements a goal oriented error indicator, by weighting residual-based estimates from the primal problem against estimates from the adjoint problem.

This is based on a trick suggested by Brian Carnes, (first proposed by Babuska and Miller in 1984) but if it doesn't actually work then the misunderstanding or misimplementation will be the fault of Roy Stogner. It's also Roy's fault there's no literature reference here yet.

Author
Roy H. Stogner
Date
2009

Definition at line 50 of file adjoint_residual_error_estimator.h.

Member Typedef Documentation

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

When calculating many error vectors at once, we need a data structure to hold them all

Definition at line 113 of file error_estimator.h.

Constructor & Destructor Documentation

libMesh::AdjointResidualErrorEstimator::AdjointResidualErrorEstimator ( )

Constructor. Responsible for picking default subestimators.

Definition at line 39 of file adjoint_residual_error_estimator.C.

39  :
42  _primal_error_estimator(new PatchRecoveryErrorEstimator()),
43  _dual_error_estimator(new PatchRecoveryErrorEstimator()),
44  _qoi_set(QoISet())
45 {
46 }
std::unique_ptr< ErrorEstimator > _dual_error_estimator
std::unique_ptr< ErrorEstimator > _primal_error_estimator
libMesh::AdjointResidualErrorEstimator::~AdjointResidualErrorEstimator ( )
inline

Destructor.

Definition at line 62 of file adjoint_residual_error_estimator.h.

62 {}

Member Function Documentation

std::unique_ptr<ErrorEstimator>& libMesh::AdjointResidualErrorEstimator::dual_error_estimator ( )
inline

Access to the "subestimator" (default: PatchRecovery) to use on the dual/adjoint solution

Definition at line 74 of file adjoint_residual_error_estimator.h.

References _dual_error_estimator.

74 { return _dual_error_estimator; }
std::unique_ptr< ErrorEstimator > _dual_error_estimator
void libMesh::AdjointResidualErrorEstimator::estimate_error ( const System system,
ErrorVector error_per_cell,
const NumericVector< Number > *  solution_vector = libmesh_nullptr,
bool  estimate_parent_error = false 
)
virtual

Compute the adjoint-weighted error on each element and place it in the error_per_cell vector.

Note
this->error_norm is ignored; the error estimate is in the seminorm given by the absolute value of the error in the quantity of interest functional. The primal and dual subestimator error_norm values are used, and should be chosen appropriately for your model.

Implements libMesh::ErrorEstimator.

Definition at line 50 of file adjoint_residual_error_estimator.C.

References _dual_error_estimator, _primal_error_estimator, _qoi_set, libMesh::System::adjoint_solve(), libMesh::SystemNorm::calculate_norm(), libMesh::ErrorEstimator::error_norm, error_plot_suffix, libMesh::ErrorVectorReal, libMesh::System::get_adjoint_solution(), libMesh::System::get_equation_systems(), libMesh::System::get_mesh(), libMesh::QoISet::has_index(), libMesh::System::is_adjoint_already_solved(), libMesh::SystemNorm::is_identity(), libMesh::MeshBase::max_elem_id(), mesh, n_vars, libMesh::System::n_vars(), libMesh::ErrorVector::plot_error(), libMesh::System::qoi, libMesh::Real, libMesh::System::solution, and libMesh::QoISet::weight().

54 {
55  LOG_SCOPE("estimate_error()", "AdjointResidualErrorEstimator");
56 
57  // The current mesh
58  const MeshBase & mesh = _system.get_mesh();
59 
60  // Resize the error_per_cell vector to be
61  // the number of elements, initialize it to 0.
62  error_per_cell.resize (mesh.max_elem_id());
63  std::fill (error_per_cell.begin(), error_per_cell.end(), 0.);
64 
65  // Get the number of variables in the system
66  unsigned int n_vars = _system.n_vars();
67 
68  // We need to make a map of the pointer to the solution vector
69  std::map<const System *, const NumericVector<Number> *>solutionvecs;
70  solutionvecs[&_system] = _system.solution.get();
71 
72  // Solve the dual problem if we have to
73  if (!_system.is_adjoint_already_solved())
74  {
75  // FIXME - we'll need to change a lot of APIs to make this trick
76  // work with a const System...
77  System & system = const_cast<System &>(_system);
78  system.adjoint_solve(_qoi_set);
79  }
80 
81  // Flag to check whether we have not been asked to weight the variable error contributions in any specific manner
82  bool error_norm_is_identity = error_norm.is_identity();
83 
84  // Create an ErrorMap/ErrorVector to store the primal, dual and total_dual variable errors
85  ErrorMap primal_errors_per_cell;
86  ErrorMap dual_errors_per_cell;
87  ErrorMap total_dual_errors_per_cell;
88  // Allocate ErrorVectors to this map if we're going to use it
89  if (!error_norm_is_identity)
90  for (unsigned int v = 0; v < n_vars; v++)
91  {
92  primal_errors_per_cell[std::make_pair(&_system, v)] = new ErrorVector;
93  dual_errors_per_cell[std::make_pair(&_system, v)] = new ErrorVector;
94  total_dual_errors_per_cell[std::make_pair(&_system, v)] = new ErrorVector;
95  }
96  ErrorVector primal_error_per_cell;
97  ErrorVector dual_error_per_cell;
98  ErrorVector total_dual_error_per_cell;
99 
100  // Have we been asked to weight the variable error contributions in any specific manner
101  if (!error_norm_is_identity) // If we do
102  {
103  // Estimate the primal problem error for each variable
104  _primal_error_estimator->estimate_errors
105  (_system.get_equation_systems(), primal_errors_per_cell, &solutionvecs, estimate_parent_error);
106  }
107  else // If not
108  {
109  // Just get the combined error estimate
110  _primal_error_estimator->estimate_error
111  (_system, primal_error_per_cell, solution_vector, estimate_parent_error);
112  }
113 
114  // Sum and weight the dual error estimate based on our QoISet
115  for (std::size_t i = 0; i != _system.qoi.size(); ++i)
116  {
117  if (_qoi_set.has_index(i))
118  {
119  // Get the weight for the current QoI
120  Real error_weight = _qoi_set.weight(i);
121 
122  // We need to make a map of the pointer to the adjoint solution vector
123  std::map<const System *, const NumericVector<Number> *>adjointsolutionvecs;
124  adjointsolutionvecs[&_system] = &_system.get_adjoint_solution(i);
125 
126  // Have we been asked to weight the variable error contributions in any specific manner
127  if (!error_norm_is_identity) // If we have
128  {
129  _dual_error_estimator->estimate_errors
130  (_system.get_equation_systems(), dual_errors_per_cell, &adjointsolutionvecs,
131  estimate_parent_error);
132  }
133  else // If not
134  {
135  // Just get the combined error estimate
136  _dual_error_estimator->estimate_error
137  (_system, dual_error_per_cell, &(_system.get_adjoint_solution(i)), estimate_parent_error);
138  }
139 
140  std::size_t error_size;
141 
142  // Get the size of the first ErrorMap vector; this will give us the number of elements
143  if (!error_norm_is_identity) // If in non default weights case
144  {
145  error_size = dual_errors_per_cell[std::make_pair(&_system, 0)]->size();
146  }
147  else // If in the standard default weights case
148  {
149  error_size = dual_error_per_cell.size();
150  }
151 
152  // Resize the ErrorVector(s)
153  if (!error_norm_is_identity)
154  {
155  // Loop over variables
156  for (unsigned int v = 0; v < n_vars; v++)
157  {
158  libmesh_assert(!total_dual_errors_per_cell[std::make_pair(&_system, v)]->size() ||
159  total_dual_errors_per_cell[std::make_pair(&_system, v)]->size() == error_size) ;
160  total_dual_errors_per_cell[std::make_pair(&_system, v)]->resize(error_size);
161  }
162  }
163  else
164  {
165  libmesh_assert(!total_dual_error_per_cell.size() ||
166  total_dual_error_per_cell.size() == error_size);
167  total_dual_error_per_cell.resize(error_size);
168  }
169 
170  for (std::size_t e = 0; e != error_size; ++e)
171  {
172  // Have we been asked to weight the variable error contributions in any specific manner
173  if (!error_norm_is_identity) // If we have
174  {
175  // Loop over variables
176  for (unsigned int v = 0; v < n_vars; v++)
177  {
178  // Now fill in total_dual_error ErrorMap with the weight
179  (*total_dual_errors_per_cell[std::make_pair(&_system, v)])[e] +=
180  static_cast<ErrorVectorReal>
181  (error_weight *
182  (*dual_errors_per_cell[std::make_pair(&_system, v)])[e]);
183  }
184  }
185  else // If not
186  {
187  total_dual_error_per_cell[e] +=
188  static_cast<ErrorVectorReal>(error_weight * dual_error_per_cell[e]);
189  }
190  }
191  }
192  }
193 
194  // Do some debugging plots if requested
195  if (!error_plot_suffix.empty())
196  {
197  if (!error_norm_is_identity) // If we have
198  {
199  // Loop over variables
200  for (unsigned int v = 0; v < n_vars; v++)
201  {
202  std::ostringstream primal_out;
203  std::ostringstream dual_out;
204  primal_out << "primal_" << error_plot_suffix << ".";
205  dual_out << "dual_" << error_plot_suffix << ".";
206 
207  primal_out << std::setw(1)
208  << std::setprecision(0)
209  << std::setfill('0')
210  << std::right
211  << v;
212 
213  dual_out << std::setw(1)
214  << std::setprecision(0)
215  << std::setfill('0')
216  << std::right
217  << v;
218 
219  (*primal_errors_per_cell[std::make_pair(&_system, v)]).plot_error(primal_out.str(), _system.get_mesh());
220  (*total_dual_errors_per_cell[std::make_pair(&_system, v)]).plot_error(dual_out.str(), _system.get_mesh());
221 
222  primal_out.clear();
223  dual_out.clear();
224  }
225  }
226  else // If not
227  {
228  std::ostringstream primal_out;
229  std::ostringstream dual_out;
230  primal_out << "primal_" << error_plot_suffix ;
231  dual_out << "dual_" << error_plot_suffix ;
232 
233  primal_error_per_cell.plot_error(primal_out.str(), _system.get_mesh());
234  total_dual_error_per_cell.plot_error(dual_out.str(), _system.get_mesh());
235 
236  primal_out.clear();
237  dual_out.clear();
238  }
239  }
240 
241  // Weight the primal error by the dual error using the system norm object
242  // FIXME: we ought to thread this
243  for (std::size_t i=0; i != error_per_cell.size(); ++i)
244  {
245  // Have we been asked to weight the variable error contributions in any specific manner
246  if (!error_norm_is_identity) // If we do
247  {
248  // Create Error Vectors to pass to calculate_norm
249  std::vector<Real> cell_primal_error;
250  std::vector<Real> cell_dual_error;
251 
252  for (unsigned int v = 0; v < n_vars; v++)
253  {
254  cell_primal_error.push_back((*primal_errors_per_cell[std::make_pair(&_system, v)])[i]);
255  cell_dual_error.push_back((*total_dual_errors_per_cell[std::make_pair(&_system, v)])[i]);
256  }
257 
258  error_per_cell[i] =
259  static_cast<ErrorVectorReal>
260  (error_norm.calculate_norm(cell_primal_error, cell_dual_error));
261  }
262  else // If not
263  {
264  error_per_cell[i] = primal_error_per_cell[i]*total_dual_error_per_cell[i];
265  }
266  }
267 
268  // Deallocate the ErrorMap contents if we allocated them earlier
269  if (!error_norm_is_identity)
270  for (unsigned int v = 0; v < n_vars; v++)
271  {
272  delete primal_errors_per_cell[std::make_pair(&_system, v)];
273  delete dual_errors_per_cell[std::make_pair(&_system, v)];
274  delete total_dual_errors_per_cell[std::make_pair(&_system, v)];
275  }
276 }
MeshBase & mesh
const unsigned int n_vars
Definition: tecplot_io.C:68
DIE A HORRIBLE DEATH HERE typedef float ErrorVectorReal
Real weight(unsigned int) const
Definition: qoi_set.h:240
std::map< std::pair< const System *, unsigned int >, ErrorVector * > ErrorMap
std::unique_ptr< ErrorEstimator > _dual_error_estimator
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
Real calculate_norm(const std::vector< Real > &v)
Definition: system_norm.h:395
std::unique_ptr< ErrorEstimator > _primal_error_estimator
bool has_index(unsigned int) const
Definition: qoi_set.h:221
void libMesh::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 = libmesh_nullptr,
bool  estimate_parent_error = false 
)
virtualinherited

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 libMesh::UniformRefinementEstimator.

Definition at line 48 of file error_estimator.C.

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

Referenced by libMesh::ErrorEstimator::~ErrorEstimator().

53 {
54  SystemNorm old_error_norm = this->error_norm;
55 
56  // Sum the error values from each system
57  for (unsigned int s = 0; s != equation_systems.n_systems(); ++s)
58  {
59  ErrorVector system_error_per_cell;
60  const System & sys = equation_systems.get_system(s);
61  if (error_norms.find(&sys) == error_norms.end())
62  this->error_norm = old_error_norm;
63  else
64  this->error_norm = error_norms.find(&sys)->second;
65 
66  const NumericVector<Number> * solution_vector = libmesh_nullptr;
67  if (solution_vectors &&
68  solution_vectors->find(&sys) != solution_vectors->end())
69  solution_vector = solution_vectors->find(&sys)->second;
70 
71  this->estimate_error(sys, system_error_per_cell,
72  solution_vector, estimate_parent_error);
73 
74  if (s)
75  {
76  libmesh_assert_equal_to (error_per_cell.size(), system_error_per_cell.size());
77  for (std::size_t i=0; i != error_per_cell.size(); ++i)
78  error_per_cell[i] += system_error_per_cell[i];
79  }
80  else
81  error_per_cell = system_error_per_cell;
82  }
83 
84  // Restore our old state before returning
85  this->error_norm = old_error_norm;
86 }
const class libmesh_nullptr_t libmesh_nullptr
virtual void estimate_error(const System &system, ErrorVector &error_per_cell, const NumericVector< Number > *solution_vector=libmesh_nullptr, bool estimate_parent_error=false)=0
void libMesh::ErrorEstimator::estimate_errors ( const EquationSystems equation_systems,
ErrorMap errors_per_cell,
const std::map< const System *, const NumericVector< Number > * > *  solution_vectors = libmesh_nullptr,
bool  estimate_parent_error = false 
)
virtualinherited

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 libMesh::UniformRefinementEstimator.

Definition at line 94 of file error_estimator.C.

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

98 {
99  SystemNorm old_error_norm = this->error_norm;
100 
101  // Find the requested error values from each system
102  for (unsigned int s = 0; s != equation_systems.n_systems(); ++s)
103  {
104  const System & sys = equation_systems.get_system(s);
105 
106  unsigned int n_vars = sys.n_vars();
107 
108  for (unsigned int v = 0; v != n_vars; ++v)
109  {
110  // Only fill in ErrorVectors the user asks for
111  if (errors_per_cell.find(std::make_pair(&sys, v)) ==
112  errors_per_cell.end())
113  continue;
114 
115  // Calculate error in only one variable
116  std::vector<Real> weights(n_vars, 0.0);
117  weights[v] = 1.0;
118  this->error_norm =
119  SystemNorm(std::vector<FEMNormType>(n_vars, old_error_norm.type(v)),
120  weights);
121 
122  const NumericVector<Number> * solution_vector = libmesh_nullptr;
123  if (solution_vectors &&
124  solution_vectors->find(&sys) != solution_vectors->end())
125  solution_vector = solution_vectors->find(&sys)->second;
126 
127  this->estimate_error
128  (sys, *errors_per_cell[std::make_pair(&sys, v)],
129  solution_vector, estimate_parent_error);
130  }
131  }
132 
133  // Restore our old state before returning
134  this->error_norm = old_error_norm;
135 }
const class libmesh_nullptr_t libmesh_nullptr
const unsigned int n_vars
Definition: tecplot_io.C:68
virtual void estimate_error(const System &system, ErrorVector &error_per_cell, const NumericVector< Number > *solution_vector=libmesh_nullptr, bool estimate_parent_error=false)=0
std::unique_ptr<ErrorEstimator>& libMesh::AdjointResidualErrorEstimator::primal_error_estimator ( )
inline

Access to the "subestimator" (default: PatchRecovery) to use on the primal/forward solution

Definition at line 68 of file adjoint_residual_error_estimator.h.

References _primal_error_estimator.

68 { return _primal_error_estimator; }
std::unique_ptr< ErrorEstimator > _primal_error_estimator
QoISet& libMesh::AdjointResidualErrorEstimator::qoi_set ( )
inline

Access to the QoISet (default: weight all QoIs equally) to use when computing errors

Definition at line 80 of file adjoint_residual_error_estimator.h.

References _qoi_set.

const QoISet& libMesh::AdjointResidualErrorEstimator::qoi_set ( ) const
inline

Access to the QoISet (default: weight all QoIs equally) to use when computing errors

Definition at line 86 of file adjoint_residual_error_estimator.h.

References _qoi_set.

void libMesh::ErrorEstimator::reduce_error ( std::vector< ErrorVectorReal > &  error_per_cell,
const Parallel::Communicator &comm  LIBMESH_CAN_DEFAULT_TO_COMMWORLD 
) const
protectedinherited

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 33 of file error_estimator.C.

References libMesh::Parallel::Communicator::sum().

Referenced by libMesh::UniformRefinementEstimator::_estimate_error(), libMesh::WeightedPatchRecoveryErrorEstimator::estimate_error(), libMesh::PatchRecoveryErrorEstimator::estimate_error(), libMesh::JumpErrorEstimator::estimate_error(), libMesh::AdjointRefinementEstimator::estimate_error(), and libMesh::ExactErrorEstimator::estimate_error().

35 {
36  // This function must be run on all processors at once
37  // parallel_object_only();
38 
39  // Each processor has now computed the error contributions
40  // for its local elements. We may need to sum the vector to
41  // recover the error for each element.
42 
43  comm.sum(error_per_cell);
44 }
virtual ErrorEstimatorType libMesh::AdjointResidualErrorEstimator::type ( ) const
inlinevirtual
Returns
The type for the ErrorEstimator subclass.

Implements libMesh::ErrorEstimator.

Definition at line 112 of file adjoint_residual_error_estimator.h.

References libMesh::ADJOINT_RESIDUAL.

Member Data Documentation

std::unique_ptr<ErrorEstimator> libMesh::AdjointResidualErrorEstimator::_dual_error_estimator
protected

An error estimator for the adjoint problem

Definition at line 125 of file adjoint_residual_error_estimator.h.

Referenced by dual_error_estimator(), and estimate_error().

std::unique_ptr<ErrorEstimator> libMesh::AdjointResidualErrorEstimator::_primal_error_estimator
protected

An error estimator for the forward problem

Definition at line 120 of file adjoint_residual_error_estimator.h.

Referenced by estimate_error(), and primal_error_estimator().

QoISet libMesh::AdjointResidualErrorEstimator::_qoi_set
protected

A QoISet to handle cases with multiple QoIs available

Definition at line 130 of file adjoint_residual_error_estimator.h.

Referenced by estimate_error(), and qoi_set().

SystemNorm libMesh::ErrorEstimator::error_norm
inherited

When 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 150 of file error_estimator.h.

Referenced by libMesh::UniformRefinementEstimator::_estimate_error(), libMesh::AdjointRefinementEstimator::AdjointRefinementEstimator(), libMesh::DiscontinuityMeasure::boundary_side_integration(), libMesh::KellyErrorEstimator::boundary_side_integration(), libMesh::DiscontinuityMeasure::DiscontinuityMeasure(), libMesh::JumpErrorEstimator::estimate_error(), estimate_error(), libMesh::ExactErrorEstimator::estimate_error(), libMesh::ErrorEstimator::estimate_errors(), libMesh::ExactErrorEstimator::ExactErrorEstimator(), libMesh::ExactErrorEstimator::find_squared_element_error(), libMesh::LaplacianErrorEstimator::init_context(), libMesh::DiscontinuityMeasure::init_context(), libMesh::KellyErrorEstimator::init_context(), libMesh::LaplacianErrorEstimator::internal_side_integration(), libMesh::DiscontinuityMeasure::internal_side_integration(), libMesh::KellyErrorEstimator::internal_side_integration(), libMesh::KellyErrorEstimator::KellyErrorEstimator(), libMesh::LaplacianErrorEstimator::LaplacianErrorEstimator(), libMesh::PatchRecoveryErrorEstimator::PatchRecoveryErrorEstimator(), libMesh::JumpErrorEstimator::reinit_sides(), and libMesh::UniformRefinementEstimator::UniformRefinementEstimator().

std::string libMesh::AdjointResidualErrorEstimator::error_plot_suffix

To aid in investigating error estimator behavior, set this string to a suffix with which to plot (prefixed by "primal_" or "dual_") the subestimator results. The suffix should end with a file extension (e.g. ".gmv") that the ErrorVector::plot_error recognizes.

Definition at line 95 of file adjoint_residual_error_estimator.h.

Referenced by estimate_error().


The documentation for this class was generated from the following files: