def getCurvatureForPoints(arcLengthList, fx_s, fy_s, smoothing=None): x, x_, x__, y, y_, y__ = getFirstAndSecondDerivForTPoints(arcLengthList, fx_s, fy_s) curvature = abs(x_* y__ - y_* x__) / np.power(x_** 2 + y_** 2, 3 / 2) fCurvature = UnivariateSpline(arcLengthList, curvature, s=smoothing) dxcurvature = fCurvature.derivative(1)(arcLengthList) dx2curvature = fCurvature.derivative(2)(arcLengthList) return curvature, dxcurvature, dx2curvature
def curvature_spline(self, x, y, error=0.1): """ Calculate the signed curvature of a 2D curve at each point using interpolating splines. Parameters ---------- x, y : numpy.array(dtype = float) shape (n_points, ) error : float - The admisible error when interpolating the splines Returns ------- curvature: numpy.array shape (n_points, ) """ # create range for array length t = np.arange(x.shape[0]) std = error * np.ones_like(x) fx = UnivariateSpline(t, x, k=4, w=1 / np.sqrt(std)) fy = UnivariateSpline(t, y, k=4, w=1 / np.sqrt(std)) xl = fx.derivative(1)(t) xl2 = fx.derivative(2)(t) yl = fy.derivative(1)(t) yl2 = fy.derivative(2)(t) curvature = (xl * yl2 - yl * xl2) / np.power(xl**2 + yl**2, 3 / 2) return curvature
def main(dt): global X_ref, Y_ref, psi_ref, vx_ref, vy_ref, Waypoints_received, stateEstimate_mark rospy.init_node('waypoints_interface', anonymous=True) rospy.Subscriber('waypoints', Waypoints, WaypointsCallback) rospy.Subscriber('state_estimate', state_Dynamic, stateEstimateCallback) pub = rospy.Publisher('final_trajectory', Trajectory2D, queue_size=1) rate = rospy.Rate(1 / dt) while (rospy.is_shutdown() != 1): if stateEstimate_mark and Waypoints_mark: num_steps_received = len(Waypoints_received.points) - 1 dt_received = Waypoints_received.dt horizon = dt_received * num_steps_received points = np.zeros((2, num_steps_received + 2)) points[0, 0] -= vx_ref * dt_received #points[1, 0] -= vy_ref * dt_received for i in range(num_steps_received): points[0, i + 2] = Waypoints_received.points[i].x points[1, i + 2] = Waypoints_received.points[i].y t_received = np.linspace(-dt_received, horizon, num_steps_received + 2) num_points = int(floor(horizon / dt + 1)) + 40 t = np.linspace(0, (num_points - 1) * dt, num_points) w = np.ones(num_steps_received + 2) w[0:2] *= 10 w[-1] *= 5 spl_x = UnivariateSpline(t_received, points[0, :], k=3, w=w) spl_y = UnivariateSpline(t_received, points[1, :], k=3, w=w) spl_x_dot = spl_x.derivative() spl_y_dot = spl_y.derivative() spl_x_val = spl_x(t) spl_y_val = spl_y(t) spl_x_dot_val = spl_x_dot(t) spl_y_dot_val = spl_y_dot(t) spl_v_val = np.sqrt(spl_x_dot_val**2 + spl_y_dot_val**2) spl_theta_val = np.arctan2(spl_y_dot_val, spl_x_dot_val) spl_theta_val[0] = 0 w_theta = np.ones(spl_theta_val.shape[0]) w_theta[0] = w_theta[0] * 10 spl_theta_fn = UnivariateSpline(t, spl_theta_val, k=3, w=w_theta) spl_theta_val = spl_theta_fn(t) spl_yr_fn = spl_theta_fn.derivative() spl_yr_val = spl_yr_fn(t) traj = Trajectory2D() for i in range(num_points): pt = TrajectoryPoint2D() pt.t = t[i] pt.x = spl_x_val[i] * cos(psi_ref) - spl_y_val[i] * sin( psi_ref) + X_ref pt.y = spl_x_val[i] * sin(psi_ref) + spl_y_val[i] * cos( psi_ref) + Y_ref pt.theta = spl_theta_val[i] + psi_ref pt.v = spl_v_val[i] pt.kappa = spl_yr_val[i] traj.point.append(pt) traj.header = Header() traj.header.stamp = rospy.get_rostime() pub.publish(traj) rate.sleep()
def expand_1d_static_fieldmap(z0, fz0): """ Expands 1D static fieldmap z, fz into r, z using splines. Cylindrically symmetric geometry. This is valid for both electric and magnetic fields. Returns functions: fr(r, z), fz(r, z) """ # Make spline and derivatives S = UnivariateSpline(z0, fz0, k=5, s=0) Sp = S.derivative() Sp2 = S.derivative(2) Sp3 = S.derivative(3) def fz(r, z): return S(z) - r**2 * Sp2(z) / 4 def fr(r, z): return -r * Sp(z) / 2 + r**3 * Sp3(z) / 16 return fr, fz
class AlphaInterpolator(object): def __init__(self, a, x, y): # Drop NaN values to avoid fitpack errors self._data = pd.DataFrame(np.array([a, x, y]).T, columns=["a", "x", "y"]) self._data.dropna(inplace=True) self._create_interpolating_polynomials() self._find_path_length() def _create_interpolating_polynomials(self): self.x_interp = UnivariateSpline(self._data.a, self._data.x, s=0) self.y_interp = UnivariateSpline(self._data.a, self._data.y, s=0) def _find_path_length(self): dx_interp = self.x_interp.derivative() dy_interp = self.y_interp.derivative() ts = np.linspace(0, 1, 200) line_length = cumtrapz(np.sqrt(dx_interp(ts) ** 2 + dy_interp(ts) ** 2), x=ts, initial=0.0) line_length /= line_length.max() # Here we invert the line_length (ts) function, in order to evenly # sample the pareto front self.l_interp = UnivariateSpline(line_length, ts, s=0) def sample(self, num): """ Return estimates of alpha values that evenly sample the pareto front """ out = self.l_interp(np.linspace(0, 1, num)) out[0] = 0.0 out[-1] = 1.0 return out
def smoothing(x,y,err=None,k=5,s=None,newx=None,derivative_order=0): # remove NaNs idx = np.isfinite(x) & np.isfinite(y) if idx.sum() != len(x): x=x[idx]; y=y[idx] # if we don't need to interpolate, use same x as input if newx is None: newx=x if err is None: w=None elif err == "auto": n=len(x) imin = int(max(0,n/2-20)) imax = imin + 20 idx = range(imin,imax) p = np.polyfit(x[idx],y[idx],2) e = np.std( y[idx] - np.polyval(p,x[idx] ) ) w = np.ones_like(x)/e else: w=np.ones_like(x)/err from scipy.interpolate import UnivariateSpline if (s is not None): s = len(x)*s s = UnivariateSpline(x, y,w=w, k=k,s=s) if (derivative_order==0): return s(newx) else: try: len(derivative_order) return np.asarray([s.derivative(d)(newx) for d in derivative_order]) except: return s.derivative(derivative_order)(newx)
def smoothing(x,y,err=None,k=5,s=None,newx=None,derivative_order=0): idx = np.isnan(x)|np.isnan(y) idx = ~ idx if newx is None: newx=x if idx.sum() > 0: x=x[idx] y=y[idx] if idx.sum() < 3: return np.ones(len(newx)) if err is None: w=None elif err == "auto": n=len(x) imin = max(0,n/2-20) imax = min(n,n/2+20) idx = range(imin,imax) p = np.polyfit(x[idx],y[idx],4) e = np.std( y[idx] - np.polyval(p,x[idx] ) ) w = np.ones_like(x)/e else: w=np.ones_like(x)/err from scipy.interpolate import UnivariateSpline if (s is not None): s = len(x)*s s = UnivariateSpline(x, y,w=w, k=k,s=s) if (derivative_order==0): return s(newx) else: try: len(derivative_order) return [s.derivative(d)(newx) for d in derivative_order] except: return s.derivative(derivative_order)(newx)
def calculate_rates(galaxy, **kwargs): print "calculating rates...." print """****calculate_rates assumes that galaxy masses are in Msun. ****actual units are: galaxy['Ms'].unit = """ + str(galaxy['Ms'].unit) + """ and galaxy['Mg'].unit = """ + str(galaxy['Mg'].unit) Nspline = kwargs.get("Nspline",10) given_age = galaxy['age'].to(u.yr).value indices = np.append(np.arange(0,len(galaxy),len(galaxy)/(Nspline-1)), len(galaxy)-1) short_age = given_age[indices] assert ("Mg" in galaxy.colnames), "galaxy column 'Mg' not found, galaxy lacks gas :-(" print galaxy['Mg'][indices].value dMg = UnivariateSpline(short_age,galaxy['Mg'][indices].value,k=3) dMgdt_func = dMg.derivative(n=1) dMgdt = dMgdt_func(given_age) * u.Msun / u.yr col_dMgdt = Column(data=dMgdt,name='dMgdt') galaxy.add_column(col_dMgdt) if "Mhi" in galaxy.colnames: dMhi = UnivariateSpline(short_age,galaxy['Mhi'][indices].value,k=3) dMhidt_func = dMhi.derivative(n=1) dMhidt = dMhidt_func(given_age) * u.Msun / u.yr col_dMhidt = Column(data=dMhidt,name='dMhidt') galaxy.add_column(col_dMhidt) if "Mh2" in galaxy.colnames: dMh2 = UnivariateSpline(short_age,galaxy['Mh2'][indices].value,k=3) dMh2dt_func = dMh2.derivative(n=1) dMh2dt = dMh2dt_func(given_age) * u.Msun / u.yr col_dMh2dt = Column(data=dMh2dt,name='dMh2dt') galaxy.add_column(col_dMh2dt) assert ("Ms" in galaxy.colnames), "galaxy column 'Ms' not found, galaxy that lacks stars is not a galaxy :-(" dMs = UnivariateSpline(short_age,galaxy['Ms'][indices].value,k=3) dMsdt_func = dMs.derivative(n=1) dMsdt = dMsdt_func(given_age) * u.Msun / u.yr col_dMsdt = Column(data=dMsdt,name='dMsdt') galaxy.add_column(col_dMsdt) if "Mh" in galaxy.colnames and "dMhdt" not in galaxy.colnames: dMh = UnivariateSpline(short_age,galaxy['Mh'][indices].value,k=3) dMhdt_func = dMh.derivative(n=1) dMhdt = dMhdt_func(given_age) * u.Msun / u.yr col_dMhdt = Column(data=dMhdt,name='dMhdt') galaxy.add_column(col_dMhdt) if "dMhdt" in galaxy.colnames: galaxy['dMcgmdt'] = galaxy['dMhdt'] - galaxy['dMsdt'] - galaxy['dMgdt'] if "dt" not in galaxy.colnames: dt = np.zeros(len(galaxy))*u.yr for i in range(len(galaxy)): dt[i] = calculate_timestep(galaxy['age'].to(u.yr),i,len(galaxy)) col_dt = Column(data=dt, name='dt') galaxy.add_column(col_dt) return galaxy
def get_velocity_and_acceleration(scalars): """ https://stackoverflow.com/questions/40226357/second-derivative-in-python-scipy-numpy-pandas """ x = np.linspace(0, len(scalars), len(scalars)) ys = np.array(scalars, dtype=np.float32) y_spl = UnivariateSpline(x, ys, s=0, k=4) velocity = y_spl.derivative(n=1) acceleration = y_spl.derivative(n=2) return velocity(x), acceleration(x)
def main(dt, horizon): global vx, vy, X, Y, psi, wz, d_f,stateEstimate_mark # import track file track = Tra('Tra_1', horizon) rospy.init_node('toy_planner', anonymous=True) rospy.Subscriber('state_estimate', state_Dynamic, stateEstimateCallback) pub = rospy.Publisher('final_trajectory', Trajectory2D, queue_size=1) rate = rospy.Rate(1/dt) # first set the horizon to be very large to get where the vehicle is track.horizon = horizon track.currentIndex = 0 num_points = 400 w = np.ones(num_points) * 0.1 w[0] = w[0] * 30 w[-1] = w[-1] * 30 while (rospy.is_shutdown() != 1): if stateEstimate_mark == True: track.currentIndex, _ = track.searchClosestPt(X, Y, track.currentIndex) if track.currentIndex + num_points < track.size: index_list = np.arange(track.currentIndex, track.currentIndex+num_points, 1) t = track.t[track.currentIndex:track.currentIndex+num_points] t_sub = track.t[index_list] x_sub = track.x[index_list] #- 0.16 y_sub = track.y[index_list] #+ 0.44 spl_x = UnivariateSpline(t_sub, x_sub, k=2) spl_y = UnivariateSpline(t_sub, y_sub, k=2) spl_x_dot = spl_x.derivative() spl_y_dot = spl_y.derivative() spl_x_val = spl_x(t) spl_y_val = spl_y(t) spl_x_dot_val = spl_x_dot(t) spl_y_dot_val = spl_y_dot(t) spl_v_val = np.sqrt(spl_x_dot_val**2 + spl_y_dot_val**2) spl_theta_val = np.arctan2(spl_y_dot_val, spl_x_dot_val) spl_yr_fn = UnivariateSpline(t, spl_theta_val, k=2).derivative() spl_yr_val = spl_yr_fn(t) traj = Trajectory2D() for i in range(num_points): pt = TrajectoryPoint2D() pt.t = t[i] pt.x = spl_x_val[i] pt.y = spl_y_val[i] pt.theta = spl_theta_val[i] pt.v = spl_v_val[i] pt.kappa = spl_yr_val[i] traj.point.append(pt) traj.header = Header() traj.header.stamp = rospy.get_rostime() pub.publish(traj) rate.sleep()
def phase_corr(self, p, MfRD, freq, aligned_phase): #NOTE: The sign of the phase used here is opposite of that in lal but they both follow the same convention from scipy.interpolate import UnivariateSpline dphi = UnivariateSpline(freq, aligned_phase, k=3, s=0) self.dphilist = dphi.derivative(1)(freq) f_final = MftoHz(MfRD, p['Mtot']) # Time correction is t(f_final) = 1/(2pi) dphi/df (f_final) t_corr = dphi.derivative(1)(f_final) / (2. * Constants.LAL_PI) logger.info("t_corr = {0}".format(t_corr)) return t_corr
def curvature(func, x, ftype='polynomial', order=4): r""" Measure the curvature of a function. Parameters ---------- func: coefcients, spline or function The function for deriving the curvature. F(x) x: The x axis for the F(x) function. ftype: string 'polynomial': func is the polynomial coefcients arrays 'spline': func is a scipy.UnivariateSpline object 'analytical': a self defined function order: int (optional) The order for fitting the analytical function. Only used if ftype='analytical' Returns ------- The curvature array """ if ftype == 'polynomial': # getting polynomial derivatives func_ = np.polyder(func) func_2 = np.polyder(func, m=2) # building arrays with derived polynomial y_ = np.polyval(func_, x) y_2 = np.polyval(func_2, x) if ftype == 'analytical': # fitting analytical function with a spline spl = UnivariateSpline(x, func(x), k=order) ftype = 'spline' if ftype == 'spline': # deriving function func_ = spl.derivative() func_2 = spl.derivative(n=2) y_ = func_(x) y_2 = func_2(x) # normalizing vectors according to the first derivative y_norm = np.median(y_) y_ = y_/y_norm y_2 = y_2/y_norm # building terms of the curvature aux = np.power((np.power(y_, 2) + 1), 1.5) aux2 = y_2 # calculating curvature and radius of curvature r = aux/aux2 k = 1/r return k
def _build_energy_curve(self): x, y = bezier(self.control_polygon.points).T t = np.linspace(0, 1, num=200) bezier_spline_x = UnivariateSpline(t, x, k=5) bezier_spline_y = UnivariateSpline(t, y, k=5) dxdt = bezier_spline_x.derivative(n=self.control_polygon.degree)(t) dydt = bezier_spline_y.derivative(n=self.control_polygon.degree)(t) norm = dxdt * dxdt + dydt * dydt norm_spline = UnivariateSpline(t, norm, k=5) energy = norm_spline.integral(0, 1) return x, y, norm, energy
class VelocityComponents: def __init__(self, s, U, C, D, spline=False, smoothing=1.0): # Store the data self.s = s self.U = U self.C = C self.D = D self.ds = abs(s[1] - s[0]) # Check if using a spline representation for C and D components self.spline = spline if spline: self._cspline = UnivariateSpline(self.s, self.C, k=5, s=smoothing) self._dspline = UnivariateSpline(self.s, self.D, k=5, s=smoothing) @property def Vk(self): """ Kinematic wave speed. """ return self.C - self.Dp @property def Cp(self): """ The spatial derivative of C component. """ if self.spline: return self._cspline.derivative(n=1)(self.s) else: return np.gradient(self.C, self.ds, edge_order=2) @Cp.setter def Cp(self, value): raise ValueError('Cannot set Cp explicitly') @property def Dp(self): """ The spatial derivative of D component. """ if self.spline: return self._dspline.derivative(n=1)(self.s) else: return np.gradient(self.D, self.ds, edge_order=2) @Dp.setter def Dp(self, value): raise ValueError('Cannot set Dp explicitly')
def get_vertical_acceleration(skeleton, frames, joint_name): """ https://stackoverflow.com/questions/40226357/second-derivative-in-python-scipy-numpy-pandas """ ps = [] for frame in frames: p = skeleton.nodes[joint_name].get_global_position(frame) ps.append(p) ps = np.array(ps) x = np.linspace(0, len(frames), len(frames)) ys = np.array(ps[:, 1]) y_spl = UnivariateSpline(x, ys, s=0, k=4) velocity = y_spl.derivative(n=1) acceleration = y_spl.derivative(n=2) return ps, velocity(x), acceleration(x)
def curvature_spline(x, y): """ this function gets the curvature of the road. """ t = numpy.arange(x.shape[0]) fx = UnivariateSpline(t, x, k=4) fy = UnivariateSpline(t, y, k=4) xDer = fx.derivative(1)(t) xDerDer = fx.derivative(2)(t) yDer = fy.derivative(1)(t) yDerDer = fy.derivative(2)(t) curvature = (xDer * yDerDer - yDer * xDerDer) / numpy.power(xDer ** 2 + yDer ** 2, 3/2) return curvature
def _get_curvature(vertex_x_padded_metres, vertex_y_padded_metres): """Computes signed curvature at each vertex, using interpolating splines. Curvature = inverse of turning radius. This method is based on curvature.py, found here: https://gist.github.com/elyase/451cbc00152cb99feac6 V_p = total number of vertices (including duplicates used for padding) V_u = number of unique vertices :param vertex_x_padded_metres: numpy array (length V_p) with x-coordinates of vertices. :param vertex_y_padded_metres: numpy array (length V_p) with y-coordinates of vertices. :return: vertex_curvatures_metres01: numpy array (length V_u) of curvatures (inverse metres). """ num_padded_vertices = len(vertex_x_padded_metres) vertex_indices_padded = numpy.linspace(0, num_padded_vertices - 1, num=num_padded_vertices, dtype=int) interp_object_for_x = UnivariateSpline(vertex_indices_padded, vertex_x_padded_metres, k=SPLINE_DEGREE) interp_object_for_y = UnivariateSpline(vertex_indices_padded, vertex_y_padded_metres, k=SPLINE_DEGREE) vertex_indices_unique = vertex_indices_padded[SPLINE_DEGREE:-SPLINE_DEGREE] x_derivs_metres_per_vertex = interp_object_for_x.derivative(1)( vertex_indices_unique) x_derivs_metres2_per_vertex2 = interp_object_for_x.derivative(2)( vertex_indices_unique) y_derivs_metres_per_vertex = interp_object_for_y.derivative(1)( vertex_indices_unique) y_derivs_metres2_per_vertex2 = interp_object_for_y.derivative(2)( vertex_indices_unique) numerators = (x_derivs_metres_per_vertex * y_derivs_metres2_per_vertex2 ) - (y_derivs_metres_per_vertex * x_derivs_metres2_per_vertex2) denominators = numpy.power( x_derivs_metres_per_vertex**2 + x_derivs_metres_per_vertex**2, 1.5) return numerators / denominators
def get_critical_points_dist(series): spline_4 = UnivariateSpline(series.keys(), series, k=4) spline_5 = UnivariateSpline(series.keys(), series, k=5) first_derivative = spline_4.derivative() second_derivative = spline_5.derivative(2) roots = first_derivative.roots() #return [(series.keys()[0], series.iloc[0], cp_labels[3])] + [(r, series[r], second_derivative_test(second_derivative, r)) # for r in roots] + [(series.keys()[-1], series.iloc[-1], cp_labels[3])] return [ (series.keys()[0], spline_4(series.keys()[0]).item(), cp_labels[3]) ] + [(r, spline_4(r).item(), second_derivative_test(second_derivative, r)) for r in roots] + [(series.keys()[-1], spline_4( series.keys()[-1]).item(), cp_labels[3])]
def histogram_maxima(peak_hist, plot_bins, hist_sigma, plot): lg.function_log() #hist_filter_1 = savgol_filter(peak_hist,5,3) #hist_filter = gaussian_filter1d(hist_filter_1,0.1) gauss_sigma = max(plot_bins) * hist_sigma """interpolate histogram for higher resolution""" interp_hist = interpolate.interp1d(plot_bins, peak_hist) new_inc = (plot_bins[1] - plot_bins[0]) / 10 new_bins = np.arange(min(plot_bins), max(plot_bins), new_inc) hist_filter = gaussian_filter1d(interp_hist(new_bins), gauss_sigma) """interpolation of histogram""" hist_spline = UnivariateSpline(new_bins, hist_filter, k=4, s=0) """higher number of bins for analysis of interpolation curve""" #new_bins = np.arange(0,max(peak_hist),0.1) """calculation of derivatives to find local maxima""" d_hist_spline = hist_spline.derivative() d2_hist_spline = hist_spline.derivative(2) d_hist_roots = d_hist_spline.roots() """only extract roots with positive values for d2/d2x(root)""" find_peaks_result = [] for n in range(0, len(d_hist_roots)): if d_hist_roots[n] > min(new_bins): if d_hist_roots[n] < max(new_bins): if d2_hist_spline(d_hist_roots[n]) < 0: find_peaks_result.append(d_hist_roots[n]) if plot == True: plt.plot(plot_bins, peak_hist, label='center of mass histogram') #plt.plot(plot_bins, hist_filter_1, label = 'savgol_filter') plt.plot(new_bins, hist_filter, label='gauss_filter') plt.plot(new_bins, d_hist_spline(new_bins), label='derivative') plt.legend() plt.show() cen_list = [] for n in range(0, len(find_peaks_result)): if hist_spline(find_peaks_result[n]) > 0: cen_list.append(np.round(find_peaks_result[n], 0)) return cen_list
def softening_scale(self,mq=70,auto=True,r=None,dens=None,mass=None,kernel='Gadget'): opt_dict={'Gadget':0.698352, 'spline':0.977693} rq=self.qmass(mq) if auto==True: prof=Profile(self.p,Ngrid=512,xmin=0.001*rq,xmax=10*rq,kind='lin') r=prof.grid.gx dens=prof.dens dens_spline=UnivariateSpline(r, dens, k=1,s=0,ext=1) der_dens=dens_spline.derivative() derdens=der_dens(r) ap=UnivariateSpline(r, r*r*dens*derdens*derdens, k=1,s=0,ext=1) bp=UnivariateSpline(r, r*r*dens*dens, k=1,s=0,ext=1) B=bp.integral(0,rq) A=ap.integral(0,rq)/(mass*mq/100.) C=(B/(A))**(1/5) cost=opt_dict[kernel] N=len(self.p.Id)**(1/5) return C*cost/N
def threshold_evaluation(scores): precision = scores[0] recall = scores[1] f1 = scores[2] max_f1 = max(f1, key=lambda x: x[1])[0] x, y = zip(*f1) y_spl = UnivariateSpline(x, y, s=0, k=4) x_range = np.linspace(x[0], x[-1], 1000) y_spl_2d = y_spl.derivative(n=2) # plt.plot(x_range, y_spl_2d(x_range)) max_f1_2d = [x for x in x_range if y_spl_2d(x) == max(y_spl_2d(x_range))] p_x, p_y = zip(*precision) r_x, r_y = zip(*recall) p_x = np.array(p_x) p_y = np.array(p_y) r_y = np.array(r_y) idx = np.argwhere(np.diff(np.sign(p_y - r_y))).flatten() inter = p_x[idx] # A bit off, interpolation should make it better return max_f1, max_f1_2d[0], inter
def find_extrema_spline(x,y,k=4,s=0,**kwargs): """ find local extrema of y(x) by taking derivative of spline Parameters ---------- x,y : array-like find extrema of y(x) k : int order of spline interpolation [must be >3] s : number s parameter sent to scipy spline interpolation (used for smoothing) **kwargs : extra arguments to UnivariateSpline Returns ------- sp : UnivariateSpline object x_max,y_max : array value of x and y at extrema(s) """ sp = UVSpline(x,y,k=k,s=s,**kwargs) x_max = sp.derivative().roots() y_max = sp(x_max) return sp,x_max,y_max
def ang_mom_circ(r, v, phi, rmax=200, bins=100): ''' :param r: radius :param v: total velocity :param phi: potential :return: j_circ(E) ''' r_phi = np.array(sorted([x for x in zip(r, phi)])) r_edges = np.linspace(0, rmax, bins+1) # check what is max(r); should I apply limits? r_bin = 0.5*(r_edges[1:] + r_edges[:-1]) phi_bin = np.zeros_like(r_bin) for i in range(len(r_bin)-1): idxs_bin = np.where((r_phi.T[0] > r_edges[i]) & (r_phi.T[0] < r_edges[i+1])) phi_bin[i] = np.mean(r_phi.T[1][idxs_bin]) phi_spl = UnivariateSpline(r_bin, phi_bin) phi_der = phi_spl.derivative() # j(E) interpolation r = np.linspace(0, rmax, 1000) j_circ_E_spl = interp1d(0.5 * r * phi_der(r) + phi_spl(r), np.sqrt(r * phi_der(r)) * r, fill_value=0, bounds_error=False) j_circ_E = j_circ_E_spl(0.5 * v ** 2 + phi) return j_circ_E
def retrieve_data(dataset, Y, derivative=False, maxlen=96): obs = dataset.shape[0] num_feature = 20 newdata = [] newY = [] t = [0.2 * i for i in range(maxlen)] for i in range(obs): data = dataset[i] datalen = data.shape[0] if datalen >= maxlen: D = data[(datalen - maxlen):(datalen), ] if derivative == True: #D_deri = np.gradient(D,axis=0) #D = np.concatenate((D,D_deri),axis=1) D_deri = [] for j in range(num_feature): sdata = D[:, j] localvar = np.std(sdata) f_spline = UnivariateSpline(t, sdata, s=2 * len(t) * localvar) f_deri = f_spline.derivative() D_deri.append(f_deri(t)) D_deri = np.array(D_deri).transpose() D = np.concatenate((D, D_deri), axis=1) newdata.append(D) newY.append(Y[i]) return np.array(newdata), np.array(newY)
def calc_Lz(cls, inp, data): """creates the emissivity function Lz over a range of temperatures""" def kev_J(x): return x * 1E3 * 1.6021E-19 tei_lin = np.linspace(inp.nmin_T, inp.nmax_T, inp.nte) Lz_tot = np.zeros(inp.nte) # for each charge state, for cs in np.arange(inp.z_imp + 1): # get fractional abundances of each as a function of ne and Te frac_abun_interp = interp1d(tei_lin, cls.frac_abun(inp, data)[0, :, cs]) Lz_cs_interp = interp1d(tei_lin, data.alradr[cs, 0, :]) for i, T in enumerate(tei_lin): Lz_tot[ i] = Lz_tot[i] + 10**Lz_cs_interp(T) * frac_abun_interp(T) # spline fit the logarithm of the emissivity. We'll spline fit the actual values next Lz_tot_interp = UnivariateSpline(inp.tei, np.log10(Lz_tot) + 100.0, s=0) # the above function gives the right values, but we also need the derivatives # we will now do a spline fit of the values themselves, rather than their base-10 logarithm T_kev_vals = np.logspace(-3, 2, 10000) T_J_vals = kev_J(T_kev_vals) Lz_vals = 10.0**(Lz_tot_interp(T_kev_vals) - 100.0) Lz_interp = UnivariateSpline(T_J_vals, Lz_vals, s=0) dLzdT_interp = Lz_interp.derivative() return Lz_interp, dLzdT_interp
def omega_phi_kerr_converge(time, data, N=1, minN=0): splrep = UnivariateSpline(time, data, s=0, k=4) tpks = splrep.derivative().roots()[1:] deltat = tpks[N] - tpks[minN] defint = splrep.integral(tpks[minN], tpks[N]) omega_phi = defint / deltat return omega_phi
def response(self, disturbance_vector): """ Returns the response of the sensor due to a disturbance The acceleration imposed to the sensor is estimatad with the following equations: acceleration(t) = d2stress(t)/t2 * material_depth/material_prop['modulus'] And the sensor response takes into account the frequency response, estimated by a normal curve freq_response(f) = norm(scale = self.bandwidth/2, loc=self.resonant_freq).pdf(f_array) freq_response(f) /= max(freq_response) response(t) = ifft(fft(acceleration) * freq_response) Args: disturbance_vector (list): list with a temporal array, in the 0 index, and a stress array, in the 1 index. Returns: list: with two arrays, the temporal array and the voltage response array. """ const = self.material_depth / self.material_prop['modulus'] t_vector = disturbance_vector[0] # using the scipy UnivariateSpline to compute the second derivative data_spl = UnivariateSpline(t_vector, disturbance_vector[1], s=0, k=3) acceleration = data_spl.derivative(n=2)(t_vector) * const # we need to take the frequency response of the acceleration stimuli N = len(disturbance_vector[1]) T = t_vector[1] - t_vector[0] f_array = np.fft.fftfreq(N, T) freq_acc = np.fft.fft(acceleration) # we need to apply a filter factor related to the frequency response of the sensor freq_response = self.frequency_response(N, (0, max(f_array)), mirror=True)[1] voltage = np.fft.ifft(freq_acc * freq_response) * self.sensitivity return voltage
def GetPeaks(): x = ds_analysis.data['x'] y = ds_analysis.data['y'] spl = UnivariateSpline(x, y, k=4, s=splineSlider.value) spl_prime = spl.derivative() spl_prime_vals = spl_prime(x) spl_prime2 = spl_prime.derivative() peaks_valleys = spl_prime.roots() peaks_valleys_ndx = [np.abs(x - i).argmin() for i in peaks_valleys] inflection_points_ndx = [] for i in range(1, len(spl_prime_vals) - 1): if spl_prime_vals[i] < spl_prime_vals[ i - 1] and spl_prime_vals[i] < spl_prime_vals[i + 1]: inflection_points_ndx.append(i) elif spl_prime_vals[i] > spl_prime_vals[ i - 1] and spl_prime_vals[i] > spl_prime_vals[i + 1]: inflection_points_ndx.append(i) ds_splinefit_peaks.data = dict(x=np.concatenate( (peaks_valleys, x[inflection_points_ndx])), y=spl(x)[np.concatenate( (peaks_valleys_ndx, inflection_points_ndx))])
def get_derivatives(xs, ys, fd=False): """ return the derivatives of y(x) at the points x if scipy is available a spline is generated to calculate the derivatives if scipy is not available the left and right slopes are calculated, if both exist the average is returned putting fd to zero always returns the finite difference slopes """ try: if fd: raise SplineInputError("no spline wanted") if len(xs) < 4: er = SplineInputError("too few data points") raise er from scipy.interpolate import UnivariateSpline spline = UnivariateSpline(xs, ys) d = spline.derivative(1)(xs) except (ImportError, SplineInputError): d = [] m, left, right = 0, 0, 0 for n in range(0, len(xs), 1): try: left = (ys[n] - ys[n - 1]) / (xs[n] - xs[n - 1]) m += 1 except IndexError: pass try: right = (ys[n + 1] - ys[n]) / (xs[n + 1] - xs[n]) m += 1 except IndexError: pass d.append(left + right / m) return d
def filter(self, ): """Update StruM to ignore uninformative position-specific features. Features with a high variance, i.e. non-specific features, do not contribute to the specificity of the StruM model. Filtering them out may increase the signal-to-noise ratio. The position-specific- features are rank ordered by their variance, and a univariate spline is fit to the distribution. The point of inflection is used as the threshold for masking less specific features. Once this method is run and the attribute `self.filter_mask` is generated, two additional methods will become available: :func:`score_seq_filt` and :func:`eval_filt`. """ from scipy.interpolate import UnivariateSpline idx = np.argsort(self.strum[1])[::-1] variance = self.strum[1][idx] n = len(idx) xvals = np.arange(n) spl = UnivariateSpline(xvals, variance, s=n / 10.) d_spl = spl.derivative(1) d_ys = d_spl(xvals) min_i = np.argmax(d_ys) self.var_thresh = spl(min_i) self.filter_mask = idx[min_i:]
def averageProfile(self, trange=[2, 3], interelm=False, elm=False, **kwargs): _idx = np.where((self.time >= trange[0]) & (self.time <= trange[1]))[0] ne = self.ne[_idx, :] neN = self.neNorm[_idx, :] if interelm: logging.warning('Computing inter-ELM profiles') self._maskElm(trange=trange, **kwargs) ne = ne[self._interElm, :] neN = neN[self._interElm, :] if elm: self._maskElm(trange=trange, **kwargs) logging.warning('Computing ELM profiles') ne = ne[self._Elm, :] neN = neN[self._Elm, :] profiles = np.nanmean(ne, axis=0) error = np.nanstd(ne, axis=0) profilesN = np.nanmean(neN, axis=0) errorN = np.nanstd(neN, axis=0) # now build the appropriate Efolding length on the # recomputed profiles using an UnivariateSpline # interpolation weighted on the error Rmid = self.eq.rho2rho('sqrtpsinorm', 'Rmid', self.rho, self.time[_idx].mean()) # S = UnivariateSpline(Rmid, profiles, w=1. / error, s=0) Efold = np.abs(S(Rmid) / S.derivative()(Rmid)) return profiles, error, Efold, profilesN, errorN
def curvature_splines(x, y=None, error=0.1): if y is None: x, y = x.real, x.imag t = np.arange(x.shape[0]) std = error * np.ones_like(x) fx = UnivariateSpline(t, x, k=4, w=1 / np.sqrt(std)) fy = UnivariateSpline(t, y, k=4, w=1 / np.sqrt(std)) xˈ = fx.derivative(1)(t) xˈˈ = fx.derivative(2)(t) yˈ = fy.derivative(1)(t) yˈˈ = fy.derivative(2)(t) curvature = abs((xˈ * yˈˈ - yˈ * xˈˈ)) / np.power(xˈ**2 + yˈ**2, 3 / 2) return curvature
def smooth_elevation(df, smooth=4): if not present(df, N.ELEVATION): log.debug(f'Smoothing {N.RAW_ELEVATION} to get {N.ELEVATION}') unique = df.loc[~df[N.DISTANCE].isna() & ~df[N.RAW_ELEVATION].isna(), [N.DISTANCE, N.RAW_ELEVATION]].drop_duplicates( N.DISTANCE) # the smoothing factor is from eyeballing results only. maybe it should be a parameter. # it seems better to smooth along the route rather that smooth the terrain model since # 1 - we expect the route to be smoother than the terrain in general (roads / tracks) # 2 - smoothing the 2d terrain is difficult to control and can give spikes # 3 - we better handle errors from mismatches between terrain model and position # (think hairpin bends going up a mountainside) # the main drawbacks are # 1 - speed on loading # 2 - no guarantee of consistency between routes (or even on the same routine retracing a path) spline = UnivariateSpline(unique[N.DISTANCE], unique[N.RAW_ELEVATION], s=len(unique) * smooth) df[N.ELEVATION] = spline(df[N.DISTANCE]) df[N.GRADE] = (spline.derivative()(df[N.DISTANCE]) / 10 ) # distance in km df[N.GRADE] = df[N.GRADE].rolling( 5, center=True).median().ffill().bfill() # avoid extrapolation / interpolation df.loc[df[N.RAW_ELEVATION].isna(), [N.ELEVATION]] = None return df
def get_derivatives(xs, ys, fd=False): """ return the derivatives of y(x) at the points x if scipy is available a spline is generated to calculate the derivatives if scipy is not available the left and right slopes are calculated, if both exist the average is returned putting fd to zero always returns the finite difference slopes """ try: if fd: raise SplineInputError('no spline wanted') if len(xs) < 4: er = SplineInputError('too few data points') raise er from scipy.interpolate import UnivariateSpline spline = UnivariateSpline(xs, ys) d = spline.derivative(1)(xs) except (ImportError, SplineInputError): d = [] m, left, right = 0, 0, 0 for n in range(0, len(xs), 1): try: left = (ys[n] - ys[n-1]) / (xs[n] - xs[n-1]) m += 1 except IndexError: pass try: right = (ys[n+1] - ys[n]) / (xs[n+1] - xs[n]) m += 1 except IndexError: pass d.append(left + right / m) return d
def spl1d(pr, fs, kk=3, ss=.001): """Use scipy.interpolate.Univariate spline to fit the data and calculate velocity and acceleration from the spline Parameters: pr = (ntime x nmark x 3) raw data array fs = sampling rate kk = spline order (default is 3) ss = spline smoothing parameter (default is .001) Returns: out = dict that holds filtered position and calculated velocity and accleration """ ntime, nmark, ncoord = pr.shape dt = 1 / fs times = np.arange(ntime) * dt # iterate through each marker and coordinate, smooth, and calculate # velocities and accelerations pf, vf, af = pr.copy(), pr.copy(), pr.copy() for j in np.arange(nmark): for k in np.arange(ncoord): d = pr[:, j, k] spl = UnivariateSpline(times, d, k=kk, s=ss) pf[:, j, k] = spl(times) vf[:, j, k] = spl.derivative(1)(times) af[:, j, k] = spl.derivative(2)(times) out = {'p': pf, 'v': vf, 'a': af} return out
def dRdS1(S1, m_DM, cp_random, cn_random, Nevents=False, **kwargs): eff1, eff2 = np.loadtxt("../Swordfish_Xenon1T/Efficiency-1705.06655.txt", unpack=True) efficiency = UnivariateSpline(eff1, eff2, ext="zeros", k=1, s=0) S1_vals, E_vals = np.loadtxt("../Swordfish_Xenon1T/S1vsER.txt", unpack=True) CalcER = UnivariateSpline(S1_vals, E_vals, k=4, s=0) dERdS1 = CalcER.derivative() ER_keV = CalcER(S1) prefactor = 0.475 * efficiency(ER_keV) def dRdE(ER_keV, m_x, cp, cn, **kwargs): #Load in the list of nuclear spins, atomic masses and mass fractions nuclei_Xe = [ "Xe128", "Xe129", "Xe130", "Xe131", "Xe132", "Xe134", "Xe136" ] nuclei_list = np.loadtxt("Nuclei.txt", usecols=(0, ), dtype='string') frac_list = np.loadtxt("Nuclei.txt", usecols=(3, )) frac_vals = dict(zip(nuclei_list, frac_list)) dRdE = np.zeros_like(ER_keV) for nuc in nuclei_Xe: dRdE += frac_vals[nuc] * DMU.dRdE_NREFT(ER_keV, m_x, cp, cn, nuc, **kwargs) return dRdE dRdEXe = dRdE(ER_keV, m_DM, cp_random, cn_random, **kwargs) s = prefactor * dRdEXe * dERdS1(S1) if Nevents: return s, sum(s * s1width) else: return s
def find_char_separators(img, num_chars): f = (img > 0).mean(axis=0) a, b = f.min(), f.max() f = (f - a) / (b - a) n, k = len(f), num_chars x = np.arange(0, n) # Initial guess s0 = np.linspace(0, n, k + 1)[1:-1] # Value boundaries for each delimiter. char_min_size = 15 delimiter_margin = 8 bounds = np.transpose( np.stack([ np.maximum(s0 - delimiter_margin, 0), np.minimum(s0 + delimiter_margin, n - 1) ], axis=0)) # Now we move the delimiters to divide the chars better y_spl = UnivariateSpline(x, f, s=0, k=4) y_spl_df = y_spl.derivative(n=1) F = lambda s: np.sum(y_spl(s)) dF = lambda s: y_spl_df(s) / (k - 1) jac = lambda s, *args: dF(s) result = minimize(F, s0, jac=jac, method='SLSQP', bounds=bounds) s = np.round(result.x) separators = s.astype(np.uint16) return separators
def getspline_Sold(self): """Cubic spline interpolation of entropy and convective velocity. """ want = self.mass < max(self.mass)*self.mass_cut S_old = UnivariateSpline(self.mass[want], self.Sgas[want], k=self.spline_k, s=self.spline_s, ext=self.spline_ext) dS_old = S_old.derivative() vconv_Sold = UnivariateSpline(self.mass[want], self.vconv[want], k=self.spline_k, s=self.spline_s, ext=self.spline_ext) return [S_old, dS_old, vconv_Sold]
def adiabat_steeper(self): ''' Checks whether the adiabat is steeper than the liquidus. Ultimately this should be part of determining the adiabat in the snow regime. ''' p_oc = self.pressure[self.outer_core()] t_oc = self.temperature[self.outer_core()] t_func = UnivariateSpline(p_oc,t_oc) return t_func.derivative()(p_oc) > self.liquidus.derivative()(p_oc)
def find_ending_point(X, y, start_point, use_alternative = False): """ ================ INPUT: array of X data (temperature), array of Y data (heat flow), int OUTPUT: int ================ Finds the end point of the reaction to estimate enthalpy. - NOTE: use_alternative: this variable decides which "end point finder" you want to use. if you want to take the post-peak max point, select True. If you want to use the end-point derived from the second derivative, select False. In order, this function: 1. Isolates data after the peak 2. Approximates the data with a spline. 3. Finds the point where the first derivative is closest to zero and nearest to the end of the reaction. This is the end point. ## note, you could also set the end point to be when the function ## has returned closest to the gradient at the start_point 4. If this point is < post-peak max point, choose the maximum point. """ start_point = 1405 reaction_x = X[start_point:] # x's after the start_point reaction_y = y[start_point:] # y's after the start_point index_of_peak = start_point + reaction_y.argmin() if use_alternative: end_point_id = index_of_peak + y[index_of_peak : ].argmax() else: pp_X, pp_y = X[index_of_peak: ], y[index_of_peak: ] spline = UnivariateSpline(pp_X, pp_y, k = 5) second_derivative = spline.derivative(2)(pp_X) relevant_end_points = np.abs(second_derivative) end_point = np.max(relevant_end_points.argsort()[:50]) # get the largest of all the zero points end_point_id = index_of_peak + end_point # just in case there are larger points between peak & end point if np.max(y[index_of_peak : end_point_id]) > y[end_point_id]: index = y[index_of_peak : end_point_id].argmax() end_point_id = index_of_peak + index return end_point_id
def get_splines(self, floor=25 * 1e-9, ceil=25 * 1e-6): from scipy.interpolate import UnivariateSpline mx, my = zip(*self.scatter_data) yy, xx = zip(*lmseq(zip(my, mx))) # filter with LMS spl = UnivariateSpline(xx, yy) spld = spl.derivative() def spl_derivative(x): s = abs(spld(x)) s[s < floor] = floor s[s > ceil] = ceil return s self.spl = spl self.spld = spl_derivative
def softening_scale(self,mq=70,auto=True,r=None,dens=None,mass=None,kernel='Gadget',type=None): """ Calculate the optimal softening scale following Dehnen, 2012 eps=cost*a(dens)*N^-0.2. The output will be in unit of r. If Auto==True, r and dens will be not considered. :param mq: Mass fraction where calcualte the softening_scale. :param auto: If True calculate the r-dens gride using the grid and Profile class wit 512 points from 0.001*rq to 10*rq. :param r: Array with the sampling radii. :param dens: Array with the density at the sampling radii. Its unity need to be the same of mass/r^3 :param mass: Total mass of the system, the method will calculate in automatic the fraction mq/100*mass :param kernel: Kernel to use. Different kernel have different constant C. The implemented kernels are: -spline: generic cubic spline (as in Dehnen, 2012) -Gadget: to calculate the softening_scale using the spline kernel of Gadget2 :return: the softening scale. """ opt_dict={'Gadget':0.698352, 'spline':0.977693} rq=self.qmass(mq,type=type) if auto==True: prof=Profile(self.p,Ngrid=512,xmin=0.01*rq,xmax=10*rq,kind='lin',type=type) r=prof.grid.gx dens=prof.dens dens_spline=UnivariateSpline(r, dens, k=1,s=0,ext=1) der_dens=dens_spline.derivative() derdens=der_dens(r) ap=UnivariateSpline(r, r*r*dens*derdens*derdens, k=1,s=0,ext=1) bp=UnivariateSpline(r, r*r*dens*dens, k=1,s=0,ext=1) B=bp.integral(0,rq) A=ap.integral(0,rq)/(mass*mq/100.) C=(B/(A))**(1/5) cost=opt_dict[kernel] N=len(self.p.Id)**(1/5) return C*cost/N
def GroundDataTrendingPlotJSON(site,crack,end = None): ##### Federico et al. constants###### slope = 1.49905955613175 intercept = -3.00263765777028 t_crit = 4.53047399738543 var_v_log = 215.515369339559 v_log_mean = 2.232839766 sum_res_square = 49.8880017417971 n = 30. #################################### if end == None: end = datetime.now() df = get_latest_ground_df(site,end) df['site_id'] = map(lambda x: x.lower(),df['site_id']) df['crack_id'] = map(lambda x: x.title(),df['crack_id']) end = pd.to_datetime(end) df = df[df.crack_id == crack.title()] cur_t = (df.timestamp.values - df.timestamp.values[0])/np.timedelta64(1,'D') cur_x = df.meas.values cur_ts = df.timestamp.values cur_ts = pd.to_datetime(cur_ts) ##### Interpolate the last 10 data points _,var = moving_average(cur_x) w = 1/np.sqrt(var) if 0 in var: w = None t_n = np.linspace(cur_t[0],cur_t[-1],20) ts_n = pd.to_datetime(cur_ts[0]) + np.array(map(lambda x: timedelta(days = x), t_n)) try: sp = UnivariateSpline(cur_t,cur_x,w=w) x_n = sp(t_n) v_s = abs(sp.derivative(n=1)(cur_t)) a_s = abs(sp.derivative(n=2)(cur_t)) v_t = np.linspace(min(v_s),max(v_s),num = 20) unc = t_crit*np.sqrt(1/(n-2)*sum_res_square*(1/n + (np.log(v_t) - v_log_mean)**2/var_v_log)) a_t = slope * np.log(v_t) + intercept a_tu = a_t + unc a_td = a_t - unc except: print "Interpolation Error for site {} crack {} at timestamp ".format(site,crack,end) t_n = np.linspace(cur_t[0],cur_t[-1],len(cur_t)) ts_n = pd.to_datetime(cur_ts[0]) + np.array(map(lambda x: timedelta(days = x), t_n)) x_n = cur_x v_s = np.zeros(len(x_n)) a_s = np.zeros(len(x_n)) v_t = np.zeros(20) a_t = np.zeros(20) a_tu = np.zeros(20) a_td = np.zeros(20) #logarithmic axes v_s = np.log(v_s) v_s = v_s[~np.logical_or(np.isnan(v_s),np.isinf(v_s))] a_s = np.log(a_s) a_s = a_s[~np.logical_or(np.isnan(a_s),np.isinf(a_s))] a_t = a_t[~np.logical_or(np.isnan(a_t),np.isinf(a_t))] a_tu = a_tu[~np.logical_or(np.isnan(a_tu),np.isinf(a_tu))] a_td = a_td[~np.logical_or(np.isnan(a_td),np.isinf(a_td))] v_t = np.log(v_t) v_t = v_t[~np.logical_or(np.isnan(v_t),np.isinf(v_t))] ts_n = map(lambda x: mytime.mktime(x.timetuple())*1000, ts_n) cur_ts = map(lambda x: mytime.mktime(x.timetuple())*1000, cur_ts) to_json = {'av' : {'v':list(v_s),'a':list(a_s),'v_threshold':list(v_t),'a_threshold_line':list(a_t),'a_threshold_up':list(a_tu),'a_threshold_down':list(a_td)},'dvt':{'gnd':{'ts':list(cur_ts),'surfdisp':list(cur_x)},'interp':{'ts':list(ts_n),'surfdisp':list(x_n)}}} print json.dumps(to_json)
def check_trending(df,out_folder,plot = False): ##### Get the data from the crack dataframe cur_t = (df.timestamp.values - df.timestamp.values[0])/np.timedelta64(1,'D') cur_x = df.meas.values ##### Interpolate the last 10 data points _,var = moving_average(cur_x) sp = UnivariateSpline(cur_t,cur_x,w=1/np.sqrt(var)) t_n = np.linspace(cur_t[0],cur_t[-1],100) x_n = sp(t_n) v_n = sp.derivative(n=1)(t_n) a_n = sp.derivative(n=2)(t_n) x_s = sp(cur_t) v_s = abs(sp.derivative(n=1)(cur_t)) a_s = abs(sp.derivative(n=2)(cur_t)) SS_res,r2,RMSE = goodness_of_fit(cur_t,cur_x,x_s) text = 'SSE = {} \nR-square = {} \nRMSE = {}'.format(round(SS_res,4),round(r2,4),round(RMSE,4)) ##### Federico et al. constants slope = 1.49905955613175 intercept = -3.00263765777028 t_crit = 4.53047399738543 var_v_log = 215.515369339559 v_log_mean = 2.232839766 sum_res_square = 49.8880017417971 n = 30. ##### Trending Alert Evaluation cur_v = v_s[-1] cur_a = a_s[-1] delta = t_crit*np.sqrt(1/(n-2)*sum_res_square*(1/n + (np.log(cur_v) - v_log_mean)**2/var_v_log)) log_a_t = slope * np.log(cur_v) + intercept log_a_t_up = log_a_t + delta log_a_t_down = log_a_t - delta a_t_up = np.e**log_a_t_up a_t_down = np.e**log_a_t_down ##### Plot points in the confidence interval envelope if plot == True: ##### Plotting Colors tableau20 = [(31, 119, 180), (174, 199, 232), (255, 127, 14), (255, 187, 120), (44, 160, 44), (152, 223, 138), (214, 39, 40), (255, 152, 150), (148, 103, 189), (197, 176, 213), (140, 86, 75), (196, 156, 148), (227, 119, 194), (247, 182, 210), (127, 127, 127), (199, 199, 199), (188, 189, 34), (219, 219, 141), (23, 190, 207), (158, 218, 229)] for i in range(len(tableau20)): r, g, b = tableau20[i] tableau20[i] = (r / 255., g / 255., b / 255.) ################# v_theo = np.linspace(min(v_s),max(v_s),10000) uncertainty = t_crit*np.sqrt(1/(n-2)*sum_res_square*(1/n + (np.log(v_theo) - v_log_mean)**2/var_v_log)) log_a_theo = slope * np.log(v_theo) + intercept log_a_theo_up = log_a_theo + uncertainty log_a_theo_down = log_a_theo - uncertainty a_theo = np.e**log_a_theo a_theo_up = np.e**log_a_theo_up a_theo_down = np.e**log_a_theo_down fig = plt.figure() fig.set_size_inches(15,8) fig.suptitle('{} Crack {} {}'.format(str(df.site_id.values[0]).upper(),str(df.crack_id.values[0]).title(),pd.to_datetime(df.timestamp.values[-1]).strftime("%b %d, %Y %H:%M"))) ax1 = fig.add_subplot(121) ax1.get_xaxis().tick_bottom() ax1.get_yaxis().tick_left() ax1.grid() l1 = ax1.plot(v_theo,a_theo,c = tableau20[0],label = 'Fukuzono (1985)') ax1.plot(v_theo,a_theo_up,'--',c = tableau20[0]) ax1.plot(v_theo,a_theo_down,'--', c = tableau20[0]) ax1.plot(v_s,a_s,c = tableau20[10]) l2 = ax1.plot(v_s[:-1],a_s[:-1],'o',c = tableau20[19],label = 'Previous') l3 = ax1.plot(v_s[-1],a_s[-1],'*',c = tableau20[6],label = 'Current') lns = l1 + l2 + l3 labs = [l.get_label() for l in lns] ax1.legend(lns,labs,loc = 'upper left',fancybox = True, framealpha = 0.5) ax1.set_xlabel('velocity (cm/day)') ax1.set_ylabel('acceleration (cm/day$^2$)') ax1.set_xscale('log') ax1.set_yscale('log') ax2 = fig.add_subplot(222) ax2.grid() ax2.plot(cur_t,cur_x,'.',c = tableau20[0],label = 'Data') ax2.plot(t_n,x_n,c = tableau20[12],label = 'Interpolation') cur_range = max(list(cur_x) + list(x_n)) - min(list(cur_x) + list(x_n)) ylim_max = max(list(cur_x) + list(x_n)) + cur_range*0.05 ylim_min = min(list(cur_x) + list(x_n)) - cur_range*0.05 ax2.set_ylim([ylim_min,ylim_max]) ax2.legend(loc = 'upper left',fancybox = True, framealpha = 0.5) ax2.set_ylabel('disp (meters)') ax3 = fig.add_subplot(224, sharex = ax2) ax3.grid() ax3.plot(t_n,v_n, color = tableau20[4],label = 'Velocity') l3_vel, l2_vel = velocity_alert_values(cur_t[-2]-cur_t[-1]) ylim_values = ax3.get_ylim() ax3.plot(ax3.get_xlim(),[l3_vel,l3_vel],'--',lw = 2., color = tableau20[2],label = 'L3 Velocity') ax3.plot(ax3.get_xlim(),[-l3_vel,-l3_vel],'--',lw = 2., color = tableau20[2]) ax3.plot(ax3.get_xlim(),[l2_vel,l2_vel],'--',lw = 2., color = tableau20[16],label = 'L2 Velocity') ax3.plot(ax3.get_xlim(),[-l2_vel,-l2_vel],'--',lw = 2., color = tableau20[16]) ax3.set_ylim(ylim_values) ax3.set_ylabel('velocity (cm/day)') ax3.set_xlabel('time (days)') ax3.legend(loc = 'upper left',fancybox = True, framealpha = 0.5) ax4 = ax3.twinx() ax4.plot(t_n,a_n,'-r',label = 'Acceleration') ax4.set_ylabel('acceleration (m/day$^2$)') ax4.legend(loc = 'upper right',fancybox = True, framealpha = 0.5) tsn = pd.to_datetime(df.timestamp.values[-1]).strftime("%Y-%m-%d_%H-%M-%S") out_filename = out_folder + '{} {} {}'.format(tsn,str(df.site_id.values[0]),str(df.crack_id.values[0])) print out_filename print text plt.savefig(out_filename,facecolor='w', edgecolor='w',orientation='landscape',mode='w',bbox_inches = 'tight') print cur_a, a_t_up, a_t_down if (cur_a <= a_t_up and cur_a >= a_t_down): #Reject alert if v and a have opposite signs if v_n[-1]*a_n[-1] >= 0: return 'Legit' else: return 'Reject' else: return 'Reject'
class corePlanet(cm_Planet): def __init__(self, masses, compositions, temperatures, liquidus=None,materials=None,**kwargs): """ Parameters ---------- masses: list of layer masses ordered in to out compositions: list of burnman.Composite or burnman.Material describing the material of each layer temperatures: temperature of the upper boundary for each layer methods: list of EOS fitting method Optional ---------- liquidus: A function describing the icb temperature (for a given composition). methods: list of burnman EOS methods to be used for each material in compositions, default: 'slb' """ super(corePlanet,self).__init__(masses, compositions, temperatures,**kwargs) # liquidus model self.liquidus_model = liquidus() self.materials = materials # Make sure the number of layers is consistent with having a growing core assert self.Nlayer >= 3 def set_liquidus_model(self,liquidus): self.liquidus_model = liquidus() def set_liquidus(self): ''' Set liquidus for current liquid composition to a UnivariateSpline) ''' liq_arr = np.array([ self.liquidus_model.T_SP(self.w_l[0],p) for p in self.pressure]) self.liquidus = UnivariateSpline(self.pressure[::-1],liq_arr[::-1]) def find_icb_temp(self,idx=0): ''' Use an FeS liquidus model to find a thermodynamically consisten temperature for the icb. Assumes that the 0th index refers to the inner core and inner core boundary. ''' assert not self.liquidus_model is None self.set_liquidus() m_inner = self.massBelowBoundary[idx] p_func = UnivariateSpline(self.int_mass, self.pressure) p_icb = p_func(m_inner) t_icb = self.liquidus(p_icb) # print 'liquidus:',p_icb,t_icb self.temperature[idx] = t_icb return t_icb def compute_temperature(self,inner_isotherm=False,outer_isotherm=False, mantle_isotherm=False): ''' Calculate a core adiabat consistent with the size of the inner core using the model FeS liquidus. Defaults to calculating adiabatic profiles, starting at the icb for both inner and outer core. ''' t_icb = self.find_icb_temp() # compute inner_core if not inner_isotherm: self.compute_adiabat_layer(0,t_icb) else: self.compute_isotherm_layer(0,t_icb) if not outer_isotherm: self.compute_adiabat_layer(1,t_icb,fromLowerBound=True) else: self.compute_isotherm_layer(1,t_icb,fromLowerBound=True) last_temp = self.temperature[self.get_layer(1)][-1] self.boundary_temperatures[0] = t_icb self.boundary_temperatures[1] = last_temp if not mantle_isotherm: for i in range(2,self.Nlayer): self.compute_adiabat_layer(i,last_temp,fromLowerBound=True) last_temp = self.temperature[self.get_layer(i) ][-1] self.boundary_temperatures[i] = last_temp else: for i in range(2,self.Nlayer): self.compute_isotherm_layer(i,last_temp,fromLowerBound=True) last_temp = self.temperature[self.get_layer(i) ][-1] self.boundary_temperatures[i] = last_temp def inner_core(self): return self.get_layer(0) def outer_core(self): return self.get_layer(1) def mantle(self): return -self.inner_core() - self.outer_core() def core(self): return self.inner_core() + self.outer_core() def icb(self): x = len(self.int_mass) # layer = np.linspace(0,x-1,x)[self.inner_core()] layer = np.arange(x)[self.inner_core()] return layer[-1] def cmb(self): x = len(self.int_mass) # layer = np.linspace(0,x-1,x)[self.outer_core()] layer = np.arange(x)[self.outer_core()] return layer[-1] def print_state(self,i=150): ''' For debugging ''' print self.int_mass[i],self.radius[i],self.density[i],self.gravity[i], print self.pressure[i],self.temperature[i] def gravitational_energy_over_r(self): ''' Calculate the Eg per change in core radius. Delta Eg = int ( [ (rho_l - rho_s)*g*4pi*r^2 ] dr ) Returns the bracketed parameter. ''' for c in self.compositions: assert( isinstance(c,burnman.Material) ), "Expected burnman.Material object" # Parameters at the inner core boundary idx_icb = self.icb() p_icb = self.pressure[idx_icb] rho_icb = self.density[idx_icb] g_icb = self.gravity[idx_icb] r_icb = self.boundaries[0] t_icb = self.temperature[idx_icb] # is this necessary? or is taking rho_ic[-1] - rho_oc[0] sufficient? rho_s,rho_l = density_coexist(self.w_l,[self.DS,self.DSi],p_icb,t_icb,\ self.materials[0],self.materials[1]) # print rho_s - rho_l # return dEg / dr return (rho_s - rho_l) * g_icb * r_icb * 4. * np.pi * r_icb**2. def specific_gravitational_energy(self): ''' Calculate the gravitational energy released per unit mass at the icb. ''' rho = self.density[self.inner_core()][-1] r = self.boundaries[0] dm_dr = rho * 4. * np.pi * r**2 return self.gravitational_energy_over_r() / dm_dr def light_element_release_over_r(self): ''' Calculate the mass of light element released per change in core radius. (kg) ''' rho = self.density[self.inner_core()][-1] r = self.boundaries[0] dm_dr = rho * 4. * np.pi * r**2 return np.sum(self.w_l[:-1]) * dm_dr def latent_heat_over_r(self): ''' Compute latent heat released per growth of inner core radius ''' p = self.pressure[self.icb()] t = self.temperature[self.icb()] rho = self.density[self.inner_core()][-1] r = self.boundaries[0] dm_dr = rho * 4. * np.pi * r**2 return iron_latent_heat(p,t,self.w_l) * dm_dr def specific_latent_heat(self): ''' Compute latent heat per change in mass ''' p = self.pressure[self.icb()] t = self.temperature[self.icb()] return iron_latent_heat(p,t,self.w_l) def detect_snow(self): ''' Test whether points in the liquid outer core are above the liquidus. This is a very simple check and doesn't consider how liquidus should perturb the adiabat ''' p_oc = self.pressure[self.outer_core()] t_oc = self.temperature[self.outer_core()] t_liq = self.liquidus(p_oc) # Boolean. True if temperature is below the liquidus (snowing) snow = t_liq > t_oc self.has_snow = snow.any() return snow def adiabat_steeper(self): ''' Checks whether the adiabat is steeper than the liquidus. Ultimately this should be part of determining the adiabat in the snow regime. ''' p_oc = self.pressure[self.outer_core()] t_oc = self.temperature[self.outer_core()] t_func = UnivariateSpline(p_oc,t_oc) return t_func.derivative()(p_oc) > self.liquidus.derivative()(p_oc) def integrate(self,n_slices,P0,n_iter=5,profile_type='adiabatic',plot=False, verbose=True): """ Iteratively determine the pressure, density temperature and gravity profiles for the planet as a function of radius within a planet, with a consistent temperature and pressure for the inner core boundary. Sets pressure, temperature, radius, boundaries, gravity, and density, for given profile in integrated mass (int_mass). Also sets differences for quantities between the last two iterations for convergence analysis. Parameters ---------- n_slices : number of steps in integrated mass P0 : initial guess for central pressure in Pa Optional ---------- n_iter : number of iterations (default: 5) profile_type : temperature profile type ('adiabatic' or 'isothermal, default: 'adiabatic') plot : create plot of density, gravity, pressure and temperature as a function of radius (default: False) verbose : (default: True) """ if verbose: self.display_input(n_slices,P0,n_iter,profile_type) self.int_mass = np.linspace(0.,self.massBelowBoundary[-1], n_slices) self.pressure = np.linspace(P0, 0.0, n_slices) # initial guess at pressure profile # take isothermal starting T profile self.temperature = np.ones_like(self.pressure)*self.boundary_temperatures[-1] self.radius = np.zeros_like(self.int_mass) self.boundaries = np.zeros_like(self.massBelowBoundary) self.gravity = np.zeros_like(self.int_mass) # eos parameters self.density = np.zeros_like(self.int_mass) self.vp = np.zeros_like(self.int_mass) self.vs = np.zeros_like(self.int_mass) self.vphi = np.zeros_like(self.int_mass) self.K = np.zeros_like(self.int_mass) self.G = np.zeros_like(self.int_mass) if plot == True: ax1 = plt.subplot(141);ax1.set_title('rho') ax2 = plt.subplot(142);ax2.set_title('g') ax3 = plt.subplot(143);ax3.set_title('P') ax4 = plt.subplot(144);ax4.set_title('T') plt.hold(True) for i in range(n_iter): # Keep track of the previous iteration for an idea of the uncertainty self.last_state = np.vstack((self.int_mass.copy(),self.radius.copy(), self.pressure.copy(), self.temperature.copy(),self.gravity.copy(), self.density.copy()) ) self.last_boundaries = self.boundaries.copy() self.last_icb_temp = self.boundary_temperatures[0] if verbose: print 'Initial'; self.print_state() # Calculate temperature and density before finding radii. if verbose: print 'Iteration #',i+1 # calculate temperature profile with consistent ICB temp if profile_type == 'adiabatic': self.compute_temperature() elif profile_type == 'isothermal': self.compute_temperature(inner_isotherm=False,outer_isotherm=False, mantle_isotherm=False) else: raise NameError('Invalid profile_type:'+profile_type) if verbose: print 'compute_temperature';self.print_state() self.evaluate_eos() if verbose: print 'evaluate_eos';self.print_state() # find radii from the calculated density profile. self.compute_radii() if verbose: print 'compute_radii';self.print_state() self.compute_boundaries() if verbose: print 'compute_boundaries';self.print_state() # compute gravity and pressure from radii self.compute_gravity() if verbose: print 'compute_gravity'; self.print_state() self.compute_pressure() if verbose: print 'compute_pressure';self.print_state() if plot==True: ax1.plot(self.radius, self.density) ax2.plot(self.radius, self.gravity) ax3.plot(self.radius, self.pressure) ax4.plot(self.radius, self.temperature) # compare differences between last two iterations present_state = np.vstack((self.int_mass,self.radius,self.pressure, self.temperature,self.gravity,self.density)) self.diff_state = present_state - self.last_state self.diff_mean = np.mean(self.diff_state,axis=1) self.diff_max = max_magnitude(self.diff_state,axis=1) self.diff_bounds = self.boundaries - self.last_boundaries self.diff_icb_temp = self.boundary_temperatures[0] - self.last_icb_temp # Check if snow encountered self.detect_snow() self.adiabat_steeper() # compute quantaties for energy/entropy budget # print diagnostiscs for last iteration if verbose: print 'Change during last iteration:' print 'mean: ', self.diff_mean print 'max: ', self.diff_max print 'boundaries: ', self.diff_bounds print 'ICB temp: ', self.diff_icb_temp if plot==True: plt.show()
def PlotTrendingAnalysis(site,marker,end): monitoring_out_path = output_file_path(site,'surficial',end = pd.to_datetime(end))['monitoring_output'] print_out_path = monitoring_out_path print_out_path2 = monitoring_out_path + 'TrendingPlots/' for path in [print_out_path,print_out_path2]: if not os.path.exists(path): os.makedirs(path) #### Get marker data df = get_latest_ground_df2(site,end) df = df.loc[df.crack_id == marker] ##### Get the data from the crack dataframe cur_t = (df.timestamp.values - df.timestamp.values[0])/np.timedelta64(1,'D') cur_x = df.meas.values ##### Interpolate the last 10 data points _,var = moving_average(cur_x) sp = UnivariateSpline(cur_t,cur_x,w=1/np.sqrt(var)) t_n = np.linspace(cur_t[0],cur_t[-1],1000) x_n = sp(t_n) v_n = sp.derivative(n=1)(t_n) a_n = sp.derivative(n=2)(t_n) v_s = abs(sp.derivative(n=1)(cur_t)) a_s = abs(sp.derivative(n=2)(cur_t)) ##### Federico et al. constants slope = 1.49905955613175 intercept = -3.00263765777028 t_crit = 4.53047399738543 var_v_log = 215.515369339559 v_log_mean = 2.232839766 sum_res_square = 49.8880017417971 n = 30. ##### Plotting Colors tableau20 = [(31, 119, 180), (174, 199, 232), (255, 127, 14), (255, 187, 120), (44, 160, 44), (152, 223, 138), (214, 39, 40), (255, 152, 150), (148, 103, 189), (197, 176, 213), (140, 86, 75), (196, 156, 148), (227, 119, 194), (247, 182, 210), (127, 127, 127), (199, 199, 199), (188, 189, 34), (219, 219, 141), (23, 190, 207), (158, 218, 229)] for i in range(len(tableau20)): r, g, b = tableau20[i] tableau20[i] = (r / 255., g / 255., b / 255.) ################# v_theo = np.linspace(min(v_s),max(v_s),10000) uncertainty = t_crit*np.sqrt(1/(n-2)*sum_res_square*(1/n + (np.log(v_theo) - v_log_mean)**2/var_v_log)) log_a_theo = slope * np.log(v_theo) + intercept log_a_theo_up = log_a_theo + uncertainty log_a_theo_down = log_a_theo - uncertainty a_theo = np.e**log_a_theo a_theo_up = np.e**log_a_theo_up a_theo_down = np.e**log_a_theo_down fig = plt.figure() fig.set_size_inches(15,8) fig.suptitle('{} Marker {} {}'.format(str(df.site_id.values[0]).upper(),str(df.crack_id.values[0]).title(),pd.to_datetime(df.timestamp.values[-1]).strftime("%b %d, %Y %H:%M"))) ax1 = fig.add_subplot(121) ax1.get_xaxis().tick_bottom() ax1.get_yaxis().tick_left() ax1.grid() l1 = ax1.plot(v_theo,a_theo,c = tableau20[0],label = 'Fukuzono (1985)') ax1.plot(v_theo,a_theo_up,'--',c = tableau20[0]) ax1.plot(v_theo,a_theo_down,'--', c = tableau20[0]) ax1.plot(v_s,a_s,c = tableau20[10]) l2 = ax1.plot(v_s[:-1],a_s[:-1],'o',c = tableau20[19],label = 'Previous') l3 = ax1.plot(v_s[-1],a_s[-1],'*',c = tableau20[6],label = 'Current') lns = l1 + l2 + l3 labs = [l.get_label() for l in lns] ax1.legend(lns,labs,loc = 'upper left',fancybox = True, framealpha = 0.5) ax1.set_xlabel('velocity (cm/day)') ax1.set_ylabel('acceleration (cm/day$^2$)') ax1.set_xscale('log') ax1.set_yscale('log') ax2 = fig.add_subplot(222) ax2.grid() ax2.plot(cur_t,cur_x,'.',c = tableau20[0],label = 'Data') ax2.plot(t_n,x_n,c = tableau20[12],label = 'Interpolation') ax2.legend(loc = 'upper left',fancybox = True, framealpha = 0.5) ax2.set_ylabel('disp (meters)') ax3 = fig.add_subplot(224, sharex = ax2) ax3.grid() ax3.plot(t_n,v_n, color = tableau20[4],label = 'Velocity') ax3.set_ylabel('velocity (cm/day)') ax3.set_xlabel('time (days)') ax3.legend(loc = 'upper left',fancybox = True, framealpha = 0.5) ax4 = ax3.twinx() ax4.plot(t_n,a_n,'-r',label = 'Acceleration') ax4.set_ylabel('acceleration (m/day$^2$)') ax4.legend(loc = 'upper right',fancybox = True, framealpha = 0.5) tsn = pd.to_datetime(df.timestamp.values[-1]).strftime("%Y-%m-%d_%H-%M-%S") out_filename = print_out_path2 + '{} {} {}'.format(tsn,str(df.site_id.values[0]),str(df.crack_id.values[0])) plt.savefig(out_filename,facecolor='w', edgecolor='w',orientation='landscape',mode='w',bbox_inches = 'tight')
def get_parameter_limits(xval, loglike, ul_confidence=0.95, tol=1E-3): """Compute upper/lower limits, peak position, and 1-sigma errors from a 1-D likelihood function. This function uses the delta-loglikelihood method to evaluate parameter limits by searching for the point at which the change in the log-likelihood value with respect to the maximum equals a specific value. A parabolic spline fit to the log-likelihood values is used to improve the accuracy of the calculation. Parameters ---------- xval : `~numpy.ndarray` Array of parameter values. loglike : `~numpy.ndarray` Array of log-likelihood values. ul_confidence : float Confidence level to use for limit calculation. tol : float Tolerance parameter for spline. """ deltalnl = onesided_cl_to_dlnl(ul_confidence) # EAC FIXME, added try block here b/c sometimes xval is np.nan try: spline = UnivariateSpline(xval, loglike, k=2, s=tol) except: print ("Failed to create spline: ", xval, loglike) return {'x0': np.nan, 'ul': np.nan, 'll': np.nan, 'err_lo': np.nan, 'err_hi': np.nan, 'err': np.nan, 'lnlmax': np.nan} # m = np.abs(loglike[1:] - loglike[:-1]) > delta_tol # xval = np.concatenate((xval[:1],xval[1:][m])) # loglike = np.concatenate((loglike[:1],loglike[1:][m])) # spline = InterpolatedUnivariateSpline(xval, loglike, k=2) sd = spline.derivative() imax = np.argmax(loglike) ilo = max(imax - 1, 0) ihi = min(imax + 1, len(xval) - 1) # Find the peak x0 = xval[imax] # Refine the peak position if np.sign(sd(xval[ilo])) != np.sign(sd(xval[ihi])): x0 = find_function_root(sd, xval[ilo], xval[ihi]) lnlmax = float(spline(x0)) fn = lambda t: spline(t) - lnlmax fn_val = fn(xval) if np.any(fn_val[imax:] < -deltalnl): xhi = xval[imax:][fn_val[imax:] < -deltalnl][0] else: xhi = xval[-1] if np.any(fn_val[:imax] < -deltalnl): xlo = xval[:imax][fn_val[:imax] < -deltalnl][-1] else: xlo = xval[0] ul = find_function_root(fn, x0, xhi, deltalnl) ll = find_function_root(fn, x0, xlo, deltalnl) err_lo = np.abs(x0 - find_function_root(fn, x0, xlo, 0.5)) err_hi = np.abs(x0 - find_function_root(fn, x0, xhi, 0.5)) if np.isfinite(err_lo): err = 0.5 * (err_lo + err_hi) else: err = err_hi o = {'x0': x0, 'ul': ul, 'll': ll, 'err_lo': err_lo, 'err_hi': err_hi, 'err': err, 'lnlmax': lnlmax} return o
def kernel(ell, nu, eig, fgong): """Returns a dict of structural kernels. I have tried to make this as notationally similar to Gough & Thompson (1991) as possible. Parameters ---------- ell: int The angular degree of the mode. nu: float The cyclic frequency of the mode. eig: np.array, shape(N,7) Eigenfrequency data for the mode, as produced by ADIPLS. fgong: dict Stellar model data in a dictionary, as per load_fgong() above. Returns ------- kernel: np.array, length N The density or sound speed structure kernel. """ omega = 2.*np.pi*nu # convert to cyclic frequency G = 6.672e-8 # gravitational constant L2 = ell*(ell+1) L = np.sqrt(L2) M, R = fgong['glob'][:2] # mass and radius from FGONG sigma = np.sqrt(R**3/G/M)*omega # dimensionless frequency ## unpack fgong file (c.f. page 6 section 2.1.3 of above doc) r = fgong['var'][::-1,0] # radial co-ordinate m = M*np.exp(fgong['var'][::-1,1]) # mass co-ordinate P = fgong['var'][::-1,3] # pressure rho = fgong['var'][::-1,4] # density Gamma1 = fgong['var'][::-1,9] # first adiabatic index cs2 = Gamma1*P/rho # square of the sound speed Y = 1 - fgong['var'][::-1,5] - fgong['var'][::-1,16] # helium abundance # Gamma_1,Y = ( partial ln Gamma_1 / partial ln Y ) _ {P, rho} etc Gamma_1rho = fgong['var'][::-1,25] Gamma_1p = fgong['var'][::-1,26] Gamma_1Y = fgong['var'][::-1,27] ## equilibrium model (c.f. ADIPLS - The Aarhus adi. osc. pack., section 2.1) A = fgong['var'][::-1,14] # 1/Gamma_1 (dln p / dln r) - (dln rho / dln r) A1 = (m/M)/(r/R)**3 # fractional volume Vg = (G*m*rho)/(Gamma1*P*r) drho_dr = -(Vg+A)*rho/r # density gradient ## unpack eigenfunction (c.f. page 7 of Notes on adi. osc. prog.) x = eig[:,0] # dimensionless radius (i.e. r/R) y1 = eig[:,1] # xi_r / R y2 = eig[:,2] # l(l+1)/R * xi_h y3 = eig[:,3] # -x * Phi' / (g * r) # y4 = eig[:,4] # x^2 * d/dx (y_3 / x) xi_r = y1*R # radial component of eigenfunction dxi_r_dr = np.hstack((0., np.diff(xi_r)/np.diff(r))) # chi is the "dilatation" if ell == 0: xi_h = 0.*xi_r # eta = G*m/r**3/omega**2 chi = Vg/x*(y1-sigma**2/A1/x*y2) elif ell > 0: xi_h = y2*R/L2 # eta = L2*G*m/r**3/omega**2 chi = Vg/x*(y1-y2*sigma**2/(A1*L2)-y3) else: raise ValueError('ell must be non-negative') # most stellar models include the central point, at which the # numerical value of chi and drho_dr might be buggy. chi[0] = 0. drho_dr[0] = 0. S = np.trapz((xi_r**2+L2*xi_h**2)*rho*r**2, r) ### Calculate c, rho pair # c.f. Gough & Thompson 1991 equation (60) K_c_rho = rho*cs2*chi**2*r**2 / (S*omega**2) # first compute the huge bracketed terms # in last two lines of equation (61) K_rho_c = (ell+1.)/r**ell*(xi_r-ell*xi_h) \ *integrate((rho*chi+xi_r*drho_dr)*r**(ell+2.), r) \ - ell*r**(ell+1.)*(xi_r+(ell+1.)*xi_h) \ *complement((rho*chi+xi_r*drho_dr)*r**(1.-ell), r) # then combine it with the rest K_rho_c = -0.5*(xi_r**2+L2*xi_h**2)*rho*omega**2*r**2 \ +0.5*rho*cs2*chi**2*r**2 \ -G*m*(chi*rho+0.5*xi_r*drho_dr)*xi_r \ -4*np.pi*G*rho*r**2*complement((chi*rho+0.5*xi_r*drho_dr)*xi_r, r) \ +G*m*rho*xi_r*dxi_r_dr \ +0.5*G*(m*drho_dr+4.*np.pi*r**2*rho**2)*xi_r**2 \ -4*np.pi*G*rho/(2.*ell+1.)*K_rho_c K_rho_c = K_rho_c / (S*omega**2) ### Calculate c^2, rho pair # d(c^2)/c^2 = 2 * d(c)/c # so K_c2_rho = K_c_rho / 2 K_c2_rho = K_c_rho / 2. K_rho_c2 = K_rho_c ### Calculate Gamma_1, rho pair # K_Gamma1_rho = K_c2_rho (c.f. Basu, Studying Stars 2011, eq 3.20) # K_rho_Gamma1 (c.f. InversionKit v. 2.2, eq. 105) K_rho_Gamma1 = K_rho_c2 integrand = Gamma1*chi**2*r**2 / (2*S*omega**2) first_int = integrate(integrand , r) second_int = complement(4*np.pi*G*rho/r**2*integrate(integrand, r), r) K_Gamma1_rho = K_rho_c2 - K_c2_rho + G*m*rho/r**2 * \ first_int + rho*r**2 * second_int ### Calculate u, Y pair # K_Y_u = Gamma_1,Y * K_Gamma1_rho (c.f. Basu & Chaplin 2016, eq 10.40) # K_u_Y = P * d(P^-1 psi)/dr + Gamma_1,p * K_Gamma1_rho # where psi is obtained by solving # d[psi(r)]/dr - 4 pi G rho r^2 int_r^R rho/(r^2 P) psi dr = -z(r) # z(r) = K_rho_Gamma1 + (Gamma_1,p + Gamma_1,rho) K_Gamma1_rho K_Y_u = Gamma_1Y * K_Gamma1_rho z = K_rho_Gamma1 + ( Gamma_1p + Gamma_1rho ) * K_Gamma1_rho rho_spl = UnivariateSpline(r, rho) P_spl = UnivariateSpline(r, P) z_spl = UnivariateSpline(r, z) drho = rho_spl.derivative() dz = z_spl.derivative() def bvp(t, psi): # psi'' + a(r) psi' + b(r) psi = f(r) # where # a(r) = P/rho (r rho' - 2 rho) # b(r) = -P/rho [ 1 / ( 4 pi G r^2 rho ) ] # f(r) = P/rho ( z r rho' - rho r z' + 2 z rho ) # rearrange into y_1' = y_2 # y_2' = f(t) - a(t) y_2 - b(t) psi # remesh onto variable x from r rhot = rho_spl(t) Pt = P_spl(t) zt = z_spl(t) # differentiate with respect to x drhot = drho(t) dzt = dz(t) # calculate variables on mesh x #Prhot = Pt / rhot #at = Prhot * ( t * rhot - 2 * rhot ) #bt = - Prhot * ( 1 / ( 4 * np.pi * G * t**2 * rhot ) ) #ft = Prhot * ( zt * t * drhot - \ # rhot * x * dzt + \ # 2 * zt * rhot ) drhorho = drhot / rhot at = drhorho - 2 / t bt = 4 * np.pi * G * t * rhot**2 / Pt ft = zt * (2/t + drhorho) - dzt return np.vstack(( psi[1], ft - at * psi[1] - bt * psi[0] )) result = solve_bvp(bvp, lambda ya, yb: np.array([ ya[0]-1, yb[0]-1 ]), r, np.array([ np.ones(len(r)), np.ones(len(r)) ]), max_nodes=1000000)#, tol=1e-5) #def dpsi_dr(psi, s): # return 4*np.pi*G * np.interp(s, r, rho) * s**2 \ # * trapz(rho[r>=s] / (r[r>=s]**2 * P[r>=s]) * psi, r[r>=s]) \ # - ( np.interp(s, r, K_rho_Gamma1) \ # + ( np.interp(s, r, Gamma_1p) + np.interp(s, r, Gamma_1rho) ) \ # * np.interp(s, r, K_Gamma1_rho) \ # ) #psi = odeint(dpsi_dr, 1.0, r).T[0] #print(psi) #def dpsi_dr(r2, psi): # print('r2 == r', np.all(r2 == r)) # psi = psi[0] # print('len(psi) == len(r)', len(psi) == len(r)) # return np.vstack((4*np.pi*G*rho*r**2 \ # * complement(rho/(r**2*P)*psi, r) \ # + ( K_rho_Gamma1 + ( Gamma_1p + Gamma_1rho ) * K_Gamma1_rho ))).T #def dpsi_dr(r2, psi): # psi = psi[0] # return np.vstack((4*np.pi*G*np.interp(r2, r, rho)*r2**2 \ # * complement(np.interp(r2, r, rho)/(r2**2*np.interp(r2,r,P))*psi, r2) \ # + ( np.interp(r2, r, K_rho_Gamma1) + ( np.interp(r2, r, Gamma_1p) \ # + np.interp(r2, r, Gamma_1rho) ) * np.interp(r2, r, K_Gamma1_rho) ))).T ##psi = np.zeros(len(r)) ##psi[0] = r[0] * f(0, 0) ##for ii in range(1, len(r)): ## h = r[ii] - r[ii-1] ## psi[ii] = psi[ii-1] + h * f(psi[ii-1], ii-1) ##print(psi) #def resid(psi): # return np.gradient(psi, r) - f(psi) #result = solve_bvp(dpsi_dr, # lambda ya,yb: np.array([ (ya[0]-1)**2 + (yb[0]-1)**2 ]), # r, [np.ones(len(r))], max_nodes=100000, tol=1e-9) # dPsi1_dr = 4 pi G r^2 rho Psi_2 + # [ K_rho_Gamma1 + ( Gamma_1P + Gamma_1rho ) * K_Gamma1_rho ] # dPsi2_dr = -rho/(r^2 P) Psi_1 #def bvp(t, psi): # rhot = rho_spl(t) # psi1 = 4 * np.pi * G * rhot * t**2 * psi[1] + z_spl(t) # psi2 = - rhot / (t * P_spl(t)) * psi[0] # return np.vstack(( psi1, psi2 )) #result = solve_bvp(bvp, # lambda ya, yb: np.array([ ya[0]-1, yb[0]-1 ]), # r, # np.array([ np.ones(len(r)), np.zeros(len(r)) ]), # max_nodes=100000000, tol=1e-4) # def bvp(t, psi): # rhot = rho_spl(t) # dpsi = 4 * np.pi * G * rhot * t**2 \ # * complement(rhot / ( t**2 * P_spl(t) ) * psi[0], t) - z_spl(t) # print('dpsi', dpsi) # return np.vstack(( dpsi )).T # result = solve_bvp(bvp, # lambda ya, yb: np.array([ yb[0]-1 ]), # r, # np.array([ np.ones(len(x)) ]), # max_nodes=100000000, tol=1e-3) #result = solve_bvp(dPsi2_dr2, # lambda ya, yb: np.array([ (ya[0]-1)**2, (yb[0]-1)**2 ]), # r, [ np.ones(len(r)), np.zeros(len(r)) ], # max_nodes=1e6)#, tol=1e-5) print(result) psi = result.sol(r)[0] #interp1d(result['x'], result['y'][0])(r) print('psi', psi) #result = least_squares(resid, np.ones(len(r))) #print(result) #psi = result['x'] #psi = minimize(sqdiff, np.ones(len(r)), method='Nelder-Mead')['x'] K_u_Y = P * UnivariateSpline(P**-1 * psi, r).derivative()(r) \ + Gamma_1p * K_Gamma1_rho return { ('c', 'rho'): (K_c_rho, K_rho_c2), ('c2', 'rho'): (K_c2_rho, K_rho_c2), ('Gamma1', 'rho'): (K_Gamma1_rho, K_rho_Gamma1), ('u', 'Y'): (K_u_Y, K_Y_u), ('psi', 'psi'): (psi, psi) }
# continue #data splicing cur_t = t[i-num_pts:i] cur_x = x[i-num_pts:i] cur_timestamp = timestamp[i-num_pts:i] #data spline try: #Take the gaussian average of data points and its variance _,var = moving_average(cur_x) sp = UnivariateSpline(cur_t,cur_x,w=c/np.sqrt(var)) t_n = np.linspace(cur_t[0],cur_t[-1],1000) #spline results x_n = sp(t_n) v_n = sp.derivative(n=1)(t_n) a_n = sp.derivative(n=2)(t_n) #compute for velocity (cm/day) vs. acceleration (cm/day^2) in log axes x_s = sp(cur_t) v_s = abs(sp.derivative(n=1)(cur_t) * 100) a_s = abs(sp.derivative(n=2)(cur_t) * 100) except: print "Interpolation Error {}".format(pd.to_datetime(str(cur_timestamp[-1])).strftime("%m/%d/%Y %H:%M")) x_n = np.ones(len(t_n))*np.nan v_n = np.ones(len(t_n))*np.nan a_n = np.ones(len(t_n))*np.nan x_s = np.ones(len(cur_t))*np.nan v_s = np.ones(len(cur_t))*np.nan a_s = np.ones(len(cur_t))*np.nan
def interpolate_derivative(xdat, ydat): # make data less exact/more crude spl = UnivariateSpline(xdat, ydat, k=4,s=0) roots = spl.derivative().roots() yfit = spl(xdat) return yfit, roots
from scipy.interpolate import UnivariateSpline from EOS import rho, cp from const import * from ext_data import opac for i in range (0, z.size): FconvArr[i] = Fconv(T[i], P[i], z[i]) FradArr[i] = Frad(T[i], P[i], z[i]) rhoArr[i] = rho(T[i], P[i], z[i]) cpArr[i] = cp(T[i], P[i]) opacArr[i] = opac(T[i],rhoArr[i]) F = FconvArr+FradArr F_spline = UnivariateSpline(z, F, s=0) dFdz = F_spline.derivative() dFdz = dFdz(z) #dFdz = np.diff(F)/h #dFdz = np.append(dFdz, dFdz[dFdz.size-1]) # semi-implicitni metoda pro casovy prirustek #d_main = np.empty(500) #d_sub = np.zeros(500) #d_sup = np.zeros(500) #b = np.zeros(500) # #h = 25000 #grid spacing # #Bz0 = np.sqrt(8e-7*np.pi*(bcg.P[499]-P[499]))
def _autofocus(self, seconds, focus_range, focus_step, thumbnail_size, keep_files, dark_thumb, merit_function, merit_function_kwargs, coarse, plots, start_event, finished_event, smooth=0.4, *args, **kwargs): # If passed a start_event wait until Event is set before proceeding # (e.g. wait for coarse focus to finish before starting fine focus). if start_event: start_event.wait() initial_focus = self.position if coarse: self.logger.debug( "Beginning coarse autofocus of {} - initial position: {}", self._camera, initial_focus) else: self.logger.debug( "Beginning autofocus of {} - initial position: {}", self._camera, initial_focus) # Set up paths for temporary focus files, and plots if requested. image_dir = self.config['directories']['images'] start_time = current_time(flatten=True) file_path_root = "{}/{}/{}/{}".format(image_dir, 'focus', self._camera.uid, start_time) # Take an image before focusing, grab a thumbnail from the centre and add it to the plot file_path = "{}/{}_{}.{}".format(file_path_root, initial_focus, "initial", self._camera.file_extension) thumbnail = self._camera.get_thumbnail(seconds, file_path, thumbnail_size, keep_file=True) if plots: thumbnail = images.mask_saturated(thumbnail) if dark_thumb is not None: thumbnail = thumbnail - dark_thumb fig = plt.figure(figsize=(9, 18), tight_layout=True) ax1 = fig.add_subplot(3, 1, 1) im1 = ax1.imshow(thumbnail, interpolation='none', cmap=palette, norm=colours.LogNorm()) fig.colorbar(im1) ax1.set_title('Initial focus position: {}'.format(initial_focus)) # Set up encoder positions for autofocus sweep, truncating at focus travel # limits if required. if coarse: focus_range = focus_range[1] focus_step = focus_step[1] else: focus_range = focus_range[0] focus_step = focus_step[0] focus_positions = np.arange(max(initial_focus - focus_range / 2, self.min_position), min(initial_focus + focus_range / 2, self.max_position) + 1, focus_step, dtype=np.int) n_positions = len(focus_positions) metric = np.empty((n_positions)) for i, position in enumerate(focus_positions): # Move focus, updating focus_positions with actual encoder position after move. focus_positions[i] = self.move_to(position) # Take exposure file_path = "{}/{}_{}.{}".format(file_path_root, focus_positions[i], i, self._camera.file_extension) thumbnail = self._camera.get_thumbnail( seconds, file_path, thumbnail_size, keep_file=keep_files) thumbnail = images.mask_saturated(thumbnail) if dark_thumb is not None: thumbnail = thumbnail - dark_thumb # Calculate focus metric metric[i] = images.focus_metric(thumbnail, merit_function, **merit_function_kwargs) self.logger.debug("Focus metric at position {}: {}".format(position, metric[i])) fitted = False # Find maximum values imax = metric.argmax() if imax == 0 or imax == (n_positions - 1): # TODO: have this automatically switch to coarse focus mode if this happens self.logger.warning( "Best focus outside sweep range, aborting autofocus on {}!".format(self._camera)) best_focus = focus_positions[imax] elif not coarse: # Crude guess at a standard deviation for focus metric, 40% of the maximum value weights = np.ones(len(focus_positions)) / (smooth * metric.max()) # Fit smoothing spline to focus metric data fit = UnivariateSpline(focus_positions, metric, w=weights, k=4, ext='raise') try: stationary_points = fit.derivative().roots() except ValueError as err: self.logger.warning('Error finding extrema of spline fit: {}'.format(err)) best_focus = focus_positions[imax] else: extrema = fit(stationary_points) if len(extrema) > 0: best_focus = stationary_points[extrema.argmax()] fitted = True else: # Coarse focus, just use max value. best_focus = focus_positions[imax] if plots: ax2 = fig.add_subplot(3, 1, 2) ax2.plot(focus_positions, metric, 'bo', label='{}'.format(merit_function)) if fitted: fs = np.arange(focus_positions[0], focus_positions[-1] + 1) ax2.plot(fs, fit(fs), 'b-', label='Smoothing spline fit') ax2.set_xlim(focus_positions[0] - focus_step / 2, focus_positions[-1] + focus_step / 2) u_limit = 1.10 * metric.max() l_limit = min(0.95 * metric.min(), 1.05 * metric.min()) ax2.set_ylim(l_limit, u_limit) ax2.vlines(initial_focus, l_limit, u_limit, colors='k', linestyles=':', label='Initial focus') ax2.vlines(best_focus, l_limit, u_limit, colors='k', linestyles='--', label='Best focus') ax2.set_xlabel('Focus position') ax2.set_ylabel('Focus metric') if coarse: ax2.set_title('{} coarse focus at {}'.format(self._camera, start_time)) else: ax2.set_title('{} fine focus at {}'.format(self._camera, start_time)) ax2.legend(loc='best') final_focus = self.move_to(best_focus) file_path = "{}/{}_{}.{}".format(file_path_root, final_focus, "final", self._camera.file_extension) thumbnail = self._camera.get_thumbnail(seconds, file_path, thumbnail_size, keep_file=True) if plots: thumbnail = images.mask_saturated(thumbnail) if dark_thumb is not None: thumbnail = thumbnail - dark_thumb ax3 = fig.add_subplot(3, 1, 3) im3 = ax3.imshow(thumbnail, interpolation='none', cmap=palette, norm=colours.LogNorm()) fig.colorbar(im3) ax3.set_title('Final focus position: {}'.format(final_focus)) if coarse: plot_path = file_path_root + '_coarse.png' else: plot_path = file_path_root + '_fine.png' fig.savefig(plot_path) plt.close(fig) if coarse: self.logger.info('Coarse focus plot for camera {} written to {}'.format( self._camera, plot_path)) else: self.logger.info('Fine focus plot for camera {} written to {}'.format( self._camera, plot_path)) self.logger.debug( 'Autofocus of {} complete - final focus position: {}', self._camera, final_focus) if finished_event: finished_event.set() return initial_focus, final_focus
secondterm = np.cross(n, np.cross(n - v, a) ) / (1-np.dot(n,v))**3 / R E = firstterm + secondterm B = np.cross(n,E) return {'E': E, 'B', B} times = np.linspace(0,100,1000) tauguess = 0. for time in times: sol = optimize.root(properinterval, tauguess,args=(fieldx,fieldy,fieldz,time)) soltau = sol.x tauguess = soltau rRet = np.array([xs(tau),ys(tau),zs(tau)]) #dtdtau = ts.derivative()(tau) #v = np.array([xs.derivative()(tau),ys.derivative()(tau),zs.derivative()(tau) ]) / dtdtau v = np.array([xts.derivative()(time),yts.derivative()(time) ,zts.derivative()(time)]) a = np.array([xts.derivative(2)(time),yts.derivative(2)(time) ,zts.derivative(2)(time)]) myEB = EB(fieldr,rRet,v, a) E = myEB.E B = myEB.B S = np.cross(E,B) print soltau #for light, x=t x =-t plt.plot(t,t+fieldx-fieldt) plt.plot(t,-t-fieldx+fieldt) plt.show()
def get_parameter_limits(xval, loglike, cl_limit=0.95, cl_err=0.68269, tol=1E-2, bounds=None): """Compute upper/lower limits, peak position, and 1-sigma errors from a 1-D likelihood function. This function uses the delta-loglikelihood method to evaluate parameter limits by searching for the point at which the change in the log-likelihood value with respect to the maximum equals a specific value. A cubic spline fit to the log-likelihood values is used to improve the accuracy of the calculation. Parameters ---------- xval : `~numpy.ndarray` Array of parameter values. loglike : `~numpy.ndarray` Array of log-likelihood values. cl_limit : float Confidence level to use for limit calculation. cl_err : float Confidence level to use for two-sided confidence interval calculation. tol : float Absolute precision of likelihood values. Returns ------- x0 : float Coordinate at maximum of likelihood function. err_lo : float Lower error for two-sided confidence interval with CL ``cl_err``. Corresponds to point (x < x0) at which the log-likelihood falls by a given value with respect to the maximum (0.5 for 1 sigma). Set to nan if the change in the log-likelihood function at the lower bound of the ``xval`` input array is less than than the value for the given CL. err_hi : float Upper error for two-sided confidence interval with CL ``cl_err``. Corresponds to point (x > x0) at which the log-likelihood falls by a given value with respect to the maximum (0.5 for 1 sigma). Set to nan if the change in the log-likelihood function at the upper bound of the ``xval`` input array is less than the value for the given CL. err : float Symmetric 1-sigma error. Average of ``err_lo`` and ``err_hi`` if both are defined. ll : float Lower limit evaluated at confidence level ``cl_limit``. ul : float Upper limit evaluated at confidence level ``cl_limit``. lnlmax : float Log-likelihood value at ``x0``. """ dlnl_limit = onesided_cl_to_dlnl(cl_limit) dlnl_err = twosided_cl_to_dlnl(cl_err) try: # Pad the likelihood function # if len(xval) >= 3 and np.max(loglike) - loglike[-1] < 1.5*dlnl_limit: # p = np.polyfit(xval[-3:], loglike[-3:], 2) # x = np.linspace(xval[-1], 10 * xval[-1], 3)[1:] # y = np.polyval(p, x) # x = np.concatenate((xval, x)) # y = np.concatenate((loglike, y)) # else: x, y = xval, loglike spline = UnivariateSpline(x, y, k=2, #k=min(len(xval) - 1, 3), w=(1 / tol) * np.ones(len(x))) except: print("Failed to create spline: ", xval, loglike) return {'x0': np.nan, 'ul': np.nan, 'll': np.nan, 'err_lo': np.nan, 'err_hi': np.nan, 'err': np.nan, 'lnlmax': np.nan} sd = spline.derivative() imax = np.argmax(loglike) ilo = max(imax - 1, 0) ihi = min(imax + 1, len(xval) - 1) # Find the peak x0 = xval[imax] # Refine the peak position if np.sign(sd(xval[ilo])) != np.sign(sd(xval[ihi])): x0 = find_function_root(sd, xval[ilo], xval[ihi]) lnlmax = float(spline(x0)) def fn(t): return spline(t) - lnlmax fn_val = fn(xval) if np.any(fn_val[imax:] < -dlnl_limit): xhi = xval[imax:][fn_val[imax:] < -dlnl_limit][0] else: xhi = xval[-1] # EAC: brute force check that xhi is greater than x0 # The fabs is here in case x0 is negative if xhi <= x0: xhi = x0 + np.fabs(x0) if np.any(fn_val[:imax] < -dlnl_limit): xlo = xval[:imax][fn_val[:imax] < -dlnl_limit][-1] else: xlo = xval[0] # EAC: brute force check that xlo is less than x0 # The fabs is here in case x0 is negative if xlo >= x0: xlo = x0 - 0.5*np.fabs(x0) ul = find_function_root(fn, x0, xhi, dlnl_limit, bounds=bounds) ll = find_function_root(fn, x0, xlo, dlnl_limit, bounds=bounds) err_lo = np.abs(x0 - find_function_root(fn, x0, xlo, dlnl_err, bounds=bounds)) err_hi = np.abs(x0 - find_function_root(fn, x0, xhi, dlnl_err, bounds=bounds)) err = np.nan if np.isfinite(err_lo) and np.isfinite(err_hi): err = 0.5 * (err_lo + err_hi) elif np.isfinite(err_hi): err = err_hi elif np.isfinite(err_lo): err = err_lo o = {'x0': x0, 'ul': ul, 'll': ll, 'err_lo': err_lo, 'err_hi': err_hi, 'err': err, 'lnlmax': lnlmax} return o
s_0_5_6 = lut.sp[0,:,0,5,6] s,n = nanmasked(s_0_5_6) snorm = norm2max(s_0_5_6) [i1000,i1077,i1493,i1600,i1200,i1300,i530,i610, i1565,i1634,i1193,i1198,i1236,i1248,i1270,i1644, i1050,i1040,i1065,i600,i870,i515] = find_closest(lut.wvl,np.array([1000,1077,1493,1600,1200,1300,530, 610,1565,1634,1193,1198,1236,1248, 1270,1644,1050,1040,1065,600,870,515])) norm2 = s_0_5_6/s_0_5_6[i1000] dsp = smooth(np.gradient(norm2,lut.wvl/1000.),2) # <codecell> norm2_uni = UnivariateSpline(lut.wvl/1000.0,norm2,k=5) norm2_uni.set_smoothing_factor(1) dnorm2 = norm2_uni.derivative() # <codecell> norm2_bspline = splrep(lut.wvl/1000.0,norm2,k=5) norm2_b = splev(lut.wvl/1000.0,norm2_bspline,der=0) dbnorm2 = splev(lut.wvl/1000.0,norm2_bspline,der=1) # <codecell> dsp2 = smooth(deriv(norm2,lut.wvl/1000.),2) # <codecell> plt.figure() plt.plot(lut.wvl,norm2)
fa = a.reshape(-1,a.shape[-1]) fo = np.zeros([fa.shape[0],nbin]) for i in range(len(fa)): fo[i] = np.bincount(pix, fa[i], minlength=nbin) return fo.reshape(a.shape[:-1]+(nbin,)) # Gapfill poltod in regions with far too few hits, to # avoid messing up the poltod power spectrum mask = poldiv[0,0] < np.mean(poldiv[0,0])*0.1 for i in range(poltod.shape[0]): poltod[i] = gapfill.gapfill_copy(poltod[i], rangelist.Rangelist(mask)) # Calc phase which is equal to az while az velocity is positive # and 2*max(az) - az while az velocity is negative x = np.arange(len(az)) az_spline = UnivariateSpline(x, az, s=1e-4) daz = az_spline.derivative(1)(x) ddaz = az_spline.derivative(2)(x) phase = az.copy() phase[daz<0] = 2*np.max(az)-az[daz<0] # Bin by az and phase apix = build_bins(az, nbin) ppix = build_bins(phase, nbin) for i, pix in enumerate([apix, ppix]): tod_eq.rhs[i] += bin_by_pix(polrhs, pix, nbin) tod_eq.div[i] += bin_by_pix(poldiv, pix, nbin) acc_eq.rhs[i] += bin_by_pix(ddaz, pix, nbin) acc_eq.div[i] += bin_by_pix(1, pix, nbin) for j in range(ndet): di = d.dets[j] det_eq.rhs[i,di] += bin_by_pix(d.tod[j]*weight[j], pix, nbin) det_eq.div[i,di] += bin_by_pix(weight[j], pix, nbin)
import matplotlib.pyplot as plt N=100 v = .5 t = np.linspace(0,50,N) x = t * v y = np.zeros(N) z = np.zeros(N) #find splines xs = UnivariateSpline(t, x, s=1) ys = UnivariateSpline(t, y, s=1) zs = UnivariateSpline(t, z, s=1) dxdt = xs.derivative()(t) dydt = ys.derivative()(t) dzdt = zs.derivative()(t) gamma = np.sqrt(1 - dxdt**2 - dydt**2 - dzdt**2) tau = integrate.cumtrapz(gamma, t) tau = np.insert(tau,0,0.) plt.figure() plt.plot(t,tau) plt.figure() plt.plot(t,x) plt.show()
def preprocess(filename, num_resamplings = 25): # read data #filename = "../data/MarieTherese_jul31_and_Aug07_all.pkl" pkl_file = open(filename, 'rb') data1 = cPickle.load(pkl_file) num_strokes = len(data1) # get the unique stroke labels, map to class labels (ints) for later using dictionary stroke_dict = dict() value_index = 0 for i in range(0,num_strokes): current_key = data1[i][0] if current_key not in stroke_dict: stroke_dict[current_key] = value_index value_index = value_index + 1 # save the dictionary to file, for later use dict_filename = "../data/stroke_label_mapping.pkl" dict_file = open(dict_filename, 'wb') pickle.dump(stroke_dict, dict_file) # - smooth data # for each stroke, get the vector of data, smooth/interpolate it over time, store sampling from smoothed signal in vector # - sample at regular intervals (1/30 of total time, etc.) -> input vector X num_params = len(data1[0][1][0]) #accelx, accely, etc. #num_params = 16 #accelx, accely, etc. # re-sample the interpolated spline this many times (25 or so seems ok, since most letters have this many points) # build an output array large enough to hold the vectors for each stroke and the (unicode -> int) stroke value (1 elts) # output_array = np.zeros((num_strokes, (num_resamplings_2 + num_resamplings) * num_params + 1)) output_array = np.zeros((num_strokes, (5 * num_resamplings) * num_params + 1)) print output_array.size print filename print num_params print num_resamplings_2 print for i in range(0, num_strokes): # how far? if (i % 100 == 0): print float(i)/num_strokes X_matrix = np.zeros((num_params, num_resamplings * 5)) # the array to store in (using original data and 2 derivs, 2 integrals) # the array to store reshaped resampled vector in X_2_vector_scaled = np.zeros((num_params, num_resamplings_2)) # the array to store the above 2 concatenated # concatenated_X_X_2 = np.zeros((num_params, num_resamplings_2 + num_resamplings)) concatenated_X_X_2 = np.zeros((num_params, num_resamplings * 5)) # the array to store in (using original data and 2 derivs, 2 integrals) # for each parameter (accelX, accelY, ...) # map the unicode character to int curr_stroke_val = stroke_dict[data1[i][0]] #print(len(curr_stroke)) #print(curr_stroke[0]) #print(curr_stroke[1]) curr_data = data1[i][1] # fix if too short for interpolation - pad current data with 3 zeros if(len(curr_data) <= 3): curr_data = np.concatenate([curr_data, np.zeros((3,num_params))]) time = np.arange(0, len(curr_data), 1) # the sample 'times' (0 to number of samples) time_new = np.arange(0, len(curr_data), float(len(curr_data))/num_resamplings) # the resampled time points for j in range(0, num_params): # iterate through parameters signal = curr_data[:,j] # one signal (accelx, etc.) to interpolate # interpolate the signal using a spline or so, so that arbitrary points can be used # (~30 seems reasonable based on data, for example) #tck = interpolate.splrep(time, signal, s=0) # the interpolation represenation tck = UnivariateSpline(time, signal, s=0) # sample the interpolation num_resamplings times to get values # resampled_data = interpolate.splev(time_new, tck, der=0) # the resampled data resampled_data = tck(time_new) # scale data (center, norm) resampled_data = preprocessing.scale(resampled_data) # first integral tck.integral = tck.antiderivative() resampled_data_integral = tck.integral(time_new) # scale data (center, norm) resampled_data_integral = preprocessing.scale(resampled_data_integral) # 2nd integral tck.integral_2 = tck.antiderivative(2) resampled_data_integral_2 = tck.integral_2(time_new) # scale data (center, norm) resampled_data_integral_2 = preprocessing.scale(resampled_data_integral_2) # first deriv tck.deriv = tck.derivative() resampled_data_deriv = tck.deriv(time_new) # scale resampled_data_deriv = preprocessing.scale(resampled_data_deriv) # second deriv tck.deriv_2 = tck.derivative(2) resampled_data_deriv_2 = tck.deriv_2(time_new) #scale resampled_data_deriv_2 = preprocessing.scale(resampled_data_deriv_2) # concatenate into one vector concatenated_resampled_data = np.concatenate((resampled_data, resampled_data_integral, resampled_data_integral_2, resampled_data_deriv, resampled_data_deriv_2)) # store for the correct parameter, to be used later as part of inputs to SVM X_matrix[j] = concatenated_resampled_data # while we're at it, square vector of resampled data to get a matrix, vectorize the matrix, and store # for each X in list, multiply X by itself -> X_2 #- vectorize X^2 (e.g. 10 x 10 -> 100 dimensions) # X_2_matrix = np.outer(concatenated_resampled_data, concatenated_resampled_data) # temp matrix for outer product # X_2_vector = np.reshape(X_2_matrix, -1) # reshape into a vector #- center and normalize X^2 by mean and standard deviation # X_2_vector_scaled[j] = preprocessing.scale(X_2_vector) #- concatenate with input X -> 110 dimensions # concatenated_X_X_2[j] = np.concatenate([X_matrix[j], X_2_vector_scaled[j]]) # FOR NOW, ONLY USE X, NOT OUTER PRODUCT concatenated_X_X_2[j] = X_matrix[j] # NOTE, THIS SHOULD REALLY JUST BE A BIG VECTOR FOR EACH STROKE, SO RESHAPE BEFORE ADDING TO OUTPUT LIST # ALSO, THE STROKE VALUE SHOULD BE ADDED this_sample = np.concatenate((np.reshape(concatenated_X_X_2, -1), np.array([curr_stroke_val]))) concatenated_samples = np.reshape(this_sample, -1) # ADD TO OUTPUT ARRAY output_array[i] = concatenated_samples print(output_array.size) return(output_array)