← Back to branch summary

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

« back to all changes in this revision

Viewing changes to nfem/geo_element/geo_draft_tst.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/geo_element/geo_draft_tst.cc
 
1
///
 
2
/// This file is part of Rheolef.
 
3
///
 
4
/// Copyright (C) 2000-2009 Pierre Saramito <Pierre.Saramito@imag.fr>
 
5
///
 
6
/// Rheolef is free software; you can redistribute it and/or modify
 
7
/// it under the terms of the GNU General Public License as published by
 
8
/// the Free Software Foundation; either version 2 of the License, or
 
9
/// (at your option) any later version.
 
10
///
 
11
/// Rheolef is distributed in the hope that it will be useful,
 
12
/// but WITHOUT ANY WARRANTY; without even the implied warranty of
 
13
/// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
14
/// GNU General Public License for more details.
 
15
///
 
16
/// You should have received a copy of the GNU General Public License
 
17
/// along with Rheolef; if not, write to the Free Software
 
18
/// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
19
///
 
20
/// =========================================================================
 
21
//
 
22
// draft version of the geo class based on the hack_array class
 
23
// - geo::const_iterator        begin(dim), end(dim)
 
24
// - accessor                   geo_element& K = geo_element(dim,ige);
 
25
//
 
26
#include "rheolef/config.h"
 
27
#ifndef _RHEOLEF_HAVE_MPI
 
28
int main() { return 0; }
 
29
#else // _RHEOLEF_HAVE_MPI
 
30
 
 
31
#include "rheolef/hack_array.h"
 
32
#include "rheolef/geo_element.h"
 
33
using namespace rheolef;
 
34
using namespace std;
 
35
 
 
36
template<class T, class Ref, class Ptr, class IteratorByVariant>
 
37
class geo_iterator {
 
38
  // see std::deque<T>::iterator
 
39
  typedef geo_iterator<T,Ref,Ptr,IteratorByVariant>                  _self;
 
40
  typedef geo_iterator<T,T&,T*,typename hack_array<T>::iterator>  _iterator;
 
41
public:
 
42
 
 
43
// typedefs
 
44
 
 
45
  typedef std::random_access_iterator_tag iterator_category;
 
46
  typedef T                               value_type;
 
47
  typedef Ptr                             pointer;
 
48
  typedef Ref                             reference;
 
49
  typedef typename T::size_type           size_type;
 
50
  typedef ptrdiff_t                       difference_type;
 
51
 
 
52
// allocators:
 
53
 
 
54
  geo_iterator (size_type map_dim, const IteratorByVariant& iter, const class geo_abstract_rep& omega);
 
55
  geo_iterator (const _iterator& y);
 
56
 
 
57
// accessors & modifiers:
 
58
 
 
59
  reference operator* () const { return *_iter; }
 
60
  pointer   operator->() const { return _iter.operator->(); }
 
61
 
 
62
  _self& operator++ () { 
 
63
    // TODO: simplifier avec variant_by_dim :
 
64
    _iter++;
 
65
    switch(_map_dim) {
 
66
      case 0:
 
67
      case 1:  break;
 
68
      case 2:  if (_iter == _last_t) { _iter = _first_q; }; break;
 
69
      case 3:
 
70
      default: if (_iter == _last_T) { _iter = _first_P; };
 
71
               if (_iter == _last_P) { _iter = _first_H; };
 
72
               break;
 
73
    }
 
74
    return *this;
 
75
  }
 
76
  _self operator++ (int) { _self tmp = *this; operator++(); return tmp; }
 
77
 
 
78
protected:
 
79
  size_type         _map_dim;
 
80
  IteratorByVariant _iter;
 
81
  IteratorByVariant _last_t;
 
82
  IteratorByVariant _last_T;
 
83
  IteratorByVariant _last_P;
 
84
  IteratorByVariant _first_q;
 
85
  IteratorByVariant _first_P;
 
86
  IteratorByVariant _first_H;
 
87
};
 
88
class geo_abstract_rep {
 
89
public:
 
90
 
 
91
// typedefs
 
92
 
 
93
  typedef geo_element_hack::size_type                    size_type;
 
94
  typedef geo_element_hack::variant_type                 variant_type;
 
95
  typedef const geo_element&                          const_reference;
 
96
  typedef hack_array<geo_element_hack>::iterator       iterator_by_variant;
 
97
  typedef hack_array<geo_element_hack>::const_iterator const_iterator_by_variant;
 
98
  typedef geo_iterator<geo_element, geo_element&, geo_element*, iterator_by_variant>
 
99
          iterator; 
 
100
  typedef geo_iterator<geo_element, const geo_element&, const geo_element*, const_iterator_by_variant>
 
101
          const_iterator; 
 
102
 
 
103
// accessors & modifiers:
 
104
 
 
105
  virtual size_type size (size_type map_dim) const = 0;
 
106
  virtual const_reference get_geo_element (size_type map_dim, size_type ige) const = 0;
 
107
  virtual const_iterator_by_variant begin_by_variant (variant_type variant) const = 0;
 
108
  virtual const_iterator_by_variant   end_by_variant (variant_type variant) const = 0;
 
109
 
 
110
  const_iterator begin (size_type dim) const {
 
111
        const_iterator_by_variant iter = begin_by_variant (reference_element::first_variant_by_dimension(dim));
 
112
        return const_iterator (dim, iter, *this);
 
113
  }
 
114
  const_iterator end   (size_type dim) const {
 
115
        const_iterator_by_variant iter = end_by_variant (reference_element::last_variant_by_dimension(dim));
 
116
        return const_iterator (dim, iter, *this);
 
117
  }
 
118
};
 
119
template<class T, class Ref, class Ptr, class IteratorByVariant>
 
120
geo_iterator<T,Ref,Ptr,IteratorByVariant>::geo_iterator (
 
121
  size_type                map_dim,
 
122
  const IteratorByVariant& iter,
 
123
  const geo_abstract_rep&  omega)
 
124
 : _map_dim(map_dim),
 
125
   _iter(iter),
 
126
   _last_t  (omega.end_by_variant   (reference_element::t)),
 
127
   _last_T  (omega.end_by_variant   (reference_element::T)),
 
128
   _last_P  (omega.end_by_variant   (reference_element::P)),
 
129
   _first_q (omega.begin_by_variant (reference_element::q)),
 
130
   _first_P (omega.begin_by_variant (reference_element::P)),
 
131
   _first_H (omega.begin_by_variant (reference_element::H))
 
132
{
 
133
}
 
134
template<class T, class Ref, class Ptr, class IteratorByVariant>
 
135
geo_iterator<T,Ref,Ptr,IteratorByVariant>::geo_iterator (const _iterator& y)
 
136
 : _map_dim(y._map_dim),
 
137
   _iter(y._iter),
 
138
   _last_t  (y._last_t),
 
139
   _last_T  (y._last_T),
 
140
   _last_P  (y._last_P),
 
141
   _first_q (y._first_q),
 
142
   _first_P (y._first_P),
 
143
   _first_H (y._first_H)
 
144
{
 
145
}
 
146
class geo_rep: public geo_abstract_rep {
 
147
public:
 
148
  typedef std::allocator<size_t> A;
 
149
  typedef geo_abstract_rep::const_iterator_by_variant  const_iterator_by_variant;
 
150
  typedef geo_abstract_rep::iterator_by_variant        iterator_by_variant;
 
151
  typedef geo_element::variant_type                 variant_type;
 
152
  typedef geo_element::parameter_type               parameter_type;
 
153
 
 
154
  geo_rep () 
 
155
   {
 
156
     for (size_type variant = 0; variant < reference_element::max_variant; variant++) {
 
157
       _geo_element [variant]
 
158
        = hack_array_mpi_rep<geo_element_hack,A>(distributor(), parameter_type(reference_element::H, 1));
 
159
     }
 
160
   }
 
161
  size_type size (size_type map_dim) const {
 
162
    switch(map_dim) {
 
163
    // TODO: simplifier avec une bcle sur variant_by_dim :
 
164
      case 0:  return _geo_element [reference_element::p].size();
 
165
      case 1:  return _geo_element [reference_element::e].size();
 
166
      case 2:  return _geo_element [reference_element::t].size()
 
167
                    + _geo_element [reference_element::q].size();
 
168
      case 3:
 
169
      default: return _geo_element [reference_element::T].size()
 
170
                    + _geo_element [reference_element::P].size()
 
171
                    + _geo_element [reference_element::H].size();
 
172
    }
 
173
  }
 
174
  const_reference get_geo_element (size_type map_dim, size_type ige) const {
 
175
    // TODO: simplifier avec variant_by_dim :
 
176
    switch(map_dim) {
 
177
      case 0:  return _geo_element [reference_element::p] [ige];
 
178
      case 1:  return _geo_element [reference_element::e] [ige];
 
179
      case 2: {
 
180
               size_t s = _geo_element [reference_element::t].size();
 
181
               if (ige < s)
 
182
                  return  _geo_element [reference_element::t] [ige];
 
183
               return     _geo_element [reference_element::q] [ige - s];
 
184
              }
 
185
      case 3:
 
186
      default:{
 
187
               size_t sT =  _geo_element [reference_element::T].size();
 
188
               if (ige < sT) 
 
189
                  return   _geo_element [reference_element::T] [ige];
 
190
               size_t sP = sT + _geo_element [reference_element::P].size();
 
191
               if (ige < sP)
 
192
                  return _geo_element [reference_element::P] [ige - sT];
 
193
               return    _geo_element [reference_element::H] [ige - sP];
 
194
              }
 
195
    }
 
196
  }
 
197
  const_iterator_by_variant begin_by_variant (variant_type variant) const {
 
198
    return _geo_element [variant].begin();
 
199
  }
 
200
  const_iterator_by_variant end_by_variant (variant_type variant) const {
 
201
    return _geo_element [variant].end();
 
202
  }
 
203
protected:
 
204
  hack_array_mpi_rep<geo_element_hack,A> _geo_element [reference_element::max_variant];
 
205
};
 
206
int main(int argc, char**argv)
 
207
{
 
208
  environment distributed (argc, argv);
 
209
  geo_rep omega;
 
210
}
 
211
#endif // _RHEOLEF_HAVE_MPI