def execute(self):
c12axis = self.calculate_c12axis()
if self.interp_from_htc:
cni = self.c12axis_init.shape[0]
if self.c12axis_init[-1, 2] > 1.:
self.c12axis_init /= self.blade_length
# interpolate blade_ae distribution onto c12 distribution
self.blade_ae.c12axis = np.zeros((cni, 4))
for i in range(4):
tck = pchip(c12axis[:, 2], c12axis[:,i])
self.blade_ae.c12axis[:, i] = tck(self.c12axis_init[:, 2])
else:
ds_root = 1. / self.blade_ni_span
ds_tip = 1. / self.blade_ni_span / 3.
dist = np.array([[0., ds_root, 1],
[1., ds_tip, self.blade_ni_span]])
x = distfunc(dist)
self.blade_ae.c12axis = np.zeros((x.shape[0], 4))
for i in range(4):
tck = pchip(c12axis[:, 2], c12axis[:,i])
self.blade_ae.c12axis[:, i] = tck(x)
# scale main axis according to radius
self.blade_ae.c12axis[:,:3] *= self.blade_length
self.blade_ae.radius = self.blade_length + self.hub_radius
self.blade_ae.s = self.bladegeom.smax * self.bladegeom.s * self.blade_length
self.blade_ae.rthick = self.bladegeom.rthick * 100.
self.blade_ae.chord = self.bladegeom.chord * self.blade_length
self.blade_ae.aeset = np.ones(len(self.blade_ae.s))
def test_endslopes(self):
# this is a smoke test for gh-3453: PCHIP interpolator should not
# set edge slopes to zero if the data do not suggest zero edge derivatives
x = np.array([0.0, 0.1, 0.25, 0.35])
y1 = np.array([279.35, 0.5e3, 1.0e3, 2.5e3])
y2 = np.array([279.35, 2.5e3, 1.50e3, 1.0e3])
for pp in (pchip(x, y1), pchip(x, y2)):
for t in (x[0], x[-1]):
assert_(pp(t, 1) != 0)
def test_cast(self):
# regression test for integer input data, see gh-3453
data = np.array([[0, 4, 12, 27, 47, 60, 79, 87, 99, 100], [-33, -33, -19, -2, 12, 26, 38, 45, 53, 55]])
xx = np.arange(100)
curve = pchip(data[0], data[1])(xx)
data1 = data * 1.0
curve1 = pchip(data1[0], data1[1])(xx)
assert_allclose(curve, curve1, atol=1e-14, rtol=1e-14)
def bdrate(file1, file2, anchorfile):
if anchorfile:
anchor = flipud(loadtxt(anchorfile));
a = flipud(loadtxt(file1));
b = flipud(loadtxt(file2));
rates = [0.06,0.2];
qa = a[:,0]
qb = b[:,0]
ra = a[:,2]*8./a[:,1]
rb = b[:,2]*8./b[:,1]
bdr = zeros((4,4))
ret = {}
for m in range(0,len(met_index)):
try:
ya = a[:,3+m];
yb = b[:,3+m];
if anchorfile:
yr = anchor[:,3+m];
#p0 = interp1d(ra, ya, interp_type)(rates[0]);
#p1 = interp1d(ra, ya, interp_type)(rates[1]);
if anchorfile:
p0 = yr[0]
p1 = yr[-1]
else:
minq = 20
maxq = 55
try:
minqa_index = qa.tolist().index(minq)
maxqa_index = qa.tolist().index(maxq)
minqb_index = qb.tolist().index(minq)
maxqb_index = qb.tolist().index(maxq)
except ValueError:
q_not_found = True
minqa_index = -1
maxqa_index = 0
minqb_index = -1
maxqb_index = 0
p0 = max(ya[maxqa_index],yb[maxqb_index])
p1 = min(ya[minqa_index],yb[minqb_index])
a_rate = pchip(ya, log(ra))(arange(p0,p1,abs(p1-p0)/5000.0));
b_rate = pchip(yb, log(rb))(arange(p0,p1,abs(p1-p0)/5000.0));
if not len(a_rate) or not len(b_rate):
bdr = NaN;
else:
bdr=100 * (exp(mean(b_rate-a_rate))-1);
except ValueError:
bdr = NaN
except linalg.linalg.LinAlgError:
bdr = NaN
except IndexError:
bdr = NaN
if abs(bdr) > 1000:
bdr = NaN
ret[m] = bdr
return ret
def execute(self):
if self.interp_from_htc:
c12axis = self.c12axis_init.copy()
else:
c12axis = self.calculate_c12axis()
ds_root = 1. / self.blade_ni_span
ds_tip = 1. / self.blade_ni_span / 3.
dist = np.array([[0., ds_root, 1], [1., ds_tip, self.blade_ni_span]])
x = distfunc(dist)
self.c12axis = np.zeros((x.shape[0], 4))
for i in range(4):
tck = pchip(c12axis[:, 2], c12axis[:, i])
self.c12axis[:, i] = tck(x)
# scale main axis according to radius
self.c12axis[:, :3] *= self.blade_length
l = ((self.c12axis[1:, 0]-self.c12axis[:-1, 0])**2 +
(self.c12axis[1:, 1]-self.c12axis[:-1, 1])**2 +
(self.c12axis[1:, 2]-self.c12axis[:-1, 2])**2)**.5
self.blade_ae.s = self.bladegeom.s * sum(l) / self.bladegeom.s[-1]
self.blade_ae.rthick = self.bladegeom.rthick * 100.
self.blade_ae.chord = self.bladegeom.chord * self.blade_length
self.blade_ae.aeset = np.ones(len(self.blade_ae.s))
def interpolate(self):
pitch = np.zeros((self.nframes))
pitch[:] = self.samp_values
pitch2 = medfilt(self.samp_values, self.SMOOTH_FACTOR)
# This part in the original code is kind of confused and caused
# some problems with the extrapolated points before the first
# voiced frame and after the last voiced frame. So, I made some
# small modifications in order to make it work better.
edges = self.edges_finder(pitch)
first_sample = pitch[0]
last_sample = pitch[-1]
if len(np.nonzero(pitch2)[0]) < 2:
pitch[pitch == 0] = self.PTCH_TYP
else:
nz_pitch = pitch2[pitch2 > 0]
pitch2 = scipy_interp.pchip(np.nonzero(pitch2)[0],
nz_pitch)(range(self.nframes))
pitch[pitch == 0] = pitch2[pitch == 0]
if self.SMOOTH > 0:
pitch = medfilt(pitch, self.SMOOTH_FACTOR)
try:
if first_sample == 0:
pitch[:edges[0]-1] = pitch[edges[0]]
if last_sample == 0:
pitch[edges[-1]+1:] = pitch[edges[-1]]
except:
pass
self.samp_interp = pitch
def test_nag(self):
# Example from NAG C implementation,
# http://nag.com/numeric/cl/nagdoc_cl25/html/e01/e01bec.html
# suggested in gh-5326 as a smoke test for the way the derivatives
# are computed (see also gh-3453)
from scipy._lib.six import StringIO
dataStr = '''
7.99 0.00000E+0
8.09 0.27643E-4
8.19 0.43750E-1
8.70 0.16918E+0
9.20 0.46943E+0
10.00 0.94374E+0
12.00 0.99864E+0
15.00 0.99992E+0
20.00 0.99999E+0
'''
data = np.loadtxt(StringIO(dataStr))
pch = pchip(data[:,0], data[:,1])
resultStr = '''
7.9900 0.0000
9.1910 0.4640
10.3920 0.9645
11.5930 0.9965
12.7940 0.9992
13.9950 0.9998
15.1960 0.9999
16.3970 1.0000
17.5980 1.0000
18.7990 1.0000
20.0000 1.0000
'''
result = np.loadtxt(StringIO(resultStr))
assert_allclose(result[:,1], pch(result[:,0]), rtol=0., atol=5e-5)
def pchipPlot(X, Y, x_new, **args):
title = 'pchip_plot'
if(args.has_key('wn')):
if(type(args['wn']) == int):
title = title+str(args['wn'])
plt.figure(title)
else:
plt.figure(title)
pc = pchip(X,Y)
plt.plot(X,Y, linestyle = '-')
plt.plot(x_new, pc(x_new), linestyle = '--')
plt.legend(['original', 'Spline pchip '], loc='best')
plt.ylabel(r'epsilon', size = 12)
a=plt.gca()
a.set_yscale('log')
a.set_xscale('log')
#Here Im going to save the file on disk if the
#user want and show the plot on the screen
if(args.has_key('save')):
if(type(args['save']) == bool and args['save'] == True):
plt.savefig(title.strip()+'.png')
plt.draw()
if(args.has_key('view')):
if(type(args['view']) == bool and args['view'] == True):
plt.show()
def solve_nonlinear(self, params, unknowns, resids):
# we need to dig into the _ByObjWrapper val to get the array
# values out
# pf_in = {name: val['val'].val for name, val in params.iteritems()}
pf_in = {}
pf_in['s'] = params['s']
pf_in['x'] = params['x']
pf_in['y'] = params['y']
pf_in['z'] = params['z']
pf_in['rot_x'] = params['rot_x']
pf_in['rot_y'] = params['rot_y']
pf_in['rot_z'] = params['rot_z']
pf_in['chord'] = params['chord']
pf_in['rthick'] = params['rthick']
pf_in['p_le'] = params['p_le']
if _PGL_installed:
pf = redistribute_planform(pf_in, s=self.s_new, spline_type=self.spline_type)
else:
pf = {}
for k, v in pf_in.iteritems():
spl = pchip(pf_in['s'], v)
pf[k] = spl(self.s_new)
for k, v in pf.iteritems():
unknowns[k+self._suffix] = v
unknowns['athick'+self._suffix] = pf['chord'] * pf['rthick']
def solve_nonlinear(self, params, unknowns, resids):
# we need to dig into the _ByObjWrapper val to get the array
# values out
# pf_in = {name: val['val'].val for name, val in params.iteritems()}
pf_in = {}
pf_in["s"] = params["s"]
pf_in["x"] = params["x"]
pf_in["y"] = params["y"]
pf_in["z"] = params["z"]
pf_in["rot_x"] = params["rot_x"]
pf_in["rot_y"] = params["rot_y"]
pf_in["rot_z"] = params["rot_z"]
pf_in["chord"] = params["chord"]
pf_in["rthick"] = params["rthick"]
pf_in["p_le"] = params["p_le"]
if _PGL_installed:
pf = redistribute_planform(pf_in, s=self.s_new, spline_type=self.spline_type)
else:
pf = {}
for k, v in pf_in.iteritems():
spl = pchip(pf_in["s"], v)
pf[k] = spl(self.s_new)
for k, v in pf.iteritems():
unknowns[k + self._suffix] = v
unknowns["athick" + self._suffix] = pf["chord"] * pf["rthick"]
def __init__(self, dz, w1, w2, w3, a, b):
# INFO 1kcal = 4184e20 kg A^2 s^-2
# TODO check bounds of a, b
self.dz = dz
self.x = np.array([-dz, -dz+1, -a, -b, 0, b, a, dz-1, dz])
self.y = np.array([0, 0, w1, w2, w3, w2, w1, 0, 0])
self.pmf = pchip(self.x, self.y)
self.derivative = self.pmf.derivative(1)
def splinePlot(p, X, Y, cl, l): p.plot(X, Y, 'o', mfc=cl, c=cl) #f = interp1d(X, Y, kind='pchip') #f = splrep(X, Y, s=0) f = pchip(X, Y) nx = np.linspace(X[0], X[-1], 100) ny = [f(x) for x in nx] p.plot(nx, ny, '-', color=cl, label=l)
def test_two_points(self):
# regression test for gh-6222: pchip([0, 1], [0, 1]) fails because
# it tries to use a three-point scheme to estimate edge derivatives,
# while there are only two points available.
# Instead, it should construct a linear interpolator.
x = np.linspace(0, 1, 11)
p = pchip([0, 1], [0, 2])
assert_allclose(p(x), 2*x, atol=1e-15)
def __call__(self, z):
"""Parameters: z is a number, sequence or array.
This method makes an instance f of LinInterp callable,
so f(z) returns the interpolation value(s) at z.
"""
if self.kind == 'pchip':
return pchip(self.X, self.Y)(z)
else:
return interp1d(self.X, self.Y, kind=self.kind,
bounds_error=False)(z)
def execute(self):
self.pfOut.s = self.x.copy()
self.pfOut.blade_length = self.pfIn.blade_length
self.pfIn._compute_s()
for name in self.pfIn.list_vars():
var = getattr(self.pfIn, name)
if not isinstance(var, np.ndarray): continue
tck = pchip(self.pfIn.s, var)
newvar = tck(self.x)
setattr(self.pfOut, name, newvar)
def test_all_zeros(self):
x = np.arange(10)
y = np.zeros_like(x)
# this should work and not generate any warnings
with warnings.catch_warnings():
warnings.filterwarnings('error')
pch = pchip(x, y)
xx = np.linspace(0, 9, 101)
assert_equal(pch(xx), 0.)
def itpl(PTS,numPTS,degree,sID,eID):
t=range(len(PTS))
ipl_t=np.linspace(sID,eID,numPTS*(eID-sID)/(len(PTS)-1)+1)
newX=pchip(t,[row[0] for row in PTS])(ipl_t)
newY=pchip(t,[row[1] for row in PTS])(ipl_t)
newZ=pchip(t,[row[2] for row in PTS])(ipl_t)
if degree==1:
newX=interp1d(t,[row[0] for row in PTS],kind='slinear')(ipl_t)
newY=interp1d(t,[row[1] for row in PTS],kind='slinear')(ipl_t)
newZ=interp1d(t,[row[2] for row in PTS],kind='slinear')(ipl_t)
elif degree==2:
newX=interp1d(t,[row[0] for row in PTS],kind='quadratic')(ipl_t)
newY=interp1d(t,[row[1] for row in PTS],kind='quadratic')(ipl_t)
newZ=interp1d(t,[row[2] for row in PTS],kind='quadratic')(ipl_t)
elif degree==3:
newX=interp1d(t,[row[0] for row in PTS],kind='cubic')(ipl_t)
newY=interp1d(t,[row[1] for row in PTS],kind='cubic')(ipl_t)
newZ=interp1d(t,[row[2] for row in PTS],kind='cubic')(ipl_t)
elif degree==4:
newX=pchip(t,[row[0] for row in PTS])(ipl_t)
newY=pchip(t,[row[1] for row in PTS])(ipl_t)
newZ=pchip(t,[row[2] for row in PTS])(ipl_t)
else:
newX=interp1d(t,[row[0] for row in PTS],kind='quadratic')(ipl_t)
newY=interp1d(t,[row[1] for row in PTS],kind='quadratic')(ipl_t)
newZ=interp1d(t,[row[2] for row in PTS],kind='quadratic')(ipl_t)
outPTS=[]
for i in range(0,len(newX)):
outPTS.append([newX[i],newY[i],newZ[i]])
return outPTS
def __call__(self, x, Cx, C):
"""
params:
----------
x: array
array with new x-distribution
xp: array
array with x-coordinates of spline control points
yp: array
array with y-coordinates of spline control points
returns
---------
ynew: array
resampled points
"""
spl = pchip(Cx, C)
return spl(x)
def plot(self, full=True, dots=False, average=0, interpolated=0):
results = gym.monitoring.monitor.load_results(self.outdir)
data = results[self.data_key]
avg_data = []
if full:
plt.plot(data, color="blue")
if dots:
plt.plot(data, ".", color="black")
if average > 0:
average = int(average)
for i, val in enumerate(data):
if i % average == 0:
if (i + average) < len(data) + average:
avg = sum(data[i : i + average]) / average
avg_data.append(avg)
new_data = expand(avg_data, average)
plt.plot(new_data, color="red", linewidth=2.5)
if interpolated > 0:
avg_data = []
avg_data_points = []
n = len(data) / interpolated
if n == 0:
n = 1
data_fix = 0
for i, val in enumerate(data):
if i % n == 0:
if (i + n) <= len(data) + n:
avg = sum(data[i : i + n]) / n
avg_data.append(avg)
avg_data_points.append(i)
if (i + n) == len(data):
data_fix = n
x = np.arange(len(avg_data))
y = np.array(avg_data)
interp = pchip(avg_data_points, avg_data)
xx = np.linspace(0, len(data) - data_fix, 1000)
plt.plot(xx, interp(xx), color="green", linewidth=3.5)
# pause so matplotlib will display
# may want to figure out matplotlib animation or use a different library in the future
plt.pause(0.000001)
def calc_spec(cube, nparams):
# add on H2 and He to VMRs
vmr = cube[:nvmr]
vmrsum = np.sum(10**vmr)
h2 = h2p * (1 - vmrsum)
he = hep * (1 - vmrsum)
vmr = np.append(vmr, [np.log10(h2), np.log10(he)])
vmr = np.tile(vmr, (len(pres), 1))
# calculate temperature and height profiles
mass, rad, T0, alpha, Teff, tau0, n, Pbase, FSH, opac = cube[nvmr:nparams]
tau0 = 10**tau0
FSH = 10**FSH
# vmr, mass, rad, T0, alpha, Teff, tau0, n, Pbase, FSH, opac = pickle.load(open('prob.pic','rb'))
# pdb.set_trace()
(H, temp) = robcat.tempprof(T0, alpha, Teff, tau0, n, vmr, mass, rad)
if all(H == np.zeros(len(temp))):
return np.zeros(len(spec))
# Find height of cloud
Hbase = pchip(10**pres[::-1], H[::-1])
Hb = np.asscalar(Hbase(10**Pbase))
# find folder to calculate in
ith = 999
# run model
# pickle.dump( (vmr, mass, rad, T0, alpha, Teff, tau0, n, Pbase, FSH, opac) , open('dump.pic', 'wb'))
# pdb.set_trace()
model = nemesisPyMult.nemesispymult(runname, len(spec), len(temp),
vmr.shape[1], ith, temp, vmr, mass,
rad, H, Hb, opac, FSH, prad, pvar,
pimag, preal, Hb2, opac2, FSH2, nav,
flat, flon, solzen, emzen, azi, wt)
# loglikelihood= -0.5*( np.sum( (spec-model)**2/yerr**2 ) )
# pdb.set_trace()
return model
def toSky(cs):
c1 = cs.T[0]
c2 = cs.T[1]
c3 = cs.T[2]
r = np.sqrt(c1**2. + c2**2. + c3**2.)
dec = np.arcsin(c3 / r) / D2R
ra = np.arccos(c1 / np.sqrt(c1**2. + c2**2.)) / D2R
zmn = z_at_value(Kos.comoving_distance, np.amin(r) * u.Mpc)
zmx = z_at_value(Kos.comoving_distance, np.amax(r) * u.Mpc)
zmn = zmn - (zstp + zmn % zstp)
zmx = zmx + (2 * zstp - zmx % zstp)
ct = np.array([
np.linspace(zmn, zmx, int(np.ceil(zmn / zstp))),
Kos.comoving_distance(np.linspace(zmn, zmx,
int(np.ceil(zmn / zstp)))).value
]).T
r2z = interpolate.pchip(*ct[:, ::-1].T)
z = r2z(r)
return z, ra, dec
def plot(self, full=True, dots=False, average=0, interpolated=0):
results = gym.monitoring.load_results(self.outdir)
data = results[self.data_key]
avg_data = []
if full:
plt.plot(data, color='blue')
if dots:
plt.plot(data, '.', color='black')
if average > 0:
average = int(average)
for i, val in enumerate(data):
if i % average == 0:
if (i + average) < len(data) + average:
avg = sum(data[i:i + average]) / average
avg_data.append(avg)
new_data = expand(avg_data, average)
plt.plot(new_data, color='red', linewidth=2.5)
if interpolated > 0:
avg_data = []
avg_data_points = []
n = len(data) / interpolated
if n == 0:
n = 1
data_fix = 0
for i, val in enumerate(data):
if i % n == 0:
if (i + n) <= len(data) + n:
avg = sum(data[i:i + n]) / n
avg_data.append(avg)
avg_data_points.append(i)
if (i + n) == len(data):
data_fix = n
x = np.arange(len(avg_data))
y = np.array(avg_data)
#print x
#print y
#print str(len(avg_data)*n)
#print data_fix
interp = pchip(avg_data_points, avg_data)
xx = np.linspace(0, len(data) - data_fix, 1000)
plt.plot(xx, interp(xx), color='green', linewidth=3.5)
def geta_zju_pchip(x,
alpha, beta, delta,
kgrid,
ppgrid=None,
is_opt=True):
m = kgrid.shape[0]
if ppgrid is None:
ppgrid = kgrid
pp = spi.pchip(ppgrid, x)
kp = pp(kgrid)
c = np.power(kgrid, alpha) + (1 - delta) * kgrid - kp
kpp = pp(kp)
cp = np.power(kp, alpha) + (1 - delta) * kp - kpp
r = np.power(c, -1) - beta * np.power(cp, -1) * \
(alpha * np.power(kp, alpha - 1) + 1 - delta)
if is_opt:
return r
else:
return pp, kp, kpp, c, cp, r
def toSky(cs, H0, Om_m, zstep):
"""Convert redshift, RA, and Dec to comoving coordinates.
Parameters
----------
cs : ndarray
Comoving xyz-coordinates table [x,y,z], assuming input cosmology.
H0 : float
Hubble's constant in km/s/Mpc.
Om_m : float
Value of matter density.
zstep : float
Redshift step size for converting distance to redshift.
Returns
-------
z : float
Object redshift.
ra : float
Object right ascension, in decimal degrees.
dec : float
Object declination, in decimal degrees.
"""
Kos = FlatLambdaCDM(H0, Om_m)
c1 = cs.T[0]
c2 = cs.T[1]
c3 = cs.T[2]
r = np.sqrt(c1**2. + c2**2. + c3**2.)
dec = np.arcsin(c3 / r) / D2R
ra = (np.arccos(c1 / np.sqrt(c1**2. + c2**2.)) * np.sign(c2) / D2R) % 360
zmn = z_at_value(Kos.comoving_distance, np.amin(r) * u.Mpc)
zmx = z_at_value(Kos.comoving_distance, np.amax(r) * u.Mpc)
zmn = zmn - (zstep + zmn % zstep)
zmx = zmx + (2 * zstep - zmx % zstep)
ct = np.array([
np.linspace(zmn, zmx, int(np.ceil(zmn / zstep))),
Kos.comoving_distance(np.linspace(zmn, zmx,
int(np.ceil(zmn / zstep)))).value
]).T
r2z = interpolate.pchip(*ct[:, ::-1].T)
z = r2z(r)
#z = H0*r/c
return z, ra, dec
def interpolate_zeros(params, method='pchip', min_val=0):
"""
Interpolate 0 values
:param params: 1D data vector
:param method:
:param factor: factor for interpolation (must be integer)
:return: interpolated 1D vector by a given factor
"""
voiced = np.array(params, float)
for i in range(0, len(voiced)):
if voiced[i] == min_val:
voiced[i] = np.nan
# last_voiced = len(params) - np.nanargmax(params[::-1] > 0)
if np.isnan(voiced[-1]):
voiced[-1] = np.nanmin(voiced)
if np.isnan(voiced[0]):
voiced[0] = np.nanmean(voiced)
not_nan = np.logical_not(np.isnan(voiced))
indices = np.arange(len(voiced))
if method == 'spline':
interp = interpolate.UnivariateSpline(indices[not_nan],
voiced[not_nan],
k=2,
s=0)
# return voiced parts intact
smoothed = interp(indices)
for i in range(0, len(smoothed)):
if not np.isnan(voiced[i]):
smoothed[i] = params[i]
return smoothed
elif method == 'pchip':
interp = interpolate.pchip(indices[not_nan], voiced[not_nan])
else:
interp = interpolate.interp1d(indices[not_nan], voiced[not_nan],
method)
return interp(indices)
def __call__(self, x, Cx, C):
"""
params:
----------
x: array
array with new x-distribution
xp: array
array with x-coordinates of spline control points
yp: array
array with y-coordinates of spline control points
returns
---------
ynew: array
resampled points
"""
spl = pchip(Cx, C)
return spl(x)
def __init__(self, waypoints:list) -> None:
"""Initializes path based on specified waypoints."""
self.init_waypoints = waypoints.copy()
for _ in range(3):
self._arclengths = _arc_len(waypoints)
path_coords = interpolate.pchip(x=self._arclengths, y=waypoints, axis=1)
path_derivatives = path_coords.derivative()
path_dderivatives = path_derivatives.derivative()
waypoints = path_coords(np.linspace(self._arclengths[0], self._arclengths[-1], 1000))
self._waypoints = waypoints.copy()
self._path_coords = path_coords
self._path_derivatives = path_derivatives
self._path_dderivatives = path_dderivatives
S = np.linspace(0, self.length, 10*self.length)
self._points = np.transpose(self._path_coords(S))
self._linestring = shapely.geometry.LineString(self._points)
def plot(self, env, full=True, dots=False, average=0, interpolated=0):
if self.data_key is rewards_key:
data = gym.wrappers.Monitor.get_episode_rewards(env)
else:
data = gym.wrappers.Monitor.get_episode_lengths(env)
avg_data = []
plt.clf()
if full:
plt.plot(data, color=self.line_color)
if dots:
plt.plot(data, '.', color='black')
if average > 0:
average = int(average)
for i, val in enumerate(data):
if i % average == 0:
if (i + average) <= len(data):
avg = sum(data[i:i + average]) / average
avg_data.append(avg)
new_data = self.expand(avg_data, average)
plt.plot(new_data, color='red', linewidth=2.5)
if interpolated > 0:
avg_data = []
avg_data_points = []
n = len(data) / interpolated
if n == 0:
n = 1
for i, val in enumerate(data):
if i % n == 0:
if (i + n) <= len(data) + n:
avg = sum(data[i:i + n]) / n
avg_data.append(avg)
avg_data_points.append(i)
interp = pchip(np.array(avg_data_points), np.array(avg_data))
xx = np.linspace(0, len(data) - 1, 1000)
plt.plot(xx, interp(xx), color='green', linewidth=3.5)
# pause so matplotlib will display
# may want to figure out matplotlib animation or use a different library in the future
plt.pause(0.000001)
def get_cluster_interp(depth_values, x_values, bandwidth=10):
# Clustering
depth_values_v = np.vstack(depth_values)
clustering = MeanShift(bandwidth=bandwidth).fit(depth_values_v)
cluster_labels = clustering.labels_
# Average by cluster
depth_clusters = clustering.cluster_centers_.ravel()
x_clusters = np.full_like(depth_clusters, np.nan)
for i in range(len(depth_clusters)):
x_clusters[i] = np.mean(x_values[cluster_labels == i])
# Sort arrays by depth
depth_index = np.argsort(depth_clusters)
x_clusters = x_clusters[depth_index]
depth_clusters = depth_clusters[depth_index]
# Do a PCHIP interpolation
interpolator = interpolate.pchip(depth_clusters, x_clusters)
return depth_clusters, x_clusters, interpolator
def __init__(self, data, Length, D1):
self._coilable = None
self._maxStrain = None
self._stress_values_trimmed = None
self._strain_values_trimmed = None
self._max_location_stress = None
self._max_location_strain = None
self._vector = None
self._curve = None
self._energy_abs = None
self._buckling_load = None
self._coilable = data['coilable'][0]
self._maxStrain = Length/Length
temp_U = data['riks_RP_Zplus_U'][:-2,2]
temp_F = data['riks_RP_Zplus_RF'][:-2,2]
stress_values = 1000*(temp_F/(np.pi*0.25*(D1)**2))
strain_values = temp_U/Length
vec_indices = np.where(stress_values <= 0)
self._stress_values_trimmed = abs(stress_values[vec_indices])
self._strain_values_trimmed = abs(strain_values[vec_indices])
self._max_location_stress = np.argmax(self._stress_values_trimmed)
self._max_location_strain = np.argmax(self._strain_values_trimmed)
#if np.max(strain_values_trimmed[max_location_strain])> np.min([0.8,maxStrain]):
if self._strain_values_trimmed[-1]<1.0:
self._strain_values_trimmed = np.append(self._strain_values_trimmed,1.0)
self._stress_values_trimmed = np.append(self._stress_values_trimmed,0.0)
vector = np.linspace(np.min(self._strain_values_trimmed),np.max(self._maxStrain),10000)
interp = interpolate.pchip(self._strain_values_trimmed,self._stress_values_trimmed)
curve = interp(vector)
self._vector = vector[:-1]
self._curve = curve[:-1]
self._energy_abs = simps(self._curve,x=self._vector)
self._buckling_load = data['P_p3_crit'][0]/(np.pi*0.25*(D1)**2)*1000
def z_pinterp(var, pres, std_z):
""" deals with masked ones
"""
if np.count_nonzero(~var.mask) < 2:
bad = np.empty((len(std_z), ))
bad.fill(np.nan)
return bad
else:
if any(pres[1:] < pres[:-1]):
sidx = np.argsort(pres)
pres, var = pres[sidx], var[sidx]
if np.ma.isMaskedArray(pres):
if len(pres.compressed()) == len(pres):
pres = pres.compressed()
else:
# make sure pres mask and var mask are same
newmask = np.logical_or(pres.mask, var.mask)
pres.mask = newmask
var.mask = newmask
pres = pres.filled()
fp = pchip(pres[~var.mask], var.compressed(), extrapolate=False)
return fp(std_z)
def getcanonicalhrf(duration, tr):
# inputs
if duration == 0:
duration = 0.1
# obtain canonical response to a 0.1-s stimulus
hrf = basichrf()
# convolve to get the predicted response to the desired stimulus duration
trold = 0.1
hrf = np.convolve(hrf, np.ones(int(np.max([1,
np.round(duration / trold)]))))
sampler = np.asarray(np.arange(0, int((hrf.shape[0] - 1) * trold), tr))
# resample to desired TR
hrf = pchip(np.asarray(range(hrf.shape[0])) * trold, hrf)(sampler)
# make the peak equal to one
hrf = hrf / np.max(hrf)
return hrf
def env(dur, f, n, file, pd):
sampFreq, sndd = wavfile.read(file, 'rb')
snd = sndd[:, 0]
# espectrograma
freq, times, sx = signal.spectrogram(snd,
fs=sampFreq,
window='hanning',
nperseg=int(round(sampFreq /
(1 + f))),
detrend=False,
scaling='spectrum')
# calculo envolvente para cada armónico
s = sx[int(n), :]
index, value = max(enumerate(s), key=operator.itemgetter(1))
s = s / s[index]
peaks, dk = find_peaks(s, distance=int(np.round(len(snd) / pd)))
si = np.concatenate(([0], s[peaks], [0]))
t = np.concatenate(([0], times[peaks], [len(snd) / sampFreq]))
pk = pchip(t, si)
if (dur == 0):
return [0]
xnew = np.arange(0, t[len(t) - 1], t[len(t) - 1] / (dur * sampFreq))
pnew = pk(xnew)
pnew = (abs(pnew) + pnew) / 2
return pnew
def execute(self):
self.dict = HAWC2InputDict()
self.dict.read(self.htc_master_file)
self.htc = self.dict.htc
self.vartrees.body_order = self.dict.body_order
for section in self.htc:
if section.name == 'simulation':
self.add_simulation(section)
elif section.name == 'wind':
self.add_wind(section)
elif section.name == 'aero':
self.add_aero(section)
elif section.name == 'aerodrag':
self.add_aerodrag(section)
elif section.name == 'new_htc_structure':
self.add_structure(section)
elif section.name == 'output':
self.add_output(section)
elif section.name == 'dll':
self.add_dlls(section)
elif section.name == 'hawcstab2':
self.add_hawcstab2(section)
# count number of blades
for iblade in range(1, 10):
if 'blade' + str(iblade) not in self.vartrees.body_order:
self.vartrees.rotor.nblades = iblade - 1
break
# copy blade twist from c2_def to blade_ae vartree
if hasattr(self.vartrees.main_bodies, 'blade1'):
from scipy.interpolate import pchip
c12 = self.vartrees.main_bodies.blade1.c12axis
tck = pchip(c12[:, 2], c12[:, 3])
twist = tck(self.vartrees.blade_ae.s)
self.vartrees.blade_ae.twist = twist
self.vartrees.blade_ae.c12axis = c12.copy()
self.vartrees.blade_structure = self.vartrees.main_bodies.blade1.beam_structure
def execute(self):
self.dict = HAWC2InputDict()
self.dict.read(self.htc_master_file)
self.htc = self.dict.htc
self.vartrees.body_order = self.dict.body_order
for section in self.htc:
if section.name == 'simulation':
self.add_simulation(section)
elif section.name == 'wind':
self.add_wind(section)
elif section.name == 'aero':
self.add_aero(section)
elif section.name == 'aerodrag':
self.add_aerodrag(section)
elif section.name == 'new_htc_structure':
self.add_structure(section)
elif section.name == 'output':
self.add_output(section)
elif section.name == 'dll':
self.add_dlls(section)
elif section.name == 'hawcstab2':
self.add_hawcstab2(section)
# count number of blades
for iblade in range(1, 10):
if 'blade'+str(iblade) not in self.vartrees.body_order:
self.vartrees.rotor.nblades = iblade-1
break
# copy blade twist from c2_def to blade_ae vartree
if hasattr(self.vartrees.main_bodies, 'blade1'):
from scipy.interpolate import pchip
c12 = self.vartrees.main_bodies.blade1.c12axis
tck = pchip(c12[:, 2], c12[:, 3])
twist = tck(self.vartrees.blade_ae.s)
self.vartrees.blade_ae.twist = twist
self.vartrees.blade_ae.c12axis = c12.copy()
self.vartrees.blade_structure = self.vartrees.main_bodies.blade1.beam_structure
def fitter(data, **kwargs):
def listify_dicts(dicts):
if len(dicts) == 0:
return {}
ld = {}
for d in dicts:
for k in d.keys():
if k not in ld.keys():
ld[k] = [d[k]]
else:
ld[k].append(d[k])
return ld
if dw.zoo.is_multiindex_dataframe(data):
return listify_dicts([fitter(d, **kwargs) for d in dw.unstack(data)])
elif type(data) is list:
return listify_dicts([fitter(d, **kwargs) for d in data])
transpose = kwargs.pop('transpose', False)
assert 'axis' in kwargs.keys(), ValueError('Must specify axis')
if kwargs['axis'] == 1:
return fitter(data.T, **dw.core.update_dict(kwargs, {'axis': int(not kwargs['axis']), 'transpose': True}))
assert kwargs['axis'] == 0, ValueError('invalid transformation')
if dw.zoo.is_multiindex_dataframe(data):
x = np.array(data.index.levels[-1])
else:
x = data.index.values
resampled_x = np.linspace(np.min(x), np.max(x), num=kwargs['n_samples'])
pchip = pd.Series(index=data.columns)
for c in data.columns:
pchip[c] = interpolate.pchip(x, data[c].values)
return {'x': x, 'resampled_x': resampled_x, 'pchip': pchip, 'transpose': transpose, 'axis': kwargs['axis'],
'n_samples': kwargs['n_samples']}
def get_dNdEE(self, mother, daughter):
"""Differential parent-->neutrino (mother--daughter) yield"""
ihijo = 20
e_grid = self.mceq.e_grid
delta = self.mceq.e_widths
x_range = e_grid[ihijo] / e_grid
rr = ParticleProperties.rr(mother, daughter)
dNdEE_edge = ParticleProperties.br_2body(mother, daughter) / (1 - rr)
dN_mat = self.mceq._decays.get_matrix(
(ParticleProperties.pdg_id[mother], 0),
(ParticleProperties.pdg_id[daughter], 0))
dNdEE = dN_mat[ihijo] * e_grid / delta
logx = np.log10(x_range)
logx_width = -np.diff(logx)[0]
good = (logx + logx_width / 2 < np.log10(1 - rr)) & (x_range >= 5.e-2)
x_low = x_range[x_range < 5e-2]
dNdEE_low = np.array([dNdEE[good][-1]] * x_low.size)
dNdEE_interp = lambda x_: interpolate.pchip(
np.concatenate([[1 - rr], x_range[good], x_low])[::-1],
np.concatenate([[dNdEE_edge], dNdEE[good], dNdEE_low])[::-1],
extrapolate=True)(x_) * np.heaviside(1 - rr - x_, 1)
return x_range, dNdEE, dNdEE_interp
def pchip6h_1h(time_index, windpredict1h):
# got data6h data
data6h = pchip6h(time_index, windpredict1h)
# convert 6hourly to hourly
# prepare data
time_index_6h = data6h.iloc[:, 0]
winddata_6h = data6h.iloc[:, 1]
pchip_obj_6h = pchip(time_index_6h, winddata_6h)
# convert to 6houly time_index
time_index_1h = pd.date_range(time_index_6h.iloc[0],
time_index_6h.iloc[-1],
freq="15min")
# test & predict
windpredict1h = pchip_obj_6h(time_index_1h)
print("MMMiiiiiiiiiiiiiii of windpredict15m:")
print(windpredict1h.min())
# windpredict1h = pchip_obj_after1h(time_index_1h)
time_index_1h = pd.Series(time_index_1h)
windpredict1h = pd.Series(windpredict1h)
framelist = [time_index_1h, windpredict1h]
data1h = pd.concat(framelist, axis=1)
return data1h
def Q5():
f_cubic = interpolate.CubicSpline(years, pops, bc_type='natural')
xs = np.linspace(1900, 1990, 1000)
ys_cubic = f_cubic(xs)
matrix_4 = np.vander((years - 1940) / 40)
coeffs = np.linalg.solve(matrix_4, pops)
ys_poly = np.polyval(coeffs, (xs - 1940) / 40)
f_hermit = interpolate.pchip(years, pops)
ys_hermit = f_hermit(xs)
plt.figure()
plt.plot(xs, ys_hermit, label="Interpolation with PCHIP")
plt.plot(xs, ys_cubic, label="Interpolation with CubicSpline")
print(ys_hermit[-1], ys_cubic[-1])
plt.plot(xs, ys_poly, label="Interpolation with Poly fit")
plt.plot(1990, 248709873, "ro", label="Real data at 1990")
plt.title("Interpolate population up to 1990")
plt.xlabel("Years")
plt.ylabel("Population")
plt.legend()
plt.savefig("Q5.png")
plt.show()
def pchip6h(time_index, windpredict1h):
pchip_obj_after1h = pchip(time_index, windpredict1h)
# convert to 6houly time_index
time_index_2 = pd.date_range(time_index.iloc[0],
time_index.iloc[-1],
freq="360min")
# test & predict, dyp
windpredict6h = pchip_obj_after1h(
time_index_2) #* random.uniform(0.9,1.1) - 2 # if < 0 : set to 0.
# windpredict6h = pchip_obj_after1h(time_index_2) * random.uniform(0.9,1.1) *0.8 # 相关性变差，影响最大最小
# print(windpredict6h.min())
time_index_2 = pd.Series(time_index_2)
windpredict6h = pd.Series(windpredict6h)
framelist = [time_index_2, windpredict6h]
data6h = pd.concat(framelist, axis=1)
#print(data6h.iloc[:,0])
print("average of data6h after mos:")
print("should be the same as above.")
print(data6h.mean())
# data6h = data6h[data6h.windpredict6h > 0]
return data6h
def test_roots(self):
# regression test for gh-6357: .roots method should work
p = pchip([0, 1], [-1, 1])
r = p.roots()
assert_allclose(r, 0.5)
def _make_random(self, npts=20):
np.random.seed(1234)
xi = np.sort(np.random.random(npts))
yi = np.random.random(npts)
return pchip(xi, yi), xi, yi
def pchip_antideriv2(x, y, axis=0):
return pchip(x, y, axis).derivative(2)
def pchip_deriv(x, y, axis=0):
return pchip(x, y, axis).derivative()
def get_interpolated(x, y):
# dense x and interpolator for the smooth curve for plotting
xx = np.linspace(x[0], x[-1], len(x) * 10)
interp = pchip(x, y)
return xx, interp(xx)
def bdrate(file1, file2, anchorfile):
if anchorfile:
anchor = flipud(loadtxt(anchorfile))
a = loadtxt(file1)
b = loadtxt(file2)
a = a[a[:, 0].argsort()]
b = b[b[:, 0].argsort()]
a = flipud(a)
b = flipud(b)
rates = [0.06, 0.2]
qa = a[:, 0]
qb = b[:, 0]
ra = a[:, 2] * 8. / a[:, 1]
rb = b[:, 2] * 8. / b[:, 1]
bdr = zeros((4, 4))
ret = {}
for m in range(0, len(met_index)):
try:
ya = a[:, 3 + m]
yb = b[:, 3 + m]
if anchorfile:
yr = anchor[:, 3 + m]
#p0 = interp1d(ra, ya, interp_type)(rates[0]);
#p1 = interp1d(ra, ya, interp_type)(rates[1]);
if anchorfile:
p0 = yr[0]
p1 = yr[-1]
yya = ya
yyb = yb
rra = ra
rrb = rb
else:
minq = 20
maxq = 55
try:
# path if quantizers 20 and 55 are in set
minqa_index = qa.tolist().index(minq)
maxqa_index = qa.tolist().index(maxq)
minqb_index = qb.tolist().index(minq)
maxqb_index = qb.tolist().index(maxq)
yya = ya[maxqa_index:minqa_index + 1]
yyb = yb[maxqb_index:minqb_index + 1]
rra = ra[maxqa_index:minqa_index + 1]
rrb = rb[maxqb_index:minqb_index + 1]
except ValueError:
# path if quantizers 20 and 55 are not found - use
# entire range of quantizers found, and fit curve
# on all the points, and set q_not_found to print
# a warning
q_not_found = True
minqa_index = -1
maxqa_index = 0
minqb_index = -1
maxqb_index = 0
yya = ya
yyb = yb
rra = ra
rrb = rb
p0 = max(ya[maxqa_index], yb[maxqb_index])
p1 = min(ya[minqa_index], yb[minqb_index])
a_rate = pchip(yya, log(rra))(arange(p0, p1,
abs(p1 - p0) / 5000.0))
b_rate = pchip(yyb, log(rrb))(arange(p0, p1,
abs(p1 - p0) / 5000.0))
if not len(a_rate) or not len(b_rate):
bdr = NaN
else:
bdr = 100 * (exp(mean(b_rate - a_rate)) - 1)
except ValueError:
bdr = NaN
except linalg.linalg.LinAlgError:
bdr = NaN
except IndexError:
bdr = NaN
if abs(bdr) > 1000:
bdr = NaN
ret[m] = bdr
return ret
def pchip_antideriv(x, y, axis=0):
return pchip(x, y, axis).derivative()
def interpolate_bladestructure(st3d, s_new):
"""
interpolate a blade structure definition onto
a new spanwise distribution using pchip
parameters
----------
st3d: dict
dictionary with blade structural definition
s_new: array
1-d array with new spanwise distribution
returns
-------
st3dn: dict
blade structural definition interpolated onto s_new distribution
"""
st3dn = {}
sorg = st3d['s']
st3dn['s'] = s_new
st3dn['version'] = st3d['version']
st3dn['materials'] = st3d['materials']
st3dn['matprops'] = st3d['matprops']
st3dn['failmat'] = st3d['failmat']
st3dn['failcrit'] = st3d['failcrit']
st3dn['web_def'] = st3d['web_def']
st3dn['regions'] = []
st3dn['webs'] = []
DPs = np.zeros((s_new.shape[0], st3d['DPs'].shape[1]))
for i in range(st3d['DPs'].shape[1]):
tck = pchip(sorg, st3d['DPs'][:, i])
DPs[:, i] = tck(s_new)
st3dn['DPs'] = DPs
for r in st3d['regions']:
rnew = {}
rnew['layers'] = r['layers']
Ts = r['thicknesses']
As = r['angles']
tnew = np.zeros((s_new.shape[0], Ts.shape[1]))
anew = np.zeros((s_new.shape[0], As.shape[1]))
for i in range(Ts.shape[1]):
tck = pchip(sorg, Ts[:, i])
tnew[:, i] = tck(s_new)
tck = pchip(sorg, As[:, i])
anew[:, i] = tck(s_new)
rnew['thicknesses'] = tnew.copy()
rnew['angles'] = anew.copy()
st3dn['regions'].append(rnew)
for r in st3d['webs']:
rnew = {}
rnew['layers'] = r['layers']
Ts = r['thicknesses']
As = r['angles']
tnew = np.zeros((s_new.shape[0], Ts.shape[1]))
anew = np.zeros((s_new.shape[0], As.shape[1]))
for i in range(Ts.shape[1]):
tck = pchip(sorg, Ts[:, i])
tnew[:, i] = tck(s_new)
tck = pchip(sorg, As[:, i])
anew[:, i] = tck(s_new)
rnew['thicknesses'] = tnew.copy()
rnew['angles'] = anew.copy()
st3dn['webs'].append(rnew)
return st3dn
Lvals=[]
for row in table[:]:
colours.append(abL_2_sRGB(a_val=row['LAB_A'],b_val=row['LAB_B'],L_val=row['LAB_L']))
tvals.append(row[tvals_in]/100)
avals.append(row['LAB_A'])
bvals.append(row['LAB_B'])
Lvals.append(row['LAB_L'])
h5file.close()
# Create Interpolation functions for a,b,L
a_pchip=interpolate.pchip(tvals,avals)
b_pchip=interpolate.pchip(tvals,bvals)
L_pchip=interpolate.pchip(tvals,Lvals)
pch_Inter=[a_pchip,b_pchip,L_pchip]
# Start plotting
# Disable depth shading
plt.ion()
art3d.zalpha = lambda *args:args[0]
# Setup canvas
nc.close()
phi = phi*np.pi/180 # angle between major axis and east [rad] (beware sign)
# ------ extract density profile, compute N2 ------------------
if clim == "lucky":
nc = Dataset(cname,'r')
T = nc.variables['temp_roms_avg'][:]
S = nc.variables['salt_roms_avg'][:]
zz = nc.variables['depth'][:]
nz = zz.size
rho = np.sort(rhop(T,S)) #SW_Density(T,S) # sorting is cheating here
rho0 = rho.mean()
frho = itp.pchip(zz[::-1],rho[::-1],extrapolate=True)
N2_tmp = -(g/rho0)*(2*np.pi)**2*frho.derivative()(zz) # # has to be in [(rad s-1)^2]
# temporary fixing:
if N2_tmp[-1]==0: N2_tmp[-1] = 1e-8
indneg, = np.where(N2_tmp<=0.)
for ii in indneg:
N2_tmp[ii] = (N2_tmp[ii-1] + N2_tmp[ii+1])/2
fN2 = itp.pchip(zz[::-1],N2_tmp[::-1],extrapolate=True)
# fit exponential profile
slope,intercept,r_val,p_val,std_err = stats.linregress(zz,np.log(N2_tmp**0.5))
N0 = np.exp(intercept)/(2*np.pi)
b = 1./slope
N2b = fN2(hgrid)
#!/usr/bin/env python3
from numpy import *
from scipy import *
from scipy.interpolate import interp1d
from scipy.interpolate import pchip
import sys
import os
import argparse
import json
a = flipud(loadtxt(sys.argv[1]));
b = flipud(loadtxt(sys.argv[2]));
for m in range(0,11):
try:
ya = a[:,3+m]
yb = b[:,3+m]
ra = a[:,2]*8./a[:,1]
rb = b[:,2]*8./b[:,1]
a_rate = pchip(ya, log(ra))(float(sys.argv[3]))
b_rate = pchip(yb, log(rb))(float(sys.argv[3]))
print(exp(b_rate - a_rate) - 1)
except IndexError:
print('NaN')
except ValueError:
print('NaN')
def calc_LR(xdf, xcat, optdf,catopt,nm, qm, Q, rmag, NX,rsearch=5.0,\
lth = None, LRfrac=0.2,lrmax=None,\
magname = 'imag_psf',xerrname='xposerr',
xra = 'RA', xdec = 'DEC', ora = 'ra', odec = 'dec',
opticalid = 'hscid',opterr = 0.1,pdf='Rayleigh',first=False):
'''
input variables:
xdf, xcat, optdf,catopt,optdf,nm, qm, Q, rmag, rsearch=5.0,\
magname = 'rmag_psf',xerrname='xposerr',
xra = 'RA', xdec = 'DEC', ora = 'ra', odec = 'dec',
opticalid = 'hscid'
For computing LR for every optical source within rsearch:
'''
if first:
print('first calc_LR')
idxmm, idhsc, d2d, d3d = catopt.search_around_sky(xcat, rsearch * u.arcsec)
match = pd.DataFrame({'xid':idxmm,'optid':idhsc,'dist':d2d.arcsec,\
'rmag':optdf.loc[idhsc,magname].values,'xposerr':xdf.loc[idxmm,xerrname],\
'raopt':optdf.loc[idhsc,ora].values,'decopt':optdf.loc[idhsc,odec].values,\
'rax':xdf.loc[idxmm,xra].values,'decx':xdf.loc[idxmm,xdec].values,\
'optname':optdf.loc[idhsc,opticalid].values})
#print('match len = ',len(match), 'xid nunique = ', match.xid.nunique())
fr = pdf_sep_gen(match.dist.values, match.xposerr.values, opterr, pdf=pdf)
n_m = pchip(rmag, nm) #, bounds_error=False,fill_value='extrapolate')
q_m = pchip(rmag, qm) #, bounds_error=False,fill_value='extrapolate')
fnm = n_m(match.rmag.values)
fqm = q_m(match.rmag.values)
fqm[np.where(fqm < 0.)] = 1e-8
fnm[np.where(fnm < 0.)] = 1e-8
LR = fr * fqm / fnm
match['LR'] = pd.Series(LR, index=match.index)
match['matchid'] = pd.Series(range(len(match)), index=match.index)
match['raoff'] = pd.Series((match.rax - match.raopt) * 3600.,
index=match.index)
match['decoff'] = pd.Series((match.decx - match.decopt) * 3600.,
index=match.index)
#several situations :
#1. all matches are unique, no further action is required.
if match.xid.nunique() - len(match) == 0:
return match, match, 1.0, 1.0, match.LR.min()
else:
if lth is None:
#If the array of lth values is not provided,
#guess it by assuming that only NX sources would be reliable,
#so loop through the LR values around that LR quantile
#qcenter = match.LR.quantile(float(NX)/len(match))
qcenter = 1. - 1.5 * float(NX) / len(match)
if qcenter < 0.:
qcenter = 0.1
lth = np.linspace(0.5 * qcenter, min([2.0 * qcenter, 0.95]), 30.)
#print(lth)
if lrmax is None:
#first
R, C, LRth = calc_RC(match, lth, Q, NX, LRfrac=LRfrac, first=first)
lthmax = LRth[np.argmax((R + C))]
if not np.isscalar(lthmax):
if len(lthmax) >= 1:
lthmax = lthmax[0]
goodmatch, R, C, LRth = calc_RCMAX(match,
lthmax,
Q,
len(xcat),
LRfrac=LRfrac)
return match, goodmatch, R, C, lthmax, LRth
else:
goodmatch, R, C, LRth = calc_RCMAX(match,
lrmax,
Q,
len(xcat),
LRfrac=LRfrac)
return match, goodmatch, R, C, lrmax, LRth
def display (all_latencies, directory): # all_latencies : solver -> #tm(0-23) -> path_len -> frac_traffic
scheme_latency_dist = OrderedDict() # solver -> path_length -> (frac_tput_mean, frac_tput_std)
for solver in all_latencies.keys():
lat_percentile = get_latency_percentile(all_latencies, solver)
scheme_latency_dist[solver] = lat_percentile
CommonConf.setupMPPDefaults()
fmts = CommonConf.getLineFormatsDict()
mrkrs = CommonConf.getLineMarkersDict()
mrkrsize = CommonConf.getLineMarkersSizeDict()
mrkrlw = CommonConf.getLineMarkersLWDict()
colors = CommonConf.getLineColorsDict()
fig = pp.figure(figsize=(6,5))
ax = fig.add_subplot(111)
max_lat = 0
for solver, latencies in scheme_latency_dist.iteritems():
max_lat = max(max_lat, max(latencies.keys()))
gap=1
for solver, latencies in scheme_latency_dist.iteritems():
xs = []
xsall = sorted(latencies.keys())
for i in range(0,len(xsall)):
if (i%gap==0):
xs.append(xsall[i])
if (len(xsall)-1)%gap!=0:
xs.append(xsall[-1])
ys = [latencies[lat][0] for lat in xs]
ydevs = [latencies[lat][1] for lat in xs]
ax.plot((xs[-1], max_lat), (ys[-1], ys[-1]), linestyle=':',
marker=mrkrs[solver],
color=colors[solver],
markersize=mrkrsize[solver],
markerfacecolor='none',
markeredgecolor=colors[solver],
markeredgewidth=mrkrsize[solver]/4,
linewidth=mrkrlw[solver])
new_xs = np.linspace(min(xs), max(xs), (max(xs)-min(xs))*3+1)
print new_xs
yinterp = pchip(xs, ys)
ydevsinterp = pchip(xs, ydevs)
new_ys = yinterp(new_xs)
new_ydevs = ydevsinterp(new_xs)
ax.errorbar(new_xs, new_ys, yerr=new_ydevs,
label=CommonConf.gen_label(solver), marker=mrkrs[solver],
linestyle=fmts[solver],
color=colors[solver],
markersize=mrkrsize[solver],
markerfacecolor='none',
markeredgecolor=colors[solver],
markeredgewidth=mrkrsize[solver]/4,
markevery=len(new_xs)/4,
errorevery=len(new_xs)/4,
linewidth=mrkrlw[solver])
ax.set_xlabel(X_LABEL)
ax.set_ylabel(Y_LABEL)
ax.spines['right'].set_visible(False)
ax.spines['top'].set_visible(False)
ax.yaxis.set_ticks_position('left')
ax.xaxis.set_ticks_position('bottom')
ax.legend(loc='best', borderaxespad=1., fancybox=True)
pp.subplots_adjust(left=0.1, right=0.8, top=0.9, bottom=0.1)
pp.ylim(0.0,1.05)
xmin,xmax = ax.get_xlim()
xmax = (xmax + (xmax%2))
pp.xlim(3, xmax)
pp.tight_layout()
pp.savefig(directory+"/LatencyCDF.svg")
def _make_random(self, npts=20):
np.random.seed(1234)
xi = np.sort(np.random.random(npts))
yi = np.random.random(npts)
return pchip(xi, yi), xi, yi
def pchip_deriv2(x, y, axis=0):
return pchip(x, y, axis).derivative(2)
for i in range(len(series)):
[
time_used_glpk, timeslot_used_glpk, time_used_graph,
timeslot_used_graph
] = get_info(i, len(count), first_char)
fig, axs = plt.subplots(2, 1)
axs[0].set_title(
str(series[i][0]) + ' teachers, ' + str(series[i][1]) + ' rooms')
axs[0].set_xlabel('Courses')
axs[0].set_ylabel('Time (second)')
time_used_glpk = np.array(time_used_glpk)
time_used_graph = np.array(time_used_graph)
smooth_count = np.linspace(arr_count.min(), arr_count.max(), 240)
pch = pchip(arr_count, time_used_glpk)
smooth_time_used_glpk = pch(smooth_count)
pch = pchip(arr_count, time_used_graph)
smooth_time_used_graph = pch(smooth_count)
axs[0].plot(smooth_count,
smooth_time_used_glpk,
marker='.',
markevery=10)
axs[0].plot(smooth_count,
smooth_time_used_graph,
marker='.',
markevery=10)
axs[1].axis('tight')
axs[1].axis('off')
columns = tuple(count)
# List of Earth masses converted to M_Jup x_new = toJupMass(MEarth) # np.linspace(min,max,n) creates a list of n values between min and max jupX = np.linspace(min(MJup),max(MJup),500) earthX = np.linspace(min(x_new),max(x_new),500) # convert radius and masses to a density IceD = toDensity(MEarth, IceR) RockD = toDensity(MEarth, RockR) IronD = toDensity(MEarth, IronR) lineColor = 'LightGray' # Interpolate a line between the data points interp = pchip(np.array(x_new),np.array(IceD)) ax.loglog(earthX, interp(earthX), c=lineColor, lw=4.0) interp = pchip(np.array(x_new),np.array(RockD)) ax.loglog(earthX, interp(earthX), c=lineColor, lw=4.0) interp = pchip(np.array(x_new),np.array(IronD)) ax.loglog(earthX, interp(earthX), c=lineColor, lw=4.0) # Convert Jupiter radii and masses to density H_HE_D = [] for idx in range(0,len(MJup)): g_mass = MJup[idx] * 1.898e30 cm_rad = H_HE[idx] * 6.9911e9 density = g_mass/( (4.0/3.0) * constants.pi * (cm_rad**3)) H_HE_D.append(density) interp = pchip(np.array(MJup),np.array(H_HE_D))
def interpolate_bladestructure(st3d, s_new):
"""
interpolate a blade structure definition onto
a new spanwise distribution using pchip
parameters
----------
st3d: dict
dictionary with blade structural definition
s_new: array
1-d array with new spanwise distribution
returns
-------
st3dn: dict
blade structural definition interpolated onto s_new distribution
"""
st3dn = {}
sorg = st3d['s']
st3dn['s'] = s_new.copy()
st3dn['version'] = st3d['version']
st3dn['materials'] = st3d['materials']
st3dn['matprops'] = st3d['matprops']
st3dn['failmat'] = st3d['failmat']
st3dn['failcrit'] = st3d['failcrit']
st3dn['web_def'] = st3d['web_def']
st3dn['dominant_regions'] = st3d['dominant_regions']
st3dn['cap_DPs'] = st3d['cap_DPs']
st3dn['le_DPs'] = st3d['le_DPs']
st3dn['te_DPs'] = st3d['le_DPs']
try:
st3dn['struct_angle'] = st3d['struct_angle']
st3dn['cap_DPs'] = st3d['cap_DPs']
st3dn['te_DPs'] = st3d['te_DPs']
st3dn['le_DPs'] = st3d['le_DPs']
names = ['cap_center_ps',
'cap_center_ss',
'cap_width_ps',
'cap_width_ss',
'te_width',
'le_width']
names.extend(['w%02dpos' % i for i in range(1, len(st3d['web_def']))])
for name in names:
tck = pchip(sorg, st3d[name])
st3dn[name] = tck(s_new)
except:
print 'no geo3d data'
st3dn['regions'] = []
st3dn['webs'] = []
if 'bonds' in st3d:
st3dn['bonds'] = []
st3dn['bond_def'] = st3d['bond_def']
DPs = np.zeros((s_new.shape[0], st3d['DPs'].shape[1]))
for i in range(st3d['DPs'].shape[1]):
tck = pchip(sorg, st3d['DPs'][:, i])
DPs[:, i] = tck(s_new)
st3dn['DPs'] = DPs
for r in st3d['regions']:
rnew = {}
rnew['layers'] = r['layers']
Ts = r['thicknesses']
As = r['angles']
tnew = np.zeros((s_new.shape[0], Ts.shape[1]))
anew = np.zeros((s_new.shape[0], As.shape[1]))
for i in range(Ts.shape[1]):
tck = pchip(sorg, Ts[:, i])
tnew[:, i] = tck(s_new)
tck = pchip(sorg, As[:, i])
anew[:, i] = tck(s_new)
rnew['thicknesses'] = tnew.copy()
rnew['angles'] = anew.copy()
st3dn['regions'].append(rnew)
for r in st3d['webs']:
rnew = {}
rnew['layers'] = r['layers']
Ts = r['thicknesses']
As = r['angles']
tnew = np.zeros((s_new.shape[0], Ts.shape[1]))
anew = np.zeros((s_new.shape[0], As.shape[1]))
for i in range(Ts.shape[1]):
tck = pchip(sorg, Ts[:, i])
tnew[:, i] = tck(s_new)
tck = pchip(sorg, As[:, i])
anew[:, i] = tck(s_new)
rnew['thicknesses'] = tnew.copy()
rnew['angles'] = anew.copy()
st3dn['webs'].append(rnew)
if 'bonds' in st3d:
for r in st3d['bonds']:
rnew = {}
rnew['layers'] = r['layers']
Ts = r['thicknesses']
As = r['angles']
tnew = np.zeros((s_new.shape[0], Ts.shape[1]))
anew = np.zeros((s_new.shape[0], As.shape[1]))
for i in range(Ts.shape[1]):
tck = pchip(sorg, Ts[:, i])
tnew[:, i] = tck(s_new)
tck = pchip(sorg, As[:, i])
anew[:, i] = tck(s_new)
rnew['thicknesses'] = tnew.copy()
rnew['angles'] = anew.copy()
st3dn['bonds'].append(rnew)
return st3dn
module_name = moduleid_to_string(module)
fname = f'direction_tau_concepts_' \
f'{module_name.lower()}_{measure.strip().lower()}_' \
f'{gap}_{samples}.png'
fname = os.path.join(out_folder, fname)
# IoU
x_a = tau_series.copy()
y_a = results[module][measure]
x_a, y_a = clean_arrays(x_a, y_a)
plt.plot(x_a, y_a, 'o', label='F1', color='tab:blue')
# Smoothen IoU
if len(x_a) > 2:
x_smooth_a = np.linspace(gap, max(x_a), 100)
f_a = pchip(x_a, y_a)
plt.plot(x_smooth_a, f_a(x_smooth_a), '--', color='tab:blue')
# Half ratio
if measure == 'propagation':
plt.axhline(y=ratio_lowest, color='gray', linestyle='dashed')
# Legend
plt.legend(loc='best')
# log scale
if measure == 'total':
plt.yscale('log')
# axis info
xlab, ylab = lab
def interpolarize(ynL):
#converts an array of the type [x,y(x)] into a continuous interpolated function f(x) between the points xmin and xmax of the array
print 'the min value of x is ' + repr(ynL[0][0])
print 'the max value of x is ' + repr(ynL[-1][0])
return pchip(ynL[:,0],ynL[:,1])
