v0.15.0
Loading...
Searching...
No Matches
BCData.hpp
Go to the documentation of this file.
1/** \file BCData.hpp
2 * \brief Data structure with Cubit native blocks/meshset with boundary
3 * conditions
4 *
5 */
6
7#ifndef __BCDATA_HPP__
8#define __BCDATA_HPP__
9
10namespace MoFEM {
11
12/*! \struct GenericCubitBcData
13 * \brief Generic bc data structure
14 * \ingroup mofem_bc
15 */
17
18 /**
19 * \brief get data from structure
20 * @param attributes vector of doubles
21 * @return error code
22 */
23 virtual MoFEMErrorCode fill_data(const std::vector<char> &bc_data) {
25 SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
26 "It makes no sense for the generic bc type");
28 }
29
30 /**
31 * \brief set data on structure
32 * @param tag_ptr pointer to tag on meshset
33 * @param size size of data in bytes
34 * @return error code
35 */
36 virtual MoFEMErrorCode set_data(void *tag_ptr, unsigned int size) const {
38 SETERRQ(PETSC_COMM_SELF, MOFEM_ATOM_TEST_INVALID,
39 "It makes no sense for the generic bc type");
41 }
42
43 /**
44 * \brief get data structure size
45 * @return size of structure in bytes
46 */
47 virtual std::size_t getSizeOfData() const = 0;
48
49 /**
50 * \brief get pointer to data structure
51 * @return pointer
52 */
53 virtual const void *getDataPtr() const = 0;
54
55 const CubitBCType tYpe; ///< Type of boundary condition
56
57 /**
58 * \brief get data type
59 * @return data type, see CubitBC
60 */
61 virtual const CubitBCType &getType() const { return tYpe; }
62
63 GenericCubitBcData(const CubitBCType type) : tYpe(type) {}
64
66};
67
68/*! \struct DisplacementCubitBcData
69 * \brief Definition of the displacement bc data structure
70 * \ingroup mofem_bc
71 */
73
74 /*! \brief attributes of DisplacementCubitBcData
75 */
76 struct __attribute__((packed)) _data_ {
77 char name[12]; //< 12 characters for "Displacement"
78 char pre1; //< Always zero
79 char pre2; //< pre-processing flags for modification of displacement bcs.
80 //They should not affect analysis, i.e. safe to ignore; 1:
81 //smallest combine, 2: average, 3: largest combine, 4: overwrite
82 //or no combination defined (default)
83 char flag1; //< Flag for X-Translation (0: N/A, 1: specified)
84 char flag2; //< Flag for Y-Translation (0: N/A, 1: specified)
85 char flag3; //< Flag for Z-Translation (0: N/A, 1: specified)
86 char flag4; //< Flag for X-Rotation (0: N/A, 1: specified)
87 char flag5; //< Flag for Y-Rotation (0: N/A, 1: specified)
88 char flag6; //< Flag for Z-Rotation (0: N/A, 1: specified)
89 double value1; //< Value for X-Translation
90 double value2; //< Value for Y-Translation
91 double value3; //< Value for Z-Translation
92 double value4; //< Value for X-Rotation
93 double value5; //< Value for Y-Rotation
94 double value6; //< Value for Z-Rotation
95 };
96
97 _data_ data;
98
99 std::size_t getSizeOfData() const { return sizeof(_data_); }
100 const void *getDataPtr() const { return &data; }
101
105
106 MoFEMErrorCode fill_data(const std::vector<char> &bc_data) {
108 // Fill data
109 if (bc_data.size() != sizeof(data))
110 SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
111 "data inconsistency %ld != %ld", bc_data.size(), sizeof(data));
112 memcpy(&data, &bc_data[0], sizeof(data));
114 }
115
116 MoFEMErrorCode set_data(void *tag_ptr, unsigned int size) const {
118 if (size != sizeof(data)) {
119 SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY, "data inconsistency");
120 }
121 memcpy(tag_ptr, &data, size);
123 }
124
125 /*! \brief Print displacement bc data
126 */
127 friend std::ostream &operator<<(std::ostream &os,
128 const DisplacementCubitBcData &e);
129};
130
131/*! \struct ForceCubitBcData
132 * \brief Definition of the force bc data structure
133 * \ingroup mofem_bc
134 */
136 struct __attribute__((packed)) _data_ {
137 char name[5]; //< 5 characters for "Force"
138 char zero[3]; //< 3 zeros
139 double value1; //< Force magnitude
140 double value2; //< Moment magnitude
141 double value3; //< X-component of force direction vector
142 double value4; //< Y-component of force direction vector
143 double value5; //< Z-component of force direction vector
144 double value6; //< X-component of moment direction vector
145 double value7; //< Y-component of moment direction vector
146 double value8; //< Z-component of moment direction vector
147 char zero2; // 0
148 };
149
150 _data_ data;
151 std::size_t getSizeOfData() const { return sizeof(_data_); }
152 const void *getDataPtr() const { return &data; }
153
155 bzero(&data, sizeof(data));
156 }
157
158 MoFEMErrorCode fill_data(const std::vector<char> &bc_data) {
160 // Fill data
161 if (bc_data.size() != sizeof(data))
162 SETERRQ(PETSC_COMM_SELF, 1, "data inconsistency");
163 memcpy(&data, &bc_data[0], sizeof(data));
165 }
166
167 MoFEMErrorCode set_data(void *tag_ptr, unsigned int size) const {
169 if (size != sizeof(data)) {
170 SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY, "data inconsistency");
171 }
172 memcpy(tag_ptr, &data, size);
174 }
175
176 /*! \brief Print force bc data
177 */
178 friend std::ostream &operator<<(std::ostream &os, const ForceCubitBcData &e);
179};
180
181/*! \struct VelocityCubitBcData
182 * \brief Definition of the velocity bc data structure
183 * \ingroup mofem_bc
184 */
186 struct __attribute__((packed)) _data_ {
187 char name[8]; //< 8 characters for "Velocity"
188 char pre1; //< Always zero
189 char pre2; //< pre-processing flags for modification of displacement bcs.
190 //They should not affect analysis, i.e. safe to ignore; 1:
191 //smallest combine, 2: average, 3: largest combine, 4: overwrite
192 //or no combination defined (default)
193 char flag1; //< Flag for X-Translation (0: N/A, 1: specified)
194 char flag2; //< Flag for Y-Translation (0: N/A, 1: specified)
195 char flag3; //< Flag for Z-Translation (0: N/A, 1: specified)
196 char flag4; //< Flag for X-Rotation (0: N/A, 1: specified)
197 char flag5; //< Flag for Y-Rotation (0: N/A, 1: specified)
198 char flag6; //< Flag for Z-Rotation (0: N/A, 1: specified)
199 double value1; //< Value for X-Translation
200 double value2; //< Value for Y-Translation
201 double value3; //< Value for Z-Translation
202 double value4; //< Value for X-Rotation
203 double value5; //< Value for Y-Rotation
204 double value6; //< Value for Z-Rotation
205 };
206
207 _data_ data;
208 std::size_t getSizeOfData() const { return sizeof(_data_); }
209 const void *getDataPtr() const { return &data; }
210
212 bzero(&data, sizeof(data));
213 }
214
215 MoFEMErrorCode fill_data(const std::vector<char> &bc_data) {
217 // Fill data
218 if (bc_data.size() != sizeof(data))
219 SETERRQ(PETSC_COMM_SELF, 1, "data inconsistency");
220 memcpy(&data, &bc_data[0], sizeof(data));
222 }
223
224 MoFEMErrorCode set_data(void *tag_ptr, unsigned int size) const {
226 if (size != sizeof(data)) {
227 SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY, "data inconsistency");
228 }
229 memcpy(tag_ptr, &data, size);
231 }
232
233 /*! \brief Print velocity bc data
234 */
235 friend std::ostream &operator<<(std::ostream &os,
236 const VelocityCubitBcData &e);
237};
238
239/*! \struct AccelerationCubitBcData
240 * \brief Definition of the acceleration bc data structure
241 * \ingroup mofem_bc
242 */
244 struct __attribute__((packed)) _data_ {
245 char name[12]; //< 12 characters for "Acceleration"
246 char pre1; //< Always zero
247 char pre2; //< pre-processing flags for modification of displacement bcs.
248 //They should not affect analysis, i.e. safe to ignore; 1:
249 //smallest combine, 2: average, 3: largest combine, 4: overwrite
250 //or no combination defined (default)
251 char flag1; //< Flag for X-Translation (0: N/A, 1: specified)
252 char flag2; //< Flag for Y-Translation (0: N/A, 1: specified)
253 char flag3; //< Flag for Z-Translation (0: N/A, 1: specified)
254 char flag4; //< Flag for X-Rotation (0: N/A, 1: specified)
255 char flag5; //< Flag for Y-Rotation (0: N/A, 1: specified)
256 char flag6; //< Flag for Z-Rotation (0: N/A, 1: specified)
257 double value1; //< Value for X-Translation
258 double value2; //< Value for Y-Translation
259 double value3; //< Value for Z-Translation
260 double value4; //< Value for X-Rotation
261 double value5; //< Value for Y-Rotation
262 double value6; //< Value for Z-Rotation
263 };
264
265 _data_ data;
266
267 std::size_t getSizeOfData() const { return sizeof(_data_); }
268 const void *getDataPtr() const { return &data; }
269
273
274 MoFEMErrorCode fill_data(const std::vector<char> &bc_data) {
276 // Fill data
277 if (bc_data.size() != sizeof(data))
278 SETERRQ(PETSC_COMM_SELF, 1, "data inconsistency");
279 memcpy(&data, &bc_data[0], sizeof(data));
281 }
282
283 MoFEMErrorCode set_data(void *tag_ptr, unsigned int size) const {
285 if (size != sizeof(data)) {
286 SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY, "data inconsistency");
287 }
288 memcpy(tag_ptr, &data, size);
290 }
291
292 /*! \brief Print acceleration bc data
293 */
294 friend std::ostream &operator<<(std::ostream &os,
295 const AccelerationCubitBcData &e);
296};
297
298/*! \struct TemperatureCubitBcData
299 * \brief Definition of the temperature bc data structure
300 * \ingroup mofem_bc
301 */
303 struct __attribute__((packed)) _data_ {
304 char name[11]; //< 11 characters for "Temperature" (11)
305 char pre1; //< This is always zero (12)
306 char pre2; //< 0: temperature is not applied on thin shells (default); 1:
307 //temperature is applied on thin shells (13)
308 char flag1; //< 0: N/A, 1: temperature value applied (not on thin shells)
309 //(14)
310 char flag2; //< 0: N/A, 1: temperature applied on thin shell middle (15)
311 char flag3; //< 0: N/A, 1: thin shell temperature gradient specified (16)
312 char flag4; //< 0: N/A, 1: top thin shell temperature (17)
313 char flag5; //< 0: N/A, 1: bottom thin shell temperature (18)
314 char flag6; //< This is always zero (19)
315 double value1; //< Temperature (default case - no thin shells)
316 double value2; //< Temperature for middle of thin shells
317 double value3; //< Temperature gradient for thin shells
318 double value4; //< Temperature for top of thin shells
319 double value5; //< Temperature for bottom of thin shells
320 double value6; //< This is always zero, i.e. ignore
321 };
322
323 _data_ data;
324
325 std::size_t getSizeOfData() const { return sizeof(_data_); }
326 const void *getDataPtr() const { return &data; }
327
331
332 MoFEMErrorCode fill_data(const std::vector<char> &bc_data) {
334 // Fill data
335 if (bc_data.size() > sizeof(data))
336 SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
337 "Wrong number of parameters in Cubit %ld != %ld", bc_data.size(),
338 sizeof(data));
339
340 // Fix for newer version of Cubit
341 if (bc_data.size() == 58) {
342 std::vector<char> new_bc_data(66, 0);
343 size_t ii = 0;
344 for (; ii != 16; ++ii)
345 new_bc_data[ii] = bc_data[ii];
346 for (; ii != bc_data.size(); ++ii)
347 new_bc_data[ii + 1] = bc_data[ii];
348 memcpy(&data, &new_bc_data[0], new_bc_data.size());
349 } else {
350 memcpy(&data, &bc_data[0], bc_data.size());
351 }
352
354 }
355
356 MoFEMErrorCode set_data(void *tag_ptr, unsigned int size) const {
358 if (size != sizeof(data)) {
359 SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY, "data inconsistency");
360 }
361 memcpy(tag_ptr, &data, size);
363 }
364
365 /*! \brief Print temperature bc data
366 */
367 friend std::ostream &operator<<(std::ostream &os,
368 const TemperatureCubitBcData &e);
369};
370
371/*! \struct PressureCubitBcData
372 * \brief Definition of the pressure bc data structure
373 * \ingroup mofem_bc
374 */
376 struct __attribute__((packed)) _data_ {
377 char name[8]; //< 8 characters for "Pressure"
378 char flag1; //< This is always zero
379 char flag2; //< 0: Pressure is interpreted as pure pressure 1: pressure is
380 //interpreted as total force
381 double value1; //< Pressure value
382 char zero; //< This is always zero
383 };
384
385 _data_ data;
386
387 std::size_t getSizeOfData() const { return sizeof(_data_); }
388 const void *getDataPtr() const { return &data; }
389
391 bzero(&data, sizeof(data));
392 }
393
394 MoFEMErrorCode fill_data(const std::vector<char> &bc_data) {
396 // Fill data
397 if (bc_data.size() != sizeof(data)) {
398 SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY, "data inconsistency");
399 }
400 memcpy(&data, &bc_data[0], sizeof(data));
402 }
403
404 MoFEMErrorCode set_data(void *tag_ptr, unsigned int size) const {
406 if (size != sizeof(data)) {
407 SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY, "data inconsistency");
408 }
409 memcpy(tag_ptr, &data, size);
411 }
412
413 /*! \brief Print pressure bc data
414 */
415 friend std::ostream &operator<<(std::ostream &os,
416 const PressureCubitBcData &e);
417};
418
419/*! \struct HeatFluxCubitBcData
420 * \brief Definition of the heat flux bc data structure
421 * \ingroup mofem_bc
422 */
424
425 struct __attribute__((packed)) _data_ {
426 char name[8]; //< 8 characters for "HeatFlux" (no space)
427 char pre1; //< This is always zero
428 char pre2; //< 0: heat flux is not applied on thin shells (default); 1: heat
429 //flux is applied on thin shells
430 char flag1; //< 0: N/A, 1: normal heat flux case (i.e. single value, case
431 //without thin shells)
432 char flag2; //< 0: N/A, 1: Thin shell top heat flux specified
433 char flag3; //< 0: N/A, 1: Thin shell bottom heat flux specified
434 double value1; //< Heat flux value for default case (no thin shells)
435 double value2; //< Heat flux (thin shell top)
436 double value3; //< Heat flux (thin shell bottom)
437 };
438
439 _data_ data;
440
441 std::size_t getSizeOfData() const { return sizeof(_data_); }
442 const void *getDataPtr() const { return &data; }
443
445 bzero(&data, sizeof(data));
446 }
447
448 MoFEMErrorCode fill_data(const std::vector<char> &bc_data) {
450 // Fill data
451 if (bc_data.size() != sizeof(data))
452 SETERRQ(PETSC_COMM_SELF, 1, "data inconsistency");
453 memcpy(&data, &bc_data[0], sizeof(data));
455 }
456
457 MoFEMErrorCode set_data(void *tag_ptr, unsigned int size) const {
459 if (size != sizeof(data)) {
460 SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY, "data inconsistency");
461 }
462 memcpy(tag_ptr, &data, size);
464 }
465
466 /*! \brief Print heat flux bc data
467 */
468 friend std::ostream &operator<<(std::ostream &os,
469 const HeatFluxCubitBcData &e);
470};
471
472/*! \struct CfgCubitBcData
473 * \brief Definition of the cfd_bc data structure
474 * \ingroup mofem_bc
475 */
477 struct __attribute__((packed)) _data_ {
478 char name[6]; //< 6 characters for "cfd_bc"
479 char zero; //< This is always zero
480 char type; //< This is the type of cfd_bc
481 };
482
483 _data_ data;
484
485 std::size_t getSizeOfData() const { return sizeof(_data_); }
486 const void *getDataPtr() const { return &data; }
487
489 bzero(&data, sizeof(data));
490 }
491
492 MoFEMErrorCode fill_data(const std::vector<char> &bc_data) {
494 // Fill data
495 if (bc_data.size() != sizeof(data))
496 SETERRQ(PETSC_COMM_SELF, 1, "data inconsistency");
497 memcpy(&data, &bc_data[0], sizeof(data));
499 }
500
501 MoFEMErrorCode set_data(void *tag_ptr, unsigned int size) const {
503 if (size != sizeof(data)) {
504 SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY, "data inconsistency");
505 }
506 memcpy(tag_ptr, &data, size);
508 }
509
510 /*! \brief Print cfd_bc data
511 */
512 friend std::ostream &operator<<(std::ostream &os, const CfgCubitBcData &e);
513};
514
515} // namespace MoFEM
516
517#endif // __BCMULTIINDICES_HPP__
#define MoFEMFunctionReturnHot(a)
Last executable line of each PETSc function used for error handling. Replaces return()
@ TEMPERATURESET
@ PRESSURESET
@ ACCELERATIONSET
@ FORCESET
@ HEATFLUXSET
@ VELOCITYSET
@ DISPLACEMENTSET
@ INTERFACESET
@ MOFEM_ATOM_TEST_INVALID
Definition definitions.h:40
@ MOFEM_DATA_INCONSISTENCY
Definition definitions.h:31
#define MoFEMFunctionBeginHot
First executable line of each MoFEM function, used for error handling. Final line of MoFEM functions ...
PetscErrorCode MoFEMErrorCode
MoFEM/PETSc error code.
std::bitset< 32 > CubitBCType
Definition Types.hpp:52
implementation of Data Operators for Forces and Sources
Definition Common.hpp:10
Definition of the acceleration bc data structure.
Definition BCData.hpp:243
friend std::ostream & operator<<(std::ostream &os, const AccelerationCubitBcData &e)
Print acceleration bc data.
Definition BCData.cpp:103
MoFEMErrorCode set_data(void *tag_ptr, unsigned int size) const
set data on structure
Definition BCData.hpp:283
MoFEMErrorCode fill_data(const std::vector< char > &bc_data)
get data from structure
Definition BCData.hpp:274
struct __attribute__((packed)) _data_
Definition BCData.hpp:244
const void * getDataPtr() const
get pointer to data structure
Definition BCData.hpp:268
std::size_t getSizeOfData() const
get data structure size
Definition BCData.hpp:267
Definition of the cfd_bc data structure.
Definition BCData.hpp:476
MoFEMErrorCode fill_data(const std::vector< char > &bc_data)
get data from structure
Definition BCData.hpp:492
MoFEMErrorCode set_data(void *tag_ptr, unsigned int size) const
set data on structure
Definition BCData.hpp:501
friend std::ostream & operator<<(std::ostream &os, const CfgCubitBcData &e)
Print cfd_bc data.
Definition BCData.cpp:199
const void * getDataPtr() const
get pointer to data structure
Definition BCData.hpp:486
std::size_t getSizeOfData() const
get data structure size
Definition BCData.hpp:485
struct __attribute__((packed)) _data_
Definition BCData.hpp:477
Definition of the displacement bc data structure.
Definition BCData.hpp:72
friend std::ostream & operator<<(std::ostream &os, const DisplacementCubitBcData &e)
Print displacement bc data.
Definition BCData.cpp:10
MoFEMErrorCode set_data(void *tag_ptr, unsigned int size) const
set data on structure
Definition BCData.hpp:116
const void * getDataPtr() const
get pointer to data structure
Definition BCData.hpp:100
struct __attribute__((packed)) _data_
attributes of DisplacementCubitBcData
Definition BCData.hpp:76
MoFEMErrorCode fill_data(const std::vector< char > &bc_data)
get data from structure
Definition BCData.hpp:106
std::size_t getSizeOfData() const
get data structure size
Definition BCData.hpp:99
Definition of the force bc data structure.
Definition BCData.hpp:135
MoFEMErrorCode fill_data(const std::vector< char > &bc_data)
get data from structure
Definition BCData.hpp:158
std::size_t getSizeOfData() const
get data structure size
Definition BCData.hpp:151
struct __attribute__((packed)) _data_
Definition BCData.hpp:136
friend std::ostream & operator<<(std::ostream &os, const ForceCubitBcData &e)
Print force bc data.
Definition BCData.cpp:53
const void * getDataPtr() const
get pointer to data structure
Definition BCData.hpp:152
MoFEMErrorCode set_data(void *tag_ptr, unsigned int size) const
set data on structure
Definition BCData.hpp:167
Generic bc data structure.
Definition BCData.hpp:16
virtual const void * getDataPtr() const =0
get pointer to data structure
const CubitBCType tYpe
Type of boundary condition.
Definition BCData.hpp:55
virtual ~GenericCubitBcData()
Definition BCData.hpp:65
virtual MoFEMErrorCode set_data(void *tag_ptr, unsigned int size) const
set data on structure
Definition BCData.hpp:36
virtual const CubitBCType & getType() const
get data type
Definition BCData.hpp:61
virtual std::size_t getSizeOfData() const =0
get data structure size
virtual MoFEMErrorCode fill_data(const std::vector< char > &bc_data)
get data from structure
Definition BCData.hpp:23
GenericCubitBcData(const CubitBCType type)
Definition BCData.hpp:63
Definition of the heat flux bc data structure.
Definition BCData.hpp:423
friend std::ostream & operator<<(std::ostream &os, const HeatFluxCubitBcData &e)
Print heat flux bc data.
Definition BCData.cpp:178
MoFEMErrorCode fill_data(const std::vector< char > &bc_data)
get data from structure
Definition BCData.hpp:448
const void * getDataPtr() const
get pointer to data structure
Definition BCData.hpp:442
MoFEMErrorCode set_data(void *tag_ptr, unsigned int size) const
set data on structure
Definition BCData.hpp:457
struct __attribute__((packed)) _data_
Definition BCData.hpp:425
std::size_t getSizeOfData() const
get data structure size
Definition BCData.hpp:441
Definition of the pressure bc data structure.
Definition BCData.hpp:375
friend std::ostream & operator<<(std::ostream &os, const PressureCubitBcData &e)
Print pressure bc data.
Definition BCData.cpp:170
const void * getDataPtr() const
get pointer to data structure
Definition BCData.hpp:388
struct __attribute__((packed)) _data_
Definition BCData.hpp:376
MoFEMErrorCode set_data(void *tag_ptr, unsigned int size) const
set data on structure
Definition BCData.hpp:404
MoFEMErrorCode fill_data(const std::vector< char > &bc_data)
get data from structure
Definition BCData.hpp:394
std::size_t getSizeOfData() const
get data structure size
Definition BCData.hpp:387
Definition of the temperature bc data structure.
Definition BCData.hpp:302
MoFEMErrorCode fill_data(const std::vector< char > &bc_data)
get data from structure
Definition BCData.hpp:332
MoFEMErrorCode set_data(void *tag_ptr, unsigned int size) const
set data on structure
Definition BCData.hpp:356
std::size_t getSizeOfData() const
get data structure size
Definition BCData.hpp:325
const void * getDataPtr() const
get pointer to data structure
Definition BCData.hpp:326
struct __attribute__((packed)) _data_
Definition BCData.hpp:303
friend std::ostream & operator<<(std::ostream &os, const TemperatureCubitBcData &e)
Print temperature bc data.
Definition BCData.cpp:139
Definition of the velocity bc data structure.
Definition BCData.hpp:185
MoFEMErrorCode set_data(void *tag_ptr, unsigned int size) const
set data on structure
Definition BCData.hpp:224
std::size_t getSizeOfData() const
get data structure size
Definition BCData.hpp:208
MoFEMErrorCode fill_data(const std::vector< char > &bc_data)
get data from structure
Definition BCData.hpp:215
const void * getDataPtr() const
get pointer to data structure
Definition BCData.hpp:209
struct __attribute__((packed)) _data_
Definition BCData.hpp:186
friend std::ostream & operator<<(std::ostream &os, const VelocityCubitBcData &e)
Print velocity bc data.
Definition BCData.cpp:67