ttim.besselnumba_total

Attributes

tiny
c
fac
nrange
a
b
fac
b
a
gam
afar
fac
bot
fac
psi
psi
a1
b1
twologhalf
wg
xg

Functions

besselk0far(z, Nt)	besselk0far.
besselk0near(z, Nt)	besselk0near.
besselk1near(z, Nt)	besselk1near.
besselk0cheb(z, Nt)	besselk0cheb.
besselk1cheb(z, Nt)	besselk1cheb.
besselk0(x, y, lab)	besselk0.
besselk1(x, y, lab)	besselk1.
k0bessel(z)	k0bessel.
besselk0v(x, y, lab, nlab, omega)	besselk0v.
k0besselv(z, nlab, omega)	k0besselv.
besselk0OLD(x, y, lab)	besselk0OLD.
lapls_int_ho(x, y, z1, z2, order)	lapls_int_ho.
bessellsreal(x, y, x1, y1, x2, y2, lab)	Bessellsreal.
bessellsrealho(x, y, x1, y1, x2, y2, lab, order)	Bessellsrealho.
bessells_int(x, y, z1, z2, lab)	bessells_int.
bessells_int_ho(x, y, z1, z2, lab, order, d1, d2)	bessells_int_ho.
bessells_int_ho_qxqy(x, y, z1, z2, lab, order, d1, d2)	bessells_int_ho_qxqy.
bessells_gauss(x, y, z1, z2, lab)	bessells_gauss.
bessells_gauss_ho(x, y, z1, z2, lab, order)	bessells_gauss_ho.
bessells_gauss_ho_d1d2(x, y, z1, z2, lab, order, d1, d2)	Returns integral from d1 to d2 along real axis.
bessells_gauss_ho_qxqy(x, y, z1, z2, lab, order)	bessells_gauss_ho_qxqy.
bessells_gauss_ho_qxqy_d1d2(x, y, z1, z2, lab, order, ...)	Returns integral from d1 to d2 along real axis.
bessells(x, y, z1, z2, lab, order, d1in, d2in)	Bessells.
bessellsv(x, y, z1, z2, lab, order, R, nlab)	Bessellsv.
bessellsv2(x, y, z1, z2, lab, order, R, nlab)	bessellsv2.
bessellsqxqy(x, y, z1, z2, lab, order, d1in, d2in)	Bessellsqxqy.
bessellsqxqyv(x, y, z1, z2, lab, order, R, nlab)	Bessellsqxqyv.
bessellsqxqyv2(x, y, z1, z2, lab, order, R, nlab)	bessellsqxqyv2.
bessellsuni(x, y, z1, z2, lab)	Bessellsuni.
bessellsuniv(x, y, z1, z2, lab, nlab)	Bessellsuniv.
lapld_int_ho(x, y, z1, z2, order)	lapld_int_ho.
lapld_int_ho_d1d2(x, y, z1, z2, order, d1, d2)	lapld_int_ho_d1d2.
lapld_int_ho_wdis(x, y, z1, z2, order)	lapld_int_ho_wdis.
lapld_int_ho_wdis_d1d2(x, y, z1, z2, order, d1, d2)	lapld_int_ho_wdis_d1d2.
besselld_int_ho(x, y, z1, z2, lab, order, d1, d2)	besselld_int_ho.
besselld_gauss_ho(x, y, z1, z2, lab, order)	besselld_gauss_ho.
besselld_gauss_ho_d1d2(x, y, z1, z2, lab, order, d1, d2)	besselld_gauss_ho_d1d2.
besselld(x, y, z1, z2, lab, order, d1in, d2in)	Besselld.
besselldv(x, y, z1, z2, lab, order, R, nlab)	Besselldv.
besselldv2(x, y, z1, z2, lab, order, R, nlab)	besselldv2.
besselldpart(x, y, z1, z2, lab, order, d1, d2)	Besselldpart.
besselld_int_ho_qxqy(x, y, z1, z2, lab, order, d1, d2)	besselld_int_ho_qxqy.
besselld_gauss_ho_qxqy(x, y, z1, z2, lab, order)	besselld_gauss_ho_qxqy.
besselld_gauss_ho_qxqy_d1d2(x, y, z1, z2, lab, order, ...)	Returns integral from d1 to d2 along real axis.
besselldqxqy(x, y, z1, z2, lab, order, d1in, d2in)	Besselldqxqy.
besselldqxqyv(x, y, z1, z2, lab, order, R, nlab)	Besselldqxqyv.
besselldqxqyv2(x, y, z1, z2, lab, order, R, nlab)	besselldqxqyv2.
bessells_circcheck(x, y, z1in, z2in, lab)	bessells_circcheck.
is_too_far(z1, z2, zc, R)	Checks whether zc is more than R away from oval surrounding line element.
circle_line_intersection(z1, z2, zc, R)	circle_line_intersection.
find_d1d2(z1, z2, zc, R)	find_d1d2.
isinside(z1, z2, zc, R)	Checks whether point zc is within oval with 'radius' R from line element.

Module Contents

ttim.besselnumba_total.tiny = 1e-10

ttim.besselnumba_total.c

ttim.besselnumba_total.fac = 1.0

ttim.besselnumba_total.nrange

ttim.besselnumba_total.a

ttim.besselnumba_total.b

ttim.besselnumba_total.fac

ttim.besselnumba_total.b

ttim.besselnumba_total.a

ttim.besselnumba_total.gam

ttim.besselnumba_total.afar

ttim.besselnumba_total.fac = 1.0

ttim.besselnumba_total.bot

ttim.besselnumba_total.fac

ttim.besselnumba_total.psi

ttim.besselnumba_total.psi

ttim.besselnumba_total.a1

ttim.besselnumba_total.b1

ttim.besselnumba_total.twologhalf

ttim.besselnumba_total.wg

ttim.besselnumba_total.xg

ttim.besselnumba_total.besselk0far(z, Nt)

besselk0far.

implicit none complex(kind=8), intent(in) :: z integer, intent(in) :: Nt complex(kind=8) :: omega, term integer :: n

ttim.besselnumba_total.besselk0near(z, Nt)

besselk0near.

implicit none complex(kind=8), intent(in) :: z integer, intent(in) :: Nt complex(kind=8) :: omega complex(kind=8) :: rsq, log1, term integer :: n

ttim.besselnumba_total.besselk1near(z, Nt)

besselk1near.

implicit none complex(kind=8), intent(in) :: z integer, intent(in) :: Nt complex(kind=8) :: omega complex(kind=8) :: zsq, log1, term integer :: n

ttim.besselnumba_total.besselk0cheb(z, Nt)

besselk0cheb.

implicit none complex(kind=8), intent(in) :: z integer, intent(in) :: Nt complex(kind=8) :: omega integer :: n, n2, ts real(kind=8) :: a, b, c, A3, u complex(kind=8) :: A1, A2, cn, cnp1, cnp2, cnp3 complex(kind=8) :: z1, z2, S, T

ttim.besselnumba_total.besselk1cheb(z, Nt)

besselk1cheb.

implicit none complex(kind=8), intent(in) :: z integer, intent(in) :: Nt complex(kind=8) :: omega integer :: n, n2, ts real(kind=8) :: a, b, c, A3, u complex(kind=8) :: A1, A2, cn, cnp1, cnp2, cnp3 complex(kind=8) :: z1, z2, S, T

ttim.besselnumba_total.besselk0(x, y, lab)

besselk0.

implicit none real(kind=8), intent(in) :: x,y complex(kind=8), intent(in) :: lab complex(kind=8) :: z, omega real(kind=8) :: cond

ttim.besselnumba_total.besselk1(x, y, lab)

besselk1.

implicit none real(kind=8), intent(in) :: x,y complex(kind=8), intent(in) :: lab complex(kind=8) :: z, omega real(kind=8) :: cond

ttim.besselnumba_total.k0bessel(z)

k0bessel.

implicit none complex(kind=8), intent(in) :: z complex(kind=8) :: omega real(kind=8) :: cond

ttim.besselnumba_total.besselk0v(x, y, lab, nlab, omega)

besselk0v.

implicit none real(kind=8), intent(in) :: x,y integer, intent(in) :: nlab complex(kind=8), dimension(nlab), intent(in) :: lab complex(kind=8), dimension(nlab), intent(inout) :: omega integer :: n

ttim.besselnumba_total.k0besselv(z, nlab, omega)

k0besselv.

implicit none integer, intent(in) :: nlab complex(kind=8), dimension(nlab), intent(in) :: z complex(kind=8), dimension(nlab), intent(inout) :: omega integer :: n

ttim.besselnumba_total.besselk0OLD(x, y, lab)

besselk0OLD.

implicit none real(kind=8), intent(in) :: x,y complex(kind=8), intent(in) :: lab complex(kind=8) :: z, omega real(kind=8) :: cond

ttim.besselnumba_total.lapls_int_ho(x, y, z1, z2, order)

lapls_int_ho.

implicit none integer, intent(in) :: order real(kind=8), intent(in) :: x,y complex(kind=8), intent(in) :: z1,z2 complex(kind=8), dimension(1:order+1) :: omega complex(kind=8), dimension(1:order+2) :: qm integer :: m, i real(kind=8) :: L complex(kind=8) :: z, zplus1, zmin1, log1, log2, log3, zpower

ttim.besselnumba_total.bessellsreal(x, y, x1, y1, x2, y2, lab)

Bessellsreal.

implicit none real(kind=8), intent(in) :: x,y,x1,y1,x2,y2,lab real(kind=8) :: phi, biglab, biga, L complex(kind=8) :: z1, z2, zeta, zetabar, omega, log1, log2, term1, term2,

d1minzeta, d2minzeta

complex(kind=8), dimension(0:20) :: zminzbar complex(kind=8), dimension(0:20,0:20) :: gamnew complex(kind=8), dimension(0:40) :: alpha, beta

ttim.besselnumba_total.bessellsrealho(x, y, x1, y1, x2, y2, lab, order)

Bessellsrealho.

implicit none real(kind=8), intent(in) :: x,y,x1,y1,x2,y2,lab integer, intent(in) :: order real(kind=8), dimension(0:order) :: phi real(kind=8) :: biglab, biga, L complex(kind=8) :: z1, z2, zeta, zetabar, omega, log1, log2, term1, term2,

d1minzeta, d2minzeta

complex(kind=8), dimension(0:20) :: zminzbar complex(kind=8), dimension(0:20,0:20) :: gamnew complex(kind=8), dimension(0:40) :: alpha, beta complex(kind=8) :: cm complex(kind=8), dimension(0:50) :: alphanew, betanew !

Maximum programmed order is 10

integer :: n, m, p

ttim.besselnumba_total.bessells_int(x, y, z1, z2, lab)

bessells_int.

implicit none real(kind=8), intent(in) :: x,y complex(kind=8), intent(in) :: z1,z2,lab real(kind=8) :: biglab, biga, L, ang, tol complex(kind=8) :: zeta, zetabar, omega, log1, log2, term1, term2,

d1minzeta, d2minzeta

complex(kind=8), dimension(0:20) :: zminzbar, anew, bnew, exprange complex(kind=8), dimension(0:20,0:20) :: gamnew, gam2 complex(kind=8), dimension(0:40) :: alpha, beta, alpha2 integer :: n

ttim.besselnumba_total.bessells_int_ho(x, y, z1, z2, lab, order, d1, d2)

bessells_int_ho.

implicit none integer, intent(in) :: order real(kind=8), intent(in) :: x,y,d1,d2 complex(kind=8), intent(in) :: z1,z2,lab complex(kind=8), dimension(0:order) :: omega real(kind=8) :: biglab, biga, L, ang, tol complex(kind=8) :: zeta, zetabar, log1, log2, term1, term2, d1minzeta, d2minzeta, cm complex(kind=8), dimension(0:20) :: zminzbar, anew, bnew, exprange complex(kind=8), dimension(0:20,0:20) :: gamnew, gam2 complex(kind=8), dimension(0:40) :: alpha, beta, alpha2 complex(kind=8), dimension(0:50) :: alphanew, betanew, alphanew2 ! Order fixed to 10 integer :: m, n, p

ttim.besselnumba_total.bessells_int_ho_qxqy(x, y, z1, z2, lab, order, d1, d2)

bessells_int_ho_qxqy.

implicit none integer, intent(in) :: order real(kind=8), intent(in) :: x,y,d1,d2 complex(kind=8), intent(in) :: z1,z2,lab complex(kind=8), dimension(0:2*order+1) :: qxqy complex(kind=8), dimension(0:order) :: qx, qy real(kind=8) :: biglab, biga, L, ang, angz, tol, bigx, bigy complex(kind=8) :: zeta, zetabar, log1, log2, term1, term2, d1minzeta,

d2minzeta, bigz

complex(kind=8) :: cm, biglabcomplex complex(kind=8), dimension(0:20) :: zminzbar, anew, bnew, exprange complex(kind=8), dimension(0:20,0:20) :: gamnew, gam2 complex(kind=8), dimension(0:40) :: alpha, beta, alpha2 complex(kind=8), dimension(0:51) :: alphanew, betanew, alphanew2 ! Order fixed to 10 complex(kind=8), dimension(0:order+1) :: omega ! To store intermediate result complex(kind=8), dimension(0:order) :: omegalap ! To store intermediate result

integer :: m, n, p

ttim.besselnumba_total.bessells_gauss(x, y, z1, z2, lab)

bessells_gauss.

implicit none real(kind=8), intent(in) :: x,y complex(kind=8), intent(in) :: z1,z2 complex(kind=8), intent(in) :: lab complex(kind=8) :: omega integer :: n real(kind=8) :: L, x0 complex(kind=8) :: bigz, biglab

ttim.besselnumba_total.bessells_gauss_ho(x, y, z1, z2, lab, order)

bessells_gauss_ho.

implicit none integer, intent(in) :: order real(kind=8), intent(in) :: x,y complex(kind=8), intent(in) :: z1,z2 complex(kind=8), intent(in) :: lab complex(kind=8), dimension(0:order) :: omega integer :: n, p real(kind=8) :: L, x0 complex(kind=8) :: bigz, biglab complex(kind=8), dimension(8) :: k0

ttim.besselnumba_total.bessells_gauss_ho_d1d2(x, y, z1, z2, lab, order, d1, d2)

Returns integral from d1 to d2 along real axis.

While strength is still Delta^order from -1 to +1.

implicit none integer, intent(in) :: order real(kind=8), intent(in) :: x,y,d1,d2 complex(kind=8), intent(in) :: z1,z2,lab complex(kind=8), dimension(0:order) :: omega, omegac integer :: n, m real(kind=8) :: xp, yp, dc, fac complex(kind=8) :: z1p,z2p,bigz1,bigz2

ttim.besselnumba_total.bessells_gauss_ho_qxqy(x, y, z1, z2, lab, order)

bessells_gauss_ho_qxqy.

implicit none integer, intent(in) :: order real(kind=8), intent(in) :: x,y complex(kind=8), intent(in) :: z1,z2 complex(kind=8), intent(in) :: lab complex(kind=8), dimension(0:2*order+1) :: qxqy integer :: n, p real(kind=8) :: L, bigy, angz complex(kind=8) :: bigz, biglab real(kind=8), dimension(8) :: r, xmind complex(kind=8), dimension(8) :: k1 complex(kind=8), dimension(0:order) :: qx,qy

ttim.besselnumba_total.bessells_gauss_ho_qxqy_d1d2(x, y, z1, z2, lab, order, d1, d2)

Returns integral from d1 to d2 along real axis.

While strength is still Delta^order from -1 to +1.

implicit none integer, intent(in) :: order real(kind=8), intent(in) :: x,y,d1,d2 complex(kind=8), intent(in) :: z1,z2,lab complex(kind=8), dimension(0:2*order+1) :: qxqy, qxqyc integer :: n, m real(kind=8) :: xp, yp, dc, fac complex(kind=8) :: z1p,z2p,bigz1,bigz2

ttim.besselnumba_total.bessells(x, y, z1, z2, lab, order, d1in, d2in)

Bessells.

implicit none integer, intent(in) :: order real(kind=8), intent(in) :: x,y,d1in,d2in complex(kind=8), intent(in) :: z1,z2 complex(kind=8), intent(in) :: lab complex(kind=8), dimension(0:order) :: omega

integer :: Nls, n real(kind=8) :: Lnear, L, d1, d2, delta complex(kind=8) :: z, delz, za, zb

ttim.besselnumba_total.bessellsv(x, y, z1, z2, lab, order, R, nlab)

Bessellsv.

implicit none integer, intent(in) :: order real(kind=8), intent(in) :: x,y,R complex(kind=8), intent(in) :: z1,z2 integer, intent(in) :: nlab real(kind=8) :: d1, d2 complex(kind=8), dimension(nlab), intent(in) :: lab complex(kind=8), dimension(nlab*(order+1)) :: omega integer :: n, nterms

ttim.besselnumba_total.bessellsv2(x, y, z1, z2, lab, order, R, nlab)

bessellsv2.

implicit none integer, intent(in) :: order real(kind=8), intent(in) :: x,y,R complex(kind=8), intent(in) :: z1,z2 integer, intent(in) :: nlab real(kind=8) :: d1, d2 complex(kind=8), dimension(nlab), intent(in) :: lab complex(kind=8), dimension(order+1,nlab) :: omega integer :: n, nterms

ttim.besselnumba_total.bessellsqxqy(x, y, z1, z2, lab, order, d1in, d2in)

Bessellsqxqy.

implicit none integer, intent(in) :: order real(kind=8), intent(in) :: x,y,d1in,d2in complex(kind=8), intent(in) :: z1,z2 complex(kind=8), intent(in) :: lab complex(kind=8), dimension(0:2*order+1) :: qxqy

integer :: Nls, n real(kind=8) :: Lnear, L, d1, d2, delta complex(kind=8) :: z, delz, za, zb

ttim.besselnumba_total.bessellsqxqyv(x, y, z1, z2, lab, order, R, nlab)

Bessellsqxqyv.

implicit none integer, intent(in) :: order real(kind=8), intent(in) :: x,y,R complex(kind=8), intent(in) :: z1,z2 integer, intent(in) :: nlab real(kind=8) :: d1, d2 complex(kind=8), dimension(nlab), intent(in) :: lab complex(kind=8), dimension(2*nlab*(order+1)) :: qxqy complex(kind=8), dimension(0:2*order+1) :: qxqylab integer :: n, nterms, nhalf

ttim.besselnumba_total.bessellsqxqyv2(x, y, z1, z2, lab, order, R, nlab)

bessellsqxqyv2.

implicit none integer, intent(in) :: order real(kind=8), intent(in) :: x,y,R complex(kind=8), intent(in) :: z1,z2 integer, intent(in) :: nlab real(kind=8) :: d1, d2 complex(kind=8), dimension(nlab), intent(in) :: lab complex(kind=8), dimension(2*(order+1),nlab) :: qxqy complex(kind=8), dimension(0:2*order+1) :: qxqylab integer :: n, nterms, nhalf

ttim.besselnumba_total.bessellsuni(x, y, z1, z2, lab)

Bessellsuni.

# Uniform strength implicit none real(kind=8), intent(in) :: x,y complex(kind=8), intent(in) :: z1,z2 complex(kind=8), intent(in) :: lab complex(kind=8) :: omega

integer :: Nls, n real(kind=8) :: Lnear, L complex(kind=8) :: z, delz, za, zb

ttim.besselnumba_total.bessellsuniv(x, y, z1, z2, lab, nlab)

Bessellsuniv.

# Uniform strength implicit none real(kind=8), intent(in) :: x,y complex(kind=8), intent(in) :: z1,z2 integer, intent(in) :: nlab complex(kind=8), dimension(nlab), intent(in) :: lab complex(kind=8), dimension(nlab), intent(inout) :: omega integer :: n

ttim.besselnumba_total.lapld_int_ho(x, y, z1, z2, order)

lapld_int_ho.

! Near field only implicit none integer, intent(in) :: order real(kind=8), intent(in) :: x,y complex(kind=8), intent(in) :: z1,z2 complex(kind=8), dimension(0:order) :: omega, qm integer :: m, n real(kind=8) :: L complex(kind=8) :: z, zplus1, zmin1

ttim.besselnumba_total.lapld_int_ho_d1d2(x, y, z1, z2, order, d1, d2)

lapld_int_ho_d1d2.

Near field only Returns integral from d1 to d2 along real axis while strength is still Delta^order from -1 to +1

implicit none integer, intent(in) :: order real(kind=8), intent(in) :: x,y,d1,d2 complex(kind=8), intent(in) :: z1,z2 complex(kind=8), dimension(0:order) :: omega, omegac integer :: n, m real(kind=8) :: xp, yp, dc, fac complex(kind=8) :: z1p,z2p,bigz1,bigz2

ttim.besselnumba_total.lapld_int_ho_wdis(x, y, z1, z2, order)

lapld_int_ho_wdis.

# Near field only implicit none integer, intent(in) :: order real(kind=8), intent(in) :: x,y complex(kind=8), intent(in) :: z1,z2 complex(kind=8), dimension(0:order) :: wdis complex(kind=8), dimension(0:10) :: qm # Max order is 10 integer :: m, n complex(kind=8) :: z, zplus1, zmin1, term1, term2, zterm

ttim.besselnumba_total.lapld_int_ho_wdis_d1d2(x, y, z1, z2, order, d1, d2)

lapld_int_ho_wdis_d1d2.

# Near field only # Returns integral from d1 to d2 along real axis while strength is still # Delta^order from -1 to +1 implicit none integer, intent(in) :: order real(kind=8), intent(in) :: x,y,d1,d2 complex(kind=8), intent(in) :: z1,z2 complex(kind=8), dimension(0:order) :: wdis, wdisc integer :: n, m real(kind=8) :: xp, yp, dc, fac complex(kind=8) :: z1p,z2p,bigz1,bigz2

ttim.besselnumba_total.besselld_int_ho(x, y, z1, z2, lab, order, d1, d2)

besselld_int_ho.

implicit none integer, intent(in) :: order real(kind=8), intent(in) :: x,y,d1,d2 complex(kind=8), intent(in) :: z1,z2,lab complex(kind=8), dimension[0:order+1] :: omega real(kind=8) :: biglab, biga, L, ang, tol, bigy complex(kind=8) :: zeta, zetabar, log1, log2, term1, term2, d1minzeta,

d2minzeta, bigz

complex(kind=8) :: cm, biglabcomplex complex(kind=8), dimension(0:20) :: zminzbar, anew, bnew, exprange complex(kind=8), dimension(0:20,0:20) :: gamnew, gam2 complex(kind=8), dimension[0:40+1] :: alpha, beta, alpha2 complex(kind=8), dimension(0:50) :: alphanew, betanew, alphanew2 # Order fixed to 10

integer :: m, n, p

ttim.besselnumba_total.besselld_gauss_ho(x, y, z1, z2, lab, order)

besselld_gauss_ho.

implicit none integer, intent(in) :: order real(kind=8), intent(in) :: x,y complex(kind=8), intent(in) :: z1,z2 complex(kind=8), intent(in) :: lab complex(kind=8), dimension(0:order) :: omega integer :: n, p real(kind=8) :: L, x0, r complex(kind=8) :: bigz, biglab complex(kind=8), dimension(8) :: k1overr

ttim.besselnumba_total.besselld_gauss_ho_d1d2(x, y, z1, z2, lab, order, d1, d2)

besselld_gauss_ho_d1d2.

# Returns integral from d1 to d2 along real axis while strength is still # Delta^order from -1 to +1 implicit none integer, intent(in) :: order real(kind=8), intent(in) :: x,y,d1,d2 complex(kind=8), intent(in) :: z1,z2,lab complex(kind=8), dimension(0:order) :: omega, omegac integer :: n, m real(kind=8) :: xp, yp, dc, fac complex(kind=8) :: z1p,z2p,bigz1,bigz2

ttim.besselnumba_total.besselld(x, y, z1, z2, lab, order, d1in, d2in)

Besselld.

implicit none integer, intent(in) :: order real(kind=8), intent(in) :: x,y,d1in,d2in complex(kind=8), intent(in) :: z1,z2 complex(kind=8), intent(in) :: lab complex(kind=8), dimension(0:order) :: omega

integer :: Nls, n real(kind=8) :: Lnear, L, d1, d2, delta complex(kind=8) :: z, delz, za, zb

ttim.besselnumba_total.besselldv(x, y, z1, z2, lab, order, R, nlab)

Besselldv.

implicit none integer, intent(in) :: order real(kind=8), intent(in) :: x,y,R complex(kind=8), intent(in) :: z1,z2 integer, intent(in) :: nlab real(kind=8) :: d1, d2 complex(kind=8), dimension(nlab), intent(in) :: lab complex(kind=8), dimension(nlab*(order+1)) :: omega integer :: n, nterms

ttim.besselnumba_total.besselldv2(x, y, z1, z2, lab, order, R, nlab)

besselldv2.

implicit none integer, intent(in) :: order real(kind=8), intent(in) :: x,y,R complex(kind=8), intent(in) :: z1,z2 integer, intent(in) :: nlab real(kind=8) :: d1, d2 complex(kind=8), dimension(nlab), intent(in) :: lab complex(kind=8), dimension(order+1,nlab) :: omega integer :: n, nterms

ttim.besselnumba_total.besselldpart(x, y, z1, z2, lab, order, d1, d2)

Besselldpart.

implicit none integer, intent(in) :: order real(kind=8), intent(in) :: x,y,d1,d2 complex(kind=8), intent(in) :: z1,z2,lab complex(kind=8), dimension(0:order) :: omega real(kind=8) :: biglab, biga, L, ang, tol, bigy complex(kind=8) :: zeta, zetabar, log1, log2, term1, term2, d1minzeta,

d2minzeta, bigz

complex(kind=8) :: cm, biglabcomplex complex(kind=8), dimension(0:20) :: zminzbar, anew, bnew, exprange complex(kind=8), dimension(0:20,0:20) :: gamnew, gam2 complex(kind=8), dimension(0:40) :: alpha, beta, alpha2 complex(kind=8), dimension(0:50) :: alphanew, betanew, alphanew2 ! Order fixed to 10 integer :: m, n, p

ttim.besselnumba_total.besselld_int_ho_qxqy(x, y, z1, z2, lab, order, d1, d2)

besselld_int_ho_qxqy.

implicit none integer, intent(in) :: order real(kind=8), intent(in) :: x,y,d1,d2 complex(kind=8), intent(in) :: z1,z2,lab complex(kind=8), dimension(0:2*order+1) :: qxqy complex(kind=8), dimension(0:order) :: rvz, rvzbar real(kind=8) :: biglab, biga, L, ang, angz, tol, bigy complex(kind=8) :: zeta, zetabar, log1, log2, term1, term2, d1minzeta,

d2minzeta, bigz

complex(kind=8) :: cm, biglabcomplex, azero complex(kind=8), dimension(0:20) :: zminzbar, anew, bnew, exprange complex(kind=8), dimension(0:20,0:20) :: gamnew, gam2 complex(kind=8), dimension(0:40) :: alpha, beta, alpha2 complex(kind=8), dimension(0:51) :: alphanew, betanew, alphanew2 ! Order fixed to 10 complex(kind=8), dimension(0:order) :: omegalap, omegaom, wdis, qx, qy !

To store intermediate result

complex(kind=8), dimension(0:order+1) :: omega ! To store intermediate result integer :: m, n, p

ttim.besselnumba_total.besselld_gauss_ho_qxqy(x, y, z1, z2, lab, order)

besselld_gauss_ho_qxqy.

implicit none integer, intent(in) :: order real(kind=8), intent(in) :: x,y complex(kind=8), intent(in) :: z1,z2 complex(kind=8), intent(in) :: lab complex(kind=8), dimension(0:2*order+1) :: qxqy integer :: n, p real(kind=8) :: L, bigy, angz complex(kind=8) :: bigz, biglab real(kind=8), dimension(8) :: r, xmind complex(kind=8), dimension(8) :: k0,k1 complex(kind=8), dimension(0:order) :: qx,qy

ttim.besselnumba_total.besselld_gauss_ho_qxqy_d1d2(x, y, z1, z2, lab, order, d1, d2)

Returns integral from d1 to d2 along real axis.

While strength is still Delta^order from -1 to +1.

implicit none integer, intent(in) :: order real(kind=8), intent(in) :: x,y,d1,d2 complex(kind=8), intent(in) :: z1,z2,lab complex(kind=8), dimension(0:2*order+1) :: qxqy, qxqyc integer :: n, m real(kind=8) :: xp, yp, dc, fac complex(kind=8) :: z1p,z2p,bigz1,bigz2

ttim.besselnumba_total.besselldqxqy(x, y, z1, z2, lab, order, d1in, d2in)

Besselldqxqy.

implicit none integer, intent(in) :: order real(kind=8), intent(in) :: x,y,d1in,d2in complex(kind=8), intent(in) :: z1,z2 complex(kind=8), intent(in) :: lab complex(kind=8), dimension(0:2*order+1) :: qxqy

integer :: Nls, n real(kind=8) :: Lnear, L, d1, d2, delta complex(kind=8) :: z, delz, za, zb

ttim.besselnumba_total.besselldqxqyv(x, y, z1, z2, lab, order, R, nlab)

Besselldqxqyv.

implicit none integer, intent(in) :: order real(kind=8), intent(in) :: x,y,R complex(kind=8), intent(in) :: z1,z2 integer, intent(in) :: nlab real(kind=8) :: d1, d2 complex(kind=8), dimension(nlab), intent(in) :: lab complex(kind=8), dimension(2*nlab*(order+1)) :: qxqy complex(kind=8), dimension(0:2*order+1) :: qxqylab

ttim.besselnumba_total.besselldqxqyv2(x, y, z1, z2, lab, order, R, nlab)

besselldqxqyv2.

implicit none integer, intent(in) :: order real(kind=8), intent(in) :: x,y,R complex(kind=8), intent(in) :: z1,z2 integer, intent(in) :: nlab real(kind=8) :: d1, d2 complex(kind=8), dimension(nlab), intent(in) :: lab complex(kind=8), dimension(2*(order+1),nlab) :: qxqy complex(kind=8), dimension(0:2*order+1) :: qxqylab integer :: n, nterms, nhalf

ttim.besselnumba_total.bessells_circcheck(x, y, z1in, z2in, lab)

bessells_circcheck.

implicit none real(kind=8), intent(in) :: x,y complex(kind=8), intent(in) :: z1in,z2in complex(kind=8), intent(in) :: lab complex(kind=8) :: omega

integer :: Npt, Nls, n real(kind=8) :: Lnear, Lzero, L, x1, y1, x2, y2 complex(kind=8) :: z, z1, z2, delz, za, zb

ttim.besselnumba_total.is_too_far(z1, z2, zc, R)

Checks whether zc is more than R away from oval surrounding line element.

ttim.besselnumba_total.circle_line_intersection(z1, z2, zc, R)

circle_line_intersection.

implicit none complex(kind=8), intent(in) :: z1, z2, zc real(kind=8), intent(in) :: R real(kind=8), intent(inout) :: xouta, youta, xoutb, youtb integer, intent(inout) :: N real(kind=8) :: Lover2, d, xa, xb complex(kind=8) :: bigz, za, zb

ttim.besselnumba_total.find_d1d2(z1, z2, zc, R)

find_d1d2.

implicit none complex(kind=8), intent(in) :: z1, z2, zc real(kind=8), intent(in) :: R real(kind=8), intent(inout) :: d1, d2 real(kind=8) :: Lover2, d, xa, xb complex(kind=8) :: bigz

ttim.besselnumba_total.isinside(z1, z2, zc, R)

Checks whether point zc is within oval with ‘radius’ R from line element.

implicit none complex(kind=8), intent(in) :: z1, z2, zc real(kind=8), intent(in) :: R integer :: irv real(kind=8) :: Lover2, d, xa, xb complex(kind=8) :: bigz