update

comparator.py

@@ -122,10 +122,10 @@ class Comparator(Aggregator, HDF5Container):
     def _time_series(self, getter, arg=None):
         series = {}
         for run in self.runs:
-            series[run] = np.zeros(len(self.nums[run]))
+            series[run] = []
             for i, num in enumerate(self.nums[run]):
-                series[run][i] = getter(run, num, arg=arg)
-        return series
+                series[run].apend(getter(run, num, arg=arg))
+        return np.array(series)
 
     def _comp(self, getter, use_num=True):
         prop = np.zeros(len(self.runs))
@@ -137,9 +137,7 @@ class Comparator(Aggregator, HDF5Container):
                 prop[i] = getter(run)
         return prop
 
-    def _time_avg(
-        self, name, start=None, end=None, span=None, ergodic=False, group="/series"
-    ):
+    def _time_avg(self, name, start=None, end=None, span=None, group="/series"):
         mean = np.zeros(len(self.runs))
         median = np.zeros(len(self.runs))
         std = np.zeros(len(self.runs))
@@ -169,15 +167,11 @@ class Comparator(Aggregator, HDF5Container):
 
                 mask = mask & (time >= start_r) & (time <= end_r) & np.isfinite(serie)
 
-            mean[i] = np.mean(serie[mask])
-            std[i] = np.std(serie[mask])
+            mean[i] = np.mean(serie[mask], axis=0)
+            std[i] = np.std(serie[mask], axis=0)
             v_min[i], q025[i], median[i], q975[i], v_max[i] = np.percentile(
-                serie[mask], [0, 2.5, 50, 97.5, 100]
+                serie[mask], [0, 2.5, 50, 97.5, 100], axis=0
             )
-            if ergodic:  # If the process is ergodic ...
-                std[i] = std[i] / np.sqrt(len(serie[mask]))
-            else:
-                std[i] = std[i]
         return {
             "runs": self.runs,
             "mean": mean,
@@ -195,6 +189,12 @@ class Comparator(Aggregator, HDF5Container):
             node_name = node_name + "_" + str(arg)
         return pp.get_attribute(node_name, attr_name)
 
+    def get_pp_value(self, name, run, num, arg=None):
+        pp = self.pp[run][num]
+        if not arg is None:
+            name = name + "_" + str(arg)
+        return pp.get_value(name)
+
     def get_global(self, node_name, run, num, arg=None, unload_cells=False):
         if not arg is None:
             node_name = node_name + "_" + str(arg)
@@ -509,6 +509,14 @@ class Comparator(Aggregator, HDF5Container):
                 unit="unit_time",
                 dependencies=["time_num"],
             ),
+            "time_rho_prof": Rule(
+                self,
+                partial(
+                    self._time_series, partial(self.get_pp_value, "/profile/rho_prof")
+                ),
+                group="/series",
+                dependencies={"time": None, "rho_prof": "__parent__"},
+            ),
             "time_pdf_slope_coldens": Rule(
                 self,
                 partial(
@@ -535,7 +543,13 @@ class Comparator(Aggregator, HDF5Container):
         self._gen_rule_time_global("mwa_sigma", "time_sigma", unit="unit_velocity")
         self._gen_rule_time_global("max_fluct_coldens")
 
-        for name in ["issfr", "time_sigma", "time_pdf_slope_coldens", "turb_power"]:
+        for name in [
+            "issfr",
+            "time_sigma",
+            "time_pdf_slope_coldens",
+            "turb_power",
+            "time_rho_prof",
+        ]:
             self._gen_rule_avg(name)
 
         self._gen_rule_avg("sinks_from_log", "mass_sink")