Add value setter for simple logged quantities.

examples/log-mpi.py

@@ -1,6 +1,7 @@
 #!/usr/bin/env python3
 
 from time import sleep
+from typing import Any
 from random import uniform
 from logpyle import (LogManager, add_general_quantities,
         add_simulation_quantities, add_run_info, IntervalTimer,
@@ -10,6 +11,27 @@
 from mpi4py import MPI
 
 
+class UserLogQuantity(LogQuantity):
+    """Logging support for arbitrary user quantities."""
+
+    def __init__(self, name, value=None, unit=None,
+          description=None, user_function=None) -> None:
+        LogQuantity.__init__(self, name=name, unit=unit,
+                             description=description)
+        self._quantity_value = value
+        self._uf = user_function
+
+    def __call__(self) -> float:
+        """Return the actual logged quantity."""
+        if self._uf:
+            return self._uf(self._quantity_value)
+        return self._quantity_value
+
+    def set_quantity_value(self, value: Any) -> None:
+        """Set the value of the logged quantity."""
+        self._quantity_value = value
+
+
 class Fifteen(LogQuantity):
     @property
     def default_aggregator(self):
@@ -30,6 +52,9 @@ def main():
 
     print(f"Rank {rank} of {size} ranks.")
 
+    def f1(q):
+        return (rank + 1)*q
+
     # Generic run metadata, such as command line, host, and time
     add_run_info(logmgr)
 
@@ -43,14 +68,23 @@ def main():
     vis_timer = IntervalTimer("t_vis", "Time spent visualizing")
     logmgr.add_quantity(vis_timer)
     logmgr.add_quantity(Fifteen("fifteen"))
+    logmgr.add_quantity(UserLogQuantity("q1"))
+    logmgr.add_quantity(UserLogQuantity("q2", value=0,
+                                        user_function=f1))
 
     # Watches are printed periodically during execution
     logmgr.add_watches([("step.max", "step={value} "),
-        ("t_step.min", "\nt_step({value:g},"), ("t_step.max", " {value:g})\n"),
-        "t_sim.max", "fifteen", "t_vis.max"])
+                        ("t_step.min", "\nt_step({value:g},"),
+                        ("t_step.max", " {value:g})\n"),
+                        ("q1.max", " UserQ1:({value:g}), "),
+                        ("q2.min", "UserQ2:({value:g},"),
+                        ("q2.max", "{value:g})\n"),
+                        "t_sim.max", "fifteen", "t_vis.max"])
 
     for istep in range(200):
         logmgr.tick_before()
+        logmgr.set_quantity_value("q1", 2*istep)
+        logmgr.set_quantity_value("q2", istep)
 
         dt = uniform(0.01, 0.1)
         set_dt(logmgr, dt)

examples/log.py

@@ -5,10 +5,32 @@
 from logpyle import (LogManager, add_general_quantities,
         add_simulation_quantities, add_run_info, IntervalTimer,
         LogQuantity, set_dt)
+from typing import Any
 
 from warnings import warn
 
 
+class UserLogQuantity(LogQuantity):
+    """Logging support for arbitrary user quantities."""
+
+    def __init__(self, name, value=None, unit=None,
+          description=None, user_function=None) -> None:
+        LogQuantity.__init__(self, name=name, unit=unit,
+                             description=description)
+        self._quantity_value = value
+        self._uf = user_function
+
+    def __call__(self) -> float:
+        """Return the actual logged quantity."""
+        if self._uf:
+            return self._uf(self._quantity_value)
+        return self._quantity_value
+
+    def set_quantity_value(self, value: Any) -> None:
+        """Set the value of the logged quantity."""
+        self._quantity_value = value
+
+
 class Fifteen(LogQuantity):
     def __call__(self):
         return 15
@@ -33,12 +55,15 @@ def main():
     vis_timer = IntervalTimer("t_vis", "Time spent visualizing")
     logmgr.add_quantity(vis_timer)
     logmgr.add_quantity(Fifteen("fifteen"))
+    logmgr.add_quantity(UserLogQuantity("q1", value=0))
 
     # Watches are printed periodically during execution
-    logmgr.add_watches(["step.max", "t_sim.max", "t_step.max", "fifteen", "t_vis"])
+    logmgr.add_watches(["step.max", "t_sim.max", "t_step.max", "fifteen", "t_vis",
+                        "q1"])
 
     for istep in range(200):
         logmgr.tick_before()
+        logmgr.set_quantity_value("q1", 2*istep + 1)
 
         dt = uniform(0.01, 0.1)
         set_dt(logmgr, dt)

logpyle/__init__.py

@@ -97,6 +97,7 @@ class LogQuantity:
     .. automethod:: tick
     .. autoproperty:: default_aggregator
     .. automethod:: __call__
+    .. automethod:: set_quantity_value
     """
 
     sort_weight = 0
@@ -136,6 +137,10 @@ def __call__(self) -> Optional[float]:
         """
         raise NotImplementedError
 
+    def set_quantity_value(self, value: Any) -> None:
+        """Set the logged quantity value."""
+        raise NotImplementedError
+
 
 class PostLogQuantity(LogQuantity):
     """A source of a loggable scalar that is gathered after each time step.
@@ -289,10 +294,12 @@ def __init__(self, quantity: LogQuantity, interval: int) -> None:
 
 class _QuantityData:
     def __init__(self, unit: str, description: str,
-                 default_aggregator: Callable) -> None:
+                 default_aggregator: Callable,
+                 value_setter: Callable = None) -> None:
         self.unit = unit
         self.description = description
         self.default_aggregator = default_aggregator
+        self.value_setter = value_setter
 
 
 def _join_by_first_of_tuple(list_of_iterables):
@@ -741,6 +748,20 @@ def set_constant(self, name: str, value: Any) -> None:
 
         self._commit()
 
+    def set_quantity_value(self, name: str, value: Any) -> None:
+        """Set a the value of a named LogQuantity.
+
+        :param name: the name of the logged quantity.
+        :param value: the value of the logged quantity.
+        """
+        if name in self.quantity_data:
+            value_setter = self.quantity_data[name].value_setter
+            if value_setter:
+                value_setter(value)
+            else:
+                from warnings import warn
+                warn(f"No value_setter defined for log quantity (name={name}).")
+
     def _insert_datapoint(self, name: str, value: Optional[float]) -> None:
         if value is None:
             return
@@ -849,12 +870,13 @@ def add_quantity(self, quantity: LogQuantity, interval: int = 1) -> None:
         :param interval: interval (in time steps) when to gather this quantity.
         """
 
-        def add_internal(name, unit, description, def_agg):
+        def add_internal(name, unit, description, def_agg, val_set=None):
             logger.debug("add log quantity '%s'" % name)
 
             if name in self.quantity_data:
                 raise RuntimeError("cannot add the same quantity '%s' twice" % name)
-            self.quantity_data[name] = _QuantityData(unit, description, def_agg)
+            self.quantity_data[name] = _QuantityData(unit, description, def_agg,
+                                                     val_set)
 
             from pickle import dumps
             self.db_conn.execute("""insert into quantities values (?,?,?,?)""", (
@@ -883,8 +905,9 @@ def add_internal(name, unit, description, def_agg):
                 add_internal(name, unit, description, def_agg)
         else:
             add_internal(quantity.name,
-                    quantity.unit, quantity.description,
-                    quantity.default_aggregator)
+                         quantity.unit, quantity.description,
+                         quantity.default_aggregator,
+                         quantity.set_quantity_value)
 
     def get_expr_dataset(self, expression, description=None, unit=None):
         """Prepare a time-series dataset for a given expression.