def obyo(y, tag, nusdx, nus, mdbCO, mdbH2O, cdbH2H2, cdbH2He):
#CO
SijM_CO, ngammaLM_CO, nsigmaDl_CO = exomol(mdbCO, Tarr, Parr, R_CO,
molmassCO)
xsm_CO = xsmatrix(cnu_CO, indexnu_CO, R_CO, pmarray_CO, nsigmaDl_CO,
ngammaLM_CO, SijM_CO, nus, dgm_ngammaL_CO)
dtaumCO = dtauM(dParr, jnp.abs(xsm_CO), MMR_CO * ONEARR, molmassCO, g)
#H2O
SijM_H2O, ngammaLM_H2O, nsigmaDl_H2O = exomol(mdbH2O, Tarr, Parr,
R_H2O, molmassH2O)
xsm_H2O = xsmatrix(cnu_H2O, indexnu_H2O, R_H2O, pmarray_H2O,
nsigmaDl_H2O, ngammaLM_H2O, SijM_H2O, nus,
dgm_ngammaL_H2O)
dtaumH2O = dtauM(dParr, jnp.abs(xsm_H2O), MMR_H2O * ONEARR, molmassH2O,
g)
#CIA
dtaucH2H2=dtauCIA(nus,Tarr,Parr,dParr,vmrH2,vmrH2,\
mmw,g,cdbH2H2.nucia,cdbH2H2.tcia,cdbH2H2.logac)
dtaucH2He=dtauCIA(nus,Tarr,Parr,dParr,vmrH2,vmrHe,\
mmw,g,cdbH2He.nucia,cdbH2He.tcia,cdbH2He.logac)
dtau = dtaumCO + dtaumH2O + dtaucH2H2 + dtaucH2He
sourcef = planck.piBarr(Tarr, nus)
Ftoa = Fref / Rp**2
F0 = rtrun(dtau, sourcef) / baseline / Ftoa
Frot = response.rigidrot(nus, F0, vsini, u1, u2)
mu = response.ipgauss_sampling(nusdx, nus, Frot, beta, RV)
errall = jnp.sqrt(e1**2 + sigma**2)
numpyro.sample(tag, dist.Normal(mu, errall), obs=y)
def model_c(nu1, y1, e1):
Rp = sample('Rp', dist.Uniform(0.5, 1.5))
Mp = sample('Mp', dist.Normal(33.5, 0.3))
RV = sample('RV', dist.Uniform(26.0, 30.0))
MMR_CO = sample('MMR_CO', dist.Uniform(0.0, maxMMR_CO))
MMR_H2O = sample('MMR_H2O', dist.Uniform(0.0, maxMMR_H2O))
T0 = sample('T0', dist.Uniform(1000.0, 1700.0))
alpha = sample('alpha', dist.Uniform(0.05, 0.15))
vsini = sample('vsini', dist.Uniform(10.0, 20.0))
# Kipping Limb Darkening Prior
q1 = sample('q1', dist.Uniform(0.0, 1.0))
q2 = sample('q2', dist.Uniform(0.0, 1.0))
u1, u2 = ld_kipping(q1, q2)
#GP
logtau = sample('logtau', dist.Uniform(-1.5, 0.5)) #tau=1 <=> 5A
tau = 10**(logtau)
loga = sample('loga', dist.Uniform(-4.0, -2.0))
a = 10**(loga)
#gravity
g = getjov_gravity(Rp, Mp)
#T-P model//
Tarr = T0 * (Parr / Pref)**alpha
#CO
SijM_CO, gammaLM_CO, sigmaDM_CO = exomol(mdbCO, Tarr, Parr, molmassCO)
xsm_CO = xsmatrix(numatrix_CO, sigmaDM_CO, gammaLM_CO, SijM_CO)
dtaumCO = dtauM(dParr, xsm_CO, MMR_CO * ONEARR, molmassCO, g)
#H2O
SijM_H2O, gammaLM_H2O, sigmaDM_H2O = exomol(mdbH2O, Tarr, Parr, molmassH2O)
xsm_H2O = xsmatrix(numatrix_H2O, sigmaDM_H2O, gammaLM_H2O, SijM_H2O)
dtaumH2O = dtauM(dParr, xsm_H2O, MMR_H2O * ONEARR, molmassH2O, g)
#CIA
dtaucH2H2=dtauCIA(nus,Tarr,Parr,dParr,vmrH2,vmrH2,\
mmw,g,cdbH2H2.nucia,cdbH2H2.tcia,cdbH2H2.logac)
dtaucH2He=dtauCIA(nus,Tarr,Parr,dParr,vmrH2,vmrHe,\
mmw,g,cdbH2He.nucia,cdbH2He.tcia,cdbH2He.logac)
dtau = dtaumCO + dtaumH2O + dtaucH2H2 + dtaucH2He
sourcef = planck.piBarr(Tarr, nus)
Ftoa = Fref / Rp**2
F0 = rtrun(dtau, sourcef) / baseline / Ftoa
Frot = response.rigidrot(nus, F0, vsini, u1, u2)
mu = response.ipgauss_sampling(nu1, nus, Frot, beta, RV)
cov = gpkernel_RBF(nu1, tau, a, e1)
sample("y1",
dist.MultivariateNormal(loc=mu, covariance_matrix=cov),
obs=y1)
def obyo(y, tag, nusd, nus, numatrix_CO, numatrix_H2O, mdbCO, mdbH2O,
cdbH2H2, cdbH2He):
#CO
SijM_CO=jit(vmap(SijT,(0,None,None,None,0)))\
(Tarr,mdbCO.logsij0,mdbCO.dev_nu_lines,mdbCO.elower,qt_CO)
gammaLMP_CO = jit(vmap(gamma_hitran,(0,0,0,None,None,None)))\
(Parr*0.99,Tarr,Parr*0.01,mdbCO.n_air,mdbCO.gamma_air,mdbCO.gamma_self)
gammaLMN_CO = gamma_natural(mdbCO.A)
gammaLM_CO = gammaLMP_CO + gammaLMN_CO[None, :]
sigmaDM_CO=jit(vmap(doppler_sigma,(None,0,None)))\
(mdbCO.dev_nu_lines,Tarr,molmassCO)
xsm_CO = xsmatrix(numatrix_CO, sigmaDM_CO, gammaLM_CO, SijM_CO)
dtaumCO = dtauM(dParr, xsm_CO, MMR_CO * ONEARR, molmassCO, g)
#H2O
SijM_H2O=jit(vmap(SijT,(0,None,None,None,0)))\
(Tarr,mdbH2O.logsij0,mdbH2O.dev_nu_lines,mdbH2O.elower,qt_H2O)
gammaLMP_H2O = jit(vmap(gamma_exomol,(0,0,None,None)))\
(Parr,Tarr,mdbH2O.n_Texp,mdbH2O.alpha_ref)
gammaLMN_H2O = gamma_natural(mdbH2O.A)
gammaLM_H2O = gammaLMP_H2O + gammaLMN_H2O[None, :]
sigmaDM_H2O=jit(vmap(doppler_sigma,(None,0,None)))\
(mdbH2O.dev_nu_lines,Tarr,molmassH2O)
xsm_H2O = xsmatrix(numatrix_H2O, sigmaDM_H2O, gammaLM_H2O, SijM_H2O)
dtaumH2O = dtauM(dParr, xsm_H2O, MMR_H2O * ONEARR, molmassH2O, g)
#CIA
dtaucH2H2=dtauCIA(nus,Tarr,Parr,dParr,vmrH2,vmrH2,\
mmw,g,cdbH2H2.nucia,cdbH2H2.tcia,cdbH2H2.logac)
dtaucH2He=dtauCIA(nus,Tarr,Parr,dParr,vmrH2,vmrHe,\
mmw,g,cdbH2He.nucia,cdbH2He.tcia,cdbH2He.logac)
dtau = dtaumCO + dtaumH2O + dtaucH2H2 + dtaucH2He
sourcef = planck.piBarr(Tarr, nus)
Ftoa = Fref / (Rp**2)
F0 = rtrun(dtau, sourcef) / baseline / Ftoa
Frot = response.rigidrot(nus, F0, vsini, u1, u2)
mu = response.ipgauss_sampling(nusd, nus, Frot, beta, RV)
#errall=jnp.sqrt(e1**2+sigma**2)
errall = e1
cov = modelcov(nusd, tau, a, errall)
#cov = modelcov(nusd,tau,a,e1)
#numpyro.sample(tag, dist.Normal(mu, e1), obs=y)
numpyro.sample(tag,
dist.MultivariateNormal(loc=mu, covariance_matrix=cov),
obs=y)
def floop(xi, null):
i, dtauatom = xi
# process---->
#test220208 dgm_sigmaD = dgml_sigmaD[i]
sp = uspecies[i]
cnu_p = padding_2Darray_for_each_atom(cnu[None, :], adb,
sp).reshape(cnu.shape)
indexnu_p = jnp.array(\
padding_2Darray_for_each_atom(indexnu[None,:], adb, sp).reshape(indexnu.shape)\
, dtype='int32')
sigmaDM_p = zero_to_ones(
padding_2Darray_for_each_atom(sigmaDM, adb, sp))
gammaLM_p = zero_to_ones(
padding_2Darray_for_each_atom(gammaLM, adb, sp))
SijM_p = padding_2Darray_for_each_atom(SijM, adb, sp)
#test220207 dgm_sigmaD_p = dgmatrix(sigmaDM_p)
#test220207 dgm_gammaL_p = dgmatrix(gammaLM_p)
xsm_p = xsmatrix(cnu_p, indexnu_p, pmarray, sigmaDM_p, gammaLM_p,
SijM_p, nus, dgm_sigmaD, dgm_gammaL)
xsm_p = jnp.abs(xsm_p)
MMRmetalMod = mods_uspecies_list[
i] #add_to_deal_with_individual_elemental_abundance
MMR_X_I = MMR_uspecies_list[
i] * 10**MMRmetalMod #modify this into individual elemental abundances shortly... (tako)
mass_X_I = atomicmass_uspecies_list[i]
dtau_each = dtauM(dParr, xsm_p, MMR_X_I * jnp.ones_like(dParr),
mass_X_I, g)
# Note that the same mixing ratio is assumed for all atmospheric layers here...
dtauatom = dtauatom + dtau_each
# <----process
i = i + 1
xi = [i, dtauatom]
return xi, null
def obyo(y, tag, nusd, nus, numatrix_CO, mdbCO, cdbH2H2):
# CO
SijM_CO = jit(vmap(SijT,
(0, None, None, None, 0)))(Tarr, mdbCO.logsij0,
mdbCO.dev_nu_lines,
mdbCO.elower, qt_CO)
gammaLMP_CO = jit(vmap(gamma_exomol,
(0, 0, None, None)))(Parr, Tarr, mdbCO.n_Texp,
mdbCO.alpha_ref)
gammaLMN_CO = gamma_natural(mdbCO.A)
gammaLM_CO = gammaLMP_CO + gammaLMN_CO[None, :]
sigmaDM_CO = jit(vmap(doppler_sigma,
(None, 0, None)))(mdbCO.dev_nu_lines, Tarr,
molmassCO)
xsm_CO = xsmatrix(numatrix_CO, sigmaDM_CO, gammaLM_CO, SijM_CO)
dtaumCO = dtauM(dParr, xsm_CO, MMR_CO * ONEARR, molmassCO, g)
# CIA
dtaucH2H2 = dtauCIA(nus, Tarr, Parr, dParr, vmrH2, vmrH2, mmw, g,
cdbH2H2.nucia, cdbH2H2.tcia, cdbH2H2.logac)
dtau = dtaumCO + dtaucH2H2
sourcef = planck.piBarr(Tarr, nus)
F0 = rtrun(dtau, sourcef) / norm
Frot = response.rigidrot(nus, F0, vsini, u1, u2)
mu = response.ipgauss_sampling(nusd, nus, Frot, beta, RV)
numpyro.sample(tag, dist.Normal(mu, sigmain), obs=y)
def obyo(y, tag, nusd, nus, numatrix_CO, numatrix_H2O, mdbCO, mdbH2O,
cdbH2H2, cdbH2He):
#CO
SijM_CO=jit(vmap(SijT,(0,None,None,None,0)))\
(Tarr,mdbCO.logsij0,mdbCO.dev_nu_lines,mdbCO.elower,qt_CO)
gammaLMP_CO = jit(vmap(gamma_exomol,(0,0,None,None)))\
(Parr,Tarr,mdbCO.n_Texp,mdbCO.alpha_ref)
gammaLMN_CO = gamma_natural(mdbCO.A)
gammaLM_CO = gammaLMP_CO + gammaLMN_CO[None, :]
sigmaDM_CO=jit(vmap(doppler_sigma,(None,0,None)))\
(mdbCO.dev_nu_lines,Tarr,molmassCO)
xsm_CO = xsmatrix(numatrix_CO, sigmaDM_CO, gammaLM_CO, SijM_CO)
dtaumCO = dtauM(dParr, xsm_CO, MMR_CO * ONEARR, molmassCO, g)
#H2O
SijM_H2O=jit(vmap(SijT,(0,None,None,None,0)))\
(Tarr,mdbH2O.logsij0,mdbH2O.dev_nu_lines,mdbH2O.elower,qt_H2O)
gammaLMP_H2O = jit(vmap(gamma_exomol,(0,0,None,None)))\
(Parr,Tarr,mdbH2O.n_Texp,mdbH2O.alpha_ref)
gammaLMN_H2O = gamma_natural(mdbH2O.A)
gammaLM_H2O = gammaLMP_H2O + gammaLMN_H2O[None, :]
sigmaDM_H2O=jit(vmap(doppler_sigma,(None,0,None)))\
(mdbH2O.dev_nu_lines,Tarr,molmassH2O)
xsm_H2O = xsmatrix(numatrix_H2O, sigmaDM_H2O, gammaLM_H2O, SijM_H2O)
dtaumH2O = dtauM(dParr, xsm_H2O, MMR_H2O * ONEARR, molmassH2O, g)
#CIA
dtaucH2H2=dtauCIA(nus,Tarr,Parr,dParr,vmrH2,vmrH2,\
mmw,g,cdbH2H2.nucia,cdbH2H2.tcia,cdbH2H2.logac)
dtaucH2He=dtauCIA(nus,Tarr,Parr,dParr,vmrH2,vmrHe,\
mmw,g,cdbH2He.nucia,cdbH2He.tcia,cdbH2He.logac)
dtau = dtaumCO + dtaumH2O + dtaucH2H2 + dtaucH2He
sourcef = planck.piBarr(Tarr, nus)
Ftoa = Fref / Rp**2
F0 = rtrun(dtau, sourcef) / baseline / Ftoa
Frot = response.rigidrot(nus, F0, vsini, u1, u2)
mu = response.ipgauss_sampling(nusd, nus, Frot, beta, RV)
np.savez("dtau_lpf.npz", [nus, dtaumCO, dtaumH2O])
return mu
def obyo(y, tag, nusdx, nus, mdbCO, mdbH2O, cdbH2H2, cdbH2He):
#CO
SijM_CO, ngammaLM_CO, nsigmaDl_CO = exomol(mdbCO, Tarr, Parr, R_CO,
molmassCO)
xsm_CO = xsmatrix(cnu_CO, indexnu_CO, R_CO, pmarray_CO, nsigmaDl_CO,
ngammaLM_CO, SijM_CO, nus, dgm_ngammaL_CO)
dtaumCO = dtauM(dParr, jnp.abs(xsm_CO), MMR_CO * ONEARR, molmassCO, g)
#H2O
SijM_H2O, ngammaLM_H2O, nsigmaDl_H2O = exomol(mdbH2O, Tarr, Parr,
R_H2O, molmassH2O)
xsm_H2O = xsmatrix(cnu_H2O, indexnu_H2O, R_H2O, pmarray_H2O,
nsigmaDl_H2O, ngammaLM_H2O, SijM_H2O, nus,
dgm_ngammaL_H2O)
dtaumH2O = dtauM(dParr, jnp.abs(xsm_H2O), MMR_H2O * ONEARR, molmassH2O,
g)
#CIA
dtaucH2H2=dtauCIA(nus,Tarr,Parr,dParr,vmrH2,vmrH2,\
mmw,g,cdbH2H2.nucia,cdbH2H2.tcia,cdbH2H2.logac)
dtaucH2He=dtauCIA(nus,Tarr,Parr,dParr,vmrH2,vmrHe,\
mmw,g,cdbH2He.nucia,cdbH2He.tcia,cdbH2He.logac)
dtau = dtaumCO + dtaumH2O + dtaucH2H2 + dtaucH2He
sourcef = planck.piBarr(Tarr, nus)
Ftoa = Fref / Rp**2
F0 = rtrun(dtau, sourcef) / baseline / Ftoa
Frot = response.rigidrot(nus, F0, vsini, u1, u2)
mu = response.ipgauss_sampling(nusdx, nus, Frot, beta, RV)
if FP64 == True:
np.savez("dtau_modit" + str(N) + "_64.npz",
[nus, dtaumCO, dtaumH2O])
else:
np.savez("dtau_modit" + str(N) + ".npz", [nus, dtaumCO, dtaumH2O])
return mu
def frun(Tarr, MMR_H2O, MMR_CO, Mp, Rp, u1, u2, RV, vsini):
g = 2478.57730044555 * Mp / Rp**2
SijM_H2O, ngammaLM_H2O, nsigmaDl_H2O = modit.exomol(
mdbH2O, Tarr, Parr, R, molmassH2O)
xsm_H2O = modit.xsmatrix(cnu_H2O, indexnu_H2O, R_H2O, pmarray_H2O,
nsigmaDl_H2O, ngammaLM_H2O, SijM_H2O, nus,
dgm_ngammaL_H2O)
dtaumH2O = dtauM(dParr, jnp.abs(xsm_H2O), MMR_H2O * ONEARR, molmassH2O, g)
SijM_CO, ngammaLM_CO, nsigmaDl_CO = modit.exomol(mdbCO, Tarr, Parr, R,
molmassCO)
xsm_CO = modit.xsmatrix(cnu_CO, indexnu_CO, R_CO, pmarray_CO, nsigmaDl_CO,
ngammaLM_CO, SijM_CO, nus, dgm_ngammaL_CO)
dtaumCO = dtauM(dParr, jnp.abs(xsm_CO), MMR_CO * ONEARR, molmassCO, g)
# CIA
dtaucH2H2 = dtauCIA(nus, Tarr, Parr, dParr, vmrH2, vmrH2, mmw, g,
cdbH2H2.nucia, cdbH2H2.tcia, cdbH2H2.logac)
dtau = dtaumH2O + dtaumCO + dtaucH2H2
sourcef = planck.piBarr(Tarr, nus)
F0 = rtrun(dtau, sourcef) / norm
Frot = response.rigidrot(nus, F0, vsini, u1, u2)
mu = response.ipgauss_sampling(nusd, nus, Frot, beta_inst, RV)
return mu
def frun(Tarr, MMR_CH4, Mp, Rp, u1, u2, RV, vsini):
g = 2478.57730044555 * Mp / Rp**2
SijM_CH4, ngammaLM_CH4, nsigmaDl_CH4 = modit.exomol(
mdbCH4, Tarr, Parr, R, molmassCH4)
xsm_CH4 = modit.xsmatrix(cnu, indexnu, R, pmarray, nsigmaDl_CH4,
ngammaLM_CH4, SijM_CH4, nus, dgm_ngammaL)
# abs is used to remove negative values in xsv
dtaumCH4 = dtauM(dParr, jnp.abs(xsm_CH4), MMR_CH4 * ONEARR, molmassCH4, g)
# CIA
dtaucH2H2 = dtauCIA(nus, Tarr, Parr, dParr, vmrH2, vmrH2, mmw, g,
cdbH2H2.nucia, cdbH2H2.tcia, cdbH2H2.logac)
dtau = dtaumCH4 + dtaucH2H2
sourcef = planck.piBarr(Tarr, nus)
F0 = rtrun(dtau, sourcef) / norm
Frot = response.rigidrot(nus, F0, vsini, u1, u2)
mu = response.ipgauss_sampling(nusd, nus, Frot, beta_inst, RV)
return mu
def floop(xi, null):
i, dtauatom = xi
# process---->
sp = uspecies[i]
MMRmetalMod = mods_uspecies_list[
i] #add_to_deal_with_individual_elemental_abundance
MMR_X_I = MMR_uspecies_list[
i] * 10**MMRmetalMod #modify this into individual elemental abundances shortly... (tako)
mass_X_I = atomicmass_uspecies_list[i]
dtau_each = dtauM(dParr, xsm, MMR_X_I * jnp.ones_like(dParr), mass_X_I,
g)
# Note that the same mixing ratio is assumed for all atmospheric layers here...
dtauatom = dtauatom + dtau_each
# <----process
i = i + 1
xi = [i, dtauatom]
return xi, null
def addmol(self, database, molecules, mmr, crit=0.):
"""
Args:
database: database= HITRAN, HITEMP, ExoMol
molecules: molecule name
mmr: mass mixing ratio (float or ndarray for the layer)
crit: line strength criterion, ignore lines whose line strength are below crit
"""
mmr = mmr * np.ones_like(self.Tarr)
axs = AutoXS(self.nus,
database,
molecules,
crit=crit,
xsmode=self.xsmode,
autogridconv=self.autogridconv)
xsm = axs.xsmatrix(self.Tarr, self.Parr)
dtauMx = dtauM(self.dParr, xsm, mmr, axs.molmass, self.gravity)
self.dtau = self.dtau + dtauMx
def floop(xi, null):
i, dtauatom = xi
# process---->
sp = uspecies[i]
numatrix_p = padding_2Darray_for_each_atom(numatrix.T, adb, sp).T
sigmaDM_p = zero_to_ones(
padding_2Darray_for_each_atom(sigmaDM, adb, sp))
gammaLM_p = padding_2Darray_for_each_atom(gammaLM, adb, sp)
SijM_p = padding_2Darray_for_each_atom(SijM, adb, sp)
xsm_p = xsmatrix(numatrix_p, sigmaDM_p, gammaLM_p, SijM_p)
MMRmetalMod = mods_uspecies_list[i]
MMR_X_I = jnp.array(
MMR_uspecies_list[i] * 10**MMRmetalMod
) # Note that this cannot modify individual elemental abundances yet (Use dtauM_vald_mmwl and VMR)
mass_X_I = jnp.array(atomicmass_uspecies_list[i])
dtau_each = dtauM(dParr, xsm_p, MMR_X_I * jnp.ones_like(dParr),
mass_X_I, g)
dtauatom = dtauatom + dtau_each
# <----process
i = i + 1
xi = [i, dtauatom]
return xi, null
def mask_weakline(mdb_mol,
Parr,
dParr,
Tarr,
SijM,
gammaLM,
sigmaDM,
MMR_mol,
molmass_mol,
mmw,
g,
vmrH2,
cdbH2H2,
margin=2,
mask=None,
Nlim=1000):
"""masking weak lines compared to CIA H2-H2 continuum.
Args:
mdb_mol: mdb
Parr: pressure layer (bar)
dParr: delta pressure layer (bar)
Tarr: temperature layer (K)
SijM: Sij matrix
gammaLM: gamma coefficient matrix
sigmaDM: Doppler broadening matrix
MMR_mol: Mass Mixing Ratio of the molecule
molmass_mol: molecualr mass of the molecule
mmw: mean molecular weight of the atmosphere
gravity: gravity (cm/s2)
vmrH2: volume mixing ratio of H2
cdbH2H2: cdb
Returns:
mask (weak line mask), maxcf (P at max contribution function for the molecule), maxcia (P at max contribution function for CIA)
"""
xsm0 = xsmatrix0(sigmaDM, gammaLM, SijM) # cross section at line centers
dtaumol = dtauM(dParr, xsm0, MMR_mol, molmass_mol, g)
ndtaumol = np.asarray(dtaumol)
dtaucH2H2 = dtauCIA(mdb_mol.nu_lines, Tarr, Parr, dParr, vmrH2, vmrH2, mmw,
g, cdbH2H2.nucia, cdbH2H2.tcia, cdbH2H2.logac)
ndtaucH2H2 = np.asarray(dtaucH2H2)
Nl = len(mdb_mol.nu_lines)
if Nl < Nlim:
cf_mol = contfunc(dtaumol, mdb_mol.nu_lines, Parr, dParr, Tarr)
maxcf = np.argmax(cf_mol, axis=0)
else:
M = int(float(Nl) / float(Nlim)) + 1
maxcf = np.array([], dtype=np.int)
for n in range(0, M):
i = n * Nlim
j = min((n + 1) * Nlim, Nl)
cf_mol = contfunc(ndtaumol[:, i:j], mdb_mol.nu_lines[i:j], Parr,
dParr, Tarr)
maxcf_tmp = np.argmax(cf_mol, axis=0)
maxcf = np.concatenate([maxcf, maxcf_tmp])
if Nl < Nlim:
cfCIA = contfunc(dtaucH2H2, mdb_mol.nu_lines, Parr, dParr, Tarr)
maxcia = np.argmax(cfCIA, axis=0)
else:
M = int(float(Nl) / float(Nlim)) + 1
maxcia = np.array([], dtype=np.int)
for n in range(0, M):
i = n * Nlim
j = min((n + 1) * Nlim, Nl)
cfCIA = contfunc(ndtaucH2H2[:, i:j], mdb_mol.nu_lines[i:j], Parr,
dParr, Tarr)
maxcia_tmp = np.argmax(cfCIA, axis=0)
maxcia = np.concatenate([maxcia, maxcia_tmp])
mask1 = (maxcf > 0) * (maxcf < maxcia + margin)
if mask is None:
mask = mask1
else:
mask = mask1 + mask
return mask, maxcf, maxcia
cnu, indexnu, R, pmarray = initspec.init_modit(mdbCH4.nu_lines, nus)
xsmmodit = modit.xsmatrix(cnu, indexnu, R, pmarray, nsigmaDl, ngammaLM, SijM,
nus, dgm_ngammaL)
# g=2478.57730044555*Mp/Rp**2
g = 1.e5 # gravity cm/s2
# MMR=0.0059 #mass mixing ratio
# 0-padding for negative values
xsmnp = np.array(xsmmodit)
print(len(xsmnp[xsmnp < 0.0]))
xsmnp[xsmnp < 0.0] = 0.0
xsmditc = jnp.array(xsmnp)
# -------------------------------
dtaum = dtauM(dParr, xsmditc, MMR * np.ones_like(Tarr), molmassCH4, g)
mmw = 2.33 # mean molecular weight
mmrH2 = 0.74
molmassH2 = molinfo.molmass('H2')
vmrH2 = (mmrH2 * mmw / molmassH2) # VMR
dtaucH2H2 = dtauCIA(nus, Tarr, Parr, dParr, vmrH2, vmrH2, mmw, g,
cdbH2H2.nucia, cdbH2H2.tcia, cdbH2H2.logac)
dtau = dtaum + dtaucH2H2
plotcf(nus, dtau, Tarr, Parr, dParr)
plt.show()
# radiative transfering...
