def get_input_current_smooth_soc_as_x(self, charging_c_rates, mesh_points):
"""
Helper function to generate a waveform with smoothly varying charging current. Should return a vector
of current values and vector of corresponding state of charge (soc) values.
Args:
charging_c_rates (list): c-rates for each of the charging steps. Each step is assumed to be an equal
SOC portion of the charge, and the length of the list just needs to be at least 1
mesh_points (list): soc values for beginning and end of each of the charging windows
returns
np.array: array with the current as a function of soc
np.array: array with the corresponding soc values
"""
mesh_points_mid = np.copy(mesh_points)
for indx in range(len(mesh_points) - 1):
mesh_points_mid[indx] = (mesh_points[indx] +
mesh_points[indx + 1]) / 2
soc_vector = np.linspace(self.soc_i, self.soc_f, self.soc_points)
mesh_points_mid = list([self.soc_i]) + list(mesh_points_mid) + list(
[self.soc_f * 1.01])
mesh_points_mid = np.array(mesh_points_mid)
charging_c_rate_start = charging_c_rates[0]
rates = np.clip([charging_c_rate_start] + charging_c_rates +
[charging_c_rates[-1]], self.min_c_rate,
self.max_c_rate)
interpolator = interpolate.PchipInterpolator(mesh_points_mid,
rates,
axis=0,
extrapolate=0)
charging_c_rate_soc1_end = interpolator.__call__(mesh_points[1])
charging_c_rate_start = np.max([
charging_c_rates[0] -
(charging_c_rate_soc1_end - charging_c_rates[0]),
charging_c_rates[0]
])
charging_c_rate_start = np.min(
[self.max_c_rate, charging_c_rate_start])
rates = np.clip([charging_c_rate_start] + charging_c_rates +
[charging_c_rates[-1]], self.min_c_rate,
self.max_c_rate)
interpolator = interpolate.PchipInterpolator(mesh_points_mid,
rates,
axis=0,
extrapolate=0)
input_current = interpolator.__call__(soc_vector)
input_current = np.nan_to_num(input_current, copy=False, nan=0)
input_curent_smooth_soc_as_x = input_current
return input_curent_smooth_soc_as_x, soc_vector
def load(self, fpath, **kwargs):
'''
Loads and interpolates missing data
source - data source. Currently only 'etdata' is supported
interp - whether to interpolate data
'''
if not (kwargs.has_key('source')):
print 'ERROR LOADING'
return ()
if kwargs['source'] == 'etdata':
self.data = np.load(fpath)
self.maskInterp = np.zeros(len(self.data), dtype=np.bool)
if kwargs.has_key('interp') & kwargs['interp'] == True:
r = np.arange(len(self.data))
mask = np.isnan(self.data['x']) | np.isnan(self.data['y'])
fx = interp.PchipInterpolator(r[~mask],
self.data[~mask]['x'],
extrapolate=True)
fy = interp.PchipInterpolator(r[~mask],
self.data[~mask]['y'],
extrapolate=True)
self.data['x'][mask] = fx(r[mask])
self.data['y'][mask] = fy(r[mask])
self.maskInterp = mask
def bdbr(ref, test, yuv_sel):
ref = np.asarray(ref)
test = np.asarray(test)
ref = ref[ref[:, 0].argsort()]
test = test[test[:, 0].argsort()]
xa, ya = np.log10(ref[:, 0]), ref[:, yuv_sel]
xb, yb = np.log10(test[:, 0]), test[:, yuv_sel]
max_i = len(ya)
i = 1
while (i < max_i):
if ya[i] < ya[i - 1] or yb[i] < yb[i - 1]:
ya = np.delete(ya, i)
yb = np.delete(yb, i)
xa = np.delete(xa, i)
xb = np.delete(xb, i)
max_i = len(ya)
else:
i += 1
x_interp = [max(min(xa), min(xb)), min(max(xa), max(xb))]
y_interp = [max(min(ya), min(yb)), min(max(ya), max(yb))]
interp_br_a = interpolate.PchipInterpolator(ya, xa)
interp_br_b = interpolate.PchipInterpolator(yb, xb)
bdbr_a = integrate.quad(interp_br_a, y_interp[0], y_interp[1])[0]
bdbr_b = integrate.quad(interp_br_b, y_interp[0], y_interp[1])[0]
bdbr = (bdbr_b - bdbr_a) / (y_interp[1] - y_interp[0])
bdbr = (math.pow(10., bdbr) - 1) * 100
return bdbr
def get_cdf(x, smoothiter=3, window=None, order=1, **kwargs):
"""
Take a set of points x and find the CDF.
Use get_cdf_raw, fit and return an interpolating function.
By default we use scipy.interpolate.Akima1DInterpolator
kwargs are passed to the interpolating function.
(We do not fit a perfectly interpolating spline right now, because if two points have identical x's,
you get infinity for the derivative.)
Note: scipy v1 has a bug in all splines right now that rejects any distribution of points with exactly equal x's.
You can obtain the PDF by taking the first derivative.
"""
xcdf, ycdf = get_cdf_raw(x)
# Smooth the CDF
if window is None:
window = int(len(xcdf)/100.)
else:
window = int(window)
if window % 2 == 0: window += 1
F = interpolate.PchipInterpolator(xcdf,ycdf,extrapolate=False)#**kwargs)
for i in range(smoothiter):
ycdf = signal.savgol_filter(F(xcdf), window, order)
F = interpolate.PchipInterpolator(xcdf,ycdf,extrapolate=False)#**kwargs)
#if "ext" not in kwargs:
# kwargs["ext"] = 3 #return the boundary value rather than extrapolating
#F = interpolate.UnivariateSpline(xcdf, ycdf, **kwargs)
#F = interpolate.Akima1DInterpolator(xcdf,ycdf,**kwargs)
return F
def get_equidistant_curve(z2, add=0, rate=0.5, high_dens=True):
def func2(x, rate):
a = 3.0 / (2 + rate)
b = a * rate
return np.where(
x < 1 / 6, a * x,
np.where(
x < 2 / 6,
b * (x - 1 / 6) + a / 6,
np.where(
x < 4 / 6,
a * (x - 2 / 6) + (a + b) / 6,
np.where(x < 5 / 6,
b * (x - 4 / 6) + (3 * a + b) / 6,
a * (x - 5 / 6) + (3 * a + 2 * b) / 6))))
t, total_len = get_length_rate(z2, output_total_length=True)
fx = interpolate.PchipInterpolator(np.hstack((t, np.array([1.0]))),
np.real(np.hstack((z2, z2[0]))))
fy = interpolate.PchipInterpolator(np.hstack((t, np.array([1.0]))),
np.imag(np.hstack((z2, z2[0]))))
if high_dens:
equidistant_t = func2(
np.linspace(0, 1, z2.shape[0] + add + 1)[:z2.shape[0] + add], rate)
else:
equidistant_t = np.linspace(0, 1,
z2.shape[0] + add + 1)[:z2.shape[0] + add]
return fx(equidistant_t) + 1j * fy(equidistant_t)
def bdbr(HEVC, VVC, yuv_sel):
HEVC = np.asarray(HEVC)
VVC = np.asarray(VVC)
HEVC = HEVC[HEVC[:, 0].argsort()]
VVC = VVC[VVC[:, 0].argsort()]
xa, ya = np.log10(HEVC[:, 0]), HEVC[:, yuv_sel]
xb, yb = np.log10(VVC[:, 0]), VVC[:, yuv_sel]
max_i = len(ya)
i = 1
while (i < max_i):
if ya[i] < ya[i - 1] or yb[i] < yb[i - 1]:
ya = np.delete(ya, i)
yb = np.delete(yb, i)
xa = np.delete(xa, i)
xb = np.delete(xb, i)
max_i = len(ya)
else:
i += 1
x_interp = [max(min(xa), min(xb)), min(max(xa), max(xb))]
y_interp = [max(min(ya), min(yb)), min(max(ya), max(yb))]
interp_br_a = interpolate.PchipInterpolator(ya, xa)
interp_br_b = interpolate.PchipInterpolator(yb, xb)
bdbr_a = integrate.quad(interp_br_a, y_interp[0], y_interp[1])[0]
bdbr_b = integrate.quad(interp_br_b, y_interp[0], y_interp[1])[0]
bdbr = (bdbr_b - bdbr_a) / (y_interp[1] - y_interp[0])
bdbr = (math.pow(10., bdbr) - 1) * 100
return bdbr
def map2fd(self, newGeometry=True):
if newGeometry == True:
for i in range(self.Nlayers - 1):
spl = interpolate.PchipInterpolator([p.y for p in self.H[i]],
[p.z for p in self.H[i]])
self.Hfd[i + 1, :] = spl(self.Hfd[0])
for i in range(self.nex):
for j in range(self.ney):
l = 0
z = self.Hfd[1, j]
for k in range(self.nez):
while (k + 0.5) * self.h > z and l < self.Nlayers - 1:
l += 1
z += self.Hfd[l + 1, j]
self.layerID[k, j, i] = l
# mantle serpentinization
spl = interpolate.PchipInterpolator([p.y for p in self.H[-1]],
self.serpw)
serpFDtop = spl(self.Hfd[0])
z0 = -self.Hfd[1:self.Nlayers, :].sum(axis=0)
for i in range(self.nex):
for j in range(self.ney):
self.serpwFD[:,j,i] = serpFDtop[j] * \
np.exp(-abs(self.Zh - z0[j])/self.serpDepth)
def parallel_IG(p,T,W,frog,SpecFund,keep_fundspec=False,max_population=12,NStep=25,parallel=True,
Type='SHG-FROG'):
"""uses the idea from Opt. Express 27, 2112-2124 (2019)
starts from a number of initial guesses (IG) and returns the best one
uses the multi-grid approach
p is a Pool object"""
TBP=TBP_frog(T,W,frog)
if TBP*4 < max_population:
population=int(TBP*4)
else:
population=max_population
#first step with Nbin/4 multigrid
(T1,W1,frog1)=multigrig_resize(T,W,frog,4) #resize the FROG
F1=interpolate.PchipInterpolator(W/2,SpecFund)
Sf1=F1(W1/2)
if parallel:
Out1=np.array(p.starmap(PCGPA_reconstruct_IG,
[[T1,W1,frog1,NStep,Sf1,keep_fundspec,Type,[]] for i in range(population)]))
else:
Out1=np.array(list(map(PCGPA_reconstruct_IG,
[T1]*population,[W1]*population,[frog1]*population,
[NStep]*population,[Sf1]*population,
[keep_fundspec]*population,[Type]*population,[[]]*population)))
ind=Out1[:,0].argsort()
Out1=Out1[ind]
#second step with Nbin/2 multigrid
In2=Out1[:int(len(Out1)/2)] #take best results from the first step
for i in range(len(In2)):
(In2[i][1],In2[i][2])=shift2zerodelay(In2[i][1],In2[i][2])
(T2,W2,frog2)=multigrig_resize(T,W,frog,2) #resize the FROG
F2=interpolate.PchipInterpolator(W/2,SpecFund)
Sf2=F2(W2/2)
F_pulse=[interpolate.PchipInterpolator(T1,In2[i][1]) for i in range(len(In2))]
Pulse=np.array([f(T2) for f in F_pulse])
ind0=np.logical_or(T2<T1[0],T2>T1[-1])
Pulse[:,ind0]=0
if parallel:
Out2=np.array(p.starmap(PCGPA_reconstruct_IG,
[[T2,W2,frog2,NStep,Sf2,keep_fundspec,Type,Pulse[i]]
for i in range(len(Pulse))]))
else:
Out2=np.array(list(map(PCGPA_reconstruct_IG,
[T2]*len(Pulse),[W2]*len(Pulse),[frog2]*len(Pulse),[NStep]*len(Pulse),
[Sf2]*len(Pulse),[keep_fundspec]*len(Pulse),[Type]*len(Pulse),
Pulse)))
ind=Out2[:,0].argsort()
Out2=Out2[ind]
#fit to the full original time window
pulse_out=Out2[0][1]
Fp=interpolate.PchipInterpolator(T2,pulse_out)
pulse=Fp(T)
ind0=np.logical_or(T<T2[0],T>T2[-1])
pulse[ind0]=0
return pulse
def get_repaneled_airfoil(self, n_points_per_side=100):
# Returns a repaneled version of the airfoil with cosine-spaced coordinates on the upper and lower surfaces.
# Inputs:
# # n_points_per_side is the number of points PER SIDE (upper and lower) of the airfoil. 100 is a good number.
# Notes: The number of points defining the final airfoil will be n_points_per_side*2-1,
# since one point (the leading edge point) is shared by both the upper and lower surfaces.
upper_original_coors = self.upper_coordinates(
) # Note: includes leading edge point, be careful about duplicates
lower_original_coors = self.lower_coordinates(
) # Note: includes leading edge point, be careful about duplicates
# Find distances between coordinates, assuming linear interpolation
upper_distances_between_points = np.sqrt(
np.power(
upper_original_coors[:-1, 0] -
upper_original_coors[1:, 0], 2) +
np.power(
upper_original_coors[:-1, 1] - upper_original_coors[1:, 1], 2))
lower_distances_between_points = np.sqrt(
np.power(
lower_original_coors[:-1, 0] -
lower_original_coors[1:, 0], 2) +
np.power(
lower_original_coors[:-1, 1] - lower_original_coors[1:, 1], 2))
upper_distances_from_TE = np.hstack(
(0, np.cumsum(upper_distances_between_points)))
lower_distances_from_LE = np.hstack(
(0, np.cumsum(lower_distances_between_points)))
upper_distances_from_TE_normalized = upper_distances_from_TE / upper_distances_from_TE[
-1]
lower_distances_from_LE_normalized = lower_distances_from_LE / lower_distances_from_LE[
-1]
# Generate a cosine-spaced list of points from 0 to 1
s = cosspace(n_points=n_points_per_side)
x_upper_func = sp_interp.PchipInterpolator(
x=upper_distances_from_TE_normalized, y=upper_original_coors[:, 0])
y_upper_func = sp_interp.PchipInterpolator(
x=upper_distances_from_TE_normalized, y=upper_original_coors[:, 1])
x_lower_func = sp_interp.PchipInterpolator(
x=lower_distances_from_LE_normalized, y=lower_original_coors[:, 0])
y_lower_func = sp_interp.PchipInterpolator(
x=lower_distances_from_LE_normalized, y=lower_original_coors[:, 1])
x_coors = np.hstack((x_upper_func(s), x_lower_func(s)[1:]))
y_coors = np.hstack((y_upper_func(s), y_lower_func(s)[1:]))
coordinates = np.column_stack((x_coors, y_coors))
# Make a new airfoil with the coordinates
name = self.name + ", repaneled to " + str(n_points_per_side) + " pts"
new_airfoil = Airfoil(name=name,
coordinates=coordinates,
repanel=False)
return new_airfoil
def interpolation(x_axis,
y_axis,
x_value,
model='chip',
method=None,
is_function=False):
methods = [
'linear', 'nearest', 'zero', 'slinear', 'quadratic', 'cubic',
'previous', 'next'
]
# print(type(x_value),type(min(x_axis)))
models = [
'akima', 'chip', 'interp1d', 'cubicspline', 'krogh', 'barycentric'
]
# print('x_axis => ',x_axis)
result = None
f = None
if model is None or model == 'interp1d':
if method in methods:
f = interpolate.interp1d(x_axis, y_axis, kind=method)
else:
f = interpolate.interp1d(x_axis, y_axis, kind='cubic')
elif model in models:
if model == 'akima':
f = interpolate.Akima1DInterpolator(x_axis, y_axis)
elif model == 'chip':
f = interpolate.PchipInterpolator(x_axis, y_axis)
elif model == 'cubicspline':
f = interpolate.CubicSpline(x_axis, y_axis)
elif model == 'krogh':
f = interpolate.KroghInterpolator(x_axis, y_axis)
elif model == 'barycentric':
f = interpolate.BarycentricInterpolator(x_axis, y_axis)
else:
f = interpolate.PchipInterpolator(x_axis, y_axis)
if is_function == True:
return f
else:
if not isinstance(x_value, list):
# if x_value <min(x_axis) or x_value >max(x_axis):
# raise Exception('interpolation error: value requested is outside of range')
# return result
try:
result = float(f(x_value))
except:
return result
else:
result = list(map(lambda x: float(f(x)), x_value))
return result
def spectrum2time(self,
set_T=False,
timewindow=[],
tstep=0,
correct2power2=True,
slow_custom=False):
"""calculating temporal profile from the given spectrum"""
if slow_custom:
"""slow but simple and reliable version when just temporal structure
is wanted (not for iterative algoritms)"""
T = np.linspace(timewindow[0], timewindow[1],
round((timewindow[1] - timewindow[0]) / tstep) -
1) #time vector
self.T = T
self.Field_T = fourier_fixedT(self.Field_W, T, self.W)
else:
if set_T:
self.settimewindow(timewindow, tstep, correct2power2)
dw = 2 * Pi / (self.T[-1] - self.T[0])
Nw = len(self.T)
W = np.linspace(-Nw / 2, Nw / 2 - 1, Nw) * dw + self.W0
Ew = interpolate.PchipInterpolator(self.W, self.Field_W)
Field_W = np.zeros(Nw) * 1j
indS = np.logical_and(
np.ones(Nw) * W[0] <= W, W <= np.ones(Nw) * W[-1])
#calculate the new interpolated E in frequency domain; with 0 values outside the interpolation range
Field_W[indS] = Ew(W[indS])
else:
Nw0 = len(self.W)
if np.log2(Nw0) % 1:
Nw = int(
2**(np.floor(np.log2(Nw0)) + 1)
) #increase the number of points to the nearest 2**? value
else:
Nw = Nw0
#interpolate spectrum to even ferquency spacing
Ew = interpolate.PchipInterpolator(self.W, self.Field_W)
W = np.linspace(self.W[0], self.W[-1], Nw)
Field_W = np.zeros(Nw) * 1j
indS = np.logical_and(
np.ones(Nw) * W[0] <= W, W <= np.ones(Nw) * W[-1])
#calculate the new interpolated E in frequency domain; with 0 values outside the interpolation range
Field_W[indS] = Ew(W[indS])
#define corresponding time vector
Nt = Nw
dt = 2 * Pi / (W[-1] - W[0])
T = np.linspace(-Nt / 2, Nt / 2 - 1, Nt) * dt
self.T = T
self.T0 = 0
# W0=self.W0
# T0=self.T0
self.Field_T = ifftshift(ifft(Field_W)) * np.exp(
-1j * W[0] * self.T)
def simp_(p, val, m=1):
nthres = len(val)
if nthres == 2:
out = (val[1] - val[0]) * p**m + val[0]
else:
p_interp = np.linspace(0, 1, nthres)
tsimp_re = interpolate.PchipInterpolator(p_interp, val.real)
tsimp_im = interpolate.PchipInterpolator(p_interp, val.imag)
out = tsimp_re(p**m) + 1j * tsimp_im(p**m)
return out
def INTER(t, point):
#pointは[x,y]のリスト
x = np.array(point)[:, 0]
y = np.array(point)[:, 1]
if len(x) > 2:
ts = np.linspace(0, 1, len(x))
in1 = interpolate.PchipInterpolator(ts, x)
in2 = interpolate.PchipInterpolator(ts, y)
return ([in1(t), in2(t)])
else: #制御点が二つだけの時の例外処理
return ([x[0] + t * (x[1] - x[0]), y[0] + t * (y[1] - y[0])])
def siftStepPchp(xArray, sigArray):
""" EMD sifting function :
- Input -> [ xArray, sigArray ] signal time-history
- Output -> [ candidate mode, inf envelope, sup envelope ]
calculates a candidate Empirical Mode as a point-to-point average of
sup and inf envelopes - using PCHIP interpolation.
"""
#
# signal length
sigLen = len(sigArray)
# point-to-point differential
sigDiff = 0.0 * sigArray
sigDiff[1:sigLen] = sigArray[1:sigLen] - sigArray[0:sigLen - 1]
#
# gradient signature - positive and negative
grdPls = sigDiff > 0.0
grdMns = ~grdPls
#
# calculate indexes to local sup and inf elements
#
# negative and positive gradients
negGrdId = 1 * grdMns
posGrdId = 1 * grdPls
# markers of sup and inf elements
supMrkFlg = 0 * grdPls
infMrkFlg = 0 * grdMns
supMrkFlg[0:sigLen - 1] = posGrdId[0:sigLen - 1] + negGrdId[1:sigLen]
infMrkFlg[0:sigLen - 1] = negGrdId[0:sigLen - 1] + posGrdId[1:sigLen]
#
# inf and sup indexes
supIdx = supMrkFlg == 2
infIdx = infMrkFlg == 2
#
# extend supIdx and infIdx to extremes
supIdx[0] = True
supIdx[sigLen - 1] = True
infIdx[0] = True
infIdx[sigLen - 1] = True
#
# calculate sup and inf envelopes by cubic spline
#
infIntpFcn = intp.PchipInterpolator(xArray[infIdx], sigArray[infIdx])
supIntpFcn = intp.PchipInterpolator(xArray[supIdx], sigArray[supIdx])
#
infEnv = infIntpFcn(xArray)
supEnv = supIntpFcn(xArray)
#
# calculate candidate mode
cndMode = sigArray - 0.5 * (infEnv + supEnv)
#
return [cndMode, infEnv, supEnv]
def Compare_RungeKutta_Hermite(s=set1, n=4, n_step=20):
# Hermite interpolation
"""
Here we view our
x = u
y = epsilon, eta
in our formulas
We generate new x_substitutes with "step" increments as our
interpolation points.
"""
# Create Runge-Kutta Values to interpolate from
H, alpha_ett, epsilon_ett, eta_ett, \
delta_alpha, delta_epsilon, delta_eta, \
kvot_alpha, kvot_epsilon, kvot_eta, \
u_print, alpha_print, epsilon_print, eta_print = RungeKutta(set_value = s, N = n)
# Create interpolation points
step = n_step
x = np.arange(step + 1) * (2 * np.pi) / step
# Interpolation functions
f_alpha = spint.PchipInterpolator(u_print, alpha_print)
f_epsilon = spint.PchipInterpolator(u_print, epsilon_print)
f_eta = spint.PchipInterpolator(u_print, eta_print)
# Mid point
R_s, a_s, b_s = s
xp, yp = klippArket(R_s, a_s, b_s)
# Plotting
plt.subplot(221)
plt.plot(epsilon_print, eta_print, f_epsilon(x), f_eta(x), '--', xp, yp,
'x')
plt.title('$\epsilon$ - $\eta$')
plt.subplot(222)
plt.plot(u_print, alpha_print, x, f_alpha(x), '--')
plt.title(r'$\alpha$')
plt.subplot(223)
plt.plot(u_print, epsilon_print, x, f_epsilon(x), '--')
plt.title('$\epsilon$')
plt.subplot(224)
plt.plot(u_print, eta_print, x, f_eta(x), '--')
plt.title('$\eta$')
plt.suptitle('Compare Runga-Kutta and Hermite')
plt.show()
def repanel_current_airfoil(self, n_points_per_side=100):
"""This method returns a repaneled version of the airfoil with cosine-spaced
coordinates on the upper and lower
surfaces.
The number of points defining the final airfoil will be (n_points_per_side *
2 - 1), since the leading edge
point is shared by both the upper and lower surfaces.
:param n_points_per_side: int, optional
This is the number of points on the upper and lower surfaces. The default
value is 100.
:return: None
"""
# Get the upper and lower surface coordinates. These both contain the leading
# edge point.
upper_original_coordinates = self.upper_coordinates()
lower_original_coordinates = self.lower_coordinates()
# Generate a cosine-spaced list of points from 0 to 1.
cosine_spaced_x_values = functions.cosspace(
n_points=n_points_per_side,
endpoint=True,
)
# Create interpolated functions for the x and y values of the upper and lower
# surfaces as a function of the
# chord fractions
upper_func = sp_interp.PchipInterpolator(
x=np.flip(upper_original_coordinates[:, 0]),
y=np.flip(upper_original_coordinates[:, 1]),
)
lower_func = sp_interp.PchipInterpolator(
x=lower_original_coordinates[:, 0],
y=lower_original_coordinates[:, 1])
# Find the x and y coordinates of the upper and lower surfaces at each of the
# cosine-spaced x values.
x_coordinates = np.hstack(
(np.flip(cosine_spaced_x_values), cosine_spaced_x_values[1:]))
y_coordinates = np.hstack((
upper_func(np.flip(cosine_spaced_x_values)),
lower_func(cosine_spaced_x_values[1:]),
))
# Stack the coordinates together and return them.
coordinates = np.column_stack((x_coordinates, y_coordinates))
self.coordinates = coordinates
def interpolate_from_key_frame(max_loc, traj, obj_time_line):
#create a time list for key_frame
ori_time_list = []
key_frame = []
key_frame_time = []
if len(max_loc) != 0:
if max_loc[0][0] != 0:
ori_time_list.append(obj_time_line[0])
key_frame.append(traj[0])
key_frame_time.append(obj_time_line[0])
else:
ori_time_list.append(obj_time_line[0])
key_frame.append(traj[0])
key_frame_time.append(obj_time_line[0])
for item in max_loc:
ori_time_list.append(obj_time_line[int(item[0])])
key_frame.append(traj[int(item[0])])
key_frame_time.append(obj_time_line[int(item[0])])
ori_time_list.append(obj_time_line[-1])
key_frame_time.append(obj_time_line[-1])
key_frame.append(traj[-1])
# f = interpolate.interp1d(ori_time_list, key_frame, kind='cubic')
# recreated_signal = f(obj_time_line)
f = interpolate.PchipInterpolator(key_frame_time, key_frame)
recreated_signal = f(obj_time_line)
return recreated_signal
def loadspectralphase(self, FP, xcal='nm', axis=(0, 1)):
Sp = imp_phase(FP, xcal=xcal, axis=axis)
if len(self.Field_W) == 0:
self.Field_W = np.ones(len(Sp)) * 1j
IntPh = interpolate.PchipInterpolator(Sp[:, 0], Sp[:, 1])
Ph = IntPh(self.W)
self.Field_W = self.Field_W * np.exp(1j * Ph)
def pulseduration(self, method='FWHM', transform_limited=False):
if transform_limited:
#for the transform limited option
Nw0 = len(self.W)
if np.log2(Nw0) % 1:
Nw = int(2**(
np.floor(np.log2(Nw0)) + 1
)) #increase the number of points to the nearest 2**? value
else:
Nw = Nw0
#interpolate spectrum to even ferquency spacing
Ew = interpolate.PchipInterpolator(self.W, np.abs(
self.Field_W)) #spectral phase is removed by np.abs
W = np.linspace(self.W[0], self.W[-1], Nw)
Field_W = np.zeros(Nw) * 1j
indS = np.logical_and(
np.ones(Nw) * W[0] <= W, W <= np.ones(Nw) * W[-1])
#calculate the new interpolated E in frequency domain; with 0 values outside the interpolation range
Field_W[indS] = Ew(W[indS])
#define corresponding time vector
Nt = Nw
dt = 2 * Pi / (W[-1] - W[0])
T = np.linspace(-Nt / 2, Nt / 2 - 1, Nt) * dt
Field_T = ifftshift(ifft(Field_W) * np.exp(1j * W[0] * T))
It = np.abs(Field_T)**2
else:
It = np.abs(self.Field_T)**2
T = self.T
return width(T, It, method)
def plot():
#x=np.array([1,2,3,4,5,6])
#y=[0,0.29,0.11,0.27,-0.97,-0.09]
#x=np.array([1,2,3,4])
#y=[0,-0.88,-0.46,-0.88]
x = np.array([1, 2, 3])
y = [0, 0.14, -0.25]
global count
count = len(y)
#x=np.linspace(0,count,num=count)
x_new = np.linspace(x.min(), x.max(), num=count * 100)
#plt.plot(x,y,'o',color='#01545a')
for i, j in zip(x, y):
plt.text(i,
j - 0.03,
'{0:.2f}'.format(j),
ha='center',
va='bottom',
fontsize=16)
f = interpolate.PchipInterpolator(x, y) #通过最高点拟合
y_new = f(x_new)
plt.plot(x_new, y_new)
#plt.plot([[0.85,1.85,2.85,3.85,4.85,5.85],[1.15,2.15,3.15,4.15,5.15,6.15]],[[0,0.29,0.11,0.27,-0.97,-0.09],[0,0.29,0.11,0.27,-0.97,-0.09]],color='#01545a',linewidth=4)
#plt.plot([[0.85,1.85,2.85,3.85],[1.15,2.15,3.15,4.15]],[[0,-0.88,-0.46,-0.88],[0,-0.88,-0.46,-0.88]],color='#01545a',linewidth=4)
plt.plot([[0.85, 1.85, 2.85], [1.15, 2.15, 3.15]],
[[0, 0.14, -0.25], [0, 0.14, -0.25]],
color='#01545a',
linewidth=4)
def histogram_voodoo(image, num_control_points=3):
'''
This function kindly provided by Daniel Eaton from the Paulsson lab.
It performs an elastic deformation on the image histogram to simulate
changes in illumination
Parameters
----------
image : 2D numpy array
Input image.
num_control_points : int, optional
Number of inflection points to use on the histogram conversion curve.
The default is 3.
Returns
-------
2D numpy array
Modified image.
'''
control_points = np.linspace(0, 1, num=num_control_points + 2)
sorted_points = copy.copy(control_points)
random_points = np.random.uniform(low=0.1,
high=0.9,
size=num_control_points)
sorted_points[1:-1] = np.sort(random_points)
mapping = interpolate.PchipInterpolator(control_points, sorted_points)
return mapping(image)
def _gufunc_pchip_roots_old(x, y, target, out):
xy = preprocess_nan_func(x, y, out)
if xy is None:
out[:] = np.nan
return
x, y = xy
# reshape to [target, ...]
target = np.reshape(
target,
[len(target)] + [
1,
] * y.ndim,
)
y = y[np.newaxis, ...]
interpolator = interpolate.PchipInterpolator(
x,
y - target,
extrapolate=False,
axis=-1,
)
roots = interpolator.roots()
flattened = roots.ravel()
for idx, f in enumerate(flattened):
if f.size > 1:
warnings.warn(
"Found multiple roots. Picking the first one. This will depend on the ordering of `dim`",
UserWarning,
)
flattened[idx] = f[0]
good = flattened.nonzero()[0]
out[:] = np.where(np.isin(np.arange(flattened.size), good), flattened,
np.nan).reshape(roots.shape)
def __init__(self, fN_mtype, zmnx=(0.,0.), pivots=[0.],
param=None, zpivot=2.4, gamma=1.5):
self.fN_mtype = fN_mtype # Should probably check the choice
if fN_mtype == 'Gamma': # I14 values
zmnx = (0., 10.)
param = [ [12., 23., 21., 28.], # Common
[1.75828e8, 9.62288e-4], # Bi values
[500, 1.7, 1.2, 4.7, 0.2, 2.7, 4.5], # LAF
[1.1, 0.9, 2.0, 1.0, 2.0] ] # DLA
self.zmnx = zmnx
# Pivots
if pivots == None: self.pivots = np.zeros(2)
else: self.pivots = pivots
self.npivot = len(pivots)
# Param
if param is None:
self.param = np.zeros(self.npivot)
else:
self.param = param
#if np.amax(self.pivots) < 99.:
# self.pivots.append(99.)
# self.param = np.append(self.param,-30.)
# Init
if fN_mtype == 'Hspline':
self.model = scii.PchipInterpolator(self.pivots, self.param)
# Redshift (needs updating)
self.zpivot = zpivot
self.gamma = gamma
def __init__(self):
"""Initialize a cosmological model and arrays to interpolate
redshift to comoving distance. Note that H0 = 100 h km/s/Mpc is
used. For now the cosmological parameters measured by Planck
(P.A.R. Ade et al., Paper XIII, A&A 594:A13, 2016) are used.
"""
h = 0.677
pl15 = cosmology.LambdaCDM(name='pl15',
H0=100 * u.km / (u.Mpc * u.s),
Om0=0.307,
Ob0=0.0486,
Ode0=0.693,
Tcmb0=2.725 * u.K,
Neff=3.05,
m_nu=np.asarray([0., 0., 0.06]) * u.eV)
z0 = 0.
z1 = 3.
nz = int((z1 - z0) / 0.001) + 1
self.z = np.linspace(z0, z1, nz)
self.r = np.zeros(nz, dtype=float)
self.r[1:] = pl15.comoving_distance(self.z[1:])
# Define an interpolation. Use the 1D cubic monotonic interpolator
# from scipy.
self.r_vs_z = interpolate.PchipInterpolator(self.z, self.r)
def update_parameters(self, parm):
""" Update parameters (mainly used in the MCMC)
Updates other things as needed
Parameters
----------
parm : ndarray
Parameters for the f(N) model to update to
"""
if self.mtype == 'Hspline':
self.param['sply'] = np.array(parm)
# Need to update the model too
self.model = scii.PchipInterpolator(self.pivots,
self.param['sply'])
elif self.mtype == 'Gamma':
if len(parm) == 4: # A,beta for LAF and A,beta for DLA
self.param['LAF']['Aval'] = parm[0]
self.param['LAF']['beta'] = parm[1]
self.param['DLA']['Aval'] = parm[2]
self.param['DLA']['beta'] = parm[3]
else:
raise ValueError(
'fN/model: Not ready for {:d} parameters'.format(
len(parm)))
def matchGrids(data, oldGrid, newGrid, interp_method='pchip'):
"""
General function for interpolating one grid of hydographic data onto a
desired grid
Parameters
----------
data : the data to be gridded onto a new grid
griddata : the datagrid to interpolate onto
Returns
-------
gridded_data : the data gridded onto chosen grid
"""
newGrid = np.squeeze(newGrid)
oldGrid = np.squeeze(oldGrid)
# find which axis to interpolate along (and which counts the stations)
data_dims = np.array(data.shape)
axis_choose = int(np.where(data_dims != len(oldGrid))[0])
gridded_data = np.empty((len(newGrid), data.shape[axis_choose]))
# Interpolate vertically through each cast
for i in range(data.shape[axis_choose]):
f = interp.PchipInterpolator(oldGrid, data[:, i])
gridded_data[:, i] = f(newGrid)
return gridded_data
def make_graph(self, data, icon):
x = [0, 0.5, 1.5, 2.5, 3.5, 4.5, 5.5, 6.5, 7]
y = [data[0]] + data + [data[len(data) - 1]]
f = interpolate.PchipInterpolator(x, y)
x_new = np.arange(0, len(y) - 2, 0.01)
y_new = f(x_new)
fig = plt.figure(frameon=False)
fig.set_size_inches(12, 4)
ax = plt.subplot(111)
ax.fill_between(x_new, y_new, min(y) - 1)
ax.set_axis_off()
buf = BytesIO()
plt.savefig(buf, format='png', transparent=True)
buf.seek(0)
plot = Image.open(buf)
plot.load()
buf.close()
plot = self.png_crop(plot)
grad = Image.open(f'{self.path}/resources/{icon}_grad.png').convert(
'RGBA')
back = Image.new('RGBA', grad.size, (255, 255, 255, 0))
plot = plot.resize(grad.size, resample=Image.ANTIALIAS)
back.paste(grad, plot)
return back
def interpolate_raw_dataset(dataset, orig_raw_dataset):
"""
Interpolate the downsampled dataset to the original sampling rate
:param mne.io.RawArray dataset: object holding the downsampled dataset
:param mne.io.RawArray orig_raw_dataset: object holding the raw dataset with the original sampling rate
:return: mne.io.RawArray object holding the interpolated dataset
"""
# obtain the time stamps, data and the info object from the dataset
ts = dataset.times
data = dataset.get_data()
# obtain the original time stamps
orig_ts = orig_raw_dataset.times
# perform interpolation
interpolator = interpolate.PchipInterpolator(ts,
data,
axis=1,
extrapolate=True)
interpolated_data = interpolator(orig_ts, extrapolate=True)
info = orig_raw_dataset.info
# substitute the ECG data with original ECG data
interpolated_dataset = mne.io.RawArray(interpolated_data,
info,
verbose=False)
return interpolated_dataset
def gen_interp_branch_points(points, div):
result = []
x, y, dist, w = [], [], [], []
for point in points:
x.append(point.x)
y.append(point.y)
dist.append(math.sqrt(point.x * point.x + point.y * point.y))
w.append(point.w)
fx = interpolate.interp1d(dist, x, kind="cubic")
fy = interpolate.interp1d(dist, y, kind="cubic")
fw = interpolate.PchipInterpolator(dist, w)
dist_min = min(dist)
dist_max = max(dist)
new_dist = []
for i in range(0, div + 1):
dist_i = dist_min + (dist_max - dist_min) * i / float(div)
if (dist_i > dist_max):
dist_i = dist_max
new_dist.append(dist_i)
new_x = fx(new_dist)
new_y = fy(new_dist)
new_w = fw(new_dist)
for (xi, yi, wi) in zip(new_x, new_y, new_w):
result.append(BranchPoint(xi, yi, wi, float('nan')))
return result
def __init__(self,
data,
child,
name=None,
interpolator="cubic spline",
extrapolate=True):
if data.ndim != 2 or data.shape[1] != 2:
raise ValueError("""
data should have exactly two columns (x and y) but has shape {}
""".format(data.shape))
elif interpolator == "pchip":
interpolating_function = interpolate.PchipInterpolator(
data[:, 0], data[:, 1], extrapolate=extrapolate)
elif interpolator == "cubic spline":
interpolating_function = interpolate.CubicSpline(
data[:, 0], data[:, 1], extrapolate=extrapolate)
else:
raise ValueError(
"interpolator '{}' not recognised".format(interpolator))
# Set name
if name is not None:
name = "interpolating function ({})".format(name)
else:
name = "interpolating function"
super().__init__(interpolating_function,
child,
name=name,
derivative="derivative")
# Store information as attributes
self.interpolator = interpolator
self.extrapolate = extrapolate
