def knn_validate(data, kernel, metric, k_neighbors, show_plot):
plot = Plot()
matrix_full = [[0, 0], [0, 0]]
y_predict_arr = []
for i in range(len(data)):
data.updateTrainTest(i)
trainDots, trainClass = data.getDotsByMode('train', False)
testDots, testClass = data.getDotsByMode('test', False)
knn = KNN(kernel=kernel, metric=metric, neighbors=k_neighbors)
knn.fit(trainDots, trainClass)
y_predict, distance = knn.predict(testDots)
y_predict_arr.append(y_predict[0])
if show_plot:
tDots = np.array(trainDots)
tCls = np.array(trainClass)
plot.knn(tDots[tCls == 1.0], tDots[tCls == -1.0], distance, testDots[0], y_predict[0])
matrix = get_metrics(y_predict, testClass)
matrix_full[0][0] += matrix[0][0]
matrix_full[0][1] += matrix[0][1]
matrix_full[1][0] += matrix[1][0]
matrix_full[1][1] += matrix[1][1]
return y_predict_arr, get_f_measure(matrix_full), matrix_full
def fillTab(frameNumber, tabName, labelNumber, portNumber):
global Graph1, Graph2
tkToggleScreenButton = tk.Button(
frameNumber,
text='Toggle Screen',
command=lambda: toggleScreen(tabName, portNumber))
tkToggleScreenButton.grid(column=0, row=1, sticky='W')
tkToggleModeButton = tk.Button(
frameNumber,
text='Toggle mode',
command=lambda: toggleMode(tabName, labelNumber))
tkToggleModeButton.grid(column=0, row=2, sticky='W')
tkGetDataButton = tk.Button(frameNumber, text='Get data', command=getData)
tkGetDataButton.grid(column=0, row=1, sticky='E')
temperatureLabel = tk.Label(frameNumber, text='Temperature: ')
temperatureLabel.grid(column=0, row=5, sticky='W')
brightnessLabel = tk.Label(frameNumber, text='Brightness: ')
brightnessLabel.grid(column=1, row=5, sticky='W')
Graph1 = Plot(frameNumber, 0, 6)
Graph2 = Plot(frameNumber, 1, 6)
labelNumber = tk.Label(frameNumber,
text='Mode: %s' % (deviceInfo[tabName]['mode']))
labelNumber.grid(column=0, row=3, sticky='W')
return Graph1, Graph2
def svm_validate(data, kernel, svm_C, show_plot):
plot = Plot()
matrix_full = [[0, 0], [0, 0]]
y_predict_arr = []
for i in range(len(data)):
data.updateTrainTest(i)
trainDots, trainClass = data.getDotsByMode('train', True)
testDots, testClass = data.getDotsByMode('test', True)
clf = SVM(kernel=kernel, C=svm_C)
clf.fit(trainDots, trainClass)
y_predict = clf.predict(testDots)
y_predict_arr.append(y_predict[0])
if show_plot:
plot.smv(trainDots[trainClass == 1], trainDots[trainClass == -1], clf, testDots[0], y_predict[0])
matrix = get_metrics(y_predict, testClass)
matrix_full[0][0] += matrix[0][0]
matrix_full[0][1] += matrix[0][1]
matrix_full[1][0] += matrix[1][0]
matrix_full[1][1] += matrix[1][1]
return y_predict_arr, get_f_measure(matrix_full), matrix_full
def plot_summary(self):
# Generate summary plot from chosen lattice and Hamiltonian
K = -(4 * np.pi) / (3 * np.sqrt(3))
if self.Haldane.value() != 0 or self.AntiHaldane.value() != 0:
Lat = lattice('Sheet', 'Haldane') # Get correct lattice
else:
Lat = lattice('Sheet', 'Monolayer')
if self.AntiHaldane.value() != 0:
H = Hamiltonian(Lat, self.Hoppingt2.value(), 0, 0, self.AntiHaldane.value())
H.add_antiHaldane() # If selected, add complex hopping
else:
H = Hamiltonian(Lat, self.Hoppingt2.value(), 0, 0, self.Haldane.value()) # If selected, add complex hopping
if self.Magneticfield2.value() != 0: # Add magnetic field
H.add_magnetic_field(self.Magneticfield2.value(), 'Perpendicular')
if self.OnsiteV2.value() != 0: # Add sublattice imbalance
H.add_lattice_imbalance(self.OnsiteV2.value())
# Generate summary plot
P = Plot(H)
P.summary(self.Nk.value(), K, 0, self.xIndex.value(), self.yIndex.value(), self.dxIndex.value(),
self.dyIndex.value())
plt.show()
def main(args):
# Get current observer location and antenna pointing direction
if args.use_config:
config = read_config()
lat, lon = config['latitude'], config['longitude']
alt, az = config['altitude'], config['azimuth']
if "none" in (lat, lon, alt, az):
print('Please check your config file or use command line arguments.')
quit()
else:
lat, lon = args.latitude, args.longitude
alt, az = args.altitude, args.azimuth
# Get current equatorial and galactic coordinates of antenna RA and Declination
Coordinates_class = Coordinates(lat = lat, lon = lon, alt = alt, az = az)
ra, dec = Coordinates_class.equatorial()
gal_lat, gal_lon = Coordinates_class.galactic()
# Receives and writes data
Receiver_class = Receiver(frequency = args.frequency, sample_rate = args.sample_rate, ppm = args.ppm, resolution = args.resolution, num_FFT = args.num_FFT)
freqs, data, SNR = Receiver_class.receive()
# Plots data
print('Plotting data...')
name = f'ra={ra},dec={dec},SNR={SNR}'
Plot_class = Plot()
Plot_class.plot(freqs = freqs, data = data, name = name)
def main():
x_data = np.linspace(-1000, 1000, 200)
root = tkinter.Tk()
plot = Plot(-500, 500, -500, 500, "g", root)
plot.plot_data(x_data)
root.mainloop()
def compareUpload(request):
"""
Upload function of Compare mode
"""
context_dict = {}
if request.method == "POST":
try:
filename = request.FILES['file'].name
axis = request.POST.get("axis")
values = request.POST.get("values")
# Upload the second file
filename_second = request.FILES['files'].name
axis_second = request.POST.get("axiss")
values_second = request.POST.get("valuess")
info = Plotinfo(filename, axis, values)
info_second = Plotinfo(filename_second, axis_second, values_second)
context_dict['show'] = 'yes'
nu = float(values)
nu_second = float(values_second)
result = Plot(filename, axis, nu, figsize=(4.5, 3.8))
result_second = Plot(filename_second, axis_second, nu_second, figsize=(4.5, 3.8))
context_dict['info'] = info
context_dict['info_second'] = info_second
context_dict['graph1'] = result
context_dict['graph2'] = result_second
context_dict['vis_success'] = 'True'
return render(request, 'compareMode.html', context=context_dict)
except:
context_dict['vis_success'] = 'False'
context_dict['errorinfo'] = "You selected the wrong file or entered the wrong axis or missing an input"
return render(request, 'compareMode.html', context=context_dict)
def findChiParams(self):
dataFileName = 'testData.txt'
function = Function()
chiLinear = ChiSquare(function.evalLinear, dataFileName)
optimiser = Optimise()
#m = params[0]
#c = params[1]
paramsGuess = [0., 1.]
paramsAccuracy = [0.000000001, 0.000000001]
paramsJump = [1., 1.]
#evals minimum m and c for our ChiSquare
params = optimiser.min(chiLinear.evalChiSquare, paramsGuess,
paramsJump, paramsAccuracy, [])
minM = params[0]
minC = params[1]
minChi = chiLinear.evalChiSquare(params)
#finding err of values in params by finding where the chiSquare
#increases by 1 either side of the minimum
mRootParamGuess = [minM + 1., minC]
cRootParamGuess = [minM, minC + 1.]
rootParamsJump = [0.0001, 0.001]
rootParamsAccuracy = [0.000001, 0.000001]
mErrPos = abs(
optimiser.equalTo(
(minChi + 1), chiLinear.evalChiSquare, mRootParamGuess,
rootParamsJump, rootParamsAccuracy, [1])[0] - minM)
cErrPos = abs(
optimiser.equalTo(
(minChi + 1), chiLinear.evalChiSquare, cRootParamGuess,
rootParamsJump, rootParamsAccuracy, [0])[1] - minC)
mErrNeg = abs(
optimiser.equalTo(
(minChi + 1), chiLinear.evalChiSquare, [minM - mErrPos, minC],
rootParamsJump, rootParamsAccuracy, [1])[0] - minM)
cErrNeg = abs(
optimiser.equalTo(
(minChi + 1), chiLinear.evalChiSquare, [minM, minC - cErrPos],
rootParamsJump, rootParamsAccuracy, [0])[1] - minC)
mErrMean = (mErrPos + mErrNeg) / 2.
cErrMean = (cErrPos + cErrNeg) / 2.
print("")
print("[m,c]:\t" + str(np.around(np.array(params), 6)) + "\n")
print("mErr:\t+" + str(np.round(mErrPos, 6)) + "\t-" +
str(np.round(mErrNeg, 6)))
print("mean:\t" + str(np.round(mErrMean, 6)) + "\n")
print("cErr:\t+" + str(np.round(cErrPos, 6)) + "\t-" +
str(np.round(cErrNeg, 6)))
print("Mean:\t" + str(np.round(cErrMean, 6)))
print("")
#self.plotChiAroundMin(chiLinear.evalChiSquare, params, [mErrPos, cErrPos], [mErrNeg, cErrNeg])
plotter = Plot()
plotter.plotChiAroundMin(chiLinear.evalChiSquare, params,
[mErrPos, cErrPos], [mErrNeg, cErrNeg])
def __init__(self,x,y,basic_path,nameFileEnd, startfillnumber, endfillnumber):
Plot.__init__(self,x,y)
loader=LoadDataFromFiles(basic_path, nameFileEnd, startfillnumber, endfillnumber)
loader.load(basic_path+"Fillnumbers.txt","Condition")
dataObject=loader.getData()
self.datax=eval("dataObject.get"+x+"()")
self.datay=eval("dataObject.get"+y+"()")
def autoscale(self):
"""Autoscale now the Heroku App.
This method gonna check the response time through Pingdom API, and adapt the number of dynos according to it.
If the measured response time is below the response time low score defined in the HAConf object, the Heroku app will be scaled up.
If the measured response time is over the response time high score defined in the HAConf object, the Heroku app will be scaled down.
If the measured response time is between the response time low score and the response time high score :
- If the tendency of the response times is strongly rising: the Heroku app will be scaled up
- If the tendency of the response times is strongly down: the Heroku app will be scaled down
"""
self._log("----> Start autoscale...")
end = datetime.utcnow()
end_time = int(time.mktime(end.timetuple()))
begin = end - timedelta(minutes = self._conf.getPingdomCheckPeriod())
begin_time = int(time.mktime(begin.timetuple()))
self._log("Pingdom period to request: Begin: {0}, End: {1}".format(begin.isoformat(), end.isoformat()))
checks = self._pd_wrapper.getChecks(self._conf.getPingdomCheckId(), begin_time, end_time)
rep_time_avg = getResponseTimeAvg(checks)
self._log("Avg resp time: {0}".format(rep_time_avg))
t = datetime.now()
reg_coef = computeLinearRegressionModel(checks)
self._log("Linear regression: y' = a * x + b with a = {0}, b = {1}".format(reg_coef[0], reg_coef[1]))
if(rep_time_avg < self._conf.getResponseTimeLow()):
if(reg_coef[0] < 0):
self._removeDyno()
settlement = "Revove dyno"
else:
self._log("===> Do nothing...")
settlement = "Do nothing"
elif(rep_time_avg >= self._conf.getResponseTimeLow() and
rep_time_avg < self._conf.getResponseTimeHigh()):
if(reg_coef[0] > self._conf.getResponseTimeTrendHigh()):
self._addDyno()
settlement = "Add dyno"
elif(reg_coef[0] < self._conf.getResponseTimeTrendLow()):
self._removeDyno()
settlement = "Revove dyno"
else:
self._log("===> Do nothing...")
settlement = "Do nothing"
else:
if(reg_coef[0] > 0):
self._addDyno()
settlement = "Add dyno"
else:
self._log("===> Do nothing...")
settlement = "Do nothing"
if(self._conf.isPlotting()):
Plot.plot(checks, rep_time_avg, reg_coef, self._conf.getResponseTimeLow(), self._conf.getResponseTimeHigh(), settlement, self._conf.getGraphsFolder() + '/' + t.strftime("%d-%m-%Y_%H-%M-%S") + "_out.pdf", "pdf")
def setup(self):
self.memory_map = self.mission.get_memory_map()
if self.settings.get("plot"):
# Setup memory map plot
from Plot import Plot
self.plot = Plot(self.environment, self.memory_map)
if self.rf_sensor is not None:
self.rf_sensor.activate()
def main(args):
config = read_config()
# Get y-axis limits from config
low_y, high_y = config['low_y'], config['high_y']
# Get current observer location and antenna pointing direction
if args.use_config:
lat, lon = config['latitude'], config['longitude']
alt, az = config['altitude'], config['azimuth']
if "none" in (lat, lon, alt, az):
print('Please check your config file or use command line arguments.')
quit()
else:
lat, lon = args.latitude, args.longitude
alt, az = args.altitude, args.azimuth
# Checks if 360 is divisable with the degree interval and calculates number of collections
num_data = 360/args.interval if args.interval != 0 else 0
second_interval = 24*60**2/num_data if num_data > 0 else None
if float(num_data).is_integer():
for i in range(int(num_data)+1):
current_time = datetime.utcnow()
if num_data != 0:
end_time = current_time + timedelta(seconds = second_interval)
# Get current equatorial and galactic coordinates of antenna RA and Declination
Coordinates_class = Coordinates(lat = lat, lon = lon, alt = alt, az = az)
ra, dec = Coordinates_class.equatorial()
gal_lat, gal_lon = Coordinates_class.galactic()
galactic_velocity = Coordinates_class.galactic_velocity(gal_lat, gal_lon)
# Receives and writes data
Receiver_class = Receiver(sample_rate = args.sample_rate, ppm = args.ppm, resolution = args.resolution, num_FFT = args.num_FFT, num_med = args.num_med)
freqs, data = Receiver_class.receive()
# Plots data
print('Plotting data...')
Plot_class = Plot(freqs = freqs, data = data, galactic_velocity = galactic_velocity)
Plot_class.plot(ra = ra, dec = dec, low_y = low_y, high_y = high_y)
if num_data != 0:
time_remaining = end_time - datetime.utcnow()
print(f'Waiting for next data collection in {time_remaining.total_seconds()} seconds')
time.sleep(time_remaining.total_seconds())
clear_console()
else:
print('360 must be divisable with the degree interval, eg. 360%\interval=0')
quit()
def createPredictionPlot():
if (request.method == 'POST'):
data = request.get_json()
predictDate = data['predictDate']
payment = data['payment']
plotCreator = Plot()
graphJSON = plotCreator.createPredictionPlot(predictDate, payment)
print(request.url) #localhost:5000/electric/pattern
return graphJSON
class MainManager(Aidlab.Aidlab):
def __init__(self):
super().__init__()
self.plot = Plot()
def did_connect(self, aidlab):
print("Connected to: ", aidlab.address)
def did_disconnect(self, aidlab):
print("Disconnected from: ", aidlab.address)
def did_receive_ecg(self, aidlab, timestamp, values):
self.plot.add(values[0])
def createSchLinePlot():
print('schLinePlot')
if (request.method == 'POST'):
data = request.get_json()
predictDate = data['predictDate']
plotCreator = Plot()
graphJSON = plotCreator.createSchLinePlot(predictDate)
print(request.url) #localhost:5000/electric/pattern
return graphJSON
def upper_edge(self):
# Calculate bandstructure and highlight edge states
Lat = lattice('Ribbon', self.SelectEdge.currentText()+' '+self.SelectStack.currentText(), self.NUnit.value()) # Create lattice
H = Hamiltonian(Lat, self.Hoppingt.value(), self.Hoppingtprime.value())# Create Hamiltonian
if self.Magneticfield.value() != 0:# Add magnetic field
H.add_magnetic_field(self.Magneticfield.value(), self.SelectBBil.currentText())
if self.OnsiteV.value() != 0:# Add lattice imbalance
H.add_lattice_imbalance(self.OnsiteV.value())
P = Plot(H)
P.upper_edge()
def calc_bands(self):
# Calculate bandstructure of finite system
Lat = lattice('Ribbon', self.SelectEdge.currentText()+' '+self.SelectStack.currentText(), self.NUnit.value()) # Create lattice
H = Hamiltonian(Lat, self.Hoppingt.value(), self.Hoppingtprime.value())# Create Hamiltonian
if self.Magneticfield.value() != 0:# Add magnetic field
H.add_magnetic_field(self.Magneticfield.value(), self.SelectBBil.currentText())
if self.OnsiteV.value() != 0:# Add lattice imbalance
H.add_lattice_imbalance(self.OnsiteV.value())
P = Plot(H)
P.show_rib()
def createLinePlot():
if (request.method == 'POST'):
data = request.get_json()
startDate = data['startDate']
endDate = data['endDate']
period = int(data['period'])
plotCreator = Plot()
graphJSON = plotCreator.createLinePlot(startDate, endDate, 'abc', period)
print(request.url) #localhost:5000/electric/pattern
return graphJSON
def train():
"""
Trains the model using the agent and the game
"""
# For Plots
plot = Plot()
plotScores = list()
plotMeanScores = list()
totalScore = 0
meanScore = 0
highestScore = 0
agent = Agent()
game = SnakeGame(ai=True)
while True:
# Get old/current state
stateOld = agent.getState(game)
# Get move based on current state
finalAction = agent.getAction(stateOld)
# Perform the move and get next state
reward, done, score = game.playStep(finalAction)
stateNew = agent.getState(game)
# Train short memory
agent.trainShortMemory(stateOld, finalAction, reward, stateNew, done)
# Remember (to store in the memory)
agent.remember(stateOld, finalAction, reward, stateNew, done)
if done:
# Train long memory
game.reset()
agent.games += 1
agent.trainLongMemory()
if score > highestScore:
highestScore = score
agent.model.save()
print('Game', agent.games, 'Score', score, 'High Score:', highestScore)
plotScores.append(score)
totalScore += score
meanScore = totalScore / agent.games
plotMeanScores.append(meanScore)
plot.plot(plotScores, plotMeanScores)
def plot_summary(self):
# Generate summary plot from chosen lattice and Hamiltonian
K = -(4 * np.pi) / (3 * np.sqrt(3))
Lat = lattice('Sheet', self.SelectStack.currentText()) # Create lattice
H = Hamiltonian(Lat, self.Hoppingt2.value(), self.Hoppingtprime2.value()) # Create Hamiltonian
if self.Magneticfield2.value() != 0: # Add magnetic field
H.add_magnetic_field(self.Magneticfield2.value(), self.SelectBBil.currentText(), self.BAngle.value())
if self.OnsiteV_2.value() != 0: # Add layer polarization
H.add_sublattice_imbalance(self.OnsiteV_2.value())
P = Plot(H)
P.summary(self.Nk.value(), K, 0, self.xIndex.value(), self.yIndex.value(), self.dxIndex.value(), self.dyIndex.value())
def putOutput(self, ticker, metrics, yahooVector, merged): print '\n---------- '+ticker+' THE RESULTS ----------' print 'Sharpe ratio\t\t ==> ' + str(round(metrics[0], 2)) print 'Company Sharpe ratio\t ==> ' + str(round(metrics[8], 2)) print 'Number of trades\t ==> ' + str(metrics[1][0]) print 'Total days\t\t ==> ' + str(len(metrics[6])) print 'Percentage in\t\t ==> ' + str(round(metrics[1][1]*100, 2)) + '%' print 'Wins, losses\t\t ==> ' + str(metrics[2]) print 'Average win, loss\t ==> ' + str(metrics[3]) print 'Expectancy\t\t ==> ' + str(round(metrics[4], 4)) print '---------------------------------------\n' print 'Plotting results..' we = Plot() # We want to plot equity, stock performance, and sentiment. we.plotThis(ticker, merged, metrics[6], metrics[7])
def generate_2D_plots(self, data_dictionary):
'''callback function... data_dictionary is a dictionary of
data_set dictionaries. The data_set keys are x_dataFrame,
y_dataFrame, x_series, y_series, x_axis, y_axis, title, style...'''
for key in data_dictionary:
idx = self.parent.project.get_next_figure_index()
self.parent.project.add_figure(Plot(idx, data_dictionary[key]))
def update_plots():
import wx
while len(plots) < len(plot_data): plots.append(Plot())
for plot,data in zip(plots,plot_data):
try:
if plot.data != data: plot.data = data; plot.update()
except wx.PyDeadObjectError: pass
def parseXml(node):
block = Block()
block.canBuild = ast.literal_eval(node.getAttribute("canBuild"))
block.blockType = int(node.getAttribute("type"))
for child in node.childNodes:
block.addPlot(Plot.parseXml(child))
return block
def bargraph_text(request):
variableList = ["", "mdn", "pon", "spi", "spei", "pdsi", "pzi", "scpdsi"]
if 'run_avg' in request.GET:
run_avg = request.GET['run_avg']
if not run_avg:
runAvg = 0
else:
runAvg = int(run_avg)
lat = float(request.GET['lat'])
lon = float(request.GET['lon'])
endYear = int(request.GET['end_year'])
startYear = int(request.GET['start_year'])
variable = int(request.GET['variable'])
variable = variableList[variable]
month = int(request.GET['month'])
span = int(request.GET['span'])
text = Plot(lat=lat,
lon=lon,
startYear=startYear,
endYear=endYear,
variable=variable,
month=month,
span=span,
runavg=runAvg,
data=None).getText()
data = []
for value in text:
data.append(value)
return render_to_response(
'print.html', {'data': data}) #, {'year': data}, {'mean': data})
def accurateUpload(request):
"""
Upload function of Accurate mode
"""
context_dict = {}
if request.method == "POST":
try:
filename = request.FILES['file'].name
axis = request.POST.get("axis")
values = request.POST.get("values")
info = Plotinfo(filename, axis, axis_value=values)
# Check value range
if info["fixedmin"] <= float(values) <= info["fixedmax"]:
context_dict['show'] = 'yes'
nu = float(values)
result = Plot(filename, axis, nu)
context_dict['info'] = info
context_dict['graph1'] = result
context_dict['vis_success'] = 'True'
return render(request, 'accurateMode.html', context=context_dict)
else:
context_dict['vis_success'] = 'Out'
context_dict['errorinfo'] = "The Value is out of range. The value range of the axis you choose is " + \
str(info["fixedmin"]) + " to " + str(info["fixedmax"]) + \
" (" + info["fixedaxis"] + ")" + '.'
return render(request, 'accurateMode.html', context=context_dict)
except:
context_dict['vis_success'] = 'False'
context_dict['errorinfo'] = "You selected the wrong file or entered the wrong axis or missed an input"
return render(request, 'accurateMode.html', context=context_dict)
def easyUpload(request):
"""
Upload function of Easy mode
"""
context_dict = {}
if request.method == "POST":
try:
filename = request.FILES['file'].name
axis = request.POST.get("axis")
info = Plotinfo(filename, axis)
zmin = info['zmin']
zmax = info['zmax']
context_dict['info'] = info
context_dict['filename'] = str(request.POST)
y = numpy.linspace(zmin, zmax, 10, endpoint=True).tolist()
jslist = []
context_dict['show'] = 'yes'
# Create 10 Range
for index in range(0, 10):
context_dict['graph' + str(index)] = Plot(filename, axis, round(y[index], 2))
jslist.append(round(y[index], 2))
context_dict['jsl'] = jslist
context_dict['vis_success'] = 'True'
return render(request, 'easyMode.html', context=context_dict)
except:
context_dict['vis_success'] = 'False'
context_dict['errorinfo'] = "Please upload the correct file and choose a valid axis"
return render(request, 'easyMode.html', context=context_dict)
def generate_maze(self, x, y):
self.clear_widgets()
self.number_of_cols = x
self.number_of_rows = y
for x in range(self.number_of_cols):
for y in range(self.number_of_rows):
print(f"{x}/{self.number_of_cols}, {y}/{self.number_of_rows}")
self.add_widget(Plot())
def calc_edge(self):
# Calculate bandstructure from chosen lattice and Hamiltonian with colormap highlighting edge states
Lat = lattice(
'Ribbon',
self.SelectEdge.currentText() + ' ' +
self.SelectStack.currentText(), self.NUnit.value())
H = Hamiltonian(Lat, self.Hoppingt.value(), self.Hoppingtprime.value())
if self.Magneticfield.value() != 0:
H.add_magnetic_field(self.Magneticfield.value(),
self.SelectBBil.currentText())
if self.OnsiteV.value() != 0:
H.add_lattice_imbalance(self.OnsiteV.value())
P = Plot(H)
P.calc_edge()
def createBarLinePlot():
if (request.method == 'POST'):
data = request.get_json()
startDate = data['startDate']
endDate = data['endDate']
payment = int(data['payment'])
period = int(data['period'])
contractElec = float(data['contractElec'])
plotCreator = Plot()
graphJSON = plotCreator.createBarLinePlot(startDate, endDate, contractElec,
payment, 'abc', period)
print(request.url) #localhost:5000/electric/pattern
print(a)
return graphJSON
def calc_edge(self):
# Calculate bandstructure from chosen lattice and Hamiltonian and highlight edge states
Lat = lattice('Ribbon', 'Twisted Bilayer', self.NUnit.value(),
self.TwistAngle.value())
H = Hamiltonian(Lat, self.Hoppingt.value())
if self.Magneticfield.value() != 0:
H.add_magnetic_field(self.Magneticfield.value(),
self.SelectBBil.currentText())
if self.OnsiteV.value() != 0:
H.add_lattice_imbalance(self.OnsiteV.value())
if self.OnsiteV_2.value() != 0:
H.add_sublattice_imbalance(self.OnsiteV_2.value())
P = Plot(H)
P.calc_edge()
def Print(self, path, **kwargs):
r"""Print the histogram to a file.
Creates a PDF/PNG/... file with the absolute path defined by **path**. If a file
with the same name already exists it will be overwritten (can be changed with
the **overwrite** keyword argument). If **mkdir** is set to ``True`` (default:
``False``) directories in **path** with do not yet exist will be created
automatically. The styling of the histogram, pad and canvas can be configured
via their respective properties passed as keyword arguments.
:param path: path of the output file (must end with '.pdf', '.png', ...)
:type path: ``str``
:param \**kwargs: :class:`.Histo2D`, :class:`.Plot`, :class:`.Canvas` and
:class:`.Pad` properties + additional properties (see below)
Keyword Arguments:
* **inject** (``list``, ``tuple``, ``ROOT.TObject``) -- inject a (list of)
*drawable* :class:`ROOT` object(s) to the main pad, object properties can
be specified by passing instead a ``tuple`` of the format
:code:`(obj, props)` where :code:`props` is a ``dict`` holding the object
properties (default: \[\])
* **overwrite** (``bool``) -- overwrite an existing file located at **path**
(default: ``True``)
* **mkdir** (``bool``) -- create non-existing directories in **path**
(default: ``False``)
"""
injections = {"inject0": kwargs.pop("inject", [])}
kwargs.setdefault("logy", False) # overwriting Pad template's default value!
properties = DissectProperties(kwargs, [Histo2D, Plot, Canvas, Pad])
if any(
map(
lambda s: "Z" in s.upper(),
[self.GetDrawOption(), properties["Pad"].get("drawoption", "")],
)
):
properties["Pad"].setdefault("rightmargin", 0.18)
plot = Plot(npads=1)
plot.Register(self, **MergeDicts(properties["Histo2D"], properties["Pad"]))
plot.Print(
path, **MergeDicts(properties["Plot"], properties["Canvas"], injections)
)
def plot_summary(self):
# Generate summary plot of chosen lattice and Hamiltonian
K = -(4 * np.pi) / (3 * np.sqrt(3))
Lat = lattice('Sheet', 'Twisted Bilayer', 1, self.TwistAngle.value())
H = Hamiltonian(Lat, self.Hoppingt2.value())
if self.Magneticfield2.value() != 0:
H.add_magnetic_field(self.Magneticfield2.value(),
self.SelectBBil.currentText(),
self.BAngle.value())
if self.OnsiteV.value() != 0:
H.add_lattice_imbalance(self.OnsiteV.value())
if self.OnsiteV_2.value() != 0:
H.add_sublattice_imbalance(self.OnsiteV_2.value())
P = Plot(H)
P.summary(self.Nk.value(), K, 0, 17, 75, 75, 75)
def main(self):
while(True):
print("1-run,2-validate")
choice=input()
if choice=="1":
self.run()
elif choice=="2":
Plot()
else:
return
def start(cls):
InOut.console_func_begin("Process")
prePro = PreProcess()
#prePro.start()
#return
pl = Plot()
pl.start()
return
city = City()
#city.start()
resource = Resource()
#resource.start()
if(Config.flag_exp_generate_exp_data):
getExpData = GetExpData()
getExpData.start()
if(Config.flag_exp_generate_ratio_data):
getExpRatioData = GetExpRatioData()
getExpRatioData.start()
#return
analyse = Analyse()
#analyse.start()
#return
#Test.test()
#return
hli = HomeLocIdentify()
hli.start()
InOut.console_func_end("Process")
def setup(self):
self.memory_map = self.mission.get_memory_map()
if self.settings.get("plot"):
# Setup memory map plot
from Plot import Plot
self.plot = Plot(self.environment, self.memory_map)
if self.rf_sensor is not None:
self.rf_sensor.activate()
class Monitor(object):
"""
Mission monitor class.
Tracks sensors and mission actions in a stepwise fashion.
"""
def __init__(self, mission, environment):
self.mission = mission
self.environment = environment
arguments = self.environment.get_arguments()
self.settings = arguments.get_settings("mission_monitor")
# Seconds to wait before monitoring again
self.step_delay = self.settings.get("step_delay")
self.sensors = self.environment.get_distance_sensors()
self.rf_sensor = self.environment.get_rf_sensor()
self.colors = self.settings.get("plot_sensor_colors")
self.memory_map = None
self.plot = None
self._paused = False
def get_delay(self):
return self.step_delay
def use_viewer(self):
return self.settings.get("viewer")
def setup(self):
self.memory_map = self.mission.get_memory_map()
if self.settings.get("plot"):
# Setup memory map plot
from Plot import Plot
self.plot = Plot(self.environment, self.memory_map)
if self.rf_sensor is not None:
self.rf_sensor.activate()
def step(self, add_point=None):
"""
Perform one step of a monitoring loop.
`add_point` can be a callback function that accepts a Location object
for a detected point from the distance sensors.
Returns `False` if the loop should be halted.
"""
if self._paused:
return True
# Put our current location on the map for visualization. Of course,
# this location is also "safe" since we are flying there.
vehicle_idx = self.memory_map.get_index(self.environment.get_location())
try:
self.memory_map.set(vehicle_idx, -1)
except KeyError:
print("Warning: Outside of memory map")
self.mission.step()
i = 0
for sensor in self.sensors:
yaw = sensor.get_angle()
pitch = sensor.get_pitch()
sensor_distance = sensor.get_distance()
if self.mission.check_sensor_distance(sensor_distance, yaw, pitch):
location = self.memory_map.handle_sensor(sensor_distance, yaw)
if add_point is not None:
add_point(location)
if self.plot:
# Display the edge of the simulated object that is
# responsible for the measured distance, and consequently
# the point itself. This should be the closest "wall" in
# the angle's direction. This is again a "cheat" for
# checking if walls get visualized correctly.
sensor.draw_current_edge(self.plot.get_plot(), self.memory_map, self.colors[i % len(self.colors)])
print("=== [!] Distance to object: {} m (yaw {}, pitch {}) ===".format(sensor_distance, yaw, pitch))
i = i + 1
# Display the current memory map interactively.
if self.plot:
self.plot.plot_lines(self.mission.get_waypoints())
self.plot.display()
if not self.mission.check_waypoint():
return False
# Remove the vehicle from the current location. We set it to "safe"
# since there is no object here.
try:
self.memory_map.set(vehicle_idx, 0)
except KeyError:
pass
return True
def sleep(self):
time.sleep(self.step_delay)
def start(self):
self.mission.start()
if self.rf_sensor is not None:
self.rf_sensor.start()
def pause(self):
"""
Pause or unpause the mission.
If the mission is currently paused, then this restarts the mission in
the correct mode. Otherwise, the vehicle is paused and the RF sensor is
put in its passive mode.
"""
if self._paused:
self.start()
self._paused = False
else:
self.environment.get_vehicle().pause()
if self.rf_sensor is not None:
self.rf_sensor.stop()
self._paused = True
def stop(self):
self.mission.stop()
if self.rf_sensor is not None:
self.rf_sensor.stop()
if self.plot:
self.plot.close()
t_W = -R_WC.dot(t_C)
T_CW = np.zeros((4, 4))
T_CW[:3, :3] = R_CW
T_CW[:3, 3:4] = t_C
T_CW[3, 3] = 1.
T_WC = np.zeros((4, 4))
T_WC[:3, :3] = R_WC
T_WC[:3, 3:4] = t_W
T_WC[3, 3] = 1.
return T_WC, T_CW
if __name__ == "__main__":
p = Plot()
geo = Geometry()
d = 10
pt0 = np.array([[0], [0], [0]])
p.plotPoint(pt0)
for i in range(10):
angle = np.deg2rad(10 * i)
pt = np.array([[d * np.cos(angle)],
[-d * np.sin(angle)],
[i]])
if i == 0:
p.plotPoint(pt, 'g.')
else:
p.plotPoint(pt)
r = Ray(pt0, pt)
def bargraph_panel(request):
try:
data = [1,2,3,4,5]
variableList = ["", "mdn","pon","spi","pdsi","pzi", "scpdsi"]
if 'run_avg' in request.GET:
run_avg = request.GET['run_avg']
if not run_avg:
runAvg = 0
else:
runAvg = int(run_avg)
if 'lat' in request.GET:
lat = request.GET['lat']
if not lat:
lat = 40
else:
lat = float(lat)
if 'lon' in request.GET:
lon = request.GET['lon']
if not lon:
lon = -100
else:
lon = float(lon)
if 'start_year' in request.GET:
startYear = request.GET['start_year']
if startYear < 1895:
startYear = 1895
else:
startYear = int(startYear)
if 'end_year' in request.GET:
endYear = request.GET['end_year']
endYear = int(endYear)
#if endYear > datetime.datetime.now().year:
# endYear = (datetime.datetime.now().year -1)
#else:
# endYear = int(endYear)
#if 'variable' in request.GET:
# variable = int(request.GET['variable'])
# variable = variableList[variable]
variable = int(request.GET['variable'])
variable = variableList[variable]
month = int(request.GET['month'])
span = int(request.GET['span'])
# Print PNG to page
try:
canvas = Plot(lat=lat, lon=lon, startYear=startYear, endYear=endYear, variable=variable, month=month, span=span, runavg=runAvg, data=None).getData()
response=HttpResponse(content_type='image/png')
canvas.print_png(response)
plt.close()
return response
except:
return HttpResponse("Invalid plot")
except:
return HttpResponse("Invalid parameters")
#!/usr/bin/env python
import cv2
import numpy as np
from Plot import Plot
from Geometry import Geometry
PI = np.pi
if __name__ == "__main__":
p = Plot()
geo = Geometry()
R = 18.1
T = 42.8
PO = np.zeros((3, 1))
# Define test points
PC = np.array([[0], [0], [R]])
h, w = 3, 15
Ppx = np.zeros((h, w, 3))
Ppx[:, :, 0] = np.arange(-(h / 2), (h / 2) + 1).reshape((h, 1))
Ppx[:, :, 1] = -np.arange(-(w / 2), (w / 2) + 1).reshape((1, w))
Ppx[:, :, 2] = 1.2 * R
# Define rotation angles
Ppx_theta = np.pi / 2
Ppx_phi = 3 * np.pi / 16
# Rotate points
def run_sim(self):
"""
Sets up and runs the simulation
"""
num_neurons = 1471 # total neurons in network
num_inputs = 14 # number of neurons considered inputs
num_runs = 1 # number of times to loop the learning
num_samples = 1 # number of samples to learn`
sim_time = 1000.0 # time to run sim for`
inhibitory_split = 0.2
connection_probability_factor = 0.02
plot_spikes = True
save_figures = True
show_figures = True
sim_start_time = strftime("%Y-%m-%d_%H:%M")
cell_params_lif = {'cm': 0.25, 'i_offset': 0.0, 'tau_m': 10.0, 'tau_refrac': 2.0, 'tau_syn_E': 3.0,
'tau_syn_I': 3.0, 'v_reset': -65.0, 'v_rest': -65.0, 'v_thresh': -50.0}
# Create the 3d structure of the NeuCube based on the user's given structure file
network_structure = NetworkStructure()
network_structure.load_structure_file()
network_structure.load_input_location_file()
# Calculate the inter-neuron distance to be used in the small world connections
network_structure.calculate_distances()
# Generate two connection matrices for excitatory and inhibitory neurons based on your defined split
network_structure.calculate_connection_matrix(inhibitory_split, connection_probability_factor)
# Get these lists to be used when connecting the neurons later
excitatory_connection_list = network_structure.get_excitatory_connection_list()
inhibitory_connection_list = network_structure.get_inhibitory_connection_list()
# Choose the correct neurons to connect them to, based on your a-priori knowledge of the data source -- eg, EEG
# to 10-20 locations, fMRI to voxel locations, etc.
input_neuron_indexes = network_structure.find_input_neurons()
# Make the input connections based on this new list
input_weight = 4.0
input_connection_list = []
for index, input_neuron_index in enumerate(input_neuron_indexes):
input_connection_list.append((index, input_neuron_index, input_weight, 0))
for run_number in xrange(num_runs):
excitatory_weights = []
inhibitory_weights = []
for sample_number in xrange(num_samples):
# At the moment with the limitations of the SpiNNaker hardware we have to reinstantiate EVERYTHING
# each run. In future there will be some form of repetition added, where the structure stays in memory
# on the SpiNNaker and only the input spikes need to be updated.
data_prefix = sim_start_time + "_r" + str(run_number + 1) + "-s" + str(sample_number + 1)
# Set up the hardware - min_delay should never be less than the timestep.
# Timestep should = 1.0 (ms) for normal realtime applications
p.setup(timestep=1.0, min_delay=1.0)
p.set_number_of_neurons_per_core("IF_curr_exp", 100)
# Create a population of neurons for the reservoir
neurons = p.Population(num_neurons, p.IF_curr_exp, cell_params_lif, label="Reservoir")
# Setup excitatory STDP
timing_rule_ex = p.SpikePairRule(tau_plus=20.0, tau_minus=20.0)
weight_rule_ex = p.AdditiveWeightDependence(w_min=0.1, w_max=1.0, A_plus=0.02, A_minus=0.02)
stdp_model_ex = p.STDPMechanism(timing_dependence=timing_rule_ex, weight_dependence=weight_rule_ex)
# Setup inhibitory STDP
timing_rule_inh = p.SpikePairRule(tau_plus=20.0, tau_minus=20.0)
weight_rule_inh = p.AdditiveWeightDependence(w_min=0.0, w_max=0.6, A_plus=0.02, A_minus=0.02)
stdp_model_inh = p.STDPMechanism(timing_dependence=timing_rule_inh, weight_dependence=weight_rule_inh)
# record the spikes from that population
neurons.record('spikes')
# Generate a population of SpikeSourceArrays containing the encoded input spike data
# eg. spike_sources = p.Population(14, p.SpikeSourceArray, {'spike_times': [[]]})
# for the moment I'm going to cheat and just use poisson trains as I don't have data with me
spike_sources = p.Population(num_inputs, p.SpikeSourcePoisson, {'rate': rand.randint(20, 80)},
label="Poisson_pop_E")
# Connect the input spike sources with the "input" neurons
connected_inputs = p.Projection(spike_sources, neurons, p.FromListConnector(input_connection_list))
# If we have weights saved/recorded from a previous run of this network, load them into the structure
# population.set(weights=weights_list) and population.setWeights(weight_list) are not supported in
# SpiNNaker at the moment so we have to do this manually.
if excitatory_weights and inhibitory_weights:
for index, ex_connection in enumerate(excitatory_connection_list):
ex_connection[2] = excitatory_weights[index]
for index, in_connection in enumerate(inhibitory_connection_list):
in_connection[2] = inhibitory_weights[index]
# Setup the connectors
excitatory_connector = p.FromListConnector(excitatory_connection_list)
inhibitory_connector = p.FromListConnector(inhibitory_connection_list)
# Connect the excitatory and inhibitory neuron populations
connected_excitatory_neurons = p.Projection(neurons, neurons, excitatory_connector,
synapse_dynamics=p.SynapseDynamics(slow=stdp_model_ex),
target="excitatory")
connected_inhibitory_neurons = p.Projection(neurons, neurons, inhibitory_connector,
synapse_dynamics=p.SynapseDynamics(slow=stdp_model_inh),
target="inhibitory")
# Set up recording the spike trains of all the neurons
neurons.record()
spike_sources.record()
# Run the actual simulation
p.run(sim_time)
# Save the output spikes
spikes_out = neurons.getSpikes(compatible_output=True)
input_spikes_out = spike_sources.getSpikes(compatible_output=True)
# Get the synaptic weights of all the neurons
excitatory_weights = connected_excitatory_neurons.getWeights()
inhibitory_weights = connected_inhibitory_neurons.getWeights()
# when we're all done, clean up
p.end()
# Make some plots, save them if required. Check if you need to either save or show them, because if not,
# there's no point wasting time plotting things nobody will ever see.
if plot_spikes and (save_figures or show_figures):
plot = Plot(save_figures, data_prefix)
# Plot the 3D structure of the network
plot.plot_structure(network_structure.get_positions(), figure_number=0)
# Plot the spikes
plot.plot_spike_raster(spikes_out, sim_time, num_neurons, figure_number=1)
# Plot the weights
plot.plot_both_weights(excitatory_weights, inhibitory_weights, figure_number=2)
# If we want to show the figures, show them now, otherwise ignore and move on
if show_figures:
# Show them all at once
plot.show_plots()
plot.clear_figures()
plot = None
def bargraph_panel(request):
try:
data = [1,2,3,4,5]
variableList = ["", "mdn","pon","spi","spei","pdsi","pzi", "scpdsi"]
if 'run_avg' in request.GET:
run_avg = request.GET['run_avg']
if not run_avg:
runAvg = 0
else:
runAvg = int(run_avg)
if 'lat' in request.GET:
lat = request.GET['lat']
if not lat:
lat = 40
else:
lat = float(lat)
if 'lon' in request.GET:
lon = request.GET['lon']
if not lon:
lon = -100
else:
lon = float(lon)
if 'start_year' in request.GET:
startYear = request.GET['start_year']
if startYear < 1895:
startYear = 1895
else:
startYear = int(startYear)
if 'end_year' in request.GET:
endYear = request.GET['end_year']
endYear = int(endYear)
#if endYear > datetime.datetime.now().year:
# endYear = (datetime.datetime.now().year -1)
#else:
# endYear = int(endYear)
#if 'variable' in request.GET:
# variable = int(request.GET['variable'])
# variable = variableList[variable]
variable = int(request.GET['variable'])
variable = variableList[variable]
month = int(request.GET['month'])
span = int(request.GET['span'])
# Print PNG to page
try:
newPlot = Plot(lat=lat, lon=lon, startYear=startYear, endYear=endYear, variable=variable, month=month, span=span, runavg=runAvg, data=None)
fig = newPlot.getData()
canvas=FigureCanvas(fig)
response=django.http.HttpResponse(content_type='image/png')
canvas.print_png(response)
return response
except:
return HttpResponse("Plot feature under development for this location.")
except:
return HttpResponse("No data.")
