def store_message(db_id, coll_id):
experiment_collection = experiment_results_pb2.Experiment()
try:
experiment_collection.ParseFromString(request.data)
except:
return json.dumps('Experiment is not well defined!')
# Connect to the database MongoDB
try:
connection = Connection('localhost', 12345)
except:
return json.dumps("Unable to connect to the database!")
db_names = connection.database_names()
if db_id in db_names:
db = connection[db_id]
else:
return json.dumps("No such database!")
coll_names = db.collection_names()
if coll_id in coll_names:
collection = db[coll_id]
else:
return json.dumps("No such experiment in the database!")
try:
collection.insert(protobuf_json.pb2json(experiment_collection))
except:
return json.dumps("Unable to store data into the database!")
return json.dumps('Data stored!')
def experiment(db_id, coll_id):
# Connect to the database MongoDB
try:
connection = Connection('localhost', 12345)
except:
return json.dumps("Unable to connect to the database!")
db = connection[db_id]
collection = db[coll_id]
try:
message_collection = collection.find_one({})
except:
return json.dumps("Unable to read data from the experiment!")
if message_collection is None:
return json.dumps("No data with this ID in the experiment!")
message_collection['_id'] = str(message_collection['_id'])
if request.data == 'protobuf':
pb_message = protobuf_json.json2pb(experiment_results_pb2.Experiment(),
message_collection)
pb_message_string = pb_message.SerializeToString()
return pb_message_string
else:
return json.dumps(message_collection)
def replace_location(db_id, coll_id):
experiment_collection = experiment_results_pb2.Experiment()
# Connect to the database MongoDB
try:
connection = Connection('localhost', 12345)
except:
return json.dumps("Unable to connect to the database!")
try:
experiment_collection.ParseFromString(request.data)
except:
return json.dumps('Message is not well defined!')
db_names = connection.database_names()
if db_id not in db_names:
return json.dumps("Database doesn't exist!")
db = connection[db_id]
coll_names = db.collection_names()
if coll_id not in coll_names:
return json.dumps("Collection doesn't exist!")
collection = db[coll_id]
try:
collection_backup = collection.find_one({})
collection.remove()
except:
return json.dumps("Unable to read data from the database!")
try:
collection.insert(protobuf_json.pb2json(experiment_collection))
except:
collection.insert(collection_backup)
return json.dumps("Unable to store data into the database!")
return json.dumps('Message successfully replaced!')
import time import protobuf_json import experiment_results_pb2 from generateURL import RequestWithMethod # The URL where server listens apiURL = 'http://localhost:5001/' # The name of a database db_id = 'test_db' # The name of an experiment in the database exp_id = 'test_exp' experiment_results = experiment_results_pb2.Experiment() experiment_results.timestamp_utc = int(time.time()) experiment_results.experiment_id = 1 # Define the scenario of the experiment experiment_results.scenario.testbed_label = 'test_testbed' # Label the testbed experiment_results.scenario.testbed_description = 'test' # Give the description experiment_results.scenario.experiment_description = 'test' # Describe experiment experiment_results.scenario.receiver_description = 'test' # Describe receiver(s) experiment_results.scenario.sender_description = 'test' # Describe your sender(s) experiment_results.scenario.interference_description = 'test' # Describe interference scenario experiment_results.primary_metrics.accuracy_error_2D_average = 0.0 # Average 2D error of the geo. accuracy of all points in the experiment experiment_results.primary_metrics.accuracy_error_2D_variance = 0.0 # 2D error variance of the geo. accuracy of all points in the experiment
def type3():
try:
experiment = message_evarilos_engine_type2_pb2.ece_type2()
experiment.ParseFromString(request.data)
except:
return json.dumps('Experiment is not well defined!')
response ={}
if experiment.store_metrics is True:
apiURL_metrics = experiment.metrics_storage_URI
db_id = experiment.metrics_storage_database
req = urllib2.Request(apiURL_metrics + 'evarilos/metrics/v1.0/database', headers={"Content-Type": "application/json"}, data = db_id)
resp = urllib2.urlopen(req)
coll_id = experiment.metrics_storage_collection
req = RequestWithMethod(apiURL_metrics + 'evarilos/metrics/v1.0/database/' + db_id + '/experiment', 'POST', headers={"Content-Type": "application/json"}, data = coll_id)
resp = urllib2.urlopen(req)
try:
req = RequestWithMethod(apiURL_metrics + 'evarilos/metrics/v1.0/database/' + db_id + '/experiment/' + coll_id, 'GET', headers={"Content-Type": "application/x-protobuf"}, data = 'protobuf')
resp = urllib2.urlopen(req)
message = resp.read()
experiment_results = experiment_results_pb2.Experiment()
experiment_results.ParseFromString(message)
except:
experiment_results = experiment_results_pb2.Experiment()
localization_error_2D = {}
localization_error_3D = {}
latency = {}
power_consumption = {}
number_of_points = 0
number_of_good_rooms = {}
for location in experiment_results.locations:
number_of_points += 1
x1 = location.true_coordinate_x
y1 = location.true_coordinate_y
x2 = location.est_coordinate_x
y2 = location.est_coordinate_y
localization_error_2D[number_of_points] = math.sqrt(math.pow((x1-x2), 2) + math.pow((y1-y2), 2))
try:
z1 = location.true_coordinate_z
z2 = location.est_coordinate_z
localization_error_3D[number_of_points] = math.sqrt(math.pow((x1-x2), 2) + math.pow((y1-y2), 2) + math.pow((z1-z2), 2))
except:
pass
try:
room1 = location.true_room_label
room2 = location.est_room_label
if room1.strip() == room2.strip():
number_of_good_rooms[number_of_points] = 1
else:
number_of_good_rooms[number_of_points] = 0
except:
pass
try:
latency[number_of_points] = location.latency
except:
pass
try:
power_consumption[number_of_points] = location.power_consumption
except:
pass
# Get location estimate from the SUT
if experiment.request_estimates is True:
time1 = time.time()
req = urllib2.Request(str(experiment.sut_location_estimate_URI), headers={"Content-Type": "application/json"})
resp = urllib2.urlopen(req)
time2 = time.time()
loc_est_latency = time2 - time1
estimated_location = json.loads(resp.read())
else:
estimated_location = {}
try:
estimated_location['coordinate_x'] = experiment.estimate.est_coordinate_x
estimated_location['coordinate_y'] = experiment.estimate.est_coordinate_y
except:
return json.dumps('Define the location estimate in the message!')
try:
estimated_location['coordinate_z'] = experiment.estimate.est_coordinate_z
except:
pass
try:
estimated_location['room_label'] = experiment.estimate.est_room_label
except:
pass
measurement_location = experiment_results.locations.add()
number_of_points += 1
measurement_location.point_id = experiment.ground_truth.point_id
try:
measurement_location.localized_node_id = experiment.ground_truth.localized_node_id
except:
pass
measurement_location.true_coordinate_x = x1 = experiment.ground_truth.true_coordinate_x
measurement_location.true_coordinate_y = y1 = experiment.ground_truth.true_coordinate_y
measurement_location.est_coordinate_x = x2 = estimated_location['coordinate_x']
measurement_location.est_coordinate_y = y2 = estimated_location['coordinate_y']
measurement_location.localization_error_2D = math.sqrt(math.pow((x1-x2), 2) + math.pow((y1-y2), 2))
localization_error_2D[number_of_points] = measurement_location.localization_error_2D
try:
measurement_location.true_coordinate_z = z1 = experiment.ground_truth.true_coordinate_z
measurement_location.est_coordinate_z = z2 = estimated_location['coordinate_z']
measurement_location.localization_error_3D = math.sqrt(math.pow((x1-x2), 2) + math.pow((y1-y2), 2) + math.pow((z1-z2), 2))
localization_error_3D[number_of_points] = measurement_location.localization_error_3D
except:
time.sleep(0)
try:
measurement_location.true_room_label = room1 = experiment.ground_truth.true_room_label
measurement_location.est_room_label = room2 = estimated_location['room_label']
if room1.strip() == room2.strip():
measurement_location.localization_correct_room = 1
number_of_good_rooms[number_of_points] = 1
else:
measurement_location.localization_correct_room = 0
number_of_good_rooms[number_of_points] = 0
except:
pass
try:
measurement_location.latency = latency[number_of_points] = loc_est_latency
except:
pass
try:
measurement_location.latency = latency[number_of_points] = experiment.estimate.latency
except:
pass
try:
measurement_location.power_consumption = location.power_consumption
power_consumption[number_of_points] = measurement_location.power_consumption
except:
pass
try:
measurement_location.power_consumption = experiment.estimate.power_consumption
power_consumption[number_of_points] = measurement_location.power_consumption
except:
pass
experiment_results.primary_metrics.error_2D_average = float(sum(localization_error_2D.values()))/number_of_points
experiment_results.primary_metrics.error_2D_min = min(localization_error_2D.values())
experiment_results.primary_metrics.error_2D_max = max(localization_error_2D.values())
experiment_results.primary_metrics.error_2D_std = numpy.std(localization_error_2D.values())
experiment_results.primary_metrics.error_2D_median = numpy.median(localization_error_2D.values())
if len(localization_error_3D) != 0:
experiment_results.primary_metrics.error_3D_average = float(sum(localization_error_3D.values()))/number_of_points
experiment_results.primary_metrics.error_3D_min = min(localization_error_3D.values())
experiment_results.primary_metrics.error_3D_max = max(localization_error_3D.values())
experiment_results.primary_metrics.error_3D_std = numpy.std(localization_error_3D.values())
experiment_results.primary_metrics.error_3D_median = numpy.median(localization_error_3D.values())
if len(number_of_good_rooms) != 0:
experiment_results.primary_metrics.room_error_average = float(sum(number_of_good_rooms.values()))/number_of_points
print number_of_good_rooms.values()
print number_of_points
if len(latency) != 0:
experiment_results.primary_metrics.latency_average = float(sum(latency.values()))/number_of_points
experiment_results.primary_metrics.latency_min = min(latency.values())
experiment_results.primary_metrics.latency_max = max(latency.values())
experiment_results.primary_metrics.latency_std = numpy.std(latency.values())
experiment_results.primary_metrics.latency_median = numpy.median(latency.values())
if sum(power_consumption) != 0:
experiment_results.primary_metrics.power_consumption_average = float(sum(power_consumption.values()))/number_of_points
experiment_results.primary_metrics.power_consumption_median = numpy.median(power_consumption.values())
experiment_results.primary_metrics.power_consumption_min = min(power_consumption.values())
experiment_results.primary_metrics.power_consumption_max = max(power_consumption.values())
experiment_results.primary_metrics.power_consumption_std = numpy.std(power_consumption.values())
else:
try:
experiment_results.primary_metrics.power_consumption_average = experiment.power_consumption_per_experiment
except:
pass
experiment_results.scenario.testbed_label = experiment.scenario.testbed_label
experiment_results.scenario.testbed_description = experiment.scenario.testbed_description
experiment_results.scenario.experiment_description = experiment.scenario.experiment_description
experiment_results.sut.sut_name = experiment.scenario.sut_description
experiment_results.scenario.receiver_description = experiment.scenario.receiver_description
experiment_results.scenario.sender_description = experiment.scenario.sender_description
experiment_results.scenario.interference_description = experiment.scenario.interference_description
experiment_results.timestamp_utc = experiment.timestamp_utc
experiment_results.experiment_label = experiment.experiment_label
obj = json.dumps(protobuf_json.pb2json(experiment_results))
if experiment.store_metrics is True:
apiURL_metrics = experiment.metrics_storage_URI
db_id = experiment.metrics_storage_database
req = urllib2.Request(apiURL_metrics + 'evarilos/metrics/v1.0/database', headers={"Content-Type": "application/json"}, data = db_id)
resp = urllib2.urlopen(req)
coll_id = experiment.metrics_storage_collection
req = RequestWithMethod(apiURL_metrics + 'evarilos/metrics/v1.0/database/' + db_id + '/experiment/' + coll_id, 'DELETE', headers={"Content-Type": "application/json"}, data = coll_id)
resp = urllib2.urlopen(req)
req = RequestWithMethod(apiURL_metrics + 'evarilos/metrics/v1.0/database/' + db_id + '/experiment', 'POST', headers={"Content-Type": "application/json"}, data = coll_id)
resp = urllib2.urlopen(req)
req = urllib2.Request(apiURL_metrics + 'evarilos/metrics/v1.0/database/' + db_id + '/experiment/' + coll_id, headers={"Content-Type": "application/json"}, data = obj)
resp = urllib2.urlopen(req)
response = protobuf_json.pb2json(experiment_results)
return json.dumps(response)
def type1():
try:
experiment = message_evarilos_engine_type1_pb2.ece_type1()
experiment.ParseFromString(request.data)
except:
return json.dumps('Experiment is not well defined!')
experiment_results = experiment_results_pb2.Experiment()
localization_error_2D = {}
localization_error_3D = {}
latency = {}
power_consumption = {}
number_of_points = 0
number_of_good_rooms = {}
for location in experiment.locations:
number_of_points += 1
measurement_location = experiment_results.locations.add()
measurement_location.point_id = location.point_id
try:
measurement_location.localized_node_id = location.localized_node_id
except:
pass
measurement_location.true_coordinate_x = x1 = location.true_coordinate_x
measurement_location.true_coordinate_y = y1 = location.true_coordinate_y
measurement_location.est_coordinate_x = x2 = location.est_coordinate_x
measurement_location.est_coordinate_y = y2 = location.est_coordinate_y
measurement_location.localization_error_2D = math.sqrt(math.pow((x1-x2), 2) + math.pow((y1-y2), 2))
localization_error_2D[number_of_points] = measurement_location.localization_error_2D
try:
measurement_location.true_coordinate_z = z1 = location.true_coordinate_z
measurement_location.est_coordinate_z = z2 = location.est_coordinate_z
measurement_location.localization_error_3D = math.sqrt(math.pow((x1-x2), 2) + math.pow((y1-y2), 2) + math.pow((z1-z2), 2))
localization_error_3D[number_of_points] = measurement_location.localization_error_3D
except:
pass
try:
measurement_location.true_room_label = room1 = location.true_room_label
measurement_location.est_room_label = room2 = location.est_room_label
if room1.strip() == room2.strip():
measurement_location.localization_correct_room = 1
number_of_good_rooms[number_of_points] = 1
else:
measurement_location.localization_correct_room = 0
number_of_good_rooms[number_of_points] = 0
except:
pass
try:
measurement_location.latency = location.latency
latency[number_of_points] = location.latency
except:
pass
try:
measurement_location.power_consumption = location.power_consumption
power_consumption[number_of_points] = location.power_consumption
except:
pass
experiment_results.primary_metrics.accuracy_error_2D_average = float(sum(localization_error_2D.values()))/number_of_points
experiment_results.primary_metrics.accuracy_error_2D_min = min(localization_error_2D.values())
experiment_results.primary_metrics.accuracy_error_2D_max = max(localization_error_2D.values())
experiment_results.primary_metrics.accuracy_error_2D_variance = numpy.var(localization_error_2D.values())
experiment_results.primary_metrics.accuracy_error_2D_median = numpy.median(localization_error_2D.values())
experiment_results.primary_metrics.accuracy_error_2D_75_percentile = numpy.percentile(localization_error_2D.values(), 75)
experiment_results.primary_metrics.accuracy_error_2D_90_percentile = numpy.percentile(localization_error_2D.values(), 90)
experiment_results.primary_metrics.accuracy_error_2D_rms = math.sqrt( (1 / float(number_of_points)) * numpy.sum( numpy.power( localization_error_2D.values(), 2)))
if len(localization_error_3D) != 0:
experiment_results.primary_metrics.accuracy_error_3D_average = float(sum(localization_error_3D.values()))/number_of_points
experiment_results.primary_metrics.accuracy_error_3D_min = min(localization_error_3D.values())
experiment_results.primary_metrics.accuracy_error_3D_max = max(localization_error_3D.values())
experiment_results.primary_metrics.accuracy_error_3D_variance = numpy.var(localization_error_3D.values())
experiment_results.primary_metrics.accuracy_error_3D_median = numpy.median(localization_error_3D.values())
experiment_results.primary_metrics.accuracy_error_3D_75_percentile = numpy.percentile(localization_error_3D.values(), 75)
experiment_results.primary_metrics.accuracy_error_3D_90_percentile = numpy.percentile(localization_error_3D.values(), 90)
experiment_results.primary_metrics.accuracy_error_3D_rms = math.sqrt( (1 / float(number_of_points)) * numpy.sum( numpy.power( localization_error_3D.values(), 2)))
if len(number_of_good_rooms) != 0:
experiment_results.primary_metrics.room_accuracy_error_average = float(sum(number_of_good_rooms.values()))/number_of_points
if len(latency) != 0:
experiment_results.primary_metrics.latency_average = float(sum(latency.values()))/number_of_points
experiment_results.primary_metrics.latency_min = min(latency.values())
experiment_results.primary_metrics.latency_max = max(latency.values())
experiment_results.primary_metrics.latency_variance = numpy.var(latency.values())
experiment_results.primary_metrics.latency_median = numpy.median(latency.values())
experiment_results.primary_metrics.latency_75_percentile = numpy.percentile(latency.values(), 75)
experiment_results.primary_metrics.latency_90_percentile = numpy.percentile(latency.values(), 90)
experiment_results.primary_metrics.latency_rms = math.sqrt( (1 / float(number_of_points)) * numpy.sum( numpy.power( latency.values(), 2)))
if len(power_consumption) != 0:
experiment_results.primary_metrics.power_consumption_average = float(sum(power_consumption.values()))/number_of_points
experiment_results.primary_metrics.power_consumption_median = numpy.median(power_consumption.values())
experiment_results.primary_metrics.power_consumption_min = min(power_consumption.values())
experiment_results.primary_metrics.power_consumption_max = max(power_consumption.values())
experiment_results.primary_metrics.power_consumption_variance = numpy.var(power_consumption.values())
experiment_results.primary_metrics.power_consumption_75_percentile = numpy.percentile(power_consumption.values(), 75)
experiment_results.primary_metrics.power_consumption_90_percentile = numpy.percentile(power_consumption.values(), 90)
experiment_results.primary_metrics.power_consumption_rms = math.sqrt( (1 / float(number_of_points)) * numpy.sum( numpy.power( power_consumption.values(), 2)))
else:
try:
experiment_results.primary_metrics.power_consumption_average = experiment.power_consumption_per_experiment
except:
pass
experiment_results.scenario.testbed_label = experiment.scenario.testbed_label
experiment_results.scenario.testbed_description = experiment.scenario.testbed_description
experiment_results.scenario.experiment_description = experiment.scenario.experiment_description
experiment_results.sut.sut_name = experiment.scenario.sut_description
experiment_results.scenario.receiver_description = experiment.scenario.receiver_description
experiment_results.scenario.sender_description = experiment.scenario.sender_description
experiment_results.scenario.interference_description = experiment.scenario.interference_description
experiment_results.timestamp_utc = experiment.timestamp_utc
experiment_results.experiment_label = experiment.experiment_label
obj = json.dumps(protobuf_json.pb2json(experiment_results))
response = {}
if experiment.store_metrics is True:
apiURL_metrics = experiment.metrics_storage_URI
db_id = experiment.metrics_storage_database
req = urllib2.Request(apiURL_metrics + 'evarilos/metrics/v1.0/database', headers={"Content-Type": "application/json"}, data = db_id)
resp = urllib2.urlopen(req)
coll_id = experiment.metrics_storage_collection
req = RequestWithMethod(apiURL_metrics + 'evarilos/metrics/v1.0/database/' + db_id + '/experiment', 'POST', headers={"Content-Type": "application/json"}, data = coll_id)
resp = urllib2.urlopen(req)
req = urllib2.Request(apiURL_metrics + 'evarilos/metrics/v1.0/database/' + db_id + '/experiment/' + coll_id, headers={"Content-Type": "application/json"}, data = obj)
resp = urllib2.urlopen(req)
response = protobuf_json.pb2json(experiment_results)
return json.dumps(response)