v0.13.2
Loading...
Searching...
No Matches
NaturalMeshsetType.hpp
Go to the documentation of this file.
1/**
2 * @file NaturalMeshsetType.hpp
3 * @brief Specialisation for NaturalMeshsetType
4 * @version 0.13.2
5 * @date 2022-09-18
6 *
7 * @copyright Copyright (c) 2022
8 *
9 */
10
11#ifndef _NATURAL_MESHSET_TYPE_HPP_
12#define _NATURAL_MESHSET_TYPE_HPP_
13
14namespace MoFEM {
15
16/**
17 * @brief Type generating natural b.c. specialisations for meshsets
18 *
19 * @tparam BCTYP
20 */
21template <CubitBC BCTYP> struct NaturalMeshsetType {};
22
23template <int FIELD_DIM, AssemblyType A, IntegrationType I, typename OpBase>
25 : OpFluxRhsImpl<NaturalMeshsetType<UNKNOWNSET>, 1, FIELD_DIM, A, I,
26 OpBase> {
27
28 OpFluxRhsImpl(MoFEM::Interface &m_field, int ms_id,
29 const std::string field_name,
30 std::vector<boost::shared_ptr<ScalingMethod>> smv);
31
32protected:
33 MoFEMErrorCode getMeshsetData(MoFEM::Interface &m_field, int ms_id);
34};
35
36template <int FIELD_DIM, AssemblyType A, IntegrationType I, typename OpBase>
38 : OpFluxRhsImpl<NaturalMeshsetType<UNKNOWNSET>, 1, FIELD_DIM, A, I,
39 OpBase> {
40
41 OpFluxRhsImpl(MoFEM::Interface &m_field, int ms_id,
42 const std::string field_name,
43 std::vector<boost::shared_ptr<ScalingMethod>> smv);
44
45protected:
46 MoFEMErrorCode getMeshsetData(MoFEM::Interface &m_field, int ms_id);
47};
48
49template <int FIELD_DIM, AssemblyType A, IntegrationType I, typename OpBase>
51 OpBase> : OpFluxRhsImpl<NaturalMeshsetType<UNKNOWNSET>, 1,
52 FIELD_DIM, A, I, OpBase> {
53
54 using Parent =
57
58 OpFluxRhsImpl(MoFEM::Interface &m_field, int ms_id,
59 const std::string field_name,
60 std::vector<boost::shared_ptr<ScalingMethod>> smv);
61
62protected:
63 MoFEMErrorCode iNtegrate(EntData &data);
64 MoFEMErrorCode getMeshsetData(MoFEM::Interface &m_field, int ms_id);
65
67};
68
69template <int FIELD_DIM, AssemblyType A, IntegrationType I, typename OpBase>
71 : FormsIntegrators<OpBase>::template Assembly<A>::template LinearForm<
72 I>::template OpSource<1, FIELD_DIM> {
73
76
77 OpFluxRhsImpl(const std::string field_name,
79 boost::shared_ptr<Range> ents_ptr,
80 std::vector<boost::shared_ptr<ScalingMethod>> smv);
81
82protected:
83 OpFluxRhsImpl(const std::string field_name,
84 std::vector<boost::shared_ptr<ScalingMethod>> smv);
87};
88
89template <AssemblyType A, IntegrationType I, typename OpBase>
91 : FormsIntegrators<OpBase>::template Assembly<A>::template LinearForm<
92 I>::template OpSource<1, 1> {
93
96
97 OpFluxRhsImpl(const std::string field_name, double value,
98 boost::shared_ptr<Range> ents_ptr,
99 std::vector<boost::shared_ptr<ScalingMethod>> smv);
100
101protected:
102 OpFluxRhsImpl(const std::string field_name,
103 std::vector<boost::shared_ptr<ScalingMethod>> smv);
104
107
109};
110
111template <AssemblyType A, IntegrationType I, typename OpBase>
113 : OpFluxRhsImpl<NaturalMeshsetType<UNKNOWNSET>, 1, 1, A, I, OpBase> {
114
115 using Parent =
117
118 OpFluxRhsImpl(MoFEM::Interface &m_field, int ms_id,
119 const std::string field_name,
120 std::vector<boost::shared_ptr<ScalingMethod>> smv);
121
122protected:
123 MoFEMErrorCode getMeshsetData(MoFEM::Interface &m_field, int ms_id);
124};
125
126template <AssemblyType A, IntegrationType I, typename OpBase>
128 : OpFluxRhsImpl<NaturalMeshsetType<UNKNOWNSET>, 1, 1, A, I, OpBase> {
129
130 using Parent =
132
133 OpFluxRhsImpl(MoFEM::Interface &m_field, int ms_id,
134 const std::string field_name,
135 std::vector<boost::shared_ptr<ScalingMethod>> smv);
136
137protected:
138 MoFEMErrorCode getMeshsetData(MoFEM::Interface &m_field, int ms_id);
139};
140
141template <int FIELD_DIM, AssemblyType A, IntegrationType I, typename OpBase>
143 : FormsIntegrators<OpBase>::template Assembly<A>::template LinearForm<
144 I>::template OpNormalMixVecTimesScalar<FIELD_DIM> {
145
147 A>::template LinearForm<I>::template OpNormalMixVecTimesScalar<FIELD_DIM>;
148
149 OpFluxRhsImpl(const std::string field_name, const double value,
150 boost::shared_ptr<Range> ents_ptr,
151 std::vector<boost::shared_ptr<ScalingMethod>> smv);
152
153protected:
154 OpFluxRhsImpl(const std::string field_name,
155 std::vector<boost::shared_ptr<ScalingMethod>> smv);
157
159};
160
161template <int FIELD_DIM, AssemblyType A, IntegrationType I, typename OpBase>
163 : OpFluxRhsImpl<NaturalMeshsetType<UNKNOWNSET>, 3, FIELD_DIM, A, I,
164 OpBase> {
165 OpFluxRhsImpl(MoFEM::Interface &m_field, int ms_id,
166 const std::string field_name,
167 std::vector<boost::shared_ptr<ScalingMethod>> smv);
168
169protected:
170 MoFEMErrorCode getMeshsetData(MoFEM::Interface &m_field, int ms_id);
171};
172
173template <int FIELD_DIM, AssemblyType A, IntegrationType I, typename OpBase>
175 OpBase> : OpFluxRhsImpl<NaturalMeshsetType<UNKNOWNSET>, 3,
176 FIELD_DIM, A, I, OpBase> {
177 OpFluxRhsImpl(MoFEM::Interface &m_field, int ms_id,
178 const std::string field_name,
179 std::vector<boost::shared_ptr<ScalingMethod>> smv);
180
181protected:
182 MoFEMErrorCode getMeshsetData(MoFEM::Interface &m_field, int ms_id);
183};
184
185// Definitions
186
187template <int FIELD_DIM, AssemblyType A, IntegrationType I, typename OpBase>
189 OpFluxRhsImpl(const std::string field_name,
191 boost::shared_ptr<Range> ents_ptr,
192 std::vector<boost::shared_ptr<ScalingMethod>> smv)
193 : OpFluxRhsImpl(field_name, smv) {
195 this->tForce(i) = t_force(i);
196 this->entsPtr = ents_ptr;
197}
198
199template <int FIELD_DIM, AssemblyType A, IntegrationType I, typename OpBase>
201 OpFluxRhsImpl(const std::string field_name,
202 std::vector<boost::shared_ptr<ScalingMethod>> smv)
203 : OpSource(
205
206 [this](const double, const double, const double) { return tForce; }
207
208 ),
209 vecOfTimeScalingMethods(smv) {
210 this->timeScalingFun = [this](const double t) {
211 double s = 1;
212 for (auto &o : vecOfTimeScalingMethods) {
213 s *= o->getScale(t);
214 }
215 return s;
216 };
217
218 static_assert(FIELD_DIM > 1, "Is not implemented for scalar field");
219}
220
221template <int FIELD_DIM, AssemblyType A, IntegrationType I, typename OpBase>
223 OpFluxRhsImpl(MoFEM::Interface &m_field, int ms_id,
224 const std::string field_name,
225 std::vector<boost::shared_ptr<ScalingMethod>> smv)
227 field_name, smv) {
228 CHK_THROW_MESSAGE(getMeshsetData(m_field, ms_id), "Get meshset data");
229}
230
231template <int FIELD_DIM, AssemblyType A, IntegrationType I, typename OpBase>
233 OpBase>::getMeshsetData(MoFEM::Interface &m_field,
234 int ms_id) {
236
237 auto cubit_meshset_ptr =
238 m_field.getInterface<MeshsetsManager>()->getCubitMeshsetPtr(ms_id,
239 NODESET);
240
241 ForceCubitBcData bc_data;
242 CHKERR cubit_meshset_ptr->getBcDataStructure(bc_data);
243
244 this->tForce(0) = bc_data.data.value3;
245 if constexpr (FIELD_DIM > 1)
246 this->tForce(1) = bc_data.data.value4;
247 if constexpr (FIELD_DIM > 2)
248 this->tForce(2) = bc_data.data.value5;
249
251 this->tForce(i) *= bc_data.data.value1;
252
253 this->entsPtr = boost::make_shared<Range>();
254 CHKERR m_field.get_moab().get_entities_by_handle(cubit_meshset_ptr->meshset,
255 *(this->entsPtr), true);
256
258}
259
260template <int FIELD_DIM, AssemblyType A, IntegrationType I, typename OpBase>
262 OpFluxRhsImpl(MoFEM::Interface &m_field, int ms_id,
263 const std::string field_name,
264 std::vector<boost::shared_ptr<ScalingMethod>> smv)
266 field_name, smv) {
267 CHK_THROW_MESSAGE(getMeshsetData(m_field, ms_id), "Get meshset data");
268}
269
270template <int FIELD_DIM, AssemblyType A, IntegrationType I, typename OpBase>
272 OpBase>::getMeshsetData(MoFEM::Interface &m_field,
273 int ms_id) {
275
276 auto cubit_meshset_ptr =
277 m_field.getInterface<MeshsetsManager>()->getCubitMeshsetPtr(ms_id,
278 BLOCKSET);
279
280 std::vector<double> block_data;
281 CHKERR cubit_meshset_ptr->getAttributes(block_data);
282 if (block_data.size() != FIELD_DIM) {
283 MOFEM_LOG("SELF", Sev::warning)
284 << "BLOCKSET is expected to have " << FIELD_DIM
285 << " attributes but has size " << block_data.size();
286 if (block_data.size() < FIELD_DIM) {
287 SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
288 "Size of attribute in BLOCKSET is too small");
289 }
290 }
291
292 MOFEM_LOG("WORLD", Sev::inform)
293 << "Flux blockset " << cubit_meshset_ptr->getName();
294 MOFEM_LOG("WORLD", Sev::inform)
295 << "Number of attributes " << block_data.size();
296
297 for (unsigned int ii = 0; ii != FIELD_DIM; ++ii) {
298 this->tForce(ii) = block_data[ii];
299 }
300
301 this->entsPtr = boost::make_shared<Range>();
302 CHKERR m_field.get_moab().get_entities_by_handle(cubit_meshset_ptr->meshset,
303 *(this->entsPtr), true);
304
306}
307
308template <int FIELD_DIM, AssemblyType A, IntegrationType I, typename OpBase>
310 OpFluxRhsImpl(MoFEM::Interface &m_field, int ms_id,
311 const std::string field_name,
312 std::vector<boost::shared_ptr<ScalingMethod>> smv)
314 field_name, smv) {
315 CHK_THROW_MESSAGE(getMeshsetData(m_field, ms_id), "Get meshset data");
316}
317
318template <int FIELD_DIM, AssemblyType A, IntegrationType I, typename OpBase>
320 I, OpBase>::iNtegrate(EntData &data) {
322
323 auto t_normal = this->getFTensor1Normal();
325
326 this->sourceFun = [&](const double, const double, const double) {
327 this->tForce(i) = t_normal(i);
328 this->tForce.normalize();
329 this->tForce(i) *= this->surfacePressure;
330 return this->tForce;
331 };
332
333 CHKERR Parent::iNtegrate(data);
335}
336
337template <int FIELD_DIM, AssemblyType A, IntegrationType I, typename OpBase>
340 OpBase>::getMeshsetData(MoFEM::Interface &m_field, int ms_id) {
342
343 auto cubit_meshset_ptr =
344 m_field.getInterface<MeshsetsManager>()->getCubitMeshsetPtr(ms_id,
345 SIDESET);
346
347 PressureCubitBcData pressure_data;
348 CHKERR cubit_meshset_ptr->getBcDataStructure(pressure_data);
349 this->surfacePressure = pressure_data.data.value1;
350
351 this->entsPtr = boost::make_shared<Range>();
352 CHKERR m_field.get_moab().get_entities_by_handle(cubit_meshset_ptr->meshset,
353 *(this->entsPtr), true);
354
356}
357
358template <AssemblyType A, IntegrationType I, typename OpBase>
360 OpFluxRhsImpl(const std::string field_name, const double value,
361 boost::shared_ptr<Range> ents_ptr,
362 std::vector<boost::shared_ptr<ScalingMethod>> smv)
363 : OpFluxRhsImpl(field_name, smv) {
364 this->scalarValue = value;
365 this->entsPtr = ents_ptr;
366}
367
368template <AssemblyType A, IntegrationType I, typename OpBase>
370 OpFluxRhsImpl(const std::string field_name,
371 std::vector<boost::shared_ptr<ScalingMethod>> smv)
373
374 [this](const double, const double, const double) {
375 return scalarValue;
376 }
377
378 ),
379 vecOfTimeScalingMethods(smv) {
380
381 this->timeScalingFun = [this](const double t) {
382 double s = 1;
383 for (auto &o : vecOfTimeScalingMethods) {
384 s *= o->getScale(t);
385 }
386 return s;
387 };
388}
389
390template <AssemblyType A, IntegrationType I, typename OpBase>
392 MoFEM::Interface &m_field, int ms_id, const std::string field_name,
393 std::vector<boost::shared_ptr<ScalingMethod>> smv)
395 field_name, smv) {
396 CHK_THROW_MESSAGE(getMeshsetData(m_field, ms_id), "Get meshset data");
397}
398
399template <AssemblyType A, IntegrationType I, typename OpBase>
402 MoFEM::Interface &m_field, int ms_id) {
404
405 auto cubit_meshset_ptr =
406 m_field.getInterface<MeshsetsManager>()->getCubitMeshsetPtr(ms_id,
407 BLOCKSET);
408 std::vector<double> block_data;
409 CHKERR cubit_meshset_ptr->getAttributes(block_data);
410 if (block_data.size() != 1) {
411 SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
412 "Expected that block has one attribute, e.g. heat flux value");
413 }
414 this->scalarValue = block_data[0];
415
416 this->entsPtr = boost::make_shared<Range>();
417 CHKERR m_field.get_moab().get_entities_by_handle(cubit_meshset_ptr->meshset,
418 *(this->entsPtr), true);
419
421}
422
423template <AssemblyType A, IntegrationType I, typename OpBase>
425 OpFluxRhsImpl(MoFEM::Interface &m_field, int ms_id,
426 const std::string field_name,
427 std::vector<boost::shared_ptr<ScalingMethod>> smv)
429 field_name, smv) {
430 CHK_THROW_MESSAGE(getMeshsetData(m_field, ms_id), "Get meshset data");
431}
432
433template <AssemblyType A, IntegrationType I, typename OpBase>
435 OpBase>::getMeshsetData(MoFEM::Interface &m_field,
436 int ms_id) {
438
439 auto cubit_meshset_ptr =
440 m_field.getInterface<MeshsetsManager>()->getCubitMeshsetPtr(ms_id,
441 SIDESET);
442 HeatFluxCubitBcData heat_flux;
443 CHKERR cubit_meshset_ptr->getBcDataStructure(heat_flux);
444 this->scalarValue = heat_flux.data.value1;
445
446 this->entsPtr = boost::make_shared<Range>();
447 CHKERR m_field.get_moab().get_entities_by_handle(cubit_meshset_ptr->meshset,
448 *(this->entsPtr), true);
449
451}
452
453template <int FIELD_DIM, AssemblyType A, IntegrationType I, typename OpBase>
455 OpFluxRhsImpl(const std::string field_name, const double value,
456 boost::shared_ptr<Range> ents_ptr,
457 std::vector<boost::shared_ptr<ScalingMethod>> smv)
458 : OpFluxRhsImpl(field_name, smv) {
459 this->scalarValue = value;
460 this->entsPtr = ents_ptr;
461}
462
463template <int FIELD_DIM, AssemblyType A, IntegrationType I, typename OpBase>
465 OpFluxRhsImpl(const std::string field_name,
466 std::vector<boost::shared_ptr<ScalingMethod>> smv)
468
469 [this](const double, const double, const double) {
470 return scalarValue;
471 }
472
473 ),
474 vecOfTimeScalingMethods(smv) {
475
476 this->timeScalingFun = [this](const double t) {
477 double s = 1;
478 for (auto &o : vecOfTimeScalingMethods) {
479 s *= o->getScale(t);
480 }
481 return s;
482 };
483}
484
485template <int FIELD_DIM, AssemblyType A, IntegrationType I, typename OpBase>
487 OpFluxRhsImpl(MoFEM::Interface &m_field, int ms_id,
488 const std::string field_name,
489 std::vector<boost::shared_ptr<ScalingMethod>> smv)
491 field_name, smv) {
492 CHK_THROW_MESSAGE(getMeshsetData(m_field, ms_id), "Get meshset data");
493}
494
495template <int FIELD_DIM, AssemblyType A, IntegrationType I, typename OpBase>
497 OpBase>::getMeshsetData(MoFEM::Interface &m_field,
498 int ms_id) {
500
501 auto cubit_meshset_ptr =
502 m_field.getInterface<MeshsetsManager>()->getCubitMeshsetPtr(ms_id,
503 BLOCKSET);
504 std::vector<double> attr_vec;
505 cubit_meshset_ptr->getAttributes(attr_vec);
506 if (attr_vec.size() != 1)
507 SETERRQ(PETSC_COMM_SELF, MOFEM_INVALID_DATA, "Should be one attribute");
508 this->scalarValue = attr_vec[0];
509
510 this->entsPtr = boost::make_shared<Range>();
511 CHKERR m_field.get_moab().get_entities_by_handle(cubit_meshset_ptr->meshset,
512 *(this->entsPtr), true);
513
515}
516
517template <int FIELD_DIM, AssemblyType A, IntegrationType I, typename OpBase>
519 OpFluxRhsImpl(MoFEM::Interface &m_field, int ms_id,
520 const std::string field_name,
521 std::vector<boost::shared_ptr<ScalingMethod>> smv)
523 field_name, smv) {
524 CHK_THROW_MESSAGE(getMeshsetData(m_field, ms_id), "Get meshset data");
525}
526
527template <int FIELD_DIM, AssemblyType A, IntegrationType I, typename OpBase>
530 OpBase>::getMeshsetData(MoFEM::Interface &m_field, int ms_id) {
532
533 auto cubit_meshset_ptr =
534 m_field.getInterface<MeshsetsManager>()->getCubitMeshsetPtr(ms_id,
535 NODESET);
536
538 CHKERR cubit_meshset_ptr->getBcDataStructure(mydata);
539 this->scalarValue = mydata.data.value1;
540
541 this->entsPtr = boost::make_shared<Range>();
542 CHKERR m_field.get_moab().get_entities_by_handle(cubit_meshset_ptr->meshset,
543 *(this->entsPtr), true);
544
546}
547
548template <CubitBC BCTYPE, int BASE_DIM, int FIELD_DIM, AssemblyType A,
549 IntegrationType I, typename OpBase>
551
553 OpBase>,
554 A, I, OpBase
555
556 > {
557
559
561
562 boost::ptr_deque<ForcesAndSourcesCore::UserDataOperator> &pipeline,
563 MoFEM::Interface &m_field, const std::string field_name,
564 std::vector<boost::shared_ptr<ScalingMethod>> smv, std::string block_name,
565 Sev sev
566
567 ) {
569
570 using OP = typename NaturalBC<OpBase>::template Assembly<
573
574 auto add_op = [&](auto &&meshset_vec_ptr) {
575 for (auto m : meshset_vec_ptr) {
576 MOFEM_TAG_AND_LOG("WORLD", sev, "OpFlux") << "Add " << *m;
577 pipeline.push_back(new OP(m_field, m->getMeshsetId(), field_name, smv));
578 }
579 MOFEM_LOG_CHANNEL("WORLD");
580 };
581
582 switch (BCTYPE) {
583 case TEMPERATURESET:
584 case FORCESET:
586 NODESET | BCTYPE));
587 case PRESSURESET:
588 case HEATFLUXSET:
590 SIDESET | BCTYPE));
591 break;
592 case BLOCKSET:
593 add_op(
594
596 std::regex(
597
598 (boost::format("%s(.*)") % block_name).str()
599
600 ))
601
602 );
603
604 break;
605 default:
606 SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_IMPLEMENTED,
607 "Handling of bc type not implemented");
608 break;
609 }
611 }
612};
613
614} // namespace MoFEM
615
616#endif //_NATURAL_MESHSET_TYPE_HPP_
static Index< 'o', 3 > o
#define MOFEM_TAG_AND_LOG(channel, severity, tag)
Tag and log in channel.
Definition: LogManager.hpp:359
constexpr int FIELD_DIM
#define CHK_THROW_MESSAGE(err, msg)
Check and throw MoFEM exception.
Definition: definitions.h:595
#define MoFEMFunctionBegin
First executable line of each MoFEM function, used for error handling. Final line of MoFEM functions ...
Definition: definitions.h:346
CubitBC
Types of sets and boundary conditions.
Definition: definitions.h:144
@ TEMPERATURESET
Definition: definitions.h:155
@ PRESSURESET
Definition: definitions.h:152
@ FORCESET
Definition: definitions.h:151
@ HEATFLUXSET
Definition: definitions.h:156
@ NODESET
Definition: definitions.h:146
@ SIDESET
Definition: definitions.h:147
@ UNKNOWNSET
Definition: definitions.h:145
@ BLOCKSET
Definition: definitions.h:148
@ MOFEM_DATA_INCONSISTENCY
Definition: definitions.h:31
@ MOFEM_INVALID_DATA
Definition: definitions.h:36
@ MOFEM_NOT_IMPLEMENTED
Definition: definitions.h:32
#define MoFEMFunctionReturn(a)
Last executable line of each PETSc function used for error handling. Replaces return()
Definition: definitions.h:416
#define CHKERR
Inline error check.
Definition: definitions.h:535
FTensor::Index< 'm', SPACE_DIM > m
IntegrationType
Form integrator integration types.
AssemblyType
[Storage and set boundary conditions]
#define MOFEM_LOG(channel, severity)
Log.
Definition: LogManager.hpp:308
SeverityLevel
Severity levels.
Definition: LogManager.hpp:33
#define MOFEM_LOG_CHANNEL(channel)
Set and reset channel.
Definition: LogManager.hpp:284
MoFEMErrorCode getCubitMeshsetPtr(const int ms_id, const CubitBCType cubit_bc_type, const CubitMeshSets **cubit_meshset_ptr) const
get cubit meshset
constexpr int BASE_DIM
FTensor::Index< 'i', SPACE_DIM > i
PetscErrorCode MoFEMErrorCode
MoFEM/PETSc error code.
Definition: Exceptions.hpp:56
implementation of Data Operators for Forces and Sources
Definition: Common.hpp:10
std::vector< boost::shared_ptr< ScalingMethod > > VecOfTimeScalingMethods
Vector of time scaling methods.
Definition: Natural.hpp:20
constexpr IntegrationType I
constexpr AssemblyType A
constexpr double t
plate stiffness
Definition: plate.cpp:59
constexpr auto field_name
static MoFEMErrorCode add(boost::ptr_deque< ForcesAndSourcesCore::UserDataOperator > &pipeline, MoFEM::Interface &m_field, const std::string field_name, std::vector< boost::shared_ptr< ScalingMethod > > smv, std::string block_name, Sev sev)
virtual moab::Interface & get_moab()=0
Deprecated interface functions.
Data on single entity (This is passed as argument to DataOperator::doWork)
Definition of the force bc data structure.
Definition: BCData.hpp:134
Definition of the heat flux bc data structure.
Definition: BCData.hpp:422
Interface for managing meshsets containing materials and boundary conditions.
Natural boundary conditions.
Definition: Natural.hpp:49
Type generating natural b.c. specialisations for meshsets.
typename FormsIntegrators< OpBase >::template Assembly< A >::template LinearForm< I >::template OpSource< 1, 1 > OpSource
MoFEMErrorCode getMeshsetData(MoFEM::Interface &m_field, int ms_id)
typename FormsIntegrators< OpBase >::template Assembly< A >::template LinearForm< I >::template OpSource< 1, FIELD_DIM > OpSource
typename FormsIntegrators< OpBase >::template Assembly< A >::template LinearForm< I >::template OpNormalMixVecTimesScalar< FIELD_DIM > OpSource
Definition of the pressure bc data structure.
Definition: BCData.hpp:374
Definition of the temperature bc data structure.
Definition: BCData.hpp:301
MoFEMErrorCode getInterface(IFACE *&iface) const
Get interface refernce to pointer of interface.