← Back to branch summary

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

« back to all changes in this revision

Viewing changes to nfem/plib/geo_domain_indirect_seq.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/plib/geo_domain_indirect_seq.cc
39
39
  return _omega.get_geo_element (dim, ige);
40
40
}
41
41
template <class T, class M>
42
 
typename geo_domain_indirect_base_rep<T,M>::const_iterator
43
 
geo_domain_indirect_base_rep<T,M>::begin (size_type dim) const
 
42
typename geo_domain_indirect_base_rep<T,M>::const_iterator_by_variant
 
43
geo_domain_indirect_base_rep<T,M>::begin_by_variant (variant_type variant) const
44
44
{
45
45
  error_macro ("domain.begin: not yet");
46
 
  return _omega.begin (dim); // (not reached) 
47
 
  // Note: here, not valid for dim=map_dimension ; requires a proxy_reference
 
46
  return _omega.begin_by_variant (variant); // (not reached) 
 
47
  // Note: here, not valid for dim(variant)=map_dimension ; requires a proxy_reference
48
48
}
49
49
template <class T, class M>
50
 
typename geo_domain_indirect_base_rep<T,M>::const_iterator
51
 
geo_domain_indirect_base_rep<T,M>::end (size_type dim) const
 
50
typename geo_domain_indirect_base_rep<T,M>::const_iterator_by_variant
 
51
geo_domain_indirect_base_rep<T,M>::end_by_variant (variant_type variant) const
52
52
{
53
53
  error_macro ("domain.end: not yet");
54
 
  return _omega.end (dim); // (not reached) 
55
 
  // Note: here, not valid for dim=map_dimension ; requires a proxy_reference
 
54
  return _omega.end_by_variant (variant); // (not reached) 
 
55
  // Note: here, not valid for dim(variant)=map_dimension ; requires a proxy_reference
56
56
}
57
57
template <class T, class M>
58
58
typename geo_domain_indirect_base_rep<T,M>::size_type
61
61
  return 0;
62
62
}
63
63
template <class T, class M>
 
64
bool
 
65
geo_domain_indirect_base_rep<T,M>::have_domain_indirect(const std::string& name) const
 
66
{
 
67
  return false;
 
68
}
 
69
template <class T, class M>
64
70
const domain_indirect_basic<M>&
65
71
geo_domain_indirect_base_rep<T,M>::get_domain_indirect (size_type i) const
66
72
{
75
81
  return _indirect; // not reached
76
82
}
77
83
template <class T, class M>
 
84
void
 
85
geo_domain_indirect_base_rep<T,M>::insert_domain_indirect (const domain_indirect_basic<M>& dom) const
 
86
{
 
87
  error_macro ("insert_domain_indirect: cannot insert inside another domain");
 
88
}
 
89
template <class T, class M>
78
90
odiststream&
79
91
geo_domain_indirect_base_rep<T,M>::put (odiststream& ops) const
80
92
{
81
 
  error_macro ("domain.put: not yet");
 
93
  error_macro ("domain.put_geo: not yet");
82
94
  return ops;
83
95
}
 
96
template <class T, class M>
 
97
const geo_size&
 
98
geo_domain_indirect_base_rep<T,M>::sizes() const
 
99
{
 
100
#ifdef TO_CLEAN
 
101
  error_macro ("domain.sizes: not yet");
 
102
#endif // TO_CLEAN
 
103
  return _omega.sizes();
 
104
}
 
105
template <class T, class M>
 
106
const geo_size&
 
107
geo_domain_indirect_base_rep<T,M>::ios_sizes() const 
 
108
{ 
 
109
  error_macro ("domain.ios_sizes: not yet");
 
110
  return _omega.ios_sizes();
 
111
}
 
112
template <class T, class M>
 
113
const typename geo_domain_indirect_base_rep<T,M>::node_type&
 
114
geo_domain_indirect_base_rep<T,M>::dis_node (size_type dis_inod) const
 
115
{
 
116
  return _omega.dis_node (dis_inod);
 
117
}
 
118
template <class T, class M>
 
119
void
 
120
geo_domain_indirect_base_rep<T,M>::dis_inod (const geo_element& K, std::vector<size_type>& dis_inod) const
 
121
{
 
122
  _omega.dis_inod (K, dis_inod);
 
123
}
 
124
template <class T, class M>
 
125
typename geo_domain_indirect_base_rep<T,M>::node_type
 
126
geo_domain_indirect_base_rep<T,M>::piola (const geo_element& K, const node_type& hat_x) const
 
127
{
 
128
  return _omega.piola (K, hat_x);
 
129
}
 
130
template <class T, class M>
 
131
typename geo_domain_indirect_base_rep<T,M>::size_type
 
132
geo_domain_indirect_base_rep<T,M>::dis_inod2dis_iv (size_type dis_inod) const
 
133
{
 
134
  error_macro ("domain.dis_inod2dis_iv: not yet");
 
135
  return 0;
 
136
}
 
137
template <class T, class M>
 
138
void
 
139
geo_domain_indirect_base_rep<T,M>::set_nodes (const array<node_type,M>&)
 
140
{
 
141
  error_macro ("domain.set_node: cannot do that");
 
142
}
 
143
template <class T, class M>
 
144
bool
 
145
geo_domain_indirect_base_rep<T,M>::check(bool verbose) const
 
146
{
 
147
  return true;
 
148
}
 
149
template <class T, class M>
 
150
void
 
151
geo_domain_indirect_base_rep<T,M>::reset_order (size_type order)
 
152
{
 
153
  error_macro ("domain.reset_order: cannot do that");
 
154
}
 
155
template <class T, class M>
 
156
typename geo_domain_indirect_base_rep<T,M>::size_type
 
157
geo_domain_indirect_base_rep<T,M>::seq_locate (const point_basic<T>&, size_type) const
 
158
{
 
159
  error_macro ("domain.seq_locate: no implemented");
 
160
  return std::numeric_limits<size_type>::max();
 
161
}
 
162
template <class T, class M>
 
163
typename geo_domain_indirect_base_rep<T,M>::size_type
 
164
geo_domain_indirect_base_rep<T,M>::dis_locate (const point_basic<T>&, size_type) const
 
165
{
 
166
  error_macro ("domain.dis_locate: no implemented");
 
167
  return std::numeric_limits<size_type>::max();
 
168
}
 
169
template <class T, class M>
 
170
typename geo_domain_indirect_base_rep<T,M>::size_type
 
171
geo_domain_indirect_base_rep<T,M>::seq_trace_move (
 
172
        const point_basic<T>&     x,
 
173
        const point_basic<T>&     v,
 
174
              point_basic<T>&     y) const
 
175
{
 
176
  error_macro ("domain.seq_trace_move: no implemented");
 
177
  return std::numeric_limits<size_type>::max();
 
178
}
 
179
template <class T, class M>
 
180
typename geo_domain_indirect_base_rep<T,M>::size_type
 
181
geo_domain_indirect_base_rep<T,M>::dis_trace_move (
 
182
        const point_basic<T>&     x,
 
183
        const point_basic<T>&     v,
 
184
              point_basic<T>&     y) const
 
185
{
 
186
  error_macro ("domain.dis_trace_move: no implemented");
 
187
  return std::numeric_limits<size_type>::max();
 
188
}
 
189
template <class T, class M>
 
190
void
 
191
geo_domain_indirect_base_rep<T,M>::locate (
 
192
  const array<point_basic<T>, M>& x,
 
193
        array<size_type, M>&      dis_ie,
 
194
  bool do_check) const
 
195
{
 
196
  error_macro ("domain.locate: no implemented");
 
197
}
 
198
template <class T, class M>
 
199
void
 
200
geo_domain_indirect_base_rep<T,M>::trace_ray_boundary (
 
201
                const array<point_basic<T>,M>&     x,
 
202
                const array<point_basic<T>,M>&     v,
 
203
                      array<size_type, M>&         dis_ie,
 
204
                      array<point_basic<T>,M>&     y,
 
205
                bool do_check) const
 
206
{
 
207
  error_macro ("domain.trace_ray_boundary: no implemented");
 
208
}
 
209
template <class T, class M>
 
210
void
 
211
geo_domain_indirect_base_rep<T,M>::trace_move (
 
212
                const array<point_basic<T>,M>&     x,
 
213
                const array<point_basic<T>,M>&     v,
 
214
                      array<size_type, M>&         dis_ie,
 
215
                      array<point_basic<T>,M>&     y) const
 
216
{
 
217
  error_macro ("domain.trace_move: no implemented");
 
218
}
84
219
// ----------------------------------------------------------------------------
85
220
// instanciation in library
86
221
// ----------------------------------------------------------------------------