def setUp(self):
self.A1 = np.eye(2)
self.A2 = np.array([[0, 1], [0, 0]])
self.B1 = np.array([[0] ,[1]])
self.B2 = np.array([[1], [0]])
self.poly1 = pc.Polytope.from_box([[0, 1], [0, 1]])
self.poly2 = pc.Polytope.from_box([[1, 2], [0, 1]])
self.total_box = pc.Region(list_poly=[self.poly1, self.poly2])
self.Uset = pc.Polytope.from_box([[0, 1]])
self.env_labels = ('hi', 'hello')
self.sys_labels = ('mode1',)
self.disc_domain_size = (2, 1)
self.LTI1 = hybrid.LtiSysDyn(A=self.A1, B=self.B1,
Uset=self.Uset, domain=self.poly1,
time_semantics='sampled', timestep=.1)
self.LTI2 = hybrid.LtiSysDyn(A=self.A2, B=self.B2,
Uset=self.Uset, domain=self.poly2,
time_semantics='sampled', timestep=.1)
self.LTI3 = hybrid.LtiSysDyn(A=self.A1, B=self.B1,
Uset=self.Uset, domain=self.poly2,
time_semantics='sampled', timestep=.1)
self.LTI4 = hybrid.LtiSysDyn(A=self.A2, B=self.B2,
Uset=self.Uset, domain=self.poly1,
time_semantics='sampled', timestep=.1)
self.PWA1 = hybrid.PwaSysDyn(list_subsys=[self.LTI1, self.LTI2],
domain=self.total_box,
time_semantics='sampled', timestep=.1)
self.PWA2 = hybrid.PwaSysDyn(list_subsys=[self.LTI3, self.LTI4],
domain=self.total_box,
time_semantics='sampled', timestep=.1)
self.dynamics1 = {(self.env_labels[0], self.sys_labels[0]): self.PWA1,
(self.env_labels[1], self.sys_labels[0]): self.PWA2}
def transition_directions_test():
"""
unit test for correctness of abstracted transition directions, with:
- uni-directional control authority
- no disturbance
"""
modes = []
modes.append(('normal', 'fly'))
modes.append(('refuel', 'fly'))
env_modes, sys_modes = zip(*modes)
cont_state_space = pc.box2poly([[0., 3.], [0., 2.]])
pwa_sys = dict()
pwa_sys[('normal', 'fly')] = hybrid.PwaSysDyn([subsys0()],
cont_state_space)
pwa_sys[('refuel', 'fly')] = hybrid.PwaSysDyn([subsys1()],
cont_state_space)
switched_dynamics = hybrid.SwitchedSysDyn(
disc_domain_size=(len(env_modes), len(sys_modes)),
dynamics=pwa_sys,
env_labels=env_modes,
disc_sys_labels=sys_modes,
cts_ss=cont_state_space)
cont_props = {}
cont_props['home'] = pc.box2poly([[0., 1.], [0., 1.]])
cont_props['lot'] = pc.box2poly([[2., 3.], [1., 2.]])
ppp = abstract.prop2part(cont_state_space, cont_props)
ppp, new2old = abstract.part2convex(ppp)
N = 8
trans_len = 1
disc_params = {}
for mode in modes:
disc_params[mode] = {'N': N, 'trans_length': trans_len}
swab = abstract.discretize_switched(ppp,
switched_dynamics,
disc_params,
plot=True,
show_ts=True,
only_adjacent=False)
ts = swab.modes[('normal', 'fly')].ts
edges = {(0, 0), (1, 1), (2, 2), (3, 3), (4, 4), (5, 5), (1, 2), (1, 4),
(1, 5), (2, 3), (2, 5), (2, 0), (3, 0), (4, 5), (5, 0)}
logger.debug(set(ts.edges()).symmetric_difference(edges))
assert (set(ts.edges()) == edges)
ts = swab.ts
assert (set(ts.edges()) == edges)
for i, j in edges:
assert (ts[i][j][0]['env_actions'] == 'normal')
assert (ts[i][j][0]['sys_actions'] == 'fly')
def test_correct_pwa_construction(self):
# Putting pwa together successfully, without time overwrite
LTI1 = hybrid.LtiSysDyn(A=self.A1,
B=self.B1,
Uset=self.Uset,
domain=self.poly1,
time_semantics='sampled',
timestep=.1)
LTI2 = hybrid.LtiSysDyn(A=self.A2,
B=self.B2,
Uset=self.Uset,
domain=self.poly2,
time_semantics='sampled',
timestep=.1)
LTI3 = hybrid.LtiSysDyn(A=self.A2,
B=self.B2,
Uset=self.Uset,
domain=self.poly1)
LTI4 = hybrid.LtiSysDyn(A=self.A1,
B=self.B2,
Uset=self.Uset,
domain=self.poly2)
PWA1 = hybrid.PwaSysDyn(list_subsys=[LTI3, LTI4],
domain=self.total_box,
overwrite_time=False)
# Putting pwa together successfully, with time overwrite
PWA2 = hybrid.PwaSysDyn(list_subsys=[LTI1, LTI2],
domain=self.total_box,
time_semantics='sampled',
timestep=.1,
overwrite_time=True)
def transition_directions_test():
"""Unit test for correctness of abstracted transition directions, with:
- uni-directional control authority
- no disturbance
"""
modes = list()
modes.append(('normal', 'fly'))
modes.append(('refuel', 'fly'))
env_modes, sys_modes = zip(*modes)
# dynamics
cont_state_space = pc.box2poly([[0.0, 3.0], [0.0, 2.0]])
pwa_sys = dict()
pwa_sys[('normal', 'fly')] = hybrid.PwaSysDyn([subsys0()],
cont_state_space)
pwa_sys[('refuel', 'fly')] = hybrid.PwaSysDyn([subsys1()],
cont_state_space)
switched_dynamics = hybrid.SwitchedSysDyn(
disc_domain_size=(len(env_modes), len(sys_modes)),
dynamics=pwa_sys,
env_labels=env_modes,
disc_sys_labels=sys_modes,
cts_ss=cont_state_space)
# propositions
cont_props = dict()
cont_props['home'] = pc.box2poly([[0.0, 1.0], [0.0, 1.0]])
cont_props['lot'] = pc.box2poly([[2.0, 3.0], [1.0, 2.0]])
# partition
ppp = abstract.prop2part(cont_state_space, cont_props)
ppp, new2old = abstract.part2convex(ppp)
# configure discretization
N = 8
trans_len = 1
disc_params = dict()
for mode in modes:
disc_params[mode] = dict(N=N, trans_length=trans_len)
# discretize
swab = abstract.discretize_switched(ppp,
switched_dynamics,
disc_params,
plot=True,
show_ts=True,
only_adjacent=False)
# assertions
ts = swab.modes[('normal', 'fly')].ts
edges = {(0, 0), (1, 1), (2, 2), (3, 3), (4, 4), (5, 5), (1, 2), (1, 4),
(1, 5), (2, 3), (2, 5), (2, 0), (3, 0), (4, 5), (5, 0)}
h = nx.MultiDiGraph()
h.add_edges_from(edges)
assert nx.is_isomorphic(ts, h)
ts = swab.ts
assert nx.is_isomorphic(ts, h)
for _, _, d in ts.edges(data=True):
assert d['env_actions'] == 'normal'
assert d['sys_actions'] == 'fly'
def load(filename):
data = scipy.io.loadmat(filename)
islti = bool(data['islti'][0][0])
ispwa = bool(data['ispwa'][0][0])
if islti:
sys = load_lti(data['A'], data['B'], data['domainA'], data['domainB'],
data['UsetA'], data['UsetB'])
elif ispwa:
nlti = len(data['A'][0])
lti_systems = []
for i in xrange(nlti):
A = data['A'][0][i]
B = data['B'][0][i]
K = data['K'][0][i]
domainA = data['domainA'][0][i]
domainB = data['domainB'][0][i]
UsetA = data['UsetA'][0][i]
UsetB = data['UsetB'][0][i]
ltisys = load_lti(A, B, K, domainA, domainB, UsetA, UsetB)
lti_systems.append(ltisys)
cts_ss = polytope.Polytope(data['ctsA'], data['ctsB'])
sys = hybrid.PwaSysDyn(list_subsys=lti_systems, domain=cts_ss)
return sys
def test_pwa_invalid_semantics(self):
LTI1 = hybrid.LtiSysDyn(A=self.A1, B=self.B1,
Uset=self.Uset, domain=self.poly1,
time_semantics='sampled', timestep=.1)
LTI2 = hybrid.LtiSysDyn(A=self.A2, B=self.B2,
Uset=self.Uset, domain=self.poly2,
time_semantics='sampled', timestep=.1)
PWA = hybrid.PwaSysDyn(list_subsys=[LTI1, LTI2], domain=self.total_box,
time_semantics='hello')
def test_pwa_difftseman_from_subsys(self):
"""LtiSysDyn subsystems time semantics do not match that of PwaSysDyn"""
LTI1 = hybrid.LtiSysDyn(A=self.A1, B=self.B1,
Uset=self.Uset, domain=self.poly1,
time_semantics='sampled', timestep=.1)
LTI2 = hybrid.LtiSysDyn(A=self.A2, B=self.B2,
Uset=self.Uset, domain=self.poly2,
time_semantics='sampled', timestep=.1)
PWA = hybrid.PwaSysDyn(list_subsys=[LTI1, LTI2], domain=self.total_box,
time_semantics='discrete', overwrite_time=False)
def test_pwa_difftstep_among_subsys(self):
"""Different timesteps among LtiSysDyn subsystems of PwaSysDyn"""
LTI1 = hybrid.LtiSysDyn(A=self.A1, B=self.B1,
Uset=self.Uset, domain=self.poly1,
time_semantics='sampled', timestep=.1)
LTI2 = hybrid.LtiSysDyn(A=self.A2, B=self.B2,
Uset=self.Uset, domain=self.poly2,
time_semantics='sampled', timestep=.2)
PWA = hybrid.PwaSysDyn(list_subsys=[LTI1, LTI2], domain=self.total_box,
time_semantics='sampled', timestep=.1,
overwrite_time=False)
def _import_pwasys(node):
domain = node.findall('domain')
if domain:
domain = _import_xml(domain[0])
else:
domain = None
# Get list of ltisys
ltilist = node.findall('ltilist')[0]
list_subsys = _import_xml(ltilist)
return hybrid.PwaSysDyn(list_subsys=list_subsys, domain=domain)
def switched_system_test():
subsystems = []
# subsystem 0
A = np.eye(2)
B = np.eye(2)
Uset = pc.box2poly([[0.0, 1.0], [0.0, 1.0]])
domain0 = pc.box2poly([[0.0, 2.0], [0.0, 2.0]])
subsystems += [hybrid.LtiSysDyn(A, B, Uset=Uset, domain=domain0)]
# subsystem 1
domain1 = pc.box2poly([[2.0, 4.0], [0.0, 2.0]])
subsystems += [hybrid.LtiSysDyn(A, B, Uset=Uset, domain=domain1)]
# PWA system
domain = domain0.union(domain1)
pwa = hybrid.PwaSysDyn(subsystems, domain)
# Switched system (mode dynamics the same, just testing code)
dom = (2, 2)
dyn = {
('a', 'c'):pwa,
('a', 'd'):pwa,
('b', 'c'):pwa,
}
env_labels = ['a', 'b']
sys_labels = ['c', 'd']
hyb = hybrid.SwitchedSysDyn(
disc_domain_size=dom,
dynamics=dyn,
cts_ss=domain,
env_labels=env_labels,
disc_sys_labels=sys_labels
)
print(hyb)
assert(hyb.disc_domain_size == dom)
assert(hyb.dynamics == dyn)
assert(hyb.env_labels == env_labels)
assert(hyb.disc_sys_labels == sys_labels)
assert(hyb.cts_ss == domain)
np.array([input_ub, -input_lb, 0]))
U2 = pc.Polytope(np.array([[1, 0, 0], [-1, 0, 0], [1, -1, 0]]),
np.array([input_ub, -input_lb, refill_rate]))
W = pc.Polytope(np.array([[1], [-1]]), np.array([disturbance, disturbance]))
# Normal operation dynamics
cont_dyn_normal = hybrid.LtiSysDyn(A, B, E, K1, U1, W, domain=cont_ss)
# Aerial refueling mode dynamics
cont_dyn_refuel = hybrid.LtiSysDyn(A, B, E, K2, U2, W, domain=cont_ss)
## Switched Dynamics
env_modes = ('normal', 'refuel')
sys_modes = ('fly', )
pwa_normal = hybrid.PwaSysDyn([cont_dyn_normal], domain=cont_ss)
pwa_refuel = hybrid.PwaSysDyn([cont_dyn_refuel], domain=cont_ss)
dynamics_dict = {('normal', 'fly'): pwa_normal, ('refuel', 'fly'): pwa_refuel}
switched_dynamics = hybrid.SwitchedSysDyn(cts_ss=cont_ss,
disc_domain_size=(len(env_modes),
len(sys_modes)),
dynamics=dynamics_dict,
env_labels=env_modes,
disc_sys_labels=sys_modes)
## Create convex proposition preserving partition
ppp = abstract.prop2part(cont_ss, cont_props)
ppp, new2old = abstract.part2convex(ppp)
cont_props['OUTSIDE'] = box2poly([[24., 25.], [24., 25.]])
orig_props = set(cont_props)
out = []
out.append(box2poly([[24., 25.], [24., 25.]]))
sdyn_off = hybrid.LtiSysDyn(A_off, B_zero, None, K_off, None, None,
cont_state_space)
sdyn_heat = hybrid.LtiSysDyn(A_heat, B_zero, None, K_heat, None, None,
cont_state_space)
sdyn_cool = hybrid.LtiSysDyn(A_cool, B_zero, None, K_cool, None, None,
cont_state_space)
sdyn_on = hybrid.LtiSysDyn(A_on, B_zero, None, K_on, None, None,
cont_state_space)
pwa_off = hybrid.PwaSysDyn(
list_subsys=[sdyn_off],
domain=cont_state_space) #,time_semantics='sampled',timestep=0.1)
pwa_heat = hybrid.PwaSysDyn(list_subsys=[sdyn_heat], domain=cont_state_space)
pwa_cool = hybrid.PwaSysDyn(list_subsys=[sdyn_cool], domain=cont_state_space)
pwa_on = hybrid.PwaSysDyn(list_subsys=[sdyn_on], domain=cont_state_space)
#print pwa_off
sys_dyn = {}
sys_dyn['regular', 'off'] = pwa_off
sys_dyn['regular', 'heat'] = pwa_heat
sys_dyn['regular', 'cool'] = pwa_cool
sys_dyn['regular', 'on'] = pwa_on
ssd = hybrid.SwitchedSysDyn(disc_domain_size=(1, 4),
dynamics=sys_dyn,
cts_ss=cont_state_space,
U = box2poly([[-1., 1.], [-1., 1.]])
U.scale(input_bound)
W = box2poly([[-1., 1.], [-1., 1.]])
W.scale(uncertainty)
dom = box2poly([[0., 3.], [0., h]])
sys_dyn = hybrid.LtiSysDyn(A, B, E, None, U, W, dom)
return sys_dyn
for mode, h in zip(modes, allh):
subsystems = [subsys0(h), subsys1(h)]
sys_dyn[mode] = hybrid.PwaSysDyn(subsystems, cont_state_space)
"""Switched Dynamics"""
# collect env, sys_modes
env_modes, sys_modes = zip(*modes)
msg = 'Found:\n'
msg += '\t Environment modes: ' + str(env_modes)
msg += '\t System modes: ' + str(sys_modes)
switched_dynamics = hybrid.SwitchedSysDyn(
disc_domain_size=(len(env_modes), len(sys_modes)),
dynamics=sys_dyn,
env_labels=env_modes,
disc_sys_labels=sys_modes,
cts_ss=cont_state_space
