def simul(discipline, rho, k, seed): if seed == "-1": seed = None master = Master() results_w, results_w_icl, results_w_icu, \ results_w_vars, results_w_vars_icl, results_w_vars_icu, \ results_nq, results_nq_icl, results_nq_icu, \ results_nq_vars, results_nq_vars_icl, results_nq_vars_icu, \ execution_time = master.webmain(discipline, rho, k, seed) execution_time = "Execution time: {0:.2f} seconds".format(execution_time) discipline = "FCFS" if discipline == 1 else "LCFS" return render_template("simulation.html", discipline=discipline, rho=rho, results_w=json.dumps(results_w), results_w_icl=json.dumps(results_w_icl), results_w_icu=json.dumps(results_w_icu), results_w_vars=json.dumps(results_w_vars), results_w_vars_icl=json.dumps(results_w_vars_icl), results_w_vars_icu=json.dumps(results_w_vars_icu), results_nq=json.dumps(results_nq), results_nq_icl=json.dumps(results_nq_icl), results_nq_icu=json.dumps(results_nq_icu), results_nq_vars=json.dumps(results_nq_vars), results_nq_vars_icl=json.dumps(results_nq_vars_icl), results_nq_vars_icu=json.dumps(results_nq_vars_icu), execution_time=execution_time)
def test_two_particles_can_be_far_away(self): master = Master(100, 1) master.create_nanoparticles_and_ligands(2, 10, 10, 1) master.agents[0].position = np.array([1, 1, 1]) position = np.array([50, 50, 50]) self.assertTrue(master._check_space_available_nanoparticle(position))
def main(): master=Master() master.start() master.join() #run() print "Server is dead" return 0
def __init__(self): Master.__init__(self) #self.proxy = {} self.params = {} #self.params['proxy_ip'] = { 'https': 'socks5://127.0.0.1:9050',} self.proxy_list = self.initProxies() self.params['return_error_page'] = 1
def test_correct_number_of_nanoparticles_are_created(self): master = Master(100, 1) master.create_nanoparticles_and_ligands(10, 1, 1, 1) self.assertEqual(10, master.number_of_nanoparticles) agents = [i for i in master.agents if isinstance(i, Nanoparticle)] self.assertEqual(10, len(agents))
def test_no_nanoparticles_are_touching(self): master = Master(1000, 1) master.create_nanoparticles_and_ligands(100, 10, 10, 1) positions = [i.position for i in master.agents] combs = combinations(positions, 2) distance = [np.linalg.norm(a - b) for (a, b) in combs] self.assertTrue(all([i > 22 for i in distance]))
def test_mult(): key_cipher = np.array([[GF2int(randint(0, 255)) for i in range(4)] for j in range(4)], dtype=GF2int) v1 = np.array([[GF2int(randint(0, 255)) for i in range(4)] for j in range(4)], dtype=GF2int) v2 = np.array([[GF2int(randint(0, 255)) for i in range(4)] for j in range(4)], dtype=GF2int) sub = Master.get_one_sub(key_cipher) shares1 = Master.get_shares(v1, sub) shares2 = Master.get_shares(v2, sub) sub.initShares(shares1) for s, mini in enumerate(sub.minicircuits): mini.state2 = shares2[s] sub.multiply(inputs1=[mini.state2 for mini in sub.minicircuits]) reconstruct = Master.reconstructShares(sub) if not np.array_equal(v1 * v2, reconstruct): return 0 else: return 1
def main(): master = Master() logging.basicConfig(filename='work.log', level=logging.DEBUG) #Init by filling root for i in range(0, ROOTCOUNT): master.AddRoot(randint(18, 21), 1024) #Init for i in range(1000): #print "Adding node" retval = ADD(master) #if retval == 2: # print "Added as root" #elif retval == 1: # print "Added to some root" if retval == 0: print "Failed????" while True: #0 - Insrt #1 - Delete #2 - Nothing #Decide what to do choice = randint(0, 2) if choice == 0: ADD(master) elif choice == 1: DEL(master) else: time.sleep(1)
def test_two_particles_cannot_be_in_same_positions(self): master = Master(100, 1) master.create_nanoparticles_and_ligands(2, 10, 10, 1) master.agents[0].position = np.array([1, 1, 1]) position = np.array([1, 1, 1]) self.assertFalse(master._check_space_available_nanoparticle(position))
def test_correct_number_ligands_are_created(self): master = Master(100, 1) master.create_nanoparticles_and_ligands(100, 10, 1, 1) self.assertEqual(master.ligand_length, 1) self.assertEqual(master.number_of_ligands, 10) ligands = [i.ligands for i in master.agents] for l in ligands: self.assertEqual(10, len(l))
def preprocesse_file(name): with open(name) as fobj: lines = fobj.readlines() pool = Master() results = [x for x in pool.do(lines, preprocessing) if (x is not None) and (len(x) > 2)] with open("./preprocessing/"+ name.split("/")[-1], "w") as file: file.write(" \n".join(results)) return "./preprocessing/"+ name.split("/")[-1]
def test_no_nanoparticles_outside_area(self): master = Master(1000, 1) master.create_nanoparticles_and_ligands(100, 10, 10, 1) positions = [i.position for i in master.agents] self.assertTrue( all([(i[0] < 1000 and i[1] < 1000 and i[2] < 1000) for i in positions])) self.assertTrue( all([(i[0] > 0 and i[1] > 0 and i[2] > 0) for i in positions]))
def validate_file(name): with open(name) as fobj: lines = fobj.readlines() master = Master() results = master.do(lines, valid_line) print(results) print(any(results)) answer = any(results) return answer
def assignMasterSlave(robot1, robot2): if robot1.type == robot2.type: printc("On ne peut pas permuter 2 " + robot2.type, 'Fail') if robot1.type == "Slave": slave = Slave(robot1.s, robot1.hostname) master = Master(robot2.s, robot2.hostname) else: slave = Slave(robot2.s, robot2.hostname) master = Master(robot1.s, robot1.hostname) return master, slave
def test_no_receptor_bases_outside_area(self): for _ in range(100): master = Master(500, 1) master.create_nanoparticles_and_ligands(100, 10, 10, 1) positions = [ i.base_position for i in master.agents if isinstance(i, Receptor) ] self.assertTrue( all([(i[0] < 1000 and i[1] < 1000 and i[2] < 1000) for i in positions])) self.assertTrue( all([(i[0] > 0 and i[1] > 0 and i[2] > 0) for i in positions]))
def test_AES(): # INIT KEYS AND PLAINTEXT key1 = np.array([[GF2int(randint(0, 255)) for i in range(4)] for j in range(4)], dtype=GF2int) key2 = np.array([[GF2int(randint(0, 255)) for i in range(4)] for j in range(4)], dtype=GF2int) key3 = np.array([[GF2int(randint(0, 255)) for i in range(4)] for j in range(4)], dtype=GF2int) key1 = "".join(format(y, '02x') for x in key1 for y in x) key2 = "".join(format(y, '02x') for x in key2 for y in x) key3 = "".join(format(y, '02x') for x in key3 for y in x) key_cipher = np.array([[GF2int(0) for i in range(4)] for j in range(4)], dtype=GF2int) plain_text = np.array([[GF2int(0) for i in range(4)] for j in range(4)], dtype=GF2int) plain_text_str = "".join(format(y, '02x') for x in plain_text for y in x) key_cipher_str = "".join(format(y, '02x') for x in key_cipher for y in x) aes_ref = AES.new(key_cipher_str) cipher_ref_str = aes_ref.encrypt(plain_text_str).encode("hex") W = aes.ExpandRoundKey(key_cipher) master = Master(key_cipher, 4) keys = [key1, key2, key3] sub = SubCircuit( np.array([ MiniCircuit(keys[s % 3], keys[(s + 1) % 3], W) for s in range(3) ])) randomness = sub.getCorrRandom() shares = [Secret(), Secret(), Secret()] for s in range(0, 3): shares[s].alpha = randomness[s] shares[s].x = plain_text + randomness[(s - 1) % 3] W = aes.ExpandRoundKey(key_cipher) sub.initShares(shares) sub.AES() shared = master.reconstructShares(sub) state = aes.AES(key_cipher, plain_text) if (not np.array_equal(state, shared)): return 0 else: return 1
def main(): GPIO.setmode(GPIO.BOARD) GPIO.setup(16, GPIO.IN) m = Master() if GPIO.input(16) == GPIO.HIGH: print("Stromlimit erreicht") while True: m.work() time.sleep(0.1)
def __init__(self, ip_address, orders_file_path): super(Daemon, self).__init__() self.__commands = Commands(orders_file_path) self.__master = Master(0, "00:00:00:00:00:00", ip_address, "0", 0) self.__master.add_stack(Stack(0,0)) self.__udp_comm = CommunicatorUDP(42666, self.__master.get_ip_address()) self.__udp_comm.open_communication() print("Master listening on {}:{}".format(ip_address, 42666)) self.__i2c_comm = CommunicatorI2C()
def loop_Validator(self): with open("./pids/validator.pid", "w") as fobj: fobj.write(str(os.getpid())) workers = Master() redis_connector = RedisWrapper() worker = ValidatorService(redis_connector, workers, validate_file) worker.start_loop()
def loop_Preprocessor(self): with open("./pids/preprocessing.pid", "w") as fobj: fobj.write(str(os.getpid())) workers = Master() redis_connector = RedisWrapper() worker = PeprocessService(redis_connector, workers, preprocesse_file) worker.start_loop()
def loop_SessionGenerator(self): with open("./pids/sessions.pid", "w") as fobj: fobj.write(str(os.getpid())) workers = Master() redis_connector = RedisWrapper() worker = SessionGeneratorService(redis_connector, workers, SessionGeneratorWorker().generate) worker.start_loop()
def __init__(self, clientId, data, verifykey, apiEndPoint): self.message = data self.sessionkey = verifykey self.apiEndPoint = apiEndPoint self.splitUrl = apiEndPoint.split('/') self.auth = Authentication() self.master = Master() self.admin = Admin() self.role = roleManage() self.attendance = attendanceManage() self.project = projectManage() self.labourer = labbourerManage() self.labclass = labourerClass() self.shift = shiftManage() self.log = Logger() self.paymentDesk = paymentDesk() self.clientId = clientId
def binding_energy(): print('Binding Energy -------------') d = np.linspace(5, 25, 5).tolist() data = {} means = [] errors = [] time_data = [] for i in d: variable_finals = [] for _ in range(3): number_of_seconds = 1 # i.e. 1 hour = 3600 seconds model = Master(dimension=1000, binding_energy=int(i), time_unit=10e-3, number_of_receptors=2, receptor_length=100, number_of_nanoparticles=1, nanoparticle_radius=50, number_of_ligands=2, ligand_length=7, binding_distance=4, receptor_radius=3, ligand_radius=3, cell_diffusion_coef=1) model.create_receptors() # 100 nm for receptor model.create_nanoparticles_and_ligands( ) # 1-2 nm for ligand # 95 particles print( f'{model.dimension/1000} μm\u00b3 system, {model.binding_energy} binding energy, {model.number_of_nanoparticles} Nanoparticles,\n' f'{model.nanoparticle_radius} nm Nanoparticle Radius, {model.number_of_ligands} Ligands, Ligand length {model.ligand_length} nm,\n' f'{model.number_of_receptors} Receptors, {model.receptor_length} nm Receptor length, {model.binding_distance} Binding distance' ) model.run(steps=number_of_seconds) # 3600 for 1 hour print(f'The surface coverage is {model.surface_coverage}') variable_finals.append(model.surface_coverage) time_data.append(np.array(model.coverage)) mean_time = np.mean(time_data, axis=0) error_time = np.std(time_data, axis=0) data[f'{model.binding_energy} KT binding energy '] = np.array( [list(range(0, model.time + 1)), mean_time, error_time]) mean_coverage = np.mean(np.array(variable_finals)) print(f'The mean surface coverage is {mean_coverage}') errors.append(np.std(np.array(variable_finals))) means.append(np.mean(np.array(variable_finals))) plt.xlabel('Time (milliseconds)') plt.ylabel('Surface Coverage') for key, value in data.items(): plt.plot(value[0], value[1], label=key) plt.fill_between(value[0], value[1] - value[2], value[1] + value[2], alpha=0.2) plt.legend() plt.show() second_variable_plot('Binding energy (kt)', 'Surface Coverage', d, means, errors)
def loop_Apriori(self): with open("./pids/apriory.pid", "w") as fobj: fobj.write(str(os.getpid())) workers = Master() redis_connector = RedisWrapper() worker = AprioriService(redis_connector, workers, None) worker.start_loop()
def test_addKey(): key_cipher = np.array([[GF2int(randint(0, 255)) for i in range(4)] for j in range(4)], dtype=GF2int) v = np.array([[GF2int(randint(0, 255)) for i in range(4)] for j in range(4)], dtype=GF2int) sub = Master.get_one_sub(key_cipher) shares = Master.get_shares(v, sub) sub.initShares(shares) sub.addKey(0) reconstruct = Master.reconstructShares(sub) if not np.array_equal(v + key_cipher, reconstruct): return 0 else: return 1
def test_Sbox(): key_cipher = np.array([[GF2int(randint(0, 255)) for i in range(4)] for j in range(4)], dtype=GF2int) v = np.array([[GF2int(randint(0, 255)) for i in range(4)] for j in range(4)], dtype=GF2int) sub = Master.get_one_sub(key_cipher) shares = Master.get_shares(v, sub) sub.initShares(shares) sub.SubBytes() reconstruct = Master.reconstructShares(sub) if not np.array_equal(np.array(sbox[np.array(v, dtype=int)], dtype=GF2int), reconstruct): return 0 else: return 1
def main(): master = Master() master.start() master.join() #run() print "Server is dead" return 0
def test_all_receptors_have_correct_length(self): master = Master(100, 1) master.create_nanoparticles_and_ligands(10, 1, 1, 1) master.create_receptors(10, 1) [ self.assertEqual(1, a.receptor_length) for a in master.agents if isinstance(a, Receptor) ]
def test_two_particles_can_be_really_close_without_touching(self): master = Master(100, 1) master.create_nanoparticles_and_ligands(2, 10, 10, 1) master.agents[0].position = np.array([1, 1, 1]) position = np.array([23, 1, 1]) self.assertTrue(master._check_space_available_nanoparticle(position)) x = 22 / np.sqrt(3) + 1 position = np.array([x, x, x]) self.assertTrue(master._check_space_available_nanoparticle(position))
def test_two_particles_cannot_be_touching(self): master = Master(100, 1) master.create_nanoparticles_and_ligands(2, 10, 10, 1) master.agents[0].position = np.array([1, 1, 1]) position = np.array([23 - 1e-10, 1, 1]) self.assertFalse(master._check_space_available_nanoparticle(position)) x = 22 / np.sqrt(3) + 1 - 1e-10 position = np.array([x, x, x]) self.assertFalse(master._check_space_available_nanoparticle(position))
def getListMaster(cursor): masters = [] for (id_master, nm_email, nm_password, nr_killed, nr_life, dt_record) in cursor: master = Master() master.idMaster = id_master master.email = nm_email master.password = nm_password master.killed = nr_killed master.life = nr_life master.dateRecord = dt_record masters.append(master) return masters
class Simulation(object): def __init__(self): self.master = Master() self.slave = Slave() def start_simulation(self): detections = 0 numOfDetections = 4000 timeArray = np.arange(numOfDetections) masters_clock = 1 # 1 - 16384 # 15 + 1023 + 16 <- Max case # min 4 max 1054 true_clock = 1 while(detections < numOfDetections): self.master.tic(masters_clock) self.slave.tic() if masters_clock == 1: print true_clock #if true_clock >= 2048: #print '****************' #print 'Clock ' + str(true_clock) #print 'F1: ' + str(self.master.freqNumOne) + ' F2: ' + str(self.master.freqNumTwo) #if true_clock == 4096: #break; if self.master.slotMode == MasterSlotMode.tx: if (self.slave.sendFHS==True): print 'Assert: TX & slave sending FHS' if ((self.slave.inBackOffZone==False) & (self.slave.inOneSlotTo==False)): if ((self.slave.freqNum == self.master.freqNumOne) | (self.slave.freqNum == self.master.freqNumTwo)): self.slave.listen("Master_MAC") print '>> Hit at ' + str(true_clock) else: # in Rx mode if (self.slave.sendFHS==True): if ((self.slave.freqNum == self.master.freqNumOne) | (self.slave.freqNum == self.master.freqNumTwo)): time = true_clock timeArray[detections] = time # Reset Master & Slave self.slave.reset() self.master.resetTrain() masters_clock = 0 # because it will get increment at the end of while loop true_clock = 0 detections = detections +1 else: print 'Assert: RX & FHS sent, freqs didnt match ' + str(true_clock) #increment clocks true_clock = true_clock + 1 masters_clock = masters_clock + 1 if masters_clock > 16384: masters_clock = 1 #self.master.resetTrain() rand_str = ''.join(random.choice( string.ascii_lowercase + string.ascii_uppercase + string.digits) for i in range(5)) + '.csv' path = 'temp/'+rand_str #print timeArray np.savetxt(path, timeArray, delimiter=',', header='Time', fmt='%1.0f')
def __init__(self): self.master = Master() self.slave = Slave()
def __init__(self, master, name, pool, virt_co): self.master = master Master.__init__(self, name, pool, virt_co)
import sys import os import shutil sys.path.append('src') from Master import Master if os.path.exists('Testing/Master'): shutil.rmtree('Testing/Master') m = Master(name = 'Server01', debug=True, destination_folder='Testing/Master', expected_connections=2) m.setServer(host='localhost', port=8080) m.setDelimeter(':::') m.run()