smashbox 1.0__py2.py3-none-any.whl

smashbox/init/multimodel_statistics.py

@@ -0,0 +1,405 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Tue Nov  4 13:23:42 2025
+
+@author: maxime
+"""
+
+from smashbox.stats import mystats
+import numpy as np
+
+
+class multimodel_statistics:
+    """
+    Class which handle computation of statistics for multi-model containers. Statistics for each model container must be calculated first. Mean, median, variance, min, max and the distribution of every scores of each model containers are computed.
+    """
+
+    def __init__(self, parent_class):
+        self._parent_class = parent_class
+        """_parent_class attribute stores the parent_class src.init.smashbox.SmashBox() 
+        to be able to access to the result of any model"""
+
+        self.multimodel_misfit_stats = _copy_stats_attr(mystats.misfit_results())
+        """Attribute misfit_stats_results stores the results of the multimodel statistics for the misfit."""
+
+        self.multimodel_quantile_stats = None
+        """Attribute quantile_stats_results store the results of the multimodel statistics for the spatial quantile"""
+
+        self.multimodel_spatial_stats = _copy_stats_attr(mystats.spatial_stats_results())
+        """Atrribute spatial_stats_results store the results of the multimodel statistics for the spatial results"""
+
+        self.multimodel_outlets_stats_sim = _copy_stats_attr(
+            mystats.outlets_stats_results()
+        )
+        """Atrribute outlets_stats store the resutls of the multimodel statistics for the  simulted outlets stats"""
+
+        self.multimodel_outlets_stats_obs = _copy_stats_attr(
+            mystats.outlets_stats_results()
+        )
+        """Atrribute outlets_stats store the resutls of the multimodel statistics for the  observed outlets stats"""
+
+    def _get_model_list(self):
+
+        model_list = list()
+
+        for key, attr in self._parent_class.__dict__.items():
+
+            if hasattr(attr, "mysmashmodel"):
+
+                current_model = getattr(self._parent_class, key)
+
+                if (
+                    current_model._myparam.param.bbox
+                    == self._parent_class.myparam.param.bbox
+                ):
+                    model_list.append(key)
+
+        return model_list
+
+    def compute_multimodel_statistics(self, model_list=None):
+        """
+        Compute the multimodel statistics: mean, median, variance, min, max and the distribution. These statistics
+        are computed over all models containers which contains statistics and match the bounding box in object myparam.
+
+        :param model_list: list of the model container, defaults to None
+        :type model_list: list, optional
+
+        """
+
+        if model_list is None:
+            model_list = self._get_model_list()
+
+        self.compute_multimodel_statistics_misfit()
+        self.compute_multimodel_statistics_outlets()
+        self.compute_multimodel_statistics_outlets(obs=False)
+        self.compute_multimodel_statistics_outlets(obs=True)
+        self.compute_multimodel_statistics_spatial()
+        self.compute_multimodel_statistics_quantile()
+
+    def compute_multimodel_statistics_misfit(self, model_list=None):
+        """
+        Compute the multimodel statistics for the misfit criteria.
+        """
+        if model_list is None:
+            model_list = self._get_model_list()
+
+        dict_results = {}
+        for model in model_list:
+            current_model = getattr(self._parent_class, model)
+
+            misfit_list = current_model.mystats.misfit_stats.results.__dict__
+
+            for misfit, results in misfit_list.items():
+
+                if results is None:
+
+                    results = (
+                        np.zeros(shape=(len(current_model.mymesh.mesh["code"]))) * np.nan
+                    )
+                    print(f"</> Warning misfit {misfit} is None for model {model}.")
+
+                if misfit in dict_results.keys():
+                    dict_results[misfit] = np.stack(
+                        (dict_results[misfit], np.array(results))
+                    )
+                else:
+                    dict_results.update({misfit: np.array(results)})
+
+        for key, values in dict_results.items():
+            stats = getattr(self.multimodel_misfit_stats, key)
+            stats._fill_stats_attributes(values)
+
+    def compute_multimodel_statistics_outlets(self, model_list=None, obs=False):
+        """
+        Compute the multimodel statistics for the outlets criteria.
+        """
+        if model_list is None:
+            model_list = self._get_model_list()
+
+        dict_results = {}
+        for model in model_list:
+            current_model = getattr(self._parent_class, model)
+
+            if obs is False:
+                misfit_list = current_model.mystats.outlets_stats.results_sim.__dict__
+            else:
+                misfit_list = current_model.mystats.outlets_stats.results_obs.__dict__
+
+            for misfit, results in misfit_list.items():
+
+                if results is None:
+
+                    results = (
+                        np.zeros(shape=(len(current_model.mymesh.mesh["code"]))) * np.nan
+                    )
+                    print(f"</> Warning misfit {misfit} is None for model {model}.")
+
+                if misfit in dict_results.keys():
+                    dict_results[misfit] = np.stack(
+                        (dict_results[misfit], np.array(results))
+                    )
+                else:
+                    dict_results.update({misfit: np.array(results)})
+
+        for key, values in dict_results.items():
+            if obs is False:
+                stats = getattr(self.multimodel_outlets_stats_sim, key)
+            else:
+                stats = getattr(self.multimodel_outlets_stats_obs, key)
+            stats._fill_stats_attributes(values)
+
+    def compute_multimodel_statistics_spatial(self, model_list=None):
+        """
+        Compute the multimodel statistics for the spatial statisctics.
+        """
+        if model_list is None:
+            model_list = self._get_model_list()
+
+        dict_results = {}
+        for model in model_list:
+            current_model = getattr(self._parent_class, model)
+
+            stats_list = current_model.mystats.spatial_stats.results.__dict__
+
+            for stats, results in stats_list.items():
+
+                if results is None:
+
+                    results = (
+                        np.zeros(
+                            shape=(
+                                (
+                                    current_model.mymesh.mesh["nrow"],
+                                    current_model.mymesh.mesh["ncol"],
+                                )
+                            )
+                        )
+                        * np.nan
+                    )
+                    print(f"</> Warning stats {stats} is None for model {model}.")
+
+                if stats in dict_results.keys():
+                    dict_results[stats] = np.stack(
+                        (dict_results[stats], np.array(results))
+                    )
+                else:
+                    dict_results.update({stats: np.array(results)})
+
+        for key, values in dict_results.items():
+            stats = getattr(self.multimodel_spatial_stats, key)
+            stats._fill_stats_attributes(values)
+
+    def compute_multimodel_statistics_quantile(self, model_list=None):
+        """
+        Compute the multimodel statistics for the quantile statistic.
+        """
+        if model_list is None:
+            model_list = self._get_model_list()
+
+        quantile_matrix_dict_results = {}
+        spatial_dict_results = {}
+        vector_dict_results = {}
+
+        self.multimodel_quantile_stats = None
+
+        for model in model_list:
+
+            current_model = getattr(self._parent_class, model)
+
+            if self.multimodel_quantile_stats is None:
+                self.multimodel_quantile_stats = _copy_quantile_attr(
+                    current_model.mystats.quantile_stats
+                )
+
+            all_quantile_results = current_model.mystats.quantile_stats.__dict__
+
+            quantile_matrix_results = dict(
+                filter(
+                    lambda key: not key[0].startswith("Quantile_"),
+                    all_quantile_results.items(),
+                )
+            )
+
+            quantile_xxh_results = dict(
+                filter(
+                    lambda key: key[0].startswith("Quantile_"),
+                    all_quantile_results.items(),
+                )
+            )
+
+            for key, quantile_matrix in quantile_matrix_results.items():
+
+                # if not key in quantile_matrix_dict_results.keys():
+                #     quantile_matrix_dict_results.update({key: {}})
+
+                if quantile_matrix is None:
+
+                    quantile_matrix = np.array([np.nan])
+                    print(f"</> Warning quantile attr {key} is None for model {model}.")
+
+                if key in quantile_matrix_dict_results.keys():
+                    quantile_matrix_dict_results[key] = np.concat(
+                        (
+                            quantile_matrix_dict_results[key],
+                            np.array(quantile_matrix)[np.newaxis, :],
+                        ),
+                        axis=0,
+                    )
+                else:
+                    quantile_matrix_dict_results.update(
+                        {key: np.array(quantile_matrix)[np.newaxis, :]}
+                    )
+
+            for key, quantile_xxh in quantile_xxh_results.items():
+
+                if not key in spatial_dict_results.keys():
+                    spatial_dict_results.update({key: {}})
+
+                if not key in vector_dict_results.keys():
+                    vector_dict_results.update({key: {}})
+
+                spatial_attr_list = [
+                    "Q_th",
+                    "maxima",
+                    "Umin",
+                    "Umax",
+                    "fit_shape",
+                    "fit_scale",
+                    "fit_loc",
+                ]
+
+                for attr in spatial_attr_list:
+
+                    results = getattr(quantile_xxh, attr)
+
+                    if results is None:
+
+                        results = (
+                            np.zeros(
+                                shape=(
+                                    (
+                                        current_model.mymesh.mesh["nrow"],
+                                        current_model.mymesh.mesh["ncol"],
+                                    )
+                                )
+                            )
+                            * np.nan
+                        )
+                        print(
+                            f"</> Warning quantile attr {attr} is None for model {model}."
+                        )
+
+                    if attr in spatial_dict_results[key].keys():
+                        spatial_dict_results[key][attr] = np.concat(
+                            (
+                                spatial_dict_results[key][attr],
+                                np.array(results)[np.newaxis, :],
+                            ),
+                            axis=0,
+                        )
+                    else:
+                        spatial_dict_results[key].update(
+                            {attr: np.array(results)[np.newaxis, :]}
+                        )
+
+                vector_attr = ["T", "T_emp", "nb_chunks", "chunk_size", "fit", "duration"]
+
+                for attr in vector_attr:
+
+                    results = getattr(quantile_xxh_results[key], attr)
+
+                    if results is None:
+
+                        results = np.array([np.nan])
+                        print(f"</> Warning attr {attr} is None for model {model}.")
+
+                    if isinstance(results, str | int | float):
+                        results = [results]
+
+                    if attr in vector_dict_results[key].keys():
+                        vector_dict_results[key][attr] = np.concat(
+                            (
+                                vector_dict_results[key][attr],
+                                np.array(results)[np.newaxis, :],
+                            ),
+                            axis=0,
+                        )
+                    else:
+                        vector_dict_results[key].update(
+                            {attr: np.array(results)[np.newaxis, :]}
+                        )
+
+        for key, values in quantile_matrix_dict_results.items():
+
+            if np.any(values != np.nan):
+                stats = getattr(self.multimodel_quantile_stats, key)
+                stats._fill_stats_attributes(values)
+
+        for key, quantile in quantile_xxh_results.items():
+
+            quantileXXh = getattr(self.multimodel_quantile_stats, key)
+
+            for var_name, values in spatial_dict_results[key].items():
+                stats = getattr(quantileXXh, var_name)
+                stats._fill_stats_attributes(values)
+
+            for var_name, values in vector_dict_results[key].items():
+                # stats = getattr(quantileXXh, var_name)
+                # stats = values
+                setattr(quantileXXh, var_name, values)
+
+
+class _copy_stats_attr:
+
+    def __init__(self, example_class):
+
+        for key in example_class.__dict__.keys():
+            setattr(self, key, _statistics())
+
+
+class _copy_quantile_attr:
+
+    def __init__(self, quantile_class):
+
+        for key in quantile_class.__dict__.keys():
+            if key.startswith("Quantile_"):
+                setattr(self, key, _copy_stats_attr(getattr(quantile_class, key)))
+            else:
+                setattr(self, key, _statistics())
+
+
+class _statistics:
+    """
+    Class statistics for every statistics used for the multimodel statistics: mean, median, variance, min, max and data (the distribution)
+    """
+
+    def __init__(self):
+
+        self.mean = None
+
+        self.median = None
+
+        self.variance = None
+
+        self.min = None
+
+        self.max = None
+
+        self.data = None
+
+    def _fill_stats_attributes(self, distrib):
+        self.mean = np.mean(distrib, axis=0)
+        self.median = np.median(distrib, axis=0)
+        self.variance = np.var(distrib, axis=0)
+        self.min = np.min(distrib, axis=0)
+        self.max = np.max(distrib, axis=0)
+        self.data = distrib
+
+    # def _fill_spatial_stats_attributes(self, matrix):
+    #     self.mean = np.mean(matrix, axis=0)
+    #     self.median = np.median(matrix, axis=0)
+    #     self.variance = np.var(matrix, axis=0)
+    #     self.min = np.min(matrix, axis=0)
+    #     self.max = np.max(matrix, axis=0)
+    #     self.data = matrix