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,
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
231 #endif // _RHEOLEF_HAVE_MPI
232 
233 } // namespace rheolef
rheolef::reference_element::last_variant_by_dimension
static variant_type last_variant_by_dimension(size_type dim)
Definition: reference_element.h:150
rheolef::hack_array::iterator
std::vector< T, A >::iterator iterator
Definition: hack_array.h:350
rheolef::geo_base_rep::size_type
base::size_type size_type
Definition: geo.h:533
rheolef::compute_bbox
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::geo_basic
generic mesh with rerefence counting
Definition: geo.h:1089
rheolef::point_basic
Definition: point.h:87
check_macro
check_macro(expr1.have_homogeneous_space(Xh1), "dual(expr1,expr2); expr1 should have homogeneous space. HINT: use dual(interpolate(Xh, expr1),expr2)")
rheolef::_RHEOLEF_instanciation
_RHEOLEF_instanciation(Float, sequential, std::allocator< Float >) _RHEOLEF_instanciation(Float
rheolef::sequential
Definition: distributed.h:28
rheolef::geo_base_rep
base class for M=sequential or distributed meshes representations
Definition: geo.h:528
rheolef::disarray::const_iterator
rep::base::const_iterator const_iterator
Definition: disarray.h:465
rheolef::distributor
see the distributor page for the full documentation
Definition: distributor.h:62
mkgeo_ball.order
order
Definition: mkgeo_ball.sh:343
rheolef::geo_element
see the geo_element page for the full documentation
Definition: geo_element.h:102
rheolef::geo_rep
sequential mesh representation
Definition: geo.h:778
rheolef::geo_element_auto
Definition: geo_element.h:376
rheolef::distributor::decide
static const size_type decide
Definition: distributor.h:76
rheolef::reference_element::first_variant_by_dimension
static variant_type first_variant_by_dimension(size_type dim)
Definition: reference_element.h:148
mkgeo_ball.variant
int variant
Definition: mkgeo_ball.sh:149
rheolef::geo_element::set_dis_ie
void set_dis_ie(size_type dis_ie)
Definition: geo_element.h:172
rheolef::geo_basic< T, sequential >
Definition: geo.h:1108
rheolef::geo_basic< T, distributed >
distributed mesh with rerefence counting
Definition: geo.h:1367
rheolef::distributed
Definition: distributed.h:88
rheolef
This file is part of Rheolef.
Definition: compiler_eigen.h:37
rheolef::geo_element::parameter_type
Definition: geo_element.h:136
Float
see the Float page for the full documentation
rheolef::reference_element::max_variant
static const variant_type max_variant
Definition: reference_element.h:82
rheolef::disarray
see the disarray page for the full documentation
Definition: disarray.h:459
rheolef::reference_element::dimension
size_type dimension() const
Definition: reference_element.h:101
rheolef::reference_element::p
static const variant_type p
Definition: reference_element.h:75
rheolef::space_numbering::nnod
size_type nnod(const basis_basic< T > &b, const geo_size &gs, size_type map_dim)
Definition: space_numbering.cc:54
rheolef::geo_rep< T, distributed >::size_type
base::size_type size_type
Definition: geo.h:934
rheolef::geo_base_rep::build_from_list
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)
Definition: geo_build_from_list.cc:36
rheolef::distributed
distributed
Definition: asr.cc:228
dis_trace_macro
#define dis_trace_macro(message)
Definition: dis_macros.h:112
M
Expr1::memory_type M
Definition: vec_expr_v2.h:416
T
Expr1::float_type T
Definition: field_expr.h:261
rheolef::heap_allocator
Definition: heap_allocator.h:69
lambda
Definition: yield_slip_circle.h:34
rheolef::geo_element::set_ios_dis_ie
void set_ios_dis_ie(size_type ios_dis_ie)
Definition: geo_element.h:173
trace_macro
#define trace_macro(message)
Definition: dis_macros.h:111