solarwindpy 0.0.1.dev0__py3-none-any.whl → 0.1.0__py3-none-any.whl

solarwindpy/plotting/labels/composition.py

@@ -0,0 +1,100 @@
+__all__ = ["Ion", "ChargeState"]
+
+import pdb  # noqa: F401
+from pathlib import Path
+from . import base
+
+known_species = ("C", "Fe", "He", "Mg", "Ne", "N", "O", "Si", "S")
+
+
+class Ion(base.Base):
+    """Represent a single ion."""
+
+    def __init__(self, species, charge):
+        """Instantiate the ion."""
+        super().__init__()
+        self.set_species_charge(species, charge)
+
+    @property
+    def species(self):
+        return self._species
+
+    @property
+    def charge(self):
+        return self._charge
+
+    @property
+    def tex(self):
+        return "{%s}^{%s}" % (self.species, self.charge)
+
+    @property
+    def units(self):
+        return r"\#"  # noqa: W605
+
+    @property
+    def path(self):
+        return Path(
+            f"""{self.species}_{self.charge.replace("+", "p").replace("-", "m")}"""
+        )
+
+    def set_species_charge(self, species, charge):
+        species = species.title()
+        if species not in known_species:
+            self.logger.warning(f"Unknown species ({species})")
+
+        invalid_charge = False
+        try:
+            isinstance(int(charge), int)
+        except ValueError:
+            invalid_charge = True
+
+        if invalid_charge and charge not in ("i", "j"):
+            raise ValueError(f"Invalid charge ({charge})")
+
+        self._species = species
+        self._charge = charge
+
+
+class ChargeState(base.Base):
+    """Ratio of two ion abundances."""
+
+    def __init__(self, ionA, ionB):
+        """Instantiate the charge-state ratio."""
+        super().__init__()
+        self.set_ions(ionA, ionB)
+
+    @property
+    def ionA(self):
+        return self._ionA
+
+    @property
+    def ionB(self):
+        return self._ionB
+
+    @property
+    def path(self):
+        return Path(f"{str(self.ionA.path)}-OV-{str(self.ionB.path)}")
+
+    @property
+    def tex(self):
+        return f"{self.ionA.tex}/{self.ionB.tex}"
+
+    @property
+    def units(self):
+        uA = self.ionA.units
+        uB = self.ionB.units
+
+        units = r"\#"
+        if uA != uB:
+            units = f"{uA}/{uB}"
+
+        return units
+
+    def set_ions(self, ionA, ionB):
+        if not isinstance(ionA, Ion):
+            ionA = Ion(*ionA)
+        if not isinstance(ionB, Ion):
+            ionB = Ion(*ionB)
+
+        self._ionA = ionA
+        self._ionB = ionB

solarwindpy/plotting/labels/datetime.py

@@ -0,0 +1,235 @@
+#!/usr/bin/env python
+r"""Special labels not handled by :py:class:`TeXlabel`."""
+import pdb  # noqa: F401
+from pathlib import Path
+from pandas.tseries.frequencies import to_offset
+from . import base
+from . import special
+
+
+class Timedelta(special.ArbitraryLabel):
+    """Label for a time interval."""
+
+    def __init__(self, offset):
+        """Instantiate the label.
+
+        Parameters
+        ----------
+        offset : str or pandas offset
+            Value convertible via :func:`pandas.tseries.frequencies.to_offset`.
+        """
+        super().__init__()
+        self.set_offset(offset)
+
+    def __str__(self):
+        return self.with_units
+
+    @property
+    def with_units(self):
+        return rf"${self.tex} \; [{self.units}]$"  # noqa: W605
+
+    #     @property
+    #     def dt(self):
+    #         return self._dt
+
+    @property
+    def offset(self):
+        return self._offset
+
+    @property
+    def tex(self):
+        return r"\Delta t"
+
+    @property
+    def path(self):
+        try:
+            return Path(f"dt-{self.offset.freqstr}")
+        except AttributeError:
+            return Path("dt-UNK")
+
+    @property
+    def units(self):
+        try:
+            return r"%s \; \mathrm{%s}" % (
+                self.offset.n,
+                self.offset.name,
+            )  # noqa: W605
+        except AttributeError:
+            return base._inU["unknown"]
+
+    def set_offset(self, new):
+        try:
+            new = to_offset(new)
+        except ValueError:
+            pass
+
+        self._offset = new
+
+
+class DateTime(special.ArbitraryLabel):
+    """Generic datetime label."""
+
+    def __init__(self, kind):
+        """Instantiate the label.
+
+        Parameters
+        ----------
+        kind : str
+            Text used to build the label, e.g. ``"Year"`` or ``"Month"``.
+        """
+        super().__init__()
+        self.set_kind(kind)
+
+    def __str__(self):
+        return self.with_units
+
+    @property
+    def with_units(self):
+        return r"$%s$" % self.tex
+
+    @property
+    def kind(self):
+        return self._kind
+
+    @property
+    def tex(self):
+        return r"\mathrm{%s}" % self.kind.replace(" ", r" \; ")  # noqa: W605
+
+    @property
+    def path(self):
+        return Path(self.kind.lower().replace(" ", "-"))
+
+    def set_kind(self, new):
+        self._kind = new
+
+
+class Epoch(special.ArbitraryLabel):
+    r"""Create epoch analysis labels, e.g. ``Hour of Day``."""
+
+    def __init__(self, kind, of_thing, space=r"\,"):
+        """Instantiate the label.
+
+        Parameters
+        ----------
+        kind : str
+            The smaller time unit, e.g. ``"Hour"``.
+        of_thing : str
+            The larger time unit, e.g. ``"Day"``.
+        space : str, default ``","``
+            TeX spacing command placed between words.
+        """
+        super().__init__()
+        self.set_smaller(kind)
+        self.set_larger(of_thing)
+        self.set_space(space)
+
+    def __str__(self):
+        return self.with_units
+
+    @property
+    def larger(self):
+        return self._larger
+
+    @property
+    def path(self):
+        return Path(f"{self.smaller}-of-{self.larger}")
+
+    @property
+    def smaller(self):
+        return self._smaller
+
+    @property
+    def space(self):
+        return self._space
+
+    @property
+    def tex(self):
+        return r"\mathrm{%s %s of %s %s}" % (
+            self.smaller,
+            self.space,
+            self.space,
+            self.larger,
+        )
+
+    @property
+    def with_units(self):
+        return r"$%s$" % self.tex
+
+    def set_larger(self, new):
+        self._larger = new.title()
+
+    def set_smaller(self, new):
+        self._smaller = new.title()
+
+    def set_space(self, new):
+        if new not in (" ", r"\,", r"\;", r"\:"):
+            raise ValueError(f"Unrecognized Space {new}")
+
+        self._space = new
+
+
+class Frequency(special.ArbitraryLabel):
+    """Frequency of another quantity."""
+
+    def __init__(self, other):
+        super().__init__()
+        self.set_other(other)
+        self.build_label()
+
+    def __str__(self):
+        return rf"${self.tex} \; [{self.units}]$"
+
+    @property
+    def other(self):
+        return self._other
+
+    @property
+    def tex(self):
+        return r"\mathrm{Frequency}"
+
+    @property
+    def units(self):
+        return f"({self.other.units})^{-1}"
+
+    @property
+    def path(self):
+        return self._path
+
+    def set_other(self, other):
+        if not isinstance(other, Timedelta):
+            other = Timedelta(other)
+
+        self._other = other
+
+    def _build_path(self):
+        units = self.units
+        if "??" in units:
+            units = "UNK"
+
+        path = Path(f"frequency_of_{units}")
+        return path
+
+    def build_label(self):
+        self._path = self._build_path()
+
+
+class January1st(special.ArbitraryLabel):
+    """Label for the first day of the year."""
+
+    def __init__(self):
+        super().__init__()
+
+    def __str__(self):
+        return self.with_units
+
+    @property
+    def with_units(self):
+        return r"$%s$" % self.tex
+
+    @property
+    def tex(self):
+        return r"\mathrm{January 1^{st} of Year}".replace(" ", r" \; ")  # noqa: W605
+
+    @property
+    def path(self):
+        return Path("January-1st-of-Year")

solarwindpy/plotting/labels/elemental_abundance.py

@@ -0,0 +1,73 @@
+__all__ = ["ElementalAbundance"]
+
+import pdb  # noqa: F401
+import logging
+from pathlib import Path
+from . import base
+
+known_species = tuple(base._trans_species.keys()) + ("X",)
+
+
+class ElementalAbundance(base.Base):
+    """Ratio of elemental abundances."""
+
+    def __init__(self, species, reference_species, pct_unit=False, photospheric=True):
+        """Instantiate the abundance label."""
+        self.set_species(species, reference_species)
+        self._pct_unit = bool(pct_unit)
+        self._photospheric = bool(photospheric)
+
+    @property
+    def species(self):
+        return self._species
+
+    @property
+    def photospheric(self):
+        return self._photospheric
+
+    @property
+    def reference_species(self):
+        return self._reference_species
+
+    @property
+    def units(self):
+        if self.pct_unit:
+            return r"\%"
+        else:
+            return r"\#"  # noqa: W605
+
+    @property
+    def tex(self):
+        num = base._trans_species.get(self.species, self.species)
+        den = base._trans_species.get(self.reference_species, self.reference_species)
+        ratio = r"\mathrm{%s}/\mathrm{%s}" % (num, den)
+        if self.photospheric:
+            tex = f"{ratio}:{ratio}_" r"\mathrm{photo}"  # noqa: W605
+        else:
+            tex = ratio
+        return tex
+
+    @property
+    def path(self):
+        path = f"{self.species}-OV-{self.reference_species}"
+        if self.photospheric:
+            path += "_photospheric-ratio"
+        return Path(path)
+
+    @property
+    def pct_unit(self):
+        return self._pct_unit
+
+    def set_species(self, species, reference_species):
+        species = species.title()
+        reference_species = reference_species.title()
+
+        if species not in known_species:
+            logging.getLogger().warning(f"Species ({species}) is not recognized")
+        if reference_species not in known_species:
+            logging.getLogger().warning(
+                f"Reference species ({reference_species}) is not recognized"
+            )
+
+        self._species = species
+        self._reference_species = reference_species