def main3():
T = 1.0 #float(sys.argv[1]) # truncation thresholf for ISP
N = int(sys.argv[1]) # truncation parameter for FB expansion
R0 = 0.3 #float(sys.argv[3]) # width of the top-hat part
A0 = float(sys.argv[2]) # decay width of Gaussian
E0 = float(sys.argv[3])
# SEQUENCE OF SAMPLING POINTS FOR OBJECTIVE FUNCTIONS
r = np.linspace(0, 1., 1000)
# SET CUSTOM PROBE FUNCTIONS
f = lambda x: flatTop(x, (R0, A0))
g = lambda x: deltaG(x, E0)
f0 = norm(r, f(r))
g0 = norm(r, g(r))
# FORWARD TRANSFORM FLAT-TOP
rho, F0, T = dFBT.FiskJohnsonContinuousFuncFWD(r, f, T, N)
# FORWARD TRANSFORM DELTA-APPROXIMATION
rho, G0, T = dFBT.FiskJohnsonContinuousFuncFWD(r, g, T, N)
# BACKWARD TRANSFORM POINTWISE PRODUCT
hr = dFBT.FiskJohnsonDiscreteFuncBCKWD(r, 2. * np.pi * G0 * F0, T)
for ir in range(rho.size):
print "FWD ", rho[ir], F0[ir], G0[ir]
fr = f(r)
# NORMALIZATION ACCOUNTS FOR DEVIATION OF ORIGINAL NORM IF
# WIDTH FALLS FAR BELOW LENGTHSCALE INDUCED BY MESH WIDTH
for ir in range(r.size):
print "BCKWD ", r[ir], fr[ir], hr[ir] * fr[0] / hr[0]
def main():
# SIMULATION PARAMETERS -----------------------------------------------
#T = 10.
N = 5
rMin = 0.01
rMax = 10.
Nr = 1000
for T in np.linspace(1., rMax, 20.):
# SET OBJECTIVE FUNCTION -----------------------------------------------
r = np.linspace(rMin, rMax, Nr, retstep=False, endpoint=False)
f, F = FBP.sombrero()
print T, N,
# FISK JOHNSON dFBT FOR CONTINUOUS FUNCTION ---------------------------
rhoFJC, F0FJC, T = dFBT.FiskJohnsonContinuousFuncFWD(r, f, T, N)
fFJC = dFBT.FiskJohnsonDiscreteFuncBCKWD(r, F0FJC, T)
print eRMS(f(r), fFJC),
# FISK JOHNSON dFBT FOR DISCRETE FUNCTION -----------------------------
rhoFJD, F0FJD, T = dFBT.FiskJohnsonDiscreteFuncFWD(r, f(r), T, N)
fFJD = dFBT.FiskJohnsonDiscreteFuncBCKWD(r, F0FJD, T)
print eRMS(f(r), fFJD),
# CREE BONES dFBT FOR CONTINUOUS FUNCTION -----------------------------
rhoCB, F0CB = dFBT.CreeBonesDiscreteFunc(r, f(r))
rCB, fCB = dFBT.CreeBonesDiscreteFunc(rhoCB, F0CB)
print eRMS(f(r), fCB)
def main():
# SIMULATION PARAMETERS ---------------------------------------------------
T = float(sys.argv[1])
rMin = 0.01
rMax = 20.
Nr = 1000
# SET OBJECTIVE FUNCTION --------------------------------------------------
r = np.linspace(rMin, rMax, Nr, retstep=False, endpoint=False)
f, F = FBP.sombrero()
for N in range(2, 40, 1):
# CREE BONES dFBT FOR CONTINUOUS FUNCTION -----------------------------
rhoCB, F0CB = dFBT.CreeBonesDiscreteFunc(r[r < T], f(r[r < T]))
# FISK JOHNSON dFBT FOR CONTINUOUS FUNCTION ---------------------------
rhoFJC, F0FJC, T = dFBT.FiskJohnsonContinuousFuncFWD(r, f, T, N)
# FISK JOHNSON EXTRAPOLATION TO DESIRED SAMPLE POINTS -----------------
F0FJCEx = dFBT.FiskJohnsonDiscreteFuncExtrapolate(rhoCB, F0FJC, T)
print T, N, eRMS(F(rhoCB), F0CB), eRMS(F(rhoCB), F0FJCEx),
# FISK JOHNSON REVERSE dFBT FOR DISCRETE FUNCTION ---------------------
fFJB = dFBT.FiskJohnsonDiscreteFuncBCKWD(r, F0FJC, T)
print eRMS(f(r[r < T]), fFJB[r < T])
def test_dFBT_selfReciprocality(self):
"""Perform unit test checking self reciprocality"""
# FISK JOHNSON FWD TRAFO - SEE EQ. (12), REF. [1]
rhoFJC,F0FJC,T = dFBT.FiskJohnsonContinuousFuncFWD(self.r,self.f,self.T,self.N)
# FISK JOHNSON BCKWD TRAFO - SEE EQ. (10), REF. [1]
fFJC = dFBT.FiskJohnsonDiscreteFuncBCKWD(self.r,F0FJC,self.T)
print eRMS(fFJC,self.f(self.r))
self.assertLessEqual(eRMS(fFJC,self.f(self.r)), 1e-6)
def test_dFBT_fourierPair(self):
"""Perform unit test on Fourier Bessel pair"""
# FISK JOHNSON FWD TRAFO - SEE EQ. (12), REF. [1]
rhoFJC,F0FJC,T = dFBT.FiskJohnsonContinuousFuncFWD(self.r,self.f,self.T,self.N)
# EXTRAPOLATION TO DESIRED SAMPLE POINTS - SEE EQ. (9), REF. [1]
F0FJCEx = dFBT.FiskJohnsonDiscreteFuncExtrapolate(self.r,F0FJC,self.T)
print eRMS(F0FJCEx,self.Fx(self.r))
self.assertLessEqual(eRMS(F0FJCEx,self.Fx(self.r)), 1e-6)
def main2():
T = 1.0 #float(sys.argv[1]) # truncation thresholf for ISP
R0 = 0.4 #float(sys.argv[3]) # width of the top-hat part
A0 = 0.1 #float(sys.argv[4]) # decay width of Gaussian
E0 = float(sys.argv[1])
# SEQUENCE OF SAMPLING POINTS FOR OBJECTIVE FUNCTIONS
r = np.linspace(0, 1., 1000)
# SET CUSTOM PROBE FUNCTIONS
f = lambda x: flatTop(x, (R0, A0))
g = lambda x: deltaG(x, E0)
for N in range(4, 50):
# FORWARD TRANSFORM FLAT-TOP
rho, F0, T = dFBT.FiskJohnsonContinuousFuncFWD(r, f, T, N)
# FORWARD TRANSFORM DELTA-APPROXIMATION
rho, G0, T = dFBT.FiskJohnsonContinuousFuncFWD(r, g, T, N)
# BACKWARD TRANSFORM POINTWISE PRODUCT
hr = dFBT.FiskJohnsonDiscreteFuncBCKWD(r, 2. * np.pi * G0 * F0, T)
print E0, N, eRMS(f(r), hr)
def main():
# SIMULATION PARAMETERS -----------------------------------------------
T = float(sys.argv[1]) #18.
N = int(sys.argv[2]) #50
rMin = 0.01
rMax = 20.
Nr = 1000
r = np.linspace(rMin, rMax, Nr, retstep=False, endpoint=False)
# OBJECTIVE FUNCTION --------------------------------------------------
#f, F = FBP.sombrero()
f, F = FBP.Gauss()
for i in range(r.size):
print "O", r[i], float(F(r[i]))
# FISK JOHNSON FWD TRAFO FOR CONTINUOUS FUNCTION ----------------------
rhoFJC, F0FJC, T = dFBT.FiskJohnsonContinuousFuncFWD(r, f, T, N)
for i in range(rhoFJC.size):
print "FJC ", rhoFJC[i], F0FJC[i]
def Y(m, k):
j = scs.jn_zeros(0, N)
jN = j[-1]
J0 = lambda x: scs.j0(x)
J1 = lambda x: scs.j1(x)
return 2.0 * J0(j[m] * j[k] / jN) / jN / J1(j[k])**2
jm = scs.jn_zeros(0, N)
fk = F0FJC * 2. / (T * T * scs.j1(jm)**2)
Fm = np.zeros(N)
for im in range(N):
for ik in range(N):
Fm[im] += Y(im, ik) * fk[ik]
fks = fk / scs.j1(jm)
Fms = Fm / scs.j1(jm)
print fks
print Fms
print np.sum(fks[:-1]**2)
print np.sum(Fms[:-1]**2)
def main():
# SIMULATION PARAMETERS -----------------------------------------------
T = float(sys.argv[1]) #18.
N = int(sys.argv[2]) #50
rMin = 0.01
rMax = 20.
Nr = 1000
r = np.linspace(rMin,rMax,Nr,retstep=False,endpoint=False)
# OBJECTIVE FUNCTION --------------------------------------------------
f, F = FBP.sombrero()
for i in range(r.size):
print "O", r[i],float(F(r[i]))
# QUADRATURE USING TRAPEZOIDAL RULE -----------------------------------
rhoCB,F0CB = dFBT.CreeBonesDiscreteFunc(r,f(r))
for i in range(rhoCB.size):
print "CB ", rhoCB[i], F0CB[i]
# FISK JOHNSON FWD TRAFO FOR CONTINUOUS FUNCTION ----------------------
rhoFJC,F0FJC,T = dFBT.FiskJohnsonContinuousFuncFWD(r,f,T,N)
for i in range(rhoFJC.size):
print "FJC ", rhoFJC[i], F0FJC[i]
# FISK JOHNSON FWD TRAFO FOR DISCRETE FUNCTION ------------------------
rhoFJD,F0FJD,T = dFBT.FiskJohnsonDiscreteFuncFWD(r,f(r),T,N)
for i in range(rhoFJD.size):
print "FJD ", rhoFJD[i], F0FJD[i]
# FISK JOHNSON EXTRAPOLATION TO DESIRED SAMPLE POINTS -----------------
F0FJCEx = dFBT.FiskJohnsonDiscreteFuncExtrapolate(rhoCB,F0FJD,T)
for i in range(rhoCB.size):
print "FJCEx ", rhoCB[i], F0FJCEx[i]
# FISK JOHNSON REVERSE dFBT FOR DISCRETE FUNCTION ---------------------
fFJB = dFBT.FiskJohnsonDiscreteFuncBCKWD(r,F0FJC,T)
for i in range(r.size):
print "FJB ", r[i], f(r[i]), fFJB[i]
def test_dFBT_generalizedParsevalTheorem(self):
"""Perform unit test based on generalized Parseval theorem"""
j = scs.jn_zeros(0,self.N)
Fm = np.zeros(self.N)
# DFT KERNEL - SEE EQ. (19), REF. [2]
Y = lambda m,k: 2.0*scs.j0(j[m]*j[k]/j[-1])/j[-1]/scs.j1(j[k])**2
# FISK JOHNSON FWD TRAFO - SEE EQ. (12), REF. [1]
rhoFJC,F0FJC,T = dFBT.FiskJohnsonContinuousFuncFWD(self.r,self.f,self.T,self.N)
# FOURIER-BESSEL COEFFICIENTS - SEE EQ. (8), REF. [2]
fk = F0FJC*2./(self.T*self.T*scs.j1(j)**2)
# FORWARD TRANSFORM VIA DFT KERNEL Y - SEE EQ. (33), REF. [2]
for im in range(self.N):
for ik in range(self.N):
Fm[im] += Y(im,ik)*fk[ik]
# SCALED COEFFICIENTS - SEE EQ. (46), REF. [2]
fkScaled = fk /scs.j1(j)
FmScaled = Fm /scs.j1(j)
self.assertAlmostEqual(np.sum(FmScaled**2), np.sum(fkScaled**2), 6)
def main():
# SIMULATION PARAMETERS ---------------------------------------------------
#T = 10.
N = int(sys.argv[1])
rMin = 0.01
rMax = 10.
Nr = 1000
# SET OBJECTIVE FUNCTION --------------------------------------------------
r = np.linspace(rMin, rMax, Nr, retstep=False, endpoint=False)
f, F = FBP.Gauss()
for T in np.linspace(20 * rMin, rMax, 100.):
# CREE BONES dFBT FOR CONTINUOUS FUNCTION -----------------------------
rhoCB, F0CB = dFBT.CreeBonesDiscreteFunc(r[r < T], f(r[r < T]))
# FISK JOHNSON dFBT FOR CONTINUOUS FUNCTION ---------------------------
rhoFJC, F0FJC, T = dFBT.FiskJohnsonContinuousFuncFWD(r, f, T, N)
# FISK JOHNSON EXTRAPOLATION TO DESIRED SAMPLE POINTS -----------------
F0FJCEx = dFBT.FiskJohnsonDiscreteFuncExtrapolate(rhoCB, F0FJC, T)
print T, N, eRMS(F(rhoCB), F0CB), eRMS(F(rhoCB), F0FJCEx)
Comp. Phys. Commun. 43 (1987) 181-202
[2] Theory and operational rules for the discrete Hankel transform
N. Baddour, U. Chouinard
J. Opt. Soc. Am. A 32 (2015) 611
[3] Operational and convolution properties of two-dimensional
Fourier transforms in polar coordinates
Baddour, N.
J. Opt. Soc. Am. A 26 (2009) 1767-1777
"""
Wrz = np.zeros(grz.shape)
# Normalize beam profile using function from isp module
f0 = isp.beamProfNormalization(r,f(r),P)
# Hankel transform of beam profile will be used repeatedly so
# precompute it here for time-efficiency
rho,F0,T = dFBT.FiskJohnsonContinuousFuncFWD(r,f,T,N)
fRec = dFBT.FiskJohnsonDiscreteFuncBCKWD(r,F0,T)
recErr = eRMS(f(r),fRec)
for iz in range(z.size):
# print iz
# Hankel transform of response to pencil beam
rho,G0,T = dFBT.FiskJohnsonDiscreteFuncFWD(r,grz[:,iz],T,N)
hr = dFBT.FiskJohnsonDiscreteFuncBCKWD(r,2.*np.pi*G0*F0,T)
# Gibbs-phenomenon workaround: remove all negative valued
# contributions to volumetric energy density at given depth
hr = np.abs(hr)
# Normalize contribution to volumetric energy density
Wrz[:,iz] = f0*hr
return Wrz, recErr