def calc_qi(dmin, dmax, dgr, dcr, rhog, l, mu, fr):
norm = gp.gamma_pdf_norm(mu, l)
i1 = pisxth*rhoi*gp.gintegral_seg(mu+3, l, dmin, dth)
i2 = ava*gp.gintegral_seg(mu+bva, l, dth, dgr)
i3 = pisxth*rhog*gp.gintegral_seg(mu+3, l, dgr, dcr)
i4 = 1/(1-fr)*ava*gp.gintegral_seg(mu+bva, l, dcr)
return (i1+i2+i3+i4)*norm
def test():
fr = 0.5
rhor = 400
qitot = 1e-3
nitot = 100000
qifrac = qitot/nitot
s = p3lookup(rhor, fr, qifrac, 0, 0.01, 'p3lookup_new.npy')
i1 = gp.gintegral_seg(s.mu, s.l, s.dgr, s.dcr)
i2, err = quad(lambda x: x**s.mu*np.exp(-s.l*x), s.dgr, s.dcr)
print '---------SINGLE INTEGRATION---------'
print 'result from gamma function:', i1
print 'result from numerical int:', i2
print 'difference i2-i1:', i2-i1
cr1 = collision_rate_pyt(s.dgr, s.dcr, s.rhog, fr, s.mu, s.l)
cr2 = collision_rate(s.dgr, s.dcr, s.rhog, fr, s.mu, s.l)
print '---------COLLISION RATE---------'
print 'result from gamma function:', cr1
print 'result from numerical int:', cr2
print 'difference i2-i1:', cr2-cr1
mu2 = 2
di1 = gp.gintegral_seg(s.mu, s.l, s.dgr, s.dcr)*gp.gintegral_seg(s.mu+1, s.l, s.dgr, s.dcr)
di2, err = dblquad(lambda x,y: x**s.mu*np.exp(-s.l*x)*y**(s.mu+1)*np.exp(-s.l*y), s.dgr, s.dcr, lambda m:s.dgr, lambda m: s.dcr)
print '---------DOUBLE INTEGRAL---------'
print 'result from gamma function:', di1
print 'result from numerical int:', di2
print 'difference i2-i1:', di2-di1
return
def test2():
D = [[0,2], [2,4], [4,6], [6,8]]
f = lambda x,y: np.exp(-x)*np.exp(-y)*(y-x)
I1 = dblquad(f, 0, 8, lambda l:0, lambda l:l)[0]
I3 = 0
for i in np.arange(1,4):
for j in np.arange(0,i):
I3 += dblquad(f, D[i][0], D[i][1], lambda l:D[j][0], lambda l:D[j][1])[0]
for i in range(4):
I3 += dblquad(f, D[i][0], D[i][1], lambda l:D[i][0], lambda l:l)[0]
I2 = 0
for i in np.arange(1,4):
for j in np.arange(0,i):
tmp1 = gp.gintegral_seg(1,1,D[i][0],D[i][1])*gp.gintegral_seg(0,1,D[j][0],D[j][1])
tmp2 = gp.gintegral_seg(0,1,D[i][0],D[i][1])*gp.gintegral_seg(1,1,D[j][0],D[j][1])
I2 += tmp1-tmp2
for i in range(4):
I2 += dblquad(f, D[i][0], D[i][1], lambda l:D[i][0], lambda l:l)[0]
print I1
print I2
print I3
return
def collision_rate_pyt(dgr, dcr, rhog, fr, mu, l):
Ku = ((8*calc.g)/(np.pi*calc.cd*calc.rhoa))**0.5
Ke = calc.E_coll*calc.pifrth
Nnorm = gp.gamma_pdf_norm(mu,l)
D = [[0, calc.dth], [calc.dth, dgr], [dgr, dcr], [dcr, lg.dmax]]
gfb = np.zeros((4, 3))
gf = np.zeros((4, 3))
b = np.zeros(4)
a = np.zeros(4)
b[0] = 3.0
b[1] = calc.bva
b[2] = 3.0
b[3] = calc.bva
a[0] = calc.pisxth*calc.rhoi
a[1] = calc.ava
a[2] = calc.pisxth*rhog
a[3] = 1/(1-fr)*calc.ava
# use lower gamma function for integral
for i in range(3):
for k in range(3):
expb = mu+b[i]*0.5+k-1
exp = mu+k
gfb[i,k] = gp.gintegral_seg(expb, l, D[i][0], D[i][1])
gf[i,k] = gp.gintegral_seg(exp, l, D[i][0], D[i][1])
# use upper gamma function for integral
for k in range(3):
i = 3
expb = mu+b[i]*0.5+k-1
exp = mu+k
gfb[i,k] = gp.gintegral_seg(expb, l, D[i][0])
gf[i,k] = gp.gintegral_seg(exp, l, D[i][0])
integral = 0
for i in np.arange(1,4):
for j in np.arange(0,i):
tmp1 = np.sqrt(a[i])*(gfb[i,2]*gf[j,0] + 2*gfb[i,1]*gf[j,1] + gfb[i,0]*gf[j,2])
tmp2 = np.sqrt(a[j])*(gf[i,2]*gfb[j,0] + 2*gf[i,1]*gfb[j,1] + gf[i,0]*gfb[j,2])
integral += tmp1-tmp2
integral = Ku*Ke*integral*Nnorm**2
# for i in range(4):
# ID1D2, err = dblquad(collision_integrand, D[i][0], D[i][1], lambda x:D[i][0], lambda x:x, args=(dgr, dcr, rhog, fr, mu, l))
# integral += ID1D2
return integral
