def integrate(self, lo, up, points=None, function=None): """Integrate between lo and up of the values Arguments: lo,up (float or array): lower/upper bound of integration function (function or None): function applied to va;lues before integration Returns: float: the integral """ if function is None: tck = self.tck() else: points = self.get_points( points=points, error= 'points need to be specified in order to integrate a function along the spline!' ) values = function(self.get_values(points=points)) #tck = splrep(points, values, t = self._knots, task = -1, k = self.degree); tck = splrep(points, values, k=self.degree) if isinstance(lo, np.ndarray): if len(up) != len(lo): raise ValueError( 'lower and upper bounds expected to have same shape!') return np.array( [splint(lo[i], up[i], tck) for i in range(len(lo))]) else: return splint(lo, up, tck)
def setGrid(self): from scipy import interpolate x0 = numpy.logspace(-3,1,81) etas = numpy.linspace(0.,2.,21) qs = numpy.linspace(0.2,1.,17) grid1 = numpy.empty((x0.size,x0.size,etas.size,qs.size)) grid2 = numpy.empty(grid1.shape) for i in range(qs.size): q = qs[i] q2 = q**2 b = 1-q2 for j in range(etas.size): eta = etas[j] g = 0.5*eta-1. # g = -1*gamma for k in range(x0.size): x = x0[k] for l in range(x0.size): y = x0[l] qb = ((2*x*y)/b)**g # q_bar qt = q*(x*y)**0.5/b # q_tilde sb = 0.5*(x/y - y/x) + s**2*b/(2*x*y) nu1 = s**2*b/(2*x*y) nu2 = nu1+ 0.5*b*(x/y + y/(x*q2)) nu = numpy.logspace(nu1,nu2,1001) mu = nu-sb t = (1+mu**2)**0.5 f1 = (t-mu)**0.5/t f2 = (t+mu)**0.5/t ng = nu**g I1 = interpolate.splrep(nu,f1*ng) I2 = interpolate.splrep(nu,f2*ng) grid1[k,l,i,j] = qt*interpolate.splint(nu1,nu2,I1) grid2[k,l,i,j] = qt*interpolate.splint(nu1,nu2,I2) pylab.imshow(grid1[:,:,i,j]) pylab.show()
def rho(z0, rhopar, pop, gp): vec = rhopar rho_at_rhalf = vec[0] vec = vec[1:] # get spline representation on gp.xepol, where rhopar are defined on spline_n = nr(gp.xepol, vec, pop, gp) # and apply it to these radii, which may be anything in between zs = np.log(z0/gp.Xscale[pop]) # have to integrate in d log(r) logrright = []; logrleft = [] if np.rank(zs) == 0: if zs>0: logrright.append(zs) else: logrleft.append(zs) else: logrright = zs[(zs>=0.)] logrleft = zs[(zs<0.)] logrleft = logrleft[::-1] # inverse order # integrate to left and right of halflight radius logrhoright = [] for i in np.arange(0, len(logrright)): logrhoright.append(np.log(rho_at_rhalf) + \ splint(0., logrright[i], spline_n)) # integration along dlog(r) instead of dr logrholeft = [] for i in np.arange(0, len(logrleft)): logrholeft.append(np.log(rho_at_rhalf) + \ splint(0., logrleft[i], spline_n)) tmp = np.exp(np.hstack([logrholeft[::-1], logrhoright])) # still defined on log(r) gh.checkpositive(tmp, 'rho()') return tmp
def energy_compute(abscissa, function): hbar = 1 omega = 1 m = 1 a = -5. b = 5. #interpolations tck_true = interpolate.splrep(abscissa, function, k=3, s=0) #W.F. tck_true_carre = interpolate.splrep(abscissa, function * function, k=3, s=0) #W.F. squared tck_true_x = interpolate.splrep(abscissa, abscissa * abscissa * function * function, k=3, s=0) #W.F. squared*x^2 der_true = interpolate.splev(abscissa, tck_true, der=1) #W.F. derivative tck_true_der = interpolate.splrep(abscissa, der_true * der_true, k=3, s=0) #W.F. derivative spline 1000 int_true_carre = interpolate.splint( a, b, tck_true_carre) #integral of W.F. squared int_true_x = interpolate.splint( a, b, tck_true_x) #integral of W.F. squared*x^2 (<x^2>) int_true_der = interpolate.splint( a, b, tck_true_der) #integral of derivative squared #energy Energy = ((-pow(hbar, 2) / (2 * m)) * (function[-1] * der_true[-1] - function[0] * der_true[0] - int_true_der) + 0.5 * m * omega * int_true_x) / int_true_carre return Energy
def radialConvolve(r, f, sigma, fk=100, fr=1): from scipy.special import j0 import special_functions as sf #mod = splrep(r,f,s=0,k=1) #norm = splint(r[0],r[-1],mod) r0 = r.copy() f0 = f.copy() r = r / sigma sigma = 1. kmin = numpy.log10(r.max()) * -1 kmax = numpy.log10(r.min()) * -1 k = numpy.logspace(kmin, kmax, r.size * fr) a = k * 0. for i in range(k.size): bessel = j0(r * k[i]) A = splrep(r, r * bessel * f, s=0, k=1) a[i] = splint(0., r[-1], A) a0 = (2. * pi * sigma**2)**-0.5 b = a0 * sigma * numpy.exp(-0.5 * k**2 * sigma**2) ab = a * b mod = splrep(k, ab, s=0, k=1) k = numpy.logspace(kmin, kmax, r.size * fk) ab = splev(k, mod) result = r * 0. for i in range(r.size): bessel = j0(k * r[i]) mod = splrep(k, k * bessel * ab, s=0, k=1) result[i] = 2 * pi * splint(0., k[-1], mod) return result
def VegaFilterMagnitude(filter,spectrum,redshift): """ Determines the Vega magnitude (up to a constant) given an input filter, SED, and redshift. """ from scipy.interpolate import splev,splint,splrep from scipy.integrate import simps from math import log10 wave = spectrum[0].copy() data = spectrum[1].copy() # Redshift the spectrum and determine the valid range of wavelengths wave *= (1.+redshift) data /= (1.+redshift) wmin,wmax = filter[0][0],filter[0][-1] cond = (wave>=wmin)&(wave<=wmax) # Evaluate the filter at the wavelengths of the spectrum response = splev(wave[cond],filter) # Determine the total observed flux (without the bandpass correction) observed = splrep(wave[cond],(response*data[cond]),s=0,k=1) flux = splint(wmin,wmax,observed) # Determine the magnitude of Vega through the filter vwave,vdata = getSED('Vega') cond = (vwave>=wmin)&(vwave<=wmax) response = splev(vwave[cond],filter) vega = splrep(vwave[cond],response*vdata[cond],s=0,k=1) vegacorr = splint(wmin,wmax,vega) return -2.5*log10(flux/vegacorr)#+2.5*log10(1.+redshift)
def VegaFilterMagnitude(filter, spectrum, redshift): """ Determines the Vega magnitude (up to a constant) given an input filter, SED, and redshift. """ from scipy.interpolate import splev, splint, splrep from scipy.integrate import simps from math import log10 wave = spectrum[0].copy() data = spectrum[1].copy() # Redshift the spectrum and determine the valid range of wavelengths wave *= (1. + redshift) data /= (1. + redshift) wmin, wmax = filter[0][0], filter[0][-1] cond = (wave >= wmin) & (wave <= wmax) # Evaluate the filter at the wavelengths of the spectrum response = splev(wave[cond], filter) # Determine the total observed flux (without the bandpass correction) observed = splrep(wave[cond], (response * data[cond]), s=0, k=1) flux = splint(wmin, wmax, observed) # Determine the magnitude of Vega through the filter vwave, vdata = getSED('Vega') cond = (vwave >= wmin) & (vwave <= wmax) response = splev(vwave[cond], filter) vega = splrep(vwave[cond], response * vdata[cond], s=0, k=1) vegacorr = splint(wmin, wmax, vega) return -2.5 * log10(flux / vegacorr) #+2.5*log10(1.+redshift)
def scale(self, band2, band1, madau=True): zs = self.zs a2 = self.tn % 1 a1 = 1. - a2 n1 = int(np.floor(self.tn)) n2 = int(np.ceil(self.tn)) bands_here = [band2, band1] temp_coeffs = [a1, a2] temp_ind = [n1, n2] temp_fband = [] for n in temp_ind: flambda = self.templates[n][1].copy() wav = self.templates[n][0].copy() wobs = wav * (1. + zs) fband_here = [] for band in bands_here: wrange = (wobs > self.filtranges[band][0]) & ( wobs < self.filtranges[band][1]) wband = wobs[wrange] flambda_here = flambda[wrange] if madau: madau_corr = etau_madau(wband, zs) flambda_here *= madau_corr nu_here = 1. / wband fnu_here = flambda_here / nu_here**2 weights = splev(wband, self.filtsplines[band]) nu_here = nu_here[::-1] fnu_here = fnu_here[::-1] weights = weights[::-1] num_integrand = splrep(nu_here, weights * fnu_here / nu_here, k=1) den_integrand = splrep(nu_here, weights / nu_here, k=1) num = splint(nu_here[0], nu_here[-1], num_integrand) den = splint(nu_here[0], nu_here[-1], den_integrand) fband_here.append(num / den) temp_fband.append(fband_here) ratio = (a1 * temp_fband[0][0] + a2 * temp_fband[1][0]) / ( a1 * temp_fband[0][1] + a2 * temp_fband[1][1]) return ratio * 10.**((self.zp[band2] - self.zp[band1]) / 2.5)
def _integrate_spl_scalar(self, ui, spl): if self.active == 'R': # passive ---- active return -interpolate.splint(self._t_active, ui, spl) elif self.active == 'L': # active ---- passive return interpolate.splint(self._t_active, ui, spl) else: # active ---- active if ui <= self._t_passive: return interpolate.splint(self._t_active[0], ui, spl) else: return -interpolate.splint(self._t_active[1], ui, spl)
def test_x2_surrounds_x1_sine_spline(self): """ x2 range is completely above x1 range using a random vector to build spline """ # old size m = 5 # new size n = 6 # bin edges x_old = np.linspace(0., 1., m + 1) x_new = np.array([-.3, -.09, 0.11, 0.14, 0.2, 0.28, 0.73]) subbins = np.array([-.3, -.09, 0., 0.11, 0.14, 0.2, 0.28, 0.4, 0.6, 0.73]) y_old = 1. + np.sin(x_old[:-1] * np.pi) # compute spline ---------------------------------- x_mids = x_old[:-1] + 0.5 * np.ediff1d(x_old) xx = np.hstack([x_old[0], x_mids, x_old[-1]]) yy = np.hstack([y_old[0], y_old, y_old[-1]]) # build spline spl = splrep(xx, yy) area_old = np.array([splint(x_old[i], x_old[i + 1], spl) for i in range(m)]) # computing subbin areas area_subbins = np.zeros((subbins.size - 1,)) for i in range(area_subbins.size): a, b = subbins[i: i + 2] a = max([a, x_old[0]]) b = min([b, x_old[-1]]) if b > a: area_subbins[i] = splint(a, b, spl) # summing subbin contributions in y_new_ref y_new_ref = np.zeros((x_new.size - 1,)) y_new_ref[1] = y_old[0] * area_subbins[2] / area_old[0] y_new_ref[2] = y_old[0] * area_subbins[3] / area_old[0] y_new_ref[3] = y_old[0] * area_subbins[4] / area_old[0] y_new_ref[4] = y_old[1] * area_subbins[5] / area_old[1] y_new_ref[5] = y_old[1] * area_subbins[6] / area_old[1] y_new_ref[5] += y_old[2] * area_subbins[7] / area_old[2] y_new_ref[5] += y_old[3] * area_subbins[8] / area_old[3] # call rebin function y_new = rebin.rebin(x_old, y_old, x_new, interp_kind=3) assert_allclose(y_new, y_new_ref)
def test_x2_surrounds_x1_sine_spline(): """ x2 range is completely above x1 range using a random vector to build spline """ # old size m = 5 # new size n = 6 # bin edges x_old = np.linspace(0., 1., m + 1) x_new = np.array([-.3, -.09, 0.11, 0.14, 0.2, 0.28, 0.73]) subbins = np.array([-.3, -.09, 0., 0.11, 0.14, 0.2, 0.28, 0.4, 0.6, 0.73]) y_old = 1. + np.sin(x_old[:-1] * np.pi) # compute spline ---------------------------------- x_mids = x_old[:-1] + 0.5 * np.ediff1d(x_old) xx = np.hstack([x_old[0], x_mids, x_old[-1]]) yy = np.hstack([y_old[0], y_old, y_old[-1]]) # build spline spl = splrep(xx, yy) area_old = np.array( [splint(x_old[i], x_old[i + 1], spl) for i in range(m)]) # computing subbin areas area_subbins = np.zeros((subbins.size - 1, )) for i in range(area_subbins.size): a, b = subbins[i:i + 2] a = max([a, x_old[0]]) b = min([b, x_old[-1]]) if b > a: area_subbins[i] = splint(a, b, spl) # summing subbin contributions in y_new_ref y_new_ref = np.zeros((x_new.size - 1, )) y_new_ref[1] = y_old[0] * area_subbins[2] / area_old[0] y_new_ref[2] = y_old[0] * area_subbins[3] / area_old[0] y_new_ref[3] = y_old[0] * area_subbins[4] / area_old[0] y_new_ref[4] = y_old[1] * area_subbins[5] / area_old[1] y_new_ref[5] = y_old[1] * area_subbins[6] / area_old[1] y_new_ref[5] += y_old[2] * area_subbins[7] / area_old[2] y_new_ref[5] += y_old[3] * area_subbins[8] / area_old[3] # call rebin function y_new = rebin.rebin(x_old, y_old, x_new, interp_kind=3) assert_allclose(y_new, y_new_ref)
def rebin(x, y, xnew, conserve_count=True): dx = get_dx(x) dxnew = get_dx(xnew) if conserve_count: # count conserved (input is per pix) spl = splrep(x, y / dx, k=1, task=0, s=0) return np.array([splint(xn-0.5*dxn,xn+0.5*dxn,spl) \ for xn,dxn in zip(xnew,dxnew)]) else: #flux conserved (input is in physical unit) spl = splrep(x, y, k=1, task=0, s=0) return np.array([splint(xn-0.5*dxn,xn+0.5*dxn,spl)/dxn \ for xn,dxn in zip(xnew,dxnew)])
def GP_int(rec): z,g,sig=rec n=len(z) tck = splrep(z,g) gint=np.zeros(n) for i in range(n): gint[i]=splint(0,z[i],tck) tck_s=splrep(z, g+sig) gint_s=np.zeros(n) for i in range(n): gint_s[i]=splint(0,z[i],tck_s) return z,gint,gint_s-gint
def kappa(r0fine, Mrfine, nufine, sigr2nu, intbetasfine, gp): # for the following: enabled calculation of kappa # kappa_r^4 kapr4nu = np.ones(len(r0fine)-gp.nexp) xint = r0fine # [pc] yint = gu.G1__pcMsun_1km2s_2 * Mrfine/r0fine**2 # [1/pc (km/s)^2] yint *= nufine # [Munit/pc^4 (km/s)^2] yint *= sigr2nu # [Munit/pc^4 (km/s)^4 yint *= np.exp(intbetasfine) # [Munit/pc^4 (km/s)^4] gh.checkpositive(yint, 'yint in kappa_r^4') yscale = 10.**(1.-min(np.log10(yint[1:]))) yint *= yscale # power-law extrapolation to infinity C = max(0., gh.quadinflog(xint[-3:], yint[-3:], r0fine[-1], gp.rinfty*r0fine[-1])) splpar_nu = splrep(xint, yint, k=3) # interpolation in real space for k in range(len(r0fine)-gp.nexp): # integrate from minimal radius to infinity kapr4nu[k] = 3.*(np.exp(-intbetasfine[k])/nufine[k]) * \ (splint(r0fine[k], r0fine[-1], splpar_nu) + C) # [(km/s)^4] kapr4nu /= yscale gh.checkpositive(kapr4nu, 'kapr4nu in kappa_r^4') splpar_kap = splrep(r0fine[:-gp.nexp], np.log(kapr4nu), k=3) kapr4ext = np.exp(splev(r0ext, splpar_kap)) kapr4nu = np.hstack([kapr4nu, kapr4ext]) gh.checkpositive(kapr4nu, 'kapr4nu in extended kappa_r^4') dbetafinedr = splev(r0fine, splrep(r0fine, betafine), der=1) gh.checknan(dbetafinedr, 'dbetafinedr in kappa_r^4') # kappa^4_los*surfdensity kapl4s = np.zeros(len(r0fine)-gp.nexp) for k in range(len(r0fine)-gp.nexp): xnew = np.sqrt(r0fine[k:]**2-r0fine[k]**2) # [pc] ynew = g(r0fine[k:], r0fine[k], betafine[k:], dbetafinedr[k:]) # [1] ynew *= nufine[k:] * kapr4nu[k:] C = max(0., gh.quadinflog(xnew[-3:], ynew[-3:], xnew[-1], gp.rinfty*xnew[-1])) splpar_nu = splrep(xnew,ynew) # not s=0.1, this sometimes gives negative entries after int kapl4s[k] = 2. * (splint(0., xnew[-1], splpar_nu) + C) #kapl4s[k] /= yscale # LOG('ynew = ',ynew,', kapl4s =', kapl4s[k]) gh.checkpositive(kapl4s, 'kapl4s in kappa_r^4') # project kappa4_los as well # only use middle values to approximate, without errors in center and far kapl4s_out = np.exp(splev(r0, splrep(r0fine[4:-gp.nexp], kapl4s[4:], k=3))) # s=0. gh.checkpositive(kapl4s_out, 'kapl4s_out in kappa_r^4') return sigl2s_out, kapl4s_out
def update(self, x, dt): self.curr_time += dt self.samples.append(x) self.time.append(self.curr_time) if len(self.samples) > 4: self.samples = self.samples[1:] self.time = self.time[1:] tck = interpolate.splrep(self.time,self.samples) if self.warmup: self.integral += interpolate.splint(self.time[-2],self.time[-1],tck) else: self.integral += interpolate.splint(self.time[0],self.time[-1],tck) self.warmup = True
def get_mag_from_sed(wave, llambda, redshift, filtname, cosmo=pygalaxev_cosmology.default_cosmo): filtdir = os.environ.get('PYGALAXEVDIR') + '/filters/' Dlum = pygalaxev_cosmology.Dlum(redshift, cosmo=cosmo) # luminosity distance in Mpc wave_obs = wave * (1. + redshift) flambda_obs = llambda * L_Sun / (4. * np.pi * (Dlum * Mpc)**2) / ( 1. + redshift) # observed specific flux in erg/s/cm^2/AA fnu = flambda_obs * wave_obs**2 / csol * 1e-8 # F_nu in cgs units nu_obs = np.flipud(csol / wave_obs * 1e8) fnu = np.flipud(fnu) fullfiltname = filtdir + filtname f = open(fullfiltname, 'r') filt_wave, filt_t = np.loadtxt(f, unpack=True) f.close() filt_spline = splrep(filt_wave, filt_t) wmin_filt, wmax_filt = filt_wave[0], filt_wave[-1] cond_filt = (wave_obs >= wmin_filt) & (wave_obs <= wmax_filt) nu_cond = np.flipud(cond_filt) # Evaluate the filter response at the wavelengths of the spectrum response = splev(wave_obs[cond_filt], filt_spline) nu_filter = csol * 1e8 / wave_obs[cond_filt] # flips arrays response = np.flipud(response) nu_filter = np.flipud(nu_filter) # filter normalization bp = splrep(nu_filter, response / nu_filter, s=0, k=1) bandpass = splint(nu_filter[0], nu_filter[-1], bp) # Integrate observed = splrep(nu_filter, response * fnu[nu_cond] / nu_filter, s=0, k=1) flux = splint(nu_filter[0], nu_filter[-1], observed) mag = -2.5 * np.log10(flux / bandpass) - 48.6 return mag
def integrate(self, a=0., b=2*np.pi): """ Find the definite integral of the spline from a to b """ # Are both a and b in (0, 2pi)? if (0 <= a <= 2*np.pi) and (0 <= b <= 2*np.pi): return splint(a, b, self._eval_args) elif ((a <= 0) and (b <= 0)) or ((a >= 2*np.pi) and (b >= 2*np.pi)): return splint(a%(2*np.pi), b%(2*np.pi), self._eval_args) elif (a <= 0) or (b >= 2*np.pi): int = 0 int += splint(a%(2*np.pi), 2*np.pi, self._eval_args) int += splint(0, b%(2*np.pi), self._eval_args) return int
def integrate_smooth(accel, dt=1e-2, init_motion=None): if init_motion is None: init_motion = np.zeros((3, 3)) time = (np.arange(accel.shape[1], dtype=np.float64)) * dt vel = np.zeros_like(accel) pose = np.zeros_like(accel) for i in range(3): tck = interpolate.splrep(time, accel[i], s=0, k=1) for j in range(accel[i].shape[0]): vel[i, j] = interpolate.splint(0, time[j], tck) vel[i] += init_motion[1, i] tck = interpolate.splrep(time, vel[i], s=0, k=1) for j in range(vel[i].shape[0]): pose[i, j] = interpolate.splint(0, time[j], tck) pose[i] += init_motion[2, i] return accel, vel, pose
def ObjectiveFunction(sigma, knots, ts, ois_rate, lib_rate): """ constructs the B-spline for the given knots, times( in years), OIS rates, and LIBOR rates for the corresponding times. Calculates the objective function for the given parameters. sigma = float (lambda from equation (40) on page 23 of lecture 1 notes) knots = numpy array ts = numpy array ois_rate = numpy array lib_rate = numpy array """ tck1 = interp.splrep(ts, ois_rate, t = knots) tck2 = interp.splrep(ts, lib_rate, t = knots) approx1 = interp.splev(ts,tck1) approx2 = interp.splev(ts,tck2) partial_sum = ((approx1 - ois_rate)**2).sum() partial_sum += (sum((approx2 - lib_rate)**2)).sum() partial_sum *= 0.5 new_tck = [] new_tck.append(knots) new_tck.append((interp.splev(ts,tck1,der=2))**2 + (interp.splev(ts, tck2, der=2)**2)) new_tck.append(3) temp = interp.splint(ts[0], ts[-1], new_tck) partial_sum += 0.5*sigma*temp return partial_sum
def cont_kldivergence(data, prior): """ Calculates the Kullback–Leibler divergence for a continuous distribution. data: samples from the posterior distribution prior: pdf of the prior distribution """ x, p = np.histogram(data, bins='auto') x = np.array(x)/np.sum(x) h = len(x) item = 0 zeroitem = False x1 = [] p1 = [] for i in range(h): if x[i] > 0 and not zeroitem: x1.append(x[i] / (p[1] - p[0])) p1.append(np.mean((p[i], p[i + 1]))) item += 1 if x[i] == 0 and not zeroitem: zeroitem = True initial = i if x[i] > 0 and zeroitem: zeroitem = False x1.append(x[i] / (p[i + 1] - p[initial])) p1.append(np.mean(p[initial:i + 1])) item += 1 x1 = np.array(x1) q1 = prior(p1) x2 = x1*np.log(x1/q1) tck = interpolate.splrep(p1, x2) return interpolate.splint(min(p1), max(p1), tck)
def test_splint(): """ Evaluate the definite integral of a B-spline. Given the knots and coefficients of a B-spline, evaluate the definite integral of the smoothing polynomial between two given points. Parameters ---------- a, b : float The end-points of the integration interval. tck : tuple A tuple (t,c,k) containing the vector of knots, the B-spline coefficients, and the degree of the spline (see `splev`). full_output : int, optional Non-zero to return optional output. Returns ------- integral : float The resulting integral. wrk : ndarray An array containing the integrals of the normalized B-splines defined on the set of knots. """ x = linspace(0,10,10) y = sin(x) tck = splrep(x, y) y2 = splint(x[0],x[-1],tck) print y2
def GetSourceSize(self,kpc=False): self.z=source_redshifts[self.name] self.Da = astCalc.da(self.z) self.scale = self.Da*1e3*np.pi/180./3600. if len(self.srcs) == 1 or self.name == 'J0837': self.Re_v = self.Ddic['Source 1 re']*0.05 self.Re_i = self.Re_v.copy() self.Re_lower = self.Ldic['Source 1 re']*0.05 self.Re_upper = self.Udic['Source 1 re']*0.05 elif len(self.srcs) == 2 and self.name != 'J0837': print 'test this out...!' Xgrid = np.logspace(-4,5,1501) Res = [] for i in range(len(self.imgs)): #if self.name == 'J1605': # source = source = self.fits[i][-3]*self.srcs[0].eval(Xgrid) + self.fits[i][-2]*self.srcs[1].eval(Xgrid) R = Xgrid.copy() light = source*2.*np.pi*R mod = splrep(R,light,t=np.logspace(-3.8,4.8,1301)) intlight = np.zeros(len(R)) for i in range(len(R)): intlight[i] = splint(0,R[i],mod) model = splrep(intlight[:-300],R[:-300]) if len(model[1][np.where(np.isnan(model[1])==True)]>0): print "arrays need to be increasing monotonically! But don't worry about it" model = splrep(intlight[:-450],R[:-450]) reff = splev(0.5*intlight[-1],model) Res.append(reff*0.05) self.Re_v,self.Re_i = Res if kpc: return [self.Re_v*self.scale, self.Re_i*self.scale] return [self.Re_v, self.Re_i]
def get_alpha(self): """ Calculates self.alpha - the likelihood that a point is part of an ELM peak based on its intensity value. """ # create a series of times across the data which serve as the centre # of time windows with half-width self.w t_c = np.linspace(np.min(self.t), np.max(self.t), self.m) u = np.zeros(self.m) for i in range(self.m): # find all data in the current time-window booles = (self.t > t_c[i] - self.w) & (self.t < t_c[i] + self.w) # sort the y-data in the window order = np.sort(self.y[np.where(booles)]) # estimate the self.rho'th percentile for the window u[i] = order[np.round(self.rho * len(order)).astype(int)] # smoothing of threshold level data u = self.smooth(u) # set threshold at ends of the data dt_c = t_c[1] - t_c[0] ind = np.round(self.w / dt_c).astype(int) u[:ind] = u[ind] u[-ind:] = u[-ind] # use a spline to determine spline = splint(t_c, u) self.tau = spline(self.t) self.alpha = np.array(self.y >= self.tau)
def printIsigma2OM(R, r, M, light_profile, lp_args, riso, infile): from numpy import arctan if type(R) == type(1.): R = numpy.asarray([R]) light = light_profile(r, lp_args) a = lp_args model = interpolate.splrep(r, M * light, k=3, s=0) result = R * 0. ua2 = (riso / R)**2 t1 = (ua2 + 0.5) / (ua2 + 1.)**1.5 for i in range(R.size): outfile = infile + '_%03d.txt' % (i) reval = logspace(log10(R[i]), log10(r[-1]), 301) reval[0] = R[i] # Avoid sqrt(-epsilon) Mlight = interpolate.splev(reval, model) u = reval / R[i] u2 = u * u ua = ua2[i] K = t1[i] * (u2 + ua) * arctan( ((u2 - 1.) / (ua + 1.))**0.5) / u - 0.5 * (1. - 1. / u2)**0.5 / (ua + 1.) integrand = K * Mlight / reval mod = interpolate.splrep(reval, K * Mlight / reval, k=3, s=0) result[i] = 2. * interpolate.splint(R[i], reval[-1], mod) f = open(outfile, 'w') for (ip, jp) in zip(reval, integrand): f.write("%f\t%.10g\n" % (ip, jp)) f.close() return result
def GetSourceSize(self,z): self.z=z self.Da = astCalc.da(self.z) self.scale = self.Da*np.pi/180./3600. if len(self.srcs) == 1: self.Re = self.Ddic['Source 1 re']*0.05 self.Re_lower = self.Ldic['Source 1 re']*0.05 self.Re_upper = self.Udic['Source 1 re']*0.05 self.Re_kpc = self.Re*self.scale return self.Re elif len(self.srcs) == 2: print 'test this out...!' Xgrid = np.logspace(-4,5,1501) Ygrid = np.logspace(-4,5,1501) Res = [] for i in range(len(self.imgs)): source = self.fits[i][-3]*self.srcs[0].eval(Xgrid) + self.fits[i][-2]*self.srcs[1].eval(Xgrid) R = Xgrid.copy() light = source*2.*np.pi*R mod = splrep(R,light,t=np.logspace(-3.8,4.8,1301)) intlight = np.zeros(len(R)) for i in range(len(R)): intlight[i] = splint(0,R[i],mod) model = splrep(intlight[:-300],R[:-300]) reff = splev(0.5*intlight[-1],model) Res.append(reff*0.05) self.Re_v,self.Re_i = Res return self.Re_v, self.Re_i
def spline_integral(x, y, x1=None, x2=None): if not x1: # Integration limits x1 = x.min() if not x2: x2 = x.max() tck = interpolate.splrep(x, y, s=0) # Spline representation return interpolate.splint(x1, x2, tck) # Integral
def calc_tissue_tac(input_tac, mtt, bv, t, lag=0): """ Calculate Time/Attenuation Curve (TAC) of tissue from input TAC smoothed with spline Args: input_tac (tuple): is argument to scipy.interpolate.splint(..., tck, ...) mtt (float): mean transit time of tissue in seconds bv (float): tissue blood volume. Should be between 0 and 1 t (np.array): time steps of output TAC lag (float): time which input TAC needed to get to the tissue Returns: (np.array): tissue TAC with in defined time steps """ if not 0 <= bv <= 1: raise ValueError('bv should be in interval from 0 to 1') if mtt == 0: mtt += 0.01 t2 = t - lag t2[t2 < t[0]] = t[0] from_t = t2 - mtt from_t[from_t < t2[0]] = t2[0] final_arr = np.array([interpolate.splint(ft, tt, input_tac) for ft, tt in zip(from_t, t2)]) return (final_arr * bv) / mtt
def Isigma2TPE(R,r,M,light_profile,lp_args,anis_par): from scipy.special import gamma,betainc,beta as B from scipy.integrate import quad if type(R)==type(1.): R = numpy.asarray([R]) light = light_profile(r,lp_args) a = lp_args if type(anis_par) == tuple: ra, bi, bo = anis_par model = splrep(r,M*light,k=3,s=0) result = R*0. eps = 1e-6 for i in range(R.size): reval = numpy.logspace(numpy.log10(R[i]),numpy.log10(r[-1]),301) reval[0] = R[i] # Avoid sqrt(-epsilon) Mlight = splev(reval,model) u = reval/R[i] ua = ra/R[i] FT1 = numpy.zeros(reval.size) for j in range(reval.size): FT1[j] = quad(FT,1.+eps,u[j],(ua,bi,bo))[0] f = u**(2*bi)*(u*u+ua*ua)**(bo-bi) K = 2.*FT1/(u)*f y= K*Mlight/reval mod = splrep(reval,y,k=3,s=0) result[i] = splint(R[i],r[-1],mod) return result
def calc_tissue_tac(input_tac, mtt, bv, t, lag=0): """ Calculate Time/Attenuation Curve (TAC) of tissue from input TAC smoothed with spline Args: input_tac (tuple): is argument to scipy.interpolate.splint(..., tck, ...) mtt (float): mean transit time of tissue in seconds bv (float): tissue blood volume. Should be between 0 and 1 t (np.array): time steps of output TAC lag (float): time which input TAC needed to get to the tissue Returns: (np.array): tissue TAC with in defined time steps """ if not 0 <= bv <= 1: raise ValueError('bv should be in interval from 0 to 1') if mtt == 0: mtt += 0.01 t2 = t - lag t2[t2 < t[0]] = t[0] from_t = t2 - mtt from_t[from_t < t2[0]] = t2[0] final_arr = np.array( [interpolate.splint(ft, tt, input_tac) for ft, tt in zip(from_t, t2)]) return (final_arr * bv) / mtt
def ObjectiveFunction(sigma, knots, ts, ois_rate, lib_rate): """ constructs the B-spline for the given knots, times( in years), OIS rates, and LIBOR rates for the corresponding times. Calculates the objective function for the given parameters. sigma = float (lambda from equation (40) on page 23 of lecture 1 notes) knots = numpy array ts = numpy array ois_rate = numpy array lib_rate = numpy array """ tck1 = interp.splrep(ts, ois_rate, t=knots) tck2 = interp.splrep(ts, lib_rate, t=knots) approx1 = interp.splev(ts, tck1) approx2 = interp.splev(ts, tck2) partial_sum = ((approx1 - ois_rate)**2).sum() partial_sum += (sum((approx2 - lib_rate)**2)).sum() partial_sum *= 0.5 new_tck = [] new_tck.append(knots) new_tck.append((interp.splev(ts, tck1, der=2))**2 + (interp.splev(ts, tck2, der=2)**2)) new_tck.append(3) temp = interp.splint(ts[0], ts[-1], new_tck) partial_sum += 0.5 * sigma * temp return partial_sum
def cumulativeCurr(file_name): input_file = open(file_name,'r') index = -1 all_time = [] all_current = [] Q = 0.0 input_lines = input_file.readlines() input_file.close() for input_line in input_lines: index += 1 tmp = input_line.split() t = float(tmp[0]) I = float(tmp[1]) all_time.append(t) all_current.append(I) sall_time = asarray(all_time) sall_current = asarray(all_current) splrepint = interpolate.splrep(sall_time, sall_current, s=0) for time in all_time: charge = interpolate.splint(sall_time[0], time, splrepint) print time,charge
def pixeval(self,x,y): from numpy import cosh from math import pi from itertools import product from scipy.interpolate import splrep, splev, splint cos = numpy.cos(self.pa*pi/180.) sin = numpy.sin(self.pa*pi/180.) xp = (x-self.x)*cos+(y-self.y)*sin yp = (y-self.y)*cos-(x-self.x)*sin zp = numpy.logspace(-2,3,200) zp = numpy.concatenate((-zp[::-1],zp)) array = numpy.zeros(xp.shape) print len(xp[0]), len(xp[1]) for ii,j in product(range(len(xp[0])),range(len(xp[1]))): #print ii,j X = xp[ii,j] Y = yp[ii,j]*numpy.cos(self.i) + zp*numpy.sin(self.i) Z = -yp[ii,j]*numpy.sin(self.i) + zp*numpy.cos(self.i) rho = numpy.exp(-(X**2. + Y**2.)**0.5 / self.x0) /cosh(Z/self.y0)**2. mod = splrep(zp,rho) array[ii,j] = splint(zp[0],zp[-1],mod) import pylab as pl pl.figure() pl.plot(Z,rho) return array
def integ(x, tck, constant=0): x = np.atleast_1d(x) out = np.zeros(x.shape[0], dtype=x.dtype) for n in xrange(len(out)): out[n] = interpolate.splint(0, x[n], tck) # out += constant return out
def spline_integrate_real(t, y, a, b): """Computes the definite integral between bounds [a,b] of a function represented by samples contained in arrays t and y. t needs to be strictly increasing. :param t: Sample times. :type t: 1D numpy array. :param y: Sample values. :type y: 1D numpy array. :param float a: Lower integration boundary. :param float b: Upper integration boundary. """ a = float(a) b = float(b) if (a > b): a, b = b, a sf = -1 else: sf = 1 # if ((a < t[0]) or (b > t[-1])): raise ValueError('Integration bounds out of range.') # spl = interpolate.splrep(t, y, k=3, s=0) r = interpolate.splint(a, b, spl) return r * sf
def _getWeights(self, a, b): """ Computes weights using spline interpolation instead of Gaussian quadrature Args: a (float): left interval boundary b (float): right interval boundary Returns: np.ndarray: weights of the collocation formula given by the nodes """ # get the defining tck's for each spline basis function circ_one = np.zeros(self.num_nodes) circ_one[0] = 1.0 tcks = [] for i in range(self.num_nodes): tcks.append( intpl.splrep(self.nodes, np.roll(circ_one, i), xb=self.tleft, xe=self.tright, k=self.order, s=0.0)) weights = np.zeros(self.num_nodes) for i in range(self.num_nodes): weights[i] = intpl.splint(a, b, tcks[i]) return weights
def integ(x, tck, constant=-1): x = np.atleast_1d(x) out = np.zeros(x.shape, dtype=x.dtype) for n in xrange(len(out)): out[n] = interpolate.splint(0, x[n], tck) out += constant return out
def E_W(x,y): EW=0 tck=interpolate.splrep(x,y) i=0 while(i<99): EW+=interpolate.splint(x[i],x[i+1],tck) i+=1 return EW
def E_W(x,y): #ekvivalentna sirina, metodom cubic spline EkW=0 tck=interpolate.splrep(x,y) i=0 while(i<(N_tacaka-1)): EkW+=interpolate.splint(x[i],x[i+1],tck) i+=1 return EkW
def rapidity_integral(spec_along_y, ylo=-0.5, yhi=0.5): '''1D integration along rapidity/pseudo-rapidity The spline interpolation and integration is much faster than the interp1d() and quad combination''' #f = interp1d(Y, spec_along_y, kind='cubic') #return quad(f, ylo, yhi, epsrel=1.0E-5)[0] tck = splrep(Y, spec_along_y) return splint(ylo, yhi, tck)
def N(mu, E, T, g, n=None): """ Find number of electrons by integrating g(E) * f(E,T,mu) * E**n over all E Parameters: mu: chemical potential E: energy grid T: temperature g: DOS n: momentum """ if n is None: tck = splrep(E, g*fermi(E,T,mu)) return splint(E[0], E[-1], tck) else: tck = splrep(E, g*fermi(E,T,mu)*E**n) return splint(E[0], E[-1], tck)
def fAnc_ext1(self, s): '''Funtion to minimize when searching the point from which the tendon is not affected by the anchorage slip in extremity 1 ''' y = interpolate.splint( 0.0, s, self.tckLossFric) - s * interpolate.splev( s, self.tckLossFric, der=0) - self.slip1 / 2.0 return y
def E_W(x,y): EkW=0 tck=interpolate.splrep(x,y) i=0 while(i<(N_tacaka-1)): EkW+=interpolate.splint(x[i],x[i+1],tck) i+=1 return EkW
def integ(x, tck, constant = 10e-9): from scipy import interpolate x = np.atleast_1d(x) out = np.zeros(x.shape, dtype=x.dtype) for n in range(len(out)): out[n] = interpolate.splint(0, x[n], tck) out += constant return out
def integ(x,tck,constant=-1): import numpy as np x = np.atleast_1d(x) out = np.zeros(x.shape, dtype=x.dtype) for n in xrange(len(out)): out[n] = interpolate.splint(0,x[n],tck) out += constant return out
def pixeval(self, x, y, scale=1, csub=23): from scipy import interpolate from math import pi, cos as COS, sin as SIN shape = x.shape x = x.ravel() y = y.ravel() cos = COS(self.pa * pi / 180.) sin = SIN(self.pa * pi / 180.) xp = (x - self.x) * cos + (y - self.y) * sin yp = (y - self.y) * cos - (x - self.x) * sin r = (self.q * xp**2 + yp**2 / self.q)**0.5 k = 2. * self.n - 1. / 3 + 4. / (405. * self.n) + 46 / (25515. * self.n**2) R = np.logspace(-5., 4., 451) # 50 pnts / decade s0 = np.exp(-k * (R**(1. / self.n) - 1.)) # Determine corrections for curvature rpow = R**(1. / self.n - 1.) term1 = (k * rpow / self.n)**2 term2 = k * (self.n - 1.) * rpow / (R * self.n**2) wid = scale / self.re corr = (term1 + term2) * wid**3 / 6. try: minR = R[abs(corr) < 0.005].min() except: minR = 0 # Evaluate model! model = interpolate.splrep(R, s0, k=3, s=0) R0 = r / self.re s = interpolate.splev(R0, model) * scale**2 if self.n <= 1. or minR == 0: return self.amp * s.reshape(shape) model2 = interpolate.splrep(R, s0 * R * self.re**2, k=3, s=0) coords = np.where(R0 < minR)[0] c = (np.indices( (csub, csub)).astype(np.float32) - csub / 2) * scale / csub for i in coords: # The central pixels are tricky because we can't assume that we # are integrating in delta-theta segments of an annulus; these # pixels are treated separately by sub-sampling with ~500 pixels if R0[i] < 3 * scale / self.re: # the pixels within 3*scale are evaluated by sub-sampling s[i] = 0. y0 = c[1] + y[i] x0 = c[0] + x[i] xp = (x0 - self.x) * cos + (y0 - self.y) * sin yp = (y0 - self.y) * cos - (x0 - self.x) * sin r0 = (self.q * xp**2 + yp**2 / self.q)**0.5 / self.re s[i] = interpolate.splev(r0.ravel(), model).mean() * scale**2 continue lo = R0[i] - 0.5 * scale / self.re hi = R0[i] + 0.5 * scale / self.re angle = (scale / self.re) / R0[i] s[i] = angle * interpolate.splint(lo, hi, model2) return self.amp * s.reshape(shape)
def fAnc_ext2(self, s): '''Funtion to minimize when searching the point from which the tendon is not affected by the anchorage slip in extremity 2 ''' y = interpolate.splint( s, self.fineScoord[-1], self.tckLossFric) - (self.fineScoord[-1] - s) * interpolate.splev( s, self.tckLossFric, der=0) - self.slip2 / 2.0 return y
def lookback_time_n(self,N): """ Lookback time as a function of log(a) in units of billion years """ H=((1-self.sol()[999,1])*np.exp(-3*self.n1)/(1-self.sol()[:,1]))**(0.5) tck3=interpolate.splrep(self.n1,1/H,s=0) lt=interpolate.splint(N,0,tck3) return self.t_H()*lt
def integ(x, spline, constant=-1): x = np.atleast_1d(x) out = np.zeros(x.shape, dtype=x.dtype) for n in range(len(out)): out[n] = interpolate.splint(0, x[n], spline) out += constant return out
def co_dis_n(self, N): H = ((1. - self.sol()[999, 0]**2. * (1 + self.sol()[999, 2]) - self.sol()[999, 1]**2.) * np.exp(-3 * self.n1) / ((1. - self.sol()[:, 0]**2. * (1 + self.sol()[:, 2]) - self.sol()[:, 1]**2.)))**(0.5) H1 = np.exp(-self.n1) / H tck3 = interpolate.splrep(self.n1, H1, s=0) rs = interpolate.splint(N, 0, tck3) return self.D_H() * rs
def summ_rule(curve, norm=1.0, xmin=None, xmax=None): """ Normalize curve to set integral to a given value. """ from scipy.interpolate import splrep, splint if xmin is None: xmin = curve.x[0] if xmax is None: xmax = curve.x[-1] tck = splrep(curve.x, curve.y) return splint(xmin, xmax, tck)
def lookback_time_n(self, N): """ Lookback time as a function of log(a) in units of billion years """ H = ((1 - self.sol()[999, 1]) * np.exp(-3 * self.n1) / (1 - self.sol()[:, 1]))**(0.5) tck3 = interpolate.splrep(self.n1, 1 / H, s=0) lt = interpolate.splint(N, 0, tck3) return self.t_H() * lt
def co_dis_n(self,N): """ Line of sight comoving distance as a function of log(a) as described in David Hogg paper in units of Mpc """ H=((1-self.sol()[999,1])*np.exp(-3*self.n1)/(1-self.sol()[:,1]))**(0.5) H1=np.exp(-self.n1)/H tck3=interpolate.splrep(self.n1,H1,s=0) rs=interpolate.splint(N,0,tck3) return self.D_H()*rs
def _spline_integral(x, y, xmin=None, xmax=None): """ Calculate spline integral of curve from xmin to xmax """ from scipy.interpolate import splrep, splint if xmin is None: xmin = x[0] if xmax is None: xmax = x[-1] tck = splrep(x, y) return splint(xmin, xmax, tck)
def general_random(func,N,interval = (0.,1.)): xs = np.linspace(interval[0],interval[1],101) spline = splrep(xs,func(xs)) intfunc = lambda x: splint(interval[0],x,spline) # intfunc = lambda x: quad(func,interval[0],x)[0] norm = intfunc(interval[1]) F = np.random.rand(N)*norm x = F*0. for i in range(0,N): x[i] = brentq(lambda x: intfunc(x) - F[i],interval[0],interval[1]) return x
def ABFilterMagnitude(filter,spectrum,redshift): """ Determines the AB magnitude (up to a constant) given an input filter, SED, and redshift. """ from scipy.interpolate import splev,splint,splrep from scipy.integrate import simps from math import log10 sol = 299792452. wave = spectrum[0].copy() data = spectrum[1].copy() # Convert to f_nu data = data*wave**2/(sol*1e10) # Redshift the spectrum and determine the valid range of wavelengths wave *= (1.+redshift) wmin,wmax = filter[0][0],filter[0][-1] cond = (wave>=wmin)&(wave<=wmax) # Evaluate the filter at the wavelengths of the spectrum response = splev(wave[cond],filter) freq = sol*1e10/wave[cond] data = data[cond]*(1.+redshift) # Flip arrays freq = freq[::-1] data = data[::-1] response = response[::-1] # Integrate observed = splrep(freq,response*data/freq,s=0,k=1) flux = splint(freq[0],freq[-1],observed) bp = splrep(freq,response/freq,s=0,k=1) bandpass = splint(freq[0],freq[-1],bp) return -2.5*log10(flux/bandpass) - 48.6
def N(mu, E,T,g): """ Find number of electrons by integrating g(E) * f(E,T,mu) over all E Parameters: mu: chemical potential E: energy grid T: temperature g: DOS """ tck = splrep(E, g*fermi(E,T,mu)) return splint(E[0], E[-1], tck)
def integrateCurr4(file_name,t0,t1,iS): input_file = open(file_name,'r') t0 = float(t0) t1 = float(t1) index = -1 all_time = [] all_current = [] Q = 0.0 input_lines = input_file.readlines() input_file.close() Ileak = 0 for input_line in input_lines: index += 1 tmp = input_line.split() t = float(tmp[0]) I = float(tmp[1]) if ( index == 0 ): Ileak = I if ( t>t0 ): all_time.append(t) all_current.append(I) sall_time = asarray(all_time) sall_current = asarray(all_current) splrepint = interpolate.splrep(sall_time, sall_current, s=0) currentnew = interpolate.splev(sall_time, splrepint, der=0) initial_time = [t0/2.0] sinitial_time = asarray(initial_time) tf = 0 if (t1 == -1): tf = sall_time[len(all_time)-1] else: tf = t1 charge = interpolate.splint(sall_time[0], tf, splrepint) dt = tf-sall_time[0] #Ileak = sall_current[len(sall_time)-1] currentnew = interpolate.splev(sinitial_time, splrepint, der=0) #print "Ileak =", Ileak #print "currentnew =", currentnew if ( iS == 1 ): charge -= Ileak*dt return charge
def make_numden_m_spline(self, scat=0, redshift=0.1): ''' Make splines to relate d(num-den)/d(mag) & num-den(> mag) to mag. Import scatter [dex]. ''' try: if redshift != self.redshift: self.initialize_redshift(redshift) except AttributeError: pass if scat != self.scat: self.scat = scat # convert scatter in log(lum) to scatter in magnitude mag_scat = 2.5 * self.scat deconvol_iter_num = 30 dmag = 0.01 dmag_scat_lo = 2 * mag_scat # extend fit for b.c.'s of deconvolute dmag_scat_hi = 1 * mag_scat self.mmin = 17.0 #self.mmax = 23.3 self.mmax=24. mags = np.arange(self.mmin - dmag_scat_lo, self.mmax + dmag_scat_hi, dmag, np.float32) numdens = np.zeros(mags.size) dndms = np.zeros(mags.size) for mi in xrange(len(mags)): numdens[mi] = np.abs(self.numden(mags[mi])) dndms[mi] = self.dndm(mags[mi]) #print 'numden ', numdens[:10] #print mags[:10] # make no scatter splines self.log_numden_m_spl = interpolate.splrep(mags, log10(numdens)) self.dndm_m_spl = interpolate.splrep(mags, dndms) self.m_log_numden_spl = interpolate.splrep(log10(numdens)[::-1], mags[::-1]) # make scatter splines if self.scat: # deconvolve observed lf assuming scatter to find unscattered one dndms_scat = deconvolute(dndms, mag_scat, dmag, deconvol_iter_num) # chop off boundaries, unreliable #print mags.min(), mags.max() #mags = mags[dmag_scat_lo / dmag:-dmag_scat_hi / dmag] #dndms_scat = dndms_scat[dmag_scat_lo / dmag:-dmag_scat_hi / dmag] #print mags.min(), mags.max() # find spline to integrate over self.dndm_m_scat_spl = interpolate.splrep(mags, dndms_scat) numdens_scat = np.zeros(mags.size) for mi in xrange(mags.size): numdens_scat[mi] = np.abs(interpolate.splint(mags[mi], mags.max(), self.dndm_m_scat_spl)) numdens_scat[mi] += 1e-9 * (1 - mi * 0.001) self.log_numden_m_scat_spl = interpolate.splrep(mags, log10(numdens_scat)) self.m_log_numden_scat_spl = interpolate.splrep(log10(numdens_scat)[::-1], mags[::-1])