← Back to branch summary

~ubuntu-branches/ubuntu/trusty/rheolef/trusty

« back to all changes in this revision

Viewing changes to nfem/lib/geo.cc

  • Committer: Package Import Robot
  • Author(s): Pierre Saramito
  • Date: 2012-04-06 09:12:21 UTC
  • mfrom: (1.1.5)
  • Revision ID: package-import@ubuntu.com-20120406091221-m58me99p1nxqui49
Tags: 6.0-1
http://bugs.debian.org/667356
http://bugs.debian.org/661689
* New upstream release 6.0 (major changes):
  - massively distributed and parallel support
  - full FEM characteristic method (Lagrange-Gakerkin method) support
  - enhanced users documentation 
  - source code supports g++-4.7 (closes: #667356)
* debian/control: dependencies for MPI distributed solvers added
* debian/rules: build commands simplified
* debian/librheolef-dev.install: man1/* to man9/* added
* debian/changelog: package description rewritted (closes: #661689)

Show diffs side-by-side

added added

removed removed

Lines of Context:
nfem/lib/geo.cc
94
94
   _name(g._name),
95
95
   _number(g._number),
96
96
   _serial_number(g._serial_number),
 
97
   _zero_level_set_number(0),
97
98
   _dim(g._dim),
98
99
   _coord_sys(g._coord_sys),
99
100
   _x(g._x),
111
112
{
112
113
    for (size_type i = 0; i < 4; i++)
113
114
        _count_geo[i] = g._count_geo[i];
114
 
    for (size_type i = 0; i < reference_element::max_size; i++)
 
115
    for (size_type i = 0; i < reference_element::max_variant; i++)
115
116
        _count_element[i] = g._count_element[i];
116
117
}
117
118
// ----------------------------------------------------------------------------
122
123
georep::reset_counters ()
123
124
{
124
125
   std::fill(_count_geo, _count_geo+4, 0);
125
 
   std::fill(_count_element, _count_element+reference_element::max_size, 0);
 
126
   std::fill(_count_element, _count_element+reference_element::max_variant, 0);
126
127
}
127
128
georep::georep(const string& a_file_name, const string& coord_sys_name)
128
129
  : occurence(),
130
131
    _name(), 
131
132
    _number(numeric_limits<size_type>::max()),
132
133
    _serial_number(numeric_limits<size_type>::max()),
 
134
    _zero_level_set_number(0),
133
135
    _dim(0), 
134
136
    _coord_sys(fem_helper::coordinate_system(coord_sys_name)),
135
137
    _x(), 
205
207
   _name(g._name),
206
208
   _number(numeric_limits<size_type>::max()),
207
209
   _serial_number(numeric_limits<size_type>::max()),
 
210
   _zero_level_set_number(0),
208
211
   _dim(g._dim),
209
212
   _coord_sys(g._coord_sys),
210
213
   _x(p),
246
249
  
247
250
  for (size_type i = 0; i < 4; i++)
248
251
        _count_geo[i] = g._count_geo[i];
249
 
  for (size_type i = 0; i < reference_element::max_size; i++)
 
252
  for (size_type i = 0; i < reference_element::max_variant; i++)
250
253
        _count_element[i] = g._count_element[i];
251
254
}
252
255
// ----------------------------------------------------------------------------
259
262
    _name(d.name()),
260
263
    _number(numeric_limits<size_type>::max()),
261
264
    _serial_number(numeric_limits<size_type>::max()),
 
265
   _zero_level_set_number(0),
262
266
    _dim(g.dimension()),
263
267
    _coord_sys(g._coord_sys),
264
268
    _x(),
283
287
  // step 1 : numbering of vertices
284
288
 
285
289
  vector<bool> node_on_d (g.n_node(), false);
286
 
  domain::const_iterator last_side = d.end();
287
 
  for (domain::const_iterator i = d.begin(); i != last_side; i++) {
 
290
  for (domain::const_iterator i = d.begin(), last_side = d.end(); i != last_side; i++) {
288
291
 
289
292
      const geo_element& S = *i;
290
293
      for (size_type j = 0; j < S.size(); j++)
325
328
  resize(d.size());
326
329
  size_type K_idx = 0;
327
330
  iterator iter_elt = begin(); 
328
 
  for (domain::const_iterator iter_side = d.begin(); 
 
331
  for (domain::const_iterator iter_side = d.begin(), last_side = d.end(); 
329
332
        iter_side != last_side; 
330
333
        iter_side++, K_idx++, iter_elt++) {
331
334
 
332
335
      const geo_element& S = *iter_side;
333
336
      geo_element&       K = *iter_elt;
334
 
      K.set_type(S.type()) ;
 
337
      K.set_variant(S.variant()) ;
335
338
      K.set_index (K_idx);
336
339
      for (size_type i = 0; i < K.size(); i++) {
337
340
          K[i] = new_vertex_idx [S[i]];
338
341
      }
339
342
      // update counters
340
343
      _count_geo    [K.dimension()]++;
341
 
      _count_element[K.type()]++;
 
344
      _count_element[K.variant()]++;
342
345
  }
343
346
  build_connectivity (*this);
344
347
}
560
563
georep::hatter (const point& x, size_type K_idx) const
561
564
{
562
565
    const geo_element& K = element(K_idx);
563
 
    switch(begin()[K_idx].type()) {
 
566
    switch(begin()[K_idx].variant()) {
564
567
        case geo_element::e: {
565
568
            if (dimension()==1)
566
569
             {
616
619
point
617
620
georep::dehatter (const meshpoint& S, bool is_a_vector) const
618
621
{
619
 
    switch(begin()[S.element()].type())
 
622
    switch(begin()[S.element()].variant())
620
623
     {
621
624
        case geo_element::e: {
622
625
            double a = begin_node()[begin()[S.element()][0]][0];
717
720
    ;
718
721
  for (size_type i = 0; i < 4; i++)
719
722
     os << "count_geo[" << i << "] = " << _count_geo[i] << endl;
720
 
  for (size_type i = 0; i < reference_element::max_size; i++)
 
723
  for (size_type i = 0; i < reference_element::max_variant; i++)
721
724
     os << "count_element[" << i << "] = " << _count_element[i] << endl;
722
725
 
723
726
  size_type i = 0;
802
805
          const geo_element& K = *iter_elt;
803
806
          for (size_type i = 0; i < K.n_face(); i++) {
804
807
              size_type idx = K.subgeo (2, i);
805
 
              if (f [idx].type() == reference_element::max_size) {
 
808
              if (f [idx].variant() == reference_element::max_variant) {
806
809
                // not yet builded:
807
810
                K.build_subgeo (2, i, f[idx]);
808
811
              }
975
978
      is >> (*i);
976
979
      (*i).set_index (idx);
977
980
      _count_geo     [(*i).dimension()]++;
978
 
      _count_element [(*i).type()]++;
 
981
      _count_element [(*i).variant()]++;
979
982
  }
980
983
  size_type map_d = map_dimension();
981
984
 
1186
1189
georep::measure (const geo_element& K) const
1187
1190
{
1188
1191
  georep::const_iterator_vertex p = begin_vertex();
1189
 
  switch (K.type()) {
 
1192
  switch (K.variant()) {
1190
1193
    case geo_element::p:
1191
1194
      return 0;
1192
1195
    case geo_element::e:
1226
1229
point
1227
1230
georep::normal (const geo_element& K, georep::size_type side) const
1228
1231
{
1229
 
  switch (K.type()) {
 
1232
  switch (K.variant()) {
1230
1233
    case reference_element::e:  { // works also in 2d and 3d
1231
1234
      point t = vertex(K[1]) - vertex(K[0]);
1232
1235
      t = t/norm(t);
1240
1243
    // TODO: T, P, H...
1241
1244
    default:
1242
1245
      error_macro("normal to element not yet implemented for element type `"
1243
 
        << K.type() << "'");
 
1246
        << K.variant() << "'");
1244
1247
  }
1245
1248
}
1246
1249
// compute normal to a facet: triangle in 3D, etc
1247
1250
point
1248
1251
georep::normal (const geo_element& S) const
1249
1252
{
1250
 
  switch (S.type()) {
 
1253
  switch (S.variant()) {
1251
1254
    case reference_element::e:  { // 2d space
1252
1255
      point t = vertex(S[1]) - vertex(S[0]);
1253
1256
      t = t/norm(t);
1263
1266
    }
1264
1267
    default:
1265
1268
      error_macro("normal to facet not yet implemented for element type `"
1266
 
        << S.type() << "'");
 
1269
        << S.variant() << "'");
1267
1270
  }
1268
1271
}
1269
1272
}// namespace rheolef