v0.13.1
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
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
103 bzero(&data, sizeof(data));
104 }
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, 1, "data inconsistency");
111 memcpy(&data, &bc_data[0], sizeof(data));
113 }
114
115 MoFEMErrorCode set_data(void *tag_ptr, unsigned int size) const {
117 if (size != sizeof(data)) {
118 SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY, "data inconsistency");
119 }
120 memcpy(tag_ptr, &data, size);
122 }
123
124 /*! \brief Print displacement bc data
125 */
126 friend std::ostream &operator<<(std::ostream &os,
127 const DisplacementCubitBcData &e);
128};
129
130/*! \struct ForceCubitBcData
131 * \brief Definition of the force bc data structure
132 * \ingroup mofem_bc
133 */
135 struct __attribute__((packed)) _data_ {
136 char name[5]; //< 5 characters for "Force"
137 char zero[3]; //< 3 zeros
138 double value1; //< Force magnitude
139 double value2; //< Moment magnitude
140 double value3; //< X-component of force direction vector
141 double value4; //< Y-component of force direction vector
142 double value5; //< Z-component of force direction vector
143 double value6; //< X-component of moment direction vector
144 double value7; //< Y-component of moment direction vector
145 double value8; //< Z-component of moment direction vector
146 char zero2; // 0
147 };
148
149 _data_ data;
150 std::size_t getSizeOfData() const { return sizeof(_data_); }
151 const void *getDataPtr() const { return &data; }
152
154 bzero(&data, sizeof(data));
155 }
156
157 MoFEMErrorCode fill_data(const std::vector<char> &bc_data) {
159 // Fill data
160 if (bc_data.size() != sizeof(data))
161 SETERRQ(PETSC_COMM_SELF, 1, "data inconsistency");
162 memcpy(&data, &bc_data[0], sizeof(data));
164 }
165
166 MoFEMErrorCode set_data(void *tag_ptr, unsigned int size) const {
168 if (size != sizeof(data)) {
169 SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY, "data inconsistency");
170 }
171 memcpy(tag_ptr, &data, size);
173 }
174
175 /*! \brief Print force bc data
176 */
177 friend std::ostream &operator<<(std::ostream &os, const ForceCubitBcData &e);
178};
179
180/*! \struct VelocityCubitBcData
181 * \brief Definition of the velocity bc data structure
182 * \ingroup mofem_bc
183 */
185 struct __attribute__((packed)) _data_ {
186 char name[8]; //< 8 characters for "Velocity"
187 char pre1; //< Always zero
188 char pre2; //< pre-processing flags for modification of displacement bcs.
189 //They should not affect analysis, i.e. safe to ignore; 1:
190 //smallest combine, 2: average, 3: largest combine, 4: overwrite
191 //or no combination defined (default)
192 char flag1; //< Flag for X-Translation (0: N/A, 1: specified)
193 char flag2; //< Flag for Y-Translation (0: N/A, 1: specified)
194 char flag3; //< Flag for Z-Translation (0: N/A, 1: specified)
195 char flag4; //< Flag for X-Rotation (0: N/A, 1: specified)
196 char flag5; //< Flag for Y-Rotation (0: N/A, 1: specified)
197 char flag6; //< Flag for Z-Rotation (0: N/A, 1: specified)
198 double value1; //< Value for X-Translation
199 double value2; //< Value for Y-Translation
200 double value3; //< Value for Z-Translation
201 double value4; //< Value for X-Rotation
202 double value5; //< Value for Y-Rotation
203 double value6; //< Value for Z-Rotation
204 };
205
206 _data_ data;
207 std::size_t getSizeOfData() const { return sizeof(_data_); }
208 const void *getDataPtr() const { return &data; }
209
211 bzero(&data, sizeof(data));
212 }
213
214 MoFEMErrorCode fill_data(const std::vector<char> &bc_data) {
216 // Fill data
217 if (bc_data.size() != sizeof(data))
218 SETERRQ(PETSC_COMM_SELF, 1, "data inconsistency");
219 memcpy(&data, &bc_data[0], sizeof(data));
221 }
222
223 MoFEMErrorCode set_data(void *tag_ptr, unsigned int size) const {
225 if (size != sizeof(data)) {
226 SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY, "data inconsistency");
227 }
228 memcpy(tag_ptr, &data, size);
230 }
231
232 /*! \brief Print velocity bc data
233 */
234 friend std::ostream &operator<<(std::ostream &os,
235 const VelocityCubitBcData &e);
236};
237
238/*! \struct AccelerationCubitBcData
239 * \brief Definition of the acceleration bc data structure
240 * \ingroup mofem_bc
241 */
243 struct __attribute__((packed)) _data_ {
244 char name[12]; //< 12 characters for "Acceleration"
245 char pre1; //< Always zero
246 char pre2; //< pre-processing flags for modification of displacement bcs.
247 //They should not affect analysis, i.e. safe to ignore; 1:
248 //smallest combine, 2: average, 3: largest combine, 4: overwrite
249 //or no combination defined (default)
250 char flag1; //< Flag for X-Translation (0: N/A, 1: specified)
251 char flag2; //< Flag for Y-Translation (0: N/A, 1: specified)
252 char flag3; //< Flag for Z-Translation (0: N/A, 1: specified)
253 char flag4; //< Flag for X-Rotation (0: N/A, 1: specified)
254 char flag5; //< Flag for Y-Rotation (0: N/A, 1: specified)
255 char flag6; //< Flag for Z-Rotation (0: N/A, 1: specified)
256 double value1; //< Value for X-Translation
257 double value2; //< Value for Y-Translation
258 double value3; //< Value for Z-Translation
259 double value4; //< Value for X-Rotation
260 double value5; //< Value for Y-Rotation
261 double value6; //< Value for Z-Rotation
262 };
263
264 _data_ data;
265
266 std::size_t getSizeOfData() const { return sizeof(_data_); }
267 const void *getDataPtr() const { return &data; }
268
270 bzero(&data, sizeof(data));
271 }
272
273 MoFEMErrorCode fill_data(const std::vector<char> &bc_data) {
275 // Fill data
276 if (bc_data.size() != sizeof(data))
277 SETERRQ(PETSC_COMM_SELF, 1, "data inconsistency");
278 memcpy(&data, &bc_data[0], sizeof(data));
280 }
281
282 MoFEMErrorCode set_data(void *tag_ptr, unsigned int size) const {
284 if (size != sizeof(data)) {
285 SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY, "data inconsistency");
286 }
287 memcpy(tag_ptr, &data, size);
289 }
290
291 /*! \brief Print acceleration bc data
292 */
293 friend std::ostream &operator<<(std::ostream &os,
294 const AccelerationCubitBcData &e);
295};
296
297/*! \struct TemperatureCubitBcData
298 * \brief Definition of the temperature bc data structure
299 * \ingroup mofem_bc
300 */
302 struct __attribute__((packed)) _data_ {
303 char name[11]; //< 11 characters for "Temperature" (11)
304 char pre1; //< This is always zero (12)
305 char pre2; //< 0: temperature is not applied on thin shells (default); 1:
306 //temperature is applied on thin shells (13)
307 char flag1; //< 0: N/A, 1: temperature value applied (not on thin shells)
308 //(14)
309 char flag2; //< 0: N/A, 1: temperature applied on thin shell middle (15)
310 char flag3; //< 0: N/A, 1: thin shell temperature gradient specified (16)
311 char flag4; //< 0: N/A, 1: top thin shell temperature (17)
312 char flag5; //< 0: N/A, 1: bottom thin shell temperature (18)
313 char flag6; //< This is always zero (19)
314 double value1; //< Temperature (default case - no thin shells)
315 double value2; //< Temperature for middle of thin shells
316 double value3; //< Temperature gradient for thin shells
317 double value4; //< Temperature for top of thin shells
318 double value5; //< Temperature for bottom of thin shells
319 double value6; //< This is always zero, i.e. ignore
320 };
321
322 _data_ data;
323
324 std::size_t getSizeOfData() const { return sizeof(_data_); }
325 const void *getDataPtr() const { return &data; }
326
328 bzero(&data, sizeof(data));
329 }
330
331 MoFEMErrorCode fill_data(const std::vector<char> &bc_data) {
333 // Fill data
334 if (bc_data.size() > sizeof(data))
335 SETERRQ2(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
336 "Wrong number of parameters in Cubit %d != %d", bc_data.size(),
337 sizeof(data));
338
339 // Fix for newer version of Cubit
340 if (bc_data.size() == 58) {
341 std::vector<char> new_bc_data(66, 0);
342 size_t ii = 0;
343 for (; ii != 16; ++ii)
344 new_bc_data[ii] = bc_data[ii];
345 for (; ii != bc_data.size(); ++ii)
346 new_bc_data[ii + 1] = bc_data[ii];
347 memcpy(&data, &new_bc_data[0], new_bc_data.size());
348 } else {
349 memcpy(&data, &bc_data[0], bc_data.size());
350 }
351
353 }
354
355 MoFEMErrorCode set_data(void *tag_ptr, unsigned int size) const {
357 if (size != sizeof(data)) {
358 SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY, "data inconsistency");
359 }
360 memcpy(tag_ptr, &data, size);
362 }
363
364 /*! \brief Print temperature bc data
365 */
366 friend std::ostream &operator<<(std::ostream &os,
367 const TemperatureCubitBcData &e);
368};
369
370/*! \struct PressureCubitBcData
371 * \brief Definition of the pressure bc data structure
372 * \ingroup mofem_bc
373 */
375 struct __attribute__((packed)) _data_ {
376 char name[8]; //< 8 characters for "Pressure"
377 char flag1; //< This is always zero
378 char flag2; //< 0: Pressure is interpreted as pure pressure 1: pressure is
379 //interpreted as total force
380 double value1; //< Pressure value
381 char zero; //< This is always zero
382 };
383
384 _data_ data;
385
386 std::size_t getSizeOfData() const { return sizeof(_data_); }
387 const void *getDataPtr() const { return &data; }
388
390 bzero(&data, sizeof(data));
391 }
392
393 MoFEMErrorCode fill_data(const std::vector<char> &bc_data) {
395 // Fill data
396 if (bc_data.size() != sizeof(data)) {
397 SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY, "data inconsistency");
398 }
399 memcpy(&data, &bc_data[0], sizeof(data));
401 }
402
403 MoFEMErrorCode set_data(void *tag_ptr, unsigned int size) const {
405 if (size != sizeof(data)) {
406 SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY, "data inconsistency");
407 }
408 memcpy(tag_ptr, &data, size);
410 }
411
412 /*! \brief Print pressure bc data
413 */
414 friend std::ostream &operator<<(std::ostream &os,
415 const PressureCubitBcData &e);
416};
417
418/*! \struct HeatFluxCubitBcData
419 * \brief Definition of the heat flux bc data structure
420 * \ingroup mofem_bc
421 */
423
424 struct __attribute__((packed)) _data_ {
425 char name[8]; //< 8 characters for "HeatFlux" (no space)
426 char pre1; //< This is always zero
427 char pre2; //< 0: heat flux is not applied on thin shells (default); 1: heat
428 //flux is applied on thin shells
429 char flag1; //< 0: N/A, 1: normal heat flux case (i.e. single value, case
430 //without thin shells)
431 char flag2; //< 0: N/A, 1: Thin shell top heat flux specified
432 char flag3; //< 0: N/A, 1: Thin shell bottom heat flux specified
433 double value1; //< Heat flux value for default case (no thin shells)
434 double value2; //< Heat flux (thin shell top)
435 double value3; //< Heat flux (thin shell bottom)
436 };
437
438 _data_ data;
439
440 std::size_t getSizeOfData() const { return sizeof(_data_); }
441 const void *getDataPtr() const { return &data; }
442
444 bzero(&data, sizeof(data));
445 }
446
447 MoFEMErrorCode fill_data(const std::vector<char> &bc_data) {
449 // Fill data
450 if (bc_data.size() != sizeof(data))
451 SETERRQ(PETSC_COMM_SELF, 1, "data inconsistency");
452 memcpy(&data, &bc_data[0], sizeof(data));
454 }
455
456 MoFEMErrorCode set_data(void *tag_ptr, unsigned int size) const {
458 if (size != sizeof(data)) {
459 SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY, "data inconsistency");
460 }
461 memcpy(tag_ptr, &data, size);
463 }
464
465 /*! \brief Print heat flux bc data
466 */
467 friend std::ostream &operator<<(std::ostream &os,
468 const HeatFluxCubitBcData &e);
469};
470
471/*! \struct CfgCubitBcData
472 * \brief Definition of the cfd_bc data structure
473 * \ingroup mofem_bc
474 */
476 struct __attribute__((packed)) _data_ {
477 char name[6]; //< 6 characters for "cfd_bc"
478 char zero; //< This is always zero
479 char type; //< This is the type of cfd_bc
480 };
481
482 _data_ data;
483
484 std::size_t getSizeOfData() const { return sizeof(_data_); }
485 const void *getDataPtr() const { return &data; }
486
488 bzero(&data, sizeof(data));
489 }
490
491 MoFEMErrorCode fill_data(const std::vector<char> &bc_data) {
493 // Fill data
494 if (bc_data.size() != sizeof(data))
495 SETERRQ(PETSC_COMM_SELF, 1, "data inconsistency");
496 memcpy(&data, &bc_data[0], sizeof(data));
498 }
499
500 MoFEMErrorCode set_data(void *tag_ptr, unsigned int size) const {
502 if (size != sizeof(data)) {
503 SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY, "data inconsistency");
504 }
505 memcpy(tag_ptr, &data, size);
507 }
508
509 /*! \brief Print cfd_bc data
510 */
511 friend std::ostream &operator<<(std::ostream &os, const CfgCubitBcData &e);
512};
513
514} // namespace MoFEM
515
516#endif // __BCMULTIINDICES_HPP__
#define MoFEMFunctionReturnHot(a)
Last executable line of each PETSc function used for error handling. Replaces return()
Definition: definitions.h:447
@ TEMPERATURESET
Definition: definitions.h:155
@ PRESSURESET
Definition: definitions.h:152
@ ACCELERATIONSET
Definition: definitions.h:154
@ FORCESET
Definition: definitions.h:151
@ HEATFLUXSET
Definition: definitions.h:156
@ VELOCITYSET
Definition: definitions.h:153
@ DISPLACEMENTSET
Definition: definitions.h:150
@ INTERFACESET
Definition: definitions.h:157
@ 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 ...
Definition: definitions.h:440
PetscErrorCode MoFEMErrorCode
MoFEM/PETSc error code.
Definition: Exceptions.hpp:56
std::bitset< 32 > CubitBCType
Definition: Types.hpp:52
implementation of Data Operators for Forces and Sources
Definition: MoFEM.hpp:24
Definition of the acceleration bc data structure.
Definition: BCData.hpp:242
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:282
MoFEMErrorCode fill_data(const std::vector< char > &bc_data)
get data from structure
Definition: BCData.hpp:273
struct __attribute__((packed)) _data_
Definition: BCData.hpp:243
const void * getDataPtr() const
get pointer to data structure
Definition: BCData.hpp:267
std::size_t getSizeOfData() const
get data structure size
Definition: BCData.hpp:266
Definition of the cfd_bc data structure.
Definition: BCData.hpp:475
MoFEMErrorCode fill_data(const std::vector< char > &bc_data)
get data from structure
Definition: BCData.hpp:491
MoFEMErrorCode set_data(void *tag_ptr, unsigned int size) const
set data on structure
Definition: BCData.hpp:500
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:485
std::size_t getSizeOfData() const
get data structure size
Definition: BCData.hpp:484
struct __attribute__((packed)) _data_
Definition: BCData.hpp:476
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:115
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:134
MoFEMErrorCode fill_data(const std::vector< char > &bc_data)
get data from structure
Definition: BCData.hpp:157
std::size_t getSizeOfData() const
get data structure size
Definition: BCData.hpp:150
struct __attribute__((packed)) _data_
Definition: BCData.hpp:135
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:151
MoFEMErrorCode set_data(void *tag_ptr, unsigned int size) const
set data on structure
Definition: BCData.hpp:166
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:422
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:447
const void * getDataPtr() const
get pointer to data structure
Definition: BCData.hpp:441
MoFEMErrorCode set_data(void *tag_ptr, unsigned int size) const
set data on structure
Definition: BCData.hpp:456
struct __attribute__((packed)) _data_
Definition: BCData.hpp:424
std::size_t getSizeOfData() const
get data structure size
Definition: BCData.hpp:440
Definition of the pressure bc data structure.
Definition: BCData.hpp:374
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:387
struct __attribute__((packed)) _data_
Definition: BCData.hpp:375
MoFEMErrorCode set_data(void *tag_ptr, unsigned int size) const
set data on structure
Definition: BCData.hpp:403
MoFEMErrorCode fill_data(const std::vector< char > &bc_data)
get data from structure
Definition: BCData.hpp:393
std::size_t getSizeOfData() const
get data structure size
Definition: BCData.hpp:386
Definition of the temperature bc data structure.
Definition: BCData.hpp:301
MoFEMErrorCode fill_data(const std::vector< char > &bc_data)
get data from structure
Definition: BCData.hpp:331
MoFEMErrorCode set_data(void *tag_ptr, unsigned int size) const
set data on structure
Definition: BCData.hpp:355
std::size_t getSizeOfData() const
get data structure size
Definition: BCData.hpp:324
const void * getDataPtr() const
get pointer to data structure
Definition: BCData.hpp:325
struct __attribute__((packed)) _data_
Definition: BCData.hpp:302
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:184
MoFEMErrorCode set_data(void *tag_ptr, unsigned int size) const
set data on structure
Definition: BCData.hpp:223
std::size_t getSizeOfData() const
get data structure size
Definition: BCData.hpp:207
MoFEMErrorCode fill_data(const std::vector< char > &bc_data)
get data from structure
Definition: BCData.hpp:214
const void * getDataPtr() const
get pointer to data structure
Definition: BCData.hpp:208
struct __attribute__((packed)) _data_
Definition: BCData.hpp:185
friend std::ostream & operator<<(std::ostream &os, const VelocityCubitBcData &e)
Print velocity bc data.
Definition: BCData.cpp:67