modal

README

[[file:../README.org][FrameFEA - Main README]]

* Package modal performs dynamic analysis
The FrameFEA analysis will optionally include a dynamic analysis for natural modes of vibration. Dynamic properties may be obtained for the un-stressed or the stressed structure by either neglecting or including geometric stiffness effects. The mass may be modeled using either the consistent mass matrix or the lumped mass matrix.

The natural frequencies and mode-shapes of the structural frame may be computed from the stiffness and mass matrices using either the Stodola method or the Jacobi method. The solution method and the convergence tolerance for these iterative methods is specified in the Input Data file. Mass density of each element is specified along with other element data. If a dynamic modal analysis is to be carried out, the Input Data file may also specify any additional mass carried by frame elements, and extra mass or inertia concentrated at nodal points. A specified set of modes may be animated within gnuplot.

FrameFEA has the capability of computing the natural frequencies and mode-shapes of frames that are fully restrained, partially restrained, or completely un-restrained. Partially restrained frames have up to six independent rigid body modes. A completely un-restrained frame has six independent rigid body modes. Stiffness matrices for partially restrained and completely unrestrained structures are not invertible. Such structural configurations cannot carry static loads. Furthermore, the numerical methods used in computing the natural frequencies and mode shapes presume that the stiffness matrix is invertible. A numerical trick called "frequency shifting" overcomes this difficulty. Presuming the mass matrix [M] is invertible, and given a sufficiently large positive scalar value s, the matrix [[K] + s[M]] is invertible, even if the stiffness matrix [K] is not invertible. So, for the purpose of computing the natural frequencies of frames with rigid-body modes, [K] is replaced by [[K]+s[M]]. The desired natural frequencies are shifted by an amount equal to the "shift" variable, s, and can be shifted back, after the natural frequencies and mode shapes are found. The mode shapes are un-changed by this "shifting." If natural frequencies are computed as "nan" (not a number) try increasing the value of the frequency shift variable either in the Input Data file or using the -f command line option. Structural models that are partially restrained or unrestrained should not include geometric stiffness effects.

A Sturm check is carried out to determine if any eigen-values were missed.

If a dynamic analysis is not to be performed, simply set the nM variable (the number of desired modes) to zero (0). If nM is set to zero, FrameFEA will stop reading the Input file at this point. If nM is set to zero, there is no need to provide numerical values for the quantities after the nM variable.

Natural frequencies and mass-normalized mode-shapes of the lower modes may be obtained using a generalized Jacobi sub-space iteration procedure or a Stodola iteration procedure. Jacobi-subspace iterations are stopped when the frequency convergence error is less than the specified frequency convergence tolerance. The frequency convergence error is defined here as: 

#+begin_export latex
\begin{equation}
error = | f_{N}^{(i)} - f_{N}^{(i-1)} | / f_{N}^{(i)} 
#+end_export

where:
- $f_{N}^{(i)}$ is the highest natural frequency computed at iteration i ,
- $f_{N}^{(i-1)}$ is the highest natural frequency computed at iteration i-1

Documentation

Index

• func AssembleM(M [][]float64, DoF, nN, nE int, xyz []femath.Vec3, r, L []float64, ...) (finalErr error)
• type Input
  • func (inData *Input) DoF() int
  • func (inData *Input) Run(K [][]float64) (Kd, Md, M, V [][]float64, f []float64, iter int, finalErr error)

Functions

func AssembleM

func AssembleM(M [][]float64, DoF, nN, nE int, xyz []femath.Vec3, r, L []float64, N1, N2 []int, Ax, Jx, Iy, Iz, p, d, EMs, NMs, NMx, NMy, NMz []float64, lump bool) (finalErr error)

AssembleM assembles the global mass matrix from element mass & inertia 24nov98

double **M,	/**< mass matrix				*/
int DoF,	/**< number of degrees of freedom		*/
int nN, int nE,	/**< number of nodes, number of frame elements	*/
vec3 *xyz,	/** XYZ locations of each node			*/
float *r,	/**< rigid radius of every node		*/
double *L,	/**< length of each frame element, effective	*/
int *N1, int *N2, /**< node connectivity			*/
float *Ax,	/**< node connectivity				*/
float *Jx, float *Iy, float *Iz,	/**< section area inertias*/
float *p,	/**< roll angle, radians			*/
float *d,	/**< frame element density			*/
float *EMs,	/**< extra frame element mass			*/
float *NMs,	/**< node mass					*/
float *NMx, float *NMy, float *NMz,	/**< node inertias	*/
int lump,	/**< 1: lumped mass matrix, 0: consistent mass	*/

Types

type Input

type Input struct {

	// Node Info
	NumNodes   int           // number of Nodes
	Xyz        []femath.Vec3 // {NumNodes} X,Y,Z node coordinates (global)
	NodeRadius []float64     // {NumNodes} node size radius, for finite sizes

	// Reaction Info
	ReactedDof []bool // {Dof} Dof's with reactions formally "r"

	// Element Info
	NumElems    int       // Number of Frame Elements
	N1, N2      []int     // {NumElems} begin and end node numbers
	Ax          []float64 // {NumElems} cross section area
	Jx, Iy, Iz  []float64 // {NumElems} section inertias
	ElemRoll    []float64 // {NumElems} roll of each member, radians
	ElemDensity []float64 // {NumElems} member densities

	L []float64 //  node-to-node length of each element (calculated)

	// Dynamic Analysis Data
	NumModes       int       // number of desired modes
	ModalMethod    int       // modal analysis method: 1=Jacobi-Subspace or 2=Stodola
	LumpFlag       bool      // true: lumped mass matrix or false: consistent mass matrix
	ModalTol       float64   // convergence tolerance for modal analysis
	ModalFreqShift float64   // modal frequency shift for unrestrained structures, shift-factor for rigid-body-modes
	NMs            []float64 // {NumNodes} node mass for each node
	NMx            []float64 // {NumNodes} node inertia about global X axis
	NMy            []float64 // {NumNodes} node inertia about global Y axis
	NMz            []float64 // {NumNodes} node inertia about global Z axis
	EMs            []float64 // {NumElems} lumped mass for each frame element
	// contains filtered or unexported fields
}

Input contains the necessary input data to run a modal analysis with the exception of the stiffness matrix.

func (*Input) DoF

func (inData *Input) DoF() int

DoF returns the degrees of freedom of the model described by the ModalInput structure (6*NumNodes).

func (*Input) Run

func (inData *Input) Run(K [][]float64) (Kd, Md, M, V [][]float64, f []float64, iter int, finalErr error)

Run performs a modal analysis of the model, and returns the dynamic stiffness and mass matricies, and the resonant mode-shapes and frequencies.