Rheolef  7.1
an efficient C++ finite element environment
geo_build_from_list.cc
Go to the documentation of this file.
1 // build geo from element & node lists
22 #include "rheolef/geo.h"
23 #include "rheolef/geo_domain.h"
24 #include "rheolef/dis_macros.h"
25 #include "rheolef/rheostream.h"
26 #include "rheolef/iorheo.h"
27 #include "rheolef/index_set.h"
28 
29 namespace rheolef {
30 
31 // --------------------------------------------------------------------------
32 // base class, common to seq & dist derived classes
33 // --------------------------------------------------------------------------
34 template <class T, class M>
35 void
37  const geo_basic<T,M>& lambda,
38  const disarray<point_basic<T>,M>& node_list,
41 {
42  typedef geo_element_auto<heap_allocator<size_type> > geo_element_tmp_type;
43  // ------------------
44  // 0) header data
45  // ------------------
46  _name = "level_set_from_" + lambda.name(); // TODO: send name by fct argument
47  _version = 4;
48  _dimension = lambda.dimension();
49  _piola_basis = lambda.get_piola_basis();
50  _sys_coord = lambda.coordinate_system();
51  _have_connectivity = true;
52 
53  // compute map_dimension from data:
54  _gs._map_dimension = 0;
56  if (ge_list[variant].dis_size() != 0) {
57  _gs._map_dimension = reference_element::dimension(variant);
58  }
59  }
60  // ------------------
61  // 1) nodes
62  // ------------------
63  communicator comm = lambda.sizes().node_ownership.comm();
64  _node = node_list;
65  _gs.node_ownership = _node.ownership();
66  compute_bbox();
67  // vertices=geo_element[p] differs from nodes when order > 1:
68  check_macro (order() == 1, "order > 1: not yet supported"); // TODO: with high order level set
69  _gs.ownership_by_variant [reference_element::p] = _gs.node_ownership;
70  // ------------------
71  // 2) count elements
72  // ------------------
73  size_type ne = 0;
76  size_type nge = ge_list [variant].size();
77  _gs.ownership_by_variant [variant] = distributor (distributor::decide, comm, nge);
79  _geo_element [variant].resize (_gs.ownership_by_variant [variant], param);
80  ne += nge;
81  }
82  _gs.ownership_by_dimension [_gs._map_dimension] = distributor (distributor::decide, comm, ne);
83  //
84  // 1.4) create 0d vertex-elements
85  //
86  // set ios_dis_iv index as fisrt field of the idx_vertex pair:
87  // # of node that are vertices:
88  {
89  check_macro (order() == 1, "order > 1: not yet supported");
90  _gs.ownership_by_dimension [0] = _gs.node_ownership;
91  _gs.ownership_by_variant [reference_element::p] = _gs.ownership_by_dimension [0];
93  _geo_element [reference_element::p].resize (_gs.ownership_by_dimension [0], param);
94  size_type first_dis_iv = _gs.ownership_by_dimension [0].first_index();
95  for (size_type iv = 0, nv = _gs.ownership_by_dimension [0].size(); iv < nv; iv++) {
96  geo_element& P = _geo_element [reference_element::p] [iv];
97  size_type dis_iv = first_dis_iv + iv;
98  P [0] = dis_iv;
99  P.set_dis_ie (dis_iv);
100  P.set_ios_dis_ie (dis_iv);
101  }
102  }
103  // ------------------
104  // 3) copy elements
105  // ------------------
106  size_type first_dis_ie = _gs.ownership_by_dimension [_gs._map_dimension].first_index();
107  size_type dis_ie = first_dis_ie;
108  size_type first_dis_v = 0;
111  size_type first_dis_igev = _gs.ownership_by_variant [variant].first_index();
112  size_type dis_igev = first_dis_igev;
113  hack_array<geo_element>::iterator ge_iter = _geo_element [variant].begin();
115  iter = ge_list[variant].begin(),
116  last = ge_list[variant].end();
117  iter != last; iter++, ge_iter++, dis_ie++, dis_igev++) {
118  *ge_iter = *iter;
119  size_type ios_dis_ie = first_dis_v + dis_igev;
120  (*ge_iter).set_dis_ie (dis_ie);
121  (*ge_iter).set_ios_dis_ie (ios_dis_ie);
122  }
123  first_dis_v += _gs.ownership_by_variant[variant].dis_size();
124  }
125  if (_gs._map_dimension >= 2) {
126  _have_connectivity = false; // TODO
127  trace_macro ("connectivity: not yet computed");
128  }
129 }
130 // --------------------------------------------------------------------------
131 // seq
132 // --------------------------------------------------------------------------
133 template <class T>
136  const disarray<point_basic<T>,sequential>& node_list,
140 {
141  base::build_from_list (lambda, node_list, ge_list);
142 }
143 // --------------------------------------------------------------------------
144 // dist
145 // --------------------------------------------------------------------------
146 #ifdef _RHEOLEF_HAVE_MPI
147 template <class T>
150  const disarray<point_basic<T>,distributed>& node_list,
151  const std::array<disarray<geo_element_auto<heap_allocator<size_type> >,distributed>,
153  : geo_base_rep<T,distributed>(),
154  _inod2ios_dis_inod(),
155  _ios_inod2dis_inod(),
156  _ios_ige2dis_ige(),
157  _ios_gs(),
158  _igev2ios_dis_igev(),
159  _ios_igev2dis_igev()
160 {
161  base::build_from_list (lambda, node_list, ge_list);
162  // ------------------------------------------------------------------------
163  // 1) set external entities, at partition boundaries
164  // ------------------------------------------------------------------------
165  build_external_entities ();
166  // ------------------------------------------------------------------------
167  // 2) set ios numbering
168  // TODO: ios: not yet nproc independant
169  // ------------------------------------------------------------------------
170  communicator comm = lambda.sizes().node_ownership.comm();
171  if (comm.size() > 1) { dis_trace_macro ("ios: not yet fully computed"); }
172  _ios_gs = base::_gs;
173  //
174  // 2.1) node ios (TODO)
175  //
176  _inod2ios_dis_inod.resize (base::_node.ownership());
177  size_type first_dis_inod = base::_node.ownership().first_index();
178  for (size_type inod = 0, nnod = _inod2ios_dis_inod.size(); inod < nnod; inod++) {
179  _inod2ios_dis_inod [inod] = first_dis_inod + inod;
180  }
181  _ios_inod2dis_inod = _inod2ios_dis_inod;
182  //
183  // 2.2) 0d-elts = vertices (TODO)
184  //
185  _igev2ios_dis_igev[reference_element::p].resize (base::_gs.ownership_by_variant [reference_element::p]);
186  size_type first_dis_iv = base::_gs.ownership_by_variant [reference_element::p].first_index();
187  for (size_type iv = 0, nv = _igev2ios_dis_igev[reference_element::p].size(); iv < nv; iv++) {
188  _igev2ios_dis_igev [reference_element::p][iv] = first_dis_iv + iv;
189  }
190  _ios_igev2dis_igev[reference_element::p] = _igev2ios_dis_igev[reference_element::p];
191  //
192  // 2.3) element ios (TODO)
193  //
194  _ios_ige2dis_ige[base::_gs._map_dimension].resize (base::_gs.ownership_by_dimension [base::_gs._map_dimension]);
195  size_type first_dis_ige = base::_gs.ownership_by_dimension [base::_gs._map_dimension].first_index();
196  size_type ige = 0;
197  for (size_type variant = reference_element::first_variant_by_dimension(base::_gs._map_dimension);
198  variant < reference_element:: last_variant_by_dimension(base::_gs._map_dimension); variant++) {
199  _igev2ios_dis_igev[variant].resize (base::_gs.ownership_by_variant [variant]);
200  size_type first_dis_igev = base::_gs.ownership_by_variant [variant].first_index();
201  for (size_type igev = 0, ngev = base::_geo_element[variant].size(); igev < ngev; igev++, ige++) {
202  const geo_element& K = base::_geo_element [variant][igev];
203  _ios_ige2dis_ige [base::_gs._map_dimension][ige] = first_dis_ige + ige;
204  _igev2ios_dis_igev [variant][igev] = first_dis_igev + igev;
205  }
206  _ios_igev2dis_igev[variant] = _igev2ios_dis_igev [variant];
207  }
208 }
209 #endif // _RHEOLEF_HAVE_MPI
210 // ----------------------------------------------------------------------------
211 // instanciation in library
212 // ----------------------------------------------------------------------------
213 #define _RHEOLEF_instanciation(T,M) \
214 template \
215 void \
216 geo_base_rep<T,M>::build_from_list ( \
217  const geo_basic<T,M>& lambda, \
218  const disarray<point_basic<T>,M>& node_list, \
219  const std::array<disarray<geo_element_auto<heap_allocator<size_type> >,M>, \
220  reference_element::max_variant>& ge_list); \
221 template \
222 geo_rep<T,M>::geo_rep ( \
223  const geo_basic<T,M>& lambda, \
224  const disarray<point_basic<T>,M>& node_list, \
225  const std::array<disarray<geo_element_auto<heap_allocator<size_type> >,M>, \
226  reference_element::max_variant>& ge_list); \
227 
228 _RHEOLEF_instanciation(Float,sequential)
229 #ifdef _RHEOLEF_HAVE_MPI
230 _RHEOLEF_instanciation(Float,distributed)
231 #endif // _RHEOLEF_HAVE_MPI
232 
233 } // namespace rheolef
field::size_type size_type
Definition: branch.cc:425
see the Float page for the full documentation
see the disarray page for the full documentation
Definition: disarray.h:459
rep::base::const_iterator const_iterator
Definition: disarray.h:465
see the distributor page for the full documentation
Definition: distributor.h:62
static const size_type decide
Definition: distributor.h:76
base class for M=sequential or distributed meshes representations
Definition: geo.h:528
void build_from_list(const geo_basic< T, M > &lambda, const disarray< point_basic< T >, M > &node_list, const std::array< disarray< geo_element_auto< heap_allocator< size_type > >, M >, reference_element::max_variant > &elt_list)
base::size_type size_type
Definition: geo.h:533
see the geo_element page for the full documentation
Definition: geo_element.h:102
void set_ios_dis_ie(size_type ios_dis_ie)
Definition: geo_element.h:173
void set_dis_ie(size_type dis_ie)
Definition: geo_element.h:172
sequential mesh representation
Definition: geo.h:778
std::vector< T, A >::iterator iterator
Definition: hack_array.h:350
static const variant_type max_variant
static variant_type last_variant_by_dimension(size_type dim)
static variant_type first_variant_by_dimension(size_type dim)
static const variant_type p
#define dis_trace_macro(message)
Definition: dis_macros.h:30
Expr1::float_type T
Definition: field_expr.h:261
check_macro(expr1.have_homogeneous_space(Xh1), "dual(expr1,expr2); expr1 should have homogeneous space. HINT: use dual(interpolate(Xh, expr1),expr2)")
size_type nnod(const basis_basic< T > &b, const geo_size &gs, size_type map_dim)
This file is part of Rheolef.
void compute_bbox(const geo_base_rep< T, M > &omega, const geo_element &K, point_basic< T > &xmin, point_basic< T > &xmax)
Definition: geo_locate.cc:50
_RHEOLEF_instanciation(Float) _RHEOLEF_instanciation_evaluate(Float
Expr1::memory_type M
Definition: vec_expr_v2.h:416