def getIntersectionIDs(self, simulation_id):
""" Get intersection IDs associated
with simulation id
"""
db = DBUtil().getDatabase()
simulation = db.simulation.find_one({"_id": ObjectId(simulation_id)})
return simulation["junctions"]
def updateSimulationStepRateDB(simulation_id, steps):
db = DBUtil().getDatabase()
if int(steps) > 0:
db.simulation.update({
"_id": simulation_id,
}, { "$set": {"update_rate": int(steps)} })
def readAllFlows(self, simulation_id):
""" Reads all flows
gets simulation id
"""
db = DBUtil().getDatabase()
flowPoints = db.flows.find({"simulation_id": ObjectId(simulation_id)})
return flowPoints
def getSimulationidDB(userid):
#ignore the supplied mode field
user_mode = getUserModeDB(userid);
db = DBUtil().getDatabase()
grouprow = db.student.find_one({"_id":userid})
if grouprow is None:
return None;
if user_mode == 'INDIVIDUAL':
simulation = db.simulation.find_one({"user_id":userid, "mode": user_mode, "status": "ACTIVE"})
# simulation id for personal mode is not created yet
# need to handle cases where there are no personal and group modes
if simulation is None:
group_simulation = db.simulation.find_one({"group_id":grouprow["group_id"], "mode": 'GROUP', "status": "ACTIVE"})
#, { "_id": 0 })
group_simulation['user_id'] = userid
group_simulation['mode'] = user_mode
groud_sim_id = group_simulation['_id']
group_simulation['_id'] = ObjectId();
simulation_id = db.simulation.insert(group_simulation)
db.simulation_association.insert({ "sim_id" : simulation_id,
"sim_asso" : [simulation_id]
})
interface = SimulationBackupInterface(groud_sim_id)
interface.saveSimulationWithNewId(simulation_id);
return simulation_id;
return simulation["_id"]
logging.info("For user " + userid + ", group_id is " + grouprow["group_id"])
simulation = db.simulation.find_one({"group_id":grouprow["group_id"], "mode": user_mode, "status": "ACTIVE"})
return simulation["_id"]
def setUserModeDB(userid, mode):
db = DBUtil().getDatabase();
print userid, mode
user_details = getUserDetailsDB(userid)
previous_mode = getUserModeDB(userid)
db.user_studentrole.update(
{ 'user_id': userid },
{ '$set':
{ 'user_mode': mode
}
}
)
# all this mess is for making collaboration within the same grp possible,
# revert if the project continues
if (mode == 'COLAB' and previous_mode != 'COLAB'):
new_grp_id = user_details['group_id'] + '_' + user_details['colab_group_type'] + '_COLAB'
db.student.update(
{ '_id': userid },
{ '$set':
{ 'group_id': new_grp_id
}
}
)
logging.info("For user " + userid + ", group_id set to " + new_grp_id)
elif (mode != 'COLAB' and previous_mode == 'COLAB'):
id_parts = user_details['group_id'].split('_')
new_grp_id = id_parts[0] + '_' + id_parts[1]
db.student.update(
{ '_id': userid },
{ '$set':
{ 'group_id': new_grp_id
}
}
)
logging.info("For user " + userid + ", group_id set to " + new_grp_id)
def getSimulationInducionLoopResult(sim_exec_id, loop_id):
db = DBUtil().getDatabase()
#Loop id is junction + location, get the associated loop id based on this
idparts = loop_id.split("!")
inductionloops = db.inductionloop.find({
"junction": idparts[1],
"location": idparts[0]
})
id_search = []
for inductionloop in inductionloops:
idkey = {}
idkey['induction_id'] = inductionloop["_id"]
id_search.append(idkey)
queryResult = db.simulation_induction_data.find(
{
"sim_exec_id": ObjectId(sim_exec_id),
"$or": id_search
}, {
"endtime": 1,
"count": 1,
"vehicletype": 1
}).sort("endtime", 1)
return queryResult
def getSimulationData(simulation_id):
db = DBUtil().getDatabase()
sim_row = db.simulation.find_one({"_id": ObjectId(simulation_id)})
if sim_row is None:
return None
else:
return sim_row
def getSimulationInductionFlowRate(sim_exec_id, location, junction):
#Loop id is junction + location, get the associated lanes based on this
db = DBUtil().getDatabase()
inductionloops = db.inductionloop.find({
"junction": junction,
"location": location
})
id_search = []
for inductionloop in inductionloops:
idkey = {}
idkey['induction_id'] = inductionloop["_id"]
id_search.append(idkey)
# get all data if out type
result = db.simulation_induction_data.aggregate([{
"$match": {
"sim_exec_id": ObjectId(sim_exec_id),
"$or": id_search
}
}, {
"$group": {
"_id": "null",
"vehiclecount": {
"$sum": "$count"
},
"endtime": {
"$max": "$endtime"
}
}
}])
return result
def deleteTrafficLightLogic(self, id):
""" Delete traffic light logic from traffic light table
gets vehicle id
"""
db = DBUtil().getDatabase()
db.trafficlightlogic.remove({"_id": ObjectId(id)})
db.trafficlightlogic.remove({"associated_with_id": ObjectId(id)})
def getAssignedVMDetailsForSimID(sim_id):
db = DBUtil().getDatabase()
vm_details = db.virtualmachine.find_one({
"simulation_id": sim_id,
"status": 'IN_USE'
})
return vm_details
def getDistinctSimulatedVehicleList(sim_exec_id, loop_id):
db = DBUtil().getDatabase()
#Loop id is junction + location, get the associated loop id based on this
idparts = loop_id.split("!")
inductionloops = db.inductionloop.find({
"junction": idparts[1],
"location": idparts[0]
})
id_search = []
for inductionloop in inductionloops:
idkey = {}
idkey['induction_id'] = inductionloop["_id"]
id_search.append(idkey)
queryResult = db.simulation_induction_data.find(
{
"sim_exec_id": ObjectId(sim_exec_id),
"$or": id_search
}, {
"vehicletype": 1
}).distinct("vehicletype")
vehicle_types = []
for vehicle in queryResult:
vehicle_types.append(vehicle)
return vehicle_types
def persistTripData(sim_exec_id):
db = DBUtil().getDatabase()
tree = ElementTree()
tree.parse(TRIP_OUT_FILE)
trips = tree.findall('tripinfo')
route_tree = ElementTree()
route_tree.parse(ROUTE_OUT_FILE)
routes = route_tree.findall('vehicle')
for trip in trips:
vehicle_route = []
for route in routes:
if route.attrib['id'] == trip.attrib['id']:
edge_string = route.find('route').attrib['edges']
vehicle_route = edge_string.split()
break
db.simulation_trip_data.insert({
"sim_exec_id": sim_exec_id,
"vehicle_id": trip.attrib['id'],
"departstep": float(trip.attrib['depart']),
"duration": float(trip.attrib['duration']),
"routelength": convertMeterToFeet(float(trip.attrib['routeLength'])),
"waittime": float(trip.attrib['waitSteps']),
"speed": convertMperSecToMPH(float(trip.attrib['routeLength']) / float(trip.attrib['duration'])),
"type": trip.attrib['vType'],
"route": vehicle_route
})
def finishSimulationDB(simulation_id):
db = DBUtil().getDatabase()
db.simulation.update({
"_id": simulation_id,
}, {"$set": {
"running": False
}})
def assignVMForSimulationID(sim_id):
db = DBUtil().getDatabase()
vm_details = db.virtualmachine.find_one({"status": 'AVAIL'})
present_time = datetime.datetime.now()
if vm_details is None:
# no VM is available, check for stale VM
logging.info('no VM is available, checking for stale VM...')
stale_time = present_time - datetime.timedelta(minutes=15)
vm_details = db.virtualmachine.find_one({
"sim_start_time": {
"$lt": stale_time
},
'status': 'IN_USE'
})
if vm_details is not None:
logging.info('Found Usable VM with ID: ' + vm_details["_id"])
db.virtualmachine.update({'_id': vm_details["_id"]}, {
'$set': {
'status': 'IN_USE',
'simulation_id': ObjectId(sim_id),
'sim_start_time': present_time
}
})
vm_details = getAssignedVMDetailsForSimID(sim_id)
return vm_details
def createDefaultVehicleData(simulation_id):
db = DBUtil().getDatabase()
db.vehicle.insert({
"simulation_id": simulation_id,
"name": "Car",
"accel": "20",
"decel": "30",
"sigma": "1",
"max_speed": "100",
"length": "10",
"probability": "0.5"
})
db.vehicle.insert({
"simulation_id": simulation_id,
"name": "Bus",
"accel": "15",
"decel": "25",
"sigma": "1",
"max_speed": "70",
"length": "15",
"probability": "0.3"
})
db.vehicle.insert({
"name": "Truck",
"simulation_id": simulation_id,
"accel": "10",
"decel": "15",
"sigma": "1",
"max_speed": "50",
"length": "20",
"probability": "0.2"
})
def getSimulationQueueResult(sim_exec_id, loop_id):
#Loop id is junction + location, get the associated lanes based on this
db = DBUtil().getDatabase()
idparts = loop_id.split("!")
lanes = db.junction.find_one({"_id": idparts[1]})[idparts[0] + "_values"]
lane_search = []
for lane in lanes:
lanekey = {}
lanekey['lane_id'] = lane
lane_search.append(lanekey)
queueResult = db.simulation_queue_data.aggregate([{
"$match": {
"sim_exec_id": ObjectId(sim_exec_id),
"$or": lane_search
}
}, {
"$group": {
"_id": "$timestep",
"queueinglength": {
"$sum": "$queueinglength"
}
}
}])
return queueResult
def readVehicles(self, simulation_id):
""" Reads vehicles from vehicles table
gets simulation id
"""
db = DBUtil().getDatabase()
vehicles = db.vehicle.find({"simulation_id": ObjectId(simulation_id)})
return vehicles
def updateProblem(self, simulation_id, problem_id):
""" Update the problem that student is
working on
"""
db = DBUtil().getDatabase()
found = db.simulation.find_one({"_id": ObjectId(simulation_id)})
found["problem_id"] = problem_id
db.simulation.save(found)
db.problems.update({"problem_id": problem_id}, {
"$push": {
"history": {
"update_time": datetime.now(),
"simulation_id": simulation_id
}
}
})
asso_simids = SimAssociationDAO().readAssociatedSimIDs(simulation_id)
for sim_id in asso_simids:
logging.info('sim_id: ' + str(sim_id))
db.simulation.update({"_id": sim_id},
{'$set': {
'problem_id': problem_id
}})
# FORGOT TO ADD THE LOGIC EARLIER, QUICKFIX FOR NOW
SimulationBackupInterface(simulation_id).backupSimulation(
"SYSTEM", "PROBLEM_UPDATED")
simdata = db.simulation.find_one({"_id": sim_id})
intersection_id = "202305472"
if (simdata is not None):
group_type = getGroupTypeDB(simdata['group_id'])
if (group_type is not None) and (group_type == 'B'):
intersection_id = "202305458"
setSimulationToDefault(sim_id, problem_id, intersection_id)
def getProblemID(self, simulation_id):
""" Return the problem ID that student is
working on
"""
db = DBUtil().getDatabase()
found = db.simulation.find_one({"_id": ObjectId(simulation_id)})
return found["problem_id"]
def persistInductionData(sim_exec_id):
db = DBUtil().getDatabase()
tree = ElementTree()
tree.parse(INDUCTION_OUT_FILE)
intervals = tree.findall('interval')
for interval in intervals:
vehiclecount = int(interval.attrib['nVehContrib'])
if vehiclecount != 0:
# valid data
xmlloop_id = interval.attrib['id']
intervals_with_type = interval.findall('typedInterval')
for interval_with_type in intervals_with_type:
type_vehicle_count = int(interval_with_type.attrib['nVehContrib'])
if type_vehicle_count != 0:
db.simulation_induction_data.insert({
"sim_exec_id": sim_exec_id,
"induction_id": interval_with_type.attrib['id'],
"begintime": float(interval_with_type.attrib['begin']),
"endtime": float(interval_with_type.attrib['end']),
"vehicletype": interval_with_type.attrib['type'],
"count": type_vehicle_count
})
def getSimulationHistoryTableDB(userid):
db = DBUtil().getDatabase()
grouprow = db.student.find_one({"_id": userid}, {
'group_id': 1,
'master_group_id': 1
})
mode = getUserModeDB(userid)
logging.info('group data: ' + str(grouprow))
return db.simulation.find({
'$and': [{
"status": 'SAVED'
}, {
"mode": mode
}, {
'$or': [{
'$and': [{
"shared_with": 'GROUP'
}, {
"master_group_id": grouprow['master_group_id']
}]
}, {
'$and': [{
"shared_with": 'NONE'
}, {
"user_id": userid
}]
}]
}]
})
def getUserModeDB(userid):
db = DBUtil().getDatabase()
usermoderow = db.user_studentrole.find_one({'user_id': userid})
if usermoderow.get('user_mode') is None:
return 'GROUP'
else:
return usermoderow['user_mode']
def persistQueueingData(sim_exec_id):
# work around for invalid xml generate in sumo version 0.17.1
f = open(QUEUE_OUT_FILE, 'r')
outfile = open(QUEUE_OUT_FILE + ".cleaned", 'w')
for line in f:
linestring = line.rstrip('\n')
if(linestring == "/>"):
outfile.write(" </lanes>\n")
elif(linestring != ">"):
outfile.write(line)
outfile.flush();
f.close()
outfile.close()
db = DBUtil().getDatabase()
tree = ElementTree()
tree.parse(QUEUE_OUT_FILE + ".cleaned")
steps = tree.findall('data')
for step in steps:
lanes = step.findall('lanes/lane')
if lanes is not None:
for lane in lanes:
db.simulation_queue_data.insert({
"sim_exec_id": sim_exec_id,
"lane_id": lane.attrib['id'],
"timestep": float(step.attrib['timestep']),
"queueingtime": float(lane.attrib['queueing_time']),
#store in feet instead of meters
"queueinglength": convertMeterToFeet(float(lane.attrib['queueing_length']))
})
def setMaxSimulationStepRateDB(simulation_id):
db = DBUtil().getDatabase()
db.simulation.update({
"_id": simulation_id,
}, {"$set": {
"update_rate": 0
}})
def saveSimulationDataWithUserInput(simulation_id, label, shared_with,
user_id):
db = DBUtil().getDatabase()
existingLabel = db.simulation.find_one({
"label": label,
"status": "SAVED",
})
if existingLabel is not None:
return {'response': {'status': "exists"}}
sim_record = db.simulation.find_one({
"_id": simulation_id,
}, {"_id": 0})
sim_record['shared_with'] = shared_with
if shared_with == 'NONE':
sim_record['user_id'] = user_id
elif shared_with == 'ALL':
colab_group_record = db.studentgroup.find_one(
{
"_id": sim_record['group_id'],
}, {
"_id": 0,
"colab_group_id": 1
})
sim_record["colab_group_id"] = colab_group_record["colab_group_id"]
sim_record['status'] = 'SAVED'
sim_record['label'] = label
sim_record['backuptime'] = datetime.now()
sim_record['old_id'] = simulation_id
sim_record['backedup_by'] = user_id
id = db.simulation.insert(sim_record)
return {'response': {'status': "success", 'id': id}}
def copySimulation(destination_id, source_id):
db = DBUtil().getDatabase()
sim_record = db.simulation.find_one({"_id": source_id}, {"_id": 0})
if sim_record.get('current_exec_id') is not None:
logging.info('Source simulation: ' + str(source_id) + ' has exec id')
db.simulation.update({"_id": destination_id}, {
'$set': {
'duration': 0,
'running': False,
'problem_id': sim_record['problem_id'],
'current_exec_id': sim_record.get('current_exec_id')
}
})
else:
logging.info('Source simulation: ' + str(source_id) +
' does not have exec id, unsetting it in destination: ' +
str(destination_id))
db.simulation.update({"_id": destination_id}, {
'$set': {
'running': False,
'problem_id': sim_record['problem_id']
},
'$unset': {
'current_exec_id': ""
}
})
def restoreSimulation(sim_id,
problem_id,
junction_id=None,
lat=None,
long=None):
db = DBUtil().getDatabase()
logging.info('Source simulation: ' + str(source_id) + ' has exec id')
setvar = {
'duration': 0,
'running': False,
'problem_id': problem_id,
'current_exec_id': sim_record.get('current_exec_id')
}
if junction_id is not None:
setvar[junctions] = [junction_id]
if lat is not None:
setvar[latitude] = lat
setvar[longitude] = long
db.simulation.update({"_id": sim_id}, {
'$set': setvar,
'$unset': {
'current_exec_id': ""
}
})
def verifyCopySimulation(sim_id):
db = DBUtil().getDatabase()
sim_record = db.simulation.find_one({"_id": sim_id})
if sim_record['shared_with'] == 'ALL':
return {'response': "ALL_MODE_COPY_FAILURE"}
else:
return None
def getUserDetailsDB(user_id):
db = DBUtil().getDatabase()
user_record = db.student.find_one({"_id": user_id})
if user_record is not None:
group_record = db.studentgroup.find_one(
{"_id": user_record['group_id']})
user_record['groupname'] = group_record['name']
return user_record
def updateCollaborationUrl(self, id, collaboration_url):
""" Update url for the hangout
"""
db = DBUtil().getDatabase()
found = db.studentgroup.find_one({"_id": id})
found["collaboration_url"] = collaboration_url
found["last_update_time"] = str(datetime.now())
db.studentgroup.save(found)
