def getUpdatedPredictedGain(coordinator_id ,tx_node_id, rx_node_id, number = 6):
#this method will take a new gain measurement (update) and based on "number" measurements done before and saved in a .dat file, it will predict the next gain
#get last measurements made
recentMeasurements = GainCalculations.getMostRecentGainMeasurments(coordinator_id, tx_node_id, rx_node_id, number)
if recentMeasurements is None:
#invert tx with rx
aux = tx_node_id
tx_node_id = rx_node_id
rx_node_id = aux
print "There are no measurements available for this combination. Trying with gain_between_tx_%d_and_rx_%d.dat?(yes or no)" %(tx_node_id, rx_node_id)
choice = raw_input("")
if choice.lower() == "no":
print "You have chosen no"
return None
elif choice.lower() =="yes":
recentMeasurements = GainCalculations.getMostRecentGainMeasurments(coordinator_id, tx_node_id, rx_node_id, number)
if recentMeasurements is None:
print "There are no measurements available for this combination at all."
return None
else:
print "Invalid input, you were supposed to enter yes or no"
return None
#take a new measurement
instant_gain= GainCalculations.calculateInstantGain(coordinator_id, tx_node_id, rx_node_id, measuring_freq=2420e6, saveresults=False, transmitting_duration=6)
#append the instant gain to the end of the recentMeasurements list
if instant_gain is None:
print "Cannot measure instant gain"
return None
recentMeasurements.append(instant_gain)
predicted_gain = kalmanImplementation.getPredictedValuesVer2(recentMeasurements, standard_deviation=GainCalculations.getStandardDeviation(coordinator_id, tx_node_id, rx_node_id))[-1]
print "Gain measurement between tx_%d and rx_%d: instant gain: %.3f dB predicted gain: %.3f dB" %(tx_node_id, rx_node_id, 10.00 * math.log10(instant_gain), 10.00*math.log10(predicted_gain) )
return predicted_gain
def plotGains(date_list, y_list, xlabel, ylabel, title, ion=False):
#y_list in dB. date_list is a list of dates at which the measurements were made
if ion:
plot.ion()
else:
plot.ioff()
plot.clf()
plot.grid()
plot.title(title)
plot.xlabel(xlabel)
plot.ylabel(ylabel)
#determine minimum and maximum values of y list. Do this now because I will need it several times.
min_y_list = min(y_list)
max_y_list = max(y_list)
#change rc param
plot.rcParams.update({'font.size': 22})
#set yticks
distance = math.fabs(math.fabs(max_y_list)-math.fabs(min_y_list))/16
#round the distance to the nearest integer
distance = round(distance) - .5
distance = int(distance) + (distance>0)
if distance <1:
distance = 1
plot.yticks(numpy.arange(min_y_list, max_y_list, distance))
#plot values
plot.plot(y_list , '-',color = "black", label = "Measured gain", linewidth = 1.3)
plot.axis([0, len(y_list), min_y_list - 2, max_y_list +2])
#plot average line
k =0.00
sum = 0.00
for i in y_list:
#do average in linear scale
sum+= math.pow(10.00, float(i)/10.00)
k+=1
linear_average_gain = sum/k
plot.axhline(10.00 * math.log10(linear_average_gain), color = 'r', linewidth = 2.2, label = "Average gain %.3f dB" %(10.00*math.log10(linear_average_gain)))
#We want to shade the night measurements with a color, and the day measurements with other color
#make 2 lists, which represents the intervals for day and night. day intervals : [ [a,b, day], [c,d, day] ,[e,f, day] ]
day_intervals = []
night_intervals = []
#determine the night and day intervals
for i in range(0, len(date_list)-1):
#for day. We want to determine index interval y_list for which date_list has a day hours
if (date_list[i].hour ==12 or date_list[i].hour == 13) and i==0 :
first_index = i
elif (date_list[i].hour == 12 or date_list[i].hour == 13) and (date_list[i-1].hour != 12 and date_list[i-1].hour != 13):
first_index = i
if (date_list[i].hour == 12 or date_list[i].hour == 13) and (date_list[i+1].hour != 12 and date_list[i+1].hour != 13):
last_index = i
day_intervals.append([first_index, last_index, date_list[i].day])
if (date_list[i].hour == 12 or date_list[i].hour == 13) and (date_list[i+1].hour == 12 or date_list[i+1].hour == 13) and (i+1) == len(date_list)-1:
last_index =i+1
day_intervals.append([first_index, last_index, date_list[i].day])
#same thing for night
if (date_list[i].hour ==21 or date_list[i].hour == 22) and i==0 :
first_index = i
elif (date_list[i].hour == 21 or date_list[i].hour == 22) and (date_list[i-1].hour != 21 and date_list[i-1].hour != 22):
first_index = i
if (date_list[i].hour == 21 or date_list[i].hour == 22) and (date_list[i+1].hour != 21 and date_list[i+1].hour != 22):
last_index = i
night_intervals.append([first_index, last_index, date_list[i].day])
if (date_list[i].hour == 21 or date_list[i].hour == 22) and (date_list[i+1].hour == 21 or date_list[i+1].hour == 22) and (i+1) == (len(date_list)-1):
last_index =i+1
night_intervals.append([first_index, last_index, date_list[i].day])
#plot vertical span
for i in range(0, len(day_intervals)):
plot.axvspan(day_intervals[i][0], day_intervals[i][1], color = "white", alpha = 0.1)
for i in range(0, len(night_intervals)):
plot.axvspan(night_intervals[i][0], night_intervals[i][1], color = "gray", alpha = 0.2)
#plot arrows from maximum to minimum value of gains
arrow_length = math.fabs(math.fabs(max_y_list) - math.fabs(min_y_list))
plot.arrow(len(y_list)/2, min_y_list, 0, arrow_length, head_width = 0.02 * len(y_list), length_includes_head = True, color = "blue",head_length = arrow_length*0.05, linewidth = 2)
plot.arrow(len(y_list)/2, max_y_list, 0, -arrow_length, head_width = 0.02 * len(y_list), length_includes_head = True, color = "blue", head_length = arrow_length*0.05, linewidth = 2)
plot.text(len(y_list)/2 +0.5, min_y_list + 0.1*arrow_length, "%.3f dB" %arrow_length, fontsize = 22, weight = 600)
#plot maximum and minimum lines
plot.axhline(max_y_list, color = 'black', linestyle = "--")
plot.text(0.4 * len(y_list), max_y_list +0.5 , "%.3f dB" % max_y_list, color = "red", weight = 600, fontsize = 22)
plot.axhline(min_y_list, color = 'black', linestyle = '--')
plot.text(0.4 * len(y_list), min_y_list - 1, "%.3f dB" % min_y_list, color = "red", weight = 600, fontsize = 22)
#I want to plot the predicted gain value using the KalmanFilter. For this I need linear values
y_list_linear = []
for i in range(0, len(y_list)):
#dB -> linear
y_list_linear.append(math.pow(10.00, float(y_list[i])/10.00))
#plot predicted gain using Kalman filter
y_list_predictedVer2 = kalmanImplementation.getPredictedValuesVer2(y_list_linear)
for i in range(0, len(y_list_predictedVer2)):
y_list_predictedVer2[i] = 10.00 * math.log10(y_list_predictedVer2[i])
#now plot y_list_predictedVer2
plot.plot(y_list_predictedVer2, '-', color = "yellow", label = "Predicted gain", linewidth = 2.2)
#plot deviations? standard deviation or % from maximum deviation?
#get standard deviation
standard_deviation = kalmanImplementation.getStandardDeviation(y_list_linear)
plot.axhspan(10.00*math.log10(linear_average_gain-standard_deviation),10.00*math.log10(linear_average_gain+standard_deviation), facecolor='black', alpha=0.20)
#plot arrow
arrow_length = 10.00*math.log10(linear_average_gain+standard_deviation) - 10.00*math.log10(linear_average_gain-standard_deviation)
plot.arrow(len(y_list)/2 - 0.3*len(y_list)/2, 10.00*math.log10(linear_average_gain-standard_deviation), 0, arrow_length, head_width = 0.6*arrow_length, length_includes_head = True, color = "green",head_length = arrow_length*0.09, linewidth = 3)
plot.arrow(len(y_list)/2 - 0.3*len(y_list)/2, 10.00*math.log10(linear_average_gain+standard_deviation), 0, -arrow_length, head_width = 0.6*arrow_length, length_includes_head = True, color = "green",head_length = arrow_length*0.09, linewidth = 3)
plot.text(len(y_list)/2 - 0.3*len(y_list)/2, 10.00*math.log10(linear_average_gain+standard_deviation)+0.5, "%.3f dB" %arrow_length, color = "green", weight=600, fontsize = 22)
#plot a text with number of measurements
plot.text(2, min(y_list)-1, "Number of\nmeasurements:\n%d" %len(y_list), color = "black", weight = 700, fontsize = 22)
#determining the mse for average
sum_tmp = 0
for i in y_list_linear:
sum_tmp+=math.pow((linear_average_gain-i), 2)
mse_average = sum_tmp/len(y_list_linear)
#determining the mse for kalman
y_list_predictedVer2 = kalmanImplementation.getPredictedValuesVer2(y_list_linear)
sum_tmp = 0
for i in range(0, len(y_list_linear)):
sum_tmp+=math.pow(y_list_predictedVer2[i]-y_list_linear[i], 2)
mse_kalman = sum_tmp/len(y_list_linear)
#plot.plot([],label = "Avg mse: %f" %(mse_average))
#plot.plot([],label= "Kalman mse: %f" %(mse_kalman))
print mse_average
print mse_kalman
leg = plot.legend(loc = 'upper right', bbox_to_anchor=(1.005, 1.01), fontsize = 22)
leg.get_frame().set_alpha(0.7)
#maximize the window
mng = plot.get_current_fig_manager()
mng.resize(*mng.window.maxsize())
fig = plot.gcf()
fig.set_size_inches( (19, 11) )
try:
os.mkdir("./gain plots")
except:
pass
plot.savefig("./gain plots/%s.png" %(title), dpi=250)
#return
if ion:
plot.draw()
else:
plot.show()