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.
geometrically_exact_rod_element.hpp
Go to the documentation of this file.
1 //
2 // Project Name: KratosSolidMechanicsApplication $
3 // Created by: $Author: JMCarbonell $
4 // Last modified by: $Co-Author: $
5 // Date: $Date: August 2017 $
6 // Revision: $Revision: 0.0 $
7 //
8 //
9 
10 #if !defined(KRATOS_GEOMETRICALLY_EXACT_ROD_ELEMENT_H_INCLUDED)
11 #define KRATOS_GEOMETRICALLY_EXACT_ROD_ELEMENT_H_INCLUDED
12 
13 // System includes
14 
15 // External includes
16 
17 // Project includes
19 
20 namespace Kratos
21 {
36 
38 
46 class KRATOS_API(SOLID_MECHANICS_APPLICATION) GeometricallyExactRodElement
48 {
49 public:
50 
56  typedef ConstitutiveLawType::Pointer ConstitutiveLawPointerType;
69 
72 
76 
78  GeometricallyExactRodElement(IndexType NewId, GeometryType::Pointer pGeometry);
79 
80  GeometricallyExactRodElement(IndexType NewId, GeometryType::Pointer pGeometry, PropertiesType::Pointer pProperties);
81 
84 
86  ~GeometricallyExactRodElement() override;
87 
88 
92 
93 
101  Element::Pointer Create(IndexType NewId, NodesArrayType const& ThisNodes, PropertiesType::Pointer pProperties) const override;
102 
103 
104  //************* STARTING - ENDING METHODS
105 
110  void Initialize(const ProcessInfo& rCurrentProcessInfo) override;
111 
115  void InitializeSolutionStep(const ProcessInfo& rCurrentProcessInfo) override;
116 
117 
118  //************************************************************************************
119  //************************************************************************************
127  int Check(const ProcessInfo& rCurrentProcessInfo) const override;
128 
132 
140  std::string Info() const override
141  {
142  std::stringstream buffer;
143  buffer << "Large Displacement Beam Element #" << Id();
144  return buffer.str();
145  }
146 
148  void PrintInfo(std::ostream& rOStream) const override
149  {
150  rOStream << "Large Displacement Beam Element #" << Id();
151  }
152 
154  void PrintData(std::ostream& rOStream) const override
155  {
156  GetGeometry().PrintData(rOStream);
157  }
162 
163 protected:
164 
170 
174  std::vector<Matrix> mInitialLocalDirectors;
175 
179  std::vector<Matrix> mCurrentLocalDirectors;
180 
184  std::vector<Matrix> mPreviousLocalDirectors;
185 
189  std::vector<Matrix> mInitialLocalDirectorsVelocities;
190 
194  std::vector<Matrix> mCurrentLocalDirectorsVelocities;
195 
200 
201 
206 
210 
217  void CalculateElementalSystem( LocalSystemComponents& rLocalSystem,
218  const ProcessInfo& rCurrentProcessInfo ) override;
219 
220 
224  void CalculateDynamicSystem( LocalSystemComponents& rLocalSystem,
225  const ProcessInfo& rCurrentProcessInfo ) override;
226 
227 
228 
232  void InitializeElementData(ElementDataType & rVariables, const ProcessInfo& rCurrentProcessInfo) override;
233 
234 
235 
239  void CalculateKinematics(ElementDataType& rVariables,
240  const unsigned int& rPointNumber) override;
241 
245  void CalculateConstitutiveMatrix(ElementDataType& rVariables) override;
246 
250  void CalculateFrameMapping(ElementDataType& rVariables,
251  const unsigned int& rPointNumber) override;
252 
253 
257  void UpdateRotationVariables(ElementDataType& rVariables,
258  const unsigned int& rPointNumber);
259 
263  virtual void CalculateDirectorsMappingTensor(Matrix& rMappingTensor,
264  ElementDataType& rVariables,
265  const int& rNode,
266  double alpha);
267 
268 
272  void CalculateCurrentStrainResultantsVector(ElementDataType& rVariables,
273  Vector& rCurrentStrainResultantsVector,
274  double Alpha) override;
275 
279  void CalculateCurrentCurvatureVector(ElementDataType& rVariables,
280  Vector& rCurrentCurvatureVector,
281  double Alpha) override;
282 
283 
287  void CalculateStressResultants(ElementDataType& rVariables, const unsigned int& rPointNumber) override;
288 
289 
294  void CalculateAndAddKuum(MatrixType& rLeftHandSideMatrix,
295  ElementDataType& rVariables,
296  double& rIntegrationWeight) override;
297 
298 
299 
303  void CalculateAndAddKuug(MatrixType& rLeftHandSideMatrix,
304  ElementDataType& rVariables,
305  double& rIntegrationWeight) override;
306 
307 
311  void CalculateAndAddKuuf(MatrixType& rLeftHandSideMatrix,
312  ElementDataType& rVariables,
313  double& rIntegrationWeight) override;
314 
315 
316 
320  void CalculateAndAddFollowerForces(VectorType& rRightHandSideVector,
321  ElementDataType& rVariables,
322  double& rIntegrationWeight) override;
323 
324 
328  void CalculateAndAddExternalForces(VectorType& rRightHandSideVector,
329  ElementDataType& rVariables,
330  Vector& rVolumeForce,
331  double& rIntegrationWeight) override;
332 
336  void CalculateAndAddInertiaLHS(MatrixType& rLeftHandSideMatrix,
337  ElementDataType& rVariables,
338  const ProcessInfo& rCurrentProcessInfo,
339  double& rIntegrationWeight) override;
340 
341 
345  void CalculateAndAddInertiaRHS(VectorType& rRightHandSideVector,
346  ElementDataType& rVariables,
347  const ProcessInfo& rCurrentProcessInfo,
348  double& rIntegrationWeight) override;
349 
350 
354  void CalculateAndAddInternalForces(VectorType& rRightHandSideVector,
355  ElementDataType & rVariables,
356  double& rIntegrationWeight) override;
357 
358 
362  void CalculateDiscreteOperatorN(MatrixType& rDiscreteOperator,
363  ElementDataType& rVariables,
364  const int& rNodeI,
365  const int& rNodeJ,
366  const int& rComponent);
367 
368  void CalculateDiscreteOperatorM(MatrixType& rDiscreteOperator,
369  ElementDataType& rVariables,
370  const int& rNodeI,
371  const int& rNodeJ,
372  const int& rComponent);
373 
377  void CalculateDifferentialOperator(MatrixType& rDifferentialOperator,
378  ElementDataType& rVariables,
379  const int& rNode,
380  double alpha) override;
381 
382 
387  void CalculateAlphaDirectors(Matrix& rDirectors, ElementDataType& rVariables, const int& rNode, double alpha);
388 
389 
390  void CalculateAlphaDirectorVector(Vector& rDirectorVector, ElementDataType& rVariables, const int& rNode, const int& rDirection, double alpha);
391 
392  void CalculateAlphaDirectorSkewSymTensor(Matrix& rDirectorSkewSymTensor, ElementDataType& rVariables, const int& rNode, const int& rDirection, double alpha);
393 
394 
398  void CalculateAlphaDirectorVector(Vector& rDirectorVector, ElementDataType& rVariables, const int& rDirection, double alpha);
399 
400  void CalculateAlphaDirectorSkewSymTensor(Matrix& rDirectorSkewSymTensor, ElementDataType& rVariables, const int& rDirection, double alpha);
401 
405  void CalculateDirectorDerivativesVector(Vector& rDirectorDerivativesVector, ElementDataType& rVariables, const int& rDirection, double alpha);
406 
407  void CalculateDirectorDerivativesSkewSymTensor(Matrix& rDirectorDerivativesSkewSymTensor, ElementDataType& rVariables, const int& rDirection, double alpha);
408 
409 
413  void CalculateAlgorithmicInertia(Matrix & rAlgorithmicInertia,
414  const Matrix& rInertiaDyadic,
415  ElementDataType & rVariables,
416  const int& NodeJ,
417  const int& NodeI,
418  double alpha);
419 
430 
431 private:
432 
451  friend class Serializer;
452 
453 
454  // A private default constructor necessary for serialization
455 
456 
457  void save(Serializer& rSerializer) const override;
458 
459  void load(Serializer& rSerializer) override;
460 
461 
468 
469 
470 }; // Class GeometricallyExactRodElement
471 
472 } // namespace Kratos.
473 #endif // KRATOS_GEOMETRICALLY_EXACT_ROD_ELEMENT_H_INCLUDED defined
Definition: beam_math_utilities.hpp:31
Definition: constitutive_law.h:47
StressMeasure
Definition: constitutive_law.h:69
std::size_t IndexType
Definition: flags.h:74
Beam Element for 3D space dimension Romero Displacement-Rotation Geometrically Exact Rod element (bas...
Definition: geometrically_exact_rod_element.hpp:48
std::vector< Matrix > mPreviousLocalDirectors
Definition: geometrically_exact_rod_element.hpp:184
std::vector< Matrix > mInitialLocalDirectors
Definition: geometrically_exact_rod_element.hpp:174
std::string Info() const override
Turn back information as a string.
Definition: geometrically_exact_rod_element.hpp:140
GeometryData::SizeType SizeType
Type for size.
Definition: geometrically_exact_rod_element.hpp:66
std::vector< Matrix > mCurrentLocalDirectorsVelocities
Definition: geometrically_exact_rod_element.hpp:194
std::vector< Matrix > mPreviousLocalDirectorsVelocities
Definition: geometrically_exact_rod_element.hpp:199
ConstitutiveLaw ConstitutiveLawType
Definition: geometrically_exact_rod_element.hpp:54
GeometryData::IntegrationMethod IntegrationMethod
Type definition for integration methods.
Definition: geometrically_exact_rod_element.hpp:60
BeamMathUtils< double > BeamMathUtilsType
Type definition for beam utilities.
Definition: geometrically_exact_rod_element.hpp:62
ConstitutiveLawType::StressMeasure StressMeasureType
StressMeasure from constitutive laws.
Definition: geometrically_exact_rod_element.hpp:58
ConstitutiveLawType::Pointer ConstitutiveLawPointerType
Pointer type for constitutive laws.
Definition: geometrically_exact_rod_element.hpp:56
LargeDisplacementBeamEMCElement::ElementDataType ElementDataType
Type for element variables.
Definition: geometrically_exact_rod_element.hpp:68
void PrintData(std::ostream &rOStream) const override
Print object's data.
Definition: geometrically_exact_rod_element.hpp:154
KRATOS_CLASS_INTRUSIVE_POINTER_DEFINITION(GeometricallyExactRodElement)
Counted pointer of GeometricallyExactRodElement.
std::vector< Matrix > mCurrentLocalDirectors
Definition: geometrically_exact_rod_element.hpp:179
void PrintInfo(std::ostream &rOStream) const override
Print information about this object.
Definition: geometrically_exact_rod_element.hpp:148
std::vector< Matrix > mInitialLocalDirectorsVelocities
Definition: geometrically_exact_rod_element.hpp:189
GeometricallyExactRodElement()
Definition: geometrically_exact_rod_element.hpp:205
Quaternion< double > QuaternionType
Type definition for quaternion.
Definition: geometrically_exact_rod_element.hpp:64
IntegrationMethod
Definition: geometry_data.h:76
std::size_t SizeType
Definition: geometry_data.h:173
Beam Element for 3D space dimension.
Definition: large_displacement_beam_emc_element.hpp:49
PointerVector is a container like stl vector but using a vector to store pointers to its data.
Definition: pointer_vector.h:72
ProcessInfo holds the current value of different solution parameters.
Definition: process_info.h:59
The serialization consists in storing the state of an object into a storage format like data file or ...
Definition: serializer.h:123
Matrix MatrixType
Definition: geometrical_transformation_utilities.h:55
Modeler::Pointer Create(const std::string &ModelerName, Model &rModel, const Parameters ModelParameters)
Checks if the modeler is registered.
Definition: modeler_factory.cpp:30
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
REF: G. R. Cowper, GAUSSIAN QUADRATURE FORMULAS FOR TRIANGLES.
Definition: mesh_condition.cpp:21
alpha
Definition: generate_convection_diffusion_explicit_element.py:113
def load(f)
Definition: ode_solve.py:307
def Alpha(n, j)
Definition: quadrature.py:93
Definition: beam_element.hpp:123