SDT-base         Contents     Functions         Previous Next     PDF Index

7.14  Constraint and fixed boundary condition handling

7.14.1  Theory and basic example

rigid links, FixDof, MPC entries, symmetry conditions, continuity constraints in CMS applications, ... all lead to problems of the form


The linear constraints [cint]{q(s)}=0 can be integrated into the problem using Lagrange multipliers or constraint elimination. Elimination is done by building a basis T for the kernel of the constraint equations, that is such that


Solving problem


is then strictly equivalent to solving (7.2).

The basis T is generated using [Case,NNode,model.DOF]=fe_case(model,'gett') where Case.T gives the T basis and Case.DOF describes the active or master DOFs (associated with the columns of T), while model.DOF or the Case.mDOF field when it exists, describe the full list of DOFs.

The NoT command option controls the need to return matrices, loads, ... in the full of unconstrained DOFs [M], {b} ... or constrained TTMT, TTb in fe_mknl, fe_load, ... .

For the two bay truss example, can be written as follows :

 model = femesh('test 2bay');
 model2=fe_case(model, ...         % defines a new case
   'FixDof','2-D motion',[.03 .04 .05]', ...  % 2-D motion
   'FixDof','Clamp edge',[1 2]');             % clamp edge
 Case=fe_case('gett',model)  % Notice the size of T and 
 fe_c(Case.DOF)                % display the list of active DOFs
 model = fe_mknl(model)
 % Now reassemble unconstrained matrices and verify the equality
 % of projected matrices


To compute resultants associated with constraint forces further details are needed. One separates active DOF qa which will be kept and slave DOF that will be eliminated qe so that the constraint is given by


The subspace with DOFs eliminated is spanned by


The problem that verifies constraints can also be written using Lagrange multipliers, which leads to


The response can be computed using elimination (equation (7.4)) and the forces needed to verify the constraints (resultant forces) can be assumed to be point forces associated with the eliminated DOF qe which leads to


A common approximation is to ignore viscous and inertia terms in the resultant, that is assume TeT Z(s) TTeT K T.

7.14.2  Local coordinates

In the presence of local coordinate systems (non zero value of DID in node column 3), the Case.cGL matrix built during the gett command, gives a local to global coordinate transformation


Constraints (mpc, rigid, ...) are defined in local coordinates, that is they correspond to


with qmaster,local master DOFs (DOFs in Case.DOF) defined in the local coordinate system and the Case.T corresponding to


As a result, model matrices before constraint elimination (with NoT) are expected to be defined in the global response system, while the projected matrix TTMT are defined in local coordinates.

celas use local coordinate information for their definition. cbush are defined in global coordinates but allow definition of orientation through the element CID.

An example of rigid links in local coordinates can be found in se_gimbal('ScriptCgl').

This built-in implementation may be impractical in practice as this generates a resolution in the local frame and a response in the global frame. It is thus not conforming to another classical formalism where the system is resolved in the global frame and response provided in the local frame.

In practice it is thus not recommended to exploit DID during analysis. It should only be used as intermediate steps in pre/post procedures.

The following structural elements support DID definition, rigid, celasand mass2.
rigidelements are treated as a case entry.
celasand mass2elements are projected in the global frame. Command feutilb CaseL2G will thus assemble them into a coupling superelement prior to removing DID entries. Few elements support DID providing elements matrices directly in the global frame, celasand mass2elements.

7.14.3  Enforced displacement

For a DofSet entry, one defines the enforced motion in Case.TIn and associated DOFs in Case.DofIn. The DOFs specified in Case.DofIn are then fixed in Case.T.

7.14.4  Resolution as MPC and penalization transformation

Whatever the constraint formulation it requires a transformation into an explicit multiple point constraint during the resolution. This transformation is accessible for RBE3 and rigidconstraints, a cleaned resolution of MPC constraints is also accessible using fe_mpc.

The output is of the format struct with fields

Such format allows the user to transform a constraint into a penalization using the constraint matrix as an observation matrix. One can indeed introduce for each constraint equation a force penalizing its violation through a coefficient kc so that {f}penal = kc [c]Nc × N {q}N × 1. This can be written by means of a symmetric stiffness matrix [kpenal]N × N = kc [c]T [I]Nc × Nc [c]Nc × N added to the system stiffness.

% Transformation of a constraint into a penalty
% Generation of a screw model example
model=demosdt('demoscrew layer 1 40 20 3 3 space .2 layer 2 40 20 4');
% Model a screw connection with a RBE3 constraint
% see sdtweb fe_case.html#ConnectionScrew
r1=struct('Origin',[20 10 0],'axis',[0 0 1],'radius',3, ...
 'planes',[0 0 111 1 0;3 0 111 1 0;   % [z0 type ProId zTol rTol]
           5.2 0 112 1 6; 7.2 0 112 1 6], ...
 'MatProId',[101 101],'rigid',[Inf abs('rigid')],'NewNode',0);
r1.planes(:,2)=1; % RBE3
% display the connection in feplot
cf=feplot(mo2);fecom('colordatamat -alpha .1');

% Replace RBE3 by a penalized coupling
% Get the constraint matrix
% remove the RBE3 constraint
% Generate the penalization stiffness with default kc
% Instance the superelement in the model
mo2=fesuper('seadd -unique 1 1 screw1',mo2,SE,[1 1]);

% Compute the system modes
def=fe_eig(cf.mdl,[5 20 1e3]);

7.14.5  Low level examples

A number of low level commands (feutil GetDof, FindNode, ...) and functions fe_c can be used to operate similar manipulations to what fe_case GetT does, but things become rapidly complex. For example

% Low level handling of constraints
 femesh('reset'); model = femesh('test 2bay');

 i1 = femesh('findnode x==0');
 adof1 = fe_c(mdof,i1,'dof',1);             % clamp edge
 adof2 = fe_c(mdof,[.03 .04 .05]','dof',1); % 2-D motion
 adof = fe_c(mdof,[adof1;adof2],'dof',2); 

 ind = fe_c(model.DOF,adof,'ind');
 mdof=mdof(ind); tmt=m(ind,ind); tkt=k(ind,ind);

Handling multiple point constraints (rigid links, ...) really requires to build a basis T for the constraint kernel. For rigid links the obsolete rigid function supports some constraint handling. The following illustrates restitution of a constrained solution on all DOFs

% Example of a plate with a rigid edge
model=femesh('testquad4 divide 10 10');femesh(model)

% select the rigid edge and set its properties
femesh(';selelt group1 & seledge & innode {x==0};addsel');
femesh('setgroup2 name rigid');
FEelt(femesh('findelt group2'),3)=123456;
FEelt(femesh('findelt group2'),4)=0;

% Assemble
model.DOF=feutil('getdof',model);% full list of DOFs
[tmt,tkt,mdof] = fe_mknl(model); % assemble constrained matrices
Case=fe_case(model,'gett');      % Obtain the transformation matrix

[md1,f1]=fe_eig(tmt,tkt,[5 10 1e3]); % compute modes on master DOF

def=struct('def',Case.T*md1,'DOF',model.DOF) % display on all DOFs
feplot(model,def); fecom(';view3;ch7')

©1991-2024 by SDTools
Previous Up Next