Line data Source code
1 : /*
2 : * Copyright (c) 2012-2015: G-CSC, Goethe University Frankfurt
3 : * Author: Andreas Vogel
4 : *
5 : * This file is part of UG4.
6 : *
7 : * UG4 is free software: you can redistribute it and/or modify it under the
8 : * terms of the GNU Lesser General Public License version 3 (as published by the
9 : * Free Software Foundation) with the following additional attribution
10 : * requirements (according to LGPL/GPL v3 §7):
11 : *
12 : * (1) The following notice must be displayed in the Appropriate Legal Notices
13 : * of covered and combined works: "Based on UG4 (www.ug4.org/license)".
14 : *
15 : * (2) The following notice must be displayed at a prominent place in the
16 : * terminal output of covered works: "Based on UG4 (www.ug4.org/license)".
17 : *
18 : * (3) The following bibliography is recommended for citation and must be
19 : * preserved in all covered files:
20 : * "Reiter, S., Vogel, A., Heppner, I., Rupp, M., and Wittum, G. A massively
21 : * parallel geometric multigrid solver on hierarchically distributed grids.
22 : * Computing and visualization in science 16, 4 (2013), 151-164"
23 : * "Vogel, A., Reiter, S., Rupp, M., Nägel, A., and Wittum, G. UG4 -- a novel
24 : * flexible software system for simulating pde based models on high performance
25 : * computers. Computing and visualization in science 16, 4 (2013), 165-179"
26 : *
27 : * This program is distributed in the hope that it will be useful,
28 : * but WITHOUT ANY WARRANTY; without even the implied warranty of
29 : * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
30 : * GNU Lesser General Public License for more details.
31 : */
32 :
33 : // extern headers
34 : #include <iostream>
35 : #include <sstream>
36 : #include <string>
37 :
38 : // include bridge
39 : #include "bridge/bridge.h"
40 : #include "bridge/util.h"
41 : #include "bridge/util_domain_algebra_dependent.h"
42 :
43 : // lib_disc includes
44 : #include "lib_disc/common/marking_utils.h"
45 : #include "lib_disc/function_spaces/grid_function.h"
46 : #include "lib_disc/function_spaces/approximation_space.h"
47 : #include "lib_disc/function_spaces/error_indicator.h"
48 : #include "lib_disc/function_spaces/error_elem_marking_strategy.h"
49 : #include "lib_disc/function_spaces/level_transfer.h"
50 : #include "lib_disc/function_spaces/local_transfer.h"
51 :
52 : // error-indicator implementation
53 : #include "lib_grid/grid_objects/constraint_traits.h"
54 : #include "lib_grid/algorithms/normal_calculation.h"
55 : #include "lib_grid/algorithms/volume_calculation.h"
56 :
57 : using namespace std;
58 :
59 : namespace ug{
60 :
61 : #ifdef UG_FOR_LUA
62 : template <typename TDomain, typename TAlgebra>
63 0 : static void MarkForAdaption_L2ErrorExactLUA(IRefiner& refiner,
64 : SmartPtr<GridFunction<TDomain, TAlgebra> > u,
65 : const char* exactSolCallbackName,
66 : const char* cmp,
67 : number minL2Error,
68 : number maxL2Error,
69 : number refFrac,
70 : int minLvl, int maxLvl,
71 : number time, int quadOrder)
72 : {
73 0 : SmartPtr<UserData<number, TDomain::dim> > spCallback
74 0 : = make_sp(new LuaUserData<number, TDomain::dim>(exactSolCallbackName));
75 0 : MarkForAdaption_L2ErrorExact(refiner, u, spCallback, cmp, minL2Error,
76 : maxL2Error, refFrac, minLvl, maxLvl, time, quadOrder);
77 0 : }
78 :
79 : template <typename TDomain, typename TAlgebra>
80 0 : static number MarkForAdaption_ResidualErrorP1AbsoluteLUA(IRefiner& refiner,
81 : SmartPtr<GridFunction<TDomain, TAlgebra> > u,
82 : const char* fCallbackName,
83 : const char* cmp,
84 : number time,
85 : number refTol,
86 : number coarsenTol,
87 : int maxLvl,
88 : int quadOrder, std::string quadType,
89 : bool refTopLvlOnly)
90 : {
91 0 : SmartPtr<UserData<number, TDomain::dim> > spCallback
92 0 : = make_sp(new LuaUserData<number, TDomain::dim>(fCallbackName));
93 0 : return MarkForAdaption_ResidualErrorP1Absolute(refiner, u, spCallback,
94 : cmp, time, refTol, coarsenTol, maxLvl, quadOrder,
95 0 : quadType, refTopLvlOnly);
96 : }
97 :
98 : template <typename TDomain, typename TAlgebra>
99 0 : static void MarkForAdaption_ResidualErrorP1RelativeLUA(IRefiner& refiner,
100 : SmartPtr<GridFunction<TDomain, TAlgebra> > u,
101 : const char* fCallbackName,
102 : const char* cmp,
103 : number time,
104 : number refFrac,
105 : int minLvl, int maxLvl,
106 : int quadOrder, std::string quadType)
107 : {
108 0 : SmartPtr<UserData<number, TDomain::dim> > spCallback
109 0 : = make_sp(new LuaUserData<number, TDomain::dim>(fCallbackName));
110 0 : MarkForAdaption_ResidualErrorP1Relative(refiner, u, spCallback, cmp, time, refFrac,
111 : minLvl, maxLvl, quadOrder, quadType);
112 0 : }
113 :
114 : #endif
115 :
116 :
117 : namespace bridge{
118 : namespace AdaptiveTools{
119 :
120 : /**
121 : * \defgroup adaptivetools_bridge Adaptive Tools Bridge
122 : * \ingroup disc_bridge
123 : * \{
124 : */
125 :
126 : /**
127 : * Class exporting the functionality. All functionality that is to
128 : * be used in scripts or visualization must be registered here.
129 : */
130 : struct Functionality
131 : {
132 :
133 : /**
134 : * Function called for the registration of Domain and Algebra dependent parts.
135 : * All Functions and Classes depending on both Domain and Algebra
136 : * are to be placed here when registering. The method is called for all
137 : * available Domain and Algebra types, based on the current build options.
138 : *
139 : * @param reg registry
140 : * @param parentGroup group for sorting of functionality
141 : */
142 : template <typename TDomain, typename TAlgebra>
143 9 : static void DomainAlgebra(Registry& reg, string grp)
144 : {
145 : string suffix = GetDomainAlgebraSuffix<TDomain,TAlgebra>();
146 : string tag = GetDomainAlgebraTag<TDomain,TAlgebra>();
147 :
148 : // Refinement
149 : {
150 : // MarkForAdaption_GradientIndicator
151 9 : string grp("ug4/Refinement/");
152 27 : reg.add_function("MarkForAdaption_GradientIndicator",
153 : &MarkForAdaption_GradientIndicator<TDomain, TAlgebra>, grp);
154 :
155 : // MarkForAdaption_AbsoluteGradientIndicator
156 27 : reg.add_function("MarkForAdaption_AbsoluteGradientIndicator",
157 : &MarkForAdaption_AbsoluteGradientIndicator<TDomain, TAlgebra>, grp);
158 :
159 : // MarkForAdaption_GradientJumpIndicator
160 27 : reg.add_function("MarkForAdaption_GradientJumpIndicator",
161 : &MarkForAdaption_GradientJumpIndicator<TDomain, TAlgebra>, grp);
162 :
163 : // MarkForAdaption_AbsoluteGradientJumpIndicator
164 27 : reg.add_function("MarkForAdaption_AbsoluteGradientJumpIndicator",
165 : &MarkForAdaption_AbsoluteGradientJumpIndicator<TDomain, TAlgebra>, grp);
166 :
167 : // MarkForAdaption_L2ErrorExact
168 27 : reg.add_function("MarkForAdaption_L2ErrorExact",
169 : &MarkForAdaption_L2ErrorExact<TDomain, TAlgebra>, grp);
170 :
171 : #ifdef UG_FOR_LUA
172 27 : reg.add_function("MarkForAdaption_L2ErrorExact",
173 : &MarkForAdaption_L2ErrorExactLUA<TDomain, TAlgebra>, grp);
174 : #endif
175 :
176 27 : reg.add_function("MarkForAdaption_GradientJump",
177 : &MarkForAdaption_GradientJump<TDomain, TAlgebra>, grp);
178 :
179 27 : reg.add_function("MarkForAdaption_GradientAverage",
180 : &MarkForAdaption_GradientAverage<TDomain, TAlgebra>, grp);
181 :
182 : // MarkForAdaption_ResidualErrorP1Absolute
183 27 : reg.add_function("MarkForAdaption_ResidualErrorP1Absolute",
184 : &MarkForAdaption_ResidualErrorP1Absolute<TDomain, TAlgebra>, grp);
185 :
186 : #ifdef UG_FOR_LUA
187 27 : reg.add_function("MarkForAdaption_ResidualErrorP1Absolute",
188 : &MarkForAdaption_ResidualErrorP1AbsoluteLUA<TDomain, TAlgebra>, grp);
189 : #endif
190 :
191 : // MarkForAdaption_ResidualErrorP1Relative
192 27 : reg.add_function("MarkForAdaption_ResidualErrorP1Relative",
193 : &MarkForAdaption_ResidualErrorP1Relative<TDomain, TAlgebra>, grp);
194 :
195 : #ifdef UG_FOR_LUA
196 27 : reg.add_function("MarkForAdaption_ResidualErrorP1Relative",
197 : &MarkForAdaption_ResidualErrorP1RelativeLUA<TDomain, TAlgebra>, grp);
198 : #endif
199 27 : reg.add_function("MarkForCoarsenening_SurfaceLayer",
200 : &MarkForCoarsenening_SurfaceLayer<TDomain, TAlgebra>, grp);
201 : }
202 :
203 : // Prolongate
204 : {
205 27 : reg.add_function("Prolongate", &Prolongate<TDomain, TAlgebra>, grp);
206 : }
207 :
208 : // Restrict
209 : {
210 27 : reg.add_function("Restrict", &Restrict<TDomain, TAlgebra>, grp);
211 : }
212 :
213 : // MarkOutOfRangeElems
214 : typedef GridFunction<TDomain, TAlgebra> TGridFunction;
215 18 : reg.add_function("MarkOutOfRangeElems", static_cast<void (*) (SmartPtr<IRefiner>, ConstSmartPtr<TGridFunction>, size_t, number, number)>(MarkOutOfRangeElems<TGridFunction>),
216 : grp.c_str(), "", "refiner # grid function # component # lower bound # upper bound",
217 : "Marks elements next to out-of-range DoFs for refinement");
218 :
219 9 : }
220 :
221 : /**
222 : * Function called for the registration of Domain dependent parts.
223 : * All Functions and Classes depending on the Domain
224 : * are to be placed here when registering. The method is called for all
225 : * available Domain types, based on the current build options.
226 : *
227 : * @param reg registry
228 : * @param parentGroup group for sorting of functionality
229 : */
230 : template <typename TDomain>
231 3 : static void Domain(Registry& reg, string grp)
232 : {
233 : string suffix = GetDomainSuffix<TDomain>();
234 : string tag = GetDomainTag<TDomain>();
235 :
236 : // group string
237 3 : grp.append("/Adaptive");
238 :
239 : // IElementMarkingStrategy
240 : {
241 : typedef IElementMarkingStrategy<TDomain> T;
242 3 : string name = string("IElementMarkingStrategy").append(suffix);
243 9 : reg.add_class_<T>(name, grp)
244 9 : .add_method("global_estimated_error", &T::global_estimated_error)
245 12 : .add_method("global_estimated_error_per_elem_max", &T::global_estimated_error_per_elem_max)
246 9 : .add_method("global_estimated_error_per_elem_min", &T::global_estimated_error_per_elem_min);
247 9 : reg.add_class_to_group(name, "IElementMarkingStrategy", tag);
248 : }
249 :
250 :
251 : // StdRefinementStrategy
252 : {
253 : typedef StdRefinementMarkingStrategy<TDomain> T;
254 : typedef IElementMarkingStrategy<TDomain> TBase;
255 3 : string name = string("StdRefinementMarking").append(suffix);
256 9 : reg.add_class_<T, TBase>(name, grp)
257 6 : .template add_constructor<void (*)(number, int)>("tolerated max error#max level")
258 9 : .add_method("set_tolerance", &T::set_tolerance)
259 9 : .add_method("set_max_level", &T::set_max_level)
260 3 : .set_construct_as_smart_pointer(true);
261 9 : reg.add_class_to_group(name, "StdRefinementMarking", tag);
262 : }
263 :
264 :
265 : // GlobalMarking
266 : {
267 : typedef GlobalMarking<TDomain> T;
268 : typedef IElementMarkingStrategy<TDomain> TBase;
269 3 : string name = string("GlobalMarking").append(suffix);
270 9 : reg.add_class_<T, TBase>(name, grp)
271 6 : .template add_constructor<void (*)(number, int)>("tolerated max error#max level")
272 9 : .add_method("set_tolerance", &T::set_tolerance)
273 9 : .add_method("set_max_level", &T::set_max_level)
274 3 : .set_construct_as_smart_pointer(true);
275 9 : reg.add_class_to_group(name, "GlobalMarking", tag);
276 : }
277 :
278 :
279 : // StdCoarseningStrategy
280 : {
281 : typedef StdCoarseningMarkingStrategy<TDomain> T;
282 : typedef IElementMarkingStrategy<TDomain> TBase;
283 3 : string name = string("StdCoarseningMarking").append(suffix);
284 9 : reg.add_class_<T, TBase>(name, grp)
285 6 : .template add_constructor<void (*)(number, number, int)>("tolerated max error#safety factor#min level")
286 6 : .template add_constructor<void (*)(number, number)>("tolerated max error#safety factor")
287 6 : .template add_constructor<void (*)(number)>("tolerated max error")
288 9 : .add_method("set_tolerance", &T::set_tolerance)
289 9 : .add_method("set_safety_factor", &T::set_safety_factor)
290 3 : .set_construct_as_smart_pointer(true);
291 9 : reg.add_class_to_group(name, "StdCoarseningMarking", tag);
292 : }
293 :
294 : // ExpectedErrorMarkingStrategy
295 : {
296 : typedef ExpectedErrorMarkingStrategy<TDomain> T;
297 : typedef IElementMarkingStrategy<TDomain> TBase;
298 3 : string name = string("ExpectedErrorMarkingStrategy").append(suffix);
299 9 : reg.add_class_<T, TBase>(name, grp)
300 : .template add_constructor<void (*)(number, int, number, number)>
301 6 : ("tolerated max squared error # maximal refinement level # "
302 : "safety factor # expected reduction of squared error by refinement")
303 9 : .add_method("set_tolerance", &T::set_tolerance)
304 12 : .add_method("set_max_level", &T::set_max_level)
305 12 : .add_method("set_safety_factor", &T::set_safety_factor)
306 9 : .add_method("set_expected_reduction_factor", &T::set_expected_reduction_factor)
307 3 : .set_construct_as_smart_pointer(true);
308 9 : reg.add_class_to_group(name, "ExpectedErrorMarkingStrategy", tag);
309 : }
310 :
311 : // MaximumMarking
312 : {
313 : typedef MaximumMarking<TDomain> T;
314 : typedef IElementMarkingStrategy<TDomain> TBase;
315 3 : string name = string("MaximumMarking").append(suffix);
316 9 : reg.add_class_<T, TBase>(name, grp)
317 6 : .template add_constructor<void (*)(number)>("theta")
318 6 : .template add_constructor<void (*)(number, number)>("theta#eps")
319 6 : .template add_constructor<void (*)(number, number, number)>("theta#eps")
320 9 : .add_method("set_max_level", &T::set_max_level)
321 9 : .add_method("set_min_level", &T::set_min_level)
322 3 : .set_construct_as_smart_pointer(true);
323 9 : reg.add_class_to_group(name, "MaximumMarking", tag);
324 : }
325 :
326 : // MeanValueMarking
327 : {
328 : typedef MeanValueMarking<TDomain> T;
329 : typedef IElementMarkingStrategy<TDomain> TBase;
330 3 : string name = string("MeanValueMarking").append(suffix);
331 9 : reg.add_class_<T, TBase>(name, grp)
332 6 : .template add_constructor<void (*)(number, number)>("theta#factor")
333 3 : .set_construct_as_smart_pointer(true);
334 9 : reg.add_class_to_group(name, "MeanValueMarking", tag);
335 : }
336 :
337 : // VarianceMarking (with eta^2)
338 : {
339 : typedef VarianceMarking<TDomain> T;
340 : typedef IElementMarkingStrategy<TDomain> TBase;
341 3 : string name = string("VarianceMarking").append(suffix);
342 9 : reg.add_class_<T, TBase>(name, grp)
343 6 : .template add_constructor<void (*)(number)>("theta")
344 6 : .template add_constructor<void (*)(number, number)>("theta#eps")
345 3 : .set_construct_as_smart_pointer(true);
346 9 : reg.add_class_to_group(name, "VarianceMarking", tag);
347 : }
348 :
349 :
350 : // VarianceMarking (with eta)
351 : {
352 : typedef VarianceMarkingEta<TDomain> T;
353 : typedef IElementMarkingStrategy<TDomain> TBase;
354 3 : string name = string("VarianceMarkingEta").append(suffix);
355 9 : reg.add_class_<T, TBase>(name, grp)
356 6 : .template add_constructor<void (*)(number)>("theta")
357 6 : .template add_constructor<void (*)(number, number)>("theta#eps")
358 6 : .template add_constructor<void (*)(number, number,number)>("theta#eps#threshlow")
359 9 : .add_method("init_refinement", &T::init_refinement)
360 9 : .add_method("init_coarsening", &T::init_coarsening)
361 3 : .set_construct_as_smart_pointer(true);
362 9 : reg.add_class_to_group(name, "VarianceMarkingEta", tag);
363 : }
364 :
365 :
366 : // APosterioriCoarsening (with eta^2)
367 : {
368 : typedef APosterioriCoarsening<TDomain> T;
369 : typedef IElementMarkingStrategy<TDomain> TBase;
370 3 : string name = string("APosterioriCoarsening").append(suffix);
371 9 : reg.add_class_<T, TBase>(name, grp)
372 6 : .template add_constructor<void (*)(number)>("theta")
373 3 : .set_construct_as_smart_pointer(true);
374 9 : reg.add_class_to_group(name, "APosterioriCoarsening", tag);
375 : }
376 :
377 : // EquilibrationMarking
378 : {
379 : typedef EquilibrationMarkingStrategy<TDomain> T;
380 : typedef IElementMarkingStrategy<TDomain> TBase;
381 3 : string name = string("EquilibrationMarking").append(suffix);
382 9 : reg.add_class_<T, TBase>(name, grp)
383 6 : .template add_constructor<void (*)(number)>("theta")
384 6 : .template add_constructor<void (*)(number, number)>("theta#eps")
385 3 : .set_construct_as_smart_pointer(true);
386 9 : reg.add_class_to_group(name, "EquilibrationMarking", tag);
387 : }
388 :
389 : // AbsoluteMarking
390 : {
391 : typedef AbsoluteMarking<TDomain> T;
392 : typedef IElementMarkingStrategy<TDomain> TBase;
393 3 : string name = string("AbsoluteMarking").append(suffix);
394 9 : reg.add_class_<T, TBase>(name, grp)
395 6 : .template add_constructor<void (*)(number)>("eta")
396 3 : .set_construct_as_smart_pointer(true);
397 9 : reg.add_class_to_group(name, "AbsoluteMarking", tag);
398 : }
399 :
400 6 : reg.add_function("MarkGlobal", &MarkGlobal<TDomain>, grp.c_str(), "", "refiner#domain", "");
401 6 : reg.add_function("MarkSubsets", &MarkSubsets<TDomain>, grp.c_str(), "", "refiner#domain#subset names (as vector of string)", "");
402 6 : reg.add_function("MarkAlongSurface", &MarkAlongSurface<TDomain>, grp.c_str(), "", "refiner#domain#vector of surface names#vector of volume names", "");
403 6 : reg.add_function("MarkAnisotropic", &MarkAnisotropic<TDomain>, grp.c_str(), "", "refiner#domain#anisotropy threshold (<=1)", "");
404 6 : reg.add_function("MarkAnisotropicX", &MarkAnisotropicOnlyX<TDomain>, grp.c_str(), "", "refiner#domain#anisotropy threshold (<=1)", "");
405 3 : }
406 :
407 : /**
408 : * Function called for the registration of Dimension dependent parts.
409 : * All Functions and Classes depending on the Dimension
410 : * are to be placed here when registering. The method is called for all
411 : * available Dimension types, based on the current build options.
412 : *
413 : * @param reg registry
414 : * @param parentGroup group for sorting of functionality
415 : */
416 : template <int dim>
417 3 : static void Dimension(Registry& reg, string grp)
418 : {
419 3 : string suffix = GetDimensionSuffix<dim>();
420 3 : string tag = GetDimensionTag<dim>();
421 :
422 3 : }
423 :
424 : /**
425 : * Function called for the registration of Algebra dependent parts.
426 : * All Functions and Classes depending on Algebra
427 : * are to be placed here when registering. The method is called for all
428 : * available Algebra types, based on the current build options.
429 : *
430 : * @param reg registry
431 : * @param parentGroup group for sorting of functionality
432 : */
433 : template <typename TAlgebra>
434 3 : static void Algebra(Registry& reg, string grp)
435 : {
436 3 : string suffix = GetAlgebraSuffix<TAlgebra>();
437 3 : string tag = GetAlgebraTag<TAlgebra>();
438 :
439 3 : }
440 :
441 : /**
442 : * Function called for the registration of Domain and Algebra independent parts.
443 : * All Functions and Classes not depending on Domain and Algebra
444 : * are to be placed here when registering.
445 : *
446 : * @param reg registry
447 : * @param parentGroup group for sorting of functionality
448 : */
449 : static void Common(Registry& reg, string grp)
450 : {
451 : }
452 :
453 : }; // end Functionality
454 :
455 : // end group adaptivetools_bridge
456 : /// \}
457 :
458 : }// end AdaptiveTools
459 :
460 : /// \addtogroup adaptivetools_bridge
461 1 : void RegisterBridge_AdaptiveTools(Registry& reg, string grp)
462 : {
463 1 : grp.append("/Discretization");
464 : typedef AdaptiveTools::Functionality Functionality;
465 :
466 : try{
467 2 : RegisterCommon<Functionality>(reg,grp);
468 2 : RegisterDimensionDependent<Functionality>(reg,grp);
469 2 : RegisterDomainDependent<Functionality>(reg,grp);
470 2 : RegisterAlgebraDependent<Functionality>(reg,grp);
471 1 : RegisterDomainAlgebraDependent<Functionality>(reg,grp);
472 : }
473 0 : UG_REGISTRY_CATCH_THROW(grp);
474 1 : }
475 :
476 : }// namespace bridge
477 : }// namespace ug
|
