Add possibility to launch an external rule

+ some plotter improvements
+ some namelist improvements
+ add datacube extraction

baseprocessor.py

@@ -14,19 +14,19 @@ from tables import HDF5ExtError
 from params import default_params, load_params
 from units import U
 
-
 class Rule:
     def __init__(
         self,
-        postproc,
         process,
         description="",
         group="",
         dependencies=[],
         kind="snapshot",
         unit=U.none,
+        name="",
+
     ):
-        self.postproc = postproc
+        self.name=name
         self.process_fn = process
         self.dependencies = dependencies
         self.group = group
@@ -39,8 +39,6 @@ class Rule:
             return self.process_fn(arg, **kwargs)
         else:
             return self.process_fn(**kwargs)
-
-
 class BaseProcessor:
     """
     Base class for processors, should not be instanciated
@@ -82,20 +80,39 @@ class BaseProcessor:
         arg=None,
         overwrite=False,
         overwrite_dep=False,
+        skip_dep=False,
         select=None,
         **kwargs,
-    ):
-        """
-        Process the rule `to_process`
-        """
-
+        ):
         self.overwrite_dep = overwrite_dep
         self.just_done = []
+        """ Process the rule 'to_process'
 
+        Parameters
+        ----------
+        to_process : str of Rule
+            name of the rule to process or Rule object with nonempty rule.name
+        arg : optional
+            argument to give to the rule
+        overwrite : bool, optional
+            Force redo if already done
+        overwrite_dep : bool, optional
+            Force redoing of the dependencies even if already done
+        skip_dep : bool, optional
+            Skip the dependency checks (assume they are already done)
+        select : dict, optional
+           Select object (see RunSelector) to only select some run/snapshot
+        """
+        
         if to_process in self.rules:
             rule = self.rules[to_process]
             return self._solve_and_process_rule(
-                to_process, rule, arg, overwrite, select, **kwargs
+                to_process, rule, arg, overwrite, skip_dep, select, **kwargs
+            )
+        elif isinstance(to_process, Rule):
+            rule = to_process
+            return self._solve_and_process_rule(
+                rule.name, rule, arg, overwrite, skip_dep, select, **kwargs
             )
         else:
             self._log(
@@ -106,9 +123,30 @@ class BaseProcessor:
             )
 
     def _solve_and_process_rule(
-        self, name, rule, arg, overwrite=False, select=None, **kwargs
+        self, name, rule, arg, overwrite=False, skip_dep=False, select=None, **kwargs
     ):
-        updated = self._solve_dependencies(name, rule, arg, overwrite, select)
+        """Resolve dependencies and proceed in the processing of a rule
+
+        Parameters
+        ----------
+        name : str
+            name of the rule
+        rule : Rule
+            rule object
+        overwrite : bool, optional
+            Force redo if already done
+        skip_dep : bool, optional
+            Skip the dependency checks (assume they are already done)
+        select : dict, optional
+        Select object (see RunSelector) to only select some run/snapshot
+
+        Returns
+        -------
+        The outbut of self._process_rule
+        """
+        updated  = False
+        if not skip_dep:
+            updated = self._solve_dependencies(name, rule, arg, overwrite, select)
         overwrite_rule = overwrite or updated
         return self._process_rule(name, rule, arg, overwrite_rule, select, **kwargs)
 
@@ -147,7 +185,7 @@ class BaseProcessor:
         return overwrite
 
     def _process_rule(self, name, rule, arg, overwrite=False, select=None, **kwargs):
-        if arg is not None:
+        if arg is not None and not isinstance(arg, BaseProcessor):
             name_full = rule.group + "/" + name + "_" + str(arg)
         else:
             name_full = rule.group + "/" + name
@@ -418,7 +456,6 @@ class HDF5Container(BaseProcessor):
         name = transform_name + "_" + rule_src_name
 
         self.rules[name] = Rule(
-            self,
             fn,
             group=group,
             unit=unit,
@@ -468,4 +505,7 @@ def oct_vect_getter(name, i, dset):
 
 
 def norm_getter(name, dset):
-    return np.sqrt(np.sum(dset[name] ** 2, axis=1))
+    return np.sqrt(np.sum(dset[name] ** 2, axis=1)) 
+
+def oct_norm_getter(name, dset):
+    return np.sqrt(np.sum(dset[name] ** 2, axis=2))