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.
contact_residualbased_elimination_builder_and_solver_with_constraints.h
Go to the documentation of this file.
1 // KRATOS ______ __ __ _____ __ __ __
2 // / ____/___ ____ / /_____ ______/ /_/ ___// /________ _______/ /___ ___________ _/ /
3 // / / / __ \/ __ \/ __/ __ `/ ___/ __/\__ \/ __/ ___/ / / / ___/ __/ / / / ___/ __ `/ /
4 // / /___/ /_/ / / / / /_/ /_/ / /__/ /_ ___/ / /_/ / / /_/ / /__/ /_/ /_/ / / / /_/ / /
5 // \____/\____/_/ /_/\__/\__,_/\___/\__//____/\__/_/ \__,_/\___/\__/\__,_/_/ \__,_/_/ MECHANICS
6 //
7 // License: BSD License
8 // license: ContactStructuralMechanicsApplication/license.txt
9 //
10 // Main authors: Vicente Mataix Ferrandiz
11 //
12 //
13 
14 #pragma once
15 
16 // System includes
17 #include <unordered_set>
18 #include <unordered_map>
19 
20 // External includes
21 
22 // Project includes
24 
25 namespace Kratos
26 {
27 
30 
34 
38 
42 
46 
57 template<class TSparseSpace,
58  class TDenseSpace, //= DenseSpace<double>,
59  class TLinearSolver //= LinearSolver<TSparseSpace,TDenseSpace>
60  >
62  : public ResidualBasedEliminationBuilderAndSolverWithConstraints< TSparseSpace, TDenseSpace, TLinearSolver >
63 {
64 public:
67 
70 
73 
76 
79 
82  using TDataType = typename BaseType::TDataType;
93 
96 
101 
103  using DofType = typename BaseType::DofType;
105 
107  using DofPointerVectorType = std::vector<typename DofType::Pointer>;
108 
110  using SizeType = std::size_t;
111 
113  using IndexType = std::size_t;
114 
116  using IndexSetType = std::unordered_set<IndexType>;
117 
121 
125 
130  {
131  }
132 
137  typename TLinearSolver::Pointer pNewLinearSystemSolver,
138  Parameters ThisParameters
139  ) : BaseType(pNewLinearSystemSolver)
140  {
141  // Validate and assign defaults
142  ThisParameters = this->ValidateAndAssignParameters(ThisParameters, this->GetDefaultParameters());
143  this->AssignSettings(ThisParameters);
144  }
145 
149  typename TLinearSolver::Pointer pNewLinearSystemSolver)
150  : BaseType(pNewLinearSystemSolver)
151  {
152  }
153 
157  {
158  }
159 
163 
167 
173  typename BaseBuilderAndSolverType::Pointer Create(
174  typename TLinearSolver::Pointer pNewLinearSystemSolver,
175  Parameters ThisParameters
176  ) const override
177  {
178  return Kratos::make_shared<ClassType>(pNewLinearSystemSolver,ThisParameters);
179  }
180 
186  ModelPart& rModelPart
187  ) override
188  {
189  if(rModelPart.MasterSlaveConstraints().size() > 0)
190  SetUpSystemWithConstraints(rModelPart);
191  else
192  BaseSetUpSystem(rModelPart);
193  }
194 
204  typename TSchemeType::Pointer pScheme,
205  ModelPart& rModelPart
206  ) override
207  {
208  if(rModelPart.MasterSlaveConstraints().size() > 0)
209  SetUpDofSetWithConstraints(pScheme, rModelPart);
210  else
211  BaseType::SetUpDofSet(pScheme, rModelPart);
212  }
213 
219  {
220  Parameters default_parameters = Parameters(R"(
221  {
222  "name" : "contact_residual_elimination_builder_and_solver_with_constraints"
223  })");
224 
225  // Getting base class default parameters
226  const Parameters base_default_parameters = BaseType::GetDefaultParameters();
227  default_parameters.RecursivelyAddMissingParameters(base_default_parameters);
228  return default_parameters;
229  }
230 
235  static std::string Name()
236  {
237  return "contact_residual_elimination_builder_and_solver_with_constraints";
238  }
239 
243 
247 
251 
253 
254 protected:
257 
261 
265 
269 
277  typename TSchemeType::Pointer pScheme,
278  ModelPart& rModelPart
279  )
280  {
281  KRATOS_TRY;
282 
283  // We are going to enforce the existence of constraints for LM for each displacement dof
284  if (rModelPart.NodesBegin()->SolutionStepsDataHas(VECTOR_LAGRANGE_MULTIPLIER)) {
285  // Reorder constrains
286  IndexType constraint_id = 1;
287  for (auto& constrain : rModelPart.MasterSlaveConstraints()) {
288  constrain.SetId(constraint_id);
289  ++constraint_id;
290  }
291 
292  // Auxiliary dofs lists
293  DofsVectorType dof_list, second_dof_list; // NOTE: The second dof list is only used on constraints to include master/slave relations
294 
295  // Contributions to the system
296  LocalSystemMatrixType transformation_matrix = LocalSystemMatrixType(0, 0);
297  LocalSystemVectorType constant_vector = LocalSystemVectorType(0);
298 
299  // Reference constraint
300  const auto& r_clone_constraint = KratosComponents<MasterSlaveConstraint>::Get("LinearMasterSlaveConstraint");
301 
302  #pragma omp parallel firstprivate(transformation_matrix, constant_vector, dof_list, second_dof_list)
303  {
304  // Current process info
305  ProcessInfo& r_current_process_info = rModelPart.GetProcessInfo();
306 
307  // A buffer to store auxiliary constraints
308  ConstraintContainerType constraints_buffer;
309 
310  // Gets the array of constraints from the modeler
311  auto& r_constraints_array = rModelPart.MasterSlaveConstraints();
312  const int number_of_constraints = static_cast<int>(r_constraints_array.size());
313  #pragma omp for schedule(guided, 512)
314  for (int i = 0; i < number_of_constraints; ++i) {
315  auto it_const = r_constraints_array.begin() + i;
316 
317  // Gets list of Dof involved on every element
318  it_const->GetDofList(dof_list, second_dof_list, r_current_process_info);
319  it_const->CalculateLocalSystem(transformation_matrix, constant_vector, r_current_process_info);
320 
321  DofPointerVectorType slave_dofs, master_dofs;
322  bool create_lm_constraint = false;
323 
324  // We check if we have SLAVE nodes in the master dofs
325  bool slave_nodes_master_dof = false;
326  // Master DoFs
327  for (auto& p_dof : second_dof_list) {
328  if (IsDisplacementDof(*p_dof)) {
329  const IndexType node_id = p_dof->Id();
330  auto pnode = rModelPart.pGetNode(node_id);
331  if (pnode->Is(SLAVE)) { // The nodes computing contact are the slave nodes
332  slave_nodes_master_dof = true;
333  break;
334  }
335  }
336  }
337 
338  // Slave DoFs
339  for (auto& p_dof : dof_list) {
340  if (IsDisplacementDof(*p_dof)) {
341  const IndexType node_id = p_dof->Id();
342  const auto& r_variable = p_dof->GetVariable();
343  auto pnode = rModelPart.pGetNode(node_id);
344  if (pnode->IsNot(INTERFACE) || slave_nodes_master_dof) { // Nodes from the contact interface cannot be slave DoFs
345  if (r_variable == DISPLACEMENT_X) {
346  slave_dofs.push_back(pnode->pGetDof(VECTOR_LAGRANGE_MULTIPLIER_X));
347  } else if (r_variable == DISPLACEMENT_Y) {
348  slave_dofs.push_back(pnode->pGetDof(VECTOR_LAGRANGE_MULTIPLIER_Y));
349  } else if (r_variable == DISPLACEMENT_Z) {
350  slave_dofs.push_back(pnode->pGetDof(VECTOR_LAGRANGE_MULTIPLIER_Z));
351  }
352  } else { // We remove it
353  it_const->Set(TO_ERASE);
354  }
355  }
356  }
357  // Master DoFs
358  if (slave_nodes_master_dof) { // The nodes computing contact are the slave nodes
359  for (auto& p_dof : second_dof_list) {
360  if (IsDisplacementDof(*p_dof)) {
361  const IndexType node_id = p_dof->Id();
362  const auto& r_variable = p_dof->GetVariable();
363  auto pnode = rModelPart.pGetNode(node_id);
364  if (r_variable == DISPLACEMENT_X) {
365  master_dofs.push_back(pnode->pGetDof(VECTOR_LAGRANGE_MULTIPLIER_X));
366  } else if (r_variable == DISPLACEMENT_Y) {
367  master_dofs.push_back(pnode->pGetDof(VECTOR_LAGRANGE_MULTIPLIER_Y));
368  } else if (r_variable == DISPLACEMENT_Z) {
369  master_dofs.push_back(pnode->pGetDof(VECTOR_LAGRANGE_MULTIPLIER_Z));
370  }
371  }
372  }
373  }
374 
375  // We check if we create constraints
376  if ((slave_dofs.size() == dof_list.size()) &&
377  (master_dofs.size() == second_dof_list.size())) {
378  create_lm_constraint = true;
379  }
380 
381  // We create the new constraint
382  if (create_lm_constraint) {
383  auto p_constraint = r_clone_constraint.Create(constraint_id + i + 1, master_dofs, slave_dofs, transformation_matrix, constant_vector);
384  (constraints_buffer).insert((constraints_buffer).begin(), p_constraint);
385  }
386  }
387 
388  // We transfer
389  #pragma omp critical
390  {
391  rModelPart.AddMasterSlaveConstraints(constraints_buffer.begin(),constraints_buffer.end());
392  }
393  }
394  }
395 
396  // We remove the marked constraints
397  rModelPart.RemoveMasterSlaveConstraintsFromAllLevels(TO_ERASE);
398 
399  KRATOS_INFO_IF("ContactResidualBasedEliminationBuilderAndSolverWithConstraints", (this->GetEchoLevel() > 0)) <<
400  "Model part after creating new constraints" << rModelPart << std::endl;
401 
402  // Calling base SetUpDofSetWithConstraints
403  BaseType::SetUpDofSetWithConstraints(pScheme, rModelPart);
404 
405  KRATOS_CATCH("");
406  }
407 
412  void AssignSettings(const Parameters ThisParameters) override
413  {
414  BaseType::AssignSettings(ThisParameters);
415  }
416 
420 
424 
428 
430 
431 private:
434 
438 
442 
446 
451  void SetUpSystemWithConstraints(ModelPart& rModelPart)
452  {
453  KRATOS_TRY
454 
455  // First we set up the system of equations without constraints
456  BaseSetUpSystem(rModelPart);
457 
458  // Add the computation of the global ids of the solvable dofs
459  IndexType counter = 0;
460  for (auto& dof : BaseType::mDofSet) {
461  if (dof.EquationId() < BaseType::mEquationSystemSize) {
462  auto it = BaseType::mDoFSlaveSet.find(dof);
463  if (it == BaseType::mDoFSlaveSet.end()) {
464  ++counter;
465  }
466  }
467  }
468 
469  // The total system of equations to be solved
471 
472  KRATOS_CATCH("ContactResidualBasedEliminationBuilderAndSolverWithConstraints::FormulateGlobalMasterSlaveRelations failed ..");
473  }
474 
479  void BaseSetUpSystem(ModelPart& rModelPart)
480  {
485  // We create a set of dofs of the displacement slave dofs with LM associated
486  std::unordered_map<IndexType, IndexSetType> set_nodes_with_lm_associated;
487  if (rModelPart.HasSubModelPart("Contact"))
488  set_nodes_with_lm_associated.reserve(rModelPart.GetSubModelPart("Contact").NumberOfNodes());
489  // Allocating auxiliary parameters
491  // We start the dof loop
492  for (auto& i_dof : BaseType::mDofSet) {
493  node_id = i_dof.Id();
494  if (IsLMDof(i_dof))
495  set_nodes_with_lm_associated.insert({node_id, IndexSetType({})});
496  }
497 
498  // Auxiliary keys
499  const IndexType key_lm_x = VECTOR_LAGRANGE_MULTIPLIER_X.Key();
500  const IndexType key_lm_y = VECTOR_LAGRANGE_MULTIPLIER_Y.Key();
501  const IndexType key_lm_z = VECTOR_LAGRANGE_MULTIPLIER_Z.Key();
502 
503  // We see which LM block
504  for (auto& i_dof : BaseType::mDofSet) {
505  node_id = i_dof.Id();
506  auto it = set_nodes_with_lm_associated.find(node_id);
507  if ( it != set_nodes_with_lm_associated.end()) {
508  if (i_dof.IsFixed()) {
509  const auto& r_variable = i_dof.GetVariable();
510  auto& aux_set = (it->second);
511  if (r_variable == DISPLACEMENT_X) {
512  aux_set.insert(key_lm_x);
513  } else if (r_variable == DISPLACEMENT_Y) {
514  aux_set.insert(key_lm_y);
515  } else if (r_variable == DISPLACEMENT_Z) {
516  aux_set.insert(key_lm_z);
517  }
518  }
519  }
520  }
521 
522  // We do now the loop over the dofs
523  for (auto& i_dof : BaseType::mDofSet) {
524  if (i_dof.IsFree()) {
525  node_id = i_dof.Id();
526  auto it = set_nodes_with_lm_associated.find(node_id);
527  if (it != set_nodes_with_lm_associated.end()) {
528  auto& aux_set = it->second;
529  if (aux_set.find((i_dof.GetVariable()).Key()) != aux_set.end()) {
530  i_dof.FixDof();
531  }
532  }
533  }
534  }
535 
536  BaseType::SetUpSystem(rModelPart);
537  }
538 
544  static inline bool IsDisplacementDof(const DofType& rDoF)
545  {
546  const auto& r_variable = rDoF.GetVariable();
547  if (r_variable == DISPLACEMENT_X ||
548  r_variable == DISPLACEMENT_Y ||
549  r_variable == DISPLACEMENT_Z) {
550  return true;
551  }
552 
553  return false;
554  }
555 
561  static inline bool IsLMDof(const DofType& rDoF)
562  {
563  const auto& r_variable = rDoF.GetVariable();
564  if (r_variable == VECTOR_LAGRANGE_MULTIPLIER_X ||
565  r_variable == VECTOR_LAGRANGE_MULTIPLIER_Y ||
566  r_variable == VECTOR_LAGRANGE_MULTIPLIER_Z) {
567  return true;
568  }
569 
570  return false;
571  }
572 
576 
580 
584 
586 
587 }; /* Class ContactResidualBasedEliminationBuilderAndSolverWithConstraints */
588 
590 
593 
594 
596 
597 } /* namespace Kratos.*/
Current class provides an implementation for the base builder and solving operations.
Definition: builder_and_solver.h:64
std::size_t IndexType
Definition of the index type.
Definition: builder_and_solver.h:76
TSparseSpace::VectorType TSystemVectorType
Definition of the vector size.
Definition: builder_and_solver.h:85
ModelPart::NodesContainerType NodesArrayType
The containers of the entities.
Definition: builder_and_solver.h:109
TSparseSpace::MatrixType TSystemMatrixType
Definition of the sparse matrix.
Definition: builder_and_solver.h:82
ModelPart::ConditionsContainerType ConditionsArrayType
Definition: builder_and_solver.h:111
virtual Parameters ValidateAndAssignParameters(Parameters ThisParameters, const Parameters DefaultParameters) const
This method validate and assign default parameters.
Definition: builder_and_solver.h:767
TDenseSpace::MatrixType LocalSystemMatrixType
The local matrix definition.
Definition: builder_and_solver.h:94
TSparseSpace::VectorPointerType TSystemVectorPointerType
Definition of the pointer to the vector.
Definition: builder_and_solver.h:91
TSparseSpace::DataType TDataType
Definition of the data type.
Definition: builder_and_solver.h:79
DofsArrayType mDofSet
Pointer to the linear solver.
Definition: builder_and_solver.h:739
TDenseSpace::VectorType LocalSystemVectorType
The local vector definition.
Definition: builder_and_solver.h:97
TSparseSpace::MatrixPointerType TSystemMatrixPointerType
Definition of the pointer to the sparse matrix.
Definition: builder_and_solver.h:88
std::size_t SizeType
Definition of the size type.
Definition: builder_and_solver.h:73
int GetEchoLevel() const
It returns the echo level.
Definition: builder_and_solver.h:674
unsigned int mEquationSystemSize
Flag taking in account if it is needed or not to calculate the reactions.
Definition: builder_and_solver.h:747
ModelPart::ElementsContainerType ElementsArrayType
Definition: builder_and_solver.h:110
Current class provides an implementation for contact builder and solving operations....
Definition: contact_residualbased_elimination_builder_and_solver_with_constraints.h:63
Parameters GetDefaultParameters() const override
This method provides the defaults parameters to avoid conflicts between the different constructors.
Definition: contact_residualbased_elimination_builder_and_solver_with_constraints.h:218
typename BaseType::LocalSystemMatrixType LocalSystemMatrixType
Definition: contact_residualbased_elimination_builder_and_solver_with_constraints.h:87
ContactResidualBasedEliminationBuilderAndSolverWithConstraints()
Default constructor.
Definition: contact_residualbased_elimination_builder_and_solver_with_constraints.h:129
void SetUpSystem(ModelPart &rModelPart) override
It organises the dofset in order to speed up the building phase.
Definition: contact_residualbased_elimination_builder_and_solver_with_constraints.h:185
void SetUpDofSetWithConstraints(typename TSchemeType::Pointer pScheme, ModelPart &rModelPart)
Builds the list of the DofSets involved in the problem by "asking" to each element and condition its ...
Definition: contact_residualbased_elimination_builder_and_solver_with_constraints.h:276
KRATOS_CLASS_POINTER_DEFINITION(ContactResidualBasedEliminationBuilderAndSolverWithConstraints)
Pointer definition of ContactResidualBasedEliminationBuilderAndSolverWithConstraints.
BaseBuilderAndSolverType::Pointer Create(typename TLinearSolver::Pointer pNewLinearSystemSolver, Parameters ThisParameters) const override
Create method.
Definition: contact_residualbased_elimination_builder_and_solver_with_constraints.h:173
ContactResidualBasedEliminationBuilderAndSolverWithConstraints(typename TLinearSolver::Pointer pNewLinearSystemSolver)
Definition: contact_residualbased_elimination_builder_and_solver_with_constraints.h:148
std::unordered_set< IndexType > IndexSetType
Index set definition.
Definition: contact_residualbased_elimination_builder_and_solver_with_constraints.h:116
static std::string Name()
Returns the name of the class as used in the settings (snake_case format)
Definition: contact_residualbased_elimination_builder_and_solver_with_constraints.h:235
ContactResidualBasedEliminationBuilderAndSolverWithConstraints(typename TLinearSolver::Pointer pNewLinearSystemSolver, Parameters ThisParameters)
Default constructor. (with parameters)
Definition: contact_residualbased_elimination_builder_and_solver_with_constraints.h:136
ModelPart::MasterSlaveConstraintContainerType ConstraintContainerType
General containers type definitions.
Definition: contact_residualbased_elimination_builder_and_solver_with_constraints.h:95
typename BaseType::LocalSystemVectorType LocalSystemVectorType
Definition: contact_residualbased_elimination_builder_and_solver_with_constraints.h:86
typename BaseType::DofType DofType
DoF types definition.
Definition: contact_residualbased_elimination_builder_and_solver_with_constraints.h:103
void AssignSettings(const Parameters ThisParameters) override
This method assigns settings to member variables.
Definition: contact_residualbased_elimination_builder_and_solver_with_constraints.h:412
std::vector< typename DofType::Pointer > DofPointerVectorType
The DoF pointer vector type definition.
Definition: contact_residualbased_elimination_builder_and_solver_with_constraints.h:107
~ContactResidualBasedEliminationBuilderAndSolverWithConstraints() override
Definition: contact_residualbased_elimination_builder_and_solver_with_constraints.h:156
std::size_t IndexType
The index type.
Definition: contact_residualbased_elimination_builder_and_solver_with_constraints.h:113
void SetUpDofSet(typename TSchemeType::Pointer pScheme, ModelPart &rModelPart) override
Builds the list of the DofSets involved in the problem by "asking" to each element and condition its ...
Definition: contact_residualbased_elimination_builder_and_solver_with_constraints.h:203
Dof represents a degree of freedom (DoF).
Definition: dof.h:86
static const TComponentType & Get(const std::string &rName)
Retrieves a component with the specified name.
Definition: kratos_components.h:114
This class aims to manage meshes for multi-physics simulations.
Definition: model_part.h:77
MasterSlaveConstraintContainerType & MasterSlaveConstraints(IndexType ThisIndex=0)
Definition: model_part.h:654
void RemoveMasterSlaveConstraintsFromAllLevels(Flags IdentifierFlag=TO_ERASE)
It erases all constraints identified by "IdentifierFlag" by removing the pointer.
Definition: model_part.cpp:1411
NodeIterator NodesBegin(IndexType ThisIndex=0)
Definition: model_part.h:487
MeshType::MasterSlaveConstraintContainerType MasterSlaveConstraintContainerType
Definition: model_part.h:219
ProcessInfo & GetProcessInfo()
Definition: model_part.h:1746
void AddMasterSlaveConstraints(std::vector< IndexType > const &MasterSlaveConstraintIds, IndexType ThisIndex=0)
Definition: model_part.cpp:1200
NodeType::Pointer pGetNode(IndexType NodeId, IndexType ThisIndex=0)
Definition: model_part.h:421
This class provides to Kratos a data structure for I/O based on the standard of JSON.
Definition: kratos_parameters.h:59
void RecursivelyAddMissingParameters(const Parameters &rDefaultParameters)
This function is designed to verify that the parameters under testing contain at least all parameters...
Definition: kratos_parameters.cpp:1457
A sorted associative container similar to an STL set, but uses a vector to store pointers to its data...
Definition: pointer_vector_set.h:72
iterator find(const key_type &Key)
Find an element with the specified key.
Definition: pointer_vector_set.h:678
ProcessInfo holds the current value of different solution parameters.
Definition: process_info.h:59
Element::DofsVectorType DofsVectorType
Definition: residualbased_elimination_builder_and_solver.h:105
Element::EquationIdVectorType EquationIdVectorType
Definition of the equation id vector.
Definition: residualbased_elimination_builder_and_solver.h:104
Current class provides an implementation for standard builder and solving operations.
Definition: residualbased_elimination_builder_and_solver_with_constraints.h:93
PointerVectorSet< Element, IndexedObject > ElementsContainerType
Additional definitions.
Definition: residualbased_elimination_builder_and_solver_with_constraints.h:130
Element::EquationIdVectorType EquationIdVectorType
Definition: residualbased_elimination_builder_and_solver_with_constraints.h:131
void SetUpDofSet(typename TSchemeType::Pointer pScheme, ModelPart &rModelPart) override
Builds the list of the DofSets involved in the problem by "asking" to each element and condition its ...
Definition: residualbased_elimination_builder_and_solver_with_constraints.h:302
BaseType::TSystemMatrixPointerType TSystemMatrixPointerType
Definition: residualbased_elimination_builder_and_solver_with_constraints.h:122
std::unordered_set< IndexType > IndexSetType
Set definition.
Definition: residualbased_elimination_builder_and_solver_with_constraints.h:140
DofType::Pointer DofPointerType
Definition: residualbased_elimination_builder_and_solver_with_constraints.h:137
BaseType::TDataType TDataType
Definition: residualbased_elimination_builder_and_solver_with_constraints.h:116
BaseType::NodesArrayType NodesArrayType
Definition: residualbased_elimination_builder_and_solver_with_constraints.h:125
void SetUpSystem(ModelPart &rModelPart) override
Organises the dofset in order to speed up the building phase.
Definition: residualbased_elimination_builder_and_solver_with_constraints.h:220
BaseType::ConditionsArrayType ConditionsArrayType
Definition: residualbased_elimination_builder_and_solver_with_constraints.h:127
BaseType::ElementsArrayType ElementsArrayType
Definition: residualbased_elimination_builder_and_solver_with_constraints.h:126
Element::DofsVectorType DofsVectorType
Definition: residualbased_elimination_builder_and_solver_with_constraints.h:132
BaseType::TSystemVectorType TSystemVectorType
Definition: residualbased_elimination_builder_and_solver_with_constraints.h:119
BaseType::LocalSystemMatrixType LocalSystemMatrixType
Definition: residualbased_elimination_builder_and_solver_with_constraints.h:121
BaseType::TSchemeType TSchemeType
Definition of the classes from the base class.
Definition: residualbased_elimination_builder_and_solver_with_constraints.h:115
SizeType mDoFToSolveSystemSize
The set containing the slave DoF of the system.
Definition: residualbased_elimination_builder_and_solver_with_constraints.h:390
DofsArrayType mDoFSlaveSet
The set containing the fixed master DoF of the system.
Definition: residualbased_elimination_builder_and_solver_with_constraints.h:389
NodeType::DofType DofType
DoF types definition.
Definition: residualbased_elimination_builder_and_solver_with_constraints.h:136
Parameters GetDefaultParameters() const override
This method provides the defaults parameters to avoid conflicts between the different constructors.
Definition: residualbased_elimination_builder_and_solver_with_constraints.h:317
void AssignSettings(const Parameters ThisParameters) override
This method assigns settings to member variables.
Definition: residualbased_elimination_builder_and_solver_with_constraints.h:1456
BaseType::TSystemVectorPointerType TSystemVectorPointerType
Definition: residualbased_elimination_builder_and_solver_with_constraints.h:123
void SetUpDofSetWithConstraints(typename TSchemeType::Pointer pScheme, ModelPart &rModelPart)
Builds the list of the DofSets involved in the problem by "asking" to each element and condition its ...
Definition: residualbased_elimination_builder_and_solver_with_constraints.h:577
BaseType::DofsArrayType DofsArrayType
Definition: residualbased_elimination_builder_and_solver_with_constraints.h:117
BaseType::LocalSystemVectorType LocalSystemVectorType
Definition: residualbased_elimination_builder_and_solver_with_constraints.h:120
BaseType::TSystemMatrixType TSystemMatrixType
Definition: residualbased_elimination_builder_and_solver_with_constraints.h:118
This class provides the implementation of the basic tasks that are needed by the solution strategy.
Definition: scheme.h:56
#define KRATOS_CATCH(MoreInfo)
Definition: define.h:110
#define KRATOS_TRY
Definition: define.h:109
std::size_t IndexType
The definition of the index type.
Definition: key_hash.h:35
#define KRATOS_INFO_IF(label, conditional)
Definition: logger.h:251
end
Definition: DEM_benchmarks.py:180
REF: G. R. Cowper, GAUSSIAN QUADRATURE FORMULAS FOR TRIANGLES.
Definition: mesh_condition.cpp:21
int dof
Definition: ode_solve.py:393
int node_id
Definition: read_stl.py:12
int counter
Definition: script_THERMAL_CORRECT.py:218
integer i
Definition: TensorModule.f:17