OGS 6.1.0-1721-g6382411ad
ThermoMechanicsFEM.h
Go to the documentation of this file.
1 
10 #pragma once
11 
12 #include <memory>
13 #include <vector>
14 
16 #include "MathLib/KelvinVector.h"
25 
28 
29 namespace ProcessLib
30 {
31 namespace ThermoMechanics
32 {
33 template <typename BMatricesType, typename ShapeMatricesType,
34  int DisplacementDim>
36 {
40  : solid_material(solid_material),
42  solid_material.createMaterialStateVariables())
43  {
44  }
45 
46  // total stress
48 
49  // total strain
51 
52  // mechanical strain
54 
56  std::unique_ptr<typename MaterialLib::Solids::MechanicsBase<
57  DisplacementDim>::MaterialStateVariables>
59  double solid_density;
61 
63  typename ShapeMatricesType::NodalRowVectorType N;
64  typename ShapeMatricesType::GlobalDimNodalMatrixType dNdx;
65 
67  {
68  eps_prev = eps;
69  eps_m_prev = eps_m;
70  sigma_prev = sigma;
71  solid_density_prev = solid_density;
72  material_state_variables->pushBackState();
73  }
74 
76 };
77 
80 template <typename ShapeMatrixType>
82 {
83  std::vector<ShapeMatrixType, Eigen::aligned_allocator<ShapeMatrixType>> N;
84 };
85 
86 template <typename ShapeFunction, typename IntegrationMethod,
87  int DisplacementDim>
90 {
91 public:
92  using ShapeMatricesType =
94 
95  // Types for displacement.
96  // (Higher order elements = ShapeFunction).
99 
101  using RhsVector = typename ShapeMatricesType::template VectorType<
102  ShapeFunction::NPOINTS + ShapeFunction::NPOINTS * DisplacementDim>;
103  using JacobianMatrix = typename ShapeMatricesType::template MatrixType<
104  ShapeFunction::NPOINTS + ShapeFunction::NPOINTS * DisplacementDim,
105  ShapeFunction::NPOINTS + ShapeFunction::NPOINTS * DisplacementDim>;
106 
108  delete;
110 
112  MeshLib::Element const& e,
113  std::size_t const /*local_matrix_size*/,
114  bool const is_axially_symmetric,
115  unsigned const integration_order,
117  : _process_data(process_data),
118  _integration_method(integration_order),
119  _element(e),
120  _is_axially_symmetric(is_axially_symmetric)
121  {
122  unsigned const n_integration_points =
123  _integration_method.getNumberOfPoints();
124 
125  _ip_data.reserve(n_integration_points);
126  _secondary_data.N.resize(n_integration_points);
127 
128  auto const shape_matrices =
129  initShapeMatrices<ShapeFunction, ShapeMatricesType,
130  IntegrationMethod, DisplacementDim>(
131  e, is_axially_symmetric, _integration_method);
132 
133  auto& solid_material =
135  _process_data.solid_materials,
136  _process_data.material_ids,
137  e.getID());
138 
139  for (unsigned ip = 0; ip < n_integration_points; ip++)
140  {
141  _ip_data.emplace_back(solid_material);
142  auto& ip_data = _ip_data[ip];
143  ip_data.integration_weight =
144  _integration_method.getWeightedPoint(ip).getWeight() *
145  shape_matrices[ip].integralMeasure * shape_matrices[ip].detJ;
146 
147  static const int kelvin_vector_size =
149  DisplacementDim>::value;
150  ip_data.sigma.setZero(kelvin_vector_size);
151  ip_data.sigma_prev.setZero(kelvin_vector_size);
152  ip_data.eps.setZero(kelvin_vector_size);
153  ip_data.eps_prev.setZero(kelvin_vector_size);
154  ip_data.eps_m.setZero(kelvin_vector_size);
155  ip_data.eps_m_prev.setZero(kelvin_vector_size);
156 
157  SpatialPosition x_position;
158  x_position.setElementID(_element.getID());
159  ip_data.solid_density =
160  _process_data.reference_solid_density(0, x_position)[0];
161  ip_data.solid_density_prev = ip_data.solid_density;
162 
163  ip_data.N = shape_matrices[ip].N;
164  ip_data.dNdx = shape_matrices[ip].dNdx;
165 
166  _secondary_data.N[ip] = shape_matrices[ip].N;
167  }
168  }
169 
171  std::size_t setIPDataInitialConditions(std::string const& name,
172  double const* values,
173  int const integration_order) override
174  {
175  if (integration_order !=
176  static_cast<int>(_integration_method.getIntegrationOrder()))
177  {
178  OGS_FATAL(
179  "Setting integration point initial conditions; The integration "
180  "order of the local assembler for element %d is different from "
181  "the integration order in the initial condition.",
182  _element.getID());
183  }
184 
185  if (name == "sigma_ip")
186  {
187  return setSigma(values);
188  }
189  else if (name == "epsilon_ip")
190  {
191  return setEpsilon(values);
192  }
193  else if (name == "epsilon_m_ip")
194  {
195  return setEpsilonMechanical(values);
196  }
197 
198  return 0;
199  }
200 
201  void assemble(double const /*t*/, std::vector<double> const& /*local_x*/,
202  std::vector<double>& /*local_M_data*/,
203  std::vector<double>& /*local_K_data*/,
204  std::vector<double>& /*local_rhs_data*/) override
205  {
206  OGS_FATAL(
207  "ThermoMechanicsLocalAssembler: assembly without jacobian is not "
208  "implemented.");
209  }
210 
211  void assembleWithJacobian(double const t,
212  std::vector<double> const& local_x,
213  std::vector<double> const& local_xdot,
214  const double /*dxdot_dx*/, const double /*dx_dx*/,
215  std::vector<double>& /*local_M_data*/,
216  std::vector<double>& /*local_K_data*/,
217  std::vector<double>& local_rhs_data,
218  std::vector<double>& local_Jac_data) override
219  {
220  auto const local_matrix_size = local_x.size();
221  assert(local_matrix_size == temperature_size + displacement_size);
222 
223  auto T = Eigen::Map<typename ShapeMatricesType::template VectorType<
224  temperature_size> const>(local_x.data() + temperature_index,
225  temperature_size);
226 
227  auto u = Eigen::Map<typename ShapeMatricesType::template VectorType<
228  displacement_size> const>(local_x.data() + displacement_index,
229  displacement_size);
230 
231  auto T_dot = Eigen::Map<typename ShapeMatricesType::template VectorType<
232  temperature_size> const>(local_xdot.data() + temperature_index,
233  temperature_size);
234 
235  auto local_Jac = MathLib::createZeroedMatrix<JacobianMatrix>(
236  local_Jac_data, local_matrix_size, local_matrix_size);
237 
238  auto local_rhs = MathLib::createZeroedVector<RhsVector>(
239  local_rhs_data, local_matrix_size);
240 
241  typename ShapeMatricesType::template MatrixType<displacement_size,
242  temperature_size>
243  KuT;
244  KuT.setZero(displacement_size, temperature_size);
245 
247  KTT.setZero(temperature_size, temperature_size);
248 
250  DTT.setZero(temperature_size, temperature_size);
251 
252  double const& dt = _process_data.dt;
253 
254  unsigned const n_integration_points =
255  _integration_method.getNumberOfPoints();
256 
257  SpatialPosition x_position;
258  x_position.setElementID(_element.getID());
259 
260  for (unsigned ip = 0; ip < n_integration_points; ip++)
261  {
262  x_position.setIntegrationPoint(ip);
263  auto const& w = _ip_data[ip].integration_weight;
264  auto const& N = _ip_data[ip].N;
265  auto const& dNdx = _ip_data[ip].dNdx;
266 
267  auto const x_coord =
268  interpolateXCoordinate<ShapeFunction, ShapeMatricesType>(
269  _element, N);
270  auto const& B = LinearBMatrix::computeBMatrix<
271  DisplacementDim, ShapeFunction::NPOINTS,
272  typename BMatricesType::BMatrixType>(dNdx, N, x_coord,
273  _is_axially_symmetric);
274 
275  auto& sigma = _ip_data[ip].sigma;
276  auto const& sigma_prev = _ip_data[ip].sigma_prev;
277 
278  auto& eps = _ip_data[ip].eps;
279  auto const& eps_prev = _ip_data[ip].eps_prev;
280 
281  auto& eps_m = _ip_data[ip].eps_m;
282  auto const& eps_m_prev = _ip_data[ip].eps_m_prev;
283 
284  auto& state = _ip_data[ip].material_state_variables;
285 
286  double const dT = N.dot(T_dot) * dt;
287  // calculate thermally induced strain
288  // assume isotropic thermal expansion
289  auto const alpha =
290  _process_data.linear_thermal_expansion_coefficient(
291  t, x_position)[0];
292  double const linear_thermal_strain_increment = alpha * dT;
293 
294  //
295  // displacement equation, displacement part
296  //
297  eps.noalias() = B * u;
298 
299  using Invariants = MathLib::KelvinVector::Invariants<
301  DisplacementDim>::value>;
302 
303  // assume isotropic thermal expansion
304  const double T_ip = N.dot(T); // T at integration point
305  eps_m.noalias() =
306  eps_m_prev + eps - eps_prev -
307  linear_thermal_strain_increment * Invariants::identity2;
308 
309  auto&& solution = _ip_data[ip].solid_material.integrateStress(
310  t, x_position, dt, eps_m_prev, eps_m, sigma_prev, *state, T_ip);
311 
312  if (!solution)
313  OGS_FATAL("Computation of local constitutive relation failed.");
314 
316  std::tie(sigma, state, C) = std::move(*solution);
317 
318  local_Jac
319  .template block<displacement_size, displacement_size>(
320  displacement_index, displacement_index)
321  .noalias() += B.transpose() * C * B * w;
322 
323  typename ShapeMatricesType::template MatrixType<DisplacementDim,
324  displacement_size>
325  N_u = ShapeMatricesType::template MatrixType<
326  DisplacementDim,
327  displacement_size>::Zero(DisplacementDim,
328  displacement_size);
329 
330  for (int i = 0; i < DisplacementDim; ++i)
331  N_u.template block<1, displacement_size / DisplacementDim>(
332  i, i * displacement_size / DisplacementDim)
333  .noalias() = N;
334 
335  // calculate real density
336  // rho_s_{n+1} * (V_{n} + dV) = rho_s_n * V_n
337  // dV = 3 * alpha * dT * V_0
338  // rho_s_{n+1} = rho_s_n / (1 + 3 * alpha * dT )
339  // see reference solid density description for details.
340  auto& rho_s = _ip_data[ip].solid_density;
341  rho_s = _ip_data[ip].solid_density_prev /
342  (1 + 3 * linear_thermal_strain_increment);
343 
344  auto const& b = _process_data.specific_body_force;
345  local_rhs
346  .template block<displacement_size, 1>(displacement_index, 0)
347  .noalias() -=
348  (B.transpose() * sigma - N_u.transpose() * rho_s * b) * w;
349 
350  //
351  // displacement equation, temperature part
352  //
353  KuT.noalias() +=
354  B.transpose() * C * alpha * Invariants::identity2 * N * w;
355  if (_ip_data[ip].solid_material.getConstitutiveModel() ==
357  {
358  auto const s = Invariants::deviatoric_projection * sigma;
359  double const norm_s = Invariants::FrobeniusNorm(s);
360  const double creep_coefficient =
361  _ip_data[ip]
362  .solid_material.getTemperatureRelatedCoefficient(
363  t, dt, x_position, T_ip, norm_s);
364  KuT.noalias() += creep_coefficient * B.transpose() * s * N * w;
365  }
366 
367  //
368  // temperature equation, temperature part;
369  //
370  auto const lambda =
371  _process_data.thermal_conductivity(t, x_position)[0];
372  KTT.noalias() += dNdx.transpose() * lambda * dNdx * w;
373 
374  auto const c =
375  _process_data.specific_heat_capacity(t, x_position)[0];
376  DTT.noalias() += N.transpose() * rho_s * c * N * w;
377  }
378 
379  // temperature equation, temperature part
380  local_Jac
381  .template block<temperature_size, temperature_size>(
382  temperature_index, temperature_index)
383  .noalias() += KTT + DTT / dt;
384 
385  // displacement equation, temperature part
386  local_Jac
387  .template block<displacement_size, temperature_size>(
388  displacement_index, temperature_index)
389  .noalias() -= KuT;
390 
391  local_rhs.template block<temperature_size, 1>(temperature_index, 0)
392  .noalias() -= KTT * T + DTT * T_dot;
393  }
394 
395  void preTimestepConcrete(std::vector<double> const& /*local_x*/,
396  double const /*t*/,
397  double const /*delta_t*/) override
398  {
399  unsigned const n_integration_points =
400  _integration_method.getNumberOfPoints();
401 
402  for (unsigned ip = 0; ip < n_integration_points; ip++)
403  {
404  _ip_data[ip].pushBackState();
405  }
406  }
407 
408  Eigen::Map<const Eigen::RowVectorXd> getShapeMatrix(
409  const unsigned integration_point) const override
410  {
411  auto const& N = _secondary_data.N[integration_point];
412 
413  // assumes N is stored contiguously in memory
414  return Eigen::Map<const Eigen::RowVectorXd>(N.data(), N.size());
415  }
416 
417 private:
418  std::size_t setSigma(double const* values)
419  {
420  auto const kelvin_vector_size =
422  DisplacementDim>::value;
423  unsigned const n_integration_points =
424  _integration_method.getNumberOfPoints();
425 
426  auto sigma_values =
427  Eigen::Map<Eigen::Matrix<double, kelvin_vector_size, Eigen::Dynamic,
428  Eigen::ColMajor> const>(
429  values, kelvin_vector_size, n_integration_points);
430 
431  for (unsigned ip = 0; ip < n_integration_points; ++ip)
432  {
433  _ip_data[ip].sigma =
435  sigma_values.col(ip));
436  }
437 
438  return n_integration_points;
439  }
440 
441  // TODO (naumov) This method is same as getIntPtSigma but for arguments and
442  // the ordering of the cache_mat.
443  // There should be only one.
444  std::vector<double> getSigma() const override
445  {
446  auto const kelvin_vector_size =
448  DisplacementDim>::value;
449  unsigned const n_integration_points =
450  _integration_method.getNumberOfPoints();
451 
452  std::vector<double> ip_sigma_values;
453  auto cache_mat = MathLib::createZeroedMatrix<Eigen::Matrix<
454  double, Eigen::Dynamic, kelvin_vector_size, Eigen::RowMajor>>(
455  ip_sigma_values, n_integration_points, kelvin_vector_size);
456 
457  for (unsigned ip = 0; ip < n_integration_points; ++ip)
458  {
459  auto const& sigma = _ip_data[ip].sigma;
460  cache_mat.row(ip) =
462  }
463 
464  return ip_sigma_values;
465  }
466 
467  std::vector<double> const& getIntPtSigma(
468  const double /*t*/,
469  GlobalVector const& /*current_solution*/,
470  NumLib::LocalToGlobalIndexMap const& /*dof_table*/,
471  std::vector<double>& cache) const override
472  {
473  static const int kelvin_vector_size =
475  DisplacementDim>::value;
476  unsigned const n_integration_points =
477  _integration_method.getNumberOfPoints();
478 
479  cache.clear();
480  auto cache_mat = MathLib::createZeroedMatrix<Eigen::Matrix<
481  double, kelvin_vector_size, Eigen::Dynamic, Eigen::RowMajor>>(
482  cache, kelvin_vector_size, n_integration_points);
483 
484  for (unsigned ip = 0; ip < n_integration_points; ++ip)
485  {
486  auto const& sigma = _ip_data[ip].sigma;
487  cache_mat.col(ip) =
489  }
490 
491  return cache;
492  }
493 
494  std::size_t setEpsilon(double const* values)
495  {
496  auto const kelvin_vector_size =
498  DisplacementDim>::value;
499  unsigned const n_integration_points =
500  _integration_method.getNumberOfPoints();
501 
502  auto epsilon_values =
503  Eigen::Map<Eigen::Matrix<double, kelvin_vector_size, Eigen::Dynamic,
504  Eigen::ColMajor> const>(
505  values, kelvin_vector_size, n_integration_points);
506 
507  for (unsigned ip = 0; ip < n_integration_points; ++ip)
508  {
509  _ip_data[ip].eps =
511  epsilon_values.col(ip));
512  }
513 
514  return n_integration_points;
515  }
516 
517  std::vector<double> getEpsilon() const override
518  {
519  auto const kelvin_vector_size =
521  DisplacementDim>::value;
522  unsigned const n_integration_points =
523  _integration_method.getNumberOfPoints();
524 
525  std::vector<double> ip_epsilon_values;
526  auto cache_mat = MathLib::createZeroedMatrix<Eigen::Matrix<
527  double, Eigen::Dynamic, kelvin_vector_size, Eigen::RowMajor>>(
528  ip_epsilon_values, n_integration_points, kelvin_vector_size);
529 
530  for (unsigned ip = 0; ip < n_integration_points; ++ip)
531  {
532  auto const& eps = _ip_data[ip].eps;
533  cache_mat.row(ip) =
535  }
536 
537  return ip_epsilon_values;
538  }
539 
540  virtual std::vector<double> const& getIntPtEpsilon(
541  const double /*t*/,
542  GlobalVector const& /*current_solution*/,
543  NumLib::LocalToGlobalIndexMap const& /*dof_table*/,
544  std::vector<double>& cache) const override
545  {
546  auto const kelvin_vector_size =
548  DisplacementDim>::value;
549  unsigned const n_integration_points =
550  _integration_method.getNumberOfPoints();
551 
552  cache.clear();
553  auto cache_mat = MathLib::createZeroedMatrix<Eigen::Matrix<
554  double, kelvin_vector_size, Eigen::Dynamic, Eigen::RowMajor>>(
555  cache, kelvin_vector_size, n_integration_points);
556 
557  for (unsigned ip = 0; ip < n_integration_points; ++ip)
558  {
559  auto const& eps = _ip_data[ip].eps;
560  cache_mat.col(ip) =
562  }
563 
564  return cache;
565  }
566 
567  std::size_t setEpsilonMechanical(double const* values)
568  {
569  auto const kelvin_vector_size =
571  DisplacementDim>::value;
572  unsigned const n_integration_points =
573  _integration_method.getNumberOfPoints();
574 
575  auto epsilon_m_values =
576  Eigen::Map<Eigen::Matrix<double, kelvin_vector_size, Eigen::Dynamic,
577  Eigen::ColMajor> const>(
578  values, kelvin_vector_size, n_integration_points);
579 
580  for (unsigned ip = 0; ip < n_integration_points; ++ip)
581  {
582  _ip_data[ip].eps_m =
584  epsilon_m_values.col(ip));
585  }
586 
587  return n_integration_points;
588  }
589 
590  std::vector<double> getEpsilonMechanical() const override
591  {
592  auto const kelvin_vector_size =
594  DisplacementDim>::value;
595  unsigned const n_integration_points =
596  _integration_method.getNumberOfPoints();
597 
598  std::vector<double> ip_epsilon_m_values;
599  auto cache_mat = MathLib::createZeroedMatrix<Eigen::Matrix<
600  double, Eigen::Dynamic, kelvin_vector_size, Eigen::RowMajor>>(
601  ip_epsilon_m_values, n_integration_points, kelvin_vector_size);
602 
603  for (unsigned ip = 0; ip < n_integration_points; ++ip)
604  {
605  auto const& eps_m = _ip_data[ip].eps_m;
606  cache_mat.row(ip) =
608  }
609 
610  return ip_epsilon_m_values;
611  }
612 
614 
615  std::vector<
617  Eigen::aligned_allocator<IntegrationPointData<
618  BMatricesType, ShapeMatricesType, DisplacementDim>>>
620 
621  IntegrationMethod _integration_method;
625 
626  static const int temperature_index = 0;
627  static const int temperature_size = ShapeFunction::NPOINTS;
628  static const int displacement_index = ShapeFunction::NPOINTS;
629  static const int displacement_size =
630  ShapeFunction::NPOINTS * DisplacementDim;
631 };
632 
633 } // namespace ThermoMechanics
634 } // namespace ProcessLib
Eigen::Matrix< double, Eigen::MatrixBase< Derived >::RowsAtCompileTime, 1 > symmetricTensorToKelvinVector(Eigen::MatrixBase< Derived > const &v)
Definition: KelvinVector.h:173
typename ShapeMatricesType::ShapeMatrices ShapeMatrices
Eigen::Map< const Eigen::RowVectorXd > getShapeMatrix(const unsigned integration_point) const override
Provides the shape matrix at the given integration point.
Kelvin vector dimensions for given displacement dimension.
Definition: KelvinVector.h:23
IntegrationPointData(MaterialLib::Solids::MechanicsBase< DisplacementDim > const &solid_material)
ShapeMatricesType::GlobalDimNodalMatrixType dNdx
std::unique_ptr< typename MaterialLib::Solids::MechanicsBase< DisplacementDim >::MaterialStateVariables > material_state_variables
VectorType< _number_of_dof > NodalForceVectorType
Rhs residual.
Definition: BMatrixPolicy.h:43
std::vector< typename ShapeMatricesType::ShapeMatrices, Eigen::aligned_allocator< typename ShapeMatricesType::ShapeMatrices > > initShapeMatrices(MeshLib::Element const &e, bool is_axially_symmetric, IntegrationMethod const &integration_method)
MechanicsBase< DisplacementDim > & selectSolidConstitutiveRelation(std::map< int, std::unique_ptr< MechanicsBase< DisplacementDim >>> const &constitutive_relations, MeshLib::PropertyVector< int > const *const material_ids, std::size_t const element_id)
ShapeMatricesType::NodalRowVectorType N
ThermoMechanicsProcessData< DisplacementDim > & _process_data
virtual std::vector< double > const & getIntPtEpsilon(const double, GlobalVector const &, NumLib::LocalToGlobalIndexMap const &, std::vector< double > &cache) const override
Eigen::Matrix< double, KelvinVectorDimensions< DisplacementDim >::value, KelvinVectorDimensions< DisplacementDim >::value, Eigen::RowMajor > KelvinMatrixType
Definition: KelvinVector.h:59
void setElementID(std::size_t element_id)
MaterialLib::Solids::MechanicsBase< DisplacementDim > const & solid_material
typename ShapeMatricesType::template MatrixType< ShapeFunction::NPOINTS+ShapeFunction::NPOINTS *DisplacementDim, ShapeFunction::NPOINTS+ShapeFunction::NPOINTS *DisplacementDim > JacobianMatrix
Eigen::Map< Matrix > createZeroedMatrix(std::vector< double > &data, Eigen::MatrixXd::Index rows, Eigen::MatrixXd::Index cols)
Definition: EigenMapTools.h:31
SecondaryData< typename ShapeMatrices::ShapeType > _secondary_data
ThermoMechanicsLocalAssembler(MeshLib::Element const &e, std::size_t const, bool const is_axially_symmetric, unsigned const integration_order, ThermoMechanicsProcessData< DisplacementDim > &process_data)
void assembleWithJacobian(double const t, std::vector< double > const &local_x, std::vector< double > const &local_xdot, const double, const double, std::vector< double > &, std::vector< double > &, std::vector< double > &local_rhs_data, std::vector< double > &local_Jac_data) override
std::vector< double > const & getIntPtSigma(const double, GlobalVector const &, NumLib::LocalToGlobalIndexMap const &, std::vector< double > &cache) const override
BMatrixType computeBMatrix(DNDX_Type const &dNdx, N_Type const &N, const double radius, const bool is_axially_symmetric)
Fills a B-matrix based on given shape function dN/dx values.
Definition: LinearBMatrix.h:41
Coordinates mapping matrices at particular location.
Definition: ShapeMatrices.h:45
Eigen::Matrix< double, 4, 1 > kelvinVectorToSymmetricTensor(Eigen::Matrix< double, 4, 1, Eigen::ColMajor, 4, 1 > const &v)
void assemble(double const, std::vector< double > const &, std::vector< double > &, std::vector< double > &, std::vector< double > &) override
typename BMatricesType::NodalForceVectorType NodalForceVectorType
std::vector< double > getEpsilonMechanical() const override
std::vector< ShapeMatrixType, Eigen::aligned_allocator< ShapeMatrixType > > N
#define OGS_FATAL(fmt,...)
Definition: Error.h:71
std::size_t setIPDataInitialConditions(std::string const &name, double const *values, int const integration_order) override
Returns number of read integration points.
void preTimestepConcrete(std::vector< double > const &, double const, double const) override
void setIntegrationPoint(unsigned integration_point)
MatrixType< ShapeFunction::NPOINTS, ShapeFunction::NPOINTS > NodalMatrixType
std::vector< IntegrationPointData< BMatricesType, ShapeMatricesType, DisplacementDim >, Eigen::aligned_allocator< IntegrationPointData< BMatricesType, ShapeMatricesType, DisplacementDim > > > _ip_data
MatrixType< _kelvin_vector_size, _number_of_dof > BMatrixType
Definition: BMatrixPolicy.h:54
typename ShapeMatricesType::template VectorType< ShapeFunction::NPOINTS+ShapeFunction::NPOINTS *DisplacementDim > RhsVector
Eigen::Matrix< double, KelvinVectorDimensions< DisplacementDim >::value, 1, Eigen::ColMajor > KelvinVectorType
Definition: KelvinVector.h:49