def InflectPoints(TP, Frac, TotalConc, DerEp=1e-3, D1Cut=1e-1):
try:
Valid = ValidbyTotalConc(TotalConc)
TP = TP[Valid]
Frac = Frac[Valid]
LogTP = np.log10(TP)
s5 = InterpolatedUnivariateSpline(LogTP, Frac, k=5)
#s5.set_smoothing_factor(1e-3)
D2 = s5.derivative(2)
R2 = D2.roots()
s4 = InterpolatedUnivariateSpline(LogTP, Frac, k=4)
#s4.set_smoothing_factor(1e-3)
D1 = s4.derivative(1)
#R1 = D1.roots()
ITest = R2[D1(R2) >= D1Cut]
DevCheck1 = np.sign(D1(ITest - DerEp)) == np.sign(D1(ITest + DerEp))
DevCheck2 = np.sign(D2(ITest - DerEp)) != np.sign(D2(ITest + DerEp))
DevCheck = np.logical_and(DevCheck1, DevCheck2)
#DevCheck = DevCheck1
#DevCheck = DevCheck2
# print "Radius of Curvature: {}".format(np.abs((1+D1(R2)**1.5)/D2(R2)))
return ITest[DevCheck]
except:
print "Inflection Point Error!!!!"
return []
def find_sub_pixel_max_value(inp, k=4, ignore_border=50):
"""
To find the highest point in a 2D array, with subpixel accuracy based on 1D spline interpolation.
The algorithm is based on a matlab script "tom_peak.m"
@param inp: A 2D numpy array containing the data points.
@type inp: numpy array 2D
@param k: The smoothing factor used in the spline interpolation, must be 1 <= k <= 5.
@type k: int
@return: A list of all points of maximal value in the structure of tuples with the x position, the y position and
the value.
@returntype: list
"""
# assert len(ixp.shape) == 2
# assert isinstance(k, int) and 1 <= k <= 5
import numpy as xp
from scipy.interpolate import InterpolatedUnivariateSpline
inp = inp[ignore_border:-ignore_border, ignore_border:-ignore_border]
v = xp.amax(inp) # the max value
result = xp.where(inp == v) # arrays of x and y positions of max values
output = []
for xpp, yp in zip(result[0], result[1]):
# Find the highest point for x (first check if on sides otherwise interpolate)
if xpp == 1 or xpp == inp.shape[0]:
x = xpp
xv = v
else:
f = InterpolatedUnivariateSpline(range(0, inp.shape[0]),
inp[:, yp],
k=k) # spline interpolation
cr_pts = f.derivative().roots()
cr_vals = f(cr_pts)
val = xp.argmax(cr_vals)
x = cr_pts[val]
xv = cr_vals[val]
# Find the highest point for y (first check if on sides otherwise interpolate)
if yp == 1 or yp == inp.shape[1]:
y = yp
yv = v
else:
f = InterpolatedUnivariateSpline(range(0, inp.shape[1]),
inp[xpp, :],
k=k) # spline interpolation
cr_pts = f.derivative().roots()
cr_vals = f(cr_pts)
val = xp.argmax(cr_vals)
y = cr_pts[val]
yv = cr_vals[val]
# Calculate the average of the max value to return a single value which is maybe more close to the true value
output.append([x + ignore_border, y + ignore_border, (xv + yv) / 2])
return output[0]
def test_aligned_spin_limit_ringdown(q):
""" Test that the (2,2) mode frequency in the ringdown is within in 1Hz between v4HM and v4PHM.
In particular, consider cases where the final spin is negative with respect to the initial
orbital angular momentum. Of course considers only aligned-spin cases"""
# Step 0: set parameters
chi1_x, chi1_y, chi1_z = 0.0, 0.0, -0.95
chi2_x, chi2_y, chi2_z = 0.0, 0.0, -0.95
m_total = 150 # Feducial total mass in solar masses
deltaT = 1.0 / 16384
distance = 500 * 1e6 * lal.PC_SI # 500 Mpc in m
f_start22 = 20
# Step 1: Get the SEOBNRv4PHM modes
hlmP = get_SEOBNRv4PHM_modes(
q,
m_total,
[chi1_x, chi2_y, chi1_z],
[chi1_x, chi2_y, chi2_z],
f_start22 * 0.5,
distance,
deltaT,
)
# Step 2: Get the SEOBNRv4HM modes
hlmA = get_SEOBNRv4HM_modes(q, m_total, chi1_z, chi2_z, f_start22 * 0.5,
distance, deltaT)
time = deltaT * np.arange(len(hlmA[(2, 2)]))
time2 = deltaT * np.arange(len(hlmP[(2, 2)]))
# Compute the (2,2) mode frequencies
mode = (2, 2)
phaseA = np.unwrap(np.angle(hlmA[mode]))
phaseP = np.unwrap(np.angle(hlmP[mode]))
intrpA = InterpolatedUnivariateSpline(time, phaseA)
intrpP = InterpolatedUnivariateSpline(time2, phaseP)
omega_A = intrpA.derivative()
omega_P = intrpP.derivative()
# Consider the frequency in the ringdown
amp = np.abs(hlmA[mode].data)
am = np.argmax(amp)
omega_A_rd = omega_A(time[am:am + 350])
omega_P_rd = omega_P(time[am:am + 350])
# Ensure the difference is small. Note here atol=1 corresponds to 1 Hz difference on frequncies of hundreds of Hz. These small
# diffrences are expected due to some minor code differences.
# Before a bug was fixed the difference would be huge, i.e. ~100s Hz
assert np.allclose(
omega_A_rd, omega_P_rd, atol=1
), "The frequencies of the (2,2) mode don't agree between SEOBNRv4PHM and SEOBNRv4HM!"
def find_Tg(quenchTs, mean_vals,sap):
print(sap)
if True:#sap<=50.:
use_first_deviation = False
if use_first_deviation:
model = piecewise(quenchTs, mean_vals)
if len(model.segments) == 2:
lines = []
l1 = model.segments[0]
m1 = l1.coeffs[1]
b1 = l1.coeffs[0]
l2 = model.segments[1]
m2 = l2.coeffs[1]
b2 = l2.coeffs[0]
f = InterpolatedUnivariateSpline(quenchTs, mean_vals, k=2)
dxdT = f.derivative(n=1)
dx_dTs = dxdT(quenchTs)
dev_index = np.where(np.abs(dx_dTs)>m1)[0][0]
x=quenchTs[dev_index]
y=mean_vals[dev_index]
else:
print('using derivatives')
f = InterpolatedUnivariateSpline(quenchTs, mean_vals, k=2)
dxdT = f.derivative(n=1)
d2xdT = f.derivative(n=2)
dx_dTs = dxdT(quenchTs)
d2x_dT2s = d2xdT(quenchTs)
max_dx2 = np.max(d2x_dT2s)
min_dx2 = np.min(d2x_dT2s)
max_i = np.where(d2x_dT2s==max_dx2)[0][0]
min_i = np.where(d2x_dT2s==min_dx2)[0][0]
x = (quenchTs[min_i]+quenchTs[max_i])/2
y = (mean_vals[min_i]+mean_vals[max_i])/2
else:
print('using line iftting')
#plot_data_with_regression(quenchTs, mean_vals)
model = piecewise(quenchTs, mean_vals)
#print(model)
if len(model.segments) == 2:
lines = []
l1 = model.segments[0]
m1 = l1.coeffs[1]
b1 = l1.coeffs[0]
l2 = model.segments[1]
m2 = l2.coeffs[1]
b2 = l2.coeffs[0]
x,y = line_intersect(m1,b1,m2,b2)
else:
print('WARNING: found more or less than 2 line segments in regression!')
return x,y
def init_slope_and_curve(self):
dim = 5
delta_r = 0.01
r_vals = np.array([
self.R - 2 * delta_r, self.R - 1 * delta_r, self.R,
self.R + 1 * delta_r, self.R + 2 * delta_r
])
LP_E = np.zeros(dim)
UP_E = np.zeros(dim)
### get a stencil of UP and LP energies
for i in range(0, dim):
self.R = r_vals[i]
self.H_e()
self.H_total = np.copy(self.H_electronic + self.H_photonic +
self.H_interaction)
vals, vecs = LA.eig(self.H_total)
idx = vals.argsort()[::1]
vals = vals[idx]
LP_E[i] = np.real(vals[1])
UP_E[i] = np.real(vals[2])
### fit spline to upper and lower polariton surface
LP_spline = InterpolatedUnivariateSpline(r_vals, LP_E, k=3)
UP_spline = InterpolatedUnivariateSpline(r_vals, UP_E, k=3)
### differentiate upper and lower polariton surfaces
LP_slope = LP_spline.derivative()
UP_slope = UP_spline.derivative()
### 2nd derivative of UP and LP surfaces
LP_curve = LP_slope.derivative()
UP_curve = UP_slope.derivative()
### store quantities
self.en_up_old = UP_spline(self.R)
self.en_up_new = UP_spline(self.R + delta_r)
self.en_lp_old = LP_spline(self.R)
self.en_lp_new = LP_spline(self.R + delta_r)
self.slope_up_old = UP_slope(self.R)
self.slope_up_new = UP_slope(self.R + delta_r)
self.slope_lp_old = LP_slope(self.R)
self.slope_lp_new = LP_slope(self.R + delta_r)
self.curve_up_old = UP_curve(self.R)
self.curve_up_new = UP_curve(self.R + delta_r)
self.curve_lp_old = LP_slope(self.R)
self.curve_lp_new = LP_slope(self.R + delta_r)
return 1
def get_data(filename):
# Make dataframe
df = pd.read_csv(filename,
names=["Wavelength", "Absorbance"],
delimiter=",")[::-1]
# Remove rows where we get NaN as an absorbance
df = df.apply(pd.to_numeric, errors='raise')
df = df.dropna()
# We only care about the wavelengths between 400 and 700 nm.
df = df[(df["Wavelength"] < 700) & (400 < df["Wavelength"])]
# Smooth the absorbance data
df["Absorbance"] = ss.savgol_filter(df["Absorbance"],
window_length=9,
polyorder=4)
# An object which makes splines
spline_maker = IUS(df["Wavelength"], df["Absorbance"])
# An object which calculates the derivative of those splines
deriv_1 = spline_maker.derivative(n=1)
deriv_2 = spline_maker.derivative(n=2)
# Calculate the derivative at all of the splines
df["First_derivative"] = deriv_1(df["Wavelength"])
df["Second_derivative"] = deriv_2(df["Wavelength"])
return df
def interpolation_spline(x_vals, y_vals):
"""
Use cubic spline interpolation to find the sub-pixel position of the peak of the CCF
:param x_vals:
If the CCF is y(x), this is the array of the x values of the data points supplied to interpolate.
:param y_vals:
If the CCF is y(x), this is the array of the y values of the data points supplied to interpolate.
:return:
Our best estimate of the position of the peak.
"""
def quadratic_spline_roots(spl):
roots = []
knots = spl.get_knots()
for a, b in zip(knots[:-1], knots[1:]):
u, v, w = spl(a), spl((a + b) / 2), spl(b)
t = np.roots([u + w - 2 * v, w - u, 2 * v])
t = t[np.isreal(t) & (np.abs(t) <= 1)]
roots.extend(t * (b - a) / 2 + (b + a) / 2)
return np.array(roots)
f = InterpolatedUnivariateSpline(x=x_vals, y=y_vals)
cr_pts = quadratic_spline_roots(f.derivative())
cr_vals = f(cr_pts)
if len(cr_vals) == 0:
return np.nan
max_index = np.argmax(cr_vals)
return cr_pts[max_index]
def convert_stress(self, mtype='qe'):
raw = np.loadtxt("ishear.txt")
data = np.zeros((len(raw), len(raw[0]) + 1))
data[:, :-1] = raw
if mtype in ['qe']:
data[:, 1] /= unitconv.uengy['rytoeV']
convunit = unitconv.ustress['evA3toGpa']
vol = np.zeros(len(raw))
vperf = 0.5 * self.pot['lattice']**3
strmat = np.zeros([3, 3])
for i in range(len(raw)):
strmat[0, 0], strmat[1, 1], strmat[2, 2] = \
raw[i, 2], raw[i, 3], raw[i, 4]
strmat[1, 0], strmat[2, 0], strmat[2, 1] = \
raw[i, 0], raw[i, 5], raw[i, 6]
strmat = np.mat(strmat)
vol[i] = vperf * np.linalg.det(strmat)
tag = 'interp'
if tag == 'interp':
# interpolate
spl = InterpolatedUnivariateSpline(raw[:, 0], raw[:, 1])
# spl.set_smoothing_factor(0.5)
splder1 = spl.derivative()
for i in range(len(raw)):
# append the stress to the last column
print("coeff", convunit / vol[i])
data[i, -1] = splder1(raw[i, 0]) * convunit / vol[i]
print(data)
np.savetxt("stress.txt", data)
def FindCriticalPrice(prices_changes, revenue_curve):
"""
Need to make sure that second derivative is negative (i.e., concave down)
"""
from scipy.interpolate import InterpolatedUnivariateSpline
f = InterpolatedUnivariateSpline(prices_changes, revenue_curve, k=4)
cr_pts = f.derivative().roots()
return cr_pts[0] # assume there is only one local/global maximum
def compute_freqInterp(time, hlm):
philm = np.unwrap(np.angle(hlm))
intrp = InterpolatedUnivariateSpline(time, philm)
omegalm = intrp.derivative()(time)
return omegalm
def peak(x, y):
"""Calculate the FWHM and peak height of a vector y with corresponding coordinates x."""
spline = InterpolatedUnivariateSpline(x, y, k=4, ext='raise')
extrema = spline.derivative().roots()
if len(extrema) < 1:
return np.nan
max_x = extrema[np.argmax(spline(extrema))]
return max_x
def build_splines(self, scale_factor):
lM_min, lM_max = self.lM_bounds
M_space = np.logspace(lM_min - 1, lM_max + 1, 500, base=10)
sigmaM = np.array([cc.sigmaMtophat_exact(M, scale_factor) for M in M_space])
ln_sig_inv_spline = IUS(M_space, -np.log(sigmaM))
deriv_spline = ln_sig_inv_spline.derivative()
self.deriv_spline = deriv_spline
self.splines_built = True
return
def cal_peierls_stress(self):
if os.path.isfile('pengy.txt'):
data = np.loadtxt('pengy.txt')
else:
data = self.read_peierls_barrier_neb()
spl = InterpolatedUnivariateSpline(data[0], data[1], k=3)
splder1 = spl.derivative()
interpnts = np.linspace(0, self._burger, 51)
stress = splder1(interpnts)
plt.savefig("tmp.png")
print(np.max(stress))
def SWPI1(M1, rhof1, T1, rhop, dp, R, gamma, mu, cd, n):
import numpy as np
import scipy.integrate as intg
import matplotlib.pyplot as plt
from scipy.interpolate import interp1d
from scipy.interpolate import InterpolatedUnivariateSpline
Vp = (4*np.pi*(dp/2)**3)/3
P1 = rhof1*R*T1
P2 = P1*(2*gamma*M1**2/(gamma+1) - ((gamma-1)/(gamma+1)))
T2 = T1*((1 + 0.5*(gamma-1)*M1**2)*(2*gamma*M1**2/(gamma-1) - 1)*2*(gamma-1)/((gamma+1)**2*M1**2))
rhof2 = rhof1*(P2*T1)/(P1*T2)
vf1 = M1*np.sqrt(gamma*R*T1)
vf2 = vf1*rhof1/rhof2
M2 = vf2/np.sqrt(gamma*R*T2)
# return vf1, vf2
"SW eqns"
Pr = 0.75
G = (gamma+1)/((4/3)+((gamma-1)/Pr))
X_SW = (8/G)*(mu/(vf1-vf2)*rhof1)
X_SW_array = np.linspace(-X_SW, X_SW, n)
# return X_SW_array
f = (8/3)*(rhof1*vf1/mu)*((gamma-1)/gamma)*X_SW_array
vf_SW = (vf1 + vf2*np.e**f) / (1 + np.e**f)
t_SW = X_SW/vf_SW[5]
# return vf_SW
t = np.linspace(0, t_SW, n)
# vf_SW_inter = interp1d(t, vf_SW, kind='cubic', fill_value='extrapolate')
vf_SW_inter = InterpolatedUnivariateSpline(t, vf_SW, k=3)
vf_SW_diff = vf_SW_inter.derivative()
# return vf_SW_diff(5)
# return vf_SW_diff(t)
# return vf_SW
def Fd(vp,t):
# dvpdt = -3*np.pi*mu*dp*(vp[0]-vf_SW_inter)/(Vp*rhop)
# dvpdt = -3*np.pi*mu*dp*(vp[0]-vf_SW_inter(t))/(Vp*rhop)
dvpdt = (0.5*rhof1*0.25*np.pi*(dp**2)*cd*(vp[0]-vf_SW_inter(t))**2)/(Vp*rhop)
return dvpdt
def Fp(vp, t):
dvpdt = (rhof1/rhop)*(vf_SW_diff(t))
return dvpdt
def Fam(vp, t):
dvpdt = (0.5*rhof1*vf_SW_diff(t))/(rhop+0.5*rhof1)
return dvpdt
vp0 = vf1
vp_d = intg.odeint(Fd, vp0, t)
vp_p = intg.odeint(Fp, vp0, t)
vp_am = intg.odeint(Fam, vp0, t)
plt.plot(X_SW_array, Fd(vp_d, t), '-r', lw=5.0)
plt.plot(X_SW_array, Fp(vp_p, t), '-b', lw=5.0)
plt.plot(X_SW_array, Fam(vp_am, t), '-g', lw=5.0)
plt.show()
plt.figure()
def phaseOmegaOrbdiff(time_common, timeDyn_Lev1, phaseorb_Lev1, timeDyn_Lev2,
phaseorb_Lev2):
intrp_Lev1 = InterpolatedUnivariateSpline(timeDyn_Lev1, phaseorb_Lev1)
intrp_Lev2 = InterpolatedUnivariateSpline(timeDyn_Lev2, phaseorb_Lev2)
phaseorbdiff = intrp_Lev2(time_common) - intrp_Lev1(time_common)
intrp_phaseorbdiff = InterpolatedUnivariateSpline(time_common,
phaseorbdiff)
omegaorbdiff = intrp_phaseorbdiff.derivative()(time_common)
return phaseorbdiff, omegaorbdiff
def build_splines(self):
"""Build the splines needed for integrals over mass bins.
"""
lM_min, lM_max = self.l10M_bounds
M_domain = np.logspace(lM_min - 1, lM_max + 1, num=500)
sigmaM = np.array(
[cc.sigmaMtophat(M, self.scale_factor) for M in M_domain])
self.sigmaM_spline = IUS(M_domain, sigmaM)
ln_sig_inv_spline = IUS(M_domain, -np.log(sigmaM))
deriv_spline = ln_sig_inv_spline.derivative()
self.deriv_spline = deriv_spline
return
def build_splines(self):
"""Build the splines needed for integrals over mass bins.
"""
lM_min,lM_max = self.l10M_bounds
M_domain = np.logspace(lM_min-1, lM_max+1, num=1000)
sigmaM = np.array([cc.sigmaMtophat(M, self.scale_factor)
for M in M_domain])
self.sigmaM_spline = IUS(M_domain, sigmaM)
ln_sig_inv_spline = IUS(M_domain, -np.log(sigmaM))
deriv_spline = ln_sig_inv_spline.derivative()
self.deriv_spline = deriv_spline
return
def get_Vmixfn(tarr,th,Dt,getVmixdot=False,E51=1.,Vmax=None):
sigEfn = get_sigEfn(tarr,th,E51=E51)
Vmixarr = Vmix_base(tarr,Dt,sigEfn)
if Vmax != None: Vmixarr[Vmixarr>Vmax]=Vmax
Vmixfn = interp1d(tarr,Vmixarr)
if getVmixdot:
Vmixfnspline = InterpolatedUnivariateSpline(tarr,Vmixarr)
Vmixdotspline = Vmixfnspline.derivative()
Vmixdotarr = Vmixdotspline(tarr)
Vmixdotfn = interp1d(tarr,Vmixdotarr)
return Vmixfn,Vmixdotfn
else:
return Vmixfn
def get_Vmixarr(tarr,th,Dt,getVmixdot=False,E51=1.,Vmax=None):
sigEfn = get_sigEfn(tarr,th,E51=E51)
Vmixarr = Vmix_base(tarr,Dt,sigEfn)
if Vmax != None: Vmixarr[Vmixarr>Vmax]=Vmax
if getVmixdot:
Vmixfnspline = InterpolatedUnivariateSpline(tarr,Vmixarr)
Vmixdotspline = Vmixfnspline.derivative()
Vmixdotarr = Vmixdotspline(tarr)
#dt = tarr[1]-tarr[0]
#Vmixdotarr = (Vmixarr[1:]-Vmixarr[:-1])/dt
#Vmixdotarr = np.concatenate((Vmixdotarr,[0]))
return Vmixarr,Vmixdotarr
else:
return Vmixarr
def deriv(self, degree: int) -> Tuple[np.array, np.array]:
"""Find the n-th derivative"""
pH, volume = self.trim_values(self.ph, self.volume_titrant)
# An object which makes splines
spline_maker = IUS(volume, pH)
# An object which calculates the derivative of those splines
deriv_function = spline_maker.derivative(n=degree)
# Calculate the derivative at all of the splines
d = deriv_function(volume)
return volume, d
def derivatives(self):
"""
function to compute the first and second derivatives of the
wavefunction by interpolating with a cubic spline and using
the built-in derivative methods of the splines. The first
derivative will be stored in the attribute self.Psi_p
and the second derivative will be stored in the attribute self.Psi_pp
"""
ci = 0 + 1j
### fit the spline to real and imaginary part of wf
fr = InterpolatedUnivariateSpline(self.x, np.real(self.Psi))
fi = InterpolatedUnivariateSpline(self.x, np.imag(self.Psi))
### get the derivative of the spline
fr_p = fr.derivative()
fi_p = fi.derivative()
### get the second derivative of the spline
fr_pp = fr_p.derivative()
fi_pp = fi_p.derivative()
### store the derivative of the spline to self.Psi_p
self.Psi_p = fr_p(self.x) + ci * fi_p(self.x)
### sore the second derivative of the spline to self.Psi_pp
self.Psi_pp = fr_pp(self.x) + ci * fi_pp(self.x)
return 1
def get_maximum(x, y):
"""
interpolate maximum
"""
f = InterpolatedUnivariateSpline(x, y, k=4)
# get Nullstellen
cr_pts = f.derivative().roots()
cr_pts = np.append(cr_pts, (x[0], x[-1])) # also check the endpoints of the interval
cr_vals = f(cr_pts)
max_index = np.argmax(cr_vals)
max_x = cr_pts[max_index]
max_y = cr_vals[max_index]
return max_x, max_y
def findMaximum(x_values, y_values):
try:
f = InterpolatedUnivariateSpline(x_values, y_values, k=4)
cr_pts = f.derivative().roots()
cr_pts = np.append(
cr_pts, (x_values[0],
x_values[-1])) # also check the endpoints of the interval
cr_vals = f(cr_pts)
min_index = np.argmin(cr_vals)
max_index = np.argmax(cr_vals)
#print("Maximum value {} at {}\nMinimum value {} at {}".format(cr_vals[max_index], cr_pts[max_index], cr_vals[min_index], cr_pts[min_index]))
return cr_vals[max_index], cr_pts[max_index]
except:
print("findMaximum failes for x_values=" + str(x_values) +
" y_values=" + str(y_values))
return None, None
def findmaxima(template):
'''Find the amplitude and peak frequency values of your template using spline interpolation'''
x_axis = template[:, 0]
y_axis = template[:, 1]
f = InterpolatedUnivariateSpline(x_axis, y_axis, k=4)
cr_pts = f.derivative().roots()
cr_pts = np.append(
cr_pts, (x_axis[0],
x_axis[-1])) # also check the endpoints of the interval
cr_vals = f(cr_pts)
max_index = np.argmax(cr_vals)
max_amplitude = cr_vals[max_index]
peak_frequency = cr_pts[max_index]
return max_amplitude, peak_frequency
def determine_spline_and_derivative(self):
time, intensity = zip(*self.peak_data)
low = bisect_left(time, self.peak_time - self.peak_window)
high = bisect_right(time, self.peak_time + self.peak_window)
# Failsafe
if high == len(time):
high = -1
new_x = linspace(time[low], time[high],
int(2500 * (time[high] - time[low])))
f = InterpolatedUnivariateSpline(time[low:high], intensity[low:high])
f_prime = f.derivative()
self.univariate_spline_data = list(zip(new_x, f(new_x)))
self.first_derivative_data = list(zip(new_x, f_prime(new_x)))
class StrippedPowerLawMassFunction(GenericMassFunction):
def __init__(self, m_a, gamma):
#These parameters are specific to the model we use
self.gamma = gamma
self.m_a = m_a
#Here 'us' denotes 'unstripped', i.e. the values before MW stripping has been accounted for
self.mmin_us = calc_Mmin(m_a)
self.mmax_us = calc_Mmax(m_a)
#Here, we generally need the average mass *before* any disruption, so let's calculate this
#before we do any correction for stripping due to the MW halo
self.mavg = ((gamma) /
(gamma + 1)) * (self.mmax_us**(gamma + 1) - self.mmin_us**
(gamma + 1)) / (self.mmax_us**gamma -
self.mmin_us**gamma)
mi_list = np.geomspace(self.mmin_us, self.mmax_us, 10000)
mf_list = mass_after_stripping(mi_list)
self.mmin = np.min(mf_list)
self.mmax = np.max(mf_list)
print("M_max:", self.mmax)
self.mi_of_mf = InterpolatedUnivariateSpline(mf_list,
mi_list,
k=1,
ext=1)
self.dmi_by_dmf = self.mi_of_mf.derivative(n=1)
def dPdlogM_nostripping(self, mass):
return self.gamma * mass**self.gamma / (self.mmax_us**self.gamma -
self.mmin_us**self.gamma)
def dPdlogM_internal(self, mass):
"""
Edit this halo mass function, dP/dlogM
Strongly recommend making this vectorized
"""
m_f = mass
m_i = self.mi_of_mf(m_f)
return self.dPdlogM_nostripping(m_i) * self.dmi_by_dmf(m_f) * m_f / m_i
def execute(block, config):
k_growth = config
z_pk, k_pk, p_lin = block.get_grid(names.matter_power_lin, 'z', 'k_h',
'p_k')
a_pk = 1 / (1 + z_pk)
growth_ind = np.where(k_pk > k_growth)[0][0]
growth_array = np.sqrt(
np.divide(p_lin[:, growth_ind],
p_lin[0, growth_ind],
out=np.zeros_like(p_lin[:, growth_ind]),
where=p_lin[:, growth_ind] != 0.))
#compute f(a) = dlnD/dlna, need to reverse when splining as expects increasing x
growth_spline = IUS(np.log(a_pk[::-1]), np.log(growth_array[::-1]))
f_array = growth_spline.derivative()(np.log(a_pk[::-1]))[::-1]
block[growth_section, 'd_z'] = growth_array
block[growth_section, 'f_z'] = f_array
block[growth_section, 'z'] = z_pk
return 0
def __init__(self, cosmo):
"""
Attributes
----------
cosmo : Cosmo object (from universe.py)
Cosmology object
"""
self.cosmo = cosmo
# self.fac = (3 * (self.cosmo.omegab+self.cosmo.omegac) * self.cosmo.H0**2.) / (const.c.to('km/s').value**3)
self.fac = (3 * (self.cosmo.omegab + self.cosmo.omegac) *
self.cosmo.H0**2.) / (const.c.to('km/s').value**2)
# Calculate growth factor derivative
z = np.logspace(1e-5, np.log10(cosmo.zstar), 1000)
s = InterpolatedUnivariateSpline(z, self.cosmo.D_z(z) * (1 + z))
self.der = s.derivative()
super(iSW, self).__init__(1e-5, self.cosmo.zstar)
class Cubic_Spline_Table_Form(object):
"""Potential form that takes tabulated data and returns interpolated values.
This potential uses cubic spline interpolation. It is simply a wrapper around
the scipy.interpolate.InterpolatedUnivariateSpline class"""
"""Identifier used in config files through `interpolation` directive"""
config_label = "cubic_spline"
#Tag used during introspection of class so that it is automatically registered with Potential_Form_Registry
is_potential = True
def __init__(self, x_data, y_data):
"""Creates a potential form by linking x,y data points by cubic splines.
:param x_data: List of x data values.
:param y_data: List of y data values."""
from scipy.interpolate import InterpolatedUnivariateSpline
# ext =1 means that a value of zero is returned outside the data range.
self._interpolant = InterpolatedUnivariateSpline(x_data, y_data, ext=1)
self._deriv = self._interpolant.derivative()
self._deriv2 = self._deriv.derivative()
@property
def interpolant(self):
"""This class is a wrapper around instances of scipy.interpolate.InterpolatedUnivariateSpline
This property returns the scipy object used internally"""
return self._interpolant
def __call__(self, x):
""":return: interpolated value at x"""
return float(self._interpolant(x))
def deriv(self, x):
""":return: derivative of potential form at x"""
return float(self._deriv(x))
def deriv2(self, x):
""":return: second derivative of potential form at x"""
return float(self._deriv2(x))
def phaseOmegalmdiff(time_common, time_Lev1, phaselm_Lev1, time_Lev2,
phaselm_Lev2):
phaselmdiff = {}
omegalmdiff = {}
assert (len(list(phaselm_Lev1.keys())) == len(list(
phaselm_Lev2.keys()))), "Levs have different mode arrays!"
for l, m in list(phaselm_Lev1.keys()):
intrp_Lev1 = InterpolatedUnivariateSpline(time_Lev1, phaselm_Lev1[l,
m])
intrp_Lev2 = InterpolatedUnivariateSpline(time_Lev2, phaselm_Lev2[l,
m])
phaselmdiff[l, m] = intrp_Lev2(time_common) - intrp_Lev1(time_common)
intrp_phaselmdiff = InterpolatedUnivariateSpline(
time_common, phaselmdiff[l, m])
omegalmdiff[l, m] = intrp_phaselmdiff.derivative()(time_common)
return phaselmdiff, omegalmdiff
def compute_OrbPhaseOmega(Lev3):
timeDyn = Lev3['Horizons']['AhA']['CoordCenterInertial']['x'][:, 0]
xA = Lev3['Horizons']['AhA']['CoordCenterInertial']['x'][:, 1]
yA = Lev3['Horizons']['AhA']['CoordCenterInertial']['y'][:, 1]
zA = Lev3['Horizons']['AhA']['CoordCenterInertial']['z'][:, 1]
xB = Lev3['Horizons']['AhB']['CoordCenterInertial']['x'][:, 1]
yB = Lev3['Horizons']['AhB']['CoordCenterInertial']['y'][:, 1]
zB = Lev3['Horizons']['AhB']['CoordCenterInertial']['z'][:, 1]
x = xA - xB
y = yA - yB
z = zA - zB
#rvec = np.concatenate((x,y,z),axis=None)
# Multiply by 2 the argument of unwrap and divide the outcome by two as suggested in https://stackoverflow.com/questions/52293831/unwrap-angle-to-have-continuous-phase
phaseorb = np.unwrap(2 * np.arctan(y / x)) / 2
intrp_phase = InterpolatedUnivariateSpline(timeDyn, phaseorb)
omegaorb = intrp_phase.derivative()(timeDyn)
return timeDyn, phaseorb, omegaorb
def test_fermi_distribution_derivative(verbose=False):
if is_numpy_newer_than('1.8.0'):
beta = 3.3
e = np.linspace(-5., 5., num=1000)
f = fermi_distribution(beta, e)
df = fermi_distribution_derivative(beta, e)
from scipy.interpolate import InterpolatedUnivariateSpline
sp = InterpolatedUnivariateSpline(e, f)
dsp = sp.derivative(1)
df_ref = dsp(e)
np.testing.assert_almost_equal(df, df_ref)
if verbose:
import matplotlib.pyplot as plt
plt.plot(e, f, label='f')
plt.plot(e, df, label='df')
plt.plot(e, df_ref, label='df_ref')
plt.legend()
plt.show()
exit()
def minimize(self, data: Data, init_hypo: Parameters = None) -> float:
"""Minimization over POIs
The method scans over the POI values in `scan_pois`, computes
the NLL and profile NPs for each one, and returns the point
that yields the minimal NLL.
Args:
data : dataset for which to compute the NLL
init_hypo : initial value (of POIs and NPs) for the minimization
Returns:
best-fit parameters
"""
self.nlls = np.zeros(self.scan_pois.size)
for i in range(0, len(self.scan_pois)):
scan_hypo = init_hypo.clone().set_poi(self.scan_pois[i])
np_min = NPMinimizer(data)
self.nlls[i] = np_min.profile_nll(scan_hypo)
self.pars[i] = np_min.min_pars
#print('@poi(', i, ') =', poi, self.nlls[i], ahat, bhat)
smooth_nll = InterpolatedUnivariateSpline(self.scan_pois,
self.nlls,
k=4)
minima = smooth_nll.derivative().roots()
self.min_nll = np.amin(self.nlls)
self.min_idx = np.argmin(self.nlls)
self.min_pois = np.array([self.scan_pois[self.min_idx]])
if len(minima) == 1:
interp_min = smooth_nll(minima[0])
if interp_min < self.min_nll:
self.min_pois = minima
self.min_nll = interp_min
self.min_pars = Parameters(self.min_pois,
self.pars[self.min_idx],
model=data.model)
return self.min_nll
# CAN PLOT THE SHAPE BELOW, SHOULD LOOK LIKE WHAT BRUNO HAD
#lets produce a lil smoothed analytic of the nEurtral
height = np.arange(0, 300, 0.1)
ray = np.zeros(len(height))
ray[:] = height
# lets model to 300 km
NeutralIndex = new_neutral(ray, len(height))
IonoIndex, ElectronDensity = iono(ray, len(height))
net_N = ((NeutralIndex) + IonoIndex) * 1e6
ElectronIndex, ElectronDesity = iono(ray, len(height))
# #we need a derivate of the iono density
smoothresults = InterpolatedUnivariateSpline(height, ElectronDesity)
prime = smoothresults.derivative(n=1)
doubleprime = smoothresults.derivative(n=2)
finerx = np.linspace(0, 300, 1000)
firstderivative = prime(finerx)
secondderivative = doubleprime(finerx)
# fig, ((ax1,ax2),(ax3,ax4)) = plt.subplots(2,2)
# ax1.plot(NeutralDesity[0,:],height, 'b')
# ax1.set_title('Neutral Density', loc='left')
# ax1.set_ylabel('Altitude (km)')
# ax1.set_xlabel('Density ($m^{-3}$)')
# ax1.set_ylim(0,300)
# ax2.plot(np.log10(NeutralDesity[0,:]),height,'b')
# ax2.set_title('Neutral Density', loc='left')
#plot elevation and azimuth in simple plot
x = np.arange(0, len(sat_data[:,1]));
x = x/60.0; #convert to minutes
ax1.plot(x, sat_data[:,2], label="Elevation");
ax1.plot(x, sat_data[:,3], label="Azimuth");
ax1.plot(x, np.repeat(0, len(x)), label="Horizon", linestyle="dashed");
legendsize=10
ax1.legend(loc='best', fontsize=legendsize);
ax1.set_ylabel("Degrees");
#plot elevation rate
ax2.plot(x, sat_data[:,5], label="Elevation rate");
#plot numerical derivative estimated from an interpolating spline
f = InterpolatedUnivariateSpline(x, sat_data[:,2], k=1)
dfdx = f.derivative()
dydx = dfdx(x)
ax2.plot(x, sat_data[0,5]/dydx[0]*dydx, label="Scaled numerical derivative");
ax2.legend(loc='best', fontsize=legendsize);
ax2.set_ylabel("Degrees");
ax2.set_ylabel("Degrees");
#plot doppler shift
ax3.plot(x, np.repeat(1000, len(x)), label="Downlink frequency");
ax3.plot(x, sat_data[:,4], label="Doppler-shifted downlink frequency");
ax3.legend(loc='best', fontsize=legendsize);
ax3.set_ylabel("Frequency (MHz)");
tickrange=np.arange(999.98, 1000.025, 0.01);
ax3.set_yticks(tickrange)
ax3.set_yticklabels(map(str, tickrange));
plt.xlabel("Timestep (min)");
class VTC(object):
bracket_size = 1000
stop_error = 0.001
max_iters = 10
def __init__(self, csv_file, vin='Vin', vout='Vout'):
self.x_values = []
self.y_values = []
self.traces = {}
self.annotations = []
self.csvfile = csv_file
try:
f = open(csv_file, 'r')
self.spamreader = csv.DictReader(f, delimiter=' ')
except TypeError:
print("THERE WAS AN ERROR!")
raise
for row in self.spamreader:
self.x_values.append(float(row[vin]))
self.y_values.append(float(row[vout]))
f.close()
# getting a spline's derivative is much more accurate for finding
# the VTC's characteristic parameters
self.spl = InterpolatedUnivariateSpline(self.x_values, self.y_values)
self.spline_1drv = self.spl.derivative()
self.get_characteristic_parameters()
self.traces['VTC'] = {
'x': self.x_values,
'y': self.y_values,
'label': 'Voltage Transfer Characteristic',
'class': 'main',
}
def find_vm(self, start=None, stop=None, bracket_size=1000,
stop_error=0.001, max_iters=10):
if not start:
start = self.min_x
if not stop:
stop = self.max_x
iter_count = 0
smallest = numpy.nan_to_num(numpy.inf)
smallest_at = 0
while smallest > stop_error and iter_count < max_iters:
q = numpy.linspace(start, stop, bracket_size)
for (x, y) in zip(q, self.spl.__call__(q)):
if abs(y-x) < smallest:
smallest = abs(y-x)
smallest_at = x
length = float(stop - start)
if not float(smallest_at - (length/4)) < start:
start = float(smallest_at - (length/4))
if not float(smallest_at + (length/4)) > stop:
stop = float(smallest_at + (length/4))
iter_count += 1
return smallest_at
def find_inflection_point(self, **iter_params):
if not hasattr(self, 'spline_1drv'):
self.spline_1drv = self.spl.derivative()
p = self.defaults
p.update(iter_params)
start, stop = p['start'], p['stop']
iter_count = 0
biggest_y = 0
biggest_x = 0
while iter_count < p['max_iters']:
q = numpy.linspace(start, stop, p['bracket_size'])
for (dx, dy) in zip(q, self.spline_1drv.__call__(q)):
if abs(dy) > biggest_y:
biggest_y = abs(dy)
biggest_x = dx
length = float(stop - start)
if not float(biggest_x - (length/4)) < start:
start = float(biggest_x - (length/4))
if not float(biggest_x + (length/4)) > stop:
stop = float(biggest_x + (length/4))
iter_count += 1
self.inflection_point = biggest_x
return biggest_x
def find_where_derivative_is(self, value, start=None,
stop=None, bracket_size=1000,
stop_error=0.001, max_iters=10):
if not hasattr(self, 'spline_1drv'):
self.spline_1drv = self.spl.derivative()
if not start:
start = self.min_x
if not stop:
stop = self.max_x
iter_count = 0
closest_y = numpy.inf
closest_x = numpy.inf
while abs(value - closest_y) > stop_error and iter_count < max_iters:
q = numpy.linspace(start, stop, bracket_size)
for (dx, dy) in zip(q, self.spline_1drv.__call__(q)):
if abs(value - dy) < abs(value - closest_y):
closest_y = dy
closest_x = dx
length = float(stop - start)
if not float(closest_x - (length/4)) < start:
start = float(closest_x - (length/4))
if not float(closest_x + (length/4)) > stop:
stop = float(closest_x + (length/4))
iter_count += 1
return closest_x
def get_tangent_line_at(self, x):
y = self.spl.__call__(x)
m = self.spl.__call__(x, 1)
b = y - (m * x)
return y, m, b
def make_tangent_line_at(self, x):
# make tangent line occupy 1/6 of plot
x_extend = self.range_x / 9
y_extend = self.range_y / 9
y, m, b = self.get_tangent_line_at(x)
x1 = x - x_extend
x2 = x + x_extend
y1 = m*x1+b
y2 = m*x2+b
return x1, x2, y1, y2
def get_characteristic_parameters(self):
self.min_x = float(min(self.x_values))
self.max_x = float(max(self.x_values))
self.min_y = float(min(self.y_values))
self.max_y = float(max(self.y_values))
self.range_x = float(self.max_x - self.min_x)
self.range_y = float(self.max_y - self.min_y)
self.defaults = {
'bracket_size': self.bracket_size,
'stop_error': self.stop_error,
'max_iters': self.max_iters,
'start': self.min_x,
'stop': self.max_x,
}
if not hasattr(self, 'inflection_point'):
self.find_inflection_point()
self.voh = self.max_y
self.vih = self.find_where_derivative_is(-1, start=self.inflection_point)
self.vm = self.find_vm()
self.vil = self.find_where_derivative_is(-1, stop=self.inflection_point)
self.vol = self.min_y
self.nml = self.vil - self.vol
self.nmh = self.voh - self.vih
# print(self.vol, self.vil, self.vm, self.vih, self.voh, self.nml, self.nmh)
def plot_ly(self, filename):
offset = (self.max_y/20)
line_style = Line(
color='rgb(44, 160, 44)',
opacity=0.25,
dash='dot',
)
helper_line_style = {
'line': line_style,
'showlegend': False,
'mode': 'lines',
'connectgaps': True,
}
traces = []
traces.append(Scatter(
x=self.x_values,
y=self.y_values,
))
for (point, name) in {self.vil: 'V_IL', self.vih: 'V_IH'}.items():
x1, x2, y1, y2 = self.make_tangent_line_at(point)
traces.append(
Scatter(
x=[x1, x2],
y=[y1, y2],
mode='lines',
name='tangent at dy/dx=-1',
showlegend=False,
connectgaps=True,
opacity=0.5,
line=Line(
color='#AAAAAA',
)
)
)
traces.append(
Scatter(
x=[point, point],
y=[self.min_y, self.spl(point)],
**helper_line_style
)
)
for (point, name) in dict({self.vol: 'V_{OL}', self.voh: 'V_{OH}'}).items():
traces.append(Scatter(
x=[self.min_x, self.max_x],
y=[point, point],
name=name,
**helper_line_style
))
traces.append(Scatter(
x=[0, self.vm],
y=[0, self.vm],
mode='lines',
name=['V_M'],
line=line_style,
))
data = Data(traces)
annotations = []
annotations.append(Annotation(x=self.max_x, xanchor='left', align='left', yanchor='top', y=self.vol, text='$V_{OL}$', showarrow=False))
annotations.append(Annotation(x=self.vil, y=self.min_y, yanchor='top', text='$V_{IL}$', showarrow=False))
annotations.append(Annotation(x=self.vm, y=self.vm, xanchor='left', align='left', text='$V_{M}$', showarrow=False))
annotations.append(Annotation(x=self.vih, y=self.min_y, yanchor='top', text='$V_{IH}$', showarrow=False))
annotations.append(Annotation(x=self.max_x, xanchor='left', align='left', y=self.voh, text='$V_{OH}$', showarrow=False))
layout = Layout(
title='Voltage Transfer Characteristic',
xaxis=XAxis(title='$V_{in} \\left(\\text{V}\\right)$', showgrid=False),
yaxis=YAxis(title='$V_{out} \\left(\\text{V}\\right)$', showgrid=False),
annotations=Annotations(annotations),
showlegend=False,
autosize=False,
width=500,
height=500,
margin=Margin(
l=50,
r=50,
b=50,
t=50,
),
)
fig = Figure(data=data, layout=layout)
plot_url = py.plot(fig, filename=filename)
def matplotlib(self, filename):
import seaborn as sns
sns.set_style('white')
offset = (self.voh - self.vol)/50
self.figure = plt.figure(facecolor='white', figsize=(3.5, 3.6))
ax = plt.gca()
ax.spines['top'].set_visible(False)
ax.spines['right'].set_visible(False)
ax.clip_on=False
plt.tick_params(top='off', right='off')
plt.locator_params('both', tight=True, nbins=4)
# set text and line formatting stuff
# plt.rc('text', usetex=True)
plt.rc('lines', linewidth=1)
plt.rc('font', size=12)
main_plot = dict(linewidth=3, zorder=20)
tangent_lines = dict(color='grey', linewidth=1)
marker_lines = dict(color='grey', linewidth=1, linestyle='--')
#
plt.xlabel(r"$V_{in}$")
plt.ylabel(r"$V_{out}$")
# plot the main VTC
plt.plot(self.x_values, self.y_values, label='VTC', **main_plot)
plt.plot([0, 1, self.vm], [0, 1, self.vm], **marker_lines)
ax.annotate('$V_{M}$', xy=(self.vm, self.vm), xytext=(0, -8), textcoords='offset points',
horizontalalignment='left', verticalalignment='middle')
for label, point in {r'$V_{OL}$': self.vol, r'$V_{IL}$': self.vil, r'$V_{IH}$': self.vih,
r'$V_{OH}$': self.voh}.items():
x1, x2, y1, y2 = self.make_tangent_line_at(point)
ax.plot([x1, x2], [y1, y2], **tangent_lines)
ax.axvline(x=point, **marker_lines)
# ax.annotate(label, xy=(point, 0), xytext=(0, -8), textcoords='offset points',
# horizontalalignment='center', verticalalignment='top')
# ax.axvline(x=self.vil, **marker_lines)
# ax.axvline(x=self.vih, **marker_lines)
ax.annotate('$V_{OL}$', xy=(self.vol, 0), xytext=(0, -8), textcoords='offset points',
horizontalalignment='left', verticalalignment='top')
ax.annotate('$V_{IL}$', xy=(self.vil, 0), xytext=(0, -8), textcoords='offset points',
horizontalalignment='center', verticalalignment='top')
ax.annotate('$V_{IH}$', xy=(self.vih, 0), xytext=(0, -8), textcoords='offset points',
horizontalalignment='center', verticalalignment='top')
ax.annotate('$V_{OH}$', xy=(self.voh, 0), xytext=(0, -8), textcoords='offset points',
horizontalalignment='center', verticalalignment='top')
ax.annotate('', xy=(0, self.voh/1.5), xycoords='data',
xytext=(self.vil, self.voh/1.5), textcoords='data',
arrowprops=dict(arrowstyle="<->", ec="k",))
ax.annotate('$NM_L$', xy=(self.vil/2, self.voh/1.5), xytext=(0, -5), textcoords='offset points',
horizontalalignment='center', verticalalignment='top')
ax.annotate('', xy=(self.vih, self.voh/1.5), xycoords='data',
xytext=(self.voh, self.voh/1.5), textcoords='data',
arrowprops=dict(arrowstyle="<->", ec="k",))
ax.annotate('$NM_H$', xy=((self.voh-self.vih)/2+self.vih, self.voh/1.5), xytext=(0, -5), textcoords='offset points',
horizontalalignment='center', verticalalignment='top')
plt.tight_layout()
ax.locator_params(axis='both', tight=True)
ax.set_ylim(0-0.02)
ax.set_xlim(0)
self.figure.savefig(filename)
def matplotly(self, filename):
plot_url = py.plot_mpl(self.figure)
