← Back to branch summary

~ubuntu-branches/ubuntu/wily/rheolef/wily

« back to all changes in this revision

Viewing changes to nfem/plib/geo_mpi.cc

  • Committer: Package Import Robot
  • Author(s): Pierre Saramito, Pierre Saramito, Sylvestre Ledru
  • Date: 2013-04-30 11:29:51 UTC
  • mfrom: (1.2.1) (11.1.1 experimental)
  • Revision ID: package-import@ubuntu.com-20130430112951-g69nuqin77t75dek
Tags: 6.4-1
[ Pierre Saramito ]
* New upstream release 6.4 (major changes):
  - new powerful c++ expressions for FEM specifications
  - configure script improved (portability increased)
  - minor bug fixes
* control:
  - all architectures are considered (armel & armhf are back)
  - no more circular-dependency librheolef-dev <--> rheolef
* rules: add security compiler flags (hardening and -W,-l,relro)
* watch: include an updated version, thanks to B. Martens <bartm@debian.org>
* copyright: various file format fixes

[ Sylvestre Ledru ]
*  Standards-Version updated to 3.9.4

Show diffs side-by-side

added added

removed removed

Lines of Context:
nfem/plib/geo_mpi.cc
24
24
 
25
25
namespace rheolef {
26
26
 
27
 
// --------------------------------------------------------------------------
28
 
// accessors to distributed data
29
 
// --------------------------------------------------------------------------
30
 
template <class T>
31
 
typename geo_rep<T,distributed>::const_reference  
32
 
geo_rep<T,distributed>::dis_get_geo_element (size_type dim, size_type dis_ige) const
33
 
{
34
 
  if (base::_gs.ownership_by_dimension[dim].is_owned (dis_ige)) {
35
 
    size_type first_dis_ige = base::_gs.ownership_by_dimension[dim].first_index();
36
 
    size_type ige = dis_ige - first_dis_ige;
37
 
    return get_geo_element (dim, ige);
38
 
  }
39
 
  // element is owned by another proc ; get its variant
40
 
  size_type iproc = base::_gs.ownership_by_dimension[dim].find_owner(dis_ige);
41
 
  size_type first_dis_ige = base::_gs.ownership_by_dimension[dim].first_index(iproc);
42
 
  size_type first_dis_v = first_dis_ige;
43
 
  size_type  last_dis_v = first_dis_v;
44
 
  size_type shift = 0;
45
 
  for (size_type variant = reference_element::first_variant_by_dimension(dim);
46
 
                 variant < reference_element:: last_variant_by_dimension(dim); variant++) {
47
 
    last_dis_v += base::_geo_element [variant].ownership().size (iproc);
48
 
    if (dis_ige < last_dis_v)  {
49
 
       assert_macro (dis_ige >= shift, "unexpected index computation");
50
 
       size_type dis_igev = dis_ige - shift;
51
 
       return base::_geo_element [variant].dis_at (dis_igev);
52
 
    }
53
 
    shift += base::_geo_element [variant].ownership().first_index (iproc);
54
 
    first_dis_v = last_dis_v;
55
 
  }
56
 
  error_macro ("geo_element dis_index " << dis_ige 
57
 
        << " cause problem; its range is [0:"<< base::_gs.ownership_by_dimension[dim].dis_size() << "[");
58
 
  return base::_geo_element [0].dis_at(0); // not reached
59
 
}
60
27
template <class T>
61
28
typename geo_rep<T,distributed>::size_type
62
29
geo_rep<T,distributed>::dis_ige2ios_dis_ige (size_type dim, size_type dis_ige) const
63
30
{
64
 
    const geo_element& K = dis_get_geo_element(dim,dis_ige);
 
31
    const geo_element& K = base::dis_get_geo_element(dim,dis_ige);
65
32
    return K.ios_dis_ie();
66
33
}
67
34
// --------------------------------------------------------------------------
86
53
    const geo_element& K = get_geo_element(dim,ige);
87
54
    return K.ios_dis_ie();
88
55
}
89
 
/** -------------------------------------------------------------------------
90
 
 * utility: vertex ownership follows node ownership, but dis_numbering differ
91
 
 * for high order > 1 meshes. This function converts numbering.
92
 
 * --------------------------------------------------------------------------
93
 
 */
94
 
template <class T>
95
 
typename geo_rep<T,distributed>::size_type
96
 
geo_rep<T,distributed>::dis_inod2dis_iv (size_type dis_inod) const
97
 
{
98
 
  if (base::order() == 1) return dis_inod;
99
 
  distributor vertex_ownership = geo_element_ownership(0);
100
 
  distributor   node_ownership = base::_node.ownership();
101
 
  size_type iproc          =   node_ownership.find_owner(dis_inod);
102
 
  size_type first_dis_inod =   node_ownership.first_index(iproc);
103
 
  size_type first_dis_iv   = vertex_ownership.first_index(iproc);
104
 
  size_type   inod = dis_inod - first_dis_inod;
105
 
  size_type     iv = inod;
106
 
  size_type dis_iv = first_dis_iv + iv;
107
 
  return dis_iv;
108
 
}
109
 
template <class T>
110
 
typename geo_rep<T,distributed>::size_type
111
 
geo_rep<T,distributed>::dis_iv2dis_inod (size_type dis_iv) const
112
 
{
113
 
  if (base::order() == 1) return dis_iv;
114
 
  distributor vertex_ownership = base::_gs.ownership_by_variant [reference_element::p];
115
 
  distributor   node_ownership = base::_gs.node_ownership;
116
 
  size_type iproc          = vertex_ownership.find_owner(dis_iv);
117
 
  size_type first_dis_iv   = vertex_ownership.first_index(iproc);
118
 
  size_type first_dis_inod =   node_ownership.first_index(iproc);
119
 
  size_type       iv = dis_iv - first_dis_iv;
120
 
  size_type     inod = iv;
121
 
  size_type dis_inod = first_dis_inod + inod;
122
 
  return dis_inod;
123
 
}
124
56
// ----------------------------------------------------------------------------
125
57
// instanciation in library
126
58
// ----------------------------------------------------------------------------