Line data Source code
1 : /*
2 : * Copyright (c) 2013-2015: G-CSC, Goethe University Frankfurt
3 : * Author: Sebastian Reiter
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 : #include <iostream>
34 : #include <sstream>
35 : #include <vector>
36 : #include <string>
37 :
38 : // include bridge
39 : #include "bridge/bridge.h"
40 : #include "bridge/util.h"
41 : #include "bridge/util_domain_dependent.h"
42 :
43 : #include "bindings/lua/lua_user_data.h"
44 :
45 : #ifdef UG_PARALLEL
46 : #include "lib_disc/parallelization/domain_load_balancer.h"
47 : #include "lib_grid/parallelization/load_balancer.h"
48 : #include "lib_grid/parallelization/load_balancer_util.h"
49 : #include "lib_grid/parallelization/partitioner_dynamic_bisection.h"
50 : #include "lib_grid/parallelization/balance_weights_ref_marks.h"
51 : #include "lib_grid/parallelization/partition_pre_processors/replace_coordinate.h"
52 : #include "lib_grid/parallelization/partition_post_processors/smooth_partition_bounds.h"
53 : #include "lib_grid/parallelization/partition_post_processors/cluster_element_stacks.h"
54 : #endif
55 :
56 : using namespace std;
57 :
58 : namespace ug{
59 :
60 : /**
61 : * \defgroup loadbalance_bridge Load Balancing Bridge
62 : * \ingroup domain_bridge
63 : * \{
64 : */
65 :
66 : #ifdef UG_PARALLEL
67 :
68 : template <int dim>
69 : class PartPreProc_RasterProjectorCoordinates : public IPartitionPreProcessor
70 : {
71 : private:
72 : typedef PPP_ReplaceCoordinate <dim> PPP_RC;
73 : SmartPtr<PPP_RC> m_ppp;
74 :
75 : public:
76 : typedef MathVector<dim> vector_t;
77 :
78 : PartPreProc_RasterProjectorCoordinates (const Attachment<vector_t> aPos)
79 : {
80 : typedef RasterLayersProjector::rel_z_attachment_t attachment_t;
81 :
82 : static const std::string attName("RasterLayersProjector_ARelZ");
83 : if(!GlobalAttachments::is_declared(attName)){
84 : GlobalAttachments::declare_attachment<attachment_t>(attName);
85 : }
86 :
87 : attachment_t aRelZ = GlobalAttachments::attachment<attachment_t>(attName);
88 :
89 : typedef PPP_ReplaceCoordinate <dim> PPP_RC;
90 :
91 : m_ppp = make_sp(new PPP_RC (aPos, aRelZ, dim - 1));
92 : }
93 :
94 : virtual void partitioning_starts ( MultiGrid* mg,
95 : IPartitioner* partitioner)
96 : {
97 : m_ppp->partitioning_starts (mg, partitioner);
98 : }
99 :
100 :
101 : virtual void partitioning_done ( MultiGrid* mg,
102 : IPartitioner* partitioner)
103 : {
104 : m_ppp->partitioning_done (mg, partitioner);
105 : }
106 :
107 : };
108 :
109 :
110 : template <class TDomain>
111 : class BalanceWeightsLuaCallback : public IBalanceWeights
112 : {
113 : public:
114 : BalanceWeightsLuaCallback(SmartPtr<TDomain> spDom, const char* luaCallbackName) :
115 : m_spDom(spDom),
116 : m_time(0)
117 : {
118 : m_pmg = spDom->grid().get();
119 : m_aaPos = spDom->position_accessor();
120 : // we'll pass the following arguments: x, y, z, lvl, t
121 : m_callback.set_lua_callback(luaCallbackName, 5);
122 : }
123 :
124 : virtual ~BalanceWeightsLuaCallback() {}
125 :
126 :
127 : void set_time(number time) {m_time = time;}
128 : number time() const {return m_time;}
129 :
130 : virtual number get_weight(Vertex* e) {return get_weight_impl(e);}
131 : virtual number get_weight(Edge* e) {return get_weight_impl(e);}
132 : virtual number get_weight(Face* e) {return get_weight_impl(e);}
133 : virtual number get_weight(Volume* e) {return get_weight_impl(e);}
134 :
135 : private:
136 : typedef typename TDomain::grid_type grid_t;
137 : typedef typename TDomain::position_type pos_t;
138 : typedef typename TDomain::position_accessor_type aapos_t;
139 :
140 : template <class TElem>
141 : number get_weight_impl(TElem* e)
142 : {
143 : pos_t c = CalculateCenter(e, m_aaPos);
144 : vector3 p;
145 : VecCopy(p, c, 0);
146 : number weight;
147 : m_callback(weight, 5, p.x(), p.y(), p.z(), (number)m_pmg->get_level(e), m_time);
148 : return weight;
149 : }
150 :
151 : SmartPtr<TDomain> m_spDom;
152 : MultiGrid* m_pmg;
153 : aapos_t m_aaPos;
154 : number m_time;
155 : LuaFunction<number, number> m_callback;
156 : };
157 : #endif
158 :
159 : // end group loadbalance_bridge
160 : /// \}
161 :
162 : namespace bridge{
163 : namespace LoadBalancing{
164 :
165 : /// \addtogroup loadbalance_bridge
166 : /// \{
167 :
168 : #ifdef UG_PARALLEL
169 :
170 : template <class TDomain, class TPartitioner>
171 : static void RegisterDynamicBisectionPartitioner(
172 : Registry& reg,
173 : string name,
174 : string grpName,
175 : string clsGrpName)
176 : {
177 : reg.add_class_<TPartitioner, IPartitioner>(name, grpName)
178 : .template add_constructor<void (*)(TDomain&)>()
179 : .add_method("set_subset_handler",
180 : &TPartitioner::set_subset_handler)
181 : .add_method("enable_longest_split_axis",
182 : &TPartitioner::enable_longest_split_axis)
183 : .add_method("enable_split_axis",
184 : &TPartitioner::enable_split_axis)
185 : .add_method("set_start_split_axis",
186 : &TPartitioner::set_start_split_axis)
187 : .add_method("num_split_improvement_iterations",
188 : &TPartitioner::num_split_improvement_iterations)
189 : .add_method("set_num_split_improvement_iterations",
190 : &TPartitioner::set_num_split_improvement_iterations)
191 : .add_method("enable_static_partitioning",
192 : &TPartitioner::enable_static_partitioning)
193 : .add_method("static_partitioning_enabled",
194 : &TPartitioner::static_partitioning_enabled)
195 : .set_construct_as_smart_pointer(true);
196 :
197 : reg.add_class_to_group(name, clsGrpName, GetDomainTag<TDomain>());
198 : }
199 :
200 : template <class TDomain, class elem_t>
201 : static void RegisterSmoothPartitionBounds(
202 : Registry& reg,
203 : string name,
204 : string grpName,
205 : string clsGrpName)
206 : {
207 : typedef SmoothPartitionBounds<elem_t> T;
208 : reg.add_class_<T, IPartitionPostProcessor>(name, grpName)
209 : .add_constructor()
210 : .set_construct_as_smart_pointer(true);
211 : reg.add_class_to_group(name, clsGrpName, GetDomainTag<TDomain>());
212 : }
213 :
214 : template <class TDomain, class elem_t, class vector_t>
215 : static void RegisterClusterElementStacks(
216 : Registry& reg,
217 : string name,
218 : string grpName,
219 : string clsGrpName)
220 : {
221 : typedef Attachment<vector_t> apos_t;
222 : typedef ClusterElementStacks<elem_t, vector_t> T;
223 : reg.add_class_<T, IPartitionPostProcessor>(name, grpName)
224 : .add_constructor()
225 : .template add_constructor<void (*)(const apos_t&, const vector_t&)>()
226 : .add_method("set_position_attachment", &T::set_position_attachment)
227 : .add_method("set_stacking_direction", &T::set_stacking_direction)
228 : .set_construct_as_smart_pointer(true);
229 : reg.add_class_to_group(name, clsGrpName, GetDomainTag<TDomain>());
230 : }
231 :
232 : #endif
233 :
234 :
235 : /**
236 : * Class exporting the functionality. All functionality that is to
237 : * be used in scripts or visualization must be registered here.
238 : */
239 : struct Functionality
240 : {
241 :
242 : static void Common(Registry& reg, string grp) {
243 : #ifdef UG_PARALLEL
244 : {
245 : typedef ProcessHierarchy T;
246 : reg.add_class_<T>("ProcessHierarchy", grp)
247 : .add_constructor()
248 : .add_method("empty", &T::empty)
249 : .add_method("add_hierarchy_level", &T::add_hierarchy_level)
250 : .add_method("num_hierarchy_levels", &T::num_hierarchy_levels)
251 : .add_method("num_global_procs_involved", &T::num_global_procs_involved)
252 : .add_method("grid_base_level", &T::grid_base_level)
253 : .add_method("hierarchy_level_from_grid_level", &T::hierarchy_level_from_grid_level)
254 : .add_method("cluster_procs", &T::cluster_procs)
255 : .add_method("to_string", &T::to_string)
256 : .add_method("add_partition_hint", &T::add_partition_hint)
257 : .add_method("partition_hint", &T::partition_hint)
258 : .set_construct_as_smart_pointer(true);
259 : }
260 :
261 : {
262 : reg.add_class_<IBalanceWeights>("IBalanceWeights", grp);
263 : }
264 :
265 : {
266 : string name = string("ICommunicationWeights");
267 : reg.add_class_<ICommunicationWeights>(name, grp);
268 : }
269 :
270 : {
271 : string name("BalanceWeightsRefMarks");
272 : typedef BalanceWeightsRefMarks T;
273 : reg.add_class_<T, IBalanceWeights>(name, grp)
274 : .add_constructor<void (*)(IRefiner*)>()
275 : .set_construct_as_smart_pointer(true);
276 : }
277 :
278 : {
279 : typedef IPartitionPreProcessor T;
280 : reg.add_class_<T>("IPartitionPreProcessor", grp);
281 : }
282 :
283 : {
284 : typedef IPartitionPostProcessor T;
285 : reg.add_class_<T>("IPartitionPostProcessor", grp);
286 : }
287 :
288 : {
289 : typedef IPartitioner T;
290 : reg.add_class_<T>("IPartitioner", grp)
291 : .add_method("set_verbose", &T::set_verbose)
292 : .add_method("partition", &T::partition)
293 : .add_method("set_balance_weights", &T::set_balance_weights)
294 : .add_method("supports_balance_weights", &T::supports_balance_weights)
295 : .add_method("set_communication_weights", &T::set_communication_weights)
296 : .add_method("supports_communication_weights", &T::supports_communication_weights)
297 : .add_method("set_next_process_hierarchy", &T::set_next_process_hierarchy)
298 : .add_method("enable_clustered_siblings", &T::enable_clustered_siblings)
299 : .add_method("clustered_siblings_enabled", &T::clustered_siblings_enabled)
300 : .add_method("set_partition_pre_processor", &T::set_partition_pre_processor)
301 : .add_method("set_partition_post_processor", &T::set_partition_post_processor);
302 : }
303 :
304 : {
305 : // Note that this class does not feature a constructor.
306 : // One normally uses the derived class DomainLoadBalancer
307 : typedef LoadBalancer T;
308 : reg.add_class_<T>("LoadBalancer", grp)
309 : //.add_method("add_distribution_level", &T::add_distribution_level)
310 : .add_method("enable_vertical_interface_creation", &T::enable_vertical_interface_creation)
311 : .add_method("set_next_process_hierarchy", &T::set_next_process_hierarchy)
312 : .add_method("rebalance", &T::rebalance)
313 : .add_method("set_balance_threshold", &T::set_balance_threshold)
314 : .add_method("set_element_threshold", &T::set_element_threshold)
315 : .add_method("set_partitioner", &T::set_partitioner)
316 : .add_method("create_quality_record", &T::create_quality_record)
317 : .add_method("print_quality_records", &T::print_quality_records)
318 : .add_method("print_last_quality_record", &T::print_last_quality_record)
319 : .add_method("estimate_distribution_quality", static_cast<number (T::*)()>(&T::estimate_distribution_quality))
320 : .add_method("set_balance_weights", &T::set_balance_weights)
321 : .add_method("problems_occurred", &T::problems_occurred);
322 : }
323 :
324 : #ifdef UG_DIM_1
325 : {
326 : typedef ug::Domain<1> TDomain;
327 : RegisterDynamicBisectionPartitioner<
328 : TDomain,
329 : DomainPartitioner<TDomain, Partitioner_DynamicBisection<Edge, 1> > >(
330 : reg,
331 : "EdgePartitioner_DynamicBisection1d",
332 : grp,
333 : "Partitioner_DynamicBisection");
334 :
335 :
336 : RegisterSmoothPartitionBounds<TDomain, Edge>(
337 : reg,
338 : "SmoothPartitionBounds1d",
339 : grp,
340 : "SmoothPartitionBounds");
341 :
342 : // RegisterClusterElementStacks<TDomain, Edge, vector1>(
343 : // reg,
344 : // "ClusterElementStacks1d",
345 : // grp,
346 : // "ClusterElementStacks");
347 : }
348 : #endif
349 : #ifdef UG_DIM_2
350 : {
351 : typedef ug::Domain<2> TDomain;
352 :
353 : RegisterDynamicBisectionPartitioner<
354 : TDomain,
355 : DomainPartitioner<TDomain, Partitioner_DynamicBisection<Edge, 2> > >(
356 : reg,
357 : "EdgePartitioner_DynamicBisection2d",
358 : grp,
359 : "ManifoldPartitioner_DynamicBisection");
360 :
361 : RegisterDynamicBisectionPartitioner<
362 : TDomain,
363 : DomainPartitioner<TDomain, Partitioner_DynamicBisection<Face, 2> > >(
364 : reg,
365 : "FacePartitioner_DynamicBisection2d",
366 : grp,
367 : "Partitioner_DynamicBisection");
368 :
369 : RegisterSmoothPartitionBounds<TDomain, Face>(
370 : reg,
371 : "SmoothPartitionBounds2d",
372 : grp,
373 : "SmoothPartitionBounds");
374 :
375 : RegisterClusterElementStacks<TDomain, Face, vector2>(
376 : reg,
377 : "ClusterElementStacks2d",
378 : grp,
379 : "ClusterElementStacks");
380 : }
381 : #endif
382 : #ifdef UG_DIM_3
383 : {
384 : typedef ug::Domain<3> TDomain;
385 :
386 : RegisterDynamicBisectionPartitioner<
387 : TDomain,
388 : DomainPartitioner<TDomain, Partitioner_DynamicBisection<Edge, 3> > >(
389 : reg,
390 : "EdgePartitioner_DynamicBisection3d",
391 : grp,
392 : "HyperManifoldPartitioner_DynamicBisection");
393 :
394 : RegisterDynamicBisectionPartitioner<
395 : TDomain,
396 : DomainPartitioner<TDomain, Partitioner_DynamicBisection<Face, 3> > >(
397 : reg,
398 : "FacePartitioner_DynamicBisection3d",
399 : grp,
400 : "ManifoldPartitioner_DynamicBisection");
401 :
402 : RegisterDynamicBisectionPartitioner<
403 : TDomain,
404 : DomainPartitioner<TDomain, Partitioner_DynamicBisection<Volume, 3> > >(
405 : reg,
406 : "VolumePartitioner_DynamicBisection3d",
407 : grp,
408 : "Partitioner_DynamicBisection");
409 :
410 : RegisterSmoothPartitionBounds<TDomain, Volume>(
411 : reg,
412 : "SmoothPartitionBounds3d",
413 : grp,
414 : "SmoothPartitionBounds");
415 :
416 : RegisterClusterElementStacks<TDomain, Volume, vector3>(
417 : reg,
418 : "ClusterElementStacks3d",
419 : grp,
420 : "ClusterElementStacks");
421 : }
422 : #endif
423 :
424 :
425 :
426 : // #ifdef UG_DIM_1
427 : // {
428 : // typedef ug::Domain<1> TDomain;
429 : // string tag = GetDomainTag<TDomain>();
430 : // typedef DomainPartitioner<TDomain, Partitioner_DynamicBisection<Edge, 1> > T;
431 : // string name = string("EdgePartitioner_DynamicBisection1d");
432 : // reg.add_class_<T, IPartitioner>(name, grp)
433 : // .add_constructor<void (*)(TDomain&)>()
434 : // .add_method("enable_static_partitioning", &T::enable_static_partitioning)
435 : // .add_method("static_partitioning_enabled", &T::static_partitioning_enabled)
436 : // .add_method("set_subset_handler", &T::set_subset_handler)
437 : // .add_method("num_split_improvement_iterations", &T::num_split_improvement_iterations)
438 : // .add_method("set_num_split_improvement_iterations", &T::set_num_split_improvement_iterations)
439 : // .set_construct_as_smart_pointer(true);
440 : // reg.add_class_to_group(name, "Partitioner_DynamicBisection", tag);
441 : // }
442 : // #endif
443 : // #ifdef UG_DIM_2
444 : // {
445 : // typedef ug::Domain<2> TDomain;
446 : // string tag = GetDomainTag<TDomain>();
447 : // {
448 : // typedef DomainPartitioner<TDomain, Partitioner_DynamicBisection<Edge, 2> >T;
449 : // string name = string("EdgePartitioner_DynamicBisection2d");
450 : // reg.add_class_<T, IPartitioner>(name, grp)
451 : // .add_constructor<void (*)(TDomain&)>()
452 : // .add_method("enable_static_partitioning", &T::enable_static_partitioning)
453 : // .add_method("static_partitioning_enabled", &T::static_partitioning_enabled)
454 : // .add_method("set_subset_handler", &T::set_subset_handler)
455 : // .add_method("num_split_improvement_iterations", &T::num_split_improvement_iterations)
456 : // .add_method("set_num_split_improvement_iterations", &T::set_num_split_improvement_iterations)
457 : // .set_construct_as_smart_pointer(true);
458 : // reg.add_class_to_group(name, "ManifoldPartitioner_DynamicBisection", tag);
459 : // }
460 : // {
461 : // typedef DomainPartitioner<TDomain, Partitioner_DynamicBisection<Face, 2> > T;
462 : // string name = string("FacePartitioner_DynamicBisection2d");
463 : // reg.add_class_<T, IPartitioner>(name, grp)
464 : // .add_constructor<void (*)(TDomain&)>()
465 : // .add_method("enable_static_partitioning", &T::enable_static_partitioning)
466 : // .add_method("static_partitioning_enabled", &T::static_partitioning_enabled)
467 : // .add_method("set_subset_handler", &T::set_subset_handler)
468 : // .add_method("num_split_improvement_iterations", &T::num_split_improvement_iterations)
469 : // .add_method("set_num_split_improvement_iterations", &T::set_num_split_improvement_iterations)
470 : // .set_construct_as_smart_pointer(true);
471 : // reg.add_class_to_group(name, "Partitioner_DynamicBisection", tag);
472 : // }
473 : // }
474 : // #endif
475 : // #ifdef UG_DIM_3
476 : // {
477 : // typedef ug::Domain<3> TDomain;
478 : // string tag = GetDomainTag<TDomain>();
479 : // {
480 : // typedef DomainPartitioner<TDomain, Partitioner_DynamicBisection<Edge, 3> > T;
481 : // string name = string("EdgePartitioner_DynamicBisection3d");
482 : // reg.add_class_<T, IPartitioner>(name, grp)
483 : // .add_constructor<void (*)(TDomain&)>()
484 : // .add_method("enable_static_partitioning", &T::enable_static_partitioning)
485 : // .add_method("static_partitioning_enabled", &T::static_partitioning_enabled)
486 : // .add_method("set_subset_handler", &T::set_subset_handler)
487 : // .add_method("num_split_improvement_iterations", &T::num_split_improvement_iterations)
488 : // .add_method("set_num_split_improvement_iterations", &T::set_num_split_improvement_iterations)
489 : // .set_construct_as_smart_pointer(true);
490 : // reg.add_class_to_group(name, "HyperManifoldPartitioner_DynamicBisection", tag);
491 : // }
492 : // {
493 : // typedef DomainPartitioner<TDomain, Partitioner_DynamicBisection<Face, 3> > T;
494 : // string name = string("FacePartitioner_DynamicBisection3d");
495 : // reg.add_class_<T, IPartitioner>(name, grp)
496 : // .add_constructor<void (*)(TDomain&)>()
497 : // .add_method("enable_static_partitioning", &T::enable_static_partitioning)
498 : // .add_method("static_partitioning_enabled", &T::static_partitioning_enabled)
499 : // .add_method("set_subset_handler", &T::set_subset_handler)
500 : // .add_method("num_split_improvement_iterations", &T::num_split_improvement_iterations)
501 : // .add_method("set_num_split_improvement_iterations", &T::set_num_split_improvement_iterations)
502 : // .set_construct_as_smart_pointer(true);
503 : // reg.add_class_to_group(name, "ManifoldPartitioner_DynamicBisection", tag);
504 : // }
505 : // {
506 : // typedef DomainPartitioner<TDomain, Partitioner_DynamicBisection<Volume, 3> > T;
507 : // string name = string("VolumePartitioner_DynamicBisection3d");
508 : // reg.add_class_<T, IPartitioner>(name, grp)
509 : // .add_constructor<void (*)(TDomain&)>()
510 : // .add_method("enable_static_partitioning", &T::enable_static_partitioning)
511 : // .add_method("static_partitioning_enabled", &T::static_partitioning_enabled)
512 : // .add_method("set_subset_handler", &T::set_subset_handler)
513 : // .add_method("num_split_improvement_iterations", &T::num_split_improvement_iterations)
514 : // .add_method("set_num_split_improvement_iterations", &T::set_num_split_improvement_iterations)
515 : // .set_construct_as_smart_pointer(true);
516 : // reg.add_class_to_group(name, "Partitioner_DynamicBisection", tag);
517 : // }
518 : // }
519 : // #endif
520 : #endif
521 : }
522 :
523 : /**
524 : * Function called for the registration of Domain dependent parts.
525 : * All Functions and Classes depending on the Domain
526 : * are to be placed here when registering. The method is called for all
527 : * available Domain types, based on the current build options.
528 : *
529 : * @param reg registry
530 : * @param parentGroup group for sorting of functionality
531 : */
532 : template <typename TDomain>
533 3 : static void Domain(Registry& reg, string grp)
534 : {
535 : string suffix = GetDomainSuffix<TDomain>();
536 : string tag = GetDomainTag<TDomain>();
537 :
538 : #ifdef UG_PARALLEL
539 :
540 : {
541 : typedef PartPreProc_RasterProjectorCoordinates<TDomain::dim> T;
542 : string name = string("PartPreProc_RasterProjectorCoordinates").append(suffix);
543 : reg.add_class_<T, IPartitionPreProcessor>(name, grp)
544 : .template add_constructor<void (*)(const Attachment<MathVector<TDomain::dim> >&)>()
545 : .set_construct_as_smart_pointer(true);
546 : reg.add_class_to_group(name, "PartPreProc_RasterProjectorCoordinates", tag);
547 : }
548 :
549 : {
550 : typedef DomainBalanceWeights<TDomain, AnisotropicBalanceWeights<TDomain::dim> > T;
551 : string name = string("AnisotropicBalanceWeights").append(suffix);
552 : reg.add_class_<T, IBalanceWeights>(name, grp)
553 : .template add_constructor<void (*)(TDomain&)>()
554 : .add_method("set_weight_factor", &T::set_weight_factor)
555 : .add_method("weight_factor", &T::weight_factor)
556 : .set_construct_as_smart_pointer(true);
557 : reg.add_class_to_group(name, "AnisotropicBalanceWeights", tag);
558 : }
559 :
560 : {
561 : typedef BalanceWeightsLuaCallback<TDomain> T;
562 : string name = string("BalanceWeightsLuaCallback").append(suffix);
563 : reg.add_class_<T, IBalanceWeights>(name, grp)
564 : .template add_constructor<void (*)(SmartPtr<TDomain> spDom,
565 : const char* luaCallbackName)>()
566 : .add_method("set_time", &T::set_time)
567 : .add_method("time", &T::time)
568 : .set_construct_as_smart_pointer(true);
569 : reg.add_class_to_group(name, "BalanceWeightsLuaCallback", tag);
570 : }
571 :
572 : {
573 : string name = string("DomainLoadBalancer").append(suffix);
574 : typedef DomainLoadBalancer<TDomain> T;
575 : typedef LoadBalancer TBase;
576 : reg.add_class_<T, TBase>(name, grp)
577 : .template add_constructor<void (*)(SmartPtr<TDomain>)>("Domain")
578 : .set_construct_as_smart_pointer(true);
579 : reg.add_class_to_group(name, "DomainLoadBalancer", tag);
580 : }
581 :
582 : reg.add_function("CreateProcessHierarchy",
583 : static_cast<SPProcessHierarchy (*)(TDomain&, size_t,
584 : size_t, size_t, int,
585 : int)>
586 : (&CreateProcessHierarchy<TDomain>),
587 : grp, "ProcessHierarchy", "Domain # minNumElemsPerProcPerLvl # "
588 : "maxNumRedistProcs # maxNumProcs # minDistLvl # "
589 : "maxLvlsWithoutRedist");
590 : reg.add_function("CreateProcessHierarchy",
591 : static_cast<SPProcessHierarchy (*)(TDomain&, size_t,
592 : size_t, size_t, int,
593 : int, IRefiner*)>
594 : (&CreateProcessHierarchy<TDomain>),
595 : grp, "ProcessHierarchy", "Domain # minNumElemsPerProcPerLvl # "
596 : "maxNumRedistProcs # maxNumProcs # minDistLvl # "
597 : "maxLvlsWithoutRedist # refiner");
598 :
599 : #endif
600 3 : }
601 :
602 : };// end of struct Functionality
603 :
604 : // end group loadbalance_bridge
605 : /// \}
606 :
607 : }// end of namespace
608 :
609 : /// \addtogroup loadbalance_bridge
610 1 : void RegisterBridge_LoadBalancing(Registry& reg, string grp)
611 : {
612 1 : grp.append("/LoadBalancing");
613 :
614 : typedef LoadBalancing::Functionality Functionality;
615 :
616 : try{
617 2 : RegisterCommon<Functionality>(reg, grp);
618 1 : RegisterDomainDependent<Functionality>(reg,grp);
619 : }
620 0 : UG_REGISTRY_CATCH_THROW(grp);
621 1 : }
622 :
623 : }// end of namespace
624 : }// end of namespace
|
