Rheolef  7.2
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 {
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" + std::to_string(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
field::size_type size_type
Definition: branch.cc:430
check_macro(expr1.have_homogeneous_space(Xh1), "dual(expr1,expr2); expr1 should have homogeneous space. HINT: use dual(interpolate(Xh, expr1),expr2)")
verbose clean transpose logscale grid shrink ball stereo iso volume skipvtk deformation fastfieldload lattice reader_on_stdin color format format bamg
This file is part of Rheolef.