127 std::array<std::vector<size_t>, 4>& massive_partition_by_dimension,
141 distributor true_K_ios_ge_ownership = build_true_ios_ge_ownership_by_dimension (ios_geo_element, K_dim);
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;
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();
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);
188 std::vector<size_type> tmp_S_massive_partition (S_dis_nge, 0);
192 distributor ios_gev_ownership = ios_geo_element [S_variant].ownership();
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++) {
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);
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];
356 distributor node_ownership = base::_node.ownership();
362 std::set<size_type> ext_vertex_set;
363 std::set<size_type> ext_node_set;
364 std::vector<size_type> dis_inod1;
365 for (
size_type dim = 1; dim <= base::_gs._map_dimension; dim++) {
367 for (
size_type ige = 0, nge = base::_gs.ownership_by_dimension[dim].size(); ige < nge; ige++) {
370 for (
size_type loc_inod = 0, loc_nnod = dis_inod1.size(); loc_inod < loc_nnod; loc_inod++) {
371 size_type dis_inod = dis_inod1 [loc_inod];
372 assert_macro (dis_inod < dis_nnod,
"node index "<< dis_inod <<
" out of range [0:"<<dis_nnod<<
"[");
373 if (node_ownership.
is_owned (dis_inod))
continue;
374 ext_node_set.insert (dis_inod);
375 if (loc_inod >= K.
size())
continue;
377 size_type dis_iv = base::dis_inod2dis_iv (dis_inod);
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();
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;
399 for (
size_type dim = base::_gs._map_dimension; dim >= 1; dim--) {
402 for (
auto x : base::_geo_element[variant].get_dis_map_entries()) {
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]);
427 for (
size_type dim = base::_gs._map_dimension; dim >= 1; dim--) {
430 for (
auto x : base::_geo_element[variant].get_dis_map_entries()) {
433 for (
size_type loc_inod = 0, loc_nnod = dis_inod1.size(); loc_inod < loc_nnod; loc_inod++) {
434 size_type dis_inod = dis_inod1 [loc_inod];
435 assert_macro (dis_inod < dis_nnod,
"node index "<< dis_inod <<
" out of range [0:"<<dis_nnod<<
"[");
436 if (node_ownership.
is_owned (dis_inod))
continue;
437 ext_node_set.insert (dis_inod);
443 base::_node.set_dis_indexes (ext_node_set);
453 distributor vertex_ownership = base::_gs.ownership_by_dimension [0];
454 distributor node_ownership = base::_node.ownership();
457 size_type last_dis_iv = vertex_ownership. last_index();
463 for (
size_type dim = side_dim; dim <= base::_gs._map_dimension; dim++) {
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)) {
471 size_type dis_iv = base::dis_inod2dis_iv (dis_inod);
472 ext_iv_set.
insert (dis_iv);
485 ball [variant].resize (vertex_ownership, empty_set);
486 distributor gev_ownership = base::_gs.ownership_by_variant [variant];
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++) {
493 assert_macro (dis_inod < dis_nnod,
"S={"<<S<<
"}: "<<iloc<<
"-node index " << dis_inod <<
" out of range [0:"<<dis_nnod<<
"[");
494 size_type dis_iv = base::dis_inod2dis_iv (dis_inod);
495 if (vertex_ownership.
is_owned(dis_iv)) {
497 ball [variant][iv] += dis_igev;
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];
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);
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);
565 for (
size_type dim = side_dim+1; dim <= base::_gs._map_dimension; dim++) {
568 for (
size_type igev = 0, ngev = base::_geo_element [var].size(); igev < ngev; igev++) {
572 for (
size_type loc_isid = 0, loc_nsid = K.
n_subgeo(side_dim); loc_isid < loc_nsid; loc_isid++) {
576 S_inod [0] = K[loc_jv0];
577 S_iv [0] = base::dis_inod2dis_iv (S_inod[0]);
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++) {
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]);
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);
652 ips >> base::_version;
653 check_macro (base::_version == 4,
"geo version < 4 not supported (HINT: see geo -upgrade)");
658 "unsupported geo without connectivity in the distributed version: HINT: use geo_upgrade");
659 base::_have_connectivity =
true;
663 base::_name =
"unnamed";
664 base::_piola_basis.reset_family_index (hdr.
order);
682 if (base::_gs._map_dimension == 0) {
683 ios_nv = ios_node.size();
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);
706 size_type first_ios_dis_v = _ios_gs.first_by_variant [variant].dis_size();
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++) {
712 size_type ios_dis_ie = first_ios_dis_v + first_ios_dis_igev + ios_igev;
714 ios_size_by_variant [K.
variant()]++;
715 if (base::order() > 1) {
716 for (
size_type iloc = 0, nloc = K.
size(); iloc < nloc; iloc++) {
717 local_is_vertex [K[iloc]] = 1;
722 if (base::order() == 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);
737 if (base::order() == 1) {
738 ios_vertex_ownership = ios_node.ownership();
752 _ios_gs.ownership_by_dimension [0] = ios_vertex_ownership;
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;
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--) {
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);
787 size_type first_dis_v = _ios_gs.first_by_variant [variant].dis_size();
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++) {
792 size_type ios_dis_igev = first_dis_v + first_ios_dis_igev + ios_igev;
794 ios_size_by_variant [S.
variant()]++;
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);
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;
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--) {
862 massive_partition_by_dimension,
863 partition_by_variant);
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];
882 _ios_ige2dis_ige[0]);
885 base::_gs.ownership_by_dimension [0] = vertex_ownership;
904 if (base::_gs._map_dimension > 0) {
905 for (
size_type side_dim = base::_gs._map_dimension-1; side_dim > 0; side_dim--) {
917 partition_by_variant);
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>());
968 for (
size_type dim = base::_gs._map_dimension; dim > 0; dim--) {
974 base::_geo_element [variant]);
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 ();
990 base::compute_bbox();