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 exomol(mdb, Tarr, Parr, molmass):
"""compute molecular line information required for MODIT using Exomol mdb.
Args:
mdb: mdb instance
Tarr: Temperature array
Parr: Pressure array
molmass: molecular mass
Returns:
line intensity matrix,
gammaL matrix,
sigmaD matrix
"""
qt = vmap(mdb.qr_interp)(Tarr)
SijM = jit(vmap(SijT, (0, None, None, None, 0)))(Tarr, mdb.logsij0,
mdb.dev_nu_lines,
mdb.elower, qt)
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, :]
sigmaDM = jit(vmap(doppler_sigma, (None, 0, None)))(mdb.nu_lines, Tarr,
molmass)
return SijM, gammaLM, sigmaDM
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 ap(fobs, nusd, ws, we, Nx):
mask = (ws < wavd[::-1]) * (wavd[::-1] < we)
#additional mask to remove a strong telluric
mask = mask * ((22898.5 > wavd[::-1]) + (wavd[::-1] > 22899.5))
fobsx = fobs[mask]
nusdx = nusd[mask]
wavdx = 1.e8 / nusdx[::-1]
errx = err[mask]
nus, wav, res = nugrid(ws - 5.0, we + 5.0, Nx, unit="AA")
#loading molecular database
mdbCO = moldb.MdbExomol('.database/CO/12C-16O/Li2015', nus)
mdbH2O = moldb.MdbExomol('.database/H2O/1H2-16O/POKAZATEL',
nus,
crit=1.e-46)
#LOADING CIA
cdbH2H2 = contdb.CdbCIA('.database/H2-H2_2011.cia', nus)
cdbH2He = contdb.CdbCIA('.database/H2-He_2011.cia', nus)
#REDUCING UNNECESSARY LINES
#1. CO
Tarr = T0c * np.ones_like(Parr)
qt = vmap(mdbCO.qr_interp)(Tarr)
gammaLMP = jit(vmap(gamma_exomol,(0,0,None,None)))\
(Parr,Tarr,mdbCO.n_Texp,mdbCO.alpha_ref)
gammaLMN = gamma_natural(mdbCO.A)
gammaLM = gammaLMP + gammaLMN[None, :]
SijM=jit(vmap(SijT,(0,None,None,None,0)))\
(Tarr,mdbCO.logsij0,mdbCO.nu_lines,mdbCO.elower,qt)
sigmaDM=jit(vmap(doppler_sigma,(None,0,None)))\
(mdbCO.nu_lines,Tarr,molmassCO)
mask_CO, maxcf, maxcia = mask_weakline(mdbCO,
Parr,
dParr,
Tarr,
SijM,
gammaLM,
sigmaDM,
maxMMR_CO * ONEARR,
molmassCO,
mmw,
g,
vmrH2,
cdbH2H2,
margin=2)
mdbCO.masking(mask_CO)
#plot_maxpoint(mask_CO,Parr,maxcf,maxcia,mol="CO")
#plt.savefig("maxpoint_CO.pdf", bbox_inches="tight", pad_inches=0.0)
#2. H2O
T0xarr = list(range(500, 1800, 100))
for k, T0x in enumerate(T0xarr):
Tarr = T0x * np.ones_like(Parr)
qt = vmap(mdbH2O.qr_interp)(Tarr)
gammaLMP = jit(vmap(gamma_exomol,(0,0,None,None)))\
(Parr,Tarr,mdbH2O.n_Texp,mdbH2O.alpha_ref)
gammaLMN = gamma_natural(mdbH2O.A)
gammaLM = gammaLMP + gammaLMN[None, :]
SijM=jit(vmap(SijT,(0,None,None,None,0)))\
(Tarr,mdbH2O.logsij0,mdbH2O.nu_lines,mdbH2O.elower,qt)
sigmaDM=jit(vmap(doppler_sigma,(None,0,None)))\
(mdbH2O.nu_lines,Tarr,molmassH2O)
mask_H2O_tmp, maxcf, maxcia = mask_weakline(mdbH2O,
Parr,
dParr,
Tarr,
SijM,
gammaLM,
sigmaDM,
maxMMR_H2O * ONEARR,
molmassH2O,
mmw,
g,
vmrH2,
cdbH2H2,
margin=2)
if k == 0:
mask_H2O = np.copy(mask_H2O_tmp)
else:
mask_H2O = mask_H2O + mask_H2O_tmp
if k == len(T0xarr) - 1:
print("H2O ")
plot_maxpoint(mask_H2O_tmp, Parr, maxcf, maxcia, mol="H2O")
plt.savefig("maxpoint_H2O.pdf",
bbox_inches="tight",
pad_inches=0.0)
print("H2O saved")
mdbH2O.masking(mask_H2O)
print("Final:", len(mask_H2O), "->", np.sum(mask_H2O))
#nu matrix
numatrix_CO = make_numatrix0(nus, mdbCO.nu_lines)
numatrix_H2O = make_numatrix0(nus, mdbH2O.nu_lines)
return fobsx, nusdx, wavdx, errx, nus, wav, res, mdbCO, mdbH2O, numatrix_CO, numatrix_H2O, cdbH2H2, cdbH2He
def ap(fobs, nusd, ws, we, Nx):
mask = (ws < wavd[::-1]) * (wavd[::-1] < we)
#additional mask
mask = mask * ((22898.5 > wavd[::-1]) + (wavd[::-1] > 22899.5))
fobsx = fobs[mask]
nusdx = nusd[mask]
wavdx = 1.e8 / nusdx[::-1]
errx = err[mask]
nus, wav, res = nugrid(ws - 5.0, we + 5.0, Nx, unit="AA")
#loading molecular database
#mdbCO=moldb.MdbExomol('.database/CO/12C-16O/Li2015',nus)
mdbCO = moldb.MdbHit('05_HITEMP2019.par.bz2', nus)
mdbCO.ExomolQT('.database/CO/12C-16O/Li2015')
##use HITEMP later
mdbH2O = moldb.MdbExomol('H2O/1H2-16O/POKAZATEL', nus, crit=1.e-45)
# mdbH2O=moldb.MdbExomol('.database/H2O/1H2-16O/POKAZATEL',nus)
print("resolution=", res)
#LOADING CIA
cdbH2H2 = contdb.CdbCIA('H2-H2_2011.cia', nus)
cdbH2He = contdb.CdbCIA('H2-He_2011.cia', nus)
### REDUCING UNNECESSARY LINES
#######################################################
#1. CO
Tarr = T0c * np.ones_like(Parr)
qt = vmap(mdbCO.qr_interp)(Tarr)
# gammaL = gamma_hitran(Pfix,Tfix, Ppart, mdbCO.n_air, \
# mdbCO.gamma_air, mdbCO.gamma_self) \
gammaLMP = 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 = gamma_natural(mdbCO.A)
#(Nlayer, Nlines)+(None, Nlines)=(Nlayers, Nlines)
gammaLM = gammaLMP + gammaLMN[None, :]
SijM=jit(vmap(SijT,(0,None,None,None,0)))\
(Tarr,mdbCO.logsij0,mdbCO.nu_lines,mdbCO.elower,qt)
sigmaDM=jit(vmap(doppler_sigma,(None,0,None)))\
(mdbCO.nu_lines,Tarr,molmassCO)
mask_CO, maxcf, maxcia = mask_weakline(mdbCO, Parr, dParr, Tarr, SijM,
gammaLM, sigmaDM,
maxMMR_CO * ONEARR, molmassCO, mmw,
g, vmrH2, cdbH2H2)
mdbCO.masking(mask_CO)
plot_maxpoint(mask_CO, Parr, maxcf, maxcia, mol="CO")
plt.savefig("npz/maxpoint_CO.pdf", bbox_inches="tight", pad_inches=0.0)
#2. H2O
T0xarr = list(range(500, 1800, 100))
for k, T0x in enumerate(T0xarr):
Tarr = T0x * np.ones_like(Parr)
qt = vmap(mdbH2O.qr_interp)(Tarr)
gammaLMP = jit(vmap(gamma_exomol,(0,0,None,None)))\
(Parr,Tarr,mdbH2O.n_Texp,mdbH2O.alpha_ref)
gammaLMN = gamma_natural(mdbH2O.A)
gammaLM = gammaLMP + gammaLMN[None, :]
SijM=jit(vmap(SijT,(0,None,None,None,0)))\
(Tarr,mdbH2O.logsij0,mdbH2O.nu_lines,mdbH2O.elower,qt)
sigmaDM=jit(vmap(doppler_sigma,(None,0,None)))\
(mdbH2O.nu_lines,Tarr,molmassH2O)
mask_H2O_tmp, maxcf, maxcia = mask_weakline(mdbH2O, Parr, dParr, Tarr,
SijM, gammaLM, sigmaDM,
maxMMR_H2O * ONEARR,
molmassH2O, mmw, g, vmrH2,
cdbH2H2)
if k == 0:
mask_H2O = np.copy(mask_H2O_tmp)
else:
mask_H2O = mask_H2O + mask_H2O_tmp
if T0x == 1700.0:
plot_maxpoint(mask_H2O_tmp, Parr, maxcf, maxcia, mol="H2O")
plt.savefig("maxpoint_H2O.pdf",
bbox_inches="tight",
pad_inches=0.0)
mdbH2O.masking(mask_H2O)
print("Final:", len(mask_H2O), "->", np.sum(mask_H2O))
#nu matrix
numatrix_CO = make_numatrix0(nus, mdbCO.nu_lines)
numatrix_H2O = make_numatrix0(nus, mdbH2O.nu_lines)
cdbH2H2 = contdb.CdbCIA('.database/H2-H2_2011.cia', nus)
cdbH2He = contdb.CdbCIA('.database/H2-He_2011.cia', nus)
return fobsx, nusdx, wavdx, errx, nus, wav, res, mdbCO, mdbH2O, numatrix_CO, numatrix_H2O, cdbH2H2, cdbH2He
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
