1 #include "rheolef/config.h"
22 #ifdef _RHEOLEF_HAVE_MPI
23 #include "rheolef/geo.h"
24 #include "rheolef/geo_domain.h"
25 #include "rheolef/space_numbering.h"
26 #include "rheolef/dis_macros.h"
27 #include "rheolef/rheostream.h"
28 #include "rheolef/iorheo.h"
29 #include "rheolef/index_set.h"
38 const distributor& ownership_by_dimension,
47 build_true_ios_ge_ownership_by_dimension (
56 if (first_variant >= last_variant)
return distributor();
57 const communicator& comm = ios_geo_element [first_variant].ownership().comm();
63 nge += ios_geo_element [
variant].size();
64 dis_nge += ios_geo_element [
variant].dis_size();
66 return distributor (dis_nge, comm, nge);
70 build_apparent_ios_ownership(
76 distributor& ios_ownership,
83 if (first_variant >= last_variant)
return;
84 const communicator& comm = ios_geo_element [first_variant].ownership().comm();
90 dis_nge += ios_geo_element [
variant].dis_size();
102 size_type last_dis_v = first_dis_v + dis_ngev;
103 size_type first_ios_dis_nge = ios_ownership.first_index();
104 size_type last_ios_dis_nge = ios_ownership. last_index();
105 size_type first_ios_dis_ngev = min (max (first_ios_dis_nge, first_dis_v), last_ios_dis_nge);
106 size_type last_ios_dis_ngev = max (min ( last_ios_dis_nge, last_dis_v), first_ios_dis_nge);
107 size_type ios_ngev = last_ios_dis_ngev - first_ios_dis_ngev;
108 ios_ownership_by_variant [
variant] = distributor (dis_ngev, comm, ios_ngev);
109 first_dis_v = last_dis_v;
120 geo_element_renumbering_part1_new (
124 const geo_size& ios_gs,
127 std::array<std::vector<size_t>, 4>& massive_partition_by_dimension,
132 size_type dis_nv = ios_vertex_ownership.dis_size();
133 size_type first_ios_dis_iv = ios_vertex_ownership.first_index();
138 disarray<index_set,distributed> K_ball (ios_vertex_ownership,
empty_set);
141 distributor true_K_ios_ge_ownership = build_true_ios_ge_ownership_by_dimension (ios_geo_element, K_dim);
142 size_type first_K_ios_dis_ige = true_K_ios_ge_ownership.first_index();
145 distributor K_ios_gev_ownership = ios_geo_element [K_variant].ownership();
146 for (
size_type K_ios_igev = 0, K_ios_ngev = K_ios_gev_ownership.size(); K_ios_igev < K_ios_ngev; K_ios_igev++, K_ios_ige++) {
147 const geo_element& K = ios_geo_element [K_variant] [K_ios_igev];
148 size_type K_ios_dis_ige = first_K_ios_dis_ige + K_ios_ige;
149 for (
size_type iloc = 0, nloc = K.size(); iloc < nloc; iloc++) {
151 assert_macro (ios_dis_iv < dis_nv,
"K={"<<K<<
"}: "<<iloc<<
"-vertex index " << ios_dis_iv <<
" out of range [0:"<<dis_nv<<
"[");
152 if (ios_vertex_ownership.is_owned(ios_dis_iv)) {
153 size_type ios_iv = ios_dis_iv - first_ios_dis_iv;
154 K_ball[ios_iv] += K_ios_dis_ige;
156 index_set K_ios_dis_ige_set;
157 K_ios_dis_ige_set += K_ios_dis_ige;
158 K_ball.dis_entry (ios_dis_iv) += K_ios_dis_ige_set;
163 K_ball.dis_entry_assembly();
167 index_set ext_ios_dis_iv;
170 distributor ios_gev_ownership = ios_geo_element [S_variant].ownership();
171 for (
size_type ios_igev = 0, ios_ngev = ios_gev_ownership.size(); ios_igev < ios_ngev; ios_igev++) {
172 const geo_element& S = ios_geo_element [S_variant] [ios_igev];
173 for (
size_type iloc = 0, nloc = S.size(); iloc < nloc; iloc++) {
175 if (! ios_vertex_ownership.is_owned (ios_dis_iv)) {
176 ext_ios_dis_iv += ios_dis_iv;
181 K_ball.set_dis_indexes (ext_ios_dis_iv);
185 distributor true_S_ios_ge_ownership = build_true_ios_ge_ownership_by_dimension (ios_geo_element, S_dim);
186 size_type S_dis_nge = true_S_ios_ge_ownership.dis_size();
187 size_type first_S_ios_dis_ige = true_S_ios_ge_ownership.first_index();
188 std::vector<size_type> tmp_S_massive_partition (S_dis_nge, 0);
192 distributor ios_gev_ownership = ios_geo_element [S_variant].ownership();
193 size_type first_ios_dis_igev = ios_gev_ownership.first_index();
194 for (
size_type ios_igev = 0, ios_ngev = ios_gev_ownership.size(); ios_igev < ios_ngev; ios_igev++, S_ios_ige++) {
195 const geo_element& S = ios_geo_element [S_variant] [ios_igev];
196 index_set K_ios_ige_set = K_ball.dis_at (S[0]);
197 for (
size_type iloc = 0, nloc = S.size(); iloc < nloc; iloc++) {
198 K_ios_ige_set.inplace_intersection (K_ball.dis_at(S[iloc]));
200 check_macro (K_ios_ige_set.size() > 0,
"connectivity: S={"<<S<<
"} not found in the side set");
202 for (index_set::const_iterator iter = K_ios_ige_set.begin(), last = K_ios_ige_set.end(); iter != last; iter++) {
204 S_owner = std::max(S_owner, massive_partition_by_dimension[K_dim][K_ios_ige]);
206 size_type S_ios_dis_ige = first_S_ios_dis_ige + S_ios_ige;
207 tmp_S_massive_partition [S_ios_dis_ige] = S_owner;
213 massive_partition_by_dimension[S_dim].resize (tmp_S_massive_partition.size(), 0);
214 communicator comm = ios_vertex_ownership.comm();
217 tmp_S_massive_partition.begin().operator->(),
218 tmp_S_massive_partition.size(),
219 massive_partition_by_dimension[S_dim].begin().operator->(),
220 mpi::maximum<size_type>());
224 size_type S_ios_dis_ige = first_S_ios_dis_ige;
227 partition_by_variant [S_variant].resize (ios_geo_element [S_variant].ownership());
228 for (
size_type S_ios_igev = 0, S_ios_negv = partition_by_variant [S_variant].size();
229 S_ios_igev < S_ios_negv; S_ios_igev++, S_ios_dis_ige++) {
230 partition_by_variant [S_variant][S_ios_igev] = massive_partition_by_dimension[S_dim] [S_ios_dis_ige];
238 geo_element_renumbering_part2 (
242 const geo_size& ios_gs,
253 std::array<disarray<size_t>,4>& ios_ige2dis_ige,
256 partition_by_variant)
262 communicator comm = ios_geo_element[0].ownership().comm();
271 ios_geo_element [
variant].repartition (
272 partition_by_variant [
variant],
277 gs.ownership_by_variant [
variant] = geo_element [
variant].ownership();
278 nge += geo_element [
variant].size();
290 first_v += geo_element [
variant].size();
298 ios_ige2dis_ige [side_dim].resize (ios_gs.ownership_by_dimension [side_dim]);
300 size_type first_dis_ige = gs.ownership_by_dimension [side_dim].first_index();
305 for (
size_type igev = 0, ngev = geo_element [
variant].size(); igev < ngev; igev++, ige++) {
310 ios_ige2dis_ige [side_dim].dis_entry (ios_dis_ige) = dis_ige;
313 ios_ige2dis_ige [side_dim].dis_entry_assembly();
317 geo_element_renumbering_propagate (
319 const std::vector<geo_element::size_type>& new_global_node_num,
322 hack_array<geo_element_hack>& gev)
330 size_type first_dis_igev = gev.ownership().first_index();
331 for (
size_type igev = 0, ngev = gev.size(); igev < ngev; igev++) {
332 geo_element& S = gev [igev];
333 for (
size_type iloc = 0, nloc = S.n_node(); iloc < nloc; iloc++) {
334 assert_macro (S[iloc] <
dis_nnod,
"node index "<<S[iloc]<<
" out of range [0:"<<
dis_nnod<<
"[");
335 assert_macro (new_global_node_num[S[iloc]] <
dis_nnod,
"new node index "<<new_global_node_num[S[iloc]] <<
" out of range [0:"<<
dis_nnod<<
"[");
336 S[iloc] = new_global_node_num [S[iloc]];
349 geo_rep<T,distributed>::build_external_entities ()
352 size_type first_dis_iv = vertex_ownership.first_index();
353 size_type last_dis_iv = vertex_ownership.last_index();
354 size_type dis_nv = vertex_ownership.dis_size();
356 distributor node_ownership = base::_node.ownership();
357 size_type first_dis_inod = node_ownership.first_index();
358 size_type last_dis_inod = node_ownership.last_index();
362 std::set<size_type> ext_vertex_set;
363 std::set<size_type> ext_node_set;
364 std::vector<size_type> dis_inod1;
367 for (
size_type ige = 0, nge = base::_gs.ownership_by_dimension[
dim].size(); ige < nge; ige++) {
368 const geo_element& K = get_geo_element(
dim,ige);
370 for (
size_type loc_inod = 0, loc_nnod = dis_inod1.size(); loc_inod < loc_nnod; loc_inod++) {
373 if (node_ownership.is_owned (
dis_inod))
continue;
375 if (loc_inod >= K.size())
continue;
378 check_macro (dis_iv < dis_nv,
"vertex index "<< dis_iv <<
" out of range [0:"<<dis_nv<<
"[");
379 check_macro (!vertex_ownership.is_owned (dis_iv),
"strange bug: not owned (nod) but is_owned(ver)");
380 ext_vertex_set.insert (dis_iv);
385 base::_node.append_dis_indexes (ext_node_set);
392 const std::map<size_type,geo_element_auto<>>& ext_gev = base::_geo_element [
variant].get_dis_map_entries();
393 index_set ext_dis_ie_set;
394 for (
auto i: ext_gev) { ext_dis_ie_set.insert (i.first); }
395 base::_geo_element [
variant].set_dis_indexes (ext_dis_ie_set);
398 std::array<index_set,reference_element::max_variant> ext_dis_igev_set;
402 for (
auto x : base::_geo_element[
variant].get_dis_map_entries()) {
403 const geo_element& K = x.second;
404 for (
size_type subgeo_dim = 0; subgeo_dim < K.dimension(); ++subgeo_dim) {
405 for (
size_type loc_is = 0, loc_ns = K.n_subgeo(subgeo_dim); loc_is < loc_ns; ++loc_is) {
406 size_type dis_ige = (subgeo_dim == 0) ? base::dis_inod2dis_iv(K[loc_is]) : (subgeo_dim == 1) ? K.edge(loc_is) : K.face(loc_is);
407 check_macro(dis_ige != std::numeric_limits<size_type>::max(),
"invalid external subgeo dis_index");
408 if (base::sizes().ownership_by_dimension [subgeo_dim].is_owned (dis_ige))
continue;
410 size_type dis_size = base::sizes().ownership_by_dimension [subgeo_dim].dis_size();
411 check_macro(dis_ige < dis_size,
"invalid external "<<subgeo_dim<<
"d subgeo dis_index = "<<dis_ige<<
" out of range [0:"<<dis_size<<
"[");
414 size_type dis_igev = base::sizes().dis_ige2dis_igev_by_dimension (subgeo_dim, dis_ige,
variant);
415 ext_dis_igev_set [
variant].insert (dis_igev);
424 base::_geo_element [
variant].append_dis_indexes (ext_dis_igev_set [
variant]);
430 for (
auto x : base::_geo_element[
variant].get_dis_map_entries()) {
431 const geo_element& K = x.second;
433 for (
size_type loc_inod = 0, loc_nnod = dis_inod1.size(); loc_inod < loc_nnod; loc_inod++) {
436 if (node_ownership.is_owned (
dis_inod))
continue;
443 base::_node.set_dis_indexes (ext_node_set);
451 geo_rep<T,distributed>::set_element_side_index (
size_type side_dim)
453 distributor vertex_ownership = base::_gs.ownership_by_dimension [0];
454 distributor node_ownership = base::_node.ownership();
456 size_type first_dis_iv = vertex_ownership.first_index();
457 size_type last_dis_iv = vertex_ownership. last_index();
462 index_set ext_iv_set;
466 for (
size_type igev = 0, ngev = base::_geo_element[
var].size(); igev < ngev; igev++) {
467 const geo_element& K = base::_geo_element [
var] [igev];
468 for (
size_type iloc = 0, nloc = K.size(); iloc < nloc; iloc++) {
470 if (! node_ownership.is_owned(
dis_inod)) {
472 ext_iv_set.insert (dis_iv);
486 distributor gev_ownership = base::_gs.ownership_by_variant [
variant];
487 size_type first_dis_igev = gev_ownership.first_index();
488 for (
size_type igev = 0, ngev = base::_geo_element [
variant].size(); igev < ngev; igev++) {
489 const geo_element& S = base::_geo_element [
variant] [igev];
490 size_type dis_igev = first_dis_igev + igev;
491 for (
size_type iloc = 0, nloc = S.size(); iloc < nloc; iloc++) {
495 if (vertex_ownership.is_owned(dis_iv)) {
497 ball [
variant][iv] += dis_igev;
499 index_set dis_igev_set;
500 dis_igev_set += dis_igev;
501 ball [
variant].dis_entry (dis_iv) += dis_igev_set;
505 ball [
variant].dis_entry_assembly();
514 ball [
variant].set_dis_indexes (ext_iv_set);
526 std::set<size_type> ext_igev_set;
527 distributor gev_ownership = base::_gs.ownership_by_variant [
variant];
528 size_type dis_ngev = gev_ownership.dis_size();
529 for (
size_type iv = 0, nv = vertex_ownership.size(); iv < nv; iv++) {
531 const index_set& ball_iv = ball [
variant] [iv];
532 for (index_set::const_iterator iter = ball_iv.begin(), last = ball_iv.end(); iter != last; iter++) {
534 assert_macro (dis_igev < dis_ngev,
"index "<<dis_igev<<
" of element variant="<<
variant<<
" is out of range [0:"<<dis_ngev<<
"[");
535 if (! gev_ownership.is_owned (dis_igev)) {
536 ext_igev_set.insert (dis_igev);
541 typedef disarray<index_set>::scatter_map_type map_type;
542 const map_type& ball_dis = ball [
variant].get_dis_map_entries();
543 for (
typename map_type::const_iterator iter_b = ball_dis.begin(), last_b = ball_dis.end(); iter_b != last_b; iter_b++) {
545 const index_set& ball_dis_iv = (*iter_b).second;
546 for (index_set::const_iterator iter = ball_dis_iv.begin(), last = ball_dis_iv.end(); iter != last; iter++) {
548 assert_macro (dis_igev < dis_ngev,
"index "<<dis_igev<<
" of element variant="<<
variant<<
" is out of range [0:"<<dis_ngev<<
"[");
549 if (! gev_ownership.is_owned (dis_igev)) {
550 ext_igev_set.insert (dis_igev);
555 base::_geo_element[
variant].append_dis_indexes (ext_igev_set);
568 for (
size_type igev = 0, ngev = base::_geo_element [
var].size(); igev < ngev; igev++) {
569 geo_element& K = base::_geo_element [
var] [igev];
572 for (
size_type loc_isid = 0, loc_nsid = K.n_subgeo(side_dim); loc_isid < loc_nsid; loc_isid++) {
573 size_type S_size = K.subgeo_size (side_dim, loc_isid);
575 size_type loc_jv0 = K.subgeo_local_vertex (side_dim, loc_isid, 0);
576 S_inod [0] = K[loc_jv0];
577 S_iv [0] = base::dis_inod2dis_iv (S_inod[0]);
578 const disarray<index_set,distributed>& ball_S_variant = ball [S_variant];
579 index_set igev_set = ball_S_variant.dis_at (S_iv[0]);
580 for (
size_type sid_jloc = 1, sid_nloc = S_size; sid_jloc < sid_nloc; sid_jloc++) {
581 size_type loc_jv = K.subgeo_local_vertex (side_dim, loc_isid, sid_jloc);
582 S_inod [sid_jloc] = K[loc_jv];
583 S_iv [sid_jloc] = base::dis_inod2dis_iv (S_inod[sid_jloc]);
584 const index_set& ball_jv = ball_S_variant.dis_at (S_iv[sid_jloc]);
585 igev_set.inplace_intersection (ball_jv);
587 check_macro (igev_set.size() > 0,
"connectivity: "<<S_size<<
"-side ("
588 <<S_iv[0]<<
","<<S_iv[1]<<
","<<S_iv[2]<<
","<<S_iv[3]<<
") not found in the side set");
589 check_macro (igev_set.size() == 1,
"connectivity: the same side is multiply represented");
590 size_type dis_igev = *(igev_set.begin());
591 const geo_element& S = base::_geo_element[S_variant].dis_at(dis_igev);
596 K.edge_indirect (loc_isid).set (orient, dis_isid);
600 if (K.subgeo_size (side_dim, loc_isid) == 3) {
602 S.get_orientation_and_shift (S_inod[0], S_inod[1], S_inod[2], orient, shift);
605 S.get_orientation_and_shift (S_inod[0], S_inod[1], S_inod[2], S_inod[3], orient, shift);
607 K.face_indirect (loc_isid).set (orient, dis_isid, shift);
620 geo_rep<T,distributed>::set_ios_permutation (disarray<size_type,distributed>& idof2ios_dis_idof)
const
626 geo_rep<T,distributed>::node_renumbering (
const distributor& ios_node_ownership)
628 std::array<size_type,reference_element::max_variant> loc_ndof_by_variant;
630 set_ios_permutation (_inod2ios_dis_inod);
637 geo_rep<T,distributed>::get (idiststream& ips)
640 check_macro (ips.good(),
"bad input stream for geo.");
643 size_type io_proc = idiststream::io_proc();
651 check_macro (
dis_scatch(ips, ips.comm(),
"\nmesh"),
"input stream does not contains a geo.");
652 ips >> base::_version;
653 check_macro (base::_version == 4,
"geo version < 4 not supported (HINT: see geo -upgrade)");
657 check_macro (! hdr.need_upgrade(),
658 "unsupported geo without connectivity in the distributed version: HINT: use geo_upgrade");
659 base::_have_connectivity =
true;
660 base::_dimension = hdr.dimension;
661 base::_gs._map_dimension = hdr.map_dimension;
662 base::_sys_coord = hdr.sys_coord;
663 base::_name =
"unnamed";
664 base::_piola_basis.reset_family_index (hdr.order);
666 size_type dis_nedg = hdr.dis_size_by_dimension [1];
667 size_type dis_nfac = hdr.dis_size_by_dimension [2];
668 size_type dis_ne = hdr.dis_size_by_dimension [base::_gs._map_dimension];
674 disarray<node_type> ios_node (
dis_nnod);
675 ios_node.get_values (ips, _point_get<T>(base::_dimension));
676 check_macro (ips.good(),
"bad input stream for geo.");
682 if (base::_gs._map_dimension == 0) {
683 ios_nv = ios_node.size();
690 geo_element::parameter_type param (
variant, 1);
691 ios_geo_element [
variant].resize (hdr.dis_size_by_variant [
variant], param);
692 ios_geo_element [
variant].get_values (ips);
694 ios_ne += ios_geo_element [
variant].size();
695 dis_ne += ios_geo_element [
variant].dis_size();
697 build_apparent_ios_ownership(
699 base::_gs._map_dimension,
700 _ios_gs.ownership_by_dimension [base::_gs._map_dimension],
701 _ios_gs.ownership_by_variant);
703 vector<size_type> local_is_vertex (
dis_nnod, 0);
707 size_type first_ios_dis_igev = ios_geo_element [
variant].ownership().first_index();
709 for (iterator_by_variant iter = ios_geo_element [
variant].begin(), last = ios_geo_element [
variant].end();
710 iter != last; iter++, ios_igev++) {
711 geo_element& K = *iter;
712 size_type ios_dis_ie = first_ios_dis_v + first_ios_dis_igev + ios_igev;
713 K.set_ios_dis_ie (ios_dis_ie);
714 ios_size_by_variant [K.variant()]++;
716 for (
size_type iloc = 0, nloc = K.size(); iloc < nloc; iloc++) {
717 local_is_vertex [K[iloc]] = 1;
723 ios_nv = ios_node.size();
725 vector<size_type> global_is_vertex (
dis_nnod, 0);
728 local_is_vertex.begin().operator->(),
729 local_is_vertex.size(),
730 global_is_vertex.begin().operator->(),
731 mpi::maximum<size_type>());
732 ios_nv = accumulate (global_is_vertex.begin() + ios_node.ownership().first_index(),
733 global_is_vertex.begin() + ios_node.ownership().last_index(), 0);
736 distributor ios_vertex_ownership;
738 ios_vertex_ownership = ios_node.ownership();
742 size_type dis_nv = ios_vertex_ownership.dis_size();
752 _ios_gs.ownership_by_dimension [0] = ios_vertex_ownership;
753 size_type first_ios_dis_iv = ios_vertex_ownership.first_index();
754 for (
size_type ios_iv = 0, ios_nv = ios_vertex_ownership.size(); ios_iv < ios_nv; ios_iv++) {
756 size_type ios_dis_iv = first_ios_dis_iv + ios_iv;
758 P.set_ios_dis_ie (ios_dis_iv);
759 ios_size_by_variant [P.variant()]++;
765 if (base::_gs._map_dimension > 0) {
766 for (
size_type side_dim = base::_gs._map_dimension - 1; side_dim >= 1; side_dim--) {
771 geo_element::parameter_type param (
variant, 1);
772 ios_geo_element [
variant].resize (hdr.dis_size_by_variant [
variant], param);
773 ios_geo_element [
variant].get_values (ips);
775 ios_ngev += ios_geo_element [
variant].size();
776 dis_ngev += ios_geo_element [
variant].dis_size();
778 build_apparent_ios_ownership(
781 _ios_gs.ownership_by_dimension [side_dim],
782 _ios_gs.ownership_by_variant);
788 size_type first_ios_dis_igev = ios_geo_element [
variant].ownership().first_index();
789 for (iterator_by_variant iter = ios_geo_element [
variant].begin(), last = ios_geo_element [
variant].end();
790 iter != last; iter++, ios_igev++) {
791 geo_element& S = *iter;
792 size_type ios_dis_igev = first_dis_v + first_ios_dis_igev + ios_igev;
793 S.set_ios_dis_ie (ios_dis_igev);
794 ios_size_by_variant [S.variant()]++;
802 distributor true_ios_ownership_by_dimension [4];
803 true_ios_ownership_by_dimension [base::_gs._map_dimension]
804 = build_true_ios_ge_ownership_by_dimension (ios_geo_element, base::_gs._map_dimension);
806 disarray<size_type> partition = geo_mpi_partition (
808 true_ios_ownership_by_dimension [base::_gs._map_dimension],
809 base::_gs._map_dimension,
818 partition_by_variant [
variant].resize (ios_geo_element [
variant].ownership());
820 last_by_var = partition_by_variant [
variant].end();
821 iter_by_var != last_by_var; iter_by_var++, iter++) {
822 *iter_by_var = *iter;
826 geo_element_renumbering_part2 (
830 base::_gs._map_dimension,
836 partition_by_variant);
840 std::array<std::vector<size_t>, 4> massive_partition_by_dimension;
842 std::vector<size_t> tmp_massive_partition (dis_ne, 0);
843 size_type true_first_dis_ige = true_ios_ownership_by_dimension [base::_gs._map_dimension].first_index();
844 for (
size_type ios_ie = 0, ios_ne = partition.size(); ios_ie < ios_ne; ios_ie++) {
845 size_type ios_dis_ie = true_first_dis_ige + ios_ie;
846 tmp_massive_partition [ios_dis_ie] = partition [ios_ie];
848 massive_partition_by_dimension [base::_gs._map_dimension].resize (dis_ne);
851 tmp_massive_partition.begin().operator->(),
852 tmp_massive_partition.size(),
853 massive_partition_by_dimension[base::_gs._map_dimension].begin().operator->(),
854 mpi::maximum<size_type>());
857 for (
size_type supergeo_dim = base::_gs.map_dimension(); supergeo_dim > 0; supergeo_dim--) {
858 geo_element_renumbering_part1_new (
862 massive_partition_by_dimension,
863 partition_by_variant);
872 size_type first_ios_dis_iv = ios_vertex_ownership.first_index();
873 for (
size_type ios_iv = 0, ios_nv = ios_vertex_ownership.size(); ios_iv < ios_nv; ios_iv++) {
874 size_type ios_dis_iv = first_ios_dis_iv + ios_iv;
875 partition_by_variant [
reference_element::p] [ios_iv] = massive_partition_by_dimension[0] [ios_dis_iv];
877 disarray<size_type> iv2ios_dis_iv;
882 _ios_ige2dis_ige[0]);
885 base::_gs.ownership_by_dimension [0] = vertex_ownership;
891 size_type first_dis_iv = vertex_ownership.first_index();
892 size_type last_dis_iv = vertex_ownership.last_index();
898 P.set_dis_ie (dis_iv);
904 if (base::_gs._map_dimension > 0) {
905 for (
size_type side_dim = base::_gs._map_dimension-1; side_dim > 0; side_dim--) {
907 geo_element_renumbering_part2 (
917 partition_by_variant);
924 domain_indirect_basic<distributed> dom;
925 bool status = dom.get (ips, *
this);
927 base::_domains.push_back (dom);
932 node_renumbering (ios_node.ownership());
933 distributor node_ownership = _inod2ios_dis_inod.ownership();
934 base::_gs.node_ownership = node_ownership;
938 _ios_inod2dis_inod.resize (ios_node.ownership(), std::numeric_limits<size_type>::max());
939 _inod2ios_dis_inod.reverse_permutation (_ios_inod2dis_inod);
945 base::_node.resize (node_ownership);
946 ios_node.permutation_apply (_ios_inod2dis_inod, base::_node);
950 vector<size_type> new_local_node_num (
dis_nnod, 0);
951 size_type first_ios_inod = _ios_inod2dis_inod.ownership().first_index();
952 size_type last_ios_inod = _ios_inod2dis_inod.ownership(). last_index();
953 for (
size_type dis_ios_inod = first_ios_inod; dis_ios_inod < last_ios_inod; dis_ios_inod++) {
954 size_type ios_inod = dis_ios_inod - first_ios_inod;
955 new_local_node_num [dis_ios_inod] = _ios_inod2dis_inod[ios_inod];
957 vector<size_type> new_global_node_num (
dis_nnod, 0);
960 new_local_node_num.begin().operator->(),
961 new_local_node_num.size(),
962 new_global_node_num.begin().operator->(),
963 mpi::maximum<size_type>());
971 geo_element_renumbering_propagate (
980 for (
size_type dim = base::_gs._map_dimension - 1; base::_gs._map_dimension > 0 &&
dim > 0;
dim--) {
981 set_element_side_index (
dim);
986 build_external_entities ();
999 std::string filename,
1000 const communicator& comm)
1003 ips.open (filename,
"geo", comm);
1004 check_macro(ips.good(),
"\"" << filename <<
"[.geo[.gz]]\" not found.");
1013 template class geo_rep<Float,distributed>;
field::size_type size_type
rep::base::const_iterator const_iterator
rep::base::iterator iterator
static const size_type decide
see the geo_element page for the full documentation
geo_element_indirect::orientation_type orientation_type
reference_element::size_type size_type
size_type ios_dis_ie() const
geo_element_indirect::shift_type shift_type
void set_dis_ie(size_type dis_ie)
std::vector< T, A >::iterator iterator
std::vector< T, A >::const_iterator const_iterator
static const variant_type max_variant
static void init_local_nnode_by_variant(size_type order, std::array< size_type, reference_element::max_variant > &loc_nnod_by_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
variant_type variant() const
static std::set< size_t > empty_set
check_macro(expr1.have_homogeneous_space(Xh1), "dual(expr1,expr2); expr1 should have homogeneous space. HINT: use dual(interpolate(Xh, expr1),expr2)")
void dis_idof(const basis_basic< T > &b, const geo_size &gs, const geo_element &K, typename std::vector< size_type >::iterator dis_idof_tab)
void dis_inod(const basis_basic< T > &b, const geo_size &gs, const geo_element &K, typename std::vector< size_type >::iterator dis_inod_tab)
size_type dis_nnod(const basis_basic< T > &b, const geo_size &gs, size_type map_dim)
void generic_set_ios_permutation(const basis_basic< T > &b, size_t map_d, const geo_size &gs, const std::array< disarray< size_t, distributed >, reference_element::max_variant > &igev2ios_dis_igev, disarray< size_t, distributed > &idof2ios_dis_idof)
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)
string delete_suffix(const string &name, const string &suffix)
delete_suffix: see the rheostream page for the full documentation
string get_basename(const string &name)
get_basename: see the rheostream page for the full documentation
bool dis_scatch(idiststream &ips, const communicator &comm, std::string ch)
distributed version of scatch(istream&,string)
void load(idiststream &in, Float &p, field &uh)