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