New feature: eigenfunction subset

.gitignore

@@ -32,4 +32,6 @@ test_legolas
 *.egg*
 !/tests/regression_tests/answers/*.dat
 !/tests/regression_tests/answers/*.log
+!/tests/pylbo_tests/utility_files/*.dat
+!/tests/pylbo_tests/utility_files/*.log
 

post_processing/pylbo/automation/defaults.py

@@ -24,13 +24,16 @@
     "savelist": [
         ("write_matrices", bool),
         ("write_eigenfunctions", bool),
-        ("write_postprocessed", bool),
+        ("write_derived_eigenfunctions", bool),
         ("show_results", bool),
         ("basename_datfile", str),
         ("basename_logfile", str),
         ("output_folder", str),
         ("logging_level", (int, np.integer)),
         ("dry_run", bool),
+        ("write_eigenfunction_subset", bool),
+        ("eigenfunction_subset_center", complex),
+        ("eigenfunction_subset_radius", (int, np.integer, float)),
     ],
     "physicslist": [
         ("mhd_gamma", float),

post_processing/pylbo/data_containers.py

@@ -11,7 +11,7 @@
     read_matrix_A,
     read_ef_grid,
     read_eigenfunction,
-    read_postprocessed,
+    read_derived_eigenfunction,
 )
 from pylbo.utilities.logger import pylboLogger
 from pylbo.exceptions import MatricesNotPresent
@@ -90,11 +90,11 @@ def ef_names(self):
         pass
 
     @abstractmethod
-    def pp_written(self):
+    def derived_efs_written(self):
         pass
 
     @abstractmethod
-    def pp_names(self):
+    def derived_ef_names(self):
         pass
 
     @abstractmethod
@@ -254,29 +254,41 @@ def ef_grid(self):
             return None
 
     @property
-    def pp_written(self):
+    def ef_subset(self):
         """
-        Checks if post-processed quantities are present.
+        Checks if dataset contains a subset of the eigenfunctions
 
         Returns
         -------
-        pp_written : bool
-            If `True`, post-processed quantities are present in the datfile.
+        bool
+            `True` if subset present, `False` otherwise
         """
-        return self.header["postprocessed_written"]
+        return self.header["eigenfunction_subset_used"]
 
     @property
-    def pp_names(self):
+    def derived_efs_written(self):
         """
-        Retrieves the post-processed quantity names.
+        Checks if derived eigenfunctions are present.
 
         Returns
         -------
-        pp_names : numpy.ndarray
-            Array containing the names of the post-processed quantities as strings.
-            None if no post-processed quantities are present.
+        bool
+            If `True`, derived eigenfunctions are present in the datfile.
         """
-        return self.header.get("pp_names", None)
+        return self.header["derived_eigenfuncs_written"]
+
+    @property
+    def derived_ef_names(self):
+        """
+        Retrieves the derived eigenfunction names.
+
+        Returns
+        -------
+        numpy.ndarray
+            Array containing the names of the derived eigenfunctions as strings.
+            None if no derived eigenfunctions are present.
+        """
+        return self.header.get("derived_ef_names", None)
 
     @staticmethod
     def _get_values(array, which_values):
@@ -554,13 +566,14 @@ def get_eigenfunctions(self, ev_guesses=None, ev_idxs=None):
         with open(self.datfile, "rb") as istream:
             for dict_idx, ef_idx in enumerate(idxs):
                 efs = read_eigenfunction(istream, self.header, ef_idx)
-                efs.update({"eigenvalue": self.eigenvalues[ef_idx]})
+                if efs is not None:
+                    efs.update({"eigenvalue": self.eigenvalues[ef_idx]})
                 eigenfuncs[dict_idx] = efs
         return eigenfuncs
 
-    def get_postprocessed(self, ev_guesses=None, ev_idxs=None):
+    def get_derived_eigenfunctions(self, ev_guesses=None, ev_idxs=None):
         """
-        Returns the post-processed quantities based on given eigenvalue guesses or their
+        Returns the derived eigenfunctions based on given eigenvalue guesses or their
         indices. An array will be returned where every item is a dictionary, containing
         both the eigenvalue and its quantities. Either eigenvalue guesses or
         indices can be supplied, but not both.
@@ -574,31 +587,30 @@ def get_postprocessed(self, ev_guesses=None, ev_idxs=None):
 
         Returns
         -------
-        postprocessed : numpy.ndarray(dtype=dict, ndim=1)
-            Array containing the post-processed quantities and eigenvalues
+        numpy.ndarray(dtype=dict, ndim=1)
+            Array containing the derived eigenfunctions and eigenvalues
             corresponding to the supplied indices. Every index in this array
-            contains a dictionary with the post-processed quantities and
+            contains a dictionary with the derived eigenfunctions and
             corresponding eigenvalue. The keys of each dictionary are the
-            post-processed quantity names.
+            corresponding eigenfunction names.
         """
         if ev_guesses is not None and ev_idxs is not None:
-            raise ValueError(
-                "get_postprocessed: either provide guesses or indices but not both"
-            )
+            raise ValueError("either provide guesses or indices but not both")
         if ev_guesses is not None:
             idxs, _ = self.get_nearest_eigenvalues(ev_guesses)
         else:
             idxs = transform_to_numpy(ev_idxs)
             for idx in idxs:
                 if not isinstance(idx, (int, np.int64)):
-                    raise ValueError("get_postprocessed: ev_idxs should be integers")
-        postprocessed = np.array([{}] * len(idxs), dtype=dict)
+                    raise ValueError("ev_idxs should be integers")
+        derived_efs = np.array([{}] * len(idxs), dtype=dict)
         with open(self.datfile, "rb") as istream:
-            for dict_idx, pp_idx in enumerate(idxs):
-                ppq = read_postprocessed(istream, self.header, pp_idx)
-                ppq.update({"eigenvalue": self.eigenvalues[pp_idx]})
-                postprocessed[dict_idx] = ppq
-        return postprocessed
+            for dict_idx, ef_idx in enumerate(idxs):
+                defs = read_derived_eigenfunction(istream, self.header, ef_idx)
+                if defs is not None:
+                    defs.update({"eigenvalue": self.eigenvalues[ef_idx]})
+                derived_efs[dict_idx] = defs
+        return derived_efs
 
     def get_nearest_eigenvalues(self, ev_guesses):
         """
@@ -701,29 +713,29 @@ def ef_grid(self):
         return np.array([ds.ef_grid for ds in self.datasets], dtype=object)
 
     @property
-    def pp_written(self):
+    def derived_efs_written(self):
         """
-        Checks if the post-processed quantities are written.
+        Checks if the derived eigenfunctions are written.
 
         Returns
         -------
-        pp_written : numpy.ndarray
+        numpy.ndarray(dtype=bool)
             An array of bools corresponding to the various datasets, `True` if a
-            dataset has post-processed quantities present.
+            dataset has derived eigenfunctions present.
         """
-        return np.array([ds.pp_written for ds in self.datasets])
+        return np.array([ds.derived_efs_written for ds in self.datasets])
 
     @property
-    def pp_names(self):
+    def derived_ef_names(self):
         """
-        Returns the post-processed quantity names.
+        Returns the derived eigenfunction names.
 
         Returns
         -------
-        pp_names : numpy.ndarray
-            An array with the post-processed quantity names as strings.
+        numpy.ndarray(dtype=str)
+            An array with the derived eigenfunction names as strings.
         """
-        names = np.array([ds.pp_names for ds in self.datasets], dtype=object)
+        names = np.array([ds.derived_ef_names for ds in self.datasets], dtype=object)
         for item in names:
             if item is None:
                 continue

post_processing/pylbo/exceptions.py

@@ -47,24 +47,6 @@ def __str__(self):
         return f"{self.msg}"
 
 
-class PostprocessedNotPresent(LegolasException):
-    """
-    Handles trying to query for post-processed quantities when these
-    are not present in the datfile.
-
-    Parameters
-    ----------
-    msg : str
-        The error message to pass on.
-    """
-
-    def __init__(self, msg):
-        self.msg = msg
-
-    def __str__(self):
-        return f"{self.msg}"
-
-
 class MatricesNotPresent(LegolasException):
     """
     Handles trying to query for matrices when these

post_processing/pylbo/file_handler.py

@@ -65,8 +65,14 @@ def load(datfile):
         pylboLogger.info("matrices present in datfile")
     if ds.header["eigenfuncs_written"]:
         pylboLogger.info("eigenfunctions present in datfile")
-    if ds.header.get("postprocessed_written", False):
-        pylboLogger.info("post-processed quantities present in datfile")
+    if ds.header.get("derived_eigenfuncs_written", False):
+        pylboLogger.info("derived eigenfunctions present in datfile")
+    if ds.header.get("eigenfunction_subset_used", False):
+        saved_efs = len(ds.header["ef_written_idxs"])
+        total_efs = len(ds.eigenvalues)
+        pylboLogger.info(
+            f"subset saved: {saved_efs}/{total_efs} eigenvalues have eigenfunctions"
+        )
     pylboLogger.info("-" * 75)
     return ds
 
@@ -150,22 +156,18 @@ def load_series(datfiles):
         if efs_present.pop():
             pylboLogger.info("eigenfunctions present in all datfiles")
 
-    # check presence of post-processed quantities
-    pp_present = set(
-        [ds.header.get("postprocessed_written", False) for ds in series.datasets]
+    # check presence of derived eigenfunctions
+    defs_present = set(
+        [ds.header.get("derived_eigenfuncs_written", False) for ds in series.datasets]
     )
-    if len(pp_present) == 0:
-        pylboLogger.info("no post-processed quantities present")
-    elif len(pp_present) > 1:
-        pylboLogger.info(
-            "post-processed quantities present in some datfiles, but not all"
-        )
+    if len(defs_present) == 0:
+        pylboLogger.info("no derived eigenfunctions present")
+    elif len(defs_present) > 1:
+        pylboLogger.info("derived eigenfunctions present in some datfiles, but not all")
     else:
-        if pp_present.pop():
-            pylboLogger.info("post-processed quantities present in all datfiles")
-
+        if defs_present.pop():
+            pylboLogger.info("derived eigenfunctions present in all datfiles")
     pylboLogger.info("-" * 75)
-
     return series