from pyarts.classes.GriddedField6 import GriddedField6 from pyarts.classes.BasicTypes import String, ArrayOfString from pyarts.classes.Vector import Vector from pyarts.classes.Matrix import Matrix from pyarts.classes.Tensor3 import Tensor3 from pyarts.classes.Tensor4 import Tensor4 from pyarts.classes.Tensor5 import Tensor5 from pyarts.classes.Tensor6 import Tensor6 from pyarts.classes import from_workspace # Get a workspace ws = Workspace() # Get some variables gf1 = from_workspace(ws.sideband_response) gf2 = from_workspace(ws.surface_type_mask) gf3 = from_workspace(ws.z_field_raw) gf4 = from_workspace(ws.antenna_response) gf5 = GriddedField5() gf6 = GriddedField6() assert not gf1 assert not gf2 assert not gf3 assert not gf4 assert not gf5 assert not gf6 assert gf1.OK assert gf2.OK
from pyarts.workspace import Workspace
from pyarts.classes.GasAbsLookup import GasAbsLookup
from pyarts.classes import from_workspace
# Get a workspace
ws = Workspace()
gal = from_workspace(ws.abs_lookup)
assert isinstance(gal, GasAbsLookup)
gal2 = GasAbsLookup()
gal.savexml("tmp.gal.xml", "binary")
gal2.readxml("tmp.gal.xml")
assert gal == gal2
from pyarts.workspace import Workspace from pyarts.classes.Ppath import Ppath from pyarts.classes import from_workspace # Get a workspace ws = Workspace() ws.atmosphere_dim = 1 ws.cloudbox_on = 0 ws.ppath_inside_cloudbox_do = 0 cloudbox_limits = from_workspace(ws.cloudbox_limits) z_field = from_workspace(ws.z_field) z_field.data = [0, 1, 2, 3] z_field.data = z_field.data.reshape(4, 1, 1) z_surface = from_workspace(ws.z_surface) z_surface.data = [0] rte_pos = from_workspace(ws.rte_pos) rte_pos.data = [4] rte_los = from_workspace(ws.rte_los) rte_los.data = [91] ws.ppath_lmax = 0.1 ws.ppathPlaneParallel() # Get the path path = from_workspace(ws.ppath) path2 = Ppath() path2.set(path) assert isinstance(path, Ppath), "Bad read" assert path, "Bad read" assert path2 == path
from pyarts.workspace import Workspace from pyarts.classes.PropagationMatrix import PropagationMatrix, ArrayOfPropagationMatrix from pyarts.classes.StokesVector import StokesVector, ArrayOfStokesVector from pyarts.classes import from_workspace # Get a workspace ws = Workspace() # Get the agenda apm = from_workspace(ws.dpropmat_clearsky_dx) asv = from_workspace(ws.dnlte_source_dx) pm = PropagationMatrix(1.0, 4, 4, 4, 4) sv = StokesVector(1.0, 4, 4, 4, 4) assert isinstance(apm, ArrayOfPropagationMatrix) apm.size = 6 apm[0].setData(1, 4, 3, 2, 0.0) apm[1].setData(1, 4, 2, 4, 1.0) apm[2].setData(2, 3, 1, 8, 2.0) apm[3].setData(3, 2, 2, 16, 3.14) apm[4].setData(5, 1, 1, 32, 6.28) apm[4].set(apm[3]) apm[5].set(pm) assert not apm[0] assert apm[1] assert apm[3] == apm[4] assert apm[5] == pm assert isinstance(asv, ArrayOfStokesVector) asv.size = 6
import os
from pyarts.workspace import Workspace
from pyarts.classes import from_workspace
from pyarts.classes.AbsorptionLines import AbsorptionLines, ArrayOfAbsorptionLines
ws = Workspace()
datapath = "../../arts-xml-data/" if not os.getenv(
"ARTS_XML_DATA_DIR") else os.getenv("ARTS_XML_DATA_DIR")
fn1 = os.path.join(datapath, 'spectroscopy/Artscat/')
fn2 = os.path.join(datapath, 'spectroscopy/Artscat/O2-66.xml')
# Init
al = AbsorptionLines()
aal = ArrayOfAbsorptionLines()
aaal = from_workspace(ws.abs_lines_per_species)
# Init is as expected
assert al.selfbroadening == False, "Bad init"
assert al.bathbroadening == False, "Bad init"
assert al.cutoff == "None", "Bad init"
assert al.mirroring == "None", "Bad init"
assert al.population == "LTE", "Bad init"
assert al.normalization == "None", "Bad init"
assert al.lineshapetype == "VP", "Bad init"
assert al.t0 == 296, "Bad init"
assert al.cutofffreq == -1, "Bad init"
assert al.linemixinglimit == -1, "Bad init"
assert al.quantumidentity.spec_ind == -1, "Bad init"
assert al.quantumidentity.type == "None", "Bad init"
assert not al.localquantumnumbers, "Bad init"
assert not al.broadeningspecies, "Bad init"
from pyarts.classes.Vector import Vector
from pyarts.classes.Matrix import Matrix
from pyarts.classes.MCAntenna import MCAntenna
from pyarts.classes import from_workspace
ws = Workspace()
mca = MCAntenna()
mca.type = 1
mca.type = 2
mca.type = 3
mca.sigma_aa = 4.5
mca.sigma_za = 4.5
mca.aa_grid = Vector([1, 2, 3, 4])
mca.za_grid = Vector([1, 2, 3, 4, 5])
mca.g_lookup = Matrix([[5, 6, 7, 8], [5, 6, 7, 8], [5, 6, 7, 8], [5, 6, 7, 8],
[5, 6, 7, 8]])
mca2 = from_workspace(ws.mc_antenna)
mca2.set(mca)
assert mca2 == mca
# mca3 = MCAntenna()
# mca.savexml("tmp.mca.xml", "binary")
# mca3.readxml("tmp.mca.xml")
# assert mca3 == mca
from pyarts.workspace import Workspace
from pyarts.classes.CIARecord import CIARecord, ArrayOfCIARecord
from pyarts.classes import from_workspace
# Get a workspace
ws = Workspace()
datapath = "../../arts-xml-data/" if not os.getenv(
"ARTS_XML_DATA_DIR") else os.getenv("ARTS_XML_DATA_DIR")
fn = os.path.join(datapath,
"spectroscopy/cia/borysow/Borysow_CIA_JUICE_SWI.xml")
acr1 = ArrayOfCIARecord()
assert not acr1, "Bad init"
acr1.readxml(fn)
ws.ReadXML(ws.abs_cia_data, fn)
acr2 = from_workspace(ws.abs_cia_data)
assert acr1, "Bad read"
assert acr1 == acr2, "Bad read"
assert isinstance(acr1[0], CIARecord), "Bad type"
acr3 = ArrayOfCIARecord()
acr3.set(acr1)
assert acr1 == acr3, "Bad read"
acr1.savexml("tmp.acr.xml", "binary")
acr3 = ArrayOfCIARecord()
acr3.readxml("tmp.acr.xml")
assert acr3 == acr1
from pyarts.workspace import Workspace
from pyarts.classes.SpeciesTag import SpeciesTag, ArrayOfArrayOfSpeciesTag
from pyarts.classes import from_workspace
# Get a workspace
ws = Workspace()
aast = from_workspace(ws.abs_species)
st = SpeciesTag("H2O-161")
ws.abs_speciesSet(species=["H2O-161"])
aast.size = 2
aast[1].size = 1
aast[1][0].set(aast[0][0])
assert st == aast[0][0]
assert st == aast[1][0]
aast.savexml("tmp.aast.xml", "binary")
aast2 = ArrayOfArrayOfSpeciesTag()
aast2.readxml("tmp.aast.xml")
assert aast == aast2
from pyarts.workspace import Workspace
from pyarts.classes.Agenda import Agenda
from pyarts.classes import from_workspace
# Get a workspace
ws = Workspace()
# Get the agenda
agenda = from_workspace(ws.abs_xsec_agenda)
assert isinstance(agenda, Agenda), "Bad read"
# a = Agenda()
# agenda.savexml("tmp.a.xml", "ascii")
# a.readxml("tmp.a.xml")
# assert a == a2
from math import isclose
from pyarts.workspace import Workspace
from pyarts.classes.Time import Time
from pyarts.classes import from_workspace
ws = Workspace()
ws.create_variable("Time", "start")
ws.create_variable("Time", "end")
ws.create_variable("Time", "time")
ws.create_variable("Numeric", "dt")
start_time = from_workspace(ws.start)
end_time = from_workspace(ws.end)
cur_time = from_workspace(ws.time)
dt = from_workspace(ws.dt)
# Test Now and Sleep
ws.timeNow(ws.start)
ws.Sleep(1)
ws.timeNow(ws.end)
ws.Duration(ws.dt, ws.start, ws.end)
assert dt >= 1, \
f"Slept for one second but duration was less: {float(dt):.3f} s"
# Test SleepUntil
ws.timeNow(ws.start)
end_time.sec = start_time.sec + 1
ws.timeSleep(ws.end)
ws.timeNow(ws.time)
duration = cur_time.sec - start_time.sec
assert duration >= 1, \
from pyarts.workspace import Workspace
from pyarts.classes.TessemNN import TessemNN
from pyarts.classes import from_workspace
# Get a workspace
ws = Workspace()
tnn = from_workspace(ws.tessem_netv)
tnn.nb_inputs = 1
tnn.nb_outputs = 2
tnn.nb_cache = 3
tnn.b1 = 4
tnn.b2 = 5
tnn.w1 = 6
tnn.w2 = 7
tnn.x_min = 8
tnn.x_max = 9
tnn.y_min = 10
tnn.y_max = 11
assert tnn == tnn
tnn2 = from_workspace(ws.tessem_neth)
tnn2.set(tnn)
assert tnn == tnn2
# tnn3 = TessemNN()
# tnn.savexml("tmp.tnn.xml", "binary")
# tnn3.readxml("tmp.tnn.xml")
# assert tnn == tnn3
import os
from pyarts.workspace import Workspace
from pyarts.classes.SpeciesAuxData import SpeciesAuxData
from pyarts.classes import from_workspace
# Get a workspace
ws = Workspace()
datapath = "../../arts-xml-data/" if not os.getenv(
"ARTS_XML_DATA_DIR") else os.getenv("ARTS_XML_DATA_DIR")
fn = os.path.join(datapath, 'planets/Mars/isotopratio_Mars.xml')
sad1 = SpeciesAuxData()
sad1.readxml(fn)
sad2 = from_workspace(ws.isotopologue_ratios)
ws.ReadXML(ws.isotopologue_ratios, fn)
sad3 = SpeciesAuxData()
sad3.set(sad2)
sad4 = SpeciesAuxData()
sad1.savexml("tmp.sad.xml", "binary")
sad4.readxml("tmp.sad.xml")
assert sad1 == sad4
assert sad1 == sad2
assert sad1 == sad3
from pyarts.workspace import Workspace from pyarts.classes.PropagationMatrix import PropagationMatrix, ArrayOfPropagationMatrix from pyarts.classes.StokesVector import StokesVector, ArrayOfStokesVector from pyarts.classes import from_workspace # Get a workspace ws = Workspace() # Get the agenda apm = from_workspace(ws.propmat_clearsky) asv = from_workspace(ws.nlte_source) pm = PropagationMatrix(1.0, 4, 4, 4, 4) sv = StokesVector(1.0, 4, 4, 4, 4) assert isinstance(apm, ArrayOfPropagationMatrix) apm.size = 6 apm[0].setData(1, 4, 3, 2, 0.0) apm[1].setData(1, 4, 2, 4, 1.0) apm[2].setData(2, 3, 1, 8, 2.0) apm[3].setData(3, 2, 2, 16, 3.14) apm[4].setData(5, 1, 1, 32, 6.28) apm[4].set(apm[3]) apm[5].set(pm) assert not apm[0] assert apm[1] assert apm[3] == apm[4] assert apm[5] == pm assert isinstance(asv, ArrayOfStokesVector) asv.size = 6
from time import sleep
from math import isclose
from pyarts.workspace import Workspace
from pyarts.classes.Timer import Timer
from pyarts.classes import from_workspace
ws = Workspace()
ws.timerStart()
time = 1
sleep(time)
ws.timerStop()
t = from_workspace(ws.timer)
assert isinstance(t, Timer)
if t.supported:
# Test that we are within 2.5 ticks of the true answer
assert isclose((t.realtime_end - t.realtime_start) / t.tick,
time,
rel_tol=2.5 / t.tick)
# t2 = Timer()
# t.savexml("tmp.t.xml", "binary")
# t2.readxml("tmp.t.xml")
# assert t == t2
def value(self):
""" Return the value of the variable in a given workspace.
By default this function will check the value in the workspace associated
with the variable of in the workspace object provided as argument to the
function call. If the variable has an associated workspace the workspace
provided as argument will be ignored.
Returns:
The value of the workspace variable represented by an object of
the corresponding python types.
Raises:
Exception: If the type of the workspace variable is not supported
by the interface.
"""
from pyarts.types import classes as arts_classes
from pyarts import classes as native_classes
if (self.ws):
ws = self.ws
if not ws:
raise ValueError(
"WorkspaceVariable object need Workspace to determine value.")
v = arts_api.get_variable_value(ws.ptr, self.ws_id, self.group_id)
if not v.initialized:
raise Exception("WorkspaceVariable " + self.name +
" is uninitialized.")
if self.group in arts_classes:
cls = arts_classes[self.group]
if hasattr(cls, "__from_variable_value_struct__"):
return cls.__from_variable_value_struct__(v)
if self.group == "Index":
return c.cast(v.ptr, c.POINTER(c.c_long))[0]
elif self.group == "Numeric":
return c.cast(v.ptr, c.POINTER(c.c_double))[0]
elif self.group == "String":
return (c.cast(v.ptr, c.c_char_p)).value.decode("utf8")
elif self.group == "ArrayOfIndex":
return [
c.cast(v.ptr, c.POINTER(c.c_long))[i]
for i in range(v.dimensions[0])
]
elif self.group == "Sparse":
m = v.dimensions[0]
n = v.dimensions[1]
nnz = v.dimensions[2]
if nnz == 0:
return sp.sparse.csr_matrix(0)
else:
data = np.ctypeslib.as_array(
c.cast(v.ptr, c.POINTER(c.c_double)), (nnz, ))
row_indices = np.ctypeslib.as_array(v.inner_ptr, (nnz, ))
col_starts = np.ctypeslib.as_array(v.outer_ptr, (m + 1, ))
return sp.sparse.csr_matrix((data, row_indices, col_starts),
shape=(m, n))
elif self.group == "Agenda":
return Agenda(v.ptr)
elif self.ndim:
shape = []
size = 1
for i in range(self.ndim):
shape.append(v.dimensions[i])
size *= v.dimensions[i]
if size > 0:
self.__array_interface__ = {
"shape": tuple(shape),
"typestr": "|f8",
"data": (v.ptr, False),
"version": 3
}
return np.asarray(self)
else:
return np.zeros(shape)
else:
if self.group in arts_classes:
try:
return self.to_arts()
except:
raise Exception(
"Type of workspace variable is not supported " +
" by the interface.")
else:
return native_classes.from_workspace(self)
from pyarts.workspace import Workspace
from pyarts.classes.BasicTypes import Numeric, Index, String
from pyarts.classes import from_workspace
# Get a workspace
ws = Workspace()
# Get the agenda
s = from_workspace(ws.output_file_format)
i = from_workspace(ws.abs_lookup_is_adapted)
n = from_workspace(ws.g0)
assert isinstance(s, String), "Bad read"
assert isinstance(n, Numeric), "Bad read"
assert isinstance(i, Index), "Bad read"
s.val = "Hej"
assert s == "Hej", "Bad write"
s.set(String("Help"))
assert s == "Help", "Bad write"
i.val = 3
assert i == 3, "Bad write"
i.set(5)
assert i == 5, "Bad write"
n.val = 3.5
assert n == 3.5, "Bad write"
n.set(3.14)
assert n == 3.14, "Bad write"
from pyarts.workspace import Workspace
from pyarts.classes.ScatteringMetaData import ScatteringMetaData
from pyarts.classes.SingleScatteringData import SingleScatteringData
from pyarts.classes import from_workspace
# Get a workspace
ws = Workspace()
datapath = "../../arts-xml-data/" if not os.getenv("ARTS_XML_DATA_DIR") else os.getenv("ARTS_XML_DATA_DIR")
fn1 = os.path.join(datapath, 'scattering/H2O_ice/MieSphere_R1.00000e+00um.meta.xml')
fn2 = os.path.join(datapath, 'scattering/H2O_ice/MieSphere_R1.00000e+00um.xml')
smd1 = ScatteringMetaData()
smd1.readxml(fn1)
smd2 = from_workspace(ws.scat_meta_single)
ws.ReadXML(ws.scat_meta_single, fn1)
smd3 = ScatteringMetaData()
smd3.set(smd2)
assert smd1 == smd2
assert smd1 == smd3
ssd1 = SingleScatteringData()
ssd1.readxml(fn2)
ssd2 = from_workspace(ws.scat_data_single)
ws.ReadXML(ws.scat_data_single, fn2)
ssd3 = SingleScatteringData()
ssd3.set(ssd2)
assert ssd1 == ssd2
from pyarts.workspace import Workspace from pyarts.classes.QuantumIdentifier import QuantumIdentifier from pyarts.classes.RetrievalQuantity import RetrievalQuantity, ArrayOfRetrievalQuantity from pyarts.classes.SpeciesTag import SpeciesTag from pyarts.classes.Vector import ArrayOfVector from pyarts.classes import from_workspace # Get a workspace ws = Workspace() ws.jacobianInit() ws.atmosphere_dim = 3 p = from_workspace(ws.p_grid) lat = from_workspace(ws.lat_grid) lon = from_workspace(ws.lon_grid) p.data = [3, 2, 1] lat.data = [1, 2, 3, 4] lon.data = [1, 2, 3, 4, 5] ws.jacobianAddTemperature(g1=p.data, g2=lat.data, g3=lon.data) arq = from_workspace(ws.jacobian_quantities) rq = RetrievalQuantity() rq.maintag = "" rq.subtag = "HSE on" rq.subsubtag = "" rq.mode = "" rq.analytical = 1 rq.target.type = "Atm" rq.target.subtype = "Temperature" rq.target.perturbation = 0.1 rq.grids = ArrayOfVector([p, lat, lon])
from pyarts.workspace import Workspace
from pyarts.classes.EnergyLevelMap import EnergyLevelMap
from pyarts.classes import from_workspace
# Get a workspace
ws = Workspace()
datapath = "../"
elm1 = EnergyLevelMap()
elm1.readxml(datapath +
"controlfiles/artscomponents/nlte/testdata/nlte_testdata.xml")
ws.ReadXML(
ws.nlte_field,
datapath + "controlfiles/artscomponents/nlte/testdata/nlte_testdata.xml")
elm2 = from_workspace(ws.nlte_field)
assert elm1, "Bad read"
assert elm1 == elm2, "Bad read"
assert elm1.data
elm3 = EnergyLevelMap()
elm3.set(elm1)
assert elm3 == elm2
elm4 = EnergyLevelMap()
elm1.savexml("tmp.elm.xml", "binary")
elm4.readxml("tmp.elm.xml")
assert elm4 == elm1
from pyarts.workspace import Workspace
from pyarts.classes.QuantumIdentifier import QuantumIdentifier, ArrayOfQuantumIdentifier
from pyarts.classes.SpeciesTag import SpeciesTag
from pyarts.classes import from_workspace
# Get a workspace
ws = Workspace()
aqi = from_workspace(ws.band_identifiers)
qi = QuantumIdentifier()
qi.spec_ind = 0
qi.type = "None"
qi.type = "All"
qi.type = "EnergyLevel"
qi.type = "Transition"
qi.upp["J"] = 3
qi.low["J"] = 2
aqi.data = [qi]
assert qi == aqi[0]
aqi.size = 2
aqi[1].set(aqi[0])
assert aqi[0] == aqi[1]
aqi.append(qi)
assert aqi[0] == aqi[2]
for x in aqi:
x.upp["J"] = 3
x.low["J"] = 2
