# Problem Solving Procedures

Note : Many of these features are new to Aladdin 2.0.

### MASS and STIFFNESS MATRICES

Stiff()

This function calculates the linear elastic stiffness matrix.

Mass( [ massflag ] )

This function calculates the system mass matrix. The {\tt massflag} argument is optional and equals:

```    massflag = [ 1]  .... compute lumped mass matrix.
massflag = [-1]  .... compute consistent mass matrix.
```

Example : In the following script of code, mass is the global mass matrix, stiff is the global stiffness matrix, and eload is a vector of external nodal loads applied to the finite element global degrees of freedom.

```    /* Form Mass matrix, stiffness matrix, and external load vector */

mass  = Mass();
stiff = Stiff();
```

The three functions Mass(), Stiff(), and ExternalLoad() should be called only after the function call to EndMesh().

### RETRIEVING INFORMATION FROM ALADDIN DATABASE

Aladdin has an ensemble of functions for retrieving information from the database that may be required for problem post processing. Post processing activities include "design rule checking", "preparation of the finite element output for plotting" and "correction of internal element forces to account for uniform/distributed element load".

FINITE ELEMENT MESH

GetCoord( [ nodeno] )

GetCoord() takes as its input a (1x1) matrix containing the node number. For two-dimensional finite element problems, GetCoord() returns a 1x2 matrix,

```    ( m[1][1], m[1][2] ) = (x,y).
```

A 1x3 matrix is returned for three-dimensional elements,

```    ( m[1][1], m[1][2], m[1][3] ) = (x,y,z).
```

Example :

GetDof( [ nodeno ] )

GetDof() is short for ``get the matching global degrees of freedom number for a node.'' It returns a (1xn) matrix, n equals to the number of degrees of freedom in the node. For two-dimensional beam-column elements, n = 3, and

```    ( m[1][1], m[1][2], m[1][3] ) =
(  dof_dx,  dof_dy,  dof_rz );
```

For the three-dimensional frame element, n = 6, and

```    ( m[1][1], m[1][2], m[1][3], m[1][4], m[1][5], m[1][6] ) =
(  dof_dx,  dof_dy,  dof_dz,  dof_rx,  dof_ry,  dof_rz ).
```

A negative number in the output matrix indicates the associated degree of freedom is fixed.

Example :

GetNode( [ elmtno ] )

GetNode() retrieves a (1xn) matrix of node numbers connected to finite element elmtno . n equals to the number of nodes in the element. For example, n = 2 for 2D and 3D beam element, and n = 4 for the 4-node shell element.

The matrix will be in the same order as you input the nodes connection in AddElmt() .

Example :

MATERIAL AND SECTION PROPERTIES

Two functions, GetSection() and GetMaterial() are provided for the retrieval of section and material properties.

GetMaterial( [ elmtno ] )

This function takes as its argument, a 1x1 matrix containing the element no. It returns a 10x1 matrix of material properties:

```    ======================================================================
Matrix Element    Quantity     Description
======================================================================
[1][1]           E     Young's modulus
[2][1]           G     Shear modulus
[3][1]          Fy     Yield stress
[4][1]          ET     Tangent Young's Modulus
[5][1]          nu     Poission's ratio
[6][1]     density     Material density
[7][1]          Fu     Ultimate stress
[8][1]  thermal[0]     x-direction coeff. of thermal expansion
[9][1]  thermal[1]     y-direction coeff. of thermal expansion
[10][1]  thermal[2]     z-direction coeff. of thermal expansion
======================================================================
```

GetSection( [ elmtno ] )

GetSection() takes as its input argument, a 1 by 1 matrix containing the element no. It returns a 16 by 1 matrix of section properties, namely

```    ===============================================================
Matrix Element   Quantity     Description
===============================================================
[1][1]        Ixx     Moment of inertia about x-x axis.
[2][1]        Iyy     Moment of inertia about y-y axis.
[3][1]        Izz     Moment of inertia about z-z axis.
[4][1]        Ixz     Product of inertia x-z.
[5][1]        Ixy     Product of inertia x-y.
[6][1]        Iyz     Product of inertia y-z.
[7][1]     weight     Section weight
[8][1]         bf     Width of flange
[9][1]         tf     Thickness of flange
[10][1]      depth     Section depth
[11][1]       area     Section area
[12][1]  thickness     Thickness of plate
[13][1]  tor_const     Torsional Constant J
[14][1]         rT     Section radius of gyration
[15][1]      width     Section width
[16][1]         tw     Thickness of web
===============================================================
```

Example :

SYSTEM MATRICES AND BEHAVIOR

GetDispl( [ nodeno ], displ_m )

GetDispl() is short for ``get displacement,'' and takes as input, a node number, nodeno, and the calculated displacement matrix displ_m .

It returns a (1xn) matrix, where n equals to the number of degrees of freedom in the node. For a two-dimensional beam element, for example, n = 3 and

```    ( m[1][1], m[1][2], m[1][3] ) = ( displ_x, displ_y, rot_z)
```

Similarly, for three-dimensional frame elements, n = 6, and

```    ( m[1][1], m[1][2], m[1][3], m[1][4], m[1][5], m[1][6] ) =
( displ_x, displ_y, displ_z,   rot_x,   rot_y,   rot_z ).
```

Example : Let's suppose that the displacements in a structure have been calculated with

```    displ = Solve (stiffness, external_load );
```

The matrix "displ" store the structural displacements. The displacements at node "ii" can be retrieved by simply giving the command:

```    nodal_displ = GetDispl( [ ii ], displ);
```

GetStress( [ elmtno ], displ_matrix )

GetStress() accepts as its input, an element number and the calculated displacement matrix. This function returns a (mxn) matrix,

```    m = the number of nodes in the element,
n = the number of degrees of freedom in a node.
```

containing the nodal forces for the matrix.

Example : (mxn)=(2x3) for 2D beam element,

```                1       2       3
node 1    Fx1     Fy1     Mz1
node 2    Fx2     Fy2     Mz2

(mxn)=(2x6) for 2D beam element,

1       2       3       4       5       6
node 1    Fx1     Fy1     Fz1     Mx1     My1     Mz1
node 2    Fx2     Fy2     Fz2     Mx2     My2     Mz2
```

The order of the nodes 1,2... is defined in the nodes connection matrix in AddElmt() .

Note. In Aladdin 1.0, this function only works for 2D and 3D beam elements. In Aladdin 2.0, works for the 2D and 3D beam elements, and the Plane Stress/Plain Strain element. We are currently adding this feature to the two- and three-d fiber elements.

GetMass( [ elmtno ] )

This function returns the mass matrix matrix corresponding to the element number elmtno .

Example : Details coming soon ....

GetStiffness( [ elmtno ] )

This function returns the element stiffness matrix corresponding to the element number elmtno .

Example : Details coming soon ....

### NONLINEAR ANALYSIS

Aladdin 2 and 3 contain functions for the solution of nonlinear finite element problems. (At this point, the implementation is rather restricted, and works for only a few finite element types).

ElmtStateDet() : This function computes the element-level resisting forces and corresponding element deformations.

Note. In Aladdin (version 3) this function is a bit of a hack and currently serves several purposes:

• For FIBER finite elements, it determines the element-level forces and deformations due to nonlinear material deformations.

• For geometrically exact finite elements, the current displacement vector "d_displ" is copied to the "array->displ" working array, and hence can be used in the formulation of stiffness matrices that are displacement dependent.

We need to fix the second item later!!!

UpdateResponse() : Save element response to frame data structures. This includes:

• Flag settings, stresses and strains for each fiber.

• Nodal displacements for geometrically exact finite elememts.

Developed in July 1996 by Mark Austin