28#include "rheolef/geo.h"
29#include "rheolef/rheostream.h"
30#include "rheolef/iorheo.h"
36bamg_load_element (std::istream& is,
size_t variant, geo_element_auto<>& K)
39 for (
size_t iloc = 0, nloc = K.size(); iloc < nloc; iloc++) {
49 const disarray<geo_element_auto<>, sequential>& elt,
50 const disarray<size_t, sequential>& elt_bamg_dom_id,
51 const std::vector<std::string>& dom_name,
52 const geo_basic<T,sequential>& omega,
53 vector<index_set>* ball)
56 typedef typename geo_basic<T,sequential>::size_type
size_type;
57 typedef pair<size_type,size_type> pair_t;
58 typedef geo_element_auto<> element_t;
59 typedef disarray<element_t, sequential> e_array_t;
60 typedef disarray<size_type, sequential> i_array_t;
61 typedef map<size_type, pair_t, less<size_type> > map_t;
69 for (
size_type ie = 0, ne = elt_bamg_dom_id.size(); ie < ne; ie++) {
71 typename map_t::iterator iter = bamg_id2idom.find (bamg_id);
72 if (iter != bamg_id2idom.end()) {
74 ((*iter).second.second)++;
78 bamg_id2idom.insert (pair<size_type,pair_t>(bamg_id, pair_t(idom,1)));
85 if (ndom != dom_name.size()) {
87 << dom_name.size() <<
" domain name(s) founded while "
88 << ndom <<
" bamg "<<dom_dim<<
"d domain(s) are defined");
96 vector<e_array_t>
domain (ndom, e_array_t(0, dummy_elt));
97 vector<size_type> counter (ndom, 0);
98 for (
size_type ie = 0, ne = elt_bamg_dom_id.size(); ie < ne; ie++) {
99 size_type bamg_dom_id = elt_bamg_dom_id [ie];
100 size_type idom = bamg_id2idom [bamg_dom_id].first;
101 if (domain[idom].size() == 0) {
102 size_type size = bamg_id2idom [bamg_dom_id].second;
103 domain[idom] = e_array_t (size, dummy_elt);
106 domain[idom][dom_ie] = elt[ie];
112 for (
typename map_t::const_iterator
113 iter = bamg_id2idom.begin(),
114 last = bamg_id2idom.end(); iter != last; ++iter) {
118 check_macro (idom < dom_name.size(),
"invalid idom="<<idom<<
" for domain name");
119 string name = dom_name [idom];
121 domain_indirect_basic<sequential> dom (domain[idom], omega, ball);
123 dom.set_map_dimension (dom_dim);
124 omega.insert_domain_indirect (dom);
126 size_type ndom2 = omega.n_domain_indirect();
131build_vertex_domains (
132 const disarray<size_t, sequential>& edg_bdr_bamg_dom_id,
133 const disarray<size_t, sequential>& vert_bamg_dom_id,
134 const std::vector<std::string>& dom_name,
135 const geo_basic<T,sequential>& omega,
136 vector<index_set>* ball)
138 if (dom_name.size() == 0)
return;
139 typedef geo_element_auto<> element_t;
140 typedef disarray<element_t, sequential> v_array_t;
145 std::set<size_t> vert_id;
146 for (
size_t iv = 0, nv = vert_bamg_dom_id.size(); iv < nv; ++iv) {
147 size_t dom_id = vert_bamg_dom_id [iv];
148 if (dom_id == 0)
continue;
149 vert_id.insert (dom_id);
154 for (
size_t iedg_bdr = 0, nedg_bdr = edg_bdr_bamg_dom_id.size(); iedg_bdr < nedg_bdr; ++iedg_bdr) {
155 size_t dom_id = edg_bdr_bamg_dom_id [iedg_bdr];
156 vert_id.erase (dom_id);
159 "unexpected VertexDomainNames with "<<dom_name.size()
160 <<
" domain names while the mesh provides " << vert_id.size()
166 for (std::set<size_t>::const_iterator iter = vert_id.begin(); iter != vert_id.end(); ++iter, ++idom) {
168 string name = dom_name[idom];
170 for (
size_t iv = 0, nv = vert_bamg_dom_id.size(); iv < nv; ++iv) {
171 if (vert_bamg_dom_id [iv] ==
id) dom_size++;
173 v_array_t vert_list (dom_size, dummy_elt);
174 for (
size_t iv = 0, iv_dom = 0, nv = vert_bamg_dom_id.size(); iv < nv; ++iv) {
175 if (vert_bamg_dom_id [iv] !=
id)
continue;
176 element_t& K = vert_list [iv_dom];
181 domain_indirect_basic<sequential> dom (vert_list, omega, ball);
183 dom.set_map_dimension (0);
184 omega.insert_domain_indirect (dom);
196 istream& is = ips.
is();
212 i_array_t vert_bamg_dom_id;
213 i_array_t edg_bdr_bamg_dom_id;
214 i_array_t tri_bamg_dom_id;
215 i_array_t qua_bamg_dom_id;
217 std::array<e_array_t, reference_element::max_variant> tmp_geo_element;
219 while (is.good() && label !=
"End") {
221 if (label ==
"Vertices") {
236 vert_bamg_dom_id = i_array_t (nnod, 0);
237 for (
size_type inod = 0; inod < nnod; inod++) {
238 is >>
vertex[inod][0] >>
vertex[inod][1] >> vert_bamg_dom_id[inod];
241 }
else if (label ==
"Triangles") {
253 tri_bamg_dom_id = i_array_t (nt, 0);
257 is >> tri_bamg_dom_id[it];
259 }
else if (label ==
"Quadrilaterals") {
270 qua_bamg_dom_id = i_array_t (nq, 0);
274 is >> qua_bamg_dom_id[iq];
276 }
else if (label ==
"Edges") {
285 edg_bdr = e_array_t (nedg, init_edg);
286 edg_bdr_bamg_dom_id = i_array_t (nedg, 0);
287 for (
size_type iedg = 0; iedg < nedg; iedg++) {
288 element_t& K = edg_bdr[iedg];
290 for (
size_type iloc = 0, nloc = 2; iloc < nloc; iloc++) {
294 is >> edg_bdr_bamg_dom_id[iedg];
301 vector<string> vertice_domain_name;
302 vector<string> edg_dom_name;
303 vector<string> region_domain_name;
308 while (c ==
'E' || c ==
'V' || c ==
'R') {
311 if (!
scatch(is,
"RegionDomainNames"))
break;
314 region_domain_name.resize (n_dom_region);
315 for (
size_type k = 0; k < n_dom_region; k++) {
316 is >> region_domain_name[k];
318 }
else if (c ==
'E') {
319 if (!
scatch(is,
"EdgeDomainNames"))
break;
325 edg_dom_name.resize (n_dom_edge);
326 for (
size_type k = 0; k < n_dom_edge; k++) {
327 is >> edg_dom_name[k];
329 }
else if (c ==
'V') {
330 if (!
scatch(is,
"VertexDomainNames"))
break;
336 vertice_domain_name.resize (n_dom_vertice);
337 for (
size_type k = 0; k < n_dom_vertice; k++) {
338 is >> vertice_domain_name[k];
346 bool do_upgrade =
true;
347 omega.build_from_data (hdr,
vertex, tmp_geo_element, do_upgrade);
352 vector<index_set> ball[4];
353 build_domains (1, edg_bdr, edg_bdr_bamg_dom_id, edg_dom_name, omega, ball);
354 build_vertex_domains (edg_bdr_bamg_dom_id, vert_bamg_dom_id, vertice_domain_name, omega, ball);
field::size_type size_type
see the disarray page for the full documentation
generic mesh with rerefence counting
idiststream: see the diststream page for the full documentation
static const variant_type q
static const variant_type e
static const variant_type p
static const variant_type t
#define error_macro(message)
#define warning_macro(message)
const point vertex[n_vertex]
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.
idiststream & geo_get_bamg(idiststream &ips, geo_basic< T, sequential > &omega)
bool scatch(std::istream &in, const std::string &ch, bool full_match=true)
scatch: see the rheostream page for the full documentation
template idiststream & geo_get_bamg< Float >(idiststream &, geo_basic< Float, sequential > &)