def __init__(self, sim_param=SimParam(), no_seed=False): """ Initialize the Simulation object. :param sim_param: is an optional SimParam object for parameter pre-configuration :param no_seed: is an optional parameter. If it is set to True, the RNG should be initialized without a a specific seed. """ self.sim_param = sim_param self.sim_state = SimState() self.system_state = SystemState(self) self.event_chain = EventChain() self.sim_result = SimResult(self) # TODO Task 2.4.3: Uncomment the line below self.counter_collection = CounterCollection(self) # TODO Task 3.1.2: Uncomment the line below and replace the "None" if no_seed: #if the mean = 1.0, then 1/lambda_ = 1.0 -> lambda_ = 1 self.rng = RNG(ExponentialRNS(1.0), ExponentialRNS(1. / float(self.sim_param.RHO))) else: self.rng = RNG( ExponentialRNS(1.0, self.sim_param.SEED_IAT), ExponentialRNS(1. / float(self.sim_param.RHO), self.sim_param.SEED_ST))
def __init__(self, setting): # Load simulation parameters self.sim_param = SimParam(setting) # Load simtime if setting.dynamictest: self.SIMTIME = setting.dynamictest.simtime self.freeaccess = False if setting.secondwindow.test_values[3]: self.freeaccess = True # Load the simulation state parameters self.sim_state = SimState() # Load the result parameters self.sim_result = SimResult() # Load the class which perfomrs all the methods governing a simple slot self.slot = TreeSlot() # Load the branch node which keeps track of a tree self.branch_node = BranchNode() # Create an array of integers of which will contain all active nodes. self.active_array = [] # For gated access, the arrived packets are put into a queue self.queue_array = [] # The number of packets generated in a single slot self.packets_gen = 0 # THe result of a slot self.result = 0 # The current slot no self.slot_no = 0 # Load the parameters for single tree resolution self.tree_state = TreeState(self)
def reset(self): """ Reset the Simulation object. """ self.sim_state = SimState() self.system_state = SystemState(self) self.event_chain = EventChain() self.sim_result = SimResult(self) self.counter_collection = CounterCollection(self) self.rng.iat_rns.set_parameters(1.) self.rng.st_rns.set_parameters(1. / float(self.sim_param.RHO))
def reset(self, no_seed=False): """ Reset the Simulation object. :param no_seed: is an optional parameter. If it is set to True, the RNG should be reset without a a specific seed. """ self.sim_state = SimState() self.system_state = SystemState(self) self.event_chain = EventChain() self.sim_result = SimResult(self) # TODO Task 2.4.3: Uncomment the line below self.counter_collection = CounterCollection(self) # TODO Task 3.1.2: Uncomment the line below and replace the "None" """
def __init__(self, sim_param=SimParam(), no_seed=False): """ Initialize the Simulation object. :param sim_param: is an optional SimParam object for parameter pre-configuration :param no_seed: is an optional parameter. If it is set to True, the RNG should be initialized without a a specific seed. """ self.sim_param = sim_param self.sim_state = SimState() self.system_state = SystemState(self) self.event_chain = EventChain() self.sim_result = SimResult(self) # TODO Task 2.4.3: Uncomment the line below self.counter_collection = CounterCollection(self) # TODO Task 3.1.2: Uncomment the line below and replace the "None" """
def reset(self, no_seed=False): """ Reset the Simulation object. :param no_seed: is an optional parameter. If it is set to True, the RNG should be reset without a a specific seed. """ self.sim_state = SimState() self.system_state = SystemState(self) self.event_chain = EventChain() self.sim_result = SimResult(self) # TODO Task 2.4.3: Uncomment the line below self.counter_collection = CounterCollection(self) # TODO Task 3.1.2: Uncomment the line below and replace the "None" if no_seed: self.rng = RNG(ExponentialRNS(1.0), ExponentialRNS(1./float(self.sim_param.RHO))) else: self.rng = RNG(ExponentialRNS(1.0, self.sim_param.SEED_IAT), ExponentialRNS(1./float(self.sim_param.RHO),self.sim_param.SEED_ST))
def reset(self, setting): self.sim_param = SimParam(setting) if setting.dynamictest: self.SIMTIME = setting.dynamictest.simtime self.freeaccess = False if setting.secondwindow.test_values[3]: self.freeaccess = True self.sim_state = SimState() self.sim_result = SimResult() self.slot = TreeSlot() self.active_array = [] self.queue_array = [] self.packets_gen = 0 self.result = 0 self.slot_no = 0 self.tree_state = TreeState(self) self.branch_node.reset()
def reset(self, no_seed=False): """ Reset the Simulation object. :param no_seed: is an optional parameter. If it is set to True, the RNG should be reset without a a specific seed. """ self.sim_state = SimState() self.system_state = SystemState(self) self.event_chain = EventChain() self.sim_result = SimResult(self) self.counter_collection = CounterCollection(self) if no_seed: self.rng = RNG(ExponentialRNS(1), ExponentialRNS(1. / float(self.sim_param.RHO))) else: self.rng = RNG( ExponentialRNS(1, self.sim_param.SEED_IAT), ExponentialRNS(1. / float(self.sim_param.RHO), self.sim_param.SEED_ST))
def __init__(self, sim_param=SimParam(), no_seed=False): """ Initialize the Simulation object. :param sim_param: is an optional SimParam object for parameter pre-configuration :param no_seed: is an optional parameter. If it is set to True, the RNG should be initialized without a a specific seed. """ self.sim_param = sim_param self.sim_state = SimState() self.system_state = SystemState(self) self.event_chain = EventChain() self.sim_result = SimResult(self) self.counter_collection = CounterCollection(self) if no_seed: self.rng = RNG(ExponentialRNS(1), ExponentialRNS(1. / float(self.sim_param.RHO))) else: self.rng = RNG( ExponentialRNS(1, self.sim_param.SEED_IAT), ExponentialRNS(1. / float(self.sim_param.RHO), self.sim_param.SEED_ST))
class Simulation(object): def __init__(self, sim_param=SimParam(), no_seed=False): """ Initialize the Simulation object. :param sim_param: is an optional SimParam object for parameter pre-configuration :param no_seed: is an optional parameter. If it is set to True, the RNG should be initialized without a a specific seed. """ self.sim_param = sim_param self.sim_state = SimState() self.system_state = SystemState(self) self.event_chain = EventChain() self.sim_result = SimResult(self) # TODO Task 2.4.3: Uncomment the line below self.counter_collection = CounterCollection(self) # TODO Task 3.1.2: Uncomment the line below and replace the "None" if no_seed: #if the mean = 1.0, then 1/lambda_ = 1.0 -> lambda_ = 1 self.rng = RNG(ExponentialRNS(1.0), ExponentialRNS(1. / float(self.sim_param.RHO))) else: self.rng = RNG( ExponentialRNS(1.0, self.sim_param.SEED_IAT), ExponentialRNS(1. / float(self.sim_param.RHO), self.sim_param.SEED_ST)) def reset(self, no_seed=False): """ Reset the Simulation object. :param no_seed: is an optional parameter. If it is set to True, the RNG should be reset without a a specific seed. """ self.sim_state = SimState() self.system_state = SystemState(self) self.event_chain = EventChain() self.sim_result = SimResult(self) # TODO Task 2.4.3: Uncomment the line below self.counter_collection = CounterCollection(self) # TODO Task 3.1.2: Uncomment the line below and replace the "None" self.rng.iat_rns.set_parameters(1.) self.rng.st_rns.set_parameters(1. / float(self.sim_param.RHO)) def do_simulation(self): """ Do one simulation run. Initialize simulation and create first and last event. After that, one after another event is processed. :return: SimResult object """ # insert first and last event self.event_chain.insert(CustomerArrival(self, 0)) self.event_chain.insert( SimulationTermination(self, self.sim_param.SIM_TIME)) # start simulation (run) while not self.sim_state.stop: # TODO Task 1.4.1: Your code goes here """ Hint: You can use and adapt the following lines in your realization e = self.event_chain.remove_oldest_event() e.process() """ e = self.event_chain.remove_oldest_event() if e: if self.sim_state.now <= e.timestamp: self.sim_state.now = e.timestamp self.counter_collection.count_queue() e.process() else: self.sim_state.stop = True #pass # TODO Task 2.4.3: Your code goes here somewhere # gather results for sim_result object self.sim_result.gather_results() return self.sim_result def do_simulation_n_limit(self, n, first_batch): """ Call this function, if the simulation should stop after a given number of packets Do one simulation run. Initialize simulation and create first event. After that, one after another event is processed. :param n: number of customers, that are processed before the simulation stops :return: SimResult object """ # insert first event if not first_batch: # if this is a first batch self.event_chain.insert(CustomerArrival(self, 0)) # start simulation (run) while not self.sim_state.stop: # TODO Task 4.3.2: Your code goes here # TODO Task 5.2.2: Your code goes here e = self.event_chain.remove_oldest_event() if e: if self.sim_state.now <= e.timestamp: self.sim_state.now = e.timestamp self.counter_collection.count_queue() e.process() if (self.sim_state.num_packets) >= n: self.sim_state.stop = True else: self.sim_state.stop = True #pass # gather results for sim_result object self.sim_result.gather_results() return self.sim_result
def task_5_2_2(): """ Run simulation in batches. Start the simulation with running until a customer count of n=100 or (n=1000) and continue to increase the number of customers by dn=n. Count the blocking proabability for the batch and calculate the confidence interval width of all values, that have been counted until now. Do this until the desired confidence level is reached and print out the simulation time as well as the number of batches. """ num_batches1 = 0 num_batches2 = 0 num_batches3 = 0 num_batches4 = 0 TIC = TimeIndependentCounter("bp") # TODO Task 5.2.2: Your code goes here sim_param = SimParam() random.seed(sim_param.SEED) sim = Simulation(sim_param) sim.sim_param.S = 4 sim.sim_param.RHO = 0.9 ## n = 100 # ALPHA: 5% with warnings.catch_warnings(): warnings.simplefilter("ignore", category=RuntimeWarning) TIC.count(sim.do_simulation_n_limit(100).blocking_probability) for i in range(10000): sim.sim_result = SimResult(sim) sim.sim_state.stop = False sim.sim_state.num_packets = 0 sim.sim_state.num_blocked_packets = 0 with warnings.catch_warnings(): warnings.simplefilter("ignore", category=RuntimeWarning) TIC.count( sim.do_simulation_n_limit(100, True).blocking_probability) print TIC.report_confidence_interval(0.05) if TIC.report_confidence_interval(0.05) < 0.0015: num_batches1 = i + 1 break t1 = sim.sim_state.now # ALPHA: 10% sim.reset() TIC.reset() with warnings.catch_warnings(): warnings.simplefilter("ignore", category=RuntimeWarning) TIC.count(sim.do_simulation_n_limit(100).blocking_probability) for i in range(10000): sim.sim_result = SimResult(sim) sim.sim_state.stop = False sim.sim_state.num_packets = 0 sim.sim_state.num_blocked_packets = 0 with warnings.catch_warnings(): warnings.simplefilter("ignore", category=RuntimeWarning) TIC.count( sim.do_simulation_n_limit(100, True).blocking_probability) print TIC.report_confidence_interval(0.1) if TIC.report_confidence_interval(0.1) < 0.0015: num_batches2 = i + 1 break t2 = sim.sim_state.now sim.reset() ## n = 1000 # ALPHA: 5% with warnings.catch_warnings(): warnings.simplefilter("ignore", category=RuntimeWarning) TIC.count(sim.do_simulation_n_limit(100).blocking_probability) for i in range(10000): sim.sim_result = SimResult(sim) sim.sim_state.stop = False sim.sim_state.num_packets = 0 sim.sim_state.num_blocked_packets = 0 with warnings.catch_warnings(): warnings.simplefilter("ignore", category=RuntimeWarning) TIC.count( sim.do_simulation_n_limit(1000, True).blocking_probability) print TIC.report_confidence_interval(0.05) if TIC.report_confidence_interval(0.05) < 0.0015: num_batches3 = i + 1 break t3 = sim.sim_state.now # ALPHA: 10% sim.reset() TIC.reset() with warnings.catch_warnings(): warnings.simplefilter("ignore", category=RuntimeWarning) TIC.count(sim.do_simulation_n_limit(100).blocking_probability) for i in range(10000): sim.sim_result = SimResult(sim) sim.sim_state.stop = False sim.sim_state.num_packets = 0 sim.sim_state.num_blocked_packets = 0 with warnings.catch_warnings(): warnings.simplefilter("ignore", category=RuntimeWarning) TIC.count( sim.do_simulation_n_limit(1000, True).blocking_probability) print TIC.report_confidence_interval(0.1) if TIC.report_confidence_interval(0.1) < 0.0015: num_batches4 = i + 1 break t4 = sim.sim_state.now # print and return both results print "N: 100; ALPHA: 5%; NUMBER OF BATCHES: " + str( num_batches1) + " and SIM TIME: " + str(t1) print "N: 100; ALPHA: 10%; NUMBER OF BATCHES: " + str( num_batches2) + " and SIM TIME: " + str(t2) print "N: 1000; ALPHA: 5%; NUMBER OF BATCHES: " + str( num_batches3) + " and SIM TIME: " + str(t3) print "N: 1000; ALPHA: 10%; NUMBER OF BATCHES: " + str( num_batches4) + " and SIM TIME: " + str(t4) return [t1, t2, t3, t4]
class Simulation(object): """ This Holds the entire Simulation object, whose parameters we update according to the outcomes """ def __init__(self, setting): # Load simulation parameters self.sim_param = SimParam(setting) # Load simtime if setting.dynamictest: self.SIMTIME = setting.dynamictest.simtime self.freeaccess = False if setting.secondwindow.test_values[3]: self.freeaccess = True # Load the simulation state parameters self.sim_state = SimState() # Load the result parameters self.sim_result = SimResult() # Load the class which perfomrs all the methods governing a simple slot self.slot = TreeSlot() # Load the branch node which keeps track of a tree self.branch_node = BranchNode() # Create an array of integers of which will contain all active nodes. self.active_array = [] # For gated access, the arrived packets are put into a queue self.queue_array = [] # The number of packets generated in a single slot self.packets_gen = 0 # THe result of a slot self.result = 0 # The current slot no self.slot_no = 0 # Load the parameters for single tree resolution self.tree_state = TreeState(self) def reset(self, setting): self.sim_param = SimParam(setting) if setting.dynamictest: self.SIMTIME = setting.dynamictest.simtime self.freeaccess = False if setting.secondwindow.test_values[3]: self.freeaccess = True self.sim_state = SimState() self.sim_result = SimResult() self.slot = TreeSlot() self.active_array = [] self.queue_array = [] self.packets_gen = 0 self.result = 0 self.slot_no = 0 self.tree_state = TreeState(self) self.branch_node.reset() def do_simulation_simple_tree_dynamic(self): """ Free access simulation, is run until the SIMTIME and thats it """ # Run simulation for the number of slots self.tree_state.reset(self) for self.slot_no in range(1, self.SIMTIME): # Generate a packet according to poisson distribution self.packets_gen = np.random.poisson(self.sim_param.lmbda) # Add the number of packets to the active packet array packetlist.add_packets_to_tree(self) # Simulate the processes that would happen in the tx and rx in one slot, update the active array accordingly self.slot.oneslotprocess(self) # Update the metrics in sim_state depending on the result self.tree_state.update_metrics(self) # Update the results self.sim_state.update_metrics(self) self.sim_result.get_result(self) def do_simulation_simple_tree_static(self, collided_packets): """ Static Simulation, when the number of in initial collided packets is given, it is essentially a single tree res :param collided_packets: the no of packets in the resolution """ # Load active array with the collided packets if collided_packets > self.sim_param.K: self.packets_gen = collided_packets packetlist.add_packets_to_tree(self) self.tree_state.reset(self) # Run the simulation as long as all packets are processed and tree is over while self.tree_state.gate_open: # Increment the slot self.slot_no += 1 # Simulate the processes that would happen in the tx and rx in one slot, update the active array accordingly self.slot.oneslotprocess(self) # Update the simstate metrics according to the result of the simulation self.tree_state.update_metrics(self) # check if all the packets are processed and the tree is at its last branch if len(self.active_array) == 0 and len( self.branch_node.branch_status) == 0: self.tree_state.gate_open = False # update the metrics from a tree to the simulation state self.sim_state.update_metrics(self) # Update the results self.sim_result.get_result(self) else: self.sim_result.throughput = 0 self.sim_result.magic_throughput = 0 def do_simulation_gated_access(self): """ Gated access, when a resolution is ongoing, the other packets wait in a buffer """ # Run the simulation where we at least simulate for the simtime and then wait for the last tree to be resolved. while self.tree_state.gate_open or self.slot_no < self.SIMTIME: # Generate a packet according to poisson distribution self.packets_gen = np.random.poisson(self.sim_param.lmbda) # Add the packet to the queue if self.slot_no < self.SIMTIME: packetlist.add_packets_to_queue(self) # if the active array is empty i.e the tree is resolved if len(self.active_array) == 0 and len( self.branch_node.branch_status) == 0: # Update the Sim_state class for the previous tree if self.slot_no != 0: self.sim_state.update_metrics(self) # Transfer the queue to the active array packetlist.copy_queue_to_active(self) # Clear the queue self.queue_array = [] # Reset all the parameters as we start a new tree self.tree_state.reset(self) # Reset the branches of the tree self.branch_node.reset() if len(self.active_array) == 0: self.tree_state.gate_open = False self.slot_no += 1 # Simulate the processes that would happen in the tx and rx in one slot, update the active array accordingly self.slot.oneslotprocess(self) # Update the metrics in sim_state depending on the result self.tree_state.update_metrics(self) # Update the results self.sim_result.get_result(self)
class Simulation(object): def __init__(self, sim_param=SimParam(), no_seed=False): """ Initialize the Simulation object. :param sim_param: is an optional SimParam object for parameter pre-configuration :param no_seed: is an optional parameter. If it is set to True, the RNG should be initialized without a a specific seed. """ self.sim_param = sim_param self.sim_state = SimState() self.system_state = SystemState(self) self.event_chain = EventChain() self.sim_result = SimResult(self) self.counter_collection = CounterCollection(self) if no_seed: self.rng = RNG(ExponentialRNS(1), ExponentialRNS(1. / float(self.sim_param.RHO))) else: self.rng = RNG( ExponentialRNS(1, self.sim_param.SEED_IAT), ExponentialRNS(1. / float(self.sim_param.RHO), self.sim_param.SEED_ST)) self.number_served_packets = 0 def reset(self, no_seed=False): """ Reset the Simulation object. :param no_seed: is an optional parameter. If it is set to True, the RNG should be reset without a a specific seed. """ self.sim_state = SimState() self.system_state = SystemState(self) self.event_chain = EventChain() self.sim_result = SimResult(self) self.counter_collection = CounterCollection(self) if no_seed: self.rng = RNG(ExponentialRNS(1), ExponentialRNS(1. / float(self.sim_param.RHO))) else: self.rng = RNG( ExponentialRNS(1, self.sim_param.SEED_IAT), ExponentialRNS(1. / float(self.sim_param.RHO), self.sim_param.SEED_ST)) def do_simulation(self): """ Do one simulation run. Initialize simulation and create first and last event. After that, one after another event is processed. :return: SimResult object """ # insert first and last event self.event_chain.insert(CustomerArrival(self, 0)) self.event_chain.insert( SimulationTermination(self, self.sim_param.SIM_TIME)) # start simulation (run) while not self.sim_state.stop: # get next simevent from events e = self.event_chain.remove_oldest_event() if e: # if event exists and timestamps are ok, process the event if self.sim_state.now <= e.timestamp: self.sim_state.now = e.timestamp self.counter_collection.count_queue() e.process() else: print "NOW: " + str( self.sim_state.now) + ", EVENT TIMESTAMP: " + str( e.timestamp) raise RuntimeError( "ERROR: TIMESTAMP OF EVENT IS SMALLER THAN CURRENT TIME." ) else: print "Event chain is empty. Abort" self.sim_state.stop = True # gather results for sim_result object self.sim_result.gather_results() return self.sim_result def do_simulation_n_limit(self, n): """ Call this function, if the simulation should stop after a given number of packets Do one simulation run. Initialize simulation and create first event. After that, one after another event is processed. :param n: number of customers, that are processed before the simulation stops :return: SimResult object """ # insert first event self.event_chain.insert(CustomerArrival(self, 0)) # start simulation (run) while (not self.sim_state.stop) and (self.number_served_packets <= n): # TODO Task 4.3.2: Your code goes here # TODO Task 5.2.2: Your code goes here # get next simevent from events e = self.event_chain.remove_oldest_event() if e: # if event exists and timestamps are ok, process the event if self.sim_state.now <= e.timestamp: self.sim_state.now = e.timestamp self.counter_collection.count_queue() e.process() else: print "NOW: " + str( self.sim_state.now) + ", EVENT TIMESTAMP: " + str( e.timestamp) raise RuntimeError( "ERROR: TIMESTAMP OF EVENT IS SMALLER THAN CURRENT TIME." ) else: print "Event chain is empty. Abort" self.sim_state.stop = True # gather results for sim_result object self.sim_result.gather_results() return self.sim_result
class Simulation(object): def __init__(self, sim_param=SimParam(), no_seed=False): """ Initialize the Simulation object. :param sim_param: is an optional SimParam object for parameter pre-configuration :param no_seed: is an optional parameter. If it is set to True, the RNG should be initialized without a a specific seed. """ self.sim_param = sim_param self.sim_state = SimState() self.system_state = SystemState(self) self.event_chain = EventChain() self.sim_result = SimResult(self) # TODO Task 2.4.3: Uncomment the line below # self.counter_collection = CounterCollection() # TODO Task 3.1.2: Uncomment the line below and replace the "None" """ if no_seed: self.rng = RNG(None, None) else: self.rng = RNG(None, None) """ def reset(self, no_seed=False): """ Reset the Simulation object. :param no_seed: is an optional parameter. If it is set to True, the RNG should be reset without a a specific seed. """ self.sim_state = SimState() self.system_state = SystemState(self) self.event_chain = EventChain() self.sim_result = SimResult(self) # TODO Task 2.4.3: Uncomment the line below # self.counter_collection = CounterCollection() # TODO Task 3.1.2: Uncomment the line below and replace the "None" """ if no_seed: self.rng = RNG(None, None) else: self.rng = RNG(None, None) """ def do_simulation(self): """ Do one simulation run. Initialize simulation and create first and last event. After that, one after another event is processed. :return: SimResult object """ # insert first and last event self.event_chain.insert(CustomerArrival(self, 0)) self.event_chain.insert( SimulationTermination(self, self.sim_param.SIM_TIME)) # start simulation (run) while not self.sim_state.stop: # TODO Task 1.4.1: Your code goes here """ Hint: You can use and adapt the following lines in your realization e = self.event_chain.remove_oldest_event() e.process() """ pass # TODO Task 2.4.3: Your code goes here somewhere # gather results for sim_result object self.sim_result.gather_results() return self.sim_result def do_simulation_n_limit(self, n): """ Call this function, if the simulation should stop after a given number of packets Do one simulation run. Initialize simulation and create first event. After that, one after another event is processed. :param n: number of customers, that are processed before the simulation stops :return: SimResult object """ # insert first event self.event_chain.insert(CustomerArrival(self, 0)) # start simulation (run) while not self.sim_state.stop: # TODO Task 4.3.2: Your code goes here # TODO Task 5.2.2: Your code goes here pass # gather results for sim_result object self.sim_result.gather_results() return self.sim_result
class Simulation(object): def __init__(self, sim_param=SimParam(), no_seed=False): """ Initialize the Simulation object. :param sim_param: is an optional SimParam object for parameter pre-configuration :param no_seed: is an optional parameter. If it is set to True, the RNG should be initialized without a a specific seed. """ self.sim_param = sim_param self.sim_state = SimState() self.system_state = SystemState(self) self.event_chain = EventChain() self.sim_result = SimResult(self) # TODO Task 2.4.3: Uncomment the line below self.counter_collection = CounterCollection(self) # TODO Task 3.1.2: Uncomment the line below and replace the "None" rns1 = ExponentialRNS(1.0) rns2 = ExponentialRNS(1.0 / self.sim_param.RHO) rns1_seed = ExponentialRNS(1.0, self.sim_param.SEED_IAT) rns2_seed = ExponentialRNS(1.0 / self.sim_param.RHO, self.sim_param.SEED_ST) if no_seed: self.rng = RNG(rns1, rns2) else: self.rng = RNG(rns1_seed, rns2_seed) def reset(self, no_seed=False): """ Reset the Simulation object. :param no_seed: is an optional parameter. If it is set to True, the RNG should be reset without a a specific seed. """ self.sim_state = SimState() self.system_state = SystemState(self) self.event_chain = EventChain() self.sim_result = SimResult(self) # TODO Task 2.4.3: Uncomment the line below self.counter_collection = CounterCollection(self) # TODO Task 3.1.2: Uncomment the line below and replace the "None" rns1 = ExponentialRNS(1.0) rns2 = ExponentialRNS(1.0 / self.sim_param.RHO) rns1_seed = ExponentialRNS(1.0, self.sim_param.SEED_IAT) rns2_seed = ExponentialRNS(1.0 / self.sim_param.RHO, self.sim_param.SEED_ST) if no_seed: self.rng = RNG(rns1, rns2) else: self.rng = RNG(rns1_seed, rns2_seed) def do_simulation(self): """ Do one simulation run. Initialize simulation and create first and last event. After that, one after another event is processed. :return: SimResult object """ # insert first and last event self.event_chain.insert(CustomerArrival(self, 0)) self.event_chain.insert( SimulationTermination(self, self.sim_param.SIM_TIME)) # start simulation (run) while not self.sim_state.stop: # TODO Task 1.4.1: Your code goes here """ Hint: You can use and adapt the following lines in your realization e = self.event_chain.remove_oldest_event() e.process() """ e = self.event_chain.remove_oldest_event() if e: # if event exists and timestamps are ok, process the event if self.sim_state.now <= e.timestamp: self.sim_state.now = e.timestamp self.counter_collection.count_queue() e.process() else: print "NOW: " + str( self.sim_state.now) + ", EVENT TIMESTAMP: " + str( e.timestamp) raise RuntimeError( "ERROR: TIMESTAMP OF EVENT IS SMALLER THAN CURRENT TIME." ) else: print "Event chain is empty. Abort" self.sim_state.stop = True # TODO Task 2.4.3: Your code goes here somewhere #self.counter_collection.count_queue() # gather results for sim_result object self.sim_result.gather_results() return self.sim_result def do_simulation_n_limit(self, n): """ Call this function, if the simulation should stop after a given number of packets Do one simulation run. Initialize simulation and create first event. After that, one after another event is processed. :param n: number of customers, that are processed before the simulation stops :return: SimResult object """ # insert first event self.event_chain.insert(CustomerArrival(self, 0)) # start simulation (run) while not self.sim_state.stop: # TODO Task 4.3.2: Your code goes here # TODO Task 5.2.2: Your code goes here pass # gather results for sim_result object self.sim_result.gather_results() return self.sim_result