def xs(Nc, Nline=10000):
nu0 = 2000.0
nu1 = 2100.0
nus = np.logspace(np.log10(nu0), np.log10(nu1), 10000, dtype=np.float64)
nu_lines = np.random.rand(Nline)*(nu1-nu0)+nu0
nsigmaD = 1.0
gammaL = np.random.rand(Nline)+0.1
cnu, indexnu, R, pmarray = initspec.init_modit(nu_lines, nus)
ngammaL = gammaL/(nu_lines/R)
ngammaL_grid = set_ditgrid(ngammaL, res=0.1)
S = jnp.array(np.random.normal(size=Nline))
ts = time.time()
a = []
for i in range(0, Nc):
tsx = time.time()
xsv = xsvector(cnu, indexnu, R, pmarray, nsigmaD,
ngammaL, S, nus, ngammaL_grid)
xsv.block_until_ready()
tex = time.time()
a.append(tex-tsx)
te = time.time()
a = np.array(a)
print(Nline, ',', np.mean(a[1:]), ',', np.std(a[1:]))
return (te-ts)/Nc
def comperr(Nnu, plotfig=False):
nus = np.logspace(np.log10(1.e7 / 2700),
np.log10(1.e7 / 2100.),
Nnu,
dtype=np.float64)
# nus=np.logspace(np.log10(3000),np.log10(6000.0),Nnu,dtype=np.float64)
mdbCO = moldb.MdbHit('/home/kawahara/exojax/data/CO/05_hit12.par', nus)
Mmol = 28.010446441149536
Tref = 296.0
Tfix = 1000.0
Pfix = 1.e-3 #
#USE TIPS partition function
Q296=np.array([107.25937215917970,224.38496958496091,112.61710362499998,\
660.22969049609367,236.14433662109374,1382.8672147421873])
Q1000=np.array([382.19096582031250,802.30952197265628,402.80326733398437,\
2357.1041210937501,847.84866308593757,4928.7215078125000])
qr = Q1000 / Q296
qt = np.ones_like(mdbCO.isoid, dtype=np.float64)
for idx, iso in enumerate(mdbCO.uniqiso):
mask = mdbCO.isoid == iso
qt[mask] = qr[idx]
Sij = SijT(Tfix, mdbCO.logsij0, mdbCO.nu_lines, mdbCO.elower, qt)
gammaL = gamma_hitran(Pfix, Tfix, Pfix, mdbCO.n_air, mdbCO.gamma_air,
mdbCO.gamma_self)
#+ gamma_natural(A) #uncomment if you inclide a natural width
sigmaD = doppler_sigma(mdbCO.nu_lines, Tfix, Mmol)
cnu, indexnu, R, dq = initspec.init_modit(mdbCO.nu_lines, nus)
nsigmaD = normalized_doppler_sigma(Tfix, Mmol, R)
ngammaL = gammaL / (mdbCO.nu_lines / R)
ngammaL_grid = set_ditgrid(ngammaL)
xs_modit_lp = modit_xsvector(cnu, indexnu, R, dq, nsigmaD, ngammaL, Sij,
nus, ngammaL_grid)
wls_modit = 100000000 / nus
#ref (direct)
d = 10000
ll = mdbCO.nu_lines
xsv_lpf_lp = lpf_xsection(nus, ll, sigmaD, gammaL, Sij, memory_size=30)
dif = xs_modit_lp / xsv_lpf_lp - 1.
med = np.median(dif)
iju = 22940.
ijd = 26400.
limu, limd = np.searchsorted(wls_modit[::-1], [iju, ijd])
std = np.std(dif[::-1][limu:limd])
return med, std, R, ijd, iju, wls_modit, xs_modit_lp, xsv_lpf_lp, dif
def xs(Nline):
nu0 = 2000.0
nu1 = 2100.0
nus = np.logspace(np.log10(nu0), np.log10(nu1), 10000, dtype=np.float64)
nu_lines = np.random.rand(Nline) * (nu1 - nu0) + nu0
nsigmaD = 1.0
gammaL = np.random.rand(Nline) + 0.1
cnu, indexnu, R, pmarray = initspec.init_modit(nu_lines, nus)
ngammaL = gammaL / (nu_lines / R)
ngammaL_grid = set_ditgrid(ngammaL, res=0.1)
S = jnp.array(np.random.normal(size=Nline))
xsv = xsvector(cnu, indexnu, R, pmarray, nsigmaD, ngammaL, S, nus,
ngammaL_grid)
xsv.block_until_ready()
return True
def test_VALD_MODIT():
#wavelength range
wls, wll = 10395, 10405
#Set a model atmospheric layers, wavenumber range for the model, an instrument
NP = 100
Parr, dParr, k = pressure_layer(NP=NP)
Pref = 1.0 #bar
ONEARR = np.ones_like(Parr)
Nx = 2000
nus, wav, res = nugrid(wls - 5.0, wll + 5.0, Nx, unit="AA", xsmode="modit")
Rinst = 100000. #instrumental spectral resolution
beta_inst = R2STD(
Rinst) #equivalent to beta=c/(2.0*np.sqrt(2.0*np.log(2.0))*R)
#atoms and ions from VALD
adbV = moldb.AdbVald(
path_ValdLineList, nus, crit=1e-100
) #The crit is defined just in case some weak lines may cause an error that results in a gamma of 0... (220219)
asdb = moldb.AdbSepVald(adbV)
#molecules from exomol
mdbH2O = moldb.MdbExomol('.database/H2O/1H2-16O/POKAZATEL',
nus,
crit=1e-50) #,crit = 1e-40)
mdbTiO = moldb.MdbExomol('.database/TiO/48Ti-16O/Toto', nus,
crit=1e-50) #,crit = 1e-50)
mdbOH = moldb.MdbExomol('.database/OH/16O-1H/MoLLIST', nus)
mdbFeH = moldb.MdbExomol('.database/FeH/56Fe-1H/MoLLIST', nus)
#CIA
cdbH2H2 = contdb.CdbCIA('.database/H2-H2_2011.cia', nus)
#molecular mass
molmassH2O = molinfo.molmass("H2O")
molmassTiO = molinfo.molmass("TiO")
molmassOH = molinfo.molmass("OH")
molmassFeH = molinfo.molmass("FeH")
molmassH = molinfo.molmass("H")
molmassH2 = molinfo.molmass("H2")
#Initialization of MODIT (for separate VALD species, and exomol molecules(e.g., FeH))
cnuS, indexnuS, R, pmarray = initspec.init_modit_vald(
asdb.nu_lines, nus, asdb.N_usp)
cnu_FeH, indexnu_FeH, R, pmarray = initspec.init_modit(
mdbFeH.nu_lines, nus)
cnu_H2O, indexnu_H2O, R, pmarray = initspec.init_modit(
mdbH2O.nu_lines, nus)
cnu_OH, indexnu_OH, R, pmarray = initspec.init_modit(mdbOH.nu_lines, nus)
cnu_TiO, indexnu_TiO, R, pmarray = initspec.init_modit(
mdbTiO.nu_lines, nus)
#sampling the max/min of temperature profiles
fT = lambda T0, alpha: T0[:, None] * (Parr[None, :] / Pref)**alpha[:, None]
T0_test = np.array([1500.0, 4000.0, 1500.0, 4000.0])
alpha_test = np.array([0.2, 0.2, 0.05, 0.05])
res = 0.2
#Assume typical atmosphere
H_He_HH_VMR_ref = [0.1, 0.15, 0.75]
PH_ref = Parr * H_He_HH_VMR_ref[0]
PHe_ref = Parr * H_He_HH_VMR_ref[1]
PHH_ref = Parr * H_He_HH_VMR_ref[2]
#Precomputing dgm_ngammaL
dgm_ngammaL_VALD = setdgm_vald_all(asdb, PH_ref, PHe_ref, PHH_ref, R, fT,
res, T0_test, alpha_test)
dgm_ngammaL_FeH = setdgm_exomol(mdbFeH, fT, Parr, R, molmassFeH, res,
T0_test, alpha_test)
dgm_ngammaL_H2O = setdgm_exomol(mdbH2O, fT, Parr, R, molmassH2O, res,
T0_test, alpha_test)
dgm_ngammaL_OH = setdgm_exomol(mdbOH, fT, Parr, R, molmassOH, res, T0_test,
alpha_test)
dgm_ngammaL_TiO = setdgm_exomol(mdbTiO, fT, Parr, R, molmassTiO, res,
T0_test, alpha_test)
T0 = 3000.
alpha = 0.07
Mp = 0.155 * 1.99e33 / 1.90e30
Rp = 0.186 * 6.96e10 / 6.99e9
u1 = 0.0
u2 = 0.0
RV = 0.00
vsini = 2.0
mmw = 2.33 * ONEARR #mean molecular weight
log_e_H = -4.2
VMR_H = 0.09
VMR_H2 = 0.77
VMR_FeH = 10**-8
VMR_H2O = 10**-4
VMR_OH = 10**-4
VMR_TiO = 10**-8
A_Fe = 1.5
A_Ti = 1.2
adjust_continuum = 0.99
ga = 2478.57730044555 * Mp / Rp**2
Tarr = T0 * (Parr / Pref)**alpha
PH = Parr * VMR_H
PHe = Parr * (1 - VMR_H - VMR_H2)
PHH = Parr * VMR_H2
VMR_e = VMR_H * 10**log_e_H
#VMR of atoms and ions (+Abundance modification)
mods_ID = jnp.array([[26, 1], [22, 1]])
mods = jnp.array([A_Fe, A_Ti])
VMR_uspecies = atomll.get_VMR_uspecies(asdb.uspecies, mods_ID, mods)
VMR_uspecies = VMR_uspecies[:, None] * ONEARR
#Compute delta tau
#Atom & ions (VALD)
SijMS, ngammaLMS, nsigmaDlS = vald_all(asdb, Tarr, PH, PHe, PHH, R)
xsmS = xsmatrix_vald(cnuS, indexnuS, R, pmarray, nsigmaDlS, ngammaLMS,
SijMS, nus, dgm_ngammaL_VALD)
dtauatom = dtauVALD(dParr, xsmS, VMR_uspecies, mmw, ga)
#FeH
SijM_FeH, ngammaLM_FeH, nsigmaDl_FeH = exomol(mdbFeH, Tarr, Parr, R,
molmassFeH)
xsm_FeH = xsmatrix(cnu_FeH, indexnu_FeH, R, pmarray, nsigmaDl_FeH,
ngammaLM_FeH, SijM_FeH, nus, dgm_ngammaL_FeH)
dtaum_FeH = dtauM_mmwl(dParr, jnp.abs(xsm_FeH), VMR_FeH * ONEARR, mmw, ga)
#H2O
SijM_H2O, ngammaLM_H2O, nsigmaDl_H2O = exomol(mdbH2O, Tarr, Parr, R,
molmassH2O)
xsm_H2O = xsmatrix(cnu_H2O, indexnu_H2O, R, pmarray, nsigmaDl_H2O,
ngammaLM_H2O, SijM_H2O, nus, dgm_ngammaL_H2O)
dtaum_H2O = dtauM_mmwl(dParr, jnp.abs(xsm_H2O), VMR_H2O * ONEARR, mmw, ga)
#OH
SijM_OH, ngammaLM_OH, nsigmaDl_OH = exomol(mdbOH, Tarr, Parr, R, molmassOH)
xsm_OH = xsmatrix(cnu_OH, indexnu_OH, R, pmarray, nsigmaDl_OH, ngammaLM_OH,
SijM_OH, nus, dgm_ngammaL_OH)
dtaum_OH = dtauM_mmwl(dParr, jnp.abs(xsm_OH), VMR_OH * ONEARR, mmw, ga)
#TiO
SijM_TiO, ngammaLM_TiO, nsigmaDl_TiO = exomol(mdbTiO, Tarr, Parr, R,
molmassTiO)
xsm_TiO = xsmatrix(cnu_TiO, indexnu_TiO, R, pmarray, nsigmaDl_TiO,
ngammaLM_TiO, SijM_TiO, nus, dgm_ngammaL_TiO)
dtaum_TiO = dtauM_mmwl(dParr, jnp.abs(xsm_TiO), VMR_TiO * ONEARR, mmw, ga)
#Hminus
dtau_Hm = dtauHminus_mmwl(nus, Tarr, Parr, dParr, VMR_e * ONEARR,
VMR_H * ONEARR, mmw, ga)
#CIA
dtauc_H2H2 = dtauCIA_mmwl(nus, Tarr, Parr, dParr, VMR_H2 * ONEARR,
VMR_H2 * ONEARR, mmw, ga, cdbH2H2.nucia,
cdbH2H2.tcia, cdbH2H2.logac)
#Summations
dtau = dtauatom + dtaum_FeH + dtaum_H2O + dtaum_OH + dtaum_TiO + dtau_Hm + dtauc_H2H2
sourcef = planck.piBarr(Tarr, nus)
F0 = rtrun(dtau, sourcef)
Frot = response.rigidrot(nus, F0, vsini, u1, u2)
wavd = jnp.linspace(wls, wll, 500)
nusd = jnp.array(1.e8 / wavd[::-1])
mu = response.ipgauss_sampling(nusd, nus, Frot, beta_inst, RV)
mu = mu / jnp.nanmax(mu) * adjust_continuum
assert (np.all(~np.isnan(mu)) * \
np.all(mu != 0) * \
np.all(abs(mu) != np.inf))
#
Mp = 33.2
mdbH2O = moldb.MdbExomol('.database/H2O/1H2-16O/POKAZATEL/', nus, crit=1.e-50)
mdbCO = moldb.MdbExomol('.database/CO/12C-16O/Li2015/', nus)
cdbH2H2 = contdb.CdbCIA('.database/H2-H2_2011.cia', nus)
print('N=', len(mdbH2O.nu_lines))
# Reference pressure for a T-P model
Pref = 1.0 # bar
ONEARR = np.ones_like(Parr)
ONEWAV = jnp.ones_like(nflux)
#
cnu_H2O, indexnu_H2O, R_H2O, pmarray_H2O = initspec.init_modit(
mdbH2O.nu_lines, nus)
cnu_CO, indexnu_CO, R_CO, pmarray_CO = initspec.init_modit(mdbCO.nu_lines, nus)
R = R_CO
# Precomputing gdm_ngammaL
def fT(T0, alpha):
return T0[:, None] * (Parr[None, :] / Pref)**alpha[:, None]
T0_test = np.array([1100.0, 1500.0, 1100.0, 1500.0])
alpha_test = np.array([0.2, 0.2, 0.05, 0.05])
res = 0.2
dgm_ngammaL_H2O = setdgm_exomol(mdbH2O, fT, Parr, R_H2O, molmassH2O, res,
T0_test, alpha_test)
dgm_ngammaL_CO = setdgm_exomol(mdbCO, fT, Parr, R_CO, molmassCO, res, T0_test,
2357.1041210937501, 847.84866308593757, 4928.7215078125000
])
qr = Q1000 / Q296
qt = np.ones_like(mdbCO.isoid, dtype=np.float64)
for idx, iso in enumerate(mdbCO.uniqiso):
mask = mdbCO.isoid == iso
qt[mask] = qr[idx]
Sij = SijT(Tfix, mdbCO.logsij0, mdbCO.nu_lines, mdbCO.elower, qt)
gammaL = gamma_hitran(Pfix, Tfix, Pfix, mdbCO.n_air, mdbCO.gamma_air,
mdbCO.gamma_self)
# + gamma_natural(A) #uncomment if you inclide a natural width
sigmaD = doppler_sigma(mdbCO.nu_lines, Tfix, Mmol)
cnu, indexnu, R, pmarray = initspec.init_modit(mdbCO.nu_lines, nus)
nsigmaD = normalized_doppler_sigma(Tfix, Mmol, R)
ngammaL = gammaL / (mdbCO.nu_lines / R)
ngammaL_grid = set_ditgrid(ngammaL)
xs_modit_lp = modit_xsvector(cnu, indexnu, R, pmarray, nsigmaD, ngammaL, Sij,
nus, ngammaL_grid)
wls_modit = 100000000 / nus
#ref (direct)
d = 10000
ll = mdbCO.nu_lines
xsv_lpf_lp = lpf_xsection(nus, ll, sigmaD, gammaL, Sij, memory_size=30)
config.update('jax_enable_x64', True)
def xsmatrix(self, Tarr, Parr):
"""cross section matrix.
Args:
Tarr: temperature layer (K)
Parr: pressure layer (bar)
Returns:
cross section (cm2)
"""
mdb = self.mdb
if self.database == 'ExoMol':
qt = vmap(mdb.qr_interp)(Tarr)
gammaLMP = jit(vmap(gamma_exomol,
(0, 0, None, None)))(Parr, Tarr, mdb.n_Texp,
mdb.alpha_ref)
gammaLMN = gamma_natural(mdb.A)
gammaLM = gammaLMP + gammaLMN[None, :]
self.molmass = mdb.molmass
SijM = jit(vmap(SijT, (0, None, None, None, 0)))(Tarr, mdb.logsij0,
mdb.nu_lines,
mdb.elower, qt)
elif self.database == 'HITRAN' or self.database == 'HITEMP':
qt = mdb.Qr_layer(Tarr)
gammaLM = jit(vmap(gamma_hitran, (0, 0, 0, None, None, None)))(Parr, Tarr, Parr, mdb.n_air, mdb.gamma_air, mdb.gamma_self)\
+ gamma_natural(mdb.A)
self.molmass = molinfo.molmass(self.molecules)
SijM = jit(vmap(SijT, (0, None, None, None, 0)))(Tarr, mdb.logsij0,
mdb.nu_lines,
mdb.elower, qt)
print('# of lines', len(mdb.nu_lines))
memory_size = 15.0
d = int(memory_size / (len(mdb.nu_lines) * 4 / 1024. / 1024.)) + 1
d2 = 100
Nlayer, Nline = np.shape(SijM)
if self.xsmode == 'auto':
xsmode = self.select_xsmode(Nline)
else:
xsmode = self.xsmode
print('xsmode=', xsmode)
if xsmode == 'lpf' or xsmode == 'LPF':
sigmaDM = jit(vmap(doppler_sigma,
(None, 0, None)))(mdb.nu_lines, Tarr,
self.molmass)
Nj = int(Nline / d2)
xsm = []
for i in tqdm.tqdm(range(0, int(len(self.nus) / d) + 1)):
s = int(i * d)
e = int((i + 1) * d)
e = min(e, len(self.nus))
xsmtmp = np.zeros((Nlayer, e - s))
for j in range(0, Nj + 1):
s2 = int(j * d2)
e2 = int((j + 1) * d2)
e2 = min(e2, Nline)
numatrix = make_numatrix0(self.nus[s:e],
mdb.nu_lines[s2:e2])
xsmtmp = xsmtmp +\
lpf.xsmatrix(
numatrix, sigmaDM[:, s2:e2], gammaLM[:, s2:e2], SijM[:, s2:e2])
if i == 0:
xsm = np.copy(xsmtmp.T)
else:
xsm = np.concatenate([xsm, xsmtmp.T])
xsm = xsm.T
elif xsmode == 'modit' or xsmode == 'MODIT':
cnu, indexnu, R_mol, pmarray = initspec.init_modit(
mdb.nu_lines, self.nus)
nsigmaDl = normalized_doppler_sigma(Tarr, self.molmass,
R_mol)[:, np.newaxis]
ngammaLM = gammaLM / (mdb.nu_lines / R_mol)
dgm_ngammaL = modit.dgmatrix(ngammaLM, 0.1)
xsm = modit.xsmatrix(cnu, indexnu, R_mol, pmarray, nsigmaDl,
ngammaLM, SijM, self.nus, dgm_ngammaL)
xsm = self.nonnegative_xsm(xsm)
elif xsmode == 'dit' or xsmode == 'DIT':
cnu, indexnu, pmarray = initspec.init_dit(mdb.nu_lines, self.nus)
sigmaDM = jit(vmap(doppler_sigma,
(None, 0, None)))(mdb.nu_lines, Tarr,
self.molmass)
dgm_sigmaD = dit.dgmatrix(sigmaDM, 0.1)
dgm_gammaL = dit.dgmatrix(gammaLM, 0.2)
xsm = dit.xsmatrix(cnu, indexnu, pmarray, sigmaDM, gammaLM, SijM,
self.nus, dgm_sigmaD, dgm_gammaL)
xsm = self.nonnegative_xsm(xsm)
else:
print('No such xsmode=', xsmode)
xsm = None
return xsm
def xsection(self, T, P):
"""cross section.
Args:
T: temperature (K)
P: pressure (bar)
Returns:
cross section (cm2)
"""
mdb = self.mdb
if self.database == 'ExoMol':
gammaL = gamma_exomol(P, T, mdb.n_Texp,
mdb.alpha_ref) + gamma_natural(mdb.A)
molmass = mdb.molmass
elif self.database == 'HITRAN' or self.database == 'HITEMP':
gammaL = gamma_hitran(P, T, P, mdb.n_air, mdb.gamma_air,
mdb.gamma_self) + gamma_natural(mdb.A)
molmass = molinfo.molmass(self.molecules)
Sij = self.linest(T)
if self.xsmode == 'auto':
xsmode = self.select_xsmode(len(mdb.nu_lines))
else:
xsmode = self.xsmode
if xsmode == 'lpf' or xsmode == 'LPF':
sigmaD = doppler_sigma(mdb.nu_lines, T, molmass)
xsv = xsection(self.nus,
mdb.nu_lines,
sigmaD,
gammaL,
Sij,
memory_size=self.memory_size)
elif xsmode == 'modit' or xsmode == 'MODIT':
checknus = check_scale_nugrid(self.nus, gridmode='ESLOG')
nus = self.autonus(checknus, 'ESLOG')
cnu, indexnu, R_mol, pmarray = initspec.init_modit(
mdb.nu_lines, nus)
nsigmaD = normalized_doppler_sigma(T, molmass, R_mol)
ngammaL = gammaL / (mdb.nu_lines / R_mol)
ngammaL_grid = modit.ditgrid(ngammaL, res=0.1)
xsv = modit.xsvector(cnu, indexnu, R_mol, pmarray, nsigmaD,
ngammaL, Sij, nus, ngammaL_grid)
if ~checknus and self.autogridconv:
xsv = jnp.interp(self.nus, nus, xsv)
elif xsmode == 'dit' or xsmode == 'DIT':
sigmaD = doppler_sigma(mdb.nu_lines, T, molmass)
checknus = check_scale_nugrid(self.nus, gridmode='ESLIN')
nus = self.autonus(checknus, 'ESLIN')
sigmaD_grid = dit.ditgrid(sigmaD, res=0.1)
gammaL_grid = dit.ditgrid(gammaL, res=0.1)
cnu, indexnu, pmarray = initspec.init_dit(mdb.nu_lines, nus)
xsv = dit.xsvector(cnu, indexnu, pmarray, sigmaD, gammaL, Sij, nus,
sigmaD_grid, gammaL_grid)
if ~checknus and self.autogridconv:
xsv = jnp.interp(self.nus, nus, xsv)
else:
print('Error:', xsmode, ' is unavailable (auto/LPF/DIT).')
xsv = None
return xsv
