def get_der_qln(l, nmax, nstop=100, zerolminus2=None, zerolminus1=None):
"""Returns the zeros of the spherical Bessel function derivative. Begins by
assuming that the zeros of the spherical Bessel function for l lie exactly
between the zeros of the Bessel function between l and l+1. This allows us
to use scipy's jn_zeros function. However, this function fails to return for
high n. To work around this we estimate the first 100 zeros using scipy's
jn_zero function and then iteratively find the roots of the next zero by
assuming the next zero occurs pi away from the last one. Brent's method is
then used to find a zero between pi/2 and 3pi/2 from the last zero.
Parameters
----------
l : int
Spherical Bessel function mode.
nmax : int
The maximum zero found for the spherical Bessel Function.
nstop : int
For n <= nstop we use scipy's jn_zeros to guess where the first nstop
zeros are. These estimates are improved using Brent's method and assuming
zeros lie between -pi/2 and pi/2 from the estimates.
"""
if nmax <= nstop:
nstop = nmax
if zerolminus2 is None and zerolminus1 is None:
z1 = special.jnp_zeros(l, nstop)
z2 = special.jnp_zeros(l + 1, nstop)
zeros_approx = np.ndarray.tolist(0.5 * (z1 + z2))
zeros = []
for i in range(0, len(zeros_approx)):
a = zeros_approx[i] - 0.5 * np.pi
b = zeros_approx[i] + 0.5 * np.pi
val = optimize.brentq(get_der_jl, a, b, args=(l))
zeros.append(val)
if nstop != nmax:
n = nstop
while n < nmax:
zero_last = zeros[-1]
a = zero_last + 0.5 * np.pi
b = zero_last + 1.5 * np.pi
val = optimize.brentq(get_der_jl, a, b, args=(l))
zeros.append(val)
n += 1
else:
dz = zerolminus1 - zerolminus2
z1 = zerolminus1 + 0.5 * dz
z2 = zerolminus2 + 1.5 * dz
zeros_approx = np.ndarray.tolist(0.5 * (z1 + z2))
zeros = []
for i in range(0, len(zeros_approx)):
a = zeros_approx[i] - 0.5 * np.pi
b = zeros_approx[i] + 0.5 * np.pi
val = optimize.brentq(get_der_jl, a, b, args=(l))
zeros.append(val)
zeros = np.array(zeros)
return zeros
def from_Z0(cls, frequency: 'Frequency', Z0: NumberLike,
f: NumberLike, ep_r: NumberLike = 1, mu_r: NumberLike = 1,
**kwargs):
r"""
Initialize from specified impedance at a given frequency, assuming the
fundamental TE11 mode.
Parameters
----------
frequency : Frequency Object
Z0 : number /array
characteristic impedance to create at `f`
f : number
frequency (in Hz) at which the resultant waveguide has the
characteristic impedance Z0
ep_r : number, array-like,
filling material's relative permittivity
mu_r : number, array-like
filling material's relative permeability
\*\*kwargs : arguments, keyword arguments
passed to :class:`~skrf.media.media.Media`'s constructor
(:func:`~skrf.media.media.Media.__init__`
"""
mu = mu_0*mu_r
ep = epsilon_0*ep_r
w = 2*pi*f
# if self.mode_type =="te":
u = jnp_zeros(1, 1)[-1]
r =u/(w*mu) * 1./sqrt((1/(Z0*1j)**2+ep/mu))
kwargs.update(dict(frequency=frequency, r=r, m=1, n=1, ep_r=ep_r, mu_r=mu_r))
return cls(**kwargs)
def alphaP_mn(m, n):
alpha = sp.jnp_zeros(m, n)
if m == 0:
alpha = np.roll(alpha, 1)
alpha[0] = 0
return alpha[n - 1]
def disk_harmonic_energy(n, m, bc='dirichlet'):
'''Get the energy of a disk harmonic function.
This allows for functions to sort a disk harmonic mode basis on energy.
Parameters
----------
n : int
Radial order
m : int
Azimuthal order
bc : string
The boundary conditions to use. This can be either 'dirichlet', or
'neumann' for a Dirichlet or Neumann boundary condition respectively.
Returns
-------
scalar
The energy corresponding to the mode.
'''
m = abs(m)
if bc == 'dirichlet':
lambda_mn = jn_zeros(m, n)[-1]
elif bc == 'neumann':
lambda_mn = jnp_zeros(m, n)[-1]
else:
raise RuntimeError('Boundary condition not recognized.')
return lambda_mn**2
def vangelderen_cylinder_perp_ln_terms(D, R, scheme, m_max=10):
# returns the scaling factors and the list of each summation component for ln(M(DELTA,delta,G)/M(0))
# D:= free diffusivity in m^2 s^-1
# R:= cylinder radius in m
# scheme is (N, 3) and contains all the (G, DELTA, delta)
# G:= gradient magnitude in T m^-1
# DELTA:= gradient separation in s
# delta:= gradient width s
am_R = jnp_zeros(1, m_max)[:, None]
am = am_R / R
am2 = am**2
# unpack for clarity
G = scheme[:, 0]
DELTA = scheme[:, 1]
delta = scheme[:, 2]
# multiplicative factor for each scheme point
fac = -2 * gamma**2 * G**2 / D**2
# summation terms until m_max, for each scheme point
comp = (1 / (am**6 * (am_R**2 - 1))) * (
2 * D * am2 * delta - 2 + 2 * np.exp(-D * am2 * delta) +
2 * np.exp(-D * am2 * DELTA) - np.exp(-D * am2 * (DELTA - delta)) -
np.exp(-D * am2 * (DELTA + delta)))
return fac, comp
def compute_all_robin_roots(beta, n, roots):
'''
:param beta: f = beta*J_n(x) + dJ_n(x)/dn = 0 this is how Robin is posed here
:param n: order of J_n
:param roots: number of roots
:return: np array with all the roots of f
'''
bessel_roots = ss.jn_zeros(n,roots)
der_bessel_roots = ss.jnp_zeros(n,roots)
result = np.zeros(roots)
for k in range(0,roots):
if (n == 0 and k == 0):
result[k] = optimize.bisect(alpha_function, 0, bessel_roots[k], args=(n,beta))
else:
if (n == 0):
result[k] = optimize.bisect(alpha_function, min(der_bessel_roots[k-1], bessel_roots[k]), max(der_bessel_roots[k-1], bessel_roots[k]), args=(n,beta))
else:
if (alpha_function(0,n,beta) == 0):
result[0] = 0
result[k] = optimize.bisect(alpha_function, min(der_bessel_roots[k - 1], bessel_roots[k - 1]),
max(der_bessel_roots[k - 1], bessel_roots[k - 1]), args=(n, beta))
else:
result[k] = optimize.bisect(alpha_function, min(der_bessel_roots[k], bessel_roots[k]), max(der_bessel_roots[k], bessel_roots[k]), args=(n,beta))
return result
def kc(self) -> NumberLike:
"""
Cut-off wave number.
Defined as
.. math::
k_c = \\frac{u_{mn}}{R}
where R is the radius of the waveguide, and u_mn is:
* the n-th root of the m-th Bessel function for 'tm' mode
* the n-th root of the Derivative of the m-th Bessel function for 'te' mode.
Returns
-------
kc : number
cut-off wavenumber
"""
if self.mode_type == "te":
u = jnp_zeros(self.m, self.n)[-1]
elif self.mode_type == "tm":
u = jn_zeros(self.m, self.n)[-1]
return u / self.r
def main(args):
m = 5
n = 5
l = 5
alpha = np.zeros((m, n))
for i in range(m):
alpha[i][:] = sp.jnp_zeros(i, 5)
if i == 0:
alpha[i][:] = np.roll(alpha[i][:], 1)
alpha[i][0] = 0
print alpha
frqs = np.zeros((5, 5, 5))
print "(m,n,l)"
print "-" * 10
for i_m in range(m):
for i_n in range(n):
for i_l in range(l):
fr = nat_frq(alpha[i_m, i_n], i_l)
frqs[i_m, i_n, i_l] = fr
print "(" + str(i_m) + "," + str(i_n+1) + "," + str(i_l) + "): " + str(fr)
return 0
def beta_pec(self, w, alpha):
"""Return phase constant of PEC waveguide
Args:
w: A complex indicating the angular frequency
alpha: A tuple (pol, n, m) where pol is 'M' for TM mode or
'E' for TE mode, n is the order of the mode, and m is the
number of modes in the order and the polarization.
Returns:
h: A complex indicating the phase constant.
"""
w_comp = w.real + 1j * w.imag
pol, n, m = alpha
if pol == "E":
chi = jnp_zeros(n, m)[-1]
elif pol == "M":
chi = jn_zeros(n, m)[-1]
else:
raise ValueError("pol must be 'E' or 'M")
val = np.sqrt(self.fill(w_comp) * w_comp**2 - chi**2 / self.r**2)
if abs(val.real) > abs(val.imag):
if val.real < 0:
val *= -1
else:
if val.imag < 0:
val *= -1
return val
def c2_pipe(r, t, Pe=10.**4, nmax=1000):
# Calculates exact C2(r,t) in the pipe. Assumes t scalar.
from scipy.special import jnp_zeros, j0, j1
mu = jnp_zeros(0, nmax)
Pe_fran = Pe / 2.
c2 = zeros(shape(r))
for n in range(nmax):
c2 += (-24. + 6 * mu[n]**2 + 72 * mu[n]**2 * t - 9 * mu[n]**4 * t +
6 * mu[n]**4 * r**2 * t) / (3 * mu[n]**8 * j0(mu[n])) * j0(
mu[n] * r)
c2 += (24 - 24 * mu[n]**2 * t) / (3 * mu[n]**7 * j0(mu[n])) * r * j1(
mu[n] * r)
expterm = (-120 + 9 * mu[n]**2 + mu[n]**2 * r**2 +
mu[n]**4 * t) / (3 * mu[n]**8 * j0(mu[n])) * j0(mu[n] * r)
expterm += (-2. - mu[n]**2 + mu[n]**2 * r**2) / (
3 * mu[n]**7 * j0(mu[n])) * r * j1(mu[n] * r)
c2 += exp(-mu[n]**2 * t) * expterm
#
c2 *= 4
c2 += 1. / 5760. * (29. - 240. * t - 60 * r**2 + 15 * r**4 +
240 * r**2 * t)
c2 *= Pe_fran**2
#
c2 += 2 * t
return c2
def __init__(
self,
diameter=None,
diffusion_constant=CONSTANTS['water_in_axons_diffusion_constant'],
number_of_roots=20,
number_of_functions=50,
):
self.diameter = diameter
self.Dintra = diffusion_constant
self.alpha = np.empty((number_of_roots, number_of_functions))
self.alpha[0, 0] = 0
if number_of_roots > 1:
self.alpha[1:, 0] = special.jnp_zeros(0, number_of_roots - 1)
for m in range(1, number_of_functions):
self.alpha[:, m] = special.jnp_zeros(m, number_of_roots)
def vangelderen_cylinder_perp_ln_terms_TAYLOR(D, R, scheme, m_max=10):
# not going to bother changing the description, it's the same thing but every exponential inside the sum as been taylored (exp(-x) = 1 + x)
# by doing so we can take out everything other then the bessel roots from the summation
# DISCLAIMER, this computation is weirdly off by an exact factor of 2 from Neuman
# returns the scaling factors and the list of each summation component for ln(M(DELTA,delta,G)/M(0))
# D:= free diffusivity in m^2 s^-1
# R:= cylinder radius in m
# scheme is (N, 3) and contains all the (G, DELTA, delta)
# G:= gradient magnitude in T m^-1
# DELTA:= gradient separation in s
# delta:= gradient width s
xm = jnp_zeros(1, m_max)[:, None]
# unpack for clarity
G = scheme[:, 0]
DELTA = scheme[:, 1]
delta = scheme[:, 2]
# multiplicative factor for each scheme point
fac = -8 * gamma**2 * G**2 * R**4 / D
# summation terms until m_max, for each scheme point
comp = (1 / (xm**4 * (xm**2 - 1)))
return fac, comp
def ExactSolutionFull(m=1, n=0):
kap = special.jnp_zeros(m, n + 1)[n]
if m >= 1 and n >= 0:
return lambda r, theta, z: special.jn(m, kap * r) * np.cos(
m * theta) * (np.cosh(kap * (1.0 + z)) / np.cosh(kap))
else:
return lambda r, theta, z: 0
def from_Z0(cls, frequency, Z0, f, ep_r=1, mu_r=1, **kw):
'''
Initialize from specified impedance at a given frequency, assuming the
fundamental TE11 mode.
Parameters
-------------
frequency : Frequency Object
Z0 : number /array
characteristic impedance to create at `f`
f : number
frequency (in Hz) at which the resultant waveguide has the
characteristic impedance Z0
'''
mu = mu_0 * mu_r
ep = epsilon_0 * ep_r
w = 2 * pi * f
# if self.mode_type =="te":
u = jnp_zeros(1, 1)[-1]
r = u / (w * mu) * 1. / sqrt((1 / (Z0 * 1j)**2 + ep / mu))
kw.update(
dict(frequency=frequency, r=r, m=1, n=1, ep_r=ep_r, mu_r=mu_r))
return cls(**kw)
def calc_te(n, m, freq, a):
"""Calculat mode in circular waveguide
:param n: TE n
:param m: TE m
:param freq: frequency in Hz
:param a: radius of circle waveguide in m
:return: Er, Ephi, Hr, Hphi
"""
wavelength = C0 / freq
ds = wavelength / 3
k = 2 * pi / wavelength
# here I multiply 1.1 only to calculate more space.
N = 3 * round(1.1 * a * 2 / ds) + 1
x0 = np.linspace(-1.1 * a, 1.1 * a, N)
x, y = np.meshgrid(x0, x0)
pnm = jnp_zeros(n, m)
pnm = pnm[m - 1]
kc = pnm / a
fc = C0 * kc / 2 / pi
if freq < fc:
raise Exception("This mode cannot spread!")
beta = np.sqrt(k**2 - kc**2)
w = 2 * pi * freq
epsr = eps0 * 1
A = 1
B = 1
phi, r = cart2pol(x, y)
r[np.where(r == 0)] = ds / 100
z = 0
# Transverse Electric field
Er = -1j * w * mue0 * n / kc / kc / r * (
A * np.cos(n * phi) - B * np.sin(n * phi)) * jv(n, kc * r) * np.exp(
-1j * beta * z)
Ephi = 1j * w * mue0 / kc * (A * np.sin(n * phi) + B * np.cos(n * phi)
) * jvp(n, kc * r) * np.exp(-1j * beta * z)
# Transverse Magnetic field
Hr = -1j * beta / kc * (A * np.sin(n * phi) + B * np.cos(n * phi)) * jvp(
n, kc * r) * np.exp(-1j * beta * z)
Hphi = -1j * beta * n / kc / kc / r * (
A * np.cos(n * phi) - B * np.sin(n * phi)) * jv(n, kc * r) * np.exp(
-1j * beta * z)
E_abs = np.hypot(np.abs(Er), np.abs(Ephi))
E_abs[np.where(r > a)] = 1e-20
# filename = 'TE{n},{m}.dat'.format(n=n, m=m)
# E_abs.tofile(filename)
print("Calculation Complete!")
return Er, Ephi, Hr, Hphi
def nj_dev(pr=0, m=31, n=11, deg=0):
if deg == 0:
x_mn = jn_zeros(m, n)[-1]
func = jvp(m, x_mn, 0) * yvp(m, x_mn * pr, 0)
elif deg == 1:
x_mn = jnp_zeros(m, n)[-1]
func = jvp(m, x_mn, 1) * yvp(m, x_mn * pr, 0)
print(x_mn)
return func
def __init__(
self,
mu=None, lambda_par=None,
diameter=None,
diffusion_perpendicular=CONSTANTS['water_in_axons_diffusion_constant'],
number_of_roots=20,
number_of_functions=50,
):
self.mu = mu
self.lambda_par = lambda_par
self.diffusion_perpendicular = diffusion_perpendicular
self.diameter = diameter
self.alpha = np.empty((number_of_roots, number_of_functions))
self.alpha[0, 0] = 0
if number_of_roots > 1:
self.alpha[1:, 0] = special.jnp_zeros(0, number_of_roots - 1)
for m in range(1, number_of_functions):
self.alpha[:, m] = special.jnp_zeros(m, number_of_roots)
def __init__(self, n, p, a):
self.n = n
self.p = p
self.a = a
self.X_np = special.jn_zeros(n,p)[-1]
self.dX_np = special.jnp_zeros(n,p)[-1]
self.f_TE = 2 * self.Fc_TE()
self.f_TM = 2 * self.Fc_TM()
self.w_TE = 2 * PI * self.f_TE
self.w_TM = 2 * PI * self.f_TM
def u_jnu_jnpu_pec(num_n, num_m):
us = np.empty((2, num_n, num_m))
jnus = np.empty((2, num_n, num_m))
jnpus = np.empty((2, num_n, num_m))
for n in range(num_n):
us[0, n] = jnp_zeros(n, num_m)
us[1, n] = jn_zeros(n, num_m)
jnus[0, n] = jv(n, us[0, n])
jnus[1, n] = np.zeros(num_m)
jnpus[0, n] = np.zeros(num_m)
jnpus[1, n] = jvp(n, us[1, n])
return us, jnus, jnpus
def disk_harmonic(n, m, D=1, bc='dirichlet', grid=None):
'''Create a disk harmonic.
Parameters
----------
n : int
Radial order
m : int
Azimuthal order
D : scalar
The diameter of the pupil.
bc : string
The boundary conditions to use. This can be either 'dirichlet', or
'neumann' for a Dirichlet or Neumann boundary condition respectively.
grid : Grid
The grid on which to evaluate the function.
Returns
-------
Field
The disk harmonic function evaluated on `grid`.
Raises
------
ValueError
If the boundary condition is not recognized.
'''
polar_grid = grid.as_('polar')
r = 2 * polar_grid.r / D
theta = polar_grid.theta
m_negative = m < 0
m = abs(m)
if bc == 'dirichlet':
lambda_mn = jn_zeros(m, n)[-1]
norm = 1
elif bc == 'neumann':
lambda_mn = jnp_zeros(m, n)[-1]
norm = 1
else:
raise ValueError('Boundary condition not recognized.')
if m_negative:
z = norm * jv(m, lambda_mn * r) * np.sin(m * theta)
else:
z = norm * jv(m, lambda_mn * r) * np.cos(m * theta)
# Do manual normalization for now...
mask = circular_aperture(D)(grid) > 0.5
norm = np.sqrt(np.sum(z[mask]**2))
return Field(z * mask / norm, grid)
def vangelderen_cylinder_perp_ln_list(D, R, DELTA, delta, G, m_max=10):
# returns the scaling factor and the list of each summation component for ln(M(DELTA,delta,G)/M(0))
# D:= free diffusivity in m^2 s^-1
# R:= cylinder radius in m
# DELTA:= gradient separation in s
# delta:= gradient width s
# G:= gradient magnitude in T m^-1
am_R = jnp_zeros(1,m_max)
am = am_R / R
am2 = am**2
fac = -2*gamma**2*G**2/D**2
comp = (1/(am**6*(am_R**2-1))) * (2*D*am2*delta - 2 + 2*np.exp(-D*am2*delta) + 2*np.exp(-D*am2*DELTA) - np.exp(-D*am2*(DELTA-delta)) - np.exp(-D*am2*(DELTA+delta)))
return fac, comp
def __init__(self,a,H,e2,p=1,f=None,mode="TE"):
self.mode=mode
if mode=='TE':
self.Xmn=spl.jnp_zeros(0,1)[0]
elif mode=='TM':
self.Xmn=spl.jn_zeros(0,1)[0]
else:
raise ValueError("mode must be either 'TE' or 'TM'" )
self.a=a
self.H=H
self.e2=e2
self.p=p
self.f=f
self.err=0
def m2_pipe(t, Pe=10.**4, nmax=1000, m20=0.):
# Calculates exact M2 in the pipe. Optional
# initial M2(t=0), m20 included.
from scipy.special import jnp_zeros
mu = jnp_zeros(0, nmax)
Pe_fran = Pe / 2.
m2 = m20 + 2. * t + Pe_fran**2 * (-1. / 1440. + 1. / 96. * t)
for n in range(nmax):
m2 += Pe_fran**2 * 32. * (exp(-(mu[n]**2) * t) / (mu[n]**8))
# end for
return m2
def c1_pipe(r, t, Pe=10.**4, nmax=1000):
# Calculates exact C1(r,t) in the pipe. Assumes t scalar.
from scipy.special import jnp_zeros, j0
mu = jnp_zeros(0, nmax)
Pe_fran = Pe / 2.
c1 = zeros(shape(r))
for n in range(nmax):
c1 += 1. / (j0(mu[n]) *
mu[n]**4) * (1. - exp(-mu[n]**2 * t) * j0(mu[n] * r))
#
c1 *= -4 * Pe_fran
return c1
def coaxial_wg_tm_mn(mesh, m=31, n=11, phi=90.0, radi_a=0.0, radi_b=25.0):
x, y = mesh[0], mesh[1]
r, t = np.sqrt(x**2 + y**2), np.arctan(y / x)
a, b = radi_a, radi_b
x0_mn = jn_zeros(m, n)[-1]
x1_mn = jnp_zeros(m, n)[-1]
if m == 0:
e_m = 1
else:
e_m = 2
func = np.sqrt(e_m / np.pi)
func *= 1 / np.abs(jvp(m + 1, x0_mn))
func *= (-jvp(m, x0_mn * r / b, 0) * np.cos(m * t) +
m / x0_mn * jvp(m, x0_mn * r / b, 0) / r * np.sin(m * t))
return func
def circle_wg_te_mn(mesh, m=31, n=11, phi=90.0, radi=25.0):
x, y = mesh[0], mesh[1]
r, t = np.sqrt(x**2 + y**2), np.arctan(y / x)
b = radi
x0_mn = jn_zeros(m, n)[-1]
x1_mn = jnp_zeros(m, n)[-1]
if m == 0:
e_m = 1
else:
e_m = 2
func = np.sqrt(e_m / np.pi)
func *= 1 / (np.sqrt(x1_mn**2 - m**2) * np.abs(jvp(m + 1, x0_mn)))
func *= (-m * jvp(m, x1_mn * r / b, 0) / r * np.cos(m * t) +
x1_mn * jvp(m, x1_mn * r / b, 1) / b * np.sin(m * t))
return func
def m3_pipe(t, Pe=10.**4, nmax=1000, m30=0.):
# Calculates exact M3 in the pipe. Optional
# initial M3(t=0), m30 included.
from scipy.special import jnp_zeros
mu = jnp_zeros(0, nmax)
Pe_fran = Pe / 2.
m3 = 1. / 480. * (-17. / 896. + 112. / 896. * t)
for n in range(nmax):
m3 += 16. * exp(-(mu[n]**2) * t) * (-240. / (mu[n]**12) + 18. /
(mu[n]**10) + t / (mu[n]**8))
# end for
m3 *= Pe_fran**3
return m3
def norm(self, w, h, alpha, a, b):
pol, n, m = alpha
en = 1 if n == 0 else 2
if self.clad(w).real < -1e6:
radius = self.r
if pol == 'E':
u = jnp_zeros(n, m)[-1]
jnu = jv(n, u)
jnpu = 0.0
else:
u = jn_zeros(n, m)[-1]
jnu = 0.0
jnpu = jvp(n, u)
return np.sqrt(a**2 * np.pi * radius**2 / en *
(1 - n**2 / u**2) * jnu**2 +
b**2 * np.pi * radius**2 / en * jnpu**2)
# ac = a.conjugate()
# bc = b.conjugate()
u = self.samples.u(h**2, w, self.fill(w))
jnu = jv(n, u)
jnpu = jvp(n, u)
v = self.samples.v(h**2, w, self.clad(w))
knv = kv(n, v)
knpv = kvp(n, v)
# uc = u.conjugate()
# jnuc = jnu.conjugate()
# jnpuc = jnpu.conjugate()
# vc = v.conjugate()
# knvc = knv.conjugate()
# knpvc = knpv.conjugate()
val_u = 2 * np.pi * self.r**2 / en
val_v = val_u * ((u * jnu) / (v * knv))**2
# val_v = val_u * (uc * u * jnuc * jnu) / (vc * v * knvc * knv)
upart_diag = self.upart_diag(n, u, jnu, jnpu, u, jnu, jnpu)
vpart_diag = self.vpart_diag(n, v, knv, knpv, v, knv, knpv)
upart_off = self.upart_off(n, u, jnu, u, jnu)
vpart_off = self.vpart_off(n, v, knv, v, knv)
return np.sqrt(val_u * (a * (a * upart_diag + b * upart_off) + b *
(b * upart_diag + a * upart_off)) - val_v *
(a * (a * vpart_diag + b * vpart_off) + b *
(b * vpart_diag + a * vpart_off)))
def _ncrs_python(self, Delta, delta, d, R, G):
if R == 0 or R < np.finfo(float).eps:
return 0
GAMMA = 267.5987E6
alpha_roots = jnp_zeros(1, 16) / R
sum = 0
for i in range(20):
alpha = alpha_roots[i]
num = (2 * d * alpha**2 * delta - 2 +
2 * np.exp(-d * alpha**2 * delta) +
2 * np.exp(-d * alpha**2 * Delta) -
np.exp(-d * alpha**2 * (Delta - delta)) -
np.exp(-d * alpha**2 * (Delta + delta)))
dem = d**2 * alpha**6 * (R**2 * alpha**2 - 1)
sum += (num / dem)
return -2 * GAMMA**2 * G**2 * sum
def main(args):
m = 5
n = 5
x = 5
alpha = np.zeros((m, n))
for i in range(m):
alpha[i][:] = sp.jnp_zeros(i, 5)
if i == 0:
alpha[i][:] = np.roll(alpha[i][:], 1)
alpha[i][0] = 0
print alpha
frqs = np.zeros((5, 5, 5))
print "(m,n,l)"
print "-" * 10
for i_m in range(m):
for i_n in range(n):
for i_x in range(x):
i_l = i_x * 2 + 1
frqs[i_m, i_n, i_x] = nat_frq(alpha[i_m, i_n], i_l)
B = np.sort(frqs, axis=None)
print "Minima"
print "-" * 10
for i_m in range(m):
for i_n in range(n):
for i_x in range(x):
if frqs[i_m, i_n, i_x] in B[:5]:
i_l = i_x * 2 + 1
print "(" + str(i_m) + "," + str(i_n + 1) + "," + str(
i_l) + "): " + str(frqs[i_m, i_n, i_x])
return 0
