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