def main(): """ Relaxed Checkpoint Simulator simulates the execution of an application given the job parameters required """ MAX_JOBS = 10 RUNTIME = 50 * HOUR OCI_LIST = [ 1.2 * HOUR, 1.7 * HOUR, 2.1 * HOUR, 2.8 * HOUR, 3.3 * HOUR, 4.7 * HOUR ] BETA_LIST = [ 0.1 * HOUR, 0.2 * HOUR, 0.25 * HOUR, 0.3 * HOUR, 0.35 * HOUR, 0.4 * HOUR ] # Ask for Input print("Relaxed Checkpointing Simulator") print("Configurations. \n 1) Maximum number of jobs:", MAX_JOBS, "\n 2) Total compute time :", RUNTIME, "seconds\n") system = Machine() simulator_properties = SimulatorProperties(RUNTIME) simulator = Simulator(system, simulator_properties) initialize_jobs(system, OCI_LIST, BETA_LIST, MAX_JOBS) simulator.__do_simulation__()
def runCoherenceFadingTest(): experimentSpec = { 'packetGen': {'type': 'random', 'length': 300}, 'code': {'type': 'spinal', 'puncturing': {'type': '8-way-v2', 'numLastCodeStep': 2}, 'hash': 'one-at-a-time', 'bitsPerSymbol': 10, 'k': 3}, 'map': {'type': 'soft', 'bitsPerSymbol': 10}, 'channel': {'type': 'coherence-fading', 'interval': 10, 'SNR_dB': 10}, 'demap': {'type': 'null'}, 'decoder': {'type': 'regular', 'beamWidth': 16, 'maxPasses': 48*8}, 'detector': {'type': 'oracle'}, 'protocol': {'type': 'sequential', 'maxPasses': 48*8}, 'statistics': {'type': 'errors'} } runner = Simulator(1) res = runner.runExperiment(experimentSpec, numpy.random.RandomState().tomaxint(4), 100) print str(res)
def runRaptorTest(): experimentSpec = { 'packetGen': {'type': 'random', 'length': 9500}, 'code': {'type': 'raptor'}, 'map': {'type': 'QAM', 'bitsPerSymbol': 6}, 'channel': {'type': 'AWGN_c', 'SNR_dB': 20}, 'demap': {'type': 'QAM', 'useApprox': True}, 'decoder': {'type': 'raptor', 'numIter': 40}, 'detector': {'type': 'oracle'}, 'protocol': {'type': 'rate-approx', 'maxSymbols': 11500, 'delta': 0.97, 'minSymbols':1280}, 'statistics': {'type': 'errors'} } runner = Simulator(2) res = runner.runExperiment(experimentSpec, numpy.random.RandomState().tomaxint(4), 3) print str(res)
def runBscLDPCTest(): experimentSpec = { 'packetGen': {'type': 'random', 'length': 648*2/3}, 'code': {'type': 'ldpc', 'n': 648, 'rate': (2,3), 'bitsPerSymbol': 1}, 'map': {'type': 'linear', 'bitsPerSymbol': 1, 'precisionBits': 1}, 'channel': {'type': 'BSC', 'flipProb': 0.04}, 'demap': {'type': 'BSC', 'flipProb': 0.04}, 'decoder': {'type': 'ldpc-float-bp', 'numIter': 40}, 'detector': {'type': 'oracle'}, 'protocol': {'type': 'one-try', 'numSymbols': 648}, 'statistics': {'type': 'errors'} } runner = Simulator(0) res = runner.runExperiment(experimentSpec, numpy.random.RandomState().tomaxint(4), 100) print str(res)
def runParallelKTest(): experimentSpec = { 'packetGen': {'type': 'random', 'length': 300}, 'code': {'type': 'spinal', 'puncturing': {'type': '8-way-v2', 'numLastCodeStep': 2}, 'hash': 'one-at-a-time', 'bitsPerSymbol': 10, 'k': 3}, 'map': {'type': 'linear', 'bitsPerSymbol': 10, 'precisionBits': 14}, 'channel': {'type': 'AWGN', 'SNR_dB': 10}, 'demap': {'type': 'null'}, 'decoder': {'type': 'parallel', 'alpha': 4, 'beta': 64, 'maxPasses': 48*8}, 'detector': {'type': 'oracle'}, 'protocol': {'type': 'sequential', 'maxPasses': 48*8}, 'statistics': {'type': 'errors'} } runner = Simulator(1) res = runner.runExperiment(experimentSpec, numpy.random.RandomState().tomaxint(4), 10) print str(res)
def runFirstErrorStatisticsTest(): experimentSpec = { 'packetGen': {'type': 'random', 'length': 256}, 'code': {'type': 'spinal', 'puncturing': {'type': '8-way-v2', 'numLastCodeStep': 2}, 'hash': 'one-at-a-time', 'bitsPerSymbol': 10, 'k': 4}, 'map': {'type': 'linear', 'bitsPerSymbol': 10, 'precisionBits': 14}, 'channel': {'type': 'AWGN', 'SNR_dB': -2}, 'demap': {'type': 'null'}, 'decoder': {'type': 'regular', 'beamWidth': 100, 'maxPasses': 48*8}, 'detector': {'type': 'oracle'}, 'protocol': {'type': 'one-try', 'numSymbols': 256*2}, 'statistics': {'type': 'first-error'} } runner = Simulator(1) for i in xrange(10): res = runner.runExperiment(experimentSpec, numpy.random.RandomState().tomaxint(4), 1) print str(res), print
def runItppQamLDPCTest(): experimentSpec = { 'packetGen': {'type': 'random', 'length': 648*5/6}, 'code': {'type': 'ldpc', 'n': 648, 'rate': (5,6), 'bitsPerSymbol': 1}, 'map': {'type': 'QAM', 'bitsPerSymbol': 6}, 'channel': {'type': 'AWGN_c', 'SNR_dB': 17.8}, 'demap': {'type': 'QAM'}, 'decoder': {'type': 'ldpc-float-bp', 'numIter': 40}, 'detector': {'type': 'oracle'}, 'protocol': {'type': 'one-try', 'numSymbols': 648/6}, 'statistics': {'type': 'errors'} } runner = Simulator(0) res = runner.runExperiment(experimentSpec, numpy.random.RandomState().tomaxint(4), 100) print str(res)
def doT1nT2n(self,Community_Coordinate): nPnt= 10 #1000 nLink= 11 #40 tests="" s=Simulator(nPnt) s.genPoints(Community_Coordinate) #s.genRandomLinks(nLink*nPnt) return s.pAll ## f2= open('doT1nT2n2.txt', 'w') ## for i in range(0,100): ## for j in range(0,i+1): ## nSteps=self.MutiTimesNoGen(s,1,i,j,0.5,0.2) ## print str(i)+"\t"+ str(j) +"\t"+str(nSteps) ## f2.write(str(i)+"\t"+ str(j) +"\t"+str(nSteps)+"\n") ## tests=tests+str(nSteps)+"\t" ## for j in range(i,101): ## tests=tests+"0\t" ## tests=tests+("\n") ## f = open('doT1nT2n.txt', 'w') ## f.write(tests) return
def runItppQamLDPCTest(): experimentSpec = { 'packetGen': {'type': 'random', 'length': 648*5/6}, 'code': {'type': 'ldpc', 'n': 648, 'rate': (5,6), 'bitsPerSymbol': 1}, 'map': {'type': 'QAM', 'bitsPerSymbol': 6}, 'channel': {'type': 'AWGN_c', 'SNR_dB': 17.8}, 'demap': {'type': 'QAM'}, 'decoder': {'type': 'ldpc-float-bp', 'numIter': 40}, 'detector': {'type': 'oracle'}, 'protocol': {'type': 'one-try', 'numSymbols': 648/6}, 'statistics': {'type': 'errors'} } runner = Simulator(0) res = runner.runExperiment(experimentSpec, numpy.random.RandomState().tomaxint(4) % 4294967295, 100) print str(res)
def main(): import this root = tkinter.Tk() root.title('Brownian Motion Simulation') simulator = Simulator(root, 50) simulator.simulate(300, 0.3) root.mainloop()
def main(): cfg.load() cfg.print_all() hexes = [ Person(i=0, j=0), Person(i=0, j=-5), Person(i=5, j=-5), Person(i=-4, j=5) ] # person = Person(i=0, j=0) # for i in range(10): # print(person.go_brr(hexes).name) # pop = Population() # pop.get_by_id(4).state = State.Deceased # pop.get_by_id(5).state = State.Recovered # print(pop) sim = Simulator() # print(sim.population) # d = Drawer.Drawer() # d.draw_hexes(sim.plane.hexagons, hexes) # print(util.get_surrounding(hexes[1].coordinates, sim.plane.hexagons)) # sim.tick() # sim.tick() for i in range(10): sim.tick()
def runLDPCTest(): experimentSpec = { 'packetGen': {'type': 'random', 'length': 648*5/6}, 'code': {'type': 'ldpc', 'n': 648, 'rate': (5,6), 'bitsPerSymbol': 3}, 'map': {'type': 'gray', 'bitsPerSymbol': 3, 'precisionBits': 14}, 'channel': {'type': 'AWGN', 'SNR_dB': 17.8}, 'demap': {'type': 'ml-gray', 'SNR_dB': 17.8}, 'decoder': {'type': 'ldpc-float-bp', 'numIter': 40}, 'detector': {'type': 'oracle'}, 'protocol': {'type': 'one-try', 'numSymbols': 648/3}, 'statistics': {'type': 'errors'} } runner = Simulator(0) res = runner.runExperiment(experimentSpec, numpy.random.RandomState().randint(0,4294967295,4), 100) print str(res)
def runTest(): experimentSpec = { 'packetGen': {'type': 'random', 'length': 300}, 'code': {'type': 'spinal', 'puncturing': {'type': '8-way-v2', 'numLastCodeStep': 2}, 'hash': 'one-at-a-time', 'bitsPerSymbol': 10, 'k': 3}, 'map': {'type': 'linear', 'bitsPerSymbol': 10, 'precisionBits': 14}, 'channel': {'type': 'AWGN', 'SNR_dB': 10}, 'demap': {'type': 'null'}, 'decoder': {'type': 'regular', 'beamWidth': 16, 'maxPasses': 48*8}, 'detector': {'type': 'oracle'}, 'protocol': {'type': 'sequential', 'maxPasses': 48*8}, 'statistics': {'type': 'errors'} } runner = Simulator(2) logging.debug('runtest begin'); res = runner.runExperiment(experimentSpec, numpy.random.RandomState().randint(0,4294967295,4), 100) print str(res)
def wake_learning(self, random_movements, veh_pos=None, graphics=True): """ Create a vehicle and run for some time-steps """ self.random_movements = random_movements # Create vehicle in simulation self.sim = Simulator(self.light) if veh_pos is None: vehicle_pos, vehicle_angle = find_random_pos(self.light) else: vehicle_pos, vehicle_angle = veh_pos, random.randint(0, 360) self.random_vehicle = self.sim.init_simulation(random_movements, graphics=graphics, cycle='wake (training)', veh_pos=vehicle_pos, veh_angle=vehicle_angle) vehicle_move = [[ self.random_vehicle.motor_left[0], self.random_vehicle.motor_right[0], self.random_vehicle.sensor_left[0], self.random_vehicle.sensor_right[0] ]] for t in range(1, random_movements): vehicle_move.append([ self.random_vehicle.motor_left[t], self.random_vehicle.motor_right[t], self.random_vehicle.sensor_left[t], self.random_vehicle.sensor_right[t] ]) vehicle_first_move = [] for t in range(0, len(vehicle_move)): vehicle_first_move.append(np.transpose(np.array(vehicle_move[t]))) self.vehicle_first_move = np.transpose(np.array(vehicle_first_move))
def doT1nT2n(self, Community_Coordinate): nPnt = 10 #1000 nLink = 11 #40 tests = "" s = Simulator(nPnt) s.genPoints(Community_Coordinate) #s.genRandomLinks(nLink*nPnt) return s.pAll ## f2= open('doT1nT2n2.txt', 'w') ## for i in range(0,100): ## for j in range(0,i+1): ## nSteps=self.MutiTimesNoGen(s,1,i,j,0.5,0.2) ## print str(i)+"\t"+ str(j) +"\t"+str(nSteps) ## f2.write(str(i)+"\t"+ str(j) +"\t"+str(nSteps)+"\n") ## tests=tests+str(nSteps)+"\t" ## for j in range(i,101): ## tests=tests+"0\t" ## tests=tests+("\n") ## f = open('doT1nT2n.txt', 'w') ## f.write(tests) return
def main(): logging.basicConfig(level = logging.DEBUG, format='%(asctime)s %(name)-12s %(levelname)-8s %(message)s') simulator = Simulator() manager = Manager(simulator) ticker = Ticker(1.0, manager) xmlrpcserver = XMLRPCServer(manager) pbrpcserver = PBRPCServer(manager) # Add some random tanks for team in range(4): for tank in range(100): retry = True while retry: pos = (random.randint(-100, 100), random.randint(-100, 100)) if pos not in simulator.position: simulator.create_tank(Tank(team, pos)) retry = False logging.info("Starting main threads") ticker.start() # The XML-RPC server isn't maintained at the moment #xmlrpcserver.start() pbrpcserver.start() # To stop the system with Ctrl-C try: while True: time.sleep(1) except KeyboardInterrupt: ticker.self_destruct()
def __init__(self, netlist, tspice, sync_obj): """Constructor.""" # Create sync object, and set debug and simulation path self.sync_obj = sync_obj self.DEBUG = self.sync_obj.getDebug( "Tanner") or self.sync_obj.getDebug("all") self.sync_obj.appendToSimulationPath("Tanner") if self.DEBUG: print('Running Tanner...') Simulator.__init__(self, netlist=netlist, sync_obj=sync_obj) # Netlist path of circuit to be simulated. self.netlist = netlist # tspice path self.tspice = tspice # Output simulation waves. Each key corresponds to a different wave. self.waves = None pass
def runRateApproxProtocolTest(): experimentSpec = { 'packetGen': {'type': 'random', 'length': 24}, 'code': {'type': 'spinal', 'puncturing': {'type': '8-way-v2', 'numLastCodeStep': 2}, 'hash': 'one-at-a-time', 'bitsPerSymbol': 10, 'k': 4}, 'map': {'type': 'linear', 'bitsPerSymbol': 10, 'precisionBits': 14}, 'channel': {'type': 'AWGN', 'SNR_dB': 10}, 'demap': {'type': 'null'}, 'decoder': {'type': 'regular', 'beamWidth': 16, 'maxPasses': 48*8}, 'detector': {'type': 'oracle'}, 'protocol': {'type': 'rate-approx', 'maxSymbols': 48*7, 'delta': 0.99}, 'statistics': {'type': 'errors'} } if 1==0: experimentSpec['protocol'] = {'type': 'sequential', 'maxPasses':48*8} runner = Simulator(1) res = runner.runExperiment(experimentSpec, numpy.random.RandomState().tomaxint(4), 500) print str(res)
def runGaussianTest(): experimentSpec = { 'packetGen': {'type': 'random', 'length': 300}, 'code': {'type': 'spinal', 'puncturing': {'type': '8-way-v2', 'numLastCodeStep': 2}, 'hash': 'one-at-a-time', 'bitsPerSymbol': 10, 'k': 3}, 'map': {'type': 'trunc-norm-v2', 'bitsPerSymbol': 10, 'precisionBits': 14, 'numStandardDevs': 0.1}, 'channel': {'type': 'AWGN', 'SNR_dB': 10}, 'demap': {'type': 'null'}, 'decoder': {'type': 'regular', 'beamWidth': 16, 'maxPasses': 48*8}, 'detector': {'type': 'oracle'}, 'protocol': {'type': 'sequential', 'maxPasses': 48*8}, 'statistics': {'type': 'errors'} } runner = Simulator(1) res = runner.runExperiment(experimentSpec, numpy.random.RandomState().tomaxint(4) % 4294967295, 100) print str(res)
def runRateApproxProtocolTest(): experimentSpec = { 'packetGen': {'type': 'random', 'length': 24}, 'code': {'type': 'spinal', 'puncturing': {'type': '8-way-v2', 'numLastCodeStep': 2}, 'hash': 'one-at-a-time', 'bitsPerSymbol': 10, 'k': 4}, 'map': {'type': 'linear', 'bitsPerSymbol': 10, 'precisionBits': 14}, 'channel': {'type': 'AWGN', 'SNR_dB': 10}, 'demap': {'type': 'null'}, 'decoder': {'type': 'regular', 'beamWidth': 16, 'maxPasses': 48*8}, 'detector': {'type': 'oracle'}, 'protocol': {'type': 'rate-approx', 'maxSymbols': 48*7, 'delta': 0.99}, 'statistics': {'type': 'errors'} } if 1==0: experimentSpec['protocol'] = {'type': 'sequential', 'maxPasses':48*8} runner = Simulator(1) res = runner.runExperiment(experimentSpec, numpy.random.RandomState().tomaxint(4) % 4294967295, 500) print str(res)
def _run_simulation(self, num_investments): '''Run a single simulation with a given number of investments For each position, the number of investments is the number of rows. For each investment, we run num_trial trials, where each trial is a column in that row. We multiply all the trials for each investment by the value of that investment, which is simply the intial budget divided by the number of investments. For each trial (column), we sum up the returns from all the investments (rows), producing a 1xnum_trials array with the cumulative returns from each day.''' position_value = self.initial_budget / num_investments # Create the simulator object simulator = Simulator({(0, .51): 1.0, (.51, 1): -1.0}, nrows=num_investments, ncols=self.num_trials) # Run the simulator, and multiply each of the results by the value # of a share for this position trial_returns = simulator.run() * position_value # Collapse all investments on each day into cumulative return cumu_ret = self.initial_budget + trial_returns.sum(axis=0) # The daily rate of return, which is the final result daily_ret = (cumu_ret / float(self.initial_budget)) - 1. return daily_ret
def main(): root = tkinter.Tk() root.title('Brownian Motion Simulation') simulator = Simulator(root) numSapienses = input("Please input numSapienses:") simulator.simulate(int(numSapienses), 0.01) root.mainloop()
def get_fitness(start_pos, start_a, brain, iterations, light, test_data=None): """ Returns the fitness of a vehicle using real-world simulation :param start_pos: vehicle starting position :param start_a: vehicle starting angle :param brain: vehicle brain :param iterations: number of iterations to run simulation for :param light: the light of the simulation :return: fitness of vehicle """ # create sprites vehicle = BrainVehicle(start_pos, start_a, light) vehicle.set_values(brain) # create Simulation vehicle = Simulator(light).run_simulation(iterations, False, vehicle) fitness = np.mean(vehicle.sensor_left) + np.mean(vehicle.sensor_right) # check for other initial conditions if test_data is not None: for test in test_data: vehicle = BrainVehicle(test[0], test[1], light) vehicle.set_values(brain) vehicle = Simulator(light).run_simulation(iterations, False, vehicle) fitness += np.mean(vehicle.sensor_left) + np.mean( vehicle.sensor_right) fitness /= len(test_data) + 1 return fitness
def runRaptorTest(): experimentSpec = { 'packetGen': {'type': 'random', 'length': 9500}, 'code': {'type': 'raptor'}, 'map': {'type': 'QAM', 'bitsPerSymbol': 6}, 'channel': {'type': 'AWGN_c', 'SNR_dB': 20}, 'demap': {'type': 'QAM', 'useApprox': True}, 'decoder': {'type': 'raptor', 'numIter': 40}, 'detector': {'type': 'oracle'}, 'protocol': {'type': 'rate-approx', 'maxSymbols': 11500, 'delta': 0.97, 'minSymbols':1280}, 'statistics': {'type': 'errors'} } runner = Simulator(2) res = runner.runExperiment(experimentSpec, numpy.random.RandomState().tomaxint(4) % 4294967295, 3) print str(res)
def doT1pT2p(self): print Community_Coordinate nPnt=1000 nLink=40 nT1=40 nT2=20 tests="" s=Simulator(nPnt) s.genPoints() s.genRandomLinks(nLink*nPnt) f2 = open('doT1pT2p2.txt', 'w') for i in range(0,101): for j in range(0,i+1): nSteps=self.MutiTimesNoGen(s,1,nT1,nT2,0.01*i,0.01*j) print str(i)+"\t"+ str(j) +"\t"+str(nSteps) f2.write(str(i)+"\t"+ str(j) +"\t"+str(nSteps)+"\n") tests=tests+str(nSteps)+"\t" for j in range(i,101): tests=tests+"0\t" tests=tests+("\n") f = open('doT1pT2p.txt', 'w') f.write(tests) return
def runCoherenceFadingTest(): experimentSpec = { 'packetGen': {'type': 'random', 'length': 300}, 'code': {'type': 'spinal', 'puncturing': {'type': '8-way-v2', 'numLastCodeStep': 2}, 'hash': 'one-at-a-time', 'bitsPerSymbol': 10, 'k': 3}, 'map': {'type': 'soft', 'bitsPerSymbol': 10}, 'channel': {'type': 'coherence-fading', 'interval': 10, 'SNR_dB': 10}, 'demap': {'type': 'null'}, 'decoder': {'type': 'regular', 'beamWidth': 16, 'maxPasses': 48*8}, 'detector': {'type': 'oracle'}, 'protocol': {'type': 'sequential', 'maxPasses': 48*8}, 'statistics': {'type': 'errors'} } runner = Simulator(1) res = runner.runExperiment(experimentSpec, numpy.random.RandomState().tomaxint(4) % 4294967295, 100) print str(res)
def __init__(self, flightParamsTemplate, submissionFile, testFlightsFile): self.submissionFile = submissionFile self.flightParamsTemplate = flightParamsTemplate self.testFlightsFile = testFlightsFile print "Starting simulator using:", testFlightsFile self.simulator = Simulator() print "Simulator started."
def runBscLDPCTest(): experimentSpec = { 'packetGen': {'type': 'random', 'length': 648*2/3}, 'code': {'type': 'ldpc', 'n': 648, 'rate': (2,3), 'bitsPerSymbol': 1}, 'map': {'type': 'linear', 'bitsPerSymbol': 1, 'precisionBits': 1}, 'channel': {'type': 'BSC', 'flipProb': 0.04}, 'demap': {'type': 'BSC', 'flipProb': 0.04}, 'decoder': {'type': 'ldpc-float-bp', 'numIter': 40}, 'detector': {'type': 'oracle'}, 'protocol': {'type': 'one-try', 'numSymbols': 648}, 'statistics': {'type': 'errors'} } runner = Simulator(0) res = runner.runExperiment(experimentSpec, numpy.random.RandomState().tomaxint(4) % 4294967295, 100) print str(res)
def main(i, is_worst_case): sim = Simulator(n, f, GoodPlayer, BadPlayer, is_worst_case=is_worst_case) res_lst = sim.simulate(i) plt.xlabel("Number of turns") plt.ylabel("Percentage of good policies") plt.plot(range(1, i+1), res_lst, 'o') plt.show()
def test_SVSS_sevreal_runs(): sim = RBRandomOrderSimulator(4, 1) players = {i: Player(sim, i, 4, 1) for i in range(1, 4 + 1)} sim.players = players runs = 5 def helper(i): dealer = players[randint(1, 4)] secret = randint(1, 40) dealer.deal_SVSS(secret) tag = (dealer.c, dealer.id) return dealer, secret, tag dealer = [] secret = [] tag = [] for i in range(runs): data = helper(i) dealer.append(data[0]) secret.append(data[1]) tag.append(data[2]) while sim.remaining(): sim.step() for i in range(runs): assert all(tag[i] in player.SVSS_val for player in players.values()), "No secret reconstructed" assert all(player.SVSS_val[tag[i]] == secret[i] for player in players.values()), "Wrong secret reconstructed"
def runFirstErrorStatisticsTest(): experimentSpec = { 'packetGen': {'type': 'random', 'length': 256}, 'code': {'type': 'spinal', 'puncturing': {'type': '8-way-v2', 'numLastCodeStep': 2}, 'hash': 'one-at-a-time', 'bitsPerSymbol': 10, 'k': 4}, 'map': {'type': 'linear', 'bitsPerSymbol': 10, 'precisionBits': 14}, 'channel': {'type': 'AWGN', 'SNR_dB': -2}, 'demap': {'type': 'null'}, 'decoder': {'type': 'regular', 'beamWidth': 100, 'maxPasses': 48*8}, 'detector': {'type': 'oracle'}, 'protocol': {'type': 'one-try', 'numSymbols': 256*2}, 'statistics': {'type': 'first-error'} } runner = Simulator(1) for i in xrange(10): res = runner.runExperiment(experimentSpec, numpy.random.RandomState().tomaxint(4) % 4294967295, 1) print str(res), print
def runParallelKTest(): experimentSpec = { 'packetGen': {'type': 'random', 'length': 300}, 'code': {'type': 'spinal', 'puncturing': {'type': '8-way-v2', 'numLastCodeStep': 2}, 'hash': 'one-at-a-time', 'bitsPerSymbol': 10, 'k': 3}, 'map': {'type': 'linear', 'bitsPerSymbol': 10, 'precisionBits': 14}, 'channel': {'type': 'AWGN', 'SNR_dB': 10}, 'demap': {'type': 'null'}, 'decoder': {'type': 'parallel', 'alpha': 4, 'beta': 64, 'maxPasses': 48*8}, 'detector': {'type': 'oracle'}, 'protocol': {'type': 'sequential', 'maxPasses': 48*8}, 'statistics': {'type': 'errors'} } runner = Simulator(1) res = runner.runExperiment(experimentSpec, numpy.random.RandomState().tomaxint(4) % 4294967295, 10) print str(res)
class Game: def __init__ (self, complexity = 8, width=1000, height=800, margin=100): world = Landscape (terrain = [ground(margin, margin, width-margin, height-margin) for i in range(complexity)]) self.board = Simulator(world, width=width, height=height) def play(self): self.board.interactive()
def getScore(self, pos, it): '''Determines how close a particle is to the optima - lower is better ''' uavPoly = pos[:len(pos) // 2] targetPoly = pos[len(pos) // 2:] sim = Simulator(uavPoly, targetPoly, f"test{it}") score = sim.runTest() return score
def __init__(self, light_pos, type=None, net_filename=None): self.net = None # NARX network self.net_filename = net_filename # network training self.training_runs, self.training_time = None, None self.random_movements, self.after_ga_movements = None, None if type == 'skmlp': self.net = narx.load_narx_mlp(net_filename) if net_filename is not None: start_time = time.time() saved_net = narx.load_pyrenn(net_filename) self.net = PyrennNarx() self.net.set_net(saved_net) self.training_runs = int( re.search('\d+', re.search('r\d+', net_filename).group(0)).group(0)) self.training_time = int( re.search('\d+', re.search('t\d+', net_filename).group(0)).group(0)) self.network_delay = int( re.search('\d+', re.search('d\d+', net_filename).group(0)).group(0)) print 'Loaded NARX from file "%s" in %ds' % ( net_filename, time.time() - start_time) self.vehicle_training_data = None # this data will hold all the vehicles that the network will train with self.ga_test_data = None # this data will hold all the vehicles that the GA will test the fitness from self.pos_before_collect = None # first position of vehicle before random collection self.ang_before_collect = None # first angle of vehicle before random collection self.collection_vehicle_pos = [ ] # all pos of collection vehicle to pass to wakeTest vehicle to show on Sim self.pos_after_collect = None # last position of vehicle after collection (passed to GA) self.ang_after_collect = None # last angle of vehicle after collection (passed to GA) self.random_vehicle = None self.brain = None # Vehicle brain assigned after GA, 6 weights self.vehicle_first_move = None self.predicted_pos = None self.ga_individuals = None self.ga_generations = None if light_pos is None: light_pos = [1100, 600] self.light = Light(light_pos) self.sim = Simulator(self.light) self.actual_vehicle = None self.count_cycles = 0 # vars for test_2_1 self.error_sensor_log = None # predicted sensor log self.real_sensor_log = None # actual sensor log
def __init__(self, budget, unitPrice): Simulator.__init__(self, budget, unitPrice) self.Kp = - 100 / (budget * 0.25) self.Ki = -7 self.OUTPUT_NAME = 'output2.csv' self.INTEGRAL_OFFSET_RATIO = 0.01 self.errorIntegral = 0 # INTEGRAL 에러 누적으로 windup 방지를 위해 만듦 self.INTEGRAL_ERROR_LIMIT = 1
def __init__(self, test_flights_info, zoneOptions, npts_per_leg, flightParamsTemplate, submission_file): self.test_flights_info = test_flights_info self.zoneOptions = zoneOptions self.npts_per_leg = npts_per_leg self.submission_file = submission_file self.flightParamsTemplate = flightParamsTemplate print "Starting simulator..." self.simulator = Simulator() print "Simulator started."
class Game: def __init__(self, complexity=8, width=1000, height=800, margin=100): world = Landscape(terrain=[ ground(margin, margin, width - margin, height - margin) for i in range(complexity) ]) self.board = Simulator(world, width=width, height=height) def play(self): self.board.interactive()
def main(): NUM_INITIAL_MOBILES = 150 SIMULATION_ITERATIONS = 3600 print("callAttempts, blkSig, blkCap, dropSig, HOfail, HO, complSuc, talkTime, GOS, HOFR, intensity") for iteration in range(10): simulator = Simulator(NUM_INITIAL_MOBILES, 1.0/3600) simulator.run(SIMULATION_ITERATIONS, iteration)
def penaltyFunction(lamb, mu, numServers, simTime, numReps, maxMIPS, aggressivness): mySim = Simulator(lam, mu, numServers, simTime, numRepsSim, maxMIPS, aggressivness) mySim.runSimulation() totalPenalty = 0 maxTemps = mySim.getMaxTemps() responseTimes = mySim.getAvgResponseTime() avgjobsinsys = mySim.getAvgJobsInSimulation() avgUtilizations = mySim.getAvgServerUtils() powerConsumedByServers = mySim.getPowerConsumptions() for rep in powerConsumedByServers: repIndex = powerConsumedByServers.index(rep) print '*****************************************************' print 'Log dump for rep', repIndex+1 print 'Avg avg utils: ', sum(avgUtilizations[repIndex]) / len(avgUtilizations[repIndex]) print 'Avg power consumed', sum(powerConsumedByServers[repIndex]) / len(powerConsumedByServers[repIndex]) print 'Avg Response Time', sum(responseTimes[repIndex]) / len(responseTimes[repIndex]) for i in range(0, len(rep)): print 'Server', i, '\tUtil:', avgUtilizations[repIndex][i], '\tMax temp:', maxTemps[repIndex][i], '\t\tConsumed:', powerConsumedByServers[repIndex][i], '\tRT:', responseTimes[repIndex][i] maxTempForRep = max(maxTemps[repIndex]) maxPowerConsForRep = max(powerConsumedByServers[repIndex]) maxUtilForRep = max(avgUtilizations[repIndex]) maxRTForRep = max(responseTimes[repIndex]) # Huge penalties for infeasible solutions if maxTempForRep > maxTemperature: totalPenalty += maxTempForRep if maxUtilForRep > maxUtilization: totalPenalty += maxUtilForRep if maxRTForRep > maxResponseTime: totalPenalty += maxRTForRep # Calculate norms against the maximums for each list # No actual use for this, penalties wouldn't make sense since the normalized scores can only be compared relative to the max... # normMaxTemps = [float(i)/maxTempForRep for i in maxTemps[repIndex]].sort(reverse=True) # normPowerConsumed = [float(i)/maxPowerConsForRep for i in powerConsumedByServers[repIndex]].sort(reverse=True) # normAvgUtils = [float(i)/maxUtilForRep for i in avgUtilizations[repIndex]].sort(reverse=True) # normResponseTimes = [float(i)/maxRTForRep for i in responseTimes[repIndex]].sort(reverse=True) avgMaxTempForRep = sum(maxTemps[repIndex]) / len(maxTemps[repIndex]) avgPowerConsForRep = sum(powerConsumedByServers[repIndex]) / len(powerConsumedByServers[repIndex]) avgUtilForRep = sum(avgUtilizations[repIndex]) / len(avgUtilizations[repIndex]) avgRTForRep = sum(responseTimes[repIndex]) / len(responseTimes[repIndex]) for item in rep: itemIndex = rep.index(item) if maxTemps[repIndex][itemIndex] > avgMaxTempForRep: totalPenalty += maxTemps[repIndex][itemIndex] - avgMaxTempForRep if powerConsumedByServers[repIndex][itemIndex] > avgPowerConsForRep: totalPenalty += powerConsumedByServers[repIndex][itemIndex] - avgPowerConsForRep if avgUtilizations[repIndex][itemIndex] > avgUtilForRep: totalPenalty += avgUtilizations[repIndex][itemIndex] - avgUtilForRep if responseTimes[repIndex][itemIndex] > avgRTForRep: totalPenalty += responseTimes[repIndex][itemIndex] - avgRTForRep # ENDFOR return totalPenalty
def doT2Number(self): tests=[] s=Simulator(1000,40,1) s.genPoints() s.genRandomLinks(40) for i in range(10,31): nSteps=self.MutiTimesNoGen(s,2,30,i,0.5,0.2) print str(i) +"\t"+str(nSteps) tests.append(nSteps) print tests return
def doT2P(self): tests=[] s=Simulator(1000,40) s.genPoints() s.genLinks() for i in range(10,51): nSteps=self.MutiTimesNoGen(s,1,20,0.5,0.01*i) print str(i*0.01) +"\t"+str(nSteps) tests.append(nSteps) print tests return
def test_net(p): with open(p, "rb") as p: dic = pickle.load(p) network = dic["sim"].network K_pl = network.K_pl K_ep = network.K_ep inputgen = BehavioralInput(pre_seed_loc=13, K_pl=K_pl, K_ep=K_ep) sim = Simulator(network, inputgen) m, f = sim.simulate() pm.plot_main(sim, f) pm.plot_J(sim)
def predict_ball(self, nticks=51): self.positions = [] sim = Simulator([], self.ball, self.rules) v1 = self.ball.position self.positions.append(v1) step = 1 for i in range(round(nticks / step)): sim.tick(step=step) self.render.add_line(v1, sim.ball.position) v1 = sim.ball.position self.positions.append(v1)
def main(): NUM_INITIAL_MOBILES = 150 SIMULATION_ITERATIONS = 3600 print( "callAttempts, blkSig, blkCap, dropSig, HOfail, HO, complSuc, talkTime, GOS, HOFR, intensity" ) for iteration in range(10): simulator = Simulator(NUM_INITIAL_MOBILES, 1.0 / 3600) simulator.run(SIMULATION_ITERATIONS, iteration)
def main(): logging.basicConfig(format=FORMAT, level=logging.WARN, filename="gamelog.txt") # @todo: this may not be necessary in the future. dbase = db.quick_setup() dbase.choices.delete_many({}) dbase.games.delete_many({}) dbase.tricks.delete_many({}) print("Deleted old data. Continuing....") sim = Simulator(GameType.PROGRESSIVE, 100000, BasicPlayer) sim.run()
def __init__(self, sim_duration): super().__init__() # the simulation env self._simulator = Simulator(sim_duration) # dynamically get the policy agents self._agents = [] # configure spaces self.action_space = [] self.observation_space = [] for agent in self._agents: pass
def __init__(self,linkRate=1,maxStep=gobalMaxStep,injectRate=0.5,\ factory=gobalGridNetworkFactory): factory.constructNetwork(8,8)\ .setFlow(Flow((2,0),(2,7),injectRate),Flow((4,0),(4,7),injectRate), Flow((0,2),(7,2),injectRate),Flow((0,4),(7,4),injectRate), Flow((1,1),(5,1),injectRate),Flow((6,1),(6,6),injectRate) ,Flow((5,6),(1,6),injectRate),Flow((1,5),(1,2),injectRate)) network = factory.getNetwork() self.packetFactory = PacketFactory() self.simulator = \ Simulator(network,maxStep,ConstLinkRateGenerator(linkRate),self.packetFactory)
def oneRoundDelay(step=10000): injectRate = 0.9 factory = GridNetworkFactory(makeSimpleNode(), Queues) factory.constructNetwork(6,6)\ .setFlow(Flow((0,0),(0,5),injectRate))\ .setFlow(Flow((5,0),(5,5),injectRate))\ .setFlow(Flow((2,0),(3,5),injectRate)) network = factory.getNetwork() packetFactory = PacketFactory() simulator = \ Simulator(network,step,ConstLinkRateGenerator(1),packetFactory) simulator.run() #simulator.printNetwork() stat = simulator.getStaticsInfo() print stat['aveDelay'] packetPool = sorted(stat['packetPool'], key=lambda p: p.getID) py.subplot(211) py.vlines([p.getCreateTime() for p in packetPool], [1], [p.getDelay() for p in packetPool], 'r') py.xlabel('Packet create time(bp with $\lambda$ = 0.9)') py.ylabel('delay') py.grid(True) injectRate = 0.9 factory = GridNetworkFactory(makeMNode(2), Queues) factory.constructNetwork(6,6)\ .setFlow(Flow((0,0),(0,5),injectRate))\ .setFlow(Flow((5,0),(5,5),injectRate))\ .setFlow(Flow((2,0),(3,5),injectRate)) network = factory.getNetwork() packetFactory = PacketFactory() simulator = \ Simulator(network,step,ConstLinkRateGenerator(1),packetFactory) simulator.run() #simulator.printNetwork() stat = simulator.getStaticsInfo() print stat['aveDelay'] packetPool = sorted(stat['packetPool'], key=lambda p: p.getID) py.subplot(212) py.vlines([p.getCreateTime() for p in packetPool], [1], [p.getDelay() for p in packetPool], 'b') py.xlabel('Packet create time (m=2 with $\lambda$ = 0.9)') py.ylabel('delay') py.grid(True) py.savefig('packetDelayInOneRound_09') py.show()
def __init__(self, budget, unitPrice): Simulator.__init__(self, budget, unitPrice) self.Kp = - 100 / (budget * 0.25) self.Ki = -5 self.Kd = 10 / (unitPrice * 50) if self.budget < unitPrice * 10000: self.Kp = -100 / (budget * 0.999) self.Kd = 30 / (unitPrice * 20) self.OUTPUT_NAME = 'output3.csv' self.INTEGRAL_OFFSET_RATIO = 0.01 self.errorIntegral = 0 # INTEGRAL 에러 누적으로 windup 방지를 위해 만듦 self.INTEGRAL_ERROR_LIMIT = 1
def doT1P(self): tests=[] s=Simulator(1000) s.genPoints() #s.genLinks(10*1000) s.genRandomLinks(10*1000) #s.setPointType(nOrigins, nLink1, nLink2, p1, p2) for i in range(20,101): nSteps=self.MutiTimesNoGen(s,1,30,10,0.01*i,0.2) print str(i*0.01) +"\t"+str(nSteps) tests.append(nSteps) print tests return
def main(): NUM_INITIAL_MOBILES = 150 SIMULATION_ITERATIONS = 3600 print("callAttempts, blkSig, blkCap, dropSig, HOfail, HO, complSuc, talkTime, GOS, HOFR, intensity") for iteration in range(10): simulator = Simulator(NUM_INITIAL_MOBILES, 1.0/3600) # simulator.basestations[0].ANTENNA_GAIN = 10 # simulator.basestations[1].ANTENNA_GAIN = 10 simulator.basestations[0].NUM_CHANNELS = 20 simulator.basestations[1].NUM_CHANNELS = 20 simulator.run(SIMULATION_ITERATIONS, iteration)
def simulationLoop(server, capacity, period, scaled, ex_time, int_time): name = server + ".csv" s = Simulator(stats = name) # Set the server if server == 'polling': s.server = PollingServer(capacity, period) elif server == 'deferrable': s.server = DeferrableServer(capacity, period) else: s.server = BackgroundServer() # Load the taskset for t in scaled: s.tasks.append(t) # Create the aperiodic task ap = AperiodicTask("Soft", ex_time, int_time) s.tasks.append(ap) # RUUUUUUUUN !!! s.init(until) s.run() return computeAverage(name)
def runItppQamLDPCTest(): experimentSpec = { "packetGen": {"type": "random", "length": 648 * 5 / 6}, "code": {"type": "ldpc", "n": 648, "rate": (5, 6), "bitsPerSymbol": 1}, "map": {"type": "QAM", "bitsPerSymbol": 6}, "channel": {"type": "AWGN_c", "SNR_dB": 17.8}, "demap": {"type": "QAM"}, "decoder": {"type": "ldpc-float-bp", "numIter": 40}, "detector": {"type": "oracle"}, "protocol": {"type": "one-try", "numSymbols": 648 / 6}, "statistics": {"type": "errors"}, } runner = Simulator(0) res = runner.runExperiment(experimentSpec, numpy.random.RandomState().tomaxint(4), 100) print str(res)
def runLTTest(): experimentSpec = { "packetGen": {"type": "random", "length": 1000}, "code": {"type": "LT"}, "map": {"type": "QAM", "bitsPerSymbol": 6}, "channel": {"type": "AWGN_c", "SNR_dB": 17.8}, "demap": {"type": "QAM"}, "decoder": {"type": "LT", "numIter": 6}, "detector": {"type": "oracle"}, "protocol": {"type": "rate-approx", "maxSymbols": 1000, "delta": 0.97, "minSymbols": 1000 / 6}, "statistics": {"type": "errors"}, } runner = Simulator(0) res = runner.runExperiment(experimentSpec, numpy.random.RandomState().tomaxint(4), 10) print str(res)
def runRaptorTest(): experimentSpec = { "packetGen": {"type": "random", "length": 9500}, "code": {"type": "raptor"}, "map": {"type": "QAM", "bitsPerSymbol": 6}, "channel": {"type": "AWGN_c", "SNR_dB": 20}, "demap": {"type": "QAM", "useApprox": True}, "decoder": {"type": "raptor", "numIter": 40}, "detector": {"type": "oracle"}, "protocol": {"type": "rate-approx", "maxSymbols": 11500, "delta": 0.97, "minSymbols": 1280}, "statistics": {"type": "errors"}, } runner = Simulator(2) res = runner.runExperiment(experimentSpec, numpy.random.RandomState().tomaxint(4), 3) print str(res)
def runBscLDPCTest(): experimentSpec = { "packetGen": {"type": "random", "length": 648 * 2 / 3}, "code": {"type": "ldpc", "n": 648, "rate": (2, 3), "bitsPerSymbol": 1}, "map": {"type": "linear", "bitsPerSymbol": 1, "precisionBits": 1}, "channel": {"type": "BSC", "flipProb": 0.04}, "demap": {"type": "BSC", "flipProb": 0.04}, "decoder": {"type": "ldpc-float-bp", "numIter": 40}, "detector": {"type": "oracle"}, "protocol": {"type": "one-try", "numSymbols": 648}, "statistics": {"type": "errors"}, } runner = Simulator(0) res = runner.runExperiment(experimentSpec, numpy.random.RandomState().tomaxint(4), 100) print str(res)
def runShortStriderTest(): experimentSpec = { "packetGen": {"type": "random", "length": 480 * 33}, "code": {"type": "strider", "fragmentLength": 512}, "map": {"type": "null", "avgPower": 1.0}, "channel": {"type": "AWGN_c", "SNR_dB": 30}, "demap": {"type": "null"}, "decoder": {"type": "strider"}, "detector": {"type": "oracle"}, "protocol": {"type": "multiple-try", "numSymbolsList": [(1215 / 4) * i for i in xrange(1, 4 * 27 + 1)]}, "statistics": {"type": "errors"}, } runner = Simulator(1) res = runner.runExperiment(experimentSpec, numpy.random.RandomState().tomaxint(4), 10) print str(res)
def runStriderFadingTest(): experimentSpec = { "packetGen": {"type": "random", "length": 1498 * 33}, "code": {"type": "strider"}, "map": {"type": "null", "avgPower": 1.0}, "channel": {"type": "coherence-fading_c", "SNR_dB": 30, "interval": 100}, "demap": {"type": "null"}, "decoder": {"type": "strider-fading"}, "detector": {"type": "oracle"}, "protocol": {"type": "multiple-try", "numSymbolsList": [(3840 / 4) * i for i in xrange(1, 4 * 27 + 1)]}, "statistics": {"type": "errors"}, } runner = Simulator(1) res = runner.runExperiment(experimentSpec, numpy.random.RandomState().tomaxint(4), 10) print str(res)
def runItppQamTurboTest(): experimentSpec = { "packetGen": {"type": "random", "length": 1530}, "code": {"type": "turbo"}, "map": {"type": "QAM", "bitsPerSymbol": 6}, "channel": {"type": "AWGN_c", "SNR_dB": 3.2}, "demap": {"type": "QAM"}, "decoder": {"type": "regular"}, "detector": {"type": "oracle"}, "protocol": {"type": "one-try", "numSymbols": (1530 * 5 + 18) / 6}, "statistics": {"type": "errors"}, } runner = Simulator(0) res = runner.runExperiment(experimentSpec, numpy.random.RandomState().tomaxint(4), 100) print str(res)