def rate_converters():
"""Two ZOH converters"""
return {
cs.Connection(cs.Src('inertia', 'omega'), cs.Dst('engine', 'omega')):
cs.Zoh,
cs.Connection(cs.Src('alpha', 'alpha'), cs.Dst('engine', 'alpha')):
cs.Zoh,
cs.Connection(cs.Src('engine', 'tau'), cs.Dst('inertia', 'tau')):
cs.Zoh,
}
def _three_cosimulations(parameters: TwoMass):
"""Helper function"""
csnet = cs_network(parameters)
slaves, connections = csnet
make_zoh: cs.ConverterConstructor = cs.Zoh
rate_converters = {
cs.Connection(src, dst): make_zoh
for dst, src in connections.items()
}
cosimulations = list()
step_sizes_1 = {name: Fraction(1, 4) for name in slaves}
initial_tokens_1 = autoconfig.find_initial_tokens(csnet, step_sizes_1,
rate_converters)
cosimulations.append(
(csnet, step_sizes_1, rate_converters, initial_tokens_1))
step_sizes_2 = {name: Fraction(1, 2) for name in slaves}
initial_tokens_2 = autoconfig.find_initial_tokens(csnet, step_sizes_2,
rate_converters)
cosimulations.append(
(csnet, step_sizes_2, rate_converters, initial_tokens_2))
step_sizes_3 = step_sizes_1
initial_tokens_3 = autoconfig.null_jacobi_initial_tokens(
connections, step_sizes_3)
cosimulations.append(
(csnet, step_sizes_3, rate_converters, initial_tokens_3))
return cosimulations
def simple_execution(end_time=Fraction(100), fig_file=None):
"""The demo function"""
plt.clf()
non_default = dict()
csnet = cs_network(generate_parameters(non_default))
slaves, connections = csnet
step_sizes = {name: Fraction(1, 4) for name in slaves}
make_zoh: cs.ConverterConstructor = cs.Zoh
rate_converters = {
cs.Connection(src, dst): make_zoh
for dst, src in connections.items()
}
initial_tokens = autoconfig.find_initial_tokens(csnet, step_sizes,
rate_converters)
cosimulation = csnet, step_sizes, rate_converters, initial_tokens
results = cs.execute(cosimulation, end_time)
print(f"v_right = {results.tokens['middle_oscillator', 'v_right'][-1]}")
print(f"v_left = {results.tokens['middle_oscillator', 'v_left'][-1]}")
print(f"F_right = {results.tokens['left_oscillator', 'F'][-1]}")
print(f"F_left = {results.tokens['right_oscillator', 'F'][-1]}")
ts, vals = cs.get_signal_samples(cosimulation, results,
'middle_oscillator', 'F_right')
# ts, vals = cs.get_signal_samples(cosimulation, results, 'right_oscillator', 'v')
plt.stem(ts, vals)
show_figure(plt.gcf(), fig_file)
def find_configuration(
csnet: cs.Network, end_time: Fraction, tolerance: float, max_iter: int = 10
) -> cs.Cosimulation:
"""A method for finding a working configuration for the given co-simulation network"""
slaves, connections = csnet
step_sizes: cs.StepSizes = {name: end_time / 10 for name in slaves.keys()}
make_zoh: cs.ConverterConstructor = cs.Zoh
rate_converters = {cs.Connection(src, dst): make_zoh for dst, src in connections.items()}
num_iter = 0
while True:
initial_tokens = find_initial_tokens(csnet, step_sizes, rate_converters)
cosim = csnet, step_sizes, rate_converters, initial_tokens
simulator_defects = calculate_simulator_defects(
slaves, connections, cs.evaluate(cosim, end_time)
)
tolerance_satisfied = all(defect < tolerance for defect in simulator_defects.values())
num_iter += 1
if not tolerance_satisfied and num_iter < max_iter:
step_sizes = {
name: step_size * _step_reduction_factor(simulator_defects[name], tolerance)
for name, step_size in step_sizes.items()
}
else:
defect = cs.evaluate(cosim, end_time)
assert max(max(defect.output.values()), max(defect.connection.values())) < tolerance
break
return csnet, step_sizes, rate_converters, initial_tokens
def test_defect_calculation_control():
"""Tests whether defect calculation give sane results"""
csnet = example.control.cs_network()
slaves, connections = csnet
step_sizes = {name: Fraction(1, 2) for name in slaves}
make_zoh: cs.ConverterConstructor = cs.Zoh
rate_converters = {
cs.Connection(src, dst): make_zoh
for dst, src in connections.items()
}
initial_tokens = {sdf.Dst('PI', 'u'): [0.], sdf.Dst('PT2', 'u'): [0.]}
cosim = csnet, step_sizes, rate_converters, initial_tokens
defect = cs.evaluate(cosim, Fraction(20.))
for val in defect.connection.values():
assert val < float('inf')
for val in defect.output.values():
assert val < float('inf')
def ramp_cosimulation(slope1=2.,
slope2=3.,
step1=Fraction(5),
step2=Fraction(7)):
"""Used for testing the defect calculation"""
csnet = _semiconnected_ramps(slope1, slope2)
_, connections = csnet
step_sizes = {'Ramp1': step1, 'Ramp2': step2}
make_zoh: cs.ConverterConstructor = cs.Zoh
rate_converters = {
cs.Connection(src, dst): make_zoh
for dst, src in connections.items()
}
alpha = Fraction(int(lcm(step1.numerator, step2.numerator)),
int(gcd(step1.denominator, step2.denominator)))
num1, num2 = tuple(map(int, [alpha / step for step in (step1, step2)]))
initial_tokens = {
sdf.Dst('Ramp1', 'u'):
[(i - num1 + 1) * step2 * slope2 for i in range(num1)],
sdf.Dst('Ramp2', 'u'):
[(i - num2 + 1) * step1 * slope1 for i in range(num2)]
}
return csnet, step_sizes, rate_converters, initial_tokens
def rate_converters():
"""Two ZOH converters"""
return {
cs.Connection(cs.Src('PI', 'y'), cs.Dst('PT2', 'u')): cs.Zoh,
cs.Connection(cs.Src('PT2', 'y'), cs.Dst('PI', 'u')): cs.Zoh,
}