def test_hybrid_fail_check_time_consistency(self):
# fail _check_time_consistency
hybrid.SwitchedSysDyn(disc_domain_size=self.disc_domain_size,
dynamics=self.dynamics1, env_labels=self.env_labels,
disc_sys_labels=self.sys_labels,
time_semantics='sampled', timestep=.2,
overwrite_time=False)
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_hybrid_difftstep_from_subsys(self):
"""LtiSysDyn subsystems timesteps do not match that of SwitchedSysDyn"""
hybrid.SwitchedSysDyn(disc_domain_size=self.disc_domain_size,
dynamics=self.dynamics1, env_labels=self.env_labels,
disc_sys_labels=self.sys_labels,
time_semantics='hello', timestep=.1,
overwrite_time=True)
def test_correct_switched_construction(self):
switched1 = hybrid.SwitchedSysDyn(disc_domain_size=self.disc_domain_size,
dynamics=self.dynamics1,
env_labels=self.env_labels,
disc_sys_labels=self.sys_labels,
time_semantics='sampled', timestep=.1,
overwrite_time=True)
switched2 = hybrid.SwitchedSysDyn(disc_domain_size=self.disc_domain_size,
dynamics=self.dynamics1,
env_labels=self.env_labels,
disc_sys_labels=self.sys_labels,
time_semantics='sampled', timestep=.1,
overwrite_time=False)
assert(switched1.time_semantics == 'sampled')
assert(switched2.time_semantics == 'sampled')
assert(switched1.timestep == .1)
assert(switched2.timestep == .1)
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 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)
def _import_hybridsys(node):
# Get parts, import the non-optional parts
disc_domain_size = _import_xml(node.findall('disc_domain_size')[0])
sys_labels = node.findall('sys_labels')
env_labels = node.findall('env_labels')
cts_ss = _import_xml(node.findall('cts_ss')[0])
dynamics = _import_xml(node.findall('dynamics')[0])
if sys_labels:
sys_labels = _import_xml(sys_labels[0])
else:
sys_labels = None
if env_labels:
env_labels = _import_xml(env_labels[0])
else:
env_lables = None
return hybrid.SwitchedSysDyn(disc_domain_size=disc_domain_size,
dynamics=dynamics, cts_ss=cts_ss, env_labels=env_labels,
disc_sys_labels=sys_labels)
# 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)
ax = ppp.plot_props()
ax.figure.savefig(imgpath + 'cprops.pdf')
ax = ppp.plot()
ax.figure.savefig(imgpath + 'ppp.pdf')
## Discretize to establish transitions
if os.name == "posix":
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,
env_labels=['regular'],
disc_sys_labels=['off', 'heat', 'cool', 'on'],
time_semantics='sampled',
timestep=0.1,
overwrite_time=True)
#print ssd;
owner = 'env'
abstMOS = ds.discretize_modeonlyswitched(ssd=ssd,
cont_props=cont_props,
owner=owner,
grid_size=1.0,
visualize=False,
eps=0.1,
is_convex=True,
N=1,
abs_tol=1e-7)
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
)
print(switched_dynamics)
ppp = abstract.prop2part(cont_state_space, cont_props)
ppp, new2old = abstract.part2convex(ppp)
"""Discretize to establish transitions"""
start = time.time()
N = 8
trans_len=1
