From fea7e0a6a62d501c216fda4e40060dff1e0941f0 Mon Sep 17 00:00:00 2001 From: Jesper Sandvig Mariegaard <34088801+jsmariegaard@users.noreply.github.com> Date: Tue, 19 Dec 2023 21:11:57 +0100 Subject: [PATCH 01/29] optionally include attrs in to_dataframe and _attrs_keys_in_by --- modelskill/comparison/_collection.py | 47 ++++++++++++++++++++++------ 1 file changed, 37 insertions(+), 10 deletions(-) diff --git a/modelskill/comparison/_collection.py b/modelskill/comparison/_collection.py index 2c211a4ef..480f0178b 100644 --- a/modelskill/comparison/_collection.py +++ b/modelskill/comparison/_collection.py @@ -199,13 +199,14 @@ def metrics(self, values) -> None: else: options.metrics.list = _parse_metric(values, self.metrics) - def to_dataframe(self) -> pd.DataFrame: + def to_dataframe(self, attrs_keys=None) -> pd.DataFrame: """Return a copy of the data as a pandas DataFrame""" # TODO: var_name # TODO delegate to each comparer + attrs_keys = attrs_keys or [] res = _all_df_template(self.n_variables) frames = [] - cols = res.keys() + cols = list(res.keys()) + attrs_keys for cmp in self.comparers.values(): for j in range(cmp.n_models): mod_name = cmp.mod_names[j] @@ -219,9 +220,20 @@ def to_dataframe(self) -> pd.DataFrame: df["x"] = cmp.x df["y"] = cmp.y df["obs_val"] = cmp.obs + # if attrs_keys is not None: + for key in attrs_keys: + # assert ( + # key in cmp.data.attrs + # ), f"key {key} not in attrs, valid keys: {cmp.data.attrs.keys()}" + if key in cmp.data.attrs: + df[key] = cmp.data.attrs[key] + else: + df[key] = False frames.append(df[cols]) if len(frames) > 0: res = pd.concat(frames) + cat_cols = ["model", "observation"] + attrs_keys + res[cat_cols] = res[cat_cols].astype("category") res = res.sort_index() res.index.name = "time" return res @@ -488,7 +500,7 @@ def skill( observation, variable = _get_deprecated_obs_var_args(kwargs) assert kwargs == {}, f"Unknown keyword arguments: {kwargs}" - cmp = self.sel( + cc = self.sel( model=model, observation=observation, variable=variable, @@ -496,28 +508,43 @@ def skill( end=end, area=area, ) - if cmp.n_points == 0: + if cc.n_points == 0: raise ValueError("Dataset is empty, no data to compare.") ## ---- end of deprecated code ---- - df = cmp.to_dataframe() - n_models = cmp.n_models # len(df.model.unique()) - n_obs = cmp.n_observations # len(df.observation.unique()) + n_models = cc.n_models # len(df.model.unique()) + n_obs = cc.n_observations # len(df.observation.unique()) # TODO: FIX n_var = ( - cmp.n_variables + cc.n_variables ) # len(df.variable.unique()) if (self.n_variables > 1) else 1 by = _parse_groupby(by, n_models, n_obs, n_var) + by, attrs_keys = self._attrs_keys_in_by(by) + df = cc.to_dataframe(attrs_keys=attrs_keys) + res = _groupby_df(df, by, metrics) res["x"] = df.groupby(by=by, observed=False).x.first() res["y"] = df.groupby(by=by, observed=False).y.first() - # TODO: set x,y to NaN if TrackObservation - res = cmp._add_as_col_if_not_in_index(df, skilldf=res) + # TODO: set x,y to NaN if TrackObservation, x.nunique() > 1 + res = cc._add_as_col_if_not_in_index(df, skilldf=res) return SkillTable(res) + @staticmethod + def _attrs_keys_in_by(by): + """Check if 'attrs:' is in by and return attrs_keys""" + attrs_keys = [] + by = [by] if isinstance(by, str) else by + for j, b in enumerate(by): + if b.startswith("attrs:"): + key = b.split(":")[1] + attrs_keys.append(key) + by[j] = key # remove 'attrs:' prefix + attrs_keys = None if len(attrs_keys) == 0 else attrs_keys + return by, attrs_keys + def _add_as_col_if_not_in_index( self, df, skilldf, fields=["model", "observation", "variable"] ): From a46b24cb43fa0298c68b1bbaaf4b9b05f1829bc5 Mon Sep 17 00:00:00 2001 From: Jesper Sandvig Mariegaard <34088801+jsmariegaard@users.noreply.github.com> Date: Tue, 19 Dec 2023 21:54:51 +0100 Subject: [PATCH 02/29] rename to group and prepare for x, y --- modelskill/comparison/_utils.py | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/modelskill/comparison/_utils.py b/modelskill/comparison/_utils.py index b5e1b70d4..a5a57e83c 100644 --- a/modelskill/comparison/_utils.py +++ b/modelskill/comparison/_utils.py @@ -62,15 +62,15 @@ def _add_spatial_grid_to_df( def _groupby_df(df, by, metrics, n_min: Optional[int] = None): - def calc_metrics(x): + def calc_metrics(group): row = {} - row["n"] = len(x) + # row["x"] = group.x.first() if group.x.nunique() == 1 else np.nan + # row["y"] = group.y.first() if group.y.nunique() == 1 else np.nan + row["n"] = len(group) for metric in metrics: - row[metric.__name__] = metric(x.obs_val, x.mod_val) + row[metric.__name__] = metric(group.obs_val, group.mod_val) return pd.Series(row) - # .drop(columns=["x", "y"]) - res = df.groupby(by=by, observed=False).apply(calc_metrics) if n_min: From 22cb543ea3e089445439517451a60bd308007f81 Mon Sep 17 00:00:00 2001 From: Jesper Sandvig Mariegaard <34088801+jsmariegaard@users.noreply.github.com> Date: Tue, 19 Dec 2023 21:55:43 +0100 Subject: [PATCH 03/29] temporary disable astype(category) --- modelskill/comparison/_collection.py | 24 ++++++++++++------------ 1 file changed, 12 insertions(+), 12 deletions(-) diff --git a/modelskill/comparison/_collection.py b/modelskill/comparison/_collection.py index 480f0178b..71c75c8d3 100644 --- a/modelskill/comparison/_collection.py +++ b/modelskill/comparison/_collection.py @@ -232,9 +232,9 @@ def to_dataframe(self, attrs_keys=None) -> pd.DataFrame: frames.append(df[cols]) if len(frames) > 0: res = pd.concat(frames) - cat_cols = ["model", "observation"] + attrs_keys - res[cat_cols] = res[cat_cols].astype("category") - res = res.sort_index() + # cat_cols = res.select_dtypes(include=["object"]).columns + # res[cat_cols] = res[cat_cols].astype("category") # TODO + # res = res.sort_index() res.index.name = "time" return res @@ -805,7 +805,7 @@ def mean_skill( assert kwargs == {}, f"Unknown keyword arguments: {kwargs}" # filter data - cmp = self.sel( + cc = self.sel( model=model, # deprecated observation=observation, # deprecated variable=variable, # deprecated @@ -813,26 +813,26 @@ def mean_skill( end=end, # deprecated area=area, # deprecated ) - if cmp.n_points == 0: + if cc.n_points == 0: raise ValueError("Dataset is empty, no data to compare.") ## ---- end of deprecated code ---- - df = cmp.to_dataframe() - mod_names = cmp.mod_names # df.model.unique() + df = cc.to_dataframe() # TODO: remove + mod_names = cc.mod_names # df.model.unique() # obs_names = cmp.obs_names # df.observation.unique() - var_names = cmp.var_names # self.var_names + var_names = cc.var_names # self.var_names # skill assessment metrics = _parse_metric(metrics, self.metrics, return_list=True) # s = self.skill(df=df, metrics=metrics) - s = cmp.skill(metrics=metrics) + s = cc.skill(metrics=metrics) if s is None: return None skilldf = s.to_dataframe() # weights - weights = cmp._parse_weights(weights, s.obs_names) + weights = cc._parse_weights(weights, s.obs_names) skilldf["weights"] = ( skilldf.n if weights is None else np.tile(weights, len(mod_names)) # type: ignore ) @@ -841,7 +841,7 @@ def weighted_mean(x): return np.average(x, weights=skilldf.loc[x.index, "weights"]) # group by - by = cmp._mean_skill_by(skilldf, mod_names, var_names) + by = cc._mean_skill_by(skilldf, mod_names, var_names) agg = {"n": "sum"} for metric in metrics: # type: ignore agg[metric.__name__] = weighted_mean # type: ignore @@ -851,7 +851,7 @@ def weighted_mean(x): res.index.name = "model" # output - res = cmp._add_as_col_if_not_in_index(df, res, fields=["model", "variable"]) + res = cc._add_as_col_if_not_in_index(df, res, fields=["model", "variable"]) return SkillTable(res.astype({"n": int})) # def mean_skill_points( From a42b5a005d54123f14f7af1a05cad850de908136 Mon Sep 17 00:00:00 2001 From: Jesper Sandvig Mariegaard <34088801+jsmariegaard@users.noreply.github.com> Date: Tue, 19 Dec 2023 22:06:11 +0100 Subject: [PATCH 04/29] only if str --- modelskill/comparison/_collection.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/modelskill/comparison/_collection.py b/modelskill/comparison/_collection.py index 71c75c8d3..6e6d0fa61 100644 --- a/modelskill/comparison/_collection.py +++ b/modelskill/comparison/_collection.py @@ -538,7 +538,7 @@ def _attrs_keys_in_by(by): attrs_keys = [] by = [by] if isinstance(by, str) else by for j, b in enumerate(by): - if b.startswith("attrs:"): + if isinstance(b, str) and b.startswith("attrs:"): key = b.split(":")[1] attrs_keys.append(key) by[j] = key # remove 'attrs:' prefix From c464769dae951876e79f7bc133aac7ecebc2ddd0 Mon Sep 17 00:00:00 2001 From: Jesper Sandvig Mariegaard <34088801+jsmariegaard@users.noreply.github.com> Date: Tue, 19 Dec 2023 22:52:11 +0100 Subject: [PATCH 05/29] =?UTF-8?q?reintroduce=20astype("category")=20and=20?= =?UTF-8?q?remove=20resulting=20empty=20groups=20=F0=9F=A4=94?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- modelskill/comparison/_collection.py | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-) diff --git a/modelskill/comparison/_collection.py b/modelskill/comparison/_collection.py index 6e6d0fa61..34b7b492c 100644 --- a/modelskill/comparison/_collection.py +++ b/modelskill/comparison/_collection.py @@ -232,8 +232,8 @@ def to_dataframe(self, attrs_keys=None) -> pd.DataFrame: frames.append(df[cols]) if len(frames) > 0: res = pd.concat(frames) - # cat_cols = res.select_dtypes(include=["object"]).columns - # res[cat_cols] = res[cat_cols].astype("category") # TODO + cat_cols = res.select_dtypes(include=["object"]).columns + res[cat_cols] = res[cat_cols].astype("category") # TODO # res = res.sort_index() res.index.name = "time" return res @@ -457,6 +457,9 @@ def skill( group by column name or by temporal bin via the freq-argument (using pandas pd.Grouper(freq)), e.g.: 'freq:M' = monthly; 'freq:D' daily + or by attributes, stored in the cc.data.attrs container, + e.g.: 'attrs:obs_provider' = group by observation provider or + 'attrs:gtype' = group by geometry type (track or point) by default ["model","observation"] metrics : list, optional list of modelskill.metrics, by default modelskill.options.metrics.list @@ -526,6 +529,8 @@ def skill( df = cc.to_dataframe(attrs_keys=attrs_keys) res = _groupby_df(df, by, metrics) + mtr_cols = [m.__name__ for m in metrics] + res = res.dropna(subset=mtr_cols, how="all") # TODO: ok to remove empty? res["x"] = df.groupby(by=by, observed=False).x.first() res["y"] = df.groupby(by=by, observed=False).y.first() # TODO: set x,y to NaN if TrackObservation, x.nunique() > 1 From b093f9662a2a66562e4bbf6c4aef178ae6748857 Mon Sep 17 00:00:00 2001 From: Jesper Sandvig Mariegaard <34088801+jsmariegaard@users.noreply.github.com> Date: Tue, 19 Dec 2023 22:58:42 +0100 Subject: [PATCH 06/29] type: ignore --- modelskill/comparison/_collection.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/modelskill/comparison/_collection.py b/modelskill/comparison/_collection.py index 34b7b492c..a9c5d74bd 100644 --- a/modelskill/comparison/_collection.py +++ b/modelskill/comparison/_collection.py @@ -529,7 +529,7 @@ def skill( df = cc.to_dataframe(attrs_keys=attrs_keys) res = _groupby_df(df, by, metrics) - mtr_cols = [m.__name__ for m in metrics] + mtr_cols = [m.__name__ for m in metrics] # type: ignore res = res.dropna(subset=mtr_cols, how="all") # TODO: ok to remove empty? res["x"] = df.groupby(by=by, observed=False).x.first() res["y"] = df.groupby(by=by, observed=False).y.first() From 3b874ad1237177faf2a4172a099f417cecff5dc4 Mon Sep 17 00:00:00 2001 From: Henrik Andersson Date: Thu, 21 Dec 2023 15:17:23 +0100 Subject: [PATCH 07/29] Add option to include observeed categories --- modelskill/comparison/_collection.py | 8 ++++++-- modelskill/comparison/_utils.py | 2 +- 2 files changed, 7 insertions(+), 3 deletions(-) diff --git a/modelskill/comparison/_collection.py b/modelskill/comparison/_collection.py index a9c5d74bd..18ab46aad 100644 --- a/modelskill/comparison/_collection.py +++ b/modelskill/comparison/_collection.py @@ -199,7 +199,7 @@ def metrics(self, values) -> None: else: options.metrics.list = _parse_metric(values, self.metrics) - def to_dataframe(self, attrs_keys=None) -> pd.DataFrame: + def to_dataframe(self, attrs_keys=None, observed=False) -> pd.DataFrame: """Return a copy of the data as a pandas DataFrame""" # TODO: var_name # TODO delegate to each comparer @@ -234,6 +234,9 @@ def to_dataframe(self, attrs_keys=None) -> pd.DataFrame: res = pd.concat(frames) cat_cols = res.select_dtypes(include=["object"]).columns res[cat_cols] = res[cat_cols].astype("category") # TODO + + if not observed: + res = res.loc[~(res == False).any(axis=1)] # res = res.sort_index() res.index.name = "time" return res @@ -447,6 +450,7 @@ def skill( self, by: Optional[Union[str, List[str]]] = None, metrics: Optional[List[str]] = None, + observed=False, **kwargs, ) -> SkillTable: """Aggregated skill assessment of model(s) @@ -526,7 +530,7 @@ def skill( by = _parse_groupby(by, n_models, n_obs, n_var) by, attrs_keys = self._attrs_keys_in_by(by) - df = cc.to_dataframe(attrs_keys=attrs_keys) + df = cc.to_dataframe(attrs_keys=attrs_keys, observed=observed) res = _groupby_df(df, by, metrics) mtr_cols = [m.__name__ for m in metrics] # type: ignore diff --git a/modelskill/comparison/_utils.py b/modelskill/comparison/_utils.py index a5a57e83c..d1b1b53a0 100644 --- a/modelskill/comparison/_utils.py +++ b/modelskill/comparison/_utils.py @@ -71,7 +71,7 @@ def calc_metrics(group): row[metric.__name__] = metric(group.obs_val, group.mod_val) return pd.Series(row) - res = df.groupby(by=by, observed=False).apply(calc_metrics) + res = df.groupby(by=by, observed=True).apply(calc_metrics) if n_min: # nan for all cols but n From fec47bf7be07e482a3c7be48d8213e46a8d5d2fa Mon Sep 17 00:00:00 2001 From: Henrik Andersson Date: Thu, 21 Dec 2023 15:27:11 +0100 Subject: [PATCH 08/29] boolean logic backwards --- modelskill/comparison/_collection.py | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/modelskill/comparison/_collection.py b/modelskill/comparison/_collection.py index 18ab46aad..c995ea771 100644 --- a/modelskill/comparison/_collection.py +++ b/modelskill/comparison/_collection.py @@ -235,7 +235,7 @@ def to_dataframe(self, attrs_keys=None, observed=False) -> pd.DataFrame: cat_cols = res.select_dtypes(include=["object"]).columns res[cat_cols] = res[cat_cols].astype("category") # TODO - if not observed: + if observed: res = res.loc[~(res == False).any(axis=1)] # res = res.sort_index() res.index.name = "time" @@ -450,7 +450,7 @@ def skill( self, by: Optional[Union[str, List[str]]] = None, metrics: Optional[List[str]] = None, - observed=False, + observed=True, **kwargs, ) -> SkillTable: """Aggregated skill assessment of model(s) @@ -467,6 +467,8 @@ def skill( by default ["model","observation"] metrics : list, optional list of modelskill.metrics, by default modelskill.options.metrics.list + observed: bool, optional + This only applies if any of the groupers are Categoricals. If True: only show observed values for categorical groupers. If False: show all values for categorical groupers. Returns ------- From 37c47f7025df82fc71134721976cca4dbb7eaf5f Mon Sep 17 00:00:00 2001 From: Henrik Andersson Date: Thu, 21 Dec 2023 16:37:04 +0100 Subject: [PATCH 09/29] Ignore ruff --- modelskill/comparison/_collection.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/modelskill/comparison/_collection.py b/modelskill/comparison/_collection.py index 18ab46aad..3902a35a2 100644 --- a/modelskill/comparison/_collection.py +++ b/modelskill/comparison/_collection.py @@ -236,7 +236,7 @@ def to_dataframe(self, attrs_keys=None, observed=False) -> pd.DataFrame: res[cat_cols] = res[cat_cols].astype("category") # TODO if not observed: - res = res.loc[~(res == False).any(axis=1)] + res = res.loc[~(res == False).any(axis=1)] # noqa # res = res.sort_index() res.index.name = "time" return res From ee3e029372de97fa0b8edc6d88457be17e7221b7 Mon Sep 17 00:00:00 2001 From: Jesper Sandvig Mariegaard <34088801+jsmariegaard@users.noreply.github.com> Date: Thu, 21 Dec 2023 23:15:24 +0100 Subject: [PATCH 10/29] reverse observed --- modelskill/comparison/_collection.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/modelskill/comparison/_collection.py b/modelskill/comparison/_collection.py index 410973550..0950db186 100644 --- a/modelskill/comparison/_collection.py +++ b/modelskill/comparison/_collection.py @@ -239,7 +239,7 @@ def to_dataframe(self, attrs_keys=None, observed=False) -> pd.DataFrame: cat_cols = res.select_dtypes(include=["object"]).columns res[cat_cols] = res[cat_cols].astype("category") # TODO - if not observed: + if observed: res = res.loc[~(res == False).any(axis=1)] # noqa # res = res.sort_index() res.index.name = "time" From 581690d9ab2b36ae776ce3aebaaf52c434fc6aa7 Mon Sep 17 00:00:00 2001 From: Jesper Sandvig Mariegaard <34088801+jsmariegaard@users.noreply.github.com> Date: Wed, 3 Jan 2024 17:16:02 +0100 Subject: [PATCH 11/29] test_skill_by_attrs_gtype and test_skill_by_attrs_gtype_and_mod --- tests/test_comparercollection.py | 20 ++++++++++++++++++++ 1 file changed, 20 insertions(+) diff --git a/tests/test_comparercollection.py b/tests/test_comparercollection.py index 18c4bd423..1c456f619 100644 --- a/tests/test_comparercollection.py +++ b/tests/test_comparercollection.py @@ -291,6 +291,26 @@ def test_filter_by_attrs_custom(cc): assert cc3[0] == cc[0] +def test_skill_by_attrs_gtype(cc): + sk = cc.skill(by="attrs:gtype") + assert len(sk) == 2 + assert sk.data.index[0] == "point" + assert sk.data.index[1] == "track" + assert sk.data.index.name == "gtype" + + +def test_skill_by_attrs_gtype_and_mod(cc): + sk = cc.skill(by=["attrs:gtype", "model"]) + assert len(sk) == 5 + assert sk.data.index[0] == ("point", "m1") + assert sk.data.index[1] == ("point", "m2") + assert sk.data.index[2] == ("track", "m1") + assert sk.data.index[3] == ("track", "m2") + assert sk.data.index[4] == ("track", "m3") + assert sk.data.index.names[0] == "gtype" + assert sk.data.index.names[1] == "model" + + # ======================== load/save ======================== From ee1fff152c913ea15c260bdd20622395f40a980b Mon Sep 17 00:00:00 2001 From: Jesper Sandvig Mariegaard <34088801+jsmariegaard@users.noreply.github.com> Date: Wed, 3 Jan 2024 17:43:29 +0100 Subject: [PATCH 12/29] docstring --- modelskill/comparison/_collection.py | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/modelskill/comparison/_collection.py b/modelskill/comparison/_collection.py index e370887e2..16703d7f5 100644 --- a/modelskill/comparison/_collection.py +++ b/modelskill/comparison/_collection.py @@ -511,7 +511,10 @@ def skill( metrics : list, optional list of modelskill.metrics, by default modelskill.options.metrics.list observed: bool, optional - This only applies if any of the groupers are Categoricals. If True: only show observed values for categorical groupers. If False: show all values for categorical groupers. + This only applies if any of the groupers are Categoricals. + + - True: only show observed values for categorical groupers. + - False: show all values for categorical groupers. Returns ------- @@ -570,7 +573,7 @@ def skill( # TODO: FIX # len(df.variable.unique()) if (self.n_variables > 1) else 1 - n_var = cc.n_quantities + n_var = cc.n_quantities by = _parse_groupby(by, n_models, n_obs, n_var) by, attrs_keys = self._attrs_keys_in_by(by) assert isinstance(by, list) From 1411245b71b269cd7af731030e5e324adb832f65 Mon Sep 17 00:00:00 2001 From: Jesper Sandvig Mariegaard <34088801+jsmariegaard@users.noreply.github.com> Date: Wed, 3 Jan 2024 17:45:29 +0100 Subject: [PATCH 13/29] test_skill_by_attrs_int, test_skill_by_attrs_observed --- tests/test_comparercollection.py | 37 ++++++++++++++++++++++++++++++++ 1 file changed, 37 insertions(+) diff --git a/tests/test_comparercollection.py b/tests/test_comparercollection.py index 1c456f619..8e64a54aa 100644 --- a/tests/test_comparercollection.py +++ b/tests/test_comparercollection.py @@ -310,6 +310,43 @@ def test_skill_by_attrs_gtype_and_mod(cc): assert sk.data.index.names[0] == "gtype" assert sk.data.index.names[1] == "model" + # TODO: observed=True doesn't work on model + # sk2 = cc.skill(by=["attrs:gtype", "model"], observed=True) + # assert len(sk2) == 6 + # assert sk.data.index[0] == ("point", "m1") + # assert sk.data.index[1] == ("point", "m2") + # assert sk.data.index[2] == ("point", "m3") + + +def test_skill_by_attrs_int(cc): + cc[0].data.attrs["custom"] = 12 + cc[1].data.attrs["custom"] = 13 + + sk = cc.skill(by="attrs:custom") + assert len(sk) == 2 + assert sk.data.index[0] == 12 + assert sk.data.index[1] == 13 + assert sk.data.index.name == "custom" + + sk = cc.skill(by=("attrs:custom", "model")) + assert len(sk) == 5 + assert sk.data.index[4] == (13, "m3") + + +def test_skill_by_attrs_observed(cc): + cc[0].data.attrs["use"] = "DA" # point + + sk = cc.skill(by="attrs:use") # observed=False is default + assert len(sk) == 2 + assert sk.data.index[0] is False # note sorted by df.groupby ! + assert sk.data.index[1] == "DA" + assert sk.data.index.name == "use" + + sk = cc.skill(by="attrs:use", observed=True) + assert len(sk) == 1 + assert sk.data.index[0] == "DA" + assert sk.data.index.name == "use" + # ======================== load/save ======================== From af27dbeaac479f73ffa8f4d5e1fdda8f522e7d3f Mon Sep 17 00:00:00 2001 From: Jesper Sandvig Mariegaard <34088801+jsmariegaard@users.noreply.github.com> Date: Wed, 3 Jan 2024 17:47:18 +0100 Subject: [PATCH 14/29] TODO on sort=False --- modelskill/comparison/_utils.py | 1 + 1 file changed, 1 insertion(+) diff --git a/modelskill/comparison/_utils.py b/modelskill/comparison/_utils.py index 50651b201..425e9388b 100644 --- a/modelskill/comparison/_utils.py +++ b/modelskill/comparison/_utils.py @@ -62,6 +62,7 @@ def calc_metrics(group): if _dt_in_by(by): df, by = _add_dt_to_df(df, by) + # sort=False to avoid re-ordering compared to original cc (also for performance) res = df.groupby(by=by, observed=False).apply(calc_metrics) if n_min: From da3669b0c1fe41285ba3d130b9195030fac6bc13 Mon Sep 17 00:00:00 2001 From: Jesper Sandvig Mariegaard <34088801+jsmariegaard@users.noreply.github.com> Date: Thu, 4 Jan 2024 06:24:28 +0100 Subject: [PATCH 15/29] observed=False --- modelskill/comparison/_collection.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/modelskill/comparison/_collection.py b/modelskill/comparison/_collection.py index d7707da65..2e34051f3 100644 --- a/modelskill/comparison/_collection.py +++ b/modelskill/comparison/_collection.py @@ -907,7 +907,7 @@ def weighted_mean(x): agg = {"n": "sum"} for metric in pmetrics: # type: ignore agg[metric.__name__] = weighted_mean # type: ignore - res = skilldf.groupby(by).agg(agg) + res = skilldf.groupby(by, observed=False).agg(agg) # TODO is this correct? res.index.name = "model" From 354a52ea266f9c03080e39a5dd16012d2bfd0413 Mon Sep 17 00:00:00 2001 From: Jesper Sandvig Mariegaard <34088801+jsmariegaard@users.noreply.github.com> Date: Thu, 4 Jan 2024 07:08:35 +0100 Subject: [PATCH 16/29] mod_idx --- modelskill/comparison/_collection_plotter.py | 4 ++-- modelskill/comparison/_comparer_plotter.py | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/modelskill/comparison/_collection_plotter.py b/modelskill/comparison/_collection_plotter.py index cc50b3eb7..6de961ed1 100644 --- a/modelskill/comparison/_collection_plotter.py +++ b/modelskill/comparison/_collection_plotter.py @@ -413,7 +413,7 @@ def _hist_one_model( assert ( mod_name in self.cc.mod_names ), f"Model {mod_name} not found in collection" - mod_id = _get_idx(mod_name, self.cc.mod_names) + mod_idx = _get_idx(mod_name, self.cc.mod_names) title = ( _default_univarate_title("Histogram", self.cc) if title is None else title @@ -423,7 +423,7 @@ def _hist_one_model( df = cmp.to_dataframe() kwargs["alpha"] = alpha kwargs["density"] = density - df.mod_val.hist(bins=bins, color=MOD_COLORS[mod_id], ax=ax, **kwargs) + df.mod_val.hist(bins=bins, color=MOD_COLORS[mod_idx], ax=ax, **kwargs) df.obs_val.hist( bins=bins, color=self.cc[0].data["Observation"].attrs["color"], diff --git a/modelskill/comparison/_comparer_plotter.py b/modelskill/comparison/_comparer_plotter.py index 2736d576a..83c7f2082 100644 --- a/modelskill/comparison/_comparer_plotter.py +++ b/modelskill/comparison/_comparer_plotter.py @@ -220,7 +220,7 @@ def _hist_one_model( cmp = self.comparer assert mod_name in cmp.mod_names, f"Model {mod_name} not found in comparer" - mod_id = _get_idx(mod_name, cmp.mod_names) + mod_idx = _get_idx(mod_name, cmp.mod_names) title = f"{mod_name} vs {cmp.name}" if title is None else title @@ -233,7 +233,7 @@ def _hist_one_model( ax = ( cmp.data[mod_name] .to_series() - .hist(bins=bins, color=MOD_COLORS[mod_id], **kwargs) + .hist(bins=bins, color=MOD_COLORS[mod_idx], **kwargs) ) cmp.data[cmp._obs_name].to_series().hist( From e93bba1f1cecff50e2fc0c3dc031bbf647f35294 Mon Sep 17 00:00:00 2001 From: Jesper Sandvig Mariegaard <34088801+jsmariegaard@users.noreply.github.com> Date: Thu, 4 Jan 2024 07:08:59 +0100 Subject: [PATCH 17/29] docstrings and variable naming --- modelskill/comparison/_collection.py | 19 +++++++++---------- 1 file changed, 9 insertions(+), 10 deletions(-) diff --git a/modelskill/comparison/_collection.py b/modelskill/comparison/_collection.py index 2e34051f3..5437b3e46 100644 --- a/modelskill/comparison/_collection.py +++ b/modelskill/comparison/_collection.py @@ -56,7 +56,7 @@ def _get_deprecated_obs_var_args(kwargs): if variable is not None: warnings.warn( - f"The 'variable' argument is deprecated, use 'sel(variable='{variable}') instead", + f"The 'variable' argument is deprecated, use 'sel(quantity='{variable}') instead", FutureWarning, ) @@ -81,7 +81,8 @@ def _all_df_template(n_quantities: int = 1): class ComparerCollection(Mapping, Scoreable): """ - Collection of comparers, constructed by calling the `modelskill.match` method. + Collection of comparers, constructed by calling the `modelskill.match` + method. Can be indexed by name or index. Examples -------- @@ -94,8 +95,6 @@ class ComparerCollection(Mapping, Scoreable): plotter = ComparerCollectionPlotter - """Collection of Comparers, indexed by name""" - def __init__(self, comparers: Iterable[Comparer]) -> None: self._comparers: Dict[str, Comparer] = {} self._insert_comparers(comparers) @@ -125,7 +124,6 @@ def _unit_text(self) -> str: @property def n_comparers(self) -> int: - """Number of comparers""" warnings.warn( "cc.n_comparers is deprecated, use len(cc) instead", FutureWarning, @@ -176,7 +174,7 @@ def obs_names(self) -> List[str]: @property def n_observations(self) -> int: - """Number of observations""" + """Number of observations (same as len(cc))""" return len(self) @property @@ -207,6 +205,7 @@ def quantity_names(self) -> List[str]: @property def n_quantities(self) -> int: + """Number of unique quantities""" return len(self.quantity_names) def to_dataframe(self, attrs_keys=None, observed=False) -> pd.DataFrame: @@ -774,12 +773,12 @@ def scatter( observation, variable = _get_deprecated_obs_var_args(kwargs) # select model - mod_id = _get_idx(model, self.mod_names) - mod_name = self.mod_names[mod_id] + mod_idx = _get_idx(model, self.mod_names) + mod_name = self.mod_names[mod_idx] # select variable - qnt_id = _get_idx(variable, self.quantity_names) - qnt_name = self.quantity_names[qnt_id] + qnt_idx = _get_idx(variable, self.quantity_names) + qnt_name = self.quantity_names[qnt_idx] # filter data cmp = self.sel( From 3506819f4f9a1c05aed8be30b5af0591c4021f15 Mon Sep 17 00:00:00 2001 From: Jesper Sandvig Mariegaard <34088801+jsmariegaard@users.noreply.github.com> Date: Thu, 4 Jan 2024 07:53:42 +0100 Subject: [PATCH 18/29] improved docstrings including consistent kwargs --- modelskill/comparison/_collection_plotter.py | 5 +++-- modelskill/comparison/_comparer_plotter.py | 23 ++++++++++++++------ modelskill/comparison/_comparison.py | 13 +++++++++++ modelskill/skill.py | 8 +++---- modelskill/skill_grid.py | 3 ++- modelskill/timeseries/_plotter.py | 9 +++++--- 6 files changed, 44 insertions(+), 17 deletions(-) diff --git a/modelskill/comparison/_collection_plotter.py b/modelskill/comparison/_collection_plotter.py index 6de961ed1..a9cff2600 100644 --- a/modelskill/comparison/_collection_plotter.py +++ b/modelskill/comparison/_collection_plotter.py @@ -112,7 +112,7 @@ def scatter( by default False ax : matplotlib axes, optional axes to plot on, by default None - **kwargs : + **kwargs other keyword arguments to matplotlib.pyplot.scatter() Examples @@ -351,7 +351,8 @@ def hist( axes to plot on, by default None figsize : tuple, optional width and height of the figure, by default None - kwargs : other keyword arguments to df.hist() + **kwargs + other keyword arguments to df.hist() Returns ------- diff --git a/modelskill/comparison/_comparer_plotter.py b/modelskill/comparison/_comparer_plotter.py index 83c7f2082..6e8b6a155 100644 --- a/modelskill/comparison/_comparer_plotter.py +++ b/modelskill/comparison/_comparer_plotter.py @@ -65,7 +65,10 @@ def timeseries( figsize : (float, float), optional figure size, by default None backend : str, optional - use "plotly" (interactive) or "matplotlib" backend, by default "matplotlib"backend: + use "plotly" (interactive) or "matplotlib" backend, + by default "matplotlib" + **kwargs + other keyword arguments to fig.update_layout (plotly backend) Returns ------- @@ -165,7 +168,8 @@ def hist( If True, draw and return a probability density alpha : float, optional alpha transparency fraction, by default 0.5 - kwargs : other keyword arguments to df.plot.hist() + **kwargs + other keyword arguments to df.plot.hist() Returns ------- @@ -265,7 +269,8 @@ def kde(self, ax=None, title=None, figsize=None, **kwargs) -> matplotlib.axes.Ax plot title, default: "KDE plot for [observation name]" figsize : tuple, optional figure size, by default None - kwargs : other keyword arguments to df.plot.kde() + **kwargs + other keyword arguments to df.plot.kde() Returns ------- @@ -339,7 +344,8 @@ def qq( axes to plot on, by default None figsize : tuple, optional figure size, by default None - kwargs : other keyword arguments to plt.plot() + **kwargs + other keyword arguments to plt.plot() Returns ------- @@ -414,7 +420,8 @@ def box(self, *, ax=None, title=None, figsize=None, **kwargs): plot title, default: [observation name] figsize : tuple, optional figure size, by default None - kwargs : other keyword arguments to df.boxplot() + **kwargs + other keyword arguments to df.boxplot() Returns ------- @@ -531,7 +538,8 @@ def scatter( right of the scatter plot, by default False ax : matplotlib.axes.Axes, optional axes to plot on, by default None - **kwargs: other keyword arguments to plt.scatter() + **kwargs + other keyword arguments to plt.scatter() Examples ------ @@ -758,7 +766,8 @@ def residual_hist( figure size, by default None ax : matplotlib.axes.Axes, optional axes to plot on, by default None - kwargs : other keyword arguments to plt.hist() + **kwargs + other keyword arguments to plt.hist() Returns ------- diff --git a/modelskill/comparison/_comparison.py b/modelskill/comparison/_comparison.py index 7e8b8d2e2..aa36f4cc9 100644 --- a/modelskill/comparison/_comparison.py +++ b/modelskill/comparison/_comparison.py @@ -466,6 +466,19 @@ def __init__( ), f"raw_mod_data[{k}] must be a TimeSeries object" self.plot = Comparer.plotter(self) + """Plot using the ComparerPlotter + + Examples + -------- + >>> cmp.plot.timeseries() + >>> cmp.plot.scatter() + >>> cmp.plot.qq() + >>> cmp.plot.hist() + >>> cmp.plot.kde() + >>> cmp.plot.box() + >>> cmp.plot.residual_hist() + >>> cmp.plot.taylor() + """ @staticmethod def from_matched_data( diff --git a/modelskill/skill.py b/modelskill/skill.py index ea0c264d2..56d310c80 100644 --- a/modelskill/skill.py +++ b/modelskill/skill.py @@ -80,7 +80,7 @@ def line( ---------- level : int or str, optional level to unstack, by default 0 - kwargs : dict, optional + **kwargs key word arguments to be pased to pd.DataFrame.plot.line() e.g. marker, title, figsize, ... @@ -113,7 +113,7 @@ def bar(self, level: int | str = 0, **kwargs): ---------- level : int or str, optional level to unstack, by default 0 - kwargs : dict, optional + **kwargs key word arguments to be pased to pd.DataFrame.plot.bar() e.g. color, title, figsize, ... @@ -140,7 +140,7 @@ def barh(self, level: int | str = 0, **kwargs): ---------- level : int or str, optional level to unstack, by default 0 - kwargs : dict, optional + **kwargs key word arguments to be passed to pd.DataFrame.plot.barh() e.g. color, title, figsize, ... @@ -539,7 +539,7 @@ def sel(self, query=None, reduce_index=True, **kwargs): reduce_index : bool, optional Should unnecessary levels of the index be removed after subsetting? Removed levels will stay as columns. By default True - **kwargs : dict, optional + **kwargs Concrete keys depend on the index names of the SkillTable (from the "by" argument in cc.skill() method) "model"=... to select specific models, diff --git a/modelskill/skill_grid.py b/modelskill/skill_grid.py index c781c3d7f..aff35d734 100644 --- a/modelskill/skill_grid.py +++ b/modelskill/skill_grid.py @@ -69,7 +69,8 @@ def plot(self, model=None, **kwargs): ---------- model : str, optional Name of model to plot, by default all models - **kwargs : keyword arguments passed to xr.DataArray plot() + **kwargs + keyword arguments passed to xr.DataArray plot() e.g. figsize Examples diff --git a/modelskill/timeseries/_plotter.py b/modelskill/timeseries/_plotter.py index b770e98f1..e66374a48 100644 --- a/modelskill/timeseries/_plotter.py +++ b/modelskill/timeseries/_plotter.py @@ -40,7 +40,8 @@ def timeseries( plot marker, by default '.' linestyle : str, optional line style, by default None - kwargs: other keyword arguments to df.plot() + **kwargs + other keyword arguments to df.plot() """ kwargs["color"] = self._ts._color if color is None else color ax = self._ts._values_as_series.plot( @@ -66,7 +67,8 @@ def hist(self, bins=100, title=None, color=None, **kwargs): plot title, default: observation name color : str, optional plot color, by default "#d62728" - kwargs : other keyword arguments to df.hist() + **kwargs + other keyword arguments to df.hist() Returns ------- @@ -111,7 +113,8 @@ def hist(self, bins=100, **kwargs): ---------- bins : int, optional specification of bins, by default 100 - kwargs : other keyword arguments to df.hist() + **kwargs + other keyword arguments to df.hist() """ import plotly.express as px # type: ignore From bd960fbccc7226c7e5f0e6548c61b3ccbb347659 Mon Sep 17 00:00:00 2001 From: Jesper Sandvig Mariegaard <34088801+jsmariegaard@users.noreply.github.com> Date: Thu, 4 Jan 2024 07:54:26 +0100 Subject: [PATCH 19/29] move deprecated methods to the bottom, and other clean-up --- modelskill/comparison/_collection.py | 331 ++++++++++++++------------- 1 file changed, 170 insertions(+), 161 deletions(-) diff --git a/modelskill/comparison/_collection.py b/modelskill/comparison/_collection.py index 5437b3e46..cf1ca36ca 100644 --- a/modelskill/comparison/_collection.py +++ b/modelskill/comparison/_collection.py @@ -91,6 +91,8 @@ class ComparerCollection(Mapping, Scoreable): >>> o1 = ms.PointObservation("klagshamn.dfs0", item=0, x=366844, y=6154291, name="Klagshamn") >>> o2 = ms.PointObservation("drogden.dfs0", item=0, x=355568.0, y=6156863.0) >>> cc = ms.match(obs=[o1,o2], mod=mr) + >>> sk = cc.skill() + >>> cc["Klagshamn"].plot.timeseries() """ plotter = ComparerCollectionPlotter @@ -98,7 +100,17 @@ class ComparerCollection(Mapping, Scoreable): def __init__(self, comparers: Iterable[Comparer]) -> None: self._comparers: Dict[str, Comparer] = {} self._insert_comparers(comparers) + self.plot = ComparerCollection.plotter(self) + """Plot using the ComparerCollectionPlotter + + Examples + -------- + >>> cc.plot.scatter() + >>> cc.plot.kde() + >>> cc.plot.taylor() + >>> cc.plot.hist() + """ def _insert_comparers(self, comparer: Union[Comparer, Iterable[Comparer]]) -> None: if isinstance(comparer, Iterable): @@ -209,7 +221,7 @@ def n_quantities(self) -> int: return len(self.quantity_names) def to_dataframe(self, attrs_keys=None, observed=False) -> pd.DataFrame: - """Return a copy of the data as a pandas DataFrame""" + """Return a copy of the data as a long-format pandas DataFrame (for groupby operations)""" # TODO delegate to each comparer attrs_keys = attrs_keys or [] res = _all_df_template(self.n_quantities) @@ -228,11 +240,7 @@ def to_dataframe(self, attrs_keys=None, observed=False) -> pd.DataFrame: df["x"] = cmp.x df["y"] = cmp.y df["obs_val"] = cmp.data["Observation"].values - # if attrs_keys is not None: for key in attrs_keys: - # assert ( - # key in cmp.data.attrs - # ), f"key {key} not in attrs, valid keys: {cmp.data.attrs.keys()}" if key in cmp.data.attrs: df[key] = cmp.data.attrs[key] else: @@ -241,11 +249,10 @@ def to_dataframe(self, attrs_keys=None, observed=False) -> pd.DataFrame: if len(frames) > 0: res = pd.concat(frames) cat_cols = res.select_dtypes(include=["object"]).columns - res[cat_cols] = res[cat_cols].astype("category") # TODO + res[cat_cols] = res[cat_cols].astype("category") if observed: res = res.loc[~(res == False).any(axis=1)] # noqa - # res = res.sort_index() res.index.name = "time" return res @@ -379,7 +386,7 @@ def sel( Time. If None, all times are selected. area : list of float, optional bbox: [x0, y0, x1, y1] or Polygon. If None, all areas are selected. - kwargs : dict, optional + **kwargs Filtering by comparer attrs similar to xarray.Dataset.filter_by_attrs e.g. `sel(gtype='track')` or `sel(obs_provider='CMEMS')` if at least one comparer has an entry `obs_provider` with value `CMEMS` in its @@ -446,7 +453,7 @@ def filter_by_attrs(self, **kwargs) -> "ComparerCollection": Parameters ---------- - kwargs : dict, optional + **kwargs Filtering by comparer attrs similar to xarray.Dataset.filter_by_attrs e.g. `sel(gtype='track')` or `sel(obs_provider='CMEMS')` if at least one comparer has an entry `obs_provider` with value `CMEMS` in its @@ -551,9 +558,8 @@ def skill( 2017-10-28 162 -0.07 0.19 0.18 0.16 0.96 0.06 1.00 2017-10-29 163 -0.21 0.52 0.47 0.42 0.79 0.11 0.99 """ - pmetrics = _parse_metric(metrics) - # TODO remove in v1.1 + # TODO remove in v1.1 ---------- model, start, end, area = _get_deprecated_args(kwargs) observation, variable = _get_deprecated_obs_var_args(kwargs) assert kwargs == {}, f"Unknown keyword arguments: {kwargs}" @@ -571,6 +577,8 @@ def skill( ## ---- end of deprecated code ---- + pmetrics = _parse_metric(metrics) + n_models = cc.n_models # len(df.model.unique()) n_obs = cc.n_observations # len(df.observation.unique()) @@ -620,27 +628,6 @@ def _add_as_col_if_not_in_index( skilldf.insert(loc=0, column=field, value=unames[0]) return skilldf - def spatial_skill( - self, - bins=5, - binsize=None, - by=None, - metrics=None, - n_min=None, - **kwargs, - ): - warnings.warn( - "spatial_skill is deprecated, use gridded_skill instead", FutureWarning - ) - return self.gridded_skill( - bins=bins, - binsize=binsize, - by=by, - metrics=metrics, - n_min=n_min, - **kwargs, - ) - def gridded_skill( self, bins=5, @@ -709,8 +696,6 @@ def gridded_skill( observation, variable = _get_deprecated_obs_var_args(kwargs) assert kwargs == {}, f"Unknown keyword arguments: {kwargs}" - metrics = _parse_metric(metrics) - cmp = self.sel( model=model, observation=observation, @@ -725,6 +710,8 @@ def gridded_skill( ## ---- end of deprecated code ---- + metrics = _parse_metric(metrics) + df = cmp.to_dataframe() df = _add_spatial_grid_to_df(df=df, bins=bins, binsize=binsize) @@ -746,69 +733,6 @@ def gridded_skill( ds[dim] = ds[dim].astype(float) return SkillGrid(ds) - def scatter( - self, - *, - bins=120, - quantiles=None, - fit_to_quantiles=False, - show_points=None, - show_hist=None, - show_density=None, - backend="matplotlib", - figsize=(8, 8), - xlim=None, - ylim=None, - reg_method="ols", - title=None, - xlabel=None, - ylabel=None, - skill_table=None, - **kwargs, - ): - warnings.warn("scatter is deprecated, use plot.scatter instead", FutureWarning) - - # TODO remove in v1.1 - model, start, end, area = _get_deprecated_args(kwargs) - observation, variable = _get_deprecated_obs_var_args(kwargs) - - # select model - mod_idx = _get_idx(model, self.mod_names) - mod_name = self.mod_names[mod_idx] - - # select variable - qnt_idx = _get_idx(variable, self.quantity_names) - qnt_name = self.quantity_names[qnt_idx] - - # filter data - cmp = self.sel( - model=mod_name, - observation=observation, - quantity=qnt_name, - start=start, - end=end, - area=area, - ) - - return cmp.plot.scatter( - bins=bins, - quantiles=quantiles, - fit_to_quantiles=fit_to_quantiles, - show_points=show_points, - show_hist=show_hist, - show_density=show_density, - backend=backend, - figsize=figsize, - xlim=xlim, - ylim=ylim, - reg_method=reg_method, - title=title, - xlabel=xlabel, - ylabel=ylabel, - skill_table=skill_table, - **kwargs, - ) - def mean_skill( self, *, @@ -880,13 +804,12 @@ def mean_skill( ## ---- end of deprecated code ---- df = cc.to_dataframe() # TODO: remove - mod_names = cc.mod_names # df.model.unique() + mod_names = cc.mod_names # obs_names = cmp.obs_names # df.observation.unique() - qnt_names = cc.quantity_names # self.qnt_names + qnt_names = cc.quantity_names # skill assessment pmetrics = _parse_metric(metrics) - # s = self.skill(df=df, metrics=metrics) s = cc.skill(metrics=pmetrics) if s is None: return None @@ -1134,67 +1057,6 @@ def score( return score - def taylor( - self, - normalize_std=False, - aggregate_observations=True, - figsize=(7, 7), - marker="o", - marker_size=6.0, - title="Taylor diagram", - **kwargs, - ): - warnings.warn("taylor is deprecated, use plot.taylor instead", FutureWarning) - - model, start, end, area = _get_deprecated_args(kwargs) - observation, variable = _get_deprecated_obs_var_args(kwargs) - assert kwargs == {}, f"Unknown keyword arguments: {kwargs}" - - cmp = self.sel( - model=model, - observation=observation, - quantity=variable, - start=start, - end=end, - area=area, - ) - - if cmp.n_points == 0: - warnings.warn("No data!") - return - - if (not aggregate_observations) and (not normalize_std): - raise ValueError( - "aggregate_observations=False is only possible if normalize_std=True!" - ) - - metrics = [mtr._std_obs, mtr._std_mod, mtr.cc] - skill_func = cmp.mean_skill if aggregate_observations else cmp.skill - s = skill_func(metrics=metrics) - - df = s.to_dataframe() - ref_std = 1.0 if normalize_std else df.iloc[0]["_std_obs"] - - if isinstance(df.index, pd.MultiIndex): - df.index = df.index.map("_".join) - - df = df[["_std_obs", "_std_mod", "cc"]].copy() - df.columns = ["obs_std", "std", "cc"] - pts = [ - TaylorPoint( - r.Index, r.obs_std, r.std, r.cc, marker=marker, marker_size=marker_size - ) - for r in df.itertuples() - ] - - taylor_diagram( - obs_std=ref_std, - points=pts, - figsize=figsize, - normalize_std=normalize_std, - title=title, - ) - def save(self, filename: Union[str, Path]) -> None: """Save the ComparerCollection to a zip file. @@ -1267,6 +1129,153 @@ def _load_comparer(folder, f) -> Comparer: os.remove(f) return cmp + # =============== Deprecated methods =============== + + def spatial_skill( + self, + bins=5, + binsize=None, + by=None, + metrics=None, + n_min=None, + **kwargs, + ): + warnings.warn( + "spatial_skill is deprecated, use gridded_skill instead", FutureWarning + ) + return self.gridded_skill( + bins=bins, + binsize=binsize, + by=by, + metrics=metrics, + n_min=n_min, + **kwargs, + ) + + def scatter( + self, + *, + bins=120, + quantiles=None, + fit_to_quantiles=False, + show_points=None, + show_hist=None, + show_density=None, + backend="matplotlib", + figsize=(8, 8), + xlim=None, + ylim=None, + reg_method="ols", + title=None, + xlabel=None, + ylabel=None, + skill_table=None, + **kwargs, + ): + warnings.warn("scatter is deprecated, use plot.scatter instead", FutureWarning) + + # TODO remove in v1.1 + model, start, end, area = _get_deprecated_args(kwargs) + observation, variable = _get_deprecated_obs_var_args(kwargs) + + # select model + mod_idx = _get_idx(model, self.mod_names) + mod_name = self.mod_names[mod_idx] + + # select variable + qnt_idx = _get_idx(variable, self.quantity_names) + qnt_name = self.quantity_names[qnt_idx] + + # filter data + cmp = self.sel( + model=mod_name, + observation=observation, + quantity=qnt_name, + start=start, + end=end, + area=area, + ) + + return cmp.plot.scatter( + bins=bins, + quantiles=quantiles, + fit_to_quantiles=fit_to_quantiles, + show_points=show_points, + show_hist=show_hist, + show_density=show_density, + backend=backend, + figsize=figsize, + xlim=xlim, + ylim=ylim, + reg_method=reg_method, + title=title, + xlabel=xlabel, + ylabel=ylabel, + skill_table=skill_table, + **kwargs, + ) + + def taylor( + self, + normalize_std=False, + aggregate_observations=True, + figsize=(7, 7), + marker="o", + marker_size=6.0, + title="Taylor diagram", + **kwargs, + ): + warnings.warn("taylor is deprecated, use plot.taylor instead", FutureWarning) + + model, start, end, area = _get_deprecated_args(kwargs) + observation, variable = _get_deprecated_obs_var_args(kwargs) + assert kwargs == {}, f"Unknown keyword arguments: {kwargs}" + + cmp = self.sel( + model=model, + observation=observation, + quantity=variable, + start=start, + end=end, + area=area, + ) + + if cmp.n_points == 0: + warnings.warn("No data!") + return + + if (not aggregate_observations) and (not normalize_std): + raise ValueError( + "aggregate_observations=False is only possible if normalize_std=True!" + ) + + metrics = [mtr._std_obs, mtr._std_mod, mtr.cc] + skill_func = cmp.mean_skill if aggregate_observations else cmp.skill + s = skill_func(metrics=metrics) + + df = s.to_dataframe() + ref_std = 1.0 if normalize_std else df.iloc[0]["_std_obs"] + + if isinstance(df.index, pd.MultiIndex): + df.index = df.index.map("_".join) + + df = df[["_std_obs", "_std_mod", "cc"]].copy() + df.columns = ["obs_std", "std", "cc"] + pts = [ + TaylorPoint( + r.Index, r.obs_std, r.std, r.cc, marker=marker, marker_size=marker_size + ) + for r in df.itertuples() + ] + + taylor_diagram( + obs_std=ref_std, + points=pts, + figsize=figsize, + normalize_std=normalize_std, + title=title, + ) + def kde(self, ax=None, **kwargs): warnings.warn("kde is deprecated, use plot.kde instead", FutureWarning) From 9fbf00a69f2d9e120ba85a4bc247317bab4e23be Mon Sep 17 00:00:00 2001 From: Jesper Sandvig Mariegaard <34088801+jsmariegaard@users.noreply.github.com> Date: Thu, 4 Jan 2024 08:21:12 +0100 Subject: [PATCH 20/29] idx instead of id --- modelskill/connection.py | 10 +++++----- modelskill/utils.py | 4 ++-- 2 files changed, 7 insertions(+), 7 deletions(-) diff --git a/modelskill/connection.py b/modelskill/connection.py index 2cf86498f..efb3f37c1 100644 --- a/modelskill/connection.py +++ b/modelskill/connection.py @@ -316,15 +316,15 @@ def _add_modelresults(self, mod): self.modelresults[mod.name] = mod def _get_obs_name(self, obs): - return self.obs_names[self._get_obs_id(obs)] + return self.obs_names[self._get_obs_idx(obs)] - def _get_obs_id(self, obs): + def _get_obs_idx(self, obs): n_con = len(self.connections) if obs is None or n_con <= 1: return 0 elif isinstance(obs, str): if obs in self.obs_names: - obs_id = self.obs_names.index(obs) + obs_idx = self.obs_names.index(obs) else: raise KeyError( f"connection {obs} could not be found in {self.obs_names}" @@ -333,12 +333,12 @@ def _get_obs_id(self, obs): if obs < 0: # Handle negative indices obs += n_con if obs >= 0 and obs < n_con: - obs_id = obs + obs_idx = obs else: raise IndexError(f"connection id {obs} is out of range (0, {n_con-1})") else: raise KeyError("connection must be None, str or int") - return obs_id + return obs_idx def __getitem__(self, x): if isinstance(x, int): diff --git a/modelskill/utils.py b/modelskill/utils.py index 816009c9a..ea5ca782b 100644 --- a/modelskill/utils.py +++ b/modelskill/utils.py @@ -155,12 +155,12 @@ def make_unique_index( def _get_name(x: int | str | None, valid_names: Sequence[str]) -> str: - """Parse name/id from list of valid names (e.g. obs from obs_names), return name""" + """Parse name/idx from list of valid names (e.g. obs from obs_names), return name""" return valid_names[_get_idx(x, valid_names)] def _get_idx(x: int | str | None, valid_names: Sequence[str]) -> int: - """Parse name/id from list of valid names (e.g. obs from obs_names), return id""" + """Parse name/idx from list of valid names (e.g. obs from obs_names), return idx""" if x is None: if len(valid_names) == 1: From 959023a65a083362ef84bd4025ef5af61bb98093 Mon Sep 17 00:00:00 2001 From: Jesper Sandvig Mariegaard <34088801+jsmariegaard@users.noreply.github.com> Date: Thu, 4 Jan 2024 09:06:26 +0100 Subject: [PATCH 21/29] better docstrings --- modelskill/matching.py | 38 ++++++++++++++++++++++++-------------- 1 file changed, 24 insertions(+), 14 deletions(-) diff --git a/modelskill/matching.py b/modelskill/matching.py index 5dc76829a..04b4b9cf9 100644 --- a/modelskill/matching.py +++ b/modelskill/matching.py @@ -82,14 +82,14 @@ def from_matched( """Create a Comparer from observation and model results that are already matched (aligned) Parameters ---------- - data : [pd.DataFrame,str,Path,mikeio.Dfs0, mikeio.Dataset] + data : [pd.DataFrame, str, Path, mikeio.Dfs0, mikeio.Dataset] DataFrame (or object that can be converted to a DataFrame e.g. dfs0) with columns obs_item, mod_items, aux_items - obs_item : [str,int], optional + obs_item : [str, int], optional Name or index of observation item, by default first item - mod_items : Iterable[str,int], optional + mod_items : Iterable[str, int], optional Names or indicies of model items, if None all remaining columns are model items, by default None - aux_items : Iterable[str,int], optional + aux_items : Iterable[str, int], optional Names or indicies of auxiliary items, by default None quantity : Quantity, optional Quantity of the observation and model results, by default Quantity(name="Undefined", unit="Undefined") @@ -186,25 +186,35 @@ def match( max_model_gap=None, ): """Compare observations and model results + Parameters ---------- - obs : (str, pd.DataFrame, Observation) - Observation to be compared - mod : (str, pd.DataFrame, ModelResultInterface) - Model result to be compared - obs_item : (int, str), optional - observation item, by default None + obs : (str, Path, pd.DataFrame, Observation, Sequence[Observation]) + Observation(s) to be compared + mod : (str, Path, pd.DataFrame, ModelResult, Sequence[ModelResult]) + Model result(s) to be compared + obs_item : int or str, optional + observation item if obs is a file/dataframe, by default None mod_item : (int, str), optional - model item, by default None + model item if mod is a file/dataframe, by default None gtype : (str, optional) - Geometry type of the model result. If not specified, it will be guessed. + Geometry type of the model result (if mod is a file/dataframe). + If not specified, it will be guessed. max_model_gap : (float, optional) - Maximum time gap (s) in the model result, by default None + Maximum time gap (s) in the model result (e.g. for event-based + model results), by default None Returns ------- + Comparer + In case of a single observation ComparerCollection - To be used for plotting and statistics + In case of multiple observations + + See Also + -------- + [from_matched][modelskill.from_matched] + Create a Comparer from observation and model results that are already matched """ if isinstance(obs, get_args(ObsInputType)): return _single_obs_compare( From 43209c4634e6354b45b4f8ead113cdbf7b314649 Mon Sep 17 00:00:00 2001 From: Jesper Sandvig Mariegaard <34088801+jsmariegaard@users.noreply.github.com> Date: Thu, 4 Jan 2024 09:33:18 +0100 Subject: [PATCH 22/29] move load/save and deprecated functionality to bottom of file --- modelskill/comparison/_comparison.py | 212 +++++++++++++-------------- 1 file changed, 102 insertions(+), 110 deletions(-) diff --git a/modelskill/comparison/_comparison.py b/modelskill/comparison/_comparison.py index aa36f4cc9..8f36d399d 100644 --- a/modelskill/comparison/_comparison.py +++ b/modelskill/comparison/_comparison.py @@ -655,8 +655,6 @@ def _model_to_frame(self, mod_name: str) -> pd.DataFrame: def to_dataframe(self) -> pd.DataFrame: """Convert to pandas DataFrame with all model data concatenated""" - # TODO is this needed?, comment out for now - # df = df.sort_index() df = pd.concat([self._model_to_frame(name) for name in self.mod_names]) df["model"] = df["model"].astype("category") df["observation"] = df["observation"].astype("category") @@ -732,84 +730,6 @@ def rename( return Comparer(matched_data=data, raw_mod_data=raw_mod_data) - def save(self, filename: Union[str, Path]) -> None: - """Save to netcdf file - - Parameters - ---------- - filename : str or Path - filename - """ - ds = self.data - - # add self.raw_mod_data to ds with prefix 'raw_' to avoid name conflicts - # an alternative strategy would be to use NetCDF groups - # https://docs.xarray.dev/en/stable/user-guide/io.html#groups - - # There is no need to save raw data for track data, since it is identical to the matched data - if self.gtype == "point": - ds = self.data.copy() # copy needed to avoid modifying self.data - - for key, ts_mod in self.raw_mod_data.items(): - ts_mod = ts_mod.copy() - # rename time to unique name - ts_mod.data = ts_mod.data.rename({"time": "_time_raw_" + key}) - # da = ds_mod.to_xarray()[key] - ds["_raw_" + key] = ts_mod.data[key] - - ds.to_netcdf(filename) - - @staticmethod - def load(filename: Union[str, Path]) -> "Comparer": - """Load from netcdf file - - Parameters - ---------- - filename : str or Path - filename - - Returns - ------- - Comparer - """ - with xr.open_dataset(filename) as ds: - data = ds.load() - - if data.gtype == "track": - return Comparer(matched_data=data) - - if data.gtype == "point": - raw_mod_data: Dict[str, TimeSeries] = {} - - for var in data.data_vars: - var_name = str(var) - if var_name[:5] == "_raw_": - new_key = var_name[5:] # remove prefix '_raw_' - ds = data[[var_name]].rename( - {"_time_raw_" + new_key: "time", var_name: new_key} - ) - ts = PointObservation(data=ds, name=new_key) - # TODO: name of time? - # ts.name = new_key - # df = ( - # data[var_name] - # .to_dataframe() - # .rename( - # columns={"_time_raw_" + new_key: "time", var_name: new_key} - # ) - # ) - raw_mod_data[new_key] = ts - - # data = data.drop(var_name).drop("_time_raw_" + new_key) - - # filter variables, only keep the ones with a 'time' dimension - data = data[[v for v in data.data_vars if "time" in data[v].dims]] - - return Comparer(matched_data=data, raw_mod_data=raw_mod_data) - - else: - raise NotImplementedError(f"Unknown gtype: {data.gtype}") - def _to_observation(self) -> PointObservation | TrackObservation: """Convert to Observation""" if self.gtype == "point": @@ -1129,28 +1049,6 @@ def score( .to_dict() ) - def spatial_skill( - self, - bins=5, - binsize=None, - by=None, - metrics=None, - n_min=None, - **kwargs, - ): - # deprecated - warnings.warn( - "spatial_skill is deprecated, use gridded_skill instead", FutureWarning - ) - return self.gridded_skill( - bins=bins, - binsize=binsize, - by=by, - metrics=metrics, - n_min=n_min, - **kwargs, - ) - def gridded_skill( self, bins: int = 5, @@ -1284,6 +1182,108 @@ def remove_bias(self, correct="Model") -> Comparer: ) return cmp + def save(self, filename: Union[str, Path]) -> None: + """Save to netcdf file + + Parameters + ---------- + filename : str or Path + filename + """ + ds = self.data + + # add self.raw_mod_data to ds with prefix 'raw_' to avoid name conflicts + # an alternative strategy would be to use NetCDF groups + # https://docs.xarray.dev/en/stable/user-guide/io.html#groups + + # There is no need to save raw data for track data, since it is identical to the matched data + if self.gtype == "point": + ds = self.data.copy() # copy needed to avoid modifying self.data + + for key, ts_mod in self.raw_mod_data.items(): + ts_mod = ts_mod.copy() + # rename time to unique name + ts_mod.data = ts_mod.data.rename({"time": "_time_raw_" + key}) + # da = ds_mod.to_xarray()[key] + ds["_raw_" + key] = ts_mod.data[key] + + ds.to_netcdf(filename) + + @staticmethod + def load(filename: Union[str, Path]) -> "Comparer": + """Load from netcdf file + + Parameters + ---------- + filename : str or Path + filename + + Returns + ------- + Comparer + """ + with xr.open_dataset(filename) as ds: + data = ds.load() + + if data.gtype == "track": + return Comparer(matched_data=data) + + if data.gtype == "point": + raw_mod_data: Dict[str, TimeSeries] = {} + + for var in data.data_vars: + var_name = str(var) + if var_name[:5] == "_raw_": + new_key = var_name[5:] # remove prefix '_raw_' + ds = data[[var_name]].rename( + {"_time_raw_" + new_key: "time", var_name: new_key} + ) + ts = PointObservation(data=ds, name=new_key) + # TODO: name of time? + # ts.name = new_key + # df = ( + # data[var_name] + # .to_dataframe() + # .rename( + # columns={"_time_raw_" + new_key: "time", var_name: new_key} + # ) + # ) + raw_mod_data[new_key] = ts + + # data = data.drop(var_name).drop("_time_raw_" + new_key) + + # filter variables, only keep the ones with a 'time' dimension + data = data[[v for v in data.data_vars if "time" in data[v].dims]] + + return Comparer(matched_data=data, raw_mod_data=raw_mod_data) + + else: + raise NotImplementedError(f"Unknown gtype: {data.gtype}") + + # =============== Deprecated methods =============== + + def spatial_skill( + self, + bins=5, + binsize=None, + by=None, + metrics=None, + n_min=None, + **kwargs, + ): + # deprecated + warnings.warn( + "spatial_skill is deprecated, use gridded_skill instead", FutureWarning + ) + return self.gridded_skill( + bins=bins, + binsize=binsize, + by=by, + metrics=metrics, + n_min=n_min, + **kwargs, + ) + # TODO remove plotting methods in v1.1 def scatter( self, @@ -1389,11 +1389,3 @@ def residual_hist(self, bins=100, title=None, color=None, **kwargs): ) return self.plot.residual_hist(bins=bins, title=title, color=color, **kwargs) - - -# class PointComparer(Comparer): -# pass - - -# class TrackComparer(Comparer): -# pass From 597b2fac2d5345368a52d119f7ebc1764cd1f302 Mon Sep 17 00:00:00 2001 From: Jesper Sandvig Mariegaard <34088801+jsmariegaard@users.noreply.github.com> Date: Thu, 4 Jan 2024 09:34:53 +0100 Subject: [PATCH 23/29] rename residual to _residual (for now) --- modelskill/comparison/_comparer_plotter.py | 4 ++-- modelskill/comparison/_comparison.py | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/modelskill/comparison/_comparer_plotter.py b/modelskill/comparison/_comparer_plotter.py index 6e8b6a155..6aec55bb9 100644 --- a/modelskill/comparison/_comparer_plotter.py +++ b/modelskill/comparison/_comparer_plotter.py @@ -766,7 +766,7 @@ def residual_hist( figure size, by default None ax : matplotlib.axes.Axes, optional axes to plot on, by default None - **kwargs + **kwargs other keyword arguments to plt.hist() Returns @@ -778,7 +778,7 @@ def residual_hist( default_color = "#8B8D8E" color = default_color if color is None else color title = f"Residuals, {self.comparer.name}" if title is None else title - ax.hist(self.comparer.residual, bins=bins, color=color, **kwargs) + ax.hist(self.comparer._residual, bins=bins, color=color, **kwargs) ax.set_title(title) ax.set_xlabel(f"Residuals of {self.comparer._unit_text}") diff --git a/modelskill/comparison/_comparison.py b/modelskill/comparison/_comparison.py index 8f36d399d..a1314c2b9 100644 --- a/modelskill/comparison/_comparison.py +++ b/modelskill/comparison/_comparison.py @@ -1155,7 +1155,7 @@ def gridded_skill( return SkillGrid(ds) @property - def residual(self): + def _residual(self): df = self.data.drop_vars(["x", "y", "z"]).to_dataframe() obs = df[self._obs_str].values mod = df[self.mod_names].values @@ -1164,7 +1164,7 @@ def residual(self): def remove_bias(self, correct="Model") -> Comparer: cmp = self.copy() - bias = cmp.residual.mean(axis=0) + bias = cmp._residual.mean(axis=0) if correct == "Model": for j in range(cmp.n_models): mod_name = cmp.mod_names[j] From 5c3afff0f6c2e6042f53ed5715d366a18c37af52 Mon Sep 17 00:00:00 2001 From: Jesper Sandvig Mariegaard <34088801+jsmariegaard@users.noreply.github.com> Date: Thu, 4 Jan 2024 09:48:46 +0100 Subject: [PATCH 24/29] IdOrNameTypes renamed to IdxOrNameTypes --- modelskill/comparison/_collection.py | 10 +++++----- modelskill/comparison/_comparison.py | 4 ++-- modelskill/comparison/_utils.py | 2 +- modelskill/matching.py | 14 +++++++------- 4 files changed, 15 insertions(+), 15 deletions(-) diff --git a/modelskill/comparison/_collection.py b/modelskill/comparison/_collection.py index cf1ca36ca..65ccad12e 100644 --- a/modelskill/comparison/_collection.py +++ b/modelskill/comparison/_collection.py @@ -33,7 +33,7 @@ _add_spatial_grid_to_df, _groupby_df, _parse_groupby, - IdOrNameTypes, + IdxOrNameTypes, TimeTypes, ) from ._comparison import _get_deprecated_args # TODO remove in v 1.1 @@ -358,14 +358,14 @@ def __add__( def sel( self, - model: Optional[IdOrNameTypes] = None, - observation: Optional[IdOrNameTypes] = None, - quantity: Optional[IdOrNameTypes] = None, + model: Optional[IdxOrNameTypes] = None, + observation: Optional[IdxOrNameTypes] = None, + quantity: Optional[IdxOrNameTypes] = None, start: Optional[TimeTypes] = None, end: Optional[TimeTypes] = None, time: Optional[TimeTypes] = None, area: Optional[List[float]] = None, - variable: Optional[IdOrNameTypes] = None, # obsolete + variable: Optional[IdxOrNameTypes] = None, # obsolete **kwargs, ) -> "ComparerCollection": """Select data based on model, time and/or area. diff --git a/modelskill/comparison/_comparison.py b/modelskill/comparison/_comparison.py index a1314c2b9..a549bb982 100644 --- a/modelskill/comparison/_comparison.py +++ b/modelskill/comparison/_comparison.py @@ -34,7 +34,7 @@ _groupby_df, _parse_groupby, TimeTypes, - IdOrNameTypes, + IdxOrNameTypes, ) from ..skill import SkillTable from ..skill_grid import SkillGrid @@ -796,7 +796,7 @@ def __add__( def sel( self, - model: Optional[IdOrNameTypes] = None, + model: Optional[IdxOrNameTypes] = None, start: Optional[TimeTypes] = None, end: Optional[TimeTypes] = None, time: Optional[TimeTypes] = None, diff --git a/modelskill/comparison/_utils.py b/modelskill/comparison/_utils.py index 425e9388b..9f38ca07e 100644 --- a/modelskill/comparison/_utils.py +++ b/modelskill/comparison/_utils.py @@ -6,7 +6,7 @@ TimeTypes = Union[str, np.datetime64, pd.Timestamp, datetime] -IdOrNameTypes = Union[int, str, List[int], List[str]] +IdxOrNameTypes = Union[int, str, List[int], List[str]] def _add_spatial_grid_to_df( diff --git a/modelskill/matching.py b/modelskill/matching.py index 04b4b9cf9..4a6a1712d 100644 --- a/modelskill/matching.py +++ b/modelskill/matching.py @@ -34,7 +34,7 @@ from . import __version__ TimeDeltaTypes = Union[float, int, np.timedelta64, pd.Timedelta, timedelta] -IdOrNameTypes = Optional[Union[int, str]] +IdxOrNameTypes = Optional[Union[int, str]] GeometryTypes = Optional[Literal["point", "track", "unstructured", "grid"]] MRInputType = Union[ str, @@ -155,8 +155,8 @@ def match( obs: PointObservation | TrackObservation, mod: Union[MRInputType, Sequence[MRInputType]], *, - obs_item: Optional[IdOrNameTypes] = None, - mod_item: Optional[IdOrNameTypes] = None, + obs_item: Optional[IdxOrNameTypes] = None, + mod_item: Optional[IdxOrNameTypes] = None, gtype: Optional[GeometryTypes] = None, max_model_gap: Optional[float] = None, ) -> Comparer: @@ -168,8 +168,8 @@ def match( obs: Iterable[PointObservation | TrackObservation], mod: Union[MRInputType, Sequence[MRInputType]], *, - obs_item: Optional[IdOrNameTypes] = None, - mod_item: Optional[IdOrNameTypes] = None, + obs_item: Optional[IdxOrNameTypes] = None, + mod_item: Optional[IdxOrNameTypes] = None, gtype: Optional[GeometryTypes] = None, max_model_gap: Optional[float] = None, ) -> ComparerCollection: @@ -496,7 +496,7 @@ def _parse_single_obs( def _parse_models( mod: Any, # TODO - item: Optional[IdOrNameTypes] = None, + item: Optional[IdxOrNameTypes] = None, gtype: Optional[GeometryTypes] = None, ) -> List[Any]: # TODO """Return a list of ModelResult objects""" @@ -510,7 +510,7 @@ def _parse_models( def _parse_single_model( mod: Any, # TODO - item: Optional[IdOrNameTypes] = None, + item: Optional[IdxOrNameTypes] = None, gtype: Optional[GeometryTypes] = None, ) -> Any: # TODO if isinstance( From d16ea04e39ea8ac40d45bc0bede1a09949ecb7ef Mon Sep 17 00:00:00 2001 From: Jesper Sandvig Mariegaard <34088801+jsmariegaard@users.noreply.github.com> Date: Thu, 4 Jan 2024 10:36:53 +0100 Subject: [PATCH 25/29] Improved docstrings, correct return types, lists in arguments --- modelskill/comparison/_collection.py | 92 +++++++++++++++------------- modelskill/comparison/_comparison.py | 26 ++++---- 2 files changed, 65 insertions(+), 53 deletions(-) diff --git a/modelskill/comparison/_collection.py b/modelskill/comparison/_collection.py index 65ccad12e..7fcd3b051 100644 --- a/modelskill/comparison/_collection.py +++ b/modelskill/comparison/_collection.py @@ -510,16 +510,20 @@ def skill( Parameters ---------- - by : (str, List[str]), optional - group by column name or by temporal bin via the freq-argument - (using pandas pd.Grouper(freq)), - e.g.: 'freq:M' = monthly; 'freq:D' daily - or by attributes, stored in the cc.data.attrs container, + by : str or List[str], optional + group by, by default ["model", "observation"] + + - by column name + - by temporal bin of the DateTimeIndex via the freq-argument + (using pandas pd.Grouper(freq)), e.g.: 'freq:M' = monthly; 'freq:D' daily + - by the dt accessor of the DateTimeIndex (e.g. 'dt.month') using the + syntax 'dt:month'. The dt-argument is different from the freq-argument + in that it gives month-of-year rather than month-of-data. + - by attributes, stored in the cc.data.attrs container, e.g.: 'attrs:obs_provider' = group by observation provider or 'attrs:gtype' = group by geometry type (track or point) - by default ["model","observation"] metrics : list, optional - list of modelskill.metrics, by default modelskill.options.metrics.list + list of modelskill.metrics (or str), by default modelskill.options.metrics.list observed: bool, optional This only applies if any of the groupers are Categoricals. @@ -528,8 +532,8 @@ def skill( Returns ------- - pd.DataFrame - skill assessment as a dataframe + SkillTable + skill assessment as a SkillTable object See also -------- @@ -547,7 +551,7 @@ def skill( EPL 66 -0.08 0.22 0.20 0.18 0.97 0.07 0.99 c2 113 -0.00 0.35 0.35 0.29 0.97 0.12 0.99 - >>> cc.skill(observation='c2', start='2017-10-28').round(2) + >>> cc.sel(observation='c2', start='2017-10-28').skill().round(2) n bias rmse urmse mae cc si r2 observation c2 41 0.33 0.41 0.25 0.36 0.96 0.06 0.99 @@ -648,11 +652,15 @@ def gridded_skill( binsize : float, optional bin size for x and y dimension, overwrites bins creates bins with reference to round(mean(x)), round(mean(y)) - by : (str, List[str]), optional - group by column name or by temporal bin via the freq-argument - (using pandas pd.Grouper(freq)), - e.g.: 'freq:M' = monthly; 'freq:D' daily - by default ["model","observation"] + by : str, List[str], optional + group by, by default ["model", "observation"] + + - by column name + - by temporal bin of the DateTimeIndex via the freq-argument + (using pandas pd.Grouper(freq)), e.g.: 'freq:M' = monthly; 'freq:D' daily + - by the dt accessor of the DateTimeIndex (e.g. 'dt.month') using the + syntax 'dt:month'. The dt-argument is different from the freq-argument + in that it gives month-of-year rather than month-of-data. metrics : list, optional list of modelskill.metrics, by default modelskill.options.metrics.list n_min : int, optional @@ -661,8 +669,8 @@ def gridded_skill( Returns ------- - xr.Dataset - skill assessment as a dataset + SkillGrid + skill assessment as a SkillGrid object See also -------- @@ -745,25 +753,26 @@ def mean_skill( First, the skill is calculated per observation, the weighted mean of the skills is then found. - .. warning:: - This method is NOT the mean skill of all observational points! (mean_skill_points) + Warning: This method is NOT the mean skill of + all observational points! (mean_skill_points) Parameters ---------- - weights : (str, List(float), Dict(str, float)), optional - None: use observations weight attribute - "equal": giving all observations equal weight, - "points": giving all points equal weight, - list of weights e.g. [0.3, 0.3, 0.4] per observation, - dictionary of observations with special weigths, others will be set to 1.0 - by default None (i.e. observations weight attribute if assigned else "equal") + weights : str or List(float) or Dict(str, float), optional + weighting of observations, by default None + + - None: use observations weight attribute (if assigned, else "equal") + - "equal": giving all observations equal weight, + - "points": giving all points equal weight, + - list of weights e.g. [0.3, 0.3, 0.4] per observation, + - dictionary of observations with special weigths, others will be set to 1.0 metrics : list, optional list of modelskill.metrics, by default modelskill.options.metrics.list Returns ------- SkillTable - mean skill assessment as a skill object + mean skill assessment as a SkillTable object See also -------- @@ -976,13 +985,14 @@ def score( Parameters ---------- - weights : (str, List(float), Dict(str, float)), optional - None: use observations weight attribute - "equal": giving all observations equal weight, - "points": giving all points equal weight, - list of weights e.g. [0.3, 0.3, 0.4] per observation, - dictionary of observations with special weigths, others will be set to 1.0 - by default None (i.e. observations weight attribute if assigned else "equal") + weights : str or List(float) or Dict(str, float), optional + weighting of observations, by default None + + - None: use observations weight attribute (if assigned, else "equal") + - "equal": giving all observations equal weight, + - "points": giving all points equal weight, + - list of weights e.g. [0.3, 0.3, 0.4] per observation, + - dictionary of observations with special weigths, others will be set to 1.0 metric : list, optional a single metric from modelskill.metrics, by default rmse @@ -1003,14 +1013,14 @@ def score( Examples -------- >>> import modelskill as ms - >>> cc = ms.match(obs, mod) + >>> cc = ms.match([o1, o2], mod) >>> cc.score() - 0.30681206 + {'mod': 0.30681206} >>> cc.score(weights=[0.1,0.1,0.8]) - 0.3383011631797379 + {'mod': 0.3383011631797379} >>> cc.score(weights='points', metric="mape") - 8.414442957854142 + {'mod': 8.414442957854142} """ weights = kwargs.pop("weights", None) @@ -1060,6 +1070,8 @@ def score( def save(self, filename: Union[str, Path]) -> None: """Save the ComparerCollection to a zip file. + Each comparer is stored as a netcdf file in the zip file. + Parameters ---------- filename : str or Path @@ -1069,10 +1081,6 @@ def save(self, filename: Union[str, Path]) -> None: -------- >>> cc = ms.match(obs, mod) >>> cc.save("my_comparer_collection.msk") - - Notes - ----- - Each comparer is stored as a netcdf file in the zip file. """ files = [] diff --git a/modelskill/comparison/_comparison.py b/modelskill/comparison/_comparison.py index a549bb982..c71ca0b1e 100644 --- a/modelskill/comparison/_comparison.py +++ b/modelskill/comparison/_comparison.py @@ -919,11 +919,15 @@ def skill( Parameters ---------- - by : (str, List[str]), optional - group by column name or by temporal bin via the freq-argument - (using pandas pd.Grouper(freq)), - e.g.: 'freq:M' = monthly; 'freq:D' daily - by default ["model"] + by : str or List[str], optional + group by, by default ["model"] + + - by column name + - by temporal bin of the DateTimeIndex via the freq-argument + (using pandas pd.Grouper(freq)), e.g.: 'freq:M' = monthly; 'freq:D' daily + - by the dt accessor of the DateTimeIndex (e.g. 'dt.month') using the + syntax 'dt:month'. The dt-argument is different from the freq-argument + in that it gives month-of-year rather than month-of-data. metrics : list, optional list of modelskill.metrics, by default modelskill.options.metrics.list @@ -1004,7 +1008,7 @@ def score( Returns ------- - float + dict[str, float] skill score as a single number (for each model) See also @@ -1017,10 +1021,10 @@ def score( >>> import modelskill as ms >>> cmp = ms.match(c2, mod) >>> cmp.score() - 0.3517964910888918 + {'mod': 0.3517964910888918} - >>> cmp.score(metric=ms.metrics.mape) - 11.567399646108198 + >>> cmp.score(metric="mape") + {'mod': 11.567399646108198} """ metric = _parse_metric(metric)[0] if not (callable(metric) or isinstance(metric, str)): @@ -1082,8 +1086,8 @@ def gridded_skill( Returns ------- - xr.Dataset - skill assessment as a dataset + SkillGrid + skill assessment as a SkillGrid object See also -------- From 56c7cd4ded8ad1c17e340aa064f9502e70106d73 Mon Sep 17 00:00:00 2001 From: Jesper Sandvig Mariegaard <34088801+jsmariegaard@users.noreply.github.com> Date: Thu, 4 Jan 2024 10:51:27 +0100 Subject: [PATCH 26/29] rename to_dataframe to _to_long_dataframe --- modelskill/comparison/_collection.py | 90 +++++++------- modelskill/comparison/_collection_plotter.py | 6 +- modelskill/comparison/_comparison.py | 46 ++++--- tests/test_aggregated_skill.py | 124 +++++++++---------- tests/test_comparer.py | 10 +- 5 files changed, 138 insertions(+), 138 deletions(-) diff --git a/modelskill/comparison/_collection.py b/modelskill/comparison/_collection.py index 7fcd3b051..a20bbbd5f 100644 --- a/modelskill/comparison/_collection.py +++ b/modelskill/comparison/_collection.py @@ -220,42 +220,6 @@ def n_quantities(self) -> int: """Number of unique quantities""" return len(self.quantity_names) - def to_dataframe(self, attrs_keys=None, observed=False) -> pd.DataFrame: - """Return a copy of the data as a long-format pandas DataFrame (for groupby operations)""" - # TODO delegate to each comparer - attrs_keys = attrs_keys or [] - res = _all_df_template(self.n_quantities) - frames = [] - cols = list(res.keys()) + attrs_keys - for cmp in self._comparers.values(): - for j in range(cmp.n_models): - mod_name = cmp.mod_names[j] - # drop "x", "y", ? - df = cmp.data.drop_vars(["z"])[[mod_name]].to_dataframe().copy() - df = df.rename(columns={mod_name: "mod_val"}) - df["model"] = mod_name - df["observation"] = cmp.name - if self.n_quantities > 1: - df["quantity"] = cmp.quantity.name - df["x"] = cmp.x - df["y"] = cmp.y - df["obs_val"] = cmp.data["Observation"].values - for key in attrs_keys: - if key in cmp.data.attrs: - df[key] = cmp.data.attrs[key] - else: - df[key] = False - frames.append(df[cols]) - if len(frames) > 0: - res = pd.concat(frames) - cat_cols = res.select_dtypes(include=["object"]).columns - res[cat_cols] = res[cat_cols].astype("category") - - if observed: - res = res.loc[~(res == False).any(axis=1)] # noqa - res.index.name = "time" - return res - def __repr__(self): out = [] out.append(f"<{type(self).__name__}>") @@ -583,8 +547,8 @@ def skill( pmetrics = _parse_metric(metrics) - n_models = cc.n_models # len(df.model.unique()) - n_obs = cc.n_observations # len(df.observation.unique()) + n_models = cc.n_models + n_obs = cc.n_observations # TODO: FIX # len(df.variable.unique()) if (self.n_variables > 1) else 1 @@ -593,7 +557,7 @@ def skill( by, attrs_keys = self._attrs_keys_in_by(by) assert isinstance(by, list) - df = cc.to_dataframe(attrs_keys=attrs_keys, observed=observed) + df = cc._to_long_dataframe(attrs_keys=attrs_keys, observed=observed) res = _groupby_df(df, by, pmetrics) mtr_cols = [m.__name__ for m in pmetrics] # type: ignore @@ -604,6 +568,42 @@ def skill( res = cc._add_as_col_if_not_in_index(df, skilldf=res) return SkillTable(res) + def _to_long_dataframe(self, attrs_keys=None, observed=False) -> pd.DataFrame: + """Return a copy of the data as a long-format pandas DataFrame (for groupby operations)""" + # TODO delegate to each comparer + attrs_keys = attrs_keys or [] + res = _all_df_template(self.n_quantities) + frames = [] + cols = list(res.keys()) + attrs_keys + for cmp in self._comparers.values(): + for j in range(cmp.n_models): + mod_name = cmp.mod_names[j] + # drop "x", "y", ? + df = cmp.data.drop_vars(["z"])[[mod_name]].to_dataframe().copy() + df = df.rename(columns={mod_name: "mod_val"}) + df["model"] = mod_name + df["observation"] = cmp.name + if self.n_quantities > 1: + df["quantity"] = cmp.quantity.name + df["x"] = cmp.x + df["y"] = cmp.y + df["obs_val"] = cmp.data["Observation"].values + for key in attrs_keys: + if key in cmp.data.attrs: + df[key] = cmp.data.attrs[key] + else: + df[key] = False + frames.append(df[cols]) + if len(frames) > 0: + res = pd.concat(frames) + cat_cols = res.select_dtypes(include=["object"]).columns + res[cat_cols] = res[cat_cols].astype("category") + + if observed: + res = res.loc[~(res == False).any(axis=1)] # noqa + res.index.name = "time" + return res + @staticmethod def _attrs_keys_in_by(by): """Check if 'attrs:' is in by and return attrs_keys""" @@ -720,7 +720,7 @@ def gridded_skill( metrics = _parse_metric(metrics) - df = cmp.to_dataframe() + df = cmp._to_long_dataframe() df = _add_spatial_grid_to_df(df=df, bins=bins, binsize=binsize) by = _parse_groupby(by, cmp.n_models, cmp.n_observations) @@ -812,7 +812,7 @@ def mean_skill( ## ---- end of deprecated code ---- - df = cc.to_dataframe() # TODO: remove + df = cc._to_long_dataframe() # TODO: remove mod_names = cc.mod_names # obs_names = cmp.obs_names # df.observation.unique() qnt_names = cc.quantity_names @@ -1058,8 +1058,8 @@ def score( ## ---- end of deprecated code ---- - skill = cmp.mean_skill(weights=weights, metrics=[metric]) - df = skill.to_dataframe() + sk = cmp.mean_skill(weights=weights, metrics=[metric]) + df = sk.to_dataframe() metric_name = metric if isinstance(metric, str) else metric.__name__ @@ -1259,9 +1259,9 @@ def taylor( metrics = [mtr._std_obs, mtr._std_mod, mtr.cc] skill_func = cmp.mean_skill if aggregate_observations else cmp.skill - s = skill_func(metrics=metrics) + sk = skill_func(metrics=metrics) - df = s.to_dataframe() + df = sk.to_dataframe() ref_std = 1.0 if normalize_std else df.iloc[0]["_std_obs"] if isinstance(df.index, pd.MultiIndex): diff --git a/modelskill/comparison/_collection_plotter.py b/modelskill/comparison/_collection_plotter.py index a9cff2600..0149d1f69 100644 --- a/modelskill/comparison/_collection_plotter.py +++ b/modelskill/comparison/_collection_plotter.py @@ -196,7 +196,7 @@ def _scatter_one_model( if cc_sel_mod.n_points == 0: raise ValueError("No data found in selection") - df = cc_sel_mod.to_dataframe() + df = cc_sel_mod._to_long_dataframe() x = df.obs_val.values y = df.mod_val.values @@ -287,7 +287,7 @@ def kde(self, *, ax=None, figsize=None, title=None, **kwargs) -> Axes: """ _, ax = _get_fig_ax(ax, figsize) - df = self.cc.to_dataframe() + df = self.cc._to_long_dataframe() ax = df.obs_val.plot.kde( ax=ax, linestyle="dashed", label="Observation", **kwargs ) @@ -421,7 +421,7 @@ def _hist_one_model( ) cmp = self.cc - df = cmp.to_dataframe() + df = cmp._to_long_dataframe() kwargs["alpha"] = alpha kwargs["density"] = density df.mod_val.hist(bins=bins, color=MOD_COLORS[mod_idx], ax=ax, **kwargs) diff --git a/modelskill/comparison/_comparison.py b/modelskill/comparison/_comparison.py index c71ca0b1e..f438d5345 100644 --- a/modelskill/comparison/_comparison.py +++ b/modelskill/comparison/_comparison.py @@ -640,26 +640,6 @@ def _unit_text(self) -> str: # Quantity name and unit as text suitable for plot labels return f"{self.quantity.name} [{self.quantity.unit}]" - def _model_to_frame(self, mod_name: str) -> pd.DataFrame: - """Convert single model data to pandas DataFrame""" - - df = self.data.drop_vars(["z"]).to_dataframe().copy() - other_models = [m for m in self.mod_names if m is not mod_name] - df = df.drop(columns=other_models) - df = df.rename(columns={mod_name: "mod_val", self._obs_str: "obs_val"}) - df["model"] = mod_name - df["observation"] = self.name - - return df - - def to_dataframe(self) -> pd.DataFrame: - """Convert to pandas DataFrame with all model data concatenated""" - - df = pd.concat([self._model_to_frame(name) for name in self.mod_names]) - df["model"] = df["model"].astype("category") - df["observation"] = df["observation"].astype("category") - return df - # TODO: is this the best way to copy (self.data.copy.. ) def __copy__(self): return deepcopy(self) @@ -909,6 +889,24 @@ def query(self, query: str) -> "Comparer": d = d.dropna(dim="time", how="all") return Comparer.from_matched_data(d, self.raw_mod_data) + def _model_to_frame(self, mod_name: str) -> pd.DataFrame: + """Convert single model data to pandas DataFrame""" + + df = self.data.drop_vars(["z"]).to_dataframe().copy() + other_models = [m for m in self.mod_names if m is not mod_name] + df = df.drop(columns=other_models) + df = df.rename(columns={mod_name: "mod_val", self._obs_str: "obs_val"}) + df["model"] = mod_name + df["observation"] = self.name + return df + + def _to_long_dataframe(self) -> pd.DataFrame: + """Return a copy of the data as a long-format pandas DataFrame (for groupby operations)""" + df = pd.concat([self._model_to_frame(name) for name in self.mod_names]) + df["model"] = df["model"].astype("category") + df["observation"] = df["observation"].astype("category") + return df + def skill( self, by: str | Iterable[str] | None = None, @@ -973,7 +971,7 @@ def skill( by = _parse_groupby(by, cmp.n_models, n_obs=1, n_qnt=1) - df = cmp.to_dataframe() + df = cmp._to_long_dataframe() res = _groupby_df(df, by, metrics) res["x"] = df.groupby(by=by, observed=False).x.first() res["y"] = df.groupby(by=by, observed=False).y.first() @@ -1034,7 +1032,7 @@ def score( model, start, end, area = _get_deprecated_args(kwargs) assert kwargs == {}, f"Unknown keyword arguments: {kwargs}" - s = self.skill( + sk = self.skill( by=["model", "observation"], metrics=[metric], model=model, # deprecated @@ -1042,7 +1040,7 @@ def score( end=end, # deprecated area=area, # deprecated ) - df = s.to_dataframe() + df = sk.to_dataframe() metric_name = metric if isinstance(metric, str) else metric.__name__ @@ -1132,7 +1130,7 @@ def gridded_skill( if cmp.n_points == 0: raise ValueError("No data to compare") - df = cmp.to_dataframe() + df = cmp._to_long_dataframe() df = _add_spatial_grid_to_df(df=df, bins=bins, binsize=binsize) # n_models = len(df.model.unique()) diff --git a/tests/test_aggregated_skill.py b/tests/test_aggregated_skill.py index 09c81dfdd..8b69796e6 100644 --- a/tests/test_aggregated_skill.py +++ b/tests/test_aggregated_skill.py @@ -116,18 +116,18 @@ def test_skill_table_from_xarray(sk_df2): def test_skill(cc1): - s = cc1.skill() + sk = cc1.skill() # TODO a minimal skill assesment consists of 1 observation, 1 model and 1 variable # in this case model and variable is implict since we only have one of each, but why do we have one observation, seems inconsistent - assert len(s.mod_names) == 0 # TODO seems wrong - assert len(s.obs_names) == 1 # makes sense - assert len(s.quantity_names) == 0 # TODO seems wrong + assert len(sk.mod_names) == 0 # TODO seems wrong + assert len(sk.obs_names) == 1 # makes sense + assert len(sk.quantity_names) == 0 # TODO seems wrong - df = s.to_dataframe() + df = sk.to_dataframe() assert isinstance(df, pd.DataFrame) - assert "bias" in repr(s) + assert "bias" in repr(sk) def test_skill_bad_args(cc1): @@ -136,13 +136,13 @@ def test_skill_bad_args(cc1): def test_skill_multi_model(cc2): - s = cc2.skill(metrics=["rmse", "bias"]) + sk = cc2.skill(metrics=["rmse", "bias"]) # TODO decide if N is a metric or not🤔 - assert len(s.metrics) == 3 + assert len(sk.metrics) == 3 - assert len(s.mod_names) == 2 - assert len(s.obs_names) == 3 + assert len(sk.mod_names) == 2 + assert len(sk.obs_names) == 3 # TODO recreate functionality of xs more domain specific # s2 = s.xs("SW_1", level="model") @@ -168,125 +168,125 @@ def test_skill_multi_model(cc2): def test_skill_sel(cc1): - s = cc1.skill(metrics=["rmse", "bias"]) - s2 = s.sel(observation="alti") + sk = cc1.skill(metrics=["rmse", "bias"]) + s2 = sk.sel(observation="alti") assert len(s2) == 1 - assert "rmse" in s.metrics - assert "bias" in s.metrics + assert "rmse" in sk.metrics + assert "bias" in sk.metrics def test_skill_sel_metrics_str(cc1): - s = cc1.skill(metrics=["rmse", "bias"]) + sk = cc1.skill(metrics=["rmse", "bias"]) with pytest.warns(FutureWarning, match="deprecated"): - s2 = s.sel(metrics="rmse") + s2 = sk.sel(metrics="rmse") assert s2.name == "rmse" def test_skill_sel_metrics_list(cc2): - s = cc2.skill(metrics=["rmse", "bias"]) + sk = cc2.skill(metrics=["rmse", "bias"]) with pytest.warns(FutureWarning, match="deprecated"): - s2 = s.sel(metrics=["rmse", "n"]) + s2 = sk.sel(metrics=["rmse", "n"]) assert "n" in s2.metrics assert "bias" not in s2.metrics def test_skill_sel_multi_model(cc2): - s = cc2.skill(metrics=["rmse", "bias"]) - s2 = s.sel(model="SW_1") - assert len(s2.mod_names) == 0 # no longer in index + sk = cc2.skill(metrics=["rmse", "bias"]) + sk2 = sk.sel(model="SW_1") + assert len(sk2.mod_names) == 0 # no longer in index # assert not isinstance(s2.index, pd.MultiIndex) - assert len(s2) == 3 + assert len(sk2) == 3 - s2 = s.sel(model="SW_1", observation=["EPL", "c2"]) - assert len(s2.obs_names) == 2 + sk2 = sk.sel(model="SW_1", observation=["EPL", "c2"]) + assert len(sk2.obs_names) == 2 # assert not isinstance(s2.index, pd.MultiIndex) - assert len(s2) == 2 + assert len(sk2) == 2 - s2 = s.sel(model=1, observation=["EPL"]) - assert len(s2.obs_names) == 0 + sk2 = sk.sel(model=1, observation=["EPL"]) + assert len(sk2.obs_names) == 0 # assert not isinstance(s2.index, pd.MultiIndex) - assert len(s2) == 1 + assert len(sk2) == 1 def test_skill_sel_query(cc2): - s = cc2.skill(metrics=["rmse", "bias"]) + sk = cc2.skill(metrics=["rmse", "bias"]) with pytest.warns(FutureWarning, match="deprecated"): - s2 = s.sel(query="rmse>0.2") + sk2 = sk.sel(query="rmse>0.2") - assert len(s2.mod_names) == 2 + assert len(sk2.mod_names) == 2 # s2 = s.sel("rmse>0.2", model="SW_2", observation=[0, 2]) # assert len(s2.mod_names) == 0 # no longer in index def test_skill_sel_fail(cc2): - s = cc2.skill(metrics=["rmse", "bias"]) + sk = cc2.skill(metrics=["rmse", "bias"]) with pytest.raises(KeyError): - s.sel(quantity="Hm0") + sk.sel(quantity="Hm0") with pytest.raises(KeyError): - s.sel(model=99) + sk.sel(model=99) def test_skill_plot_bar(cc1): - s = cc1.skill(metrics=["rmse", "bias"]) - s["bias"].plot.bar() + sk = cc1.skill(metrics=["rmse", "bias"]) + sk["bias"].plot.bar() def test_skill_plot_bar_multi_model(cc2): - s = cc2.skill(metrics="rmse") - s["rmse"].plot.bar() + sk = cc2.skill(metrics="rmse") + sk["rmse"].plot.bar() with pytest.raises(KeyError): - s["bad_metric"].plot.bar() + sk["bad_metric"].plot.bar() def test_skill_plot_line(cc1): - s = cc1.skill(metrics=["rmse", "bias"]) - s["bias"].plot.line() - s["bias"].plot.line(title="Skill") + sk = cc1.skill(metrics=["rmse", "bias"]) + sk["bias"].plot.line() + sk["bias"].plot.line(title="Skill") with pytest.raises(KeyError): - s["NOT_A_METRIC"].plot.line() + sk["NOT_A_METRIC"].plot.line() def test_skill_plot_line_multi_model(cc2): - s = cc2.skill(metrics="rmse") - s.rmse.plot.line() + sk = cc2.skill(metrics="rmse") + sk.rmse.plot.line() with pytest.raises(KeyError): - s["bad_metric"] + sk["bad_metric"] def test_skill_plot_grid(cc2): - s = cc2.skill() - s["rmse"].plot.grid() - s["bias"].plot.grid() - s["si"].plot.grid(fmt=".0%") - s["bias"].plot.grid(figsize=(2, 1), show_numbers=False) + sk = cc2.skill() + sk["rmse"].plot.grid() + sk["bias"].plot.grid() + sk["si"].plot.grid(fmt=".0%") + sk["bias"].plot.grid(figsize=(2, 1), show_numbers=False) - s2 = s.sel(model="SW_1") + sk2 = sk.sel(model="SW_1") with pytest.warns(UserWarning) as wn: - s2["rmse"].plot.grid() + sk2["rmse"].plot.grid() assert len(wn) == 1 assert "only possible for MultiIndex" in str(wn[0].message) def test_skill_style(cc2): - s = cc2.skill(metrics=["bias", "rmse", "lin_slope", "si"]) - s.style() - s.style(decimals=0) - s.style(metrics="rmse") - s.style(metrics=["bias", "rmse"]) - s.style(metrics=[]) - s.style(cmap="viridis_r", show_best=False) + sk = cc2.skill(metrics=["bias", "rmse", "lin_slope", "si"]) + sk.style() + sk.style(decimals=0) + sk.style(metrics="rmse") + sk.style(metrics=["bias", "rmse"]) + sk.style(metrics=[]) + sk.style(cmap="viridis_r", show_best=False) def test_skill_round(cc2): - s = cc2.skill() + sk = cc2.skill() # TODO consider decimals per metric, e.g. {bias: 2, rmse: 3} - s.round(decimals=2) + sk.round(decimals=2) diff --git a/tests/test_comparer.py b/tests/test_comparer.py index 04ad4fa80..d667563bf 100644 --- a/tests/test_comparer.py +++ b/tests/test_comparer.py @@ -562,8 +562,9 @@ def test_add_tc_pc(pc, tc): assert len(cc) == 2 -def test_pc_to_dataframe(pc): - df = pc.to_dataframe() +def test_pc_to_long_dataframe(pc): + # private method testing + df = pc._to_long_dataframe() assert isinstance(df, pd.DataFrame) assert df.shape == (10, 6) assert "mod_val" in df.columns @@ -584,9 +585,10 @@ def test_pc_to_dataframe(pc): assert df.iloc[9].model == "m2" -def test_pc_to_dataframe_add_col(pc): +def test_pc_to_long_dataframe_add_col(pc): + # private method testing pc.data["derived"] = pc.data.m1 + pc.data.m2 - df = pc.to_dataframe() + df = pc._to_long_dataframe() assert isinstance(df, pd.DataFrame) assert df.shape == (10, 7) assert "derived" in df.columns From 5afaa519b38dadfa82960cea2d6c7c39e9bd6cc3 Mon Sep 17 00:00:00 2001 From: Jesper Sandvig Mariegaard <34088801+jsmariegaard@users.noreply.github.com> Date: Thu, 4 Jan 2024 10:58:50 +0100 Subject: [PATCH 27/29] to_dataframe removed, use cmp.data.to_dataframe instead --- notebooks/Metocean_track_comparison.ipynb | 251 +++++++++++++--------- 1 file changed, 154 insertions(+), 97 deletions(-) diff --git a/notebooks/Metocean_track_comparison.ipynb b/notebooks/Metocean_track_comparison.ipynb index c9d03b0e8..11180c80d 100644 --- a/notebooks/Metocean_track_comparison.ipynb +++ b/notebooks/Metocean_track_comparison.ipynb @@ -14,7 +14,7 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -35,7 +35,7 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 2, "metadata": {}, "outputs": [ { @@ -44,7 +44,7 @@ " 'HD'" ] }, - "execution_count": 33, + "execution_count": 2, "metadata": {}, "output_type": "execute_result" } @@ -66,7 +66,7 @@ }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -76,7 +76,7 @@ }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 4, "metadata": {}, "outputs": [ { @@ -178,7 +178,7 @@ "2017-10-26 04:37:58 1.939 9.980000 " ] }, - "execution_count": 35, + "execution_count": 4, "metadata": {}, "output_type": "execute_result" } @@ -189,16 +189,16 @@ }, { "cell_type": "code", - "execution_count": 36, + "execution_count": 5, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "Quantity(name='Surface Elevation', unit='meter')" + "Quantity(name='Surface Elevation', unit='m')" ] }, - "execution_count": 36, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" } @@ -209,16 +209,24 @@ }, { "cell_type": "code", - "execution_count": 37, + "execution_count": 6, "metadata": {}, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\jem\\Source\\modelskill\\modelskill\\timeseries\\_track.py:135: UserWarning: Removed 22 duplicate timestamps with keep=first\n", + " warnings.warn(\n" + ] + }, { "data": { "text/plain": [ "TrackObservation: alti, n=1093" ] }, - "execution_count": 37, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" } @@ -231,7 +239,7 @@ }, { "cell_type": "code", - "execution_count": 38, + "execution_count": 7, "metadata": {}, "outputs": [ { @@ -240,13 +248,13 @@ "" ] }, - "execution_count": 38, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -261,7 +269,7 @@ }, { "cell_type": "code", - "execution_count": 39, + "execution_count": 8, "metadata": {}, "outputs": [ { @@ -273,7 +281,7 @@ " Model: HD, rmse=0.115" ] }, - "execution_count": 39, + "execution_count": 8, "metadata": {}, "output_type": "execute_result" } @@ -285,7 +293,7 @@ }, { "cell_type": "code", - "execution_count": 40, + "execution_count": 9, "metadata": {}, "outputs": [ { @@ -666,11 +674,12 @@ " HD (time) float32 0.3699 0.356 0.3559 ... 0.7068 0.7068 0.685\n", "Attributes:\n", " gtype: track\n", - " modelskill_version: 1.0.a2\n", - " name: alti
  • gtype :
    track
    modelskill_version :
    1.0.dev23
    weight :
    1.0
    name :
    alti
  • " ], "text/plain": [ "\n", @@ -856,11 +865,12 @@ " HD (time) float32 0.3699 0.356 0.3559 ... 0.7068 0.7068 0.685\n", "Attributes:\n", " gtype: track\n", - " modelskill_version: 1.0.a2\n", + " modelskill_version: 1.0.dev23\n", + " weight: 1.0\n", " name: alti" ] }, - "execution_count": 40, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" } @@ -871,12 +881,12 @@ }, { "cell_type": "code", - "execution_count": 41, + "execution_count": 10, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
    " ] @@ -900,9 +910,17 @@ }, { "cell_type": "code", - "execution_count": 42, + "execution_count": 11, "metadata": {}, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\jem\\Source\\modelskill\\modelskill\\timeseries\\_track.py:135: UserWarning: Removed 22 duplicate timestamps with keep=first\n", + " warnings.warn(\n" + ] + }, { "data": { "text/html": [ @@ -1280,12 +1298,12 @@ " HD (time) float64 nan nan nan nan nan nan ... nan nan nan nan nan nan\n", "Attributes:\n", " gtype: track\n", - " modelskill_version: 1.0.a2
  • gtype :
    track
    modelskill_version :
    1.0.dev23
  • " ], "text/plain": [ "\n", @@ -1310,10 +1328,10 @@ " HD (time) float64 nan nan nan nan nan nan ... nan nan nan nan nan nan\n", "Attributes:\n", " gtype: track\n", - " modelskill_version: 1.0.a2" + " modelskill_version: 1.0.dev23" ] }, - "execution_count": 42, + "execution_count": 11, "metadata": {}, "output_type": "execute_result" } @@ -1326,7 +1344,7 @@ }, { "cell_type": "code", - "execution_count": 43, + "execution_count": 12, "metadata": {}, "outputs": [ { @@ -1335,7 +1353,7 @@ " 'HD' (n_points: 1093)" ] }, - "execution_count": 43, + "execution_count": 12, "metadata": {}, "output_type": "execute_result" } @@ -1346,9 +1364,18 @@ }, { "cell_type": "code", - "execution_count": 44, + "execution_count": 13, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\jem\\Source\\modelskill\\modelskill\\timeseries\\_track.py:135: UserWarning: Removed 22 duplicate timestamps with keep=first\n", + " warnings.warn(\n" + ] + } + ], "source": [ "fn = '../tests/testdata/altimetry_NorthSea_20171027.csv'\n", "df = pd.read_csv(fn, index_col=0, parse_dates=True)\n", @@ -1357,7 +1384,7 @@ }, { "cell_type": "code", - "execution_count": 46, + "execution_count": 14, "metadata": {}, "outputs": [ { @@ -1737,11 +1764,12 @@ " alti (time) float64 1.645 1.12 1.088 1.031 ... 0.0364 0.0283 0.0601\n", "Attributes:\n", " gtype: track\n", - " modelskill_version: 1.0.a2
  • gtype :
    track
    modelskill_version :
    1.0.dev23
    weight :
    1.0
  • " ], "text/plain": [ "\n", @@ -1766,10 +1794,11 @@ " alti (time) float64 1.645 1.12 1.088 1.031 ... 0.0364 0.0283 0.0601\n", "Attributes:\n", " gtype: track\n", - " modelskill_version: 1.0.a2" + " modelskill_version: 1.0.dev23\n", + " weight: 1.0" ] }, - "execution_count": 46, + "execution_count": 14, "metadata": {}, "output_type": "execute_result" } @@ -1780,21 +1809,30 @@ }, { "cell_type": "code", - "execution_count": 47, + "execution_count": 15, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\jem\\Source\\modelskill\\modelskill\\matching.py:269: FutureWarning: compare is deprecated. Use match instead.\n", + " warnings.warn(\"compare is deprecated. Use match instead.\", FutureWarning)\n" + ] + } + ], "source": [ "cmp = ms.compare(o1, mr)" ] }, { "cell_type": "code", - "execution_count": 48, + "execution_count": 16, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
    " ] @@ -1819,9 +1857,17 @@ }, { "cell_type": "code", - "execution_count": 49, + "execution_count": 17, "metadata": {}, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\jem\\Source\\modelskill\\modelskill\\timeseries\\_track.py:135: UserWarning: Removed 22 duplicate timestamps with keep=first\n", + " warnings.warn(\n" + ] + }, { "data": { "text/plain": [ @@ -1831,7 +1877,7 @@ " Model: HD, rmse=0.115" ] }, - "execution_count": 49, + "execution_count": 17, "metadata": {}, "output_type": "execute_result" } @@ -1856,7 +1902,7 @@ }, { "cell_type": "code", - "execution_count": 50, + "execution_count": 18, "metadata": {}, "outputs": [], "source": [ @@ -1865,7 +1911,7 @@ }, { "cell_type": "code", - "execution_count": 51, + "execution_count": 19, "metadata": {}, "outputs": [ { @@ -2246,13 +2292,13 @@ " observation <U4 'alti'\n", "Attributes:\n", " long_name: Number of observations\n", - " units: -
    • y
      (y)
      float64
      50.6 51.66 52.7 53.75 54.8
      long_name :
      Latitude
      units :
      degrees north
      array([50.6045, 51.655 , 52.703 , 53.751 , 54.799 ])
    • x
      (x)
      float64
      -0.436 1.543 3.517 5.492 7.466
      long_name :
      Longitude
      units :
      degrees east
      array([-0.436 ,  1.543 ,  3.517 ,  5.4915,  7.466 ])
    • observation
      ()
      <U4
      'alti'
      array('alti', dtype='<U4')
    • y
      PandasIndex
      PandasIndex(Index([50.6045, 51.655, 52.703, 53.751, 54.799], dtype='float64', name='y'))
    • x
      PandasIndex
      PandasIndex(Index([-0.43599999999999994, 1.543, 3.5169999999999995, 5.4915,\n",
      +                            "       7.465999999999999],\n",
      +                            "      dtype='float64', name='x'))
  • long_name :
    Number of observations
    units :
    -
  • " ], "text/plain": [ "\n", @@ -2270,7 +2316,7 @@ " units: -" ] }, - "execution_count": 51, + "execution_count": 19, "metadata": {}, "output_type": "execute_result" } @@ -2289,12 +2335,12 @@ }, { "cell_type": "code", - "execution_count": 52, + "execution_count": 20, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
    " ] @@ -2319,12 +2365,12 @@ }, { "cell_type": "code", - "execution_count": 53, + "execution_count": 21, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA3AAAAHUCAYAAAB7+MoGAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAACBZ0lEQVR4nO3deVxU1fsH8M8ddhBwQbYEBMUFxVxIFPfc0twr19w1TUuRlDIr0AzSEtFMTTPR0rS+aqW54Uaa+0LuS4qCBpIbuILOnN8f/JgcB5Bh7jAX+Lxfr/uKOffOmWeG4umZc+45khBCgIiIiIiIiBRPZe4AiIiIiIiIqHBYwBEREREREZUQLOCIiIiIiIhKCBZwREREREREJQQLOCIiIiIiohKCBRwREREREVEJwQKOiIiIiIiohGABR0REREREVEKwgCMiIiIiIiohWMBRnuLi4iBJEg4fPmzuUExm5cqViI2NzfOcJEmIjIws1njM6dn3e/r0aURGRuLy5ct61w4ZMgRVq1YtttiIiHIxNzE3MTcRsYCjMqygJLlv3z6MGDGieANSkNOnT2Pq1Kl5JsmPP/4Y69atK/6giIjKAOam/DE3EeWwNHcARM/z4MED2NvbF+trNmnSpFhfrySpVq2auUMgIjI75iZlYW6isoQjcGXQnj170LZtWzg6OsLe3h4hISH4/fff87z29u3bGDp0KCpWrAgHBwd07doVly5d0rnm2LFj6NKlC1xdXWFjYwNPT0+8+uqruHr1qvYaIQTmz5+P+vXrw87ODhUqVMDrr7+u11fr1q1Rt25d/PHHHwgJCYG9vT2GDRuGHj16wMfHBxqNRi/G4OBgNGzYUPv466+/RsuWLeHq6goHBwcEBgZi5syZePz4sc7r/P7777hy5QokSdIeufKapnLy5El0794dFSpUgK2tLerXr49ly5bpXLNr1y5IkoQff/wRU6ZMgaenJ5ycnNCuXTucO3cun9+Iafz7778YM2YMAgICUK5cObi6uuLll1/G7t27C3xeXFwc3njjDQBAmzZttJ9NXFwcAE5TISLTYG5ibioIcxPRf1jAlTEJCQl4+eWXkZGRgSVLluDHH3+Eo6MjunbtitWrV+tdP3z4cKhUKu2UjoMHD6J169a4c+cOAOD+/fto3749rl+/jq+//hrx8fGIjY2Ft7c37t69q+1n1KhRCA0NRbt27fDLL79g/vz5OHXqFEJCQnD9+nWd10xNTcWbb76J/v37Y+PGjRgzZgyGDRuG5ORk7NixQ+fas2fP4uDBgxg6dKi27eLFi+jfvz++//57bNiwAcOHD8cXX3yBUaNGaa+ZP38+mjVrBnd3d+zbt0975OfcuXMICQnBqVOnMHfuXKxduxYBAQEYMmQIZs6cqXf9hx9+iCtXruDbb7/FokWLcOHCBXTt2hVqtbrA348QAk+ePCnU8Ty3bt0CAEREROD333/H0qVL4efnh9atW2PXrl35Pu/VV19FVFQUgJz/4cj9bF599dXnviYRUVEwN+VgbtqV7/OYm4ieIqhMadKkiXB1dRV3797Vtj158kTUrVtXVKlSRWg0GiGEEEuXLhUARM+ePXWe/+effwoAYvr06UIIIQ4fPiwAiF9++SXf19y3b58AIGbNmqXTnpKSIuzs7ER4eLi2rVWrVgKA2L59u861jx8/Fm5ubqJ///467eHh4cLa2lrcuHEjz9dWq9Xi8ePHYvny5cLCwkLcunVLe+7VV18VPj4+eT4PgIiIiNA+7tu3r7CxsRHJyck613Xq1EnY29uLO3fuCCGE2LlzpwAgOnfurHPdTz/9JACIffv25fl6uXKfX5gjKSmpwL6e9eTJE/H48WPRtm1bvd/rs+/3559/FgDEzp079foZPHhwvp8bEVFRMDcxNzE3ERUeR+DKkPv37+PAgQN4/fXXUa5cOW27hYUFBg4ciKtXr+pNpRgwYIDO45CQEPj4+GDnzp0AgOrVq6NChQp4//33sXDhQpw+fVrvdTds2ABJkvDmm2/qfEvn7u6OF198Ue8btwoVKuDll1/WabO0tMSbb76JtWvXIiMjAwCgVqvx/fffo3v37qhUqZL22mPHjqFbt26oVKkSLCwsYGVlhUGDBkGtVuP8+fOGf3AAduzYgbZt28LLy0unfciQIXjw4IHeN6TdunXTeVyvXj0AwJUrVwp8nUaNGuHQoUOFOjw9PZ8b98KFC9GwYUPY2trC0tISVlZW2L59O86cOVOYt01EZHLMTcxNzE1EhuEiJmXI7du3IYSAh4eH3rncP7g3b97UaXd3d9e71t3dXXuds7MzEhIS8Nlnn+HDDz/E7du34eHhgZEjR+Kjjz6ClZUVrl+/DiEE3Nzc8ozLz89P53Fe8QHAsGHDMGvWLKxatQqjRo3Cli1bkJqaqjNFJTk5GS1atEDNmjUxZ84cVK1aFba2tjh48CDGjh2Lhw8fFvAJ5e/mzZsGfW5PJ20AsLGxAYDnvn65cuVQv379QsVkaVnwf74xMTF47733MHr0aHz66adwcXGBhYUFPv74YyZJIlIM5ibmJuYmIsOwgCtDKlSoAJVKhdTUVL1z//zzDwDAxcVFpz0tLU3v2rS0NFSvXl37ODAwEKtWrYIQAsePH0dcXBymTZsGOzs7fPDBB3BxcYEkSdi9e7c2WTzt2banb9h+WkBAABo3boylS5di1KhRWLp0KTw9PdGhQwftNb/88gvu37+PtWvXwsfHR9uemJiYZ5+FValSJYM+t6JKSEhAmzZtCnVtUlJSgTds//DDD2jdujUWLFig0/70/R9ERObG3FR0zE1EZRMLuDLEwcEBwcHBWLt2Lb788kvY2dkBADQaDX744QdUqVIFNWrU0HnOihUr8Nprr2kf7927F1euXMlzHxpJkvDiiy9i9uzZiIuLw9GjRwEAXbp0weeff45r166hd+/eRr2HoUOH4u2338aePXuwfv16hIWFwcLCQicGQDfxCiGwePFivb5sbGwK/a1n27ZtsW7dOvzzzz8600OWL18Oe3t72ZZ2zp2mUhjPm6YiSZLe/4AcP34c+/bt05tu86zCfitLRGQs5iZdzE35Y24iysECroyJjo5G+/bt0aZNG0ycOBHW1taYP38+Tp48iR9//FHvG8bDhw9jxIgReOONN5CSkoIpU6bghRdewJgxYwDk3EMwf/589OjRA35+fhBCYO3atbhz5w7at28PAGjWrBneeustDB06FIcPH0bLli3h4OCA1NRU7NmzB4GBgXj77bcLFX+/fv0QFhaGfv36ISsrC0OGDNE53759e1hbW6Nfv34IDw/Ho0ePsGDBAty+fVuvr8DAQKxduxYLFixAo0aNoFKpEBQUlOfrRkREYMOGDWjTpg0++eQTVKxYEStWrMDvv/+OmTNnwtnZuVDxP4+jo2O+MRiqS5cu+PTTTxEREYFWrVrh3LlzmDZtGnx9fZ+7UljdunUBAIsWLYKjoyNsbW3h6+urN/2GiEgOzE3/YW7KH3MT0f8z1+opZD67d+8WL7/8snBwcBB2dnaiSZMmYv369TrX5K70tXXrVjFw4EBRvnx5YWdnJzp37iwuXLigve7s2bOiX79+olq1asLOzk44OzuLxo0bi7i4OL3X/e6770RwcLD2datVqyYGDRokDh8+rL2mVatWok6dOgXG379/fwFANGvWLM/z69evFy+++KKwtbUVL7zwgpg0aZLYtGmT3spVt27dEq+//rooX768kCRJPP2fA55Z+UoIIU6cOCG6du0qnJ2dhbW1tXjxxRfF0qVLda7JXanr559/1mlPSkoSAPSuN6WsrCwxceJE8cILLwhbW1vRsGFD8csvv+S5Ulde7zc2Nlb4+voKCwsLndi50hcRmQJzUw7mpv8wNxHlTRJCiOIuGomIiIiIiMhw3EaAiIiIiIiohGABR0REREREVEKwgCMiIiIiIiohWMARERERERGVECzgiIiIiIiISggWcERERERERCVEqd/IW6PR4J9//oGjo6PeRqBERHIQQuDu3bvw9PSESlX078UePXqE7Oxs2eKytraGra2tbP2RfJibiMjUlJibmJfkUeoLuH/++QdeXl7mDoOIyoCUlBRUqVKlSM999OgRfH3KIS1dLVs87u7uSEpKYrJUIOYmIiouxuamSnbl8ADy5CbmJXmU+gLO0dERAODzwSdQldJ/WY72/9bcIZhczxqB5g7BpB52DTJ3CCa3eMZX5g7BZO7d0yCk8Q3t35uiyM7ORlq6GklHfODkaPzs9sy7Gvg2uoLs7GwmSgXK/Xdl86GTcChX9H9vlGz6lvPmDsHkfhra2NwhkBEqNR9j7hBMSqgfQ336J6Nz0wOoMQgvwNrIO6+yocHytGvMSzIo9QVc7tQUla1tqS3gnBwtzB2CyVlKVuYOwaQsrUrnv5tPc5ShKFE6OabCOTmqZCngSNly/11xKOeIco5OZo7GNKzsHMwdgsk5OZXO311ZIVlYmzuEYiFHbrKGCtaSkblJGB0G/b9SX8AREZUkaqGBWoYkpxYa4zshIiICYCFJsDCyELSAxCJOJizgiIgURAMBjQwZTo4+iIiIAEAlARZGDuSpABZwMuE8HSIiIiIiohKCI3BERAqigQZyTH6UpxciIiIZp1CSLFjAEREpiFoIqIXxc0zk6IOIiAjImT5p7BTK0r/kXvHhFEoiIiIiIqISgiNwREQKwkVMiIhIaTiFUllYwBERKYgGAmoWcEREpCCcQqksnEJJRERERERUQnAEjohIQTiFkoiIlIZTKJWFBRwRkYJwFUoiIlIaCcZP22P5Jh9OoSQiIiIiIiohOAJHRKQgmv8/5OiHiIhIDpxCqSws4IiIFEQt0yqUcvRBREQEcBVKpeEUSiIiIiIiohKCI3BERAqiFjmHHP0QERHJIWcEztgplCQXFnBERArCe+CIiEhpOIVSWcw6hTIyMhKSJOkc7u7u2vNDhgzRO9+kSRMzRkxERKUZ8xIRESmd2Ufg6tSpg23btmkfW1jo1uevvPIKli5dqn1sbW1dbLERERU3DSSoZVipS8PVvoqMeYmISBdXoVQWsy9iYmlpCXd3d+1RuXJlnfM2NjY65ytWrFhgf1lZWcjMzNQ5iIhKCo2Q76CikTsvAcxNRFSyqaT/plEW9VAVsX6bP38+fH19YWtri0aNGmH37t35Xpuamor+/fujZs2aUKlUCA0NzfO6NWvWICAgADY2NggICMC6deuKFpyZmL2Au3DhAjw9PeHr64u+ffvi0qVLOud37doFV1dX1KhRAyNHjkR6enqB/UVHR8PZ2Vl7eHl5mTJ8IiIqZeTOSwBzExFRUaxevRqhoaGYMmUKjh07hhYtWqBTp05ITk7O8/qsrCxUrlwZU6ZMwYsvvpjnNfv27UOfPn0wcOBA/PXXXxg4cCB69+6NAwcOmPKtyEoSQpjte9pNmzbhwYMHqFGjBq5fv47p06fj7NmzOHXqFCpVqoTVq1ejXLly8PHxQVJSEj7++GM8efIER44cgY2NTZ59ZmVlISsrS/s4MzMTXl5e8I2MgsrWtrjeWrE6P3iBuUMwuY6eef9HWFo87Bls7hBM7oc5s8wdgsncvatBvYB0ZGRkwMnJqUh9ZGZmwtnZGQdOuaOco/Hfrd27q0FwnTSjYiqLTJGXgPxz0+4zV1DOsXT+fj7+/Yy5QzC59W81NXcIZATrBsPMHYJJCXU2npxYIUtumuVUHXaSccuQPBRqvJf5t0HxBAcHo2HDhliw4L//161duzZ69OiB6OjoAp/bunVr1K9fH7GxsTrtffr0QWZmJjZt2qRte+WVV1ChQgX8+OOPhX9DZmTWe+A6deqk/TkwMBBNmzZFtWrVsGzZMoSFhaFPnz7a83Xr1kVQUBB8fHzw+++/o1evXnn2aWNjU2ASJSJSMrVM98DJ0UdZZIq8BDA3EVHJJucqlM9OIc/v72N2djaOHDmCDz74QKe9Q4cO2Lt3b5Hj2LdvHyZMmKDT1rFjR71CT8nMPoXyaQ4ODggMDMSFCxfyPO/h4QEfH598zxMREcmJeYmISF5eXl46U8rzG0m7ceMG1Go13NzcdNrd3NyQlpZW5NdPS0uTvc/iZvZVKJ+WlZWFM2fOoEWLFnmev3nzJlJSUuDh4VHMkRERFQ+NkKARMqxCKUMfxLxERATIOwKXkpKiM4XyebMTpGdWvxRC6LUZyhR9FiezjsBNnDgRCQkJSEpKwoEDB/D6668jMzMTgwcPxr179zBx4kTs27cPly9fxq5du9C1a1e4uLigZ8+e5gybiMhkcqdQynGQ4ZiXiIj05W4jYOwBAE5OTjpHfgWci4sLLCws9EbG0tPT9UbQDOHu7i57n8XNrAXc1atX0a9fP9SsWRO9evWCtbU19u/fDx8fH1hYWODEiRPo3r07atSogcGDB6NGjRrYt28fHB0dzRk2ERGVUsxLRETKYG1tjUaNGiE+Pl6nPT4+HiEhIUXut2nTpnp9bt261ag+i5tZp1CuWrUq33N2dnbYsmVLMUZDRGR+aqigluG7NbUMsZRFzEtERPosIMMUyiKsex8WFoaBAwciKCgITZs2xaJFi5CcnIzRo0cDACZPnoxr165h+fLl2uckJiYCAO7du4d///0XiYmJsLa2RkBAAABg/PjxaNmyJWbMmIHu3bvj119/xbZt27Bnzx7j3mAxUtQ9cEREZZ2Q6R44wXvgiIhIJqqnpkAa04eh+vTpg5s3b2LatGlITU1F3bp1sXHjRvj4+ADI2bj72T3hGjRooP35yJEjWLlyJXx8fHD58mUAQEhICFatWoWPPvoIH3/8MapVq4bVq1cjOLjkbOnEAo6IiIiIiBRpzJgxGDNmTJ7n4uLi9NoKs8X166+/jtdff93Y0MyGBRwRkYJwHzgiIlIaWVahZFqSDQs4IiIFUQsV1EKGe+CKcK8BERFRXixkmEJp7PPpP4rayJuIiIiIiIjyxxE4IiIF0UCCRobv1jTgEBwREcmDUyiVhQUcEZGC8B44IiJSGk6hVBZOoSQiIiIiIiohOAJHRKQg8i1iwimUREQkD5UkFWkft2f7IHlwBI6ISEFy7oGT5zBE1apVIUmS3jF27FgAOfvqREZGwtPTE3Z2dmjdujVOnTplio+AiIgURrKQZDlIHizgiIgIhw4dQmpqqvaIj48HALzxxhsAgJkzZyImJgbz5s3DoUOH4O7ujvbt2+Pu3bvmDJuIiKjM4RRKIiIF0UAFtRlWoaxcubLO488//xzVqlVDq1atIIRAbGwspkyZgl69egEAli1bBjc3N6xcuRKjRo0yOl4iIlIulYUElYpTKJWCI3BERAqSew+cHAcAZGZm6hxZWVnPjSE7Oxs//PADhg0bBkmSkJSUhLS0NHTo0EF7jY2NDVq1aoW9e/ea7LMgIiKFsFBBMvKABcsOufCTJCIqxby8vODs7Kw9oqOjn/ucX375BXfu3MGQIUMAAGlpaQAANzc3nevc3Ny054iIiKh4cAolEZGCaKCSdSPvlJQUODk5adttbGye+9wlS5agU6dO8PT01GmXnpn+IoTQayMiotJHUhm/CInE/UllwwKOiEhB1EKCWsiwkff/9+Hk5KRTwD3PlStXsG3bNqxdu1bb5u7uDiBnJM7Dw0Pbnp6erjcqR0REpY/KQoLKyAJOxQJONpxCSUREWkuXLoWrqyteffVVbZuvry/c3d21K1MCOffJJSQkICQkxBxhEhERlVkcgSMiUhC1TKtQqg1chRIANBoNli5disGDB8PS8r/0IEkSQkNDERUVBX9/f/j7+yMqKgr29vbo37+/0bESEZGySSoVJJVxuUkShuclyhsLOCIiBdEIFTRChnvgipAot23bhuTkZAwbNkzvXHh4OB4+fIgxY8bg9u3bCA4OxtatW+Ho6Gh0rEREpGycQqksLOCIiAgA0KFDB4h8Cj9JkhAZGYnIyMjiDYqIiIh0sIAjIlIQc06hJCIiyotkwVUolYQFHBGRgmgAWVah1BgfChEREYDcAs7Ie+CYmWTDVSiJiIiIiIhKCI7AEREpiHwbefP7OSIikgcXMVEWFnBERAqiFiqoZViFUo4+iIiIgJyFrCSVkffAaVjAyYUZnoiIiIiIqITgCBwRkYJoIEEjwzQTOfogIiICAJWFCiojFzFRcWaIbFjAEREpCKdQEhGR0siyjYAMKyxTDmZ4IiIiIiKiEoIjcERECiLfRt78fo6IiOTBEThlYQFHRKQgGiFBI8dG3kyUREQkE94Dpyz8JImIiIiIiEoIjsARESmIRqYplNzIm4iIZCPDFEpwZohsWMARESmIRqigkWGaiRx9EBERAYBKkqAyciNvlcQCTi7M8ERERERERCUER+CIiBREDQlqGTbhlqMPIiIiAJAsVJCMXMRE0nDcSC4s4IiIFIRTKImISGlUFhJURt4Dp9Lwi0W5MMMTERERERGVEByBIyJSEDXkmf6oNj4UIiIiADJt5M0RONmwgCMiUhBOoSQiIqXhPXDKwk+SiIiIiIiohOAIHBGRgqiFCmoZRs/k6IOIiAgAVBaQYRETmYIhFnBEREoiIEEjwz1wgtsIEBGRTCSVBMnIjbyNfT79h1/REhERERERlRAcgSMiUhBOoSQiIqVRqVRQGbmIiUrNvCQXFnBERAqiERI0wvhpJnL0QUREBMi0jYCRz6f/lJkCzuf3+7C0LJ07I/3+hq25QzC5q1NCzB2CSXnueWTuEEyuZ3S4uUMwGXX2IwAfmjsMKoHqeZaHk5OTucOgIvIZttLcIZjUle/6mzsEk/qr/g1zh2BS97Ifo/EJc0dBplBmCjgiopJADRXUMtyeLEcfREREgEz7wBn5fPoPCzgiIgXhFEoiIlIaSaWCpDKygDPy+fQffpJEREREREQlBEfgiIgURAMVNDJ8tyZHH0RERACgspBhFUpOoZQNCzgiIgVRCwlqGaY/ytEHERERAECGe+DAAk42/CSJiIiIiIhKCI7AEREpCBcxISIipZFUMqxCyUVMZMMCjohIQYRQQSOMT3JChj6IiIgArkKpNPwkiYiIiIiISgiOwBERKYgaEtSQYRETGfogIiICcjfytjCyD7VM0RBH4IiIFEQj/rsPzrjDsNe9du0a3nzzTVSqVAn29vaoX78+jhw5oj0vhEBkZCQ8PT1hZ2eH1q1b49SpUzK/eyIiUiLp/1ehNPYgefCTJCIq427fvo1mzZrBysoKmzZtwunTpzFr1iyUL19ee83MmTMRExODefPm4dChQ3B3d0f79u1x9+5d8wVORERUBnEKJRGRgmhkWsTEkD5mzJgBLy8vLF26VNtWtWpV7c9CCMTGxmLKlCno1asXAGDZsmVwc3PDypUrMWrUKKPjJSIi5VKpVFAZuQiJsc+n//CTJCJSEA0k2Q4AyMzM1DmysrL0XvO3335DUFAQ3njjDbi6uqJBgwZYvHix9nxSUhLS0tLQoUMHbZuNjQ1atWqFvXv3mv5DISIis+IUSmXhJ0lEVIp5eXnB2dlZe0RHR+tdc+nSJSxYsAD+/v7YsmULRo8ejXHjxmH58uUAgLS0NACAm5ubzvPc3Ny054iIiKh4mLWAi4yMhCRJOoe7u3ue144aNQqSJCE2NrZ4gyQiKkZqIcl2AEBKSgoyMjK0x+TJk/VeU6PRoGHDhoiKikKDBg0watQojBw5EgsWLNC5TpJ0V7YUQui1lXTMS0RE+jgCpyxmvweuTp062LZtm/axRR5LlP7yyy84cOAAPD09izM0IqJiJ/c9cE5OTnBycirwWg8PDwQEBOi01a5dG2vWrAEAbQGTlpYGDw8P7TXp6el6o3KlAfMSEZEuSZJhI2+JBZxczP5JWlpawt3dXXtUrlxZ5/y1a9fwzjvvYMWKFbCysjJTlEREpVezZs1w7tw5nbbz58/Dx8cHAODr6wt3d3fEx8drz2dnZyMhIQEhISHFGmtxYF4iIiIlM/sI3IULF+Dp6QkbGxsEBwcjKioKfn5+AHKm9QwcOBCTJk1CnTp1CtVfVlaWzk36mZmZJombiMgUNMjZx02OfgprwoQJCAkJQVRUFHr37o2DBw9i0aJFWLRoEYCcqZOhoaGIioqCv78//P39ERUVBXt7e/Tv39/oWJVG7rwEMDcRUckmxxRITqGUj1k/yeDgYCxfvhxbtmzB4sWLkZaWhpCQENy8eRNAztLWlpaWGDduXKH7jI6O1rlh38vLy1ThExHJTsi0AqUwoIB76aWXsG7dOvz444+oW7cuPv30U8TGxmLAgAHaa8LDwxEaGooxY8YgKCgI165dw9atW+Ho6GiKj8FsTJGXAOYmIirZeA+csph1BK5Tp07anwMDA9G0aVNUq1YNy5YtQ6tWrTBnzhwcPXrUoJvkJ0+ejLCwMO3jzMxMJkoioufo0qULunTpku95SZIQGRmJyMjI4gvKDEyRlwDmJiIiko/Zp1A+zcHBAYGBgbhw4QJUKhXS09Ph7e2tPa9Wq/Hee+8hNjYWly9fzrMPGxsb2NjYFFPERETy0giZplDK0AfJk5cA5iYiKtlUFiqojBxBM/b59B9FFXBZWVk4c+YMWrRogYEDB6Jdu3Y65zt27IiBAwdi6NChZoqQiMi05F6FkozDvEREBEgqyfhVKFX8YlEuZi3gJk6ciK5du8Lb2xvp6emYPn06MjMzMXjwYFSqVAmVKlXSud7Kygru7u6oWbOmmSImIqLCmjt3rsHPGTp0qFnvq2NeIiIipTNrAXf16lX069cPN27cQOXKldGkSRPs379fu3Q1EVFZU5qmUIaGhqJKlSp57qOWl5SUFHTp0sWsBRzzEhGRPq5CqSxmLeBWrVpl0PUF3V9ARFQa5K4iKUc/SnD48GG4uroW6lolrGjJvEREpI8FnLLwkyQiIpOIiIhAuXLlCn39hx9+iIoVK5owIiIiopKPBRwRkYLkTqGU4zC3iIgI2NvbF/r6yZMno3z58qYLiIiIikSSVJBURh5S0cqO+fPnw9fXF7a2tmjUqBF2795d4PUJCQlo1KgRbG1t4efnh4ULF+qcj4uLgyRJesejR4+KFJ85sIAjIlKQ0lTA5efzzz/HnTt3zB0GEREVkmRhAZWRh1TI+6Gftnr1aoSGhmLKlCk4duwYWrRogU6dOiE5OTnP65OSktC5c2e0aNECx44dw4cffohx48ZhzZo1Otc5OTkhNTVV57C1tS3SZ2MOLOCIiKhYRUVF4datW+YOg4iIFC4mJgbDhw/HiBEjULt2bcTGxsLLywsLFizI8/qFCxfC29sbsbGxqF27NkaMGIFhw4bhyy+/1LlOkiS4u7vrHCUJCzgiIgUpCyNwQghzh0BERAbIXcTE2AMAMjMzdY6srKw8XzM7OxtHjhxBhw4ddNo7dOiAvXv35vmcffv26V3fsWNHHD58GI8fP9a23bt3Dz4+PqhSpQq6dOmCY8eOGfPxFLtCrUKZmZlpcMdOTk4GP4eIiKiwmJuIiEoeLy8vnccRERGIjIzUu+7GjRtQq9Vwc3PTaXdzc0NaWlqefaelpeV5/ZMnT3Djxg14eHigVq1aiIuLQ2BgIDIzMzFnzhw0a9YMf/31F/z9/Y17c8WkUAVc+fLlIUmF/zZXkiScP38efn5+RQ6MiKgsKk37wOXn9OnT8PT0NLof5iYiouIh5zYCKSkpOl+m2djYFPy8Z/7OCyEK/Nuf1/VPtzdp0gRNmjTRnm/WrBkaNmyIr776CnPnzi3EOzG/Qu8D97///a9QyzsLIdC5c2ejgiIiKqsE5NnDTcmTFJ/99tUYzE1ERKaXu5KksX0AOTMhCjMbwsXFBRYWFnqjbenp6XqjbLnc3d3zvN7S0hKVKlXK8zkqlQovvfQSLly4UJi3oQiFKuB8fHzQsmXLfN/4s/z8/GBlZWVUYEREVLJVrFgR58+fh4uLS6Gu9/b2xu7du+Hj41Oo65mbiIhKL2trazRq1Ajx8fHo2bOntj0+Ph7du3fP8zlNmzbF+vXrddq2bt2KoKCgfP/+CyGQmJiIwMBA+YI3sUIVcElJSQZ1evLkySIFQ0RU1pWmKZR37tzBpk2b4OzsXKjrb968CbVaXej+mZuIiIqHnFMoDREWFoaBAwciKCgITZs2xaJFi5CcnIzRo0cDyNk/9Nq1a1i+fDkAYPTo0Zg3bx7CwsIwcuRI7Nu3D0uWLMGPP/6o7XPq1Klo0qQJ/P39kZmZiblz5yIxMRFff/21Ue+vOBV6CiUREZleaSrgAGDw4MHmDoGIiIwkqSTjCziV4XmpT58+uHnzJqZNm4bU1FTUrVsXGzdu1M7USE1N1dkTztfXFxs3bsSECRPw9ddfw9PTE3PnzsVrr72mvebOnTt46623kJaWBmdnZzRo0AB//PEHGjdubNT7K05FKuC2b9+O7du3Iz09HRqNRufcd999J0tgRERUsj2bH0yNuYmIqPQZM2YMxowZk+e5uLg4vbZWrVrh6NGj+fY3e/ZszJ49W67wzMLgAm7q1KmYNm0agoKC4OHhYdAKYEREVLDSNgJXXJibiIhMR85FTMh4BhdwCxcuRFxcHAYOHGiKeIiIyjQWcEXD3EREZDqSygKSysLoPkgeBpfC2dnZCAkJMUUsRERERcLcREREZYXBBdyIESOwcuVKU8RCRFTmCSHJdpQlzE1ERCakspDnIFkUagplWFiY9meNRoNFixZh27ZtqFevnt6eCjExMfJGSERUhmggybKRtxx9KB1zExFRMVGpcg5j+yBZFKqAO3bsmM7j+vXrA+CeOkREVDhHjx6FlZWVdqPUX3/9FUuXLkVAQAAiIyNhbW1tcJ/MTUREVBYVqoDbuXOnqeMgIiKU3kVMRo0ahQ8++ACBgYG4dOkS+vbti549e+Lnn3/GgwcPEBsba3CfzE1ERMVDsrCAZGHkIiZGPp/+Y/BY5rBhw3D37l299vv372PYsGGyBEVEVFaV1nvgzp8/rx0h+/nnn9GyZUusXLkScXFxWLNmjdH9MzcREZkQ74FTFIMLuGXLluHhw4d67Q8fPsTy5ctlCYqIiEoXIYR2c+1t27ahc+fOAAAvLy/cuHHD6P6Zm4iIqKwo9D5wmZmZEEJACIG7d+/C1tZWe06tVmPjxo1wdXU1SZBERGVFaZ1CGRQUhOnTp6Ndu3ZISEjAggULAABJSUlwc3Mrcr/MTURExUClMn4EjYuYyKbQBVz58uUhSRIkSUKNGjX0zkuShKlTp8oaHBFRWSPX9EelTaGMjY3FgAED8Msvv2DKlCmoXr06AOB///ufUfu3MTcREZmepFJBMrIAM/b59J9CF3A7d+6EEAIvv/wy1qxZg4oVK2rPWVtbw8fHB56eniYJkoiISrZ69erhxIkTeu1ffPEFLIy4sZ25iYiIyppCF3CtWrXCkydPMGjQIAQFBcHLy8uUcRERlUlCpimUShuBy5WdnY309HTt/XC5vL29i9QfcxMRUTGQZFiEROIiJnIxaCzT0tISa9asgVqtNlU8RERlmgAghAyHud/IM86fP48WLVrAzs4OPj4+8PX1ha+vL6pWrQpfX1+j+mZuIiIyMa5CqSiFHoHL1bZtW+zatQtDhgwxQThERFQaDR06FJaWltiwYQM8PDwgSfKOEDI3ERFRWWFwAdepUydMnjwZJ0+eRKNGjeDg4KBzvlu3brIFR0RU1mggQYIMq1DK0IecEhMTceTIEdSqVcsk/TM3ERGZDhcxURaDC7i3334bABATE6N3TpIkTmEhIjJCaV2FMiAgQJb93vLD3EREZEJyTIHkFErZGFwKazSafA8mSCIiysuMGTMQHh6OXbt24ebNm8jMzNQ5jMXcREREZYXBI3BERGQ6GiFBKoUbebdr1w5Azr1qTxNCcISMiEjpuJG3ohSpgEtISMCXX36JM2fOQJIk1K5dG5MmTUKLFi3kjo+IqEzJXUVSjn6UZOfOnSZ/DeYmIiLTkCwsIBmxZ2duHyQPgwu4H374AUOHDkWvXr0wbtw4CCGwd+9etG3bFnFxcejfv78p4iQiohKsVatWJu2fuYmIiMoKgwu4zz77DDNnzsSECRO0bePHj0dMTAw+/fRTJkkiIiOYYxGTyMhITJ06VafNzc0NaWlp/9+XwNSpU7Fo0SLcvn0bwcHB+Prrr1GnTh2DYrpz5w6WLFmiHSELCAjAsGHD4OzsbFA/eWFuIiIyIZXK+CmQnEIpG4M/yUuXLqFr16567d26dUNSUpIsQRERlVW5BZwchyHq1KmD1NRU7XHixAntuZkzZyImJgbz5s3DoUOH4O7ujvbt2+Pu3buF7v/w4cOoVq0aZs+ejVu3buHGjRuIiYlBtWrVcPToUYNizQtzExGRCXEjb0UxuIDz8vLC9u3b9dq3b98OLy8vWYIiIqLiZWlpCXd3d+1RuXJlADmjb7GxsZgyZQp69eqFunXrYtmyZXjw4AFWrlxZ6P4nTJiAbt264fLly1i7di3WrVuHpKQkdOnSBaGhoUbHz9xERERlhcFTKN977z2MGzcOiYmJCAkJgSRJ2LNnD+Li4jBnzhxTxEhEVGbIvQrls0v029jYwMbGRu/6CxcuwNPTEzY2NggODkZUVBT8/PyQlJSEtLQ0dOjQQaePVq1aYe/evRg1alSh4jl8+DAWL14MS8v/0o6lpSXCw8MRFBRUlLeog7mJiMh0JJUFJCNH0Ix9Pv2nSBt5u7u7Y9asWfjpp58AALVr18bq1avRvXt32QMkIipL5F6F8tnRp4iICERGRuq0BQcHY/ny5ahRowauX7+O6dOnIyQkBKdOndLeB+fm5qbzHDc3N1y5cqXQ8Tg5OSE5ORm1atXSaU9JSYGjo2Oh+8kPcxMRkQlJMtwDJ/EeOLkUaRuBnj17omfPnnLHQkREMktJSYGTk5P2cV6jb506ddL+HBgYiKZNm6JatWpYtmwZmjRpAgCQJN1Rwdz92wqrT58+GD58OL788kudEbJJkyahX79+hr6tPDE3ERFRWVDkjbyzs7ORnp4OjUaj0+7t7W10UEREZVXOCJwcq1Dm/NPJyUmngCsMBwcHBAYG4sKFC+jRowcAIC0tDR4eHtpr0tPT9UblCvLll19CkiQMGjQIT548AQBYWVnh7bffxueff25QfAVhbiIikh+nUCqLwQXchQsXMGzYMOzdu1enPffbWLVaLVtwRERljTm2EXhWVlYWzpw5gxYtWsDX1xfu7u6Ij49HgwYNAOQUSQkJCZgxY0ah+7S2tsacOXMQHR2NixcvQgiB6tWrw97evshxPo25iYjIhFQq41eR5DYCsjG4gBsyZAgsLS2xYcMGeHh4GDSFhoiIlGfixIno2rUrvL29kZ6ejunTpyMzMxODBw+GJEkIDQ1FVFQU/P394e/vj6ioKNjb2xdpbzV7e3sEBgbK/h6Ym4iIqKwwuIBLTEzEkSNH9G5EJyIi44n/P+Top7CuXr2Kfv364caNG6hcuTKaNGmC/fv3w8fHBwAQHh6Ohw8fYsyYMdqNvLdu3frcxUd69eqFuLg4ODk5oVevXgVeu3btWgMi1sfcRERkQtzIW1EMLuACAgJw48YNU8RCRFTmmWMK5apVqwo8L0kSIiMj9VavfB5nZ2ftSJiTk5NJR8WYm4iITEeysIBkYeQ9cEY+n/5jcAE3Y8YMhIeHIyoqCoGBgbCystI5b+jN8kREVDotXbpU+3NcXJxJX4u5iYiIygqDC7h27doBANq2bavTzhvFiYhkYI45lMXg5Zdfxtq1a1G+fHmd9szMTPTo0QM7duwwqn/mJiIiE1JZyLCICUfg5GJwAbdz505TxEFERAAg0xRKyNGHjHbt2oXs7Gy99kePHmH37t1G98/cRERkQizgFMXgAq5Vq1amiIOIiEqh48ePa38+ffo00tLStI/VajU2b96MF154wejXYW4iIqKyosgbeRMRkfxyNvKWpx8lqF+/PiRJgiRJePnll/XO29nZ4auvvjJDZEREVFiSSgXJyFUkjX0+/YcFHBGRgihhI285JSUlQQgBPz8/HDx4EJUrV9aes7a2hqurKyy4MhkRkbJJMkyhlPi3Xi5lp4A7dBKQrJ5/XQk06fuh5g7B5GyCb5k7BJNSfXbW3CGYnEuCuSMwnSfisblDUKzcveQ0Go2ZI6Hi9skrpX9Pvow21c0dAhmh9tLfzB2CSWVmZgIrnc0dBplA2SngiIhKAiHJswCJQkbgnnX69GkkJyfrLWjSrVs3M0VERETPJUmAZOQUSBPuBVrWGFzAPXz4EEII2NvbAwCuXLmCdevWISAgAB06dJA9QCKisqS03QOX69KlS+jZsydOnDgBSZIg/j/A3M29jV3mn7mJiMiEJJUMBRzvgZOLwZ9k9+7dsXz5cgDAnTt3EBwcjFmzZqF79+5YsGCB7AESEVHJN378ePj6+uL69euwt7fHqVOn8McffyAoKAi7du0yun/mJiIiKisMLuCOHj2KFi1aAAD+97//wc3NDVeuXMHy5csxd+5c2QMkIipThIyHguzbtw/Tpk1D5cqVoVKpoFKp0Lx5c0RHR2PcuHFG98/cRERkOkJSyXKQPAz+JB88eABHR0cAwNatW9GrVy+oVCo0adIEV65ckT1AIqKyJHcVSjkOJVGr1ShXrhwAwMXFBf/88w+AnEVOzp07Z3T/zE1ERCaUO4XS2INkYfAnWb16dfzyyy9ISUnBli1btPcWpKenw8nJSfYAiYio5Ktbt652U+/g4GDMnDkTf/75J6ZNmwY/Pz+j+2duIiKissLgAu6TTz7BxIkTUbVqVTRu3BhNmzYFkPONZ4MGDWQPkIiozCll0ycB4KOPPtJuJTB9+nRcuXIFLVq0wMaNG2WZ4sjcRERkQpIkz0GyMHgVytdffx3NmzdHamoqXnzxRW1727Zt0bNnT1mDIyIqa0rbRt65OnbsqP3Zz88Pp0+fxq1bt1ChQgXtSpTGYG4iIjIhlSrnMLYPkkWRPkl3d3c4OjoiPj4eDx8+BAC89NJLqFWr9G/aSUREhlu2bBnu37+v01axYkVZirdczE1ERFQWGFzA3bx5E23btkWNGjXQuXNnpKamAgBGjBiB9957T/YAiYjKlFK6CuXEiRPh6uqKvn37YsOGDXjy5Ims/TM3ERGZDlehVBaDP8kJEybAysoKycnJ2g1TAaBPnz7YvHmzrMEREZU9koyHcqSmpmL16tWwsLBA37594eHhgTFjxmDv3r2y9M/cRERkQlyFUlEM/iS3bt2KGTNmoEqVKjrt/v7+Bi/VHBkZCUmSdA53d3ed87Vq1YKDgwMqVKiAdu3a4cCBA4aGTEREZmZpaYkuXbpgxYoVSE9PR2xsLK5cuYI2bdqgWrVqRvcvV25iXiIiIqUzeBGT+/fv63y7mevGjRuwsbExOIA6depg27Zt2scWFhban2vUqIF58+bBz88PDx8+xOzZs9GhQwf8/fffqFy5ssGvRUSkeHJNf1TYFMqn2dvbo2PHjrh9+zauXLmCM2fOGN2nnLmJeYmI6BlyjKBxBE42Bn+SLVu2xPLly7WPJUmCRqPBF198gTZt2hgcgKWlJdzd3bXH0wmwf//+aNeuHfz8/FCnTh3ExMQgMzNTu5cQEVGpU0rvgQNyNttesWIFOnfuDE9PT8yePRs9evTAyZMnje5bztzEvERE9AxOoVQUg0fgvvjiC7Ru3RqHDx9GdnY2wsPDcerUKdy6dQt//vmnwQFcuHABnp6esLGxQXBwMKKiovLc1DU7OxuLFi2Cs7OzzhLRz8rKykJWVpb2cWZmpsExERGRvPr164f169fD3t4eb7zxBnbt2oWQkBDZ+pczN8mdlwDmJiIiko/BpXBAQACOHz+Ol156Ce3bt8f9+/fRq1cvHDt2zOD7GIKDg7F8+XJs2bIFixcvRlpaGkJCQnDz5k3tNRs2bEC5cuVga2uL2bNnIz4+Hi4uLvn2GR0dDWdnZ+3h5eVl6FskIjIfIcl3KIgkSVi9ejX++ecffP3117IWb4B8uckUeQlgbiKikk1IkgyrUCorL5VkkhBCMRNt7t+/j2rVqiE8PBxhYWHattTUVNy4cQOLFy/Gjh07cODAAbi6uubZR17fcnp5eaE1usNSsiqW91HcUiLk/R8hJbJpdMvcIZiUa7ez5g6BjPBEPMYu/IqMjAw4OTkVqY/MzEw4OzujyrypUNnZGh2T5uEjXH0nwqiY5PL48WN06NAB33zzDWrUqGHWWAwlR14C8s9NSvj9mMqh5NvmDsHkMrLk3Q5Dadr5877Okiw3r8iRm25c+AtOjo7GxXP3Llz8XyzVf/eKS5Emo+7evRtvvvkmQkJCcO3aNQDA999/jz179hgVjIODAwIDA3HhwgWdturVq6NJkyZYsmQJLC0tsWTJknz7sLGxgZOTk85BRETmY2VlhZMnT8q6aXdeTJGb5MhLAHMTERHJx+ACbs2aNejYsSPs7Oxw9OhR7TeKd+/eRVRUlFHBZGVl4cyZM/Dw8Mj3GiGEzreYRESlSildxGTQoEHPLXKMYarcxLxERARAkuQ5SBYGL2Iyffp0LFy4EIMGDcKqVau07SEhIZg2bZpBfU2cOBFdu3aFt7c30tPTMX36dGRmZmLw4MG4f/8+PvvsM3Tr1g0eHh64efMm5s+fj6tXr+KNN94wNGwiopJBrvvXFHYPXHZ2Nr799lvEx8cjKCgIDg4OOudjYmKM6l+u3MS8RESUB24joCgGF3Dnzp1Dy5Yt9dqdnJxw584dg/q6evUq+vXrhxs3bqBy5cpo0qQJ9u/fDx8fHzx69Ahnz57FsmXLcOPGDVSqVAkvvfQSdu/ejTp16hgaNhERmdHJkyfRsGFDAMD58+d1zskxtVKu3MS8RERESmdwAefh4YG///4bVatW1Wnfs2dPnsssF+Tpb0mfZWtri7Vr1xoaHhFRiSaJnEOOfpRk586dJu1frtzEvEREpC93JUlj+yB5GPxJjho1CuPHj8eBAwcgSRL++ecfrFixAhMnTsSYMWNMESMRUdlRSu+By/X3339jy5YtePjwIYCc+8fkwNxERGRCkgpQGXmwgJONwSNw4eHhyMjIQJs2bfDo0SO0bNkSNjY2mDhxIt555x1TxEhERCXczZs30bt3b+zcuROSJOHChQvw8/PDiBEjUL58ecyaNcuo/pmbiIiorDCoFFar1UhISMB7772HGzdu4ODBg9i/fz/+/fdffPrpp6aKkYio7CilG3lPmDABVlZWSE5Ohr29vba9T58+2Lx5s1F9MzcREZlY7iImxh4kC4NG4CwsLNCxY0ecOXMGFStWRFBQkKniIiIqm+Sa/qiwKZRbt27Fli1bUKVKFZ12f39/XLlyxai+mZuIiEyMq1AqisGfZGBgIC5dumSKWIiIqJS6f/++zshbrhs3bsDGxsbo/pmbiIiorDC4gPvss88wceJEbNiwAampqcjMzNQ5iIjICKV0EZOWLVti+fLl2seSJEGj0eCLL75AmzZtjO6fuYmIyIQ4hdIomzdvxp49e7SPv/76a9SvXx/9+/fH7du3De7P4EVMXnnlFQBAt27ddPbuEUJAkiSo1WqDgyAiov9XSqdQfvHFF2jdujUOHz6M7OxshIeH49SpU7h16xb+/PNPo/tnbiIiMh0hSTJsI6Cse7OL06RJkzBjxgwAwIkTJ/Dee+8hLCwMO3bsQFhYGJYuXWpQfwYXcKbey4eIiEqfgIAAHD9+HAsWLICFhQXu37+PXr16YezYsfDw8DC6f+YmIiJSqqSkJAQEBAAA1qxZgy5duiAqKgpHjx5F586dDe7P4AKuVatWBr8IEREVklwrSCpsFUoAcHd3x9SpU03SN3MTEZEJcRETo1hbW+PBgwcAgG3btmHQoEEAgIoVKxZpmr/BBdzx48fzbJckCba2tvD29pblhnQiorJIEjmHHP0UVXR0ND788EOMHz8esbGxAHKmIk6dOhWLFi3C7du3ERwcjK+//hp16tQpVJ+bN29GuXLl0Lx5cwA58/8XL16MgIAAfP3116hQoULRAwZzExGRSUlSzmFsH2VU8+bNERYWhmbNmuHgwYNYvXo1AOD8+fN6qzMXhsEFXP369XXuL3iWlZUV+vTpg2+++Qa2trYGB0REROZz6NAhLFq0CPXq1dNpnzlzJmJiYhAXF4caNWpg+vTpaN++Pc6dOwdHR8fn9vvs/P+wsDC89957RZ7//yzmJiIiUqp58+ZhzJgx+N///ocFCxbghRdeAABs2rRJew+3IQwey1y3bh38/f2xaNEiJCYm4tixY1i0aBFq1qyJlStXYsmSJdixYwc++ugjg4MhIirzzLgK5b179zBgwAAsXrxYZ0RMCIHY2FhMmTIFvXr1Qt26dbFs2TI8ePAAK1euLFTfz87/79q1K6KiojB//nxs2rTJ8GCfwdxERGRCZlyFcv78+fD19YWtrS0aNWqE3bt3F3h9QkICGjVqBFtbW/j5+WHhwoV616xZswYBAQGwsbFBQEAA1q1bV6TYCsvb2xsbNmzAX3/9heHDh2vbZ8+ejblz5xrcn8EjcJ999hnmzJmDjh07atvq1auHKlWq4OOPP8bBgwfh4OCA9957D19++aXBARERkXyenVtvY2OT71TCsWPH4tVXX0W7du0wffp0bXtSUhLS0tLQoUMHnX5atWqFvXv3YtSoUc+NQ+75/89ibiIiMh0hqWRYhdLw569evRqhoaGYP38+mjVrhm+++QadOnXC6dOn4e3trXd9UlISOnfujJEjR+KHH37An3/+iTFjxqBy5cp47bXXAAD79u1Dnz598Omnn6Jnz55Yt24devfujT179iA4ONio91gYDx8+xOPHj3XanJycDOrD4E/yxIkT8PHx0Wv38fHBiRMnAORMZUlNTTW0ayIikpmXlxecnZ21R3R0dJ7XrVq1CkePHs3zfFpaGgDAzc1Np93NzU177nly5/9/+umnOHjwIF599VUARZ///yzmJiKi0icmJgbDhw/HiBEjULt2bcTGxsLLywsLFizI8/qFCxfC29sbsbGxqF27NkaMGIFhw4bpfHEXGxuL9u3bY/LkyahVqxYmT56Mtm3bau/5NoX79+/jnXfegaurK8qVK4cKFSroHIYyuICrVasWPv/8c2RnZ2vbHj9+jM8//xy1atUCAFy7dk0v0RMR0fNJ+G8hE6OO/+8vJSUFGRkZ2mPy5Ml6r5mSkoLx48fjhx9+KPD+sGfvMcvdY60w5s2bB0tLS9nm/z+LuYmIyIRknEKZmZmpc2RlZeX5ktnZ2Thy5IjO7A8A6NChA/bu3Zvnc/bt26d3fceOHXH48GHtqFd+1+TXpxzCw8OxY8cOzJ8/HzY2Nvj2228xdepUeHp6Yvny5Qb3Z/AUyq+//hrdunVDlSpVUK9ePUiShOPHj0OtVmPDhg0AgEuXLmHMmDEGB0NEVObJvI2Ak5PTc6dmHDlyBOnp6WjUqJG2Ta1W448//sC8efNw7tw5ADkjcU/v2Zaenl7ogih3/v+zZs+eXajnPw9zExGR6eRs5G1cbsp9vpeXl057REQEIiMj9a6/ceMG1Gq1QbM/0tLS8rz+yZMnuHHjBjw8PPK9prAzSopi/fr1WL58OVq3bo1hw4ahRYsWqF69Onx8fLBixQoMGDDAoP4MLuBCQkJw+fJl/PDDDzh//jyEEHj99dfRv39/7UpkAwcONLRbIiIyk7Zt22qnGeYaOnQoatWqhffffx9+fn5wd3dHfHw8GjRoACDnm9GEhATtypKFoVarsW7dOpw5cwaSJKFWrVro0aMHLC0NTkV6mJuIiEqGlJQUnS8Wn7fFi6GzP/K6/tl2Y2aUFMWtW7fg6+sLIOeL1Vu3bgHIub3g7bffNri/ImXNcuXKYfTo0UV5KhERFaSIK0jm2U8hOTo6om7dujptDg4OqFSpkrY9NDQUUVFR8Pf3h7+/P6KiomBvb4/+/fsX6jVOnjyJbt264fr166hZsyaAnPvfKleujN9++w2BgYGFDzgfzE1ERKYhRM5hbB9A4WaGAICLiwssLCz0RsYKmv3h7u6e5/WWlpaoVKlSgdeYcoq9n58fLl++DB8fHwQEBOCnn35C48aNsX79epQvX97g/oq0nMz333+P5s2bw9PTE1euXAGQMw3m119/LUp3RESUy4zbCBQkPDwcoaGhGDNmDIKCgnDt2jVs3bq1UHvAAcCIESNQt25dXL16FUePHsXRo0eRkpKCevXq4a233pIlRuYmIiLT0Aghy2EIa2trNGrUCPHx8Trt8fHxCAkJyfM5TZs21bt+69atCAoKgpWVVYHX5NenHIYOHYq//voLADB58mTtvXATJkzApEmTDO7P4AJuwYIFCAsLQ6dOnXD79m2o1WoAQIUKFUy6egsRERWfXbt26fxNlyQJkZGRSE1NxaNHj5CQkKA3aleQv/76C9HR0TqrbVWoUAGfffYZEhMTjY6XuYmIqPQJCwvDt99+i++++w5nzpzBhAkTkJycrJ1tMXnyZO22NAAwevRoXLlyBWFhYThz5gy+++47LFmyBBMnTtReM378eGzduhUzZszA2bNnMWPGDGzbtg2hoaEmex8TJkzAuHHjAABt2rTB2bNn8eOPP+Lo0aMYP368wf0ZXMB99dVXWLx4MaZMmaJz30JQUJDePRRERGQYWVag/P9DSWrWrInr16/rtaenp6N69epG98/cRERkOuaaGNKnTx/ExsZi2rRpqF+/Pv744w9s3LhRu21MamoqkpOTtdf7+vpi48aN2LVrF+rXr49PP/0Uc+fO1e4BB+TcM71q1SosXboU9erVQ1xcHFavXl0se8Dl8vb2Rq9evfDiiy8W6fkG3wOXlJSkvYn9aTY2Nrh//36RgiAiov9nhnvgTOXpDbqjoqIwbtw4REZGokmTJgCA/fv3Y9q0aQYthJIf5iYiItPRiJzD2D6KYsyYMfmuIBwXF6fX1qpVKxw9erTAPl9//XW8/vrrRQuokObOnYu33noLtra2mDt3boHX5o7OFZbBBZyvry8SExP1NkzdtGkTAgICDO2OiIhKqfLly+us6iWEQO/evbVtuSuDde3aVTvlsaiYm4iISElmz56NAQMGwNbWtsAtcyRJMn0BN2nSJIwdOxaPHj2CEAIHDx7Ejz/+iOjoaHz77beGdkdERE8rRSNwO3fuLLbXYm4iIjIdIYT2Szdj+ihLkpKS8vw5r20NDGVwATd06FA8efIE4eHhePDgAfr3748XXngBc+bMQd++fYscCBERyXf/mhLugWvVqlWxvRZzExGR6ZhzCmVpsWTJEsyePRsXLlwAAPj7+yM0NBQjRowwuK8i7QM3cuRIjBw5Ejdu3IBGo4Grq2tRuiEiojLkzp07WLJkiXYj74CAAAwbNgzOzs6y9M/cRERESvTxxx9j9uzZePfdd9G0aVMAwL59+zBhwgRcvnwZ06dPN6i/IhVwuVxcXIx5OhERPUtIOYcc/SjI4cOH0bFjR9jZ2aFx48YQQiAmJgafffYZtm7dioYNG8r2WsxNRETyK+MDaEZZsGABFi9ejH79+mnbunXrhnr16uHdd981TQHXoEGDQs/TfN6qL0REVIBSdA/c0yZMmIBu3bph8eLF2mX+nzx5ghEjRiA0NBR//PGHwX0yNxERFQ9OoTSOWq1GUFCQXnujRo3w5MkTg/srVAHXo0cP7c+PHj3C/PnzERAQoB0C3L9/P06dOpXvEp9ERFS2HT58WKd4AwBLS0uEh4fnmdQKg7mJiIhKgjfffBMLFixATEyMTvuiRYswYMAAg/srVAEXERGh/XnEiBEYN24cPv30U71rUlJSDA6AiIj+U5oWMXmak5MTkpOTUatWLZ32lJQUODo6FqlP5iYiouLBVSgNFxYWpv1ZkiR8++232Lp1q85eqCkpKRg0aJDBfRt8D9zPP/+Mw4cP67W/+eabCAoKwnfffWdwEERE9P9K6RTKPn36YPjw4fjyyy8REhICSZKwZ88eTJo0SeeegKJibiIiMh3N/x/G9lGWHDt2TOdxo0aNAAAXL14EAFSuXBmVK1fGqVOnDO7b4ALOzs4Oe/bsgb+/v077nj17YGtra3AARERU+n355ZeQJAmDBg3Szve3srLC22+/jc8//9zo/pmbiIhISUy5F6rBBVxoaCjefvttHDlyRGcI8LvvvsMnn3wie4BERGWKTFMolTYCZ21tjTlz5iA6OhoXL16EEALVq1eHvb29LP0zNxERmY4QOYexfZA8DC7gPvjgA/j5+WHOnDlYuXIlAKB27dqIi4tD7969ZQ+QiKhMKaVTKHPZ29sjMDBQ9n6Zm4iITIerUCpLkfaB6927NxMiEREpCnMTERGVBUZt5E1ERDIr5SNwRERU8nAVSmVRFeaiihUr4saNG4Xu1NvbG1euXClyUEREZVXuNgJyHKUdcxMRUfHQyHSQPAo1Anfnzh1s2rQJzs7Oher05s2bUKvVRgVGREQlW8OGDbF9+3ZUqFAB06ZNw8SJE2VbtARgbiIiorKp0FMoBw8ebMo4iIiolDlz5gzu37+PChUqYOrUqRg9erSsBRzA3EREVBwEZFiFUpZICChkAafRcNCTiKhYlKJ74OrXr4+hQ4eiefPmEELgyy+/RLly5fK8tihL/TM3EREVD40Q0BhZwRn7fPoPFzEhIiKTiIuLQ0REBDZs2ABJkrBp0yZYWuqnHUmSuFcbERFRIbGAIyJSELkWIFHCIiY1a9bEqlWrAAAqlQrbt2+Hq6urmaMiIiJDyTE5RAFpqdRgAUdEpDSlMMtxuiMRUcnFjbyVhQUcEREVi4sXLyI2NhZnzpyBJEmoXbs2xo8fj2rVqpk7NCIiohKjUPvAERFRMREyHgqyZcsWBAQE4ODBg6hXrx7q1q2LAwcOoE6dOoiPjzd3eEREVBCRswqlMYfS8lJJVqQRuIsXL2Lp0qW4ePEi5syZA1dXV2zevBleXl6oU6eO3DESEZUZpekeuKd98MEHmDBhAj7//HO99vfffx/t27c3+jWYm4iITEMDAY2RFZixz6f/GDwCl5CQgMDAQBw4cABr167FvXv3AADHjx9HRESE7AESEVHJd+bMGQwfPlyvfdiwYTh9+rTR/TM3ERFRWWFwAffBBx9g+vTpiI+Ph7W1tba9TZs22Ldvn6zBERGVOaV0CmXlypWRmJio156YmCjLypTMTUREpmPs9EntNEqShcFTKE+cOIGVK1fqtVeuXBk3b96UJSgiorKqtE6hHDlyJN566y1cunQJISEhkCQJe/bswYwZM/Dee+8Z3T9zExGR6XAVSmUxuIArX748UlNT4evrq9N+7NgxvPDCC7IFRkREpcfHH38MR0dHzJo1C5MnTwYAeHp6IjIyEuPGjTO6f+YmIiIqKwyeQtm/f3+8//77SEtLgyRJ0Gg0+PPPPzFx4kQMGjTIFDESEZUdpXQKpSRJmDBhAq5evYqMjAxkZGTg6tWrGD9+PCRJMrp/5iYiItPhFEplMbiA++yzz+Dt7Y0XXngB9+7dQ0BAAFq2bImQkBB89NFHpoiRiKjsKKUF3NMcHR3h6Ogoa5/MTUREppO7CqWxB8nD4CmUVlZWWLFiBaZNm4Zjx45Bo9GgQYMG8Pf3N0V8REREz8XcREREZUWR9oEDgGrVqqFatWpyxkJEVOaV1kVMigtzExGR/OSYAskplPIpVAEXFhZW6A5jYmKKHAwVjQi8a+4QTM4zXG3uEEzqibkDIOWQa/pjGUiUzE3KVrW8jblDMLnKThXMHQJRsdAIAY2RFZixz6f/FKqAO3bsmM7jI0eOQK1Wo2bNmgCA8+fPw8LCAo0aNZI/QiIiKtEeP36MDh064JtvvkGNGjVk65e5iYiIyqJCFXA7d+7U/hwTEwNHR0csW7YMFSrkfPN0+/ZtDB06FC1atDBNlEREZUUpHIGzsrLCyZMnZVlt8mnMTURExUOtyTmM7YPkYfAqlLNmzUJ0dLQ2QQJAhQoVMH36dMyaNUvW4IiIyprce+DkOJRk0KBBWLJkicn6Z24iIjKd3CmUxh4kD4MLuMzMTFy/fl2vPT09HXfvlv57sYiISpsFCxagXr16cHJygpOTE5o2bYpNmzZpzwshEBkZCU9PT9jZ2aF169Y4deqUQa+RnZ2NBQsWoFGjRhg1ahTCwsJ0DmMxNxERUVlh8CqUPXv2xNChQzFr1iw0adIEALB//35MmjQJvXr1kj1AIqIyxQxTKKtUqYLPP/8c1atXBwAsW7YM3bt3x7Fjx1CnTh3MnDkTMTExiIuLQ40aNTB9+nS0b98e586dK/R+bidPnkTDhg0B5Nyb9jQ5plYyNxERmY5GCKi5iIliGFzALVy4EBMnTsSbb76Jx48f53RiaYnhw4fjiy++kD1AIqKyxBzbCHTt2lXn8WeffYYFCxZg//79CAgIQGxsLKZMmaIthJYtWwY3NzesXLkSo0aNKtRrPH2/mikwNxERmY5GGF+AaVi/ycbgAs7e3h7z58/HF198gYsXL0IIgerVq8PBwcEU8RERkREyMzN1HtvY2MDGJv/l3dVqNX7++Wfcv38fTZs2RVJSEtLS0tChQwedPlq1aoW9e/cWuoDL9ffff+PixYto2bIl7OzsIISQZQSOuYmIiMqKIm/k7eDggHr16skZCxERyTyF0svLS6c5IiICkZGRepefOHECTZs2xaNHj1CuXDmsW7cOAQEB2Lt3LwDAzc1N53o3NzdcuXKl0OHcvHkTvXv3xs6dOyFJEi5cuAA/Pz+MGDEC5cuXl22hEeYmIiL5cRVKZTG4gGvTpk2B35bu2LGj0H1FRkZi6tSpOm1ubm5IS0vD48eP8dFHH2Hjxo24dOkSnJ2d0a5dO3z++efw9PQ0NGwiopJB5gIuJSUFTk5O2ub8Rt9q1qyJxMRE3LlzB2vWrMHgwYORkJCgPf/s331DR84mTJgAKysrJCcno3bt2tr2Pn36YMKECUYXcHLlJuYlIiJ93MhbWQwu4OrXr6/z+PHjx0hMTMTJkycxePBggwOoU6cOtm3bpn1sYWEBAHjw4AGOHj2Kjz/+GC+++CJu376N0NBQdOvWDYcPHzb4dYiIyqLclSWfx9raWruISVBQEA4dOoQ5c+bg/fffBwCkpaXBw8NDe316erreqFxBtm7dii1btqBKlSo67f7+/gaN5OVHztzEvEREREpmcAE3e/bsPNsjIyNx7949wwOwtIS7u7teu7OzM+Lj43XavvrqKzRu3BjJycnw9vY2+LWIiJRO+v9Djn6MIYRAVlYWfH194e7ujvj4eDRo0ABAzpYACQkJmDFjRqH7u3//Puzt7fXab9y4UeA9eYUlZ25iXiIi0qWWYRVKY59P/zF4H7j8vPnmm/juu+8Mft6FCxfg6ekJX19f9O3bF5cuXcr32oyMDEiShPLly+d7TVZWFjIzM3UOIqISQ8h4FNKHH36I3bt34/Llyzhx4gSmTJmCXbt2YcCAAZAkCaGhoYiKisK6detw8uRJDBkyBPb29ujfv3+hX6Nly5ZYvny59rEkSdBoNPjiiy/Qpk2bwgdroKLkJrnzEsDcREQlmwa5K1EacZj7TZQiRV7E5Fn79u2Dra2tQc8JDg7G8uXLUaNGDVy/fh3Tp09HSEgITp06hUqVKulc++jRI3zwwQfo379/gdOBoqOj9e5fICKi/F2/fh0DBw5EamoqnJ2dUa9ePWzevBnt27cHAISHh+Phw4cYM2YMbt++jeDgYGzdurXQe8ABwBdffIHWrVvj8OHDyM7ORnh4OE6dOoVbt27hzz//NNVbMzg3mSIvAcxNREQkH0kIw8Yzn90QVQiB1NRUHD58GB9//DEiIiKKHMz9+/dRrVo1hIeHIywsTNv++PFjvPHGG0hOTsauXbsKTJRZWVnIysrSPs7MzISXlxdaozssJasix6Zkyf8LNHcIJuf30SNzh2BST85eMHcIZIQn4jF24VdkZGQU6n6zvGRmZsLZ2Rl1RkfBwsawL8Pyos56hFMLPzQqJrmlpaVhwYIFOHLkCDQaDRo2bIixY8fq3FtXVKbKTXLkJSD/3KSk34/c/s18YO4QTK6yk/60YCKlyM0rcuSmNYf/hkO5wn9pl5f79+7itaDqpfrvXnExeATOyclJZ6UvlUqFmjVrYtq0aTr7BBWFg4MDAgMDceHCf/8z+/jxY/Tu3RtJSUnYsWPHc3/hz9vjiIhI0WRehVJJ3N3dTTYKZarcJEdeApibiKhkEzKsQmngmBEVwOACLi4uzgRh5MjKysKZM2fQokULAP8lyQsXLmDnzp1601eIiKjkuH37NpYsWYIzZ85AkiTUrl0bQ4cORcWKFY3u21S5iXmJiIiUxuBFTPz8/HDz5k299jt37sDPz8+gviZOnIiEhAQkJSXhwIEDeP3115GZmYnBgwfjyZMneP3113H48GGsWLECarUaaWlpSEtLQ3Z2tqFhExGVHMW4gElxSUhIgK+vL+bOnYvbt2/j1q1bmDt3Lnx9fXX2mysquXIT8xIRkT61kOcgeRg8Anf58mWo1Wq99qysLFy7ds2gvq5evYp+/frhxo0bqFy5Mpo0aYL9+/fDx8cHly9fxm+//QZAf3+fnTt3onXr1oaGTkSkeJLIOeToR0nGjh2L3r17Y8GCBdp91dRqNcaMGYOxY8fi5MmTRvUvV25iXiIi0seNvJWl0AVcbtICgC1btsDZ2Vn7WK1WY/v27ahatapBL75q1ap8z1WtWpVzZYmISomLFy9izZo12uINyNkgOywsTGd7AUPJnZuYl4iISOkKXcD16NEDQM7ePYMHD9Y5Z2VlhapVq2LWrFmyBkdEVOaU0kVMGjZsiDNnzqBmzZo67WfOnNEbzTIEcxMRkempNQJqjZEbeRv5fPpPoQs4jSZn+z1fX18cOnQILi4uJguKiKisKk1TKI8fP679edy4cRg/fjz+/vtvNGnSBACwf/9+fP311/j888+L/BrMTUREpscplMpi8D1wSUlJpoiDiIhKmfr160OSJJ1ph+Hh4XrX9e/fH3369DHqtZibiIiorChUATd37ly89dZbsLW1xdy5cwu8dty4cbIERkRUJpWiKZSmLqqYm4iIioccq0hyFUr5FKqAmz17NgYMGABbW1vMnj073+skSWKSJCIyQmmaQunj42PS/pmbiIiKB6dQKkuhCrinv0XlNBUiIiqKa9eu4c8//0R6err23rVcRSmwmJuIiKgsMvgeuGnTpmHixImwt7fXaX/48CG++OILfPLJJ7IFR0RU5pSiKZRPW7p0KUaPHg1ra2tUqlQJkiRpz8kxQsbcRERkOhqNgMbIVSSNfT79R2XoE6ZOnYp79+7ptT948ABTp06VJSgiojJLyHgoyCeffIJPPvkEGRkZuHz5MpKSkrTHpUuXjO6fuYmIyHQ04r/74Ip6sH6Tj8EFnBBC55vTXH/99RcqVqwoS1BERFS6PHjwAH379oVKZXDaKRTmJiIiKisKPYWyQoUKkCQJkiShRo0aOolSrVbj3r17GD16tEmCJCIqK0rTIiZPGz58OH7++Wd88MEHsvbL3EREZHpcxERZCl3AxcbGQgiBYcOGYerUqXB2dtaes7a2RtWqVdG0aVOTBElEVGaU0nvgoqOj0aVLF2zevBmBgYGwsrLSOR8TE1OkfpmbiIhMTy0E1EYWYMY+n/5T6AJu8ODBAABfX1+EhIToJV8iIqL8REVFYcuWLahZsyYA6C1iUlTMTUREVNYYvAplq1attD8/fPgQjx8/1jnv5ORkfFRERGWUJAQkGb6llKMPOcXExOC7777DkCFDTNI/cxMRkelwFUplMfhu8gcPHuCdd96Bq6srypUrhwoVKugcRERkhFK6CqWNjQ2aNWtmsv6Zm4iITEcN41ehVJv7TZQiBhdwkyZNwo4dOzB//nzY2Njg22+/xdSpU+Hp6Ynly5ebIkYiIirhxo8fj6+++spk/TM3ERFRWWHwFMr169dj+fLlaN26NYYNG4YWLVqgevXq8PHxwYoVKzBgwABTxElEVCaU1lUoDx48iB07dmDDhg2oU6eO3r1qa9euNap/5iYiItPhKpTKYnABd+vWLfj6+gLIuafg1q1bAIDmzZvj7bffljc6IqKyppSuQlm+fHn06tXLZP0zNxERmQ5XoVQWgws4Pz8/XL58GT4+PggICMBPP/2Exo0bY/369ShfvrwJQiQiopJu6dKlJu2fuYmIiMoKg++BGzp0KP766y8AwOTJk7X3G0yYMAGTJk2SPUAiorIkdwqlHEdZwtxERGQ6Go2A2siDq1DKx+ARuAkTJmh/btOmDc6ePYvDhw+jWrVqePHFF2UNjoiozCmlUyh9fX0L3O/t0qVLRvXP3EREZDq5RZixfZA8DC7gnuXt7Q1vb2+kpKRg2LBh+O677+SIi4iISpHQ0FCdx48fP8axY8ewefNmk4yQMTcREVFpZfAUyvzcunULy5Ytk6s7IqIyqbROoRw/frzOMXHiRKxYsQLTpk3DuXPnTPa6zE1ERMYzdvqkHCN4z3P79m0MHDgQzs7OcHZ2xsCBA3Hnzp0CnyOEQGRkJDw9PWFnZ4fWrVvj1KlTOte0bt0akiTpHH379jXhO3k+2Qo4IiKSQSndyDs/nTp1wpo1a8wdBhERFUCtkaOIM22M/fv3R2JiIjZv3ozNmzcjMTERAwcOLPA5M2fORExMDObNm4dDhw7B3d0d7du3x927d3WuGzlyJFJTU7XHN998Y8q38lxGT6EkIiIqqv/973+oWLGiucMgIqIS7MyZM9i8eTP279+P4OBgAMDixYvRtGlTnDt3DjVr1tR7jhACsbGxmDJlinabm2XLlsHNzQ0rV67EqFGjtNfa29vD3d29eN5MIbCAIyJSGKVNf5RDgwYNdBYxEUIgLS0N//77L+bPn2/GyIiI6HnkXMQkMzNTp93GxgY2NjZG9b1v3z44OztrizcAaNKkCZydnbF37948C7ikpCSkpaWhQ4cOOrG0atUKe/fu1SngVqxYgR9++AFubm7o1KkTIiIi4OjoaFTMxih0Afe8DVifN8eUiIgKQYicQ45+FKRHjx46j1UqFSpXrozWrVujVq1aRe6XuYmIyPTkLOC8vLx02iMiIhAZGWlU32lpaXB1ddVrd3V1RVpaWr7PAQA3Nzeddjc3N1y5ckX7eMCAAfD19YW7uztOnjyJyZMn46+//kJ8fLxRMRuj0AWcs7Pzc88PGjTI6ICIiKj0iYiIMEm/zE1ERCVLSkoKnJyctI8LGn2LjIzE1KlTC+zv0KFDAJDnVjVCiAK3sMnrec8+Z+TIkdqf69atC39/fwQFBeHo0aNo2LBhgX2bSqELuKVLl5oyDiIignwrSJbGaZh5YW4iIjI9jQwjcLkbeTs5OekUcAV55513nrviY9WqVXH8+HFcv35d79y///6rN8KWK/eetrS0NHh4eGjb09PT830OADRs2BBWVla4cOGC8gs4IiIqBqVsI2+VSlWobz+fPHlSTBEREZGh1EKGKZRFmNrv4uICFxeX517XtGlTZGRk4ODBg2jcuDEA4MCBA8jIyEBISEiez8mdFhkfH48GDRoAALKzs5GQkIAZM2bk+1qnTp3C48ePdYq+4sYCjoiITGbdunX5ntu7dy+++uorCIXdr0dERCVL7dq18corr2DkyJHaJf7feustdOnSRWcBk1q1aiE6Oho9e/aEJEkIDQ1FVFQU/P394e/vj6ioKNjb26N///4AgIsXL2LFihXo3LkzXFxccPr0abz33nto0KABmjVrZpb3CrCAIyJSFEmTc8jRjxJ0795dr+3s2bOYPHky1q9fjwEDBuDTTz81Q2RERFRYci5iYiorVqzAuHHjtKtKduvWDfPmzdO55ty5c8jIyNA+Dg8Px8OHDzFmzBjcvn0bwcHB2Lp1q3aFSWtra2zfvh1z5szBvXv34OXlhVdffRURERGwsLAw6fspCAs4IiIlKWVTKJ/2zz//ICIiAsuWLUPHjh2RmJiIunXrmjssIiJ6jpJQwFWsWBE//PBDgdc8O+NDkiRERkbmuwqml5cXEhIS5ApRNipzB0BEROYVHR2Nl156CY6OjnB1dUWPHj1w7tw5nWuEEIiMjISnpyfs7OzQunVrnDp1qlD9Z2Rk4P3330f16tVx6tQpbN++HevXr2fxRkREVAQs4IiIFCR3FUo5jsJKSEjA2LFjsX//fsTHx+PJkyfo0KED7t+/r71m5syZiImJwbx583Do0CG4u7ujffv2uHv3boF9z5w5E35+ftiwYQN+/PFH7N27Fy1atCjqx0NERGbwRCNkOUgenEJJRKQkZtjIe/PmzTqPly5dCldXVxw5cgQtW7aEEAKxsbGYMmWKduPsZcuWwc3NDStXrsSoUaPy7fuDDz6AnZ0dqlevjmXLlmHZsmV5Xrd27dpCx0tERMWrJEyhLEtYwBERlWKZmZk6j21sbArcNBWA9gbvihUrAgCSkpKQlpamvTE8t59WrVph7969BRZwgwYNeu42AkRERFR4LOCIiBRE7o28vby8dNojIiLyvVkbyLnXLSwsDM2bN9feo5aWlgYAehuburm54cqVKwXGERcXZ1jgRESkOHJu5E3GYwFHRKQkMq9CmZKSAicnJ23z80bf3nnnHRw/fhx79uzRO/fsSJoQgqNrRERlgFqIIm3E/WwfJA8WcEREpZiTk5NOAVeQd999F7/99hv++OMPVKlSRdvu7u4OIGckzsPDQ9uenp6uNypHREREpsVVKImIFMQcq1AKIfDOO+9g7dq12LFjB3x9fXXO+/r6wt3dHfHx8dq27OxsJCQkICQkRK63TkRECpW7iImxB8mDI3BEREpihlUox44di5UrV+LXX3+Fo6Oj9p43Z2dn2NnZQZIkhIaGIioqCv7+/vD390dUVBTs7e3Rv39/42MlIiJF4yqUysICjoiojFuwYAEAoHXr1jrtS5cuxZAhQwAA4eHhePjwIcaMGYPbt28jODgYW7duhaOjYzFHS0REVLaxgCMiUhC5V6EsDFGI0TpJkhAZGVngCpZERFQ6cQROWVjAEREpicyrUBIRERlLLTRQazRG90Hy4CImREREREREJQRH4IiIFMQcUyiJiIgKwo28lYUFHBGRkmhEziFHP0RERDJQawRUvAdOMTiFkoiIiIiIqITgCBwRkZJwERMiIlKYJxpAMnIE7QnXMJENR+CIiIiIiIhKCI7AEREpiASZFjExvgsiIiIAvAdOaVjAEREpiRA5hxz9EBERyYAFnLJwCiUREREREVEJwRE4IiIF4T5wRESkNByBUxYWcERESsJVKImISGG4kbeycAolERERERFRCcEROCIiBZGEgCTDAiRy9EFERATkTH80dh84TqGUT5kp4Cwcy8FCsjZ3GCbhsdjW3CGY3JOzJ8wdAlHx0Pz/IUc/RGZU2cne3CEQkUyEEBBGFmCCXyzKhlMoiYiIiIiISogyMwJHRFQScAolEREpjUYjjF6EhIuYyIcFHBGRknAVSiIiUhghhNFTIDmFUj6cQklERERERFRCmLWAi4yMhCRJOoe7u7v2/Nq1a9GxY0e4uLhAkiQkJiaaL1giouIghHwHGYx5iYhIn9AIWQ6Sh9mnUNapUwfbtm3TPrawsND+fP/+fTRr1gxvvPEGRo4caY7wiIiKlSRyDjn6oaJhXiIi0sV74JTF7AWcpaWlzrebTxs4cCAA4PLly8UYERERlWXMS0REpGRmvwfuwoUL8PT0hK+vL/r27YtLly4Z1V9WVhYyMzN1DiKiEoNTKM1O7rwEMDcRUckmNPIcJA+zFnDBwcFYvnw5tmzZgsWLFyMtLQ0hISG4efNmkfuMjo6Gs7Oz9vDy8pIxYiIi05I08h1kOFPkJYC5iYhKttxVKI09SB5mLeA6deqE1157DYGBgWjXrh1+//13AMCyZcuK3OfkyZORkZGhPVJSUuQKl4iISjlT5CWAuYmIiORj9nvgnubg4IDAwEBcuHChyH3Y2NjAxsZGxqiIiIqRXNMf+U2nLOTISwBzExGVbFzERFnMfg/c07KysnDmzBl4eHiYOxQiIvMQMh5kNOYlIiJuI6A0Zh2BmzhxIrp27Qpvb2+kp6dj+vTpyMzMxODBgwEAt27dQnJyMv755x8AwLlz5wAA7u7u+a4QRkREVFTMS0REpHRmHYG7evUq+vXrh5o1a6JXr16wtrbG/v374ePjAwD47bff0KBBA7z66qsAgL59+6JBgwZYuHChOcMmIjIZSQjZDjIc8xIRUR7kGH3jCJxszDoCt2rVqgLPDxkyBEOGDCmeYIiIlID3wJkV8xIRkT6NDF8MapiXZKOoe+CIiIiIiIgof4pahZKIqMwTAOTYw41fdBIRkUyEMH4REu4DJx8WcERECiLX/Wu8B46IiOQixyqSXIVSPpxCSUREREREVEJwBI6ISEkEZFrExPguiIiIAECjASSjN/KWKRhiAUdEpChchZKIiBRGCGH0PWy8B04+nEJJRERERERUQnAEjohISTQAJJn6ISIikoHQ5BzG9kHy4AgcEZGC5K5CKcdhiD/++ANdu3aFp6cnJEnCL7/8onNeCIHIyEh4enrCzs4OrVu3xqlTp2R850REpFQajZDlIHmwgCMiIty/fx8vvvgi5s2bl+f5mTNnIiYmBvPmzcOhQ4fg7u6O9u3b4+7du8UcKRERUdnGKZREREpipkVMOnXqhE6dOuXTlUBsbCymTJmCXr16AQCWLVsGNzc3rFy5EqNGjTI6XCIiUi7uA6csHIEjIlKS3AJOjgNAZmamzpGVlWVwSElJSUhLS0OHDh20bTY2NmjVqhX27t0r21snIiJlyi3gjD1IHizgiIhKMS8vLzg7O2uP6Ohog/tIS0sDALi5uem0u7m5ac8RERFR8eAUSiIiJZF5CmVKSgqcnJy0zTY2NkXuUpJ0l8cUQui1ERFR6aMpwuJYefVB8mABR0SkJDJvI+Dk5KRTwBWFu7s7gJyROA8PD217enq63qgcERGVPrwHTlk4hZKIiArk6+sLd3d3xMfHa9uys7ORkJCAkJAQM0ZGRERU9nAEjohIQYqyh1t+/Rji3r17+Pvvv7WPk5KSkJiYiIoVK8Lb2xuhoaGIioqCv78//P39ERUVBXt7e/Tv39/oWImISNmEkGEEjlMoZcMCjohIScy0jcDhw4fRpk0b7eOwsDAAwODBgxEXF4fw8HA8fPgQY8aMwe3btxEcHIytW7fC0dHR+FiJiEjRhAwbcXMKpXxYwBEREVq3bl3gt6OSJCEyMhKRkZHFFxQRERHpYQFHRKQkGgFIMnxLyW86iYhIJkIIo6dAcgqlfFjAEREpiZmmUBIREeWHq1AqC1ehJCIiIiIiKiE4AkdEpCgyjcCB33QSEZE8NBph9NR8YxdBof+wgCMiUhJOoSQiIoURGjWERm10HyQPTqEkIiIiIiIqITgCR0SkJBoBWaY/cqoKERHJhCNwysICjohISYQm55CjHyIiIhkIjUaGAo55SS6cQklERERERFRCcASOiEhJuIgJEREpjFCrIdRGjsAZ+Xz6Dws4IiIl4T1wRESkMELIcA+cYAEnF06hJCIiIiIiKiFYwBERKUnuFEo5DiIiIhnkrkJp7GFKt2/fxsCBA+Hs7AxnZ2cMHDgQd+7cKfA5a9euRceOHeHi4gJJkpCYmKh3TVZWFt599124uLjAwcEB3bp1w9WrV03zJgqJBRwRkZIIyFTAmfuNEBFRaVESCrj+/fsjMTERmzdvxubNm5GYmIiBAwcW+Jz79++jWbNm+Pzzz/O9JjQ0FOvWrcOqVauwZ88e3Lt3D126dIHajPf08R44IiIiIiIqsc6cOYPNmzdj//79CA4OBgAsXrwYTZs2xblz51CzZs08n5db4F2+fDnP8xkZGViyZAm+//57tGvXDgDwww8/wMvLC9u2bUPHjh3lfzOFwBE4IiIl4RRKIiJSGDlH4DIzM3WOrKwso+Pbt28fnJ2dtcUbADRp0gTOzs7Yu3dvkfs9cuQIHj9+jA4dOmjbPD09UbduXaP6NRYLOCIiJdFo5DuIiIhkkLuRt3FHTl7y8vLS3qfm7OyM6Ohoo+NLS0uDq6urXrurqyvS0tKM6tfa2hoVKlTQaXdzczOqX2NxCiURERERERWLlJQUODk5aR/b2Njke21kZCSmTp1aYH+HDh0CAEiSpHdOCJFnu7FM1W9hsYAjIlISbuRNREQKo9GoASMXIdH8//OdnJx0CriCvPPOO+jbt2+B11StWhXHjx/H9evX9c79+++/cHNzMzzY/+fu7o7s7Gzcvn1bZxQuPT0dISEhRe7XWCzgiIiUhAUcEREpjByrSBbl+S4uLnBxcXnudU2bNkVGRgYOHjyIxo0bAwAOHDiAjIwMowqtRo0awcrKCvHx8ejduzcAIDU1FSdPnsTMmTOL3K+xeA8cERERERGVWLVr18Yrr7yCkSNHYv/+/di/fz9GjhyJLl266KxAWatWLaxbt077+NatW0hMTMTp06cBAOfOnUNiYqL2/jZnZ2cMHz4c7733HrZv345jx47hzTffRGBgoHZVSnNgAUdEpCQaId9BREQkg5KwD9yKFSsQGBiIDh06oEOHDqhXrx6+//57nWvOnTuHjIwM7ePffvsNDRo0wKuvvgoA6Nu3Lxo0aICFCxdqr5k9ezZ69OiB3r17o1mzZrC3t8f69ethYWFh0vdTEE6hJCJSECE0EML4FSTl6IOIiAgAoFZDqIwswEy88XXFihXxww8/FHiNeOb2giFDhmDIkCEFPsfW1hZfffUVvvrqK2NDlA1H4IiIiIiIiEoIjsARESmJkGn6IxcxISIimQhh/CqUQph2BK4sYQFHRKQkQgBgAUdERMohNBrjCzgNp/bLhVMoiYiIiIiISgiOwBERKYlGA0gyfEvJRUyIiEgmQoaNvE29CmVZwgKOiEhJOIWSiIgUJmcKpXFfDHIKpXw4hZKIiIiIiKiE4AgcEZGCCI0GQoYplNwHjoiI5MIplMrCAo6ISEk4hZKIiBSGBZyycAolERERERFRCcEROCIiJdEIQOIIHBERKYdGo4bEETjFYAFHRKQkQgCQYxsBFnBERCQPodYAkpEFnJr3ZsuFUyiJiIiIiIhKCI7AEREpiNAICBmmUAqOwBERkUyEkGERE8EplHJhAUdEpCRCA3mmUHKqChERyUNo1MZPoeQ9cLLhFEoiIgIAzJ8/H76+vrC1tUWjRo2we/duc4dEREREz2ABR0SkIEIjZDsMsXr1aoSGhmLKlCk4duwYWrRogU6dOiE5OdlE75SIiEoKoVHLcpA8WMARESmJ0Mh3GCAmJgbDhw/HiBEjULt2bcTGxsLLywsLFiww0RslIqKSggWcspT6e+Byb+R/Ih6bORLTefLkkblDMDmpFP/+qOR7gpx/P+VYOOQJHgMyrD+SG1NmZqZOu42NDWxsbHTasrOzceTIEXzwwQc67R06dMDevXuND4b05P678uzvh4hILrl/X2RZ1Er92PjUpOb/y8ml1Bdwd+/eBQAk3PvJzJGY0DZzB0BEQM7fG2dn5yI919raGu7u7tiTtlG2eMqVKwcvLy+dtoiICERGRuq03bhxA2q1Gm5ubjrtbm5uSEtLky0e+k9ubnr290NEJDc5clPaaXn+P9rd3R3W1tay9FWWlfoCztPTEykpKXB0dIQkSeYOJ0+ZmZnw8vJCSkoKnJyczB2OSfA9lg58j3kTQuDu3bvw9PQs8uva2toiKSkJ2dnZRe4jr7ie/bv37Ojb0569Nq/nkzyUnpv433rpURbeJ99j3pSYm6ytrWFraytLX2VZqS/gVCoVqlSpYu4wCsXJyanU/uHJxfdYOvA96ivqt5tPs7W1NUtic3FxgYWFhd5oW3p6ut6oHMmjpOQm/rdeepSF98n3qK8k5ybKHxcxISIq46ytrdGoUSPEx8frtMfHxyMkJMRMUREREVFeSv0IHBERPV9YWBgGDhyIoKAgNG3aFIsWLUJycjJGjx5t7tCIiIjoKSzgFMDGxgYREREF3ptS0vE9lg58j6VXnz59cPPmTUybNg2pqamoW7cuNm7cCB8fH3OHRmZQFv47KAvvESgb75PvkcoaSciytigRERERERGZGu+BIyIiIiIiKiFYwBEREREREZUQLOCIiIiIiIhKCBZwREREREREJQQLODObP38+fH19YWtri0aNGmH37t3mDkk20dHReOmll+Do6AhXV1f06NED586dM3dYJhUdHQ1JkhAaGmruUGR17do1vPnmm6hUqRLs7e1Rv359HDlyxNxhyebJkyf46KOP4OvrCzs7O/j5+WHatGnQaDTmDo3ILJibShfmppKJuYnywwLOjFavXo3Q0FBMmTIFx44dQ4sWLdCpUyckJyebOzRZJCQkYOzYsdi/fz/i4+Px5MkTdOjQAffv3zd3aCZx6NAhLFq0CPXq1TN3KLK6ffs2mjVrBisrK2zatAmnT5/GrFmzUL58eXOHJpsZM2Zg4cKFmDdvHs6cOYOZM2fiiy++wFdffWXu0IiKHXNT6cLcVHIxN1F+uI2AGQUHB6Nhw4ZYsGCBtq127dro0aMHoqOjzRiZafz7779wdXVFQkICWrZsae5wZHXv3j00bNgQ8+fPx/Tp01G/fn3ExsaaOyxZfPDBB/jzzz9L1Tfwz+rSpQvc3NywZMkSbdtrr70Ge3t7fP/992aMjKj4MTeVHsxNJRtzE+WHI3Bmkp2djSNHjqBDhw467R06dMDevXvNFJVpZWRkAAAqVqxo5kjkN3bsWLz66qto166duUOR3W+//YagoCC88cYbcHV1RYMGDbB48WJzhyWr5s2bY/v27Th//jwA4K+//sKePXvQuXNnM0dGVLyYm0oX5qaSjbmJ8mNp7gDKqhs3bkCtVsPNzU2n3c3NDWlpaWaKynSEEAgLC0Pz5s1Rt25dc4cjq1WrVuHo0aM4dOiQuUMxiUuXLmHBggUICwvDhx9+iIMHD2LcuHGwsbHBoEGDzB2eLN5//31kZGSgVq1asLCwgFqtxmeffYZ+/fqZOzSiYsXcVHowN5V8zE2UHxZwZiZJks5jIYReW2nwzjvv4Pjx49izZ4+5Q5FVSkoKxo8fj61bt8LW1tbc4ZiERqNBUFAQoqKiAAANGjTAqVOnsGDBglKTJFevXo0ffvgBK1euRJ06dZCYmIjQ0FB4enpi8ODB5g6PqNgxN5VszE3MTVS6sYAzExcXF1hYWOh9o5menq73zWdJ9+677+K3337DH3/8gSpVqpg7HFkdOXIE6enpaNSokbZNrVbjjz/+wLx585CVlQULCwszRmg8Dw8PBAQE6LTVrl0ba9asMVNE8ps0aRI++OAD9O3bFwAQGBiIK1euIDo6mkmSyhTmptKBual0YG6i/PAeODOxtrZGo0aNEB8fr9MeHx+PkJAQM0UlLyEE3nnnHaxduxY7duyAr6+vuUOSXdu2bXHixAkkJiZqj6CgIAwYMACJiYklPkECQLNmzfSW2D5//jx8fHzMFJH8Hjx4AJVK98+hhYUFl2qmMoe5qXRgbiodmJsoPxyBM6OwsDAMHDgQQUFBaNq0KRYtWoTk5GSMHj3a3KHJYuzYsVi5ciV+/fVXODo6ar/RdXZ2hp2dnZmjk4ejo6PefRMODg6oVKlSqbmfYsKECQgJCUFUVBR69+6NgwcPYtGiRVi0aJG5Q5NN165d8dlnn8Hb2xt16tTBsWPHEBMTg2HDhpk7NKJix9xU8jE3lQ7MTZQvQWb19ddfCx8fH2FtbS0aNmwoEhISzB2SbADkeSxdutTcoZlUq1atxPjx480dhqzWr18v6tatK2xsbEStWrXEokWLzB2SrDIzM8X48eOFt7e3sLW1FX5+fmLKlCkiKyvL3KERmQVzU+nD3FTyMDdRfrgPHBERERERUQnBe+CIiIiIiIhKCBZwREREREREJQQLOCIiIiIiohKCBRwREREREVEJwQKOiIiIiIiohGABR0REREREVEKwgCMiIiIiIiohWMARERERERGVECzgyGiXL1+GJElITEw0Sf+SJOGXX34p8vN37doFSZIgSRJ69OhR4LWtW7dGaGhokV+L9A0ZMkT7+RvzeyQiKizmJSoI8xKVdCzgSrghQ4Y894+/qXl5eSE1NRV169YF8F9iunPnjlnjeta5c+cQFxdn7jBKrfx+73PmzEFqaqp5giKiYse8VHjMS6bFvESllaW5A6CSz8LCAu7u7uYO47lcXV1Rvnx5c4eBx48fw8rKytxhFBtnZ2c4OzubOwwiKkOYlwzDvERUsnAErpRLSEhA48aNYWNjAw8PD3zwwQd48uSJ9nzr1q0xbtw4hIeHo2LFinB3d0dkZKROH2fPnkXz5s1ha2uLgIAAbNu2TWfawdNTVS5fvow2bdoAACpUqABJkjBkyBAAQNWqVREbG6vTd/369XVe78KFC2jZsqX2teLj4/Xe07Vr19CnTx9UqFABlSpVQvfu3XH58mWDP5v79+9j0KBBKFeuHDw8PDBr1iy9a7KzsxEeHo4XXngBDg4OCA4Oxq5du3SuWbx4Mby8vGBvb4+ePXsiJiZGJyFHRkaifv36+O677+Dn5wcbGxsIIZCRkYG33noLrq6ucHJywssvv4y//vpLp+/169ejUaNGsLW1hZ+fH6ZOnarz+4uMjIS3tzdsbGzg6emJcePGFfien9dfTEwMAgMD4eDgAC8vL4wZMwb37t3Tnr9y5Qq6du2KChUqwMHBAXXq1MHGjRsL/L0TET2NeSl/zEvMS0SFwRG4UuzatWvo3LkzhgwZguXLl+Ps2bMYOXIkbG1tdZLTsmXLEBYWhgMHDmDfvn0YMmQImjVrhvbt20Oj0aBHjx7w9vbGgQMHcPfuXbz33nv5vqaXlxfWrFmD1157DefOnYOTkxPs7OwKFa9Go0GvXr3g4uKC/fv3IzMzU2/e/4MHD9CmTRu0aNECf/zxBywtLTF9+nS88sorOH78OKytrQv9+UyaNAk7d+7EunXr4O7ujg8//BBHjhxB/fr1tdcMHToUly9fxqpVq+Dp6Yl169bhlVdewYkTJ+Dv748///wTo0ePxowZM9CtWzds27YNH3/8sd5r/f333/jpp5+wZs0aWFhYAABeffVVVKxYERs3boSzszO++eYbtG3bFufPn0fFihWxZcsWvPnmm5g7dy5atGiBixcv4q233gIARERE4H//+x9mz56NVatWoU6dOkhLS9NLtE97Xn8AoFKpMHfuXFStWhVJSUkYM2YMwsPDMX/+fADA2LFjkZ2djT/++AMODg44ffo0ypUrZ9TvnYjKDualgjEvMS8RFYqgEm3w4MGie/fueZ778MMPRc2aNYVGo9G2ff3116JcuXJCrVYLIYRo1aqVaN68uc7zXnrpJfH+++8LIYTYtGmTsLS0FKmpqdrz8fHxAoBYt26dEEKIpKQkAUAcO3ZMCCHEzp07BQBx+/ZtnX59fHzE7NmzddpefPFFERERIYQQYsuWLcLCwkKkpKRoz2/atEnntZYsWaL3nrKysoSdnZ3YsmVLnp9DXvHcvXtXWFtbi1WrVmnbbt68Kezs7MT48eOFEEL8/fffQpIkce3aNZ3+2rZtKyZPniyEEKJPnz7i1Vdf1Tk/YMAA4ezsrH0cEREhrKysRHp6urZt+/btwsnJSTx69EjnudWqVRPffPONEEKIFi1aiKioKJ3z33//vfDw8BBCCDFr1ixRo0YNkZ2dnef7ftbz+svLTz/9JCpVqqR9HBgYKCIjI/O8Nr/fe66nf49EVHoxLzEvMS8RmRZH4EqxM2fOoGnTppAkSdvWrFkz3Lt3D1evXoW3tzcAoF69ejrP8/DwQHp6OoCcG6y9vLx07iVo3LixyeL19vZGlSpVtG1NmzbVuebIkSP4+++/4ejoqNP+6NEjXLx4sdCvdfHiRWRnZ+v0X7FiRdSsWVP7+OjRoxBCoEaNGjrPzcrKQqVKlQDkfD49e/bUOd+4cWNs2LBBp83HxweVK1fWeR/37t3T9pPr4cOH2vdx5MgRHDp0CJ999pn2vFqtxqNHj/DgwQO88cYbiI2NhZ+fH1555RV07twZXbt2haVl3v9ZP68/e3t77Ny5E1FRUTh9+jQyMzPx5MkTPHr0CPfv34eDgwPGjRuHt99+G1u3bkW7du3w2muv6f37Q0SUH+al/DEv6ffHvESUNxZwpZgQQidJ5rYB0Gl/9sZlSZKg0Wjy7aOoVCqV9vVzPX78WC+2Z2N5mkajQaNGjbBixQq9a59ORM+T12s9S6PRwMLCAkeOHNFOL8lVrlw5bT/5fcZPc3Bw0Ovbw8ND774FANr7FDQaDaZOnYpevXrpXWNrawsvLy+cO3cO8fHx2LZtG8aMGYMvvvgCCQkJed6M/rz+rly5gs6dO2P06NH49NNPUbFiRezZswfDhw/X/p5GjBiBjh074vfff8fWrVsRHR2NWbNm4d1339Xrk4joWcxL+WNe0u+PeYkobyzgSrGAgACsWbNG54/53r174ejoiBdeeKFQfdSqVQvJycm4fv063NzcAACHDh0q8Dm58/3VarVOe+XKlXWW7c3MzERSUpJOvMnJyfjnn3/g6ekJANi3b59OHw0bNsTq1au1N1gXVfXq1WFlZYX9+/drv/G9ffs2zp8/j1atWgEAGjRoALVajfT0dLRo0SLPfmrVqoWDBw/qtB0+fPi5r9+wYUOkpaXB0tISVatWzfeac+fOoXr16vn2Y2dnh27duqFbt24YO3YsatWqhRMnTqBhw4YG93f48GE8efIEs2bNgkqVs77RTz/9pHedl5cXRo8ejdGjR2Py5MlYvHgx3n333Xx/70REuZiX8se8pI95iShvXIWyFMjIyEBiYqLOkZycjDFjxiAlJQXvvvsuzp49i19//RUREREICwvT/iF8nvbt26NatWoYPHgwjh8/jj///BNTpkwBoP8tZC4fHx9IkoQNGzbg33//1a4W9fLLL+P777/H7t27cfLkSQwePFjnG8R27dqhZs2aGDRoEP766y/s3r1b+1q5BgwYABcXF3Tv3h27d+9GUlISEhISMH78eFy9erXQn1m5cuUwfPhwTJo0Cdu3b8fJkycxZMgQnc+lRo0aGDBgAAYNGoS1a9ciKSkJhw4dwowZM7Bx40YAwLvvvouNGzciJiYGFy5cwDfffINNmzY999vhdu3aoWnTpujRowe2bNmCy5cvY+/evfjoo4+0ifaTTz7B8uXLERkZiVOnTuHMmTNYvXo1PvroIwBAXFwclixZgpMnT+LSpUv4/vvvYWdnBx8fnzxf83n9VatWDU+ePMFXX32l7W/hwoU6fYSGhmLLli1ISkrC0aNHsWPHDtSuXRtA/r93Iip7mJeYl5iXiEyoeG+5I7kNHjxYANA7Bg8eLIQQYteuXeKll14S1tbWwt3dXbz//vvi8ePH2ue3atVKe3N0ru7du2ufL4QQZ86cEc2aNRPW1taiVq1aYv369QKA2Lx5sxBC/2ZxIYSYNm2acHd3F5IkafvKyMgQvXv3Fk5OTsLLy0vExcXp3CwuhBDnzp0TzZs3F9bW1qJGjRpi8+bNejcZp6amikGDBgkXFxdhY2Mj/Pz8xMiRI0VGRkaen1F+NzHfvXtXvPnmm8Le3l64ubmJmTNn6n0e2dnZ4pNPPhFVq1YVVlZWwt3dXfTs2VMcP35ce82iRYvECy+8IOzs7ESPHj3E9OnThbu7u/Z8RESEePHFF/XiyszMFO+++67w9PQUVlZWwsvLSwwYMEAkJydrr9m8ebMICQkRdnZ2wsnJSTRu3FgsWrRICCHEunXrRHBwsHBychIODg6iSZMmYtu2bXl+BoXpTwghYmJihIeHh7CzsxMdO3YUy5cv1/ns3nnnHVGtWjVhY2MjKleuLAYOHChu3LihfX5ev/dcz/4eiah0Yl5iXmJeIjItSYhCTLomesqff/6J5s2b4++//0a1atXMHc5z7dq1C23atMHt27eLZcPUkSNH4uzZs9i9e7fJX6skkSQJ69atQ48ePcwdChGVMsxLBWNeyhvzEpVUnEJJz7Vu3TrEx8fj8uXL2LZtG9566y00a9asRCTJp1WpUgX9+vWTvd8vv/wSf/31F/7++2989dVXWLZsGQYPHiz765RUo0eP1t5cT0QkB+algjEvFYx5iUo6jsDRcy1fvhyffvopUlJS4OLignbt2mHWrFl6Sw0r1cOHD3Ht2jUAOfcYPL30tBx69+6NXbt24e7du/Dz88O7776L0aNHy/oaJVl6ejoyMzMB5CwF/uzKZ0REhmJeKhjzUsGYl6ikYwFHRERERERUQnAKJRERERERUQnBAo6IiIiIiKiEYAFHRERERERUQrCAIyIiIiIiKiFYwBEREREREZUQLOCIiIiIiIhKCBZwREREREREJQQLOCIiIiIiohLi/wDaZPxneCrK+gAAAABJRU5ErkJggg==", "text/plain": [ "
    " ] @@ -2352,13 +2398,13 @@ }, { "cell_type": "code", - "execution_count": 54, + "execution_count": 22, "metadata": {}, "outputs": [], "source": [ - "all_df = cmp.to_dataframe()\n", - "all_df[\"wl category\"] = 'high'\n", - "all_df.loc[all_df['mod_val']<0, \"wl category\"] = 'low'" + "dftmp = cmp.data.to_dataframe()\n", + "dftmp[\"wl category\"] = 'high'\n", + "dftmp.loc[dftmp['HD']<0, \"wl category\"] = 'low'" ] }, { @@ -2371,7 +2417,7 @@ }, { "cell_type": "code", - "execution_count": 56, + "execution_count": 23, "metadata": {}, "outputs": [ { @@ -2753,11 +2799,12 @@ " wl category (time) object 'high' 'high' 'high' ... 'high' 'high' 'high'\n", "Attributes:\n", " gtype: track\n", - " modelskill_version: 1.0.a2\n", - " name: alti
  • gtype :
    track
    modelskill_version :
    1.0.dev23
    weight :
    1.0
    name :
    alti
  • " ], "text/plain": [ "\n", @@ -2984,17 +3031,18 @@ " wl category (time) object 'high' 'high' 'high' ... 'high' 'high' 'high'\n", "Attributes:\n", " gtype: track\n", - " modelskill_version: 1.0.a2\n", + " modelskill_version: 1.0.dev23\n", + " weight: 1.0\n", " name: alti" ] }, - "execution_count": 56, + "execution_count": 23, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "cmp.data[\"wl category\"] = all_df[\"wl category\"]\n", + "cmp.data[\"wl category\"] = dftmp[\"wl category\"]\n", "cmp.data" ] }, @@ -3008,7 +3056,7 @@ }, { "cell_type": "code", - "execution_count": 57, + "execution_count": 24, "metadata": {}, "outputs": [ { @@ -3384,8 +3432,8 @@ " * x (x) float64 -0.436 1.543 3.517 5.492 7.466\n", " * wl category (wl category) object 'high' 'low'\n", "Data variables:\n", - " n (y, x, wl category) int64 0 3 14 3 0 0 0 0 ... 6 0 0 20 0 71 4\n", - " bias (y, x, wl category) float64 nan nan -0.2252 ... nan -0.1077 nan
    • y
      PandasIndex
      PandasIndex(Index([50.6045, 51.655, 52.703, 53.751, 54.799], dtype='float64', name='y'))
    • x
      PandasIndex
      PandasIndex(Index([-0.43599999999999994, 1.543, 3.5169999999999995, 5.4915,\n",
      +                            "       7.465999999999999],\n",
      +                            "      dtype='float64', name='x'))
    • wl category
      PandasIndex
      PandasIndex(Index(['high', 'low'], dtype='object', name='wl category'))
  • " ], "text/plain": [ "\n", @@ -3453,11 +3501,11 @@ " * x (x) float64 -0.436 1.543 3.517 5.492 7.466\n", " * wl category (wl category) object 'high' 'low'\n", "Data variables:\n", - " n (y, x, wl category) int64 0 3 14 3 0 0 0 0 ... 6 0 0 20 0 71 4\n", + " n (y, x, wl category) int32 0 3 14 3 0 0 0 0 ... 6 0 0 20 0 71 4\n", " bias (y, x, wl category) float64 nan nan -0.2252 ... nan -0.1077 nan" ] }, - "execution_count": 57, + "execution_count": 24, "metadata": {}, "output_type": "execute_result" } @@ -3469,12 +3517,12 @@ }, { "cell_type": "code", - "execution_count": 58, + "execution_count": 25, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAp0AAAEiCAYAAAC7oWkDAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAAA4TklEQVR4nO3de3hU1b3/8c+eCUm4JAESCKSGELTKLdyCchPBiiBQrBdU0AZohdYqlUtBRetP9CCxPQpUESjosaBYaIW2iAiEgyAUAblEOUghCkiARAxgwkVDklm/P1KmjCSzkwyTncv79TzrMbPXnjXfPcjKl7XWXtsyxhgBAAAAQeRyOgAAAADUfCSdAAAACDqSTgAAAAQdSScAAACCjqQTAAAAQUfSCQAAgKAj6QQAAEDQkXQCAAAg6Eg6AQAAEHQknbXMn/70JzVs2NDpMGoFy7L097//vdT6DRs2yLIsffPNN2Vuc+rUqerUqVPAsQES/UFlsusPgNqApBNXXMuWLTVr1iynw6jyevbsqaysLEVFRTkdChA09AcALiLpRI1WUFDgdAilCg0NVbNmzWRZltOhALVCVe4PgNqApLOae/fdd9WwYUN5PB5JUnp6uizL0uTJk73n/PKXv9Tw4cPL3ObRo0c1bNgwNW7cWPXr11fXrl21bds2SdIXX3yhn/zkJ4qNjVWDBg10/fXXa926dd739u3bV19++aUmTJggy7J8EqotW7bopptuUt26dRUfH69HH31U586d89ZnZWVp8ODBqlu3rhITE/X2229fNkpy5MgR/eQnP1GDBg0UGRmpe++9V1999ZW3/uL08//8z/+oVatWCgsL08KFCxUdHa38/Hyf67z77rs1YsSIMn8vFZGTk6M777xT9erV0w9/+EOtWLHCW1fS9PqCBQsUHx+vevXq6c4779SMGTNKnP5888031bJlS0VFRWnYsGE6c+ZMUK8D1QP9QdXuDy61Z88e/ehHP1LdunUVHR2tX/ziFzp79qy3zuVyKScnR5J0+vRpuVwu3XPPPd73p6amqkePHpUWL3AlkHRWczfddJPOnDmj3bt3S5I2btyomJgYbdy40XvOhg0b1KdPnzK1d/bsWfXp00fHjx/XihUr9Mknn+ixxx7z/hI7e/asBg0apHXr1mn37t0aMGCAhgwZoiNHjkiSli9frquuukrPPfecsrKylJWVJam4Ex0wYIDuuusuffrpp1q6dKk2b96ssWPHej97xIgROn78uDZs2KBly5Zp/vz5OnHihLfeGKM77rhDp06d0saNG5WWlqYvvvhC9913n881fP755/rLX/6iZcuWKT09Xffee6+Kiop8Er6cnBytXLlSP/vZz0r9Ltq1a6cGDRqUWtq1a2f7fT777LO699579emnn2rQoEF64IEHdOrUqRLP/ec//6mHHnpI48aNU3p6um699VY9//zzl533xRdf6O9//7tWrlyplStXauPGjXrhhRdsY0HNR39QtfuDi86fP6/bbrtNjRo10scff6y//vWvWrdunff627dvr+joaO+f24cffqjo6Gh9+OGH3jbK8+cIVBkG1V6XLl3Miy++aIwx5o477jDPP/+8CQ0NNXl5eSYrK8tIMvv27TPGGPPGG2+YqKioUtv64x//aCIiIszJkyfL/Plt27Y1r7zyivd1QkKCmTlzps85KSkp5he/+IXPsU2bNhmXy2W+/fZbs2/fPiPJfPzxx976jIwMI8nb1tq1a43b7TZHjhzxnrN3714jyWzfvt0YY8wzzzxj6tSpY06cOOHzWb/61a/MwIEDva9nzZplWrVqZTweT6nXdfjwYZORkVFqOXz4sN/vRZL57W9/63199uxZY1mWef/9940xxnzwwQdGkjl9+rQxxpj77rvPDB482KeNBx54wOfP65lnnjH16tUzeXl53mOTJ0823bp18xsLag/6g6rbH/ztb38zxhgzf/5806hRI3P27Flv/XvvvWdcLpfJzs42xhhz1113mbFjxxpjjBk/frz5zW9+Y2JiYszevXtNQUGBadCggbcvAaqLEIdyXVxBffv21YYNGzRx4kRt2rRJ06ZN07Jly7R582Z98803io2NVevWrcvUVnp6ujp37qzGjRuXWH/u3Dk9++yzWrlypY4fP67CwkJ9++233pGN0uzcuVOff/65Fi9e7D1mjJHH49GhQ4d04MABhYSEqEuXLt76a665Ro0aNfK+3rdvn+Lj4xUfH+891rZtWzVs2FD79u3T9ddfL0lKSEhQkyZNfD5/zJgxuv7663Xs2DH94Ac/0BtvvKFRo0b5XU+ZkJDg95rKokOHDt6f69evr4iICJ/Rmkvt379fd955p8+xG264QStXrvQ51rJlS0VERHhfN2/evNQ2UfvQH1Td/uDS2Dt27Kj69et7j/Xq1Usej0f79+9XbGys+vbtq/nz50sqHrH+r//6Lx06dEgbN25Ubm6uvv32W/Xq1euKxQRUBpLOGqBv3756/fXX9cknn8jlcqlt27bq06ePNm7cqNOnT5drCqZu3bp+6ydPnqw1a9boxRdf1DXXXKO6detq6NChunDhgt/3eTwe/fKXv9Sjjz56WV2LFi20f//+Et9njPH5uaRfCt8/fmlHflHnzp3VsWNHLVq0SAMGDNCePXv07rvv+o25Xbt2+vLLL0utT0hI0N69e/22UadOHZ/XlmV5pya/r6Tru/T6K9Imah/6g6rbH9jFLsl7vG/fvho3bpw+//xz/d///Z969+6tL774Qhs3btQ333yj5ORkn398AtUBSWcNcHEd16xZs9SnTx9ZlqU+ffooNTVVp0+f1rhx48rcVocOHfTaa6/p1KlTJY5ubNq0SaNGjfKOyJ09e1aHDx/2OSc0NFRFRUU+x7p06aK9e/fqmmuuKfFzW7durcLCQu3evVvJycmSitdiXXqTTdu2bXXkyBFlZmZ6Rzc+++wz5ebmqk2bNrbXNnr0aM2cOVPHjh1Tv379fEZISrJq1Sq/d7t+P/kLVOvWrbV9+3afYzt27Liin4Gaj/6g6vcHbdu21cKFC3Xu3DlvUvzPf/5TLpdL1157raT/rOucNm2aOnbsqMjISJ8/R9ZzolpyaFofV1iXLl2M2+02s2fPNsYYc+rUKVOnTh0jyezdu9d7nt0arvz8fHPttdea3r17m82bN5svvvjCvPPOO2bLli3GmOI1Yp06dTK7d+826enpZsiQISYiIsKMGzfO28att95qbr/9dnP06FHz9ddfG2OM+eSTT0zdunXNww8/bHbv3m0OHDhg/vGPf3jXLBljTL9+/UyXLl3Mtm3bzK5du8zNN99s6tata2bNmmWMMcbj8ZjOnTub3r17m507d5pt27aZ5ORk06dPH28bzzzzjOnYsWOJ15abm2vq1atnQkNDzZIlS8rz9VaILlnDdVFUVJR54403jDGXr+ncvHmzcblc5qWXXjIHDhww8+bNM9HR0aZhw4be95d0fTNnzjQJCQnBuxBUO/QHxapqf3Du3DnTvHlzc/fdd5s9e/aY9evXm1atWpmRI0f6vOeuu+4ybrfbTJo0yRhTfM2NGzc2brfbvPfee0GPGbjSuHu9hrj55ptVVFSkvn37SpIaNWqktm3bqkmTJmX6V/9FoaGhWrt2rZo2bapBgwYpKSlJL7zwgtxutyRp5syZatSokXr27KkhQ4ZowIABPuuuJOm5557T4cOHdfXVV3vXUnXo0EEbN25URkaGevfurc6dO+vpp59W8+bNve9btGiRYmNjddNNN+nOO+/UmDFjFBERofDwcEn/eaJHo0aNdNNNN6lfv35q1aqVli5dWqZri4yM1N13360GDRrojjvuKPN3Ull69eqlefPmacaMGerYsaNWr16tCRMmeK8fKCv6A3tO9gf16tXTmjVrdOrUKV1//fUaOnSobrnlFs2ePdvnvO//OVqWpd69e0uSbrzxxkqNGbgSLGNKWDQGVAFHjx5VfHy81q1bp1tuueWKtHnrrbeqTZs2evnll69Ie8E2ZswY/etf/9KmTZucDgVwFP0BUP2xphNVxvr163X27FklJSUpKytLjz32mFq2bKmbbrop4LZPnTqltWvXav369ZeNJlQlL774om699VbVr19f77//vhYuXKg5c+Y4HRZQ6egPgJqHpBNVRkFBgZ588kkdPHhQERER6tmzpxYvXnxFbtjp0qWLTp8+rd/97ne67rrrrkC0wbF9+3b9/ve/15kzZ9SqVSu9/PLLGj16tNNhAZWO/gCoeZheBwAAQNBxIxEAAACCjqQTAAAAQUfSCQAAgKCr8TcSeTweHT9+XBEREX6fqwugajLG6MyZM4qLi5PLVf5/J9MHANVboH3AlfDdd9/ZPt5VKt7blr2VS1fjk87jx4/bPt4MQNWXmZmpq666qtzvow8AaoaK9gGB+u677xRdt4HOq8j23GbNmunQoUMknqWo8UlnRESEJCn9swPen6ub3dlnnQ4hYLde29TpEAISfePDTocQkCemTXQ6hArLP39W/z28T4X//l58X2ZmpiIjI69kaJXm8MkzTocQsJbR1bP/hfPy8vIUHx/v2O/wCxcu6LyKNEI/UKifVYkX5NGi7GO6cOECSWcpanzSeXE6LSIiQhHV9BdOvbPVf0qwuv6yv8hyhzodQkDC6zdwOoSAVXRq/OL7IiMjq+3/hxEXakIfQNKJwDi9PKau5VaoVXrS6TaWxCaUftX4pBMAACBQLkty+8l7XRJJpw2STgAAABuhLkuhfkZbjbEkTyUGVA2RdAIAANhwW5bcfpJOt6r/MphgI+kEAACw4baZXndXXijVFkknAACADUY6A0fSCQAAYCPEslTHT9JZRNJpy9HHYE6dOlWWZfmUZs2aeetHjRp1WX337t0djBgAANRGF6fX/RX45/hIZ7t27bRu3Trva7fbd1XEbbfdpjfeeMP7OjS0eu+XCAAAqp/ixNLf9DrsOJ50hoSE+Ixufl9YWJjfegAAgGDjRqLAOTq9LkkZGRmKi4tTYmKihg0bpoMHD/rUb9iwQU2bNtW1116rMWPG6MSJE37by8/PV15enk8BUHvQBwAIhjouq3ivzlJKHRfz63YcTTq7deumRYsWac2aNVqwYIGys7PVs2dPnTx5UpI0cOBALV68WOvXr9dLL72kjz/+WD/60Y+Un59fapupqamKiorylvj4+Mq6HABVAH0AgGC4ePe6vwL/HE06Bw4cqLvvvltJSUnq16+f3nvvPUnSwoULJUn33XefBg8erPbt22vIkCF6//33deDAAe95JZkyZYpyc3O9JTMzs1KuBUDVQB8AIBi4kShwjq/pvFT9+vWVlJSkjIyMEuubN2+uhISEUuul4jWgYWFhwQoRQBVHHwAgGFjTGTjH13ReKj8/X/v27VPz5s1LrD958qQyMzNLrQcAAAiGYE2vz5kzR4mJiQoPD1dycrI2bdpU6rnLly/XrbfeqiZNmigyMlI9evTQmjVrKnpJlc7RpHPSpEnauHGjDh06pG3btmno0KHKy8vTyJEjdfbsWU2aNEkfffSRDh8+rA0bNmjIkCGKiYnRnXfe6WTYAACglqlj2dxIVIGkc+nSpRo/fryeeuop7d69W71799bAgQN15MiREs//8MMPdeutt2rVqlXauXOnbr75Zg0ZMkS7d+8O9PIqhaPT60ePHtXw4cOVk5OjJk2aqHv37tq6dasSEhL07bffas+ePVq0aJG++eYbNW/eXDfffLOWLl2qiIgIJ8MGAAC1jO30egUGOmfMmKEHH3xQo0ePliTNmjVLa9as0dy5c5WamnrZ+bNmzfJ5PX36dP3jH//Qu+++q86dO5c/gErmaNK5ZMmSUuvq1q1brYaMAQBAzWX77PV/131/m7bS1plfuHBBO3fu1BNPPOFzvH///tqyZUuZYvJ4PDpz5owaN25cpvOdVqXWdAIAAFRFZb17PT4+3mfbtpJGLCUpJydHRUVFio2N9TkeGxur7OzsMsX00ksv6dy5c7r33nsDurbKUqXuXgcAAKiK6rhcquMqfayujowkKTMzU5GRkd7jdrtpWN8bPTXGXHasJH/+8581depU/eMf/1DTpk1tz68KSDoBAABsWG5Llp+nDl1MFCMjI32SztLExMTI7XZfNqp54sSJy0Y/v2/p0qV68MEH9de//lX9+vUrQ/RVA9PrAAAANlxuy7aUR2hoqJKTk5WWluZzPC0tTT179iz1fX/+8581atQovf322xo8eHCFrsUpjHQCAADYcbtk+Zlel2XK3eTEiROVkpKirl27qkePHpo/f76OHDmihx56SFLxE9aOHTumRYsWSSpOOEeMGKE//OEP6t69u3eUtG7duoqKiir/NVUykk4AAAAb7jouud2lJ53uovInnffdd59Onjyp5557TllZWWrfvr1WrVqlhIQESVJWVpbPnp1//OMfVVhYqEceeUSPPPKI9/jIkSP1pz/9qdyfX9lIOgEAAGxYLv8jnZYpf9IpSQ8//LAefvjhEuu+n0hu2LChQp9RVZB0AgAA2LBbt+lSxR6DWZuQdAIAANiw3JYsP0mnRdJpi6QTAADAhjvUJbfbXXp9BdZ01jYknQAAADYsy2afTg8jnXZIOgEAAGy43C65/Ny97jJsfW6HpBMAAMCG7ZpOw0inHZJOAAAAGySdgSPpBAAAsOEKdcsdUvqNRC4XNxLZIekEAACw4bIsufzcSOSyGOm0Q9IJAABgw3K7ZPm5kcjycCORHZJOAAAAG7ZPJGLLJFsknQAAADZcoW656vhZ02mxptMOSScAAIANl1s2I52VGEw1RdIJAABgw3LZPJHITx2KkXQCAADYcLlsnkhUxI1EdmpN0pl7oUie/CKnw6iQOn7+J68u/rjtS6dDCMgPb77T6RACMrneHqdDqLA8c17TnA7CYYkxEU6HANR6rlC3XKF+1nSK+XU7tSbpBAAAqCjL5ZLl8rNlkp86FCPpBAAAsOFy20yv14BZyWAj6QQAALBjszm8SDptkXQCAADYsFw2TyRiet0WSScAAIANV50QuerUKb3ew+bwdhxNy6dOnSrLsnxKs2bNSjz3l7/8pSzL0qxZsyo3SAAAUOtdfPa6vwL/HB/pbNeundatW+d97XZfvh3B3//+d23btk1xcXGVGRoAAICkf+/T6WcK3V8dijmedIaEhJQ6uilJx44d09ixY7VmzRoNHjy4EiMDAAAoZjeayUinPce/oYyMDMXFxSkxMVHDhg3TwYMHvXUej0cpKSmaPHmy2rVr52CUAACgNnOFhPx7XWcpJcTxcbwqz9FvqFu3blq0aJGuvfZaffXVV5o2bZp69uypvXv3Kjo6Wr/73e8UEhKiRx99tMxt5ufnKz8/3/s6Ly8vGKEDqKLoAwAEAyOdgXM06Rw4cKD356SkJPXo0UNXX321Fi5cqD59+ugPf/iDdu3aJcuyytxmamqqnn322WCEC6AaoA8AEAwknYGrUt9Q/fr1lZSUpIyMDG3atEknTpxQixYtFBISopCQEH355Zf6zW9+o5YtW5baxpQpU5Sbm+stmZmZlXcBABxHHwAgGC4+kchfgX9VagFCfn6+9u3bp969eyslJUX9+vXzqR8wYIBSUlL0s5/9rNQ2wsLCFBYWFuxQAVRR9AEAgsFVxy1XndLTJldRUSVGUz05mnROmjRJQ4YMUYsWLXTixAlNmzZNeXl5GjlypKKjoxUdHe1zfp06ddSsWTNdd911DkUMAABqI6bXA+do0nn06FENHz5cOTk5atKkibp3766tW7cqISHBybAAAAB8WJbL76MuLYuk046j39CSJUt0/PhxXbhwQceOHdOyZcvUtm3bUs8/fPiwxo8fX3kBAgAASLLcbrn8FKuEh9uUxZw5c5SYmKjw8HAlJydr06ZNpZ6blZWl+++/X9ddd51cLle1y4lIywEAAGy4QkNsS3ktXbpU48eP11NPPaXdu3erd+/eGjhwoI4cOVLi+fn5+WrSpImeeuopdezYMdBLqnQknQAAADYsl8u2lNeMGTP04IMPavTo0WrTpo1mzZql+Ph4zZ07t8TzW7ZsqT/84Q8aMWKEoqKiAr2kSkfSCQAAYOPijUT+ilT8QIpLy6UPq7jUhQsXtHPnTvXv39/neP/+/bVly5agX48TSDoBAABsWC7Lf9LpKn6QTXx8vKKiorwlNTW1xPZycnJUVFSk2NhYn+OxsbHKzs4O+vU4oUrt0wkAAFAV2U2hX6zLzMxUZGSk97jdvsHff+qiMaZcT2KsTkg6AQAAbFghobJCQv3UeyRJkZGRPklnaWJiYuR2uy8b1Txx4sRlo581BdPrAAAAdlwu+1IOoaGhSk5OVlpams/xtLQ09ezZ80pGXmUw0gkAAGDDstmLsyL7dE6cOFEpKSnq2rWrevToofnz5+vIkSN66KGHJElTpkzRsWPHtGjRIu970tPTJUlnz57V119/rfT0dIWGhvrd57yqIOkEAACw43IXF3/15XTffffp5MmTeu6555SVlaX27dtr1apV3iczZmVlXbZnZ+fOnb0/79y5U2+//bYSEhJ0+PDhcn9+ZSPpBAAAsGGFhMgKqeOnvrBC7T788MN6+OGHS6z705/+dNkxY0yFPqcqIOkEAACwY9mMdFoVewxmbULSCQAAYCcI0+u1DUknAACAjbLu04nSkXQCAADYCakj+dmnUxVc01mbkHQCAADYCMaWSbUNSScAAIAduw3gmV63RdIJAABghxuJAkbSCQAAYMNy1/G/T6e79DoUI+kEAACwYbncsvyMZvqrQzGSTgAAADsul830Oms67ZB0AgAA2OFGooCRdAIAANhgy6TAkXQCAADYCQm12Ry+oPJiqaZIOgEAAGzwGMzA1Zqk8+qYCEVGRjgdRoWEuy2nQwjY1Y3CnQ4hIL+cMcTpEGqt0Lw8p0MAAMmy2afTYnrdTq1JOgEAACrMsiTLz2imVf0HiIKNpBMAAMCGcYXIuEpPm/zVoRjfEAAAgB3LZTPSyZpOOySdAAAAdizL/xQ60+u2HE3Lp06dKsuyfEqzZs186lu3bq369eurUaNG6tevn7Zt2+ZgxAAAoFa6uDm8vwK/HB/pbNeundatW+d97b5kc9Vrr71Ws2fPVqtWrfTtt99q5syZ6t+/vz7//HM1adLEiXABAEAtxJrOwDn+DYWEhPiMbl7q/vvv93k9Y8YMvf766/r00091yy23VEZ4AAAArOm8AhxPOjMyMhQXF6ewsDB169ZN06dPV6tWrS4778KFC5o/f76ioqLUsWPHUtvLz89Xfn6+93Uee/wBtQp9AICgIOkMmKPfULdu3bRo0SKtWbNGCxYsUHZ2tnr27KmTJ096z1m5cqUaNGig8PBwzZw5U2lpaYqJiSm1zdTUVEVFRXlLfHx8ZVwKgCqCPgBAMBjLkrFcfgo3EtmxjDHG6SAuOnfunK6++mo99thjmjhxovdYVlaWcnJytGDBAq1fv17btm1T06ZNS2yjpFGO+Ph45ebmKjIyslKu40o7euqs0yEErMBTZf43q5DEmOr5NKuaIC8vT1FRUWX+O1wT+wCgNitvHxCsz8/5/FNFRpT+uyDvzBnFXNOhRvU1q1evVoMGDXTjjTdKkl599VUtWLBAbdu21auvvqpGjRqVq70qNRZcv359JSUlKSMjw+fYNddco+7du+v1119XSEiIXn/99VLbCAsLU2RkpE8BUHvQBwAIiovT6/5KDTN58mTvEqU9e/boN7/5jQYNGqSDBw96BwfLw/E1nZfKz8/Xvn371Lt371LPMcb4jGIAAAAE28VpdH/1Nc2hQ4fUtm1bSdKyZcv04x//WNOnT9euXbs0aNCgcrfn6Dc0adIkbdy4UYcOHdK2bds0dOhQ5eXlaeTIkTp37pyefPJJbd26VV9++aV27dql0aNH6+jRo7rnnnucDBsAANQ2ls0enTUw6QwNDdX58+clSevWrVP//v0lSY0bN67QTZqOjnQePXpUw4cPV05Ojpo0aaLu3btr69atSkhI0Hfffad//etfWrhwoXJychQdHa3rr79emzZtUrt27ZwMGwAA1Da18O71G2+8URMnTlSvXr20fft2LV26VJJ04MABXXXVVeVuz9Gkc8mSJaXWhYeHa/ny5ZUYDQAAQClcIcXFX30NM3v2bD388MN65513NHfuXP3gBz+QJL3//vu67bbbyt1ezfuGAAAArrCLWyb5q69pWrRooZUrV152fObMmRVqr+aNBQMAAFxpQbp7fc6cOUpMTFR4eLiSk5O1adMmv+dv3LhRycnJCg8PV6tWrTRv3rwKfW55ffvtt8rLy/Mp5VXub2jUqFH68MMPy/1BAAAA1ZZl2ZdyWrp0qcaPH6+nnnpKu3fvVu/evTVw4EAdOXKkxPMPHTqkQYMGqXfv3tq9e7eefPJJPfroo1q2bFmgV1eic+fOaezYsWratKkaNGigRo0a+ZTyKnfSeebMGfXv318//OEPNX36dB07dqzcHwoAAFCdGFeIbSmvGTNm6MEHH9To0aPVpk0bzZo1S/Hx8Zo7d26J58+bN08tWrTQrFmz1KZNG40ePVo///nP9eKLLwZ6eSV67LHHtH79es2ZM0dhYWF67bXX9OyzzyouLk6LFi0qd3vlTjqXLVumY8eOaezYsfrrX/+qli1bauDAgXrnnXdUUFBQ7gAAAACqvDJOr39/Crq0vcUvXLignTt3erchuqh///7asmVLie/56KOPLjt/wIAB2rFjR1BysHfffVdz5szR0KFDFRISot69e+u3v/2tpk+frsWLF5e7vQotQIiOjta4ceO0e/dubd++Xddcc41SUlIUFxenCRMm+DxRCAAAoLorvpHIf5Gk+Ph4RUVFeUtqamqJ7eXk5KioqEixsbE+x2NjY5WdnV3ie7Kzs0s8v7CwUDk5OVfgKn2dOnVKiYmJkqTIyEidOnVKUvFWShVZahnQjURZWVlau3at1q5dK7fbrUGDBmnv3r1q27Zthe9sAgAAqGqMsS+SlJmZqdzcXG+ZMmWK33at760FNcZcdszu/JKOXwmtWrXS4cOHJUlt27bVX/7yF0nFI6ANGzYsd3vlXoBQUFCgFStW6I033tDatWvVoUMHTZgwQQ888IAiIiIkFe+/+atf/UoTJkwod0AAAABVTZExKrqYWZZSLxWPCEZGRtq2FxMTI7fbfdmo5okTJy4bzbyoWbNmJZ4fEhKi6Oho288sr5/97Gf65JNP1KdPH02ZMkWDBw/WK6+8osLCQs2YMaPc7ZU76WzevLk8Ho+GDx+u7du3q1OnTpedM2DAgAplwAAAAFWRxxQXf/XlERoaquTkZKWlpenOO+/0Hk9LS9NPfvKTEt/To0cPvfvuuz7H1q5dq65du6pOnTrlC6AMLh08vPnmm/Wvf/1LO3bs0NVXX62OHTuWu71yJ50zZ87UPffco/Dw8FLPadSokQ4dOlTuYAAAAKoiY4x3Kru0+vKaOHGiUlJS1LVrV/Xo0UPz58/XkSNH9NBDD0mSpkyZomPHjnnvFH/ooYc0e/ZsTZw4UWPGjNFHH32k119/XX/+858rdlHl1KJFC7Vo0aLC7y930pmSklLhDwMAAKiOrvRIpyTdd999OnnypJ577jllZWWpffv2WrVqlRISEiQV3ztz6Z6diYmJWrVqlSZMmKBXX31VcXFxevnll3X33XeX/8NL8fLLL+sXv/iFwsPD9fLLL/s999FHHy1X25apSGpejeTl5SkqKkq5ubllWmNRFR09ddbpEAJWUJG/jVVIYkyE0yHUWoH+Ha4JfQBQmzn9d/ji5x86mqUIP59/Ji9PiVc1r/Z9TWJionbs2KHo6GjvneslsSxLBw8eLFfbPHsdAADARpHHqMjPAIq/uurk0uWRl/58Je6S59nrAAAANjxlKDXR66+/rvbt2ys8PFzh4eFq3769XnvttQq1xUgnAACAjUv34iytvqZ5+umnNXPmTP36179Wjx49JBU/FWnChAk6fPiwpk2bVq72SDoBAABsBONGoqpu7ty5WrBggYYPH+49dvvtt6tDhw769a9/TdIJAABwpZV1c/iapKioSF27dr3seHJysgoLC8vdHms6AQAAbBjZPAbT6QCD4Kc//anmzp172fH58+frgQceKHd7jHQCAADY8Bgjj5/RTH911cnEiRO9P1uWpddee01r165V9+7dJUlbt25VZmamRowYUe62SToBAABsGPkfzawZKae0e/dun9fJycmSpC+++EKS1KRJEzVp0kR79+4td9sknQAAADY8HqnIz75InhqyZ9IHH3wQtLZJOgEAAGx4ZOTxM57prw7FSDoBAABs1MZ9Oq80kk4AAAAbtXGfziuNpBMAAMBGbdyn80oj6QQAALDB9HrgSDqrgZi6bqdDCFidnM+dDiFASU4HgFrs5JnzTocQsOiIek6HAASktuzTGUwknQAAADaKbLZM8leHYo4+BnPq1KmyLMunNGvWTJJUUFCgxx9/XElJSapfv77i4uI0YsQIHT9+3MmQAQBALXRxpNNfgX+Oj3S2a9dO69at8752u4unks+fP69du3bp6aefVseOHXX69GmNHz9et99+u3bs2OFUuAAAoBYq9BgV+NkBvpDb1205nnSGhIR4RzcvFRUVpbS0NJ9jr7zyim644QYdOXJELVq0qKwQAQBALcf0euAcnV6XpIyMDMXFxSkxMVHDhg3TwYMHSz03NzdXlmWpYcOGlRcgAACo9ZheD5yjI53dunXTokWLdO211+qrr77StGnT1LNnT+3du1fR0dE+53733Xd64okndP/99ysyMrLUNvPz85Wfn+99nZeXF7T4AVQ99AEAgoF9OgPn6EjnwIEDdffddyspKUn9+vXTe++9J0lauHChz3kFBQUaNmyYPB6P5syZ47fN1NRURUVFeUt8fHzQ4gdQ9dAHAAiGAo9RQZGfwppOW45Pr1+qfv36SkpKUkZGhvdYQUGB7r33Xh06dEhpaWl+RzklacqUKcrNzfWWzMzMYIcNoAqhDwAQDMZmat0w0mnL8RuJLpWfn699+/apd+/ekv6TcGZkZOiDDz64bMq9JGFhYQoLCwt2qACqKPoAAMFQZIqLv3r452jSOWnSJA0ZMkQtWrTQiRMnNG3aNOXl5WnkyJEqLCzU0KFDtWvXLq1cuVJFRUXKzs6WJDVu3FihoaFOhg4AAGoRnkgUOEeTzqNHj2r48OHKyclRkyZN1L17d23dulUJCQk6fPiwVqxYIUnq1KmTz/s++OAD9e3bt/IDBgAAtVJBkUcFfvZF8leHYo4mnUuWLCm1rmXLlqyPAAAAVQLT64GrUms6AQAAqiKm1wNH0gkAAGDD4zHy+NkWyV8dipF0AgAA2Ch+9nrpiSXPXrdXpfbpBAAAqIouPpHIXwmW06dPKyUlxfvQi5SUFH3zzTd+37N8+XINGDBAMTExsixL6enpQYuvrEg6AQAAbFycXvdXguX+++9Xenq6Vq9erdWrVys9PV0pKSl+33Pu3Dn16tVLL7zwQtDiKi+m1wEAAGwUyebu9SB97r59+7R69Wpt3bpV3bp1kyQtWLBAPXr00P79+3XdddeV+L6LSenhw4eDFFn5MdIJAABgw98jMO3ubA/ERx99pKioKG/CKUndu3dXVFSUtmzZEpTPDBZGOgEAAGwUFHnkLsPm8Hl5eT7HA300b3Z2tpo2bXrZ8aZNm3qf1FhdMNIJAABgo8hjbIskxcfHe2/4iYqKUmpqaontTZ06VZZl+S07duyQJFmWddn7jTElHq/KGOkEAACwcWliWVq9JGVmZioyMtJ7vLRRzrFjx2rYsGF+P7Nly5b69NNP9dVXX11W9/XXXys2NrYsoVcZJJ0AAAA2ijyySTqL/xsZGemTdJYmJiZGMTExtuf16NFDubm52r59u2644QZJ0rZt25Sbm6uePXuWLfgqgul1AAAAGxcKPbYlGNq0aaPbbrtNY8aM0datW7V161aNGTNGP/7xj33uXG/durX+9re/eV+fOnVK6enp+uyzzyRJ+/fvV3p6uqPrQEk6AQAAbHhs1nMGc5/OxYsXKykpSf3791f//v3VoUMHvfnmmz7n7N+/X7m5ud7XK1asUOfOnTV48GBJ0rBhw9S5c2fNmzcvaHHaYXodAADARpGxWdMZxCcSNW7cWG+99Zbfc8z3Pn/UqFEaNWpU0GKqCJJOAAAAG2W9kQilI+kEAACwkV/okfys28wP0prOmoSkEwAAwAYjnYEj6QQAALDhsUk6g3kjUU1B0gkAAGCjyBi/NwsF80aimoKkEwAAwMYFmzWdwdqnsyYh6QQAALDBms7AkXQCAADYKDIeFXlKH80sMox02iHpBAAAsMGNRIEj6QQAALBR5DFyMb0eEJJOAAAAG/mFRh4/NwsVFJJ02iHpBAAAsMFIZ+BIOgEAAGyQdAaOpBMAAMAGNxIFjqSzGoi787+dDiFgp1b/P6dDAKqt6Ih6TocA1HqFRf43hy8sYsskOy4nP3zq1KmyLMunNGvWzFu/fPlyDRgwQDExMbIsS+np6c4FCwAAai2Px9gW+Odo0ilJ7dq1U1ZWlrfs2bPHW3fu3Dn16tVLL7zwgoMRAgCA2s4YY1vgn+PT6yEhIT6jm5dKSUmRJB0+fLgSIwIAAPBlPEbGz2imvzoUczzpzMjIUFxcnMLCwtStWzdNnz5drVq1qnB7+fn5ys/P977Oy8u7EmECqCboAwAEQ1GhkeVnL84i9um05ej0erdu3bRo0SKtWbNGCxYsUHZ2tnr27KmTJ09WuM3U1FRFRUV5S3x8/BWMGEBVRx8AIBiYXg+co0nnwIEDdffddyspKUn9+vXTe++9J0lauHBhhducMmWKcnNzvSUzM/NKhQugGqAPABAM3EgUOMen1y9Vv359JSUlKSMjo8JthIWFKSws7ApGBaA6oQ8AEAys6Qyc43evXyo/P1/79u1T8+bNnQ4FAADgP/6ddJZWRNJpy9GRzkmTJmnIkCFq0aKFTpw4oWnTpikvL08jR46UJJ06dUpHjhzR8ePHJUn79++XJDVr1qzUO94BAACutCKPR/KzAXyRh83h7Tg60nn06FENHz5c1113ne666y6FhoZq69atSkhIkCStWLFCnTt31uDBgyVJw4YNU+fOnTVv3jwnwwYAALWMv1FOu6l3FHN0pHPJkiV+60eNGqVRo0ZVTjAAAACl8Hgky++z1ysxmGqqSt1IBAAAUBXZbYvElkn2SDoBAABsFBUayc3m8IEg6QQAALDBlkmBI+kEAACwQdIZOJJOAAAAGx5jZPlZt+lhTaetKrU5PAAAQFXkKfLIU+in+NnDM1CnT59WSkqKoqKiFBUVpZSUFH3zzTelnl9QUKDHH39cSUlJql+/vuLi4jRixAjvvudOIekEAACwYWyeux7M6fX7779f6enpWr16tVavXq309HSlpKSUev758+e1a9cuPf3009q1a5eWL1+uAwcO6Pbbbw9ajGXB9DoAAIANp7ZM2rdvn1avXq2tW7eqW7dukqQFCxaoR48e2r9/v6677rrL3hMVFaW0tDSfY6+88opuuOEGHTlyRC1atAhKrHYY6QQAALDh1BOJPvroI0VFRXkTTknq3r27oqKitGXLljK3k5ubK8uy1LBhwyBEWTaMdAIAANgoKiyUcRWWWu8pLK7Ly8vzOR4WFqawsLAKf252draaNm162fGmTZsqOzu7TG189913euKJJ3T//fcrMjKywrEEipFOAAAAG8ZTZFskKT4+3nvDT1RUlFJTU0tsb+rUqbIsy2/ZsWOHJMmyrMvjMabE499XUFCgYcOGyePxaM6cOQF8A4FjpBMAAMCG8Xi8iWVp9ZKUmZnpM5pY2ijn2LFjNWzYML+f2bJlS3366af66quvLqv7+uuvFRsb6/f9BQUFuvfee3Xo0CGtX7/e0VFOiaQTAADAlikqkinyk3T+uy4yMrJMyV1MTIxiYmJsz+vRo4dyc3O1fft23XDDDZKkbdu2KTc3Vz179iz1fRcTzoyMDH3wwQeKjo62/axgY3odAADAhjE20+um9IQ0EG3atNFtt92mMWPGaOvWrdq6davGjBmjH//4xz53rrdu3Vp/+9vfJEmFhYUaOnSoduzYocWLF6uoqEjZ2dnKzs7WhQsXghJnWTDSCQAAYMNTeEGy3P7rg2Tx4sV69NFH1b9/f0nS7bffrtmzZ/ucs3//fuXm5kqSjh49qhUrVkiSOnXq5HPeBx98oL59+wYtVn9IOgEAAGxcerNQafXB0rhxY7311lt+z7l0n9CWLVsGbd/QQJB0AgAA2CjrjUQoHUknAACADY+nSPKTdHqCONJZU5B0AgAA2Che01n6/dfBXNNZU5B0AgAA2CkqknH5Gc30s50SipF0AgAA2DDG//R6sLZMqklIOgEAAGwYj8d/0smNRLZIOgEAAGx4Cgtk+XmmjiksqMRoqieSTgAAABvG5u71YO7TWVOQdAIAANgg6QwcSScAAIANj6dIFklnQEg6AQAAbHgKC2QZq9R6U8SaTjsknQAAADaMp0iyGOkMBEknAACADZLOwNX4pNMYI0nKy8tzOJKKM4XfOR1CwKrz9w9nXfx/5+Lf5fKqCX0AUJsF2gdcKabgO/+JJdPrtmp80nnmzBlJUnx8vMOR1G5RUalOh4Bq7syZM4qKiqrQ+yT6AKC6q2gfEKjQ0FA1a9ZM2Z/9xfbcZs2aKTQ0tBKiqp4s4/Q/HYLM4/Ho+PHjioiIkGWVvgC4MuTl5Sk+Pl6ZmZmKjIx0NJaK4hqcV93jl8p3DcYYnTlzRnFxcXK5St+YuTT0AVcW1+C86h6/VLl9wJXw3Xff6cKFC7bnhYaGKjw8vBIiqp5q/Einy+XSVVdd5XQYPiIjI6ttR3ER1+C86h6/VPZrCGR0gz4gOLgG51X3+KXK6QOuhPDwcJLJK8CZfzIAAACgViHpBAAAQNCRdFaisLAwPfPMMwoLC3M6lArjGpxX3eOXasY1VERNuG6uwXnVPX6pZlwDyq/G30gEAAAA5zHSCQAAgKAj6QQAAEDQkXQCAAAg6Eg6K8mcOXOUmJio8PBwJScna9OmTU6HVGapqam6/vrrFRERoaZNm+qOO+7Q/v37nQ4rIKmpqbIsS+PHj3c6lHI5duyYfvrTnyo6Olr16tVTp06dtHPnTqfDKrPCwkL99re/VWJiourWratWrVrpueeek8fjcTq0oKMPqFroA5xRm/sAkHRWiqVLl2r8+PF66qmntHv3bvXu3VsDBw7UkSNHnA6tTDZu3KhHHnlEW7duVVpamgoLC9W/f3+dO3fO6dAq5OOPP9b8+fPVoUMHp0Mpl9OnT6tXr16qU6eO3n//fX322Wd66aWX1LBhQ6dDK7Pf/e53mjdvnmbPnq19+/bp97//vf77v/9br7zyitOhBRV9QNVCH+Cc2toH4N8Mgu6GG24wDz30kM+x1q1bmyeeeMKhiAJz4sQJI8ls3LjR6VDK7cyZM+aHP/yhSUtLM3369DHjxo1zOqQye/zxx82NN97odBgBGTx4sPn5z3/uc+yuu+4yP/3pTx2KqHLQB1Qd9AHOqq19AIox0hlkFy5c0M6dO9W/f3+f4/3799eWLVsciiowubm5kqTGjRs7HEn5PfLIIxo8eLD69evndCjltmLFCnXt2lX33HOPmjZtqs6dO2vBggVOh1UuN954o/73f/9XBw4ckCR98skn2rx5swYNGuRwZMFDH1C10Ac4qzb2AfiPGv/sdafl5OSoqKhIsbGxPsdjY2OVnZ3tUFQVZ4zRxIkTdeONN6p9+/ZOh1MuS5Ys0a5du/Txxx87HUqFHDx4UHPnztXEiRP15JNPavv27Xr00UcVFhamESNGOB1emTz++OPKzc1V69at5Xa7VVRUpOeff17Dhw93OrSgoQ+oOugDnFcb+wD8B0lnJbEsy+e1MeayY9XB2LFj9emnn2rz5s1Oh1IumZmZGjdunNauXavw8HCnw6kQj8ejrl27avr06ZKkzp07a+/evZo7d261+YWzdOlSvfXWW3r77bfVrl07paena/z48YqLi9PIkSOdDi+o6AOcRR9QNdTmPgAknUEXExMjt9t92YjGiRMnLhv5qOp+/etfa8WKFfrwww911VVXOR1OuezcuVMnTpxQcnKy91hRUZE+/PBDzZ49W/n5+XK73Q5GaK958+Zq27atz7E2bdpo2bJlDkVUfpMnT9YTTzyhYcOGSZKSkpL05ZdfKjU1tcb+wqEPqBroA6qG2tgH4D9Y0xlkoaGhSk5OVlpams/xtLQ09ezZ06GoyscYo7Fjx2r58uVav369EhMTnQ6p3G655Rbt2bNH6enp3tK1a1c98MADSk9Pr/K/bCSpV69el21Tc+DAASUkJDgUUfmdP39eLpdvt+N2u2v0din0AVUDfUDVUBv7AFzCybuYaoslS5aYOnXqmNdff9189tlnZvz48aZ+/frm8OHDTodWJr/61a9MVFSU2bBhg8nKyvKW8+fPOx1aQKrbnavbt283ISEh5vnnnzcZGRlm8eLFpl69euatt95yOrQyGzlypPnBD35gVq5caQ4dOmSWL19uYmJizGOPPeZ0aEFFH1A10QdUvtraB6AYSWclefXVV01CQoIJDQ01Xbp0qVZbjUgqsbzxxhtOhxaQ6vYLxxhj3n33XdO+fXsTFhZmWrdubebPn+90SOWSl5dnxo0bZ1q0aGHCw8NNq1atzFNPPWXy8/OdDi3o6AOqHvqAyleb+wAYYxljjDNjrAAAAKgtWNMJAACAoCPpBAAAQNCRdAIAACDoSDoBAAAQdCSdAAAACDqSTgAAAAQdSScAAACCjqQTAAAAQUfSCQAAgKAj6QQAAEDQkXQCAAAg6Eg6US19/fXXatasmaZPn+49tm3bNoWGhmrt2rUORgagMtAHANWPZYwxTgcBVMSqVat0xx13aMuWLWrdurU6d+6swYMHa9asWU6HBqAS0AcA1QtJJ6q1Rx55ROvWrdP111+vTz75RB9//LHCw8OdDgtAJaEPAKoPkk5Ua99++63at2+vzMxM7dixQx06dHA6JACViD4AqD5Y04lq7eDBgzp+/Lg8Ho++/PJLp8MBUMnoA4Dqg5FOVFsXLlzQDTfcoE6dOql169aaMWOG9uzZo9jYWKdDA1AJ6AOA6oWkE9XW5MmT9c477+iTTz5RgwYNdPPNNysiIkIrV650OjQAlYA+AKhemF5HtbRhwwbNmjVLb775piIjI+VyufTmm29q8+bNmjt3rtPhAQgy+gCg+mGkEwAAAEHHSCcAAACCjqQTAAAAQUfSCQAAgKAj6QQAAEDQkXQCAAAg6Eg6AQAAEHQknQAAAAg6kk4AAAAEHUknAAAAgo6kEwAAAEFH0gkAAICgI+kEAABA0P1/BrTJJdqpPS4AAAAASUVORK5CYII=", "text/plain": [ "
    " ] @@ -3499,9 +3547,18 @@ }, { "cell_type": "code", - "execution_count": 59, + "execution_count": 26, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\jem\\Source\\modelskill\\modelskill\\timeseries\\_track.py:135: UserWarning: Removed 22 duplicate timestamps with keep=first\n", + " warnings.warn(\n" + ] + } + ], "source": [ "import warnings\n", "\n", @@ -3523,12 +3580,12 @@ }, { "cell_type": "code", - "execution_count": 60, + "execution_count": 27, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
    " ] From a235c924182c73dd82b22dfe8cd489f5c595c3e4 Mon Sep 17 00:00:00 2001 From: Jesper Sandvig Mariegaard <34088801+jsmariegaard@users.noreply.github.com> Date: Thu, 4 Jan 2024 12:23:12 +0100 Subject: [PATCH 28/29] rename --- modelskill/comparison/_comparer_plotter.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/modelskill/comparison/_comparer_plotter.py b/modelskill/comparison/_comparer_plotter.py index 6aec55bb9..c28ac977f 100644 --- a/modelskill/comparison/_comparer_plotter.py +++ b/modelskill/comparison/_comparer_plotter.py @@ -723,11 +723,11 @@ def taylor( mtr.cc, ] - s = cmp.skill(metrics=metrics) + sk = cmp.skill(metrics=metrics) - if s is None: # TODO + if sk is None: # TODO return - df = s.to_dataframe() + df = sk.to_dataframe() ref_std = 1.0 if normalize_std else df.iloc[0]["_std_obs"] df = df[["_std_obs", "_std_mod", "cc"]].copy() From 256a344b31c0e00c19113b48d2bad9432321da44 Mon Sep 17 00:00:00 2001 From: Jesper Sandvig Mariegaard <34088801+jsmariegaard@users.noreply.github.com> Date: Thu, 4 Jan 2024 12:23:36 +0100 Subject: [PATCH 29/29] cmp.to_dataframe removed --- .../Metocean_track_comparison_global.ipynb | 502 ++++++++++++++++-- 1 file changed, 465 insertions(+), 37 deletions(-) diff --git a/notebooks/Metocean_track_comparison_global.ipynb b/notebooks/Metocean_track_comparison_global.ipynb index 63b843306..2320af016 100644 --- a/notebooks/Metocean_track_comparison_global.ipynb +++ b/notebooks/Metocean_track_comparison_global.ipynb @@ -274,7 +274,7 @@ { "data": { "text/plain": [ - "modelskill.spatial.GridSkill" + "modelskill.skill_grid.SkillGrid" ] }, "execution_count": 8, @@ -348,10 +348,9 @@ " \n", " x\n", " y\n", - " obs_val\n", - " mod_val\n", - " model\n", - " observation\n", + " Observation\n", + " z\n", + " GWM\n", " val_cat\n", " \n", " \n", @@ -362,7 +361,6 @@ " \n", " \n", " \n", - " \n", " \n", " \n", " \n", @@ -371,9 +369,8 @@ " -33.706020\n", " 23.181158\n", " 2.611\n", + " NaN\n", " 2.292599\n", - " GWM\n", - " 3a\n", " Hm0[m]=[2, 5)\n", " \n", " \n", @@ -381,9 +378,8 @@ " -33.720741\n", " 23.240074\n", " 2.608\n", + " NaN\n", " 2.292612\n", - " GWM\n", - " 3a\n", " Hm0[m]=[2, 5)\n", " \n", " \n", @@ -391,9 +387,8 @@ " -33.735474\n", " 23.298990\n", " 2.518\n", + " NaN\n", " 2.292624\n", - " GWM\n", - " 3a\n", " Hm0[m]=[2, 5)\n", " \n", " \n", @@ -401,9 +396,8 @@ " -33.750214\n", " 23.357904\n", " 2.729\n", + " NaN\n", " 2.292637\n", - " GWM\n", - " 3a\n", " Hm0[m]=[2, 5)\n", " \n", " \n", @@ -411,9 +405,8 @@ " -33.764965\n", " 23.416819\n", " 2.593\n", + " NaN\n", " 2.292650\n", - " GWM\n", - " 3a\n", " Hm0[m]=[2, 5)\n", " \n", " \n", @@ -421,21 +414,21 @@ "" ], "text/plain": [ - " x y obs_val mod_val model \\\n", - "time \n", - "2018-01-01 00:00:00 -33.706020 23.181158 2.611 2.292599 GWM \n", - "2018-01-01 00:00:01 -33.720741 23.240074 2.608 2.292612 GWM \n", - "2018-01-01 00:00:02 -33.735474 23.298990 2.518 2.292624 GWM \n", - "2018-01-01 00:00:03 -33.750214 23.357904 2.729 2.292637 GWM \n", - "2018-01-01 00:00:04 -33.764965 23.416819 2.593 2.292650 GWM \n", - "\n", - " observation val_cat \n", - "time \n", - "2018-01-01 00:00:00 3a Hm0[m]=[2, 5) \n", - "2018-01-01 00:00:01 3a Hm0[m]=[2, 5) \n", - "2018-01-01 00:00:02 3a Hm0[m]=[2, 5) \n", - "2018-01-01 00:00:03 3a Hm0[m]=[2, 5) \n", - "2018-01-01 00:00:04 3a Hm0[m]=[2, 5) " + " x y Observation z GWM \\\n", + "time \n", + "2018-01-01 00:00:00 -33.706020 23.181158 2.611 NaN 2.292599 \n", + "2018-01-01 00:00:01 -33.720741 23.240074 2.608 NaN 2.292612 \n", + "2018-01-01 00:00:02 -33.735474 23.298990 2.518 NaN 2.292624 \n", + "2018-01-01 00:00:03 -33.750214 23.357904 2.729 NaN 2.292637 \n", + "2018-01-01 00:00:04 -33.764965 23.416819 2.593 NaN 2.292650 \n", + "\n", + " val_cat \n", + "time \n", + "2018-01-01 00:00:00 Hm0[m]=[2, 5) \n", + "2018-01-01 00:00:01 Hm0[m]=[2, 5) \n", + "2018-01-01 00:00:02 Hm0[m]=[2, 5) \n", + "2018-01-01 00:00:03 Hm0[m]=[2, 5) \n", + "2018-01-01 00:00:04 Hm0[m]=[2, 5) " ] }, "execution_count": 10, @@ -444,9 +437,9 @@ } ], "source": [ - "all_df = cmp.to_dataframe()\n", - "mean_val = all_df[['mod_val','obs_val']].mean(axis=1)\n", - "all_df['val_cat'] = pd.cut(mean_val,[0,2,5,np.inf],labels=[\"Hm0[m]=[0, 2)\",\"Hm0[m]=[2, 5)\",\"Hm0[m]=[5, inf)\"])\n", + "all_df = cmp.data.to_dataframe()\n", + "mean_val = all_df[['GWM','Observation']].mean(axis=1)\n", + "all_df['val_cat'] = pd.cut(mean_val, [0,2,5,np.inf], labels=[\"Hm0[m]=[0, 2)\",\"Hm0[m]=[2, 5)\",\"Hm0[m]=[5, inf)\"])\n", "all_df.head()" ] }, @@ -463,6 +456,441 @@ "cell_type": "code", "execution_count": 12, "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
    \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
    <xarray.Dataset>\n",
    +                            "Dimensions:      (time: 9105388)\n",
    +                            "Coordinates:\n",
    +                            "  * time         (time) datetime64[ns] 2018-01-01 ... 2018-12-30T23:59:59\n",
    +                            "    x            (time) float64 -33.71 -33.72 -33.74 ... 153.7 153.7 153.7\n",
    +                            "    y            (time) float64 23.18 23.24 23.3 23.36 ... 23.19 23.13 23.07\n",
    +                            "    z            float64 nan\n",
    +                            "Data variables:\n",
    +                            "    Observation  (time) float64 2.611 2.608 2.518 2.729 ... 3.572 3.505 3.364\n",
    +                            "    GWM          (time) float64 2.293 2.293 2.293 2.293 ... 2.693 2.693 2.693\n",
    +                            "    val_cat      (time) object 'Hm0[m]=[2, 5)' ... 'Hm0[m]=[2, 5)'\n",
    +                            "Attributes:\n",
    +                            "    gtype:               track\n",
    +                            "    modelskill_version:  1.0.dev23\n",
    +                            "    weight:              1.0\n",
    +                            "    name:                3a
    " + ], + "text/plain": [ + "\n", + "Dimensions: (time: 9105388)\n", + "Coordinates:\n", + " * time (time) datetime64[ns] 2018-01-01 ... 2018-12-30T23:59:59\n", + " x (time) float64 -33.71 -33.72 -33.74 ... 153.7 153.7 153.7\n", + " y (time) float64 23.18 23.24 23.3 23.36 ... 23.19 23.13 23.07\n", + " z float64 nan\n", + "Data variables:\n", + " Observation (time) float64 2.611 2.608 2.518 2.729 ... 3.572 3.505 3.364\n", + " GWM (time) float64 2.293 2.293 2.293 2.293 ... 2.693 2.693 2.693\n", + " val_cat (time) object 'Hm0[m]=[2, 5)' ... 'Hm0[m]=[2, 5)'\n", + "Attributes:\n", + " gtype: track\n", + " modelskill_version: 1.0.dev23\n", + " weight: 1.0\n", + " name: 3a" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "cmp.data" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, "outputs": [], "source": [ "ss = cmp.gridded_skill(by=[\"val_cat\"], metrics=[\"bias\"], bins=(np.arange(-180,180,5), np.arange(-90,90,5)), n_min=20)" @@ -470,7 +898,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 14, "metadata": {}, "outputs": [], "source": [ @@ -481,7 +909,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 15, "metadata": {}, "outputs": [ { @@ -501,7 +929,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 16, "metadata": {}, "outputs": [ {