dgpost 2.2.2__tar.gz → 2.3__tar.gz

{dgpost-2.2.2/src/dgpost.egg-info → dgpost-2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dgpost
-Version: 2.2.2
+Version: 2.3
 Summary: datagram post-processing toolkit
 Author: Ueli Sauter
 Author-email: Peter Kraus <peter.kraus@tu-berlin.de>

{dgpost-2.2.2 → dgpost-2.3}/src/dgpost/main.py

@@ -97,7 +97,6 @@ def run(path: str, patch: str = None) -> tuple[dict, dict]:
         if saveas in tables:
             temp = combine_tables(tables[saveas], newdf)
             temp.attrs = tables[saveas].attrs
-            temp.attrs["units"].update(newdf.attrs["units"])
             tables[saveas] = temp
         else:
             tables[saveas] = newdf

{dgpost-2.2.2 → dgpost-2.3}/src/dgpost/transform/catalysis.py

@@ -208,7 +208,8 @@ def conversion(
             standard,
         )
         sd = smiles[name_to_chem(standard).smiles]
-        exp = inp[sd["inp"]] / out[sd["out"]]
+        temp = np.where(out[sd["out"]] > 0, out[sd["out"]], np.nan)
+        exp = inp[sd["inp"]] / temp
 
     # reactant-based conversion
     if type == "reactant":
@@ -216,7 +217,8 @@ def conversion(
         assert "out" in fd, f"Feedstock '{feedstock}' not in outlet."
         logger.debug("Calculating reactant-based conversion.")
         dfsm = inp[fd["inp"]] - out[fd["out"]] * exp
-        Xr = dfsm / inp[fd["inp"]]
+        f_in = np.where(inp[fd["inp"]] > 0, inp[fd["inp"]], np.nan)
+        Xr = dfsm / f_in
         tag = f"{'Xr' if output is None else output}->{feedstock}"
         ret = {tag: Xr}
 
@@ -224,6 +226,7 @@ def conversion(
     else:
         assert "inp" in fd, f"Feedstock '{feedstock}' not in inlet."
         f_in = inp[fd["inp"]] * element_from_formula(fform, element)
+        f_in = np.where(f_in > 0, f_in, np.nan)
         nat_out = f_in * 0.0
 
         if "out" in fd:
@@ -241,6 +244,7 @@ def conversion(
                 nat_out += dnat
         if type == "product":
             logger.debug("Calculating product-based conversion using reactant outlet.")
+            nat_out = np.where(nat_out > 0, nat_out, np.nan)
             Xp = (nat_out - f_out) / nat_out
             prefix = f"Xp_{element}" if output is None else output
         elif type == "mixed":
@@ -342,6 +346,8 @@ def selectivity(
                 nat_out = dnat
             else:
                 nat_out += dnat
+
+    nat_out = np.where(nat_out > 0, nat_out, np.nan)
     ret = {}
     for k, v in smiles.items():
         if k != fsmi and "out" in v:
@@ -523,7 +529,8 @@ def atom_balance(
 
     if rin is None:
         sd = smiles[name_to_chem(standard).smiles]
-        exp = inp[sd["inp"]] / out[sd["out"]]
+        temp = np.where(out[sd["out"]] > 0, out[sd["out"]], np.nan)
+        exp = inp[sd["inp"]] / temp
     else:
         exp = 1.0
 
@@ -537,6 +544,8 @@ def atom_balance(
         if "out" in v:
             dout = exp * out[v["out"]] * element_from_formula(formula, element)
             nat_out = dout if nat_out is None else nat_out + dout
+
+    nat_in = np.where(nat_in > 0, nat_in, np.nan)
     dnat = nat_in - nat_out
     atbal = 1 - dnat / nat_in
     tag = f"atbal_{element}" if output is None else output

dgpost-2.3/src/dgpost/transform/complex.py

@@ -0,0 +1,108 @@
+"""
+.. codeauthor::
+    Peter Kraus
+
+Provides convenience functions for converting complex numbers between rectangular and
+polar forms.
+
+.. rubric:: Functions
+
+.. autosummary::
+
+    to_rectangular
+    to_polar
+
+
+"""
+
+import pint
+import numpy as np
+from uncertainties import unumpy as unp
+from dgpost.utils.helpers import load_data
+
+
+@load_data(
+    ("mag", None, list),
+    ("arg", "radians", list),
+)
+def to_rectangular(
+    mag: pint.Quantity,
+    arg: pint.Quantity,
+    output: str = None,
+) -> pint.Quantity:
+    """
+    Convert the provided complex number in polar form :math:`(r, θ)` to rectangular
+    (or Cartesian) form :math:`(x, y)`.
+
+    Parameters
+    ----------
+    mag
+        The magnitude :math:`r`.
+
+    arg
+        The argument (or angle) :math:`θ`. By default in radians.
+
+    output
+        Name of the output namespace. Defaults to ``None``, which means ``x`` and ``y``
+        will be returned.
+
+    Returns
+    -------
+    dict(output, x) : dict[str, pint.Quantity]
+        Returns the Cartesian x-coordinate.
+
+    dict(output, y) : dict[str, pint.Quantity]
+        Returns the Cartesian y-coordinate.
+
+    """
+    arg_rad = arg.to("radians")
+    y = mag * unp.sin(arg_rad)
+    x = mag * unp.cos(arg_rad)
+    pretag = "" if output is None else f"{output}->"
+    return {f"{pretag}x": x, f"{pretag}y": y}
+
+
+@load_data(
+    ("x", None, list),
+    ("y", None, list),
+)
+def to_polar(
+    x: pint.Quantity,
+    y: pint.Quantity,
+    output: str = None,
+) -> pint.Quantity:
+    """
+    Convert the provided complex number in rectangular form :math:`(x, y)` to polar
+    form :math:`(r, θ)`.
+
+    Returns
+
+    Parameters
+    ----------
+    x
+        The Cartesian x-coordinate of the complex number.
+
+    y
+        The Cartesian y-coordinate of the complex number.
+
+    output
+        Name of the output namespace. Defaults to ``None``, which means ``mag`` and
+        ``arg`` will be returned.
+
+    Returns
+    -------
+    dict(output, mag) : dict[str, pint.Quantity]
+        Returns the magnitude (r) of the complex number.
+
+    dict(output, arg) : dict[str, pint.Quantity]
+        Returns the argument (θ) of the complex number, in radians.
+
+    """
+    print(f"{x=}")
+    x = np.asarray(x)
+    y = np.asarray(y)
+    print(f"{x=}")
+    mag = pint.Quantity(unp.sqrt(x**2 + y**2), "dimensionless")
+    arg = pint.Quantity(unp.arctan2(y, x), "radians")
+    pretag = "" if output is None else f"{output}->"
+    return {f"{pretag}mag": mag, f"{pretag}arg": arg}

dgpost-2.3/src/dgpost/transform/mixtures.py

@@ -0,0 +1,93 @@
+"""
+.. codeauthor::
+    Peter Kraus
+
+Includes functions to convert namespaces containing mixtures of chemicals between
+various representations, such as mole fractions etc.
+
+.. rubric:: Functions
+
+.. autosummary::
+
+    flows_to_fractions
+    fractions_to_flows
+
+"""
+
+import pint
+import numpy as np
+
+from dgpost.utils.helpers import load_data, fill_nans
+
+ureg = pint.get_application_registry()
+
+
+@load_data(
+    ("total", "m³/s"),
+    ("vdot", "m³/s", dict),
+)
+def flows_to_fractions(
+    total: pint.Quantity,
+    vdot: dict[str, pint.Quantity] = None,
+    output: str = "x",
+    _inp: dict = {},
+) -> dict[str, pint.Quantity]:
+    """
+    Calculates the volume fractions of components in the provided namespace ``vdot``,
+    given the total flow in ``total``.
+
+    Parameters
+    ----------
+    total
+        The total flow, by default in m³/s. Negative or zero values are ignored.
+
+    vdot
+        The dictionary containing flows of all species/components. By default in m³/s.
+
+    output
+        Prefix of the output namespace. Defaults to "x" for mole fraction.
+
+    """
+    ret = {}
+    temp = np.where(total > 0, total, np.nan)
+    for k, v in vdot.items():
+        if _inp["total"] == f"{_inp['vdot']}->{k}":
+            continue
+        ret[f"{output}->{k}"] = v / temp
+    return ret
+
+
+@load_data(
+    ("total", "m³/s"),
+    ("x", None, dict),
+)
+def fractions_to_flows(
+    total: pint.Quantity,
+    x: dict[str, pint.Quantity] = None,
+    fillnan: bool = True,
+    output: str = "vdot",
+    _inp: dict = {},
+) -> dict[str, pint.Quantity]:
+    """
+    Calculates the partial flow rates in the mixture given mole fractions in the provided
+    namespace ``x`` and the total flow in ``total``.
+
+    Parameters
+    ----------
+    total
+        The total flow, by default in m³/s. Negative or zero values are ignored.
+
+    x
+        The dictionary containing mole fractions of all species/components.
+
+    output
+        Prefix of the output namespace. Defaults to "vdot" for flow rates.
+
+    """
+    ret = {}
+    temp = np.where(total > 0, total, np.nan)
+    for k, v in x.items():
+        if fillnan:
+            v = fill_nans(v, fillmag=0.0)
+        ret[f"{output}->{k}"] = v * temp
+    return ret