[projections] add a constraint to have physically plausible models for the fitted models.

projects/projected_snowfall/elevation_temporal_model_for_projections/ensemble_fit/independent_ensemble_fit.py

@@ -14,24 +14,23 @@ from projects.projected_snowfall.elevation_temporal_model_for_projections.ensemb
 class IndependentEnsembleFit(AbstractEnsembleFit):
     """For each gcm_rcm_couple, we create a OneFoldFit"""
 
-    def __init__(self, massif_names, gcm_rcm_couple_to_altitude_studies: Dict[Tuple[str, str], AltitudesStudies], models_classes,
-                 fit_method=MarginFitMethod.extremes_fevd_mle, temporal_covariate_for_fit=None, only_models_that_pass_goodness_of_fit_test=True,
-                 confidence_interval_based_on_delta_method=False):
-        super().__init__(massif_names, gcm_rcm_couple_to_altitude_studies, models_classes, fit_method, temporal_covariate_for_fit, only_models_that_pass_goodness_of_fit_test,
-                         confidence_interval_based_on_delta_method)
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
 
         # Set appropriate setting
         OneFoldFit.last_year = 2100
         OneFoldFit.nb_years = 95
         # Load a classical visualizer
         self.gcm_rcm_couple_to_visualizer = {}
-        for gcm_rcm_couple, studies in gcm_rcm_couple_to_altitude_studies.items():
+        for gcm_rcm_couple, studies in self.gcm_rcm_couple_to_altitude_studies.items():
+            print(gcm_rcm_couple)
             visualizer = AltitudesStudiesVisualizerForNonStationaryModels(studies, self.models_classes,
                                                                           False,
                                                                           self.massif_names, self.fit_method,
                                                                           self.temporal_covariate_for_fit,
                                                                           self.only_models_that_pass_goodness_of_fit_test,
-                                                                          self.confidence_interval_based_on_delta_method)
+                                                                          self.confidence_interval_based_on_delta_method,
+                                                                          self.remove_physically_implausible_models)
             self.gcm_rcm_couple_to_visualizer[gcm_rcm_couple] = visualizer
 
         # Assign max

projects/projected_snowfall/elevation_temporal_model_for_projections/main_elevation_temporal_for_projections_ensemble.py

@@ -44,17 +44,17 @@ def main():
     set_seed_for_test()
     AbstractExtractEurocodeReturnLevel.ALPHA_CONFIDENCE_INTERVAL_UNCERTAINTY = 0.2
 
-    fast = True
+    fast = False
     if fast is None:
         massif_names = None
-        gcm_rcm_couples = gcm_rcm_couples[:2]
+        gcm_rcm_couples = gcm_rcm_couples[1:2]
         AbstractExtractEurocodeReturnLevel.NB_BOOTSTRAP = 10
-        altitudes_list = altitudes_for_groups[2:3]
+        altitudes_list = altitudes_for_groups[:2]
     elif fast:
         AbstractExtractEurocodeReturnLevel.NB_BOOTSTRAP = 10
-        massif_names = ['Vanoise', 'Haute-Maurienne', 'Vercors'][:]
-        gcm_rcm_couples = gcm_rcm_couples[:2]
-        altitudes_list = altitudes_for_groups[1:2]
+        massif_names = None
+        gcm_rcm_couples = ('CNRM-CM5', 'CCLM4-8-17')
+        altitudes_list = altitudes_for_groups[:1]
     else:
         massif_names = None
         altitudes_list = altitudes_for_groups[:]
@@ -83,7 +83,8 @@ def main_loop(gcm_rcm_couples, altitudes_list, massif_names, study_classes, ense
             massif_names=massif_names,
             temporal_covariate_for_fit=temporal_covariate_for_fit,
             confidence_interval_based_on_delta_method=False,
-            display_only_model_that_pass_gof_test=False
+            display_only_model_that_pass_gof_test=False,
+            remove_physically_implausible_models=True,
         )
         visualizer.plot()
         del visualizer

test/test_projects/test_altitude_spatial/test_one_fold_fit.py

@@ -3,10 +3,13 @@ import unittest
 from extreme_data.meteo_france_data.adamont_data.adamont.adamont_snowfall import AdamontSnowfall
 from extreme_data.meteo_france_data.adamont_data.adamont_scenario import AdamontScenario
 from extreme_data.meteo_france_data.scm_models_data.safran.safran import SafranSnowfall1Day
+from extreme_fit.model.margin_model.linear_margin_model.temporal_linear_margin_models import StationaryTemporalModel
 from extreme_fit.model.margin_model.polynomial_margin_model.gev_altitudinal_models import StationaryAltitudinal
 from extreme_fit.model.margin_model.polynomial_margin_model.models_based_on_pariwise_analysis.gev_with_constant_shape_wrt_altitude import \
     AltitudinalShapeConstantTimeLocationLinear, AltitudinalShapeConstantTimeScaleLinear, \
     AltitudinalShapeConstantTimeLocScaleLinear
+from extreme_fit.model.margin_model.polynomial_margin_model.utils import \
+    ALTITUDINAL_GEV_MODELS_BASED_ON_POINTWISE_ANALYSIS
 from projects.altitude_spatial_model.altitudes_fit.altitudes_studies import AltitudesStudies
 from projects.altitude_spatial_model.altitudes_fit.one_fold_analysis.one_fold_fit import OneFoldFit
 from spatio_temporal_dataset.coordinates.temporal_coordinates.abstract_temporal_covariate_for_fit import \
@@ -14,7 +17,6 @@ from spatio_temporal_dataset.coordinates.temporal_coordinates.abstract_temporal_
 
 
 class TestOneFoldFit(unittest.TestCase):
-    pass
 
     def setUp(self) -> None:
         super().setUp()
@@ -35,7 +37,8 @@ class TestOneFoldFit(unittest.TestCase):
         for study_class in [SafranSnowfall1Day, AdamontSnowfall][:]:
             dataset = self.load_dataset(study_class)
             one_fold_fit = OneFoldFit(self.massif_name, dataset,
-                                      models_classes=self.model_classes, temporal_covariate_for_fit=None)
+                                      models_classes=self.model_classes, temporal_covariate_for_fit=None,
+                                      only_models_that_pass_goodness_of_fit_test=False)
             _ = one_fold_fit.best_estimator.margin_model
         self.assertTrue(True)
 
@@ -44,7 +47,8 @@ class TestOneFoldFit(unittest.TestCase):
             dataset = self.load_dataset(study_class)
             one_fold_fit = OneFoldFit(self.massif_name, dataset,
                                       models_classes=self.model_classes,
-                                      temporal_covariate_for_fit=TimeTemporalCovariate)
+                                      temporal_covariate_for_fit=TimeTemporalCovariate,
+                                      only_models_that_pass_goodness_of_fit_test=False)
             _ = one_fold_fit.best_estimator.margin_model
         self.assertTrue(True)
 
@@ -53,10 +57,24 @@ class TestOneFoldFit(unittest.TestCase):
             dataset = self.load_dataset(study_class, scenario=AdamontScenario.rcp85)
             one_fold_fit = OneFoldFit(self.massif_name, dataset,
                                       models_classes=self.model_classes,
-                                      temporal_covariate_for_fit=AnomalyTemperatureTemporalCovariate)
+                                      temporal_covariate_for_fit=AnomalyTemperatureTemporalCovariate,
+                                      only_models_that_pass_goodness_of_fit_test=False)
             _ = one_fold_fit.best_estimator.margin_model
         self.assertTrue(True)
 
+    def test_remove_physically_implausible_models(self):
+        self.massif_name = "Aravis"
+        self.altitudes = [600, 900]
+        self.model_classes = ALTITUDINAL_GEV_MODELS_BASED_ON_POINTWISE_ANALYSIS
+        dataset = self.load_dataset(AdamontSnowfall,
+                                    scenario=AdamontScenario.rcp85, gcm_rcm_couple=('CNRM-CM5', 'CCLM4-8-17'))
+        one_fold_fit = OneFoldFit(self.massif_name, dataset,
+                                  models_classes=self.model_classes,
+                                  temporal_covariate_for_fit=None,
+                                  only_models_that_pass_goodness_of_fit_test=False,
+                                  remove_physically_implausible_models=True)
+        self.assertFalse(one_fold_fit.has_at_least_one_valid_model)
+
 
 if __name__ == '__main__':
     unittest.main()