KASKADE 7 development version
errorDistribution.hh
Go to the documentation of this file.
1/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2/* */
3/* This file is part of the library KASKADE 7 */
4/* see http://www.zib.de/Numerik/numsoft/kaskade7/ */
5/* */
6/* Copyright (C) 2002-2015 Zuse Institute Berlin */
7/* */
8/* KASKADE 7 is distributed under the terms of the ZIB Academic License. */
9/* see $KASKADE/academic.txt */
10/* */
11/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
12
13#ifndef ERROR_DISTRIBUTION_HH
14#define ERROR_DISTRIBUTION_HH
15
16#include <string>
17
18#include <boost/utility.hpp>
19#include <boost/fusion/include/as_vector.hpp>
20
21#include "fem/assemble.hh"
22#include "fem/functionspace.hh"
23#include "fem/lagrangespace.hh"
24#include "fem/shapefunctioncache.hh"
25
26// forward declarations
27namespace Dune
28{
29 template <class,int> class FieldVector;
30 template <class,int,int> class FieldMatrix;
31 template <class, int> class QuadratureRule;
32}
33
34namespace Kaskade
35{
36 using namespace boost::fusion;
37 using namespace AssemblyDetail;
38
39 enum class ErrorNorm { Energy, L2, H1, H1_half };
40
41 template <class OriginalEvaluators, class ExtensionEvaluators, class Functional,
42 class ArgYH, class ArgYE, class ArgUH, class ArgUE, class ArgPH, class ArgPE>
43 void evaluateData(OriginalEvaluators& originalEvaluators, ExtensionEvaluators& extendedEvaluators, Functional const& f,
44 ArgYH& yl, ArgYE& yh, ArgUH& ul, ArgUE& uh, ArgPH& pl, ArgPE& ph, double w)
45 {
46 if( f.considerControlVariable_ )
47 {
48 uh.value += w * at_c<Functional::uIdx>(f.errorEstimateH.data).value(at_c<Functional::uSHIdx>(extendedEvaluators));
49 ul.value += w * at_c<Functional::uIdx>(f.errorEstimateL.data).value(at_c<Functional::uSLIdx>(originalEvaluators));
50 uh.gradient += w * at_c<Functional::uIdx>(f.errorEstimateH.data).gradient(at_c<Functional::uSHIdx>(extendedEvaluators));
51 ul.gradient += w * at_c<Functional::uIdx>(f.errorEstimateL.data).gradient(at_c<Functional::uSLIdx>(originalEvaluators));
52 }
53 if( f.considerStateVariable_ )
54 {
55 yh.value += w * at_c<Functional::yIdx>(f.errorEstimateH.data).value(at_c<Functional::ySHIdx>(extendedEvaluators));
56 yl.value += w * at_c<Functional::yIdx>(f.errorEstimateL.data).value(at_c<Functional::ySLIdx>(originalEvaluators));
57 yh.gradient += w * at_c<Functional::yIdx>(f.errorEstimateH.data).gradient(at_c<Functional::ySHIdx>(extendedEvaluators));
58 yl.gradient += w * at_c<Functional::yIdx>(f.errorEstimateL.data).gradient(at_c<Functional::ySLIdx>(originalEvaluators));
59 }
60 if( f.considerAdjointVariable_ )
61 {
62 ph.value += w * at_c<Functional::pIdx>(f.errorEstimateH.data).value(at_c<Functional::pSHIdx>(extendedEvaluators));
63 pl.value += w * at_c<Functional::pIdx>(f.errorEstimateL.data).value(at_c<Functional::pSLIdx>(originalEvaluators));
64 ph.gradient += w * at_c<Functional::pIdx>(f.errorEstimateH.data).gradient(at_c<Functional::pSHIdx>(extendedEvaluators));
65 pl.gradient += w * at_c<Functional::pIdx>(f.errorEstimateL.data).gradient(at_c<Functional::pSLIdx>(extendedEvaluators));
66 }
67 }
68
69 template <class ArgYL, class ArgYH, class ArgUL, class ArgUH, class ArgPL, class ArgPH>
70 void clearVarArgs(ArgYL& yl, ArgYH& yh, ArgUL& ul, ArgUH& uh, ArgPL& pl, ArgPH& ph)
71 {
72 ul.value = 0; ul.gradient = 0;
73 yl.value = 0; yl.gradient = 0;
74 pl.value = 0; pl.gradient = 0;
75 uh.value = 0; uh.gradient = 0;
76 yh.value = 0; yh.gradient = 0;
77 ph.value = 0; ph.gradient = 0;
78 }
79
80 template <class ArgU, class ArgY, class ArgP>
81 double computeL2Error(ArgU const& u, ArgY const& y, ArgP const& p)
82 {
83 return u.value*u.value + y.value*y.value + p.value*p.value;
84 }
85
86 template <class ArgU, class ArgY, class ArgP>
87 double computeH1HalfError(ArgU const& u, ArgY const& y, ArgP const& p)
88 {
89 LinAlg::EuclideanScalarProduct sp;
90 return sp(u.gradient,u.gradient) + sp(y.gradient,y.gradient) + sp(p.gradient,p.gradient);
91 }
92
93
94 template <class Functional, class ExtendedAnsatzVars >
95 class ErrorDistribution
96 {
97 typedef typename Functional::AnsatzVars OriginalAnsatzVars;
98 typedef typename OriginalAnsatzVars::Grid Grid;
99 typedef ShapeFunctionCache<Grid, typename Functional::Scalar> SfCache;
100 typedef ShapeFunctionCache<Grid, typename Functional::Scalar> SfCache2;
101 typedef typename OriginalAnsatzVars::Spaces OriginalSpaces;
102 typedef typename ExtendedAnsatzVars::Spaces ExtendedSpaces;
103 typedef typename result_of::as_vector<typename result_of::transform<OriginalSpaces, GetEvaluators<SfCache> >::type>::type OriginalEvaluators;
104 typedef typename result_of::as_vector<typename result_of::transform<ExtendedSpaces, GetEvaluators<SfCache2> >::type>::type ExtendedEvaluators;
105 typedef typename Grid::ctype CoordType;
106 typedef Dune::QuadratureRule<typename Functional::AnsatzVars::Grid::ctype, Functional::AnsatzVars::Grid::dimension> QuadRule;
107 typedef Dune::QuadratureRule<typename Functional::AnsatzVars::Grid::ctype, Functional::AnsatzVars::Grid::dimension-1> FaceQuadRule;
108 public:
109 typedef typename Functional::Scalar Scalar;
110 typedef FEFunctionSpace<DiscontinuousLagrangeMapper<Scalar,typename Grid::LeafGridView> > AnsatzSpace;
111 typedef boost::fusion::vector<AnsatzSpace const*> AnsatzSpaces;
112 typedef Variable<SpaceIndex<0>,Components<1>,VariableId<0> > AnsatzVariableInformation;
113 typedef boost::fusion::vector<AnsatzVariableInformation> VariableDescriptions;
114 typedef VariableSetDescription<AnsatzSpaces,VariableDescriptions> AnsatzVars;
115 typedef typename AnsatzVars::template CoefficientVectorRepresentation<0,1>::type ErrorVector;
116 typedef AnsatzVars TestVars;
117 typedef OriginalAnsatzVars OriginVars;
118 //typedef AnsatzVars OriginVars;
119 static int const dim = Grid::dimension;
120 static ProblemType const type = Functional::type;
121
122 static constexpr int yIdx = getStateId<Functional>();
123 static constexpr int uIdx = getControlId<Functional>();
124 static constexpr int pIdx = getAdjointId<Functional>();
125 static constexpr int uSLIdx = result_of::value_at_c<typename OriginalAnsatzVars::Variables, uIdx>::type::spaceIndex;
126 static constexpr int ySLIdx = result_of::value_at_c<typename OriginalAnsatzVars::Variables, yIdx>::type::spaceIndex;
127 static constexpr int pSLIdx = result_of::value_at_c<typename OriginalAnsatzVars::Variables, pIdx>::type::spaceIndex;
128 static constexpr int uSHIdx = result_of::value_at_c<typename ExtendedAnsatzVars::Variables, uIdx>::type::spaceIndex;
129 static constexpr int ySHIdx = result_of::value_at_c<typename ExtendedAnsatzVars::Variables, yIdx>::type::spaceIndex;
130 static constexpr int pSHIdx = result_of::value_at_c<typename ExtendedAnsatzVars::Variables, pIdx>::type::spaceIndex;
131
132 class DomainCache
133 {
134 public:
135 DomainCache(ErrorDistribution const& f_, typename OriginVars::VariableSet const& /*vars*/, int flags=7)
136 : f(f_), domainCache(f.functional,f.iterate,flags)
137 {
138 }
139
140 template <class Entity>
141 void moveTo(Entity const &entity)
142 {
143 e = &entity;
144 domainCache.moveTo(entity);
145 }
146
147 template <class Position, class Evaluators>
148 void evaluateAt(Position const&, Evaluators const& evaluators)
149 {
150 clearVarArgs(yl,yh,ul,uh,pl,ph);
151 OriginalEvaluators originalEvaluators(transform(f.iterate.descriptions.spaces,GetEvaluators<SfCache>(&sfCache)));
152 ExtendedEvaluators extendedEvaluators(transform(f.errorEstimateH.descriptions.spaces,GetEvaluators<SfCache>(&extendedSFCache)));
153 QuadRule qr = QuadratureTraits<QuadRule>().rule(e->type(),f.qOrder);
154 moveEvaluatorsToCell(originalEvaluators,*e);
155 moveEvaluatorsToCell(extendedEvaluators,*e);
156 useQuadratureRuleInEvaluators(originalEvaluators,qr,0);
157 useQuadratureRuleInEvaluators(extendedEvaluators,qr,0);
158
159 size_t nQuadPos = qr.size();
160 for (size_t g=0; g<nQuadPos; ++g)
161 {
162 // pos of integration point
163 Dune::FieldVector<CoordType,dim> quadPos = qr[g].position();
164 // for all spaces involved, update the evaluators associated
165 // to this quadrature point
166 moveEvaluatorsToIntegrationPoint(originalEvaluators,quadPos);
167 moveEvaluatorsToIntegrationPoint(extendedEvaluators,quadPos);
168 // prepare evaluation of functional
169 domainCache.evaluateAt(qr[g].position(),originalEvaluators);
170
171 evaluateData(originalEvaluators, extendedEvaluators, f, yl, yh, ul, uh, pl, ph, qr[g].weight());
172 }
173 }
174
175 Scalar d0() const { return 0; }
176
177 template<int row, int dim>
178 Dune::FieldVector<Scalar, TestVars::template Components<row>::m>
179 d1 (VariationalArg<Scalar,dim> const& arg) const
180 {
181 VariationalArg<Scalar,dim,OriginalAnsatzVars::template Components<yIdx>::m> y(yh);
182 VariationalArg<Scalar,dim,OriginalAnsatzVars::template Components<uIdx>::m> u(uh);
183 VariationalArg<Scalar,dim,OriginalAnsatzVars::template Components<pIdx>::m> p(ph);
184
185 if( !f.onlyH_ )
186 {
187 u.value += ul.value;
188 u.gradient += ul.gradient;
189 y.value += yl.value;
190 y.gradient += yl.gradient;
191 p.value += pl.value;
192 p.gradient += pl.gradient;
193 }
194
195 if( f.errorNorm == ErrorNorm::L2 ) return computeL2Error(u,y,p);
196 if( f.errorNorm == ErrorNorm::H1_half ) return computeH1HalfError(u,y,p);
197 if( f.errorNorm == ErrorNorm::H1 ) return computeL2Error(u,y,p) + computeH1HalfError(u,y,p);
198
199 Scalar result = 0;
200 result += Functional::template D2<yIdx,yIdx>::present ? domainCache.template d2_impl<yIdx,yIdx>(y,y) : 0.;
201 result += Functional::template D2<yIdx,uIdx>::present ? domainCache.template d2_impl<yIdx,uIdx>(y,u) : 0.;
202 result += Functional::template D2<uIdx,yIdx>::present ? domainCache.template d2_impl<uIdx,yIdx>(u,y) : 0.;
203 result += Functional::template D2<uIdx,uIdx>::present ? domainCache.template d2_impl<uIdx,uIdx>(u,u) : 0.;
204 if( !f.useStateNormForAdjoint_ )
205 {
206 result += Functional::template D2<yIdx,pIdx>::present ? domainCache.template d2_impl<yIdx,pIdx>(y,p) : 0.;
207 result += Functional::template D2<pIdx,yIdx>::present ? domainCache.template d2_impl<pIdx,yIdx>(p,y) : 0.;
208 result += Functional::template D2<pIdx,uIdx>::present ? domainCache.template d2_impl<pIdx,uIdx>(p,u) : 0.;
209 result += Functional::template D2<uIdx,pIdx>::present ? domainCache.template d2_impl<uIdx,pIdx>(u,p) : 0.;
210 result += Functional::template D2<pIdx,pIdx>::present ? domainCache.template d2_impl<pIdx,pIdx>(p,p) : 0.;
211 }
212 else
213 {
214 result += Functional::template D2<pIdx,pIdx>::present ? domainCache.template d2_impl<yIdx,yIdx>(p,p) : 0.;
215 }
216 return result*arg.value[0];
217 }
218
219 template<int row, int col, int dim>
220 Dune::FieldMatrix<Scalar,1,1> d2 (VariationalArg<Scalar,dim> const&, VariationalArg<Scalar,dim> const&) const { return Dune::FieldMatrix<Scalar,1,1>(0); }
221
222 private:
223 ErrorDistribution const& f;
224 typename Functional::DomainCache domainCache;
225 typename AnsatzVars::Grid::template Codim<0>::Entity const* e;
226 VariationalArg<Scalar,dim,OriginalAnsatzVars::template Components<yIdx>::m> yl;
227 VariationalArg<Scalar,dim,ExtendedAnsatzVars::template Components<yIdx>::m> yh;
228 VariationalArg<Scalar,dim,OriginalAnsatzVars::template Components<uIdx>::m> ul;
229 VariationalArg<Scalar,dim,ExtendedAnsatzVars::template Components<uIdx>::m> uh;
230 VariationalArg<Scalar,dim,OriginalAnsatzVars::template Components<pIdx>::m> pl;
231 VariationalArg<Scalar,dim,ExtendedAnsatzVars::template Components<pIdx>::m> ph;
232 SfCache sfCache;
233 SfCache2 extendedSFCache;
234 };
235
236 class BoundaryCache
237 {
238 public:
239 BoundaryCache(ErrorDistribution const& f_, typename OriginVars::VariableSet const& vars, int flags=7)
240 : f(f_), boundaryCache(f.functional,f.iterate,flags)
241 {}
242
243 template <class FaceIterator>
244 void moveTo(FaceIterator const& entity)
245 {
246 e = &entity;
247 boundaryCache.moveTo(entity);
248 }
249
250 template <class Evaluators>
251 void evaluateAt(Dune::FieldVector<typename AnsatzVars::Grid::ctype, AnsatzVars::Grid::dimension-1> const& xlocal, Evaluators const& evaluators)
252 {
253 clearVarArgs(yl,yh,ul,uh,pl,ph);
254 OriginalEvaluators originalEvaluators(transform(f.iterate.descriptions.spaces,GetEvaluators<SfCache>(&sfCache)));
255 ExtendedEvaluators extendedEvaluators(transform(f.errorEstimateH.descriptions.spaces,GetEvaluators<SfCache>(&extendedSFCache)));
256 FaceQuadRule qr = QuadratureTraits<FaceQuadRule>().rule((*e)->geometryInInside().type(),f.qOrder);
257 moveEvaluatorsToCell(originalEvaluators,*at_c<ySLIdx>(evaluators).cell_);
258 moveEvaluatorsToCell(extendedEvaluators,*at_c<ySLIdx>(evaluators).cell_);
259 moveEvaluatorsToCell(originalEvaluators,*e);
260 moveEvaluatorsToCell(extendedEvaluators,*e);
261 useQuadratureRuleInEvaluators(originalEvaluators,qr,(*e)->indexInInside());
262 useQuadratureRuleInEvaluators(extendedEvaluators,qr,(*e)->indexInInside());
263
264 size_t nQuadPos = qr.size();
265 for (size_t g=0; g<nQuadPos; ++g)
266 {
267 // pos of integration point
268 Dune::FieldVector<CoordType,dim> quadPos = (*e)->geometryInInside().global(qr[g].position());
269 // for all spaces involved, update the evaluators associated
270 // to this quadrature point
271 moveEvaluatorsToIntegrationPoint(originalEvaluators,quadPos);
272 moveEvaluatorsToIntegrationPoint(extendedEvaluators,quadPos);
273 // prepare evaluation of functional
274 boundaryCache.evaluateAt(qr[g].position(),originalEvaluators);
275
276 evaluateData(originalEvaluators, extendedEvaluators, f, yl, yh, ul, uh, pl, ph, qr[g].weight());
277 }
278 }
279
280 Scalar d0() const { return 0; }
281
282 template<int row, int dim>
283 Dune::FieldVector<Scalar,1> d1 (VariationalArg<Scalar,dim> const& arg) const
284 {
285 return Dune::FieldVector<Scalar,1>(0);
286 VariationalArg<Scalar,dim,OriginalAnsatzVars::template Components<yIdx>::m> y(yh);
287 VariationalArg<Scalar,dim,OriginalAnsatzVars::template Components<uIdx>::m> u(uh);
288 VariationalArg<Scalar,dim,OriginalAnsatzVars::template Components<pIdx>::m> p(ph);
289
290 if( !f.onlyH_ )
291 {
292 u.value += ul.value;
293 u.gradient += ul.gradient;
294 y.value += yl.value;
295 y.gradient += yl.gradient;
296 p.value += pl.value;
297 p.gradient += pl.gradient;
298 }
299
300 if( f.errorNorm != ErrorNorm::Energy ) return computeL2Error(u,y,p);
301
302 Scalar result = Functional::template D2<yIdx,yIdx>::present ? boundaryCache.template d2_impl<yIdx,yIdx>(y,y) : 0.;
303 result += Functional::template D2<yIdx,uIdx>::present ? boundaryCache.template d2_impl<yIdx,uIdx>(y,u) : 0.;
304 result += Functional::template D2<uIdx,yIdx>::present ? boundaryCache.template d2_impl<uIdx,yIdx>(u,y) : 0.;
305 result += Functional::template D2<uIdx,uIdx>::present ? boundaryCache.template d2_impl<uIdx,uIdx>(u,u) : 0.;
306 if( !f.useStateNormForAdjoint_ )
307 {
308 result += Functional::template D2<yIdx,pIdx>::present ? boundaryCache.template d2_impl<yIdx,pIdx>(y,p) : 0.;
309 result += Functional::template D2<pIdx,yIdx>::present ? boundaryCache.template d2_impl<pIdx,yIdx>(p,y) : 0.;
310 result += Functional::template D2<pIdx,uIdx>::present ? boundaryCache.template d2_impl<pIdx,uIdx>(p,u) : 0.;
311 result += Functional::template D2<uIdx,pIdx>::present ? boundaryCache.template d2_impl<uIdx,pIdx>(u,p) : 0.;
312 result += Functional::template D2<pIdx,pIdx>::present ? boundaryCache.template d2_impl<pIdx,pIdx>(p,p) : 0.;
313 }
314 else
315 {
316 result += Functional::template D2<pIdx,pIdx>::present ? boundaryCache.template d2_impl<yIdx,yIdx>(p,p) : 0.;
317 }
318 return result*arg.value[0];
319 }
320
321 template<int row, int col, int dim>
322 Dune::FieldMatrix<Scalar,1,1> d2 (VariationalArg<Scalar,dim> const&, VariationalArg<Scalar,dim> const&) const { return Dune::FieldMatrix<Scalar,1,1>(0); }
323
324 private:
325 ErrorDistribution const& f;
326 typename Functional::BoundaryCache boundaryCache;
327 typename AnsatzVars::Grid::LeafGridView::IntersectionIterator const* e;
328 VariationalArg<Scalar,dim,OriginalAnsatzVars::template Components<yIdx>::m> yl;
329 VariationalArg<Scalar,dim,ExtendedAnsatzVars::template Components<yIdx>::m> yh;
330 VariationalArg<Scalar,dim,OriginalAnsatzVars::template Components<uIdx>::m> ul;
331 VariationalArg<Scalar,dim,ExtendedAnsatzVars::template Components<uIdx>::m> uh;
332 VariationalArg<Scalar,dim,OriginalAnsatzVars::template Components<pIdx>::m> pl;
333 VariationalArg<Scalar,dim,ExtendedAnsatzVars::template Components<pIdx>::m> ph;
334 SfCache sfCache;
335 SfCache2 extendedSFCache;
336 };
337
338 ErrorDistribution(Functional const& functional_, typename OriginalAnsatzVars::VariableSet const& iterate_,
339 typename OriginalAnsatzVars::VariableSet const& errorEstimateL_, typename ExtendedAnsatzVars::VariableSet const& errorEstimateH_)
340 : functional(functional_), iterate(iterate_), errorEstimateL(errorEstimateL_), errorEstimateH(errorEstimateH_), ansatzSpace(boost::fusion::at_c<0>(iterate.descriptions.spaces)->gridManager(), iterate.descriptions.gridView,0),
341 ansatzSpaces(&ansatzSpace), varName( {"error"} ), ansatzVars(ansatzSpaces,varName)
342
343 {}
344
345 template <int row>
346 struct D1
347 {
348 static bool const present = true;
349 static bool const constant = false;
350 };
351
352 template <int row, int col>
353 struct D2
354 {
355 static bool const present = false;
356 static bool const symmetric = false;
357 static bool const lumped = false;
358 };
359
360 template <class Cell>
361 int integrationOrder(Cell const&, int, bool) const { return 0; }
362
363 AnsatzSpaces const& getSpaces() const { return ansatzSpaces; }
364
365 AnsatzVars const& getVariableSetDescription() const { return ansatzVars; }
366
367 void ignoreLowerOrderError(bool ignore) { onlyH_ = ignore; }
368 void considerStateVariable(bool consider) { considerStateVariable_ = consider; }
369 void considerControlVariable(bool consider) { considerControlVariable_ = consider; }
370 void considerAdjointVariable(bool consider) { considerAdjointVariable_ = consider; }
371 void setErrorNorm(ErrorNorm errNorm) { errorNorm = errNorm; }
372 void useStateNormForAdjoint(bool useStateNorm) { useStateNormForAdjoint_ = useStateNorm; }
373
374 friend class DomainCache;
375 friend class BoundaryCache;
376
377 Functional const& functional;
378 typename OriginalAnsatzVars::VariableSet const& iterate;
379 typename OriginalAnsatzVars::VariableSet const& errorEstimateL;
380 typename ExtendedAnsatzVars::VariableSet const& errorEstimateH;
381 AnsatzSpace ansatzSpace;
382 AnsatzSpaces ansatzSpaces;
383 std::string varName[1];
384 AnsatzVars ansatzVars;
385 ErrorNorm errorNorm = ErrorNorm::Energy;
386 bool onlyH_ = false, considerStateVariable_ = true, considerControlVariable_ = true, considerAdjointVariable_ = false, useStateNormForAdjoint_ = false;
387 int qOrder = 6;
388 };
389}
390#endif
Kaskade::ErrorDistribution::BoundaryCache::d2
Dune::FieldMatrix< Scalar, 1, 1 > d2(VariationalArg< Scalar, dim > const &, VariationalArg< Scalar, dim > const &) const
Definition: errorDistribution.hh:322
Kaskade::ErrorDistribution::BoundaryCache::moveTo
void moveTo(FaceIterator const &entity)
Definition: errorDistribution.hh:244
Kaskade::ErrorDistribution::BoundaryCache::evaluateAt
void evaluateAt(Dune::FieldVector< typename AnsatzVars::Grid::ctype, AnsatzVars::Grid::dimension-1 > const &xlocal, Evaluators const &evaluators)
Definition: errorDistribution.hh:251
Kaskade::ErrorDistribution::BoundaryCache::BoundaryCache
BoundaryCache(ErrorDistribution const &f_, typename OriginVars::VariableSet const &vars, int flags=7)
Definition: errorDistribution.hh:239
Kaskade::ErrorDistribution::BoundaryCache::d1
Dune::FieldVector< Scalar, 1 > d1(VariationalArg< Scalar, dim > const &arg) const
Definition: errorDistribution.hh:283
Kaskade::ErrorDistribution::DomainCache::DomainCache
DomainCache(ErrorDistribution const &f_, typename OriginVars::VariableSet const &, int flags=7)
Definition: errorDistribution.hh:135
Kaskade::ErrorDistribution::DomainCache::d2
Dune::FieldMatrix< Scalar, 1, 1 > d2(VariationalArg< Scalar, dim > const &, VariationalArg< Scalar, dim > const &) const
Definition: errorDistribution.hh:220
Kaskade::ErrorDistribution::DomainCache::evaluateAt
void evaluateAt(Position const &, Evaluators const &evaluators)
Definition: errorDistribution.hh:148
Kaskade::ErrorDistribution::DomainCache::d1
Dune::FieldVector< Scalar, TestVars::template Components< row >::m > d1(VariationalArg< Scalar, dim > const &arg) const
Definition: errorDistribution.hh:179
Kaskade::ErrorDistribution::ySHIdx
static constexpr int ySHIdx
Definition: errorDistribution.hh:129
Kaskade::ErrorDistribution::uSHIdx
static constexpr int uSHIdx
Definition: errorDistribution.hh:128
Kaskade::ErrorDistribution::setErrorNorm
void setErrorNorm(ErrorNorm errNorm)
Definition: errorDistribution.hh:371
Kaskade::ErrorDistribution::type
static ProblemType const type
Definition: errorDistribution.hh:120
Kaskade::ErrorDistribution::AnsatzVars
VariableSetDescription< AnsatzSpaces, VariableDescriptions > AnsatzVars
Definition: errorDistribution.hh:114
Kaskade::ErrorDistribution::pSHIdx
static constexpr int pSHIdx
Definition: errorDistribution.hh:130
Kaskade::ErrorDistribution::ErrorVector
AnsatzVars::template CoefficientVectorRepresentation< 0, 1 >::type ErrorVector
Definition: errorDistribution.hh:115
Kaskade::ErrorDistribution::errorEstimateH
ExtendedAnsatzVars::VariableSet const & errorEstimateH
Definition: errorDistribution.hh:380
Kaskade::ErrorDistribution::getSpaces
AnsatzSpaces const & getSpaces() const
Definition: errorDistribution.hh:363
Kaskade::ErrorDistribution::AnsatzSpaces
boost::fusion::vector< AnsatzSpace const * > AnsatzSpaces
Definition: errorDistribution.hh:111
Kaskade::ErrorDistribution::getVariableSetDescription
AnsatzVars const & getVariableSetDescription() const
Definition: errorDistribution.hh:365
Kaskade::ErrorDistribution::errorEstimateL
OriginalAnsatzVars::VariableSet const & errorEstimateL
Definition: errorDistribution.hh:379
Kaskade::ErrorDistribution::ErrorDistribution
ErrorDistribution(Functional const &functional_, typename OriginalAnsatzVars::VariableSet const &iterate_, typename OriginalAnsatzVars::VariableSet const &errorEstimateL_, typename ExtendedAnsatzVars::VariableSet const &errorEstimateH_)
Definition: errorDistribution.hh:338
Kaskade::ErrorDistribution::considerStateVariable
void considerStateVariable(bool consider)
Definition: errorDistribution.hh:368
Kaskade::ErrorDistribution::pSLIdx
static constexpr int pSLIdx
Definition: errorDistribution.hh:127
Kaskade::ErrorDistribution::useStateNormForAdjoint
void useStateNormForAdjoint(bool useStateNorm)
Definition: errorDistribution.hh:372
Kaskade::ErrorDistribution::considerAdjointVariable
void considerAdjointVariable(bool consider)
Definition: errorDistribution.hh:370
Kaskade::ErrorDistribution::considerControlVariable
void considerControlVariable(bool consider)
Definition: errorDistribution.hh:369
Kaskade::ErrorDistribution::iterate
OriginalAnsatzVars::VariableSet const & iterate
Definition: errorDistribution.hh:378
Kaskade::ErrorDistribution::AnsatzSpace
FEFunctionSpace< DiscontinuousLagrangeMapper< Scalar, typename Grid::LeafGridView > > AnsatzSpace
Definition: errorDistribution.hh:110
Kaskade::ErrorDistribution::AnsatzVariableInformation
Variable< SpaceIndex< 0 >, Components< 1 >, VariableId< 0 > > AnsatzVariableInformation
Definition: errorDistribution.hh:112
Kaskade::ErrorDistribution::uSLIdx
static constexpr int uSLIdx
Definition: errorDistribution.hh:125
Kaskade::ErrorDistribution::integrationOrder
int integrationOrder(Cell const &, int, bool) const
Definition: errorDistribution.hh:361
Kaskade::ErrorDistribution::ySLIdx
static constexpr int ySLIdx
Definition: errorDistribution.hh:126
Kaskade::ErrorDistribution::ignoreLowerOrderError
void ignoreLowerOrderError(bool ignore)
Definition: errorDistribution.hh:367
Kaskade::ErrorDistribution::VariableDescriptions
boost::fusion::vector< AnsatzVariableInformation > VariableDescriptions
Definition: errorDistribution.hh:113
Kaskade::FEFunctionSpace
A representation of a finite element function space defined over a domain covered by a grid.
Definition: functionspace.hh:1117
Kaskade::GetEvaluators
A boost::fusion functor for creating an evaluator from the space, using a shape function cache that i...
Definition: functionspace.hh:1794
functionspace.hh
FEFunctionSpace and FunctionSpaceElement and the like.
Kaskade::useQuadratureRuleInEvaluators
void useQuadratureRuleInEvaluators(Evaluator &evals, QuadratureRule const &qr, int subId)
Tells all evaluators to use the given quadrature rule on the given subentity.
Definition: functionspace.hh:1912
Kaskade::moveEvaluatorsToIntegrationPoint
void moveEvaluatorsToIntegrationPoint(Evaluators &evals, Dune::FieldVector< CoordType, dim > const &x, Dune::QuadratureRule< CoordType, subDim > const &qr, int ip, int subId)
Moves all provided evaluators to the given integration point, evaluating the shape functions there.
Definition: functionspace.hh:1929
Kaskade::Evaluators
typename boost::fusion::result_of::as_vector< typename boost::fusion::result_of::transform< Spaces, GetEvaluatorTypes >::type >::type Evaluators
the heterogeneous sequence type of Evaluators for the given spaces
Definition: functionspace.hh:1858
Kaskade::ProblemType
ProblemType
A type for describing the nature of a PDE problem.
Definition: functionspace.hh:114
Kaskade::Cell
typename GridView::template Codim< 0 >::Entity Cell
The type of cells (entities of codimension 0) in the grid view.
Definition: gridBasics.hh:35
lagrangespace.hh
Lagrange Finite Elements.
Kaskade::computeH1HalfError
double computeH1HalfError(ArgU const &u, ArgY const &y, ArgP const &p)
Definition: errorDistribution.hh:87
Kaskade::clearVarArgs
void clearVarArgs(ArgYL &yl, ArgYH &yh, ArgUL &ul, ArgUH &uh, ArgPL &pl, ArgPH &ph)
Definition: errorDistribution.hh:70
Kaskade::evaluateData
void evaluateData(OriginalEvaluators &originalEvaluators, ExtensionEvaluators &extendedEvaluators, Functional const &f, ArgYH &yl, ArgYE &yh, ArgUH &ul, ArgUE &uh, ArgPH &pl, ArgPE &ph, double w)
Definition: errorDistribution.hh:43
Kaskade::moveEvaluatorsToCell
void moveEvaluatorsToCell(Evaluators &evals, Cell const &cell)
Moves all provided evaluators to the given cell.
Definition: functionspace.hh:1888
Kaskade::computeL2Error
double computeL2Error(ArgU const &u, ArgY const &y, ArgP const &p)
Definition: errorDistribution.hh:81
Kaskade::Components
Helper class for specifying the number of components of a variable.
Definition: variables.hh:100
Kaskade::QuadratureTraits
A cache that stores suitable quadrature rules for quick retrieval.
Definition: quadrature.hh:35
Kaskade::QuadratureTraits::rule
static Rule const & rule(const Dune::GeometryType &t, int p)
Definition: quadrature.hh:38
Kaskade::Variable
A class defining elementary information about a single variable.
Definition: variables.hh:128
Kaskade::VariationalArg
A class that stores values, gradients, and Hessians of evaluated shape functions.
Definition: shapefunctioncache.hh:53
Kaskade::VariationalArg::value
ValueType value
The shape function's value, a vector of dimension components
Definition: shapefunctioncache.hh:83
Generated on Fri Sep 6 2024 13:12:58 for KASKADE 7 development version by doxygen 1.9.4