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_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 main():
master = Master()
master.start()
master.join()
#run()
print "Server is dead"
return 0
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 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 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 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 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_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 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 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_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_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 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 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 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_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 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 test_no_receptor_tips_are_touching(self):
for _ in range(100):
master = Master(100, 1)
master.create_nanoparticles_and_ligands(10, 1, 1, 1)
master.create_receptors(100, 1)
positions = [
a.tip_position for a in master.agents
if isinstance(a, Receptor)
]
combs = combinations(positions, 2)
distance = [np.linalg.norm(a - b) for (a, b) in combs]
[self.assertNotAlmostEqual(d, 0) for d in distance]
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 __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 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
def run_mapred(input_files, map_fn, reduce_fn, output_location):
# init master and works
master = Master((HOST, HOST_PORT), MasterHandler)
clusters = [uid for uid in CLUSTER_TABLE]
if len(clusters) < 2:
raise ValueError("Not enough Cluster!")
# load balance
mappers_uid, reducers_uid = balance_mapper_reducer(clusters)
# split files
input_data = []
for file in input_files:
splits = Util.split_file(file_path=file, num_split=len(mappers_uid))
input_data.append(splits)
# print (splits)
# print (input_data)
# print ("start!")
master_args = (master, input_data, mappers_uid, reducers_uid,
output_location)
master_process = multiprocessing.Process(target=master_work,
args=master_args)
master_process.start()
# print ("Master Donez!")
# mapper run
for uid in mappers_uid:
mapper = CLUSTER_TABLE[uid]
mapper_args = (mapper, len(reducers_uid), map_fn)
mapper_process = multiprocessing.Process(target=mapper_work,
args=mapper_args)
mapper_process.start()
# print ("Mapper setup")
# reducer run
for uid in reducers_uid:
reducer = CLUSTER_TABLE[uid]
reducer_args = (reducer, reduce_fn)
reducer_process = multiprocessing.Process(target=reducer_work,
args=reducer_args)
reducer_process.start()
def Machine(self, mtype, ip_port, clock_time, logs_file, **kwargs):
i = 0
if mtype is 'm':
master = Master(ip_port, clock_time, logs_file, kwargs['d'],
kwargs['slaves_file'])
while True:
i += 1
print("Execution ", i)
master.get_slaves_time()
master.calculate_time()
time.sleep(5)
elif mtype is 's':
slave = Slave(ip_port, clock_time, logs_file)
from rpyc.utils.server import ThreadedServer
print("Slave machine")
t = ThreadedServer(slave,
port=int(ip_port[ip_port.index(':') + 1:]))
t.start()
else:
print("Option not available")
def __init__(self):
self.master = Master()
self.slave = Slave()
