class CommandsListener(threading.Thread): def __init__(self, thymioController, mainLogger): threading.Thread.__init__(self) # Create socket for listening to simulation commands self.__sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.__sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) self.__sock.bind((cl.COMMANDS_LISTENER_HOST, cl.COMMANDS_LISTENER_PORT)) self.__sock.listen(5) self.__thymioController = thymioController self.__mainLogger = mainLogger self.__simulation = None self.__counter = pr.starter_number def run(self): while 1: try: # Waiting for client... self.__mainLogger.debug("CommandListener - Waiting on accept...") conn, (addr, port) = self.__sock.accept() self.__mainLogger.debug('CommandListener - Received command from (' + addr + ', ' + str(port) + ')') if addr not in cl.TRUSTED_CLIENTS: self.__mainLogger.error( 'CommandListener - Received connection request from untrusted client (' + addr + ', ' + str( port) + ')') continue # Receive one message self.__mainLogger.debug('CommandListener - Receiving command...') recvOptions = recvOneMessage(conn) self.__mainLogger.debug('CommandListener - Received ' + str(recvOptions)) if recvOptions.kill: # Received killing command -> Stop everything self.__thymioController.killRequest() if self.__simulation: self.__simulation.stop() break elif recvOptions.start and (not self.__simulation or self.__simulation.isStopped()): # Adding experiment number to pr.EXPERIMENT_NAME experiment_name = pr.EXPERIMENT_NAME + "_" + str(self.__counter) self.__counter += 1 # Received start request AND simulation is not running -> Start a new simulation self.__mainLogger.debug("CommandListener - Starting simulation...") self.__simulation = Simulation(self.__thymioController, recvOptions.debug, experiment_name) self.__thymioController.setSimulation(self.__simulation) self.__simulation.start() elif recvOptions.stop and self.__simulation and not self.__simulation.isStopped(): # TODO: Stop properly # Received stop request AND simulation is up and running -> Stop the simulation self.__mainLogger.debug("CommandListener - Stopping simulation...") self.__simulation.stop() self.__simulation = None elif recvOptions.stopthymio: self.__mainLogger.debug("CommandListener - Stopping Thymio...") self.__thymioController.stopThymio() except: self.__mainLogger.critical( 'Error in CommandsListener: ' + str(sys.exc_info()[0]) + ' - ' + traceback.format_exc()) self.__mainLogger.debug('CommandListener - KILLED -> Exiting...')
def main(): coffee = Body.ThermalBody(500) solver = Solver.Euler(0.5) def stop_condition(coffee): return coffee.temperature > sim.Ta * 1.1 sim = Simulation.CoolingSim(stop_condition, solver, 293, 0.05, coffee) t, T = sim.get_results() plt.plot(t, T) coffee = Body.ThermalBody(500) solver = Solver.RK2(0.5) def stop_condition(coffee): return coffee.temperature > sim.Ta * 1.1 sim = Simulation.CoolingSim(stop_condition, solver, 293, 0.05, coffee) t, T = sim.get_results() plt.plot(t, T) plt.title("OOP Cooling Curves") plt.xlabel("Time [s]") plt.ylabel("Temperature[K]") plt.legend(["Euler Curve", "RK2 Cooling Curve"])
def main(): for device in ConfigureWin.config["devices"]: for city in ConfigureWin.config["citys"]: print(city + " device: " + device) simulation = Simulation(city, device) simulation.start()
def handlePerformedActionShow(words, writeFile): global opponentName global numBoardCards global preflopBets global postflopBets global turnBets global riverBets global boardCards global d if(words[5] == opponentName): opponentHand = [] for card in words[1:5]: opponentHand.append(parseCard(card)) preflopRating = Pokerini.pokeriniLookup(opponentHand, d) writeFile.write(str(preflopRating)+","+','.join(preflopBets)) writeFile.write('\n') if(numBoardCards >= 3): postflopRanking = Simulation.simulateOld(opponentHand, boardCards[0:3], 3, 100) writeFile.write(str(postflopRanking)+","+','.join(postflopBets)) writeFile.write('\n') if(numBoardCards >= 4): turnRanking = Simulation.simulateOld(opponentHand, boardCards[0:4], 4, 100) writeFile.write(str(turnRanking)+","+','.join(turnBets)) writeFile.write('\n') if(numBoardCards == 5): riverRanking = Simulation.simulateOld(opponentHand, boardCards[0:5], 5, 100) writeFile.write(str(riverRanking)+","+','.join(riverBets)) writeFile.write('\n')
def main(): skull = Body.GravBody(5, 6.371 * 10**6, 8000.) solver = Solver.RK2(0.001) def stop_condition(skull): return skull.velocity > 0 sim1 = Simulation.TrajectorySim(stop_condition, solver, skull) x, y = sim1.get_results() skull2 = Body.GravBody(5, 6.371 * 10**6, 8000.) sim2 = Simulation.InverseTrajectorySim(stop_condition, solver, skull2) a, b = sim2.get_results() plt.plot(x, y) plt.plot(a, b) plt.title("Skull Tosses") plt.xlabel("Time [s]") plt.ylabel("Height [m]") plt.legend(["Uniform Gravity", "Inverse Square Gravity"]) plt.figure() varray = np.arange(0, 100, 0.5) harray = [] for v in varray: skull3 = Body.GravBody(5, 6.371 * 10**6, v) sim3 = Simulation.InverseTrajectorySim(stop_condition, solver, skull3) result = sim3.get_results() harray.append(skull3.position) plt.plot(varray, harray) plt.title("Maximum Height vs. Initial Velocity") plt.xlabel("Initial Velocity [m/s]") plt.ylabel("Maximum Height [m]")
def ranCoor(self, p_mu, p_numu): #.. Rotation angles phi = Simu.getRandom() * 2.*mth.pi cPhi = mth.cos(phi) sPhi = mth.sin(phi) cTheta = -1. + 2.*Simu.getRandom() sTheta = mth.sqrt(1. - cTheta**2) theta = mth.acos(cTheta) #.. Rotation angles Ra = np.array([ \ [cPhi , -sPhi, 0. ], \ [sPhi , cPhi, 0. ], \ [0. , 0., 1. ] \ ]) # print("Ra:", Ra) Rb = np.array([ \ [cTheta , 0., -sTheta ], \ [0. , 1., 0. ], \ [sTheta , 0., cTheta ] \ ]) # print("Rb:", Rb) Rr = np.dot(Ra, Rb) # print("Rr:", Rr) #.. Do rotation: p_mu1 = np.dot(Rr, p_mu) p_numu1 = np.dot(Rr, p_numu) return p_mu1, p_numu1, cTheta, phi
def __init__(self, master=None): super().__init__(master=master) self.title("Choice Selection") self.geometry("350x125") choiceLabel = Label(self, text="Please select which you will use") choiceLabel.grid(row=0, column=1) global rockImage global paperImage global scissorsImage rockImage = ImagesHelper.GetImage("Rock") paperImage = ImagesHelper.GetImage("Paper") scissorsImage = ImagesHelper.GetImage("Scissors") rockButton = Button(self, text="Rock", image=rockImage) rockButton.bind("<Button>", lambda e: Simulation.RockSimulationForm(self)) rockButton.grid(row=1, column=0) paperButton = Button(self, image=paperImage) paperButton.bind("<Button>", lambda e: Simulation.PaperSimulationForm(self)) paperButton.grid(row=1, column=1) scissorsButton = Button(self, image=scissorsImage) scissorsButton.bind("<Button>", lambda e: Simulation.ScissorsSimulationForm(self)) scissorsButton.grid(row=1, column=2)
def handlePerformedActionShow(words, writeFile): global myName global numBoardCards global preflopBets global postflopBets global turnBets global riverBets global boardCards global d if (words[5] == myName): myHand = [] for card in words[1:5]: myHand.append(parseCard(card)) preflopRating = Pokerini.pokeriniLookup(myHand, d) writeFile.write(str(preflopRating) + "," + ','.join(preflopBets)) writeFile.write('\n') if (numBoardCards >= 3): postflopRanking = Simulation.simulateOld(myHand, boardCards[0:3], 3, 100) writeFile.write( str(postflopRanking) + "," + ','.join(postflopBets)) writeFile.write('\n') if (numBoardCards >= 4): turnRanking = Simulation.simulateOld(myHand, boardCards[0:4], 4, 100) writeFile.write(str(turnRanking) + "," + ','.join(turnBets)) writeFile.write('\n') if (numBoardCards == 5): riverRanking = Simulation.simulateOld(myHand, boardCards[0:5], 5, 100) writeFile.write(str(riverRanking) + "," + ','.join(riverBets)) writeFile.write('\n')
def CalPerformance(self, model): testTimes = 100 testHorizon = 500 successTimes = 0 for i in range(testTimes): # initialize variable preO = 0 histO = np.tile([[1, 0, 0]], (1, self.L)) Q_tm1 = 0 for t in range(testHorizon): # decide which action to take if preO == 2: a_t = 0 else: probA = model.predict(histO, batch_size=1) if np.random.uniform() < probA[0, 0]: a_t = 0 else: a_t = 1 # run simulation once simObj = Simulation(self.systemParaDict, a_t, Q_tm1) simObj.Main() curO = simObj.o_t # add o_t-1 into history newHistO = np.array([[0, 0, 0]]) newHistO[0, curO] = 1 histO = np.hstack((histO[:, 3:], newHistO)) # count successful times if a_t == 1 and simObj.f_t == 'S': successTimes += 1 # update temporary variables preO = curO Q_tm1 = simObj.Q_t # calculate throughput of the secondary user return successTimes / (testTimes * testHorizon)
def set_variables_panel(self): self.simulation = Simulation(self) font_ctrl = wx.Font(11, wx.FONTFAMILY_DEFAULT, wx.FONTSTYLE_NORMAL, wx.NORMAL) font_var = wx.Font(12, wx.FONTFAMILY_DEFAULT, wx.FONTSTYLE_NORMAL, wx.NORMAL) font = wx.Font(15, wx.FONTFAMILY_DEFAULT, wx.FONTSTYLE_NORMAL, wx.NORMAL) font_exec = wx.Font(18, wx.FONTFAMILY_DEFAULT, wx.FONTSTYLE_NORMAL, wx.NORMAL) self.parameters_text = wx.StaticText(self.panel, label='Parametry Symulacji:', pos=(0.01*self.screen_size[0], 0.36*self.screen_size[1])) self.parameters_text.SetFont(font_var) self.parameters_text.Hide() y = 0.36 * self.screen_size[1] for i in range(6): self.var_start.append(wx.StaticText(self.panel, label='', pos=(0.01*self.screen_size[0], y + 0.04*(i+1)*self.screen_size[1]))) self.var_start[i].Hide() self.var_start[i].SetFont(font_var) self.Ctrls.append(wx.SpinCtrlDouble(self.panel, value='0', pos=(0.12*self.screen_size[0], y + 0.04*(i+1)*self.screen_size[1]), size=(0.09*self.screen_size[0], -1))) self.Ctrls[i].Hide() self.Ctrls[i].SetFont(font_ctrl) self.var_exec.append(wx.StaticText(self.panel, label='', pos=((0.86-i*0.15)*self.screen_size[0], 0.87*self.screen_size[1]))) self.var_exec[i].Hide() self.var_exec[i].SetFont(font_exec) self.legend.append(wx.StaticText(self.panel, label='', pos=(0.01*self.screen_size[0],0.6*self.screen_size[1] + 0.04*(i+1)*self.screen_size[1]))) self.legend[i].SetFont(font) self.language = wx.StaticText(self.panel, label=u'Język', pos=(0.01*self.screen_size[0], 0.01 * self.screen_size[1])) self.language.SetFont(font) png1 = wx.Image('variants.png', wx.BITMAP_TYPE_ANY).ConvertToBitmap() self.variants = [] variants = wx.StaticBitmap(self.panel, -1, png1, (0.35 * self.screen_size[0], 0.3 * self.screen_size[1]), (png1.GetWidth(), png1.GetHeight())) self.variants.append(variants) font = wx.Font(18, wx.FONTFAMILY_DEFAULT, wx.FONTSTYLE_NORMAL, wx.NORMAL) variants2 = wx.StaticText(self.panel,label='\n1\n\n\n\n\n2\n\n\n\n3\n\n\n\n4',pos=(0.3 * self.screen_size[0],0.3 * self.screen_size[1])) variants2.SetFont(font) self.variants.append(variants2) for i in self.variants: i.Hide()
def main(): city = "Shenzhen" device = "5100" simulation = Simulation(city, device) simulation.start()
def evolve_dag(population_size=10, number_of_offsprings=10, n=22, edge_mutation_probability=0.2, weight_mutation_probability=1., iters=10, tracks=[], frames_limit=25): population = initial_population(population_size, n) objective_values = evaluate_population(population, tracks, frames_limit) matrix = population[0].edges results = np.zeros(iters) last_saved_value = 0. for t in range(iters): print t children = [] parent_indices = parent_selection(objective_values, population_size, number_of_offsprings) print parent_indices ### crossover for i in range(len(parent_indices)/2): c1, c2 = dag.crossover(population[parent_indices[2*i]], population[parent_indices[2*i+1]], -const.network_weights_limit, const.network_weights_limit) children.append(c1) children.append(c2) ### mutation for child in children: if np.random.random() < edge_mutation_probability: child.edge_mutation() if np.random.random() < weight_mutation_probability: child.weight_mutation(-const.network_weights_limit, const.network_weights_limit) ### children evaluation and replacement children_objective_values = evaluate_population(children, tracks, frames_limit) objective_values = np.hstack((objective_values, children_objective_values)) tmp_population = population + children I = np.argsort(objective_values)[::-1] population = [] for i in range(population_size): population.append(tmp_population[I[i]]) objective_values = objective_values[I[:population_size]] ### statistics if (population[0].edges == matrix ).sum() != population[0].n ** 2 or t == iters-1: matrix = population[0].edges population[0].draw(save=True, nr=t) results[t] = objective_values.max() print t, results[t] if objective_values.max() - last_saved_value > 0.07 or t == iters-1: last_saved_value = objective_values.max() dag.save_population(population) np.savetxt(path_root + 'results.txt', results) for i in range(len(tracks)): title = path_root + "track_" + str(i+1) + "_gen_" + str(t) sim.simulation_movie(tracks[i], create_cars(population[:5]), title=title, frames_limit=frames_limit, show_demo=False, save=True) return results, population
def GenerateTrans(self, s): r = np.sqrt(self._epsilon * self._beta) / 1000. rp = np.sqrt(self._epsilon / self._beta) x = Simu.getParabolic(r) y = Simu.getParabolic(r) xp = Simu.getParabolic(rp) yp = Simu.getParabolic(rp) return x, y, xp, yp
def Simulation_launch(self): if self.busy > 0: return False # A new simulation thread is created if self.Simulation_stop(): self.simulation = Simulation(self.OneStep) self.simulation.start() return True
def main(): battlesimulator = Master() battlesimulator.introMessage() setupPlayers = SetupPlayers() setupPlayers.askPlayer() battlesimulator.displayStats(Warrior(1, 2, 3), Warrior(4, 5, 6)) warriorSet = WarriorSet(Warrior(1, 2, 3), Warrior(4, 5, 6)) warriorSet.printWarriors() simulation = Simulation() simulation.setWarriors(Warrior(1, 2, 3), Warrior(4, 5, 6)) simulation.run()
def evaluate_action_with_robots(results, state): pf_normal_value = evaluate_action(results, state) sum_potential = 0.0 number_of_actions = 0.0 for p in results.positions(): if p.cat() == Category.INFIELD or p.cat() == Category.OPPGOAL: sum_potential += evaluate_single_pos_with_robots( state.pose * p.pos(), state.opp_robots, state.own_robots) number_of_actions += 1 assert number_of_actions > 0 sum_potential /= number_of_actions squared_difference = np.abs( pf_normal_value - sum_potential ) # decide whether considering other robots is appropriate if squared_difference < 0.05: # upper bound - how to choose? return pf_normal_value # ab hier experimental # new Ball pos with passing new_ball_pos = results.expected_ball_pos_mean #update state new_state = copy.copy(state) new_state.ball_position = m2d.Vector2(0.0, 0.0) # Ball = Robot new_state.translation = new_ball_pos #new_state.rotation = pass # maybe rotation as needed for direkt / shortest path to the ball new_state.potential_field_function = "normal" # Simulation as in Simulation.py (decide_smart) actions_consequences = [] # Simulate Consequences for action in new_state.actions: #new_state.actions includes the possible kicks single_consequence = a.ActionResults([]) actions_consequences.append( Sim.simulate_consequences(action, single_consequence, new_state, 30)) best_action_with_team = Sim.decide_smart(actions_consequences, state) # compare new best action # TODO: Add simulation of a second kick without other robots to have better comparison # needed: action which would have been done without other robots # what should get returned?? to compare with other actions """ if best_value > pf_normal_value: return sum_potential """ return sum_potential
def execute(self, simulation: Simulation): """ Runs a simulation using the using the neural network as the agent :param simulation: The simulation to run, and get the score from :return: The score from the simulation """ while simulation.get_state( batch_id=self.batch_id) != Simulation.SimulationState.FINISHED: input_data = simulation.get_data(batch_id=self.batch_id) processed_data = self.run(input_data) simulation.apply_controls(processed_data, batch_id=self.batch_id) return simulation.get_score(batch_id=self.batch_id)
def init_multi_params(): global FULL_SCREEN global FRAME_SIZE global CROP_SIZE global SCREEN_SIZE global ACC Sim.init_multi() Ac.init_multi_arduino_communication() CROP_SIZE = (106, 360) SCREEN_SIZE = (8.0, 12.0) FULL_SCREEN = (8.0, 12.0) ACC = RELATIVE_ACC * SCREEN_SIZE[0]
def setUp(self): Simulation.setupJobEffMC() cores = 3000 bandwidth = 3000 self.system = Site.Batch( cores, bandwidth ) file1 = "/store/data/1" file2 = "/store/data/2" theStore = Data.EventStore() theStore.addFile( file1, 10000 ) theStore.addFile( file2, 20000 ) inputData = { file1, file2 } aJob = Job.Job( "T2_CH_CERN", inputData, 0.1, 220, 200, theStore ) self.system.addJob( aJob ) self.system.runJob( aJob, 0 )
def GenerateSamples(self, model): # initialize variables fullX = np.zeros((self.T, 3 * self.L)) fullY = np.zeros((self.T, 2)) indexU = np.zeros((self.T, 1)) sampleA, sampleR = [], [] preO = 0 histO = np.tile([[1, 0, 0]], (1, self.L)) Q_tm1 = 0 # generate trainX for t in range(self.T): # decide which action to take if preO == 0: a_t = 1 elif preO == 1: probA = model.predict(histO, batch_size=1) if np.random.uniform() < probA[0, 0]: a_t = 0 else: a_t = 1 else: a_t = 0 # run simulation once simObj = Simulation(self.systemParaDict, a_t, Q_tm1) simObj.Main() curO = simObj.o_t # add o_t-1 into history newHistO = np.array([[0, 0, 0]]) newHistO[0, preO] = 1 histO = np.hstack((histO[:, 3:], newHistO)) # collect data fullX[t, :] = histO sampleA.append(a_t) sampleR.append(simObj.r_t) if curO == 1: indexU[t, 0] = 1 # update temporary variables preO = curO Q_tm1 = simObj.Q_t # calculate reward-to-go rSum = 0 for t in reversed(range(self.T - 1)): fullY[t, 0] = sampleA[t + 1] rSum = self.beta * rSum + sampleR[t + 1] fullY[t, 1] = rSum # extract train data trainX = fullX[np.nonzero(indexU > 0)[0], :] trainY = fullY[np.nonzero(indexU > 0)[0], :] # return results return trainX, trainY
def GenerateSamples(self, model): # initialize variables fullX = np.zeros((self.T, 3 * self.L)) fullY = np.zeros((self.T, 2)) sampleA, sampleR = [], [] histO = np.tile([[1, 0, 0]], (1, self.L)) Q_tm1 = 0 # generate trainX for t in range(self.T): # decide which action to take probA = model.predict(histO, batch_size=1) if np.random.uniform() < probA[0, 0]: a_t = 0 else: a_t = 1 # run simulation once simObj = Simulation(self.systemParaDict, a_t, Q_tm1) simObj.Main() curO = simObj.o_t # add o_t into history newHistO = np.array([[0, 0, 0]]) newHistO[0, curO] = 1 histO = np.hstack((histO[:, 3:], newHistO)) # collect data fullX[t, :] = histO sampleA.append(a_t) sampleR.append(simObj.r_t) # update temporary variables Q_tm1 = simObj.Q_t # print('===== t =', t, '=====') # print('input = ' + str(histO)) # print('p_N = ' + str(probA[0, 0])) # print('a_t = ' + str(a_t)) # print('r_t = ' + str(simObj.r_t)) # calculate reward-to-go rSum = 0 for t in reversed(range(self.T)): fullY[t, 0] = sampleA[t] rSum = self.beta * rSum + sampleR[t] fullY[t, 1] = rSum # extract train data trainX = fullX trainY = fullY # print(trainY) # return results return trainX, trainY
def set_a_trader_simulation(path_trader_folder): path_RAS, path_Trades, path_Pnls = [""] * 3 if os.path.isfile(os.path.join(path_trader_folder, 'RawArbSignals.csv')): path_RAS = os.path.join(path_trader_folder, 'RawArbSignals.csv') if os.path.isfile(os.path.join(path_trader_folder, 'Trades.csv')): path_Trades = os.path.join(path_trader_folder, 'Trades.csv') if os.path.isfile(os.path.join(path_trader_folder, 'TraderPnls.csv')): path_Pnls = os.path.join(path_trader_folder, 'TraderPnls.csv') trader_name = ' - '.join(str(path_trader_folder).split('\\')[-2:]) trader_simulation_obj = Simulation(name=trader_name) trader_simulation_obj.files_set_data(file_RAS=path_RAS, file_Trades=path_Trades, file_Pnl=path_Pnls) return trader_simulation_obj
def __OnScriptNew(self, event): name = wx.GetTextFromUser("Enter Script Name:", "Script Name") if (name is None) or (len(name) < 0): return newScript = Simulation.SimScript(name) self.sim.savedPresets.startScripts.append(newScript) self.RefreshBox()
def EvaluationNN3(env, action_space, size_input, labels, TrainingSet, nSamples, max_epochs): average_NN = np.empty((0)) success_percentageNN = np.empty((0)) for i in range(len(nSamples)): model = NN3(action_space, size_input) encoded = tf.keras.utils.to_categorical(labels) model.fit(TrainingSet[0:nSamples[i], :], encoded[0:nSamples[i], :], epochs=50) T = 100 [trajNN, controlNN, flagNN] = sim.FlatPolicySim(env, model, max_epochs, T, size_input) length_trajNN = np.empty((0)) for j in range(len(trajNN)): length_trajNN = np.append(length_trajNN, len(trajNN[j][:])) average_NN = np.append( average_NN, np.divide(np.sum(length_trajNN), len(length_trajNN))) success_percentageNN = np.append( success_percentageNN, np.divide(np.sum(flagNN), len(length_trajNN))) return average_NN, success_percentageNN
def test_computational_time(): """This test ensures that the time required for the Adiabatic Quantum Computation is properly calculated. Asserts: That the function results_of_simulation(100,2,H0,H1) returns the expected value of the time, in a simulation with 100 steps, 2 particles and certain hi and Jij coefficients. """ hi = numpy.array((1, 2)) Jij = numpy.array(((0, 1), (1, 0))) H0 = Simulation.Hamiltonian_0(2) H1 = Simulation.Hamiltonian_1(2, hi, Jij) expected_result = 0.6571 actual_result = Simulation.results_of_simulation(100, 2, H0, H1) assert actual_result == expected_result
def ethz_config_pim( test_sys, options ): (TestCPUClass, test_mem_mode, FutureClass) = Simulation.setCPUClass(options) # JIWON: existing code created only one PIM system, modified to create multiple as necessary test_sys.pim_sys = [build_pim_system(options, test_mem_mode, TestCPUClass, pim_id=i) for i in xrange(options.num_pim_sys)] for i in xrange(options.num_pim_sys): pim_device_range = AddrRange(PIM_ADDRESS_BASE + i * PIM_ADDRESS_SIZE_INT, size = PIM_ADDRESS_SIZE) # added by JIWON test_sys.pim_sys[i].p2s = Bridge(ranges=test_sys.mem_ranges, delay='0.01ns', req_size=32, resp_size=32) test_sys.pim_sys[i].s2p = Bridge(ranges=pim_device_range, delay='0.01ns', req_size=32, resp_size=32) if ( GEM5_ENABLE_COMM_MONITORS == "TRUE" ): test_sys.pim_sys[i].Smon = CommMonitor() if ( SMON_DUMP_ADDRESS == "TRUE" ): test_sys.pim_sys[i].Smon.dump_addresses=True test_sys.pim_sys[i].Smon.dump_file="m5out/smon_addr_dump.txt" test_sys.pim_sys[i].pimbus.master = test_sys.pim_sys[i].Smon.slave test_sys.pim_sys[i].Smon.master = test_sys.pim_sys[i].p2s.slave else: test_sys.pim_sys[i].pimbus.master = test_sys.pim_sys[i].p2s.slave test_sys.pim_sys[i].s2p.master = test_sys.pim_sys[i].pimbus.slave if ( MOVE_PIM_TO_HOST == "FALSE" ): test_sys.pim_sys[i].p2s.master = test_sys.smcxbar.slave test_sys.smcxbar.master = test_sys.pim_sys[i].s2p.slave; else: test_sys.pim_sys[i].p2s.master = test_sys.membus.slave test_sys.membus.master = test_sys.pim_sys[i].s2p.slave;
def average_over_seeds(model_type_list, model_parameters_list, n=N, k=K, t=T, possible_rewards=POSSIBLE_REWARDS, get_reward_probabilities=get_reward_probabilities, min_seed=MIN_SEED, max_seed=MAX_SEED): """ run simulation for many models, with different seeds and return the required arrays for Visualization.py plot functions with vis.DATA list_type argument :param model_type_list: list of ModelType enums, containing the models to run :param model_parameters_list: list of dictionaries containing parameters for the models in model_type_list :param n: number of machines :param k: number of machines to choose each round :param t: number of trials :param possible_rewards: list of possible machine rewards :param get_reward_probabilities: function that returns a list of reward probabilities :param min_seed: lowest seed to run :param max_seed: highest seed to run :return: convergence, reward_sum, distance_from_real_distributions - arrays of tuples, first argument in tuple is the sim.type and the second is the actual data """ convergence_list = np.zeros((len(model_type_list), t - 1)) reward_sums = np.zeros((len(model_type_list), t)) regrets = np.zeros((len(model_type_list), t)) distances = [[] for _ in range(len(model_type_list))] sim_titles = [] for seed in tqdm(range(min_seed, max_seed + 1)): optimal_reward = None cur_rewards = np.zeros_like(reward_sums) for i, model_type, model_parameters in tqdm( zip(np.arange(len(model_type_list)), model_type_list, model_parameters_list)): np.random.seed(seed) sim = s.Simulation(n, k, t, possible_rewards, get_reward_probabilities, model_type, **model_parameters) if seed == min_seed: sim_titles.append(sim.type) sim.run_simulation() convergence_list[i, :] += sim.get_convergence_rate() if sim.type == "Optimal Model": optimal_reward = sim.get_reward_sum() cur_rewards[i, :] += sim.get_reward_sum() reward_sums[i, :] += cur_rewards[i, :] for j, machine in enumerate(sim.machine_list): distances[i].append( vis.fr_metric( machine.reward_probabilities, sim.model.estimated_machine_reward_distribution[j, :])) regrets[...] += optimal_reward - cur_rewards convergence_list /= (max_seed - min_seed + 1) reward_sums /= (max_seed - min_seed + 1) regrets /= (max_seed - min_seed + 1) return [(sim_titles[i], convergence_list[i, :]) for i in range(len(model_type_list))], \ [(sim_titles[i], reward_sums[i, :]) for i in range(len(model_type_list))], \ [(sim_titles[i], distances[i]) for i in range(len(model_type_list))], \ [(sim_titles[i], regrets[i]) for i in range(len(model_type_list))]
def EvaluationNN1(map, stateSpace, P, traj, control, ntraj): average_NN = np.empty((0)) success_percentageNN = np.empty((0)) average_expert = np.empty((0)) for i in range(len(ntraj)): action_space = 5 labels, TrainingSet = ProcessData(traj[0:ntraj[i]][:], control[0:ntraj[i]][:], stateSpace) model = NN1(action_space) model.fit(TrainingSet, labels, epochs=50) predictions, deterministic_policy = MakePredictions(model, stateSpace) T = 100 base = ss.BaseStateIndex(stateSpace, map) TERMINAL_STATE_INDEX = ss.TerminalStateIndex(stateSpace, map) [trajNN, controlNN, flagNN] = sim.StochasticSampleTrajMDP(P, predictions, 1000, T, base, TERMINAL_STATE_INDEX) length_trajNN = np.empty((0)) for j in range(len(trajNN)): length_trajNN = np.append(length_trajNN, len(trajNN[j][:])) average_NN = np.append( average_NN, np.divide(np.sum(length_trajNN), len(length_trajNN))) success_percentageNN = np.append( success_percentageNN, np.divide(np.sum(flagNN), len(length_trajNN))) length_traj = np.empty((0)) for k in range(ntraj[i]): length_traj = np.append(length_traj, len(traj[k][:])) average_expert = np.append( average_expert, np.divide(np.sum(length_traj), len(length_traj))) return average_NN, success_percentageNN, average_expert
def start_times(self): Mp = 1.0 Ms = 1. * 10.**(-6) ap = 2.0 e = 0.5 As = 1.0 Ap = 0.25 omega = 0. i = 0. sim = Simulation.ExoSim(Mp, Ms, ap, e, As, Ap, omega, i, apnd=True) sim.advance() time, bodies = sim.get_results() t = np.array(time) v = np.array([b[1].velocity.x for b in bodies]) test = v[1:] * v[:-1] vt = v[:-1] tt = t[:-1] times = tt[test < 0] if len(times) == 1.: times = np.append(times, sim.period / 2. + times[0]) test2 = vt[test < 0] if test2[0] < 0: return times elif test2[0] > 0: return np.array([times[1], times[0] + sim.period])
def e_8_f(): bnb = Sim.BallAndBeam() max_force = 15 rise_time_theta = 1 beam_mass = bnb.dynamics.beam_mass ball_mass = bnb.dynamics.ball_mass beam_length = bnb.dynamics.beam_length gravity = bnb.dynamics.gravity c_theta = 1 / (beam_length * (ball_mass / 4 + beam_mass / 3)) natural_frequency_theta = np.pi / (2 * rise_time_theta * (1 - damping_ratio**2)**(1/2)) proportional_gain_theta = natural_frequency_theta**2 / c_theta derivative_gain_theta = 2 * damping_ratio * natural_frequency_theta / c_theta rise_time_z = 10 * rise_time_theta natural_frequency_z = np.pi / (2 * rise_time_z * (1 - damping_ratio**2)**(1/2)) proportional_gain_z = natural_frequency_z**2 / -gravity derivative_gain_z = 2 * damping_ratio * natural_frequency_z / -gravity bnb.add_controller(PD.BallAndBeam, proportional_gain_z, derivative_gain_z, proportional_gain_theta, derivative_gain_theta, max_force) # a square wave with magnitude 0.25±0.15 meters and frequency 0.01 Hz requests = sg.generator(sg.constant, amplitude=0.0, t_step=bnb.seconds_per_sim_step, t_final=10) handle = bnb.view_animation(requests) Sim.Animations.plt.waitforbuttonpress() Sim.Animations.plt.close() return handle
def load_default(self): self.params = np.array([ 51.9957, 81, 3.7998e-7, -0.204599, 0, 328.93, 88.8624, 11.7176, 1182.19, 2026.27, 7.14503, 0, 0, 89.1588, 87.5647, 0.278594 ]) energy = self.params[0] etalimit = self.params[1] / 180.0 * np.pi pos = self.params[2:5] orien = R.EulerZXZ2Mat(self.params[5:8] / 180.0 * np.pi) # strain=np.array([ 0.00228725, -0.00046991, -0.00013953, -0.0001595 , 0.00143135, # 0.00070123, 0.00089509, 0.00438468, 0.0014488 ])+np.array([ -1.66347153e-03, 9.19749189e-04, 8.19250063e-05, # -1.33069566e-04, -1.18838324e-03, -2.40553445e-04, # 1.67946465e-03, -8.97547675e-03, -8.87805809e-04]) strain = np.zeros(9) strain = strain.reshape((3, 3)) + np.eye(3) orien = strain.dot(orien) Det = G.Detector() Det.Move(self.params[8], self.params[9], self.params[10:13], R.EulerZXZ2Mat(self.params[13:16] / 180.0 * np.pi)) self._xrd.Setup(energy, etalimit, pos, orien, Det) self._xrd.Simulate() self.choosePeakID.setMinimum(0) self.choosePeakID.setMaximum(len(self._xrd.Peaks) - 1) try: self.res = pickle.load(open('tmp_res.pickle', 'r')) except: self.res = [None] * len(self._xrd.Peaks) self.l0.setText('Setup finished')
def __init__(self): self._sample = G.CrystalStr('Ti7') self._sample.getRecipVec() self._sample.getGs(11) self._Peaks = None self._Gs = None self._PeaksInfo = None
def pull_data(run, test_x, test_y, num_round): yhats = [] yhhats = [] MSEs = [] xhats = [] for i in range(0, len(run)): method = run[i] print(run[i]) res_file = os.path.join(data_dir, method + "_results.dat") DR_model = Dim_Red.load_DR(method, data_dir) X_0 = DR_model.Encode_X(test_x) #add predicted y (yhat) to list of yhats yhats = [*yhats, DR_model.Pred_Y(X_0)[:, 0:1]] #convert DR to x for xhat xhat = DR_model.Decode_X(X_0) xhats = [*xhats, xhat] #add simulated y from xhat to list of yhhats yhhats = [*yhhats, Simulation.Evaluate_yhhat(test_x, xhat)] #add MSE stats for PLS MSEs = [ *MSEs, generate_stats(test_y, yhats[-1], yhhats[-1][0], yhhats[-1][1], test_x, xhats[-1], num_round) ] print(MSEs) return yhats, xhats, yhhats, MSEs
def get_sample(traj_dist,experiment_id): #Start a simulation and do the stuff functions = {} args = {} real_fun(functions) states = np.genfromtxt('/home/elias/[email protected]/_Winter2015/CSC494/Trajectories/Traj'+str(experiment_id+1)+'state.txt', delimiter=',',dtype=np.float32) actions = np.genfromtxt('/home/elias/[email protected]/_Winter2015/CSC494/Trajectories/Traj'+str(experiment_id+1)+'action.txt' ,dtype=np.float32) T,d = states.shape #Create simulation Sim = Simulation(function=functions["Traj{}".format(str(experiment_id+1))], args=[[0,0,3],0]) Sim.restart() f = open('/home/elias/[email protected]/_Winter2015/CSC494/Trajectories/Traj{}pred.txt'.format(experiment_id+1),'w+') r = open('/home/elias/[email protected]/_Winter2015/CSC494/Trajectories/Traj{}residuals.txt'.format(experiment_id+1),'w+') for timestep in range(T): states[timestep,:] = normalize(state_norms[experiment_id],controller.getDif(Sim.cid,Sim.copter,Sim.target)) old = actions[timestep,:].copy() actions[timestep,:] = denormalize(action_norms[experiment_id], get_action(traj_dist,states[timestep,:],timestep)[0]) Sim.forward(actions[timestep,:].tolist()) f.write(str(actions[timestep,:])+'\n') r.write(str(old-actions[timestep,:])+'\n') #Sim.forward() Sim.sync() print(vrep.simxStopSimulation(Sim.cid,vrep.simx_opmode_oneshot_wait)) f.close() r.close() return states,actions
def updateHandRanking(self): if(self.cardsChanged == True): if(self.numBoardCards == 0): #preflop self.pokeriniRank = Pokerini.pokeriniLookup(self.myHand, pokeriniDict) self.calculatePreflopBetLimit() if(self.numBoardCards >= 3):#postflop #self.simulationWinChance = Simulation.simulate(self.myHand, self.boardCards, self.numBoardCards, 200, handEvalDict, translationDict) self.simulationWinChance = Simulation.simulateOld(self.myHand, self.boardCards, self.numBoardCards, self.numSimulations) self.cardsChanged = False
class Simulation_Control(object): """ Controls the simulation, either step by step, or in a continuous mode. """ def __init__(self, SimulationStep): self.OneStep = SimulationStep # function that launches one step of the simulation ## Status of the simulation programme self.simulation = None # name of the simulation thread self.busy = 0 # busy meter to avoid fatal parallelism between simulation and display #self.previous_Disp_period = self.Disp_period = 1 # display period def RunButtonClick(self, event=None): self.simulation_steady_mode = True # Continuous functioning self.Simulation_resume() def PauseButtonClick(self,event=None): self.Simulation_stop() def Simulation_stop(self): if self.simulation is not None: self.simulation.stop() if self.simulation.isAlive(): #print 'strange...' #sleep(2) self.simulation = None # well... return False self.simulation = None return True def Simulation_launch(self): if self.busy > 0: return False # A new simulation thread is created if self.Simulation_stop(): self.simulation = Simulation(self.OneStep) self.simulation.start() return True def Simulation_resume(self): return self.Simulation_launch()
def startStandalone(): import Simulation print('MagneticPendulum -Standalone') print('--------------------------------------------') print('Image resolution: {0}x{0} Output: {1}'.format(Parameter.RESOLUTION, Parameter.IMG_NAME)) print('Working with {0} sub-processes in total.'.format(Parameter.MAX_PROCESSES)) print('============================================') start = time.time() im= Image.new('RGB', (Parameter.RESOLUTION, Parameter.RESOLUTION)) data = [] pixel = [] + [0]*(Parameter.RESOLUTION**2) manager = Manager() coordinates = manager.Queue() values = manager.Queue() workerRunning = manager.Value('i', 0) Simulation.createAllCoordinates(coordinates, data) while workerRunning.get() < Parameter.MAX_PROCESSES: Process(target=Simulation.workerThread,args=(coordinates, workerRunning, values)).start() time.sleep(1) while workerRunning.value > 0: Simulation.drawImage(im, data, pixel, values) time.sleep(Parameter.REPAINT) Simulation.drawImage(im, data, pixel, values) print('Image succeeded. Time consumed: {0:.2f}s'.format((time.time() - start))) print('Exiting...') sys.exit(0)
def startServer(): freeze_support() print('MagneticPendulum -Cluster/Server') print('--------------------------------------------') print('Image resolution: {0}x{0} Output: {1}'.format(Parameter.RESOLUTION, Parameter.IMG_NAME)) print('============================================') print('Now waiting to have some working clients.') import Simulation manager = ClusterQueueManager() data = [] coordinates = manager.getCoordinates() values = manager.getValues() im= Image.new('RGB', (Parameter.RESOLUTION, Parameter.RESOLUTION)) pixel = [] + [0]*(Parameter.RESOLUTION**2) Simulation.createAllCoordinates(coordinates, data) start = time.time() manager.start() while not coordinates.empty(): while manager.getRunningClients() > 0: if not values.empty(): Simulation.drawImage(im, data, pixel, values) time.sleep(Parameter.REPAINT) time.sleep(.5) print("Coordinates are now completely distributed.") while manager.getRunningClients() > 0: time.sleep(Parameter.REPAINT) print('Waiting for {0} clients to be done'.format(manager.getRunningClients())) Simulation.drawImage(im, data, pixel, values) print('Image succeeded. Time consumed: {0:.2f}s'.format((time.time() - start))) print('Exiting...') sys.exit(0)
def run(self): while 1: try: # Waiting for client... self.__mainLogger.debug("CommandListener - Waiting on accept...") conn, (addr, port) = self.__sock.accept() self.__mainLogger.debug('CommandListener - Received command from (' + addr + ', ' + str(port) + ')') if addr not in cl.TRUSTED_CLIENTS: self.__mainLogger.error( 'CommandListener - Received connection request from untrusted client (' + addr + ', ' + str( port) + ')') continue # Receive one message self.__mainLogger.debug('CommandListener - Receiving command...') recvOptions = recvOneMessage(conn) self.__mainLogger.debug('CommandListener - Received ' + str(recvOptions)) if recvOptions.kill: # Received killing command -> Stop everything self.__thymioController.killRequest() if self.__simulation: self.__simulation.stop() break elif recvOptions.start and (not self.__simulation or self.__simulation.isStopped()): # Adding experiment number to pr.EXPERIMENT_NAME experiment_name = pr.EXPERIMENT_NAME + "_" + str(self.__counter) self.__counter += 1 # Received start request AND simulation is not running -> Start a new simulation self.__mainLogger.debug("CommandListener - Starting simulation...") self.__simulation = Simulation(self.__thymioController, recvOptions.debug, experiment_name) self.__thymioController.setSimulation(self.__simulation) self.__simulation.start() elif recvOptions.stop and self.__simulation and not self.__simulation.isStopped(): # TODO: Stop properly # Received stop request AND simulation is up and running -> Stop the simulation self.__mainLogger.debug("CommandListener - Stopping simulation...") self.__simulation.stop() self.__simulation = None elif recvOptions.stopthymio: self.__mainLogger.debug("CommandListener - Stopping Thymio...") self.__thymioController.stopThymio() except: self.__mainLogger.critical( 'Error in CommandsListener: ' + str(sys.exc_info()[0]) + ' - ' + traceback.format_exc()) self.__mainLogger.debug('CommandListener - KILLED -> Exiting...')
def setup_cpus(options): # By default, set workload to path of user-specified binary workloads = options.cmd numThreads = 1 if options.cpu_type == "detailed" or options.cpu_type == "inorder": # check for SMT workload workloads = options.cmd.split(";") if len(workloads) > 1: process = [] smt_idx = 0 inputs = [] outputs = [] errouts = [] if options.input != "": inputs = options.input.split(";") if options.output != "": outputs = options.output.split(";") if options.errout != "": errouts = options.errout.split(";") for wrkld in workloads: smt_process = LiveProcess() smt_process.executable = wrkld smt_process.cmd = wrkld + " " + options.options if inputs and inputs[smt_idx]: smt_process.input = inputs[smt_idx] if outputs and outputs[smt_idx]: smt_process.output = outputs[smt_idx] if errouts and errouts[smt_idx]: smt_process.errout = errouts[smt_idx] process += [smt_process] smt_idx += 1 numThreads = len(workloads) (CPUClass, test_mem_mode, FutureClass) = Simulation.setCPUClass(options) CPUClass.clock = options.clock CPUClass.numThreads = numThreads return (CPUClass, test_mem_mode, FutureClass)
## p3 = 10 ## p4 = .1 ## p5 = 1000. #### p1 = .001 ## p1 = 0.000 #### p2 = .007 #### p2 = 0.007 ## p2 = 0.0075 ## p3 = 10 ## p4 = 5E-4 ## p5 = 10.0 #Now make a new simulation sim = Simulation(sim_id, sim_base_path, ts, te, dt) #add some gradients ## #from Van Winkle et al 2012 for 02 ## D = 1.7e-9 / (1e-12) #um^2/sec ## consump_rate = (4.0e-17)#*(10**6) mols/cell/sec #umols/cell/sec ## #This value later gets normalized using the ## #set the outside concentration ## outside_c = 1.04e-4*10**6 #(umol/L) or uM #from War-tenberg et al., 2001 D = 10.0 # um^2/sec consump_rate = 2.0e-20 #mol/cell/sec production_rate = 2.0e-20 ## outside_c = .1 #umol/L or uM
parser = optparse.OptionParser() Options.addCommonOptions(parser) Options.addFSOptions(parser) # Add the ruby specific and protocol specific options if '--ruby' in sys.argv: Ruby.define_options(parser) (options, args) = parser.parse_args() if args: print "Error: script doesn't take any positional arguments" sys.exit(1) # system under test can be any CPU (TestCPUClass, test_mem_mode, FutureClass) = Simulation.setCPUClass(options) # Match the memories with the CPUs, based on the options for the test system TestMemClass = Simulation.setMemClass(options) if options.benchmark: try: bm = Benchmarks[options.benchmark] except KeyError: print "Error benchmark %s has not been defined." % options.benchmark print "Valid benchmarks are: %s" % DefinedBenchmarks sys.exit(1) else: if options.dual: bm = [SysConfig(disk=options.disk_image, rootdev=options.root_device, mem=options.mem_size, os_type=options.os_type),
# instantiate an EtherSwitch switch = EtherSwitch() # instantiate distEtherLinks to connect switch ports # to other gem5 instances switch.portlink = [DistEtherLink(speed = options.ethernet_linkspeed, delay = options.ethernet_linkdelay, dist_rank = options.dist_rank, dist_size = options.dist_size, server_name = options.dist_server_name, server_port = options.dist_server_port, sync_start = options.dist_sync_start, sync_repeat = options.dist_sync_repeat, is_switch = True, num_nodes = options.dist_size) for i in xrange(options.dist_size)] for (i, link) in enumerate(switch.portlink): link.int0 = switch.interface[i] return switch # Add options parser = optparse.OptionParser() Options.addCommonOptions(parser) Options.addFSOptions(parser) (options, args) = parser.parse_args() system = build_switch(options) root = Root(full_system = True, system = system) Simulation.run(options, root, None, None)
# Copyright © 2016 Jalel Benerrami. All rights reserved. # from /Users/jalelbenerrami/Desktop/project_Python/Point2D import* # from /Users/jalelbenerrami/Desktop/project_Python/Simulation import* from Point2D import * from Simulation import * # # Run programm by choosing parameters into the terminal # # Number of random points n = input("\nEnter the number of points you want to generate : ") n = int(n) print(n, "\n") # Choose a strategy s = input("Choose a strategy : " ) s = int(s) print(s, "\n") # Create a simulation with given number of points Sim = Simulation(n) # Execute the created simulation Sim.execute(s) # Display the information about executed simulation print(Sim, "\n")
if buildEnv['TARGET_ISA'] == "alpha": system = makeLinuxAlphaRubySystem(test_mem_mode, bm[0]) elif buildEnv['TARGET_ISA'] == "x86": system = makeLinuxX86System(test_mem_mode, options.num_cpus, bm[0], True) setWorkCountOptions(system, options) else: fatal("incapable of building non-alpha or non-x86 full system!") system.ruby = Ruby.create_system(options, system, system.piobus, system._dma_devices) system.cpu = [CPUClass(cpu_id=i) for i in xrange(options.num_cpus)] for (i, cpu) in enumerate(system.cpu): # # Tie the cpu ports to the correct ruby system ports # cpu.icache_port = system.ruby._cpu_ruby_ports[i].port cpu.dcache_port = system.ruby._cpu_ruby_ports[i].port if buildEnv['TARGET_ISA'] == "x86": cpu.itb.walker.port = system.ruby._cpu_ruby_ports[i].port cpu.dtb.walker.port = system.ruby._cpu_ruby_ports[i].port cpu.interrupts.pio = system.piobus.port cpu.interrupts.int_port = system.piobus.port root = Root(system = system) Simulation.run(options, root, system, FutureClass)
from Simulation import * default = raw_input("Welcome. \n To use default settings, press y, else, press any other key" ) if default == 'y': print "Running simulator with default settings" run = Simulation(500,500,400,400,2) else: x = raw_input("Enter quadcopter start x coordinate: ") y = raw_input("Enter quadcopter start y coordinate: ") tx = raw_input("Enter target x coordinate: ") ty = raw_input("Enter target y coordinate: ") difficulty = raw_input("Enter number of obstacles: ") run = Simulation(int(x),int(y),int(tx),int(ty),int(difficulty)) run.render()
# diffusion testing IM = InternalModel() IM.add_node('a') # no degradation IM2 = InternalModel() IM2.add_node('a','linear',params=[0.5]) IM2.add_node('b','linear',params=[1]) eid = IM2.add_edge('b','b','hill_activ',params=[1,1,2]) IM2.add_edge('a',eid,'lin_activ',is_mod=True,mod_type='mult',params=[5]) cell1 = Cell([0]) cell2 = Cell([1]) cell3 = Cell([3]) sim = Simulation() sim.add_cell(cell1) sim.add_cell(cell2) sim.add_cell(cell3) im_id = sim.add_internal_model(IM) im_id2 = sim.add_internal_model(IM2) connections = np.array([[True,True,False],[True,True,True],[False,True,True]]) sim.set_internal_model([0,1],im_id) sim.set_internal_model([2],im_id2) sim.add_interaction('a','a','diffusion',connections,params=[1]) sim.set_initial_conditions([0],{'a':0}) sim.set_initial_conditions([1],{'a':6})
app, options.spec_input)) multiprocesses.append(workload.makeLiveProcess()) except: print >>sys.stderr, "Unable to find workload for %s: %s" % ( buildEnv['TARGET_ISA'], app) sys.exit(1) elif options.cmd: multiprocesses, numThreads = get_processes(options) else: print >> sys.stderr, "No workload specified. Exiting!\n" sys.exit(1) #JON_print_members(options, "OPTIONS", 156) (CPUClass, test_mem_mode, FutureClass) = Simulation.setCPUClass(options) CPUClass.numThreads = numThreads # Check -- do not allow SMT with multiple CPUs if options.smt and options.num_cpus > 1: fatal("You cannot use SMT with multiple CPUs!") np = options.num_cpus system = System(cpu = [CPUClass(cpu_id=i) for i in xrange(np)], mem_mode = test_mem_mode, mem_ranges = [AddrRange(options.mem_size)], cache_line_size = options.cacheline_size) # Create a top-level voltage domain system.voltage_domain = VoltageDomain(voltage = options.sys_voltage)
IM.add_edge('sp',uy_edge,'hill_inactiv',is_mod=True,mod_type='mult',params=[1.0,1.0,0.145,20]) # mystery species m things # u -> m IM.add_edge('u','m','hill_activ',params=[1.0/Tm,4e-6,6]) # m -| yan IM.add_edge('m',uy_edge,'hill_inactiv',is_mod=True,mod_type='mult',params=[1.0,1.0,0.7,3]) # need to make some cells # the 1d case is easy: # in our 'lattice', all the cells are distance 1 apart NCells = 60 cells = [Cell([x]) for x in np.linspace(1,NCells,NCells)] # add these cells to the simulation sim = Simulation() for i in xrange(NCells): sim.add_cell(cells[i]) im_id = sim.add_internal_model(IM) # set all cells to have the same internal model sim.set_internal_model(range(NCells),im_id) # set boundary conditions before setting intercellular interactions sim.set_boundary_conditions([0],'ref_on') # cells adjacent to one another are connected # for diffusion we include main diagonal # equivalent to 3 wide diagonal diff_connections = (np.eye(NCells,k=-1) + np.eye(NCells,k=0) + np.eye(NCells,k=1)) > 0
# i: left -> right # j: bottom -> top centers = np.empty((NCells,2)) # a center for each cell for i in xrange(ncolumns): for j in xrange(nrows): c = np.array([float(i) + 0.5*(j % 2),(np.sqrt(3)/2)*float(j)]) centers[i + j*ncolumns,:] = c # can add noise to centers # centers += np.random.normal(0.0,0.15,(NCells,2)) # place each cell at these vertices cells = [Cell(c) for c in centers] # add these cells to the simulation sim = Simulation() for i in xrange(NCells): sim.add_cell(cells[i]) im_id = sim.add_internal_model(IM) # set all cells to have the same internal model sim.set_internal_model(range(NCells),im_id) # set up reflecting boundary conditions at bottom edge # sim.set_boundary_conditions(range(ncolumns),'ref_on') sim.set_boundary_conditions(range((nrows-1)*ncolumns,nrows*ncolumns),'abs_on') # need to figure out which cells are connect to which connections = np.zeros((NCells,NCells)) > 0 # default boolean false array tri = Delaunay(centers)
for wrkld in workloads: smt_process = LiveProcess() smt_process.executable = wrkld smt_process.cmd = wrkld + " " + options.options if inputs and inputs[smt_idx]: smt_process.input = inputs[smt_idx] if outputs and outputs[smt_idx]: smt_process.output = outputs[smt_idx] if errouts and errouts[smt_idx]: smt_process.errout = errouts[smt_idx] process += [smt_process, ] smt_idx += 1 numThreads = len(workloads) (CPUClass, test_mem_mode, FutureClass) = Simulation.setCPUClass(options) CPUClass.clock = options.clock CPUClass.numThreads = numThreads; system = System(cpu = [CPUClass(cpu_id=i) for i in xrange(np)], physmem = DRAM, membus = RR_CoherentBus(num_pids=options.numpids), #membus = CoherentBus(), mem_mode = test_mem_mode, numPids = options.numpids, fast_forward = (options.fast_forward != None), fixAddr = options.fixaddr) # Sanity check if options.fastmem and (options.caches or options.l2cache): fatal("You cannot use fastmem in combination with caches!")
# i: left -> right # j: bottom -> top centers = np.empty((NCells,2)) # a center for each cell for i in xrange(ncolumns): for j in xrange(nrows): c = np.array([float(i) + 0.5*(j % 2),(np.sqrt(3)/2)*float(j)]) centers[i + j*ncolumns,:] = c # can add noise to centers # centers += np.random.normal(0.0,0.15,(NCells,2)) # place each cell at these vertices cells = [Cell(c) for c in centers] # add these cells to the simulation sim = Simulation() for i in xrange(NCells): sim.add_cell(cells[i]) im_id = sim.add_internal_model(IM) # set all cells to have the same internal model sim.set_internal_model(range(NCells),im_id) # set up reflecting boundary conditions at bottom edge # sim.set_boundary_conditions(range(ncolumns),'ref_on') # sim.set_boundary_conditions(range((nrows-1)*ncolumns,nrows*ncolumns),'abs_on') # sim.set_boundary_conditions(range(ncolumns),'ref_on') # sim.set_boundary_conditions(range((nrows-1)*ncolumns,nrows*ncolumns),'ref_on')
else: rents_paid.append(rent) pos = (pos + moves_forward) % Simulation.no_of_squares # print moves_forward # print "Rent paid = ", rent # print "Current position = ", Simulation.square_names[pos], "\n" # Code for dice roll # If not IN JAIL, do a normal move if pos != -1: # print "Starting position = ", Simulation.square_names[pos] doubles, triples, mr_monopoly, bus_ticket, moves_forward = Simulation.roll_dice() square_ix = (pos + moves_forward) % Simulation.no_of_squares square_name = Simulation.square_names[(pos + moves_forward) % Simulation.no_of_squares] square_type = Simulation.square_type[square_ix] if square_type == 'RR': rent = Simulation.rent_value_3[square_ix] elif square_type == 'UY': rent = Simulation.rent_value_2[square_ix] / 10000 * moves_forward else: rent = Simulation.rent_value_S[square_ix] if rent < 0:
else: exec("workload = %s(buildEnv['TARGET_ISA', 'linux', '%s')" % ( app, options.spec_input)) multiprocesses.append(workload.makeLiveProcess()) except: print >>sys.stderr, "Unable to find workload for %s: %s" % ( buildEnv['TARGET_ISA'], app) sys.exit(1) elif options.cmd: multiprocesses, numThreads = get_processes(options) else: print >> sys.stderr, "No workload specified. Exiting!\n" sys.exit(1) (CPUClass, test_mem_mode, FutureClass) = Simulation.setCPUClass(options) CPUClass.numThreads = numThreads # Check -- do not allow SMT with multiple CPUs if options.smt and options.num_cpus > 1: fatal("You cannot use SMT with multiple CPUs!") np = options.num_cpus system = System(cpu = [CPUClass(cpu_id=i) for i in xrange(np)], mem_mode = test_mem_mode, mem_ranges = [AddrRange(options.mem_size)], cache_line_size = options.cacheline_size) # Create a top-level voltage domain system.voltage_domain = VoltageDomain(voltage = options.sys_voltage)
def main(start_day=1, end_day=80, extend_days=0, price_per_kg=0.25, food_cost=0.35, facility_cost=2.89, r_value=0.00, cycles_per_year=2, restriction=0.05): sim = Simulation(start_day, end_day, extend_days, price_per_kg, food_cost, facility_cost, r_value, cycles_per_year, restriction) sim.simulate() sim.print_end_costs() return sim
execfile(os.path.join(config_root, "common", "Options.py")) (options, args) = parser.parse_args() if args: print "Error: script doesn't take any positional arguments" sys.exit(1) # driver system CPU is always simple... note this is an assignment of # a class, not an instance. DriveCPUClass = AtomicSimpleCPU drive_mem_mode = 'atomic' # system under test can be any CPU (TestCPUClass, test_mem_mode, FutureClass) = Simulation.setCPUClass(options) TestCPUClass.clock = '2GHz' DriveCPUClass.clock = '2GHz' if options.benchmark: try: bm = Benchmarks[options.benchmark] except KeyError: print "Error benchmark %s has not been defined." % options.benchmark print "Valid benchmarks are: %s" % DefinedBenchmarks sys.exit(1) else: if options.dual: bm = [SysConfig(), SysConfig()] else:
if options.benchmark: try: bm = Benchmarks[options.benchmark] except KeyError: print "Error benchmark %s has not been defined." % options.benchmark print "Valid benchmarks are: %s" % DefinedBenchmarks sys.exit(1) else: bm = [SysConfig(disk=options.disk_image, mem=options.mem_size)] # Check for timing mode because ruby does not support atomic accesses if not (options.cpu_type == "detailed" or options.cpu_type == "timing"): print >> sys.stderr, "Ruby requires TimingSimpleCPU or O3CPU!!" sys.exit(1) (CPUClass, test_mem_mode, FutureClass) = Simulation.setCPUClass(options) CPUClass.clock = options.clock if buildEnv['TARGET_ISA'] == "alpha": system = makeLinuxAlphaRubySystem(test_mem_mode, bm[0]) elif buildEnv['TARGET_ISA'] == "x86": system = makeLinuxX86System(test_mem_mode, options.num_cpus, bm[0], True) #system = addExternalDisk(system) Simulation.setWorkCountOptions(system, options) else: fatal("incapable of building non-alpha or non-x86 full system!") if options.mem_size: bm[0]=SysConfig(disk=bm[0].disk, mem=options.mem_size,script=bm[0].script()) if options.kernel is not None: system.kernel = binary(options.kernel)
from Simulation import * from function_names import * import numpy as np from numpy import * functions = {} args = {} real_fun(functions) states = genfromtxt('/home/elias/[email protected]/_Winter2015/CSC494/Trajectories/Traj7state.txt', delimiter=',',dtype=float32) actions = genfromtxt('/home/elias/[email protected]/_Winter2015/CSC494/Trajectories/Traj7action.txt' ,dtype=float32) T,d = states.shape #Create simulation Sim = Simulation(function=functions["Traj7"], args=[[0,0,3],0]) Sim.restart() for x in range(T): Sim.forward(actions[x,:].tolist()) #Sim.forward() print(controller.getDif(Sim.cid,Sim.copter,Sim.target)) print(actions[x,:]) raw_input() Sim.sync()