Rheolef
7.1
an efficient C++ finite element environment
geo_seq_put_bamg.cc
Go to the documentation of this file.
1
//
22
// bamg output
23
//
24
// author: Pierre.Saramito@imag.fr
25
//
26
// date: 26 mars 2012
27
//
28
#include "rheolef/geo.h"
29
#include "rheolef/space_numbering.h"
30
#include "rheolef/piola_util.h"
31
#include "rheolef/rheostream.h"
32
#include "rheolef/iorheo.h"
33
using namespace
std;
34
namespace
rheolef
{
35
36
// ----------------------------------------------------------------------------
37
// one element puts
38
// ----------------------------------------------------------------------------
39
template
<
class
T>
40
static
41
void
42
put_edge (ostream&
bamg
,
const
geo_element& K,
const
basis_basic<T>& my_numb,
const
geo_basic<T,sequential>& omega)
43
{
44
typedef
typename
geo_basic<T,sequential>::size_type
size_type
;
45
static
size_type
order2bamg_type [11] = {0, 1, 8, 26, 27, 28, 62, 63, 64, 65, 66 };
46
size_type
my_order = my_numb.degree();
47
check_macro
(my_order <= 10, "bamg output: element 'e' order > 10 not yet supported
");
48
std::vector<size_type> inod;
49
space_numbering::dis_idof (my_numb, omega.sizes(), K, inod);
50
bamg << K.dis_ie()+1 << "
" << order2bamg_type [my_order] << "
2 99 2
"; // TODO: domains
51
for (size_type iloc = 0, nloc = inod.size(); iloc < nloc; iloc++) {
52
bamg << "
" << inod[iloc]+1;
53
}
54
bamg << endl;
55
}
56
template <class T>
57
static
58
void
59
put_triangle (ostream& bamg, const geo_element& K, const basis_basic<T>& my_numb, const geo_basic<T,sequential>& omega)
60
{
61
typedef typename geo_basic<T,sequential>::size_type size_type;
62
static size_type order2bamg_type [11] = {0, 2, 9, 21, 23, 25, 42, 43, 44, 45, 46};
63
size_type my_order = my_numb.degree();
64
// TODO: permutations of internal nodes for order >= 4
65
check_macro (my_order <= 3, "
bamg
output: element
't'
order
> 10 not yet supported
");
66
std::vector<size_type> inod;
67
space_numbering::dis_idof (my_numb, omega.sizes(), K, inod);
68
bamg << K.dis_ie()+1 << "
" << order2bamg_type [my_order] << "
2 99 2
"; // TODO: domains
69
for (size_type iloc = 0, nloc = inod.size(); iloc < nloc; iloc++) {
70
bamg << "
" << inod[iloc]+1;
71
}
72
bamg << endl;
73
}
74
#ifdef TODO
75
template <class T>
76
static
77
void
78
put_quadrangle (ostream& bamg, const geo_element& K, const basis_basic<T>& my_numb, const geo_basic<T,sequential>& omega)
79
{
80
typedef typename geo_basic<T,sequential>::size_type size_type;
81
typedef point_basic<size_type> ilat;
82
std::vector<size_type> inod;
83
space_numbering::dis_idof (my_numb, omega.sizes(), K, inod);
84
size_type my_order = my_numb.degree();
85
for (size_type i = 0; i < my_order; i++) {
86
for (size_type j = 0; j < my_order; j++) {
87
size_type loc_inod00 = reference_element_q::ilat2loc_inod (my_order, ilat(i, j));
88
size_type loc_inod10 = reference_element_q::ilat2loc_inod (my_order, ilat(i+1, j));
89
size_type loc_inod11 = reference_element_q::ilat2loc_inod (my_order, ilat(i+1, j+1));
90
size_type loc_inod01 = reference_element_q::ilat2loc_inod (my_order, ilat(i, j+1));
91
bamg << "
4\t
" << inod[loc_inod00] << "
"
92
<< inod[loc_inod10] << "
"
93
<< inod[loc_inod11] << "
"
94
<< inod[loc_inod01] << endl;
95
}
96
}
97
}
98
template <class T>
99
static
100
void
101
put_hexahedron (ostream& bamg, const geo_element& K, const basis_basic<T>& my_numb, const geo_basic<T,sequential>& omega)
102
{
103
typedef typename geo_basic<T,sequential>::size_type size_type;
104
typedef point_basic<size_type> ilat;
105
std::vector<size_type> inod;
106
space_numbering::dis_idof (my_numb, omega.sizes(), K, inod);
107
size_type my_order = my_numb.degree();
108
for (size_type i = 0; i < my_order; i++) {
109
for (size_type j = 0; j < my_order; j++) {
110
for (size_type k = 0; k < my_order; k++) {
111
size_type loc_inod000 = reference_element_H::ilat2loc_inod (my_order, ilat(i, j, k));
112
size_type loc_inod100 = reference_element_H::ilat2loc_inod (my_order, ilat(i+1, j, k));
113
size_type loc_inod110 = reference_element_H::ilat2loc_inod (my_order, ilat(i+1, j+1, k));
114
size_type loc_inod010 = reference_element_H::ilat2loc_inod (my_order, ilat(i, j+1, k));
115
size_type loc_inod001 = reference_element_H::ilat2loc_inod (my_order, ilat(i, j, k+1));
116
size_type loc_inod101 = reference_element_H::ilat2loc_inod (my_order, ilat(i+1, j, k+1));
117
size_type loc_inod011 = reference_element_H::ilat2loc_inod (my_order, ilat(i, j+1, k+1));
118
size_type loc_inod111 = reference_element_H::ilat2loc_inod (my_order, ilat(i+1, j+1, k+1));
119
bamg << "
8\t
" << inod[loc_inod000] << "
"
120
<< inod[loc_inod100] << "
"
121
<< inod[loc_inod110] << "
"
122
<< inod[loc_inod010] << "
"
123
<< inod[loc_inod001] << "
"
124
<< inod[loc_inod101] << "
"
125
<< inod[loc_inod111] << "
"
126
<< inod[loc_inod011] << endl;
127
}
128
}
129
}
130
}
131
#endif // TODO
132
template <class T>
133
static
134
void
135
put (ostream& bamg, const geo_element& K, const basis_basic<T>& my_numb, const geo_basic<T,sequential>& omega, const disarray<point_basic<Float>,sequential>& my_node)
136
{
137
switch (K.variant()) {
138
#ifdef TODO
139
case reference_element::p: bamg << "
1\t
" << K[0] << endl; break;
140
#endif // TODO
141
case reference_element::e: put_edge (bamg, K, my_numb, omega); break;
142
case reference_element::t: put_triangle (bamg, K, my_numb, omega); break;
143
#ifdef TODO
144
case reference_element::q: put_quadrangle (bamg, K, my_numb, omega); break;
145
case reference_element::T: put_tetrahedron (bamg, K, my_numb, omega); break;
146
case reference_element::P: put_prism (bamg, K, my_numb, omega, my_node); break;
147
case reference_element::H: put_hexahedron (bamg, K, my_numb, omega); break;
148
#endif // TODO
149
default: error_macro ("
unsupported element
variant
`
" << K.name() <<"
'");
150
}
151
}
152
// ----------------------------------------------------------------------------
153
// geo puts
154
// ----------------------------------------------------------------------------
155
156
template <class T>
157
odiststream&
158
geo_put_bamg (odiststream& ops, const geo_basic<T,sequential>& omega, const basis_basic<T>& my_numb, const disarray<point_basic<T>,sequential>& my_node)
159
{
160
//
161
// 0) pre-requises
162
//
163
typedef typename geo_basic<T,sequential>::size_type size_type;
164
size_type my_order = my_numb.degree();
165
ostream& bamg = ops.os();
166
check_macro (omega.dimension() == 2, "geo: unexpected "<<omega.dimension()<<"d mesh for bamg output");
167
//
168
// 1) put header
169
//
170
bamg << setprecision (std::numeric_limits<T>::digits10)
171
<< "MeshVersionFormated" << endl
172
<< "0" << endl << endl
173
<< "Identifier" << endl
174
<< "\"G=" << omega.familyname() << ".bamgcad;1, Date: 01/02/28 19:43 29s\"" << endl << endl
175
<< "Geometry" << endl
176
<< "\"" << omega.familyname() << ".bamgcad\"" << endl << endl;
177
// TODO: add domains: scan by domain and add for earch element to a domain list
178
//
179
// 2) put nodes
180
//
181
bamg << "Vertices" << endl
182
<< my_node.size() << endl;
183
for (size_type inod = 0, nnod = my_node.size(); inod < nnod; inod++) {
184
bamg << my_node[inod][0] << " " << my_node[inod][1] << " 1" << endl;
185
}
186
//
187
// 3) put elements
188
//
189
// TODO: see nfem/lib/geo-bamg.cc
190
error_macro ("geo::put_bamg: not yet");
191
return ops;
192
}
193
template <class T>
194
odiststream&
195
geo_put_bamg (odiststream& ops, const geo_basic<T,sequential>& omega)
196
{
197
basis_basic<T> my_numb ("P" + itos(omega.order()));
198
return geo_put_bamg (ops, omega, my_numb, omega.get_nodes());
199
}
200
// ----------------------------------------------------------------------------
201
// instanciation in library
202
// ----------------------------------------------------------------------------
203
template odiststream& geo_put_bamg<Float> (odiststream&, const geo_basic<Float,sequential>&, const basis_basic<Float>&, const disarray<point_basic<Float>,sequential>&);
204
template odiststream& geo_put_bamg<Float> (odiststream&, const geo_basic<Float,sequential>&);
205
206
}// namespace rheolef
check_macro
check_macro(expr1.have_homogeneous_space(Xh1), "dual(expr1,expr2); expr1 should have homogeneous space. HINT: use dual(interpolate(Xh, expr1),expr2)")
mkgeo_ball.order
order
Definition:
mkgeo_ball.sh:343
mkgeo_ball.variant
int variant
Definition:
mkgeo_ball.sh:149
bamg
verbose clean transpose logscale grid shrink ball stereo iso volume skipvtk deformation fastfieldload lattice reader_on_stdin color format format bamg
Definition:
iorheo-members.h:71
rheolef
This file is part of Rheolef.
Definition:
compiler_eigen.h:37
size_type
field::size_type size_type
Definition:
branch.cc:425