def tetmConstants(self, ri, ro, neff, wl, EH, c, idx): a = numpy.empty((2, 2)) n = self.maxIndex(wl) u = self.u(ro, neff, wl) urp = self.u(ri, neff, wl) if neff < n: B1 = j0(u) B2 = y0(u) F1 = j0(urp) / B1 F2 = y0(urp) / B2 F3 = -j1(urp) / B1 F4 = -y1(urp) / B2 c1 = wl.k0 * ro / u else: B1 = i0(u) B2 = k0(u) F1 = i0(urp) / B1 F2 = k0(urp) / B2 F3 = i1(urp) / B1 F4 = -k1(urp) / B2 c1 = -wl.k0 * ro / u c3 = c * c1 a[0, 0] = F1 a[0, 1] = F2 a[1, 0] = F3 * c3 a[1, 1] = F4 * c3 return numpy.linalg.solve(a, EH.take(idx))
def cutoffTE(b): # EXP: 2.4220557071361126 a = rho * b return (i0(u1 * a) * (j0(u2 * b) * yn(2, u2 * a) - y0(u2 * b) * jn(2, u2 * a)) - iv(2, u1 * a) * (j0(u2 * a) * y0(u2 * b) - y0(u2 * a) * j0(u2 * b)))
def qd(rd, td): from scipy.special import j1 from scipy.special import j0 import math if td < 0.01: return 2 * td ** 0.5 / 3.14159265359 ** 0.5 else: b = [1.129552, 1.160436, 0.2642821, 0.01131791, 0.5900113, 0.04589742, 1.0, 0.5002034, 1.50, 1.979139] qd_inf = (b[0] * td ** b[7] + b[1] * td + b[2] * td ** b[8] + b[3] * td ** b[9]) / ( b[4] * td ** b[7] + b[5] * td + b[6]) if rd > 100: return qd_inf b1 = [-0.00222107, -0.627638, 6.277915, -2.734405, 1.2708, -1.100417] b2 = [-0.00796608, -1.85408, 18.71169, -2.758326, 4.829162, -1.009021] alpha1 = beta(b1, rd) alpha2 = beta(b2, rd) J0Alpha1 = j0(alpha1) J0Alpha2 = j0(alpha2) J1Alpha1rd = j1(alpha1 * rd) J1Alpha2rd = j1(alpha2 * rd) qd_fin = (rd ** 2 - 1) / 2 - (2 * math.exp(-alpha1 ** 2 * td) * J1Alpha1rd ** 2) / ( alpha1 ** 2 * (J0Alpha1 ** 2 - J1Alpha1rd ** 2)) - ( 2 * math.exp(-alpha2 ** 2 * td) * J1Alpha2rd ** 2) / ( alpha2 ** 2 * (J0Alpha2 ** 2 - J1Alpha2rd ** 2)) return min(qd_inf, qd_fin)
def main(L, N): A = 3.1926 a = 180 # [m] H = a / 3 # [m] X0 = X = linspace(-a, a, N) # [m] Y0 = Y = -H * 1 / 6.04844 * (sp.j0(A) * sp.i0(A * X / a) - sp.i0(A) * sp.j0(A * X / a)) if L > 0: X = insert(X, 0, -L) X = append(X, L) Y = insert(Y, 0, 0) Y = append(Y, 0) h = 10 # writing CSV g = column_stack((0 * X, X, Y)) f = open('HillShape_X.csv', 'wb') csvWriter = csv.writer(f, delimiter=',') csvWriter.writerow(X) f.close() f = open('HillShape_Y.csv', 'wb') csvWriter = csv.writer(f, delimiter=',') csvWriter.writerow(Y) f.close() return X, Y
def gradient(pos_previous, pos_current): #Calculate the concentration C cos_sum = 1 + 2 * (np.cos(pos_previous[:, 1] - pos_current[1])) * np.exp(-k3) for i in range(2, 41): cos_sum += 2 * np.cos( i * (pos_previous[:, 1] - pos_current[1])) * np.exp(-k3 * i**2) sin_sum = -2 * (np.sin(pos_previous[:, 1] - pos_current[1])) * np.exp(-k3) for i in range(2, 41): sin_sum += -2 * i * np.sin( i * (pos_previous[:, 1] - pos_current[1])) * np.exp(-k3 * i**2) C = sp.j0(pos_previous[:, 0] - pos_current[0]) * cos_sum * np.exp(-( (pos_previous[:, 2] - pos_current[2])**2) / k5) # Calculate the gradients grad = threeCol # gradient in r direction posx = pos_previous[:, 0] - pos_current[0] Grad_2 = -1 * sp.jv(1, posx) grad[0] = np.sum(Grad_2) # gradient in theta direction grad[1] = np.sum( (sp.j0(pos_previous[:, 0] - pos_current[0]) / rad) * sin_sum * np.exp(-((pos_previous[:, 2] - pos_current[2])**2) / k5)) # gradient in z direction grad[2] = np.sum(C * (-2) * (pos_previous[:, 1] - pos_current[1]) / k5) return grad
def cutoffTM(b): # EXP: 2.604335468618898 a = rho * b return (n22 / n12 * (j0(u2 * b) * yn(2, u2 * a) - y0(u2 * b) * jn(2, u2 * a)) + (n22 / n12 - 1 + iv(2, u1 * a) / i0(u1 * a)) * (j0(u2 * b) * y0(u2 * a) - y0(u2 * b) * j0(u2 * a)))
def exact(k, R1, R2, derivs): if (derivs): # Bessel evaluated at R1 J0_1 = special.j0(k * R1) Y0_1 = special.y0(k * R1) J1_1 = special.j1(k * R1) Y1_1 = special.y1(k * R1) # Bessel evaluated at R2 J0_2 = special.j0(k * R2) Y0_2 = special.y0(k * R2) J1_2 = special.j1(k * R2) Y1_2 = special.y1(k * R2) # # d Z1(k r)/dr = k*Z0(k r) - Z1(k r) / r # Jprime_1 = k * J0_1 - J1_1 / R1 Jprime_2 = k * J0_2 - J1_2 / R2 Yprime_1 = k * Y0_1 - Y1_1 / R1 Yprime_2 = k * Y0_2 - Y1_2 / R2 else: Jprime_1 = special.jvp(1, k * R1, 1) Jprime_2 = special.jvp(1, k * R2, 1) Yprime_1 = special.yvp(1, k * R1, 1) Yprime_2 = special.yvp(1, k * R2, 1) # F(k r) = J'_m(kr R1) * Y'_m(kr R2) - J'_m(kr R2) * Y'_m(kr R1) = 0 return Jprime_1 * Yprime_2 - Jprime_2 * Yprime_1
def g_int_lamarche(x, tt, Rt, rt, kt, gam, v): # tt = Fourier number # re = outer radius of the equivalent tube for concentric cylinders # rb = borehole radius # ks = soil thermal conductivity # kg = grout thermal conductivity # als = soil thermal diffusivity # alg = grout thermal diffusivity zeta1 = (1 - v * Rt * x**2) * y1(x) - v * x * y0(x) zeta2 = (1 - v * Rt * x**2) * j1(x) - v * x * j0(x) psi = (zeta2 * (j0(x * rt * gam) * y1(x * rt) - j1(x * rt * gam) * y0(x * rt) * kt * gam) - zeta1 * (j0(x * rt * gam) * j1(x * rt) - j1(x * rt * gam) * j0(x * rt) * kt * gam)) phi = (zeta1 * (y0(x * rt * gam) * j1(x * rt) - y1(x * rt * gam) * j0(x * rt) * kt * gam) - zeta2 * (y0(x * rt * gam) * y1(x * rt) - y1(x * rt * gam) * y0(x * rt) * kt * gam)) I = (1 - exp(-x**2 * tt)) / (x**5 * (phi**2 + psi**2)) return I
def u(r, t, eps, colslag, date=None): if date != None: updateParameret_array(date) numerator = (parameter_array['l'] * parameter_array['betta'] * parameter_array['P']) denominator = (50 * sp.pi * parameter_array['alf'] * parameter_array['a']**2) all = numerator / denominator x = ((-2 * parameter_array['alf'] * t) / (parameter_array['c'] * parameter_array['l'])) u = all * (1 - np.exp(x)) if (colslag == 0): if dataChanged[0] == 1: N = analitic_eps(eps) for i in np.arange(1, N, 1): u += An(i, t) * spc.j0((bessel0[i] * r) / parameter_array['R']) else: N = array_norm_N[str(eps)] for i in np.arange(1, N, 1): u += An(i, t) * spc.j0((bessel0[i] * r) / parameter_array['R']) else: for i in np.arange(1, colslag, 1): u += An(i, t) * spc.j0((bessel0[i] * r) / parameter_array['R']) return u
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 get_three_parts(self): # get rid of x1 as it's not needed x1 = -1. if self.physics.D == 3: A, _, _, x2 = self.get_coeff_three_part_3D(full_output=True) if x2 is None: # the search for the three-part coefficients did not converge: # the three-part solution may not be appropriate three_parts_lower = False three_parts_upper = False else: # tests for validity of three-part solution if self.physics.coupling == 'linear' and self.high_density: three_parts_lower = ( self.phi_c + A * np.sin(self.x0) / self.x0 > 1. / 3.) three_parts_upper = ( 5. / 6. > self.phi_c + A * np.sin(self.x0) / self.x0) else: three_parts_lower = ( self.phi_c + A * np.sinh(self.nu_eff * self.x0) / self.x0 > 1. / 3.) three_parts_upper = ( 5. / 6. > self.phi_c + A * np.sinh(self.nu_eff * self.x0) / self.x0) elif self.physics.D == 2: A, _, _, x2 = self.get_coeff_three_part_2D(full_output=True) if x2 is None: # the search for the three-part coefficients did not converge: # the three-part solution may not be appropriate three_parts_lower = False three_parts_upper = False else: if self.physics.coupling == 'linear' and self.high_density: three_parts_lower = (self.phi_c + A * j0(self.x0) > 1. / 3.) three_parts_upper = (5. / 6. > self.phi_c + A * j0(self.x0)) else: three_parts_lower = ( self.phi_c + A * i0(self.nu_eff * self.x0) > 1. / 3.) three_parts_upper = ( 5. / 6. > self.phi_c + A * i0(self.nu_eff * self.x0)) three_parts = three_parts_lower and three_parts_upper return x1, x2, three_parts
def __init__(self): from scipy.special import j0, jv self.full_well = 200000 # Table 5 of [1] bandwidths = [45, 46, 47] optical_throughput = [0.516, 0.605, 0.602] quantum_efficiencies = [0.4, 0.35, 0.13] self.polarized_bands = [0.47, 0.66, 0.862] num_subframes = 23 p = np.linspace(0.0, 1.0, num_subframes + 1) p1 = p[0:-1] p2 = p[1:] x = 0.5 * (p1 + p2 - 1) delta0_list = [4.472, 3.081, 2.284] r = 0.0 eta = 0.009 self.p, self.correlation, self.w, self.reflectance_to_electrons = dict( ), dict(), dict(), dict() for wavelength, delta0, ot, qe, bw in zip(self.polarized_bands, delta0_list, optical_throughput, quantum_efficiencies, bandwidths): # Define z'(x_n) (Eq. 8in [1]) z_idx = np.pi * x != eta z = np.full_like(x, r) z[z_idx] = -2 * delta0 * np.sin(np.pi * x - eta)[z_idx] * np.sqrt( 1 + r**2 / np.tan(np.pi * x - eta)[z_idx]) # Define s_n (Eq. 9 in [1]) s = np.ones(shape=(num_subframes)) s_idx = z_idx if r == 0 else np.ones_like(x, dtype=np.bool) s[s_idx] = (np.tan(np.pi * x - eta)**2 - r)[s_idx] / (np.tan(np.pi * x - eta)**2 + r)[s_idx] # Define F(x_n) (Eq. 7 in [1]) f = j0(z) + (1 / 3) * (np.pi * (p2 - p1) / 2)**2 * delta0**2 * ( 1 - r**2) * (s * jv(2, z) - np.cos(2 * (np.pi * x - eta)) * j0(z)) # P modulation matrix for I, Q, U with and idealized modulator (without the linear correction factor) # Eq. 15 of [1] pq = np.vstack((np.ones_like(x), f, np.zeros_like(x))).T pu = np.vstack((np.ones_like(x), np.zeros_like(x), f)).T self.p[wavelength] = np.vstack((pq, pu)) self.correlation[wavelength] = np.matmul(self.p[wavelength].T, self.p[wavelength]) # W demodulation matrix (Eq. 16 of [1]) self.w[wavelength] = np.linalg.pinv(self.p[wavelength]) # Transform rho into S (Eq. (24) of [1]) self.reflectance_to_electrons[wavelength] = (1.408 * 10**18 * ot * qe * bw) / \ ((1000*wavelength)**4 * (np.exp(2489.7/(1000*wavelength))) - 1)
def modified_bessel(times, bes_A, bes_Omega, bes_s, res_begin, bes_Delta): """ Not Tested. """ b = np.where( times > res_begin + bes_Delta / 2., special.j0(bes_s * bes_Omega * (-res_begin + times - bes_Delta / 2.)), (np.where(times < res_begin - bes_Delta / 2., special.j0(bes_Omega * (res_begin - times - bes_Delta / 2.)), 1))) return bes_A * b
def update(val): dd = sdd.val II = [] for t in tt: F1 = sp.j0(np.pi * (t - dd / 2.)) + sp.jn(2, np.pi * (t - dd / 2.)) F2 = sp.j0(np.pi * (t + dd / 2.)) + sp.jn(2, np.pi * (t + dd / 2.)) II.append(F1 * F1 + F2 * F2) l.set_ydata(II) fig.canvas.draw_idle()
def _kernel_ssc_integrand(self, chi, ktheta_a, ktheta_b, norm=1.0): D_z = self.cosmo.growth_factor(self.cosmo.redshift(chi)) return (norm * self.window_function_a1.window_function(chi) * self.window_function_a2.window_function(chi) * self.window_function_b1.window_function(chi) * self.window_function_b2.window_function(chi) * D_z * D_z * D_z * D_z * D_z * D_z * self._sigma2(chi) / chi * special.j0(ktheta_a * chi) * special.j0(ktheta_b * chi))
def _kernel_NG_integrand(self, chi, ktheta_a, ktheta_b, norm=1.0): D_z = self.cosmo.growth_factor(self.cosmo.redshift(chi)) return (norm*self.window_function_a1.window_function(chi)* self.window_function_a2.window_function(chi)* self.window_function_b1.window_function(chi)* self.window_function_b2.window_function(chi)* D_z*D_z*D_z*D_z/(chi*chi)* special.j0(ktheta_a*chi)*special.j0(ktheta_b*chi))
def qd(rd, td): """ Dimensionless cumulative production (QD) using Klins et al. Polynomial Approach to Bessel Functions in Aquifer """ from scipy.special import j1 from scipy.special import j0 import math import mpmath def csch(x): if x > 100: return 0 else: return float(mpmath.csch(x)) def beta(b, rd): return b[0] + b[1] * csch( rd) + b[2] * rd**b[3] + b[4] * rd**b[5] # Algorithm if td < 0.01: return 2 * td**0.5 / 3.14159265359**0.5 else: b = [ 1.129552, 1.160436, 0.2642821, 0.01131791, 0.5900113, 0.04589742, 1.0, 0.5002034, 1.50, 1.979139 ] qd_inf = (b[0] * td**b[7] + b[1] * td + b[2] * td**b[8] + b[3] * td**b[9]) / (b[4] * td**b[7] + b[5] * td + b[6]) if rd > 100: return qd_inf b1 = [ -0.00222107, -0.627638, 6.277915, -2.734405, 1.2708, -1.100417 ] b2 = [ -0.00796608, -1.85408, 18.71169, -2.758326, 4.829162, -1.009021 ] alpha1 = beta(b1, rd) alpha2 = beta(b2, rd) J0Alpha1 = j0(alpha1) J0Alpha2 = j0(alpha2) J1Alpha1rd = j1(alpha1 * rd) J1Alpha2rd = j1(alpha2 * rd) qd_fin = (rd**2 - 1) / 2 - ( 2 * math.exp(-alpha1**2 * td) * J1Alpha1rd**2) / ( alpha1**2 * (J0Alpha1**2 - J1Alpha1rd**2)) - ( 2 * math.exp(-alpha2**2 * td) * J1Alpha2rd**2) / (alpha2**2 * (J0Alpha2**2 - J1Alpha2rd**2)) return min(qd_inf, qd_fin)
def nonlocal_model(p, en, get_G=False, get_N=False, pristine=False): af1, ef1, af2, ef2, c0, v1, v2, g1, g2, t1, t2 = p g0 = 3.0 c0 = float(c0) b = 1600 f1 = af1 * np.cos(k * np.pi) + ef1 f2 = af2 * np.cos(k * np.pi) + ef2 c = (k**2. - c0**2) * b / c0**2 G = np.zeros([6, len(en), len(k)], dtype=np.complex128) for ix, enval in enumerate(en): w0 = enval + 1j * g0 w1 = enval + 1j * g1 w2 = enval + 1j * g2 denominator = (c - w0) * (f1 - w1) * (f2 - w2) - (v2**2 * (f1 - w1) + v1**2 * (f2 - w2)) * (np.sin( np.pi * k)**2) G[0, ix] = (-(f1 - w1) * (f2 - w2)) / denominator G[1, ix] = (-(c - w0) * (f2 - w2) + v2**2 * np.sin(np.pi * k)**2) / denominator G[2, ix] = (-(c - w0) * (f1 - w1) + v1**2 * np.sin(np.pi * k)**2) / denominator G[3, ix] = -(v1 * (f2 - w2)) / denominator G[4, ix] = -(v2 * (f1 - w1)) / denominator G[5, ix] = -v1 * v2 * np.sin(np.pi * k)**2 / denominator if get_G: return G N = np.zeros([9, len(en)], dtype=np.complex128) N[0] = (0.5 / np.pi) * np.sum(k * G[0], axis=1) N[1] = (0.5 / np.pi) * np.sum(k * G[1], axis=1) N[2] = (0.5 / np.pi) * np.sum(k * G[2], axis=1) N[3] = (0.5 / np.pi) * np.sum(k * G[5], axis=1) N[4] = (0.5 / np.pi) * np.sum(k * G[1] * j0(2 * k), axis=1) N[5] = (0.5 / np.pi) * np.sum(k * G[2] * j0(2 * k), axis=1) N[6] = (0.5 / np.pi) * np.sum(k * G[5] * j0(2 * k), axis=1) N[7] = (0.25 / np.pi) * np.sum(k * G[3] * (1 - j0(2 * k)), axis=1) N[8] = (0.25 / np.pi) * np.sum(k * G[4] * (1 - j0(2 * k)), axis=1) if get_N: return N if pristine: didv = -1 * (np.imag(N[0]) + 4 * t1**2 * np.imag(N[1]) + 4 * t2**2 * np.imag(N[2]) + 8 * t1 * t2 * np.imag(N[3]) - 4 * t1**2 * np.imag(N[4]) - 4 * t2**2 * np.imag(N[5]) - 8 * t1 * t2 * np.imag(N[6]) + 8 * t1 * np.imag(N[7]) + 8 * t2 * np.imag(N[8])) else: didv = -1 * (np.imag(N[0]) + 2 * t1**2 * np.imag(N[1]) + 2 * t2**2 * np.imag(N[2]) + 8 * t1 * t2 * np.imag(N[3]) - 4 * t1**2 * np.imag(N[4]) - 4 * t2**2 * np.imag(N[5]) - 8 * t1 * t2 * np.imag(N[6]) + 8 * t1 * np.imag(N[7]) + 8 * t2 * np.imag(N[8])) return didv
def enframe(samples, beta=8.5, overlapping=0, window_length=240, window_type='Rectangle'): """ divede samples into frame :param samples: :param beta: parameter for kaiser window :param frame_num: :param window_length: :param window_type: :return: enframed frames """ frames_num = len(samples) // (window_length - overlapping) frames = np.zeros([frames_num, window_length]) for i in range(frames_num): start = i * (window_length - overlapping) end = start + window_length data = samples[start:end] N = len(data) x = np.linspace(0, N - 1, N, dtype=np.int64) if window_type == 'Rectangle': data = data elif window_type == 'Triangle': for i in range(N): if i < N: data[i] = 2 * i / (N - 1) else: data[i] = 2 - 2 * i / (N - 1) elif window_type == 'Hamming': w = 0.54 - 0.46 * np.cos(2 * np.pi * x / (N - 1)) data = data * w elif window_type == 'Hanning': w = 0.5 * (1 - np.cos(2 * np.pi * x / (N - 1))) data = data * w elif window_type == 'Blackman': w = 0.42 - 0.5 * (1 - np.cos(2 * np.pi * x / (N - 1))) + 0.08 * np.cos( 4 * np.pi * x / (N - 1)) data = data * w elif window_type == 'Kaiser': w = special.j0( beta * np.sqrt(1 - np.square(1 - 2 * x / (N - 1)))) / special.j0(beta) data = data * w else: raise NameError('Unrecongnized window type') frames[i] = data return frames
def _tecoeq(self, v0, nu): u1r1, u2r1, u2r2, s1, s2, n1sq, n2sq, n3sq = self.__params(v0) (f11a, f11b) = ((j0(u1r1), jn(2, u1r1)) if s1 > 0 else (i0(u1r1), -iv(2, u1r1))) if s2 > 0: f22a, f22b = j0(u2r2), y0(u2r2) f2a = jn(2, u2r1) * f22b - yn(2, u2r1) * f22a f2b = j0(u2r1) * f22b - y0(u2r1) * f22a else: # a f22a, f22b = i0(u2r2), k0(u2r2) f2a = kn(2, u2r1) * f22a - iv(2, u2r1) * f22b f2b = i0(u2r1) * f22b - k0(u2r1) * f22a return f11a * f2a - f11b * f2b
def tau_binf (a, c): # numerator : integrand = lambda x, a,c: (1-np.exp(-x**2/(4*a**2*c**2))) / x**3 * (ss.y0(x/a)*ss.j0(x)-ss.j0(x/a)*ss.y0(x)) / (ss.y0(x)**2+ss.j0(x)**2) - log(1/a)/(2*a**2*c**2*π) / (1 + 4/π**2 * (np.euler_gamma+np.log(x/2))**2) / x # |------------------- g1 -------------------------------------------------------------------------------------| |-------------------------- g2 -----------------------------------------| cutoff = 100*max(1,c) I = sint.quad( integrand, 0, cutoff, args=(a,c), epsrel=1e-5, limit=1000 )[0] int_num = I + log(1/a)*int_2_rem(cutoff)/(4*a**2*c**2) # denominator : integrand = lambda x, a,c: ( np.exp(-x**2/(4*a**2*c**2)) * (ss.y0(x/a)*ss.j0(x)-ss.j0(x/a)*ss.y0(x)) / (ss.y0(x)**2+ss.j0(x)**2) - 2/π * log(1/a) / (1 + 4/π**2 * (np.euler_gamma+np.log(x/2))**2) ) / x # |----------------- f1 ----------------------------------------------------------------------------| |-------------------------- f2 -------------------------------| cutoff = max(10,2*c**2) I = sint.quad( integrand, 0, cutoff, args=(a,c), epsrel=1e-7, limit=1000 )[0] den = 1 - 2/π * (I + log(1/a)*int_2_rem(cutoff)) return 8*a**2/π * int_num / den
def init_TST(self, Rmax_new, Nr_new): """ Setup DHT transform and data buffers. Parameters ---------- Rmax_new: float (m) (optional) New radial size for the output calculation domain. If not defined `Rmax` will be used. Nr_new: int New number of nodes of the radial grid. If is `None`, `Nr` will be used. """ Rmax = self.Rmax Nr = self.Nr dtype = self.dtype self.Rmax_new = Rmax_new if self.Rmax_new is None: self.Rmax_new = Rmax self.Nr_new = Nr_new if self.Nr_new is None: self.Nr_new = Nr self.r_new = np.linspace(0, self.Rmax_new, self.Nr_new) alpha = jn_zeros(0, Nr + 1) alpha_np1 = alpha[-1] alpha = alpha[:-1] kr = self.bcknd.to_host(self.kr) self.TM = j0(self.r[:, None] * kr[None, :]) self.TM = self.bcknd.inv(self.TM, dtype) self.invTM = self.bcknd.to_device(\ j0(self.r_new[:,None]*kr[None,:]), dtype) self.shape_trns = (self.Nr, ) self.shape_trns_new = (self.Nr_new, ) self.u_loc = self.bcknd.zeros(self.Nr, dtype) self.u_ht = self.bcknd.zeros(self.Nr, dtype) self.u_iht = self.bcknd.zeros(self.Nr_new, dtype) self.TST_matmul = self.bcknd.make_matmul(self.TM, self.u_loc, self.u_ht) self.iTST_matmul = self.bcknd.make_matmul(self.invTM, self.u_ht, self.u_iht)
def trunc_sgf(k, L): if type(k) == np.ndarray: out = np.zeros(k.shape, dtype=float) sel = k == 0 nsel = ~sel knsel = k[nsel] out[sel] = -L**2 * np.log(L) + L**2 * (1 + 2 * np.log(L)) / 4 out[nsel] = (1.0 - j0(L * knsel)) / knsel**2 - L * np.log(L) * j1( L * knsel) / knsel return out elif k == 0: return -L**2 * np.log(L) + L**2 * (1 + 2 * np.log(L)) / 4 else: return (1.0 - j0(L * k)) / k**2 - L * np.log(L) * j1(L * k) / k
def _lpfield(self, wl, nu, neff, r): rho = self.fiber.outerRadius(0) k = wl.k0 nco2 = self.fiber.maxIndex(0, wl)**2 ncl2 = self.fiber.minIndex(1, wl)**2 u = rho * k * sqrt(nco2 - neff**2) w = rho * k * sqrt(neff**2 - ncl2) if r < rho: ex = j0(u * r / rho) / j0(u) else: ex = k0(w * r / rho) / k0(w) hy = neff * Y0 * ex # Snyder & Love uses nco, but Bures uses neff return numpy.array((ex, 0, 0)), numpy.array((0, hy, 0))
def nonlocal_model(p, en, get_G=False, get_N=False, pristine=False): af1, ef1, af2, ef2, c0, v1, v2, g1, g2, t1, t2 = p g0 = 3.0 c0 = float(c0) b = 1600 f1 = af1*np.cos(k*np.pi) + ef1 f2 = af2*np.cos(k*np.pi) + ef2 c = (k**2.-c0**2) * b/c0**2 G = np.zeros([6, len(en), len(k)], dtype=np.complex128) for ix, enval in enumerate(en): w0 = enval + 1j*g0 w1 = enval + 1j*g1 w2 = enval + 1j*g2 denominator = (c - w0) * (f1 - w1) * (f2 - w2) - (v2**2 * (f1 - w1) + v1**2 * (f2 - w2)) * (np.sin(np.pi*k)**2) G[0,ix] = (-(f1 - w1) * (f2 - w2)) /denominator G[1,ix] = (-(c - w0) * (f2 - w2) + v2**2 * np.sin(np.pi*k)**2) /denominator G[2,ix] = (-(c - w0) * (f1 - w1) + v1**2 * np.sin(np.pi*k)**2) /denominator G[3,ix] = -(v1 * (f2 - w2)) /denominator G[4,ix] = -(v2 * (f1 - w1)) /denominator G[5,ix] = -v1*v2*np.sin(np.pi*k)**2 /denominator if get_G: return G N = np.zeros([9,len(en)], dtype=np.complex128) N[0] = (0.5/np.pi)*np.sum(k*G[0], axis=1) N[1] = (0.5/np.pi)*np.sum(k*G[1], axis=1) N[2] = (0.5/np.pi)*np.sum(k*G[2], axis=1) N[3] = (0.5/np.pi)*np.sum(k*G[5], axis=1) N[4] = (0.5/np.pi)*np.sum(k*G[1]*j0(2*k), axis=1) N[5] = (0.5/np.pi)*np.sum(k*G[2]*j0(2*k), axis=1) N[6] = (0.5/np.pi)*np.sum(k*G[5]*j0(2*k), axis=1) N[7] = (0.25/np.pi)*np.sum(k*G[3]*(1-j0(2*k)), axis=1) N[8] = (0.25/np.pi)*np.sum(k*G[4]*(1-j0(2*k)), axis=1) if get_N: return N if pristine: didv = -1*(np.imag(N[0]) + 4*t1**2*np.imag(N[1]) + 4*t2**2*np.imag(N[2]) + 8*t1*t2*np.imag(N[3]) - 4*t1**2*np.imag(N[4]) - 4*t2**2*np.imag(N[5]) - 8*t1*t2*np.imag(N[6]) + 8*t1*np.imag(N[7]) + 8*t2*np.imag(N[8])) else: didv = -1*(np.imag(N[0]) + 2*t1**2*np.imag(N[1]) + 2*t2**2*np.imag(N[2]) + 8*t1*t2*np.imag(N[3]) - 4*t1**2*np.imag(N[4]) - 4*t2**2*np.imag(N[5]) - 8*t1*t2*np.imag(N[6]) + 8*t1*np.imag(N[7]) + 8*t2*np.imag(N[8])) return didv
def plotrcfte(): V = numpy.linspace(1, 7) rho = 0.5 f = j0(V) * yn(2, V*rho) - y0(V) * jn(2, rho*V) pyplot.plot(V, f) pyplot.show()
def experimental_eps(r, t, eps, date=None): if date != None: updateParameret_array(date) numerator = (parameter_array['l'] * parameter_array['betta'] * parameter_array['P']) denominator = (50 * sp.pi * parameter_array['alf'] * parameter_array['a']**2) all = numerator / denominator x = ((-2 * parameter_array['alf'] * t) / (parameter_array['c'] * parameter_array['l'])) u = all * (1 - np.exp(x)) N = analitic_eps(eps) for i in np.arange(1, N + 1, 1): u += An(i, t) * spc.j0((bessel0[i] * r) / parameter_array['R']) flag.append(u) i = N - 2 analit_eps = flag[N - 1] while (abs(analit_eps - flag[i]) <= eps) and (i > 0): i = i - 1 if ((i + 2) > NMAX[0]): NMAX[0] = i + 2 flag.clear() return NMAX[0]
def calculate_1D_truncated_coulomb(pd, q_v=None, N_c=None): """ Simple 1D truncation of Coulomb kernel PRB 73, 205119. The periodic direction is determined from k-point grid. """ from scipy.special import j1, k0, j0, k1 qG_Gv = pd.get_reciprocal_vectors(add_q=True) if pd.kd.gamma: if q_v is not None: qG_Gv += q_v else: raise ValueError('Presently, calculations only work with a small q in the normal direction') # The periodic direction is determined from k-point grid Nn_c = np.where(N_c == 1)[0] Np_c = np.where(N_c != 1)[0] if len(Nn_c) != 2: # The k-point grid does not fit with boundary conditions Nn_c = [0, 1] # Choose reduced cell vectors 0, 1 Np_c = [2] # Choose reduced cell vector 2 # The radius is determined from area of non-periodic part of cell Acell_cv = pd.gd.cell_cv[Nn_c, :][:, Nn_c] R = (np.linalg.det(Acell_cv) / np.pi)**0.5 qGnR_G = (qG_Gv[:, Nn_c[0]]**2 + qG_Gv[:, Nn_c[1]]**2)**0.5 * R qGpR_G = abs(qG_Gv[:, Np_c[0]]) * R v_G = 4 * np.pi / (qG_Gv**2).sum(axis=1) v_G *= (1.0 + qGnR_G * j1(qGnR_G) * k0(qGpR_G) - qGpR_G * j0(qGnR_G) * k1(qGpR_G)) return v_G.astype(complex)
def get_roots(self): j0_rng = np.linspace(0, 40, 400) j0_value = [special.j0(i) for i in j0_rng] j0_interval = Bessel.get_intervals(j0_rng, j0_value, 10) if len(j0_interval) == 0: raise RuntimeError("No roots of Bessel function were found") self.roots = [optimize.bisect(special.j0, i[0], i[1]) for i in j0_interval]
def angular_corr_func(thetas, zs, dn_dz_1, dn_dz_2): # thetas from degrees to radians thetas = (thetas * u.deg).to('radian').value # get dimensionless power spectrum deltasquare = power_spec_at_zs(zs, read=False, dimensionless=True) # power spectrum over k^2 first_term = deltasquare / (k_grid**2) # everything inside Bessel function # has 3 dimensions, k, theta, and z # therefore need to do outer product of two arrays, then broadcast 3rd array to 3D and multiply besselterm = j0( cosmo.comovingDistance(np.zeros(len(zs)), zs)[:, None, None] * np.outer(k_grid, thetas)) # Not sure if this is right # I think you need to convert H(z)/c from 1/Mpc to h/Mpc in order to cancel units of k, but not sure dz_d_chi = (apcosmo.H(zs) / const.c).to(u.littleh / u.Mpc, u.with_H0(apcosmo.H0)).value # product of redshift distributions, and dz/dchi differentials = dz_d_chi * dn_dz_1 * dn_dz_2 # total integrand is all terms multiplied out. This is a 3D array integrand = np.pi * differentials * np.transpose( first_term) * np.transpose(besselterm) # do k integral first along k axis k_int = np.trapz(integrand, k_grid, axis=1) # then integrate along z axis total = np.trapz(k_int, zs, axis=1) return total
def gravground( x , y , g , G , *args , **kwargs): ''' def gravground( x , y , g , G , *args , **kwargs): Create the Thomas-Fermi ground state for a gravitational system ''' X,Y = np.meshgrid(x,y) R = np.sqrt( X ** 2. + Y ** 2. ) bj0z1 = jn_zeros( 0, 1 ) #First zero of zeroth order besselj scaling = np.sqrt( 2 * np.pi * G / g ) gr0 = bj0z1 / scaling Rprime = R * scaling gtfsol = j0( Rprime ) * np.array( [ map( int,ii ) for ii in map( lambda rad: rad <= gr0, R ) ] ) gtfsol *= scaling ** 2. / ( 2 * np.pi * j1( bj0z1 ) * bj0z1 ) return gtfsol
def BeamFunction(self, apfunc, r, sigma, wl, thetamax=5, nsamples=128): """ apfunc - Aperture distribution function r - Radius out to D/2 (m) sigma - taper width in wavelengths over dish wl - wavelength (m) """ # Convert to No. wavelength units rho = r / wl drho = np.abs(rho[1] - rho[0]) # To store output beam pattern. beam = np.zeros(nsamples) # Line-of-sight angles to calculate beam power thetas = np.linspace(0, thetamax, nsamples) * np.pi / 180. # Loop over thetas for i, theta in enumerate(thetas): # Tools of Radio Astronomy 5th Ed. eqn. 6.67 top = np.sum( apfunc(r, sigma, wl) * j0(2 * np.pi * np.sin(theta) * rho) * rho) * drho bot = np.sum(apfunc(r, sigma, wl) * rho) * drho beam[i] = np.abs(top / bot)**2 return beam, thetas * 180 / np.pi
def Bn(n): j0 = spc.j0(bessel0[n]) j1 = spc.j1(bessel0[n] / 5) numerator = 2 * parameter_array['betta'] * parameter_array['P'] * j1 denominator = 5 * parameter_array['c'] * np.pi * ( parameter_array['a'])**2 * bessel0[n] * (j0)**2 return numerator / denominator
def sears_lift_sin_gust(w0, L, Uinf, chord, tv): """ Returns the lift coefficient for a sinusoidal gust (see set_gust.sin) as the imaginary part of the CL complex function defined below. The input gust must be the imaginary part of .. math:: wgust = w0*\exp(1.0j*C*(Ux*S.time[tt] - xcoord) ) with: .. math:: C=2\pi/L and ``xcoord=0`` at the aerofoil half-chord. """ # reduced frequency kg = np.pi * chord / L # Theo's funciton Ctheo = theo_fun(kg) # Sear's function J0, J1 = scsp.j0(kg), scsp.j1(kg) S = (J0 - 1.0j * J1) * Ctheo + 1.0j * J1 phase = np.angle(S) CL = 2. * np.pi * w0 / Uinf * np.abs(S) * np.sin(2. * np.pi * Uinf / L * tv + phase) return CL
def _kernel_integrand(self, chi, ktheta): D_z = self.cosmo.growth_factor(self.cosmo.redshift(chi)) z = self.cosmo.redshift(chi) return (self.window_function_a.window_function(chi)* self.window_function_b.window_function(chi)* D_z*D_z*special.j0(ktheta*chi))
def _tmcoeq(self, v0, nu): u1r1, u2r1, u2r2, s1, s2, n1sq, n2sq, n3sq = self.__params(v0) if s1 == 0: # e f11a, f11b = 2, 1 elif s1 > 0: # a, b, d f11a, f11b = j0(u1r1) * u1r1, j1(u1r1) else: # c f11a, f11b = i0(u1r1) * u1r1, i1(u1r1) if s2 > 0: f22a, f22b = j0(u2r2), y0(u2r2) f2a = j1(u2r1) * f22b - y1(u2r1) * f22a f2b = j0(u2r1) * f22b - y0(u2r1) * f22a else: # a f22a, f22b = i0(u2r2), k0(u2r2) f2a = i1(u2r1) * f22b + k1(u2r1) * f22a f2b = i0(u2r1) * f22b - k0(u2r1) * f22a return f11a * n2sq * f2a - f11b * n1sq * f2b * u2r1
def function1D(self, x): A0 = self.getParameterValue("A0") alpha = self.getParameterValue("alpha") fi = self.getParameterValue("fi") nu = self.getParameterValue("nu") LamT = self.getParameterValue("LamT") LamL = self.getParameterValue("LamL") return A0*( alpha*(2.0*np.pi*nu*x+(np.pi)/180.0)*sp.j0(x)*np.exp(-LamT*x) + (1.0-alpha)*np.exp(-LamL*x) )
def plotCF(): ncl = 1.444 nco = ncl + 0.05 V = numpy.linspace(1, 7) pyplot.plot(V, j0(V)) pyplot.plot(V, j1(V)) pyplot.plot(V, jn(2, V)) n02 = ncl*ncl / (nco * nco) a = (1 - n02) / (1 + n02) pyplot.plot(V, a * jn(2, V) - j0(V)) pyplot.plot(V, a * jn(3, V) - j1(V)) pyplot.plot(V, a * jn(4, V) - jn(2, V)) pyplot.axhline(0, ls='--', color='k') pyplot.show()
def _j1(self, x): if self._nu == -1: return j0(x) elif self._nu == 0: return j1(x) elif isinstance(self._nu, int): return jn(self._nu + 1, x) else: return jv(self._nu + 1, x)
def __integrand(self,theta): """ theta and theta_R should be in radians """ if theta==0: return self.F_ell else: return self.F_ell *\ j0(theta*self.ell)
def funcZetaCyl(z, Bi): """ zeta, Bi function for cylinder as f(z) = z*J1(z) - Bi*J0(z) note that J1 and J0 are bessel functions z = zeta values which are later solved for the positive roots for theta Bi = Biot number h*L/k, (-) """ f = z*sp.j1(z) - Bi*sp.j0(z) return f
def __integrand(self,theta): """ Internal method to construct integrand. Theta should be in radians """ if theta==0: return self.F_ell else: return self.F_ell * j0(self.ell*theta)
def _j1(self, x): if self._nu == -1: return j0(x) elif self._nu == 0: return j1(x) elif np.floor(self._nu) == self._nu: return jn(self._nu + 1, x) else: return jv(self._nu + 1, x)
def J0_plot(self): """Sample J0 at linspace(0, 20, 200)""" x = linspace(0, 20, 200) y = j0(x) x1 = x[::10] y1 = map(j0i, x1) self.pyplot.plot(x, y, label=r'$J_0(x)$') # self.pyplot.plot(x1, y1, 'ro', label=r'$J_0^{integ}(x)$') self.pyplot.title(r'Verify $J_0(x)=\frac{1}{\pi}\int_0^{\pi}\cos(x \sin\phi)\,d\phi$') self.pyplot.xlabel('$x$') self.pyplot.legend()
def main(sampleFile): A = 3.1926 a = 180 # [m] H = a/3 # [m] X = linspace(-a,a,301) # [m] Y = - H * 1/6.04844 * ( sp.j0(A)*sp.i0(A*X/a) - sp.i0(A)*sp.j0(A*X/a) ) X = insert(X,0,1000); X = append(X,1000) Y = insert(Y,0,0); Y = append(Y,0) h = 10 # interpolating for a refined line xSample = linspace(-1000,1000,2000) ySample = interp(xSample,X,Y) # opening file infile = open(sampleFile,"r") outfile = open(sampleFile + "_t","w") N = i = 0 value = 0.0 # reading first line line = infile.readline() while line: # finding the "nonuniform" line if line.find("points")>0 and line.find("//")<0: outfile.write(line) # writing new sample line shape for x,y in zip(xSample,ySample): sampleLine = " ( %12.10f %12.10f %12.10f )\n" % (x,value, y+h) outfile.write(sampleLine) line = infile.readline() else: outfile.write(line) # reading new line line = infile.readline() # close files infile.close() outfile.close() # copying original to new and viceversa subprocess.call("cp -r " + sampleFile + " " + sampleFile + "_temp",shell=True) subprocess.call("cp -r " + sampleFile + "_t " + sampleFile,shell=True)
def integrand_circ(self,theta): #circular window: F = 2*J_1(theta*ell)/(theta*ell) theta *= ARCMIN_TO_RAD A = 1E10 factor = 2./ numpy.pi / self.theta_s_rad**2 / A integrand = lambda ell : \ A * self.P2D(ell) \ * special.j1(self.theta_s_rad*ell)**2 \ * special.j0(theta * ell) / ell return factor,integrand
def integrand_gaus(self,theta): #gaussian window: F = exp( -0.5*(theta*ell)**2 ) theta *= ARCMIN_TO_RAD A = 1E10 factor = 0.5 / numpy.pi / A integrand = lambda ell: \ A * self.P2D(ell) \ * numpy.exp( -(theta*ell)**2 ) \ * special.j0(theta * ell) * ell return factor,integrand
def funcCn(root, b): """ First term in the theta function root = root from the zeta, Bi equation b = shape factor where 2 sphere, 1 cylinder, 0 slab """ if b == 2: Cn = 4*(np.sin(root)-root*np.cos(root)) / (2*root-np.sin(2*root)) elif b == 1: Cn = (2/root) * (sp.j1(root) / (sp.j0(root)**2 + sp.j1(root)**2)) elif b == 0: Cn = (4*np.sin(root)) / (2*root + np.sin(2*root)) return Cn
def funcDn(r, root, b): """ Second term in the theta function root = root from the zeta, Bi equation b = shape factor where 2 sphere, 1 cylinder, 0 slab """ if b == 2: Dn = (1/(root*r)) * np.sin(root*r) elif b == 1: Dn = sp.j0(root * r) elif b == 0: Dn = np.cos(root * r) return Dn
def NCD(Nucleus,Model,Range=2,Bins=100): """Returns the Nuclear Charge Distribution for a given Nucleus with specified model. Creates radial distribution from 0 to Range*nuclear radius with n number of bins. If no values are set, defaults to 197Au using two-parameter Fermi model up to twice the nuclear radius with 100 bins.""" #For multiple models of the same nucleus takes the first set of parameters and notifies the user which parameters are used. j=[] for index in range(len(pNucleus)): if pNucleus[index]==Nucleus and pModel[index]==Model: j.append(index) i=index j=np.array(j,dtype=int) if len(j)>1: #print "Multiple parameters detected for given model. Using primary values." i=j[0] r=np.linspace(0,Range*float(pr2[i]),Bins) if Model=='HO': return (1+float(pZ_Alpha[i])*(r/float(pC_A[i]))**2)*np.exp(-1*(r/float(pC_A[i]))**2) elif Model=='MHO': print "Warning: Model not yet supported\nPlease use a different model." return None elif Model=='Mi': print "Warning: Model not yet supported\nPlease use a different model." return None elif Model=='FB': #print "Warning: Fourier-Bessel Model currently contains support for He-3 only. If not simulating He-3 collisions, please choose another model." for FBindex in range(len(FBnucleus)): if FBnucleus[FBindex]==Nucleus: iFB=FBindex r=np.linspace(0,float(FBR[iFB]),Bins) p=np.zeros(np.size(r),float) v=np.arange(0,17,1) for i in range(len(r)): p[i]=abs(sum(FBa[iFB-1,v]*j0((v+1)*np.pi*r[i]/float(FBR[iFB])))) return p elif Model=='SOG': print "Warning: Model not yet supported\nPlease use a different model." return None elif Model=='2pF': return 1/(1+np.exp((r-float(pC_A[i]))/float(pZ_Alpha[i]))) elif Model=='3pF': return (1+float(pw[i])*r**2/float(pC_A[i])**2)/(1+np.exp((r-float(pC_A[i]))/float(pZ_Alpha[i]))) elif Model=='3pG': return (1+float(pw[i])*r**2/float(pC_A[i])**2)/(1+np.exp((r**2-float(pC_A[i])**2)/float(pZ_Alpha[i])**2)) elif Model=='UG': print "Warning: Model not yet supported\nPlease use a different model." return None else: print 'Error: Model not found\nPlease check that the model was typed in correctly. (Case Sensitive)' return None
def main(L,N): A = 3.1926 a = 180 # [m] H = a/3 # [m] X0 = X = linspace(-a,a,N) # [m] Y0 = Y = - H * 1/6.04844 * ( sp.j0(A)*sp.i0(A*X/a) - sp.i0(A)*sp.j0(A*X/a) ) if L>0: X = insert(X,0,-L); X = append(X,L) Y = insert(Y,0,0); Y = append(Y,0) h = 10 # writing CSV g = column_stack((0*X,X,Y)) f = open('HillShape_X.csv','wb') csvWriter = csv.writer(f, delimiter=',') csvWriter.writerow(X) f.close() f = open('HillShape_Y.csv','wb') csvWriter = csv.writer(f, delimiter=',') csvWriter.writerow(Y) f.close() return X,Y
def autofrompower_3d(k, pk,rr): """Cmpute the autocorrelation function a 3D dimensionful power spectrum, such as you might get from CAMB. From Challinor's structure notes: P(k) = < δ δ*> Δ^2 = P(k) k^3/(2π^2) ζ(r) = int dk/k Δ^2 j_0(kr) = int dk (k^2) P(k) j_0(kr) / (2π^2) Arguments: k - k values pk - power spectrum r - values of r = | x-y | at which to evaluate the autocorrelation """ auto = np.array([np.sum(pk*j0(k*r)*k**2/2/math.pi**2)/np.size(k) for r in rr]) return auto
def _tefield(self, wl, nu, neff, r): rho = self.fiber.outerRadius(0) k = wl.k0 nco2 = self.fiber.maxIndex(0, wl)**2 ncl2 = self.fiber.minIndex(1, wl)**2 u = rho * k * sqrt(nco2 - neff**2) w = rho * k * sqrt(neff**2 - ncl2) if r < rho: hz = -Y0 * u / (k * rho) * j0(u * r / rho) / j1(u) ephi = -j1(u * r / rho) / j1(u) else: hz = Y0 * w / (k * rho) * k0(w * r / rho) / k1(w) ephi = -k1(w * r / rho) / k1(w) hr = -neff * Y0 * ephi return numpy.array((0, ephi, 0)), numpy.array((hr, 0, hz))
def _tmfield(self, wl, nu, neff, r): rho = self.fiber.outerRadius(0) k = wl.k0 nco2 = self.fiber.maxIndex(0, wl)**2 ncl2 = self.fiber.minIndex(1, wl)**2 u = rho * k * sqrt(nco2 - neff**2) w = rho * k * sqrt(neff**2 - ncl2) if r < rho: ez = -u / (k * neff * rho) * j0(u * r / rho) / j1(u) er = j1(u * r / rho) / j1(u) hphi = Y0 * nco2 / neff * er else: ez = nco2 / ncl2 * w / (k * neff * rho) * k0(w * r / rho) / k1(w) er = nco2 / ncl2 * k1(w * r / rho) / k1(w) hphi = Y0 * nco2 / ncl2 * k1(w * r / rho) / k1(w) return numpy.array((er, 0, ez)), numpy.array((0, hphi, 0))
def v1D_Coulomb(qG, N_p, N_np, R): """Coulomb Potential in the 1D Periodic Case. Nanotube/Nanowire/Atomic Chain calculation. Cutoff in non-periodic N_np directions. No cutoff in periodic N_p direction. :: v1D = 4 pi/|q+G|^2 * [1 + |G_n|R J_1(|G_n|R) K_0(G_p R) - G_p R J_0(|G_n| R) K_1(G_p R)] """ from scipy.special import j1, k0, j0, k1 G_nR = (qG[:, N_np[0]]**2 + qG[:, N_np[1]]**2)**0.5 * R G_pR = abs(qG[:, N_p[0]]) * R v_q = 1. / (qG**2).sum(axis=1) v_q *= (1. + G_nR * j1(G_nR) * k0(G_pR) - G_pR * j0(G_nR) * k1(G_pR)) return v_q
def calculateFelParameters(input): p = FelParameters() p.gamma0 = input.gamma0 p.delgam = input.delgam p.xlamd = input.xlamd # undulator period p.ex = input.emitx p.ey = input.emity p.rxbeam = input.rxbeam p.rybeam = input.rybeam p.aw0 = input.aw0 p.Ip = input.curpeak p.deta = p.delgam / p.gamma0 p.lambda0 = p.xlamd / (2.0 * p.gamma0**2) *(1.0 + p.aw0**2) p.k0 = 2 * np.pi / p.lambda0 p.Ia = 17000.0 a = p.aw0**2 / (2*(1+p.aw0**2)) p.fc = sf.j0(a) - sf.j1(a) p.N = p.Ip * p.lambda0 / 1.4399644850445153e-10 p.sigb = 0.5 * (p.rxbeam + p.rybeam) p.rho = (1.0 / p.gamma0) * np.power( (p.aw0 * p.fc * p.xlamd / (8.0 * np.pi * p.sigb) )**2 * p.Ip / p.Ia, 1.0/3.0) p.Pb = p.gamma0 * p.Ip * 510998.927 p.power = 6.0 * np.sqrt(np.pi) * p.rho**2 * p.Pb / (p.N * np.log(p.N / p.rho) ) p.lg = p.xlamd / (4*np.pi * np.sqrt(3) * p.rho) p.zr = 4 * np.pi * p.sigb**2 / p.lambda0 xie_a = [0.45, 0.57, 0.55, 1.6, 3.0, 2.0, 0.35, 2.9, 2.4, 51.0, 0.95, 3.0, 5.4, 0.7, 1.9, 1140.0, 2.2, 2.9, 3.2] p.xie_etad = p.lg / (2 * p.k0 * p.sigb**2) p.xie_etae = 0 p.xie_etagamma = p.deta / (p.rho * np.sqrt(3)) p.xie_lscale = xie_a[0] * p.xie_etad ** xie_a[1] + xie_a[2] * p.xie_etae ** xie_a[3] + xie_a[4] * p.xie_etagamma ** xie_a[5] return p
def LambDipole(model, U=.01,R = 1.): """ Generate Lamb's dipole vorticity field. Parameters ----------- U: float Translation speed (dipole's strength). R: float Diple's radius. Return ------- q: array of floats Vorticity (physical space). """ N = model.nx x, y = model.x, model.y x0,y0 = x[N//2,N//2],y[N//2,N//2] r = np.sqrt( (x-x0)**2 + (y-y0)**2 ) s = np.zeros_like(r) for i in range(N): for j in range(N): if r[i,j] == 0.: s[i,j] = 0. else: s[i,j] = (y[i,j]-y0)/r[i,j] lam = (3.8317)/R C = -(2.*U*lam)/(special.j0(lam*R)) q = np.zeros_like(r) q[r<=R] = C*special.j1(lam*r[r<=R])*s[r<=R] return q