def index(request):
config = config_file.get_config()
if request.POST:
if len(request.POST) > 0:
for r in request.POST:
config.set('bblio',r,str(request.POST[r]))
config_file.set_config(config)
try:
config.items('bblio')
except:
config.add_section('bblio')
form = ConfigForm()
for f in form.fields:
try:
form.fields[f].initial = config.get('bblio',str(f))
except:
config.set('bblio',f,'')
config_file.set_config(config)
context = {'form' : form }
return render(request, 'operations/admin.html', context)
def return_masks(masterflat, toplot=False):
config = config_file.set_config()
masterflat.astype(float)
ybin = config["binning"]
print "assuming a ybin of", ybin
print "creating a set of steps for the centres of the orders"
steps = mean(masterflat[:,
len(masterflat[0]) / 2 -
10:len(masterflat[0]) / 2 + 10],
axis=1)
#steps = steps[:-100/ybin]
### normalise the flats
norm = []
j = 200 / ybin
i = 0
while i < len(steps):
norm.append([
i + j / 2,
min(steps[i:i + j]),
max(steps[i:i + j]) - min(steps[i:i + j])
])
i += j
norm = array(norm)
x = arange(len(steps))
norm_min = interpolate.splrep(norm[:, 0], norm[:, 1], k=1)
norm_min = interpolate.splev(x, norm_min)
norm_max = interpolate.splrep(norm[:, 0], norm[:, 2], k=1)
norm_max = interpolate.splev(x, norm_max)
# plt.plot(x,norm_min)
# plt.plot(x,norm_max+norm_min)
# plt.plot(steps)
# plt.show()
steps -= norm_min
steps /= norm_max
from scipy.signal import find_peaks_cwt
indexes = find_peaks_cwt(steps, arange(20, 70, 10) / ybin, min_snr=0.2)
indexes = sort(indexes) ### just to make sure
indexes = indexes[:19]
x = arange(len(indexes))
# plt.plot(steps)
# plt.scatter(indexes,zeros(len(indexes)))
# plt.show()
def minfunc(x0):
f = x0[0] * log(x - x0[1]) + x0[2]
return (f - indexes)**2
x0 = optimize.least_squares(minfunc, [-1., -1., 1., 1.]).x
x = arange(config["norder"] + 1)
f = x0[0] * log((x - x0[1]) * x0[3]) + x0[2]
#f = polyfit(x,indexes,3)
#x = arange(config["norder"]+1)
#f = polyval(f,x)
# plt.scatter(arange(len(indexes)),indexes)
# plt.plot(x,f)
# plt.show()
indexes = f.astype(int)
if len(indexes) - 1 < config["norder"]:
print "!!!!!!!!!!! Ah shit, did not identify enough orders, check your flats !!!!!!!!!!!!!!!!!"
# plt.scatter(indexes,zeros(len(indexes)))
# plt.plot(steps,color="r")
# plt.show()
print "finding edges for each order"
order_masks = []
stepsize = 50
cutoff = 0.5
for order in range(len(indexes) - 1):
#for order in [22]:
if order < config["norder"]:
if order == 0:
trace_top = []
### initiate trace
xpos = arange(10 / ybin, indexes[order])
edge = mean(masterflat[10 / ybin:indexes[order],
len(masterflat[0]) / 2 -
10 / ybin:len(masterflat[0]) / 2 + 10],
axis=1)
mask = edge - min(edge) > cutoff * (max(edge) - min(edge))
edge = min(xpos[mask])
edge0 = edge
width = indexes[order] - edge
trace_top.append([len(masterflat[0]) / 2, edge])
### look left
x = len(masterflat[0]) / 2 - 10
while x > 100:
xpos = arange(10 / ybin, edge + width)
edge = mean(masterflat[10 / ybin:edge + width,
x - stepsize:x + stepsize],
axis=1)
mask = edge - min(edge) > cutoff * (max(edge) - min(edge))
edge = min(xpos[mask])
trace_top.append([x, edge])
x -= stepsize
zpt = indexes[order] - (indexes[order] -
indexes[order - 1]) / 2
edge = edge0
### look right
x = len(masterflat[0]) / 2 + 10
while x < len(masterflat[0]) - 100:
xpos = arange(10 / ybin, edge + width)
edge = mean(masterflat[10 / ybin:edge + width,
x - stepsize:x + stepsize],
axis=1)
mask = edge - min(edge) > cutoff * (max(edge) - min(edge))
edge = min(xpos[mask])
trace_top.append([x, edge])
x += stepsize
else:
trace_top = []
zpt = indexes[order] - (indexes[order] -
indexes[order - 1]) / 2
### initiate trace
xpos = arange(zpt, indexes[order])
edge = mean(masterflat[zpt:indexes[order],
len(masterflat[0]) / 2 -
10:len(masterflat[0]) / 2 + 10],
axis=1)
mask = edge - min(edge) > cutoff * (max(edge) - min(edge))
edge = min(xpos[mask])
width = indexes[order] - edge
trace_top.append([len(masterflat[0]) / 2, edge])
edge0 = edge
zpt = edge - 5
### look left
x = len(masterflat[0]) / 2 - 10
while x > 100:
xpos = arange(zpt + (edge - edge0), edge + width)
edge = mean(masterflat[zpt + (edge - edge0):edge + width,
x - stepsize:x + stepsize],
axis=1)
#plt.plot(xpos,edge)
emin, eminpos = min(edge), xpos[argmin(edge)]
if min(xpos) < eminpos:
xpos = xpos[argmin(edge):]
edge = edge[argmin(edge):]
mask = (edge -
min(edge)) > cutoff * (max(edge) - min(edge))
edge = min(xpos[mask])
#plt.axvline(x=edge)
#plt.show()
trace_top.append([x, edge])
x -= stepsize
#zpt = indexes[order]-(indexes[order]-indexes[order-1])/2
edge = edge0
### look right
x = len(masterflat[0]) / 2 + 10
while x < len(masterflat[0]) - 100:
xpos = arange(zpt + (edge - edge0), edge + width)
edge = mean(masterflat[zpt + (edge - edge0):edge + width,
x - stepsize:x + stepsize],
axis=1)
#plt.plot(xpos,edge)
emin, eminpos = min(edge), xpos[argmin(edge)]
if min(xpos) < eminpos:
xpos = xpos[argmin(edge):]
edge = edge[argmin(edge):]
mask = edge - min(edge) > cutoff * (max(edge) - min(edge))
edge = min(xpos[mask])
#plt.axvline(x=edge)
#plt.show()
trace_top.append([x, edge])
x += stepsize
trace_top = array(trace_top) - 2.
trace_top_fit = polyfit_sigclip(trace_top[:, 0], trace_top[:, 1])
#trace_top_fit = polyval(trace_top_fit,arange(len(masterflat)))
#################
trace_bottom = []
zpt = indexes[order] + (indexes[order + 1] - indexes[order]) / 2
### initiate trace
xpos = arange(indexes[order], zpt)
edge = mean(masterflat[indexes[order]:zpt,
len(masterflat[0]) / 2 -
10:len(masterflat[0]) / 2 + 10],
axis=1)
mask = edge - min(edge) > cutoff * (max(edge) - min(edge))
edge = max(xpos[mask])
width = edge - indexes[order]
trace_bottom.append([len(masterflat[0]) / 2, edge])
edge0 = edge
zpt = edge + 5
### look left
x = len(masterflat[0]) / 2 - 10
while x > 100:
xpos = arange(edge - width, zpt + (edge - edge0))
edge = mean(masterflat[edge - width:zpt + (edge - edge0),
x - stepsize:x + stepsize],
axis=1)
emin, eminpos = min(edge), xpos[argmin(edge)]
if max(xpos) > eminpos:
xpos = xpos[:argmin(edge)]
edge = edge[:argmin(edge)]
#plt.plot(xpos,edge)
mask = edge - min(edge) > cutoff * (max(edge) - min(edge))
edge = max(xpos[mask])
#plt.axvline(x=edge)
#plt.show()
trace_bottom.append([x, edge])
x -= stepsize
#zpt = indexes[order]+(indexes[order+1]-indexes[order])/2
edge = edge0
### look right
x = len(masterflat[0]) / 2 + 10
while x < len(masterflat[0]) - 100:
xpos = arange(edge - width, zpt + (edge - edge0))
edge = mean(masterflat[edge - width:zpt + (edge - edge0),
x - stepsize:x + stepsize],
axis=1)
emin, eminpos = min(edge), xpos[argmin(edge)]
if max(xpos) > eminpos:
xpos = xpos[:argmin(edge)]
edge = edge[:argmin(edge)]
#plt.plot(xpos,edge)
mask = edge - min(edge) > cutoff * (max(edge) - min(edge))
edge = max(xpos[mask])
#plt.axvline(x=edge)
#plt.show()
trace_bottom.append([x, edge])
x += stepsize
trace_bottom = array(trace_bottom) + 2.
trace_bottom_fit = polyfit_sigclip(trace_bottom[:, 0],
trace_bottom[:, 1])
if toplot:
plt.scatter(trace_bottom[:, 0], trace_bottom[:, 1])
plt.plot(arange(len(masterflat[0])),
polyval(trace_bottom_fit, arange(len(masterflat[0]))))
plt.scatter(trace_top[:, 0], trace_top[:, 1])
plt.plot(arange(len(masterflat[0])),
polyval(trace_top_fit, arange(len(masterflat[0]))))
plt.show()
x = arange(len(masterflat[0]))
y = arange(len(masterflat))
xx, yy = meshgrid(x, y)
mask = masterflat == masterflat
mask *= yy > polyval(trace_top_fit, xx)
mask *= yy < polyval(trace_bottom_fit, xx)
order_masks.append([mask, trace_top_fit, trace_bottom_fit])
pickle.dump(order_masks,
open(config["folder"] + "/temp/order_masks.pkl", "wb"))
return order_masks
import os, sys, string, pickle, pyfits
import emcee
from numpy import *
from scipy import interpolate, optimize
import matplotlib.pyplot as plt
import warnings
warnings.filterwarnings("ignore")
import config_file
config = config_file.set_config()
library_path = config["spectral_library"] + "lib/"
library = pickle.load(open(library_path + "library.pkl", "rb"))
c = 3. * 10**5
def make_rot_prof(v, vsini=100, epsilon=0.6451, scale=1, vshift=0):
vrot = 2 * (1 - epsilon) * (1 - (
(v - vshift) / vsini)**2)**(0.5) + 0.5 * pi * epsilon * (1 - (
(v - vshift) / vsini)**2)
#vrot /= pi*vsini*(1-epsilon/3)
mask = vrot != vrot
vrot[mask] = 0
vrot /= max(vrot)
vrot *= scale
return vrot