diff --git a/mlair/helpers/statistics.py b/mlair/helpers/statistics.py
index 1b1b9284f3d1f378974b8615136aeb6f2d79fb8d..65574f4c2641d811e31087a1c9bb61f5e9a2aa8f 100644
--- a/mlair/helpers/statistics.py
+++ b/mlair/helpers/statistics.py
@@ -267,7 +267,7 @@ class SkillScores:
 
         for iahead in ahead_names:
             data = internal_data.sel(ahead=iahead)
-            external_data = self.external_data.sel(ahead=iahead, type=self.observation_name)
+            external_data = self.external_data.sel(ahead=iahead, type=[self.observation_name])
 
             skill_score.loc[["CASE I", "AI", "BI", "CI"], iahead] = np.stack(self._climatological_skill_score(
                 data, mu_type=1, forecast_name=forecast_name, observation_name=self.observation_name).values.flatten())
@@ -286,9 +286,11 @@ class SkillScores:
 
         return skill_score
 
-    def _climatological_skill_score(self, data, observation_name, forecast_name, mu_type=1, external_data=None):
+    def _climatological_skill_score(self, internal_data, observation_name, forecast_name, mu_type=1,
+                                    external_data=None):
         kwargs = {"external_data": external_data} if external_data is not None else {}
-        return self.__getattribute__(f"skill_score_mu_case_{mu_type}")(data, observation_name, forecast_name, **kwargs)
+        return self.__getattribute__(f"skill_score_mu_case_{mu_type}")(internal_data, observation_name, forecast_name,
+                                                                       **kwargs)
 
     def general_skill_score(self, data: Data, forecast_name: str, reference_name: str,
                             observation_name: str = None) -> np.ndarray:
@@ -346,15 +348,15 @@ class SkillScores:
         suffix = {"mean": mean, "sigma": sigma, "r": r, "p": p}
         return AI, BI, CI, data, suffix
 
-    def skill_score_mu_case_1(self, data, observation_name, forecast_name):
+    def skill_score_mu_case_1(self, internal_data, observation_name, forecast_name):
         """Calculate CASE I."""
-        AI, BI, CI, data, _ = self.skill_score_pre_calculations(data, observation_name, forecast_name)
+        AI, BI, CI, data, _ = self.skill_score_pre_calculations(internal_data, observation_name, forecast_name)
         skill_score = np.array(AI - BI - CI)
         return pd.DataFrame({"skill_score": [skill_score], "AI": [AI], "BI": [BI], "CI": [CI]}).to_xarray().to_array()
 
-    def skill_score_mu_case_2(self, data, observation_name, forecast_name):
+    def skill_score_mu_case_2(self, internal_data, observation_name, forecast_name):
         """Calculate CASE II."""
-        AI, BI, CI, data, suffix = self.skill_score_pre_calculations(data, observation_name, forecast_name)
+        AI, BI, CI, data, suffix = self.skill_score_pre_calculations(internal_data, observation_name, forecast_name)
         monthly_mean = self.create_monthly_mean_from_daily_data(data)
         data = xr.concat([data, monthly_mean], dim="type")
         sigma = suffix["sigma"]
@@ -365,30 +367,25 @@ class SkillScores:
         skill_score = np.array((AI - BI - CI - AII + BII) / (1 - AII + BII))
         return pd.DataFrame({"skill_score": [skill_score], "AII": [AII], "BII": [BII]}).to_xarray().to_array()
 
-    def skill_score_mu_case_3(self, data, observation_name, forecast_name, external_data=None):
+    def skill_score_mu_case_3(self, internal_data, observation_name, forecast_name, external_data=None):
         """Calculate CASE III."""
-        AI, BI, CI, data, suffix = self.skill_score_pre_calculations(data, observation_name, forecast_name)
+        AI, BI, CI, data, suffix = self.skill_score_pre_calculations(internal_data, observation_name, forecast_name)
         mean, sigma = suffix["mean"], suffix["sigma"]
         AIII = (((external_data.mean().values - mean.sel(type=observation_name, drop=True)) / sigma.sel(
             type=observation_name, drop=True)) ** 2).values
         skill_score = np.array((AI - BI - CI + AIII) / (1 + AIII))
         return pd.DataFrame({"skill_score": [skill_score], "AIII": [AIII]}).to_xarray().to_array()
 
-    def skill_score_mu_case_4(self, data, observation_name, forecast_name, external_data=None):
+    def skill_score_mu_case_4(self, internal_data, observation_name, forecast_name, external_data=None):
         """Calculate CASE IV."""
-        AI, BI, CI, data, suffix = self.skill_score_pre_calculations(data, observation_name, forecast_name)
-        monthly_mean_external = self.create_monthly_mean_from_daily_data(external_data, columns=data.type.values)
-        # monthly_mean_external = self.create_monthly_mean_from_daily_data(external_data, columns=data.type.values,
-        #                                                                  index=data.index)
+        AI, BI, CI, data, suffix = self.skill_score_pre_calculations(internal_data, observation_name, forecast_name)
+        monthly_mean_external = self.create_monthly_mean_from_daily_data(external_data, index=data.index)
         data = xr.concat([data, monthly_mean_external], dim="type")
         mean, sigma = suffix["mean"], suffix["sigma"]
-        monthly_mean_external = self.create_monthly_mean_from_daily_data(external_data, columns=data.type.values)
         mean_external = monthly_mean_external.mean()
         sigma_external = np.sqrt(monthly_mean_external.var())
-
         r_mu, p_mu = stats.pearsonr(
             *[data.sel(type=n).values.flatten() for n in [observation_name, observation_name + "X"]])
-
         AIV = np.array(r_mu ** 2)
         BIV = ((r_mu - sigma_external / sigma.sel(type=observation_name, drop=True)) ** 2).values
         CIV = (((mean_external - mean.sel(type=observation_name, drop=True)) / sigma.sel(type=observation_name,
diff --git a/mlair/model_modules/model_class.py b/mlair/model_modules/model_class.py
index a603b466e4dab0dc30b6b6b22d10b6c27ee59767..756d1d1416a52bf180dc41dfadfb4aaf80d59bcd 100644
--- a/mlair/model_modules/model_class.py
+++ b/mlair/model_modules/model_class.py
@@ -748,7 +748,7 @@ class MyPaperModel(AbstractModelClass):
     def set_compile_options(self):
         self.optimizer = keras.optimizers.SGD(lr=self.initial_lr, momentum=0.9)
         self.compile_options = {"loss": [keras.losses.mean_squared_error, keras.losses.mean_squared_error],
-                                "metrics": ['mse', 'mea']}
+                                "metrics": ['mse', 'mae']}
 
 
 if __name__ == "__main__":