22#include "rheolef/geo_domain.h"
40 if (sid_dim != 0 && base::_gs._map_dimension <= sid_dim)
return;
47 for (
size_type ioige = 0, noige = indirect.
size(); ioige < noige; ioige++) {
50 for (
size_type loc_isid = 0, loc_nsid = bgd_K.
n_subgeo(sid_dim); loc_isid < loc_nsid; loc_isid++) {
58 case 1: bgd_dis_isid = bgd_K.
edge(loc_isid);
break;
59 case 2: bgd_dis_isid = bgd_K.
face(loc_isid);
break;
60 default:
error_macro (
"domain: unexpected side dimension " << sid_dim);
62 bgd_isid_is_on_domain[bgd_dis_isid] += 1;
68 if (bgd_isid_is_on_domain[bgd_isid] != 0) dom_nsid++ ;
76 bgd_isid2dom_dis_isid.resize (bgd_omega.
geo_element_ownership(sid_dim), std::numeric_limits<size_type>::max());
77 dom_isid2bgd_isid.resize (dom_isid_ownership, std::numeric_limits<size_type>::max());
79 if (bgd_isid_is_on_domain[bgd_isid] == 0)
continue;
81 bgd_isid2dom_dis_isid [bgd_isid] = dom_dis_isid;
82 dom_isid2bgd_isid [dom_isid] = bgd_isid;
84 size_by_variant [bgd_S.
variant()]++;
97 base::_geo_element[
variant].resize (dom_igev_ownership, param);
98 base::_gs.ownership_by_variant[
variant] = dom_igev_ownership;
99 dom_nge += dom_igev_ownership.
size();
100 dom_dis_nge += dom_igev_ownership.
dis_size();
102 base::_gs.ownership_by_dimension[sid_dim] =
distributor (dom_dis_nge, comm, dom_nge);
116 if (sid_dim != 0 && base::_gs._map_dimension <= sid_dim)
return;
122 distributor dom_isid_ownership = dom_isid2bgd_isid.ownership();
123 for (
size_type dom_isid = 0, dom_nsid = dom_isid_ownership.
size(); dom_isid < dom_nsid; dom_isid++) {
124 size_type bgd_isid = dom_isid2bgd_isid [dom_isid];
126 size_type dom_ios_dis_isid = dom_dis_isid;
128 geo_element& dom_S = get_geo_element(sid_dim,dom_isid);
138 for (
size_type dom_isid = 0, dom_nsid = dom_isid_ownership.
size(); dom_isid < dom_nsid; dom_isid++) {
139 geo_element& dom_S = get_geo_element(sid_dim,dom_isid);
141 for (
size_type iloc = 0, nloc = dom_S.
size(); iloc < nloc; iloc++) {
144 size_type dom_dis_iv = bgd_iv2dom_dis_iv.dis_at (bgd_dis_iv);
145 size_type dom_dis_inod = base::dis_iv2dis_inod (dom_dis_iv);
146 dom_S[iloc] = dom_dis_inod;
159 std::map<size_type,size_type>& bgd_ie2dom_ie,
160 std::map<size_type,size_type>& dis_bgd_ie2dis_dom_ie)
163 base::_name = bgd_omega.
name() +
"[" + indirect.
name() +
"]";
166 base::_dimension = bgd_omega.
dimension();
169 base::_have_connectivity = 1;
177 std::array<disarray<size_type,sequential>,4> bgd_ige2dom_dis_ige;
178 std::array<disarray<size_type,sequential>,4> dom_ige2bgd_ige;
179 domain_set_side_part1 (indirect, bgd_omega, 0,
180 bgd_ige2dom_dis_ige[0], dom_ige2bgd_ige[0],
181 dom_isid2dom_ios_dis_isid [0], size_by_variant);
182 domain_set_side_part2 (indirect, bgd_omega, bgd_ige2dom_dis_ige[0], 0,
183 bgd_ige2dom_dis_ige[0], dom_ige2bgd_ige[0],
184 dom_isid2dom_ios_dis_isid [0], size_by_variant);
192 for (
size_type ioige = 0, noige = indirect.
size(); ioige < noige; ioige++) {
194 bgd_ie2dom_ie [ige] = ioige;
196 size_by_variant [bgd_K.
variant()]++;
207 base::_geo_element[
variant].resize (dom_igev_ownership, param);
208 base::_gs.ownership_by_variant [
variant] = dom_igev_ownership;
209 dis_nge += dom_igev_ownership.
dis_size();
210 nge += dom_igev_ownership.
size();
212 base::_gs.ownership_by_dimension [
map_dim] =
distributor (dis_nge, base::comm(), nge);
217 for (
size_type sid_dim = 1; sid_dim < base::_gs._map_dimension; sid_dim++) {
218 domain_set_side_part1 (indirect, bgd_omega, sid_dim,
219 bgd_ige2dom_dis_ige[sid_dim], dom_ige2bgd_ige[sid_dim],
220 dom_isid2dom_ios_dis_isid [sid_dim], size_by_variant);
226 std::array<size_type,reference_element::max_variant> loc_nnod_by_variant ;
232 nnod += base::_gs.ownership_by_variant [
variant].size() * loc_nnod_by_variant [
variant];
235 base::_gs.node_ownership = dom_node_ownership;
239 size_type first_dis_ioige = indirect.ownership().first_index();
240 for (
size_type ioige = 0, noige = indirect.
size(); ioige < noige; ioige++) {
241 size_type dis_ioige = first_dis_ioige + ioige;
250 for (
size_type iloc = 0, nloc = dom_K.
size(); iloc < nloc; iloc++) {
253 size_type dom_dis_iv = bgd_ige2dom_dis_ige[0].dis_at (bgd_dis_iv);
254 size_type dom_dis_inod = base::dis_iv2dis_inod (dom_dis_iv);
255 dom_K[iloc] = dom_dis_inod;
259 if (base::_gs._map_dimension > 0) {
260 dom_ige2bgd_ige [base::_gs._map_dimension].resize(indirect.ownership());
261 bgd_ige2dom_dis_ige[base::_gs._map_dimension].resize(bgd_omega.
geo_element_ownership(base::_gs._map_dimension), std::numeric_limits<size_type>::max());
262 for (
size_type ioige = 0, noige = indirect.
size(); ioige < noige; ioige++) {
264 dom_ige2bgd_ige [base::_gs._map_dimension] [ioige] = bgd_ige;
265 bgd_ige2dom_dis_ige[base::_gs._map_dimension] [bgd_ige] = ioige;
272 for (
size_type sid_dim = 1; sid_dim < base::_gs._map_dimension; sid_dim++) {
273 domain_set_side_part2 (indirect, bgd_omega, bgd_ige2dom_dis_ige[0], sid_dim,
274 bgd_ige2dom_dis_ige[sid_dim], dom_ige2bgd_ige[sid_dim],
275 dom_isid2dom_ios_dis_isid [sid_dim], size_by_variant);
282 base::_node.resize (dom_node_ownership);
291 if (loc_nnod_by_variant [
variant] == 0)
continue;
293 for (
size_type dom_igev = 0, dom_ngev = base::_geo_element [
variant].size(); dom_igev < dom_ngev; dom_igev++, dom_ige++) {
297 size_type bgd_igev = bgd_ige - first_bgd_v;
298 for (
size_type loc_inod = 0, loc_nnod = loc_nnod_by_variant [
variant]; loc_inod < loc_nnod; loc_inod++, dom_inod++) {
299 size_type bgd_inod = first_bgd_inod_v + bgd_igev * loc_nnod_by_variant [
variant] + loc_inod;
300 dom_inod2bgd_inod [dom_inod] = bgd_inod;
301 base::_node [dom_inod] = bgd_omega.
node (bgd_inod);
312 set_element_side_index (
dim);
319 size_type dom_inod = base::dis_iv2dis_inod (dom_iv);
326 check_macro (ptr != 0,
"cannot build domains on \""<<base::_name<<
"\"");
331 if (bgd_dom.
name() == indirect.
name())
continue;
333 if (dom_map_dim > base::_gs._map_dimension)
continue;
334 std::vector<size_type> ie_list;
338 size_type dom_dis_ige = bgd_ige2dom_dis_ige [dom_map_dim][bgd_ige];
339 if (dom_dis_ige == std::numeric_limits<size_type>::max())
continue;
341 ie_list.push_back(dom_ige);
343 if (ie_list.size() == 0)
continue;
345 base::_domains.push_back (dom);
see the distributor page for the full documentation
size_type dis_size() const
global and local sizes
size_type size(size_type iproc) const
static const size_type decide
const communicator_type & comm() const
const_iterator_ioige ioige_end() const
const_iterator_ioige ioige_begin() const
size_type map_dimension() const
the finite element boundary domain
size_type map_dimension() const
const geo_element_indirect & oige(size_type ioige) const
virtual const node_type & node(size_type inod) const =0
virtual const basis_basic< T > & get_piola_basis() const =0
virtual const distributor & geo_element_ownership(size_type dim) const =0
virtual std::string name() const =0
geo_element_hack::size_type size_type
virtual const_reference get_geo_element(size_type dim, size_type ige) const =0
virtual const geo_size & sizes() const =0
virtual size_type dis_inod2dis_iv(size_type dis_inod) const =0
virtual size_type dimension() const =0
virtual coordinate_type coordinate_system() const =0
const domain_indirect_basic< M > & get_domain_indirect(size_type i) const
size_type n_domain_indirect() const
see the geo_element page for the full documentation
size_type edge(size_type i) const
size_type face(size_type i) const
void set_ios_dis_ie(size_type ios_dis_ie)
size_type dimension() const
variant_type variant() const
size_type n_subgeo(size_type subgeo_dim) const
void set_dis_ie(size_type dis_ie)
sequential mesh representation
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
#define trace_macro(message)
#define assert_macro(ok_condition, message)
#define error_macro(message)
check_macro(expr1.have_homogeneous_space(Xh1), "dual(expr1,expr2); expr1 should have homogeneous space. HINT: use dual(interpolate(Xh, expr1),expr2)")
size_type nnod(const basis_basic< T > &b, const geo_size &gs, size_type map_dim)
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)
distributor ownership_by_variant[reference_element::max_variant]
distributor first_by_variant[reference_element::max_variant]