Constraint

Background

The Constraint class imposes linear kinematic relations between different degrees of freedom in the model. This object provides member functions that allow

• Constraint::GetSlaveInformation() : to obtain the degree-of-freedom to be constrained (slave)
• Constraint::GetMasterInformation() : the degree-of-freedoms list to be combined (masters)
• Constraint::GetCombinationFactors() : the coefficients in which the master dof will be combined (masters)

In the figure an example of a rigid diaphragm node k is shown in which two slave degree-of-freedom at node p and q denoted by \(U_\textrm{1}^{\textrm{p}}\) and \(U_\textrm{1}^{\textrm{q}}\) in the direction 1 are represented as a function of \(u_\textrm{1}\), \(u_\textrm{2}\), and \(u_\textrm{3}\) master degree-of-freedom.

REFERENCE:

• Carlos Felippa. "Introduction to Finite Element Methods (ASEN 5007)": Multifreedom Constraints I, Fall 2005.

Pre-Analysis

The python 01-Pre_Process/Method/Attach.py file provides with an interface to populate the Entities dictionary. A Constraint can be created using the addConstraint() function. This function will transform the provided information into json format to be parse in the Run-Analysis.

• addConstraint(tag, name, attributes):

  • tag : The identifier of the constraint, i.e., tag < -1
  • name : The constraint type that is being applied (Equal, General).
  • attributes : Dictionary containing the master node(s) information. The fields are
    • 'stag' : The slave node(s) tags to be constrained
    • 'sdof' : The slave degree-of-freedom to be constrained
    • 'mtag' : The master node(s) tags to be employed
    • 'mdof' : The master degree-of-freedom to be combined
    • 'factor': The combinational factors to be combined

  Example

  A CONSTRAINT can be defined using the python interface as follows:
  SVL.addConstraint(tag=-2, name='Equal', attributes={'stag': 4, 'sdof': 1, 'mtag': 3, 'mdof': 1})

  Application
  Please refer to the D07-ST_Lin_2DConstrainedBuilding_Elastic_Frame2.py file located at 03-Validations/01-Debugging/ to see an example on how to define equal constraint using the addConstraint function.

Also there are built-in constraints for the case of Rigid Diaphragm, Rigid Body or Rigid Links are available. These constraints can be easily constructed using the following functions implemented at 01-Pre_Process/Method/Attach.py:

• addDiaphragm(tag, attributes):

  • tag : The identifier of the diaphragm, i.e., tag > 1
  • attributes : Dictionary containing the master node(s) information. The fields are
    • 'tag' : The node tag that the diaphragm node will take (must be different other 'Nodes' defined)
    • 'list' : List of nodes that belong to the diaphragm
    • 'axis' : The Axis that is perpendicular to the diaphragm

  Application
  Please refer to the H05-ST_Lin_3DBuildingDiaphragm_ElasticPStress_Frame2_Shell4.py file located at 03-Validations/01-Debugging/ to see an example on how to define equal constraint using the addDiaphragm function.

• addRigidLink(tag, attributes):

  • tag : The identifier of the rigid link, i.e., tag > 1
  • attributes : Dictionary containing the master node(s) information. The fields are
    • 'tag' : The master rigid link node.
    • 'type' : Solid or Structural.
    • 'list' : List of slave nodes that this rigid link will connect.

  Application
  Please refer to the E05-ST_Lin_2DRigidLink_Elastic_Frame2.py file located at 03-Validations/01-Debugging/ to see an example on how to define equal constraint using the addRigidLink function.

• addRigidBody(tag, attributes):
  • tag : The identifier of the rigid body, i.e., tag > 1
  • attributes : Dictionary containing the master node(s) information. The fields are
    • 'tag' : The node tag that the rigid body node will take (must be different other 'Nodes' defined)
    • 'ndof' : The number of degree of freedom of the rigid body i.e., 3 (2D) and 6 (3D)
    • 'list' : List of slave nodes that belongs to the rigid body.
    • 'center' : The center of rotation of the rigid body

The python 01-Pre_Process/Method/Compute.py file transform a rigid link, diaphragm, and rigid body fields into SVL constraints.

• ApplyConstraints():
  This function enforces all constraints defines as rigid link, diaphragm, rigid body at the same time.

  Example

  The diaphragm constraints are enforced using the python interface as follows:
  SVL.DiaphragmConstraints()
  
  All special constraints such as rigid link, diaphragm, rigid body can be enforced at the same time as follows:
  SVL.ApplyConstraints()

On the contrary, the 01-Pre_Process/Method/Remove.py file provides with an interface to depopulate the Entities dictionary. For example, to remove an already define Constraint, Rigid Link, Diaphragm, or Rigid Body use:

• delConstraint(tag):
  • tag : The identifier of the node to be removed, i.e., tag < -1
• delRigidLink(tag):
  • tag : The identifier of the rigid link to be removed, i.e., tag > -1
• delDiaphragm(tag):
  • tag : The identifier of the diaphragm to be removed, i.e., tag > -1
• delRigidBody(tag):
  • tag : The identifier of the rigid body to be removed, i.e., tag > -1

Run-Analysis

The C++ 02-Run_Process/01-Node/Constraint.cpp file provides the class implementation. A Constraint is created using the built-in json parse-structure provided in the Driver.hpp. A Constraint is defined inside the "Constraint" json field indicating its "Tag" as follows,

• {
      "Constraints": {
          "Tag": {
              "name" : str,
              "attributes": {
                  "stag" : int,
                  "mtag" : [ ],
                  "factor" : [ ]
              }
          }
      }
  }
  

  Variable	Description
  Tag	A unique ( \(\leq -2\)) constraint number identifier.
  name	The constraint name: Equal, Diaphragm, RigidLink, RigidBody.
  stag	The associated total degree of freedom identifier (slave) of the constraint.
  mtag	Free-degree-of-freedom identifiers (masters) to be combined.
  factor	Coefficient values for each degree of freedom.

  
  

  Attention

  The Tag number ( \(\leq -2\)) identifier must coincide with the constrained free-degree-of-freedom number.

  The Constraint information is used in the Assembler to construct the transformation matrix \(\textbf{T} \in R^{nTotal \times nFree}\).

  The pair <mtag ( \(u_i\)), factor ( \(\alpha_i\))> are used to form the constraint as \(\displaystyle{U_j = \sum_{i=1}^{n} \alpha_i \, u_i}\).

  Note

  It is worth mentioning that the upper-case letter represents the total degree of freedom number to which the constraint will be enforced, and it will be identified with a negative identifier. In addition, the lower-case letter represent the free-degree-of-freedom numbers that define the constraint.

  Example

  A CONSTRAINT of the form: \(U_{12} = 1.0 \, u_{5}\) is constructed as:
  { "Constraints": { "-3": { "name" : Equal, "attributes": { "stag" : 12, "mtag" : [5], "factor" : [1.0] } } } }

  A CONSTRAINT of the form: \(U_{24} = 1.0 \, u_{12} + 4.0 \, u_{14}\) is constructed as:
  { "Constraints": { "-5": { "name" : General, "attributes": { "stag" : 24, "mtag" : [12,14], "factor" : [1.0,4.0] } } } }