def findGeometry(self):
w, b, ub, e = self.spectrumOf('b')
w, rsovera, ursovera, e = self.spectrumOf('rsovera')
wdt, dt, udt, edt = self.spectrumOf('dt')
colors = np.array([np.array(bin.color) for bin in self.bins])
ok = ub > 0
weight = ((ub)**2 + (ursovera / rsovera)**2)**(-1)
ink_errorbar(b[ok],
rsovera[ok],
xerr=ub[ok],
yerr=ursovera[ok],
colors=colors[ok],
alpha=weight[ok] / max(weight[ok]))
bestb = np.sum(b[ok] / ub[ok]**2) / np.sum(1.0 / ub[ok]**2)
bestrsovera = np.sum(rsovera[ok] / ursovera[ok]**2) / np.sum(
1.0 / ursovera[ok]**2)
plt.plot(bestb, bestrsovera, 'o', markersize=20, alpha=0.5)
ok = udt > 0.0
bestdt = np.sum(dt[ok] / udt[ok]**2) / np.sum(1.0 / udt[ok]**2)
return bestb, bestrsovera, bestdt
def plot(self, rvcs, xlim=(-.1, 0.1), ylim=(-15,15), binsize=6.0/24.0/60.0, title='', **kwargs):
for rvc in rvcs:
x, y, yerr = self.x(rvc), self.y(rvc), self.yerr(rvc)
cmap = zachopy.cmaps.one2another(bottom='white', top='orangered')
kw = dict(linewidth=0, elinewidth=1.5, capthick=1.5, marker='o', markersize=4, markeredgecolor='none')
plt.sca(self.axes[self.label])
minimumuncertainty = np.min(rvc.effective_uncertainty)
weights = np.minimum((minimumuncertainty/rvc.effective_uncertainty)**2, 1)
ink_errorbar(x, y, yerr, colors=cmap(weights), alpha=1, zorder=weights, **kw)
print weights
print cmap(weights)
ghosts = [-1,1]
for ghost in ghosts:
bwcmap = zachopy.cmaps.one2another(bottom='white', top='silver')
ink_errorbar(x+ ghost*rvc.TM.planet.period.value, y, yerr, colors=bwcmap(weights), zorder=weights, **kw)#grayscale=True,
tm = rvc.TM
chunks = ghosts
chunks.append(0)
for ghost in ghosts:
t = np.arange(tm.planet.period.value*(-0.5 + ghost), tm.planet.period.value*(0.5 + ghost), 0.01)
x, y = t, scale*(tm.stellar_rv(t=t + tm.planet.t0.value) - tm.star.gamma.value)
sorted = np.argsort(x)
x = x[sorted]
y = y[sorted]
if ghost == 0:
self.axes[self.label].plot(x, y, linewidth=1.5, alpha=1, color=cmap(0.5), zorder=0.5)
else:
self.axes[self.label].plot(x, y, linewidth=1.5, alpha=1, color='lightgray', zorder=0.5)
kw = dict(linestyle='--', linewidth=2, alpha=0.3, color='gray', zorder=-102)
self.axes[self.label].axvline(tm.planet.period.value/2.0, **kw)
self.axes[self.label].axvline(-tm.planet.period.value/2.0, **kw)
xlim = rvc.TM.planet.period.value*np.array([-0.75, 0.75])
self.axes[self.label].set_xlim(*xlim)
self.axes[self.label].set_ylim(*ylim)
ax = self.axes[self.label]
plt.setp(ax.get_xticklabels(), fontsize=8)
plt.setp(ax.get_yticklabels(), fontsize=8)
def plot(self, key, labels=False, ax=None, **kw):
self.set(key)
try:
self.ax
except AttributeError:
self.setup(ax=ax)
plt.sca(self.ax)
self.ax.set_xscale(self.xscale)
self.ax.set_yscale(self.yscale)
rlower = np.abs(self.pop.planet_radius_lower)
rupper = np.abs(self.pop.planet_radius_upper)
rissmallenough = 0.5*(rlower+rupper)/self.pop.planet_radius < 1.0/1.0#2.5#/2.5
risntzero = 0.5*(rlower+rupper) > 0.0
mlower = np.abs( self.pop.planet_mass_lower)
mupper = np.abs(self.pop.planet_mass_upper)
missmallenough = 0.5*(mlower+mupper)/self.pop.planet_mass < 1.0/1.0#2.5#/2.5
misntzero = 0.5*(mlower+mupper) > 0.0
self.ok = (rissmallenough*risntzero*missmallenough*misntzero)
#assert(len(self.ok) ==1)
#self.ok = ok.nonzero()
#self.ok = np.arange(len(self.pop.planet_mass))
x = self.pop.planet_mass[self.ok]
try:
xerr = np.vstack([-self.pop.planet_mass_lower[self.ok].filled(), self.pop.planet_mass_upper[self.ok].filled()])
except:
xerr = np.vstack([-self.pop.planet_mass_lower[self.ok], self.pop.planet_mass_upper[self.ok]])
y = self.pop.planet_radius[self.ok]
try:
yerr = np.vstack([-self.pop.planet_radius_lower[self.ok].filled(), self.pop.planet_radius_upper[self.ok].filled()])
except:
yerr = np.vstack([-self.pop.planet_radius_lower[self.ok], self.pop.planet_radius_upper[self.ok]])
#print self.ok
width=1
kw = dict(marker='o', linewidth=0, elinewidth=width, alpha=1.0, label=self.pop.name, color=self.pop.color, markeredgecolor=self.pop.color, capthick=width, capsize=2, markersize=3)
# self.ax.errorbar(x, y, xerr=xerr, yerr=yerr, **kw)
color = self.pop.color
r, g, b = zachopy.color.name2color(color.lower())
n = len(x)
rgba = np.zeros((n, 4))
rgba[:,0] = r
rgba[:,1] = g
rgba[:,2] = b
mass = x
radius = y
density = mass/radius**3
merr = 0.5*(mlower + mupper)[self.ok]
rerr = 0.5*(rlower + rupper)[self.ok]
#density_uncertainty = np.sqrt((merr/mass)**2 + 9*(rerr/radius)**2)
#density = mass/radius**3
density_uncertainty = np.sqrt((merr/mass)**2 + (rerr/radius)**2)#*density
#assert(False)
weights = np.minimum((0.1*np.sqrt(2)/density_uncertainty)**2, 1)
over = weights > 1
weights[over] = 1
kw['zorder'] = weights
#rgba[:,3] = 1.0*weights
rgba[:,:3] = 1.0 - (1.0 - rgba[:,:3])*weights.reshape(len(weights), 1)
rgba[:,3] = 1.0#*weights
#print rgba
if len(x) > 1:
self.speak(key)
ink_errorbar(x, y, xerr=xerr, yerr=yerr, colors=rgba, **kw)
#assert(False)
else:
kw['zorder'] = 1e6
self.ax.errorbar(x, y, xerr=xerr, yerr=yerr, **kw)
#l = []
#l.extend(self.pop.name)
#if len(self.ok) > 1:
"""
if len(x) > 0:
for i, name in enumerate(self.pop.name[self.ok]):
self.ax.text(x[i], y[i], name)"""
self.ax.set_ylim(*self.ylim)
self.ax.set_xlim(*self.xlim)
self.ax.set_xlabel(self.xlabel)
self.ax.set_ylabel(self.ylabel)
#self.ax.yaxis.set_major_formatter(plt.matplotlib.ticker.ScalarFormatter('{}'))
#self.ax.yaxis.set_minor_formatter(plt.matplotlib.ticker.ScalarFormatter())
if labels:
best = np.argsort(self.size)
for i in best[-10:]:
try:
plt.text(self.x[i], self.y[i], self.pop.name[i])
except:
print '!#!!@$!@$!@$'
print self.pop.name[i]
plt.draw()
