ttim.besselnumba

Attributes

tiny
c
fac
nrange
a
b
fac
b
a
gam
binom
afar
fac
bot
fac
psi
psi
a1
b1
twologhalf
wg
xg
exprange
anew
bnew

Functions

besselk0near(z, Nt)	besselk0near.
besselk0cheb(z, Nt)	besselk0cheb.
besselk0(x, y, lab)	besselk0.
bessells_int(x, y, z1, z2, lab)	bessells_int.
bessells_gauss(x, y, z1, z2, lab)	bessells_gauss.
circle_line_intersection(z1, z2, zc, R)	circle_line_intersection.
bessellsv2(x, y, z1, z2, lab, order, R)	bessellsv2.
find_d1d2(z1, z2, zc, R)	find_d1d2.
bessells(x, y, z1, z2, lab, order, d1in, d2in)	Bessells.
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.
isinside(z1, z2, zc, R)	Checks whether point zc is within oval with 'radius' R from line element.
bessellsqxqyv2(x, y, z1, z2, lab, order, R)	bessellsqxqyv2.
bessellsqxqy(x, y, z1, z2, lab, order, d1in, d2in)	Bessellsqxqy.
bessells_gauss_ho_qxqy_d1d2(x, y, z1, z2, lab, order, ...)	Returns integral from d1 to d2 along real axis.
lapls_int_ho(x, y, z1, z2, order)	lapls_int_ho.
lapls_int_ho_wdis(x, y, z1, z2, order)	Note this is W andReturns Qx - iQy.
lapld_int_ho_d1d2(x, y, z1, z2, order, d1, d2)	lapld_int_ho_d1d2.
lapld_int_ho(x, y, z1, z2, order)	lapld_int_ho.
bessells_gauss_ho_qxqy(x, y, z1, z2, lab, order)	bessells_gauss_ho_qxqy.
besselk1cheb(z, Nt)	besselk1cheb.
besselk1(x, y, lab)	besselk1.
besselk1near(z, Nt)	besselk1near.
besselldv2(x, y, z1, z2, lab, order, R)	besselldv2.
besselld(x, y, z1, z2, lab, order, d1in, d2in)	Besselld.
besselld_gauss_ho_d1d2(x, y, z1, z2, lab, order, d1, d2)	besselld_gauss_ho_d1d2.
besselld_gauss_ho(x, y, z1, z2, lab, order)	besselld_gauss_ho.
besselldqxqyv2(x, y, z1, z2, lab, order, R)	besselldqxqyv2.
besselldqxqy(x, y, z1, z2, lab, order, d1in, d2in)	Besselldqxqy.
besselld_gauss_ho_qxqy_d1d2(x, y, z1, z2, lab, order, ...)	Returns integral from d1 to d2 along real axis.
besselld_gauss_ho_qxqy(x, y, z1, z2, lab, order)	besselld_gauss_ho_qxqy.
besselldpart(x, y, z1, z2, lab, order, d1, d2)	Besselldpart.
lapld_int_ho_wdis_d1d2(x, y, z1, z2, order, d1, d2)	lapld_int_ho_wdis_d1d2.
lapld_int_ho_wdis(x, y, z1, z2, order)	lapld_int_ho_wdis.
Fp(x, y, z1, z2, biga, order, d1, d2, a, b, nt)
bessells_int_ho(x, y, z1, z2, lab, order, d1, d2[, nt])	Docs.
bessells_int_ho_qxqy(x, y, z1, z2, lab, order, d1, d2)	Docs.
besselld_int_ho(x, y, z1, z2, lab, order, d1, d2)	Docs.
besselld_int_ho_qxqy(x, y, z1, z2, lab, order, d1, d2)	Docs.
potbeslsv(x, y, z1, z2, lab, order, ilap, naq[, R])	Potential of line-sink for use in timml.
disbeslsv(x, y, z1, z2, lab, order, ilap, naq[, R])	Disvec of line-sink for use in timml.
potbesldv(x, y, z1, z2, lab, order, ilap, naq[, R])	Potential of line-doublet for use in timml.
disbesldv(x, y, z1, z2, lab, order, ilap, naq[, R])	Disvec of line-doublet for use in timml.

Module Contents

ttim.besselnumba.tiny = 1e-10

ttim.besselnumba.c

ttim.besselnumba.fac = 1.0

ttim.besselnumba.nrange

ttim.besselnumba.a

ttim.besselnumba.b

ttim.besselnumba.fac

ttim.besselnumba.b

ttim.besselnumba.a

ttim.besselnumba.gam

ttim.besselnumba.binom

ttim.besselnumba.afar

ttim.besselnumba.fac = 1.0

ttim.besselnumba.bot

ttim.besselnumba.fac

ttim.besselnumba.psi

ttim.besselnumba.psi

ttim.besselnumba.a1

ttim.besselnumba.b1

ttim.besselnumba.twologhalf

ttim.besselnumba.wg

ttim.besselnumba.xg

ttim.besselnumba.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.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.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.exprange

ttim.besselnumba.anew

ttim.besselnumba.bnew

ttim.besselnumba.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.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.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.bessellsv2(x, y, z1, z2, lab, order, R)

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.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.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.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.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.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

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

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.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.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.lapls_int_ho(x, y, z1, z2, order)

lapls_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.lapls_int_ho_wdis(x, y, z1, z2, order)

Note this is W andReturns Qx - iQy.

ttim.besselnumba.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.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.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.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.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.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.besselldv2(x, y, z1, z2, lab, order, R)

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.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.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.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.besselldqxqyv2(x, y, z1, z2, lab, order, R)

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.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.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.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.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.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.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.Fp(x, y, z1, z2, biga, order, d1, d2, a, b, nt)

ttim.besselnumba.bessells_int_ho(x, y, z1, z2, lab, order, d1, d2, nt=20)

Docs.

To come here

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

Docs.

To come here

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

Docs.

To come here

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

Docs.

To come here

ttim.besselnumba.potbeslsv(x, y, z1, z2, lab, order, ilap, naq, R=8)

Potential of line-sink for use in timml.

ttim.besselnumba.disbeslsv(x, y, z1, z2, lab, order, ilap, naq, R=8)

Disvec of line-sink for use in timml.

ttim.besselnumba.potbesldv(x, y, z1, z2, lab, order, ilap, naq, R=8)

Potential of line-doublet for use in timml.

ttim.besselnumba.disbesldv(x, y, z1, z2, lab, order, ilap, naq, R=8)

Disvec of line-doublet for use in timml.