Merge pull request #69 from cseptesting/68-improve-report-module

Improved report module

Author: pabloitu

floatcsep/experiment.py

@@ -394,7 +394,6 @@ def set_tasks(self) -> None:
                     tstring=time_i,
                     models=self.models,
                 )
-                print("000")
                 task_graph.add(task=task_j)
 
         # Set up the Forecasts creation

floatcsep/infrastructure/repositories.py

@@ -205,29 +205,26 @@ def set_test_cats(self, tstring: str, fmt: str = "json") -> None:
         """
 
         test_cat_name = self.registry.get_test_catalog_key(tstring)
-        if not exists(test_cat_name):
-            log.debug(
-                f"[Catalogs] Filtering testing catalog and saving to "
-                f"{self.registry.rel(test_cat_name)}"
-            )
-            start, end = str2timewindow(tstring)
-            sub_cat = self.catalog.filter(
-                [
-                    f"origin_time < {end.timestamp() * 1000}",
-                    f"origin_time >= {start.timestamp() * 1000}",
-                    f"magnitude >= {self.mag_min}",
-                    f"magnitude < {self.mag_max}",
-                ],
-                in_place=False,
-            )
-            if self.region:
-                sub_cat.filter_spatial(region=self.region, in_place=True)
 
-            writer = getattr(CatalogSerializer, fmt)
-            writer(catalog=sub_cat, filename=test_cat_name)
+        log.debug(
+            f"[Catalogs] Filtering testing catalog and saving to "
+            f"{self.registry.rel(test_cat_name)}"
+        )
+        start, end = str2timewindow(tstring)
+        sub_cat = self.catalog.filter(
+            [
+                f"origin_time < {end.timestamp() * 1000}",
+                f"origin_time >= {start.timestamp() * 1000}",
+                f"magnitude >= {self.mag_min}",
+                f"magnitude < {self.mag_max}",
+            ],
+            in_place=False,
+        )
+        if self.region:
+            sub_cat.filter_spatial(region=self.region, in_place=True)
 
-        else:
-            log.debug(f"[Catalogs] Using test catalog from {self.registry.rel(test_cat_name)}")
+        writer = getattr(CatalogSerializer, fmt)
+        writer(catalog=sub_cat, filename=test_cat_name)
 
     def filter_catalog(
         self,
@@ -344,26 +341,28 @@ def __init__(self, registry: ModelFileRegistry, **kwargs):
     def load_forecast(
         self,
         tstring: Union[str, list],
+        name=None,
         region=None,
         n_sims=None,
     ) -> Union[CatalogForecast, list[CatalogForecast]]:
         """
         Returns a forecast object or a sequence of them for a set of time window strings.
 
         Args:
-            tstring (str, list): String representing the time-window
+            tstring (str, list): String representing the time-window.
+            name (str): Name of the forecast model.
             region (optional): A region, in case the forecast requires to be filtered lazily.
-            n_sims (optional: The number of simulations/synthetic catalogs of the forecast
+            n_sims (optional: The number of simulations/synthetic catalogs of the forecast.
 
         Returns:
             The CSEP CatalogForecast object or a list of them.
         """
         if isinstance(tstring, str):
-            return self._load_single_forecast(tstring, region=region, n_sims=n_sims)
+            return self._load_single_forecast(tstring, name=name, region=region, n_sims=n_sims)
         else:
             return [self._load_single_forecast(t, region) for t in tstring]
 
-    def _load_single_forecast(self, tstring: str, region=None, n_sims=None):
+    def _load_single_forecast(self, tstring: str, name=None, region=None, n_sims=None):
         start_date, end_date = str2timewindow(tstring)
 
         fc_path = self.registry.get_forecast_key(tstring)
@@ -372,6 +371,7 @@ def _load_single_forecast(self, tstring: str, region=None, n_sims=None):
 
         forecast_ = f_parser(
             fc_path,
+            name=name,
             start_time=start_date,
             end_time=end_date,
             n_cat=n_sims,

floatcsep/model.py

@@ -364,7 +364,7 @@ def get_forecast(
                 If None, will return a forecast for all regions.
 
         """
-        return self.repository.load_forecast(tstring, region=region)
+        return self.repository.load_forecast(tstring, name=self.name, region=region)
 
     def create_forecast(self, tstring: str, **kwargs) -> None:
         """

floatcsep/postprocess/plot_handler.py

@@ -85,29 +85,42 @@ def plot_forecasts(experiment: "Experiment") -> None:
     plot_forecast_config["projection"]: ccrs.Projection = parse_projection(
         plot_forecast_config.get("projection")
     )
+    plot_forecast_config["title"] = None
 
     for model in experiment.models:
         for window in time_windows:
             forecast = model.get_forecast(window, region=experiment.region)
             ax = forecast.plot(plot_args=plot_forecast_config)
 
-            # If catalog option is passed, catalog is plotted on top of the forecast
             if plot_forecast_config.get("catalog"):
                 cat_args = plot_forecast_config.get("catalog", {})
                 if cat_args is True:
                     cat_args = {}
-                experiment.catalog_repo.get_test_cat(window).plot(
+                overlay_args = {
+                    **cat_args,
+                    "basemap": plot_forecast_config.get("basemap", None),
+                }
+                ax = experiment.catalog_repo.get_test_cat(window).plot(
                     ax=ax,
                     extent=ax.get_extent(),
-                    plot_args=cat_args.update(
-                        {
-                            "basemap": plot_forecast_config.get("basemap", None),
-                            "title": ax.get_title(),
-                        }
-                    ),
+                    plot_args=overlay_args,
                 )
-            fig_path = experiment.registry.get_figure_key(window, "forecasts", model.name)
-            pyplot.savefig(fig_path, dpi=plot_forecast_config.get("dpi", 300))
+
+            fig = ax.get_figure()
+            fig.canvas.draw()
+
+            dpi = plot_forecast_config.get("dpi", 300)
+            png_path = (
+                experiment.registry.get_figure_key(window, "forecasts", model.name) + ".png"
+            )
+            fig.savefig(
+                png_path,
+                dpi=dpi,
+                bbox_inches="tight",
+                pad_inches=0.02,
+                facecolor="white",
+            )
+            pyplot.close(fig)
 
 
 def plot_catalogs(experiment: "Experiment") -> None:
@@ -171,33 +184,73 @@ def plot_catalogs(experiment: "Experiment") -> None:
     if test_catalog.get_number_of_events() == 0:
         log.debug(f"Catalog has zero events in {experiment_timewindow}")
         return
+    dpi = plot_catalog_config.get("dpi", 300)
 
     # Plot catalog map
     ax = test_catalog.plot(plot_args=plot_catalog_config)
+    fig = ax.get_figure()
+    fig.canvas.draw()
     cat_map_path = experiment.registry.get_figure_key("main_catalog_map")
-    ax.get_figure().savefig(cat_map_path, dpi=plot_catalog_config.get("dpi", 300))
+    fig.savefig(
+        cat_map_path,
+        dpi=dpi,
+        bbox_inches="tight",  # <— trim outer margins
+        pad_inches=0.02,  # <— tiny padding to avoid clipping
+        facecolor="white",
+    )
+    pyplot.close(fig)
 
     # Plot catalog time series vs. magnitude
     ax = magnitude_vs_time(test_catalog)
+    fig = ax.get_figure()
+    fig.canvas.draw()
     cat_time_path = experiment.registry.get_figure_key("main_catalog_time")
-    ax.get_figure().savefig(cat_time_path, dpi=plot_catalog_config.get("dpi", 300))
+    fig.savefig(
+        cat_time_path,
+        dpi=dpi,
+        bbox_inches="tight",
+        pad_inches=0.02,
+        facecolor="white",
+    )
+    pyplot.close(fig)
 
     # If selected, plot the test catalogs for each of the time windows
     if plot_catalog_config.get("all_time_windows"):
         for tw in experiment.time_windows:
-            test_catalog = experiment.catalog_repo.get_test_cat(timewindow2str(tw))
+            tw_str = timewindow2str(tw)
+            test_catalog = experiment.catalog_repo.get_test_cat(tw_str)
 
-            if test_catalog.get_number_of_events() != 0:
-                log.debug(f"Catalog has zero events in {tw}. Skip plotting")
+            if test_catalog.get_number_of_events() == 0:
+                log.debug(f"Catalog has zero events in {tw_str}. Skip plotting")
                 continue
 
+            # Map
             ax = test_catalog.plot(plot_args=plot_catalog_config)
-            cat_map_path = experiment.registry.get_figure_key(tw, "catalog_map")
-            ax.get_figure().savefig(cat_map_path, dpi=plot_catalog_config.get("dpi", 300))
+            fig = ax.get_figure()
+            fig.canvas.draw()
+            cat_map_path = experiment.registry.get_figure_key(tw_str, "catalog_map") + ".png"
+            fig.savefig(
+                cat_map_path,
+                dpi=dpi,
+                bbox_inches="tight",
+                pad_inches=0.02,
+                facecolor="white",
+            )
+            pyplot.close(fig)
 
+            # Time series
             ax = magnitude_vs_time(test_catalog)
-            cat_time_path = experiment.registry.get_figure_key(tw, "catalog_time")
-            ax.get_figure().savefig(cat_time_path, dpi=plot_catalog_config.get("dpi", 300))
+            fig = ax.get_figure()
+            fig.canvas.draw()
+            cat_time_path = experiment.registry.get_figure_key(tw_str, "catalog_time") + ".png"
+            fig.savefig(
+                cat_time_path,
+                dpi=dpi,
+                bbox_inches="tight",
+                pad_inches=0.02,
+                facecolor="white",
+            )
+            pyplot.close(fig)
 
 
 def plot_custom(experiment: "Experiment"):