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  MoFEM::Interface &m_field, boost::shared_ptr<FEMethod> fe_ptr,
160  SmartPetscObj<Vec> rhs = nullptr,
161  LogManager::SeverityLevel sev = Sev::inform,
162  boost::shared_ptr<std::vector<double>> reaction_ptr = nullptr);
163 
164  MoFEMErrorCode operator()();
165 
166 protected:
168  boost::weak_ptr<FEMethod> fePtr;
171  PetscBool printBlockName; //< print block name when printing reaction
172  boost::shared_ptr<std::vector<double>> reactionPtr;
173  char reactionBlockName[255];
174 };
175 
176 template <int FIELD_DIM, AssemblyType A, IntegrationType I, typename OpBase>
178  : FormsIntegrators<OpBase>::template Assembly<A>::template LinearForm<
179  I>::template OpSource<1, FIELD_DIM> {
180 
181  using OpSource = typename FormsIntegrators<OpBase>::template Assembly<
182  A>::template LinearForm<I>::template OpSource<1, FIELD_DIM>;
183 
184  OpEssentialRhsImpl(const std::string field_name,
185  boost::shared_ptr<DisplacementCubitBcData> bc_data,
186  boost::shared_ptr<Range> ents_ptr,
187  std::vector<boost::shared_ptr<ScalingMethod>> smv);
188 
189 private:
194 
196  double z) {
199  tAngles, FTensor::Tensor1<double, 3>{x, y, z}, tOffset);
201  t_ret(i) = tVal(i) + rot(i);
202  return t_ret;
203  };
204 
206  initDispFunction(boost::shared_ptr<DisplacementCubitBcData> bc_data) {
207  if (bc_data->data.flag4 || bc_data->data.flag5 || bc_data->data.flag6) {
208  return [this](double x, double y, double z) {
209  return this->rotFunction(x, y, z);
210  };
211  }
212  return [this](double x, double y, double z) { return tVal; };
213  }
214 };
215 
216 template <int FIELD_DIM, AssemblyType A, IntegrationType I, typename OpBase>
217 OpEssentialRhsImpl<DisplacementCubitBcData, 1, FIELD_DIM, A, I, OpBase>::
218  OpEssentialRhsImpl(const std::string field_name,
219  boost::shared_ptr<DisplacementCubitBcData> bc_data,
220  boost::shared_ptr<Range> ents_ptr,
221  std::vector<boost::shared_ptr<ScalingMethod>> smv)
222  : OpSource(field_name, initDispFunction(bc_data), ents_ptr),
223  vecOfTimeScalingMethods(smv) {
224  static_assert(FIELD_DIM > 1, "Is not implemented for scalar field");
225 
227  tVal(i) = 0;
228  tAngles(i) = 0;
229  tOffset(i) = 0;
230 
231  if (bc_data->data.flag1 == 1)
232  tVal(0) = -bc_data->data.value1;
233  if (bc_data->data.flag2 == 1 && FIELD_DIM > 1)
234  tVal(1) = -bc_data->data.value2;
235  if (bc_data->data.flag3 == 1 && FIELD_DIM > 2)
236  tVal(2) = -bc_data->data.value3;
237  if (bc_data->data.flag4 == 1 && FIELD_DIM > 2)
238  tAngles(0) = -bc_data->data.value4;
239  if (bc_data->data.flag5 == 1 && FIELD_DIM > 2)
240  tAngles(1) = -bc_data->data.value5;
241  if (bc_data->data.flag6 == 1 && FIELD_DIM > 1)
242  tAngles(2) = -bc_data->data.value6;
243 
244  if (auto ext_bc_data =
245  dynamic_cast<DisplacementCubitBcDataWithRotation const *>(
246  bc_data.get())) {
247  for (int a = 0; a != 3; ++a)
248  tOffset(a) = ext_bc_data->rotOffset[a];
249  }
250 
251  this->timeScalingFun = [this](const double t) {
252  double s = 1;
253  for (auto &o : vecOfTimeScalingMethods) {
254  s *= o->getScale(t);
255  }
256  return s;
257  };
258 }
259 
260 template <int BASE_DIM, int FIELD_DIM, AssemblyType A, IntegrationType I,
261  typename OpBase>
263  OpBase>
264  : FormsIntegrators<OpBase>::template Assembly<A>::template BiLinearForm<
265  I>::template OpMass<BASE_DIM, FIELD_DIM> {
266 
267  using OpMass = typename FormsIntegrators<OpBase>::template Assembly<
269 
270  OpEssentialLhsImpl(const std::string field_name,
271  boost::shared_ptr<Range> ents_ptr);
272 };
273 
274 template <int BASE_DIM, int FIELD_DIM, AssemblyType A, IntegrationType I,
275  typename OpBase>
278  boost::shared_ptr<Range>
279  ents_ptr)
280  : OpMass(
282 
283  [](double, double, double) constexpr { return 1; },
284 
285  ents_ptr) {}
286 
287 template <int BASE_DIM, int FIELD_DIM, AssemblyType A, IntegrationType I,
288  typename OpBase>
290 
292  OpBase>,
293  A, I, OpBase
294 
295  > {
296 
298 
300 
301  MoFEM::Interface &m_field,
302  boost::ptr_deque<ForcesAndSourcesCore::UserDataOperator> &pipeline,
303  const std::string problem_name, std::string field_name,
304  boost::shared_ptr<MatrixDouble> field_mat_ptr,
305  std::vector<boost::shared_ptr<ScalingMethod>> smv
306 
307  ) {
309 
310  using OP =
311  typename EssentialBC<OpBase>::template Assembly<A>::template LinearForm<
312  I>::template OpEssentialRhs<DisplacementCubitBcData, BASE_DIM,
313  FIELD_DIM>;
314  using OpInternal = typename FormsIntegrators<OpBase>::template Assembly<
315  A>::template LinearForm<I>::template OpBaseTimesVector<BASE_DIM,
316  FIELD_DIM, 1>;
317 
318  auto add_op = [&](auto &bcs) {
320  for (auto &m : bcs) {
321  if (auto bc = m.second->dispBcPtr) {
322  auto &bc_id = m.first;
323  auto regex_str =
324  (boost::format("%s_%s_(.*)") % problem_name % field_name).str();
325  if (std::regex_match(bc_id, std::regex(regex_str))) {
326  MOFEM_TAG_AND_LOG("SELF", Sev::noisy, "OpEssentialRhs") << *bc;
327  pipeline.push_back(
328  new OpSetBc(field_name, false, m.second->getBcMarkersPtr()));
329  pipeline.push_back(
330  new OP(field_name, bc, m.second->getBcEntsPtr(), smv));
331  pipeline.push_back(new OpInternal(
332  field_name, field_mat_ptr,
333  [](double, double, double) constexpr { return 1.; },
334  m.second->getBcEntsPtr()));
335  pipeline.push_back(new OpUnSetBc(field_name));
336  }
337  }
338  }
339  MOFEM_LOG_CHANNEL("SELF");
341  };
342 
343  CHKERR add_op(m_field.getInterface<BcManager>()->getBcMapByBlockName());
344 
346  }
347 };
348 
349 template <int BASE_DIM, int FIELD_DIM, AssemblyType A, IntegrationType I,
350  typename OpBase>
352 
354  OpBase>,
355  A, I, OpBase
356 
357  > {
358 
360 
362 
363  MoFEM::Interface &m_field,
364  boost::ptr_deque<ForcesAndSourcesCore::UserDataOperator> &pipeline,
365  const std::string problem_name, std::string field_name
366 
367  ) {
369 
370  using OP = typename EssentialBC<OpBase>::template Assembly<A>::
371  template BiLinearForm<I>::template OpEssentialLhs<
373 
374  auto add_op = [&](auto &bcs) {
376  for (auto &m : bcs) {
377  if (auto bc = m.second->dispBcPtr) {
378  auto &bc_id = m.first;
379  auto regex_str =
380  (boost::format("%s_%s_(.*)") % problem_name % field_name).str();
381  if (std::regex_match(bc_id, std::regex(regex_str))) {
382  MOFEM_TAG_AND_LOG("SELF", Sev::noisy, "OpEssentialLhs") << *bc;
383  pipeline.push_back(
384  new OpSetBc(field_name, false, m.second->getBcMarkersPtr()));
385  pipeline.push_back(new OP(field_name, m.second->getBcEntsPtr()));
386  pipeline.push_back(new OpUnSetBc(field_name));
387  }
388  }
389  }
390  MOFEM_LOG_CHANNEL("SELF");
392  };
393 
394  CHKERR add_op(m_field.getInterface<BcManager>()->getBcMapByBlockName());
395 
397  }
398 };
399 
400 } // namespace MoFEM
401 
402 #endif // _ESSENTIAL_DISPLACEMENTCUBITBCDATA_HPP__
MoFEMFunctionReturnHot
#define MoFEMFunctionReturnHot(a)
Last executable line of each PETSc function used for error handling. Replaces return()
Definition: definitions.h:460
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:195
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:190
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:191
MoFEM::OpEssentialRhsImpl< DisplacementCubitBcData, 1, FIELD_DIM, A, I, OpBase >::vecOfTimeScalingMethods
VecOfTimeScalingMethods vecOfTimeScalingMethods
Definition: EssentialDisplacementCubitBcData.hpp:193
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:169
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:182
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:548
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:168
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:243
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:361
MoFEM::AddEssentialToLhsPipelineImpl
Function (factory) for setting operators for lhs pipeline.
Definition: Essential.hpp:103
MoFEM::EssentialPreProcReaction< DisplacementCubitBcData >::mField
MoFEM::Interface & mField
Definition: EssentialDisplacementCubitBcData.hpp:167
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:58
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:299
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:206
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:268
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::EssentialPreProcReaction< DisplacementCubitBcData >::reactionPtr
boost::shared_ptr< std::vector< double > > reactionPtr
Definition: EssentialDisplacementCubitBcData.hpp:172
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:170
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:171
MoFEM::FormsIntegrators
Integrator forms.
Definition: FormsIntegrators.hpp:306
MoFEM::OpEssentialRhsImpl< DisplacementCubitBcData, 1, FIELD_DIM, A, I, OpBase >::tOffset
FTensor::Tensor1< double, 3 > tOffset
Definition: EssentialDisplacementCubitBcData.hpp:192
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:453
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:429
MoFEMFunctionBegin
#define MoFEMFunctionBegin
First executable line of each MoFEM function, used for error handling. Final line of MoFEM functions ...
Definition: definitions.h:359
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