def _filter_res(filename):
"""
Reads files containing results of either algorithm1 or algorithm2,
and finds the results that are significant according to the
following criteria:
* waiting:
- Interval is contained in the non-negative part of the real axis.
- Interval is wider than 90 seconds.
- More than 50 points are in the solution region defined as
{(x,y): s<=x<=e, x-s <= y <= x-s+120}.
* blocking:
- Interval is contained in the non-negative part of the real axis.
- Interval is wider than 120 seconds.
- More than 50 points are in the solution region defined as A U B, where
A = {(x,y): s<=x<=e, x-s <= y <= x-s+120}.
B = {(x,y): e<=x<=e+120, max(0, x-e-120) <= y <= min(x-e, e-s)}
"""
algtype = filename[18:-4]
results = csv.reader(open(filename), delimiter=',')
firstrow = True
outfile = open(filename[:-4] + '_sig.csv', 'w')
reswriter = csv.writer(outfile, delimiter=',')
for row in results:
if firstrow:
firstrow = False
reswriter.writerow(row)
else:
if int(float(row[5])) > 0:
if int(float(row[6])) > int(float(row[5])):
if algtype == 'waiting':
data = get_matching_delay(row[1], row[0],
row[3], row[2])
#Check if solution region has more than 50 points
if delaycounter(data[0], data[1], row[5:], 120) > 50:
if int(float(row[6])) - int(float(row[5])) > 90:
#save
reswriter.writerow(row)
else:
#blocking
data = get_matching_delay(row[1], row[0],
row[3], row[2])
#Check if solution region has more than 50 points
if delaycounter(data[0], data[1], row[5:], 120) > 50:
if int(float(row[6])) - int(float(row[5])) > 120:
#save
reswriter.writerow(row)
outfile.close()
from plot_trains import scatter_trains
from get_matching_delay import get_matching_delay
from train_algos import algorithm1_mod, algorithm1
from delaycounter import delaycounter
from new_alg1mod import algorithm1_mod2
delayer, victim = get_matching_delay('1619','45961', False, True)
import csv
algres = (90, -842, -72)
print delaycounter(delayer, victim, (algres[1], algres[2]),
algtype = 'blocking')
scatter_trains(delayer, victim, algres, waiting = False, show = True)
CSV_WRITER2 = csv.writer(open('ALGRES/' + FILENAME[11:21] + '_blocking' +
'.csv', 'w'), delimiter=',')
#write header
CSV_WRITER1.writerow(['VICTIM', 'DELAYER', 'ISVICTIMARRIVING',
'ISDELAYERARRIVING', 'NUMOFPOINTS',
'START', 'END'])
CSV_WRITER2.writerow(['VICTIM', 'DELAYER', 'ISVICTIMARRIVING',
'ISDELAYERARRIVING', 'NUMOFPOINTS',
'START', 'END'])
for train in DATASTRUCTURE:
for delayer in DATASTRUCTURE[train]:
delayer_arr = FILENAME[18:21] == 'ARR'
train_arr = FILENAME[11:14] == 'ARR'
delay = get_matching_delay(delayer, train, delayer_arr, train_arr)
#run algorithms
res1 = algorithm1(array(delay[0]), array(delay[1]))
res2 = algorithm2(array(delay[0]), array(delay[1]))
if res1[2] - res1[1] > 90:
CSV_WRITER1.writerow([train, delayer, int(train_arr),
int(delayer_arr), res1[0], res1[1],
res1[2]])
if res2[2] - res2[1] > 120:
CSV_WRITER2.writerow([train, delayer, int(train_arr),
int(delayer_arr), res2[0], res2[1],
res2[2]])
from get_matching_delay import get_matching_delay
import sys
import csv
victim = sys.argv[1]
delayer = sys.argv[2]
victim_dir = sys.argv[3] == 'ARR'
delayer_dir = sys.argv[4] == 'ARR'
victim_data, delayer_data = get_matching_delay(victim, delayer)
if delayer == '816':
print delayer_data
writer = csv.writer(open(victim + sys.argv[3] + delayer + sys.argv[4] + '.csv',
'w'))
writer.writerow([victim, delayer])
for i in range(len(victim_data)):
writer.writerow([delayer_data[i], victim_data[i]])
from get_matching_delay import get_matching_delay
import csv
delayer = "3743"
victim = "239"
del_dir = False
vic_dir = False
del_data, vic_data = get_matching_delay(delayer, victim, del_dir, vic_dir)
outfile = open("temp.csv", "w")
writer = csv.writer(outfile, delimiter=",")
# write header
writer.writerow([delayer, victim])
for i in range(len(del_data)):
writer.writerow([del_data[i], vic_data[i]])
outfile.close()
k +=1
i += 1
if sol:
return (k_star, s_star, e_star)
else:
return algorithm1(train1, train2)
def test():
x = [1, 1, 2, 6, 7, 9, 3, 4, 2, 3, 7, 7, 7]
y = [0, 3, 5, 3, 8, 2, 5, 5, 7, 2, 6, 4, 2]
result = algorithm1_mod3(x, y)
print result
print delaycounter(x, y, (result[1], result[2]))
if __name__ == '__main__':
delayer, victim = get_matching_delay(1052, 304, True, False)
res1 = algorithm1_mod3(delayer, victim)
res2 = algorithm1_mod2(delayer, victim)
#res3 = algorithm1_mod(delayer, victim)
res4 = algorithm1_mod4(delayer, victim)
res5 = algorithm1_mod5(delayer, victim)
#test()
print res1
print delaycounter(delayer, victim, (res1[1], res1[2]))
scatter_trains(delayer, victim, res1)
print res2
print delaycounter(delayer, victim, (res2[1], res2[2]))
scatter_trains(delayer, victim, res2)
#print res3
#print delaycounter(delayer, victim, (res3[1], res3[2]))
#scatter_trains(delayer, victim, res3)
