v0.14.0
EssentialDisplacementCubitBcData.hpp
Go to the documentation of this file.
1 /**
2  * @file EssentialDisplacementCubitBcData.hpp
3  * @brief Implementations specialisation for DisplacementCubitBcData
4  * @version 0.13.2
5  * @date 2022-09-18
6  *
7  * @copyright Copyright (c) 2022
8  *
9  */
10 
11 #ifndef _ESSENTIAL_DISPLACEMENTCUBITBCDATA_HPP__
12 #define _ESSENTIAL_DISPLACEMENTCUBITBCDATA_HPP__
13 
14 namespace MoFEM {
15 
16 /**
17  * @brief A specialized version of DisplacementCubitBcData that includes an
18  * additional rotation offset.
19  *
20  * DisplacementCubitBcDataWithRotation extends the DisplacementCubitBcData
21  * structure with a rotation offset and a method to calculate the rotated
22  * displacement given the rotation angles and coordinates.
23  */
25 
26  std::array<double, 3> rotOffset;
28 
29  /**
30  * @brief Calculates the rotated displacement given the rotation angles,
31  * coordinates, and an optional offset.
32  *
33  * @param angles A FTensor::Tensor1 containing the rotation angles.
34  * @param coordinates A FTensor::Tensor1 containing the coordinates.
35  * @param offset An optional FTensor::Tensor1 containing the offset
36  * (default is {0., 0., 0.}).
37  * @return FTensor::Tensor1<double, 3> representing the rotated displacement.
38  */
41  FTensor::Tensor1<double, 3> coordinates,
43  0., 0., 0.}) {
44 
48 
49  FTensor::Tensor1<double, 3> rotated_displacement;
50  rotated_displacement(i) = 0;
51 
52  auto get_rotation = [&](auto &omega) {
53  FTensor::Tensor2<double, 3, 3> rotation_matrix;
54 
56  rotation_matrix(i, j) = kronecker_delta(i, j);
57 
58  const double angle = sqrt(omega(i) * omega(i));
59  if (std::abs(angle) < std::numeric_limits<double>::epsilon())
60  return rotation_matrix;
61 
63  t_omega(i, j) = FTensor::levi_civita<double>(i, j, k) * omega(k);
64  const double a = sin(angle) / angle;
65  const double sin_squared = sin(angle / 2.) * sin(angle / 2.);
66  const double b = 2. * sin_squared / (angle * angle);
67  rotation_matrix(i, j) += a * t_omega(i, j);
68  rotation_matrix(i, j) += b * t_omega(i, k) * t_omega(k, j);
69 
70  return rotation_matrix;
71  };
72 
73  auto rotation = get_rotation(angles);
74  FTensor::Tensor1<double, 3> coordinate_distance;
75  coordinate_distance(i) = offset(i) - coordinates(i);
76  rotated_displacement(i) =
77  coordinate_distance(i) - rotation(j, i) * coordinate_distance(j);
78 
79  return rotated_displacement;
80  }
81 };
82 
83 /**
84  * @brief Specialization for DisplacementCubitBcData
85  *
86  * Specialization to enforce blocksets which DisplacementCubitBcData ptr. That
87  * is to enforce displacement constraints. set
88  *
89  * @tparam
90  */
93  boost::shared_ptr<FEMethod> fe_ptr,
94  std::vector<boost::shared_ptr<ScalingMethod>> smv,
95  bool get_coords = false);
96 
97  virtual ~EssentialPreProc() = default;
98 
99  MoFEMErrorCode operator()();
100 
101 protected:
103  boost::weak_ptr<FEMethod> fePtr;
105  bool getCoords;
106 };
107 
108 /**
109  * @brief Specialization for DisplacementCubitBcData
110  *
111  * @tparam
112  */
115  boost::shared_ptr<FEMethod> fe_ptr, double diag,
116  SmartPetscObj<Vec> rhs = nullptr);
117 
118  virtual ~EssentialPostProcRhs() = default;
119 
120  MoFEMErrorCode operator()();
121 
122 protected:
124  boost::weak_ptr<FEMethod> fePtr;
125  double vDiag;
127 };
128 
129 /**
130  * @brief Specialization for DisplacementCubitBcData
131  *
132  * @tparam
133  */
136  boost::shared_ptr<FEMethod> fe_ptr, double diag,
137  SmartPetscObj<Mat> lhs = nullptr,
138  SmartPetscObj<AO> ao = nullptr);
139 
140  virtual ~EssentialPostProcLhs() = default;
141 
142  MoFEMErrorCode operator()();
143 
144 protected:
146  boost::weak_ptr<FEMethod> fePtr;
147  double vDiag;
150 };
151 
152 /**
153  * @brief Specialization for DisplacementCubitBcData
154  *
155  * @tparam
156  */
159  boost::shared_ptr<FEMethod> fe_ptr,
160  SmartPetscObj<Vec> rhs = nullptr,
161  LogManager::SeverityLevel sev = Sev::inform);
162 
163  MoFEMErrorCode operator()();
164 
165 protected:
167  boost::weak_ptr<FEMethod> fePtr;
170  PetscBool printBlockName; //< print block name when printing reaction
171 };
172 
173 template <int FIELD_DIM, AssemblyType A, IntegrationType I, typename OpBase>
175  : FormsIntegrators<OpBase>::template Assembly<A>::template LinearForm<
176  I>::template OpSource<1, FIELD_DIM> {
177 
178  using OpSource = typename FormsIntegrators<OpBase>::template Assembly<
179  A>::template LinearForm<I>::template OpSource<1, FIELD_DIM>;
180 
181  OpEssentialRhsImpl(const std::string field_name,
182  boost::shared_ptr<DisplacementCubitBcData> bc_data,
183  boost::shared_ptr<Range> ents_ptr,
184  std::vector<boost::shared_ptr<ScalingMethod>> smv);
185 
186 private:
191 
193  double z) {
196  tAngles, FTensor::Tensor1<double, 3>{x, y, z}, tOffset);
198  t_ret(i) = tVal(i) + rot(i);
199  return t_ret;
200  };
201 
203  initDispFunction(boost::shared_ptr<DisplacementCubitBcData> bc_data) {
204  if (bc_data->data.flag4 || bc_data->data.flag5 || bc_data->data.flag6) {
205  return [this](double x, double y, double z) {
206  return this->rotFunction(x, y, z);
207  };
208  }
209  return [this](double x, double y, double z) { return tVal; };
210  }
211 };
212 
213 template <int FIELD_DIM, AssemblyType A, IntegrationType I, typename OpBase>
214 OpEssentialRhsImpl<DisplacementCubitBcData, 1, FIELD_DIM, A, I, OpBase>::
215  OpEssentialRhsImpl(const std::string field_name,
216  boost::shared_ptr<DisplacementCubitBcData> bc_data,
217  boost::shared_ptr<Range> ents_ptr,
218  std::vector<boost::shared_ptr<ScalingMethod>> smv)
219  : OpSource(field_name, initDispFunction(bc_data), ents_ptr),
220  vecOfTimeScalingMethods(smv) {
221  static_assert(FIELD_DIM > 1, "Is not implemented for scalar field");
222 
224  tVal(i) = 0;
225  tAngles(i) = 0;
226  tOffset(i) = 0;
227 
228  if (bc_data->data.flag1 == 1)
229  tVal(0) = -bc_data->data.value1;
230  if (bc_data->data.flag2 == 1 && FIELD_DIM > 1)
231  tVal(1) = -bc_data->data.value2;
232  if (bc_data->data.flag3 == 1 && FIELD_DIM > 2)
233  tVal(2) = -bc_data->data.value3;
234  if (bc_data->data.flag4 == 1 && FIELD_DIM > 2)
235  tAngles(0) = -bc_data->data.value4;
236  if (bc_data->data.flag5 == 1 && FIELD_DIM > 2)
237  tAngles(1) = -bc_data->data.value5;
238  if (bc_data->data.flag6 == 1 && FIELD_DIM > 1)
239  tAngles(2) = -bc_data->data.value6;
240 
241  if (auto ext_bc_data =
242  dynamic_cast<DisplacementCubitBcDataWithRotation const *>(
243  bc_data.get())) {
244  for (int a = 0; a != 3; ++a)
245  tOffset(a) = ext_bc_data->rotOffset[a];
246  }
247 
248  this->timeScalingFun = [this](const double t) {
249  double s = 1;
250  for (auto &o : vecOfTimeScalingMethods) {
251  s *= o->getScale(t);
252  }
253  return s;
254  };
255 }
256 
257 template <int BASE_DIM, int FIELD_DIM, AssemblyType A, IntegrationType I,
258  typename OpBase>
260  OpBase>
261  : FormsIntegrators<OpBase>::template Assembly<A>::template BiLinearForm<
262  I>::template OpMass<BASE_DIM, FIELD_DIM> {
263 
264  using OpMass = typename FormsIntegrators<OpBase>::template Assembly<
266 
267  OpEssentialLhsImpl(const std::string field_name,
268  boost::shared_ptr<Range> ents_ptr);
269 };
270 
271 template <int BASE_DIM, int FIELD_DIM, AssemblyType A, IntegrationType I,
272  typename OpBase>
275  boost::shared_ptr<Range>
276  ents_ptr)
277  : OpMass(
279 
280  [](double, double, double) constexpr { return 1; },
281 
282  ents_ptr) {}
283 
284 template <int BASE_DIM, int FIELD_DIM, AssemblyType A, IntegrationType I,
285  typename OpBase>
287 
289  OpBase>,
290  A, I, OpBase
291 
292  > {
293 
295 
297 
298  MoFEM::Interface &m_field,
299  boost::ptr_deque<ForcesAndSourcesCore::UserDataOperator> &pipeline,
300  const std::string problem_name, std::string field_name,
301  boost::shared_ptr<MatrixDouble> field_mat_ptr,
302  std::vector<boost::shared_ptr<ScalingMethod>> smv
303 
304  ) {
306 
307  using OP =
308  typename EssentialBC<OpBase>::template Assembly<A>::template LinearForm<
309  I>::template OpEssentialRhs<DisplacementCubitBcData, BASE_DIM,
310  FIELD_DIM>;
311  using OpInternal = typename FormsIntegrators<OpBase>::template Assembly<
312  A>::template LinearForm<I>::template OpBaseTimesVector<BASE_DIM,
313  FIELD_DIM, 1>;
314 
315  auto add_op = [&](auto &bcs) {
317  for (auto &m : bcs) {
318  if (auto bc = m.second->dispBcPtr) {
319  auto &bc_id = m.first;
320  auto regex_str =
321  (boost::format("%s_%s_(.*)") % problem_name % field_name).str();
322  if (std::regex_match(bc_id, std::regex(regex_str))) {
323  MOFEM_TAG_AND_LOG("SELF", Sev::noisy, "OpEssentialRhs") << *bc;
324  pipeline.push_back(
325  new OpSetBc(field_name, false, m.second->getBcMarkersPtr()));
326  pipeline.push_back(
327  new OP(field_name, bc, m.second->getBcEntsPtr(), smv));
328  pipeline.push_back(new OpInternal(
329  field_name, field_mat_ptr,
330  [](double, double, double) constexpr { return 1.; },
331  m.second->getBcEntsPtr()));
332  pipeline.push_back(new OpUnSetBc(field_name));
333  }
334  }
335  }
336  MOFEM_LOG_CHANNEL("SELF");
338  };
339 
340  CHKERR add_op(m_field.getInterface<BcManager>()->getBcMapByBlockName());
341 
343  }
344 };
345 
346 template <int BASE_DIM, int FIELD_DIM, AssemblyType A, IntegrationType I,
347  typename OpBase>
349 
351  OpBase>,
352  A, I, OpBase
353 
354  > {
355 
357 
359 
360  MoFEM::Interface &m_field,
361  boost::ptr_deque<ForcesAndSourcesCore::UserDataOperator> &pipeline,
362  const std::string problem_name, std::string field_name
363 
364  ) {
366 
367  using OP = typename EssentialBC<OpBase>::template Assembly<A>::
368  template BiLinearForm<I>::template OpEssentialLhs<
370 
371  auto add_op = [&](auto &bcs) {
373  for (auto &m : bcs) {
374  if (auto bc = m.second->dispBcPtr) {
375  auto &bc_id = m.first;
376  auto regex_str =
377  (boost::format("%s_%s_(.*)") % problem_name % field_name).str();
378  if (std::regex_match(bc_id, std::regex(regex_str))) {
379  MOFEM_TAG_AND_LOG("SELF", Sev::noisy, "OpEssentialLhs") << *bc;
380  pipeline.push_back(
381  new OpSetBc(field_name, false, m.second->getBcMarkersPtr()));
382  pipeline.push_back(new OP(field_name, m.second->getBcEntsPtr()));
383  pipeline.push_back(new OpUnSetBc(field_name));
384  }
385  }
386  }
387  MOFEM_LOG_CHANNEL("SELF");
389  };
390 
391  CHKERR add_op(m_field.getInterface<BcManager>()->getBcMapByBlockName());
392 
394  }
395 };
396 
397 } // namespace MoFEM
398 
399 #endif // _ESSENTIAL_DISPLACEMENTCUBITBCDATA_HPP__
MoFEMFunctionReturnHot
#define MoFEMFunctionReturnHot(a)
Last executable line of each PETSc function used for error handling. Replaces return()
Definition: definitions.h:447
MoFEM::UnknownInterface::getInterface
MoFEMErrorCode getInterface(IFACE *&iface) const
Get interface reference to pointer of interface.
Definition: UnknownInterface.hpp:93
omega
constexpr double omega
Save field DOFS on vertices/tags.
Definition: dynamic_first_order_con_law.cpp:93
MoFEM::DisplacementCubitBcDataWithRotation::DisplacementCubitBcDataWithRotation
DisplacementCubitBcDataWithRotation()
Definition: EssentialDisplacementCubitBcData.hpp:27
MoFEM::OpEssentialRhsImpl< DisplacementCubitBcData, 1, FIELD_DIM, A, I, OpBase >::rotFunction
FTensor::Tensor1< double, FIELD_DIM > rotFunction(double x, double y, double z)
Definition: EssentialDisplacementCubitBcData.hpp:192
FTensor::Tensor1< double, 3 >
MOFEM_LOG_CHANNEL
#define MOFEM_LOG_CHANNEL(channel)
Set and reset channel.
Definition: LogManager.hpp:284
MoFEM::OpEssentialRhsImpl< DisplacementCubitBcData, 1, FIELD_DIM, A, I, OpBase >::tVal
FTensor::Tensor1< double, FIELD_DIM > tVal
Definition: EssentialDisplacementCubitBcData.hpp:187
MoFEM::EssentialPreProc< DisplacementCubitBcData >::vecOfTimeScalingMethods
VecOfTimeScalingMethods vecOfTimeScalingMethods
Definition: EssentialDisplacementCubitBcData.hpp:104
MoFEM::OpEssentialRhsImpl< DisplacementCubitBcData, 1, FIELD_DIM, A, I, OpBase >::tAngles
FTensor::Tensor1< double, 3 > tAngles
Definition: EssentialDisplacementCubitBcData.hpp:188
MoFEM::OpEssentialRhsImpl< DisplacementCubitBcData, 1, FIELD_DIM, A, I, OpBase >::vecOfTimeScalingMethods
VecOfTimeScalingMethods vecOfTimeScalingMethods
Definition: EssentialDisplacementCubitBcData.hpp:190
MoFEM::DisplacementCubitBcDataWithRotation::rotOffset
std::array< double, 3 > rotOffset
Definition: EssentialDisplacementCubitBcData.hpp:26
MoFEM::EssentialBC
Essential boundary conditions.
Definition: Essential.hpp:111
MoFEM::Exceptions::MoFEMErrorCode
PetscErrorCode MoFEMErrorCode
MoFEM/PETSc error code.
Definition: Exceptions.hpp:56
MoFEM::EssentialPreProcReaction< DisplacementCubitBcData >::vRhs
SmartPetscObj< Vec > vRhs
Definition: EssentialDisplacementCubitBcData.hpp:168
FTensor::Kronecker_Delta
Kronecker Delta class.
Definition: Kronecker_Delta.hpp:15
A
constexpr AssemblyType A
Definition: operators_tests.cpp:30
MoFEM::DisplacementCubitBcData
Definition of the displacement bc data structure.
Definition: BCData.hpp:76
MoFEM::OpEssentialRhsImpl< DisplacementCubitBcData, 1, FIELD_DIM, A, I, OpBase >::OpSource
typename FormsIntegrators< OpBase >::template Assembly< A >::template LinearForm< I >::template OpSource< 1, FIELD_DIM > OpSource
Definition: EssentialDisplacementCubitBcData.hpp:179
MoFEM::EssentialPostProcLhs< DisplacementCubitBcData >::fePtr
boost::weak_ptr< FEMethod > fePtr
Definition: EssentialDisplacementCubitBcData.hpp:146
BASE_DIM
constexpr int BASE_DIM
Definition: dg_projection.cpp:15
MoFEM::EssentialPostProcLhs< DisplacementCubitBcData >::mField
MoFEM::Interface & mField
Definition: EssentialDisplacementCubitBcData.hpp:145
FTensor::Tensor2< double, 3, 3 >
MoFEM::DeprecatedCoreInterface
Deprecated interface functions.
Definition: DeprecatedCoreInterface.hpp:16
FIELD_DIM
constexpr int FIELD_DIM
Definition: child_and_parent.cpp:15
I
constexpr IntegrationType I
Definition: operators_tests.cpp:31
MoFEM::EssentialPostProcLhs< DisplacementCubitBcData >::vDiag
double vDiag
Definition: EssentialDisplacementCubitBcData.hpp:147
MoFEM::OpBaseImpl
Definition: FormsIntegrators.hpp:178
CHKERR
#define CHKERR
Inline error check.
Definition: definitions.h:535
MoFEM
implementation of Data Operators for Forces and Sources
Definition: Common.hpp:10
MoFEM::VectorFun
boost::function< FTensor::Tensor1< double, DIM >(const double, const double, const double)> VectorFun
Vector function type.
Definition: FormsIntegrators.hpp:176
a
constexpr double a
Definition: approx_sphere.cpp:30
MoFEM::BcManager
Simple interface for fast problem set-up.
Definition: BcManager.hpp:25
MoFEM::EssentialPreProcReaction< DisplacementCubitBcData >::fePtr
boost::weak_ptr< FEMethod > fePtr
Definition: EssentialDisplacementCubitBcData.hpp:167
MoFEM::EssentialPostProcLhs< DisplacementCubitBcData >::vLhs
SmartPetscObj< Mat > vLhs
Definition: EssentialDisplacementCubitBcData.hpp:148
MoFEM::EssentialPreProc< DisplacementCubitBcData >::mField
MoFEM::Interface & mField
Definition: EssentialDisplacementCubitBcData.hpp:102
double
MoFEM::OpEssentialLhsImpl
Enforce essential constrains on lhs.
Definition: Essential.hpp:81
MoFEM::BcManager::getBcMapByBlockName
BcMapByBlockName & getBcMapByBlockName()
Get the bc map.
Definition: BcManager.hpp:207
MoFEM::AddEssentialToRhsPipelineImpl
Function (factory) for setting operators for rhs pipeline.
Definition: Essential.hpp:92
MoFEM::EssentialPostProcLhs
Class (Function) to enforce essential constrains on the left hand side diagonal.
Definition: Essential.hpp:33
MoFEM::AddEssentialToLhsPipelineImpl< OpEssentialLhsImpl< DisplacementCubitBcData, BASE_DIM, FIELD_DIM, A, I, OpBase >, A, I, OpBase >::add
static MoFEMErrorCode add(MoFEM::Interface &m_field, boost::ptr_deque< ForcesAndSourcesCore::UserDataOperator > &pipeline, const std::string problem_name, std::string field_name)
Definition: EssentialDisplacementCubitBcData.hpp:358
MoFEM::AddEssentialToLhsPipelineImpl
Function (factory) for setting operators for lhs pipeline.
Definition: Essential.hpp:103
MoFEM::EssentialPreProcReaction< DisplacementCubitBcData >::mField
MoFEM::Interface & mField
Definition: EssentialDisplacementCubitBcData.hpp:166
MoFEM::EssentialPreProc< DisplacementCubitBcData >::getCoords
bool getCoords
Definition: EssentialDisplacementCubitBcData.hpp:105
MoFEM::EssentialPostProcRhs< DisplacementCubitBcData >::fePtr
boost::weak_ptr< FEMethod > fePtr
Definition: EssentialDisplacementCubitBcData.hpp:124
MoFEM::DisplacementCubitBcDataWithRotation::GetRotDisp
static FTensor::Tensor1< double, 3 > GetRotDisp(const FTensor::Tensor1< double, 3 > &angles, FTensor::Tensor1< double, 3 > coordinates, FTensor::Tensor1< double, 3 > offset=FTensor::Tensor1< double, 3 >{ 0., 0., 0.})
Calculates the rotated displacement given the rotation angles, coordinates, and an optional offset.
Definition: EssentialDisplacementCubitBcData.hpp:40
MoFEM::LogManager::SeverityLevel
SeverityLevel
Severity levels.
Definition: LogManager.hpp:33
MoFEM::EssentialPostProcRhs< DisplacementCubitBcData >::vRhs
SmartPetscObj< Vec > vRhs
Definition: EssentialDisplacementCubitBcData.hpp:126
t
constexpr double t
plate stiffness
Definition: plate.cpp:59
i
FTensor::Index< 'i', SPACE_DIM > i
Definition: hcurl_divergence_operator_2d.cpp:27
MoFEM::EssentialPreProcReaction
Class (Function) to calculate residual side diagonal.
Definition: Essential.hpp:49
BiLinearForm
MoFEM::AddEssentialToRhsPipelineImpl< OpEssentialRhsImpl< DisplacementCubitBcData, BASE_DIM, FIELD_DIM, A, I, OpBase >, A, I, OpBase >::add
static MoFEMErrorCode add(MoFEM::Interface &m_field, boost::ptr_deque< ForcesAndSourcesCore::UserDataOperator > &pipeline, const std::string problem_name, std::string field_name, boost::shared_ptr< MatrixDouble > field_mat_ptr, std::vector< boost::shared_ptr< ScalingMethod >> smv)
Definition: EssentialDisplacementCubitBcData.hpp:296
MoFEM::EssentialPostProcRhs
Class (Function) to enforce essential constrains on the right hand side diagonal.
Definition: Essential.hpp:41
field_name
constexpr auto field_name
Definition: poisson_2d_homogeneous.cpp:13
FTensor::Index< 'i', 3 >
MoFEM::IntegrationType
IntegrationType
Form integrator integration types.
Definition: FormsIntegrators.hpp:136
MoFEM::EssentialPostProcRhs< DisplacementCubitBcData >::vDiag
double vDiag
Definition: EssentialDisplacementCubitBcData.hpp:125
MoFEM::OpEssentialRhsImpl< DisplacementCubitBcData, 1, FIELD_DIM, A, I, OpBase >::initDispFunction
VectorFun< FIELD_DIM > initDispFunction(boost::shared_ptr< DisplacementCubitBcData > bc_data)
Definition: EssentialDisplacementCubitBcData.hpp:203
MoFEM::OpUnSetBc
Definition: FormsIntegrators.hpp:49
MoFEM::OpEssentialLhsImpl< DisplacementCubitBcData, BASE_DIM, FIELD_DIM, A, I, OpBase >::OpMass
typename FormsIntegrators< OpBase >::template Assembly< A >::template BiLinearForm< I >::template OpMass< BASE_DIM, FIELD_DIM > OpMass
Definition: EssentialDisplacementCubitBcData.hpp:265
MOFEM_TAG_AND_LOG
#define MOFEM_TAG_AND_LOG(channel, severity, tag)
Tag and log in channel.
Definition: LogManager.hpp:362
MoFEM::OpEssentialRhsImpl
Enforce essential constrains on rhs.
Definition: Essential.hpp:65
MoFEM::AssemblyType
AssemblyType
[Storage and set boundary conditions]
Definition: FormsIntegrators.hpp:104
FTensor::kronecker_delta
Tensor2_Expr< Kronecker_Delta< T >, T, Dim0, Dim1, i, j > kronecker_delta(const Index< i, Dim0 > &, const Index< j, Dim1 > &)
Rank 2.
Definition: Kronecker_Delta.hpp:81
j
FTensor::Index< 'j', 3 > j
Definition: matrix_function.cpp:19
MoFEM::EssentialPreProcReaction< DisplacementCubitBcData >::sevLevel
LogManager::SeverityLevel sevLevel
Definition: EssentialDisplacementCubitBcData.hpp:169
MoFEM::VecOfTimeScalingMethods
std::vector< boost::shared_ptr< ScalingMethod > > VecOfTimeScalingMethods
Vector of time scaling methods.
Definition: Natural.hpp:20
MoFEM::OpSetBc
Set indices on entities on finite element.
Definition: FormsIntegrators.hpp:38
MoFEM::EssentialPreProcReaction< DisplacementCubitBcData >::printBlockName
PetscBool printBlockName
Definition: EssentialDisplacementCubitBcData.hpp:170
MoFEM::FormsIntegrators
Integrator forms.
Definition: FormsIntegrators.hpp:299
MoFEM::OpEssentialRhsImpl< DisplacementCubitBcData, 1, FIELD_DIM, A, I, OpBase >::tOffset
FTensor::Tensor1< double, 3 > tOffset
Definition: EssentialDisplacementCubitBcData.hpp:189
m
FTensor::Index< 'm', 3 > m
Definition: shallow_wave.cpp:80
MoFEMFunctionBeginHot
#define MoFEMFunctionBeginHot
First executable line of each MoFEM function, used for error handling. Final line of MoFEM functions ...
Definition: definitions.h:440
MoFEM::DisplacementCubitBcDataWithRotation
A specialized version of DisplacementCubitBcData that includes an additional rotation offset.
Definition: EssentialDisplacementCubitBcData.hpp:24
MoFEM::EssentialPreProc
Class (Function) to enforce essential constrains.
Definition: Essential.hpp:25
MoFEM::SmartPetscObj< Vec >
k
FTensor::Index< 'k', 3 > k
Definition: matrix_function.cpp:20
OP
MoFEMFunctionReturn
#define MoFEMFunctionReturn(a)
Last executable line of each PETSc function used for error handling. Replaces return()
Definition: definitions.h:416
MoFEMFunctionBegin
#define MoFEMFunctionBegin
First executable line of each MoFEM function, used for error handling. Final line of MoFEM functions ...
Definition: definitions.h:346
MoFEM::EssentialPreProc< DisplacementCubitBcData >::fePtr
boost::weak_ptr< FEMethod > fePtr
Definition: EssentialDisplacementCubitBcData.hpp:103
MoFEM::EssentialPostProcRhs< DisplacementCubitBcData >::mField
MoFEM::Interface & mField
Definition: EssentialDisplacementCubitBcData.hpp:123
MoFEM::EssentialPostProcLhs< DisplacementCubitBcData >::vAO
SmartPetscObj< AO > vAO
Definition: EssentialDisplacementCubitBcData.hpp:149