Rheolef  7.2
an efficient C++ finite element environment
 
Loading...
Searching...
No Matches
geo_build_from_list.cc
Go to the documentation of this file.
1
21// 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
29namespace rheolef {
30
31// --------------------------------------------------------------------------
32// base class, common to seq & dist derived classes
33// --------------------------------------------------------------------------
34template <class T, class M>
35void
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;
55 for (size_type variant = 0; variant < reference_element::max_variant; variant++) {
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();
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;
74 for (size_type variant = reference_element::first_variant_by_dimension(_gs._map_dimension);
75 variant < reference_element:: last_variant_by_dimension(_gs._map_dimension); variant++) {
76 size_type nge = ge_list [variant].size();
77 _gs.ownership_by_variant [variant] = distributor (distributor::decide, comm, nge);
78 geo_element::parameter_type param (variant, order());
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;
109 for (size_type variant = reference_element::first_variant_by_dimension(_gs._map_dimension);
110 variant < reference_element:: last_variant_by_dimension(_gs._map_dimension); variant++) {
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// --------------------------------------------------------------------------
133template <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
147template <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) \
214template \
215void \
216geo_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); \
221template \
222geo_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
229#ifdef _RHEOLEF_HAVE_MPI
230_RHEOLEF_instanciation(Float,distributed)
231#endif // _RHEOLEF_HAVE_MPI
232
233} // namespace rheolef
#define _RHEOLEF_instanciation(T, M, A)
Definition asr.cc:223
see the Float page for the full documentation
see the disarray page for the full documentation
Definition disarray.h:497
rep::base::const_iterator const_iterator
Definition disarray.h:503
see the distributor page for the full documentation
Definition distributor.h:69
static const size_type decide
Definition distributor.h:83
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
generic mesh with rerefence counting
Definition geo.h:1089
see the geo_element page for the full documentation
void set_ios_dis_ie(size_type ios_dis_ie)
void set_dis_ie(size_type dis_ie)
base::size_type size_type
Definition geo.h:934
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 trace_macro(message)
Definition dis_macros.h:111
#define dis_trace_macro(message)
Definition dis_macros.h:112
Expr1::float_type T
Definition field_expr.h:230
check_macro(expr1.have_homogeneous_space(Xh1), "dual(expr1,expr2); expr1 should have homogeneous space. HINT: use dual(interpolate(Xh, expr1),expr2)")
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
Expr1::memory_type M