def test_pchip_interpolate(self):
assert_array_almost_equal(
pchip_interpolate([1, 2, 3], [4, 5, 6], [0.5], der=1), [1.])
assert_array_almost_equal(
pchip_interpolate([1, 2, 3], [4, 5, 6], [0.5], der=0), [3.5])
assert_array_almost_equal(
pchip_interpolate([1, 2, 3], [4, 5, 6], [0.5], der=[0, 1]),
[[3.5], [1]])
def calc_1d_interpolation(x, y, kind=None, no=50):
''' Return linspaced x and interpolated y for average, with pm std dev.
Parameters
----------
x : float
x-values
y : float
y-values
Returns
-------
xls : float
x-values, unique
ya : float
y-values, average
yp : float
y-values, average + standard deviation
ym : float
y-values, average - standard deviation
'''
# Calculate and sort variables
xu, ya, ys = calc_statistics(x, y)
xls = np.linspace(min(xu), max(xu), num=no)
yp = ya + ys
ym = ya - ys
# 'linear' is safe but not that nice
# 'quadratic' seems to oscillate
# 'cubic' seems to oscillate
# 1 d interpolation
kinds = [
'pchip', 'linear', 'nearest', 'zero', 'slinear', 'quadratic', 'cubic'
]
if kind is None:
kind = kinds[0]
if not len(xu) > 1:
kind = 'few_xu'
logger.info(f'Skipping interpolation, too few points: {len(xu)}')
if kind == 'few_xu':
ya = np.array([ya for xi in xls])
yp = np.array([yp for xi in xls])
ym = np.array([ym for xi in xls])
elif kind == 'pchip':
ya = interpolate.pchip_interpolate(xu, ya, xls)
yp = interpolate.pchip_interpolate(xu, yp, xls)
ym = interpolate.pchip_interpolate(xu, ym, xls)
else:
# Only linear interpolation seems to work well for a small dataset
ya = interpolate.interp1d(xu, ya, kind=kind)(xls)
yp = interpolate.interp1d(xu, yp, kind=kind)(xls)
ym = interpolate.interp1d(xu, ym, kind=kind)(xls)
return xls, ya, yp, ym
def test_pchip_interpolate(self):
assert_array_almost_equal(
pchip_interpolate([1,2,3], [4,5,6], [0.5], der=1),
[1.])
assert_array_almost_equal(
pchip_interpolate([1,2,3], [4,5,6], [0.5], der=0),
[3.5])
assert_array_almost_equal(
pchip_interpolate([1,2,3], [4,5,6], [0.5], der=[0, 1]),
[[3.5], [1]])
def CorrectAbsorption(wl_abs, abs_data, Name, Type):
data = np.loadtxt('materials/' + Name + '_nk.txt')
n = pchip_interpolate(data[:, 0], data[:, 1], wl_abs)
k = pchip_interpolate(data[:, 0], data[:, 2], wl_abs)
t = 160 * 1e-6
t_array = np.ones((len(wl_abs), )) * t
alpha = 4 * np.pi * k / (wl_abs * 1e-9)
if Type == "Tiedje":
return abs_data * alpha / (alpha + (1 / (4 * (n**2) * t_array)))
elif Type == "2Pass":
Tout = abs_data * np.exp(-alpha * 2 * t_array)
return abs_data - Tout
def interp_1d_values_from_profiles(self):
"""Interpolate values in 1D (lateral + longitudinal) from profiles"""
new_values = np.zeros((self.nb_var, self.nb_nodes_in_riverbed))
for i_zone in np.unique(self.points['zone']):
filter_points = self.points['zone'] == i_zone
section_us = self.section_seq[i_zone]
section_ds = self.section_seq[i_zone + 1]
xt_us = section_us.coord.array['Xt']
xt_ds = section_ds.coord.array['Xt']
xt_us_target = self.points['Xt_upstream'][filter_points]
xt_ds_target = self.points['Xt_downstream'][filter_points]
for i, var in enumerate(self.var_names()):
values_us = section_us.coord.values[var]
values_ds = section_ds.coord.values[var]
if self.interp_values == 'LINEAR':
new_values_us = np.interp(xt_us_target, xt_us, values_us)
new_values_ds = np.interp(xt_ds_target, xt_ds, values_ds)
elif self.interp_values == 'B-SPLINE':
splrep_us = interpolate.splrep(xt_us, values_us)
splrep_ds = interpolate.splrep(xt_ds, values_ds)
new_values_us = interpolate.splev(xt_us_target, splrep_us)
new_values_ds = interpolate.splev(xt_ds_target, splrep_ds)
elif self.interp_values == 'AKIMA':
new_values_us = interpolate.Akima1DInterpolator(
xt_us, values_us)(xt_us_target)
new_values_ds = interpolate.Akima1DInterpolator(
xt_ds, values_ds)(xt_ds_target)
elif self.interp_values == 'PCHIP':
new_values_us = interpolate.pchip_interpolate(
xt_us, values_us, xt_us_target)
new_values_ds = interpolate.pchip_interpolate(
xt_ds, values_ds, xt_ds_target)
elif self.interp_values == 'CUBIC_SPLINE':
new_values_us = interpolate.CubicSpline(
xt_us, values_us)(xt_us_target)
new_values_ds = interpolate.CubicSpline(
xt_ds, values_ds)(xt_ds_target)
else:
raise NotImplementedError
new_values[i, filter_points] = new_values_us * (1 - self.points['xl'][filter_points]) + \
new_values_ds * self.points['xl'][filter_points]
return new_values
def calc_func(antenna_pol, field_pol):
"""antenna_pol should be 0 or 1 for X or Y antenna, and field_pol is 0 or 1 for zenithal or azimuthal field"""
nonlocal temp_AVE_matrix, tmp3
## first average
Npairs = int((end_i - start_i) / 2)
for pair_i in range(Npairs):
ant_i = 2 * pair_i + antenna_pol + start_i
get_ant_i(ant_i, field_pol) ## this fills temp_matrix
temp_AVE_matrix += temp_matrix ## error prone, but should be okay
if not np.all(np.isfinite(temp_AVE_matrix)):
print('YO problem!', pair_i,
np.all(np.isfinite(temp_matrix)))
quit()
temp_AVE_matrix /= Npairs
upsample_grid = np.empty(
[num_zeniths, num_azimuths,
len(interpolant_frequencies)],
dtype=np.complex)
## now interpolate frequencies
for zi, ze in enumerate(self.AART_thetas):
for ai, az in enumerate(self.AART_Phis):
np.abs(temp_AVE_matrix[zi, ai, :], out=tmp3)
interp_ampltude = pchip_interpolate(
self.all_frequencies, tmp3, interpolant_frequencies)
angles = np.angle(temp_AVE_matrix[zi, ai, :])
angles = np.unwrap(angles)
interp_angle = pchip_interpolate(self.all_frequencies,
angles,
interpolant_frequencies)
## now convert back to real and imag
interp_angle = interp_angle * 1j
np.exp(interp_angle, out=upsample_grid[zi, ai, :])
upsample_grid[zi, ai, :] *= interp_ampltude
## and final angle-frequency interpolant
return RegularGridInterpolator(
(self.AART_thetas, self.AART_Phis, interpolant_frequencies),
upsample_grid,
bounds_error=False,
fill_value=0.0)
def patch_bokeh(self, start, mid, end, *args, **kwargs):
xs = [start[0], mid[0], end[0]]
ys = [start[1], mid[1], end[1]]
x2 = np.linspace(xs[0], xs[-1], 100)
y2 = interpolate.pchip_interpolate(xs, ys, x2)
self._bokeh_fig.line(x2, y2, *args, **kwargs)
def curved_line(x0, x1, y0, angle=0, x_spread=4, y_spread=20, num_points=0):
if num_points == 0:
num_points = np.random.randint(3, 6) * 2
### get x points
x = np.linspace(x0, x1, num_points)
for i in range(len(x)):
x[i] += rand.randint(-x_spread, x_spread)
x[0], x[-1] = x0, x1
### get y points
y = np.full(num_points, y0)
for i in range(len(y)):
y[i] += rand.randint(-y_spread, y_spread)
y[0], y[-1] = y0, y0
### interpolate
line_res = 5
x2 = np.linspace(x[0], x[-1], (x[-1] - x[0]) * line_res)
x2, indices = np.unique(x2, return_index=True)
y2 = interpolate.pchip_interpolate(x, y, x2[indices])
vx, vy = [], []
for i in range(len(hx) - 1):
coord = rotate((x0, y0), (x2[i], y2[i]), math.radians(angle))
vx.append(coord[0])
vy.append(coord[1])
vx, vy = quantize_line_pair(vx, vy)
return vx, vy
def FittedTransmission(voltages, offset, amplitude, *params):
"""
Return the transmission function for a shaper
"""
V, M = GetVM(*params)
return amplitude * np.cos(pchip_interpolate(
V, M, voltages))**2 + offset
def phs4(reducedTemperature):
# Reduced collision integral for a hard sphere - 4 potential
Xt = [
0.01, 0.04, 0.09, 0.16, 0.25, 0.36, 0.49, 0.64, 0.81, 1.00, 1.21, 1.44,
1.69, 1.96, 2.25, 2.56, 2.89, 3.24, 3.61, 4.00, 4.84, 5.76, 6.76, 7.84,
9.00, 10.24, 11.56, 12.96, 14.44, 16.00, 19.36, 23.04, 27.04, 31.36,
36.00, 40.96, 46.24, 51.84, 57.76, 64.00, 100.00, 1000.00
]
YtG = [
13.67, 6.640, 4.343, 3.213, 2.548, 2.117, 1.823, 1.617, 1.472, 1.368,
1.292, 1.236, 1.194, 1.161, 1.136, 1.116, 1.100, 1.087, 1.076, 1.067,
1.054, 1.044, 1.036, 1.031, 1.026, 1.023, 1.020, 1.017, 1.015, 1.014,
1.010, 1.005, 1.000, 1.000, 1.000, 1.000, 1.000, 1.000, 1.000, 1.000,
1.000, 1.000
]
#sets up to see if the temperature is even in range It might not be neccesary with pchip interpolation,
#but it will at least catch some odd errors coming through.
if reducedTemperature >= Xt[41]:
q = 1.00
return float(q)
if reducedTemperature <= Xt[0]:
q = 1.4691 / math.sqrt(reducedTemperature)
return float(q)
#interpolates using scipy "pchip" tested to give best results with this data set.
q = interpolate.pchip_interpolate(Xt, YtG, reducedTemperature)
#this is a numpy object so you have to convert it to something useful to the rest of the program.
return float(q)
def stopPicking(self,proj):
filename = fd.asksaveasfilename()
if filename is not '':
self.picking = False
print("Picking mode off")
np.savetxt(filename+'_profile.txt',self.picked,delimiter='\t')
print('saved picked file as "%s"' %(filename+'_profile.txt'))
# If we have 3D info, also plot it as 3D points
if proj.threeD is not None:
# First calculate along-track points
topoVal = proj.threeD[:,2]
npos = proj.threeD.shape[0]
steplen = np.sqrt(
np.power( proj.threeD[1:npos,0]-proj.threeD[0:npos-1,0] ,2.0) +
np.power( proj.threeD[1:npos,1]-proj.threeD[0:npos-1,1] ,2.0) +
np.power( proj.threeD[1:npos,2]-proj.threeD[0:npos-1,2] ,2.0)
)
alongdist = np.cumsum(steplen)
topoPos = np.append(0,alongdist)
pick3D = np.zeros((self.picked.shape[0],3))
# If profile is adjusted, need to start the picked at zero.
pickProfileShifted = self.picked[:,0] - np.min(proj.profilePos)
#for i in range(0,3):
for i in range(0,2):
pick3D[:,i] = interp.pchip_interpolate(topoPos,
proj.threeD[:,i],
pickProfileShifted).squeeze()
#self.picked[:,0]).squeeze()
pick3D[:,2] = self.picked[:,1].squeeze()
np.savetxt(filename+'_3D.txt',pick3D,delimiter='\t')
print('saved picked file as "%s"' %(filename+'_3D.txt'))
def getCurrent_trapz(wl_abs, abs_data, wl_min, wl_max, theta_in):
cdir = os.path.dirname(
os.path.abspath(inspect.getfile(
inspect.currentframe()))) # script directory
am15data = opencsv(os.path.join(cdir, 'ASTMG173.csv'))
wl_am15 = am15data[:, 0]
e = 1.6021765e-19
h = 6.62607004e-34
c = 299792458
am15jphdata = np.multiply(wl_am15, am15data[:, 2])
am15jphdata *= 1.e-9 * e / (h * c) / 10
am15jphdata *= np.cos(
theta_in) #Correct for incident angles different from 0
#print "am15 shape " + str(np.shape(wl_am15))
#print "wl_abs shape " + str(np.shape(wl_abs))
#print "abs_data shape " + str(np.shape(abs_data))
abs_fine = pchip_interpolate(wl_abs, abs_data, wl_am15)
#abs_fine = abs_spline(wl_am15)
abs_int_data = np.multiply(am15jphdata, abs_fine)
n_wl = wl_am15.size
for i in range(0, n_wl):
if wl_am15[i] < wl_min:
abs_int_data[i] = 0
elif wl_am15[i] > wl_max:
abs_int_data[i] = 0
j_abs = np.trapz(abs_int_data, wl_am15)
return j_abs
def perlinNoise1D(npts, weights):
if not isinstance(weights, list):
weights = range(int(round(weights)))
weights = np.power([2] * len(weights), weights)
n = len(weights)
xvals = np.linspace(0, 1, npts)
total = np.zeros((npts, 1))
for i in range(n):
frequency = 2**i
this_npts = round(npts / frequency)
if this_npts > 1:
total += weights[i] * pchip_interpolate(
np.linspace(0, 1, this_npts),
np.random.random((this_npts, 1)), xvals)
# else:
# TODO does it matter print("Maxed out at octave {}".format(i))
total = total - np.min(total)
total = total / np.max(total)
return total.reshape(-1)
def interp_steeper(Nodes,paramNode,TS,SPLINE,K=0.4):
"""Function to interpolate by making steeper increasing or decreasing pieces of the spline.
'pchip' method extrapolates with constant to the right
"""
'''
:param array Nodes: length-4 list composed of four dates [StartDate,DateOfImposedSanctions1,DateOfImposedSanctions2,EndDate0]
:param array betaNode: length-4 list composed of estimated beta values
:param array TS: time series of float values indicating all dates with available data
:param str SPLINE: method for interpolation 'spline' or 'pchip' ! Currently developed only for 'pchip'
:param float K: K=0.4 by default
'''
# obtain spline
if SPLINE == 'spline':
warnings.warn("The 'spline' calculation is not currently implemented. The method will default to 'pchip'.")
SPLINE = 'pchip'
if SPLINE == 'pchip':
paramVal = sci.pchip_interpolate(Nodes,paramNode,TS)
paramVal_new = paramVal.copy()
else:
sys.exit('SPLINE method not recognized: "spline" and "pchip" available only')
time_interval = [x-Nodes[0] for x in Nodes]
#start modifying all parts of the spline and make them steeper
for i in range(len(Nodes)-1):
if paramNode[i] > paramNode[i+1]:
time_range = range(time_interval[i],time_interval[i+1]+1)
I=[time_interval[i],time_interval[i+1]]
steeper_segment=steeper(paramVal[time_range],I,K)
paramVal_new[time_range]=steeper_segment #we allow overlap due to interpolation
else:
time_range = range(time_interval[i],time_interval[i+1]+1)
I=[time_interval[i],time_interval[i+1]]
steeper_segment = np.array([-x for x in steeper([-x for x in paramVal[time_range]], I, K)]);
paramVal_new[time_range]=steeper_segment #we allow overlap due to interpolation
return paramVal_new
def _interpolate_z(self, z, t):
''' Interpolate t and return instantaneous velocity. '''
tl = np.linspace(min(t), max(t), 50)
za = pchip_interpolate(t, z, tl)
v = -np.diff(za) / np.diff(tl)
v = np.insert(v, 0, 0) # insert 0 as first speed
return v, za, tl
def plot_Mohr(self):
# Cu is the undrained shear strength
Cu = 0.5 * max(self.data['Stress (lb/in2)'])
x = [0, Cu, max(self.data['Stress (lb/in2)'])]
y = [0, Cu, 0]
x2 = np.linspace(x[0], x[-1], 100)
y2 = interpolate.pchip_interpolate(x, y, x2)
plt.plot(x2, y2, color='blue')
plt.plot(x, y, "ro", color='red')
# The following three codes are for the sake of specifying and labeling what the three points represent
plt.plot(Cu, Cu, 'ro', color='red', label='undrained shear strength')
plt.plot(0, 0, 'ro', color='green', label='normal stress failure')
plt.plot(max(self.data['Stress (lb/in2)']),
0,
'ro',
color='purple',
label='unconfined compression strength')
# These next lines are for the titles, labels, and design of the plot itslef
plt.title('Mohr’s Circle for Unconfined Compression Test',
fontweight='black',
fontfamily='monospace')
plt.xlabel('Normal Stress (lb/in2)')
plt.ylabel('Shear Stress (lb/in2)')
plt.grid(ls='-')
plt.legend(loc="lower center")
plt.show()
def Ac_hier(Rmax, R_idx, R_tmp, g_idx, eigen_cumsum, R_norm, A, R, C_orig, a,
num, Ct):
R_set = Rmax[R_idx] - R_tmp
eigen_sum = np.zeros(np.shape(R_tmp))
acc_r_sum = np.zeros(np.shape(R_tmp))
for i3 in range(np.shape(R_tmp)[1]):
ig = g_idx[i3]
eigen_tmp = np.asarray(eigen_cumsum[ig][0][:])
eigen_sum[:,
i3] = (eigen_tmp[np.array(R_set[:, i3], dtype=int) - 1] -
eigen_cumsum[ig][0][0]) / (eigen_cumsum[ig][0][-1] -
eigen_cumsum[ig][0][0])
acc_r_sum[:, i3] = interpolate.pchip_interpolate(
R_norm[:, ig], A[:, ig], R_set[:, i3] / R[-1, ig].astype(float))
C_tmp = R_set.astype(float).dot(a[np.asarray(g_idx)]) / C_orig
eigen_prod = np.multiply(np.prod(eigen_sum, axis=1), C_tmp)
eigen_prod = np.prod(acc_r_sum, axis=1) + eigen_prod
eigen_prod2 = eigen_prod[eigen_prod.argsort()[::-1]]
tmp_num = min(len(R_tmp), num)
tmp_val = eigen_prod2[tmp_num - 1]
tmp_idx = eigen_prod >= tmp_val
R_ = R_tmp[tmp_idx]
return R_
def interpolate_nan(self, y):
"""Interpolate over NaN points in data with monotonic cubic splines."""
assert y.ndim == 1, "Input must be 1D"
from scipy import interpolate
x = np.arange(len(y))
y_interp = interpolate.pchip_interpolate(x[~np.isnan(y)], y[~np.isnan(y)], x)
return y_interp
def _interpolate_t(self, z, t):
''' Interpolate t and return instantaneous velocity. '''
zu, ta, ts, tmin, tmax = self._calc_stat(z, t, sort=True)
zl = np.linspace(min(zu), max(zu), 50)
ta = pchip_interpolate(zu, ta, zl)
v = -np.diff(zl) / np.diff(ta)
v = np.insert(v, 0, 0) # insert 0 as first speed
return v, zl, ta
def QRED(t, g, r):
Q3 = P16_6_4(t, g).real
Q2 = P12_6_4(t, g).real
Q1 = P8_6_4(t, g).real
Q = [round(Q1, 5), round(Q2, 5), round(Q3, 5)]
X = [8., 12., 16.]
QN = interpolate.pchip_interpolate(X, Q, r)
return QN
def make_R(L, E_norm, R_norm_tmp, R, Amax):
Rmax = np.empty(L, dtype=int)
for i in range(L):
x = E_norm[i]
y = R_norm_tmp[i]
Rmax[i] = np.round(
interpolate.pchip_interpolate(x, y, Amax) * R[-1, i])
return Rmax
def _ax_minmaxfill(self, ax, x, z, desc=None):
'''Add fill min-max to plot. '''
logger.log(5, self._ax_minmaxfill.__doc__)
desc = desc or dict(self.desc, **self.interp_desc)
desc.pop('ls', None) # invalid key
desc.pop('marker', None) # invalid key
desc.pop('edgecolor', None) # invalid key
desc.pop('s', None) # invalid key
xu, za, zs, zmin, zmax = self._calc_stat(x, z, sort=True)
xl = np.linspace(min(xu), max(xu), 500)
za = pchip_interpolate(xu, za, xl)
zmin = pchip_interpolate(xu, zmin, xl)
zmax = pchip_interpolate(xu, zmax, xl)
diff = (zmax - zmin) / 20 * 0 # center space?
ax.fill_between(xl, zmax, za - diff, alpha=.15, **desc)
ax.fill_between(xl, za + diff, zmin, alpha=.15, **desc)
self.update_min_max(xl, za)
def scribble(canvas, color):
num_points = np.random.randint(3, 6)
splat_width = 4
splat_height = 20
x_neighbor_width = 80
x = np.random.randint(0, canvas.shape[0], size=num_points)
while ((min(abs(np.ediff1d(x))) < x_neighbor_width) |
(max(x) - min(x) <= ((splat_width + 1) * num_points)) |
(x.shape[0] != np.unique(x).shape[0]) | (x[1] - x[0] <= splat_width)
| (x[-1] - x[-2] <= splat_width)):
x = np.random.randint(0, canvas.shape[0], size=num_points)
x.sort()
y = np.random.randint(0, canvas.shape[1], size=num_points)
v, w = x.copy(), y.copy()
for i in range(num_points - 2):
v_temp = v[i + 1] + rand.randint(-splat_width, splat_width)
while v_temp in v:
v_temp = v[i + 1] + rand.randint(-splat_width, splat_width)
v[i + 1, ] = min(max(v_temp, 0), canvas.shape[0] - 1)
w[i + 1, ] += min(max(rand.randint(-splat_height, splat_height), 0),
canvas.shape[1] - 1)
v.sort()
line_res = 5
x2 = np.linspace(x[0], x[-1], (x[-1] - x[0]) * line_res)
x2, indices = np.unique(x2, return_index=True)
y2 = interpolate.pchip_interpolate(x, y, x2[indices])
v2 = np.linspace(v[0], v[-1], (v[-1] - v[0]) * line_res)
v2, indices = np.unique(v2, return_index=True)
w2 = interpolate.pchip_interpolate(v, w, v2[indices])
#do splatter
for i in range(len(x2)):
if y2[i] < canvas.shape[1]:
canvas[int(math.ceil(x2[i]))][int(math.ceil(y2[i]))] = color
canvas[int(math.floor(x2[i]))][int(math.floor(y2[i]))] = color
if (v2[i] >= 0) & (w2[i] >= 0) & (v2[i] < canvas.shape[0]) & (
w2[i] < canvas.shape[1] - 1):
canvas[int(math.ceil(v2[i]))][int(math.ceil(w2[i]))] = color
canvas[int(math.floor(v2[i]))][int(math.floor(w2[i]))] = color
def correctTopo(data, velocity, profilePos, topoPos, topoVal, twtt):
'''
Corrects for topography along the profile by shifting each
Trace up or down depending on provided coordinates.
INPUT:
data data matrix whose columns contain the traces
velocity subsurface RMS velocity in m/ns
profilePos along-profile coordinates of the traces
topoPos along-profile coordinates for provided elevation
in meters
topoVal elevation values for provided along-profile
coordinates, in meters
twtt two-way travel time values for the samples, in ns
OUTPUT:
newdata data matrix with shifted traces, padded with NaN
newtwtt twtt for the shifted / padded data matrix
maxElev maximum elevation value
minElev minimum elevation value
'''
# We assume that the profilePos are the correct along-profile
# points of the measurements (they can be correted with adj profile)
# For some along-profile points, we have the elevation from prepTopo
# So we can just interpolate
if not ((all(np.diff(topoPos) > 0)) or (all(np.diff(topoPos) < 0))):
raise ValueError(
'\x1b[1;31;47m' +
'The profile vs topo file does not have purely increasing or decreasing along-profile positions'
+ '\x1b[0m')
else:
elev = interp.pchip_interpolate(topoPos, topoVal, profilePos)
elevdiff = elev - np.min(elev)
# Turn each elevation point into a two way travel-time shift.
# It's two-way travel time
etime = 2 * elevdiff / velocity
timeStep = twtt[3] - twtt[2]
# Calculate the time shift for each trace
tshift = (np.round(etime / timeStep)).astype(int)
maxup = np.max(tshift)
# We want the highest elevation to be zero time.
# Need to shift by the greatest amount, where we are the lowest
tshift = np.max(tshift) - tshift
# Make new datamatrix
newdata = np.empty((data.shape[0] + maxup, data.shape[1]))
newdata[:] = np.nan
# Set new twtt
newtwtt = np.arange(0, twtt[-1] + maxup * timeStep, timeStep)
nsamples = len(twtt)
# Enter every trace at the right place into newdata
for pos in range(0, len(profilePos)):
#print(type(tshift[pos][0]))
# print("POS", pos)
# print(len(profilePos))
newdata[tshift[pos][0]:tshift[pos][0] + nsamples,
pos] = np.squeeze(data[:, pos])
return newdata, newtwtt, np.max(elev), np.min(elev)
def RF_From_Calibre(calibre):
InterpCalibre = [
20, 30, 40, 60, 75, 81, 90, 105, 120, 130, 155, 175, 203, 225, 250,
275, 300, 325, 350, 375, 400, 450, 500, 550, 600, 650, 700, 800, 900,
1000
]
InterpRF = [
295, 260, 225, 175, 152, 144, 134, 113, 99, 90, 60, 47, 30, 25, 22, 18,
16, 15, 13, 12, 10, 8, 7, 5, 3, 2, 2, 2, 2, 2
]
return int(pchip_interpolate(InterpCalibre, InterpRF, calibre))
def _ax_interpolate_zx(self, ax, x, z, desc=None):
'''Add interpolation to plot. Use x = x(z).'''
logger.log(5, self._ax_interpolate.__doc__)
desc = desc or dict(self.desc, **self.interp_desc)
if np.unique(z).size < 2:
msg = 'Skipping interpolate, too few datapoints ({}).'
logger.info(msg.format(np.unique(z).size))
return
zu, xa, xs, xmin, xmax = self._calc_stat(z, x, sort=True)
zl = np.linspace(min(zu), max(zu), 500)
xa = pchip_interpolate(zu, xa, zl)
ax.plot(xa, zl, **desc)
self.update_min_max(xa, zl)
def _ax_interpolate(self, ax, x, z, desc=None):
'''Add interpolation to plot. '''
logger.log(5, self._ax_interpolate.__doc__)
desc = desc or dict(self.desc, **self.interp_desc)
if np.unique(x).size < 2:
msg = 'Skipping interpolate, too few datapoints ({}).'
logger.info(msg.format(np.unique(x)))
return
xu, za, zs, zmin, zmax = self._calc_stat(x, z, sort=True)
xl = np.linspace(min(xu), max(xu), 500)
za = pchip_interpolate(xu, za, xl)
ax.plot(xl, za, **desc)
self.update_min_max(xl, za)
def projection_penalty(xx, yy, xx0, yy0, dxx0, dyy0, points_weight,
length3d): # standard deviation
'''
Assume that xx0, yy0 - are equidistantly spaced in terms of arc length
'''
N = len(xx0)
slist_norm = np.linspace(0, 1, N, endpoint=True)
slist = curve3d.calc_slist(xx, yy)
xx_interp = pchip_interpolate(slist / slist[-1], xx, slist_norm)
yy_interp = pchip_interpolate(slist / slist[-1], yy, slist_norm)
points_penalty = points_weight * np.sum(
(xx_interp - xx0)**2 + (yy_interp - yy0)**2) / N * length3d**-2
## Add penalty for tangents deviation # works as penalty on derivative deviation (see Sobolev space)
dxx_interp = np.diff(xx_interp)
dyy_interp = np.diff(yy_interp)
ds = slist[-1] / (N - 1) # To normalize; ds in 2D
tangent_penalty = np.sum((dxx_interp - dxx0)**2 +
(dyy_interp - dyy0)**2) * ds**-2 / (N - 1)
return (points_penalty + tangent_penalty)
def edit_init_file(config_set):
base_output_dir = pathlib.Path('ic_special')
if not base_output_dir.exists():
print("No *.h5 files have been generated in {}".format(
str(base_output_dir)))
exit(-1)
output_dir = str(base_output_dir / config_set['name'])
# here we load the esp_initial.h5 and edit the thermodynamic properties
init_file = output_dir + '/esp_initial.h5'
if os.path.exists(init_file):
openh5 = h5py.File(init_file)
else:
print("Initial h5 file {} not found!".format(init_file))
exit(-1)
#--------vertical------------------------------
nv = np.int(config_set['vlevel'])
glev = np.int(config_set['glevel'])
point_num = 2 + 10 * 2**(2 * glev)
dh = np.float(config_set['Top_altitude']) / nv
final_height = np.arange(dh / 2, np.float(config_set['Top_altitude']), dh)
fvert = open(config_set['vertical_file'], 'r+')
vert_keys = fvert.readlines()[0].split()
fvert.close()
if not 'Height' in vert_keys:
print("Error! Vertical data file {} must include 'Height'".format(
config_set['vertical_file']))
exit(-1)
columns = np.loadtxt(config_set['vertical_file'], skiprows=1)
vert_struct = {}
for col in np.arange(len(vert_keys)):
vert_struct[vert_keys[col]] = columns[:, col]
vert_out = {}
for key in vert_struct.keys():
if key in openh5.keys():
vert_out[key] = interp.pchip_interpolate(vert_struct['Height'],
vert_struct[key],
final_height)
for i in np.arange(np.int(point_num)):
for key in vert_out.keys():
openh5[key][i * nv:i * nv + nv] = vert_out[key]
openh5.close()
def generate_kml_file(trajGen, trajectory, gps_trajectory, trajectory_name,
ith):
kml_traj = np.zeros((5, trajGen.nStages + 1))
if gps_trajectory.shape[0] == 5:
gpsMeter = GPSMeterConverter(gps_trajectory[1, 0],
gps_trajectory[0, 0], gps_trajectory[2,
0])
else:
gpsMeter = GPSMeterConverter(gps_trajectory[7, 0],
gps_trajectory[6, 0], gps_trajectory[8,
0])
[kml_traj[0, :], kml_traj[1, :], kml_traj[2, :]
] = gpsMeter.meter_to_gps(trajectory[trajGen.posStateIndices[0], :],
trajectory[trajGen.posStateIndices[1], :],
trajectory[trajGen.posStateIndices[2], :])
kml_traj[3, :] = np.rad2deg(trajectory[trajGen.yawStateIndex, :])
kml_traj[4, :] = np.rad2deg(trajectory[trajGen.pitchStateIndex, :])
# interpolate trajectory
time_step = 0.01
end_time = trajectory[trajGen.endTimeStateIndex, 0]
dt = end_time / trajGen.nStages
times_mpcc = np.arange(0, trajGen.nStages + 1) * dt
interp_mpcc = np.linspace(times_mpcc[0], times_mpcc[-1],
int(end_time / time_step))
longitude = pchip_interpolate(times_mpcc, kml_traj[0, :], interp_mpcc)
latitude = pchip_interpolate(times_mpcc, kml_traj[1, :], interp_mpcc)
altitude = pchip_interpolate(times_mpcc, kml_traj[2, :], interp_mpcc)
heading = pchip_interpolate(times_mpcc, kml_traj[3, :], interp_mpcc)
tilt = pchip_interpolate(times_mpcc, kml_traj[4, :], interp_mpcc)
# generate kml file
# filepath = './kmls/' + trajectory_name.replace('.h5', str(ith) + '.kml')
filepath = './kmls/' + 'test' + str(ith) + '.kml'
write_to_kml_file(filepath, time_step, longitude, latitude, altitude,
heading, tilt)
def reconstruct_angles(rr, num_segments):
'''
'''
from scipy.interpolate import pchip_interpolate
r0 = rr[0]
xx, yy, zz = rr.T
slist = calc_slist(xx, yy, zz)
slist_norm = sp.linspace(0, 1, num_segments + 1, endpoint=True)
# Interpolate to equal arc length spacing
xx_interp = pchip_interpolate(slist / slist[-1], xx, slist_norm)
yy_interp = pchip_interpolate(slist / slist[-1], yy, slist_norm)
zz_interp = pchip_interpolate(slist / slist[-1], zz, slist_norm)
thetas = []
psis = []
for dx, dy, dz in zip(sp.diff(xx_interp), sp.diff(yy_interp),
sp.diff(zz_interp)):
_, theta, psi = get_ds_angles(dx, dy, dz)
thetas.append(theta)
psis.append(psi)
ds = slist[-1] / num_segments
return r0, ds, thetas, psis
def cmfxyz(lam, e=None, **kwargs):
"""
Color matching function for xyz tristimulus
:param lam: wavelength 𝜆 [m]
:type lam: float or array_like
:param e: illlumination spectrum defined at the wavelengths 𝜆
:type e: numpy array (N,1)
:return: xyz-chromaticity
:rtype: numpy array, shape = (N,3)
The color matching function is the XYZ tristimulus required to match a
particular wavelength excitation.
``cmfxyz(𝜆)`` is the CIE XYZ color matching function (N,3) for illumination
at wavelength 𝜆 (N,1) [m]. If 𝜆 is a vector then each row of XYZ
is the color matching function of the corresponding element of 𝜆.
``cmfxzy(𝜆, e)`` is the CIE XYZ color matching (1,3) function for an
illumination spectrum e (N,1) defined at corresponding wavelengths 𝜆 (N,1).
Example:
.. runblock:: pycon
.. note::
- CIE 1931 2-deg XYZ CMFs from cvrl.ioo.ucl.ac.uk .
:references:
- Robotics, Vision & Control, Chapter 14.3, P. Corke, Springer 2011.
"""
lam = base.getvector(lam)
xyz = _loaddata('cmfxyz.dat', comments='%')
XYZ = interpolate.pchip_interpolate(xyz[:, 0],
xyz[:, 1:],
lam,
axis=0,
**kwargs)
if e is not None:
# approximate rectangular integration
dlam = lam[1] - lam[0]
XYZ = e.reshape((1, -1)) @ XYZ * dlam
return XYZ
def curveInterp(t, curve):
#zero rates
tempCurve = -numpy.log(curve[1])/curve[0]
tempCurve[0] = 0.0000
if t < 0:
return 1
elif t > 30:
f = numpy.exp(numpy.interp(t, curve[0], numpy.log(curve[1]), right = numpy.log(curve[1,9])*t/30))
return f
else:
f = interpolate.pchip_interpolate(curve[0], tempCurve, t)
tnew = numpy.exp(-f * t)
return tnew
def interimpulse_fit(driver, kernel, minima, maxima, original_time, original_signal, original_fs):
"""
Estimate the tonic EDA driver and signal. The mean (or median) of data between impulses is used to estimate the
tonic driver. This driver is then convolved with the kernel to produce the tonic signal.
Parameters
----------
driver : array_like
The composite EDA driver
kernel : array_like
The kernel impulse response
minima : numpy.ndarray
The minima in the composite EDA driver
maxima :
The maxima in the composite EDA driver
original_time : array_like
The timestamps of the original EDA signal
original_signal : array_like
The original EDA signal
original_fs : float
The sample rate of the original EDA signal
Returns
-------
tonic_driver : numpy.ndarray
The estimated tonic EDA driver
tonic_data : numpy.ndarray
The estimated tonic EDA signal
"""
# FIXME: Add tests
from scipy.interpolate import pchip_interpolate
from scipy.signal import convolve
tonic_driver = np.array([])
tonic_data = np.array([])
# Original timestamps (comes from leda2.analysis0.target.t)
original_time = original_time.copy()
# Original EDA signal (comes from leda2.analysis0.target.d)
original_signal = original_signal.copy()
# Original sample rate (comes from leda2.analysis0.target.sr)
original_fs = original_fs
# Hard coded value came from observing first run during continuous analysis (comes from
# leda2.set.tonicGridSize_sdeco)
grid_spacing = 10
# Number of samples in the kernel
kernel_length = kernel.size
# Get inter-impulse data index
interimpulse_indices = np.array([], dtype='int64')
# If there are more than two maximum indices in maxima
if maxima.size > 2:
# Iterate from the first to the penultimate
for i in range(maxima.size - 1):
# Indices of samples between following minimum and next minimum. These indices are the indices of the gaps
# between impulses.
current_interimpulse_indices = np.arange(minima[i, 1], minima[i + 1, 0] + 1)
# Append these indices to interimpulse_indices
interimpulse_indices = np.concatenate([interimpulse_indices, current_interimpulse_indices])
# Add the index of the first minimum for the second maximum to the beginning of interimpulse_indices. Add the index of the second minimum for the last maximum, plus all remaining samples except for the last second of data, to the end of interimpulse_indices.
interimpulse_indices = np.concatenate([[minima[1, 0]], interimpulse_indices, np.arange(minima[-1, 1], driver.size - original_fs + 1)])
# There weren'original_time any maxima (except for first and last 'global' maxima), so
# the entire driver is tonic. Set interimpulse_indices to be all those indices where the
# timestamp is greater than zero.
else: #no peaks (exept for pre-peak and may last peak) so data represents tonic only, so ise all data for tonic estimation
interimpulse_indices = np.nonzero(original_time > 0)[0]
interimpulse_indices = np.int64(interimpulse_indices)
# interimpulse_times are the timestamps corresponding to the interimpulse_indices indices.
interimpulse_times = original_time[interimpulse_indices]
# interimpulse_data is the driver corresponding to the interimpulse_indices indices.
interimpulse_data = driver[interimpulse_indices]
# I don'original_time know what the significance of the name grid_time is, but
# grid_time is a vector from 0 to the penultimate timestamp with a step size
# of grid_spacing, and the last timestamp added to the end.
grid_time = np.arange(0, original_time[-2], grid_spacing)
grid_time = np.concatenate([grid_time, [original_time[-1]]])
### I don'original_time know why they do this...
if grid_spacing < 30:
grid_spacing = grid_spacing * 2
# Initialize vector of ground levels
tonic_level = np.zeros(grid_time.size)
# Iterate over length of grid_time vector
for i in range(0, grid_time.size):
# Select relevant interimpulse time points for tonic estimate at
# grid_time
# If i represents the first grid_time entry
if i == 0:
# time_indices is all inter-impulse timestamp indices that are less than or equal
# to the first grid_time entry plus the grid size, and greater
# than one.
time_indices = np.nonzero((interimpulse_times <= (grid_time[i] + grid_spacing)) & (interimpulse_times > 1.0))[0]
# grid_indices is the same except using all timestamps.
grid_indices = np.nonzero((original_time <= (grid_time[i] + grid_spacing)) & (original_time > 1.0))[0]
# If i represents the last grid_time entry
elif i == grid_time.size - 1:
# time_indices is all inter-impulse timestamp indices that are after the last
# grid_time entry minus the grid size, and less than the last
# overall timestamp minus one second.
time_indices = np.nonzero((interimpulse_times > (grid_time[i] - grid_spacing)) & (interimpulse_times < (original_time[-1] - 1.0)))[0]
# grid_indices is the same except using all timestamps.
grid_indices = np.nonzero((original_time > (grid_time[i] - grid_spacing)) & (original_time < (original_time[-1] - 1.0)))[0]
else:
# time_indices is all inter-impulse timestamp indices that are a half a grid size
# before and after grid_time(i)
# TODO: The spacing calculated here is different from Ledalab. Confirm that this is a bug in Ledalab.
time_indices = np.nonzero((interimpulse_times > (grid_time[i] - grid_spacing/2)) & (interimpulse_times <= (grid_time[i] + grid_spacing/2)))[0]
# grid_indices is the same except using all timestamps.
grid_indices = np.nonzero((original_time > (grid_time[i] - grid_spacing/2)) & (original_time <= (grid_time[i] + grid_spacing/2)))[0]
# Estimate tonic_level at grid_time
# If there are more than two inter-impulse timestamps in this grid
# window
if time_indices.size > 2:
# Take the ground level as the minimum of the mean of inter-impulse
# data over the window, or the original signal at the nearest
# possible time index.
closest_index, closest_time = Pypsy.signal.utilities.closest_time_index(original_time, grid_time[i])
tonic_level[i] = np.min(np.array([np.mean(interimpulse_data[time_indices]), original_signal[closest_index]]))
# If there are two or fewer inter-impulse timestamps in this grid
# window
else:
# Take the ground level as the minimum of the median of
# inter-impulse data over the window, or the original signal at the
# nearest possible time index.
closest_index, closest_time = Pypsy.signal.utilities.closest_time_index(original_time, grid_time[i])
tonic_level[i] = np.min([np.median(driver[grid_indices]), original_signal[closest_index]])
# tonic_driver is the tonic_level signal PCHIP interpolated across the
# original timestamps
tonic_driver = pchip_interpolate(grid_time, tonic_level, original_time)
# Stash currently-computed data
grid_time_stored = grid_time
tonic_level_stored = tonic_level
tonic_driver_stored = tonic_driver
# Prepend tonic_driver with a kernel-length of the initial value and
# convolve it with the kernel.
tonic_driver_extended = np.concatenate([np.ones(kernel_length) * tonic_driver[0], tonic_driver])
tonic_data = convolve(tonic_driver_extended, kernel)
# Trim kernel length from beginning and end of convolved signal
tonic_data = tonic_data[kernel_length:tonic_data.size - kernel_length + 1]
# Stash data
tonic_data_stored = tonic_data
# Correction for tonic sections still higher than raw data
# Move closest grid_time at time of maximum difference of tonic surpassing data
# Iterate i from length(grid_time) - 1 down to 0
for i in range(grid_time.size - 2, 0, -1):
# Get subrange of original timestamps that are closest to our
# grid_time timestamps
time_indices = Pypsy.signal.utilities.subrange_indices(original_time, grid_time[i], grid_time[i+1])
# Find the max in the tonic data convolved with the kernel plus a
# minimum allowable distance (defaults to 0) minus the original signal
minimum_difference = 0
eps = np.finfo(float).eps
difference = (tonic_data[time_indices] + minimum_difference) - original_signal[time_indices]
maximum_difference = np.max(difference)
# If this max is greater than the distance from 1.0 to the next larget
# double-precision number (2.2204e-16)
if maximum_difference > eps:
index = np.nonzero(difference == maximum_difference)[0]
# Subtract this max from this tonic_level and the next
tonic_level[i] = tonic_level[i] - maximum_difference
tonic_level[i+1] = tonic_level[i+1] - maximum_difference
# Interpolate tonic_driver and convolve again
tonic_driver = pchip_interpolate(grid_time, tonic_level, original_time)
tonic_driver_extended = np.concatenate([np.ones(kernel_length) * tonic_driver[0], tonic_driver])
tonic_data = convolve(tonic_driver_extended, kernel)
# Trim kernel length from beginning and end of convolved signal
tonic_data = tonic_data[kernel_length:tonic_data.size - kernel_length + 1]
# FIXME: The actual Ledalab function saves all this analysis (and the piecewise polynomial) back to globals
return tonic_driver, tonic_data
def FittedTransmission (voltages, offset, amplitude, *params) : """ Return the transmission function for a shaper """ V, M = GetVM(*params) return amplitude*np.cos( pchip_interpolate(V,M,voltages) )**2 + offset
def GetDispersionPhaseCurves (self, wavelengths, scans, voltages, pixels_edges,
calibration, pixel2lambda_func, pulse_shaper_pixel_num ) :
"""
Surface calibration:
Find dispersion and phase curves based on a result of the method `self.FitSpectralScans`
`calibration` is the return of `self.FitSpectralScans`
"""
import operator
# Find the calibration function that was best fitted
best_calibation_voltage, best_calib_phase, _ = min(calibration, key=operator.itemgetter(2))
# Form a function representing calibration curve (best fitted)
# Normalizing calibration curve
best_calib_phase -= best_calib_phase.min()
best_calib_phase /= best_calib_phase.max()
best_calibration_curve = PchipInterpolator (best_calibation_voltage, best_calib_phase)
# Selecting the voltage range
V_min = max( best_calibation_voltage.min(), voltages.min() )
V_max = min( best_calibation_voltage.max(), voltages.max() )
V_indx = np.nonzero( (V_min <= voltages)&(voltages <= V_max) )
# Select scanning range that corresponds to a valid region of voltages and wavelength
scans = scans[V_indx[0], pixels_edges[0]:pixels_edges[-1]]
# Wavelength position of pixels in a new sliced scan
wavelengths_cut = wavelengths[ pixels_edges[0]:pixels_edges[-1] ]
# Central wavelength of each pixels
logical_pixel_lambda = 0.5*( wavelengths[pixels_edges[1:]] + wavelengths[pixels_edges[:-1]] )
# Construct the initial guess for the dispersion curve
# use the cubic polynomial interpolation
# normalize it to the best fitted calibration curve
best_min = best_calibration_curve(V_min)
best_max = best_calibration_curve(V_max)
# values of the calibration curves
calibration_values = best_calibration_curve( voltages[V_indx] )[:,np.newaxis]
def TransmissionC (calibration_values, params) :
"""
Transmission coefficient for fitting
"""
offset = params[:len(params)/2]
multiplier = params[len(params)/2:]
phase = calibration_values * np.polyval(multiplier, wavelengths_cut)
phase += np.polyval(offset, wavelengths_cut)
return np.cos( phase )**2
def Fit_TransmissionC (calibration_values, *params) :
return np.ravel( TransmissionC(calibration_values, params) )
# Initial guess for fitting parameters
c_min, c_max = zip(*[ pchip_interpolate(c[0],c[1],[V_min, V_max]) for c in calibration ])
c_min = np.array(c_min); c_max = np.array(c_max)
# Use different power fits
power_fits = []
for power in [1, 3, 5, 7] :
offset = np.polyfit(logical_pixel_lambda, (best_max*c_min-best_min*c_max)/(best_max-best_min), power)
multiplier = np.polyfit(logical_pixel_lambda, (c_max-c_min)/(best_max-best_min), power)
p0=np.append(offset, multiplier)
try :
popt, _ = curve_fit(Fit_TransmissionC, calibration_values, np.ravel(scans), p0=p0)
except RuntimeError : popt = p0
# Calculate the Transmission coefficients for plotting
TC_fitted = TransmissionC(calibration_values, popt)
# Calculate fitting error
error = np.sum( (TC_fitted - scans)**2 )
power_fits.append( (error, popt, TC_fitted) )
# Select the best power fit
_, popt, TC_fitted = min(power_fits)
# Extracted the fitted parameters
offset = popt[:len(popt)/2]
multiplier = popt[len(popt)/2:]
# Get wavelength for each physical pixel in the pulse shaper
physical_pixel_lambda = pixel2lambda_func(np.arange(pulse_shaper_pixel_num))
# Calculate offset and multiplier for each physical pixel
offset = np.polyval(offset, physical_pixel_lambda)
multiplier = np.polyval(multiplier, physical_pixel_lambda)
# Return results
return TC_fitted, scans, { "offset" : offset,
"multiplier" : multiplier,
"calibration_curve_voltage" : best_calibation_voltage,
"calibration_curve_phase" : best_calib_phase }
corr_centered_flow = []
for i in range(len(centered_flow)):
for j in range(len(cal_error)):
if round(centered_flow[i], 1) == round(cal_inflow[j], 1):
corr = cal_error[j]
break
else:
corr = 0.0
corr_centered_flow.append(centered_flow[i]*(1.0 + corr/100))
interpolate_corr_flow = interp1d(centered_times, corr_centered_flow,kind='cubic')
interpolate_flow = interp1d(centered_times, centered_flow,kind='cubic')
das_t_interpolation = np.array(das_t)[(np.array(das_t) > centered_times[0]) & (np.array(das_t)<centered_times[-1])]
interpolated_flow = interpolate_flow(das_t_interpolation)
interpolated_corr_flow = interpolate_corr_flow(das_t_interpolation)
pchip_interpolated_flow = pchip_interpolate(centered_times, corr_centered_flow,das_t_interpolation)
import matplotlib
matplotlib.rcParams.update({'font.size':15})
corr_fig = plt.figure('Poster')
# Siphon
tk_ax3 = corr_fig.add_subplot(3, 1, 1)
tk_ax3.plot(t, sg_h, '-b')
tk_ax3.set_ylabel('level in \nsiphon gauge [mm]')
tk_ax3.set_axis_bgcolor('0.95')
tk_ax3.grid(True)
# DAS frequencies
das_ax2 = corr_fig.add_subplot(3, 1, 2, sharex=tk_ax3)
das_ax2.plot(das_t, das_frequencies, '-r')
das_ax2.set_ylabel('DAS Frequencies [Hz]')
das_ax2.set_axis_bgcolor('0.95')
das_ax2.grid(True)
def obtener_rcsda(energiaMeV,medio):
from record import record
class Material(record):
matname = ""
densidad = 0 # densidad escrita en g/cm**3
material1 = Material(matname = "Liquid water", densidad = 1.0)
material2 = Material(matname = "Air dry", densidad = 1.20479E-03)
material3 = Material(matname = "Compact bone", densidad = 1.85000E+00)
material4 = Material(matname = "Lung", densidad = 1.05000E+00)
material5 = Material(matname = "Soft tissue", densidad = 1.00000E+00)
tissue = []
if medio == 1:
tissue = material1.matname
elif medio == 2:
tissue = material2.matname
elif medio == 3:
tissue = material3.matname
elif medio == 4:
tissue = material4.matname
elif medio == 5:
tissue = material5.matname
else:
print "Please choose an allowed value for selecting medium."
sys.exit()
# esta funcion necesita la energia en unidades de MeV y el codigo del medio (i.e. agua = 1)
if medio == 1:
energias = open("Rcsda_tables/tabla_electrones_Rcsda_agua", "r")
elif medio == 2:
energias = open("Rcsda_tables/tabla_electrones_Rcsda_Air_Dry","r")
elif medio == 3:
energias = open("Rcsda_tables/tabla_electrones_Rcsda_Compact_Bone","r")
elif medio == 4:
energias = open("Rcsda_tables/tabla_electrones_Rcsda_Lung","r")
elif medio == 5:
energias = open("Rcsda_tables/tabla_electrones_Rcsda_Soft_Tissue","r")
else:
print "Please choose an allowed medium"
linea = energias.readline()
n = 0
xi = [] #energies
yi = [] #ranges in g/cm**3
while linea != "":
linea = linea.strip()
n += 1
if n <= 6:
linea = energias.readline()
else:
lista = linea.split()
xi.append(float(lista[0]))
if medio == 1:
yi.append(float(lista[1])/material1.densidad)
elif medio == 2:
yi.append(float(lista[1])/material2.densidad)
elif medio == 3:
yi.append(float(lista[1])/material3.densidad)
elif medio == 4:
yi.append(float(lista[1])/material4.densidad)
elif medio == 5:
yi.append(float(lista[1])/material5.densidad)
else:
print "There is no material with this code"
linea = energias.readline()
energias.close()
from scipy.interpolate import pchip_interpolate
rcsda = float(pchip_interpolate(xi, yi, energiaMeV))
return (rcsda, tissue)
def FitSpectralScans (self, scans, voltages, pixels_edges) :
"""
Perform fitting to the pulse shaper's mask transmission coefficient
"""
def FitIndividualPixel (voltages, pixel, modulation, p0=None) :
"""
Find fit for individual pixel with initial guess for phase function given by `modulation`.
`voltages` voltage values for which `pixel` was measured
`pixel` measured transmission (to be fitted)
`p0` is the initial guess for fitting parametres
"""
def GetVM (V0, V1, m0, m1) :
"""
Return voltage and phase modulation from parameters
"""
M = m0 + m1*modulation
V = np.linspace(V0, V1, M.size)
return V, M
def FittedTransmission (voltages, offset, amplitude, *params) :
"""
Return the transmission function for a shaper
"""
V, M = GetVM(*params)
return amplitude*np.cos( pchip_interpolate(V,M,voltages) )**2 + offset
# Set fitting parameters to their default values
if p0 is None : p0 = [0., 1., voltages.min(), voltages.max(), 0., 1.]
# Fitting the transmission
try : popt, _ = curve_fit(FittedTransmission, voltages, pixel, p0=p0)
except RuntimeError : popt = p0
# Get fitting error
fitting_error = np.sum( ( FittedTransmission(voltages, *popt) - pixel )**2 )
return fitting_error, GetVM(*popt[2:]), popt
############################################################################
# Selecting the voltage range
V_min = max( voltages_trial.min(), voltages.min() )
V_max = min( voltages_trial.max(), voltages.max() )
indx = np.nonzero( (V_min <= voltages)&(voltages <= V_max) )
# Number of calibration points lying within the voltage region
num_vol_trial = np.sum( (V_min <= voltages_trial)&(voltages_trial <= V_max) )
if num_vol_trial < 2 : num_vol_trial = 2
# Re-sample modulation provided by CRi so that the voltage is equidistantly spaced
resampled_vis_modulation = pchip_interpolate(voltages_trial, vis_modulation,
np.linspace(V_min, V_max, min(len(voltages), num_vol_trial) )
)
resampled_nir_modulation = pchip_interpolate(voltages_trial, nir_modulation,
np.linspace(V_min, V_max, min(len(voltages), num_vol_trial) )
)
# Normalizing scans
scans -= scans.min(axis=0); scans /= scans.max(axis=0)
# Bin the spectrum into pixels
spectral_slices = map( lambda begin,end : scans[:,begin:end].mean(axis=1), pixels_edges[:-1], pixels_edges[1:] )
# List containing calibration data for each pixel
calibration = []
# Initial guesses for fitting
vis_p0 = None; nir_p0 = None;
# Fit individual pulse shaper pixels them
for pixel_num, pixel in enumerate(spectral_slices) :
# Smoothing and normalizing each pixel
#pixel = gaussian_filter(pixel,sigma=1)
pixel -= pixel.min(); pixel /= pixel.max()
# Fit the pixel by using the vis calibration curve as the initial guess
vis_err, vis_calibration, vis_p0 = FitIndividualPixel(voltages[indx], pixel[indx],
resampled_vis_modulation, vis_p0)
# Fit the pixel by using the nir calibration curve as the initial guess
nir_err, nir_calibration, nir_p0 = FitIndividualPixel(voltages[indx], pixel[indx],
resampled_nir_modulation, nir_p0)
# Choose the best fit
if nir_err > vis_err :
calibation_voltage, calibration_phase = vis_calibration
fit_err = vis_err
else :
calibation_voltage, calibration_phase = nir_calibration
fit_err = nir_err
###################### Plot ########################
visvis.clf()
# Plot measured data
visvis.plot( voltages, pixel, lc='r',ms='*', mc='r')
# Plot fitted data
plot_voltages = np.linspace( calibation_voltage.min(), calibation_voltage.max(), 500)
transmission_fit = np.cos( pchip_interpolate(calibation_voltage, calibration_phase, plot_voltages) )**2
visvis.plot( plot_voltages, transmission_fit, lc='b')
visvis.title ('Calibrating pixel %d / %d' % (pixel_num, len(spectral_slices)-1) )
visvis.legend(['measured', 'fitted'])
visvis.xlabel ('voltages')
visvis.ylabel ('Transmission coefficient')
self.fig.DrawNow()
############ Save the calibration data ##################
calibration.append( ( calibation_voltage, calibration_phase, fit_err ) )
return calibration
