Repository navigation
Expand file tree
/
Copy pathiosys.py
More file actions
2725 lines (2233 loc) · 110 KB
/
Copy pathiosys.py
File metadata and controls
2725 lines (2233 loc) · 110 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
# iosys.py - input/output system module
#
# RMM, 28 April 2019
#
# Additional features to add
# * Allow constant inputs for MIMO input_output_response (w/out ones)
# * Add support for constants/matrices as part of operators (1 + P)
# * Add unit tests (and example?) for time-varying systems
# * Allow time vector for discrete time simulations to be multiples of dt
# * Check the way initial outputs for discrete time systems are handled
#
"""The :mod:`~control.iosys` module contains the
:class:`~control.InputOutputSystem` class that represents (possibly nonlinear)
input/output systems. The :class:`~control.InputOutputSystem` class is a
general class that defines any continuous or discrete time dynamical system.
Input/output systems can be simulated and also used to compute equilibrium
points and linearizations.
"""
__author__ = "Richard Murray"
__copyright__ = "Copyright 2019, California Institute of Technology"
__credits__ = ["Richard Murray"]
__license__ = "BSD"
__maintainer__ = "Richard Murray"
__email__ = "murray@cds.caltech.edu"
import numpy as np
import scipy as sp
import copy
from warnings import warn
from .statesp import StateSpace, tf2ss, _convert_to_statespace
from .xferfcn import TransferFunction
from .timeresp import _check_convert_array, _process_time_response, \
TimeResponseData
from .lti import isctime, isdtime, common_timebase
from . import config
__all__ = ['InputOutputSystem', 'LinearIOSystem', 'NonlinearIOSystem',
'InterconnectedSystem', 'LinearICSystem', 'input_output_response',
'find_eqpt', 'linearize', 'ss2io', 'tf2io', 'interconnect',
'summing_junction']
# Define module default parameter values
_iosys_defaults = {
'iosys.state_name_delim': '_',
'iosys.duplicate_system_name_prefix': '',
'iosys.duplicate_system_name_suffix': '$copy',
'iosys.linearized_system_name_prefix': '',
'iosys.linearized_system_name_suffix': '$linearized'
}
class InputOutputSystem(object):
"""A class for representing input/output systems.
The InputOutputSystem class allows (possibly nonlinear) input/output
systems to be represented in Python. It is intended as a parent
class for a set of subclasses that are used to implement specific
structures and operations for different types of input/output
dynamical systems.
Parameters
----------
inputs : int, list of str, or None
Description of the system inputs. This can be given as an integer
count or as a list of strings that name the individual signals. If an
integer count is specified, the names of the signal will be of the
form `s[i]` (where `s` is one of `u`, `y`, or `x`). If this parameter
is not given or given as `None`, the relevant quantity will be
determined when possible based on other information provided to
functions using the system.
outputs : int, list of str, or None
Description of the system outputs. Same format as `inputs`.
states : int, list of str, or None
Description of the system states. Same format as `inputs`.
dt : None, True or float, optional
System timebase. 0 (default) indicates continuous
time, True indicates discrete time with unspecified sampling
time, positive number is discrete time with specified
sampling time, None indicates unspecified timebase (either
continuous or discrete time).
params : dict, optional
Parameter values for the systems. Passed to the evaluation functions
for the system as default values, overriding internal defaults.
name : string, optional
System name (used for specifying signals). If unspecified, a generic
name <sys[id]> is generated with a unique integer id.
Attributes
----------
ninputs, noutputs, nstates : int
Number of input, output and state variables
input_index, output_index, state_index : dict
Dictionary of signal names for the inputs, outputs and states and the
index of the corresponding array
dt : None, True or float
System timebase. 0 (default) indicates continuous time, True indicates
discrete time with unspecified sampling time, positive number is
discrete time with specified sampling time, None indicates unspecified
timebase (either continuous or discrete time).
params : dict, optional
Parameter values for the systems. Passed to the evaluation functions
for the system as default values, overriding internal defaults.
name : string, optional
System name (used for specifying signals)
Notes
-----
The :class:`~control.InputOuputSystem` class (and its subclasses) makes
use of two special methods for implementing much of the work of the class:
* _rhs(t, x, u): compute the right hand side of the differential or
difference equation for the system. This must be specified by the
subclass for the system.
* _out(t, x, u): compute the output for the current state of the system.
The default is to return the entire system state.
"""
# Allow ndarray * InputOutputSystem to give IOSystem._rmul_() priority
__array_priority__ = 12 # override ndarray, matrix, SS types
_idCounter = 0
def _name_or_default(self, name=None):
if name is None:
name = "sys[{}]".format(InputOutputSystem._idCounter)
InputOutputSystem._idCounter += 1
return name
def __init__(self, inputs=None, outputs=None, states=None, params={},
name=None, **kwargs):
"""Create an input/output system.
The InputOutputSystem constructor is used to create an input/output
object with the core information required for all input/output
systems. Instances of this class are normally created by one of the
input/output subclasses: :class:`~control.LinearICSystem`,
:class:`~control.LinearIOSystem`, :class:`~control.NonlinearIOSystem`,
:class:`~control.InterconnectedSystem`.
"""
# Store the input arguments
# default parameters
self.params = params.copy()
# timebase
self.dt = kwargs.get('dt', config.defaults['control.default_dt'])
# system name
self.name = self._name_or_default(name)
# Parse and store the number of inputs, outputs, and states
self.set_inputs(inputs)
self.set_outputs(outputs)
self.set_states(states)
#
# Class attributes
#
# These attributes are defined as class attributes so that they are
# documented properly. They are "overwritten" in __init__.
#
#: Number of system inputs.
#:
#: :meta hide-value:
ninputs = 0
#: Number of system outputs.
#:
#: :meta hide-value:
noutputs = 0
#: Number of system states.
#:
#: :meta hide-value:
nstates = 0
def __repr__(self):
return self.name if self.name is not None else str(type(self))
def __str__(self):
"""String representation of an input/output system"""
str = "System: " + (self.name if self.name else "(None)") + "\n"
str += "Inputs (%s): " % self.ninputs
for key in self.input_index:
str += key + ", "
str += "\nOutputs (%s): " % self.noutputs
for key in self.output_index:
str += key + ", "
str += "\nStates (%s): " % self.nstates
for key in self.state_index:
str += key + ", "
return str
def __mul__(sys2, sys1):
"""Multiply two input/output systems (series interconnection)"""
# Note: order of arguments is flipped so that self = sys2,
# corresponding to the ordering convention of sys2 * sys1
# Convert sys1 to an I/O system if needed
if isinstance(sys1, (int, float, np.number)):
sys1 = LinearIOSystem(StateSpace(
[], [], [], sys1 * np.eye(sys2.ninputs)))
elif isinstance(sys1, np.ndarray):
sys1 = LinearIOSystem(StateSpace([], [], [], sys1))
elif isinstance(sys1, (StateSpace, TransferFunction)):
sys1 = LinearIOSystem(sys1)
elif not isinstance(sys1, InputOutputSystem):
raise TypeError("Unknown I/O system object ", sys1)
# Make sure systems can be interconnected
if sys1.noutputs != sys2.ninputs:
raise ValueError("Can't multiply systems with incompatible "
"inputs and outputs")
# Make sure timebase are compatible
dt = common_timebase(sys1.dt, sys2.dt)
# Create a new system to handle the composition
inplist = [(0, i) for i in range(sys1.ninputs)]
outlist = [(1, i) for i in range(sys2.noutputs)]
newsys = InterconnectedSystem(
(sys1, sys2), inplist=inplist, outlist=outlist)
# Set up the connection map manually
newsys.set_connect_map(np.block(
[[np.zeros((sys1.ninputs, sys1.noutputs)),
np.zeros((sys1.ninputs, sys2.noutputs))],
[np.eye(sys2.ninputs, sys1.noutputs),
np.zeros((sys2.ninputs, sys2.noutputs))]]
))
# If both systems are linear, create LinearICSystem
if isinstance(sys1, StateSpace) and isinstance(sys2, StateSpace):
ss_sys = StateSpace.__mul__(sys2, sys1)
return LinearICSystem(newsys, ss_sys)
# Return the newly created InterconnectedSystem
return newsys
def __rmul__(sys1, sys2):
"""Pre-multiply an input/output systems by a scalar/matrix"""
# Convert sys2 to an I/O system if needed
if isinstance(sys2, (int, float, np.number)):
sys2 = LinearIOSystem(StateSpace(
[], [], [], sys2 * np.eye(sys1.noutputs)))
elif isinstance(sys2, np.ndarray):
sys2 = LinearIOSystem(StateSpace([], [], [], sys2))
elif isinstance(sys2, (StateSpace, TransferFunction)):
sys2 = LinearIOSystem(sys2)
elif not isinstance(sys2, InputOutputSystem):
raise TypeError("Unknown I/O system object ", sys2)
return InputOutputSystem.__mul__(sys2, sys1)
def __add__(sys1, sys2):
"""Add two input/output systems (parallel interconnection)"""
# Convert sys1 to an I/O system if needed
if isinstance(sys2, (int, float, np.number)):
sys2 = LinearIOSystem(StateSpace(
[], [], [], sys2 * np.eye(sys1.ninputs)))
elif isinstance(sys2, np.ndarray):
sys2 = LinearIOSystem(StateSpace([], [], [], sys2))
elif isinstance(sys2, (StateSpace, TransferFunction)):
sys2 = LinearIOSystem(sys2)
elif not isinstance(sys2, InputOutputSystem):
raise TypeError("Unknown I/O system object ", sys2)
# Make sure number of input and outputs match
if sys1.ninputs != sys2.ninputs or sys1.noutputs != sys2.noutputs:
raise ValueError("Can't add systems with incompatible numbers of "
"inputs or outputs.")
ninputs = sys1.ninputs
noutputs = sys1.noutputs
# Create a new system to handle the composition
inplist = [[(0, i), (1, i)] for i in range(ninputs)]
outlist = [[(0, i), (1, i)] for i in range(noutputs)]
newsys = InterconnectedSystem(
(sys1, sys2), inplist=inplist, outlist=outlist)
# If both systems are linear, create LinearICSystem
if isinstance(sys1, StateSpace) and isinstance(sys2, StateSpace):
ss_sys = StateSpace.__add__(sys2, sys1)
return LinearICSystem(newsys, ss_sys)
# Return the newly created InterconnectedSystem
return newsys
def __radd__(sys1, sys2):
"""Parallel addition of input/output system to a compatible object."""
# Convert sys2 to an I/O system if needed
if isinstance(sys2, (int, float, np.number)):
sys2 = LinearIOSystem(StateSpace(
[], [], [], sys2 * np.eye(sys1.noutputs)))
elif isinstance(sys2, np.ndarray):
sys2 = LinearIOSystem(StateSpace([], [], [], sys2))
elif isinstance(sys2, (StateSpace, TransferFunction)):
sys2 = LinearIOSystem(sys2)
elif not isinstance(sys2, InputOutputSystem):
raise TypeError("Unknown I/O system object ", sys2)
return InputOutputSystem.__add__(sys2, sys1)
def __sub__(sys1, sys2):
"""Subtract two input/output systems (parallel interconnection)"""
# Convert sys1 to an I/O system if needed
if isinstance(sys2, (int, float, np.number)):
sys2 = LinearIOSystem(StateSpace(
[], [], [], sys2 * np.eye(sys1.ninputs)))
elif isinstance(sys2, np.ndarray):
sys2 = LinearIOSystem(StateSpace([], [], [], sys2))
elif isinstance(sys2, (StateSpace, TransferFunction)):
sys2 = LinearIOSystem(sys2)
elif not isinstance(sys2, InputOutputSystem):
raise TypeError("Unknown I/O system object ", sys2)
# Make sure number of input and outputs match
if sys1.ninputs != sys2.ninputs or sys1.noutputs != sys2.noutputs:
raise ValueError("Can't add systems with incompatible numbers of "
"inputs or outputs.")
ninputs = sys1.ninputs
noutputs = sys1.noutputs
# Create a new system to handle the composition
inplist = [[(0, i), (1, i)] for i in range(ninputs)]
outlist = [[(0, i), (1, i, -1)] for i in range(noutputs)]
newsys = InterconnectedSystem(
(sys1, sys2), inplist=inplist, outlist=outlist)
# If both systems are linear, create LinearICSystem
if isinstance(sys1, StateSpace) and isinstance(sys2, StateSpace):
ss_sys = StateSpace.__sub__(sys1, sys2)
return LinearICSystem(newsys, ss_sys)
# Return the newly created InterconnectedSystem
return newsys
def __rsub__(sys1, sys2):
"""Parallel subtraction of I/O system to a compatible object."""
# Convert sys2 to an I/O system if needed
if isinstance(sys2, (int, float, np.number)):
sys2 = LinearIOSystem(StateSpace(
[], [], [], sys2 * np.eye(sys1.noutputs)))
elif isinstance(sys2, np.ndarray):
sys2 = LinearIOSystem(StateSpace([], [], [], sys2))
elif isinstance(sys2, (StateSpace, TransferFunction)):
sys2 = LinearIOSystem(sys2)
elif not isinstance(sys2, InputOutputSystem):
raise TypeError("Unknown I/O system object ", sys2)
return InputOutputSystem.__sub__(sys2, sys1)
def __neg__(sys):
"""Negate an input/output systems (rescale)"""
if sys.ninputs is None or sys.noutputs is None:
raise ValueError("Can't determine number of inputs or outputs")
# Create a new system to hold the negation
inplist = [(0, i) for i in range(sys.ninputs)]
outlist = [(0, i, -1) for i in range(sys.noutputs)]
newsys = InterconnectedSystem(
(sys,), dt=sys.dt, inplist=inplist, outlist=outlist)
# If the system is linear, create LinearICSystem
if isinstance(sys, StateSpace):
ss_sys = StateSpace.__neg__(sys)
return LinearICSystem(newsys, ss_sys)
# Return the newly created system
return newsys
def _isstatic(self):
"""Check to see if a system is a static system (no states)"""
return self.nstates == 0
# Utility function to parse a list of signals
def _process_signal_list(self, signals, prefix='s'):
if signals is None:
# No information provided; try and make it up later
return None, {}
elif isinstance(signals, int):
# Number of signals given; make up the names
return signals, {'%s[%d]' % (prefix, i): i for i in range(signals)}
elif isinstance(signals, str):
# Single string given => single signal with given name
return 1, {signals: 0}
elif all(isinstance(s, str) for s in signals):
# Use the list of strings as the signal names
return len(signals), {signals[i]: i for i in range(len(signals))}
else:
raise TypeError("Can't parse signal list %s" % str(signals))
# Find a signal by name
def _find_signal(self, name, sigdict): return sigdict.get(name, None)
# Update parameters used for _rhs, _out (used by subclasses)
def _update_params(self, params, warning=False):
if warning:
warn("Parameters passed to InputOutputSystem ignored.")
def _rhs(self, t, x, u, params={}):
"""Evaluate right hand side of a differential or difference equation.
Private function used to compute the right hand side of an
input/output system model. Intended for fast
evaluation; for a more user-friendly interface
you may want to use :meth:`dynamics`.
"""
NotImplemented("Evaluation not implemented for system of type ",
type(self))
def dynamics(self, t, x, u):
"""Compute the dynamics of a differential or difference equation.
Given time `t`, input `u` and state `x`, returns the value of the
right hand side of the dynamical system. If the system is continuous,
returns the time derivative
dx/dt = f(t, x, u)
where `f` is the system's (possibly nonlinear) dynamics function.
If the system is discrete-time, returns the next value of `x`:
x[t+dt] = f(t, x[t], u[t])
Where `t` is a scalar.
The inputs `x` and `u` must be of the correct length.
Parameters
----------
t : float
the time at which to evaluate
x : array_like
current state
u : array_like
input
Returns
-------
dx/dt or x[t+dt] : ndarray
"""
return self._rhs(t, x, u)
def _out(self, t, x, u, params={}):
"""Evaluate the output of a system at a given state, input, and time
Private function used to compute the output of of an input/output
system model given the state, input, parameters. Intended for fast
evaluation; for a more user-friendly interface you may want to use
:meth:`output`.
"""
# If no output function was defined in subclass, return state
return x
def output(self, t, x, u):
"""Compute the output of the system
Given time `t`, input `u` and state `x`, returns the output of the
system:
y = g(t, x, u)
The inputs `x` and `u` must be of the correct length.
Parameters
----------
t : float
the time at which to evaluate
x : array_like
current state
u : array_like
input
Returns
-------
y : ndarray
"""
return self._out(t, x, u)
def set_inputs(self, inputs, prefix='u'):
"""Set the number/names of the system inputs.
Parameters
----------
inputs : int, list of str, or None
Description of the system inputs. This can be given as an integer
count or as a list of strings that name the individual signals.
If an integer count is specified, the names of the signal will be
of the form `u[i]` (where the prefix `u` can be changed using the
optional prefix parameter).
prefix : string, optional
If `inputs` is an integer, create the names of the states using
the given prefix (default = 'u'). The names of the input will be
of the form `prefix[i]`.
"""
self.ninputs, self.input_index = \
self._process_signal_list(inputs, prefix=prefix)
def set_outputs(self, outputs, prefix='y'):
"""Set the number/names of the system outputs.
Parameters
----------
outputs : int, list of str, or None
Description of the system outputs. This can be given as an integer
count or as a list of strings that name the individual signals.
If an integer count is specified, the names of the signal will be
of the form `u[i]` (where the prefix `u` can be changed using the
optional prefix parameter).
prefix : string, optional
If `outputs` is an integer, create the names of the states using
the given prefix (default = 'y'). The names of the input will be
of the form `prefix[i]`.
"""
self.noutputs, self.output_index = \
self._process_signal_list(outputs, prefix=prefix)
def set_states(self, states, prefix='x'):
"""Set the number/names of the system states.
Parameters
----------
states : int, list of str, or None
Description of the system states. This can be given as an integer
count or as a list of strings that name the individual signals.
If an integer count is specified, the names of the signal will be
of the form `u[i]` (where the prefix `u` can be changed using the
optional prefix parameter).
prefix : string, optional
If `states` is an integer, create the names of the states using
the given prefix (default = 'x'). The names of the input will be
of the form `prefix[i]`.
"""
self.nstates, self.state_index = \
self._process_signal_list(states, prefix=prefix)
def find_input(self, name):
"""Find the index for an input given its name (`None` if not found)"""
return self.input_index.get(name, None)
def find_output(self, name):
"""Find the index for an output given its name (`None` if not found)"""
return self.output_index.get(name, None)
def find_state(self, name):
"""Find the index for a state given its name (`None` if not found)"""
return self.state_index.get(name, None)
def issiso(self):
"""Check to see if a system is single input, single output"""
return self.ninputs == 1 and self.noutputs == 1
def feedback(self, other=1, sign=-1, params={}):
"""Feedback interconnection between two input/output systems
Parameters
----------
sys1: InputOutputSystem
The primary process.
sys2: InputOutputSystem
The feedback process (often a feedback controller).
sign: scalar, optional
The sign of feedback. `sign` = -1 indicates negative feedback,
and `sign` = 1 indicates positive feedback. `sign` is an optional
argument; it assumes a value of -1 if not specified.
Returns
-------
out: InputOutputSystem
Raises
------
ValueError
if the inputs, outputs, or timebases of the systems are
incompatible.
"""
# TODO: add conversion to I/O system when needed
if not isinstance(other, InputOutputSystem):
# Try converting to a state space system
try:
other = _convert_to_statespace(other)
except TypeError:
raise TypeError(
"Feedback around I/O system must be an I/O system "
"or convertable to an I/O system.")
other = LinearIOSystem(other)
# Make sure systems can be interconnected
if self.noutputs != other.ninputs or other.noutputs != self.ninputs:
raise ValueError("Can't connect systems with incompatible "
"inputs and outputs")
# Make sure timebases are compatible
dt = common_timebase(self.dt, other.dt)
inplist = [(0, i) for i in range(self.ninputs)]
outlist = [(0, i) for i in range(self.noutputs)]
# Return the series interconnection between the systems
newsys = InterconnectedSystem(
(self, other), inplist=inplist, outlist=outlist,
params=params, dt=dt)
# Set up the connecton map manually
newsys.set_connect_map(np.block(
[[np.zeros((self.ninputs, self.noutputs)),
sign * np.eye(self.ninputs, other.noutputs)],
[np.eye(other.ninputs, self.noutputs),
np.zeros((other.ninputs, other.noutputs))]]
))
if isinstance(self, StateSpace) and isinstance(other, StateSpace):
# Special case: maintain linear systems structure
ss_sys = StateSpace.feedback(self, other, sign=sign)
return LinearICSystem(newsys, ss_sys)
# Return the newly created system
return newsys
def linearize(self, x0, u0, t=0, params={}, eps=1e-6,
name=None, copy=False, **kwargs):
"""Linearize an input/output system at a given state and input.
Return the linearization of an input/output system at a given state
and input value as a StateSpace system. See
:func:`~control.linearize` for complete documentation.
"""
#
# If the linearization is not defined by the subclass, perform a
# numerical linearization use the `_rhs()` and `_out()` member
# functions.
#
# Figure out dimensions if they were not specified.
nstates = _find_size(self.nstates, x0)
ninputs = _find_size(self.ninputs, u0)
# Convert x0, u0 to arrays, if needed
if np.isscalar(x0):
x0 = np.ones((nstates,)) * x0
if np.isscalar(u0):
u0 = np.ones((ninputs,)) * u0
# Compute number of outputs by evaluating the output function
noutputs = _find_size(self.noutputs, self._out(t, x0, u0))
# Update the current parameters
self._update_params(params)
# Compute the nominal value of the update law and output
F0 = self._rhs(t, x0, u0)
H0 = self._out(t, x0, u0)
# Create empty matrices that we can fill up with linearizations
A = np.zeros((nstates, nstates)) # Dynamics matrix
B = np.zeros((nstates, ninputs)) # Input matrix
C = np.zeros((noutputs, nstates)) # Output matrix
D = np.zeros((noutputs, ninputs)) # Direct term
# Perturb each of the state variables and compute linearization
for i in range(nstates):
dx = np.zeros((nstates,))
dx[i] = eps
A[:, i] = (self._rhs(t, x0 + dx, u0) - F0) / eps
C[:, i] = (self._out(t, x0 + dx, u0) - H0) / eps
# Perturb each of the input variables and compute linearization
for i in range(ninputs):
du = np.zeros((ninputs,))
du[i] = eps
B[:, i] = (self._rhs(t, x0, u0 + du) - F0) / eps
D[:, i] = (self._out(t, x0, u0 + du) - H0) / eps
# Create the state space system
linsys = LinearIOSystem(
StateSpace(A, B, C, D, self.dt, remove_useless=False),
name=name, **kwargs)
# Set the names the system, inputs, outputs, and states
if copy:
if name is None:
linsys.name = \
config.defaults['iosys.linearized_system_name_prefix'] + \
self.name + \
config.defaults['iosys.linearized_system_name_suffix']
linsys.ninputs, linsys.input_index = self.ninputs, \
self.input_index.copy()
linsys.noutputs, linsys.output_index = \
self.noutputs, self.output_index.copy()
linsys.nstates, linsys.state_index = \
self.nstates, self.state_index.copy()
return linsys
def copy(self, newname=None):
"""Make a copy of an input/output system."""
dup_prefix = config.defaults['iosys.duplicate_system_name_prefix']
dup_suffix = config.defaults['iosys.duplicate_system_name_suffix']
newsys = copy.copy(self)
newsys.name = self._name_or_default(
dup_prefix + self.name + dup_suffix if not newname else newname)
return newsys
class LinearIOSystem(InputOutputSystem, StateSpace):
"""Input/output representation of a linear (state space) system.
This class is used to implement a system that is a linear state
space system (defined by the StateSpace system object).
Parameters
----------
linsys : StateSpace or TransferFunction
LTI system to be converted
inputs : int, list of str or None, optional
Description of the system inputs. This can be given as an integer
count or as a list of strings that name the individual signals. If an
integer count is specified, the names of the signal will be of the
form `s[i]` (where `s` is one of `u`, `y`, or `x`). If this parameter
is not given or given as `None`, the relevant quantity will be
determined when possible based on other information provided to
functions using the system.
outputs : int, list of str or None, optional
Description of the system outputs. Same format as `inputs`.
states : int, list of str, or None, optional
Description of the system states. Same format as `inputs`.
dt : None, True or float, optional
System timebase. 0 (default) indicates continuous time, True indicates
discrete time with unspecified sampling time, positive number is
discrete time with specified sampling time, None indicates unspecified
timebase (either continuous or discrete time).
params : dict, optional
Parameter values for the systems. Passed to the evaluation functions
for the system as default values, overriding internal defaults.
name : string, optional
System name (used for specifying signals). If unspecified, a
generic name <sys[id]> is generated with a unique integer id.
Attributes
----------
ninputs, noutputs, nstates, dt, etc
See :class:`InputOutputSystem` for inherited attributes.
A, B, C, D
See :class:`~control.StateSpace` for inherited attributes.
"""
def __init__(self, linsys, inputs=None, outputs=None, states=None,
name=None, **kwargs):
"""Create an I/O system from a state space linear system.
Converts a :class:`~control.StateSpace` system into an
:class:`~control.InputOutputSystem` with the same inputs, outputs, and
states. The new system can be a continuous or discrete time system.
"""
if isinstance(linsys, TransferFunction):
# Convert system to StateSpace
linsys = _convert_to_statespace(linsys)
elif not isinstance(linsys, StateSpace):
raise TypeError("Linear I/O system must be a state space "
"or transfer function object")
# Look for 'input' and 'output' parameter name variants
inputs = _parse_signal_parameter(inputs, 'input', kwargs)
outputs = _parse_signal_parameter(outputs, 'output', kwargs, end=True)
# Create the I/O system object
super(LinearIOSystem, self).__init__(
inputs=linsys.ninputs, outputs=linsys.noutputs,
states=linsys.nstates, params={}, dt=linsys.dt, name=name)
# Initalize additional state space variables
StateSpace.__init__(self, linsys, remove_useless=False)
# Process input, output, state lists, if given
# Make sure they match the size of the linear system
ninputs, self.input_index = self._process_signal_list(
inputs if inputs is not None else linsys.ninputs, prefix='u')
if ninputs is not None and linsys.ninputs != ninputs:
raise ValueError("Wrong number/type of inputs given.")
noutputs, self.output_index = self._process_signal_list(
outputs if outputs is not None else linsys.noutputs, prefix='y')
if noutputs is not None and linsys.noutputs != noutputs:
raise ValueError("Wrong number/type of outputs given.")
nstates, self.state_index = self._process_signal_list(
states if states is not None else linsys.nstates, prefix='x')
if nstates is not None and linsys.nstates != nstates:
raise ValueError("Wrong number/type of states given.")
# The following text needs to be replicated from StateSpace in order for
# this entry to show up properly in sphinx doccumentation (not sure why,
# but it was the only way to get it to work).
#
#: Deprecated attribute; use :attr:`nstates` instead.
#:
#: The ``state`` attribute was used to store the number of states for : a
#: state space system. It is no longer used. If you need to access the
#: number of states, use :attr:`nstates`.
states = property(StateSpace._get_states, StateSpace._set_states)
def _update_params(self, params={}, warning=True):
# Parameters not supported; issue a warning
if params and warning:
warn("Parameters passed to LinearIOSystems are ignored.")
def _rhs(self, t, x, u):
# Convert input to column vector and then change output to 1D array
xdot = self.A @ np.reshape(x, (-1, 1)) \
+ self.B @ np.reshape(u, (-1, 1))
return np.array(xdot).reshape((-1,))
def _out(self, t, x, u):
# Convert input to column vector and then change output to 1D array
y = self.C @ np.reshape(x, (-1, 1)) \
+ self.D @ np.reshape(u, (-1, 1))
return np.array(y).reshape((-1,))
class NonlinearIOSystem(InputOutputSystem):
"""Nonlinear I/O system.
Creates an :class:`~control.InputOutputSystem` for a nonlinear system by
specifying a state update function and an output function. The new system
can be a continuous or discrete time system (Note: discrete-time systems
are not yet supported by most functions.)
Parameters
----------
updfcn : callable
Function returning the state update function
`updfcn(t, x, u, params) -> array`
where `x` is a 1-D array with shape (nstates,), `u` is a 1-D array
with shape (ninputs,), `t` is a float representing the currrent
time, and `params` is a dict containing the values of parameters
used by the function.
outfcn : callable
Function returning the output at the given state
`outfcn(t, x, u, params) -> array`
where the arguments are the same as for `upfcn`.
inputs : int, list of str or None, optional
Description of the system inputs. This can be given as an integer
count or as a list of strings that name the individual signals.
If an integer count is specified, the names of the signal will be
of the form `s[i]` (where `s` is one of `u`, `y`, or `x`). If
this parameter is not given or given as `None`, the relevant
quantity will be determined when possible based on other
information provided to functions using the system.
outputs : int, list of str or None, optional
Description of the system outputs. Same format as `inputs`.
states : int, list of str, or None, optional
Description of the system states. Same format as `inputs`.
params : dict, optional
Parameter values for the systems. Passed to the evaluation
functions for the system as default values, overriding internal
defaults.
dt : timebase, optional
The timebase for the system, used to specify whether the system is
operating in continuous or discrete time. It can have the
following values:
* dt = 0: continuous time system (default)
* dt > 0: discrete time system with sampling period 'dt'
* dt = True: discrete time with unspecified sampling period
* dt = None: no timebase specified
name : string, optional
System name (used for specifying signals). If unspecified, a
generic name <sys[id]> is generated with a unique integer id.
"""
def __init__(self, updfcn, outfcn=None, inputs=None, outputs=None,
states=None, params={}, name=None, **kwargs):
"""Create a nonlinear I/O system given update and output functions."""
# Look for 'input' and 'output' parameter name variants
inputs = _parse_signal_parameter(inputs, 'input', kwargs)
outputs = _parse_signal_parameter(outputs, 'output', kwargs)
# Store the update and output functions
self.updfcn = updfcn
self.outfcn = outfcn
# Initialize the rest of the structure
dt = kwargs.pop('dt', config.defaults['control.default_dt'])
super(NonlinearIOSystem, self).__init__(
inputs=inputs, outputs=outputs, states=states,
params=params, dt=dt, name=name
)
# Make sure all input arguments got parsed
if kwargs:
raise TypeError("unknown parameters %s" % kwargs)
# Check to make sure arguments are consistent
if updfcn is None:
if self.nstates is None:
self.nstates = 0
else:
raise ValueError("States specified but no update function "
"given.")
if outfcn is None:
# No output function specified => outputs = states
if self.noutputs is None and self.nstates is not None:
self.noutputs = self.nstates
elif self.noutputs is not None and self.noutputs == self.nstates:
# Number of outputs = number of states => all is OK
pass
elif self.noutputs is not None and self.noutputs != 0:
raise ValueError("Outputs specified but no output function "
"(and nstates not known).")
# Initialize current parameters to default parameters
self._current_params = params.copy()
# Return the value of a static nonlinear system
def __call__(sys, u, params=None, squeeze=None):
"""Evaluate a (static) nonlinearity at a given input value
If a nonlinear I/O system has no internal state, then evaluating the
system at an input `u` gives the output `y = F(u)`, determined by the
output function.
Parameters
----------
params : dict, optional
Parameter values for the system. Passed to the evaluation function
for the system as default values, overriding internal defaults.
squeeze : bool, optional
If True and if the system has a single output, return the system
output as a 1D array rather than a 2D array. If False, return the
system output as a 2D array even if the system is SISO. Default
value set by config.defaults['control.squeeze_time_response'].
"""
# Make sure the call makes sense
if not sys._isstatic():
raise TypeError(
"function evaluation is only supported for static "
"input/output systems")
# If we received any parameters, update them before calling _out()
if params is not None:
sys._update_params(params)
# Evaluate the function on the argument
out = sys._out(0, np.array((0,)), np.asarray(u))
_, out = _process_time_response(
None, out, issiso=sys.issiso(), squeeze=squeeze)
return out
def _update_params(self, params, warning=False):
# Update the current parameter values