KratosMultiphysics
KRATOS Multiphysics (Kratos) is a framework for building parallel, multi-disciplinary simulation software, aiming at modularity, extensibility, and high performance. Kratos is written in C++, and counts with an extensive Python interface.
base_solid_element.h
Go to the documentation of this file.
1 // KRATOS ___| | | |
2 // \___ \ __| __| | | __| __| | | __| _` | |
3 // | | | | | ( | | | | ( | |
4 // _____/ \__|_| \__,_|\___|\__|\__,_|_| \__,_|_| MECHANICS
5 //
6 // License: BSD License
7 // license: structural_mechanics_application/license.txt
8 //
9 // Main authors: Riccardo Rossi
10 // Vicente Mataix Ferrandiz
11 // Alejandro Cornejo
12 //
13 
14 #if !defined(KRATOS_BASE_SOLID_ELEMENT_H_INCLUDED )
15 #define KRATOS_BASE_SOLID_ELEMENT_H_INCLUDED
16 
17 // System includes
18 
19 // External includes
20 
21 // Project includes
22 #include "includes/define.h"
23 #include "includes/element.h"
28 
29 namespace Kratos
30 {
31 
34 
38 
40  typedef std::size_t IndexType;
41 
43  typedef std::size_t SizeType;
44 
48 
52 
56 
65 class KRATOS_API(FEM_TO_DEM_APPLICATION) BaseSolidElement
66  : public Element
67 {
68 protected:
73  {
76  double detF;
78  double detJ0;
83 
91  const SizeType StrainSize,
92  const SizeType Dimension,
93  const SizeType NumberOfNodes
94  )
95  {
96  detF = 1.0;
97  detJ0 = 1.0;
98  N = ZeroVector(NumberOfNodes);
99  B = ZeroMatrix(StrainSize, Dimension * NumberOfNodes);
100  F = IdentityMatrix(Dimension);
101  DN_DX = ZeroMatrix(NumberOfNodes, Dimension);
102  J0 = ZeroMatrix(Dimension, Dimension);
103  InvJ0 = ZeroMatrix(Dimension, Dimension);
104  Displacements = ZeroVector(Dimension * NumberOfNodes);
105  }
106  };
107 
112  {
116 
121  ConstitutiveVariables(const SizeType StrainSize)
122  {
123  StrainVector = ZeroVector(StrainSize);
124  StressVector = ZeroVector(StrainSize);
125  D = ZeroMatrix(StrainSize, StrainSize);
126  }
127  };
128 public:
129 
132 
135 
137  typedef ConstitutiveLawType::Pointer ConstitutiveLawPointerType;
138 
141 
144 
146  typedef Node NodeType;
147 
149  typedef Element BaseType;
150 
151  // Counted pointer of BaseSolidElement
153 
157 
158  // Constructor void
160  {};
161 
162  // Constructor using an array of nodes
163  BaseSolidElement( IndexType NewId, GeometryType::Pointer pGeometry ):Element(NewId,pGeometry)
164  {};
165 
166  // Constructor using an array of nodes with properties
167  BaseSolidElement( IndexType NewId, GeometryType::Pointer pGeometry, PropertiesType::Pointer pProperties ):Element(NewId,pGeometry,pProperties)
168  {};
169 
170  // Copy constructor
172  :BaseType(rOther)
173  ,mThisIntegrationMethod(rOther.mThisIntegrationMethod)
174  {};
175 
176  // Destructor
177  ~BaseSolidElement() override
178  {};
179 
183 
187 
192  void Initialize(const ProcessInfo& rCurrentProcessInfo) override;
193 
197  void ResetConstitutiveLaw() override;
198 
203  void InitializeSolutionStep(const ProcessInfo& rCurrentProcessInfo) override;
204 
209  void InitializeNonLinearIteration(const ProcessInfo& rCurrentProcessInfo) override;
210 
215  void FinalizeNonLinearIteration(const ProcessInfo& rCurrentProcessInfo) override;
216 
221  void FinalizeSolutionStep(const ProcessInfo& rCurrentProcessInfo) override;
222 
230  Element::Pointer Clone (
231  IndexType NewId,
232  NodesArrayType const& rThisNodes
233  ) const override;
234 
240  void EquationIdVector(
241  EquationIdVectorType& rResult,
242  const ProcessInfo& rCurrentProcessInfo
243  ) const override;
244 
250  void GetDofList(
251  DofsVectorType& rElementalDofList,
252  const ProcessInfo& rCurrentProcessInfo
253  ) const override;
254 
260  {
261  return mThisIntegrationMethod;
262  }
263 
269  void GetValuesVector(
270  Vector& rValues,
271  int Step = 0
272  ) const override;
273 
279  void GetFirstDerivativesVector(
280  Vector& rValues,
281  int Step = 0
282  ) const override;
283 
289  void GetSecondDerivativesVector(
290  Vector& rValues,
291  int Step = 0
292  ) const override;
293 
301  void CalculateLocalSystem(
302  MatrixType& rLeftHandSideMatrix,
303  VectorType& rRightHandSideVector,
304  const ProcessInfo& rCurrentProcessInfo
305  ) override;
306 
312  void CalculateLeftHandSide(
313  MatrixType& rLeftHandSideMatrix,
314  const ProcessInfo& rCurrentProcessInfo
315  ) override;
316 
322  void CalculateRightHandSide(
323  VectorType& rRightHandSideVector,
324  const ProcessInfo& rCurrentProcessInfo
325  ) override;
326 
336  void AddExplicitContribution(
337  const VectorType& rRHSVector,
338  const Variable<VectorType>& rRHSVariable,
339  const Variable<double >& rDestinationVariable,
340  const ProcessInfo& rCurrentProcessInfo
341  ) override;
342 
352  void AddExplicitContribution(const VectorType& rRHSVector,
353  const Variable<VectorType>& rRHSVariable,
354  const Variable<array_1d<double, 3> >& rDestinationVariable,
355  const ProcessInfo& rCurrentProcessInfo
356  ) override;
357 
363  void CalculateMassMatrix(
364  MatrixType& rMassMatrix,
365  const ProcessInfo& rCurrentProcessInfo
366  ) override;
367 
373  void CalculateDampingMatrix(
374  MatrixType& rDampingMatrix,
375  const ProcessInfo& rCurrentProcessInfo
376  ) override;
377 
385  const Variable<bool>& rVariable,
386  std::vector<bool>& rOutput,
387  const ProcessInfo& rCurrentProcessInfo
388  ) override;
389 
397  const Variable<int>& rVariable,
398  std::vector<int>& rOutput,
399  const ProcessInfo& rCurrentProcessInfo
400  ) override;
401 
409  const Variable<double>& rVariable,
410  std::vector<double>& rOutput,
411  const ProcessInfo& rCurrentProcessInfo
412  ) override;
413 
421  const Variable<array_1d<double, 3>>& rVariable,
422  std::vector<array_1d<double, 3>>& rOutput,
423  const ProcessInfo& rCurrentProcessInfo
424  ) override;
425 
433  const Variable<array_1d<double, 6>>& rVariable,
434  std::vector<array_1d<double, 6>>& rOutput,
435  const ProcessInfo& rCurrentProcessInfo
436  ) override;
437 
445  const Variable<Vector>& rVariable,
446  std::vector<Vector>& rOutput,
447  const ProcessInfo& rCurrentProcessInfo
448  ) override;
449 
457  const Variable<Matrix>& rVariable,
458  std::vector<Matrix>& rOutput,
459  const ProcessInfo& rCurrentProcessInfo
460  ) override;
461 
469  const Variable<bool>& rVariable,
470  const std::vector<bool>& rValues,
471  const ProcessInfo& rCurrentProcessInfo
472  ) override;
473 
481  const Variable<int>& rVariable,
482  const std::vector<int>& rValues,
483  const ProcessInfo& rCurrentProcessInfo
484  ) override;
485 
493  const Variable<double>& rVariable,
494  const std::vector<double>& rValues,
495  const ProcessInfo& rCurrentProcessInfo
496  ) override;
497 
505  const Variable<Vector>& rVariable,
506  const std::vector<Vector>& rValues,
507  const ProcessInfo& rCurrentProcessInfo
508  ) override;
509 
517  const Variable<Matrix>& rVariable,
518  const std::vector<Matrix>& rValues,
519  const ProcessInfo& rCurrentProcessInfo
520  ) override;
521 
529  const Variable<ConstitutiveLaw::Pointer>& rVariable,
530  const std::vector<ConstitutiveLaw::Pointer>& rValues,
531  const ProcessInfo& rCurrentProcessInfo
532  ) override;
533 
541  const Variable<ConstitutiveLaw::Pointer>& rVariable,
542  std::vector<ConstitutiveLaw::Pointer>& rValues,
543  const ProcessInfo& rCurrentProcessInfo
544  ) override;
545 
546 
554  const Variable<array_1d<double, 3 > >& rVariable,
555  const std::vector<array_1d<double, 3 > >& rValues,
556  const ProcessInfo& rCurrentProcessInfo
557  ) override;
558 
566  const Variable<array_1d<double, 6 > >& rVariable,
567  const std::vector<array_1d<double, 6 > >& rValues,
568  const ProcessInfo& rCurrentProcessInfo
569  ) override;
570 
571  // GetValueOnIntegrationPoints are TEMPORARY until they are removed!!!
572  // They will be removed from the derived elements; i.e. the implementation
573  // should be in CalculateOnIntegrationPoints!
574  // Adding these functions here is bcs GiD calls GetValueOnIntegrationPoints
575 
583  int Check( const ProcessInfo& rCurrentProcessInfo ) const override;
584 
586  Element& rElement,
587  Element::MatrixType& rDampingMatrix,
588  const ProcessInfo& rCurrentProcessInfo,
589  const std::size_t MatrixSize);
590 
594 
595 
599 
600 
604 
606  std::string Info() const override
607  {
608  std::stringstream buffer;
609  buffer << "Base Solid Element #" << Id() << "\nConstitutive law: " << mConstitutiveLawVector[0]->Info();
610  return buffer.str();
611  }
612 
614  void PrintInfo(std::ostream& rOStream) const override
615  {
616  rOStream << "Base Solid Element #" << Id() << "\nConstitutive law: " << mConstitutiveLawVector[0]->Info();
617  }
618 
620  void PrintData(std::ostream& rOStream) const override
621  {
622  pGetGeometry()->PrintData(rOStream);
623  }
624 
628 
629 protected:
630 
633 
637 
639 
640  std::vector<ConstitutiveLaw::Pointer> mConstitutiveLawVector;
641 
645 
649 
654  void SetIntegrationMethod(const IntegrationMethod& ThisIntegrationMethod)
655  {
656  mThisIntegrationMethod = ThisIntegrationMethod;
657  }
658 
663  void SetConstitutiveLawVector(const std::vector<ConstitutiveLaw::Pointer>& ThisConstitutiveLawVector)
664  {
665  mConstitutiveLawVector = ThisConstitutiveLawVector;
666  }
667 
671  virtual void InitializeMaterial();
672 
676  virtual ConstitutiveLaw::StressMeasure GetStressMeasure() const;
677 
681  virtual bool UseElementProvidedStrain() const;
682 
691  virtual void CalculateAll(
692  MatrixType& rLeftHandSideMatrix,
693  VectorType& rRightHandSideVector,
694  const ProcessInfo& rCurrentProcessInfo,
695  const bool CalculateStiffnessMatrixFlag,
696  const bool CalculateResidualVectorFlag
697  );
698 
705  virtual void CalculateKinematicVariables(
706  KinematicVariables& rThisKinematicVariables,
707  const IndexType PointNumber,
708  const GeometryType::IntegrationMethod& rIntegrationMethod
709  );
710 
719  virtual void SetConstitutiveVariables(
720  KinematicVariables& rThisKinematicVariables,
721  ConstitutiveVariables& rThisConstitutiveVariables,
723  const IndexType PointNumber,
724  const GeometryType::IntegrationPointsArrayType& IntegrationPoints
725  );
726 
736  virtual void CalculateConstitutiveVariables(
737  KinematicVariables& rThisKinematicVariables,
738  ConstitutiveVariables& rThisConstitutiveVariables,
740  const IndexType PointNumber,
741  const GeometryType::IntegrationPointsArrayType& IntegrationPoints,
743  );
744 
750  Matrix& CalculateDeltaDisplacement(Matrix& DeltaDisplacement) const;
751 
761  virtual double CalculateDerivativesOnReferenceConfiguration(
762  Matrix& rJ0,
763  Matrix& rInvJ0,
764  Matrix& rDN_DX,
765  const IndexType PointNumber,
766  IntegrationMethod ThisIntegrationMethod
767  ) const;
768 
778  double CalculateDerivativesOnCurrentConfiguration(
779  Matrix& rJ,
780  Matrix& rInvJ,
781  Matrix& rDN_DX,
782  const IndexType PointNumber,
783  IntegrationMethod ThisIntegrationMethod
784  ) const;
785 
793  const GeometryType::IntegrationPointsArrayType& IntegrationPoints,
794  const IndexType PointNumber
795  ) const;
796 
804  virtual void CalculateAndAddKm(
805  MatrixType& rLeftHandSideMatrix,
806  const Matrix& B,
807  const Matrix& D,
808  const double IntegrationWeight
809  ) const;
810 
818  void CalculateAndAddKg(
819  MatrixType& rLeftHandSideMatrix,
820  const Matrix& DN_DX,
821  const Vector& rStressVector,
822  const double IntegrationWeight
823  ) const;
824 
834  virtual void CalculateAndAddResidualVector(
835  VectorType& rRightHandSideVector,
836  const KinematicVariables& rThisKinematicVariables,
837  const ProcessInfo& rCurrentProcessInfo,
838  const array_1d<double, 3>& rBodyForce,
839  const Vector& rStressVector,
840  const double IntegrationWeight
841  ) const;
842 
851  void CalculateAndAddExtForceContribution(
852  const Vector& rN,
853  const ProcessInfo& rCurrentProcessInfo,
854  const array_1d<double, 3>& rBodyForce,
855  VectorType& rRightHandSideVector,
856  const double IntegrationWeight
857  ) const;
858 
865  virtual double GetIntegrationWeight(
866  const GeometryType::IntegrationPointsArrayType& rThisIntegrationPoints,
867  const IndexType PointNumber,
868  const double detJ
869  ) const;
870 
876  void CalculateShapeGradientOfMassMatrix(MatrixType& rMassMatrix, ShapeParameter Deriv) const;
877 
878  double GetRayleighAlpha(const Properties& rProperties, const ProcessInfo& rCurrentProcessInfo);
879  double GetRayleighBeta(const Properties& rProperties, const ProcessInfo& rCurrentProcessInfo);
883 
887 
891 
892 private:
895 
899 
903 
907 
912  void CalculateLumpedMassVector(
913  VectorType &rLumpedMassVector,
914  const ProcessInfo& rCurrentProcessInfo) const override;
915 
921  void CalculateDampingMatrixWithLumpedMass(
922  MatrixType& rDampingMatrix,
923  const ProcessInfo& rCurrentProcessInfo
924  );
925 
933  template<class TType>
934  void GetValueOnConstitutiveLaw(
935  const Variable<TType>& rVariable,
936  std::vector<TType>& rOutput
937  )
938  {
939  const GeometryType::IntegrationPointsArrayType& integration_points = GetGeometry().IntegrationPoints( this->GetIntegrationMethod() );
940 
941  for ( IndexType point_number = 0; point_number <integration_points.size(); ++point_number ) {
942  mConstitutiveLawVector[point_number]->GetValue( rVariable,rOutput[point_number]);
943  }
944  }
945 
954  template<class TType>
955  void CalculateOnConstitutiveLaw(
956  const Variable<TType>& rVariable,
957  std::vector<TType>& rOutput,
958  const ProcessInfo& rCurrentProcessInfo
959  )
960  {
961  const GeometryType::IntegrationPointsArrayType& integration_points = GetGeometry().IntegrationPoints( this->GetIntegrationMethod() );
962 
963  const SizeType number_of_nodes = GetGeometry().size();
964  const SizeType dimension = GetGeometry().WorkingSpaceDimension();
965  const SizeType strain_size = mConstitutiveLawVector[0]->GetStrainSize();
966 
967  KinematicVariables this_kinematic_variables(strain_size, dimension, number_of_nodes);
968  ConstitutiveVariables this_constitutive_variables(strain_size);
969 
970  // Create constitutive law parameters:
971  ConstitutiveLaw::Parameters Values(GetGeometry(),GetProperties(),rCurrentProcessInfo);
972 
973  // Set constitutive law flags:
974  Flags& ConstitutiveLawOptions=Values.GetOptions();
975  ConstitutiveLawOptions.Set(ConstitutiveLaw::USE_ELEMENT_PROVIDED_STRAIN, UseElementProvidedStrain());
976  ConstitutiveLawOptions.Set(ConstitutiveLaw::COMPUTE_STRESS, true);
977  ConstitutiveLawOptions.Set(ConstitutiveLaw::COMPUTE_CONSTITUTIVE_TENSOR, false);
978 
979  Values.SetStrainVector(this_constitutive_variables.StrainVector);
980 
981  for (IndexType point_number = 0; point_number < integration_points.size(); ++point_number) {
982  // Compute element kinematics B, F, DN_DX ...
983  this->CalculateKinematicVariables(this_kinematic_variables, point_number, this->GetIntegrationMethod());
984 
985  // Compute material reponse
986  this->SetConstitutiveVariables(this_kinematic_variables, this_constitutive_variables, Values, point_number, integration_points);
987 
988  rOutput[point_number] = mConstitutiveLawVector[point_number]->CalculateValue( Values, rVariable, rOutput[point_number] );
989  }
990  }
991 
995 
999 
1003 
1004  friend class Serializer;
1005 
1006  void save( Serializer& rSerializer ) const override;
1007 
1008  void load( Serializer& rSerializer ) override;
1009 
1010 }; // class BaseSolidElement.
1011 
1015 
1016 
1020 
1021 } // namespace Kratos.
1022 
1023 #endif // KRATOS_BASE_SOLID_ELEMENT_H_INCLUDED defined
This is base class used to define the solid elements.
Definition: base_solid_element.h:67
ConstitutiveLaw ConstitutiveLawType
Reference type definition for constitutive laws.
Definition: base_solid_element.h:134
KRATOS_CLASS_INTRUSIVE_POINTER_DEFINITION(BaseSolidElement)
BaseSolidElement(BaseSolidElement const &rOther)
Definition: base_solid_element.h:171
ConstitutiveLawType::StressMeasure StressMeasureType
StressMeasure from constitutive laws.
Definition: base_solid_element.h:140
void PrintInfo(std::ostream &rOStream) const override
Print information about this object.
Definition: base_solid_element.h:614
std::string Info() const override
Turn back information as a string.
Definition: base_solid_element.h:606
~BaseSolidElement() override
Definition: base_solid_element.h:177
Element BaseType
The base element type.
Definition: base_solid_element.h:149
Node NodeType
This is the definition of the node.
Definition: base_solid_element.h:146
BaseSolidElement(IndexType NewId, GeometryType::Pointer pGeometry)
Definition: base_solid_element.h:163
BaseSolidElement()
Definition: base_solid_element.h:159
ConstitutiveLawType::Pointer ConstitutiveLawPointerType
Pointer type for constitutive laws.
Definition: base_solid_element.h:137
void AddExplicitContribution(const VectorType &rRHSVector, const Variable< VectorType > &rRHSVariable, const Variable< array_1d< double, 3 > > &rDestinationVariable, const ProcessInfo &rCurrentProcessInfo) override
This function is designed to make the element to assemble an rRHS vector identified by a variable rRH...
BaseSolidElement(IndexType NewId, GeometryType::Pointer pGeometry, PropertiesType::Pointer pProperties)
Definition: base_solid_element.h:167
GeometryData::IntegrationMethod IntegrationMethod
Type definition for integration methods.
Definition: base_solid_element.h:143
void SetConstitutiveLawVector(const std::vector< ConstitutiveLaw::Pointer > &ThisConstitutiveLawVector)
Sets the used constitutive laws.
Definition: base_solid_element.h:663
IntegrationMethod GetIntegrationMethod() const override
Returns the used integration method.
Definition: base_solid_element.h:259
std::vector< ConstitutiveLaw::Pointer > mConstitutiveLawVector
Currently selected integration methods.
Definition: base_solid_element.h:640
IntegrationMethod mThisIntegrationMethod
Definition: base_solid_element.h:638
void PrintData(std::ostream &rOStream) const override
Print object's data.
Definition: base_solid_element.h:620
void SetIntegrationMethod(const IntegrationMethod &ThisIntegrationMethod)
Sets the used integration method.
Definition: base_solid_element.h:654
Definition: constitutive_law.h:47
StressMeasure
Definition: constitutive_law.h:69
@ StressMeasure_PK2
Definition: constitutive_law.h:71
Base class for all Elements.
Definition: element.h:60
std::size_t SizeType
Definition: element.h:94
std::size_t IndexType
Definition: flags.h:74
This defines the geometrical object, base definition of the element and condition entities.
Definition: geometrical_object.h:58
IntegrationMethod
Definition: geometry_data.h:76
std::vector< IntegrationPointType > IntegrationPointsArrayType
Definition: geometry.h:161
This class defines the node.
Definition: node.h:65
ProcessInfo holds the current value of different solution parameters.
Definition: process_info.h:59
Properties encapsulates data shared by different Elements or Conditions. It can store any type of dat...
Definition: properties.h:69
The serialization consists in storing the state of an object into a storage format like data file or ...
Definition: serializer.h:123
Variable class contains all information needed to store and retrive data from a data container.
Definition: variable.h:63
std::size_t IndexType
The definition of the index type.
Definition: key_hash.h:35
Matrix MatrixType
Definition: geometrical_transformation_utilities.h:55
void SetValuesOnIntegrationPoints(TObject &dummy, const Variable< TDataType > &rVariable, const std::vector< TDataType > &values, const ProcessInfo &rCurrentProcessInfo)
Definition: add_mesh_to_python.cpp:185
pybind11::list CalculateOnIntegrationPoints(TObject &dummy, const Variable< TDataType > &rVariable, const ProcessInfo &rProcessInfo)
Definition: add_mesh_to_python.cpp:142
void InitializeSolutionStep(ConstructionUtility &rThisUtil, std::string ThermalSubModelPartName, std::string MechanicalSubModelPartName, std::string HeatFluxSubModelPartName, std::string HydraulicPressureSubModelPartName, bool thermal_conditions, bool mechanical_conditions, int phase)
Definition: add_custom_utilities_to_python.cpp:45
void CalculateRayleighDampingMatrix(Element &rElement, Element::MatrixType &rDampingMatrix, const ProcessInfo &rCurrentProcessInfo, const std::size_t MatrixSize)
Method to calculate the rayleigh damping-matrix.
Definition: structural_mechanics_element_utilities.cpp:193
double GetRayleighAlpha(const Properties &rProperties, const ProcessInfo &rCurrentProcessInfo)
Method to get the rayleigh-alpha parameter.
Definition: structural_mechanics_element_utilities.cpp:136
double GetRayleighBeta(const Properties &rProperties, const ProcessInfo &rCurrentProcessInfo)
Method to get the rayleigh-beta parameter.
Definition: structural_mechanics_element_utilities.cpp:154
array_1d< double, 3 > GetBodyForce(const Element &rElement, const GeometryType::IntegrationPointsArrayType &rIntegrationPoints, const IndexType PointNumber)
This method returns the computed the computed body force.
Definition: structural_mechanics_element_utilities.cpp:71
REF: G. R. Cowper, GAUSSIAN QUADRATURE FORMULAS FOR TRIANGLES.
Definition: mesh_condition.cpp:21
KratosZeroVector< double > ZeroVector
Definition: amatrix_interface.h:561
AMatrix::IdentityMatrix< double > IdentityMatrix
Definition: amatrix_interface.h:564
KratosZeroMatrix< double > ZeroMatrix
Definition: amatrix_interface.h:559
std::size_t SizeType
The definition of the size type.
Definition: mortar_classes.h:43
ModelPart::NodesContainerType NodesArrayType
Definition: gid_gauss_point_container.h:42
int strain_size
Definition: generate_hyper_elastic_simo_taylor_neo_hookean.py:16
F
Definition: hinsberg_optimization.py:144
int dimension
Definition: isotropic_damage_automatic_differentiation.py:123
def load(f)
Definition: ode_solve.py:307
N
Definition: sensitivityMatrix.py:29
B
Definition: sensitivityMatrix.py:76
Definition: base_solid_element.h:112
Vector StressVector
Definition: base_solid_element.h:114
Matrix D
Definition: base_solid_element.h:115
Vector StrainVector
Definition: base_solid_element.h:113
ConstitutiveVariables(const SizeType StrainSize)
Definition: base_solid_element.h:121
Definition: base_solid_element.h:73
Matrix InvJ0
Definition: base_solid_element.h:80
Vector Displacements
Definition: base_solid_element.h:82
Matrix DN_DX
Definition: base_solid_element.h:81
Vector N
Definition: base_solid_element.h:74
double detF
Definition: base_solid_element.h:76
Matrix J0
Definition: base_solid_element.h:79
double detJ0
Definition: base_solid_element.h:78
Matrix B
Definition: base_solid_element.h:75
KinematicVariables(const SizeType StrainSize, const SizeType Dimension, const SizeType NumberOfNodes)
Definition: base_solid_element.h:90
Matrix F
Definition: base_solid_element.h:77
Definition: constitutive_law.h:189
Definition: geometrical_sensitivity_utility.h:33