def test_nb1_rho(self):
N = 500
m = 1.5
rho = np.linspace(0.1, 20, N)
m = 1.5
x15 = rho / 2 / (m - 1)
qext, scal5, qback, g = miepython.mie(m, x15)
m = 1.1
x11 = rho / 2 / (m - 1)
qext, scal1, qback, g = miepython.mie(m, x11)
self.assertAlmostEqual(scal1[0], 0.0006616369953521216, delta=1e-6)
self.assertAlmostEqual(scal1[99], 3.449616595439377, delta=1e-6)
self.assertAlmostEqual(scal1[199], 1.6837703285684387, delta=1e-6)
self.assertAlmostEqual(scal1[299], 2.3167184401740495, delta=1e-6)
self.assertAlmostEqual(scal1[399], 2.218210809017406, delta=1e-6)
self.assertAlmostEqual(scal1[499], 1.876467571615533, delta=1e-6)
self.assertAlmostEqual(scal5[0], 2.3084093592198083e-05, delta=1e-6)
self.assertAlmostEqual(scal5[99], 4.07295075914037, delta=1e-6)
self.assertAlmostEqual(scal5[199], 1.8857586341949146, delta=1e-6)
self.assertAlmostEqual(scal5[299], 2.464763930426085, delta=1e-6)
self.assertAlmostEqual(scal5[399], 2.430569030744473, delta=1e-6)
self.assertAlmostEqual(scal5[499], 2.03583698038088, delta=1e-6)
def test_05_old_wiscombe_non_absorbing(self):
# OLD MIEV0 Test Case 1
m = complex(1.5, 0.0)
x = 10
s1 = 4.322E+00 + 4.868E+00 * 1j
G = abs(2 * s1 / x)**2
qext, qsca, qback, g = miepython.mie(m, x)
self.assertAlmostEqual(qsca, 2.8820, delta=1e-4)
self.assertAlmostEqual(qback, G, delta=1e-4)
# OLD MIEV0 Test Case 2
m = complex(1.5, 0.0)
x = 100
s1 = 4.077E+01 + 5.175E+01 * 1j
G = abs(2 * s1 / x)**2
qext, qsca, qback, g = miepython.mie(m, x)
self.assertAlmostEqual(qsca, 2.0944, delta=1e-4)
self.assertAlmostEqual(qback, G, delta=1e-4)
# OLD MIEV0 Test Case 3
m = complex(1.5, 0.0)
x = 1000
G = 4 * 2.576E+06 / x**2
qext, qsca, qback, g = miepython.mie(m, x)
self.assertAlmostEqual(qsca, 2.0139, delta=1e-4)
self.assertAlmostEqual(qback, G, delta=1e-3)
# OLD MIEV0 Test Case 4
m = complex(1.5, 0.0)
x = 5000.0
G = 4 * 2.378E+08 / x**2
qext, qsca, qback, g = miepython.mie(m, x)
self.assertAlmostEqual(qsca, 2.0086, delta=1e-4)
self.assertAlmostEqual(qback, G, delta=3e-3)
def test_07_wiscombe_absorbing(self):
#MIEV0 Test Case 12
m = 1.5-1j
x = 0.055
qext, qsca, qback, g = miepython.mie(m,x)
self.assertAlmostEqual(qsca, 0.000011, delta=1e-6)
self.assertAlmostEqual(g, 0.000491, delta=1e-6)
#MIEV0 Test Case 13
m = 1.5-1j
x = 0.056
qext, qsca, qback, g = miepython.mie(m,x)
self.assertAlmostEqual(qsca, 0.000012, delta=1e-6)
self.assertAlmostEqual(g, 0.000509, delta=1e-6)
#MIEV0 Test Case 14
m = 1.5-1j
x = 1
qext, qsca, qback, g = miepython.mie(m,x)
self.assertAlmostEqual(qsca, 0.6634538, delta=1e-6)
self.assertAlmostEqual(g, 0.192136, delta=1e-6)
#MIEV0 Test Case 15
m = 1.5-1j
x = 100
x=100.0
qext, qsca, qback, g = miepython.mie(m,x)
self.assertAlmostEqual(qsca, 1.283697, delta=1e-3)
self.assertAlmostEqual(qext, 2.097502, delta=1e-2)
self.assertAlmostEqual(g, 0.850252, delta=1e-3)
def test_11_wiscombe_perfectly_reflecting(self):
# MIEV0 Test Case 0
m = 0
x = 0.001
qext, qsca, qback, g = miepython.mie(m, x)
self.assertAlmostEqual(qsca, 3.3333E-12, delta=1e-13)
# MIEV0 Test Case 1
m = 0
x = 0.099
qext, qsca, qback, g = miepython.mie(m, x)
self.assertAlmostEqual(qsca, 0.000321, delta=1e-4)
self.assertAlmostEqual(g, -0.397357, delta=1e-3)
# MIEV0 Test Case 2
m = 0
x = 0.101
qext, qsca, qback, g = miepython.mie(m, x)
self.assertAlmostEqual(qsca, 0.000348, delta=1e-6)
self.assertAlmostEqual(g, -0.397262, delta=1e-6)
# MIEV0 Test Case 3
m = 0
x = 100
qext, qsca, qback, g = miepython.mie(m, x)
self.assertAlmostEqual(qsca, 2.008102, delta=1e-6)
self.assertAlmostEqual(g, 0.500926, delta=1e-6)
# MIEV0 Test Case 4
m = 0
x = 10000
qext, qsca, qback, g = miepython.mie(m, x)
self.assertAlmostEqual(qsca, 2.000289, delta=1e-6)
self.assertAlmostEqual(g, 0.500070, delta=1e-6)
def test_05_wiscombe_non_absorbing(self):
# MIEV0 Test Case 7
m=complex(0.75, 0.0)
x=10.0
qext, qsca, qback, g = miepython.mie(m,x)
self.assertAlmostEqual(qsca, 2.232265, delta=1e-6)
self.assertAlmostEqual(g, 0.896473, delta=1e-6)
# MIEV0 Test Case 8
m=complex(0.75, 0.0)
x=1000.0
qext, qsca, qback, g = miepython.mie(m,x)
self.assertAlmostEqual(qsca, 1.997908, delta=1e-6)
self.assertAlmostEqual(g, 0.844944, delta=1e-6)
def test_08_wiscombe_more_absorbing(self):
#MIEV0 Test Case 17
m = 10.0 - 10.0j
x = 1.0
qext, qsca, qback, g = miepython.mie(m,x)
self.assertAlmostEqual(qsca, 2.049405, delta=1e-6)
self.assertAlmostEqual(g, -0.110664, delta=1e-6)
#MIEV0 Test Case 18
m = 10.0 - 10.0j
x = 100.0
qext, qsca, qback, g = miepython.mie(m,x)
self.assertAlmostEqual(qsca, 1.836785, delta=1e-6)
self.assertAlmostEqual(g, 0.556215, delta=1e-6)
def mie(wavl, r, n=1, k=None):
"""
Wrapper to calcuilate mie scattering parameters using miepython.
Parameters
----------
wavl
Wavelength values, same units as r.
r
Particle radius values, same units as wavl.
n
Real refractive index values. If k is None, n can be the complex
refractive index in form n - ik.
k
Imaginary refractive index values.
Returns
-------
Q_ext, Q_sca, Q_back, g
"""
if k is None:
m = np.array(n)
else:
m = np.array(n) - 1j * np.array(k)
x = 2 * np.pi * np.array(r) / np.array(wavl)
Q_ext, Q_sca, Q_back, g = miepython.mie(m, x)
return Q_ext, Q_sca, Q_back, g
def get_mie_efficiencies(ri, r_data, wavelength):
"""
:param ri:
:param r_data: units should be the same as wavelength
:param wavelength: units should be the same as radius
:return:
"""
# mp.mie can take x vector as input
# these are the ext and sca efficiencies, compare to cross sections (qext * A)
qext = np.empty((len(wavelength), len(r_data)))
qsca = np.empty((len(wavelength), len(r_data)))
for wl_index in range(len(wavelength)):
for r_index in range(len(r_data)):
m = ri[wl_index]
# miepython sign convention: imaginary part has to be negative; complex RI = real -j * imaginary
m = m.real - 1j * m.imag
x = 2 * np.pi * r_data[r_index] / wavelength[wl_index]
# efficiencies are without units, area will be in um^2
qext[wl_index, r_index], qsca[wl_index,
r_index], qback, g = mp.mie(m, x)
mie_vo = {}
mie_vo['qext'] = qext
mie_vo['qsca'] = qsca
mie_vo['wavelength'] = wavelength
mie_vo['r_data'] = r_data
return mie_vo
def test_09_single_nonmagnetic(self):
m = 1.5 - 0.5j
x = 2.5
qext, qsca, qback, g = miepython.mie(m, x)
self.assertAlmostEqual(qext, 2.562873497454734, delta=1e-7)
self.assertAlmostEqual(qsca, 1.097071819088392, delta=1e-7)
self.assertAlmostEqual(qback, 0.123586468179818, delta=1e-7)
self.assertAlmostEqual(g, 0.748905978948507, delta=1e-7)
def test_03_bh_dielectric(self):
m = 1.55
lambda0 = 0.6328
radius = 0.525
x = 2 * np.pi * radius / lambda0
qext, qsca, qback, g = miepython.mie(m, x)
self.assertAlmostEqual(qext, 3.10543, delta=0.00001)
self.assertAlmostEqual(qsca, 3.10543, delta=0.00001)
self.assertAlmostEqual(qback, 2.92534, delta=0.00001)
self.assertAlmostEqual(g, 0.63314, delta=0.00001)
def test_04_non_dielectric(self):
m = 1.55 - 0.1j
lambda0 = 0.6328
radius = 0.525
x = 2 * np.pi * radius / lambda0
qext, qsca, qback, g = miepython.mie(m, x)
self.assertAlmostEqual(qext, 2.86165188243, delta=1e-7)
self.assertAlmostEqual(qsca, 1.66424911991, delta=1e-7)
self.assertAlmostEqual(qback, 0.20599534080, delta=1e-7)
self.assertAlmostEqual(g, 0.80128972639, delta=1e-7)
def test_05_wiscombe_non_absorbing(self):
# MIEV0 Test Case 5
m = complex(0.75, 0.0)
x = 0.099
s1 = 1.81756e-8 - 1.64810e-4 * 1j
G = abs(2 * s1 / x)**2
qext, qsca, qback, g = miepython.mie(m, x)
self.assertAlmostEqual(qsca, 0.000007, delta=1e-6)
self.assertAlmostEqual(g, 0.001448, delta=1e-6)
self.assertAlmostEqual(qback, G, delta=1e-6)
# MIEV0 Test Case 6
m = complex(0.75, 0.0)
x = 0.101
s1 = 2.04875E-08 - 1.74965E-04 * 1j
G = abs(2 * s1 / x)**2
qext, qsca, qback, g = miepython.mie(m, x)
self.assertAlmostEqual(qsca, 0.000008, delta=1e-6)
self.assertAlmostEqual(g, 0.001507, delta=1e-6)
self.assertAlmostEqual(qback, G, delta=1e-6)
# MIEV0 Test Case 7
m = complex(0.75, 0.0)
x = 10.0
s1 = -1.07857E+00 - 3.60881E-02 * 1j
G = abs(2 * s1 / x)**2
qext, qsca, qback, g = miepython.mie(m, x)
self.assertAlmostEqual(qsca, 2.232265, delta=1e-6)
self.assertAlmostEqual(g, 0.896473, delta=1e-6)
self.assertAlmostEqual(qback, G, delta=1e-6)
# MIEV0 Test Case 8
m = complex(0.75, 0.0)
x = 1000.0
s1 = 1.70578E+01 + 4.84251E+02 * 1j
G = abs(2 * s1 / x)**2
qext, qsca, qback, g = miepython.mie(m, x)
self.assertAlmostEqual(qsca, 1.997908, delta=1e-6)
self.assertAlmostEqual(g, 0.844944, delta=1e-6)
self.assertAlmostEqual(qback, G, delta=1e-6)
def test_nb1_x(self):
N = 500
m = 1.5
x = np.linspace(0.1, 20, N) # also in microns
qext, qsca, qback, g = miepython.mie(m, x)
self.assertAlmostEqual(qsca[0], 2.3084093592198083e-05, delta=1e-6)
self.assertAlmostEqual(qsca[100], 4.105960809066763, delta=1e-6)
self.assertAlmostEqual(qsca[200], 1.9947867190110644, delta=1e-6)
self.assertAlmostEqual(qsca[300], 2.4652591512196405, delta=1e-6)
self.assertAlmostEqual(qsca[400], 2.472171798724846, delta=1e-6)
self.assertAlmostEqual(qsca[499], 2.03583698038088, delta=1e-6)
def test_06_wiscombe_water_absorbing(self):
#MIEV0 Test Case 9
m = complex(1.33, -0.00001)
x = 1.0
qext, qsca, qback, g = miepython.mie(m, x)
self.assertAlmostEqual(qsca, 0.093923, delta=1e-6)
self.assertAlmostEqual(g, 0.184517, delta=1e-6)
#MIEV0 Test Case 10
m = complex(1.33, -0.00001)
x = 100.0
qext, qsca, qback, g = miepython.mie(m, x)
self.assertAlmostEqual(qsca, 2.096594, delta=1e-6)
self.assertAlmostEqual(g, 0.868959, delta=1e-6)
#MIEV0 Test Case 11
m = complex(1.33, -0.00001)
x = 10000.0
qext, qsca, qback, g = miepython.mie(m, x)
self.assertAlmostEqual(g, 0.907840, delta=1e-6)
self.assertAlmostEqual(qsca, 1.723857, delta=1e-6)
def Q_ext(mj, r_min, r_max, r_step):
'''
m: 负折射率,虚数
r ：直径,微米[um]
* m,r可以为数组,但长度必须相同
numbda ：波长,微米[um]
'''
r = np.arange(r_min, r_max, r_step)
num_r = r.shape[0] # 获取x的长度
m = np.empty(num_r, dtype=complex) # 创建空数组
m.fill(mj) # 为空数组填充复折射率
Q_ext, Q_sca, Q_back, g = miepython.mie(m, r)
print(Q_ext)
def test_10_small_spheres(self):
# MIEV0 Test Case 5
m = 0.75
x = 0.099
qext, qsca, qback, g = miepython.mie(m, x)
self.assertAlmostEqual(qext, 0.000007, delta=1e-6)
self.assertAlmostEqual(g, 0.001448, delta=1e-6)
# MIEV0 Test Case 6
m = 0.75
x = 0.101
qext, qsca, qback, g = miepython.mie(m, x)
self.assertAlmostEqual(qext, 0.000008, delta=1e-6)
self.assertAlmostEqual(g, 0.001507, delta=1e-6)
m = 1.5 - 1j
x = 0.055
qext, qsca, qback, g = miepython.mie(m, x)
self.assertAlmostEqual(qext, 0.101491, delta=1e-6)
self.assertAlmostEqual(g, 0.000491, delta=1e-6)
x = 0.056
qext, qsca, qback, g = miepython.mie(m, x)
self.assertAlmostEqual(qext, 0.103347, delta=1e-6)
self.assertAlmostEqual(g, 0.000509, delta=1e-6)
m = 1e-10 - 1e10j
x = 0.099
qext, qsca, qback, g = miepython.mie(m, x)
self.assertAlmostEqual(qext, 0.000321, delta=1e-6)
self.assertAlmostEqual(g, -0.397357, delta=1e-4)
x = 0.101
qext, qsca, qback, g = miepython.mie(m, x)
self.assertAlmostEqual(qext, 0.000348, delta=1e-6)
self.assertAlmostEqual(g, -0.397262, delta=1e-6)
m = 0 - 1e10j
x = 0.099
qext, qsca, qback, g = miepython.mie(m, x)
self.assertAlmostEqual(qext, 0.000321, delta=1e-6)
self.assertAlmostEqual(g, -0.397357, delta=1e-4)
x = 0.101
qext, qsca, qback, g = miepython.mie(m, x)
self.assertAlmostEqual(qext, 0.000348, delta=1e-6)
self.assertAlmostEqual(g, -0.397262, delta=1e-4)
def test_nb1_spheres(self):
N = 500
m = 1.0
r = 500 # nm
lambda0 = np.linspace(300, 800, N) # also in nm
mwater = 4 / 3 # rough approximation
mm = m / mwater
xx = 2 * np.pi * r * mwater / lambda0
qext, qsca, qback, g = miepython.mie(mm, xx)
self.assertAlmostEqual(qsca[0], 1.5525047718022498, delta=1e-6)
self.assertAlmostEqual(qsca[99], 2.1459528526672678, delta=1e-6)
self.assertAlmostEqual(qsca[199], 2.365171370327149, delta=1e-6)
self.assertAlmostEqual(qsca[299], 2.2039860928542128, delta=1e-6)
self.assertAlmostEqual(qsca[399], 1.9261758931397088, delta=1e-6)
self.assertAlmostEqual(qsca[499], 1.640006561518987, delta=1e-6)
def test_12_scatter_function(self):
x = 1.0
m = 1.5 - 1.0j
theta = np.arange(0, 181, 30)
mu = np.cos(theta * np.pi / 180)
qext, qsca, qback, g = miepython.mie(m, x)
S1, S2 = miepython.mie_S1_S2(m, x, mu)
S1 *= np.sqrt(np.pi * x**2 * qext)
S2 *= np.sqrt(np.pi * x**2 * qext)
self.assertAlmostEqual(S1[0].real, 0.584080, delta=1e-6)
self.assertAlmostEqual(S1[0].imag, 0.190515, delta=1e-6)
self.assertAlmostEqual(S2[0].real, 0.584080, delta=1e-6)
self.assertAlmostEqual(S2[0].imag, 0.190515, delta=1e-6)
self.assertAlmostEqual(S1[1].real, 0.565702, delta=1e-6)
self.assertAlmostEqual(S1[1].imag, 0.187200, delta=1e-6)
self.assertAlmostEqual(S2[1].real, 0.500161, delta=1e-6)
self.assertAlmostEqual(S2[1].imag, 0.145611, delta=1e-6)
self.assertAlmostEqual(S1[2].real, 0.517525, delta=1e-6)
self.assertAlmostEqual(S1[2].imag, 0.178443, delta=1e-6)
self.assertAlmostEqual(S2[2].real, 0.287964, delta=1e-6)
self.assertAlmostEqual(S2[2].imag, 0.041054, delta=1e-6)
self.assertAlmostEqual(S1[3].real, 0.456340, delta=1e-6)
self.assertAlmostEqual(S1[3].imag, 0.167167, delta=1e-6)
self.assertAlmostEqual(S2[3].real, 0.0362285, delta=1e-6)
self.assertAlmostEqual(S2[3].imag, -0.0618265, delta=1e-6)
self.assertAlmostEqual(S1[4].real, 0.400212, delta=1e-6)
self.assertAlmostEqual(S1[4].imag, 0.156643, delta=1e-6)
self.assertAlmostEqual(S2[4].real, -0.174875, delta=1e-6)
self.assertAlmostEqual(S2[4].imag, -0.122959, delta=1e-6)
self.assertAlmostEqual(S1[5].real, 0.362157, delta=1e-6)
self.assertAlmostEqual(S1[5].imag, 0.149391, delta=1e-6)
self.assertAlmostEqual(S2[5].real, -0.305682, delta=1e-6)
self.assertAlmostEqual(S2[5].imag, -0.143846, delta=1e-6)
self.assertAlmostEqual(S1[6].real, 0.348844, delta=1e-6)
self.assertAlmostEqual(S1[6].imag, 0.146829, delta=1e-6)
self.assertAlmostEqual(S2[6].real, -0.348844, delta=1e-6)
self.assertAlmostEqual(S2[6].imag, -0.146829, delta=1e-6)
def CalcCrossSection(d, material = "gold", at_lambda_nm = None, do_print = True):
'''
d - particle diameter in m
https://miepython.readthedocs.io/en/latest/02_efficiencies.html?highlight=scattering%20cross%20section
https://opensky.ucar.edu/islandora/object/technotes%3A232/datastream/PDF/view
'''
import miepython as mp
import numpy as np
import matplotlib.pyplot as plt
# import the parameters from online library
if material == 'gold':
data = np.genfromtxt('https://refractiveindex.info/tmp/data/main/Au/Johnson.txt', delimiter='\t')
if material == "silver":
data = np.genfromtxt('https://refractiveindex.info/tmp/data/main/Ag/Johnson.txt', delimiter='\t')
if material == "polystyrene":
data = np.genfromtxt('https://refractiveindex.info/tmp/data/organic/C8H8%20-%20styrene/Sultanova.txt', delimiter='\t')
if material == "DNA":
data = np.genfromtxt('https://refractiveindex.info/tmp/data/other/human%20body/DNA/Inagaki.txt', delimiter='\t')
n_media = 1.333
# data is stacked so need to rearrange
N = len(data)//2
lambda_um = data[1:N,0]
# lambda_um = lambda_um / n_media
m_real = data[1:N,1]
# some of the data do not have any complex part. than the reading in fails
num_nan = len(data[np.isnan(data)])
if num_nan == 4:
m_imag = data[N+1:,1]
else:
m_imag = np.zeros_like(m_real)
#lambda_um = lambda_um[30:35]
# m_real = m_real[30:35]
# m_imag = m_imag[30:35]
# print("lambda_um: ", lambda_um)
# print("m_real: ", m_real)
# print("m_imag: ", m_imag)
r_um = d*1e6/2 #radius in microns
r_nm = r_um * 1000
# print("particle radius in nm: ", r_nm)
x = n_media*2*np.pi*r_um/lambda_um;
m = (m_real - 1.0j * m_imag) / n_media
qext, qsca, qback, g = mp.mie(m,x)
qabs = (qext - qsca)
absorb = qabs * np.pi * r_nm**2
scat = qsca * np.pi * r_nm**2
extinct = qext* np.pi * r_nm**2
lambda_nm = 1000 * lambda_um
if at_lambda_nm == None:
# plt.plot(lambda_nm,qext,'g.-')
# plt.plot(lambda_nm,qext - qsca,'r.-')
plt.plot(lambda_nm,qsca,'k.-')
plt.xlabel("Wavelength (nm)")
plt.ylabel("Efficency")
plt.title("Efficency for %.1f nm Spheres" % (r_nm*2))
plt.xlim([400, 800])
plt.figure()
plt.plot(lambda_nm,scat,'r.-')
plt.xlabel("Wavelength (nm)")
plt.ylabel("Cross Section (1/$nm^2$)")
plt.title("Cross Sections for %.1f nm Spheres" % (r_nm*2))
plt.xlim(300,800)
plt.show()
C_Scat = scat
else:
C_Scat = np.interp(at_lambda_nm, lambda_nm, scat)
C_Abs = np.interp(at_lambda_nm, lambda_nm, absorb)
if do_print == True:
print("Size parameter: ", np.interp(at_lambda_nm, lambda_nm, x))
print("Scatterung efficency: ", np.interp(at_lambda_nm, lambda_nm, qsca))
print("Scattering cross-section [nm²]: ", C_Scat)
return C_Scat, C_Abs
"""
Plot the scattering efficiency as a function of wavelength for 4micron glass spheres
"""
import numpy as np
import matplotlib.pyplot as plt
import miepython
num = 100
radius = 2 # in microns
lam = np.linspace(0.2, 1.2, num) # also in microns
x = 2 * np.pi * radius / lam
# from https://refractiveindex.info/?shelf=glass&book=BK7&page=SCHOTT
m = np.sqrt(1 + 1.03961212 / (1 - 0.00600069867 / lam**2) + 0.231792344 /
(1 - 0.0200179144 / lam**2) + 1.01046945 /
(1 - 103.560653 / lam**2))
qqsca = np.zeros(num)
for i in range(num):
qext, qsca, qback, g = miepython.mie(m[i], x[i])
qqsca[i] = qsca
plt.plot(lam * 1000, qqsca)
plt.title("BK7 glass spheres 4 micron diameter")
plt.xlabel("Wavelength (nm)")
plt.ylabel("Scattering Efficiency (-)")
plt.show()
])
ref_k = np.array([
1.188, 1.203, 1.226, 1.251, 1.277, 1.304, 1.350, 1.387, 1.427, 1.460,
1.497, 1.536, 1.577, 1.631, 1.688, 1.749, 1.803, 1.847, 1.869, 1.878,
1.889, 1.893, 1.898, 1.883, 1.871, 1.866, 1.895, 1.933, 1.952, 1.958,
1.948, 1.914, 1.849, 1.833, 2.081, 2.455, 2.863, 3.272, 3.697, 4.103,
4.542, 5.083, 5.663, 6.350, 7.150, 8.145, 9.519, 11.21, 13.78
])
radius = 0.1 # in microns
m = ref_n - 1.0j * ref_k
x = 2 * np.pi * radius / ref_lam
cross_section_area = np.pi * radius**2
mu_a = 4 * np.pi * ref_k / ref_lam # nm
qext, qsca, qback, g = miepython.mie(m, x)
sca_cross_section = qsca * cross_section_area
abs_cross_section = (qext - qsca) * cross_section_area
plt.subplots(3, 1, figsize=(9, 9))
plt.subplot(311)
plt.plot(ref_lam * 1000, ref_n, 'ob')
plt.plot(ref_lam * 1000, -ref_k, 'sr')
plt.title("Gold Spheres 100nm diameter")
plt.xticks([])
plt.text(700, 1, "real refractive index", color='blue')
plt.text(1100, -6, "imaginary refractive index", color='red')
plt.subplot(312)
plt.plot(ref_lam * 1000, 1000 / mu_a, 'ob')
#!/usr/bin/env python3
"""
Plot the extinction efficiency as a function of particle size
for non-absorbing and absorbing spheres
"""
import numpy as np
import matplotlib.pyplot as plt
import miepython
x = np.linspace(0.1, 100, 300)
# mie() will automatically try to do the right thing
qext, qsca, qback, g = miepython.mie(1.5, x)
plt.plot(x, qext, color='red', label="1.5")
qext, qsca, qback, g = miepython.mie(1.5 - 0.1j, x)
plt.plot(x, qext, color='blue', label="1.5-0.1j")
plt.title("Comparison of extinction for absorbing and non-absorbing spheres")
plt.xlabel("Size Parameter (-)")
plt.ylabel("Qext")
plt.legend()
plt.show()
def calc_optical_params_MIE(basePath,
cell_radius,
cell_density,
reals,
imags,
wavelengths,
plots=True,
savefigs=True):
"""
cell radius is in microns
density is in kg/m3
reals is generated by preprocess_RI()
imags is generated by preprocess_RI()
wavelengths is generated by preprocess_RI()
name is the component of the filename that identifies the specific model run
plots is a Boolean that toggles plotting of the oprical params
"""
qqabs = np.zeros(len(wavelengths))
qqsca = np.zeros(len(wavelengths))
qqext = np.zeros(len(wavelengths))
MAC = np.zeros(len(wavelengths))
assym = np.zeros(len(wavelengths))
for i in np.arange(0, len(wavelengths), 1):
# Use K to drive mie solver
m = reals[i][0]
k = imags[i][0]
X = 2 * np.pi * cell_radius / wavelengths[i]
qext, qsca, qback, g = mie(complex(str("{}-{}j".format(m, k))), X)
abs_coeff = 4 * np.pi * (imags[i] / wavelengths[i] * 1000)
qabs = qext - qsca
qqabs[
i] = qabs * np.pi * cell_radius**2 # calculate cross section from efficiency
qqsca[
i] = qsca * np.pi * cell_radius**2 # calculate cross section from efficiency
qqext[
i] = qext * np.pi * cell_radius**2 # calculate cross section from efficiency
MAC[i] = abs_coeff / cell_density # calculate mass absorption coefficient from cross section
assym[i] = g
ss_alb = qqsca / qqext
if plots:
plt.figure(1)
plt.plot(wavelengths, qqabs, 'b', label='absorption cross section')
plt.plot(wavelengths, qqsca, 'g', label='scattering cross section')
plt.plot(wavelengths, qqext, 'r', label='extinction cross section')
plt.xlim(0.2, 2.5)
plt.ylabel(r"Cross Section ($\mu$m$^2$)")
plt.xlabel('Wavelength (nm)')
plt.legend(loc='best')
if savefigs:
plt.savefig(str(basePath + "crosssections{}.jpg".format(name)),
dpi=150)
plt.show()
else:
plt.show()
return assym, ss_alb
