def main():
parser = OptionParser(description='Fitting to a noisy data generated by a known function')
parser.add_option("--npoints", type="int", help="number of data points")
parser.add_option("--low", type="float", help="smallest data point")
parser.add_option("--high", type="float", help="highest data point")
parser.add_option("--sigma", type="float", help="std of noise")
(options, args) = parser.parse_args()
pl.figure(1,(7,6))
ax = pl.subplot(1,1,1)
pl.connect('key_press_event',kevent.press)
sigma = options.sigma
Ls = np.append(np.linspace(options.low,options.high,options.npoints),46)
nLs = np.linspace(min(Ls),max(Ls),100)
Mis = HalfLog(Ls,.5,0.5)
errs = np.random.normal(0,sigma, len(Mis))
Mis = Mis+errs
pl.errorbar(Ls,Mis,errs,ls='',marker='s',color='b')
print sigma/Mis
coeff, var_matrix = curve_fit(FreeLog,Ls,Mis,(1.0,1.0,1.0))
err = np.sqrt(np.diagonal(var_matrix))
dof = len(Ls) - len(coeff)
chisq = sum(((Mis-FreeLog(Ls,coeff[0],coeff[1],coeff[2]))/sigma)**2)
cdf = special.chdtrc(dof,chisq)
print 'Free: a = %0.2f(%0.2f); b = %0.2f(%0.2f); c = %0.2f(%0.2f); p-value = %0.2f ' %(coeff[0],err[0],coeff[1],err[1],coeff[2],err[2],cdf)
pl.plot(nLs,FreeLog(nLs,coeff[0],coeff[1],coeff[2]),label='Free',color='y')
coeff, var_matrix = curve_fit(ZeroLog,Ls,Mis,(1.0,1.0))
err = np.sqrt(np.diagonal(var_matrix))
dof = len(Ls) - len(coeff)
chisq = sum(((Mis-ZeroLog(Ls,coeff[0],coeff[1]))/sigma)**2)
cdf = special.chdtrc(dof,chisq)
print 'Zero: a = %0.2f(%0.2f); c = %0.2f(%0.2f); p-value = %0.2f' %(coeff[0],err[0],coeff[1],err[1],cdf)
pl.plot(nLs,ZeroLog(nLs,coeff[0],coeff[1]),label='Zero',color='g')
pl.tight_layout()
coeff, var_matrix = curve_fit(HalfLog,Ls,Mis,(1.0,1.0))
err = np.sqrt(np.diagonal(var_matrix))
dof = len(Ls) - len(coeff)
chisq = sum(((Mis-HalfLog(Ls,coeff[0],coeff[1]))/sigma)**2)
cdf = special.chdtrc(dof,chisq)
print 'Half: a = %0.2f(%0.2f); c = %0.2f(%0.2f); p-value = %0.2f' %(coeff[0],err[0],coeff[1],err[1],cdf)
pl.plot(nLs,HalfLog(nLs,coeff[0],coeff[1]),label='Half',color='b')
pl.tight_layout()
coeff, var_matrix = curve_fit(OneLog,Ls,Mis,(1.0,1.0))
err = np.sqrt(np.diagonal(var_matrix))
dof = len(Ls) - len(coeff)
chisq = sum(((Mis-OneLog(Ls,coeff[0],coeff[1]))/sigma)**2)
cdf = special.chdtrc(dof,chisq)
print 'Unity: a = %0.2f(%0.2f); c = %0.2f(%0.2f); p-value = %0.2f' %(coeff[0],err[0],coeff[1],err[1],cdf)
pl.plot(nLs,OneLog(nLs,coeff[0],coeff[1]),label='Unity',color='r')
pl.tight_layout()
pl.legend()
pl.show()
def plotGetRetangle():
""" Area selection from selected pen.
"""
selRect = []
if len(ds.EpmDatasetAnalysisPens.SelectedPens) != 1:
sr.msgBox('EPM Python Plugin - Demo Tools', 'Please select a single pen before applying this function!', 'Warning')
return 0
epmData = ds.EpmDatasetAnalysisPens.SelectedPens[0].values
y = epmData['Value'].copy()
x = np.arange(len(y))
fig, current_ax = pl.subplots()
pl.plot(x, y, lw=2, c='g', alpha=.3)
def line_select_callback(eclick, erelease):
'eclick and erelease are the press and release events'
x1, y1 = eclick.xdata, eclick.ydata
x2, y2 = erelease.xdata, erelease.ydata
print ("\n(%3.2f, %3.2f) --> (%3.2f, %3.2f)" % (x1, y1, x2, y2))
selRect.append((int(x1), y1, int(x2), y2))
def toggle_selector(event):
if event.key in ['Q', 'q'] and toggle_selector.RS.active:
toggle_selector.RS.set_active(False)
if event.key in ['A', 'a'] and not toggle_selector.RS.active:
toggle_selector.RS.set_active(True)
toggle_selector.RS = RectangleSelector(current_ax, line_select_callback, drawtype='box', useblit=True, button=[1,3], minspanx=5, minspany=5, spancoords='pixels')
pl.connect('key_press_event', toggle_selector)
pl.show()
return selRect
def getData() :
pylab.subplot(111)
pylab.plot([xmin,xmin,xmax,xmax], [ymin,ymax,ymin,ymax], '.k')
pylab.title("press the numbers 1 or 2 to generate data points and 'q' to quit")
global binding_id
binding_id = pylab.connect('key_press_event', pick)
pylab.show()
def getData():
pylab.subplot(111)
pylab.plot([xmin, xmin, xmax, xmax], [ymin, ymax, ymin, ymax], '.k')
pylab.title(
"press the numbers 1 or 2 to generate data points and 'q' to quit")
global binding_id
binding_id = pylab.connect('key_press_event', pick)
pylab.show()
def analyse(params="1N0U 0"):
"""
launch pymol
from console type: run analyse.py protein_id skip_header
note: skip_header is an int that indicates the number of rows to skip
"""
protein, skip_header = params.split(" ")
score_path = '{}/score.fsc'.format(protein)
x, y, annote = read_scores(score_path, int(skip_header))
ax = plot_scores(x, y)
s_best, s_median = stats(x, y, annote)
print("among the 25 lowest energy structures:")
print("best structrure: {1} with gdt_ts {0}".format(*s_best))
print("Median gdt_ts: {0} from structure {1}".format(*s_median))
pl1 = PymolLauncher(x, y, annote, ax)
pl1.set_native("{0}/{0}.pdb".format(protein))
load_native(pl1)
plt.connect('button_press_event', pl1)
plt.show()
def getData(**args) :
global numpy_container
numpy_container = False
if 'numpy_container' in args :
numpy_container = args['numpy_container']
pylab.subplot(111)
pylab.plot([xmin,xmin,xmax,xmax], [ymin,ymax,ymin,ymax], '.k')
pylab.title("press the numbers 1 or 2 to generate data points and 'q' to quit")
global binding_id
binding_id = pylab.connect('key_press_event', pick)
pylab.show()
def main():
# create a OptionParser object
parser = OptionParser()
options, args = add_options(parser)
# open a score file with the argument from OptionParser object
gdts, scores, pdbs = read_scores(options.score_file, options.skipheader)
ax = plot_scores(gdts, scores)
s_best, s_median = stats(gdts, scores, pdbs)
print("among the 25 lowest energy structures:")
print("best structrure: {1} with gdt_ts {0}".format(*s_best))
print("Median gdt_ts: {0} from structure {1}".format(*s_median))
pl1 = PymolLauncher( gdts, scores, pdbs, ax )
pl1.set_native(options.native)
plt.connect('button_press_event', pl1)
plt.gca().set_autoscale_on(False)
pymol.finish_launching()
load_native(pl1)
plt.show()
def plotGetRetangle():
""" Get area selection from selected pen
"""
if len(ep.EpmDatasetPens.SelectedPens) != 1:
ep.showMsgBox(_g_DemoToolsCaption, _g_MissSinglePenTxt,
_g_MissPensMsgType)
return None
epmData = ep.EpmDatasetPens.SelectedPens[0].Values
y = epmData['Value'].copy()
x = np.arange(len(y))
from matplotlib.pylab import show, subplots, plot, figure, connect
fig, current_ax = subplots()
plot(x, y, lw=2, c='g', alpha=.3)
selRect = []
def line_select_callback(eclick, erelease):
# eclick and erelease are the press and release events
x1, y1 = eclick.xdata, eclick.ydata
x2, y2 = erelease.xdata, erelease.ydata
print "\n({:3.3f}, {:3.3f}) --> ({:3.3f}, {:3.3f})".format(
x1, y1, x2, y2)
selRect.append((int(x1), y1, int(x2), y2))
def toggle_selector(event):
if event.key in ['Q', 'q'] and toggle_selector.RS.active:
toggle_selector.RS.set_active(False)
if event.key in ['A', 'a'] and not toggle_selector.RS.active:
toggle_selector.RS.set_active(True)
from matplotlib.widgets import RectangleSelector
toggle_selector.RS = RectangleSelector(current_ax,
line_select_callback,
drawtype='box',
useblit=True,
button=[1, 3],
minspanx=5,
minspany=5,
spancoords='pixels')
connect('key_press_event', toggle_selector)
show()
return selRect
def getData(**args):
global numpy_container
numpy_container = False
if 'numpy_container' in args:
numpy_container = args['numpy_container']
pylab.subplot(111)
pylab.plot([xmin, xmin, xmax, xmax], [ymin, ymax, ymin, ymax], '.k')
pylab.title(
"press the numbers 1 or 2 to generate data points and 'q' to quit")
global binding_id
binding_id = pylab.connect('key_press_event', pick)
pylab.show()
def __init__(self,
X,
img_height,
img_width,
nrows=10,
ncols=20,
startidx=0,
figtitle="",
luminance_scale_mode=0,
colormaps=[mpl.cm.jet, mpl.cm.gray],
vmin=None,
vmax=None,
transpose_img=False):
self.X = X
self.img_height = img_height
self.img_width = img_width
self.nrows = nrows
self.ncols = ncols
self.figtitle = figtitle
self.startidx = startidx
# appearance control
self.luminance_scale_mode = luminance_scale_mode
self.interpolation = 'nearest'
self.colormaps = colormaps
self.cmapchoice = 0
self.show_colorbar = True
self.disable_ticks = True
self.vmin = vmin
self.vmax = vmax
self.transpose_img = transpose_img
# plot it
self.draw()
mpl.connect('key_press_event', self.keyPressed)
# connect('button_press_event', self.__clicked)
# start interactive loop
mpl.show()
def plotGetRetangle():
""" Area selection from selected pen.
"""
selRect = []
if len(ds.EpmDatasetAnalysisPens.SelectedPens) != 1:
sr.msgBox('EPM Python Plugin - Demo Tools',
'Please select a single pen before applying this function!',
'Warning')
return 0
epmData = ds.EpmDatasetAnalysisPens.SelectedPens[0].values
y = epmData['Value'].copy()
x = np.arange(len(y))
fig, current_ax = pl.subplots()
pl.plot(x, y, lw=2, c='g', alpha=.3)
def line_select_callback(eclick, erelease):
'eclick and erelease are the press and release events'
x1, y1 = eclick.xdata, eclick.ydata
x2, y2 = erelease.xdata, erelease.ydata
print("\n(%3.2f, %3.2f) --> (%3.2f, %3.2f)" % (x1, y1, x2, y2))
selRect.append((int(x1), y1, int(x2), y2))
def toggle_selector(event):
if event.key in ['Q', 'q'] and toggle_selector.RS.active:
toggle_selector.RS.set_active(False)
if event.key in ['A', 'a'] and not toggle_selector.RS.active:
toggle_selector.RS.set_active(True)
toggle_selector.RS = RectangleSelector(current_ax,
line_select_callback,
drawtype='box',
useblit=True,
button=[1, 3],
minspanx=5,
minspany=5,
spancoords='pixels')
pl.connect('key_press_event', toggle_selector)
pl.show()
return selRect
def __init__(self, X,
img_height,
img_width,
nrows = 10, ncols = 20,
startidx = 0,
figtitle="",
luminance_scale_mode=0,
colormaps = [mpl.cm.jet, mpl.cm.gray],
vmin = None, vmax = None,
transpose_img=False):
self.X = X
self.img_height = img_height
self.img_width = img_width
self.nrows = nrows
self.ncols = ncols
self.figtitle = figtitle
self.startidx = startidx
# appearance control
self.luminance_scale_mode = luminance_scale_mode
self.interpolation = 'nearest'
self.colormaps = colormaps
self.cmapchoice = 0
self.show_colorbar = True
self.disable_ticks = True
self.vmin = vmin
self.vmax = vmax
self.transpose_img = transpose_img
# plot it
self.draw()
mpl.connect('key_press_event', self.keyPressed)
# connect('button_press_event', self.__clicked)
# start interactive loop
mpl.show()
def make_mask(data_file, mask_file='none'):
global key, x, y, lc, data, im, xy, mymask, xx, yy, px, lx, lm, default_mask, maskfig
# determine if a point is inside a given polygon or not
# Polygon is a list of (x,y) pairs.
#read input parameters
print "masking the edf file"
print "use mouse to select a region"
print "m - to mask selected region"
print "u - to unmask selected region"
print "a - to cancel selected region"
print "w - to save mask and exit"
#print "e - to exit"
data = loadedf(data_file)
lx, ly = shape(data)
if os.path.exists(mask_file) is True:
mymask = loadedf(mask_file, 0)
automask = loadedf(mask_file, 1)
if shape(mymask) != shape(data):
mymask = zeros((lx, ly))
else:
mymask = zeros((lx, ly))
automask = zeros((lx, ly))
#points=[]
#for i in range(lx):
# for j in range(ly):
# points.append([i,j])
x, y = meshgrid(arange(lx), arange(ly))
x, y = x.flatten(), y.flatten()
points = vstack((x, y)).T
key = []
x = 0
y = 0
xy = []
xx = []
yy = []
print "Make Mask"
def on_click(event):
print "On click"
global key, x, y, lc, data, im, xy, mymask, xx, yy, px, lx, lm, default_mask, maskfig
if not event.inaxes:
xy = []
return
x, y = int(event.xdata), int(event.ydata)
xx.append([x])
yy.append([y])
xy.append([y, x])
lc.set_data(xx, yy)
p.draw()
def on_click_key(event):
global key, x, y, lc, data, im, xy, mymask, xx, yy, px, lx, lm, default_mask, maskfig
key = event.key
if not event.inaxes:
xy = []
return
if key == 'a':
xx = []
yy = []
xy = []
x = 0
y = 0
lc.set_data(xx, yy)
lm.set_data(xx, yy)
p.draw()
if key == 'm':
#print 'masking'
xx.append(xx[0]) #xx[-1]=xx[0]
yy.append(yy[0]) #yy[-1]=yy[0]
xy.append(xy[0]) #xy[-1]=xy[0]
#ind=points_inside_poly(points,xy).reshape(lx,ly).T
ind = contains_path(points, xy).reshape(lx, ly).T
mymask[ind] = 1
data = masked_array(data, mymask + automask)
im.set_data(data)
xx = []
yy = []
xy = []
lc.set_data(xx, yy)
lm.set_data(xx, yy)
p.draw()
x = 0
y = 0
print "key m pressed"
if key == 'u':
xx.append(xx[0]) #xx[-1]=xx[0]
yy.append(yy[0]) #yy[-1]=yy[0]
xy.append(xy[0]) #xy[-1]=xy[0]
ind = points_inside_poly(points, xy).reshape(lx, ly).T
mymask[ind] = 0
data = masked_array(data, mymask + automask)
im.set_data(data)
xx = []
yy = []
xy = []
lc.set_data(xx, yy)
lm.set_data(xx, yy)
p.draw()
x = 0
y = 0
print "key u pressed"
if key == 'r':
mymask = 0 * mymask
mymask = mymask.reshape(lx, ly)
data = masked_array(data, mymask + automask)
im.set_data(data)
xx = []
yy = []
xy = []
lc.set_data(xx, yy)
lm.set_data(xx, yy)
p.draw()
x = 0
y = 0
print "key r pressed"
if key == 'w':
p.close()
saveedf(mask_file, mymask, 0)
saveedf(mask_file, automask, 1)
print "key w pressed, CLOSING"
return
def on_move(event):
#print"On move"
global lm, x, y
if not event.inaxes: return
xm, ym = int(event.xdata), int(event.ydata)
# update the line positions
if x != 0:
lm.set_data((x, xm), (y, ym))
p.draw()
p.rc('image', origin='lower')
p.rc('image', interpolation='nearest')
p.figure()
px = p.subplot(111)
data = p.log(data + 1)
im = p.imshow(masked_array(data, mymask + automask))
p.title(
"Select a ROI. Press m to mask or u to unmask it \n w to write mask and exit"
)
lc, = px.plot((0, 0), (0, 0),
'-+m',
linewidth=1,
markersize=8,
markeredgewidth=1)
lm, = px.plot((0, 0), (0, 0),
'-+m',
linewidth=1,
markersize=8,
markeredgewidth=1)
px.set_xlim(0, ly)
px.set_ylim(0, lx)
#p.ion()
cidb = p.connect('button_press_event', on_click)
cidk = p.connect('key_press_event', on_click_key)
cidm = p.connect('motion_notify_event', on_move)
p.show()
def photcombine(a_wave,
a_f,
a_df,
a_fl,
c_wave,
c_f,
c_df,
c_fl,
f_wave,
f_dwave,
edit=False,
preference=None):
nfit = len(f_wave)
f_f = pl.zeros(nfit)
f_df = pl.zeros(nfit)
f_fl = pl.zeros(nfit)
for i in range(nfit):
# TODO can't deal with flag=2,4
# are there any detections:
a_det = pl.where((abs(a_wave - f_wave[i]) <
(0.5 * f_dwave[i])) * (a_fl == 1))[0]
c_det = pl.where((abs(c_wave - f_wave[i]) <
(0.5 * f_dwave[i])) * (c_fl == 1))[0]
# are there any UL:
a_ul = pl.where((abs(a_wave - f_wave[i]) <
(0.5 * f_dwave[i])) * (a_fl == 3))[0]
c_ul = pl.where((abs(c_wave - f_wave[i]) <
(0.5 * f_dwave[i])) * (c_fl == 3))[0]
# any cat UL?
if len(c_ul) > 0:
# more than one?
if len(c_ul) > 1:
d = abs(c_wave[c_ul] - f_wave[i])
closest_c_ul = c_det[pl.where(d == d.min())[0]]
print "ambiguous catalog upper limits, choosing %f for fitter %f" % (
c_wave[closest_c_ul], f_wave[i])
print " set=", c_wave[c_ul]
else:
closest_c_ul = c_ul
else:
closest_c_ul = -1
# any app UL?
if len(a_ul) > 0:
# more than one?
if len(a_ul) > 1:
d = abs(a_wave[a_ul] - f_wave[i])
closest_a_ul = a_det[pl.where(d == d.min())[0]]
print "ambiguous apphot upper limits, choosing %f for fitter %f" % (
a_wave[closest_a_ul], f_wave[i])
print " set=", a_wave[a_ul]
else:
closest_a_ul = a_ul
else:
closest_a_ul = -1
# any app detections?
if len(a_det) > 0:
# more than one?
if len(a_det) > 1:
d = abs(a_wave[a_det] - f_wave[i])
closest_a_det = a_det[pl.where(d == d.min())[0]]
print "ambiguous apphot photometry, choosing %f for fitter %f" % (
a_wave[closest_a_det], f_wave[i])
print " set=", a_wave[a_det]
else:
closest_a_det = a_det
else:
closest_a_det = -1
# any cat detections?
if len(c_det) > 0:
# more than one?
if len(c_det) > 1:
d = abs(c_wave[c_det] - f_wave[i])
closest_c_det = c_det[pl.where(d == d.min())[0]]
print "ambiguous catalog photometry, choosing %f for fitter %f" % (
c_wave[closest_c_det], f_wave[i])
print " set=", c_wave[c_det]
else:
closest_c_det = c_det
else:
closest_c_det = -1
# combine:
if preference == "cat":
# user wants cat, there's cat det, done.
if closest_c_det >= 0:
f_f[i] = c_f[closest_c_det]
f_df[i] = c_df[closest_c_det]
f_fl[i] = 1
# throw away apphot det silently here
# TODO check if apphot UL is lower than cat_phot?
elif closest_c_ul >= 0:
# there's no det, but a cat UL - is there app det?
if closest_a_det >= 0:
if a_f[closest_a_det] <= c_f[closest_c_ul]:
# there's an appdet below the cat UL:
f_f[i] = a_f[closest_a_det]
f_df[i] = a_df[closest_a_det]
f_fl[i] = 1
else:
# there's an appdet _above_ the cat UL - WTF?
print "apphot detection brighter than catalog UL at ", f_wave[
i]
# assume apphot is wrong
f_f[i] = c_f[closest_c_ul]
f_df[i] = c_df[closest_c_ul]
f_fl[i] = 3
else:
# start with that cat UL
f_f[i] = c_f[closest_c_ul]
f_df[i] = c_df[closest_c_ul]
f_fl[i] = 3
# now if there's also an app UL
if closest_a_ul >= 0:
# and its lower
if a_f[closest_a_ul] <= c_f[closest_c_ul]:
# use lower app UL instead of cat UL:
f_f[i] = a_f[closest_a_ul]
f_df[i] = a_df[closest_a_ul]
f_fl[i] = 3
else:
# user wanted cat, but there's no cat.
if closest_a_det >= 0:
f_f[i] = a_f[closest_a_det]
f_df[i] = a_df[closest_a_det]
f_fl[i] = 1
elif closest_a_ul >= 0:
f_f[i] = a_f[closest_a_ul]
f_df[i] = a_df[closest_a_ul]
f_fl[i] = 3
# otherwise they get nothing - f_fl stays=0
elif preference == "app":
# user wants app, there's app det, done.
if closest_cadet >= 0:
f_f[i] = a_f[closest_a_det]
f_df[i] = a_df[closest_a_det]
f_fl[i] = 1
# throw away catphot det silently here
# TODO check if catphot UL is lower than appphot?
elif closest_a_ul >= 0:
# there's no det, but an app UL - is there a cat det?
if closest_c_det >= 0:
if c_f[closest_c_det] <= a_f[closest_a_ul]:
# there's an catdet below the app UL:
f_f[i] = c_f[closest_c_det]
f_df[i] = c_df[closest_c_det]
f_fl[i] = 1
else:
# there's an catdet _above_ the app UL - WTF?
print "catalog detection brighter than appphot UL at ", f_wave[
i]
# assume apphot is wrong
f_f[i] = c_f[closest_c_det]
f_df[i] = c_df[closest_c_det]
f_fl[i] = 1
else:
# start with that app UL
f_f[i] = a_f[closest_a_ul]
f_df[i] = a_df[closest_a_ul]
f_fl[i] = 3
# now if there's also a cat UL
if closest_c_ul >= 0:
# and its lower
if c_f[closest_c_ul] <= a_f[closest_a_ul]:
# use lower app UL instead of cat UL:
f_f[i] = c_f[closest_c_ul]
f_df[i] = c_df[closest_c_ul]
f_fl[i] = 3
else:
# user wanted app, but there's no app.
if closest_c_det >= 0:
f_f[i] = c_f[closest_c_det]
f_df[i] = c_df[closest_c_det]
f_fl[i] = 1
elif closest_c_ul >= 0:
f_f[i] = c_f[closest_c_ul]
f_df[i] = c_df[closest_c_ul]
f_fl[i] = 3
# otherwise they get nothing - f_fl stays=0
else: # preference is neither cat nor app:
# implicit preference for cat but some averaging
if closest_c_det >= 0:
if closest_a_det >= 0:
# 2 dets -average
f_f[i] = 0.5 (c_f[closest_c_det] + a_f[closest_a_det])
f_df[i] = max([
c_df[closest_c_det], a_df[closest_a_det],
abs(c_f[closest_c_det] - a_f[closest_a_det])
])
f_fl[i] = 1
else:
# cat det; is there an app UL?
if closest_a_ul >= 0:
if a_f[closest_a_ul] <= c_f[closest_c_det]:
print "apphot UL below cat detection at ", f_wave[
i]
# in case of discrepency, assum cat correct
f_f[i] = c_f[closest_c_det]
f_df[i] = c_df[closest_c_det]
f_fl[i] = 1
elif closest_c_ul >= 0:
# there's a catalog UL, but no det:
# start by assuming cat right
f_f[i] = c_f[closest_c_ul]
f_df[i] = c_df[closest_c_ul]
f_fl[i] = 3
if closest_a_det >= 0:
if a_f[closest_a_det] <= c_f[closest_c_ul]:
# apphot det below cat UL- replace with that
f_f[i] = a_f[closest_a_det]
f_df[i] = a_df[closest_a_det]
f_fl[i] = 1
elif closest_a_ul >= 0:
if a_f[closest_a_ul] <= c_f[closest_c_ul]:
# apphot UL below cat UL- replace with that
f_f[i] = a_f[closest_a_ul]
f_df[i] = a_df[closest_a_ul]
f_fl[i] = 3
# next, set uncert minima to 10%
z = pl.where(f_fl == 1)[0]
for zz in z:
f_df[zz] = max([f_df[zz], 0.1 * f_f[zz]])
# todo check for and set UL confidence levels?
if edit:
global whatx, fit_1, fit_3, startpos, endpos, fits_1, xs_1, x1, y1, x3, y3
# for interactive editing
# plot fit phot and prepare to edit it
z = pl.where(f_fl == 1)[0]
if len(z) > 0:
fit_1 = pl.plot(f_wave[z], f_f[z], 'r.', markersize=8,
label="fitter")[0]
fits_1 = []
for j in range(len(z)):
uncert = f_f[z[j]] + pl.array([-1, 1]) * f_df[z[j]]
#if uncert[0]<pl.ylim()[0]: uncert[0]=pl.ylim()[0]
fits_1.append(
pl.plot(f_wave[z[j]] * pl.array([1, 1]), uncert, 'r')[0])
else:
fit_1 = None
z = pl.where(f_fl == 3)[0]
if len(z) > 0:
fit_3 = pl.plot(f_wave[z], f_f[z], 'rv')[0]
else:
fit_3 = None
ndets = len(fits_1)
xs_1 = pl.zeros(ndets) # x locations of the error bars
for k in range(ndets):
xs_1[k] = fits_1[k].get_data()[0][0]
pl.legend(loc=4, prop={'size': 8}, numpoints=1)
if edit:
def click(event):
if not event.inaxes: return
global whatx, fit_1, fit_3, startpos, endpos, fits_1, xs_1, x1, y1, x3, y3
startpos = event.xdata, event.ydata
# find closest existing pt
if fit_1 == None:
# print "no fit_1?!"
x1 = []
y1 = []
d1 = pl.array([1e10])
else:
x1, y1 = fit_1.get_data()
d1 = abs(event.xdata - x1)
if fit_3 == None:
# print "no fit_3?!"
x3 = []
y3 = []
d3 = pl.array([1e10])
else:
x3, y3 = fit_3.get_data()
d3 = abs(event.xdata - x3)
# todo: for deletions, make sure we have all avail wavelength pts
# i suppose that the flux combination step that creates fit_wave
# will do that...
# print "x1=",x1
# print "x3=",x3
if len(d1) <= 0:
d1 = pl.array([1e10])
if len(d3) <= 0:
d3 = pl.array([1e10])
if d1.min() <= d3.min():
whatpoint = pl.where(d1 == d1.min())[0][0]
whatx = x1[whatpoint]
print "deleting detection %d @ " % whatpoint, whatx
fit_1.set_data(pl.delete(x1, whatpoint),
pl.delete(y1, whatpoint))
# delete the uncert error line too
# ds_1=abs(event.xdata-xs_1)
# k=pl.where(ds_1==ds_1.min())[0][0]
k = whatpoint
fits_1[k].remove()
fits_1 = pl.delete(fits_1, k)
xs_1 = pl.delete(xs_1, k)
else:
whatpoint = pl.where(d3 == d3.min())[0][0]
whatx = x3[whatpoint]
print "deleting UL %d @ " % whatpoint, whatx
x3 = pl.delete(x3, whatpoint)
y3 = pl.delete(y3, whatpoint)
fit_3.set_data(x3, y3)
if event.button == 3: #R-click
x3 = pl.append(x3, whatx)
y3 = pl.append(y3, startpos[1])
if fit_3 == None:
fit_3 = pl.plot(x3, y3, 'rv')[0]
else:
fit_3.set_data(x3, y3)
pl.draw()
# print x3
# print x1
# print xs_1
def unclick(event):
if not event.inaxes: return
global whatx, fit_1, fit_3, startpos, endpos, fits_1, xs_1, x1, y1, x3, y3
endpos = event.xdata, event.ydata
if event.button == 1:
if fit_1:
x1, y1 = fit_1.get_data()
x1 = pl.append(x1, whatx)
y1 = pl.append(y1, 0.5 * (startpos[1] + endpos[1]))
fit_1.set_data(x1, y1)
else:
fit_1 = pl.plot(whatx, 0.5 * (startpos[1] + endpos[1]),
'r.')[0]
fits_1 = []
# add this to the list of uncert lines plots
fits_1 = pl.append(
fits_1,
pl.plot([whatx, whatx], [startpos[1], endpos[1]], 'r')[0])
xs_1 = pl.append(xs_1, whatx)
# print "xs_1 = ",xs_1
# XXX TODO also set the uncert somewhere
pl.draw()
# print x3
# print x1
# print xs_1
cid0 = pl.connect('button_press_event', click)
cid1 = pl.connect('button_release_event', unclick)
print "edit fitter points and then press enter in the terminal"
x = raw_input()
pl.disconnect(cid0)
pl.disconnect(cid1)
if not fit_3 == None:
x3, y3 = fit_3.get_data()
print "upper limits are now:", x3, y3
for j in range(len(x3)):
d = abs(f_wave - x3[j])
z = pl.where(d == d.min())[0][0]
f_f[z] = y3[j]
f_fl[z] = 3
f_df[z] = 0.999 # XXXX
x1, y1 = fit_1.get_data()
print "detections are now:", x1, y1
for j in range(len(x1)):
d = abs(f_wave - x1[j])
z = pl.where(d == d.min())[0][0]
f_f[z] = y1[j]
f_fl[z] = 1
f_df[z] = 0.1 * f_f[z] # XXXX need real uncert from drawing!
return f_f, f_df, f_fl
if event.button == 3:
lon, lat = map(event.xdata, event.ydata, inverse=True)
if opts.osys == 'eq': lon = (360 - lon) % 360
lon *= a.img.deg2rad
lat *= a.img.deg2rad
ra, dec = ephem.hours(lon), ephem.degrees(lat)
x, y, z = a.coord.radec2eq((ra, dec))
flx = h[(x, y, z)]
print '#%d (RA,DEC): (%s, %s), Jy: %f' % (cnt, ra, dec, flx)
cnt += 1
elif event.button == 2:
lon, lat = map(event.xdata, event.ydata, inverse=True)
if opts.osys == 'eq': lon = (360 - lon) % 360
lon *= a.img.deg2rad
lat *= a.img.deg2rad
ra, dec = ephem.hours(lon), ephem.degrees(lat)
x, y, z = a.coord.radec2eq((ra, dec))
#flx = h[(x,y,z)]
crd = [mk_arr(c, dtype=np.double) for c in (x, y, z)]
px, wgts = h.crd2px(*crd, **{'interpolate': 1})
flx = np.sum(h[px], axis=-1)
print '#%d (RA,DEC): (%s, %s), Jy: %f (4px sum)' % (cnt, ra, dec,
flx)
cnt += 1
else:
return
#register this function with the event handler
p.connect('button_press_event', click)
p.show()
for m in markers:
m.set_visible(not m.get_visible())
self.axis.figure.canvas.draw()
else:
# t = axis.text(x,y, " - %s"%(annote), )
t = axis.text(x,y, "%s"%(annote), horizontalalignment='left', verticalalignment='bottom', size=15)
m = axis.scatter([x],[y], marker='d', c='r', zorder=100)
self.drawnAnnotations[(x,y)] =(t,m)
self.axis.figure.canvas.draw()
def drawSpecificAnnote(self, annote):
annotesToDraw = [(x,y,a) for x,y,a in self.data if a==annote]
for x,y,a in annotesToDraw:
self.drawAnnote(self.axis, x, y, a)
if __name__ == '__main__':
'''
Example code...
'''
import matplotlib.pylab as plt
x = range(10)
y = range(10)
annotes = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']
plt.scatter(x,y)
af = AnnoteFinder(x,y, annotes)
plt.connect('button_press_event', af)
plt.show()
import matplotlib.pylab as plt
from matplotlib.widgets import RectangleSelector
def line_select_callback(eclick, erelease):
x1, y1 = eclick.xdata, eclick.ydata
x2, y2 = erelease.xdata, erelease.ydata
rect = plt.Rectangle((min(x1, x2), min(y1, y2)), np.abs(x1 - x2),
np.abs(y1 - y2))
axes.add_patch(rect)
print('efd')
fig = plt.figure()
axes = fig.add_subplot(111)
axes.plot([1, 2], [3, 4])
tg = RectangleSelector(axes,
line_select_callback,
drawtype='box',
useblit=False,
button=[1, 3],
minspanx=5,
minspany=5,
spancoords='pixels',
interactive=True)
plt.connect('key_press_envent', tg)
plt.show()
####
def connect(self,ax=None):
#if ax is None: ax = self.ax
#if ax is None: ax = plt.gca()
#self.ax = ax
plt.gca()
plt.connect('motion_notify_event', self.mouse_move)
def main():
predictions = {}
scores = []
gdts = []
pdbs = []
# create a OptionParser object
parser = OptionParser()
options, args = add_options(parser)
# open a score file with the argument from OptionParser object
with open(options.score_file, 'r') as sf:
sf.readline() # jump first line
# in 1AIU/score.fsc also jump second line
sf.readline() # jump second line
eof = False
while not eof:
line = sf.readline()
if line:
l = line.split()
# fill the three lists of scores, gdts and pdbs
scores.append(float(l[1]))
gdts.append(float(l[28]))
pdbs.append(l[33])
else:
eof = True
sf.close()
# plot the energy vs gdts
plt.scatter(gdts, scores)
plt.xlabel('GDT_TS')
plt.ylabel('Energy')
plt.xlim([0,1])
# sort lists by energy
for i in range(len(pdbs)):
predictions[pdbs[i]] = (scores[i], gdts[i])
spreds = sorted(predictions.items(), key=operator.itemgetter(1))
# go through top25 predictions, calc median and find prediction p of highest GDT_TS score
maxg = 0
maxp = ""
median = 0
for p, (e, g) in spreds[:25]:
if g > maxg:
maxg = g
maxp = p
median += g
print "Maximum GDT_TS: " + maxp + " with GDT_TS = " + str(maxg)
print "Mean GDT_TS of top 25: " + str(median / (1.0 * 25))
pl1 = PymolLauncher( gdts, scores, pdbs )
pl1.set_native(options.native)
plt.connect('button_press_event', pl1)
plt.gca().set_autoscale_on(False)
# launch pymol and show plot
pymol.finish_launching()
plt.show()
"""/end Code that links the data to PymolLauncher"""
else:
def click(event):
print([event.key])
if event.key == 'm':
mode = raw_input('Enter new mode: ')
for k in plots:
try:
d = data_mode(plt_data[k], mode)
plots[k].set_data(d)
except(ValueError):
print('Unrecognized plot mode')
p.draw()
elif event.key == 'd':
max = raw_input('Enter new max: ')
try: max = float(max)
except(ValueError): max = None
drng = raw_input('Enter new drng: ')
try: drng = float(drng)
except(ValueError): drng = None
for k in plots:
_max,_drng = max, drng
if _max is None or _drng is None:
d = plots[k].get_array()
if _max is None: _max = d.max()
if _drng is None: _drng = _max - d.min()
plots[k].set_clim(vmin=_max-_drng, vmax=_max)
print('Replotting...')
p.draw()
p.connect('key_press_event', click)
p.show()
cnt = 1
def click(event):
global cnt
if not event.button in [2,3]: return
if not opts.nogrid:
lon,lat = map(event.xdata, event.ydata, inverse=True)
lon = (180 + kwds['ra'] - lon) % 360
lon *= a.img.deg2rad; lat *= a.img.deg2rad
ra,dec = ephem.hours(lon), ephem.degrees(lat)
xpx = np.around((event.xdata-1-dx1) / (dx2 - dx1) * d.shape[0] - .5)
ypx = np.around((event.ydata-1-dy1) / (dy2 - dy1) * d.shape[1] - .5)
flx = d[ypx,xpx]
if opts.mode.startswith('log'): flx = 10**flx
print('#%d (RA,DEC): (%s, %s), PX: (%d,%d) Jy: %f' % (cnt, ra, dec, xpx, ypx, flx))
else:
xpx = np.around(event.xdata)
ypx = np.around(event.ydata)
flx = d[ypx,xpx]
if opts.mode.startswith('log'): flx = 10**flx
print('#%d PX: (%d,%d) Jy: %f' % (cnt, xpx, ypx, flx))
cnt += 1
#register this function with the event handler
p.connect('button_press_event', click)
if not opts.batch:
if opts.outfile != '':
print('Saving to', opts.outfile)
p.savefig(opts.outfile)
else: p.show()
def main():
parser = OptionParser(description='Fitting to a noisy data generated by a known function')
parser.add_option("--npoints", type="int", help="number of data points")
parser.add_option("--low", type="float", help="smallest data point")
parser.add_option("--high", type="float", help="highest data point")
parser.add_option("--sigma", type="float", help="std of noise")
(options, args) = parser.parse_args()
pl.figure(1,(8,3))
pl.rcParams.update(mplrc.aps['params'])
ax = pl.subplot(1,1,1)
ax.set_xlabel(r'$L_y$')
ax.set_ylabel(r'$I_2^{A}/L_y$')
minorLocator = AutoMinorLocator(5)
ax.xaxis.set_minor_locator(minorLocator)
minorLocator = AutoMinorLocator(5)
ax.yaxis.set_minor_locator(minorLocator)
choice = 4 #4#0
off = 0
FitFuncs = [FreeLog,FreeLog2,OneLog,HalfLog,HalfLog2,ZeroLog]
FitEqs = [r'0.5N_G log(L)/L+',r'b \, log(L)/L+',r'log(L)/L+',r'0.5log(L)/L+',r'0.5log(\frac{\rho_s}{c}L)/L+','']
for i,fit in enumerate(FitEqs):
if choice == 1: FitEqs[i] = r'a+'+fit+r'c(b,\gamma_{free})/L'
elif choice == 3: FitEqs[i] = r'a+'+fit+r'c(\gamma_{free})/L'
elif choice == 4: FitEqs[i] = r'a+'+fit+r'\gamma_{ord}/L'
else: FitEqs[i] = r'a+'+fit+r'd/L'
FitEqs[1] = FitEqs[1] + r'+d/L^2'
FitEqs[4] = FitEqs[4] + r'+d/L^2'
FitFunc = FitFuncs[choice]
FitEq = FitEqs[choice]
if choice == 0:
clab = ['a','N_G','d']
guess = np.ones(3)
elif choice == 1:
clab = ['a','b',r'\gamma_{free}','d']
guess = np.ones(4)
elif choice == 3:
clab = ['a',r'\gamma_{free}']
guess = np.ones(2)
elif choice == 4:
clab = ['a',r'\gamma_{ord}','d']
guess = np.ones(3)
else:
clab = ['a','c']
guess = np.ones(2)
ax.set_title(r'$Fit\, to\, the\, form:\, %s$' %FitEq)
pl.connect('key_press_event',kevent.press)
sigma = options.sigma
off = 1
offh = 8
beta = 184
gammae_exp = []
gammav_exp = []
#----------------------------------------------------------------------------------------------------------------------------------------------
#1/8-------------------------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------------------------
off = 0
Ls = np.array([8,16,24,32])
#MIs = np.array([0.20170987004291954, 0.16195953475521396, 0.14235010902049608, 0.13113092651426075])
#dMIs = np.array([0.00019319572927642786, 0.00023402606005673606, 0.00024543616376892271, 0.00019744156940868488])
MIs = np.array([0.20170987004291954, 0.16195953475521396, 0.14235010902049608, 0.13107297667495113])
dMIs = np.array([0.00019319572927642786, 0.00023402606005673606, 0.00024543616376892271, 0.00016942024648351241])
print Ls
coeff, var_matrix = curve_fit(FitFunc,Ls,MIs,guess,sigma=1.0/(dMIs**2))
err = np.sqrt(np.diagonal(var_matrix))
dof = len(Ls) - len(coeff)
chisq = sum(((MIs-FitFunc(Ls,*coeff))/dMIs)**2)
cdf = special.chdtrc(dof,chisq)
lab = 'Fit: '
if choice == 4:
gammav_exp.append(coeff[-2])
gammae_exp.append(err[-2])
for i in range(len(guess)):
lab += r'$%s = %0.3f(%0.3f);\,$' %(clab[i],coeff[i],err[i])
lab += r'$\chi^2/DOF=%0.2f;\,$' %(chisq/float(dof))
lab += r'$\, p-value = %0.2f$' %cdf
#pl.errorbar(Ls,MIs,dMIs,ls='',label=r'$\beta =%3.0f$'%beta,color='y')
pl.errorbar(Ls,MIs,dMIs,ls='',label=r'$Data\, for\, A/(L_xL_y)=1/8$',color=fcolors(4))
nLs = np.linspace(Ls[0],Ls[-1],100)
pl.plot(nLs,FitFunc(nLs,*coeff),label=lab,color=fcolors(4))
#----------------------------------------------------------------------------------------------------------------------------------------------
#2/8------------------------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------------------------
off = 1
Ls = np.array([4,8, 12, 16, 20, 24, 28,32])[off:]
#MIs = np.array([ 0.27140758767953033, 0.22113400442581177, 0.19095315323315157, 0.17249654628602423, 0.15946872869885381, 0.14956906776848633, 0.14271734664170935, 0.13648367829389965])[off:]
#dMIs = np.array([ 0.00035063105703284086, 0.00028390662712597328, 0.00030945156199167442, 0.00032588203068154991, 0.00021749486902703514, 0.00034962902498649281, 0.00033862852457444855,0.00027553624634053158])[off:]
MIs = np.array([ 0.27140758767953033, 0.22113400442581177, 0.19095315323315157, 0.17249654628602423, 0.15946872869885381, 0.14956906776848633, 0.14271734664170935, 0.13639189179498032])[off:]
dMIs = np.array([ 0.00035063105703284086, 0.00028390662712597328, 0.00030945156199167442, 0.00032588203068154991, 0.00021749486902703514, 0.00034962902498649281, 0.00033862852457444855,0.0002417771731823463])[off:]
coeff, var_matrix = curve_fit(FitFunc,Ls,MIs,guess,sigma=1.0/(dMIs**2))
err = np.sqrt(np.diagonal(var_matrix))
dof = len(Ls) - len(coeff)
chisq = sum(((MIs-FitFunc(Ls,*coeff))/dMIs)**2)
cdf = special.chdtrc(dof,chisq)
lab = 'Fit: '
if choice == 4:
gammav_exp.append(coeff[-2])
gammae_exp.append(err[-2])
for i in range(len(guess)):
lab += r'$%s = %0.3f(%0.3f);\,$' %(clab[i],coeff[i],err[i])
lab += r'$\chi^2/DOF=%0.2f;\,$' %(chisq/float(dof))
lab += r'$\, p-value = %0.2f$' %cdf
#pl.errorbar(Ls,MIs,dMIs,ls='',label=r'$\beta =%3.0f$'%beta,color='b')
pl.errorbar(Ls,MIs,dMIs,ls='',label=r'$Data\, for\, A/(L_xL_y)= 1/4$',color=fcolors(6))
nLs = np.linspace(Ls[0],Ls[-1],100)
pl.plot(nLs,FitFunc(nLs,*coeff),label=lab,color=fcolors(6))
#----------------------------------------------------------------------------------------------------------------------------------------------
#3/8-------------------------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------------------------
off = 0
Ls = np.array([8,16,24,32])
#MIs = np.array([0.22996345403546045, 0.17674766273907488, 0.15299083379548556, 0.13889845232701539])
#dMIs = np.array([0.00035023175479636717, 0.00039822181187702241, 0.00037804621953715169, 0.00032578195392620591])
MIs = np.array([0.22996345403546045, 0.17674766273907488, 0.15299083379548556, 0.13883803379406248])
dMIs = np.array([0.00035023175479636717, 0.00039822181187702241, 0.00037804621953715169, 0.00029383814706680241])
coeff, var_matrix = curve_fit(FitFunc,Ls,MIs,guess,sigma=1.0/(dMIs**2))
err = np.sqrt(np.diagonal(var_matrix))
dof = len(Ls) - len(coeff)
chisq = sum(((MIs-FitFunc(Ls,*coeff))/dMIs)**2)
cdf = special.chdtrc(dof,chisq)
lab = 'Fit: '
if choice == 4:
gammav_exp.append(coeff[-2])
gammae_exp.append(err[-2])
for i in range(len(guess)):
lab += r'$%s = %0.3f(%0.3f);\,$' %(clab[i],coeff[i],err[i])
lab += r'$\chi^2/DOF=%0.2f;\,$' %(chisq/float(dof))
lab += r'$\, p-value = %0.2f$' %cdf
#pl.errorbar(Ls,MIs,dMIs,ls='',label=r'$\beta =%3.0f$'%beta,color='y')
pl.errorbar(Ls,MIs,dMIs,ls='',label=r'$Data\, for\, A/(L_xL_y)=3/8$',color=fcolors(3))
nLs = np.linspace(Ls[0],Ls[-1],100)
pl.plot(nLs,FitFunc(nLs,*coeff),label=lab,color=fcolors(3))
#----------------------------------------------------------------------------------------------------------------------------------------------
# 4/8 ---------------------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------------------------
Ls = np.array([8,10, 12, 16, 20, 24,28,32])
#MIs = np.array([0.23251280150358983, 0.21337256591279627,0.19797531796757287, 0.17775003649902879, 0.16411815945015565, 0.15374365325070799, 0.14583169547075336, 0.13937802905214949])
#dMIs = np.array([0.00040395552486499571, 0.00062070973509060503,0.00043835040610511769, 0.00046104739832369675, 0.00030739428405506897, 0.00043982489905168917, 0.00047582622823638226, 0.00037807728176096899])
MIs = np.array([0.23251280150358983, 0.21337256591279627,0.19797531796757287, 0.17775003649902879, 0.16411815945015565, 0.15374365325070799, 0.14583169547075336, 0.13931301552362246])
dMIs = np.array([0.00040395552486499571, 0.00062070973509060503,0.00043835040610511769, 0.00046104739832369675, 0.00030739428405506897, 0.00043982489905168917, 0.00047582622823638226, 0.00033882833155090007])
coeff, var_matrix = curve_fit(FitFunc,Ls,MIs,guess,sigma=1.0/(dMIs**2))
err = np.sqrt(np.diagonal(var_matrix))
dof = len(Ls) - len(coeff)
chisq = sum(((MIs-FitFunc(Ls,*coeff))/dMIs)**2)
cdf = special.chdtrc(dof,chisq)
lab = 'Fit: '
if choice == 4:
gammav_exp.append(coeff[-2])
gammae_exp.append(err[-2])
for i in range(len(guess)):
lab += r'$%s = %0.3f(%0.3f);\,$' %(clab[i],coeff[i],err[i])
lab += r'$\chi^2/DOF=%0.2f;\,$' %(chisq/float(dof))
lab += r'$\, p-value = %0.2f$' %cdf
#pl.errorbar(Ls,MIs,dMIs,ls='',label=r'$\beta =%3.0f$'%beta,color='y')
pl.errorbar(Ls,MIs,dMIs,ls='',label=r'$Data\, for\, A/(L_xL_y)=0.50$',color=fcolors(2))
nLs = np.linspace(Ls[0],Ls[-1],100)
pl.plot(nLs,FitFunc(nLs,*coeff),label=lab,color=fcolors(2))
pl.tight_layout()
#ax.set_ylim([0.13,0.24])
#ax.set_xlim([7.5,32.5])
lgd = pl.legend()
lgd.draw_frame(False)
if choice == 4:
geom_exp = [0.125,0.250,0.375,0.500]
geom_thr = [0.100,0.125,0.1500,0.2000,0.2500,0.3000,0.3500,0.3750,0.4000,0.4500,0.5000]
gamma_thr = [0.598,0.672,0.7255,0.8008,0.8512,0.8866,0.9116,0.9209,0.9283,0.9379,0.9410]
print np.array(gamma_thr) - 0.5*np.log(2.0*np.pi)
pl.figure(2,(8,3))
pl.connect('key_press_event',kevent.press)
pl.rcParams.update(mplrc.aps['params'])
ax = pl.subplot(1,1,1)
ax.set_xlabel(r'$A/(L_xL_y)$')
ax.set_ylabel(r'$\gamma_{ord}$')
minorLocator = AutoMinorLocator(5)
ax.xaxis.set_minor_locator(minorLocator)
minorLocator = AutoMinorLocator(5)
ax.yaxis.set_minor_locator(minorLocator)
ax.plot(geom_thr,gamma_thr,color=colors[1],label=r"$Theory$")
ax.errorbar(geom_exp,gammav_exp,gammae_exp,
ls='', color=colors[2], label=r"$MC$")
lgd = pl.legend()
lgd.draw_frame(False)
lgd.draggable(state=True)
ax.set_xlim([0.1,0.51])
pl.tight_layout()
pl.show()
def main():
parser = argparse.ArgumentParser(description='Scaling analysis of MI as function of Beta')
parser.add_argument('fileNames', help='MI files', nargs='+')
args = parser.parse_args()
nfit = 3
cfits = ['a','b','c','d']
colors = ["#66CAAE", "#CF6BDD", "#E27844", "#7ACF57", "#92A1D6", "#E17597", "#C1B546",'b']
Z = [[0,0],[0,0]]
nhs = 6
min, max = (0, 8)
mymap = mpl.colors.LinearSegmentedColormap.from_list('mycolors',['blue','red'])
levels = np.linspace(min,max,nhs)
CS3 = pl.contourf(Z, levels, cmap=mymap)
pl.clf()
Clb = pl.colorbar(CS3) # using the colorbar info I got from contourf
Clb.ax.set_ylabel(r'$\mathrm{\beta \, [K^{-1}]}$')
ax = pl.subplot(1,1,1)
ax.set_xlabel(r'$\mathrm{L_x}$')
ax.set_ylabel(r'$\mathrm{MI/(2L_x)}$')
f,axs = pl.subplots(nfit)
pl.connect('key_press_event',kevent.press)
n = len(open(args.fileNames[0]).readlines())-1
Lxs = np.zeros(len(args.fileNames))
MIs = np.zeros((n,len(args.fileNames)))
dMIs = np.zeros((n,len(args.fileNames)))
for i,fileName in enumerate(args.fileNames):
scalarhelp = ssexyhelp.ScalarReduce(fileName)
parmap = scalarhelp.getParmap()
Lx = int(parmap['Lx'])
Lxs[i] = Lx
scalarhelp = ssexyhelp.ScalarReduce(fileName)
MIs[:,i], dMIs[:,i] = scalarhelp.getAverages('MI')
rb, Beta = scalarhelp.getrParams()
sorted_indices = np.argsort(Lxs)
Lxs = Lxs[sorted_indices]
LogCoeff = np.zeros((n,nfit))
dLogCoeff = np.zeros((n,nfit))
#chisqs = np.zeros(n)
#cdfs = np.zeros(n)
for i,b in enumerate(Beta):
MI = MIs[i,:][sorted_indices]
dMI = dMIs[i,:][sorted_indices]
LogCoeff[i,:], var_matrix = curve_fit(FreeLog1,Lxs,MI,np.ones(nfit))
dLogCoeff[i,:] = np.sqrt(np.diagonal(var_matrix))
#dof = len(Lcs) - len(LogCoeff[i,:])
#chisqs[i] = sum(((Mis-FreeLog1(Lxs,*LogCoeff))/sigma)**2)
#cdfs = special.chdtrc(dof,chisq)
for i in range(nfit):
axs[i].errorbar(Beta,LogCoeff[:,i],dLogCoeff[:,i], label=r"$\mathrm{a+b*log(L)/L+c/L}$")
#axs[i].set_xlabel(r'$\mathrm{\beta}[K^{-1}]$')
axs[i].set_xlabel(r'$\mathrm{\beta}[K^{-1}]$')
axs[i].set_ylabel(r'$\mathrm{%s}$' %cfits[i])
axs[i].legend(loc=4)
# Using contourf to provide my colorbar info, then clearing the figure
lookup_betas = range(-len(Beta),-1,1)
#lookup_betas = range(-20,-1,1)
step = float(max-min)/len(lookup_betas)
for j,i in enumerate(lookup_betas):
r = (float(step*j)-min)/(max-min)
g = 0
b = 1-r
ax.plot(Lxs,MIs[i,:][sorted_indices],marker = 'o',linestyle='',color = (r,g,b))#,label=r'$\mathrm{\beta=%0.3f}$' %Beta[i])
ax.plot(Lxs,FreeLog1(Lxs,*LogCoeff[i,:]),color = (r,g,b))
#ax.plot(Beta,MIs[:,0],color = colors[j%len(colors)])
pl.tight_layout()
ax.legend()
pl.show()
def make_mask(data_file,mask_file='none'):
global key, x, y,lc,data,im,xy,mymask,xx,yy,px,lx,lm,default_mask,maskfig
# determine if a point is inside a given polygon or not
# Polygon is a list of (x,y) pairs.
#read input parameters
print "masking the edf file"
print "use mouse to select a region"
print "m - to mask selected region"
print "u - to unmask selected region"
print "a - to cancel selected region"
print "w - to save mask and exit"
#print "e - to exit"
data=loadedf(data_file)
lx,ly=shape(data)
if os.path.exists(mask_file) is True:
mymask=loadedf(mask_file,0)
automask=loadedf(mask_file,1)
if shape(mymask)!=shape(data):
mymask=zeros((lx,ly))
else:
mymask=zeros((lx,ly))
automask=zeros((lx,ly))
#points=[]
#for i in range(lx):
# for j in range(ly):
# points.append([i,j])
x, y = meshgrid(arange(lx), arange(ly))
x, y = x.flatten(), y.flatten()
points = vstack((x,y)).T
key=[]
x=0
y=0
xy=[]
xx=[]
yy=[]
print "Make Mask"
def on_click(event):
print "On click"
global key, x, y,lc,data,im,xy,mymask,xx,yy,px,lx,lm,default_mask,maskfig
if not event.inaxes:
xy=[]
return
x,y=int(event.xdata), int(event.ydata)
xx.append([x])
yy.append([y])
xy.append([y,x])
lc.set_data(xx,yy)
p.draw()
def on_click_key(event):
global key, x, y,lc,data,im,xy,mymask,xx,yy,px,lx,lm,default_mask,maskfig
key=event.key
if not event.inaxes:
xy=[]
return
if key=='a':
xx=[]
yy=[]
xy=[]
x=0
y=0
lc.set_data(xx,yy)
lm.set_data(xx,yy)
p.draw()
if key=='m':
#print 'masking'
xx.append(xx[0])#xx[-1]=xx[0]
yy.append(yy[0])#yy[-1]=yy[0]
xy.append(xy[0])#xy[-1]=xy[0]
ind=points_inside_poly(points,xy).reshape(lx,ly).T
mymask[ind]=1
data=masked_array(data,mymask+automask)
im.set_data(data)
xx=[]
yy=[]
xy=[]
lc.set_data(xx,yy)
lm.set_data(xx,yy)
p.draw()
x=0
y=0
print "key m pressed"
if key=='u':
xx.append(xx[0])#xx[-1]=xx[0]
yy.append(yy[0])#yy[-1]=yy[0]
xy.append(xy[0])#xy[-1]=xy[0]
ind=points_inside_poly(points,xy).reshape(lx,ly).T
mymask[ind]=0
data=masked_array(data,mymask+automask)
im.set_data(data)
xx=[]
yy=[]
xy=[]
lc.set_data(xx,yy)
lm.set_data(xx,yy)
p.draw()
x=0
y=0
print "key u pressed"
if key=='r':
mymask=0*mymask
mymask=mymask.reshape(lx,ly)
data=masked_array(data,mymask+automask)
im.set_data(data)
xx=[]
yy=[]
xy=[]
lc.set_data(xx,yy)
lm.set_data(xx,yy)
p.draw()
x=0
y=0
print "key r pressed"
if key=='w':
p.close()
saveedf(mask_file,mymask,0)
saveedf(mask_file,automask,1)
print "key w pressed, CLOSING"
return
def on_move(event):
#print"On move"
global lm,x,y
if not event.inaxes: return
xm,ym=int(event.xdata), int(event.ydata)
# update the line positions
if x!=0:
lm.set_data((x,xm),(y,ym))
p.draw()
p.rc('image',origin = 'lower')
p.rc('image',interpolation = 'nearest')
p.figure()
px=p.subplot(111)
data=p.log(data+1)
im=p.imshow(masked_array(data,mymask+automask))
p.title("Select a ROI. Press m to mask or u to unmask it \n w to write mask and exit")
lc,=px.plot((0,0),(0,0),'-+m',linewidth=1,markersize=8,markeredgewidth=1)
lm,=px.plot((0,0),(0,0),'-+m',linewidth=1,markersize=8,markeredgewidth=1)
px.set_xlim(0,ly)
px.set_ylim(0,lx)
#p.ion()
cidb=p.connect('button_press_event',on_click)
cidk=p.connect('key_press_event',on_click_key)
cidm=p.connect('motion_notify_event',on_move)
p.show()
for k in plots:
try:
d = data_mode(plt_data[k], mode)
plots[k].set_data(d)
except (ValueError):
print('Unrecognized plot mode')
p.draw()
elif event.key == 'd':
max = raw_input('Enter new max: ')
try:
max = float(max)
except (ValueError):
max = None
drng = raw_input('Enter new drng: ')
try:
drng = float(drng)
except (ValueError):
drng = None
for k in plots:
_max, _drng = max, drng
if _max is None or _drng is None:
d = plots[k].get_array()
if _max is None: _max = d.max()
if _drng is None: _drng = _max - d.min()
plots[k].set_clim(vmin=_max - _drng, vmax=_max)
print('Replotting...')
p.draw()
p.connect('key_press_event', click)
p.show()
'cy': test_coords[:, 1]
})
test_coords_rec = test_coords_df.to_records(index=False)
fid.create_table('/', 'coords', obj=test_coords_rec)
else:
continue
if _debug:
fig, ax = plt.subplots(1, 1)
ax.imshow(img, cmap='gray')
ax.plot(coords[..., 0], coords[..., 1], '.r')
toggle_selector.RS = RectangleSelector(
ax,
line_select_callback,
drawtype='box',
useblit=True,
button=[1, 3], # don't use middle button
minspanx=5,
minspany=5,
spancoords='pixels',
interactive=True)
toggle_selector.is_finished = False
plt.connect('key_press_event', toggle_selector)
plt.show()
while not toggle_selector.is_finished:
plt.pause(0.5)
plt.close()
def _plot_tc(tc,x,y,plant_id, title,xlabel,ylabel, split=False, merge_unique=False, content='scatter', legend=str, print_fct=None, cla=True):
"""
actual ploting done by `plot_stat` and `plot_compare`
legend: a function that convert label into string
content: either 'scatter' or 'box'
"""
import matplotlib.pyplot as plt
from matplotlib import pylab
from matplotlib.backends import backend, interactive_bk
if cla:
plt.cla()
if split is None:
plt.plot(x, y, '.')
if print_fct: print_fct(title,x,y)
else:
if isinstance(split,basestring):
split = ['metadata'] + split.split('.')
label = [reduce(getattr, [t]+split) for t in tc]
label = np.array(label)
label_set = np.unique(label)
else:
label=[]
for spl in split:
spl = ['metadata'] + spl.split('.')
label.append([reduce(getattr, [t]+spl) for t in tc])
from rhizoscan.ndarray import unique_rows
label = np.array(label).T
label_set = unique_rows(label)
if content=='scatter':
color = ['b','g','r','c','m','y','k']
for i,lab in enumerate(label_set):
lab_mask = label==lab
if lab_mask.ndim>1: lab_mask = lab_mask.all(axis=-1)
yi = y[lab_mask]
xi = x[lab_mask]
if merge_unique:
pos = np.concatenate([xi[:,None],yi[:,None]],axis=-1)
pos = np.ascontiguousarray(pos).view([('x',pos.dtype),('y',pos.dtype)])
v,s = np.unique(pos, return_inverse=1)
size = np.bincount(s)
xi,yi = v['x'],v['y']
else:
size = 2
label_str = legend(lab)
colori = color[i%len(color)]
plt.scatter(xi, yi, s=8*size, c=colori, edgecolors='none', label=label_str)
if print_fct: print_fct(title+' - '+label_str, xi,yi)
plt.legend(loc=0)
else: # if content=='box':
boxes = []
names = []
for i,lab in enumerate(label_set):
lab_mask = label==lab
if lab_mask.ndim>1: lab_mask = lab_mask.all(axis=-1)
#xi = x[lab_mask]
boxes.append(y[lab_mask])
names.append(legend(lab))
bp = plt.boxplot(boxes)
for f in bp['fliers']: f.remove()
plt.xticks(range(1,len(names)+1),names)
ax = plt.gca()
ax.set_xlabel(xlabel)
ax.set_ylabel(ylabel)
ax.set_title(title)
if backend in interactive_bk:
ax.tree_data = _Mapping(title=title,x=x,y=y,tc=tc, plant_id=plant_id)
flag = '_ROOT_MEASUREMENT_CB'
if not hasattr(plt.gcf(),flag):
cid = pylab.connect('button_press_event', _plot_axe_selected_tree)
setattr(plt.gcf(),flag,cid)
return ax
def multi_plot(tc, split='metadata.date', scale=1):
""" deprecated """
import matplotlib.pyplot as plt
from matplotlib import pylab
import time
plt.clf()
plt.subplot(2, 2, 1) #3,1)#plt.figure(3)
plot(tc,
stat='total_length',
title='Total root length',
split=split,
legend=True,
scale=scale)
plt.subplot(2, 2, 2) #3,2)#plt.figure(1)
plot(tc,
stat='axe1_length',
title='Length of primary axes',
split=split,
legend=False,
scale=scale)
plt.subplot(2, 2, 3) #3,3)#plt.figure(2)
plot(tc,
stat='axe2_length_total',
title='Total length of secondary axes',
split=split,
legend=False,
scale=scale)
plt.subplot(2, 2, 4) #3,4)#plt.figure(4)
plot(tc,
stat='axe2_number',
title='Number of secondary axes',
split=split,
legend=False,
merge_unique=1)
#plt.subplot(2,3,5)#plt.figure(4)
#plot(tc, stat='ramification_length', title='longueur de ramification', split=split, legend=False)
plt.subplot(2, 2, 1).set_xlabel('')
plt.subplot(2, 2, 2).set_xlabel('')
plt.subplot(2, 2, 2).set_ylabel('')
plt.subplot(2, 2, 4).set_ylabel('')
def display_tree(event):
if event.button != 3: return
plt.axes(event.inaxes)
data = getattr(plt.gca(), 'tree_data')
x, y = event.xdata, event.ydata
d2 = ((data.x - x)**2 + (data.y - y)**2)
stat = data.stat
pid, a, r = data.trees[np.argmin(d2)]
f = plt.gcf().number #get_figure()
#plt.subplot(2,3,6)
plt.figure(f + 41)
# plot reference in red
r.tree.plot(bg='k', sc='r')
# plot auto in color map suitable to shown stat
saxe = a.tree.segment.axe
order = a.tree.axe.order()
ind = saxe >= -1
amask = a.tree.axe.plant == pid
smask = amask[a.tree.segment.axe]
smask &= (a.tree.segment.node != 0).all(axis=1)
if stat == 'axe1_length': sc = order[saxe * (saxe > 0)] + 2
elif stat == 'axe2_length': sc = order[saxe * (saxe > 0)] + 2
elif stat == 'total_length': sc = 2 * (saxe > 0) + 3 * (saxe == -1)
else:
sc = 2 * (saxe > 0) + 3 * (saxe == -1
) #saxe*(order[saxe*(saxe>0)]==2)
#elif stat=='total_length': sc = 2*(saxe>0)+3*(saxe==-1)
#elif stat=='axe2_number': sc = 2*(saxe>0)+3*(saxe==-1)#saxe*(order[saxe*(saxe>0)]==2)
a.tree.plot(bg=None, sc=sc, indices=ind) #smask)
# display a line abov and below the selected root plant
#slist = set([s for slist in a.tree.axe.segment[a.tree.axe.plant==pid] for s in slist])
#slist.discard(0)
#smask = a.tree.axe.plant[a.tree.segment.axe]==pid
#smask[0] = 0
#smask[a.tree.segment.seed!=pid] = 0
smask = a.tree.segment.seed == pid
node = np.unique(a.tree.segment.node[smask])
node = node[node > 0]
pos = a.tree.node.position[:, node]
x0, y0 = pos.min(axis=1) * 0.95
x1, y1 = pos.max(axis=1) * 1.05
plt.plot([x0, x0, x1, x1], [y1, y0, y0, y1], 'g', linewidth=3)
#plt.plot([x0,x1],[y1,y1], 'g', linewidth=3)
# display title
meta = a.tree.metadata
title = meta.genotype.name + ' at ' + time.asctime(meta.date)
plt.title(title)
print title
#plt.figure(f)
flag = '_ROOT_MEASUREMENT_CB'
if not hasattr(plt.gcf(), flag):
cid = pylab.connect('button_press_event', display_tree)
setattr(plt.gcf(), flag, cid)
