Contents Functions PDF Index 
Purpose
Transformations from normal mode models to other model formats.
Syntax
[res,po,psib,cpsi] = nor2res( ... ) % sdtweb('res') for format RES = nor2res( ... ) [a,b,c,d] = nor2ss ( ... ) % sdtweb('ss') for format SYS = nor2ss ( ... ) xf = nor2xf ( ... ) % sdtweb('xf') for format ... = nor2.. (DEF,MODEL, ... ) % high level input ... = nor2.. (DEF,ga,MODEL, ... ) ... = nor2.. (ga,om,pb,cp, ... ) % low level input ... = nor2ss ( ... , ind,fc,OutputCmd) % frequency,truncation... ... = nor2xf ( ... , w,ind,fc,OutputCmd)
Description
These functions provide detailed access, for simple high level calls see fe2ss. Normal mode models are second order models detailed in the Theory section below. nor2res, nor2ss, and nor2xf provide a number of transformations from the normal mode form to residue, statespace, and transfer function formats.
The normal mode model is specified using either high level structure arguments DEF,MODEL (where the model is assumed to contain load and sensor case entries) or low level numeric arguments om,ga,pb,cp. Additional arguments w,ind,fc,OutputCmd can or must be specified depending on the desired output. These arguments are listed below.
The normal mode shapes are given in a DEF structure with fields .def, .DOF, .data (see section 7.8).
These mode shapes are assumed mass normalized and the first column of the .data field is assumed to give modal frequencies in Hz. They can be computed with fe_eig or imported from an external FEM code (see FEMLink). See also fe2ss.
Damping can be declared in different ways
def.data=sqrt(real(def.data.^2)).*sqrt(1+i*damp*2); IIxh=nor2xf(def,[],model,w,'hz');
as illustrated in section 5.3.2.
Inputs and outputs are described by a model containing a Case (see section 4.5). Giving the model is needed when inputs correspond to distributed loads (FVol or FSurf case entries detailed under fe_load). SensDof are the only output entries currently supported (see fe_case).
Note that DofSet entries are handled as acceleration inputs. The basis described by DEF must allow a correct representation of these inputs. This can be achieved by using a basis containing static corrections for unit displacements or loads on the interface (see fe2ss CraigBampton or Free commands). A proper basis can also be generated using acceleration inputs at single nodes where a large seismic mass is added to the model. This solution is easier to implement when dealing with external FEM codes.
Here is a sample call that compares responses for two damping levels
[model,def]=demosdt('demogartfe'); InDof=[4.03;55.03;2.03]; OutDof=[4 55 30]'+.03; freq=linspace(5,70,500)'; model=fe_case(model, ... 'DofLoad','Force',InDof, ... 'SensDof','Sensors',OutDof); model=stack_set(model,'info','Freq',freq, ... 'info','DefaultZeta',.01); % Ignored when def.data(:,2) exists nor2xf(def,model,'acc iiplot "Test" po reset'); % Another variation % define variable damping in def.data(:,2) def.data(def.data(:,1)<30,2)=.005; % 0.5% damping below 30 Hz def.data(def.data(:,1)>30,2)=.02; % 2% damping above 30 Hz % Truncate to first 10 modes (static correction is lost) d1=fe_def('subdef',def,1:12); % Define inputs and ouputs using DOFs (less general than fe_case) nor2xf(d1,InDof,OutDof,freq,'acc iiplot "Variable damping"'); iicom('ch2');ci=iiplot;ci.Stack
When using distributed loads (pressure, etc.), the model elements are needed to define the load so that the model rather than a Case must be given as in the following example
model = demosdt('demo ubeam'); def=fe_eig(model,[106 20 10000 11 1e5]); %Pressure load data=struct('sel','x==.5', ... 'eltsel','withnode {z>1.25}','def',1,'DOF',.19); model=fe_case(model,'Fsurf','Surface load',data) %Sensors model=fe_case(model,'sensdof','Sensors',[50:54]'+.03); fe_case(model,'info') model=stack_set(model,'info','Freq',linspace(10,240,460)); nor2xf(def,0.01,model,'iiplot "Test" po reset');
Example of transmissibility prediction using the large mass method where one defines a rigid base and a large mass such that one has 6 rigid body modes and fixed interface modes
model = demosdt('demo ubeam'); % define rigid base i1=feutil('findnode z==0',model); model = fe_case(model,'reset', ... 'rigid append','Base',[i1(1);123456;i1(2:end)]); % Add large mass on the base model.Elt(end+[1:2],1:7)=[Inf abs('mass1') 0; i1(1) [1 1 1 1 1 1]*1e6]; def=fe_eig(model,[5 20 1e3]); % This can be computed elsewhere % Transmissibility for unit acceleration along x model=fe_case(model,'DofSet','IN', ... struct('def',[1;0;0;0;0;0],'DOF',i1(1)+[1:6]'/100), ... 'SensDof','OUT',[1.01;314.01]); f=linspace(50,500,1024)'; nor2xf(def,.01,model,f,'acc iiplot "TransLarge" reset'); % Clean approach without the large mass mo2=stack_set(model,'info','EigOpt',[5 14 1e3]); mo2=fe_case(mo2,'DofSet','IN',i1(1)); SE=fe_reduc('CraigBampton se',model); % craigbampton reduction % Free modes of CraigBampton basis TR=fe_eig({SE.K{:} SE.DOF});TR.DOF=SE.TR.DOF;TR.def=SE.TR.def*TR.def; nor2xf(TR,.01,model,f,'acc iiplot "TransCraig"'); iicom('ch2');
Standard low level arguments om (modal stiffness matrix), ga (modal viscous damping matrix), pb (modal controllability) and cp (modal observability) used to describe normal mode models are detailed in section section 5.2. A typical call using this format would be
[model,def]=demosdt('demogartfe'); b = fe_c(def.DOF,[4.03;55.03])'; c = fe_c(def.DOF,[1 30 40]'+.03); IIw=linspace(5,70,500)'; nor2xf(def.data,0.01,def.def'*b,c*def.def,IIw*2*pi, ... 'Hz iiplot "Simul" po reset');
Other arguments are
nor2res returns a complex mode model in the residue form
[α(s)] = 

 = 


This routine is particularly useful to recreate results in the identified residue form res for comparison with direct identification results from id_rc.
Pole residue models are always assumed to correspond to force to displacement transfer functions. Acceleration input or velocity, acceleration output specifications are thus ignored.
nor2ss returns statespace models (see the theory section below).
When no rolloff frequency is specified, nor2ss introduces a correction, for displacement only, in the statespace models through the use of a nonzero d term. If a rolloff frequency fc is given, the static correction is introduced in the statespace model through the use of additional high frequency modes. Unlike the nonzero D term which it replaces, this correction also allows to correct for velocity contributions of truncated modes.
You can also specify fc as a series of poles (as many as inputs) given in the frequency/damping format (see ii_pof).
You force use of SDT structure and rather than Control Toolbox LTI object using setpref('SDT','UseControlToolbox',0). You can convert between formats using ss_lti=nor2ss('ss2struct',ss_sdt) or ss_sdt=nor2ss('ss2struct',ss_lti).
nor2xf computes FRF (from u to y) associated to the normal mode model. When used with modal frequencies freq and a subset of the modes (specified by a non empty ind), nor2xf introduces static corrections for the truncated modes.
SDT uses fields lab_in and lab_out, while the control toolbox objects use InputName and OutputName. The commands lab_in are used to robust handling based on the object type.
lab_in =nor2ss('lab_in', sys) % Get in lab_out=nor2ss('lab_out',sys) % Get out sys=nor2ss('lab_in' ,sys,lab_in) % Set in sys=nor2ss('lab_out',sys,lab_out) % Set out
The basic normal mode form associated with load inputs [b]{u} is (see section 5.2)

where the coordinates p are such that the mass is the identity matrix and the stiffness is the diagonal matrix of frequencies squared.
The associated statespace model has the form

When used with modal frequencies wj and a subset of the modes (specified by ind), nor2ss introduces static corrections for the truncated modes. When requesting velocity or acceleration output, static correction can only be included by using additional modes.
In cases with displacement output only, the static corrections are ranked by decreasing contribution (using a SVD of the d term). You can thus look at the input shape matrix b to see whether all corrections are needed.
nor2ss (and nor2xf by calling nor2ss) supports the creation of statespace models of transmissibilities (transfer functions from acceleration input to displacement, velocity or acceleration. For such models, one builds a transformation such that the inputs u_{a} associated with imposed accelerations correspond to states
{ 
 } = [T_{I} T_{C}] {p} 
and solves the fixed interface eigenvalue problem
[T_{C}^{T}Ω T_{C} − ω_{jC}^{2} T_{C}^{T} I T_{C} ] {φ_{jC}} = {0} 
leading to basis [T_{I} T_{C}]= [T_{I} T_{C}[φ_{jC}]] which is used to build the state space model

Simple adjustments lead to velocity and acceleration outputs.
When using acceleration input, care must be taken that the initial shapes of the normal mode model form an appropriate basis. This can be achieved by using a basis containing static corrections for unit displacements or loads on the interface (see fe2ss CraigBampton or Free commands) or a seismic mass technique.
See also
res2nor, id_nor, fe_c, psi2nor
demo_fe