def test_graph_and_lines(self):
"""Tests simulation with graph and lines"""
config_name = get_full_class_name(Config)
with patch(config_name+'.graph_dict', new_callable=PropertyMock) as mock_graph_dict:
with patch(config_name+'.lines_dict', new_callable=PropertyMock) as mock_lines_dict:
with patch(config_name+'.traffic_data_dict',
new_callable=PropertyMock) as mock_traffic_dict:
mock_graph_dict.return_value = {'A': [('B', 7), ('D', 2)],
'B': [('A', 7), ('C', 1), ('E', 2)],
'C': [('B', 1), ('D', 3)],
'D': [('A', 2), ('C', 3)],
'E': [('B', 2), ('F', 2)],
'F': [('E', 2)]}
mock_lines_dict.return_value = {
0: {'id': 0, 'bus_capacity': 20, 'frequency1': 17, 'frequency2': 17,
'route1': ['A', 'D', 'C', 'B', 'E', 'F'],
'route2': ['F', 'E', 'B', 'A']}}
config = Config(["A", "B", "C", "D", "E", "F"], {}, {}, {}, 1.0)
mock_traffic_dict.return_value = {'E': {'E': 0, 'F': 0, 'D': 0, 'A': 0, 'C': 0, 'B': 0},
'F': {'E': 0, 'F': 0, 'D': 0, 'A': 0, 'C': 0, 'B': 0},
'D': {'E': 0, 'F': 0, 'D': 0, 'A': 0, 'C': 0, 'B': 0},
'A': {'E': 0, 'F': 0, 'D': 0, 'A': 0, 'C': 0, 'B': 0},
'C': {'E': 0, 'F': 0, 'D': 0, 'A': 0, 'C': 0, 'B': 0},
'B': {'E': 0, 'F': 0, 'D': 0, 'A': 0, 'C': 0, 'B': 0}}
simulation = Simulation(config)
def mocked_update(mocked_self):
"""Mocked update """
for bus in mocked_self.buses:
if bus.route == 0:
if bus.id not in mocked_self.mocked_dict.keys():
mocked_self.mocked_dict[bus.id] = []
if bus.time_to_next_stop == 0:
mocked_self.mocked_dict[bus.id].append(bus.current_stop_name)
else:
mocked_self.mocked_dict[bus.id].append(bus.current_stop_name + bus.next_stop_name)
def finished(mocked_self):
mocked_self.mocked_update()
return False
add_property(simulation, "finished", finished)
from types import MethodType
simulation.mocked_update = MethodType(mocked_update, simulation)
add_variable(simulation, "count_finished", 0)
add_variable(simulation, "mocked_dict", {})
count = 0
while count < 35:
count += 1
simulation.refresh()
paths = ['PA', 'A', 'AD', 'AD', 'D', 'DC', 'DC', 'DC', 'C', 'CB', 'B', 'BE', 'BE', 'E', 'EF', 'EF', 'F']
self.assertEqual(len(simulation.mocked_dict), 2)
for path in simulation.mocked_dict.values():
self.assertEqual(path, paths)
def __init__(self, machine_configs, task_configs, algorithm, event_file):
self.env = simpy.Environment()
cluster = Cluster()
cluster.add_machines(machine_configs)
task_broker = Episode.broker_cls(self.env, task_configs)
scheduler = Scheduler(self.env, algorithm)
self.simulation = Simulation(self.env, cluster, task_broker, scheduler,
event_file)
def test_graph_and_lines_transfer_3(self):
"""Tests simulation with graph and lines - looong bus stops"""
config_name = get_full_class_name(Config)
with patch(config_name+'.graph_dict', new_callable=PropertyMock) as mock_graph_dict:
with patch(config_name+'.lines_dict', new_callable=PropertyMock) as mock_lines_dict:
with patch(config_name+'.traffic_data_dict',
new_callable=PropertyMock) as mock_traffic_dict:
class MockedGenerator:
def __init__(self, empty_argument):
self.done = False
def generate(self, src, dest):
if not self.done and src == 'C' and dest == 'F':
self.done = True
return 1
return 0
mock_graph_dict.return_value = {'A': [('B', 2), ('D', 2)],
'B': [('A', 2), ('C', 2), ('E', 2)],
'C': [('B', 8), ('D', 2)],
'D': [('A', 2), ('C', 2)],
'E': [('B', 2), ('F', 2)],
'F': [('E', 2)]}
mock_lines_dict.return_value = {
0: {'id': 0, 'bus_capacity': 20, 'frequency1': 1000, 'frequency2': 1000,
'route1': ['B', 'A', 'D', 'C'],
'route2': ['C', 'D', 'A', 'B']},
1: {'id': 1, 'bus_capacity': 20, 'frequency1': 1000, 'frequency2': 1000,
'route1': ['C', 'B', 'E', 'F'],
'route2': ['F', 'E', 'B', 'C']}}
config = Config(["A", "B", "C", "D", "E", "F"], {}, {}, {}, 1.0)
mock_traffic_dict.return_value = {'E': {'E': 0, 'F': 0, 'D': 0, 'A': 0, 'C': 0, 'B': 0},
'F': {'E': 0, 'F': 0, 'D': 0, 'A': 0, 'C': 0, 'B': 0},
'D': {'E': 0, 'F': 0, 'D': 0, 'A': 0, 'C': 0, 'B': 0},
'A': {'E': 0, 'F': 0, 'D': 0, 'A': 0, 'C': 0, 'B': 0},
'C': {'E': 0, 'F': 1, 'D': 0, 'A': 0, 'C': 0, 'B': 0},
'B': {'E': 0, 'F': 0, 'D': 0, 'A': 0, 'C': 0, 'B': 0}}
simulation = Simulation(config, MockedGenerator)
for _ in range(11):
simulation.refresh()
k = 0
for bus in simulation.buses:
if bus.line.number == 1 and bus.route == 0:
k += 1
self.are_lists_equal(bus.passengers, [PassengersGroup('F', 1)],
passenger_group_equality)
self.are_equal(k, 1)
def __init__(self,
configuration_path: str = global_constants.
DEFAULT_CONFIGURATION_PATH):
super(JsbsimGymEnvironmentWrapper, self).__init__()
self.sim = Simulation(configuration_path=configuration_path)
self._dimensions = 1
self.action_space = spaces.Box(low=-0,
high=1,
shape=(self._dimensions, ),
dtype=np.float32)
self.observation_space = spaces.Box(
low=np.inf,
high=np.inf,
shape=self._getObs().
shape, # Passt sich damit automatisch an die Beobachtung an
dtype=np.float32)
class Episode(object):
def __init__(self, machine_configs, task_configs, algorithm, event_file):
self.env = simpy.Environment()
cluster = Cluster()
cluster.add_machines(machine_configs)
task_broker = Broker(self.env, task_configs)
scheduler = Scheduler(self.env, algorithm)
self.simulation = Simulation(self.env, cluster, task_broker, scheduler,
event_file)
def run(self):
self.simulation.run()
self.env.run()
def __init__(self,
configuration_file: str = config.DEFAULT_CONFIGURATION_FILE):
super(JsbsimGymEnvironmentWrapper, self).__init__()
self.configuration = toml.load(os.path.expanduser(configuration_file))
self.sim = Simulation(configuration_file=configuration_file)
self._dimensions = 1
self.action_space = spaces.Box(low=-0,
high=1,
shape=(self._dimensions, ),
dtype=np.float32)
self.observation_space = spaces.Box(
low=np.inf,
high=np.inf,
shape=self._getObs().
shape, # Passt sich damit automatisch an die Beobachtung an
dtype=np.float32)
self.sim_steps = self.configuration['simulation'][
'agent_interaction_freq']
class JsbsimGymEnvironmentWrapper(gym.Env):
"""Custom Environment that follows gym interface"""
metadata = {'render.modes': ['human']}
def __init__(self,
configuration_file: str = config.DEFAULT_CONFIGURATION_FILE):
super(JsbsimGymEnvironmentWrapper, self).__init__()
self.configuration = toml.load(os.path.expanduser(configuration_file))
self.sim = Simulation(configuration_file=configuration_file)
self._dimensions = 1
self.action_space = spaces.Box(low=-0,
high=1,
shape=(self._dimensions, ),
dtype=np.float32)
self.observation_space = spaces.Box(
low=np.inf,
high=np.inf,
shape=self._getObs().
shape, # Passt sich damit automatisch an die Beobachtung an
dtype=np.float32)
self.sim_steps = self.configuration['simulation'][
'agent_interaction_freq']
def reset(self):
self.sim.reset_with_initial_condition()
observation = self._getObs()
reward = self._calcRewards(observation)
return observation, reward, self._calcDones(), {}
def step(
self, actions: List[np.ndarray]
) -> Tuple[np.ndarray, np.ndarray, np.ndarray, Dict]:
self.sim.set_properties('fcs/throttle-cmd-norm', actions[0])
for _ in range(self.sim_steps):
self.sim.run()
observation = self._getObs()
reward = self._calcRewards(observation)
return observation, reward, self._calcDones(), {}
def _getObs(self) -> np.ndarray:
state = self.sim.get_state()
return np.array(list(state.values()))
def _calcRewards(self, observation) -> np.ndarray:
rewAgent0 = 0
return np.array([rewAgent0], dtype=np.float32)
def _calcDones(self) -> np.ndarray:
dones = np.zeros(1)
return dones
def render(self, mode='human'):
pass
def close(self):
pass
def seed(self, seed=None) -> None:
pass
def main():
if len(sys.argv) != 11:
print(
"Input parameters must be: 'lambda mu theta C c0 Q L H simulation_time repeats'"
)
else:
start_time = time.time()
lambd = float(sys.argv[1])
mu = float(sys.argv[2])
theta = float(sys.argv[3])
C = int(sys.argv[4])
c0 = int(sys.argv[5])
Q = int(sys.argv[6])
L = int(sys.argv[7])
H = int(sys.argv[8])
simulation_time = int(sys.argv[9])
repeats = int(sys.argv[10])
print("Test for M/M/C[c0]/R[L,H]: lambda =", lambd, ", mu =", mu,
", theta = ", theta, ", C =", C, ", c0=", c0, ", Q =", Q,
", sim time =", simulation_time, ", repeats =", repeats)
B = 0
W = 0
N = 0
is_debug = False
simulation = Simulation("m/m/c[c0]/r[l,h]", lambd, mu, theta, C, c0, L,
H, simulation_time, Q, is_debug)
for i in range(0, repeats):
simulation = Simulation("m/m/c[c0]/r[l,h]", lambd, mu, theta, C,
c0, L, H, simulation_time, Q, is_debug)
simulation.start_requests(simulation_time)
B += simulation.queue.blocked / (simulation.queue.blocked +
simulation.served_count)
w = 0
for request in simulation.served_requests:
w += request.w
for request in simulation.queue.blocked_requests:
w += request.w
W += w / (simulation.served_count +
len(simulation.queue.blocked_requests))
N += (w / (simulation.served_count +
len(simulation.queue.blocked_requests))) * lambd
B /= repeats
W /= repeats
N /= repeats
end_time = time.time()
print("B =", B, "\nW =", W, "\nN =", N)
print("Execution time = %s seconds" % (end_time - start_time))
def generate_statistics(self):
generated_values = []
t1 = time.time()
for lambd in self.range_dict[PARAM.LAMBDA]:
for mu in self.range_dict[PARAM.MU]:
for theta in self.range_dict[PARAM.THETA]:
for C in self.range_dict[PARAM.C]:
for c0 in self.range_dict[PARAM.c0]:
for L in self.range_dict[PARAM.L]:
for H in self.range_dict[PARAM.H]:
for Q in self.range_dict[PARAM.Q]:
if lambd <= 0: continue
if mu <= 0: continue
if theta <= 0: continue
if C <= 0: continue
if c0 <= 0: continue
if L <= 0: continue
if H <= 0: continue
if Q <= 0: continue
if c0 > C or c0 < 0: continue
if H - L < 2: continue
if Q - H <= 2: continue
if H < L or H > Q: continue
if L > Q: continue
start_time = time.time()
generated_values_storage = Generated_values_storage(
)
for repeats in self.range_dict[
PARAM.REPEATS]:
sim = Simulation(
self.mode, lambd, mu, theta, C,
c0, L, H, self.simulation_time,
Q, self.is_debug)
if (self.strategy == "time"):
sim.start()
else:
sim.start_requests(
self.simulation_time)
generated_values_storage.add(sim)
end_time = time.time()
generated_values_storage.normalize(
self.parameters[
PARAM.REPEATS].end_value)
generated_values.append(
generated_values_storage)
self.log(lambd, mu, theta, C, c0, L, H,
Q, start_time, end_time)
t2 = time.time()
print("Total simulation time = %.5f" % (t2 - t1))
return generated_values
def generate(self):
"""
Run simulation and collect statistic depending with specified strategy
strategy = {
single - run with fixed params
range - run for specified range
}
strategy depends on input_range, if there is no range then single simulation will be executed
"""
generated_values = []
print("Input parameters has range =", self.has_range, "\n")
if self.has_range:
for var in np.arange(self.input_range[0], self.input_range[1] + 1,
self.step):
start_time = time.time()
generated_values_storage = Generated_values_storage()
for i in range(0, int(self.repeats)):
sim = Simulation("m/m/c[c0]/r[l,h]",
self.lambd if self.lambd != -1 else var,
self.mu if self.mu != -1 else var,
self.theta if self.theta != -1 else var,
int(self.C) if self.C != -1 else var,
int(self.c0) if self.c0 != -1 else var,
int(self.L) if self.L != -1 else var,
int(self.H) if self.H != -1 else var,
int(self.simulation_time),
int(self.Q) if self.Q != -1 else var,
self.is_debug)
sim.start()
generated_values_storage.add(sim)
end_time = time.time()
print("Generated values added to storage for ", self.x_axis,
" = ", var, "/", self.input_range[1], ", repeated ",
len(range(0, int(self.repeats))), " times, ",
"execution time = %s sec" % (end_time - start_time))
generated_values_storage.normalize(self.repeats)
generated_values.append(generated_values_storage)
else:
for i in range(1, self.repeats):
print("Repeat #", i)
generated_values_storage = Generated_values_storage()
sim = Simulation("m/m/c[c0]/r[l,h]", self.lambd, self.mu,
self.theta, int(self.C), int(self.c0),
int(self.L), int(self.H),
int(self.simulation_time), int(self.Q),
self.is_debug)
generated_values_storage.add(sim)
generated_values_storage.normalize(self.repeats)
generated_values.append(generated_values_storage)
return generated_values
("Name", '$name'),
("index", "$index"),
("Wert", "$y")]
p = figure(title="simple line example", x_axis_label='Datapoints', y_axis_label='Data', tooltips=TOOLTIPS)
p.line(df['phi'].index.values, df['phi'], line_width=2,
legend_label='phi', name='phi', color="red")
p.line(df['theta'].index.values, df['theta'], line_width=2,
legend_label='theta', name='theta', color="green")
p.line(df['u'].index.values, df['u'], line_width=2,
legend_label='u', name='u', color="blue")
output_file("plot.html")
save(p)
sim = Simulation()
result = sim.run()
sim.set_properties('propulsion/engine/set-running', 1)
sim.set_properties('fcs/throttle-cmd-norm', 1.0)
i = 0
state = ""
before = datetime.now()
while result and sim.jsbsim.get_sim_time() <= 50:
#print(i)
state = sim.get_state()
if i%5==0:
sim.set_properties('fcs/aileron-cmd-norm', pid.innerLoopAileron(np.deg2rad(5), state['phi'], state['p'],
sim.jsbsim.get_property_value(
'fcs/aileron-cmd-norm')))
sim.set_properties('fcs/elevator-cmd-norm', pid.innerLoopElevator(np.deg2rad(-10), state['theta'], state['q'],
sim.jsbsim.get_property_value(
p.line(df['u'].index.values,
df['u'],
line_width=2,
legend_label='u',
name='u',
color="blue")
p.line(df['rpm'].index.values,
df['rpm'],
line_width=2,
legend_label='rpm',
name='rpm',
color="black")
output_file("plot.html")
save(p)
sim = Simulation()
result = sim.run()
sim.set_properties('propulsion/starter_cmd', 1)
sim.set_properties('propulsion/engine/set-running', 1)
sim.set_properties('propulsion/magneto_cmd', 2.0)
sim.set_properties('fcs/mixture-cmd-norm', 0.87)
sim.set_properties('fcs/throttle-cmd-norm', 1.0)
i = 0
state = ""
before = datetime.now()
while result and sim.jsbsim.get_sim_time() <= 50:
#print(i)
state = sim.get_state()
sim.set_properties('fcs/throttle-cmd-norm', 0.99)
sim.set_properties('fcs/mixture-cmd-norm', 0.87)
if i % 5 == 0:
adapters = get_available_adapters(arguments.device,
device_package=arguments.device_package)
protocols = {adapter.protocol for adapter in adapters.values()}
for p in protocols:
print(p)
exit()
device = device_type(**parameters)
adapter = import_adapter(arguments.device,
arguments.protocol,
device_package=arguments.device_package)(
device, arguments.adapter_args)
simulation = Simulation(device=device, adapter=adapter)
simulation.cycle_delay = arguments.cycle_delay
simulation.speed = arguments.speed
if arguments.rpc_host:
simulation.control_server = ControlServer(
{
'device':
device,
'simulation':
ExposedObject(simulation, exclude=('start', 'control_server'))
}, *arguments.rpc_host.split(':'))
simulation.start()
def main():
lambd = 2
mu = 1
theta = 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001
C = 5
c0 = 1
Q = 10
L = 3
H = 6
simulation_time = 1000
repeats = 1
served_requests = [
10**2, 10**3, 10**4, 10**5, 10**6, 10**7, 10**8, 10**9, 10**10
]
files = []
for sr in served_requests:
start_time = time.time()
theoretical_mmcr = MMCR(lambd, mu, c0, Q)
theoretical_result = theoretical_mmcr.run()
B = theoretical_result[0]
W = theoretical_result[1]
N = theoretical_result[2]
### sim
B2 = 0
W2 = 0
N2 = 0
served = 0
is_debug = False
if is_debug: print("Q=", Q)
simulation = Simulation("m/m/c/r", lambd, mu, theta, C, c0, L, H,
simulation_time, Q, is_debug)
for i in range(0, repeats):
simulation = Simulation("m/m/c/r", lambd, mu, theta, C, c0, L, H,
simulation_time, Q, is_debug)
simulation.start(sr)
B2 += simulation.queue.blocked / (simulation.queue.blocked +
simulation.served_count)
w = 0
for request in simulation.served_requests:
w += request.w
for request in simulation.queue.blocked_requests:
w += request.w
W2 += w / (simulation.served_count +
len(simulation.queue.blocked_requests))
N2 += (w / (simulation.served_count +
len(simulation.queue.blocked_requests))) * lambd
B2 /= repeats
W2 /= repeats
N2 /= repeats
end_time = time.time()
abs_path = os.path.abspath(__file__)
path = 'served_requests_test' + '-(lambda=%s,mu=%s,theta=%s,C=%s,c0=%s,L=%s,H=%s,sim_time=%s, served requests =%s)' % (
lambd, mu, theta, C, c0, L, H, (end_time - start_time), sr)
path = path + ".csv"
outfile = open(path, 'w')
output = csv.writer(outfile, delimiter=';')
output.writerow(['Served', 'theor B', 'imit B', 'diff'])
outrow = []
outrow.append(B)
outrow.append(B2)
outrow.append(abs((B2 - B) / B))
output.writerow(outrow)
output.writerow(['Served', 'theor N', 'imit N', 'diff'])
outrow = []
outrow.append(N)
outrow.append(N2)
outrow.append(abs((N2 - N) / N))
output.writerow(outrow)
output.writerow(['Served', 'theor W', 'imit W', 'diff'])
outrow = []
outrow.append(W)
outrow.append(W2)
outrow.append(abs((W2 - W) / W))
output.writerow(outrow)
outfile.close()
files.append(path)
print("theoretical B =", B, ", simulation B=", B2, ", Difference = ",
abs((B2 - B) / B),
"\ntheoretical W =", W, ", simulation W=", W2, ", Difference = ",
abs((W2 - W) / W), "\ntheoretical N =", N, ", simulation N=", N2,
", Difference = ", abs((N2 - N) / N))
def main():
if len(sys.argv) != 9:
print("Input parameters must be: 'lambda mu theta C c0 Q simulation_time repeats'")
else:
start_time = time.time()
lambd = float(sys.argv[1])
mu = float(sys.argv[2])
theta = float(sys.argv[3])
C = int(sys.argv[4])
c0 = int(sys.argv[5])
Q = int(sys.argv[6])
simulation_time = int(sys.argv[7])
repeats = int(sys.argv[8])
# unused parameters
L = 1
H = 1
#
print("Difference test for M/M/C[c0]/R: lambda =", lambd, ", mu =", mu, ", C =", C, ", c0=", c0,", Q =", Q, ", theta = ", theta, ", sim time =",
simulation_time, ", repeats =", repeats)
print("c0 will be used for theoretical m/m/c/r calculation")
### theoretical
theoretical_mmcr = MMCR(lambd, mu, c0, Q)
theoretical_result = theoretical_mmcr.run()
B = theoretical_result[0]
W = theoretical_result[1]
N = theoretical_result[2]
### sim
B2 = 0
W2 = 0
N2 = 0
is_debug = False
if is_debug: print("Q=",Q)
simulation = Simulation("m/m/c[c0]/r", lambd, mu, theta, C, c0, L, H, simulation_time, Q, is_debug)
for i in range(0, repeats):
simulation = Simulation("m/m/c[c0]/r", lambd, mu, theta, C, c0, L, H, simulation_time, Q, is_debug)
simulation.start()
B2 += simulation.queue.blocked / (simulation.queue.blocked + simulation.served_count)
w = 0
for request in simulation.served_requests:
w += request.w
for request in simulation.queue.blocked_requests:
w += request.w
W2 += w / (simulation.served_count + len(simulation.queue.blocked_requests))
N2 += (w / (simulation.served_count + len(simulation.queue.blocked_requests))) * lambd
B2 /= repeats
W2 /= repeats
N2 /= repeats
end_time = time.time()
print("theoretical B =", B, ", simulation B=", B2, ", Difference = ", abs((B2 - B) / B),
"\ntheoretical W =", W, ", simulation W=", W2, ", Difference = ", abs((W2 - W) / W),
"\ntheoretical N =", N, ", simulation N=", N2, ", Difference = ", abs((N2 - N) / N))
print("Execution time = %s seconds" % (end_time - start_time))
parser.add_argument('-m', '--metrics', action="extend", nargs="+", type=str,
help='Metrics to be calculated after a simulation '\
'finishes.')
parser.add_argument('-d',
'--discard',
action="extend",
nargs="+",
type=str,
help='If set, discards the created .')
def tui(stdscr):
total_jobs = len(Simulation.instances_status)
s = screen.SimulationScreen(stdscr, total_jobs)
s.init()
s.loop(settings.PARALLEL_INSTANCES)
if __name__ == "__main__":
options = parser.parse_args()
settings_module = options.settings or 'settings'
settings = Settings(settings_module)
if options.display_stdout:
setattr(settings, 'STDOUT', None)
build_simulations(settings, options=options)
if options.use_tui:
curses.wrapper(tui)
else:
Simulation.dispatch_all(settings.PARALLEL_INSTANCES)
Simulation.join()
def main():
"""
Main method to launch
"""
if len(sys.argv) < 12 or len(sys.argv) > 13:
print("Input parameters must be: 'filename lambda mu C c0 Q theta L H simulation_time is_debug repeats(optionally)'")
else:
start_time = time.time()
file_name = sys.argv[1]
lambd = float(sys.argv[2])
mu = float(sys.argv[3])
C = int(sys.argv[4])
c0 = int(sys.argv[5])
Q = int(sys.argv[6])
theta = float(sys.argv[7])
L = int(sys.argv[8])
H = int(sys.argv[9])
simulation_time = float(sys.argv[10]);
is_debug = True if sys.argv[11] == "True" else False;
repeats = int(sys.argv[12]) if len(sys.argv) == 13 else 1;
print("Simulation started for params: lambda =", lambd,
", mu =", mu,
", C =", C,
", c0 =", c0,
", Q =", Q,
", theta =", theta,
", L =", L,
", H =", H,
", repeats =", repeats)
blocked = 0
served = 0
generated = 0
B = 0
N = 0
simulation = Simulation("m/m/c[c0]/r[l,h]", lambd, mu, theta, C, c0, L, H, simulation_time, Q, is_debug)
for i in range(0, repeats):
simulation = Simulation("m/m/c[c0]/r[l,h]", lambd, mu, theta, C, c0, L, H, simulation_time, Q, is_debug)
simulation.start()
blocked += simulation.queue.blocked
served += simulation.served_count
generated += simulation.flow.generated_count
B += simulation.queue.blocked/(simulation.served_count+simulation.queue.blocked)
N += simulation.served_count/simulation_time
end_time = time.time()
blocked = blocked/repeats
served = served/repeats
generated = generated/repeats
B = B/repeats
N = N/repeats
print( "")
print( "Summary results:")
print( "blocked=", blocked, " served=", served, ", generated=", generated)
print("B = ", B)
print("N = ", N)
print("Execution time = %s seconds" % (end_time - start_time))
print( "... to be implemented more summary ...")
# write stats to file
abs_path = os.path.abspath(__file__)
path = os.path.relpath('stats', abs_path)
path = os.path.join(path, file_name + '-(%s,%s,%s,%s,%s,%s,%s,%s).csv' % (lambd,mu,theta,C,c0,L,H,simulation_time))
outfile=open(path,'w')
output = csv.writer(outfile, delimiter=';')
output.writerow(['Request ID','Queue', 'Arrival_Time','Queue_Arrival_time','Server_Arrival_time','alpha','beta'])
i=0
for request in simulation.served_requests:
i=i+1
outrow=[]
outrow.append(request.ID)
outrow.append(request.queue_size_at_serving)
outrow.append(request.arrival_time)
outrow.append(request.queue_arrival_time)
outrow.append(request.server_arrival_time)
outrow.append(request.alpha)
outrow.append(request.beta)
output.writerow(outrow)
outfile.close()
return simulation
def main():
if len(sys.argv) != 7:
print(
"Input parameters must be: 'lambda mu C Q simulation_time repeats'"
)
else:
start_time = time.time()
print(
"Difference test for theoretical M/M/C/R model and 'm/m/c/r' imitation mode."
)
lambd = float(sys.argv[1])
mu = float(sys.argv[2])
C = int(sys.argv[3])
R = int(sys.argv[4])
simulation_time = int(sys.argv[5])
repeats = int(sys.argv[6])
theoretical_mmcr = MMCR(lambd, mu, C, R)
theoretical_result = theoretical_mmcr.run()
B = theoretical_result[0]
W = theoretical_result[1]
N = theoretical_result[2]
Wq = theoretical_result[3]
Q = theoretical_result[4]
### sim
B2 = 0
W2 = 0
N2 = 0
Wq2 = 0
Q2 = 0
theta = 1
L = 1
H = 1
c0 = C
is_debug = False
simulation = Simulation("m/m/c/r", lambd, mu, theta, C, c0, L, H,
simulation_time, R, is_debug)
for i in range(0, repeats):
simulation = Simulation("m/m/c/r", lambd, mu, theta, C, c0, L, H,
simulation_time, R, is_debug)
simulation.start()
B2 += simulation.queue.blocked / (simulation.queue.blocked +
simulation.served_count)
w = 0
for request in simulation.served_requests:
w += request.w
for request in simulation.queue.blocked_requests:
w += request.w
W2 += w / (simulation.served_count +
len(simulation.queue.blocked_requests))
N2 += (w / (simulation.served_count +
len(simulation.queue.blocked_requests))) * lambd
wq = 0
for request in simulation.served_requests:
wq += request.wq
for request in simulation.queue.blocked_requests:
wq += request.wq
Wq2 += wq / (simulation.served_count +
len(simulation.queue.blocked_requests))
Q2 += (wq / (simulation.served_count +
len(simulation.queue.blocked_requests))) * lambd
B2 /= repeats
W2 /= repeats
N2 /= repeats
Wq2 /= repeats
Q2 /= repeats
end_time = time.time()
print("theoretical B =", B, ", simulation B=", B2, ", Difference = ",
abs((B2 - B) / B),
"\ntheoretical W =", W, ", simulation W=", W2, ", Difference = ",
abs((W2 - W) / W), "\ntheoretical N =", N, ", simulation N=", N2,
", Difference = ", abs((N2 - N) / N), "\ntheoretical Wq =",
Wq, ", simulation Wq=", Wq2, ", Difference = ",
abs((Wq2 - Wq) / Wq), "\ntheoretical Q =", Q, ", simulation Q=",
Q2, ", Difference = ", abs((Q2 - Q) / Q))
print("Execution time = %s seconds" % (end_time - start_time))
