mechss
Sparse second-order state-space model
Description
Use mechss to represent second-order sparse models using
matrices obtained from your finite element analysis (FEA) package. Such sparse models arise
from finite element analysis (FEA) and are useful in fields like structural analysis, fluid
flow, heat transfer and electromagnetics. The resultant matrices from this type of modeling
are quite large with a sparse pattern. Hence, using mechss is an efficient
way to represent such large sparse state-space models in MATLAB® to perform linear analysis. You can also use mechss to
convert a first-order sparss model object or other dynamic system models to a mechss
object.
You can use mechss model objects to represent SISO or MIMO state-space
models in continuous time or discrete time. In continuous time, a second-order sparse
mass-spring-damper model is represented in the following form:
Here, the full state vector is given by where and are the displacement and velocity vectors. u and
y represent the inputs and outputs, respectively. M,
C and K represent the mass, damping and stiffness
matrices, respectively. B is the input matrix while F
and G are the output matrices for displacement and velocity, respectively.
D is the input-to-output matrix.
You can use a mechss object to:
Perform time-domain and frequency-domain response analysis.
Specify signal-based connections with other LTI models.
Specify physical interfaces between components using the
interfacecommand.
For more information, see Sparse Model Basics.
Creation
Syntax
Description
sys = mechss(M,C,K,B,F,G,D)mechss object representing this continuous-time
second-order mass-spring-damper model:
Here, M, C, and
K represent the mass, damping, and stiffness matrices,
respectively. B is the input-to-state matrix while
F and G are the displacement-to-output and
velocity-to-output matrices resulting from the two components of the state
x. D is the input-to-output matrix. You can set
M to [] when the mass matrix is an identity
matrix. Set G and D to []
or omit them when they are empty.
Input Arguments
Output Arguments
Properties
Object Functions
The following lists show functions you can use with mechss model
objects.
Examples
Continuous-Time Sparse Second-Order Model
For this example, consider the sparse matrices for the 3-D beam model subjected to an impulsive point load at its tip in the file sparseBeam.mat.
Extract the sparse matrices from sparseBeam.mat.
load('sparseBeam.mat','M','K','B','F','G','D');
Create the mechss model object by specifying [] for matrix C, since there is no damping.
sys = mechss(M,[],K,B,F,G,D)
Sparse continuous-time second-order model with 3 outputs, 1 inputs, and 3408 nodes.
Use "spy" and "showStateInfo" to inspect model structure.
Type "properties('mechss')" for a list of model properties.
Type "help mechssOptions" for available solver options for this model.
The output sys is a mechss model object containing a 3-by-1 array of sparse models with 3408 nodes, 1 input, and 3 outputs.
You can use the spy command to visualize the sparsity of the mechss model object.
spy(sys)
Discrete-Time Sparse Second-Order Model
For this example, consider the sparse matrices of the discrete system in the file discreteSOSparse.mat.
Load the sparse matrices from discreteSOSparse.mat.
load('discreteSOSparse.mat','M','C','K','B','F','G','D','ts');
Create the discrete-time mechss model object by specifying the sample time ts.
sys = mechss(M,C,K,B,F,G,D,ts)
Sparse discrete-time second-order model with 1 outputs, 1 inputs, and 28408 nodes.
Use "spy" and "showStateInfo" to inspect model structure.
Type "properties('mechss')" for a list of model properties.
Type "help mechssOptions" for available solver options for this model.
The output sys is a discrete-time mechss model object with 28408 nodes, 1 input, and 1 output.
You can use the spy command to visualize the sparsity pattern of the mechss model object. You can right-click on the plot to select matrices to be displayed.
spy(sys)
Array of Sparse Second-Order Models
For this example, consider sparseSOArray.mat which contains three sets of sparse matrices that define multiple sparse second-order state-space models.
Extract the data from sparseSOArray.mat.
load('sparseSOArray.mat');Preallocate a 3-by-1 array of mechss models.
sys = mechss(zeros(1,1,3));
Next, use indexed assignment to populate the 3-by-1 array with sparse second-order models.
sys(:,:,1) = mechss(M1,[],K1,B1,F1,G1,[]); sys(:,:,2) = mechss(M2,[],K2,B2,F2,G2,[]); sys(:,:,3) = mechss(M3,[],K3,B3,F3,G3,[]); size(sys)
3x1 array of sparse second-order models. Each model has 1 outputs, 1 inputs, and between 385 and 738 nodes.
Alternatively, you can also create an array of sparse second-order models using the stack command when you have models with the same I/O sizes.
Copyright 2020 The MathWorks, Inc
MIMO Static Gain Sparse Second-Order Model
Create a static gain MIMO sparse second-order state-space model.
Consider the following two-input, three-output static gain matrix:
Specify the gain matrix and create the static gain sparse second-order state-space model.
D = [1,5;2,3;5,9]; sys = mechss(D); size(sys)
Sparse second-order model with 3 outputs, 2 inputs, and 0 nodes.
Mass-Spring-Damper Sparse Second-Order Model
For this example, consider sparseSOSignal.mat which contains the mass, stiffness, and damping sparse matrices.
Load the sparse matrices from sparseSOSignal.mat and create the sparse second-order model object.
load('sparseSOModel.mat','M','C','K'); sys = mechss(M,C,K);
mechss creates the model object sys with the following assumptions:
Identity matrices for
BandFwith the same size as mass matrixM.Zero matrices for
GandD.
Convert First-Order Sparse Model to Second-Order Sparse Model Representation
For this example, consider sparssModel.mat that contains a sparss model object ltiSys.
Load the sparss model object from sparssModel.mat.
load('sparssModel.mat','ltiSys'); ltiSys
Sparse continuous-time state-space model with 1 outputs, 1 inputs, and 354 states.
Use "spy" and "showStateInfo" to inspect model structure.
Type "properties('sparss')" for a list of model properties.
Type "help sparssOptions" for available solver options for this model.
Use the mechss command to convert to mechss model object representation.
sys = mechss(ltiSys)
Sparse continuous-time second-order model with 1 outputs, 1 inputs, and 354 nodes.
Use "spy" and "showStateInfo" to inspect model structure.
Type "properties('mechss')" for a list of model properties.
Type "help mechssOptions" for available solver options for this model.
Time and Frequency Response of Sparse Second-Order Model
For this example, consider tuningForkData.mat that contains the sparse second-order model of a tuning fork being struck gently but quickly on one of its tines. The system has one input, the pressure applied on one of its tines, which results in two outputs - the displacements at the tip and base of the tuning fork.
Load the sparse matrices from tuningForkData.mat into the workspace and create the mechss model object.
load('tuningForkData.mat','M','K','B','F'); sys = mechss(M,[],K,B,F,'InputName','pressure','Outputname',{'y tip','x base'})
Next, set solver options for the model by setting the UseParallel parameter to true and the DAESolver to use trbdf3. Use spy to inspect the model structure. Enabling parallel computing requires a Parallel Computing Toolbox™ license.
sys.SolverOptions.UseParallel = true;
sys.SolverOptions.DAESolver = 'trbdf3';
spy(sys)
You can also use showStateInfo to examine the components.
showStateInfo(sys)
Use step to obtain the step response plot of the system. You need to provide the time vector or final time for sparse models.
t = linspace(0,0.5,1000); step(sys,t)
Next, obtain the Bode plot to examine the frequency response. You need to provide the frequency vector for sparse models.
w = logspace(1,5,1000); bode(sys,w), grid
Sparse Second-Order Model in a Feedback Loop
For this example, consider sparseSOSignal.mat that contains a sparse second-order model. Define an actuator, sensor, and controller and connect them together with the plant in a feedback loop.
Load the sparse matrices and create the mechss object.
load sparseSOSignal.mat plant = mechss(M,C,K,B,F,[],[],'Name','Plant');
Next, create an actuator and sensor using transfer functions.
act = tf(1,[1 0.5 3],'Name','Actuator'); sen = tf(1,[0.02 7],'Name','Sensor');
Create a PID controller object for the plant.
con = pid(1,1,0.1,0.01,'Name','Controller');
Use the feedback command to connect the plant, sensor, actuator, and controller in a feedback loop.
sys = feedback(sen*plant*act*con,1)
Sparse continuous-time second-order model with 1 outputs, 1 inputs, and 7111 nodes.
Use "spy" and "showStateInfo" to inspect model structure.
Type "properties('mechss')" for a list of model properties.
Type "help mechssOptions" for available solver options for this model.
The resultant system sys is a mechss object since mechss objects take precedence over all other model object types.
Use showStateInfo to view the component and signal groups.
showStateInfo(sys)
The state groups are:
Type Name Size
-------------------------------
Component Sensor 1
Component Plant 7102
Signal 1
Component Actuator 2
Signal 1
Component Controller 2
Signal 1
Signal 1
Use xsort to sort the components and signals, and then view the component and signal groups.
sysSort = xsort(sys); showStateInfo(sysSort)
The state groups are:
Type Name Size
-------------------------------
Component Sensor 1
Component Plant 7102
Component Actuator 2
Component Controller 2
Signal 4
Observe that the components are now ordered before the signal partition. The signals are now sorted and grouped together in a single partition.
You can also visualize the sparsity pattern of the resultant system using spy.
spy(sysSort)
Physical Connections Between Components in a Sparse Second-Order Model
For this example, consider a structural model that consists of two square plates connected with pillars at each vertex as depicted in the figure below. The lower plate is attached rigidly to the ground while the pillars are attached rigidly to each vertex of the square plate.
Load the finite element model matrices contained in platePillarModel.mat and create the sparse second-order model representing the above system.
load('platePillarModel.mat') sys = ... mechss(M1,[],K1,B1,F1,'Name','Plate1') + ... mechss(M2,[],K2,B2,F2,'Name','Plate2') + ... mechss(Mp,[],Kp,Bp,Fp,'Name','Pillar3') + ... mechss(Mp,[],Kp,Bp,Fp,'Name','Pillar4') + ... mechss(Mp,[],Kp,Bp,Fp,'Name','Pillar5') + ... mechss(Mp,[],Kp,Bp,Fp,'Name','Pillar6');
Use showStateInfo to examine the components of the mechss model object.
showStateInfo(sys)
The state groups are:
Type Name Size
----------------------------
Component Plate1 2646
Component Plate2 2646
Component Pillar3 132
Component Pillar4 132
Component Pillar5 132
Component Pillar6 132
Now, load the interfaced node index data from nodeData.mat and use interface to create the physical connections between the two plates and the four pillars. nodes is a 6x7 cell array where the first two rows contain node index data for the first and second plates while the remaining four rows contain index data for the four pillars.
load('nodeData.mat','nodes') for i=3:6 sys = interface(sys,"Plate1",nodes{1,i},"Pillar"+i,nodes{i,1}); sys = interface(sys,"Plate2",nodes{2,i},"Pillar"+i,nodes{i,2}); end
Specify connection between the bottom plate and the ground.
sysCon = interface(sys,"Plate2",nodes{2,7});Use showStateInfo to confirm the physical interfaces.
showStateInfo(sysCon)
The state groups are:
Type Name Size
-----------------------------------
Component Plate1 2646
Component Plate2 2646
Component Pillar3 132
Component Pillar4 132
Component Pillar5 132
Component Pillar6 132
Interface Plate1-Pillar3 12
Interface Plate2-Pillar3 12
Interface Plate1-Pillar4 12
Interface Plate2-Pillar4 12
Interface Plate1-Pillar5 12
Interface Plate2-Pillar5 12
Interface Plate1-Pillar6 12
Interface Plate2-Pillar6 12
Interface Plate2-Ground 6
You can use spy to visualize the sparse matrices in the final model.
spy(sysCon)
The data set for this example was provided by Victor Dolk from ASML.
References
[1] H. Hilber, T. Hughes & R. Taylor. " Improved numerical dissipation for time integration algorithms in structural dynamics." Earthquake Engineering and Structural Dynamics, vol. 5, no. 3, pp. 283-292, 1977.
[2] M. Hosea and L. Shampine. "Analysis and implementation of TR-BDF2." Applied Numerical Mathematics, vol. 20, no. 1-2, pp. 21-37, 1996.
See Also
full | interface | mechssdata | showStateInfo | Sparse Second Order | sparss | spy | xsort