def task_3_2_2(): """ Here, we execute task 3.2.2 and print the results to the console. The first result string keeps the results for 100s, the second one for 1000s simulation time. """ # TODO Task 3.2.2: Your code goes here rho = [.01, .5, .8, .9] system_utilization_result = [] sim_param = SimParam() random.seed(sim_param.SEED) sim = Simulation(sim_param) sim.sim_param.SIM_TIME = 100000 sim.sim_param.S = 5 for r in rho: sim.sim_param.RHO = r sim.reset() system_utilization_result.append(sim.do_simulation().system_utilization) print "The system utilization results for a simulation time of 100s :" print system_utilization_result rho = [.01, .5, .8, .9] system_utilization_result = [] sim_param = SimParam() random.seed(sim_param.SEED) sim = Simulation(sim_param) sim.sim_param.SIM_TIME = 1000000 sim.sim_param.S = 5 for r in rho: sim.sim_param.RHO = r sim.reset() system_utilization_result.append(sim.do_simulation().system_utilization) print "The system utilization results for a simulation time of 1000s :" print system_utilization_result
def task_2_7_2(): """ Here, you can execute task 2.7.2 if you want to execute it in a separate function """ # TODO Task 2.7.2: Your code goes here or in the function above sim_param = SimParam() random.seed(sim_param.SEED) sim_param.SIM_TIME = 1000000 sim = Simulation(sim_param) return do_simulation_study(sim)
def task_1_7_2(): """ Execute task 1.7.2 and perform a simulation study according to the task assignment. :return: Minimum number of buffer spaces to meet requirements. """ sim_param = SimParam() random.seed(sim_param.SEED) sim_param.SIM_TIME = 1000000 sim_param.MAX_DROPPED = 100 sim_param.NO_OF_RUNS = 100 sim = Simulation(sim_param) return do_simulation_study(sim)
def task_4_3_1(): """ Run the correlation tests for given rho for all correlation counters in counter collection. After each simulation, print report results. SIM_TIME is set higher in order to avoid a large influence of startup effects """ # TODO Task 4.3.1: Your code goes here rho = [0.01, 0.5, 0.8, 0.95] sim_param = SimParam() random.seed(sim_param.SEED) sim = Simulation(sim_param) sim.sim_param.SIM_TIME = 1000000 sim.sim_param.S = 10000 for r in rho: print "---------- rho = ,", r, " ---------" sim.sim_param.RHO = r sim.reset() with warnings.catch_warnings(): warnings.simplefilter("ignore", category=RuntimeWarning) sim.do_simulation() print "Correlation between IAT and waiting time of a packet : ", sim.counter_collection.cnt_iat_wt.get_cor( ) print "Correlation between IAT and serving time of a packet : ", sim.counter_collection.cnt_iat_st.get_cor( ) print "Correlation between IAT and system time (waiting time + serving time) of a packet : ", sim.counter_collection.cnt_iat_syst.get_cor( ) print "Correlation between service time and system time of a packet : ", sim.counter_collection.cnt_st_syst.get_cor( ) print "Auto-correlation of waiting time with lags ranging from 1 to 20 : ", sim.counter_collection.acnt_wt.get_auto_cor( 2)
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 task_4_3_1(): """ Run the correlation tests for given rho for all correlation counters in counter collection. After each simulation, print report results. SIM_TIME is set higher in order to avoid a large influence of startup effects """ # TODO Task 4.3.1: Your code goes here sim_param = SimParam() sim = Simulation(sim_param) sim.sim_param.S = 10000 sim.sim_param.SIM_TIME = 10000000 for rho in [0.01, 0.5, 0.8, 0.95]: sim.sim_param.RHO = rho sim.reset() sim.counter_collection.reset() sim = sim.do_simulation().sim print("RHO = " + str(rho)) print("Correlation between IAT and waiting time of a packet = " + str(sim.counter_collection.cnt_iat_wt.get_cor())) print("Correlation between IAT and serving time of a packet = " + str(sim.counter_collection.cnt_iat_st.get_cor())) print( "Correlation between IAT and system time (waiting time + serving time) of a packet = " + str(sim.counter_collection.cnt_iat_syst.get_cor())) print( "Correlation between serving time and system time of a packet = " + str(sim.counter_collection.cnt_st_syst.get_cor())) for lag in range(0, 21): print( "Lag = " + str(lag) + " Auto-correlation of waiting time with lags ranging from 1 to 20 = " + str(sim.counter_collection.acnt_wt.get_auto_cor(lag))) print(" ")
def __init__(self, user_id, dist=10, slice_list=[], sim_param=SimParam()): """ """ self.user_id = user_id self.slice_list = slice_list self.sim_param = sim_param self.distance = dist # np.random.uniform(self.sim_param.dist_range) if self.sim_param.cts_service: self.channel = ChannelModalCts(self) else: self.channel = ChannelModal(self) self.traffic_generator = TrafficGenerator(self) self.traffic_list = [] self.traffic_list_dict = {} for i in self.slice_list: if 0: #i.slice_param.SLICE_ID==0: self.traffic_list.append( self.traffic_generator.periodic_arrivals(i)) # for RR else: self.traffic_list.append( self.traffic_generator.poisson_arrivals(i)) self.traffic_list_dict.update( {i.slice_param.SLICE_ID: self.traffic_list[-1]})
def __init__(self, t_final: int = 1000): """ Main ran_simulation """ sim_param = SimParam(t_final) self.initialize_spaces (sim_param) # other attributes of ran_environment self.state = None self.sim_param = sim_param #self.C_algo = 'RL' self.slice_scores = None # slice scores for reward method 3 self.user_scores = None # generate seed values new_seed = seeding.create_seed() self.sim_param.update_seeds(new_seed) # initialize SD_RAN_Controller self.SD_RAN_Controller = Controller(self.sim_param) # data self.user_score_arr = None self.slice_score_arr = None self.reward_hist = None self.cost_tp_hist = None self.cost_bp_hist = None self.cost_delay_hist = None self.reset_counter = 0 columns = 'reward_hist slice_score_0 slice_score_1 slice_score_2' self.env_df = pd.DataFrame(columns=columns.split())
def task_5_2_4(rho, alpha, sim_time, num): """ Plot confidence interval as described in the task description for task 5.2.4. We use the function plot_confidence() for the actual plotting and run our simulation several times to get the samples. Due to the different configurations, we receive eight plots in two figures. """ # TODO Task 5.2.4: Your code goes here #rho = 0.5 / alpha = 0.1 / Sim time = 100s TIC_SU = TimeIndependentCounter("System Utilization") TIC_CI = [] sim_param = SimParam() random.seed(sim_param.SEED) sim = Simulation(sim_param) sim.sim_param.SIM_TIME = sim_time sim.sim_param.S = 100000 sim.sim_param.RHO = rho random.seed(sim.sim_param.SEED_IAT) random.seed(sim.sim_param.SEED_ST) for i in range(100): for j in range(30): with warnings.catch_warnings(): warnings.simplefilter("ignore", category=RuntimeWarning) TIC_SU.count(sim.do_simulation().system_utilization) sim.reset() with warnings.catch_warnings(): warnings.simplefilter("ignore", category=RuntimeWarning) TIC_CI.append( (TIC_SU.get_mean() - TIC_SU.report_confidence_interval(alpha), TIC_SU.get_mean() + TIC_SU.report_confidence_interval(alpha))) TIC_SU.reset() plot_confidence(sim, 100, TIC_CI, rho, "alpha=" + str(alpha), num, alpha)
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 task_2_7_1(): """ Here, you should execute task 2.7.1 (and 2.7.2, if you want). """ # TODO Task 2.7.1: Your code goes here sim_param = SimParam() random.seed(sim_param.SEED) sim = Simulation(sim_param) do_simulation_study(sim)
def task_2_7_1(): """ Here, we execute tasks 2.7.1 and 2.7.2 in the same function. This makes sense, since we use only one figure with four subfigures to display the plots, which makes comparability easier. """ sim_param = SimParam() random.seed(sim_param.SEED) sim = Simulation(sim_param) return do_simulation_study(sim)
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. """ results = [None, None, None, None] # TODO Task 5.2.2: Your code goes here bp = [] hw = [] sim_param = SimParam() sim = Simulation(sim_param) sim.sim_param.S = 4 sim.sim_param.RHO = .9 err = .0015 half_width = 1.0 count_bp = TimeIndependentCounter() i = 0 for batch in [100, 1000]: for alpha in [.1, .05]: first_batch = False count_bp.reset() sim.reset() while 1: blocking_pro = sim.do_simulation_n_limit( batch, first_batch).blocking_probability first_batch = True #after first batch count_bp.count(blocking_pro) half_width = count_bp.report_confidence_interval(alpha) sim.sim_state.stop = False #set the parameter back to original value sim.counter_collection.reset() sim.sim_state.num_blocked_packets = 0 sim.sim_state.num_packets = 0 if half_width < err: break results[i] = sim.sim_state.now bp.append(count_bp.get_mean()) hw.append(half_width) i += 1 # print and return results print("BATCH SIZE: 100; ALPHA: 10%; TOTAL SIMULATION TIME (SECONDS): " + str(results[0] / 1000) + "; Blocking Probability Mean: " + str(bp[0]) + "; Half width: " + str(hw[0])) print("BATCH SIZE: 100; ALPHA: 5%; TOTAL SIMULATION TIME (SECONDS): " + str(results[1] / 1000) + "; Blocking Probability Mean: " + str(bp[1]) + "; Half width: " + str(hw[1])) print("BATCH SIZE: 1000; ALPHA: 10%; TOTAL SIMULATION TIME (SECONDS): " + str(results[2] / 1000) + "; Blocking Probability Mean: " + str(bp[2]) + "; Half width: " + str(hw[2])) print("BATCH SIZE: 1000; ALPHA: 5%; TOTAL SIMULATION TIME (SECONDS): " + str(results[3] / 1000) + "; Blocking Probability Mean: " + str(bp[3]) + "; Half width: " + str(hw[3])) return results
def task_1_7_1(): """ Execute task 1.7.1 and perform a simulation study according to the task assignment. :return: Minimum number of buffer spaces to meet requirements. """ sim_param = SimParam() random.seed(sim_param.SEED) sim = Simulation(sim_param) return do_simulation_study(sim)
def task_1_7_3(queue_size): """ Execute bonus task 1.7.3. """ # TODO Bonus Task 1.7.3: Your code goes here (if necessary) sim_param = SimParam() random.seed(sim_param.SEED) sim = Simulation(sim_param) sim.sim_param.S=queue_size result_set=[] for i in range(sim.sim_param.NO_OF_RUNS): sim.reset() sim_result=sim.do_simulation() result_set.append(sim_result.blocking_probability) result_length=len(result_set) n, bins, patches = pylab.hist(result_set) nc=np.cumsum(n/result_length) cdf=[0.0] for i in nc: cdf.append(i) sim_param = SimParam() random.seed(sim_param.SEED) sim_param.SIM_TIME = 1000000 sim_param.MAX_DROPPED = 100 sim_param.NO_OF_RUNS = 100 sim = Simulation(sim_param) sim.sim_param.S=queue_size result_set=[] for i in range(sim.sim_param.NO_OF_RUNS): sim.reset() sim_result=sim.do_simulation() result_set.append(sim_result.blocking_probability) result_length=len(result_set) n1, bins1, patches1 = pylab.hist(result_set) nc1=np.cumsum(n/result_length) cdf1=[0.0] for i in nc: cdf1.append(i) pylab.figure(1) pylab.xlabel('blocking_probability') pylab.ylabel('density') pylab.title('Histogram of the probability density function') pylab.hist(n, bins) pylab.hist(n1, bins1) pylab.figure(2) pylab.xlim(0.0,1.0) pylab.ylim(0.0,1.0) pylab.xlabel('blocking_probability') pylab.ylabel('CDF') pylab.title('CDF function') line1, = pylab.plot(bins,cdf, marker='o', label='100000 ms, 10 MAX_DROPPED, 1000 runs') line2, = pylab.plot(bins1,cdf1, marker='o', label='1000000 ms, 100 MAX_DROPPED, 100 runs') pylab.legend(handler_map={line1: HandlerLine2D(numpoints=4)}) pylab.show()
def study_waiting_time(): sim_param = SimParam() sim = Simulation(sim_param) sim.sim_param.S = 5 sim.sim_param.SIM_TIME = 100000 # 100 seconds num_run = 100 dataset = [] for run in range(num_run): sim.reset() random.seed() sim.do_simulation() # Take the values (waiting time) of the first 150 packets dataset.append(sim.counter_collection.cnt_wt.values[0:150]) # Manipulate the data set pkt_mean = [] for pkt in range(150): s = 0 for run in range(num_run): s += dataset[run][pkt] pkt_mean.append(s/float(num_run)) plt.subplot(121) plt.plot(pkt_mean) plt.title("100s Run") plt.xlabel("Packet Number") plt.ylabel("Waiting Time (ms)") sim.sim_param.SIM_TIME = 1000000 dataset = [] for run in range(num_run): sim.reset() random.seed() sim.do_simulation() # Take the values (waiting time) of the first 1900 packets dataset.append(sim.counter_collection.cnt_wt.values[0:1800]) # Manipulate the dataset pkt_mean = [] for pkt in range(1800): s = 0 for run in range(num_run): s += dataset[run][pkt] pkt_mean.append(s / float(num_run)) plt.subplot(122) plt.plot(pkt_mean) plt.title("1000s Run") plt.xlabel("Packet Number") plt.ylabel("Waiting Time (ms)")
def task_5_2_1(): """ Run task 5.2.1. Make multiple runs until the blocking probability distribution reaches a confidence level alpha. Simulation is performed for 100s and 1000s and for alpha = 90% and 95%. """ results = [None, None, None, None] # TODO Task 5.2.1: Your code goes here bp = [] hw = [] sim_param = SimParam() sim = Simulation(sim_param) sim.sim_param.S = 4 sim.sim_param.RHO = .9 count_bp = TimeIndependentCounter() err = .0015 i = 0 for sim_time in [100000, 1000000]: sim.sim_param.SIM_TIME = sim_time for alpha in [.1, .05]: count_bp.reset() while 1: sim.reset() blocking_pro = sim.do_simulation().blocking_probability count_bp.count(blocking_pro) half_width = count_bp.report_confidence_interval(alpha=alpha) if half_width < err: break results[i] = len(count_bp.values) bp.append(count_bp.get_mean()) hw.append(half_width) i += 1 # print and return results print("SIM TIME: 100s; ALPHA: 10%; NUMBER OF RUNS: " + str(results[0]) + "; TOTAL SIMULATION TIME (SECONDS): " + str(results[0] * 100) + "; Blocking Probability Mean: " + str(bp[0]) + "; Half width: " + str(hw[0])) print("SIM TIME: 100s; ALPHA: 5%; NUMBER OF RUNS: " + str(results[1]) + "; TOTAL SIMULATION TIME (SECONDS): " + str(results[1] * 100) + "; Blocking Probability Mean: " + str(bp[1]) + "; Half width: " + str(hw[1])) print("SIM TIME: 1000s; ALPHA: 10%; NUMBER OF RUNS: " + str(results[2]) + "; TOTAL SIMULATION TIME (SECONDS): " + str(results[2] * 1000) + "; Blocking Probability Mean: " + str(bp[2]) + "; Half width: " + str(hw[2])) print("SIM TIME: 1000s; ALPHA: 5%; NUMBER OF RUNS: " + str(results[3]) + "; TOTAL SIMULATION TIME (SECONDS): " + str(results[3] * 1000) + "; Blocking Probability Mean: " + str(bp[3]) + "; Half width: " + str(hw[3])) return results
def task_3_2_1(): """ This function plots two histograms for verification of the random distributions. One histogram is plotted for a uniform distribution, the other one for an exponential distribution. """ # TODO Task 3.2.1: Your code goes here sim_param = SimParam() random.seed(sim_param.SEED) sim_param.RHO = 0.01 sim = Simulation(sim_param) rns_iat = ExponentialRNS(1.0) rns_st = ExponentialRNS(1.0/sim.sim_param.RHO) rns_uniform = UniformRNS((2,4)) hist1 = TimeIndependentHistogram(sim, "Line") hist2 = TimeIndependentHistogram(sim, "Line") hist3 = TimeIndependentHistogram(sim, "bp") for i in range(1000000): hist1.count(rns_iat.next()) hist2.count(rns_st.next()) hist3.count(rns_uniform.next()) hist1.report() hist2.report() hist3.report()
def do_theoretical_iter(sim, setting): """ :param n_stop: till the end of number of users we want to sweep till can be used to compare different formulas in different formulas in different papers. plots the throughput vs number of users :return: """ param = SimParam(setting) users = range(param.K + 1, setting.theorsweep.n_stop + 1) theoretical = [] theoretical1 = [] theoretical2 = [] theoretical3 = [] theoretical4 = [] theoretical5 = [] for n in users: if setting.theorsweep.test_values[0]: theoretical.append(TheoreticalPlots().qarysic(n, param)) if setting.theorsweep.test_values[1]: theoretical1.append(TheoreticalPlots().sicta(n, param)) if setting.theorsweep.test_values[2]: theoretical2.append(TheoreticalPlots().simpletree(n)) if setting.theorsweep.test_values[3]: theoretical3.append(TheoreticalPlots().recsicta(n)) if setting.theorsweep.test_values[4]: theoretical4.append(TheoreticalPlots().recquary(n, param)) if setting.theorsweep.test_values[5]: theoretical5.append(TheoreticalPlots().qsicta(n, param)) if setting.theorsweep.test_values[0]: pyplot.plot(users, theoretical, 'b-', label='Quary Sic') if setting.theorsweep.test_values[1]: pyplot.plot(users, theoretical1, 'g-', label='SICTA') if setting.theorsweep.test_values[2]: pyplot.plot(users, theoretical2, 'r-', label='Simple Tree') if setting.theorsweep.test_values[3]: pyplot.plot(users, theoretical3, 'c-', label='Recursive SICTA') if setting.theorsweep.test_values[4]: pyplot.plot(users, theoretical4, 'm-', label='Recursive Quary') if setting.theorsweep.test_values[5]: pyplot.plot(users, theoretical5, 'y-', label='QSICTA Giannakkis') pyplot.xlabel('Users') pyplot.ylabel('Throughput') pyplot.legend() pyplot.xscale('log') figname = F"K{sim.sim_param.K}Q{sim.sim_param.SPLIT}TheoreticalCalc" pyplot.savefig(figname + '.png', dpi=300) tikzplotlib.save(figname + '.tex') pyplot.show()
def study_waiting_time_dist(): sim_param = SimParam() random.seed(0) sim = Simulation(sim_param) sim.sim_param.S = 5 sim.sim_param.SIM_TIME = 100000 # 100 seconds sim.reset() sim.do_simulation() # sim.counter_collection.hist_wt.report() print(sim.counter_collection.cnt_wt.get_mean()) plt.plot(sim.counter_collection.cnt_wt.values) plt.show()
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 task_5_2_4(): """ Plot confidence interval as described in the task description for task 5.2.4. We use the function plot_confidence() for the actual plotting and run our simulation several times to get the samples. Due to the different configurations, we receive eight plots in two figures. """ # TODO Task 5.2.4: Your code goes here sim_param = SimParam() sim = Simulation(sim_param) sim.sim_param.S = 40000000 #infinite M/M/1/inf err = .0015 plt_no = 1 for rho in [0.5, 0.9]: sim.sim_param.RHO = rho for alpha in [0.1, 0.05]: for sim_time in [100000, 1000000]: sim.sim_param.SIM_TIME = sim_time print(" Sim time " + str(sim.sim_param.SIM_TIME / 1000) + "s " + " Alpha " + str(alpha) + " RHO " + str(rho)) count_util = TimeIndependentCounter() mean_count = TimeIndependentCounter() y_low = [] y_high = [] x = [] for repeat in range(100): count_util.reset() for sim_run in range(30): sim.reset() count_util.count( sim.do_simulation().system_utilization) mean = count_util.get_mean() half_width = count_util.report_confidence_interval( alpha=alpha) mean_count.count(mean) y_low.append(mean - half_width) y_high.append(mean + half_width) x.append(repeat + 1) pyplot.subplot(2, 2, plt_no) plt_no += 1 plot_confidence(sim, x, y_low, y_high, mean_count.get_mean(), sim.sim_param.RHO, "Utilization", alpha) pyplot.show() plt_no = 1
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 task_4_3_2(): """ Exercise to plot auto correlation depending on lags. Run simulation until 10000 (or 100) packets are served. For the different rho values, simulation is run and the blocking probability is auto correlated. Results are plotted for each N value in a different diagram. Note, that for some seeds with rho=0.DES and N=100, the variance of the auto covariance is 0 and returns an error. """ # TODO Task 4.3.2: Your code goes here data_n_100 = [] data_n_10000 = [] lags = range(21) del lags[0] sim_param = SimParam() random.seed(sim_param.SEED) sim = Simulation(sim_param) sim.sim_param.SIM_TIME = 1000000 sim.sim_param.S = 10000 with warnings.catch_warnings(): warnings.simplefilter("ignore", category=RuntimeWarning) sim.do_simulation_n_limit(100) for i in lags: data_n_100.append(sim.counter_collection.acnt_wt.get_auto_cor(i)) sim.reset() with warnings.catch_warnings(): warnings.simplefilter("ignore", category=RuntimeWarning) sim.do_simulation_n_limit(10000) for i in lags: data_n_10000.append(sim.counter_collection.acnt_wt.get_auto_cor(i)) pylab.figure(1) pylab.xlabel('lag') pylab.ylabel('Auto Correlation') pylab.title( 'Auto Correlation of Waiting Times (n=100) for lags ranging from 1 to 20' ) pylab.plot(lags, data_n_100) pylab.figure(2) pylab.xlabel('lag') pylab.ylabel('Auto Correlation') pylab.title( 'Auto Correlation of Waiting Times (n=10000) for lags ranging from 1 to 20' ) pylab.plot(lags, data_n_10000) pylab.show()
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))
def task_4_3_2(): """ Exercise to plot the scatter plot of (a) IAT and serving time, (b) serving time and system time The scatter plot helps to better understand the meaning of bit/small covariance/correlation. For every rho, two scatter plots are needed. The simulation parameters are the same as in task_4_3_1() """ # TODO Task 4.3.2: Your code goes here sim_param = SimParam() sim = Simulation(sim_param) sim.sim_param.S = 10000 sim.sim_param.SIM_TIME = 10000000 for rho in [0.01, 0.5, 0.8, 0.95]: sim.sim_param.RHO = rho sim.reset() sim.counter_collection.reset() sim = sim.do_simulation().sim cnt_iat = sim.counter_collection.cnt_iat_st.values_x cnt_st = sim.counter_collection.cnt_iat_st.values_y cnt_syst = sim.counter_collection.cnt_st_syst.values_y corr_iat_st = float(sim.counter_collection.cnt_iat_st.get_cor()) corr_st_syst = float(sim.counter_collection.cnt_st_syst.get_cor()) fig = plt.figure() ax1 = fig.add_subplot(1, 1, 1) plt.subplot(1, 2, 1) plt.title('Rho %.2f Correlation %.3f' % (rho, corr_iat_st)) plt.xlabel("Correlation IAT - ST") plt.plot(cnt_iat, cnt_st, 'o') plt.subplot(1, 2, 2) plt.title('Rho %.2f Correlation %.3f' % (rho, corr_st_syst)) plt.xlabel("Correlation ST - SYST") plt.plot(cnt_st, cnt_syst, 'o') plt.show()
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]
def task_5_2_1(): """ Run task 5.2.1. Make multiple runs until the blocking probability distribution reaches a confidence level alpha. Simulation is performed for 100s and 1000s and for alpha = 90% and 95%. """ results = [None, None, None, None] TIC = TimeIndependentCounter("bp") # TODO Task 5.2.1: Your code goes here #SIM TIME: 100s; ALPHA: 10% sim_param = SimParam() random.seed(sim_param.SEED) sim = Simulation(sim_param) sim.sim_param.SIM_TIME = 100000 sim.sim_param.S = 4 sim.sim_param.RHO = 0.9 for i in range(10000): with warnings.catch_warnings(): warnings.simplefilter("ignore", category=RuntimeWarning) TIC.count(sim.do_simulation().blocking_probability) if TIC.report_confidence_interval(0.1) < 0.0015: results[0] = i break sim.reset() #SIM TIME: 100s; ALPHA: 5% TIC.reset() for i in range(10000): with warnings.catch_warnings(): warnings.simplefilter("ignore", category=RuntimeWarning) TIC.count(sim.do_simulation().blocking_probability) if TIC.report_confidence_interval(0.05) < 0.0015: results[1] = i break sim.reset() #SIM TIME: 1000s; ALPHA: 10% sim.sim_param.SIM_TIME = 1000000 TIC.reset() for i in range(10000): with warnings.catch_warnings(): warnings.simplefilter("ignore", category=RuntimeWarning) TIC.count(sim.do_simulation().blocking_probability) if TIC.report_confidence_interval(0.05) < 0.0015: results[2] = i break sim.reset() #SIM TIME: 1000s; ALPHA: 5% sim.sim_param.SIM_TIME = 1000000 TIC.reset() for i in range(10000): with warnings.catch_warnings(): warnings.simplefilter("ignore", category=RuntimeWarning) TIC.count(sim.do_simulation().blocking_probability) if TIC.report_confidence_interval(0.05) < 0.0015: results[3] = i break sim.reset() # print and return results print "SIM TIME: 100s; ALPHA: 10%; NUMBER OF RUNS: " + str(results[0]) print "SIM TIME: 100s; ALPHA: 5%; NUMBER OF RUNS: " + str(results[1]) print "SIM TIME: 1000s; ALPHA: 10%; NUMBER OF RUNS: " + str(results[2]) print "SIM TIME: 1000s; ALPHA: 5%; NUMBER OF RUNS: " + str(results[3]) return results
class UWG(object): """Morph a rural EPW file to urban conditions using a file with a list of urban parameters. args: epwDir: The directory in which the rural EPW file sits. epwFileName: The name of the rural epw file that will be morphed. uwgParamDir: The directory in which the UWG Parameter File (.uwg) sits. uwgParamFileName: The name of the UWG Parameter File (.uwg). destinationDir: Optional destination directory for the morphed EPW file. If left blank, the morphed file will be written into the same directory as the rural EPW file (the epwDir). destinationFileName: Optional destination file name for the morphed EPW file. If left blank, the morphed file will append "_UWG" to the original file name. returns: newClimateFile: the path to a new EPW file that has been morphed to account for uban conditions. """ """ Section 1 - Definitions for constants / other parameters """ MINTHICKNESS = 0.01 # Minimum layer thickness (to prevent crashing) (m) MAXTHICKNESS = 0.05 # Maximum layer thickness (m) SOILTCOND = 1 # http://web.mit.edu/parmstr/Public/NRCan/nrcc29118.pdf (Figly & Snodgrass) SOILVOLHEAT = 2e6 # http://www.europment.org/library/2013/venice/bypaper/MFHEEF/MFHEEF-21.pdf (average taken from Table 1) SOIL = Material(SOILTCOND, SOILVOLHEAT, name="soil") # Soil material used for soil-depth padding # Physical constants G = 9.81 # gravity (m s-2) CP = 1004. # heat capacity for air (J/kg K) VK = 0.40 # von karman constant (dimensionless) R = 287. # gas constant dry air (J/kg K) RV = 461.5 # gas constant water vapor (J/kg K) LV = 2.26e6 # latent heat of evaporation (J/kg) SIGMA = 5.67e-08 # Stefan Boltzmann constant (W m-2 K-4) WATERDENS = 1000. # water density (kg m-3) LVTT = 2.5008e6 # TT = 273.16 # ESTT = 611.14 # CL = 4.218e3 # CPV = 1846.1 # B = 9.4 # Coefficients derived by Louis (1979) CM = 7.4 # COLBURN = math.pow( (0.713 / 0.621), (2 / 3.)) # (Pr/Sc)^(2/3) for Colburn analogy in water evaporation # Site-specific parameters WGMAX = 0.005 # maximum film water depth on horizontal surfaces (m) # File path parameter RESOURCE_PATH = os.path.abspath( os.path.join(os.path.dirname(__file__), "..", "resources")) CURRENT_PATH = os.path.abspath(os.path.dirname(__file__)) def __init__(self, epwFileName, uwgParamFileName=None, epwDir=None, uwgParamDir=None, destinationDir=None, destinationFileName=None): # Logger will be disabled by default unless explicitly called in tests self.logger = logging.getLogger(__name__) # User defined self.epwFileName = epwFileName if epwFileName.lower().endswith( '.epw' ) else epwFileName + '.epw' # Revise epw file name if not end with epw self.uwgParamFileName = uwgParamFileName # If file name is entered then will UWG will set input from .uwg file # If user does not overload self.destinationFileName = destinationFileName if destinationFileName else self.epwFileName.strip( '.epw') + '_UWG.epw' self.epwDir = epwDir if epwDir else os.path.join( self.RESOURCE_PATH, "epw") self.uwgParamDir = uwgParamDir if uwgParamDir else os.path.join( self.RESOURCE_PATH, "parameters") self.destinationDir = destinationDir if destinationDir else os.path.join( self.RESOURCE_PATH, "epw_uwg") # refdata: Serialized DOE reference data, z_meso height data self.readDOE_file_path = os.path.join(self.CURRENT_PATH, "refdata", "readDOE.pkl") self.z_meso_dir_path = os.path.join(self.CURRENT_PATH, "refdata") # EPW precision self.epw_precision = 1 # init UWG variables self._init_param_dict = None # Define Simulation and Weather parameters self.Month = None # starting month (1-12) self.Day = None # starting day (1-31) self.nDay = None # number of days self.dtSim = None # simulation time step (s) self.dtWeather = None # seconds (s) # HVAC system and internal laod self.autosize = None # autosize HVAC (1 or 0) self.sensOcc = None # Sensible heat from occupant self.LatFOcc = None # Latent heat fraction from occupant (normally 0.3) self.RadFOcc = None # Radiant heat fraction from occupant (normally 0.2) self.RadFEquip = None # Radiant heat fraction from equipment (normally 0.5) self.RadFLight = None # Radiant heat fraction from light (normally 0.7) # Define Urban microclimate parameters self.h_ubl1 = None # ubl height - day (m) self.h_ubl2 = None # ubl height - night (m) self.h_ref = None # inversion height self.h_temp = None # temperature height self.h_wind = None # wind height self.c_circ = None # circulation coefficient self.c_exch = None # exchange coefficient self.maxDay = None # max day threshhold self.maxNight = None # max night threshhold self.windMin = None # min wind speed (m/s) self.h_obs = None # rural average obstacle height # Urban characteristics self.bldHeight = None # average building height (m) self.h_mix = None # mixing height (m) self.bldDensity = None # building density (0-1) self.verToHor = None # building aspect ratio self.charLength = None # radius defining the urban area of study [aka. characteristic length] (m) self.alb_road = None # road albedo self.d_road = None # road pavement thickness self.sensAnth = None # non-building sensible heat (W/m^2) self.latAnth = None # non-building latent heat heat (W/m^2) # Fraction of building typology stock self.bld = None # 16x3 matrix of fraction of building type by era # climate Zone self.zone = None # Vegetation parameters self.vegCover = None # urban area veg coverage ratio self.treeCoverage = None # urban area tree coverage ratio self.vegStart = None # vegetation start month self.vegEnd = None # vegetation end month self.albVeg = None # Vegetation albedo self.rurVegCover = None # rural vegetation cover self.latGrss = None # latent fraction of grass self.latTree = None # latent fraction of tree # Define Traffic schedule self.SchTraffic = None # Define Road (Assume 0.5m of asphalt) self.kRoad = None # road pavement conductivity (W/m K) self.cRoad = None # road volumetric heat capacity (J/m^3 K) # Define optional Building characteristics self.flr_h = None # floor-to-floor height self.albRoof = None # roof albedo (0 - 1) self.vegRoof = None # Fraction of the roofs covered in grass/shrubs (0-1) self.glzR = None # Glazing Ratio self.SHGC = None # Solar Heat Gain Coefficient self.albWall = None # Wall albedo def __repr__(self): return "UWG: {} ".format(self.epwFileName) def is_near_zero(self, num, eps=1e-10): return abs(float(num)) < eps def read_epw(self): """Section 2 - Read EPW file properties: self.climateDataPath self.newPathName self._header # header data self.epwinput # timestep data for weather self.lat # latitude self.lon # longitude self.GMT # GMT self.nSoil # Number of soil depths self.Tsoil # nSoil x 12 matrix for soil temperture (K) self.depth_soil # nSoil x 1 matrix for soil depth (m) """ # Make dir path to epw file self.climateDataPath = os.path.join(self.epwDir, self.epwFileName) # Open epw file and feed csv data to climate_data try: climate_data = utilities.read_csv(self.climateDataPath) except Exception as e: raise Exception("Failed to read epw file! {}".format(e.message)) # Read header lines (1 to 8) from EPW and ensure TMY2 format. self._header = climate_data[0:8] # Read weather data from EPW for each time step in weather file. (lines 8 - end) self.epwinput = climate_data[8:] # Read Lat, Long (line 1 of EPW) self.lat = float(self._header[0][6]) self.lon = float(self._header[0][7]) self.GMT = float(self._header[0][8]) # Read in soil temperature data (assumes this is always there) # ref: http://bigladdersoftware.com/epx/docs/8-2/auxiliary-programs/epw-csv-format-inout.html soilData = self._header[3] self.nSoil = int(soilData[1]) # Number of ground temperature depths self.Tsoil = utilities.zeros( self.nSoil, 12) # nSoil x 12 matrix for soil temperture (K) self.depth_soil = utilities.zeros( self.nSoil, 1) # nSoil x 1 matrix for soil depth (m) # Read monthly data for each layer of soil from EPW file for i in xrange(self.nSoil): self.depth_soil[i][0] = float( soilData[2 + (i * 16)]) # get soil depth for each nSoil # Monthly data for j in xrange(12): self.Tsoil[i][j] = float(soilData[ 6 + (i * 16) + j]) + 273.15 # 12 months of soil T for specific depth # Set new directory path for the moprhed EPW file self.newPathName = os.path.join(self.destinationDir, self.destinationFileName) def read_input(self): """Section 3 - Read Input File (.m, file) Note: UWG_Matlab input files are xlsm, XML, .m, file. properties: self._init_param_dict # dictionary of simulation initialization parameters self.sensAnth # non-building sensible heat (W/m^2) self.SchTraffic # Traffice schedule self.BEM # list of BEMDef objects extracted from readDOE self.Sch # list of Schedule objects extracted from readDOE """ uwg_param_file_path = os.path.join(self.uwgParamDir, self.uwgParamFileName) if not os.path.exists(uwg_param_file_path): raise Exception( "Param file: '{}' does not exist.".format(uwg_param_file_path)) # Open .uwg file and feed csv data to initializeDataFile try: uwg_param_data = utilities.read_csv(uwg_param_file_path) except Exception as e: raise Exception("Failed to read .uwg file! {}".format(e.message)) # The initialize.uwg is read with a dictionary so that users changing # line endings or line numbers doesn't make reading input incorrect self._init_param_dict = {} count = 0 while count < len(uwg_param_data): row = uwg_param_data[count] row = [row[i].replace(" ", "") for i in xrange(len(row))] # strip white spaces # Optional parameters might be empty so handle separately is_optional_parameter = ( row != [] and \ ( row[0] == "albRoof" or \ row[0] == "vegRoof" or \ row[0] == "glzR" or \ row[0] == "hvac" or \ row[0] == "albWall" or \ row[0] == "SHGC" ) ) if row == [] or "#" in row[0]: count += 1 continue elif row[0] == "SchTraffic": # SchTraffic: 3 x 24 matrix trafficrows = uwg_param_data[count + 1:count + 4] self._init_param_dict[row[0]] = map( lambda r: utilities.str2fl(r[:24]), trafficrows) count += 4 elif row[0] == "bld": #bld: 17 x 3 matrix bldrows = uwg_param_data[count + 1:count + 17] self._init_param_dict[row[0]] = map( lambda r: utilities.str2fl(r[:3]), bldrows) count += 17 elif is_optional_parameter: self._init_param_dict[row[0]] = float( row[1]) if row[1] != "" else None count += 1 else: self._init_param_dict[row[0]] = float(row[1]) count += 1 ipd = self._init_param_dict # Define Simulation and Weather parameters if self.Month is None: self.Month = ipd['Month'] if self.Day is None: self.Day = ipd['Day'] if self.nDay is None: self.nDay = ipd['nDay'] if self.dtSim is None: self.dtSim = ipd['dtSim'] if self.dtWeather is None: self.dtWeather = ipd['dtWeather'] # HVAC system and internal laod if self.autosize is None: self.autosize = ipd['autosize'] if self.sensOcc is None: self.sensOcc = ipd['sensOcc'] if self.LatFOcc is None: self.LatFOcc = ipd['LatFOcc'] if self.RadFOcc is None: self.RadFOcc = ipd['RadFOcc'] if self.RadFEquip is None: self.RadFEquip = ipd['RadFEquip'] if self.RadFLight is None: self.RadFLight = ipd['RadFLight'] # Define Urban microclimate parameters if self.h_ubl1 is None: self.h_ubl1 = ipd['h_ubl1'] if self.h_ubl2 is None: self.h_ubl2 = ipd['h_ubl2'] if self.h_ref is None: self.h_ref = ipd['h_ref'] if self.h_temp is None: self.h_temp = ipd['h_temp'] if self.h_wind is None: self.h_wind = ipd['h_wind'] if self.c_circ is None: self.c_circ = ipd['c_circ'] if self.c_exch is None: self.c_exch = ipd['c_exch'] if self.maxDay is None: self.maxDay = ipd['maxDay'] if self.maxNight is None: self.maxNight = ipd['maxNight'] if self.windMin is None: self.windMin = ipd['windMin'] if self.h_obs is None: self.h_obs = ipd['h_obs'] # Urban characteristics if self.bldHeight is None: self.bldHeight = ipd['bldHeight'] if self.h_mix is None: self.h_mix = ipd['h_mix'] if self.bldDensity is None: self.bldDensity = ipd['bldDensity'] if self.verToHor is None: self.verToHor = ipd['verToHor'] if self.charLength is None: self.charLength = ipd['charLength'] if self.alb_road is None: self.alb_road = ipd['albRoad'] if self.d_road is None: self.d_road = ipd['dRoad'] if self.sensAnth is None: self.sensAnth = ipd['sensAnth'] if self.latAnth is None: self.latAnth = ipd['latAnth'] # climate Zone if self.zone is None: self.zone = ipd['zone'] # Vegetation parameters if self.vegCover is None: self.vegCover = ipd['vegCover'] if self.treeCoverage is None: self.treeCoverage = ipd['treeCoverage'] if self.vegStart is None: self.vegStart = ipd['vegStart'] if self.vegEnd is None: self.vegEnd = ipd['vegEnd'] if self.albVeg is None: self.albVeg = ipd['albVeg'] if self.rurVegCover is None: self.rurVegCover = ipd['rurVegCover'] if self.latGrss is None: self.latGrss = ipd['latGrss'] if self.latTree is None: self.latTree = ipd['latTree'] # Define Traffic schedule if self.SchTraffic is None: self.SchTraffic = ipd['SchTraffic'] # Define Road (Assume 0.5m of asphalt) if self.kRoad is None: self.kRoad = ipd['kRoad'] if self.cRoad is None: self.cRoad = ipd['cRoad'] # Building stock fraction if self.bld is None: self.bld = ipd['bld'] # Optional parameters if self.albRoof is None: self.albRoof = ipd['albRoof'] if self.vegRoof is None: self.vegRoof = ipd['vegRoof'] if self.glzR is None: self.glzR = ipd['glzR'] if self.albWall is None: self.albWall = ipd['albWall'] if self.SHGC is None: self.SHGC = ipd['SHGC'] def set_input(self): """ Set inputs from .uwg input file if not already defined, the check if all the required input parameters are there. """ # If a uwgParamFileName is set, then read inputs from .uwg file. # User-defined class properties will override the inputs from the .uwg file. if self.uwgParamFileName is not None: print "\nReading uwg file input." self.read_input() else: print "\nNo .uwg file input." # Required parameters is_defined = (type(self.Month) == float or type(self.Month) == int) and \ (type(self.Day) == float or type(self.Day) == int) and \ (type(self.nDay) == float or type(self.nDay) == int) and \ type(self.dtSim) == float and type(self.dtWeather) == float and \ (type(self.autosize) == float or type(self.autosize) == int) and \ type(self.sensOcc) == float and type(self.LatFOcc) == float and \ type(self.RadFOcc) == float and type(self.RadFEquip) == float and \ type(self.RadFLight) == float and type(self.h_ubl1) == float and \ type(self.h_ubl2) == float and type(self.h_ref) == float and \ type(self.h_temp) == float and type(self.h_wind) == float and \ type(self.c_circ) == float and type(self.c_exch) == float and \ type(self.maxDay) == float and type(self.maxNight) == float and \ type(self.windMin) == float and type(self.h_obs) == float and \ type(self.bldHeight) == float and type(self.h_mix) == float and \ type(self.bldDensity) == float and type(self.verToHor) == float and \ type(self.charLength) == float and type(self.alb_road) == float and \ type(self.d_road) == float and type(self.sensAnth) == float and \ type(self.latAnth) == float and type(self.bld) == type([]) and \ self.is_near_zero(len(self.bld)-16.0) and \ type(self.latTree) == float and type(self.latGrss) == float and \ (type(self.zone) == float or type(self.zone) == int) and \ (type(self.vegStart) == float or type(self.vegStart) == int) and \ (type(self.vegEnd) == float or type(self.vegEnd) == int) and \ type(self.vegCover) == float and type(self.treeCoverage) == float and \ type(self.albVeg) == float and type(self.rurVegCover) == float and \ type(self.kRoad) == float and type(self.cRoad) == float and \ type(self.SchTraffic) == type([]) and self.is_near_zero(len(self.SchTraffic)-3.0) if not is_defined: raise Exception( "The required parameters have not been defined correctly. Check input parameters and try again." ) # Modify zone to be used as python index self.zone = int(self.zone) - 1 def init_input_obj(self): """Section 4 - Create UWG objects from input parameters self.simTime # simulation time parameter obj self.weather # weather obj for simulation time period self.forcIP # Forcing obj self.forc # Empty forcing obj self.geoParam # geographic parameters obj self.RSM # Rural site & vertical diffusion model obj self.USM # Urban site & vertical diffusion model obj self.UCM # Urban canopy model obj self.UBL # Urban boundary layer model self.road # urban road element self.rural # rural road element self.soilindex1 # soil index for urban rsoad depth self.soilindex2 # soil index for rural road depth self.BEM # list of BEMDef objects self.Sch # list of Schedule objects """ climate_file_path = os.path.join(self.epwDir, self.epwFileName) self.simTime = SimParam(self.dtSim, self.dtWeather, self.Month, self.Day, self.nDay) # simulation time parametrs self.weather = Weather( climate_file_path, self.simTime.timeInitial, self.simTime.timeFinal ) # weather file data for simulation time period self.forcIP = Forcing(self.weather.staTemp, self.weather) # initialized Forcing class self.forc = Forcing() # empty forcing class # Initialize geographic Param and Urban Boundary Layer Objects nightStart = 18. # arbitrary values for begin/end hour for night setpoint nightEnd = 8. maxdx = 250. # max dx (m) self.geoParam = Param(self.h_ubl1,self.h_ubl2,self.h_ref,self.h_temp,self.h_wind,self.c_circ,\ self.maxDay,self.maxNight,self.latTree,self.latGrss,self.albVeg,self.vegStart,self.vegEnd,\ nightStart,nightEnd,self.windMin,self.WGMAX,self.c_exch,maxdx,self.G,self.CP,self.VK,self.R,\ self.RV,self.LV,math.pi,self.SIGMA,self.WATERDENS,self.LVTT,self.TT,self.ESTT,self.CL,\ self.CPV,self.B, self.CM, self.COLBURN) self.UBL = UBLDef('C', self.charLength, self.weather.staTemp[0], maxdx, self.geoParam.dayBLHeight, self.geoParam.nightBLHeight) # Defining road emis = 0.93 asphalt = Material(self.kRoad, self.cRoad, 'asphalt') road_T_init = 293. road_horizontal = 1 road_veg_coverage = min(self.vegCover / (1 - self.bldDensity), 1.) # fraction of surface vegetation coverage # define road layers road_layer_num = int(math.ceil(self.d_road / 0.05)) thickness_vector = map(lambda r: 0.05, range( road_layer_num)) # 0.5/0.05 ~ 10 x 1 matrix of 0.05 thickness material_vector = map(lambda n: asphalt, range(road_layer_num)) self.road = Element(self.alb_road,emis,thickness_vector,material_vector,road_veg_coverage,\ road_T_init,road_horizontal,name="urban_road") self.rural = copy.deepcopy(self.road) self.rural.vegCoverage = self.rurVegCover self.rural._name = "rural_road" # Define BEM for each DOE type (read the fraction) if not os.path.exists(self.readDOE_file_path): raise Exception("readDOE.pkl file: '{}' does not exist.".format( readDOE_file_path)) readDOE_file = open(self.readDOE_file_path, 'rb') # open pickle file in binary form refDOE = cPickle.load(readDOE_file) refBEM = cPickle.load(readDOE_file) refSchedule = cPickle.load(readDOE_file) readDOE_file.close() # Define building energy models k = 0 r_glaze = 0 # Glazing ratio for total building stock SHGC = 0 # SHGC addition for total building stock alb_wall = 0 # albedo wall addition for total building stock h_floor = self.flr_h or 3.05 # average floor height total_urban_bld_area = math.pow( self.charLength, 2 ) * self.bldDensity * self.bldHeight / h_floor # total building floor area area_matrix = utilities.zeros(16, 3) self.BEM = [] # list of BEMDef objects self.Sch = [] # list of Schedule objects for i in xrange(16): # 16 building types for j in xrange(3): # 3 built eras if self.bld[i][j] > 0.: # Add to BEM list self.BEM.append(refBEM[i][j][self.zone]) self.BEM[k].frac = self.bld[i][j] self.BEM[k].fl_area = self.bld[i][j] * total_urban_bld_area # Overwrite with optional parameters if provided if self.glzR: self.BEM[k].building.glazingRatio = self.glzR if self.albRoof: self.BEM[k].roof.albedo = self.albRoof if self.vegRoof: self.BEM[k].roof.vegCoverage = self.vegRoof if self.SHGC: self.BEM[k].building.shgc = self.SHGC if self.albWall: self.BEM[k].wall.albedo = self.albWall # Keep track of total urban r_glaze, SHGC, and alb_wall for UCM model r_glaze = r_glaze + self.BEM[k].frac * self.BEM[ k].building.glazingRatio ## SHGC = SHGC + self.BEM[k].frac * self.BEM[k].building.shgc alb_wall = alb_wall + self.BEM[k].frac * self.BEM[ k].wall.albedo # Add to schedule list self.Sch.append(refSchedule[i][j][self.zone]) k += 1 # Reference site class (also include VDM) self.RSM = RSMDef(self.lat, self.lon, self.GMT, self.h_obs, self.weather.staTemp[0], self.weather.staPres[0], self.geoParam, self.z_meso_dir_path) self.USM = RSMDef(self.lat, self.lon, self.GMT, self.bldHeight / 10., self.weather.staTemp[0], self.weather.staPres[0], self.geoParam, self.z_meso_dir_path) T_init = self.weather.staTemp[0] H_init = self.weather.staHum[0] self.UCM = UCMDef(self.bldHeight,self.bldDensity,self.verToHor,self.treeCoverage,self.sensAnth,self.latAnth,T_init,H_init,\ self.weather.staUmod[0],self.geoParam,r_glaze,SHGC,alb_wall,self.road) self.UCM.h_mix = self.h_mix # Define Road Element & buffer to match ground temperature depth roadMat, newthickness = procMat(self.road, self.MAXTHICKNESS, self.MINTHICKNESS) for i in xrange(self.nSoil): # if soil depth is greater then the thickness of the road # we add new slices of soil at max thickness until road is greater or equal is_soildepth_equal = self.is_near_zero( self.depth_soil[i][0] - sum(newthickness), 1e-15) if is_soildepth_equal or (self.depth_soil[i][0] > sum(newthickness)): while self.depth_soil[i][0] > sum(newthickness): newthickness.append(self.MAXTHICKNESS) roadMat.append(self.SOIL) self.soilindex1 = i break self.road = Element(self.road.albedo, self.road.emissivity, newthickness, roadMat,\ self.road.vegCoverage, self.road.layerTemp[0], self.road.horizontal, self.road._name) # Define Rural Element ruralMat, newthickness = procMat(self.rural, self.MAXTHICKNESS, self.MINTHICKNESS) for i in xrange(self.nSoil): # if soil depth is greater then the thickness of the road # we add new slices of soil at max thickness until road is greater or equal is_soildepth_equal = self.is_near_zero( self.depth_soil[i][0] - sum(newthickness), 1e-15) if is_soildepth_equal or (self.depth_soil[i][0] > sum(newthickness)): while self.depth_soil[i][0] > sum(newthickness): newthickness.append(self.MAXTHICKNESS) ruralMat.append(self.SOIL) self.soilindex2 = i break self.rural = Element(self.rural.albedo, self.rural.emissivity, newthickness,\ ruralMat,self.rural.vegCoverage,self.rural.layerTemp[0],self.rural.horizontal, self.rural._name) def hvac_autosize(self): """ Section 6 - HVAC Autosizing (unlimited cooling & heating) """ for i in xrange(len(self.BEM)): if self.is_near_zero(self.autosize) == False: self.BEM[i].building.coolCap = 9999. self.BEM[i].building.heatCap = 9999. def simulate(self): """ Section 7 - UWG main section self.N # Total hours in simulation self.ph # per hour self.dayType # 3=Sun, 2=Sat, 1=Weekday self.ceil_time_step # simulation timestep (dt) fitted to weather file timestep # Output of object instance vector self.WeatherData # Nx1 vector of forc instance self.UCMData # Nx1 vector of UCM instance self.UBLData # Nx1 vector of UBL instance self.RSMData # Nx1 vector of RSM instance self.USMData # Nx1 vector of USM instance """ self.N = int(self.simTime.days * 24) # total number of hours in simulation n = 0 # weather time step counter self.ph = self.simTime.dt / 3600. # dt (simulation time step) in hours # Data dump variables time = range(self.N) self.WeatherData = [None for x in xrange(self.N)] self.UCMData = [None for x in xrange(self.N)] self.UBLData = [None for x in xrange(self.N)] self.RSMData = [None for x in xrange(self.N)] self.USMData = [None for x in xrange(self.N)] print '\nSimulating new temperature and humidity values for {} days from {}/{}.\n'.format( int(self.nDay), int(self.Month), int(self.Day)) self.logger.info("Start simulation") for it in range( 1, self.simTime.nt, 1 ): # for every simulation time-step (i.e 5 min) defined by uwg # Update water temperature (estimated) if self.is_near_zero(self.nSoil): self.forc.deepTemp = sum(self.forcIP.temp) / float( len(self.forcIP.temp) ) # for BUBBLE/CAPITOUL/Singapore only self.forc.waterTemp = sum(self.forcIP.temp) / float( len(self.forcIP.temp) ) - 10. # for BUBBLE/CAPITOUL/Singapore only else: self.forc.deepTemp = self.Tsoil[ self.soilindex1][self.simTime.month - 1] #soil temperature by depth, by month self.forc.waterTemp = self.Tsoil[2][self.simTime.month - 1] # There's probably a better way to update the weather... self.simTime.UpdateDate() self.logger.info("\n{0} m={1}, d={2}, h={3}, s={4}".format( __name__, self.simTime.month, self.simTime.day, self.simTime.secDay / 3600., self.simTime.secDay)) self.ceil_time_step = int( math.ceil(it * self.ph) ) - 1 # simulation time increment raised to weather time step # minus one to be consistent with forcIP list index # Updating forcing instance self.forc.infra = self.forcIP.infra[ self. ceil_time_step] # horizontal Infrared Radiation Intensity (W m-2) self.forc.wind = max(self.forcIP.wind[self.ceil_time_step], self.geoParam.windMin) # wind speed (m s-1) self.forc.uDir = self.forcIP.uDir[ self.ceil_time_step] # wind direction self.forc.hum = self.forcIP.hum[ self.ceil_time_step] # specific humidty (kg kg-1) self.forc.pres = self.forcIP.pres[ self.ceil_time_step] # Pressure (Pa) self.forc.temp = self.forcIP.temp[ self.ceil_time_step] # air temperature (C) self.forc.rHum = self.forcIP.rHum[ self.ceil_time_step] # Relative humidity (%) self.forc.prec = self.forcIP.prec[ self.ceil_time_step] # Precipitation (mm h-1) self.forc.dif = self.forcIP.dif[ self. ceil_time_step] # horizontal solar diffuse radiation (W m-2) self.forc.dir = self.forcIP.dir[ self.ceil_time_step] # normal solar direct radiation (W m-2) self.UCM.canHum = copy.copy( self.forc.hum) # Canyon humidity (absolute) same as rural # Update solar flux self.solar = SolarCalcs(self.UCM, self.BEM, self.simTime, self.RSM, self.forc, self.geoParam, self.rural) self.rural, self.UCM, self.BEM = self.solar.solarcalcs() # Update building & traffic schedule # Assign day type (1 = weekday, 2 = sat, 3 = sun/other) if self.is_near_zero(self.simTime.julian % 7): self.dayType = 3 # Sunday elif self.is_near_zero(self.simTime.julian % 7 - 6.): self.dayType = 2 # Saturday else: self.dayType = 1 # Weekday # Update anthropogenic heat load for each hour (building & UCM) self.UCM.sensAnthrop = self.sensAnth * ( self.SchTraffic[self.dayType - 1][self.simTime.hourDay]) # Update the energy components for building types defined in initialize.uwg for i in xrange(len(self.BEM)): # Set temperature self.BEM[i].building.coolSetpointDay = self.Sch[i].Cool[ self.dayType - 1][self.simTime. hourDay] + 273.15 # add from temperature schedule for cooling self.BEM[i].building.coolSetpointNight = self.BEM[ i].building.coolSetpointDay self.BEM[i].building.heatSetpointDay = self.Sch[i].Heat[ self.dayType - 1][self.simTime. hourDay] + 273.15 # add from temperature schedule for heating self.BEM[i].building.heatSetpointNight = self.BEM[ i].building.heatSetpointDay # Internal Heat Load Schedule (W/m^2 of floor area for Q) self.BEM[i].Elec = self.Sch[i].Qelec * self.Sch[i].Elec[ self.dayType - 1][self.simTime.hourDay] # Qelec x elec fraction for day self.BEM[i].Light = self.Sch[i].Qlight * self.Sch[i].Light[ self.dayType - 1][self.simTime.hourDay] # Qlight x light fraction for day self.BEM[i].Nocc = self.Sch[i].Nocc * self.Sch[i].Occ[ self.dayType - 1][self.simTime. hourDay] # Number of occupants x occ fraction for day self.BEM[i].Qocc = self.sensOcc * (1 - self.LatFOcc) * self.BEM[ i].Nocc # Sensible Q occupant * fraction occupant sensible Q * number of occupants # SWH and ventilation schedule self.BEM[i].SWH = self.Sch[i].Vswh * self.Sch[i].SWH[ self.dayType - 1][self.simTime. hourDay] # litres per hour x SWH fraction for day self.BEM[i].building.vent = self.Sch[ i].Vent # m^3/s/m^2 of floor self.BEM[i].Gas = self.Sch[i].Qgas * self.Sch[i].Gas[ self.dayType - 1][self.simTime. hourDay] # Gas Equip Schedule, per m^2 of floor # This is quite messy, should update # Update internal heat and corresponding fractional loads intHeat = self.BEM[i].Light + self.BEM[i].Elec + self.BEM[ i].Qocc self.BEM[ i].building.intHeatDay = intHeat # W/m2 from light, electricity, occupants self.BEM[i].building.intHeatNight = intHeat self.BEM[i].building.intHeatFRad = ( self.RadFLight * self.BEM[i].Light + self.RadFEquip * self.BEM[i].Elec ) / intHeat # fraction of radiant heat from light and equipment of whole internal heat self.BEM[ i].building.intHeatFLat = self.LatFOcc * self.sensOcc * self.BEM[ i].Nocc / intHeat # fraction of latent heat (from occupants) of whole internal heat # Update envelope temperature layers self.BEM[i].T_wallex = self.BEM[i].wall.layerTemp[0] self.BEM[i].T_wallin = self.BEM[i].wall.layerTemp[-1] self.BEM[i].T_roofex = self.BEM[i].roof.layerTemp[0] self.BEM[i].T_roofin = self.BEM[i].roof.layerTemp[-1] # Update rural heat fluxes & update vertical diffusion model (VDM) self.rural.infra = self.forc.infra - self.rural.emissivity * self.SIGMA * self.rural.layerTemp[ 0]**4. # Infrared radiation from rural road self.rural.SurfFlux(self.forc, self.geoParam, self.simTime, self.forc.hum, self.forc.temp, self.forc.wind, 2., 0.) self.RSM.VDM(self.forc, self.rural, self.geoParam, self.simTime) # Calculate urban heat fluxes, update UCM & UBL self.UCM, self.UBL, self.BEM = urbflux(self.UCM, self.UBL, self.BEM, self.forc, self.geoParam, self.simTime, self.RSM) self.UCM.UCModel(self.BEM, self.UBL.ublTemp, self.forc, self.geoParam) self.UBL.UBLModel(self.UCM, self.RSM, self.rural, self.forc, self.geoParam, self.simTime) """ # Experimental code to run diffusion model in the urban area # N.B Commented out in python UWG because computed wind speed in # urban VDM: y = =0.84*ln((2-x/20)/0.51) results in negative log # for building heights >= 40m. Uroad = copy.copy(self.UCM.road) Uroad.sens = copy.copy(self.UCM.sensHeat) Uforc = copy.copy(self.forc) Uforc.wind = copy.copy(self.UCM.canWind) Uforc.temp = copy.copy(self.UCM.canTemp) self.USM.VDM(Uforc,Uroad,self.geoParam,self.simTime) """ self.logger.info("dbT = {}".format(self.UCM.canTemp - 273.15)) if n > 0: logging.info("dpT = {}".format(self.UCM.Tdp)) logging.info("RH = {}".format(self.UCM.canRHum)) if self.is_near_zero(self.simTime.secDay % self.simTime.timePrint) and n < self.N: self.logger.info("{0} ----sim time step = {1}----\n\n".format( __name__, n)) self.WeatherData[n] = copy.copy(self.forc) _Tdb, _w, self.UCM.canRHum, _h, self.UCM.Tdp, _v = psychrometrics( self.UCM.canTemp, self.UCM.canHum, self.forc.pres) self.UBLData[n] = copy.copy(self.UBL) self.UCMData[n] = copy.copy(self.UCM) self.RSMData[n] = copy.copy(self.RSM) self.logger.info("dbT = {}".format(self.UCMData[n].canTemp - 273.15)) self.logger.info("dpT = {}".format(self.UCMData[n].Tdp)) self.logger.info("RH = {}".format(self.UCMData[n].canRHum)) n += 1 def write_epw(self): """ Section 8 - Writing new EPW file """ epw_prec = self.epw_precision # precision of epw file input for iJ in xrange(len(self.UCMData)): # [iJ+self.simTime.timeInitial-8] = increments along every weather timestep in epw # [6 to 21] = column data of epw self.epwinput[iJ + self.simTime.timeInitial - 8][6] = "{0:.{1}f}".format( self.UCMData[iJ].canTemp - 273.15, epw_prec) # dry bulb temperature [?C] self.epwinput[iJ + self.simTime.timeInitial - 8][7] = "{0:.{1}f}".format( self.UCMData[iJ].Tdp, epw_prec) # dew point temperature [?C] self.epwinput[iJ + self.simTime.timeInitial - 8][8] = "{0:.{1}f}".format( self.UCMData[iJ].canRHum, epw_prec) # relative humidity [%] self.epwinput[iJ + self.simTime.timeInitial - 8][21] = "{0:.{1}f}".format( float(self.WeatherData[iJ].wind), epw_prec) # wind speed [m/s] # Writing new EPW file epw_new_id = open(self.newPathName, "w") for i in xrange(8): new_epw_line = '{}\r\n'.format( reduce(lambda x, y: x + "," + y, self._header[i])) epw_new_id.write(new_epw_line) for i in xrange(len(self.epwinput)): printme = "" for ei in xrange(34): printme += "{}".format(self.epwinput[i][ei]) + ',' printme = printme + "{}".format(self.epwinput[i][ei]) new_epw_line = "{0}\r\n".format(printme) epw_new_id.write(new_epw_line) epw_new_id.close() print "New climate file '{}' is generated at {}.".format( self.destinationFileName, self.destinationDir) def run(self): # run main class methods self.read_epw() self.set_input() self.init_input_obj() self.hvac_autosize() self.simulate() self.write_epw()
def ran_simulation(): """ Main ran_simulation """ # define sim_param and inside RB pool: all available Resources list sim_param = SimParam() no_of_slices = sim_param.no_of_slices no_of_users_per_slice = sim_param.no_of_users_per_slice # create result directories create_dir(sim_param) # create logfile and write SimParameters results_dir = "results/" + sim_param.timestamp log_file = open(results_dir + "/logfile.txt", "wt") log_file.write('no_of_slices: %d\nno_of_users_per_slice: %d\n\n' % (no_of_slices, no_of_users_per_slice)) attrs = vars(sim_param) log_file.write('SimParam\n'+''.join("%s: %s\n" % item for item in attrs.items())) # log_file.close() # initialize SD_RAN_Controller SD_RAN_Controller = Controller(sim_param) # Each slice has different users slices = [] slice_results = [] # initialize all slices for i in range(no_of_slices): slice_param_tmp = SliceParam(sim_param) slice_param_tmp.SLICE_ID = i slices.append(SliceSimulation(slice_param_tmp)) slice_results.append([]) # initialize all users with traffics and distances tmp_users = [] seed_dist = 0 # users in all slices have identical distance distributions #rng_dist = RNG(ExponentialRNS(lambda_x=1. / float(sim_param.MEAN_Dist)), s_type='dist') # , the_seed=seed_dist rng_dist = RNG(UniformRNS(sim_param.DIST_MIN,sim_param.DIST_MAX, the_seed=seed_dist), s_type='dist') # dist_arr = [10, 100 ]#[30, 30, 100, 100, 100, 100, 100, 100, 100, 100] # 10*(1+user_id%no_of_users_per_slice)**2 for j in range(no_of_users_per_slice): user_id = i*no_of_users_per_slice + j #tmp_users.append(User(user_id, rng_dist.get_dist(), slice_list=[slices[i]], sim_param=sim_param)) tmp_users.append(User(user_id, dist_arr[j], slice_list=[slices[i]], sim_param=sim_param)) # insert user to slices slices[i].insert_users(tmp_users) # Choose Slice Manager Algorithm, 'PF': prop fair, 'MCQI': Max Channel Quality Index, 'RR': round-robin slices[0].slice_param.SM_ALGO = 'RR' slices[1].slice_param.SM_ALGO = 'MCQI' slices[2].slice_param.SM_ALGO = 'PF' # log Slice Parameters for i in range(no_of_slices): attrs = vars(slices[i].slice_param) log_file.write('\nSliceParam\n' + ''.join("%s: %s\n" % item for item in attrs.items())) #log_file.close() # loop rounds for each slice for i in range(int(sim_param.T_FINAL/sim_param.T_C)): RB_mapping = SD_RAN_Controller.RB_allocate_to_slices(slices[0].sim_state.now, slices) for j in range(len(slices)): slices[j].prep_next_round(RB_mapping[j,:,:]) slice_results[j].append(slices[j].simulate_one_round()) # Store Simulation Results # user results parent_dir = "results/" + sim_param.timestamp + "/user_results" path = parent_dir + "/tp" for i in range(len(slice_results)): user_count = len(slice_results[i][-1].server_results) # choose latest result for data for k in range(user_count): common_name = "/slice%d_user%d_" % (i, slice_results[i][-1].server_results[k].server.user.user_id) cc_temp = slice_results[i][-1].server_results[k].server.counter_collection # tp filename = parent_dir + "/tp" + common_name + "sum_power_two.csv" savetxt(filename, cc_temp.cnt_tp.sum_power_two, delimiter=',') filename = parent_dir + "/tp" + common_name + "values.csv" savetxt(filename, cc_temp.cnt_tp.values, delimiter=',') filename = parent_dir + "/tp" + common_name + "timestamps.csv" savetxt(filename, cc_temp.cnt_tp.timestamps, delimiter=',') filename = parent_dir + "/tp" + common_name + "all_data.csv" #savetxt(filename, np.transpose(np.array([cc_temp.cnt_tp.values,cc_temp.cnt_tp.timestamps])), delimiter=',') df = DataFrame(np.transpose(np.array([cc_temp.cnt_tp.values,cc_temp.cnt_tp.timestamps])), columns=['Values', 'Timestamps']) export_csv = df.to_csv(filename, index=None, header=True) # tp2 filename = parent_dir + "/tp2" + common_name + "sum_power_two.csv" savetxt(filename, cc_temp.cnt_tp2.sum_power_two, delimiter=',') filename = parent_dir + "/tp2" + common_name + "values.csv" savetxt(filename, cc_temp.cnt_tp2.values, delimiter=',') filename = parent_dir + "/tp2" + common_name + "timestamps.csv" savetxt(filename, cc_temp.cnt_tp2.timestamps, delimiter=',') # ql filename = parent_dir + "/ql" + common_name + "sum_power_two.csv" savetxt(filename, cc_temp.cnt_ql.sum_power_two, delimiter=',') filename = parent_dir + "/ql" + common_name + "values.csv" savetxt(filename, cc_temp.cnt_ql.values, delimiter=',') filename = parent_dir + "/ql" + common_name + "timestamps.csv" savetxt(filename, cc_temp.cnt_ql.timestamps, delimiter=',') # system time (delay) filename = parent_dir + "/delay" + common_name + "values.csv" savetxt(filename, cc_temp.cnt_syst.values, delimiter=',') filename = parent_dir + "/delay" + common_name + "timestamps.csv" savetxt(filename, cc_temp.cnt_syst.timestamps, delimiter=',') # Find how to insert histograms # plot results parent_dir = "results/" + sim_param.timestamp plot_results(parent_dir, no_of_slices, no_of_users_per_slice, sim_param, slices) # rb dist printing filename = "results/" + sim_param.timestamp + "/summary" rb_total = 0 rb_dist = [] for s in slices: rb_dist_slice = [] for u in s.server_list: rb_dist_slice.append(u.RB_counter) slicesum = np.nansum(rb_dist_slice) print("Slice %d dist: " % s.slice_param.SLICE_ID, *np.round(np.divide(rb_dist_slice,slicesum/100), 1)) # write these to file savetxt(filename, cc_temp.cnt_ql.sum_power_two, delimiter=',') rb_dist.append(slicesum) totalsum = np.nansum(rb_dist) print("rb dist (RR MCQI PF): ", *np.round(np.divide(rb_dist, totalsum / 100), 1))