|
4779
|
1 ## Copyright (C) 1996, 1998 Auburn University. All rights reserved. |
|
|
2 ## |
|
|
3 ## This file is part of Octave. |
|
|
4 ## |
|
|
5 ## Octave is free software; you can redistribute it and/or modify it |
|
7016
|
6 ## under the terms of the GNU General Public License as published by |
|
|
7 ## the Free Software Foundation; either version 3 of the License, or (at |
|
|
8 ## your option) any later version. |
|
4779
|
9 ## |
|
7016
|
10 ## Octave is distributed in the hope that it will be useful, but |
|
|
11 ## WITHOUT ANY WARRANTY; without even the implied warranty of |
|
|
12 ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
|
|
13 ## General Public License for more details. |
|
4779
|
14 ## |
|
|
15 ## You should have received a copy of the GNU General Public License |
|
7016
|
16 ## along with Octave; see the file COPYING. If not, see |
|
|
17 ## <http://www.gnu.org/licenses/>. |
|
4779
|
18 |
|
|
19 ## -*- texinfo -*- |
|
5016
|
20 ## @deftypefn {Function File} {@var{outsys} =} ss (@var{a}, @var{b}, @var{c}, @var{d}, @var{tsam}, @var{n}, @var{nz}, @var{stname}, @var{inname}, @var{outname}, @var{outlist}) |
|
7001
|
21 ## Create system structure from state-space data. May be continuous, |
|
5016
|
22 ## discrete, or mixed (sampled data) |
|
4779
|
23 ## |
|
|
24 ## @strong{Inputs} |
|
|
25 ## @table @var |
|
|
26 ## @item a |
|
|
27 ## @itemx b |
|
|
28 ## @itemx c |
|
|
29 ## @itemx d |
|
|
30 ## usual state space matrices. |
|
|
31 ## |
|
|
32 ## default: @var{d} = zero matrix |
|
|
33 ## |
|
|
34 ## @item tsam |
|
|
35 ## sampling rate. Default: @math{tsam = 0} (continuous system) |
|
|
36 ## |
|
|
37 ## @item n |
|
|
38 ## @itemx nz |
|
|
39 ## number of continuous, discrete states in the system |
|
|
40 ## |
|
|
41 ## If @var{tsam} is 0, @math{n = @code{rows}(@var{a})}, @math{nz = 0}. |
|
|
42 ## |
|
|
43 ## If @var{tsam} is greater than zero, @math{n = 0}, |
|
|
44 ## @math{nz = @code{rows}(@var{a})} |
|
|
45 ## |
|
|
46 ## see below for system partitioning |
|
|
47 ## |
|
|
48 ## @item stname |
|
4844
|
49 ## cell array of strings of state signal names |
|
4779
|
50 ## |
|
|
51 ## default (@var{stname}=[] on input): @code{x_n} for continuous states, |
|
|
52 ## @code{xd_n} for discrete states |
|
|
53 ## |
|
|
54 ## @item inname |
|
4844
|
55 ## cell array of strings of input signal names |
|
4779
|
56 ## |
|
|
57 ## default (@var{inname} = [] on input): @code{u_n} |
|
|
58 ## |
|
|
59 ## @item outname |
|
5573
|
60 ## cell array of strings of output signal names |
|
4779
|
61 ## |
|
|
62 ## default (@var{outname} = [] on input): @code{y_n} |
|
|
63 ## |
|
|
64 ## @item outlist |
|
|
65 ## |
|
|
66 ## list of indices of outputs y that are sampled |
|
|
67 ## |
|
|
68 ## If @var{tsam} is 0, @math{outlist = []}. |
|
|
69 ## |
|
|
70 ## If @var{tsam} is greater than 0, @math{outlist = 1:@code{rows}(@var{c})}. |
|
|
71 ## @end table |
|
|
72 ## |
|
7001
|
73 ## Unlike states, discrete/continuous outputs may appear in any order. |
|
4779
|
74 ## |
|
4946
|
75 ## @code{sys2ss} returns a vector @var{yd} where |
|
4779
|
76 ## @var{yd}(@var{outlist}) = 1; all other entries of @var{yd} are 0. |
|
|
77 ## |
|
5016
|
78 ## @strong{Output} |
|
|
79 ## @table @var |
|
|
80 ## @item outsys |
|
|
81 ## system data structure |
|
|
82 ## @end table |
|
4779
|
83 ## |
|
|
84 ## @strong{System partitioning} |
|
|
85 ## |
|
|
86 ## Suppose for simplicity that outlist specified |
|
|
87 ## that the first several outputs were continuous and the remaining outputs |
|
|
88 ## were discrete. Then the system is partitioned as |
|
|
89 ## @example |
|
|
90 ## @group |
|
|
91 ## x = [ xc ] (n x 1) |
|
|
92 ## [ xd ] (nz x 1 discrete states) |
|
|
93 ## a = [ acc acd ] b = [ bc ] |
|
|
94 ## [ adc add ] [ bd ] |
|
|
95 ## c = [ ccc ccd ] d = [ dc ] |
|
|
96 ## [ cdc cdd ] [ dd ] |
|
|
97 ## |
|
|
98 ## (cdc = c(outlist,1:n), etc.) |
|
|
99 ## @end group |
|
|
100 ## @end example |
|
|
101 ## with dynamic equations: |
|
|
102 ## @ifinfo |
|
|
103 ## @math{d/dt xc(t) = acc*xc(t) + acd*xd(k*tsam) + bc*u(t)} |
|
|
104 ## |
|
|
105 ## @math{xd((k+1)*tsam) = adc*xc(k*tsam) + add*xd(k*tsam) + bd*u(k*tsam)} |
|
|
106 ## |
|
|
107 ## @math{yc(t) = ccc*xc(t) + ccd*xd(k*tsam) + dc*u(t)} |
|
|
108 ## |
|
|
109 ## @math{yd(k*tsam) = cdc*xc(k*tsam) + cdd*xd(k*tsam) + dd*u(k*tsam)} |
|
|
110 ## @end ifinfo |
|
|
111 ## @iftex |
|
|
112 ## @tex |
|
|
113 ## $$\eqalign{ |
|
|
114 ## {d \over dt} x_c(t) |
|
|
115 ## & = a_{cc} x_c(t) + a_{cd} x_d(k*t_{sam}) + bc*u(t) \cr |
|
|
116 ## x_d((k+1)*t_{sam}) |
|
|
117 ## & = a_{dc} x_c(k t_{sam}) + a_{dd} x_d(k t_{sam}) + b_d u(k t_{sam}) \cr |
|
|
118 ## y_c(t) |
|
|
119 ## & = c_{cc} x_c(t) + c_{cd} x_d(k t_{sam}) + d_c u(t) \cr |
|
|
120 ## y_d(k t_{sam}) |
|
|
121 ## & = c_{dc} x_c(k t_{sam}) + c_{dd} x_d(k t_{sam}) + d_d u(k t_{sam}) |
|
|
122 ## }$$ |
|
|
123 ## @end tex |
|
|
124 ## @end iftex |
|
|
125 ## |
|
|
126 ## @strong{Signal partitions} |
|
|
127 ## @example |
|
|
128 ## @group |
|
|
129 ## | continuous | discrete | |
|
|
130 ## ---------------------------------------------------- |
|
|
131 ## states | stname(1:n,:) | stname((n+1):(n+nz),:) | |
|
|
132 ## ---------------------------------------------------- |
|
|
133 ## outputs | outname(cout,:) | outname(outlist,:) | |
|
|
134 ## ---------------------------------------------------- |
|
|
135 ## @end group |
|
|
136 ## @end example |
|
|
137 ## where @math{cout} is the list of in 1:@code{rows}(@var{p}) |
|
|
138 ## that are not contained in outlist. (Discrete/continuous outputs |
|
|
139 ## may be entered in any order desired by the user.) |
|
|
140 ## |
|
|
141 ## @strong{Example} |
|
|
142 ## @example |
|
|
143 ## octave:1> a = [1 2 3; 4 5 6; 7 8 10]; |
|
|
144 ## octave:2> b = [0 0 ; 0 1 ; 1 0]; |
|
4855
|
145 ## octave:3> c = eye (3); |
|
|
146 ## octave:4> sys = ss (a, b, c, [], 0, 3, 0, @{"volts", "amps", "joules"@}); |
|
4779
|
147 ## octave:5> sysout(sys); |
|
|
148 ## Input(s) |
|
|
149 ## 1: u_1 |
|
|
150 ## 2: u_2 |
|
|
151 ## |
|
|
152 ## Output(s): |
|
|
153 ## 1: y_1 |
|
|
154 ## 2: y_2 |
|
|
155 ## 3: y_3 |
|
|
156 ## |
|
|
157 ## state-space form: |
|
|
158 ## 3 continuous states, 0 discrete states |
|
|
159 ## State(s): |
|
|
160 ## 1: volts |
|
|
161 ## 2: amps |
|
|
162 ## 3: joules |
|
|
163 ## |
|
|
164 ## A matrix: 3 x 3 |
|
|
165 ## 1 2 3 |
|
|
166 ## 4 5 6 |
|
|
167 ## 7 8 10 |
|
|
168 ## B matrix: 3 x 2 |
|
|
169 ## 0 0 |
|
|
170 ## 0 1 |
|
|
171 ## 1 0 |
|
|
172 ## C matrix: 3 x 3 |
|
|
173 ## 1 0 0 |
|
|
174 ## 0 1 0 |
|
|
175 ## 0 0 1 |
|
|
176 ## D matrix: 3 x 3 |
|
|
177 ## 0 0 |
|
|
178 ## 0 0 |
|
|
179 ## 0 0 |
|
|
180 ## @end example |
|
|
181 ## Notice that the @math{D} matrix is constructed by default to the |
|
|
182 ## correct dimensions. Default input and output signals names were assigned |
|
|
183 ## since none were given. |
|
|
184 ## @end deftypefn |
|
|
185 |
|
|
186 ## Author: John Ingram <ingraje@eng.auburn.edu> |
|
|
187 ## Created: July 20, 1996 |
|
|
188 |
|
|
189 function retsys = ss (a, b, c, d, tsam, n, nz, stname, inname, outname, outlist) |
|
|
190 |
|
|
191 ## Test for correct number of inputs |
|
|
192 if ((nargin < 3) | (nargin > 11)) |
|
6046
|
193 print_usage (); |
|
4779
|
194 endif |
|
|
195 |
|
|
196 ## verify A, B, C, D arguments |
|
|
197 ## If D is not specified, set it to a zero matrix of appriate dimension. |
|
|
198 if (nargin == 3) d = zeros(rows(c) , columns(b)); |
|
|
199 elseif (isempty(d)) d = zeros(rows(c) , columns(b)); endif |
|
|
200 |
|
|
201 ## Check the dimensions |
|
|
202 [na,m,p] = abcddim(a,b,c,d); |
|
|
203 |
|
|
204 ## If dimensions are wrong, exit function |
|
|
205 if (m == -1) |
|
|
206 error("a(%dx%d), b(%dx%d), c(%dx%d), d(%dx%d); incompatible", ... |
|
|
207 rows(a), columns(a), rows(b), columns(b), rows(c), columns(c), ... |
|
|
208 rows(d), columns(d)); |
|
|
209 endif |
|
|
210 |
|
|
211 ## check for tsam input |
|
|
212 if(nargin < 5) tsam = 0; |
|
|
213 elseif( !( is_sample(tsam) | (tsam == 0) ) ) |
|
|
214 error("tsam must be a nonnegative real scalar"); |
|
|
215 endif |
|
|
216 |
|
|
217 ## check for continuous states |
|
|
218 if( (nargin < 6) & (tsam == 0) ) n = na; |
|
|
219 elseif(nargin < 6) n = 0; |
|
5443
|
220 elseif((!ismatrix(n)) | ischar(n)) |
|
4779
|
221 error("Parameter n is not a numerical value."); |
|
|
222 elseif( (!isscalar(n)) | (n < 0 ) | (n != round(n)) ) |
|
|
223 if(isscalar(n)) error("invalid value of n=%d,%e",n,n); |
|
|
224 else error("invalid value of n=(%dx%d)", ... |
|
|
225 rows(n), columns(n)); endif |
|
|
226 endif |
|
|
227 |
|
|
228 ## check for num discrete states |
|
|
229 if( (nargin < 7) & (tsam == 0)) nz = 0; |
|
|
230 elseif(nargin < 7) nz = na - n; |
|
5443
|
231 elseif((!ismatrix(nz)) | ischar(nz)) |
|
4779
|
232 error("Parameter nz is not a numerical value."); |
|
|
233 elseif( (!isscalar(nz)) | (nz < 0 ) | (nz != round(nz)) ) |
|
|
234 if(isscalar(nz)) |
|
|
235 error(["invalid value of nz=",num2str(nz)]); |
|
|
236 else |
|
|
237 error(["invalid value of nz=(",num2str(rows(nz)),"x", ... |
|
|
238 num2str(columns(nz)),")"]); |
|
|
239 endif |
|
|
240 endif |
|
|
241 |
|
|
242 ## check for total number of states |
|
|
243 if( (n + nz) != na ) |
|
|
244 error(["invalid: a is ",num2str(na),"x",num2str(na),", n=", ... |
|
|
245 num2str(n),", nz=",num2str(nz)]); |
|
|
246 endif |
|
|
247 |
|
|
248 ## construct system with default names |
|
|
249 retsys.a = a; |
|
|
250 retsys.b = b; |
|
|
251 retsys.c = c; |
|
|
252 retsys.d = d; |
|
|
253 |
|
|
254 retsys.n = n; |
|
|
255 retsys.nz = nz; |
|
|
256 retsys.tsam = tsam; |
|
|
257 retsys.yd = zeros(1,p); # default value entered below |
|
|
258 |
|
|
259 ## Set the system vector: active = 2(ss), updated = [0 0 1]; |
|
|
260 retsys.sys = [2, 0, 0, 1]; |
|
|
261 |
|
|
262 retsys.stname = __sysdefstname__ (n, nz); |
|
|
263 retsys.inname = __sysdefioname__ (m, "u"); |
|
|
264 retsys.outname = __sysdefioname__ (p, "y"); |
|
|
265 |
|
|
266 ## check for state names |
|
|
267 if(nargin >= 8) |
|
|
268 if(!isempty(stname)) retsys = syssetsignals(retsys,"st",stname); endif |
|
|
269 endif |
|
|
270 |
|
|
271 ## check for input names |
|
|
272 if(nargin >= 9) |
|
|
273 if(!isempty(inname)) retsys = syssetsignals(retsys,"in",inname); endif |
|
|
274 endif |
|
|
275 |
|
|
276 ## check for output names |
|
|
277 if(nargin >= 10) |
|
|
278 if(!isempty(outname)) retsys = syssetsignals(retsys,"out",outname); endif |
|
|
279 endif |
|
|
280 |
|
|
281 ## set up yd |
|
|
282 if(nargin < 11) |
|
|
283 retsys = syssetsignals(retsys,"yd",ones(1,p)*(tsam > 0)); |
|
|
284 else |
|
|
285 if(!isempty(outlist)) |
|
|
286 retsys = syssetsignals(retsys,"yd",ones(size(outlist)),outlist); |
|
|
287 endif |
|
|
288 endif |
|
|
289 |
|
|
290 endfunction |
