def get_oxygen_to_hif(self, degree=1, render=False):
"""
Returns coefficients for ultra-hypoxia and hypoxia polynomials to be
used by cancer cells if the warburg
switch has *NOT* been activated. At present, only hypoxic threshold is
changed whereas ultra-hypoxic is left as-is.
Parameters
----------
degree : int, optional
Degree of the generated polynomial. Optional, defaults to 1.
render : bool, optional
If set to true, will display the generated function
Returns
-------
list
Coefficients of polynomial for ultra-hypoxia
list
Coefficients of polynomial for hypoxia
"""
points = [
# Points below 0.02
(0, 0),
(self.ultra_hypoxia_threshold, self.max_hif),
# Points to 0.02
(self.ultra_hypoxia_threshold, self.max_hif),
(self.hypoxia_threshold, 1),
]
xs = [p[0] for p in points]
ys = [p[1] for p in points]
# Fitting points between 0.02 and 0.2
xsAscending = [xs[0], xs[1]]
ysAscending = [ys[0], ys[1]]
pA = Polynomial.fit(xsAscending, ysAscending, degree)
# Fitting points between 0.02 and 0
xsDescending = [xs[2], xs[3]]
ysDescending = [ys[2], ys[3]]
pD = Polynomial.fit(xsDescending, ysDescending, degree)
# Getting data to reproduce polynomials, use of sort:
# p = Polynomial(coef=[list of coeffs], domain=[xstart, xend])
if render:
plt.plot(*pA.linspace(), label="Ascending", color="orange")
plt.plot(*pD.linspace(), label="Descending", color="green")
plt.scatter(xs, ys, label="Raw Points")
plt.legend()
plt.xlabel("Oxygen Saturation (%)")
plt.ylabel("Relative HIF Expression Rates")
plt.title("Oxygen Saturation to Relative HIF Expression Rates")
plt.show()
return [round(c, 2)
for c in list(pA.coef)], [round(c, 2) for c in list(pD.coef)]
def video_efficiency(self, usuario):
x_eff_video_1 = array([70.0, 85.0, 100.0])
y_eff_video_1 = array([75.0, 85.0, 100.0])
pol_eff_video_1 = Polynomial.fit(x_eff_video_1, y_eff_video_1, 2)
x_eff_video_2 = array([100.0, 150.0, 200.0, 250.0, 300.0])
y_eff_video_2 = array([100.0, 60.0, 30.0, 10.0, 0.0])
pol_eff_video_2 = Polynomial.fit(x_eff_video_2, y_eff_video_2, 2)
subject_videos = GqlQuery("SELECT * FROM ViewerVideo")
videosAbove70 = 0
videoPoints = 0
for subject_video in subject_videos:
userVideo = GqlQuery("SELECT * FROM UserVideo WHERE video = :1 AND user = :2", subject_video.video, usuario.user).get()
if(userVideo != None):
porcentajeVideo = (userVideo.seconds_watched/userVideo.duration)*100
if(porcentajeVideo > 70):
videosAbove70 += 1
if(porcentajeVideo >= 100):
videoPoints += pol_eff_video_2(porcentajeVideo)
if(porcentajeVideo < 100):
videoPoints += pol_eff_video_1(porcentajeVideo)
if(videosAbove70 != 0):
videoPoints = int(videoPoints/videosAbove70)
return videoPoints
def correct_minority_voltage(plot_name, minority_voltage):
"""correct for the slope of the voltage curve
fit a line to the beginning and end of the minority voltage
curve. then subtract the line from the curve to remove the slope.
The special selection of the x values is, because we can't fit the peak,
we can only fit the more or less linear parts of the input curve.
"""
global coordinate
xs = numpy.linspace(0, 239, 240)
xs = numpy.concatenate((xs, numpy.linspace(310, 399, 90)))
xs = numpy.concatenate((xs, numpy.linspace(1200, len(minority_voltage) - 1, len(minority_voltage) - 1200)))
selected_minority_voltage = minority_voltage[0:240] + minority_voltage[310:400] + minority_voltage[1200:]
corrected = []
fit = Poly.fit(xs, selected_minority_voltage, 1)
for i, min_v in enumerate(minority_voltage):
corrected.append(min_v - fit(i))
# make a plot for visual inspection of the fit quality
full_xs = numpy.linspace(0, xs[-1], len(minority_voltage))
plot = fig.add_subplot(y_max, x_max, coordinate)
plt.title(plot_name)
plt.plot(full_xs, fit(full_xs), label="fit")
plt.plot(full_xs, minority_voltage, label="minority voltage")
plt.plot(full_xs, corrected, label="corrected minority voltage")
plt.plot(full_xs, numpy.zeros(len(full_xs)), label="zero reference")
coordinate += 1
return corrected
def get_knee_level(mask, percentage_mid=0.5, percentage_side=0.15):
min_x, max_x = get_top_width(mask)
possible_indices = np.arange(np.floor(min_x), np.ceil(max_x))
mid = int(len(possible_indices) / 2)
num_pts_mid = int(len(possible_indices) * percentage_mid)
num_pts_side = int(len(possible_indices) * percentage_side)
lower_mid = int(mid - num_pts_mid / 2)
upper_mid = int(mid + num_pts_mid / 2)
x_vals = np.concatenate([
possible_indices[num_pts_side:lower_mid],
possible_indices[upper_mid:-num_pts_side]
])
y_vals = np.array([get_min_y_per_x(mask, _x) for _x in x_vals])
line = Polynomial.fit(x_vals,
y_vals,
1,
domain=[x_vals.min(), x_vals.max()])
return line(possible_indices), possible_indices
def lsf(mask, leave_out_percentage=(0.15, 0.15)):
if isinstance(leave_out_percentage, (float, int)):
bottom_percentage = top_percentage = leave_out_percentage
else:
top_percentage, bottom_percentage = leave_out_percentage
contour_points = get_contpt(mask)
if leave_out_percentage:
num_pts_top = int(len(contour_points[0]) * top_percentage)
num_pts_bottom = int(len(contour_points[0]) * bottom_percentage)
indices = np.argsort(contour_points[0])
contour_points = (contour_points[0][indices],
contour_points[1][indices])
contour_points_filtered = (
contour_points[0][num_pts_top:-num_pts_bottom],
contour_points[1][num_pts_top:-num_pts_bottom],
)
else:
contour_points_filtered = contour_points
line = Polynomial.fit(
contour_points_filtered[0],
contour_points_filtered[1],
1,
domain=[contour_points[0].min(), contour_points[0].max()],
)
return contour_points[0], line(contour_points[0])
def read_plot_power_opt():
#read new data
power_within_data = pd.read_csv("power_within_x.csv", delimiter=',')
x_within = power_within_data['Temp']
y_within = power_within_data['Power']
z_within = power_within_data['Error']
golden_data_power = pd.read_csv("golden_power_opt.csv", delimiter=',')
x_golden = golden_data_power['Temp']
y_golden = golden_data_power['Power']
z_golden = golden_data_power['Error']
print('series', x_golden, y_golden)
label2 = ' Error:' + str(error)
label1 = ' INV : ' + str(inv) + ' Header : ' + str(header)
label = label2 + label1
plt.annotate(
label,
xy=(x_golden, y_golden),
arrowprops=dict(facecolor='black', shrink=0.05),
)
p = Polynomial.fit(x, y, 3)
#print('p COEFF',p.coef)
plt.plot(*p.linspace(), 'bo')
plt.plot(x, y, color='green', linestyle='dashed', marker='o')
plt.plot(
search_points(inv, header)[0],
search_points(inv, header)[1], 'ro')
plt.show()
def get_time_per_particle(e_vs_pps_file):
"""Estimate the simulation time per primary particle, in water
at different energies. Return polynomial fit"""
# Takes E_vs_PPS data
energies, time_per_prim = [], []
for line in open(e_vs_pps_file, "r"):
values = [float(s) for s in line.strip().split()]
energies.append(values[0])
time_per_prim.append(1.0 / values[1])
plt.scatter(energies, time_per_prim)
p = Polynomial.fit(energies, time_per_prim, 2)
plt.plot(*p.linspace())
################# checking polynomial fit ##################
time = []
for en in energies:
t = -6.2931E-4 + 1.3926E-5 * en + 1.5251E-8 * en**2
time.append(t)
plt.scatter(energies, time, s=15)
############################################################
plt.ylabel("Simulation time per primary")
plt.xlabel("Energy")
plt.ylim((0, 0.005))
###print(p)
# correct coefficients
pnormal = p.convert(domain=(-1, 1))
print("time per particle polynomial params = {}".format(pnormal))
def poly(x, y, plot=False):
p = Polynomial.fit(y, x, 3)
if plot:
plt.scatter(x, y)
plt.plot(*p.linspace(), lw=3, color='r')
plt.show()
return p
def xi_csd(d, bins=np.linspace(0,15,151), nbg=0., binned=False):
from scipy import signal
from numpy.polynomial import Polynomial
np.random.seed(seed=42)
if binned==False:
actcounts, bins = np.histogram(d, bins=bins)
counts = actcounts + np.random.poisson(nbg, size=len(d))
else:counts = d + np.random.poisson(nbg, size=len(d))
counts = np.maximum(counts - nbg, np.zeros_like(counts))
centroids = (bins[1:] + bins[:-1]) / 2.
err = np.sqrt(counts+nbg)#*(counts/actcounts)
bkg=0
degree=1
pp=Polynomial.fit(centroids,counts,degree,w=1./numpy.sqrt(counts+1.))
tdata= counts/pp(centroids)
terr = err/pp(centroids)
px, py= signal.csd(tdata,tdata, fs=1./(centroids[1]-centroids[0]),scaling='spectrum',nperseg=len(centroids))
py= py.real
px= 1./px
py= numpy.sqrt(py*(centroids[-1]-centroids[0]))
nerrsim= 1000
ppy_err= numpy.empty((nerrsim,len(px)))
for ii in range(nerrsim):
tmock= terr*numpy.random.normal(size=len(centroids))
ppy_err[ii]= signal.csd(tmock,tmock,
fs=1./(centroids[1]-centroids[0]),scaling='spectrum',
nperseg=len(centroids))[1].real
py_err= numpy.sqrt(numpy.median(ppy_err,axis=0)*(centroids[-1]-centroids[0]))
#np.save('/Users/hendel/Desktop/pscrosscheck_xi_csd.npy',(d,bins,counts,tdata,terr,px,py,py_err))
return px,py,py_err
def get_hif_to_metabolic_rate(self, render=False):
"""
Returns coefficients for hif to metabolic rate. The domain of the
function is [0, maxHIF].
Parameters
----------
render : bool, optional
If set to true, will display the generated function
Returns
-------
list
Function coefficients
"""
points = [(0, self.base_oxygen_metabolic_rate), (self.max_hif, 0)]
xs = [p[0] for p in points]
ys = [p[1] for p in points]
p = Polynomial.fit(xs, ys, 2)
# Getting data to reproduce polynomials, use of sort:
# p = Polynomial(coef=[list of coeffs], domain=[xstart, xend])
if render:
plt.plot(*p.linspace(), label="Fit", color="orange")
plt.scatter(xs, ys, label="Raw Points")
plt.legend()
plt.xlabel("HIF Expression Rates")
plt.ylabel("Metabolic Rate")
plt.title("Metabolic Rates across HIF Expression Rates")
plt.show()
return [round(c, 2) for c in list(p.coef)]
def process_pal5_densdata(options):
# Read and prep data
backg= 400.
data= numpy.loadtxt('data/ibata_fig7b_raw.dat',delimiter=',')
sindx= numpy.argsort(data[:,0])
data= data[sindx]
data_lowerr= numpy.loadtxt('data/ibata_fig7b_rawlowerr.dat',delimiter=',')
sindx= numpy.argsort(data_lowerr[:,0])
data_lowerr= data_lowerr[sindx]
data_uperr= numpy.loadtxt('data/ibata_fig7b_rawuperr.dat',delimiter=',')
sindx= numpy.argsort(data_uperr[:,0])
data_uperr= data_uperr[sindx]
data_err= 0.5*(data_uperr-data_lowerr)
# CUTS
indx= (data[:,0] > options.minxi-0.05)*(data[:,0] < options.maxxi)
data= data[indx]
data_lowerr= data_lowerr[indx]
data_uperr= data_uperr[indx]
data_err= data_err[indx]
# Compute power spectrum
tdata= data[:,1]-backg
pp= Polynomial.fit(data[:,0],tdata,deg=options.polydeg,w=1./data_err[:,1])
tdata/= pp(data[:,0])
ll= data[:,0]
py= signal.csd(tdata,tdata,fs=1./(ll[1]-ll[0]),scaling='spectrum',
nperseg=len(ll))[1]
py= py.real
# Also compute the bispectrum
Bspec, Bpx= bispectrum.bispectrum(numpy.vstack((tdata,tdata)).T,
nfft=len(tdata),wind=7,nsamp=1,overlap=0)
ppyr= numpy.fabs(Bspec[len(Bspec)//2+_BISPECIND,len(Bspec)//2:].real)
ppyi= numpy.fabs(Bspec[len(Bspec)//2+_BISPECIND,len(Bspec)//2:].imag)
return (numpy.sqrt(py*(ll[-1]-ll[0])),data_err[:,1]/pp(data[:,0]),
ppyr,ppyi)
def tglob_ar6(sce, start_date, ye):
'''Provides a few time series of temperature consistent with the AR6
temperature assessment.
Assumes normal distribution which is not the case in AR6. Needs to be
revised later.
Export a data array.'''
if sce == 'ssp585_hpp':
# hpp scenario from AR6 uses the same temperature as
sce = 'ssp585'
N = 50 # Number of time series to generate
ar6_temp_df = get_ar6_temp()
df = ar6_temp_df[sce].copy()
# Assuming a normal distribution (it is not!) the standard devation is:
df['sigma'] = (df['95pc'] - df['5pc']) / (2 * 1.64)
NormD = np.random.normal(0, 1, N)
years = np.arange(start_date, ye + 1)
paths = np.zeros([N, len(years)])
for i in range(N):
p = P.fit(df.index, df['mean'] + NormD[i] * df['sigma'], 3)
paths[i, :] = p(years)
ds = xr.DataArray(paths,
coords=[np.arange(N), years],
dims=['model', 'time'])
return ds
def process_pal5_densdata(options):
# Read and prep data
backg = 400.0
data = numpy.loadtxt("data/ibata_fig7b_raw.dat", delimiter=",")
sindx = numpy.argsort(data[:, 0])
data = data[sindx]
data_lowerr = numpy.loadtxt("data/ibata_fig7b_rawlowerr.dat", delimiter=",")
sindx = numpy.argsort(data_lowerr[:, 0])
data_lowerr = data_lowerr[sindx]
data_uperr = numpy.loadtxt("data/ibata_fig7b_rawuperr.dat", delimiter=",")
sindx = numpy.argsort(data_uperr[:, 0])
data_uperr = data_uperr[sindx]
data_err = 0.5 * (data_uperr - data_lowerr)
# CUTS
indx = (data[:, 0] > options.minxi - 0.05) * (data[:, 0] < options.maxxi)
data = data[indx]
data_lowerr = data_lowerr[indx]
data_uperr = data_uperr[indx]
data_err = data_err[indx]
# Compute power spectrum
tdata = data[:, 1] - backg
pp = Polynomial.fit(data[:, 0], tdata, deg=options.polydeg, w=1.0 / data_err[:, 1])
tdata /= pp(data[:, 0])
ll = data[:, 0]
py = signal.csd(tdata, tdata, fs=1.0 / (ll[1] - ll[0]), scaling="spectrum", nperseg=len(ll))[1]
py = py.real
# Also compute the bispectrum
Bspec, Bpx = bispectrum.bispectrum(numpy.vstack((tdata, tdata)).T, nfft=len(tdata), wind=7, nsamp=1, overlap=0)
ppyr = numpy.fabs(Bspec[len(Bspec) // 2 + _BISPECIND, len(Bspec) // 2 :].real)
ppyi = numpy.fabs(Bspec[len(Bspec) // 2 + _BISPECIND, len(Bspec) // 2 :].imag)
return (numpy.sqrt(py * (ll[-1] - ll[0])), data_err[:, 1] / pp(data[:, 0]), ppyr, ppyi)
def process_mock_densdata(options):
print ("Using mock Pal 5 data from %s" % options.mockfilename)
# Read and prep data for mocks
xvid = numpy.loadtxt(options.mockfilename)
xv = xvid[:, :6]
xv = xv[numpy.argsort(xvid[:, 6])]
XYZ = bovy_coords.galcenrect_to_XYZ(xv[:, 0], xv[:, 1], xv[:, 2], Xsun=R0, Zsun=0.025)
lbd = bovy_coords.XYZ_to_lbd(XYZ[0], XYZ[1], XYZ[2], degree=True)
radec = bovy_coords.lb_to_radec(lbd[:, 0], lbd[:, 1], degree=True)
xieta = pal5_util.radec_to_pal5xieta(radec[:, 0], radec[:, 1], degree=True)
# make sure the progenitor is at (0,0)
xieta[:, 0] -= numpy.median(xieta[:, 0])
xieta[:, 1] -= numpy.median(xieta[:, 1])
h, e = numpy.histogram(xieta[:, 0], range=[0.2, 14.3], bins=141)
xdata = numpy.arange(0.25, 14.35, 0.1)
# Compute power spectrum
tdata = h - 0.0
pp = Polynomial.fit(xdata, tdata, deg=options.polydeg, w=1.0 / numpy.sqrt(h + 1.0))
tdata /= pp(xdata)
ll = xdata
py = signal.csd(tdata, tdata, fs=1.0 / (ll[1] - ll[0]), scaling="spectrum", nperseg=len(ll))[1]
py = py.real
# Also compute the bispectrum
Bspec, Bpx = bispectrum.bispectrum(numpy.vstack((tdata, tdata)).T, nfft=len(tdata), wind=7, nsamp=1, overlap=0)
ppyr = numpy.fabs(Bspec[len(Bspec) // 2 + _BISPECIND, len(Bspec) // 2 :].real)
ppyi = numpy.fabs(Bspec[len(Bspec) // 2 + _BISPECIND, len(Bspec) // 2 :].imag)
return (numpy.sqrt(py * (ll[-1] - ll[0])), numpy.sqrt(h + 1.0) / pp(xdata), ppyr, ppyi)
def read_plot_power_opt():
#read new data
power_within_data = pd.read_csv("power_within_x.csv", delimiter=',')
x_within= power_within_data['Temp']
y_within = power_within_data['Power']
z_within = power_within_data['Error']
golden_data_power = pd.read_csv("golden_power_opt.csv", delimiter=',')
x_golden = golden_data_power['Temp']
y_golden = golden_data_power['Power']
z_golden = golden_data_power['Error']
print('series', x_golden, y_golden)
plt.figure(figsize=(12,6))
label2 = ' Error:' + str(error)
label1 = ' INV : ' + str(inv) + ' Header : ' + str(header)
label = label2+label1
plt.annotate(label, xy=(x_golden, y_golden),arrowprops=dict(facecolor='yellow', shrink=0.05),)
p = Polynomial.fit(x, y, 3)
#print('p COEFF',p.coef)
plt.plot(*p.linspace(), 'bo', label='polynomial')
plt.plot(x, y, 'o')
plt.xlabel('Temperature')
plt.ylabel('Power')
plt.title('Temp Sensor Power Optimization')
plt.plot(search_points(inv, header)[0], search_points(inv, header)[1], 'ro', label='Other simulated points using the same design parameters')
plt.legend(loc='upper left', frameon=True)
plt.show()
def computeDistribution(self, d):
"""
Function computing the discrete distribution (histogram) of each
latent state over the 24h in one hour bin
"""
"""
Iterate through hours and compute histogram:
"""
count = np.zeros((len(np.arange(18)), 2), dtype=float)
i = 0
for t in np.arange(24):
if t in self.recoveryHours:
count[i, 0] = t
count[i, 1] = len(np.where(d[:, d.shape[1] - 1] == t)[0])
i += 1
idx_recHours = []
for i in self.recoveryHours:
i = float(i)
idx_recHours.append(np.where(count[:, 0] == i)[0][0])
count = count[idx_recHours, :]
"""
Fit curve on histogram : Polynomial fit
"""
p = Polynomial.fit(self.recoveryInd, count[:, 1], self.polydeg)
pConv = p.convert(domain=[-1, 1])
return count, p
def calc_level_tibia2(mask, contour_pts, lsf, vert_tol=0.025, horiz_tol=0.25):
vert_tol = vert_tol * (contour_pts[0].max() - contour_pts[0].min())
intersec = None
contour_zipped = list(zip(*contour_pts))
for pt in zip(*lsf):
if (int(pt[0]), int(pt[1])) in contour_zipped:
intersec = pt
# transform horizontal tolerance from relative to absolute
y_level_pts = np.nonzero(mask[int(intersec[0])])[0]
horiz_tol = horiz_tol * (y_level_pts.max() - y_level_pts.min())
valid_pt = ([], [])
min_y, max_y = intersec[0] - vert_tol, intersec[0] + vert_tol
min_x, max_x = intersec[1] - horiz_tol, intersec[1] + horiz_tol
for pt in zip(*contour_pts):
if min_y <= pt[0] <= max_y and min_x <= pt[1] <= max_x:
valid_pt[0].append(pt[0])
valid_pt[1].append(pt[1])
line = Polynomial.fit(valid_pt[1],
valid_pt[0],
1,
domain=[contour_pts[1].min(), contour_pts[1].max()])
_, indices_level = get_contpt(mask[int(np.mean(contour_pts[0])):])
indices_level = np.arange(indices_level.min(), indices_level.max())
return line(indices_level), indices_level
def parabola_example():
# print the type
print("PARABOLA:")
img=read_image('parabola.png')
edged=get_all_edge_points(img)
# manually entered:
points=np.array([[165, 143], [183, 92], [221, 22], [183, 442], [161, 155]])
a,b,c,d,e,f=get_conics_coefficients(points)
# display the coeffienct
print_coefficents(a,b,c,d,e,f)
discriminant=b**2-4*a*c
print("discriminant:",discriminant)
# should be 0
assert abs(discriminant)<EPLISION_DISCRMENANT
x=np.array([p[0] for p in edged ])
y=[p[1] for p in edged ]
p = Polynomial.fit(x, y, 2)
y_new=p(x)
plt.scatter(y_new,x,color='black')
plt.show()
def process_mock_densdata(options):
print("Using mock Pal 5 data from %s" % options.mockfilename)
# Read and prep data for mocks
xvid= numpy.loadtxt(options.mockfilename)
xv= xvid[:,:6]
xv= xv[numpy.argsort(xvid[:,6])]
XYZ= bovy_coords.galcenrect_to_XYZ(xv[:,0],xv[:,1],xv[:,2],
Xsun=R0,Zsun=0.025)
lbd= bovy_coords.XYZ_to_lbd(XYZ[0],XYZ[1],XYZ[2],degree=True)
radec= bovy_coords.lb_to_radec(lbd[:,0],lbd[:,1],degree=True)
xieta= pal5_util.radec_to_pal5xieta(radec[:,0],radec[:,1],degree=True)
# make sure the progenitor is at (0,0)
xieta[:,0]-= numpy.median(xieta[:,0])
xieta[:,1]-= numpy.median(xieta[:,1])
h,e= numpy.histogram(xieta[:,0],range=[0.2,14.3],bins=141)
xdata= numpy.arange(0.25,14.35,0.1)
# Compute power spectrum
tdata= h-0.
pp= Polynomial.fit(xdata,tdata,deg=options.polydeg,w=1./numpy.sqrt(h+1.))
tdata/= pp(xdata)
ll= xdata
py= signal.csd(tdata,tdata,fs=1./(ll[1]-ll[0]),scaling='spectrum',
nperseg=len(ll))[1]
py= py.real
# Also compute the bispectrum
Bspec, Bpx= bispectrum.bispectrum(numpy.vstack((tdata,tdata)).T,
nfft=len(tdata),wind=7,nsamp=1,overlap=0)
ppyr= numpy.fabs(Bspec[len(Bspec)//2+_BISPECIND,len(Bspec)//2:].real)
ppyi= numpy.fabs(Bspec[len(Bspec)//2+_BISPECIND,len(Bspec)//2:].imag)
return (numpy.sqrt(py*(ll[-1]-ll[0])),numpy.sqrt(h+1.)/pp(xdata),
ppyr,ppyi)
def calc_level_tibia1(contour_pts, percentage_mid=0.5, percentage_side=0.15):
min_x, max_x = top_width(contour_pts)
possible_indices = np.arange(np.floor(min_x), np.ceil(max_x))
mid = int(len(possible_indices) / 2)
num_pts_mid = int(len(possible_indices) * percentage_mid)
num_pts_side = int(len(possible_indices) * percentage_side)
lower_mid = int(mid - num_pts_mid / 2)
upper_mid = int(mid + num_pts_mid / 2)
x_vals = np.concatenate([
possible_indices[num_pts_side:lower_mid],
possible_indices[upper_mid:-num_pts_side],
])
y_vals = np.array([get_min_y_per_x(contour_pts, _x) for _x in x_vals])
# actual fitting
line = Polynomial.fit(x_vals,
y_vals,
1,
domain=[x_vals.min(), x_vals.max()])
return line(possible_indices), possible_indices
def fit_polynomial(data, deg=2):
poly = Polynomial.fit(data['alphas'], data['chi2'], deg)
if np.isnan(np.min(poly.coef)):
print 'RankWarning in fit'
return None
return poly
def optimal_portfolio(returns1):
n = len(returns1)
returns1 = np.asmatrix(returns1)
N = 100
mus = [10**(5.0 * t/N - 1.0) for t in range(N)]
# Convert to cvxopt matrices
S = opt.matrix(np.cov(returns1))
pbar = opt.matrix(np.mean(returns1, axis=1))
# Create constraint matrices
G = -opt.matrix(np.eye(n)) # negative n x n identity matrix
h = opt.matrix(0.0, (n, 1))
A = opt.matrix(1.0, (1, n))
b = opt.matrix(1.0)
# Calculate efficient frontier weights using quadratic programming
portfolios = [solvers.qp(mu * S, -pbar, G, h, A, b)['x']
for mu in mus]
# CALCULATE RISKS AND RETURNS FOR FRONTIER
returns1 = [blas.dot(pbar, x) for x in portfolios]
risks1 = [np.sqrt(blas.dot(x, S * x)) for x in portfolios]
# CALCULATE THE 2ND DEGREE POLYNOMIAL OF THE FRONTIER CURVE
m1 = np.polyfit(returns1, risks1, 2)
p = P.fit(returns1, risks1, 2)
#x1 = np.sqrt(m1[2] / m1[0])
# CALCULATE THE OPTIMAL PORTFOLIO
#wt = solvers.qp(opt.matrix(x1 * S), -pbar, G, h, A, b)['x']
#return np.asarray(wt), returns1, risks1
return returns1, risks1
def plot_dens_data(filename=None, backg=400., color='k',zorder=10,marker='o',
poly_deg=1,minxi=0.25,
errsim_color='k',errsim_zorder=0,
err_color=0.7,err_zorder=0,err=False):
"""Plots the power spectrum of the data"""
# Read the data
if filename == None:
data= numpy.loadtxt('data/ibata_fig7b_raw.dat',delimiter=',')
data_lowerr= numpy.loadtxt('data/ibata_fig7b_rawlowerr.dat',delimiter=',')
data_uperr= numpy.loadtxt('data/ibata_fig7b_rawuperr.dat',delimiter=',')
else:
data= numpy.loadtxt('data/fakeobs/'+filename,delimiter=',')
data_lowerr= numpy.loadtxt('data/fakeobs/'+filename+'_lower',delimiter=',')
data_uperr= numpy.loadtxt('data/fakeobs/'+filename+'_upper',delimiter=',')
sindx= numpy.argsort(data[:,0])
data= data[sindx]
sindx= numpy.argsort(data_lowerr[:,0])
data_lowerr= data_lowerr[sindx]
sindx= numpy.argsort(data_uperr[:,0])
data_uperr= data_uperr[sindx]
data_err= 0.5*(data_uperr-data_lowerr)
# CUTS
if filename == None: indx= (data[:,0] > minxi-0.05)*(data[:,0] < 14.35)
else: indx= (data[:,0] >0.)*(data[:,0] <14.4)
data= data[indx]
data_lowerr= data_lowerr[indx]
data_uperr= data_uperr[indx]
data_err= data_err[indx]
# Compute power spectrum
tdata= data[:,1]-backg
pp= Polynomial.fit(data[:,0],tdata,deg=poly_deg,w=1./data_err[:,1])
tdata/= pp(data[:,0])
data_err= data_err[:,1]/pp(data[:,0])
ll= data[:,0]
px, py= signal.csd(tdata,tdata,
fs=1./(ll[1]-ll[0]),scaling=scaling,
nperseg=len(ll))
py= py.real
px= 1./px
py= numpy.sqrt(py*(ll[-1]-ll[0]))
# Perform simulations of the noise to determine the power in the noise
nerrsim= 1000
ppy_err= numpy.empty((nerrsim,len(px)))
for ii in range(nerrsim):
tmock= data_err*numpy.random.normal(size=len(ll))
ppy_err[ii]= signal.csd(tmock,tmock,
fs=1./(ll[1]-ll[0]),scaling=scaling,
nperseg=len(ll))[1].real
py_err= numpy.sqrt(numpy.median(ppy_err,axis=0)*(ll[-1]-ll[0]))
pcut= np.nanmedian(ppy_err) # Only trust points above this, then remove noise
#loglog(px[py>pcut],numpy.sqrt(py[py>pcut]**2.-py_err[py>pcut]**2.),
# marker=marker,color=color,zorder=zorder,ls='none')
yvals = numpy.sqrt(py**2.-py_err**2.)
loglog(px,yvals,marker=marker,color=color,zorder=zorder,ls='none',label=filename)
errorbar(px[np.isnan(yvals)],py_err[np.isnan(yvals)],
yerr=numpy.array([.03+0.*px[np.isnan(yvals)],.03+0.*px[np.isnan(yvals)]]),
uplims=True,capthick=2.,ls='none',color=color,zorder=zorder)
loglog(px,py_err,lw=2.,color=errsim_color,zorder=errsim_zorder)
return None
def process_mock_densdata(options):
print("Using mock Pal 5 data from %s" % options.mockfilename)
simn = 2
dat = np.loadtxt(
'/Users/hendel/projects/streamgaps/streampepper/data/fakeobs/' +
options.mockfilename,
delimiter=',')
#fix seed for testing
if 0:
print('warning: Poisson seed fixed')
np.random.seed(42)
h = dat[simn] + np.random.poisson(options.nbg, size=len(dat[simn]))
h = np.maximum(h - options.nbg, np.zeros_like(h))
#h,e= np.histogram(xieta[:,0],range=[0.2,14.3],bins=141)
bins = np.linspace(options.ximin, options.ximax, options.nxi)
xdata = (bins[1:] + bins[:-1]) / 2.
# Compute power spectrum
tdata = h - 0.
pp = Polynomial.fit(xdata,
tdata,
deg=options.polydeg,
w=1. / np.sqrt(h + 1.))
tdata = tdata / pp(xdata)
ll = xdata
px, py = signal.csd(tdata,
tdata,
fs=1. / (ll[1] - ll[0]),
scaling='spectrum',
nperseg=len(ll))
px = 1. / px
py = py.real
py = np.sqrt(py * (ll[-1] - ll[0]))
#get ps error level
nerrsim = 1000
ppy_err = np.empty((nerrsim, len(px)))
terr = np.sqrt(h + 1. + options.nbg) / pp(xdata)
for ii in range(nerrsim):
tmock = terr * np.random.normal(size=len(ll))
ppy_err[ii] = signal.csd(tmock,
tmock,
fs=1. / (ll[1] - ll[0]),
scaling='spectrum',
nperseg=len(ll))[1].real
py_err = np.sqrt(np.median(ppy_err, axis=0) * (ll[-1] - ll[0]))
np.save('/Users/hendel/Desktop/pscrosscheck_abc.npy',
(dat[simn], bins, h, tdata, terr, px, py, py_err))
# Also compute the bispectrum
Bspec, Bpx = bispectrum.bispectrum(np.vstack((tdata, tdata)).T,
nfft=len(tdata),
wind=7,
nsamp=1,
overlap=0)
ppyr = np.fabs(Bspec[len(Bspec) // 2 + _BISPECIND, len(Bspec) // 2:].real)
ppyi = np.fabs(Bspec[len(Bspec) // 2 + _BISPECIND, len(Bspec) // 2:].imag)
return (py, terr, ppyr, ppyi, py_err)
def hyperbola_example():
# print the type
print("HYPERBOLA:")
img=read_image('hyperbola.png')
edged=get_all_edge_points(img)
selected_points=np.array([
[116,170],
[141,267],
[137,442],
[310,399],
[355,123]
])
a,b,c,d,e,f=get_conics_coefficients(selected_points)
# display the coeffienct
print_coefficents(a,b,c,d,e,f)
discriminant=b**2-4*a*c
print("discriminant:",discriminant)
# represents an hyperbola
assert discriminant>0 and abs(discriminant)>EPLISION_DISCRMENANT
# fit the data to the hypberbola
x=np.array([p[0] for p in edged if p[1]<=200])
y=[p[1] for p in edged if p[1]<=200]
p = Polynomial.fit(x, y, 2)
y_new=p(x)
plt.scatter(y_new,x,color='black')
x=np.array([p[0] for p in edged if p[1]>200])
y=[p[1] for p in edged if p[1]>200]
p = Polynomial.fit(x, y, 2)
y_new=p(x)
plt.scatter(y_new,x,color='black')
plt.show()
def __init__(self, relation, degree):
N = 100
xs = np.linspace(min(relation.x), max(relation.x), N)
polynomial = Polynomial.fit(relation.x, relation.y, deg=degree)
ys = polynomial(xs)
Curve.__init__(self, x=xs, y=ys)
self.connectPoints = True
self.label = self.latexPolynomial(polynomial.coef)
self.degree = degree
self.N = N
def check_stabilization(self):
""" Check for the stabilization of the focus
"""
if self._autofocus_iterations > 10:
p = Poly.fit(np.linspace(0, 9, num=10), self._last_pid_output_values, deg=1)
slope = p(9) - p(0)
if np.absolute(slope) < 10:
self._autofocus_stable = True
else:
self._autofocus_stable = False
return self._autofocus_stable
def displayer(plotlist3, title):
plotlist3 = relative(plotlist3)
plt.figure(figsize=(12, 4))
y = plotlist3
x = [(x / len(plotlist3)) * 100 for x in range(len(plotlist3))]
plt.plot(x, y, alpha=.5)
plt.title(title)
plt.ylabel("Sentiment of dialog relative to mean")
plt.xlabel("Percent of Movie")
p = Polynomial.fit(x, y, 30)
plt.plot(*p.linspace())
plt.show()
def get_minmax_point(self, values):
find_min = self.type == 'min' or self.type == 'tmin'
find_arg = self.type == 'tmin' or self.type == 'tmax'
pos = np.argmin(values) if find_min else np.argmax(values)
if pos == 0 or pos == len(values) - 1:
return pos if find_arg else values[pos]
poly = Polynomial.fit([pos - 1, pos, pos + 1],
[values[pos - 1], values[pos], values[pos + 1]],
deg=2)
s = poly.deriv()
x = s.roots()[0]
return x if find_arg else poly(x)
def plot(self):
hfont = {'fontname':'Sans'}
figure,axes = plt.subplots(4,1,sharex=False,figsize=(6,10))
refline=np.ones(list(self.countrydata.values())[0].relgrowthrate.size)*self.declinelevel
#axes[0].plot(refline,linewidth=3,color='g')
axes[0].plot(self.relgrowthrate,label="Relative increrase")
axes[0].plot(self.relgrowthratefive,label='5-day average')
axes[1].plot(self.active,label='Active cases')
#Do linear fit
time=np.arange(-self.recovery_time+1,1)
poly=Polynomial.fit(time, self.growth[-self.recovery_time:],1)
k=poly.coef[1]
efficiency=(poly(time)[0]/poly(time)[-1])
axes[2].plot(time,self.growth[-self.recovery_time:],label='Growth')
axes[2].plot(time,poly(time),label='Trend, eff=%s' %('{0:.2f}'.format(efficiency)))
axes[3].plot(time,self.relgrowthrate[-self.recovery_time:],label='Relative increase')
axes[3].plot(time,self.relgrowthratefive[-self.recovery_time:],label='5-day average')
axes[1].axvline(self.active.shape[0]-self.recovery_time,linestyle='dashed', color='c',label='Recovery limit')
axes[0].set_xlabel('Days since Jan 20, 2020', **hfont,fontsize=18);
axes[0].set_ylabel('Relative increase', **hfont,fontsize=18);
axes[1].set_xlabel('Days since Jan 20, 2020', **hfont,fontsize=18);
axes[1].set_ylabel('Active cases\n past %s d' %(self.recovery_time), **hfont,fontsize=18);
axes[2].set_xlabel('Active period', **hfont,fontsize=18);
axes[2].set_ylabel('Daily growth\n past %s d' %(self.recovery_time), **hfont,fontsize=18);
axes[3].set_xlabel('Active period', **hfont,fontsize=18);
axes[3].set_ylabel('Relative increase\n past %s d' %(self.recovery_time), **hfont,fontsize=18);
axes[0].legend()
axes[1].legend()
axes[2].legend()
axes[3].legend()
axes[0].set_xlim(0,self.active.size-1)
axes[0].set_ylim(0,1)
axes[1].set_xlim(0,self.active.size-1)
axes[2].set_xlim(-self.recovery_time+1,0)
axes[3].set_xlim(-self.recovery_time+1,0)
axes[3].set_ylim(0,0.4)
axes[0].grid(True)
axes[1].grid(True)
axes[2].grid(True)
axes[3].grid(True)
titlestr = self.punchline %(self.name)
#plt.subplots_adjust(top=0.8,hspace=0.4)
plt.subplots_adjust(hspace=0.4)
plt.subplots_adjust(left=0.2)
plt.suptitle(titlestr,fontsize=20);
plt.grid(True);
printstr=self.figurepath+"/Covid19_in_%s.%s" %(self.name,self.figtype)
plt.show(block=False);
figure.savefig(printstr, format=self.figtype, dpi=300);
plt.show(block=False);
def infer(self) -> Tuple[Polynomial, str]:
best = None
complexity = None
best_resid = np.inf
linear, (resid, *_) = Polynomial.fit(self.x, self.y, 1, full=True)
if resid < best_resid:
best = linear
if linear.coef[1] > self.epsilon:
complexity = 'n'
else:
complexity = '1'
# m, b = np.polyfit(np.log2(self.x), self.y, 1)
# yp = np.polyval([m, b], np.log2(self.x))
# plt.plot(self.x, yp, label=f'O(nlogn) [{m:.2f}log(x) + {b:.2f}]')
quadradic, (resid, *_) = Polynomial.fit(self.x, self.y, 2, full=True)
if resid < best_resid and quadradic.coef[2] > self.epsilon:
best = quadradic
complexity = 'n²'
return best, complexity
def calc_curve_tangent_slope(x, y, degree=3, unit='radians'):
poly = Polynomial.fit(x, y, degree)
c = poly.convert().coef
c_deriv = [i * cd for i, cd in enumerate(c)]
c_deriv = c[1:]
f_deriv = Polynomial(c_deriv)
tan_slope = f_deriv(x)
slope = np.arctan(tan_slope)
if unit == 'degree':
slope = slope / np.pi * 180.
return slope
def __init__(self, addr, max_power, power_recv=None):
Sensor.__init__(self, addr)
power_expected = array([max_power*i/100 for i in xrange(0, 110, 10)])
if power_recv is None:
power_recv = power_expected[:]
self._poly = Polynomial.fit(power_recv, power_expected, 2)
#self.least_squares(power_recv, power_expected)
self._conv = interp1d(*self._poly.linspace())
self._min_recv = min(power_recv)
self._max_recv = max(power_recv)
self._min_pow = min(power_expected)
self._max_pow = max(power_expected)
self.recv_read = 0
self.SEND_DELAY = 2
def fit_config(x):
res = Polynomial.fit(np.arange(len(x)), x, 8)
a0, a1, a2 = res.coef[:3]
v = np.random.rand()
def equations(vars):
D, THETA, k = vars
return (
k * v / D**2 - a0,
a0 * (2 * (v / D) * np.cos(THETA)) - a1,
-a0 * ((v / D)**2 * (1 - 4 * np.cos(THETA)**2)) - a2,
)
D, THETA, k = fsolve(equations, (1, 1, 1))
return D, THETA, k
def __init__(self, addr, max_power, power_recv=None):
Sensor.__init__(self, addr)
power_expected = array(
[max_power * i / 100 for i in xrange(0, 110, 10)])
if power_recv is None:
power_recv = power_expected[:]
self._poly = Polynomial.fit(power_recv, power_expected, 2)
#self.least_squares(power_recv, power_expected)
self._conv = interp1d(*self._poly.linspace())
self._min_recv = min(power_recv)
self._max_recv = max(power_recv)
self._min_pow = min(power_expected)
self._max_pow = max(power_expected)
self.recv_read = 0
self.SEND_DELAY = 2
def exercise_progress(self, usuario):
x_vid = array([0.0, 25.0, 50.0, 75.0, 100.0])
y_vid = array([0.0, 40.0, 65.0, 85.0, 100.0])
pol_exercise_progress = Polynomial.fit(x_vid, y_vid, 5)
subject_exercises = GqlQuery("SELECT * FROM ViewerExercise")
exercise_progress = 0
for subject_exercise in subject_exercises:
userExercise = GqlQuery("SELECT * FROM UserExercise WHERE exercise_model = :1 AND user = :2", subject_exercise.exercise, usuario.user).get()
if(userExercise != None):
if(userExercise._progress == 1.0):
exercise_progress += 100
else:
exercise_progress += pol_exercise_progress(userExercise._progress*100)
return int(exercise_progress/subject_exercises.count())
def video_progress(self, usuario):
x_vid = array([0.0, 50.0, 75.0, 100.0])
y_vid = array([0.0, 30.0, 55.0, 100.0])
pol_video_progress = Polynomial.fit(x_vid, y_vid, 5)
total_video_progress = 0
subject_videos = GqlQuery("SELECT * FROM ViewerVideo")
for subject_video in subject_videos:
userVideo = GqlQuery("SELECT * FROM UserVideo WHERE video = :1 AND user = :2", subject_video.video, usuario.user).get()
if(userVideo != None):
porcentajeVideo = (userVideo.seconds_watched/userVideo.duration)*100
if(porcentajeVideo >= 100):
total_video_progress += 100
else:
total_video_progress += pol_video_progress(porcentajeVideo)
return int(total_video_progress/subject_videos.count())
points = np.array([ (0.4, 0.587), (1, 0.967), (5, 5.01), (10, 10.09), (15, 15.16), (20, 20.23), (25, 25.32), (30, 30.37), (35, 35.4), (40, 40.5), (45, 45.6), (50, 50.6), (51, 51.6), (52, 52.6), (53, 53.7), (54, 54.7), (55, 54.8), (56, 54.8) ]) # get x and y vectors x = points[:,0] y = points[:,1] p = Polynomial.fit(x, y, 8) plt.plot(x,y,'o') plt.plot(*p.linspace()) plt.show()
def getCafeExptime(swasp_id, vmag):
V=np.arange(8,14.0,0.5)
t=np.array([30,120,300,900,2700])
snr=defaultdict(list)
snr[8.] = np.array([23.381,46.762,73.937,128.063,221.812])
snr[8.5] = np.array([18.572,37.144,58.731,101.724,176.192])
snr[9.] = np.array([15.306,30.612,48.402,83.835,145.206])
snr[9.5] = np.array([12.158,24.316,38.447,66.592,115.341])
snr[10.] = np.array([9.657,19.315,30.540,52.896,91.619])
snr[10.5] = np.array([7.671,15.342,24.258,42.017,72.776])
snr[11.] = np.array([6.093,12.817,19.269,33.375,57.807])
snr[11.5] = np.array([4.840,9.680,15.306,26.511,45.918])
snr[12.] = np.array([3.844,7.689,12.158,21.058,36.474])
snr[12.5] = np.array([3.05,6.108,9.657,16.727,28.972])
snr[13.] = np.array([2.426,4.852,7.671,13.287,23.014])
snr[13.5] = np.array([1.923,3.854,6.093,10.554,18.280])
coeffs_store=defaultdict(list)
for i in sorted(snr.keys()):
coeffs=np.polyfit(t,snr[i],2)
coeffs_store[i]=coeffs
tn=np.arange(30,3060,60)
besty=np.polyval(coeffs,tn)
diff=V-vmag
n=np.where(abs(diff)==min(abs(diff)))[0][0]
p=P.fit(t,snr[V[n]],2)
t1,t2=(p-args.snr).roots()
if t1<t2:
predicted=t1.real
else:
predicted=t2.real
print('Predicted exptime {0:.2f}'.format(predicted))
# round to the nearest 60
predicted = int(math.ceil(predicted/60))*60
print('Rounding up to nearest 60s {0:d}'.format(predicted))
# check for texp>2700, scale to right number of
# spectra to get required SNR
if predicted > 2700:
print('Predicted time > 2700s, looking for good combo of spectra')
snr_max = snr[V[n]][-1]
print('SNR_max @ 2700 = {0:.2f}'.format(snr_max))
n_spectra = (args.snr/snr[V[n]][-1])**2
print('This needs {0:.2f} spectra @ 2700'. format(n_spectra))
n_spectra = math.ceil(n_spectra)
print('Rounding up to next integer n_spectra = {0:d}'.format(n_spectra))
# now work out the best exptime to use to combine
# n_spectra spectra to get the desired args.snr
target_single_spectra_snr = args.snr/math.sqrt(n_spectra)
print('Working out the target SNR per spectra...')
print('To achive SNR_total = {0:d} we need {1:d} spectra of SNR_i = {2:.2f}'.format(args.snr, n_spectra, target_single_spectra_snr))
snr_range = np.polyval(coeffs_store[V[n]], tn)
diff_ss_snr = abs(snr_range - target_single_spectra_snr)
loc_ss_snr = np.where(diff_ss_snr == min(diff_ss_snr))[0][0]
predicted = tn[loc_ss_snr]
print('The best exposure time for this combination of spectra is {0:d} x {1:d}s'.format(n_spectra, predicted))
elif predicted < 0:
predicted = 60
n_spectra=1
else:
n_spectra=1
print("{0:s} {1:.2f} {2:d} x {3:.2f}s".format(swasp_id,vmag,n_spectra,predicted))
return n_spectra, predicted
def polfit_residuals(
x, y, deg, reject=None,
color='b', size=75,
xlim=None, ylim=None,
xlabel=None, ylabel=None, title=None,
use_r=False,
debugplot=0):
"""Polynomial fit with display of residuals and additional work with R.
Parameters
----------
x : 1d numpy array, float
X coordinates of the data being fitted.
y : 1d numpy array, float
Y coordinates of the data being fitted.
deg : int
Degree of the fitting polynomial.
reject : None or 1d numpy array (bool)
If not None, it must be a boolean array indicating whether a
particular point is rejected or not (i.e., the rejected points
are flagged as True in this array). Rejected points are
displayed but not used in the fit.
color : single character or 1d numpy array of characters
Color for all the symbols (single character) or for each
individual symbol (array of color names with the same length as
'x' or 'y'). If 'color' is a single character, the rejected
points are displayed in red color, whereas when 'color' is an
array of color names, rejected points are displayed with the
color provided in this array.
size : int
Marker size for all the symbols (single character) or for each
individual symbol (array of integers with the same length as
'x' or 'y').
xlim : tuple (floats)
Plot limits in the X axis.
ylim : tuple (floats)
Plot limits in the Y axis.
xlabel : string
Character string for label in X axis.
ylabel : string
Character string for label in y axis.
title : string
Character string for graph title.
use_r : bool
If True, the function computes several fits, using R, to
polynomials of degree deg, deg+1 and deg+2 (when possible).
debugplot : int
Determines whether intermediate computations and/or plots
are displayed:
00 : no debug, no plots
01 : no debug, plots without pauses
02 : no debug, plots with pauses
10 : debug, no plots
11 : debug, plots without pauses
12 : debug, plots with pauses
Return
------
poly : instance of Polynomial (numpy)
Result from the polynomial fit using numpy Polynomial. Only
points not flagged as rejected are employed in the fit.
yres : 1d numpy array, float
Residuals from polynomial fit. Note that the residuals are
computed for all the points, including the rejected ones. In
this way the dimension of this array is the same as the
dimensions of the input 'x' and 'y' arrays.
"""
# protections
if type(x) is not np.ndarray:
raise ValueError("x=" + str(x) + " must be a numpy.ndarray")
elif x.ndim != 1:
raise ValueError("x.ndim=" + str(x.ndim) + " must be 1")
if type(y) is not np.ndarray:
raise ValueError("y=" + str(y) + " must be a numpy.ndarray")
elif y.ndim != 1:
raise ValueError("y.ndim=" + str(y.ndim) + " must be 1")
npoints = x.size
if npoints != y.size:
raise ValueError("x.size != y.size")
if reject is not None:
if npoints != reject.size:
raise ValueError("x.size != reject.size")
if type(deg) not in [np.int, np.int64]:
raise ValueError("deg=" + str(deg) +
" is not a valid integer")
# select points for fit
if reject is None:
xfitted = np.copy(x)
yfitted = np.copy(y)
xrejected = None
yrejected = None
nfitted = npoints
nrejected = 0
else:
xfitted = x[np.logical_not(reject)]
yfitted = y[np.logical_not(reject)]
xrejected = x[reject]
yrejected = y[reject]
# update number of points for fit
nfitted = xfitted.size
nrejected = sum(reject)
if deg > nfitted - 1:
raise ValueError("Insufficient nfitted=" + str(nfitted) +
" for deg=" + str(deg))
# polynomial fits using R
if use_r:
from ..rutilities import LinearModelYvsX
print("\n>>> Total number of points:", nfitted)
# using orthogonal polynomials
for delta_deg in [2, 1, 0]:
deg_eff = deg + delta_deg
if deg_eff <= nfitted - 1:
myfit = LinearModelYvsX(x=xfitted, y=yfitted, degree=deg_eff,
raw=False)
print(">>> Fit with R, using orthogonal polynomials:")
print(myfit.summary)
pause_debugplot(debugplot)
# fit using raw polynomials
myfit = LinearModelYvsX(x=xfitted, y=yfitted, degree=deg, raw=True)
print(">>> Fit with R, using raw polynomials:")
print(myfit.summary)
pause_debugplot(debugplot)
# fit with requested degree (and raw polynomials)
poly = Polynomial.fit(x=xfitted, y=yfitted, deg=deg)
poly = Polynomial.cast(poly)
# compute residuals
yres = y - poly(x) # of all the points
yres_fitted = yfitted - poly(xfitted) # points employed in the fit
yres_rejected = None
if nrejected > 0:
yres_rejected = yrejected - poly(xrejected) # points rejected
if debugplot >= 10:
print(">>> Polynomial fit:\n", poly)
if debugplot % 10 != 0:
# define colors, markers and sizes for symbols
if np.array(color).size == 1:
mycolor = np.array([color] * npoints)
if reject is not None:
mycolor[reject] = 'r'
elif np.array(color).size == npoints:
mycolor = np.copy(np.array(color))
elif np.array(color).shape[0] == npoints: # assume rgb color
mycolor = np.copy(np.array(color))
else:
raise ValueError("color=" + str(color) +
" doesn't have the expected dimension")
if np.array(size).size == 1:
mysize = np.repeat([size], npoints)
elif np.array(size).size == npoints:
mysize = np.copy(np.array(size))
else:
raise ValueError("size=" + str(size) +
" doesn't have the expected dimension")
if reject is None:
cfitted = np.copy(mycolor)
crejected = None
sfitted = np.copy(mysize)
srejected = None
else:
cfitted = mycolor[np.logical_not(reject)]
crejected = mycolor[reject]
sfitted = mysize[np.logical_not(reject)]
srejected = mysize[reject]
import matplotlib
matplotlib.use('Qt4Agg')
import matplotlib.pyplot as plt
fig = plt.figure()
# residuals
ax2 = fig.add_subplot(2, 1, 2)
if xlabel is None:
ax2.set_xlabel('x')
else:
ax2.set_xlabel(xlabel)
ax2.set_ylabel('residuals')
if xlim is None:
xmin = min(x)
xmax = max(x)
dx = xmax - xmin
xmin -= dx/20
xmax += dx/20
else:
xmin, xmax = xlim
ax2.set_xlim([xmin, xmax])
ymin = min(yres_fitted)
ymax = max(yres_fitted)
dy = ymax - ymin
ymin -= dy/20
ymax += dy/20
ax2.set_ylim([ymin, ymax])
ax2.axhline(y=0.0, color="black", linestyle="dashed")
ax2.scatter(xfitted, yres_fitted, color=cfitted,
marker='o',
edgecolor='k', s=sfitted)
if nrejected > 0:
ax2.scatter(xrejected, yres_rejected,
marker='x', s=srejected,
color=crejected)
# original data and polynomial fit
ax = fig.add_subplot(2, 1, 1, sharex=ax2)
if ylabel is None:
ax.set_ylabel('y')
else:
ax.set_ylabel(ylabel)
ax.set_xlim([xmin, xmax])
if ylim is None:
ymin = min(y)
ymax = max(y)
dy = ymax - ymin
ymin -= dy/20
ymax += dy/20
else:
ymin, ymax = ylim
ax.set_ylim([ymin, ymax])
ax.scatter(xfitted, yfitted,
color=cfitted, marker='o', edgecolor='k',
s=sfitted, label="fitted data")
xpol = np.linspace(start=xmin, stop=xmax, num=1000)
ypol = poly(xpol)
ax.plot(xpol, ypol, 'c-', label="fit")
if nrejected > 0:
ax.scatter(xrejected, yrejected,
marker='x', s=srejected, color=crejected,
label="rejected")
# shrink axes and put a legend
box = ax2.get_position()
ax2.set_position([box.x0, box.y0,
box.width, box.height * 0.92])
delta_ybox = box.height*0.15
box = ax.get_position()
ax.set_position([box.x0, box.y0 - delta_ybox,
box.width, box.height * 0.92])
ax.legend(loc=3, bbox_to_anchor=(0.0, 1.1, 1., 0.07),
mode="expand", borderaxespad=0., ncol=4,
numpoints=1)
# graph title
if title is not None:
plt.title(title + "\n\n")
plt.show(block=False)
plt.pause(0.001)
pause_debugplot(debugplot)
# return result
return poly, yres
A = [3.9, 4.0, 4.1, 4.2]
E = []
for a in A:
name = 'bulk-fcc-%.1f' % a
b = a / 2
bulk = Atoms('Al',
cell=[[0, b, b],
[b, 0, b],
[b, b, 0]],
pbc=True)
k = 4
calc = GPAW(mode=PW(300), # cutoff
kpts=(k, k, k), # k-points
txt=name + '.txt') # output file
bulk.set_calculator(calc)
energy = bulk.get_potential_energy()
calc.write(name + '.gpw')
E.append(energy)
p = Polynomial.fit(A, E, 3)
a0 = p.deriv(1).roots()[0]
B = p.deriv(2)(a0) * 4 / 9 / a0 / u.J * u.m**3 * 1e-9 # GPa
print((a0, B))
assert abs(a0 - 3.9924) < 0.001
assert abs(B - 87.22) < 0.1
