[Tutor] nested integral

[Msd De]

NameError: name 'fixed_quad' is not defined

I am currently writing a program that involves nested integrals.
Every source that I have seen to do this either involves lambda or creating
a definition that outputs an equation.
So, my question is, is there any way to integrate it without doing that?
Here's part of my code:

LB=0.0
UB=etatip
K001_Intg=[None]*64;K0d1_Intg=[None]*64;Kd01_Intg=[None]*64;Kdd1_Intg=[None]*64
def kfac_11(eta, Ex):  #variable is eta
distGen=array_defl[i]
sumK00=0.0;sumK0d=0.0;sumKd0=0.0;sumKdd=0.0
for j in range(64): #column for eta values
xp=array_xefl[int(j),int(i)]
global ak1
global ak2
ak1 = numpy.sqrt(2*FCON*Ex)
ak2 = numpy.sqrt(2*FCON*(Ex-deltaprime))
a=2*FCON*abs(EL-Ex)
b = 2*FCON*abs(ER - EL)/distGen
#print ak1,ak2,FCON,EL,a,b
aminbd =2*FCON*abs(ER - Ex)
X10=(TWOTHRD/b)*a**ONEHALF
X1d=(TWOTHRD/b)*(aminbd)**ONEHALF
#print aminbd,X10,X1d
BIX10=iv(N,X10)
BIX1d=iv(N,X1d)
BKX10=kv(N,X10)
BKX1d=kv(N,X1d)
#print BIX10,BIX1d,BKX10,BKX1d
BIpX10=0.5*((iv(N1,X10))+(iv(N2,X10)))
BIpX1d=0.5*((iv(N1,X1d))+(iv(N2,X1d)))
BKpX10= - 0.5*((kv(N1,X10))+(kv(N2,X10)))
BKpX1d= - 0.5*((kv(N1,X1d))+(kv(N2,X1d)))
KIthrdX10X1d=BKX10*BIX1d- BKX10*BIX1d
KIthrdX1dX10=BKX1d*BIX10- BKX1d*BIX10
IKX10X1d=BIX10*BKX1d- BIX1d*BKX10
KIX10X1d=-IKX10X1d
KIX1dX10=BKX1d*BIX10- BKX10*BIX1d
detGama=ONEHALF**TWOTHRD/((X10*X1d)**THRD*IKX10X1d)
W=-ONEHALF*b**THRD/detGama
X1ofxp=(TWOTHRD/b )*(a-b*xp)**ONEHALF
BKX1ofxp=kv(N,X1ofxp)
BIX1ofxp=iv(N,X1ofxp)
KIthrdX1X10=BKX1ofxp*BIX10 - BKX10*BIX1ofxp
KIthrdX1dX1=BKX1d*BIX1ofxp - BKX1ofxp*BIX1d
F0_xp=KIthrdX1X10*(ONEHALF*X1ofxp)**TWOTHRD/detGama
Fd_xp=KIthrdX1dX1*(ONEHALF*X1ofxp)**TWOTHRD/detGama

f_xp=FCON*(phi1-phi2+evb)*(-1.0+xp/distGen+np.log((1+eta)/(1-eta))/np.log((1+etatip)/(1.0-etatip)))
#eta
etaTerm=(d/etatip)*(np.sqrt((ximat[j]**2-eta**2)/(1-eta**2)))
K001_Intg=F0_xp*Fd_xp*f_xp*etaTerm/W
K0d1_Intg=Kdd_0*F0_xp**2*f_xp*etaTerm/W
Kd01_Intg=K00_0*Fd_xp**2*f_xp*etaTerm/W
Kdd1_Intg=F0_xp*Fd_xp*f_xp*etaTerm/W

arr_KFact=[]
sumK00=0.0;sumK0d=0.0;sumKd0=0.0;sumKdd=0.0
K00_F=integrate.fixed_quad(K001_Intg, LB, UB, n=64)
K0d_F=integrate.fixed_quad(K0d1_Intg, LB, UB, n=64)
Kd0_F=integrate.fixed_quad(Kd01_Intg, LB, UB, n=64)
Kdd_F=integrate.fixed_quad(Kdd1_Intg, LB, UB, n=64)
sumK00=sumK00+K00_F
sumK0d=sumK0d+K0d_F
sumKd0=sumKd0+Kd0_F
sumKdd=sumKdd+Kdd_F

K00intg=sumK00
K0dintg=sumK0d
Kd0intg=sumKd0
Kddintg=sumKdd

K00_1=K00_0*(1+K00intg)
K0d_1=K0d_0+K0dintg
Kd0_1=Kd0_0+Kd0intg
Kdd_1=Kdd_0*(1.0+Kddintg)
# print K00_1,K0d_1,Kd0_1,Kdd_1

TP_1 =
abs(2.0*1j*ak1*Kdd_1/((1j*ak2-K0d_1)*(1j*ak1+Kd0_1)+K00_1*Kdd_1))**2.0
DEx_11=(ak2/ak1)*TP_1
return DEx_11

def DEx11(Ex):  # 64 values of array_defl
distGen=array_defl[i]
return fixed_quad(kfac_11, LB, UB, n=64, args=(Ex))

JRuss11={}
ELOW11Russ=EMIN
EHIGH11Russ=ESTG1
array_JRuss11=np.zeros(64)
for i in range(64): #64 values of dfl(xi)
JRuss11[i]=fixed_quad(lambda Ex: DEx11(Ex),ELOW11Russ, EHIGH11Russ, n=64)
# JRuss11[k]=integrate.fixed_quad(DEx11, ELOW11Russ, EHIGH11Russ, n=64)
array_JRuss11[int(i)]=(JRuss11[i][0])