From b9ee4ba8f23516775b15a53acd5393d5d558276c Mon Sep 17 00:00:00 2001 From: manishvenu Date: Fri, 25 Oct 2024 11:38:42 -0600 Subject: [PATCH 01/87] Add GFDL Rotation Code and minor tides debugging in setup_run_directory MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The GFDL rotation code was commented out🙈 --- regional_mom6/regional_mom6.py | 26 ++++++++++++++++++-------- 1 file changed, 18 insertions(+), 8 deletions(-) diff --git a/regional_mom6/regional_mom6.py b/regional_mom6/regional_mom6.py index cc843959..1bbc2980 100644 --- a/regional_mom6/regional_mom6.py +++ b/regional_mom6/regional_mom6.py @@ -2251,12 +2251,13 @@ def setup_run_directory( # Check if we can implement tides if with_tides: + if not (self.mom_input_dir / "forcing").exists(): + all_files = os.listdir(Path(self.mom_input_dir)) + else: + all_files = os.listdir(Path(self.mom_input_dir / "forcing"))+ os.listdir(Path(self.mom_input_dir)) tidal_files_exist = any( "tidal" in filename - for filename in ( - os.listdir(Path(self.mom_input_dir / "forcing")) - + os.listdir(Path(self.mom_input_dir)) - ) + for filename in all_files ) if not tidal_files_exist: raise ( @@ -3439,13 +3440,22 @@ def regrid_tides( # Convert complex u and v to ellipse, # rotate ellipse from earth-relative to model-relative, # and convert ellipse back to amplitude and phase. + # There is probably a complicated trig identity for this? But + # this works too. + + if self.orientation in ['south', 'north']: + angle = self.coords['angle'] + elif self.orientation in ['west', 'east']: + angle = self.coords['angle'] + + # Convert complex u and v to ellipse, + # rotate ellipse from earth-relative to model-relative, + # and convert ellipse back to amplitude and phase. + print(ucplex) SEMA, ECC, INC, PHA = ap2ep(ucplex, vcplex) - # Rotate to the model grid by adjusting the inclination. - # Requries that angle is in radians. - ua, va, up, vp = ep2ap(SEMA, ECC, INC, PHA) - + print(ua) ds_ap = xr.Dataset( {f"uamp_{self.segment_name}": ua, f"vamp_{self.segment_name}": va} ) From ed4e02d7e4786248aba6c7723d59005a1ffb9ce2 Mon Sep 17 00:00:00 2001 From: manishvenu Date: Fri, 25 Oct 2024 11:42:21 -0600 Subject: [PATCH 02/87] Black --- regional_mom6/regional_mom6.py | 23 +++++++++++------------ 1 file changed, 11 insertions(+), 12 deletions(-) diff --git a/regional_mom6/regional_mom6.py b/regional_mom6/regional_mom6.py index 1bbc2980..d99b52f8 100644 --- a/regional_mom6/regional_mom6.py +++ b/regional_mom6/regional_mom6.py @@ -2254,11 +2254,10 @@ def setup_run_directory( if not (self.mom_input_dir / "forcing").exists(): all_files = os.listdir(Path(self.mom_input_dir)) else: - all_files = os.listdir(Path(self.mom_input_dir / "forcing"))+ os.listdir(Path(self.mom_input_dir)) - tidal_files_exist = any( - "tidal" in filename - for filename in all_files - ) + all_files = os.listdir( + Path(self.mom_input_dir / "forcing") + ) + os.listdir(Path(self.mom_input_dir)) + tidal_files_exist = any("tidal" in filename for filename in all_files) if not tidal_files_exist: raise ( "No files with 'tidal' in their names found in the forcing or input directory. If you meant to use tides, please run the setup_tides_rectangle_boundaries method first. That does output some tidal files." @@ -3441,13 +3440,13 @@ def regrid_tides( # rotate ellipse from earth-relative to model-relative, # and convert ellipse back to amplitude and phase. # There is probably a complicated trig identity for this? But - # this works too. - - if self.orientation in ['south', 'north']: - angle = self.coords['angle'] - elif self.orientation in ['west', 'east']: - angle = self.coords['angle'] - + # this works too. + + if self.orientation in ["south", "north"]: + angle = self.coords["angle"] + elif self.orientation in ["west", "east"]: + angle = self.coords["angle"] + # Convert complex u and v to ellipse, # rotate ellipse from earth-relative to model-relative, # and convert ellipse back to amplitude and phase. From e019788b9f2e9a35a023e32302f9a9aec5d24bd4 Mon Sep 17 00:00:00 2001 From: manishvenu Date: Fri, 25 Oct 2024 14:22:55 -0600 Subject: [PATCH 03/87] Actual Angle Change --- regional_mom6/regional_mom6.py | 1 + 1 file changed, 1 insertion(+) diff --git a/regional_mom6/regional_mom6.py b/regional_mom6/regional_mom6.py index d99b52f8..b312d09a 100644 --- a/regional_mom6/regional_mom6.py +++ b/regional_mom6/regional_mom6.py @@ -3453,6 +3453,7 @@ def regrid_tides( print(ucplex) SEMA, ECC, INC, PHA = ap2ep(ucplex, vcplex) + INC -= angle.data[np.newaxis, :] ua, va, up, vp = ep2ap(SEMA, ECC, INC, PHA) print(ua) ds_ap = xr.Dataset( From cda881d690abd417bc91d84a7671e88ab92bd344 Mon Sep 17 00:00:00 2001 From: manishvenu Date: Fri, 25 Oct 2024 17:19:49 -0600 Subject: [PATCH 04/87] Minor Clean --- regional_mom6/regional_mom6.py | 11 +++-------- 1 file changed, 3 insertions(+), 8 deletions(-) diff --git a/regional_mom6/regional_mom6.py b/regional_mom6/regional_mom6.py index b312d09a..0854bbc1 100644 --- a/regional_mom6/regional_mom6.py +++ b/regional_mom6/regional_mom6.py @@ -3442,24 +3442,19 @@ def regrid_tides( # There is probably a complicated trig identity for this? But # this works too. - if self.orientation in ["south", "north"]: - angle = self.coords["angle"] - elif self.orientation in ["west", "east"]: - angle = self.coords["angle"] + + angle = self.coords["angle"] # Convert complex u and v to ellipse, # rotate ellipse from earth-relative to model-relative, # and convert ellipse back to amplitude and phase. - print(ucplex) SEMA, ECC, INC, PHA = ap2ep(ucplex, vcplex) - INC -= angle.data[np.newaxis, :] ua, va, up, vp = ep2ap(SEMA, ECC, INC, PHA) - print(ua) ds_ap = xr.Dataset( {f"uamp_{self.segment_name}": ua, f"vamp_{self.segment_name}": va} ) - # up, vp aren't dataarrays + # up, vp aren't dataarraysf ds_ap[f"uphase_{self.segment_name}"] = ( ("constituent", self.coords.attrs["locations_name"]), up, From e271cb318525f42ee1d1d059e2d51ab629deac3c Mon Sep 17 00:00:00 2001 From: manishvenu Date: Wed, 6 Nov 2024 14:39:08 -0700 Subject: [PATCH 05/87] Add First Regridding Option --- regional_mom6/regional_mom6.py | 484 ++++++++++++++------------------- regional_mom6/regridding.py | 383 ++++++++++++++++++++++++++ regional_mom6/utils.py | 24 +- 3 files changed, 603 insertions(+), 288 deletions(-) create mode 100644 regional_mom6/regridding.py diff --git a/regional_mom6/regional_mom6.py b/regional_mom6/regional_mom6.py index 0854bbc1..e3bc1995 100644 --- a/regional_mom6/regional_mom6.py +++ b/regional_mom6/regional_mom6.py @@ -21,7 +21,7 @@ from collections import defaultdict import json import copy - +import regridding as rgd warnings.filterwarnings("ignore") __all__ = [ @@ -1669,7 +1669,7 @@ def setup_boundary_tides( This tidal data functions are sourced from the GFDL NWA25 and changed in the following ways: - Converted code for RM6 segment class - Implemented Horizontal Subsetting - - Combined all functions of NWA25 into a four function process (in the style of rm6) (expt.setup_tides_rectangular_boundaries, segment.coords, segment.regrid_tides, segment.encode_tidal_files_and_output) + - Combined all functions of NWA25 into a four function process (in the style of rm6) (expt.setup_tides_rectangular_boundaries, self.coords, segment.regrid_tides, segment.encode_tidal_files_and_output) Original Code was sourced from: @@ -3013,59 +3013,64 @@ def rotate(self, u, v): def regrid_velocity_tracers(self): """ - Cut out and interpolate the velocities and tracers - """ + Cut out and interpolate the velocities and tracers + """ rawseg = xr.open_dataset(self.infile, decode_times=False, engine="netcdf4") + coords = rgd.coords(self.hgrid, self.orientation, self.segment_name) if self.arakawa_grid == "A": + rawseg = rawseg.rename({self.x: "lon", self.y: "lat"}) ## In this case velocities and tracers all on same points - regridder = xe.Regridder( + regridder = rgd.create_regridder( rawseg[self.u], - self.coords, - "bilinear", - locstream_out=True, - reuse_weights=False, - filename=self.outfolder + coords, + self.outfolder / f"weights/bilinear_velocity_weights_{self.orientation}.nc", ) - segment_out = xr.merge( - [ - regridder( - rawseg[ - [self.u, self.v, self.eta] - + [self.tracers[i] for i in self.tracers] - ] - ) + regridded = regridder( + rawseg[ + [self.u, self.v, self.eta] + + [self.tracers[i] for i in self.tracers] ] ) + rotated_u, rotated_v = self.rotate( + regridded[self.u], regridded[self.v] + ) + rotated_ds = xr.Dataset( + { + self.u: rotated_u, + self.v: rotated_v, + } + ) + segment_out = xr.merge( + [rotated_ds, regridded.drop_vars([self.u, self.v])] + ) if self.arakawa_grid == "B": ## All tracers on one grid, all velocities on another - regridder_velocity = xe.Regridder( + regridder_velocity = rgd.create_regridder( rawseg[self.u].rename({self.xq: "lon", self.yq: "lat"}), - self.coords, - "bilinear", - locstream_out=True, - reuse_weights=False, - filename=self.outfolder + coords, + self.outfolder / f"weights/bilinear_velocity_weights_{self.orientation}.nc", ) - - regridder_tracer = xe.Regridder( - rawseg[self.tracers["salt"]].rename({self.xh: "lon", self.yh: "lat"}), - self.coords, - "bilinear", - locstream_out=True, - reuse_weights=False, - filename=self.outfolder + regridder_tracer = rgd.create_regridder( + rawseg[self.tracers["salt"]].rename( + {self.xh: "lon", self.yh: "lat"} + ), + coords, + self.outfolder / f"weights/bilinear_tracer_weights_{self.orientation}.nc", ) + velocities_out = regridder_velocity( - rawseg[[self.u, self.v]].rename({self.xq: "lon", self.yq: "lat"}) + rawseg[[self.u, self.v]].rename( + {self.xq: "lon", self.yq: "lat"} + ) ) velocities_out["u"], velocities_out["v"] = self.rotate( @@ -3085,42 +3090,49 @@ def regrid_velocity_tracers(self): if self.arakawa_grid == "C": ## All tracers on one grid, all velocities on another - regridder_uvelocity = xe.Regridder( + regridder_uvelocity = rgd.create_regridder( rawseg[self.u].rename({self.xq: "lon", self.yh: "lat"}), - self.coords, - "bilinear", - locstream_out=True, - reuse_weights=False, - filename=self.outfolder + coords, + self.outfolder / f"weights/bilinear_uvelocity_weights_{self.orientation}.nc", ) - regridder_vvelocity = xe.Regridder( + + regridder_vvelocity = rgd.create_regridder( rawseg[self.v].rename({self.xh: "lon", self.yq: "lat"}), - self.coords, - "bilinear", - locstream_out=True, - reuse_weights=False, - filename=self.outfolder + coords, + self.outfolder / f"weights/bilinear_vvelocity_weights_{self.orientation}.nc", ) - regridder_tracer = xe.Regridder( - rawseg[self.tracers["salt"]].rename({self.xh: "lon", self.yh: "lat"}), - self.coords, - "bilinear", - locstream_out=True, - reuse_weights=False, - filename=self.outfolder + regridder_tracer = rgd.create_regridder( + rawseg[self.tracers["salt"]].rename( + {self.xh: "lon", self.yh: "lat"} + ), + coords, + self.outfolder / f"weights/bilinear_tracer_weights_{self.orientation}.nc", ) + regridded_u = regridder_uvelocity(rawseg[[self.u]]) + regridded_v = regridder_vvelocity(rawseg[[self.v]]) + + rotated_u, rotated_v = self.rotate( + regridded_u[self.u], regridded_v[self.v] + ) + rotated_ds = xr.Dataset( + { + self.u: rotated_u, + self.v: rotated_v, + } + ) segment_out = xr.merge( [ - regridder_vvelocity(rawseg[[self.v]]), - regridder_uvelocity(rawseg[[self.u]]), + rotated_ds, regridder_tracer( - rawseg[[self.eta] + [self.tracers[i] for i in self.tracers]] + rawseg[ + [self.eta] + [self.tracers[i] for i in self.tracers] + ] ), ] ) @@ -3132,51 +3144,34 @@ def regrid_velocity_tracers(self): del segment_out["lat"] ## Convert temperatures to celsius # use pint if ( - np.nanmin(segment_out[self.tracers["temp"]].isel({self.time: 0, self.z: 0})) + np.nanmin( + segment_out[self.tracers["temp"]].isel({self.time: 0, self.z: 0}) + ) > 100 ): segment_out[self.tracers["temp"]] -= 273.15 segment_out[self.tracers["temp"]].attrs["units"] = "degrees Celsius" # fill in NaNs - segment_out = ( - segment_out.ffill(self.z) - .interpolate_na(f"{self.coords.attrs['parallel']}_{self.segment_name}") - .ffill(f"{self.coords.attrs['parallel']}_{self.segment_name}") - .bfill(f"{self.coords.attrs['parallel']}_{self.segment_name}") + segment_out = rgd.fill_missing_data(segment_out, self.z) + segment_out = rgd.fill_missing_data( + segment_out, f"{self.coords.attrs['parallel']}_{self.segment_name}" ) - - time = np.arange( + + times = xr.DataArray(np.arange( 0, #! Indexing everything from start of experiment = simple but maybe counterintutive? segment_out[self.time].shape[ 0 ], ## Time is indexed from start date of window dtype=float, - ) - - segment_out = segment_out.assign_coords({"time": time}) + ), # Import pandas for this shouldn't be a big deal b/c it's already kinda required somewhere deep in some tree. + dims=["time"]) + # This to change the time coordinate. + segment_out = rgd.add_or_update_time_dim(segment_out,times) segment_out.time.attrs = { - "calendar": "julian", - "units": f"{self.time_units} since {self.startdate}", - } - # Dictionary we built for encoding the netcdf at end - encoding_dict = { - "time": { - "dtype": "double", - }, - f"nx_{self.segment_name}": { - "dtype": "int32", - }, - f"ny_{self.segment_name}": { - "dtype": "int32", - }, - } - - ### Generate the dz variable; needs to be in layer thicknesses - dz = segment_out[self.z].diff(self.z) - dz.name = "dz" - dz = xr.concat([dz, dz[-1]], dim=self.z) - + "calendar": "julian", + "units": f"{self.time_units} since {self.startdate}", + } # Here, keep in mind that 'var' keeps track of the mom6 variable names we want, and self.tracers[var] # will return the name of the variable from the original data @@ -3195,130 +3190,53 @@ def regrid_velocity_tracers(self): ## Rename each variable in dataset segment_out = segment_out.rename({allfields[var]: v}) - ## Rename vertical coordinate for this variable - segment_out[f"{var}_{self.segment_name}"] = segment_out[ - f"{var}_{self.segment_name}" - ].rename({self.z: f"nz_{self.segment_name}_{var}"}) - - ## Replace the old depth coordinates with incremental integers - segment_out[f"nz_{self.segment_name}_{var}"] = np.arange( - segment_out[f"nz_{self.segment_name}_{var}"].size + segment_out = rgd.vertical_coordinate_encoding( + segment_out, v, self.segment_name, self.z ) - ## Re-add the secondary dimension (even though it represents one value..) - segment_out[v] = segment_out[v].expand_dims( - f"{self.coords.attrs['perpendicular']}_{self.segment_name}", - axis=self.coords.attrs["axis_to_expand"], + segment_out = rgd.add_secondary_dimension( + segment_out, v, coords, self.segment_name ) - ## Add the layer thicknesses - segment_out[f"dz_{v}"] = ( - [ - "time", - f"nz_{v}", - f"ny_{self.segment_name}", - f"nx_{self.segment_name}", - ], - da.broadcast_to( - dz.data[None, :, None, None], - segment_out[v].shape, - chunks=( - 1, - None, - None, - None, - ), ## Chunk in each time, and every 5 vertical layers - ), + segment_out = rgd.generate_layer_thickness( + segment_out, v, self.segment_name, self.z ) - encoding_dict[v] = { - "_FillValue": netCDF4.default_fillvals["f8"], - "zlib": True, - # "chunksizes": tuple(s), - } - encoding_dict[f"dz_{v}"] = { - "_FillValue": netCDF4.default_fillvals["f8"], - "zlib": True, - # "chunksizes": tuple(s), - } - - ## appears to be another variable just with integers?? - encoding_dict[f"nz_{self.segment_name}_{var}"] = {"dtype": "int32"} ## Treat eta separately since it has no vertical coordinate. Do the same things as for the surface variables above segment_out = segment_out.rename({self.eta: f"eta_{self.segment_name}"}) - encoding_dict[f"eta_{self.segment_name}"] = { - "_FillValue": netCDF4.default_fillvals["f8"], - } - segment_out[f"eta_{self.segment_name}"] = segment_out[ - f"eta_{self.segment_name}" - ].expand_dims( - f"{self.coords.attrs['perpendicular']}_{self.segment_name}", - axis=self.coords.attrs["axis_to_expand"] - 1, + + segment_out = rgd.add_secondary_dimension( + segment_out, f"eta_{self.segment_name}", coords, self.segment_name ) # Overwrite the actual lat/lon values in the dimensions, replace with incrementing integers - segment_out[f"{self.coords.attrs['parallel']}_{self.segment_name}"] = np.arange( - segment_out[f"{self.coords.attrs['parallel']}_{self.segment_name}"].size + segment_out[f"{self.coords.attrs['parallel']}_{self.segment_name}"] = ( + np.arange( + segment_out[ + f"{self.coords.attrs['parallel']}_{self.segment_name}" + ].size + ) ) segment_out[f"{self.coords.attrs['perpendicular']}_{self.segment_name}"] = [0] - if self.orientation == "north": - self.hgrid_seg = self.hgrid.isel(nyp=[-1]) - self.perpendicular = "ny" - self.parallel = "nx" - - if self.orientation == "south": - self.hgrid_seg = self.hgrid.isel(nyp=[0]) - self.perpendicular = "ny" - self.parallel = "nx" - - if self.orientation == "east": - self.hgrid_seg = self.hgrid.isel(nxp=[-1]) - self.perpendicular = "nx" - self.parallel = "ny" - - if self.orientation == "west": - self.hgrid_seg = self.hgrid.isel(nxp=[0]) - self.perpendicular = "nx" - self.parallel = "ny" - - # Store actual lat/lon values here as variables rather than coordinates - segment_out[f"lon_{self.segment_name}"] = ( - [f"ny_{self.segment_name}", f"nx_{self.segment_name}"], - self.coords.lon.expand_dims( - dim="blank", axis=self.coords.attrs["axis_to_expand"] - 2 - ).data, - ) - segment_out[f"lat_{self.segment_name}"] = ( - [f"ny_{self.segment_name}", f"nx_{self.segment_name}"], - self.coords.lat.expand_dims( - dim="blank", axis=self.coords.attrs["axis_to_expand"] - 2 - ).data, - ) - - # Add units to the lat / lon to keep the `categorize_axis_from_units` checker from throwing warnings - segment_out[f"lat_{self.segment_name}"].attrs = { - "units": "degrees_north", - } - segment_out[f"lon_{self.segment_name}"].attrs = { - "units": "degrees_east", - } - segment_out[f"ny_{self.segment_name}"].attrs = { - "units": "degrees_north", - } - segment_out[f"nx_{self.segment_name}"].attrs = { - "units": "degrees_east", + encoding_dict = { + "time": {"dtype": "double"}, + f"nx_{self.segment_name}": { + "dtype": "int32", + }, + f"ny_{self.segment_name}": { + "dtype": "int32", + }, } - # If repeat-year forcing, add modulo coordinate - if self.repeat_year_forcing: - segment_out["time"] = segment_out["time"].assign_attrs({"modulo": " "}) + encoding_dict = rgd.generate_encoding( + segment_out, encoding_dict, default_fill_value=netCDF4.default_fillvals["f8"] + ) - with ProgressBar(): - segment_out.load().to_netcdf( - self.outfolder / f"forcing_obc_{self.segment_name}.nc", - encoding=encoding_dict, - unlimited_dims="time", - ) + segment_out.load().to_netcdf( + self.outfolder / f"forcing_obc_{self.segment_name}.nc", + encoding=encoding_dict, + unlimited_dims="time", + ) return segment_out, encoding_dict @@ -3342,9 +3260,9 @@ def regrid_tides( General Description: This tidal data functions are sourced from the GFDL NWA25 and changed in the following ways: - - Converted code for RM6 segment class - - Implemented Horizontal Subsetting - - Combined all functions of NWA25 into a four function process (in the style of rm6) (expt.setup_tides_rectangular_boundaries, segment.coords, segment.regrid_tides, segment.encode_tidal_files_and_output) + - Converted code for RM6 segment class + - Implemented Horizontal Subsetting + - Combined all functions of NWA25 into a four function process (in the style of rm6) (expt.setup_tides_rectangular_boundaries, segment.coords, segment.regrid_tides, segment.encode_tidal_files_and_output) Original Code was sourced from: @@ -3356,70 +3274,67 @@ def regrid_tides( Web Address: https://github.com/jsimkins2/nwa25 """ + # Establish Coord + coords = rgd.coords(self.hgrid, self.orientation, self.segment_name) + ########## Tidal Elevation: Horizontally interpolate elevation components ############ - regrid = xe.Regridder( + regrid = rgd.create_regridder( tpxo_h[["lon", "lat", "hRe"]], - self.coords, - method="nearest_s2d", - locstream_out=True, - periodic=False, - filename=Path( - self.outfolder / "forcing" / f"regrid_{self.segment_name}_tidal_elev.nc" + coords, + Path( + self.outfolder + / "forcing" + / f"regrid_{self.segment_name}_tidal_elev.nc" ), - reuse_weights=False, ) + redest = regrid(tpxo_h[["lon", "lat", "hRe"]]) imdest = regrid(tpxo_h[["lon", "lat", "hIm"]]) # Fill missing data. # Need to do this first because complex would get converted to real - redest = redest.ffill(dim=self.coords.attrs["locations_name"], limit=None)[ - "hRe" - ] - imdest = imdest.ffill(dim=self.coords.attrs["locations_name"], limit=None)[ - "hIm" - ] + redest = rgd.fill_missing_data( + redest, f"{coords.attrs['parallel']}_{self.segment_name}" + ) + redest = redest["hRe"] + imdest = rgd.fill_missing_data( + imdest, f"{coords.attrs['parallel']}_{self.segment_name}" + ) + imdest = imdest["hIm"] # Convert complex cplex = redest + 1j * imdest # Convert to real amplitude and phase. ds_ap = xr.Dataset({f"zamp_{self.segment_name}": np.abs(cplex)}) + # np.angle doesn't return dataarray ds_ap[f"zphase_{self.segment_name}"] = ( - ("constituent", self.coords.attrs["locations_name"]), + ("constituent", f"{coords.attrs['parallel']}_{self.segment_name}"), -1 * np.angle(cplex), ) # radians # Add time coordinate and transpose so that time is first, # so that it can be the unlimited dimension - ds_ap, _ = xr.broadcast(ds_ap, times) + times = xr.DataArray( + pd.date_range( + self.startdate, periods=1 + ), # Import pandas for this shouldn't be a big deal b/c it's already kinda required somewhere deep in some tree. + dims=["time"], + ) + + ds_ap = rgd.add_or_update_time_dim(ds_ap, times) ds_ap = ds_ap.transpose( - "time", "constituent", self.coords.attrs["locations_name"] + "time", "constituent", f"{coords.attrs['parallel']}_{self.segment_name}" ) - self.encode_tidal_files_and_output(ds_ap, "tz") + self.encode_tidal_files_and_output(self, ds_ap, "tz") ########### Regrid Tidal Velocity ###################### - regrid_u = xe.Regridder( - tpxo_u[["lon", "lat", "uRe"]], - self.coords, - method=method, - locstream_out=True, - periodic=periodic, - reuse_weights=False, - ) - - regrid_v = xe.Regridder( - tpxo_v[["lon", "lat", "vRe"]], - self.coords, - method=method, - locstream_out=True, - periodic=periodic, - reuse_weights=False, - ) + regrid_u = rgd.create_regridder(tpxo_u[["lon", "lat", "uRe"]], coords, ".temp") + regrid_v = rgd.create_regridder(tpxo_v[["lon", "lat", "vRe"]], coords, ".temp2") - # Interpolate each real and imaginary parts to segment. + # Interpolate each real and imaginary parts to self. uredest = regrid_u(tpxo_u[["lon", "lat", "uRe"]])["uRe"] uimdest = regrid_u(tpxo_u[["lon", "lat", "uIm"]])["uIm"] vredest = regrid_v(tpxo_v[["lon", "lat", "vRe"]])["vRe"] @@ -3427,65 +3342,77 @@ def regrid_tides( # Fill missing data. # Need to do this first because complex would get converted to real - uredest = uredest.ffill(dim=self.coords.attrs["locations_name"], limit=None) - uimdest = uimdest.ffill(dim=self.coords.attrs["locations_name"], limit=None) - vredest = vredest.ffill(dim=self.coords.attrs["locations_name"], limit=None) - vimdest = vimdest.ffill(dim=self.coords.attrs["locations_name"], limit=None) + uredest = rgd.fill_missing_data( + uredest, f"{coords.attrs['parallel']}_{self.segment_name}" + ) + uimdest = rgd.fill_missing_data( + uimdest, f"{coords.attrs['parallel']}_{self.segment_name}" + ) + vredest = rgd.fill_missing_data( + vredest, f"{coords.attrs['parallel']}_{self.segment_name}" + ) + vimdest = rgd.fill_missing_data( + vimdest, f"{coords.attrs['parallel']}_{self.segment_name}" + ) # Convert to complex, remaining separate for u and v. ucplex = uredest + 1j * uimdest vcplex = vredest + 1j * vimdest - # Convert complex u and v to ellipse, - # rotate ellipse from earth-relative to model-relative, - # and convert ellipse back to amplitude and phase. - # There is probably a complicated trig identity for this? But - # this works too. - angle = self.coords["angle"] + angle = coords["angle"] # Fred's grid is in degrees + # Convert complex u and v to ellipse, # rotate ellipse from earth-relative to model-relative, # and convert ellipse back to amplitude and phase. SEMA, ECC, INC, PHA = ap2ep(ucplex, vcplex) - INC -= angle.data[np.newaxis, :] + + INC -= np.radians(angle.data[np.newaxis, :]) ua, va, up, vp = ep2ap(SEMA, ECC, INC, PHA) + + # Convert to real amplitude and phase. ds_ap = xr.Dataset( {f"uamp_{self.segment_name}": ua, f"vamp_{self.segment_name}": va} ) # up, vp aren't dataarraysf ds_ap[f"uphase_{self.segment_name}"] = ( - ("constituent", self.coords.attrs["locations_name"]), + ("constituent", f"{coords.attrs['parallel']}_{self.segment_name}"), up, ) # radians ds_ap[f"vphase_{self.segment_name}"] = ( - ("constituent", self.coords.attrs["locations_name"]), + ("constituent", f"{coords.attrs['parallel']}_{self.segment_name}"), vp, ) # radians - ds_ap, _ = xr.broadcast(ds_ap, times) - - # Need to transpose so that time is first, - # so that it can be the unlimited dimension + times = xr.DataArray( + pd.date_range( + self.startdate, periods=1 + ), # Import pandas for this shouldn't be a big deal b/c it's already kinda required somewhere deep in some tree. + dims=["time"], + ) + ds_ap = rgd.add_or_update_time_dim(ds_ap,times) ds_ap = ds_ap.transpose( - "time", "constituent", self.coords.attrs["locations_name"] + "time", "constituent", f"{coords.attrs['parallel']}_{self.segment_name}" ) # Some things may have become missing during the transformation - ds_ap = ds_ap.ffill(dim=self.coords.attrs["locations_name"], limit=None) + ds_ap = rgd.fill_missing_data( + ds_ap, f"{coords.attrs['parallel']}_{self.segment_name}" + ) - self.encode_tidal_files_and_output(ds_ap, "tu") + self.encode_tidal_files_and_output(segment, ds_ap, "tu") return def encode_tidal_files_and_output(self, ds, filename): """ This function: - - Expands the dimensions (with the segment name) - - Renames some dimensions to be more specific to the segment - - Provides an output file encoding - - Exports the files. + - Expands the dimensions (with the segment name) + - Renames some dimensions to be more specific to the segment + - Provides an output file encoding + - Exports the files. Args: self.outfolder (str/path): The output folder to save the tidal files into @@ -3496,9 +3423,9 @@ def encode_tidal_files_and_output(self, ds, filename): General Description: This tidal data functions are sourced from the GFDL NWA25 and changed in the following ways: - - Converted code for RM6 segment class - - Implemented Horizontal Subsetting - - Combined all functions of NWA25 into a four function process (in the style of rm6) (expt.setup_tides_rectangular_boundaries, segment.coords, segment.regrid_tides, segment.encode_tidal_files_and_output) + - Converted code for RM6 segment class + - Implemented Horizontal Subsetting + - Combined all functions of NWA25 into a four function process (in the style of rm6) (expt.setup_tides_rectangular_boundaries, self.coords, segment.regrid_tides, segment.encode_tidal_files_and_output) Original Code was sourced from: @@ -3511,48 +3438,31 @@ def encode_tidal_files_and_output(self, ds, filename): """ + coords = rgd.coords(self.hgrid, self.orientation, self.segment_name) ## Expand Tidal Dimensions ## - if "z" in ds.coords or "constituent" in ds.dims: - offset = 0 - else: - offset = 1 - if self.orientation in ["south", "north"]: - ds = ds.expand_dims(f"ny_{self.segment_name}", 2 - offset) - elif self.orientation in ["west", "east"]: - ds = ds.expand_dims(f"nx_{self.segment_name}", 3 - offset) + + for var in ds: + + ds = rgd.add_secondary_dimension(ds, str(var), coords, self.segment_name) ## Rename Tidal Dimensions ## ds = ds.rename( {"lon": f"lon_{self.segment_name}", "lat": f"lat_{self.segment_name}"} ) - if "z" in ds.coords: - ds = ds.rename({"z": f"nz_{self.segment_name}"}) - if self.orientation in ["south", "north"]: - ds = ds.rename( - {self.coords.attrs["locations_name"]: f"nx_{self.segment_name}"} - ) - elif self.orientation in ["west", "east"]: - ds = ds.rename( - {self.coords.attrs["locations_name"]: f"ny_{self.segment_name}"} - ) ## Perform Encoding ## - for v in ds: - ds[v].encoding["_FillValue"] = 1.0e20 + fname = f"{filename}_{self.segment_name}.nc" # Set format and attributes for coordinates, including time if it does not already have calendar attribute # (may change this to detect whether time is a time type or a float). # Need to include the fillvalue or it will be back to nan encoding = { - "time": dict(_FillValue=1.0e20), + "time": dict(dtype="float64", calendar="gregorian", _FillValue=1.0e20), f"lon_{self.segment_name}": dict(dtype="float64", _FillValue=1.0e20), f"lat_{self.segment_name}": dict(dtype="float64", _FillValue=1.0e20), } - if "calendar" not in ds["time"].attrs and "modulo" not in ds["time"].attrs: - encoding.update( - {"time": dict(dtype="float64", calendar="gregorian", _FillValue=1.0e20)} - ) + encoding = rgd.generate_encoding(ds, encoding, default_fill_value=netCDF4.default_fillvals["f8"]) ## Export Files ## ds.to_netcdf( @@ -3561,4 +3471,4 @@ def encode_tidal_files_and_output(self, ds, filename): encoding=encoding, unlimited_dims="time", ) - return + return ds diff --git a/regional_mom6/regridding.py b/regional_mom6/regridding.py new file mode 100644 index 00000000..cabdd46c --- /dev/null +++ b/regional_mom6/regridding.py @@ -0,0 +1,383 @@ +""" +Helper Functions to take the user though the regridding of boundary conditions and encoding for MOM6. Built for RM6 + +Steps: +1. Initial Regridding -> Find the boundary of the hgrid, and regrid the forcing variables to that boundary. Call (initial_regridding) and then use the xesmf Regridder with whatever datasets you need. +2. Work on some data issues + 1. For temperature - Make sure it's in Celsius + 2. FILL IN NANS -> this is important for MOM6 (fill_missing_data) -> This diverges between +3. For tides, we split the tides into an amplitude and a phase... +4. In some cases, here is a great place to rotate the velocities to match a curved grid.... (tidal_velocity), velocity is also a good place to do this. +5. We then add the time coordinate +6. For vars that are not just surface variables, we need to add several depth related variables + 1. Add a dz variable in layer thickness + 2. Some metadata issues later on +7. Now we do up the metadata +8. Rename variables to var_segment_num +9. (IF VERTICAL EXISTS) Rename the vertical coordinate of the variable to nz_segment_num_var +10. (IF VERTICAL EXISTS) Declare this new vertical coordiante as a increasing series of integers +11. Re-add the "perpendicular" dimension +12. ....Add layer thickness of dz to the vertical forcings +13. Add to encoding_dict a fill value(_FillValue) and zlib, dtype, for time, lat long, ....and each variable (no type needed though) + + + +""" + +import xesmf as xe +import xarray as xr +from pathlib import Path +import dask.array as da +import numpy as np +import netCDF4 +from .utils import setup_logger + + +regridding_logger = setup_logger(__name__) + + +def coords(hgrid: xr.Dataset, orientation: str, segment_name: str) -> xr.Dataset: + """ + This function: + Allows us to call the self.coords for use in the xesmf.Regridder in the regrid_tides function. self.coords gives us the subset of the hgrid based on the orientation. + + Args: + hgrid (xr.Dataset): The hgrid dataset + orientation (str): The orientation of the boundary + segment_name (str): The name of the segment + Returns: + xr.Dataset: The correct coordinate space for the orientation + + Code adapted from: + Author(s): GFDL, James Simkins, Rob Cermak, etc.. + Year: 2022 + Title: "NWA25: Northwest Atlantic 1/25th Degree MOM6 Simulation" + Version: N/A + Type: Python Functions, Source Code + Web Address: https://github.com/jsimkins2/nwa25 + + """ + # Rename nxp and nyp to locations + if orientation == "south": + rcoord = xr.Dataset( + { + "lon": hgrid["x"].isel(nyp=0), + "lat": hgrid["y"].isel(nyp=0), + "angle": hgrid["angle_dx"].isel(nyp=0), + } + ) + rcoord = rcoord.rename_dims({"nxp": f"nx_{segment_name}"}) + rcoord.attrs["perpendicular"] = "ny" + rcoord.attrs["parallel"] = "nx" + rcoord.attrs["axis_to_expand"] = ( + 2 ## Need to keep track of which axis the 'main' coordinate corresponds to when re-adding the 'secondary' axis + ) + elif orientation == "north": + rcoord = xr.Dataset( + { + "lon": hgrid["x"].isel(nyp=-1), + "lat": hgrid["y"].isel(nyp=-1), + "angle": hgrid["angle_dx"].isel(nyp=-1), + } + ) + rcoord = rcoord.rename_dims({"nxp": f"nx_{segment_name}"}) + rcoord.attrs["perpendicular"] = "ny" + rcoord.attrs["parallel"] = "nx" + rcoord.attrs["axis_to_expand"] = 2 + elif orientation == "west": + rcoord = xr.Dataset( + { + "lon": hgrid["x"].isel(nxp=0), + "lat": hgrid["y"].isel(nxp=0), + "angle": hgrid["angle_dx"].isel(nxp=0), + } + ) + rcoord = rcoord.rename_dims({"nyp": f"ny_{segment_name}"}) + rcoord.attrs["perpendicular"] = "nx" + rcoord.attrs["parallel"] = "ny" + rcoord.attrs["axis_to_expand"] = 3 + elif orientation == "east": + rcoord = xr.Dataset( + { + "lon": hgrid["x"].isel(nxp=-1), + "lat": hgrid["y"].isel(nxp=-1), + "angle": hgrid["angle_dx"].isel(nxp=-1), + } + ) + rcoord = rcoord.rename_dims({"nyp": f"ny_{segment_name}"}) + rcoord.attrs["perpendicular"] = "nx" + rcoord.attrs["parallel"] = "ny" + rcoord.attrs["axis_to_expand"] = 3 + + # Make lat and lon coordinates + rcoord = rcoord.assign_coords(lat=rcoord["lat"], lon=rcoord["lon"]) + + return rcoord + + +def create_regridder( + forcing_variables: xr.Dataset, + output_grid: xr.Dataset, + outfile: Path = Path(".temp"), + method: str = "bilinear", +) -> xe.Regridder: + """ + Basic Regridder for any forcing variables, this just wraps the xesmf regridder for a few defaults + Parameters + ---------- + forcing_variables : xr.Dataset + The dataset of the forcing variables + output_grid : xr.Dataset + The dataset of the output grid -> this is the boundary of the hgrid + outfile : Path, optional + The path to the output file for weights I believe, by default Path(".temp") + method : str, optional + The regridding method, by default "bilinear" + Returns + ------- + xe.Regridder + The regridding object + """ + regridding_logger.info("Creating Regridder") + regridder = xe.Regridder( + forcing_variables, + output_grid, + method=method, + locstream_out=True, + periodic=False, + filename=outfile, + reuse_weights=False, + ) + return regridder + + +def fill_missing_data(ds: xr.Dataset, z_dim_name: str) -> xr.Dataset: + """ + Fill in missing values with forward fill along the z dimension (We can make this more elaborate with time.... The original RM6 fill was different) + Parameters + ---------- + ds : xr.Dataset + The dataset to fill in + z_dim_name : str + The name of the z dimension + Returns + ------- + xr.Dataset + The filled in dataset + """ + regridding_logger.info("Forward filling in missing data along z-dim") + ds = ds.ffill( + dim=z_dim_name, limit=None + ) # This fills in the nans with the forward fill along the z dimension with an unlimited num of nans + return ds + + +def add_or_update_time_dim(ds: xr.Dataset, times) -> xr.Dataset: + """ + Add the time dimension to the dataset, in tides case can be one time step. + Parameters + ---------- + ds : xr.Dataset + The dataset to add the time dimension to + times : list, np.Array, xr.DataArray + The list of times + Returns + ------- + xr.Dataset + The dataset with the time dimension added + """ + regridding_logger.info("Adding time dimension") + + regridding_logger.debug(f"Times: {times}") + regridding_logger.debug(f"Make sure times is a DataArray") + # Make sure times is an xr.DataArray + times = xr.DataArray(times) + + + if "time" in ds.dims: + regridding_logger.debug("Time already in dataset, overwriting with new values") + ds["time"] = times + else: + regridding_logger.debug("Time not in dataset, xr.Broadcasting time dimension") + ds, _ = xr.broadcast(ds, times) + + # Make sure time is first.... + regridding_logger.debug("Transposing time to first dimension") + new_dims = ["time"] + [dim for dim in ds.dims if dim != "time"] + ds = ds.transpose(*new_dims) + + return ds + + +def generate_dz(ds: xr.Dataset, z_dim_name: str) -> xr.Dataset: + """ + For vertical coordinates, you need to have the layer thickness or something. Generate the dz variable for the dataset + Parameters + ---------- + ds : xr.Dataset + The dataset to get the z variable from + z_dim_name : str + The name of the z dimension + Returns + ------- + xr.Dataset + the dz variable + """ + dz = ds[z_dim_name].diff(z_dim_name) + dz.name = "dz" + dz = xr.concat([dz, dz[-1]], dim=z_dim_name) + return dz + + +def add_secondary_dimension( + ds: xr.Dataset, var: str, coords, segment_name: str +) -> xr.Dataset: + """Add the perpendiciular dimension to the dataset, even if it's like one val. It's required. + Parameters + ----------- + ds : xr.Dataset + The dataset to add the perpendicular dimension to + var : str + The variable to add the perpendicular dimension to + coords : xr.Dataset + The coordinates from the function coords... + segment_name : str + The segment name + Returns + ------- + xr.Dataset + The dataset with the perpendicular dimension added + + + """ + + # Check if we need to insert the dim earlier or later + regridding_logger.info("Adding perpendicular dimension to {}".format(var)) + + + regridding_logger.debug("Checking if nz or constituent is in dimensions, then we have to bump the perpendicular dimension up by one") + insert_behind_by = 0 + if any( + coord.startswith("nz") or coord == "constituent" for coord in ds[var].dims + ): + regridding_logger.debug("Bump it by one") + insert_behind_by = 0 + else: + # Missing vertical dim or tidal coord means we don't need to offset the perpendicular + insert_behind_by = 1 + + regridding_logger.debug(f"Expand dimensions") + ds[var] = ds[var].expand_dims( + f"{coords.attrs['perpendicular']}_{segment_name}", + axis=coords.attrs["axis_to_expand"] - insert_behind_by, + ) + return ds + + +def vertical_coordinate_encoding( + ds: xr.Dataset, var: str, segment_name: str, old_vert_coord_name: str +) -> xr.Dataset: + """ + Rename vertical coordinate to nz_..., then change it to regular increments + + Parameters + ---------- + ds : xr.Dataset + The dataset to rename the vertical coordinate in + var : str + The variable to rename the vertical coordinate in + segment_name : str + The segment name + old_vert_coord_name : str + The old vertical coordinate name + """ + + regridding_logger.info("Renaming vertical coordinate to nz_... in {}".format(var)) + section = "_seg" + base_var = var[: var.find(section)] if section in var else var + ds[var] = ds[var].rename({old_vert_coord_name: f"nz_{segment_name}_{base_var}"}) + + ## Replace the old depth coordinates with incremental integers + regridding_logger.info("Replacing old depth coordinates with incremental integers") + ds[f"nz_{segment_name}_{base_var}"] = np.arange( + ds[f"nz_{segment_name}_{base_var}"].size + ) + + return ds + + +def generate_layer_thickness( + ds: xr.Dataset, var: str, segment_name: str, old_vert_coord_name: str +) -> xr.Dataset: + """ + Generate Layer Thickness Variable, needed for vars with vertical dimensions + Parameters + ---------- + ds : xr.Dataset + The dataset to generate the layer thickness for + var : str + The variable to generate the layer thickness for + segment_name : str + The segment name + old_vert_coord_name : str + The old vertical coordinate name + Returns + ------- + xr.Dataset + The dataset with the layer thickness variable added + """ + regridding_logger.debug("Generating layer thickness variable for {}".format(var)) + dz = generate_dz(ds, old_vert_coord_name) + ds[f"dz_{var}"] = ( + [ + "time", + f"nz_{var}", + f"ny_{segment_name}", + f"nx_{segment_name}", + ], + da.broadcast_to( + dz.data[None, :, None, None], + ds[var].shape, + chunks=( + 1, + None, + None, + None, + ), ## Chunk in each time, and every 5 vertical layers + ), + ) + + return ds + + +def generate_encoding( + ds: xr.Dataset, encoding_dict, default_fill_value=netCDF4.default_fillvals["f8"] +) -> xr.Dataset: + """ + Generate the encoding dictionary for the dataset + Parameters + ---------- + ds : xr.Dataset + The dataset to generate the encoding for + encoding_dict : dict + The starting encoding dict with some specifications needed for time and other vars, this will be updated with encodings in this function + default_fill_value : float, optional + The default fill value, by default 1.0e20 + Returns + ------- + dict + The encoding dictionary + """ + regridding_logger.info("Generating encoding dictionary") + for var in ds: + if "_segment_" in var and not "nz" in var: + encoding_dict[var] = { + "_FillValue": default_fill_value, + } + for var in ds.coords: + if "nz_" in var: + encoding_dict[var] = { + "dtype": "int32", + } + + return encoding_dict diff --git a/regional_mom6/utils.py b/regional_mom6/utils.py index 447a2e4f..c28eeda2 100644 --- a/regional_mom6/utils.py +++ b/regional_mom6/utils.py @@ -1,5 +1,6 @@ import numpy as np - +import logging +import sys def vecdot(v1, v2): """Return the dot product of vectors ``v1`` and ``v2``. @@ -294,3 +295,24 @@ def ep2ap(SEMA, ECC, INC, PHA): vp = -np.angle(cv) return ua, va, up, vp + +def setup_logger(name: str) -> logging.Logger: + """ + Setup general config for a logger. + """ + logger = logging.getLogger(name) + logger.setLevel(logging.INFO) + if not logger.hasHandlers(): + # Create a handler to print to stdout (Jupyter captures stdout) + handler = logging.StreamHandler(sys.stdout) + handler.setLevel(logging.INFO) + + # Create a formatter (optional) + formatter = logging.Formatter( + "%(asctime)s - %(name)s.%(funcName)s - %(levelname)s - %(message)s" + ) + handler.setFormatter(formatter) + + # Add the handler to the logger + logger.addHandler(handler) + return logger From df3b1d3e0e9b9a9559b02857b2d680e1af51b827 Mon Sep 17 00:00:00 2001 From: manishvenu Date: Thu, 7 Nov 2024 13:35:10 -0700 Subject: [PATCH 06/87] More tidal changes --- regional_mom6/regional_mom6.py | 18 ++++++++++-------- 1 file changed, 10 insertions(+), 8 deletions(-) diff --git a/regional_mom6/regional_mom6.py b/regional_mom6/regional_mom6.py index e3bc1995..02725c46 100644 --- a/regional_mom6/regional_mom6.py +++ b/regional_mom6/regional_mom6.py @@ -21,7 +21,7 @@ from collections import defaultdict import json import copy -import regridding as rgd +from . import regridding as rgd warnings.filterwarnings("ignore") __all__ = [ @@ -1648,8 +1648,8 @@ def setup_single_boundary( def setup_boundary_tides( self, - path_to_td, - tidal_filename, + tpxo_elevation_filepath, + tpxo_velocity_filepath, tidal_constituents="read_from_expt_init", boundary_type="rectangle", ): @@ -1687,7 +1687,7 @@ def setup_boundary_tides( if tidal_constituents != "read_from_expt_init": self.tidal_constituents = tidal_constituents tpxo_h = ( - xr.open_dataset(Path(path_to_td / f"h_{tidal_filename}")) + xr.open_dataset(Path(tpxo_elevation_filepath)) .rename({"lon_z": "lon", "lat_z": "lat", "nc": "constituent"}) .isel( constituent=convert_to_tpxo_tidal_constituents(self.tidal_constituents) @@ -1698,7 +1698,7 @@ def setup_boundary_tides( tpxo_h["hRe"] = np.real(h) tpxo_h["hIm"] = np.imag(h) tpxo_u = ( - xr.open_dataset(Path(path_to_td / f"u_{tidal_filename}")) + xr.open_dataset(Path(tpxo_velocity_filepath)) .rename({"lon_u": "lon", "lat_u": "lat", "nc": "constituent"}) .isel( constituent=convert_to_tpxo_tidal_constituents(self.tidal_constituents) @@ -1709,7 +1709,7 @@ def setup_boundary_tides( tpxo_u["uRe"] = np.real(u) tpxo_u["uIm"] = np.imag(u) tpxo_v = ( - xr.open_dataset(Path(path_to_td / f"u_{tidal_filename}")) + xr.open_dataset(Path(tpxo_velocity_filepath)) .rename({"lon_v": "lon", "lat_v": "lat", "nc": "constituent"}) .isel( constituent=convert_to_tpxo_tidal_constituents(self.tidal_constituents) @@ -3328,7 +3328,7 @@ def regrid_tides( "time", "constituent", f"{coords.attrs['parallel']}_{self.segment_name}" ) - self.encode_tidal_files_and_output(self, ds_ap, "tz") + self.encode_tidal_files_and_output( ds_ap, "tz") ########### Regrid Tidal Velocity ###################### regrid_u = rgd.create_regridder(tpxo_u[["lon", "lat", "uRe"]], coords, ".temp") @@ -3402,7 +3402,7 @@ def regrid_tides( ds_ap, f"{coords.attrs['parallel']}_{self.segment_name}" ) - self.encode_tidal_files_and_output(segment, ds_ap, "tu") + self.encode_tidal_files_and_output( ds_ap, "tu") return @@ -3464,6 +3464,8 @@ def encode_tidal_files_and_output(self, ds, filename): } encoding = rgd.generate_encoding(ds, encoding, default_fill_value=netCDF4.default_fillvals["f8"]) + # Can't have nas in the land segments and such cuz it crashes + ds = ds.fillna(0) ## Export Files ## ds.to_netcdf( Path(self.outfolder / "forcing" / fname), From 7dc3cae7c6ca835dac1f3adfc848a04ad606bf7a Mon Sep 17 00:00:00 2001 From: manishvenu Date: Thu, 7 Nov 2024 13:46:57 -0700 Subject: [PATCH 07/87] Change default tides to use all constituents in TPXO allowed in MOM6 --- regional_mom6/regional_mom6.py | 110 +++++++++++++-------------------- regional_mom6/regridding.py | 16 +++-- regional_mom6/utils.py | 2 + 3 files changed, 53 insertions(+), 75 deletions(-) diff --git a/regional_mom6/regional_mom6.py b/regional_mom6/regional_mom6.py index 02725c46..4b621e18 100644 --- a/regional_mom6/regional_mom6.py +++ b/regional_mom6/regional_mom6.py @@ -22,6 +22,7 @@ import json import copy from . import regridding as rgd + warnings.filterwarnings("ignore") __all__ = [ @@ -589,7 +590,7 @@ def create_empty( hgrid_type="even_spacing", repeat_year_forcing=False, minimum_depth=4, - tidal_constituents=["M2"], + tidal_constituents=["M2", "S2", "N2", "K2", "K1", "O1", "P1", "Q1", "MM", "MF"], expt_name=None, boundaries=["south", "north", "west", "east"], ): @@ -653,7 +654,7 @@ def __init__( vgrid_type="hyperbolic_tangent", repeat_year_forcing=False, minimum_depth=4, - tidal_constituents=["M2"], + tidal_constituents=["M2", "S2", "N2", "K2", "K1", "O1", "P1", "Q1", "MM", "MF"], create_empty=False, expt_name=None, boundaries=["south", "north", "west", "east"], @@ -3013,8 +3014,8 @@ def rotate(self, u, v): def regrid_velocity_tracers(self): """ - Cut out and interpolate the velocities and tracers - """ + Cut out and interpolate the velocities and tracers + """ rawseg = xr.open_dataset(self.infile, decode_times=False, engine="netcdf4") coords = rgd.coords(self.hgrid, self.orientation, self.segment_name) @@ -3032,22 +3033,17 @@ def regrid_velocity_tracers(self): regridded = regridder( rawseg[ - [self.u, self.v, self.eta] - + [self.tracers[i] for i in self.tracers] + [self.u, self.v, self.eta] + [self.tracers[i] for i in self.tracers] ] ) - rotated_u, rotated_v = self.rotate( - regridded[self.u], regridded[self.v] - ) + rotated_u, rotated_v = self.rotate(regridded[self.u], regridded[self.v]) rotated_ds = xr.Dataset( { self.u: rotated_u, self.v: rotated_v, } ) - segment_out = xr.merge( - [rotated_ds, regridded.drop_vars([self.u, self.v])] - ) + segment_out = xr.merge([rotated_ds, regridded.drop_vars([self.u, self.v])]) if self.arakawa_grid == "B": ## All tracers on one grid, all velocities on another @@ -3058,19 +3054,14 @@ def regrid_velocity_tracers(self): / f"weights/bilinear_velocity_weights_{self.orientation}.nc", ) regridder_tracer = rgd.create_regridder( - rawseg[self.tracers["salt"]].rename( - {self.xh: "lon", self.yh: "lat"} - ), + rawseg[self.tracers["salt"]].rename({self.xh: "lon", self.yh: "lat"}), coords, self.outfolder / f"weights/bilinear_tracer_weights_{self.orientation}.nc", ) - velocities_out = regridder_velocity( - rawseg[[self.u, self.v]].rename( - {self.xq: "lon", self.yq: "lat"} - ) + rawseg[[self.u, self.v]].rename({self.xq: "lon", self.yq: "lat"}) ) velocities_out["u"], velocities_out["v"] = self.rotate( @@ -3097,7 +3088,6 @@ def regrid_velocity_tracers(self): / f"weights/bilinear_uvelocity_weights_{self.orientation}.nc", ) - regridder_vvelocity = rgd.create_regridder( rawseg[self.v].rename({self.xh: "lon", self.yq: "lat"}), coords, @@ -3106,9 +3096,7 @@ def regrid_velocity_tracers(self): ) regridder_tracer = rgd.create_regridder( - rawseg[self.tracers["salt"]].rename( - {self.xh: "lon", self.yh: "lat"} - ), + rawseg[self.tracers["salt"]].rename({self.xh: "lon", self.yh: "lat"}), coords, self.outfolder / f"weights/bilinear_tracer_weights_{self.orientation}.nc", @@ -3117,9 +3105,7 @@ def regrid_velocity_tracers(self): regridded_u = regridder_uvelocity(rawseg[[self.u]]) regridded_v = regridder_vvelocity(rawseg[[self.v]]) - rotated_u, rotated_v = self.rotate( - regridded_u[self.u], regridded_v[self.v] - ) + rotated_u, rotated_v = self.rotate(regridded_u[self.u], regridded_v[self.v]) rotated_ds = xr.Dataset( { self.u: rotated_u, @@ -3130,9 +3116,7 @@ def regrid_velocity_tracers(self): [ rotated_ds, regridder_tracer( - rawseg[ - [self.eta] + [self.tracers[i] for i in self.tracers] - ] + rawseg[[self.eta] + [self.tracers[i] for i in self.tracers]] ), ] ) @@ -3144,9 +3128,7 @@ def regrid_velocity_tracers(self): del segment_out["lat"] ## Convert temperatures to celsius # use pint if ( - np.nanmin( - segment_out[self.tracers["temp"]].isel({self.time: 0, self.z: 0}) - ) + np.nanmin(segment_out[self.tracers["temp"]].isel({self.time: 0, self.z: 0})) > 100 ): segment_out[self.tracers["temp"]] -= 273.15 @@ -3157,21 +3139,23 @@ def regrid_velocity_tracers(self): segment_out = rgd.fill_missing_data( segment_out, f"{self.coords.attrs['parallel']}_{self.segment_name}" ) - - times = xr.DataArray(np.arange( - 0, #! Indexing everything from start of experiment = simple but maybe counterintutive? - segment_out[self.time].shape[ - 0 - ], ## Time is indexed from start date of window - dtype=float, - ), # Import pandas for this shouldn't be a big deal b/c it's already kinda required somewhere deep in some tree. - dims=["time"]) + + times = xr.DataArray( + np.arange( + 0, #! Indexing everything from start of experiment = simple but maybe counterintutive? + segment_out[self.time].shape[ + 0 + ], ## Time is indexed from start date of window + dtype=float, + ), # Import pandas for this shouldn't be a big deal b/c it's already kinda required somewhere deep in some tree. + dims=["time"], + ) # This to change the time coordinate. - segment_out = rgd.add_or_update_time_dim(segment_out,times) + segment_out = rgd.add_or_update_time_dim(segment_out, times) segment_out.time.attrs = { - "calendar": "julian", - "units": f"{self.time_units} since {self.startdate}", - } + "calendar": "julian", + "units": f"{self.time_units} since {self.startdate}", + } # Here, keep in mind that 'var' keeps track of the mom6 variable names we want, and self.tracers[var] # will return the name of the variable from the original data @@ -3202,7 +3186,6 @@ def regrid_velocity_tracers(self): segment_out, v, self.segment_name, self.z ) - ## Treat eta separately since it has no vertical coordinate. Do the same things as for the surface variables above segment_out = segment_out.rename({self.eta: f"eta_{self.segment_name}"}) @@ -3211,12 +3194,8 @@ def regrid_velocity_tracers(self): ) # Overwrite the actual lat/lon values in the dimensions, replace with incrementing integers - segment_out[f"{self.coords.attrs['parallel']}_{self.segment_name}"] = ( - np.arange( - segment_out[ - f"{self.coords.attrs['parallel']}_{self.segment_name}" - ].size - ) + segment_out[f"{self.coords.attrs['parallel']}_{self.segment_name}"] = np.arange( + segment_out[f"{self.coords.attrs['parallel']}_{self.segment_name}"].size ) segment_out[f"{self.coords.attrs['perpendicular']}_{self.segment_name}"] = [0] encoding_dict = { @@ -3229,7 +3208,9 @@ def regrid_velocity_tracers(self): }, } encoding_dict = rgd.generate_encoding( - segment_out, encoding_dict, default_fill_value=netCDF4.default_fillvals["f8"] + segment_out, + encoding_dict, + default_fill_value=netCDF4.default_fillvals["f8"], ) segment_out.load().to_netcdf( @@ -3282,9 +3263,7 @@ def regrid_tides( tpxo_h[["lon", "lat", "hRe"]], coords, Path( - self.outfolder - / "forcing" - / f"regrid_{self.segment_name}_tidal_elev.nc" + self.outfolder / "forcing" / f"regrid_{self.segment_name}_tidal_elev.nc" ), ) @@ -3328,7 +3307,7 @@ def regrid_tides( "time", "constituent", f"{coords.attrs['parallel']}_{self.segment_name}" ) - self.encode_tidal_files_and_output( ds_ap, "tz") + self.encode_tidal_files_and_output(ds_ap, "tz") ########### Regrid Tidal Velocity ###################### regrid_u = rgd.create_regridder(tpxo_u[["lon", "lat", "uRe"]], coords, ".temp") @@ -3359,16 +3338,13 @@ def regrid_tides( ucplex = uredest + 1j * uimdest vcplex = vredest + 1j * vimdest - - - angle = coords["angle"] # Fred's grid is in degrees - + angle = coords["angle"] # Fred's grid is in degrees # Convert complex u and v to ellipse, # rotate ellipse from earth-relative to model-relative, # and convert ellipse back to amplitude and phase. SEMA, ECC, INC, PHA = ap2ep(ucplex, vcplex) - + INC -= np.radians(angle.data[np.newaxis, :]) ua, va, up, vp = ep2ap(SEMA, ECC, INC, PHA) @@ -3392,7 +3368,7 @@ def regrid_tides( ), # Import pandas for this shouldn't be a big deal b/c it's already kinda required somewhere deep in some tree. dims=["time"], ) - ds_ap = rgd.add_or_update_time_dim(ds_ap,times) + ds_ap = rgd.add_or_update_time_dim(ds_ap, times) ds_ap = ds_ap.transpose( "time", "constituent", f"{coords.attrs['parallel']}_{self.segment_name}" ) @@ -3402,7 +3378,7 @@ def regrid_tides( ds_ap, f"{coords.attrs['parallel']}_{self.segment_name}" ) - self.encode_tidal_files_and_output( ds_ap, "tu") + self.encode_tidal_files_and_output(ds_ap, "tu") return @@ -3443,7 +3419,7 @@ def encode_tidal_files_and_output(self, ds, filename): ## Expand Tidal Dimensions ## for var in ds: - + ds = rgd.add_secondary_dimension(ds, str(var), coords, self.segment_name) ## Rename Tidal Dimensions ## @@ -3462,7 +3438,9 @@ def encode_tidal_files_and_output(self, ds, filename): f"lon_{self.segment_name}": dict(dtype="float64", _FillValue=1.0e20), f"lat_{self.segment_name}": dict(dtype="float64", _FillValue=1.0e20), } - encoding = rgd.generate_encoding(ds, encoding, default_fill_value=netCDF4.default_fillvals["f8"]) + encoding = rgd.generate_encoding( + ds, encoding, default_fill_value=netCDF4.default_fillvals["f8"] + ) # Can't have nas in the land segments and such cuz it crashes ds = ds.fillna(0) diff --git a/regional_mom6/regridding.py b/regional_mom6/regridding.py index cabdd46c..b4026e3f 100644 --- a/regional_mom6/regridding.py +++ b/regional_mom6/regridding.py @@ -193,7 +193,6 @@ def add_or_update_time_dim(ds: xr.Dataset, times) -> xr.Dataset: # Make sure times is an xr.DataArray times = xr.DataArray(times) - if "time" in ds.dims: regridding_logger.debug("Time already in dataset, overwriting with new values") ds["time"] = times @@ -247,19 +246,18 @@ def add_secondary_dimension( ------- xr.Dataset The dataset with the perpendicular dimension added - - + + """ - + # Check if we need to insert the dim earlier or later regridding_logger.info("Adding perpendicular dimension to {}".format(var)) - - regridding_logger.debug("Checking if nz or constituent is in dimensions, then we have to bump the perpendicular dimension up by one") + regridding_logger.debug( + "Checking if nz or constituent is in dimensions, then we have to bump the perpendicular dimension up by one" + ) insert_behind_by = 0 - if any( - coord.startswith("nz") or coord == "constituent" for coord in ds[var].dims - ): + if any(coord.startswith("nz") or coord == "constituent" for coord in ds[var].dims): regridding_logger.debug("Bump it by one") insert_behind_by = 0 else: diff --git a/regional_mom6/utils.py b/regional_mom6/utils.py index c28eeda2..91a96c36 100644 --- a/regional_mom6/utils.py +++ b/regional_mom6/utils.py @@ -2,6 +2,7 @@ import logging import sys + def vecdot(v1, v2): """Return the dot product of vectors ``v1`` and ``v2``. ``v1`` and ``v2`` can be either numpy vectors or numpy.ndarrays @@ -296,6 +297,7 @@ def ep2ap(SEMA, ECC, INC, PHA): return ua, va, up, vp + def setup_logger(name: str) -> logging.Logger: """ Setup general config for a logger. From 1237528d524c35f7651a2e89c41efe4cab98f780 Mon Sep 17 00:00:00 2001 From: manishvenu Date: Thu, 7 Nov 2024 13:55:08 -0700 Subject: [PATCH 08/87] Fix Tests --- tests/test_config.py | 13 ++++++++++++- tests/test_manish_branch.py | 5 ++++- 2 files changed, 16 insertions(+), 2 deletions(-) diff --git a/tests/test_config.py b/tests/test_config.py index 005b685c..c5621418 100644 --- a/tests/test_config.py +++ b/tests/test_config.py @@ -61,7 +61,18 @@ def test_write_config(): assert config_dict["expt_name"] == "test" assert config_dict["hgrid_type"] == "even_spacing" assert config_dict["repeat_year_forcing"] == False - assert config_dict["tidal_constituents"] == ["M2"] + assert config_dict["tidal_constituents"] == [ + "M2", + "S2", + "N2", + "K2", + "K1", + "O1", + "P1", + "Q1", + "MM", + "MF", + ] assert config_dict["expt_name"] == "test" assert config_dict["boundaries"] == ["south", "north"] shutil.rmtree(run_dir) diff --git a/tests/test_manish_branch.py b/tests/test_manish_branch.py index b2865512..8724770e 100644 --- a/tests/test_manish_branch.py +++ b/tests/test_manish_branch.py @@ -252,7 +252,10 @@ def test_tides(self, dummy_tidal_data): # Create Forcing Folder os.makedirs(self.dump_files_dir / "forcing", exist_ok=True) - self.expt.setup_boundary_tides(self.dump_files_dir, "fake_tidal_data.nc") + self.expt.setup_boundary_tides( + self.dump_files_dir / "h_fake_tidal_data.nc", + self.dump_files_dir / "u_fake_tidal_data.nc", + ) def test_change_MOM_parameter(self): """ From 77201323a30cacf2fe868d469bb7f8b3d1e415aa Mon Sep 17 00:00:00 2001 From: manishvenu Date: Tue, 12 Nov 2024 10:45:59 -0700 Subject: [PATCH 09/87] Start of Angle Calc --- regional_mom6/regridding.py | 79 ++ .../testing_to_be_deleted/angle_calc.md | 11 + .../angle_calc_mom6.ipynb | 755 ++++++++++++++++++ 3 files changed, 845 insertions(+) create mode 100644 regional_mom6/testing_to_be_deleted/angle_calc.md create mode 100755 regional_mom6/testing_to_be_deleted/angle_calc_mom6.ipynb diff --git a/regional_mom6/regridding.py b/regional_mom6/regridding.py index b4026e3f..e794d041 100644 --- a/regional_mom6/regridding.py +++ b/regional_mom6/regridding.py @@ -379,3 +379,82 @@ def generate_encoding( } return encoding_dict + + + +def modulo_around_point(x, xc, Lx): + """ + This function calculates the modulo around a point. Return the modulo value of x in an interval [xc-(Lx/2) xc+(Lx/2)]. If Lx<=0, then it returns x without applying modulo arithmetic. + Parameters + ---------- + x: float + Value to which to apply modulo arithmetic + xc: float + Center of modulo range + Lx: float + Modulo range width + Returns + ------- + float + x shifted by an integer multiple of Lx to be close to xc, + """ + if Lx <= 0: + return x + else: + return ((x - (xc - 0.5*Lx)) % Lx )- Lx/2 + xc + + +def initialize_grid_rotation_angle(hgrid: xr.Dataset) -> xr.Dataset: + """ + Calculate the angle_dx in degrees from the true x (east?) direction counterclockwise) and save as angle_dx_mom6 + Parameters + ---------- + hgrid: xr.Dataset + The hgrid dataset + Returns + ------- + xr.Dataset + The dataset with the mom6_angle_dx variable added + """ + regridding_logger.info("Initializing grid rotation angle") + # Direct Translation + pi_720deg = np.arctan(1)/180 # One quarter the conversion factor from degrees to radians + + ## Check length of longitude + len_lon = 360.0 + G_len_lon = hgrid.x.max() - hgrid.x.min() + if G_len_lon != 360: + regridding_logger.info("This is a regional case") + len_lon = G_len_lon + + angles_arr = np.zeros((len(hgrid.nyp), len(hgrid.nxp))) + + # Compute lonB for all points + lonB = np.zeros((2, 2, len(hgrid.nyp)-2, len(hgrid.nxp)-2)) + + # Vectorized Compute lonB - Fortran is 1-indexed, so we need to subtract 1 from the indices in lonB[m-1,n-1] + for n in np.arange(1,3): + for m in np.arange(1,3): + lonB[m-1, n-1] = modulo_around_point(hgrid.x[np.arange((m-2+1),(m-2+len(hgrid.nyp)-1)), np.arange((n-2+1),(n-2+len(hgrid.nxp)-1))], hgrid.x[1:-1,1:-1], len_lon) + + # Vectorized Compute lon_scale + lon_scale = np.cos(pi_720deg* ((hgrid.y[0:-2, 0:-2] + hgrid.y[1:-1, 1:-1]) + (hgrid.y[1:-1, 0:-2] + hgrid.y[0:-2, 1:-1]))) + + # Vectorized Compute angle + angle = np.arctan2( + lon_scale * ((lonB[0, 1] - lonB[1, 0]) + (lonB[1, 1] - lonB[0, 0])), + (hgrid.y[0:-2, 1:-1] - hgrid.y[1:-1, 0:-2]) + (hgrid.y[1:-1, 1:-1] - hgrid.y[0:-2, 0:-2]) + ) + + # Assign angle to angles_arr + angles_arr[1:-1,1:-1] = 90 - np.rad2deg(angle) + + + # Assign angles_arr to hgrid + hgrid["angle_dx_mom6"] = (("nyp", "nxp"), angles_arr) + hgrid["angle_dx_mom6"].attrs["_FillValue"] = np.nan + hgrid["angle_dx_mom6"].attrs["units"] = "deg" + hgrid["angle_dx_mom6"].attrs["description"] = "MOM6 calculates angles internally, this field replicates that for rotating boundary conditions. Use this over other angle fields for MOM6 applications" + + return hgrid + diff --git a/regional_mom6/testing_to_be_deleted/angle_calc.md b/regional_mom6/testing_to_be_deleted/angle_calc.md new file mode 100644 index 00000000..4f40e8e9 --- /dev/null +++ b/regional_mom6/testing_to_be_deleted/angle_calc.md @@ -0,0 +1,11 @@ +# MOM6 Angle Calculation Steps + +1. Calculate pi/4rads / 180 degress = Gives a 1/4 conversion of degrees to radians. I.E. multiplying an angle in degrees by this gives the conversion to radians at 1/4 the value. +2. Figure out the longitudunal extent of our domain, or periodic range of longitudes. For global cases it is len_lon = 360, for our regional cases it is given by the hgrid. +3. At each point on our hgrid, we find the point to the left, bottom left diag, bottom, and itself. We adjust each of these longitudes to be in the range of len_lon around the point itself. (module_around_point) +4. We then find the lon_scale, which is the "trigonometric scaling factor converting changes in longitude to equivalent distances in latitudes". Whatever that actually means is we add the latitude of all four of these points from part 3 and basically average it and convert to radians. We then take the cosine of it. +5. Then we calculate the angle. This is a simple arctan2 so y/x. + 1. The "y" component is the addition of the difference between the diagonals in longitude of lonB multiplied by the lon_scale, which is our conversion to latitude. + 2. The "x" component is the same addition of differences in latitude. + 3. Thus, given the same units, we can call arctan to get the angle in degrees +6. Challenge: Because this takes the left & bottom points, we can't calculate the angle at the left and bottom edges. Therefore, we can always calculate it the other way by using the right and top points. diff --git a/regional_mom6/testing_to_be_deleted/angle_calc_mom6.ipynb b/regional_mom6/testing_to_be_deleted/angle_calc_mom6.ipynb new file mode 100755 index 00000000..921aedf6 --- /dev/null +++ b/regional_mom6/testing_to_be_deleted/angle_calc_mom6.ipynb @@ -0,0 +1,755 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import xarray as xr\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Size: 111MB\n", + "Dimensions: (nyp: 1561, nxp: 1481, ny: 1560, nx: 1480)\n", + "Dimensions without coordinates: nyp, nxp, ny, nx\n", + "Data variables:\n", + " tile |S255 255B ...\n", + " y (nyp, nxp) float64 18MB ...\n", + " x (nyp, nxp) float64 18MB ...\n", + " dy (ny, nxp) float64 18MB ...\n", + " dx (nyp, nx) float64 18MB ...\n", + " area (ny, nx) float64 18MB ...\n", + " angle_dx (nyp, nxp) float64 18MB ...\n", + "Attributes:\n", + " file_name: ocean_hgrid.nc\n", + " Description: MOM6 NCAR NWA12\n", + " Author: Fred Castruccio (fredc@ucar.edu)\n", + " Created: 2024-04-18T08:39:49.607481\n", + " type: MOM6 supergrid file\n" + ] + } + ], + "source": [ + "\n", + "hgrid = xr.open_dataset(\"/glade/u/home/manishrv/documents/nwa12_0.1/mom_input/n3b.clean/hgrid.nc\")\n", + "print(hgrid)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "hgrid[\"angle_dx\"].plot()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " pi_720deg = atan(1.0) / 180.0\n", + " len_lon = 360.0 ; if (G%len_lon > 0.0) len_lon = G%len_lon\n", + " do j=G%jsc,G%jec ; do i=G%isc,G%iec\n", + " do n=1,2 ; do m=1,2\n", + " lonB(m,n) = modulo_around_point(G%geoLonBu(I+m-2,J+n-2), G%geoLonT(i,j), len_lon)\n", + " enddo ; enddo\n", + " lon_scale = cos(pi_720deg*((G%geoLatBu(I-1,J-1) + G%geoLatBu(I,J)) + &\n", + " (G%geoLatBu(I,J-1) + G%geoLatBu(I-1,J)) ) )\n", + " angle = atan2(lon_scale*((lonB(1,2) - lonB(2,1)) + (lonB(2,2) - lonB(1,1))), &\n", + " (G%geoLatBu(I-1,J) - G%geoLatBu(I,J-1)) + &\n", + " (G%geoLatBu(I,J) - G%geoLatBu(I-1,J-1)) )\n", + " G%sin_rot(i,j) = sin(angle) ! angle is the clockwise angle from lat/lon to ocean\n", + " G%cos_rot(i,j) = cos(angle) ! grid (e.g. angle of ocean \"north\" from true north)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "function modulo_around_point(x, xc, Lx) result(x_mod)\n", + " real, intent(in) :: x !< Value to which to apply modulo arithmetic [A]\n", + " real, intent(in) :: xc !< Center of modulo range [A]\n", + " real, intent(in) :: Lx !< Modulo range width [A]\n", + " real :: x_mod !< x shifted by an integer multiple of Lx to be close to xc [A].\n", + "\n", + " if (Lx > 0.0) then\n", + " x_mod = modulo(x - (xc - 0.5*Lx), Lx) + (xc - 0.5*Lx)\n", + " else\n", + " x_mod = x\n", + " endif\n", + "end function modulo_around_point" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "This is a regional case\n" + ] + } + ], + "source": [ + "# Direct Translation\n", + "pi_720deg = np.arctan(1)/180 # One quarter the conversion factor from degrees to radians\n", + " \n", + "## Check length of longitude\n", + "len_lon = 360.0\n", + "G_len_lon = hgrid.x.max() - hgrid.x.min()\n", + "if G_len_lon != 360:\n", + " print(\"This is a regional case\")\n", + " len_lon = G_len_lon\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "## Iterate it, j=G%jsc,G%jec ; do i=G%isc,G%iec mean we iterate from jsc to jec and isc to iec\n", + "## Then you iterate around it, 1,2 and 1,2\n", + "\n", + "# In this way we wrap each longitude in the correct way even if we are at the seam like 360, I still don't understand it as much\n", + "\n", + "\n", + "def modulo_around_point(x, xc, Lx):\n", + " \"\"\"\n", + " This function calculates the modulo around a point, for use in cases where we are wrapping around the globe at the seam. Return the modulo value of x in an interval [xc-(Lx/2) xc+(Lx/2)]. If Lx<=0, then it returns x without applying modulo arithmetic.\n", + " Parameters\n", + " ----------\n", + " x: float\n", + " Value to which to apply modulo arithmetic\n", + " xc: float\n", + " Center of modulo range\n", + " Lx: float\n", + " Modulo range width\n", + " Returns\n", + " -------\n", + " float\n", + " x shifted by an integer multiple of Lx to be close to xc, \n", + " \"\"\"\n", + " if Lx <= 0:\n", + " return x\n", + " else:\n", + " return ((x - (xc - 0.5*Lx)) % Lx )- Lx/2 + xc\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[0. 0. 0. ... 0. 0. 0. ]\n", + " [0. 0. 0. ... 0. 0. 0. ]\n", + " [0. 0. 0. ... 0. 0. 0. ]\n", + " ...\n", + " [0. 4.45305106 4.47236786 ... 4.39342157 4.3767402 4.36004645]\n", + " [0. 4.46353797 4.48289919 ... 4.40354537 4.38683191 4.37010606]\n", + " [0. 4.4740426 4.49344831 ... 4.41368567 4.3969401 4.3801821 ]]\n" + ] + } + ], + "source": [ + "\n", + "angles_arr_v2 = np.zeros((len(hgrid.nyp), len(hgrid.nxp)))\n", + "\n", + "# Compute lonB for all points\n", + "lonB = np.zeros((2, 2, len(hgrid.nyp)-1, len(hgrid.nxp)-1))\n", + "\n", + "# Vectorized computation of lonB\n", + "for n in np.arange(1,3):\n", + " for m in np.arange(1,3):\n", + " lonB[m-1, n-1] = modulo_around_point(hgrid.x[np.arange((m-2+1),(m-2+len(hgrid.nyp))), np.arange((n-2+1),(n-2+len(hgrid.nxp)))], hgrid.x[1:,1:], len_lon)\n", + "\n", + "# Compute lon_scale\n", + "lon_scale = np.cos(pi_720deg* ((hgrid.y[0:-1, 0:-1] + hgrid.y[1:, 1:]) + (hgrid.y[1:, 0:-1] + hgrid.y[0:-1, 1:])))\n", + "\n", + "# Compute angle\n", + "angle = np.arctan2(\n", + " lon_scale * ((lonB[0, 1] - lonB[1, 0]) + (lonB[1, 1] - lonB[0, 0])),\n", + " (hgrid.y[0:-1, 1:] - hgrid.y[1:, 0:-1]) + (hgrid.y[1:, 1:] - hgrid.y[0:-1, 0:-1])\n", + ")\n", + "# Assign angle to angles_arr\n", + "angles_arr_v2[1:,1:] = 90 - np.rad2deg(angle)\n", + "# Print the result\n", + "print(angles_arr_v2)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "hgrid[\"angle_dx_mom6\"] = ((\"nyp\", \"nxp\"), angles_arr_v2)\n", + "hgrid[\"angle_dx_mom6\"].attrs[\"_FillValue\"] = np.nan\n", + "hgrid[\"angle_dx_mom6\"].attrs[\"units\"] = \"rad\"\n", + "hgrid[\"angle_dx_mom6\"].attrs[\"description\"] = \"MOM6 calculates angles internally, this field replicates that for rotating boundary conditions. Use this over other angle fields for MOM6 applications\"\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "hgrid[\"angle_dx_mom6\"].plot(vmin = 0)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "angle_diff = hgrid[\"angle_dx\"][1:,1:] - hgrid[\"angle_dx_mom6\"][1:,1:]\n", + "plt.figure(figsize=(8, 6))\n", + "angle_diff.plot(cmap='coolwarm')\n", + "plt.title(\"Difference between caluculated MOM6 angle and angle_dx from Hgrid angle_dx\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.Dataset> Size: 129MB\n",
+       "Dimensions:        (nyp: 1561, nxp: 1481, ny: 1560, nx: 1480)\n",
+       "Dimensions without coordinates: nyp, nxp, ny, nx\n",
+       "Data variables:\n",
+       "    tile           |S255 255B ...\n",
+       "    y              (nyp, nxp) float64 18MB ...\n",
+       "    x              (nyp, nxp) float64 18MB -98.0 -97.96 -97.92 ... -37.49 -37.45\n",
+       "    dy             (ny, nxp) float64 18MB ...\n",
+       "    dx             (nyp, nx) float64 18MB ...\n",
+       "    area           (ny, nx) float64 18MB ...\n",
+       "    angle_dx       (nyp, nxp) float64 18MB ...\n",
+       "    angle_dx_mom6  (nyp, nxp) float64 18MB 0.0 0.0 0.0 0.0 ... 4.414 4.397 4.38\n",
+       "Attributes:\n",
+       "    file_name:    ocean_hgrid.nc\n",
+       "    Description:  MOM6 NCAR NWA12\n",
+       "    Author:       Fred Castruccio (fredc@ucar.edu)\n",
+       "    Created:      2024-04-18T08:39:49.607481\n",
+       "    type:         MOM6 supergrid file
" + ], + "text/plain": [ + " Size: 129MB\n", + "Dimensions: (nyp: 1561, nxp: 1481, ny: 1560, nx: 1480)\n", + "Dimensions without coordinates: nyp, nxp, ny, nx\n", + "Data variables:\n", + " tile |S255 255B ...\n", + " y (nyp, nxp) float64 18MB ...\n", + " x (nyp, nxp) float64 18MB -98.0 -97.96 -97.92 ... -37.49 -37.45\n", + " dy (ny, nxp) float64 18MB ...\n", + " dx (nyp, nx) float64 18MB ...\n", + " area (ny, nx) float64 18MB ...\n", + " angle_dx (nyp, nxp) float64 18MB ...\n", + " angle_dx_mom6 (nyp, nxp) float64 18MB 0.0 0.0 0.0 0.0 ... 4.414 4.397 4.38\n", + "Attributes:\n", + " file_name: ocean_hgrid.nc\n", + " Description: MOM6 NCAR NWA12\n", + " Author: Fred Castruccio (fredc@ucar.edu)\n", + " Created: 2024-04-18T08:39:49.607481\n", + " type: MOM6 supergrid file" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "hgrid" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "crr_dev", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.7" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From caac62c88048c43b5111d5bf8c2ced1c92dfa9cd Mon Sep 17 00:00:00 2001 From: manishvenu Date: Tue, 12 Nov 2024 10:47:13 -0700 Subject: [PATCH 10/87] Blacl --- regional_mom6/regridding.py | 47 ++++++++++++++++++++++++------------- 1 file changed, 31 insertions(+), 16 deletions(-) diff --git a/regional_mom6/regridding.py b/regional_mom6/regridding.py index e794d041..05490b43 100644 --- a/regional_mom6/regridding.py +++ b/regional_mom6/regridding.py @@ -381,7 +381,6 @@ def generate_encoding( return encoding_dict - def modulo_around_point(x, xc, Lx): """ This function calculates the modulo around a point. Return the modulo value of x in an interval [xc-(Lx/2) xc+(Lx/2)]. If Lx<=0, then it returns x without applying modulo arithmetic. @@ -396,13 +395,13 @@ def modulo_around_point(x, xc, Lx): Returns ------- float - x shifted by an integer multiple of Lx to be close to xc, + x shifted by an integer multiple of Lx to be close to xc, """ if Lx <= 0: return x else: - return ((x - (xc - 0.5*Lx)) % Lx )- Lx/2 + xc - + return ((x - (xc - 0.5 * Lx)) % Lx) - Lx / 2 + xc + def initialize_grid_rotation_angle(hgrid: xr.Dataset) -> xr.Dataset: """ @@ -418,8 +417,10 @@ def initialize_grid_rotation_angle(hgrid: xr.Dataset) -> xr.Dataset: """ regridding_logger.info("Initializing grid rotation angle") # Direct Translation - pi_720deg = np.arctan(1)/180 # One quarter the conversion factor from degrees to radians - + pi_720deg = ( + np.arctan(1) / 180 + ) # One quarter the conversion factor from degrees to radians + ## Check length of longitude len_lon = 360.0 G_len_lon = hgrid.x.max() - hgrid.x.min() @@ -430,31 +431,45 @@ def initialize_grid_rotation_angle(hgrid: xr.Dataset) -> xr.Dataset: angles_arr = np.zeros((len(hgrid.nyp), len(hgrid.nxp))) # Compute lonB for all points - lonB = np.zeros((2, 2, len(hgrid.nyp)-2, len(hgrid.nxp)-2)) + lonB = np.zeros((2, 2, len(hgrid.nyp) - 2, len(hgrid.nxp) - 2)) # Vectorized Compute lonB - Fortran is 1-indexed, so we need to subtract 1 from the indices in lonB[m-1,n-1] - for n in np.arange(1,3): - for m in np.arange(1,3): - lonB[m-1, n-1] = modulo_around_point(hgrid.x[np.arange((m-2+1),(m-2+len(hgrid.nyp)-1)), np.arange((n-2+1),(n-2+len(hgrid.nxp)-1))], hgrid.x[1:-1,1:-1], len_lon) + for n in np.arange(1, 3): + for m in np.arange(1, 3): + lonB[m - 1, n - 1] = modulo_around_point( + hgrid.x[ + np.arange((m - 2 + 1), (m - 2 + len(hgrid.nyp) - 1)), + np.arange((n - 2 + 1), (n - 2 + len(hgrid.nxp) - 1)), + ], + hgrid.x[1:-1, 1:-1], + len_lon, + ) # Vectorized Compute lon_scale - lon_scale = np.cos(pi_720deg* ((hgrid.y[0:-2, 0:-2] + hgrid.y[1:-1, 1:-1]) + (hgrid.y[1:-1, 0:-2] + hgrid.y[0:-2, 1:-1]))) + lon_scale = np.cos( + pi_720deg + * ( + (hgrid.y[0:-2, 0:-2] + hgrid.y[1:-1, 1:-1]) + + (hgrid.y[1:-1, 0:-2] + hgrid.y[0:-2, 1:-1]) + ) + ) # Vectorized Compute angle angle = np.arctan2( lon_scale * ((lonB[0, 1] - lonB[1, 0]) + (lonB[1, 1] - lonB[0, 0])), - (hgrid.y[0:-2, 1:-1] - hgrid.y[1:-1, 0:-2]) + (hgrid.y[1:-1, 1:-1] - hgrid.y[0:-2, 0:-2]) + (hgrid.y[0:-2, 1:-1] - hgrid.y[1:-1, 0:-2]) + + (hgrid.y[1:-1, 1:-1] - hgrid.y[0:-2, 0:-2]), ) # Assign angle to angles_arr - angles_arr[1:-1,1:-1] = 90 - np.rad2deg(angle) - + angles_arr[1:-1, 1:-1] = 90 - np.rad2deg(angle) # Assign angles_arr to hgrid hgrid["angle_dx_mom6"] = (("nyp", "nxp"), angles_arr) hgrid["angle_dx_mom6"].attrs["_FillValue"] = np.nan hgrid["angle_dx_mom6"].attrs["units"] = "deg" - hgrid["angle_dx_mom6"].attrs["description"] = "MOM6 calculates angles internally, this field replicates that for rotating boundary conditions. Use this over other angle fields for MOM6 applications" + hgrid["angle_dx_mom6"].attrs[ + "description" + ] = "MOM6 calculates angles internally, this field replicates that for rotating boundary conditions. Use this over other angle fields for MOM6 applications" return hgrid - From 798a9f42cd225ecaa024a5e4a5425cacb35efbca Mon Sep 17 00:00:00 2001 From: manishvenu Date: Wed, 13 Nov 2024 16:21:26 -0700 Subject: [PATCH 11/87] Rand --- .../angle_calc_mom6.ipynb | 591 ++++++++++++++++-- 1 file changed, 547 insertions(+), 44 deletions(-) diff --git a/regional_mom6/testing_to_be_deleted/angle_calc_mom6.ipynb b/regional_mom6/testing_to_be_deleted/angle_calc_mom6.ipynb index 921aedf6..f824f5cf 100755 --- a/regional_mom6/testing_to_be_deleted/angle_calc_mom6.ipynb +++ b/regional_mom6/testing_to_be_deleted/angle_calc_mom6.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 1, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -13,7 +13,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, "outputs": [ { @@ -43,21 +43,45 @@ "source": [ "\n", "hgrid = xr.open_dataset(\"/glade/u/home/manishrv/documents/nwa12_0.1/mom_input/n3b.clean/hgrid.nc\")\n", - "print(hgrid)\n" + "print(hgrid)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "k = 2\n", + "kp2 = k //2\n", + "tlon = hgrid.x[kp2::k,kp2::k]\n", + "tlat = hgrid.y[kp2::k,kp2::k]\n", + "\n", + "# U point locations\n", + "ulon = hgrid.x[kp2::k,::k]\n", + "ulat = hgrid.y[kp2::k,::k]\n", + "\n", + "# V point locations\n", + "vlon = hgrid.x[::k,kp2::k]\n", + "vlat = hgrid.y[::k,kp2::k]\n", + "\n", + "# Corner point locations\n", + "qlon = hgrid.x[::k,::k]\n", + "qlat = hgrid.y[::k,::k]\n" ] }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 5, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 3, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" }, @@ -99,23 +123,23 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "function modulo_around_point(x, xc, Lx) result(x_mod)\n", - " real, intent(in) :: x !< Value to which to apply modulo arithmetic [A]\n", - " real, intent(in) :: xc !< Center of modulo range [A]\n", - " real, intent(in) :: Lx !< Modulo range width [A]\n", - " real :: x_mod !< x shifted by an integer multiple of Lx to be close to xc [A].\n", + " function modulo_around_point(x, xc, Lx) result(x_mod)\n", + " real, intent(in) :: x !< Value to which to apply modulo arithmetic [A]\n", + " real, intent(in) :: xc !< Center of modulo range [A]\n", + " real, intent(in) :: Lx !< Modulo range width [A]\n", + " real :: x_mod !< x shifted by an integer multiple of Lx to be close to xc [A].\n", "\n", - " if (Lx > 0.0) then\n", - " x_mod = modulo(x - (xc - 0.5*Lx), Lx) + (xc - 0.5*Lx)\n", - " else\n", - " x_mod = x\n", - " endif\n", - "end function modulo_around_point" + " if (Lx > 0.0) then\n", + " x_mod = modulo(x - (xc - 0.5*Lx), Lx) + (xc - 0.5*Lx)\n", + " else\n", + " x_mod = x\n", + " endif\n", + " end function modulo_around_point" ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 6, "metadata": {}, "outputs": [ { @@ -141,7 +165,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ @@ -176,56 +200,504 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 13, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "[[0. 0. 0. ... 0. 0. 0. ]\n", - " [0. 0. 0. ... 0. 0. 0. ]\n", - " [0. 0. 0. ... 0. 0. 0. ]\n", - " ...\n", - " [0. 4.45305106 4.47236786 ... 4.39342157 4.3767402 4.36004645]\n", - " [0. 4.46353797 4.48289919 ... 4.40354537 4.38683191 4.37010606]\n", - " [0. 4.4740426 4.49344831 ... 4.41368567 4.3969401 4.3801821 ]]\n" + " Size: 5MB\n", + "array([[0. , 0. , 0. , ..., 0. , 0. ,\n", + " 0. ],\n", + " [0. , 0. , 0. , ..., 0. , 0. ,\n", + " 0. ],\n", + " [0. , 0. , 0. , ..., 0. , 0. ,\n", + " 0. ],\n", + " ...,\n", + " [4.43651643, 4.47489525, 4.5132071 , ..., 4.40963338, 4.37648025,\n", + " 4.34327766],\n", + " [4.45746382, 4.49601954, 4.53450787, ..., 4.429975 , 4.39669398,\n", + " 4.36336333],\n", + " [4.47848207, 4.51721524, 4.5558806 , ..., 4.45038282, 4.41697365,\n", + " 4.38351466]])\n", + "Dimensions without coordinates: nyp, nxp\n" ] } ], "source": [ - "\n", - "angles_arr_v2 = np.zeros((len(hgrid.nyp), len(hgrid.nxp)))\n", + "angles_arr_v2 = np.zeros((len(tlon.nyp), len(tlon.nxp)))\n", "\n", "# Compute lonB for all points\n", - "lonB = np.zeros((2, 2, len(hgrid.nyp)-1, len(hgrid.nxp)-1))\n", + "lonB = np.zeros((2, 2, len(tlon.nyp), len(tlon.nxp)))\n", "\n", "# Vectorized computation of lonB\n", "for n in np.arange(1,3):\n", " for m in np.arange(1,3):\n", - " lonB[m-1, n-1] = modulo_around_point(hgrid.x[np.arange((m-2+1),(m-2+len(hgrid.nyp))), np.arange((n-2+1),(n-2+len(hgrid.nxp)))], hgrid.x[1:,1:], len_lon)\n", + " lonB[m-1, n-1] = modulo_around_point(qlon[np.arange((m-2+1),(m-2+len(qlon.nyp))), np.arange((n-2+1),(n-2+len(qlon.nxp)))], tlon, len_lon)\n", "\n", "# Compute lon_scale\n", - "lon_scale = np.cos(pi_720deg* ((hgrid.y[0:-1, 0:-1] + hgrid.y[1:, 1:]) + (hgrid.y[1:, 0:-1] + hgrid.y[0:-1, 1:])))\n", + "lon_scale = np.cos(pi_720deg* ((qlat[0:-1, 0:-1] + qlat[1:, 1:]) + (qlat[1:, 0:-1] + qlat[0:-1, 1:])))\n", + "\n", + "\n", "\n", "# Compute angle\n", "angle = np.arctan2(\n", " lon_scale * ((lonB[0, 1] - lonB[1, 0]) + (lonB[1, 1] - lonB[0, 0])),\n", - " (hgrid.y[0:-1, 1:] - hgrid.y[1:, 0:-1]) + (hgrid.y[1:, 1:] - hgrid.y[0:-1, 0:-1])\n", + " (qlat[:-1, :-1] - qlat[1:, 1:]) + (qlat[1:, 0:-1] - qlat[0:-1, 1:])\n", ")\n", "# Assign angle to angles_arr\n", - "angles_arr_v2[1:,1:] = 90 - np.rad2deg(angle)\n", + "angles_arr_v2 = np.rad2deg(angle) - 90\n", "# Print the result\n", "print(angles_arr_v2)" ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.DataArray 'y' (nyp: 780, nxp: 740)> Size: 5MB\n",
+       "array([[90.        , 90.        , 90.        , ..., 90.        ,\n",
+       "        90.        , 90.        ],\n",
+       "       [90.        , 90.        , 90.        , ..., 90.        ,\n",
+       "        90.        , 90.        ],\n",
+       "       [90.        , 90.        , 90.        , ..., 90.        ,\n",
+       "        90.        , 90.        ],\n",
+       "       ...,\n",
+       "       [94.43651643, 94.47489525, 94.5132071 , ..., 94.40963338,\n",
+       "        94.37648025, 94.34327766],\n",
+       "       [94.45746382, 94.49601954, 94.53450787, ..., 94.429975  ,\n",
+       "        94.39669398, 94.36336333],\n",
+       "       [94.47848207, 94.51721524, 94.5558806 , ..., 94.45038282,\n",
+       "        94.41697365, 94.38351466]])\n",
+       "Dimensions without coordinates: nyp, nxp
" + ], + "text/plain": [ + " Size: 5MB\n", + "array([[90. , 90. , 90. , ..., 90. ,\n", + " 90. , 90. ],\n", + " [90. , 90. , 90. , ..., 90. ,\n", + " 90. , 90. ],\n", + " [90. , 90. , 90. , ..., 90. ,\n", + " 90. , 90. ],\n", + " ...,\n", + " [94.43651643, 94.47489525, 94.5132071 , ..., 94.40963338,\n", + " 94.37648025, 94.34327766],\n", + " [94.45746382, 94.49601954, 94.53450787, ..., 94.429975 ,\n", + " 94.39669398, 94.36336333],\n", + " [94.47848207, 94.51721524, 94.5558806 , ..., 94.45038282,\n", + " 94.41697365, 94.38351466]])\n", + "Dimensions without coordinates: nyp, nxp" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.rad2deg(angle)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, "metadata": {}, "outputs": [], "source": [ - "hgrid[\"angle_dx_mom6\"] = ((\"nyp\", \"nxp\"), angles_arr_v2)\n", + "# Create the new DataArray with the new dimensions\n", + "new_data_array = xr.DataArray(\n", + " angles_arr_v2,\n", + " dims=[\"qy\", \"qx\"],\n", + " coords={\n", + " \"qy\": tlon.nyp.values,\n", + " \"qx\": tlon.nxp.values,\n", + " }\n", + ")\n", + "\n", + "\n", + "\n", + "hgrid[\"angle_dx_mom6\"] = new_data_array\n", "hgrid[\"angle_dx_mom6\"].attrs[\"_FillValue\"] = np.nan\n", "hgrid[\"angle_dx_mom6\"].attrs[\"units\"] = \"rad\"\n", "hgrid[\"angle_dx_mom6\"].attrs[\"description\"] = \"MOM6 calculates angles internally, this field replicates that for rotating boundary conditions. Use this over other angle fields for MOM6 applications\"\n" @@ -233,22 +705,22 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 8, + "execution_count": 23, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -263,12 +735,42 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "hgrid[\"angle_dx\"][kp2::k,kp2::k].plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 31, "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAsAAAAIhCAYAAABANwzIAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAADeA0lEQVR4nOydeZgU1fX3vzU7jMywyQyDAwy4oWBUMAhKAEEQBIwbuCEaJBITfXHEhfBT0ShEJEgUERcUFQWzqHEhyOBCVMaNiAlIjCYooowjSGZYZ2Dmvn80XXRV13LvrVtLd5/P8/QDU3Xuubequ6q+ffrcczXGGANBEARBEARBZAhZYQ+AIAiCIAiCIIKEBDBBEARBEASRUZAAJgiCIAiCIDIKEsAEQRAEQRBERkECmCAIgiAIgsgoSAATBEEQBEEQGQUJYIIgCIIgCCKjIAFMEARBEARBZBQkgAmCIAiCIIiMQkgAL168GJqm6a+CggKUlpZi8ODBmDVrFmpra5PazJgxA5qmGbY1NjZi8uTJ6NixI7Kzs3HiiScCAH744QdcdNFF6NChAzRNw09/+lPpA0sHNE3Dr371K2X+9uzZgxkzZuCtt95S5jOd+fLLL6FpGhYvXhz2UPDWW29B0zSp9+7TTz/FjBkz8OWXXyofl9X1bcUVV1wBTdPQqlUr7Nq1K2n/V199haysLGiahhkzZiTt37hxI6644gp07twZeXl5aN++PUaOHIm//vWvSbbxc+X03p1xxhnQNA1du3ZN2rd7927cdtttOProo5Gfn4927dph8ODB+Pzzz12PM0wGDRqEQYMGhT0MKbp27Yorrrgi7GE4Esb55b2+eLF79kaVQYMGoWfPnpb7tm3bZnu/8Arv59HLfTkownqOpcI1nSPT6IknnsCxxx6L/fv3o7a2Fu+88w7uuecezJkzB8899xyGDh2q21511VU466yzDO0feughPPzww3jggQfQu3dvHHbYYQCA3/zmN3jhhRfw+OOPo3v37mjbtq2HQyPM7NmzB3fccQcApOyDkhDn008/xR133IFBgwZZCr6gyM3NxYEDB/Dcc89h4sSJhn1PPPEEWrVqhfr6+qR2zz//PC655BJ069YNt956K4455hh89913eOKJJzBy5EjceOONmD17dlK7Vq1aYdGiRUk34U2bNuGtt95CUVFRUptdu3Zh8ODB+Pbbb3HLLbfghBNOQF1dHdasWYM9e/Z4OwEEETJ2z17CyAsvvGB5fyDSCykB3LNnT/Tp00f/+/zzz8f111+P008/Heeddx4+//xzlJSUAACOOOIIHHHEEYb269evR4sWLZKim+vXr0f37t1x6aWXygzLkr1796JFixbK/BEEIUdeXh5Gjx6Nxx9/3CCAGWNYvHgxxo0bh0cffdTQ5j//+Q/Gjx+PXr164a233kJhYaG+78ILL8QvfvEL3HvvvTj55JNx0UUXGdqOGzcOjz32GD7//HMcddRR+vbHH38cnTp1Qq9evfDpp58a2vzf//0fNm7ciH/84x/o1q2bvn3MmDFKzgFBhInds9cMYwz79u3LuGdnXC+cdNJJYQ+FCABlOcCdO3fG7373O+zcuRMPP/ywvt38E46maXjsscewd+9ew8+UmqZh1apV2Lhxo749/rNCY2Mj7rrrLhx77LHIz8/H4YcfjiuvvBLff/+9YQxdu3bFqFGj8Pzzz+Okk05CQUGBHvGsqanB1VdfjSOOOAJ5eXmoqKjAHXfcgQMHDujt4z8VzJkzB3PnzkVFRQUOO+ww9OvXD++9917SMb///vsYPXo02rVrh4KCAnTv3h1Tpkwx2Hz++ee45JJL0KFDB+Tn56NHjx548MEHhc7tww8/rP8ce9xxx2HZsmVJNm7H9+WXX+Lwww8HANxxxx36Ob7iiiuwYcMGaJqGP/7xj7q/tWvXQtM0HH/88YZ+xowZg969exu2Pffcc+jXrx8KCwtx2GGHYfjw4fj444+TxvjRRx9hzJgxaNu2LQoKCnDSSSfhD3/4g8Em/ll488038Ytf/ALt27dHu3btcN555+Hbb7/lOl9u78sXX3yBK6+8EkcddRRatmyJTp06YfTo0fjnP//p6vuKK66wjKJa/VTZ3NyMBx54ACeeeCJatGiB1q1b49RTT8VLL72k29j9hMfz89FHH32Eiy66CF27dkWLFi3QtWtXXHzxxfjqq690m8WLF+PCCy8EAAwePNgyNWDVqlUYMmQIioqK0LJlS5x22ml4/fXXk/p79dVXceKJJyI/Px8VFRWYM2eO4/is+NnPfoY1a9bgs88+M/T/1Vdf4corr0yyv++++7Bnzx488MADBvEb53e/+x1at26Nu+++O2nfmWeeifLycjz++OP6tubmZjz55JOYMGECsrKMt789e/bgsccew4UXXmgQvyLccccd6Nu3L9q2bYuioiKcfPLJWLRoERhjBrv4vWrFihU4+eST0aJFCxx77LGGscZ555130K9fPxQUFKBTp0649dZb8dhjj0HTNNe0Ft57pxU8ny9A7Jrdv38/brrpJpSWlqJly5Y4/fTT8cEHH7iOJU46nV8zPNfXsmXLoGka5s+fb9h+++23Izs7G1VVVbb+7Z698X2/+tWvsHDhQvTo0QP5+fl48sknAcTOz5AhQ9CqVSu0bNkS/fv3x6uvvmrwHf8MvPHGG5g0aRLatWuHoqIiXH755di9ezdqamowduxYtG7dGh07dsTUqVOxf/9+4XPEA+/76aQXrO6///rXv3DWWWehZcuWaN++PSZPnoydO3dyjYn3mRNPqVi6dCmmT5+OsrIyFBUVYejQoYZ7JhD7kjJz5kx06dIFBQUF6NOnD6qqqrhTdVRoE4DvmmaMYeTIkWjXrh02b96sb9+zZw+OP/549OjRA7t37xbu2zNMgCeeeIIBYB9++KHl/l27drHs7Gw2ZMgQfdvtt9/OEruprq5mI0eOZC1atGDV1dWsurqa1dTUsOrqanbSSSexbt266dvr6upYU1MTO+uss1hhYSG74447WFVVFXvsscdYp06d2HHHHcf27Nmj++7SpQvr2LEj69atG3v88cfZm2++yT744AO2detWVl5ezrp06cIefvhhtmrVKvab3/yG5efnsyuuuEJvv2nTJgaAde3alZ111lnsxRdfZC+++CLr1asXa9OmDfvf//6n265YsYLl5uayE044gS1evJi98cYb7PHHH2cXXXSRbrNhwwZWXFzMevXqxZ566im2cuVKdsMNN7CsrCw2Y8YM1/MNgJWXl7PjjjuOLV26lL300kvsrLPOYgDYH//4R92O5/j27dvHVqxYwQCwiRMn6uf4iy++YIwx1rFjR/bzn/9c9/nb3/6WtWjRggFg33zzDWOMsf3797OioiJ200036XZ333030zSN/exnP2OvvPIKe/7551m/fv1YYWEh27Bhg273xhtvsLy8PDZgwAD23HPPsRUrVrArrriCAWBPPPGEbhf/jHXr1o1de+217LXXXmOPPfYYa9OmDRs8eLDrOeN5X1avXs1uuOEG9qc//YmtXr2avfDCC+ynP/0pa9GiBfvXv/6l28U/D4njmzBhAuvSpUtSv+bPOWOMjR8/nmmaxq666ir2l7/8hf31r39ld999N/v973+v2wBgt99+e5K/Ll26sAkTJuh/v/nmmwwAe/PNN/Vtf/zjH9ltt93GXnjhBbZ69Wq2bNkyNnDgQHb44Yez77//njHGWG1tLZs5cyYDwB588EH9fa+trWWMMfb0008zTdPYT3/6U/b888+zl19+mY0aNYplZ2ezVatW6X2tWrWKZWdns9NPP509//zz7I9//CM75ZRTWOfOnZOO24oJEyawwsJC1tzczLp06WL4DI0bN4795Cc/Yd9//33S+Tj66KNZSUmJo++xY8cyAGzr1q2Gc/XHP/6R3XrrraysrIwdOHCAMcbYX//6V6ZpGvviiy/Y2WefbXgv//a3vzEA7O6772aTJ09mrVu3Zrm5uax3797slVdecT1Gxhi74oor2KJFi1hVVRWrqqpiv/nNb1iLFi3YHXfcYbDr0qULO+KII9hxxx3HnnrqKfbaa6+xCy+8kAFgq1ev1u0++eQTVlBQwE444QS2bNky9tJLL7GRI0eyrl27MgBs06ZNuu3AgQPZwIED9b9F7p1W8Hy+GBO7ZidMmMA0TWM33ngjW7lyJZs7dy7r1KkTKyoqMnzeM+H8JiJyfU2ePJnl5eXpz+HXX3+dZWVlsf/7v/9z7MPq2Ru/DwBgnTp1YieccAJ79tln2RtvvMHWr1/P3nrrLf0aeO6559iLL77Ihg0bxjRNY8uWLdN9xz8DFRUV7IYbbmArV65k99xzD8vOzmYXX3wxO/nkk9ldd93Fqqqq2M0338wAsN/97neu52XgwIHs+OOPZ/v370961dTUJN0vRN5PO70Q35f4eaypqWEdOnRgnTp1Yk888QRbvnw5u/TSS/X3J/G+bAXvMyd+7+ratSu79NJL2auvvsqWLl3KOnfuzI466ij9PsYYY9OmTWMA2M9//nO2YsUK9uijj7LOnTuzjh07Gj6nVs8xr9okEd5retu2beyII45gffv2ZY2NjXrbFi1asH/84x9CfapCqQBmjLGSkhLWo0cP/W8rYRB/GJqJf9gTWbp0KQPA/vznPxu2f/jhhwwAW7Bggb6tS5cuLDs7m3322WcG26uvvpoddthh7KuvvjJsnzNnDgOgC7X4B6VXr16GD9oHH3zAALClS5fq27p37866d+/O9u7da3suhg8fzo444ghWV1dn2P6rX/2KFRQUsB9++MG2LWOxm1KLFi1YTU2Nvu3AgQPs2GOPZUceeaTw8VkJjDiXXXYZ69atm/730KFD2aRJk1ibNm3Yk08+yRhj7N1332UA2MqVKxljjG3evJnl5OSwa6+91uBr586drLS0lI0dO1bfduyxx7KTTjqJ7d+/32A7atQo1rFjR9bU1MQYO/QZu+aaawx2s2fPNogcO3jeFzMHDhxgjY2N7KijjmLXX3+9vt2LAI6LqenTpzv27UUAWx3Hrl27WGFhoUFk//GPf7Rsu3v3bta2bVs2evRow/ampib2ox/9iP34xz/Wt/Xt25eVlZUZzmt9fT1r27atkABmLHauSktL2f79+9n27dtZfn4+W7x4seXns6CggJ166qmOvuMP1Pfff58xZhTA//3vf5mmabqAvfDCC9mgQYMYYyxJAMfvNUVFRey0005jL730EnvllVfY4MGDmaZpbMWKFa7HmUhTUxPbv38/u/POO1m7du1Yc3Ozvq9Lly6soKDAcM3u3buXtW3bll199dX6tgsvvJAVFhYaBGdTUxM77rjjXAWayL2TB7vPF+81u3HjRgbAcI0xxtgzzzzDAHAJ4ETS6fyKXF/79u1jJ510EquoqGCffvopKykpYQMHDjQ8s+ywe/YCYMXFxUnPpFNPPZV16NCB7dy5U9924MAB1rNnT3bEEUfo5zz+GTA/C376058yAGzu3LmG7SeeeCI7+eSTXcc7cOBABsDxlXi/EHk/7fRCfF/i5/Hmm29mmqaxdevWGezOPPNMLgFsxu6ZE793jRw50mD/hz/8gQFg1dXVjDHGfvjhB5afn8/GjRtnsKuurmYAXAWwV20SR/Safuedd1hOTg6bMmUKe/zxxxkA9thjj3H15QfKy6Ax009RXnnllVfQunVrjB49GgcOHNBfJ554IkpLS5NmX55wwgk4+uijk3wMHjwYZWVlBh8jRowAAKxevdpgf/bZZyM7O9vgE4D+09+///1v/Oc//8HEiRNRUFBgOe59+/bh9ddfx7nnnouWLVsa+h05ciT27dtnmVZhZsiQIXo+NQBkZ2dj3Lhx+OKLL7Blyxap47Pr57///S82bdqEffv24Z133sFZZ52FwYMH6z+rrVq1Cvn5+Tj99NMBAK+99hoOHDiAyy+/3NBvQUEBBg4cqL83X3zxBf71r3/pud3mc7F169akn3fMOZfm98AKnvcl3v/MmTNx3HHHIS8vDzk5OcjLy8Pnn3+OjRs3up4rHuLVCX75y18q8WfFrl27cPPNN+PII49ETk4OcnJycNhhh2H37t1cx7FmzRr88MMPmDBhguE9aW5uxllnnYUPP/wQu3fvxu7du/Hhhx/ivPPOM5zXVq1aYfTo0cLjvvLKK/Hdd9/hr3/9K5555hnk5eXpaRoyxO85VrPlKyoqMGjQIDz++OPYvn07/vKXv+BnP/uZpZ/m5mYAsVzlv/71rxg9ejTOPvtsvPLKK+jYsSN+85vfuI7ljTfewNChQ1FcXIzs7Gzk5ubitttuw/bt25Oq5Jx44ono3Lmz/ndBQQGOPvpow2d89erVOOOMM9C+fXt9W1ZWFsaOHes6FtF7pxnRz5fbNfvmm28CQNIcj7FjxyInh286Sjqd3zii11d+fj7+8Ic/YPv27Tj55JPBGMPSpUsNzywZzjjjDLRp08Ywrvfffx8XXHCBYbJcdnY2xo8fjy1btiTdt0eNGmX4u0ePHgBiz1Tzdqd7eSLdu3fHhx9+mPRatWpVkq3o+2mlF6x48803cfzxx+NHP/qRYfsll1zCdQyizxy3a+m9995DQ0ND0nGdeuqprhOdVWkTQPyaPu2003D33Xdj3rx5+MUvfoHLLrssaUJ0kEhNgrNj9+7d2L59O3r16qXM53fffYf//e9/yMvLs9y/bds2w98dO3a09PHyyy8jNzeXy0e7du0Mf+fn5wOIJcgD0PO7zJP7Etm+fTsOHDiABx54AA888ABXv1aUlpbabtu+fTuOOOII4eOzIl65Y9WqVaioqMD+/ftxxhln4LvvvtMf/KtWrcJpp52mT4z47rvvAACnnHKKpc94jmXcburUqZg6dSrXGN3eAyt43hcAqKysxIMPPoibb74ZAwcORJs2bZCVlYWrrrrK0b8I33//PbKzsy3fP1VccskleP3113HrrbfilFNOQVFRETRNw8iRI7mOI/6+XHDBBbY2P/zwAzRNQ3Nzs+NnUYQuXbpgyJAhePzxx/Hll1/ioosuQsuWLS2rLHTu3BmbNm1y9BfP6ysvL7fcP3HiRFx55ZWYO3cuWrRoYXu88c9c//790apVK317y5YtMXDgQLz44ouO4/jggw8wbNgwDBo0CI8++qiej//iiy/i7rvvTnpPzJ9xIPY5T7Tbvn274QtwHKttZkTvnWZEP19u1+z27dsBJH9mcnJyLM+FmXQ7v3F27NghfH0deeSRGDBgAF599VX84he/sHzuiWL2sWPHDjDGLH2XlZUBOPSexjFXboqfG6vt+/bt4xpXPL/VjNX5FX0/ec/b9u3bUVFRkbSd9/4n+szhvZZkPruqtEniOESu6UsvvRS33norGhoacOONN3L14xdKBfCrr76KpqYmpSW24hMqVqxYYbk/8UEFWEeB2rdvjxNOOMFyogxw6GLmJT6ZLB6BtaJNmzb6N2W7KKDVBWWmpqbGdlv8A6bi+I444ggcffTRWLVqFbp27Yo+ffqgdevWGDJkCK655hq8//77eO+99/RJAvF+AeBPf/oTunTpYus7bjdt2jScd955ljbHHHOM6xjd4HlfAGDJkiW4/PLLMXPmTMP2bdu2oXXr1o5tCwoK0NDQkLTdfMM4/PDD0dTUhJqaGsebbH5+vqU/84PFTF1dHV555RXcfvvtuOWWW/TtDQ0N+OGHHxzbxom/Lw888ABOPfVUS5uSkhLs378fmqY5fhZF+dnPfobLLrsMzc3NeOihh2ztzjzzTDz44IN47733LMe4Z88eVFVVoWfPnrYPo/POOw+//OUv8dvf/haTJk2yndkej7JYwRhLmjRnZtmyZcjNzcUrr7xiiOS5CWcn2rVrp39RSYTnvIveOxNR8fkyE79f1dTUoFOnTvr2AwcOuH7egfQ6v4m0adNG+Pp67LHH8Oqrr+LHP/4x5s+fj3HjxqFv375c/dlhfnbGRdrWrVuTbOOTGxMjrVFA9P3krbHcrl07T/c/L88cu/EAsD1WpyiwKm2SOA7ea7qpqQmXXnop2rRpg/z8fEycOBHvvvuu7ZdIv1EmgDdv3oypU6eiuLgYV199tSq3GDVqFJYtW4ampibpC3zUqFFYvnw5unfvbviJR5ajjz4a3bt3x+OPP47Kykr921kiLVu2xODBg/Hxxx/jhBNOkH6DX3/9dXz33Xf6t7qmpiY899xz6N69ux7p5D0+tyjq0KFD8Yc//AHl5eX6T1ZHH300OnfujNtuuw379+831HgePnw4cnJy8J///Afnn3++bb/HHHMMjjrqKHzyySdJNwCV8LwvQOymZ9736quv4ptvvsGRRx7p2EfXrl1RW1treE8aGxvx2muvGexGjBiBWbNm4aGHHsKdd97p6O8f//iHYdsbb7xhuViE+RgYY0nH8dhjj6Gpqcmwze59P+2009C6dWt8+umnjmWR8vLy8OMf/xjPP/887r33Xl187Ny5Ey+//LLjOO0499xzce6556K4uNhWfAPA9ddfj8cffxzXXnttUhk0IParwo4dOxxFdIsWLXDbbbfhb3/7G37xi1/Y2nXs2BH9+vXDu+++i/r6er0O6J49e7B69WrHcQKx9yQnJ8fwU/TevXvx9NNPO7ZzYuDAgVi+fDm2bdumi43m5mZDxRY7vNw7RT5fvMQDI88884yhkswf/vAHQzUepzGly/lNpLCwUOj6+uc//4nrrrsOl19+OR599FH0798f48aNw8cff6zk+ZY4rr59++L555/HnDlz9C+Ozc3NWLJkiR40iRJe3k8nBg8ejNmzZ+OTTz4xpEE8++yzXO29PHOs6Nu3L/Lz8/Hcc88ZgkrvvfcevvrqK0cBrEqbAOLX9O233463334bK1euRGFhIX7yk5/gxhtvxO9//3vpMXhBSgCvX79ezxmpra3F22+/jSeeeALZ2dl44YUX9EicCi666CI888wzGDlyJP7f//t/+PGPf4zc3Fxs2bIFb775Js455xyce+65jj7uvPNOVFVVoX///rjuuutwzDHHYN++ffjyyy+xfPlyLFy40PVnczMPPvggRo8ejVNPPRXXX389OnfujM2bN+O1117DM888AwD4/e9/j9NPPx0DBgzAL37xC3Tt2hU7d+7EF198gZdffhlvvPGGaz/t27fHGWecgVtvvRWFhYVYsGAB/vWvfxlKofEeX6tWrdClSxf85S9/wZAhQ9C2bVu0b99ev1iGDBmCBQsWYNu2bZg3b57uf8iQIXjiiSfQpk0bw4e8a9euuPPOOzF9+nT897//xVlnnYU2bdrgu+++wwcffIDCwkI9Yvzwww9jxIgRGD58OK644gp06tQJP/zwAzZu3Ii///3vnm9QcXjel1GjRmHx4sU49thjccIJJ2Dt2rW49957uT4D48aNw2233YaLLroIN954I/bt24f7778/SRQMGDAA48ePx1133YXvvvsOo0aNQn5+Pj7++GO0bNkS1157LQBg/PjxuPXWW3Hbbbdh4MCB+PTTTzF//nwUFxc7jqOoqAg/+clPcO+99+rv4erVq7Fo0aKkiEJ8JaVHHnkErVq1QkFBASoqKtCuXTs88MADmDBhAn744QdccMEF6NChA77//nt88skn+P7773Vh+Zvf/AZnnXUWzjzzTNxwww1oamrCPffcg8LCQqmIYEFBAf70pz+52nXv3h1PP/00Lr30UpxyyimorKzUF8J4/PHH8de//hVTp07FuHHjHP1UVlaisrLStb85c+Zg8ODBGD58OG6++WZomobf/e532LZtm2sO8Nlnn425c+fikksuwc9//nNs374dc+bMsf0ixsP06dPx8ssvY8iQIZg+fTpatGiBhQsX6iWDnKLSXu6dIp8vXnr06IHLLrsM8+bNQ25uLoYOHYr169djzpw5XIsOpNP5NcN7fe3evRtjx45FRUUFFixYgLy8PPzhD3/AySefjCuvvNJTNNyKWbNm4cwzz8TgwYMxdepU5OXlYcGCBVi/fj2WLl2qdJU6FXh5P52YMmUKHn/8cZx99tm46667UFJSgmeeeQb/+te/uNp7eeZY0bZtW1RWVmLWrFlo06YNzj33XGzZsgV33HEHOnbs6HqcKrQJIHZNV1VVYdasWbj11lsxZMgQALHP19SpUzFo0CDua0UpIjPm4jM946+8vDzWoUMHNnDgQDZz5ky9pEoiXqtAMBYrvzVnzhz2ox/9iBUUFLDDDjuMHXvssezqq69mn3/+uW7XpUsXdvbZZ1uO/fvvv2fXXXcdq6ioYLm5uaxt27asd+/ebPr06WzXrl2MsUOzJe+9996k9rCYrV9dXc1GjBjBiouLWX5+PuvevXvSbMhNmzaxn/3sZ6xTp04sNzeXHX744ax///7srrvushynuc9f/vKXbMGCBax79+4sNzeXHXvsseyZZ56ROj7GYuV2TjrpJJafn580S3PHjh0sKyuLFRYW6mVKGDs0o/O8886zHOeLL77IBg8ezIqKilh+fj7r0qULu+CCCwxltBiLlagZO3Ys69ChA8vNzWWlpaXsjDPOYAsXLtRt7CqN8FRBiOP2vuzYsYNNnDiRdejQgbVs2ZKdfvrp7O23306a5W01e5YxxpYvX85OPPFE1qJFC9atWzc2f/58y895U1MTu++++1jPnj1ZXl4eKy4uZv369WMvv/yybtPQ0MBuuukmVl5ezlq0aMEGDhzI1q1bx1UFYsuWLez8889nbdq0Ya1atWJnnXUWW79+fVJbxhibN28eq6ioYNnZ2UnHtHr1anb22Weztm3bstzcXNapUyd29tlnG0rtMcbYSy+9xE444QSWl5fHOnfuzH77299aHrcVdtd8Ik5VSjZs2MAmTJjAjjjiCP3zfdZZZ7FXX301yTaxCoQT5ioQceKfhZYtW7KWLVuyM844g7377ruOvuI8/vjj7JhjjmH5+fmsW7dubNasWWzRokWWM9Ct7lXmz2B8PH379mX5+fmstLSU3Xjjjeyee+5hAAylGa3a8t47reD9fIlcsw0NDeyGG25gHTp00Ct8VFdXW35mrUin82uG5/q67LLLWMuWLQ0lJhk7VOnlvvvuc+zDqQrEL3/5S8s2b7/9NjvjjDNYYWEha9GiBTv11FMN9zDG7D8D8fEnVmVwGocZO03AmP39gvf9dNILVp/HTz/9lJ155pmsoKCAtW3blk2cOJH95S9/4Xou8T5z7O5dVs+i5uZmdtddd7EjjjiC5eXlsRNOOIG98sor7Ec/+hE799xzHdvGt8tqk0R4rulvv/2WdejQgZ1xxhl6xaf4MYwePZq1bt3acP0GhcaY4rINBEEQhK8MGzYMX375Jf7973+HPZS0hM5vepEp7+emTZtw7LHH4vbbb8evf/3rsIcTeZROgiMIgiDUUllZiZNOOgnl5eX44Ycf8Mwzz6CqqgqLFi0Ke2hpAZ3f9CJT3s9PPvkES5cuRf/+/VFUVITPPvsMs2fPRlFRUailxVIJEsAEQRARpqmpCbfddhtqamqgaRqOO+44PP3007jsssvCHlpa4Of5bW5u1utL28FbA5ngI1Oul8LCQnz00UdYtGgR/ve//6G4uBiDBg3C3XffzVXGz42mpibHdR00TfNcezpsKAWCIAiCIHxgxowZhtKRVmzatMl18QKCCJquXbs6LlaSuNhVqkICmCAIgiB84Ntvv9Vr5trhtRQVQfjBP//5T8sa9XFatWqlpH5/mJAAJgiCIAiCIKRYsGAB7r33XmzduhXHH3885s2bhwEDBtjar169GpWVldiwYQPKyspw0003YfLkyZa2y5Ytw8UXX4xzzjknqcyfaL9m5IriEQRBEARBEBnNc889hylTpmD69On4+OOPMWDAAIwYMQKbN2+2tN+0aRNGjhyJAQMG4OOPP8avf/1rXHfddfjzn/+cZPvVV19h6tSplqJWtF8rKAIcEs3Nzfj222/RqlWryBUTJwiCIAjCGsYYdu7cibKyMunFNbywb98+NDY2+uI7Ly/PsNS4G3379sXJJ59sWI2zR48e+OlPf4pZs2Yl2d9888146aWXsHHjRn3b5MmT8cknn6C6ulrf1tTUhIEDB+LKK6/E22+/jf/973+GCLBov1bQ9NOQ+Pbbb1FeXh72MAiCIAiCkODrr7+WXs1Nln379qGsxWHYAbklyd0oLS3FJ598YhDB+fn5lisuNjY2Yu3atbjlllsM24cNG4Y1a9ZY+q+ursawYcMM24YPH45FixZh//79yM3NBRBb4fbwww/HxIkT8fbbb3vu1woSwCHRqlUrAMDTrY9ES+1QKRG237lkTthoue7fdrOy7SPaWm7yvqyc5G2WdhZ+NdO2RBstSzPZZtnbamZb6z60hG/7if7t+tW0LC5bK78GP9zbsgT2JZyPg8cfPw9OtgcP6ZDvuK1NW71B3JeW0G+WXRvT+E19wHxeE/rQTP0Zxh9vn9DPoX1GmyQ/mtmHqV2Wdmhfko3ZR8J2G7/M7EtL2O7aJv630Y4hK2mMSW2gJbQz+mUW42Yw74Pel7md2ZZpWvI2JIxVH49man/wXxZ/j7P0fXobmNow098WNs2J+3R7WLdnmuO++N/NDNb7Dm5vTuzLZNusd6AZ7A22zGib6CP+NGGmfc3m/liyv0O2yT7M2+KV3pL6AfRSWvo+k22S/2Zm4d/kQ2/LjD5h+psl+DL5OOTT2Eb3efDf5L4ZGvftxBMzeujP8SBpbGzEDjRhcXYFWirOYt2DZlxRsympjNrtt9+OGTNmJNlv27YNTU1NSfYlJSWoqamx7KOmpsbS/sCBA9i2bRs6duyId999F4sWLcK6dessfcj0awUJ4JCIP8gPy8lBYVaC2soFmg9ENyvFSqyasRKvbu25hbGD4AXERK/Z3iBMk+wEha9Z0NnY2vl1ErBOfqx9WIlrk4By8OUozt3Er9kXl/i18aFZ+7QV2HbHavo7SQAn+hERv452CaLVVhRbiFkbIWrVxlX8mttYCOpkMWshgF1ELTTtkHh1sE0WtTYiOUGQ2wlgliCAbf9NEKV2+6wFsI2AZokC05sAjm+3E8CJbUQEcHw7jwA+ZOsugM1+bQVwgmjUx88hgM3buQWwLlpNf3OIYG4BrH8rSbgnhUBhbrYheKYCjTUBTbHIdlFRkb7dKvpraGc6D4wxx3NjZR/fvnPnTlx22WV49NFH0b59e6X9miEBHDJarpYk2qI+M9FJ4MZxEsq8YhdwF7yAOtFr7k9W9IraW4nWxP8n+o37ko36GvyZo6yWvhzGKCh+DaSC+HVDRPy6+bCL5Dr2b+pHBLOgdiAp+sszJkd//ONNjOra20T7jpmlJURyVfgD00UwL5p2SMC527KEyDqf36ysQ6LTjbityJiysjQ0NzO9jd6vpqGZMWhZMRGsaZrj4g2Ox3LQh+7zoK+kvq3uZyGg5WjIUizAtYPve1FRkUEA29G+fXtkZ2cnRV1ra2ttF+MoLS21tM/JyUG7du2wYcMGfPnllxg9erS+P76YTE5ODj777DOUl5cL92sFCeCQycrRkGW+oExiMOyIME/UN45U9NcmZUK12LXcryjS69VeNOKbuF9W+Brb2tu7RX0t29tFfh36i5z4dRO2VrilPnCI4uQor03017J/0z676K8D5uivo605+sthywOXP06RJjuGMBARhV78Z2lMjwK72/ILeLNA5SHuP1FgMo/fGA6J7IMiNt7HQd+HhHtc3MoL50wmLy8PvXv3RlVVFc4991x9e1VVFc455xzLNv369cPLL79s2LZy5Ur06dMHubm5OPbYY/HPf/7TsP///u//sHPnTvz+979HeXm5VL9WkAAOGasIsJnsXA1sf7gXJ0/UF3AXy17Ebqx98oPRL9Frbhu08E30xxs5dkx3ABLEn5PQtfJhLUotj4tT/BpINfFrZ8eDS+qDkA+biLFIlFUX2DziUCAaLBI5Nqc48PjNdMwiUybSLBYZ9iJutYM/T8sLY3Mk9pBdCFHgCHwGtdwsvl+qRHxKnLfKykqMHz8effr0Qb9+/fDII49g8+bNel3fadOm4ZtvvsFTTz0FIFbxYf78+aisrMSkSZNQXV2NRYsWYenSpQCAgoIC9OzZ09BH69atAcCw3a1fHkgAh0xWtuY4aSxO2FPjhKLADsdjd6x2XwJkBK+ljYPoNftw8q9a+Cb+30r42u0XjvoCSeLXSSyLpDxY2nCI38DSHlQhk/drsBcXpULR34PYCk6r3F9XX/wiVm8jkJIgFBUOKHobhSixBsY9DnPKgkwUWaaNWaAKtZVIgzDj1lY0CkzIMW7cOGzfvh133nkntm7dip49e2L58uXo0qULAGDr1q2G2rwVFRVYvnw5rr/+ejz44IMoKyvD/fffj/PPP19pvzxQHeCQqK+vR3FxMVYcfwIKs2OJ7M1NYm8FE7QXwUnE2uEm5EVErp0/FWLX7IdX8Dq1kxW9ZnuniG/idhXpDu7bbASpVZ9WY3BLe7CokOGL+A0i+iua+sBZxcEgVmUrPzhNfjv4N9fkNwufxooRB/eFMAHOsN/iX6sKEIZ/EybBOU16M//NMwkOgGEinNMkuMTtxklsdm2M/auaCBf3yTMRzvC3xWQ4q4lwVrYyk+GM7Q9NiPMyGS7uw+DTNCFu3556LLy5E+rq6rhyZVUS1w4vtD/WOIFeAbubm3Dutn+FclxhQBHgkNGyDqVACP+Yka0Ji2ZeeKLSZtxSOeyErlN/PII35ttZ9LqmRWTZt/eaFiEifBNt3NMmnIWsU7qDVRueqK+lfaaLX6/wiF9VSESUzYikK+htBHKFzW28EIVoblTwEhmWSa+I4yUNIsmXTRpE8rjjqQuUC0zYQwI4ZLTsLF0YmiuasCb3xIdsF9EZBE7CNo5jbWCbY+ARurH2zhFeK19Ogte8XyYlQlb02vnkFbGxP9QJ35g7e3u3lAfLdm4pDxZ+hcWv5fnwSfx6jf464FT2zGq/a/SXB5foLw9yqRPibcxt7f7mQbSyAhALWoimp4lUWfDSxt5XXNS6T4Sza6tEGOvi1OhLdDKcHxMHeXKBw4Zn/pCwz+YIHFiAkAAOGacc4GaF5X3MYppHtIrAEzF2ulhtI8CKBK+VjUiUmDctQrXwTfy//f5kgcLbxmvU19CXh3xfA7Li14qoi1+X6K+v2KQdiGCX/iDlQwJzf+ke8bUTe14EsszkNjsfKnJ7zZiFsehkONkosJMIJtIDEsAho2n23+JUPALjKRIy6Qci8HwTdYwC26ZAWI+bKxfYRfBa2TiuJOeQFuGn8E204Z3gxtPGKrosM9EtZu9N/MqmPRiwEaN24jdl8Cv3VwKZ9IdkH3Gx7MGHomhomHhKBbCpBewlImv2oSLqnBzd9Z4GQcSwLKHq1SdFgIkgycpzKGadIJhkc339TpHgFc9Ok+qcInjcOcAWdm4RXitfMpFep3YqRK/tdouIb+J+L8LX0o9T1Bdwzfe18mUWvpbteCK/EuI36tHfIMp9iU5+E/KtIMKcPE7158SLyAu7Oo99RPhgVFegmoRbH+ZIrAp40yDcosCH2mdOFJhSILxDAjhktKwsvuhpAGORhbdihKjQBcQmx/mdC2z+26mtr8IXcIz4Jm537c8h19fWziEaG5T4NeAmfi1IGfHrY+UHZZjSH1SIVBWimbePsJFZ2U24Dx/Eq51ojYtNgog6JIBDRsvSHB/Uh4j2HYXvGOyFLiAmdu36VJEa4SR6zX+b2wYlfBNtpPJ8Ab6ob6KdU/TUqq1ApQerdk7il3uhCx5/buI30zGJaj/EaRCC19xX1FA50c29L/mJcKJ9+J0GEUYUOArwriEg5LMpGscWFCSAQyYrW0N2zqGbvl2qg2aq9+d1qUgViPz8Il0j2EMOsJ2dF8Frbi9TIYLXTibim7jdTfjG3PoQ9Y39Ye/LLd83wb+StAcHf1ziN02jv9zpDwpgZt8+imjZ/VEhjPxYe7Hqvyj3mgZBELKQAA6ZWAT44MOgmXF/o4tKPFjkG6ibYBYRu3Z9y6ZGiIhec9+8k+X47bxFfI22zsI3sZ3KqK9hW9TFrxOqxG+a47b4ha99ugnfFJ0wpyJ/VxW24tS0PaqkYxRYy9akFqxy9BmRz1tQkAAOGU3LShARh7YzlyQq8+S2ICPCoon3POkRqlIjeNMivAhes73YZDk50cvbNjThG/vD3p9AyoNVn14WubA8BqvJXaryfq1I1eivW/pDoBP1Dv7rImjNq7ylOrzR2Pj+MMWoOQ+YNw3C78lwBGEFCeCQSYwAGxGNHAV7lfPm/B6yd38YySyWISt4rbaJiF6zvUiesJ/C1/B/F+Fra6tC/DpEfQ12fonfBBwn0CX54xDKbqhOfUhz3JZDJozoIs9l8pwuCg9Gks3iMVNREQWOAr7kAKfJl0ZeSACHjN2HWETOsmYmLEhVIRoNls0Fju3jT5Hg3yYves37xQSyj8IXkIr6Jm53Km9maC+b8pDYVpX4TcTqOMz92uX9cgllm+ivHyJWNvobMHbpD0Hk/2YysoLWPBEu1dIa4oiWRCOIOCSAQ8YuAhxPceBKbbAS0JJ1g92Q/cbJI5RlyqSJbLfyr75ChDrR67TPc8TXbO8gfBN9CKc8JG4TyPc1jNsigiyV85toxyN+ZfN+rfAr9cGJgNIfZFZ/S3VSNa9YhnhqBW8ecNBpEDKkQxTY/tdjDz4z6HMNkAAOnVgdYKcHiHhqg8hkOllkLjyvucDiIthd8Fq19yJ6zfuTxuCH8AUsxa+tT4l0B4OtYNTXrm0g4jcRnooPrrYWx8HZ1pfljiMS/c0U0iWvOF0QzQVWEQWOyg8XWnaW4wqvUj6RWRFyEsAh4/QtTia1gTU3K/9W6IRM6oV7NQgZEWw9Dv9Ko7nZW0d7zba8EWPZVAdHew9RX8P2qIpfnmhuInZ5v06fcQWpD6LRXy7SYPJbIuYJcOYKEH4L00yK+EYRuyiwSnijwET6QAI4ZLJy7FeCS9zOW+XBXC9YpK27b28PAb40CCfxay8AeIWunR+lghfgFr1O+/wUvbG2ERC+idusvjRYpBcIVXtItLMU1CZ7R1uTDY/49WHiG2/lhyBwK3/mlv/L+7ffNJuE9CGhnRrC16+JbYfSDcJNg+Aaq2AU2JwGwUNiKkTY0CQ475AADhk/8njixIWvH/5lfXrNBQbs85B5837tbf0TvWZ7r9HeWHcKxC9PNNoh19cwjjDEbwKOdX5lxK/RuakNh2D1kvrAOfHNCdHobzpgjgibhazd/nTBXApNF4M2lSDcJsKlAirGypsLTKQXJIBDRsvSkJ0bi9o6TVyLP7Pc6gObfTvBExlWKZ550yVUlUNztncXy1yCWjLSa97vVE0iqIhvkh8vwjehvVuEVrjSA49fFeLXbdJbIhLpC9ypDw641v0VQHbyW5CLXxDpi+xkOCdfvFFgHhJTIaKApvkwCa45GscWFCSAQyYxAuwmD5ubvJU7M4tnvyayucHzs41sKgRPZNfJj2uUFxCK9Jr3i5RR80X4AnLpDgn+rSo8GGw5o76GY+HJ90307Yf4TYRn0puLgLXELvXBCZvoL1c02CX66yei6Q+EPbapCC61gMNENA1ChuSUC/lIrVsUmEg/SACHTLwKBM/kNdnHRDyyrLpWsJf8IxWpECqqQnCnTXgQveb9jvnGMmkOpnaBRH0TttuJZ+mUh4RtgYpfh9SLQ+PnEMYHEUp98GPiGwe8k9+CwF4gH/zXNAEunYgLWbPAjdJyyHF484D97DsuTkVItyiwlu3tGWzpM8OEPgngkIlHgOOT15wuapk0CCB52WQzbjcS5T+zcAhxb5Ui+ISu7Vgsbm5e84NViF6ndjyi1+zPq/A12NsJbcmUB6MdZ0TZKY0hcb+o+HWb9GbRXnXqg9TEN4XR3yimP9jl9aYCZqEb7lic84DN0Wd/xiA/Gc4uCiySz2yeEEdR4MyABHDIiE6C87rqm5V4DiMVgrdPlakQtm04BK9VW0+iF4iU8HXsgzfXN6Ff7qhvol8V4jcRP8VvIjy5uwpTH5xQGf31gl36Q6YTZkQ3zCWR3dIggsJLXeBEgR0FtGwNmvIIcDSOLShIAIdM4kIYftbwPVQRwp+fD8OsCiE6Mc5OSKgQvdY29sLX/FOa5zQHQCjVIWm7yqhvwnbelAeDrYz49Zr2kIjEpDdrGydhzCGeTXiK/grgR+3fIPJ/M11s21WCCKZv6/QIFSSlXDikQchEgQ8dg3UUOGq4L6Il5zOTIAEcMokRYD/TIOxEosyFrUqk815sslFgEaFr50u14I0Ny7vojfmxEaBO/lQI30Q/IvnGvFFfN/9W47D0LSiWeSO/DuKXK+9XQDyLRGe5osvmyKyEuPUj/cEt/1fKZ4rV8vVKEELXrR6wN9/OaRCWbbLEl0eWyQW2KotGpD4kgEPG/C2OJwrsJQ1CRSUIM0GkQ7j2ISh27XzyTopTKXrd2ssI36R2qoWvuW+nXN+YQbJvzqivnX+l4jcRkchvAlJ5vw42jtHRJFsLfxK5vyoitH6kP6iYABdmrnDQP/Wrwo9UBRVpEGIRXe9R4Cgimj7J6zOTIAEcNppmFALZB1dyc7hSZaPAsbbJK8Ul4hx9Vn9xcItnl0iQcBqETRt+UewseAFB0euWauExv9epPyXCN2G7q/BN2G4Z9U30pSLlwa2NU+Q3cb+D4LYUvzx5vzxVH0SitRzRWKnor83kNxFUpj+omAAXF9VRLSMWJHYT4byQPDmNv9qC7iPLfTKcXRTYqSSa1ygwkR6QAA4Zq2LWLH4VO8G8TYaL9RONCXExJzxRYDcRLCZ27dpw1xL2KnotfPDm9pp9R0H4msekLOUhcXvY4jcRkUlvhn3GMQhVfXDqwzLyLB/95UFJxDgi9YBTNVVCphawytSFpNxcCZ+HfBjTIFQhMja7ihBRw5elkGkSHBEksikQUl9DTVe+bwnvHr4ihzEpTqiesM+iN+bPXvjypjkk7XOYeKdc/LpEfY22EikPib68iN9EeMWvk3hVnfdrBUeer1D01wG70mc8eEl/UJH/64VUWR5ZRiSqqEKhooSbGrHskBvMEQXWbU1RYGdbigKnEySAQ8acx+PnRDhY3PhUzW4NMpdYNhLsnA8sJ3at+uPxpUz0xjZY73PKQ+acKOeb8E3sRybqm9iHVBuJyK+g+JXJ+zXAkaqQlDeccI2bo79O0WiR6K+IiDaPxUuqAo8A18WzAhEb1YiwSD1eFZFeL7m6XtIgzG2sjkEX0lnyyyNbjjsFosCUA+wdEsAhY1XKJMiJcH594L1El/lrBIunPDju4xS8Vn2rFr2ufXBGe2P9OOzzM93BtJ076pu4PaLi1wCP+E1EIPXBEidBywFPH0K1hyVSGDwJYpEUjYiKWBlERJiKRStUiGYRzGkQXlEdBdbHl2EiMZ0hARwyWpbxguIRtjL1ghMjvWHU+vMrt9g9Guyw3y5SzBHltfUtKnoB/tze2AZ7/y6VJ1SlOhjGKBv1tetLJuUhsV1A4leo4oPd+E3jsBKQshPfZHJ/HW0EJr/JpD94yR1WbZvUNuSUCJG0BTWR3thEOBFkIs0yaRAik+H4/PBHgaOGpvlQBzjkPPygIQEcMskpEAcfHo4pEO5pEsltDv1fpnqEDMFEgV3snKLEnNFd2354J9B5ifTGNjjvl8nvNfv1M+Ir2pebiE20cRPMie38FL9OE9I4fDALe0vxKzLxzbDNwWfcRmDhC7GUCQFbifxfkUoQ6RQRTkRmIlwcqVxiiTxgkTQIu5rAouM3R4EdbVMsCkwpEN4hARw2WVnJQoo7BUIuChzWai+yFxdXOwmhG/NtEwUWSZNQIHot/fgR7TX7tROj5n1+il8hEWsTlXaNFgcofhPxmvdr2OeQOmGVhsCRKsEjTnmiv+bav04IpUr4FH2V8Ru0ePYSzeXBS04vDzK5w6psMyUKTHiDBHDIaJqWLF6yszlmo0K4qKI51SIoPH2r5J0YJyFyY/v4ha6dPU9ag9U4vER6Y/1Kil7T+HgX1vA16pto7xb1TWzHFS22sPVT/Doch5UPx4iro1h2EK+S6RSqor88ecEiucO6CFcsQjOxBrBMSoVMpFeVf6fJcObUi3gahBVOUWC7usDGcRyaEBcFfCmD1hyRgwsIEsAhYzsJziWSwuJ3BBECmPzGhUQE2u186HaSE+NEBG9sPP6IXksb2UltVv5Fc3xjhtb9qRa+jn0pSnmwO4YgxW8CVoJTpOqDta/kcTvlF/NEf53gE7AckWFFOb1+5+yGnRMsi4gwFckDFon0yqRByMKTl+y8z31xDCK1Cee3cJ/429/+htGjR6OsrAyapuHFF1+0tb366quhaRrmzZtn2N7Q0IBrr70W7du3R2FhIcaMGYMtW7YYbHbs2IHx48ejuLgYxcXFGD9+PP73v/9JjTmex2N8ZTm+gEORY56XTjzdIuxX4vGLHgPgem7szqvjebBpd2icWYZXzI9mfFmMzewzoSODUEmyMY0t6VzYjNvSv3mMiccQ3286twcNjWIwDPFrPg7udsGIXwOWX4rsRbLjpDcLv06pD9zwRH8t93FEdOM2jnWIeQT1QT8cAownCs1DuuYGA5bfy23hjDMctOUXpyJj4LF1/rHE3kGWfg908O3wEY3ff6MQBbbWDt5fmURaCeDdu3fjRz/6EebPn+9o9+KLL+L9999HWVlZ0r4pU6bghRdewLJly/DOO+9g165dGDVqFJqamnSbSy65BOvWrcOKFSuwYsUKrFu3DuPHj5cbtJYsxrScbMcPaFZOtqtITnxlZWcjKztbSDQH8crKFjsOLSvr4LFzXMQOAtyxrUno6mLRLHY5Ba9+Q4kLuYMvSxte0WsnrBP7sBG9VuI96QuEnfCNb9eMx27oO9F3Qr/m7QZ72/4sRDNXOwvbuI25nZ2vg7hFfi1r/Zr8uIpfK3HpEOnVfbhUfZCO/upC1kHs8qQ4KE5/cLZRJIQjEN0VEZaOQk6RHzMiApXHL4+txaXJNZ4sEd8WRrrgTSulRMRJqxSIESNGYMSIEY4233zzDX71q1/htddew9lnn23YV1dXh0WLFuHpp5/G0KFDAQBLlixBeXk5Vq1aheHDh2Pjxo1YsWIF3nvvPfTt2xcA8Oijj6Jfv3747LPPcMwxx4gN2uJbF2t2SW8QLIMW9uQ3HqS+eXIcj5Nfx5IvNu24K0TwpDYAlhFxx/1mHw4pDjF/9vu5c3xN+4QjvuZx8UR9ZdolbneL+pptLGxVRH5d7ZxCWQnIVn2w8itabk0k+mu5T1H6g9corfr84cxC09xTKLI0gUlsWd7SIJzGI5sLfKh9LBfYbkxRwCp9UoXPTCKtBLAbzc3NGD9+PG688UYcf/zxSfvXrl2L/fv3Y9iwYfq2srIy9OzZE2vWrMHw4cNRXV2N4uJiXfwCwKmnnori4mKsWbPGVgA3NDSgoaFB/7u+vh6AKUIGgDFncesqjo0HHOsjFX/WELgQeY5PRuzGfHMK2dgOPls30Wtlo1D4xprbiEJz33bC1zwGFekODj7dRbONrZv4tRmHm/iVLXcW25bcN1fJswScJr4xK78WyOb+ykZbuXKOOcSFZyHsMbUiCjgtdMEjVOPwCFYefyLi2FF4au75xFbCWcS3c7/JFSEoFzh9ySgBfM899yAnJwfXXXed5f6amhrk5eWhTZs2hu0lJSWoqanRbTp06JDUtkOHDrqNFbNmzcIdd9yRvCPxZ2EAGrId70hadkwkc5GVHWi1B1WICnau4t2CItd1LLxiF1AjeK36DED0JrdziCiHIXzN22XyfU22whPeEn35KX45Ux+S9iX4Vhn9dSp9xid2HUS2pEiNQgqDFVG7DfNUguCZCMez4pxXAW2uCczdLst+YQyRihDGdofKooUN1QH2TsYI4LVr1+L3v/89/v73vwt/eGMXX+KD3urGyxz9Tps2DZWVlfrf9fX1KC8vT/oZgzU3Oyc1NTMuwRcXyan+gRZamYYnEiwjdmM7+dtYRY05RK+lP5WiN9bAeQw8qQ6mfpyqSYQifu2OyaP4NfrkFL8JiE56c9smmvpgsHPIwfUz+ivuk+NeZyWEOSK4PCXQuIR4REQ3z2IYqqO5nv04RFVF0il4+5XfF706wCSAvZMxAvjtt99GbW0tOnfurG9ramrCDTfcgHnz5uHLL79EaWkpGhsbsWPHDkMUuLa2Fv379wcAlJaW4rvvvkvy//3336OkpMS2//z8fOTn5ydtT6o24Ba1zQLXSm4aYqvFRS70IIrABali6WQhoQvYpmooE7xAoKI3qb3XiK/ZfxhRXzufdoLVz8hvQhu3SW+WfjgXvHCKNDtNfEvEa/TXCtn0B64cYQshmm6rw8mKQlV4FcfKUhUShLNT2oRfUWAiPcgYATx+/Hh9Yluc4cOHY/z48bjyyisBAL1790Zubi6qqqowduxYAMDWrVuxfv16zJ49GwDQr18/1NXV4YMPPsCPf/xjAMD777+Puro6XSQLoWnGBypHDjCP0NNFsspvdCJL9PiASIK+rNB1be9R8Fr65hC9sT4iKHzN4+ARr2a7dBS/CXCLX0MbTjHHHRnm3Oaw6pto9NeP9AdZsRq1CXRWeFnO2NW3ooitbHtVaRB+jyWVosAUAfZOWgngXbt24YsvvtD/3rRpE9atW4e2bduic+fOaNeuncE+NzcXpaWl+sS14uJiTJw4ETfccAPatWuHtm3bYurUqejVq5cunnv06IGzzjoLkyZNwsMPPwwA+PnPf45Ro0aJV4CA8UPMYouMWxtypjR4rfjgGF1WdHGomGnKfaFypFA4+hIRvDb2vFUilIjeWCPnMfktfM19RCnqa7L3Tfzq7Z2Frqe83wQso7XcIlpMqIqWPgt6Ip4sUUllCBqv4pgnD9ixf8k0CKfJcKK+RKPAIpl5RHRJKwH80UcfYfDgwfrf8ZzbCRMmYPHixVw+7rvvPuTk5GDs2LHYu3cvhgwZgsWLFyM7O1u3eeaZZ3Ddddfp1SLGjBnjWnvYFkNdVzhMM+Wb0KZlI/lqFUDLOnScfkygU/YNk/MOxNWfU16wU764xwoRXILXws5rpNfah40wNY+JN8fXPA7P6RI+il+bfF+/xK/opLdE3FIfrLBKfbBMkRCM/jotfOG0jTt32cEXTz+W9j6K3CimUngWpw4T4bwLZ3X7nLZZlUQ7lEoRS4Nw9XVQBEcpChxfNEu1z0wirQTwoEGDhD6cX375ZdK2goICPPDAA3jggQds27Vt2xZLliyRGWIS8YUO9HHbfaA5av/qF7nM11ML0RzoxeDhKzX3OF1uFqJi17F/u+NRJXpjDU1tBIWvlwl2MhFfJx9+C19TmyiKXwOceb+JCFd9SNxmEW0NI/orm/4gmv/rlGoQ5jLLQeJUCcJrOoTKSOyhfcniM6goMJGepJUATkkOPiCcxBeLZ/07Ibg4BmCK8EbsNx1p8c0zEc4lYiYsdmM7bHzZPWB8Er0WNo7RXqt+VQhfs23Uor5J9urErwEr8WvYb+Mrvs0l71d16oNo9NcK2aoMRvtg0x+iDk/ZsqDwI6qrohqEY98WUeBDfYtHgaOAlqUhK1vtWLSmaBxbUJAADhktS4OW45zeoAHuFbizs4V/mnFOuQgZyZ92uG9ObtFgiZJoXsRuzC2H4AW8pzhY9O+WayyV6mD245fwdRqfrPiV9Oca+U3c7iK6eZc6NuAiuFVHf53TGni3SUZjOQWhqmWSowpvSoC/++QW5hBPdUiuCewknq2juvaVKHijwFoafG4IEsDhE48A24gnXRg7Cbb4im+c4s8glFOkpovUt24fy6LF/AsIXht7adFrYecqei3GoEz4mm1l6gGb9ymK+gJpIn5tjsdxcQ3YiDyfor9WcOcIK6j+oFLQOo0nomGDSKE2FUGs/JtTSTRLe8EocBSgKhDeIQEcNlkakG2/+hvXpDbBFd/0j3hUo79WSAh1ZZUiHPyIiN1YV+oEr6U/N0ELQdFr1a/qiK95n6jwdfCtJOXBzqfBRwDi12LSm1uUVWbim9OkOYOdRfRXPCJsJY7F0h94838dBbbC3N6o5gnLClLRiXAq0yB4fR1aoY03qus9Chw25kW0VPnMJDLraCOILkayNOsXEHvw2b3ifg5+G3R6JRGvQJEKL/N5Ez1ejnPo+B4cfK/ML9u2erdZhleCs0Mvq/fDwc7an82xJJ4CuzHb+bAbH09/bn6s9iX55BC/ie0Txsc0LSXFbyIyk94M+92iyAomvrnhJfornjfMZy9aa1dpVNnnn86zEIxIE/1Bzsle3BdfA+u5yfZtsyyDBVY+uLrPKBYsWICKigoUFBSgd+/eePvttx3tV69ejd69e6OgoADdunXDwoULDfuff/559OnTB61bt0ZhYSFOPPFEPP300wabGTNmIF5EIP4qLS0VGjdFgCOAVRQxvpSxbfRRpOKD4mWRvZZHU/4zi+gdiaN/xyWYnSLCdt+g7W7aspHe2EbXcblGe638yEZ8zfsd/Ti0U5nrm9QmRPGbgF3fvJPejPv5I8KqUh9UTHSzwlKUe+jLLxGt24cY7fVa4szdv330VcV4VKRB8EZwxXONox8FjkoKxHPPPYcpU6ZgwYIFOO200/Dwww9jxIgR+PTTTw0r78bZtGkTRo4ciUmTJmHJkiV49913cc011+Dwww/H+eefDyBWaWv69Ok49thjkZeXh1deeQVXXnklOnTogOHDh+u+jj/+eKxatUr/O7FcLQ8kgMPGIlIHILaUsZPQzE4Qya64+BJEi3/GZJKh/Pr6LHDhOopbTn+OPxV5FLu2/mVyei1sLH2J5PeafQoJ6BQWvkl+1EZ+RSa9ec37dUp9SMRp4lvifvecZatt3sWpFwGYDhPgvCJaXUJUFIumSPCmQXgpicazPLJr/xQF1pk7dy4mTpyIq666CgAwb948vPbaa3jooYcwa9asJPuFCxeic+fOmDdvHoDY4mIfffQR5syZowvgQYMGGdr8v//3//Dkk0/inXfeMQjgnJwc4ahvIvQ2hoz5J3LDT9sSP8lz/0TP+3IevPiLB4/j5D4nHOfY7j1K6Cz5pfvOAm9ag7kfy3NsNWbTMTvZJPlyGrO5jdmv1T7HlAnTvsS2VufHrn9ekRol8ZuAUvFr8OviK9HW5bbPO/HNLTUiyPQHmT6E/UY0t9cNTROsDiR4mJbfrwV9uPyw4VtbUR9Zoo59hCcNUOYFAPX19YZXQ0OD5RgaGxuxdu1afVGwOMOGDcOaNWss21RXVyfZDx8+HB999BH279+fZM8Yw+uvv47PPvsMP/nJTwz7Pv/8c5SVlaGiogIXXXQR/vvf/3KfP4AiwOFjFgbMeSlj1tzsLkwTvsFyRTv1ri0iuqrTFSQROY4kOI/BdQKA281PMP3BPl2CL4rLFe21svES7bXa7+rPRnSabSWivoCTqOW181n8xqOkIuLXZtzSeb8uYlwm+muF6slvoqvMyWApwFUI5ghHmMUjufYT4bz06ZQGYT0O+R8zefvnjQKnM+Xl5Ya/b7/9dsyYMSPJbtu2bWhqakJJSYlhe0lJCWpqaix919TUWNofOHAA27ZtQ8eOHQEAdXV16NSpExoaGpCdnY0FCxbgzDPP1Nv07dsXTz31FI4++mh89913uOuuu9C/f39s2LAB7dq14zpOEsBhk6UlCwaH6gxcszSzDgplQVzTLsJGUowLzWyVFbkubYXELiAveK18WoYyXESvlW9VqQ4itg59BCJ8TW1cV1uzFc2C4tdCNLsJbx7x65b6YFnZwSX661QNwtDGSwUHiaiuVRvRCXC8hC12VQg0UXFpnZqQnAcsLHKzgkuDcO/j0Lb4/6MSBfazCsTXX3+NoqIifXt+fr5zO9M5idVqdngeWtibt7dq1Qrr1q3Drl278Prrr6OyshLdunXT0yNGjBih2/bq1Qv9+vVD9+7d8eSTT6KystJxvHFIAIdNYgSYYzlkV4HmEkG2bJJ4x4hIxJcH6Yuf9wbmISKsQvDGupAUvbHGFm0Fo71WNqqEr9neqR+vub5JdsFEfR19uojfRLj6d7OVSH1w2y8XEeaL/kYBaxGdOfgV+XQTm07bVE+G440CG9ukznNShqKiIoMAtqN9+/bIzs5OivbW1tYmRXnjlJaWWtrn5OQYIrdZWVk48sgjAQAnnngiNm7ciFmzZiXlB8cpLCxEr1698Pnnn7uOOw4J4JAxf4tzjNzyCD6ZyK/ib5GBInsj4jlmF9/uKRMKxK6dvazgtWqrZJJcwBHfpHYSUV8n/yGLX5HIb6I/u7zcRIHJW/M30VZkkpufEVy3baqjzKlMkOLViyj1ltbgXxQ4LoKtosBRIApVIPLy8tC7d29UVVXh3HPP1bdXVVXhnHPOsWzTr18/vPzyy4ZtK1euRJ8+fZCbm2vbF2PMNhcZABoaGrBx40YMGDCAe/wkgMMmPmFHL1Vm8wBzi/66RY/NJN4h0unbrIyY5zh+abELqBG8dn3Iil6rfqTyhRUJX/N+3jxf09/OduL+w478GnARv072VmNyncTmcl2oiv66+Yx6+oMqghifpRAUrAQRBLxpEG77VYnwKAnfOFFZCKOyshLjx49Hnz590K9fPzzyyCPYvHkzJk+eDACYNm0avvnmGzz11FMAgMmTJ2P+/PmorKzEpEmTUF1djUWLFmHp0qW6z1mzZqFPnz7o3r07GhsbsXz5cjz11FN46KGHdJupU6di9OjR6Ny5M2pra3HXXXehvr4eEyZM4B47CeCwiT8Q7B5GPMI40Y8TqpZADmIFOVUXtqC457oBuAkVUcFr18bOXqXotbLjSp3wKdXB1FZJ1Nfch4d8X6ftqsSvkooPLqkPYlUj1Ed/jfud++RFqg3nBDgv26yEVdQrSliLxOSJcF7ygFUJ1iBygc37iUOMGzcO27dvx5133omtW7eiZ8+eWL58Obp06QIA2Lp1KzZv3qzbV1RUYPny5bj++uvx4IMPoqysDPfff79eAg0Adu/ejWuuuQZbtmxBixYtcOyxx2LJkiUYN26cbrNlyxZcfPHF2LZtGw4//HCceuqpeO+99/R+edCY+ZNDBEJ9fT2Ki4vx3WMz0KpFnr0hz29DnPV4ZSbG2TsL4GOj6E4j/K3WTeACjrnSsotohCZ4efvwInqt7EMUvk7tuPNtgxK/HJFfHvErk/qQaOPWt60vvX3CfpY8RqtUBrv0hnh72/3x9gn9NFv5ZM5trP2ItU28hVvaMeP4DMdn0dbgz9VPsl0zM+6z951s12w1rni/FuMytrXo17LtwW3Nydvs27Dk/RbtLY8vYaPVGBNzgePb9+6ux10T26Kuro4rV1Ylce3w6c9/ilZ59ikDMuxs3I/jHnkxlOMKA4oARwA7wcSYS8kz3tXgXKLIzk1tRHPIX4M9/fTDI3DjcOREBSJ4AW+i187WLcXBysZH4Qu4CVpekSwnrqXq+wYU+U1Ehfg1+HMRv1x9u4zTer/EPUki/cHVZ8RSAKJOEHnAVlFcr3jJBTbvJ1IfEsBhY7XgRHO8JIiDMI63tSPxghURfKZockpNkBM5zkR46wRLpj4ccqBA8Dr58TPaa+XLT+Frbi8b9TX149TOS8qDk29P4ldAFNt9jtxKntkhK3Rdaxm7TEqTS6Nw3i+TXxvVChBeJo0l4kXE+omfaRAiPnnbhIWm+TAJLsOUPQngsIlPgkskG0lC1NCkmUPoCS2VnACP7ygjWyuYVzzLitxDHdn4dWinOspr158fotfKhjfVweJvJekOprZO0V1V+b7JvuTFr2XFB8HIL0/qg0g7N1sr/CjLZtjvFilWtABGKkSPrfJyg+5Plbg2RGclos6qosBE6kMCOGw0zfhg1eutWDwcBCO/PKIuSSSnUB1gXoRXkeM9B7JiFxAXvEB4oteqrUfhC/CnOiTZmvd76CeIfN/kfryLXy+I5P3a+hARuh6jvwZbjyJO1UQ5P/pRRRaYbxUleCfCyflWnwbhVxQ4CkSlCkQqQwI4bLKyjA9sx6s12/1O4xI9TnIZ9dXfVCEj7HmEs9vdUEboAmJi124cIkszu0V6rdp5Fb1WPhQJX7d+vEZ9k/pQme8rOenNHFFVkfcrUuHB1dZi4psdIikRbrZuYjATRLEMqoQtb0qD9zaH0iCk2lMUOOMgARw2iSkQrNletLiVO0u8sjknxenIRn3DuBmojFCLRIZ5vvb7UCvYsZ1q0WvXPmrC19yfbLqDyY9U1Ne8T1D8JiEpfs2ozvuVzwcW6M9rSoNNdQevvjIBmVrAMtFTXj8ibdz65C2JJrI/ClHgKCyEkeqQAA6bLOuHrI6e9iApjHU/kpPiEsdgJmoXi+wkOL095/H4WCvYsa3wZDmFoteqLYcA91X4mvoTivqafHmt8gDIiV/RtIeg8n7tkBbFAtFfQzsforeyuP2uJhUVzrCAoozwFEmDsJoMZ9zvHBmmKHBmQQI4bDTNJafXTUhx9uOpnkyK5QV5+XoukgPlReS6tVchdp36CFL0WvqJoPA19yOR8pDk00O+r9m33+JXdeqDbPTXPX2C//puVhhhliGKWsmPKK21sHSeeOdHGoSIrYgYV5UOohLKAfYOCeAoIDPhTbAGsJCws1qDMtWRvbB5o8p+VYcAwhe9VnYWvlxFrMU2L8LXrb2juDXv5436mvc5RUEFxa+ZqIlf1zJsiWO3mfimMvprZysiZFWmXaQLqsqsJSIjdkV8yqRB2PmyigIbfUXjPY9lT6pOgVDqLvKQAA4bTbN5CLpFFzkjujJlzdL5IpC5wlVVhQDkhK5TOxGxa+eHR/Da+PQl2mvVv6KIb9J+V1/qor5OfTtFXKMmfkUixYbjgI0PkSitgK1tO4+iNurLGPuNVSUI435v+bVuaRAGsWoZJeafDJfqUWDCGySAw8ZcBQKIXeluk92cxFZizi6PeEsuiujexgmZ+sO8+PEVVfRbtFehq/crIXid+vcqeu1sg4r2WvUvmFPMXd3Bqi+JqG9yn9ERv34gmvogG41VIVhFSoGpFLV+1CeWJdVFm8j4My0KTJPgvEMCOGwSI8CHMu2T7Xgmu/GIYyBZoIp+6N1+Hwv7dxSvF7Ho+L2KXTcfKgSvkx+V0V6LbYELXwt/KnJ9AbmUhyTbgMRvGKkPdvBEf8X8WbdTmf6QSBRWgIujMj3Ba2qC+35vecCyiEyGoyhw5kICOGxiiTwH/3C4zfLksHJPdPP4QONNvwgbrw9ukdxnrsoQLv6cxqsyPYJT8AJyKQ787ZxFr6UfLxPczH0KCHXeqK/ZD29E2llYy6c9JO3zOfXBz+ivbGRVOj9YoW065gqb8VtMi6RB2PlVGQUOHatfj1X4zCBIAIeNw4MUwKForVtKBOD84U286kWEndWdJewIr1dkJ/UJVYjwIHbd+lIheB36kI30Wrb1aUKdp4ivpb/gor7mfekufv2M/qpOf5DNK84EVEY/veYJq2gnm14h+/ggogcJ4CjgmPJgI2rchDHAL46t+o2j6mpXtaSQn4h+++Udjxex69ZPFEWvbduIC1+r/Skkfs2Iit8g4ZkEJytMRfsXaicQFRYRcH4tXSyCzGIYdqgUorLC220yXCKpmOagaRo0xc9E1f6iDgngsEnMAU7ETRRxZSEIpiowpv4nEN6FOmTw4+camXHyigg/hK5bO6+C12Z7kKI3ZhNN4Wv2JZKSwbu6WxCRX6d9fkR/ZeERy3a1f2VTGkTuopkSFXarBJGIWx6w0dZ7GoTIZDhX8Z2QBkFR4PSDBHDYGHKAwZ/ywJPuwCPMmGRqhHk8doSdU6TiTiUaJfM7H1hC8AIhil6bcQUifC388qY7WPtXG/V1beeT+DUTVupDGNHfRFT0I1u1IcpRRr9SCWTTDmRxmwxn118qRIFpIQzvkAAOm6QIsNsH0CUeIRLFbW72ls/LHMq1RRGvP/eqzAHW7TxEhUXFrlN/Ntt9F70W/nhErZ8RX2v/nMLXNBbuqK+5HezHr0L8hpX3aweP+BUtk+anoA5cLCsYs0gkVr4PfwSu3UQ2WfGtIgocNlQGzTskgMMmPpPTLVXArcQZT05wop9437xYTZ1N9clwcaRXiRO4WfCcKzd/KgWvwz6xSHFw0V4uG4mJebIVHpJtnYVxOohfr6iYBOeE6lzaxLtepi6AEUQ0VEUfImkQdqRaFJjwBgngqGAnbpyEceLV6fSQEk1zsLrqVfw0wl2mTQA/f7LxMx/Yg9gFHASv2xjCFL02PiMpfK3sOXN9zfvd+/FP/JrxKnLDSn0Qzf3lwbYvBUI3UXxlSl6wGVkRqkLIGv3xT4az9WGKAkcCLUv98y9dglqckAAOGaZptg8szS2dgUdQMibxoVYsVHnyllXhR0qGzE2BZxwc50O10HX0qaCihLToteiHx8Y11cHKxoPwTbJXFPWN2fKlWThOZPMY+XXaF8akN1kCqybhq2+l7pQgLSAT0i/kfbinMAilYNj4sIsCR74uMCEMCeCw0bRkgXAwYusojAHOiXASEV9Rwee29HEU84S9ftMVPSavYhfgyBcWiO66+QxJ9HLbhS18Lcbkd8qDm88wxC8vUYv+8mCX/hDUpLyoI1IJwt6Hfzm1RiHLPxmO13fo+JADHI0DCw4SwGGTWAWC8dX+dRXGgFjkmPeBZncDSbefTWQFO2eEm0tASIpdrj78Er02vv0UvpZjsbLxUfw6iUjXtiGKXzM84jepjYfUB7/gEtU+pj+IEkYNYNXCU3UOr5/5tzyR5ChNdiP8gwRwyCSmQGhOFSCYe8UGxpm6IFXqpDnFKj6oQDJlgztCxjUxzq9cYId2CmoHp4TotWjnJeorInxj9uIpD0n7knz6F/k19+c19SHK0V8/MBxjGosr1eKVZ2KanXhWk0OMSKZBaFoWNMXBJ9X+og4J4LBxmbyiHbryrNsbJrhx2Nj0Y9tvHC/5u35MfuPFh7xj4Z+AuSfG+ZgTDAhFeB37C0L02vQjk+pg2aeP6Q5u7Z2ivua2fohfM7yT4XjEr6NvBQtUuKEq+suT/mC3nSbAHcLXFIcssUeL3WQ4igJnLiSAo4DTQ8clqusYNZaFNUvl+ZnhylUOGBXHpSP6bZl3pr3XFAnJChOik+NsxVJURa9VuwCFb8xeLuXBvN9J/AqlTnDv4xO/olUfzHiJ/ma62JTFz3QDYz/WE+G8CE1RESyLOQocCbI09Tm7UTm2gCABHDaaliwE3MqbJUR0ufKB3YSXeRKbiLBzmACnVGwGiZefgQTaKkuVkBS8jmNQIHpt7VNB+FqMM6ior9m3U76vq62P4teMTK4vT+qDDEFNWiPUwpPK4CUNgicKnCrQSnDeIQEcNvGFMAB1i2HAWVwlpTfwijYrsZtJOUOSx6o2J1he7LqOJWjRa9NnkMLXsl2AUV83/6rErxkZ8ZvsQyLFQiL1QWX010v6QyaggWX8FwYe4R2ZKDDhCRLAIWOYBOdWucFVSHEIKMn0Bk2qnjAnbmXUZPBZmEtFt7lzgTl8exG6LmNRInjt7G1FNmdUWGJim5V/vyO+MXt54Wve7yXfV0XkFzCLR4f+Akh9cMKv6K+X/F+7CXDNHDa2/n0W57QqWrShpZC9QwI4bHgnwbmtFAe4R45N/dliIUhFBV9SlNnROPwospJ0DZnjUCB2AZ8EL6BG9Nr0Lyt6bfvn7EM04ms1hqhEfc32QYtfM9yC12Pqg1/RX8IdY4T0UC1gPysxOMGzKIZoGoRo+gWRmpAAjgIOeb6OohjwJoz1vjwshGETvU3Z/F87POUFC5wLFWIXUC54HdsJ5xFHU/ha2XgVvuaxiPqPuviVivB6TH1wbONRzIax+EUmwTMRzksecEahaeqDR+n23HaBBHDIMC0r6WGkudT85an3y53MLlvf1y0fOZ2RvUkITDBQslgGfBC7Tu1EBK+Nve+iF/Al4htrE07Kg+j+IMQvbxqDTLqEXfTX0bdCMcuT/hA0GS8GOVAZBSbSAxLAYZNYBeLg1Wb1QNYE6/1yVYcA+ESZ1fRYr3eBsO/YftzFJGbQqpwg5yhaAddjjpLotR1P2MLXyo9C4WvZXpG4dW/rr/g1I5MuwbvohUxahMqZCDz5v36RKguDqIQnDSLdoBxg76RV+O5vf/sbRo8ejbKyMmiahhdffFHft3//ftx8883o1asXCgsLUVZWhssvvxzffvutwUdDQwOuvfZatG/fHoWFhRgzZgy2bNlisNmxYwfGjx+P4uJiFBcXY/z48fjf//4nNWaGhAhwXAxbvOKRYrtXrH2W6ys+6Y73BeBQpQovLzMOxxrIywqFxyh0fnneO92vy2fA6dwaxifY3m6cNsfrag9Nf9mNydKHRX9W7S2PxWRnOB82YzFg9oMsmFdzsxqPXR9xG+Pfmq29mz+hCHNSW//FL28Uljf1gdtOIvobRL6w3QQ4laSb+EvUZ35FYrNMt48g+yaCJa0E8O7du/GjH/0I8+fPT9q3Z88e/P3vf8ett96Kv//973j++efx73//G2PGjDHYTZkyBS+88AKWLVuGd955B7t27cKoUaPQ1NSk21xyySVYt24dVqxYgRUrVmDdunUYP368p7E7ChJAStDYRtA4hNYhv4Ji2Q4VItrvl+t75PFcCJz3WH8876e7uBf+bDmN2eZ82LZJtLcQvYnj4/Jh0R+PWLWzUyF84+My92Xux2ksSeJZYcqDeX/yPjnxa0Zm0pv5b5nUB5Fx2I1JJvrrV/qDX6I16pP97ASmSrFp7ENL+L+6PgIjpOdgOpFWKRAjRozAiBEjLPcVFxejqqrKsO2BBx7Aj3/8Y2zevBmdO3dGXV0dFi1ahKeffhpDhw4FACxZsgTl5eVYtWoVhg8fjo0bN2LFihV477330LdvXwDAo48+in79+uGzzz7DMcccIzZoK9HhkAoB4FA6hN1Vm3AHdftZXJNZBCOgiW9ClSRsCGwyHs95s8A1bcHQh/uxcPlz8+PgQ3jhDJH0Bhs/dn3ypCfY2cmkOsTaiQlfnr78zPc17xcRv2aEor0SUdykfZypD0FFf3nxq/RauizLazcRzitBpEFEaXlkTdMMIl6Vz0wirQSwKHV1ddA0Da1btwYArF27Fvv378ewYcN0m7KyMvTs2RNr1qzB8OHDUV1djeLiYl38AsCpp56K4uJirFmzxlYANzQ0oKGhQf+7vr4+9h9NMz70mcukNMYcRY7m1l7Al71/xd8Sw6okofo4DiJ6TnUEjtdvoRvrw6G9j4LXrm+RKhQ8QtTWZ5IgdRflURe+1vvlI7+y4le1aOad+JbkQyL661lMK40SR1+oJApPv4SjSnFrGK+NmCbSi4wVwPv27cMtt9yCSy65BEVFRQCAmpoa5OXloU2bNgbbkpIS1NTU6DYdOnRI8tehQwfdxopZs2bhjjvuSNoe/+lTc6qqwFxKmnFGfJOjvS43UYurXkowuxpF/2cXaVGbiISg5+6Xx7cPgheQEL02/rxGeu1s/RS+Vr54osuZIH7NyO5TkfogI1h5kRF2YU9Ui0oUUwYZMW0nxhOrQYj0Hwk0H1IWUuBZrJKMFMD79+/HRRddhObmZixYsMDVnjFmyheyeAiabMxMmzYNlZWV+t/19fUoLy8/1N6iraMoBg4JY5eI8aE+RNMh+CPJtrsy5YLyEK1WnQYRs+PLaZZtr0r02o3Da7QXkBe+sbbO0VorXzz9uQlfHr+pIn5l835Vpz6I7DPYBZT+4DWaG6XopF8RWRm/XsdCUeD0J+ME8P79+zF27Fhs2rQJb7zxhh79BYDS0lI0NjZix44dhihwbW0t+vfvr9t89913SX6///57lJSU2Pabn5+P/Pz85B12k6BclizmWpo4iHQIIJgZBF7vPgHnNgWRBuFZ5HL6cYysKRK8jr5CEr2xtpkhfGP20RK/ZnhTH5zambFb+CLJh8f0B15SUWQlrgbn3ZfH6G6WddVO5/bWNYGjDpVB806GhOdixMXv559/jlWrVqFdu3aG/b1790Zubq5hstzWrVuxfv16XQD369cPdXV1+OCDD3Sb999/H3V1dbqNCHYz490qBXBVH7DyYSe4raoJOFQWiI3BuTQbd2UKHtzGJzF+XpQeo8w4Od9D6WoUZj8Jn0m76gWulRscPq92/mzPk4W93XjdbC192lR1cKs2wdsnT7oDj183H877oyd+zZjHJJv6oCL3l1fk8oo1GVGlcjJdlAkqNpHYj4zO89qeiB5pFQHetWsXvvjiC/3vTZs2Yd26dWjbti3KyspwwQUX4O9//zteeeUVNDU16Tm7bdu2RV5eHoqLizFx4kTccMMNaNeuHdq2bYupU6eiV69eelWIHj164KyzzsKkSZPw8MMPAwB+/vOfY9SoUeIVIGB6+Dnky2rgi/i6Rfxc0yps/Hq6S5nu/mmRFqHiri1xHpQunOHygHV9n5zyghVEeZ3shVIwFEZ77fp2E71W7aQmzgnutxqLk/h1FbcKxa9TRNdJ/IqkN8hMinPaxyvEnfzJ1P/lFdoyucVhRDwTK0HIwBsp9po6IRNRDgy7YJZXnxlEWgngjz76CIMHD9b/jufcTpgwATNmzMBLL70EADjxxBMN7d58800MGjQIAHDfffchJycHY8eOxd69ezFkyBAsXrwY2dnZuv0zzzyD6667Tq8WMWbMGMvaw6KYH2aJObl2N14NCVe3W64w3AWUZekx3ovCTsAHnH4QCTzcSISqX3D2wxNN8kPwOvqVaMOd4mDj32/ha+VPRboDj41b1Bcwizn+qC/X35Il1MyI5P3KpkUEGf1VTSpUgPADXjHrNQ1CxRiI1CCtBPCgQYMcP8Q8H/CCggI88MADeOCBB2xt2rZtiyVLlkiNMQmrb3EHhaTdg12ZME7oS/+TQ3zZ1ueVFX08lSLCwodvxFLl3QTGwZ2j6EHwxtqHJ3pt7e0iySEIX6u2KoQtj43KlAeuvyXLnZnbmsWvisoOVuNTsY93LLyCKd2Fldf8XtV2vOOJbBQ4S1Ofi5FhuR1pJYBTEXOuoevkNtbsKFzi4pjn4cCVVmHqG5AUcIn9mu9UKfazi9L6xDJpECIPfh7/HoSuax9+C16HPnhFr51vPyO+VnZ+CF8gWPHrpa2b+HXsJ4Dor4rJb7wpCvx9ye3zip+RUNU1g/nFcWpNhtO0LGiKn52q/UUdEsAhw5M7aBCMVh9QQ4qDuzjWbV1usoYosl3fdjhEdQNbnS1MPN5IRCfA8NcL5sgN9iJ4AaWi17E/zhSHmA//ha9VW+kcYqnIcbji13V8XtpK5v2KtuXdp2Lym+r830zDSSjzRm1losCZ8PjKFEgARwCrh5vmkrfrKoqBJBEqIo4BgSiy5Q6P3ySjkBbh47dh2RneYjWDOfODQxC8gDrRG/PlLdprNx5Z4WvV1t/IsFjKg2U/CtMeXPtymPSW1FagH7e2fkR/VVRr8DvaGFbesOoUhiCJ4pgMUAqEZ0gAh41V+SuO5Y65JrMJTF6TrQGs4uZvKaIj/FOM6vJE8qXhBPKCOcIWfOkS8mLZb8Eb8xMt0ctrJy+O3aOdQeb7yrR3Sn0Qje6KpD6IpFQY/EhGdVWs/ua3kI166TUnUapCbItMhiNSHxLAYZNQBs1xYQmOFd3cosaH7ARTG6yiwwLiy2055KjfdGVRUu5N0IdIekkkBa9Ln36lONja+ix8ee1kor6xdqkrfs0Ij0XB5DbRMRn7cPApkP7BS9jLK/uFk2BVUQ4tVSfDaVlZ0BQvhazaX9TJrKONIIZoh+awqALHAgq8izPYLaJhu4hCvFKFyCvxGF3Gla4vSzydR4H3TODzwLMwh+tnClrSy2ksxnNi3WfMb5bhZXcu3PrhGZeVb+NYOBe+kLRzGrfRl+mYmWaZ8mCu72uuzBB18etl0puX1Aenfv2I/joJZef+7Pc5EZWcYk3zdyBOWo43TkCRXj4WLFiAiooKFBQUoHfv3nj77bcd7VevXo3evXujoKAA3bp1w8KFCw37n3/+efTp0wetW7dGYWEhTjzxRDz99NOe+zVDAjgCiIoHS3HlImDs/DiJNVHBZRyPhGi2E41RxIfjkz3XYgLc+TNi5zNpv8Pnlae9U/9Wgjfm0/5cuI2Tx97Wt8/CN25n1a/b+NyEr6Ufq/MRYfHrhqj4DSQyHLLIDLt/r8imoqoQrJqDk0gFSN2CYrIvQZ577jlMmTIF06dPx8cff4wBAwZgxIgR2Lx5s6X9pk2bMHLkSAwYMAAff/wxfv3rX+O6667Dn//8Z92mbdu2mD59Oqqrq/GPf/wDV155Ja688kq89tpr0v1ankLGk/BCKKe+vh7FxcX4z3uvo9Vhhfp2p3QB2wlniTa8k8ck3nZu37btM++jpqLiha2YdUJxKgTPz7KOfiTSGmI+nYW/tT97US/SRxipDvZ27gJRxUQ3S5uQxa/K6K9IW7for2OussnWafW3RFunPsX6MI01sdxc0j7e/u3bNTOnvq39mceVdDzcfTvsa7bf59wfs7drBvbtqcctF7VGXV0dioqKECRx7bB1/s0oapGv1vfeBnT81T1Cx9W3b1+cfPLJeOihh/RtPXr0wE9/+lPMmjUryf7mm2/GSy+9hI0bN+rbJk+ejE8++QTV1dW2/Zx88sk4++yz8Zvf/EaqXysoBzhsNBgSlOwe0hprdhUhGpwnzyX6Evqm5zI2177ibuj3JACSgjYRwfMo0p9noQu4ji8owevYxqPoFbENWvjyiFqrbTxR2EwRv2acxK8ZJ2HqZuvUpxPpmv/Lg+q6wWac8odDJUtTH5I+GHqvr683bM7Pz0d+frLYbmxsxNq1a3HLLbcYtg8bNgxr1qyx7KK6ulpfRTfO8OHDsWjRIuzfvx+5ubmGfYwxvPHGG/jss89wzz33SPdrBQngqGD1QHaZ+MZb19ccOXYSMJZRXh7BZXOH8CL2vEac/cazkLVD8ouC6HiUiF3Ak+CN9SEuYGN+/Yv02vnxaisrfAErAcfpy4eoL4/fKIlfN1SWWlNl6+xHxFa9AI+kILTAaeKak7B1qgYRmTQIyZQFV58AysvLDZtvv/12zJgxI8l827ZtaGpqQklJiWF7SUkJampqLLuoqamxtD9w4AC2bduGjh07AgDq6urQqVMnNDQ0IDs7GwsWLMCZZ54p3a8VJIBDxpyzpyXetiVEMcAvjGP98YtjK9+HdohHlF3NUikn2A1FNyqZcyL0MA9Z8LqNQVT0OvWXqsI31pbEr3N/cNwvck2IRH+T2opce46R4tSJ8DoJS6dorbMg9V90y44tHfn6668NKRBW0d9EzHnTjDHHXGore/P2Vq1aYd26ddi1axdef/11VFZWolu3bhg0aJB0v2ZIAIdM4sQWjTFH8aCBI3XBpYaw7kuwjm9cKMuKUoNwplQIAN4FvsiDWKpPjvcpDLHr2k6B4BW19y6Q1Qlf6RQIBSkPVn6iLn5VLughUvrMr/SHTBJqVgQhpKMQm/GzDFpRURFXDnD79u2RnZ2dFHWtra1Nis7GKS0ttbTPyclBu3bt9G1ZWVk48sgjAQAnnngiNm7ciFmzZmHQoEFS/VoRgbeRiONa1spUEspSfHDO7BSuCIHkShVulQB4+3N7RRk/j8uP820J72eG4/PnVrlCpLqEU1unfu182vnzYu/V1q6yA291B6kIr1U7CxGYiuJXFDf/XnJLVUV/k2y9jCnDxbEZp+/nIpHETCUvLw+9e/dGVVWVYXtVVRX69+9v2aZfv35J9itXrkSfPn2S8n8TYYyhoaFBul8rKAIcMk7CxG3FN7eIMZCQUiGQxysiOg2T3BRMxLCqdBF1EWyHivNh8Cd7HkQnzXF8L1axshyPiJfpX2pSXIDR3pituoivl20yUV8eP1biL4ycXy/RXbfUB7+iv25tRVBV1i1qmCO5TukLIgtYpFQahOZD6VAJf5WVlRg/fjz69OmDfv364ZFHHsHmzZsxefJkAMC0adPwzTff4KmnngIQq/gwf/58VFZWYtKkSaiursaiRYuwdOlS3eesWbPQp08fdO/eHY2NjVi+fDmeeuopQ8UHt355IAEcMuZIS6IAdJv4ZicCEsuNuaZUGDa43AAtrn5ZsWzbRQrdhFUSdGUIgE/o6rYKBG+sT3FxyjMGv0WvqH3Uha99v6khfnnwO3ps9GX820tVhlSP0qoSiX5Vd4ickE1xxo0bh+3bt+POO+/E1q1b0bNnTyxfvhxdunQBAGzdutVQm7eiogLLly/H9ddfjwcffBBlZWW4//77cf755+s2u3fvxjXXXIMtW7agRYsWOPbYY7FkyRKMGzeOu18eqA5wSMRr+f3ro3dRVNjS1k5l7V+ROrxJ4pgXHz9OGVsVApCvDCGY5cRbqo73WL1Eed3GI50jHGHhG/MRvPiVnkAXgPjlsVGd9+s1+pucl6vZ2rr27dCXW/5v0nlyqq3rMA6nOrwxW4fjc6y363IehcZgv1+2HnBsf3JN4L176nHz2HDrANc8ehuKWhao9b1nH0on3RnKcYUBRYAjgGztX96JafqENw5xExfJIsLJtXKFKD6UVAsdxflkosJWb+dTDWGeCJ1fYtfNt6jglWnDO7ENUB/xFbGVEb5W26yOwS3fl6d/rvGlsPgVxUvqhJlUjyz7hUhEmKLH6QUJ4JAxT4IxpC+4pUDYPAy91P11E0hWUWRpsWxrlJlpEIC8sDX4kEmHEPhyoULsxmxcRK0PotepnbrIsDfha+fb73QHq228vmSWNg5C/EYN0eivt76ifS4AQNMY9zi9iE9VecBRQtOyoCkOCqn2F3VIAIeM1axwM26iOGYjLoyd/Jl9Oo0vuZ393cOLwJNOywgBFULW1reHLwh+LJbB69dPwevWXlTEyrSJovC1718yEqwg5YHXxr1v5/08/UQ5+mvGvS9lXaWEAPSCWNTXuChGZOIzWZq+cptSnxkECeAI4CZY3SpBxGzchSyvmJGp+at6yWOvkeYoo3pJaC+pIULll3jTIbjqB/sndt3aq02J4BedMT8CecMRFr6AmpQHWZtUFL9ec3/9JBUnH4tUghD1RWQGJIBDxlwGzS2Sm5ze4Bwxjvdhh2WU1+Vm6LVUGVc1iMh8zQ6XMBbLEOmXe9KcihxhyUlvsm2d2/gT7bXbrlr4Cm2TiPpatUsl8ZtuOE0Q8+47mvdqTykTqZAGEZEyaKkMCeCQYThUBk2D8ypubpPiDvngT1PgFTpe6v2KLrcsS5hVIoKcoOc1WiOcBiHwZURZfrBP+b+ybUUjvTFf3qK9dtt5I7RC7X2M+lrZydoEJX6jFv0VTX/wM3qcqpFSkTxgM5FNgyA8QQI4QphvijzCMWkSG/fEOPe0Cre+3cbiNiZHXxZRZjdStUqE6p8fZc+DcIUIlfnBEUyJiLXznuLg1IdX4Ws3Fr+Fr0jbKIlfHryK33QjVQWvGymf9mCzYqdnnxkECeCQYfCaAuE+Kc7Ol5W/mE+XKLPHMmW0IIYcKgS+VIUIP/KEI50S4bAvBYWviF+V4lelQFYlfr3m/fIQdvRXlExLB7FDZU4xkRqQAA6ZeAoEz8Qz3hQINz9xX/H+eTCuUCeYAiGQkyxLVBfJCCIq7TVfWvTLRigl03yMEMsI3phP/0Sv3XaRVAdbHyFEfa3sZPJ9Zf1Y2bmJXyu8pj4EgdPiF7H9AQ5GENGobJBRXHMaROhkZcVeqn1mECSAI4JstFc+BULtxDirPg715U0w85Cq6Q92qJwE6PdEONF+wha8sfZqRa9Tn8q2BxTxBYJPebCy4xG/VsiIXx4/KlIfVEd/CSMUtSVEIAEcMrGFMKKWAsEXPU5qJxFNtvTjQx6SjKjmJcyKFUFPiBPtMyopEbH24YtemTZeha/d9jCivrx2vOJXRdoDjx+e24do6oMKohSQjCJJaQ0eJsJFDqoC4RkSwCHDmwLBm7IQTAqE2EXCK8Zl4J0sF6Wyan7nNwddOi2aKREu+10iiVEUvXb2KnxHRfjGxpKMX2kPVjY84ldF6oMf0V/R9Af3iLTz36mOWSC75QFHKg2CFsLwDAngiOAW7fUS6VWyAhyn8LbCq2B2IlMmy6lM8UjHlIiYn+BFr9M+qTYREL62/WWg+LVCZrU3PyaaRUGHmWsAuwlm0cU+kgVoNI6bSA9IAIdMLAXCeBPQa/Q6PEB5J825+TH7c/Np5Z+3D7d+RfsnYqj4EuB3KoRIH2GLXbcxKBfDCia2OW5PE+HrpV9Z8SsXhXXux7qN/9HfVIDErQCa5kMKRGYElOKQAA4ZxjQwpkHTnKssJFVSUJgfbOfPybeTf7e+RPoVGU+q42c0O6jlkkX74o8SiwuA5L6CFb1O+5xzjqMrfEVs/Ra/vOPzU/z6kfrAg4xQDCInmSBSCRLAEcF8E0wUxIC8KAa8V4Bw8m3XB09fvH3LjCcTSLW0CJViF/AueN3G5Ms+wWiv0z5Rcc2b52vnww+R7OdkN4BP/FohM+nN0kYi9UFF9FeGVCqX5ic8ecCRgBbC8AwJ4NDJMjyotYOPBKcbWlwc8y5YIZICIStYZQRUUEskG/oMuF5wWOkcqZAWoUroxvpVMHHOw/5UEr2ifqIkfEXsVEV+Ab68Xz9SH6zbOPsA/BGz6SKIzZUgKK84cyEBHDJJN2SLB7lmelxY3fDMEWPAXmBYLnXMkW+c7F+uXBpPn6Jj4SVV84t9KaEUaFqEgDAOSPDy2KgWvU7tVKZS+CV8VdhmqviVSX3wq+6vivuJeQKcH6RiHnNg0EIYniEBHAFcK0BIimJATBgD4uI4Npbg0h8o9cEdVSJf5lyLlpvj/ek2CoLXbb+M6JXd56fwtbP3I+prZ+u3+LUeR/I2mUlvVsikPvjZl4o2ZqIaRfUjwhuZNAjCEySAQ4ZB02/ORtFrI2jjqQougoAnlUK3dZmAZ9mGuY/VfmzBVH6I6vLIZoKKSqtJi5AQxQKRIh6hG7PzLnZ5bFz3R1j0ivryUyRHJepr649T/PKkLHBNwpMqtybnRy41w/lvHqIqiGWI5ApzlAPsGRLAEYKrsgPvRDcbIWGOHAPON1GrCDLgLoScVl4LKvUhVdMdRFAdEfeyYIjoRBxesRuzDUbw8tgEKXqd+hON9jr58hrxtbMXWc44HcWvFerKrfGdBzeCEnaRE5AOUF5wZkACOGQSI8CJHIr0OohTjohxsh1H6bKEx5aIqJGJJCf5sLnrUOqDOKpWv5OdYS4icGP2IpHi8MUuV/uARK+TPxVCVtQ+qHQHINrilyfvV1Xqg6p2fGkW0b0fRzJa6we0FLJnSACHTFwA80R65aPBfOL4kL1DmTTbR5t4uoWlDw+izSnqnMr4vYyz1xJKokI31kat2OW1k43QifjwY+Kc39FelfZhRn2FfAYsfq2QzzuW7M+vSXVSQjs6IjolI76aD5PgSAATYRCE4LUWu+rE8aF23kSy7sdFLCf5zrD8JSdUP1xkRG6snWhaREjCOCTR69S3TLTXyV8YwtfO3mtusshEN5Xi19I/7/gkqz74Gf1VNTmPIFIREsAhE18JLhG9zq/y9AeOCK2gvblNrJ24WBLNTVaFqMhWSZgREFlBa/QhmxqhXuSK2HoVuzw2qiO9Xnymu/C1s1UtfL1EflWmPvgZ/VWV/uCXaA5TjEcutYImwXmGBHDI8N64k1aG8y39QczerY1b20M+1IhmUaL0M5wsKsSstV/5cyPT1jdhLBnFU7rfZQwqc3vdxhOG8LXzL2Ibpvjl7deL+FWZ+pCKpdko0kwEDQngCMAjOnkrNYgIWL8iwrJ98fo65DOz8pVkUV4pIoDIr2gbsVJrAQhiHwSvm1+VotepTZSFr53vqEd+ZVMfeMWvquhvumBeDc6KyOcF0yQ4z5AADhlzFQipyXCci2Coju46RXVl0ye8+PLSR9QJqgqGin78jv4C3qJ0snZ+il43/+kifO3sRSo82NnbjiNNxK/KX6tkf8oPM/2BIFRDAjhimG+uvGkKlnYiq8OFlvogH1XmJSjxGFWiEgGWbas6ustrp2LyXJREr2w7P4Wvk70fE92AYMQvL17Er9/RX3/Ls2X2PVkJlAPsGRLAIWOOAMdRWQc4yVawXFkYqQ+i+cl+4Vf0OEqiXNVYpFMjhBfQCEkQS87iF+kn6qLXqU1UhG9su4Vfj+I5SpFfL+LXz+ivdTvZ/uTaEQQvJIBDhiFWBYInXSHQcmecOcci/Tj1J+NHxq8oURKqPPg5Xq++ZaI+Ua8YwTVxySfR66VtqghfKf8eJ7upFr9RRzb6y+sraPwUzpGqBJHlQx1g1f4iDgngiCBb+UFE7IqmMtjae1zwwq+0h1QTq1FB5XmTXzXOvyiwiL2KKC9Pf15KsfkhmFUKX5k2fkV9geDErx3pEP21QqXYjYJwTjWYpimvfZ9ptfRJAIdMMzTDzTCLM1WBp1YwEE4dYEBcCNkJZr9EbapOjAta5KuIaAVVNUIoAsx5XCrELk9/YUSJZUSvU39RivgC3lMe7MYiEvmNuvjljf6qTH9IxSg5kZ6kVbz7b3/7G0aPHo2ysjJomoYXX3zRsJ8xhhkzZqCsrAwtWrTAoEGDsGHDBoNNQ0MDrr32WrRv3x6FhYUYM2YMtmzZYrDZsWMHxo8fj+LiYhQXF2P8+PH43//+p+QY4oI48WVFfAGNxJel3cEcY6uXCnu3Nm5tnY7H7eUFnjFH8aUCP86xp/deop2wPedxcV17PNeR4LXp5kNl22Y4T2xzG69oGyvCEL+259JGQKaq+A0ClWkTUe4z0mjaoVJoyl6Z9eUkrQTw7t278aMf/Qjz58+33D979mzMnTsX8+fPx4cffojS0lKceeaZ2Llzp24zZcoUvPDCC1i2bBneeecd7Nq1C6NGjUJTU5Nuc8kll2DdunVYsWIFVqxYgXXr1mH8+PFSY+Z5+FuJYqsHtKiYERVbXoSaH4JPRjSreqkgqmNX+T7JtpVqI3DMPNeT3Th4+uY5JlEfXto2w174eu2Tt00zO/Sya8PdB7MXmCJVHkSipyIT3sIUv/zCnW+bbPSXF+s+fe3SkgzTfgTSLAVixIgRGDFihOU+xhjmzZuH6dOn47zzzgMAPPnkkygpKcGzzz6Lq6++GnV1dVi0aBGefvppDB06FACwZMkSlJeXY9WqVRg+fDg2btyIFStW4L333kPfvn0BAI8++ij69euHzz77DMccc4xl/w0NDWhoaND/rq+vPziu2A1edqU3uyhVFpLvIE7iR7Q0mtVYRNq6tRfxI+vbC6pEsJ/Inrsg/cv4kDn3PKkMAP94eL9IePXD8yXQCdVpDk7tnNpEKd3ByQ+veLTzLRaR5vMpQhDil7+tlV3075spAy2E4ZmMOdpNmzahpqYGw4YN07fl5+dj4MCBWLNmDQBg7dq12L9/v8GmrKwMPXv21G2qq6tRXFysi18AOPXUU1FcXKzbWDFr1iw9ZaK4uBjl5eWG/byROt6IFG+Ey6l/t4ihl+gtT3sRX158p+tLFtX+PX1GBCPYwp97zvHIXBM8vmR8uLWXjfYm9u3Ur0gb0YhvvB/r7Zab0178Rin1gSDSibSKADtRU1MDACgpKTFsLykpwVdffaXb5OXloU2bNkk28fY1NTXo0KFDkv8OHTroNlZMmzYNlZWV+t/19fUoLy8Hg/HGq0FsEhxgfeM22Cb45ImEmaPHvN/aRVaes/UB6zu7F0En018q4de58bs/2WgQbzTX0JeIYOccF6+A9+rHS5TXrb2Xvp1Er2gbx35CEL6AP/m+drYqxC+vgA8i+hsEmf4lgKpAeCdjBHAczfQGM8aStpkx21jZu/nJz89Hfn6+6/isbmJWIs3uhimSymAn/pwEhlVqhduYDH06lEcD1IpmHoIWj1HFj/Pg9edOv4UuIDbGoAQvjx830evmwy1CLdMuqsLXyZfXqK+d71QSv37gaYGQCIlsIr3JGAFcWloKIBbB7dixo769trZWjwqXlpaisbERO3bsMESBa2tr0b9/f93mu+++S/L//fffJ0WXebD6WVE2HzjuL8lOosSYjDgGnAUyIB9NdvSpSLylYjQ4LAGvKpdPRuQCcsetWuyK+A1C9HodR5DC16k/J7ETRtRX1H9Uxa8dXqK/UYP3vDVbXEypcHwGKAfYMxlztBUVFSgtLUVVVZW+rbGxEatXr9bFbe/evZGbm2uw2bp1K9avX6/b9OvXD3V1dfjggw90m/fffx91dXW6jQhWuXC8+bi8uZVO/nhmcovkcDpVrFCVkyzyEiHsnF2Zlwx+n1cl77/kcYuOWcS/l2uHx5eZZtPLbUw8xyfS3vE656joINyfS2UH0dJmouXN7KKWomO1Igri14+qD14mv6Wc4DxIVlR+NNQ0f14ZRFpFgHft2oUvvvhC/3vTpk1Yt24d2rZti86dO2PKlCmYOXMmjjrqKBx11FGYOXMmWrZsiUsuuQQAUFxcjIkTJ+KGG25Au3bt0LZtW0ydOhW9evXSq0L06NEDZ511FiZNmoSHH34YAPDzn/8co0aNsq0AwYOX1AcVaQ+8+ca8/bj1F0c0AugWYTajKlIpgkj0Ok4Y4xRFNlprh5fotcz58is9gtcvjz+vqQ084/HSXnW0N7bP3qff6Q6AmqgvEA3xa4dXsRlU7i+lPxBBklYC+KOPPsLgwYP1v+OTziZMmIDFixfjpptuwt69e3HNNddgx44d6Nu3L1auXIlWrVrpbe677z7k5ORg7Nix2Lt3L4YMGYLFixcjOztbt3nmmWdw3XXX6dUixowZY1t72A1zhIF3cluisHR7oIlMmDP75vFv1xdvf279J6JahAHiotqNqIhZP86VE6rSMWTPn99pESJ9qBK7PL68ple4tY+K6HXy6eQvSsLXyb8K8Svkw4fUh6BKn5EoBpCVFXup9plBaIzRRykM6uvrUVxcjNc/3IzDDitytOWNKLpFW2X9eu1HRZ+OPhULWOIQfuQYe30gekn98KsfXt8qIryAd9HL4yMVhK+TT5lINolfPlvb8+Ex/cFL1QqR9rw5wHb97N5djxsvKEZdXR2Kipyf36qJa4etrz2FosKWan3v3oOOwy8P5bjCIK0iwKkIg/GhaPX9K53SHrxEk2XHw91fmglpP8Sra5+Koj3pkh6hKsoLhC963dpHRfgC6qK+Tv1EXfzaIRLyCjL66zX9IYzV48KEyqB5hwRwyJhvEE4PzERxHJW0B5kV5Nz6Fh2Do+8QqkmkMn6nb6g4x0GlSIj2EzWxy+vHL9Eb2+/QbwQivk59hSF8Hf0Ii3p+3yKpD16XLvYjH9mvvoj0hgRwBOCN8Fo9YO0yduxuuipLojn149Yfb98iY7H07aOg8yOdg5eo5BnHUfnlIYwUCb/ErojvVBG9buNwEx2pKnyBzBG/doiJT2/RX8IFKoPmGRLAIeNUcskMrygGxIWxnX8gmJQHv9Md/EhviJoIVYXfkXAV5y3IFAkRsSviX+WEurBFb2y/Q98+CWqVeb5OfTmLdrF+whC/dojk/dr74LeNQvTWKv+XyExIAEcAFdUezAKS5xo3i2SeB63XlAc/0h1UR5kJPnyZ3R1iioRfQhdQK3Z5/fEIk3QTvUDmCl/nMVn5EY1m84/Fr+ivyOQ3v4hKtJppWWCKI7aq/UUdEsAhk1gGjVdc8tYHtvMZRzR67NQPT38AvxAQidh6FWJhpjKETdBR7LBLpQHiQlemv6gKXh5fXkQvEK1or1ufKtMdnPqJmvj104eo73TpL3D8WLgiwybBZZbcjziJqySZXwY78K+S5eTTyjeQvAKV3Uv0GHj65j1GnhcvomNOp5cofr4nKsYt+7l161/0XPD65/VreazMeUU2O39u47Ie+6GX5VjgvLqfk3833zznQLZPp2MRaWN7L3Ucn812iZQHu5xfu8iv10lvzuPh951q0V/CmgULFqCiogIFBQXo3bs33n77bUf71atXo3fv3igoKEC3bt2wcOFCw/5HH30UAwYMQJs2bdCmTRsMHTrUsPouAMyYMQOaphlepaWlQuMmARwyvAJBhXgU8c0jkGSFBm/fYYs1GTEdVcI+DyrfX78+c45tFIh5Xt92qBK85vHZH4N/ojfRv9txWPbNIXxF+3Q+Fodx2vQlKlgBOfHrJyrEr6o+VZBO+b8MWXoahLKXhCR87rnnMGXKFEyfPh0ff/wxBgwYgBEjRmDz5s2W9ps2bcLIkSMxYMAAfPzxx/j1r3+N6667Dn/+8591m7feegsXX3wx3nzzTVRXV6Nz584YNmwYvvnmG4Ov448/Hlu3btVf//znP4XGTikQEcPqBqhBLG9WZaUHtxuaTIqFGd5LTubmqiq9IR1EsEpUPOjsUPGM8jI+mfdapD8R/6rSGgC+MfKIDy8pDjx9uH0J8KNflcIXkBOsKsWvaMUHP0VnGJHboFMoMpm5c+di4sSJuOqqqwAA8+bNw2uvvYaHHnoIs2bNSrJfuHAhOnfujHnz5gEAevTogY8++ghz5szB+eefDyC22m4ijz76KP70pz/h9ddfx+WXX65vz8nJEY76JkICOGTsIhlZCfcpt4ebWbzKiFaeB6iVSBZ58NuJUVnBwyOc/RRqbgSRWxzm8fHgR8DF6zHLfpkR7dcPoSviNyjBy9OXX6LXrW/5OsRy/QUhfJ38yZQ68zP1wQ7htBBKf0jGxxzg+vp6w+b8/Hzk5+cnmTc2NmLt2rW45ZZbDNuHDRuGNWvWWHZRXV2NYcOGGbYNHz4cixYtwv79+5Gbm5vUZs+ePdi/fz/atm1r2P7555+jrKwM+fn56Nu3L2bOnIlu3bq5H+dBKAUiZHjz+0R+8vQr5cHrz+OqUx14c5Vlfyr3ikh6h+wrSII4z6qO2Y/PqWh/TvBe21a+ecdtb+eefuCW3mDuT6Yf3hxnt/6d+rZDtfiVyfUFghG/TvgtflMhipoKYwya8vJyFBcX6y+rSC4AbNu2DU1NTSgpKTFsLykpQU1NjWWbmpoaS/sDBw5g27Ztlm1uueUWdOrUCUOHDtW39e3bF0899RRee+01PProo6ipqUH//v2xfft27uOkCHAE4E17sLv5ZNncy+1urnbpDoDzt3ivFR6c+uUdg+iY7AhKBAf1DTPqqW1+iHWvaSmyY5Lp148IL8B/DEFFenn64vlyIDsGb4twyPUpJVYlIt4yKQ8xf2Li1G/x63f019Y+6jdJUTTNh4UwYu/l119/jaKiIn2zVfTX2Mz4GWCMJW1zs7faDgCzZ8/G0qVL8dZbb6GgoEDfPmLECP3/vXr1Qr9+/dC9e3c8+eSTqKysdBxvHBLAIROPYpiFnEi+rtsDwyyQw0p3kBUssoJdFpWpC6l8zw06wqwyzzqMNAnRn2P9ELoxWz67qAheIDzR69ZetfAFgov6hpn2kK4pC6k+fl6KiooMAtiO9u3bIzs7OynaW1tbmxTljVNaWmppn5OTg3bt2hm2z5kzBzNnzsSqVatwwgknOI6lsLAQvXr1wueff+467jgkgCOC1Y1EdDKbnVB0umhFo8dufentOR6cfq3+xhtptu0v4nm1qYRfkweVzDb3MDaZB2EqCF7evnn69DPSyzOGVBG+sj6jKn5lCCv662fdY79hmgamOAdY1F9eXh569+6NqqoqnHvuufr2qqoqnHPOOZZt+vXrh5dfftmwbeXKlejTp48h//fee+/FXXfdhddeew19+vRxHUtDQwM2btyIAQMGcI+fBHDIJOaqmT97opPZZEQrz4PcSiSLPMxlK0zY+lO02IYsXgV21IhChQvVXzq8HpNspEe0X+GJdQLjiprgBfwXvYB8moNb/1ERvm77ZCo9qBS/YaU+ZBxalg8pEOL+KisrMX78ePTp0wf9+vXDI488gs2bN2Py5MkAgGnTpuGbb77BU089BQCYPHky5s+fj8rKSkyaNAnV1dVYtGgRli5dqvucPXs2br31Vjz77LPo2rWrHjE+7LDDcNhhhwEApk6ditGjR6Nz586ora3FXXfdhfr6ekyYMIF77CSAI4TdBW/3pUwkagyIpVUkIhNB5u2Xp/8kfxJiSWVaQxQEY9TxO4qu6j3w8jD1u1xazJ7fVqXg5e1bheiN9RVetNetf3fR7rAv4lFfp31Sv3IoEr8ypELUNh0ZN24ctm/fjjvvvBNbt25Fz549sXz5cnTp0gUAsHXrVkNN4IqKCixfvhzXX389HnzwQZSVleH+++/XS6ABsYU1GhsbccEFFxj6uv322zFjxgwAwJYtW3DxxRdj27ZtOPzww3Hqqafivffe0/vlQWOMPjZhUF9fj+LiYvxlzXcoPCyWa5MlIAJlfvmQFYFeI548IlmEsCOw6bx0ctjpH6q/XKiIFgVWNk1wrLyCV2QsURK9POPJFOHrti9I8asy71dl9DeI9Id4/3v31OPGC4pRV1fHlSurkrh22Lz6RRQdVqjW967d6Dzwp6EcVxhQBDhCON3MzeLY7cZuJZBl83J5BYBMDrIdTqJZpUiSEdNhi8SoElRkXOVPoF5Xt5NrJ2bvh9AVGQfvOQoi0gv4K3qBzBa+MZ92bdSlPTi1UVnOTSWUepF+kAAOGXMtS/vFIqxvPnZRY9F0isTx2KEi95ZXcIrcbLxEmP0UbWFHqu2IagqHHw8YFcfq5QuPn2I35t+fKHOQojdm49IPV8UKb+PwS/i6+U4F8etEUIJVZmyi0d9UIr58sWqfmQQJ4IghmterShgf6ktsbMa27ncVr9FkK7wIJ9XpGYlEVWgGQRDRkkiVTZM83nQUvLF+1Uys8xrt5RmLF+EL+BP1ddsftPiVWehC7RLO4m1kSAdhTPBDAjhkEqtAxPFaDQLge7BaiWSeG4DIpDxnP/adeRE3QYlnQg1+flFQla7i5cEoKnJj/fmXP+zHEs1BCV5eP2GKXjf/6SB8ZX3KjlFqDAqjv5F8TkSkCkQqQwI4gqioBhGzd75qRXKOjf05uuWeoMf7kBeddOZVUEU1dSHqBB3xVl46zePbLiN0Y/3KCGQBWx8Eb2wMasQqEEyKAxCu8HXzLyt8vfl1aqdW/Dqh2p/Mqm8U/c08SACHDIPGvRSyqPD0shgF78NcNoqcPA77fSqEjoiIzuTUhaDxvVyaooearLg9NA5/Ra7eJkSxG7Pj7DugSC/gXfQC0Yz4urV1zatOgciv6tSHtIn+ApFYCCPVIQEcUURXewPEI8exNvKT3gD3BxlvaTfeG5Ps9Rm0iM4UwqqI4Ue0xqvIBeTPh99iF/BH8MZsOfsPUPQC4Qtftz7cBaqcCHXb79ey00FGfmVSH2THEVVoEpx3SACHTDNLvtBlSoDJCGPA/0lvsrnI9mPiNtVR9aWWyp/5i98PIRUCF/D+OQhC7ALigkR1lBdQJ3pjdt6jvTz9qVnRTn6/l6ivu2+ndvL9BjVJzYu/VBS5hL+QAA4bi5uO281VZmli++WInfsC1Ex6k6lkwQOPeA7ixpcpvxxF5SGiSsyaUfElx8s5ipLQPWTPOQ7uleh4+1UjeHn6DFv0xvyHI3xjbdVHfcNIe1Ad/Y1q+gOA2ENH9YMnUx5kByEBHAGES5/Z7JJdPMJt0peKSW9+TXiTFUIiUWceoiIMUxW/BG0iKiP4Xt9v2TxzuZ+Z/asoEYboBdREeoH0F74x/05tUyPqy4OT+KX7M2EFCeCIIlPZQUYYA/LRY729hyhysi81UWU3VAku1UI61QhCuLrhV2qKioemlwmVQYjdWBt+W7FV6Xjt1Ile3n6DEL48NpkofoPO+/UnEh2B+74POcBUBo0IFKs6wHFkljO2rAnMea3aCWUVi1f4kburUvjIiukoCMBUJsi8auW5iB7fey8/rwZRVcIPsRuzTU3By91XyKI31odTe2/9+5H24MUvRX4JWUgAh4zTQyboqg5ONyCeFdNULoUMiN28vKYu+SHE0rFqRBQnAvr1kFNVDi9ooRtrJ95GfFU6Xjv1pdm4+04h4cvjw4uIjLX3J+rr1tYv8euFlI7+ArYlVL36zCRIAEcA0QUpZHNyPdUFFrjmZXORnVCRhiHUn4L7QBTFYpQI+jnix81dxSSZIEUu4J/QPWQfbcHL268K0RvrK9yIb8xHOFFft/1eRLXbhLe0TX0glEECOGRcbzw2N3TZldq8phVwlT7juEfwRJQTERUvXldzo8oRqfHzod8RC1WzwMMonQbILsMsaq9e8IqMI2jRy2vnVfjy2IQpfHnap5r4TSWoDrB3SABHAJlUBxlh7NSXW3+H2nsXyIC6iLIdXoRRUEshp8uNWBVB//ymusRR2CXU5JdiFrUX6yfqope3XxWiV1VffGKexK8oKRX91eBDGTS17qIOCeCQYUwDY5qlcJRJdfCy8ISKnFvRh6OqiLITfkebg0KlMI/qMYoSRJ3OKJVPC0rkxtr4W5NYaOJcCIKX1y4o0Rvri8dPdIWvV/9exW/K1vwlfIEEcEQQrQUca2O93e1LoYrli1XUBo758b/sWdAC2i/SRbSaCevB40eOtqogkZfqIrJj8DOyG/MvYCtw/KpFN+8400348vSTruLXjchFfwEwZIFBcQqEYn9RhwRwhJGpBRxrZ7+PR5iKTsoTHYPIWIw+1UeXeQhKoEVFaCeSalERvyceqnwOei2h5+2B7m90N9aHoH2IopfXjkf08voKSvjy9BVl4Qv4L35TKvWBUAYJ4JBpZuLlx7xUc+C9lu3EqehDW3aynhN+RJfF+vfnhphqYlMFYVfK8OvZpqI+tNexyZ5buQU4BO0Fz09YgjfWd3qKXp6+gpmo59I+RPEbZZimgSnOAVbtL+qQAI440qu7eagHHGvvvJ/3OvGSk2yHjDBQeV2HLdoS8SLGo3QcqggiWKN68ZOwhC4g//BPRcErYqtS9PLaRUn48vgJQmCHLX4p+pvekAAOGcbkUha8lBrjfWA6iSsVE+bieBEUKlMyvBDWF+dUFbFRea74uZKfqmP0+h57W4hDoo2PYhfwR/DGxhFN0RvzRcJXdAzpLn6pDJp3SABHHNmJboCCld0UlTzzmnbhhIyAEY048xDxe2XGENTS1KrfbxVfZLz+lBuE2AUCyCWOuOiN9cvjS93YglvtToGPFBC/dL9PD0gAh4zdcoZeVj4LQhzHxiCfi2ztj9vUU8RVlUjyQ0hnOkEJWCf8eripitaHIXT1tikueAH1olfENl2FL09fXD5I/HJDSyF7hwRwyNhd7zwfRDuR7Hmim8AF7iUX2Q4VOcr8fcm3jYJYI4wE+XDyI/1EzdLKHttLfq4DmTznk9gV9a1S8Mb8qRXlURK+PH7chC/vWDJF/AKUAqECEsARQHqim82DinfBBK9RZMCnZY8DqA18qC9PzQ1k2ARa5UTl4eJnXrXKGecqzleQYheQTLNIMdEbGwOvz8wWvoAa8asmQh2RGxARGCSAI4xqYQyoEceAmNjjfRhILXksKVb8KGVG989oEuREQfXLKyvy4+HXisAn0fkoeEX9p4vo5fUXpNAOKuoLqBG/Ubu/Uxk075AADhmnKhC+VIAQeBA6iWXRm4HXvGQ3/Iwyy+BXreB0JWrVLPyuDaryYaoiby9okSvbzk+xK2ovVqotuqKX105VxBeITtQ35if1xC+hBhLAESbMChCA+4OVN5oMeM9LdkP2Ae7X6mtRE3SZTpDF7v14WKqanBLqBLoABK9MP2GLXpExRFX4cvuKUNQ35id1xS9NgvMOCeCQsYsAOwlBngvSqb2qSW6iFwuPYPZ6sxEV0Jm8zHFUiOpKTEE8+FQ+cFSdx6BFLhCM0JVpE7bgFRlDGKXaeP0FKXyB9Be/hBpIAEcUrxPUVExwA9xvJCLCTlX6hWMfHm5YfqY/RVXkZQphPMj8iKZEaRKdl/ZRFbxAaoleEb9RFb68vtRGq1Nf/FIVCO9E7mgZY77Oxjxw4AD+7//+DxUVFWjRogW6deuGO++8E80JVypjDDNmzEBZWRlatGiBQYMGYcOGDQY/DQ0NuPbaa9G+fXsUFhZizJgx2LJli/B4mplmePEQjxpbvby2l4mQuL1kiP+8w/NShdt5EXkRaoji++H351LltaTqnHhpb77Hyd7nZMbKNz6xc8yYpr9UjkVsDPx+RftX5o8z6ht0ygNPqTO6h2cGkRHAixYtQs+ePVFQUICCggL07NkTjz32mPJ+7rnnHixcuBDz58/Hxo0bMXv2bNx777144IEHdJvZs2dj7ty5mD9/Pj788EOUlpbizDPPxM6dO3WbKVOm4IUXXsCyZcvwzjvvYNeuXRg1ahSampo8jc/qYSHy8FAhBlSLCx6R7OVhLyKWgxLUKsV0Jr9UEtbnw7fPvcLz5/0al7tfOfXtRzuZ850oeN1Er5d7o/s45M6Niv65/TUfevH4c0PkGNx9uRtxvWfNAOOMbPuJ6ueeHznFUScSKRC33nor7rvvPlx77bXo168fAKC6uhrXX389vvzyS9x1113K+qqursY555yDs88+GwDQtWtXLF26FB999BGA2EUyb948TJ8+Heeddx4A4Mknn0RJSQmeffZZXH311airq8OiRYvw9NNPY+jQoQCAJUuWoLy8HKtWrcLw4cO5x2O+wPkmuNkbZSlaREIkHUC1vziiES9VebaqbwKy6RyE+vdCFUGktCj/AqDAn0zqgooxyLaTi5r7W2nCj/QGUVvVecUqUx2E+lUkfHn75D1OIjWIhAB+6KGH8Oijj+Liiy/Wt40ZMwYnnHACrr32WqUC+PTTT8fChQvx73//G0cffTQ++eQTvPPOO5g3bx4AYNOmTaipqcGwYcP0Nvn5+Rg4cCDWrFmDq6++GmvXrsX+/fsNNmVlZejZsyfWrFljKYAbGhrQ0NCg/11fX285PruLkH9hCm/i2G0couPh9SfrN5GoVYKIE1URR8QIIz9btbhV7der0AW8jSXKgjfWRsw+CqJXZBzpIHxj/tJX/DL4kAMcnaSAQIiEAG5qakKfPn2Stvfu3RsHDhxQ2tfNN9+Muro6HHvsscjOzkZTUxPuvvtuXXzX1NQAAEpKSgztSkpK8NVXX+k2eXl5aNOmTZJNvL2ZWbNm4Y477kjanhgB9rPyAyD2UHMTyzIPKK+T91T1YSZIAUTVIMSI+uRBv4Ss332ELXC9tpdfiS6YyXd+CV5Re7/GkUnCF4ie+AXgS8pCpgVrIiH3L7vsMjz00ENJ2x955BFceumlSvt67rnnsGTJEjz77LP4+9//jieffBJz5szBk08+abDTTEqKMZa0zYyTzbRp01BXV6e/vv76a4v23nL5VOZTeslDlh2firxP3j5U98uLbD50pr6CIqzPjF99qLx+VYzLS3tvedL8+bt2Y5UZo0gfomMSGY+Iby6/HPm9Ij557cSOh8+QN+obRfFLqCESEWAgNglu5cqVOPXUUwEA7733Hr7++mtcfvnlqKys1O3mzp3rqZ8bb7wRt9xyCy666CIAQK9evfDVV19h1qxZmDBhAkpLSwHEorwdO3bU29XW1upR4dLSUjQ2NmLHjh2GKHBtbS369+9v2W9+fj7y8/OTtrODF7br8sYcF6tb9FPkoaMymhyHNwUjjCiwin5FyLAVJz0R5PsiQ3Bfnvz50Kgav1c/Xr7wyC4843d0V7Yfv1IbZPyrjvaK2Ip92VH7fIm68I0thay6DFpmPZgiIYDXr1+Pk08+GQDwn//8BwBw+OGH4/DDD8f69et1O7cILA979uxBVpbxQ5Odna2XQauoqEBpaSmqqqpw0kknAQAaGxuxevVq3HPPPQBiqRm5ubmoqqrC2LFjAQBbt27F+vXrMXv2bKlxOV3o3Cu3OfhQnbMrl2qgLgXDCS8P4qCu/6iLukwlrPfFL3ELqD0mVb7CELuxtnLtSPSq8UvCl4gSkRDAb775ZmB9jR49GnfffTc6d+6M448/Hh9//DHmzp2Ln/3sZwBiInvKlCmYOXMmjjrqKBx11FGYOXMmWrZsiUsuuQQAUFxcjIkTJ+KGG25Au3bt0LZtW0ydOhW9evXSq0KoxG9xHEd15QdRn4mICgIvgjkR1QIow75Qh0JUv0z4KWoT8eP4oyB0Y+MIp+pEEIJXpo2fohcIX/gC6lMdRPr3I9rtF5QD7J1ICODFixdj3LhxaNGihe99PfDAA7j11ltxzTXXoLa2FmVlZbj66qtx22236TY33XQT9u7di2uuuQY7duxA3759sXLlSrRq1Uq3ue+++5CTk4OxY8di7969GDJkCBYvXozs7Gyh8bjlpmkuwo73ZsEjlFWmSMj4lPEfR7XYiKqgJvwnKOFqhd+fF9X+VeRphyVyAfnxByF2Af+FuGi0M2zRG/MbnvAV8UlEH435uewaJx07dsTu3btx4YUXYuLEibZ5tOlEfX09iouL8fDyOrQoLJLy4SaORfCrOkFQEdCoR1pVCWrCmjBFKw9B3WX96EfVZESvQjfmw1v7IAWvbDu/o7yAv4IvlYQvIBf13benHtMubo26ujoUFck9v2WJa4eP160zBOVUsHPnTpx04omhHFcYRCICvGXLFrz66qtYvHgxBg8ejIqKClx55ZWGSWnpitMsWPdJbXwPFB6hLHrTVZl6YYVfdYb9HIMTURdoRDJhhwb87l91lQ0VAjfmx7sPbznGwbULKtXCz0ivqL1fold4HCmU7kD4QyTKoGVnZ2PMmDF4/vnn8fXXX+PnP/85nnnmGXTu3BljxozBX/7yF32SWiahqjSSuRSQ1UsUv8tYOR27inPi1xiCHB+RTNTfryD79+PaVHkPUXHcXo/NS/+y7byOk7sfzmWJZfsQtRctZSYa8RVJd0gH8cvzXJd5ZRKRiAAn0qFDB5x22mn47LPP8O9//xv//Oc/ccUVV6B169Z44oknMGjQoLCHqBTzTUFVZFU8gureQCblQuQm7zUNw8vNKogUiijfTAlxwno//a6PrPohqOo8eZ9QF077oKK8gP+RXpk2qRbxFfUbHlk+rNwWiZhoYETmaL/77jvMmTMHxx9/PAYNGoT6+nq88sor2LRpE7799lucd955mDBhQtjD9B1VUVU/Ik1+f5sMc9EE1dFeigKHSyq8l0F+zv26ZlWeJ1XH7f0+J99e1f2aq6/m5JdoX36MTXxREAaRiK/seRLxTWQGkYgAjx49Gq+99hqOPvpoTJo0CZdffjnatm2r72/RogVuuOEG3HfffSGO0h/iF5xIBNLtpiIaSeW54OUXl1CXp+yGFxEc1BLFdHNNP/yOyDrh90+Wfnxe1U2qC9dHGHnGMpmAQUR5AZnJe2INhCPPPkZ8w7zm41AZNO9EQgB36NABq1evRr9+/WxtOnbsiE2bNgU4qmBxugDFS4I575cRe7w3CL+FsrEvdXchlTe0oMQ04Z0oPMjMBJmH59cXMpXnVdUYvfpJFcEr218QojfWT3SEr6j/KN4vCHkiIYAXLVqE119/Hb/+9a9RW1ubNOHt8ccfh6Zp6NKlS0gjDBeRC5RHgPpV8QGQv9HLCGfVQkGVoKabZOYS5iSSIH5d8OOzHRWBGycMoQsEK3Zl2wUheGNtxOz9zn2O4j2dIsDeiUQO8J133olhw4bh9ddfx7Zt27Bjxw7DK51RnWfoR95iFHNw/YBm0mYuUX7fg7wmwqjqosqXKCqO0csYZPJ3rfr1u538uZGr5CA0NsFzJ3vshDMLFixARUUFCgoK0Lt3b7z99tuO9qtXr0bv3r1RUFCAbt26YeHChYb9jz76KAYMGIA2bdqgTZs2GDp0KD744APP/ZqJRAT4oYcewuLFizF+/PiwhxI5VKceiN4wVeYm2+FnSgYvqqtAkAgmws73DuLB7ccxqvSp4hx4Tp3wWMEzyAgv4GWipf+RXsD/aC+QGqI3KhHg5557DlOmTMGCBQtw2mmn4eGHH8aIESPw6aefonPnzkn2mzZtwsiRIzFp0iQsWbIE7777Lq655hocfvjhOP/88wEAb731Fi6++GL0798fBQUFmD17NoYNG4YNGzagU6dOUv1aEYmV4Nq1a4cPPvgA3bt3D3sogRFfzeX+v1ivBKc6j9TvMl9Br8QW9TzbqK9MR9gT/h3RnqAfzP792qLWX5Qm1oUleL20TTfRK90PZ5t9e+ox/ZJwV4L78ONPcZjileB27dyJU046Tui4+vbti5NPPhkPPfSQvq1Hjx746U9/ilmzZiXZ33zzzXjppZewceNGfdvkyZPxySefoLq62rKPpqYmtGnTBvPnz8fll18u1a8VkUiBuOqqq/Dss8+GPYxIofqnSL9/Rg06fSGscmm8iKZ0qHylC+l+/sL87AZxLvzwq7Y0nPdxyZYiUzUGL229pjb4nd4AeDunQv0Inoco3GfjEWDVLyAmshNfDQ0NlmNobGzE2rVrMWzYMMP2YcOGYc2aNZZtqqurk+yHDx+Ojz76CPv377dss2fPHuzfv1+vDibTrxWRSIHYt28fHnnkEaxatQonnHACcnNzDfvnzp0b0sj8x3yx8kYORS5WvyexBb1ssdfoqt8iOOzodBRuzulClH8KDeN99rNP1eda2ZdtBYuQqvgy4YUgI7yxdnL9BTkRUDaQFBX8mHcQ91deXm7Yfvvtt2PGjBlJ9tu2bUNTUxNKSkoM20tKSlBTU2PZR01NjaX9gQMHsG3bNnTs2DGpzS233IJOnTph6NCh0v1aEQkB/I9//AMnnngiAGD9+vWGfVqG/ZbsdoHJnA6eC92LaBO5Kah4O73chIL4OIUpmsIW334SZTHqlbAfrEH0H+UKEnFUiF0gdQVvrG8SvSr6SmW+/vprQwpEfn6+o71ZpzHGHLWblb3VdgCYPXs2li5dirfeegsFBQWe+jUTCQH85ptvhj2ElMEPgQzw3xiCXq5Y/eQ0NX6i+r0snUVilInqAzLolA6/SFehq8pPGII31lauXdAl31I92muFn5PgioqKuHKA27dvj+zs7KSoa21tbVJ0Nk5paamlfU5ODtq1a2fYPmfOHMycOVPPDvDSrxWRyAHOZKxyyFTnlKnMxQs67zaquZ0qxxW1Y0sVwj7nfp7/sMcV1DXu230qoHtq0H68nvvE/F3RPF6rY+Aedwgl3+TOT2bfU0XJy8tD7969UVVVZdheVVWF/v37W7bp169fkv3KlSvRp08fQ/rrvffei9/85jdYsWIF+vTp47lfKyIRASac4blhZEl+leG90IPOu/Xjp3xVN7UoRn/phh0tovp+BPkLgZ/nQFUENxGV41XhS00JN29OPH2J8vAeyfabSSkOUSmDVllZifHjx6NPnz7o168fHnnkEWzevBmTJ08GAEybNg3ffPMNnnrqKQCxig/z589HZWUlJk2ahOrqaixatAhLly7Vfc6ePRu33nornn32WXTt2lWP9B522GE47LDDuPrlgQRwyDh92xSqwSt4sxEVzF5uEH7lLfOiWkxH6WYZRTEeJlF6b1QShdSWIM6tH8I2jurxq/KnroRbaopdz30HLHpZMwOLwgUZEcaNG4ft27fjzjvvxNatW9GzZ08sX75cX7l369at2Lx5s25fUVGB5cuX4/rrr8eDDz6IsrIy3H///XoNYCC2wEVjYyMuuOACQ1+Jk/Hc+uUhEnWAM5F4Lb+5f7auA8xDEOJHNrLshaiKunSeYEb4S1Sfl0Hf/f0UuIB/6SiqiIrYjfnw1j6MCC/gPaVOqp2p03176nHr+Dah1gFe8/fPfakD3P/ko0I5rjCgCHDIeLkR8LT1nLogcJNTJZZlz4nfwjndy6cR0RWqPIQdyvBb3AL+HaNqv2prNqtxFqbg9dp/GKIXSBa+RHpBAjgCiF6gIkIvSDHp9QbpVUD7KQDSvXwaETxhC1Y7ghCyifh9HvzyH0WRG/Pl3UeYYhfwfm4zQfQy+FAHWHFOcdQhAZyCBBH5FbmBqBKHsjfdINI0Ul1cE/JEVajyErSgTSSoc5cKIjdOVCK6caKw0AdAoleUZmhoVixYVfuLOiSAQ6YZ9hd+EItTBL0whR9iL+zIs1dSXWAR/hOmiLUiyM+s3335pX2iFtWNQ4L3YHsPA0hBvUxYQAI4wgRROizofNsoliILQ1yELboJ70RNlIoQ5peuIPtOBXF7yKdaf1Fa7ENNSTeP7T0OImqiNypl0FIZEsAhk1iM3Ouyz34veZyIn3nLfvRvRZipB6kmnoIS7Kl2XsIkar8cBF5RIoD+MknoAtEq7aZiLOkmegm1kACOEKI3WxnB7OWCDiIlww2VojXoB3Yq5/qSMOUnasKUl7DHHewiHf515odr1ddflIQuEA2xC6SW4GXMh0lwiv1FHRLAKQzvTdxrZDlOOqzmFqYIDVtgWJHKojxOFM9rWETxXAQtKoIobe/bpLuIr3CXboIXSC3RS6iFBHDIuK07rmaSGv8VrkosA3I3Fr9r4ap+cKW6gIyiYMpEUul9CFMwBLluUyYv5QyoLvOmyE9EorxRuF4Z1OfsRuCwAoUEcMSRudC8iDKvD5gg8phF8VNUR+FG6Eaqi3RVpMJ75SdRi3SFsQhpKi/n7EtqhWKfURK6cdJF8BLqIQEcMqzZeMNUMdkozLJkMg81lVFnK1Te5FNxtTa6eac2UROudoQhaA/1HVxfqbicMxBdsQtET/AC0b9vUg6wd0gARwzem2tYyw77oVW9PDj9Fs9mghIjqSi0M5FUEaeihClmzQReXSKFl3QG/Fq8Q7E/EryeoTJo3iEBnKKEtWpa1MqP+f2gDlpgx0lXYUWoI0oi1Y0whxpkBZNUXbQDiLbIBaKZk0ykNiSAQ8ZtEhwQ7qIPftR/9XLzCVqPBiEywhLZhP+kkkjlIUqHE0ZpvqCOP5WELuDPUsJRFbzNzQzNEYhQUAqEd0gApwBBr9aWiIqHjEoR7fcDKAwtmm4iiYgGqfCxikJ96XRYmS4Rv44n6iI3jmqxS6QvJIBDppkZbwIqcz+jkN8LeHvIBb1kcDoKbCLapIJQ5SEKYjaRMM5rUHrJz2PzQ+gC0Re7QGoJXgZA9SWXOkevBhLAEYP3+ovKIhN+C7qoRaC9EmWxk+7iPMrnPipETcSaCTWXOMC+gzhOv4QukBpiF0gtwUuohwRwiuL1ulUloFXelKIYgZYlSqKbFxKI0STqopSXKH2+wtI9QZ0DP8UtkHo5yukodCkH2DskgEMm6ElwcdJ1lbaoRDGjIlpSUYhHjai8l1EgSiLWTNgaJ+hz47fIBVJP6MbxQ/AmjjfK1wHBDwngFCDMhS0Skb2nBFnTlpY6NkLijUjVh3XYgjaRMM5hEAIXSO2JeYB/0d2oXzdUB9g7JIBDhjUz/UanKVCKUYyiptryxolE9SaY6sI8nYnqZyYIoiRarQj7vQlK1MZJh0l5fqYvhP158AKlQHiHBHCEELk5qhDLtuMIsewaL6rviam28loq37iJ6BF14WpFlK6BoIVtnHSbmEdilwgSEsApioobrmoR7ccNJihRHSUBkGpinPBGlD57fhN1ERKWkE0k6CEEWgfZ54Pz+1ji/qPwOaYUCO+QAA4Zcx3gRHyfdCZ5M/Iz+mwmFapMqCYCz2CCSCIKD31RoiBo44Q5lHQSuUBAZeKi89EhfIIEcIQRvY8Elhfr4QYXpHg2Q4tcEJlAuj64oyRmEwl7WKEs+BHQQQdWNi6aHy1HnIJnXnxmEiSA0wiVH16/dKrfD7F0FthhkQnCPl3fuzCIqlB1IkpDDnWxj4BPBAlcIkxIAIcMTx3gRFIhJzbMHFY/H75hiuswoYdH+pKKYtWJKB9OFK6jMBaECPK4g+qrOQJvJuUAe4cEcIoRxeWKzai4x0ZRa4YlFjJVeGca6SZGZUmV0xABDWQgrNXOAl8AJMh85qi9yYRSSACHTHMzM9y4snwQO6m4OETQ9/Ioa0wSRkQUSKePYZR1TRSW7Q3r/ATdbyoLXKoD7B0SwBFD5ubnh2h2IoqLbXiFBDeRqkRAL4VCKmmXKIjaOGGft1Am7YV90D4gmj7J6zOTyAp7AGHwzTff4LLLLkO7du3QsmVLnHjiiVi7dq2+nzGGGTNmoKysDC1atMCgQYOwYcMGg4+GhgZce+21aN++PQoLCzFmzBhs2bIl6EMBcCiKrOoVBPGLN4hXFInP4KUXvby+okq6XNdRvqdG5byF2X8zY64v1TBaYj4tyDgBvGPHDpx22mnIzc3FX//6V3z66af43e9+h9atW+s2s2fPxty5czF//nx8+OGHKC0txZlnnomdO3fqNlOmTMELL7yAZcuW4Z133sGuXbswatQoNDU1CY0nKjf5RKJ6s5clk4U2QdiRaddDqtzPonaOwx5H0OI2Dmu2f0WBZmi+vDKJjEuBuOeee1BeXo4nnnhC39a1a1f9/4wxzJs3D9OnT8d5550HAHjyySdRUlKCZ599FldffTXq6uqwaNEiPP300xg6dCgAYMmSJSgvL8eqVaswfPhwZeOVvb7DTDFQ+dAIOr3DC1F86MeJWspJphHlz0bUieKXahGi+t5HZVxhpidERcwS4ZBxEeCXXnoJffr0wYUXXogOHTrgpJNOwqOPPqrv37RpE2pqajBs2DB9W35+PgYOHIg1a9YAANauXYv9+/cbbMrKytCzZ0/dxkxDQwPq6+sNLz9Jl6iO6vSOqEd//CKoKDi9onHd+EkmXIOp9N5HcVw8aQlhRnCjFMmVJT4JTvUrk8i4CPB///tfPPTQQ6isrMSvf/1rfPDBB7juuuuQn5+Pyy+/HDU1NQCAkpISQ7uSkhJ89dVXAICamhrk5eWhTZs2STbx9mZmzZqFO+64I2m76M0o7EieyvtV2MfCQxREcCpFwQn/icJnMuqk8peOKI89KpPJUl28EtEg4wRwc3Mz+vTpg5kzZwIATjrpJGzYsAEPPfQQLr/8ct1OM6kzxljSNjNONtOmTUNlZaX+d319PcrLy4XH7/X+EyXR6ce9NErHpwoSPES6ExFdpZRUOqaoCNs4URC4zOGcMIR/vvyI5EfsY+A7GSeAO3bsiOOOO86wrUePHvjzn/8MACgtLQUQi/J27NhRt6mtrdWjwqWlpWhsbMSOHTsMUeDa2lr079/fst/8/Hzk5+cnbQ/6xuN3d2EL0KhewGGfF4IwE9VrJSxS+XxETcAmEgUxm4iTsCUyi4zLAT7ttNPw2WefGbb9+9//RpcuXQAAFRUVKC0tRVVVlb6/sbERq1ev1sVt7969kZuba7DZunUr1q9fbyuAnRDJlwoyh0oGyp+0xs/80jBemU7Y55/ewxjpeD5S5RnAk2MbhvhljDm+0oX4UsiqX5lExkWAr7/+evTv3x8zZ87E2LFj8cEHH+CRRx7BI488AiCW+jBlyhTMnDkTRx11FI466ijMnDkTLVu2xCWXXAIAKC4uxsSJE3HDDTegXbt2aNu2LaZOnYpevXrpVSGCxM8bYFYEQpdRumdF4HREgii9J0R4ZPrnIGoBCFGiFp01EzXB2nzwfEXhvPlRBzzTsu0yTgCfcsopeOGFFzBt2jTceeedqKiowLx583DppZfqNjfddBP27t2La665Bjt27EDfvn2xcuVKtGrVSre57777kJOTg7Fjx2Lv3r0YMmQIFi9ejOzsbKHxWH1L1iIUl/fjBh8FUS1LxO7HBlL4tBIuRPlzl4qkunC1IgqijJeoCds4zSl0DgnvaCyqn8Q0p76+HsXFxZj2yHYUtCxS6jtKAjpoUllcEwSRTDqKVTtSScQmkgoyQqW4bdhbj3smt0ddXR2KitQ+v92Ia4c//W0bWh6mtu89u+pxwU/COa4wyLgIcCYQ1E00ikI7lR6WJNaJKJBK10xUSFWhakcqCNg4FKUlVEECOGQYnBPz3UqvhYmfD4EoimvVkPAgCP9JN7HqRCoJ2URSRdTGz28UzrMfkzcjcFiBQgI44qi60KIspK0I+qGVCYKbIKJGJolTN6IgqlSRKoI2Tjqde4IfEsAZQhgXeCqJ7kx4EJPIT10y4fMZZTJFIKWacDWTKe8TADRDQ7PismWq/UUdEsAhw5r5bzpZKSZggroZpZLQDhMSUUS6kknCx41UF7GJ0PtK+AkJ4BQi6BtbqgjuVL9JkoAnokaqX1NRJZ3EqROp/vlxq4cbhXq5lAPsHRLAhC1B3KxTRWT7Sao/LAgi3cgUoepEut2XoiBaVcKYBsbUBk9U+4s6JIBDRnZ5xnSJGob1oCHhTRCpAwlSMdJNvCaSbkKWCA8SwClKmDe4dBDfmfpAJeGfXmTq5zjVSGdBygOJVvXQUsjeocchIUw8ah3Ui1BHczO90ulFeIfuYe7ExZbsKxVgzUzoRRxiwYIFqKioQEFBAXr37o23337b0X716tXo3bs3CgoK0K1bNyxcuNCwf8OGDTj//PPRtWtXaJqGefPmJfmYMWMGNE0zvEpLS4XGTRHgkFFxg8hK/YCsI1F7gKRDBJwgokDUru10IlM1WqaI06hMgnvuuecwZcoULFiwAKeddhoefvhhjBgxAp9++ik6d+6cZL9p0yaMHDkSkyZNwpIlS/Duu+/immuuweGHH47zzz8fALBnzx5069YNF154Ia6//nrbvo8//nisWrVK/zs7O1to7CSA04AoXe/pLsYBemgTBMFHlO7NUSNThGoqUl9fb/g7Pz8f+fn5lrZz587FxIkTcdVVVwEA5s2bh9deew0PPfQQZs2alWS/cOFCdO7cWY/q9ujRAx999BHmzJmjC+BTTjkFp5xyCgDglltusR1nTk6OcNQ3EUqBIJTi9aeyTPipjSCI4KH7kRpEUwXSKYUgHnWNQgyEQfPlBQDl5eUoLi7WX1ZCFgAaGxuxdu1aDBs2zLB92LBhWLNmjWWb6urqJPvhw4fjo48+wv79+4XOweeff46ysjJUVFTgoosuwn//+1+h9hQBDpkwbgZaGodpU/S+qpQ0fnsJRdB1kh6kqpAMgiiI1FTl66+/RlFRkf63XfR327ZtaGpqQklJiWF7SUkJampqLNvU1NRY2h84cADbtm1Dx44ducbYt29fPPXUUzj66KPx3Xff4a677kL//v2xYcMGtGvXjssHCeAMJKybZjoL7yhBz0SCCA8Spd4g4cpHM9Tf6+PzaouKigwC2A3zvBjGmONcGSt7q+1OjBgxQv9/r1690K9fP3Tv3h1PPvkkKisruXyQACYCI6oPBhLmBJHaRPXekgmQYM1c2rdvj+zs7KRob21tbVKUN05paamlfU5ODnfk1orCwkL06tULn3/+OXcbEsAhE4V8okwvakAPz/BJty8h9JkigiDsZ0cq0+zhGvXSVhVRqAKRl5eH3r17o6qqCueee66+vaqqCuecc45lm379+uHll182bFu5ciX69OmD3Nxc4THHaWhowMaNGzFgwADuNiSAicjcRDNdiGcyJBiJVCYq99B0JwrCMypEQQADQGVlJcaPH48+ffqgX79+eOSRR7B582ZMnjwZADBt2jR88803eOqppwAAkydPxvz581FZWYlJkyahuroaixYtwtKlS3WfjY2N+PTTT/X/f/PNN1i3bh0OO+wwHHnkkQCAqVOnYvTo0ejcuTNqa2tx1113ob6+HhMmTOAeOwngkGluZkkXdVaaRcN4oYcIfQkgUh+6jtMbEqFEIuPGjcP27dtx5513YuvWrejZsyeWL1+OLl26AAC2bt2KzZs36/YVFRVYvnw5rr/+ejz44IMoKyvD/fffr5dAA4Bvv/0WJ510kv73nDlzMGfOHAwcOBBvvfUWAGDLli24+OKLsW3bNhx++OE49dRT8d577+n98qAxKmoaCvX19SguLsaU33+H/Bb8yeZ+k6nimyAIIhUhQeo/ZpnUsLcev59Sirq6OqHJYiqIa4dFK/+HloVq+96zux4Th7UO5bjCgCLAhIEo30xJnBMEEQWifJ/MZCieR4hAAjhkzGvF0zK79tBDRy30hSKzoeuJUAUJz+CJSg5wKkMCOGJE7UZCgjx9IQFEEOlB1J4bBJEKkAAmHEnFGyuJdoIgVJGK90DCGdbsbuNnexVQBNg7JIBDJgoXUrpBDyyCIIjwoecbEWVIAEeAVLhJaFlhj4AgCIJwIhWeJYQaGFO/FHKmxY5IABNc0I1VDPrCQBD+QPciQiXNEqpPpo1qGNPAmNp0P9X+og4JYILwAXpIEwRBOBMFIUlkLiSAQ6aZsZS5CWTR5DKCIIiUIFWeK4QcNAnOOySACW7ohho89KWDSGfonkIQRFiQACaICEMCgSCITCdqlX2iMJ5mHybBZVppeBLAIWNeCS7KUH1dgiCI1CRVnjMEERQkgAlu6AaaftCXGkIUug8QRPhQDrB3SAATRAZDYoYgiHTEz6XeaRn59IAEcMg0N7OMv5iysigKSRAEYUemPyOIZCgC7B0SwETo0M2dSIS+EDlD1wtBEDQJzjskgAmCiBQk8AiCiBLmyGimRUrTFRLAIePHzxipAs2/IgiCkCdTnx0EpUCogAQwERqZdrERBEEQBBENSAATBEEQBEGkEM3NsZdqn5kECeCQYYyBpXHOo0YTmgiCIEInnZ8zQUPlI9MDEsCEr9BNlyAIgiDUQjnA3skKewAEQRAEQRAEESQUAQ4ZxhiaI/y1K4tKNRAEQRAJRPmZFQRRSIGgCLB3SAATjmT6jY4gCIIgokYzfFgIQ627yEMpEARBEARBEERGQRHgkGHNfFUgqJoCQRAEkelEYWJ1JMbAmPJUjCikdgQJCeAUIQoXHEEQBEEQRDqQ0SkQs2bNgqZpmDJlir6NMYYZM2agrKwMLVq0wKBBg7BhwwZDu4aGBlx77bVo3749CgsLMWbMGGzZsiXg0RMEQRAEkYnEJ8GpfmUSGSuAP/zwQzzyyCM44YQTDNtnz56NuXPnYv78+fjwww9RWlqKM888Ezt37tRtpkyZghdeeAHLli3DO++8g127dmHUqFFoamoK+jAIgiAIgiAIQTIyBWLXrl249NJL8eijj+Kuu+7StzPGMG/ePEyfPh3nnXceAODJJ59ESUkJnn32WVx99dWoq6vDokWL8PTTT2Po0KEAgCVLlqC8vByrVq3C8OHDhcbCmwNMEARBEET4ROGZzXxYCpllWBmIjIwA//KXv8TZZ5+tC9g4mzZtQk1NDYYNG6Zvy8/Px8CBA7FmzRoAwNq1a7F//36DTVlZGXr27KnbWNHQ0ID6+nrDiyAIgiAIggiejIsAL1u2DH//+9/x4YcfJu2rqakBAJSUlBi2l5SU4KuvvtJt8vLy0KZNmySbeHsrZs2ahTvuuMPr8AmCIAiCyHBoIQzvZJQA/vrrr/H//t//w8qVK1FQUGBrp5lWP2OMJW0z42Yzbdo0VFZW6n/X19ejvLwczUx9MWuCIAiCIPwhCs9sP7RDFI4rSDIqBWLt2rWora1F7969kZOTg5ycHKxevRr3338/cnJy9MivOZJbW1ur7ystLUVjYyN27Nhha2NFfn4+ioqKDC+CIAiCIAgieDJKAA8ZMgT//Oc/sW7dOv3Vp08fXHrppVi3bh26deuG0tJSVFVV6W0aGxuxevVq9O/fHwDQu3dv5ObmGmy2bt2K9evX6zYEQRAEQRB+QWXQvJNRKRCtWrVCz549DdsKCwvRrl07ffuUKVMwc+ZMHHXUUTjqqKMwc+ZMtGzZEpdccgkAoLi4GBMnTsQNN9yAdu3aoW3btpg6dSp69eqVNKmOB6oCQRAEQRCpAz2z04OMEsA83HTTTdi7dy+uueYa7NixA3379sXKlSvRqlUr3ea+++5DTk4Oxo4di71792LIkCFYvHgxsrOzQxw5QRAEQRCZgB/Bs0wT9hrLtMWfI0J9fT2Ki4tx5YwvkVdA+cAEQRAEkQo07qvHEzO6oq6uLvD5PHHt8Jund6Cgpdq+9+2px63j24RyXGFAEeCQYYyBvoMQBEEQRGoQhWc2VYHwTkZNgiMIgiAIgiAIigATBEEQBEGkELQQhndIABMEQRAEQaQQzc0MzYpzFlT7izokgEOmuTnzPnQEQRAEkao0N4c9AkIFJIAJgiAIgiBSCEqB8A5NgiMIgiAIgiAyCooAhwyVQSMIgiCI1CEKz2yKAHuHIsAEQRAEQRBERkERYIIgCIIgiBSimTE0Kw7ZqvYXdSgCHDLx9bzpRS960Yte9KJXaryIQyxYsAAVFRUoKChA79698fbbbzvar169Gr1790ZBQQG6deuGhQsXGvZv2LAB559/Prp27QpN0zBv3jwl/ZohAUwQBEEQBJFCsGZ/XqI899xzmDJlCqZPn46PP/4YAwYMwIgRI7B582ZL+02bNmHkyJEYMGAAPv74Y/z617/Gddddhz//+c+6zZ49e9CtWzf89re/RWlpqZJ+rSABTBAEQRAEkUIwMH0SvbIXxCPbc+fOxcSJE3HVVVehR48emDdvHsrLy/HQQw9Z2i9cuBCdO3fGvHnz0KNHD1x11VX42c9+hjlz5ug2p5xyCu69915cdNFFyM/PV9KvFZQDHDL0cwpBEARBpA7p/syur683/J2fn28pRBsbG7F27Vrccssthu3Dhg3DmjVrLH1XV1dj2LBhhm3Dhw/HokWLsH//fuTm5rqOT6ZfKygCTBAEQRAEkUKw5vhKsupe8RSI8vJyFBcX669Zs2ZZjmHbtm1oampCSUmJYXtJSQlqamos29TU1FjaHzhwANu2beM6dpl+raAIMEEQBEEQBAEA+Prrr1FUVKT/bZeGEEfTNMPfjLGkbW72VtvdEO3XDAlggiAIgiCIFMKPRbTi/oqKigwC2I727dsjOzs7KepaW1ubFJ2NU1paammfk5ODdu3acY1Tpl8rSACHTDPU1/IjCIIgCMIfmiUmi6UjeXl56N27N6qqqnDuuefq26uqqnDOOedYtunXrx9efvllw7aVK1eiT58+XPm/sv1aQQKYIAiCIAgihWhmsZdqn6JUVlZi/Pjx6NOnD/r164dHHnkEmzdvxuTJkwEA06ZNwzfffIOnnnoKADB58mTMnz8flZWVmDRpEqqrq7Fo0SIsXbpU99nY2IhPP/1U//8333yDdevW4bDDDsORRx7J1S8PJIAJgiAIgiAIYcaNG4ft27fjzjvvxNatW9GzZ08sX74cXbp0AQBs3brVUJu3oqICy5cvx/XXX48HH3wQZWVluP/++3H++efrNt9++y1OOukk/e85c+Zgzpw5GDhwIN566y2ufnnQmOokEoKL+vp6FBcX46Kb/o28/FZhD4cgCIIgCA4aG3Zi2eyjUVdXx5Urq5K4drhhfi3yW6jtu2FvPX73qw6hHFcYUASYIAiCIAgihWAs9lLtM5OgOsAEQRAEQRBERkER4JDxo5QJQRAEQRD+EIVndnMzQ7PiWXCq/UUdigATBEEQBEEQGQVFgAmCIAiCIFIIPxfCyBRIAIcM8+FnDIIgCIIg/IHRMzstIAFMEARBEASRQrDm2Eu1z0yCcoAJgiAIgiCIjIIiwARBEARBEClEM2NoVpyzq9pf1CEBHDKsmVE+EUEQBEGkCPTMTg9IABMEQRAEQaQQVAXCOySACYIgCIIgUghaCMM7JIBDhlaCIwiCIIjUgZ7Z6QEJYIIgCIIgiBSCsdhLtc9MgsqgEQRBEARBEBkFRYBDhjU3gzVnWPVpgiAIgkhRovDMZkx9BalMS+2gCDBBEARBEASRUVAEmCAIgiAIIoVgPiyEkWkRYBLAIeNHKROCIAiCIPyBntnpAQlggiAIgiCIFMKPVWQzbYU7EsAEQRAEQRApBAlg75AADhlaCIMgCIIgUgd6ZqcHJIAJgiAIgiBSiGYWe6n2mUlQGTSCIAiCIAgio6AIcMj4kcdDEARBEIQ/ROGZTTnA3qEIMEEQBEEQBJFRUASYIAiCIAgihfBjAn2mTe7LOAE8a9YsPP/88/jXv/6FFi1aoH///rjnnntwzDHH6DaMMdxxxx145JFHsGPHDvTt2xcPPvggjj/+eN2moaEBU6dOxdKlS7F3714MGTIECxYswBFHHCE0HkqBIAiCIIjUgZ7Z6UHGpUCsXr0av/zlL/Hee++hqqoKBw4cwLBhw7B7927dZvbs2Zg7dy7mz5+PDz/8EKWlpTjzzDOxc+dO3WbKlCl44YUXsGzZMrzzzjvYtWsXRo0ahaampjAOiyAIgiCIDKG5+dBKsupeYR9VsGRcBHjFihWGv5944gl06NABa9euxU9+8hMwxjBv3jxMnz4d5513HgDgySefRElJCZ599llcffXVqKurw6JFi/D0009j6NChAIAlS5agvLwcq1atwvDhwwM/LoIgCIIgMgNKgfBOxkWAzdTV1QEA2rZtCwDYtGkTampqMGzYMN0mPz8fAwcOxJo1awAAa9euxf79+w02ZWVl6Nmzp25jpqGhAfX19YYXQRAEQRAEETwZFwFOhDGGyspKnH766ejZsycAoKamBgBQUlJisC0pKcFXX32l2+Tl5aFNmzZJNvH2ZmbNmoU77rgjaXszmtHMMux3B4IgCIJIUZoR/jObyqB5J6MjwL/61a/wj3/8A0uXLk3ap2ma4W/GWNI2M04206ZNQ11dnf76+uuv5QdOEARBEARBSJOxEeBrr70WL730Ev72t78ZKjeUlpYCiEV5O3bsqG+vra3Vo8KlpaVobGzEjh07DFHg2tpa9O/f37K//Px85Ofn+3EoBEEQBEFkEBQB9k7GCWDGGK699lq88MILeOutt1BRUWHYX1FRgdLSUlRVVeGkk04CADQ2NmL16tW45557AAC9e/dGbm4uqqqqMHbsWADA1q1bsX79esyePVtsPM2Z96EjCIIgiFSFshbTg4wTwL/85S/x7LPP4i9/+QtatWql5+wWFxejRYsW0DQNU6ZMwcyZM3HUUUfhqKOOwsyZM9GyZUtccskluu3EiRNxww03oF27dmjbti2mTp2KXr166VUhCIIgCIIg/KAZDM2KqzY04/+3d/fBUVf3Hsc/a5LdYExWISVLeIjB4Q4PAdGlhCDW1GrkwXqdtvJQ3GBrp40tkJAKRKEjZYqAMwqlI7EGpPbSCtMBvNihlUWRxkkIvYEgj0rbSMAmTXlK8IpJyJ77hzcb1kQMZDebze/9mvnNuGe/e3LOd3B/35ycPWutxTjLFcCFhYWSpMzMzID2DRs26LHHHpMkLViwQJcuXdKPf/xj/xdh7Ny5U/Hx8f74VatWKTo6WlOnTvV/EcZvfvMbRUVFddVUAAAAcB1sxmoHv3UT9fX1cjqdmvx4uWLsN4V7OAAAoAOaGj/WjvVu1dXVKSEhoUt/dkvtMH3BB7I74r/8BdegseGiNj33H2GZVzhYbgUYAAAgkvFFGJ1n6WPQAAAAYD2sAIdZKH6LAwAAodEd7tnGZ+TjGLROYQUYAAAAlsIKMAAAQAThizA6jwI4zHw+n3w+TtUGACAScM/uGSiAAQAAIginQHQee4ABAABgKawAh1ko9vEAAIDQ6A73bOPzyQR5K0aw++vuKIABAAAiiC8Ex6AFu7/uji0QAAAAsBQK4DAzxsfFxcXFxcUVQVe4tXwILtjX9Vi7dq1SU1MVGxsrt9ut4uLiq8bv2bNHbrdbsbGxGjx4sF566aU2MVu2bNHw4cPlcDg0fPhwbdu2LeD5JUuWyGazBVwul+uaxk0BDAAAgGu2efNm5eXladGiRTpw4IDuvvtuTZo0SVVVVe3GV1ZWavLkybr77rt14MABPf3005o7d662bNnijyktLdW0adPk8Xh08OBBeTweTZ06VWVlZQF9jRgxQtXV1f7r0KFD1zR2m7HauRfdRH19vZxOp+73lCrGflO4hwMAADqgqfFjef8rQ3V1dUpISOjSn91SO/znEwcV44gPat9NDRf134W3X9O80tPTdeedd6qwsNDfNmzYMD388MNavnx5m/iFCxdq+/btOnbsmL8tJydHBw8eVGlpqSRp2rRpqq+v15/+9Cd/zMSJE3XLLbfotddek/TZCvDrr7+uioqK65mqJD4EF3acAgEAQOTo6ffs+vr6gMcOh0MOh6NNXGNjo8rLy1VQUBDQnpWVpZKSknb7Li0tVVZWVkDbAw88oPXr16upqUkxMTEqLS3VvHnz2sSsXr06oO3EiRNKTk6Ww+FQenq6nn32WQ0ePLij02QLBAAAQCRpWTwL9iVJAwcOlNPp9F/treRK0pkzZ9Tc3KykpKSA9qSkJNXU1LT7mpqamnbjL1++rDNnzlw15so+09PT9dvf/lZvvvmmioqKVFNTo/Hjx+vs2bMdziErwAAAAJAknTp1KmALRHurv1ey2WwBj40xbdq+LP7z7V/W56RJk/z/PXLkSGVkZOi2227Tq6++qvz8/KuOtwUFcLixBQIAgMjRDe7ZPvnkC/JpFD591l9CQkKH9gAnJiYqKiqqzWpvbW1tmxXcFi6Xq9346Oho9enT56oxX9SnJMXFxWnkyJE6ceLEl467BVsgAAAAIojxhWIbxLWNwW63y+12y+v1BrR7vV6NHz++3ddkZGS0id+5c6fGjBmjmJiYq8Z8UZ+S1NDQoGPHjqlfv34dHj8FMAAAAK5Zfn6+1q1bp1deeUXHjh3TvHnzVFVVpZycHEnSU089pezsbH98Tk6OTp48qfz8fB07dkyvvPKK1q9fryeffNIfk5ubq507d2rlypU6fvy4Vq5cqV27dikvL88f8+STT2rPnj2qrKxUWVmZvvOd76i+vl6zZs3q8NjZAhFmPhP8P2MAAIDQ6A737FCcIHU9/U2bNk1nz57V0qVLVV1drbS0NO3YsUMpKSmSpOrq6oAzgVNTU7Vjxw7NmzdPL774opKTk7VmzRp9+9vf9seMHz9emzZt0uLFi/Wzn/1Mt912mzZv3qz09HR/zOnTpzVjxgydOXNGX/nKVzRu3Djt3bvX/3M7gnOAw6TlLL97pxcrmnOAAQCICJcbP9bbm+4O6znAkx8vD/p3CDQ1fqwd691hmVc4sAIMAAAQQTrz1cVX69NKKIDDjC/CAAAgcnDP7hkogAEAACKIz+eTzxfkY9CC3F93xykQAAAAsBRWgMPMGJ+MxX7rAgAgUhlOgegRKIABAAAiiDG+oBfi3aGw70psgQAAAIClsAIcZpwCAQBA5OgO92y2QHQeK8AAAACwFFaAAQAAIkko/npssRVgCuAwC8VGdgAAEBrcs3sGCmAAAIAI4jM++YJciAe7v+6OPcAAAACwFFaAw8znk3wW23cDAECk6g7fXcUpEJ1HAQwAABBBQvEtslbb28wWCAAAAFgKK8BhZnzB/y0OAACERne4Z7MFovNYAQYAAIClsAIMAAAQQULxHQJW2wNMARxmofgzBgAACA3u2T0DBTAAAEAECcURqt1ga3OXYg8wAAAALIUV4DALxT4eAAAQGt3hnh2KE6S6w+kWXYkVYAAAAFgKK8AAAAARhHOAO48COMw4BQIAgMjRHe7ZHIPWeWyBAAAAgKVQAHfC2rVrlZqaqtjYWLndbhUXF4d7SAAAoIdr+etxsC8rYQvEddq8ebPy8vK0du1a3XXXXfr1r3+tSZMm6ejRoxo0aFCH+wnFJzkBAEBocM/uGVgBvk4vvPCCHn/8cf3gBz/QsGHDtHr1ag0cOFCFhYXhHhoAAOjBWhbPgn1ZCSvA16GxsVHl5eUqKCgIaM/KylJJSUm7r2loaFBDQ4P/cV1dnSTp8uVPQjdQAAAQVC33bWPCt2Wg+fL/RkSf3RkF8HU4c+aMmpublZSUFNCelJSkmpqadl+zfPly/fznP2/TXv7WIyEZIwAACJ2LFy/K6XR26c+02+1yuVz6n7emhqR/l8slu90ekr67GwrgTrDZbAGPjTFt2lo89dRTys/P9z++cOGCUlJSVFVV1eX/A3U39fX1GjhwoE6dOqWEhIRwDyesyEUrctGKXLQiF63IRauuzIUxRhcvXlRycnJIf057YmNjVVlZqcbGxpD0b7fbFRsbG5K+uxsK4OuQmJioqKioNqu9tbW1bVaFWzgcDjkcjjbtTqfT8m9cLRISEsjF/yMXrchFK3LRily0IhetuioX4Vy4io2NtUyRGkp8CO462O12ud1ueb3egHav16vx48eHaVQAAADoCFaAr1N+fr48Ho/GjBmjjIwMvfzyy6qqqlJOTk64hwYAAICroAC+TtOmTdPZs2e1dOlSVVdXKy0tTTt27FBKSkqHXu9wOPTMM8+0uy3CashFK3LRily0IhetyEUrctGKXOBa2Uw4z/EAAAAAuhh7gAEAAGApFMAAAACwFApgAAAAWAoFMAAAACyFAjhM1q5dq9TUVMXGxsrtdqu4uDjcQwqq5cuX66tf/ari4+PVt29fPfzww3r//fcDYowxWrJkiZKTk9WrVy9lZmbqyJEjATENDQ2aM2eOEhMTFRcXp4ceekinT5/uyqkE3fLly2Wz2ZSXl+dvs1IuPvroIz366KPq06ePbrzxRo0ePVrl5eX+562Si8uXL2vx4sVKTU1Vr169NHjwYC1dulQ+n88f01Nz8Ze//EXf/OY3lZycLJvNptdffz3g+WDN+/z58/J4PHI6nXI6nfJ4PLpw4UKIZ3dtrpaLpqYmLVy4UCNHjlRcXJySk5OVnZ2tf/7znwF9WCEXn/ejH/1INptNq1evDmjvKblAFzDocps2bTIxMTGmqKjIHD161OTm5pq4uDhz8uTJcA8taB544AGzYcMGc/jwYVNRUWGmTJliBg0aZD7++GN/zIoVK0x8fLzZsmWLOXTokJk2bZrp16+fqa+v98fk5OSY/v37G6/Xa/bv32++/vWvm9tvv91cvnw5HNPqtH379plbb73VjBo1yuTm5vrbrZKLc+fOmZSUFPPYY4+ZsrIyU1lZaXbt2mX+9re/+WOskotf/OIXpk+fPuaPf/yjqaysNH/4wx/MTTfdZFavXu2P6am52LFjh1m0aJHZsmWLkWS2bdsW8Hyw5j1x4kSTlpZmSkpKTElJiUlLSzMPPvhgV02zQ66WiwsXLpj77rvPbN682Rw/ftyUlpaa9PR043a7A/qwQi6utG3bNnP77beb5ORks2rVqoDnekouEHoUwGEwduxYk5OTE9A2dOhQU1BQEKYRhV5tba2RZPbs2WOMMcbn8xmXy2VWrFjhj/n000+N0+k0L730kjHmszf/mJgYs2nTJn/MRx99ZG644Qbz5z//uWsnEAQXL140Q4YMMV6v19xzzz3+AthKuVi4cKGZMGHCFz5vpVxMmTLFfP/73w9o+9a3vmUeffRRY4x1cvH5QidY8z569KiRZPbu3euPKS0tNZLM8ePHQzyr63O1oq/Fvn37jCT/gonVcnH69GnTv39/c/jwYZOSkhJQAPfUXCA02ALRxRobG1VeXq6srKyA9qysLJWUlIRpVKFXV1cnSerdu7ckqbKyUjU1NQF5cDgcuueee/x5KC8vV1NTU0BMcnKy0tLSIjJXP/nJTzRlyhTdd999Ae1WysX27ds1ZswYPfLII+rbt6/uuOMOFRUV+Z+3Ui4mTJigt956Sx988IEk6eDBg3r33Xc1efJkSdbKxZWCNe/S0lI5nU6lp6f7Y8aNGyen0xmxuZE+ey+12Wy6+eabJVkrFz6fTx6PR/Pnz9eIESPaPG+lXKDz+Ca4LnbmzBk1NzcrKSkpoD0pKUk1NTVhGlVoGWOUn5+vCRMmKC0tTZL8c20vDydPnvTH2O123XLLLW1iIi1XmzZt0v79+/XXv/61zXNWysU//vEPFRYWKj8/X08//bT27dunuXPnyuFwKDs721K5WLhwoerq6jR06FBFRUWpublZy5Yt04wZMyRZ69/FlYI175qaGvXt27dN/3379o3Y3Hz66acqKCjQd7/7XSUkJEiyVi5Wrlyp6OhozZ07t93nrZQLdB4FcJjYbLaAx8aYNm09xezZs/Xee+/p3XffbfPc9eQh0nJ16tQp5ebmaufOnYqNjf3COCvkwufzacyYMXr22WclSXfccYeOHDmiwsJCZWdn++OskIvNmzdr48aN+v3vf68RI0aooqJCeXl5Sk5O1qxZs/xxVshFe4Ix7/biIzU3TU1Nmj59unw+n9auXful8T0tF+Xl5frlL3+p/fv3X/OYe1ouEBxsgehiiYmJioqKavObZm1tbZsVj55gzpw52r59u3bv3q0BAwb4210ulyRdNQ8ul0uNjY06f/78F8ZEgvLyctXW1srtdis6OlrR0dHas2eP1qxZo+joaP9crJCLfv36afjw4QFtw4YNU1VVlSRr/buYP3++CgoKNH36dI0cOVIej0fz5s3T8uXLJVkrF1cK1rxdLpf+9a9/ten/3//+d8TlpqmpSVOnTlVlZaW8Xq9/9VeyTi6Ki4tVW1urQYMG+d9HT548qZ/+9Ke69dZbJVknFwgOCuAuZrfb5Xa75fV6A9q9Xq/Gjx8fplEFnzFGs2fP1tatW/X2228rNTU14PnU1FS5XK6APDQ2NmrPnj3+PLjdbsXExATEVFdX6/DhwxGVq2984xs6dOiQKioq/NeYMWM0c+ZMVVRUaPDgwZbJxV133dXmOLwPPvhAKSkpkqz17+KTTz7RDTcEvgVHRUX5j0GzUi6uFKx5Z2RkqK6uTvv27fPHlJWVqa6uLqJy01L8njhxQrt27VKfPn0CnrdKLjwej957772A99Hk5GTNnz9fb775piTr5AJB0tWfukPrMWjr1683R48eNXl5eSYuLs58+OGH4R5a0DzxxBPG6XSad955x1RXV/uvTz75xB+zYsUK43Q6zdatW82hQ4fMjBkz2j3qaMCAAWbXrl1m//795t577+32Rzx1xJWnQBhjnVzs27fPREdHm2XLlpkTJ06Y3/3ud+bGG280Gzdu9MdYJRezZs0y/fv39x+DtnXrVpOYmGgWLFjgj+mpubh48aI5cOCAOXDggJFkXnjhBXPgwAH/yQbBmvfEiRPNqFGjTGlpqSktLTUjR47sdsddXS0XTU1N5qGHHjIDBgwwFRUVAe+lDQ0N/j6skIv2fP4UCGN6Ti4QehTAYfLiiy+alJQUY7fbzZ133uk/HqynkNTutWHDBn+Mz+czzzzzjHG5XMbhcJivfe1r5tChQwH9XLp0ycyePdv07t3b9OrVyzz44IOmqqqqi2cTfJ8vgK2UizfeeMOkpaUZh8Nhhg4dal5++eWA562Si/r6epObm2sGDRpkYmNjzeDBg82iRYsCCpuemovdu3e3+/4wa9YsY0zw5n327Fkzc+ZMEx8fb+Lj483MmTPN+fPnu2iWHXO1XFRWVn7he+nu3bv9fVghF+1prwDuKblA6NmMMaYrVpoBAACA7oA9wAAAALAUCmAAAABYCgUwAAAALIUCGAAAAJZCAQwAAABLoQAGAACApVAAAwAAwFIogAEAAGApFMAAAACwFApgAAAAWAoFMAAAACyFAhgAOiAzM1Nz587VggUL1Lt3b7lcLi1ZskSS9M4778hut6u4uNgf//zzzysxMVHV1dX+18+ePVuzZ8/WzTffrD59+mjx4sUyxoRjOgBgaRTAANBBr776quLi4lRWVqbnnntOS5culdfrVWZmpvLy8uTxeFRXV6eDBw9q0aJFKioqUr9+/QJeHx0drbKyMq1Zs0arVq3SunXrwjgjALAmm2H5AQC+VGZmppqbmwNWeceOHat7771XK1asUGNjo8aNG6chQ4boyJEjysjIUFFRUcDra2trdeTIEdlsNklSQUGBtm/frqNHj3b5fADAylgBBoAOGjVqVMDjfv36qba2VpJkt9u1ceNGbdmyRZcuXdLq1avbvH7cuHH+4leSMjIydOLECTU3N4d03ACAQBTAANBBMTExAY9tNpt8Pp//cUlJiSTp3LlzOnfuXJeODQDQcRTAABAEf//73zVv3jwVFRVp3Lhxys7ODiiOJWnv3r1tHg8ZMkRRUVFdOVQAsDwKYADopObmZnk8HmVlZel73/ueNmzYoMOHD+v5558PiDt16pTy8/P1/vvv67XXXtOvfvUr5ebmhmnUAGBd0eEeAABEumXLlunDDz/UG2+8IUlyuVxat26dpk6dqvvvv1+jR4+WJGVnZ+vSpUsaO3asoqKiNGfOHP3whz8M48gBwJo4BQIAukBmZqZGjx7d7ofjAABdiy0QAAAAsBQKYAAAAFgKWyAAAABgKawAAwAAwFIogAEAAGApFMAAAACwFApgAAAAWAoFMAAAACyFAhgAAACWQgEMAAAAS6EABgAAgKX8H9uZ9Aw8eSLgAAAAAElFTkSuQmCC", + "image/png": "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", "text/plain": [ "
" ] @@ -278,9 +780,10 @@ } ], "source": [ - "angle_diff = hgrid[\"angle_dx\"][1:,1:] - hgrid[\"angle_dx_mom6\"][1:,1:]\n", + "angle_diff = hgrid[\"angle_dx\"][kp2::k,kp2::k].values - hgrid[\"angle_dx_mom6\"].values\n", "plt.figure(figsize=(8, 6))\n", - "angle_diff.plot(cmap='coolwarm')\n", + "plt.imshow(angle_diff,cmap='coolwarm')\n", + "plt.colorbar()\n", "plt.title(\"Difference between caluculated MOM6 angle and angle_dx from Hgrid angle_dx\")\n", "plt.show()" ] From cc957cf4ffe5a5d83853d932237a2b8513513216 Mon Sep 17 00:00:00 2001 From: Manish Venumuddula <80477243+manishvenu@users.noreply.github.com> Date: Wed, 20 Nov 2024 15:55:26 -0700 Subject: [PATCH 12/87] Clean up testing (#37) * Remove extra directories created * Black * Clean up created dirs --- tests/test_config.py | 25 +++--- tests/test_expt_class.py | 12 +-- tests/test_manish_branch.py | 146 ++++++++++++++++++++++++------------ 3 files changed, 115 insertions(+), 68 deletions(-) diff --git a/tests/test_config.py b/tests/test_config.py index c5621418..eefc4297 100644 --- a/tests/test_config.py +++ b/tests/test_config.py @@ -6,7 +6,7 @@ import shutil -def test_write_config(): +def test_write_config(tmp_path): expt_name = "testing" latitude_extent = [16.0, 27] @@ -17,6 +17,7 @@ def test_write_config(): ## Place where all your input files go input_dir = Path( os.path.join( + tmp_path, expt_name, "inputs", ) @@ -25,11 +26,12 @@ def test_write_config(): ## Directory where you'll run the experiment from run_dir = Path( os.path.join( + tmp_path, expt_name, "run_files", ) ) - data_path = Path("data") + data_path = Path(tmp_path / "data") for path in (run_dir, input_dir, data_path): os.makedirs(str(path), exist_ok=True) @@ -49,7 +51,7 @@ def test_write_config(): expt_name="test", boundaries=["south", "north"], ) - config_dict = expt.write_config_file() + config_dict = expt.write_config_file(tmp_path / "testing_config.json") assert config_dict["longitude_extent"] == tuple(longitude_extent) assert config_dict["latitude_extent"] == tuple(latitude_extent) assert config_dict["date_range"] == date_range @@ -80,7 +82,7 @@ def test_write_config(): shutil.rmtree(data_path) -def test_load_config(): +def test_load_config(tmp_path): expt_name = "testing" @@ -92,6 +94,7 @@ def test_load_config(): ## Place where all your input files go input_dir = Path( os.path.join( + tmp_path, expt_name, "inputs", ) @@ -100,11 +103,12 @@ def test_load_config(): ## Directory where you'll run the experiment from run_dir = Path( os.path.join( + tmp_path, expt_name, "run_files", ) ) - data_path = Path("data") + data_path = Path(tmp_path / "data") for path in (run_dir, input_dir, data_path): os.makedirs(str(path), exist_ok=True) @@ -122,9 +126,11 @@ def test_load_config(): mom_input_dir=input_dir, toolpath_dir="", ) - path = "testing_config.json" + path = os.path.join(tmp_path, "testing_config.json") config_expt = expt.write_config_file(path) - new_expt = rmom6.create_experiment_from_config(os.path.join(path)) + new_expt = rmom6.create_experiment_from_config( + os.path.join(path), mom_input_folder=tmp_path, mom_run_folder=tmp_path + ) assert str(new_expt) == str(expt) print(new_expt.vgrid) print(expt.vgrid) @@ -136,8 +142,3 @@ def test_load_config(): assert os.path.exists(new_expt.mom_input_dir / "hgrid.nc") & os.path.exists( new_expt.mom_input_dir / "vcoord.nc" ) - shutil.rmtree(run_dir) - shutil.rmtree(input_dir) - shutil.rmtree(data_path) - shutil.rmtree(new_expt.mom_run_dir) - shutil.rmtree(new_expt.mom_input_dir) diff --git a/tests/test_expt_class.py b/tests/test_expt_class.py index aff3a4b8..d459aed3 100644 --- a/tests/test_expt_class.py +++ b/tests/test_expt_class.py @@ -60,8 +60,8 @@ def test_setup_bathymetry( number_vertical_layers=number_vertical_layers, layer_thickness_ratio=layer_thickness_ratio, depth=depth, - mom_run_dir=mom_run_dir, - mom_input_dir=mom_input_dir, + mom_run_dir=tmp_path / mom_run_dir, + mom_input_dir=tmp_path / mom_input_dir, toolpath_dir=toolpath_dir, hgrid_type=hgrid_type, ) @@ -255,8 +255,8 @@ def test_ocean_forcing( number_vertical_layers=number_vertical_layers, layer_thickness_ratio=layer_thickness_ratio, depth=depth, - mom_run_dir=mom_run_dir, - mom_input_dir=mom_input_dir, + mom_run_dir=tmp_path / mom_run_dir, + mom_input_dir=tmp_path / mom_input_dir, toolpath_dir=toolpath_dir, hgrid_type=hgrid_type, ) @@ -452,8 +452,8 @@ def test_rectangular_boundaries( number_vertical_layers=number_vertical_layers, layer_thickness_ratio=layer_thickness_ratio, depth=depth, - mom_run_dir=mom_run_dir, - mom_input_dir=mom_input_dir, + mom_run_dir=tmp_path / mom_run_dir, + mom_input_dir=tmp_path / mom_input_dir, toolpath_dir=toolpath_dir, hgrid_type=hgrid_type, boundaries=["east"], diff --git a/tests/test_manish_branch.py b/tests/test_manish_branch.py index 8724770e..98755c8d 100644 --- a/tests/test_manish_branch.py +++ b/tests/test_manish_branch.py @@ -154,24 +154,9 @@ def dummy_bathymetry_data(): class TestAll: - @classmethod - def setup_class(self): # tmp_path is a pytest fixture - expt_name = "testing" - ## User-1st, test if we can even read the angled nc files. - self.dump_files_dir = Path("testing_outputs") - os.makedirs(self.dump_files_dir, exist_ok=True) - self.expt = rmom6.experiment.create_empty( - expt_name=expt_name, - mom_input_dir=self.dump_files_dir, - mom_run_dir=self.dump_files_dir, - ) - - @classmethod - def teardown_class(cls): - shutil.rmtree(cls.dump_files_dir) @pytest.fixture(scope="module") - def full_legit_expt_setup(self, dummy_bathymetry_data): + def full_legit_expt_setup(self, dummy_bathymetry_data, tmp_path): expt_name = "testing" @@ -183,6 +168,7 @@ def full_legit_expt_setup(self, dummy_bathymetry_data): ## Place where all your input files go input_dir = Path( os.path.join( + tmp_path, expt_name, "inputs", ) @@ -191,11 +177,12 @@ def full_legit_expt_setup(self, dummy_bathymetry_data): ## Directory where you'll run the experiment from run_dir = Path( os.path.join( + tmp_path, expt_name, "run_files", ) ) - data_path = Path("data") + data_path = Path(tmp_path / "data") for path in (run_dir, input_dir, data_path): os.makedirs(str(path), exist_ok=True) bathy_path = data_path / "bathymetry.nc" @@ -218,50 +205,102 @@ def full_legit_expt_setup(self, dummy_bathymetry_data): ) return expt - def test_full_legit_expt_setup(self, full_legit_expt_setup): - assert str(full_legit_expt_setup) + def test_full_legit_expt_setup(self, tmp_path, dummy_bathymetry_data): + expt_name = "testing" + latitude_extent = [16.0, 27] + longitude_extent = [192, 209] + + date_range = ["2005-01-01 00:00:00", "2005-02-01 00:00:00"] + + ## Place where all your input files go + input_dir = Path( + os.path.join( + tmp_path, + expt_name, + "inputs", + ) + ) - # @pytest.mark.skipif( - # IN_GITHUB_ACTIONS, reason="Test doesn't work in Github Actions." - # ) - def test_tides(self, dummy_tidal_data): + ## Directory where you'll run the experiment from + run_dir = Path( + os.path.join( + tmp_path, + expt_name, + "run_files", + ) + ) + data_path = Path(tmp_path / "data") + for path in (run_dir, input_dir, data_path): + os.makedirs(str(path), exist_ok=True) + bathy_path = data_path / "bathymetry.nc" + bathymetry = dummy_bathymetry_data + bathymetry.to_netcdf(bathy_path) + ## User-1st, test if we can even read the angled nc files. + expt = rmom6.experiment( + longitude_extent=longitude_extent, + latitude_extent=latitude_extent, + date_range=date_range, + resolution=0.05, + number_vertical_layers=75, + layer_thickness_ratio=10, + depth=4500, + minimum_depth=5, + mom_run_dir=run_dir, + mom_input_dir=input_dir, + toolpath_dir="", + ) + assert str(expt) + + def test_tides(self, dummy_tidal_data, tmp_path): """ Test the main setup tides function! """ - + expt_name = "testing" + ## User-1st, test if we can even read the angled nc files. + expt = rmom6.experiment.create_empty( + expt_name=expt_name, + mom_input_dir=tmp_path, + mom_run_dir=tmp_path, + ) # Generate Fake Tidal Data ds_h, ds_u = dummy_tidal_data # Save to Fake Folder - ds_h.to_netcdf(self.dump_files_dir / "h_fake_tidal_data.nc") - ds_u.to_netcdf(self.dump_files_dir / "u_fake_tidal_data.nc") + ds_h.to_netcdf(tmp_path / "h_fake_tidal_data.nc") + ds_u.to_netcdf(tmp_path / "u_fake_tidal_data.nc") # Set other required variables needed in setup_tides # Lat Long - self.expt.longitude_extent = (-5, 5) - self.expt.latitude_extent = (0, 30) + expt.longitude_extent = (-5, 5) + expt.latitude_extent = (0, 30) # Grid Type - self.expt.hgrid_type = "even_spacing" - # Dates - self.expt.date_range = ("2000-01-01", "2000-01-02") - self.expt.segments = {} + expt.hgrid_type = "even_spacing" + # DatesÆ’ + expt.date_range = ("2000-01-01", "2000-01-02") + expt.segments = {} # Generate Hgrid Data - self.expt.resolution = 0.1 - self.expt.hgrid = self.expt._make_hgrid() + expt.resolution = 0.1 + expt.hgrid = expt._make_hgrid() # Create Forcing Folder - os.makedirs(self.dump_files_dir / "forcing", exist_ok=True) + os.makedirs(tmp_path / "forcing", exist_ok=True) - self.expt.setup_boundary_tides( - self.dump_files_dir / "h_fake_tidal_data.nc", - self.dump_files_dir / "u_fake_tidal_data.nc", + expt.setup_boundary_tides( + tmp_path / "h_fake_tidal_data.nc", + tmp_path / "u_fake_tidal_data.nc", ) - def test_change_MOM_parameter(self): + def test_change_MOM_parameter(self, tmp_path): """ Test the change MOM parameter function, as well as read_MOM_file and write_MOM_file under the hood. """ - + expt_name = "testing" + ## User-1st, test if we can even read the angled nc files. + expt = rmom6.experiment.create_empty( + expt_name=expt_name, + mom_input_dir=tmp_path, + mom_run_dir=tmp_path, + ) # Copy over the MOM Files to the dump_files_dir base_run_dir = Path( os.path.join( @@ -271,22 +310,29 @@ def test_change_MOM_parameter(self): ) ) shutil.copytree( - base_run_dir / "common_files", self.expt.mom_run_dir, dirs_exist_ok=True + base_run_dir / "common_files", expt.mom_run_dir, dirs_exist_ok=True ) - MOM_override_dict = self.expt.read_MOM_file_as_dict("MOM_override") - og = self.expt.change_MOM_parameter("DT", "30", "COOL COMMENT") - MOM_override_dict_new = self.expt.read_MOM_file_as_dict("MOM_override") + MOM_override_dict = expt.read_MOM_file_as_dict("MOM_override") + og = expt.change_MOM_parameter("DT", "30", "COOL COMMENT") + MOM_override_dict_new = expt.read_MOM_file_as_dict("MOM_override") assert MOM_override_dict_new["DT"]["value"] == "30" assert MOM_override_dict["DT"]["value"] == og assert MOM_override_dict_new["DT"]["comment"] == "COOL COMMENT\n" - def test_properties_empty(self): + def test_properties_empty(self, tmp_path): """ Test the properties """ - dss = self.expt.era5 - dss_2 = self.expt.tides_boundaries - dss_3 = self.expt.ocean_state_boundaries - dss_4 = self.expt.initial_condition - dss_5 = self.expt.bathymetry_property + expt_name = "testing" + ## User-1st, test if we can even read the angled nc files. + expt = rmom6.experiment.create_empty( + expt_name=expt_name, + mom_input_dir=tmp_path, + mom_run_dir=tmp_path, + ) + dss = expt.era5 + dss_2 = expt.tides_boundaries + dss_3 = expt.ocean_state_boundaries + dss_4 = expt.initial_condition + dss_5 = expt.bathymetry_property print(dss, dss_2, dss_3, dss_4, dss_5) From 3bf61970ee6e668f6576dd2566217febfa129b43 Mon Sep 17 00:00:00 2001 From: manishvenu Date: Wed, 20 Nov 2024 15:57:53 -0700 Subject: [PATCH 13/87] Rand --- .../testing_to_be_deleted/angle_calc.md | 16 +- .../angle_calc_mom6.ipynb | 1901 ++++++++++++++--- 2 files changed, 1570 insertions(+), 347 deletions(-) diff --git a/regional_mom6/testing_to_be_deleted/angle_calc.md b/regional_mom6/testing_to_be_deleted/angle_calc.md index 4f40e8e9..6c77780c 100644 --- a/regional_mom6/testing_to_be_deleted/angle_calc.md +++ b/regional_mom6/testing_to_be_deleted/angle_calc.md @@ -1,11 +1,21 @@ -# MOM6 Angle Calculation Steps +# MOM6 Angle Calculation Steps +## Process of calculation -> Only works on t-points 1. Calculate pi/4rads / 180 degress = Gives a 1/4 conversion of degrees to radians. I.E. multiplying an angle in degrees by this gives the conversion to radians at 1/4 the value. 2. Figure out the longitudunal extent of our domain, or periodic range of longitudes. For global cases it is len_lon = 360, for our regional cases it is given by the hgrid. 3. At each point on our hgrid, we find the point to the left, bottom left diag, bottom, and itself. We adjust each of these longitudes to be in the range of len_lon around the point itself. (module_around_point) -4. We then find the lon_scale, which is the "trigonometric scaling factor converting changes in longitude to equivalent distances in latitudes". Whatever that actually means is we add the latitude of all four of these points from part 3 and basically average it and convert to radians. We then take the cosine of it. +4. We then find the lon_scale, which is the "trigonometric scaling factor converting changes in longitude to equivalent distances in latitudes". Whatever that actually means is we add the latitude of all four of these points from part 3 and basically average it and convert to radians. We then take the cosine of it. As I understand it, it's a conversion of longitude to equivalent latitude distance. 5. Then we calculate the angle. This is a simple arctan2 so y/x. 1. The "y" component is the addition of the difference between the diagonals in longitude of lonB multiplied by the lon_scale, which is our conversion to latitude. 2. The "x" component is the same addition of differences in latitude. 3. Thus, given the same units, we can call arctan to get the angle in degrees -6. Challenge: Because this takes the left & bottom points, we can't calculate the angle at the left and bottom edges. Therefore, we can always calculate it the other way by using the right and top points. + +## Conversion to Q points +1. (Recommended by Gustavo) +2. We use XGCM to interpolate from the t-points to all other points in the supergrid. + +## Implementation + +1. Direct implementation of MOM6 grid angle initalization function (and modulo_around_point) +2. Wrap direct implementation combined with XGCM interpolation for grid angles + diff --git a/regional_mom6/testing_to_be_deleted/angle_calc_mom6.ipynb b/regional_mom6/testing_to_be_deleted/angle_calc_mom6.ipynb index f824f5cf..55b7ff58 100755 --- a/regional_mom6/testing_to_be_deleted/angle_calc_mom6.ipynb +++ b/regional_mom6/testing_to_be_deleted/angle_calc_mom6.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 2, + "execution_count": 33, "metadata": {}, "outputs": [], "source": [ @@ -13,7 +13,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 101, "metadata": {}, "outputs": [ { @@ -43,218 +43,1428 @@ "source": [ "\n", "hgrid = xr.open_dataset(\"/glade/u/home/manishrv/documents/nwa12_0.1/mom_input/n3b.clean/hgrid.nc\")\n", + "ocean_geo = xr.open_dataset(\"/glade/u/home/manishrv/manish_scratch_symlink/n3b.clean/run/ocean_geometry.nc\")\n", "print(hgrid)" ] }, { "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "k = 2\n", - "kp2 = k //2\n", - "tlon = hgrid.x[kp2::k,kp2::k]\n", - "tlat = hgrid.y[kp2::k,kp2::k]\n", - "\n", - "# U point locations\n", - "ulon = hgrid.x[kp2::k,::k]\n", - "ulat = hgrid.y[kp2::k,::k]\n", - "\n", - "# V point locations\n", - "vlon = hgrid.x[::k,kp2::k]\n", - "vlat = hgrid.y[::k,kp2::k]\n", - "\n", - "# Corner point locations\n", - "qlon = hgrid.x[::k,::k]\n", - "qlat = hgrid.y[::k,::k]\n" - ] - }, - { - "cell_type": "code", - "execution_count": 5, + "execution_count": 97, "metadata": {}, "outputs": [ { "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.DataArray 'lath' (lath: 780)> Size: 6kB\n",
+       "array([ 5.242669,  5.325648,  5.408616, ..., 53.820237, 53.85652 , 53.892753])\n",
+       "Coordinates:\n",
+       "  * lath     (lath) float64 6kB 5.243 5.326 5.409 5.492 ... 53.82 53.86 53.89\n",
+       "Attributes:\n",
+       "    long_name:       Latitude\n",
+       "    units:           degrees_north\n",
+       "    cartesian_axis:  Y
" + ], + "text/plain": [ + " Size: 6kB\n", + "array([ 5.242669, 5.325648, 5.408616, ..., 53.820237, 53.85652 , 53.892753])\n", + "Coordinates:\n", + " * lath (lath) float64 6kB 5.243 5.326 5.409 5.492 ... 53.82 53.86 53.89\n", + "Attributes:\n", + " long_name: Latitude\n", + " units: degrees_north\n", + " cartesian_axis: Y" + ] + }, + "execution_count": 97, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ocean_geo.lath" + ] + }, + { + "cell_type": "code", + "execution_count": 100, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 5.20117513, 5.24266887, 5.28415984, ..., 52.74478451,\n", + " 52.76099408, 52.77719011])" + ] + }, + "execution_count": 100, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "hgrid.y[:,0].values" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [], + "source": [ + "k = 2\n", + "kp2 = k //2\n", + "offset_one_by_two_y = slice(kp2, len(hgrid.x.nyp),k)\n", + "offset_one_by_two_x = slice(kp2, len(hgrid.x.nxp),k)\n", + "by_two_x = slice(0, len(hgrid.x.nxp),k)\n", + "by_two_y = slice(0, len(hgrid.x.nyp),k)\n", + "t_points = (offset_one_by_two_y,offset_one_by_two_x)\n", + "u_points = (offset_one_by_two_y,by_two_x)\n", + "v_points = (by_two_y,offset_one_by_two_x)\n", + "q_points = (by_two_y,by_two_x)\n", + "tlon = hgrid.x[t_points]\n", + "tlat = hgrid.y[t_points]\n", + "\n", + "# U point locations\n", + "ulon = hgrid.x[u_points]\n", + "ulat = hgrid.y[u_points]\n", + "\n", + "# V point locations\n", + "vlon = hgrid.x[v_points]\n", + "vlat = hgrid.y[v_points]\n", + "\n", + "# Corner point locations\n", + "qlon = hgrid.x[q_points]\n", + "qlat = hgrid.y[q_points]\n" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(781, 741)" + ] + }, + "execution_count": 36, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "qlon.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 37, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "hgrid[\"angle_dx\"].plot()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " pi_720deg = atan(1.0) / 180.0\n", + " len_lon = 360.0 ; if (G%len_lon > 0.0) len_lon = G%len_lon\n", + " do j=G%jsc,G%jec ; do i=G%isc,G%iec\n", + " do n=1,2 ; do m=1,2\n", + " lonB(m,n) = modulo_around_point(G%geoLonBu(I+m-2,J+n-2), G%geoLonT(i,j), len_lon)\n", + " enddo ; enddo\n", + " lon_scale = cos(pi_720deg*((G%geoLatBu(I-1,J-1) + G%geoLatBu(I,J)) + &\n", + " (G%geoLatBu(I,J-1) + G%geoLatBu(I-1,J)) ) )\n", + " angle = atan2(lon_scale*((lonB(1,2) - lonB(2,1)) + (lonB(2,2) - lonB(1,1))), &\n", + " (G%geoLatBu(I-1,J) - G%geoLatBu(I,J-1)) + &\n", + " (G%geoLatBu(I,J) - G%geoLatBu(I-1,J-1)) )\n", + " G%sin_rot(i,j) = sin(angle) ! angle is the clockwise angle from lat/lon to ocean\n", + " G%cos_rot(i,j) = cos(angle) ! grid (e.g. angle of ocean \"north\" from true north)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " function modulo_around_point(x, xc, Lx) result(x_mod)\n", + " real, intent(in) :: x !< Value to which to apply modulo arithmetic [A]\n", + " real, intent(in) :: xc !< Center of modulo range [A]\n", + " real, intent(in) :: Lx !< Modulo range width [A]\n", + " real :: x_mod !< x shifted by an integer multiple of Lx to be close to xc [A].\n", + "\n", + " if (Lx > 0.0) then\n", + " x_mod = modulo(x - (xc - 0.5*Lx), Lx) + (xc - 0.5*Lx)\n", + " else\n", + " x_mod = x\n", + " endif\n", + " end function modulo_around_point" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "This is a regional case\n" + ] + } + ], + "source": [ + "# Direct Translation\n", + "pi_720deg = np.arctan(1)/180 # One quarter the conversion factor from degrees to radians\n", + " \n", + "## Check length of longitude\n", + "len_lon = 360.0\n", + "G_len_lon = hgrid.x.max() - hgrid.x.min()\n", + "if G_len_lon != 360:\n", + " print(\"This is a regional case\")\n", + " len_lon = G_len_lon\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [], + "source": [ + "## Iterate it, j=G%jsc,G%jec ; do i=G%isc,G%iec mean we iterate from jsc to jec and isc to iec\n", + "## Then you iterate around it, 1,2 and 1,2\n", + "\n", + "# In this way we wrap each longitude in the correct way even if we are at the seam like 360, I still don't understand it as much\n", + "\n", + "\n", + "def modulo_around_point(x, xc, Lx):\n", + " \"\"\"\n", + " This function calculates the modulo around a point, for use in cases where we are wrapping around the globe at the seam. Return the modulo value of x in an interval [xc-(Lx/2) xc+(Lx/2)]. If Lx<=0, then it returns x without applying modulo arithmetic.\n", + " Parameters\n", + " ----------\n", + " x: float\n", + " Value to which to apply modulo arithmetic\n", + " xc: float\n", + " Center of modulo range\n", + " Lx: float\n", + " Modulo range width\n", + " Returns\n", + " -------\n", + " float\n", + " x shifted by an integer multiple of Lx to be close to xc, \n", + " \"\"\"\n", + " if Lx <= 0:\n", + " return x\n", + " else:\n", + " return ((x - (xc - 0.5*Lx)) % Lx )- Lx/2 + xc\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Size: 5MB\n", + "array([[0. , 0. , 0. , ..., 0. , 0. ,\n", + " 0. ],\n", + " [0. , 0. , 0. , ..., 0. , 0. ,\n", + " 0. ],\n", + " [0. , 0. , 0. , ..., 0. , 0. ,\n", + " 0. ],\n", + " ...,\n", + " [4.43651643, 4.47489525, 4.5132071 , ..., 4.40963338, 4.37648025,\n", + " 4.34327766],\n", + " [4.45746382, 4.49601954, 4.53450787, ..., 4.429975 , 4.39669398,\n", + " 4.36336333],\n", + " [4.47848207, 4.51721524, 4.5558806 , ..., 4.45038282, 4.41697365,\n", + " 4.38351466]])\n", + "Dimensions without coordinates: nyp, nxp\n" + ] + } + ], + "source": [ + "angles_arr_v2 = np.zeros((len(tlon.nyp), len(tlon.nxp)))\n", + "\n", + "# Compute lonB for all points\n", + "lonB = np.zeros((2, 2, len(tlon.nyp), len(tlon.nxp)))\n", + "\n", + "# Vectorized computation of lonB\n", + "for n in np.arange(0,2):\n", + " for m in np.arange(0,2):\n", + " lonB[m, n] = modulo_around_point(qlon[np.arange(m,(m-1+len(qlon.nyp))), np.arange(n,(n-1+len(qlon.nxp)))], tlon, len_lon)\n", + "\n", + "# Compute lon_scale\n", + "lon_scale = np.cos(pi_720deg* ((qlat[0:-1, 0:-1] + qlat[1:, 1:]) + (qlat[1:, 0:-1] + qlat[0:-1, 1:])))\n", + "\n", + "\n", + "\n", + "# Compute angle\n", + "angle = np.arctan2(\n", + " lon_scale * ((lonB[0, 1] - lonB[1, 0]) + (lonB[1, 1] - lonB[0, 0])),\n", + " (qlat[:-1, :-1] - qlat[1:, 1:]) + (qlat[1:, 0:-1] - qlat[0:-1, 1:])\n", + ")\n", + "# Assign angle to angles_arr\n", + "angles_arr_v2 = np.rad2deg(angle) - 90\n", + "# Print the result\n", + "print(angles_arr_v2)" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [], + "source": [ + "# Create the new DataArray with the new dimensions\n", + "t_angles = xr.DataArray(\n", + " angles_arr_v2,\n", + " dims=[\"qy\", \"qx\"],\n", + " coords={\n", + " \"qy\": tlon.nyp.values,\n", + " \"qx\": tlon.nxp.values,\n", + " }\n", + ")\n", + "\n", + "\n", + "\n", + "hgrid[\"t_angle_dx_mom6\"] = t_angles\n", + "hgrid[\"t_angle_dx_mom6\"].attrs[\"_FillValue\"] = np.nan\n", + "hgrid[\"t_angle_dx_mom6\"].attrs[\"units\"] = \"deg\"\n", + "hgrid[\"t_angle_dx_mom6\"].attrs[\"description\"] = \"MOM6 calculates angles internally, this field replicates that for rotating boundary conditions. Use this over other angle fields for MOM6 applications\"\n" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 43, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjMAAAGwCAYAAABcnuQpAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAADCyElEQVR4nO29e5wVxZn//+kzwHARJoLCOOtEUYlGwcSAi2A2YhBd4iVZ84pJzMXb7g9XgyKgCTH5SvI1YEy8fk3M6tfgbQ3Z16pZs5sLuKv4JepqEBMhiRplxQuzZBUZMDjAnPr90V3VVdVV1dWXc5t5Pq/XgdNVz/NU9ZnT1e/zVHV3wBhjIJFIJBKJRGpRVRrdARKJRCKRSKQiIpghkUgkEonU0iKYIZFIJBKJ1NIimCGRSCQSidTSIpghkUgkEonU0iKYIZFIJBKJ1NIimCGRSCQSidTSGtLoDjSDqtUq3njjDYwePRpBEDS6OyQSiURqYjHGsGPHDnR1daFSqV1O4N1338Xu3bsLxxk2bBiGDx9eQo+aVwQzAN544w10d3c3uhskEolEaiG9+uqrOPDAA2sS+91338XEg/ZBz9b+wrE6OzuxadOmAQ00BDMARo8eDQCYNO9/oTJ8OBAArAKgAjD+Pgjfy/+jEtchYLGdsA9vrhxuM+ET2zIEHOorTMQJohcCIIjKKhUmYlSiev6DoK1SjXzC9xWwMBS3C1hcHm0PqVRD32hbeYG/r4a+qKISVENbhPs0pFJFGxgCbhMwVBC+BxD5MLQFVQQI/68EVbQB0f9RfIT94O20BVXRRltUX4niQfiGfQGASuTD38u+bWDKdtivcDuI2pPL4r4zrTz6E/Ht6E/WJiXx2hAodWF9bFCB+b1pu82QHaw4ZoR1/1qqCvsNw6vR5ymrX7vBuO4vb8vvk35ReWTTz5J11ehzqDJuG38u/aIuULb7o8+VsSAuYxUlXj8Cpawa+cRlFfSzQMSqRuX90bdbtq9KbfSjgioL48U+AaqsAn76qrIK+ll4RIv2ora4bz8LxH4xVolihL5VBFF9+J4htK0y7s+34xeL2lDKJFsmlTFuj7i8WpVtEL1CO8YCoBqWAwCrVsL33IYFCP/E0f8MAAvAquH/gVQWNayUB5DqGBBUo/8ZgKrsH/pGhzwC/iXiw2xV85fjMKDa9y6e/7/fFOeOWmj37t3o2dqPV9YdjDGj82d/endUcdDU/8Lu3bsJZga6+NTSkKHDURk6XAEZDiwCZHSwkbcrLPaRwSVQbSD9zyrRyZUDTwUAGIIKhxkOOUBQqSIIgKASwQ7CehbBDn+PCHwYYvAJyyPoAUM1AhcmvYKgKgCI2wX8yA4YGKK2pO0gqMZHePReBhv+vwwpoU80tEpgAwABqgpoVCK/igwsUdy4XgIz8b4ax9AAh8dpC+KTb1sEcOF7P8gJ65Ask75bMfAwATwA09CEaQDDDIDSL/mbVUuocUEMEEOG7qMPMDKk6Ogj//6ssECxa+Pl0SfXJjUXg4kKLIH0eQSoGOsCCUjA7aOy2L8ilfGDW/orsgpY1LN+ceCHYMFb7mcVBKggEO1XUIkgpS3qR7/0Hhx8WOhTjeJX5QEm8UsrbjMEg0oIB3zvI4gJWIAAQfi//IrKmIgdlzPJDuJ/hD+bhD2AakW857aI2g4iYKlWA/E5cBjhgBKI9+E2B52ABRFQyPWRT/RF4sACxPARDku8PxK0yMOWDD6SrxojtlNs67AsYZ/RAfYZnb+dag3HhWYSwYws6YvNIoYQB1P4X3hAwrLNAgRgqi8CYRSXITzoKgxBNQiPT8bCwbPKgEr4SySosDBmJQQTVCtApRr6cnhi0WBZDQ+stkpVvK8EDP1Rm20VoL9aAQtCkBmCaviLTcrS7EUFFWbI0rAgztRE29Vouw0BKoyhGlRRQYA2/j4I0AaGKgJUwFCNYgDhwVVhFeFTlU7e4aBdlX4VV9AmbfNafuJqi7ZD26o44VdRQb8ENgD/RcvBJhC/hmPfqugfAPRziGFh+R6E0LIHEuBEf9A9CBKZnLBNKdsgnfDbtPGlyqBJB56o/ZTBsxZAkwoylse7JWFFtevX3KqKrQQzDnAJ683ZFl6u1CnwopZXNX8986LGjrMv/cyUrQlE9oX3pd+QgZHf675yBkbuB8+sxL5x5qVfqlMzL/ZMTJzRCrC3WklkYgCITEt/lEnhmRgA6K/GWZo4GxNnbXi2hWdsZEjhdTFAIQEyAlh8QIZp0KH9r5QjWR7ubNJWiYnYvx7qZ9XEsZLVfzCIYEaW/mWO3ivAUg2zKIwzigQ6cXqUKfECaTOoBiIbE/5qYVHcsFwHGgQIf0XoQIMgHP2j/6LfguivVkLwqISw0laJfqxEgINKOOzuRWTHgL3ch09BoSrgQy4LW6kKQJGhZigQNQL0szYr1AAQsXWoCe0QAU4FlSA8iKuIU/hton0+8PuBjSiTwGYP5KyNfIKoirYAYA8qAlRsgKPWxSOPDDlADDp7mJrN2WOAl7Bf6vYexlIyNBFQOSx85TMEmjIyQBJUTPH6tf1Ig5bQJlmuw4sOLmHbSXgJy5MAE4NJEmD6tboQMFQI4T5Vyb8aZV7iONJ7ASLJaaS4jRgsuL8OMbzOBjE8tg4yvlNKHFTkKSUZXORt7gNEY5sELIVBRs6+gIOGBWSkqSVlqgiQ2pOABVDiJCBI9quTqmCpPyjS/AeDCGYk8S8q/58hCSxytiammMinCrBKDCxBtC0yKTxDw4GmivDsxiJYMQANGAtxxwI0AcL6KsJUbKUSZTGqFQQBE1kaVKqoMCayM3zqqRplXxhjUcwQdABEAANRJmdpOLiEHapEJ/UwSwPAmqkJPyY1WyNDTRjNnK3hvjxbE8dKBxtE/ZPBBoARbnj2Q8/chDHU7A3gBhy5PrRJBx1ZVUPWwwY+Jukw5CPfX4Eu2NEhBDDDimnblFEJ31ecNrasi1pnz76E24HWjgowtgwMjykDTOyfzMLwGHIWRo+RJRMT+5gzMfwzywMx3JeDDM/OCFhhgZKdYVBBRQcZFmVQAJhBhsMLYAQZOSsiQEafBuIgpEFJKrBA2tbtoMUgNZUIZmTpX2JI4AI1A8NBReKZJARJ/wMSxPADEExkV0R7OtAEYaUJaEIoiUyiNTfVCGJQCdtoq4Q/RwTESL/c+6P6Ku98tSLW0lQCJgFMtqknAI7pJwYEFVSZGWoAKNkaANZpqErA0M/8wCYui/vH4wEq3MQnFglCNMDh9mEsO+AAMeTwfZEl24GpEAQkgUeWCX507ZFcbXEAM3ykKTk1Zo9ly7CY6tOgBfDLuoR16fAi18vTR7zeBDB82zWNxOPpAMNjyFNJPIbcLw4lHGB4vLRMTBzLPKVkghjepyLZGNO0EsR2CClqNgYIM9lIgEwglekZFBU6LBkZyc8HZHSAUbI1Br96qgrT0vps/oNBBDOSAglgBIQwDUiiMgVYIH2/RQxt/YzUBgs4DEk1fA0NNKARLUSWHH6iesZrpHU0YAGqVUSZmYpYBIxKBDF8HyOA0bM0MEwzVcBEpkbUWaBGzdxE4GKAmn60JdbVAFCyNW1BVUw9JaahNIhwZWzC+kABm7AsCTdhhkZdIKwDjrx2hZ9AuF8YTwaY2FZebwOooBPaJkdKBXhkGeDHpT05gMUmF/zooGKyl4FF90mDFpuNDi5qnT+8qPbmDAzvs56BUWOa18IkfeOrksR2yRDD288zpQQgAS48O8PrBMiIDI2UuamqAJMbZKSMjg4sJpDR17qEnbGsn7HAjrCBob5O6mfMui7N138wiGBGFv/iBlFGJjCsi4nsBPQA8foZSP9HsBJUmZrBqUYLeoWPG2jAQvtQQYQ24ZQUBxdE00h8AQ0LosQMi6edKgCqVW4e2fN9k9bS8ImeqEPKx8MXCAPItkg4YIjm26K+hFBTCTg0xetqwtbt2ZqwPjkNFZYnFw6H9TyuPPWUzNqE5THc7GFt4hJw07QUlyuDA6iQE8auSnUVbe2MCjsAImgx/7rSp7TqJRfMuEDF5p8FWkKbZCbHmK1JgRdu48q+cHvTFBLvo2saSbzXAIb30zaVxNvwWRPD+5wXYnifimZjTNNKRpDh34kSQEa9bFoCGflqJO1/I+zIh5HsA7W+EdkZUroIZjTxzImSkeFfYqjAoqQlOZzwBcKiPiIjJpfztS78QJEWBWtAgyAEFxvQBIF5HU0VYV1VZF7CK5p4h3nGJmwuuZYmvPS7AsaYMvXEX4mDWTBZmImxXfkEQJ1+UjJBAdoCZpyC6kdc1m+YhgpbTi4cBuKTj35VVOjrDzdhuWGayZHBiW2SmRyufg1UTODiurzSmrmpkUxwwmWcYtL2F1CBRfdLg5akjQousm1a5kWOJWdOuI9tDYwa2z6NFNolF/TyvshZGG7LY6etieH2Puti5LqsC3yBnCBTjX0hlctgINbP6CDDD4E0kFH+D5QyxQZJkDHZJCAHyXoRq06iBcB+IpjRxb/cQZx5gXTuljMyvJx/8VlFzeSIeg4ljK+LAVCJgQaAepWTDDTRvwmgYTBeuh3ecyaCHSZlbwDlkm0OOEEQJNbSVIFwMArUBcL8Mm51mim5ngaANVMDAMZLusHi6SjDFBQQT28BSE5DBVX0s7ZExoaDDfeRwYaXhfudDW6ANimGfAJ0Q05oYwed0DZ58tezO4qY2latZYITLh1SAD/AyQItYbkdXOQy2c4n+xLGcQOMuljZPo3EY+hrYXi9DjFVJY4ZYnibpukkEceSoXFBTFifIxsDCFCpVg3ZGEjAok8rSe8TIMOhwQQyyuXYGsgoVzhpEGICIMANOa76OqkKlhgzsvoPBhHMSJJvliRPDQX8qmQOLNX4f1QgLqGWy0V9EL4X2ZggytBUAQQxoHDoYQFCAInWwIQ3rQvEjxF+R2AE6i+fQNwhOBx4gujKpICFGZqgEr/nEGOEmghIggDmq576A3EX4YqAE/3Ower0U2wT3fCOBdgrlbUJ3/CDC+8GzCKb+A7De9GGCgu397A2cZdhID6Zh1cjRe+Dqrh6qBJUsQdtynYbqtjD2kT/gHgNi4jBtPhMhhXVh8cV9QbbsI/pmRhTWcU1KNUJaFwgA5gzSPq0kylOGqgIO8s0kR7HuAjYA1rC7WTmhW/bQChtCkn4p8CLqNPsTFNGcb1un5xO4nVZ1sX4ZGJCPyTu5CvXOy+7liFGhoZqDEq2bIxcp9+hV4EV23STfgVUVbUPdF+pvs7JUJKHCGYk8fQigzSVxMXs/wfSZuisApFIqXKgkaeiOLQgnnYS62GA8CB2LQyOUkWhTxwH1Yp0pAZiLU0A6Z40LFCgBpUoMxOF5+tpbJdy8+mn+AMM/RKLh8WHKU1BRWVV1mafhgqYcs8aAMZLvIH4BOJaZxP6MLEtn0BNi4kBewYnLFOzOKF9sj60kdfMqCd8eW2OyV74pcCKa/qnLJnARKn3mFIK7dS+6pdD29pzTROF5UGizAYvclv6uhelzhNgbNmXOL6UWRGx0iFGBxX5fdpUEi8zQQzfpzSIAZB/bYxvNkYHGQ4iBUHGmpEx2CtTTdwXajx9uqkeomkmPxHM6BJEEX2hA8RXNwVJ2BH/Q92WCSfgIMEXBSN5lROgrqNRgEZfGBwwBPxKKIb4fjTifjZQFgcrU08IUEWcpQH4VA6UBcLyehpRj/iSbhPUKNkaeE5BBdG6GGaehqoE8aJhAMarocJlvW0R/MQwxdfZhG1GJwxtETFXfLVUPDXVFsUFknADuAEn9DFDzh4kMy/JdTNJMDFBj1IPx1RUSTKBiSwdUgAzACXXDZkzLXqb1vU0lqyLWqbCiqlMzr7Ibej3gpHb0K9EEnEsWRi+jz7TSLG/P8TI8dRppPLXxYR+yA4yYk2MZCM/Owl+IGOtg1puAhiTr5DDt95ZGbqayU8EM7KkL6wMJPL6GQEbTPtfL4cKK+J9FDhxlVNklQAafuRo62hYlQMNAO1+NPri4ABBdKk2n6aCeBSCaeqJ3z1YXk+jZ2k43PDsiA41kOpkqAFgvAJK2IJZszUy2PDpIn5DPgDWjA0HG7muX87aSOttADmLY8/c8HvchO2aL8O2QQ6QXEfSpp3wTcAT+rlhJe35TUWUlpUBkpBi83MBS1jvhhY9blrWxVbmk32R49oyMDyWbSEvt/edSorLzVcm6fWue8VwWx1iAGReF5M5GwPEtlUtGxPFhX4lE1JgRZ6C0qeKdJCR6o1TUCY/IAE4RhgiNZUIZiQpX3ZIYCJnWfhb6csvlyvrbaRMDrcRoCQDDQPiMVoDGhl3DEATzjTJ+MTfRQuAI3BR7kmDIBxA+FErTizRFE017IzP1FM4rRPG4jc1lqeZ+I6H2RcJdFiQgBp5CkrO1lSCanSPmBhs9Gmo8ONRMzaACjZtqKLK2hTYCuMlszZhfTximS4D57ItXrVBTuivrxkxgUsSTHTo0VXLG2T5wIwpM2OeZtL3P7DW22+iZ5uaClLL0uCFx5ezL/L+pQEMj226pFq3NZf7Q4w+nSS/951SAmAGmci3ltNKmUFGssuTkdGzM/q4b60ztVUHVaNXEf/BIIIZWdIXVgcWce8ZqFCiw4rsJ8BGtuGLhrlHFFQ8+iAqF0DDkLy5XoDoCqZoIFHW0YT+4j45YHGGh6dm+D1pIhvOPGqWBtapJxPUqDfdg3n6SYMaZW2NlJVJZGs02OFgIz86AYAhY5MEm9AuBioAqXDDY4c2TNkOy5IZHDkekAQBPetiWjirA09o5x6a8tzJN4vSp5lMfU72yWRng5ZknT3jIpcrZRZ4kdsyTR+FtmoGRW3DnIERZUYYsWVnNFhx1JkyMbzeZ3GvqYxDDK/zycbItvUCGfEbSV/Yi6RPGpCYQMaVtZHL66V+FLuaqYhvK4lgRpZ8QET/y8Ai30yP2yTu8Cv5iZhahgaSj7hsG5oNB5oAYq2NcgRF00gIkFxHA95Z3rw0/QQA0j1lYnDinZR+pUkQo09Fyetp+GXcyj1qAkQDWnL6SYYXIJnJMWZrOETwQZtPQwURACG+tDuMoYJN2G7oq2RtAhZfum2Bm7Bdc/YmtIv/Lj6QI6/F4TLBTj+Sct1vJmwnPXtSRGnt26528ruRnjnTEta5wUUudy0INq+lSc++yG2lZWC4jT6NpLZlzrTIfU6UWyDGtCaG2/hOKQHROd0EMYARZHwgBkB2kKlqAKGDjF5nARlj5sbwPgEyBjsdYII6rkPpZ0Cxp2aX15dmFsGMpED6YjMLsOjrZ8SBCOm7LttzQJGAJvlcJ8NVTnJ5BDQIgvheNFKr/F8WrZ2JL98ObQSABRD3pAmigU55vpOcpRFtxAuA+ba+nqYCdZGwDDcmqDFnZOIyZQoKcbYGME9D8XIgeiaUAWwAOLM2gDtz06/byCdMQwaHP3pBLw9jJE/4+sJdGzSkTfXY7hRcltLaN0GKzc8FLHq9FWZS1tYUgRe5XdsiXtneNY3E/aqJttKnkgB4QUz4PjmdxG1sZUyKnwAZGU64nSfIqEASQoqxDgaQkQFFA5m0qSUT9JjqRAbGZqOXAwmoITWPCGZ0yV9ivmkCFiSzMDrAyCAEBmXKSbGJvNOAhh/YLID50u3oXw4rccdDAuMPq4QEO/paGp6lEfzDLPemYUjcdI9PPYXdsmdqAh1oZIgxTEEBcE9DSeU8kwOoYAPAus4GQAw3gWSvwQ1fc8PtuWS7fi2Dw2XL5ISxwgXIsozAI90A0CRTxqcWSgcaW3bGDite9TnARS433Sk4S/ZF9k0DGFOdEWQcU0kAxJoYM7jYp5PC9zGw8LiZ18UACrwkICaqzzutBMSwksiMSHV5QMbqo7eTAjvJcqb0v9aiNTN+IpiRFFSZMXuiA0tUFPkgvqFeAHFDvCBAfAM9nhWR7vXCbSC9WHQTPbku9I2zLQKA5CudQipRb7AXvZdvsgdAydIACKEoSs0oWRrE7etQA4RxTTfdA4OAnSAI0I/Yjmc4+HuerQGgggt/zyKI0erAgEpQiaeetOwMr9ur17GKuLQ59q0qMdqU8op0jxxIvlVRxm/gF/rKN8+LR7u2oApIsKLf/E6/f0x4g7+k2lJS25WgfsOWDVgA+7od45VOGRYCp8FK6C9nbYJkvQVa5DofcBHbhukjZVuHFEu9LQPDy/JMJfH4PveLEW1LUOKzLoa3mRViYlBIgkxQjWMn4EK/YZ2wd8MLfx9fEu4HO8nYTAWdOii8c7n5mPL1HwwimNHFRBIhniLiZZFJdD5XfrnwcmVKioOR5uss4w+i5HUMKQuDAURXNYUkAnVxsBFqonpAy9TEUAMAxuknFt+fRr/pHuP2LDkFpUw9Re/5guFKFEsHG34DPH55N6+TbQAJTJi6zobX8cwNAPXqqCAuNy0mBlSA0NfeADBOU8l9Cv886mBS0UbCxJVOFlDQsz1qzGR2p5ZywQxgXzvjgpUwrlbvWGvjCy5hHB0iTOtqkvAi15syL3q9KfvCbVxTTD5XJYV2cZ9t00axn1omQ0xsH0OMiC+BjDz9pIOMMv5lBRk5rg4qUh9TQcYCIa738f54ZHSUPjA1FqmpRDAjK/rCchAA1MyMDCCIzv1M+tIzQPFz3nNGhiVodjrQmK50ChA/LkGfAJMXBxunnviALy8Mli8Jjwc/iJJ4kbB8fxogXi/DorIg0ABGgxpxObcMNRHkhHYwrqEBZDhJ1suXYRvBJojX2oQfEwejdLgJ21YBhz/1W9TzBcZBPFUFaJATMGWqSJ66km10tQVJO8UnBS5qoTyLgdMW/uo2yfvPBGY7B7jo9b7wopQ5szN2gHHZ2LIwcr0LYni5dyYGEICSBjGiLzrEADHIeEAMADPIWIEjUEDCCDJyLNN9ZGCKq8WU4qRBURiPJe3rpCqDMp7k8R8MIpiRJL7AMmhE538dSkTWJYgHGhl8ACQW+ipAI122DWawq2pTSxxcKmFLyjoaGIAmGoBEliYBNKLH6tRT1GZMXMlFwnxsC02Tl3O7oIa3xzM6/cI/ttezNQqw6BAjrbEB4oyNDja8Lvw/ztrI9U64gbr2JiyLT2pthnouWyYHMGRlNNgRdgYIUHystbWVq1+2tTUmH9uzmUz29oXBQaJeXVtjqLdkX7idu94AKSnTTMxgx7QYtgW9sT2EnQlsRB2ScGKbUoJkm2ldjFSng4wRPnxBhvvI0zywvDfAhxFk+HuLr56JMQISpPh1Un/BaaZa366hWUQwI0t8eXmmAubsigY4iRhyuQQ6OtCIArjAR3+6dvSDp6It3Y3IKqyTeiWyNJa1NIAgMjlLAwblDsJSS1Idp75AAAwf6+XpJxlqkveqCQGIQw2ARLZGXzSsAI0MLdCyOJINrzctFtYX+upwE8aKFhUbsjehbTKDA6iQo9uFcdWBRoedMJ59Ya8NfuopF9D4PJfJFMN9abbZ1gQuSr2S8dGhIx1w8mZgACSmkUSZBWB43EIQA8RwItu5IAa8XIITwAwyUp0RZKTvZVaQSdRDK4fub7d1gYwKWnF/VX+mtFnPrAzJXwQzktQ0JAML4l8mMmRA+m4H4p8YKmQYERkeBnGVkqiTp4+CDEADiKduI+B9hThY45vkQfZQ/g37ZF8gHC7iDaRMTSCyNACQWE+jQQ2gAgyHGnmdTT/fL948c2drwv6pYAMk19FUWWAEG326ClCzNla4gbrmJrSvihOsLYMT2quLguV1LTro6NNWcbkdFkzwkybX85vSbopnkwlQREwjvJhumqdDih1w8oCLXO6fnTGAiuc0U9o0Et/2nUoy2etrYkQbok4uk9phcEMM39bAxzqtJNknshkWiNHrvUGG+5oeZaDBSRrIGDMvSpvM2Ld6Ag1lZvxEMKOLA4H+nich9HLIb0IpMCIxhSnLE697gRloGNSpJa0NvmWcduIBAsTgI2VpxBSWHI1naZgESlLbpvU04j8Jgvj0k56VUS/rjrIyUXw+taQsIo4ARUwRBMwKNsasjAQ2vFypt2RlONyE79U1N7Id7xOXfEWRDDmhj2qXfMRBctDRgUext8CP2TYO0u95+bZv7Nje75JsV3wbsABmaNFjmcBFtndlZ5Q4juyL63/faaS4Lu5L0k6FFRfEpGVi+LYOL/I0lJKNSYMY0XBcljkbg7g+C8iIhLIJShLtIxVkrNkemO0SWZwaSwbmvP6DQQQzspgELAHEYmAOJRDlEpAE0hc/iO1kIJLjy3UykCjQJF8WDgBivUwSaBCBAfhl3RLQhNUq9iSyNAzmK56inY6zM/wlQY/0OAMBVFI2xwU18rSUDC9hD2WwkbNBTIEcfX0NgMQaGwDJ7AzUet0GMGdl5DU3piuXdFs966I+RVsHmSS0mIBH7ofP1UvibscFB1/fX3fOKSePRx0k18u4Fge7wcVm7wMvJvssGRhebs/IxPFN2RnTol69PCvEiH4oEKOBCaCCTBTDmI0xgY6wlSDJCBFBos4bZEzgYfDLAjLmuvigqTfAkLKLYEaS+MIqwKJNN8kgA6hfcCYSG6FtVMag+kLyTwMaxbYKsAg65DsBCz9t0XBcZwGaqAPGBcIMKtSI7Ew0uEn2TAAGBxMo8KNe/QTrYmFTViYceGPgkaeh+Hv5km6+xib8OJKLg5X/FQhRszu6j2IvnbBMGRzZVmxbfOKy5NSP7QnYcobHJh6v7HtMpF2SndZmGqyEZZqNBVp0//SpJRv8BIqPL7zoPkyLmQYweh1jyTpTuQliUqeTkHyvZGIAFWKi7UDbVkBGBx3xXo1rBBmtLgvI+ICO+M1lsONKBRktpr6v9RJNM/mJYEaWCViik3PiPTRYkQFIAhrxywBI3N3XC2gCs614ppNWz7esi4ODqEMcVKCtpYlsA75zIjrEehpRJMVToYZnXlQ7xniWK5mVkaegbGtreB+SwBP1T87YaGBjmo4S/yemmmLokaHGBEWiDO6sjO0eNLpv7GOeXtIzPLr4jf1cl3GXIdcambB9O/QYp5e0ffKFFt3XBC6mcl/YsU0f8TrXFFK4HffRVueaShL1iG3DNwaIARQgUcGFgw4gIIbX6RmcNIiBwQZJkNGzJHJ9AiSQ9HFlUnxAR/+hmaiHIYZkb8vehP/Xj2j6UfF6Yr3df3CIYEZTYs1KFUB0eXPAYMyWKHcADiL/CGjEmpiIHfS7+wYVHkgqi2JwQJJjy1M+rBINKDIY8B9m0uJg8CYcUBNA7QOfegJ43HgbkMCG+wDxehxE2aMoWxPGCMTVUby9gP+yE1AWCHsON1XwzE0MLJCAp4K4Dfluw/w9v+MwWHzlTwVSOeL2Ev8zJN9DtTP6M61cOhEnQCYRJ8rQaGOlsLNAAo+711hbO6VlfmzTTlkzMnq9DVbk9zZ/H2iR/W2gwst0OOG+LkAx+aZlYHid8fJqzSYJM9J7E8AAKqBI2RPdxwtiJBsrxEixnRBjK3eBjsMnS0bGBjLaYVtTyd+TvP6DQQQzsviveBbzRZyNCaeb5HMVBxpx0Eb2pgyNgB9o/hHs6PWJK50M7caZG8viYN6JgPef7wuQXCAce4YDgWWRsIAYPmBG/QuSl3QLwopGAp6t4WtrGPdj8TSUKTMTXyElQR1LZm3kdTahbTJzA8QLdiuan1Jnyr4Ysjj8vWlaSt+W/fXYosww8NiyNGFdbaaTsiprJgYw99kFKfq273RU2jSTadFuos4j8+Kql7MvvN5Wp0MMM8TSISZ1KklsI/a1AUqeTEwU3wwiBpDRfWz+NvsiIKN80BrIINmOEWTqCDMkPxHMaFJABpBO/tFJOD6tRw7xAZIAG3gCDcz1iSudTEAj/A2Lg+V+8noJaMJ6ZW/iBgPHImEFgsIdFFc/Bdp7QIEaPk2kr63hb8O/QQw2OrzY1tgIsOFZGA1s5LU2+tobASi8zgA3oh4OwAnUaScAqp10wjKCjAY7NjtRh+T0lEumOwunKfMVTQ6oMl+9lANoUqDFFcOVeZHr3UCj+rsARq+31ekAw+us00iRnXMqSQSG6msDFBlihG8SdgKpXAcCXqaDjgk6RDmSddbsiaHNrBkZpV1hz4x1OsiI8jo+vZHWzPiJYEaSIG8E8VoUDW50oJEBwwocBYBGqTfEV4BAfiBlVKagCpPqlRj61BPA58VMj0UI/aLIfAcDqFADM9SEn4V6FRQYt4k/dH19jQleACh14bYdbHh92JXYH4hhB0BiQTEgw5F5HY2wt7xX7GABGY8yObZPNkbuRxmXaPrGsE8v+ZWnr6FJhxgTuNhsjLCTAi8mGxPA8Hp9iolJ7+XfE84FvUACYhKXV0flMowoU1EcYqDaxD5xmTMbo4GKChyBGSBMYGKqswAJ93GBjCxjdgVI9sNin6gztFFr9bOK9Vlnfv4ldqaJVf8Hukg6+OCDo7UU6uviiy8GADDGsHTpUnR1dWHEiBGYNWsWNm7cqMTo6+vD/Pnzsd9++2HUqFE444wz8Nprr+XrkPZlN6cZVYrn5YHBTvGBocx0sHoczMqvG6N9OFgF0bPjg+gFvT4RI1DiQioLYwRA9GJVhDfn4z7iSbdhGasG8dx9NYhsEfpFcVm1gmo1HLirkY14segheggH62q1Er1C+/5qWN8vyiuRXYB+8aqEr2gwqCJAP0v6yy9exqS6Kguwl1Wwl8WxmOZbZQH2VivYq73XX3Is/qrCUGaJ4Yot2/BXmm3Wl29cZ/+1fTV9Brq/a1v+OzIWKH9vHjdhY/l7h9vhi7FwoXP4vVFtuJ347kbfUTVuXC++n9KLMem4iL67/MWi44NnU1h0/NqOKyXFWY2PXdkX0fEqjnt+PHOfqmH8kMacQD7etTFPGUOqgXJDO3ksMo2x8tiUNjamgYzeJ9s4bxrP7eM9ENOl+rmQmkcNzcw8/fTT6O+P11pv2LABc+bMwac+9SkAwLXXXovrr78ed955J973vvfh6quvxpw5c/D8889j9OjRAIAFCxbgpz/9KVauXIlx48Zh0aJFOO2007Bu3Tq0tWW7oiN+PDy/EFnNivCDhm/rWRm53phtqVGGxmwf/bKC/UZ7ol7qu5KlgdTxaLTgvy3dVz/xnUW8pgbSPWhYFF9kgALEU1DS2ppAXVsT/mls62vCWMo9bCz1ctYGkLMuUX8A6Pe2AczZG16uZ3Dij8GeyTGV2bIuotyS2XA9pbuW8skOZcnSpE0x6YsZ0zIu/uXJeGnTR7qNsuRCytAwrQxMt9HrfaeSAAEwUr1pOglQf+wIe83OmDHhMZhWnthWszHOLIgJWGzlhnZtIANDHOePzCwLfiWQ0TM6tVQI5fnzDtVBQl4NhZn9999f2b7mmmtw6KGH4oQTTgBjDDfeeCOuvPJKnHnmmQCAu+66CxMmTMB9992HefPmYfv27bjjjjtwzz334KSTTgIA3Hvvveju7sbDDz+MU045JXunBJAkp5sASNvJ9TM6UJQBNMIgiM/74n3c5UQ8iPOr60Z7UX0EF6qNBjV856OyINoZFgVkUb244InDigY14MCiTC/FviHwWNbWRJ2TPpJUcJHrlb+fvJZGAjvADDcyyNgAR15/w+tEgwCYdLbjcJa2jsZVLtpA4xcAA+kQ5btmxnT1heteM3nBRY6bZuuaPjLVA9J5VYIPX4BR65JAk4AYLS4vS0yNaFAi++pTK4FUl4ALyNuBtm2xM7zXbZ3ZahjKDWVynMwgo0sHmQaI1sz4qWnWzOzevRv33nsvFi5ciCAI8PLLL6Onpwcnn3yysGlvb8cJJ5yAxx9/HPPmzcO6deuwZ88exaarqwuTJ0/G448/boWZvr4+9PX1ie3e3t7wTfSFFZdm85MvomNE2zYtCC4baFJtwnN/BARJ2GGRtQCWqN4INYizNHEbnB74yAGJpMxXPvFoip+48aBjsbDYyUCY69kaSNtMjgFAvtRbBxsA1qwNAOiZGyCGG0D6e3kAjl7H6/WFxrL0jI7i5wAZ3yxMnsW/XJkXATvsbZeJpq2R0X19gSasS7bhWvci12dZHyN/wqlXIwFmAOH1BqAJlQNi9BhMLfeBGMVOgYvACRvCT6/Ttm3lTtix2dpip4GMCYR0Cdv8xxOpNmoamPnJT36Ct99+G+eeey4AoKenBwAwYcIExW7ChAl45ZVXhM2wYcOw7777Jmy4v0nLly/HN77xjUS5flCbppuS/zcWaDiQCM7Q6uSsjgAWQ1y+pUAPP3ADji0sjgnEDQcGqInsElDDSYpBydbEqRYZbEzZGhVsEhkbXi9DBpCAGw42AFLhBoB1akp8ctI9eEwgYwIgud42rWSCHi7XjesCbSQuc+rJ974VWa9sSkwhZQYac9s+GZos8KLY621oMfMATHJbrUtAjAwWkE/eOSCGxzEBRBRDwI7t5G+CAQ/osEJTySDjkupnmV6q831mii8AHhzg1TQwc8cdd2Du3Lno6upSyuWTBACEDxd0D6ZpNkuWLMHChQvFdm9vL7q7u+MvaT/A2vi5tQ5AwyAyKjJ8iCwL92NJG4kNwLM0HHDkDEzsIz2DCVo7AgzU6SIm2g6Ejziag6g84K6CYuLxLmCJmLwdLiZ9OIyDgwQoIibirA0CJoeIytWb84HFl2PHuxffjI83KseRr5TiJ0XRh6idfs2WQxgQQ0ZF+YurfoqvJBFDK69YynU/oTqPX2mAY4Mp45SSEWI0Gw2UsgCLzT7NNgEuUmGu7Eu0bcy+KA1a4shQopXJcCDDTqCVKQAj+ekAI2xtmRjdN+GX3Db6pcBOYIlripklI5OEphSQqePxxReyF/EfDGoKmHnllVfw8MMP44EHHhBlnZ2dAMLsywEHHCDKt27dKrI1nZ2d2L17N7Zt26ZkZ7Zu3YqZM2da22tvb0d7e7uzT+qdgGsLNEA8SBltowI+3qTaWKBG9YkGQvA1Kxo8iXO3+miEuK14vYwMS2IghvbsJwaxqFaADYuCcT/ROW1NDYvr9OkovniYf4a2KSk9cxPuRwwq8TSSfXrKZgv+d9SnmaRBRM7qAOZpJT0GjwPYszACYjJmXnymnfJmc1xgY4cag60DWEyxsoCLzd665kUr1OFFsfMAmOS21oYGGVaIscCI0VbeKeEfqPZyXAUO4vg2GNHbcUGOOduTrLNmY/S4Lj/xv3oMmpQGMqTmVVPAzIoVKzB+/HiceuqpomzixIno7OzE6tWrccwxxwAI19WsWbMG3/72twEAU6dOxdChQ7F69WqcddZZAIAtW7Zgw4YNuPbaazP3Q3yRObjUCWgAWKedBJBYfG2gIzIlLM3HsgBYaotPJ4k1NVFlENUZoUbMfekPtAzLjNNQYqdlOx1kTGATA4VzSkoObYIbQFlTA9iBxQY4uo/JD0ASdJQPPJR9HY20kQIcNmhJe7aSS76Q4xr7bb8WswCLyadIhsYFL3K5LfuitOMFMID4Qson9yimHssKMQk7iy1vUapPgEgCMDSIUeqQrHPVpwCO084nrjMes+6D+r/H1JK+vzVWteCzmehqpjqpWq1ixYoVOOecczBkSNydIAiwYMECLFu2DJMmTcKkSZOwbNkyjBw5EmeffTYAoKOjAxdccAEWLVqEcePGYezYsVi8eDGmTJkirm7KJMbPqTG4qPWWS7Yhn4uzAw14uQFo0t4LX4sNz9KIOgEWBqiJgETJ7kigJIMPoPXDBDV8pzSoEbYMYbYmKlOyNbIvC/39wCaOJYMNkIQbGWRccBP7xnFcGRnZB4DRT3yimj+PASSvQrBBj+KrVRaBFh/5pLCzZmrSgMW0bQMX3da5WFeryJR9kXwzAYzyvxZTgolEZkWHGC1GZoiRygJDG77ZGKVtk68BJvTtRLlub4nrBTIuX5/MSxbbkkRrZvzUcJh5+OGHsXnzZpx//vmJuiuuuAK7du3CRRddhG3btmH69OlYtWqVuMcMANxwww0YMmQIzjrrLOzatQuzZ8/GnXfemfkeM4CZtuXsDJA475gzHxmBRqnXgAYGe6uvbCNBiwATFvffGFvKwCRs+Xag2jGpUQVqOJSIRiQwCZJTUAI6ZLCRwQjFwAZQ4UaBFhMhSucKX8AB4AU5sr2e0ZFjxOXRGwsUyNmXRl+GmZa1sY2rJuDJmqWxZVyA8uBFqddhxVSWB2Ck8gSU+ECMtl8JONGhA3qZBjFRfa5sjF6nt22BC3VMKQgympwZGd5eg9fJyKqiQveZ8VDA2CDBNod6e3vR0dGB407932gbNhwiG8HXhQQQT7FOlPMTPJAoY9EJXNgEJpuoE3o54rgmP5ev3JfEtvZej6PWMXMbWt8UO8TlTIoDi59cpthH5clFw1ocqOWBbmcoU6ZppBE5vvLJ4GuLqRYnfYzbSMi1GNgkV53ZPpO5UVlHCldGxnqJdsZpJX1bN08DF70N1d4CGrKds8wCMFFsJ8Do5Ro4yHU6VIjWOZhofXBmYmQbA9CYICZuy7Ct1fkCj3x4+2R6bG04F/wq8dMX/MY+DP2738UTP/9f2L59O8aMGYNaiJ+X7nt2MkaOzv7jnOvPO/px9gc31LSvzaCGZ2aaStEXlwHRj3z/9TOuH8Tm7E38P2CoD9RBVveDxZdnUIRd5CT3M5GliWyYFgMwrKeROmGafmJSp0zZF3XnpY4FTBrApJvxCXvTNBTfoXhn5WkjAPasDeK4EJ93+OHo01K8HoZyPYMDxCc18VFYpp3kssQaGwA6IcrA4wIFE+jU6ieLz2Xa7vvO+MV0ZVqMPibIMLTnzLxIcZzZF6U9C8DYpqV0gNHKk3HieKYsjIjlMZ1ksk2c5F0xDDGNgAGtzlCfABkbpOixTDainBlBRsgALKlqQJamnwWFpotrPdXcLCKYkcS/2LafsXkXBHOASAALkmVKPR9jmMVPBxVtW4YU7i8gxAQ1Un0CasDibakdOZ4MNUBsGwOQbQoKWke1+9ZE9k6wgfSB6XCjgIxqowCGBW6Uv4EP4Gi7Y6rXQYfbyG3p5fYrmrSCBg5eadBkgx8jwPjYMXu9axoqDV4Ue6ZtK3aGMgk4lPhKOxrEyFAhts3xTBBjyq5kgZi4THuvx4js7THddWnAFNjKdR9bXFHOjCCTmpGx1UXbjVB/wQXA/fUkrwaKYMYgW3YGKAA0Uhk0O2g+CdvAADSRg3T+T4KLHleCEHksFjwg1SehJoKyyNMYTwYC2VY+6Yt+BiqMCCBCvCOBedGwEWyAZDxX1oaZ4Sb8vJkRbgBPwIEaS/hJfxh5eEnYQDE1nujl7IvPGJt1WsoknyyMr72tN0Yfg3FyqskRIwu42MqVPhjKNJgwtuOaRlK2k/WJzA3viSmGfqKHXhbbGjMtJtgw2cjbsr3J3wgcmq0rhuZjiyvWyDDNlpn6mQ1kjBBGahoRzMhi/FyoQwpfzhudJ32BRpykmTiBK5DCT+yB6itAIjrBi3IgThwFahuJKaPIJu5D7AMeA2r7kNoGpHYCOa520g5Y3FfEHeUZHQSqrfgMxYcQSPZShQwjMgfwjkjtMMUv2T/hrZ/jZMqS+q7YaecZ+eZ5cZ20yFj4Se0KPymscu4MpHIJUhQHte+m7IsTWGqcrfEGHUsXzVNLHnYOqNHb8lk/Y/3QdcCQ2vbOvOj9dcCL0Zf3SgMS+X8rwPC4BjtrJsUYw9yWEXBSgETUyTaWNpwQI/yZ20+xdzw80gYycuxq/WimyiqoFriaqTpIlsUSzEgSX2CYgSaRz7faQv5RLyULtKucAjlG/D8M78FtgnjwVMole1Engwm341Ci2TJpgx/Uon3JJ5Aac05Bye2I8380SEeRlYyN+ExdU1GASn5+mRtEn5uIqXyw2gcEe7YGQDxtBbVOWYcjdo7XaydM2V7YSPGVcrUtkw9XpsyJr2mBcdC9ADijjwtagHzgkvDTiVSzcWVdpPqaAYwcywEe6gk9MJQl3ydiRWWm2C4QSgUSvc7UjradBWSsfkqd4+GRKWtiBMgUOC6yiqaZ/EQwI6vqWACsb0fZGSHDPWhkaMkCNND9IwkbCWiUchkgtDpo9fo5UvGVIEwBIqlTMlPo00omH6bsVCABj3p5t9Q8ElNRcqW8EdnYwAaAG27kviXgJqxMBZyEj1yv75gKOkoMSH2SfbWYCR/odtaqyDml3lO+P/qcoOWZlXECi8HGC1z0cuV9bOPKvgB1BBjpfxMciPK0qSTNT4eYOE5cZpxmMcCD1V7eRoqf1gd3bObnB8SwIkvYqRV6VsaV+CQ1XvlxbxAq8eWW0pPGL758MCllLFGXejDqMZAsd/nwvpr6pNfJ23JfjP2oSvXVIBxEozl+JW5Viy3qAgTVIO4/TD5xXMVX7ie3qQYJ30CrAwNYNRy7WDUAk+urQTI2bxtqP7gvqwZgLJBiQa1naj3T+1GV+qPHVfY9AKtWzC8WKK9qtT4vvV1m6aO6D9pL7Hf8SnyGhs9R/j66/g62v5/1O8SS/Up8v6XvbGCoT8Q3xdCPVWmcCeR+a/00HUdxX2If5djUxgjdTznu9DHAMGYodVVDmcsejjpDXwuBDOSy9HvJqG0aQCbKyvgmNstQFfEVTXleevIpTY899hhOP/10dHV1IQgC/OQnP1HqGWNYunQpurq6MGLECMyaNQsbN24sa3dzi2BGFoPIzpi+0MYvOT/o4QaaZBlL1NkGAZtNIA8MVbdPIrYGF4lBTh6gYIkn2SQGtKoZapIApNn7go0JOvQThnRC84YbBjPc6G3JJ0ioJzAb5BhBxwI7VuDRwUfqs+slw0SRV1o7CgRY+m6EEB2M0oDF+Lma/iYOcKlq+8S0Pko2RngxfdeqsAKMNYZ0fNm+30Y/3acMiDGMGdZxyAIxyR950Tbi8co0prl+AAKmOpawScCHqGeJvst1QqYyrjpPL4lmo5vmFXll0TvvvIMPfOADuOWWW4z11157La6//nrccsstePrpp9HZ2Yk5c+Zgx44dZexubtE0k0lVhqBimF6ScZwZppwCQx3i7z9/H/9vv9IJmq3TJhDNmu0YlLUz8rbSr6hB+XhV7AN1kBAxJT/+nvdNmYKKfHU/EUtsB3FbUYNM2qlAsmPKzjL9A1Z3XIoXaPV6HCbtR2JqCnEc9YPWPlS5PnqjX9Wk2sA9jWTxUUwCc0Wt1wAWXQBsjWG0T7HTfaS4zrU2kl1giif3z1ifjBWY6vQ2eFwtptGX2f10ex0EFBubn8E3rd4FEqLPjn6lwUiyjnn7JkAGGsjA0CetLGBQQMYKO02u3t5eZdv2wOW5c+di7ty5xhiMMdx444248sorceaZZwIA7rrrLkyYMAH33Xcf5s2bV37HPUWZGUnyAWes1w8WLuY+QKxl0YGZNu1k+9WS+KUC6b3h15nul5heMrxXfsmZfk06ppK8pqBsvzz1X7Vyvwz7mSlr48rc6HGk7IySFdEzHqYsTmomJ5k9SGY57JkbPXNh9E/NotimirK99H5Y++JoI/FZyZ+XLdNStfxt9YxL9PeLfVVbkTWpwp15cX2vDLHk40UcMynfVVPGQy1XPwfjsWzK4OjHjm1c8Ky3+ST6DbevEUbkl1LH0n0h16trZORMemjHDPurZdelK5dMMWst/mymIi8A6O7uRkdHh3gtX748c182bdqEnp4enHzyyaKsvb0dJ5xwAh5//PHS9jmPKDMjS7oDsCk7A8C8IDj6xa5fso0gSCQL1MXA8XEVwL0wWCoyLgwGrwuQWBwMyQ8MxqwMN0hkdRxt2RYKJ9qNYos4crZGa9/WrpxhsWVsRF/0rI2cRdE/ED1zEwUJEh+ClJmT2zfYAUhehaRnckSHE2+Utwl7rcCZEfFJlhQdlDP5Ozpki2Mq1/Y57com3d6YdTHYiboUe2s8vT1TZofpNrZy1deYhXH522wt/q7Mi7MPcky9vxbfJIDY6pixLwkIEmXmNTKJeqUdy9VMTPss66gqAq8Hurr8AeDVV19VHmdgysqkqaenBwAwYcIEpXzChAl45ZVXcvexDBHM2MSQBJoASE4hue9BI9+AxAY0wlcHmkiJ869WJttxoAGiQd4CKVZAgQwEgjvMsMLLTFDD25VAJpA6HgJMoMKJxVdpW/5jmMBG2hEZbES9ZG+EG6lf+oeiAI48daGBEKCdYDV75UojzU8pk/3NG9YiY5x6Kq1tV70B0HyubnJCi25vAxfnez94UWz0KSRmsnHVqf6lQUz0vzfE8G0HTIiYpnY9fI12op/MC4ISUMLrHfeSiT8nLYsTnQPi+Cy5v3VQ8admh75jxowp7dlMgXa5JGMsUVZvEcxIErQuZVt0oAFigInPtdGXnJdJQAMWHd1BoJzQ+flSBwyxtkR6bpFYr8Jt5BjSe8FOUnwEMdTwOmVnAim+FksvU2CEA0xgKOMfKNP6JVdq/5tuxpdoB7oPlMpAqhP+spvYkGBFjqMaqZCgH6gy2ClnDjW2qQ2mtyMHdIwH3mNFI35Ceq6ZcS41sNUZYht30RdWErZ2P++si+6bBh3GuqR/LnjRy7U2nTE9wcdYr7fhAKXUbIywYwl/N9AkgcO02DctI5MGMqancQ8GdXZ2AggzNAcccIAo37p1ayJbU28RzMiKvrimBb88kxITjQY0gVYmLQpOxGRJpojBKGoPfouDTe+NdgG8p59MGRE5w6L7C/DR+iBgSI6vQRIvTwJQINkxpS+2GOoHqflLsk5NRZWm6ST3HyBI1inBpS7oPvqmPkZKfTeOnyaG8ASLmstnvLf01cpjpvK84KL5OjM5JhsHvCRt1f+NcSwg4R1HL7fZmmyich+wMcY21Rv8rbG0bXmRr1pujpUHZOL9TgEZGPa7jip+07zylsZOnDgRnZ2dWL16NY455hgAwO7du7FmzRp8+9vfLq2dPCKY0SVAQ3omU5UBFW39i3SSV8pyAA0Qv4/jREATBAlb2d71nm+Dx9aAJs3XGM8CIUw0YoAMGYgsbThhyjSlxJ31NuVYiT+WHD+KY4AIBTzkKSrRnrYjNpKUHR2go701+5s33YNrvTI0GeDJ2SVbnSm+yTYNRjKCS8LOBC/Se2sWx1hvARhTmQ1Kstqbth2+3hBjsjf42DIzSTBh0nstvsE/L8jwchvICCVsGDLfvKWAqixwPnnexz+Ldu7ciT/+8Y9ie9OmTXj22WcxduxYvPe978WCBQuwbNkyTJo0CZMmTcKyZcswcuRInH322bn7WIYIZiQlUodMAxoguShYXxOjQw4HGslHB5rI3ZKt4Sfv9LU0ehxotsLOlaXRQUIqc0GINbEg2fCC1GyNFCcR1wNs5D4rbSsfVKD2Rc6A5AEc2cj2R5K3lQB6ueyvfqJGGLCNVY3O0LjARdhY+mgFG4+yLGtnNGWBl6R98n38XU/GKgQwWXzKgBjdz9SHtBiGciPIWIHFVl4QZCCVpVy5VG+QaYR+/etf48QTTxTbCxcuBACcc845uPPOO3HFFVdg165duOiii7Bt2zZMnz4dq1atwujRoxvVZQAEM6qq4ZdVgIN+gtG2ZTiRTRJXMkVffv3hlNwnztxIICKVhZuyV/J8ybT3NjvRTw4NLHYwnXcT51UdEHhcDWqMNnq5BBM6kCQyQFqnEhkb3kEDvBh9pfrwfdx5GZQgVasd1eJKRonvjWxs+oM4y7WTvencbzs51yMzkxWYXF3KUuezjiZl95P2JcKLJZ4XwNjsXT56H23tpfhbsyfR/8ZMjCm2DTyctswew/resNDX0L8kTBmegs1BhsWx5f2Tf+zWc81MteA0U9ab5s2aNQvMsX9BEGDp0qVYunRp7j7VQgQzBilAA8uCYCUDo8ELkmUI4Lx02wg00AAE5nU0STuzv2wr6mWoMcWKAupf7UTGxVCmbEvgkOiTDBxyuQwjesZG2tEYNJJZGyvcaJ1g+ofmmJoS3TN9uLqZD+joTjawMbRltEl0sEHyGe+dAOMBLJ7tWCFD93f9LS3vXdkXtd5dlgYwRj8LePjamaDE6qvHcfjZMjP2eub0M8dOufRattH8Ev3WQQZ6+1FhVYWueqj4U7MHx+3kCGYkiRRiRS5zAA0gQYgKJ7mARvhp51oFdNR1NMLG5S+Vy3ZKPQcDi43lvG2GGg00Er46VMj+NrDRY8t9N5RZMy28LXmntBgmABIxATWu8kY1M+1AIptjcHL5G8/mroG1HjyTZWBPASxrMsmzDWe2xRTHBAomW5tdrQDGVpcCJ7kgxmWj9ceUXRG+BnDxysYYYjvfy9NGvDwFZOJ9kHyZ5bO1+Q7w6aVWF8GMpoAxsGqAoBJlQcSJzB9oQvsMQAPAuDBYgphoUwBN2IQ9S6OfM21AomdebIuEdTBJAIyhLOFrgg6tn1aw4WOeBCImALFDiQFu5JiA8iFZszeanVKRAjmJGBYZMzuJAM4iqdJRV2NZwURWjv6ZT/wp0KKV+YJLwjYPvMjlrj5I9bkARrO1wZM3AJn6a4pviJsGT7arlYzvZf+cIMN9jX3Ur1yyrJNR+lzHaaZ+BOgv8KukiG8riWBGVmIQ09bPyEADqECDGE6SYCIBS2So3ItG8uPdcAFJXB5DjSkTo28rdSYY4W3IMADNRvJLiyNLh5VEVkYGCT2GnkGR60wAIvcxC9wkbAxt2wDHYJ+4kklqxnamz3S1kjtUEoRqpRLHdScA5byqyQku2rYzs5MGKrbyMgHGVOYLJ1kgJtpOtGsADn1bhx69rayXXcc2HiDjs9jXF2R4X+WMTP0YRoimmfxEMCOLz9sizM4AEBkaHTrEdzoCmrBOApqICtTzXxSJn9C1K53AWHSOVW+wJ+x5G1G5AjUMYEGQBI4AkqMWTz/569mTAOq5m2k2ehxo7SJZ7vRn7hhKHSQxQ71s4PGeSQ5Bwk4dwRLwpp9jTefcRFlgtDPGSxh5jqiaWZlLaHy7kLkDtriGchcYuMp8gSVh6wEzvuCi1LtAxVTmATpFAEbYaXFdsfymsZi7X9b3BkAxLfS1AYvt8mvZzgRKpoyM3g6paUQwoyt6XLJYmwKIDI08naRnaIz3oWEq+IgsjeVKJz0+EB0/olyFi2T2RV0gLNfF7cNYH2i2ug0/yTKmFqZlhPRYApwsYAQYyqSdNdnLDciDkc/0EdP9bFkcvQ15NNMgLPFhmOLLdtD2xfrhmYwtNgbVfQD2ac9hY+2vJ8Q4ocXg48rg5IYXySYthhfA5KzLBDF8W983n9hGIGFJe4OvDUQSPjrI2LIxkb+xXG8n0ReWzMgo7dTvYOpHsami/vK60tQimJGU+KIjytBU4rL4ZCeBSoB0oAl4zCTQADDeYM+2ONj0Pu4ei94HCTvdNumr1pl85MyB87JuF5CktGPqXwJe5Db0eh1Q9HodbrROGaeoEjGSKaJUyDHumKGvCXiR3trGNNfYWmJGJlO7FqVCVRaIMcXzmI7yBhfd1wdeJLtCACP7WE66Rj8f2JG2be1ZT/y2+EYbZqzzy/KokCJDTFyeEWRMVy2ZbooH6b3v37xGomkmPxHMyBJPzQ5BAgi/zHxBMBBCgi3zwoEmMkwHGkAtN9xgj9tEIaWYZjCJ36v9le24re7LT9Y+UAPAfK8aCQBMwCTvSNYMjDErk+Ijd8AKN7Y4UqddgCPXe6+TcQGKA2yMg2karDRgAM7cti+oCHvLTmeAFqNNFsgx2Fnbs8UpCDCmOqet1EZqZkdvIyV+nmyMsc62NibR7xJBRuxntCFPL+l2jMX9qYPKetDkQBfBjEECaOSUQ3TJtnNRcHTAiPvQpAGNVI7IXQCNAishXJmmmoA0wLHfm4aXJWJJnwOCjFCTEhtamW6bgAyLnwmaFB/tg0qFG91OgxYX4CTqLTbmBT9aP/ROuaDHYKMGtpTXShmgKT074wcr1nhp0GKySQMhHzvLexM4eGdtPOpcMBTAYmvrkyWmT0bICDH6ttGPvy8IMrbyqtovHsPYd8OVS3q7pOYTwYykcGU8087O0voZ+R40MpAgAiAH0IQuhiuWgrhNASvyOhpuFx2F+hocORZ/L7Ieoo5F781ZGlssY2yp0AY1iPZD2ImdTZ7P9ZhyHeTP1JAZMYGNDUiccAPNTm/f0EfFNg1ylJ2C8uEnszKys9bFxB8tZWDNMO7a2KHUtHraAmBHW75gYbXNCy6aba4pqLTyFOhx1ftOJRltfaGF26S0bZtS0m3t7bGkn+VqJblPTn8NZGy2MsjIfYOWnYn7VD+oYQhQLfDLhBXwbSURzJikX4LNJCDg96BRHgApgYYFaPhJ3Z5lUcsRIJGlMWVyIlPj+7hNvuleIJzw53bRST1xPtZgRfGzZWs0sDFmWFxgY4ql1WeGG1N8R/YGyAg5Nj+breZj8rMW5hy3SoUWwBuk0jM0Gfw8y3zBxWjrAylSXd6sTZq/71SSyzYNWhJte0CMHsMa0wAotmyM0y4nyMj7pYOMcZ2MDDJ1Fk0z+YlgRlY0FyoyIhJ8KCesKpJAI4FGVqABDFDEy7XnOgGafyL7kwQVtY5F7+1QY8x+RBvWzIrNzwI1phipYKOBkLXe0le93AghHtkbYavFBQyQY/NLZGSktyZGUT7oZL0pTqKq5B9ouQEoxS8LbNjKvfvmASRZbDPDj2d9akbH1Y8UiPHJzJhAxWtKyerL61iyTsrGxHUGuwIgowOXzyXYMWCpsENqDhHM6GIMQTUAq8jAEQONPOUkgAaQwMIMNIg2jUAjAYkxhpylQRJ8krFjO1En/Pj7dKixxXBt634cCgKp0JqtkeOawCbFR2wYsjoA0jM3ur8GO0bAgWrjyhhYL7+2ZWsMdQlfPa5DpWdfPJUHLHzr8sZOBRetzJphcdX5+LvgQy43+fjY+wBSAhzcvomTvubnNcVkyLIAcN/N1xjTcTM8Q5vGrJLppni2Bb8NAJkqC1At8EukiG8riWBGlvLlNQANAEh5E+WxB5DPj9pUUHRgBZVAPbnzm+QxQNxgLzqByjfeEz5yloafaKUb7Qk7Uaduy/HjOiZtB8nsB4cpS0zTNiCdYA11+gma8X+4LRz2HGCk+sQN8kzwYItt6I+8nZgWSoEZk4+tmdjBVuEHKjIoNp08B/4yszxeU1A+fjYY0f2L2GUBHkNcrykqH6CR7ZjNV4UYr8xLIl42iDHGNaybEe+rhj4a40Rv0jIyHGQS+14/oukv+NTsIr6tJIIZSWKulP8yr0IFmggewjNj5BRlaABAv7GePpWk34tG2BqyMXKWJjRVp574WpooDIyZGshxZNiK69RtaT8M9eJzSonj8jX6y1kSSJV6hkX2keqVjIns52GTsNNsE9NCJlAyxdM7bvOVZSgvmtWo54+y0jM/jnjWtjxAxgd2fKEkYesDOQUBRvHLCSy+EKRenpwS3wA1ar1lgW/C1wI8aXVFQSYRW7sEW/anq5qaTgQzJrHonyAwAw2vhnqVk+lOwfpUkg/Q8C6Ipkx18hVPCqjEbSbiRP/XDGqkxlygo/sr8CBV6HcbtrXhKofFRoEbrY2ErcHeVA8YYkKz476GcrnjXhDik7VptjHXoz/OPmeAGK8MjcnOsV0Ucqz+chuG+jzTVD6ZGTcEGeAg13YSQHRIcNr61NUSZKSppXpmZLhomslPBDOyGAuBhC/4jcCA16WtockNNDDDiFed5XEIYaUtju+2GWog74s8jWSIxW2NsCFDCmIpMXSwkaQDhQmqXNCSBiw+gAOkQI7FTu0wElJOTraxSPtMmnHMygRTeSDG1kZeuPEAkqy2XpkbS1xXBsVW7zuVZKurJcQAMGdjIntXLGud50JfeX2Mdd2P5Ku/j31Y8rtQQ1VRQbXAVFER31YSwYxBAmgAxOtn4AQaAOLRB0agAaAvDAaQujjYWKfHApIPrYRqi9i0MNSYbPRyGQx8MjjGGHqfTNNRsp8FYmzQIzYyZGR0e5sPkISL3NNPPmAjx09U2H1KU57B3cMn03RSFnsf2CkAOg0DGKncdyopjpETYvQyHWKiehfE6PFV3xSQccUzgIzeZ9NN8fR1MgrIkJpSBDOy+IEYBAqQcKABYL3KKYQNZgcaw1QRAtinncRRaLiEW48VQY3pZnthWwaoCeKDPyvUhGXuKShXPGOZDA0SHJh8AJjX2Vja1+OXkZExZlkywIvz8msXfEg7652JyTL+2j7wkuSdqXHYZQUcJ2jYfNN8bCCh+9rgRarzmnpyAUlKmQuEcq+JscZNggmggowOKsI+K+TkAJm0xb6iry6Q0R91UGP1swD9BdKuRXxbSQQzJkVAE76H4WRUDGj0m+PZpp0SC4A5tPBu2DIvhgXCwl5flKzU+22HZSwqyw41cpkCGVI9k9+YIET200HD4OvyT9QZ6lMBR+p0JtCBPY4xli2GKU4elT1GZ4iXCjquekOd7/RTFnBJrddtLXZemZu08pQyN/SwhL135sW4nQ4xXvYsrou3Nd+09TH6fmYFGW2f5fpEdqcOojUzfmr4ZNrrr7+Oz3/+8xg3bhxGjhyJD37wg1i3bp2oZ4xh6dKl6OrqwogRIzBr1ixs3LhRidHX14f58+djv/32w6hRo3DGGWfgtddey9wXJRUZrZ8J34fbiUVhkN7ri8T0u0my8EBLHHj8VWXhPWmkg1HYi/4kD+5A7pvsW7UMJJKtKV68v1q9tK2WMeM+KvvGpD4Z6lxlpjgJm6pWDunl8q+q7STipNSjGr3S4sp/D1NfLHHkv6MxpqUN+WXb91q9En3I0GdrXJ/PxxDXGCfjd0D/Lhq/Ax7fPb2d1O+0zbdqsLV9Noa2fI5Xn2PUNPYk+uwx/vB609hoBRm9vGyQ0cdyDWT0OwTXWix6anbeFxskdwBu6F5u27YNxx9/PIYOHYqf//zn+N3vfofrrrsO73nPe4TNtddei+uvvx633HILnn76aXR2dmLOnDnYsWOHsFmwYAEefPBBrFy5EmvXrsXOnTtx2mmnob+/P3OfnEDDy5R6LYDHgeQ6aDnQWAcOaAMNoByU1kHFMgjp8fIPbuogafMzDdDeg7ZWLp9IbL6uE4zxZJQVcAw2rhOw8wTve1LPACkmwMkEG5Y+2l6+/fLZD2cfbe1lBMxcf1vP75YXvLi+twbftJjm45dZIcZ9TLvGAgavbIzuo9szeVuqZ1I8BvFjTy7LBTKJH34s7rPpRymXHovUdGroNNO3v/1tdHd3Y8WKFaLs4IMPFu8ZY7jxxhtx5ZVX4swzzwQA3HXXXZgwYQLuu+8+zJs3D9u3b8cdd9yBe+65ByeddBIA4N5770V3dzcefvhhnHLKKYl2+/r60NfXJ7Z7e3ujBsP/5KmicG0K4iucDGto4mke/kXnUy9RHEC9Fw0Pg/jAkO8jY1wczKMy6SZ5UaV60zpLfb/olvmmewyQb9AXfg6io4krkpLt8m3+IfKyeCEzLwOQvBrKUB+oH6e5XI8He0zhD0l6PdRtJZbso8tWZhj7nFlfU3uecbNIWZ+UQ6l99OpEMRtrHyzlRnu9zGBjW+tijOuIZ//h4+FjacPWduFpJFOZZWEvoAFMwsaxgFePa6pPWxujxI3emLIoCR9Dpl2OY4rFbeu5ZgYB+gvMIRfxbSU1NDPz0EMPYdq0afjUpz6F8ePH45hjjsHtt98u6jdt2oSenh6cfPLJoqy9vR0nnHACHn/8cQDAunXrsGfPHsWmq6sLkydPFja6li9fjo6ODvHq7u6OKw00zjM0xgNDInr9QOO/ikSsqjrIiF8Xog31gDZNPQEev4zketNA4vrlZJqCMmz7/5JL/iq0xfP5BWott/3CTfn1bWwX0svUv4JTSz7ZGe8MTc6ppNSMTVkZGFffffrn+IysfhaftL9j4m9v+Pv7TEv5fNdsU67wiG0/NuwZGOOxDM8y21hj+FskfFwgY5qikusN2Rjhp/VF7Lc0zpYOMvKrjgo/hqDAq67dbZgaCjMvv/wybr31VkyaNAm//OUvceGFF+KSSy7B3XffDQDo6ekBAEyYMEHxmzBhgqjr6enBsGHDsO+++1ptdC1ZsgTbt28Xr1dffTWskMg78Uh4cTAYDhDTtJMGNK7bZxsPUungTp16Mk0vMe3A1esNJybbQJQOLKaB1XOwdQzq6YO3Z13aCSdtaomln+RMJ0fnCdYDDEpdd9KgV941NM54Dl+jnwkoDX/T1LZ8AEyy965j9rr0Y8D/x4KzDCY7BuN0uPx34n6Q41h8LHF5DFHPIUaPrY9Jwi/aME0raf2xrn2UPksh19RSNVlEaqwaOs1UrVYxbdo0LFu2DABwzDHHYOPGjbj11lvxxS9+UdgF2gNxGGOJMl0um/b2drS3t9scwS+PEfebqUJMOZku247vFBxux1ceRbEYIK50kh5SCQCm5zolbrIHqFc8GaZorPefQbIeUlggHpQSl3TzfbD5idjqtlLG4grVl0m26mfAja2XL9uuSHL4u/xMMk0tJO4bYzJk6n7K5bZsb+CoE75I77OIlShM9ytNxp1Pl7HfWeIa6q27bbI1xdfLtO2Ej6vet46l25gup7bZ22O4yjTQkONpAOP0y2Ajtk0Q4/RLB5lEDEtGRohneJR4MYDVW3whbxH/waCG7uUBBxyAI488Uil7//vfj82bNwMAOjs7ASCRYdm6davI1nR2dmL37t3Ytm2b1cZb8pdczsTodVyOg0T5FcJtPX5FuH6ByNNOyi8sqAe9O3tiiQ0kfhWrNhY/Q1u2X5Jpvy6tv0Zdv9Qddq5fvKm/ujNMJRn7BMPL0A+lvSJTL65XydNFpS0ozjKllvb3N3zW1r57/A1TF4Zn/D65fNOOG/kYsWVgbMdftmOS2Y9x/e8EDz+XjRYHgHKlUmLsgSl29EaZCorrs4CMMo0ELb4OMXJ2vQ6qIij8GgxqKMwcf/zxeP7555WyF154AQcddBAAYOLEiejs7MTq1atF/e7du7FmzRrMnDkTADB16lQMHTpUsdmyZQs2bNggbDJJTh86gMaaykxMS0E9SJj5IJSnr6wAIR/0sA9MqetpbLG5jQVqTIOSH6x4DqzVeMD2HbRdJ4O0q1VST3QeJznXCdK55gGWl8c+lrFmRj9J1WW9jN53n79ljs8p07oZT/80G+f3MOU7VDbAZDsmGaxjgfT9AKIyGHyhjTOm+LqNHMe1NsY41Z2ctk9cLp0HZLhkWJH/599bUlOqodNMl112GWbOnIlly5bhrLPOwlNPPYXbbrsNt912GwAgCAIsWLAAy5Ytw6RJkzBp0iQsW7YMI0eOxNlnnw0A6OjowAUXXIBFixZh3LhxGDt2LBYvXowpU6aIq5t8pUBGdKdfZWpJm3IKAOk5TkB4pKlTToknbpsegQCoN9kDklM9pidwA9apJ9cUkTodZLYB4oNfZCkN01pWX6UNe5m7nEnlsVXAJCe+r3IA29STHp8lDZi6af5No7dpaNfVhtyQbeooSLxxiBnfNo0y/y5M2YnAVW+rs5QnYhnsCttodYGzzvzHtPnkLlcyEAa7LNNJkp1PfMWvBtNKxjgukBF9gSpLZqbel2fTHYD91FCYOfbYY/Hggw9iyZIl+OY3v4mJEyfixhtvxOc+9zlhc8UVV2DXrl246KKLsG3bNkyfPh2rVq3C6NGjhc0NN9yAIUOG4KyzzsKuXbswe/Zs3HnnnWhra8vcJ/25TN5AA0QHiD/Q6OtoBNAo9Ty0Hiesd17GDckXBuiwrLmJ/SIzHWpS4ittSLZ+AGMrVwcQ03OiTH660mwT8GGBDm/I4THqsF7G2K9GjGM5x3onpPjE9gUWh73R1gUjtnY9wCKss5No6QADOEEEMGdhdF+l3GFnhCT+3hdiFJsSQEbpiwQrVa1cBxnTGpo6idbM+ClgrM6Y2YTq7e1FR0cHZh91OYYMGQ4gAhSRkQiU/wW8aPWiPIjLle+RsJNjxtV6XD0ek+Kq21IbFXOd7mvz97arGMrkfuh9dNpmLE/UuUnD5etlb/Kx2VlsnfYpfpltUlTmDzUvAHHJ1z/FLmu2xgdavO0ywE7iV70NOlx1Hj6pECLbVg1lnhCjlmWHGB9/K8TIceRpJTlWBpAxTi2Z2mUMe/v78O8bv4Pt27djzJgxqIX4eekz//55DNtnWO44u3fuxsrZ99a0r80gejaTLjkLI6aAWJyhAeJsjHyVk1zOf22z+OZ6AJIPqRRe/F1Y5rrRXrjN24szQuIEpWVqeF0g9Um9KV6g+IveyHaGdvSb8MXxVH8xwEjTca4b36WWG+uYpS6I+2Xx5fsl1ydOEIFmY+qTw9Zpz330fhj802ycseWiWv98yRm/cGbGFcNS7gs1eaafvLMuWn1hqEmBFyCZgbHFcE4lZbGzZWJMMdIgxulrgBhTzLSMi6le+XvW+iCKVUXBZzMNkgXABDOy5C+yPK0k10VQkwCayCY+5wQCHsSl3tUIaBADgvx0bOPUE9KhxnopN5BcUyP78/4p/YmVaEeyk23lX3ZpU1G2GEl7c3mmOsaSWRfb2hspgNeDImGWlVdMbWlOXg+VzDouWcCqLJUGRh5xUtty1JcKLQY74zoKT0BJ1HvW5QYYjzi+EKOU63by3dryQAzgDzI6xMh9bGGQAcIxqwiQMIKZQSrTOhn+aAOtXgEawHwvmtAp/C/PWhrAbz0NJCAxQE1Q0epkfxPUpMAP77u0d2GxCWy0rEQRsMlSZ65nWn3yQDcd+onhywInadCSCixp4478OeYco2qemfFUpn6k2GZeFGyx959+Yk6bTPCi1ftnZiwAI/koJ3e53BNMbLbemRhTvROEVJBQyjR/azZGbqMMkNFj6u9rLHpqtp8IZmRpmRk5q2IClsQC4CqSQKNNO9mABpBP8jwDE27rC4RD23heSAciFVKicJaFwnFrZqiRbdMyLQpEAcaFwz5xbP3LWmeq14HClL0JbdRC7ywO74Rl/PBZ8Ou92Nf0h2kFZTgPNMeiYDe4GOPVCm48MjBA8SxMbluPNTFqGd+WHHwX+Mpl+rSSHtsJSZ6go7VJai4RzOgygIwpS6IDDaBCRyagAexZGkhQo1/GrdhEfdCmnsIyxEa2TI0cwycDY7BVYESOq/06NF7qLbepx1Ld1XN3Ak5UA9OwkwY4oU3S05jFscGJC0pSgCYzpMifYRMrc0aoIMhkXz9jqUgDDx+bIvVav8qYRnLGccGHZOudiZFimTM/FoiQ7bKAjA5IZYCMI1atRVcz+YlgRlYVQBsUkJGhBDADSwJcDEADyCdDfhBGQOGaduLm8tSTnqVxTD0VgRpbHDlW1iwLAnPGJpn0MMdKxDP6SnUGcPABHKONKYsTGSeuqLK0rfpY6uROZACUxELnZlDeH7EefpmnloSfH7RY2/CxKww3FpDQfLMCjFJn60NZEJMaRyrMscgXyA4yxmmjJgYZgKaZfEUwo0tb0GvN0mQEGsWXn6QsWRrr4mAYsjRAYoGwN9QATqgxxnHEyjx9ZFk47Iqlx9Nj6r4+9UYbC0jYzpGmTA53MIGOqw1Tg5nHo0aCTV6AQYbsTYpdFmBxtpsTcIrAS6Je97UATNLPDRNe9jZbz0yMKVbqwxw1aMk1rSTX1QBk6n3jPFK6CGZs0kFGmXbJATS6rww0sGdpAAPUyFkawLxAGNwuGcNnTQ1gPh/apoMS62VM9pbsTrj/UOSbtZH7YIpr9k/KB3AAB4AwO3BYMzrCL502vMDHJm1HavFDrZRFxZ4xUk8kjursU0/ptvngxgEvmr9tEW9aXOui4CLA41oTI8Wzx1KhQCnTIEaJo0OMbGeCJJ/1L02ekeEq+nwlujR7EEp9nAGMmZnUDIypHnCvo5HjaouDw34BzrU0psu4s0CN/CFIv7hSp6B81svI9g4ISQCIZ9YmLa4xtgkMDDDiWvJikmvIcJ1+nbBjCOIDPy4ZT75ZQtbgR6n3L10PszzTT76Qk3/aKWnknX1J64cHkOTxyQMxSrkvxMi2ZWVjpLbKBpl6Z2VomslPBDOyWPwAM+WGebKcwKKfVKOwBpt49Yx6ugfkLI00QOhTT1IU+WSo33BPbyNuNxk77kGkqtRX7SZ8YbtyQMPN+Ez28PDR/fo1P24i36xPiwsY2oXaL9nGHEdrzxTPYe/0kf0svnqMuJ8ZBlPfcawW43OBmIWvYkqLURBqrLYZMi7CJmfmJVFfC3hx2fgCDOCeTpJiea2LkXxLhxj5vcuWppmaTgQzvjJNO+k31nNkaQAYMzmmRbzWqSdIUKNN38jTTwDMa2oMVz8B5mxNWI7YWLsJX9yH2Eb1NcOSEtfWD4OfPo0FJE8CaRmctDZM/UuL57J3+XBHnx9NZUwx1fPHWeEpJ0//1HYc9eVMNyULi8KLOUZxgHH55YWY1KkkwD2dZI3lABlTO86pqwyw4wM9DdBAyMz09vZm9sn66AWCGV22aSSpLguspC4eBpCYegLcUJNY9yI7QYWaPFNQok+8XJJhGiph4wAb45odtfdGvwQQ5YCbtDaEDYOaJRK2ZhW5askbVDzBx9mO2Mgfx6qSxvqyFgCnxsoCLYAfuFjilgovmn/uq6CyAowU274WJzvEKPGyZmPkep9Fvia7vNmbqv4h1E4DAWbe8573IMgwPR4EAV544QUccsgh3j4EM7KqTLk0OwvQABZYcS0eBtKzNFKbtnvThD5ye5GfCWoq6gFvvAJKy/rY4MOUrYFmYo2LlMyLC4g0X2O7MJxE4Je9MbVna9PWtk8bPr5KHF/wSZPWYJ6xrpQFv7oyxCySlXH6W36B5wYXm53lxG6uT+lL3sxN3qmkhH0KxMj21ngRKDkW+CZjZgAZ36xNk4HMQNI///M/Y+zYsal2jDF87GMfyxyfYEZXlYXrQ0xAA5izLjZY0cDDmskB4vU2WbM0wid8a7qc2zj9JNabROUGqFHiwQEf8sHtAJtMmRfN1iujkhID8MvemNoLjZn1xJ8XdICMkMKKZWis7TeBMvUjL6wAVmBx+pUFLpY+pE1PlZKBAawAk7AtA2K84knlWbMxUrs+62OMdlmnlqoGvxprIGRmDjroIHzkIx/BuHHjvOwPOeQQDB06NFMbBDOyxJfZAjRA9iudYLAHUuMmsjRADDVRlgYwQ41xPU3kb1pTY3xMgrCP2smarQHs62u02GG72uCetl5G3UxkffQY1jiWyy0zQQ7McCV8GOLviNXfX6VlaJpJGT4Av8XBOYDF0Q/b9yQVOix98VpbYznp+/hbMzCarRfAJHxSIEbvj2l6yhNilLip8OQJJnntGwAyQPhRFHvQZOO1adOmTPYbNmzI3AbBjE0GoAGQOo2UCkAGO2PcyM61QNgINYlFvClQo0GXDaJyTRVZ1tdAM0uAjaMNoz/ywY0pjrAtCXLidtxDig/waAGb/vEFvsqcGfI4meQBFsAfWpztlAEvhji5MzBpth5ZmLBOPeEnymUfW99NECOX26DJlWVR/JPAkxVkFOkg0wANhMxMPUQwo0vOtGhAA8C+Lkb2dU4nJe0ScWU7QIUjCTDMUCPBC+CfqbFADaBma+TDwnlDPBlsAnhPRelthPX6qOpoyxLDGAdmwDH1SdhnhBxXf5JtZhswMwNQMyrHr9yil21bgcXhV5OFwVnhRYtjrC86jZRoIwkHiXLZJ8t0klaeeUop4e+wTfNxZXqMGZnGwU2r6+abbzaWB0GA4cOH47DDDsNHPvIRtLW1ZYpLMKNI+tJmBRpABRTP6SRrFsaw6Ng59cRj6IuEEZ+wrVADQL4dv3UKKuEjf3LaQGy7dw3gBJuEfZAcbPNeXu0LODospcUFEN4Lx8EVPs96y4MlWQGo2ZRrvY6HjxNYHDGyrrXxXWNTVgYnSwYmYe+CpYSfB8RYYMx6FVQKxCjx9c8m49VK1lhZMzgmkKnzNNNAy8zccMMN+NOf/oQ///nP2HfffcEYw9tvv42RI0din332wdatW3HIIYfgkUceQXd3t3fcwfE4zSySv+ymL7Q4YCWil+d85ZcUL2As6aPb67ZVs60Si8mvqL4K5RWXMwQsGmwSbcdxArkNqQ9yeZDwUV9Kf6V2A8b7FL36Wfj5Sq+gnym2ij0vU+KFbSTaNLRrjGWJp8dU4uqx5VhV/e8Swo7yqhpeuo300uMl+u/7MvytSn1l7I91vxyfhc9nl/o5Jfqd8e9t+ztbvk/GuD7fTdlGP1b6mdtePyZsxyCDemz3s/iY77cf87b9Se4rb08ut4w3yribHHtsY6ZpjEqMw7b48nhuG/f1ujoCDYeZIq9m0rJly3DsscfixRdfxJtvvom33noLL7zwAqZPn46bbroJmzdvRmdnJy677LJMcSkzI0v+oupTR9JlyHKmJJFxkX3k/wH4ZF+ctoBxkbCwYYCSqeFxDIuFk2td4nazZmwAKFNRiLphjC/2TaqHppRpKaOP1qaxXWGXYe2MpdwW29WGT3vWeGmZhgzyyRLlVWn9zPgBpWZ4Uk4+uRYFm8pN3zejnUc80zoNrajYOhut0mcaSWvDaypJrkv0nyVt0tbF6O99p5+y+JhAxmRHyqyvfe1ruP/++3HooYeKssMOOwzf/e538clPfhIvv/wyrr32Wnzyk5/MFJdgRpcOInIZ4Helk0ectDUyui0A89RWZG9cUwM1pusKqDB+Mq5pfQ1gBxvxWSh+UGS7iV5cr0kf1E1w47tuJgPgGPviiK36pZw8M04qlTl8pk2J5VaJnWyqRcG2Ol9wscTPAy9GPxfAuOAB8FvMa2gn83oYLV6mdTGyjcFWsU8DGh9QajKQGWjTTFu2bMHevXsT5Xv37kVPTw8AoKurCzt27MgUl6aZTEr7EmtfduMUkh7H8D4xL23z0+1lW1s/mPTS261Kg44S3zBI6fEiGfc5ZSoq9pXa0lO/er2+LwyJaSndx+rHknaxLUu+DHHjfjteDj/7NJ/7VfZ0kLP/OV+l9s/2Nynw+eT9m1nbtX3vDN896z5q3+OEr6mNlH1XYkA9JsM2AX2KxTh26H8D6G1I5ZYxxdaXhJ1pyke3sYx/pYGM/HcwQYvpHFAHMRYUfmXR3r178bWvfQ0TJ07EiBEjcMghh+Cb3/wmqtVy0q4nnngi5s2bh/Xr14uy9evX4+///u/x0Y9+FADw3HPPYeLEiZniUmZGVpV5Z1acC4MB+9VOgBI3kdHQMy+Ge9gIe0tWxzj9BCD1sm7hD8kf2oEdKG8Tbcnf95SpqLR7zRizNoYMjGlg0S8Ft/oC9qkkx8/1IjfJc7Vpj1nu4Jk1M+Slkn+1Zs/OFIzp6H+WjIvVPm/mBUj0zTV9FNYbgvhOI2ntuTJBPot6E+3pP+LSbLLYJ/YrA8i42m4QyDRC3/72t/GDH/wAd911F4466ij8+te/xnnnnYeOjg5ceumlhePfcccd+MIXvoCpU6eKG+Pt3bsXs2fPxh133AEA2GeffXDddddlikswo4tDCpANaABYp50sYGICkNSppyz2gGqXAjUAlCd11xRstLU5PlctecONvuaGF2cAHFN/VJ98oCNipFr49SWP0vpfRGX2s/R1M0DqfueZirL61BJeDLEyTSGZ+uJqU6+rB8TI21mhx9CWderKF2QUuxIXsaWoiqDQTfO4r/6wx/b2drS3tyfsn3jiCXz84x/HqaeeCgA4+OCD8aMf/Qi//vWvc/dBVmdnJ1avXo0//OEPeOGFF8AYwxFHHIHDDz9c2Jx44omZ4xLMyOJfUBvQAEm4Mdg6F/maYrhgCCgGNSY7E9RwO1O2RsSQPirHouHCYCNiWNqz9EnYJovMgGNYe+OMIYWyyQsUHJd+Z+1LHtV8Br3EDmfPzqQ75AGWVD9PcLHGMfS74QCj1VsX9ab1ywIxTru82RvL55G6PsY3XgNU1poZ/TLnq666CkuXLk3Yf/jDH8YPfvADvPDCC3jf+96H3/zmN1i7di1uvPHG3H0w6ZBDDkEQBDj00EMxZEhxFCGY0cWqQFAxA438XgcawH0/GsB55ZJcbp16MvUl8rdCjctOhhrdTsnWINFXPug5Fw1HsfUBVVk8DIineYt6A9wYF/Maf+Z6Zm8Ae7rYBTm2WI5+JmJkOdtnBB9nu+LvXE48l0rL0GQ8mfhlZwrEsH1nsoALkBteQrv6AQxQPsRYMyS+PmUBkG19TNrUUh2zMmXq1VdfxZgxY8S2KSsDAF/+8pexfft2HHHEEWhra0N/fz++9a1v4bOf/Wwp/fjzn/+M+fPn46677gIA8XTsSy65BF1dXfjKV76SKy4tAHbJh9ptB0dUnrrIV4+j+TrvZ2Pwt/q47Jj0ku24rWlxn4gTv0z15gXA/gsSjX3kXMVS2jf00bhIUn/pC4zle+AYYnnFdPTbvWiVlfPK2G7Rl/FvkbPfWfpext8g/E5avgO2+M7vmd/fwx5XOx7k4yVtEW/8EbqPW71euidPYh/k+Ma2JTvbYl3dLotP2vu8IKP3J2FbhQAZHYBqqLIWAI8ZM0Z52WDmxz/+Me69917cd999eOaZZ3DXXXfhu9/9roCPolqyZAl+85vf4NFHH8Xw4cNF+UknnYQf//jHueNSZkYWk760AESGBkisjbG+t9yPRjShZE6kA8IWE+qvffWSaLu/6zJqW2wAyUW60mgYVJN18j1LEmtFmPaUaRb1U1IAbVDoR5yRkm107GYGOwbDDoXx9SytGMQDQy6Ffw1MaZZ+/hknq5Qiw/ocObZS5EjnWH/ZZ15BXL/Bt5BydNM7C5S2cDOlOkuWxeljKDMu2AUSWRejrbENtbBQ9sXQhjO74juV5PDzApis/om7JRvAxWYvZ2PqfCzV+9Lsyy+/HF/5ylfwmc98BgAwZcoUvPLKK1i+fDnOOeec3P3g+slPfoIf//jHOO644xBI4++RRx6Jl156KXdcghldEYCE76MpJyB92kl/b1gcDIQHmXX6iNtpPnLcTGtqom3jFJTup9kKe3HST9oCsK+xEfHizdQpqaidxLSU3u+o76YTQBLGeMxksXN9i2N6J22qybYA2SjHlJZNqe23uHJNUfl+3nmBRfibDbKuw0m72ijVNgVOjH1KAxjdJgvAAPmmkvL65c3E6HU+9g0EmbDJ7JdX6/5Z9Oc//xmVivrrsa2trbRLs//0pz9h/PjxifJ33nlHgZusIpgxqWyg4eWAHS5S1sRY/QHn1Uzefnp7gGovH8OOhcNcmRYQSza54SbaD6OtafyxAI61b1If0054XsMdP2azXOZZUdcrDWjlufzV0yUvsKT6O9xKhxcgF8AAJWdhgMZBjCuGFUx84MgDZAbw5dmnn346vvWtb+G9730vjjrqKKxfvx7XX389zj///FLiH3vssfi3f/s3zJ8/HwAEwNx+++2YMWNG7rgEM7JM95kB/IEGcE87aT5eWRZHO15QY+hT2pVG3tkaIDVjA6SDTRgXyYEqC9wA/tkbG+CI+Oaqsq5UypVZyZLtGSjKsbveoOfxCzvPVU/W6SKgPvBisEvNwBjaywIwqfZZfH3j+F7aPQBAhhWcZsqamfk//+f/4Otf/zouuugibN26FV1dXZg3bx7+1//6X7n7IGv58uX467/+a/zud7/D3r17cdNNN2Hjxo144oknsGbNmtxxCWZ0WWHFsY5GTo0VydIA2aaeXDHgF8fqy/0t9sKnKNiIfVCLisCN6Jtn9kbxyQE5zj4n4jTZtFL+MVJVDcf3XJkoz+mA9CyNy7ckcLG1Y7HNlX0x2RnCO8EA8M+mmLbzZnAsEOPsrw/EOH0MINOgHxMM3l9nq38WjR49GjfeeGPpl2JzzZw5E7/61a/w3e9+F4ceeihWrVqFD33oQ3jiiScwZcqU3HEJZkyyAQ1gztKkZVJMl3Brdb6XVpcONZqv1d8IICWADWCJLdkFdjv7FFIGwAHyQ47Sptsk883qtMvgy1DiR1qNxueaTIVlHNH9szRpcbJDi9PPFs4XXgy2XvBiaNucFSqQhUnxz+RbdErJFc/p4wEyReiChClTppR2dRQXwYws/QueBWh0OxeAWLI0gGPqyRVf27ZfPWXYT0e2JuFvimHL8LjAhvfTtM7G0L9Mi3fzAA6QC3IU/xJgJ47J35Q0YErf3Yastyl54M+8Dx72TmABnNDi9HeFLQAvQH6ACdvwBxBvH98MSppvXhgqCjL6/WOsf9P6HkRVBIUeP1Lk7sFlSb/7sEvyvXCyiGBGl8fUULitAQ3gl6XhdaYsTVSXd4Gvadt5JZNub8qk2Pqi90frO5ft7r7ecGMBFm/AccGGBXBEvwH3SSwFdJQ4vuNfBuhxtytvNNevyFKAKmOMVFjhygstQHng4rJPW7zr6EsqUADZIUQvqxHEJGIlbD3AJdFXD5Cxxa2j6n01Uy30nve8x/tKpf7+/lxtEMyYZAMavU4GGt02LYuSdeoJ8F7ga2oz65VMmaahTH1y+elZG7097uuTuZH67LXuRvaxjU0OyAnj+oFO2Ce/ATAz9JgkfU1b5oqnEvrpDSpAKqx4xcsBLWHcbD7GzIvN3gdeTL4+GRiTXxbw8PH3BSJfiNG3nX4eC30TsUHKoEceeUS8/6//+i985StfwbnnniuuXnriiSdw1113Yfny5bnbaCjMLF26FN/4xjeUsgkTJqCnpwcAwBjDN77xDdx2223Ytm0bpk+fju9973s46qijhH1fXx8WL16MH/3oR9i1axdmz56N73//+zjwwAOzd4ghhglTFgUw3DxPzoE6brIHmLMgJqhJAwnXtFGKEksm9BvhVdJjmfg6EccQy8jlTDqR6xV6u/1Qp/skW/nmfcKe2ewBMJZcP6I3bfEVfw/XDw3tx4V5H6WY+v7muTd32jnY85dRWcoEGVmU8XYX3v3wMcsDK2l+WaAFyA8uQL7pI1NZWpy0GEVgKG39is+UEmCHGN02bb9qrCoLENTxpnm10AknnCDef/Ob38T111+vPB7hjDPOwJQpU3DbbbflvjFfwx9ncNRRR2HLli3i9dxzz4m6a6+9Ftdffz1uueUWPP300+js7MScOXOwY8cOYbNgwQI8+OCDWLlyJdauXYudO3fitNNOy52qApCB6B0Hh26nx+Tbep1823RDvXLb8Kr08mkrLV7WmIY4zliyn8U3viW69jK1LceoJl9Ge8nPeTt7l6+tj6aXZR9tL+Nnl/elybcPZb2MKnG/MvfD82+V9nfP9b3hfc7yPbX12bDvxrZNn7nhs0v4+sSyxdHt9TJTvSGetU9p62L0batfa4AMb7boq5n0xBNPYNq0aYnyadOm4amnnsodt+HTTEOGDEFnZ2einDGGG2+8EVdeeSXOPPNMAMBdd92FCRMm4L777sO8efOwfft23HHHHbjnnntw0kknAQDuvfdedHd34+GHH8Ypp5ySrTP6F9c0LQRkWxwMONbdaG3IdSm+uaeNSp5G0uPIfbPGcsXT/EUM0wHpWgQM8y9e61SV5Ov6he29ODfHWhmgWDYjkXnJmMFohErL3mQJ49lm4ZvruT5/m6/ta2m1N5Rb2s2VgTHEyzUN5QAYr75lycbo276LfH0XEJu2Sd7q7u7GD37wA1x33XVK+T/8wz8knuydRQ2HmRdffBFdXV1ob2/H9OnTsWzZMhxyyCHYtGkTenp6cPLJJwvb9vZ2nHDCCXj88ccxb948rFu3Dnv27FFsurq6MHnyZDz++ONWmOnr60NfX5/YVlZa2yDGBBuuxcGAG2o8F/DWDGocbTphRM7luWJH5UYwkeOZ+qr1zxojC+Dw/lgGeh/ICftiro77lhLHEDO0TzdP+mubA2GALboLGT8Dr7VFRaAlzb+e8GLz94yZC4ZSICYRt1YQA7QsyAyEBcCybrjhBnzyk5/EL3/5Sxx33HEAgCeffBIvvfQS7r///txxGzrNNH36dNx999345S9/idtvvx09PT2YOXMm3nzzTbFuZsKECYqPvKamp6cHw4YNw7777mu1MWn58uXo6OgQrwQN+n6RUw807eDxnXoybWeZfgLcUzxpbRriGqe2XLF949li6v6WGMkBVnvZ+qPHNKT/A1dfrH1Lf3nHdLRj3NeB8Er7e5X4d8g0pVjkO+L6W8E8XWaNyWWZTvSeevKMmXs6yhbbFjfjeCfKrO3pttUMtsz+Xu9DHVTWU7ObRR/72Mfw4osv4uMf/zjeeustvPnmm/j4xz+OF154AR/72Mdyx21oZmbu3Lni/ZQpUzBjxgwceuihuOuuuwSx6ZdzMcZSL/FKs1myZAkWLlwotnt7e81AY5tmkrdTp5KkaScv+5TtrJkawL1g2DJVZCrLPRWlx4vKvbI2tn474ijxbGNPWgbFMVUl4puyVDYVuNdLM19mXU/lvkIrw2eWmmXxieeodmbPXHVFsy+2cp8MjM3XBRe+sRM+Ke2k9SNLNka3T4Mlxa9+c7gDYQGwrgMPPBDf+ta3So3Z8AXAskaNGoUpU6bgxRdfFOto9AzL1q1bRbams7MTu3fvxrZt26w2JrW3t2PMmDHKC0DyC5r2a0SW6ZeEeF9NHlR50qcZfrk4MyCuuJ6/4rwW/NriecRMXQxripMSz2sxqCuuHt/ySz1XZsf2OcE/y5A5G1FDld1n4y38c3yepfy9hI3lJT6DlEXRrr+756JnY6y0+FkzML5lenxJXgt7TeOZa8w1xVDqU7IxLQAyA0W//e1vMz11e+PGjdi7d2+mNpoKZvr6+vD73/8eBxxwACZOnIjOzk6sXr1a1O/evRtr1qzBzJkzAQBTp07F0KFDFZstW7Zgw4YNwiazXECjbxsHIUe9DjVpqVSvgSMlBgwDiS90eJZ5Tx1ZTwrmE4bzZFAi4Hhf8eKKn/PkmTiJ+sT3eTlUC9DIBEwl75/vZ5xn2tD5nRCfZ9p3KqUNy3c51/STT3xDv53+WdvxiS/L54edK0ZiDNTG2Tztmd5Xqw0BmRoPB3XRMcccgzfffNPbfsaMGdi8eXOmNho6zbR48WKcfvrpeO9734utW7fi6quvRm9vL8455xwEQYAFCxZg2bJlmDRpEiZNmoRly5Zh5MiROPvsswEAHR0duOCCC7Bo0SKMGzcOY8eOxeLFizFlyhRxdVMu8S9sJWI9xmCdZuLbAJSpIP1Ge3K9zwJh2d63TVMMycZrmsjia+2Tow1rO7wt/SizxfaJb2qDt2OKlxLXGD9tUMiy+FdqGzAATQaZ7rHTFCNYRhX5DBRl3XffP5dPXJdNyv5lWvSbVld0WipLXwxZmFS/tOkkn209jp791n0KLSZO+ZFbQ4VAUmQBcImdyd0Hhq9//esYOXKkl/3u3bszt9FQmHnttdfw2c9+Fv/zP/+D/fffH8cddxyefPJJHHTQQQCAK664Art27cJFF10kbpq3atUqjB49WsS44YYbMGTIEJx11lnipnl33nkn2trasneIY6w4AVdVoOEy3fROtjHdaE+vB+xQw31sbSoxtDL9gNXjRHZGKPABDpP0vjnasbYFeN2wL9GEDnl6W6ab+WVoMzD9na2NIduN6URsfxeTAtMtlep8g7zMqsUImyOk9xVgPnZ5YcWnjTKgxRanALhY20oDD5tdHhDKsi7Gp82Ef+NAZqDoIx/5CJ5//nlv+xkzZmDEiBGZ2ggYo79Mb28vOjo6cNL+F2BIZVhYKJ8MKoafvvrJIm0bULM1Rh+tHd3eFjdP2xZb68nY9OvfZpuxPFObaW141ntBh+8kbA5wKO1uvE3OLJlV0miU6zJ1Xx+PDFJNwMXRduaFxVmzQGVCjI+fVxwPyCgTZKS6vdXdePhPd2D79u25H4yYJn5eOuyeJWgbOTx3nP4/v4s/fmF5TfvaDGr4fWaaVnqGBlChJm3ax/SL3vWcJyA9U2OLa2tbLjPFMvjmvi9MyvRTojxrm662DTFLmVZynbSyXMkk94tv5jjZGgFokPwUKXwPnSz+Gaa7CkGLT72jL5mnpQpmYKxt5s3CmMryQIzJLytAGdt1rLup5zQTih3mg2SIIJhRZPrCKie3qhtoTGWJGFEbTjjRoMblJ/v6gI4cKy0e4sHLepJPueGd97oYQ5vCzHddjKk9V5sGG9fJyRt0fPvlkgFcCp/QMyj1WVKNTugWaT/j2pzCa2V8bfKAiytuVp+iAAOUN5VkipUHYnzazzqt1OjvPskoghldqTBiWBwMZFusC6QvEgb8oMbk6wIdUz9s8STbTBkbPYatH65yR9tK+3offPqit+1pk3ZSy/04gVou4M05nVUzWKnliSDnAuJM++prWwBcgJzw4qrLMH3kbL/MLEymeDWYUjKVNSHIDLQ7ANdKBDMmpQENYM7SANmyJN7TSDmhJq0srS82W6iDXerN7vQ4cizfzI1Wnwtw0vrk2weLre9JsdRnKKWt62m1X5ElXvla03UzvrZF19fknaZy+dUqA2OzrzfEmOyyZmN8fOolBppn8hDBjE1e2RUNaGx+aVNRQG0yNbK/LTPjOw3liGEEG8AfbjwBxljvAROlQY7elzRbi09p62WAUk/+za66rpvJ6lPrRcFpNmXBiytWUYCxleeZTrL1p4xsjE8c22dRCxV9JAFlZgahqsz9IEVe5pp2Mvm54MJ3yscXarz8M8BOAbABPOEmK8DY+m3xb/Ri30wnUQu01GuNStarrFp67UxW/zIXBvu0nTdjU+ai4SwAYyvPm4Wx+Ze6uLjJQWYAqa+vD5VKBUOHDgUAvPTSS/jhD3+IzZs346CDDsIFF1yAiRMn5o7fVHcAbgrpd5MEzF9uE9373I/AK5alDwnfKqyPSrD529qXy+UyuZzHdd16XIvvvJ275c6kaTGN9a798uybsY+mfrr67Wo7rc9ZfbPE9ZTtM/H+rLKoVvtZxD/D39n7c/FpO2u9q8+OPlpjKvEMx7jL3lSeFlvxN4xhJn/vcdFSpss0Xpv2wdV+HdTA4aBUzZ07Fz/96U8BAL/61a9w1FFH4V//9V+xZ88e/OxnP8PkyZPxxBNP5I5PmRmbvKZ9DGW2BcKynW+Z5w3wQn/5PuKGS7u5v96WrQ+ucl5nOrBNfZR8nFkSZ3Yk5YgMHO1msQEy37ol9cZ8LuW4UaCXTN/NZlGtR9cCU28NWQzsY1OrBcNZMy+uOiMw2Gw9p5JMMUx2vmU+mRhTmdYHZssi1UADZQHw+vXr8YEPfAAAcOWVV+Kiiy7C9ddfL+q//vWv4/LLL8fatWtzxSeYkZT4ghZZZGtbT+PjazsRZZ2GArJNRdn6YeqLrc4GULqP5tfQK5ay2Om2KLDwF6jt4l+geX6WZVXJ54rcWaRGwU2t4AWoPcDY2vCdRrL6Z+hDAkZyQoyhL/UEmYGkPXv2YM+ePQCAP/zhD7jpppuU+nPPPRc33nhj7vgEM5oYqyLQ78SrZ2lCw/SFvab1NC5fwA8mfBf9ArUBG99+utpJi4mU9TdAOuCY2rD109fOZZvil/WEmrp+ZRCPqaWs1ckToxZwU8vHIADuqZGskOKqq0UWxmVf62yMoT8NARkWoNAi3ibJzEyfPh0//elPccQRR+DQQw/Fb37zG5GpAYBnn30WY8eOzR2fYMYgK9AA7jv48jIg+yLhPOWmPjljGBYOy3H0WHkyMy5AsU1L2Xw1/9TsDeB3tZKtLa09p53Lx9fP5Y/aLK4t7TEKGVTXRcJF26ol4HieBxsCL3nrsgBMrjjNATGhWWN+PRRd99Isydmrr74ac+fOxTvvvIPPfvazWLRoEV588UW8//3vx/PPP4+bb74ZS5YsyR2fYMYi/sVNzdK44MN0bxrADDV6jDxQAxTL1vjGsvXV1V9bvWtayuSvxfC6UgkoDjmGtr19XL5Z/LPEtJk3y8jmUq36WI+pJqA8aPFpO21BatnwktZmGRBTZDpJxB0YIDOQNGPGDPz85z/HwoUL8Z//+Z8AgG9961sAgK6uLixduhSXXnpp7vgEM7JMv/yzTDsBnmtfCk4/OWOnZGsSfcwBNs54bvjIDDdpbVviFIYcIP+decuCFh9QaQU4qYXK2u88cWrxOATfvhSBl7T6RgKMyz5LeT0gplowVZJVLHoV8W8SzZgxA0888QT+9Kc/4eWXX0a1WsUBBxyAgw8+uHBsghldBlDxnnYKjTOAh+ciYblcr0tbV2ProzGWfl2nZY2NHjMNUHyzOjb/vIBjiOX97CUg/aRlW4BbwhRT5jhZVM+ppkbAVhlt1gpYuMoAF584eeElrf2sAOOKlyXjkiUTkyV2FpCpswbK1Uyy9t9/f+y///6lxiSYMckCNIDHtFNojMg4vVw+CH2mn7LG530UbXiCDVBO1sbVT996k41tUMkJOUBG0AH8T3iuq47qOMVUSpv1Uq36WK/LtoFs+1AGuPjY5M2+AHaAccWtZRYGKA4xQFODzEDVU089hUcffRRbt25FVfsbypdrZxHBjE2WzEvmLA2QLVMD1C5bI/fV1V9jW55gkxbXGNsDXnxsTH0x9ccWzxHX50RW2iMHfG9l2QpQUmuVtJShLpduA/4nxDLAxccmT/YlLW6ZV0/VGWJC8yYEmQF0qC9btgxf+9rXcPjhh2PChAkI5DWQBbLGBDOyGEPijmkGUJG/7EEt7uNSJFvjaiPRToapI9nXNsjZbtanx/fJlvjAhu/6lSwDkeumfyntlLG4NvXmgSSjSlvYnDdO1pNdmetoSllrk/KlK2v6qEhdFoCxlWcBGJs9Y3X9ITHQppluuukm/PCHP8S5555balyCGV0ZF9YaMzXc3pURyJqtAYqDTVpd4QyLY81NnvjWdvynjjLZAumDvulv6mrHt11eXeIg2YjLsLOopS7ZzvPLPEubZdvWEl7S4ucBFScslQAxQDmZmIasAUOxzEyTZXUqlQqOP/740uMSzNhkWsgLZF9PA9ihxnXyNbadMg1l8stbB7inpHz8s8KNTzvO9kqAHJs9l89JzQY8ae26lANMWuIy7KyqxT4VmUKo5ToaX1uv9TYe6b56A4yrzgYwLp8yIMZmPxCPpQbpsssuw/e+971Cd/s1iWDGpQxAE5pnhJrcGRQL1Mh+aSfwImADZM/aAOlwY2rH1JapPWe7GcHFd/rKpqzTWj6iwTSbylrjUK+1NGWCC1B7eEnzz1tXJsQArZuNURQguf4hq3/zaPHixTj11FNx6KGH4sgjjxRP0eZ64IEHcsUlmJFVrQJtWpkLaAAr1Finniw+XhDiOwUl+6TFNNX7gEmWrI21D6ZHERcAHFO7rvZd9i6fND/fGEDxk64vDLWaar3gsowTVJ4YWXzKBBeftoteUZUWv1khxmGfK3NUtgbYNNP8+fPxyCOP4MQTT8S4ceMKLfqVRTCjK8u9XwDnWprQpQ5Qw/vNVSbY+NSXdKO70K4A4JjadbXv6keaT5pvlhhZ4ulq9FUWzaKyfz0XiZfVN/Pi4RKyLr7tFgGUtPo8AJMasySIcbVTT5AZgLr77rtx//3349RTTy01LsGMSSagAQpBTehWwh120+oAf7BJi+1Tb+1DyrSUT1vCLuXqKVe7aX0w9cOnTz6+WeJkjeerZl0E3KjUfaMyMkBtoEXYljRN5ROnVgCT5lsmxDh8mg5iBlhmZuzYsTj00ENLj0swY1PauhTX1TCWk6Z1+on7AfmzNbZ6F9j4+KfV+9rkgZvUdjNAjqkPaf1x9SnRZskZGt+4aWr4fH+NVKv9ashVTxlPkqUuDPadyioIQXmzMGn1jn0sbUoJaGw2ZoA8NZtr6dKluOqqq7BixQqMHDmytLgEM2kqMUsTujmmn1J8nW361LsATfa3xfBaB5MzcwNkAwrnepaMkGPrj6y0tSlZToJZAKXeMDJQ7ypcVv8KXflUI2gBsvWr1tkXrmYCmBS/psvGDGDdfPPNeOmllzBhwgQcfPDBiQXAzzzzTK64BDOyWJTPK2uhrWMaST/onFNQun/ayT2t3naA2u5jk6WdInZZgCJPxiTLycTnMnJf+d5PpxbKCif17FsjAai0q51ynuzy7HvZwOJrVxRcfGIUWJyc+kTrsiGGsbp+d4s212y/Mz7xiU/UJC7BjEnOaSRLpob7AZmzNaFrgYxNWttyvcsmbUpKj+PbXhY7Z/8sR2Xe+7rkye4o/p7PHch74izjSqVmG8lqoVotgs4LKkqMGkNL1jbKghegOMD42NQbYoDsN+mrtQbYmpmrrrqqJnEJZmxKAxrAfcJPOyHXGmq48q6D0Q/osuGmLFsgH+TY2vFtEyiW6fFRra9Uqsdl3c12tVUZgKLEK7B/zXJX4bLgxTdWAYAJ3XNOJaW1XWRajJRZ69atw+9//3sEQYAjjzwSxxxzTKF4BDMu+axByZOlAbyhJgzhcdVOGRkbl13ZcFPU1scnz4JfnzZ921diFXlccw4Q8lGzgUYWlQ0lxjZK+HzyfsZZ264F5PiuFyltqqoJISbNtx4aYAuAt27dis985jN49NFH8Z73vAeMMWzfvh0nnngiVq5cif333z9X3BqNkgNMaQcCf9l8XZOeVRa/rM1X/VKqaWlVn8lXXzt5v33ml33immyz9NfXB1A/d9PLV7b28/TJ2kaVXvor92dZ8t+r6PeorO98Fnvn/ngc03rMIjYpnxUf+5xXJvmMe9b2862NYXVcGByw4q9m0vz589Hb24uNGzfirbfewrZt27Bhwwb09vbikksuyR2XMjOSmOkOwKIy+kY4MwGOTI1PjKLZGjkGV6H7u3jaAf6ZG1PctNh5sjJFp5B8gSbLVE0RoGnW+8U0QvX6pdxqj0TI6pPlhFzmlJXH51poPYxPPwpkY+oJMmGD0auIfxPpF7/4BR5++GG8//3vF2VHHnkkvve97+Hkk0/OHZdgRhP/oga5p49S1tN4xZC+fUXAxjOWcuCWNS1kOuDLBBybj4+fyzdLDCDbCa/IGpVGp7oHimoxtVb0b1Mv2KkFvPjalgEwPnEGEsQMUFWr1cTl2AAwdOhQVAt8xjTNZFHqF9cnfVk0BpBpGsp7Ksp3OqrM9DWQnJrKksrO0k4ZUz21mDZKm5IoY9prMKien2NZ34Mi/nn8ih5rZdiWNXZlGbesMTynw23VzXDTvCKvJtJHP/pRXHrppXjjjTdE2euvv47LLrsMs2fPzh2XMjMOpWZpgPAA8M1Q5L1ZnYgV2Tl+4ZeasdH7lta/PNmVrBkcWzu+7ZWVkfGJVSS2LgKa8lSLLFcZMfPGyHOiLTvzIvqSbuuVgfGMVTgT4xGj4RkZhmJTRU02dNxyyy34+Mc/joMPPhjd3d0IggCbN2/GlClTcO+99+aOSzDjIfnLbAQb3xN+WWDjefdc06DhdWWUI2ZmkMgDDz6Dh+/VVFnazeKfJWYZsbOq1dbYNMs0WjOCTq1hJY9PBriuK7wAAwNgBrC6u7vxzDPPYPXq1fjDH/4AxhiOPPJInHTSSYXiEszIYgxIvbVI1Z2p4XEAv4yN7zoS3wWrKesyUu88bIrJlfW+LXnXrvj4uQabtL+Prd08/cgas2gbvmoWOGik6vEZlNVGkZNnrcGFyxNgvOElQ8x6QQzgATJ5p5nzaoBlZrjmzJmDOXPmlBavadbMLF++HEEQYMGCBaKMMYalS5eiq6sLI0aMwKxZs7Bx40bFr6+vD/Pnz8d+++2HUaNG4YwzzsBrr72WvyMeX1RWrfqRe9a5bZ9YWdbYeKZ8vdbb5Ihd1zUCSj8N6wV8PmPffhRdO5OnjVr3o5nULJ9H2W2U8b0s63hK7SvLdLznHkd8++2MV876xNRxvVHHGSvh1WR66qmncO2112Lx4sVYuHCh8sqrpoCZp59+GrfddhuOPvpopfzaa6/F9ddfj1tuuQVPP/00Ojs7MWfOHOzYsUPYLFiwAA8++CBWrlyJtWvXYufOnTjttNPQ399frFOeBF8a1AD+A1veQSk1bDX/oJRlgWXek0KtTyh5fx03C3SUCUaNfDXLZ5NVZX23ivYpj0+BH0ENARigfhDD4wwivf766/j85z+PcePGYeTIkfjgBz+IdevWlRJ72bJlOO6447BixQr8+te/xvr168Xr2WefzR234dNMO3fuxOc+9zncfvvtuPrqq0U5Yww33ngjrrzySpx55pkAgLvuugsTJkzAfffdh3nz5mH79u244447cM8994j5tnvvvRfd3d14+OGHccoppxTrHP8Cp0wFeC0UzhDPa22NHtMrrmTrcZlwpikpUxsZ2jIOFt5313UMNFmncXxPOj5TWTaVNTC22rqYvGqGE0nZayjK2Ke8MXIuJq/J9FEYOENczz54/hgtI07NVec7AG/btg3HH388TjzxRPz85z/H+PHj8dJLL+E973lP/j5Iuummm/DDH/4Q5557binxuHKNyEuXLsUrr7xSSgcuvvhinHrqqYnFP5s2bUJPT49yE5329naccMIJePzxxwGEz3bYs2ePYtPV1YXJkycLG5P6+vrQ29urvJzy/KWQOVOT5ddHLTM2GebCM/8iM7VVJIOT9VdzrbIAab/Cy8j4pKnRGZRWztTU4+9X1j4ViZHz2Mt1rOedgk6NW/JUPFoIZFDeHYD1c15fX5+xvW9/+9vo7u7GihUr8Jd/+Zc4+OCDMXv2bBx66KGl7E+lUsHxxx9fSiwlbh6nn/70pzj00EMxe/Zs3HfffXj33XdzNb5y5Uo888wzWL58eaKup6cHADBhwgSlfMKECaKup6cHw4YNw7777mu1MWn58uXo6OgQr+7ubr8Olw01csxagk0euMk56Hmr6D1Aan2iKPuEmvXkWQ8YamU18vOsxXemjDj1BBdTe+kN1XasSzOLxuWmW+BbJ3V3dyvnPdN5FwAeeughTJs2DZ/61Kcwfvx4HHPMMbj99ttL68dll12G733ve6XF48o1zbRu3Tr89re/xYoVK3DZZZfh4osvxmc+8xmcf/75OPbYY71ivPrqq7j00kuxatUqDB8+3GoXaKl0xliiTFeazZIlS5SFRr29vSHQVJn9cQZqA7xzbjPf6aeMcQFkm4qSY/vGB5IDVI6pqbA5z/3Pcom4uxPu+jzTM1kGt1pM/xDQ1F61PoGVFb/gPYcy/ego0m7W/c2zQN/HrMSpKQDh51BP2GHRq4g/wnPumDFjRHF7e7vR/OWXX8att96KhQsX4qtf/SqeeuopXHLJJWhvb8cXv/jFAh0JtXjxYpx66qk49NBDceSRRybuBvzAAw/kipt74v/oo4/GDTfcgNdffx0//OEP8frrr+P444/HlClTcNNNN2H79u1O/3Xr1mHr1q2YOnUqhgwZgiFDhmDNmjW4+eabMWTIEJGR0TMsW7duFXWdnZ3YvXs3tm3bZrUxqb29HWPGjFFeQnmmQdLMfH8R6HG9D66MvzjL+uXnKdMvv8JZnCJ3xq11FqaZplMGm/J+9kU//1rEL+E7X+px59dgjnEl59iVZlr6BRoFxpwmkH7Os8FMtVrFhz70ISxbtgzHHHMM5s2bh7/7u7/DrbfeWko/5s+fj0ceeQTve9/7MG7cOCVb1NHRkTtu4QXA1WoVu3fvRl9fHxhjGDt2LG699VZ8/etfx+23345Pf/rTRr/Zs2fjueeeU8rOO+88HHHEEfjyl7+MQw45BJ2dnVi9ejWOOeYYAMDu3buxZs0afPvb3wYATJ06FUOHDsXq1atx1llnAQC2bNmCDRs24Nprry24Y9GXNsviVY9f5LmzNZ7xE4NCnnuuFHkuUYYsim1g9c7k2PqQoy+KfAfisjMw9QKaRi4cbjVoq3V/Szo55s62lNGPJsnACPOsV475qIEQE6DYk6+zHu0HHHAAjjzySKXs/e9/P+6///78nZB099134/7778epp55aSjyu3DCzbt06rFixAj/60Y9E+ul73/seDjvsMADAddddh0suucQKM6NHj8bkyZOVslGjRmHcuHGifMGCBVi2bBkmTZqESZMmYdmyZRg5ciTOPvtsAEBHRwcuuOACLFq0COPGjcPYsWOxePFiTJkypfDdBIXyQA3gPQUly/tqKM82AJgHjlo+LiDtoM85VZXsRs4rq3zkC0G1OtHVGjZaDSh81ej9qtEJrzCocNUTWESbOfreDPACtHQWpoiOP/54PP/880rZCy+8gIMOOqiU+GPHji1tMbGsXDBz9NFH43e/+x1OOeUU3HHHHTj99NPR1qYuNvnCF76Ayy+/vFDnrrjiCuzatQsXXXQRtm3bhunTp2PVqlUYPXq0sLnhhhswZMgQnHXWWdi1axdmz56NO++8M9GfwsoCNUC29S/cpUjWJktbebI3RdsUbRfL5sTdcA9gmbI7unwHsSJPwXapESflVs0y1UN1OKmVBixAOf2tJ7zkbK9mEAM0F8jU+dLsyy67DDNnzsSyZctw1lln4amnnsJtt92G2267LX8fJC1duhRXXXUVVqxYgZEjR5YSEwACxrJ/i/73//7fOP/88/EXf/EXpXWkkert7UVHRwc+2n4WhgTD/JzynMhynDC8waaEtoSK3EOljPZl1QgYCsFOEdUKgEh+atBJqlRY4SprX4qCZx2yL8KtxlNUvp/pXrYb/9H3T9i+fbu65rJE8fPSQcu/hYrjIpk0Vd99F68suTJTX//1X/8VS5YswYsvvoiJEydi4cKF+Lu/+7vcfZB1zDHH4KWXXgJjDAcffHBiAfAzzzyTK26uzMxbb72F6667LtUuCAIvu6YRY/4TjFkzNTw+l+fJPvUhlz5tZWgPQL6pqbT2s/ZB9KUGa2JQ4lRWVpV5Mh1MYNRMv5Q11QRUuMre70aAS8G2cz30sdaZmIGUeTTotNNOw2mnnVaT2J/4xCdqEjcXzDz77LNYt24d+vv7cfjhhwMI59Ta2trwoQ99SNilXULdlOIDU57LifOATY5pKCBHxqbw9FCBqSlbH/L2hatGoMOV9SRV92xPE5/gW1k1hROTavF3LO0y8PrDC1AngAFyQEwDbpHAolcR/ybSVVdd5WX3ox/9CGeccQZGjRrlZZ8LZk4//XSMHj0ad911l7hh3bZt23Deeefhr/7qr7Bo0aI8YZtLrOoPNFx1ytYAyYO94XAD5J+eKhtyAL9BquTMRpGTYMOmvQaw6g4lNtUSOsvMEJRxL6N6A0zeNlsBYiLJd/HN69+KmjdvHqZPn45DDjnEyz4XzFx33XVYtWqVcufdfffdF1dffTVOPvnkgQEzQPYsDVceqAFygw1QMGujt52zD9bBsGzIAcpZk9Pohb6S6nHibSZgahrQKKJ6ZcZqMaXRYHARIZoZYICGQsxgV9blvLlgpre3F//93/+No446SinfunWr8kTrASP5C533HigNAhugwCLiotkbrrIhB0gfzMqc4sw6CDbpWpYBARC1VKOm7Wq5/qLMO0c3El6KtJ/75ppNcrwMsGmmWikXzPzN3/wNzjvvPFx33XU47rjjAABPPvkkLr/8cvGE6wGrotkaoK5gA9QQbnL2R6gWkMPlM/DVak1XGSfFJgWiplazriGqx2LRsh93UVKfC8FL0X60OsRwEcx4KRfM/OAHP8DixYvx+c9/Hnv27AkDDRmCCy64AN/5zndK7WDTKm+2Bsj1zKO43eLrS1wDTOG1N4mAea5gyjCY1DK7k6ZaLnBv1hPzYFSjrlyp5fO4St6nwtAClHCl1QCBF1Iu5YKZkSNH4vvf/z6+853viOvFDzvsMO9Vx80q5vugyaRj+H/eNQlFsjaiD8WyNyJMnjsTOwPWYHGvrLRBtIwsj01FBt9WvNKv1dVsl9PW4+GhNdjnUsBFBGsQwACFIIbV8cfGYF0AnFWFns00atQoHH300WX1pSnEqgxBbqAokK3hKhtsRH+aCHCA2i/u5fIdeGsJPSbV8sTayqDUbMCRV/V+ynmNPrdSwQUop59FQaJFICZutL53AG4WHXTQQYkb6rnUPJc3NJFYlRX/0rJq8fRl0adDK/1h6qtoOOlJ4JmeCO4VnLlftZD85PG0V7PL5wnOzfpqZjX6O1Ljz60mx3RZ/SxjLCwwJpdyTsgrVsKrifTwww9b6/7hH/5BvN+wYQO6u7u94xLMOFQq1JQJNk0IN4B5MCz9lx3Q+BNilpNaq4HQYFCz/u3q+L2u2XFaC3gpA2BaEWIGqE499VQsWrQIu3fvFmV/+tOfcPrpp2PJkiW54xLMeIh/oZsGbIDaw02Jg6cNcmoCOkBzZwCKgNBgg6SB9Fk16DtZ0+Ou7H0odTwrNs42E8TwNTNFXs2kxx57DD/96U9x7LHHYuPGjfi3f/s3TJ48GTt37sRvfvOb3HELrZkZjOJf8NzrauJA8fsybmZWxlobXSWvvTE24RhYC6/LcTac4QhvhTUoAxVoml1NMDVWsx8FSiM12s8ygaGEH4nNAjCKik4VNdkuTZ8+HevXr8eFF16IqVOnolqt4uqrr8bll19e6BFIBDM5VRrUhMHi92WDDVctAQeoyQk/bZCuKewoHck5GrQCBJFCNQGU2FQXWFEabAFw4SrpsuqmhJgBrOeffx5PP/00DjzwQLzxxhv4wx/+gD//+c+FroimaaaCKm0KKg5Y7nQUV9nTUroaMJ3jmr6q+wnA2EGPqYWBsDC2URogn2/Dvse1/ixqMeaUPD4203SSVUWnmJps96655hrMmDEDc+bMwYYNG/D0009j/fr1OProo/HEE0/kjkuZmRKlHxSlZ23iwMXjph3Atc7k6GpAZsdHdcv+pImApmnVFOAsq97flVrBQA1uZtf04GLSAJtmuummm/CTn/wEc+fOBQAcddRReOqpp/DVr34Vs2bNQl9fX664BDOyWBVAtRxYgHrglAI2cWB1uxYPEKzlVJVJaQNwg6Zs8p6omgaCSN5qOihxqRFwWw8QaAWAKTtrPsj03HPPYb/99lPKhg4diu985zs47bTTcsclmDGp6B19jSFrBDZhcHW7Vk9Htg0K9XiOkM/g3URrVMo+MRIcmdVSAOKrZsjC1e2J4LX5+9UkA9MogBlgmRkdZGSdcMIJueMSzLhUA6gJw9YQbMIGkmW1AhzAPfDV84GJDZzSqrUG5El7sKkZIEVWvadcagwDNZtCanAWZiA8ziDLA6gfeOCBXG0QzPio7KuNlNA1WGdjbihZVkvA4WoW0JGV9aTSgvBDqpOaDVBMatida2sPATVdA0NTSaWpo6NDvGeM4cEHH0RHRwemTZsGAFi3bh3efvvtTNCji2Amq2qUrYnD1zhrozaWLKsH4HA1I+iYVOSERSDU/GoFIHGpGRa11unEX5cFvAQxpWvFihXi/Ze//GWcddZZ+MEPfoC2tvDJzv39/bjoooswZsyY3G0QzORVjaEmbCJ54DYEcMKGa9uuLp9Bq5mAx6ZanigHGyi1OnTkVTPAiqw6n+wHPcAMsDUzP/zhD7F27VoBMgDQ1taGhQsXYubMmfjOd76TKy7BTFHVa/GtaK5O01LJhs3l9YYcWb6DXCtATx4N1pP7QFKzgYqsBp3g63b5dDMDjKSBsGZG1t69e/H73/8ehx9+uFL++9//HtUCawMJZspWHTI2anMNgpu4A/a6RoKOrKyD40CFH1Lt1cxwYlITnNDreu+XJtjfwa7zzjsP559/Pv74xz/iuOOOAwA8+eSTuOaaa3DeeefljkswUys1KJORNjDUFXayDBzNAj5A7U9IBEuNU6vBRl412Um7YTera7LPIbcG0Nf2u9/9Ljo7O3HDDTdgy5YtAIADDjgAV1xxBRYtWpQ7LsFMvVXDK6P8mm/AOhwf+Qw6zQQ8RdToE2oz/L0b/Rm0spr8BN3Qu+w2+WeTSwNszUylUsEVV1yBK664Ar29vQBgXPj7q1/9CtOmTUN7e7tXXIKZRqrO623s3TB/25sCcmT5DlQDBXpqJQKJ5lSLnYib5tEADfjcmmbfW1yuq5fmzp2LZ599FocccohXLIIZSazKwALWuJN4k8ANl+uAbTrQkZV1cCP4IdVKLQYoNjXVybuBn2kjPoeBtgDYVyzjBQ4EMwbV9V4v7o6o20100m2ZbI6P8g6OTfT3INVYAwRKXGoqYNHV4M+/sVNnGFDTTLUSwUyK+Je4KU7STQw3XE21ALnWqsUA24R/05bTIACPvGpqYOFqkr9fS3xWJCGCGU81/BJok5rx3i8p8hkgmuKzbZSaZCAntZ5a9uTbZN/5ZvscB+s0U1YRzORUU2VsdDX6MQUF5TuYNOVnTyKVrGY7uRZSk4ELV1N/xoN0minIeIdzgpmCasqMjUktmMVJU9YBqGn/NqRBp6Y+eZahJoUWWQP+b9DiogXADVbT3sfFpkF0uXMtB6+m/huTcotOeAa1AKjoaum/4wDMzOzduxePPvooXnrpJZx99tkYPXo03njjDYwZMwb77LMPAGDHjh2ZYhLM1EEtk71xqRUeW9BAESg1Ti19ompWtSCwyBpI34mBtmbmlVdewV//9V9j8+bN6Ovrw5w5czB69Ghce+21ePfdd/GDH/wgV1yCmQao5bI3aUob+Ah2CmkgDcykJlGLw4quAX2MDLDMzKWXXopp06bhN7/5DcaNGyfK/+Zv/gZ/+7d/mzsuwUyTaEBkb2waRFNZJFLDNcBAxaQBDS8DXGvXrsWvfvUrDBs2TCk/6KCD8Prrr+eO29Czx6233oqjjz4aY8aMwZgxYzBjxgz8/Oc/F/WMMSxduhRdXV0YMWIEZs2ahY0bNyox+vr6MH/+fOy3334YNWoUzjjjDLz22mv13pXSxaos8RrwYlX/F4k02DSIj41BNxbKYiW8mkjVahX9/f2J8tdeew2jR4/OHbehMHPggQfimmuuwa9//Wv8+te/xkc/+lF8/OMfF8By7bXX4vrrr8ctt9yCp59+Gp2dnZgzZ46yMGjBggV48MEHsXLlSqxduxY7d+7EaaedZvywWl0mwBl0BzZXFvAZwIM8qYVF31+jaIxTxdfMFHk1k+bMmYMbb7xRbAdBgJ07d+Kqq67Cxz72sdxxA5b1+qcaa+zYsfjOd76D888/H11dXViwYAG+/OUvAwizMBMmTMC3v/1tzJs3D9u3b8f++++Pe+65B5/+9KcBAG+88Qa6u7vxs5/9DKeccoqxjb6+PvT19Ynt3t5edHd3Y1bwNxgSDK39TtZBA2qaqllE02AkWYMIMGqhVoaUvWwPHmUPYvv27c6HJRZRb28vOjo6cMQly9DWPjx3nP6+d/GHm79a075m0RtvvIETTzwRbW1tePHFFzFt2jS8+OKL2G+//fDYY49h/PjxueI2zejc39+PlStX4p133sGMGTOwadMm9PT04OSTTxY27e3tOOGEE/D4448DANatW4c9e/YoNl1dXZg8ebKwMWn58uXo6OgQr+7u7trtWINky+K08gDScOXJBtEv7saL/m4NFY1DBTXAppm6urrw7LPPYvHixZg3bx6OOeYYXHPNNVi/fn1ukAGaYAHwc889hxkzZuDdd9/FPvvsgwcffBBHHnmkgJEJEyYo9hMmTMArr7wCAOjp6cGwYcOw7777Jmx6enqsbS5ZsgQLFy4U2zwzM1jUsk/DHqiiEyNpAIgApTYaaJdmA8CIESNw/vnn4/zzzy8tZsNh5vDDD8ezzz6Lt99+G/fffz/OOeccrFmzRtTrtzRmjKXe5jjNpr29He3t7QbHKoDoxDJIpxTorrokEgkgOElI/tFBP0Ay6aGHHvK2PeOMM3K10XCYGTZsGA477DAAwLRp0/D000/jpptuEutkenp6cMABBwj7rVu3imxNZ2cndu/ejW3btinZma1bt2LmzJnFOiZ/WQcp2PiIHhxJIrWeCFQ81QzQMgDuM/OJT3zCyy4IgtwX7zTdWZoxhr6+PkycOBGdnZ1YvXq1qNu9ezfWrFkjQGXq1KkYOnSoYrNlyxZs2LChOMwonaK58iJyrd+heXQSqTzRcVaCmm2sHwBrZqrVqteryFXIDc3MfPWrX8XcuXPR3d2NHTt2YOXKlXj00Ufxi1/8AkEQYMGCBVi2bBkmTZqESZMmYdmyZRg5ciTOPvtsAEBHRwcuuOACLFq0COPGjcPYsWOxePFiTJkyBSeddFLtOq5/ySlzU5ryDLSU+SENVBF41EHNAi2kQmoozPz3f/83vvCFL2DLli3o6OjA0UcfjV/84heYM2cOAOCKK67Arl27cNFFF2Hbtm2YPn06Vq1apdxY54YbbsCQIUNw1llnYdeuXZg9ezbuvPNOtLW11W9HTAcDAU7dVHTAJxgi1UoEI02oFoOXIHoV8W8m3XzzzcbyIAgwfPhwHHbYYfjIRz6S+RzedPeZaYT49fyz8PHa3meGAGfQiACpNUXwMQBVA3jZy/bgUfxLXe4zc+TfF7/PzO9ubZ77zEycOBF/+tOf8Oc//xn77rsvGGN4++23MXLkSOyzzz7YunUrDjnkEDzyyCOZrjKms2s9RWtvBo2yrBNqxtdg3XdSi2sA3g9ooN0BeNmyZTj22GPx4osv4s0338Rbb72FF154AdOnT8dNN92EzZs3o7OzE5dddlmmuA2/mmlQy3agUQaH1GDRiZ3U9BoAoDIY9bWvfQ33338/Dj30UFF22GGH4bvf/S4++clP4uWXX8a1116LT37yk5niEsw0o1wHKYEOiUQaTBrs0DIALs2WtWXLFuzduzdRvnfvXnGz266uLuUZjD6iM2OriW61TiKRBopoLPNTC1+WrevEE0/EvHnzsH79elG2fv16/P3f/z0++tGPAgifDDBx4sRMcQlmBqpogCCRSI0UgQrJoDvuuANjx47F1KlTxd34p02bhrFjx+KOO+4AAOyzzz647rrrMsWlaabBKt+BhKa1SCSSSQQjdVEjn820fPlyfPWrX8Wll16KG2+8MX8gSfxmuH/4wx/wwgsvgDGGI444AocffriwOfHEEzPHJZghuZVlwCLwIZFaXwQpzaUGrZl5+umncdttt+Hoo48u0LhdRxxxBI444ojS4hHMkMpTnkGQAIhEqp0ITEg5tHPnTnzuc5/D7bffjquvvrrU2P39/bjzzjvx7//+79i6dSuqVfU7+h//8R+54hLMkBqrIoMtgRBpsIigZNCqrGmm3t5epZyvVzHp4osvxqmnnoqTTjqpdJi59NJLceedd+LUU0/F5MmTEQTl3GCUYIbUuip7gCc4IpUpAhBSGSppmkm/m+5VV12FpUuXJsxXrlyJZ555Bk8//XSBRu1auXIl/umf/gkf+9jHSo1LMEMicTXy5EMgVTsRVJBIePXVV5XHGZiyMq+++iouvfRSrFq1CsOH53+EgkvDhg3DYYcdVnpcghkSqRlEJ1wSiWRQWdNMY8aMSX0207p167B161ZMnTpVlPX39+Oxxx7DLbfcgr6+vsIPcV60aBFuuukm3HLLLaVNMQEEMyQSiUQiNa/qeDXT7Nmz8dxzzyll5513Ho444gh8+ctfLgwyALB27Vo88sgj+PnPf46jjjoKQ4eqD3d+4IEHcsUlmCGRSCQSqVlVR5gZPXo0Jk+erJSNGjUK48aNS5Tn1Xve8x78zd/8TSmxZBHMkEgkEolEqotWrFhRk7gEMyQSiUQiNakaeQdgAHj00UeLBaiTCGZIJBKJRGpWDbCnZgPAP//zP+Of/umfsHnzZuzevVupe+aZZ3LFpOtBSSQSiUQi1UU333wzzjvvPIwfPx7r16/HX/7lX2LcuHF4+eWXMXfu3NxxCWZIJBKJRGpSBYwVfjWTvv/97+O2227DLbfcgmHDhuGKK67A6tWrcckll2D79u254xLMkEgkEonUrGIlvJpImzdvxsyZMwEAI0aMwI4dOwAAX/jCF/CjH/0od1yCGRKJRCKRSHVRZ2cn3nzzTQDAQQcdhCeffBIAsGnTJrACWSSCGRKJRCKRmlT8aqYir2bSRz/6Ufz0pz8FAFxwwQW47LLLMGfOHHz6058udP8ZupqJRCKRSKRm1QC7mum2225DtRo+vuXCCy/E2LFjsXbtWpx++um48MILc8clmCGRSCQSiVQXVSoVVCrxpNBZZ52Fs846K2F30UUX4Zvf/Cb2228/v7il9ZBEIpFIJFKpGmjTTL6699570dvb621PmRkSiUQikZpVA2yayVdZFwMTzJBIJBKJ1KRq9OMMWkU0zUQikUgkEqmlRZkZEolEIpGaVYN0mimrCGZIJBKJRGpiDZapoiKiaSYSiUQikUh10ebNm42Lexlj2Lx5s9j+/Oc/jzFjxnjHpcwMiUQikUjNKsbCVxH/JtLEiROxZcsWjB8/Xil/6623MHHiRPT39wMAbr311kxxCWZIJBKJRGpSDbSrmRhjCIIgUb5z504MHz48d1yCGRKJRCKRSDXVwoULAQBBEODrX/86Ro4cKer6+/vxn//5n/jgBz+YOz7BDIlEIpFIzaoBcjXT+vXrAYSZmeeeew7Dhg0TdcOGDcMHPvABLF68OHd8ghkSiUQikZpUQTV8FfFvBj3yyCMAgPPOOw833XRTpsW9Pmro1UzLly/Hsccei9GjR2P8+PH4xCc+geeff16xYYxh6dKl6OrqwogRIzBr1ixs3LhRsenr68P8+fOx3377YdSoUTjjjDPw2muv1XNXSCQSiUQipWjFihWlgwzQYJhZs2YNLr74Yjz55JNYvXo19u7di5NPPhnvvPOOsLn22mtx/fXX45ZbbsHTTz+Nzs5OzJkzBzt27BA2CxYswIMPPoiVK1di7dq12LlzJ0477TSxKppEIpFIpJYUK+E1CNTQaaZf/OIXyvaKFSswfvx4rFu3Dh/5yEfAGMONN96IK6+8EmeeeSYA4K677sKECRNw3333Yd68edi+fTvuuOMO3HPPPTjppJMAhE/b7O7uxsMPP4xTTjml7vtFIpFIJFIZGmhXM9VKTXXTvO3btwMAxo4dCwDYtGkTenp6cPLJJwub9vZ2nHDCCXj88ccBAOvWrcOePXsUm66uLkyePFnY6Orr60Nvb6/yIpFIJBKp6cTvM1PkNQjUNDDDGMPChQvx4Q9/GJMnTwYA9PT0AAAmTJig2E6YMEHU9fT0YNiwYdh3332tNrqWL1+Ojo4O8eru7i57d0gkEolEItVJTQMzX/rSl/Db3/4WP/rRjxJ1+g12bDfd8bVZsmQJtm/fLl6vvvpq/o6TSCQSiVQj8WmmIq/BoKaAmfnz5+Ohhx7CI488ggMPPFCUd3Z2AkAiw7J161aRrens7MTu3buxbds2q42u9vZ2jBkzRnmRSCQSidR0ogXAXmoozDDG8KUvfQkPPPAA/uM//gMTJ05U6idOnIjOzk6sXr1alO3evRtr1qzBzJkzAQBTp07F0KFDFZstW7Zgw4YNwoZEIpFIJNLAVUOvZrr44otx33334V/+5V8wevRokYHp6OjAiBEjEAQBFixYgGXLlmHSpEmYNGkSli1bhpEjR+Lss88WthdccAEWLVqEcePGYezYsVi8eDGmTJkirm4ikUgkEqkVRVcz+amhMMOfijlr1iylfMWKFTj33HMBAFdccQV27dqFiy66CNu2bcP06dOxatUqjB49WtjfcMMNGDJkCM466yzs2rULs2fPxp133om2trZ67QqJRCKRSOVrgD01u1YKGBske+pQb28vOjo6MAsfx5BgaKO7QyKRSKQm1l62B4/iX7B9+/aarbnk56XjPvZNDBma/2nSe/e8iyd/9r9q2tdmED2biUQikUikJhVNM/mJYIZEIpFIpGbVAHlqdq3VFJdmk0gkEolEIuUVZWZIJBKJRGpS0TSTnwhmSCQSiURqVlVZ+CriPwhEMEMikUgkUrOK1sx4idbMkEgkEolEamlRZoZEIpFIpCZVgIJrZkrrSXOLYIZEIpFIpGYV3QHYSzTNRCKRSCQSqaVFmRkSiUQikZpUdGm2nwhmSCQSiURqVtHVTF6iaSYSiUQikUgtLcrMkEgkEonUpAoYQ1BgEW8R31YSwQyJRCKRSM2qavQq4j8IRNNMJBKJRCKRWlqUmSGRSCQSqUlF00x+IpghkUgkEqlZRVczeYlghkQikUikZhXdAdhLtGaGRCKRSCRSS4syMyQSiUQiNanoDsB+oswMiUQikUjNKj7NVOSVQcuXL8exxx6L0aNHY/z48fjEJz6B559/vkY7V54IZkgkEolEIgEA1qxZg4svvhhPPvkkVq9ejb179+Lkk0/GO++80+iuOUXTTCQSiUQiNamCavgq4p9Fv/jFL5TtFStWYPz48Vi3bh0+8pGP5O9IjUUwQyKRSCRSs6qkq5l6e3uV4vb2drS3t6e6b9++HQAwduzY/H2og2iaiUQikUikAa7u7m50dHSI1/Lly1N9GGNYuHAhPvzhD2Py5Ml16GV+UWaGRCKRSKRmVUk3zXv11VcxZswYUeyTlfnSl76E3/72t1i7dm2BDtRHBDMkEolEIjWpynqcwZgxYxSYSdP8+fPx0EMP4bHHHsOBBx6Yu/16iWCGRCKRSCQSgHBqaf78+XjwwQfx6KOPYuLEiY3ukpcIZkgkEolEalbV+XEGF198Me677z78y7/8C0aPHo2enh4AQEdHB0aMGJG/HzUWLQAmkUgkEqlZxQBUC7wyctCtt96K7du3Y9asWTjggAPE68c//nE5+1MjUWaGRCKRSKQmVVlrZnzFWvTBlJSZIZFIJBKJ1NKizAyJRCKRSM0qhoJrZkrrSVOLYIZEIpFIpGZVnRcAt6pomolEIpFIJFJLq6Ew89hjj+H0009HV1cXgiDAT37yE6WeMYalS5eiq6sLI0aMwKxZs7Bx40bFpq+vD/Pnz8d+++2HUaNG4YwzzsBrr71Wx70gkUgkEqlGKnIlE38NAjUUZt555x184AMfwC233GKsv/baa3H99dfjlltuwdNPP43Ozk7MmTMHO3bsEDYLFizAgw8+iJUrV2Lt2rXYuXMnTjvtNPT399drN0gkEolEqon41UxFXoNBDV0zM3fuXMydO9dYxxjDjTfeiCuvvBJnnnkmAOCuu+7ChAkTcN9992HevHnYvn077rjjDtxzzz046aSTAAD33nsvuru78fDDD+OUU06p276QSCQSiURqjJp2zcymTZvQ09ODk08+WZS1t7fjhBNOwOOPPw4AWLduHfbs2aPYdHV1YfLkycLGpL6+PvT29iovEolEIpGaTnwBcJHXIFDTwgy/hfKECROU8gkTJoi6np4eDBs2DPvuu6/VxqTly5crj0Lv7u4uufckEolEIpUgghkvNS3McAVBoGwzxhJlutJslixZgu3bt4vXq6++WkpfSSQSiUQi1V9NCzOdnZ0AkMiwbN26VWRrOjs7sXv3bmzbts1qY1J7e7t4HHrWx6KTSCQSiVQ3UWbGS00LMxMnTkRnZydWr14tynbv3o01a9Zg5syZAICpU6di6NChis2WLVuwYcMGYUMikUgkUsuKLs32UkOvZtq5cyf++Mc/iu1Nmzbh2WefxdixY/He974XCxYswLJlyzBp0iRMmjQJy5Ytw8iRI3H22WcDCB9JfsEFF2DRokUYN24cxo4di8WLF2PKlCni6iYSiUQikVpV9X7QZKuqoTDz61//GieeeKLYXrhwIQDgnHPOwZ133okrrrgCu3btwkUXXYRt27Zh+vTpWLVqFUaPHi18brjhBgwZMgRnnXUWdu3ahdmzZ+POO+9EW1tb3feHRCKRSCRS/RWwVn3ed4nq7e1FR0cHZuHjGBIMbXR3SCQSidTE2sv24FH8C7Zv316zNZf8vHTSpMswpK09d5y9/X14+MUbatrXZhA9aJJEIpFIpGZVlQFBgZxDdXDkK5p2ATCJRCKRSCSSjygzQyKRSCRSs6ro5dWDZCUJwQyJRCKRSE2roveKGRwwQ9NMJBKJRCKRWlqUmSGRSCQSqVlF00xeIpghkUgkEqlZVWUoNFVEVzORSCQSiUQiNb8oM0MikUgkUrOKVcNXEf9BIIIZEolEIpGaVbRmxksEMyQSiUQiNatozYyXaM0MiUQikUiklhZlZkgkEolEalbRNJOXCGZIJBKJRGpWMRSEmdJ60tSiaSYSiUQikUgtLcrMkEgkEonUrKJpJi8RzJBIJBKJ1KyqVgEUuFdMdXDcZ4ammUgkEolEIrW0KDNDIpFIJFKziqaZvEQwQyKRSCRSs4pgxks0zUQikUgkEqmlRZkZEolEIpGaVfQ4Ay8RzJBIJBKJ1KRirApW4MnXRXxbSQQzJBKJRCI1qxgrll2hNTMkEolEIpFIzS/KzJBIJBKJ1KxiBdfMDJLMDMEMiUQikUjNqmoVCAqsexkka2ZomolEIpFIJFJLizIzJBKJRCI1q2iayUsEMyQSiUQiNalYtQpWYJppsFyaTdNMJBKJRCKRWlqUmSGRSCQSqVlF00xeIpghkUgkEqlZVWVAQDCTJppmIpFIJBKJ1NKizAyJRCKRSM0qxgAUuc/M4MjMEMyQSCQSidSkYlUGVmCaiRHMkEgkEolEaqhYFcUyM3Rpdkvp+9//PiZOnIjhw4dj6tSp+H//7/81ukskEolEIrWkWu2cOiBg5sc//jEWLFiAK6+8EuvXr8df/dVfYe7cudi8eXOju0YikUgkUm6xKiv8yqpWPKcGbABMqE2fPh0f+tCHcOutt4qy97///fjEJz6B5cuXJ+z7+vrQ19cntnt7e9Hd3Y1Z+DiGBEPr0mcSiUQitab2sj14FP+C7du3Y8yYMTVpo7e3Fx0dHYXPS3n6mvWc2gxq+TUzu3fvxrp16/CVr3xFKT/55JPx+OOPG32WL1+Ob3zjG4nyvdhT6N5EJBKJRBr42os9AOqzuLboeYn3tbe3Vylvb29He3t7wj7PObUZ1PIw8z//8z/o7+/HhAkTlPIJEyagp6fH6LNkyRIsXLhQbG/atAkf/OAHsRY/q2lfSSQSiTRwtGPHDnR0dNQk9rBhw9DZ2Ym1PcXPS/vssw+6u7uVsquuugpLly5N2OY5pzaDWh5muIIgULYZY4kyLp1IDzroIADA5s2ba/bFbIT49Nmrr75as1RovTUQ9wmg/WolDcR9Ami/sogxhh07dqCrq6uUeCYNHz4cmzZtwu7duwvHMp0PTVkZWVnOqc2gloeZ/fbbD21tbQli3Lp1a4IsbapUwnXQHR0dA+og5hozZsyA26+BuE8A7VcraSDuE0D75at6/PAdPnw4hg8fXvN2ZJVxTm2EWv5qpmHDhmHq1KlYvXq1Ur569WrMnDmzQb0ikUgkEqn11Krn1JbPzADAwoUL8YUvfAHTpk3DjBkzcNttt2Hz5s248MILG901EolEIpFaSq14Th0QMPPpT38ab775Jr75zW9iy5YtmDx5Mn72s5+JtTBpam9vx1VXXZU6h9hqGoj7NRD3CaD9aiUNxH0CaL9IsYqeUxuhAXGfGRKJRCKRSINXLb9mhkQikUgk0uAWwQyJRCKRSKSWFsEMiUQikUiklhbBDIlEIpFIpJYWwQxa61Hnjz32GE4//XR0dXUhCAL85Cc/UeoZY1i6dCm6urowYsQIzJo1Cxs3blRs+vr6MH/+fOy3334YNWoUzjjjDLz22mt13AtVy5cvx7HHHovRo0dj/Pjx+MQnPoHnn39esWnF/br11ltx9NFHi5t1zZgxAz//+c9FfSvuk67ly5cjCAIsWLBAlLXifi1duhRBECivzs5OUd+K+8T1+uuv4/Of/zzGjRuHkSNH4oMf/CDWrVsn6ltt3w4++ODE3yoIAlx88cUAWm9/SCWJDXKtXLmSDR06lN1+++3sd7/7Hbv00kvZqFGj2CuvvNLorhn1s5/9jF155ZXs/vvvZwDYgw8+qNRfc801bPTo0ez+++9nzz33HPv0pz/NDjjgANbb2ytsLrzwQvYXf/EXbPXq1eyZZ55hJ554IvvABz7A9u7dW+e9CXXKKaewFStWsA0bNrBnn32WnXrqqey9730v27lzp7Bpxf166KGH2L/927+x559/nj3//PPsq1/9Khs6dCjbsGFDy+6TrKeeeoodfPDB7Oijj2aXXnqpKG/F/brqqqvYUUcdxbZs2SJeW7duFfWtuE+MMfbWW2+xgw46iJ177rnsP//zP9mmTZvYww8/zP74xz8Km1bbt61btyp/p9WrVzMA7JFHHmnJ/SGVo0EPM3/5l3/JLrzwQqXsiCOOYF/5ylca1CN/6TBTrVZZZ2cnu+aaa0TZu+++yzo6OtgPfvADxhhjb7/9Nhs6dChbuXKlsHn99ddZpVJhv/jFL+rWd5e2bt3KALA1a9YwxgbOfjHG2L777sv+7//9vy2/Tzt27GCTJk1iq1evZieccIKAmVbdr6uuuop94AMfMNa16j4xxtiXv/xl9uEPf9ha38r7xnXppZeyQw89lFWr1QGxP6R8GtTTTPxR5yeffLJS3uyPOrdp06ZN6OnpUfanvb0dJ5xwgtifdevWYc+ePYpNV1cXJk+e3DT7vH37dgDA2LFjAQyM/erv78fKlSvxzjvvYMaMGS2/TxdffDFOPfVUnHTSSUp5K+/Xiy++iK6uLkycOBGf+cxn8PLLLwNo7X166KGHMG3aNHzqU5/C+PHjccwxx+D2228X9a28b0A4ht977704//zzEQRBy+8PKb8GNcy06qPObeJ9du1PT08Phg0bhn333ddq00gxxrBw4UJ8+MMfxuTJkwG09n4999xz2GeffdDe3o4LL7wQDz74II488siW3qeVK1fimWeewfLlyxN1rbpf06dPx913341f/vKXuP3229HT04OZM2fizTffbNl9AoCXX34Zt956KyZNmoRf/vKXuPDCC3HJJZfg7rvvBtC6fy+un/zkJ3j77bdx7rnnAmj9/SHl14B4nEFRtdqjztOUZ3+aZZ+/9KUv4be//S3Wrl2bqGvF/Tr88MPx7LPP4u2338b999+Pc845B2vWrBH1rbZPr776Ki699FKsWrXK+TTfVtuvuXPnivdTpkzBjBkzcOihh+Kuu+7CcccdB6D19gkAqtUqpk2bhmXLlgEAjjnmGGzcuBG33norvvjFLwq7Vtw3ALjjjjswd+5cdHV1KeWtuj+k/BrUmZlWfdS5TfzqC9f+dHZ2Yvfu3di2bZvVplGaP38+HnroITzyyCM48MADRXkr79ewYcNw2GGHYdq0aVi+fDk+8IEP4KabbmrZfVq3bh22bt2KqVOnYsiQIRgyZAjWrFmDm2++GUOGDBH9arX90jVq1ChMmTIFL774Ysv+rQDggAMOwJFHHqmUvf/978fmzZsBtPax9corr+Dhhx/G3/7t34qyVt4fUjENaphp1Ued2zRx4kR0dnYq+7N7926sWbNG7M/UqVMxdOhQxWbLli3YsGFDw/aZMYYvfelLeOCBB/Af//EfmDhxolLfqvtlEmMMfX19LbtPs2fPxnPPPYdnn31WvKZNm4bPfe5zePbZZ3HIIYe05H7p6uvrw+9//3sccMABLfu3AoDjjz8+cZuDF154QTwwsJX3bcWKFRg/fjxOPfVUUdbK+0MqqHqvOG428Uuz77jjDva73/2OLViwgI0aNYr913/9V6O7ZtSOHTvY+vXr2fr16xkAdv3117P169eLS8mvueYa1tHRwR544AH23HPPsc9+9rPGyxIPPPBA9vDDD7NnnnmGffSjH23oZYl///d/zzo6Otijjz6qXHL55z//Wdi04n4tWbKEPfbYY2zTpk3st7/9LfvqV7/KKpUKW7VqVcvuk0ny1UyMteZ+LVq0iD366KPs5ZdfZk8++SQ77bTT2OjRo8U40Ir7xFh4+fyQIUPYt771Lfbiiy+yf/zHf2QjR45k9957r7BpxX3r7+9n733ve9mXv/zlRF0r7g+puAY9zDDG2Pe+9z120EEHsWHDhrEPfehD4pLgZtQjjzzCACRe55xzDmMsvNTyqquuYp2dnay9vZ195CMfYc8995wSY9euXexLX/oSGzt2LBsxYgQ77bTT2ObNmxuwN6FM+wOArVixQti04n6df/754nu1//77s9mzZwuQYaw198kkHWZacb/4vUiGDh3Kurq62Jlnnsk2btwo6ltxn7h++tOfssmTJ7P29nZ2xBFHsNtuu02pb8V9++Uvf8kAsOeffz5R14r7QyqugDHGGpISIpFIJBKJRCpBg3rNDIlEIpFIpNYXwQyJRCKRSKSWFsEMiUQikUiklhbBDIlEIpFIpJYWwQyJRCKRSKSWFsEMiUQikUiklhbBDIlEIpFIpJYWwQyJRCKRSKSWFsEMiUQikUiklhbBDIlEIpFIpJYWwQyJRCKRSKSWFsEMiTTI9c477+CLX/wi9tlnHxxwwAG47rrrMGvWLCxYsAB/+MMfMHLkSNx3333C/oEHHsDw4cPx3HPPNbDXJBKJFItghkQa5Lr88svxyCOP4MEHH8SqVavw6KOPYt26dQCAI444At/97ndx0UUX4ZVXXsEbb7yBv/u7v8M111yDKVOmNLjnJBKJFIqemk0iDWLt3LkT48aNw913341Pf/rTAIC33noLBx54IP6//+//w4033ggAOO2009Db24thw4ahUqngl7/8JYIgaGDPSSQSKdaQRneARCI1Ti+99BJ2796NGTNmiLKxY8fi8MMPV+x++MMf4n3vex8qlQo2bNhAIEMikZpKNM1EIg1i+SZmf/Ob3+Cdd97BO++8g56enhr3ikQikbKJYIZEGsQ67LDDMHToUDz55JOibNu2bXjhhRfE9ltvvYVzzz0XV155Jc477zx87nOfw65duxrRXRKJRDKKYIZEGsTaZ599cMEFF+Dyyy/Hv//7v2PDhg0499xzUanEQ8OFF16I7u5ufO1rX8P1118PxhgWL17cwF6TSCSSKlozQyINcn3nO9/Bzp07ccYZZ2D06NFYtGgRtm/fDgC4++678bOf/Qzr16/HkCFDMGTIEPzjP/4jZs6ciVNPPRUf+9jHGtx7EolEoquZSCSSQbNmzcIHP/hBcTUTiUQiNbNomolEIpFIJFJLi2CGRCKRSCRSS4ummUgkEolEIrW0KDNDIpFIJBKppUUwQyKRSCQSqaVFMEMikUgkEqmlRTBDIpFIJBKppUUwQyKRSCQSqaVFMEMikUgkEqmlRTBDIpFIJBKppUUwQyKRSCQSqaX1/wMvUxkX89vWsgAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "hgrid[\"t_angle_dx_mom6\"].plot(vmin = 0)" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 44, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "hgrid[\"angle_dx\"][kp2::k,kp2::k].plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "angle_diff = hgrid[\"angle_dx\"][kp2::k,kp2::k].values - hgrid[\"t_angle_dx_mom6\"].values\n", + "plt.figure(figsize=(8, 6))\n", + "plt.imshow(angle_diff,cmap='coolwarm')\n", + "plt.colorbar()\n", + "plt.title(\"Difference between caluculated MOM6 angle and angle_dx from Hgrid angle_dx\")\n", + "plt.show() " + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 56, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Define a new angle field\n", + "hgrid[\"angle_dx_rm6\"] = xr.full_like(hgrid.angle_dx, np.nan)\n", + "hgrid[\"angle_dx_rm6\"].attrs[\"units\"] = \"degrees\"\n", + "hgrid[\"angle_dx_rm6\"][t_points] = hgrid[\"t_angle_dx_mom6\"].values\n", + "hgrid[\"angle_dx_rm6\"].plot()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Apply XGCM Interpolation" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "metadata": {}, + "outputs": [], + "source": [ + "import xgcm" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 104, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Size: 18MB\n", + "Dimensions: (nyp: 780, nxp: 740, nyp_q: 781, nxp_q: 741)\n", + "Coordinates:\n", + " xh (nyp, nxp) float64 5MB -97.96 -97.88 -97.79 ... -37.58 -37.49\n", + " yh (nyp, nxp) float64 5MB 5.243 5.243 5.243 ... 58.34 58.34 58.35\n", + " xq (nyp_q, nxp_q) float64 5MB -98.0 -97.92 -97.83 ... -37.54 -37.45\n", + " yq (nyp_q, nxp_q) float64 5MB 5.201 5.201 5.201 ... 58.37 58.37 58.38\n", + "Dimensions without coordinates: nyp, nxp, nyp_q, nxp_q\n", + "Data variables:\n", + " *empty*\n" + ] + }, + { + "ename": "ValueError", + "evalue": "Input `xh` (for the `center` position on axis `X`) is not a dimension in the input datasets `ds`.", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[104], line 17\u001b[0m\n\u001b[1;32m 14\u001b[0m \u001b[38;5;28mprint\u001b[39m(xgcm_input)\n\u001b[1;32m 15\u001b[0m coords_mom6\u001b[38;5;241m=\u001b[39m{\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mX\u001b[39m\u001b[38;5;124m'\u001b[39m:{\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mcenter\u001b[39m\u001b[38;5;124m'\u001b[39m:\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mxh\u001b[39m\u001b[38;5;124m'\u001b[39m, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mouter\u001b[39m\u001b[38;5;124m'\u001b[39m:\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mxq\u001b[39m\u001b[38;5;124m'\u001b[39m}, \n\u001b[1;32m 16\u001b[0m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mY\u001b[39m\u001b[38;5;124m'\u001b[39m:{\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mcenter\u001b[39m\u001b[38;5;124m'\u001b[39m:\u001b[38;5;124m'\u001b[39m\u001b[38;5;124myh\u001b[39m\u001b[38;5;124m'\u001b[39m,\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mouter\u001b[39m\u001b[38;5;124m'\u001b[39m:\u001b[38;5;124m'\u001b[39m\u001b[38;5;124myq\u001b[39m\u001b[38;5;124m'\u001b[39m }}\n\u001b[0;32m---> 17\u001b[0m xgcm_hgrid \u001b[38;5;241m=\u001b[39m \u001b[43mxgcm\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mGrid\u001b[49m\u001b[43m(\u001b[49m\u001b[43mxgcm_input\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\n\u001b[1;32m 18\u001b[0m \u001b[43m \u001b[49m\u001b[43mcoords\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcoords_mom6\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\n\u001b[1;32m 19\u001b[0m \u001b[43m \u001b[49m\u001b[43mperiodic\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m/glade/work/manishrv/conda-envs/CrocoDashDev/lib/python3.12/site-packages/xgcm/grid.py:1340\u001b[0m, in \u001b[0;36mGrid.__init__\u001b[0;34m(self, ds, check_dims, periodic, default_shifts, face_connections, coords, metrics, boundary, fill_value)\u001b[0m\n\u001b[1;32m 1336\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\n\u001b[1;32m 1337\u001b[0m \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mCould not find dimension `\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mdim\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m` (for the `\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mpos\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m` position on axis `\u001b[39m\u001b[38;5;132;01m{\u001b[39;00maxis\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m`) in input dataset.\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 1338\u001b[0m )\n\u001b[1;32m 1339\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m dim \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;129;01min\u001b[39;00m ds\u001b[38;5;241m.\u001b[39mdims:\n\u001b[0;32m-> 1340\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\n\u001b[1;32m 1341\u001b[0m \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mInput `\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mdim\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m` (for the `\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mpos\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m` position on axis `\u001b[39m\u001b[38;5;132;01m{\u001b[39;00maxis\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m`) is not a dimension in the input datasets `ds`.\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 1342\u001b[0m )\n\u001b[1;32m 1344\u001b[0m \u001b[38;5;66;03m# Convert all inputs to axes-kwarg mappings\u001b[39;00m\n\u001b[1;32m 1345\u001b[0m \u001b[38;5;66;03m# TODO We need a way here to check valid input. Maybe also in _as_axis_kwargs?\u001b[39;00m\n\u001b[1;32m 1346\u001b[0m \u001b[38;5;66;03m# Parse axis properties\u001b[39;00m\n\u001b[1;32m 1347\u001b[0m boundary \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_as_axis_kwarg_mapping(boundary, axes\u001b[38;5;241m=\u001b[39mall_axes)\n", + "\u001b[0;31mValueError\u001b[0m: Input `xh` (for the `center` position on axis `X`) is not a dimension in the input datasets `ds`." + ] + } + ], + "source": [ + "# Define tpointx (xh) tpoint y (yh) qpoint x (xq) and qpoint y (yq) Hgrid to add XGCM required variables\n", + "xh_points = np.arange(kp2, len(hgrid.x.nxp),k)\n", + "yh_points = np.arange(kp2, len(hgrid.x.nyp),k)\n", + "xq_points = np.arange(0, len(hgrid.x.nxp),k)\n", + "yq_points = np.arange(0, len(hgrid.x.nyp),k)\n", + "xgcm_input = xr.Dataset(\n", + " coords = {\n", + " \"xh\": ((\"nyp\",\"nxp\"),tlon.values),\n", + " \"yh\": ((\"nyp\",\"nxp\"),tlat.values),\n", + " \"xq\": ((\"nyp_q\",\"nxp_q\"),qlon.values),\n", + " \"yq\": ((\"nyp_q\",\"nxp_q\"),qlat.values),\n", + " }\n", + ")\n", + "print(xgcm_input)\n", + "coords_mom6={'X':{'center':'xh', 'outer':'xq'}, \n", + " 'Y':{'center':'yh','outer':'yq' }}\n", + "xgcm_hgrid = xgcm.Grid(xgcm_input, \n", + " coords=coords_mom6, \n", + " periodic = False)" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "\n", + "X Axis (not periodic, boundary=None):\n", + " * center lonh --> outer\n", + " * outer lonq --> center\n", + "Y Axis (not periodic, boundary=None):\n", + " * center lath --> outer\n", + " * outer latq --> center" + ] + }, + "execution_count": 49, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# From Tutorial\n", + "grid = xgcm.Grid(ocean_geo, coords={'X': {'center': 'lonh', 'outer': 'lonq'},\n", + " 'Y': {'center': 'lath', 'outer': 'latq'}}, periodic = False)\n", + "grid" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.DataArray 'y' (lath: 780, lonh: 740)> Size: 5MB\n",
+       "array([[0.        , 0.        , 0.        , ..., 0.        , 0.        ,\n",
+       "        0.        ],\n",
+       "       [0.        , 0.        , 0.        , ..., 0.        , 0.        ,\n",
+       "        0.        ],\n",
+       "       [0.        , 0.        , 0.        , ..., 0.        , 0.        ,\n",
+       "        0.        ],\n",
+       "       ...,\n",
+       "       [4.43651643, 4.47489525, 4.5132071 , ..., 4.40963338, 4.37648025,\n",
+       "        4.34327766],\n",
+       "       [4.45746382, 4.49601954, 4.53450787, ..., 4.429975  , 4.39669398,\n",
+       "        4.36336333],\n",
+       "       [4.47848207, 4.51721524, 4.5558806 , ..., 4.45038282, 4.41697365,\n",
+       "        4.38351466]])\n",
+       "Coordinates:\n",
+       "  * lath     (lath) float64 6kB 5.243 5.326 5.409 5.492 ... 53.82 53.86 53.89\n",
+       "  * lonh     (lonh) float64 6kB -97.96 -97.88 -97.79 ... -36.54 -36.46 -36.38
" + ], "text/plain": [ - "" + " Size: 5MB\n", + "array([[0. , 0. , 0. , ..., 0. , 0. ,\n", + " 0. ],\n", + " [0. , 0. , 0. , ..., 0. , 0. ,\n", + " 0. ],\n", + " [0. , 0. , 0. , ..., 0. , 0. ,\n", + " 0. ],\n", + " ...,\n", + " [4.43651643, 4.47489525, 4.5132071 , ..., 4.40963338, 4.37648025,\n", + " 4.34327766],\n", + " [4.45746382, 4.49601954, 4.53450787, ..., 4.429975 , 4.39669398,\n", + " 4.36336333],\n", + " [4.47848207, 4.51721524, 4.5558806 , ..., 4.45038282, 4.41697365,\n", + " 4.38351466]])\n", + "Coordinates:\n", + " * lath (lath) float64 6kB 5.243 5.326 5.409 5.492 ... 53.82 53.86 53.89\n", + " * lonh (lonh) float64 6kB -97.96 -97.88 -97.79 ... -36.54 -36.46 -36.38" ] }, - "execution_count": 5, + "execution_count": 50, "metadata": {}, "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjwAAAGwCAYAAACtlb+kAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAAC86UlEQVR4nO39e5wVxbnvj396BhgugVFAGEfR4DnsaAQvwYi3E0lUjIpsT/YJMRg0xhiNihLwGjUx/iJEz0sl0R2MxqMeidHf3mpibkRMFOWgYlCiaLbG7UQxkZDs4OAFGZhV3z+6q7qquqq6+rKu83xerwWrq556qnrN6ur3eurp7oAxxkAikUgkEonUwmqr9wBIJBKJRCKRqi0CHhKJRCKRSC0vAh4SiUQikUgtLwIeEolEIpFILS8CHhKJRCKRSC0vAh4SiUQikUgtLwIeEolEIpFILa9B9R5As6hSqeAvf/kLRo4ciSAI6j0cEolEIjWwGGN455130N3djba26sQWPvjgA/T19ZXia8iQIRg6dGgpvhpVBDye+stf/oIJEybUexgkEolEaiJt2LABu+++e+l+P/jgA0zc80PYuKm/FH9dXV3o6elpaegh4PHUyJEjAQCTzvoG2oYOBdoAFiD8n78Pkv+jLdpuAxCw6H/E/wfRja4DgLUxYR/bMiAAgjYWlYdlQfRCAAQBELRVEASxfZuwCevb2ypiuy1gaA8qoavIri1gaG+roA3xNn+1a9ttAUMb+PtK2BfCssFt4cHXBoZBbRW0I9y/9rb+0A8qYX3A0I6KNJbw/7aggnYg+p9FthW0cVtU0B5URB/tvC76O4U+K2iP+pH7jG2Z2A7bMKWM9xtEfxvhS4yHiW1eFpZDjAuI14vbpYBgO+KNuF6NGLYpNvY6U9vYLv0Xpe4rqyrwu0l7Jfr8ZPUbbvCu+5O39Tq5PffeL9n0M7UufB/ub4Vx+3j/+0VdILb7o8+QSWWh7zbFXz8CpYx/G+OyNvQLH22osDbhuxLVc/uK5Cu0jf2F7QJURH1UxtrA5DGwQGnL+66wAEz4CNuG/QXivRgHaxOfRQVB6Et6scifUsYCYdtficZSCY+GCqJ6FoCx8DNVtyF8gAGQ7SrhOMT/3AZB+AFGtrxdwABUuJ/wFfDtsJWoD0R92FaUVaS28v/gtrGd8j+L6yt9H+DlH14tzh1lq6+vDxs39eP1tR/GqJHFIkhb3qlgz6l/Ql9fHwEPCWIZq33IULQPGarADgcYUSZDj7zdFkGNtC3gRpQxCZSYUqZAD5jYDgKGILIPAoY2uRxAW1sl3g54u/AVgEMRQ9BWiWEKkk1beLoJgkrsQ7ILJPBhEQgFQegr3FZnAwFREcQImAn46Ym3D+GjTfofQHhKccAPIAMVh5UK2gMOIhUJdswAlLTTYccOQfL/YR2SZdJ3q13U63ATfhahDa+TfQTKtuojCRlxG65ynyqTBkD9hnoXyIT1XBwYwvrBCATUcLvBEoAMRgw2vEz+v8ICDJK2w/fxSV6uC0GkDe1RWXtU1g4OPW1aWQgZbZHPNgBtEeS0AVFdEnL4GIJoDIGAo2g7mjCCCHLawy0gghMWjT/0HE08LKzvjyakIBoLIgAJWBvapAmrwsL+AwTxOFgQv6JyJnzH5Uyya49gpo1F4CdgIogARd0GEI6DAZVK7ItPQywCGVYJoulPBaNAhhpRB6ASiKkn3Bekwk5ggx2pLrGtQxBi6K52CsSHRgb40MiiP14GRpoGAU9GiS86EP+qgFrGT0P6Nv+lwdqYaBN5jY5qRAc/C2fwtvA9b8MqQRjFaWNAEB3oYGAIwtk9CIA2oFJBFO0JbSuVNgQRVLVH9SyIDsS2CtoYC7/wwo6hEjAMin6b76i0oS1g2IG2MLLDDNEeFmBQW3/4oys6mfAjv8Lawz6CijgRVYIK2oIA7Qj7bgMLJ8hoxgnbtIV2CFABEyfrCtrQhkp4ooim9/Zom59IKqhEJyd5m0OK9Ctcgpr4130MGfGv6RiQQn+RLQcdxsuZUh7WMf5pCLVJ80slqt8OZgQhANjOWAKIoNmHPuxRH9F3FSa3VNixPLJPxzIdinSoUW3j/XBFbcJ6LUqDNqVcqZMiM7w8GdVJj+KodmrkR46myKCltg0U4OHRHDUSEyjt+TgqTG8bR3FERCcRweFRoWRExxjlkcoZ0//3ierE20AIM7xcjtpwOAojPHLkJrbxgp0oQiQDi9xGLZMiOqZyw0s+N8jtq61+VlGOk7w+BoIIeLKK/+IIpPeI/5fDptyGb4PbRgATVKIoD2KfYVkQG0ODnqg92kKkYiyM/LDwN1Y4KbTxgQQROPEBA/2VEHTa28KfJP2VNrAoUsNYBEQIXXDAYSwEoLYgXKYyBBaAANhRaRfLXDsQ/nKsBDzCA4C1YXtk3oYA7REEZQGf0A4RBLWJiA6HHxlIOBYB8IYfAAoAyfATlvkBEJhcZ4egsD6WDELbmRoV0oEoHBcSMsORrNBnGWmUPtOkKbIDwDhJ+0CNXmcCG71cBxwdbsK+24x1JsipSCDD69Igh/vikMPHE7/X4AYScGvLXfqylejPA3REuQfo8DFXWIAdlbhtVtipSG0rlUDxw6HGCDsVaZnLBDsy1KRFdnQw0Zex9P8BqT8R8DZGfxQIgtS2BqqAeS8vu3wMBBHwZJX8hYcUwWEq1HBbhQ2k7QQoVYIQXGToqUQNBACF/yvQEwRglXToYUG8UsZBh+f5oC0srwQIgzJBEEJQwIAIcNoYlGhPHNkxR3tEfk+0zcGnPYIaHv3pZ+1O8AHC5aIKAgE+AAceJkFQHPVpC1gU8q+Ik5Uv/IRlftGfsNwMQKEfOwRtRwwzMghBgxwdAGQgApJQJMoNcGSTCZrSlOUXpQmKZBgRdhagMW2ngY3NxhS9ETYeUZxwW4UU1dYOOdzOFc2R3+vt1XbZQccnohO3rW5UhwF22Im+MLlgJ2qbhB1TFEeDHXlZClDrlHaG8ki1ju6QsomAJ6PkLzSL3kP7PwE1pm0WiKiKgCJeFnDbqCZa3gqiZSsl0hMwoC2aJKKIbxAtfyECl7a2eOmrgnDdvK2NLwGpS1wsyn3hdTwCVIlgRo72FAYfFkd/bOADQIn6cBjq15a7Qjtz1AeAN/yEZX7Rn7BcBaDtrD0GGQcEAWYQCm3i2XI74vyg2FadTV1RFh2QTNoeuTOBky4TqLikQ4zLj14mA4tenwY2QLbojezTBDhyvQw5IiE4J+Rwf6ZojnivAFYyETluH/vzjejEPvyWr7h9mbDDIz6sEpfJ/8uwwxOXrZEdZorshD/6bNEZW2THaWPwZfRdA1Vguiwgu4+BIAKerOKAwvRlKoC1Sf9LNgJyKkDQJtuHEMOCqJyDDY/iMAjA4dADRMtbAcJlMfBIUMCHF9oGoYOgLRA5Pba8niAIlGhPiA4RjEnRnmqAD1hblMDM4mUrCXwAKFGfECgqAn7A2hEnLAdh5CQCqQrCD7stqGA72tHO4mTn7aw9gpcwv6g9smlDBWDtaA9Y5IsnQVekdmFdmzRJxEnMlaiOAQj72M7axX7ES3oVMSmHfbclbSQgkvvg9bo9lw5Iumxgsz0jzMjyASEdYGztZJjR2yWiPg6oSdar4CLX+8CNXJ8GOHzcST/JvBzuJw1yeP+uaE5sY4Ka7BEdALWJ6nCgYfFVWTrIJK7EYoB6NZYhZ8cAJUHUTgGTigV29CRlzY+yjST81EL9jFlz5LL4GAgi4MkoPYRpjOgwNfoTAHHURrLnv16USE8FQBAvb4lfMDzSE4TrS6FtBCNtgTSoIAKsZDKzQC/DEpct2qODT3tb9FsgiJe5KiwIc3ui8vDqjDjnh8OKCXzaotkmjLQEIrmZgw8AJeoTxmbalahPPyCWvNqDcHx65Edf9gLiE5Me/QHkaA+HLjkqpC6BhfbmSBAHtLAu/uLIicUV6aTM2/NxyTJdSaEsh/F2KQmI8nJaGfKBHR1iuHwgyAQ1JltX1Eatl8vyA468rUdxVF/J5SreVocc3ZctmiNv20BHifgkyswRHbkuDXT459BfaRPbWWGHR3UApC9hZYEdSwTGCDtyNIYloSUBMSYbGOpJDScCnqySIYbpy1Tm6I9oF6gRIIik5SjSwyNDAJTlLTmRGQgPdA49CMAqbugReT2OJS452tPeVgknGCm3x3YlVxvCl5LbE8RUx8v5hxbCUAbwCVhyuStgqDAIkGpHlNwcSMtghnyf+H1b9L4SwU67Aj/hnyYJQDL88DIuWx6QUhfE9mrUwgxC8vIYgERUSR6vrO1oSwWaxFJZAZmgRZcNimSYEf48oCa2zQ43sm0a4HBfFW0MySRoc+IxH78MOXzcegIyf2+K5sR+pGUqy7KVeO8BOokyC+gAqGpUR/7fCTv8626BHfGV1i49j98nYUccKgZ7r2UwOOprIEpa9hcBTw4JyAlMEZv4/yC63IkhBp0E9AgoipxBivS0ZYMeHhmKeg/dRWEcsUwGbYmrje8Qn9DjhOa0aE/eZS5XxCfctWSeT9hGXu5i6Ee7NddHRH0Q5/uENnb4AW8TxEnP/QhBpcLardEfIAlBaqTGDkGAHYRCO3Ui0i8516FIlCMJRwkxte88MgGLSTrEiPamqJUn1Oi2rsgNoEfS3BEcuV/TUpW6bYYcUWeBHO5Dhxxeb4rmxH7M+Tm8zyKgw+vSlq8AVB92oiupzPk6Wh3UelNkJ7Rxg4wzyqO399musipgiXkij4+BIAKejJKpXv6KyPAilrSg2opyqXEQ5duE+T8BEEiRHm15K4i2xX18KkEIUAETMCTu1ROwiGh4dAfxIrO8xBXVMW6iRXt4bk+Z4APAmuMDQMnzCW3DmwbyqA9YW5SLE20j3t6BdrRFuTpyvg/P2WmLLo1Xcn7AANYu5fqw+D3CHBz5hoNK/k/0h9zOYMwDAvgSUkUkB7dFbUVODs/xCbQcH0nyEhkfB5ecw9OmfCvbjT5kcX9lKg2CjEtzBiByLmUZojWAGWp0e9vylFzmgptw2y+Kw7eTfpKRHO4vC+TIdjaYke3Tlq4ApIJO3uWr3FEdC+wod0/W6pUcHMC8jMXrDLBjuvkgb5MWBap1hIfkLwKerJLIPYj+EfleHG4MkJMoj90kIj2J5a2KmtOj3LxQaqNcwaX0xN+Zl7j0hGY52sNze/RteZmrDYjyZqKcniiyYgWfaE95NEYGHwBq1AcMQBsqDJAvaxc3L0SUn8O3pciPnO8j9wc+Rn7ykKI/8n1+QrtkBAhQ83+4bHlAoX0yGrRda2+KCsW+9WUec2TGFbGR84mqKVu+jqj3WMYK7fRoVzrY6O18IjeyjyyAo2zngBxRpi1Zcb96bk7swxzNif1lAx1e5srT8Vm+AlB92OGpgh6wI7ezLmMhCSzGyI4JbrgDi20tIzy0pOUnAp6M4l968fVg0tIWL5eASIEc+QouSEADdfkrsbwFeEEPoN2gUMMq2xIX4zuCIMwrKhjtCZetQnfhreUDK/go0BO9wCBycmTwqbD2eLkrCLdF1AfxzQzDj0u9ykuGHznnB5BARVv6CuuYtm0GICAJQXKd/GyrNBDSbUI7HVTM8GJbOrL7KV+pY9BABjBDUoXpkJcONmF5NrhRy1SgMZWl5ePofaRBjl7Gozm8rziBWcvhScCPGXTkujTQicvMoAPACDs+oMPbMmlpyQg7Ub1YhtIARoYJF+wEWh6PFUi0Mh97/iPV2AaS3xqIrtLyFwFPVkl0zyBFcDj0RDYyEAESuMjbgWP5SwKauG2c0yOgh0dlJEtx2XqgJTNHgzQucekJzSzwjvb086iRBj5imStg4oouQIvsCMDxAJ8gAiSmLXfpUZ8gTnRuCyqR7xh+5JwfeTw87weAMfoDOAAoiG/vbrr82RwJYmrUwgJCYXtTVCQJL2lA474DczlKi/DoIGNro4NRclkrCTZ6uel+PaZIkQ4zpjLbFVq+kMN92SCH26dFc7i9CWbkuiwRnbhMBR0AqXk6oU0VozrVgB0YykzgYqrTym12pMYTAU8OCUjh4AEoj5EwARE3T8CQBD3K8heQmtMj+uE3IAwQ36sn+ldJZmZRPZOWtsT/YbRHSWj2jvaoV3P1s8CZ3xMErsiOBkOIc3ri/B9z1AeASHQG4iUvAFb4MS17hX1E2xkBKCxTo0CyH8C8HKbb6E87N8NNEl5MYJTmp2ylL2klx21e0tI/g8Bab78RoW0ZTIMZU0QnA+DI+5AGObzMBTkJ2xSYcdUxrd4FOgCcy1e83iuqA9Qcdkx5OSbYgV6m2bl8mHxaIaoGqgCFj+qBcdtBAp7M0ilfwAxfkmIauEQAweda65VbLLbly06hb0tOTxSdiQEpquX36gkQ3kiQ5/XwNvJNCnljS7RHzu3xA5+wXThqe8QHLAQKU44PwAHHnOAMwAw/fPLW4AcsunpLTnaWgIgnPIOFScM7RNIxRESJS77snd/wkCdA86RnAIlE6LBMupqKxTdDDMcZJyTrl4onE5srSi3/vLi2q80TOT28T5tSr+xC+pKVLlcSszGBOWUpS/6b6PUmqLGVK2UWuJH7Kwo43H+/XqZBjr3cDjlyuZJ8DG2bJaM3vhEd7sMKOgDyRnUAqEtYiOp4snG0Ld47LjtPjewYEpITdhVLHUx9Ot7XQP0ofpVW0fbNIgKerJKARo7kiLoAxuRkJdKjQQ8iILItbxmhh5fDAD1SPaAucSmXrvMlLku0h/GBSPXhIMPJMG/ER87xCX3F4ANoV3BBjQaJesQRHtMVXkAMP/zePgASOT8AtLyfKOk5iO/1w/vsZ0gAEJCMAnFfch+hXfy3MUWEwnL3zQZN0RNXIrIJKGzSl9hcyuIXsEOPOXfHAEEJ6PEHm0S5I8fHnNeTDjhyf76Qw+t8lqz4/2kQZIrm8Hob6MT1Kuhwu0REB0jCjgF0AHjBTilLWD6wI4NUip0NdmCzRew7Lq8NRPQzoPjT0ssZS6OLgCertC8/P5YBDVigQY8JjrRtZXlLS3AW0BNAPJ6C9yIghUFEdPRRyP8mL11H9mhPBD588HJ+D2NQIj5BwOIbFzI14hME8X15+HIXkFzaCnN3pPeJuuhZWwyJfB/ADj/iHj9BnPcT2kfAIi1/AUkA4gnQvAyI79sT9pGEIMAPhMI69URvisDY4IPfT8hXWa/g8oUjwAwxLj/JhOXAWu+sS8nzMef1uAFH7iMtH0e2tUGOaJ8AJnNujlzH35cFOrYyATs66ABG2DGCjmZbU9hB/H8qFJngCAZfJj/CTjsZkBpCBDwZJb7YEYko4BMVI4ryIDaLD1zenClulLwgUafZCLipWKCHj4knMwfRALW8HkhRnHhg4aC9oz0scC5zIbJXojuIojIa+PCIjw4+CbCJ6k1Xd/E6wLDkZYAfXifDT1hnj/6EbcwAFLaJYU2UmSAIKojYQCj0r86aen1oYwYPn+UpLn7H6SzKAjxAEmJiP4Z9SgEe3cYngdkVvQnbZQMcuTwv5CTrkldaqf0lQUdPRFbqPEAnrPe7zJz7MkZ1IL3XYUcDHQA1hR0k/KUsR8l2SNoI2fqD+r6aohwefxHwZFX0pVaggxmiNxr06FCkPEiUbwfwy+nh0CNFXBAEUXsmjScalSmvJ0C8xCXgKJ7QfKI9PuATBCwR8Qk/n2SODwAlwTkci3m5C4hzfRLlUnv93j68Ha/bAShw5AtAO8BvIBg/OoNDkMgDiv7u8k0QZfF28Y0MAZ4bxCVyhLhENCl548HEHZe1mwq2BfZpLS23J49sgMPlAzpAtuRle8JyEmzCttnhRh6DC3D4trvOADQp9WnRnPh93Jct8Vi2TYvoQJTlBB0AuaM6UR+JpGTpEnaRmwODnQY2TtiRfJlgJ5DGYfbNkmBURVUQWB/dksXHQBABT0Yp67LSASHABVJkRoIeHYoCwJ3rE0jvAZH3A4bwKetR9AXQ/PIru7gv5RlbsbX8b9i/ZGeI9giHNvARAzbn96hlcY5POFHGdv3CzrzcJUd2Eu9t8KNFeIzRH8RXfPE6AFYAAuxRoLB9PIEYo0HRkhiXKSok6rTJSI8QCTsH0ISXzZcPNWlyQY9tuc0FNKFPrd6R1Gx7lpYJYsoCnLT6NMhJ1MlRGEc0J36fBJ3wfXbQkdulX30FuKI66rJPBtjRgAOAetk5kExERrKdN+wo47TYw2zDYadW0R1SNhHwZBX/YkM6xnVwkbcj6EkuT8VvEm0Z1EhPZB7wy8QrbugRUaDIlkd0xBIXf+I6i+vSoj1BYF7mYjEDiWgTz+8xQQ73KcOQeh8fQF/uEjcujPaQR30AKcGZw1FgzveRbWXAkeEHQCIyZAUgxPlC8X11JMhhcTt+wjFBUNhOXU5SHw+RPMHrQCTsHL/S2lKiLdWUa1xGcGNJ+7QrtdLAJnxvS2j2BxzFviDkcBtrnSGaA+gQk1y2ksv1iI4OP6IO8TaHGBl0eBsdcJxRHcTbiaiOqNPq4YYduc4KMLC1ywY74htisUmCEUvW10AVFr6K+hgIIuDJoUBEP6ITtwwzEnkkoAeSHTSY4WUV1WcCemQ7T+iJgUyy4DcfhGe0h0X24hUDUoQhEJOeE3xiAInBJ4QhDj6mPB/5vZzLI9/FGYAKPwJezPADIHG1lwwx8mXpaQDE++F1LggK/ViiQdEYRJ0ht0YHonAccY6QLn5TxXoqe9KyHWhEOwvYhNtuuJFt1JyfcgDH+X+GJatEmSFCw21N5baIjqiDA3SAGF5Y0k4Bnai8SK5ObFtn2GFiarRCjrFfGOproP4SlrSKtm8WEfBklPhCQ1rqgQQbEtgo5dp2ABWCEnVyjpALevTcHVcyMzTokbyFUaUYesC0aE804ERSMyc6JRfHDD6ADDnmpS4BNhLQcNtKNC4lyVlAlX3JywU/CgQJmwhWJLjxASA+aehRINkH9ysvL9lAKLRVJyIdiMJ+7AnH+tKZr1xXbGVNVgbcwGN9knoCYuxQE44rHYBMcKPUy2WuJa6SIQdAYslKlFmiOdyvC3Rsy1k20OFt8yxfiXHpMJMjqhOXoe6wI8bt9C9N0PzTqRHwkPxFwJNVTI7oRCfbqIofKAJa5HJtWwALv/9Om1YHqInJ2n16FDsgzt2xJDPLeT3GJa4A8QNIZXsBLxH4AMmkZrlevtGggCbEic2AAjlADD9x4jKMNzEEIrjj5QET7/UbGvZH9YmIjmQHFkV4TDaQIimsLYYhLcJjstEToXk9f3o675drh2anLFkxdflrR/S/moAs3cdHn2W1zXa93qIdJSQxm+6oLMsGQeZHT/jDTzIHKAk2sg/ZPg/cmMp8c3J0W6bZ54EcuVyP5oh+lTYy/KRFdAAddKzLV5G/2FaqR2zjFdWBWlcz2Ine8z5csFOP6A5AEZ4sIuDJqEA6MNTISSRpWykP4qgO5DrpQLLBDKDBkdWuwBIXQww+EbwwDhcBDMtcMfjo+T0iXBN9WAnw4TAUgQ+gRnIQfU6JqE+086ZcHx75UZa4osgPAFGmR3b06A9gAJ+AWSM8ehRI2Gt2fAxcMrDwB6GKOu2GZcmoDzMmIPOnxtsk5xPVUs7EZctEaxqn7icr2OhtjMtbjgiP/D4L4Mj/myCHlydsJJhwJSGnlWcFHdlWhh4FdPQ2kV0iqqPZW6M6UR9eUR1oNta25cCOPD69Lxvs1BJ6ZIgu4mMgiIAnq5j6Pl7eQTKfR/6flwcq9MQTjAY4WnsAcX6PXMYgblAIBndeD9OewxUNSER7hGQcCv/lS1fxMle8M3p+TxCYwUdMmMLWDT48EhQEarmc66OUcz8SCOnLXgASCc9xUrG2nROAbMtYwhYq4OggpDxBXYMheVxKmdRXsi60r8dVWlzOJS3Pq7UA0zKXGWz09rbk5byAY7LPAzl8OxnZifuwRXP4/76gk7jqCsgGOnzbFdWR2zGtXvhLRnXiMrhhR4cOaHVVgB1b/1z1hB1SNhHw5JAONeKNBDKinkOQBDT65ery/6nQI5WBQboSK37P5GWsiDnEEldFrYMYl4JGgqzkaA9gWeYKACW/R2org49pqUthoAhY9OhOvNzFoQYK1IBJEKnDD6Ase3H4kROegRhIbFDDb3bI6+T/lTLpM5SjO6ptRSm3gRAfsywdiAAzFAl7uKM+Nrnu2QO4ozbWNo6wuW35KxHVcUCNsT4H3MjvfQDHVOYDOXzbBDm2OtOylV6ug05cbwCdqIH1yivuUIKZRJ4OpHoZdCDZyFAD1TYBGVK9FV6QfF8T2JH6lPN2Avl/YV8b6qElLX8R8GRUIB0kMXjwmULN52GIozIJGIqgh8MK9GdqmXJ6NN/gMKX3KWxTlrgiaOHsksjtkVrJ9coylww+0keRiPjwnY4iPvLl7ByCeKAo/JxlYAlBBoAx1yd8z/eYKfCj1AVazg9iQDFFf+T/lbKojRxpMdrJZQpMtqlgZICa2Far19oCcl6Pe4JNgxhFJV7GngZHxuUrwwSctszlH+HxeF8Abox11m0VcPQ6ZmiXFXLichVYEjk6wlEgOUQCjpygo9tIX0k9qmOGFQPo6DaAYpNqXzbssBh2TFGfQPu/2upHW64LCVQfA0MEPFnFYsgQACFtJMAkiA+KBJgEMSAovpAGMjmhh3MJn/sCqV4Zvwwy0UCjmUGuT+T3MMmWyTcsjMYJdWmMAQr4yLZiuQuwLm0ly8MPXI78xMtecR0AY/QHcAOQnP/Dy7gEBMFSr703LXXF7dtVW23iNIGL7kepi8ZmiwLVQml3cvVNYM4e4fGHG7k8LdqTJYKjbqt92ur1SA6v0wGISe+h1Evj1CMzotwAOsIpku2i7UDbju2RhCFhr9pmjeoIP7C0N8BHrWDH3H+NaAdQIoFFfAwEEfDkkQw2EnAo+TySrRWGkISeeEKKt+WHiLqgJ2EbNVCWuPS20VYy2hPjTbzfgYjYyPVKfo8MPtEHkAo+LGW5K2AhrDD3klcITzEUhUO2w4+e9yNvy7k/4d/DDEDyexvI6BBkei+2oW1rE5Fp2csERXGdPbfHprRIEVeeSdYV7bFCTwao0bezRn1sbW2Ao9SVADl6vakuPqeaQce5bGV4nwo6kS8n6Og2kfSoTlwGCRJif1bQ4PIAGXMftYGd8H9GeTwNKgKerBIzEDTYkaAnCA98Zqx3Q484YKOrsuT3Aoike+0IOJFtOQwEep+WJS5u5BPt4S0ZBx81vwdMAh/RC6+3gU/UsxQO4+CjLHdJUR/+p9ABJw1+EP2N4vaIJ3hL9McFQPzeP7xvLtsSlwI42pJYAn502NGAyGYn6gxwZLTTACfvXVezAJANwuyRnozQ44CktPfyr10fwDGVlQ05QHTuVUAFyWUroHqgE22rkCPZSONKi+ooNjLUFIQdZRxFYUe3S9nWYSfLCnIRUQ6Pvwh4csgJMway0Ytc0MMPNAEiXNL7QMr3kcsYBwlm8C9cWJa4Yk8xEEACKnnUEiABan6PiCKxOKoUjyRsrIOPAlSc1jTwke2Z5E1OdLYteal1YR/y1V5AevQn3CU7APH2ot4S0eFKRHOkv4AcEVLsPcrkfpyPmpDGUo1LUn18uq/cStaVtZwlb5vgRrfPAjiynyyQo9cbc3OigtRlK80uFXSABCRZ83Tkdvz7LvsR2yoYmaFEgh0brMBRZ4EWpU1W2IHUjyblOYrQ7OuoftZmfS6dv4+SBtPgIuDJKEHx0akyATMVANFdj9FmSGLW/lfqAoBFMBMAcSIz9xvPa4l62Y+yxBXEUCOAwbTExST//H48cFzCLgCED9YAPtF2oLSRTxrRWAPtyi5ul0g6lprzOTsQbxFIwCE+Jynyw+t4O7neFP3hHQWiL9VHv+S3XyqX4YVJk2TyiitmfG/aBrOUmWZmmw+HstialBWafJevXPZZoj5ZwMZWrpapvkxtswCO8r/cb8JGhpcskAMokwXT2tsAxhLR0e10iDGBTrytgo5ulxrVsZXbYIjbO9qZ4EgeV9alLPnJ7aTGUf2eKAjg8ccfx4knnoju7m4EQYCf/OQnVtuzzjoLQRBgyZIlSvm2bdswb948jB07FiNGjMCsWbPw5ptvKjabN2/G3Llz0dnZic7OTsydOxdvv/12vkGbvtzygQWoB5nnwSXKYLdPPbANY3HbBwgqQfJJwwwhTFWiem1/wicVSxNbZCsmsopqwyoAk9uIySAsY5XwFy2r6O+jCT5qy1iASiX8JVqJ7BDV88Q9hvCEUqm0Ra/Qvr8S1vdX2iI/bYo/ub6/0iZ+NVUQoJ/FNuGrTfjh72XfctkO1iZe/dJLtuuvtGGH9KqwQNl2lkn++auC8BEFpjrFLvrMTL6zvmRftnH5jNE2Hp+yivaZMhYof0e5D9ff0FwefQdYEL3UvyO36a+E3yn+/axUkjby91d8D6Xvrn4sJL/z/HgIjy1xDFTU4yGGk6gNP+4qyfY8oiPPDahIx7jULtBO6DHExPaqr+S8ESjl2vxjmAOzvk9Ak+98LKko7NQqAhQeS20FX9l+sDSr6hrhee+997D//vvj9NNPx7/8y79Y7X7yk5/g6aefRnd3d6Ju/vz5+NnPfoZ7770XY8aMwcKFCzFz5kysXbsW7e1h/sKcOXPw5ptvYvny5QCAr3zlK5g7dy5+9rOfZR6z+DIDYGBKxEIOfIT/J5OYvSM9zGwPWxuEb+SIDp/r+Lhs9pCXuaL9SCxzsbBC9hNe9QT1yBYhF6bawJbczHeY20iRnmgQctSHJznzCJJ8hZccKQrN4xsbArBGd/Toj778FbaRbJi+hJW0k/3xPpQlL3k5KxB/CMWv7CfLcpYr2qIsZdVokkuL/vjm7QBQIinCLmVpKy1ykyxP+nZFcOR6VzTIGcmRCvJEc0Q7MSapTrRJLlsBeiREjwLF5QqMQDrss0Z1Ih9GO71O27aVG8GFbztsE0r4KgA7dB+ehlNdgee4447Dcccd57T585//jPPOOw+//vWvccIJJyh1vb29uP3223H33Xfj6KOPBgAsW7YMEyZMwCOPPIJjjz0Wf/jDH7B8+XI89dRTmDZtGgDgtttuw6GHHoqXX34ZH/nIR4z9btu2Ddu2bRPbW7ZsMdolIad+0GN9L0MPU4EotpegJtDaC0JSk5pjG04YfHZB7DzQlrp08FHa8QHpS1zRe9E29G+9wssFP0Bqbo9cD/gBEGCHIB125HIAVhASNtLJky9hmaAIsMNDW0p9LZTWt+3SWJ978uht/aHH3I8v4Mjv05aqAD/IUes1SNHaGpet+LYP6MhlnqAj2mptzDASJOqNURwY/Gi2ZpBK8W3z6fDtCzvqZwFSE6ihc3gqlQrmzp2Liy66CPvuu2+ifu3atdi+fTtmzJghyrq7uzF58mSsXr0axx57LJ588kl0dnYK2AGAQw45BJ2dnVi9erUVeBYvXoxvfetbyYqI4uPLvx35POL/6kEPovOh+aoszSbeBaUOEgBxqDH55YOSk5E5r3AIEREfeSckCBHgwyJokOAlpkfDCSlAvAPif0Ekoo2c7yP/L84Dge5CAhGpHohzd/QIkOJHHqsc3ZFmQPWHXuxXzgEStdo207b7DTahoTsPhyclunJ+qqm89+ExRnQ8Ij9J4DGPxQeETODiE8EB8gGO0r9cbwCeUB6QE5UlICfRzmILGRDygY7wkQY62rYRkNKgBe62zjF5wE7sVzrmteiO43AsVeUkLddnXqi1Ghp4rr32WgwaNAjnn3++sX7jxo0YMmQIdt55Z6V8/Pjx2Lhxo7AZN25cou24ceOEjUmXXXYZFixYILa3bNmCCRMmKKHLukFPZMwiCLD55NCi2AQxV3DDRP9yRIX75X3yD0S2kQYQRHUCfKR+eA+xr0DskDHqwz1yQJIG6RP5iZe9skV/IMogojthWfg/jwJxO/6/NboD1ZZ/VvryldxOtDVFcgwnfJOt0iZSvdfqbVEcriLgo8/Z+r5mgRsfe5NtAnCkwlyQo2+bIIf/b/Jji+Yk2mq20mfiBB2pvcnOGBVxwY5PuzRocY3PCC16uRl2EnIsZdUy6sPz4Yr6GAhqWOBZu3Ytvvvd7+LZZ59VfkX7iDGmtDG11210dXR0oKOjw+Q8DkRYoEeclFEF6JHAw2Tr9T5QWYTXCadivjIvcwmQMtlI4KMsdQn/McDwGxgm83wA5bEVYlx8YNIDS6UxxzAD4dcbfhDvkz8AxY3kKJC+FCY+Ken7JoMQt5UnSCMMyYOU/ADmZ1HFgJV+/BS9SgvIvlzmgh9zFMdg54Aak5+8cGOzV87bliiO7CcX5CgdqdCR8KWVVS2io/kRUR0dQOT3Cb926LC2S4OWFL+ZYEeT6iMFdkgNqYYFnieeeAKbNm3CHnvsIcr6+/uxcOFCLFmyBH/605/Q1dWFvr4+bN68WYnybNq0CYcddhgAoKurC3/9618T/v/2t79h/Pjxucdn+aFtrovP6+o2t0c26DG1gf7eBka8PIIEV7QnBht1mYvbydsm8DFFcgC5g7g89OdY7uLteTuxUxL88A/BE36AGCRs0Z+wzg1AABI5PnIUSLbn71MjOw4YAuy5PPI+uUBHBxxbdKiofCDIFU03/fLME+3xgRu9nWuJSik3tjGMtQjkyNsSiJiWrQAVHKygY4Ii3iMztzNDSGyXgBkT3LjqbTCib5vaG8ZgtTfWs4SdEZR8rsgylVVJlRKepVXRJ5gWVcMCz9y5c0UiMtexxx6LuXPn4vTTTwcATJ06FYMHD8aKFSswe/ZsAMBbb72F9evX47rrrgMAHHrooejt7cWaNWtw8MEHAwCefvpp9Pb2CijKIv6F59EGr6UtBXTCLxaTo0tMs5f+h1zG5xWmlWu2MajYAEZqE6gcovuIuSKAWD5C7FTijvzgwzsKXMtdMEd9LPAjg4tCe9IfJC36E9pkAyD+XokCIe7TtBwmtwPghCHuw3RVhb5kpkvO36kW4LjkEza3Ji57RHz0tq5ojy8QMZMNS5YZI0GGujIgR/HpAhctMpNqz8tcoBOV69Gf1KgNPOpNEGPZLgI75kgRSxw3abCTUOJWJZYDsWRRDo+/6go87777Ll599VWx3dPTg3Xr1mH06NHYY489MGbMGMV+8ODB6OrqEonGnZ2dOOOMM7Bw4UKMGTMGo0ePxoUXXogpU6YIWNpnn33w6U9/GmeeeSZ+8IMfAAgvS585c6Y1Ydkpxs+3EtxkzOcBgKDCwJd3THCSsOcgEECJ9hiBxnCeF20t5QJ8NB/COZ87ORAEybs1y22VRGTuRgIccU4REALxeYBJJ289yTkqk/6LfUg7riQ7QwMgSO1kR1ris6FK8clk/4pb9URrSnbmrfRV1bQk5qQPtz9ZpiTpWqlIpMcGQVmWr3T7BBzZ/PrCDVAO4MhlMnxwvxr4GCFHtE3WWSGHt3WAi7B1RXRM9tDbJ7d9ozq6D/HpMK1cH5fDZ2IZKwE5Ztix5e0o2zUQv5dOMR8EPFXX7373O3zyk58U2zxJ+LTTTsOdd97p5ePGG2/EoEGDMHv2bGzduhVHHXUU7rzzTnEPHgD40Y9+hPPPP19czTVr1izcfPPNucYsvtQoAD1B0qd8fjZCDwcBXm6AHtN7ASGaT71cAR0+nshYtIu2w7ok+MiQFO9jNDFDy/ERvgLJufYhyfAjg1JknyfyI8OUXiYvf0F8xkHcFyRwiurjtvGHKT5/uR/uuoTojn6yVoDKMG/J9fWI7OhKS1wuEuUxtbdFbBK2zFxeCHBMZcJe35beW5a/jNCi+1VO7BYwUsqCRNu0iI5uY7VPtE9uZ4rqyD5M400Bl2Q5S9TbYEdWGuyQGlMBY/TX8dGWLVvQ2dmJQ074/6F9yNCwMABYmxytCKEnjpoEAiLs/0snyqjMag9DPS+Dn72YY/VyfQxQ7Uz1ah0z22rjExEf+Zyk2EoUl2jPlO1ElAhQoz5yW+W9WhcYbM1lmm/ZTq7Xyq2+k1XmttayRJFQlkiO8TL3AkoDGlmuyE+WiI8rYmNskxNuEuNyAI5SXhByAAO0pERzjG2UMhV0kv6Lg45i42qfsp3oxzTmNNhJ+GQpkCPX+V2RJZft6PsATy7/Bnp7ezFq1CiULX5Ouvu5KRg+Mv0hwS69/04/5h74QtXG2ihq2ByehhW/SiuQthFAn0/DYIPn5eo8HwjxMW2yh6k+UCfgNHs5EiPspP2Rx8CjPXo931bbGnJ3gthh/HkFUf8S+PDJIwgLmHCsfxDywN35PolkZ2nflQ8AyVwfU/6PMwIEqW+5PSQoMdTp5z49IiSZJBKgwzIkZIoUJW20ghpEfXx+VrlAyQg5PnbMXu/MASoNcIDEH1rxVwByjP9L7bT9C8vM7Z0RnURZEjRMY7X7dNdZbblflw8LwFQFdjQZoz01UH8JScv9xqOp9UTAk1HiS62ATHJpC6Y6WKCHMXHiNkIPP7Gr5+A4pBuBhbzEJUOJsBeAoG1r8GLKyVHAJ9DaSu8V8JHGp9gwgOfrBGIH9XFFJ4JAKrTAj5zvI7cx5vzw/mLKgKokkCjvlTJpklDDO7E3PZpjNot6DhLRFiMDsKRdPKR0eCk7opMm34iPbVTW9oYGyeUsR73L1gQxXuWGsjyAY6gzQo4jkqOWB4n2bmgJ1LI0iIFWVibo8G197C7A0WxUv8zaVwJWHJGdZL+1vf8OKbsIeLKK8fOlH/SEbTxyehhgvU+PqFfbQrYB4mgPh4wUe3k7AUiaD24os4JoK/UjoEgCn7hMgy4NXvSoj2ofqLBigR858mPL+ZEjNAmffI+UDwL2KJD2gcpXayX64n4gjQdxO7lejwzZ7OIKo3minbFtjeXVv2VHzMtZHv4Lwo1Sp5RnBBzFLifkmNrq3xNm96GDhM3eBTqmcVsBKqVOaW+AFSCeW3wByQt2TGNU9kmDHU067CTqKrajsVxVWBsqBa/SqgyQzBYCnjIkYMSSxCyd7BPnaug2ZuiBqY00BBl6gPj4k8/pSnRH8pnwodUp20E8gcjQokOTDD7hv8wIPnKZAB8OKFLHNojJCz/iM4rq5EvRMwEQH58OIjYIEnXxiVJZGov61+cf43KXfA43zFeZIKdMBso4d7qXsjK0SYnuWAHGUG8HH0u5Dipy/4qdA1TKgBzdjw4nJmhJAx2br6jc5DtLVEfuMwE0ej8Wv9b2ij3zgh09WiNghxnqpM9CKauwzMdBXtGSlr8IeDJKfKkhAY4CNPYrt2IasUAPEJ3wk9AjR1dcYCLeByr0AFo/0YYNnGCxFYCSFXzkKA4vk/qJ7XiBFCGCVMeLCsKP4lOO/kQVzvwf/YOCYRmMWSAIcbtELo4MfrxIAKwKREo7ST6QY0x2rsF8VzSPx7S+Z/TJdBs72CTqlTpHO3EiNQCOpb5mkCP9X03Q0dsYQcfkQ7ex1aX1o9W5bZgbUBRfhqUp5qrTAKhGkR1SdhHwZFVFerQEVMCBdk5iSEKPACTmgB6EYJCAHqut+h7chkOPBCNMs+FjVaI/0rZSJ/mxgo88DiaBj6gPxP7pkKPYyXDC+3DAD5PXdDzgR26rgFNUYV3+guRf7I4/BIW+ov2w1Ks2kAq5nXoiVu5haQIG5UzlBx4JFwkfDjDxVYoP6zgN5eaIT4pNwo8FfJT3KYAj2ZgAIQEmSl2yj1JAJ1FWEuiY7FyAYrE31pnG52hng51A3PLabJ8GO6a8HS4rAPE+UBtVUPx2E4YVu5ZUsTjYAJZ6wBjuw5ByGaN+wMn/KwcrL4t82G0jm4rBBlLbijoexa9Uh+i9vA/iwDa1R7ytjEPuryLXBwALEFQCdexSv/JYwv+1NvIEprQL7UL72G/8CoQv/l5vH1TiOlQCsArCFwNYJQDT2ocvqQ8WWF+8fXkvpLyK91HpbwOrhK/wfWONGyzd3vU3Cf+Whu9IRfubsXh8sk2gvOTvrvYdUb7Pye+jfDzox7zy3WTady5xfOnHknpMyMeY7XgzHmOanV5mnFMc84YCM9FclZjTDNvGeUnbFldiaf34wI4+T/okKYvojtam2uI3Hiz6yqLHH38cJ554Irq7uxEEAX7yk58o9YwxXHXVVeju7sawYcMwffp0vPjiiyXudT4R8GQV/1Inyh2XIyYOVKbWOQ9Kph2UdlvTe+HH0N466bj8yHUW8NHHapyYlIkzmuxNvnPAj9pOPqEZTjhM9SdsZB+yH+nEpUAQg3pS1U9wcl/cBtFLnHRjm/gEK720E3zC1tQmBbBkP2kvcaLP1MbRf8o4rX5SP5OUz1f/e0jAIeBG/E2lfTaBifzdlL9Hpu+b4fsrf+8VP5C+e/I+mY49va2jnXLca8dkoi3UMpOddc4w+LbOI7wMjjqLj8QYhQ+mfI7Gtkp9+jKWDjuyErDT4nrvvfew//77W2/ge9111+GGG27AzTffjGeeeQZdXV045phj8M4779R4pKpoSSujRLSkwhC0hUtZAaL51Xa5erjhv7yVKAutASirJjyIyQzvmbShtAnUY1X0EdnKx6rJDxiSy1SGenmpS5RJ/Qg/cr/68hWLPwsEybbKBya3kz5DQBpHZJvI+1E+CEiDlT84KQcIkh+oNrZ8nMSSmNxO2AfatmYjFdiu0jK3iUwMM3G9rthK7dd50jC0NdnrZVqfzqRmfdmQedgxU33S1uorURcY/QZ6P4nywGlvam/6kSZsTe1NvixtjP3L9dBsLW0T7y3brnvsJMqABOyk/zhlST/6j+AaPlqinGdphe23bNmilHd0dKCjoyNhf9xxx+G4444z+mKMYcmSJbj88svxmc98BgBw1113Yfz48bjnnntw1llnFRprEVGEJ6+iL7kzqhMdHHKd9/IW9DKWKNN//dh+CSV+3SDZPjExmPxYQtLGNoaIjzVkHtWpv1TVX9JwjUt+2SI/0j57RX8S75ORG2U5wORPijrokaDEMotmry6PyS+pDaSXcZlGbZu6NKRHXIq8PJagrPuVum9Ifk76d0CP2MhRm+jvYbPXozeJ5Sn9OyN/VyzRHmXpVh4rpO+P/Dlo30f5e2Y/FtTPxzgH6MdgxXKMGMZqjdCkzAWuYzaA2dY2r+nwom8raQAG+0ywA0sbvYzDjuhL/kCrrwqCUl4AMGHCBHR2dorX4sWLM4+np6cHGzduFI9yAkJwOvLII7F69erS9juPKMKTVfqdlvVID3iqMRJl/DBIXL0FaJEhKJGPuIyBJ+gq0RTEv5Jke2jv5W0eUNCTmkWlHElJRGJUeyVSY4jIiM+Kl0Hzw9T+5EgKiyIu+mMdxH5LvmN77i/QbJhqExcp9sqPe2WWk8sDY3mg20vOEkGNIHn5uekSKusjJFw/IQPxj5/0L0oZyurPZW+JCPlcpWVqb4toGO11IDC+j+1dEZxkfaDa6SdVQ12ivaONnw+7rdOfBhEJO1e9xVbvMzWqI97r0KH6Tvphan0lpV60t/zIldolPscqq8wIz4YNG5RHS5iiO2nauHEjAGD8+PFK+fjx4/H6668XGGVxEfBklPhSc4AJ4nIZcJKXoDuWtwLVZ1ymAYp4Hy1xBXG/YnxG+6SNqOPD1M/Thvd6WwV8DP0qn5k8LwdQJgUjJJn6k0oEPlrayzAoZFj64sWJk0YQVypLVzKxGXdcIlCxE0z+L2krv9XaANpJXd4n/SSu1CEpFyDVaHIO+0oHMeePZFudwW8msNHrXW2LAo5s6wAWc50KSbkgJ8XeG3QcZcZ6pNR7vDfCjqNNVWHHlrfDx9VkGjVqVGnP0gq0X2qMsURZrUXAk1cy9FQY0JYCOKayjNAjA44tr0ffFiygQ4duF2jQI9mnQY5SFoGGsT8dRiRYFL4stom2LB6ED/wAap3SXnxAmp0+lqjSCkDQPiwTBCm2cSdeMCS31doDBkgwAV+KypiPcs3zaW0sYzcynLHMATZp2775PFYbLYojvTf60r97Bh+mKEIh0LH49bGxApJcb+rbCjAWv4a2RWFH/kyU4GyivSGpWYedOj1aopwbD5aX3dLV1QUgjPTsuuuuonzTpk2JqE+tRcCTVdEXnEknSwbES1tKeQr0IB16oi7NEBOVxItoKeddzQ8fpwI2OvhEDSU+8AMfvin5lyX75QVpUZ8s8CP6kz4AedJV4AeaDxlkYAEg7lBfBpNhxvTHULalE6kPDCk7obVPbponXleUBzlhJat8wMs1DludyW8WsDH48IGbpJ1nFMdQnwZK1YjmpPr1aetq5+M35X0SXpilXHuv+FJhJy2yI6TnYTIgcSflhA1DrW5uU2EBKh7HVJqPsjRx4kR0dXVhxYoVOPDAAwEAfX19WLlyJa699trS+skjAp6MEklxCOFFXrqS83kAA+Do0MPtJOiBqR5ucDFGeyT4SPjRgUEqY4C6zCVDDAcOaRw6lJjKxIAVSEnaFIUfAGDyg0L5jok6g3/53CTVy1GZ2JaptraTmNxefWswVscfl1kmINu8FHhcFaKNq67yASvXWK3Q41GWNZ/HZuuR52MFpqKAI9tVA3Js5a62epmPD0N90aiO/D4RfeF9VHRbZhmD/V479rYh7DTjkpav3n33Xbz66qtiu6enB+vWrcPo0aOxxx57YP78+Vi0aBEmTZqESZMmYdGiRRg+fDjmzJlTx1ET8OSXDi/8pJUW6TGVsRh64mUrU/Jz1F4qi+tZ9D6QokWxPQxtZF+QtgVMZAEf3l4GH5tf3Ub2LfuTYQwGewMsJaM4hsiNZC9/KEb4Uj60IDGmBATpH4jsVzN05e0k/yi6rdpHAg5MrJAKRCVO0HnAKq37LJBjGINx93zhRveXE3CSNiVDjqmu2qCj20jjMPl2wZJvVMfWzgktvNwAO0IlwU4tVSlhSSvrjQd/97vf4ZOf/KTYXrBgAQDgtNNOw5133omLL74YW7duxTnnnIPNmzdj2rRpePjhhzFy5MhC4ywqAp6sishdRBIMQKNEejSAUUFDgxoOPVI9gkAEKewRHvm97DV53tTPlyYIStjK4CO3twEMUsCH9yt1zqTBpEZ95LG64McIMIFkH0+gOuAEhg+XGT9AA1BJskEQoPWhGGvn6jQgkn3Y6m12SpsaRn982cpl55Ok7NmXE250H2UAjmRj85EKIobx2dqY6pz+U2zTQMfpx+AjDa68l7AS7/1gxxkR4vXSvXbMoCTXM+Wzr6bKeVp6tvbTp08Hc0SwgiDAVVddhauuuqrQuMoWAU8eVYCgLb5SCgASV265oIdHdWCAGg49cj2g+LYBUPzendAMqcwGTkASWvTEZt2fK+KjQIVkK6DJ0Nba3hd+5H0zlFlhxQBAuo+EDd8pLdRkigQBMAONvt+SH71Rar6OLVrjmoTL5p08E34KdFmDUJ59ZQIbw3YZgGPz44rkJOo926VCTvS+SDTICDp8Ow1ueJ2zntn9GHyYQAbICTu83HKvnbhtVN/iS1nNLgKejFK+2G3SAz4DpEIPINlkgR7dNyQ4kQBIhaHQ0hXt4WU+0R6l3gY+HF4iw8Q5WLJRQMLQVgckfRxyoS/8KH1whwq4FAAgk50yaD8Qkk2TOxsr0SwBQElwSA3g1HietsKLrBxjMkdADDufF2607byAo5Sn1fu0ddT5Ak0W0AHiYzdh4/Lj8GmL6hjbFoQdr4iQCXaQ7BeACjvSOKqtfgToL/hrpWj7ZhEBT1ZFB2K8pOUPPfG50AI9gGjLryAwJTNHw1BBQXsfn29ZVJ68WSEfonJuNkGLBg8y+ETuY5v4Y0rCiw4hKeVGO0C92aBhf+S/lb4M5QNAAG8XqO0AiS4lO6lz5QQl9w1tLKI+SXXGE7aDDhJ+LfICjAaVPbJjmaiN0OPh1xds9L6zwI3ej6sPqd4FR6a6qkKObufjy1RnKEsFHWFnem9Ywkqz0cvlvkywk7BjdYMdoD5LWs0qAp6cChgLb5HPvyccXKRf8CbocS5vmSI5hmRmORqkRHgQn2OTgYZsy1x8Oy3iA8Cc3CzBkamNzZdenoAfk62pTo+kSL7SAEj3qUCVKVIjRYJkE33nA8eHYcz1USI9NqrTIct/oq31BVuZgCttcFYA8uw3BXSccKPZuyJBmSM4Pr71k7+pzKeuDNDh256+rHAkw0NUlwpNynuW6C8R1QHSYQeSfQbYETKNhdQwIuDJKr6eHMTQE7RFER8OLgYocUEPEMOFAj0chkzJzEByiUuJGJnKWdRX+jJX3Je5zmgvgw8vEzsGJVdHgQ9H1MfYj24rj8lWZwAgJr9JAR2lXKtTd0yDIN1W2RGtjVaWAKjEwDV7o7HBRu+zEeQzFouNPfrjV5YFbhL2nuBTFuQo9Q7wyQNAuUAn+t8LdPi21YapdQY7MwSxZBtXvk7CV8bIDqTxVpJj1/ustvpRfEmqv5yhNLwIePKI8bN0tM3zebQrtxLQI+qgQI/5SizLFVwcaCQwEjairf192LU92gOktUXiBO4DPqa23lEfHYrkvnzgRx+zK/oj9WfyAVggSIcTn5wdE9C4YEgrV+x1PxYbq59ayvM8kApkGUDHDBkZwCatPivgSDZWPyn1NkBx1XlFhTKAjij3AZ3ofyPoWOvMvmQISdj5wo6prQ/sMGnMfPwWKKqFaEnLXwQ8GaUeaGGMhQWBeuUW+DlYg57oQDLdnBDCm73cltdjbhu/5ydz9XzOoveBFRqUtpGNEXx0IJH749tw2On9y3bwr5P9AJI9kv2Kemj1XCYfup1Wx3QfhnoTKSYmSPGF0dpK41LtLX4sdlY/9ZDPOFJs7EBhoLo0qPGxsQGKcywWmyKAk9bGBh2msjyQ47tttWHJNk64sYAOr/PI14n7KQg7psiOYsfi8VRZZT48tNVFwJNVTHpaug169OUtYQUoy1vRCVGP2Hjn9SBpAwgmEO/jaJLURryPwUevg2Rv9GvYNrUB4I76yHY6/BhsfeuMER6pzBoBgmYjS7aT2+v+DD4Ty1Ym8JILrFEenYbMzRNygUO1Iz4ZASs9umMZsKVdLrDRbXzhRrNNAxyXTV7IMbV1QpHNdxHQ0ctdoBNt+0V4DLCSMV/H6DtPZAexnfy+VrBDyiYCnpwS0ANEcGKAHs1OWd7KCT1Rd4klrrCcQYkoQYcbxO2l92FdDD5OiIn2xxjxsbWR+9HBJ/JjXK7SfcqwIpW5QEbhBL2N7tMFQNDs5DFB82eyzQJCNt+iPBklUoaZ+CN40EZGICldPhnUjjH6RFactnpZFrjR7H2WulIBR2+bE3KMZTrkmPyXCTrKNvPykRqV4XYVmw+/y85FmyywY7kii48xHlNtDiqGAJWCv1hYwfbNIgKejAp/SchgEb5XoAfhAcFvTCjb5YUeIOlDXuJS+gHs0R7YISjcVpfl5DoY2uSO+EiF3lEf2a8LfmRfFoixwo0NgEz+bREYky2z2Os2/K01upPsx9RGtbFU1GuOy3AeyAIaXu1SwCZPnz6A47LLu8TlqndGhlxjqCboRNtZfPouYYk6W/Qm8mH0XSLsCNXwsnRa0vIXAU8OhdEVA/QgAp3ocvW80AMAetKy1YcYT/Ream+M9iT60dvBuMwl20Jqo0OJbZuf8I2RnCxRnzzwY4OYjADktBMGmq0sPk+aIMcEaoZyow9bf2lAkzIn571s3Seg5O64gH9f0EnzY2ln+5um2mYAHB8bJ+TIbWSfNnsPYCoDdKx+UvswRGU8lrBcdaXADuR9YNK4kjakxhABT1ZJX+wE9AhAiKAHMCcyA5Bzcjj0AAa40Wx1H7yNEu3hI2EsSh6W7HQw4bslb0cn8oCxyNYOPjqApG3HFVId70/rhJlslfEpH4o5SVmvl3zq408AkNQW0NrrfWi2ir1cD62NMNY2U0Jl1pO1JWJkkwtqCoNLUX85gCRXX2lQY+rHBicZ6ooCjlJuamPotxTIkdvnAB1/mLKAjm6bcsl5bKf5NzwINOnHAjuGyE69YKfCAlQK3lSraPtmEQFPVvEveBCkR3r09wzWZStUGNBmi8j4LXEBUHJ7jODkEeER7YQti+rSIz4mnwqg6PBjsQVgjfwo9nJ/Dv96vRcA6eNx1Ol+hL08WB2clMEZxmqSC6i0epPfRLc1nJi95DGeXGM2tPECG0OZawmrLMBx2WSFHGMbR11qNMdpawcd67YBdIy2lqiOy4+1/7JgB9LYELcN62tzcPWX8LT0ou2bRQQ8ecViuEm8F8tYWqQnC/RIYGJKWjbBDK8zRXuMPmCGFHtdPvCx9aPYGGBGsS0AP15wY7Ex2QEZIMjmzzJw6w8tQ3meJZlG+yFXGnBZ/PiAo63MCS8e9V6A42HnBUcuX54+fZetzLY5QMe47RnVsdmm1VUM48wCOzD0Iycpy59HDfN4SH4i4MkocZUBB4hKEEVUZHjRoMd2yboNegBrXo89L8dQl3LfHsAMIGlwkgo+fPclZ1ZfBhs46lLhxwIx1n58AEizS7O1AU0aCFnbaoNOhRZHfcNFdFzyGGsmoLGU+0R6ssBNwj4HCBWGHLncCSpJ+3qBjrE+Laqj+3LVpcGOvk8m2LHda8d2uXoNREta/iLgySE5GblM6AGkuUXP60Fkb4roRPVWmLElNZtsow3TDQGT20zalm5gKO+H7NfkW+5b8y/voAkwhE/eBmobxafeN5Ll+geRuiRlsjXY8zZpNkbfuj00P4b6NFBolLktE3yl2TrqfZeuvOwKgJD3UlhRwJHe+0aMci1bOW18tx2gE217gU5U772EpftLg51E347IjlZWbVXQhkrBJami7ZtFBDxZJb74EvRAggoT9ABw3ZwQgBq9KRDtsfkyJjVzW2jgI52cjdtKe77Nom131MfY1gQ/iOV7fjdGf/R2BgBKlGt1eiQmdRlLr7e0AZLwkTvCY4Ipi6ygUU0Qyjv5p7RzQpPrO+BjWwBuEvZFAEcv92lrABivMkede2kn63Y66KTZe4GQKaoTtbHuX9ZlLFHPEmWkxhIBTx4pOTviH3ukR79PjwY9HCiM0BMgcem6Yg+oS2KGuniEZvCxLYnFvmLF9vG24t8CPrKN7Euv0yNBtjIvPzLYJJsl2ur+XXWZIcjQRrRLdAYrEDnbaG3Fpi/INMA87R31cdhVZZkrKxBlqKsJ5EjlXtEcpax80DHaSMtXot4jqqPXK1EdSxsj7MiPi5D3N20ZixlgR4amKqufBegvGLYt2r5ZRMCTVfIXH1CgBYA90mOBntBlkAox1kvXg7gveXipERzbnZp1W9mXFmUy98e3VfAx2cjyBR0j/MifvwwVejsTAOngIg9KB6A0qDFBkO7UBjIGGLL60HwZ/Zl8iAK7bc2V4ZyQCkOueh+osdnmAKJcgKPXVQNyZNvUNhZgMJU5YKrMqI5e71zC0sut/vxhR8h0+bkEO7UU5fD4q64Ld48//jhOPPFEdHd3IwgC/OQnPxF127dvxyWXXIIpU6ZgxIgR6O7uxqmnnoq//OUvio9t27Zh3rx5GDt2LEaMGIFZs2bhzTffVGw2b96MuXPnorOzE52dnZg7dy7efvvt/AOXvtDGdV7pF0DiYJF/DRgeQKcfzPL6slji4mVRvTiYU65aSLStSL+qLL7MfdnLkttMvHQbuW+XT1ubwGJrbKeXQ3rJddqYgorqQx9zWr3Jp7Gd4e+R8GGrk9omfJpeleTL5rfMl6nfLOO1+nZ8NtZ+bH+ntL9v3u+A/H2UvntWPxVtXCk21u+5oSy9jfl4dfkV23yf4DGf5J5/4nq9P1RYnK+jt4E6RrGfJthJ9BG1N9xrR7kiy/RQ0SqLRU9LL/JiA+ROy3Xdy/feew/7778/br755kTd+++/j2effRZXXnklnn32WTzwwAN45ZVXMGvWLMVu/vz5ePDBB3Hvvfdi1apVePfddzFz5kz09/cLmzlz5mDdunVYvnw5li9fjnXr1mHu3Lm5xqzAipTPAyA+UIAE9MgHXeJgq0gHiO3AFpNfeEC7JgOfiSLPxMNt5EnXOgFW1DbyPgeGCcl0krBO7ibfvicLqW1inwEBQAkIsvkx+TKd0E1wUUn6NoIBM/sxgkAl5cXMLyOMlPyyAkvauNPG6vh8rH2Y/Bn8OO1sf0/9uy19r1y+MgFOxnJTfVwW/yjhx6brGDfPFfqxyQrPN5nrbVEdY5vISAcU3oa3R7gdj1nvg8EMO7wxqZFU1yWt4447Dscdd5yxrrOzEytWrFDKbrrpJhx88MF44403sMcee6C3txe333477r77bhx99NEAgGXLlmHChAl45JFHcOyxx+IPf/gDli9fjqeeegrTpk0DANx222049NBD8fLLL+MjH/mIsf9t27Zh27ZtYnvLli3ivXzVFcSNB6WcHERlFYjlLdOzt8JlqZS8HsuSlemePan5O9H/WfJ7ZHu+D2af6rbLJiyLHYkbNEoNvXN1mNpB6qMiHD51u0A3YOo+gKn1gbZt69tmB1jGafpwdX+OeqMvvlmHSHbA0m0S8mnjsDH2abH3stW2XUtTRp/M8l63ZfnLjTZKGUvYmu3Sy9Qx6MAQ2VRsfcWNrX7TlrfSrsJS2lhgx9jGnLMTt3PATq1yeBCgv+A6ddH2zaKmimP19vYiCALstNNOAIC1a9di+/btmDFjhrDp7u7G5MmTsXr1agDAk08+ic7OTgE7AHDIIYegs7NT2Ji0ePFisQTW2dmJCRMmhBWmg8Yz0hPawHzgRL6UcDJSDl6PaE8i9Ms0nzl+gfFxuCI8xl9/Vjs1hG77NWmsz1Fu+zWd+IVs6hfaS7dJ+VWdul+maIPUxmtpJy2aYurP9DKNIcsrT6Qnx/7k+cxc9sZxpHwPXN/PtO+Iq/+s3/M0G9MSs/H4hd/xm5gbXPMJVN/hNnP25RXVyQk7+lxrgh0h25wd+UqU1VDhRxAUfNVl6DVX0yQtf/DBB7j00ksxZ84cjBo1CgCwceNGDBkyBDvvvLNiO378eGzcuFHYjBs3LuFv3Lhxwsakyy67DAsWLBDbW7ZskaCHQYnqmMoYEB6Z2SM9yoNHAWNkRk9otkZ79AiRlngcXz6P7BEfUxvpM9TL5GPKbMekMr9kZ5svIJq4LFEeW5uEb9mHwY/w5YoE8U5MkR69raMfr3Zyf/xt3h9vdZgEgyx9pthafWUoN350ml2in5Rtl71S52pneW+zcV5pJZXnK7PARUW20dqlRWx8bBxXYYltA+go2ymwY13G4jYJf8k6UuOoKYBn+/btOPnkk1GpVPD9738/1Z4xhiCQTphBctrSbXR1dHSgo6PD5Dz+nwNO9PgI6/IWAPmSdfWBowAE2ITb8uMoQg+BHWD4uKR79sjlqctY8q7ZbHTwkU7eehv5RK0vUdkAxLSUJW5qKMoDa3sZJlyAorcHpHHBXKd+EJIfZeDJNso3y0BsyrnMQoKJE6NlGUwpMi0F+kJEtaPaBQDKax9cNpY66y6b4Ccj2KS1yVuXCXBs9oXBxwwjAOzRHEc7U1SlEOgo9emwYwQdeTyyL6u/+sAOTzwu6mMgqOGBZ/v27Zg9ezZ6enrw29/+VkR3AKCrqwt9fX3YvHmzEuXZtGkTDjvsMGHz17/+NeH3b3/7G8aPH59vUBG0JKI6tpweDikm6Alkf0CeaE+4HSkn+OhAZbJRwIeJZopfU56PaudXliyPncYPZVWdWG8UaPGp1yWiQA54MvVjbGNqx00skR3TOJVCB5gEtg/TRylQkRYpyhSd8ZGvP4edc8g2CDKVe5SlAVEZgJOwzQI5Urndh6vMACOyTw10TG2dY/GN6GRqG8NJpqiOtJ3wFflTylxRnyqrggCVgr9WirZvFjU01nHY+eMf/4hHHnkEY8aMUeqnTp2KwYMHK8nNb731FtavXy+A59BDD0Vvby/WrFkjbJ5++mn09vYKm0xKHAz8oJEPRq1M/iUhZ/sra9OWg8vyqyTtQFcuYeflTGvnWht32RjyMVxr+b55AEoOgbPcnYeg2ys2aTk6KX70eu+cD0sejzNHCZZXyj4q48iY0+N6FboKy/eVYczic3R8Tr7fg8J/T5NNhu+S134abLMeC+rx7bBVvmcMtlwb+Xvhauvq1zbPcD8A1KiOR1vjVbCI/eaGnbRlLFJDq64RnnfffRevvvqq2O7p6cG6deswevRodHd343/9r/+FZ599Fj//+c/R398vcm5Gjx6NIUOGoLOzE2eccQYWLlyIMWPGYPTo0bjwwgsxZcoUcdXWPvvsg09/+tM488wz8YMf/AAA8JWvfAUzZ860XqGVqijyYoz0VAKlzhTp8crrAdQlrrb4AJOXuMLt2Ee4zccZHcQ82hOElSIQIo9Ha5uwAcxRIUuejxgXYB6b3IehzL+cSeWB0R4M7nwYRxQnNcpjsrH1abKztef2cIw98cYhZnzbEMr829JjB5zRJludodw32lMkupNqz+RyzVCpK16ulrGkrdy+pIiOyb8RdCzjc0V1lO0isOOzjKXX1wiA6E7L/qor8Pzud7/DJz/5SbHNk4RPO+00XHXVVXjooYcAAAcccIDS7tFHH8X06dMBADfeeCMGDRqE2bNnY+vWrTjqqKNw5513or29Xdj/6Ec/wvnnny+u5po1a5bx3j8+Ug6makEPgMQSl8gTirZFQgkS7QJ+suX9SUnNgAFqHGDiBT5Igo/Rv9TW1EfCZ+ZyM/y42piUlipjAhSTT+MUYoMvG/RY+jN17jtnJcxqPdflPA84IcbXt6XeF2yMtjkAyBdwwjo7rZYBOclyB6y4EpHT2mYBHcA/VyeycS85WdpmgR1IZYqtBYZqJMrh8VddgWf69Olgji+Hq45r6NChuOmmm3DTTTdZbUaPHo1ly5blGqNJeo6NFXqAMKcH8slfimtE0AMATOT+IJnXg/BkLvoE1IRmxb8FSqT177T8HlN7+aSbSFSW7aQJ0ZXkrLSXIEA5uRcqFx+cVBfEbbQ6ACiUpJxCb4mokdhIt9frEu1MflNsnb7rrSzjSbHNE+mxtskDNoYyVxtXBCfRtmTAcdp7RHPUMrudE4Y88nRM/VQlqiOXZ4ns8HJa4mo4NXzScsNJys9JhR5DvekKrjjao8NKXA8WRzASCc2WmxWqviL5RHxM7YPY0AeQAAv8yB9lSuQnaZ+tPFHHmGLgigLpbUWBvpxlsLFeKWWJ7BR5QKhXVMf1ATWSMp4fUiM+jvosUGO1Lwg3YX0+wPGuc7ZJARVDNEe1zQY6JjuviI7kwwo6QGPBTg1VQQnP0mroiaE8EfDkUQrUZIKetCUuPdrDl7h8oj2B6iu0icQnlzLAx2Cn9BXAueQV2pYDPzpAZAEgOQoU1icdeEGQBW5s06BzycoCREpbONo7BtEIy/Zey1S6PNrkhaFMIJQGN0abDICj1ZdSVzSaY/NRBIg00DH5MEeFbMDh6r9GsFND6GEofpWW/uOvVUXAk1XyF7pe0AP/aA8gwYSe3wMkwMcXaEx2pr4gdQWYoz4+PhJ+YC7PUmeuZ1q9Owpk8iEKPUGI23snVtv6QzaISZwkazHnFTgPeMORw672ycz5ASet3j/6kwFybH34+MgLOlJ9puUrIHNUB6gh7NQIeuhp6f4i4MkjT6jJtrwF8DdBlP+TtsTFoz0AzDcrjKQvQRkjKNoVXXKdCUbCk7BhGUv6jOKb8FkiNmnwI/nQ/ciAkAACzzq/ep3+ov/0SJAycN02WWayt+b26O10nzYfSoWl3NFHXZVhLIWTmS112RKZ3WBj9FcEfgoCDlADyJFsXUtXqX5ygI7JpzfoGP03JuyQsomAJ6u0CE8u6AGSycye0R5AAh+RVYuEfwE+eSM+QCK5WR1v/FmYoj7G/iTbhN8skZ8UX8l29jqfeqONvhwWGckgFNvanVp/WNnayD5tg7X5g6O/BlHmJa6CsJM9l8dQ4QM3BrvSojtAeZDj6at00JF8maNCFtCQ7cqI6pj6yAs7NbrbMl2l5S8CnjzSYCYz9ACZlrgAiGhPWm4PgMQyFwAkLmP3AJZEcrPnchckN7JtWF4O/Lh8ufrX60z1JhDxXcrSl8RiWzNpFMnfEYPIu4zVKPCT98ewR7tcS1jwBxtrH2nw4mOTWm+BDa1t6ZDjYW8EHVu9T54OYI/qmHzoUR15zDbYkWybBXYAWtLKIgKerKoAaEc26OGK6gEYwcgIPbydK7cnNBL/JaNJUH3H1ungY4r4GMAHMAOINeqj75/hBxtghx/Zl9633L/uTx8zN0gFHJONCTYskGKMCIkm9smmWvk7cruwo4xtiyov5CBDFCjFznq/lCxgY7FPgxcfGxfgJOr1tj6Qo/nMAjpetlkjOpKtE3Rkn0YfGuwYAMk7X8fHJs0XqWFEwJNHlgiOFXoAI/jYoAdQIzLGJS7oUKGCTyKpGUgucwlrD/DhER+YwccGM1mjPsrSXaA2ssKP5k/36Yr+2Nun22Sxs9kCbhjiDU1LZUk/js7TJM/vVYKfXFdk6fL0kXqycVRnX+ZKt80X4XEAjqm9BXISbUuO5iTKPSM6SrkJRlygI/nJsoSl+Ksi7NRS9CwtfxHwZFTanZYT4CLdIdk3r8cvoRl28HFdzYUYfEKvHJAglblhRYAPADjyfGRfLn/KiZpJyc4MQGBp0691BNiXv0RUTfIL1bcemTHmyGg2Lju5v4RtYoBAGnAkTuAZqMoHltS+MplXTZl/IaeYp+5XFqCx2PtfvaXbFIAbU70PsGjtyoYcxSZ1CUwq9IjoWH3nAB1jnRO6PG1rFOGhJS1/EfDkUFqujvjfwzZtiUvUcSiQoj0A3EnNKeBjWupyJTeH7eGM+gDIDj96JMejjd4PAncESPer+zb5T/QBexTFNLW5Ii6uqdAnUpNlKk1cadboynGeKHqlVp5cn9xwA6QDjsGXC3LyLn/ZIMe7TZ5ojmKbBB2l3ODLuXwl91kS7CiiZaymFgFPTpUJPVYbwBntMS1zGfN7XInNgHGpK9NVVhL42JKcXTk3VvhxtLGOhddpk1X4GWk2Whvdv96HrS+TL5ctkA41adNm5qu0JKeN/GMuV3TJo03e6I6zbU64MdqZfGWJ4mj9lH2FV6ZojrdPB3zItlmjOlJbr6uw5PoCkR1FNQQfivD4i4Anq5SDzwN6ACSWr3Rbkw1gTmgGskV7ZPDREpvD+gzgo0FUDESSDEnOCRtf+IEqJfKj7FdK9AeGkweSUSBzjk5+CAKqG+VJ8+H0DT//NVPO80N5CczZ2tohyANubD4LAI653q+td7tGAB2pvNSojsEu1zKWUlcb6CHg8RcBTx5lBBmfnJ3UJS7E5ydXtAdAfAk74pOzEXwA7xwftZUnpPjAj6dfvV0CCJh2k0IGET3jjRM5NSl5QMZ+DH0JO2h9OvpW2yTreDvx1mJjPJn6zl2e83GRubD0fKAM/opEdZztLb/ec4ONwS7XMpgn4CTqXe3Khhyg9qAj9ekT1TH6yApGNYIdUjYR8GRVhYWXpQNmkNGWl7Lk7GSJ9ggf/IQst/WN+KQsdSn38cka9dHycqzw45m/E9al5PBoc0xqe32M8IsE6eN09SnsdQBTG6VCRY6Vq9JkPfGrf6yqKzM85QUa0T4D2Fj684Ebq88MgGOu94OcRJ0P5Gj+awE6APyWr+T6jFEdo11e2KnRshZFePxFwJNH0Q35ZFkvRc+S1wN4R3ucl7Dzekt+T+hTKjdEfAAoV5ilgU84DmlicuTl5IIfbQnLde8e09j08eljtPqBPwRF3VplgyHbWLTG3pEW3+Wwwqr1j9gM/fklMbuNsoANYIEbi30anJhtsvnI1F6PSNhAxztSVDvQUfym9Zt3Cctgr6hOsAOEH0Pxh4cODBHwZJX8xW5LgRhu75PXA+SK9ij9ylAhwr/RkpYP+CRgJoKcSnww2Za7fKI+YRsobfLAT+jHDS95AMjkx+gL9pOb6w7teWEobp9hUssASM2g7NEdj88zzaQEsLH2kwNwzDY1gBytH3ekyAwFaffSUfyaQEcrd0Z1pP5TISYn7DRCZIeLIjz+IuDJIw4bMvQASTixQY9U5nrchG4HeER75GUuub2+zCXaReU+4JNxuQvQTuQ54cdkq/jRoz/wACCYAaRwkrLjxmN5YSh2kMwdcsm5jNZMynECKXqZOlAS2AB+cGPxWyrgAE7ISdjbIEdrZ4vmKHU+fjOAjurb3H/uJayUNv45O7UFH1K6CHjySoceqcw3cmOFGSCZ0By9t97QUK+3JFhkiviEldK7uNwr6qO0dkdlElODNoEoAMTU6IVpCSfRl+Hk7wtBJtCwwoT8Oeq++12dSC5cYGT+0zicJfey0X/M5U509mzngtI0P1VLZDbaeYBSmYCj9VkYcvT+SgCdtIiOYpMn+iO/d7VR6lL6q7IowuMvAp7M0r7UadADOCM3xuiQ3iaq91rmkuqB9IgPAONVXWFbvX9hlBr1UfoWbaQ+NbBy3YhQj/7I9/ox2ku7a+tP71PYJUrM/kJb+6TmWn5KmwpTT8jcT84HHDf01FbgPOH7uRVKZnacyOp2v54SISdRb4McID03x+C/lIiObGMdQw7bPJEgF+zUCHoIePxFwJNHhiiNDXoAWJehvJauAP9lLiT7SIv4lLXcBahRnwT8WPJ9Ev7hsRzliv4If2qTQstXBn82n7F9PhiCuSuznwLP7ckLS9VWkX3yjvCk2aWcqDInM3vCjdE2D+AY2hW7gsscSUnUWWAm6b8E0NHG4hvV8bJtItghZRMBT1aZvsgy9ADZk5mBBABljfYAsPcBLSLDkIj4AMgPPoA96gPY831EO+mj1GFBz/tJi/7AD4CMScwWULEBim1Kc+FMGgy5+vPt30eFwKKaKrBT/jchTDfMeiNCZ5tqLHdljeIYxuENOYA9OqK3rRfoJPw4oMVmmwWQGgh2KMLjLwKePEqBldRkZsB9vx6pDeCO4Djze4A4F0i3yRrxgbbsZCII8U6ts+X7JMdhWIpKuRrLeDWSDkBA4jYCpnbWy7mZOVnYlceTeqNAJxXxv7vDBtrJJGtysmNOrvbcV+rNCDOcXEpJZHaCUDGwsdqmwI2xXcblMRfgGOuLQo7ermzQsdlnaGcfhyfs1Ojmg4wFYAUP2qLtm0UNGthuAmX5skfl1tCw3N7wPmAsbluR2jrslX4M9opPhnjCkW0q8SvZ3jCx6f44i5nGX1HrEmMRbbW+eD+GscQ2ST+oMPWltRPtTS+brWk80ctkn9qPR592f+Zx5Hll6TfPy/W5ZX5l+JyM342Mn3uezy3Td0r/nlaYV9vEZ2qy0V6JYy/jsek+BqU60xximHvUviQbw5gSNr72XKb3WrtkPWs42KmXduzYgSuuuAITJ07EsGHDsNdee+Hqq69GpdKooeNQFOHJqgozLhkpERo90iPVZ8nR0d8bl7ks9ko/3F7uC0ja8WPUtKzkE/UxtFN+uUkbrmWvxHikYcnyuhzdspxlnJC0ZGjhI1lkHI/axjHhBeZ+fPq0DaSsqInPklsZKjfKU3K/Kftf6nKXR/6Ntb1hnK4oTlhvcOSbl2Po0xbNAWBfttL8+kR0rHa634JRHWs/hh+w1nHUGHYqCArfeDBr+2uvvRa33HIL7rrrLuy777743e9+h9NPPx2dnZ244IILCo2lmiLgySNLro4CPQC88nqA1BwdK6BkWeaygZLJTj5etbwd9eou3YdUlwF+AKjLcEBy6Ssl98fYJ5IABFjOSVkhyJLIbBub2n/6hJjlJoOlTa8lgpOXSuwr07g9gC7Vn4tns8CNxVdZgBPa2KHAWJ8FcrR632WrRL9ZQcfRxsve0DZ1CUsu97KtTbSjzByeLVu2KOUdHR3o6OhI2D/55JP453/+Z5xwwgkAgA9/+MP48Y9/jN/97neFxlFt0ZJWVpm+xF4HlXSgiDCw5SB3+bO19VjmsoWurXYAbCFswB2qdi55yX45L7EC4XXhIyXMr40tdakDMC8xVBzLFzZfjnEWWvLx8Oe/LFbjV6lj9/y8PD+ztL+js63lO2Pz6f0d8Pnugn+uJS1XGfo11stzgVwPWMeWsJPnJJedpY2XvaOtMnauBoedsjVhwgR0dnaK1+LFi412RxxxBH7zm9/glVdeAQD8/ve/x6pVq3D88cfXcriZRRGePGIVIGhLRm8AuKIzmZe4TD4Mbb3bA9rzqSxtTHbSsazOXo6oD2C4xFxxhMTVXkDm6E/oN/kLx5h/bPgJHDDEn61qbE/gtfxaNyZI+/qUxyOcpUj5DnjY+/RrNcjRAUtzWkyZI1Ke9ql+XcsWliqrT8tnZI7ymOwMhWlRHJMvzcYVyQEMgOPwbQUKIOUKMBtcePh2+fK9Csvl02Qvg06Vv/txN+UlLW/YsAGjRo0S5aboDgBccskl6O3txd5774329nb09/fjmmuuwec///lC46i2CHjyikMPYAQZ63sLJGUGHw2CvNprY7K2AYxjE7byCVk+qFPgx2vZC1AnyyA5CeoApOf/JMapukvImrfiyLWxTmW2pTHZxAVEyphSzZR+q7EcpcyjBSfwqi2XZfTrNY60PIyU6lLgxtKPD+AY7YwAVQByDPW1BB2n/yKg1ESwE3Zf3pLWqFGjFOCx6b777sOyZctwzz33YN9998W6deswf/58dHd347TTTis0lmqKgCerlC99Tuhx2HsnJgNW8ElLVE5CiAF8TO2gQZIGJqXCjxir1geQBDB9EjYAkHHMkU97jo7tp3oOEJL6Sz2ZWvKGbMoMRz4Sn3XJfoHyx4oc4/RJLM0LNYDzhJcFbkL7nIBj8mmwqSrkmOzzgI6rnW+EpwVhJ+yu9pelX3TRRbj00ktx8sknAwCmTJmC119/HYsXLybgaTkp8FEd6AE8ozV82xYtArx9eLXTbIV9ifAT+kzamGFFLTQCULQPvlEgV7QkLwjFbe31vO9MV3lkhCOX1GhOOT7TVCpQZb06xtM8PYG5ynAD5AccoBzIMflxgY4DNlJt80R09O0iUR2XL/7elq/j8tlCev/999HWpqYAt7e302XpLSsFNnjmW1sSYoSN5b0tDwjlgY/Th94OsOf5WNoWgR8AyrO8Yp+ajY1MEiXmSSaxDAYYc4HCvuy/dly/g9KuvrLmCqlOsuXi9PO/d4Y2FjldeCzDOVXNyT+Ha2/QSvm17o7yuNr5g43VPi/c2OyqGMnxsveBFN2uDB95ozpAQ8AOK2FJK2uE58QTT8Q111yDPfbYA/vuuy+ee+453HDDDfjSl75UaBzVFgFPVsn34QHM0R4ZYhI2jmgPb5NnmQrati886e20befyUVH44W1c0R/hVy3yWgKT+i0SCVLa2OYxjxwar3vcpESJjD6B8iMy+vxX9gRehfNB9gRmvwbpEZ609iXAja0fi60P5OSJ4oS+SwSdsiJBZS5fuXw3GOwA4Z+o6Cpa1uY33XQTrrzySpxzzjnYtGkTuru7cdZZZ+Eb3/hG7jF87GMfy2QfBAEeeugh7Lbbbt5tCHjyyAk0nktcgBFMbBEi3/vpOPtCfvBJtOVjMLXXxiza6PBjapOI/iB5NGcBICB5NBsASIzRFpHNC0JRf0BJQKT4rdJyFlAVILGp9DyhjLO/V/95oYYrK9zY+iwAOECDQE7W9mWAjm7rE9VxtvGAnaIU0sAaOXIklixZgiVLlpTmc926dVi4cCE+9KEPpdoyxvCd73wH27Zty9QHAU8RWYHGAT1AtmiPVucNLFngJSVqkwoyentHf6KNAUIS/QLJ6A+QnEh8AUjsT7LYBkFivDlASLT1mfc8IkSxT/6m4IQqLa9V7QqqrCrxJJFpnzxt84JNaltbVS0Ax9J/KrQA9QMdfTuLnyJLWEDDwU4FQaYbldp8NIIuuugijBs3zsv2+uuvz+yfgCerTAePD/QAfktcQGq0B3Asc+m2ZUVtUtoLH2nwZGoDJKM/JqgxRX9gsTXN6TkgSB+v6s8BQkAqDAkfgH9EJQMYmfuTNxqFcuwqDGIZ26cCDeD+m/v4KANuXPbNDDk+7csGHX27iWAn7K41Hh7a09ODXXbZxdv+pZdeQnd3d6Y+CHjyKA1MZOgB0qM9LqgwwVJU50xKtvVh2c4MLkbIcPgA1Ce3G9qIdmnRH15sSEQ2LoGJvpLFABzJxu5JwJYgLfwaxmf0keV+50yCpBxSPoP6z3FmlXS+8IIXWZ4XmOQGGlFvN6ga3AB+gGNq73WPn2yQk9lHkchQ1iuwTO1883UUfyBl0J577pnJfsKECZn7qOujJR5//HGceOKJ6O7uRhAE+MlPfqLUM8Zw1VVXobu7G8OGDcP06dPx4osvKjbbtm3DvHnzMHbsWIwYMQKzZs3Cm2++qdhs3rwZc+fOFbfLnjt3Lt5+++18g5a/xC7CZ5aDRb7NvO4j0U7aNrWTbF23kXf6dfhK9ZfFR5qfyE5uF98BVXvpfcrtK8mX0VYZa/JlbaNPaLaXYV+M+6Z/Lq6X4bPN+lLkGn89X5pK2dcSP9/Uz0/U278/7kdaWNr4frdt4zPsm7V9yueS2EfbdpoPvV/bdoo/pX9hy+xzpmnc1naeUR2bvyqL33iw6KuRtHz5cqxatUps/+u//isOOOAAzJkzB5s3b87tt67A895772H//ffHzTffbKy/7rrrcMMNN+Dmm2/GM888g66uLhxzzDF45513hM38+fPx4IMP4t5778WqVavw7rvvYubMmejv7xc2c+bMwbp167B8+XIsX74c69atw9y5c/MPPMsBJt5XkAAf2c51sPgexDBMAPIvIdvkZJtsbP5MPj18OOHHo20eAAIsJwmTvdJvDhDyORlKJplP3L5gZPpsM/bZSC9FeT6DjLDo9Td0fe88vkvOtryd7/fWNl7D/hp9mD5bw+dlbevypflJ+PDdzurPd351ttPmbJd/Wfp2leWajrK8GkkXXXSReJDpCy+8gIULF+L444/Ha6+9hgULFuT2W9clreOOOw7HHXecsY4xhiVLluDyyy/HZz7zGQDAXXfdhfHjx+Oee+7BWWedhd7eXtx+++24++67cfTRRwMAli1bhgkTJuCRRx7Bscceiz/84Q9Yvnw5nnrqKUybNg0AcNttt+HQQw/Fyy+/jI985CP5Bs+YOQ8HcObeZMrtUdpp246lLkDLzfHIq0nrT55cUhOVeTv9KLItYSWWvmBsq49DtDcdrI58HeMyAGBfDlP6t7T1SSTOkq8jfZ0SJ/0UKUtenss0zaisn4uiLE09+ilyc0LAsjSV1s709bbZm8otfRp9+JzU03JzfPyYANflM2HvqHe19c3V0W1dPhuNIppIPT09+OhHPwoAuP/++zFz5kwsWrQIzz77bKEHlDbs09J7enqwceNGzJgxQ5R1dHTgyCOPxOrVqwEAa9euxfbt2xWb7u5uTJ48Wdg8+eST6OzsFLADAIcccgg6OzuFjUnbtm3Dli1blBeAfL8UEraGaI/haepe23kiPlkiNKZfnvqvPtOvadPPB0OZ8Reojz9Le2sUSLzsP29MSwbi13XKz6PSn+hdYY59cL+CSv2jMjWJ/OT8fJzfg2r9bfN+vxzfZft33+LHM+rldfxyaf5yRYRc49TGmPApxsGyLV/pbUWdI6qTsHX41NtVUTxpueirkTRkyBC8//77AIBHHnlEnONHjx4dn4tzqGGTljdu3AgAGD9+vFI+fvx4vP7668JmyJAh2HnnnRM2vP3GjRuNl7mNGzdO2Ji0ePFifOtb3zJXMmaP7sjbrggOACXaw+1dl7C7trNEfAB3hCatT4Nfb99F/dl8WnwkfOlVaZEZw+Xxil/bWIzjspsIf0WuolK+W9maNr1ynmCyXbruZ2yN1vj4cX2NbO1s5UUiOBn85o4IJWAiaVIooqNvp7b1BJ00vzWEnbC71rhKS9bhhx+OBQsW4PDDD8eaNWtw3333AQBeeeUV7L777rn9NmyEhyvQrkhhjCXKdOk2Jvs0P5dddhl6e3vFa8OGDboD9b3vgZWwdUR7bL7z/tKB4ZcSkCsvx1Rm/HXnmatj/EVs+uWp+/TOyckYCXL5lP26frWn+TCOM9tLkU8/eV9FVc2xaeOr2ucn91Hk7y7qDS+xD67cIou/LBEc3Y+rTPet+fTyJ8s2bsN47W1Y9nlS2R+5LkNUR6837ZtoV5v15FZMWv7Xf/1XDB48GP/+7/+OpUuXirsp/+pXv8KnP/3p3H4bNsLT1dUFIIzQ7LrrrqJ806ZNIurT1dWFvr4+bN68WYnybNq0CYcddpiw+etf/5rw/7e//S0RPZLV0dGBjo4O9yAZs0d3+Be/jGhPWl++/Un1zkiK/ugM2a98QJcd+cngU/FtmldckZc8kSDR1uFX958y3zHT5+yjKtwwMHW+KwN6UlSdJ7Pnc5oapcniP8XEGrlJ858lguPyZSr3ibbY2pvsPPrwihRlieh4tdcG4QSjDODT4A/RbGTt2LEDjz76KG699Vbl3A8AN954YyHfDRvhmThxIrq6urBixQpR1tfXh5UrVwqYmTp1KgYPHqzYvPXWW1i/fr2wOfTQQ9Hb24s1a9YIm6effhq9vb3CJpP0L3KRAy7xKyRntCfPLyHJppSojIf/zFEaU5n+S9v261X3XyASpP7SdLxc/k19OaIExoiBr3+PvnVljSxV42VVifub+TP39e/xvUj/bjn8O77PmSNBPn0YfFv/JnqZyc6jD6fv0iPfhqhOWn/6ftnqagw7RQ4Pj6mh5ho0aBC++tWvoq+vr3zfpXvMoHfffRevvvqq2O7p6cG6deswevRo7LHHHpg/fz4WLVqESZMmYdKkSVi0aBGGDx+OOXPmAAA6OztxxhlnYOHChRgzZgxGjx6NCy+8EFOmTBFXbe2zzz749Kc/jTPPPBM/+MEPAABf+cpXMHPmzPxXaPEvdFvEi/zbUlK+jfGGhSZ7nz55mXzwWvzok5r31Vh6GS83lHlHaRw3ELQenRb/1j7S+vLwq/j3mTRsV4+5mnjcwNBXiSfTN4G8oy0+yjOzezZJ+4549e/Y11yRIFebIlGcLGW+/STAwcMmbdvow/GjtXAEybE0ViWFwFI0h6ekwZSkadOm4bnnnst8M8I01RV4fve73+GTn/yk2ObX15922mm48847cfHFF2Pr1q0455xzsHnzZkybNg0PP/wwRo4cKdrceOONGDRoEGbPno2tW7fiqKOOwp133on29nZh86Mf/Qjnn3++yPSeNWuW9d4/mVSpxNADhN+atGUn2+XrRvsU8OFtADv4mMp8/CCelDInI9vKLbaFEpVt/rU65/KVC4RsfuV+Lf6NfflOLEWSl4WP5CRYKjzUW0Vn6RzNvaAGKAQ2qf3krSuaxGwrLxNygHToMJV5+cmwfOXThwJKKb5JmXTOOedg4cKFePPNNzF16lSMGDFCqd9vv/1y+Q0Yo7+Mj7Zs2YLOzk4cvcsZGNSu5fa0aSuDpmRovUzfbkupB6Dk+Jja+PRjK/PxBZgfa2BaGLUlhGcstz5GwbUY60pqT0t493lsg+9CcIZHQBR5XETYV7HmLaGCM5k3zIj+POw9ADO131oAjstXFiAaaKADWGFnR6UPj/ztdvT29mLUqFHJcRYUPyf997svQ/vwoYV89b//AV6du7hqY82qNv2cCiAIAvCLjeQbC2dRwyYtN7QSEZOUJS5elhbtAezLXED1Ij6+vuARjcmRjOyyNy6z6X2m9W3r36O/RL+2vvUxuPrSx+To16YEIFXzZ0vZMFXDn1iZIYYra7sywCat35xRo8yAY6urBeT49p0HdEztqgQ7tRRD8UOq0aIePT09VfFLwFNECWjxWOIC3DBSBHxM7XjbtCUmXq5PAG3mXByg4FKULRfHNTaYJ1Kvpam0ZSnXROWRwyPG4btklJY35JLneIpIAaoqdlXt/QCQ/3POuPxXSg6Pj02t8nyKAo7NR17IMZX55Oj4tMsKOkD2C1hI3io7d4erYa/SaljlIX6fg8nngEy0qyQPbv3qAlNbvu07Dps/ydbraimbD9vYXOWOvq33GfK9Ysv2uaTY2a7C8R6Ta5y+4/F5eShtX8p6eaka+5vjs8+0L0W+V2njdIzH6T+tXK+zjcPwmaT64POI17zmMV8ZfRnmQ692GbcrlWRyclqbKqoV77QMAHfffTcOP/xwdHd3i5sNL1myBD/96U9z+yTgyaO0A1Q/IHzaGP34ThA5wSetLMuEpfnIdCm6w0+mE4al/8wQZPKd9aRlmPByAYAvGPmAks+YG/HlUkmfT+a/TZYx+9h4jDPzeGx1rna28aSNwbpfnnOGqyzVXwHQSesv0X+Oeb3aYiW9GkhLly7FggULcPzxx+Ptt98WOTs77bQTlixZktsvAU9emb7UPgeHzwGSZdJQyjKCj8+EZZwMWXH4AfyjLrY+0iZ2xzgyR13SxpDlROc4mZcWIckLAs32sqjw55jx7+ZtmwNsnHDh873zrfMYj9WX4scwP6SNJ60sL+jwtj59pvrxgJ16qIzoToNFeG666SbcdtttuPzyy5Urrg866CC88MILuf1SDk8R8S+4Mxk5Okj03B5TO7lMPnj0y8mBlHvyyD/JHHk+1vaGMp8x2cYl2ZtOLrkuRbeN16dOsklbVknND+LyeaaW1ncme0t772Whgaqin0/W9mnfk0hef7c0myL1KbCYyZ8pj8ZlbwNGH7+m/BxT+1LzhFJAx9a/7XMhpaqnpwcHHnhgoryjowPvvfdebr8EPFlVYQBY+mMfgHLAx+ovKku5qiqR4Cy39WqfAX58fBva6BOs15VYKT5TIcnTxnVi8r5yC0jGUrOcSE2XrJcFOkUvh6+WqglyRXx7Ag1XKWDjY5NWXybgAOVAjq08byKytW2BsrywU0PZgo5ZfTSSJk6ciHXr1iWSl3/1q1/hox/9aG6/BDx5ZbppIOCO9gBIXMlls7OV6X1kBR/ADD9pUZ885bboj95Ga2cFIMAeBTL51MdTxMZg5w1DgP+J0rTIXDAK5FSjzXRZVObYM4IMV6YIm69tUbgB8gFOmu9qQo7Nvy/omNr79u8DOt7tan88teLT0i+66CKce+65+OCDD8AYw5o1a/DjH/8Yixcvxg9/+MPcfgl4ikiHHqD60R6rT0/wAfJFfWxjc5Xbxqj3kdIuEwABfvfCyRoNctkZbH1OhMabDWY98bqy8JoZZooqJ8DIyrVcWDYAFYQboAqA42pX2nJYgYiOzbbGUR1mW34jper000/Hjh07cPHFF+P999/HnDlzsNtuu+G73/0uTj755Nx+CXgyKvEltkEP0Hjgk/CbEvXx9mMpd9W5oj96O62tMw8ISIcgk3/TGDMATuqJyQA3WU6o1jsxV2tOreXlDDU8LxTOecravmwAKgI3aX3kARxXXRmQY/NTC9DxbVtv2Ckj6bjBIjwAcOaZZ+LMM8/E3//+d1QqFYwbN66wTwKeHGKsgiBtWSg09ISUjODjU54ZWgrAj+zLtWTkqjNNYK7+5LawT/ReScd57o7seyIrkpxc4E7MPnI+zqJBfpxWPSm7iP9qwY/HZ19KblDZgOOqKwNybH58gcZWnhd0LOOpdWSnFXN4PvWpT+GBBx7ATjvthLFjx4ryLVu24KSTTsJvf/vbXH4JeHIqAT1AxmUlAwz5gk/W8mrAj6+vLHWucaf1afGfGg0C/GHI1qel71R7Vzvftln86WaNNssVUdn7Uu3lLKC2V3Sl5ZaUDTiuPsuAHJv9AAKdVtZjjz2Gvr6+RPkHH3yAJ554IrdfAp4C4l9wI/jkjfYA1QMfPjbAbxkOsMOP7Ev354IYV51PfdalMIOP1GiQ0p/RNOpbd5ATbrKeKNOAppVApiyV8Znk8ZHhHJjpztOp/RYAnLT6MiHH5a+WoJPFry/s1Oo4ZNGrqI8G0PPPPy/ev/TSS9i4caPY7u/vx/Lly7Hbbrvl9k/Ak1WmiEEZ0R5TeS3AxzZGo68c8JPqMyMA6TZpUSCbD0Nfma66ArLBUNpYdLmgpqyJtFEvSZdVi5NGkT5y/Kgv/counyuDqgU4af1XM5qTp7xIVAfwh50aXq3VSldpHXDAAQiCAEEQ4FOf+lSiftiwYbjpppty+yfgySMDzDijPZptqeCj2/uU63W5IjX67VgdS1+y3zSA8YGTPBCkj8PVl8Fn5quuil5tVeaJvuwls0ZRtcZfYGUi8zJhFvtqg42PTWrkKCPguHxmhbAskOOyLxLVoZsNFlJPTw8YY9hrr72wZs0a7LLLLqJuyJAhGDdunHLn5awi4Ckiw9KVMdpjsS0FfHz8ZOojb6TGAUBZ/KaN17feZmebkPQxuXya/KLApehAvpOs75VUzQ42RVRiWkXunKfMuT0lLm1VO/8nz1JVqs8qRnOy+rGMs+Fgp0UOcX6jwYrtb1dQ9CytorKQv/WAsF1lYPvFYluDtoVms/pytbE9M0tvZ/RbgfFZN7pf1687n/1x2WSx08eUdXw+fQDlPCdLjLkKr3qrxvtTyt8jz3chy/fN129ZNqnjcRzbZcwntjrf8rT50dtPxrnd5LcGGkhPS7/xxhvpaek1letATphaZtyywSfPwV0m/KT6rSATAPlO+j42WezKgqG0PlKgiCvrAzC9QcmlakBUDYCrap9Vkb9jWRDta+tj5zPOhI+U47eakFMv0MmyhFVH2An7KunVQLI9LX3nnXemp6XXXK6JI2Fq+UVgsRf+sxygQPrBXi34KRr9SYPCrCcIX7ustnlgqAwoygBIXHlP/s388laZn3nZf/dq2PqMOeEnA+Ck9eEaZ5Y6Z3/VB51MS1hZvo8ko+hp6Y0m/qX2vOw7NanZ0Mbah3xA2fJ8AHuuT1af+gFc9qXiNuhJS4T27cvUZ5ptHntTG8B98rMpa05RmarX1Vv1PFGUkX+Rd/xZgc1XPvvkc+8YH/DL2z5vnSvHwwVTRl/m8lw/VOuiIHoV9dE4oqelN6oYc5/kfMHH0cYKPml1ZcBPWr3PCd7n5G3cN23CcX1maf2Z+nT17bLP28anPVfeE7Bt37OoWX+hVjNptMhnkqdt2WAD+MGNT99FACetPrXvjInIrjrHfjQP7ACtdB8eLnpaeiPLCR3MeBIqBD6mvlIhJDqAdfDxaVsEjoDqARDgD0G2fk19p40jrY2rnW/7LL5kVfOk30oq8wRVSxjK8vctC3B8+i0COWn1eaI5qT6rHNWpOJbrSamip6U3iioVIKjYwSFDtCdskgN8eF9hw2x1rqiP3DbNt0+9dQw5AMjan8dymK1fV/+ucbjG49PO10dWX0X7aSbV4hd1GX3k9VENsAH8x1MUcHxs8kZz0tqWGdFxtXPBTi3VghEeelp6oynrPXGA6oKPqc/U3BvtwHQte/n4z2tTND8nCwgB7nsE2VQ0p6aaN/+rFTQ1m6q1z0X95o3C1QNssvirJuCktc8RzQmbZYzouPqqNehw0dPSvUXAU1QVR7QHqA74WNp6R1+sN78rGP3JY+Mcj0ckyOQvtf8MUSHbWHSl5c5Uawkrq++iKhopamTwKmtsRZYVsy6DVGtJrAzA8bEpAjlp9WVHdFz91Qt2BoDkp6UXFQFPGfLJj8kJPmHTjFGftH59oCQL/Pj04+rLd/mqrNycrCAk2hUAIi6fpOKiJ95qLl81MrAA1R9fKVdz5Tw51hNufO288oGqCDlAbUEHyJdIXaIYK95Vox3W//Vf/4VvfOMbePTRR7Fp06bEnZf/8Y9/5PJLwJNVjNmv4LNFe0S7lEiG5WRYk6iPrR5Ihx/dj09faX36whKQ7Uot2zjS+gCKARFX1hNmnquuGm32anSVnehdJFk1z98u6/jLBBxfu6KQk2aT8hnUFHTS2pWtFszh+cIXvoD//M//xBlnnIHx48cjKOlHHAFPHjnhJWe0BygGPh7ty0k4Tsn7yeKriF2afdkJyq6+RHvPE50PGHEVPRmXcZl6I6uWV6WVddVNLRKZ8/RVS8Dx9VMgmhM2rwLoAHWP6rS6Vq1ahVWrVmH//fcv1S8BT1755sPkyYVJidp4L3c5fJSWa2M68H2WwGz+Mi9DOSaYvDcBzHP5uk/fwk/BE2ctganVVM1LheuWzFylCE8W21oBDlAMctLaV+vKsWqqBZOW9957b2zdurV0vwQ8RVUEfLza+0V9QhcpkR+bnzxRFucSU84okG/fPvZ52wDuCdE3YlLmZekJ31U4aWeBqFqpEe5jUvZJrFBCc4NEeAD/JN0aQU7oZoCBTqSAha+iPhpJ3//+93HppZfiG9/4BiZPnozBgwcr9aNGjcrll4CnLNUKfID8S16yH9+lnVJybDwByOQ3zXdWe1sb37ZFIkRZx2JTNZKSGwEuqq2mSGiuUZQna5syAcfXrtqQ4zOOArlHrFZXbrVgDs9OO+2E3t5efOpTn1LKGWMIgkA8TDSrCHgyilUqQLvLwJHfAxQHH6D8qI/DV+m5OID/MpjNd5r/IkBTNI8HyHbia7Sk5HrfoLARcyBKT2qucZQnT7ssJ+saQ07oqnFBB6gh7LSoTjnlFAwZMgT33HMPJS3XW/zLHBSCFk/wcfnJEPWJXdUJgFy2QDkQ5NNP4cTkkvJ4uMo6mZaVnNyIwJFXNU1oLqmvWsNQNcAmi21ZgOPrqxVBpwVzeNavX4/nnnsOH/nIR0r1S8BTQKxSsUMPUA74ePtJh5/QlUf0J4O/TJGdMiAIcH9Wtn7S+kprm8WHr6+8fk2i5OTyVQ34K8Nn7qu8qnxTw0aFnNBZip8mBB3ROVpuSeuggw7Chg0bCHgaTanRHqB88En1VUX4SfGZCYBM9j5tygYhnz59fOTxl9VvGX0NJNX0figl9lXEV96TbzWv9ioTcnz91ejyeVq+Kl/z5s3DBRdcgIsuughTpkxJJC3vt99+ufwS8JSk0sEHaEz40X2m+C0tqdhreSgnCNn6zNp/Fn9FfBfpi5RN1fpsy/Bb5ERbTbgBMkUcS4Wc0KGHrxYCnRaM8Hzuc58DAHzpS18SZUEQ1D9pmUVfirKSippdpYEP4Bf1yeQvO/yEbksEoLCDZFne3JkiIAT4wZCr/6xjyeu7zP4GomoNhWX2V0uwyduuGoCTxW+N7xeUCjuM1e4714LA09PTUxW/uW++cfvtt2Py5MkYOnQohg4dismTJ+OHP/xhmWPDjh07cMUVV2DixIkYNmwY9tprL1x99dXKczUYY7jqqqvQ3d2NYcOGYfr06XjxxRcVP9u2bcO8efMwduxYjBgxArNmzcKbb76Zb1D8i+xB/94Hhc/6Mn/5+kv1ydSX020l8crk2zf8bHrlbZdlAvR5+cg1lqLjLLO/gfiq9Wfso7K+e0XGkaddxuO70NzhO3anT4/P0tNX6rxe9PvWRPrzn/+ML3zhCxgzZgyGDx+OAw44AGvXri3F95577ul85VUu4LnyyitxwQUX4MQTT8S//du/4d/+7d9w4okn4mtf+xquuOKK3IPRde211+KWW27BzTffjD/84Q+47rrr8L//9//GTTfdJGyuu+463HDDDbj55pvxzDPPoKurC8cccwzeeecdYTN//nw8+OCDuPfee7Fq1Sq8++67mDlzZu6wmJDHF9sLfLgvnwMl70SY6tdzkhGuM0xiuv8M/RQ6oZR5AiwLirKOs1on8oGkeny+ZX9fio6xEJhlO24LzQ3pzsuDHNlfWre+P2DrIX6VVtFXBm3evBmHH344Bg8ejF/96ld46aWXcP3112OnnXbKvRsPPfQQtm/f7m3/y1/+MvPdmAPGsv+Vxo4di5tuugmf//znlfIf//jHmDdvHv7+979ndWnUzJkzMX78eNx+++2i7F/+5V8wfPhw3H333WCMobu7G/Pnz8cll1wCIIzmjB8/Htdeey3OOuss9Pb2YpdddsHdd98t1gX/8pe/YMKECfjlL3+JY4891tj3tm3bsG3bNrG9ZcsWTJgwAZ8a9jkMCoYkG3guLziXunL6BOC/NJPVL5DrkufUZbAS+9I6Lta+bD82Zfl7kRpH1czbKOOEWdRHjqv9Mi1R5ekjyz6VfINE7x+rBu1gffjt1vvQ29ub+87ALm3ZsgWdnZ3Y47pvo23Y0EK+Kls/wBsXX+E91ksvvRT/7//9PzzxxBOF+pXV3t6OjRs3YpdddvGyHzVqFNatW4e99trLu49cOTz9/f046KCDEuVTp07Fjh078rg06ogjjsAtt9yCV155Bf/0T/+E3//+91i1ahWWLFkCIFzn27hxI2bMmCHadHR04Mgjj8Tq1atx1llnYe3atdi+fbti093djcmTJ2P16tVW4Fm8eDG+9a1v+Q+Wf+lTTpReOT4ZfQLwz/eR/Xr71g5oDygxTYJeEJT1yefJjs3l1Ug6LgJFeU+cBErlqNYJp2X/+i/DX85bGWQGnDx9VQNyMvj1TkhusSjrli1blO2Ojg50dHQk7B566CEce+yx+OxnP4uVK1dit912wznnnIMzzzwzd9+MMXzxi1809mfSBx98kLmPXMDzhS98AUuXLsUNN9yglN9666045ZRT8rg06pJLLkFvby/23ntvtLe3o7+/H9dcc42ILG3cuBEAMH78eKXd+PHj8frrrwubIUOGYOedd07Y8PYmXXbZZViwYIHY5hGeVGUEH8ADfrIASpbHOOi+vfvIByW2iTJzUnSOvr0npmrdZyePf5Ma5cqQgaxqn+TK8l/w3ky5wCZvv1n3uRkgp1b3xmLRq6gPIHGO++Y3v4mrrroqYf7aa69h6dKlWLBgAb7+9a9jzZo1OP/889HR0YFTTz011xBOO+20TPannHJK5shZ7qu0br/9djz88MM45JBDAABPPfUUNmzYgFNPPVUBBR2Ksui+++7DsmXLcM8992DffffFunXrMH/+fHR3dysfjn6FGL90zaU0GxvZosLcj5aIO+CDSzfNE/Xx9J0ZgPL0ARSKzOSOBrn6ztC/Nhh3fb0uIacrsqqjevxCL7vPEk6sueEmb/958+iq4D/T5eWNBjsla8OGDQpE2KItlUoFBx10EBYtWgQAOPDAA/Hiiy9i6dKluYHnjjvuyNUui3IBz/r16/Gxj30MAPCf//mfAIBddtkFu+yyC9avXy/sil6qftFFF+HSSy/FySefDACYMmUKXn/9dSxevBinnXYaurq6AIRRnF133VW027Rpk4j6dHV1oa+vD5s3b1aiPJs2bcJhhx2Wb2A+D+DkygE+QJXgB1AnjTz3p8nyN82xFBZ3mzMa5OpfVzWfY1U2oFTrxNwsINUMSwfVHGNJJ9BCYFNkHNUGnBx9tAroBCjhaenR/6NGjfKKmuy666746Ec/qpTts88+uP/++4sNpMrKBTyPPvpo2eMw6v3330ebdlJub28Xl6VPnDgRXV1dWLFiBQ488EAAQF9fH1auXIlrr70WQJhXNHjwYKxYsQKzZ88GALz11ltYv349rrvuumIDrDD/k2aWfBxkjPrI/jP0kRl+9H4y91cwPwclgZBrPLKKJFDXY7krj5oBJOqlWn42VThR1g1uws5z9pljzI0AOkDTRnXy6PDDD8fLL7+slL3yyiuFLhmvhXIBz5133onPfe5zGDZsWNnjUXTiiSfimmuuwR577IF9990Xzz33HG644QZx98UgCDB//nwsWrQIkyZNwqRJk7Bo0SIMHz4cc+bMAQB0dnbijDPOwMKFCzFmzBiMHj0aF154IaZMmYKjjz66+CCzRHuA3OAD1BB+gGzJsWVGgUT/5YBQOJycib4+E1hZD+0EyjnBNkvEpppqNIir4omwMNRwFR1j0Uv4q9xf5rsiNxPo1OHhoV/72tdw2GGHYdGiRZg9ezbWrFmDW2+9FbfeemuxcVRZuYDnsssuw/nnn4/PfvazOOOMM/IvDaXopptuwpVXXolzzjkHmzZtQnd3N8466yx84xvfEDYXX3wxtm7dinPOOQebN2/GtGnT8PDDD2PkyJHC5sYbb8SgQYMwe/ZsbN26FUcddRTuvPNOtLf7JON4yvdhm1w5oKQw/GToK/PTy119Zu0bcE8iJcKQrKpEiVwqE5a4Gu1k30qq8YmtNJjhKmv8tYabnH1WFXKA+oMOV4lJy776+Mc/jgcffBCXXXYZrr76akycOBFLliwp9aKlaijXfXj6+/vxi1/8AnfeeSd+8YtfYOLEiTj99NOVvJpWE7/nwac6Zpvvw2NSnhNajl/ome7tU0J/QmVdIl1mVKIaEBEpd6SoGqrifra0GuQkVTrMyGoEsOGq8WMxcj3fqkqgs4P14bfb/v9Vvw/PnouvQdvQgvfh+eADvH7Z5VUba5l6//33MXz48Fxtc83g7e3tmDVrFh544AFs2LABX/nKV/CjH/0Ie+yxB2bNmoWf/vSnyuMfBqyy3FGYK8cdXvldQL3v6mzqL8+dZcu623Cpd7hl9ldBmR6xYXtVXa79rMer2cdZkmr2/Sh7H8s6Bsu8m7RvszxzX579zPr51iraykp6NZCmT59ufPzT008/jQMOOCC338I/WceNG4fDDz8chx56KNra2vDCCy/gi1/8Iv7bf/tveOyxx4q6bzwxBuS5s2he8Mn5KycX/Oj95r2yoloQVMZdZGt0MswCRzWDpGqqToBRTdX1b1it72qZx1XZj8vI0rToD7wsygw6lezniAIKWDmvRtKoUaOw33774d577wUAVCoVXHXVVfjEJz6BWbNm5fab+z48f/3rX3H33XfjjjvuwGuvvYaTTjoJP//5z3H00Udj69atuOKKK3DaaaeJGwC2nPgXOu9l0kXuHpxhCUifEDIvfxW5KovLNinlWRKr5h2Qs55ISl5WqgX0NNSyXAE1HSDWCv6qEVUoI1pfcFy5frwV6TfP36vZvpMNrIceegi33HILvvzlL+Ohhx7Cn/70J7zxxhv4xS9+Uehio1zAc+KJJ+LXv/41/umf/glnnnkmTj31VIwePVrUDxs2DAsXLsSNN96Ye2BNozzgA8QHVNF7wWQ8uRcGIL3/nOMAUC4IyXJNcmXmC9UZkPKo6UChkVWvCFa1lkrKTEMoYYy5IadI/80IOmUsSTVYhAcAzj77bLz++uu49tprMWjQIDz22GOFL5DKBTzjxo3DypUrceihh1ptdt11V/T09OQeWNOpKPgANYcfoCQA0sdRYDwAqgdCQHUjRGkqcoJsAFhqSTXaslst8j7Kzq8sacyFAKfoOHLnPjXAD4gWBJ7Nmzfjy1/+Mn7zm9/gBz/4AVauXIkZM2bguuuuwznnnJPbby7guf322/Gb3/wGX//617Fp06ZEgvL/+T//B0EQNPxNiKqivOAD1B1+gBIBSB+PcFilB26W+VDNet1N2aVanZgbBawaDUTKUE1vZFilE3GJ+1AYcICBCzktrsmTJ2PixIl47rnnMHHiRJx55pm47777cM455+AXv/gFfvGLX+Tym+sscfXVV2PGjBn4zW9+g7///e/YvHmz8iKheOJa2Vdd5JR+BVgpv8LKTkYGzAmURROn02Tbl2rtYy1U76uominZud5//2p/30vch9LmkcIXVRT4jtU4GdlXrZi0fPbZZ+Pxxx/HxIkTRdnnPvc5/P73v0dfX19uv7kiPEuXLsWdd96JuXPn5u54wEg+QMq6429Zz4AqKQok3JUdDRKOS4g6ZJlgy4wWyarGSY/urOyvZoDOWt7Oo0qfRymRG+GsjB9DBX00IOQoqsOdlqutK6+80li+++67Y8WKFbn95gKevr6+qt1dudHFKszvaenmxvH7IlfLFF36EuPRJoKCJ0/TRFcIgoTjKsOQLt8Ju1pglEXNcBIn1RZkZFX5+1Eq3ADljbfOkMMqDDnu6ZuzM7REDs/zzz/vbbvffvvl6iMX8Hz5y1/GPffcY6WwVheLDqagEGwUyPWRVRb8AKUDEFClaJDSQcqRWs0ISJ7JvhEgiVRcjXRj1RqdWEuHG6DcsZexFFoC6JDy6YADDkAQBAIUA8fc3d/fn6uPXMDzwQcf4NZbb8UjjzyC/fbbD4MHD1bqb7jhhlyDaTaVCj6ho2IDKmPpS1bZScey62qDkOjIYwKqafJxCScNgqZiaiRY8VGNo3hVARvhvMEAByhlyaqeoFNGDk4j5PDIV3U/99xzuPDCC3HRRReJq8GffPJJXH/99bjuuuty95ELeJ5//nlxe+f169crdS4qa1XJX/bS4Cd0lt8XYJ4QqgFBQNVBSHRTjZN9nkm4nt/zZjthk2I1wBJkVYFGdFKNJO0SfZaUl9MQEZ0WWdKSr+r+7Gc/i+9973s4/vjjRdl+++2HCRMm4Morr8RJJ52Uq49cwPPoo4/m6mwgqJSoT+wsfl/WHXLLjgJxVRmERDf1ACLjQDLOEAPwh8CAUAMAjEk1gRrRWZU+g7JhopUgp8X1wgsvKFdocU2cOBEvvfRSbr8UG6+SWIWJV0kO1VdZqvblwDW+RNt0+Wtpl9QXGljGS5ib9bL2ZlKT/k3SvuNV+55X+zOoxlxU4pxZ6nxepjwvO3dekt5gu7XPPvvg29/+Nj744ANRtm3bNnz729/GPvvsk9tv7mdpkfxVatQndhq/L/P5SNVYBjOpRhGhRLeeJ4OaRYqyqFGhx+dv1qhjbzDVFcrFIGr0t6oWPJR8GXlDQo6sFlnSknXLLbfgxBNPxIQJE7D//vsDAH7/+98jCAL8/Oc/z+2XgKeGKi3XJ+lY3S77AZG1giCg9peg24aR8cTTkIBUKxHMONUQEKOr1n+zakJDFe6T0/CQ0+I6+OCD0dPTg2XLluE//uM/wBjD5z73OcyZMwcjRozI7ZeAp07SD6iqAlDYQXn+AfcEVg8YklWHfJkyT2oDGp4aRA0JKT6qJ3zW7Inw1fnblA45tbphYQtGeABg+PDh+MpXvuK0OeGEE/DDH/4Qu+66q5dPAp6sYhWgGis81Yr+xB2o22UDkCzbxFGr5zQ12qXoGVXtk20rAFXTAklRNUo0rZYRkCqCQ1UiOTW+M3OrXJaeR48//ji2bt3qbU/Ak0fVyp8R7qsMP2EnybJqQhBQfxCSleXE0cBwlEcDFhYaVY0CMbrqsaxTA1io2nJVoz+CgkTAU1hl3THZ6r4G8BN3liyrNgQB9Vkey6Jmu08Pqb5qVICxqZ75KjWChKrm5BDoNI0IeMpSlaM+YRfJg7YuEBR2XN1+uXwnqkYAI1nVOukRSJWnZgOTrGqUxNs6AEHVk44bCXJaNIenGiLgqYZqAD9xV1VMfnZ3bC6vFQjpalYwyqpWP0mT/NQoMKOrTiBQs6uqGgl0Ig3kHJ6sIuCptmoIP2F3dYgCqQOw19ULhmRlmRibHY5IzaVGhRiT6nzir+ll4w0IOaR8IuCppWoMP3G3dYoCJQdir2sEGNKVZ1IlSCJxNRPAmNQgJ/q63BOnQfbdW03+Vcurr3/96xg9erS3fQOeZQaIqvGYCO+uWeJVd+mPzqjj51NI+u3x87xI9ddA+Ts24HFXt7mpAfY9l1hJrwbT3XffjcMPPxzd3d14/fXXAQBLlizBT3/6U2Fz2WWXYaeddvL2ScDTCGqAycYEQU0BQw0ySZeqMk629Gp9WLGpSY6Xus83DfRZkFQtXboUCxYswPHHH4+3334b/f39AICddtoJS5Ysye2XgKdR1UAHYt0npixqksmeRMqsJv1eN9T80cCfU14VfXBoGUnPZeumm27Cbbfdhssvvxzt7e2i/KCDDsILL7yQ2y/l8DSDanmX5AyyTVp1yxHKqqyTXoN87qQWUQuddIE65dqkqcU+Y6PKWJJqsD9dT08PDjzwwER5R0cH3nvvvdx+CXgyilUY0J5uV+VBJMsa6GTsmviaBoZMKjp5NtDfiFSiBsJJNVJDQo2sBvlbsAoDo1tI5NbEiROxbt067Lnnnkr5r371K3z0ox/N7ZeAJ4dqevdjXzU4BHH5TpgN87mWqXpNxg34PShdDXKia2Y1PMzoarC/eb0+v1a8D89FF12Ec889Fx988AEYY1izZg1+/OMfY/HixfjhD3+Y2y8BT0E1JPxwNQkEmeQzeTTc592oarATA6n2ajqY0dWg3+GG+FxbcEnr9NNPx44dO3DxxRfj/fffx5w5c7Dbbrvhu9/9Lk4++eTcfgl4SlRDww9Xo90huYCyTDYN+/cgkQqoIU64ZatB4YarJT/zBtSZZ56JM888E3//+99RqVQwbty4wj4JeKqkhrnZn69aCIRMyjpJNfzfi9SSGnAn0waHG66G/ru0YIRH1tixY0vzRcBTIzVF9MekFgchm4pOcE31NyaVqoY+OdZLTQI2sprl79gqOTwHHnggAs+HIz/77LO5+iDgqYPq/ryrMuQzgbU4FLlUj8my6b5DNVKznLiaVk0IMyY17fekRSI8J510UtX7IOBpEDXdEpiP0ibCAQxE1VDTTtikxlaLAI0uOl4aS9/85jer3kfDn3H+/Oc/4wtf+ALGjBmD4cOH44ADDsDatWtFPWMMV111Fbq7uzFs2DBMnz4dL774ouJj27ZtmDdvHsaOHYsRI0Zg1qxZePPNN2u9K5nUEHclrbaa9M6xJFJLaYAcfy07p7KSXgNADQ08mzdvxuGHH47BgwfjV7/6FV566SVcf/31ysPCrrvuOtxwww24+eab8cwzz6CrqwvHHHMM3nnnHWEzf/58PPjgg7j33nuxatUqvPvuu5g5c6Z4PkczqGFuzV4P0eMiSKRsomNmwMyXrfhoiZ133hmjR49OvMaMGYPddtsNRx55JO64447Mfht6Sevaa6/FhAkTlB378Ic/LN4zxrBkyRJcfvnl+MxnPgMAuOuuuzB+/Hjcc889OOuss9Db24vbb78dd999N44++mgAwLJlyzBhwgQ88sgjOPbYY2u6T2WqZe9oXER0N2RSq6iFYaRMtTLMDFR94xvfwDXXXIPjjjsOBx98MBhjeOaZZ7B8+XKce+656OnpwVe/+lXs2LEDZ555prffhgaehx56CMceeyw++9nPYuXKldhtt91wzjnniB3s6enBxo0bMWPGDNGmo6MDRx55JFavXo2zzjoLa9euxfbt2xWb7u5uTJ48GatXr7YCz7Zt27Bt2zaxvWXLlirtZXXUEonR9RABE6ksEbCUKgIbi1okaVnWqlWr8O1vfxtnn322Uv6DH/wADz/8MO6//37st99++N73vpcJeBp6dn7ttdewdOlSTJo0Cb/+9a9x9tln4/zzz8f//b//FwCwceNGAMD48eOVduPHjxd1GzduxJAhQ7DzzjtbbUxavHgxOjs7xWvChAll7lpdZHtqMU0kJSrLUkKeF6lc0d+q4URzVDa14pLWr3/9a7EiI+uoo47Cr3/9awDA8ccfj9deey2T34YGnkqlgo997GNYtGgRDjzwQJx11lk488wzsXTpUsVOv3afMZZ6PX+azWWXXYbe3l7x2rBhQ/4daQIRDDWJqg1UA+1FqptoviHZNHr0aPzsZz9LlP/sZz/D6NGjAQDvvfceRo4cmclvQy9p7brrrokno+6zzz64//77AQBdXV0AwijOrrvuKmw2bdokoj5dXV3o6+vD5s2blSjPpk2bcNhhh1n77ujoQEdHR2n70syiXCESiZRHBDA1UAsuaV155ZX46le/ikcffRQHH3wwgiDAmjVr8Mtf/hK33HILAGDFihU48sgjM/lt6AjP4Ycfjpdfflkpe+WVV8Qj4ydOnIiuri6sWLFC1Pf19WHlypUCZqZOnYrBgwcrNm+99RbWr1/vBB6Sn1yRIfrlRiK1nuiYbzC14GXpZ555JlauXIkRI0bggQcewL//+79j+PDhWLlyJc444wwAwMKFC3Hfffdl8tvQEZ6vfe1rOOyww7Bo0SLMnj0ba9aswa233opbb70VQLiUNX/+fCxatAiTJk3CpEmTsGjRIgwfPhxz5swBAHR2duKMM87AwoULMWbMGIwePRoXXnghpkyZYlwjTBWrABTUyCV62CeJ1NgiSClBfKmUlkwL6fDDD8fhhx9eqs+GBp6Pf/zjePDBB3HZZZfh6quvxsSJE7FkyRKccsopwubiiy/G1q1bcc4552Dz5s2YNm0aHn74YWVt78Ybb8SgQYMwe/ZsbN26FUcddRTuvPNOtLe35xuY/kWmK3NKFz3sk0QqLgKYGqmOcBOg+G/wRpw9K5UKXn31VWzatAmVivr5fuITn8jlM2CM0RHhoS1btqCzsxPT8c8YFAy2GxL8NJUIlEjNIAKXBlQK5Oxg2/EYfore3l6MGjWq9O75OemjX12E9o6hhXz1b/sALy39etXGmlVPPfUU5syZg9dffx06ogRBkPumwQ0d4WlK2Q4CAqGGVLVPJARUA0cEJS2sBl6eapWnpcs6++yzcdBBB+EXv/gFdt11V++nqKeJgKdWMh0wBEEtr0Y5CbY6eDXK50xqETUw4AwE/fGPf8S///u/47//9/9eql8CnnqKIIhUIxEQkEgWNTvctOBl6dOmTcOrr75KwNPyIggikUik6qjZ4camBgOWopo3bx4WLlyIjRs3YsqUKRg8WM2b3W+//XL5JeBpBqUdpAREJBKJFKpVoWYA6V/+5V8AAF/60pdEWRAE4gkJlLQ8kEVARCKRBpIIaoTqnbS8ePFifP3rX8cFF1yAJUuWFBtIpJ6enlL86CLgGQgiICKRSM0mgho/1TGH55lnnsGtt96ae4nJJv40hbJFwEPym1gIikgkUlkimGl6vfvuuzjllFNw22234dvf/nZV+njppZfwxhtvoK+vTymfNWtWLn8EPCQ/+U5QBEYk0sAVgUzNVeaS1pYtW5Ry10O0zz33XJxwwgk4+uijSwee1157Df/zf/5PvPDCCyJ3B4C4H0/eHB46O5HKFasUf5FIpPqJjt3mUokPD50wYQI6OzvFa/HixcYu7733Xjz77LPW+qK64IILMHHiRPz1r3/F8OHD8eKLL+Lxxx/HQQcdhMceeyy3X4rwkBpPRSZOijCRSAQfpFzasGGD8mgJU3Rnw4YNuOCCC/Dwww9j6NBij7Sw6cknn8Rvf/tb7LLLLmhra0NbWxuOOOIILF68GOeffz6ee+65XH4JeEitpWpM9ARRpGqLAIWUU2UuaY0aNSr1WVpr167Fpk2bMHXqVFHW39+Pxx9/HDfffDO2bduW/8Hckr8PfehDAICxY8fiL3/5Cz7ykY9gzz33xMsvv5zbLwEPiZSmep+MCLhqo3r/nUmkPKrxVVpHHXUUXnjhBaXs9NNPx957741LLrmkMOwAwOTJk/H8889jr732wrRp03DddddhyJAhuPXWW7HXXnvl9kvAQyI1uuhETCKRbKox8IwcORKTJ09WykaMGIExY8YkyvPqiiuuwHvvvQcA+Pa3v42ZM2fif/yP/4ExY8bgvvvuy+2XgIdEIpFIJFLD6NhjjxXv99prL7z00kv4xz/+gZ133rnQk9MJeEgkEolEalLV+07LAApdOeWr0aNHF/ZBwEMikUgkUrOqBZ+WXi1RNiSJRCKRSKSWF0V4SCQSiURqUgWMIWDFQjRF2zeLCHhIJBKJRGpW0ZKWt2hJi0QikUgkUsuLIjwkEolEIjWpGuEqrWYRAQ+JRCKRSM0qWtLyFi1pkUgkEolEanlRhIdEIpFIpCYVLWn5i4CHRCKRSKRmFS1peYuAh0QikUikJhVFePxFOTwkEolEIpFaXhThIZFIJBKpWUVLWt4i4CGRSCQSqYk1UJakioqWtEgkEolEIrW8KMJDIpFIJFKzirHwVdTHABABD4lEIpFITSq6SstftKRFIpFIJBKp5UURHhKJRCKRmlV0lZa3CHhIJBKJRGpSBZXwVdTHQFBTLWktXrwYQRBg/vz5oowxhquuugrd3d0YNmwYpk+fjhdffFFpt23bNsybNw9jx47FiBEjMGvWLLz55ps1Hj2JRCKRSKR6qWmA55lnnsGtt96K/fbbTym/7rrrcMMNN+Dmm2/GM888g66uLhxzzDF45513hM38+fPx4IMP4t5778WqVavw7rvvYubMmejv76/1bpBIJBKJVJ5YSa8BoKYAnnfffRennHIKbrvtNuy8886inDGGJUuW4PLLL8dnPvMZTJ48GXfddRfef/993HPPPQCA3t5e3H777bj++utx9NFH48ADD8SyZcvwwgsv4JFHHqnXLpFIJBKJVFj8Kq2ir4GgpgCec889FyeccAKOPvpopbynpwcbN27EjBkzRFlHRweOPPJIrF69GgCwdu1abN++XbHp7u7G5MmThY1J27Ztw5YtW5QXiUQikUgNJX4fnqKvAaCGT1q+99578eyzz+KZZ55J1G3cuBEAMH78eKV8/PjxeP3114XNkCFDlMgQt+HtTVq8eDG+9a1vFR0+iUQikUikBlBDR3g2bNiACy64AMuWLcPQoUOtdkEQKNuMsUSZrjSbyy67DL29veK1YcOGbIMnkUgkEqnKoiUtfzU08KxduxabNm3C1KlTMWjQIAwaNAgrV67E9773PQwaNEhEdvRIzaZNm0RdV1cX+vr6sHnzZquNSR0dHRg1apTyIpFIJBKpoURJy95qaOA56qij8MILL2DdunXiddBBB+GUU07BunXrsNdee6GrqwsrVqwQbfr6+rBy5UocdthhAICpU6di8ODBis1bb72F9evXCxsSiUQikUitrYbO4Rk5ciQmT56slI0YMQJjxowR5fPnz8eiRYswadIkTJo0CYsWLcLw4cMxZ84cAEBnZyfOOOMMLFy4EGPGjMHo0aNx4YUXYsqUKYkkaBKJRCKRmkn0LC1/NTTw+Ojiiy/G1q1bcc4552Dz5s2YNm0aHn74YYwcOVLY3HjjjRg0aBBmz56NrVu34qijjsKdd96J9vb2Oo6cRCKRSKSCoqeleytgbIDsaUFt2bIFnZ2dmI5/xqBgcL2HQyKRSKQG1g62HY/hp+jt7a1KDig/Jx1y/NUYNNh+UY+Pdmz/AE/98htVG2ujqOkjPCQSiUQiDVTRkpa/CHhIJBKJRGpW0dPSvdXQV2mRSCQSiUQilSGK8JBIJBKJ1KSiJS1/EfCQSCQSidSsqrDwVdTHABABD4lEIpFIzSrK4fEW5fCQSCQSiURqeVGEh0QikUikJlWAEnJ4ShlJ44uAh0QikUikZhXdadlbtKRFIpFIJBKp5UURHhKJRCKRmlR0Wbq/CHhIJBKJRGpW0VVa3qIlLRKJRCKRSC0vivCQSCQSidSkChhDUDDpuGj7ZhEBD4lEIpFIzapK9CrqYwCIlrRIJBKJRCK1vCjCQyKRSCRSk4qWtPxFwEMikUgkUrOKrtLyFgEPiUQikUjNKrrTsrcoh4dEIpFIJFLLiyI8JBKJRCI1qehOy/6iCA+JRCKRSM0qvqRV9JVBixcvxsc//nGMHDkS48aNw0knnYSXX365SjtYngh4SCQSiUQieWvlypU499xz8dRTT2HFihXYsWMHZsyYgffee6/eQ3OKlrRIJBKJRGpSBZXwVdRHFi1fvlzZvuOOOzBu3DisXbsWn/jEJ4oNpooi4CGRSCQSqVlV4lVaW7ZsUYo7OjrQ0dGR2ry3txcAMHr06GLjqLJoSYtEIpFIJBImTJiAzs5O8Vq8eHFqG8YYFixYgCOOOAKTJ0+uwSjziyI8JBKJRCI1q0q88eCGDRswatQoUewT3TnvvPPw/PPPY9WqVQUHUX0R8JBIJBKJ1KQq89ESo0aNUoAnTfPmzcNDDz2Exx9/HLvvvnuhMdRCBDwkEolEIpG8xRjDvHnz8OCDD+Kxxx7DxIkT6z0kLxHwkEgkEonUrKrDoyXOPfdc3HPPPfjpT3+KkSNHYuPGjQCAzs5ODBs2rNhYqihKWiaRSCQSqVnFAFQKvjLy0tKlS9Hb24vp06dj1113Fa/77ruvlF2qlijCQyKRSCRSk6rMHB5fsSZ92ChFeEgkEolEIrW8KMJDIpFIJFKziqGEHJ5SRtLwIuAhkUgkEqlZVYek5WYVLWmRSCQSiURqeVGEh0QikUikZlUFQFCCjwGgho7wLF68GB//+McxcuRIjBs3DieddBJefvllxYYxhquuugrd3d0YNmwYpk+fjhdffFGx2bZtG+bNm4exY8dixIgRmDVrFt58881a7gqJRCKRSKWLX6VV9DUQ1NDAs3LlSpx77rl46qmnsGLFCuzYsQMzZszAe++9J2yuu+463HDDDbj55pvxzDPPoKurC8cccwzeeecdYTN//nw8+OCDuPfee7Fq1Sq8++67mDlzJvr7++uxWyQSiUQikWqshl7SWr58ubJ9xx13YNy4cVi7di0+8YlPgDGGJUuW4PLLL8dnPvMZAMBdd92F8ePH45577sFZZ52F3t5e3H777bj77rtx9NFHAwCWLVuGCRMm4JFHHsGxxx5r7Hvbtm3Ytm2b2N6yZUuV9pJEIpFIpJyipGVvNXSER1dvby8AYPTo0QCAnp4ebNy4ETNmzBA2HR0dOPLII7F69WoAwNq1a7F9+3bFpru7G5MnTxY2Ji1evBidnZ3iNWHChGrsEolEIpFI+cWBp+hrAKhpgIcxhgULFuCII47A5MmTAUA8v2P8+PGK7fjx40Xdxo0bMWTIEOy8885WG5Muu+wy9Pb2iteGDRvK3B0SiUQikUg1VEMvack677zz8Pzzz2PVqlWJuiBQU9QZY4kyXWk2HR0d6OjoyDdYEolEIpFqIVrS8lZTRHjmzZuHhx56CI8++ih23313Ud7V1QUAiUjNpk2bRNSnq6sLfX192Lx5s9WGRCKRSKSmVNEHh/LXAFBDAw9jDOeddx4eeOAB/Pa3v8XEiROV+okTJ6KrqwsrVqwQZX19fVi5ciUOO+wwAMDUqVMxePBgxeatt97C+vXrhQ2JRCKRSM0ouizdXw29pHXuuefinnvuwU9/+lOMHDlSRHI6OzsxbNgwBEGA+fPnY9GiRZg0aRImTZqERYsWYfjw4ZgzZ46wPeOMM7Bw4UKMGTMGo0ePxoUXXogpU6aIq7ZIJBKJRCK1thoaeJYuXQoAmD59ulJ+xx134Itf/CIA4OKLL8bWrVtxzjnnYPPmzZg2bRoefvhhjBw5UtjfeOONGDRoEGbPno2tW7fiqKOOwp133on29vZa7QqJRCKRSOWLcni8FTA2QPa0oLZs2YLOzk5Mxz9jUDC43sMhkUgkUgNrB9uOx/BT9Pb2YtSoUaX75+eko//bfAxqL3aBzY7+bXjkP5dUbayNoobO4SGRSCQSiUQqQw29pEUikUgkEskhWtLyFgEPiUQikUhNqzLulDwwgIeWtEgkEolEIrW8KMJDIpFIJFKzipa0vEXAQyKRSCRSs6rCUHhJqjIwgIeWtEgkEolEIrW8KMJDIpFIJFKzilXCV1EfA0AEPCQSiUQiNasoh8dbBDwkEolEIjWrKIfHW5TDQyKRSCQSqeVFER4SiUQikZpVtKTlLQIeEolEIpGaVQwlAE8pI2l40ZIWiUQikUiklhdFeEgkEolEalbRkpa3CHhIJBKJRGpWVSoACt5HpzIw7sNDS1okEolEIpFaXhThIZFIJBKpWUVLWt4i4CGRSCQSqVlFwOMtWtIikUgkEonU8qIID4lEIpFIzSp6tIS3CHhIJBKJRGpSMVYBK/i086Ltm0UEPCQSiUQiNasYKx6hoRweEolEIpFIpNYQRXhIJBKJRGpWsRJyeAZIhIeAh0QikUikZlWlAgQFc3AGSA4PLWmRSCQSiURqeVGEh0QikUikZhUtaXmLgIdEIpFIpCYVq1TACi5pDZTL0mlJi0QikUgkUsuLIjwkEolEIjWraEnLWwQ8JBKJRCI1qyoMCAh4fERLWiQSiUQikVpeFOEhkUgkEqlZxRiAovfhGRgRHgIeEolEIpGaVKzCwAouaTECHhKJRCKRSA0tVkHxCA9dlt5y+v73v4+JEydi6NChmDp1Kp544ol6D4lEIpFIJFINNGCA57777sP8+fNx+eWX47nnnsP/+B//A8cddxzeeOONeg+NRCKRSKRcYhVWymsgaMAAzw033IAzzjgDX/7yl7HPPvtgyZIlmDBhApYuXVrvoZFIJBKJlE+sUs5rAGhA5PD09fVh7dq1uPTSS5XyGTNmYPXq1cY227Ztw7Zt28R2b28vAGAHthe+xxOJRCKRWls7sB1A9ROCyzgn8bG2ugYE8Pz9739Hf38/xo8fr5SPHz8eGzduNLZZvHgxvvWtbyXKV+GXVRkjiUQikVpP77zzDjo7O0v3O2TIEHR1dWHVxnLOSV1dXRgyZEgpvhpVAwJ4uIIgULYZY4kyrssuuwwLFiwQ22+//Tb23HNPvPHGG1X58tZDW7ZswYQJE7BhwwaMGjWq3sMpTbRfzaNW3CegNferFfcJqN5+McbwzjvvoLu7uzSfsoYOHYqenh709fWV4m/IkCEYOnRoKb4aVQMCeMaOHYv29vZENGfTpk2JqA9XR0cHOjo6EuWdnZ0tdbADwKhRo1punwDar2ZSK+4T0Jr71Yr7BFRnv6r943jo0KEtDyllakAkLQ8ZMgRTp07FihUrlPIVK1bgsMMOq9OoSCQSiUQi1UoDIsIDAAsWLMDcuXNx0EEH4dBDD8Wtt96KN954A2effXa9h0YikUgkEqnKGjDA87nPfQ7/9V//hauvvhpvvfUWJk+ejF/+8pfYc889vdp3dHTgm9/8pnGZq1nVivsE0H41k1pxn4DW3K9W3CegdfeLlFTABspDNEgkEolEIg1YDYgcHhKJRCKRSANbBDwkEolEIpFaXgQ8JBKJRCKRWl4EPCQSiUQikVpeBDwe+v73v4+JEydi6NChmDp1Kp544ol6D8mqxYsX4+Mf/zhGjhyJcePG4aSTTsLLL7+s2DDGcNVVV6G7uxvDhg3D9OnT8eKLLyo227Ztw7x58zB27FiMGDECs2bNwptvvlnLXbFq8eLFCIIA8+fPF2XNuk9//vOf8YUvfAFjxozB8OHDccABB2Dt2rWivhn3a8eOHbjiiiswceJEDBs2DHvttReuvvpqVCrxAwqbYb8ef/xxnHjiieju7kYQBPjJT36i1Je1D5s3b8bcuXPR2dmJzs5OzJ07F2+//XbN92n79u245JJLMGXKFIwYMQLd3d049dRT8Ze//KWh9yltv3SdddZZCIIAS5YsUcobcb9IJYuRnLr33nvZ4MGD2W233cZeeukldsEFF7ARI0aw119/vd5DM+rYY49ld9xxB1u/fj1bt24dO+GEE9gee+zB3n33XWHzne98h40cOZLdf//97IUXXmCf+9zn2K677sq2bNkibM4++2y22267sRUrVrBnn32WffKTn2T7778/27FjRz12S2jNmjXswx/+MNtvv/3YBRdcIMqbcZ/+8Y9/sD333JN98YtfZE8//TTr6elhjzzyCHv11VeFTTPu17e//W02ZswY9vOf/5z19PSwf/u3f2Mf+tCH2JIlS4RNM+zXL3/5S3b55Zez+++/nwFgDz74oFJf1j58+tOfZpMnT2arV69mq1evZpMnT2YzZ86s+T69/fbb7Oijj2b33Xcf+4//+A/25JNPsmnTprGpU6cqPhptn9L2S9aDDz7I9t9/f9bd3c1uvPHGht8vUrki4EnRwQcfzM4++2ylbO+992aXXnppnUaUTZs2bWIA2MqVKxljjFUqFdbV1cW+853vCJsPPviAdXZ2sltuuYUxFk58gwcPZvfee6+w+fOf/8za2trY8uXLa7sDkt555x02adIktmLFCnbkkUcK4GnWfbrkkkvYEUccYa1v1v064YQT2Je+9CWl7DOf+Qz7whe+wBhrzv3ST6Jl7cNLL73EALCnnnpK2Dz55JMMAPuP//iPmu6TSWvWrGEAxA+8Rt8nxuz79eabb7LddtuNrV+/nu25554K8DTDfpGKi5a0HOrr68PatWsxY8YMpXzGjBlYvXp1nUaVTb29vQCA0aNHAwB6enqwceNGZZ86Ojpw5JFHin1au3Yttm/frth0d3dj8uTJdd3vc889FyeccAKOPvpopbxZ9+mhhx7CQQcdhM9+9rMYN24cDjzwQNx2222ivln364gjjsBvfvMbvPLKKwCA3//+91i1ahWOP/54AM27X7LK2ocnn3wSnZ2dmDZtmrA55JBD0NnZ2RD72dvbiyAIsNNOOwFo3n2qVCqYO3cuLrroIuy7776J+mbdL1I2DZg7LefR3//+d/T39yceMDp+/PjEg0gbUYwxLFiwAEcccQQmT54MAGLcpn16/fXXhc2QIUOw8847J2zqtd/33nsvnn32WTzzzDOJumbdp9deew1Lly7FggUL8PWvfx1r1qzB+eefj46ODpx66qlNu1+XXHIJent7sffee6O9vR39/f245ppr8PnPfx5A8/69ZJW1Dxs3bsS4ceMS/seNG1f3/fzggw9w6aWXYs6cOeKhms26T9deey0GDRqE888/31jfrPtFyiYCHg8FQaBsM8YSZY2o8847D88//zxWrVqVqMuzT/Xa7w0bNuCCCy7Aww8/7HwycDPtExD+6jzooIOwaNEiAMCBBx6IF198EUuXLsWpp54q7Jptv+677z4sW7YM99xzD/bdd1+sW7cO8+fPR3d3N0477TRh12z7ZVIZ+2Cyr/d+bt++HSeffDIqlQq+//3vp9o38j6tXbsW3/3ud/Hss89m7r+R94uUXbSk5dDYsWPR3t6eoPdNmzYlftk1mubNm4eHHnoIjz76KHbffXdR3tXVBQDOferq6kJfXx82b95staml1q5di02bNmHq1KkYNGgQBg0ahJUrV+J73/seBg0aJMbUTPsEALvuuis++tGPKmX77LMP3njjDQDN+bcCgIsuugiXXnopTj75ZEyZMgVz587F1772NSxevBhA8+6XrLL2oaurC3/9618T/v/2t7/VbT+3b9+O2bNno6enBytWrBDRHaA59+mJJ57Apk2bsMcee4j54/XXX8fChQvx4Q9/GEBz7hcpuwh4HBoyZAimTp2KFStWKOUrVqzAYYcdVqdRucUYw3nnnYcHHngAv/3tbzFx4kSlfuLEiejq6lL2qa+vDytXrhT7NHXqVAwePFixeeutt7B+/fq67PdRRx2FF154AevWrROvgw46CKeccgrWrVuHvfbaq+n2CQAOP/zwxC0DXnnlFfFA22b8WwHA+++/j7Y2dWppb28Xl6U3637JKmsfDj30UPT29mLNmjXC5umnn0Zvb29d9pPDzh//+Ec88sgjGDNmjFLfjPs0d+5cPP/888r80d3djYsuugi//vWvATTnfpFyqNZZ0s0mfln67bffzl566SU2f/58NmLECPanP/2p3kMz6qtf/Srr7Oxkjz32GHvrrbfE6/333xc23/nOd1hnZyd74IEH2AsvvMA+//nPGy+n3X333dkjjzzCnn32WfapT32qIS5L55Kv0mKsOfdpzZo1bNCgQeyaa65hf/zjH9mPfvQjNnz4cLZs2TJh04z7ddppp7HddttNXJb+wAMPsLFjx7KLL75Y2DTDfr3zzjvsueeeY8899xwDwG644Qb23HPPiSuWytqHT3/602y//fZjTz75JHvyySfZlClTqnaps2uftm/fzmbNmsV23313tm7dOmX+2LZtW8PuU9p+maRfpdWo+0UqVwQ8HvrXf/1Xtueee7IhQ4awj33sY+IS70YUAOPrjjvuEDaVSoV985vfZF1dXayjo4N94hOfYC+88ILiZ+vWrey8885jo0ePZsOGDWMzZ85kb7zxRo33xi4deJp1n372s5+xyZMns46ODrb33nuzW2+9Valvxv3asmULu+CCC9gee+zBhg4dyvbaay92+eWXKyfNZtivRx991HgsnXbaaaXuw3/913+xU045hY0cOZKNHDmSnXLKKWzz5s0136eenh7r/PHoo4827D6l7ZdJJuBpxP0ilauAMcZqEUkikUgkEolEqpcoh4dEIpFIJFLLi4CHRCKRSCRSy4uAh0QikUgkUsuLgIdEIpFIJFLLi4CHRCKRSCRSy4uAh0QikUgkUsuLgIdEIpFIJFLLi4CHRCKRSCRSy4uAh0QikUgkUsuLgIdEIpFIJFLLi4CHRCKRSCRSy4uAh0QiKZo+fTrOP/98XHzxxRg9ejS6urpw1VVXAQAee+wxDBkyBE888YSwv/766zF27Fi89dZbov15552H8847DzvttBPGjBmDK664AvTYPhKJVE8R8JBIpITuuusujBgxAk8//TSuu+46XH311VixYgWmT5+O+fPnY+7cuejt7cXvf/97XH755bjtttuw6667Ku0HDRqEp59+Gt/73vdw44034oc//GEd94hEIg100dPSSSSSounTp6O/v1+J4hx88MH41Kc+he985zvo6+vDIYccgkmTJuHFF1/EoYceittuu01pv2nTJrz44osIggAAcOmll+Khhx7CSy+9VPP9IZFIJIAiPCQSyaD99ttP2d51112xadMmAMCQIUOwbNky3H///di6dSuWLFmSaH/IIYcI2AGAQw89FH/84x/R399f1XGTSCSSTQQ8JBIpocGDByvbQRCgUqmI7dWrVwMA/vGPf+Af//hHTcdGIpFIeUTAQyKRMuk///M/8bWvfQ233XYbDjnkEJx66qkKDAHAU089ldieNGkS2tvbazlUEolEEiLgIZFI3urv78fcuXMxY8YMnH766bjjjjuwfv16XH/99Yrdhg0bsGDBArz88sv48Y9/jJtuugkXXHBBnUZNIpFIwKB6D4BEIjWPrrnmGvzpT3/Cz372MwBAV1cXfvjDH2L27Nk45phjcMABBwAATj31VGzduhUHH3ww2tvbMW/ePHzlK1+p48hJJNJAF12lRSKRStX06dNxwAEHGJOZSSQSqV6iJS0SiUQikUgtLwIeEolEIpFILS9a0iKRSCQSidTyoggPiUQikUiklhcBD4lEIpFIpJYXAQ+JRCKRSKSWFwEPiUQikUiklhcBD4lEIpFIpJYXAQ+JRCKRSKSWFwEPiUQikUiklhcBD4lEIpFIpJbX/weOWXjVqMarBwAAAABJRU5ErkJggg==", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "hgrid[\"angle_dx\"].plot()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - " pi_720deg = atan(1.0) / 180.0\n", - " len_lon = 360.0 ; if (G%len_lon > 0.0) len_lon = G%len_lon\n", - " do j=G%jsc,G%jec ; do i=G%isc,G%iec\n", - " do n=1,2 ; do m=1,2\n", - " lonB(m,n) = modulo_around_point(G%geoLonBu(I+m-2,J+n-2), G%geoLonT(i,j), len_lon)\n", - " enddo ; enddo\n", - " lon_scale = cos(pi_720deg*((G%geoLatBu(I-1,J-1) + G%geoLatBu(I,J)) + &\n", - " (G%geoLatBu(I,J-1) + G%geoLatBu(I-1,J)) ) )\n", - " angle = atan2(lon_scale*((lonB(1,2) - lonB(2,1)) + (lonB(2,2) - lonB(1,1))), &\n", - " (G%geoLatBu(I-1,J) - G%geoLatBu(I,J-1)) + &\n", - " (G%geoLatBu(I,J) - G%geoLatBu(I-1,J-1)) )\n", - " G%sin_rot(i,j) = sin(angle) ! angle is the clockwise angle from lat/lon to ocean\n", - " G%cos_rot(i,j) = cos(angle) ! grid (e.g. angle of ocean \"north\" from true north)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - " function modulo_around_point(x, xc, Lx) result(x_mod)\n", - " real, intent(in) :: x !< Value to which to apply modulo arithmetic [A]\n", - " real, intent(in) :: xc !< Center of modulo range [A]\n", - " real, intent(in) :: Lx !< Modulo range width [A]\n", - " real :: x_mod !< x shifted by an integer multiple of Lx to be close to xc [A].\n", - "\n", - " if (Lx > 0.0) then\n", - " x_mod = modulo(x - (xc - 0.5*Lx), Lx) + (xc - 0.5*Lx)\n", - " else\n", - " x_mod = x\n", - " endif\n", - " end function modulo_around_point" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "This is a regional case\n" - ] } ], "source": [ - "# Direct Translation\n", - "pi_720deg = np.arctan(1)/180 # One quarter the conversion factor from degrees to radians\n", - " \n", - "## Check length of longitude\n", - "len_lon = 360.0\n", - "G_len_lon = hgrid.x.max() - hgrid.x.min()\n", - "if G_len_lon != 360:\n", - " print(\"This is a regional case\")\n", - " len_lon = G_len_lon\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [], - "source": [ - "## Iterate it, j=G%jsc,G%jec ; do i=G%isc,G%iec mean we iterate from jsc to jec and isc to iec\n", - "## Then you iterate around it, 1,2 and 1,2\n", - "\n", - "# In this way we wrap each longitude in the correct way even if we are at the seam like 360, I still don't understand it as much\n", - "\n", + "# Set up angle data...\n", + "t_angles = xr.DataArray(\n", + " angles_arr_v2,\n", + " dims=[\"lath\", \"lonh\"],\n", + " coords={\n", + " \"lath\": ocean_geo.lath.values,\n", + " \"lonh\": ocean_geo.lonh.values,\n", + " }\n", + ")\n", "\n", - "def modulo_around_point(x, xc, Lx):\n", - " \"\"\"\n", - " This function calculates the modulo around a point, for use in cases where we are wrapping around the globe at the seam. Return the modulo value of x in an interval [xc-(Lx/2) xc+(Lx/2)]. If Lx<=0, then it returns x without applying modulo arithmetic.\n", - " Parameters\n", - " ----------\n", - " x: float\n", - " Value to which to apply modulo arithmetic\n", - " xc: float\n", - " Center of modulo range\n", - " Lx: float\n", - " Modulo range width\n", - " Returns\n", - " -------\n", - " float\n", - " x shifted by an integer multiple of Lx to be close to xc, \n", - " \"\"\"\n", - " if Lx <= 0:\n", - " return x\n", - " else:\n", - " return ((x - (xc - 0.5*Lx)) % Lx )- Lx/2 + xc\n", - "\n" + "t_angles\n" ] }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 90, "metadata": {}, "outputs": [ { - "name": "stdout", + "name": "stderr", "output_type": "stream", "text": [ - " Size: 5MB\n", - "array([[0. , 0. , 0. , ..., 0. , 0. ,\n", - " 0. ],\n", - " [0. , 0. , 0. , ..., 0. , 0. ,\n", - " 0. ],\n", - " [0. , 0. , 0. , ..., 0. , 0. ,\n", - " 0. ],\n", - " ...,\n", - " [4.43651643, 4.47489525, 4.5132071 , ..., 4.40963338, 4.37648025,\n", - " 4.34327766],\n", - " [4.45746382, 4.49601954, 4.53450787, ..., 4.429975 , 4.39669398,\n", - " 4.36336333],\n", - " [4.47848207, 4.51721524, 4.5558806 , ..., 4.45038282, 4.41697365,\n", - " 4.38351466]])\n", - "Dimensions without coordinates: nyp, nxp\n" + "/glade/work/manishrv/conda-envs/CrocoDashDev/lib/python3.12/site-packages/xgcm/grid_ufunc.py:832: FutureWarning: The return type of `Dataset.dims` will be changed to return a set of dimension names in future, in order to be more consistent with `DataArray.dims`. To access a mapping from dimension names to lengths, please use `Dataset.sizes`.\n", + " out_dim: grid._ds.dims[out_dim] for arg in out_core_dims for out_dim in arg\n" ] } ], "source": [ - "angles_arr_v2 = np.zeros((len(tlon.nyp), len(tlon.nxp)))\n", - "\n", - "# Compute lonB for all points\n", - "lonB = np.zeros((2, 2, len(tlon.nyp), len(tlon.nxp)))\n", - "\n", - "# Vectorized computation of lonB\n", - "for n in np.arange(1,3):\n", - " for m in np.arange(1,3):\n", - " lonB[m-1, n-1] = modulo_around_point(qlon[np.arange((m-2+1),(m-2+len(qlon.nyp))), np.arange((n-2+1),(n-2+len(qlon.nxp)))], tlon, len_lon)\n", - "\n", - "# Compute lon_scale\n", - "lon_scale = np.cos(pi_720deg* ((qlat[0:-1, 0:-1] + qlat[1:, 1:]) + (qlat[1:, 0:-1] + qlat[0:-1, 1:])))\n", - "\n", - "\n", - "\n", - "# Compute angle\n", - "angle = np.arctan2(\n", - " lon_scale * ((lonB[0, 1] - lonB[1, 0]) + (lonB[1, 1] - lonB[0, 0])),\n", - " (qlat[:-1, :-1] - qlat[1:, 1:]) + (qlat[1:, 0:-1] - qlat[0:-1, 1:])\n", - ")\n", - "# Assign angle to angles_arr\n", - "angles_arr_v2 = np.rad2deg(angle) - 90\n", - "# Print the result\n", - "print(angles_arr_v2)" + "# Interpolate....\n", + "angle_ds = xr.Dataset()\n", + "angle_ds[\"angle_dx_rm6_q\"] = grid.interp(t_angles, axis=['X', 'Y'], to=\"outer\", boundary = \"extend\")\n", + "angle_ds[\"angle_dx_rm6_v\"] = grid.interp(t_angles, axis=[ 'Y'], to=\"outer\", boundary = \"extend\")\n", + "angle_ds[\"angle_dx_rm6_u\"] = grid.interp(t_angles, axis=[ 'X'], to=\"outer\", boundary = \"extend\")" ] }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 91, "metadata": {}, "outputs": [ { @@ -342,7 +1552,7 @@ ".xr-sections {\n", " padding-left: 0 !important;\n", " display: grid;\n", - " grid-template-columns: 150px auto auto 1fr 20px 20px;\n", + " grid-template-columns: 150px auto auto 1fr 0 20px 0 20px;\n", "}\n", "\n", ".xr-section-item {\n", @@ -350,7 +1560,8 @@ "}\n", "\n", ".xr-section-item input {\n", - " display: none;\n", + " display: inline-block;\n", + " opacity: 0;\n", "}\n", "\n", ".xr-section-item input + label {\n", @@ -362,6 +1573,10 @@ " color: var(--xr-font-color2);\n", "}\n", "\n", + ".xr-section-item input:focus + label {\n", + " border: 2px solid var(--xr-font-color0);\n", + "}\n", + "\n", ".xr-section-item input:enabled + label:hover {\n", " color: var(--xr-font-color0);\n", "}\n", @@ -624,133 +1839,144 @@ " stroke: currentColor;\n", " fill: currentColor;\n", "}\n", - "
<xarray.DataArray 'y' (nyp: 780, nxp: 740)> Size: 5MB\n",
-       "array([[90.        , 90.        , 90.        , ..., 90.        ,\n",
-       "        90.        , 90.        ],\n",
-       "       [90.        , 90.        , 90.        , ..., 90.        ,\n",
-       "        90.        , 90.        ],\n",
-       "       [90.        , 90.        , 90.        , ..., 90.        ,\n",
-       "        90.        , 90.        ],\n",
+       "
<xarray.Dataset> Size: 14MB\n",
+       "Dimensions:         (latq: 781, lonq: 741, lonh: 740, lath: 780)\n",
+       "Coordinates:\n",
+       "  * latq            (latq) float64 6kB 5.201 5.284 5.367 ... 53.84 53.87 53.91\n",
+       "  * lonq            (lonq) float64 6kB -98.0 -97.92 -97.83 ... -36.42 -36.33\n",
+       "  * lonh            (lonh) float64 6kB -97.96 -97.88 -97.79 ... -36.46 -36.38\n",
+       "  * lath            (lath) float64 6kB 5.243 5.326 5.409 ... 53.82 53.86 53.89\n",
+       "Data variables:\n",
+       "    angle_dx_rm6_q  (latq, lonq) float64 5MB 0.0 0.0 0.0 0.0 ... 4.434 4.4 4.384\n",
+       "    angle_dx_rm6_v  (latq, lonh) float64 5MB 0.0 0.0 0.0 ... 4.45 4.417 4.384\n",
+       "    angle_dx_rm6_u  (lath, lonq) float64 5MB 0.0 0.0 0.0 0.0 ... 4.434 4.4 4.384
"
+       "       [4.43651643, 4.45570584, 4.49405117, ..., 4.39305682, 4.35987896,\n",
+       "        4.34327766],\n",
+       "       [4.45746382, 4.47674168, 4.5152637 , ..., 4.41333449, 4.38002866,\n",
+       "        4.36336333],\n",
+       "       [4.47848207, 4.49784865, 4.53654792, ..., 4.43367824, 4.40024415,\n",
+       "        4.38351466]])
    • latq
      PandasIndex
      PandasIndex(Index([ 5.201175132990646,  5.284159844737953,  5.367133441666669,\n",
+       "        5.450095751278957,  5.533046601195114,  5.615985819155333,\n",
+       "        5.698913233021465,  5.781828670778779,  5.864731960537714,\n",
+       "        5.947622930535634,\n",
+       "       ...\n",
+       "        53.58314957068581,  53.61976530934297,  53.65632971328116,\n",
+       "        53.69284287347758,  53.72930488057105,  53.76571582493504,\n",
+       "       53.802075796656574,  53.83838488558746, 53.874643181222716,\n",
+       "       53.910850772760504],\n",
+       "      dtype='float64', name='latq', length=781))
    • lonq
      PandasIndex
      PandasIndex(Index([              -98.0,  -97.91666666666674,  -97.83333333333348,\n",
+       "                    -97.75,  -97.66666666666674,  -97.58333333333348,\n",
+       "                     -97.5,  -97.41666666666674,  -97.33333333333348,\n",
+       "                    -97.25,\n",
+       "       ...\n",
+       "       -37.083333333333485,               -37.0,  -36.91666666666674,\n",
+       "       -36.833333333333485,              -36.75,  -36.66666666666674,\n",
+       "       -36.583333333333485,               -36.5,  -36.41666666666674,\n",
+       "       -36.333333333333485],\n",
+       "      dtype='float64', name='lonq', length=741))
    • lonh
      PandasIndex
      PandasIndex(Index([ -97.95833333333348,             -97.875,  -97.79166666666674,\n",
+       "        -97.70833333333348,             -97.625,  -97.54166666666674,\n",
+       "        -97.45833333333348,             -97.375,  -97.29166666666674,\n",
+       "        -97.20833333333348,\n",
+       "       ...\n",
+       "                   -37.125,  -37.04166666666674, -36.958333333333485,\n",
+       "                   -36.875,  -36.79166666666674, -36.708333333333485,\n",
+       "                   -36.625,  -36.54166666666674, -36.458333333333485,\n",
+       "                   -36.375],\n",
+       "      dtype='float64', name='lonh', length=740))
    • lath
      PandasIndex
      PandasIndex(Index([ 5.242668867430943,  5.325648043338498,  5.408616018163888,\n",
+       "        5.491572619468121,  5.574517674931223,  5.657451012353994,\n",
+       "        5.740372459659776,  5.823281844896203,  5.906178996236959,\n",
+       "        5.989063741983525,\n",
+       "       ...\n",
+       "       53.564822422351234,  53.60146386256571,  53.63805392248538,\n",
+       "        53.67459269319862, 53.711080265507746,  53.74751672993067,\n",
+       "        53.78390217675452, 53.820236695885875,  53.85652037696807,\n",
+       "        53.89275330944369],\n",
+       "      dtype='float64', name='lath', length=780))
    • " ], "text/plain": [ - " Size: 5MB\n", - "array([[90. , 90. , 90. , ..., 90. ,\n", - " 90. , 90. ],\n", - " [90. , 90. , 90. , ..., 90. ,\n", - " 90. , 90. ],\n", - " [90. , 90. , 90. , ..., 90. ,\n", - " 90. , 90. ],\n", - " ...,\n", - " [94.43651643, 94.47489525, 94.5132071 , ..., 94.40963338,\n", - " 94.37648025, 94.34327766],\n", - " [94.45746382, 94.49601954, 94.53450787, ..., 94.429975 ,\n", - " 94.39669398, 94.36336333],\n", - " [94.47848207, 94.51721524, 94.5558806 , ..., 94.45038282,\n", - " 94.41697365, 94.38351466]])\n", - "Dimensions without coordinates: nyp, nxp" + " Size: 14MB\n", + "Dimensions: (latq: 781, lonq: 741, lonh: 740, lath: 780)\n", + "Coordinates:\n", + " * latq (latq) float64 6kB 5.201 5.284 5.367 ... 53.84 53.87 53.91\n", + " * lonq (lonq) float64 6kB -98.0 -97.92 -97.83 ... -36.42 -36.33\n", + " * lonh (lonh) float64 6kB -97.96 -97.88 -97.79 ... -36.46 -36.38\n", + " * lath (lath) float64 6kB 5.243 5.326 5.409 ... 53.82 53.86 53.89\n", + "Data variables:\n", + " angle_dx_rm6_q (latq, lonq) float64 5MB 0.0 0.0 0.0 0.0 ... 4.434 4.4 4.384\n", + " angle_dx_rm6_v (latq, lonh) float64 5MB 0.0 0.0 0.0 ... 4.45 4.417 4.384\n", + " angle_dx_rm6_u (lath, lonq) float64 5MB 0.0 0.0 0.0 0.0 ... 4.434 4.4 4.384" ] }, - "execution_count": 12, + "execution_count": 91, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "np.rad2deg(angle)" + "angle_ds" ] }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 92, "metadata": {}, "outputs": [], "source": [ - "# Create the new DataArray with the new dimensions\n", - "new_data_array = xr.DataArray(\n", - " angles_arr_v2,\n", - " dims=[\"qy\", \"qx\"],\n", - " coords={\n", - " \"qy\": tlon.nyp.values,\n", - " \"qx\": tlon.nxp.values,\n", - " }\n", - ")\n", - "\n", - "\n", - "\n", - "hgrid[\"angle_dx_mom6\"] = new_data_array\n", - "hgrid[\"angle_dx_mom6\"].attrs[\"_FillValue\"] = np.nan\n", - "hgrid[\"angle_dx_mom6\"].attrs[\"units\"] = \"rad\"\n", - "hgrid[\"angle_dx_mom6\"].attrs[\"description\"] = \"MOM6 calculates angles internally, this field replicates that for rotating boundary conditions. Use this over other angle fields for MOM6 applications\"\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 23, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
    " - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "hgrid[\"angle_dx_mom6\"].plot(vmin = 0)" + "hgrid[\"angle_dx_rm6\"][u_points] = angle_ds[\"angle_dx_rm6_u\"].values\n", + "hgrid[\"angle_dx_rm6\"][v_points] = angle_ds[\"angle_dx_rm6_v\"].values\n", + "hgrid[\"angle_dx_rm6\"][q_points] = angle_ds[\"angle_dx_rm6_q\"].values" ] }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 93, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 26, + "execution_count": 93, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
    " ] @@ -760,17 +1986,17 @@ } ], "source": [ - "hgrid[\"angle_dx\"][kp2::k,kp2::k].plot()" + "hgrid['angle_dx_rm6'].plot()" ] }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 94, "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAq4AAAIOCAYAAAB544/oAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAACtVElEQVR4nO2deXzVVN7Gn3QvhVbWlrIWRAUBxeIgqAPIJoqOywjuqOgLLigCozK8KjoKiojMiODG4o7jKI4LKmVU1AEVGXVYHAdfUUSpCCJlbaE97x/1hrskuVlOlnvzfD+ffKDJyTknuTfJc5/8zu8oQggBQgghhBBCAk6G3x0ghBBCCCHEDBSuhBBCCCEkJaBwJYQQQgghKQGFKyGEEEIISQkoXAkhhBBCSEpA4UoIIYQQQlICCldCCCGEEJISULgSQgghhJCUgMKVEEIIIYSkBJaE68KFC6Eoirrk5eWhpKQE/fv3x7Rp07B169aEfaZMmQJFUWLW1dTUYMyYMWjZsiUyMzNx7LHHAgB+/vlnnH/++WjRogUURcFZZ51l+8DSAUVRcN1110mrb+/evZgyZQreffddaXWmM9988w0URcHChQv97greffddKIpi67Nbv349pkyZgm+++UZ6v7Suby0uu+wyKIqCRo0aYffu3Qnbv/32W2RkZEBRFEyZMiVh+xdffIHLLrsMbdu2RU5ODpo1a4bTTjsNb7zxRkLZyLky+uxOOeUUKIqC9u3bJ2zbs2cPbrvtNhxxxBHIzc1F06ZN0b9/f2zYsCHpcfpJv3790K9fP7+7YYv27dvjsssu87sbhvhxfs1eX2bRe/YGlX79+qFr166a27Zt26Z7v3CK2e+jk/uyV/j1HHPzms6ys9OCBQtw1FFH4cCBA9i6dSs++OAD3HvvvZgxYwaef/55DBw4UC175ZVX4tRTT43Zf+7cuXjkkUfw4IMPory8HA0bNgQA/OlPf8LixYsxf/58dOzYEU2aNHFwaCSevXv34o477gCAlH3AEeusX78ed9xxB/r166cp1LwiOzsbBw8exPPPP49Ro0bFbFuwYAEaNWqEqqqqhP1eeuklXHjhhejQoQNuvfVWHHnkkfjxxx+xYMECnHbaafjDH/6A6dOnJ+zXqFEjzJs3L+HmuXHjRrz77rsoLCxM2Gf37t3o378/fvjhB9xyyy3o3r07du7ciRUrVmDv3r3OTgAhPqP37CWxLF68WPP+QIKBLeHatWtX9OzZU/373HPPxY033oiTTjoJ55xzDjZs2IDi4mIAQOvWrdG6deuY/deuXYv8/PwEN3Ht2rXo2LEjLrroIjvd0mTfvn3Iz8+XVh8hxB45OTk444wzMH/+/BjhKoTAwoULMWLECDz22GMx+/zf//0fLrnkEnTr1g3vvvsuCgoK1G3nnXcerr76atx333047rjjcP7558fsO2LECDz++OPYsGEDOnXqpK6fP38+WrVqhW7dumH9+vUx+/zv//4vvvjiC/z73/9Ghw4d1PVnnnmmlHNAiJ/oPXvjEUJg//79oXt2RvRCjx49/O4KMUBajGvbtm1x//33Y9euXXjkkUfU9fGvOhRFweOPP459+/bFvM5TFAXLli3DF198oa6P2O81NTW46667cNRRRyE3NxfNmzfH5Zdfjp9++immD+3bt8ewYcPw0ksvoUePHsjLy1MdxsrKSowePRqtW7dGTk4OysrKcMcdd+DgwYPq/hFLfcaMGZg5cybKysrQsGFD9O7dGx9++GHCMX/00Uc444wz0LRpU+Tl5aFjx44YN25cTJkNGzbgwgsvRIsWLZCbm4vOnTvjoYcesnRuH3nkEfW1ZZcuXbBo0aKEMsmO75tvvkHz5s0BAHfccYd6ji+77DKsW7cOiqLghRdeUOtbvXo1FEXB0UcfHdPOmWeeifLy8ph1zz//PHr37o2CggI0bNgQQ4YMwaeffprQx08++QRnnnkmmjRpgry8PPTo0QN//etfY8pEvgvvvPMOrr76ajRr1gxNmzbFOeecgx9++MHU+Ur2uXz11Ve4/PLL0alTJzRo0ACtWrXCGWecgTVr1iSt+7LLLtN0LbVe6dXV1eHBBx/Esccei/z8fBx22GE44YQT8Morr6hl9F51mXnN8sknn+D8889H+/btkZ+fj/bt2+OCCy7At99+q5ZZuHAhzjvvPABA//79NV+hL1u2DAMGDEBhYSEaNGiAE088Ef/4xz8S2nv99ddx7LHHIjc3F2VlZZgxY4Zh/7S44oorsGLFCnz55Zcx7X/77be4/PLLE8o/8MAD2Lt3Lx588MEY0Rrh/vvvx2GHHYa77747YdugQYPQpk0bzJ8/X11XV1eHJ554AiNHjkRGRuztb+/evXj88cdx3nnnxYhWK9xxxx3o1asXmjRpgsLCQhx33HGYN28ehBAx5SL3qjfffBPHHXcc8vPzcdRRR8X0NcIHH3yA3r17Iy8vD61atcKtt96Kxx9/HIqiJA3/MHvv1MLM9wuwds0eOHAAN910E0pKStCgQQOcdNJJ+Pjjj5P2JUI6nd94zFxfixYtgqIomD17dsz622+/HZmZmaioqNCtX+/ZG9l23XXX4eGHH0bnzp2Rm5uLJ554AkD9+RkwYAAaNWqEBg0aoE+fPnj99ddj6o58B95++21cddVVaNq0KQoLC3HppZdiz549qKysxPDhw3HYYYehZcuWmDhxIg4cOGD5HJnB7OdppBe07r//+c9/cOqpp6JBgwZo1qwZxowZg127dpnqk9lnTiT04LnnnsPkyZNRWlqKwsJCDBw4MOaeCdT/uJg6dSratWuHvLw89OzZExUVFaZDWmRoE8DcNS2EwGmnnYamTZti06ZN6vq9e/fi6KOPRufOnbFnzx7zjQoLLFiwQAAQq1at0ty+e/dukZmZKQYMGKCuu/3220V0MytXrhSnnXaayM/PFytXrhQrV64UlZWVYuXKlaJHjx6iQ4cO6vqdO3eK2tpaceqpp4qCggJxxx13iIqKCvH444+LVq1aiS5duoi9e/eqdbdr1060bNlSdOjQQcyfP1+888474uOPPxZbtmwRbdq0Ee3atROPPPKIWLZsmfjTn/4kcnNzxWWXXabuv3HjRgFAtG/fXpx66qni5ZdfFi+//LLo1q2baNy4sfjll1/Usm+++abIzs4W3bt3FwsXLhRvv/22mD9/vjj//PPVMuvWrRNFRUWiW7du4sknnxRLly4VEyZMEBkZGWLKlClJzzcA0aZNG9GlSxfx3HPPiVdeeUWceuqpAoB44YUX1HJmjm///v3izTffFADEqFGj1HP81VdfCSGEaNmypfif//kftc577rlH5OfnCwDi+++/F0IIceDAAVFYWChuuukmtdzdd98tFEURV1xxhXjttdfESy+9JHr37i0KCgrEunXr1HJvv/22yMnJESeffLJ4/vnnxZtvvikuu+wyAUAsWLBALRf5jnXo0EGMHTtWvPXWW+Lxxx8XjRs3Fv379096zsx8LsuXLxcTJkwQf/vb38Ty5cvF4sWLxVlnnSXy8/PFf/7zH7Vc5PsQ3b+RI0eKdu3aJbQb/z0XQohLLrlEKIoirrzySvH3v/9dvPHGG+Luu+8Wf/7zn9UyAMTtt9+eUF+7du3EyJEj1b/feecdAUC888476roXXnhB3HbbbWLx4sVi+fLlYtGiRaJv376iefPm4qeffhJCCLF161YxdepUAUA89NBD6ue+detWIYQQTz31lFAURZx11lnipZdeEq+++qoYNmyYyMzMFMuWLVPbWrZsmcjMzBQnnXSSeOmll8QLL7wgjj/+eNG2bduE49Zi5MiRoqCgQNTV1Yl27drFfIdGjBghfvvb34qffvop4XwcccQRori42LDu4cOHCwBiy5YtMefqhRdeELfeeqsoLS0VBw8eFEII8cYbbwhFUcRXX30lTj/99JjP8r333hMAxN133y3GjBkjDjvsMJGdnS3Ky8vFa6+9lvQYhRDisssuE/PmzRMVFRWioqJC/OlPfxL5+fnijjvuiCnXrl070bp1a9GlSxfx5JNPirfeekucd955AoBYvny5Wu7zzz8XeXl5onv37mLRokXilVdeEaeddppo3769ACA2btyolu3bt6/o27ev+reVe6cWZr5fQli7ZkeOHCkURRF/+MMfxNKlS8XMmTNFq1atRGFhYcz3PQznNxor19eYMWNETk6O+hz+xz/+ITIyMsT//u//Grah9eyN3AcAiFatWonu3buLZ599Vrz99tti7dq14t1331Wvgeeff168/PLLYvDgwUJRFLFo0SK17sh3oKysTEyYMEEsXbpU3HvvvSIzM1NccMEF4rjjjhN33XWXqKioEDfffLMAIO6///6k56Vv377i6KOPFgcOHEhYKisrE+4XVj5PPb0Q2Rb9faysrBQtWrQQrVq1EgsWLBBLliwRF110kfr5RN+XtTD7zIncu9q3by8uuugi8frrr4vnnntOtG3bVnTq1Em9jwkhxKRJkwQA8T//8z/izTffFI899pho27ataNmyZcz3VOs55lSbRGP2mt62bZto3bq16NWrl6ipqVH3zc/PF//+978ttSlVuAohRHFxsejcubP6t9YDPfIQiyfyJY3mueeeEwDEiy++GLN+1apVAoCYM2eOuq5du3YiMzNTfPnllzFlR48eLRo2bCi+/fbbmPUzZswQAFSBFfmAu3XrFvMF+fjjjwUA8dxzz6nrOnbsKDp27Cj27duney6GDBkiWrduLXbu3Bmz/rrrrhN5eXni559/1t1XiPqbSX5+vqisrFTXHTx4UBx11FHi8MMPt3x8WsIgwsUXXyw6dOig/j1w4EBx1VVXicaNG4snnnhCCCHEP//5TwFALF26VAghxKZNm0RWVpYYO3ZsTF27du0SJSUlYvjw4eq6o446SvTo0UMcOHAgpuywYcNEy5YtRW1trRDi0HfsmmuuiSk3ffr0GHGih5nPJZ6DBw+Kmpoa0alTJ3HjjTeq650I14gImjx5smHbToSr1nHs3r1bFBQUxIjjF154QXPfPXv2iCZNmogzzjgjZn1tba045phjxG9+8xt1Xa9evURpaWnMea2qqhJNmjSxJFyFqD9XJSUl4sCBA2L79u0iNzdXLFy4UPP7mZeXJ0444QTDuiMPwo8++kgIEStcv/76a6Eoiio8zzvvPNGvXz8hhEgQrpF7TWFhoTjxxBPFK6+8Il577TXRv39/oSiKePPNN5MeZzS1tbXiwIED4s477xRNmzYVdXV16rZ27dqJvLy8mGt23759okmTJmL06NHquvPOO08UFBTECMXa2lrRpUuXpMLKyr3TDHrfL7PX7BdffCEAxFxjQgjxzDPPCACmhGs06XR+rVxf+/fvFz169BBlZWVi/fr1ori4WPTt2zfmmaWH3rMXgCgqKkp4Jp1wwgmiRYsWYteuXeq6gwcPiq5du4rWrVur5zzyHYh/Fpx11lkCgJg5c2bM+mOPPVYcd9xxSfvbt29fAcBwib5fWPk89fRCZFv09/Hmm28WiqKIzz77LKbcoEGDTAnXePSeOZF712mnnRZT/q9//asAIFauXCmEEOLnn38Wubm5YsSIETHlVq5cKQAkFa5OtUkEq9f0Bx98ILKyssS4cePE/PnzBQDx+OOPm2orGunpsETcKxunvPbaazjssMNwxhln4ODBg+py7LHHoqSkJGE0X/fu3XHEEUck1NG/f3+UlpbG1DF06FAAwPLly2PKn3766cjMzIypE4D6iuy///0v/u///g+jRo1CXl6eZr/379+Pf/zjHzj77LPRoEGDmHZPO+007N+/XzP8IJ4BAwao8cIAkJmZiREjRuCrr77C5s2bbR2fXjtff/01Nm7ciP379+ODDz7Aqaeeiv79+6uvn5YtW4bc3FycdNJJAIC33noLBw8exKWXXhrTbl5eHvr27at+Nl999RX+85//qLHL8ediy5YtCa9B4mMK4z8DLcx8LpH2p06dii5duiAnJwdZWVnIycnBhg0b8MUXXyQ9V2aIjHa/9tprpdSnxe7du3HzzTfj8MMPR1ZWFrKystCwYUPs2bPH1HGsWLECP//8M0aOHBnzmdTV1eHUU0/FqlWrsGfPHuzZswerVq3COeecE3NeGzVqhDPOOMNyvy+//HL8+OOPeOONN/DMM88gJydHDWewQ+SeozX6uqysDP369cP8+fOxfft2/P3vf8cVV1yhWU9dXR2A+ljcN954A2eccQZOP/10vPbaa2jZsiX+9Kc/Je3L22+/jYEDB6KoqAiZmZnIzs7Gbbfdhu3btydkXTn22GPRtm1b9e+8vDwcccQRMd/x5cuX45RTTkGzZs3UdRkZGRg+fHjSvli9d8Zj9fuV7Jp95513ACBhDMPw4cORlWVuuEU6nd8IVq+v3Nxc/PWvf8X27dtx3HHHQQiB5557LuaZZYdTTjkFjRs3junXRx99hN///vcxg7gyMzNxySWXYPPmzQn37WHDhsX83blzZwD1z9T49Ub38mg6duyIVatWJSzLli1LKGv189TSC1q88847OProo3HMMcfErL/wwgtNHYPVZ06ya+nDDz9EdXV1wnGdcMIJSQfgytImgPVr+sQTT8Tdd9+NWbNm4eqrr8bFF1+cMFDXDLYGZ+mxZ88ebN++Hd26dZNW548//ohffvkFOTk5mtu3bdsW83fLli0163j11VeRnZ1tqo6mTZvG/J2bmwugPnAbgBq/FD/oLJrt27fj4MGDePDBB/Hggw+aaleLkpIS3XXbt29H69atLR+fFpFMEMuWLUNZWRkOHDiAU045BT/++KP6wF62bBlOPPFENWD/xx9/BAAcf/zxmnVGYggj5SZOnIiJEyea6mOyz0ALM58LAIwfPx4PPfQQbr75ZvTt2xeNGzdGRkYGrrzySsP6rfDTTz8hMzNT8/OTxYUXXoh//OMfuPXWW3H88cejsLAQiqLgtNNOM3Uckc/l97//vW6Zn3/+GYqioK6uzvC7aIV27dphwIABmD9/Pr755hucf/75aNCggeao/bZt22Ljxo2G9UXi1tq0aaO5fdSoUbj88ssxc+ZM5Ofn6x5v5DvXp08fNGrUSF3foEED9O3bFy+//LJhPz7++GMMHjwY/fr1w2OPPabGm7/88su4++67Ez6T+O84UP89jy63ffv2mB+uEbTWxWP13hmP1e9Xsmt2+/btABK/M1lZWZrnIp50O78RduzYYfn6Ovzww3HyySfj9ddfx9VXX6353LNKfB07duyAEEKz7tLSUgCHPtMI8ZmAIudGa/3+/ftN9SsSvxmP1vm1+nmaPW/bt29HWVlZwnqz9z+rzxyz15Kd764sbRLdDyvX9EUXXYRbb70V1dXV+MMf/mCqnXikCtfXX38dtbW1UlMtRQL933zzTc3t0Q8YQNt1adasGbp37645gAM4dBGaJTLIKeJ4atG4cWP1l6me66Z1IcRTWVmpuy7yxZBxfK1bt8YRRxyBZcuWoX379ujZsycOO+wwDBgwANdccw0++ugjfPjhh2rweqRdAPjb3/6Gdu3a6dYdKTdp0iScc845mmWOPPLIpH1MhpnPBQCefvppXHrppZg6dWrM+m3btuGwww4z3DcvLw/V1dUJ6+Mv9ObNm6O2thaVlZWGN8fc3FzN+uIfCPHs3LkTr732Gm6//Xbccsst6vrq6mr8/PPPhvtGiHwuDz74IE444QTNMsXFxThw4AAURTH8LlrliiuuwMUXX4y6ujrMnTtXt9ygQYPw0EMP4cMPP9Ts4969e1FRUYGuXbvqPkTOOeccXHvttbjnnntw1VVX6Y6UjrgaWgghEgZzxbNo0SJkZ2fjtddei3HOkgleI5o2bar+wIjGzHm3eu+MRsb3K57I/aqyshKtWrVS1x88eDDp9x1Ir/MbTePGjS1fX48//jhef/11/OY3v8Hs2bMxYsQI9OrVy1R7esQ/OyPiasuWLQllI4Puop3NIGD18zSbI7dp06aO7n9Onjl6/QGge6xGrqssbRLdD7PXdG1tLS666CI0btwYubm5GDVqFP75z3/q/vjTQ5pw3bRpEyZOnIiioiKMHj1aVrUYNmwYFi1ahNraWtsX5rBhw7BkyRJ07Ngx5lWIXY444gh07NgR8+fPx/jx49VfQ9E0aNAA/fv3x6efforu3btb/mAi/OMf/8CPP/6o/oqqra3F888/j44dO6rOotnjS+ZaDhw4EH/961/Rpk0b9dXOEUccgbZt2+K2227DgQMHYnL0DhkyBFlZWfi///s/nHvuubrtHnnkkejUqRM+//zzhAtXJmY+F6D+ZhW/7fXXX8f333+Pww8/3LCN9u3bY+vWrTGfSU1NDd56662YckOHDsW0adMwd+5c3HnnnYb1/fvf/45Z9/bbb2sm6Y8/BiFEwnE8/vjjqK2tjVmn97mfeOKJOOyww7B+/XrD9Dg5OTn4zW9+g5deegn33XefKhp27dqFV1991bCfepx99tk4++yzUVRUpCuaAeDGG2/E/PnzMXbs2IR0WEC9i79jxw5D8Zufn4/bbrsN7733Hq6++mrdci1btkTv3r3xz3/+E1VVVWoex71792L58uWG/QTqP5OsrKyYV7b79u3DU089ZbifEX379sWSJUuwbds2VSTU1dXFZADRw8m908r3yywRQ+OZZ56JyUzy17/+NSa7i1Gf0uX8RlNQUGDp+lqzZg2uv/56XHrppXjsscfQp08fjBgxAp9++qmU51t0v3r16oWXXnoJM2bMUH/w1dXV4emnn1bNjiDh5PM0on///pg+fTo+//zzmHCBZ5991tT+Tp45WvTq1Qu5ubl4/vnnY8ygDz/8EN9++62hcJWlTQDr1/Ttt9+O999/H0uXLkVBQQF++9vf4g9/+AP+/Oc/W2rXlnBdu3atGhOxdetWvP/++1iwYAEyMzOxePFi1fmSwfnnn49nnnkGp512Gm644Qb85je/QXZ2NjZv3ox33nkHv/vd73D22Wcb1nHnnXeioqICffr0wfXXX48jjzwS+/fvxzfffIMlS5bg4YcfTvp6OZ6HHnoIZ5xxBk444QTceOONaNu2LTZt2oS33noLzzzzDADgz3/+M0466SScfPLJuPrqq9G+fXvs2rULX331FV599VW8/fbbSdtp1qwZTjnlFNx6660oKCjAnDlz8J///CcmJZbZ42vUqBHatWuHv//97xgwYACaNGmCZs2aqV/yAQMGYM6cOdi2bRtmzZql1j9gwAAsWLAAjRs3jvlytm/fHnfeeScmT56Mr7/+GqeeeioaN26MH3/8ER9//DEKCgpUh/aRRx7B0KFDMWTIEFx22WVo1aoVfv75Z3zxxRf417/+5fjGEsHM5zJs2DAsXLgQRx11FLp3747Vq1fjvvvuM/UdGDFiBG677Tacf/75+MMf/oD9+/fjL3/5S8LD/OSTT8Yll1yCu+66Cz/++COGDRuG3NxcfPrpp2jQoAHGjh0LALjkkktw66234rbbbkPfvn2xfv16zJ49G0VFRYb9KCwsxG9/+1vcd9996me4fPlyzJs3L+EXfGTmmUcffRSNGjVCXl4eysrK0LRpUzz44IMYOXIkfv75Z/z+979HixYt8NNPP+Hzzz/HTz/9pArCP/3pTzj11FMxaNAgTJgwAbW1tbj33ntRUFBgy4HLy8vD3/72t6TlOnbsiKeeegoXXXQRjj/+eIwfP16dgGD+/Pl44403MHHiRIwYMcKwnvHjx2P8+PFJ25sxYwb69++PIUOG4Oabb4aiKLj//vuxbdu2pDGup59+OmbOnIkLL7wQ//M//4Pt27djxowZuj+gzDB58mS8+uqrGDBgACZPnoz8/Hw8/PDDauoYIxfYyb3TyvfLLJ07d8bFF1+MWbNmITs7GwMHDsTatWsxY8YMU8ne0+n8xmP2+tqzZw+GDx+OsrIyzJkzBzk5OfjrX/+K4447Dpdffrkj91mLadOmYdCgQejfvz8mTpyInJwczJkzB2vXrsVzzz0ndVYvGTj5PI0YN24c5s+fj9NPPx133XUXiouL8cwzz+A///mPqf2dPHO0aNKkCcaPH49p06ahcePGOPvss7F582bccccdaNmyZdLjlKFNAGvXdEVFBaZNm4Zbb70VAwYMAFD//Zo4cSL69etn+loBYC8dVmTJyckRLVq0EH379hVTp05VU2tE4zSrgBD1aZhmzJghjjnmGJGXlycaNmwojjrqKDF69GixYcMGtVy7du3E6aefrtn3n376SVx//fWirKxMZGdniyZNmojy8nIxefJksXv3biHEodF39913X8L+0Bj9vXLlSjF06FBRVFQkcnNzRceOHRNG123cuFFcccUVolWrViI7O1s0b95c9OnTR9x1112a/Yxv89prrxVz5swRHTt2FNnZ2eKoo44SzzzzjK3jE6I+7UqPHj1Ebm5uwqi/HTt2iIyMDFFQUKCmqxDi0AjBc845R7OfL7/8sujfv78oLCwUubm5ol27duL3v/99TDolIepTlQwfPly0aNFCZGdni5KSEnHKKaeIhx9+WC2jl7nCzKj6CMk+lx07dohRo0aJFi1aiAYNGoiTTjpJvP/++wmjhrVGYwohxJIlS8Sxxx4r8vPzRYcOHcTs2bM1v+e1tbXigQceEF27dhU5OTmiqKhI9O7dW7z66qtqmerqanHTTTeJNm3aiPz8fNG3b1/x2WefmcoqsHnzZnHuueeKxo0bi0aNGolTTz1VrF27NmFfIYSYNWuWKCsrE5mZmQnHtHz5cnH66aeLJk2aiOzsbNGqVStx+umnx6RcE0KIV155RXTv3l3k5OSItm3binvuuUfzuLXQu+ajMcp6sW7dOjFy5EjRunVr9ft96qmnitdffz2hbHRWASPiswpEiHwXGjRoIBo0aCBOOeUU8c9//tOwrgjz588XRx55pMjNzRUdOnQQ06ZNE/PmzdMc0ax1r4r/Dkb606tXL5GbmytKSkrEH/7wB3HvvfcKADEp+rT2NXvv1MLs98vKNVtdXS0mTJggWrRooWaMWLlypeZ3Vot0Or/xmLm+Lr74YtGgQYOYVINCHMoc8sADDxi2YZRV4Nprr9Xc5/333xennHKKKCgoEPn5+eKEE06IuYcJof8diPQ/epS/UT/i0dMEQujfL8x+nkZ6Qev7uH79ejFo0CCRl5cnmjRpIkaNGiX+/ve/m3oumX3m6N27tJ5FdXV14q677hKtW7cWOTk5onv37uK1114TxxxzjDj77LMN942st6tNojFzTf/www+iRYsW4pRTTlEzCEWO4YwzzhCHHXZYzPWbDEUIyWkACCGEuMrgwYPxzTff4L///a/fXUlLeH7Ti7B8nhs3bsRRRx2F22+/HX/84x/97o5rSB2cRQghRC7jx49Hjx490KZNG/z888945plnUFFRgXnz5vndtbSA5ze9CMvn+fnnn+O5555Dnz59UFhYiC+//BLTp09HYWGhrRRTqQSFKyGEBJja2lrcdtttqKyshKIo6NKlC5566ilcfPHFfnctLXDz/NbV1an5gfUwm8OWmCMs10tBQQE++eQTzJs3D7/88guKiorQr18/3H333abSuSWjtrbWMC+/oiiOcwfbhaEChBBCiAtMmTIlJoWgFhs3bkyaNJ4Qr2nfvr3hJBHRkwx5DYVrijFnzhzcd9992LJlC44++mjMmjULJ598st/dIoQQEscPP/yg5jzVw2lKIkLcYM2aNZo5xiM0atRISv51O1C4phDPP/88LrnkEsyZMwcnnngiHnnkETz++ONYv359zNSGhBBCCCHpCIVrCtGrVy8cd9xxMcnWO3fujLPOOgvTpk3zsWeEEEIIIe7DqPAUoaamBqtXr46ZfhGoT/OxYsUKU3XU1dXhhx9+QKNGjQKXOJoQQgixihACu3btQmlpqe0JBpywf/9+1NTUuFJ3Tk5OzPTGpB4K1xRh27ZtqK2tTRgtWFxcrDtfcnV1dUyMyvfff48uXbq42k9CCCHEa7777jvbM1HZZf/+/SjNb4gdsDcNcjJKSkqwceNGitc4KFxTjHinVAih655OmzZNc0Rr+YAXkJnVwJX+EUIIIV5Re3AvVv/jPDRq1MjztmtqarADtViYWYYGkOv27kUdLqvciJqaGgrXOChcU4RmzZohMzMzwV3dunWrbs62SZMmxczPXlVVhTZt2iAruwBZ2QWu9pcQQghxm4hx42f4W0F2JhoocnOaKqIWLhm5KY/3ASHEFjk5OSgvL0dFRUXM+oqKCvTp00dzn9zcXBQWFsYshBBCCCGpCh3XFGL8+PG45JJL0LNnT/Tu3RuPPvooNm3ahDFjxliqR8nIgOJDEDshhBAikyA8y5QsBRmSHV9FcAC1HhSuKcSIESOwfft23HnnndiyZQu6du2KJUuWoF27dn53jRBCCCHEdShcU4xrrrkG11xzjaM6MjIUZGTw1xwhhJDUJgjPMiU7A4oi1/lVmGJfFwrXEMJQAUIIIelAEJ5lGZnyzaCMOv8FeVDx/xMnhBBCCCHEBHRcQ4iiKJw5ixBCSMoThGeZkq1Akey4KnRcdaHjSgghhBBCUgI6riFEyVACERdECCGEOEG202mHjCzGuHoJ1QshhBBCCEkJ6LiGkHrHlb/mCCGEpDZBeJYxxtVb6LgSQgghhJCUgI5rCGEeV0IIIelAEJ5lGZkKMjIlx7jW0nHVg8I1hGQo8udVJoQQQryGz7LwQeFKCCGEEGITJVOBItlxVUBBrgeFawhRFIYKEEIISX0Uxf9nmSuhAhSuuvj/iRNCCCGEEGICOq4hhOmwCCGEpANBeJa58UxVhP/HFVTouBJCCCGEkJSAjmsIURQFCkdiEkIISXGC8CxTMjOgZMr1ARUIqfWlExSuYYR5XAkhhKQDfJaFDgpXQgghhBCbMKuAt1C4hpCMDAUZAQhoJ4QQQpzAZ1n4oHAlhBBCCLGJoriQVaCOglwPCtcQojDGlRBCSBoQhGeZkgnpoQIKx2bp4v8nTgghhBBCiAnouIYQpsMihBCSDgThWaZkKlCkO67+H1dQoeNKCCGEEEJSAjquIYRTvhJCCEkHgvAsc2PcSBBid4MKhWsIycjIQAYvCkIIISkOn2Xhg8KVEEIIIcQmbrzFDIKTHFQoXEOIogQjoJ0QQghxAh9l4YPClRBCCCHEJq5M+cqsArpQuIYQN2b5IIQQQrwmCG8PGSrgLYxqJoQQQgghKQEd1xDCdFiEEELSgSA8yxTFhXRYCn1FPXhmCCGEEEJISkDHNYRkKAoyAhAXRAghhDghCM8yxrh6Cx1XQgghhBCSEtBxDSFuTE9HCCGEeE0QnmWupMOqo+OqB4VrCOHgLEIIIekAn2Xhg8KVEEIIIcQmjHH1FgrXEKIoSiCSNhNCCCFOCMKzzI3wuyCEQAQVnhlCCCGEEJIS0HENIRkZCjL4GoIQQkiKE4RnGUMFvIWOKyGEEEIISQnouIYQxrgSQghJB4LwLKPj6i10XAkhhBBCSEpAxzWMMI8rIYSQdCAAzzI6rt5Cx5UQQgghhKQEdFxDCGfOIoQQkg4E4VlW/0yVncfV/+MKKhSuISRDUZARgIB2QgghxAlBeJYpGQoyMiWHCtT6f1xBhaECHvDee+/hjDPOQGlpKRRFwcsvvxyzXQiBKVOmoLS0FPn5+ejXrx/WrVsXU6a6uhpjx45Fs2bNUFBQgDPPPBObN2/28CgIIYQQQvyFjqsH7NmzB8cccwwuv/xynHvuuQnbp0+fjpkzZ2LhwoU44ogjcNddd2HQoEH48ssv0ahRIwDAuHHj8Oqrr2LRokVo2rQpJkyYgGHDhmH16tXIzMy01B9FYagAIYSQ1IfpsMIHhasHDB06FEOHDtXcJoTArFmzMHnyZJxzzjkAgCeeeALFxcV49tlnMXr0aOzcuRPz5s3DU089hYEDBwIAnn76abRp0wbLli3DkCFDPDsWQgghhBC/oHD1mY0bN6KyshKDBw9W1+Xm5qJv375YsWIFRo8ejdWrV+PAgQMxZUpLS9G1a1esWLHCsnBVMjKkB5ITQgghXhOEZ5kbz9QgHFdQoXD1mcrKSgBAcXFxzPri4mJ8++23apmcnBw0btw4oUxkfy2qq6tRXV2t/l1VVSWr24QQQgghnkPhGhDi43SEEEljd5KVmTZtGu64446E9RlKIHI2E0IIIY4IwrOMMa7eQi/aZ0pKSgAgwTndunWr6sKWlJSgpqYGO3bs0C2jxaRJk7Bz5051+e677yT3nhBCCCHEO+i4+kxZWRlKSkpQUVGBHj16AABqamqwfPly3HvvvQCA8vJyZGdno6KiAsOHDwcAbNmyBWvXrsX06dN1687NzUVubm7Cek5AQAghJB0IwrOMjqu3ULh6wO7du/HVV1+pf2/cuBGfffYZmjRpgrZt22LcuHGYOnUqOnXqhE6dOmHq1Klo0KABLrzwQgBAUVERRo0ahQkTJqBp06Zo0qQJJk6ciG7duqlZBgghhBDiPRyc5S0Urh7wySefoH///urf48ePBwCMHDkSCxcuxE033YR9+/bhmmuuwY4dO9CrVy8sXbpUzeEKAA888ACysrIwfPhw7Nu3DwMGDMDChQst53AFfs3jGoDcd4QQQogT+CwLH4oQQvjdCeINVVVVKCoqwsjbNiInr1HyHQghhJAAU7N/F564sww7d+5EYWGhp21HnqnrRp2BRjnZUuveVXMAR8971ZfjCjp0XENIRgaQwfgZQgghKQ7fqIcPCtcQwlABQggh6UAQnmWMcfUWnhlCCCGEEJIS0HENIUyHRQghJB0IxLNMUeoX2XUSTei4EkIIIYSQlICOawjJyFA4OIsQQkjKE4RnmaK4MAEBHVddKFwJIYQQQmzCwVneQuEaQphVgBBCSDrAZ1n4oHAlhBBCCLGJGwOeAzHoLKBQuIYQJaN+IYQQQlIZPsvCB4UrIYQQQohNGOPqLRSuIURRFGQwLogQQkiKwxjX8EHhSgghhBBik/rwO9kxrlKrSysoXEOIGznnCCGEEK+h4xo+KFwJIYQQQmzCrALeQuEaQpjHlRBCSDoQiGdZRkb9IrtOognPDCGEEEIISQnouIaQDKV+IYQQQlKZIDzL3HiLGQgnOaDQcSWEEEIIISkBHdcQ4kYgOSGEEOI1QXiWcQICb6FwDSEcnEUIISQd4LMsfFC4EkIIIYTYhOmwvIXCNYS4kbmDEEII8Ro+y8IHhSshhBBCiF0UF9wgzvmqC4VrCGGMKyGEkHSAz7LwQeFKCCGEEGIXNzL1MMZVFwrXEJKRoSCDFwUhhJAUJwjPMkXJgCL51b7s+tIJnhlCCCGEEJIS0HENIYpSvxBCCCGpTCCeZW7Mox4AJzmo0HElhBBCCEkD5syZg7KyMuTl5aG8vBzvv/++Yfnly5ejvLwceXl56NChAx5++OGY7Y899hhOPvlkNG7cGI0bN8bAgQPx8ccfO27XCXRcQwinfCWEEJIOBOFZFpQpX59//nmMGzcOc+bMwYknnohHHnkEQ4cOxfr169G2bduE8hs3bsRpp52Gq666Ck8//TT++c9/4pprrkHz5s1x7rnnAgDeffddXHDBBejTpw/y8vIwffp0DB48GOvWrUOrVq1stesURQghpNdKAklVVRWKiorwh7k/ITe/0O/uEEIIIY6o3leF+65ujp07d6Kw0NvnWuSZ+u2Uq1CYlyO37v01aDflMUvH1atXLxx33HGYO3euuq5z584466yzMG3atITyN998M1555RV88cUX6roxY8bg888/x8qVKzXbqK2tRePGjTF79mxceumlttp1Ch3XEOJGOA4hhBDiNUF4lrk55WtVVVXM+tzcXOTm5iaUr6mpwerVq3HLLbfErB88eDBWrFih2cbKlSsxePDgmHVDhgzBvHnzcODAAWRnZyfss3fvXhw4cABNmjSx3a5TGONKCCGEEBJA2rRpg6KiInXRczC3bduG2tpaFBcXx6wvLi5GZWWl5j6VlZWa5Q8ePIht27Zp7nPLLbegVatWGDhwoO12nULHNYRw5ixCCCHpQCCeZYoif4rWX4/ru+++iwkV0HJbY3eLPR9CCMNzpFVeaz0ATJ8+Hc899xzeffdd5OXlOWrXCRSuhBBCCCE2cTNUoLCw0FSMa7NmzZCZmZngcm7dujXBDY1QUlKiWT4rKwtNmzaNWT9jxgxMnToVy5YtQ/fu3R216xQK1zDiwo9DQgghxHMCYLgGgZycHJSXl6OiogJnn322ur6iogK/+93vNPfp3bs3Xn311Zh1S5cuRc+ePWPiW++77z7cddddeOutt9CzZ0/H7TqFwpUQQgghxC4ZGfWL7DotMn78eFxyySXo2bMnevfujUcffRSbNm3CmDFjAACTJk3C999/jyeffBJAfQaB2bNnY/z48bjqqquwcuVKzJs3D88995xa5/Tp03Hrrbfi2WefRfv27VVntWHDhmjYsKGpdmVD4RpCMhQFGUGICyKEEEIcwGfZIUaMGIHt27fjzjvvxJYtW9C1a1csWbIE7dq1AwBs2bIFmzZtUsuXlZVhyZIluPHGG/HQQw+htLQUf/nLX9QcrkD9xAI1NTX4/e9/H9PW7bffjilTpphqVzbM4xoiIjnn/vjYduQ1YB5XQgghqc3+vVWYelVTX/O4br7nWhTmGQ+aslz3/mq0vuUhX44r6NBxDSGKEpD5nQkhhBAH8FkWPihcCSGEEELsorgQ48oR1LpQuIYQN+LICSGEEK/hsyx8ULgSQgghhNjEzTyuJBEK1xDCmbMIIYSkA4F4likZLsycRStZD54ZQgghhBCSEtBxDSHMKkAIISQdCMSzLEOpX2TXSTSh40oIIYQQQlICOq4hhFkFCCGEpANBeJYpSgYUyTGpsutLJ3hmXGbatGk4/vjj0ahRI7Ro0QJnnXUWvvzyy5gyQghMmTIFpaWlyM/PR79+/bBu3bqYMtXV1Rg7diyaNWuGgoICnHnmmdi8ebOXh0IIIYQQ4it0XF1m+fLluPbaa3H88cfj4MGDmDx5MgYPHoz169ejoKAAADB9+nTMnDkTCxcuxBFHHIG77roLgwYNwpdffolGjRoBAMaNG4dXX30VixYtQtOmTTFhwgQMGzYMq1evRmZmpqU+MasAIYSQdCAQzzLGuHoKhavLvPnmmzF/L1iwAC1atMDq1avx29/+FkIIzJo1C5MnT8Y555wDAHjiiSdQXFyMZ599FqNHj8bOnTsxb948PPXUUxg4cCAA4Omnn0abNm2wbNkyDBkyxPPjIoQQQgjxGgpXj9m5cycAoEmTJgCAjRs3orKyEoMHD1bL5Obmom/fvlixYgVGjx6N1atX48CBAzFlSktL0bVrV6xYsUJXuFZXV6O6ulr9u6qqCgCzChBCCEkPgvAsUzIyoEgOtpVdXzrBM+MhQgiMHz8eJ510Erp27QoAqKysBAAUFxfHlC0uLla3VVZWIicnB40bN9Yto8W0adNQVFSkLm3atJF5OIQQQgiJuEGyF6IJHVcPue666/Dvf/8bH3zwQcK2+DgdIUTS2J1kZSZNmoTx48erf1dVVaFNmzauhOMQQgghXsNnWfigcPWIsWPH4pVXXsF7772H1q1bq+tLSkoA1LuqLVu2VNdv3bpVdWFLSkpQU1ODHTt2xLiuW7duRZ8+fXTbzM3NRW5uruxDIYQQQkiEDEV+Xi4qcl0oXF1GCIGxY8di8eLFePfdd1FWVhazvaysDCUlJaioqECPHj0AADU1NVi+fDnuvfdeAEB5eTmys7NRUVGB4cOHAwC2bNmCtWvXYvr06Zb75Ma0yoQQQojX8FkWPihcXebaa6/Fs88+i7///e9o1KiRGpNaVFSE/Px8KIqCcePGYerUqejUqRM6deqEqVOnokGDBrjwwgvVsqNGjcKECRPQtGlTNGnSBBMnTkS3bt3ULAOEEEII8QE3YlIZ46oLhavLzJ07FwDQr1+/mPULFizAZZddBgC46aabsG/fPlxzzTXYsWMHevXqhaVLl6o5XAHggQceQFZWFoYPH459+/ZhwIABWLhwoeUcrgCQoSjI4EVBCCEkxeGzLHwoQgjhdyeIN1RVVaGoqAj3LPoFeQ0K/e4OIYQQ4oj9e6twy/mHYefOnSgs9Pa5FnmmVj4yGYX5eXLr3rcfJaPv9uW4gg4d1xDCTBuEEELSAT7LwgeFKyGEEEKIXdwY8cxRZ7pQuIYROq6EEELSgSA8yxQXkqPzIa0LJT0hhBBCCEkJ6LiGEM6cRQghJB0IwrNMUTKgSH61L7u+dIJnhhBCCCGEpAR0XEOIojDumxBC0hVR53cPQoYbrzGDYCUHFApXQgghJI0IkzHBMUzhg8I1hDDGlZBY6jgNCyHELkyH5SkUroSQ0MMfcoSkJrx2wweFawjhzFnBgJMtE0JIGuDGQ5UPaV0oXAnxCd6XCCHEGYG4j2Zk1C+y6ySaULiGEKc/DukUEkIIIcQPKFyJZQLxC5cQQkjoCcTziIOzPIVnhhBCCCGEpAR0XEMI02ERQghJBwLxLOMEBJ5Cx5UQQgghhKQEdFxDCNNhEUIISQcC8SxzYx71QBxYMKHjSgghhBBCUgI6riGEjishhJB0IBDPMk5A4CkUroQQQgghduEEBJ5C4RpCmFWAEBIW6jhhCiFpBYUrIYSQtIU/0tObQHy+DBXwFArXEMIYV0LSA06/TAgJGxSuhBCSovAHKAk7gbgGOOWrp1C4hhDGuJIwwlhHQghJfShcCSGhgD/WCEk/AnFdKy5kFaDjqguFawhhjCuxC2MqCSGE+AmFKyHENPzBQwgJAoH6Ec2sAp5C4RpG6LgGlkDdjAkhJKBEnmGBeJZxcJanULgSEiACcRMmhJiCPzQJ8R4K1xCSoQhkKOG949YJqkNCiHP4QzMABOEzYKiAp1C4ktARZtFOiFfwByIhxA0oXEOI21kF+PqMEMIfiMQLAvE9y3AhHZbs+tIIClciHb7hIEQu/DFICCH1ULgSQkjA4Y9BQmIJ0o85oSgQki9S2fWlExSuIYQTEBCiT5AeiIQQbQKVDot4CoUrIYREwQch8Qr+SEoTFMWFPK68EelB4RpCMpSAzO9MiAZ1fJiTkEBt4hyew/BB4UoICRT8UUWM4A8bEjg4c5anULiGEEURUIKQQoSkBIL5OEmA4A8bEk0Qvg8cnOUtFK6EEEP4Iyd88McKISSoULiGEGYVSH04qIO4CX+shBP+YLEJQwU8hcKVkBSEPzzSF/4oIX6Rij9YUrHPxBkUriEkA8GIC0pnOICE2IU/SlID/sAgKm68xuSNQBcKV0JcgD8M0gf+CCFaUFcEA34O4YPCNYQwqwBjuYh5+CPEH/iDgaQMGRn1i+w6iSYUriSUhF24pwv8AZK+8AdDcOGPCuInlPQeMHfuXHTv3h2FhYUoLCxE79698cYbb6jbhRCYMmUKSktLkZ+fj379+mHdunUxdVRXV2Ps2LFo1qwZCgoKcOaZZ2Lz5s22+hMJx0mFhRAjIm8PuMhfCNEjMvtiIBa/TwYO5XGVvRBtgvCZpz2tW7fGPffcg08++QSffPIJTjnlFPzud79Txen06dMxc+ZMzJ49G6tWrUJJSQkGDRqEXbt2qXWMGzcOixcvxqJFi/DBBx9g9+7dGDZsGGpra/06LE/wWzhz4Y+PsOK3cE7HhaQpkXRYsheiiSIEx0b6QZMmTXDffffhiiuuQGlpKcaNG4ebb74ZQL27WlxcjHvvvRejR4/Gzp070bx5czz11FMYMWIEAOCHH35AmzZtsGTJEgwZMsRUm1VVVSgqKsKid7ajQcNCKcdRJ6UWQkgyeKcmJJG9u6tw0SlNsXPnThQWynmumSXyTP2h4hkUFjSQW/eevSgddJEvxxV0GOPqMbW1tXjhhRewZ88e9O7dGxs3bkRlZSUGDx6slsnNzUXfvn2xYsUKjB49GqtXr8aBAwdiypSWlqJr165YsWKFrnCtrq5GdXW1+ndVVZX04+FvwvSDP0aCCd1ra1DoE68QSgaEZIdUdn3pBIWrR6xZswa9e/fG/v370bBhQyxevBhdunTBihUrAADFxcUx5YuLi/Htt98CACorK5GTk4PGjRsnlKmsrNRtc9q0abjjjjskHwlJd3i7tAcFf7Cg0HcGhT8JKhSuHnHkkUfis88+wy+//IIXX3wRI0eOxPLly9XtStxdVgiRsC6eZGUmTZqE8ePHq39XVVWhTZs2jLdKMziyPhhQ8CdCMZ+6pIrwD0Q/3QjoD8SBBRMKV4/IycnB4YcfDgDo2bMnVq1ahT//+c9qXGtlZSVatmyplt+6davqwpaUlKCmpgY7duyIcV23bt2KPn366LaZm5uL3NxcNw6HBAj+CLEGhb53UMzHQiFPiHN4X/EJIQSqq6tRVlaGkpISVFRUqNtqamqwfPlyVZSWl5cjOzs7psyWLVuwdu1aQ+Gqh9+jzLm48wOdmMPvkeV+L8Q/Mrg4WoKKQIYa5yptCfQR+wsdVw/44x//iKFDh6JNmzbYtWsXFi1ahHfffRdvvvkmFEXBuHHjMHXqVHTq1AmdOnXC1KlT0aBBA1x44YUAgKKiIowaNQoTJkxA06ZN0aRJE0ycOBHdunXDwIEDfT464gSKV3Mw3k4eYRSvdNnTAy0pR3kXPihcPeDHH3/EJZdcgi1btqCoqAjdu3fHm2++iUGDBgEAbrrpJuzbtw/XXHMNduzYgV69emHp0qVo1KiRWscDDzyArKwsDB8+HPv27cOAAQOwcOFCZGZmWu5PhiKQEcKHl2zq+DD0jLAJfAp1uYRRrEdD4e4yjHH1FOZxDRGRnHN/e+8naXlcCTGC4p5owacOkcXe3VUY0a+Zr3lcN7/zNxQ2LJBb9+49aN3/98zjqgEd1zDC+EoAfHh6QVicfQp0a6Tz/Yf3FULchcKVhJZ0fnjKgg9hc6SbQKcQt0/Y7iu8RwBCUSAkf/Cy60snKFxDiAIBBelxtxHgxe0m6Xzv5ANXn3QQ4hTf3uD3PcLv9on3ULiSlCZdBLhbUNjrkw4PPIpvfdJBfAMU4CmBklG/yK6TaELhGkKClkOUD1/3SFdhT0FeT5CuY7PwerdGughwIyjOiRUoXInvpOLD1w/4wD9EKgvysIvuVLzeee25ixNxHgRhL34NwJNdJ9GGwjWEuJHHlb+Y3ScVH/hGhFUMpIro5oPzEKl67YX1GiPpDYUrkUIQfvWmChT59aSiGAiTEEgFgU1xbUwqXmPJCOI1GJmmVXadRBsK1xBilFWADwL3STeRHyYhHnQhEMSHuptQXIePhGswCKeXg7M8hcKVxJAKD4KgEfYHUyoJ8XQX2UEU1mET0/Gkyj017PcxkjpQ0hPiEEUNzU/9Jd2JxHcHbUlnIllMgrSQRPy+96TyfSsyAYHsxQ5z5sxBWVkZ8vLyUF5ejvfff9+w/PLly1FeXo68vDx06NABDz/8cMz2devW4dxzz0X79u2hKApmzZqVUMeUKVOgKErMUlJSYqv/ZqDjGkJ48zYmzA5REB4CZkg3dyho4pXOtPeE+b5D5PD8889j3LhxmDNnDk488UQ88sgjGDp0KNavX4+2bdsmlN+4cSNOO+00XHXVVXj66afxz3/+E9dccw2aN2+Oc889FwCwd+9edOjQAeeddx5uvPFG3baPPvpoLFu2TP07MzNT/gH+CoUrIXEE8aFml3R9GAZNYFNIyyfdxXM8Qb7vpOt9RBZBGZw1c+ZMjBo1CldeeSUAYNasWXjrrbcwd+5cTJs2LaH8ww8/jLZt26ouaufOnfHJJ59gxowZqnA9/vjjcfzxxwMAbrnlFt22s7KyXHVZY9rypBUSKBRFQAnAg8lLRMgeghGC/DAE0ueBGBQhnU4CmuI5OAT5PhLkvsmgqqoq5u/c3Fzk5uYmlKupqcHq1asTxOXgwYOxYsUKzbpXrlyJwYMHx6wbMmQI5s2bhwMHDiA7O9t0Pzds2IDS0lLk5uaiV69emDp1Kjp06GB6fytQuJJQkE5CPZ1EeNAeOqkupP0U0OkkmiMEQTwDFNCBx434u1/ra9OmTczq22+/HVOmTEkovm3bNtTW1qK4uDhmfXFxMSorKzWbqKys1Cx/8OBBbNu2DS1btjTV1V69euHJJ5/EEUccgR9//BF33XUX+vTpg3Xr1qFp06am6rAChWsIyUD6jMqr87sDPhBkEZ7qotpvIZ3Kwpmi2T2CIqABimiv+e6771BYWKj+reW2RqPE3cSEEAnrkpXXWm/E0KFD1f9369YNvXv3RseOHfHEE09g/PjxpusxC4UrSWkowINFUER1qgpoP4RzKovlCH6I5nQXy3oESUQDAemPCzGukTyuhYWFMcJVj2bNmiEzMzPBXd26dWuCqxqhpKREs3xWVpYjp7SgoADdunXDhg0bbNdhRLo894kFIjGuQV3CSEaAl1SE31/zMB2VPcKc/onE4tYnbYWcnByUl5ejoqIiZn1FRQX69OmjuU/v3r0Tyi9duhQ9e/a0FN8aT3V1Nb744gvToQZWoeNKAkcqPvz1SFXnL5ogiNdUcqS9/v6m4nfMS/GaDo5yPH6L17C6zUFn/PjxuOSSS9CzZ0/07t0bjz76KDZt2oQxY8YAACZNmoTvv/8eTz75JABgzJgxmD17NsaPH4+rrroKK1euxLx58/Dcc8+pddbU1GD9+vXq/7///nt89tlnaNiwIQ4//HAAwMSJE3HGGWegbdu22Lp1K+666y5UVVVh5MiRrhwnhWsI8fNXe9hueEEV4akmdvwSz6kgmL38jqXa9wagSHYDv4VzhKA8T4KSDmvEiBHYvn077rzzTmzZsgVdu3bFkiVL0K5dOwDAli1bsGnTJrV8WVkZlixZghtvvBEPPfQQSktL8Ze//EVNhQUAP/zwA3r06KH+PWPGDMyYMQN9+/bFu+++CwDYvHkzLrjgAmzbtg3NmzfHCSecgA8//FBtVzaKEGG51EhVVRWKiorwxoffo6Bh8pgZYkxQbpqpSiqKIDdJBZHsBfxemIdPb2DP7ir87sQS7Ny501QsqEwiz9T/+/AfaNSwQGrdu3bvQccTBvhyXEGHjmsIcSsWL2wPnKC4DvGkiqDmK/VYvHCVU0Ece/G9CPp3wSxexwtTKOugwIV0WHKrSycoXIk0gvpa3A6p/GBjWiJtvPp+Bvm747Y4TgVhDFAc28XPgXUUzSQChWsIsTpaPFUeRjIJoghPhQeh16I5iELZ7e9OkL8HbgrjVLsPURzLRU80ByFLhUAGhORvv+z60gkKV5KUdLx8Uu0hCPgrpoP6gPRCKAdNHLv5PQjq5wxQFGtBcUzCCIVrCImOcQ3rTSmIYjzID88wj1x3UxyHRRQH7TONx637QZCvabOE+do3i1AUCMnWr+z60gkK15ATxFfiMkjFGyBTPtUTplftboniMAjiIH2OelAQW8PO9yQIz7CgpMMKCxSuJC0Jws0snqA+aL26PQblYRuGV+2yBXHQhDAg/3MMymdnBoZNkDBD4RpC0mHawCA+SJPhh5gO0sM4DCPa09VZpBC2ThA+NzuE4TqVjZ0pWs3USbShcCUpSRCFdxBvNGFKAZWur2VlfoZB+JwAuddvEK87IH1/xDhF9nXKF+rhg8I1hLg1AYFsUu0m7YeYDspDO51fv8t+MPophCmCjQnK9aQHXeFgwhhXb6FwJYEliOI6aDd6r8Synw/0dHOuZD2O0sUJDtI1Jet6CroAjpBu1xYJBxSuoSRYMa6pcpMHwhunmm6j39PBeaQAPkQQrpFowiaAowljSjWmw/IWClfiO0ES0UDwHhbpnB4qHQb9pLrzKEMAU/y6Q5gFcDx6n3EQ38wRd6FwDSGK4s80eaky13TYYlXTySFJ5XjHVBbAFL/1BFH8Aql9XaQCzCrgLRSuxDOC9uYjSELabbGcyk5kBK9FgYzPJBXPeyo6v36L3gipeu6tQBGcCAdneQuFawjJgECGi0KpLkVuRl4LaT+FshvCmI5kclJR/Do5z6koeoH0Eb5AaojfCDKuj6CFmhH3oXAl0nFTFNshKELabaHstTBO1fjUVBMHTs4zRa850sHtjRAG1zdoMFTAWyhcQ0h9jGtqPbyd4LWQ9ksouyGMvRTDqeROpoo4oOh1n3QSvUC4ng0kNaFwJbYJ4mjOINww0ykMQ6YY9kIEp4r4TQWRFgbR6/f9It1Eb4SwiV8BF2JcOSeYLhSuIUSxkcc1VV5beCmm/Rm9Lf/4vBLDMkRw0MVvkEVv0MMbUmkgWxBElV1ZE2TBG43ZzyaIBgpxFwpXYoqgBcAHQUinyzSnssSwFwLYqfh1W/javU4oeIN97uKxcy6DIHaB9HV5/YQxrt5C4RpCkjmuqXDBeC2kU+XVpx5ePDRlCGC3xa8T4eum6A2yaAu6SEuVt0dBP49moOglQYDClSQQNHcV8F9Mp/qUp6mSSsqJ+A2q6A2a4A272A3qOdMi6C65FdIlZZkW9VO+ys7jGrzPMChQuIYQRRHqDTGINzgtvBLTnjurKZZSKsij6YMqeu08fyh2k0NXV58g/3Cwi54sDMIQJoYKeAuFa8gJYmC7nzdQNwWyJw//gI+qD6rwtSN6KXb1odAN3vlKRjqKXZKeULiSwJGumQFSZarEIIvfIL06TXWxGxShG8RwmaBPLxwEoQtQ7EaoDxWQ7LgyVEAXCtcQYicdlpv4eRN2SyS7fXMOsrgEgjfYKCgPWKtiNyhCNygiFwiem+uHEAviOTNLkH58ktQkCOEhoWLatGlQFAXjxo1T1wkhMGXKFJSWliI/Px/9+vXDunXrYvarrq7G2LFj0axZMxQUFODMM8/E5s2bPe69O0SEtNuLp8f0axyxjMW1PgbwfAaqLwH4nDIgLC1uUT/bnrnFbYJ2vfv9HTHVxwBcT04J4nmNIITiykK0oXD1kFWrVuHRRx9F9+7dY9ZPnz4dM2fOxOzZs7Fq1SqUlJRg0KBB2LVrl1pm3LhxWLx4MRYtWoQPPvgAu3fvxrBhw1BbW2u5H14JxaDdFFP1eNJN+AalL9L7EIDPhSI3qh8BuobVPgXgujXVzwBc04ToQeHqEbt378ZFF12Exx57DI0bN1bXCyEwa9YsTJ48Geeccw66du2KJ554Anv37sWzzz4LANi5cyfmzZuH+++/HwMHDkSPHj3w9NNPY82aNVi2bJlfh2SbdBPIQe9v0IRvUM6P7+1T5AZC4ALBc3EB/78flvoagPucv1h9N5J8oTzTh2fGI6699lqcfvrpGDhwYMz6jRs3orKyEoMHD1bX5ebmom/fvlixYgUAYPXq1Thw4EBMmdLSUnTt2lUto0V1dTWqqqpiFuDXm4zEV9lBvammmhgOav+C8rn7fS4ocilwg3Cf0OxXwO/F0fh9HZPUh4OzPGDRokX417/+hVWrViVsq6ysBAAUFxfHrC8uLsa3336rlsnJyYlxaiNlIvtrMW3aNNxxxx1Ou+8Yr26YXsQEybyRCsjvr5P+ye6Pnc9d5mdo9VzIPH4rbft13v0cfObWoDOz4jUoU/+6cQ8wwso1GZQYy2TnMgjiNiKzZddJtKFwdZnvvvsON9xwA5YuXYq8vDzdckrcHVcIkbAunmRlJk2ahPHjx6t/V1VVoU2bNq67I4A389bH44ZAdvPm7fSGK13w2OyPVMFn8TP0S+img8ilwDXGbXELBFfgAv5+P1INCldvoXB1mdWrV2Pr1q0oLy9X19XW1uK9997D7Nmz8eWXXwKod1Vbtmypltm6davqwpaUlKCmpgY7duyIcV23bt2KPn366Ladm5uL3Nxc2YdkCreFMeCNOJYlht24uQfFXbXTD1nt+yV0gy5ywyRw013cAuY+d7+EDgUu8RrGuLrMgAEDsGbNGnz22Wfq0rNnT1x00UX47LPP0KFDB5SUlKCiokLdp6amBsuXL1dFaXl5ObKzs2PKbNmyBWvXrjUUrnq4Efvpx+sa+eHwHCDl1efrV9t+nPOgnl/ZBDn+1i2CEHer9iWg92m1fykwLsIu7jxRKfT1oOPqMo0aNULXrl1j1hUUFKBp06bq+nHjxmHq1Kno1KkTOnXqhKlTp6JBgwa48MILAQBFRUUYNWoUJkyYgKZNm6JJkyaYOHEiunXrljDYy0+8uCm6fTHLesjJdoHs3sz9jBkFJDqrFtqW1qbHTpLXrpofLp6Zc+qHc+v3RA9eObdAsN3bCHRxiREUrgHgpptuwr59+3DNNddgx44d6NWrF5YuXYpGjRqpZR544AFkZWVh+PDh2LdvHwYMGICFCxciMzPTcnsK6qCgTkrfhcemvWxx7NYN2okAlvkQ9Vvw+iI4TbaZigLX82MLoLhNt5AEgOLWLkFxaN1wSINwfoOKIoSXlwPxk6qqKhQVFWHVv9ahYZQoDjpei2M7BOUm48egOMB758PL8+1pWx6dR6+/r+l4DuPx69qLEMQnuRef+57dVRhwfDvs3LkThYWFrrcXTeSZ+vGnX0h/pu7etQu/6dHZl+MKOnRcQ4jTWCevH3qy3OEIbgjhoJxPO06vjAeu12l2vHQePW3Lo1fpQQtLkNqWD44t4G84AhA81xZIHefWKW5M0cowCH0oXIllUj2WVYYQlil+7Z5PWefIqth1+gD2UuQGTeB6IW69CvOgsLWG38IWSC5u/XBtwyJuiTwoXEOI3bggL38BBj2W1Yn4lSV6/RosZUXoeiVyvRC4qSJug+LaeiVs0yHGFqCwNcL4u+Z/jARjXL2FwpWYxu0g+CAn+wdkDnixJ3plCF6vB0t5lWjeC4EbFHHrtmubao6tlwIa8ObcaWF0LXkVXxtUYUvCBYVrCLEa4+rVLz/Zwlj2Q8TvV/pWBa9ToevldyRIAjfo4tZtoRaEUIR0dGvTXdQC4RW2dFy9hcKVJMXtmFa3LlCnQtiPlFAx7TsWON4JXa9Erhdpi9wWbq4LT5eFmt9uLUWtNYIQghDBSNimsqilcPUWCtdQYs5x9cxplSiMvRzEYdgPD0fOq216JHS9cHKDLG5TWdj66dZS1Bq05ZOoBejWktSDwpXokopOq9M+e52UPqZtj0bQA07Fj/sC129xm6rCNshubRhErSv3NIpaAPrC1stpdfUQcCEdFh1XXShcQ0iyGNdUc1q9ngbTrT5YFbtux2Kq7dg8NrcFrpviNlWFLUWtQRseiE2v76t6582LDDBBErUkXFC4kgRSzWkNgsvqR2oqr/Khuu1+mhG4bonbVBO2qSZq3fxBl0qC1st2AH9dWkD/+khXQVs/ibrcY0vXcyUDCtcQovx6mWnhxfSqQXNa/Rs85V0Mq9vpotxO9J9M3KaSsA2TqE1llzYdBS1Al5akPhSuJAbZ06tGI1sU++20eu2yevJ632eBm0rCNuyiNtVcWjq0SdrzUdACqS1qmVXAWyhcQ4giAEVjiKZwOcpdlihO5ZmnvBtA5bID6lI+VLfCEtwQtm6IcK9FbZgELUMObLbns6AFwhd6QIyhcCUqWmJWBrIFsZ/TrXopdr0ZQOVe/Kpbg5DccEGNvlOy3dogObUUtOktaN107YIiaK1MQe0WQriQVcDD85hqULiGEK2sAq7e4CQJYhkC2I/pVoMiQO3W75oL6oKwdcMFlS1qvQw/CKugDXq4AeCN0PTanQWCIWi9RkD+OfVfjgcXClcCwL1MAlJTzTgQwE5Fr1ezULk/yMmtV/EuCEaPhW2QRW3YBC3d2bj6U9ydBcIpaIk7ULiGEAV1UMShB65Q3MskIEMQS3FPbIheJ2LXitB1I77yUN3BcFi9FrZBFrUUtCbqozsbW3+aurOA++fOCxgq4C0UriRGxMpCphh2In4dDXCyKHbtCl03E/WnisMqvT6PRG0YBK3sQWGp4M5SzHrfTkybdGeJARSuISQ6xtW1kagSxLAM8evpYCoLQteOyHUrUX8qOKwy3VCZolZqvwIqaL1wZylm5ZDOYhbQPn+BmfJVeoxrAA4soFC4hhw3YlulTQzgQPw6Eb2eDKYyKXKtCly/xK2vQtQDUeunS+u2oA2CO0sxG1cvxSwhulC4hhBFHIpxdSO+NQhxrVZFr93z4LbINSNwgyBuAytEZYlHlwWtrJCDILqzYRKz0n60xx277FfkXmWVCYuYZYyrt1C4hhzZ8a2yhLDX07B6IXTdGlDlh7i1IpCCKGql1SNJ0KazO5tKYpaubFT9FLMkoFC4hpBIjKsrr4scCmGnwteq4HVb6LolcGWLW5nCNmii1o963BS0QXNngyZm6crKwdNc3x625QYCkD5ZuvwgvvSBwjXEyI5vlZO2yuYEAR686gfsCEZ3BK70mFOJwjZootZNQetHyIGb7qwMMSsrZpaurMV66cr6BkMFvIXCNYREYlxlx7c6FcLOUlcFK6bVDYFrpc9eCtsgiVqvBa2bMbR+uLMyxGzYXFkpopOubKDaIsGGwjXEBC2+1cu4VivHHpzX/UniTn0Stm6L2nQRtEEQszLCDNLRlWV4gRz8ELJuzfpoBabD8hYK1xDiVoxrKqSvAlLndT9gVUB6I2y9FrVBFrSpJmbT3ZUNgpAFYo+PjmxU/RRjRAIUriFG5i9Vr9NXAan5uh/w0xk1eE0fIFHrt6BNdTEbhBADv1zZIApZhhZE1Z+mQpYxrt5C4RpCFCGgCGF7ilLNOh2I4KCmsPJL4PohbGX1SYqz6bOgdXoMfovZIIQYUMga1OWykJUpBqOP2w0hla5ClrgLhWuIsTJFaTKciGA7ojdIca3heOWvIwYdClor/XBD0HrlzgZNzFLI1pOOQjZV3VggdYUsY1y9hcI1hLgxc5ZdEWxX8Lo/Y5W3o/yB4LijsvripB9OHdowilkvXVkK2bi+SHQm3YyPTSU3FnCv7yS1oXANOTIyCzgaWGVD8FpPlu+OyA1qCiu3xKSsfpjpg+PX9QESs56JUadi0oGjFjQhKyNrAd1YC/WG3I2tE/WL7DqJNhSuoUT8ugCQ8Yve42wCVsSuGyI3lV/7uylqnfTBi7b9ErN+ubJ+hhf4LWTpxvpTn1qvh24s02GFDwrX0CPjonfgKLg9wMqkyLWWbzRcr/29EZXy204lMZsKrmxQhCzd2F/rooglIYXCNYTIj3G1K34DNMDKhMCVKW6D4JCa7YdfolKv7VQSs364sn4IWSeDvVLdjbUrYgF5oi4VRSyQPkKW6bC8hcI15Pgb42pV8Fp8wEnOqypT3MoQtn6/9vcrhjWVxKwfrqwsIUs31hwUsQ7qphtLbEDhGkIieVwjOM3n6t3kAVaErj+DrJKJWxnC1gtRGyRB67WYtTsAzGtX1m0hm+puLEUsRaxXCFG/yK6TaEPhShznc7UjfN2ObTUncr0fZCVnClT5g6Pq2w+mU+q1mJXlyqaCkE0lN5YiliKWEIDCNZTUO65RN3WHca6epLRyYTpVmeJWhrB1Kmr9jGVNHXEZJxJddGX9FLLp6MY6C4GQFxcbBBEbluwEgLxjdpM6KI4+V706iTYUrsRxnGuQUlrJF7jJ+unNICu3RG0qiEs325PVVtCEbCq6sX6EFKSqE8sUWxR1YYbCNYTUZ5xzPrJWrS8VU1pJi2t1LmzdErVuClq77qzfYtYtV9YvIRt0NzboIjYdwgncELHSJiaQXJ9ar8bMb37CrALeQuFKABi/Zk6GZbfDJaErW+DKiWs16pPLr+8lC1q3BKaXr/3TTcgG3Y213ZYEEetXTKzTPLEMJbBYdwBELAdneQuFawiJzuMajd1YV6ui1y2h6/nIf8fpqOyLWidt2xW0QRezMtoJqpANshvrdkiBjJhYL0UsXVhv6yPhg8KVqNiNdbX86t+C0LX0UJT0+l+GsHVP1Lr4Wt1GrtJ0c0v9ELJBdWO9ErFeD+xKxXjYILmwFLCJiF8D8GTXSbShcA0jeu81bOZzdTPG1azIlTETFeBc2Lovau0JWtsxqR6JWb9c2SAI2aC6sV6JWK9jYv2Oh011FzaVwghIekLhSg5hN6jGpdRWgIXX/yYErtPE/Wb645ao9VLQBlXMuuHKei1kg+jGppOI9ToelrGwdGEBoE7UL7LrJNpQuIYRnRhXwGacq1XB68vo/+Ti1u0ZqZyIWrmCNphiNggxrG4L2SC6sekkYlPJhWUYgXf1kfSCwpXE4Emcq1mhK2n0P2DPrYvZ34GodTMDgL14VuvurBdiNoiv/t13S71zY9NBxNKFTYQCNgC4kA4LTIeli7Mpk4gppkyZAkVRYpaSkhJ1uxACU6ZMQWlpKfLz89GvXz+sW7cupo7q6mqMHTsWzZo1Q0FBAc4880xs3rzZXociMa56iw0imQrMLNL6aaGvTvsUyX2rtThpO/m+QnOx015yhMZirR2rx5O0vMNzbaV+N+u2Wr8ZrNRdX7/5815ff526uNGf6H2slre0jyLUxQpW2zm0n/lzJqtNoF7AZtjcV23fxnnSrMfBcXhRH0ltKFw94uijj8aWLVvUZc2aNeq26dOnY+bMmZg9ezZWrVqFkpISDBo0CLt27VLLjBs3DosXL8aiRYvwwQcfYPfu3Rg2bBhqa2vld9aMYHQgdqUKXEl9C5qoTb6fNTGr11ZyzAtZrTaSl/dOyPpZd3z9ftZdX789EWsWTwSpDTHjRMBabosCNjQC1s4jU/JjNVQwVMAjsrKyYlzWCEIIzJo1C5MnT8Y555wDAHjiiSdQXFyMZ599FqNHj8bOnTsxb948PPXUUxg4cCAA4Omnn0abNm2wbNkyDBkyxFJfzNxQLb/usnKVeRwCkLRvNuNLzbSvd5N1JZ7TTpyp5Xa0jkdeiIHVgUZWXv07CStwM2TB/3CFX1/HBiyUwItYWC/CCGTEwTKEwN36nBJ5NyG7TqINHVeP2LBhA0pLS1FWVobzzz8fX3/9NQBg48aNqKysxODBg9Wyubm56Nu3L1asWAEAWL16NQ4cOBBTprS0FF27dlXLyCb6NaGZxRISf2667trabD/pfjYcWjtteePMuufKuunIWuqHR06vzHqt1+1NKIFZ7Lmc6RlGkE4OrEyC6L76zZw5c1BWVoa8vDyUl5fj/fffNyy/fPlylJeXIy8vDx06dMDDDz8cs33dunU499xz0b59eyiKglmzZklp1wkUrh7Qq1cvPPnkk3jrrbfw2GOPobKyEn369MH27dtRWVkJACguLo7Zp7i4WN1WWVmJnJwcNG7cWLeMFtXV1aiqqopZAMmv6n/FFZEbBGGbooLWuLxzMWtMvJCVKCAdCNmkZQMgNr0QsabKuhhKYDmsIQXCCKySyiEETnEjfMBvghIq8Pzzz2PcuHGYPHkyPv30U5x88skYOnQoNm3apFl+48aNOO2003DyySfj008/xR//+Edcf/31ePHFF9Uye/fuRYcOHXDPPfdovjW2065TKFw9YOjQoTj33HPRrVs3DBw4EK+//jqA+pCACErcazohRMK6eJKVmTZtGoqKitSlTZs2lvptVuBaFbrSxK2fsa0225UpaK22Y1zempi1/tn7L2Ttnr9kpJqItRsPa6pswFzYIAvYVI2BDWr8KwFmzpyJUaNG4corr0Tnzp0xa9YstGnTBnPnztUs//DDD6Nt27aYNWsWOnfujCuvvBJXXHEFZsyYoZY5/vjjcd999+H8889Hbm6ulHadQuHqAwUFBejWrRs2bNig/oKJd063bt2qurAlJSWoqanBjh07dMtoMWnSJOzcuVNdvvvuu/oNLv3kkylwpYhbh8fmpUtrpy2vxazMur0QsslwO6QgafspJmK9cGHNQgF7qD27pGv4gB+IX9NhyV6sUFNTg9WrV8eEFALA4MGDdUMKV65cmVB+yJAh+OSTT3DgwAHX2nUKhasPVFdX44svvkDLli1RVlaGkpISVFRUqNtramqwfPly9OnTBwBQXl6O7OzsmDJbtmzB2rVr1TJa5ObmorCwMGaxjAsi1ytx6+jYbPTfVnvJjtFjMWtc1k1X1pyIja/XSn8Ny7ogDN0Wm2awdj2568Ja6YPVMAKzeClgrZLK8a9OofuqT3y4X3V1tWa5bdu2oba21jDsMJ7KykrN8gcPHsS2bdtM9c9Ou05hVgEPmDhxIs444wy0bdsWW7duxV133YWqqiqMHDkSiqJg3LhxmDp1Kjp16oROnTph6tSpaNCgAS688EIAQFFREUaNGoUJEyagadOmaNKkCSZOnKiGHljF6qt905MLmBWvDqY+VZsyNbraIBtAst9sesdilEBfp8+GfZXUjuFI/bgHgoA/WQCi67aWuUBOpgCzyfijz5fRuYpv3+xnEOQ6o+tNVmd9vb+WtZCRwOzIekv9sFDWTnmgXqDZmY3LShv1+9mbyMBue4DzDAQysw/Y6b/fuDnla3yI3+23344pU6bo7mc17FCrvNb6ZNgJd7QLhasHbN68GRdccAG2bduG5s2b44QTTsCHH36Idu3aAQBuuukm7Nu3D9dccw127NiBXr16YenSpWjUqJFaxwMPPICsrCwMHz4c+/btw4ABA7Bw4UJkZma63n/pIteMwHWQospMP2yLWj8FrSQxq+VsWBGzMoSslTrtCtl0ErFupNeSW6e581lfr72UWkEQsHYEmhMBa3cWLrviLwPCcfqssIpXt/juu+9i3pbqxZk2a9YMmZmZhmGH8ZSUlGiWz8rKQtOmTU31z067TqFw9YBFixYZblcUBVOmTDH8FZWXl4cHH3wQDz74oOP+WHnNF8GMo1JfdzrkXtURmh4IWjfFrFuurBSBaFvIhkPEuuGYppoLG0YB65f7GgTxCtjrvx/YzQKQrE4ApsP8cnJyUF5ejoqKCpx99tnq+oqKCvzud7/T3Kd379549dVXY9YtXboUPXv2RHZ2tql+2mnXKRSuYcTGFWZW6Jp6WMkQtw6ErV1RK03QuilmXXJlZQhZ98MKgi1iZQtOP11YCthfy9sUsEF3Xxk6YI1IZLbsOq0yfvx4XHLJJejZsyd69+6NRx99FJs2bcKYMWMA1A/Y/v777/Hkk08CAMaMGYPZs2dj/PjxuOqqq7By5UrMmzcPzz33nFpnTU0N1q9fr/7/+++/x2effYaGDRvi8MMPN9WubChcw4qF1/8AAJNxrrIEruMYVxsOqFG7UgWtm2LWJVfWTyFr3o01F1Lgl4hNJReWAtaaYPIi/jXM7msqiNcgMGLECGzfvh133nkntmzZgq5du2LJkiVqWOKWLVticquWlZVhyZIluPHGG/HQQw+htLQUf/nLX3DuueeqZX744Qf06NFD/XvGjBmYMWMG+vbti3fffddUu7JRhJBtcJOgUlVVhaKiImz+xwsobNgAgPkQAEuYHcxlgJN+mR5MFo+NNq22ZemhY7E/pvtioV6zdZp9sJiuz2QfzZ//5PVJ75vEcyL9/PpUX32dZs+f+WvFUvsWRZDl8haFmh1RZsd9tdsW4Hz6UafiFdDv++7du3DicZ2wc+dOe5lzHBB5pj7xjx1oUCC37b17qjByQGNfjivo0HENOVZiXU2LSTNubjJHJ0m/rMRLxu7n9wh/jfIuObOmXVkPHVk7bqxXIQVuObEyXE63XN0gO7BBcl8tlQ+4++pX6ACdVyILCtdQUhcrLj0OA6gvlETcOhC2dkStTEEbFDHrtpD1SmjZCSkIkogNsuikgHUnfCDIsa9+ZR1IZ/Hq5uAskgiFK7EW72omf6qJKy6puDXqk01R64mgdUnMWhoA5pGQddONdSwWLYtYeQO7vHZh/XB0ZQtYN+JfXRGkHrivXolXwPu413QWr8Q7KFzDiN7PQxlOqVqXe6EAdkWtJ4LWJTHryJUNsJANjoi1lp3Aaxc2aKJTfqYEawO40tl9tRs64HXWAYrXQ9Bx9RYKV3IIiTNf+RUKYEfUyhK0fotZX4Ssw7CCVBWxXruwQRWdfglYN8MHgpR5gOLVoI6AiVfiHRSuIcRoyldpM18BxgLXgbCVLmolCVqvxGyghKyNurwUsWZ+fMgKJfBSwCZtT7Lo9D5XrTsCVrb7GrTQAT8GbfktXoNAnVBQJyFzQnydRBsKVxKD2eldXZ/9ysNwAM22LLbhipgNsJB14sZ6KWKD5sL6FUbgRT1m64rUJzv+NVXc1yDHvaaieA0CDBXwFgrXMGLmKnM4QQBgQtwa9cHvcAAJ7qzjhPpBELIUsRoE04UNmoBNF/c1KHGvFK86+wfEdSXeQeFKtDHzc8/N2a9ki1o3Ba1DMWvalTUZXmBHyDpxY2WFFPghYp2FEph3YcMoYN0IH5DtvroROuBW3GvQxWuYoePqLRSuIcQoxjUaR46p2pi1AU6m2rcjal10UJ2IWS9cWTN1Bc2NlS1i/XZhpYlpicJTlmvqZfiAFffVr9ABN+NevRKvdmDIAPEKCtcwYjKO1RNx6/NkAW44qJr1+iFkHb2et+jGBlzEeu/C2q/DKwGb6uED6RY64KZ4tUoqhgz4iRBAHR1Xz6BwDSvS8rE6FLc23FO3JwtwRcyarFOqkPXSjZUtYiXExHrhwqaKgE3F8IEghw6kmnhNlXhXQsxA4RpGogNynMxgFcGBuHV7qlXDNqzU70I4gBlX1jUh66YbK6MdC3X46cJ6EQcrQ8DKFJ6ywgeCGjpA8Wq/DaekqusqhCK936l4HryCwjXs+J6T1Yao9UPQSnRR69s2UZ8kIevuYCn/RayXLqx9AVvfeqQ3bvShvmZjoSEj/jVog8Dq65IXOkDx6hy6rsRNKFxDiNbgLDdjVe0KW1cdVJ36naamkhrbKknIynBjrYYUOBWxTkMJ/AojkDmQy7aIDlj8q5fuq6zQAYpX+/U7JRVdV2YV8BYKVwLA2PmMYDtWFbAnbN0UtE7FrF1X1kMhK8WNtVmHUxHrtgsbrDACfwWs2+ED3oYgyBWvgAm31yXxagW3xaWd+um6EregcA0jej8Pg5aX1U1B64WYlSRkTcXISnBjgy5ig+7COhOwDoRhErEmK/7VbeEpLwTB+7hXN8Srm86jVyEDdkk117XOhawCsutLJyhcySGClpfVRUErW8y6KWS9cmO9GTCVJM7QQITKcmH9FLB+ua/1NTsTn17Ez5rph/l6zMW9+iFezZLqIQNhcV0ZKuAtFK5hRNQZx526FBLgdsyqFUHry2xVfglZH0RskF1Ys2EEbgjYoIcPyIp9TaXQAZnuoyuxsQHL8UqI31C4kkQcZAmQmZcVsCAmDeo3P/pfXkiAX0I2lUWsqy6sDYdYhoD1M/7Vb/dVRuhAkMSrbFEaBJFJ11UOdFy9hcI1hCh1AkqSABqRYWMwldqARQcVsCxqnb7qNx9rKkeAuiJkU1jEOnJh7YhBnwSsn/GvfruvQYmdra8ntcVrGF3XVItzJd5B4RpGhKgXMEYPFBOR4bri1k4YgluprKTnZPVJyNpwY5OGFHglYmW7sE7CCFJSwKa3++pd7Gx4xKsVgp4eKxXg4CxvoXANMyZSYNkVt5ZFrQRB60cqK8+ErNturCQRGyQX1r0+JRewfg3gcuK+Blm8yqvDW/HqF0HrXxjCBYh3ULiGkfjBWYYxq/bCAiyLWhmC1m0xa8KVdUPIOnZjPRSxvruwLg3ksipg3R/A5ULcrYTQAYpX62UslXMpZCDo6bGCDmNcvYXCldiPWU22r0VR61jQui1mbb2udx4S4JWIdRITazmUQIILmy4CNp3cVydutJm25dVhbqICGch2P4MQ+xk0R5eECwrXMGJ1AgLbg7Es5lt1KmhTIJ2V05AAS/tbFKJOBnZJCSUIkoC1ISbtCtiguq9uuadepdxyKqy8DhmgGExd6urqF9l1Em0oXMkh7OZoteq6ShC0UsWsr1kAXEw15YWIlSnEgiRgHQjfZKItaO6rk9ABvwdtOds//UMGGC7gDQwV8BYK1zASH+MajWFYgPV0VtZe9ZsvK1XMmnBlpQhZmW6sWyJWYjys7VhYg76mioANovvqRuiAF/lejUhH8UoIMYbCNYwY5dmwHRZgUdQ6FbQyxawNESo9nZVVN9YtESsjHtYDF9bo+IImYL13X70NHXBTvMp55e9cvHqJ9JhYlwSz1XrTObMAHVdvoXANK8mSxPmVo9X0636JYtYLIWvFjXVJxFoW13ZDCQISRuCagLUoKL13X90LHfAj44Dbrm19Hcly3QbPdXVjkBbDBUgqQOEaSuoMxUV9ERvC1nKsq0lBa9adtSlm3RayjgSjRvtOX7Mn7ZMsN9WE8JUtYGWHEHgZPuC1++r1oC0/xatXg7VkwbCC1KIOLkxAILe6tILCNezYDQ3Qu0plTDwgcYIAU5MIyBaynmYCcEHEOnRhrYQRmImDtRNCIEvAyhbR9f3QFiVO3Nd0Ea9GBGGwltM+mi1juj0XBmkREnQoXEOIIurMxWgC1l1Uo5+dbqe1MjUQK3kZx0LWiRvro4iV5cLKDiPwXMBKCh/wMvY1eehAaohX/wd7OQ8ZIOFDCAEhOShVdn3pBIUrAZDoCkZjWdRacWldTmslw5W1JGQduLFyMwHIHfBkyoW1E0bgs4D1KnzA/9AB/bjXdBOvRnjhPMpyXemSEqINhWsYqROWXvVbFrVWBK3ZfphyU224ssn6nyS0wJEb68nrew9d2KAIWJcHcHnlviYLHZAZ92q7LZdEpBPn1O2QAbquJB5mFfAWCtcwYvT63+Krfj1R64qglSFmrQpZN93YIIpYO/2QEQcrU8C6MYArgO6rl3GvbqXKMsLvTANGJBOvXjqqsrMLUJhbR9TJn+kq2fCTMEPhGlasxq4CUlxa04LWjJi1k6PVQyGbCiJWigvrIA7WqoC1FN/pQfiAl+6rnbjXoIvX4A70CkZu13SaUtZqDlfZqb5I+kDhGkai32tYmRwAMO+ORsjQF2ExTdoYRGXLlXVTyKaCiJXowspp35qAteUyWjyOILivskIH0kG8GuFXrKwZ/BaKxDsYKuAtFK5hx+jqcEvUmnRopYhZN4VsKohYmS6si3GwsgSsXQfUT/dVVtaBdBWvbsa7Gu/rfqwrxS0h1qFwDSOiLrmAA+SJWjtOKRLFrKkwAzeFrBU31mCbmyJWpgvrSRys1wLWb/fVg7hXL9JlBUm8Bj3LgFNMxcu6MIsWMY/ReGcndRJtKFxJPVadVD1Ra1bQ2hCztlxZJ0LWAzfWsYh1VUR6EAcrUcBaDh+Q5b5KaheQE/dqP12WNeHjVrYB2fjpugbpPKQSFOHECArXMFIHazNfmXVSAfOC1iUxK1XIynJj3RSxbojI+H65EQer1bYVEaZR3jf3VdY5gLH76pd4tZvnVQ+6riTdYIyrt1C4hhEjd9VLQStDzLopZCW9xjclYu3ExDp1YT0MI9AsH6TwgYC5r26LV33kidcghQy46bo6JQzC2WpGAUKMoHANK0biFTDnfkYwk19Vq047YtZNIWvXjZUhYu0M7PLShZUgYAMdPmDDfU1l8Wp3kgKr4s8tMSkbZ44twwVkkophAqJOQEgOSpVdXzpB4RpCRF0dRFS2ZCXDxKCnQ4UT18mcytVpeionQtauG2s4SMsdESvLhfVSwMqMf3U1fMCk0LMTOpCu4lV2vGvQXFcSXILwo4CDs7yFwpXEiNhoHAlau1O5WnVlk4lhC0LWthsrIR5VX3haDCVI1rYfAtaF+Fe/3FenoQPywhW8EK/ayAxNcCtuVTZ+T0gQpHMRIWj9IeGBPz894Pvvv8fFF1+Mpk2bokGDBjj22GOxevVqdbsQAlOmTEFpaSny8/PRr18/rFu3LqaO6upqjB07Fs2aNUNBQQHOPPNMbN682V6HIpHk8Ut8sV+dWa1Fo3DiokXkp6neT1Qz9STpt+G+Bu0roi5msVWnXl+MjsFMOwbtK3UiYepZ3bZ12tU85ujyJo9L+9xp12HYpun2hCpiE8qbLKs3KYaVPkfcVzN16LZppSygpssyXd5i/dCp3wjdNgzq0m/fqB39fey2ZbRf0v7off4piOzpXq3Et1oNEwiKeNZ7pDpdiDYUri6zY8cOnHjiicjOzsYbb7yB9evX4/7778dhhx2mlpk+fTpmzpyJ2bNnY9WqVSgpKcGgQYOwa9cutcy4ceOwePFiLFq0CB988AF2796NYcOGoba21nqnjB7UJq8eaWI2XkiaEbPJ+m1lX4N2pYpYM/1PWK9XXoKA1WlX/5itC1gz7UW36aw9Z2UtiWhoH5808WpBXPslXm2JTTtC2IGYDBLJjiNdjpMQL2CogMvce++9aNOmDRYsWKCua9++vfp/IQRmzZqFyZMn45xzzgEAPPHEEyguLsazzz6L0aNHY+fOnZg3bx6eeuopDBw4EADw9NNPo02bNli2bBmGDBlivWNGDx4zr+uBhFebWuI1Idwg2at9wL9JAwxe/+uPzLcRTmA1lEC3vPb6pGEETuJgLYQQuD6Ay0r4gIXYVyf9NYx7dThoy7+wAQG4nM1AZsgCYP/VunGMrL/hAiSWoLitAFBXJ1AnOShVdn3pBB1Xl3nllVfQs2dPnHfeeWjRogV69OiBxx57TN2+ceNGVFZWYvDgweq63Nxc9O3bFytWrAAArF69GgcOHIgpU1paiq5du6pltKiurkZVVVXMAsDY3QS0nVIzTqfJcANT7UXjxJG1G1ZgMqTAVF3R9em1n7DeRRfWYpuWQwg09jfrZsoKHzDTL72yVkMHNOvVcl+tup0+OK9WsezsBsB1teMWE/dJxWwCxB8oXF3m66+/xty5c9GpUye89dZbGDNmDK6//no8+eSTAIDKykoAQHFxccx+xcXF6rbKykrk5OSgcePGumW0mDZtGoqKitSlTZs2iYW0XtVbEbQJZZKHG9gSs0Z9trKvjNjYKCyLWKuhBHZjYeNwKmAtxcAahA9YiX811VakvYT9vQsdSFXxaq2s++6P7FhXr0mnONdkmHU73crfGiS3FdB/7DHG1R0oXF2mrq4Oxx13HKZOnYoePXpg9OjRuOqqqzB37tyYckr8a3chEtbFk6zMpEmTsHPnTnX57rvvft3RhAA1K2jturMJ1XgkZM32KQgiNuE4LLiwARewjttKWJfYltWBW1o4dYqliFcLZa24k27Hu/rtusoeEFa/H9WEG1hxW4MmWon3ULi6TMuWLdGlS5eYdZ07d8amTZsAACUlJQCQ4Jxu3bpVdWFLSkpQU1ODHTt26JbRIjc3F4WFhTGLLmYFqBNBG7PdmiubtH6jPurtl1CnAxEbh77oslBPsnNnpm6dOlwVsCb65djRlOG+apQzHTpgQfQ5Fq8WBaaWYPMz04Bm/TIHfUl2XcM8UEp2RoGwQMfVW/gtdZkTTzwRX375Zcy6//73v2jXrh0AoKysDCUlJaioqFC319TUYPny5ejTpw8AoLy8HNnZ2TFltmzZgrVr16plLKEnPp04qi5nB7AkZI36ZrY/VkWsHy5ssj7G45WAtSQqXRLKCe2YFPo6ZVNNvFopK8NFdDuWFghGfKwT/O6LLKdSdphAOritdUK4shBtmFXAZW688Ub06dMHU6dOxfDhw/Hxxx/j0UcfxaOPPgqgPkRg3LhxmDp1Kjp16oROnTph6tSpaNCgAS688EIAQFFREUaNGoUJEyagadOmaNKkCSZOnIhu3bqpWQasEfXAljVxgNm6zM44BSQ+rKPCIuLFa0z2AqN6ZU4coFdep42kmQn0zp/dzAC6ZRPXa87IZdSW3QwEWm1r7WvQjqnk/Zrt/HqMJrMOuJFxwFG2AQtlrWYa0MLtLAMy+kgICR8Uri5z/PHHY/HixZg0aRLuvPNOlJWVYdasWbjooovUMjfddBP27duHa665Bjt27ECvXr2wdOlSNGrUSC3zwAMPICsrC8OHD8e+ffswYMAALFy4EJmZmc46qOfYWBWhenVZSXWVbH8ZQtbsrFqyRaxOei1TqbWMBKxe/9wWsBYEm66wNDP7lkY7ltN0mZlFy4l4jbTvo3jVwkpKKJkza/mB7HRaxBlhclsB/ZdUTusk2ihC0I8OC1VVVSgqKsKWh/+Iwvy8mG2a07tqkexGHy9mrdZhtL/RfgYPc91js9MPvX202tcrq1O35kNUa52Vvpntl05fhVZbJtvRPh5z9Znd11kbDso57KNmLKEL7dS3ZaGshXq1XFerdev1z7AeSeWN9km+n8E2gwg8wzqTCLOk25OIQDPCz0yMq5l6ZAtXozZ3796FE4/rhJ07dxqP43CByDN10qPbkddAbtv791Zh2v809eW4gg4dVwIg0bGMYHkCATvOrB0XNH4/k26s45ACO6/q9eq24sLa7ZtZB1bnuJQ6kSheNdxJx6/1NdxX6aEDEp1Xp3204rxqYvZc6OBmyEDQsDsZQdiQJVpNt5dGeVsFBGR7gCJA8dlBg8I1jBgNWXRjNiwnsa4yhKwZERtfn9NX9XHtWhGgpgVssr5JErBOwgekx75Kb0Mj7tVCfKwX4tWpyLQSSyojZEDmjFqa9TM2NtDIzt3KHx0kHgrXMFIngIiASxBvGiJThph1EuvqUlyqKRFrxenUa9emCystDjbIAjYN3FffxKuEwVpaWBOYzl1XP4VouohdGWECXpJObitQf6vQeWnpqE6iDYVr2NG72jJ0hF80BoOjAAuv5QE5QtYNEWsxc4ChkItr01AcJxOwFvZ3Q8BKCx9w6r5SvGqKV7N4HV4gy3W1CsMFnCMztlVmmyR8ULiGECES43ESZuDSErTJ3NkkzqyhkK0vENW+jbRVfotYmaP+DQQsYCKMwIqANSHW4tc5dV+lxb5Kr9+FjAN2cSBew+q6yvwMgiR23e6HlxMPyBiQFTS0nqky6iTaULiGEQ1RqneRxAjaZGI2SZiBoZCtLxC9MapdG+EBevvoubd2Razbg6acxsHWCW3h73b4QBJxZSku1UbogLPQBGeDtoz6pdd/TdfVIWbFq/eDupwTJFEZBvxwW80ShO+B3pw7Tusk2lC4hhUzIQLQFrSOxKybkwg42ceuEysr5jS6LRlxsG6HD8QLovjwAZnuq07ogC3n0WXxmk4hA265rn6FC4SVIAi7COnothLvoXANI9FZBWyECFgWs24KWadurJYTa0HE2nJhXQojkBo+oNUPr93XJMLRdtyraWc39cWr05ABLVxzaH0apJXqA7ScDnSS4fTLdFutfDeDInBFnYCQbJHKri+doHANO2bSYtkQs54KWSdxrg7jU111YS0KWMt5YK3Gv8p2X6UJzOSuqmln16Z4jcfXHK8mMBsy4HWsqxUYLuANss6x7EwC/OzDC4VrCBF1dSbiTY3jVZOJWbeFrHQRKzGUwLQLK1PA2o1/1eqHV+6rk9CBgIlX2ZkGzOB2/ZbbtrS/e+ECuhkNKHRdwYzbKjtEIGifY/RLTJl1Em1S9/0IsY9GJHlEzMYvsYVE4hJTb13sErOriFnM7qfXln4f6w4tWscc//rFbFm9eg36ZrqdZOW0znV8OY26FFEXk4nAsB9m+pC0TOKPGUWr7njif+SYKKPVfuKxJp4303XHoZh4imiVMdWeVl0wt5/Z+rXKKRoz82iWc/gE1eyjXtmQzhbklhBLPo2ssQTwUiCmqmgl3kPHNcyYmJ41eX5WfYfUyFk17ciaaEuKE+vCICvPHFg3B3BJcl+thg44iXs1k3FAivNq0p014076FTLgBO3jcmeQVqrHoTohyEJNptuaytTVCdRJjkmVXV86QeEaRuLdKj1RF02U8DCOPZUsZM2GFTgVsXZCCUzGwpqOg7UrYE2KYdMDuFyIfTUdOiAhK0AQxWsCAQkZcCfWlWjhhgBNF1FIt5VYgcI1hCSMVtR6lRf/IDQYvW/oykoQspbdWDsi1kqMqwOH1JQLK3PwlNkBXH66r1bjXlNQvNpNYeUoy4BvJLquMrILOC0bNtwOE5DltqaDaOUEBN5C4RpStFJtKEY5UesLHPp/kjADXVfWrJD1WsTaCSUIgoCVNYBLpvuaINAS3Vc7oQNWMw7YFq/xaB2TjTJ2+2N7cgIPXNdgCWaSrgRZtAKJLzFl1Um04R0njAjtgVCRXHTRS8J+8Us00YOaDAZ/xW7QGeylM2BLd5CXhcFdmn1Jdkxa50HruI3qszKQy2of9AZwJakn6eAtvbZj/o5rW+s8xg+k0vrho1WvUV81yiQdsGWmXi2nI6Fee2XMDFQyNZhJ4kAwP3E68Eu/Xj71jUgltzXoopV4Dx3XsJMsrZVVZ9bIlc1IdD/rdzF2SxP6mcyNTebEupnCyqZLmtAPK3XbiX+1M3jLqfsqIe7Vzut9W06nqXCE5HGfduNdE+qROFDLjUkJEnEWLqBFGN1do8/ESBj6LfZkhgikAnVCoE7yjzDZ9aUT4boLEACJrmXS9FRJnNm4jeYc2ZhddFJw6aTCSpZyK2lZJy6skbuqdayxB2rdgTVTt6bDadIljkLTfTVzTMnaNeoHNNzXIDuvcSQ4hhrtxJex1RdAO0VWQlvyXFezqbHobh7CTkhH0AScDLfVaRtWy5FwQcc1jESEnMGofsAgnhQwdGVNObImB3tpxsYmcWKTxsS65cLajYN14sDaiX91I/ZVQtYBq85rTD/12k3mvMaR1HnViGU1M1graTs2y8h0XYOEW4OuOJjLnri2VL+kTAemxW0AMitwcJa3BPfORdwnmbNq5Mwa7GvakY3pi4XYWAtOrOl4WKsurFbftY7TShkdB9ZWvTF/J4lBteu+WjwWy3GvJhzQpC5pMudVQp2amImJTdjHhMNr13U1gVcTErhdXxCRLZbdChNw6rZ6HdcaBNFKvIeOawiJF3KGzirgeCpXXUfWohvrihNr14W1667acGB1HWAz7q8V91DDfTXM+2o25tZi3Kv0XK/JnFczrmXSOq3Hu3rqupo5bw4wOxmBK9PPpqmL6kreV5+9qnQVrZyAwFvouIaReFfTasyrwb66+0XvI8GNteXEavTbsK8GLqxmv+P7a6dMbCeN29Y7VxbqTNYv3WljrbZpuD14zqu5kf1JXFUTddiKq/XYdSXuESTB7YXbKosgiVbiPXRcw4pFZxXQcClN7JdsH1NubJIcq6adWAMX1mosrLQ8rDac0qTxr165r07jXiU7rwk4dF5tObMJfbDuzCbth4l9bJfRIOjxsGHDbpiAE7fVqwFZpsoEULRq+SUy6iTaULiGkHi3UxWLdsMEJM6ApdmvZCJWY2CXZootA3FqN4zAkYC18qpfJ3whafiAEzGZYuLVjsByLF49ChlIqMPEpATSQhE09/NnMoKwiGivnVin7SUTk+ksWoFf3+BJfrXPwVn6ULiGkPhX3YZZAWS6q2bK2xGxbruwWv2TIWC1nFCLmQIcu6/xgjjJ/kmzDthpz03xaiIrgGWsilc7bfrousqNGbUf55pqsat+x4+6hdMQgXQXrcR7KFxDSkKcJg6JH8NJB1wSslZCCqSKWBMurGEYgRsC1sagp5R2XxPErbfi1bLraock4jborqvbTqepEIqAYLWfMsW3G2ECfv84SAfRKoT8CQjouOqTnj8RiTE6g5h0JwLAofCChEFVJgduxWA2bZVeWa1+aA3sMkivZXgurKTUiq9Hr53oPur1z+p2q4O3LNaXbBCWq4O2HA7Ycn2wVtL6rD905AwY8+5hF4Y0Vm7it2A0gxduazKCLlqJ99BxDTtaDx8l0akEYl1E3fACCWECViYQiPRDc9IDEy6sYSysVnt6YQRWHVgr7qRFt1Sq+2oidMC1uNegO68OQwZkuIxmXNcEPA8XIFawc979cFu9ChFIBTSz5Eiok2hDxzWExDuric6giF109out04QjG9OEuYkBTJez6cIaptWKb0+j/7plZLuhbrivMQdkzVE0TJmVws6r30hxXZPVabOMrLZShaCJKq+dRxmZBIyQFSIQtM+JuA8d1zASJfAUjTjQCJqDmgDLjqwVN9ayE6tVzooLa5SRwAsH1mn8q9bgJ7Puq8W6LMW9Btl5NSAtXFczg7TstGM7zlUAAREXQRmtLzXu1QW31e0QgXQTrXRcvYWOa8gxmp5V12G16MjqTjjgxGE1EXdq6MKq+whdFzbheHXaie6PbhnZjqjRdjNt2awr2b4JzqsTl9egrJ1JCnS3yY53dYgbrmsCJvpsZjICxrnWIyujQFCEmBEUrcRv6LiGEQ3hlXRCABg4rCYcWb2MBZpurE0n1pILG/3w13Eg7TqwCXG58XG0shxRre1mY1+16nIS92o244DVdpykyorCcbyrFXxwXRP7YN919oKg9Sfo2AkTcMttNW4znKJVYxywlDqJNrxzhBAB89O6mnVkYzcYu7GxdZiLizXMOBBXRpoLG9f3hONL0g+97VLiX2POg7XY1xistGPkVFrJOGDFLTWqBxrOq149mn2y8GSQnWUgiWtq1XU1Mw1sMtIpPtUtgpayy/PQB5fjbFNRtBLvoXANMdFCz/D1vAkhayqsIElZQxGr0WfNvsaV06snur2oFcETsNEk62vswcX97aAdnXoStgdBvDp5zW4xZEAmvrxyt9GmlwO9vMIt59dqfKvu+oC4rW6HCKSyaI1/Lspa7DBnzhyUlZUhLy8P5eXleP/99w3LL1++HOXl5cjLy0OHDh3w8MMPJ5R58cUX0aVLF+Tm5qJLly5YvHhxzPYpU6ZAUZSYpaSkxFb/zUDhGkKMsgq4IWSjKk8Ue1FlY9eZd2ENHVYzIjcIAjbm2G26r2YyDxi1E42FelwTr0bbLJWVGO9qtM2q6+o2EmJjzcS5yiJV42X9mjFLtojzM0QglUUroG0CyVis8vzzz2PcuHGYPHkyPv30U5x88skYOnQoNm3apFl+48aNOO2003DyySfj008/xR//+Edcf/31ePHFF9UyK1euxIgRI3DJJZfg888/xyWXXILhw4fjo48+iqnr6KOPxpYtW9RlzZo1lvtvFgrXMKIRkOOGkNWqO6piQyfWqD47DquVMIKoFdIFbAx+uK9WRbLJelwRr8ler0f9nXSwlmF/JIYMWCGJsPUjXIDUE2SRlAw38rbanbHL1PYUF61BYubMmRg1ahSuvPJKdO7cGbNmzUKbNm0wd+5czfIPP/ww2rZti1mzZqFz58648sorccUVV2DGjBlqmVmzZmHQoEGYNGkSjjrqKEyaNAkDBgzArFmzYurKyspCSUmJujRv3ty146RwDTPRI+p1RJktIavW4aGIjeufYb/8ELAm25YmLI2cWatxr3rbgiBeo9uwUI+jkAEjgua6WsRenthgH1OQkBUmIHuSAichAnbb9LIOt6m/jQvJS33dVVVVMUt1dbVmH2pqarB69WoMHjw4Zv3gwYOxYsUKzX1WrlyZUH7IkCH45JNPcODAAcMy8XVu2LABpaWlKCsrw/nnn4+vv/7a9PmzCoVrCDGcfMCBkD1Uh3ciNqFNM/2KK6O73YaAjcFq2/HnIO74Y/qh04ekzqxO/3wRr3r9jMeoDQeDtUy3kaSsMwfXmeuavH7J9dkm9cWtlYFZfoktr8MWnB4nZ99KTps2bVBUVKQu06ZN0yy3bds21NbWori4OGZ9cXExKisrNfeprKzULH/w4EFs27bNsEx0nb169cKTTz6Jt956C4899hgqKyvRp08fbN++3fLxmoHpsEJIRJCZmnwgXgho7KOYTV8FABkZMWJQqw+aabZ0Evgn1BXdXrJ0WWa3/9pGQiotjRRPVlNoxaTPitsGIeyls7KyLaoNzckRzKTeiutnwn52JimI3xbfRjTxZY22RdWTNEVWFFbKJuuDzPRX8f2yNQWswzaJM2QOyrLaBmDfbXU7RCCVRKvdmNRkdQLAd999h8LCQnV9bm6u4X5K3L0lIUWjifLx65PVOXToUPX/3bp1Q+/evdGxY0c88cQTGD9+vGF/7UDhGmLM5myNyTMavY+O8FUyMhIuYr0cq5ZFrIkcsQm5Yd0UsE5ywBq1a3Dchnlf9fKaGm1LJpDNiEuvxWvCtkN/O8rvGk2C4NQvG1RhS9zFyo8EWSJLP9zA+o8Jv0IE0km0uk1hYWGMcNWjWbNmyMzMTHBXt27dmuCYRigpKdEsn5WVhaZNmxqW0asTAAoKCtCtWzds2LAhab/twJ/NIUQ/E4DFVFcmwgrUdRYGR2m1HVXRoUWnjO04WLPbnca/GrSrt01K6ECyuFdEb9J/HW+2DtNhA1bCG/Tqj0NayIARDkICrOD16/3EQV+p95pf6weGltAxW85S2wETVG70x3ia2fCJ1iCkw8rJyUF5eTkqKipi1ldUVKBPnz6a+/Tu3Tuh/NKlS9GzZ09kZ2cbltGrEwCqq6vxxRdfoGXLlpaOwSwUriGkXphpC0ZpQlajbGz7UeLQREysYTxsXFvxdRzqnzwB6yj+1ergLYPjNWw/els0RsLTqH6zdURjV7zq1WE33tVulgEn6bEMsDohgXFd8ULTWOh6IYRTLZdrMtxywGUNyvLSbaVoDS7jx4/H448/jvnz5+OLL77AjTfeiE2bNmHMmDEAgEmTJuHSSy9Vy48ZMwbffvstxo8fjy+++ALz58/HvHnzMHHiRLXMDTfcgKVLl+Lee+/Ff/7zH9x7771YtmwZxo0bp5aZOHEili9fjo0bN+Kjjz7C73//e1RVVWHkyJGuHCdDBUKMiH/gKcbTsuqv13i1nySkID4u1sp0rclew+vFwUoNIZAV/+ow9tV06ECyuFed19xuhw3EYDO0QbcOo21xdVgJGYjdZtQXg/OQBIYLBB8/wgSsYiv7gIO4Vrv1mq07qKLVyYQBRnVaZcSIEdi+fTvuvPNObNmyBV27dsWSJUvQrl07AMCWLVticrqWlZVhyZIluPHGG/HQQw+htLQUf/nLX3DuueeqZfr06YNFixbhf//3f3HrrbeiY8eOeP7559GrVy+1zObNm3HBBRdg27ZtaN68OU444QR8+OGHaruyUYTsiGISWKqqqlBUVIQvr/09GuVmH9qgIyQUvXg+jfLa6zT2jyunVSYhkFyrTLJ6FOPtMfvHbzNoP1nfYuqNP3/RcZ5G/TXqT/Q2o2OMbjv+s9HbFt9fRae/BscVsy3+XOm0myAYbfQvtt3YcsJkHYn90N9PGByn0bbEeozaMKg3ru74bQmiykJd2vUl2a4hshN/CCTpg0Y9Zl7vOwkBMF9OY52GcJUxW5Yst9XrAVmG21wUrbt370Lf8jLs3LnTVCyoTCLP1Atu2YCc3EZS666p3oXn7unky3EFHYYKhBDTsaqiLmY5tL9xWEF8O0bhBE5DCXSPyUoYgZUQAafxr0b91avTbuhAdLtGca9a6+P6JCVsQGcf02myTIcT2IyLtbmfvJhZiXGwHsNcrtbxyz1MNdEqoATWaSX+wFCBEBIdNxqPkpGhnwIr6uGoFVagFVJgKpzATiiBxDACSyEEdsMHDLIPmM08YDl0wOyrfaOQAplhAwb7GGYaiMZGyIBhlgErr/qjsJRhQK//SXASLpCQFstKloOQ4MRttdSOBdHlhdtqte1k9TkKH3CYUguw9tvQLYISKhAW6LiGFDMDr1Q0HFktN1arTlNtGAzqUv82mZFAb38jB9bSIC4r22S5r0bnQGMfW4O24m+SOs6pofNqYn/TjqdR32LaMVm3yYeA166rFadSpqvqdICW3w6vVWQ7dk5z5QbRbdXDrcFYckQrf4yFEQrXECKE8XSqWiP5k2YPMAgp0Grj0DproQTJwgjcFrBWt2lmH4g/1qi+xPTTbFsa+yRNmZVsffw2syEJJvY3L0pNhjTotmlDWCeUMxKdboQdWBCELlpNQU2JFeSJD9wSo7LcVrdyttqpM91Ea/xU6LIWok1w7wJpRPv27aEoSsJy7bXXAqj/0k+ZMgWlpaXIz89Hv379sG7dupg6qqurMXbsWDRr1gwFBQU488wzsXnzZlv9MZPaym7Mav3x6DuxevUb1h3X/qF2kqeriq8/amddMaYpYI3aNLPNgvuq10er4jWxPh/Ea0xdydu0Fe9qKDyjwk9M9s226HQBvxzZVCZI4lZGmIDbeB3Xmm6ilXhPcK7wNGbVqlXYsmWLukSS+Z533nkAgOnTp2PmzJmYPXs2Vq1ahZKSEgwaNAi7du1S6xg3bhwWL16MRYsW4YMPPsDu3bsxbNgw1NbW2uqTlVCBZG6sikMRG9+HhHp1tlsJIzASsLYHcMlyX/WO3454tSoy3RKvZkWgnniVHY5gtm8x7Zh0XQMWLpCQz5UY4iSbgNN2rJaV6bZabTvpNhdn3HJav1uIOoE6yQtjXPWhcPWA5s2bo6SkRF1ee+01dOzYEX379oUQArNmzcLkyZNxzjnnoGvXrnjiiSewd+9ePPvsswCAnTt3Yt68ebj//vsxcOBA9OjRA08//TTWrFmDZcuWWe6P2ckGzLqxVkWsfj1J6tUJIzhUv/kR/1YFrG6dVrIPaNUX7b5aCR1I0n78Po7FazRO6jUp0mzFu8b00aT4jdlHruvqSbiAFQL+6tHLvLWyXVlN0eux2ypzQJYfGQTMxMsGUbQS76Fw9Ziamho8/fTTuOKKK6AoCjZu3IjKykoMHjxYLZObm4u+fftixYoVAIDVq1fjwIEDMWVKS0vRtWtXtYwW1dXVqKqqilkAJIgyJ+mt7IhYK/Gw8W0n1KnRppUZr4zczaTxr+ouxuEDmustuK9afTMrkqWJVwMx5Ui82hGlTkWxZNfVdDk3hGPAxajbpFqaJDfdVj303FY7ItBP0Rpk4p+jshaiDYWrx7z88sv45ZdfcNlllwEAKisrAQDFxcUx5YqLi9VtlZWVyMnJQePGjXXLaDFt2jQUFRWpS5s2bdRtZtxULSfUSKDailuVKGDjt9sWsGbjX5O5r1HrTWceiD4ujfadxr1KE69mBZMD8Wo6ZCAavXplu65RyIgtNQoXcCtHalhiYmWKWyuTDpiu04Io8ztEwC7pLFqBQ/d4Ds7yBgpXj5k3bx6GDh2K0tLSmPXxMzLF5O3UIVmZSZMmYefOnery3Xff1e/nICxAa50tEZvEhTUbRqAiUcBGnWBVyJgNH7AU+6pVl07WASlxr5rHKEe86tZpFqvi1Y5rGoVj19XHcAHb2QxSDC/dVNn5Wx2HDrh87F6GCLgpWuug2BLnJLWhcPWQb7/9FsuWLcOVV16prispKQGABOd069atqgtbUlKCmpoa7NixQ7eMFrm5uSgsLIxZAH1X02pYgNY6o/3i61Zx4MKaEbCH6jWOO9Wt02b4gKn1WnVZyTpgoW3fxKtT11YPq26uV66r1+ECsghy30xiJnY1UFkHfHBbvQwRcFu0BoV440fWQrQJzhUcAhYsWIAWLVrg9NNPV9eVlZWhpKREzTQA1MfBLl++HH369AEAlJeXIzs7O6bMli1bsHbtWrWMHeyEBcSLNisiVpYLG99edF0qBm6l2Vf3VsIHDrWbvB1LA7eij0ej7bQSrzJDBvTQS4/l1CU2wLz4lS8cmVlAHmbDBByHDkgQZDJDBChaSdDglK8eUVdXhwULFmDkyJHIyjp02hVFwbhx4zB16lR06tQJnTp1wtSpU9GgQQNceOGFAICioiKMGjUKEyZMQNOmTdGkSRNMnDgR3bp1w8CBAy33JV7IKXFTldavUwzWxe5rtJ/eVKzJtidMjfrrw19RMjT2PfS3UT0JffhVKCiKckjcZWjVHzctq8b0sTH7RNUVaUdv2li9KWN1p4tN0icz9ccfg+Y0rlFtmVrvpM7o/uuU150S1mqdNohtO6peI0yXM9c3w+lfzbaV4thxSu2KQNkZDjQFrotuq249NkIErNaVrL50FK2RFFay6yTaULh6xLJly7Bp0yZcccUVCdtuuukm7Nu3D9dccw127NiBXr16YenSpWjUqJFa5oEHHkBWVhaGDx+Offv2YcCAAVi4cCEyMzMt9yXaqYwWexHixeihctZFbOLfycrHCWqPBKyegNSsL+KMaQi1GNFpRqSmqXgNNFF9VuoEhKRjiRG4kvspr07zxyX9eCQjKw40SJkJZMTBWg0RsCMyKVqJnyiCQ9dCQ1VVFYqKivCv4YNQmJeTsF0VSjHrEh9c8eUS/85Ist1q+ajt8duiHqxG7RjWEbUtZrBbhnbdCedE0d4W0x8zbZhoWxUyev2xWLde32MEU5L2Y8rarS++7zrlY4SUkzqj/i9M7Jsg4HTqFY73j7sGDbbptRW/LcGtM9uvhHoM2k/Wv/rKre2frLzmgCrjMlpC3MzALCdhAlbcVu39nce22hGaqSJad++uwik922Pnzp3qOA6viDxTz7r238jObZR8BwscqN6Flx/q7stxBZ3g/pwmriI37ZXV2FZz5Q+1pxEHG9lmJwbW7AAuncFTyQZvRbevYmfgllY9GpMVeBrzqrXOw3hXaZiJdbUxSCu2DTuDvOgj2EWWO+zlRAgx7brotlqtx1boAJ1W4hEUrmFEiKRiVGudTBEbv/+hv90RsMnq0BrApWIweCtqB831rorXyDHE998N8WrQdsJ6mWmy4rCcHstGCivLRItgVwd5UdTKRm6OV2duq3ad5h/RskIEZE/n6kS0Jkt3FZ/W2i/iTR9ZC9GGwjWEuJExIL5e7b+Tu7DmyloXsFr1q+gIWMvuq07e15i247ILHOqDc/Eac1yyxKtGG5YFoxYOXFfH08FaQc81dfq0lP20DcLT2wJWwwRstSEtBlb+pANO6pMxlayXg7Hs1pnMZQ3SV57C1VsoXEOMtkB1I+2VgfCM2m69rDMBq5lCK+o8HKrLPffVKGVWsjbdFK/J2rAiGB2FDNjFYl5Xx6mxTOCmG2vYrkFKLO8mLHAm9GSEAZjL8equA2ttf/OCWdardC/jWtNFtBLvYVaBEBIvRONH/x9aF/VgT5L2Ktk+RiP/rZTVSqcVsy3Sn6gsBJEBXKJOJK87av+YdFcmUmclZB5wmHUgoU07GQesZhsAYvc3aCNm/aEdNUfm69aXDCfpsXzCVvqsmP0NUl8RAPIdT6dtm+2PllizMiBLC7dDBChak1OHOtRJ/hFYxxzMutBxDSFuuKrR6+Lb0a7PSmyrsQOrVYfWRAZ6dUfvryLDfTUIHdCsI5lDatF5jarAfHsuDtbSxGrIgBVkua5mwgUkToxgliBP7+p1Gi23crxaEZBu42aIgJeDsdJNtBLvoeMaQvTEmlNX9dB27fLabql+Wb169cppThgQ7aDq5IB17L5qOKF6OVYj62P6bMIJVddbcF4t53mNYMUpteDGmnJxk2HGdU0VUiXvbQpiS4jZ/CycDMpyy22Vhczcr0b1AaktWkVdnJkgqU6iTYrd6YkstILAZTqx8eXtltXepl3OdPyqiK1X+/8W3FeDgVtRhbXrqNOoQ6LzqteHmNhWrXUyBmslqytZ1gK7jqZVF9ftJ4TTtFpRMLOAPaSlyvIpREGrXb9CBLwWrckzB/DHX9igcA0hdbVCXSJ4FRpgJDjNDKAyI3TNDOCyPHgrel8LoQN6aarMDNrSrNcF8SplsJYWMkIGkpTVzTBgE1nhAn6/xve7fZm4EXYgK0zAC7fVjxCBIIlWI4Iy61m8ESRrIdpQuIaQaDEVLWIjQtaqiJXhwmpvSy5MI39rHZsdAatXp4pWf+IzAxjVERf3qlVWqnjVOgaNp4GueNXcX0O8mskWkKwuLdx0XVOFFBChTgaTWU2FZWY2LKd9MNOun1gJEaBoJekGhWsI0ROYQKIba1fEHmrLvrNqLTQgsd34441frxU+YNp91WpHJ3RAs22vxGuS9qUM1tJap+UW2A0/0EKG62pmkJZPpHNIgNsDt2QIW7uDsoLotmqWtZFBwGpdyepLJ9EaMS9kL0QbDs4KKdEiJ37AVf26jJhQgoxM/YFUkfKR7XYHaNktZ71MVBuRfmoM3ooenJYw6Cp6v6hBR5ppreLajh8wFd/P+HRZuoPBzA7YqhOJabKi0aozGr3BWur+wlaKLM3t0XVptK9Zvx7J+mUGnb47SXmlu6/TAWYc7GUKeRMT+HOutQSfzIkGrNTjtWgNmmCNUFdXhzqtH+MO6yTa0HENIcle9devi3VW9ZzY+PJG9WvV64UDG18mus8qFt3X+P3iQwcObdeOe41qLKE/Ws5rTL2ynFcLbq6teNckzqWm66pXvxZ6rmsyZKaxSqhbJ8411O5JMMVGBFlhAl64rUEKEaBoJX5B4RpC6uqMQgH0Ray6v41Qgvj/x9drRcBq/998GbOxr0b1JQsdSBb3ale8aq1LKl7VfcyLV6N1lkIGtNbZEcFWxKbdaWADFi5AkDg1bJIwADlTxdoblGWu7tQKEaBoNUf0c1DmQrShcA0hkQsieTyrsSi148Ia1atXzs0y0X1ViRKvpgdu6YnoJOLVKOOAlni1FfNqRRTG1xddp5UYVa11dgZqyXRdZU9kEAD8yh7gVpyqbIEiQ9jKdFud4DREwE/RWgfFIH2XfdEqhCL9PJPgQ+EaUuLFoywRa1Q2elt8P4zKySxzqF0T7mukrE7oQHxdSVNm6brCcsSr1joj8WppsFZ8uZh1GsLYhliOQabrqrndebgAQwG0sSJq/Z7a1k77fritMkIENMt6JFr19zHonM32/CBicsheiDYUriEkWWYAuyLWaN/4cnp16pWzW+bQMdtwX6OFqEbogF5bScWrUZsOxGtSQZvM8TTaV0PkOg4Z0OqDQ9fV1nYrbVmsww1H1KuMA15P2xoE7GQT8MJt1WzXZPys0Xo3+wI4Cw1IFdFKvCd8dyYCUSsgamPFm1URq9Zl0YWNLqddh3NxGv1/J+6risnQATuDtrwQrzH7WhysZSm/q1ouSciAurND11UDS+ECyepKEuZgGcuTGEhuPwA4EcNW41u9ChOwW48TtzVIca1uiFYjgihao5+bMheiDYVrCKmLiKpfBaxVEau1LVHQuidgo8trbZflvtoJHTAzaEvFL/GqbjMnDG2FDFhc59i91TwWC2LPblYC4hqu53tNmPhAzqAsu8LKqUj2I67VS9HKeFYSgcI1pNTVCXUBzItYIFk4QPIwgsR9rGUOsOPQmtke30b8OjOhA5r7xNftpniNlNdaF9nXSbyri66r6XrsuK5W3FMLIjadpla1i3GcqDuxmV5gd1CWmTJmQxLMuq1BmhbWLdEaaNxwW+m46kLhGkISnFSTIlZzX5MurFUBa0ecWnFXzWzX2ydQ4jWyzWqOVxnxrlqi04HramsftzIJ/IqltFh0Yi3hbJpYZ2ECbg3KMiOw/AwRSEfRGoQfPHWizpWFaEPhGkZqBUStjhDVEbH1ZZ25sNF1RO9jVMaN8AE7+8evM4p71RS8ksRrfD/tTFAQVYlu36SEDGi5nDYcVNP7JBOZdtqOKetS6EEK4Lc4cH1wEazHw8oq4xQrIQJm9zdcHxDRmmwAF0lfKFxDyCFRWqcugL6IrS/rzIVN/L88AWtme2S92f0P7ZMkdCCyzsygrajXP3bFq2ZIhVmhajfe1aQTazlkwKzrmwyNemy9wncpzjVM4QRGcanW0mQF69EUVLfVaVxrKovWICE7TCD6eUQSCdbdgXhGgkOqI2IB5y5s/HqZAtbO9gjG7qrJ0AGr4jVqH7PiNaqBhLq0xGtCXU7iXU3U5Wiglsw6dOv2PsRAv14+jLRwIkSchgnISoElq4yXca1m+2RUh2zRmmwQVtBEK/EeCtcQEu+eGolYpy5sdP3x6+0IWPUYPHNXjerWcFJdEK9aA6esikvb8a4m60rYL6ZfElxXI0c4WblkWEmLpbVdxgQGPmHH2fTbDXU920C80HXRbZWNjLhWzbI2BkfpXVZGr/hTNTRAiEMGjrQlAPeHoELhGkJihJtJERu9n4hyYI1c2Pi2nApYo7qduK9mxa2heAV8E68x7mx8XQ7iXePbMztQK6HOZOvi27FTh9lwgWTC1unDwq6jmpZOrIEIsTA4SqZYkTFTV1DdVrfiWo3EpNE0rlbaTdZOUAUr8QcK1xCimwVAR8TWb0seShBdR30ZeQLWaLts91VvX/12jcWrUf2G4jWhD/rupFZogdN4V7shA6YdU3U/ya6ryTZsidR0dkHsjLR3YcpWS7GwDicdSDYoy47bajf9VVDjWvUIgmgNSm5XO/GrZhaiDYVrSEk6ratFFxZwT8Aal3UW25q4zlgYHyqfKF61Mg4Y1R9Pgng1cniN0mTJiHdNKGRwE9Vq71Dl+uvMClGrYlHWDT9pHKxL7m0aimPDQVtWnEK/wxRszb5lbkCWbPwYjOW1aCXhhMI1hCQND7DowsbvI1PAxu9nJnwgsR7roQPquTJZb3x5S+JVqz2L4jW+jNV416gKYvsfNNfVoLzWOtPhAmn5qt4+QYl9lTtoy3hQli1RasJtTdYvQL7b6sdgrDCL1khaRNkL0YbCNYTU1dWhLiI+DESsGRe2fr1xHGz8vmYFbPx2M+EDieusi9tk2+LrTdymL1719jcrXhPasDJYy2rIgE5bMduM6j5Ugf42qyLSC9GpJYCTuLjJBloFYSBWUJAVXpAsTEB6/ZLcVlP7uSBaZUwJ64VoTTZ4K2iiFai//UWP+5Cz+H1UwYXCNYSIgwLigFAFbDIRC8QJuahyMUJXJw7WjoBNaNNE+IBWnXr7JhOheu5osm2H6tQWr4YhCxriKF4YagpMo8FaevWYCRkwEomGQtWE62p54JaEcAFZca4hw57raU9cyMoDm7SdgLutsgmSaDUSn6nkshL/oHANIXUHfxUWB+oFLABdEQvIc2HNCtiEukyEDySWcyZCY9eZ3yZLvMa0pSNeTQ3WMhCYptxSo5ABK/VYdV3V3VwKF3CCh2JXCVgIg9uuplv1WnV5k7mtstJfeREiICPtlUzRqtu2TdEahJ+ettJdmViINhSuIaXuoFCXiIDVErFWXdiEMnECtr7+ZJMZWAsf0C+nH7/qZFsEL8Wrip54tRLvaiZkwMxALTdc1/g2tJARLmC2DluZB5L0JWBi1G3sil1DIeNymIBVpKXI8ki0WgkxoGglQYPCNYQkCNVfBazmtiQuLGBNwMaIUgMBG1+vLPfV6bb49mSJV92yBq/2E/YxEouRsiZCBqIq1uyLmXoN69PClJiVEC4gm5CJ0Ghkp8JyK0zA6qAsP93WxHq8GYwVRNGaLJ41SKI1+k2kzIVoQ+EaQvSEarQLG70NkCtg48vGC9j67cnDBxLaTOK+JpY3EpvG4tVomx3xqnmT0hOvduJdrYhZM6/unbquhyrU3xbfptn9rYpfsyEHfJDoYlZYepH31etk9YlCN3n6K7MhAjL7pbsuoKJVjzoES7QS76FwDSHiYKzTqilU9cStThiBFQFrlEYrfh9Z7mv8Njtxr16JV8PYVQvxrof2tRAyEL+P0UCt+H2suK5G9Yk4cayFRRHp26j+UA7+MifArIQCmN2WvE333dbENoMRImDlvLktWu1O+xrUq4npsLyFwjWECK24VkkurFkBW7/O3AAup+6r3jYnIQBm64v+Owaz4tVIoCWJdzUV3G9BzEaQ7rqqfTEhRu3Gxdptz2U8F9RRjmeMU6m33iFex546HZTluL0AhAg4zSDghWjVIxVFK/EeCteQYkuoShSwVgdw1W/THryV0IbF0IHof4222QkpSFyv4aaaFK9O4l11XVcDXHNdI8TXr13hr0Ucxs6axewALS+yF0jCbi7R+n3dEbQJ7diMb3UU+xpgt9VMPW5kEAiiaE0WGhCENFmMcfUWCtcQ4lioShKwgLn41+j66rebc18jZY1CB+L3seOi2havBjcm0+LVRFxqAnp1uOW6JuxjQuCZKWMm3MBu3cQQO06m2X1khQkkG5TlFBluq1PxaQazotcv0Wo0CCuZYA2CaAWiTRWmw/KCLL87QLwjIkx219SiThHIyFaAmvptSrYCHPj1/1mH1gOAUnfo5pDx6/+VqH0zshSgOmrf2tr69RkZQC2gZCpA7a9lo/6v1P5a16/rMjIU4OCvGzN/3ZYR1XaGAhz8tTwAJePQg0L5dVtGRuJ+SkZU+QO/9iF+fULZX/dX4svG7pNQ3mCbosSv/7VddbtxW9BqI/IwiK8r8rei3d/4NiP7K9EP+7j+Rv7Wa0OzjoTzGDnXiccUX7/6d8K+0WXj/o7uT3x9iHboDNqP3z9qnTAqH12/xnlM+mo+RmhlRG1XNPYxfuUfvS5GUGn0S7c/iHdcTbRfX5l2XdH7GKSzsrQNRvvBdNn4uNxkbqv263jj+FnNAVkmZueSHSKgJ0S1B4xpl9WLY7YjWvUw67Lu2bPr13X+OZS1B/ekRJ3pAoVriNi+fTsA4HKxERBQxSYQ939CCCEkhdi1axeKioo8bTMnJwclJSX45B/DXam/pKQEOTk5rtSdyijCz58pxFN++eUXNG7cGJs2bfL8AveaqqoqtGnTBt999x0KCwv97o7rhOl4eazpSZiOFQjX8bp5rEII7Nq1C6WlpfVv+Txm//79qKmpSV7QBjk5OcjLy3Ol7lSGjmuIiFzURUVFaX+jjFBYWBiaYwXCdbw81vQkTMcKhOt43TpWP42YvLw8ikuP4eAsQgghhBCSElC4EkIIIYSQlIDCNUTk5ubi9ttvR25urt9dcZ0wHSsQruPlsaYnYTpWIFzHG6ZjJe7DwVmEEEIIISQloONKCCGEEEJSAgpXQgghhBCSElC4EkIIIYSQlIDClRBCCCGEpAQUriFizpw5KCsrQ15eHsrLy/H+++/73SXLvPfeezjjjDNQWloKRVHw8ssvx2wXQmDKlCkoLS1Ffn4++vXrh3Xr1sWUqa6uxtixY9GsWTMUFBTgzDPPxObNmz08iuRMmzYNxx9/PBo1aoQWLVrgrLPOwpdffhlTJl2OFQDmzp2L7t27qwnKe/fujTfeeEPdnk7HGs20adOgKArGjRunrkunY50yZQoURYlZSkpK1O3pdKwA8P333+Piiy9G06ZN0aBBAxx77LFYvXq1uj2djrd9+/YJn62iKLj22msBpNexkoAhSChYtGiRyM7OFo899phYv369uOGGG0RBQYH49ttv/e6aJZYsWSImT54sXnzxRQFALF68OGb7PffcIxo1aiRefPFFsWbNGjFixAjRsmVLUVVVpZYZM2aMaNWqlaioqBD/+te/RP/+/cUxxxwjDh486PHR6DNkyBCxYMECsXbtWvHZZ5+J008/XbRt21bs3r1bLZMuxyqEEK+88op4/fXXxZdffim+/PJL8cc//lFkZ2eLtWvXCiHS61gjfPzxx6J9+/aie/fu4oYbblDXp9Ox3n777eLoo48WW7ZsUZetW7eq29PpWH/++WfRrl07cdlll4mPPvpIbNy4USxbtkx89dVXapl0Ot6tW7fGfK4VFRUCgHjnnXeEEOl1rCRYULiGhN/85jdizJgxMeuOOuooccstt/jUI+fEC9e6ujpRUlIi7rnnHnXd/v37RVFRkXj44YeFEEL88ssvIjs7WyxatEgt8/3334uMjAzx5ptvetZ3q2zdulUAEMuXLxdCpPexRmjcuLF4/PHH0/JYd+3aJTp16iQqKipE3759VeGabsd6++23i2OOOUZzW7od68033yxOOukk3e3pdrzx3HDDDaJjx46irq4u7Y+V+AtDBUJATU0NVq9ejcGDB8esHzx4MFasWOFTr+SzceNGVFZWxhxnbm4u+vbtqx7n6tWrceDAgZgypaWl6Nq1a6DPxc6dOwEATZo0AZDex1pbW4tFixZhz5496N27d1oe67XXXovTTz8dAwcOjFmfjse6YcMGlJaWoqysDOeffz6+/vprAOl3rK+88gp69uyJ8847Dy1atECPHj3w2GOPqdvT7XijqampwdNPP40rrrgCiqKk9bES/6FwDQHbtm1DbW0tiouLY9YXFxejsrLSp17JJ3IsRsdZWVmJnJwcNG7cWLdM0BBCYPz48TjppJPQtWtXAOl5rGvWrEHDhg2Rm5uLMWPGYPHixejSpUvaHeuiRYvwr3/9C9OmTUvYlm7H2qtXLzz55JN466238Nhjj6GyshJ9+vTB9u3b0+5Yv/76a8ydOxedOnXCW2+9hTFjxuD666/Hk08+CSD9PttoXn75Zfzyyy+47LLLAKT3sRL/yfK7A8Q7FEWJ+VsIkbAuHbBznEE+F9dddx3+/e9/44MPPkjYlk7HeuSRR+Kzzz7DL7/8ghdffBEjR47E8uXL1e3pcKzfffcdbrjhBixduhR5eXm65dLhWAFg6NCh6v+7deuG3r17o2PHjnjiiSdwwgknAEifY62rq0PPnj0xdepUAECPHj2wbt06zJ07F5deeqlaLl2ON5p58+Zh6NChKC0tjVmfjsdK/IeOawho1qwZMjMzE37Fbt26NeEXcSoTGa1sdJwlJSWoqanBjh07dMsEibFjx+KVV17BO++8g9atW6vr0/FYc3JycPjhh6Nnz56YNm0ajjnmGPz5z39Oq2NdvXo1tm7divLycmRlZSErKwvLly/HX/7yF2RlZal9TYdj1aKgoADdunXDhg0b0upzBYCWLVuiS5cuMes6d+6MTZs2AUjPaxYAvv32WyxbtgxXXnmlui5dj5UEAwrXEJCTk4Py8nJUVFTErK+oqECfPn186pV8ysrKUFJSEnOcNTU1WL58uXqc5eXlyM7OjimzZcsWrF27NlDnQgiB6667Di+99BLefvttlJWVxWxPp2PVQwiB6urqtDrWAQMGYM2aNfjss8/UpWfPnrjooovw2WefoUOHDmlzrFpUV1fjiy++QMuWLdPqcwWAE088MSFl3X//+1+0a9cOQPpeswsWLECLFi1w+umnq+vS9VhJQPB6NBjxh0g6rHnz5on169eLcePGiYKCAvHNN9/43TVL7Nq1S3z66afi008/FQDEzJkzxaeffqqm9brnnntEUVGReOmll8SaNWvEBRdcoJmCpXXr1mLZsmXiX//6lzjllFMCl4Ll6quvFkVFReLdd9+NSTmzd+9etUy6HKsQQkyaNEm89957YuPGjeLf//63+OMf/ygyMjLE0qVLhRDpdazxRGcVECK9jnXChAni3XffFV9//bX48MMPxbBhw0SjRo3U+046HevHH38ssrKyxN133y02bNggnnnmGdGgQQPx9NNPq2XS6XiFEKK2tla0bdtW3HzzzQnb0u1YSXCgcA0RDz30kGjXrp3IyckRxx13nJpaKZV45513BICEZeTIkUKI+pQzt99+uygpKRG5ubnit7/9rVizZk1MHfv27RPXXXedaNKkicjPzxfDhg0TmzZt8uFo9NE6RgBiwYIFapl0OVYhhLjiiivU72bz5s3FgAEDVNEqRHodazzxwjWdjjWSuzM7O1uUlpaKc845R6xbt07dnk7HKoQQr776qujatavIzc0VRx11lHj00Udjtqfb8b711lsCgPjyyy8TtqXbsZLgoAghhC9WLyGEEEIIIRZgjCshhBBCCEkJKFwJIYQQQkhKQOFKCCGEEEJSAgpXQgghhBCSElC4EkIIIYSQlIDClRBCCCGEpAQUroQQQgghJCWgcCWEEEIIISkBhSshhBBCCEkJKFwJIYQQQkhKQOFKCCGEEEJSAgpXQgghhBCSEvw/YpP/hTI7cnMAAAAASUVORK5CYII=", + "image/png": "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", "text/plain": [ "
    " ] @@ -780,17 +2006,17 @@ } ], "source": [ - "angle_diff = hgrid[\"angle_dx\"][kp2::k,kp2::k].values - hgrid[\"angle_dx_mom6\"].values\n", + "angle_diff = hgrid[\"angle_dx\"] - hgrid[\"angle_dx_rm6\"]\n", "plt.figure(figsize=(8, 6))\n", - "plt.imshow(angle_diff,cmap='coolwarm')\n", + "plt.imshow(angle_diff)\n", "plt.colorbar()\n", "plt.title(\"Difference between caluculated MOM6 angle and angle_dx from Hgrid angle_dx\")\n", - "plt.show()" + "plt.show() " ] }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "metadata": {}, "outputs": [ { @@ -878,7 +2104,7 @@ ".xr-sections {\n", " padding-left: 0 !important;\n", " display: grid;\n", - " grid-template-columns: 150px auto auto 1fr 20px 20px;\n", + " grid-template-columns: 150px auto auto 1fr 0 20px 0 20px;\n", "}\n", "\n", ".xr-section-item {\n", @@ -886,7 +2112,8 @@ "}\n", "\n", ".xr-section-item input {\n", - " display: none;\n", + " display: inline-block;\n", + " opacity: 0;\n", "}\n", "\n", ".xr-section-item input + label {\n", @@ -898,6 +2125,10 @@ " color: var(--xr-font-color2);\n", "}\n", "\n", + ".xr-section-item input:focus + label {\n", + " border: 2px solid var(--xr-font-color0);\n", + "}\n", + "\n", ".xr-section-item input:enabled + label:hover {\n", " color: var(--xr-font-color0);\n", "}\n", @@ -1160,83 +2391,65 @@ " stroke: currentColor;\n", " fill: currentColor;\n", "}\n", - "
    <xarray.Dataset> Size: 129MB\n",
-       "Dimensions:        (nyp: 1561, nxp: 1481, ny: 1560, nx: 1480)\n",
-       "Dimensions without coordinates: nyp, nxp, ny, nx\n",
-       "Data variables:\n",
-       "    tile           |S255 255B ...\n",
-       "    y              (nyp, nxp) float64 18MB ...\n",
-       "    x              (nyp, nxp) float64 18MB -98.0 -97.96 -97.92 ... -37.49 -37.45\n",
-       "    dy             (ny, nxp) float64 18MB ...\n",
-       "    dx             (nyp, nx) float64 18MB ...\n",
-       "    area           (ny, nx) float64 18MB ...\n",
-       "    angle_dx       (nyp, nxp) float64 18MB ...\n",
-       "    angle_dx_mom6  (nyp, nxp) float64 18MB 0.0 0.0 0.0 0.0 ... 4.414 4.397 4.38\n",
-       "Attributes:\n",
-       "    file_name:    ocean_hgrid.nc\n",
-       "    Description:  MOM6 NCAR NWA12\n",
-       "    Author:       Fred Castruccio (fredc@ucar.edu)\n",
-       "    Created:      2024-04-18T08:39:49.607481\n",
-       "    type:         MOM6 supergrid file
    " + " [0.02399983, 0.02397845, 0.02397953, ..., 0.01129944, 0.01130202,\n", + " 0.01129223],\n", + " [0.02400675, 0.02398527, 0.02398634, ..., 0.01128624, 0.01128885,\n", + " 0.01127906],\n", + " [0.0240375 , 0.02401598, 0.02401707, ..., 0.01128954, 0.01129214,\n", + " 0.01128232]])
        • " ], "text/plain": [ - " Size: 129MB\n", - "Dimensions: (nyp: 1561, nxp: 1481, ny: 1560, nx: 1480)\n", - "Dimensions without coordinates: nyp, nxp, ny, nx\n", - "Data variables:\n", - " tile |S255 255B ...\n", - " y (nyp, nxp) float64 18MB ...\n", - " x (nyp, nxp) float64 18MB -98.0 -97.96 -97.92 ... -37.49 -37.45\n", - " dy (ny, nxp) float64 18MB ...\n", - " dx (nyp, nx) float64 18MB ...\n", - " area (ny, nx) float64 18MB ...\n", - " angle_dx (nyp, nxp) float64 18MB ...\n", - " angle_dx_mom6 (nyp, nxp) float64 18MB 0.0 0.0 0.0 0.0 ... 4.414 4.397 4.38\n", - "Attributes:\n", - " file_name: ocean_hgrid.nc\n", - " Description: MOM6 NCAR NWA12\n", - " Author: Fred Castruccio (fredc@ucar.edu)\n", - " Created: 2024-04-18T08:39:49.607481\n", - " type: MOM6 supergrid file" + " Size: 17MB\n", + "array([[0.0018886 , 0.0018886 , 0.0018886 , ..., 0.0018886 , 0.0018886 ,\n", + " 0.0018886 ],\n", + " [0.00190363, 0.00190363, 0.00190363, ..., 0.00190363, 0.00190363,\n", + " 0.00190363],\n", + " [0.00191865, 0.00191865, 0.00191865, ..., 0.00191865, 0.00191865,\n", + " 0.00191865],\n", + " ...,\n", + " [0.02399983, 0.02397845, 0.02397953, ..., 0.01129944, 0.01130202,\n", + " 0.01129223],\n", + " [0.02400675, 0.02398527, 0.02398634, ..., 0.01128624, 0.01128885,\n", + " 0.01127906],\n", + " [0.0240375 , 0.02401598, 0.02401707, ..., 0.01128954, 0.01129214,\n", + " 0.01128232]])\n", + "Dimensions without coordinates: nyp, nxp" ] }, - "execution_count": 13, + "execution_count": 86, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "hgrid" + "# Looks like the interpolation is working reasonably except in the boundaries, we need to choose a specific angle" ] } ], "metadata": { "kernelspec": { - "display_name": "crr_dev", + "display_name": "CrocoDashDev", "language": "python", "name": "python3" }, From b89c461f5db22849436433cfb4a1804468469d2d Mon Sep 17 00:00:00 2001 From: manishvenu Date: Wed, 20 Nov 2024 16:14:20 -0700 Subject: [PATCH 14/87] Keith Method Step 1, add t-point boundaries to coords() --- regional_mom6/regridding.py | 61 ++++++++++++++++++++++++++++--------- 1 file changed, 47 insertions(+), 14 deletions(-) diff --git a/regional_mom6/regridding.py b/regional_mom6/regridding.py index 05490b43..a6587569 100644 --- a/regional_mom6/regridding.py +++ b/regional_mom6/regridding.py @@ -36,15 +36,18 @@ regridding_logger = setup_logger(__name__) -def coords(hgrid: xr.Dataset, orientation: str, segment_name: str) -> xr.Dataset: +def coords( + hgrid: xr.Dataset, orientation: str, segment_name: str, coords_at_t_points=False +) -> xr.Dataset: """ This function: - Allows us to call the self.coords for use in the xesmf.Regridder in the regrid_tides function. self.coords gives us the subset of the hgrid based on the orientation. + Allows us to call the coords for use in the xesmf.Regridder in the regrid_tides function. self.coords gives us the subset of the hgrid based on the orientation. Args: hgrid (xr.Dataset): The hgrid dataset orientation (str): The orientation of the boundary segment_name (str): The name of the segment + coords_at_t_points (bool, optional): Whether to return the boundary t-points instead of the q/u/v of a general boundary for rotation. Defaults to False. Returns: xr.Dataset: The correct coordinate space for the orientation @@ -57,13 +60,43 @@ def coords(hgrid: xr.Dataset, orientation: str, segment_name: str) -> xr.Dataset Web Address: https://github.com/jsimkins2/nwa25 """ + + dataset_to_get_coords = None + + if coords_at_t_points: + regridding_logger.info("Creating (fake) coordinates of the boundary t-points") + + # Calc T Point Info + k = 2 + kp2 = k // 2 + offset_one_by_two_y = slice(kp2, len(hgrid.x.nyp), k) + offset_one_by_two_x = slice(kp2, len(hgrid.x.nxp), k) + t_points = (offset_one_by_two_y, offset_one_by_two_x) + + # Subset the hgrid to the t-points + tlon = hgrid.x[t_points] + tlat = hgrid.y[t_points] + tangle_dx = hgrid["angle_dx"][t_points] + + # Assign to dataset + dataset_to_get_coords = xr.Dataset() + dataset_to_get_coords["x"] = tlon + dataset_to_get_coords["y"] = tlat + dataset_to_get_coords["angle_dx"] = tangle_dx + else: + regridding_logger.info( + "Creating (actual) coordinates of the boundary q/u/v points" + ) + # Don't have to do anything because this is the actual boundary. t-points are one-index deep and require managing. + dataset_to_get_coords = hgrid + # Rename nxp and nyp to locations if orientation == "south": rcoord = xr.Dataset( { - "lon": hgrid["x"].isel(nyp=0), - "lat": hgrid["y"].isel(nyp=0), - "angle": hgrid["angle_dx"].isel(nyp=0), + "lon": dataset_to_get_coords["x"].isel(nyp=0), + "lat": dataset_to_get_coords["y"].isel(nyp=0), + "angle": dataset_to_get_coords["angle_dx"].isel(nyp=0), } ) rcoord = rcoord.rename_dims({"nxp": f"nx_{segment_name}"}) @@ -75,9 +108,9 @@ def coords(hgrid: xr.Dataset, orientation: str, segment_name: str) -> xr.Dataset elif orientation == "north": rcoord = xr.Dataset( { - "lon": hgrid["x"].isel(nyp=-1), - "lat": hgrid["y"].isel(nyp=-1), - "angle": hgrid["angle_dx"].isel(nyp=-1), + "lon": dataset_to_get_coords["x"].isel(nyp=-1), + "lat": dataset_to_get_coords["y"].isel(nyp=-1), + "angle": dataset_to_get_coords["angle_dx"].isel(nyp=-1), } ) rcoord = rcoord.rename_dims({"nxp": f"nx_{segment_name}"}) @@ -87,9 +120,9 @@ def coords(hgrid: xr.Dataset, orientation: str, segment_name: str) -> xr.Dataset elif orientation == "west": rcoord = xr.Dataset( { - "lon": hgrid["x"].isel(nxp=0), - "lat": hgrid["y"].isel(nxp=0), - "angle": hgrid["angle_dx"].isel(nxp=0), + "lon": dataset_to_get_coords["x"].isel(nxp=0), + "lat": dataset_to_get_coords["y"].isel(nxp=0), + "angle": dataset_to_get_coords["angle_dx"].isel(nxp=0), } ) rcoord = rcoord.rename_dims({"nyp": f"ny_{segment_name}"}) @@ -99,9 +132,9 @@ def coords(hgrid: xr.Dataset, orientation: str, segment_name: str) -> xr.Dataset elif orientation == "east": rcoord = xr.Dataset( { - "lon": hgrid["x"].isel(nxp=-1), - "lat": hgrid["y"].isel(nxp=-1), - "angle": hgrid["angle_dx"].isel(nxp=-1), + "lon": dataset_to_get_coords["x"].isel(nxp=-1), + "lat": dataset_to_get_coords["y"].isel(nxp=-1), + "angle": dataset_to_get_coords["angle_dx"].isel(nxp=-1), } ) rcoord = rcoord.rename_dims({"nyp": f"ny_{segment_name}"}) From 783addd23389000b849640692c01f4a4b0a60ea5 Mon Sep 17 00:00:00 2001 From: manishvenu Date: Thu, 21 Nov 2024 11:16:15 -0700 Subject: [PATCH 15/87] Start implementing alternative angles approaches... --- regional_mom6/regridding.py | 159 +++++++++++++++++++++++++----------- 1 file changed, 110 insertions(+), 49 deletions(-) diff --git a/regional_mom6/regridding.py b/regional_mom6/regridding.py index a6587569..27777404 100644 --- a/regional_mom6/regridding.py +++ b/regional_mom6/regridding.py @@ -32,6 +32,23 @@ import netCDF4 from .utils import setup_logger +# An Enum is like a dropdown selection for a menu, it essentially limits the type of input parameters. It comes with additional complexity, which of course is always a challenge. +from enum import Enum + + +class RotationMethod(Enum): + """ + This Enum defines the rotational method to be used in boundary conditions. The main regional mom6 class passes in this enum to regrid_tides and regrid_velocity_tracers to determine the method used. + + KEITH_DOUBLE_REGRIDDING: This method is used to regrid the boundary conditions to the t-points, b/c we can calculate t-point angle the same way as MOM6, rotate the conditions, and regrid again to the q-u-v, or actual, boundary + FRED_AVERAGE: This method is used with the basis that we can find the angles at the q-u-v points by pretending we have another row/column of the hgrid with the same distances as the t-point to u/v points in the actual grid then use the four poitns to calculate the angle the exact same way MOM6 does. + GIVEN_ANGLE: This is the original default RM6 method which expects a pre-given angle called angle_dx + """ + + KEITH_DOUBLE_REGRIDDING = 1 + FRED_AVERAGE = 2 + GIVEN_ANGLE = 3 + regridding_logger = setup_logger(__name__) @@ -64,29 +81,23 @@ def coords( dataset_to_get_coords = None if coords_at_t_points: - regridding_logger.info("Creating (fake) coordinates of the boundary t-points") + regridding_logger.info("Creating coordinates of the boundary t-points") # Calc T Point Info - k = 2 - kp2 = k // 2 - offset_one_by_two_y = slice(kp2, len(hgrid.x.nyp), k) - offset_one_by_two_x = slice(kp2, len(hgrid.x.nxp), k) - t_points = (offset_one_by_two_y, offset_one_by_two_x) - - # Subset the hgrid to the t-points - tlon = hgrid.x[t_points] - tlat = hgrid.y[t_points] - tangle_dx = hgrid["angle_dx"][t_points] + ds = get_hgrid_arakawa_c_points(hgrid, "t") + tangle_dx = hgrid["angle_dx"][(ds.t_points_y, ds.t_points_x)] # Assign to dataset - dataset_to_get_coords = xr.Dataset() - dataset_to_get_coords["x"] = tlon - dataset_to_get_coords["y"] = tlat - dataset_to_get_coords["angle_dx"] = tangle_dx - else: - regridding_logger.info( - "Creating (actual) coordinates of the boundary q/u/v points" + dataset_to_get_coords = xr.Dataset( + { + "x": ds.tlon, + "y": ds.tlat, + "angle_dx": (("nyp", "nxp"), tangle_dx.values), + }, + coords={"nyp": ds.nyp, "nxp": ds.nxp}, ) + else: + regridding_logger.info("Creating coordinates of the boundary q/u/v points") # Don't have to do anything because this is the actual boundary. t-points are one-index deep and require managing. dataset_to_get_coords = hgrid @@ -445,8 +456,8 @@ def initialize_grid_rotation_angle(hgrid: xr.Dataset) -> xr.Dataset: The hgrid dataset Returns ------- - xr.Dataset - The dataset with the mom6_angle_dx variable added + xr.DataArray + The t-point angles """ regridding_logger.info("Initializing grid rotation angle") # Direct Translation @@ -461,48 +472,98 @@ def initialize_grid_rotation_angle(hgrid: xr.Dataset) -> xr.Dataset: regridding_logger.info("This is a regional case") len_lon = G_len_lon - angles_arr = np.zeros((len(hgrid.nyp), len(hgrid.nxp))) + angles_arr_v2 = np.zeros((len(tlon.nyp), len(tlon.nxp))) # Compute lonB for all points - lonB = np.zeros((2, 2, len(hgrid.nyp) - 2, len(hgrid.nxp) - 2)) - - # Vectorized Compute lonB - Fortran is 1-indexed, so we need to subtract 1 from the indices in lonB[m-1,n-1] - for n in np.arange(1, 3): - for m in np.arange(1, 3): - lonB[m - 1, n - 1] = modulo_around_point( - hgrid.x[ - np.arange((m - 2 + 1), (m - 2 + len(hgrid.nyp) - 1)), - np.arange((n - 2 + 1), (n - 2 + len(hgrid.nxp) - 1)), + lonB = np.zeros((2, 2, len(tlon.nyp), len(tlon.nxp))) + + # Vectorized computation of lonB + for n in np.arange(0, 2): + for m in np.arange(0, 2): + lonB[m, n] = modulo_around_point( + qlon[ + np.arange(m, (m - 1 + len(qlon.nyp))), + np.arange(n, (n - 1 + len(qlon.nxp))), ], - hgrid.x[1:-1, 1:-1], + tlon, len_lon, ) - # Vectorized Compute lon_scale + # Compute lon_scale lon_scale = np.cos( pi_720deg - * ( - (hgrid.y[0:-2, 0:-2] + hgrid.y[1:-1, 1:-1]) - + (hgrid.y[1:-1, 0:-2] + hgrid.y[0:-2, 1:-1]) - ) + * ((qlat[0:-1, 0:-1] + qlat[1:, 1:]) + (qlat[1:, 0:-1] + qlat[0:-1, 1:])) ) - # Vectorized Compute angle + # Compute angle angle = np.arctan2( lon_scale * ((lonB[0, 1] - lonB[1, 0]) + (lonB[1, 1] - lonB[0, 0])), - (hgrid.y[0:-2, 1:-1] - hgrid.y[1:-1, 0:-2]) - + (hgrid.y[1:-1, 1:-1] - hgrid.y[0:-2, 0:-2]), + (qlat[:-1, :-1] - qlat[1:, 1:]) + (qlat[1:, 0:-1] - qlat[0:-1, 1:]), ) - # Assign angle to angles_arr - angles_arr[1:-1, 1:-1] = 90 - np.rad2deg(angle) + angles_arr_v2 = np.rad2deg(angle) - 90 # Assign angles_arr to hgrid - hgrid["angle_dx_mom6"] = (("nyp", "nxp"), angles_arr) - hgrid["angle_dx_mom6"].attrs["_FillValue"] = np.nan - hgrid["angle_dx_mom6"].attrs["units"] = "deg" - hgrid["angle_dx_mom6"].attrs[ - "description" - ] = "MOM6 calculates angles internally, this field replicates that for rotating boundary conditions. Use this over other angle fields for MOM6 applications" - - return hgrid + t_angles = xr.DataArray( + angles_arr_v2, + dims=["qy", "qx"], + coords={ + "qy": tlon.nyp.values, + "qx": tlon.nxp.values, + }, + ) + return t_angles + + +def get_hgrid_arakawa_c_points(hgrid: xr.Dataset, point_type="t") -> xr.Dataset: + """ + Get the Arakawa C points from the Hgrid, originally written by Fred (Castruccio) and moved to RM6 + Parameters + ---------- + hgrid: xr.Dataset + The hgrid dataset + Returns + ------- + xr.Dataset + The specific points x, y, & point indexes + """ + if point_type not in "uvqt": + raise ValueError("point_type must be one of 'uvqt'") + + regridding_logger.info("Getting {} points..".format(point_type)) + + # Figure out the maths for the offset + k = 2 + kp2 = k // 2 + offset_one_by_two_y = np.arange(kp2, len(hgrid.x.nyp), k) + offset_one_by_two_x = np.arange(kp2, len(hgrid.x.nxp), k) + by_two_x = np.arange(0, len(hgrid.x.nxp), k) + by_two_y = np.arange(0, len(hgrid.x.nyp), k) + + # T point locations + if point_type == "t": + points = (offset_one_by_two_y, offset_one_by_two_x) + # U point locations + elif point_type == "u": + points = (offset_one_by_two_y, by_two_x) + # V point locations + elif point_type == "v": + points = (by_two_y, offset_one_by_two_x) + # Corner point locations + elif point_type == "q": + points = (by_two_y, by_two_x) + else: + raise ValueError("Invalid Point Type (u, v, q, or t only)") + + point_dataset = xr.Dataset( + { + "{}lon".format(point_type): hgrid.x[points], + "{}lat".format(point_type): hgrid.y[points], + "{}_points_y".format(point_type): points[0], + "{}_points_x".format(point_type): points[1], + } + ) + point_dataset.attrs["description"] = ( + "Arakawa C {}-points of supplied h-grid".format(point_type) + ) + return point_dataset From 567288e4ca025d4ad67aba1d3cec19429ac0d970 Mon Sep 17 00:00:00 2001 From: manishvenu Date: Thu, 21 Nov 2024 11:38:50 -0700 Subject: [PATCH 16/87] Set up rotational method framework --- regional_mom6/regional_mom6.py | 65 +++++++++++++++++++++++++--------- regional_mom6/regridding.py | 2 ++ 2 files changed, 50 insertions(+), 17 deletions(-) diff --git a/regional_mom6/regional_mom6.py b/regional_mom6/regional_mom6.py index 4b621e18..cfeb71fb 100644 --- a/regional_mom6/regional_mom6.py +++ b/regional_mom6/regional_mom6.py @@ -2993,7 +2993,7 @@ def coords(self): return rcoord - def rotate(self, u, v): + def rotate(self, u, v, radian_angle): # Make docstring """ @@ -3002,19 +3002,23 @@ def rotate(self, u, v): Args: u (xarray.DataArray): The u-component of the velocity. v (xarray.DataArray): The v-component of the velocity. + radian_angle (xarray.DataArray): The angle of the grid in RADIANS Returns: Tuple[xarray.DataArray, xarray.DataArray]: The rotated u and v components of the velocity. """ - angle = self.coords.angle.values * np.pi / 180 - u_rot = u * np.cos(angle) - v * np.sin(angle) - v_rot = u * np.sin(angle) + v * np.cos(angle) + u_rot = u * np.cos(radian_angle) - v * np.sin(radian_angle) + v_rot = u * np.sin(radian_angle) + v * np.cos(radian_angle) return u_rot, v_rot - def regrid_velocity_tracers(self): + def regrid_velocity_tracers(self, rotational_method=rgd.RotationMethod.GIVEN_ANGLE): """ Cut out and interpolate the velocities and tracers + Paramaters + ---------- + rotational_method: rgd.RotationMethod + The method to use for rotation of the velocities. Currently, the default method, GIVEN_ANGLE, works even with non-rotated grids """ rawseg = xr.open_dataset(self.infile, decode_times=False, engine="netcdf4") @@ -3036,7 +3040,14 @@ def regrid_velocity_tracers(self): [self.u, self.v, self.eta] + [self.tracers[i] for i in self.tracers] ] ) - rotated_u, rotated_v = self.rotate(regridded[self.u], regridded[self.v]) + if rotational_method == rgd.RotationMethod.GIVEN_ANGLE: + rotated_u, rotated_v = self.rotate( + regridded[self.u], + regridded[self.v], + radian_angle=self.coords.angle.values * np.pi / 180, + ) + elif rotational_method == rgd.RotationMethod.NO_ROTATION: + rotated_u, rotated_v = regridded[self.u], regridded[self.v] rotated_ds = xr.Dataset( { self.u: rotated_u, @@ -3063,10 +3074,17 @@ def regrid_velocity_tracers(self): velocities_out = regridder_velocity( rawseg[[self.u, self.v]].rename({self.xq: "lon", self.yq: "lat"}) ) - - velocities_out["u"], velocities_out["v"] = self.rotate( - velocities_out["u"], velocities_out["v"] - ) + if rotational_method == rgd.RotationMethod.GIVEN_ANGLE: + velocities_out["u"], velocities_out["v"] = self.rotate( + velocities_out["u"], + velocities_out["v"], + radian_angle=self.coords.angle.values * np.pi / 180, + ) + elif rotational_method == rgd.RotationMethod.NO_ROTATION: + velocities_out["u"], velocities_out["v"] = ( + velocities_out["u"], + velocities_out["v"], + ) segment_out = xr.merge( [ @@ -3104,8 +3122,14 @@ def regrid_velocity_tracers(self): regridded_u = regridder_uvelocity(rawseg[[self.u]]) regridded_v = regridder_vvelocity(rawseg[[self.v]]) - - rotated_u, rotated_v = self.rotate(regridded_u[self.u], regridded_v[self.v]) + if rotational_method == rgd.RotationMethod.GIVEN_ANGLE: + rotated_u, rotated_v = self.rotate( + regridded[self.u], + regridded[self.v], + radian_angle=self.coords.angle.values * np.pi / 180, + ) + elif rotational_method == rgd.RotationMethod.NO_ROTATION: + rotated_u, rotated_v = regridded[self.u], regridded[self.v] rotated_ds = xr.Dataset( { self.u: rotated_u, @@ -3222,7 +3246,14 @@ def regrid_velocity_tracers(self): return segment_out, encoding_dict def regrid_tides( - self, tpxo_v, tpxo_u, tpxo_h, times, method="nearest_s2d", periodic=False + self, + tpxo_v, + tpxo_u, + tpxo_h, + times, + rotational_method=rgd.RotationMethod.GIVEN_ANGLE, + method="nearest_s2d", + periodic=False, ): """ This function: @@ -3236,6 +3267,7 @@ def regrid_tides( infile_td (str): Raw Tidal File/Dir tpxo_v, tpxo_u, tpxo_h (xarray.Dataset): Specific adjusted for MOM6 tpxo datasets (Adjusted with setup_tides) times (pd.DateRange): The start date of our model period + rotational_method (rgd.RotationMethod): The method to use for rotation of the velocities. Currently, the default method, GIVEN_ANGLE, works even with non-rotated grids Returns: *.nc files: Regridded tidal velocity and elevation files in 'inputdir/forcing' @@ -3338,14 +3370,13 @@ def regrid_tides( ucplex = uredest + 1j * uimdest vcplex = vredest + 1j * vimdest - angle = coords["angle"] # Fred's grid is in degrees - # Convert complex u and v to ellipse, # rotate ellipse from earth-relative to model-relative, # and convert ellipse back to amplitude and phase. SEMA, ECC, INC, PHA = ap2ep(ucplex, vcplex) - - INC -= np.radians(angle.data[np.newaxis, :]) + if rotational_method == rgd.RotationMethod.GIVEN_ANGLE: + angle = coords["angle"] # Fred's grid is in degrees + INC -= np.radians(angle.data[np.newaxis, :]) ua, va, up, vp = ep2ap(SEMA, ECC, INC, PHA) # Convert to real amplitude and phase. diff --git a/regional_mom6/regridding.py b/regional_mom6/regridding.py index 27777404..8884a2b4 100644 --- a/regional_mom6/regridding.py +++ b/regional_mom6/regridding.py @@ -43,11 +43,13 @@ class RotationMethod(Enum): KEITH_DOUBLE_REGRIDDING: This method is used to regrid the boundary conditions to the t-points, b/c we can calculate t-point angle the same way as MOM6, rotate the conditions, and regrid again to the q-u-v, or actual, boundary FRED_AVERAGE: This method is used with the basis that we can find the angles at the q-u-v points by pretending we have another row/column of the hgrid with the same distances as the t-point to u/v points in the actual grid then use the four poitns to calculate the angle the exact same way MOM6 does. GIVEN_ANGLE: This is the original default RM6 method which expects a pre-given angle called angle_dx + NO_ROTATION: Grids parallel to lat/lon axes, no rotation needed """ KEITH_DOUBLE_REGRIDDING = 1 FRED_AVERAGE = 2 GIVEN_ANGLE = 3 + NO_ROTATION = 4 regridding_logger = setup_logger(__name__) From a1ba7671e5b9c3c8725b51b058c0d63de9718fa8 Mon Sep 17 00:00:00 2001 From: manishvenu Date: Fri, 22 Nov 2024 11:57:38 -0700 Subject: [PATCH 17/87] Add h, t, and change default mom6_angle_calc to regional --- regional_mom6/regridding.py | 33 ++++++++++++++++++--------------- 1 file changed, 18 insertions(+), 15 deletions(-) diff --git a/regional_mom6/regridding.py b/regional_mom6/regridding.py index 8884a2b4..a6acc77d 100644 --- a/regional_mom6/regridding.py +++ b/regional_mom6/regridding.py @@ -468,13 +468,16 @@ def initialize_grid_rotation_angle(hgrid: xr.Dataset) -> xr.Dataset: ) # One quarter the conversion factor from degrees to radians ## Check length of longitude - len_lon = 360.0 - G_len_lon = hgrid.x.max() - hgrid.x.min() - if G_len_lon != 360: - regridding_logger.info("This is a regional case") - len_lon = G_len_lon + G_len_lon = hgrid.x.max() - hgrid.x.min() # We're always going to be working with the regional case.... in the global case len_lon is different, and is a check in the actual MOM code. + len_lon = G_len_lon - angles_arr_v2 = np.zeros((len(tlon.nyp), len(tlon.nxp))) + # Get the tlon and tlat + ds_t = get_hgrid_arakawa_c_points(hgrid, "t") + tlon = ds_t.tlon + ds_q = get_hgrid_arakawa_c_points(hgrid, "q") + qlon = ds_q.qlon + qlat = ds_q.qlat + angles_arr = np.zeros((len(tlon.nyp), len(tlon.nxp))) # Compute lonB for all points lonB = np.zeros((2, 2, len(tlon.nyp), len(tlon.nxp))) @@ -503,15 +506,15 @@ def initialize_grid_rotation_angle(hgrid: xr.Dataset) -> xr.Dataset: (qlat[:-1, :-1] - qlat[1:, 1:]) + (qlat[1:, 0:-1] - qlat[0:-1, 1:]), ) # Assign angle to angles_arr - angles_arr_v2 = np.rad2deg(angle) - 90 + angles_arr = np.rad2deg(angle) - 90 # Assign angles_arr to hgrid t_angles = xr.DataArray( - angles_arr_v2, - dims=["qy", "qx"], + angles_arr, + dims=["nyp", "nxp"], coords={ - "qy": tlon.nyp.values, - "qx": tlon.nxp.values, + "nyp": tlon.nyp.values, + "nxp": tlon.nxp.values, }, ) return t_angles @@ -529,8 +532,8 @@ def get_hgrid_arakawa_c_points(hgrid: xr.Dataset, point_type="t") -> xr.Dataset: xr.Dataset The specific points x, y, & point indexes """ - if point_type not in "uvqt": - raise ValueError("point_type must be one of 'uvqt'") + if point_type not in "uvqth": + raise ValueError("point_type must be one of 'uvqht'") regridding_logger.info("Getting {} points..".format(point_type)) @@ -543,7 +546,7 @@ def get_hgrid_arakawa_c_points(hgrid: xr.Dataset, point_type="t") -> xr.Dataset: by_two_y = np.arange(0, len(hgrid.x.nyp), k) # T point locations - if point_type == "t": + if point_type == "t" or point_type == "h": points = (offset_one_by_two_y, offset_one_by_two_x) # U point locations elif point_type == "u": @@ -555,7 +558,7 @@ def get_hgrid_arakawa_c_points(hgrid: xr.Dataset, point_type="t") -> xr.Dataset: elif point_type == "q": points = (by_two_y, by_two_x) else: - raise ValueError("Invalid Point Type (u, v, q, or t only)") + raise ValueError("Invalid Point Type (u, v, q, or t/h only)") point_dataset = xr.Dataset( { From d2ec0266a440db21299e9eda29b5da101892cbfc Mon Sep 17 00:00:00 2001 From: manishvenu Date: Mon, 9 Dec 2024 09:24:15 -0700 Subject: [PATCH 18/87] black --- regional_mom6/regridding.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/regional_mom6/regridding.py b/regional_mom6/regridding.py index a6acc77d..1da2b480 100644 --- a/regional_mom6/regridding.py +++ b/regional_mom6/regridding.py @@ -468,7 +468,9 @@ def initialize_grid_rotation_angle(hgrid: xr.Dataset) -> xr.Dataset: ) # One quarter the conversion factor from degrees to radians ## Check length of longitude - G_len_lon = hgrid.x.max() - hgrid.x.min() # We're always going to be working with the regional case.... in the global case len_lon is different, and is a check in the actual MOM code. + G_len_lon = ( + hgrid.x.max() - hgrid.x.min() + ) # We're always going to be working with the regional case.... in the global case len_lon is different, and is a check in the actual MOM code. len_lon = G_len_lon # Get the tlon and tlat From 1b385ef9f13e038edd4b9c18f298cf5c0a96ce02 Mon Sep 17 00:00:00 2001 From: manishvenu Date: Mon, 9 Dec 2024 11:33:42 -0700 Subject: [PATCH 19/87] Fred Angle Calc --- regional_mom6/regional_mom6.py | 135 ++++++++------------------------- regional_mom6/regridding.py | 115 +++++++++++++++++++++++++++- 2 files changed, 147 insertions(+), 103 deletions(-) diff --git a/regional_mom6/regional_mom6.py b/regional_mom6/regional_mom6.py index cfeb71fb..a2c12e2a 100644 --- a/regional_mom6/regional_mom6.py +++ b/regional_mom6/regional_mom6.py @@ -1670,7 +1670,7 @@ def setup_boundary_tides( This tidal data functions are sourced from the GFDL NWA25 and changed in the following ways: - Converted code for RM6 segment class - Implemented Horizontal Subsetting - - Combined all functions of NWA25 into a four function process (in the style of rm6) (expt.setup_tides_rectangular_boundaries, self.coords, segment.regrid_tides, segment.encode_tidal_files_and_output) + - Combined all functions of NWA25 into a four function process (in the style of rm6) (expt.setup_tides_rectangular_boundaries, coords, segment.regrid_tides, segment.encode_tidal_files_and_output) Original Code was sourced from: @@ -2901,97 +2901,6 @@ def __init__( self.segment_name = segment_name self.repeat_year_forcing = repeat_year_forcing - @property - def coords(self): - """ - - - This function: - Allows us to call the self.coords for use in the xesmf.Regridder in the regrid_tides function. self.coords gives us the subset of the hgrid based on the orientation. - - Args: - None - Returns: - xr.Dataset: The correct coordinate space for the orientation - - General Description: - This tidal data functions are sourced from the GFDL NWA25 and changed in the following ways: - - Converted code for RM6 segment class - - Implemented Horizontal Subsetting - - Combined all functions of NWA25 into a four function process (in the style of rm6) (expt.setup_tides_rectangular_boundaries, segment.coords, segment.regrid_tides, segment.encode_tidal_files_and_output) - - - Code adapted from: - Author(s): GFDL, James Simkins, Rob Cermak, etc.. - Year: 2022 - Title: "NWA25: Northwest Atlantic 1/25th Degree MOM6 Simulation" - Version: N/A - Type: Python Functions, Source Code - Web Address: https://github.com/jsimkins2/nwa25 - - """ - # Rename nxp and nyp to locations - if self.orientation == "south": - rcoord = xr.Dataset( - { - "lon": self.hgrid["x"].isel(nyp=0), - "lat": self.hgrid["y"].isel(nyp=0), - "angle": self.hgrid["angle_dx"].isel(nyp=0), - } - ) - rcoord = rcoord.rename_dims({"nxp": f"nx_{self.segment_name}"}) - rcoord.attrs["perpendicular"] = "ny" - rcoord.attrs["parallel"] = "nx" - rcoord.attrs["axis_to_expand"] = ( - 2 ## Need to keep track of which axis the 'main' coordinate corresponds to when re-adding the 'secondary' axis - ) - rcoord.attrs["locations_name"] = ( - f"nx_{self.segment_name}" # Legacy name of nx_... was locations. This provides a clear transform in regrid_tides - ) - elif self.orientation == "north": - rcoord = xr.Dataset( - { - "lon": self.hgrid["x"].isel(nyp=-1), - "lat": self.hgrid["y"].isel(nyp=-1), - "angle": self.hgrid["angle_dx"].isel(nyp=-1), - } - ) - rcoord = rcoord.rename_dims({"nxp": f"nx_{self.segment_name}"}) - rcoord.attrs["perpendicular"] = "ny" - rcoord.attrs["parallel"] = "nx" - rcoord.attrs["axis_to_expand"] = 2 - rcoord.attrs["locations_name"] = f"nx_{self.segment_name}" - elif self.orientation == "west": - rcoord = xr.Dataset( - { - "lon": self.hgrid["x"].isel(nxp=0), - "lat": self.hgrid["y"].isel(nxp=0), - "angle": self.hgrid["angle_dx"].isel(nxp=0), - } - ) - rcoord = rcoord.rename_dims({"nyp": f"ny_{self.segment_name}"}) - rcoord.attrs["perpendicular"] = "nx" - rcoord.attrs["parallel"] = "ny" - rcoord.attrs["axis_to_expand"] = 3 - rcoord.attrs["locations_name"] = f"ny_{self.segment_name}" - elif self.orientation == "east": - rcoord = xr.Dataset( - { - "lon": self.hgrid["x"].isel(nxp=-1), - "lat": self.hgrid["y"].isel(nxp=-1), - "angle": self.hgrid["angle_dx"].isel(nxp=-1), - } - ) - rcoord = rcoord.rename_dims({"nyp": f"ny_{self.segment_name}"}) - rcoord.attrs["perpendicular"] = "nx" - rcoord.attrs["parallel"] = "ny" - rcoord.attrs["axis_to_expand"] = 3 - rcoord.attrs["locations_name"] = f"ny_{self.segment_name}" - - # Make lat and lon coordinates - rcoord = rcoord.assign_coords(lat=rcoord["lat"], lon=rcoord["lon"]) - - return rcoord def rotate(self, u, v, radian_angle): # Make docstring @@ -3044,7 +2953,14 @@ def regrid_velocity_tracers(self, rotational_method=rgd.RotationMethod.GIVEN_ANG rotated_u, rotated_v = self.rotate( regridded[self.u], regridded[self.v], - radian_angle=self.coords.angle.values * np.pi / 180, + radian_angle=np.radians(coords.angle.values) + ) + elif rotational_method == rgd.RotationMethod.FRED_AVERAGE: + degree_angle = rgd.initialize_hgrid_rotation_angles_using_pseudo_hgrid(self.hgrid) + rotated_u, rotated_v = self.rotate( + regridded[self.u], + regridded[self.v], + radian_angle=np.radians(degree_angle.values) ) elif rotational_method == rgd.RotationMethod.NO_ROTATION: rotated_u, rotated_v = regridded[self.u], regridded[self.v] @@ -3078,7 +2994,14 @@ def regrid_velocity_tracers(self, rotational_method=rgd.RotationMethod.GIVEN_ANG velocities_out["u"], velocities_out["v"] = self.rotate( velocities_out["u"], velocities_out["v"], - radian_angle=self.coords.angle.values * np.pi / 180, + radian_angle=np.radians(coords.angle.values) + ) + elif rotational_method == rgd.RotationMethod.FRED_AVERAGE: + degree_angle = rgd.initialize_hgrid_rotation_angles_using_pseudo_hgrid(self.hgrid) + velocities_out["u"], velocities_out["v"] = self.rotate( + velocities_out["u"], + velocities_out["v"], + radian_angle=np.radians(degree_angle.values) ) elif rotational_method == rgd.RotationMethod.NO_ROTATION: velocities_out["u"], velocities_out["v"] = ( @@ -3126,7 +3049,14 @@ def regrid_velocity_tracers(self, rotational_method=rgd.RotationMethod.GIVEN_ANG rotated_u, rotated_v = self.rotate( regridded[self.u], regridded[self.v], - radian_angle=self.coords.angle.values * np.pi / 180, + radian_angle= np.radians(coords.angle.values) + ) + elif rotational_method == rgd.RotationMethod.FRED_AVERAGE: + degree_angle = rgd.initialize_hgrid_rotation_angles_using_pseudo_hgrid(self.hgrid) + rotated_u, rotated_v = self.rotate( + regridded[self.u], + regridded[self.v], + radian_angle= np.radians(degree_angle.values) ) elif rotational_method == rgd.RotationMethod.NO_ROTATION: rotated_u, rotated_v = regridded[self.u], regridded[self.v] @@ -3161,7 +3091,7 @@ def regrid_velocity_tracers(self, rotational_method=rgd.RotationMethod.GIVEN_ANG # fill in NaNs segment_out = rgd.fill_missing_data(segment_out, self.z) segment_out = rgd.fill_missing_data( - segment_out, f"{self.coords.attrs['parallel']}_{self.segment_name}" + segment_out, f"{coords.attrs['parallel']}_{self.segment_name}" ) times = xr.DataArray( @@ -3218,10 +3148,10 @@ def regrid_velocity_tracers(self, rotational_method=rgd.RotationMethod.GIVEN_ANG ) # Overwrite the actual lat/lon values in the dimensions, replace with incrementing integers - segment_out[f"{self.coords.attrs['parallel']}_{self.segment_name}"] = np.arange( - segment_out[f"{self.coords.attrs['parallel']}_{self.segment_name}"].size + segment_out[f"{coords.attrs['parallel']}_{self.segment_name}"] = np.arange( + segment_out[f"{coords.attrs['parallel']}_{self.segment_name}"].size ) - segment_out[f"{self.coords.attrs['perpendicular']}_{self.segment_name}"] = [0] + segment_out[f"{coords.attrs['perpendicular']}_{self.segment_name}"] = [0] encoding_dict = { "time": {"dtype": "double"}, f"nx_{self.segment_name}": { @@ -3252,8 +3182,6 @@ def regrid_tides( tpxo_h, times, rotational_method=rgd.RotationMethod.GIVEN_ANGLE, - method="nearest_s2d", - periodic=False, ): """ This function: @@ -3377,6 +3305,9 @@ def regrid_tides( if rotational_method == rgd.RotationMethod.GIVEN_ANGLE: angle = coords["angle"] # Fred's grid is in degrees INC -= np.radians(angle.data[np.newaxis, :]) + elif rotational_method == rgd.RotationMethod.FRED_AVERAGE: + degree_angle = rgd.initialize_hgrid_rotation_angles_using_pseudo_hgrid(self.hgrid) + INC -= np.radians(degree_angle.data[np.newaxis, :]) ua, va, up, vp = ep2ap(SEMA, ECC, INC, PHA) # Convert to real amplitude and phase. @@ -3432,7 +3363,7 @@ def encode_tidal_files_and_output(self, ds, filename): This tidal data functions are sourced from the GFDL NWA25 and changed in the following ways: - Converted code for RM6 segment class - Implemented Horizontal Subsetting - - Combined all functions of NWA25 into a four function process (in the style of rm6) (expt.setup_tides_rectangular_boundaries, self.coords, segment.regrid_tides, segment.encode_tidal_files_and_output) + - Combined all functions of NWA25 into a four function process (in the style of rm6) (expt.setup_tides_rectangular_boundaries, coords, segment.regrid_tides, segment.encode_tidal_files_and_output) Original Code was sourced from: diff --git a/regional_mom6/regridding.py b/regional_mom6/regridding.py index 1da2b480..83897816 100644 --- a/regional_mom6/regridding.py +++ b/regional_mom6/regridding.py @@ -451,7 +451,7 @@ def modulo_around_point(x, xc, Lx): def initialize_grid_rotation_angle(hgrid: xr.Dataset) -> xr.Dataset: """ - Calculate the angle_dx in degrees from the true x (east?) direction counterclockwise) and save as angle_dx_mom6 + Calculate the angle_dx in degrees from the true x (east?) direction counterclockwise) and return as DataArray Parameters ---------- hgrid: xr.Dataset @@ -574,3 +574,116 @@ def get_hgrid_arakawa_c_points(hgrid: xr.Dataset, point_type="t") -> xr.Dataset: "Arakawa C {}-points of supplied h-grid".format(point_type) ) return point_dataset + + +def create_pseudo_hgrid(hgrid: xr.Dataset) -> xr.Dataset: + """ + Adds an additional boundary to the hgrid to allow for the calculation of the angle_dx for the boundary points using the method in MOM6 + """ + pseudo_hgrid_x = np.full((len(hgrid.nyp) + 2, len(hgrid.nxp)+2), np.nan) + pseudo_hgrid_y = np.full((len(hgrid.nyp) + 2, len(hgrid.nxp)+2), np.nan) + + ## Fill Boundaries + pseudo_hgrid_x[1:-1, 1:-1] = hgrid.x.values + pseudo_hgrid_x[0, 1:-1] = hgrid.x.values[0,:] - (hgrid.x.values[1,:] - hgrid.x.values[0,:]) # Bottom Fill + pseudo_hgrid_x[-1, 1:-1] = hgrid.x.values[-1,:] + (hgrid.x.values[-1,:] - hgrid.x.values[-2,:]) # Top Fill + pseudo_hgrid_x[1:-1, 0] = hgrid.x.values[:,0] - (hgrid.x.values[:,1] - hgrid.x.values[:,0]) # Left Fill + pseudo_hgrid_x[1:-1, -1] = hgrid.x.values[:,-1] + (hgrid.x.values[:,-1] - hgrid.x.values[:,-2]) # Right Fill + + pseudo_hgrid_y[1:-1, 1:-1] = hgrid.y.values + pseudo_hgrid_y[0, 1:-1] = hgrid.y.values[0,:] - (hgrid.y.values[1,:] - hgrid.y.values[0,:]) # Bottom Fill + pseudo_hgrid_y[-1, 1:-1] = hgrid.y.values[-1,:] + (hgrid.y.values[-1,:] - hgrid.y.values[-2,:]) # Top Fill + pseudo_hgrid_y[1:-1, 0] = hgrid.y.values[:,0] - (hgrid.y.values[:,1] - hgrid.y.values[:,0]) # Left Fill + pseudo_hgrid_y[1:-1, -1] = hgrid.y.values[:,-1] + (hgrid.y.values[:,-1] - hgrid.y.values[:,-2]) # Right Fill + + + ## Fill Corners + pseudo_hgrid_x[0, 0] = hgrid.x.values[0,0] - (hgrid.x.values[1,1] - hgrid.x.values[0,0]) # Bottom Left + pseudo_hgrid_x[-1, 0] = hgrid.x.values[-1,0] - (hgrid.x.values[-2,1] - hgrid.x.values[-1,0]) # Top Left + pseudo_hgrid_x[0, -1] = hgrid.x.values[0,-1] - (hgrid.x.values[1,-2] - hgrid.x.values[0,-1]) # Bottom Right + pseudo_hgrid_x[-1, -1] = hgrid.x.values[-1,-1] - (hgrid.x.values[-2,-2] - hgrid.x.values[-1,-1]) # Top Right + + pseudo_hgrid_y[0, 0] = hgrid.y.values[0,0] - (hgrid.y.values[1,1] - hgrid.y.values[0,0]) # Bottom Left + pseudo_hgrid_y[-1, 0] = hgrid.y.values[-1,0] - (hgrid.y.values[-2,1] - hgrid.y.values[-1,0]) # Top Left + pseudo_hgrid_y[0, -1] = hgrid.y.values[0,-1] - (hgrid.y.values[1,-2] - hgrid.y.values[0,-1]) # Bottom Right + pseudo_hgrid_y[-1, -1] = hgrid.y.values[-1,-1] - (hgrid.y.values[-2,-2] - hgrid.y.values[-1,-1]) # Top Right + + pseudo_hgrid = xr.Dataset( + { + "x": (["nyp", "nxp"], pseudo_hgrid_x), + "y": (["nyp", "nxp"], pseudo_hgrid_y), + } + ) + return pseudo_hgrid + +def initialize_hgrid_rotation_angles_using_pseudo_hgrid(hgrid: xr.Dataset, pseudo_hgrid:xr.Dataset)->xr.Dataset: + """ + Calculate the angle_dx in degrees from the true x (east?) direction counterclockwise) and return as dataarray + + Parameters + ---------- + hgrid: xr.Dataset + The hgrid dataset + pseudo_hgrid: xr.Dataset + The pseudo hgrid dataset + Returns + ------- + xr.DataArray + The t-point angles + """ + # Direct Translation + pi_720deg = ( + np.arctan(1) / 180 + ) # One quarter the conversion factor from degrees to radians + + ## Check length of longitude + G_len_lon = pseudo_hgrid.x.max() - pseudo_hgrid.x.min() # We're always going to be working with the regional case.... in the global case len_lon is different, and is a check in the actual MOM code. + len_lon = G_len_lon + + angles_arr = np.zeros((len(hgrid.nyp), len(hgrid.nxp))) + + # Compute lonB for all points + lonB = np.zeros((2, 2, len(hgrid.nyp), len(hgrid.nxp))) + + # Vectorized computation of lonB + lonB[0][0] = modulo_around_point( + pseudo_hgrid.x[:-2, :-2], hgrid.x, len_lon + ) # Bottom Left + lonB[1][0] = modulo_around_point( + pseudo_hgrid.x[2:, :-2], hgrid.x, len_lon + ) # Top Left + lonB[1][1] = modulo_around_point( + pseudo_hgrid.x[2:, 2:], hgrid.x, len_lon + ) # Top Right + lonB[0][1] = modulo_around_point( + pseudo_hgrid.x[:-2, 2:], hgrid.x, len_lon + ) # Bottom Right + + + # Compute lon_scale + lon_scale = np.cos( + pi_720deg + * ((pseudo_hgrid.y[:-2, :-2] + pseudo_hgrid.y[:-2, 2:]) + (pseudo_hgrid.y[2:, 2:] + pseudo_hgrid.y[2:, :-2])) + ) + + # Compute angle + angle = np.arctan2( + lon_scale * ((lonB[0, 1] - lonB[1, 0]) + (lonB[1, 1] - lonB[0, 0])), + (pseudo_hgrid.y[:-2, :-2] -pseudo_hgrid.y[2:, 2:]) + (pseudo_hgrid.y[2:, :-2] - pseudo_hgrid.y[:-2, 2:]), + ) + # Assign angle to angles_arr + angles_arr = np.rad2deg(angle) - 90 + + # Assign angles_arr to hgrid + t_angles = xr.DataArray( + angles_arr, + dims=["nyp", "nxp"], + coords={ + "nyp": hgrid.nyp.values, + "nxp": hgrid.nxp.values, + }, + ) + return t_angles + + + From 9cd837f8daee3b90b043f1a7b1ad315bb6c2e3df Mon Sep 17 00:00:00 2001 From: manishvenu Date: Mon, 9 Dec 2024 11:34:30 -0700 Subject: [PATCH 20/87] Black --- regional_mom6/regional_mom6.py | 31 +++++---- regional_mom6/regridding.py | 112 ++++++++++++++++++++++----------- 2 files changed, 93 insertions(+), 50 deletions(-) diff --git a/regional_mom6/regional_mom6.py b/regional_mom6/regional_mom6.py index a2c12e2a..345a41b7 100644 --- a/regional_mom6/regional_mom6.py +++ b/regional_mom6/regional_mom6.py @@ -2901,7 +2901,6 @@ def __init__( self.segment_name = segment_name self.repeat_year_forcing = repeat_year_forcing - def rotate(self, u, v, radian_angle): # Make docstring @@ -2953,14 +2952,16 @@ def regrid_velocity_tracers(self, rotational_method=rgd.RotationMethod.GIVEN_ANG rotated_u, rotated_v = self.rotate( regridded[self.u], regridded[self.v], - radian_angle=np.radians(coords.angle.values) + radian_angle=np.radians(coords.angle.values), ) elif rotational_method == rgd.RotationMethod.FRED_AVERAGE: - degree_angle = rgd.initialize_hgrid_rotation_angles_using_pseudo_hgrid(self.hgrid) + degree_angle = rgd.initialize_hgrid_rotation_angles_using_pseudo_hgrid( + self.hgrid + ) rotated_u, rotated_v = self.rotate( regridded[self.u], regridded[self.v], - radian_angle=np.radians(degree_angle.values) + radian_angle=np.radians(degree_angle.values), ) elif rotational_method == rgd.RotationMethod.NO_ROTATION: rotated_u, rotated_v = regridded[self.u], regridded[self.v] @@ -2994,14 +2995,16 @@ def regrid_velocity_tracers(self, rotational_method=rgd.RotationMethod.GIVEN_ANG velocities_out["u"], velocities_out["v"] = self.rotate( velocities_out["u"], velocities_out["v"], - radian_angle=np.radians(coords.angle.values) + radian_angle=np.radians(coords.angle.values), ) elif rotational_method == rgd.RotationMethod.FRED_AVERAGE: - degree_angle = rgd.initialize_hgrid_rotation_angles_using_pseudo_hgrid(self.hgrid) + degree_angle = rgd.initialize_hgrid_rotation_angles_using_pseudo_hgrid( + self.hgrid + ) velocities_out["u"], velocities_out["v"] = self.rotate( velocities_out["u"], velocities_out["v"], - radian_angle=np.radians(degree_angle.values) + radian_angle=np.radians(degree_angle.values), ) elif rotational_method == rgd.RotationMethod.NO_ROTATION: velocities_out["u"], velocities_out["v"] = ( @@ -3049,14 +3052,16 @@ def regrid_velocity_tracers(self, rotational_method=rgd.RotationMethod.GIVEN_ANG rotated_u, rotated_v = self.rotate( regridded[self.u], regridded[self.v], - radian_angle= np.radians(coords.angle.values) + radian_angle=np.radians(coords.angle.values), ) elif rotational_method == rgd.RotationMethod.FRED_AVERAGE: - degree_angle = rgd.initialize_hgrid_rotation_angles_using_pseudo_hgrid(self.hgrid) + degree_angle = rgd.initialize_hgrid_rotation_angles_using_pseudo_hgrid( + self.hgrid + ) rotated_u, rotated_v = self.rotate( regridded[self.u], regridded[self.v], - radian_angle= np.radians(degree_angle.values) + radian_angle=np.radians(degree_angle.values), ) elif rotational_method == rgd.RotationMethod.NO_ROTATION: rotated_u, rotated_v = regridded[self.u], regridded[self.v] @@ -3306,8 +3311,10 @@ def regrid_tides( angle = coords["angle"] # Fred's grid is in degrees INC -= np.radians(angle.data[np.newaxis, :]) elif rotational_method == rgd.RotationMethod.FRED_AVERAGE: - degree_angle = rgd.initialize_hgrid_rotation_angles_using_pseudo_hgrid(self.hgrid) - INC -= np.radians(degree_angle.data[np.newaxis, :]) + degree_angle = rgd.initialize_hgrid_rotation_angles_using_pseudo_hgrid( + self.hgrid + ) + INC -= np.radians(degree_angle.data[np.newaxis, :]) ua, va, up, vp = ep2ap(SEMA, ECC, INC, PHA) # Convert to real amplitude and phase. diff --git a/regional_mom6/regridding.py b/regional_mom6/regridding.py index 83897816..d8512d62 100644 --- a/regional_mom6/regridding.py +++ b/regional_mom6/regridding.py @@ -580,43 +580,77 @@ def create_pseudo_hgrid(hgrid: xr.Dataset) -> xr.Dataset: """ Adds an additional boundary to the hgrid to allow for the calculation of the angle_dx for the boundary points using the method in MOM6 """ - pseudo_hgrid_x = np.full((len(hgrid.nyp) + 2, len(hgrid.nxp)+2), np.nan) - pseudo_hgrid_y = np.full((len(hgrid.nyp) + 2, len(hgrid.nxp)+2), np.nan) + pseudo_hgrid_x = np.full((len(hgrid.nyp) + 2, len(hgrid.nxp) + 2), np.nan) + pseudo_hgrid_y = np.full((len(hgrid.nyp) + 2, len(hgrid.nxp) + 2), np.nan) ## Fill Boundaries pseudo_hgrid_x[1:-1, 1:-1] = hgrid.x.values - pseudo_hgrid_x[0, 1:-1] = hgrid.x.values[0,:] - (hgrid.x.values[1,:] - hgrid.x.values[0,:]) # Bottom Fill - pseudo_hgrid_x[-1, 1:-1] = hgrid.x.values[-1,:] + (hgrid.x.values[-1,:] - hgrid.x.values[-2,:]) # Top Fill - pseudo_hgrid_x[1:-1, 0] = hgrid.x.values[:,0] - (hgrid.x.values[:,1] - hgrid.x.values[:,0]) # Left Fill - pseudo_hgrid_x[1:-1, -1] = hgrid.x.values[:,-1] + (hgrid.x.values[:,-1] - hgrid.x.values[:,-2]) # Right Fill + pseudo_hgrid_x[0, 1:-1] = hgrid.x.values[0, :] - ( + hgrid.x.values[1, :] - hgrid.x.values[0, :] + ) # Bottom Fill + pseudo_hgrid_x[-1, 1:-1] = hgrid.x.values[-1, :] + ( + hgrid.x.values[-1, :] - hgrid.x.values[-2, :] + ) # Top Fill + pseudo_hgrid_x[1:-1, 0] = hgrid.x.values[:, 0] - ( + hgrid.x.values[:, 1] - hgrid.x.values[:, 0] + ) # Left Fill + pseudo_hgrid_x[1:-1, -1] = hgrid.x.values[:, -1] + ( + hgrid.x.values[:, -1] - hgrid.x.values[:, -2] + ) # Right Fill pseudo_hgrid_y[1:-1, 1:-1] = hgrid.y.values - pseudo_hgrid_y[0, 1:-1] = hgrid.y.values[0,:] - (hgrid.y.values[1,:] - hgrid.y.values[0,:]) # Bottom Fill - pseudo_hgrid_y[-1, 1:-1] = hgrid.y.values[-1,:] + (hgrid.y.values[-1,:] - hgrid.y.values[-2,:]) # Top Fill - pseudo_hgrid_y[1:-1, 0] = hgrid.y.values[:,0] - (hgrid.y.values[:,1] - hgrid.y.values[:,0]) # Left Fill - pseudo_hgrid_y[1:-1, -1] = hgrid.y.values[:,-1] + (hgrid.y.values[:,-1] - hgrid.y.values[:,-2]) # Right Fill - + pseudo_hgrid_y[0, 1:-1] = hgrid.y.values[0, :] - ( + hgrid.y.values[1, :] - hgrid.y.values[0, :] + ) # Bottom Fill + pseudo_hgrid_y[-1, 1:-1] = hgrid.y.values[-1, :] + ( + hgrid.y.values[-1, :] - hgrid.y.values[-2, :] + ) # Top Fill + pseudo_hgrid_y[1:-1, 0] = hgrid.y.values[:, 0] - ( + hgrid.y.values[:, 1] - hgrid.y.values[:, 0] + ) # Left Fill + pseudo_hgrid_y[1:-1, -1] = hgrid.y.values[:, -1] + ( + hgrid.y.values[:, -1] - hgrid.y.values[:, -2] + ) # Right Fill ## Fill Corners - pseudo_hgrid_x[0, 0] = hgrid.x.values[0,0] - (hgrid.x.values[1,1] - hgrid.x.values[0,0]) # Bottom Left - pseudo_hgrid_x[-1, 0] = hgrid.x.values[-1,0] - (hgrid.x.values[-2,1] - hgrid.x.values[-1,0]) # Top Left - pseudo_hgrid_x[0, -1] = hgrid.x.values[0,-1] - (hgrid.x.values[1,-2] - hgrid.x.values[0,-1]) # Bottom Right - pseudo_hgrid_x[-1, -1] = hgrid.x.values[-1,-1] - (hgrid.x.values[-2,-2] - hgrid.x.values[-1,-1]) # Top Right - - pseudo_hgrid_y[0, 0] = hgrid.y.values[0,0] - (hgrid.y.values[1,1] - hgrid.y.values[0,0]) # Bottom Left - pseudo_hgrid_y[-1, 0] = hgrid.y.values[-1,0] - (hgrid.y.values[-2,1] - hgrid.y.values[-1,0]) # Top Left - pseudo_hgrid_y[0, -1] = hgrid.y.values[0,-1] - (hgrid.y.values[1,-2] - hgrid.y.values[0,-1]) # Bottom Right - pseudo_hgrid_y[-1, -1] = hgrid.y.values[-1,-1] - (hgrid.y.values[-2,-2] - hgrid.y.values[-1,-1]) # Top Right - - pseudo_hgrid = xr.Dataset( - { - "x": (["nyp", "nxp"], pseudo_hgrid_x), - "y": (["nyp", "nxp"], pseudo_hgrid_y), - } + pseudo_hgrid_x[0, 0] = hgrid.x.values[0, 0] - ( + hgrid.x.values[1, 1] - hgrid.x.values[0, 0] + ) # Bottom Left + pseudo_hgrid_x[-1, 0] = hgrid.x.values[-1, 0] - ( + hgrid.x.values[-2, 1] - hgrid.x.values[-1, 0] + ) # Top Left + pseudo_hgrid_x[0, -1] = hgrid.x.values[0, -1] - ( + hgrid.x.values[1, -2] - hgrid.x.values[0, -1] + ) # Bottom Right + pseudo_hgrid_x[-1, -1] = hgrid.x.values[-1, -1] - ( + hgrid.x.values[-2, -2] - hgrid.x.values[-1, -1] + ) # Top Right + + pseudo_hgrid_y[0, 0] = hgrid.y.values[0, 0] - ( + hgrid.y.values[1, 1] - hgrid.y.values[0, 0] + ) # Bottom Left + pseudo_hgrid_y[-1, 0] = hgrid.y.values[-1, 0] - ( + hgrid.y.values[-2, 1] - hgrid.y.values[-1, 0] + ) # Top Left + pseudo_hgrid_y[0, -1] = hgrid.y.values[0, -1] - ( + hgrid.y.values[1, -2] - hgrid.y.values[0, -1] + ) # Bottom Right + pseudo_hgrid_y[-1, -1] = hgrid.y.values[-1, -1] - ( + hgrid.y.values[-2, -2] - hgrid.y.values[-1, -1] + ) # Top Right + + pseudo_hgrid = xr.Dataset( + { + "x": (["nyp", "nxp"], pseudo_hgrid_x), + "y": (["nyp", "nxp"], pseudo_hgrid_y), + } ) return pseudo_hgrid -def initialize_hgrid_rotation_angles_using_pseudo_hgrid(hgrid: xr.Dataset, pseudo_hgrid:xr.Dataset)->xr.Dataset: + +def initialize_hgrid_rotation_angles_using_pseudo_hgrid( + hgrid: xr.Dataset, pseudo_hgrid: xr.Dataset +) -> xr.Dataset: """ Calculate the angle_dx in degrees from the true x (east?) direction counterclockwise) and return as dataarray @@ -637,7 +671,9 @@ def initialize_hgrid_rotation_angles_using_pseudo_hgrid(hgrid: xr.Dataset, pseud ) # One quarter the conversion factor from degrees to radians ## Check length of longitude - G_len_lon = pseudo_hgrid.x.max() - pseudo_hgrid.x.min() # We're always going to be working with the regional case.... in the global case len_lon is different, and is a check in the actual MOM code. + G_len_lon = ( + pseudo_hgrid.x.max() - pseudo_hgrid.x.min() + ) # We're always going to be working with the regional case.... in the global case len_lon is different, and is a check in the actual MOM code. len_lon = G_len_lon angles_arr = np.zeros((len(hgrid.nyp), len(hgrid.nxp))) @@ -648,28 +684,31 @@ def initialize_hgrid_rotation_angles_using_pseudo_hgrid(hgrid: xr.Dataset, pseud # Vectorized computation of lonB lonB[0][0] = modulo_around_point( pseudo_hgrid.x[:-2, :-2], hgrid.x, len_lon - ) # Bottom Left + ) # Bottom Left lonB[1][0] = modulo_around_point( pseudo_hgrid.x[2:, :-2], hgrid.x, len_lon - ) # Top Left + ) # Top Left lonB[1][1] = modulo_around_point( pseudo_hgrid.x[2:, 2:], hgrid.x, len_lon - ) # Top Right + ) # Top Right lonB[0][1] = modulo_around_point( pseudo_hgrid.x[:-2, 2:], hgrid.x, len_lon - ) # Bottom Right - + ) # Bottom Right # Compute lon_scale lon_scale = np.cos( pi_720deg - * ((pseudo_hgrid.y[:-2, :-2] + pseudo_hgrid.y[:-2, 2:]) + (pseudo_hgrid.y[2:, 2:] + pseudo_hgrid.y[2:, :-2])) + * ( + (pseudo_hgrid.y[:-2, :-2] + pseudo_hgrid.y[:-2, 2:]) + + (pseudo_hgrid.y[2:, 2:] + pseudo_hgrid.y[2:, :-2]) + ) ) # Compute angle angle = np.arctan2( lon_scale * ((lonB[0, 1] - lonB[1, 0]) + (lonB[1, 1] - lonB[0, 0])), - (pseudo_hgrid.y[:-2, :-2] -pseudo_hgrid.y[2:, 2:]) + (pseudo_hgrid.y[2:, :-2] - pseudo_hgrid.y[:-2, 2:]), + (pseudo_hgrid.y[:-2, :-2] - pseudo_hgrid.y[2:, 2:]) + + (pseudo_hgrid.y[2:, :-2] - pseudo_hgrid.y[:-2, 2:]), ) # Assign angle to angles_arr angles_arr = np.rad2deg(angle) - 90 @@ -684,6 +723,3 @@ def initialize_hgrid_rotation_angles_using_pseudo_hgrid(hgrid: xr.Dataset, pseud }, ) return t_angles - - - From a2c5cf464f29481b4309bef00d47a58611fe7b2f Mon Sep 17 00:00:00 2001 From: manishvenu Date: Mon, 9 Dec 2024 11:36:00 -0700 Subject: [PATCH 21/87] Black 2 --- regional_mom6/regridding.py | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/regional_mom6/regridding.py b/regional_mom6/regridding.py index d8512d62..2e66c83e 100644 --- a/regional_mom6/regridding.py +++ b/regional_mom6/regridding.py @@ -649,7 +649,7 @@ def create_pseudo_hgrid(hgrid: xr.Dataset) -> xr.Dataset: def initialize_hgrid_rotation_angles_using_pseudo_hgrid( - hgrid: xr.Dataset, pseudo_hgrid: xr.Dataset + hgrid: xr.Dataset, ) -> xr.Dataset: """ Calculate the angle_dx in degrees from the true x (east?) direction counterclockwise) and return as dataarray @@ -665,6 +665,9 @@ def initialize_hgrid_rotation_angles_using_pseudo_hgrid( xr.DataArray The t-point angles """ + # Get Fred Pseudo grid + pseudo_hgrid = create_pseudo_hgrid(hgrid) + # Direct Translation pi_720deg = ( np.arctan(1) / 180 From bc76619b2e4b08db6333d763f6a35938ed390e84 Mon Sep 17 00:00:00 2001 From: manishvenu Date: Mon, 9 Dec 2024 12:00:00 -0700 Subject: [PATCH 22/87] Keith Method --- regional_mom6/regional_mom6.py | 72 +++++++++++++++++++++++++++++++++- 1 file changed, 70 insertions(+), 2 deletions(-) diff --git a/regional_mom6/regional_mom6.py b/regional_mom6/regional_mom6.py index 345a41b7..1ab7ad6c 100644 --- a/regional_mom6/regional_mom6.py +++ b/regional_mom6/regional_mom6.py @@ -2930,7 +2930,13 @@ def regrid_velocity_tracers(self, rotational_method=rgd.RotationMethod.GIVEN_ANG """ rawseg = xr.open_dataset(self.infile, decode_times=False, engine="netcdf4") - coords = rgd.coords(self.hgrid, self.orientation, self.segment_name) + + if rotational_method == rgd.RotationMethod.KEITH_DOUBLE_REGRIDDING: + coords = rgd.coords( + self.hgrid, self.orientation, self.segment_name, coords_at_t_points=True + ) + else: + coords = rgd.coords(self.hgrid, self.orientation, self.segment_name) if self.arakawa_grid == "A": @@ -2963,6 +2969,20 @@ def regrid_velocity_tracers(self, rotational_method=rgd.RotationMethod.GIVEN_ANG regridded[self.v], radian_angle=np.radians(degree_angle.values), ) + elif rotational_method == rgd.RotationMethod.KEITH_DOUBLE_REGRIDDING: + degree_angle = rgd.initialize_grid_rotation_angle(self.hgrid) + rotated_u, rotated_v = self.rotate( + regridded[self.u], + regridded[self.v], + radian_angle=np.radians(degree_angle.values), + ) + + coords = rgd.coords(self.hgrid, self.orientation, self.segment_name) + u_regridder = rgd.create_regridder(rotated_u, coords, ".temp") + v_regridder = rgd.create_regridder(rotated_v, coords, ".temp") + rotated_u = u_regridder(rotated_u) + rotated_v = v_regridder(rotated_v) + elif rotational_method == rgd.RotationMethod.NO_ROTATION: rotated_u, rotated_v = regridded[self.u], regridded[self.v] rotated_ds = xr.Dataset( @@ -3006,6 +3026,19 @@ def regrid_velocity_tracers(self, rotational_method=rgd.RotationMethod.GIVEN_ANG velocities_out["v"], radian_angle=np.radians(degree_angle.values), ) + elif rotational_method == rgd.RotationMethod.KEITH_DOUBLE_REGRIDDING: + degree_angle = rgd.initialize_grid_rotation_angle(self.hgrid) + velocities_out["u"], velocities_out["v"] = self.rotate( + velocities_out["u"], + velocities_out["v"], + radian_angle=np.radians(degree_angle.values), + ) + + coords = rgd.coords(self.hgrid, self.orientation, self.segment_name) + u_regridder = rgd.create_regridder(velocities_out["u"], coords, ".temp") + v_regridder = rgd.create_regridder(velocities_out["v"], coords, ".temp") + velocities_out["u"] = u_regridder(velocities_out["u"]) + velocities_out["v"] = v_regridder(velocities_out["v"]) elif rotational_method == rgd.RotationMethod.NO_ROTATION: velocities_out["u"], velocities_out["v"] = ( velocities_out["u"], @@ -3063,6 +3096,19 @@ def regrid_velocity_tracers(self, rotational_method=rgd.RotationMethod.GIVEN_ANG regridded[self.v], radian_angle=np.radians(degree_angle.values), ) + elif rotational_method == rgd.RotationMethod.KEITH_DOUBLE_REGRIDDING: + degree_angle = rgd.initialize_grid_rotation_angle(self.hgrid) + rotated_u, rotated_v = self.rotate( + regridded[self.u], + regridded[self.v], + radian_angle=np.radians(coords.angle.values), + ) + + coords = rgd.coords(self.hgrid, self.orientation, self.segment_name) + u_regridder = rgd.create_regridder(rotated_u, coords, ".temp") + v_regridder = rgd.create_regridder(rotated_v, coords, ".temp") + rotated_u = u_regridder(rotated_u) + rotated_v = v_regridder(rotated_v) elif rotational_method == rgd.RotationMethod.NO_ROTATION: rotated_u, rotated_v = regridded[self.u], regridded[self.v] rotated_ds = xr.Dataset( @@ -3220,7 +3266,7 @@ def regrid_tides( Web Address: https://github.com/jsimkins2/nwa25 """ - # Establish Coord + # Establish Coords coords = rgd.coords(self.hgrid, self.orientation, self.segment_name) ########## Tidal Elevation: Horizontally interpolate elevation components ############ @@ -3275,6 +3321,13 @@ def regrid_tides( self.encode_tidal_files_and_output(ds_ap, "tz") ########### Regrid Tidal Velocity ###################### + + # Change to t-point coords + if rotational_method == rgd.RotationMethod.KEITH_DOUBLE_REGRIDDING: + coords = rgd.coords( + self.hgrid, self.orientation, self.segment_name, coords_at_t_points=True + ) + regrid_u = rgd.create_regridder(tpxo_u[["lon", "lat", "uRe"]], coords, ".temp") regrid_v = rgd.create_regridder(tpxo_v[["lon", "lat", "vRe"]], coords, ".temp2") @@ -3315,8 +3368,23 @@ def regrid_tides( self.hgrid ) INC -= np.radians(degree_angle.data[np.newaxis, :]) + elif rotational_method == rgd.RotationMethod.KEITH_DOUBLE_REGRIDDING: + angle = rgd.initialize_grid_rotation_angle(self.hgrid) + INC -= np.radians(angle.data[np.newaxis, :]) ua, va, up, vp = ep2ap(SEMA, ECC, INC, PHA) + # Regrid back to real boundary + if rotational_method == rgd.RotationMethod.KEITH_DOUBLE_REGRIDDING: + coords = rgd.coords(self.hgrid, self.orientation, self.segment_name) + ua_regrid = rgd.create_regridder(ua, coords, ".temp") + ua = ua_regrid(ua) + va_regrid = rgd.create_regridder(va, coords, ".temp") + va = va_regrid(va) + up_regrid = rgd.create_regridder(up, coords, ".temp") + up = up_regrid(up) + vp_regrid = rgd.create_regridder(vp, coords, ".temp") + vp = vp_regrid(vp) + # Convert to real amplitude and phase. ds_ap = xr.Dataset( {f"uamp_{self.segment_name}": ua, f"vamp_{self.segment_name}": va} From 2796839f749ddcb84bf88a91d00f71cee90ebde7 Mon Sep 17 00:00:00 2001 From: manishvenu Date: Tue, 10 Dec 2024 09:56:35 -0700 Subject: [PATCH 23/87] Tidal Rotational Methods Completed --- regional_mom6/regional_mom6.py | 78 ++++++++++++++++++++++++++++------ regional_mom6/regridding.py | 18 +++++--- 2 files changed, 75 insertions(+), 21 deletions(-) diff --git a/regional_mom6/regional_mom6.py b/regional_mom6/regional_mom6.py index 1ab7ad6c..23fe0b85 100644 --- a/regional_mom6/regional_mom6.py +++ b/regional_mom6/regional_mom6.py @@ -593,6 +593,7 @@ def create_empty( tidal_constituents=["M2", "S2", "N2", "K2", "K1", "O1", "P1", "Q1", "MM", "MF"], expt_name=None, boundaries=["south", "north", "west", "east"], + rotational_method=rgd.RotationMethod.GIVEN_ANGLE, ): """ Substitute init method to creates an empty expirement object, with the opportunity to override whatever values wanted. @@ -614,6 +615,7 @@ def create_empty( repeat_year_forcing=None, tidal_constituents=None, expt_name=None, + rotational_method=None, ) expt.expt_name = expt_name @@ -635,6 +637,7 @@ def create_empty( expt.layout = None self.segments = {} self.boundaries = boundaries + self.rotational_method = rotational_method return expt def __init__( @@ -658,6 +661,7 @@ def __init__( create_empty=False, expt_name=None, boundaries=["south", "north", "west", "east"], + rotational_method=rgd.RotationMethod.GIVEN_ANGLE, ): # Creates empty experiment object for testing and experienced user manipulation. @@ -694,7 +698,7 @@ def __init__( self.layout = None # This should be a tuple. Leaving in a dummy 'None' makes it easy to remind the user to provide a value later on. self.minimum_depth = minimum_depth # Minimum depth allowed in bathy file self.tidal_constituents = tidal_constituents - + self.rotational_method = rotational_method if hgrid_type == "from_file": try: self.hgrid = xr.open_dataset(self.mom_input_dir / "hgrid.nc") @@ -1542,6 +1546,7 @@ def setup_ocean_state_boundaries( varnames, arakawa_grid="A", boundary_type="rectangular", + rotational_method=rgd.RotationMethod.GIVEN_ANGLE, ): """ This function is a wrapper for `simple_boundary`. Given a list of up to four cardinal directions, @@ -1592,6 +1597,7 @@ def setup_ocean_state_boundaries( orientation ), # A number to identify the boundary; indexes from 1 arakawa_grid=arakawa_grid, + rotational_method=rotational_method, ) def setup_single_boundary( @@ -1602,6 +1608,7 @@ def setup_single_boundary( segment_number, arakawa_grid="A", boundary_type="simple", + rotational_method=rgd.RotationMethod.GIVEN_ANGLE, ): """ Here 'simple' refers to boundaries that are parallel to lines of constant longitude or latitude. @@ -1642,7 +1649,9 @@ def setup_single_boundary( repeat_year_forcing=self.repeat_year_forcing, ) - self.segments[orientation].regrid_velocity_tracers() + self.segments[orientation].regrid_velocity_tracers( + rotational_method=rotational_method + ) print("Done.") return @@ -1653,6 +1662,7 @@ def setup_boundary_tides( tpxo_velocity_filepath, tidal_constituents="read_from_expt_init", boundary_type="rectangle", + rotational_method=rgd.RotationMethod.GIVEN_ANGLE, ): """ This function: @@ -1749,7 +1759,9 @@ def setup_boundary_tides( seg = self.segments[b] # Output and regrid tides - seg.regrid_tides(tpxo_v, tpxo_u, tpxo_h, times) + seg.regrid_tides( + tpxo_v, tpxo_u, tpxo_h, times, rotational_method=rotational_method + ) print("Done") def setup_bathymetry( @@ -3364,28 +3376,66 @@ def regrid_tides( angle = coords["angle"] # Fred's grid is in degrees INC -= np.radians(angle.data[np.newaxis, :]) elif rotational_method == rgd.RotationMethod.FRED_AVERAGE: - degree_angle = rgd.initialize_hgrid_rotation_angles_using_pseudo_hgrid( - self.hgrid + + self.hgrid["angle_dx_rm6"] = ( + rgd.initialize_hgrid_rotation_angles_using_pseudo_hgrid(self.hgrid) ) + breakpoint() + degree_angle = rgd.coords( + self.hgrid, + self.orientation, + self.segment_name, + angle_variable_name="angle_dx_rm6", + )["angle"] INC -= np.radians(degree_angle.data[np.newaxis, :]) elif rotational_method == rgd.RotationMethod.KEITH_DOUBLE_REGRIDDING: - angle = rgd.initialize_grid_rotation_angle(self.hgrid) + ds = rgd.get_hgrid_arakawa_c_points(self.hgrid, "t") + self.hgrid["angle_dx_rm6"] = xr.full_like(self.hgrid["angle_dx"], np.nan) + self.hgrid["angle_dx_rm6"][ds.t_points_y.values, ds.t_points_x.values] = ( + rgd.initialize_grid_rotation_angle(self.hgrid) + ) + angle = rgd.coords( + self.hgrid, + self.orientation, + self.segment_name, + coords_at_t_points=True, + angle_variable_name="angle_dx_rm6", + )["angle"] INC -= np.radians(angle.data[np.newaxis, :]) ua, va, up, vp = ep2ap(SEMA, ECC, INC, PHA) # Regrid back to real boundary if rotational_method == rgd.RotationMethod.KEITH_DOUBLE_REGRIDDING: coords = rgd.coords(self.hgrid, self.orientation, self.segment_name) - ua_regrid = rgd.create_regridder(ua, coords, ".temp") - ua = ua_regrid(ua) - va_regrid = rgd.create_regridder(va, coords, ".temp") - va = va_regrid(va) - up_regrid = rgd.create_regridder(up, coords, ".temp") - up = up_regrid(up) - vp_regrid = rgd.create_regridder(vp, coords, ".temp") - vp = vp_regrid(vp) + + ## Reorganize regridding into 2D + ds = xr.Dataset() + expanded_lat = np.tile(ua.lat, (1, 1)) + expanded_lon = np.tile(ua.lon, (1, 1)) + ds["lat"] = xr.DataArray(expanded_lat, dims=("y", "x")) + ds["lon"] = xr.DataArray(expanded_lon, dims=("y", "x")) + + exp_ua = [ua] + ds["ua"] = xr.DataArray(exp_ua, dims=("y", "constituent", "x")) + + exp_va = [va] + ds["va"] = xr.DataArray(exp_va, dims=("y", "constituent", "x")) + + exp_vp = [vp] + ds["vp"] = xr.DataArray(exp_vp, dims=("y", "constituent", "x")) + + exp_up = [up] + ds["up"] = xr.DataArray(exp_up, dims=("y", "constituent", "x")) + + regridder = rgd.create_regridder(ds, coords, ".temp", method="nearest_s2d") + + ua = regridder(ds["ua"]) + va = regridder(ds["va"]) + up = regridder(ds["up"]).data + vp = regridder(ds["vp"]).data # Convert to real amplitude and phase. + ds_ap = xr.Dataset( {f"uamp_{self.segment_name}": ua, f"vamp_{self.segment_name}": va} ) diff --git a/regional_mom6/regridding.py b/regional_mom6/regridding.py index 2e66c83e..2805d8cc 100644 --- a/regional_mom6/regridding.py +++ b/regional_mom6/regridding.py @@ -56,7 +56,11 @@ class RotationMethod(Enum): def coords( - hgrid: xr.Dataset, orientation: str, segment_name: str, coords_at_t_points=False + hgrid: xr.Dataset, + orientation: str, + segment_name: str, + coords_at_t_points=False, + angle_variable_name="angle_dx", ) -> xr.Dataset: """ This function: @@ -88,13 +92,13 @@ def coords( # Calc T Point Info ds = get_hgrid_arakawa_c_points(hgrid, "t") - tangle_dx = hgrid["angle_dx"][(ds.t_points_y, ds.t_points_x)] + tangle_dx = hgrid[angle_variable_name][(ds.t_points_y, ds.t_points_x)] # Assign to dataset dataset_to_get_coords = xr.Dataset( { "x": ds.tlon, "y": ds.tlat, - "angle_dx": (("nyp", "nxp"), tangle_dx.values), + angle_variable_name: (("nyp", "nxp"), tangle_dx.values), }, coords={"nyp": ds.nyp, "nxp": ds.nxp}, ) @@ -109,7 +113,7 @@ def coords( { "lon": dataset_to_get_coords["x"].isel(nyp=0), "lat": dataset_to_get_coords["y"].isel(nyp=0), - "angle": dataset_to_get_coords["angle_dx"].isel(nyp=0), + "angle": dataset_to_get_coords[angle_variable_name].isel(nyp=0), } ) rcoord = rcoord.rename_dims({"nxp": f"nx_{segment_name}"}) @@ -123,7 +127,7 @@ def coords( { "lon": dataset_to_get_coords["x"].isel(nyp=-1), "lat": dataset_to_get_coords["y"].isel(nyp=-1), - "angle": dataset_to_get_coords["angle_dx"].isel(nyp=-1), + "angle": dataset_to_get_coords[angle_variable_name].isel(nyp=-1), } ) rcoord = rcoord.rename_dims({"nxp": f"nx_{segment_name}"}) @@ -135,7 +139,7 @@ def coords( { "lon": dataset_to_get_coords["x"].isel(nxp=0), "lat": dataset_to_get_coords["y"].isel(nxp=0), - "angle": dataset_to_get_coords["angle_dx"].isel(nxp=0), + "angle": dataset_to_get_coords[angle_variable_name].isel(nxp=0), } ) rcoord = rcoord.rename_dims({"nyp": f"ny_{segment_name}"}) @@ -147,7 +151,7 @@ def coords( { "lon": dataset_to_get_coords["x"].isel(nxp=-1), "lat": dataset_to_get_coords["y"].isel(nxp=-1), - "angle": dataset_to_get_coords["angle_dx"].isel(nxp=-1), + "angle": dataset_to_get_coords[angle_variable_name].isel(nxp=-1), } ) rcoord = rcoord.rename_dims({"nyp": f"ny_{segment_name}"}) From 3fffc034fc35d6648be8c21f25077994e9ade94f Mon Sep 17 00:00:00 2001 From: manishvenu Date: Tue, 10 Dec 2024 11:18:22 -0700 Subject: [PATCH 24/87] Finish rotational methods for velocity_tracers --- regional_mom6/regional_mom6.py | 207 ++++++++++++++++++++++++++++----- 1 file changed, 181 insertions(+), 26 deletions(-) diff --git a/regional_mom6/regional_mom6.py b/regional_mom6/regional_mom6.py index 23fe0b85..f23a8c52 100644 --- a/regional_mom6/regional_mom6.py +++ b/regional_mom6/regional_mom6.py @@ -2973,30 +2973,82 @@ def regrid_velocity_tracers(self, rotational_method=rgd.RotationMethod.GIVEN_ANG radian_angle=np.radians(coords.angle.values), ) elif rotational_method == rgd.RotationMethod.FRED_AVERAGE: - degree_angle = rgd.initialize_hgrid_rotation_angles_using_pseudo_hgrid( - self.hgrid - ) + self.hgrid["angle_dx_rm6"] = ( + rgd.initialize_hgrid_rotation_angles_using_pseudo_hgrid(self.hgrid) + ) + degree_angle = rgd.coords( + self.hgrid, + self.orientation, + self.segment_name, + angle_variable_name="angle_dx_rm6", + )["angle"] rotated_u, rotated_v = self.rotate( regridded[self.u], regridded[self.v], radian_angle=np.radians(degree_angle.values), ) elif rotational_method == rgd.RotationMethod.KEITH_DOUBLE_REGRIDDING: - degree_angle = rgd.initialize_grid_rotation_angle(self.hgrid) + ds = rgd.get_hgrid_arakawa_c_points(self.hgrid, "t") + self.hgrid["angle_dx_rm6"] = xr.full_like( + self.hgrid["angle_dx"], np.nan + ) + self.hgrid["angle_dx_rm6"][ + ds.t_points_y.values, ds.t_points_x.values + ] = rgd.initialize_grid_rotation_angle(self.hgrid) + degree_angle = rgd.coords( + self.hgrid, + self.orientation, + self.segment_name, + coords_at_t_points=True, + angle_variable_name="angle_dx_rm6", + )["angle"] rotated_u, rotated_v = self.rotate( regridded[self.u], regridded[self.v], radian_angle=np.radians(degree_angle.values), ) - coords = rgd.coords(self.hgrid, self.orientation, self.segment_name) - u_regridder = rgd.create_regridder(rotated_u, coords, ".temp") - v_regridder = rgd.create_regridder(rotated_v, coords, ".temp") - rotated_u = u_regridder(rotated_u) - rotated_v = v_regridder(rotated_v) + + ds = xr.Dataset() + + expanded_lat = np.tile(rotated_u.lat, (1, 1)) + expanded_lon = np.tile(rotated_u.lon, (1, 1)) + ds["lat"] = xr.DataArray(expanded_lat, dims=("y", "x")) + ds["lon"] = xr.DataArray(expanded_lon, dims=("y", "x")) + + exp_rotated_u = [rotated_u] + ds["rotated_u"] = xr.DataArray( + exp_rotated_u, dims=("y", "time", "depth", "x") + ) + + exp_rotated_v = [rotated_v] + ds["rotated_v"] = xr.DataArray( + exp_rotated_v, dims=("y", "time", "depth", "x") + ) + + regridder_keith = rgd.create_regridder( + ds, coords, ".temp", method="nearest_s2d" + ) + rotated_u = regridder_keith(ds["rotated_u"]) + rotated_v = regridder_keith(ds["rotated_v"]) + + ## Also need to re-regrid the rest of the variables with the correct coords + regridder = rgd.create_regridder( + rawseg[self.u], + coords, + self.outfolder + / f"weights/bilinear_velocity_weights_{self.orientation}.nc", + ) + regridded = regridder( + rawseg[ + [self.u, self.v, self.eta] + + [self.tracers[i] for i in self.tracers] + ] + ) elif rotational_method == rgd.RotationMethod.NO_ROTATION: rotated_u, rotated_v = regridded[self.u], regridded[self.v] + rotated_ds = xr.Dataset( { self.u: rotated_u, @@ -3030,16 +3082,35 @@ def regrid_velocity_tracers(self, rotational_method=rgd.RotationMethod.GIVEN_ANG radian_angle=np.radians(coords.angle.values), ) elif rotational_method == rgd.RotationMethod.FRED_AVERAGE: - degree_angle = rgd.initialize_hgrid_rotation_angles_using_pseudo_hgrid( - self.hgrid - ) + self.hgrid["angle_dx_rm6"] = ( + rgd.initialize_hgrid_rotation_angles_using_pseudo_hgrid(self.hgrid) + ) + degree_angle = rgd.coords( + self.hgrid, + self.orientation, + self.segment_name, + angle_variable_name="angle_dx_rm6", + )["angle"] velocities_out["u"], velocities_out["v"] = self.rotate( velocities_out["u"], velocities_out["v"], radian_angle=np.radians(degree_angle.values), ) elif rotational_method == rgd.RotationMethod.KEITH_DOUBLE_REGRIDDING: - degree_angle = rgd.initialize_grid_rotation_angle(self.hgrid) + ds = rgd.get_hgrid_arakawa_c_points(self.hgrid, "t") + self.hgrid["angle_dx_rm6"] = xr.full_like( + self.hgrid["angle_dx"], np.nan + ) + self.hgrid["angle_dx_rm6"][ + ds.t_points_y.values, ds.t_points_x.values + ] = rgd.initialize_grid_rotation_angle(self.hgrid) + degree_angle = rgd.coords( + self.hgrid, + self.orientation, + self.segment_name, + coords_at_t_points=True, + angle_variable_name="angle_dx_rm6", + )["angle"] velocities_out["u"], velocities_out["v"] = self.rotate( velocities_out["u"], velocities_out["v"], @@ -3047,10 +3118,44 @@ def regrid_velocity_tracers(self, rotational_method=rgd.RotationMethod.GIVEN_ANG ) coords = rgd.coords(self.hgrid, self.orientation, self.segment_name) - u_regridder = rgd.create_regridder(velocities_out["u"], coords, ".temp") - v_regridder = rgd.create_regridder(velocities_out["v"], coords, ".temp") - velocities_out["u"] = u_regridder(velocities_out["u"]) - velocities_out["v"] = v_regridder(velocities_out["v"]) + + ds = xr.Dataset() + + expanded_lat = np.tile(velocities_out["u"].lat, (1, 1)) + expanded_lon = np.tile(velocities_out["u"].lon, (1, 1)) + ds["lat"] = xr.DataArray(expanded_lat, dims=("y", "x")) + ds["lon"] = xr.DataArray(expanded_lon, dims=("y", "x")) + + exp_rotated_u = [velocities_out["u"]] + ds["rotated_u"] = xr.DataArray( + exp_rotated_u, dims=("y", "time", "depth", "x") + ) + + exp_rotated_v = [velocities_out["v"]] + ds["rotated_v"] = xr.DataArray( + exp_rotated_v, dims=("y", "time", "depth", "x") + ) + + regridder_keith = rgd.create_regridder( + ds, coords, ".temp", method="nearest_s2d" + ) + velocities_out["u"] = regridder_keith(ds["rotated_u"]) + velocities_out["v"] = regridder_keith(ds["rotated_v"]) + + ## Also need to re-regrid the rest of the variables with the correct coords + regridder = rgd.create_regridder( + rawseg[self.u], + coords, + self.outfolder + / f"weights/bilinear_velocity_weights_{self.orientation}.nc", + ) + regridded = regridder( + rawseg[ + [self.u, self.v, self.eta] + + [self.tracers[i] for i in self.tracers] + ] + ) + elif rotational_method == rgd.RotationMethod.NO_ROTATION: velocities_out["u"], velocities_out["v"] = ( velocities_out["u"], @@ -3100,16 +3205,35 @@ def regrid_velocity_tracers(self, rotational_method=rgd.RotationMethod.GIVEN_ANG radian_angle=np.radians(coords.angle.values), ) elif rotational_method == rgd.RotationMethod.FRED_AVERAGE: - degree_angle = rgd.initialize_hgrid_rotation_angles_using_pseudo_hgrid( - self.hgrid - ) + self.hgrid["angle_dx_rm6"] = ( + rgd.initialize_hgrid_rotation_angles_using_pseudo_hgrid(self.hgrid) + ) + degree_angle = rgd.coords( + self.hgrid, + self.orientation, + self.segment_name, + angle_variable_name="angle_dx_rm6", + )["angle"] rotated_u, rotated_v = self.rotate( regridded[self.u], regridded[self.v], radian_angle=np.radians(degree_angle.values), ) elif rotational_method == rgd.RotationMethod.KEITH_DOUBLE_REGRIDDING: - degree_angle = rgd.initialize_grid_rotation_angle(self.hgrid) + ds = rgd.get_hgrid_arakawa_c_points(self.hgrid, "t") + self.hgrid["angle_dx_rm6"] = xr.full_like( + self.hgrid["angle_dx"], np.nan + ) + self.hgrid["angle_dx_rm6"][ + ds.t_points_y.values, ds.t_points_x.values + ] = rgd.initialize_grid_rotation_angle(self.hgrid) + degree_angle = rgd.coords( + self.hgrid, + self.orientation, + self.segment_name, + coords_at_t_points=True, + angle_variable_name="angle_dx_rm6", + )["angle"] rotated_u, rotated_v = self.rotate( regridded[self.u], regridded[self.v], @@ -3117,10 +3241,42 @@ def regrid_velocity_tracers(self, rotational_method=rgd.RotationMethod.GIVEN_ANG ) coords = rgd.coords(self.hgrid, self.orientation, self.segment_name) - u_regridder = rgd.create_regridder(rotated_u, coords, ".temp") - v_regridder = rgd.create_regridder(rotated_v, coords, ".temp") - rotated_u = u_regridder(rotated_u) - rotated_v = v_regridder(rotated_v) + ds = xr.Dataset() + + expanded_lat = np.tile(rotated_u.lat, (1, 1)) + expanded_lon = np.tile(rotated_u.lon, (1, 1)) + ds["lat"] = xr.DataArray(expanded_lat, dims=("y", "x")) + ds["lon"] = xr.DataArray(expanded_lon, dims=("y", "x")) + + exp_rotated_u = [rotated_u] + ds["rotated_u"] = xr.DataArray( + exp_rotated_u, dims=("y", "time", "depth", "x") + ) + + exp_rotated_v = [rotated_v] + ds["rotated_v"] = xr.DataArray( + exp_rotated_v, dims=("y", "time", "depth", "x") + ) + + regridder_keith = rgd.create_regridder( + ds, coords, ".temp", method="nearest_s2d" + ) + rotated_u = regridder_keith(ds["rotated_u"]) + rotated_v = regridder_keith(ds["rotated_v"]) + + ## Also need to re-regrid the rest of the variables with the correct coords + regridder = rgd.create_regridder( + rawseg[self.u], + coords, + self.outfolder + / f"weights/bilinear_velocity_weights_{self.orientation}.nc", + ) + regridded = regridder( + rawseg[ + [self.u, self.v, self.eta] + + [self.tracers[i] for i in self.tracers] + ] + ) elif rotational_method == rgd.RotationMethod.NO_ROTATION: rotated_u, rotated_v = regridded[self.u], regridded[self.v] rotated_ds = xr.Dataset( @@ -3380,7 +3536,6 @@ def regrid_tides( self.hgrid["angle_dx_rm6"] = ( rgd.initialize_hgrid_rotation_angles_using_pseudo_hgrid(self.hgrid) ) - breakpoint() degree_angle = rgd.coords( self.hgrid, self.orientation, From e632e2c80cbb1f0588666435cf21cf0c92016df0 Mon Sep 17 00:00:00 2001 From: manishvenu Date: Tue, 10 Dec 2024 11:51:02 -0700 Subject: [PATCH 25/87] Combine the grid_rotation_calc for fred_pseudo and mom6 general (keiths) --- regional_mom6/regridding.py | 212 ++++++++++++++++-------------------- 1 file changed, 96 insertions(+), 116 deletions(-) diff --git a/regional_mom6/regridding.py b/regional_mom6/regridding.py index 2805d8cc..64b01404 100644 --- a/regional_mom6/regridding.py +++ b/regional_mom6/regridding.py @@ -453,63 +453,54 @@ def modulo_around_point(x, xc, Lx): return ((x - (xc - 0.5 * Lx)) % Lx) - Lx / 2 + xc -def initialize_grid_rotation_angle(hgrid: xr.Dataset) -> xr.Dataset: +def mom6_angle_calculation_method( + len_lon, + top_left: xr.DataArray, + top_right: xr.DataArray, + bottom_left: xr.DataArray, + bottom_right: xr.DataArray, + point: xr.DataArray, +) -> xr.DataArray: """ - Calculate the angle_dx in degrees from the true x (east?) direction counterclockwise) and return as DataArray + Calculate the angle of the point using the MOM6 method in initialize_grid_rotation_angle. Built for vectorized calculations Parameters ---------- - hgrid: xr.Dataset - The hgrid dataset + len_lon: float + The length of the longitude of the regional domain + top_left, top_right, bottom_left, bottom_right: xr.DataArray + The four points around the point to calculate the angle from the hgrid requires an x and y component + point: xr.DataArray + The point to calculate the angle from the hgrid Returns ------- xr.DataArray - The t-point angles + The angle of the point """ - regridding_logger.info("Initializing grid rotation angle") + regridding_logger.info("Calculating grid rotation angle") # Direct Translation pi_720deg = ( np.arctan(1) / 180 ) # One quarter the conversion factor from degrees to radians - ## Check length of longitude - G_len_lon = ( - hgrid.x.max() - hgrid.x.min() - ) # We're always going to be working with the regional case.... in the global case len_lon is different, and is a check in the actual MOM code. - len_lon = G_len_lon - - # Get the tlon and tlat - ds_t = get_hgrid_arakawa_c_points(hgrid, "t") - tlon = ds_t.tlon - ds_q = get_hgrid_arakawa_c_points(hgrid, "q") - qlon = ds_q.qlon - qlat = ds_q.qlat - angles_arr = np.zeros((len(tlon.nyp), len(tlon.nxp))) - # Compute lonB for all points - lonB = np.zeros((2, 2, len(tlon.nyp), len(tlon.nxp))) + lonB = np.zeros((2, 2, len(point.nyp), len(point.nxp))) # Vectorized computation of lonB - for n in np.arange(0, 2): - for m in np.arange(0, 2): - lonB[m, n] = modulo_around_point( - qlon[ - np.arange(m, (m - 1 + len(qlon.nyp))), - np.arange(n, (n - 1 + len(qlon.nxp))), - ], - tlon, - len_lon, - ) + # Vectorized computation of lonB + lonB[0][0] = modulo_around_point(bottom_left.x, point.x, len_lon) # Bottom Left + lonB[1][0] = modulo_around_point(top_left.x, point.x, len_lon) # Top Left + lonB[1][1] = modulo_around_point(top_right.x, point.x, len_lon) # Top Right + lonB[0][1] = modulo_around_point(bottom_right.x, point.x, len_lon) # Bottom Right # Compute lon_scale lon_scale = np.cos( - pi_720deg - * ((qlat[0:-1, 0:-1] + qlat[1:, 1:]) + (qlat[1:, 0:-1] + qlat[0:-1, 1:])) + pi_720deg * ((bottom_left.y + bottom_right.y) + (top_right.y + top_left.y)) ) # Compute angle angle = np.arctan2( lon_scale * ((lonB[0, 1] - lonB[1, 0]) + (lonB[1, 1] - lonB[0, 0])), - (qlat[:-1, :-1] - qlat[1:, 1:]) + (qlat[1:, 0:-1] - qlat[0:-1, 1:]), + (bottom_left.y - top_right.y) + (top_left.y - bottom_right.y), ) # Assign angle to angles_arr angles_arr = np.rad2deg(angle) - 90 @@ -519,13 +510,82 @@ def initialize_grid_rotation_angle(hgrid: xr.Dataset) -> xr.Dataset: angles_arr, dims=["nyp", "nxp"], coords={ - "nyp": tlon.nyp.values, - "nxp": tlon.nxp.values, + "nyp": point.nyp.values, + "nxp": point.nxp.values, }, ) return t_angles +def initialize_hgrid_rotation_angles_using_pseudo_hgrid( + hgrid: xr.Dataset, +) -> xr.Dataset: + """ + Calculate the angle_dx in degrees from the true x (east?) direction counterclockwise) and return as dataarray + + Parameters + ---------- + hgrid: xr.Dataset + The hgrid dataset + pseudo_hgrid: xr.Dataset + The pseudo hgrid dataset + Returns + ------- + xr.DataArray + The t-point angles + """ + # Get Fred Pseudo grid + pseudo_hgrid = create_pseudo_hgrid(hgrid) + + return mom6_angle_calculation_method( + pseudo_hgrid.x.max() - pseudo_hgrid.x.min(), + pseudo_hgrid.isel(nyp=slice(2, None), nxp=slice(0, -2)), + pseudo_hgrid.isel(nyp=slice(2, None), nxp=slice(2, None)), + pseudo_hgrid.isel(nyp=slice(0, -2), nxp=slice(0, -2)), + pseudo_hgrid.isel(nyp=slice(0, -2), nxp=slice(2, None)), + hgrid, + ) + + +def initialize_grid_rotation_angle(hgrid: xr.Dataset) -> xr.DataArray: + """ + Calculate the angle_dx in degrees from the true x (east?) direction counterclockwise) and return as DataArray + Parameters + ---------- + hgrid: xr.Dataset + The hgrid dataset + Returns + ------- + xr.DataArray + The t-point angles + """ + ds_t = get_hgrid_arakawa_c_points(hgrid, "t") + ds_q = get_hgrid_arakawa_c_points(hgrid, "q") + + # Reformat into x, y comps + t_points = xr.Dataset( + { + "x": (("nyp", "nxp"), ds_t.tlon.data), + "y": (("nyp", "nxp"), ds_t.tlat.data), + } + ) + q_points = xr.Dataset( + { + "x": (("nyp", "nxp"), ds_q.qlon.data), + "y": (("nyp", "nxp"), ds_q.qlat.data), + } + ) + + return mom6_angle_calculation_method( + hgrid.x.max() - hgrid.x.min(), + q_points.isel(nyp=slice(1, None), nxp=slice(0, -1)), + q_points.isel(nyp=slice(1, None), nxp=slice(1, None)), + q_points.isel(nyp=slice(0, -1), nxp=slice(0, -1)), + q_points.isel(nyp=slice(0, -1), nxp=slice(1, None)), + t_points, + ) + + def get_hgrid_arakawa_c_points(hgrid: xr.Dataset, point_type="t") -> xr.Dataset: """ Get the Arakawa C points from the Hgrid, originally written by Fred (Castruccio) and moved to RM6 @@ -650,83 +710,3 @@ def create_pseudo_hgrid(hgrid: xr.Dataset) -> xr.Dataset: } ) return pseudo_hgrid - - -def initialize_hgrid_rotation_angles_using_pseudo_hgrid( - hgrid: xr.Dataset, -) -> xr.Dataset: - """ - Calculate the angle_dx in degrees from the true x (east?) direction counterclockwise) and return as dataarray - - Parameters - ---------- - hgrid: xr.Dataset - The hgrid dataset - pseudo_hgrid: xr.Dataset - The pseudo hgrid dataset - Returns - ------- - xr.DataArray - The t-point angles - """ - # Get Fred Pseudo grid - pseudo_hgrid = create_pseudo_hgrid(hgrid) - - # Direct Translation - pi_720deg = ( - np.arctan(1) / 180 - ) # One quarter the conversion factor from degrees to radians - - ## Check length of longitude - G_len_lon = ( - pseudo_hgrid.x.max() - pseudo_hgrid.x.min() - ) # We're always going to be working with the regional case.... in the global case len_lon is different, and is a check in the actual MOM code. - len_lon = G_len_lon - - angles_arr = np.zeros((len(hgrid.nyp), len(hgrid.nxp))) - - # Compute lonB for all points - lonB = np.zeros((2, 2, len(hgrid.nyp), len(hgrid.nxp))) - - # Vectorized computation of lonB - lonB[0][0] = modulo_around_point( - pseudo_hgrid.x[:-2, :-2], hgrid.x, len_lon - ) # Bottom Left - lonB[1][0] = modulo_around_point( - pseudo_hgrid.x[2:, :-2], hgrid.x, len_lon - ) # Top Left - lonB[1][1] = modulo_around_point( - pseudo_hgrid.x[2:, 2:], hgrid.x, len_lon - ) # Top Right - lonB[0][1] = modulo_around_point( - pseudo_hgrid.x[:-2, 2:], hgrid.x, len_lon - ) # Bottom Right - - # Compute lon_scale - lon_scale = np.cos( - pi_720deg - * ( - (pseudo_hgrid.y[:-2, :-2] + pseudo_hgrid.y[:-2, 2:]) - + (pseudo_hgrid.y[2:, 2:] + pseudo_hgrid.y[2:, :-2]) - ) - ) - - # Compute angle - angle = np.arctan2( - lon_scale * ((lonB[0, 1] - lonB[1, 0]) + (lonB[1, 1] - lonB[0, 0])), - (pseudo_hgrid.y[:-2, :-2] - pseudo_hgrid.y[2:, 2:]) - + (pseudo_hgrid.y[2:, :-2] - pseudo_hgrid.y[:-2, 2:]), - ) - # Assign angle to angles_arr - angles_arr = np.rad2deg(angle) - 90 - - # Assign angles_arr to hgrid - t_angles = xr.DataArray( - angles_arr, - dims=["nyp", "nxp"], - coords={ - "nyp": hgrid.nyp.values, - "nxp": hgrid.nxp.values, - }, - ) - return t_angles From 8a29dddb7e0c44e830221c1cf0447973c3196ff9 Mon Sep 17 00:00:00 2001 From: manishvenu Date: Tue, 10 Dec 2024 12:09:37 -0700 Subject: [PATCH 26/87] Move rotation/angle functions to a different file --- regional_mom6/regional_mom6.py | 71 +++---- regional_mom6/regridding.py | 354 +++++---------------------------- regional_mom6/rotation.py | 251 +++++++++++++++++++++++ 3 files changed, 341 insertions(+), 335 deletions(-) create mode 100644 regional_mom6/rotation.py diff --git a/regional_mom6/regional_mom6.py b/regional_mom6/regional_mom6.py index f23a8c52..35f09830 100644 --- a/regional_mom6/regional_mom6.py +++ b/regional_mom6/regional_mom6.py @@ -22,6 +22,7 @@ import json import copy from . import regridding as rgd +from . import rotation as rot warnings.filterwarnings("ignore") @@ -593,7 +594,7 @@ def create_empty( tidal_constituents=["M2", "S2", "N2", "K2", "K1", "O1", "P1", "Q1", "MM", "MF"], expt_name=None, boundaries=["south", "north", "west", "east"], - rotational_method=rgd.RotationMethod.GIVEN_ANGLE, + rotational_method=rot.RotationMethod.GIVEN_ANGLE, ): """ Substitute init method to creates an empty expirement object, with the opportunity to override whatever values wanted. @@ -661,7 +662,7 @@ def __init__( create_empty=False, expt_name=None, boundaries=["south", "north", "west", "east"], - rotational_method=rgd.RotationMethod.GIVEN_ANGLE, + rotational_method=rot.RotationMethod.GIVEN_ANGLE, ): # Creates empty experiment object for testing and experienced user manipulation. @@ -1546,7 +1547,7 @@ def setup_ocean_state_boundaries( varnames, arakawa_grid="A", boundary_type="rectangular", - rotational_method=rgd.RotationMethod.GIVEN_ANGLE, + rotational_method=rot.RotationMethod.GIVEN_ANGLE, ): """ This function is a wrapper for `simple_boundary`. Given a list of up to four cardinal directions, @@ -1608,7 +1609,7 @@ def setup_single_boundary( segment_number, arakawa_grid="A", boundary_type="simple", - rotational_method=rgd.RotationMethod.GIVEN_ANGLE, + rotational_method=rot.RotationMethod.GIVEN_ANGLE, ): """ Here 'simple' refers to boundaries that are parallel to lines of constant longitude or latitude. @@ -1662,7 +1663,7 @@ def setup_boundary_tides( tpxo_velocity_filepath, tidal_constituents="read_from_expt_init", boundary_type="rectangle", - rotational_method=rgd.RotationMethod.GIVEN_ANGLE, + rotational_method=rot.RotationMethod.GIVEN_ANGLE, ): """ This function: @@ -2932,18 +2933,18 @@ def rotate(self, u, v, radian_angle): v_rot = u * np.sin(radian_angle) + v * np.cos(radian_angle) return u_rot, v_rot - def regrid_velocity_tracers(self, rotational_method=rgd.RotationMethod.GIVEN_ANGLE): + def regrid_velocity_tracers(self, rotational_method=rot.RotationMethod.GIVEN_ANGLE): """ Cut out and interpolate the velocities and tracers Paramaters ---------- - rotational_method: rgd.RotationMethod + rotational_method: rot.RotationMethod The method to use for rotation of the velocities. Currently, the default method, GIVEN_ANGLE, works even with non-rotated grids """ rawseg = xr.open_dataset(self.infile, decode_times=False, engine="netcdf4") - if rotational_method == rgd.RotationMethod.KEITH_DOUBLE_REGRIDDING: + if rotational_method == rot.RotationMethod.KEITH_DOUBLE_REGRIDDING: coords = rgd.coords( self.hgrid, self.orientation, self.segment_name, coords_at_t_points=True ) @@ -2966,15 +2967,15 @@ def regrid_velocity_tracers(self, rotational_method=rgd.RotationMethod.GIVEN_ANG [self.u, self.v, self.eta] + [self.tracers[i] for i in self.tracers] ] ) - if rotational_method == rgd.RotationMethod.GIVEN_ANGLE: + if rotational_method == rot.RotationMethod.GIVEN_ANGLE: rotated_u, rotated_v = self.rotate( regridded[self.u], regridded[self.v], radian_angle=np.radians(coords.angle.values), ) - elif rotational_method == rgd.RotationMethod.FRED_AVERAGE: + elif rotational_method == rot.RotationMethod.FRED_AVERAGE: self.hgrid["angle_dx_rm6"] = ( - rgd.initialize_hgrid_rotation_angles_using_pseudo_hgrid(self.hgrid) + rot.initialize_hgrid_rotation_angles_using_pseudo_hgrid(self.hgrid) ) degree_angle = rgd.coords( self.hgrid, @@ -2987,14 +2988,14 @@ def regrid_velocity_tracers(self, rotational_method=rgd.RotationMethod.GIVEN_ANG regridded[self.v], radian_angle=np.radians(degree_angle.values), ) - elif rotational_method == rgd.RotationMethod.KEITH_DOUBLE_REGRIDDING: + elif rotational_method == rot.RotationMethod.KEITH_DOUBLE_REGRIDDING: ds = rgd.get_hgrid_arakawa_c_points(self.hgrid, "t") self.hgrid["angle_dx_rm6"] = xr.full_like( self.hgrid["angle_dx"], np.nan ) self.hgrid["angle_dx_rm6"][ ds.t_points_y.values, ds.t_points_x.values - ] = rgd.initialize_grid_rotation_angle(self.hgrid) + ] = rot.initialize_grid_rotation_angle(self.hgrid) degree_angle = rgd.coords( self.hgrid, self.orientation, @@ -3046,7 +3047,7 @@ def regrid_velocity_tracers(self, rotational_method=rgd.RotationMethod.GIVEN_ANG ] ) - elif rotational_method == rgd.RotationMethod.NO_ROTATION: + elif rotational_method == rot.RotationMethod.NO_ROTATION: rotated_u, rotated_v = regridded[self.u], regridded[self.v] rotated_ds = xr.Dataset( @@ -3075,15 +3076,15 @@ def regrid_velocity_tracers(self, rotational_method=rgd.RotationMethod.GIVEN_ANG velocities_out = regridder_velocity( rawseg[[self.u, self.v]].rename({self.xq: "lon", self.yq: "lat"}) ) - if rotational_method == rgd.RotationMethod.GIVEN_ANGLE: + if rotational_method == rot.RotationMethod.GIVEN_ANGLE: velocities_out["u"], velocities_out["v"] = self.rotate( velocities_out["u"], velocities_out["v"], radian_angle=np.radians(coords.angle.values), ) - elif rotational_method == rgd.RotationMethod.FRED_AVERAGE: + elif rotational_method == rot.RotationMethod.FRED_AVERAGE: self.hgrid["angle_dx_rm6"] = ( - rgd.initialize_hgrid_rotation_angles_using_pseudo_hgrid(self.hgrid) + rot.initialize_hgrid_rotation_angles_using_pseudo_hgrid(self.hgrid) ) degree_angle = rgd.coords( self.hgrid, @@ -3096,14 +3097,14 @@ def regrid_velocity_tracers(self, rotational_method=rgd.RotationMethod.GIVEN_ANG velocities_out["v"], radian_angle=np.radians(degree_angle.values), ) - elif rotational_method == rgd.RotationMethod.KEITH_DOUBLE_REGRIDDING: + elif rotational_method == rot.RotationMethod.KEITH_DOUBLE_REGRIDDING: ds = rgd.get_hgrid_arakawa_c_points(self.hgrid, "t") self.hgrid["angle_dx_rm6"] = xr.full_like( self.hgrid["angle_dx"], np.nan ) self.hgrid["angle_dx_rm6"][ ds.t_points_y.values, ds.t_points_x.values - ] = rgd.initialize_grid_rotation_angle(self.hgrid) + ] = rot.initialize_grid_rotation_angle(self.hgrid) degree_angle = rgd.coords( self.hgrid, self.orientation, @@ -3156,7 +3157,7 @@ def regrid_velocity_tracers(self, rotational_method=rgd.RotationMethod.GIVEN_ANG ] ) - elif rotational_method == rgd.RotationMethod.NO_ROTATION: + elif rotational_method == rot.RotationMethod.NO_ROTATION: velocities_out["u"], velocities_out["v"] = ( velocities_out["u"], velocities_out["v"], @@ -3198,15 +3199,15 @@ def regrid_velocity_tracers(self, rotational_method=rgd.RotationMethod.GIVEN_ANG regridded_u = regridder_uvelocity(rawseg[[self.u]]) regridded_v = regridder_vvelocity(rawseg[[self.v]]) - if rotational_method == rgd.RotationMethod.GIVEN_ANGLE: + if rotational_method == rot.RotationMethod.GIVEN_ANGLE: rotated_u, rotated_v = self.rotate( regridded[self.u], regridded[self.v], radian_angle=np.radians(coords.angle.values), ) - elif rotational_method == rgd.RotationMethod.FRED_AVERAGE: + elif rotational_method == rot.RotationMethod.FRED_AVERAGE: self.hgrid["angle_dx_rm6"] = ( - rgd.initialize_hgrid_rotation_angles_using_pseudo_hgrid(self.hgrid) + rot.initialize_hgrid_rotation_angles_using_pseudo_hgrid(self.hgrid) ) degree_angle = rgd.coords( self.hgrid, @@ -3219,14 +3220,14 @@ def regrid_velocity_tracers(self, rotational_method=rgd.RotationMethod.GIVEN_ANG regridded[self.v], radian_angle=np.radians(degree_angle.values), ) - elif rotational_method == rgd.RotationMethod.KEITH_DOUBLE_REGRIDDING: + elif rotational_method == rot.RotationMethod.KEITH_DOUBLE_REGRIDDING: ds = rgd.get_hgrid_arakawa_c_points(self.hgrid, "t") self.hgrid["angle_dx_rm6"] = xr.full_like( self.hgrid["angle_dx"], np.nan ) self.hgrid["angle_dx_rm6"][ ds.t_points_y.values, ds.t_points_x.values - ] = rgd.initialize_grid_rotation_angle(self.hgrid) + ] = rot.initialize_grid_rotation_angle(self.hgrid) degree_angle = rgd.coords( self.hgrid, self.orientation, @@ -3277,7 +3278,7 @@ def regrid_velocity_tracers(self, rotational_method=rgd.RotationMethod.GIVEN_ANG + [self.tracers[i] for i in self.tracers] ] ) - elif rotational_method == rgd.RotationMethod.NO_ROTATION: + elif rotational_method == rot.RotationMethod.NO_ROTATION: rotated_u, rotated_v = regridded[self.u], regridded[self.v] rotated_ds = xr.Dataset( { @@ -3400,7 +3401,7 @@ def regrid_tides( tpxo_u, tpxo_h, times, - rotational_method=rgd.RotationMethod.GIVEN_ANGLE, + rotational_method=rot.RotationMethod.GIVEN_ANGLE, ): """ This function: @@ -3414,7 +3415,7 @@ def regrid_tides( infile_td (str): Raw Tidal File/Dir tpxo_v, tpxo_u, tpxo_h (xarray.Dataset): Specific adjusted for MOM6 tpxo datasets (Adjusted with setup_tides) times (pd.DateRange): The start date of our model period - rotational_method (rgd.RotationMethod): The method to use for rotation of the velocities. Currently, the default method, GIVEN_ANGLE, works even with non-rotated grids + rotational_method (rot.RotationMethod): The method to use for rotation of the velocities. Currently, the default method, GIVEN_ANGLE, works even with non-rotated grids Returns: *.nc files: Regridded tidal velocity and elevation files in 'inputdir/forcing' @@ -3491,7 +3492,7 @@ def regrid_tides( ########### Regrid Tidal Velocity ###################### # Change to t-point coords - if rotational_method == rgd.RotationMethod.KEITH_DOUBLE_REGRIDDING: + if rotational_method == rot.RotationMethod.KEITH_DOUBLE_REGRIDDING: coords = rgd.coords( self.hgrid, self.orientation, self.segment_name, coords_at_t_points=True ) @@ -3528,13 +3529,13 @@ def regrid_tides( # rotate ellipse from earth-relative to model-relative, # and convert ellipse back to amplitude and phase. SEMA, ECC, INC, PHA = ap2ep(ucplex, vcplex) - if rotational_method == rgd.RotationMethod.GIVEN_ANGLE: + if rotational_method == rot.RotationMethod.GIVEN_ANGLE: angle = coords["angle"] # Fred's grid is in degrees INC -= np.radians(angle.data[np.newaxis, :]) - elif rotational_method == rgd.RotationMethod.FRED_AVERAGE: + elif rotational_method == rot.RotationMethod.FRED_AVERAGE: self.hgrid["angle_dx_rm6"] = ( - rgd.initialize_hgrid_rotation_angles_using_pseudo_hgrid(self.hgrid) + rot.initialize_hgrid_rotation_angles_using_pseudo_hgrid(self.hgrid) ) degree_angle = rgd.coords( self.hgrid, @@ -3543,11 +3544,11 @@ def regrid_tides( angle_variable_name="angle_dx_rm6", )["angle"] INC -= np.radians(degree_angle.data[np.newaxis, :]) - elif rotational_method == rgd.RotationMethod.KEITH_DOUBLE_REGRIDDING: + elif rotational_method == rot.RotationMethod.KEITH_DOUBLE_REGRIDDING: ds = rgd.get_hgrid_arakawa_c_points(self.hgrid, "t") self.hgrid["angle_dx_rm6"] = xr.full_like(self.hgrid["angle_dx"], np.nan) self.hgrid["angle_dx_rm6"][ds.t_points_y.values, ds.t_points_x.values] = ( - rgd.initialize_grid_rotation_angle(self.hgrid) + rot.initialize_grid_rotation_angle(self.hgrid) ) angle = rgd.coords( self.hgrid, @@ -3560,7 +3561,7 @@ def regrid_tides( ua, va, up, vp = ep2ap(SEMA, ECC, INC, PHA) # Regrid back to real boundary - if rotational_method == rgd.RotationMethod.KEITH_DOUBLE_REGRIDDING: + if rotational_method == rot.RotationMethod.KEITH_DOUBLE_REGRIDDING: coords = rgd.coords(self.hgrid, self.orientation, self.segment_name) ## Reorganize regridding into 2D diff --git a/regional_mom6/regridding.py b/regional_mom6/regridding.py index 64b01404..c36b0625 100644 --- a/regional_mom6/regridding.py +++ b/regional_mom6/regridding.py @@ -32,25 +32,6 @@ import netCDF4 from .utils import setup_logger -# An Enum is like a dropdown selection for a menu, it essentially limits the type of input parameters. It comes with additional complexity, which of course is always a challenge. -from enum import Enum - - -class RotationMethod(Enum): - """ - This Enum defines the rotational method to be used in boundary conditions. The main regional mom6 class passes in this enum to regrid_tides and regrid_velocity_tracers to determine the method used. - - KEITH_DOUBLE_REGRIDDING: This method is used to regrid the boundary conditions to the t-points, b/c we can calculate t-point angle the same way as MOM6, rotate the conditions, and regrid again to the q-u-v, or actual, boundary - FRED_AVERAGE: This method is used with the basis that we can find the angles at the q-u-v points by pretending we have another row/column of the hgrid with the same distances as the t-point to u/v points in the actual grid then use the four poitns to calculate the angle the exact same way MOM6 does. - GIVEN_ANGLE: This is the original default RM6 method which expects a pre-given angle called angle_dx - NO_ROTATION: Grids parallel to lat/lon axes, no rotation needed - """ - - KEITH_DOUBLE_REGRIDDING = 1 - FRED_AVERAGE = 2 - GIVEN_ANGLE = 3 - NO_ROTATION = 4 - regridding_logger = setup_logger(__name__) @@ -165,6 +146,60 @@ def coords( return rcoord +def get_hgrid_arakawa_c_points(hgrid: xr.Dataset, point_type="t") -> xr.Dataset: + """ + Get the Arakawa C points from the Hgrid, originally written by Fred (Castruccio) and moved to RM6 + Parameters + ---------- + hgrid: xr.Dataset + The hgrid dataset + Returns + ------- + xr.Dataset + The specific points x, y, & point indexes + """ + if point_type not in "uvqth": + raise ValueError("point_type must be one of 'uvqht'") + + regridding_logger.info("Getting {} points..".format(point_type)) + + # Figure out the maths for the offset + k = 2 + kp2 = k // 2 + offset_one_by_two_y = np.arange(kp2, len(hgrid.x.nyp), k) + offset_one_by_two_x = np.arange(kp2, len(hgrid.x.nxp), k) + by_two_x = np.arange(0, len(hgrid.x.nxp), k) + by_two_y = np.arange(0, len(hgrid.x.nyp), k) + + # T point locations + if point_type == "t" or point_type == "h": + points = (offset_one_by_two_y, offset_one_by_two_x) + # U point locations + elif point_type == "u": + points = (offset_one_by_two_y, by_two_x) + # V point locations + elif point_type == "v": + points = (by_two_y, offset_one_by_two_x) + # Corner point locations + elif point_type == "q": + points = (by_two_y, by_two_x) + else: + raise ValueError("Invalid Point Type (u, v, q, or t/h only)") + + point_dataset = xr.Dataset( + { + "{}lon".format(point_type): hgrid.x[points], + "{}lat".format(point_type): hgrid.y[points], + "{}_points_y".format(point_type): points[0], + "{}_points_x".format(point_type): points[1], + } + ) + point_dataset.attrs["description"] = ( + "Arakawa C {}-points of supplied h-grid".format(point_type) + ) + return point_dataset + + def create_regridder( forcing_variables: xr.Dataset, output_grid: xr.Dataset, @@ -429,284 +464,3 @@ def generate_encoding( } return encoding_dict - - -def modulo_around_point(x, xc, Lx): - """ - This function calculates the modulo around a point. Return the modulo value of x in an interval [xc-(Lx/2) xc+(Lx/2)]. If Lx<=0, then it returns x without applying modulo arithmetic. - Parameters - ---------- - x: float - Value to which to apply modulo arithmetic - xc: float - Center of modulo range - Lx: float - Modulo range width - Returns - ------- - float - x shifted by an integer multiple of Lx to be close to xc, - """ - if Lx <= 0: - return x - else: - return ((x - (xc - 0.5 * Lx)) % Lx) - Lx / 2 + xc - - -def mom6_angle_calculation_method( - len_lon, - top_left: xr.DataArray, - top_right: xr.DataArray, - bottom_left: xr.DataArray, - bottom_right: xr.DataArray, - point: xr.DataArray, -) -> xr.DataArray: - """ - Calculate the angle of the point using the MOM6 method in initialize_grid_rotation_angle. Built for vectorized calculations - Parameters - ---------- - len_lon: float - The length of the longitude of the regional domain - top_left, top_right, bottom_left, bottom_right: xr.DataArray - The four points around the point to calculate the angle from the hgrid requires an x and y component - point: xr.DataArray - The point to calculate the angle from the hgrid - Returns - ------- - xr.DataArray - The angle of the point - """ - regridding_logger.info("Calculating grid rotation angle") - # Direct Translation - pi_720deg = ( - np.arctan(1) / 180 - ) # One quarter the conversion factor from degrees to radians - - # Compute lonB for all points - lonB = np.zeros((2, 2, len(point.nyp), len(point.nxp))) - - # Vectorized computation of lonB - # Vectorized computation of lonB - lonB[0][0] = modulo_around_point(bottom_left.x, point.x, len_lon) # Bottom Left - lonB[1][0] = modulo_around_point(top_left.x, point.x, len_lon) # Top Left - lonB[1][1] = modulo_around_point(top_right.x, point.x, len_lon) # Top Right - lonB[0][1] = modulo_around_point(bottom_right.x, point.x, len_lon) # Bottom Right - - # Compute lon_scale - lon_scale = np.cos( - pi_720deg * ((bottom_left.y + bottom_right.y) + (top_right.y + top_left.y)) - ) - - # Compute angle - angle = np.arctan2( - lon_scale * ((lonB[0, 1] - lonB[1, 0]) + (lonB[1, 1] - lonB[0, 0])), - (bottom_left.y - top_right.y) + (top_left.y - bottom_right.y), - ) - # Assign angle to angles_arr - angles_arr = np.rad2deg(angle) - 90 - - # Assign angles_arr to hgrid - t_angles = xr.DataArray( - angles_arr, - dims=["nyp", "nxp"], - coords={ - "nyp": point.nyp.values, - "nxp": point.nxp.values, - }, - ) - return t_angles - - -def initialize_hgrid_rotation_angles_using_pseudo_hgrid( - hgrid: xr.Dataset, -) -> xr.Dataset: - """ - Calculate the angle_dx in degrees from the true x (east?) direction counterclockwise) and return as dataarray - - Parameters - ---------- - hgrid: xr.Dataset - The hgrid dataset - pseudo_hgrid: xr.Dataset - The pseudo hgrid dataset - Returns - ------- - xr.DataArray - The t-point angles - """ - # Get Fred Pseudo grid - pseudo_hgrid = create_pseudo_hgrid(hgrid) - - return mom6_angle_calculation_method( - pseudo_hgrid.x.max() - pseudo_hgrid.x.min(), - pseudo_hgrid.isel(nyp=slice(2, None), nxp=slice(0, -2)), - pseudo_hgrid.isel(nyp=slice(2, None), nxp=slice(2, None)), - pseudo_hgrid.isel(nyp=slice(0, -2), nxp=slice(0, -2)), - pseudo_hgrid.isel(nyp=slice(0, -2), nxp=slice(2, None)), - hgrid, - ) - - -def initialize_grid_rotation_angle(hgrid: xr.Dataset) -> xr.DataArray: - """ - Calculate the angle_dx in degrees from the true x (east?) direction counterclockwise) and return as DataArray - Parameters - ---------- - hgrid: xr.Dataset - The hgrid dataset - Returns - ------- - xr.DataArray - The t-point angles - """ - ds_t = get_hgrid_arakawa_c_points(hgrid, "t") - ds_q = get_hgrid_arakawa_c_points(hgrid, "q") - - # Reformat into x, y comps - t_points = xr.Dataset( - { - "x": (("nyp", "nxp"), ds_t.tlon.data), - "y": (("nyp", "nxp"), ds_t.tlat.data), - } - ) - q_points = xr.Dataset( - { - "x": (("nyp", "nxp"), ds_q.qlon.data), - "y": (("nyp", "nxp"), ds_q.qlat.data), - } - ) - - return mom6_angle_calculation_method( - hgrid.x.max() - hgrid.x.min(), - q_points.isel(nyp=slice(1, None), nxp=slice(0, -1)), - q_points.isel(nyp=slice(1, None), nxp=slice(1, None)), - q_points.isel(nyp=slice(0, -1), nxp=slice(0, -1)), - q_points.isel(nyp=slice(0, -1), nxp=slice(1, None)), - t_points, - ) - - -def get_hgrid_arakawa_c_points(hgrid: xr.Dataset, point_type="t") -> xr.Dataset: - """ - Get the Arakawa C points from the Hgrid, originally written by Fred (Castruccio) and moved to RM6 - Parameters - ---------- - hgrid: xr.Dataset - The hgrid dataset - Returns - ------- - xr.Dataset - The specific points x, y, & point indexes - """ - if point_type not in "uvqth": - raise ValueError("point_type must be one of 'uvqht'") - - regridding_logger.info("Getting {} points..".format(point_type)) - - # Figure out the maths for the offset - k = 2 - kp2 = k // 2 - offset_one_by_two_y = np.arange(kp2, len(hgrid.x.nyp), k) - offset_one_by_two_x = np.arange(kp2, len(hgrid.x.nxp), k) - by_two_x = np.arange(0, len(hgrid.x.nxp), k) - by_two_y = np.arange(0, len(hgrid.x.nyp), k) - - # T point locations - if point_type == "t" or point_type == "h": - points = (offset_one_by_two_y, offset_one_by_two_x) - # U point locations - elif point_type == "u": - points = (offset_one_by_two_y, by_two_x) - # V point locations - elif point_type == "v": - points = (by_two_y, offset_one_by_two_x) - # Corner point locations - elif point_type == "q": - points = (by_two_y, by_two_x) - else: - raise ValueError("Invalid Point Type (u, v, q, or t/h only)") - - point_dataset = xr.Dataset( - { - "{}lon".format(point_type): hgrid.x[points], - "{}lat".format(point_type): hgrid.y[points], - "{}_points_y".format(point_type): points[0], - "{}_points_x".format(point_type): points[1], - } - ) - point_dataset.attrs["description"] = ( - "Arakawa C {}-points of supplied h-grid".format(point_type) - ) - return point_dataset - - -def create_pseudo_hgrid(hgrid: xr.Dataset) -> xr.Dataset: - """ - Adds an additional boundary to the hgrid to allow for the calculation of the angle_dx for the boundary points using the method in MOM6 - """ - pseudo_hgrid_x = np.full((len(hgrid.nyp) + 2, len(hgrid.nxp) + 2), np.nan) - pseudo_hgrid_y = np.full((len(hgrid.nyp) + 2, len(hgrid.nxp) + 2), np.nan) - - ## Fill Boundaries - pseudo_hgrid_x[1:-1, 1:-1] = hgrid.x.values - pseudo_hgrid_x[0, 1:-1] = hgrid.x.values[0, :] - ( - hgrid.x.values[1, :] - hgrid.x.values[0, :] - ) # Bottom Fill - pseudo_hgrid_x[-1, 1:-1] = hgrid.x.values[-1, :] + ( - hgrid.x.values[-1, :] - hgrid.x.values[-2, :] - ) # Top Fill - pseudo_hgrid_x[1:-1, 0] = hgrid.x.values[:, 0] - ( - hgrid.x.values[:, 1] - hgrid.x.values[:, 0] - ) # Left Fill - pseudo_hgrid_x[1:-1, -1] = hgrid.x.values[:, -1] + ( - hgrid.x.values[:, -1] - hgrid.x.values[:, -2] - ) # Right Fill - - pseudo_hgrid_y[1:-1, 1:-1] = hgrid.y.values - pseudo_hgrid_y[0, 1:-1] = hgrid.y.values[0, :] - ( - hgrid.y.values[1, :] - hgrid.y.values[0, :] - ) # Bottom Fill - pseudo_hgrid_y[-1, 1:-1] = hgrid.y.values[-1, :] + ( - hgrid.y.values[-1, :] - hgrid.y.values[-2, :] - ) # Top Fill - pseudo_hgrid_y[1:-1, 0] = hgrid.y.values[:, 0] - ( - hgrid.y.values[:, 1] - hgrid.y.values[:, 0] - ) # Left Fill - pseudo_hgrid_y[1:-1, -1] = hgrid.y.values[:, -1] + ( - hgrid.y.values[:, -1] - hgrid.y.values[:, -2] - ) # Right Fill - - ## Fill Corners - pseudo_hgrid_x[0, 0] = hgrid.x.values[0, 0] - ( - hgrid.x.values[1, 1] - hgrid.x.values[0, 0] - ) # Bottom Left - pseudo_hgrid_x[-1, 0] = hgrid.x.values[-1, 0] - ( - hgrid.x.values[-2, 1] - hgrid.x.values[-1, 0] - ) # Top Left - pseudo_hgrid_x[0, -1] = hgrid.x.values[0, -1] - ( - hgrid.x.values[1, -2] - hgrid.x.values[0, -1] - ) # Bottom Right - pseudo_hgrid_x[-1, -1] = hgrid.x.values[-1, -1] - ( - hgrid.x.values[-2, -2] - hgrid.x.values[-1, -1] - ) # Top Right - - pseudo_hgrid_y[0, 0] = hgrid.y.values[0, 0] - ( - hgrid.y.values[1, 1] - hgrid.y.values[0, 0] - ) # Bottom Left - pseudo_hgrid_y[-1, 0] = hgrid.y.values[-1, 0] - ( - hgrid.y.values[-2, 1] - hgrid.y.values[-1, 0] - ) # Top Left - pseudo_hgrid_y[0, -1] = hgrid.y.values[0, -1] - ( - hgrid.y.values[1, -2] - hgrid.y.values[0, -1] - ) # Bottom Right - pseudo_hgrid_y[-1, -1] = hgrid.y.values[-1, -1] - ( - hgrid.y.values[-2, -2] - hgrid.y.values[-1, -1] - ) # Top Right - - pseudo_hgrid = xr.Dataset( - { - "x": (["nyp", "nxp"], pseudo_hgrid_x), - "y": (["nyp", "nxp"], pseudo_hgrid_y), - } - ) - return pseudo_hgrid diff --git a/regional_mom6/rotation.py b/regional_mom6/rotation.py new file mode 100644 index 00000000..22a1aef0 --- /dev/null +++ b/regional_mom6/rotation.py @@ -0,0 +1,251 @@ +from .utils import setup_logger + +rotation_logger = setup_logger(__name__) +# An Enum is like a dropdown selection for a menu, it essentially limits the type of input parameters. It comes with additional complexity, which of course is always a challenge. +from enum import Enum +import xarray as xr +import numpy as np +from .regridding import get_hgrid_arakawa_c_points + + +class RotationMethod(Enum): + """ + This Enum defines the rotational method to be used in boundary conditions. The main regional mom6 class passes in this enum to regrid_tides and regrid_velocity_tracers to determine the method used. + + KEITH_DOUBLE_REGRIDDING: This method is used to regrid the boundary conditions to the t-points, b/c we can calculate t-point angle the same way as MOM6, rotate the conditions, and regrid again to the q-u-v, or actual, boundary + FRED_AVERAGE: This method is used with the basis that we can find the angles at the q-u-v points by pretending we have another row/column of the hgrid with the same distances as the t-point to u/v points in the actual grid then use the four poitns to calculate the angle the exact same way MOM6 does. + GIVEN_ANGLE: This is the original default RM6 method which expects a pre-given angle called angle_dx + NO_ROTATION: Grids parallel to lat/lon axes, no rotation needed + """ + + KEITH_DOUBLE_REGRIDDING = 1 + FRED_AVERAGE = 2 + GIVEN_ANGLE = 3 + NO_ROTATION = 4 + + +def initialize_hgrid_rotation_angles_using_pseudo_hgrid( + hgrid: xr.Dataset, +) -> xr.Dataset: + """ + Calculate the angle_dx in degrees from the true x (east?) direction counterclockwise) and return as dataarray + + Parameters + ---------- + hgrid: xr.Dataset + The hgrid dataset + pseudo_hgrid: xr.Dataset + The pseudo hgrid dataset + Returns + ------- + xr.DataArray + The t-point angles + """ + # Get Fred Pseudo grid + pseudo_hgrid = create_pseudo_hgrid(hgrid) + + return mom6_angle_calculation_method( + pseudo_hgrid.x.max() - pseudo_hgrid.x.min(), + pseudo_hgrid.isel(nyp=slice(2, None), nxp=slice(0, -2)), + pseudo_hgrid.isel(nyp=slice(2, None), nxp=slice(2, None)), + pseudo_hgrid.isel(nyp=slice(0, -2), nxp=slice(0, -2)), + pseudo_hgrid.isel(nyp=slice(0, -2), nxp=slice(2, None)), + hgrid, + ) + + +def initialize_grid_rotation_angle(hgrid: xr.Dataset) -> xr.DataArray: + """ + Calculate the angle_dx in degrees from the true x (east?) direction counterclockwise) and return as DataArray + Parameters + ---------- + hgrid: xr.Dataset + The hgrid dataset + Returns + ------- + xr.DataArray + The t-point angles + """ + ds_t = get_hgrid_arakawa_c_points(hgrid, "t") + ds_q = get_hgrid_arakawa_c_points(hgrid, "q") + + # Reformat into x, y comps + t_points = xr.Dataset( + { + "x": (("nyp", "nxp"), ds_t.tlon.data), + "y": (("nyp", "nxp"), ds_t.tlat.data), + } + ) + q_points = xr.Dataset( + { + "x": (("nyp", "nxp"), ds_q.qlon.data), + "y": (("nyp", "nxp"), ds_q.qlat.data), + } + ) + + return mom6_angle_calculation_method( + hgrid.x.max() - hgrid.x.min(), + q_points.isel(nyp=slice(1, None), nxp=slice(0, -1)), + q_points.isel(nyp=slice(1, None), nxp=slice(1, None)), + q_points.isel(nyp=slice(0, -1), nxp=slice(0, -1)), + q_points.isel(nyp=slice(0, -1), nxp=slice(1, None)), + t_points, + ) + + +def modulo_around_point(x, xc, Lx): + """ + This function calculates the modulo around a point. Return the modulo value of x in an interval [xc-(Lx/2) xc+(Lx/2)]. If Lx<=0, then it returns x without applying modulo arithmetic. + Parameters + ---------- + x: float + Value to which to apply modulo arithmetic + xc: float + Center of modulo range + Lx: float + Modulo range width + Returns + ------- + float + x shifted by an integer multiple of Lx to be close to xc, + """ + if Lx <= 0: + return x + else: + return ((x - (xc - 0.5 * Lx)) % Lx) - Lx / 2 + xc + + +def mom6_angle_calculation_method( + len_lon, + top_left: xr.DataArray, + top_right: xr.DataArray, + bottom_left: xr.DataArray, + bottom_right: xr.DataArray, + point: xr.DataArray, +) -> xr.DataArray: + """ + Calculate the angle of the point using the MOM6 method in initialize_grid_rotation_angle. Built for vectorized calculations + Parameters + ---------- + len_lon: float + The length of the longitude of the regional domain + top_left, top_right, bottom_left, bottom_right: xr.DataArray + The four points around the point to calculate the angle from the hgrid requires an x and y component + point: xr.DataArray + The point to calculate the angle from the hgrid + Returns + ------- + xr.DataArray + The angle of the point + """ + rotation_logger.info("Calculating grid rotation angle") + # Direct Translation + pi_720deg = ( + np.arctan(1) / 180 + ) # One quarter the conversion factor from degrees to radians + + # Compute lonB for all points + lonB = np.zeros((2, 2, len(point.nyp), len(point.nxp))) + + # Vectorized computation of lonB + # Vectorized computation of lonB + lonB[0][0] = modulo_around_point(bottom_left.x, point.x, len_lon) # Bottom Left + lonB[1][0] = modulo_around_point(top_left.x, point.x, len_lon) # Top Left + lonB[1][1] = modulo_around_point(top_right.x, point.x, len_lon) # Top Right + lonB[0][1] = modulo_around_point(bottom_right.x, point.x, len_lon) # Bottom Right + + # Compute lon_scale + lon_scale = np.cos( + pi_720deg * ((bottom_left.y + bottom_right.y) + (top_right.y + top_left.y)) + ) + + # Compute angle + angle = np.arctan2( + lon_scale * ((lonB[0, 1] - lonB[1, 0]) + (lonB[1, 1] - lonB[0, 0])), + (bottom_left.y - top_right.y) + (top_left.y - bottom_right.y), + ) + # Assign angle to angles_arr + angles_arr = np.rad2deg(angle) - 90 + + # Assign angles_arr to hgrid + t_angles = xr.DataArray( + angles_arr, + dims=["nyp", "nxp"], + coords={ + "nyp": point.nyp.values, + "nxp": point.nxp.values, + }, + ) + return t_angles + + +def create_pseudo_hgrid(hgrid: xr.Dataset) -> xr.Dataset: + """ + Adds an additional boundary to the hgrid to allow for the calculation of the angle_dx for the boundary points using the method in MOM6 + """ + pseudo_hgrid_x = np.full((len(hgrid.nyp) + 2, len(hgrid.nxp) + 2), np.nan) + pseudo_hgrid_y = np.full((len(hgrid.nyp) + 2, len(hgrid.nxp) + 2), np.nan) + + ## Fill Boundaries + pseudo_hgrid_x[1:-1, 1:-1] = hgrid.x.values + pseudo_hgrid_x[0, 1:-1] = hgrid.x.values[0, :] - ( + hgrid.x.values[1, :] - hgrid.x.values[0, :] + ) # Bottom Fill + pseudo_hgrid_x[-1, 1:-1] = hgrid.x.values[-1, :] + ( + hgrid.x.values[-1, :] - hgrid.x.values[-2, :] + ) # Top Fill + pseudo_hgrid_x[1:-1, 0] = hgrid.x.values[:, 0] - ( + hgrid.x.values[:, 1] - hgrid.x.values[:, 0] + ) # Left Fill + pseudo_hgrid_x[1:-1, -1] = hgrid.x.values[:, -1] + ( + hgrid.x.values[:, -1] - hgrid.x.values[:, -2] + ) # Right Fill + + pseudo_hgrid_y[1:-1, 1:-1] = hgrid.y.values + pseudo_hgrid_y[0, 1:-1] = hgrid.y.values[0, :] - ( + hgrid.y.values[1, :] - hgrid.y.values[0, :] + ) # Bottom Fill + pseudo_hgrid_y[-1, 1:-1] = hgrid.y.values[-1, :] + ( + hgrid.y.values[-1, :] - hgrid.y.values[-2, :] + ) # Top Fill + pseudo_hgrid_y[1:-1, 0] = hgrid.y.values[:, 0] - ( + hgrid.y.values[:, 1] - hgrid.y.values[:, 0] + ) # Left Fill + pseudo_hgrid_y[1:-1, -1] = hgrid.y.values[:, -1] + ( + hgrid.y.values[:, -1] - hgrid.y.values[:, -2] + ) # Right Fill + + ## Fill Corners + pseudo_hgrid_x[0, 0] = hgrid.x.values[0, 0] - ( + hgrid.x.values[1, 1] - hgrid.x.values[0, 0] + ) # Bottom Left + pseudo_hgrid_x[-1, 0] = hgrid.x.values[-1, 0] - ( + hgrid.x.values[-2, 1] - hgrid.x.values[-1, 0] + ) # Top Left + pseudo_hgrid_x[0, -1] = hgrid.x.values[0, -1] - ( + hgrid.x.values[1, -2] - hgrid.x.values[0, -1] + ) # Bottom Right + pseudo_hgrid_x[-1, -1] = hgrid.x.values[-1, -1] - ( + hgrid.x.values[-2, -2] - hgrid.x.values[-1, -1] + ) # Top Right + + pseudo_hgrid_y[0, 0] = hgrid.y.values[0, 0] - ( + hgrid.y.values[1, 1] - hgrid.y.values[0, 0] + ) # Bottom Left + pseudo_hgrid_y[-1, 0] = hgrid.y.values[-1, 0] - ( + hgrid.y.values[-2, 1] - hgrid.y.values[-1, 0] + ) # Top Left + pseudo_hgrid_y[0, -1] = hgrid.y.values[0, -1] - ( + hgrid.y.values[1, -2] - hgrid.y.values[0, -1] + ) # Bottom Right + pseudo_hgrid_y[-1, -1] = hgrid.y.values[-1, -1] - ( + hgrid.y.values[-2, -2] - hgrid.y.values[-1, -1] + ) # Top Right + + pseudo_hgrid = xr.Dataset( + { + "x": (["nyp", "nxp"], pseudo_hgrid_x), + "y": (["nyp", "nxp"], pseudo_hgrid_y), + } + ) + return pseudo_hgrid From ff9735f5ad3ad97a280d90e9e814c2a2bf1f9286 Mon Sep 17 00:00:00 2001 From: manishvenu Date: Tue, 10 Dec 2024 12:44:10 -0700 Subject: [PATCH 27/87] Doesn't make sense to use rot method in expt because the regrid methods are in segment right now. Something to discuss and then add --- regional_mom6/regional_mom6.py | 5 ----- 1 file changed, 5 deletions(-) diff --git a/regional_mom6/regional_mom6.py b/regional_mom6/regional_mom6.py index 35f09830..9104dad1 100644 --- a/regional_mom6/regional_mom6.py +++ b/regional_mom6/regional_mom6.py @@ -594,7 +594,6 @@ def create_empty( tidal_constituents=["M2", "S2", "N2", "K2", "K1", "O1", "P1", "Q1", "MM", "MF"], expt_name=None, boundaries=["south", "north", "west", "east"], - rotational_method=rot.RotationMethod.GIVEN_ANGLE, ): """ Substitute init method to creates an empty expirement object, with the opportunity to override whatever values wanted. @@ -616,7 +615,6 @@ def create_empty( repeat_year_forcing=None, tidal_constituents=None, expt_name=None, - rotational_method=None, ) expt.expt_name = expt_name @@ -638,7 +636,6 @@ def create_empty( expt.layout = None self.segments = {} self.boundaries = boundaries - self.rotational_method = rotational_method return expt def __init__( @@ -662,7 +659,6 @@ def __init__( create_empty=False, expt_name=None, boundaries=["south", "north", "west", "east"], - rotational_method=rot.RotationMethod.GIVEN_ANGLE, ): # Creates empty experiment object for testing and experienced user manipulation. @@ -699,7 +695,6 @@ def __init__( self.layout = None # This should be a tuple. Leaving in a dummy 'None' makes it easy to remind the user to provide a value later on. self.minimum_depth = minimum_depth # Minimum depth allowed in bathy file self.tidal_constituents = tidal_constituents - self.rotational_method = rotational_method if hgrid_type == "from_file": try: self.hgrid = xr.open_dataset(self.mom_input_dir / "hgrid.nc") From c190d47e64104855ff107cde0e68076c1774c844 Mon Sep 17 00:00:00 2001 From: manishvenu Date: Tue, 10 Dec 2024 15:44:36 -0700 Subject: [PATCH 28/87] Clean up the keith method to use the regridding func add_secondary_dimension --- regional_mom6/regional_mom6.py | 92 +++++++++---------- regional_mom6/regridding.py | 22 +++-- .../testing_to_be_deleted/angle_calc.md | 45 +++++++-- 3 files changed, 93 insertions(+), 66 deletions(-) diff --git a/regional_mom6/regional_mom6.py b/regional_mom6/regional_mom6.py index 9104dad1..4868701b 100644 --- a/regional_mom6/regional_mom6.py +++ b/regional_mom6/regional_mom6.py @@ -3006,25 +3006,21 @@ def regrid_velocity_tracers(self, rotational_method=rot.RotationMethod.GIVEN_ANG coords = rgd.coords(self.hgrid, self.orientation, self.segment_name) ds = xr.Dataset() - - expanded_lat = np.tile(rotated_u.lat, (1, 1)) - expanded_lon = np.tile(rotated_u.lon, (1, 1)) - ds["lat"] = xr.DataArray(expanded_lat, dims=("y", "x")) - ds["lon"] = xr.DataArray(expanded_lon, dims=("y", "x")) - - exp_rotated_u = [rotated_u] - ds["rotated_u"] = xr.DataArray( - exp_rotated_u, dims=("y", "time", "depth", "x") + ds["rotated_u"] = rotated_u + ds["rotated_v"] = rotated_v + rgd.add_secondary_dimension(ds, "lat", coords, "", to_beginning=True) + rgd.add_secondary_dimension(ds, "lon", coords, "", to_beginning=True) + rgd.add_secondary_dimension( + ds, "rotated_u", coords, "", to_beginning=True ) - - exp_rotated_v = [rotated_v] - ds["rotated_v"] = xr.DataArray( - exp_rotated_v, dims=("y", "time", "depth", "x") + rgd.add_secondary_dimension( + ds, "rotated_v", coords, "", to_beginning=True ) regridder_keith = rgd.create_regridder( ds, coords, ".temp", method="nearest_s2d" ) + rotated_u = regridder_keith(ds["rotated_u"]) rotated_v = regridder_keith(ds["rotated_v"]) @@ -3116,20 +3112,16 @@ def regrid_velocity_tracers(self, rotational_method=rot.RotationMethod.GIVEN_ANG coords = rgd.coords(self.hgrid, self.orientation, self.segment_name) ds = xr.Dataset() + ds["rotated_u"] = velocities_out["u"] + ds["rotated_v"] = velocities_out["v"] - expanded_lat = np.tile(velocities_out["u"].lat, (1, 1)) - expanded_lon = np.tile(velocities_out["u"].lon, (1, 1)) - ds["lat"] = xr.DataArray(expanded_lat, dims=("y", "x")) - ds["lon"] = xr.DataArray(expanded_lon, dims=("y", "x")) - - exp_rotated_u = [velocities_out["u"]] - ds["rotated_u"] = xr.DataArray( - exp_rotated_u, dims=("y", "time", "depth", "x") + rgd.add_secondary_dimension(ds, "lat", coords, "", to_beginning=True) + rgd.add_secondary_dimension(ds, "lon", coords, "", to_beginning=True) + rgd.add_secondary_dimension( + ds, "rotated_u", coords, "", to_beginning=True ) - - exp_rotated_v = [velocities_out["v"]] - ds["rotated_v"] = xr.DataArray( - exp_rotated_v, dims=("y", "time", "depth", "x") + rgd.add_secondary_dimension( + ds, "rotated_v", coords, "", to_beginning=True ) regridder_keith = rgd.create_regridder( @@ -3238,20 +3230,16 @@ def regrid_velocity_tracers(self, rotational_method=rot.RotationMethod.GIVEN_ANG coords = rgd.coords(self.hgrid, self.orientation, self.segment_name) ds = xr.Dataset() + ds["rotated_u"] = rotated_u + ds["rotated_v"] = rotated_v - expanded_lat = np.tile(rotated_u.lat, (1, 1)) - expanded_lon = np.tile(rotated_u.lon, (1, 1)) - ds["lat"] = xr.DataArray(expanded_lat, dims=("y", "x")) - ds["lon"] = xr.DataArray(expanded_lon, dims=("y", "x")) - - exp_rotated_u = [rotated_u] - ds["rotated_u"] = xr.DataArray( - exp_rotated_u, dims=("y", "time", "depth", "x") + rgd.add_secondary_dimension(ds, "lat", coords, "", to_beginning=True) + rgd.add_secondary_dimension(ds, "lon", coords, "", to_beginning=True) + rgd.add_secondary_dimension( + ds, "rotated_u", coords, "", to_beginning=True ) - - exp_rotated_v = [rotated_v] - ds["rotated_v"] = xr.DataArray( - exp_rotated_v, dims=("y", "time", "depth", "x") + rgd.add_secondary_dimension( + ds, "rotated_v", coords, "", to_beginning=True ) regridder_keith = rgd.create_regridder( @@ -3561,22 +3549,24 @@ def regrid_tides( ## Reorganize regridding into 2D ds = xr.Dataset() - expanded_lat = np.tile(ua.lat, (1, 1)) - expanded_lon = np.tile(ua.lon, (1, 1)) - ds["lat"] = xr.DataArray(expanded_lat, dims=("y", "x")) - ds["lon"] = xr.DataArray(expanded_lon, dims=("y", "x")) - - exp_ua = [ua] - ds["ua"] = xr.DataArray(exp_ua, dims=("y", "constituent", "x")) - exp_va = [va] - ds["va"] = xr.DataArray(exp_va, dims=("y", "constituent", "x")) - - exp_vp = [vp] - ds["vp"] = xr.DataArray(exp_vp, dims=("y", "constituent", "x")) + ds["ua"] = ua + ds["va"] = va + ds["vp"] = ( + ["constituent", coords.attrs["parallel"] + "_" + self.segment_name], + vp, + ) + ds["up"] = ( + ["constituent", coords.attrs["parallel"] + "_" + self.segment_name], + up, + ) - exp_up = [up] - ds["up"] = xr.DataArray(exp_up, dims=("y", "constituent", "x")) + rgd.add_secondary_dimension(ds, "lat", coords, "", to_beginning=True) + rgd.add_secondary_dimension(ds, "lon", coords, "", to_beginning=True) + rgd.add_secondary_dimension(ds, "ua", coords, "", to_beginning=True) + rgd.add_secondary_dimension(ds, "va", coords, "", to_beginning=True) + rgd.add_secondary_dimension(ds, "up", coords, "", to_beginning=True) + rgd.add_secondary_dimension(ds, "vp", coords, "", to_beginning=True) regridder = rgd.create_regridder(ds, coords, ".temp", method="nearest_s2d") diff --git a/regional_mom6/regridding.py b/regional_mom6/regridding.py index c36b0625..a8f6ac23 100644 --- a/regional_mom6/regridding.py +++ b/regional_mom6/regridding.py @@ -314,7 +314,7 @@ def generate_dz(ds: xr.Dataset, z_dim_name: str) -> xr.Dataset: def add_secondary_dimension( - ds: xr.Dataset, var: str, coords, segment_name: str + ds: xr.Dataset, var: str, coords, segment_name: str, to_beginning=False ) -> xr.Dataset: """Add the perpendiciular dimension to the dataset, even if it's like one val. It's required. Parameters @@ -327,6 +327,8 @@ def add_secondary_dimension( The coordinates from the function coords... segment_name : str The segment name + to_beginning : bool, optional + Whether to add the perpendicular dimension to the beginning or to the selected position, by default False Returns ------- xr.Dataset @@ -342,12 +344,20 @@ def add_secondary_dimension( "Checking if nz or constituent is in dimensions, then we have to bump the perpendicular dimension up by one" ) insert_behind_by = 0 - if any(coord.startswith("nz") or coord == "constituent" for coord in ds[var].dims): - regridding_logger.debug("Bump it by one") - insert_behind_by = 0 + if not to_beginning: + + if any( + coord.startswith("nz") or coord == "constituent" for coord in ds[var].dims + ): + regridding_logger.debug("Bump it by one") + insert_behind_by = 0 + else: + # Missing vertical dim or tidal coord means we don't need to offset the perpendicular + insert_behind_by = 1 else: - # Missing vertical dim or tidal coord means we don't need to offset the perpendicular - insert_behind_by = 1 + insert_behind_by = coords.attrs[ + "axis_to_expand" + ] # Just magic to add dim to the beginning regridding_logger.debug(f"Expand dimensions") ds[var] = ds[var].expand_dims( diff --git a/regional_mom6/testing_to_be_deleted/angle_calc.md b/regional_mom6/testing_to_be_deleted/angle_calc.md index 6c77780c..524b298b 100644 --- a/regional_mom6/testing_to_be_deleted/angle_calc.md +++ b/regional_mom6/testing_to_be_deleted/angle_calc.md @@ -1,21 +1,48 @@ -# MOM6 Angle Calculation Steps +# Rotation and angle calculation in RM6 using MOM6 Angle Calculation +This document explains the process by which Regional MOM6 calculates the angle of curved hgrids. MOM6 doesn't actually use the user-provided "angle_dx" field in input hgrids, but internally calculates the angle. To accomodate this fact when we rotate our boundary conditions, we implemented MOM6 angle calculation in a file called "rotation.py", and adjusted functions where we regrid the boundary conditions. -## Process of calculation -> Only works on t-points + +## MOM6 process of angle calculation (T-point only) 1. Calculate pi/4rads / 180 degress = Gives a 1/4 conversion of degrees to radians. I.E. multiplying an angle in degrees by this gives the conversion to radians at 1/4 the value. 2. Figure out the longitudunal extent of our domain, or periodic range of longitudes. For global cases it is len_lon = 360, for our regional cases it is given by the hgrid. -3. At each point on our hgrid, we find the point to the left, bottom left diag, bottom, and itself. We adjust each of these longitudes to be in the range of len_lon around the point itself. (module_around_point) +3. At each point on our hgrid, we find the q-point to the top left, bottom left, bottom right, top right. We adjust each of these longitudes to be in the range of len_lon around the point itself. (module_around_point) 4. We then find the lon_scale, which is the "trigonometric scaling factor converting changes in longitude to equivalent distances in latitudes". Whatever that actually means is we add the latitude of all four of these points from part 3 and basically average it and convert to radians. We then take the cosine of it. As I understand it, it's a conversion of longitude to equivalent latitude distance. 5. Then we calculate the angle. This is a simple arctan2 so y/x. - 1. The "y" component is the addition of the difference between the diagonals in longitude of lonB multiplied by the lon_scale, which is our conversion to latitude. + 1. The "y" component is the addition of the difference between the diagonals in longitude (adjusted by modulo_around_point in step 3) multiplied by the lon_scale, which is our conversion to latitude. 2. The "x" component is the same addition of differences in latitude. 3. Thus, given the same units, we can call arctan to get the angle in degrees -## Conversion to Q points -1. (Recommended by Gustavo) -2. We use XGCM to interpolate from the t-points to all other points in the supergrid. + +## Problem +MOM6 only calculates the angle at t-points. For boundary rotation, we need the angle at the boundary, which is q/u/v points. Because we need the points to the left, right, top, and bottom of the point, this method won't work for the boundary. + + +# Convert this method to boundary angles - 3 Options +1. **GIVEN_ANGLE**: Don't calculate the angle and use the user-provided field in the hgrid called "angle_dx" +2. **FRED_AVERAGE**: Calculate another boundary row/column points around the hgrid using simple difference techniques. Use the new points to calculate the angle at the boundaries. This works because we can now access the four points needed to calculate the angle, where previously at boundaries we would be missing at least two. +3. **KEITH_DOUBLE_REGRIDDING**: Regrid the boundary conditions to the t-points. Rotate using the MOM6 angle calculation. Regrid to the boundary. + ## Implementation -1. Direct implementation of MOM6 grid angle initalization function (and modulo_around_point) -2. Wrap direct implementation combined with XGCM interpolation for grid angles +Most calculation code is implemented in the rotation.py script, and the functional uses are in regrid_velocity_tracers and regrid_tides functions in the segment class of RM6. + + +### Calculation Code (rotation.py) +1. **Rotational Method Definition**: Rotational Methods are defined in the enum class "Rotational Method" in rotation.py. +2. **MOM6 Angle Calculation**: The method is implemented in "mom6_angle_calculation_method" in rotation.py and the direct t-point angle calculation is "initialize_grid_rotation_angle". +3. **Fred's Pseudo Grid Averaging**: The method to add the additional boundary row/columns is referenced in "pseudo_hgrid" functions in rotation.py +4. **Keith's Double Regridding**: Keith's double regridding makes use of the "initialize_grid_rotation_angle" function in rotation.py. + +### Implementation Code (regional_mom6.py) +Both regridding functions (regrid_velocity_tracers, regrid_tides) accept a parameter called "rotational_method" which takes the Enum class defining the rotational method. + +We then define each method with a bunch of if statements. Here are the processes: + +1. Given angle is the default method of accepting the hgrid's angle_dx +2. Fred's method is the least code, and we simply swap out the hgrid angle with the generated one we calculate right where we do the rotation. +3. Keith's method is where we actually do a bit more: + 1. We change the call to "coords" to get the t-points so that the initial regridding is to the t_points intead of the boundary + 2. We then rotate it using a similar method to Fred's of regenerating the angle right where we do the rotation + 3. Then we have to regrid the result to the actual boundary. Because (by definition) it is a curvilinear grid, we have to restructure the dataset to include an extra dimension so that xesmf plays nicely, then regrid the whole thing to the boundary. It adds a decent amount of code I guess. From 70e6da32c93dd98a0ba925c6658f1e2f719cb336 Mon Sep 17 00:00:00 2001 From: manishvenu Date: Tue, 10 Dec 2024 15:48:07 -0700 Subject: [PATCH 29/87] Add angle_calc to docs --- .../testing_to_be_deleted => docs}/angle_calc.md | 10 +++++++--- 1 file changed, 7 insertions(+), 3 deletions(-) rename {regional_mom6/testing_to_be_deleted => docs}/angle_calc.md (88%) diff --git a/regional_mom6/testing_to_be_deleted/angle_calc.md b/docs/angle_calc.md similarity index 88% rename from regional_mom6/testing_to_be_deleted/angle_calc.md rename to docs/angle_calc.md index 524b298b..e1364310 100644 --- a/regional_mom6/testing_to_be_deleted/angle_calc.md +++ b/docs/angle_calc.md @@ -1,9 +1,13 @@ # Rotation and angle calculation in RM6 using MOM6 Angle Calculation -This document explains the process by which Regional MOM6 calculates the angle of curved hgrids. MOM6 doesn't actually use the user-provided "angle_dx" field in input hgrids, but internally calculates the angle. To accomodate this fact when we rotate our boundary conditions, we implemented MOM6 angle calculation in a file called "rotation.py", and adjusted functions where we regrid the boundary conditions. +This document explains the implementation of MOM6 angle calculation in RM6, which is the process by which RM6 calculates the angle of curved hgrids. + +**Issue:** MOM6 doesn't actually use the user-provided "angle_dx" field in input hgrids, but internally calculates the angle. + +**Solution:** To accomodate this fact, when we rotate our boundary conditions, we implemented MOM6 angle calculation in a file called "rotation.py", and adjusted functions where we regrid the boundary conditions. ## MOM6 process of angle calculation (T-point only) -1. Calculate pi/4rads / 180 degress = Gives a 1/4 conversion of degrees to radians. I.E. multiplying an angle in degrees by this gives the conversion to radians at 1/4 the value. +1. Calculate pi/4rads / 180 degrees = Gives a 1/4 conversion of degrees to radians. I.E. multiplying an angle in degrees by this gives the conversion to radians at 1/4 the value. 2. Figure out the longitudunal extent of our domain, or periodic range of longitudes. For global cases it is len_lon = 360, for our regional cases it is given by the hgrid. 3. At each point on our hgrid, we find the q-point to the top left, bottom left, bottom right, top right. We adjust each of these longitudes to be in the range of len_lon around the point itself. (module_around_point) 4. We then find the lon_scale, which is the "trigonometric scaling factor converting changes in longitude to equivalent distances in latitudes". Whatever that actually means is we add the latitude of all four of these points from part 3 and basically average it and convert to radians. We then take the cosine of it. As I understand it, it's a conversion of longitude to equivalent latitude distance. @@ -23,7 +27,7 @@ MOM6 only calculates the angle at t-points. For boundary rotation, we need the a 3. **KEITH_DOUBLE_REGRIDDING**: Regrid the boundary conditions to the t-points. Rotate using the MOM6 angle calculation. Regrid to the boundary. -## Implementation +## Code Description Most calculation code is implemented in the rotation.py script, and the functional uses are in regrid_velocity_tracers and regrid_tides functions in the segment class of RM6. From 8067744c0cf5173c53316c64cf072fd375655ae8 Mon Sep 17 00:00:00 2001 From: manishvenu Date: Tue, 10 Dec 2024 15:51:09 -0700 Subject: [PATCH 30/87] Main Page Link for now... --- docs/index.rst | 1 + 1 file changed, 1 insertion(+) diff --git a/docs/index.rst b/docs/index.rst index 531ad99c..095b5367 100644 --- a/docs/index.rst +++ b/docs/index.rst @@ -93,6 +93,7 @@ The bibtex entry for the paper is: mom6-file-structure-primer api contributing + angle_calc Indices and tables From f08b8d4a1f36d3b4a1a7593eb6c0762d4cd40cc7 Mon Sep 17 00:00:00 2001 From: manishvenu Date: Tue, 10 Dec 2024 16:10:05 -0700 Subject: [PATCH 31/87] Start testing setup --- regional_mom6/regional_mom6.py | 18 +- regional_mom6/regridding.py | 2 +- tests/test_rotation.py | 0 ..._branch.py => test_tides_and_parameter.py} | 238 ++++++++---------- 4 files changed, 118 insertions(+), 140 deletions(-) create mode 100644 tests/test_rotation.py rename tests/{test_manish_branch.py => test_tides_and_parameter.py} (50%) diff --git a/regional_mom6/regional_mom6.py b/regional_mom6/regional_mom6.py index 4868701b..6e82d8e1 100644 --- a/regional_mom6/regional_mom6.py +++ b/regional_mom6/regional_mom6.py @@ -3017,9 +3017,7 @@ def regrid_velocity_tracers(self, rotational_method=rot.RotationMethod.GIVEN_ANG ds, "rotated_v", coords, "", to_beginning=True ) - regridder_keith = rgd.create_regridder( - ds, coords, ".temp", method="nearest_s2d" - ) + regridder_keith = rgd.create_regridder(ds, coords, method="nearest_s2d") rotated_u = regridder_keith(ds["rotated_u"]) rotated_v = regridder_keith(ds["rotated_v"]) @@ -3124,9 +3122,7 @@ def regrid_velocity_tracers(self, rotational_method=rot.RotationMethod.GIVEN_ANG ds, "rotated_v", coords, "", to_beginning=True ) - regridder_keith = rgd.create_regridder( - ds, coords, ".temp", method="nearest_s2d" - ) + regridder_keith = rgd.create_regridder(ds, coords, method="nearest_s2d") velocities_out["u"] = regridder_keith(ds["rotated_u"]) velocities_out["v"] = regridder_keith(ds["rotated_v"]) @@ -3242,9 +3238,7 @@ def regrid_velocity_tracers(self, rotational_method=rot.RotationMethod.GIVEN_ANG ds, "rotated_v", coords, "", to_beginning=True ) - regridder_keith = rgd.create_regridder( - ds, coords, ".temp", method="nearest_s2d" - ) + regridder_keith = rgd.create_regridder(ds, coords, method="nearest_s2d") rotated_u = regridder_keith(ds["rotated_u"]) rotated_v = regridder_keith(ds["rotated_v"]) @@ -3480,8 +3474,8 @@ def regrid_tides( self.hgrid, self.orientation, self.segment_name, coords_at_t_points=True ) - regrid_u = rgd.create_regridder(tpxo_u[["lon", "lat", "uRe"]], coords, ".temp") - regrid_v = rgd.create_regridder(tpxo_v[["lon", "lat", "vRe"]], coords, ".temp2") + regrid_u = rgd.create_regridder(tpxo_u[["lon", "lat", "uRe"]], coords) + regrid_v = rgd.create_regridder(tpxo_v[["lon", "lat", "vRe"]], coords) # Interpolate each real and imaginary parts to self. uredest = regrid_u(tpxo_u[["lon", "lat", "uRe"]])["uRe"] @@ -3568,7 +3562,7 @@ def regrid_tides( rgd.add_secondary_dimension(ds, "up", coords, "", to_beginning=True) rgd.add_secondary_dimension(ds, "vp", coords, "", to_beginning=True) - regridder = rgd.create_regridder(ds, coords, ".temp", method="nearest_s2d") + regridder = rgd.create_regridder(ds, coords, method="nearest_s2d") ua = regridder(ds["ua"]) va = regridder(ds["va"]) diff --git a/regional_mom6/regridding.py b/regional_mom6/regridding.py index a8f6ac23..adebb7a5 100644 --- a/regional_mom6/regridding.py +++ b/regional_mom6/regridding.py @@ -203,7 +203,7 @@ def get_hgrid_arakawa_c_points(hgrid: xr.Dataset, point_type="t") -> xr.Dataset: def create_regridder( forcing_variables: xr.Dataset, output_grid: xr.Dataset, - outfile: Path = Path(".temp"), + outfile: Path = None, method: str = "bilinear", ) -> xe.Regridder: """ diff --git a/tests/test_rotation.py b/tests/test_rotation.py new file mode 100644 index 00000000..e69de29b diff --git a/tests/test_manish_branch.py b/tests/test_tides_and_parameter.py similarity index 50% rename from tests/test_manish_branch.py rename to tests/test_tides_and_parameter.py index 8724770e..e6a3faa7 100644 --- a/tests/test_manish_branch.py +++ b/tests/test_tides_and_parameter.py @@ -13,6 +13,9 @@ import importlib IN_GITHUB_ACTIONS = os.getenv("GITHUB_ACTIONS") == "true" +# @pytest.mark.skipif( +# IN_GITHUB_ACTIONS, reason="Test doesn't work in Github Actions." +# ) @pytest.fixture(scope="module") @@ -153,140 +156,121 @@ def dummy_bathymetry_data(): return bathymetry -class TestAll: - @classmethod - def setup_class(self): # tmp_path is a pytest fixture - expt_name = "testing" - ## User-1st, test if we can even read the angled nc files. - self.dump_files_dir = Path("testing_outputs") - os.makedirs(self.dump_files_dir, exist_ok=True) - self.expt = rmom6.experiment.create_empty( - expt_name=expt_name, - mom_input_dir=self.dump_files_dir, - mom_run_dir=self.dump_files_dir, +@pytest.fixture(scope="module") +def full_expt_setup(dummy_bathymetry_data): + + expt_name = "testing" + + latitude_extent = [16.0, 27] + longitude_extent = [192, 209] + + date_range = ["2005-01-01 00:00:00", "2005-02-01 00:00:00"] + + ## Place where all your input files go + input_dir = Path( + os.path.join( + expt_name, + "inputs", ) + ) - @classmethod - def teardown_class(cls): - shutil.rmtree(cls.dump_files_dir) + ## Directory where you'll run the experiment from + run_dir = Path( + os.path.join( + expt_name, + "run_files", + ) + ) + data_path = Path("data") + for path in (run_dir, input_dir, data_path): + os.makedirs(str(path), exist_ok=True) + bathy_path = data_path / "bathymetry.nc" + bathymetry = dummy_bathymetry_data + bathymetry.to_netcdf(bathy_path) + ## User-1st, test if we can even read the angled nc files. + expt = rmom6.experiment( + longitude_extent=longitude_extent, + latitude_extent=latitude_extent, + date_range=date_range, + resolution=0.05, + number_vertical_layers=75, + layer_thickness_ratio=10, + depth=4500, + minimum_depth=5, + mom_run_dir=run_dir, + mom_input_dir=input_dir, + toolpath_dir="", + ) + return expt - @pytest.fixture(scope="module") - def full_legit_expt_setup(self, dummy_bathymetry_data): - expt_name = "testing" +def test_full_expt_setup(full_expt_setup): + assert str(full_expt_setup) - latitude_extent = [16.0, 27] - longitude_extent = [192, 209] - date_range = ["2005-01-01 00:00:00", "2005-02-01 00:00:00"] +def test_tides(dummy_tidal_data, tmp_path): + """ + Test the main setup tides function! + """ + expt_name = "testing" - ## Place where all your input files go - input_dir = Path( - os.path.join( - expt_name, - "inputs", - ) - ) + expt = rmom6.experiment.create_empty( + expt_name=expt_name, + mom_input_dir=tmp_path, + mom_run_dir=tmp_path, + ) + # Generate Fake Tidal Data + ds_h, ds_u = dummy_tidal_data + + # Save to Fake Folder + ds_h.to_netcdf(tmp_path / "h_fake_tidal_data.nc") + ds_u.to_netcdf(tmp_path / "u_fake_tidal_data.nc") + + # Set other required variables needed in setup_tides + + # Lat Long + expt.longitude_extent = (-5, 5) + expt.latitude_extent = (0, 30) + # Grid Type + expt.hgrid_type = "even_spacing" + # Dates + expt.date_range = ("2000-01-01", "2000-01-02") + expt.segments = {} + # Generate Hgrid Data + expt.resolution = 0.1 + expt.hgrid = expt._make_hgrid() + # Create Forcing Folder + os.makedirs(tmp_path / "forcing", exist_ok=True) + + expt.setup_boundary_tides( + tmp_path / "h_fake_tidal_data.nc", + tmp_path / "u_fake_tidal_data.nc", + ) - ## Directory where you'll run the experiment from - run_dir = Path( - os.path.join( - expt_name, - "run_files", - ) - ) - data_path = Path("data") - for path in (run_dir, input_dir, data_path): - os.makedirs(str(path), exist_ok=True) - bathy_path = data_path / "bathymetry.nc" - bathymetry = dummy_bathymetry_data - bathymetry.to_netcdf(bathy_path) - self.glorys_path = bathy_path - ## User-1st, test if we can even read the angled nc files. - expt = rmom6.experiment( - longitude_extent=longitude_extent, - latitude_extent=latitude_extent, - date_range=date_range, - resolution=0.05, - number_vertical_layers=75, - layer_thickness_ratio=10, - depth=4500, - minimum_depth=5, - mom_run_dir=run_dir, - mom_input_dir=input_dir, - toolpath_dir="", - ) - return expt - - def test_full_legit_expt_setup(self, full_legit_expt_setup): - assert str(full_legit_expt_setup) - - # @pytest.mark.skipif( - # IN_GITHUB_ACTIONS, reason="Test doesn't work in Github Actions." - # ) - def test_tides(self, dummy_tidal_data): - """ - Test the main setup tides function! - """ - - # Generate Fake Tidal Data - ds_h, ds_u = dummy_tidal_data - - # Save to Fake Folder - ds_h.to_netcdf(self.dump_files_dir / "h_fake_tidal_data.nc") - ds_u.to_netcdf(self.dump_files_dir / "u_fake_tidal_data.nc") - - # Set other required variables needed in setup_tides - - # Lat Long - self.expt.longitude_extent = (-5, 5) - self.expt.latitude_extent = (0, 30) - # Grid Type - self.expt.hgrid_type = "even_spacing" - # Dates - self.expt.date_range = ("2000-01-01", "2000-01-02") - self.expt.segments = {} - # Generate Hgrid Data - self.expt.resolution = 0.1 - self.expt.hgrid = self.expt._make_hgrid() - # Create Forcing Folder - os.makedirs(self.dump_files_dir / "forcing", exist_ok=True) - - self.expt.setup_boundary_tides( - self.dump_files_dir / "h_fake_tidal_data.nc", - self.dump_files_dir / "u_fake_tidal_data.nc", - ) - def test_change_MOM_parameter(self): - """ - Test the change MOM parameter function, as well as read_MOM_file and write_MOM_file under the hood. - """ - - # Copy over the MOM Files to the dump_files_dir - base_run_dir = Path( - os.path.join( - importlib.resources.files("regional_mom6").parent, - "demos", - "premade_run_directories", - ) - ) - shutil.copytree( - base_run_dir / "common_files", self.expt.mom_run_dir, dirs_exist_ok=True +def test_change_MOM_parameter(tmp_path): + """ + Test the change MOM parameter function, as well as read_MOM_file and write_MOM_file under the hood. + """ + expt_name = "testing" + + expt = rmom6.experiment.create_empty( + expt_name=expt_name, + mom_input_dir=tmp_path, + mom_run_dir=tmp_path, + ) + # Copy over the MOM Files to the dump_files_dir + base_run_dir = Path( + os.path.join( + importlib.resources.files("regional_mom6").parent, + "demos", + "premade_run_directories", ) - MOM_override_dict = self.expt.read_MOM_file_as_dict("MOM_override") - og = self.expt.change_MOM_parameter("DT", "30", "COOL COMMENT") - MOM_override_dict_new = self.expt.read_MOM_file_as_dict("MOM_override") - assert MOM_override_dict_new["DT"]["value"] == "30" - assert MOM_override_dict["DT"]["value"] == og - assert MOM_override_dict_new["DT"]["comment"] == "COOL COMMENT\n" - - def test_properties_empty(self): - """ - Test the properties - """ - dss = self.expt.era5 - dss_2 = self.expt.tides_boundaries - dss_3 = self.expt.ocean_state_boundaries - dss_4 = self.expt.initial_condition - dss_5 = self.expt.bathymetry_property - print(dss, dss_2, dss_3, dss_4, dss_5) + ) + shutil.copytree(base_run_dir / "common_files", expt.mom_run_dir, dirs_exist_ok=True) + MOM_override_dict = expt.read_MOM_file_as_dict("MOM_override") + og = expt.change_MOM_parameter("DT", "30", "COOL COMMENT") + MOM_override_dict_new = expt.read_MOM_file_as_dict("MOM_override") + assert MOM_override_dict_new["DT"]["value"] == "30" + assert MOM_override_dict["DT"]["value"] == og + assert MOM_override_dict_new["DT"]["comment"] == "COOL COMMENT\n" From 0c3509a3450cb508935cd8bbf42100ae5673efe8 Mon Sep 17 00:00:00 2001 From: manishvenu Date: Tue, 10 Dec 2024 17:06:54 -0700 Subject: [PATCH 32/87] Change func name for consistency --- regional_mom6/regional_mom6.py | 8 ++++---- regional_mom6/rotation.py | 2 +- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/regional_mom6/regional_mom6.py b/regional_mom6/regional_mom6.py index 6e82d8e1..0cc7b2ed 100644 --- a/regional_mom6/regional_mom6.py +++ b/regional_mom6/regional_mom6.py @@ -2970,7 +2970,7 @@ def regrid_velocity_tracers(self, rotational_method=rot.RotationMethod.GIVEN_ANG ) elif rotational_method == rot.RotationMethod.FRED_AVERAGE: self.hgrid["angle_dx_rm6"] = ( - rot.initialize_hgrid_rotation_angles_using_pseudo_hgrid(self.hgrid) + rot.initialize_grid_rotation_angles_using_pseudo_hgrid(self.hgrid) ) degree_angle = rgd.coords( self.hgrid, @@ -3073,7 +3073,7 @@ def regrid_velocity_tracers(self, rotational_method=rot.RotationMethod.GIVEN_ANG ) elif rotational_method == rot.RotationMethod.FRED_AVERAGE: self.hgrid["angle_dx_rm6"] = ( - rot.initialize_hgrid_rotation_angles_using_pseudo_hgrid(self.hgrid) + rot.initialize_grid_rotation_angles_using_pseudo_hgrid(self.hgrid) ) degree_angle = rgd.coords( self.hgrid, @@ -3190,7 +3190,7 @@ def regrid_velocity_tracers(self, rotational_method=rot.RotationMethod.GIVEN_ANG ) elif rotational_method == rot.RotationMethod.FRED_AVERAGE: self.hgrid["angle_dx_rm6"] = ( - rot.initialize_hgrid_rotation_angles_using_pseudo_hgrid(self.hgrid) + rot.initialize_grid_rotation_angles_using_pseudo_hgrid(self.hgrid) ) degree_angle = rgd.coords( self.hgrid, @@ -3512,7 +3512,7 @@ def regrid_tides( elif rotational_method == rot.RotationMethod.FRED_AVERAGE: self.hgrid["angle_dx_rm6"] = ( - rot.initialize_hgrid_rotation_angles_using_pseudo_hgrid(self.hgrid) + rot.initialize_grid_rotation_angles_using_pseudo_hgrid(self.hgrid) ) degree_angle = rgd.coords( self.hgrid, diff --git a/regional_mom6/rotation.py b/regional_mom6/rotation.py index 22a1aef0..09b54729 100644 --- a/regional_mom6/rotation.py +++ b/regional_mom6/rotation.py @@ -24,7 +24,7 @@ class RotationMethod(Enum): NO_ROTATION = 4 -def initialize_hgrid_rotation_angles_using_pseudo_hgrid( +def initialize_grid_rotation_angles_using_pseudo_hgrid( hgrid: xr.Dataset, ) -> xr.Dataset: """ From ceb9a42202a0a3b5f364bf450d040bbcfd4d1de0 Mon Sep 17 00:00:00 2001 From: manishvenu Date: Wed, 11 Dec 2024 09:19:30 -0700 Subject: [PATCH 33/87] Minor Commenting --- regional_mom6/regional_mom6.py | 65 ++++++++++++++++++++++++---------- 1 file changed, 46 insertions(+), 19 deletions(-) diff --git a/regional_mom6/regional_mom6.py b/regional_mom6/regional_mom6.py index 0cc7b2ed..90cefc3a 100644 --- a/regional_mom6/regional_mom6.py +++ b/regional_mom6/regional_mom6.py @@ -1661,14 +1661,14 @@ def setup_boundary_tides( rotational_method=rot.RotationMethod.GIVEN_ANGLE, ): """ - This function: We subset our tidal data and generate more boundary files! Args: path_to_td (str): Path to boundary tidal file. - tidal_filename: Name of the tpxo product that's used in the tidal_filename. Should be h_{tidal_filename}, u_{tidal_filename} - tidal_constiuents: List of tidal constituents to include in the regridding. Default is [0] which is the M2 constituent. - boundary_type (Optional[str]): Type of boundary. Currently, only ``'rectangle'`` is supported. Here 'rectangle' refers to boundaries that are parallel to lines of constant longitude or latitude. + tidal_filename: Name of the tpxo product that's used in the tidal\_filename. Should be h_tidal_filename, u_tidal_filename + tidal_constituents: List of tidal constituents to include in the regridding. Default is [0] which is the M2 constituent. + boundary_type (str): Type of boundary. Currently, only rectangle is supported. Here rectangle refers to boundaries that are parallel to lines of constant longitude or latitude. + Returns: *.nc files: Regridded tidal velocity and elevation files in 'inputdir/forcing' @@ -2914,7 +2914,6 @@ def rotate(self, u, v, radian_angle): """ Rotate the velocities to the grid orientation. - Args: u (xarray.DataArray): The u-component of the velocity. v (xarray.DataArray): The v-component of the velocity. @@ -2931,25 +2930,26 @@ def rotate(self, u, v, radian_angle): def regrid_velocity_tracers(self, rotational_method=rot.RotationMethod.GIVEN_ANGLE): """ Cut out and interpolate the velocities and tracers - Paramaters - ---------- - rotational_method: rot.RotationMethod - The method to use for rotation of the velocities. Currently, the default method, GIVEN_ANGLE, works even with non-rotated grids + Args: + rotational_method (rot.RotationMethod): The method to use for rotation of the velocities. Currently, the default method, GIVEN_ANGLE, works even with non-rotated grids """ rawseg = xr.open_dataset(self.infile, decode_times=False, engine="netcdf4") + # If we pick Keith's Rotational Method, we regrid initially to t_points if rotational_method == rot.RotationMethod.KEITH_DOUBLE_REGRIDDING: + coords = rgd.coords( self.hgrid, self.orientation, self.segment_name, coords_at_t_points=True ) + # If not, we get the boundary points else: coords = rgd.coords(self.hgrid, self.orientation, self.segment_name) if self.arakawa_grid == "A": rawseg = rawseg.rename({self.x: "lon", self.y: "lat"}) - ## In this case velocities and tracers all on same points + # In this case velocities and tracers all on same points regridder = rgd.create_regridder( rawseg[self.u], coords, @@ -2962,35 +2962,50 @@ def regrid_velocity_tracers(self, rotational_method=rot.RotationMethod.GIVEN_ANG [self.u, self.v, self.eta] + [self.tracers[i] for i in self.tracers] ] ) + + ## Angle Calculation & Rotation if rotational_method == rot.RotationMethod.GIVEN_ANGLE: rotated_u, rotated_v = self.rotate( regridded[self.u], - regridded[self.v], + regridded_v, radian_angle=np.radians(coords.angle.values), ) + elif rotational_method == rot.RotationMethod.FRED_AVERAGE: + + # Recalculate entire hgrid angles self.hgrid["angle_dx_rm6"] = ( rot.initialize_grid_rotation_angles_using_pseudo_hgrid(self.hgrid) ) + + # Get just the boundary degree_angle = rgd.coords( self.hgrid, self.orientation, self.segment_name, angle_variable_name="angle_dx_rm6", )["angle"] + + # Rotate rotated_u, rotated_v = self.rotate( regridded[self.u], regridded[self.v], radian_angle=np.radians(degree_angle.values), ) elif rotational_method == rot.RotationMethod.KEITH_DOUBLE_REGRIDDING: + + # Get Hgrid t_point indexes ds = rgd.get_hgrid_arakawa_c_points(self.hgrid, "t") self.hgrid["angle_dx_rm6"] = xr.full_like( self.hgrid["angle_dx"], np.nan ) + + # Fill Hgrid t_points with the MOM6 angle calculation self.hgrid["angle_dx_rm6"][ ds.t_points_y.values, ds.t_points_x.values ] = rot.initialize_grid_rotation_angle(self.hgrid) + + # Get just the angles at the t_points of the boundary (basically one row/column in) degree_angle = rgd.coords( self.hgrid, self.orientation, @@ -2998,6 +3013,8 @@ def regrid_velocity_tracers(self, rotational_method=rot.RotationMethod.GIVEN_ANG coords_at_t_points=True, angle_variable_name="angle_dx_rm6", )["angle"] + + # Rotate rotated_u, rotated_v = self.rotate( regridded[self.u], regridded[self.v], @@ -3005,9 +3022,12 @@ def regrid_velocity_tracers(self, rotational_method=rot.RotationMethod.GIVEN_ANG ) coords = rgd.coords(self.hgrid, self.orientation, self.segment_name) + # Store data in a new dataset for regridding to the boundary ds = xr.Dataset() ds["rotated_u"] = rotated_u ds["rotated_v"] = rotated_v + + # Add a new dimension because while the boundary is just one cell wide, the regridding function expects a 2D array b/c curvilinear by definition rgd.add_secondary_dimension(ds, "lat", coords, "", to_beginning=True) rgd.add_secondary_dimension(ds, "lon", coords, "", to_beginning=True) rgd.add_secondary_dimension( @@ -3017,12 +3037,13 @@ def regrid_velocity_tracers(self, rotational_method=rot.RotationMethod.GIVEN_ANG ds, "rotated_v", coords, "", to_beginning=True ) + # Regrid regridder_keith = rgd.create_regridder(ds, coords, method="nearest_s2d") rotated_u = regridder_keith(ds["rotated_u"]) rotated_v = regridder_keith(ds["rotated_v"]) - ## Also need to re-regrid the rest of the variables with the correct coords + # Also need to re-regrid the rest of the variables with the correct coords regridder = rgd.create_regridder( rawseg[self.u], coords, @@ -3037,6 +3058,8 @@ def regrid_velocity_tracers(self, rotational_method=rot.RotationMethod.GIVEN_ANG ) elif rotational_method == rot.RotationMethod.NO_ROTATION: + + # Just transfer values rotated_u, rotated_v = regridded[self.u], regridded[self.v] rotated_ds = xr.Dataset( @@ -3065,6 +3088,8 @@ def regrid_velocity_tracers(self, rotational_method=rot.RotationMethod.GIVEN_ANG velocities_out = regridder_velocity( rawseg[[self.u, self.v]].rename({self.xq: "lon", self.yq: "lat"}) ) + + # See explanation of the rotational methods in the A grid section if rotational_method == rot.RotationMethod.GIVEN_ANGLE: velocities_out["u"], velocities_out["v"] = self.rotate( velocities_out["u"], @@ -3182,10 +3207,12 @@ def regrid_velocity_tracers(self, rotational_method=rot.RotationMethod.GIVEN_ANG regridded_u = regridder_uvelocity(rawseg[[self.u]]) regridded_v = regridder_vvelocity(rawseg[[self.v]]) + + # See explanation of the rotational methods in the A grid section if rotational_method == rot.RotationMethod.GIVEN_ANGLE: rotated_u, rotated_v = self.rotate( - regridded[self.u], - regridded[self.v], + regridded_u, + regridded_v, radian_angle=np.radians(coords.angle.values), ) elif rotational_method == rot.RotationMethod.FRED_AVERAGE: @@ -3199,8 +3226,8 @@ def regrid_velocity_tracers(self, rotational_method=rot.RotationMethod.GIVEN_ANG angle_variable_name="angle_dx_rm6", )["angle"] rotated_u, rotated_v = self.rotate( - regridded[self.u], - regridded[self.v], + regridded_u, + regridded_v, radian_angle=np.radians(degree_angle.values), ) elif rotational_method == rot.RotationMethod.KEITH_DOUBLE_REGRIDDING: @@ -3219,8 +3246,8 @@ def regrid_velocity_tracers(self, rotational_method=rot.RotationMethod.GIVEN_ANG angle_variable_name="angle_dx_rm6", )["angle"] rotated_u, rotated_v = self.rotate( - regridded[self.u], - regridded[self.v], + regridded_u, + regridded_v, radian_angle=np.radians(coords.angle.values), ) @@ -3256,7 +3283,7 @@ def regrid_velocity_tracers(self, rotational_method=rot.RotationMethod.GIVEN_ANG ] ) elif rotational_method == rot.RotationMethod.NO_ROTATION: - rotated_u, rotated_v = regridded[self.u], regridded[self.v] + rotated_u, rotated_v = regridded_u, regridded_v rotated_ds = xr.Dataset( { self.u: rotated_u, From 2d5f5026e988c65026c7d144a64f23a816da2961 Mon Sep 17 00:00:00 2001 From: manishvenu Date: Wed, 11 Dec 2024 09:23:48 -0700 Subject: [PATCH 34/87] Minor Commenting --- regional_mom6/regional_mom6.py | 29 +++++++++++++++++++++++++++-- 1 file changed, 27 insertions(+), 2 deletions(-) diff --git a/regional_mom6/regional_mom6.py b/regional_mom6/regional_mom6.py index 90cefc3a..74b7d815 100644 --- a/regional_mom6/regional_mom6.py +++ b/regional_mom6/regional_mom6.py @@ -3533,27 +3533,46 @@ def regrid_tides( # rotate ellipse from earth-relative to model-relative, # and convert ellipse back to amplitude and phase. SEMA, ECC, INC, PHA = ap2ep(ucplex, vcplex) + + if rotational_method == rot.RotationMethod.GIVEN_ANGLE: - angle = coords["angle"] # Fred's grid is in degrees + + # Get user-provided angle + angle = coords["angle"] + + # Rotate INC -= np.radians(angle.data[np.newaxis, :]) + elif rotational_method == rot.RotationMethod.FRED_AVERAGE: + # Generate entire hgrid angles using pseudo_hgrid self.hgrid["angle_dx_rm6"] = ( rot.initialize_grid_rotation_angles_using_pseudo_hgrid(self.hgrid) ) + + # Get just boundary angles degree_angle = rgd.coords( self.hgrid, self.orientation, self.segment_name, angle_variable_name="angle_dx_rm6", )["angle"] + + # Rotate INC -= np.radians(degree_angle.data[np.newaxis, :]) + elif rotational_method == rot.RotationMethod.KEITH_DOUBLE_REGRIDDING: + + # Get hgrid t_points ds = rgd.get_hgrid_arakawa_c_points(self.hgrid, "t") + + # Fill hgrid t_points with MOM6 angle calculation self.hgrid["angle_dx_rm6"] = xr.full_like(self.hgrid["angle_dx"], np.nan) self.hgrid["angle_dx_rm6"][ds.t_points_y.values, ds.t_points_x.values] = ( rot.initialize_grid_rotation_angle(self.hgrid) ) + + # Get boundary angles angle = rgd.coords( self.hgrid, self.orientation, @@ -3561,14 +3580,18 @@ def regrid_tides( coords_at_t_points=True, angle_variable_name="angle_dx_rm6", )["angle"] + + # Rotate INC -= np.radians(angle.data[np.newaxis, :]) ua, va, up, vp = ep2ap(SEMA, ECC, INC, PHA) # Regrid back to real boundary if rotational_method == rot.RotationMethod.KEITH_DOUBLE_REGRIDDING: + + # Get actual boundary instead of t_point boundary coords = rgd.coords(self.hgrid, self.orientation, self.segment_name) - ## Reorganize regridding into 2D + # Fill data into a 2D dataset b/c though the boundary is 1D, it is curvilinear by def of rotation. ds = xr.Dataset() ds["ua"] = ua @@ -3582,6 +3605,7 @@ def regrid_tides( up, ) + # Add empty 1 value secondary dimension for regridding rgd.add_secondary_dimension(ds, "lat", coords, "", to_beginning=True) rgd.add_secondary_dimension(ds, "lon", coords, "", to_beginning=True) rgd.add_secondary_dimension(ds, "ua", coords, "", to_beginning=True) @@ -3589,6 +3613,7 @@ def regrid_tides( rgd.add_secondary_dimension(ds, "up", coords, "", to_beginning=True) rgd.add_secondary_dimension(ds, "vp", coords, "", to_beginning=True) + # Regrid regridder = rgd.create_regridder(ds, coords, method="nearest_s2d") ua = regridder(ds["ua"]) From 04ac89e0d1445c901d91c367f6c9099cd8a62af4 Mon Sep 17 00:00:00 2001 From: manishvenu Date: Wed, 11 Dec 2024 09:23:59 -0700 Subject: [PATCH 35/87] Black --- regional_mom6/regional_mom6.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/regional_mom6/regional_mom6.py b/regional_mom6/regional_mom6.py index 74b7d815..ca2238c5 100644 --- a/regional_mom6/regional_mom6.py +++ b/regional_mom6/regional_mom6.py @@ -3534,11 +3534,10 @@ def regrid_tides( # and convert ellipse back to amplitude and phase. SEMA, ECC, INC, PHA = ap2ep(ucplex, vcplex) - if rotational_method == rot.RotationMethod.GIVEN_ANGLE: # Get user-provided angle - angle = coords["angle"] + angle = coords["angle"] # Rotate INC -= np.radians(angle.data[np.newaxis, :]) From 6ba30249ba782c36c460bddcd2b5a393764896bd Mon Sep 17 00:00:00 2001 From: manishvenu Date: Wed, 11 Dec 2024 09:33:33 -0700 Subject: [PATCH 36/87] Redo Auto Docs --- docs/api.rst | 43 ++++++++++++++++++++++++++-------- regional_mom6/regional_mom6.py | 2 +- 2 files changed, 34 insertions(+), 11 deletions(-) diff --git a/docs/api.rst b/docs/api.rst index 3db049aa..93087763 100644 --- a/docs/api.rst +++ b/docs/api.rst @@ -1,22 +1,45 @@ -=============== - API reference -=============== +regional\_mom6 package +====================== +Submodules +---------- -+++++++++++++++++++ - ``regional_mom6`` -+++++++++++++++++++ +regional\_mom6.regional\_mom6 module +------------------------------------ .. automodule:: regional_mom6.regional_mom6 :members: :undoc-members: - :private-members: + :show-inheritance: +regional\_mom6.regridding module +-------------------------------- -+++++++++++ - ``utils`` -+++++++++++ +.. automodule:: regional_mom6.regridding + :members: + :undoc-members: + :show-inheritance: + +regional\_mom6.rotation module +------------------------------ + +.. automodule:: regional_mom6.rotation + :members: + :undoc-members: + :show-inheritance: + +regional\_mom6.utils module +--------------------------- .. automodule:: regional_mom6.utils :members: :undoc-members: + :show-inheritance: + +Module contents +--------------- + +.. automodule:: regional_mom6 + :members: + :undoc-members: + :show-inheritance: diff --git a/regional_mom6/regional_mom6.py b/regional_mom6/regional_mom6.py index ca2238c5..b2a4535a 100644 --- a/regional_mom6/regional_mom6.py +++ b/regional_mom6/regional_mom6.py @@ -1665,7 +1665,7 @@ def setup_boundary_tides( Args: path_to_td (str): Path to boundary tidal file. - tidal_filename: Name of the tpxo product that's used in the tidal\_filename. Should be h_tidal_filename, u_tidal_filename + tidal_filename: Name of the tpxo product that's used in the tidal_filename. Should be h_tidal_filename, u_tidal_filename tidal_constituents: List of tidal constituents to include in the regridding. Default is [0] which is the M2 constituent. boundary_type (str): Type of boundary. Currently, only rectangle is supported. Here rectangle refers to boundaries that are parallel to lines of constant longitude or latitude. From da52a7ff1d37e71df8c9088c5cb6797018a337e7 Mon Sep 17 00:00:00 2001 From: manishvenu Date: Wed, 11 Dec 2024 12:11:15 -0700 Subject: [PATCH 37/87] Start of testing --- tests/test_regridding.py | 103 +++++++++++++ tests/test_rotation.py | 309 +++++++++++++++++++++++++++++++++++++++ 2 files changed, 412 insertions(+) create mode 100644 tests/test_regridding.py diff --git a/tests/test_regridding.py b/tests/test_regridding.py new file mode 100644 index 00000000..613b729f --- /dev/null +++ b/tests/test_regridding.py @@ -0,0 +1,103 @@ +import regional_mom6 as rm6 +import regional_mom6.rotation as rot +import regional_mom6.regridding as rgd +import pytest +import xarray as xr +import numpy as np + + +@pytest.fixture +def generate_curvilinear_grid(request): + """ + Params are a tuple longitude, tuple latitude, angle + """ + + def _generate_curvilinear_grid( + lon_point, + lat_point, + angle_base, + shift_angle_by=0, + nxp=10, + nyp=10, + resolution=0.1, + ): + """ + Generate a curvilinear grid dataset with longitude, latitude, and angle arrays. + + Parameters: + lon_point : float + Point for the lower left corner of the grid + lat_point : float + Point for the lower left corner of the grid + angle_base : float + Base angle (in radians) to initialize the grid angles. + shift_angle_by : float, optional + Maximum random variation to add or subtract from the base angle (default is 0). + nxp : int, optional + Number of points in the longitude direction (default is 10). + nyp : int, optional + Number of points in the latitude direction (default is 10). + resolution : float, optional + Loose resolution of the grid (default is 0.1). + + Returns: + xarray.Dataset + Dataset containing 'x' (longitude), 'y' (latitude), and 'angle' arrays with metadata. + """ + # Generate logical grid + lon = np.zeroes((nyp, nxp)) + lat = np.zeroes((nyp, nxp)) + + lon[0][0] = lon_point + lat[0][0] = lat_point + + angle = angle_base + np.random.uniform( + -shift_angle_by, shift_angle_by, (nyp, nxp) + ) + + # based on the angle, construct the grid from these points. + + return xr.Dataset( + { + "x": (("nyp", "nxp"), lon), + "y": (("nyp", "nxp"), lat), + "angle": (("nyp", "nxp"), angle), + } + ) + + return _generate_curvilinear_grid + + +# Not testing get_arakawa_c_points, coords, & create_regridder +def test_smoke_untested_funcs(generate_curvilinear_grid): + hgrid = generate_curvilinear_grid([100, 110], [10, 20], 10) + assert rgd.get_hgrid_arakawa_c_points(hgrid, "t") + assert rgd.coords(hgrid, "north", "segment_002") + + +def test_fill_missing_data(): + return + + +def test_add_or_update_time_dim(): + return + + +def test_generate_dz(): + return + + +def test_add_secondary_dimension(): + return + + +def test_add_vertical_coordinate_encoding(): + return + + +def test_generate_layer_thickness(): + return + + +def test_generate_encoding(): + return diff --git a/tests/test_rotation.py b/tests/test_rotation.py index e69de29b..fe7b735c 100644 --- a/tests/test_rotation.py +++ b/tests/test_rotation.py @@ -0,0 +1,309 @@ +import regional_mom6 as rm6 +import regional_mom6.rotation as rot +import regional_mom6.regridding as rgd +import pytest +import xarray as xr +import numpy as np + + +@pytest.fixture +def generate_curvilinear_grid(request): + """ + Params are a tuple longitude, tuple latitude, angle + """ + + def _generate_curvilinear_grid( + lon_point, + lat_point, + angle_base, + shift_angle_by=0, + nxp=10, + nyp=10, + resolution=0.1, + ): + """ + Generate a curvilinear grid dataset with longitude, latitude, and angle arrays. + + Parameters: + lon_point : float + Point for the lower left corner of the grid + lat_point : float + Point for the lower left corner of the grid + angle_base : float + Base angle (in radians) to initialize the grid angles. + shift_angle_by : float, optional + Maximum random variation to add or subtract from the base angle (default is 0). + nxp : int, optional + Number of points in the longitude direction (default is 10). + nyp : int, optional + Number of points in the latitude direction (default is 10). + resolution : float, optional + Loose resolution of the grid (default is 0.1). + + Returns: + xarray.Dataset + Dataset containing 'x' (longitude), 'y' (latitude), and 'angle' arrays with metadata. + """ + # Generate logical grid + lon = np.zeroes((nyp, nxp)) + lat = np.zeroes((nyp, nxp)) + + lon[0][0] = lon_point + lat[0][0] = lat_point + + angle = angle_base + np.random.uniform( + -shift_angle_by, shift_angle_by, (nyp, nxp) + ) + + # based on the angle, construct the grid from these points. + + return xr.Dataset( + { + "x": (("nyp", "nxp"), lon), + "y": (("nyp", "nxp"), lat), + "angle": (("nyp", "nxp"), angle), + } + ) + + return _generate_curvilinear_grid + + +def test_pseudo_hgrid_generation(generate_curvilinear_grid): + hgrid = generate_curvilinear_grid([100, 110], [10, 20], 10) + pseudo_hgrid = rot.create_pseudo_hgrid(hgrid) + + # Check Size + assert len(pseudo_hgrid.nxp) == (len(hgrid.nxp) + 2) + assert len(pseudo_hgrid.nyp) == (len(hgrid.nyp) + 2) + + # Check pseudo_hgrid keeps the same values + assert (pseudo_hgrid.x.values[1:-1, 1:-1] == hgrid.x.values).all() + assert (pseudo_hgrid.y.values[1:-1, 1:-1] == hgrid.y.values).all() + + # Check extra boundary has realistic values + diff_check = 1 + assert ( + ( + pseudo_hgrid.x.values[0, 1:-1] + - (hgrid.x.values[0, :] - (hgrid.x.values[1, :] - hgrid.x.values[0, :])) + ) + < diff_check + ).all() + assert ( + ( + pseudo_hgrid.x.values[1:-1, 0] + - (hgrid.x.values[:, 0] - (hgrid.x.values[:, 1] - hgrid.x.values[:, 0])) + ) + < diff_check + ).all() + assert ( + ( + pseudo_hgrid.x.values[-1, 1:-1] + - (hgrid.x.values[-1, :] - (hgrid.x.values[-2, :] - hgrid.x.values[-1, :])) + ) + < diff_check + ).all() + assert ( + ( + pseudo_hgrid.x.values[1:-1, -1] + - (hgrid.x.values[:, -1] - (hgrid.x.values[:, -2] - hgrid.x.values[:, -1])) + ) + < diff_check + ).all() + + # Check corners for the same... + assert ( + pseudo_hgrid.x.values[0, 0] + - (hgrid.x.values[0, 0] - (hgrid.x.values[1, 1] - hgrid.x.values[0, 0])) + ) < diff_check + assert ( + pseudo_hgrid.x.values[-1, 0] + - (hgrid.x.values[-1, 0] - (hgrid.x.values[-2, 1] - hgrid.x.values[-1, 0])) + ) < diff_check + assert ( + pseudo_hgrid.x.values[0, -1] + - (hgrid.x.values[0, -1] - (hgrid.x.values[1, -2] - hgrid.x.values[0, -1])) + ) < diff_check + assert ( + pseudo_hgrid.x.values[-1, -1] + - (hgrid.x.values[-1, -1] - (hgrid.x.values[-2, -2] - hgrid.x.values[-1, -1])) + ) < diff_check + + # Same for y + assert ( + ( + pseudo_hgrid.y.values[0, 1:-1] + - (hgrid.y.values[0, :] - (hgrid.y.values[1, :] - hgrid.y.values[0, :])) + ) + < diff_check + ).all() + assert ( + ( + pseudo_hgrid.y.values[1:-1, 0] + - (hgrid.y.values[:, 0] - (hgrid.y.values[:, 1] - hgrid.y.values[:, 0])) + ) + < diff_check + ).all() + assert ( + ( + pseudo_hgrid.y.values[-1, 1:-1] + - (hgrid.y.values[-1, :] - (hgrid.y.values[-2, :] - hgrid.y.values[-1, :])) + ) + < diff_check + ).all() + assert ( + ( + pseudo_hgrid.y.values[1:-1, -1] + - (hgrid.y.values[:, -1] - (hgrid.y.values[:, -2] - hgrid.y.values[:, -1])) + ) + < diff_check + ).all() + + assert ( + pseudo_hgrid.y.values[0, 0] + - (hgrid.y.values[0, 0] - (hgrid.y.values[1, 1] - hgrid.y.values[0, 0])) + ) < diff_check + assert ( + pseudo_hgrid.y.values[-1, 0] + - (hgrid.y.values[-1, 0] - (hgrid.y.values[-2, 1] - hgrid.y.values[-1, 0])) + ) < diff_check + assert ( + pseudo_hgrid.y.values[0, -1] + - (hgrid.y.values[0, -1] - (hgrid.y.values[1, -2] - hgrid.y.values[0, -1])) + ) < diff_check + assert ( + pseudo_hgrid.y.values[-1, -1] + - (hgrid.y.values[-1, -1] - (hgrid.y.values[-2, -2] - hgrid.y.values[-1, -1])) + ) < diff_check + + return + + +def test_mom6_angle_calculation_method(generate_curvilinear_grid): + """ + Check no rotation, up tilt, down tilt. + """ + + # Check no rotation + top_left = xr.Dataset( + { + "x": (("nyp", "nxp"), [[0]]), + "y": (("nyp", "nxp"), [[1]]), + } + ) + top_right = xr.Dataset( + { + "x": (("nyp", "nxp"), [[1]]), + "y": (("nyp", "nxp"), [[1]]), + } + ) + bottom_left = xr.Dataset( + { + "x": (("nyp", "nxp"), [[0]]), + "y": (("nyp", "nxp"), [[0]]), + } + ) + bottom_right = xr.Dataset( + { + "x": (("nyp", "nxp"), [[1]]), + "y": (("nyp", "nxp"), [[0]]), + } + ) + point = xr.Dataset( + { + "x": (("nyp", "nxp"), [[0.5]]), + "y": (("nyp", "nxp"), [[0.5]]), + } + ) + + assert ( + rot.mom6_angle_calculation_method( + 2, top_left, top_right, bottom_left, bottom_right, point + ) + == 0 + ) + + # Up tilt + hgrid = generate_curvilinear_grid([100, 110], [10, 20], 10, 10) + ds_t = rgd.get_hgrid_arakawa_c_points(hgrid, "t") + ds_q = rgd.get_hgrid_arakawa_c_points(hgrid, "q") + + # Reformat into x, y comps + t_points = xr.Dataset( + { + "x": (("nyp", "nxp"), ds_t.tlon.data), + "y": (("nyp", "nxp"), ds_t.tlat.data), + } + ) + q_points = xr.Dataset( + { + "x": (("nyp", "nxp"), ds_q.qlon.data), + "y": (("nyp", "nxp"), ds_q.qlat.data), + } + ) + assert ( + rot.mom6_angle_calculation_method( + hgrid.x.max() - hgrid.x.min(), + q_points.isel(nyp=slice(1, None), nxp=slice(0, -1)), + q_points.isel(nyp=slice(1, None), nxp=slice(1, None)), + q_points.isel(nyp=slice(0, -1), nxp=slice(0, -1)), + q_points.isel(nyp=slice(0, -1), nxp=slice(1, None)), + t_points, + ) + < 20 + ).all() + + ## Down tilt + hgrid = generate_curvilinear_grid([100, 110], [10, 20], -10, 10) + + ds_t = rgd.get_hgrid_arakawa_c_points(hgrid, "t") + ds_q = rgd.get_hgrid_arakawa_c_points(hgrid, "q") + + # Reformat into x, y comps + t_points = xr.Dataset( + { + "x": (("nyp", "nxp"), ds_t.tlon.data), + "y": (("nyp", "nxp"), ds_t.tlat.data), + } + ) + q_points = xr.Dataset( + { + "x": (("nyp", "nxp"), ds_q.qlon.data), + "y": (("nyp", "nxp"), ds_q.qlat.data), + } + ) + assert ( + rot.mom6_angle_calculation_method( + hgrid.x.max() - hgrid.x.min(), + q_points.isel(nyp=slice(1, None), nxp=slice(0, -1)), + q_points.isel(nyp=slice(1, None), nxp=slice(1, None)), + q_points.isel(nyp=slice(0, -1), nxp=slice(0, -1)), + q_points.isel(nyp=slice(0, -1), nxp=slice(1, None)), + t_points, + ) + > -20 + ).all() + + return + + +def test_initialize_grid_rotation_angle(generate_curvilinear_grid): + """ + Generate a curvilinear grid and test the grid rotation angle at t_points based on what we pass to generate_curvilinear_grid + """ + hgrid = generate_curvilinear_grid([100, 110], [10, 20], 10) + angle = rot.initialize_grid_rotation_angle(hgrid) + + assert (angle.values == 10).all() + return + + +def test_initialize_grid_rotation_angle_using_pseudo_hgrid(generate_curvilinear_grid): + """ + Generate a curvilinear grid and test the grid rotation angle at t_points based on what we pass to generate_curvilinear_grid + """ + hgrid = generate_curvilinear_grid([100, 110], [10, 20], 10) + angle = rot.initialize_grid_rotation_angle_using_pseudo_hgrid(hgrid) + + assert (angle.values - hgrid.angle < 1).all() + return From 08dcf5dede226fef6a7fded826be7bb5062153ab Mon Sep 17 00:00:00 2001 From: manishvenu Date: Wed, 11 Dec 2024 14:23:40 -0700 Subject: [PATCH 38/87] Test until curved grid generation comes in --- tests/test_regridding.py | 4 ++-- tests/test_rotation.py | 10 +++++++--- 2 files changed, 9 insertions(+), 5 deletions(-) diff --git a/tests/test_regridding.py b/tests/test_regridding.py index 613b729f..dd6fce4b 100644 --- a/tests/test_regridding.py +++ b/tests/test_regridding.py @@ -45,8 +45,8 @@ def _generate_curvilinear_grid( Dataset containing 'x' (longitude), 'y' (latitude), and 'angle' arrays with metadata. """ # Generate logical grid - lon = np.zeroes((nyp, nxp)) - lat = np.zeroes((nyp, nxp)) + lon = np.zeros((nyp, nxp)) + lat = np.zeros((nyp, nxp)) lon[0][0] = lon_point lat[0][0] = lat_point diff --git a/tests/test_rotation.py b/tests/test_rotation.py index fe7b735c..c1a57267 100644 --- a/tests/test_rotation.py +++ b/tests/test_rotation.py @@ -45,8 +45,8 @@ def _generate_curvilinear_grid( Dataset containing 'x' (longitude), 'y' (latitude), and 'angle' arrays with metadata. """ # Generate logical grid - lon = np.zeroes((nyp, nxp)) - lat = np.zeroes((nyp, nxp)) + lon = np.zeros((nyp, nxp)) + lat = np.zeros((nyp, nxp)) lon[0][0] = lon_point lat[0][0] = lat_point @@ -294,7 +294,10 @@ def test_initialize_grid_rotation_angle(generate_curvilinear_grid): hgrid = generate_curvilinear_grid([100, 110], [10, 20], 10) angle = rot.initialize_grid_rotation_angle(hgrid) - assert (angle.values == 10).all() + assert (angle.values == 10).all() # Angle is correct + assert ( + angle.values.shape == rgd.get_hgrid_arakawa_c_points(hgrid, "t").tlon.shape + ) # Shape is correct return @@ -306,4 +309,5 @@ def test_initialize_grid_rotation_angle_using_pseudo_hgrid(generate_curvilinear_ angle = rot.initialize_grid_rotation_angle_using_pseudo_hgrid(hgrid) assert (angle.values - hgrid.angle < 1).all() + assert angle.values.shape == hgrid.x.shape return From 9ab34e9872f06be175452cfda114e3156e474396 Mon Sep 17 00:00:00 2001 From: manishvenu Date: Wed, 11 Dec 2024 14:47:51 -0700 Subject: [PATCH 39/87] Bug --- regional_mom6/regional_mom6.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/regional_mom6/regional_mom6.py b/regional_mom6/regional_mom6.py index b2a4535a..50e6af62 100644 --- a/regional_mom6/regional_mom6.py +++ b/regional_mom6/regional_mom6.py @@ -2967,7 +2967,7 @@ def regrid_velocity_tracers(self, rotational_method=rot.RotationMethod.GIVEN_ANG if rotational_method == rot.RotationMethod.GIVEN_ANGLE: rotated_u, rotated_v = self.rotate( regridded[self.u], - regridded_v, + regridded[self.v], radian_angle=np.radians(coords.angle.values), ) From 3290d73a700d49efe45c8cbe078ec86e5849d708 Mon Sep 17 00:00:00 2001 From: manishvenu Date: Thu, 12 Dec 2024 10:57:00 -0700 Subject: [PATCH 40/87] Test_Rotation Changes --- tests/test_rotation.py | 149 ++++++++++++----------------------------- 1 file changed, 41 insertions(+), 108 deletions(-) diff --git a/tests/test_rotation.py b/tests/test_rotation.py index c1a57267..688b3fed 100644 --- a/tests/test_rotation.py +++ b/tests/test_rotation.py @@ -4,72 +4,35 @@ import pytest import xarray as xr import numpy as np +import os +# Define the path where the curvilinear hgrid file is expected in the Docker container +DOCKER_FILE_PATH = "/data/hgrid.nc" -@pytest.fixture -def generate_curvilinear_grid(request): - """ - Params are a tuple longitude, tuple latitude, angle - """ - - def _generate_curvilinear_grid( - lon_point, - lat_point, - angle_base, - shift_angle_by=0, - nxp=10, - nyp=10, - resolution=0.1, - ): - """ - Generate a curvilinear grid dataset with longitude, latitude, and angle arrays. - - Parameters: - lon_point : float - Point for the lower left corner of the grid - lat_point : float - Point for the lower left corner of the grid - angle_base : float - Base angle (in radians) to initialize the grid angles. - shift_angle_by : float, optional - Maximum random variation to add or subtract from the base angle (default is 0). - nxp : int, optional - Number of points in the longitude direction (default is 10). - nyp : int, optional - Number of points in the latitude direction (default is 10). - resolution : float, optional - Loose resolution of the grid (default is 0.1). - - Returns: - xarray.Dataset - Dataset containing 'x' (longitude), 'y' (latitude), and 'angle' arrays with metadata. - """ - # Generate logical grid - lon = np.zeros((nyp, nxp)) - lat = np.zeros((nyp, nxp)) - - lon[0][0] = lon_point - lat[0][0] = lat_point - - angle = angle_base + np.random.uniform( - -shift_angle_by, shift_angle_by, (nyp, nxp) - ) - - # based on the angle, construct the grid from these points. - - return xr.Dataset( - { - "x": (("nyp", "nxp"), lon), - "y": (("nyp", "nxp"), lat), - "angle": (("nyp", "nxp"), angle), - } - ) - return _generate_curvilinear_grid +# Define the local directory where the user might have added the curvilinear hgrid file +LOCAL_FILE_PATH = "/glade/u/home/manishrv/documents/nwa12_0.1/tides_dev/small_curvilinear_hgrid.nc" - -def test_pseudo_hgrid_generation(generate_curvilinear_grid): - hgrid = generate_curvilinear_grid([100, 110], [10, 20], 10) +@pytest.fixture +def get_curvilinear_hgrid(): + # Check if the file exists in the Docker-specific location + if os.path.exists(DOCKER_FILE_PATH): + return xr.open_dataset(DOCKER_FILE_PATH) + + # Check if the user has provided the file in a specific local directory + elif os.path.exists(LOCAL_FILE_PATH): + return xr.open_dataset(LOCAL_FILE_PATH) + + # If neither location contains the file, raise an error + else: + pytest.skip(f"Required file 'hgrid.nc' not found in {DOCKER_FILE_PATH} or {LOCAL_FILE_PATH}") + +def test_get_curvilinear_hgrid_fixture(get_curvilinear_hgrid): + # If the fixture fails to find the file, the test will be skipped. + assert get_curvilinear_hgrid is not None + +def test_pseudo_hgrid_generation(get_curvilinear_hgrid): + hgrid = get_curvilinear_hgrid pseudo_hgrid = rot.create_pseudo_hgrid(hgrid) # Check Size @@ -179,7 +142,7 @@ def test_pseudo_hgrid_generation(generate_curvilinear_grid): return -def test_mom6_angle_calculation_method(generate_curvilinear_grid): +def test_mom6_angle_calculation_method(get_curvilinear_hgrid): """ Check no rotation, up tilt, down tilt. """ @@ -223,39 +186,8 @@ def test_mom6_angle_calculation_method(generate_curvilinear_grid): == 0 ) - # Up tilt - hgrid = generate_curvilinear_grid([100, 110], [10, 20], 10, 10) - ds_t = rgd.get_hgrid_arakawa_c_points(hgrid, "t") - ds_q = rgd.get_hgrid_arakawa_c_points(hgrid, "q") - - # Reformat into x, y comps - t_points = xr.Dataset( - { - "x": (("nyp", "nxp"), ds_t.tlon.data), - "y": (("nyp", "nxp"), ds_t.tlat.data), - } - ) - q_points = xr.Dataset( - { - "x": (("nyp", "nxp"), ds_q.qlon.data), - "y": (("nyp", "nxp"), ds_q.qlat.data), - } - ) - assert ( - rot.mom6_angle_calculation_method( - hgrid.x.max() - hgrid.x.min(), - q_points.isel(nyp=slice(1, None), nxp=slice(0, -1)), - q_points.isel(nyp=slice(1, None), nxp=slice(1, None)), - q_points.isel(nyp=slice(0, -1), nxp=slice(0, -1)), - q_points.isel(nyp=slice(0, -1), nxp=slice(1, None)), - t_points, - ) - < 20 - ).all() - - ## Down tilt - hgrid = generate_curvilinear_grid([100, 110], [10, 20], -10, 10) - + # Angled + hgrid = get_curvilinear_hgrid ds_t = rgd.get_hgrid_arakawa_c_points(hgrid, "t") ds_q = rgd.get_hgrid_arakawa_c_points(hgrid, "q") @@ -273,41 +205,42 @@ def test_mom6_angle_calculation_method(generate_curvilinear_grid): } ) assert ( - rot.mom6_angle_calculation_method( + (rot.mom6_angle_calculation_method( hgrid.x.max() - hgrid.x.min(), q_points.isel(nyp=slice(1, None), nxp=slice(0, -1)), q_points.isel(nyp=slice(1, None), nxp=slice(1, None)), q_points.isel(nyp=slice(0, -1), nxp=slice(0, -1)), q_points.isel(nyp=slice(0, -1), nxp=slice(1, None)), t_points, - ) - > -20 + ) -hgrid["angle_dx"].isel(nyp=ds_t.t_points_y, nxp=ds_t.t_points_x).values + ) < 1 ).all() return -def test_initialize_grid_rotation_angle(generate_curvilinear_grid): +def test_initialize_grid_rotation_angle(get_curvilinear_hgrid): """ Generate a curvilinear grid and test the grid rotation angle at t_points based on what we pass to generate_curvilinear_grid """ - hgrid = generate_curvilinear_grid([100, 110], [10, 20], 10) + hgrid = get_curvilinear_hgrid angle = rot.initialize_grid_rotation_angle(hgrid) - - assert (angle.values == 10).all() # Angle is correct + ds_t = rgd.get_hgrid_arakawa_c_points(hgrid, "t") + assert ((angle.values -hgrid["angle_dx"].isel(nyp=ds_t.t_points_y, nxp=ds_t.t_points_x).values + ) < 1).all() # Angle is correct assert ( - angle.values.shape == rgd.get_hgrid_arakawa_c_points(hgrid, "t").tlon.shape + angle.values.shape == ds_t.tlon.shape ) # Shape is correct return -def test_initialize_grid_rotation_angle_using_pseudo_hgrid(generate_curvilinear_grid): +def test_initialize_grid_rotation_angle_using_pseudo_hgrid(get_curvilinear_hgrid): """ Generate a curvilinear grid and test the grid rotation angle at t_points based on what we pass to generate_curvilinear_grid """ - hgrid = generate_curvilinear_grid([100, 110], [10, 20], 10) - angle = rot.initialize_grid_rotation_angle_using_pseudo_hgrid(hgrid) + hgrid = get_curvilinear_hgrid + angle = rot.initialize_grid_rotation_angles_using_pseudo_hgrid(hgrid) - assert (angle.values - hgrid.angle < 1).all() + assert (angle.values - hgrid.angle_dx < 1).all() assert angle.values.shape == hgrid.x.shape return From 6709422867d38bff1d0f96cad36bde78e972956c Mon Sep 17 00:00:00 2001 From: manishvenu Date: Thu, 12 Dec 2024 10:59:59 -0700 Subject: [PATCH 41/87] Adjust Docker Path --- tests/test_rotation.py | 49 ++++++++++++++++++++++++++---------------- 1 file changed, 31 insertions(+), 18 deletions(-) diff --git a/tests/test_rotation.py b/tests/test_rotation.py index 688b3fed..11b3b76d 100644 --- a/tests/test_rotation.py +++ b/tests/test_rotation.py @@ -7,30 +7,37 @@ import os # Define the path where the curvilinear hgrid file is expected in the Docker container -DOCKER_FILE_PATH = "/data/hgrid.nc" +DOCKER_FILE_PATH = "/data/small_curvilinear_hgrid.nc" # Define the local directory where the user might have added the curvilinear hgrid file -LOCAL_FILE_PATH = "/glade/u/home/manishrv/documents/nwa12_0.1/tides_dev/small_curvilinear_hgrid.nc" +LOCAL_FILE_PATH = ( + "/glade/u/home/manishrv/documents/nwa12_0.1/tides_dev/small_curvilinear_hgrid.nc" +) + @pytest.fixture def get_curvilinear_hgrid(): # Check if the file exists in the Docker-specific location if os.path.exists(DOCKER_FILE_PATH): return xr.open_dataset(DOCKER_FILE_PATH) - + # Check if the user has provided the file in a specific local directory elif os.path.exists(LOCAL_FILE_PATH): return xr.open_dataset(LOCAL_FILE_PATH) - + # If neither location contains the file, raise an error else: - pytest.skip(f"Required file 'hgrid.nc' not found in {DOCKER_FILE_PATH} or {LOCAL_FILE_PATH}") + pytest.skip( + f"Required file 'hgrid.nc' not found in {DOCKER_FILE_PATH} or {LOCAL_FILE_PATH}" + ) + def test_get_curvilinear_hgrid_fixture(get_curvilinear_hgrid): # If the fixture fails to find the file, the test will be skipped. assert get_curvilinear_hgrid is not None + def test_pseudo_hgrid_generation(get_curvilinear_hgrid): hgrid = get_curvilinear_hgrid pseudo_hgrid = rot.create_pseudo_hgrid(hgrid) @@ -205,15 +212,18 @@ def test_mom6_angle_calculation_method(get_curvilinear_hgrid): } ) assert ( - (rot.mom6_angle_calculation_method( - hgrid.x.max() - hgrid.x.min(), - q_points.isel(nyp=slice(1, None), nxp=slice(0, -1)), - q_points.isel(nyp=slice(1, None), nxp=slice(1, None)), - q_points.isel(nyp=slice(0, -1), nxp=slice(0, -1)), - q_points.isel(nyp=slice(0, -1), nxp=slice(1, None)), - t_points, - ) -hgrid["angle_dx"].isel(nyp=ds_t.t_points_y, nxp=ds_t.t_points_x).values - ) < 1 + ( + rot.mom6_angle_calculation_method( + hgrid.x.max() - hgrid.x.min(), + q_points.isel(nyp=slice(1, None), nxp=slice(0, -1)), + q_points.isel(nyp=slice(1, None), nxp=slice(1, None)), + q_points.isel(nyp=slice(0, -1), nxp=slice(0, -1)), + q_points.isel(nyp=slice(0, -1), nxp=slice(1, None)), + t_points, + ) + - hgrid["angle_dx"].isel(nyp=ds_t.t_points_y, nxp=ds_t.t_points_x).values + ) + < 1 ).all() return @@ -226,11 +236,14 @@ def test_initialize_grid_rotation_angle(get_curvilinear_hgrid): hgrid = get_curvilinear_hgrid angle = rot.initialize_grid_rotation_angle(hgrid) ds_t = rgd.get_hgrid_arakawa_c_points(hgrid, "t") - assert ((angle.values -hgrid["angle_dx"].isel(nyp=ds_t.t_points_y, nxp=ds_t.t_points_x).values - ) < 1).all() # Angle is correct assert ( - angle.values.shape == ds_t.tlon.shape - ) # Shape is correct + ( + angle.values + - hgrid["angle_dx"].isel(nyp=ds_t.t_points_y, nxp=ds_t.t_points_x).values + ) + < 1 + ).all() # Angle is correct + assert angle.values.shape == ds_t.tlon.shape # Shape is correct return From f3b251a7d7f1ef4801b0f7da1e76001dc49decd7 Mon Sep 17 00:00:00 2001 From: manishvenu Date: Thu, 12 Dec 2024 11:43:33 -0700 Subject: [PATCH 42/87] Testing Framework Trial 1 --- .github/workflows/testing.yml | 2 +- tests/conftest.py | 29 +++++++++++++++ tests/test_regridding.py | 66 ++--------------------------------- tests/test_rotation.py | 26 -------------- 4 files changed, 32 insertions(+), 91 deletions(-) create mode 100644 tests/conftest.py diff --git a/.github/workflows/testing.yml b/.github/workflows/testing.yml index feb203e8..da83f540 100644 --- a/.github/workflows/testing.yml +++ b/.github/workflows/testing.yml @@ -18,7 +18,7 @@ jobs: testing: needs: formatting runs-on: ubuntu-latest - container: ghcr.io/cosima/regional-test-env:updated + container: manishvenu1/rm6_with_curvilinear:v2 defaults: run: shell: bash -el {0} diff --git a/tests/conftest.py b/tests/conftest.py new file mode 100644 index 00000000..db1bf2cf --- /dev/null +++ b/tests/conftest.py @@ -0,0 +1,29 @@ +import pytest +import os +import xarray as xr + +# Define the path where the curvilinear hgrid file is expected in the Docker container +DOCKER_FILE_PATH = "/data/small_curvilinear_hgrid.nc" + + +# Define the local directory where the user might have added the curvilinear hgrid file +LOCAL_FILE_PATH = ( + "/glade/u/home/manishrv/documents/nwa12_0.1/tides_dev/small_curvilinear_hgrid.nc" +) + + +@pytest.fixture +def get_curvilinear_hgrid(): + # Check if the file exists in the Docker-specific location + if os.path.exists(DOCKER_FILE_PATH): + return xr.open_dataset(DOCKER_FILE_PATH) + + # Check if the user has provided the file in a specific local directory + elif os.path.exists(LOCAL_FILE_PATH): + return xr.open_dataset(LOCAL_FILE_PATH) + + # If neither location contains the file, raise an error + else: + pytest.skip( + f"Required file 'hgrid.nc' not found in {DOCKER_FILE_PATH} or {LOCAL_FILE_PATH}" + ) diff --git a/tests/test_regridding.py b/tests/test_regridding.py index dd6fce4b..4d163ea5 100644 --- a/tests/test_regridding.py +++ b/tests/test_regridding.py @@ -6,71 +6,9 @@ import numpy as np -@pytest.fixture -def generate_curvilinear_grid(request): - """ - Params are a tuple longitude, tuple latitude, angle - """ - - def _generate_curvilinear_grid( - lon_point, - lat_point, - angle_base, - shift_angle_by=0, - nxp=10, - nyp=10, - resolution=0.1, - ): - """ - Generate a curvilinear grid dataset with longitude, latitude, and angle arrays. - - Parameters: - lon_point : float - Point for the lower left corner of the grid - lat_point : float - Point for the lower left corner of the grid - angle_base : float - Base angle (in radians) to initialize the grid angles. - shift_angle_by : float, optional - Maximum random variation to add or subtract from the base angle (default is 0). - nxp : int, optional - Number of points in the longitude direction (default is 10). - nyp : int, optional - Number of points in the latitude direction (default is 10). - resolution : float, optional - Loose resolution of the grid (default is 0.1). - - Returns: - xarray.Dataset - Dataset containing 'x' (longitude), 'y' (latitude), and 'angle' arrays with metadata. - """ - # Generate logical grid - lon = np.zeros((nyp, nxp)) - lat = np.zeros((nyp, nxp)) - - lon[0][0] = lon_point - lat[0][0] = lat_point - - angle = angle_base + np.random.uniform( - -shift_angle_by, shift_angle_by, (nyp, nxp) - ) - - # based on the angle, construct the grid from these points. - - return xr.Dataset( - { - "x": (("nyp", "nxp"), lon), - "y": (("nyp", "nxp"), lat), - "angle": (("nyp", "nxp"), angle), - } - ) - - return _generate_curvilinear_grid - - # Not testing get_arakawa_c_points, coords, & create_regridder -def test_smoke_untested_funcs(generate_curvilinear_grid): - hgrid = generate_curvilinear_grid([100, 110], [10, 20], 10) +def test_smoke_untested_funcs(get_curvilinear_hgrid): + hgrid = get_curvilinear_hgrid assert rgd.get_hgrid_arakawa_c_points(hgrid, "t") assert rgd.coords(hgrid, "north", "segment_002") diff --git a/tests/test_rotation.py b/tests/test_rotation.py index 11b3b76d..db4a5adb 100644 --- a/tests/test_rotation.py +++ b/tests/test_rotation.py @@ -6,32 +6,6 @@ import numpy as np import os -# Define the path where the curvilinear hgrid file is expected in the Docker container -DOCKER_FILE_PATH = "/data/small_curvilinear_hgrid.nc" - - -# Define the local directory where the user might have added the curvilinear hgrid file -LOCAL_FILE_PATH = ( - "/glade/u/home/manishrv/documents/nwa12_0.1/tides_dev/small_curvilinear_hgrid.nc" -) - - -@pytest.fixture -def get_curvilinear_hgrid(): - # Check if the file exists in the Docker-specific location - if os.path.exists(DOCKER_FILE_PATH): - return xr.open_dataset(DOCKER_FILE_PATH) - - # Check if the user has provided the file in a specific local directory - elif os.path.exists(LOCAL_FILE_PATH): - return xr.open_dataset(LOCAL_FILE_PATH) - - # If neither location contains the file, raise an error - else: - pytest.skip( - f"Required file 'hgrid.nc' not found in {DOCKER_FILE_PATH} or {LOCAL_FILE_PATH}" - ) - def test_get_curvilinear_hgrid_fixture(get_curvilinear_hgrid): # If the fixture fails to find the file, the test will be skipped. From 4315b543ab2bf73acbb135b3281f361b928175a2 Mon Sep 17 00:00:00 2001 From: manishvenu Date: Thu, 12 Dec 2024 12:08:40 -0700 Subject: [PATCH 43/87] Docker Docs --- docs/docker_image_testing.md | 35 +++++++++++++++++++++++++++++++++++ docs/index.rst | 3 ++- 2 files changed, 37 insertions(+), 1 deletion(-) create mode 100644 docs/docker_image_testing.md diff --git a/docs/docker_image_testing.md b/docs/docker_image_testing.md new file mode 100644 index 00000000..474dc5d6 --- /dev/null +++ b/docs/docker_image_testing.md @@ -0,0 +1,35 @@ +# Docker Image & Github Testing (For contributors) + +RM6 uses a docker image in github actions for holding large data. It wasn't directly being used, but for downloading the curvilinear grid for testing, we are using it. This document is a list of helpful commands to work on it. + +The link to the image is here: +https://github.com/COSIMA/regional-mom6/pkgs/container/regional-test-env + +For local development of the image to add data to it for testing, first pull it. +```docker pull ghcr.io/cosima/regional-test-env:updated``` + +Then to do testing of the image, we cd into our cloned version of RM6, and run this command. It mounts our code in the /workspace directory.: +```docker run -it --rm \ -v $(pwd):/workspace \ -w /workspace \ ghcr.io/cosima/regional-test-env:updated \ /bin/bash``` + +The -it flag is for shell access, and the workspace stuff is to get our local code in the container. +You have to download conda, python, pip, and all that business to properly run the tests. + +Getting to adding the data, you should create a folder and add both the data you want to add and a file simple called "Dockerfile". In Dockerfile, we'll get the original image, then copy the data we need to the data folder. + +``` +# Use the base image +FROM ghcr.io/cosima/regional-test-env: + +# Copy your local file into the /data directory in the container +COPY /data/ +``` + +Then, we need to build the image, tag it, and push it + +``` +docker build -t my-custom-image . # IN THE DIRECTORY WITH THE DOCKERFILE +docker tag my-custom-image ghcr.io/cosima/regional-test-env: +docker ghcr.io/cosima/regional-test-env: +``` + + diff --git a/docs/index.rst b/docs/index.rst index 095b5367..fdbaa54e 100644 --- a/docs/index.rst +++ b/docs/index.rst @@ -91,9 +91,10 @@ The bibtex entry for the paper is: installation demos mom6-file-structure-primer + angle_calc api contributing - angle_calc + docker_image_testing Indices and tables From f6e6d7c9c72dc62b3e2d10cc37501b725f30cc82 Mon Sep 17 00:00:00 2001 From: manishvenu Date: Thu, 12 Dec 2024 13:11:55 -0700 Subject: [PATCH 44/87] Test Cleaning --- .../angle_calc_mom6.ipynb | 2471 ----------------- tests/test_config.py | 21 +- tests/test_expt_class.py | 29 +- tests/test_tides_and_parameter.py | 12 +- 4 files changed, 25 insertions(+), 2508 deletions(-) delete mode 100755 regional_mom6/testing_to_be_deleted/angle_calc_mom6.ipynb diff --git a/regional_mom6/testing_to_be_deleted/angle_calc_mom6.ipynb b/regional_mom6/testing_to_be_deleted/angle_calc_mom6.ipynb deleted file mode 100755 index 55b7ff58..00000000 --- a/regional_mom6/testing_to_be_deleted/angle_calc_mom6.ipynb +++ /dev/null @@ -1,2471 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 33, - "metadata": {}, - "outputs": [], - "source": [ - "import xarray as xr\n", - "import numpy as np\n", - "import matplotlib.pyplot as plt\n" - ] - }, - { - "cell_type": "code", - "execution_count": 101, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " Size: 111MB\n", - "Dimensions: (nyp: 1561, nxp: 1481, ny: 1560, nx: 1480)\n", - "Dimensions without coordinates: nyp, nxp, ny, nx\n", - "Data variables:\n", - " tile |S255 255B ...\n", - " y (nyp, nxp) float64 18MB ...\n", - " x (nyp, nxp) float64 18MB ...\n", - " dy (ny, nxp) float64 18MB ...\n", - " dx (nyp, nx) float64 18MB ...\n", - " area (ny, nx) float64 18MB ...\n", - " angle_dx (nyp, nxp) float64 18MB ...\n", - "Attributes:\n", - " file_name: ocean_hgrid.nc\n", - " Description: MOM6 NCAR NWA12\n", - " Author: Fred Castruccio (fredc@ucar.edu)\n", - " Created: 2024-04-18T08:39:49.607481\n", - " type: MOM6 supergrid file\n" - ] - } - ], - "source": [ - "\n", - "hgrid = xr.open_dataset(\"/glade/u/home/manishrv/documents/nwa12_0.1/mom_input/n3b.clean/hgrid.nc\")\n", - "ocean_geo = xr.open_dataset(\"/glade/u/home/manishrv/manish_scratch_symlink/n3b.clean/run/ocean_geometry.nc\")\n", - "print(hgrid)" - ] - }, - { - "cell_type": "code", - "execution_count": 97, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
        \n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "
        <xarray.DataArray 'lath' (lath: 780)> Size: 6kB\n",
-       "array([ 5.242669,  5.325648,  5.408616, ..., 53.820237, 53.85652 , 53.892753])\n",
-       "Coordinates:\n",
-       "  * lath     (lath) float64 6kB 5.243 5.326 5.409 5.492 ... 53.82 53.86 53.89\n",
-       "Attributes:\n",
-       "    long_name:       Latitude\n",
-       "    units:           degrees_north\n",
-       "    cartesian_axis:  Y
        " - ], - "text/plain": [ - " Size: 6kB\n", - "array([ 5.242669, 5.325648, 5.408616, ..., 53.820237, 53.85652 , 53.892753])\n", - "Coordinates:\n", - " * lath (lath) float64 6kB 5.243 5.326 5.409 5.492 ... 53.82 53.86 53.89\n", - "Attributes:\n", - " long_name: Latitude\n", - " units: degrees_north\n", - " cartesian_axis: Y" - ] - }, - "execution_count": 97, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "ocean_geo.lath" - ] - }, - { - "cell_type": "code", - "execution_count": 100, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([ 5.20117513, 5.24266887, 5.28415984, ..., 52.74478451,\n", - " 52.76099408, 52.77719011])" - ] - }, - "execution_count": 100, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "hgrid.y[:,0].values" - ] - }, - { - "cell_type": "code", - "execution_count": 35, - "metadata": {}, - "outputs": [], - "source": [ - "k = 2\n", - "kp2 = k //2\n", - "offset_one_by_two_y = slice(kp2, len(hgrid.x.nyp),k)\n", - "offset_one_by_two_x = slice(kp2, len(hgrid.x.nxp),k)\n", - "by_two_x = slice(0, len(hgrid.x.nxp),k)\n", - "by_two_y = slice(0, len(hgrid.x.nyp),k)\n", - "t_points = (offset_one_by_two_y,offset_one_by_two_x)\n", - "u_points = (offset_one_by_two_y,by_two_x)\n", - "v_points = (by_two_y,offset_one_by_two_x)\n", - "q_points = (by_two_y,by_two_x)\n", - "tlon = hgrid.x[t_points]\n", - "tlat = hgrid.y[t_points]\n", - "\n", - "# U point locations\n", - "ulon = hgrid.x[u_points]\n", - "ulat = hgrid.y[u_points]\n", - "\n", - "# V point locations\n", - "vlon = hgrid.x[v_points]\n", - "vlat = hgrid.y[v_points]\n", - "\n", - "# Corner point locations\n", - "qlon = hgrid.x[q_points]\n", - "qlat = hgrid.y[q_points]\n" - ] - }, - { - "cell_type": "code", - "execution_count": 36, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(781, 741)" - ] - }, - "execution_count": 36, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "qlon.shape" - ] - }, - { - "cell_type": "code", - "execution_count": 37, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 37, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
        " - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "hgrid[\"angle_dx\"].plot()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - " pi_720deg = atan(1.0) / 180.0\n", - " len_lon = 360.0 ; if (G%len_lon > 0.0) len_lon = G%len_lon\n", - " do j=G%jsc,G%jec ; do i=G%isc,G%iec\n", - " do n=1,2 ; do m=1,2\n", - " lonB(m,n) = modulo_around_point(G%geoLonBu(I+m-2,J+n-2), G%geoLonT(i,j), len_lon)\n", - " enddo ; enddo\n", - " lon_scale = cos(pi_720deg*((G%geoLatBu(I-1,J-1) + G%geoLatBu(I,J)) + &\n", - " (G%geoLatBu(I,J-1) + G%geoLatBu(I-1,J)) ) )\n", - " angle = atan2(lon_scale*((lonB(1,2) - lonB(2,1)) + (lonB(2,2) - lonB(1,1))), &\n", - " (G%geoLatBu(I-1,J) - G%geoLatBu(I,J-1)) + &\n", - " (G%geoLatBu(I,J) - G%geoLatBu(I-1,J-1)) )\n", - " G%sin_rot(i,j) = sin(angle) ! angle is the clockwise angle from lat/lon to ocean\n", - " G%cos_rot(i,j) = cos(angle) ! grid (e.g. angle of ocean \"north\" from true north)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - " function modulo_around_point(x, xc, Lx) result(x_mod)\n", - " real, intent(in) :: x !< Value to which to apply modulo arithmetic [A]\n", - " real, intent(in) :: xc !< Center of modulo range [A]\n", - " real, intent(in) :: Lx !< Modulo range width [A]\n", - " real :: x_mod !< x shifted by an integer multiple of Lx to be close to xc [A].\n", - "\n", - " if (Lx > 0.0) then\n", - " x_mod = modulo(x - (xc - 0.5*Lx), Lx) + (xc - 0.5*Lx)\n", - " else\n", - " x_mod = x\n", - " endif\n", - " end function modulo_around_point" - ] - }, - { - "cell_type": "code", - "execution_count": 39, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "This is a regional case\n" - ] - } - ], - "source": [ - "# Direct Translation\n", - "pi_720deg = np.arctan(1)/180 # One quarter the conversion factor from degrees to radians\n", - " \n", - "## Check length of longitude\n", - "len_lon = 360.0\n", - "G_len_lon = hgrid.x.max() - hgrid.x.min()\n", - "if G_len_lon != 360:\n", - " print(\"This is a regional case\")\n", - " len_lon = G_len_lon\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": 40, - "metadata": {}, - "outputs": [], - "source": [ - "## Iterate it, j=G%jsc,G%jec ; do i=G%isc,G%iec mean we iterate from jsc to jec and isc to iec\n", - "## Then you iterate around it, 1,2 and 1,2\n", - "\n", - "# In this way we wrap each longitude in the correct way even if we are at the seam like 360, I still don't understand it as much\n", - "\n", - "\n", - "def modulo_around_point(x, xc, Lx):\n", - " \"\"\"\n", - " This function calculates the modulo around a point, for use in cases where we are wrapping around the globe at the seam. Return the modulo value of x in an interval [xc-(Lx/2) xc+(Lx/2)]. If Lx<=0, then it returns x without applying modulo arithmetic.\n", - " Parameters\n", - " ----------\n", - " x: float\n", - " Value to which to apply modulo arithmetic\n", - " xc: float\n", - " Center of modulo range\n", - " Lx: float\n", - " Modulo range width\n", - " Returns\n", - " -------\n", - " float\n", - " x shifted by an integer multiple of Lx to be close to xc, \n", - " \"\"\"\n", - " if Lx <= 0:\n", - " return x\n", - " else:\n", - " return ((x - (xc - 0.5*Lx)) % Lx )- Lx/2 + xc\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": 41, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " Size: 5MB\n", - "array([[0. , 0. , 0. , ..., 0. , 0. ,\n", - " 0. ],\n", - " [0. , 0. , 0. , ..., 0. , 0. ,\n", - " 0. ],\n", - " [0. , 0. , 0. , ..., 0. , 0. ,\n", - " 0. ],\n", - " ...,\n", - " [4.43651643, 4.47489525, 4.5132071 , ..., 4.40963338, 4.37648025,\n", - " 4.34327766],\n", - " [4.45746382, 4.49601954, 4.53450787, ..., 4.429975 , 4.39669398,\n", - " 4.36336333],\n", - " [4.47848207, 4.51721524, 4.5558806 , ..., 4.45038282, 4.41697365,\n", - " 4.38351466]])\n", - "Dimensions without coordinates: nyp, nxp\n" - ] - } - ], - "source": [ - "angles_arr_v2 = np.zeros((len(tlon.nyp), len(tlon.nxp)))\n", - "\n", - "# Compute lonB for all points\n", - "lonB = np.zeros((2, 2, len(tlon.nyp), len(tlon.nxp)))\n", - "\n", - "# Vectorized computation of lonB\n", - "for n in np.arange(0,2):\n", - " for m in np.arange(0,2):\n", - " lonB[m, n] = modulo_around_point(qlon[np.arange(m,(m-1+len(qlon.nyp))), np.arange(n,(n-1+len(qlon.nxp)))], tlon, len_lon)\n", - "\n", - "# Compute lon_scale\n", - "lon_scale = np.cos(pi_720deg* ((qlat[0:-1, 0:-1] + qlat[1:, 1:]) + (qlat[1:, 0:-1] + qlat[0:-1, 1:])))\n", - "\n", - "\n", - "\n", - "# Compute angle\n", - "angle = np.arctan2(\n", - " lon_scale * ((lonB[0, 1] - lonB[1, 0]) + (lonB[1, 1] - lonB[0, 0])),\n", - " (qlat[:-1, :-1] - qlat[1:, 1:]) + (qlat[1:, 0:-1] - qlat[0:-1, 1:])\n", - ")\n", - "# Assign angle to angles_arr\n", - "angles_arr_v2 = np.rad2deg(angle) - 90\n", - "# Print the result\n", - "print(angles_arr_v2)" - ] - }, - { - "cell_type": "code", - "execution_count": 42, - "metadata": {}, - "outputs": [], - "source": [ - "# Create the new DataArray with the new dimensions\n", - "t_angles = xr.DataArray(\n", - " angles_arr_v2,\n", - " dims=[\"qy\", \"qx\"],\n", - " coords={\n", - " \"qy\": tlon.nyp.values,\n", - " \"qx\": tlon.nxp.values,\n", - " }\n", - ")\n", - "\n", - "\n", - "\n", - "hgrid[\"t_angle_dx_mom6\"] = t_angles\n", - "hgrid[\"t_angle_dx_mom6\"].attrs[\"_FillValue\"] = np.nan\n", - "hgrid[\"t_angle_dx_mom6\"].attrs[\"units\"] = \"deg\"\n", - "hgrid[\"t_angle_dx_mom6\"].attrs[\"description\"] = \"MOM6 calculates angles internally, this field replicates that for rotating boundary conditions. Use this over other angle fields for MOM6 applications\"\n" - ] - }, - { - "cell_type": "code", - "execution_count": 43, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 43, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
        " - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "hgrid[\"t_angle_dx_mom6\"].plot(vmin = 0)" - ] - }, - { - "cell_type": "code", - "execution_count": 44, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 44, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
        " - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "hgrid[\"angle_dx\"][kp2::k,kp2::k].plot()" - ] - }, - { - "cell_type": "code", - "execution_count": 45, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
        " - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "angle_diff = hgrid[\"angle_dx\"][kp2::k,kp2::k].values - hgrid[\"t_angle_dx_mom6\"].values\n", - "plt.figure(figsize=(8, 6))\n", - "plt.imshow(angle_diff,cmap='coolwarm')\n", - "plt.colorbar()\n", - "plt.title(\"Difference between caluculated MOM6 angle and angle_dx from Hgrid angle_dx\")\n", - "plt.show() " - ] - }, - { - "cell_type": "code", - "execution_count": 56, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 56, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjwAAAGwCAYAAACtlb+kAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAACgHUlEQVR4nO2deXgUVfb3v5UAYRGjwSEhGiUgKrKJoCw6ArKJAjL6ExVFVERUBMIqCEhkIBGEBFc2GXFAxNdRHBlllU0ERdlkUVAJi0oGRzGIQgKp+/7RXdV1q+veqq7qpJecz/M0pOvUuUstt07fqvMthTHGQBAEQRAEEcckRLoBBEEQBEEQZQ0FPARBEARBxD0U8BAEQRAEEfdQwEMQBEEQRNxDAQ9BEARBEHEPBTwEQRAEQcQ9FPAQBEEQBBH3VIp0A2IFVVXx008/oWbNmlAUJdLNIQiCIKIYxhh+//13pKenIyGhbOYWzpw5g5KSkrCUVaVKFVStWjUsZUUrFPA45KeffkJGRkakm0EQBEHEEEePHsUll1wS9nLPnDmDzMvOQ+Hx0rCUl5aWhoKCgrgOeijgcUjNmjUB+A7e888/H9dPfAUsAUACwBTgy/GDuPWbT3sFUHz2HSN4W7OXX/b5KgBTGHY/NpizN/7Hi4DCwBKAvf2G8ra38gGFQfF/vuo9MlDn0mmAwgAFSFAYtvUcw/m2XTEZigIkJqhIAMP6zhN1W+e1z+jLFYXhw3Y5nG/vzaOQoDD9s6hVnm575MvBSISKBEVFosLw8rWzOd/Rux5GgsKQqDAkQMXfm/xTt03e2weJigoFDImKilEN3+F8Zx3oiQSoAHx9GtDgQ9228LsuSFRUJEBFAoDe9ddyvh8W3ODzg4pumVs429pDLZGoqEgEQwIY2l62k7N/eaQJFIUhESquydjH2fb+cBUS4RMoTwRDg0sOcPaCHxvo94ovu/hbznbspyu4+8ip6bzvr8eu8rdZwQV1vuZsJ49drf+dqCiokbZX//5HYSMkGEqulrab8y0ubMp9T0r7ypHNq+/pwibcd2O7/ihsBAAo9Yu9n1+H386/HWsIAFD92zqlzje67X/HrtT9gODt+MNPDVDqN5v3wfc/XgHVbyuFgqsu2c/Zdx9tqNvM+/7zI039bfZta/Nxs/ZQS6hQoCIBXep+ztk+OHgjSv37SGUJuLP+es6++PtOKGUJUKGg3+UrOdusAz2h+usshYIhVy7l7M/tuxsMCkpZAsY3WszZxu1+EKVMgcoUMJaA5695TbcN2T4QKhS/PQFzWr7C+T7w+TBff/z+S9pM121/2/SUvlxlStCY0fHjiWBMAWMKSqFgY+dndFub5VPA9DYBX3Qfy/k2XzoNjAGMKQBTsOv/AuNc4yV58B0SCsCAPX2Gcb6NF7zgs6t++yNDdFuT2S9BAXyDtgp8NehJzvea/FegMAAqsGMkP263yPVtG0UFwILH/FYTXgGYbwj+bMognDx5EhkZGfq1I9yUlJSg8HgpDm+ri/NreptBOvm7istaHEJJSUlcBzwKvVrCGSdPnkRycjKKiopw/vnnR7o5BEEQRBRT1tcMrfxfDmSGJeCpdUVB3F/faIaHIAiCIGKUUqbqs5leyqgIUMBDEARBEDGKCqbf9vVSRkWA0tIJgiAIgoh7aIaHIAiCIGIUFSq83pDyXkJsQAGPS5oMz9cztFgCsHcqnynQ8Jl8MH+W1jcTeVuD3HxfgkECAIXhu1HDOXu9F2f4fAEUDB7B2erOfd6f3QUggeHww6MDtn9O1TO4oAAF9/GZDw3emezL7kpgUAB8c0cga6LJBxOhKAwJCb4srO23TuZ826wagwR/2QkKw8aOz+u2zuuH6dlblRQVy/76Eud71+bH/XYVCQrDm63m6bZHvnwQCf7p1ARFxewWCznfYTvv0bO7EhSG55r+S7dl77kdCf7sLgAY1+g/nG/+112Q4LcNvWoNZ5uzv50/w8tX98NXbOLsi79rhUT/IHD35V9wtn8fvMbXXqhIVFTcmrmHs68u8GX5JCoqbq7LZwBtOHSFnnWWqKhoe9lBzv754Uz/tmC47tJDnG37kUt9fv42N7v0qG7bfZRPe22S8QP3fd/Ri7nvV2f86Mjm1VfWrl1HeJkHY38A4Isjdbnvxu2x+XA9/e9SloC/1v2OW3fDoStQ6svHCdoHKwuu1rOlAATtv/e+b+4rFwm4q/42zrb4u1Yo9Z+cKhLQr8Fmzj5nfzvd94kr13G2/K+76G1SWQJGX72cs0/a09OfMZWAvzfhs7BG77oLKhL0bKsXmr/F2R/b1heqP8PrtZYLONt9nw/wZ1IlQGUK3mk7S7fdvunJQKYVFCy/6QXOt8PaEb5sKn+m1qZO03Tb9SueBmOACl8mlnnMaPTvbD3TijGFG28avDOZy8L6/p6nOd+6C58LZGKpwKEHn9Jtl732vC+TigFgCg4NHMn5Zr40AwD82VYKDmYFxtf60/P05QoDvh3Dj81X/j1fz7Qyj9tXj8vXM7TAgsf8psMD9l0v8LaypJQxLmPRbRkVAQp4XKIAYMz3h2J1rDDDOmZf5jtnFBVgCRYihqoCJYHpQY/ZBn/AwlTTCv4Bgun/msyGAcRctsoUJABQLWwAUKomAAm+9G/zbwHV4HDO4i7pOZaABDAkMAUJpo11Vk3U09nBgn21wThBUfQLPe/LoMJaCPIsS0SCxFaKBD2osbZb+5awRABAIhSc9f/N+SJRb7uVb6ISuOiJyw5ul1bXWSBoO55hlYR98fmK717LbGXpW4LAtrPaVkbfUlM5Z1lg6LLaTyUsUXhclPh9VcEdfa3sUgv7WZaot8WqfG0fiXy19lrt+7MsESpThL5a0GLFOZaop5YH2dREffua23xODfTFah+U+oMkLYXciDHYsfI1Bjvm0cgY7Fhea/3BjP6/AWOwIzrktaDGXLHi99PLsKhXZtM+ojEfIl8iKqCAxwssELyY0ZdbGVVASZDYtZPSyqidyP6gJ8jmq926WH/QAgSXraoKmAIkCq5PjPmCHqbNIBkoVROgGjR6zOiDoYKg/p5jCUhgit/f+iLvC3TUoEHVF9Awf0AUXK8s4ClFAkqZ9UUr4Cu/IIqmgQMXTIv+IHDxKbXYS4FgSRwMAcEB0Vn/r3sRxuAiFJtXX6uAMGATBzQ+uzioMW4Ly8ADiZZlGttkFVgYy7YKiIwBj5V/KRKgsgTLIEyvV7CvtKDGinNqomF2yMJXFftqszeqRWBiXG7lbwx2mMkeCIYQZAP4YMf840wPdlRrX2OwExQQGYMdwQ9KzT9oWNDLtQ5aAsGUwAZxQMTZyxF6aNk5FPC4hQGK4gsELIcZbblohsfOrgKwmv3R1vcHPZzJPzPkLyXYlQHwBy1mpXNt0ClVYfnqjFKWoAdJ5mFem8FhjEG1ONvPqQmcaCFv883waDNAwb6JUBUVCbCY4fEHQyoU/daU2Z7AEvRbXmYb4LuoWQVaJZIZE+MvdSsCF2OL2R9WyTIQCi5bHAwBwQHRWVbJN/MjKPuMWslyO/h8y26Gp0Qa8NjP0miYAwTjthAFS6WCAEA2g+OrK0EYLOmzQ9KZGOuARwt0RGWf0wMiC189MLEOloxBTXC5CcKg5pyaIAx2AP+PHINAoLlO4yyOVZuYP8Aw25lqWC750cesggtjsCMKllRBYMJ8M+t2szh2MzjRNMOjglmOF6GWUREg4UGHkPAgQRAE4ZTyEh4s+KYOanoUHvz9dxWZVx2L++sbzfAQBEEQRIxCt7ScQwEPQRAEQcQolKXlHBIeJAiCIAgi7qEZHoIgCIKIUVQIs/NDKqMiQAGPS5oPytdFB6EEC001GZkP5hcmDBIlnJCv+0EJFri6Iifg+91TvK1efp7uB4Xh4JCAMGHdV6cbbAgS5Kr7+jRfeoFmfyAg5pX5Zq4uWKgoCBICu+Ldv/tECwEoCsPXf5uo25oue8ZnU2ApWth65VhdsFBRGCde1mHtCC6Da2W7mZxvj08Gc/Z3276q2+797FEAvjoTwLCw1Wucr1HUcG7LNzjb4O336UKIAJB/zRLOPuar/wPgS/+e0vQ9zqYJHgI+8UCz4OG0fd387VIxsuFKzmYUQwSCBRFf3d9B/9ssXPfagb/y/bviE/3vfxy4Uf87UVGDBPHe+Lat/ncCVPRt8Jn+feG3rbl1jTY7u52vsV4AXLuMbVahcP0BAiJ+GgOv3KD//er+Dlxm0ZNXreXWzf+6CwBfdpN5H0zb140TADTvv+w9t/t8LQQAtePClxWVgOnN3ubsQ3fcq2fQvXTtm5zt0S/76RlWpUzB69e9ztk1gUAAeKv1XM525+YnuEwrs7hn1w1Zuu3jDnmc7aaPR3Hp5Vu6PKfbrlv+tN4mK/HAJh9M5LKxjOf9Fe/+Xc+0Ygz4rvd4zjfzzVwuE+vQA2N0W90FU7ksrMP9R3O+dWdPN2Q9KTg0KDDO1XtxRiDtXAW+H84Lt14+NV/PwlIYcODpwBiqCwv6s7y+edYkLvi031cNHrebDM/3jX8CccHmTwSEB7fPKUfhwTBkaXn1jxUo4HGLIa1ceKgIUta1k1HmJ/MN+JmFBy2EboxmFVASBOswgPn1eSxL8Nt9DTDpcfjTzhXFWixR1TQ3rDR8WIKezi7T8LHS2jmnCQ8yWGv4GEUNzTaW4Et1F9y7PqenrVtrnmhtkYnPWWkAybSBjL5WKfElTHy6nrXTpTHYzfpCZyXl2tntfWVp6V40fBKFInxOfEWp4YBv/4qQpY4b65UJKWqKx0Flq2Jfu/RxXUDQKqVdDdRnTg83CgdanQqlqiIWD1QNGjyW6eHGtHPrtHRdBNDC1xeYWKSty9LOAS7YsUxLl6SWC9PVERjvAet1ZOWWJaUMYXhbenjaEu1QwOMS/bovCEy05aLgwc7uU2G2sBlFC81tUgEoCliC4OhlCpjKAEWBWWqHqYo+86NY+Kuq38dibNMUV0WXkFLm08mxWkdl/nqZAiuFBF2l2S8wKLYFX6SMooZB/WEJUBmgirRp/EFcqaWWTqI+w2N9YfMHPAI1XS3gMesKGX1FoncijDYrfRhjsBQsWugt8JDhNEizQhPxk/na2WU2UdDjq1cQ0KiBoMUKPWix1MpJ0PVyrJBq6dgoIuszOAKNHlFQ49PZ8f1tKx5o1tIxBDtWwRIX7FgEHlLFY1VmkwsEcsGOyS4NhhDwEarn29i5/4mogwIetzgIWgBJMOSfqZHN4oh+gTBJ0KP9KrIarxVtlsZyFkcBGPPZLWIAps8eWak0J+izO5aihZpCM5j1gGt4/5cZuWhhguVyvV3+C4C1KKHvApIoES0Uzf6o8AVLvr+tZ4CA4Nc/AL6LrP5qAqkgojgYskKbaUlQVMtfa8aZI9UUxJVlwOOkzTJftwGPSM0YCOwfkfCg9poGK4yigpaBBxSh7znDzI7lKyAEMz9auTJF5FKJrxbUWG0Po3CgLJCynBQ2BEvWwYMSCDqCfiUZAhqLeo0Bifk0MgYzdmrJwUrLcl9ZMCQNsoy+5Qw9w+McEh50CAkPEgRBEE4pL+HB7ftScZ5H4cFTv6u49ur/xv31jdLSCYIgCIKIe+iWFkEQBEHEKCqDfovdSxkVAQp4CIIgCCJGKYUifJFxKGVUBOiWFkEQBEEQcQ/N8LikZX+fACBL8GVEmYWmrhnsEyYUihIaUrythAk1m1kY68q/B0QLmQJ8OzZgv/z5PL1cKMGCXJkvzfD94fc1innVnTNdFyVkCnD4kVGcb90FUwOihmCciJitaOG//u63+XLEvrnjGd3W6N/ZAKDr+HzVYxLne+1H432ihfAJG269JUe3tVk1RvcDwAkaAgFRQwBBYmzdNg7Vs7MSFBYk5Pa3TwfpvkaxQyAgeKj5vtlqHmfvt7W/36YGicsZxRCBYEHEJ7bfr//96rWLOJsmlqjxQvO39L+H7byHW9cspDhy193cd6NgnswGAKN33cV9n9bsHce+RnspU7h2GdusMoXrD+DrrxGjkJ+2nbTMotktFnLrGkX+Xmu5gLNp+0fzNQtWavtXZQl4u81sznbn5ic436U3vMLZb9s4xGeHguU3vcDZOq8fxulKrbt5Bme/cY1PfI8xBZ92nsrZrl/xtN/mK3tbtymcvdl/Juhp4+ZzqOHSZ3UbA7DfcP41eGcyl5b+/d3jOF9OPBDAob4G8cA3pupZVowBhx82iQfOfZ7L1Dr0eEAINfPlGVwWllFAFQDqz8gzZEwp+G50YJxrkJvPZUwdGM+PkVdl53PZVl//PWBvNDafy9LaM433bTo84LtrJm9rPiggLGglLnjdw4E2b13Aj71lCc3wOIcCHpfoAoDW2dT2OjtwkJYuqtuv0RNkZxLhQK1ckXaQX8NHC0yC22zoTZCID6SihXpaq4WGj0/fx6fRY5WeqjKfdk+pRTq8MaVdlALOWLDYIcCntIt0T0Qp7+cMaedW977P+VOOE6w0evxiiCLOSUTvNLHEUP189cqE9vztFeTUSlPLJeXa2Y1tthpwSwWaM0ZfYeo5E2v4nDMslwkAWmFMCxelpduJA1rp3WjLRb5aoCPyVSXCg5yODjPb5Fo6MvFAqAGlZOtGG9PSg8sFAgGNVb26LcS0dKleDuPtMl8rG9eGUHzLEJkgZShlVAQo4HGL/wKuaNo1JqRBi3ayQ3Bu2ARLUKyFCX3LJEGPqkBJYNaCzNx3i0HTHxD5xAeZyaYEZn8sOqwFNZYaPkyBwhT/qymCW636NYUUBUEDI2O+WQNF8ak4B/lKdHi0QUKq4SOw6wGNYGQ75w9qRCJwmkiiVdlnBRdpn2+C8OFCmZ/PLruIaxdLa7s8AAjUaxW0yHV45G2WBTVnuaDFQtNGKgCoSFWa7YIWPeCxKFumeKwJA8r0ckS+Rp0dq8BEpJTMlWeYqdHbpAdhEGjtGE5qi2BJm+GxPI3UgN0MF8xY+Brt0qDFgrAoLYdoC6qXiEoo4PFAIKixGinEQYuCwKBlFxCJ6tSCnqA6VYBZKCnr5arWQYvdayk0uxa2mFoFTbTQelv41VoVFjw5xBRAYWD+wCfI1e9rFRCVMp/goW8gD65We+WFlRCcfnERzeJIghpt9kd4UfQrPItsGtZluwuGztkIANrNHMmQ2Z0GLZY2W9FCsaqx3YzWOdm2spkdkgUt55jYZvS1mok5xxL05WKRP3GQps/GWKCqWjBkPVvCBAGRFrSIytVVkq0CF2OwI5oREdkNwY71bIkh2BEFLbCwGe0Wvl6Vlh3N4pRzwEO3tJxDwoMOIeFBgiAIwinlJTy4dk9GWIQHb258NO6vbzTDQxAEQRAxiuzZr1DKqAhQWjpBEARBEHEPzfAQBEEQRIxCz/A4hwIegiAIgohRSlkCSm2SB+zLCFNjohwKeFzS+v6AyB9TgK1v8EJTLR/JA1MUsAQLUcIn8wOaNIqFMOGIgH3P87zt6qfz9fRvpvCiWlc9GxA0BID9E3jfBrl8vUYxr/oz8jjbwSwL0ULdznDoiYCImC5aCJ/voQEm0cLXp/H2fk8FbAufC2RfKUDBfWM53/pLcgBDhtZ3vcfrtive/bvPzULQEACufj9bzwrbe3s2Z2v2nwl+X9/3nbf9nbNft/xp3W4UOwR8godAIJPKLBJ308e+/ieAYX3H6Zytw9oRnK9ZELHz+mG6bWW7mZyt28ah3HejsJ0meKeVbRZS7PHJYO670X77pic5279vfJn7LrPb+crq7fHJYO7Zgw9vepFbV9bfrhuyAASynVa3z+fW7bhuuG43C/y1/3gklwm1sePznP2G1U/pvlu6PMfZjAKAAPBFN/7YuPaj8XqbzMdU02XPcM9bmI/Jq97zCQYy8OKAgE+805hpZTwPAKDeWzl6dtDBPrzwZ91/an3wZT5x59/r07iU9MP9TeKBc6YHso6YWDwQAAoG8+KB9fLzuGyp70cGxpTLp+ZzmVZGAVXAJ7Cq2RQGfDMxYG/4TD6XLbVvCu/b6Kl8Lhtr9/SAvekwXrRw14u8b/Mn/HY1eNxu2T+PK9csLtj6vhm6fctb/LYgooOIPsOzceNG9OjRA+np6VAUBe+//75w3YEDB0JRFMycOZNbXlxcjMGDB+Oiiy5CjRo10LNnT/zwww/cOidOnEDfvn2RnJyM5ORk9O3bF7/99pu3xjMm113QruESPQc3qZFS0S2blEk7fQrblEu/XVHNAmQAVAVWImEAwFS/noeVnSlgqmIpigb4LixMVcDUBAsNEZ8PU60f2mNM8en4WJSr+ssT2UtZAlQowpR240dkt0qNLvWnJot8VabgnJqgpzcb0ZZbCY2d87dXhWJZ7zkW8Avy9ZdrV6+V3c5XZb72aJ9Q2mzcFqJ6tXXMaNtXlB6uSvaBzFfTfvIdG1a+/tRy8zmilyu2M2jp5xZp6WogLZ1ZtFk7h5hFufovFYtzmxm0coLOa61R/gBApN1lOSZAPlbpY5Eq0a2xS0sXjFWycc5OtND1+GnqU3niO4cSPH4qxi2tiAY8f/zxB5o1a4aXX35Zut7777+Pzz//HOnp6UG2rKwsLF26FEuWLMGmTZtw6tQpdO/eHaWlpfo6ffr0wc6dO7FixQqsWLECO3fuRN++fT213XdwM6nIlMKYrU6E5UnnXydkjQkVgOofRKxOOkm9tgOBqogHGeNyy0HTH5j4g5MgX/+AbDVY60GNha+qagGLta928VAFF2LtomZlL1UlF0T/L+1SQaBVqgYuqFb1igIAzVdUr/ECb77Iy4IDu3qNy0XBkhdfJ4GWSO1a1F/jdhIFNXbbWLaPfPvfYt8aAlZxkG3dJu1YFdmNAbxVuUxN8Ac2QWbdT6TDo5+bQVo6Cn9ui3wFAZFIDdnoa6mmbBzHLMYqPRByEbRIAyK7H3YOyxXarQLDMkZ7hsfrpyIQ0Vta3bp1Q7du3aTr/Pjjj3jyySexcuVK3HbbbZytqKgI8+fPx8KFC9GpUycAwKJFi5CRkYE1a9aga9eu+Prrr7FixQp89tlnaNWqFQBg3rx5aNOmDfbv348rr7zSst7i4mIUFxfr30+ePMmvwPwCgj49viBkooRGFWbLc4P5bqWIBjaIfJmkTM3XX3bQ8a0JhCnMUuldC0wUWNi1AU9hlmqJ2oCn3Q7jUJWAn5VaIoNfnBDBSsxMk8y3sMF/AbDyQ0D92afUbFGtP6ixLJcFBgir/asyiwuLH+MFVip4KKrXRvBOhMyu2WSq0yJkr1lwWq8I47Yy/wKVKRYDsHlNg9xX28ZWwYMxCLK2G5SLLeplhr8t7YKTVw+CmNhX//FgRhclhCR4EGwPv6/lbImhTZZjoBbIWAREToIW7X+p0rJg7NXXsSjXNmixKddWeJCIWqJGeFBRFCxduhS9evXSl6mqik6dOuH222/H0KFDUbduXWRlZSErKwsAsHbtWnTs2BG//vorLrzwQt2vWbNm6NWrF5599ln84x//wPDhw4NuYV1wwQXIz8/HQw89ZNme7OxsPPvss0HL412YiSAIgvBOeQkPLt3VADVqypXH7fjj91L8rdm3cX99i2odnqlTp6JSpUoYMmSIpb2wsBBVqlThgh0ASE1NRWFhob5O7dq1g3xr166tr2PF2LFjUVRUpH+OHj3qoScEQRAEEX605+C8fioCUZultW3bNrzwwgvYvn07FMsXQ4nxvSE74GPlb17HTFJSEpKSkkKqlyAIgiCI6CRqZ3g++eQTHD9+HJdeeikqVaqESpUq4fDhwxgxYgTq1q0LAEhLS0NJSQlOnDjB+R4/fhypqan6Ov/973+Dyv/555/1dQiCIAgiFlGRgFKPHzV6Q4GwErW97Nu3L7766ivs3LlT/6Snp2PUqFFYuXIlAKBFixaoXLkyVq9erfsdO3YMe/bsQdu2bQEAbdq0QVFREbZu3aqv8/nnn6OoqEhfhyAIgiBiEU140OunIhDRW1qnTp3Cd999p38vKCjAzp07kZKSgksvvRS1atXi1q9cuTLS0tL0zKrk5GT0798fI0aMQK1atZCSkoKRI0eiSZMmetZWw4YNccstt2DAgAGYM2cOAODRRx9F9+7dhRlaTrjh/6YDiqIL9W1+mxeaatU3IOQXJErYX7P5so+2zTWJXw0KCAjufIm3NR2Wr+mHAQqwe0bA3ni0QXhQAfbm8r4NJ+TrbYICfJMdsOtCX/DZD4znfRs8lx9I5FCsRQs134PDLEQLEfAteDKwreq+Oj2QSqEAhx4byfnWnfe8oV7GCaPJBA0Bv+Ca3/dQ3zGcrd7iHN0PAA7ey4u11X97iqXYIeATgTP6HrhzAmfXBOQAazFEDUUJFp9r8sFE/e/dPfmH5psue4bLGtvVPSBsd82HfBvMonfXfsT3Yfutkx3ZytLXrs2aOKSGsb9Nl/m2q5axZN5Wjf6d7bcD+3plc7aGS5/lfM376Mr3Juk2875t8M5kvVwg+NiovyRHt5uPqcw3c31/+H0L7udFNuv+c6puDzqWNYFAvz1IIHCuXzyRKTg00HQOvTpdtymMP/+0c1PLpDw4lD936+flcRlTZvHAgG+weOAVk3lxwf3PBOxXZedzGU9GAVXAJ7BqzLbaOzVgbzIyn8vC+iqP9202hG/XzpcD9msfN/iy4LH3uofzdJtMWBAIFhe88c7puu8nS/l9UJaoYZihUStI2llEA54vv/wSHTp00L8PH+47wPr164cFCxY4KiM/Px+VKlVC7969cfr0aXTs2BELFixAYmLgqfU333wTQ4YMQZcuXQAAPXv2tNX+scOXWs78idoiu2WSKJeyzqzWkKSX675Waes2aelcm4JSTAOBkDRd00pyQxsEFEF//annlin8xpR2Kwz1mlNnmQpA8aeVW7prjbVOWZduLIEAHKCltIt9tZRn63T4BN1mKXiopQELU+XFbZJhpSnjpE7AWVq6m3o1IT1h2ZK0dWPKurWwpPs2Mz2N2+rZP8NySy0dWcFGX2u76JhixhRvyxWsTsyAzRh4GOE0ciRtshPpE9oh8LdJDw+ktEvS0kVthqRsu9Ryh2nncp2zihE8xCIRDXjat2+PULLiDx06FLSsatWqeOmll/DSSy8FO/hJSUnBokWL3DRRjB5c+IKeYLs4GLJDFiwZgxrzBcqRvo///2AtHYOfRcWKCj1+MJv1gEbUIX+hms6PdbmCAdsYmFjo8AD+wMFqY6nacqsLUyA6s9bw0Rpo0R2DXopI/8cX0FjUayjDCm25LBjy1Wu22WjpSIIHWZ0+X1lQYhM8SIM0g86OlVCfpF2O6pXYfH9Y22VlM4nOjl3ZAUFBUWQp2Q+SoEVfZnPxt0SgwGwsVyguaAwoRG0S1K8FDFIBQJHdMI7JAjE7lWbFYkNLgzDNFgFxQRmlEn2uUMqoCERtllasY5wBCsIYtFiOjPKgBRDYuXIFvn5jkN1QrnQAsrJrAQ2Ypa9x9sg6gjDM4kjabF6BEzQUXCTEs0eB2R+h6q2gXGaYEbGdBRD4ak0wI51NURP0AMs8VmvfRQOXVGgvBAHA8PrKB1lp4KEFQyJfmSghJx4oLttyBsdwERUeN0IMQYNlvdbLAcPFWygQqBVifX7pZQj8hGJ7BnFBmTq7sM2wXkdmM9uD6hUs1+GCGus2O1HBt7Sp4rq12R1hu8oI7cFjb2VEUQRXhkSN8GC0U9YiUgRBEET8UF7Cgwt2NEN1j8KDf/5eigeb74r76xvN8BAEQRBEjKKyBKges6zUCjLvQQEPQRAEQcQodEvLORUj+Z4gCIIgiAoNBTwEQRAEEaOoCGRquf3I1BSs2LhxI3r06IH09HQoioL333+fszPGkJ2djfT0dFSrVg3t27fH3r17w9Vl19AtLZe06/G8nnnEFOCT90dxdqMw4eb/xwtUtb5vBoyihZ//kxe4uu7hPN325Wu87drH8vU6AWDHq8N02zWDeeHBXTOHcb5NhufrNqYAe54P2BuNyff94bfty+F9OdFCAN88G7BfOSmfyzjaP4H3vSKHFy38dkzAfvm0fD3lgSm8sBkA1MvP0/0A4GBWwF7vxRlcUkrBYH47131lhl72oSdMYmyzjYKHDIce5fefUfDw8CO87bJ/TPO5+e2HHjKJwL0xVf/bUgzRwKEHeEHEuguf0zOxzMJ0unCdn4L7AnZdSNHPwT686F29t0x2gyieZtP68/09JhHGJbyv0S6zOa1Xm00PavNiTcTP1zBjfzPfzOUyaYJE/BY+p5cdtI3/Gdg/YBb7aIEmAKgE7dvL/jGNqzdIAHCeJgCI4GNq9nTdBgCHHjcdk6/M0DN8jOKAgE8gMJC5FCwQWC8/T7d/P5y3Xf58HoxaO989FTj/GuT6znstM+nAOP7c1QVJ/WVz4oETeV+heKDff+9zAXvjUbyvUUAV8AmsGrOldr1gGOee5G3GMRAAWjyaz2VifTk/sD2ueyiPy+Ayj71t+szQs7HMYrI3/N90ztcsLtiux/OA6qtzw0f8cVGWhEd4MDT/P/74A82aNcNDDz2EO++8M8g+bdo05OXlYcGCBbjiiiswefJkdO7cGfv370fNmjU9tdULFPC4RWVQEhRxCjgATYtHZrO8c2pIL7eyQVSnzM/vwwT+euq4oGxd48eiw9ogEEg9t2iX3y+obVqqrWKdoq/p9FhrB1lr+/DtUqwzebUBU4EwlVeYKq/pDsnsegOC2xxooHW77FLaRdo/wjKNdit/Pc1a5Gu93M5mLNtXPt84eQq33M7ZLFOIJWVLUqlt22XcjpZp3u7rtRSz022BgEXqK9oW2nkvSi0X+lqsZ+FrJ0zoKi3dxiZPS2f2vpL+WsH7WqzoD3bKOy09nJw8eZL7LnqJdrdu3dCtWzfLMhhjmDlzJsaNG4c77rgDAPDGG28gNTUVixcvxsCBA8PfcIfQLa0yQnbQG222wlkCm1DbwuZk1nV0zHYmH2Q0u2XZBm0Kq0FbF+qysCuqoUyriwXjy7eqF6ph6snsK2iTz8dQhqVdsWyTr59iO1N946HlhVOrV6s7yNkwRSfoD1OVoLI1gT8rm9EXFu3SfES+etkWIoK2vkabxTFnW6/IzpTAR7KtLLexGvCVbivhvodYfM5hvYpVvYY6LMvVzgOByq/wYms8Ny32gcyXO+cFY4Y0eBCVbbRZuBr9ZCrN1kFNINgJVeEZkO/baFRSDue7tDIyMpCcnKx/cnNzbWoPpqCgAIWFhfqbDQBf4NSuXTts3rw5bP12A83wuIWBm+WxsvsmJiysRptAz19h1uccN4sTNOMRsElnaZTgc5ZTd5YNXorF7JCoraZ1rGZpZDNHup/WJEGbpXXCOhayFy2EeEP6Z3jEvzAVQ6dMJhZokOWuF108tHL1DkhsFgVIZ0scvmrBla/klQd2Mzy2szRWf2vYvNJCeuAYVY1l5cqOGwukqsQIHJPWbZL7y3w5VWNZuYJ6RcGDk9khYZu1Mu18hX2V1xu0nsnXLtgR/ti0+Du4zeUbEKlQoIrvMzguAwCOHj3K6fBYze7YUVhYCABITU3llqempuLw4cMeWukdEh50CAkPEgRBEE4pL+HB/C/botp53uYuTp86h2EtN7tqq6IoWLp0KXr16gUA2Lx5M2644Qb89NNPqFOnjr7egAEDcPToUaxYscJTW71At7QIgiAIgggLaWlpAAIzPRrHjx8PmvUpbyjgIQiCIIgYRRMe9PoJF5mZmUhLS8Pq1av1ZSUlJdiwYQPatm0btnrcQM/wEARBEESMojJF+rJcp2WEwqlTp/Ddd9/p3wsKCrBz506kpKTg0ksvRVZWFnJyctCgQQM0aNAAOTk5qF69Ovr06eOpnV6hgMclHbpONWjLKFi/nNdduKnn87DT6AFgq9Pz+UJeJ+L6B/O4xJQv/hGwtxiQr9cJANvnDON8mw/K1+uEAux8KWBvNpT3/Sqf920y0uCL0DR8rh6fz7X560kB+1XZ+fpypvA6H4BPB8So4WPUCdE0RDR/o74PwGv8fDeK3471Z/D6PmbtknozA/YgzRMb/Z/Ml2cEbCY9lbqvTue+B+kDzQroAx16zGSbY/IdGLDXnfs8b7PQFeLsA0Y5spW5r+EJwqA2a33yb2yuv3Om877mbTUrsK2C9G5enc494HtokMX+85cdtG+NejgADg7h7fpxw4CDw0zHXF4e97CtWXPq8mn5+t/fjeaP5QbP5XMP4x54mrdfMTmgeWPWwbpyEq+H8012wN7wmXx9ucKAfZNN565MS2c036bd03nfpsP5so26YM2G8OXufJn3vfbxfO6BaeNY1vKRPK5e4xgIANf347V2PlsUsBt1dsCCx94b75yu+5l1dm7q+byvXIHWToeuU/2+DGtX89pP8caXX36JDh066N+H+8fPfv36YcGCBRg9ejROnz6NJ554AidOnECrVq2watWqiGrwABTwuIdBKOFiXseML7uIAYp1Nohmt9Tw0eoFggpXmNBL99Xcgqo1Zk1Y4dfDEaaQGtouarNVlhbnK6iay9QyLpdp9GgOTNBoY5aHnT3IJtf/kWUAaenIwuNGlkFkTEc2+xuzh0SZZSLs0hbssnjsfEWdtcvSkurhuK9XcZJpJcCJrzjDy1+GyC7IhvLVK2+bVAZDqtHjJPtLYLfxldntNHy080BoM7fNomzhWCRKOze32apcf7Aj9mX2x2aYUcNwSypU4cH27dtDlu+kKAqys7ORnZ3tqV3hhgIelxiDC6vUc0V0EQYMQQuzzk022q3KhThoUfyhknWb9dVCTi1XIM621AIPob8kqOHS1WUXH8ViINIGPCuboV2Wg6KqQBhJGX2t0MuVb2dLZIO8v13SYMjqbzubaJmGp8DDg68suIPBJuuPk6BG5CvALj1cHhC5LBcQXsD1emFvtw0QZHWGGHjY+ZZpsGReR+jLr2AMdqSp5yJhQfN6nK/NgVVGhOdt6RXjcV4KeMKA5Ukn0ejhgxaLoEYFWIJ4NkW7houCFgUMTBBIAZAES/KgRdFmUyT9sUKkwQNAV3gW+kpmcSTxCtcuS7SLj91Mi1WbJf0B4NfpEbcJsAmGJcGQvpp0hsdqsBbU569TipOgxM5ueY7Y+MrE+Ww1fMQmaUBqW69NHdLAQ7Gxy2d/pLM4doGHqAxDUBLyzJIWDIkaJSnbboaHt1uswPh1gn2ZddkseJ3gsmUaWza+auQCH8IeCnjcogJKgn82RXRLxB/0CJEMFlrQI/OTBS2WoZZhkThYErTHEDwExVJaP0RBgCHQsvyl58DXqs2y2R29bFnQIqlXnwGyu6gJb6WJbApfv0W7nMzwWF5ATHVY1WtJxGZ4JAJ/sJ8BkCGfZVPkZdgEJTJfJwKAQl+Jnd+/IbaLibelXZtsAzQbX5nwoP0MD7O2S4Idn90Q7EgCIus+OQh2REQo2CmFglKPwoNe/WMFEh50CAkPEgRBEE4pL+HBZz/vhKoehQfPnDqHia3WxP31rWLcuCMIgiAIokJDt7QIgiAIIkYphfdbUqXhaUrUQwEPQRAEQcQolKXlHAp4XNKxfY7v6V1/YP3x2rGc3ShMuH7FU5ytXY/nOTG9jf/mBdduvMMnPscU4NN/8eJXbe+eEXiYWQG2LA4IZ7W+PyBKyBRg6xu8INd1D+XpNgD4cr5BtPDRfADQ/bfPHsb5Nn8iX+8rU3ihsGZDAjYovMAY4BMg0x8UU4DdMwL2xqPy9eUAsGca79toDF+vUdTw6nG87eu/875XTczX//7mWZPt2Xzu2VIrwUOt3APjedsVU/g2m0XgGuQG2hUkhjg10CYowQJzlz+fp/8dJJY4PY/7bhSu04UUNdsIC9E7o90gtCizlYsvE7TZ2Cdm6q9hWygseFtd/nyefqAHbWPjPgDw3VMW+8/Pt2NN+z4nn3sQ1iiECQSOG8BaAFBrLwB8M9H58dpwAi/Ut28KbzcKBO7NNZ1DT/G+RtHQJiPy9eUAsDuP922Wxdt3vRCwXzM4n3uoeccrvK8uHuj3N4oHthiQzz2UbByLAJ/AqmZTGPD5PwP21vfncQ8mG8dAAGjb2yAOyRg3ht54x3TuoWXz2Nvutml6vTJhQajA2o95ccGO7XP0stdsHIfyopQloNRjwOLVP1aggMclunigJEtLgSBhQ0tZl+WBM+tiwQwZXIIMBFGCkF25gDg1ncvSktiEdWqBiSC7SOhvzEwKxQbItXS0jAubmWDbTB1J2rpteVbraFlNoswxQaO0bBtxqrxguagdTu1efG3S0r1o2khTy51kWgnLdbieLNPKrl5hZpHELsvwkgkeGs57S2wzqeR2cVo6E9q4dlmdS06ysPzrWafDSzKx/HWLZQPEjrZyB0TEoYDHK0xy1ZQFF8agx4QsCNADGquLgTYQWCel8+UqZhvz2wRKzYa+BJUtsxnaDFiktGsKzpLgQS/TcvCCMHC01eHR/rcMLsTXU8cpwla+NoGJo1RsSdq5LN3drk12dpFsgNuybS8QHlLpXV3QDHbuf6fl2pUtCYSN9Vnretm0QeIrDaQgtjkq1yZocZuW7lhXSDYOCoIl+3R4i+UwBDuy9HPGbM+ncMOgQPX4DI9IrDbeoIDHLcwXGogvXH7xP9lAItLpYQyi1074yhYFLdrFX/xaCs3NKmjx2QRKzQYHqxkeLfAQBkv+wMJcr7+5Ygy+ojZJZ7MkAY00SnNQr1Bc0CZAACSDqtNAKwQ/APJXT9i9OFASTNkLALoPWhxdxA3rmX1l29iu3lBnb7h2OanXJoCwtEnqdhYoi222gXKoAQ34/pgDBNtgyVy+lc12BlCwXFK2cXbIEptgJxLQLS3nUMDjkcCtLROaMKGF4nEgMAEnVx5UpqVasv/Xi9UsDjNew63L9a9mHbToNlGbBBgDD9mAC4tBxtBNq/FCesvLONjKAhPJYGwr8mczaMqu59YBgk184fBCbfVOMmlAJAkQpOVarO/YBgcXJbe+Hm6HOb7Iu6jXya1DVzNANgGP7cwSrE8Ru0DK6QyPOCASnMDGcm2DKRZsk7wPK6SZJytEt7xUSX+0ulWL9hJRAwkPOoSEBwmCIAinlJfw4IhPuyPpvMqeyio+dRYzbvhP3F/faIaHIAiCIGKU0jC8Ld2rf6xQMXpJEARBEESFhmZ4CIIgCCJGUZkC1S7xwEEZFQEKeFzSue1k3x8KAEXB6k280JQuTAjg43W8KOHNnZ/zPczsP8bWrTQJE946zWdLULBhGS+MddPtftFCf9mfLDWIat05nbN9+g4vyNXm3hl6nUwBPnszYG/VNy/QH/BCX4BftNBg/+IfAXvLR/ICD2crwLa5JgGyx/I53+2zAvbmg/L19gC8oCEgFzVsOowv9yuTaJouqqYAu6fztsaj8rmnOC0FD/3sfS5Y5M2IUQwRAK4eH7Dvm8zbGk7g2/z1JN4uFUvM5uv9Jjtgv+pZk80savcsv52NQouaIJ5GkAijxB4OX+0BUVGbNYx22bYAbET8nvHb/PWaBStl++/qcfncA6vmfS87bjgBQAQfc01GBtplFOcEgCbD87mHjs3HerOsQLuM4oCAXyDQXy7An2PNn+D3gfHcBIBrB/KihdvmBewtH8njHg42jgmAXzzQYA8SDwT0B3yNYxHgE1jV6lQYP5bdeOd0rj+b3uPFWW+6/XmuXuMY2u7WadzD0GZR2Js7P6c/eC4UFvT7msUFO7ed7NcXYlj12TMoL1QkQPV4s8arf6xAAY9L9LRzwPKpfGmmleYvEi0EhBlcdmULs8aAgGAh5FlaojqFdhbI7LJLaRfZRJtBlh1m12Yn6cO2WVpWvjJBQ0DXFhLWKylfzwIKURuIyw4KMR3erj+Os7/s7KZ1naSH22YtCdrgOD1cVrZoWznxtalXpqVjWa9hudDXbaaVoE7drvtbZEvJ/GV2o1ZOiG0OKlvmaxpDjQGLTO/IKvWc87U4DmSihER0QAGPB+yCFlnKOhIM/hZ+gCQVWxGUbQgehCJxmkaMOaA3pLtbIglMjEGJKKXdUIRjm95mUxuctIlbLrm4CH1tVJqFqfCwCaacBgh2FxBT2U50aYTILpaAPNU6DGnaItzorDjxtavXycVUVI5baQC9XpGvjYaPVM7A5pgS2vRyrU9Su/RvR3ZB3VI9HCa36zbBD0Y7pWVp4GInLOh/7UR5UsoUlHq8JeXVP1aggMctfnFA399iu/WJzsBURQ96QvM1BhcWNr++j21gogbbfF0x9MvSboGhPmGQZtFeWxvgLHgQBB/SGRE7X0m9tjo8skHe7hUQbi+YToMHWX+c1FsWvk6CC7Ovh5kW29khr1o6IrtNf4U6VublNsGFmzaJgyUmXofZ7EOnwZBoewtmgXy+1jYdLdgJarNcaVmqs2Mcq0XjdgSgZ3icE9Ebdxs3bkSPHj2Qnp4ORVHw/vvv67azZ8/iqaeeQpMmTVCjRg2kp6fjgQcewE8//cSVUVxcjMGDB+Oiiy5CjRo10LNnT/zwww/cOidOnEDfvn2RnJyM5ORk9O3bF7/99pv3DjBm+2tAhCL5JWA8oYNQJSes/2QWi3nJfG3qdjJ4MZGdBQZOq3qNH6t6/eVaDXzy/lr7Ab6Li/6R1WspXe/cLitXeLEV+Rpt5m2hBsoU7SOFBdYTtlfSZi/7L6JtlpTryleyj5yUqx13Qb6SbcEdc4LjRrodBW3mzh+7c8jCV37eG8YTgXigeFtJxjInwY6gXcbxT6yYjOD2av52woIyJeYygvnflu7lwyqI0nJEhQeXL1+OTz/9FNdeey3uvPNOLF26FL169QIAFBUV4f/+7/8wYMAANGvWDCdOnEBWVhbOnTuHL7/8Ui/j8ccfx7Jly7BgwQLUqlULI0aMwK+//opt27YhMTERANCtWzf88MMPmDt3LgDg0UcfRd26dbFs2TLHbSXhQYIgCMIp5SU8+OiGu1DFo/BgyamzmNvunbi/vkX0lla3bt3QrVs3S1tycjJWr17NLXvppZdw/fXX48iRI7j00ktRVFSE+fPnY+HChejUqRMAYNGiRcjIyMCaNWvQtWtXfP3111ixYgU+++wztGrVCgAwb948tGnTBvv378eVV15pWX9xcTGKi4v17ydPngxHlwmCIAgibJRCQanHl3969Y8VYmoeq6ioCIqi4IILLgAAbNu2DWfPnkWXLl30ddLT09G4cWNs3rwZALBlyxYkJyfrwQ4AtG7dGsnJyfo6VuTm5uq3wJKTk5GRkVE2nSIIgiAIl6gs8ByP+0+ke1E+xEzAc+bMGYwZMwZ9+vTRp9wKCwtRpUoVXHjhhdy6qampKCws1NepXbt2UHm1a9fW17Fi7NixKCoq0j9Hjx4NY28IgiAIgihPYiJL6+zZs7jnnnugqipeffVV2/UZY1AMmUaKRdaReR0zSUlJSEpKEtq7tszWs5mYomDVVl5oqkubv+vigqs/Hc/ZOt00BVAUPVPn4/VPc/abOz7n+yMBWLuaF7/q0HUqJy64fvlo3dbutmlAgtYmYOMHvGjhX3s97/vDX7dRsEsXLfTbzaKFmhCY9mzblrcC9tb3zdD9AOCzRbwAWasH8gxlA1sXBOwyQUPAL24G6JpHRuGzFo/mc+Vun20STXs83+8L7HiVt9kJHl4zOFD2rhdNIm9D87k2G8UQAYMgIoCv8k224f56/d93i8QSYSE+NzKf+24UU9RsWpv3PM/7Nh7F+xrtdiKMjUebfA12mc3WV9Ims11h1v3VMAtLSrfjcEO5CBbxazo8X99B5v3XLMtQLwsW+Ws2JGA3HzfXDM7nHsA1H3OaCCAQfLzq4p3+erfP4e0tHg2UbTxHAKBl/zz9b4Xx59h1D+VxD/Yaz03Ad+4aExaM53br+2ZwDwEbxwQAaNt7hu4HhCYe+Ndez3NlG8eydrdN43w3fDSa8+3QdSpnX7cqIC54c8fnuMwzsyhsp5um+NqsIkhM1igsCCBIXLBry2zdtnLbsygvtAePvZZREYj6gOfs2bPo3bs3CgoKsHbtWu6BqrS0NJSUlODEiRPcLM/x48fRtm1bfZ3//ve/QeX+/PPPSE1Ndd8w7VlvRbHJ1BL7izRvdFFDSRaXpb4Pg56OqSQIRAkVQd0MhtRyQdmKdVaSsVxLuLKDfa2Wc/UClvo+xnKlabHScsX1KkywgmEgDjnN21ivxNeyCElquX16sbhJdpo2rm2QpBzbtEm3C88fmzbI+muzjmMNH0FmkrBem1R6J8eNcD1J1pFMzsDJvhdp3tjKCkDsa/QLWcPH5ljX1rEWD2SG81ewvYTjbiDY8aRNFWZUKFA9PoPj1T9WiOqwTgt2vv32W6xZswa1atXi7C1atEDlypW5h5uPHTuGPXv26AFPmzZtUFRUhK1bt+rrfP755ygqKtLX8YTwIi9OWddPKFmAIEuZhP0gYXlTlplSRd2ULRxs5WmxwvRVxvtb+Yrq5lLdRRc9gc0uNVmW7m7sq+XgaJe2LPMVbSeAS6MXbUc36eF2vnr6uEV6uMzmtV5ZGj533Fi4CreT39dpCrjIJpIVcL0PbHztJBiEsg+mckVaOvJz13ChtyhXtO+NvrJ6Qx2LuOVCYUL/cis5A5EfbMZmu2AnAqKDRGhEdIbn1KlT+O677/TvBQUF2LlzJ1JSUpCeno7/+7//w/bt2/Gf//wHpaWl+jM3KSkpqFKlCpKTk9G/f3+MGDECtWrVQkpKCkaOHIkmTZroWVsNGzbELbfcggEDBmDOnDkAfGnp3bt3F2ZoOUIFkMAARZEHPQJ3/TUP0lmRYJtRndlOXFBUrqbUbPbTzNZ+gVkh8zrGV1ZYzz5IfG3rFRcr2kbmsu1mAKQzQDa+wnoZvCktS9pk6Scvlis3qBibNnmZ4XHqKwpaRNjODslmlry8HkIUVBjtgjJkMy129fIzPKKLvE2bLOqwnaWRaN4EggOxr7RNsrK1ZRY/3KTBDiTBjqFdonp1u8gmefVEUP3lBCktOyeiAc+XX36JDh066N+HD/fdH+7Xrx+ys7PxwQcfAACuueYazm/dunVo3749ACA/Px+VKlVC7969cfr0aXTs2BELFizQNXgA4M0338SQIUP0bK6ePXvi5ZdfDk8njIrLRvyvjxD+UlAUPlCwKlM4WPhveQX9avKXK7jYSoMLm1dLGG+jWd4OE72ywoGvb7k1sjY7Cu7c2CAZDAH7d2lJ+iRVf7Zpl12bnJZrXs02WHJps/X1ECx58fUadDq6ZWkX0Mgu8pY2+S8Dp7f/Qr095ORHgztfm6ADkKol2/uKAkODr8juNtiJ0OwOPcPjnIgKD8YSJDxIEARBOKW8hAfv+fh+VDmviqeySk6VYEnHRXF/fYv6h5YJgiAIgrBGRRjepVVBHlqmgIcgCIIgYhQWhiwt8dOm8QUFPARBEAQRo9Db0p1DAY9Lbmk6PvCwsqJgxc5JnL1ri4m6feWX2ZytS+tJuh8ArNoygbN3vtEnfsUSgDUbefGrju1zOF+jcNbNHZ/jhAbMooXtb5nK+QaJFmokKNiwjBctvOl2n2ihdl588n7A/te/TecEADe9y4uI3fB/0xEQaQQ2/7+AAJlM0BAA2vSZwT2M+9mbAXurvgFBNSjA5//kRdOu7xcQNTQLqumCh357kOChQazty/nOxRABvwicn21zTQJyAwM2S7FETWBOAbbPshZS9NXNi9MZResAsdCibn9lmCNbRH0lfTLaFCbfVkG2x/hyg/aBfx8pLHj/GQX+AAuRP/+xARZ83Fz3cB733XzMXf9gwG4+Xq/vxwsEmo/11vcHfM3Cn236zNDbBPDnmHb+aTbjuQn4z10EHhA2nts33jGdy5gyjgmAf8wwPNhsHFPa3TaN245m8cD2t0zlHnrmxAM7P8c9QPzxWl48sGP7HG5brdkQEHbtfOOUwMPKDFi9mReF7dJ6kl62WUzWKCwIFVi5gxcXvKXZBD0Nf8XuKSCiDwp4vCDK0LKzGzO4rOyGLC4znMifyVdhDEz1LxNkSwGBjCm+Tm0lCDV8NLMVTtLaff6CLC0HAnXmHyHSVGujXZYRY+drhb4tBCs5zS6SZfLYZPmIZAWE9WpZdC5S5csjLd0KaVaabDuFUK+tnpXZZvfSIadZWjbtCqVNPl+J0dhfgS6N65R2m3rFqd8O6tXXMa1kzMCSndsyLR03mVgO093LG8rScg4FPG4xBhxWB7osLd3OzvR/LOGCniCbRKWZAVYaPFqZsloDdVqVq41MilxTA8HBllMdHsAi2DL03zKd3sNFz0nQIt5Wzi4+srJD9nV4MbXbP6G2KSy+boMWJ0Gp9IIo9rUT/hThWIdH5itskztfLsgRBcoO+huc0s6kdXvR0hEGO8ZlDgJAoRimoGzZcgD2qekRCHrolpZzKODximyWRwtqTHBBiSiw9gcnlvVBfoEXzTwYRQuD3A0aPpaoTH9dhWimxXLmyNAuq2pt9X8MA5b5R4gskDLbQ7HZ2o0X0xBnTGxFyTxc1Nzq+8ChrlDINif1uvR19JoG29kFwXkimcVxqv9TNjM8LgNpB0GLpc28PNRXS4h0dEx1WwelhoWSoEU2i+Mp2BH9iJX4OnrtBBFRKODxgi4QaP0rRP4+LLFdKCwI8ArN5kDLKFgouICJyjaKA4oDOP9AYn5Plx5oier0r2YxQySbrTKWDYin44V1e5hpcRp4WK0mFSa0DbTcX9SEARgcBH9ug5oQtmPIt+E81CsPWpjrwDJyMzxi1WJAHgA6DvxFbXYz+2Nnt+kPAHGAYRP88TNa5iBNEtAIfELyj0CwQ+/Scg4JDzqEhAcJgiAIp5SX8OBtKx9B5RrehAfP/lGCD7u+FvfXt4rxpBJBEARBEBUauqVFEARBEDFKvDy0fMcdd4TsM3v2bNSuXdvx+hTwEARBEESMEi8Bz/vvv4/evXujWrVqjtZfvHgxTp06RQFPedCt4VgExPQUrNjLC03d0tQvaKUoWLHr75yta/OJvj/8NxRXbuMFrLpe96wuamcWv+rS5u96nQAvnGUULARCEy3seHOuXiYSgkULO3SZyj0Qu25lQAisfbeAaCFTgkXE2t02DTA86GwUILup5/NcuRv/zYuX/fVv07myN71nED67czq3bpDg4V0z9L8/fYcXVGvb22/z1735bZPg4b0BXysxRK09AC+GCMhF4DixRACfLzTZHwjYhUKKfra+MdzaZiG0aBS1A3i7zKbZjePhF68H7JyAo8kWjnqFvpJtodm1h2LN21HfxprdvA/8+0hhwfuv9f153AOr5n2vi/wB2LLY+pjSHqo1H3P6MQmxAKDGp//ij/Ub7wjYjecI4D+HDG02CgQaxQEBYOMH/PnHCZIy/tzWz3t/2etXPGV09Y0ZfhTGuDHl5o7P6csBWIoH+uy+70HigXqbGFZ/ahIP9I+RWrtWfRYYQ7te9yxnM4vCamOzwliQmKw+pvt9zeKC3Rr6+6AyLN//HIjQefHFFx0HMP/6179CLp8CHi/oqdyC1EgnGVyCp6ikqY/+OplVlhYARbWO1u3Sx7U6mYW/bUq7tp4oXV6QNaPIE2bkZdtmCMmyLeRFSNOebbLSnNRrV3aovo4FDUOsU7MLU5Y9pJaHK1NOaBetwwzrCH3F55/bLC59W8nqleDaLmuzZN9qdmH5jlLa5WONo23hRkBQliJuk6cjz5SUlBsh4mWGZ926dUhJSXG8/vLly3HxxReHVAcFPG5RmW/WQqbDI7HJBQK1EVlermW6pkCFmfdDsGaLVpRiP0iZXzTHp53bp7AGl2vwF9h8RZhTTA02G9/g9viDQ1HY4uDCJRIndVKvsGy3AYKHi2XEhQed2IMutja+TtK0XQQ1din8jgJlu4u0m3olQZqjVHkX2kP2Ke02wYGD/QBYyVGEIdhxo8PjJNixU+IuAxi8p5WXf6uDadeuXUjr33jjjSHXQVlaXlAlJ4f+a0584tgKWNmVa1m2pF6ublGdsD76Vch1MfxlipRtRTaoTP8ItTxEFwptG4guUAzC/nAXPctZOEmb/WUqquACZ1OvvGwmbpN/G1n52pcraZfMFiW+ofdXvB2Nx4xQiVnSJm2/u933ehsEdpmmjbS/sDlerXy1889Qh7lNevmi8UYw1GhjhsKYWEsn1GDHVKflGCobqwxlu3pFhKxc2fWgDNFmeLx+oont27dj9+7d+vd///vf6NWrF55++mmUlJS4LpcCHq/IInrprz1tgJKf8MJyBYKFPl9YD17aIG1zIbCC+7WmWtikFwkmHpCNPgIJetEFiLtAuLiAuA48JG0CQrggSi6K4guxoF3G5TbbItTgIeK+qrf+imxOgpogXxWu95/XAJ3b/7I+iWxA8DlmqFPWZss+Ma18i4DGvDzINzAeWO4j4/a3K9sCod1psCP5senolhfhiYEDB+LAgQMAgIMHD+Kee+5B9erV8c4772D06NE23mJIeNAhJDxIEARBOKW8hAfb/+dxVKqR5Kmsc38UY333WVFzfUtOTsb27dtRv359TJ06FWvXrsXKlSvx6aef4p577sHRo0ddlUvP8BAEQRBEjBIvDy0bYYxBVX1TamvWrEH37t0BABkZGfjf//7nuly6pUUQBEEQRNTQsmVLTJ48GQsXLsSGDRtw2223AQAKCgqQmprqulya4SEIgiCIGCUeZ3hmzpyJ++67D++//z7GjRuHyy+/HIBPe6dt27auy6WAxyXdLh8FPfVbUbD8wFTefuUYXWxv+de5nO2WRn5BQP/8mlnA6pZmE/RyzeJXXZtPDMzLKQonnKWJatmJFmrrcKKFN0wOrKgoWL2JFy3sdNMUGFPdjUJgHdvncDajoCEQEBnTWPuxQYCs83OcntC6VSbxsq5TuZRzo7iZJnym2S0FD/1s+NBk6/E8V65ZcO2m258P2MxiiL0CNigKPllqIfTmb5dZBE4XiPPXbRZLNIopBgkpSsTnbvi/6dw+MAstGkUYzXaZDeAF8QBeFE9ms7Pb1euozf5HEM1CfMZtFSTSZyNYaSviZyBo3xuODaPAH8AfU2AWIn89AnajOCcgFwAEePHP9ctNtlumcg8GG0VDNXFA7UFcs+CoTCCwYwf/uKbZ1j/N+XZql8M9xGsUQuXGG8YLqAJy8cAu10+CMX08SDywxUTuoeSVOwLCrvrY6vdd8ZWhHTCMzUCQmGy3hmO5h77N4oLdGozW27v8u+dRXjCmgHkMWEL1P3fuHLKzs/Hmm2+isLAQderUwYMPPojx48cjIcH7jaOmTZtyWVoazz//PBITE12XSwGPFzS9G9Fz35pWjwiR8KBtuX4/q8wVkRAiDOuLNHwAQKqlE/AX2iww1hUklgibrAcIske0Ov26QtZ2SaEqgyLbNxJfY32WIo5aBoqFNobmKyzeYb1WNpGgpLFNIdsc1OvW1zajxUGbHWnEBPnKq/XSZi/1AhBnfTrxFWZYisvgzj1Z5qeVv8EmTZW30+GxtInbJdXKMa0vzdSSIE07F5WhZ4DFfx7Q1KlTMXv2bLzxxhto1KgRvvzySzz00ENITk7G0KFDw1LHb7/9hn/961/4/vvvMWrUKKSkpGDfvn1ITU0NWXBQgwIer2jBiQjLVGuDSrIsPVIQHAgFCzU/wLpNokDJWK7oAmKojyXwK3EBgNWmMARTQQOJsR+WwZ+xInOb5Rd5PbgQ7R4XYmtcmxRx2rNQhFESDDmuV4DbwMQuaPESLNmK6Ulw1GYXwa6n/tr5e6nXiR6OsF65mnKgHMn5Z+NrhXQfGcsW/cCyapOGE50cOxmNEH3tfnzJ6gQQkWBHheJZeFDzP3nyJLc8KSkJSUnBGWBbtmzB7bffrj9bU7duXbz11lv48ssvPbVD46uvvkLHjh1xwQUX4NChQxgwYABSUlKwdOlSHD58GP/85z9dlUsPLbvFabQvQKojYfMLRurn5NePYCCxbZPoF5tMZ8fYFoagAZSrU/ALUyZDb6t7ImyT6WPGKMgmqFOq4yJok72Qm2A5+L4K9YwkbXIrAFhWOjxhaTPs6w0ul/EfC+RaSOI2S+s1iGxaHlui7WDVbqt2aWUE2Zj03Lazi+q1PZZtbNI6VQfrOBkfQzzH7Mq2HV8jQDiFBzMyMpCcnKx/cnNzLeu88cYb8fHHH+taObt27cKmTZtw6623hqVPw4cPx0MPPYRvv/0WVatW1Zd369YNGzdudF0uzfB4we6WlWj2x7Dc7p1ZouW24leSW0eWM0Sy211W6xnLVeF7zYKbmQAG65kfDW3gS7AauMTVAfIZIPtfzFr9Fiv697urX/osaKLKsl2yW2UyPzd2xzN0VjjdjiG2yc7O2UL8weGoXsn+sy3D5W0pJ7fSXN2+BaQ/cqT+Tn7IQHDbSvpDRR44SIMWm9twsnLD4iscqzR7FL1oK0SOHj3K6fBYze4AwFNPPYWioiJcddVVSExMRGlpKaZMmYJ77703LO344osvMGfOnKDlF198MQoLC12XS8KDDiHhQYIgCMIp5SU8eP3SoWERHtz6txcct3XJkiUYNWoUnn/+eTRq1Ag7d+5EVlYW8vLy0K9fP09tAYDU1FSsWLECzZs3R82aNbFr1y7Uq1cPq1atQv/+/Ul4kCAIgiAqGpFISx81ahTGjBmDe+65BwDQpEkTHD58GLm5uWEJeG6//XZMmjQJ/+///T8AgKIoOHLkCMaMGYM777zTdbn0DA9BEARBxChaWrrXTyj8+eefQenniYmJujqyV6ZPn46ff/4ZtWvXxunTp9GuXTtcfvnlqFmzJqZMmWJfgACa4SEIgiAIwjE9evTAlClTcOmll6JRo0bYsWMH8vLy8PDDD4el/PPPPx+bNm3C2rVrsX37dqiqimuvvRadOnXyVC4FPC7pVneY7w//w8HLC/J4++UB4TCzCFW3KwzieooSLGDVcGyg3H05nO2WRuO4eTmjaCEnqgVgxa6/c9+7Np8Y+JIArNwWEOTq2jKba9PKLwzrwif2ZfTlhMDa8PWs2sK3gxMZA7D6U4Pg4Y2+9jN/n4ziZIBfvMwPU3hxMzvBw443BzIMjIJpgEEM0V+vWXBNE2QDYCmGaMQo5Ab4hN40jEKJus3Q5iCROIOYYpCQ4q3TuO9Ge7tbp3FPQwcJLd5m8jXYZbao9/U/gSjbVjKRPkC8D8CY9f7zo7DgfW88NoJsdiJ/nZ/TH6Q1inMC/LEMBB/PRhFASwFAA0bR0E43+c4/7aFjs+CoTCDQ7rznxgzwQqhdr3uWe/g3SDzQMFYpjHECrLbigU38ffD3ySgg2O3qp7l6zaKw+tjMGJZ/yx8n+pjufzh5+UFehFK/JqgMy4/MRHnBwnBLK9QZnpdeegkTJkzAE088gePHjyM9PR0DBw7EM888Y+8cAjfffDPatm2LpKQkKDL5F4fQLS2vyJ7YF2Zr2KRNasvd6FNIs1MkGQo2Ke2OfS3bZfiI2qZKMj3sMkWEKd7iOrlUeEk6vLVwGaR9kqYm27ZZ3Fe7FPCySksPG6HW66TNAmz3ASDfBw6kAazLFLdNmmINcKnYoZZtfw5aH3PceWd3rIdQrl6+6DwyjjVu0tbtxkfRtuTGMQfjc1DZNplYEdDhYeB3g6tPiHXWrFkTM2fOxOHDh3H69Gl8//33mDx5MqpUqRKWPqmqir///e+4+OKLcd5556GgoAAAMGHCBMyfP991uRTwuMVOh8dqPSNufGBzofY6iDj0FYqXCXylWjo2A6asXY4CC6s6Te2yVlWFo2DINiAK8g0hIBItt9kWoQZLIQVSosBDeCEW28q2zZLjyiaIdr0tEMIxZac5ZVWvqe3O2+zvq9WPCgfnn23QAjhQabbwNY5lofqKbKIyjDj9MWrlB0RVsBOvTJ48GQsWLMC0adO4IKpJkyZ47bXXXJdLAY8XZAe4Ey0G6a8UFyeyVqaD+iyDFlmT7YISyUCuYT1ogh/MzT4q/xG1KfTgwfQRtNXLhSvcs0OexPRkdptgs8yEB+3aYNdmSX9db0fA8XFRnoGyl2NdOHtqVbdFm7nyjTg4553OxITs6/RHXVCbnQVL4nodjuvliKa07PUTTfzzn//E3Llzcd9993HvzmratCm++eYb1+XSMzxekYkPMhVQLGJK7YQQ3ZNkzGezVGP12YSDrZ0AIKztjl5ZIXi/FydoaFefaR27V1pIfW0EDx1fYC0FHjWbVbk2/bUJ+qRI2xxok1XgIcNeaNFDEF0W5ULeZtv+AJJjSu5mu49srnnyHyQSR+lshbxO4yxOKOUa2xPW904ZfUVjldN6Q5xZEvp5tRmDHbs+lyOReHloWfPjjz/qb0g3oqoqzp4967pcEh50CAkPEgRBEE4pL+HBpu+MRGJ1b8KDpX8W46u7pkfN9a1ly5bIysrC/fffzwkPPvvss1izZg0++eQTV+VG9JbWxo0b0aNHD6Snp0NRFLz//vucnTGG7OxspKeno1q1amjfvj327t3LrVNcXIzBgwfjoosuQo0aNdCzZ0/88MMP3DonTpxA37599feD9O3bF7/99lsZ944gCIIgypZwvksrWpg4cSKefPJJTJ06Faqq4r333sOAAQOQk5PjKRMsogHPH3/8gWbNmuHll1+2tE+bNg15eXl4+eWX8cUXXyAtLQ2dO3fG77//rq+TlZWFpUuXYsmSJdi0aRNOnTqF7t27o7S0VF+nT58+2LlzJ1asWIEVK1Zg586d6Nu3b5n3jyAIgiDKEvPjbG4/0USPHj3w9ttv46OPPoKiKHjmmWfw9ddfY9myZejcubPrciP6DE+3bt3QrVs3SxtjDDNnzsS4ceNwxx13AADeeOMNpKamYvHixRg4cCCKioowf/58LFy4UBckWrRoETIyMrBmzRp07doVX3/9NVasWIHPPvsMrVq1AgDMmzcPbdq0wf79+3HllVeWT2cJgiAIgpBy7tw5TJkyBQ8//DA2bNgQ1rKj9qHlgoICFBYWokuXLvqypKQktGvXDps3b8bAgQOxbds2nD17llsnPT0djRs3xubNm9G1a1ds2bIFycnJerADAK1bt0ZycjI2b94sDHiKi4tRXFysfz958iRn73bJkMAXRcHyoy/w9kuzfH8kKFh+KJ+3ZQ43+CYEC1hpAleKEix+JREt7NaQFyMzi2rd0ogXFTMKct3SZBz38G6QmJcm9uVfxygExgkaAli541nue9cWE7myjSJjXa/j1xUKHvrnIjnBw9aTuHKDBA/bBvpgFEwD5GKIQEAQEQgWY9PE2jRkYolGkTfNZpw9NovEdWyfI7Z1MInPGYQWZTZALlxnK2oXjb52/TXYg2zteSG+UPaBTMQP4I8N83FhPKYAuchf0PHY1nS8mo5nowhgkABg60ncw71BAoAGzOefLkjqnwLgxEptzvtbrnmGmzowCqHe0tTQfsY4AVWAH6sUxjgBVrtxjhsjASw/EBCD7NZgNNemIFFYw9gcJCarjen+NgeN+do1gTEs//EllBfx9tBypUqV8Pzzz4flnVxmojYtXXsFfGpqKrc8NTVVtxUWFqJKlSq48MILpevUrl07qPzatWtLXzOfm5urP/OTnJyMjIwMfgVZFoERO20GWZpjqNkLMn0J2Oh8aOXZzW9a2KWptnZlO51TFaWwSlOTXaYA25UrS5W38fW1yz5l2rZNoW5HBnGfZbZo9dXXEfTZwXFVFun/0uPCrl2SvtqntEvKtcuIMvo7XW7RNktfq78dlm0v1Cgf74TnidFf5htuWxkRiXdplTWdOnXC+vXrw15u1M7waJjlpBljthLT5nWs1rcrZ+zYsRg+PBDtnzx50jrosUstF9l8DbO2ayeiMN3dob8AYUo7IA6BjT7meg19lZZtVb5xOwmCFiGyco3lWWwnLrVcdLEVHR4221+qeeJwQBRdiB1hd/EJtU0x6Osppd2ubCfvR7QNACTlu+23oF2uy/NSrl352nInZVv9sHNTZzj8oyzYAXwPLSvl/Lb0sqZbt24YO3Ys9uzZgxYtWqBGjRqcvWfPnq7KjdqAJy0tDYBvhqZOnTr68uPHj+uzPmlpaSgpKcGJEye4WZ7jx4+jbdu2+jr//e9/g8r/+eefg2aPjCQlJSEpyUGqn9ugx4k91BPTLhCyswP2OjxW9YqW+dG1dkTlOxlEBEGLtFyHbRP7ScqUlSvZr/YCcA4H1CA9I3mxnjVtyoAyb7PdxVZUtkxHyWgLObCUVustMLF7LYWoDIflCst2Up/djyA7/3DaOeFBi0Y43X7SwDM8bwyvyDz++OMAgLy8vCCboihcUlIoRO0trczMTKSlpWH16tX6spKSEmzYsEEPZlq0aIHKlStz6xw7dgx79uzR12nTpg2KioqwdetWfZ3PP/8cRUVF+jqeCXWQsVP7tLvN5eREt2uTyW47fWz0swq0HE57CxWenQQCghkgN6q3trcmZOUy0yeE9tpO49vdEjGWY1WuXb1Ojh9zm5j4Nk/YlJatkLXZSX9F/bG7JSkrw24bSo4Lz7elXL+WwlCmaB1XquF245jzcUFatkiAVYat3eYEc3u7KwLBjvlUcPuJJlRVFX7cBjtAhIUHT506he+++w4A0Lx5c+Tl5aFDhw5ISUnBpZdeiqlTpyI3Nxevv/46GjRogJycHKxfvx779+9HzZo1Afgiwf/85z9YsGABUlJSMHLkSPzyyy/Ytm2bLkndrVs3/PTTT5gzZw4A4NFHH8Vll12GZcuWOW4rCQ8SBEEQTikv4cEGi8YgsXpVT2WV/nkG397/XNxf3yJ6S+vLL79Ehw4d9O/aMzP9+vXDggULMHr0aJw+fRpPPPEETpw4gVatWmHVqlV6sAMA+fn5qFSpEnr37o3Tp0+jY8eOWLBgAff+jTfffBNDhgzRs7l69uwp1P4hCIIgCCJyvPjii5bLFUVB1apVcfnll+Omm27irvNOoFdLOIRmeAiCIAinlNcMz+ULx4Zlhue7vrlRc33LzMzEzz//jD///BMXXnghGGP47bffUL16dZx33nk4fvw46tWrh3Xr1gUnE0mI2md4CIIgCIKQY36k0O0nmsjJycF1112Hb7/9Fr/88gt+/fVXHDhwAK1atcILL7yAI0eOIC0tDcOGDQup3KjN0op2uqU9EfiiKFh+7BXefvFg/W+zCFW3S4ZwWTauRQvBi2N1qzdS9wMsRLUajObbbBTkuuIpvk0GQUNALvbV7Wqf+JqWMWUUNAT8ooYGjCJjnAAZJIKH/jYbBQ9vuSYgoMYUJVjw0CCMZimGaMAoqAYYBNfACyUCIYglghd5M9ss7a0Nvp+JbWa7UXgOsBCfk9i9+IYiiBfOeh35+ievQ9mOut3/7Gmo+894bAhF/DS7+bhqma23Oeh41I5Xf7usjnXt4V/jOQKEIAAIi/NPdu5KxAEBmzHjyjEBA2PcWASYxiqAE2DVhVkBQGXBwq2yMbLuMO6B5OVHZvK+GUMDbfqBv61iHNOhqsFjvuGasLzwVRDuGT9+PN59913Ur19fX3b55Zdj+vTpuPPOO3Hw4EFMmzYNd955Z0jlUsATDiyzKlQgQTKBxpg8PRwQZye48TP7hppiqjKxLpAfYZaInQ6PXoBF+bI2G2yONEHMbZLNb2rlidokIeS2GHGb5OE1a8UlnvpqR6jZj07tdttYlpbupL9u1/HQZsfp6G62qRcdHr0MF5lWsvXsJDvc+jlpk10mVjk/JRJvSsuAL9v63LlzQcvPnTunCwanp6dz79V0At3Scku4ToxQBz6pn4Orpds6gYCyqXnQsMlt5AZGN3o5TtOtLeqVpus6SYn3sn9s2mTVLsftNbfZJm3ZcXvttrFV0FlWvjLs+utwW8j2gW2ad6jHhl1fHaSdu0ppd2vT2mRogyUif9F4oflY/e20XH0dgZaO2zFUhqpGXbDjqzNMnyiiQ4cOGDhwIHbs2KEv27FjBx5//HHcfPPNAIDdu3cjMzMzpHIp4PGC26CnTH8lqs4DH6tlXgIiyXqOdHhkejmiupzYbdoTsoaPk7pFOLzI212IzXbbX9tegqVo9LXBSVAZ9oDGztdBfxy/okVmd+PrVofHy7hgd+7qbfMwzrmdWXKyn92UWxaE47USUTbDM3/+fKSkpKBFixa6CHDLli2RkpKC+fPnAwDOO+88zJgxI6RyKUvLIZSlRRAEQTilvLK06i0YhwSPWVrqn2dw8MEpUXd9++abb3DgwAEwxnDVVVcJX/btFHqGhyAIgiBiFDcTzVZlRCP16tWDoiioX78+KlXyHq7QLS2CIAiCiFHi8W3pf/75J/r374/q1aujUaNGOHLkCABgyJAheO6552y8xVDAQxAEQRBE1DB27Fjs2rUL69evR9Wqgdt1nTp1wttvv+26XLqlRRAEQRCxSjgeOo6yGZ73338fb7/9Nlq3bg3FIA1y9dVX4/vvv3ddLgU8LrnlokehKIEJsuU/z+bs3VIfD9j+O4u3aQJV/h0ZsmihhqJwooW6aJZWrllUqy6vSmkUNZSJdQEGUUPAJ4hoEDXUhcC0eg0iYYBfRMwoahiK4OGVYzj9H068TBM20+o1C58ZBBGDxBAbmQTVJGKJRrE1wIFYm8EuFVIELwJntgfZDEKLAIQijGabV1+jgCPAi97JbKH4KoyFtc1Ge5DNyz5oNoF74CGkfS8R8dPt/sQj2fFqKfLnP9YBi/PAqQAgLM6/K57i7cZz1ygOyFiw0Kk2LvgzpYwCgd3qjeSyrILGG9lYpQmzavWahVszhnL7yCggyIkHwmJ8rTNI9zWLBxrHdMBiXP/LY2D+Pq3431yUF/H4DM/PP/+M2rVrBy3/448/uAAoVOiWlgcYU/UD3GUB1svttB7s/O10MUIpywpZGW5TfaUpsxI9D7t6IU7xluIkVb4M09JD9vVSrg126fBOU8BlviFj118v26Ks0tKNiNLwBXhKpTeeP6I0bSfbUXbMWSE9Zx2OcXZttizbwT4Xaeo4PV4s2uTpWkBwXHfddfjwww/171qQM2/ePLRp08Z1uTTDEwYsD3QHysR+Z+vloqCHMXulZTvcBD1aHxWLGFkrT9RfWZu1OmV2kc3YD6u6bQYv1yrBMuVou3qd9NfO1w1eyo1GXyd4uSCGWqaZEAMaIIwqzqFQHj/tZYGALFgK1cdx2R4CEycKz+UN83+8lhFF5Obm4pZbbsG+fftw7tw5vPDCC9i7dy+2bNmCDRs2uC6XZnjKEicqo25w+6s2HIObTPDLySxMqLNSTny1ukPBpkzHsw9uVX7DPTMRyoxHOc4OOaIs2uxlJsbrLI2NqKCrWS0nx7+TGZxQ+2vnK61XMlaEcqyFOmZIZ508zJ47HWPKOSiKxyyttm3b4tNPP8Wff/6J+vXrY9WqVUhNTcWWLVvQokUL1+WS8KBDSHiQIAiCcEp5CQ9eOveZsAgPHnl0Utxf3+iWFkEQBEHEMnEwbXHy5EnH67oNyijgIQiCIIgYJV7eln7BBRc4zsAqLS11VQcFPARBEAQRq8TJQ8vr1q3T/z506BDGjBmDBx98UM/K2rJlC9544w3k5uaKirCFAh6CIAiCICJKu3bt9L8nTZqEvLw83Hvvvfqynj17okmTJpg7dy769evnqg4KeFxyy4WPBL4oClb8Oo+3pwzQU6XNIlRhES3U7AZxrG51BvE2iaAhwItucYKG4MW6AIOooWY3Ch4ahcBQhoKHsBAv0zCJIQIG4TMg2GYUTYNALFFkk4ixcXZFsRZSNPpK7EE2mYCcxFbRfYU2TRAvlH0QglCf8LgQ2WXHXIPRXOZQSMe67ByyO/9k527dYVxGUtB5f2kW32azSKrRZh5vZGOV3TgnGyMdiAcCPqkRq3Hb2N+gMd9wTVhx4jWUH4r/47WM6GHLli2YPXt20PKWLVvikUcesfBwBqWlhwMXwltSkSq3GhSRSrizTd+1abM0JV3lP27qsKvXSwq43XrhrFcmIGcnLhePyPrrxGZHuPefU183afa24pwOziE3x6OMaBirwjk2R+t5xcL0iSIyMjIsA545c+YgIyPDdbk0wxNBPAc9Vg94yWxGDYoEU6xrHBhk5TqxW+H2AiNd39AfmSCiG7xohHgZzJ1cJNwIT8q2hd12ikVfGW4CVafrlZWvp/56CHLCcd56sct0c9wGVJI+hUUt2YuwIQEAyM/Px5133omVK1eidevWAIDPPvsM33//Pd59913X5dIMj1ui4aD28gvK7UDixB7K+k5fG2H7q9hKJt4moHQ7I1Iev/KdlBFKueGot7zxKjzotq/hKNetr9sZOqczOOHc905mquxEA2UCgTK1+TIIdkLCq7BhOInDGZ5bb70V3377LW6//Xb8+uuv+OWXX3D77bfjwIEDuPXWW12XS8KDDiHhQYIgCMIp5SU8mPHKs0io5lF48PQZHB00Me6vbzTDQxAEQRBERPnqq6+ghjBDtnfvXpw7dy6kOijgIQiCIIgYxXx31+0n0jRv3hy//PKL4/XbtGmDI0eOhFQHPbRMEARBELFKOJ7BiYKAhzGGCRMmoHr16o7WLykpCbkOCngIgiAIgogoN910E/bv3+94/TZt2qBatWoh1UEBj0tuOf8h7vuKk6/z9uSHA7aif/C2C3nhJLNI1S0pAwI2s7jVRY/yvgZxLE00S0MmaAjwolvdUh/n0p2NYl2AScxLUTixL0+ChxcP5us1C5BJBBFlYoicXVGsRdGMvlZ2v3CkUWwNkIuxme1BNjuhN4NdZjPbZeJydva49fVnLIWyHc32kH1l+97uuDEckyEfr4ZzQXge+O9bcOeQneCo3blreOYi6Lw3jguM8QKAEnFAwGasshnnZGOkcWwFQhMPNI7pgMW4brgmmK8HZQpTfB+vZUSY9evXl3kdFPDEEYypnIJzEFpKZoLg4PaiISJDGxTN2j9uy7Pyk2nTiFKE7fRsRCmsdttRRlndLLfTD5GmK1cwXzvKSjCvPHSh3Pq6Kd/uAdNw1Rutgn9RgsJ8H69lVAQo4IlGZBdjm4utI+GscA8gTgMPNxoVZRnU2F3YvAZEbnB7sXXS3opEWQUtdkRzUOPGr6x0ZcIgeGg71nlRgrav3L1vuImTZ3jKAwp4XMJUFYpoxgKwCVpsZjw0fxnhDlpCmf1xG0RY1hvCgGolPmd3kS+LQU1bHm7FY694CZbKotxI+nohUgrP0egbjnLDXH+ZBzoeZq5YNAjSEkJIeNAhJDxIEARBOKXchAfz/x4e4cFhE+L++kYzPARBEAQRq9AtLcdQwEMQBEEQRMQpLi5GQkICKleuDAD4/vvv8Y9//ANHjhzBZZddhv79+yMzM9N1+aS0TBAEQRCxipMXgzr5RAHdunXDsmXLAACffvopGjVqhP/85z84e/YsPvroIzRu3BhbtmxxXb7nGR7tESCFMkQIgiAIonyJo1taO3bsQLNmzQAA48aNwxNPPIG8vIDW1YQJEzBq1Chs2rTJVfmuA5758+cjPz8f3377LQCgQYMGyMrKwiOPPGLj6Zxz584hOzsbb775JgoLC1GnTh08+OCDGD9+PBL8GU6MMTz77LOYO3cuTpw4gVatWuGVV15Bo0aN9HKKi4sxcuRIvPXWWzh9+jQ6duyIV199FZdcconrtnWt8YDvD3+gt/LUG7z9vH7632abJ9FCzebvv1EcKxRBQ4AX3dJt/iwto1gX4FHwUGKXCYwF2RUlNPEygz3IZieWaLCHIqRotstsUruihCbCaCcgV4F9QykXCNP+E9kcCvVJRfys7LJjXXKehHT+qYw/d70IAEpsgM1YZTfOaXb/tjaOoV7EA41jOmAx5mvXBAAr//gn4p0ff/wRTz31FJYvX47Tp0/jiiuuwPz589GiRQvXZZ49exZnz54FAHzzzTd44QVeRPPBBx/EzJkzXZfv6pbWhAkTMHToUPTo0QPvvPMO3nnnHfTo0QPDhg3D+PHjXTfGzNSpUzF79my8/PLL+PrrrzFt2jQ8//zzeOmlwEAybdo05OXl4eWXX8YXX3yBtLQ0dO7cGb///ru+TlZWFpYuXYolS5Zg06ZNOHXqFLp3747S0lLvjSyLN685EuNSQ9fIcCryFWLqLWOq/gmZUOqzSkt3i5e35mnbXrQP3Owbq/ZZLRO1O9reBBhpZNuiLLeV3XHhFi9t9uKrnZ9lIadQVmU7Of/i6TzRlJa9fkLgxIkTuOGGG1C5cmUsX74c+/btw4wZM3DBBRd46kqrVq30W1r169fHrl27OPvOnTuRkpLiunxXMzyzZs3CvHnzcO+99+rLevbsiaZNm2Lw4MGYPHmy6wYZ2bJlC26//XbcdtttAIC6devirbfewpdffgnAN7szc+ZMjBs3DnfccQcA4I033kBqaioWL16MgQMHoqioCPPnz8fChQvRqVMnAMCiRYuQkZGBNWvWoGvXrpZ1FxcXo7i4WP9+8uTJsPQJcKDhA7i/EJdFuYBvUHKgLOwq6NHKd0M4Bi3RRdEr4b7oeSEWtXQipcOjUd77L1JaOy7PPdfnutM6y2IfOywzlvR0wqm0bL7OJSUlISkpKWj9qVOnIiMjA6+/HpgFq1u3rrdGAJg8eTK6deuGP/74A/feey9GjBiBb7/9Fg0bNsT+/fvx4osvYuzYsa7LdzXDU1paipYtWwYtb9GiBc6dO+e6MWZuvPFGfPzxxzhw4AAAYNeuXdi0aRNuvfVWAEBBQQEKCwvRpUsX3ScpKQnt2rXD5s2bAQDbtm3D2bNnuXXS09PRuHFjfR0rcnNzkZycrH8yMjLC1i/Ad0KVyUkl+4UpbVAIsz8eZoBCHiSNdYY6MJfVr/hIzhCI7DE0QJcbbrajzC8UymJmKRzHnPkccnhOeZ7BdXPu2pYdhv1krtbpuBwvs0MmMjIyuOtebm6u5XoffPABWrZsibvuugu1a9dG8+bNMW/ePMt1Q6FNmzZYvnw5Vq5ciSFDhuCXX37BlClTcP/992P+/PnIzs7G6NGjXZfvSnhw8ODBqFy5MvcwEQCMHDkSp0+fxiuvvCLwDA3GGJ5++mlMnToViYmJKC0txZQpU/QIb/Pmzbjhhhvw448/Ij09Xfd79NFHcfjwYaxcuRKLFy/GQw89xM3WAECXLl2QmZmJOXPmWNZtNcOTkZER98JMBEEQhHfKS3jw0qmTwyI8eOSp8Th69CjXVtEMT9WqvvqGDx+Ou+66C1u3bkVWVhbmzJmDBx54IGh9N/z88884ePAgVFVFnTp1wjKD5Omh5VWrVqF169YAgM8++wxHjx7FAw88gOHDA28UNgdFofD2229j0aJFWLx4MRo1aoSdO3ciKysL6enp6Ncv8ACZOUOMMWabNWa3jmhHEwRBEEQ8cv755zsKzlRVRcuWLZGTkwMAaN68Ofbu3YtZs2aFLeD5y1/+gr/85S9hKUvDVcCzZ88eXHvttQB8wkBAoHF79uzR1/Oaqj5q1CiMGTMG99xzDwCgSZMmOHz4MHJzc9GvXz+kpaUBgJ7BpXH8+HGkpqYCANLS0lBSUoITJ07gwgsv5NZp27atp/YRBEEQRCRREIZneEJcv06dOrj66qu5ZQ0bNsS7777rrSEGtm7divXr1+P48eNQTbcZ3U6kuAp41q1b56qyUPnzzz/19HONxMREvfOZmZlIS0vD6tWr0bx5cwBASUkJNmzYgKlTpwLwPVdUuXJlrF69Gr179wYAHDt2DHv27MG0adPKpR8EQRAEES/ccMMN2L9/P7fswIEDuOyyy8JSfk5ODsaPH48rr7wSqamp3OSJl4kUVwHPggULcPfdd6NatWquK3ZCjx49MGXKFFx66aVo1KgRduzYgby8PDz8sE9LQVEUZGVlIScnBw0aNECDBg2Qk5OD6tWro0+fPgCA5ORk9O/fHyNGjECtWrWQkpKCkSNHokmTJnrWFkEQBEHEJC7Syi3LCIFhw4ahbdu2yMnJQe/evbF161bMnTsXc+fOtXd2wAsvvIB//OMfePDBB8NSnoargGfs2LEYMmQI7rrrLvTv37/Mbg299NJLmDBhAp544gkcP34c6enpGDhwIJ555hl9ndGjR+P06dN44okndOHBVatWoWbNmvo6+fn5qFSpEnr37q0LDy5YsACJiYmu29a1Wl/u+8rTC4Pt/jRuswiVUaDK0i4RLZSJX9kKGkrstoJcErtjITALu0xgzM4eilhiKEKKml1RfLOLoQgpmu2ufP39kYrAmewhCchVMN9QygXCsP9c+no9XoU2J+eQhY2z+3NbQhI69SIAmPwwlwnFjVU245xsjPQiHqjb/BlnlmO+5muylSkRUFq+7rrrsHTpUowdOxaTJk1CZmYmZs6cifvuu89jQ3wkJCTghhtuCEtZRlwFPD/88AM+/PBDLFiwAB06dEBmZiYeeugh7rmacFCzZk3MnDlTqqyoKAqys7ORnZ0tXKdq1ap46aWXOMHCcsGrtkyIU3eO9H1kdbqdKtTur7qpOyx6N4IyHGoHiRCl4RqXa0FRWJH1J1SfikoUbitPujV2lFWfPKXAexRaLEtc6ZzROWake/fu6N69e5mUPWzYMLzyyiueVJWtcBXwJCYmomfPnujZsyeOHz+ORYsWYcGCBZgwYQJuueUW9O/fHz169Ah6/iauYCpQFhc7ro7QTzBP2j5eB5my0IJxGfzplFEwpGF1ESvTC5tbvAQAsehbxjgJhsNKNAY0GhEac1yNdeWhn1Pe538EZnjKmpEjR+K2225D/fr1cfXVV+tvT9d47733XJXr+Ypdu3Zt3HDDDWjTpg0SEhKwe/duPPjgg6hfvz7Wr1/vtfjoprxVhSOJ1196XkXCRK9T8IJMFK2M5PTtRBg9vaaDCJlQ90GZ7puyetVCWQllejmnPbSlzERbjbjZB0wt/2AHAaVlr59oYvDgwVi3bh2uuOIK1KpVixNDTE5Odl2uK+FBAPjvf/+LhQsX4vXXX8fBgwfRq1cv9O/fH506dcLp06cxfvx4/Otf/8Lhw4ddNy6aKGsRKYIgCCJ+KC/hwbpTpiChqkfhwTNncGjcuKi5vtWsWRNLlizRXysVLlzd0urRowdWrlyJK664AgMGDMADDzzAvdCrWrVqGDFiBPLz88PWUIIgCIIgTMThLa2UlBTUr18/7OW6Cnhq166NDRs2oE2bNsJ16tSpg4KCAtcNIwiCIAjChjgMeLKzszFx4kS8/vrrqF69etjKdRXwzJ8/Hx9//DGefvppSxXEf/zjH1AUJWwiRARBEARBVAxefPFFfP/990hNTUXdunWDHlrevn27q3JdBTyTJk3Cs88+i5YtW6JOnTqeXyFBEARBEETohOOh42h7aLlXr15lUq6rgGfWrFlYsGAB+vbta79ynNK1Ki+wtPLMm0K70OZPaw9FwEomeGgraCixd63xAJf6HYrgoZ2Yl1TwsJzEEkMRUrT1DUFoMRQRRi++ERd/LG/fKNwHnn3L6njVbJp4YLjOP79Ny5gK55hhO1YJbLrdkGXFjZFOBGMBgKnSMR0Qj+tMZVhVshjlRgSUlsuSc+fOAQAefvhhZGRkhLVsV2npJSUlFf7Fm0xlYF7TRyOUxiikLFJXEUgjDXsqaVml29phTLO36lNZp8yGG7vtKLNHyjdasTsuwiHRIEO2HcNdVbjO6XC3zcu47GFMDss1wVXFYfpECZUqVcL06dNRWloa9rJdBTyPPPIIFi8uxwg2ionYQW6FUcejLLQ8wlGMaYAsU02NSF4s3V70Yi1YilciGbTIsAsOw12d4cdKWM/TcJybZaSVRUSejh07lomOn6tbWmfOnMHcuXOxZs0aNG3aNOiBIrevbif8aL8wylrJOVTKMHAQDaaeXpchrdCmL15eteEV0YVFdsGxuxipqrtXf0Q7ZbWtIoHsmIzAuReewsug3eEIcqJpZt0j8fgMT7du3TB27Fjs2bMHLVq0QI0aNTh7z549XZXrSniwQ4cO4gIVBWvXrnXVmGiGhAcJgiAIp5SX8GC9Z3LCIjx4cNLTUXN9k72WSlEU17e7XM3wrFu3zlVlBEEQBEEQMsxSN+EiDue4CYIgCKKC4PEdWkqUPbQcCk2aNMHRo0cdr+9qhocgCIIgiCggDpWWnXLo0CGcPXvW8fo0w0MQBEEQRNxDMzwu6VL5Ht8f/kwqs9BUlyp99L9lNpFdSfBlCIUifhWKGCKUBHeCXBZ2R74JBlHDUEXEBPZQfINsdsJnBnsogmqR8u16Xj8um82NgFy8+ppt0bj/PPvKjvUwnUNBvmU9ZgB6NpXrcU7iayUQ6HXc1tq76uwSlBsVeIYnVCjg8UoZpTeWubaPud1MLds0eFF/VMYFQ+VGrAjZhYAsvditLR59oxrRcRmp4zVSOjexOK5GKNU9HtPSywoKeGIMpjJ99qcMCi+bcu2IRvGwCGmiEHGME+2nSBFngQ1BWEEBT1lRhjMmkZEvNwxM5SmIGI3BkB0ULMUv0Ry0yJDNsEaCMgx0yn12nIgZXAkPVkRIeJAgCIJwSnkJD9Yfm4NEj8KDpWfO4Pvc6BEelPHnn3+ievXqAIDFixfj9ttvD1JiFkFZWgRBEAQRo3jV4AnHM0Dhpn379vjhhx+Cln/++ee45ppr9O99+vRxHOwAFPAQBEEQBBFFnH/++WjatCmWLPFlu6mqiuzsbNx0002u36MF0DM8BEEQBBHbRNkMjVc++OADzJ49G4888gg++OADHDp0CEeOHMGHH36ITp06uS6XAh6CIAiCiFXiVIfnsccew+HDhzF16lRUqlQJ69evR9u2bT2VSQGPS3ThQT9moSmjXWYL2VcifuVIGKsMfMMlBFaWvkG2EETTQhFUi5RvuYjAxahvLOw/x74WQnyAzbEewfPPmDEVDWNVpMZtIjROnDiBRx55BB9//DHmzJmDDRs2oEuXLpg2bRqeeOIJ1+VSwBNrRGFKZETS5L1itx2jcDsTcY7smIvy49FqDIjouBDB7VXe/Y5H4cHGjRsjMzMTO3bsQGZmJgYMGIC3334bTzzxBD788EN8+OGHrsqlh5ZdwlSmf6KGKB0UjdsqqraXW5jKf2R2omLh9LiIwWPDfO5G7TkdoW0bsW3BwvSJIh577DFs3LgRmZmZ+rK7774bu3btQklJietyaYYnDETVCR9jA2lUbbvywMvMkmYrT+HHeMXtbEqMnV9eidrzs4Lth4rGhAkTLJdfcsklWL16tetySXjQISQ8SBAEQTilvIQHrxiZg8Qkj8KDxWdwYHpkhQe/+uorx+s2bdrUVR00w0MQBEEQsUqcZGldc801UBQF2hyMoojfGVlaWuqqDpobJwiCIAgiohQUFODgwYMoKCjAe++9h8zMTLz66qvYsWMHduzYgVdffRX169fHu+++67oOmuEhCIIgiFglTmZ4LrvsMv3vu+66Cy+++CJuvfVWfVnTpk2RkZGBCRMmoFevXq7qoICHIAiCIGKUeExL3717N5ehpZGZmYl9+/a5LpcCHpd0Tryb+7669G2hXWYL1VcmfhWKMFbU+fozj8pKgCyUcmPRN2JCbjHgGwv7L1K+tuVG85jhwjdS43aZEiczPEYaNmyIyZMnY/78+ajqfxN8cXExJk+ejIYNG7oulwKeGMOYJqokiB/qijlEaaaUfkoQZUccn19Rm1JP2DJ79mz06NEDGRkZaNasGQBg165dUBQF//nPf1yXG/UPLf/444+4//77UatWLVSvXh3XXHMNtm3bptsZY8jOzkZ6ejqqVauG9u3bY+/evVwZxcXFGDx4MC666CLUqFEDPXv2tHz1fKxhJQRWoYhxITeCCDtxKHgYKlEphliWxKHw4PXXX4+CggJMmTIFTZs2RZMmTZCTk4OCggJcf/31rsuN6hmeEydO4IYbbkCHDh2wfPly1K5dG99//z0uuOACfZ1p06YhLy8PCxYswBVXXIHJkyejc+fO2L9/P2rWrAkAyMrKwrJly7BkyRLUqlULI0aMQPfu3bFt2zYkJiZGqHdlQ4U60e0gATkiXqBXoXDQOBcgHp/hAYDq1avj0Ucfla5z22234bXXXkOdOnUclRnVwoNjxozBp59+ik8++cTSzhhDeno6srKy8NRTTwHwzeakpqZi6tSpGDhwIIqKivCXv/wFCxcuxN13++6x/vTTT8jIyMBHH32Erl27OmoLCQ8SBEEQTikv4cGrhoRHePCbFyMrPOiGmjVrYteuXahXr56j9aP6ltYHH3yAli1b4q677kLt2rXRvHlzzJs3T7cXFBSgsLAQXbp00ZclJSWhXbt22Lx5MwBg27ZtOHv2LLdOeno6GjdurK9jRXFxMU6ePMl9CIIgCCKqiMNbWmVFVAc8Bw8exKxZs9CgQQOsXLkSjz32GIYMGYJ//vOfAIDCwkIAQGpqKueXmpqq2woLC1GlShVceOGFwnWsyM3NRXJysv7JyMgIZ9cIgiAIwjPaLS2vn4pAVAc8qqri2muvRU5ODpo3b46BAwdiwIABmDVrFreeWYKaMSaVpXayztixY1FUVKR/jh496r4jBEEQBEFElKgOeOrUqYOrr76aW9awYUMcOXIEAJCWlgYAQTM1x48f12d90tLSUFJSghMnTgjXsSIpKQnnn38+9yEIgiCIqIJuaTkmqrO0brjhBuzfv59bduDAAV2COjMzE2lpaVi9ejWaN28OACgpKcGGDRswdepUAECLFi1QuXJlrF69Gr179wYAHDt2DHv27MG0adNct61zwl3c99XqO7y9jASsZL6hlBsPvqEIkIUiThaLvrEoAldevrGw/yLlG4vnfXn5Cm3+jLigMd9wTTDbypQ4FB4sK6I64Bk2bBjatm2LnJwc9O7dG1u3bsXcuXMxd+5cAL5bWVlZWcjJyUGDBg3QoEED5OTkoHr16ujTx6cgmpycjP79+2PEiBGoVasWUlJSMHLkSDRp0gSdOnUqu8ZXsDTRSGCXmkqpq0RFQXas03kQJmhMjzqefvpppKSkOF4/qgOe6667DkuXLsXYsWMxadIkZGZmYubMmbjvvvv0dUaPHo3Tp0/jiSeewIkTJ9CqVSusWrVK1+ABgPz8fFSqVAm9e/fG6dOn0bFjRyxYsCByGjzaiaNE9R3FuIaCJSLaoKAlioih4Ebxf7yWEW0sXLgQs2fPRkFBAbZs2YLLLrsMM2fORGZmJm6//XYAvmdtQyHqr7jdu3fH7t27cebMGXz99dcYMGAAZ1cUBdnZ2Th27BjOnDmDDRs2oHHjxtw6VatWxUsvvYRffvkFf/75J5YtWxYdWVcVRPk03tCUXEWKrm5tRGwQjn1P+z9KicUxOQ6f4Zk1axaGDx+OW2+9Fb/99htKS0sBABdccAFmzpzputyoFh6MJkh4kCAIgnBKeQkPNnosPMKDe2dHj/Dg1VdfjZycHPTq1YsTF9yzZw/at2+P//3vf67KjfoZHoIgCIIgKg4FBQV6IpKRpKQk/PHHH67LpYCHIAiCIGKVOLyllZmZiZ07dwYtX758eZBUTShE9UPLBEEQBEHYEGUBi1dGjRqFQYMG4cyZM2CMYevWrXjrrbeQm5uL1157zXW5FPC4xFaHR6LJUFa+oZQbsm8U6GJ48S0vLaRI+cbCPoiUbyzsv0j5Rnz/OdC0MdvLdJwro3GbCI2HHnoI586dw+jRo/Hnn3+iT58+uPjii/HCCy/gnnvusS9AAN3SIpyhZS/EYhYDQRCRQTRm0DgSNiL9Lq3c3FxdEy+cDBgwAIcPH8bx48dRWFiIo0ePon///p7KpBkewjt2A5fRTtpDBBEfhHLeE2VHBJWWv/jiC8ydOxdNmzb12AAxF110UdjKooCHKF+sfunZrU9BEkGUHbJzkIIWQsCpU6dw3333Yd68eZg8ebLn8po3b2770m+N7du3u6qDAh4i+hENuhQsEUQAN+cJBTQxj9dbUloZgE/bx0hSUhKSkpIsfQYNGoTbbrsNnTp1CkvA06tXL89l2EHCgw4h4UGCIAjCKeUlPNikfw4Sq3gUHiw5g93znw5aPnHiRGRnZwctX7JkCaZMmYIvvvgCVatWRfv27XHNNdd4UkEuD2iGhyAIgiAIHD16lAvOrGZ3jh49iqFDh2LVqlWoWtVboFXeUMBDEARBEDFKOG9pnX/++bazUdu2bcPx48fRokULfVlpaSk2btyIl19+GcXFxZ5fzH3hhRdaPs+jKAqqVq2Kyy+/HA8++CAeeuihkMqlgIcgCIIgYpVyztLq2LEjdu/ezS176KGHcNVVV+Gpp57yHOwAwDPPPIMpU6agW7duuP7668EYwxdffIEVK1Zg0KBBKCgowOOPP45z584FvVBcBgU8LqlwwoMx7lte+yBSvrGwDyLlGwv7L1K+sbD/IuUbM8KD5Rzw1KxZE40bN+aW1ahRA7Vq1Qpa7pZNmzZh8uTJeOyxx7jlc+bMwapVq/Duu++iadOmePHFF0MKeCiFhSAIgiCIqGHlypXo1KlT0PKOHTti5cqVAIBbb70VBw8eDKlcmuEhCIIgiBglnM/wuGX9+vXeCjCRkpKCZcuWYdiwYdzyZcuWISUlBQDwxx9/oGbNmiGVSwEPQRAEQcQqEVRaLismTJiAxx9/HOvWrcP1118PRVGwdetWfPTRR5g9ezYAYPXq1WjXrl1I5VLAQxAEQRBE1DBgwABcffXVePnll/Hee++BMYarrroKGzZsQNu2bQEAI0aMCLlcEh50CAkPEgRBEE4pL+HBa/pOCYvw4M6F4+L++kYzPARBEAQRq8ThLS0AUFUV3333HY4fPw5V5V+BctNNN7kqkwIegiAIgiCihs8++wx9+vTB4cOHYb4JpSgKSktLXZVLAQ9BEARBxCjRkKUVbh577DG0bNkSH374IerUqeP4Lep2UMDjEhIRiy3fWBCB8+IbC/sgUr6xsP8i5RsL+y9SviQ8GDm+/fZb/Otf/8Lll18e1nJJeJAgCIIgiKihVatW+O6778JeLs3wEARBEESMEo+3tAYPHowRI0agsLAQTZo0QeXKlTl706ZNXZVLAQ9BEARBxCpxeEvrzjvvBAA8/PDD+jJFUcAYo4eWCYIgCKIiEo8zPAUFBWVSLgkPOoSEBwmCIAinlJfwYIu7wyM8uO1tEh4kCIIgCCJaicNbWhr79u3DkSNHUFJSwi3v2bOnq/Io4CEIgiCIGCbabkl55eDBg/jb3/6G3bt368/uAND1eNw+w0Np6QRBEARBRA1Dhw5FZmYm/vvf/6J69erYu3cvNm7ciJYtW2L9+vWuy6UZHpeQiFhs+caCCJwX31jYB5HyjYX9FynfWNh/kfKNHeFB5vt4LSOK2LJlC9auXYu//OUvSEhIQEJCAm688Ubk5uZiyJAh2LFjh6tyaYaHIAiCIGIULUvL6yeaKC0txXnnnQcAuOiii/DTTz8BAC677DLs37/fdbk0w0MQBEEQRNTQuHFjfPXVV6hXrx5atWqFadOmoUqVKpg7dy7q1avnulwKeAiCIAgiVonDLK3x48fjjz/+AABMnjwZ3bt3x1//+lfUqlULb7/9tutyKeAhCIIgiBhFUX0fr2VEE127dtX/rlevHvbt24dff/0VF154oac3p8eU8GBubi6efvppDB06FDNnzgQAMMbw7LPPYu7cuThx4gRatWqFV155BY0aNdL9iouLMXLkSLz11ls4ffo0OnbsiFdffRWXXHKJ47pJeJAgCIJwSnkJD173t8moVNmb8OC5s2fwxdLxcX99i5mHlr/44gvMnTs36KVh06ZNQ15eHl5++WV88cUXSEtLQ+fOnfH777/r62RlZWHp0qVYsmQJNm3ahFOnTqF79+6uc/kJgiAIIipgYfpUAGIi4Dl16hTuu+8+zJs3DxdeeKG+nDGGmTNnYty4cbjjjjvQuHFjvPHGG/jzzz+xePFiAEBRURHmz5+PGTNmoFOnTmjevDkWLVqE3bt3Y82aNZHqEkEQBEF4Jh6ztMqKmAh4Bg0ahNtuuw2dOnXilhcUFKCwsBBdunTRlyUlJaFdu3bYvHkzAGDbtm04e/Yst056ejoaN26sr2NFcXExTp48yX0IgiAIIqrQdHi8fioAUf/Q8pIlS7B9+3Z88cUXQbbCwkIAQGpqKrc8NTUVhw8f1tepUqUKNzOkraP5W5Gbm4tnn31WaCcRsdjyjQUROC++sbAPIuUbC/svUr6xsP8i5RszwoOEY6J6hufo0aMYOnQoFi1ahKpVxQ9lmZ/aZozZPsltt87YsWNRVFSkf44ePRpa4wmCIAiijKFbWs6J6oBn27ZtOH78OFq0aIFKlSqhUqVK2LBhA1588UVUqlRJn9kxz9QcP35ct6WlpaGkpAQnTpwQrmNFUlISzj//fO5DEARBEFEFPbTsmKgOeDp27Ijdu3dj586d+qdly5a47777sHPnTtSrVw9paWlYvXq17lNSUoINGzagbdu2AIAWLVqgcuXK3DrHjh3Dnj179HUIgiAIgohvovoZnpo1a6Jx48bcsho1aqBWrVr68qysLOTk5KBBgwZo0KABcnJyUL16dfTp0wcAkJycjP79+2PEiBGoVasWUlJSMHLkSDRp0iToIWiCIAiCiCXCcUuqotzSiinhQQBo3749rrnmmiDhwTlz5nDCg8ZA6cyZMxg1ahQWL17MCQ9mZGQ4rpeEBwmCIAinlJfwYOtbJ4VFePCzj56J++tbzAU8kYICHoIgCMIpFPBEH1F9S4sgCIIgCDF0S8s5FPAQBEEQRKwSh29LLyso4HEJiYjFlm8siMB58Y2FfRAp31jYf5HyjYX9FylfEh6MPyjgIQiCIIgYhW5pOYcCHoIgCIKIVVTm+3gtowJAAQ9BEARBxCr0DI9jolppmSAIgiAIIhyQDo9DSIeHIAiCcEp56fDc0OlZVKrkUYfn3Bl8umZi3F/f6JYWQRAEQcQqjPk+XsuoANAtLYIgCIIg4h6a4SEIgiCIGIXS0p1DAY9LSEQstnxjQQTOi28s7INI+cbC/ouUbyzsv0j5xozwIGVpOYZuaREEQRAEEffQDA9BEARBxCgKY1A8PnTs1T9WoICHIAiCIGIV1f/xWkYFgG5pEQRBEAQR95DwoENIeJAgCIJwSnkJD97012fCIjy48ZNJcX99o1taBEEQBBGrUJaWYyjgIQiCIIhYhZSWHUPP8BAEQRAEEffQDI9LSEQstnxjQQTOi28s7INI+cbC/ouUbyzsv0j5xorwICktO4dmeAiCIAgiVtFuaXn9hEBubi6uu+461KxZE7Vr10avXr2wf//+Mupg+KCAhyAIgiAIx2zYsAGDBg3CZ599htWrV+PcuXPo0qUL/vjjj0g3TQrd0iIIgiCIGEVRfR+vZYTCihUruO+vv/46ateujW3btuGmm27y1pgyhAIegiAIgohVwpildfLkSW5xUlISkpKSbN2LiooAACkpKd7aUcaQ8KBDSHiQIAiCcEp5CQ+2v35cWIQH12+dErR84sSJyM7OlvoyxnD77bfjxIkT+OSTTzy1o6yhGR6CIAiCiFXCKDx49OhRLjhzMrvz5JNP4quvvsKmTZs8NqLsoYCHIAiCIGKUcL4t/fzzzw9pNmrw4MH44IMPsHHjRlxyySWe2lAeUMBDEARBEIRjGGMYPHgwli5divXr1yMzMzPSTXIEBTwuIRGx2PKNBRE4L76xsA8i5RsL+y9SvrGw/yLlGyvCg5F4tcSgQYOwePFi/Pvf/0bNmjVRWFgIAEhOTka1atW8taUMIR0egiAIgohVGADV4yfEeGnWrFkoKipC+/btUadOHf3z9ttvh6VLZQXN8BAEQRBEjBLOZ3icEqvJ3TTDQxAEQRBE3EMzPARBEAQRqzCE4RmesLQk6iHhQYeQ8CBBEAThlPISHry52VOolGivlyPjXGkx1u6aGvfXN7qlRRAEQRBE3EO3tAiCIAgiVlEBKGEoowIQ1TM8ubm5uO6661CzZk3Url0bvXr1wv79+7l1GGPIzs5Geno6qlWrhvbt22Pv3r3cOsXFxRg8eDAuuugi1KhRAz179sQPP/xQnl0hCIIgiLCjZWl5/VQEonqGZ8OGDRg0aBCuu+46nDt3DuPGjUOXLl2wb98+1KhRAwAwbdo05OXlYcGCBbjiiiswefJkdO7cGfv370fNmjUBAFlZWVi2bBmWLFmCWrVqYcSIEejevTu2bduGxMREV20jEbHY8o0FETgvvrGwDyLlGwv7L1K+sbD/IuUbM8KDhGOiOuBZsWIF9/31119H7dq1sW3bNtx0001gjGHmzJkYN24c7rjjDgDAG2+8gdTUVCxevBgDBw5EUVER5s+fj4ULF6JTp04AgEWLFiEjIwNr1qxB165dLesuLi5GcXGx/v3kyZNl1EuCIAiCcEkElJZjlai+pWWmqKgIAJCSkgIAKCgoQGFhIbp06aKvk5SUhHbt2mHz5s0AgG3btuHs2bPcOunp6WjcuLG+jhW5ublITk7WPxkZGWXRJYIgCIJwjxbweP1UAGIm4GGMYfjw4bjxxhvRuHFjANDf35Gamsqtm5qaqtsKCwtRpUoVXHjhhcJ1rBg7diyKior0z9GjR8PZHYIgCIIgypGY0eEZNGgQPvzwQ2zatEl/Df3mzZtxww034KeffkKdOnX0dQcMGICjR49ixYoVWLx4MR566CHu9hQAdO7cGfXr18fs2bMd1U86PARBEIRTykuHp2PDEWHR4fn46xlxf32LiRmewYMH44MPPsC6dev0YAcA0tLSACBopub48eP6rE9aWhpKSkpw4sQJ4ToEQRAEEZN4fXGo9qkARHXAwxjDk08+iffeew9r165FZmYmZ8/MzERaWhpWr16tLyspKcGGDRvQtm1bAECLFi1QuXJlbp1jx45hz549+joEQRAEEYtQWrpzojpLa9CgQVi8eDH+/e9/o2bNmvpMTnJyMqpVqwZFUZCVlYWcnBw0aNAADRo0QE5ODqpXr44+ffro6/bv3x8jRoxArVq1kJKSgpEjR6JJkyZ61hZBEARBEPFNVAc8s2bNAgC0b9+eW/7666/jwQcfBACMHj0ap0+fxhNPPIETJ06gVatWWLVqla7BAwD5+fmoVKkSevfujdOnT6Njx45YsGCBaw0egiAIgogKKC3dMTHz0HKkMT+ARiJiseUbCyJwXnxjYR9EyjcW9l+kfGNh/0XK1+s+KK+HljvVzwrLQ8trvp9JDy0TBEEQBEHEOlF9S4sgCIIgCAl0S8sxFPAQBEEQRMwSDqXkihHw0DM8DiHhQYIgCMIp5fYMT70hqJTg8RketRhrDr4Y99c3muEhCIIgiFiFbmk5hgIegiAIgohVVAbPt6TUihHwUJYWQRAEQRBxD83wEARBEESswlTfx2sZFQAKeFxCImKx5RsLInBefGNhH0TKNxb2X6R8Y2H/Rco3nPugTKFneBxDAQ9BEARBxCr0DI9j6BkegiAIgiDiHprhIQiCIIhYhW5pOYaEBx1CwoMEQRCEU8pNeLDOQFRKqOKprHNqCdYcmxP31ze6pUUQBEEQRNxDt7QIgiAIIlahW1qOoYCHIAiCIGIVVQXgUUdHrRg6PHRLiyAIgiCIuIdmeFxCImKx5RsLInBefGNhH0TKNxb2X6R8Y2H/RcqXhAfjDwp4CIIgCCJWoYDHMXRLiyAIgiCIuIdmeAiCIAgiVqFXSziGhAcdQsKDBEEQhFPKS3iw44X9wiI8+PGJN+L++kYzPARBEAQRqzDmfYamgsx70DM8BEEQBEHEPTTDQxAEQRCxCgvDMzwVZIaHAh6CIAiCiFVUFVA8KiWziqG0TAGPS0hELLZ8Y0EEzotvLOyDSPnGwv6LlG8s7L9I+caM8CDhGAp4CIIgCCJWoVtajqGAhyAIgiBiFKaqYB5vabEKckuLsrQIgiAIgoh7SHjQISQ8SBAEQTilvIQHb652NyopHoUHWQnWnn477q9vdEuLIAiCIGIVlQEKPcPjBLqlRRAEQRBE3EMzPARBEAQRqzAGwKsOT8WY4aGAhyAIgiBiFKYyMI+3tCrKo7wU8LiERMRiyzcWROC8+MbCPoiUbyzsv0j5xsL+i5RvzAgPMhXeZ3goLT3uePXVV5GZmYmqVauiRYsW+OSTTyLdJIIgCIKIOWLxelphAp63334bWVlZGDduHHbs2IG//vWv6NatG44cORLpphEEQRCEK5jKwvIJhVi9nlaYgCcvLw/9+/fHI488goYNG2LmzJnIyMjArFmzIt00giAIgnAHU8PzCYFYvZ5WCOHBkpISVK9eHe+88w7+9re/6cuHDh2KnTt3YsOGDUE+xcXFKC4u1r8XFRXh0ksvxdGjR+NamIkgCILwzsmTJ5GRkYHffvsNycnJZVJ+cnIybsStqITKnso6h7PYhI+Crm9JSUlISkri1nVzPY0WKsRDy//73/9QWlqK1NRUbnlqaioKCwstfXJzc/Hss88GLc/IyCiTNhIEQRDxx++//14mAU+VKlWQlpaGTYUfhaW88847L+j6NnHiRGRnZ3PL3FxPo4UKEfBoKIrCfWeMBS3TGDt2LIYPH65//+2333DZZZfhyJEjZXLwRgLtF0i8zVpRv2KHeOwTEJ/9isc+AWXXL8YYfv/9d6Snp4etTCNVq1ZFQUEBSkpKwlKe1fXQPLtjJJTrabRQIQKeiy66CImJiUHR5/Hjx4OiVA2rqTwASE5OjquTHQDOP//8uOsTQP2KJeKxT0B89ise+wSUTb/K+sdx1apVUbVq1TKtw4yb62m0UCEeWq5SpQpatGiB1atXc8tXr16Ntm3bRqhVBEEQBBFbxPL1tELM8ADA8OHD0bdvX7Rs2RJt2rTB3LlzceTIETz22GORbhpBEARBxAyxej2tMAHP3XffjV9++QWTJk3CsWPH0LhxY3z00Ue47LLLHPknJSVh4sSJ0nuasUY89gmgfsUS8dgnID77FY99AuK3X2WJ1+tppKgQaekEQRAEQVRsKsQzPARBEARBVGwo4CEIgiAIIu6hgIcgCIIgiLiHAh6CIAiCIOIeCngc8OqrryIzMxNVq1ZFixYt8Mknn0S6SUJyc3Nx3XXXoWbNmqhduzZ69eqF/fv3c+swxpCdnY309HRUq1YN7du3x969e7l1iouLMXjwYFx00UWoUaMGevbsiR9++KE8uyIkNzcXiqIgKytLXxarffrxxx9x//33o1atWqhevTquueYabNu2TbfHYr/OnTuH8ePHIzMzE9WqVUO9evUwadIkqGrgBYWx0K+NGzeiR48eSE9Ph6IoeP/99zl7uPpw4sQJ9O3bF8nJyUhOTkbfvn3x22+/lXufzp49i6eeegpNmjRBjRo1kJ6ejgceeAA//fRTVPfJrl9mBg4cCEVRMHPmTG55NPaLCDOMkLJkyRJWuXJlNm/ePLZv3z42dOhQVqNGDXb48OFIN82Srl27stdff53t2bOH7dy5k912223s0ksvZadOndLXee6551jNmjXZu+++y3bv3s3uvvtuVqdOHXby5El9nccee4xdfPHFbPXq1Wz79u2sQ4cOrFmzZuzcuXOR6JbO1q1bWd26dVnTpk3Z0KFD9eWx2Kdff/2VXXbZZezBBx9kn3/+OSsoKGBr1qxh3333nb5OLPZr8uTJrFatWuw///kPKygoYO+88w4777zz2MyZM/V1YqFfH330ERs3bhx79913GQC2dOlSzh6uPtxyyy2scePGbPPmzWzz5s2scePGrHv37uXep99++4116tSJvf322+ybb75hW7ZsYa1atWItWrTgyoi2Ptn1y8jSpUtZs2bNWHp6OsvPz4/6fhHhhQIeG66//nr22GOPccuuuuoqNmbMmAi1KDSOHz/OALANGzYwxhhTVZWlpaWx5557Tl/nzJkzLDk5mc2ePZsx5hv4KleuzJYsWaKv8+OPP7KEhAS2YsWK8u2Agd9//501aNCArV69mrVr104PeGK1T0899RS78cYbhfZY7ddtt93GHn74YW7ZHXfcwe6//37GWGz2y3wRDVcf9u3bxwCwzz77TF9ny5YtDAD75ptvyrVPVmzdupUB0H/gRXufGBP364cffmAXX3wx27NnD7vsssu4gCcW+kV4h25pSSgpKcG2bdvQpUsXbnmXLl2wefPmCLUqNIqKigAAKSkpAICCggIUFhZyfUpKSkK7du30Pm3btg1nz57l1klPT0fjxo0j2u9BgwbhtttuQ6dOnbjlsdqnDz74AC1btsRdd92F2rVro3nz5pg3b55uj9V+3Xjjjfj4449x4MABAMCuXbuwadMm3HrrrQBit19GwtWHLVu2IDk5Ga1atdLXad26NZKTk6Oin0VFRVAUBRdccAGA2O2Tqqro27cvRo0ahUaNGgXZY7VfRGhUGKVlN/zvf/9DaWlp0AvRUlNTg16cFo0wxjB8+HDceOONaNy4MQDo7bbq0+HDh/V1qlSpggsvvDBonUj1e8mSJdi+fTu++OKLIFus9ungwYOYNWsWhg8fjqeffhpbt27FkCFDkJSUhAceeCBm+/XUU0+hqKgIV111FRITE1FaWoopU6bg3nvvBRC7+8tIuPpQWFiI2rVrB5Vfu3btiPfzzJkzGDNmDPr06aO/VDNW+zR16lRUqlQJQ4YMsbTHar+I0KCAxwHmV94zxoKWRSNPPvkkvvrqK2zatCnI5qZPker30aNHMXToUKxatUr6ZuBY6hPg+9XZsmVL5OTkAACaN2+OvXv3YtasWXjggQf09WKtX2+//TYWLVqExYsXo1GjRti5cyeysrKQnp6Ofv366evFWr+sCEcfrNaPdD/Pnj2Le+65B6qq4tVXX7VdP5r7tG3bNrzwwgvYvn17yPVHc7+I0KFbWhIuuugiJCYmBkXvx48fD/plF20MHjwYH3zwAdatW4dLLrlEX56WlgYA0j6lpaWhpKQEJ06cEK5Tnmzbtg3Hjx9HixYtUKlSJVSqVAkbNmzAiy++iEqVKultiqU+AUCdOnVw9dVXc8saNmyII0eOAIjNfQUAo0aNwpgxY3DPPfegSZMm6Nu3L4YNG4bc3FwAsdsvI+HqQ1paGv773/8Glf/zzz9HrJ9nz55F7969UVBQgNWrV+uzO0Bs9umTTz7B8ePHcemll+rjx+HDhzFixAjUrVsXQGz2iwgdCngkVKlSBS1atMDq1au55atXr0bbtm0j1Co5jDE8+eSTeO+997B27VpkZmZy9szMTKSlpXF9KikpwYYNG/Q+tWjRApUrV+bWOXbsGPbs2RORfnfs2BG7d+/Gzp079U/Lli1x3333YefOnahXr17M9QkAbrjhhiDJgAMHDugv4IvFfQUAf/75JxIS+KElMTFRT0uP1X4ZCVcf2rRpg6KiImzdulVf5/PPP0dRUVFE+qkFO99++y3WrFmDWrVqcfZY7FPfvn3x1VdfceNHeno6Ro0ahZUrVwKIzX4RLijvp6RjDS0tff78+Wzfvn0sKyuL1ahRgx06dCjSTbPk8ccfZ8nJyWz9+vXs2LFj+ufPP//U13nuuedYcnIye++999ju3bvZvffea5lOe8kll7A1a9aw7du3s5tvvjkq0tI1jFlajMVmn7Zu3coqVarEpkyZwr799lv25ptvsurVq7NFixbp68Riv/r168cuvvhiPS39vffeYxdddBEbPXq0vk4s9Ov3339nO3bsYDt27GAAWF5eHtuxY4eesRSuPtxyyy2sadOmbMuWLWzLli2sSZMmZZbqLOvT2bNnWc+ePdkll1zCdu7cyY0fxcXFUdsnu35ZYc7SitZ+EeGFAh4HvPLKK+yyyy5jVapUYddee62e4h2NALD8vP766/o6qqqyiRMnsrS0NJaUlMRuuukmtnv3bq6c06dPsyeffJKlpKSwatWqse7du7MjR46Uc2/EmAOeWO3TsmXLWOPGjVlSUhK76qqr2Ny5czl7LPbr5MmTbOjQoezSSy9lVatWZfXq1WPjxo3jLpqx0K9169ZZnkv9+vULax9++eUXdt9997GaNWuymjVrsvvuu4+dOHGi3PtUUFAgHD/WrVsXtX2y65cVVgFPNPaLCC8KY4yVx0wSQRAEQRBEpKBneAiCIAiCiHso4CEIgiAIIu6hgIcgCIIgiLiHAh6CIAiCIOIeCngIgiAIgoh7KOAhCIIgCCLuoYCHIAiCIIi4hwIegiAIgiDiHgp4CIIgCIKIeyjgIQiCIAgi7qGAhyAIgiCIuIcCHoIgONq3b48hQ4Zg9OjRSElJQVpaGrKzswEA69evR5UqVfDJJ5/o68+YMQMXXXQRjh07pvs/+eSTePLJJ3HBBRegVq1aGD9+POi1fQRBRBIKeAiCCOKNN95AjRo18Pnnn2PatGmYNGkSVq9ejfbt2yMrKwt9+/ZFUVERdu3ahXHjxmHevHmoU6cO51+pUiV8/vnnePHFF5Gfn4/XXnstgj0iCKKiQ29LJwiCo3379igtLeVmca6//nrcfPPNeO6551BSUoLWrVujQYMG2Lt3L9q0aYN58+Zx/sePH8fevXuhKAoAYMyYMfjggw+wb9++cu8PQRAEQDM8BEFY0LRpU+57nTp1cPz4cQBAlSpVsGjRIrz77rs4ffo0Zs6cGeTfunVrPdgBgDZt2uDbb79FaWlpmbabIAhCBAU8BEEEUblyZe67oihQVVX/vnnzZgDAr7/+il9//bVc20YQBOEGCngIggiJ77//HsOGDcO8efPQunVrPPDAA1wwBACfffZZ0PcGDRogMTGxPJtKEAShQwEPQRCOKS0tRd++fdGlSxc89NBDeP3117Fnzx7MmDGDW+/o0aMYPnw49u/fj7feegsvvfQShg4dGqFWEwRBAJUi3QCCIGKHKVOm4NChQ1i2bBkAIC0tDa+99hp69+6Nzp0745prrgEAPPDAAzh9+jSuv/56JCYmYvDgwXj00Ucj2HKCICo6lKVFEERYad++Pa655hrLh5kJgiAiBd3SIgiCIAgi7qGAhyAIgiCIuIduaREEQRAEEffQDA9BEARBEHEPBTwEQRAEQcQ9FPAQBEEQBBH3UMBDEARBEETcQwEPQRAEQRBxDwU8BEEQBEHEPRTwEARBEAQR91DAQxAEQRBE3PP/AQoIQQCbVxl/AAAAAElFTkSuQmCC", - "text/plain": [ - "
        " - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Define a new angle field\n", - "hgrid[\"angle_dx_rm6\"] = xr.full_like(hgrid.angle_dx, np.nan)\n", - "hgrid[\"angle_dx_rm6\"].attrs[\"units\"] = \"degrees\"\n", - "hgrid[\"angle_dx_rm6\"][t_points] = hgrid[\"t_angle_dx_mom6\"].values\n", - "hgrid[\"angle_dx_rm6\"].plot()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Apply XGCM Interpolation" - ] - }, - { - "cell_type": "code", - "execution_count": 47, - "metadata": {}, - "outputs": [], - "source": [ - "import xgcm" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": 104, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " Size: 18MB\n", - "Dimensions: (nyp: 780, nxp: 740, nyp_q: 781, nxp_q: 741)\n", - "Coordinates:\n", - " xh (nyp, nxp) float64 5MB -97.96 -97.88 -97.79 ... -37.58 -37.49\n", - " yh (nyp, nxp) float64 5MB 5.243 5.243 5.243 ... 58.34 58.34 58.35\n", - " xq (nyp_q, nxp_q) float64 5MB -98.0 -97.92 -97.83 ... -37.54 -37.45\n", - " yq (nyp_q, nxp_q) float64 5MB 5.201 5.201 5.201 ... 58.37 58.37 58.38\n", - "Dimensions without coordinates: nyp, nxp, nyp_q, nxp_q\n", - "Data variables:\n", - " *empty*\n" - ] - }, - { - "ename": "ValueError", - "evalue": "Input `xh` (for the `center` position on axis `X`) is not a dimension in the input datasets `ds`.", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[104], line 17\u001b[0m\n\u001b[1;32m 14\u001b[0m \u001b[38;5;28mprint\u001b[39m(xgcm_input)\n\u001b[1;32m 15\u001b[0m coords_mom6\u001b[38;5;241m=\u001b[39m{\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mX\u001b[39m\u001b[38;5;124m'\u001b[39m:{\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mcenter\u001b[39m\u001b[38;5;124m'\u001b[39m:\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mxh\u001b[39m\u001b[38;5;124m'\u001b[39m, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mouter\u001b[39m\u001b[38;5;124m'\u001b[39m:\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mxq\u001b[39m\u001b[38;5;124m'\u001b[39m}, \n\u001b[1;32m 16\u001b[0m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mY\u001b[39m\u001b[38;5;124m'\u001b[39m:{\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mcenter\u001b[39m\u001b[38;5;124m'\u001b[39m:\u001b[38;5;124m'\u001b[39m\u001b[38;5;124myh\u001b[39m\u001b[38;5;124m'\u001b[39m,\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mouter\u001b[39m\u001b[38;5;124m'\u001b[39m:\u001b[38;5;124m'\u001b[39m\u001b[38;5;124myq\u001b[39m\u001b[38;5;124m'\u001b[39m }}\n\u001b[0;32m---> 17\u001b[0m xgcm_hgrid \u001b[38;5;241m=\u001b[39m \u001b[43mxgcm\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mGrid\u001b[49m\u001b[43m(\u001b[49m\u001b[43mxgcm_input\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\n\u001b[1;32m 18\u001b[0m \u001b[43m \u001b[49m\u001b[43mcoords\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcoords_mom6\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\n\u001b[1;32m 19\u001b[0m \u001b[43m \u001b[49m\u001b[43mperiodic\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m/glade/work/manishrv/conda-envs/CrocoDashDev/lib/python3.12/site-packages/xgcm/grid.py:1340\u001b[0m, in \u001b[0;36mGrid.__init__\u001b[0;34m(self, ds, check_dims, periodic, default_shifts, face_connections, coords, metrics, boundary, fill_value)\u001b[0m\n\u001b[1;32m 1336\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\n\u001b[1;32m 1337\u001b[0m \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mCould not find dimension `\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mdim\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m` (for the `\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mpos\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m` position on axis `\u001b[39m\u001b[38;5;132;01m{\u001b[39;00maxis\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m`) in input dataset.\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 1338\u001b[0m )\n\u001b[1;32m 1339\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m dim \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;129;01min\u001b[39;00m ds\u001b[38;5;241m.\u001b[39mdims:\n\u001b[0;32m-> 1340\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\n\u001b[1;32m 1341\u001b[0m \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mInput `\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mdim\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m` (for the `\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mpos\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m` position on axis `\u001b[39m\u001b[38;5;132;01m{\u001b[39;00maxis\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m`) is not a dimension in the input datasets `ds`.\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 1342\u001b[0m )\n\u001b[1;32m 1344\u001b[0m \u001b[38;5;66;03m# Convert all inputs to axes-kwarg mappings\u001b[39;00m\n\u001b[1;32m 1345\u001b[0m \u001b[38;5;66;03m# TODO We need a way here to check valid input. Maybe also in _as_axis_kwargs?\u001b[39;00m\n\u001b[1;32m 1346\u001b[0m \u001b[38;5;66;03m# Parse axis properties\u001b[39;00m\n\u001b[1;32m 1347\u001b[0m boundary \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_as_axis_kwarg_mapping(boundary, axes\u001b[38;5;241m=\u001b[39mall_axes)\n", - "\u001b[0;31mValueError\u001b[0m: Input `xh` (for the `center` position on axis `X`) is not a dimension in the input datasets `ds`." - ] - } - ], - "source": [ - "# Define tpointx (xh) tpoint y (yh) qpoint x (xq) and qpoint y (yq) Hgrid to add XGCM required variables\n", - "xh_points = np.arange(kp2, len(hgrid.x.nxp),k)\n", - "yh_points = np.arange(kp2, len(hgrid.x.nyp),k)\n", - "xq_points = np.arange(0, len(hgrid.x.nxp),k)\n", - "yq_points = np.arange(0, len(hgrid.x.nyp),k)\n", - "xgcm_input = xr.Dataset(\n", - " coords = {\n", - " \"xh\": ((\"nyp\",\"nxp\"),tlon.values),\n", - " \"yh\": ((\"nyp\",\"nxp\"),tlat.values),\n", - " \"xq\": ((\"nyp_q\",\"nxp_q\"),qlon.values),\n", - " \"yq\": ((\"nyp_q\",\"nxp_q\"),qlat.values),\n", - " }\n", - ")\n", - "print(xgcm_input)\n", - "coords_mom6={'X':{'center':'xh', 'outer':'xq'}, \n", - " 'Y':{'center':'yh','outer':'yq' }}\n", - "xgcm_hgrid = xgcm.Grid(xgcm_input, \n", - " coords=coords_mom6, \n", - " periodic = False)" - ] - }, - { - "cell_type": "code", - "execution_count": 49, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "\n", - "X Axis (not periodic, boundary=None):\n", - " * center lonh --> outer\n", - " * outer lonq --> center\n", - "Y Axis (not periodic, boundary=None):\n", - " * center lath --> outer\n", - " * outer latq --> center" - ] - }, - "execution_count": 49, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# From Tutorial\n", - "grid = xgcm.Grid(ocean_geo, coords={'X': {'center': 'lonh', 'outer': 'lonq'},\n", - " 'Y': {'center': 'lath', 'outer': 'latq'}}, periodic = False)\n", - "grid" - ] - }, - { - "cell_type": "code", - "execution_count": 50, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
        \n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "
        <xarray.DataArray 'y' (lath: 780, lonh: 740)> Size: 5MB\n",
-       "array([[0.        , 0.        , 0.        , ..., 0.        , 0.        ,\n",
-       "        0.        ],\n",
-       "       [0.        , 0.        , 0.        , ..., 0.        , 0.        ,\n",
-       "        0.        ],\n",
-       "       [0.        , 0.        , 0.        , ..., 0.        , 0.        ,\n",
-       "        0.        ],\n",
-       "       ...,\n",
-       "       [4.43651643, 4.47489525, 4.5132071 , ..., 4.40963338, 4.37648025,\n",
-       "        4.34327766],\n",
-       "       [4.45746382, 4.49601954, 4.53450787, ..., 4.429975  , 4.39669398,\n",
-       "        4.36336333],\n",
-       "       [4.47848207, 4.51721524, 4.5558806 , ..., 4.45038282, 4.41697365,\n",
-       "        4.38351466]])\n",
-       "Coordinates:\n",
-       "  * lath     (lath) float64 6kB 5.243 5.326 5.409 5.492 ... 53.82 53.86 53.89\n",
-       "  * lonh     (lonh) float64 6kB -97.96 -97.88 -97.79 ... -36.54 -36.46 -36.38
        " - ], - "text/plain": [ - " Size: 5MB\n", - "array([[0. , 0. , 0. , ..., 0. , 0. ,\n", - " 0. ],\n", - " [0. , 0. , 0. , ..., 0. , 0. ,\n", - " 0. ],\n", - " [0. , 0. , 0. , ..., 0. , 0. ,\n", - " 0. ],\n", - " ...,\n", - " [4.43651643, 4.47489525, 4.5132071 , ..., 4.40963338, 4.37648025,\n", - " 4.34327766],\n", - " [4.45746382, 4.49601954, 4.53450787, ..., 4.429975 , 4.39669398,\n", - " 4.36336333],\n", - " [4.47848207, 4.51721524, 4.5558806 , ..., 4.45038282, 4.41697365,\n", - " 4.38351466]])\n", - "Coordinates:\n", - " * lath (lath) float64 6kB 5.243 5.326 5.409 5.492 ... 53.82 53.86 53.89\n", - " * lonh (lonh) float64 6kB -97.96 -97.88 -97.79 ... -36.54 -36.46 -36.38" - ] - }, - "execution_count": 50, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Set up angle data...\n", - "t_angles = xr.DataArray(\n", - " angles_arr_v2,\n", - " dims=[\"lath\", \"lonh\"],\n", - " coords={\n", - " \"lath\": ocean_geo.lath.values,\n", - " \"lonh\": ocean_geo.lonh.values,\n", - " }\n", - ")\n", - "\n", - "t_angles\n" - ] - }, - { - "cell_type": "code", - "execution_count": 90, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/glade/work/manishrv/conda-envs/CrocoDashDev/lib/python3.12/site-packages/xgcm/grid_ufunc.py:832: FutureWarning: The return type of `Dataset.dims` will be changed to return a set of dimension names in future, in order to be more consistent with `DataArray.dims`. To access a mapping from dimension names to lengths, please use `Dataset.sizes`.\n", - " out_dim: grid._ds.dims[out_dim] for arg in out_core_dims for out_dim in arg\n" - ] - } - ], - "source": [ - "# Interpolate....\n", - "angle_ds = xr.Dataset()\n", - "angle_ds[\"angle_dx_rm6_q\"] = grid.interp(t_angles, axis=['X', 'Y'], to=\"outer\", boundary = \"extend\")\n", - "angle_ds[\"angle_dx_rm6_v\"] = grid.interp(t_angles, axis=[ 'Y'], to=\"outer\", boundary = \"extend\")\n", - "angle_ds[\"angle_dx_rm6_u\"] = grid.interp(t_angles, axis=[ 'X'], to=\"outer\", boundary = \"extend\")" - ] - }, - { - "cell_type": "code", - "execution_count": 91, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
        \n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "
        <xarray.Dataset> Size: 14MB\n",
-       "Dimensions:         (latq: 781, lonq: 741, lonh: 740, lath: 780)\n",
-       "Coordinates:\n",
-       "  * latq            (latq) float64 6kB 5.201 5.284 5.367 ... 53.84 53.87 53.91\n",
-       "  * lonq            (lonq) float64 6kB -98.0 -97.92 -97.83 ... -36.42 -36.33\n",
-       "  * lonh            (lonh) float64 6kB -97.96 -97.88 -97.79 ... -36.46 -36.38\n",
-       "  * lath            (lath) float64 6kB 5.243 5.326 5.409 ... 53.82 53.86 53.89\n",
-       "Data variables:\n",
-       "    angle_dx_rm6_q  (latq, lonq) float64 5MB 0.0 0.0 0.0 0.0 ... 4.434 4.4 4.384\n",
-       "    angle_dx_rm6_v  (latq, lonh) float64 5MB 0.0 0.0 0.0 ... 4.45 4.417 4.384\n",
-       "    angle_dx_rm6_u  (lath, lonq) float64 5MB 0.0 0.0 0.0 0.0 ... 4.434 4.4 4.384
        " - ], - "text/plain": [ - " Size: 14MB\n", - "Dimensions: (latq: 781, lonq: 741, lonh: 740, lath: 780)\n", - "Coordinates:\n", - " * latq (latq) float64 6kB 5.201 5.284 5.367 ... 53.84 53.87 53.91\n", - " * lonq (lonq) float64 6kB -98.0 -97.92 -97.83 ... -36.42 -36.33\n", - " * lonh (lonh) float64 6kB -97.96 -97.88 -97.79 ... -36.46 -36.38\n", - " * lath (lath) float64 6kB 5.243 5.326 5.409 ... 53.82 53.86 53.89\n", - "Data variables:\n", - " angle_dx_rm6_q (latq, lonq) float64 5MB 0.0 0.0 0.0 0.0 ... 4.434 4.4 4.384\n", - " angle_dx_rm6_v (latq, lonh) float64 5MB 0.0 0.0 0.0 ... 4.45 4.417 4.384\n", - " angle_dx_rm6_u (lath, lonq) float64 5MB 0.0 0.0 0.0 0.0 ... 4.434 4.4 4.384" - ] - }, - "execution_count": 91, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "angle_ds" - ] - }, - { - "cell_type": "code", - "execution_count": 92, - "metadata": {}, - "outputs": [], - "source": [ - "hgrid[\"angle_dx_rm6\"][u_points] = angle_ds[\"angle_dx_rm6_u\"].values\n", - "hgrid[\"angle_dx_rm6\"][v_points] = angle_ds[\"angle_dx_rm6_v\"].values\n", - "hgrid[\"angle_dx_rm6\"][q_points] = angle_ds[\"angle_dx_rm6_q\"].values" - ] - }, - { - "cell_type": "code", - "execution_count": 93, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 93, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
        " - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "hgrid['angle_dx_rm6'].plot()" - ] - }, - { - "cell_type": "code", - "execution_count": 94, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
        " - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "angle_diff = hgrid[\"angle_dx\"] - hgrid[\"angle_dx_rm6\"]\n", - "plt.figure(figsize=(8, 6))\n", - "plt.imshow(angle_diff)\n", - "plt.colorbar()\n", - "plt.title(\"Difference between caluculated MOM6 angle and angle_dx from Hgrid angle_dx\")\n", - "plt.show() " - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
        \n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "
        <xarray.DataArray (nyp: 1560, nxp: 1380)> Size: 17MB\n",
-       "array([[0.0018886 , 0.0018886 , 0.0018886 , ..., 0.0018886 , 0.0018886 ,\n",
-       "        0.0018886 ],\n",
-       "       [0.00190363, 0.00190363, 0.00190363, ..., 0.00190363, 0.00190363,\n",
-       "        0.00190363],\n",
-       "       [0.00191865, 0.00191865, 0.00191865, ..., 0.00191865, 0.00191865,\n",
-       "        0.00191865],\n",
-       "       ...,\n",
-       "       [0.02399983, 0.02397845, 0.02397953, ..., 0.01129944, 0.01130202,\n",
-       "        0.01129223],\n",
-       "       [0.02400675, 0.02398527, 0.02398634, ..., 0.01128624, 0.01128885,\n",
-       "        0.01127906],\n",
-       "       [0.0240375 , 0.02401598, 0.02401707, ..., 0.01128954, 0.01129214,\n",
-       "        0.01128232]])\n",
-       "Dimensions without coordinates: nyp, nxp
        " - ], - "text/plain": [ - " Size: 17MB\n", - "array([[0.0018886 , 0.0018886 , 0.0018886 , ..., 0.0018886 , 0.0018886 ,\n", - " 0.0018886 ],\n", - " [0.00190363, 0.00190363, 0.00190363, ..., 0.00190363, 0.00190363,\n", - " 0.00190363],\n", - " [0.00191865, 0.00191865, 0.00191865, ..., 0.00191865, 0.00191865,\n", - " 0.00191865],\n", - " ...,\n", - " [0.02399983, 0.02397845, 0.02397953, ..., 0.01129944, 0.01130202,\n", - " 0.01129223],\n", - " [0.02400675, 0.02398527, 0.02398634, ..., 0.01128624, 0.01128885,\n", - " 0.01127906],\n", - " [0.0240375 , 0.02401598, 0.02401707, ..., 0.01128954, 0.01129214,\n", - " 0.01128232]])\n", - "Dimensions without coordinates: nyp, nxp" - ] - }, - "execution_count": 86, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Looks like the interpolation is working reasonably except in the boundaries, we need to choose a specific angle" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "CrocoDashDev", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.12.7" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/tests/test_config.py b/tests/test_config.py index c5621418..ba47521c 100644 --- a/tests/test_config.py +++ b/tests/test_config.py @@ -6,7 +6,7 @@ import shutil -def test_write_config(): +def test_write_config(tmp_path): expt_name = "testing" latitude_extent = [16.0, 27] @@ -17,6 +17,7 @@ def test_write_config(): ## Place where all your input files go input_dir = Path( os.path.join( + tmp_path, expt_name, "inputs", ) @@ -25,6 +26,7 @@ def test_write_config(): ## Directory where you'll run the experiment from run_dir = Path( os.path.join( + tmp_path, expt_name, "run_files", ) @@ -80,7 +82,7 @@ def test_write_config(): shutil.rmtree(data_path) -def test_load_config(): +def test_load_config(tmp_path): expt_name = "testing" @@ -92,6 +94,7 @@ def test_load_config(): ## Place where all your input files go input_dir = Path( os.path.join( + tmp_path, expt_name, "inputs", ) @@ -99,10 +102,11 @@ def test_load_config(): ## Directory where you'll run the experiment from run_dir = Path( + tmp_path, os.path.join( expt_name, "run_files", - ) + ), ) data_path = Path("data") for path in (run_dir, input_dir, data_path): @@ -122,9 +126,11 @@ def test_load_config(): mom_input_dir=input_dir, toolpath_dir="", ) - path = "testing_config.json" + path = tmp_path / "testing_config.json" config_expt = expt.write_config_file(path) - new_expt = rmom6.create_experiment_from_config(os.path.join(path)) + new_expt = rmom6.create_experiment_from_config( + os.path.join(path), mom_input_folder=tmp_path, mom_run_folder=tmp_path + ) assert str(new_expt) == str(expt) print(new_expt.vgrid) print(expt.vgrid) @@ -136,8 +142,3 @@ def test_load_config(): assert os.path.exists(new_expt.mom_input_dir / "hgrid.nc") & os.path.exists( new_expt.mom_input_dir / "vcoord.nc" ) - shutil.rmtree(run_dir) - shutil.rmtree(input_dir) - shutil.rmtree(data_path) - shutil.rmtree(new_expt.mom_run_dir) - shutil.rmtree(new_expt.mom_input_dir) diff --git a/tests/test_expt_class.py b/tests/test_expt_class.py index aff3a4b8..b8f7cde4 100644 --- a/tests/test_expt_class.py +++ b/tests/test_expt_class.py @@ -17,8 +17,6 @@ "number_vertical_layers", "layer_thickness_ratio", "depth", - "mom_run_dir", - "mom_input_dir", "toolpath_dir", "hgrid_type", ), @@ -31,8 +29,6 @@ 5, 1, 1000, - "rundir/", - "inputdir/", "toolpath", "even_spacing", ), @@ -46,12 +42,12 @@ def test_setup_bathymetry( number_vertical_layers, layer_thickness_ratio, depth, - mom_run_dir, - mom_input_dir, toolpath_dir, hgrid_type, tmp_path, ): + mom_run_dir = tmp_path / "rundir" + mom_input_dir = tmp_path / "inputdir" expt = experiment( longitude_extent=longitude_extent, latitude_extent=latitude_extent, @@ -166,8 +162,7 @@ def generate_silly_coords( coords = {"silly_lat": silly_lat, "silly_lon": silly_lon, "silly_depth": silly_depth} -mom_run_dir = "rundir/" -mom_input_dir = "inputdir/" + toolpath_dir = "toolpath" hgrid_type = "even_spacing" @@ -198,8 +193,6 @@ def generate_silly_coords( "number_vertical_layers", "layer_thickness_ratio", "depth", - "mom_run_dir", - "mom_input_dir", "toolpath_dir", "hgrid_type", ), @@ -212,8 +205,6 @@ def generate_silly_coords( number_vertical_layers, layer_thickness_ratio, depth, - "rundir/", - "inputdir/", "toolpath", "even_spacing", ), @@ -227,8 +218,6 @@ def test_ocean_forcing( number_vertical_layers, layer_thickness_ratio, depth, - mom_run_dir, - mom_input_dir, toolpath_dir, hgrid_type, temp_dataarray_initial_condition, @@ -246,7 +235,8 @@ def test_ocean_forcing( "silly_lon": silly_lon, "silly_depth": silly_depth, } - + mom_run_dir = tmp_path / "rundir" + mom_input_dir = tmp_path / "inputdir" expt = experiment( longitude_extent=longitude_extent, latitude_extent=latitude_extent, @@ -332,8 +322,6 @@ def test_ocean_forcing( "number_vertical_layers", "layer_thickness_ratio", "depth", - "mom_run_dir", - "mom_input_dir", "toolpath_dir", "hgrid_type", ), @@ -346,8 +334,6 @@ def test_ocean_forcing( 5, 1, 1000, - "rundir/", - "inputdir/", "toolpath", "even_spacing", ), @@ -361,8 +347,6 @@ def test_rectangular_boundaries( number_vertical_layers, layer_thickness_ratio, depth, - mom_run_dir, - mom_input_dir, toolpath_dir, hgrid_type, tmp_path, @@ -443,7 +427,8 @@ def test_rectangular_boundaries( ) eastern_boundary.to_netcdf(tmp_path / "east_unprocessed.nc") eastern_boundary.close() - + mom_run_dir = tmp_path / "rundir" + mom_input_dir = tmp_path / "inputdir" expt = experiment( longitude_extent=longitude_extent, latitude_extent=latitude_extent, diff --git a/tests/test_tides_and_parameter.py b/tests/test_tides_and_parameter.py index e6a3faa7..8b1e0f99 100644 --- a/tests/test_tides_and_parameter.py +++ b/tests/test_tides_and_parameter.py @@ -20,8 +20,8 @@ @pytest.fixture(scope="module") def dummy_tidal_data(): - nx = 2160 - ny = 1081 + nx = 100 + ny = 100 nc = 15 nct = 4 @@ -156,8 +156,8 @@ def dummy_bathymetry_data(): return bathymetry -@pytest.fixture(scope="module") -def full_expt_setup(dummy_bathymetry_data): +@pytest.fixture() +def full_expt_setup(dummy_bathymetry_data, tmp_path): expt_name = "testing" @@ -169,6 +169,7 @@ def full_expt_setup(dummy_bathymetry_data): ## Place where all your input files go input_dir = Path( os.path.join( + tmp_path, expt_name, "inputs", ) @@ -177,11 +178,12 @@ def full_expt_setup(dummy_bathymetry_data): ## Directory where you'll run the experiment from run_dir = Path( os.path.join( + tmp_path, expt_name, "run_files", ) ) - data_path = Path("data") + data_path = Path(tmp_path, "data") for path in (run_dir, input_dir, data_path): os.makedirs(str(path), exist_ok=True) bathy_path = data_path / "bathymetry.nc" From 04d625de8c5bac8ecd804cdaa773a8ce14736d0a Mon Sep 17 00:00:00 2001 From: manishvenu Date: Thu, 12 Dec 2024 13:19:23 -0700 Subject: [PATCH 45/87] Change name of docker docs --- docs/{docker_image_testing.md => docker_image_dev.md} | 2 +- docs/index.rst | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) rename docs/{docker_image_testing.md => docker_image_dev.md} (96%) diff --git a/docs/docker_image_testing.md b/docs/docker_image_dev.md similarity index 96% rename from docs/docker_image_testing.md rename to docs/docker_image_dev.md index 474dc5d6..5c20030a 100644 --- a/docs/docker_image_testing.md +++ b/docs/docker_image_dev.md @@ -29,7 +29,7 @@ Then, we need to build the image, tag it, and push it ``` docker build -t my-custom-image . # IN THE DIRECTORY WITH THE DOCKERFILE docker tag my-custom-image ghcr.io/cosima/regional-test-env: -docker ghcr.io/cosima/regional-test-env: +docker push ghcr.io/cosima/regional-test-env: ``` diff --git a/docs/index.rst b/docs/index.rst index fdbaa54e..d8f614ca 100644 --- a/docs/index.rst +++ b/docs/index.rst @@ -94,7 +94,7 @@ The bibtex entry for the paper is: angle_calc api contributing - docker_image_testing + docker_image_dev Indices and tables From c50b66854055f82cfc6c0cef1a95130fbeecb961 Mon Sep 17 00:00:00 2001 From: manishvenu Date: Thu, 12 Dec 2024 14:20:50 -0700 Subject: [PATCH 46/87] Adjust docker image to crocodile one --- .github/workflows/testing.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/testing.yml b/.github/workflows/testing.yml index da83f540..efe9811b 100644 --- a/.github/workflows/testing.yml +++ b/.github/workflows/testing.yml @@ -18,7 +18,7 @@ jobs: testing: needs: formatting runs-on: ubuntu-latest - container: manishvenu1/rm6_with_curvilinear:v2 + container: ghcr.io/crocodile-cesm/crocodile_rm6_test_env:latest defaults: run: shell: bash -el {0} From a2b961a60210949b51b1870558c60d3d91a90c8b Mon Sep 17 00:00:00 2001 From: manishvenu Date: Mon, 16 Dec 2024 18:15:06 -0700 Subject: [PATCH 47/87] Step 1: Setup Framework Tidal Regridding Nans/LandMask BugFix --- regional_mom6/regridding.py | 85 +++++++++++++++++++++++++++++++++++++ 1 file changed, 85 insertions(+) diff --git a/regional_mom6/regridding.py b/regional_mom6/regridding.py index adebb7a5..6822eef3 100644 --- a/regional_mom6/regridding.py +++ b/regional_mom6/regridding.py @@ -443,6 +443,91 @@ def generate_layer_thickness( return ds +def get_boundary_mask( + hgrid: xr.Dataset, bathy: xr.Dataset, side: str, segment_name: str, minimum_depth=0 +) -> np.ndarray: + """ + Mask out the boundary conditions based on the bathymetry. We don't want to have boundary conditions on land. + Parameters + ---------- + hgrid : xr.Dataset + The hgrid dataset + bathy : xr.Dataset + The bathymetry dataset + side : str + The side of the boundary, "north", "south", "east", or "west" + segment_name : str + The segment name + minimum_depth : float, optional + The minimum depth to consider land, by default 0 + Returns + ------- + np.Array + The boundary mask + """ + + # Hide the bathy as an angle field so we can take advantage of the coords function to get the boundary points. + bathy = bathy.rename({"lath": "nyp", "lonh": "nxp"}) + + # Copy Hgrid + bathy_2 = hgrid.copy(deep=True) + + # Create new depth field + bathy_2["depth"] = bathy_2["angle_dx"] + bathy_2["depth"][:, :] = np.nan + + # Fill at t_points (what bathy is determined at) + ds_t = get_hgrid_arakawa_c_points(hgrid, "t") + bathy_2["depth"][ds_t.t_points_y.values, ds_t.t_points_x.values] = bathy.depth + + bathy_2_coords = coords( + bathy_2, + side, + segment_name, + angle_variable_name="depth", + coords_at_t_points=True, + ) + + # Get the Boundary Depth + bathy_2_coords["boundary_depth"] = bathy_2_coords["angle"] + land = 0 + ocean = 1.0 + boundary_mask = np.full(np.shape(coords(hgrid, side, segment_name).angle), ocean) + for i in range(len(bathy_2_coords["boundary_depth"])): + if bathy_2_coords["boundary_depth"][i] <= minimum_depth: + # The points to the left and right of this t-point are land points + boundary_mask[(i * 2) + 2] = land + boundary_mask[(i * 2) + 1] = land + boundary_mask[(i * 2)] = land + + # If the corners are nans, we convert them to ocean as well. + if np.isnan(boundary_mask[0]): + boundary_mask[0] = ocean + if np.isnan(boundary_mask[-1]): + boundary_mask[-1] = ocean + + # Looks like in the boundary between land and ocean - in NWA for example - we basically need to remove 3 points closest to ocean as a buffer. + # Search for intersections + beaches_before = [] + beaches_after = [] + for index in range(1, len(boundary_mask) - 1): + if boundary_mask[index - 1] == land and boundary_mask[index] == ocean: + beaches_before.append(index) + elif boundary_mask[index + 1] == land and boundary_mask[index] == ocean: + beaches_after.append(index) + for beach in beaches_before: + for i in range(3): + if beach - 1 - i >= 0: + boundary_mask[beach - 1 - i] = ocean + for beach in beaches_before: + for i in range(3): + if beach + 1 + i >= 0: + boundary_mask[beach + 1 + i] = ocean + boundary_mask[np.where(boundary_mask == land)] = np.nan + + return boundary_mask + + def generate_encoding( ds: xr.Dataset, encoding_dict, default_fill_value=netCDF4.default_fillvals["f8"] ) -> xr.Dataset: From 9287030815f03b836c20f2162747fa86a9e57545 Mon Sep 17 00:00:00 2001 From: manishvenu Date: Tue, 17 Dec 2024 13:22:05 -0700 Subject: [PATCH 48/87] Finish setting up masking framework --- regional_mom6/regional_mom6.py | 74 ++++++++++++++++++++++++++++++++-- regional_mom6/regridding.py | 18 +++++---- 2 files changed, 81 insertions(+), 11 deletions(-) diff --git a/regional_mom6/regional_mom6.py b/regional_mom6/regional_mom6.py index 50e6af62..9ad4a1fe 100644 --- a/regional_mom6/regional_mom6.py +++ b/regional_mom6/regional_mom6.py @@ -1542,6 +1542,7 @@ def setup_ocean_state_boundaries( varnames, arakawa_grid="A", boundary_type="rectangular", + bathymetry_path=None, rotational_method=rot.RotationMethod.GIVEN_ANGLE, ): """ @@ -1558,6 +1559,8 @@ def setup_ocean_state_boundaries( arakawa_grid (Optional[str]): Arakawa grid staggering type of the boundary forcing. Either ``'A'`` (default), ``'B'``, or ``'C'``. boundary_type (Optional[str]): Type of box around region. Currently, only ``'rectangular'`` is supported. + bathymetry_path (Optional[str]): Path to the bathymetry file. Default is None, in which case the bathymetry file is assumed to be in the input directory. + rotational_method (Optional[str]): Method to use for rotating the boundary velocities. Default is 'GIVEN_ANGLE'. """ if boundary_type != "rectangular": raise ValueError( @@ -1578,6 +1581,8 @@ def setup_ocean_state_boundaries( raise ValueError( "This method only supports up to four boundaries. To set up more complex boundary shapes you can manually call the 'simple_boundary' method for each boundary." ) + if bathymetry_path is None: + bathymetry_path = self.mom_input_dir / "bathymetry.nc" # Now iterate through our four boundaries for orientation in self.boundaries: @@ -1593,6 +1598,7 @@ def setup_ocean_state_boundaries( orientation ), # A number to identify the boundary; indexes from 1 arakawa_grid=arakawa_grid, + bathymetry_path=bathymetry_path, rotational_method=rotational_method, ) @@ -1604,6 +1610,7 @@ def setup_single_boundary( segment_number, arakawa_grid="A", boundary_type="simple", + bathymetry_path=None, rotational_method=rot.RotationMethod.GIVEN_ANGLE, ): """ @@ -1624,6 +1631,8 @@ def setup_single_boundary( arakawa_grid (Optional[str]): Arakawa grid staggering type of the boundary forcing. Either ``'A'`` (default), ``'B'``, or ``'C'``. boundary_type (Optional[str]): Type of boundary. Currently, only ``'simple'`` is supported. Here 'simple' refers to boundaries that are parallel to lines of constant longitude or latitude. + bathymetry_path (Optional[str]): Path to the bathymetry file. Default is None, in which case the bathymetry file is assumed to be in the input directory. + rotational_method (Optional[str]): Method to use for rotating the boundary velocities. Default is 'GIVEN_ANGLE'. """ print("Processing {} boundary...".format(orientation), end="") @@ -1635,6 +1644,7 @@ def setup_single_boundary( raise ValueError("Only simple boundaries are supported by this method.") self.segments[orientation] = segment( hgrid=self.hgrid, + bathymetry_path=bathymetry_path, infile=path_to_bc, # location of raw boundary outfolder=self.mom_input_dir, varnames=varnames, @@ -1658,6 +1668,7 @@ def setup_boundary_tides( tpxo_velocity_filepath, tidal_constituents="read_from_expt_init", boundary_type="rectangle", + bathymetry_path=None, rotational_method=rot.RotationMethod.GIVEN_ANGLE, ): """ @@ -1668,7 +1679,8 @@ def setup_boundary_tides( tidal_filename: Name of the tpxo product that's used in the tidal_filename. Should be h_tidal_filename, u_tidal_filename tidal_constituents: List of tidal constituents to include in the regridding. Default is [0] which is the M2 constituent. boundary_type (str): Type of boundary. Currently, only rectangle is supported. Here rectangle refers to boundaries that are parallel to lines of constant longitude or latitude. - + bathymetry_path (str): Path to the bathymetry file. Default is None, in which case the bathymetry file is assumed to be in the input directory. + rotational_method (str): Method to use for rotating the tidal velocities. Default is 'GIVEN_ANGLE'. Returns: *.nc files: Regridded tidal velocity and elevation files in 'inputdir/forcing' @@ -1693,6 +1705,8 @@ def setup_boundary_tides( ) if tidal_constituents != "read_from_expt_init": self.tidal_constituents = tidal_constituents + if bathymetry_path is None: + bathymetry_path = self.mom_input_dir / "bathymetry.nc" tpxo_h = ( xr.open_dataset(Path(tpxo_elevation_filepath)) .rename({"lon_z": "lon", "lat_z": "lat", "nc": "constituent"}) @@ -1740,6 +1754,7 @@ def setup_boundary_tides( if b not in self.segments.keys(): # I.E. not set yet seg = segment( hgrid=self.hgrid, + bathymetry_path=bathymetry_path, infile=None, # location of raw boundary outfolder=self.mom_input_dir, varnames=None, @@ -2851,6 +2866,7 @@ def __init__( self, *, hgrid, + bathymetry_path, infile, outfolder, varnames, @@ -2906,6 +2922,10 @@ def __init__( self.infile = infile self.outfolder = outfolder self.hgrid = hgrid + try: + self.bathymetry = xr.open_dataset(bathymetry_path) + except: + self.bathymetry = None self.segment_name = segment_name self.repeat_year_forcing = repeat_year_forcing @@ -3376,6 +3396,32 @@ def regrid_velocity_tracers(self, rotational_method=rot.RotationMethod.GIVEN_ANG segment_out[f"{coords.attrs['parallel']}_{self.segment_name}"].size ) segment_out[f"{coords.attrs['perpendicular']}_{self.segment_name}"] = [0] + + ## Add Boundary Mask ## + if self.bathymetry is not None: + print( + "Masking to bathymetry. If you don't want this, set bathymetry_path to None in the segment class." + ) + mask = rgd.get_boundary_mask( + self.hgrid, + self.bathymetry, + self.orientation, + self.segment_name, + minimum_depth=0, + ) + if self.orientation in ["east", "west"]: + mask = mask[:, np.newaxis] + for var in segment_out.data_vars.keys(): + segment_out[var] = segment_out[var].fillna(0) + segment_out[var] = segment_out[var] * mask + else: + print( + "Warning: All NaNs filled b/c bathymetry wasn't provided to the function. Add bathymetry_path to the segment class to avoid this" + ) + segment_out = segment_out.fillna( + 0 + ) # Without bathymetry, we can't assume the nans will be allowed in Boundary Conditions + encoding_dict = { "time": {"dtype": "double"}, f"nx_{self.segment_name}": { @@ -3700,6 +3746,30 @@ def encode_tidal_files_and_output(self, ds, filename): {"lon": f"lon_{self.segment_name}", "lat": f"lat_{self.segment_name}"} ) + ## Add Boundary Mask ## + if self.bathymetry is not None: + print( + "Masking to bathymetry. If you don't want this, set bathymetry_path to None in the segment class." + ) + mask = rgd.get_boundary_mask( + self.hgrid, + self.bathymetry, + self.orientation, + self.segment_name, + minimum_depth=0, + ) + if self.orientation in ["east", "west"]: + mask = mask[:, np.newaxis] + for var in ds.data_vars.keys(): + ds[var] = ds[var].fillna(0) + ds[var] = ds[var] * mask + else: + print( + "Warning: All NaNs filled b/c bathymetry wasn't provided to the function. Add bathymetry_path to the segment class to avoid this" + ) + ds = ds.fillna(0) + # Without bathymetry, we can't assume the nans will be allowed in Boundary Conditions + ## Perform Encoding ## fname = f"{filename}_{self.segment_name}.nc" @@ -3715,8 +3785,6 @@ def encode_tidal_files_and_output(self, ds, filename): ds, encoding, default_fill_value=netCDF4.default_fillvals["f8"] ) - # Can't have nas in the land segments and such cuz it crashes - ds = ds.fillna(0) ## Export Files ## ds.to_netcdf( Path(self.outfolder / "forcing" / fname), diff --git a/regional_mom6/regridding.py b/regional_mom6/regridding.py index 6822eef3..5ee2b86c 100644 --- a/regional_mom6/regridding.py +++ b/regional_mom6/regridding.py @@ -493,18 +493,20 @@ def get_boundary_mask( land = 0 ocean = 1.0 boundary_mask = np.full(np.shape(coords(hgrid, side, segment_name).angle), ocean) - for i in range(len(bathy_2_coords["boundary_depth"])): + + ## Mask2DCu is the mask for the u/v points on the hgrid and is set to OBCmaskCy as well... + for i in range(len(bathy_2_coords["boundary_depth"]) - 1): if bathy_2_coords["boundary_depth"][i] <= minimum_depth: # The points to the left and right of this t-point are land points boundary_mask[(i * 2) + 2] = land - boundary_mask[(i * 2) + 1] = land + boundary_mask[(i * 2) + 1] = ( + land # u/v point on the second level just like mask2DCu + ) boundary_mask[(i * 2)] = land - # If the corners are nans, we convert them to ocean as well. - if np.isnan(boundary_mask[0]): - boundary_mask[0] = ocean - if np.isnan(boundary_mask[-1]): - boundary_mask[-1] = ocean + # Corner Q-points defined as wet + boundary_mask[0] = ocean + boundary_mask[-1] = ocean # Looks like in the boundary between land and ocean - in NWA for example - we basically need to remove 3 points closest to ocean as a buffer. # Search for intersections @@ -521,7 +523,7 @@ def get_boundary_mask( boundary_mask[beach - 1 - i] = ocean for beach in beaches_before: for i in range(3): - if beach + 1 + i >= 0: + if beach + 1 + i < len(beaches_before): boundary_mask[beach + 1 + i] = ocean boundary_mask[np.where(boundary_mask == land)] = np.nan From 85d1c74de5f034cff9dce424a8d34a6254eb549b Mon Sep 17 00:00:00 2001 From: manishvenu Date: Wed, 18 Dec 2024 14:40:04 -0700 Subject: [PATCH 49/87] Clean up process of masking --- regional_mom6/regional_mom6.py | 59 +++++--------------------- regional_mom6/regridding.py | 75 ++++++++++++++++++++++++++++++++++ 2 files changed, 85 insertions(+), 49 deletions(-) diff --git a/regional_mom6/regional_mom6.py b/regional_mom6/regional_mom6.py index 9ad4a1fe..d3606091 100644 --- a/regional_mom6/regional_mom6.py +++ b/regional_mom6/regional_mom6.py @@ -3397,31 +3397,13 @@ def regrid_velocity_tracers(self, rotational_method=rot.RotationMethod.GIVEN_ANG ) segment_out[f"{coords.attrs['perpendicular']}_{self.segment_name}"] = [0] - ## Add Boundary Mask ## - if self.bathymetry is not None: - print( - "Masking to bathymetry. If you don't want this, set bathymetry_path to None in the segment class." - ) - mask = rgd.get_boundary_mask( - self.hgrid, - self.bathymetry, - self.orientation, - self.segment_name, - minimum_depth=0, - ) - if self.orientation in ["east", "west"]: - mask = mask[:, np.newaxis] - for var in segment_out.data_vars.keys(): - segment_out[var] = segment_out[var].fillna(0) - segment_out[var] = segment_out[var] * mask - else: - print( - "Warning: All NaNs filled b/c bathymetry wasn't provided to the function. Add bathymetry_path to the segment class to avoid this" - ) - segment_out = segment_out.fillna( - 0 - ) # Without bathymetry, we can't assume the nans will be allowed in Boundary Conditions - + segment_out = rgd.mask_dataset( + segment_out, + self.hgrid, + self.bathymetry, + self.orientation, + self.segment_name, + ) encoding_dict = { "time": {"dtype": "double"}, f"nx_{self.segment_name}": { @@ -3746,30 +3728,9 @@ def encode_tidal_files_and_output(self, ds, filename): {"lon": f"lon_{self.segment_name}", "lat": f"lat_{self.segment_name}"} ) - ## Add Boundary Mask ## - if self.bathymetry is not None: - print( - "Masking to bathymetry. If you don't want this, set bathymetry_path to None in the segment class." - ) - mask = rgd.get_boundary_mask( - self.hgrid, - self.bathymetry, - self.orientation, - self.segment_name, - minimum_depth=0, - ) - if self.orientation in ["east", "west"]: - mask = mask[:, np.newaxis] - for var in ds.data_vars.keys(): - ds[var] = ds[var].fillna(0) - ds[var] = ds[var] * mask - else: - print( - "Warning: All NaNs filled b/c bathymetry wasn't provided to the function. Add bathymetry_path to the segment class to avoid this" - ) - ds = ds.fillna(0) - # Without bathymetry, we can't assume the nans will be allowed in Boundary Conditions - + ds = rgd.mask_dataset( + ds, self.hgrid, self.bathymetry, self.orientation, self.segment_name + ) ## Perform Encoding ## fname = f"{filename}_{self.segment_name}.nc" diff --git a/regional_mom6/regridding.py b/regional_mom6/regridding.py index 5ee2b86c..9a020d5b 100644 --- a/regional_mom6/regridding.py +++ b/regional_mom6/regridding.py @@ -530,6 +530,81 @@ def get_boundary_mask( return boundary_mask +def mask_dataset( + ds: xr.Dataset, + hgrid: xr.Dataset, + bathymetry: xr.Dataset, + orientation, + segment_name: str, +) -> xr.Dataset: + """ + This function masks the dataset to the provided bathymetry. If bathymetry is not provided, it fills all NaNs with 0. + Parameters + ---------- + ds : xr.Dataset + The dataset to mask + hgrid : xr.Dataset + The hgrid dataset + bathymetry : xr.Dataset + The bathymetry dataset + orientation : str + The orientation of the boundary + segment_name : str + The segment name + """ + ## Add Boundary Mask ## + if bathymetry is not None: + regridding_logger.info( + "Masking to bathymetry. If you don't want this, set bathymetry_path to None in the segment class." + ) + mask = get_boundary_mask( + hgrid, + bathymetry, + orientation, + segment_name, + minimum_depth=0, + ) + if orientation in ["east", "west"]: + mask = mask[:, np.newaxis] + else: + mask = mask[np.newaxis, :] + + for var in ds.data_vars.keys(): + + ## Compare the dataset to the mask by reducing dims## + dataset_reduce_dim = ds[var] + for index in range(ds[var].ndim - 2): + dataset_reduce_dim = dataset_reduce_dim[0] + if orientation in ["east", "west"]: + dataset_reduce_dim = dataset_reduce_dim[:, 0] + mask_reduce = mask[:, 0] + else: + dataset_reduce_dim = dataset_reduce_dim[0, :] + mask_reduce = mask[0, :] + loc_nans_data = np.where(np.isnan(dataset_reduce_dim)) + loc_nans_mask = np.where(np.isnan(mask_reduce)) + + ## Check if all nans in the data are in the mask without corners ## + if not np.isin(loc_nans_data[1:-1], loc_nans_mask[1:-1]).all(): + regridding_logger.warning( + f"NaNs in {var} not in mask. This values are filled with zeroes b/c they could cause issues with boundary conditions." + ) + + ## Remove Nans if needed ## + ds[var] = ds[var].fillna(0) + + ## Apply the mask ## + ds[var] = ds[var] * mask + else: + regridding_logger.warning( + "All NaNs filled b/c bathymetry wasn't provided to the function. Add bathymetry_path to the segment class to avoid this" + ) + ds = ds.fillna( + 0 + ) # Without bathymetry, we can't assume the nans will be allowed in Boundary Conditions + return ds + + def generate_encoding( ds: xr.Dataset, encoding_dict, default_fill_value=netCDF4.default_fillvals["f8"] ) -> xr.Dataset: From 33a021df530eab916835d03ba4e17d0bdc536373 Mon Sep 17 00:00:00 2001 From: manishvenu Date: Wed, 18 Dec 2024 16:56:38 -0700 Subject: [PATCH 50/87] Regridding Testing except for the mask functions --- regional_mom6/regridding.py | 2 +- tests/conftest.py | 103 ++++++++++++++++++++++++++++ tests/test_regridding.py | 130 +++++++++++++++++++++++++++++++----- 3 files changed, 218 insertions(+), 17 deletions(-) diff --git a/regional_mom6/regridding.py b/regional_mom6/regridding.py index 9a020d5b..630847c9 100644 --- a/regional_mom6/regridding.py +++ b/regional_mom6/regridding.py @@ -607,7 +607,7 @@ def mask_dataset( def generate_encoding( ds: xr.Dataset, encoding_dict, default_fill_value=netCDF4.default_fillvals["f8"] -) -> xr.Dataset: +) -> dict: """ Generate the encoding dictionary for the dataset Parameters diff --git a/tests/conftest.py b/tests/conftest.py index db1bf2cf..49d6dd6b 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -1,6 +1,7 @@ import pytest import os import xarray as xr +import numpy as np # Define the path where the curvilinear hgrid file is expected in the Docker container DOCKER_FILE_PATH = "/data/small_curvilinear_hgrid.nc" @@ -27,3 +28,105 @@ def get_curvilinear_hgrid(): pytest.skip( f"Required file 'hgrid.nc' not found in {DOCKER_FILE_PATH} or {LOCAL_FILE_PATH}" ) + + +@pytest.fixture() +def generate_silly_vt_dataset(tmp_path): + latitude_extent = [30, 40] + longitude_extent = [-80, -70] + eastern_boundary = xr.Dataset( + { + "temp": xr.DataArray( + np.random.random((100, 5, 10, 10)), + dims=["silly_lat", "silly_lon", "silly_depth", "time"], + coords={ + "silly_lat": np.linspace( + latitude_extent[0] - 5, latitude_extent[1] + 5, 100 + ), + "silly_lon": np.linspace( + longitude_extent[1] - 0.5, longitude_extent[1] + 0.5, 5 + ), + "silly_depth": np.linspace(0, 1000, 10), + "time": np.linspace(0, 1000, 10), + }, + ), + "eta": xr.DataArray( + np.random.random((100, 5, 10)), + dims=["silly_lat", "silly_lon", "time"], + coords={ + "silly_lat": np.linspace( + latitude_extent[0] - 5, latitude_extent[1] + 5, 100 + ), + "silly_lon": np.linspace( + longitude_extent[1] - 0.5, longitude_extent[1] + 0.5, 5 + ), + "time": np.linspace(0, 1000, 10), + }, + ), + "salt": xr.DataArray( + np.random.random((100, 5, 10, 10)), + dims=["silly_lat", "silly_lon", "silly_depth", "time"], + coords={ + "silly_lat": np.linspace( + latitude_extent[0] - 5, latitude_extent[1] + 5, 100 + ), + "silly_lon": np.linspace( + longitude_extent[1] - 0.5, longitude_extent[1] + 0.5, 5 + ), + "silly_depth": np.linspace(0, 1000, 10), + "time": np.linspace(0, 1000, 10), + }, + ), + "u": xr.DataArray( + np.random.random((100, 5, 10, 10)), + dims=["silly_lat", "silly_lon", "silly_depth", "time"], + coords={ + "silly_lat": np.linspace( + latitude_extent[0] - 5, latitude_extent[1] + 5, 100 + ), + "silly_lon": np.linspace( + longitude_extent[1] - 0.5, longitude_extent[1] + 0.5, 5 + ), + "silly_depth": np.linspace(0, 1000, 10), + "time": np.linspace(0, 1000, 10), + }, + ), + "v": xr.DataArray( + np.random.random((100, 5, 10, 10)), + dims=["silly_lat", "silly_lon", "silly_depth", "time"], + coords={ + "silly_lat": np.linspace( + latitude_extent[0] - 5, latitude_extent[1] + 5, 100 + ), + "silly_lon": np.linspace( + longitude_extent[1] - 0.5, longitude_extent[1] + 0.5, 5 + ), + "silly_depth": np.linspace(0, 1000, 10), + "time": np.linspace(0, 1000, 10), + }, + ), + } + ) + return eastern_boundary + + +@pytest.fixture() +def dummy_bathymetry_data(): + latitude_extent = [16.0, 27] + longitude_extent = [192, 209] + + bathymetry = np.random.random((100, 100)) * (-100) + bathymetry = xr.DataArray( + bathymetry, + dims=["silly_lat", "silly_lon"], + coords={ + "silly_lat": np.linspace( + latitude_extent[0] - 5, latitude_extent[1] + 5, 100 + ), + "silly_lon": np.linspace( + longitude_extent[0] - 5, longitude_extent[1] + 5, 100 + ), + }, + ) + bathymetry.name = "silly_depth" + return bathymetry diff --git a/tests/test_regridding.py b/tests/test_regridding.py index 4d163ea5..e634ad08 100644 --- a/tests/test_regridding.py +++ b/tests/test_regridding.py @@ -7,35 +7,133 @@ # Not testing get_arakawa_c_points, coords, & create_regridder -def test_smoke_untested_funcs(get_curvilinear_hgrid): +def test_smoke_untested_funcs(get_curvilinear_hgrid, generate_silly_vt_dataset): hgrid = get_curvilinear_hgrid + ds = generate_silly_vt_dataset + ds["lat"] = ds.silly_lat + ds["lon"] = ds.silly_lat assert rgd.get_hgrid_arakawa_c_points(hgrid, "t") assert rgd.coords(hgrid, "north", "segment_002") + assert rgd.create_regridder(ds, ds) -def test_fill_missing_data(): - return +def test_fill_missing_data(generate_silly_vt_dataset): + ds = generate_silly_vt_dataset + ds["temp"][0, 0, 6:10, 0] = np.nan + ds = rgd.fill_missing_data(ds, "silly_depth") -def test_add_or_update_time_dim(): - return + assert ( + ds["temp"][0, 0, 6:10, 0] == (ds["temp"][0, 0, 5, 0]) + ).all() # Assert if we are forward filling in time + ds_2 = generate_silly_vt_dataset + ds_2["temp"][0, 0, 6:10, 0] = ds["temp"][0, 0, 5, 0] + assert (ds["temp"] == (ds_2["temp"])).all() # Assert everything else is the same -def test_generate_dz(): - return +def test_add_or_update_time_dim(generate_silly_vt_dataset): + ds = generate_silly_vt_dataset + ds = rgd.add_or_update_time_dim(ds, xr.DataArray([0])) -def test_add_secondary_dimension(): - return + assert ds["time"].values == [0] # Assert time is added + assert ds["temp"].dims[0] == "time" # Check time is first dim -def test_add_vertical_coordinate_encoding(): - return +def test_generate_dz(generate_silly_vt_dataset): + ds = generate_silly_vt_dataset + dz = rgd.generate_dz(ds, "silly_depth") + z = np.linspace(0, 1000, 10) + dz_check = np.full(z.shape, z[1] - z[0]) + assert ( + (dz.values - dz_check) < 0.00001 + ).all() # Assert dz is generated correctly (some roundingleniency) -def test_generate_layer_thickness(): - return - +def test_add_secondary_dimension(get_curvilinear_hgrid, generate_silly_vt_dataset): + ds = generate_silly_vt_dataset + hgrid = get_curvilinear_hgrid -def test_generate_encoding(): - return + # N/S Boundary + coords = rgd.coords(hgrid, "north", "segment_002") + ds = rgd.add_secondary_dimension(ds, "temp", coords, "segment_002") + assert ds["temp"].dims == ( + "silly_lat", + "ny_segment_002", + "silly_lon", + "silly_depth", + "time", + ) + + # E/W Boundary + coords = rgd.coords(hgrid, "east", "segment_003") + ds = rgd.add_secondary_dimension(ds, "temp", coords, "segment_003") + assert ds["temp"].dims == ( + "silly_lat", + "silly_lon", + "nx_segment_003", + "silly_depth", + "time", + ) + + # Beginning + ds = rgd.add_secondary_dimension(ds, "temp", coords, "segment_003") + assert ds["temp"].dims[0] == "nx_segment_003" + + # NZ dim E/W Boundary + ds["temp"].dims[0] = "nz" + ds = rgd.add_secondary_dimension(ds, "temp", coords, "segment_003") + assert ds["temp"].dims == ( + "nz", + "silly_lon", + "silly_depth", + "nx_segment_003", + "time", + ) + + +def test_vertical_coordinate_encoding(generate_silly_vt_dataset): + ds = generate_silly_vt_dataset + ds = rgd.vertical_coordinate_encoding(ds, "temp", "segment_002", "silly_depth") + assert "nz_segment_002_temp" in ds["temp"].dims + assert "nz_segment_002_temp" in ds + assert ( + ds["nz_segment_002_temp"] == np.arange(ds[f"nz_segment_002_temp"].size) + ).all() + + +def test_generate_layer_thickness(generate_silly_vt_dataset): + ds = generate_silly_vt_dataset + ds["temp"] = ds["temp"].transpose("time", "silly_depth", "silly_lat", "silly_lon") + ds = rgd.generate_layer_thickness(ds, "temp", "segment_002", "silly_depth") + assert "dz_temp" in ds + assert ds["dz_temp"].dims == ("time", "nz_temp", "ny_segment_002", "nx_segment_002") + assert ( + ds["temp"]["silly_depth"].shape == ds["dz_temp"]["nz_temp"].shape + ) # Make sure the depth dimension was broadcasted correctly + + +def test_generate_encoding(generate_silly_vt_dataset): + ds = generate_silly_vt_dataset + encoding_dict = {} + ds["temp_segment_002"] = ds["temp"] + ds.coords["temp_segment_003_nz_"] = ds.silly_depth + encoding_dict = rgd.generate_encoding(ds, encoding_dict, default_fill_value="-3") + assert ( + encoding_dict["temp_segment_002"]["_FillValue"] == "-3" + and "dtype" not in encoding_dict["temp_segment_002"] + ) + assert encoding_dict["temp_segment_003_nz_"]["dtype"] == "int32" + + +## TBD - Boundary Mask Functions + + +def test_get_boundary_mask(get_curvilinear_hgrid, dummy_bathymetry_data): + hgrid = get_curvilinear_hgrid + bathy_og = get_curvilinear_hgrid + bathy = bathy_og.isel( + nxp=slice(0, bathy_og.dims["nxp"] // 2), nyp=slice(0, bathy_og.dims["nyp"] // 2) + ) + mask = rgd.get_boundary_mask(hgrid, bathy, "north", "segment_002") + assert True From 516af0b02d4c6ef20b46afea5329d92a4c81ff33 Mon Sep 17 00:00:00 2001 From: manishvenu Date: Thu, 19 Dec 2024 11:00:58 -0700 Subject: [PATCH 51/87] First round testing w/o mask tests --- tests/conftest.py | 2 +- tests/test_regridding.py | 21 +++++++++++++-------- tests/test_tides_and_parameter.py | 22 ---------------------- 3 files changed, 14 insertions(+), 31 deletions(-) diff --git a/tests/conftest.py b/tests/conftest.py index 49d6dd6b..e3155884 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -31,7 +31,7 @@ def get_curvilinear_hgrid(): @pytest.fixture() -def generate_silly_vt_dataset(tmp_path): +def generate_silly_vt_dataset(): latitude_extent = [30, 40] longitude_extent = [-80, -70] eastern_boundary = xr.Dataset( diff --git a/tests/test_regridding.py b/tests/test_regridding.py index e634ad08..b46c1dc2 100644 --- a/tests/test_regridding.py +++ b/tests/test_regridding.py @@ -67,8 +67,9 @@ def test_add_secondary_dimension(get_curvilinear_hgrid, generate_silly_vt_datase # E/W Boundary coords = rgd.coords(hgrid, "east", "segment_003") - ds = rgd.add_secondary_dimension(ds, "temp", coords, "segment_003") - assert ds["temp"].dims == ( + ds = generate_silly_vt_dataset + ds = rgd.add_secondary_dimension(ds, "v", coords, "segment_003") + assert ds["v"].dims == ( "silly_lat", "silly_lon", "nx_segment_003", @@ -77,16 +78,20 @@ def test_add_secondary_dimension(get_curvilinear_hgrid, generate_silly_vt_datase ) # Beginning - ds = rgd.add_secondary_dimension(ds, "temp", coords, "segment_003") + ds = generate_silly_vt_dataset + ds = rgd.add_secondary_dimension( + ds, "temp", coords, "segment_003", to_beginning=True + ) assert ds["temp"].dims[0] == "nx_segment_003" # NZ dim E/W Boundary - ds["temp"].dims[0] = "nz" - ds = rgd.add_secondary_dimension(ds, "temp", coords, "segment_003") - assert ds["temp"].dims == ( - "nz", + ds = generate_silly_vt_dataset + ds = ds.rename({"silly_depth": "nz"}) + ds = rgd.add_secondary_dimension(ds, "u", coords, "segment_003") + assert ds["u"].dims == ( + "silly_lat", "silly_lon", - "silly_depth", + "nz", "nx_segment_003", "time", ) diff --git a/tests/test_tides_and_parameter.py b/tests/test_tides_and_parameter.py index 8b1e0f99..abf798f0 100644 --- a/tests/test_tides_and_parameter.py +++ b/tests/test_tides_and_parameter.py @@ -134,28 +134,6 @@ def dummy_tidal_data(): return ds_h, ds_u -@pytest.fixture(scope="module") -def dummy_bathymetry_data(): - latitude_extent = [16.0, 27] - longitude_extent = [192, 209] - - bathymetry = np.random.random((100, 100)) * (-100) - bathymetry = xr.DataArray( - bathymetry, - dims=["silly_lat", "silly_lon"], - coords={ - "silly_lat": np.linspace( - latitude_extent[0] - 5, latitude_extent[1] + 5, 100 - ), - "silly_lon": np.linspace( - longitude_extent[0] - 5, longitude_extent[1] + 5, 100 - ), - }, - ) - bathymetry.name = "silly_depth" - return bathymetry - - @pytest.fixture() def full_expt_setup(dummy_bathymetry_data, tmp_path): From 98bc9c7a17ddc94a58293c621ad239b4f546aec9 Mon Sep 17 00:00:00 2001 From: manishvenu Date: Thu, 19 Dec 2024 14:10:42 -0700 Subject: [PATCH 52/87] First Round Testing Completed --- regional_mom6/regridding.py | 37 +++++++--- tests/conftest.py | 2 +- tests/test_regridding.py | 131 ++++++++++++++++++++++++++++++++++-- 3 files changed, 153 insertions(+), 17 deletions(-) diff --git a/regional_mom6/regridding.py b/regional_mom6/regridding.py index 630847c9..126df566 100644 --- a/regional_mom6/regridding.py +++ b/regional_mom6/regridding.py @@ -444,7 +444,13 @@ def generate_layer_thickness( def get_boundary_mask( - hgrid: xr.Dataset, bathy: xr.Dataset, side: str, segment_name: str, minimum_depth=0 + hgrid: xr.Dataset, + bathy: xr.Dataset, + side: str, + segment_name: str, + minimum_depth=0, + x_dim_name="lonh", + y_dim_name="lath", ) -> np.ndarray: """ Mask out the boundary conditions based on the bathymetry. We don't want to have boundary conditions on land. @@ -466,8 +472,15 @@ def get_boundary_mask( The boundary mask """ - # Hide the bathy as an angle field so we can take advantage of the coords function to get the boundary points. - bathy = bathy.rename({"lath": "nyp", "lonh": "nxp"}) + # Hide the bathy as an hgrid so we can take advantage of the coords function to get the boundary points. + try: + bathy = bathy.rename({y_dim_name: "nyp", x_dim_name: "nxp"}) + except: + try: + bathy = bathy.rename({"ny": "nyp", "nx": "nxp"}) + except: + regridding_logger.error("Could not rename bathy to nyp and nxp") + raise ValueError("Please provide the bathymetry x and y dimension names") # Copy Hgrid bathy_2 = hgrid.copy(deep=True) @@ -495,7 +508,7 @@ def get_boundary_mask( boundary_mask = np.full(np.shape(coords(hgrid, side, segment_name).angle), ocean) ## Mask2DCu is the mask for the u/v points on the hgrid and is set to OBCmaskCy as well... - for i in range(len(bathy_2_coords["boundary_depth"]) - 1): + for i in range(len(bathy_2_coords["boundary_depth"])): if bathy_2_coords["boundary_depth"][i] <= minimum_depth: # The points to the left and right of this t-point are land points boundary_mask[(i * 2) + 2] = land @@ -504,10 +517,6 @@ def get_boundary_mask( ) boundary_mask[(i * 2)] = land - # Corner Q-points defined as wet - boundary_mask[0] = ocean - boundary_mask[-1] = ocean - # Looks like in the boundary between land and ocean - in NWA for example - we basically need to remove 3 points closest to ocean as a buffer. # Search for intersections beaches_before = [] @@ -521,12 +530,16 @@ def get_boundary_mask( for i in range(3): if beach - 1 - i >= 0: boundary_mask[beach - 1 - i] = ocean - for beach in beaches_before: + for beach in beaches_after: for i in range(3): - if beach + 1 + i < len(beaches_before): + if beach + 1 + i < len(boundary_mask): boundary_mask[beach + 1 + i] = ocean boundary_mask[np.where(boundary_mask == land)] = np.nan + # Corner Q-points defined as wet + boundary_mask[0] = ocean + boundary_mask[-1] = ocean + return boundary_mask @@ -536,6 +549,8 @@ def mask_dataset( bathymetry: xr.Dataset, orientation, segment_name: str, + y_dim_name="lath", + x_dim_name="lonh", ) -> xr.Dataset: """ This function masks the dataset to the provided bathymetry. If bathymetry is not provided, it fills all NaNs with 0. @@ -563,6 +578,8 @@ def mask_dataset( orientation, segment_name, minimum_depth=0, + x_dim_name=x_dim_name, + y_dim_name=y_dim_name, ) if orientation in ["east", "west"]: mask = mask[:, np.newaxis] diff --git a/tests/conftest.py b/tests/conftest.py index e3155884..bf3f0555 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -23,7 +23,7 @@ def get_curvilinear_hgrid(): elif os.path.exists(LOCAL_FILE_PATH): return xr.open_dataset(LOCAL_FILE_PATH) - # If neither location contains the file, raise an error + # If neither location contains the file, skip test else: pytest.skip( f"Required file 'hgrid.nc' not found in {DOCKER_FILE_PATH} or {LOCAL_FILE_PATH}" diff --git a/tests/test_regridding.py b/tests/test_regridding.py index b46c1dc2..cc6beb8f 100644 --- a/tests/test_regridding.py +++ b/tests/test_regridding.py @@ -134,11 +134,130 @@ def test_generate_encoding(generate_silly_vt_dataset): ## TBD - Boundary Mask Functions -def test_get_boundary_mask(get_curvilinear_hgrid, dummy_bathymetry_data): +def test_get_boundary_mask(get_curvilinear_hgrid): hgrid = get_curvilinear_hgrid - bathy_og = get_curvilinear_hgrid - bathy = bathy_og.isel( - nxp=slice(0, bathy_og.dims["nxp"] // 2), nyp=slice(0, bathy_og.dims["nyp"] // 2) + t_points = rgd.get_hgrid_arakawa_c_points(hgrid, "t") + bathy = hgrid.isel(nyp=t_points.t_points_y, nxp=t_points.t_points_x) + bathy["depth"] = (("t_points_y", "t_points_x"), (np.full(bathy.x.shape, 0))) + north_mask = rgd.get_boundary_mask( + hgrid, + bathy, + "north", + "segment_002", + y_dim_name="t_points_y", + x_dim_name="t_points_x", ) - mask = rgd.get_boundary_mask(hgrid, bathy, "north", "segment_002") - assert True + south_mask = rgd.get_boundary_mask( + hgrid, + bathy, + "south", + "segment_001", + y_dim_name="t_points_y", + x_dim_name="t_points_x", + ) + east_mask = rgd.get_boundary_mask( + hgrid, + bathy, + "east", + "segment_003", + y_dim_name="t_points_y", + x_dim_name="t_points_x", + ) + west_mask = rgd.get_boundary_mask( + hgrid, + bathy, + "west", + "segment_004", + y_dim_name="t_points_y", + x_dim_name="t_points_x", + ) + + # Check corner property of mask, and ensure each direction is following what we expect + for mask in [north_mask, south_mask, east_mask, west_mask]: + assert mask[0] == 1 and mask[-1] == 1 # Ensure Corners are oceans + assert np.isnan(mask[1:-1]).all() # Ensure all other points are land + assert north_mask.shape == (hgrid.x[-1].shape) # Ensure mask is the right shape + assert south_mask.shape == (hgrid.x[0].shape) # Ensure mask is the right shape + assert east_mask.shape == (hgrid.x[:, -1].shape) # Ensure mask is the right shape + assert west_mask.shape == (hgrid.x[:, 0].shape) # Ensure mask is the right shape + + ## Now we check if the coast masking is correct (remember we make 3 cells into the coast be ocean) + start_ind = 6 + end_ind = 9 + for i in range(start_ind, end_ind + 1): + bathy["depth"][-1][i] = 15 + north_mask = rgd.get_boundary_mask( + hgrid, + bathy, + "north", + "segment_002", + y_dim_name="t_points_y", + x_dim_name="t_points_x", + ) + assert north_mask[0] == 1 and north_mask[-1] == 1 # Ensure Corners are oceans + assert ( + north_mask[(((start_ind * 2) + 1) - 3) : (((end_ind * 2) + 1) + 3 + 1)] == 1 + ).all() # Ensure coasts are ocean with a 3 cell buffer (remeber mask is on the hgrid boundary) so (6 *2 +2) - 3 -> (9 *2 +2) + 3 + + ## On E/W + start_ind = 6 + end_ind = 9 + for i in range(start_ind, end_ind + 1): + bathy["depth"][:, 0][i] = 15 + west_mask = rgd.get_boundary_mask( + hgrid, + bathy, + "west", + "segment_004", + y_dim_name="t_points_y", + x_dim_name="t_points_x", + ) + assert west_mask[0] == 1 and west_mask[-1] == 1 # Ensure Corners are oceans + assert ( + west_mask[(((start_ind * 2) + 1) - 3) : (((end_ind * 2) + 1) + 3 + 1)] == 1 + ).all() # Ensure coasts are ocean with a 3 cell buffer (remeber mask is on the hgrid boundary) so (6 *2 +2) - 3 -> (9 *2 +2) + 3 + + +def test_mask_dataset(get_curvilinear_hgrid): + hgrid = get_curvilinear_hgrid + t_points = rgd.get_hgrid_arakawa_c_points(hgrid, "t") + bathy = hgrid.isel(nyp=t_points.t_points_y, nxp=t_points.t_points_x) + bathy["depth"] = (("t_points_y", "t_points_x"), (np.full(bathy.x.shape, 0))) + ds = hgrid.copy(deep=True) + ds = ds.drop_vars(("tile", "area", "y", "x", "angle_dx", "dy", "dx")) + ds["temp"] = (("t_points_y", "t_points_x"), (np.full(hgrid.x.shape, 100))) + ds["temp"] = ds["temp"].isel(t_points_y=-1) + start_ind = 6 + end_ind = 9 + for i in range(start_ind, end_ind + 1): + bathy["depth"][-1][i] = 15 + + ds["temp"][ + start_ind * 2 + 2 + ] = ( + np.nan + ) # Add a missing value not in the land mask to make sure it is filled with a dummy value + ds["temp"] = ds["temp"].expand_dims("nz_temp", axis=0) + ds = rgd.mask_dataset( + ds, + hgrid, + bathy, + "north", + "segment_002", + y_dim_name="t_points_y", + x_dim_name="t_points_x", + ) + + assert ( + np.isnan(ds["temp"][0][start_ind * 2 + 2]) == False + ) # Ensure missing value was filled + assert ( + np.isnan( + ds["temp"][0][(((start_ind * 2) + 1) - 3) : (((end_ind * 2) + 1) + 3 + 1)] + ) + ).all() == False # Ensure data is kept in ocean area + assert ( + np.isnan(ds["temp"][0][1 : (((start_ind * 2) + 1) - 3)]) + ).all() == True and ( + np.isnan(ds["temp"][0][(((end_ind * 2) + 1) + 3 + 1) : -1]) + ).all() == True # Ensure data is not in land area From 39ac51e68bafd29e23c1217a602a1e9ea3bfbc37 Mon Sep 17 00:00:00 2001 From: manishvenu Date: Thu, 19 Dec 2024 15:52:34 -0700 Subject: [PATCH 53/87] Minor Clean --- tests/test_regridding.py | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/tests/test_regridding.py b/tests/test_regridding.py index cc6beb8f..4ce94295 100644 --- a/tests/test_regridding.py +++ b/tests/test_regridding.py @@ -47,7 +47,7 @@ def test_generate_dz(generate_silly_vt_dataset): dz_check = np.full(z.shape, z[1] - z[0]) assert ( (dz.values - dz_check) < 0.00001 - ).all() # Assert dz is generated correctly (some roundingleniency) + ).all() # Assert dz is generated correctly (some rounding leniency) def test_add_secondary_dimension(get_curvilinear_hgrid, generate_silly_vt_dataset): @@ -131,9 +131,6 @@ def test_generate_encoding(generate_silly_vt_dataset): assert encoding_dict["temp_segment_003_nz_"]["dtype"] == "int32" -## TBD - Boundary Mask Functions - - def test_get_boundary_mask(get_curvilinear_hgrid): hgrid = get_curvilinear_hgrid t_points = rgd.get_hgrid_arakawa_c_points(hgrid, "t") From f7df20c86c5c82526bd5ef34605b3c656c3fc06a Mon Sep 17 00:00:00 2001 From: Manish Venumuddula <80477243+manishvenu@users.noreply.github.com> Date: Thu, 19 Dec 2024 16:44:31 -0700 Subject: [PATCH 54/87] MOM6 Angle Calculation (#34) * Start of Angle Calc * Blacl * Rand * Rand * Keith Method Step 1, add t-point boundaries to coords() * Start implementing alternative angles approaches... * Set up rotational method framework * Add h, t, and change default mom6_angle_calc to regional * black * Fred Angle Calc * Black * Black 2 * Keith Method * Tidal Rotational Methods Completed * Finish rotational methods for velocity_tracers * Combine the grid_rotation_calc for fred_pseudo and mom6 general (keiths) * Move rotation/angle functions to a different file * Doesn't make sense to use rot method in expt because the regrid methods are in segment right now. Something to discuss and then add * Clean up the keith method to use the regridding func add_secondary_dimension * Add angle_calc to docs * Main Page Link for now... * Start testing setup * Change func name for consistency * Minor Commenting * Minor Commenting * Black * Redo Auto Docs * Start of testing * Test until curved grid generation comes in * Bug * Test_Rotation Changes * Adjust Docker Path * Testing Framework Trial 1 * Docker Docs * Test Cleaning * Change name of docker docs * Adjust docker image to crocodile one * Step 1: Setup Framework Tidal Regridding Nans/LandMask BugFix * Finish setting up masking framework * Revert "Finish setting up masking framework" This reverts commit 9287030815f03b836c20f2162747fa86a9e57545. * Revert "Step 1: Setup Framework Tidal Regridding Nans/LandMask BugFix" This reverts commit a2b961a60210949b51b1870558c60d3d91a90c8b. * respond to alper comments --- .github/workflows/testing.yml | 2 +- docs/angle_calc.md | 45 ++++ docs/api.rst | 43 +++- docs/docker_image_dev.md | 35 ++++ docs/index.rst | 2 + regional_mom6/regional_mom6.py | 285 ++++++++++++++----------- regional_mom6/regridding.py | 137 ++++++++++-- regional_mom6/rotation.py | 250 ++++++++++++++++++++++ regional_mom6/utils.py | 15 ++ tests/conftest.py | 29 +++ tests/test_config.py | 5 +- tests/test_expt_class.py | 29 +-- tests/test_manish_branch.py | 338 ------------------------------ tests/test_regridding.py | 41 ++++ tests/test_rotation.py | 233 ++++++++++++++++++++ tests/test_tides_and_parameter.py | 278 ++++++++++++++++++++++++ 16 files changed, 1247 insertions(+), 520 deletions(-) create mode 100644 docs/angle_calc.md create mode 100644 docs/docker_image_dev.md create mode 100644 regional_mom6/rotation.py create mode 100644 tests/conftest.py delete mode 100644 tests/test_manish_branch.py create mode 100644 tests/test_regridding.py create mode 100644 tests/test_rotation.py create mode 100644 tests/test_tides_and_parameter.py diff --git a/.github/workflows/testing.yml b/.github/workflows/testing.yml index feb203e8..efe9811b 100644 --- a/.github/workflows/testing.yml +++ b/.github/workflows/testing.yml @@ -18,7 +18,7 @@ jobs: testing: needs: formatting runs-on: ubuntu-latest - container: ghcr.io/cosima/regional-test-env:updated + container: ghcr.io/crocodile-cesm/crocodile_rm6_test_env:latest defaults: run: shell: bash -el {0} diff --git a/docs/angle_calc.md b/docs/angle_calc.md new file mode 100644 index 00000000..5d8a3e91 --- /dev/null +++ b/docs/angle_calc.md @@ -0,0 +1,45 @@ +# Rotation and angle calculation in RM6 using MOM6 Angle Calculation +This document explains the implementation of MOM6 angle calculation in RM6, which is the process by which RM6 calculates the angle of curved hgrids. + +**Issue:** MOM6 doesn't actually use the user-provided "angle_dx" field in input hgrids, but internally calculates the angle. + +**Solution:** To accomodate this fact, when we rotate our boundary conditions, we implemented MOM6 angle calculation in a file called "rotation.py", and adjusted functions where we regrid the boundary conditions. + + +## MOM6 process of angle calculation (T-point only) +1. Calculate pi/4rads / 180 degrees = Gives a 1/4 conversion of degrees to radians. I.E. multiplying an angle in degrees by this gives the conversion to radians at 1/4 the value. +2. Figure out the longitudunal extent of our domain, or periodic range of longitudes. For global cases it is len_lon = 360, for our regional cases it is given by the hgrid. +3. At each point on our hgrid, we find the q-point to the top left, bottom left, bottom right, top right. We adjust each of these longitudes to be in the range of len_lon around the point itself. (module_around_point) +4. We then find the lon_scale, which is the "trigonometric scaling factor converting changes in longitude to equivalent distances in latitudes". Whatever that actually means is we add the latitude of all four of these points from part 3 and basically average it and convert to radians. We then take the cosine of it. As I understand it, it's a conversion of longitude to equivalent latitude distance. +5. Then we calculate the angle. This is a simple arctan2 so y/x. + 1. The "y" component is the addition of the difference between the diagonals in longitude (adjusted by modulo_around_point in step 3) multiplied by the lon_scale, which is our conversion to latitude. + 2. The "x" component is the same addition of differences in latitude. + 3. Thus, given the same units, we can call arctan to get the angle in degrees + + +## Problem +MOM6 only calculates the angle at t-points. For boundary rotation, we need the angle at the boundary, which is q/u/v points. Because we need the points to the left, right, top, and bottom of the point, this method won't work for the boundary. + + +# Convert this method to boundary angles - 3 Options +1. **GIVEN_ANGLE**: Don't calculate the angle and use the user-provided field in the hgrid called "angle_dx" +2. **EXPAND_GRID**: Calculate another boundary row/column points around the hgrid using simple difference techniques. Use the new points to calculate the angle at the boundaries. This works because we can now access the four points needed to calculate the angle, where previously at boundaries we would be missing at least two. + + +## Code Description + +Most calculation code is implemented in the rotation.py script, and the functional uses are in regrid_velocity_tracers and regrid_tides functions in the segment class of RM6. + + +### Calculation Code (rotation.py) +1. **Rotational Method Definition**: Rotational Methods are defined in the enum class "Rotational Method" in rotation.py. +2. **MOM6 Angle Calculation**: The method is implemented in "mom6_angle_calculation_method" in rotation.py and the direct t-point angle calculation is "initialize_grid_rotation_angle". +3. **Fred's Pseudo Grid Expansion**: The method to add the additional boundary row/columns is referenced in "pseudo_hgrid" functions in rotation.py + +### Implementation Code (regional_mom6.py) +Both regridding functions (regrid_velocity_tracers, regrid_tides) accept a parameter called "rotational_method" which takes the Enum class defining the rotational method. + +We then define each method with a bunch of if statements. Here are the processes: + +1. Given angle is the default method of accepting the hgrid's angle_dx +2. Fred's method is the least code, and we simply swap out the hgrid angle with the generated one we calculate right where we do the rotation. diff --git a/docs/api.rst b/docs/api.rst index 3db049aa..93087763 100644 --- a/docs/api.rst +++ b/docs/api.rst @@ -1,22 +1,45 @@ -=============== - API reference -=============== +regional\_mom6 package +====================== +Submodules +---------- -+++++++++++++++++++ - ``regional_mom6`` -+++++++++++++++++++ +regional\_mom6.regional\_mom6 module +------------------------------------ .. automodule:: regional_mom6.regional_mom6 :members: :undoc-members: - :private-members: + :show-inheritance: +regional\_mom6.regridding module +-------------------------------- -+++++++++++ - ``utils`` -+++++++++++ +.. automodule:: regional_mom6.regridding + :members: + :undoc-members: + :show-inheritance: + +regional\_mom6.rotation module +------------------------------ + +.. automodule:: regional_mom6.rotation + :members: + :undoc-members: + :show-inheritance: + +regional\_mom6.utils module +--------------------------- .. automodule:: regional_mom6.utils :members: :undoc-members: + :show-inheritance: + +Module contents +--------------- + +.. automodule:: regional_mom6 + :members: + :undoc-members: + :show-inheritance: diff --git a/docs/docker_image_dev.md b/docs/docker_image_dev.md new file mode 100644 index 00000000..5c20030a --- /dev/null +++ b/docs/docker_image_dev.md @@ -0,0 +1,35 @@ +# Docker Image & Github Testing (For contributors) + +RM6 uses a docker image in github actions for holding large data. It wasn't directly being used, but for downloading the curvilinear grid for testing, we are using it. This document is a list of helpful commands to work on it. + +The link to the image is here: +https://github.com/COSIMA/regional-mom6/pkgs/container/regional-test-env + +For local development of the image to add data to it for testing, first pull it. +```docker pull ghcr.io/cosima/regional-test-env:updated``` + +Then to do testing of the image, we cd into our cloned version of RM6, and run this command. It mounts our code in the /workspace directory.: +```docker run -it --rm \ -v $(pwd):/workspace \ -w /workspace \ ghcr.io/cosima/regional-test-env:updated \ /bin/bash``` + +The -it flag is for shell access, and the workspace stuff is to get our local code in the container. +You have to download conda, python, pip, and all that business to properly run the tests. + +Getting to adding the data, you should create a folder and add both the data you want to add and a file simple called "Dockerfile". In Dockerfile, we'll get the original image, then copy the data we need to the data folder. + +``` +# Use the base image +FROM ghcr.io/cosima/regional-test-env: + +# Copy your local file into the /data directory in the container +COPY /data/ +``` + +Then, we need to build the image, tag it, and push it + +``` +docker build -t my-custom-image . # IN THE DIRECTORY WITH THE DOCKERFILE +docker tag my-custom-image ghcr.io/cosima/regional-test-env: +docker push ghcr.io/cosima/regional-test-env: +``` + + diff --git a/docs/index.rst b/docs/index.rst index 531ad99c..d8f614ca 100644 --- a/docs/index.rst +++ b/docs/index.rst @@ -91,8 +91,10 @@ The bibtex entry for the paper is: installation demos mom6-file-structure-primer + angle_calc api contributing + docker_image_dev Indices and tables diff --git a/regional_mom6/regional_mom6.py b/regional_mom6/regional_mom6.py index 4b621e18..1232910a 100644 --- a/regional_mom6/regional_mom6.py +++ b/regional_mom6/regional_mom6.py @@ -14,7 +14,7 @@ import os import importlib.resources import datetime -from .utils import quadrilateral_areas, ap2ep, ep2ap +from .utils import quadrilateral_areas, ap2ep, ep2ap, is_rectilinear_hgrid import pandas as pd from pathlib import Path import glob @@ -22,6 +22,7 @@ import json import copy from . import regridding as rgd +from . import rotation as rot warnings.filterwarnings("ignore") @@ -694,7 +695,6 @@ def __init__( self.layout = None # This should be a tuple. Leaving in a dummy 'None' makes it easy to remind the user to provide a value later on. self.minimum_depth = minimum_depth # Minimum depth allowed in bathy file self.tidal_constituents = tidal_constituents - if hgrid_type == "from_file": try: self.hgrid = xr.open_dataset(self.mom_input_dir / "hgrid.nc") @@ -1542,6 +1542,7 @@ def setup_ocean_state_boundaries( varnames, arakawa_grid="A", boundary_type="rectangular", + rotational_method=rot.RotationMethod.GIVEN_ANGLE, ): """ This function is a wrapper for `simple_boundary`. Given a list of up to four cardinal directions, @@ -1592,6 +1593,7 @@ def setup_ocean_state_boundaries( orientation ), # A number to identify the boundary; indexes from 1 arakawa_grid=arakawa_grid, + rotational_method=rotational_method, ) def setup_single_boundary( @@ -1602,6 +1604,7 @@ def setup_single_boundary( segment_number, arakawa_grid="A", boundary_type="simple", + rotational_method=rot.RotationMethod.GIVEN_ANGLE, ): """ Here 'simple' refers to boundaries that are parallel to lines of constant longitude or latitude. @@ -1642,7 +1645,9 @@ def setup_single_boundary( repeat_year_forcing=self.repeat_year_forcing, ) - self.segments[orientation].regrid_velocity_tracers() + self.segments[orientation].regrid_velocity_tracers( + rotational_method=rotational_method + ) print("Done.") return @@ -1653,16 +1658,17 @@ def setup_boundary_tides( tpxo_velocity_filepath, tidal_constituents="read_from_expt_init", boundary_type="rectangle", + rotational_method=rot.RotationMethod.GIVEN_ANGLE, ): """ - This function: We subset our tidal data and generate more boundary files! Args: path_to_td (str): Path to boundary tidal file. - tidal_filename: Name of the tpxo product that's used in the tidal_filename. Should be h_{tidal_filename}, u_{tidal_filename} - tidal_constiuents: List of tidal constituents to include in the regridding. Default is [0] which is the M2 constituent. - boundary_type (Optional[str]): Type of boundary. Currently, only ``'rectangle'`` is supported. Here 'rectangle' refers to boundaries that are parallel to lines of constant longitude or latitude. + tidal_filename: Name of the tpxo product that's used in the tidal_filename. Should be h_tidal_filename, u_tidal_filename + tidal_constituents: List of tidal constituents to include in the regridding. Default is [0] which is the M2 constituent. + boundary_type (str): Type of boundary. Currently, only rectangle is supported. Here rectangle refers to boundaries that are parallel to lines of constant longitude or latitude. + Returns: *.nc files: Regridded tidal velocity and elevation files in 'inputdir/forcing' @@ -1670,7 +1676,7 @@ def setup_boundary_tides( This tidal data functions are sourced from the GFDL NWA25 and changed in the following ways: - Converted code for RM6 segment class - Implemented Horizontal Subsetting - - Combined all functions of NWA25 into a four function process (in the style of rm6) (expt.setup_tides_rectangular_boundaries, self.coords, segment.regrid_tides, segment.encode_tidal_files_and_output) + - Combined all functions of NWA25 into a four function process (in the style of rm6) (expt.setup_tides_rectangular_boundaries, coords, segment.regrid_tides, segment.encode_tidal_files_and_output) Original Code was sourced from: @@ -1749,7 +1755,9 @@ def setup_boundary_tides( seg = self.segments[b] # Output and regrid tides - seg.regrid_tides(tpxo_v, tpxo_u, tpxo_h, times) + seg.regrid_tides( + tpxo_v, tpxo_u, tpxo_h, times, rotational_method=rotational_method + ) print("Done") def setup_bathymetry( @@ -2901,129 +2909,41 @@ def __init__( self.segment_name = segment_name self.repeat_year_forcing = repeat_year_forcing - @property - def coords(self): - """ - - - This function: - Allows us to call the self.coords for use in the xesmf.Regridder in the regrid_tides function. self.coords gives us the subset of the hgrid based on the orientation. - - Args: - None - Returns: - xr.Dataset: The correct coordinate space for the orientation - - General Description: - This tidal data functions are sourced from the GFDL NWA25 and changed in the following ways: - - Converted code for RM6 segment class - - Implemented Horizontal Subsetting - - Combined all functions of NWA25 into a four function process (in the style of rm6) (expt.setup_tides_rectangular_boundaries, segment.coords, segment.regrid_tides, segment.encode_tidal_files_and_output) - - - Code adapted from: - Author(s): GFDL, James Simkins, Rob Cermak, etc.. - Year: 2022 - Title: "NWA25: Northwest Atlantic 1/25th Degree MOM6 Simulation" - Version: N/A - Type: Python Functions, Source Code - Web Address: https://github.com/jsimkins2/nwa25 - - """ - # Rename nxp and nyp to locations - if self.orientation == "south": - rcoord = xr.Dataset( - { - "lon": self.hgrid["x"].isel(nyp=0), - "lat": self.hgrid["y"].isel(nyp=0), - "angle": self.hgrid["angle_dx"].isel(nyp=0), - } - ) - rcoord = rcoord.rename_dims({"nxp": f"nx_{self.segment_name}"}) - rcoord.attrs["perpendicular"] = "ny" - rcoord.attrs["parallel"] = "nx" - rcoord.attrs["axis_to_expand"] = ( - 2 ## Need to keep track of which axis the 'main' coordinate corresponds to when re-adding the 'secondary' axis - ) - rcoord.attrs["locations_name"] = ( - f"nx_{self.segment_name}" # Legacy name of nx_... was locations. This provides a clear transform in regrid_tides - ) - elif self.orientation == "north": - rcoord = xr.Dataset( - { - "lon": self.hgrid["x"].isel(nyp=-1), - "lat": self.hgrid["y"].isel(nyp=-1), - "angle": self.hgrid["angle_dx"].isel(nyp=-1), - } - ) - rcoord = rcoord.rename_dims({"nxp": f"nx_{self.segment_name}"}) - rcoord.attrs["perpendicular"] = "ny" - rcoord.attrs["parallel"] = "nx" - rcoord.attrs["axis_to_expand"] = 2 - rcoord.attrs["locations_name"] = f"nx_{self.segment_name}" - elif self.orientation == "west": - rcoord = xr.Dataset( - { - "lon": self.hgrid["x"].isel(nxp=0), - "lat": self.hgrid["y"].isel(nxp=0), - "angle": self.hgrid["angle_dx"].isel(nxp=0), - } - ) - rcoord = rcoord.rename_dims({"nyp": f"ny_{self.segment_name}"}) - rcoord.attrs["perpendicular"] = "nx" - rcoord.attrs["parallel"] = "ny" - rcoord.attrs["axis_to_expand"] = 3 - rcoord.attrs["locations_name"] = f"ny_{self.segment_name}" - elif self.orientation == "east": - rcoord = xr.Dataset( - { - "lon": self.hgrid["x"].isel(nxp=-1), - "lat": self.hgrid["y"].isel(nxp=-1), - "angle": self.hgrid["angle_dx"].isel(nxp=-1), - } - ) - rcoord = rcoord.rename_dims({"nyp": f"ny_{self.segment_name}"}) - rcoord.attrs["perpendicular"] = "nx" - rcoord.attrs["parallel"] = "ny" - rcoord.attrs["axis_to_expand"] = 3 - rcoord.attrs["locations_name"] = f"ny_{self.segment_name}" - - # Make lat and lon coordinates - rcoord = rcoord.assign_coords(lat=rcoord["lat"], lon=rcoord["lon"]) - - return rcoord - - def rotate(self, u, v): + def rotate(self, u, v, radian_angle): # Make docstring """ Rotate the velocities to the grid orientation. - Args: u (xarray.DataArray): The u-component of the velocity. v (xarray.DataArray): The v-component of the velocity. + radian_angle (xarray.DataArray): The angle of the grid in RADIANS Returns: Tuple[xarray.DataArray, xarray.DataArray]: The rotated u and v components of the velocity. """ - angle = self.coords.angle.values * np.pi / 180 - u_rot = u * np.cos(angle) - v * np.sin(angle) - v_rot = u * np.sin(angle) + v * np.cos(angle) + u_rot = u * np.cos(radian_angle) - v * np.sin(radian_angle) + v_rot = u * np.sin(radian_angle) + v * np.cos(radian_angle) return u_rot, v_rot - def regrid_velocity_tracers(self): + def regrid_velocity_tracers(self, rotational_method=rot.RotationMethod.GIVEN_ANGLE): """ Cut out and interpolate the velocities and tracers + Args: + rotational_method (rot.RotationMethod): The method to use for rotation of the velocities. Currently, the default method, GIVEN_ANGLE, works even with non-rotated grids """ - + if rotational_method == rot.RotationMethod.NO_ROTATION: + if not is_rectilinear_hgrid(self.hgrid): + raise ValueError("NO_ROTATION method only works with rectilinear grids") rawseg = xr.open_dataset(self.infile, decode_times=False, engine="netcdf4") + coords = rgd.coords(self.hgrid, self.orientation, self.segment_name) if self.arakawa_grid == "A": rawseg = rawseg.rename({self.x: "lon", self.y: "lat"}) - ## In this case velocities and tracers all on same points + # In this case velocities and tracers all on same points regridder = rgd.create_regridder( rawseg[self.u], coords, @@ -3036,7 +2956,40 @@ def regrid_velocity_tracers(self): [self.u, self.v, self.eta] + [self.tracers[i] for i in self.tracers] ] ) - rotated_u, rotated_v = self.rotate(regridded[self.u], regridded[self.v]) + + ## Angle Calculation & Rotation + if rotational_method == rot.RotationMethod.GIVEN_ANGLE: + rotated_u, rotated_v = self.rotate( + regridded[self.u], + regridded[self.v], + radian_angle=np.radians(coords.angle.values), + ) + + elif rotational_method == rot.RotationMethod.EXPAND_GRID: + + # Recalculate entire hgrid angles + self.hgrid["angle_dx_rm6"] = ( + rot.initialize_grid_rotation_angles_using_expanded_hgrid(self.hgrid) + ) + + # Get just the boundary + degree_angle = rgd.coords( + self.hgrid, + self.orientation, + self.segment_name, + angle_variable_name="angle_dx_rm6", + )["angle"] + + # Rotate + rotated_u, rotated_v = self.rotate( + regridded[self.u], + regridded[self.v], + radian_angle=np.radians(degree_angle.values), + ) + elif rotational_method == rot.RotationMethod.NO_ROTATION: + # Just transfer values + rotated_u, rotated_v = regridded[self.u], regridded[self.v] + rotated_ds = xr.Dataset( { self.u: rotated_u, @@ -3064,9 +3017,33 @@ def regrid_velocity_tracers(self): rawseg[[self.u, self.v]].rename({self.xq: "lon", self.yq: "lat"}) ) - velocities_out["u"], velocities_out["v"] = self.rotate( - velocities_out["u"], velocities_out["v"] - ) + # See explanation of the rotational methods in the A grid section + if rotational_method == rot.RotationMethod.GIVEN_ANGLE: + velocities_out["u"], velocities_out["v"] = self.rotate( + velocities_out["u"], + velocities_out["v"], + radian_angle=np.radians(coords.angle.values), + ) + elif rotational_method == rot.RotationMethod.EXPAND_GRID: + self.hgrid["angle_dx_rm6"] = ( + rot.initialize_grid_rotation_angles_using_expanded_hgrid(self.hgrid) + ) + degree_angle = rgd.coords( + self.hgrid, + self.orientation, + self.segment_name, + angle_variable_name="angle_dx_rm6", + )["angle"] + velocities_out["u"], velocities_out["v"] = self.rotate( + velocities_out["u"], + velocities_out["v"], + radian_angle=np.radians(degree_angle.values), + ) + elif rotational_method == rot.RotationMethod.NO_ROTATION: + velocities_out["u"], velocities_out["v"] = ( + velocities_out["u"], + velocities_out["v"], + ) segment_out = xr.merge( [ @@ -3105,7 +3082,30 @@ def regrid_velocity_tracers(self): regridded_u = regridder_uvelocity(rawseg[[self.u]]) regridded_v = regridder_vvelocity(rawseg[[self.v]]) - rotated_u, rotated_v = self.rotate(regridded_u[self.u], regridded_v[self.v]) + # See explanation of the rotational methods in the A grid section + if rotational_method == rot.RotationMethod.GIVEN_ANGLE: + rotated_u, rotated_v = self.rotate( + regridded_u, + regridded_v, + radian_angle=np.radians(coords.angle.values), + ) + elif rotational_method == rot.RotationMethod.EXPAND_GRID: + self.hgrid["angle_dx_rm6"] = ( + rot.initialize_grid_rotation_angles_using_expanded_hgrid(self.hgrid) + ) + degree_angle = rgd.coords( + self.hgrid, + self.orientation, + self.segment_name, + angle_variable_name="angle_dx_rm6", + )["angle"] + rotated_u, rotated_v = self.rotate( + regridded_u, + regridded_v, + radian_angle=np.radians(degree_angle.values), + ) + elif rotational_method == rot.RotationMethod.NO_ROTATION: + rotated_u, rotated_v = regridded_u, regridded_v rotated_ds = xr.Dataset( { self.u: rotated_u, @@ -3137,7 +3137,7 @@ def regrid_velocity_tracers(self): # fill in NaNs segment_out = rgd.fill_missing_data(segment_out, self.z) segment_out = rgd.fill_missing_data( - segment_out, f"{self.coords.attrs['parallel']}_{self.segment_name}" + segment_out, f"{coords.attrs['parallel']}_{self.segment_name}" ) times = xr.DataArray( @@ -3194,10 +3194,10 @@ def regrid_velocity_tracers(self): ) # Overwrite the actual lat/lon values in the dimensions, replace with incrementing integers - segment_out[f"{self.coords.attrs['parallel']}_{self.segment_name}"] = np.arange( - segment_out[f"{self.coords.attrs['parallel']}_{self.segment_name}"].size + segment_out[f"{coords.attrs['parallel']}_{self.segment_name}"] = np.arange( + segment_out[f"{coords.attrs['parallel']}_{self.segment_name}"].size ) - segment_out[f"{self.coords.attrs['perpendicular']}_{self.segment_name}"] = [0] + segment_out[f"{coords.attrs['perpendicular']}_{self.segment_name}"] = [0] encoding_dict = { "time": {"dtype": "double"}, f"nx_{self.segment_name}": { @@ -3222,7 +3222,12 @@ def regrid_velocity_tracers(self): return segment_out, encoding_dict def regrid_tides( - self, tpxo_v, tpxo_u, tpxo_h, times, method="nearest_s2d", periodic=False + self, + tpxo_v, + tpxo_u, + tpxo_h, + times, + rotational_method=rot.RotationMethod.GIVEN_ANGLE, ): """ This function: @@ -3236,6 +3241,7 @@ def regrid_tides( infile_td (str): Raw Tidal File/Dir tpxo_v, tpxo_u, tpxo_h (xarray.Dataset): Specific adjusted for MOM6 tpxo datasets (Adjusted with setup_tides) times (pd.DateRange): The start date of our model period + rotational_method (rot.RotationMethod): The method to use for rotation of the velocities. Currently, the default method, GIVEN_ANGLE, works even with non-rotated grids Returns: *.nc files: Regridded tidal velocity and elevation files in 'inputdir/forcing' @@ -3254,8 +3260,11 @@ def regrid_tides( Type: Python Functions, Source Code Web Address: https://github.com/jsimkins2/nwa25 """ + if rotational_method == rot.RotationMethod.NO_ROTATION: + if not is_rectilinear_hgrid(self.hgrid): + raise ValueError("NO_ROTATION method only works with rectilinear grids") - # Establish Coord + # Establish Coords coords = rgd.coords(self.hgrid, self.orientation, self.segment_name) ########## Tidal Elevation: Horizontally interpolate elevation components ############ @@ -3310,8 +3319,9 @@ def regrid_tides( self.encode_tidal_files_and_output(ds_ap, "tz") ########### Regrid Tidal Velocity ###################### - regrid_u = rgd.create_regridder(tpxo_u[["lon", "lat", "uRe"]], coords, ".temp") - regrid_v = rgd.create_regridder(tpxo_v[["lon", "lat", "vRe"]], coords, ".temp2") + + regrid_u = rgd.create_regridder(tpxo_u[["lon", "lat", "uRe"]], coords) + regrid_v = rgd.create_regridder(tpxo_v[["lon", "lat", "vRe"]], coords) # Interpolate each real and imaginary parts to self. uredest = regrid_u(tpxo_u[["lon", "lat", "uRe"]])["uRe"] @@ -3338,17 +3348,40 @@ def regrid_tides( ucplex = uredest + 1j * uimdest vcplex = vredest + 1j * vimdest - angle = coords["angle"] # Fred's grid is in degrees - # Convert complex u and v to ellipse, # rotate ellipse from earth-relative to model-relative, # and convert ellipse back to amplitude and phase. SEMA, ECC, INC, PHA = ap2ep(ucplex, vcplex) - INC -= np.radians(angle.data[np.newaxis, :]) + if rotational_method == rot.RotationMethod.GIVEN_ANGLE: + + # Get user-provided angle + angle = coords["angle"] + + # Rotate + INC -= np.radians(angle.data[np.newaxis, :]) + + elif rotational_method == rot.RotationMethod.EXPAND_GRID: + + # Generate entire hgrid angles using pseudo_hgrid + self.hgrid["angle_dx_rm6"] = ( + rot.initialize_grid_rotation_angles_using_expanded_hgrid(self.hgrid) + ) + + # Get just boundary angles + degree_angle = rgd.coords( + self.hgrid, + self.orientation, + self.segment_name, + angle_variable_name="angle_dx_rm6", + )["angle"] + + # Rotate + INC -= np.radians(degree_angle.data[np.newaxis, :]) ua, va, up, vp = ep2ap(SEMA, ECC, INC, PHA) # Convert to real amplitude and phase. + ds_ap = xr.Dataset( {f"uamp_{self.segment_name}": ua, f"vamp_{self.segment_name}": va} ) @@ -3401,7 +3434,7 @@ def encode_tidal_files_and_output(self, ds, filename): This tidal data functions are sourced from the GFDL NWA25 and changed in the following ways: - Converted code for RM6 segment class - Implemented Horizontal Subsetting - - Combined all functions of NWA25 into a four function process (in the style of rm6) (expt.setup_tides_rectangular_boundaries, self.coords, segment.regrid_tides, segment.encode_tidal_files_and_output) + - Combined all functions of NWA25 into a four function process (in the style of rm6) (expt.setup_tides_rectangular_boundaries, coords, segment.regrid_tides, segment.encode_tidal_files_and_output) Original Code was sourced from: diff --git a/regional_mom6/regridding.py b/regional_mom6/regridding.py index b4026e3f..adebb7a5 100644 --- a/regional_mom6/regridding.py +++ b/regional_mom6/regridding.py @@ -36,15 +36,22 @@ regridding_logger = setup_logger(__name__) -def coords(hgrid: xr.Dataset, orientation: str, segment_name: str) -> xr.Dataset: +def coords( + hgrid: xr.Dataset, + orientation: str, + segment_name: str, + coords_at_t_points=False, + angle_variable_name="angle_dx", +) -> xr.Dataset: """ This function: - Allows us to call the self.coords for use in the xesmf.Regridder in the regrid_tides function. self.coords gives us the subset of the hgrid based on the orientation. + Allows us to call the coords for use in the xesmf.Regridder in the regrid_tides function. self.coords gives us the subset of the hgrid based on the orientation. Args: hgrid (xr.Dataset): The hgrid dataset orientation (str): The orientation of the boundary segment_name (str): The name of the segment + coords_at_t_points (bool, optional): Whether to return the boundary t-points instead of the q/u/v of a general boundary for rotation. Defaults to False. Returns: xr.Dataset: The correct coordinate space for the orientation @@ -57,13 +64,37 @@ def coords(hgrid: xr.Dataset, orientation: str, segment_name: str) -> xr.Dataset Web Address: https://github.com/jsimkins2/nwa25 """ + + dataset_to_get_coords = None + + if coords_at_t_points: + regridding_logger.info("Creating coordinates of the boundary t-points") + + # Calc T Point Info + ds = get_hgrid_arakawa_c_points(hgrid, "t") + + tangle_dx = hgrid[angle_variable_name][(ds.t_points_y, ds.t_points_x)] + # Assign to dataset + dataset_to_get_coords = xr.Dataset( + { + "x": ds.tlon, + "y": ds.tlat, + angle_variable_name: (("nyp", "nxp"), tangle_dx.values), + }, + coords={"nyp": ds.nyp, "nxp": ds.nxp}, + ) + else: + regridding_logger.info("Creating coordinates of the boundary q/u/v points") + # Don't have to do anything because this is the actual boundary. t-points are one-index deep and require managing. + dataset_to_get_coords = hgrid + # Rename nxp and nyp to locations if orientation == "south": rcoord = xr.Dataset( { - "lon": hgrid["x"].isel(nyp=0), - "lat": hgrid["y"].isel(nyp=0), - "angle": hgrid["angle_dx"].isel(nyp=0), + "lon": dataset_to_get_coords["x"].isel(nyp=0), + "lat": dataset_to_get_coords["y"].isel(nyp=0), + "angle": dataset_to_get_coords[angle_variable_name].isel(nyp=0), } ) rcoord = rcoord.rename_dims({"nxp": f"nx_{segment_name}"}) @@ -75,9 +106,9 @@ def coords(hgrid: xr.Dataset, orientation: str, segment_name: str) -> xr.Dataset elif orientation == "north": rcoord = xr.Dataset( { - "lon": hgrid["x"].isel(nyp=-1), - "lat": hgrid["y"].isel(nyp=-1), - "angle": hgrid["angle_dx"].isel(nyp=-1), + "lon": dataset_to_get_coords["x"].isel(nyp=-1), + "lat": dataset_to_get_coords["y"].isel(nyp=-1), + "angle": dataset_to_get_coords[angle_variable_name].isel(nyp=-1), } ) rcoord = rcoord.rename_dims({"nxp": f"nx_{segment_name}"}) @@ -87,9 +118,9 @@ def coords(hgrid: xr.Dataset, orientation: str, segment_name: str) -> xr.Dataset elif orientation == "west": rcoord = xr.Dataset( { - "lon": hgrid["x"].isel(nxp=0), - "lat": hgrid["y"].isel(nxp=0), - "angle": hgrid["angle_dx"].isel(nxp=0), + "lon": dataset_to_get_coords["x"].isel(nxp=0), + "lat": dataset_to_get_coords["y"].isel(nxp=0), + "angle": dataset_to_get_coords[angle_variable_name].isel(nxp=0), } ) rcoord = rcoord.rename_dims({"nyp": f"ny_{segment_name}"}) @@ -99,9 +130,9 @@ def coords(hgrid: xr.Dataset, orientation: str, segment_name: str) -> xr.Dataset elif orientation == "east": rcoord = xr.Dataset( { - "lon": hgrid["x"].isel(nxp=-1), - "lat": hgrid["y"].isel(nxp=-1), - "angle": hgrid["angle_dx"].isel(nxp=-1), + "lon": dataset_to_get_coords["x"].isel(nxp=-1), + "lat": dataset_to_get_coords["y"].isel(nxp=-1), + "angle": dataset_to_get_coords[angle_variable_name].isel(nxp=-1), } ) rcoord = rcoord.rename_dims({"nyp": f"ny_{segment_name}"}) @@ -115,10 +146,64 @@ def coords(hgrid: xr.Dataset, orientation: str, segment_name: str) -> xr.Dataset return rcoord +def get_hgrid_arakawa_c_points(hgrid: xr.Dataset, point_type="t") -> xr.Dataset: + """ + Get the Arakawa C points from the Hgrid, originally written by Fred (Castruccio) and moved to RM6 + Parameters + ---------- + hgrid: xr.Dataset + The hgrid dataset + Returns + ------- + xr.Dataset + The specific points x, y, & point indexes + """ + if point_type not in "uvqth": + raise ValueError("point_type must be one of 'uvqht'") + + regridding_logger.info("Getting {} points..".format(point_type)) + + # Figure out the maths for the offset + k = 2 + kp2 = k // 2 + offset_one_by_two_y = np.arange(kp2, len(hgrid.x.nyp), k) + offset_one_by_two_x = np.arange(kp2, len(hgrid.x.nxp), k) + by_two_x = np.arange(0, len(hgrid.x.nxp), k) + by_two_y = np.arange(0, len(hgrid.x.nyp), k) + + # T point locations + if point_type == "t" or point_type == "h": + points = (offset_one_by_two_y, offset_one_by_two_x) + # U point locations + elif point_type == "u": + points = (offset_one_by_two_y, by_two_x) + # V point locations + elif point_type == "v": + points = (by_two_y, offset_one_by_two_x) + # Corner point locations + elif point_type == "q": + points = (by_two_y, by_two_x) + else: + raise ValueError("Invalid Point Type (u, v, q, or t/h only)") + + point_dataset = xr.Dataset( + { + "{}lon".format(point_type): hgrid.x[points], + "{}lat".format(point_type): hgrid.y[points], + "{}_points_y".format(point_type): points[0], + "{}_points_x".format(point_type): points[1], + } + ) + point_dataset.attrs["description"] = ( + "Arakawa C {}-points of supplied h-grid".format(point_type) + ) + return point_dataset + + def create_regridder( forcing_variables: xr.Dataset, output_grid: xr.Dataset, - outfile: Path = Path(".temp"), + outfile: Path = None, method: str = "bilinear", ) -> xe.Regridder: """ @@ -229,7 +314,7 @@ def generate_dz(ds: xr.Dataset, z_dim_name: str) -> xr.Dataset: def add_secondary_dimension( - ds: xr.Dataset, var: str, coords, segment_name: str + ds: xr.Dataset, var: str, coords, segment_name: str, to_beginning=False ) -> xr.Dataset: """Add the perpendiciular dimension to the dataset, even if it's like one val. It's required. Parameters @@ -242,6 +327,8 @@ def add_secondary_dimension( The coordinates from the function coords... segment_name : str The segment name + to_beginning : bool, optional + Whether to add the perpendicular dimension to the beginning or to the selected position, by default False Returns ------- xr.Dataset @@ -257,12 +344,20 @@ def add_secondary_dimension( "Checking if nz or constituent is in dimensions, then we have to bump the perpendicular dimension up by one" ) insert_behind_by = 0 - if any(coord.startswith("nz") or coord == "constituent" for coord in ds[var].dims): - regridding_logger.debug("Bump it by one") - insert_behind_by = 0 + if not to_beginning: + + if any( + coord.startswith("nz") or coord == "constituent" for coord in ds[var].dims + ): + regridding_logger.debug("Bump it by one") + insert_behind_by = 0 + else: + # Missing vertical dim or tidal coord means we don't need to offset the perpendicular + insert_behind_by = 1 else: - # Missing vertical dim or tidal coord means we don't need to offset the perpendicular - insert_behind_by = 1 + insert_behind_by = coords.attrs[ + "axis_to_expand" + ] # Just magic to add dim to the beginning regridding_logger.debug(f"Expand dimensions") ds[var] = ds[var].expand_dims( diff --git a/regional_mom6/rotation.py b/regional_mom6/rotation.py new file mode 100644 index 00000000..9c3900dd --- /dev/null +++ b/regional_mom6/rotation.py @@ -0,0 +1,250 @@ +from .utils import setup_logger + +rotation_logger = setup_logger(__name__) +# An Enum is like a dropdown selection for a menu, it essentially limits the type of input parameters. It comes with additional complexity, which of course is always a challenge. +from enum import Enum +import xarray as xr +import numpy as np +from .regridding import get_hgrid_arakawa_c_points + + +class RotationMethod(Enum): + """ + This Enum defines the rotational method to be used in boundary conditions. The main regional mom6 class passes in this enum to regrid_tides and regrid_velocity_tracers to determine the method used. + + EXPAND_GRID: This method is used with the basis that we can find the angles at the q-u-v points by pretending we have another row/column of the hgrid with the same distances as the t-point to u/v points in the actual grid then use the four poitns to calculate the angle the exact same way MOM6 does. + GIVEN_ANGLE: This is the original default RM6 method which expects a pre-given angle called angle_dx + NO_ROTATION: Grids parallel to lat/lon axes, no rotation needed + """ + + EXPAND_GRID = 1 + GIVEN_ANGLE = 2 + NO_ROTATION = 3 + + +def initialize_grid_rotation_angles_using_expanded_hgrid( + hgrid: xr.Dataset, +) -> xr.Dataset: + """ + Calculate the angle_dx in degrees from the true x (east?) direction counterclockwise) and return as dataarray + + Parameters + ---------- + hgrid: xr.Dataset + The hgrid dataset + Returns + ------- + xr.DataArray + The t-point angles + """ + # Get expanded (pseudo) grid + expanded_hgrid = create_expanded_hgrid(hgrid) + + return mom6_angle_calculation_method( + expanded_hgrid.x.max() - expanded_hgrid.x.min(), + expanded_hgrid.isel(nyp=slice(2, None), nxp=slice(0, -2)), + expanded_hgrid.isel(nyp=slice(2, None), nxp=slice(2, None)), + expanded_hgrid.isel(nyp=slice(0, -2), nxp=slice(0, -2)), + expanded_hgrid.isel(nyp=slice(0, -2), nxp=slice(2, None)), + hgrid, + ) + + +def initialize_grid_rotation_angle(hgrid: xr.Dataset) -> xr.DataArray: + """ + Calculate the angle_dx in degrees from the true x (east?) direction counterclockwise) and return as DataArray + Parameters + ---------- + hgrid: xr.Dataset + The hgrid dataset + Returns + ------- + xr.DataArray + The t-point angles + """ + ds_t = get_hgrid_arakawa_c_points(hgrid, "t") + ds_q = get_hgrid_arakawa_c_points(hgrid, "q") + + # Reformat into x, y comps + t_points = xr.Dataset( + { + "x": (("nyp", "nxp"), ds_t.tlon.data), + "y": (("nyp", "nxp"), ds_t.tlat.data), + } + ) + q_points = xr.Dataset( + { + "x": (("nyp", "nxp"), ds_q.qlon.data), + "y": (("nyp", "nxp"), ds_q.qlat.data), + } + ) + + return mom6_angle_calculation_method( + hgrid.x.max() - hgrid.x.min(), + q_points.isel(nyp=slice(1, None), nxp=slice(0, -1)), + q_points.isel(nyp=slice(1, None), nxp=slice(1, None)), + q_points.isel(nyp=slice(0, -1), nxp=slice(0, -1)), + q_points.isel(nyp=slice(0, -1), nxp=slice(1, None)), + t_points, + ) + + +def modulo_around_point(x, xc, Lx): + """ + This function calculates the modulo around a point. Return the modulo value of x in an interval [xc-(Lx/2) xc+(Lx/2)]. If Lx<=0, then it returns x without applying modulo arithmetic. + Parameters + ---------- + x: float + Value to which to apply modulo arithmetic + xc: float + Center of modulo range + Lx: float + Modulo range width + Returns + ------- + float + x shifted by an integer multiple of Lx to be close to xc, + """ + if Lx <= 0: + return x + else: + return ((x - (xc - 0.5 * Lx)) % Lx) - Lx / 2 + xc + + +def mom6_angle_calculation_method( + len_lon, + top_left: xr.DataArray, + top_right: xr.DataArray, + bottom_left: xr.DataArray, + bottom_right: xr.DataArray, + point: xr.DataArray, +) -> xr.DataArray: + """ + Calculate the angle of the point using the MOM6 method in initialize_grid_rotation_angle. Built for vectorized calculations + Parameters + ---------- + len_lon: float + The length of the longitude of the regional domain + top_left, top_right, bottom_left, bottom_right: xr.DataArray + The four points around the point to calculate the angle from the hgrid requires an x and y component + point: xr.DataArray + The point to calculate the angle from the hgrid + Returns + ------- + xr.DataArray + The angle of the point + """ + rotation_logger.info("Calculating grid rotation angle") + # Direct Translation + pi_720deg = ( + np.arctan(1) / 180 + ) # One quarter the conversion factor from degrees to radians + + # Compute lonB for all points + lonB = np.zeros((2, 2, len(point.nyp), len(point.nxp))) + + # Vectorized computation of lonB + # Vectorized computation of lonB + lonB[0][0] = modulo_around_point(bottom_left.x, point.x, len_lon) # Bottom Left + lonB[1][0] = modulo_around_point(top_left.x, point.x, len_lon) # Top Left + lonB[1][1] = modulo_around_point(top_right.x, point.x, len_lon) # Top Right + lonB[0][1] = modulo_around_point(bottom_right.x, point.x, len_lon) # Bottom Right + + # Compute lon_scale + lon_scale = np.cos( + pi_720deg * ((bottom_left.y + bottom_right.y) + (top_right.y + top_left.y)) + ) + + # Compute angle + angle = np.arctan2( + lon_scale * ((lonB[0, 1] - lonB[1, 0]) + (lonB[1, 1] - lonB[0, 0])), + (bottom_left.y - top_right.y) + (top_left.y - bottom_right.y), + ) + # Assign angle to angles_arr + angles_arr = np.rad2deg(angle) - 90 + + # Assign angles_arr to hgrid + t_angles = xr.DataArray( + angles_arr, + dims=["nyp", "nxp"], + coords={ + "nyp": point.nyp.values, + "nxp": point.nxp.values, + }, + ) + return t_angles + + +def create_expanded_hgrid(hgrid: xr.Dataset, expansion_width=1) -> xr.Dataset: + """ + Adds an additional boundary to the hgrid to allow for the calculation of the angle_dx for the boundary points using the method in MOM6 + """ + if expansion_width != 1: + raise NotImplementedError("Only expansion_width = 1 is supported") + + pseudo_hgrid_x = np.full((len(hgrid.nyp) + 2, len(hgrid.nxp) + 2), np.nan) + pseudo_hgrid_y = np.full((len(hgrid.nyp) + 2, len(hgrid.nxp) + 2), np.nan) + + ## Fill Boundaries + pseudo_hgrid_x[1:-1, 1:-1] = hgrid.x.values + pseudo_hgrid_x[0, 1:-1] = hgrid.x.values[0, :] - ( + hgrid.x.values[1, :] - hgrid.x.values[0, :] + ) # Bottom Fill + pseudo_hgrid_x[-1, 1:-1] = hgrid.x.values[-1, :] + ( + hgrid.x.values[-1, :] - hgrid.x.values[-2, :] + ) # Top Fill + pseudo_hgrid_x[1:-1, 0] = hgrid.x.values[:, 0] - ( + hgrid.x.values[:, 1] - hgrid.x.values[:, 0] + ) # Left Fill + pseudo_hgrid_x[1:-1, -1] = hgrid.x.values[:, -1] + ( + hgrid.x.values[:, -1] - hgrid.x.values[:, -2] + ) # Right Fill + + pseudo_hgrid_y[1:-1, 1:-1] = hgrid.y.values + pseudo_hgrid_y[0, 1:-1] = hgrid.y.values[0, :] - ( + hgrid.y.values[1, :] - hgrid.y.values[0, :] + ) # Bottom Fill + pseudo_hgrid_y[-1, 1:-1] = hgrid.y.values[-1, :] + ( + hgrid.y.values[-1, :] - hgrid.y.values[-2, :] + ) # Top Fill + pseudo_hgrid_y[1:-1, 0] = hgrid.y.values[:, 0] - ( + hgrid.y.values[:, 1] - hgrid.y.values[:, 0] + ) # Left Fill + pseudo_hgrid_y[1:-1, -1] = hgrid.y.values[:, -1] + ( + hgrid.y.values[:, -1] - hgrid.y.values[:, -2] + ) # Right Fill + + ## Fill Corners + pseudo_hgrid_x[0, 0] = hgrid.x.values[0, 0] - ( + hgrid.x.values[1, 1] - hgrid.x.values[0, 0] + ) # Bottom Left + pseudo_hgrid_x[-1, 0] = hgrid.x.values[-1, 0] - ( + hgrid.x.values[-2, 1] - hgrid.x.values[-1, 0] + ) # Top Left + pseudo_hgrid_x[0, -1] = hgrid.x.values[0, -1] - ( + hgrid.x.values[1, -2] - hgrid.x.values[0, -1] + ) # Bottom Right + pseudo_hgrid_x[-1, -1] = hgrid.x.values[-1, -1] - ( + hgrid.x.values[-2, -2] - hgrid.x.values[-1, -1] + ) # Top Right + + pseudo_hgrid_y[0, 0] = hgrid.y.values[0, 0] - ( + hgrid.y.values[1, 1] - hgrid.y.values[0, 0] + ) # Bottom Left + pseudo_hgrid_y[-1, 0] = hgrid.y.values[-1, 0] - ( + hgrid.y.values[-2, 1] - hgrid.y.values[-1, 0] + ) # Top Left + pseudo_hgrid_y[0, -1] = hgrid.y.values[0, -1] - ( + hgrid.y.values[1, -2] - hgrid.y.values[0, -1] + ) # Bottom Right + pseudo_hgrid_y[-1, -1] = hgrid.y.values[-1, -1] - ( + hgrid.y.values[-2, -2] - hgrid.y.values[-1, -1] + ) # Top Right + + pseudo_hgrid = xr.Dataset( + { + "x": (["nyp", "nxp"], pseudo_hgrid_x), + "y": (["nyp", "nxp"], pseudo_hgrid_y), + } + ) + return pseudo_hgrid diff --git a/regional_mom6/utils.py b/regional_mom6/utils.py index 91a96c36..d499430e 100644 --- a/regional_mom6/utils.py +++ b/regional_mom6/utils.py @@ -1,6 +1,7 @@ import numpy as np import logging import sys +import xarray as xr def vecdot(v1, v2): @@ -318,3 +319,17 @@ def setup_logger(name: str) -> logging.Logger: # Add the handler to the logger logger.addHandler(handler) return logger + + +def is_rectilinear_hgrid(hgrid: xr.Dataset) -> bool: + """ + Check if the hgrid is a rectilinear grid. + """ + if hgrid.x.shape[0] < 2 or hgrid.x.shape[1] < 2: + raise ValueError("hgrid must have at least 2 points in each direction") + if not np.all(hgrid.y == hgrid.y[:, 0].values[:, np.newaxis]): + return False + if not np.all(hgrid.x == hgrid.x[0, :].values[np.newaxis, :]): + return False + + return True diff --git a/tests/conftest.py b/tests/conftest.py new file mode 100644 index 00000000..db1bf2cf --- /dev/null +++ b/tests/conftest.py @@ -0,0 +1,29 @@ +import pytest +import os +import xarray as xr + +# Define the path where the curvilinear hgrid file is expected in the Docker container +DOCKER_FILE_PATH = "/data/small_curvilinear_hgrid.nc" + + +# Define the local directory where the user might have added the curvilinear hgrid file +LOCAL_FILE_PATH = ( + "/glade/u/home/manishrv/documents/nwa12_0.1/tides_dev/small_curvilinear_hgrid.nc" +) + + +@pytest.fixture +def get_curvilinear_hgrid(): + # Check if the file exists in the Docker-specific location + if os.path.exists(DOCKER_FILE_PATH): + return xr.open_dataset(DOCKER_FILE_PATH) + + # Check if the user has provided the file in a specific local directory + elif os.path.exists(LOCAL_FILE_PATH): + return xr.open_dataset(LOCAL_FILE_PATH) + + # If neither location contains the file, raise an error + else: + pytest.skip( + f"Required file 'hgrid.nc' not found in {DOCKER_FILE_PATH} or {LOCAL_FILE_PATH}" + ) diff --git a/tests/test_config.py b/tests/test_config.py index eefc4297..31d55886 100644 --- a/tests/test_config.py +++ b/tests/test_config.py @@ -102,11 +102,12 @@ def test_load_config(tmp_path): ## Directory where you'll run the experiment from run_dir = Path( + tmp_path, os.path.join( tmp_path, expt_name, "run_files", - ) + ), ) data_path = Path(tmp_path / "data") for path in (run_dir, input_dir, data_path): @@ -126,7 +127,7 @@ def test_load_config(tmp_path): mom_input_dir=input_dir, toolpath_dir="", ) - path = os.path.join(tmp_path, "testing_config.json") + path = tmp_path / "testing_config.json" config_expt = expt.write_config_file(path) new_expt = rmom6.create_experiment_from_config( os.path.join(path), mom_input_folder=tmp_path, mom_run_folder=tmp_path diff --git a/tests/test_expt_class.py b/tests/test_expt_class.py index d459aed3..e5554f8e 100644 --- a/tests/test_expt_class.py +++ b/tests/test_expt_class.py @@ -17,8 +17,6 @@ "number_vertical_layers", "layer_thickness_ratio", "depth", - "mom_run_dir", - "mom_input_dir", "toolpath_dir", "hgrid_type", ), @@ -31,8 +29,6 @@ 5, 1, 1000, - "rundir/", - "inputdir/", "toolpath", "even_spacing", ), @@ -46,12 +42,12 @@ def test_setup_bathymetry( number_vertical_layers, layer_thickness_ratio, depth, - mom_run_dir, - mom_input_dir, toolpath_dir, hgrid_type, tmp_path, ): + mom_run_dir = tmp_path / "rundir" + mom_input_dir = tmp_path / "inputdir" expt = experiment( longitude_extent=longitude_extent, latitude_extent=latitude_extent, @@ -166,8 +162,7 @@ def generate_silly_coords( coords = {"silly_lat": silly_lat, "silly_lon": silly_lon, "silly_depth": silly_depth} -mom_run_dir = "rundir/" -mom_input_dir = "inputdir/" + toolpath_dir = "toolpath" hgrid_type = "even_spacing" @@ -198,8 +193,6 @@ def generate_silly_coords( "number_vertical_layers", "layer_thickness_ratio", "depth", - "mom_run_dir", - "mom_input_dir", "toolpath_dir", "hgrid_type", ), @@ -212,8 +205,6 @@ def generate_silly_coords( number_vertical_layers, layer_thickness_ratio, depth, - "rundir/", - "inputdir/", "toolpath", "even_spacing", ), @@ -227,8 +218,6 @@ def test_ocean_forcing( number_vertical_layers, layer_thickness_ratio, depth, - mom_run_dir, - mom_input_dir, toolpath_dir, hgrid_type, temp_dataarray_initial_condition, @@ -246,7 +235,8 @@ def test_ocean_forcing( "silly_lon": silly_lon, "silly_depth": silly_depth, } - + mom_run_dir = tmp_path / "rundir" + mom_input_dir = tmp_path / "inputdir" expt = experiment( longitude_extent=longitude_extent, latitude_extent=latitude_extent, @@ -332,8 +322,6 @@ def test_ocean_forcing( "number_vertical_layers", "layer_thickness_ratio", "depth", - "mom_run_dir", - "mom_input_dir", "toolpath_dir", "hgrid_type", ), @@ -346,8 +334,6 @@ def test_ocean_forcing( 5, 1, 1000, - "rundir/", - "inputdir/", "toolpath", "even_spacing", ), @@ -361,8 +347,6 @@ def test_rectangular_boundaries( number_vertical_layers, layer_thickness_ratio, depth, - mom_run_dir, - mom_input_dir, toolpath_dir, hgrid_type, tmp_path, @@ -443,7 +427,8 @@ def test_rectangular_boundaries( ) eastern_boundary.to_netcdf(tmp_path / "east_unprocessed.nc") eastern_boundary.close() - + mom_run_dir = tmp_path / "rundir" + mom_input_dir = tmp_path / "inputdir" expt = experiment( longitude_extent=longitude_extent, latitude_extent=latitude_extent, diff --git a/tests/test_manish_branch.py b/tests/test_manish_branch.py deleted file mode 100644 index 98755c8d..00000000 --- a/tests/test_manish_branch.py +++ /dev/null @@ -1,338 +0,0 @@ -""" -Test suite for everything involed in pr #12 -""" - -import regional_mom6 as rmom6 -import os -import pytest -import logging -from pathlib import Path -import xarray as xr -import numpy as np -import shutil -import importlib - -IN_GITHUB_ACTIONS = os.getenv("GITHUB_ACTIONS") == "true" - - -@pytest.fixture(scope="module") -def dummy_tidal_data(): - nx = 2160 - ny = 1081 - nc = 15 - nct = 4 - - # Define tidal constituents - con_list = [ - "m2 ", - "s2 ", - "n2 ", - "k2 ", - "k1 ", - "o1 ", - "p1 ", - "q1 ", - "mm ", - "mf ", - "m4 ", - "mn4 ", - "ms4 ", - "2n2 ", - "s1 ", - ] - con_data = np.array([list(con) for con in con_list], dtype="S1") - - # Generate random data for the variables - lon_z_data = np.tile(np.linspace(-180, 180, nx), (ny, 1)).T - lat_z_data = np.tile(np.linspace(-90, 90, ny), (nx, 1)) - ha_data = np.random.rand(nc, nx, ny) - hp_data = np.random.rand(nc, nx, ny) * 360 # Random phases between 0 and 360 - hRe_data = np.random.rand(nc, nx, ny) - hIm_data = np.random.rand(nc, nx, ny) - - # Create the xarray dataset - ds_h = xr.Dataset( - { - "con": (["nc", "nct"], con_data), - "lon_z": (["nx", "ny"], lon_z_data), - "lat_z": (["nx", "ny"], lat_z_data), - "ha": (["nc", "nx", "ny"], ha_data), - "hp": (["nc", "nx", "ny"], hp_data), - "hRe": (["nc", "nx", "ny"], hRe_data), - "hIm": (["nc", "nx", "ny"], hIm_data), - }, - coords={ - "nc": np.arange(nc), - "nct": np.arange(nct), - "nx": np.arange(nx), - "ny": np.arange(ny), - }, - attrs={ - "type": "Fake OTIS tidal elevation file", - "title": "Fake TPXO9.v1 2018 tidal elevation file", - }, - ) - - # Generate random data for the variables for u_tpxo9.v1 - lon_u_data = ( - np.random.rand(nx, ny) * 360 - 180 - ) # Random longitudes between -180 and 180 - lat_u_data = ( - np.random.rand(nx, ny) * 180 - 90 - ) # Random latitudes between -90 and 90 - lon_v_data = ( - np.random.rand(nx, ny) * 360 - 180 - ) # Random longitudes between -180 and 180 - lat_v_data = ( - np.random.rand(nx, ny) * 180 - 90 - ) # Random latitudes between -90 and 90 - Ua_data = np.random.rand(nc, nx, ny) - ua_data = np.random.rand(nc, nx, ny) - up_data = np.random.rand(nc, nx, ny) * 360 # Random phases between 0 and 360 - Va_data = np.random.rand(nc, nx, ny) - va_data = np.random.rand(nc, nx, ny) - vp_data = np.random.rand(nc, nx, ny) * 360 # Random phases between 0 and 360 - URe_data = np.random.rand(nc, nx, ny) - UIm_data = np.random.rand(nc, nx, ny) - VRe_data = np.random.rand(nc, nx, ny) - VIm_data = np.random.rand(nc, nx, ny) - - # Create the xarray dataset for u_tpxo9.v1 - ds_u = xr.Dataset( - { - "con": (["nc", "nct"], con_data), - "lon_u": (["nx", "ny"], lon_u_data), - "lat_u": (["nx", "ny"], lat_u_data), - "lon_v": (["nx", "ny"], lon_v_data), - "lat_v": (["nx", "ny"], lat_v_data), - "Ua": (["nc", "nx", "ny"], Ua_data), - "ua": (["nc", "nx", "ny"], ua_data), - "up": (["nc", "nx", "ny"], up_data), - "Va": (["nc", "nx", "ny"], Va_data), - "va": (["nc", "nx", "ny"], va_data), - "vp": (["nc", "nx", "ny"], vp_data), - "URe": (["nc", "nx", "ny"], URe_data), - "UIm": (["nc", "nx", "ny"], UIm_data), - "VRe": (["nc", "nx", "ny"], VRe_data), - "VIm": (["nc", "nx", "ny"], VIm_data), - }, - coords={ - "nc": np.arange(nc), - "nct": np.arange(nct), - "nx": np.arange(nx), - "ny": np.arange(ny), - }, - attrs={ - "type": "Fake OTIS tidal transport file", - "title": "Fake TPXO9.v1 2018 WE/SN transports/currents file", - }, - ) - - return ds_h, ds_u - - -@pytest.fixture(scope="module") -def dummy_bathymetry_data(): - latitude_extent = [16.0, 27] - longitude_extent = [192, 209] - - bathymetry = np.random.random((100, 100)) * (-100) - bathymetry = xr.DataArray( - bathymetry, - dims=["silly_lat", "silly_lon"], - coords={ - "silly_lat": np.linspace( - latitude_extent[0] - 5, latitude_extent[1] + 5, 100 - ), - "silly_lon": np.linspace( - longitude_extent[0] - 5, longitude_extent[1] + 5, 100 - ), - }, - ) - bathymetry.name = "silly_depth" - return bathymetry - - -class TestAll: - - @pytest.fixture(scope="module") - def full_legit_expt_setup(self, dummy_bathymetry_data, tmp_path): - - expt_name = "testing" - - latitude_extent = [16.0, 27] - longitude_extent = [192, 209] - - date_range = ["2005-01-01 00:00:00", "2005-02-01 00:00:00"] - - ## Place where all your input files go - input_dir = Path( - os.path.join( - tmp_path, - expt_name, - "inputs", - ) - ) - - ## Directory where you'll run the experiment from - run_dir = Path( - os.path.join( - tmp_path, - expt_name, - "run_files", - ) - ) - data_path = Path(tmp_path / "data") - for path in (run_dir, input_dir, data_path): - os.makedirs(str(path), exist_ok=True) - bathy_path = data_path / "bathymetry.nc" - bathymetry = dummy_bathymetry_data - bathymetry.to_netcdf(bathy_path) - self.glorys_path = bathy_path - ## User-1st, test if we can even read the angled nc files. - expt = rmom6.experiment( - longitude_extent=longitude_extent, - latitude_extent=latitude_extent, - date_range=date_range, - resolution=0.05, - number_vertical_layers=75, - layer_thickness_ratio=10, - depth=4500, - minimum_depth=5, - mom_run_dir=run_dir, - mom_input_dir=input_dir, - toolpath_dir="", - ) - return expt - - def test_full_legit_expt_setup(self, tmp_path, dummy_bathymetry_data): - expt_name = "testing" - latitude_extent = [16.0, 27] - longitude_extent = [192, 209] - - date_range = ["2005-01-01 00:00:00", "2005-02-01 00:00:00"] - - ## Place where all your input files go - input_dir = Path( - os.path.join( - tmp_path, - expt_name, - "inputs", - ) - ) - - ## Directory where you'll run the experiment from - run_dir = Path( - os.path.join( - tmp_path, - expt_name, - "run_files", - ) - ) - data_path = Path(tmp_path / "data") - for path in (run_dir, input_dir, data_path): - os.makedirs(str(path), exist_ok=True) - bathy_path = data_path / "bathymetry.nc" - bathymetry = dummy_bathymetry_data - bathymetry.to_netcdf(bathy_path) - ## User-1st, test if we can even read the angled nc files. - expt = rmom6.experiment( - longitude_extent=longitude_extent, - latitude_extent=latitude_extent, - date_range=date_range, - resolution=0.05, - number_vertical_layers=75, - layer_thickness_ratio=10, - depth=4500, - minimum_depth=5, - mom_run_dir=run_dir, - mom_input_dir=input_dir, - toolpath_dir="", - ) - assert str(expt) - - def test_tides(self, dummy_tidal_data, tmp_path): - """ - Test the main setup tides function! - """ - expt_name = "testing" - ## User-1st, test if we can even read the angled nc files. - expt = rmom6.experiment.create_empty( - expt_name=expt_name, - mom_input_dir=tmp_path, - mom_run_dir=tmp_path, - ) - # Generate Fake Tidal Data - ds_h, ds_u = dummy_tidal_data - - # Save to Fake Folder - ds_h.to_netcdf(tmp_path / "h_fake_tidal_data.nc") - ds_u.to_netcdf(tmp_path / "u_fake_tidal_data.nc") - - # Set other required variables needed in setup_tides - - # Lat Long - expt.longitude_extent = (-5, 5) - expt.latitude_extent = (0, 30) - # Grid Type - expt.hgrid_type = "even_spacing" - # DatesÆ’ - expt.date_range = ("2000-01-01", "2000-01-02") - expt.segments = {} - # Generate Hgrid Data - expt.resolution = 0.1 - expt.hgrid = expt._make_hgrid() - # Create Forcing Folder - os.makedirs(tmp_path / "forcing", exist_ok=True) - - expt.setup_boundary_tides( - tmp_path / "h_fake_tidal_data.nc", - tmp_path / "u_fake_tidal_data.nc", - ) - - def test_change_MOM_parameter(self, tmp_path): - """ - Test the change MOM parameter function, as well as read_MOM_file and write_MOM_file under the hood. - """ - expt_name = "testing" - ## User-1st, test if we can even read the angled nc files. - expt = rmom6.experiment.create_empty( - expt_name=expt_name, - mom_input_dir=tmp_path, - mom_run_dir=tmp_path, - ) - # Copy over the MOM Files to the dump_files_dir - base_run_dir = Path( - os.path.join( - importlib.resources.files("regional_mom6").parent, - "demos", - "premade_run_directories", - ) - ) - shutil.copytree( - base_run_dir / "common_files", expt.mom_run_dir, dirs_exist_ok=True - ) - MOM_override_dict = expt.read_MOM_file_as_dict("MOM_override") - og = expt.change_MOM_parameter("DT", "30", "COOL COMMENT") - MOM_override_dict_new = expt.read_MOM_file_as_dict("MOM_override") - assert MOM_override_dict_new["DT"]["value"] == "30" - assert MOM_override_dict["DT"]["value"] == og - assert MOM_override_dict_new["DT"]["comment"] == "COOL COMMENT\n" - - def test_properties_empty(self, tmp_path): - """ - Test the properties - """ - expt_name = "testing" - ## User-1st, test if we can even read the angled nc files. - expt = rmom6.experiment.create_empty( - expt_name=expt_name, - mom_input_dir=tmp_path, - mom_run_dir=tmp_path, - ) - dss = expt.era5 - dss_2 = expt.tides_boundaries - dss_3 = expt.ocean_state_boundaries - dss_4 = expt.initial_condition - dss_5 = expt.bathymetry_property - print(dss, dss_2, dss_3, dss_4, dss_5) diff --git a/tests/test_regridding.py b/tests/test_regridding.py new file mode 100644 index 00000000..4d163ea5 --- /dev/null +++ b/tests/test_regridding.py @@ -0,0 +1,41 @@ +import regional_mom6 as rm6 +import regional_mom6.rotation as rot +import regional_mom6.regridding as rgd +import pytest +import xarray as xr +import numpy as np + + +# Not testing get_arakawa_c_points, coords, & create_regridder +def test_smoke_untested_funcs(get_curvilinear_hgrid): + hgrid = get_curvilinear_hgrid + assert rgd.get_hgrid_arakawa_c_points(hgrid, "t") + assert rgd.coords(hgrid, "north", "segment_002") + + +def test_fill_missing_data(): + return + + +def test_add_or_update_time_dim(): + return + + +def test_generate_dz(): + return + + +def test_add_secondary_dimension(): + return + + +def test_add_vertical_coordinate_encoding(): + return + + +def test_generate_layer_thickness(): + return + + +def test_generate_encoding(): + return diff --git a/tests/test_rotation.py b/tests/test_rotation.py new file mode 100644 index 00000000..ccf29d2d --- /dev/null +++ b/tests/test_rotation.py @@ -0,0 +1,233 @@ +import regional_mom6 as rm6 +import regional_mom6.rotation as rot +import regional_mom6.regridding as rgd +import pytest +import xarray as xr +import numpy as np +import os + + +def test_get_curvilinear_hgrid_fixture(get_curvilinear_hgrid): + # If the fixture fails to find the file, the test will be skipped. + assert get_curvilinear_hgrid is not None + + +def test_expanded_hgrid_generation(get_curvilinear_hgrid): + hgrid = get_curvilinear_hgrid + expanded_hgrid = rot.create_expanded_hgrid(hgrid) + + # Check Size + assert len(expanded_hgrid.nxp) == (len(hgrid.nxp) + 2) + assert len(expanded_hgrid.nyp) == (len(hgrid.nyp) + 2) + + # Check pseudo_hgrid keeps the same values + assert (expanded_hgrid.x.values[1:-1, 1:-1] == hgrid.x.values).all() + assert (expanded_hgrid.y.values[1:-1, 1:-1] == hgrid.y.values).all() + + # Check extra boundary has realistic values + diff_check = 1 + assert ( + ( + expanded_hgrid.x.values[0, 1:-1] + - (hgrid.x.values[0, :] - (hgrid.x.values[1, :] - hgrid.x.values[0, :])) + ) + < diff_check + ).all() + assert ( + ( + expanded_hgrid.x.values[1:-1, 0] + - (hgrid.x.values[:, 0] - (hgrid.x.values[:, 1] - hgrid.x.values[:, 0])) + ) + < diff_check + ).all() + assert ( + ( + expanded_hgrid.x.values[-1, 1:-1] + - (hgrid.x.values[-1, :] - (hgrid.x.values[-2, :] - hgrid.x.values[-1, :])) + ) + < diff_check + ).all() + assert ( + ( + expanded_hgrid.x.values[1:-1, -1] + - (hgrid.x.values[:, -1] - (hgrid.x.values[:, -2] - hgrid.x.values[:, -1])) + ) + < diff_check + ).all() + + # Check corners for the same... + assert ( + expanded_hgrid.x.values[0, 0] + - (hgrid.x.values[0, 0] - (hgrid.x.values[1, 1] - hgrid.x.values[0, 0])) + ) < diff_check + assert ( + expanded_hgrid.x.values[-1, 0] + - (hgrid.x.values[-1, 0] - (hgrid.x.values[-2, 1] - hgrid.x.values[-1, 0])) + ) < diff_check + assert ( + expanded_hgrid.x.values[0, -1] + - (hgrid.x.values[0, -1] - (hgrid.x.values[1, -2] - hgrid.x.values[0, -1])) + ) < diff_check + assert ( + expanded_hgrid.x.values[-1, -1] + - (hgrid.x.values[-1, -1] - (hgrid.x.values[-2, -2] - hgrid.x.values[-1, -1])) + ) < diff_check + + # Same for y + assert ( + ( + expanded_hgrid.y.values[0, 1:-1] + - (hgrid.y.values[0, :] - (hgrid.y.values[1, :] - hgrid.y.values[0, :])) + ) + < diff_check + ).all() + assert ( + ( + expanded_hgrid.y.values[1:-1, 0] + - (hgrid.y.values[:, 0] - (hgrid.y.values[:, 1] - hgrid.y.values[:, 0])) + ) + < diff_check + ).all() + assert ( + ( + expanded_hgrid.y.values[-1, 1:-1] + - (hgrid.y.values[-1, :] - (hgrid.y.values[-2, :] - hgrid.y.values[-1, :])) + ) + < diff_check + ).all() + assert ( + ( + expanded_hgrid.y.values[1:-1, -1] + - (hgrid.y.values[:, -1] - (hgrid.y.values[:, -2] - hgrid.y.values[:, -1])) + ) + < diff_check + ).all() + + assert ( + expanded_hgrid.y.values[0, 0] + - (hgrid.y.values[0, 0] - (hgrid.y.values[1, 1] - hgrid.y.values[0, 0])) + ) < diff_check + assert ( + expanded_hgrid.y.values[-1, 0] + - (hgrid.y.values[-1, 0] - (hgrid.y.values[-2, 1] - hgrid.y.values[-1, 0])) + ) < diff_check + assert ( + expanded_hgrid.y.values[0, -1] + - (hgrid.y.values[0, -1] - (hgrid.y.values[1, -2] - hgrid.y.values[0, -1])) + ) < diff_check + assert ( + expanded_hgrid.y.values[-1, -1] + - (hgrid.y.values[-1, -1] - (hgrid.y.values[-2, -2] - hgrid.y.values[-1, -1])) + ) < diff_check + + return + + +def test_mom6_angle_calculation_method(get_curvilinear_hgrid): + """ + Check no rotation, up tilt, down tilt. + """ + + # Check no rotation + top_left = xr.Dataset( + { + "x": (("nyp", "nxp"), [[0]]), + "y": (("nyp", "nxp"), [[1]]), + } + ) + top_right = xr.Dataset( + { + "x": (("nyp", "nxp"), [[1]]), + "y": (("nyp", "nxp"), [[1]]), + } + ) + bottom_left = xr.Dataset( + { + "x": (("nyp", "nxp"), [[0]]), + "y": (("nyp", "nxp"), [[0]]), + } + ) + bottom_right = xr.Dataset( + { + "x": (("nyp", "nxp"), [[1]]), + "y": (("nyp", "nxp"), [[0]]), + } + ) + point = xr.Dataset( + { + "x": (("nyp", "nxp"), [[0.5]]), + "y": (("nyp", "nxp"), [[0.5]]), + } + ) + + assert ( + rot.mom6_angle_calculation_method( + 2, top_left, top_right, bottom_left, bottom_right, point + ) + == 0 + ) + + # Angled + hgrid = get_curvilinear_hgrid + ds_t = rgd.get_hgrid_arakawa_c_points(hgrid, "t") + ds_q = rgd.get_hgrid_arakawa_c_points(hgrid, "q") + + # Reformat into x, y comps + t_points = xr.Dataset( + { + "x": (("nyp", "nxp"), ds_t.tlon.data), + "y": (("nyp", "nxp"), ds_t.tlat.data), + } + ) + q_points = xr.Dataset( + { + "x": (("nyp", "nxp"), ds_q.qlon.data), + "y": (("nyp", "nxp"), ds_q.qlat.data), + } + ) + assert ( + ( + rot.mom6_angle_calculation_method( + hgrid.x.max() - hgrid.x.min(), + q_points.isel(nyp=slice(1, None), nxp=slice(0, -1)), + q_points.isel(nyp=slice(1, None), nxp=slice(1, None)), + q_points.isel(nyp=slice(0, -1), nxp=slice(0, -1)), + q_points.isel(nyp=slice(0, -1), nxp=slice(1, None)), + t_points, + ) + - hgrid["angle_dx"].isel(nyp=ds_t.t_points_y, nxp=ds_t.t_points_x).values + ) + < 1 + ).all() + + return + + +def test_initialize_grid_rotation_angle(get_curvilinear_hgrid): + """ + Generate a curvilinear grid and test the grid rotation angle at t_points based on what we pass to generate_curvilinear_grid + """ + hgrid = get_curvilinear_hgrid + angle = rot.initialize_grid_rotation_angle(hgrid) + ds_t = rgd.get_hgrid_arakawa_c_points(hgrid, "t") + assert ( + ( + angle.values + - hgrid["angle_dx"].isel(nyp=ds_t.t_points_y, nxp=ds_t.t_points_x).values + ) + < 1 + ).all() # Angle is correct + assert angle.values.shape == ds_t.tlon.shape # Shape is correct + return + + +def test_initialize_grid_rotation_angle_using_expanded_hgrid(get_curvilinear_hgrid): + """ + Generate a curvilinear grid and test the grid rotation angle at t_points based on what we pass to generate_curvilinear_grid + """ + hgrid = get_curvilinear_hgrid + angle = rot.initialize_grid_rotation_angles_using_expanded_hgrid(hgrid) + + assert (angle.values - hgrid.angle_dx < 1).all() + assert angle.values.shape == hgrid.x.shape + return diff --git a/tests/test_tides_and_parameter.py b/tests/test_tides_and_parameter.py new file mode 100644 index 00000000..8b1e0f99 --- /dev/null +++ b/tests/test_tides_and_parameter.py @@ -0,0 +1,278 @@ +""" +Test suite for everything involed in pr #12 +""" + +import regional_mom6 as rmom6 +import os +import pytest +import logging +from pathlib import Path +import xarray as xr +import numpy as np +import shutil +import importlib + +IN_GITHUB_ACTIONS = os.getenv("GITHUB_ACTIONS") == "true" +# @pytest.mark.skipif( +# IN_GITHUB_ACTIONS, reason="Test doesn't work in Github Actions." +# ) + + +@pytest.fixture(scope="module") +def dummy_tidal_data(): + nx = 100 + ny = 100 + nc = 15 + nct = 4 + + # Define tidal constituents + con_list = [ + "m2 ", + "s2 ", + "n2 ", + "k2 ", + "k1 ", + "o1 ", + "p1 ", + "q1 ", + "mm ", + "mf ", + "m4 ", + "mn4 ", + "ms4 ", + "2n2 ", + "s1 ", + ] + con_data = np.array([list(con) for con in con_list], dtype="S1") + + # Generate random data for the variables + lon_z_data = np.tile(np.linspace(-180, 180, nx), (ny, 1)).T + lat_z_data = np.tile(np.linspace(-90, 90, ny), (nx, 1)) + ha_data = np.random.rand(nc, nx, ny) + hp_data = np.random.rand(nc, nx, ny) * 360 # Random phases between 0 and 360 + hRe_data = np.random.rand(nc, nx, ny) + hIm_data = np.random.rand(nc, nx, ny) + + # Create the xarray dataset + ds_h = xr.Dataset( + { + "con": (["nc", "nct"], con_data), + "lon_z": (["nx", "ny"], lon_z_data), + "lat_z": (["nx", "ny"], lat_z_data), + "ha": (["nc", "nx", "ny"], ha_data), + "hp": (["nc", "nx", "ny"], hp_data), + "hRe": (["nc", "nx", "ny"], hRe_data), + "hIm": (["nc", "nx", "ny"], hIm_data), + }, + coords={ + "nc": np.arange(nc), + "nct": np.arange(nct), + "nx": np.arange(nx), + "ny": np.arange(ny), + }, + attrs={ + "type": "Fake OTIS tidal elevation file", + "title": "Fake TPXO9.v1 2018 tidal elevation file", + }, + ) + + # Generate random data for the variables for u_tpxo9.v1 + lon_u_data = ( + np.random.rand(nx, ny) * 360 - 180 + ) # Random longitudes between -180 and 180 + lat_u_data = ( + np.random.rand(nx, ny) * 180 - 90 + ) # Random latitudes between -90 and 90 + lon_v_data = ( + np.random.rand(nx, ny) * 360 - 180 + ) # Random longitudes between -180 and 180 + lat_v_data = ( + np.random.rand(nx, ny) * 180 - 90 + ) # Random latitudes between -90 and 90 + Ua_data = np.random.rand(nc, nx, ny) + ua_data = np.random.rand(nc, nx, ny) + up_data = np.random.rand(nc, nx, ny) * 360 # Random phases between 0 and 360 + Va_data = np.random.rand(nc, nx, ny) + va_data = np.random.rand(nc, nx, ny) + vp_data = np.random.rand(nc, nx, ny) * 360 # Random phases between 0 and 360 + URe_data = np.random.rand(nc, nx, ny) + UIm_data = np.random.rand(nc, nx, ny) + VRe_data = np.random.rand(nc, nx, ny) + VIm_data = np.random.rand(nc, nx, ny) + + # Create the xarray dataset for u_tpxo9.v1 + ds_u = xr.Dataset( + { + "con": (["nc", "nct"], con_data), + "lon_u": (["nx", "ny"], lon_u_data), + "lat_u": (["nx", "ny"], lat_u_data), + "lon_v": (["nx", "ny"], lon_v_data), + "lat_v": (["nx", "ny"], lat_v_data), + "Ua": (["nc", "nx", "ny"], Ua_data), + "ua": (["nc", "nx", "ny"], ua_data), + "up": (["nc", "nx", "ny"], up_data), + "Va": (["nc", "nx", "ny"], Va_data), + "va": (["nc", "nx", "ny"], va_data), + "vp": (["nc", "nx", "ny"], vp_data), + "URe": (["nc", "nx", "ny"], URe_data), + "UIm": (["nc", "nx", "ny"], UIm_data), + "VRe": (["nc", "nx", "ny"], VRe_data), + "VIm": (["nc", "nx", "ny"], VIm_data), + }, + coords={ + "nc": np.arange(nc), + "nct": np.arange(nct), + "nx": np.arange(nx), + "ny": np.arange(ny), + }, + attrs={ + "type": "Fake OTIS tidal transport file", + "title": "Fake TPXO9.v1 2018 WE/SN transports/currents file", + }, + ) + + return ds_h, ds_u + + +@pytest.fixture(scope="module") +def dummy_bathymetry_data(): + latitude_extent = [16.0, 27] + longitude_extent = [192, 209] + + bathymetry = np.random.random((100, 100)) * (-100) + bathymetry = xr.DataArray( + bathymetry, + dims=["silly_lat", "silly_lon"], + coords={ + "silly_lat": np.linspace( + latitude_extent[0] - 5, latitude_extent[1] + 5, 100 + ), + "silly_lon": np.linspace( + longitude_extent[0] - 5, longitude_extent[1] + 5, 100 + ), + }, + ) + bathymetry.name = "silly_depth" + return bathymetry + + +@pytest.fixture() +def full_expt_setup(dummy_bathymetry_data, tmp_path): + + expt_name = "testing" + + latitude_extent = [16.0, 27] + longitude_extent = [192, 209] + + date_range = ["2005-01-01 00:00:00", "2005-02-01 00:00:00"] + + ## Place where all your input files go + input_dir = Path( + os.path.join( + tmp_path, + expt_name, + "inputs", + ) + ) + + ## Directory where you'll run the experiment from + run_dir = Path( + os.path.join( + tmp_path, + expt_name, + "run_files", + ) + ) + data_path = Path(tmp_path, "data") + for path in (run_dir, input_dir, data_path): + os.makedirs(str(path), exist_ok=True) + bathy_path = data_path / "bathymetry.nc" + bathymetry = dummy_bathymetry_data + bathymetry.to_netcdf(bathy_path) + ## User-1st, test if we can even read the angled nc files. + expt = rmom6.experiment( + longitude_extent=longitude_extent, + latitude_extent=latitude_extent, + date_range=date_range, + resolution=0.05, + number_vertical_layers=75, + layer_thickness_ratio=10, + depth=4500, + minimum_depth=5, + mom_run_dir=run_dir, + mom_input_dir=input_dir, + toolpath_dir="", + ) + return expt + + +def test_full_expt_setup(full_expt_setup): + assert str(full_expt_setup) + + +def test_tides(dummy_tidal_data, tmp_path): + """ + Test the main setup tides function! + """ + expt_name = "testing" + + expt = rmom6.experiment.create_empty( + expt_name=expt_name, + mom_input_dir=tmp_path, + mom_run_dir=tmp_path, + ) + # Generate Fake Tidal Data + ds_h, ds_u = dummy_tidal_data + + # Save to Fake Folder + ds_h.to_netcdf(tmp_path / "h_fake_tidal_data.nc") + ds_u.to_netcdf(tmp_path / "u_fake_tidal_data.nc") + + # Set other required variables needed in setup_tides + + # Lat Long + expt.longitude_extent = (-5, 5) + expt.latitude_extent = (0, 30) + # Grid Type + expt.hgrid_type = "even_spacing" + # Dates + expt.date_range = ("2000-01-01", "2000-01-02") + expt.segments = {} + # Generate Hgrid Data + expt.resolution = 0.1 + expt.hgrid = expt._make_hgrid() + # Create Forcing Folder + os.makedirs(tmp_path / "forcing", exist_ok=True) + + expt.setup_boundary_tides( + tmp_path / "h_fake_tidal_data.nc", + tmp_path / "u_fake_tidal_data.nc", + ) + + +def test_change_MOM_parameter(tmp_path): + """ + Test the change MOM parameter function, as well as read_MOM_file and write_MOM_file under the hood. + """ + expt_name = "testing" + + expt = rmom6.experiment.create_empty( + expt_name=expt_name, + mom_input_dir=tmp_path, + mom_run_dir=tmp_path, + ) + # Copy over the MOM Files to the dump_files_dir + base_run_dir = Path( + os.path.join( + importlib.resources.files("regional_mom6").parent, + "demos", + "premade_run_directories", + ) + ) + shutil.copytree(base_run_dir / "common_files", expt.mom_run_dir, dirs_exist_ok=True) + MOM_override_dict = expt.read_MOM_file_as_dict("MOM_override") + og = expt.change_MOM_parameter("DT", "30", "COOL COMMENT") + MOM_override_dict_new = expt.read_MOM_file_as_dict("MOM_override") + assert MOM_override_dict_new["DT"]["value"] == "30" + assert MOM_override_dict["DT"]["value"] == og + assert MOM_override_dict_new["DT"]["comment"] == "COOL COMMENT\n" From bab82f682f5c416fefec4a05edcffb2650ad6ec5 Mon Sep 17 00:00:00 2001 From: manishvenu Date: Fri, 20 Dec 2024 11:42:38 -0700 Subject: [PATCH 55/87] Docs changes --- demos/premade_run_directories/README.md | 2 +- docs/angle_calc.md | 2 +- docs/index.rst | 1 + docs/mom6-file-structure-primer.md | 6 +++++ docs/rm6_workflow.md | 32 +++++++++++++++++++++++++ regional_mom6/regional_mom6.py | 15 ++++++------ regional_mom6/regridding.py | 8 ++++--- 7 files changed, 53 insertions(+), 13 deletions(-) create mode 100644 docs/rm6_workflow.md diff --git a/demos/premade_run_directories/README.md b/demos/premade_run_directories/README.md index a3488a41..4a1da513 100644 --- a/demos/premade_run_directories/README.md +++ b/demos/premade_run_directories/README.md @@ -1,4 +1,4 @@ -## Premade Run Directories +# Premade Run Directories These directories are used for the demo notebooks, and can be used as templates for setting up a new experiment. The [documentation](https://regional-mom6.readthedocs.io/en/latest/mom6-file-structure-primer.html) explains what all the files are for. diff --git a/docs/angle_calc.md b/docs/angle_calc.md index 5d8a3e91..7a74e958 100644 --- a/docs/angle_calc.md +++ b/docs/angle_calc.md @@ -21,7 +21,7 @@ This document explains the implementation of MOM6 angle calculation in RM6, whic MOM6 only calculates the angle at t-points. For boundary rotation, we need the angle at the boundary, which is q/u/v points. Because we need the points to the left, right, top, and bottom of the point, this method won't work for the boundary. -# Convert this method to boundary angles - 3 Options +## Convert this method to boundary angles - 3 Options 1. **GIVEN_ANGLE**: Don't calculate the angle and use the user-provided field in the hgrid called "angle_dx" 2. **EXPAND_GRID**: Calculate another boundary row/column points around the hgrid using simple difference techniques. Use the new points to calculate the angle at the boundaries. This works because we can now access the four points needed to calculate the angle, where previously at boundaries we would be missing at least two. diff --git a/docs/index.rst b/docs/index.rst index d8f614ca..ce2095ea 100644 --- a/docs/index.rst +++ b/docs/index.rst @@ -91,6 +91,7 @@ The bibtex entry for the paper is: installation demos mom6-file-structure-primer + rm6_workflow angle_calc api contributing diff --git a/docs/mom6-file-structure-primer.md b/docs/mom6-file-structure-primer.md index 708fdebd..102c019f 100644 --- a/docs/mom6-file-structure-primer.md +++ b/docs/mom6-file-structure-primer.md @@ -106,3 +106,9 @@ These files can be big, so it is usually helpful to store them somewhere without confusing, and getting them wrong can likewise cause some cryptic error messages! These boundaries do not have to follow lines of constant longitude and latitude, but it is much easier to set things up if they do. For an example of a curved boundary, see this [Northwest Atlantic experiment](https://github.com/jsimkins2/nwa25/tree/main). + +* `forcing/{tz/tu}_segment**` + The boundary tidal segments, numbered the same way as in `MOM_input`. The dimensions and coordinates are fairly + confusing, and getting them wrong can likewise cause some cryptic error messages! These boundaries do not have to + follow lines of constant longitude and latitude, but it is much easier to set things up if they do. For an example + of a curved boundary, see this [Northwest Atlantic experiment](https://github.com/jsimkins2/nwa25/tree/main). diff --git a/docs/rm6_workflow.md b/docs/rm6_workflow.md new file mode 100644 index 00000000..a7bc9de8 --- /dev/null +++ b/docs/rm6_workflow.md @@ -0,0 +1,32 @@ +# Regional MOM6 Workflow + +Regional MOM6(RM6) sets up all the data and files for running a basic regional case of MOM6. + +It includes: + +1. Run Files like MOM_override, MOM_input, diag_table +2. BC File like velocity, tracers, tides +3. Basic input files like hgrid & bathymetry. +4. Initial Condition files + + +To set up a case with all the files, RM6 has its own way of grabbing and organizing files for the user. + +RM6 organizes all files into two directories, a "input" directory, and a "run" directory. The input directory includes all of the data we need for our regional case. The run directory includes all of the parameters and outputs (diags) we want for our model. Please see the structure primer document for more information. + +The other folders are the data directories. RM6 needs the user to collect the initial condition & boundary condition data and put them into a folder(s). + +Therefore, to start for the user to use RM6, they should have two (empty or not) directories for the input and run files, as well as directories for their input data. + +Depending on the computer used (NCAR-Derecho/Casper doesn't need this), the user may also need to provide a path to FRE_tools. + +To create all these files, RM6 using a class called "Experiment" to hold all of the parameters and functions. Users can follow a few quick steps to setup their cases: +1.Initalize the experiment object with all the directories and parameters wanted. The initalization can also create the hgrid and vertical coordinate or accept two files called "hgrid.nc" and "vcoord.nc" in the input directory. +2. Call different "setup..." functions to setup all the data needed for the case (bathymetry, initial condition, velocity, tracers, tides). +3. Finally, call "setup_run_directory" to setup the run files like MOM_override for their cases. +4. Based on how MOM6 is setup on the computer, there are follow-up steps unique to each situation. RM6 provides all of what the user needs to run MOM6. + + +There are a few convience functions to help support the process. +1. Very light read and write config file functions to easily save experiments +2. A change_MOM_parameter function to easily adjust MOM parameter values from python. \ No newline at end of file diff --git a/regional_mom6/regional_mom6.py b/regional_mom6/regional_mom6.py index 3708ddde..fd694bc9 100644 --- a/regional_mom6/regional_mom6.py +++ b/regional_mom6/regional_mom6.py @@ -14,7 +14,6 @@ import os import importlib.resources import datetime -from .utils import quadrilateral_areas, ap2ep, ep2ap, is_rectilinear_hgrid import pandas as pd from pathlib import Path import glob @@ -23,7 +22,7 @@ import copy from . import regridding as rgd from . import rotation as rot -from . import rotation as rot +from .utils import quadrilateral_areas, ap2ep, ep2ap, is_rectilinear_hgrid warnings.filterwarnings("ignore") @@ -1683,13 +1682,13 @@ def setup_boundary_tides( bathymetry_path (str): Path to the bathymetry file. Default is None, in which case the bathymetry file is assumed to be in the input directory. rotational_method (str): Method to use for rotating the tidal velocities. Default is 'GIVEN_ANGLE'. Returns: - *.nc files: Regridded tidal velocity and elevation files in 'inputdir/forcing' + .nc files: Regridded tidal velocity and elevation files in 'inputdir/forcing' General Description: This tidal data functions are sourced from the GFDL NWA25 and changed in the following ways: - - Converted code for RM6 segment class - - Implemented Horizontal Subsetting - - Combined all functions of NWA25 into a four function process (in the style of rm6) (expt.setup_tides_rectangular_boundaries, coords, segment.regrid_tides, segment.encode_tidal_files_and_output) + - Converted code for RM6 segment class + - Implemented Horizontal Subsetting + - Combined all functions of NWA25 into a four function process (in the style of rm6) (expt.setup_tides_rectangular_boundaries, coords, segment.regrid_tides, segment.encode_tidal_files_and_output) Original Code was sourced from: @@ -3267,7 +3266,7 @@ def regrid_tides( times (pd.DateRange): The start date of our model period rotational_method (rot.RotationMethod): The method to use for rotation of the velocities. Currently, the default method, GIVEN_ANGLE, works even with non-rotated grids Returns: - *.nc files: Regridded tidal velocity and elevation files in 'inputdir/forcing' + .nc files: Regridded tidal velocity and elevation files in 'inputdir/forcing' General Description: This tidal data functions are sourced from the GFDL NWA25 and changed in the following ways: @@ -3451,7 +3450,7 @@ def encode_tidal_files_and_output(self, ds, filename): dataset (xarray.Dataset): The processed tidal dataset filename (str): The output file name Returns: - *.nc files: Regridded [FILENAME] files in 'self.outfolder/[filename]_[segmentname].nc' + .nc files: Regridded [FILENAME] files in 'self.outfolder/[filename]_[segmentname].nc' General Description: This tidal data functions are sourced from the GFDL NWA25 and changed in the following ways: diff --git a/regional_mom6/regridding.py b/regional_mom6/regridding.py index 126df566..11b93d6e 100644 --- a/regional_mom6/regridding.py +++ b/regional_mom6/regridding.py @@ -4,10 +4,12 @@ Steps: 1. Initial Regridding -> Find the boundary of the hgrid, and regrid the forcing variables to that boundary. Call (initial_regridding) and then use the xesmf Regridder with whatever datasets you need. 2. Work on some data issues + 1. For temperature - Make sure it's in Celsius 2. FILL IN NANS -> this is important for MOM6 (fill_missing_data) -> This diverges between -3. For tides, we split the tides into an amplitude and a phase... -4. In some cases, here is a great place to rotate the velocities to match a curved grid.... (tidal_velocity), velocity is also a good place to do this. + +3. For tides, we split the tides into an amplitude and a phase +4. In some cases, here is a great place to rotate the velocities to match a curved grid (tidal_velocity), velocity is also a good place to do this. 5. We then add the time coordinate 6. For vars that are not just surface variables, we need to add several depth related variables 1. Add a dz variable in layer thickness @@ -371,7 +373,7 @@ def vertical_coordinate_encoding( ds: xr.Dataset, var: str, segment_name: str, old_vert_coord_name: str ) -> xr.Dataset: """ - Rename vertical coordinate to nz_..., then change it to regular increments + Rename vertical coordinate to nz[additional-text] then change it to regular increments Parameters ---------- From 4b1782f3fbd946713ca2885ac7bfc1f4a5241d5c Mon Sep 17 00:00:00 2001 From: manishvenu Date: Sat, 21 Dec 2024 08:35:33 -0700 Subject: [PATCH 56/87] Seg Fault Issue Pt1 --- tests/test_expt_class.py | 3 +++ 1 file changed, 3 insertions(+) diff --git a/tests/test_expt_class.py b/tests/test_expt_class.py index e5554f8e..502eb3ca 100644 --- a/tests/test_expt_class.py +++ b/tests/test_expt_class.py @@ -312,6 +312,9 @@ def test_ocean_forcing( # max(temp) can be less maximum_temperature_in_C due to re-gridding assert np.nanmax(expt.ic_tracers["temp"]) <= maximum_temperature_in_C + # Seg Fault Issue + expt.ic_tracers.close() + @pytest.mark.parametrize( ( From 51a16fa1fdd8c7cf7632451e4efb9e93508dc668 Mon Sep 17 00:00:00 2001 From: manishvenu Date: Sat, 21 Dec 2024 08:50:39 -0700 Subject: [PATCH 57/87] Disable threading --- tests/test_expt_class.py | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/tests/test_expt_class.py b/tests/test_expt_class.py index 502eb3ca..dfd39a62 100644 --- a/tests/test_expt_class.py +++ b/tests/test_expt_class.py @@ -2,6 +2,8 @@ import pytest from regional_mom6 import experiment import xarray as xr +import xesmf as xe +import dask ## Note: ## When creating test dataarrays we use 'silly' names for coordinates to @@ -223,6 +225,7 @@ def test_ocean_forcing( temp_dataarray_initial_condition, tmp_path, ): + dask.config.set(scheduler="single-threaded") silly_lat, silly_lon, silly_depth = generate_silly_coords( longitude_extent, latitude_extent, resolution, depth, number_vertical_layers @@ -312,7 +315,7 @@ def test_ocean_forcing( # max(temp) can be less maximum_temperature_in_C due to re-gridding assert np.nanmax(expt.ic_tracers["temp"]) <= maximum_temperature_in_C - # Seg Fault Issue + # Close experiment tracers explicitly expt.ic_tracers.close() From 12ad67e83d5047f574e9620e3eb14ff6ebd4dadd Mon Sep 17 00:00:00 2001 From: manishvenu Date: Sat, 21 Dec 2024 08:56:59 -0700 Subject: [PATCH 58/87] Just single threading --- tests/test_expt_class.py | 3 --- 1 file changed, 3 deletions(-) diff --git a/tests/test_expt_class.py b/tests/test_expt_class.py index dfd39a62..772fba88 100644 --- a/tests/test_expt_class.py +++ b/tests/test_expt_class.py @@ -315,9 +315,6 @@ def test_ocean_forcing( # max(temp) can be less maximum_temperature_in_C due to re-gridding assert np.nanmax(expt.ic_tracers["temp"]) <= maximum_temperature_in_C - # Close experiment tracers explicitly - expt.ic_tracers.close() - @pytest.mark.parametrize( ( From 9b7da85a151305e08cd9023214281084e7b2acea Mon Sep 17 00:00:00 2001 From: manishvenu Date: Sat, 21 Dec 2024 09:21:03 -0700 Subject: [PATCH 59/87] Clean up testing --- tests/conftest.py | 142 +++++++++++++++++++++++++++++++++++++++ tests/test_expt_class.py | 142 +++++---------------------------------- 2 files changed, 160 insertions(+), 124 deletions(-) diff --git a/tests/conftest.py b/tests/conftest.py index bf3f0555..ba8d1b47 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -110,6 +110,62 @@ def generate_silly_vt_dataset(): return eastern_boundary +@pytest.fixture() +def generate_silly_ic_dataset(): + def _generate_silly_ic_dataset( + longitude_extent, + latitude_extent, + resolution, + number_vertical_layers, + depth, + temp_dataarray_initial_condition, + ): + nx, ny = number_of_gridpoints(longitude_extent, latitude_extent, resolution) + silly_lat, silly_lon, silly_depth = generate_silly_coords( + longitude_extent, latitude_extent, resolution, depth, number_vertical_layers + ) + + dims = ["silly_lat", "silly_lon", "silly_depth"] + + coords = { + "silly_lat": silly_lat, + "silly_lon": silly_lon, + "silly_depth": silly_depth, + } + # initial condition includes, temp, salt, eta, u, v + initial_cond = xr.Dataset( + { + "eta": xr.DataArray( + np.random.random((ny, nx)), + dims=["silly_lat", "silly_lon"], + coords={ + "silly_lat": silly_lat, + "silly_lon": silly_lon, + }, + ), + "temp": temp_dataarray_initial_condition, + "salt": xr.DataArray( + np.random.random((ny, nx, number_vertical_layers)), + dims=dims, + coords=coords, + ), + "u": xr.DataArray( + np.random.random((ny, nx, number_vertical_layers)), + dims=dims, + coords=coords, + ), + "v": xr.DataArray( + np.random.random((ny, nx, number_vertical_layers)), + dims=dims, + coords=coords, + ), + } + ) + return initial_cond + + return _generate_silly_ic_dataset + + @pytest.fixture() def dummy_bathymetry_data(): latitude_extent = [16.0, 27] @@ -130,3 +186,89 @@ def dummy_bathymetry_data(): ) bathymetry.name = "silly_depth" return bathymetry + + +def temperature_dataarrays( + longitude_extent, latitude_extent, resolution, number_vertical_layers, depth +): + + silly_lat, silly_lon, silly_depth = generate_silly_coords( + longitude_extent, latitude_extent, resolution, depth, number_vertical_layers + ) + + dims = ["silly_lat", "silly_lon", "silly_depth"] + + coords = { + "silly_lat": silly_lat, + "silly_lon": silly_lon, + "silly_depth": silly_depth, + } + + toolpath_dir = "toolpath" + hgrid_type = "even_spacing" + + nx, ny = number_of_gridpoints(longitude_extent, latitude_extent, resolution) + + temp_in_C, temp_in_C_masked, temp_in_K, temp_in_K_masked = ( + generate_temperature_arrays(nx, ny, number_vertical_layers) + ) + + temp_C = xr.DataArray(temp_in_C, dims=dims, coords=coords) + temp_K = xr.DataArray(temp_in_K, dims=dims, coords=coords) + temp_C_masked = xr.DataArray(temp_in_C_masked, dims=dims, coords=coords) + temp_K_masked = xr.DataArray(temp_in_K_masked, dims=dims, coords=coords) + + maximum_temperature_in_C = np.max(temp_in_C) + return [temp_C, temp_C_masked, temp_K, temp_K_masked] + + +def number_of_gridpoints(longitude_extent, latitude_extent, resolution): + nx = int((longitude_extent[-1] - longitude_extent[0]) / resolution) + ny = int((latitude_extent[-1] - latitude_extent[0]) / resolution) + + return nx, ny + + +def generate_silly_coords( + longitude_extent, latitude_extent, resolution, depth, number_vertical_layers +): + nx, ny = number_of_gridpoints(longitude_extent, latitude_extent, resolution) + + horizontal_buffer = 5 + + silly_lat = np.linspace( + latitude_extent[0] - horizontal_buffer, + latitude_extent[1] + horizontal_buffer, + ny, + ) + silly_lon = np.linspace( + longitude_extent[0] - horizontal_buffer, + longitude_extent[1] + horizontal_buffer, + nx, + ) + silly_depth = np.linspace(0, depth, number_vertical_layers) + + return silly_lat, silly_lon, silly_depth + + +def generate_temperature_arrays(nx, ny, number_vertical_layers): + + # temperatures close to 0 áµ’C + temp_in_C = np.random.randn(ny, nx, number_vertical_layers) + + temp_in_C_masked = np.copy(temp_in_C) + if int(ny / 4 + 4) < ny - 1 and int(nx / 3 + 4) < nx + 1: + temp_in_C_masked[ + int(ny / 3) : int(ny / 3 + 5), int(nx) : int(nx / 4 + 4), : + ] = float("nan") + else: + raise ValueError("use bigger domain") + + temp_in_K = np.copy(temp_in_C) + 273.15 + temp_in_K_masked = np.copy(temp_in_C_masked) + 273.15 + + # ensure we didn't mask the minimum temperature + if np.nanmin(temp_in_C_masked) == np.min(temp_in_C): + return temp_in_C, temp_in_C_masked, temp_in_K, temp_in_K_masked + else: + return generate_temperature_arrays(nx, ny, number_vertical_layers) diff --git a/tests/test_expt_class.py b/tests/test_expt_class.py index 772fba88..b7b430f1 100644 --- a/tests/test_expt_class.py +++ b/tests/test_expt_class.py @@ -4,6 +4,12 @@ import xarray as xr import xesmf as xe import dask +from .conftest import ( + generate_temperature_arrays, + generate_silly_coords, + number_of_gridpoints, + temperature_dataarrays, +) ## Note: ## When creating test dataarrays we use 'silly' names for coordinates to @@ -96,58 +102,6 @@ def test_setup_bathymetry( bathymetry_file.unlink() -def number_of_gridpoints(longitude_extent, latitude_extent, resolution): - nx = int((longitude_extent[-1] - longitude_extent[0]) / resolution) - ny = int((latitude_extent[-1] - latitude_extent[0]) / resolution) - - return nx, ny - - -def generate_temperature_arrays(nx, ny, number_vertical_layers): - - # temperatures close to 0 áµ’C - temp_in_C = np.random.randn(ny, nx, number_vertical_layers) - - temp_in_C_masked = np.copy(temp_in_C) - if int(ny / 4 + 4) < ny - 1 and int(nx / 3 + 4) < nx + 1: - temp_in_C_masked[ - int(ny / 3) : int(ny / 3 + 5), int(nx) : int(nx / 4 + 4), : - ] = float("nan") - else: - raise ValueError("use bigger domain") - - temp_in_K = np.copy(temp_in_C) + 273.15 - temp_in_K_masked = np.copy(temp_in_C_masked) + 273.15 - - # ensure we didn't mask the minimum temperature - if np.nanmin(temp_in_C_masked) == np.min(temp_in_C): - return temp_in_C, temp_in_C_masked, temp_in_K, temp_in_K_masked - else: - return generate_temperature_arrays(nx, ny, number_vertical_layers) - - -def generate_silly_coords( - longitude_extent, latitude_extent, resolution, depth, number_vertical_layers -): - nx, ny = number_of_gridpoints(longitude_extent, latitude_extent, resolution) - - horizontal_buffer = 5 - - silly_lat = np.linspace( - latitude_extent[0] - horizontal_buffer, - latitude_extent[1] + horizontal_buffer, - ny, - ) - silly_lon = np.linspace( - longitude_extent[0] - horizontal_buffer, - longitude_extent[1] + horizontal_buffer, - nx, - ) - silly_depth = np.linspace(0, depth, number_vertical_layers) - - return silly_lat, silly_lon, silly_depth - - longitude_extent = [-5, 3] latitude_extent = (0, 10) date_range = ["2003-01-01 00:00:00", "2003-01-01 00:00:00"] @@ -156,35 +110,12 @@ def generate_silly_coords( layer_thickness_ratio = 1 depth = 1000 -silly_lat, silly_lon, silly_depth = generate_silly_coords( - longitude_extent, latitude_extent, resolution, depth, number_vertical_layers -) - -dims = ["silly_lat", "silly_lon", "silly_depth"] - -coords = {"silly_lat": silly_lat, "silly_lon": silly_lon, "silly_depth": silly_depth} - - -toolpath_dir = "toolpath" -hgrid_type = "even_spacing" - -nx, ny = number_of_gridpoints(longitude_extent, latitude_extent, resolution) - -temp_in_C, temp_in_C_masked, temp_in_K, temp_in_K_masked = generate_temperature_arrays( - nx, ny, number_vertical_layers -) - -temp_C = xr.DataArray(temp_in_C, dims=dims, coords=coords) -temp_K = xr.DataArray(temp_in_K, dims=dims, coords=coords) -temp_C_masked = xr.DataArray(temp_in_C_masked, dims=dims, coords=coords) -temp_K_masked = xr.DataArray(temp_in_K_masked, dims=dims, coords=coords) - -maximum_temperature_in_C = np.max(temp_in_C) - @pytest.mark.parametrize( "temp_dataarray_initial_condition", - [temp_C, temp_C_masked, temp_K, temp_K_masked], + temperature_dataarrays( + longitude_extent, latitude_extent, resolution, number_vertical_layers, depth + ), ) @pytest.mark.parametrize( ( @@ -224,20 +155,9 @@ def test_ocean_forcing( hgrid_type, temp_dataarray_initial_condition, tmp_path, + generate_silly_ic_dataset, ): dask.config.set(scheduler="single-threaded") - - silly_lat, silly_lon, silly_depth = generate_silly_coords( - longitude_extent, latitude_extent, resolution, depth, number_vertical_layers - ) - - dims = ["silly_lat", "silly_lon", "silly_depth"] - - coords = { - "silly_lat": silly_lat, - "silly_lon": silly_lon, - "silly_depth": silly_depth, - } mom_run_dir = tmp_path / "rundir" mom_input_dir = tmp_path / "inputdir" expt = experiment( @@ -254,42 +174,16 @@ def test_ocean_forcing( hgrid_type=hgrid_type, ) - ## Generate some initial condition to test on - - nx, ny = number_of_gridpoints(longitude_extent, latitude_extent, resolution) - # initial condition includes, temp, salt, eta, u, v - initial_cond = xr.Dataset( - { - "eta": xr.DataArray( - np.random.random((ny, nx)), - dims=["silly_lat", "silly_lon"], - coords={ - "silly_lat": silly_lat, - "silly_lon": silly_lon, - }, - ), - "temp": temp_dataarray_initial_condition, - "salt": xr.DataArray( - np.random.random((ny, nx, number_vertical_layers)), - dims=dims, - coords=coords, - ), - "u": xr.DataArray( - np.random.random((ny, nx, number_vertical_layers)), - dims=dims, - coords=coords, - ), - "v": xr.DataArray( - np.random.random((ny, nx, number_vertical_layers)), - dims=dims, - coords=coords, - ), - } + initial_cond = generate_silly_ic_dataset( + longitude_extent, + latitude_extent, + resolution, + number_vertical_layers, + depth, + temp_dataarray_initial_condition, ) - # Generate boundary forcing - initial_cond.to_netcdf(tmp_path / "ic_unprocessed") initial_cond.close() varnames = { @@ -311,7 +205,7 @@ def test_ocean_forcing( # ensure that temperature is in degrees C assert np.nanmin(expt.ic_tracers["temp"]) < 100.0 - + maximum_temperature_in_C = np.max(temp_dataarray_initial_condition) # max(temp) can be less maximum_temperature_in_C due to re-gridding assert np.nanmax(expt.ic_tracers["temp"]) <= maximum_temperature_in_C From 0730fcfb8c16b7c44130f5749f70f970c40865e5 Mon Sep 17 00:00:00 2001 From: manishvenu Date: Sat, 21 Dec 2024 09:36:32 -0700 Subject: [PATCH 60/87] Remove Single Threading --- tests/conftest.py | 2 +- tests/test_expt_class.py | 5 ++--- 2 files changed, 3 insertions(+), 4 deletions(-) diff --git a/tests/conftest.py b/tests/conftest.py index ba8d1b47..e9eaece9 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -188,7 +188,7 @@ def dummy_bathymetry_data(): return bathymetry -def temperature_dataarrays( +def get_temperature_dataarrays( longitude_extent, latitude_extent, resolution, number_vertical_layers, depth ): diff --git a/tests/test_expt_class.py b/tests/test_expt_class.py index b7b430f1..65ca9735 100644 --- a/tests/test_expt_class.py +++ b/tests/test_expt_class.py @@ -8,7 +8,7 @@ generate_temperature_arrays, generate_silly_coords, number_of_gridpoints, - temperature_dataarrays, + get_temperature_dataarrays, ) ## Note: @@ -113,7 +113,7 @@ def test_setup_bathymetry( @pytest.mark.parametrize( "temp_dataarray_initial_condition", - temperature_dataarrays( + get_temperature_dataarrays( longitude_extent, latitude_extent, resolution, number_vertical_layers, depth ), ) @@ -157,7 +157,6 @@ def test_ocean_forcing( tmp_path, generate_silly_ic_dataset, ): - dask.config.set(scheduler="single-threaded") mom_run_dir = tmp_path / "rundir" mom_input_dir = tmp_path / "inputdir" expt = experiment( From cfe53e58380ef6c2ad126c88e038070baf635e15 Mon Sep 17 00:00:00 2001 From: manishvenu Date: Sat, 21 Dec 2024 13:35:15 -0700 Subject: [PATCH 61/87] Add back single threading --- tests/test_expt_class.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/tests/test_expt_class.py b/tests/test_expt_class.py index 65ca9735..eb288ef5 100644 --- a/tests/test_expt_class.py +++ b/tests/test_expt_class.py @@ -157,6 +157,7 @@ def test_ocean_forcing( tmp_path, generate_silly_ic_dataset, ): + dask.config.set(scheduler="single-threaded") mom_run_dir = tmp_path / "rundir" mom_input_dir = tmp_path / "inputdir" expt = experiment( @@ -207,6 +208,7 @@ def test_ocean_forcing( maximum_temperature_in_C = np.max(temp_dataarray_initial_condition) # max(temp) can be less maximum_temperature_in_C due to re-gridding assert np.nanmax(expt.ic_tracers["temp"]) <= maximum_temperature_in_C + dask.config.set(scheduler=None) @pytest.mark.parametrize( From 9169dbd81a9f8f78f42d031a1f5eea2709e7284a Mon Sep 17 00:00:00 2001 From: manishvenu Date: Mon, 23 Dec 2024 15:03:28 -0700 Subject: [PATCH 62/87] Spelling Mistake --- docs/rm6_workflow.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/rm6_workflow.md b/docs/rm6_workflow.md index a7bc9de8..647a12d2 100644 --- a/docs/rm6_workflow.md +++ b/docs/rm6_workflow.md @@ -21,7 +21,7 @@ Therefore, to start for the user to use RM6, they should have two (empty or not) Depending on the computer used (NCAR-Derecho/Casper doesn't need this), the user may also need to provide a path to FRE_tools. To create all these files, RM6 using a class called "Experiment" to hold all of the parameters and functions. Users can follow a few quick steps to setup their cases: -1.Initalize the experiment object with all the directories and parameters wanted. The initalization can also create the hgrid and vertical coordinate or accept two files called "hgrid.nc" and "vcoord.nc" in the input directory. +1. Initalize the experiment object with all the directories and parameters wanted. The initalization can also create the hgrid and vertical coordinate or accept two files called "hgrid.nc" and "vcoord.nc" in the input directory. 2. Call different "setup..." functions to setup all the data needed for the case (bathymetry, initial condition, velocity, tracers, tides). 3. Finally, call "setup_run_directory" to setup the run files like MOM_override for their cases. 4. Based on how MOM6 is setup on the computer, there are follow-up steps unique to each situation. RM6 provides all of what the user needs to run MOM6. From ca8fff5b3f3eb0659964c80e02a23d7d92283ad1 Mon Sep 17 00:00:00 2001 From: manishvenu Date: Thu, 26 Dec 2024 10:26:01 -0700 Subject: [PATCH 63/87] Zero Out Attempt --- regional_mom6/regional_mom6.py | 2 +- regional_mom6/regridding.py | 19 ++++++++++++------- 2 files changed, 13 insertions(+), 8 deletions(-) diff --git a/regional_mom6/regional_mom6.py b/regional_mom6/regional_mom6.py index fd694bc9..8fbc5901 100644 --- a/regional_mom6/regional_mom6.py +++ b/regional_mom6/regional_mom6.py @@ -2866,13 +2866,13 @@ def __init__( self, *, hgrid, - bathymetry_path, infile, outfolder, varnames, segment_name, orientation, startdate, + bathymetry_path = None, arakawa_grid="A", time_units="days", repeat_year_forcing=False, diff --git a/regional_mom6/regridding.py b/regional_mom6/regridding.py index 11b93d6e..81dffc88 100644 --- a/regional_mom6/regridding.py +++ b/regional_mom6/regridding.py @@ -505,8 +505,9 @@ def get_boundary_mask( # Get the Boundary Depth bathy_2_coords["boundary_depth"] = bathy_2_coords["angle"] - land = 0 + land = 0.5 ocean = 1.0 + zero_out = 0.0 boundary_mask = np.full(np.shape(coords(hgrid, side, segment_name).angle), ocean) ## Mask2DCu is the mask for the u/v points on the hgrid and is set to OBCmaskCy as well... @@ -519,6 +520,7 @@ def get_boundary_mask( ) boundary_mask[(i * 2)] = land + # Looks like in the boundary between land and ocean - in NWA for example - we basically need to remove 3 points closest to ocean as a buffer. # Search for intersections beaches_before = [] @@ -531,16 +533,19 @@ def get_boundary_mask( for beach in beaches_before: for i in range(3): if beach - 1 - i >= 0: - boundary_mask[beach - 1 - i] = ocean + boundary_mask[beach - 1 - i] = zero_out for beach in beaches_after: for i in range(3): if beach + 1 + i < len(boundary_mask): - boundary_mask[beach + 1 + i] = ocean + boundary_mask[beach + 1 + i] = zero_out + boundary_mask[np.where(boundary_mask == land)] = np.nan - # Corner Q-points defined as wet - boundary_mask[0] = ocean - boundary_mask[-1] = ocean + # Corner Q-points defined as land should be zeroed out + if np.isnan(boundary_mask[0]): + boundary_mask[0] = zero_out + if np.isnan(boundary_mask[-1] == land): + boundary_mask[-1] = zero_out return boundary_mask @@ -612,7 +617,7 @@ def mask_dataset( ## Remove Nans if needed ## ds[var] = ds[var].fillna(0) - ## Apply the mask ## + ## Apply the mask ## # Multiplication allows us to use 1, 0, and nan in the mask ds[var] = ds[var] * mask else: regridding_logger.warning( From 0b672a8e74b1c1b328116b13c769cace838aa4f2 Mon Sep 17 00:00:00 2001 From: manishvenu Date: Thu, 26 Dec 2024 11:36:17 -0700 Subject: [PATCH 64/87] Black + Add Mask to Regrid_vt --- regional_mom6/regional_mom6.py | 9 ++++++++- regional_mom6/regridding.py | 1 - 2 files changed, 8 insertions(+), 2 deletions(-) diff --git a/regional_mom6/regional_mom6.py b/regional_mom6/regional_mom6.py index 8fbc5901..94bf3fa3 100644 --- a/regional_mom6/regional_mom6.py +++ b/regional_mom6/regional_mom6.py @@ -2872,7 +2872,7 @@ def __init__( segment_name, orientation, startdate, - bathymetry_path = None, + bathymetry_path=None, arakawa_grid="A", time_units="days", repeat_year_forcing=False, @@ -3230,6 +3230,13 @@ def regrid_velocity_tracers(self, rotational_method=rot.RotationMethod.GIVEN_ANG "dtype": "int32", }, } + segment_out = rgd.mask_dataset( + segment_out, + self.hgrid, + self.bathymetry, + self.orientation, + self.segment_name, + ) encoding_dict = rgd.generate_encoding( segment_out, encoding_dict, diff --git a/regional_mom6/regridding.py b/regional_mom6/regridding.py index 81dffc88..b55176b6 100644 --- a/regional_mom6/regridding.py +++ b/regional_mom6/regridding.py @@ -520,7 +520,6 @@ def get_boundary_mask( ) boundary_mask[(i * 2)] = land - # Looks like in the boundary between land and ocean - in NWA for example - we basically need to remove 3 points closest to ocean as a buffer. # Search for intersections beaches_before = [] From 3ae3071e80637d9c4124dee7648a06dd86cba9bc Mon Sep 17 00:00:00 2001 From: manishvenu Date: Thu, 26 Dec 2024 15:01:51 -0700 Subject: [PATCH 65/87] Zero Out Corner + 3 Cell --- regional_mom6/regridding.py | 14 +++++++++++++- 1 file changed, 13 insertions(+), 1 deletion(-) diff --git a/regional_mom6/regridding.py b/regional_mom6/regridding.py index b55176b6..3a74f5bc 100644 --- a/regional_mom6/regridding.py +++ b/regional_mom6/regridding.py @@ -543,7 +543,7 @@ def get_boundary_mask( # Corner Q-points defined as land should be zeroed out if np.isnan(boundary_mask[0]): boundary_mask[0] = zero_out - if np.isnan(boundary_mask[-1] == land): + if np.isnan(boundary_mask[-1]): boundary_mask[-1] = zero_out return boundary_mask @@ -615,6 +615,18 @@ def mask_dataset( ## Remove Nans if needed ## ds[var] = ds[var].fillna(0) + elif np.isnan(dataset_reduce_dim[0]): # The corner is nan in the data + ds[var] = ds[var].copy() + ds[var][..., 0, 0] = 0 + elif np.isnan(dataset_reduce_dim[-1]): # The corner is nan in the data + ds[var] = ds[var].copy() + if orientation in ["east", "west"]: + ds[var][..., -1, 0] = 0 + else: + ds[var][..., 0, -1] = 0 + + ## Remove Nans if needed ## + ds[var] = ds[var].fillna(0) ## Apply the mask ## # Multiplication allows us to use 1, 0, and nan in the mask ds[var] = ds[var] * mask From 9cbd5cf1217a7820bae76dbdab0e2a28b2ec8451 Mon Sep 17 00:00:00 2001 From: manishvenu Date: Thu, 26 Dec 2024 19:42:24 -0700 Subject: [PATCH 66/87] Update Land Mask Tests --- tests/test_regridding.py | 26 +++++++++++++++++++++----- 1 file changed, 21 insertions(+), 5 deletions(-) diff --git a/tests/test_regridding.py b/tests/test_regridding.py index 4ce94295..dfd262bc 100644 --- a/tests/test_regridding.py +++ b/tests/test_regridding.py @@ -171,7 +171,9 @@ def test_get_boundary_mask(get_curvilinear_hgrid): # Check corner property of mask, and ensure each direction is following what we expect for mask in [north_mask, south_mask, east_mask, west_mask]: - assert mask[0] == 1 and mask[-1] == 1 # Ensure Corners are oceans + assert ( + mask[0] == 0 and mask[-1] == 0 + ) # Ensure Corners are oceans and set to zero for zeroing out values assert np.isnan(mask[1:-1]).all() # Ensure all other points are land assert north_mask.shape == (hgrid.x[-1].shape) # Ensure mask is the right shape assert south_mask.shape == (hgrid.x[0].shape) # Ensure mask is the right shape @@ -191,10 +193,18 @@ def test_get_boundary_mask(get_curvilinear_hgrid): y_dim_name="t_points_y", x_dim_name="t_points_x", ) - assert north_mask[0] == 1 and north_mask[-1] == 1 # Ensure Corners are oceans assert ( - north_mask[(((start_ind * 2) + 1) - 3) : (((end_ind * 2) + 1) + 3 + 1)] == 1 + north_mask[0] == 0 and north_mask[-1] == 0 + ) # Ensure Corners are oceans and zeroed out if land + assert ( + north_mask[(((start_ind * 2) + 1)) : (((end_ind * 2) + 1) + 1)] == 1 ).all() # Ensure coasts are ocean with a 3 cell buffer (remeber mask is on the hgrid boundary) so (6 *2 +2) - 3 -> (9 *2 +2) + 3 + assert ( + north_mask[(((start_ind * 2) + 1) - 3) : (((start_ind * 2) + 1))] == 0 + ).all() # Left Side + assert ( + north_mask[(((end_ind * 2) + 1) + 1) : (((end_ind * 2) + 1) + 3 + 1)] == 0 + ).all() # Right Side ## On E/W start_ind = 6 @@ -209,10 +219,16 @@ def test_get_boundary_mask(get_curvilinear_hgrid): y_dim_name="t_points_y", x_dim_name="t_points_x", ) - assert west_mask[0] == 1 and west_mask[-1] == 1 # Ensure Corners are oceans + assert west_mask[0] == 0 and west_mask[-1] == 0 # Ensure Corners are oceans assert ( - west_mask[(((start_ind * 2) + 1) - 3) : (((end_ind * 2) + 1) + 3 + 1)] == 1 + west_mask[(((start_ind * 2) + 1)) : (((end_ind * 2) + 1) + 1)] == 1 ).all() # Ensure coasts are ocean with a 3 cell buffer (remeber mask is on the hgrid boundary) so (6 *2 +2) - 3 -> (9 *2 +2) + 3 + assert ( + west_mask[(((start_ind * 2) + 1) - 3) : (((start_ind * 2) + 1))] == 0 + ).all() # Ensure left side is zeroed out + assert ( + west_mask[(((end_ind * 2) + 1) + 1) : (((end_ind * 2) + 1) + 3 + 1)] == 0 + ).all() # Right Side is zeroed out def test_mask_dataset(get_curvilinear_hgrid): From 5c0ae857a442917a7ab0e6747ef4712393178e8b Mon Sep 17 00:00:00 2001 From: manishvenu Date: Thu, 26 Dec 2024 20:25:47 -0700 Subject: [PATCH 67/87] Fix Bathy NTiles Issue --- regional_mom6/regridding.py | 11 +++++++++++ 1 file changed, 11 insertions(+) diff --git a/regional_mom6/regridding.py b/regional_mom6/regridding.py index 3a74f5bc..0cbb015a 100644 --- a/regional_mom6/regridding.py +++ b/regional_mom6/regridding.py @@ -493,6 +493,17 @@ def get_boundary_mask( # Fill at t_points (what bathy is determined at) ds_t = get_hgrid_arakawa_c_points(hgrid, "t") + + # Identify any extra dimension like ntiles + extra_dim = None + for dim in bathy.dims: + if dim not in ["nyp", "nxp"]: + extra_dim = dim + break + # Select the first index along the extra dimension if it exists + if extra_dim: + bathy = bathy.isel({extra_dim: 0}) + bathy_2["depth"][ds_t.t_points_y.values, ds_t.t_points_x.values] = bathy.depth bathy_2_coords = coords( From 92cf66c5a643f9f2e42ba361bc7cf689849b481c Mon Sep 17 00:00:00 2001 From: manishvenu Date: Fri, 27 Dec 2024 09:23:19 -0700 Subject: [PATCH 68/87] Minor Cleaning + Variable Renaming --- regional_mom6/regridding.py | 66 ++++++++++++++++++------------- tests/test_tides_and_parameter.py | 54 ------------------------- 2 files changed, 39 insertions(+), 81 deletions(-) diff --git a/regional_mom6/regridding.py b/regional_mom6/regridding.py index 0cbb015a..3a0a0825 100644 --- a/regional_mom6/regridding.py +++ b/regional_mom6/regridding.py @@ -470,11 +470,13 @@ def get_boundary_mask( The minimum depth to consider land, by default 0 Returns ------- - np.Array + np.ndarray The boundary mask """ # Hide the bathy as an hgrid so we can take advantage of the coords function to get the boundary points. + + # First rename bathy dims to nyp and nxp try: bathy = bathy.rename({y_dim_name: "nyp", x_dim_name: "nxp"}) except: @@ -485,11 +487,11 @@ def get_boundary_mask( raise ValueError("Please provide the bathymetry x and y dimension names") # Copy Hgrid - bathy_2 = hgrid.copy(deep=True) + bathy_as_hgrid = hgrid.copy(deep=True) # Create new depth field - bathy_2["depth"] = bathy_2["angle_dx"] - bathy_2["depth"][:, :] = np.nan + bathy_as_hgrid["depth"] = bathy_as_hgrid["angle_dx"] + bathy_as_hgrid["depth"][:, :] = np.nan # Fill at t_points (what bathy is determined at) ds_t = get_hgrid_arakawa_c_points(hgrid, "t") @@ -504,26 +506,32 @@ def get_boundary_mask( if extra_dim: bathy = bathy.isel({extra_dim: 0}) - bathy_2["depth"][ds_t.t_points_y.values, ds_t.t_points_x.values] = bathy.depth + bathy_as_hgrid["depth"][ + ds_t.t_points_y.values, ds_t.t_points_x.values + ] = bathy.depth - bathy_2_coords = coords( - bathy_2, + bathy_as_hgrid_coords = coords( + bathy_as_hgrid, side, segment_name, angle_variable_name="depth", coords_at_t_points=True, ) - # Get the Boundary Depth - bathy_2_coords["boundary_depth"] = bathy_2_coords["angle"] + # Get the Boundary Depth -> we're done with the hgrid now + bathy_as_hgrid_coords["boundary_depth"] = bathy_as_hgrid_coords["angle"] + + # Mask Fill Values land = 0.5 ocean = 1.0 zero_out = 0.0 + + # Create Mask boundary_mask = np.full(np.shape(coords(hgrid, side, segment_name).angle), ocean) - ## Mask2DCu is the mask for the u/v points on the hgrid and is set to OBCmaskCy as well... - for i in range(len(bathy_2_coords["boundary_depth"])): - if bathy_2_coords["boundary_depth"][i] <= minimum_depth: + # Fill with MOM6 version of mask + for i in range(len(bathy_as_hgrid_coords["boundary_depth"])): + if bathy_as_hgrid_coords["boundary_depth"][i] <= minimum_depth: # The points to the left and right of this t-point are land points boundary_mask[(i * 2) + 2] = land boundary_mask[(i * 2) + 1] = ( @@ -531,32 +539,36 @@ def get_boundary_mask( ) boundary_mask[(i * 2)] = land + # Land points that can't be NaNs: Corners & 3 points at the coast + # Looks like in the boundary between land and ocean - in NWA for example - we basically need to remove 3 points closest to ocean as a buffer. # Search for intersections - beaches_before = [] - beaches_after = [] + coasts_lower_index = [] + coasts_higher_index = [] for index in range(1, len(boundary_mask) - 1): if boundary_mask[index - 1] == land and boundary_mask[index] == ocean: - beaches_before.append(index) + coasts_lower_index.append(index) elif boundary_mask[index + 1] == land and boundary_mask[index] == ocean: - beaches_after.append(index) - for beach in beaches_before: - for i in range(3): - if beach - 1 - i >= 0: - boundary_mask[beach - 1 - i] = zero_out - for beach in beaches_after: - for i in range(3): - if beach + 1 + i < len(boundary_mask): - boundary_mask[beach + 1 + i] = zero_out + coasts_higher_index.append(index) - boundary_mask[np.where(boundary_mask == land)] = np.nan + # Remove 3 land points from the coast, and make them zeroed out real values + for i in range(3): + for coast in coasts_lower_index: + if coast - 1 - i >= 0: + boundary_mask[coast - 1 - i] = zero_out + for coast in coasts_higher_index: + if coast + 1 + i < len(boundary_mask): + boundary_mask[coast + 1 + i] = zero_out # Corner Q-points defined as land should be zeroed out - if np.isnan(boundary_mask[0]): + if boundary_mask[0] == land: boundary_mask[0] = zero_out - if np.isnan(boundary_mask[-1]): + if boundary_mask[-1] == land: boundary_mask[-1] = zero_out + # Convert land points to nans + boundary_mask[np.where(boundary_mask == land)] = np.nan + return boundary_mask diff --git a/tests/test_tides_and_parameter.py b/tests/test_tides_and_parameter.py index abf798f0..1eca029c 100644 --- a/tests/test_tides_and_parameter.py +++ b/tests/test_tides_and_parameter.py @@ -134,60 +134,6 @@ def dummy_tidal_data(): return ds_h, ds_u -@pytest.fixture() -def full_expt_setup(dummy_bathymetry_data, tmp_path): - - expt_name = "testing" - - latitude_extent = [16.0, 27] - longitude_extent = [192, 209] - - date_range = ["2005-01-01 00:00:00", "2005-02-01 00:00:00"] - - ## Place where all your input files go - input_dir = Path( - os.path.join( - tmp_path, - expt_name, - "inputs", - ) - ) - - ## Directory where you'll run the experiment from - run_dir = Path( - os.path.join( - tmp_path, - expt_name, - "run_files", - ) - ) - data_path = Path(tmp_path, "data") - for path in (run_dir, input_dir, data_path): - os.makedirs(str(path), exist_ok=True) - bathy_path = data_path / "bathymetry.nc" - bathymetry = dummy_bathymetry_data - bathymetry.to_netcdf(bathy_path) - ## User-1st, test if we can even read the angled nc files. - expt = rmom6.experiment( - longitude_extent=longitude_extent, - latitude_extent=latitude_extent, - date_range=date_range, - resolution=0.05, - number_vertical_layers=75, - layer_thickness_ratio=10, - depth=4500, - minimum_depth=5, - mom_run_dir=run_dir, - mom_input_dir=input_dir, - toolpath_dir="", - ) - return expt - - -def test_full_expt_setup(full_expt_setup): - assert str(full_expt_setup) - - def test_tides(dummy_tidal_data, tmp_path): """ Test the main setup tides function! From 7861c18d685a256479d0088daa29eef592abfe30 Mon Sep 17 00:00:00 2001 From: alperaltuntas Date: Sun, 29 Dec 2024 09:42:51 -0700 Subject: [PATCH 69/87] minor changes ahead of visualCaseGen integration in CrocoDash: - correct the first arg of a classmethod (from self to cls). - introduce optional write_to_file arg in setup_bathymetry. - introduce optional bathymetry obj arg in tidy_bathymetry. --- regional_mom6/regional_mom6.py | 61 ++++++++++++++++++++-------------- 1 file changed, 36 insertions(+), 25 deletions(-) diff --git a/regional_mom6/regional_mom6.py b/regional_mom6/regional_mom6.py index cc843959..7ac5b846 100644 --- a/regional_mom6/regional_mom6.py +++ b/regional_mom6/regional_mom6.py @@ -575,7 +575,7 @@ class experiment: @classmethod def create_empty( - self, + cls, longitude_extent=None, latitude_extent=None, date_range=None, @@ -596,7 +596,7 @@ def create_empty( """ Substitute init method to creates an empty expirement object, with the opportunity to override whatever values wanted. """ - expt = self( + expt = cls( longitude_extent=None, latitude_extent=None, date_range=None, @@ -632,8 +632,8 @@ def create_empty( expt.longitude_extent = longitude_extent expt.ocean_mask = None expt.layout = None - self.segments = {} - self.boundaries = boundaries + cls.segments = {} + cls.boundaries = boundaries return expt def __init__( @@ -1760,6 +1760,7 @@ def setup_bathymetry( vertical_coordinate_name="elevation", # This is to match GEBCO fill_channels=False, positive_down=False, + write_to_file=True, ): """ Cut out and interpolate the chosen bathymetry and then fill inland lakes. @@ -1783,6 +1784,7 @@ def setup_bathymetry( but can also connect extra islands to land. Default: ``False``. positive_down (Optional[bool]): If ``True``, it assumes that bathymetry vertical coordinate is positive down. Default: ``False``. + write_to_file (Optional[bool]): Whether to write the bathymetry to a file. Default: ``True``. """ ## Convert the provided coordinate names into a dictionary mapping to the @@ -1856,9 +1858,10 @@ def setup_bathymetry( ) bathymetry_output.depth.attrs["long_name"] = "Elevation relative to sea level" bathymetry_output.depth.attrs["coordinates"] = "lon lat" - bathymetry_output.to_netcdf( - self.mom_input_dir / "bathymetry_original.nc", mode="w", engine="netcdf4" - ) + if write_to_file: + bathymetry_output.to_netcdf( + self.mom_input_dir / "bathymetry_original.nc", mode="w", engine="netcdf4" + ) tgrid = xr.Dataset( data_vars={ @@ -1894,10 +1897,11 @@ def setup_bathymetry( tgrid.lat.attrs["_FillValue"] = 1e20 tgrid.depth.attrs["units"] = "meters" tgrid.depth.attrs["coordinates"] = "lon lat" - tgrid.to_netcdf( - self.mom_input_dir / "bathymetry_unfinished.nc", mode="w", engine="netcdf4" - ) - tgrid.close() + if write_to_file: + tgrid.to_netcdf( + self.mom_input_dir / "bathymetry_unfinished.nc", mode="w", engine="netcdf4" + ) + tgrid.close() bathymetry_output = bathymetry_output.load() @@ -1914,19 +1918,21 @@ def setup_bathymetry( ) regridder = xe.Regridder(bathymetry_output, tgrid, "bilinear", parallel=False) bathymetry = regridder(bathymetry_output) - bathymetry.to_netcdf( - self.mom_input_dir / "bathymetry_unfinished.nc", mode="w", engine="netcdf4" - ) + if write_to_file: + bathymetry.to_netcdf( + self.mom_input_dir / "bathymetry_unfinished.nc", mode="w", engine="netcdf4" + ) print( "Regridding successful! Now calling `tidy_bathymetry` method for some finishing touches..." ) - self.tidy_bathymetry(fill_channels, positive_down) + self.tidy_bathymetry(fill_channels, positive_down, bathymetry=bathymetry) print("setup bathymetry has finished successfully.") - return + + return bathymetry def tidy_bathymetry( - self, fill_channels=False, positive_down=False, vertical_coordinate_name="depth" + self, fill_channels=False, positive_down=False, vertical_coordinate_name="depth", bathymetry=None ): """ An auxiliary function for bathymetry used to fix up the metadata and remove inland @@ -1944,6 +1950,9 @@ def tidy_bathymetry( but can also connect extra islands to land. Default: ``False``. positive_down (Optional[bool]): If ``False`` (default), assume that bathymetry vertical coordinate is positive down, as is the case in GEBCO for example. + bathymetry (Optional[xr.Dataset]): The bathymetry dataset to tidy up. If not provided, + it will read the bathymetry from the file ``bathymetry_unfinished.nc`` in the input directory + that was created by :func:`~setup_bathymetry`. """ ## reopen bathymetry to modify @@ -1951,9 +1960,10 @@ def tidy_bathymetry( "Tidy bathymetry: Reading in regridded bathymetry to fix up metadata...", end="", ) - bathymetry = xr.open_dataset( - self.mom_input_dir / "bathymetry_unfinished.nc", engine="netcdf4" - ) + if read_bathy_from_file := bathymetry is None: + bathymetry = xr.open_dataset( + self.mom_input_dir / "bathymetry_unfinished.nc", engine="netcdf4" + ) ## Ensure correct encoding bathymetry = xr.Dataset( @@ -2115,11 +2125,12 @@ def tidy_bathymetry( ~(bathymetry.depth <= self.minimum_depth), self.minimum_depth + 0.1 ) - bathymetry.expand_dims({"ntiles": 1}).to_netcdf( - self.mom_input_dir / "bathymetry.nc", - mode="w", - encoding={"depth": {"_FillValue": None}}, - ) + if read_bathy_from_file: + bathymetry.expand_dims({"ntiles": 1}).to_netcdf( + self.mom_input_dir / "bathymetry.nc", + mode="w", + encoding={"depth": {"_FillValue": None}}, + ) print("done.") return From f3973c50b5af5371e5d5e913f080c327a7c03eb4 Mon Sep 17 00:00:00 2001 From: manishvenu Date: Mon, 30 Dec 2024 09:30:32 -0700 Subject: [PATCH 70/87] Mirro GFDL NWA12-Cobalt a bit more and add diag table date adjustment --- regional_mom6/regional_mom6.py | 85 ++++++++++++++++++---------------- regional_mom6/regridding.py | 71 ++++++++++++++++------------ 2 files changed, 88 insertions(+), 68 deletions(-) diff --git a/regional_mom6/regional_mom6.py b/regional_mom6/regional_mom6.py index 94bf3fa3..fa78a830 100644 --- a/regional_mom6/regional_mom6.py +++ b/regional_mom6/regional_mom6.py @@ -1559,7 +1559,7 @@ def setup_ocean_state_boundaries( arakawa_grid (Optional[str]): Arakawa grid staggering type of the boundary forcing. Either ``'A'`` (default), ``'B'``, or ``'C'``. boundary_type (Optional[str]): Type of box around region. Currently, only ``'rectangular'`` is supported. - bathymetry_path (Optional[str]): Path to the bathymetry file. Default is None, in which case the bathymetry file is assumed to be in the input directory. + bathymetry_path (Optional[str]): Path to the bathymetry file. Default is None, in which case the BC is not masked. rotational_method (Optional[str]): Method to use for rotating the boundary velocities. Default is 'GIVEN_ANGLE'. """ if boundary_type != "rectangular": @@ -1581,8 +1581,6 @@ def setup_ocean_state_boundaries( raise ValueError( "This method only supports up to four boundaries. To set up more complex boundary shapes you can manually call the 'simple_boundary' method for each boundary." ) - if bathymetry_path is None: - bathymetry_path = self.mom_input_dir / "bathymetry.nc" # Now iterate through our four boundaries for orientation in self.boundaries: @@ -1631,7 +1629,7 @@ def setup_single_boundary( arakawa_grid (Optional[str]): Arakawa grid staggering type of the boundary forcing. Either ``'A'`` (default), ``'B'``, or ``'C'``. boundary_type (Optional[str]): Type of boundary. Currently, only ``'simple'`` is supported. Here 'simple' refers to boundaries that are parallel to lines of constant longitude or latitude. - bathymetry_path (Optional[str]): Path to the bathymetry file. Default is None, in which case the bathymetry file is assumed to be in the input directory. + bathymetry_path (Optional[str]): Path to the bathymetry file. Default is None, in which case the BC is not masked rotational_method (Optional[str]): Method to use for rotating the boundary velocities. Default is 'GIVEN_ANGLE'. """ @@ -1679,7 +1677,7 @@ def setup_boundary_tides( tidal_filename: Name of the tpxo product that's used in the tidal_filename. Should be h_tidal_filename, u_tidal_filename tidal_constituents: List of tidal constituents to include in the regridding. Default is [0] which is the M2 constituent. boundary_type (str): Type of boundary. Currently, only rectangle is supported. Here rectangle refers to boundaries that are parallel to lines of constant longitude or latitude. - bathymetry_path (str): Path to the bathymetry file. Default is None, in which case the bathymetry file is assumed to be in the input directory. + bathymetry_path (str): Path to the bathymetry file. Default is None, in which case the BC is not masked rotational_method (str): Method to use for rotating the tidal velocities. Default is 'GIVEN_ANGLE'. Returns: .nc files: Regridded tidal velocity and elevation files in 'inputdir/forcing' @@ -1705,8 +1703,6 @@ def setup_boundary_tides( ) if tidal_constituents != "read_from_expt_init": self.tidal_constituents = tidal_constituents - if bathymetry_path is None: - bathymetry_path = self.mom_input_dir / "bathymetry.nc" tpxo_h = ( xr.open_dataset(Path(tpxo_elevation_filepath)) .rename({"lon_z": "lon", "lat_z": "lat", "nc": "constituent"}) @@ -1751,23 +1747,19 @@ def setup_boundary_tides( print("Processing {} boundary...".format(b), end="") # If the GLORYS ocean_state has already created segments, we don't create them again. - if b not in self.segments.keys(): # I.E. not set yet - seg = segment( - hgrid=self.hgrid, - bathymetry_path=bathymetry_path, - infile=None, # location of raw boundary - outfolder=self.mom_input_dir, - varnames=None, - segment_name="segment_{:03d}".format( - self.find_MOM6_rectangular_orientation(b) - ), - orientation=b, # orienataion - startdate=self.date_range[0], - repeat_year_forcing=self.repeat_year_forcing, - ) - self.segments[b] = seg - else: - seg = self.segments[b] + seg = segment( + hgrid=self.hgrid, + bathymetry_path=bathymetry_path, + infile=None, # location of raw boundary + outfolder=self.mom_input_dir, + varnames=None, + segment_name="segment_{:03d}".format( + self.find_MOM6_rectangular_orientation(b) + ), + orientation=b, # orienataion + startdate=self.date_range[0], + repeat_year_forcing=self.repeat_year_forcing, + ) # Output and regrid tides seg.regrid_tides( @@ -2528,6 +2520,19 @@ def setup_run_directory( 0, ] nml.write(self.mom_run_dir / "input.nml", force=True) + + # Edit Diag Table Date + # Read the file + with open(self.mom_run_dir / "diag_table", "r") as file: + lines = file.readlines() + + # The date is the second line + lines[1] = self.date_range[0].strftime("%Y %-m %-d %-H %-M %-S\n") + + # Write the file + with open(self.mom_run_dir / "diag_table", "w") as file: + file.writelines(lines) + return def change_MOM_parameter( @@ -2969,6 +2974,7 @@ def regrid_velocity_tracers(self, rotational_method=rot.RotationMethod.GIVEN_ANG coords, self.outfolder / f"weights/bilinear_velocity_weights_{self.orientation}.nc", + method="nearest_s2d", ) regridded = regridder( @@ -3143,9 +3149,10 @@ def regrid_velocity_tracers(self, rotational_method=rot.RotationMethod.GIVEN_ANG ## segment out now contains our interpolated boundary. ## Now, we need to fix up all the metadata and save + segment_out = segment_out.rename( + {"lon": f"lon_{self.segment_name}", "lat": f"lat_{self.segment_name}"} + ) - del segment_out["lon"] - del segment_out["lat"] ## Convert temperatures to celsius # use pint if ( np.nanmin(segment_out[self.tracers["temp"]].isel({self.time: 0, self.z: 0})) @@ -3155,9 +3162,11 @@ def regrid_velocity_tracers(self, rotational_method=rot.RotationMethod.GIVEN_ANG segment_out[self.tracers["temp"]].attrs["units"] = "degrees Celsius" # fill in NaNs - segment_out = rgd.fill_missing_data(segment_out, self.z) + # segment_out = rgd.fill_missing_data(segment_out, self.z) segment_out = rgd.fill_missing_data( - segment_out, f"{coords.attrs['parallel']}_{self.segment_name}" + segment_out, + xdim=f"{coords.attrs['parallel']}_{self.segment_name}", + zdim=self.z, ) times = xr.DataArray( @@ -3240,7 +3249,7 @@ def regrid_velocity_tracers(self, rotational_method=rot.RotationMethod.GIVEN_ANG encoding_dict = rgd.generate_encoding( segment_out, encoding_dict, - default_fill_value=netCDF4.default_fillvals["f8"], + default_fill_value=1.0e20, ) segment_out.load().to_netcdf( @@ -3312,11 +3321,11 @@ def regrid_tides( # Fill missing data. # Need to do this first because complex would get converted to real redest = rgd.fill_missing_data( - redest, f"{coords.attrs['parallel']}_{self.segment_name}" + redest, xdim=f"{coords.attrs['parallel']}_{self.segment_name}", zdim=None ) redest = redest["hRe"] imdest = rgd.fill_missing_data( - imdest, f"{coords.attrs['parallel']}_{self.segment_name}" + imdest, xdim=f"{coords.attrs['parallel']}_{self.segment_name}", zdim=None ) imdest = imdest["hIm"] @@ -3362,16 +3371,16 @@ def regrid_tides( # Fill missing data. # Need to do this first because complex would get converted to real uredest = rgd.fill_missing_data( - uredest, f"{coords.attrs['parallel']}_{self.segment_name}" + uredest, xdim=f"{coords.attrs['parallel']}_{self.segment_name}", zdim=None ) uimdest = rgd.fill_missing_data( - uimdest, f"{coords.attrs['parallel']}_{self.segment_name}" + uimdest, xdim=f"{coords.attrs['parallel']}_{self.segment_name}", zdim=None ) vredest = rgd.fill_missing_data( - vredest, f"{coords.attrs['parallel']}_{self.segment_name}" + vredest, xdim=f"{coords.attrs['parallel']}_{self.segment_name}", zdim=None ) vimdest = rgd.fill_missing_data( - vimdest, f"{coords.attrs['parallel']}_{self.segment_name}" + vimdest, xdim=f"{coords.attrs['parallel']}_{self.segment_name}", zdim=None ) # Convert to complex, remaining separate for u and v. @@ -3437,7 +3446,7 @@ def regrid_tides( # Some things may have become missing during the transformation ds_ap = rgd.fill_missing_data( - ds_ap, f"{coords.attrs['parallel']}_{self.segment_name}" + ds_ap, xdim=f"{coords.attrs['parallel']}_{self.segment_name}", zdim=None ) self.encode_tidal_files_and_output(ds_ap, "tu") @@ -3503,9 +3512,7 @@ def encode_tidal_files_and_output(self, ds, filename): f"lon_{self.segment_name}": dict(dtype="float64", _FillValue=1.0e20), f"lat_{self.segment_name}": dict(dtype="float64", _FillValue=1.0e20), } - encoding = rgd.generate_encoding( - ds, encoding, default_fill_value=netCDF4.default_fillvals["f8"] - ) + encoding = rgd.generate_encoding(ds, encoding, default_fill_value=1.0e20) ## Export Files ## ds.to_netcdf( diff --git a/regional_mom6/regridding.py b/regional_mom6/regridding.py index 3a0a0825..8bfa15b9 100644 --- a/regional_mom6/regridding.py +++ b/regional_mom6/regridding.py @@ -238,9 +238,11 @@ def create_regridder( return regridder -def fill_missing_data(ds: xr.Dataset, z_dim_name: str) -> xr.Dataset: +def fill_missing_data( + ds: xr.Dataset, xdim: str = "locations", zdim: str = "z", fill: str = "b" +) -> xr.Dataset: """ - Fill in missing values with forward fill along the z dimension (We can make this more elaborate with time.... The original RM6 fill was different) + Fill in missing values, taken from GFDL NWA 25 Repo Parameters ---------- ds : xr.Dataset @@ -252,11 +254,14 @@ def fill_missing_data(ds: xr.Dataset, z_dim_name: str) -> xr.Dataset: xr.Dataset The filled in dataset """ - regridding_logger.info("Forward filling in missing data along z-dim") - ds = ds.ffill( - dim=z_dim_name, limit=None - ) # This fills in the nans with the forward fill along the z dimension with an unlimited num of nans - return ds + regridding_logger.info("Filling in missing data horizontally, then vertically") + if fill == "f": + filled = ds.ffill(dim=xdim, limit=None) + elif fill == "b": + filled = ds.bfill(dim=xdim, limit=None) + if zdim is not None: + filled = filled.ffill(dim=zdim, limit=None).fillna(0) + return filled def add_or_update_time_dim(ds: xr.Dataset, times) -> xr.Dataset: @@ -453,6 +458,7 @@ def get_boundary_mask( minimum_depth=0, x_dim_name="lonh", y_dim_name="lath", + add_land_exceptions = True ) -> np.ndarray: """ Mask out the boundary conditions based on the bathymetry. We don't want to have boundary conditions on land. @@ -468,6 +474,8 @@ def get_boundary_mask( The segment name minimum_depth : float, optional The minimum depth to consider land, by default 0 + add_land_exceptions : bool + Add the corners and 3 coast point exceptions Returns ------- np.ndarray @@ -539,32 +547,33 @@ def get_boundary_mask( ) boundary_mask[(i * 2)] = land + if add_land_exceptions: # Land points that can't be NaNs: Corners & 3 points at the coast # Looks like in the boundary between land and ocean - in NWA for example - we basically need to remove 3 points closest to ocean as a buffer. # Search for intersections - coasts_lower_index = [] - coasts_higher_index = [] - for index in range(1, len(boundary_mask) - 1): - if boundary_mask[index - 1] == land and boundary_mask[index] == ocean: - coasts_lower_index.append(index) - elif boundary_mask[index + 1] == land and boundary_mask[index] == ocean: - coasts_higher_index.append(index) - - # Remove 3 land points from the coast, and make them zeroed out real values - for i in range(3): - for coast in coasts_lower_index: - if coast - 1 - i >= 0: - boundary_mask[coast - 1 - i] = zero_out - for coast in coasts_higher_index: - if coast + 1 + i < len(boundary_mask): - boundary_mask[coast + 1 + i] = zero_out - - # Corner Q-points defined as land should be zeroed out - if boundary_mask[0] == land: - boundary_mask[0] = zero_out - if boundary_mask[-1] == land: - boundary_mask[-1] = zero_out + coasts_lower_index = [] + coasts_higher_index = [] + for index in range(1, len(boundary_mask) - 1): + if boundary_mask[index - 1] == land and boundary_mask[index] == ocean: + coasts_lower_index.append(index) + elif boundary_mask[index + 1] == land and boundary_mask[index] == ocean: + coasts_higher_index.append(index) + + # Remove 3 land points from the coast, and make them zeroed out real values + for i in range(3): + for coast in coasts_lower_index: + if coast - 1 - i >= 0: + boundary_mask[coast - 1 - i] = zero_out + for coast in coasts_higher_index: + if coast + 1 + i < len(boundary_mask): + boundary_mask[coast + 1 + i] = zero_out + + # Corner Q-points defined as land should be zeroed out + if boundary_mask[0] == land: + boundary_mask[0] = zero_out + if boundary_mask[-1] == land: + boundary_mask[-1] = zero_out # Convert land points to nans boundary_mask[np.where(boundary_mask == land)] = np.nan @@ -580,6 +589,7 @@ def mask_dataset( segment_name: str, y_dim_name="lath", x_dim_name="lonh", + add_land_exceptions = True ) -> xr.Dataset: """ This function masks the dataset to the provided bathymetry. If bathymetry is not provided, it fills all NaNs with 0. @@ -595,6 +605,8 @@ def mask_dataset( The orientation of the boundary segment_name : str The segment name + add_land_exceptions : bool + To add the corner and 3 point coast exception """ ## Add Boundary Mask ## if bathymetry is not None: @@ -609,6 +621,7 @@ def mask_dataset( minimum_depth=0, x_dim_name=x_dim_name, y_dim_name=y_dim_name, + add_land_exceptions = add_land_exceptions ) if orientation in ["east", "west"]: mask = mask[:, np.newaxis] From b5b3e38548813851ce473cdfcc64c1726fc46da6 Mon Sep 17 00:00:00 2001 From: manishvenu Date: Mon, 30 Dec 2024 09:33:18 -0700 Subject: [PATCH 71/87] Black --- regional_mom6/regridding.py | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/regional_mom6/regridding.py b/regional_mom6/regridding.py index 8bfa15b9..8d81fcda 100644 --- a/regional_mom6/regridding.py +++ b/regional_mom6/regridding.py @@ -458,7 +458,7 @@ def get_boundary_mask( minimum_depth=0, x_dim_name="lonh", y_dim_name="lath", - add_land_exceptions = True + add_land_exceptions=True, ) -> np.ndarray: """ Mask out the boundary conditions based on the bathymetry. We don't want to have boundary conditions on land. @@ -548,10 +548,10 @@ def get_boundary_mask( boundary_mask[(i * 2)] = land if add_land_exceptions: - # Land points that can't be NaNs: Corners & 3 points at the coast + # Land points that can't be NaNs: Corners & 3 points at the coast - # Looks like in the boundary between land and ocean - in NWA for example - we basically need to remove 3 points closest to ocean as a buffer. - # Search for intersections + # Looks like in the boundary between land and ocean - in NWA for example - we basically need to remove 3 points closest to ocean as a buffer. + # Search for intersections coasts_lower_index = [] coasts_higher_index = [] for index in range(1, len(boundary_mask) - 1): @@ -589,7 +589,7 @@ def mask_dataset( segment_name: str, y_dim_name="lath", x_dim_name="lonh", - add_land_exceptions = True + add_land_exceptions=True, ) -> xr.Dataset: """ This function masks the dataset to the provided bathymetry. If bathymetry is not provided, it fills all NaNs with 0. @@ -621,7 +621,7 @@ def mask_dataset( minimum_depth=0, x_dim_name=x_dim_name, y_dim_name=y_dim_name, - add_land_exceptions = add_land_exceptions + add_land_exceptions=add_land_exceptions, ) if orientation in ["east", "west"]: mask = mask[:, np.newaxis] From 8f59ebb05345b3cb2f8215d9a852f761208fd839 Mon Sep 17 00:00:00 2001 From: alperaltuntas Date: Tue, 31 Dec 2024 13:43:25 -0700 Subject: [PATCH 72/87] Add aiohttp and copernicusmarine dependencies --- pyproject.toml | 2 ++ 1 file changed, 2 insertions(+) diff --git a/pyproject.toml b/pyproject.toml index e5eb7a54..ed909cc5 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -17,6 +17,8 @@ dependencies = [ "xarray <= 2024.7.0", "xesmf >= 0.8.4", "f90nml >= 1.4.1", + "aiohttp >= 3.9.5,<3.10.0", + "copernicusmarine >= 1.2.4,<1.3.0" ] [build-system] From bbda1b99f3e9e013f4465344856732b441436821 Mon Sep 17 00:00:00 2001 From: alperaltuntas Date: Tue, 31 Dec 2024 13:46:37 -0700 Subject: [PATCH 73/87] add hgrid_path and vgrid_path args to __init__ to allow non-standard filenames. Similarly, add thickesses arg to _make_vgrid. --- regional_mom6/regional_mom6.py | 41 +++++++++++++++++++++++++++------- 1 file changed, 33 insertions(+), 8 deletions(-) diff --git a/regional_mom6/regional_mom6.py b/regional_mom6/regional_mom6.py index 7ac5b846..96121eb7 100644 --- a/regional_mom6/regional_mom6.py +++ b/regional_mom6/regional_mom6.py @@ -650,7 +650,9 @@ def __init__( longitude_extent=None, latitude_extent=None, hgrid_type="even_spacing", + hgrid_path=None, vgrid_type="hyperbolic_tangent", + vgrid_path=None, repeat_year_forcing=False, minimum_depth=4, tidal_constituents=["M2"], @@ -673,7 +675,7 @@ def __init__( self.mom_run_dir = Path(mom_run_dir) self.mom_input_dir = Path(mom_input_dir) - self.toolpath_dir = Path(toolpath_dir) + self.toolpath_dir = Path(toolpath_dir) if toolpath_dir is not None else None self.mom_run_dir.mkdir(exist_ok=True) self.mom_input_dir.mkdir(exist_ok=True) @@ -695,8 +697,12 @@ def __init__( self.tidal_constituents = tidal_constituents if hgrid_type == "from_file": + if hgrid_path is None: + hgrid_path = self.mom_input_dir / "hgrid.nc" + else: + hgrid_path = Path(hgrid_path) try: - self.hgrid = xr.open_dataset(self.mom_input_dir / "hgrid.nc") + self.hgrid = xr.open_dataset(hgrid_path) self.longitude_extent = ( float(self.hgrid.x.min()), float(self.hgrid.x.max()), @@ -712,13 +718,20 @@ def __init__( ) raise ValueError else: + if hgrid_path: + raise ValueError("hgrid_path can only be set if hgrid_type is 'from_file'.") self.longitude_extent = tuple(longitude_extent) self.latitude_extent = tuple(latitude_extent) self.hgrid = self._make_hgrid() if vgrid_type == "from_file": + if vgrid_path is None: + vgrid_path = self.mom_input_dir / "vgrid.nc" + else: + vgrid_path = Path(vgrid_path) + try: - self.vgrid = xr.open_dataset(self.mom_input_dir / "vcoord.nc") + vgrid_from_file = xr.open_dataset(vgrid_path) except: print( @@ -726,7 +739,10 @@ def __init__( + f"Make sure `vcoord.nc`exists in {self.mom_input_dir} directory." ) raise ValueError + self.vgrid = self._make_vgrid(vgrid_from_file.dz.data) else: + if vgrid_path: + raise ValueError("vgrid_path can only be set if vgrid_type is 'from_file'.") self.vgrid = self._make_vgrid() self.segments = {} @@ -906,7 +922,7 @@ def _make_hgrid(self): return hgrid - def _make_vgrid(self): + def _make_vgrid(self, thicknesses=None): """ Generates a vertical grid based on the ``number_vertical_layers``, the ratio of largest to smallest layer thickness (``layer_thickness_ratio``) and the @@ -914,9 +930,10 @@ def _make_vgrid(self): (All these parameters are specified at the class level.) """ - thicknesses = hyperbolictan_thickness_profile( - self.number_vertical_layers, self.layer_thickness_ratio, self.depth - ) + if thicknesses is None: + thicknesses = hyperbolictan_thickness_profile( + self.number_vertical_layers, self.layer_thickness_ratio, self.depth + ) zi = np.cumsum(thicknesses) zi = np.insert(zi, 0, 0.0) # add zi = 0.0 as first interface @@ -1531,7 +1548,15 @@ def get_glorys_rectangular(self, raw_boundaries_path): ) print( - f"script `get_glorys_data.sh` has been created at {raw_boundaries_path}.\n Run this script via bash to download the data from a terminal with internet access. \nYou will need to enter your Copernicus Marine username and password.\nIf you don't have an account, make one here:\nhttps://data.marine.copernicus.eu/register" + f"The script `get_glorys_data.sh` has been generated at:\n {raw_boundaries_path}.\n" + f"To download the data, run this script using `bash` in a terminal with internet access.\n\n" + f"Important instructions:\n" + f"1. You will need your Copernicus Marine username and password.\n" + f" If you do not have an account, you can create one here: \n" + f" https://data.marine.copernicus.eu/register\n" + f"2. You will be prompted to enter your Copernicus Marine credentials multiple times: once for each dataset.\n" + f"3. Depending on the dataset size, the download process may take significant time and resources.\n" + f"4. Thus, on certain systems, you may need to run this script as a batch job.\n" ) return From 9665892ad88f081265ff87855adaa65f486fe3db Mon Sep 17 00:00:00 2001 From: alperaltuntas Date: Mon, 6 Jan 2025 14:39:59 -0700 Subject: [PATCH 74/87] black reformatting --- regional_mom6/regional_mom6.py | 26 ++++++++++++++++++++------ 1 file changed, 20 insertions(+), 6 deletions(-) diff --git a/regional_mom6/regional_mom6.py b/regional_mom6/regional_mom6.py index 96121eb7..80986c43 100644 --- a/regional_mom6/regional_mom6.py +++ b/regional_mom6/regional_mom6.py @@ -719,7 +719,9 @@ def __init__( raise ValueError else: if hgrid_path: - raise ValueError("hgrid_path can only be set if hgrid_type is 'from_file'.") + raise ValueError( + "hgrid_path can only be set if hgrid_type is 'from_file'." + ) self.longitude_extent = tuple(longitude_extent) self.latitude_extent = tuple(latitude_extent) self.hgrid = self._make_hgrid() @@ -742,7 +744,9 @@ def __init__( self.vgrid = self._make_vgrid(vgrid_from_file.dz.data) else: if vgrid_path: - raise ValueError("vgrid_path can only be set if vgrid_type is 'from_file'.") + raise ValueError( + "vgrid_path can only be set if vgrid_type is 'from_file'." + ) self.vgrid = self._make_vgrid() self.segments = {} @@ -1885,7 +1889,9 @@ def setup_bathymetry( bathymetry_output.depth.attrs["coordinates"] = "lon lat" if write_to_file: bathymetry_output.to_netcdf( - self.mom_input_dir / "bathymetry_original.nc", mode="w", engine="netcdf4" + self.mom_input_dir / "bathymetry_original.nc", + mode="w", + engine="netcdf4", ) tgrid = xr.Dataset( @@ -1924,7 +1930,9 @@ def setup_bathymetry( tgrid.depth.attrs["coordinates"] = "lon lat" if write_to_file: tgrid.to_netcdf( - self.mom_input_dir / "bathymetry_unfinished.nc", mode="w", engine="netcdf4" + self.mom_input_dir / "bathymetry_unfinished.nc", + mode="w", + engine="netcdf4", ) tgrid.close() @@ -1945,7 +1953,9 @@ def setup_bathymetry( bathymetry = regridder(bathymetry_output) if write_to_file: bathymetry.to_netcdf( - self.mom_input_dir / "bathymetry_unfinished.nc", mode="w", engine="netcdf4" + self.mom_input_dir / "bathymetry_unfinished.nc", + mode="w", + engine="netcdf4", ) print( "Regridding successful! Now calling `tidy_bathymetry` method for some finishing touches..." @@ -1957,7 +1967,11 @@ def setup_bathymetry( return bathymetry def tidy_bathymetry( - self, fill_channels=False, positive_down=False, vertical_coordinate_name="depth", bathymetry=None + self, + fill_channels=False, + positive_down=False, + vertical_coordinate_name="depth", + bathymetry=None, ): """ An auxiliary function for bathymetry used to fix up the metadata and remove inland From cd5e4084d56aecde6981780533df1a0870ffd4b9 Mon Sep 17 00:00:00 2001 From: manishvenu Date: Mon, 6 Jan 2025 17:14:50 -0700 Subject: [PATCH 75/87] Update Initial Condition + Alternate Rotation Function --- regional_mom6/regional_mom6.py | 133 ++++++++++++++++++++------------- regional_mom6/regridding.py | 10 ++- tests/test_regridding.py | 5 +- 3 files changed, 95 insertions(+), 53 deletions(-) diff --git a/regional_mom6/regional_mom6.py b/regional_mom6/regional_mom6.py index fa78a830..a98cb53c 100644 --- a/regional_mom6/regional_mom6.py +++ b/regional_mom6/regional_mom6.py @@ -1114,6 +1114,7 @@ def setup_initial_condition( varnames, arakawa_grid="A", vcoord_type="height", + rotational_method=rot.RotationMethod.GIVEN_ANGLE, ): """ Reads the initial condition from files in ``ic_path``, interpolates to the @@ -1127,6 +1128,7 @@ def setup_initial_condition( Either ``'A'`` (default), ``'B'``, or ``'C'``. vcoord_type (Optional[str]): The type of vertical coordinate used in the forcing files. Either ``'height'`` or ``'thickness'``. + rotational_method (Optional[RotationMethod]): The method used to rotate the velocities. """ # Remove time dimension if present in the IC. @@ -1249,28 +1251,6 @@ def setup_initial_condition( + "Terminating!" ) - ## Construct the xq, yh and xh, yq grids - ugrid = ( - self.hgrid[["x", "y"]] - .isel(nxp=slice(None, None, 2), nyp=slice(1, None, 2)) - .rename({"x": "lon", "y": "lat"}) - .set_coords(["lat", "lon"]) - ) - vgrid = ( - self.hgrid[["x", "y"]] - .isel(nxp=slice(1, None, 2), nyp=slice(None, None, 2)) - .rename({"x": "lon", "y": "lat"}) - .set_coords(["lat", "lon"]) - ) - - ## Construct the cell centre grid for tracers (xh, yh). - tgrid = ( - self.hgrid[["x", "y"]] - .isel(nxp=slice(1, None, 2), nyp=slice(1, None, 2)) - .rename({"x": "lon", "y": "lat", "nxp": "nx", "nyp": "ny"}) - .set_coords(["lat", "lon"]) - ) - # NaNs might be here from the land mask of the model that the IC has come from. # If they're not removed then the coastlines from this other grid will be retained! # The land mask comes from the bathymetry file, so we don't need NaNs @@ -1309,39 +1289,75 @@ def setup_initial_condition( .ffill("lat") .bfill("lat") ) + renamed_hgrid = self.hgrid # This is not a deep copy + renamed_hgrid["lon"] = renamed_hgrid["x"] + renamed_hgrid["lat"] = renamed_hgrid["y"] + tgrid = ( + rgd.get_hgrid_arakawa_c_points(self.hgrid, "t") + .rename({"tlon": "lon", "tlat": "lat", "nxp": "nx", "nyp": "ny"}) + .set_coords(["lat", "lon"]) + ) ## Make our three horizontal regridders - regridder_u = xe.Regridder( - ic_raw_u, - ugrid, - "bilinear", + + regridder_u = rgd.create_regridder( + ic_raw_u, renamed_hgrid, locstream_out=False, method="bilinear" ) - regridder_v = xe.Regridder( - ic_raw_v, - vgrid, - "bilinear", + regridder_v = rgd.create_regridder( + ic_raw_v, renamed_hgrid, locstream_out=False, method="bilinear" ) + regridder_t = rgd.create_regridder( + ic_raw_tracers, tgrid, locstream_out=False, method="bilinear" + ) # Doesn't need to be rotated, so we can regrid to just tracers - regridder_t = xe.Regridder( - ic_raw_tracers, - tgrid, - "bilinear", - ) + # ugrid= rgd.get_hgrid_arakawa_c_points(self.hgrid, "u").rename({"ulon": "lon", "ulat": "lat"}).set_coords(["lat", "lon"]) + # vgrid = rgd.get_hgrid_arakawa_c_points(self.hgrid, "v").rename({"vlon": "lon", "vlat": "lat"}).set_coords(["lat", "lon"]) + ## Construct the cell centre grid for tracers (xh, yh). print("INITIAL CONDITIONS") ## Regrid all fields horizontally. print("Regridding Velocities... ", end="") - + regridded_u = regridder_u(ic_raw_u) + regridded_v = regridder_v(ic_raw_v) + if rotational_method == rot.RotationMethod.GIVEN_ANGLE: + rotated_u, rotated_v = segment.rotate( + None, + regridded_u, + regridded_v, + radian_angle=np.radians(self.hgrid.angle_dx.values), + ) + elif rotational_method == rot.RotationMethod.EXPAND_GRID: + self.hgrid["angle_dx_rm6"] = ( + rot.initialize_grid_rotation_angles_using_expanded_hgrid(self.hgrid) + ) + rotated_u, rotated_v = segment.rotate( + regridded_u, + regridded_v, + radian_angle=np.radians(self.hgrid.angle_dx_rm6.values), + ) + elif rotational_method == rot.RotationMethod.NO_ROTATION: + rotated_u, rotated_v = regridded_u, regridded_v + # Slice the velocites to the u and v grid. + u_points = rgd.get_hgrid_arakawa_c_points(self.hgrid, "u") + v_points = rgd.get_hgrid_arakawa_c_points(self.hgrid, "v") + rotated_v = rotated_v[:, v_points.v_points_y.values, v_points.v_points_x.values] + rotated_u = rotated_u[:, u_points.u_points_y.values, u_points.u_points_x.values] + rotated_u["lon"] = u_points.ulon + rotated_u["lat"] = u_points.ulat + rotated_v["lon"] = v_points.vlon + rotated_v["lat"] = v_points.vlat + + # Merge Vels vel_out = xr.merge( [ - regridder_u(ic_raw_u) - .rename({"lon": "xq", "lat": "yh", "nyp": "ny", varnames["zl"]: "zl"}) - .rename("u"), - regridder_v(ic_raw_v) - .rename({"lon": "xh", "lat": "yq", "nxp": "nx", varnames["zl"]: "zl"}) - .rename("v"), + rotated_u.rename( + {"lon": "xq", "lat": "yh", "nyp": "ny", varnames["zl"]: "zl"} + ).rename("u"), + rotated_v.rename( + {"lon": "xh", "lat": "yq", "nxp": "nx", varnames["zl"]: "zl"} + ).rename("v"), ] ) @@ -1400,14 +1416,11 @@ def setup_initial_condition( eta_out.attrs = ic_raw_eta.attrs ## Regrid the fields vertically - if ( vcoord_type == "thickness" ): ## In this case construct the vertical profile by summing thickness tracers_out["zl"] = tracers_out["zl"].diff("zl") - dz = tracers_out[self.z].diff(self.z) - dz.name = "dz" - dz = xr.concat([dz, dz[-1]], dim=self.z) + dz = rgd.generate_dz(tracers_out, self.z) tracers_out = tracers_out.interp({"zl": self.vgrid.zl.values}) vel_out = vel_out.interp({"zl": self.vgrid.zl.values}) @@ -2934,9 +2947,30 @@ def __init__( self.segment_name = segment_name self.repeat_year_forcing = repeat_year_forcing - def rotate(self, u, v, radian_angle): - # Make docstring + def rotate_complex(self, u, v, radian_angle): + """ + Rotate velocities to grid orientation using complex number math (Same as rotate) + Args: + u (xarray.DataArray): The u-component of the velocity. + v (xarray.DataArray): The v-component of the velocity. + radian_angle (xarray.DataArray): The angle of the grid in RADIANS + + Returns: + Tuple[xarray.DataArray, xarray.DataArray]: The rotated u and v components of the velocity. + """ + # express velocity in the complex plan + vel = u + v * 1j + # rotate velocity using grid angle theta + vel = vel * np.exp(1j * radian_angle) + + # From here you can easily get the rotated u, v, or the magnitude/direction of the currents: + u = np.real(vel) + v = np.imag(vel) + + return u, v + + def rotate(self, u, v, radian_angle): """ Rotate the velocities to the grid orientation. Args: @@ -2974,7 +3008,7 @@ def regrid_velocity_tracers(self, rotational_method=rot.RotationMethod.GIVEN_ANG coords, self.outfolder / f"weights/bilinear_velocity_weights_{self.orientation}.nc", - method="nearest_s2d", + method="bilinear", ) regridded = regridder( @@ -2990,7 +3024,6 @@ def regrid_velocity_tracers(self, rotational_method=rot.RotationMethod.GIVEN_ANG regridded[self.v], radian_angle=np.radians(coords.angle.values), ) - elif rotational_method == rot.RotationMethod.EXPAND_GRID: # Recalculate entire hgrid angles diff --git a/regional_mom6/regridding.py b/regional_mom6/regridding.py index 8d81fcda..7af0e6a9 100644 --- a/regional_mom6/regridding.py +++ b/regional_mom6/regridding.py @@ -207,6 +207,8 @@ def create_regridder( output_grid: xr.Dataset, outfile: Path = None, method: str = "bilinear", + locstream_out: bool = True, + periodic: bool = False, ) -> xe.Regridder: """ Basic Regridder for any forcing variables, this just wraps the xesmf regridder for a few defaults @@ -220,6 +222,10 @@ def create_regridder( The path to the output file for weights I believe, by default Path(".temp") method : str, optional The regridding method, by default "bilinear" + locstream_out : bool, optional + Whether to output the locstream, by default True + periodic : bool, optional + Whether the grid is periodic, by default False Returns ------- xe.Regridder @@ -230,8 +236,8 @@ def create_regridder( forcing_variables, output_grid, method=method, - locstream_out=True, - periodic=False, + locstream_out=locstream_out, + periodic=periodic, filename=outfile, reuse_weights=False, ) diff --git a/tests/test_regridding.py b/tests/test_regridding.py index dfd262bc..6ba00dec 100644 --- a/tests/test_regridding.py +++ b/tests/test_regridding.py @@ -18,10 +18,13 @@ def test_smoke_untested_funcs(get_curvilinear_hgrid, generate_silly_vt_dataset): def test_fill_missing_data(generate_silly_vt_dataset): + """ + Only testing forward fill for now + """ ds = generate_silly_vt_dataset ds["temp"][0, 0, 6:10, 0] = np.nan - ds = rgd.fill_missing_data(ds, "silly_depth") + ds = rgd.fill_missing_data(ds, "silly_depth", fill="f") assert ( ds["temp"][0, 0, 6:10, 0] == (ds["temp"][0, 0, 5, 0]) From 7be170fac78ce74554f10221307e49009bebdbbb Mon Sep 17 00:00:00 2001 From: manishvenu Date: Wed, 8 Jan 2025 13:59:08 -0700 Subject: [PATCH 76/87] Rename get_glorys_rect to get_glorys --- demos/reanalysis-forced.ipynb | 2 +- regional_mom6/regional_mom6.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/demos/reanalysis-forced.ipynb b/demos/reanalysis-forced.ipynb index a4d161f2..b9b3dc04 100644 --- a/demos/reanalysis-forced.ipynb +++ b/demos/reanalysis-forced.ipynb @@ -191,7 +191,7 @@ "metadata": {}, "outputs": [], "source": [ - "expt.get_glorys_rectangular(\n", + "expt.get_glorys(\n", " raw_boundaries_path=glorys_path\n", ")" ] diff --git a/regional_mom6/regional_mom6.py b/regional_mom6/regional_mom6.py index fc666732..9cde4552 100644 --- a/regional_mom6/regional_mom6.py +++ b/regional_mom6/regional_mom6.py @@ -1486,7 +1486,7 @@ def setup_initial_condition( return - def get_glorys_rectangular(self, raw_boundaries_path): + def get_glorys(self, raw_boundaries_path): """ This function is a wrapper for `get_glorys_data`, calling this function once for each of the rectangular boundary segments and the initial condition. For more complex boundary shapes, call `get_glorys_data` directly for each of your boundaries that aren't parallel to lines of constant latitude or longitude. For example, for an angled Northern boundary that spans multiple latitudes, you'll need to download a wider rectangle containing the entire boundary. From 1048b701606d2d3c2581250fca9581f0a33eb46a Mon Sep 17 00:00:00 2001 From: manishvenu Date: Thu, 9 Jan 2025 10:36:20 -0700 Subject: [PATCH 77/87] Move RM6 to logging over print statements, but still report regional_mom6 to stdout --- demos/reanalysis-forced.ipynb | 11 ++++ regional_mom6/regional_mom6.py | 110 +++++++++++++++++---------------- regional_mom6/regridding.py | 2 +- regional_mom6/rotation.py | 4 +- regional_mom6/utils.py | 10 +-- 5 files changed, 75 insertions(+), 62 deletions(-) diff --git a/demos/reanalysis-forced.ipynb b/demos/reanalysis-forced.ipynb index b9b3dc04..84ba01a9 100644 --- a/demos/reanalysis-forced.ipynb +++ b/demos/reanalysis-forced.ipynb @@ -55,6 +55,17 @@ "from dask.distributed import Client" ] }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Currently, only the regional_mom6 module reports logging information to the info level, for more detailed output\n", + "# import logging\n", + "# logging.basicConfig(level=logging.INFO) \n" + ] + }, { "cell_type": "markdown", "metadata": {}, diff --git a/regional_mom6/regional_mom6.py b/regional_mom6/regional_mom6.py index 9cde4552..0d295033 100644 --- a/regional_mom6/regional_mom6.py +++ b/regional_mom6/regional_mom6.py @@ -22,7 +22,9 @@ import copy from . import regridding as rgd from . import rotation as rot -from .utils import quadrilateral_areas, ap2ep, ep2ap, is_rectilinear_hgrid +from .utils import quadrilateral_areas, ap2ep, ep2ap, is_rectilinear_hgrid, setup_logger +import logging +rm6_logger = setup_logger(__name__, set_handler=True) warnings.filterwarnings("ignore") @@ -97,14 +99,14 @@ def create_experiment_from_config( Returns: experiment: An experiment object with the fields from the config loaded in. """ - print("Reading from config file....") + rm6_logger.info("Reading from config file....") with open(config_file_path, "r") as f: config_dict = json.load(f) - print("Creating Empty Experiment Object....") + rm6_logger.info("Creating Empty Experiment Object....") expt = experiment.create_empty() - print("Setting Default Variables.....") + rm6_logger.info("Setting Default Variables.....") expt.expt_name = config_dict["expt_name"] try: expt.longitude_extent = tuple(config_dict["longitude_extent"]) @@ -145,13 +147,13 @@ def create_experiment_from_config( expt.boundaries = config_dict["boundaries"] if create_hgrid_and_vgrid: - print("Creating hgrid and vgrid....") + rm6_logger.info("Creating hgrid and vgrid....") expt.hgrid = expt._make_hgrid() expt.vgrid = expt._make_vgrid() else: - print("Skipping hgrid and vgrid creation....") + rm6_logger.info("Skipping hgrid and vgrid creation....") - print("Done!") + rm6_logger.info("Done!") return expt @@ -713,7 +715,7 @@ def __init__( float(self.hgrid.y.max()), ) except: - print( + rm6_logger.error( "Error while reading in existing horizontal grid!\n\n" + f"Make sure `hgrid.nc`exists in {self.mom_input_dir} directory." ) @@ -737,7 +739,7 @@ def __init__( vgrid_from_file = xr.open_dataset(vgrid_path) except: - print( + rm6_logger.error( "Error while reading in existing vertical coordinates!\n\n" + f"Make sure `vcoord.nc`exists in {self.mom_input_dir} directory." ) @@ -779,7 +781,7 @@ def __getattr__(self, name): decode_times=False, ) else: - print( + rm6_logger.error( f"bathymetry.nc file not found! Make sure you've successfully run the setup_bathmetry method, or copied your own bathymetry.nc file into {self.mom_input_dir}." ) return None @@ -791,7 +793,7 @@ def __getattr__(self, name): decode_times=False, ) else: - print( + rm6_logger.error( f"init_vel.nc file not found! Make sure you've successfully run the setup_initial_condition method, or copied your own init_vel.nc file into {self.mom_input_dir}." ) return @@ -804,7 +806,7 @@ def __getattr__(self, name): decode_times=False, ) else: - print( + rm6_logger.error( f"init_tracers.nc file not found! Make sure you've successfully run the setup_initial_condition method, or copied your own init_tracers.nc file into {self.mom_input_dir}." ) return @@ -817,7 +819,7 @@ def __getattr__(self, name): decode_cf=False, ) except: - print( + rm6_logger.error( f"{name} files not found! Make sure you've successfully run the setup_ocean_state_boundaries method, or copied your own segment files file into {self.mom_input_dir}." ) return None @@ -950,7 +952,7 @@ def _make_vgrid(self, thicknesses=None): ## Check whether the minimum depth is less than the first three layers if self.minimum_depth < zi[2]: - print( + rm6_logger.warning( f"Warning: Minimum depth of {self.minimum_depth}m is less than the depth of the third interface ({zi[2]}m)!\n" + "This means that some areas may only have one or two layers between the surface and sea floor. \n" + "For increased stability, consider increasing the minimum depth, or adjusting the vertical coordinate to add more layers near the surface." @@ -1089,7 +1091,7 @@ def write_config_file(self, path=None, export=True, quiet=False): Dict: A dictionary containing the configuration information. """ if not quiet: - print("Writing Config File.....") + rm6_logger.info("Writing Config File.....") try: date_range = [ self.date_range[0].strftime("%Y-%m-%d %H:%M:%S"), @@ -1126,7 +1128,7 @@ def write_config_file(self, path=None, export=True, quiet=False): indent=4, ) if not quiet: - print("Done.") + rm6_logger.info("Done.") return config_dict def setup_initial_condition( @@ -1335,11 +1337,11 @@ def setup_initial_condition( # vgrid = rgd.get_hgrid_arakawa_c_points(self.hgrid, "v").rename({"vlon": "lon", "vlat": "lat"}).set_coords(["lat", "lon"]) ## Construct the cell centre grid for tracers (xh, yh). - print("INITIAL CONDITIONS") + rm6_logger.info("Setting up Initial Conditions") ## Regrid all fields horizontally. - print("Regridding Velocities... ", end="") + rm6_logger.info("Regridding Velocities... ", end="") regridded_u = regridder_u(ic_raw_u) regridded_v = regridder_v(ic_raw_v) if rotational_method == rot.RotationMethod.GIVEN_ANGLE: @@ -1382,7 +1384,7 @@ def setup_initial_condition( ] ) - print("Done.\nRegridding Tracers... ", end="") + rm6_logger.info("Done.\nRegridding Tracers... ", end="") tracers_out = ( xr.merge( @@ -1406,7 +1408,7 @@ def setup_initial_condition( } ) - print("Done.\nRegridding Free surface... ", end="") + rm6_logger.info("Done.\nRegridding Free surface... ", end="") eta_out = ( regridder_t(ic_raw_eta) @@ -1414,7 +1416,7 @@ def setup_initial_condition( .rename("eta_t") .transpose("ny", "nx") ) ## eta_t is the name set in MOM_input by default - print("Done.") + rm6_logger.info("Done.") ## Return attributes to arrays @@ -1446,7 +1448,7 @@ def setup_initial_condition( tracers_out = tracers_out.interp({"zl": self.vgrid.zl.values}) vel_out = vel_out.interp({"zl": self.vgrid.zl.values}) - print("Saving outputs... ", end="") + rm6_logger.info("Saving outputs... ", end="") vel_out.fillna(0).to_netcdf( self.mom_input_dir / "init_vel.nc", @@ -1482,7 +1484,7 @@ def setup_initial_condition( self.ic_tracers = tracers_out self.ic_vels = vel_out - print("done setting up initial condition.") + rm6_logger.info("done setting up initial condition.") return @@ -1615,7 +1617,7 @@ def setup_ocean_state_boundaries( ) if len(self.boundaries) < 4: - print( + rm6_logger.warning( "NOTE: the 'setup_run_directories' method does understand the less than four boundaries but be careful. Please check the MOM_input/override file carefully to reflect the number of boundaries you have, and their orientations. You should be able to find the relevant section in the MOM_input/override file by searching for 'segment_'. Ensure that the segment names match those in your inputdir/forcing folder" ) @@ -1675,7 +1677,7 @@ def setup_single_boundary( rotational_method (Optional[str]): Method to use for rotating the boundary velocities. Default is 'GIVEN_ANGLE'. """ - print("Processing {} boundary...".format(orientation), end="") + rm6_logger.info("Processing {} boundary...".format(orientation), end="") if not path_to_bc.exists(): raise FileNotFoundError( f"Boundary file not found at {path_to_bc}. Please ensure that the files are named in the format `east_unprocessed.nc`." @@ -1699,7 +1701,7 @@ def setup_single_boundary( rotational_method=rotational_method ) - print("Done.") + rm6_logger.info("Done.") return def setup_boundary_tides( @@ -1739,7 +1741,7 @@ def setup_boundary_tides( Type: Python Functions, Source Code Web Address: https://github.com/jsimkins2/nwa25 """ - if boundary_type != "rectangle": + if boundary_type != "rectangle" and boundary_type != "curvilinear": raise ValueError( "Only rectangular boundaries are supported by this method." ) @@ -1786,7 +1788,7 @@ def setup_boundary_tides( ) # Initialize or find boundary segment for b in self.boundaries: - print("Processing {} boundary...".format(b), end="") + rm6_logger.info("Processing {} boundary...".format(b), end="") # If the GLORYS ocean_state has already created segments, we don't create them again. seg = segment( @@ -1807,7 +1809,7 @@ def setup_boundary_tides( seg.regrid_tides( tpxo_v, tpxo_u, tpxo_h, times, rotational_method=rotational_method ) - print("Done") + rm6_logger.info("Done") def setup_bathymetry( self, @@ -1991,7 +1993,7 @@ def setup_bathymetry( ) self.tidy_bathymetry(fill_channels, positive_down, bathymetry=bathymetry) - print("setup bathymetry has finished successfully.") + rm6_logger.info("setup bathymetry has finished successfully.") return bathymetry @@ -2024,7 +2026,7 @@ def tidy_bathymetry( """ ## reopen bathymetry to modify - print( + rm6_logger.info( "Tidy bathymetry: Reading in regridded bathymetry to fix up metadata...", end="", ) @@ -2052,7 +2054,7 @@ def tidy_bathymetry( land_mask = np.abs(ocean_mask - 1) ## REMOVE INLAND LAKES - print("done. Filling in inland lakes and channels... ", end="") + rm6_logger.info("done. Filling in inland lakes and channels... ", end="") changed = True ## keeps track of whether solution has converged or not @@ -2200,7 +2202,7 @@ def tidy_bathymetry( encoding={"depth": {"_FillValue": None}}, ) - print("done.") + rm6_logger.info("done.") return def run_FRE_tools(self, layout=None): @@ -2208,17 +2210,17 @@ def run_FRE_tools(self, layout=None): User provides processor ``layout`` tuple of processing units. """ - print( + rm6_logger.info( "Running GFDL's FRE Tools. The following information is all printed by the FRE tools themselves" ) if not (self.mom_input_dir / "bathymetry.nc").exists(): - print("No bathymetry file! Need to run setup_bathymetry method first") + rm6_logger.error("No bathymetry file! Need to run setup_bathymetry method first") return for p in self.mom_input_dir.glob("mask_table*"): p.unlink() - print( + rm6_logger.info( "OUTPUT FROM MAKE SOLO MOSAIC:", subprocess.run( str(self.toolpath_dir / "make_solo_mosaic/make_solo_mosaic") @@ -2229,7 +2231,7 @@ def run_FRE_tools(self, layout=None): sep="\n\n", ) - print( + rm6_logger.info( "OUTPUT FROM QUICK MOSAIC:", subprocess.run( str(self.toolpath_dir / "make_quick_mosaic/make_quick_mosaic") @@ -2249,7 +2251,7 @@ def configure_cpu_layout(self, layout): ``layout`` tuple of processing units. """ - print( + rm6_logger.info( "OUTPUT FROM CHECK MASK:\n\n", subprocess.run( str(self.toolpath_dir / "check_mask/check_mask") @@ -2291,8 +2293,8 @@ def setup_run_directory( ) if not premade_rundir_path.exists(): - print("Could not find premade run directories at ", premade_rundir_path) - print( + rm6_logger.info("Could not find premade run directories at ", premade_rundir_path) + rm6_logger.info( "Perhaps the package was imported directly rather than installed with conda. Checking if this is the case... " ) @@ -2307,7 +2309,7 @@ def setup_run_directory( + "There may be an issue with package installation. Check that the `premade_run_directory` folder is present in one of these two locations" ) else: - print("Found run files. Continuing...") + rm6_logger.info("Found run files. Continuing...") # Define the locations of the directories we'll copy files across from. Base contains most of the files, and overwrite replaces files in the base directory. base_run_dir = Path(premade_rundir_path / "common_files") @@ -2379,7 +2381,7 @@ def setup_run_directory( mask_table = None for p in self.mom_input_dir.glob("mask_table.*"): if mask_table != None: - print( + rm6_logger.warning( f"WARNING: Multiple mask tables found. Defaulting to {mask_table}. If this is not what you want, remove it from the run directory and try again." ) break @@ -2393,7 +2395,7 @@ def setup_run_directory( y, ) # This is a local variable keeping track of the layout as read from the mask table. Not to be confused with self.layout which is unchanged and may differ. - print( + rm6_logger.info( f"Mask table {p.name} read. Using this to infer the cpu layout {layout}, total masked out cells {masked}, and total number of CPUs {ncpus}." ) # Case where there's no mask table. Either because user hasn't run FRE tools, or because the domain is mostly water. @@ -2403,11 +2405,11 @@ def setup_run_directory( # in case the user accidentally loads in the wrong mask table. layout = self.layout if layout == None: - print( + rm6_logger.warning( "WARNING: No mask table found, and the cpu layout has not been set. \nAt least one of these is requiret to set up the experiment if you're running MOM6 standalone with the FMS coupler. \nIf you're running within CESM, ignore this message." ) else: - print( + rm6_logger.warning( f"No mask table found, but the cpu layout has been set to {self.layout} This suggests the domain is mostly water, so there are " + "no `non compute` cells that are entirely land. If this doesn't seem right, " + "ensure you've already run the `FRE_tools` method which sets up the cpu mask table. Keep an eye on any errors that might print while" @@ -2450,7 +2452,7 @@ def setup_run_directory( # OBC Adjustments # Delete MOM_input OBC stuff that is indexed because we want them only in MOM_override. - print( + rm6_logger.info( "Deleting indexed OBC keys from MOM_input_dict in case we have a different number of segments" ) keys_to_delete = [key for key in MOM_input_dict if "_SEGMENT_00" in key] @@ -2550,7 +2552,7 @@ def setup_run_directory( if not using_payu and os.path.exists(f"{self.mom_run_dir}/config.yaml"): os.remove(f"{self.mom_run_dir}/config.yaml") elif ncpus == None: - print( + rm6_logger.warning( "WARNING: Layout has not been set! Cannot create payu configuration file. Run the FRE_tools first." ) else: @@ -2628,7 +2630,7 @@ def change_MOM_parameter( if param_name in MOM_override_dict.keys(): original_val = MOM_override_dict[param_name]["value"] - print( + rm6_logger.info( "This parameter {} is being replaced from {} to {} in MOM_override".format( param_name, original_val, param_value ) @@ -2640,10 +2642,10 @@ def change_MOM_parameter( else: if param_name in MOM_override_dict.keys(): original_val = MOM_override_dict[param_name]["value"] - print("Deleting parameter {} from MOM_override".format(param_name)) + rm6_logger.info("Deleting parameter {} from MOM_override".format(param_name)) del MOM_override_dict[param_name] else: - print( + rm6_logger.info( "Key to be deleted {} was not in MOM_override to begin with.".format( param_name ) @@ -2712,7 +2714,7 @@ def write_MOM_file(self, MOM_file_dict): # As in there wasn't an override before but we want one if MOM_file_dict[var]["override"]: lines[jj] = "#override " + lines[jj] - print("Added override to variable " + var + "!") + rm6_logger.info("Added override to variable " + var + "!") if var in MOM_file_dict.keys() and ( str(MOM_file_dict[var]["value"]) ) != str(original_MOM_file_dict[var]["value"]): @@ -2733,7 +2735,7 @@ def write_MOM_file(self, MOM_file_dict): + "\n" ) - print( + rm6_logger.info( "Changed", var, "from", @@ -2755,7 +2757,7 @@ def write_MOM_file(self, MOM_file_dict): lines.append( f"{key} = {MOM_file_dict[key]['value']} !{MOM_file_dict[key]['comment']}\n" ) - print( + rm6_logger.info( "Added", key, "to", @@ -2777,7 +2779,7 @@ def write_MOM_file(self, MOM_file_dict): for line in lines if not all(word in line for word in search_words) ] - print( + rm6_logger.info( "Removed", key, "in", diff --git a/regional_mom6/regridding.py b/regional_mom6/regridding.py index 7af0e6a9..ef003964 100644 --- a/regional_mom6/regridding.py +++ b/regional_mom6/regridding.py @@ -35,7 +35,7 @@ from .utils import setup_logger -regridding_logger = setup_logger(__name__) +regridding_logger = setup_logger(__name__, set_handler=False) def coords( diff --git a/regional_mom6/rotation.py b/regional_mom6/rotation.py index 9c3900dd..a8151e46 100644 --- a/regional_mom6/rotation.py +++ b/regional_mom6/rotation.py @@ -1,6 +1,6 @@ from .utils import setup_logger - -rotation_logger = setup_logger(__name__) +import logging +rotation_logger = setup_logger(__name__, set_handler = False) # An Enum is like a dropdown selection for a menu, it essentially limits the type of input parameters. It comes with additional complexity, which of course is always a challenge. from enum import Enum import xarray as xr diff --git a/regional_mom6/utils.py b/regional_mom6/utils.py index d499430e..966bf966 100644 --- a/regional_mom6/utils.py +++ b/regional_mom6/utils.py @@ -299,20 +299,20 @@ def ep2ap(SEMA, ECC, INC, PHA): return ua, va, up, vp -def setup_logger(name: str) -> logging.Logger: +def setup_logger(name: str, set_handler = False, log_level = logging.INFO) -> logging.Logger: """ Setup general config for a logger. """ logger = logging.getLogger(name) - logger.setLevel(logging.INFO) - if not logger.hasHandlers(): + logger.setLevel(log_level) + if set_handler and not logger.hasHandlers(): # Create a handler to print to stdout (Jupyter captures stdout) handler = logging.StreamHandler(sys.stdout) - handler.setLevel(logging.INFO) + handler.setLevel(log_level) # Create a formatter (optional) formatter = logging.Formatter( - "%(asctime)s - %(name)s.%(funcName)s - %(levelname)s - %(message)s" + "%(name)s.%(funcName)s:%(levelname)s:%(message)s" ) handler.setFormatter(formatter) From 8360a2765a6fdee68b85438e32759c1266ec9967 Mon Sep 17 00:00:00 2001 From: manishvenu Date: Thu, 9 Jan 2025 10:38:45 -0700 Subject: [PATCH 78/87] Formatting --- regional_mom6/regional_mom6.py | 13 ++++++++++--- regional_mom6/rotation.py | 3 ++- regional_mom6/utils.py | 8 ++++---- 3 files changed, 16 insertions(+), 8 deletions(-) diff --git a/regional_mom6/regional_mom6.py b/regional_mom6/regional_mom6.py index 0d295033..bef03274 100644 --- a/regional_mom6/regional_mom6.py +++ b/regional_mom6/regional_mom6.py @@ -24,6 +24,7 @@ from . import rotation as rot from .utils import quadrilateral_areas, ap2ep, ep2ap, is_rectilinear_hgrid, setup_logger import logging + rm6_logger = setup_logger(__name__, set_handler=True) warnings.filterwarnings("ignore") @@ -2214,7 +2215,9 @@ def run_FRE_tools(self, layout=None): "Running GFDL's FRE Tools. The following information is all printed by the FRE tools themselves" ) if not (self.mom_input_dir / "bathymetry.nc").exists(): - rm6_logger.error("No bathymetry file! Need to run setup_bathymetry method first") + rm6_logger.error( + "No bathymetry file! Need to run setup_bathymetry method first" + ) return for p in self.mom_input_dir.glob("mask_table*"): @@ -2293,7 +2296,9 @@ def setup_run_directory( ) if not premade_rundir_path.exists(): - rm6_logger.info("Could not find premade run directories at ", premade_rundir_path) + rm6_logger.info( + "Could not find premade run directories at ", premade_rundir_path + ) rm6_logger.info( "Perhaps the package was imported directly rather than installed with conda. Checking if this is the case... " ) @@ -2642,7 +2647,9 @@ def change_MOM_parameter( else: if param_name in MOM_override_dict.keys(): original_val = MOM_override_dict[param_name]["value"] - rm6_logger.info("Deleting parameter {} from MOM_override".format(param_name)) + rm6_logger.info( + "Deleting parameter {} from MOM_override".format(param_name) + ) del MOM_override_dict[param_name] else: rm6_logger.info( diff --git a/regional_mom6/rotation.py b/regional_mom6/rotation.py index a8151e46..979d0cd6 100644 --- a/regional_mom6/rotation.py +++ b/regional_mom6/rotation.py @@ -1,6 +1,7 @@ from .utils import setup_logger import logging -rotation_logger = setup_logger(__name__, set_handler = False) + +rotation_logger = setup_logger(__name__, set_handler=False) # An Enum is like a dropdown selection for a menu, it essentially limits the type of input parameters. It comes with additional complexity, which of course is always a challenge. from enum import Enum import xarray as xr diff --git a/regional_mom6/utils.py b/regional_mom6/utils.py index 966bf966..f4602f04 100644 --- a/regional_mom6/utils.py +++ b/regional_mom6/utils.py @@ -299,7 +299,9 @@ def ep2ap(SEMA, ECC, INC, PHA): return ua, va, up, vp -def setup_logger(name: str, set_handler = False, log_level = logging.INFO) -> logging.Logger: +def setup_logger( + name: str, set_handler=False, log_level=logging.INFO +) -> logging.Logger: """ Setup general config for a logger. """ @@ -311,9 +313,7 @@ def setup_logger(name: str, set_handler = False, log_level = logging.INFO) -> lo handler.setLevel(log_level) # Create a formatter (optional) - formatter = logging.Formatter( - "%(name)s.%(funcName)s:%(levelname)s:%(message)s" - ) + formatter = logging.Formatter("%(name)s.%(funcName)s:%(levelname)s:%(message)s") handler.setFormatter(formatter) # Add the handler to the logger From ba38e9d02cadf0514c4b2c776ef37fd6f47aaa5f Mon Sep 17 00:00:00 2001 From: manishvenu Date: Thu, 9 Jan 2025 11:12:41 -0700 Subject: [PATCH 79/87] Fix logging bug --- regional_mom6/regional_mom6.py | 31 +++++++++++++++---------------- 1 file changed, 15 insertions(+), 16 deletions(-) diff --git a/regional_mom6/regional_mom6.py b/regional_mom6/regional_mom6.py index bef03274..7c93c37c 100644 --- a/regional_mom6/regional_mom6.py +++ b/regional_mom6/regional_mom6.py @@ -1342,7 +1342,7 @@ def setup_initial_condition( ## Regrid all fields horizontally. - rm6_logger.info("Regridding Velocities... ", end="") + rm6_logger.info("Regridding Velocities... ") regridded_u = regridder_u(ic_raw_u) regridded_v = regridder_v(ic_raw_v) if rotational_method == rot.RotationMethod.GIVEN_ANGLE: @@ -1385,7 +1385,7 @@ def setup_initial_condition( ] ) - rm6_logger.info("Done.\nRegridding Tracers... ", end="") + rm6_logger.info("Done.\nRegridding Tracers... ") tracers_out = ( xr.merge( @@ -1409,7 +1409,7 @@ def setup_initial_condition( } ) - rm6_logger.info("Done.\nRegridding Free surface... ", end="") + rm6_logger.info("Done.\nRegridding Free surface... ") eta_out = ( regridder_t(ic_raw_eta) @@ -1449,7 +1449,7 @@ def setup_initial_condition( tracers_out = tracers_out.interp({"zl": self.vgrid.zl.values}) vel_out = vel_out.interp({"zl": self.vgrid.zl.values}) - rm6_logger.info("Saving outputs... ", end="") + rm6_logger.info("Saving outputs... ") vel_out.fillna(0).to_netcdf( self.mom_input_dir / "init_vel.nc", @@ -1678,7 +1678,7 @@ def setup_single_boundary( rotational_method (Optional[str]): Method to use for rotating the boundary velocities. Default is 'GIVEN_ANGLE'. """ - rm6_logger.info("Processing {} boundary...".format(orientation), end="") + rm6_logger.info("Processing {} boundary...".format(orientation)) if not path_to_bc.exists(): raise FileNotFoundError( f"Boundary file not found at {path_to_bc}. Please ensure that the files are named in the format `east_unprocessed.nc`." @@ -1789,7 +1789,7 @@ def setup_boundary_tides( ) # Initialize or find boundary segment for b in self.boundaries: - rm6_logger.info("Processing {} boundary...".format(b), end="") + rm6_logger.info("Processing {} boundary...".format(b)) # If the GLORYS ocean_state has already created segments, we don't create them again. seg = segment( @@ -2028,8 +2028,7 @@ def tidy_bathymetry( ## reopen bathymetry to modify rm6_logger.info( - "Tidy bathymetry: Reading in regridded bathymetry to fix up metadata...", - end="", + "Tidy bathymetry: Reading in regridded bathymetry to fix up metadata..." ) if read_bathy_from_file := bathymetry is None: bathymetry = xr.open_dataset( @@ -2055,7 +2054,7 @@ def tidy_bathymetry( land_mask = np.abs(ocean_mask - 1) ## REMOVE INLAND LAKES - rm6_logger.info("done. Filling in inland lakes and channels... ", end="") + rm6_logger.info("done. Filling in inland lakes and channels... ") changed = True ## keeps track of whether solution has converged or not @@ -2743,13 +2742,13 @@ def write_MOM_file(self, MOM_file_dict): ) rm6_logger.info( - "Changed", - var, - "from", - original_MOM_file_dict[var], - "to", - MOM_file_dict[var], - "in {}!".format(MOM_file_dict["filename"]), + "Changed " + + str(var) + + " from " + + str(original_MOM_file_dict[var]["value"]) + + " to " + + str(MOM_file_dict[var]["value"]) + + "in {}!".format(str(MOM_file_dict["filename"])) ) # Add new fields From 3d5dbeb8cb060c76bd1535f1a2a14e9d5071c5fb Mon Sep 17 00:00:00 2001 From: manishvenu Date: Thu, 9 Jan 2025 12:53:26 -0700 Subject: [PATCH 80/87] Revert RM6 Logging --- regional_mom6/regional_mom6.py | 112 ++++++++++++++++----------------- 1 file changed, 55 insertions(+), 57 deletions(-) diff --git a/regional_mom6/regional_mom6.py b/regional_mom6/regional_mom6.py index 7c93c37c..5a632816 100644 --- a/regional_mom6/regional_mom6.py +++ b/regional_mom6/regional_mom6.py @@ -22,10 +22,8 @@ import copy from . import regridding as rgd from . import rotation as rot -from .utils import quadrilateral_areas, ap2ep, ep2ap, is_rectilinear_hgrid, setup_logger -import logging +from .utils import quadrilateral_areas, ap2ep, ep2ap, is_rectilinear_hgrid -rm6_logger = setup_logger(__name__, set_handler=True) warnings.filterwarnings("ignore") @@ -100,14 +98,14 @@ def create_experiment_from_config( Returns: experiment: An experiment object with the fields from the config loaded in. """ - rm6_logger.info("Reading from config file....") + print("Reading from config file....") with open(config_file_path, "r") as f: config_dict = json.load(f) - rm6_logger.info("Creating Empty Experiment Object....") + print("Creating Empty Experiment Object....") expt = experiment.create_empty() - rm6_logger.info("Setting Default Variables.....") + print("Setting Default Variables.....") expt.expt_name = config_dict["expt_name"] try: expt.longitude_extent = tuple(config_dict["longitude_extent"]) @@ -148,13 +146,13 @@ def create_experiment_from_config( expt.boundaries = config_dict["boundaries"] if create_hgrid_and_vgrid: - rm6_logger.info("Creating hgrid and vgrid....") + print("Creating hgrid and vgrid....") expt.hgrid = expt._make_hgrid() expt.vgrid = expt._make_vgrid() else: - rm6_logger.info("Skipping hgrid and vgrid creation....") + print("Skipping hgrid and vgrid creation....") - rm6_logger.info("Done!") + print("Done!") return expt @@ -716,7 +714,7 @@ def __init__( float(self.hgrid.y.max()), ) except: - rm6_logger.error( + print( "Error while reading in existing horizontal grid!\n\n" + f"Make sure `hgrid.nc`exists in {self.mom_input_dir} directory." ) @@ -740,7 +738,7 @@ def __init__( vgrid_from_file = xr.open_dataset(vgrid_path) except: - rm6_logger.error( + print( "Error while reading in existing vertical coordinates!\n\n" + f"Make sure `vcoord.nc`exists in {self.mom_input_dir} directory." ) @@ -782,7 +780,7 @@ def __getattr__(self, name): decode_times=False, ) else: - rm6_logger.error( + print( f"bathymetry.nc file not found! Make sure you've successfully run the setup_bathmetry method, or copied your own bathymetry.nc file into {self.mom_input_dir}." ) return None @@ -794,7 +792,7 @@ def __getattr__(self, name): decode_times=False, ) else: - rm6_logger.error( + print( f"init_vel.nc file not found! Make sure you've successfully run the setup_initial_condition method, or copied your own init_vel.nc file into {self.mom_input_dir}." ) return @@ -807,7 +805,7 @@ def __getattr__(self, name): decode_times=False, ) else: - rm6_logger.error( + print( f"init_tracers.nc file not found! Make sure you've successfully run the setup_initial_condition method, or copied your own init_tracers.nc file into {self.mom_input_dir}." ) return @@ -820,7 +818,7 @@ def __getattr__(self, name): decode_cf=False, ) except: - rm6_logger.error( + print( f"{name} files not found! Make sure you've successfully run the setup_ocean_state_boundaries method, or copied your own segment files file into {self.mom_input_dir}." ) return None @@ -953,7 +951,7 @@ def _make_vgrid(self, thicknesses=None): ## Check whether the minimum depth is less than the first three layers if self.minimum_depth < zi[2]: - rm6_logger.warning( + print( f"Warning: Minimum depth of {self.minimum_depth}m is less than the depth of the third interface ({zi[2]}m)!\n" + "This means that some areas may only have one or two layers between the surface and sea floor. \n" + "For increased stability, consider increasing the minimum depth, or adjusting the vertical coordinate to add more layers near the surface." @@ -1092,7 +1090,7 @@ def write_config_file(self, path=None, export=True, quiet=False): Dict: A dictionary containing the configuration information. """ if not quiet: - rm6_logger.info("Writing Config File.....") + print("Writing Config File.....") try: date_range = [ self.date_range[0].strftime("%Y-%m-%d %H:%M:%S"), @@ -1129,7 +1127,7 @@ def write_config_file(self, path=None, export=True, quiet=False): indent=4, ) if not quiet: - rm6_logger.info("Done.") + print("Done.") return config_dict def setup_initial_condition( @@ -1338,11 +1336,11 @@ def setup_initial_condition( # vgrid = rgd.get_hgrid_arakawa_c_points(self.hgrid, "v").rename({"vlon": "lon", "vlat": "lat"}).set_coords(["lat", "lon"]) ## Construct the cell centre grid for tracers (xh, yh). - rm6_logger.info("Setting up Initial Conditions") + print("Setting up Initial Conditions") ## Regrid all fields horizontally. - rm6_logger.info("Regridding Velocities... ") + print("Regridding Velocities... ", end="") regridded_u = regridder_u(ic_raw_u) regridded_v = regridder_v(ic_raw_v) if rotational_method == rot.RotationMethod.GIVEN_ANGLE: @@ -1385,7 +1383,7 @@ def setup_initial_condition( ] ) - rm6_logger.info("Done.\nRegridding Tracers... ") + print("Done.\nRegridding Tracers... ", end="") tracers_out = ( xr.merge( @@ -1409,7 +1407,7 @@ def setup_initial_condition( } ) - rm6_logger.info("Done.\nRegridding Free surface... ") + print("Done.\nRegridding Free surface... ", end="") eta_out = ( regridder_t(ic_raw_eta) @@ -1417,7 +1415,7 @@ def setup_initial_condition( .rename("eta_t") .transpose("ny", "nx") ) ## eta_t is the name set in MOM_input by default - rm6_logger.info("Done.") + print("Done.") ## Return attributes to arrays @@ -1449,7 +1447,7 @@ def setup_initial_condition( tracers_out = tracers_out.interp({"zl": self.vgrid.zl.values}) vel_out = vel_out.interp({"zl": self.vgrid.zl.values}) - rm6_logger.info("Saving outputs... ") + print("Saving outputs... ", end="") vel_out.fillna(0).to_netcdf( self.mom_input_dir / "init_vel.nc", @@ -1485,7 +1483,7 @@ def setup_initial_condition( self.ic_tracers = tracers_out self.ic_vels = vel_out - rm6_logger.info("done setting up initial condition.") + print("done setting up initial condition.") return @@ -1618,7 +1616,7 @@ def setup_ocean_state_boundaries( ) if len(self.boundaries) < 4: - rm6_logger.warning( + print( "NOTE: the 'setup_run_directories' method does understand the less than four boundaries but be careful. Please check the MOM_input/override file carefully to reflect the number of boundaries you have, and their orientations. You should be able to find the relevant section in the MOM_input/override file by searching for 'segment_'. Ensure that the segment names match those in your inputdir/forcing folder" ) @@ -1678,7 +1676,7 @@ def setup_single_boundary( rotational_method (Optional[str]): Method to use for rotating the boundary velocities. Default is 'GIVEN_ANGLE'. """ - rm6_logger.info("Processing {} boundary...".format(orientation)) + print("Processing {} boundary...".format(orientation), end="") if not path_to_bc.exists(): raise FileNotFoundError( f"Boundary file not found at {path_to_bc}. Please ensure that the files are named in the format `east_unprocessed.nc`." @@ -1702,7 +1700,7 @@ def setup_single_boundary( rotational_method=rotational_method ) - rm6_logger.info("Done.") + print("Done.") return def setup_boundary_tides( @@ -1789,7 +1787,7 @@ def setup_boundary_tides( ) # Initialize or find boundary segment for b in self.boundaries: - rm6_logger.info("Processing {} boundary...".format(b)) + print("Processing {} boundary...".format(b), end="") # If the GLORYS ocean_state has already created segments, we don't create them again. seg = segment( @@ -1810,7 +1808,7 @@ def setup_boundary_tides( seg.regrid_tides( tpxo_v, tpxo_u, tpxo_h, times, rotational_method=rotational_method ) - rm6_logger.info("Done") + print("Done") def setup_bathymetry( self, @@ -1994,7 +1992,7 @@ def setup_bathymetry( ) self.tidy_bathymetry(fill_channels, positive_down, bathymetry=bathymetry) - rm6_logger.info("setup bathymetry has finished successfully.") + print("setup bathymetry has finished successfully.") return bathymetry @@ -2027,8 +2025,8 @@ def tidy_bathymetry( """ ## reopen bathymetry to modify - rm6_logger.info( - "Tidy bathymetry: Reading in regridded bathymetry to fix up metadata..." + print( + "Tidy bathymetry: Reading in regridded bathymetry to fix up metadata...", end="" ) if read_bathy_from_file := bathymetry is None: bathymetry = xr.open_dataset( @@ -2054,7 +2052,7 @@ def tidy_bathymetry( land_mask = np.abs(ocean_mask - 1) ## REMOVE INLAND LAKES - rm6_logger.info("done. Filling in inland lakes and channels... ") + print("done. Filling in inland lakes and channels... ", end="") changed = True ## keeps track of whether solution has converged or not @@ -2202,7 +2200,7 @@ def tidy_bathymetry( encoding={"depth": {"_FillValue": None}}, ) - rm6_logger.info("done.") + print("done.") return def run_FRE_tools(self, layout=None): @@ -2210,11 +2208,11 @@ def run_FRE_tools(self, layout=None): User provides processor ``layout`` tuple of processing units. """ - rm6_logger.info( + print( "Running GFDL's FRE Tools. The following information is all printed by the FRE tools themselves" ) if not (self.mom_input_dir / "bathymetry.nc").exists(): - rm6_logger.error( + print( "No bathymetry file! Need to run setup_bathymetry method first" ) return @@ -2222,7 +2220,7 @@ def run_FRE_tools(self, layout=None): for p in self.mom_input_dir.glob("mask_table*"): p.unlink() - rm6_logger.info( + print( "OUTPUT FROM MAKE SOLO MOSAIC:", subprocess.run( str(self.toolpath_dir / "make_solo_mosaic/make_solo_mosaic") @@ -2233,7 +2231,7 @@ def run_FRE_tools(self, layout=None): sep="\n\n", ) - rm6_logger.info( + print( "OUTPUT FROM QUICK MOSAIC:", subprocess.run( str(self.toolpath_dir / "make_quick_mosaic/make_quick_mosaic") @@ -2253,7 +2251,7 @@ def configure_cpu_layout(self, layout): ``layout`` tuple of processing units. """ - rm6_logger.info( + print( "OUTPUT FROM CHECK MASK:\n\n", subprocess.run( str(self.toolpath_dir / "check_mask/check_mask") @@ -2295,11 +2293,11 @@ def setup_run_directory( ) if not premade_rundir_path.exists(): - rm6_logger.info( + print( "Could not find premade run directories at ", premade_rundir_path ) - rm6_logger.info( - "Perhaps the package was imported directly rather than installed with conda. Checking if this is the case... " + print( + "Perhaps the package was imported directly rather than installed with conda. Checking if this is the case... ", end="" ) premade_rundir_path = Path( @@ -2313,7 +2311,7 @@ def setup_run_directory( + "There may be an issue with package installation. Check that the `premade_run_directory` folder is present in one of these two locations" ) else: - rm6_logger.info("Found run files. Continuing...") + print("Found run files. Continuing...") # Define the locations of the directories we'll copy files across from. Base contains most of the files, and overwrite replaces files in the base directory. base_run_dir = Path(premade_rundir_path / "common_files") @@ -2385,7 +2383,7 @@ def setup_run_directory( mask_table = None for p in self.mom_input_dir.glob("mask_table.*"): if mask_table != None: - rm6_logger.warning( + print( f"WARNING: Multiple mask tables found. Defaulting to {mask_table}. If this is not what you want, remove it from the run directory and try again." ) break @@ -2399,7 +2397,7 @@ def setup_run_directory( y, ) # This is a local variable keeping track of the layout as read from the mask table. Not to be confused with self.layout which is unchanged and may differ. - rm6_logger.info( + print( f"Mask table {p.name} read. Using this to infer the cpu layout {layout}, total masked out cells {masked}, and total number of CPUs {ncpus}." ) # Case where there's no mask table. Either because user hasn't run FRE tools, or because the domain is mostly water. @@ -2409,11 +2407,11 @@ def setup_run_directory( # in case the user accidentally loads in the wrong mask table. layout = self.layout if layout == None: - rm6_logger.warning( + print( "WARNING: No mask table found, and the cpu layout has not been set. \nAt least one of these is requiret to set up the experiment if you're running MOM6 standalone with the FMS coupler. \nIf you're running within CESM, ignore this message." ) else: - rm6_logger.warning( + print( f"No mask table found, but the cpu layout has been set to {self.layout} This suggests the domain is mostly water, so there are " + "no `non compute` cells that are entirely land. If this doesn't seem right, " + "ensure you've already run the `FRE_tools` method which sets up the cpu mask table. Keep an eye on any errors that might print while" @@ -2456,7 +2454,7 @@ def setup_run_directory( # OBC Adjustments # Delete MOM_input OBC stuff that is indexed because we want them only in MOM_override. - rm6_logger.info( + print( "Deleting indexed OBC keys from MOM_input_dict in case we have a different number of segments" ) keys_to_delete = [key for key in MOM_input_dict if "_SEGMENT_00" in key] @@ -2556,7 +2554,7 @@ def setup_run_directory( if not using_payu and os.path.exists(f"{self.mom_run_dir}/config.yaml"): os.remove(f"{self.mom_run_dir}/config.yaml") elif ncpus == None: - rm6_logger.warning( + print( "WARNING: Layout has not been set! Cannot create payu configuration file. Run the FRE_tools first." ) else: @@ -2634,7 +2632,7 @@ def change_MOM_parameter( if param_name in MOM_override_dict.keys(): original_val = MOM_override_dict[param_name]["value"] - rm6_logger.info( + print( "This parameter {} is being replaced from {} to {} in MOM_override".format( param_name, original_val, param_value ) @@ -2646,12 +2644,12 @@ def change_MOM_parameter( else: if param_name in MOM_override_dict.keys(): original_val = MOM_override_dict[param_name]["value"] - rm6_logger.info( + print( "Deleting parameter {} from MOM_override".format(param_name) ) del MOM_override_dict[param_name] else: - rm6_logger.info( + print( "Key to be deleted {} was not in MOM_override to begin with.".format( param_name ) @@ -2720,7 +2718,7 @@ def write_MOM_file(self, MOM_file_dict): # As in there wasn't an override before but we want one if MOM_file_dict[var]["override"]: lines[jj] = "#override " + lines[jj] - rm6_logger.info("Added override to variable " + var + "!") + print("Added override to variable " + var + "!") if var in MOM_file_dict.keys() and ( str(MOM_file_dict[var]["value"]) ) != str(original_MOM_file_dict[var]["value"]): @@ -2741,7 +2739,7 @@ def write_MOM_file(self, MOM_file_dict): + "\n" ) - rm6_logger.info( + print( "Changed " + str(var) + " from " @@ -2763,7 +2761,7 @@ def write_MOM_file(self, MOM_file_dict): lines.append( f"{key} = {MOM_file_dict[key]['value']} !{MOM_file_dict[key]['comment']}\n" ) - rm6_logger.info( + print( "Added", key, "to", @@ -2785,7 +2783,7 @@ def write_MOM_file(self, MOM_file_dict): for line in lines if not all(word in line for word in search_words) ] - rm6_logger.info( + print( "Removed", key, "in", From 29318a05fb11acc74d30bca39f29cd05598334bf Mon Sep 17 00:00:00 2001 From: manishvenu Date: Thu, 9 Jan 2025 13:01:05 -0700 Subject: [PATCH 81/87] Formatting --- regional_mom6/regional_mom6.py | 18 +++++++----------- 1 file changed, 7 insertions(+), 11 deletions(-) diff --git a/regional_mom6/regional_mom6.py b/regional_mom6/regional_mom6.py index 5a632816..1a1eca82 100644 --- a/regional_mom6/regional_mom6.py +++ b/regional_mom6/regional_mom6.py @@ -2026,7 +2026,8 @@ def tidy_bathymetry( ## reopen bathymetry to modify print( - "Tidy bathymetry: Reading in regridded bathymetry to fix up metadata...", end="" + "Tidy bathymetry: Reading in regridded bathymetry to fix up metadata...", + end="", ) if read_bathy_from_file := bathymetry is None: bathymetry = xr.open_dataset( @@ -2212,9 +2213,7 @@ def run_FRE_tools(self, layout=None): "Running GFDL's FRE Tools. The following information is all printed by the FRE tools themselves" ) if not (self.mom_input_dir / "bathymetry.nc").exists(): - print( - "No bathymetry file! Need to run setup_bathymetry method first" - ) + print("No bathymetry file! Need to run setup_bathymetry method first") return for p in self.mom_input_dir.glob("mask_table*"): @@ -2293,11 +2292,10 @@ def setup_run_directory( ) if not premade_rundir_path.exists(): + print("Could not find premade run directories at ", premade_rundir_path) print( - "Could not find premade run directories at ", premade_rundir_path - ) - print( - "Perhaps the package was imported directly rather than installed with conda. Checking if this is the case... ", end="" + "Perhaps the package was imported directly rather than installed with conda. Checking if this is the case... ", + end="", ) premade_rundir_path = Path( @@ -2644,9 +2642,7 @@ def change_MOM_parameter( else: if param_name in MOM_override_dict.keys(): original_val = MOM_override_dict[param_name]["value"] - print( - "Deleting parameter {} from MOM_override".format(param_name) - ) + print("Deleting parameter {} from MOM_override".format(param_name)) del MOM_override_dict[param_name] else: print( From f4dfef77dfe574314e67b77f05883150d33b7e88 Mon Sep 17 00:00:00 2001 From: manishvenu Date: Fri, 10 Jan 2025 13:59:29 -0700 Subject: [PATCH 82/87] Alper Review Comments Pt1 --- regional_mom6/regional_mom6.py | 111 +++++++++++++-------------------- regional_mom6/utils.py | 67 +++++++++++++++++--- 2 files changed, 99 insertions(+), 79 deletions(-) diff --git a/regional_mom6/regional_mom6.py b/regional_mom6/regional_mom6.py index 1a1eca82..f220d2cc 100644 --- a/regional_mom6/regional_mom6.py +++ b/regional_mom6/regional_mom6.py @@ -20,9 +20,15 @@ from collections import defaultdict import json import copy -from . import regridding as rgd -from . import rotation as rot -from .utils import quadrilateral_areas, ap2ep, ep2ap, is_rectilinear_hgrid +from regional_mom6 import regridding as rgd +from regional_mom6 import rotation as rot +from regional_mom6.utils import ( + quadrilateral_areas, + ap2ep, + ep2ap, + is_rectilinear_hgrid, + rotate, +) warnings.filterwarnings("ignore") @@ -934,6 +940,11 @@ def _make_vgrid(self, thicknesses=None): of largest to smallest layer thickness (``layer_thickness_ratio``) and the total ``depth`` parameters. (All these parameters are specified at the class level.) + + Args: + thicknesses (Optional[np.ndarray]): An array of layer thicknesses. If not provided, + the layer thicknesses are generated using the :func:`~hyperbolictan_thickness_profile` + function. """ if thicknesses is None: @@ -941,6 +952,9 @@ def _make_vgrid(self, thicknesses=None): self.number_vertical_layers, self.layer_thickness_ratio, self.depth ) + if not isinstance(thicknesses, np.ndarray): + raise ValueError("thicknesses must be a numpy array") + zi = np.cumsum(thicknesses) zi = np.insert(zi, 0, 0.0) # add zi = 0.0 as first interface @@ -1311,9 +1325,9 @@ def setup_initial_condition( .ffill("lat") .bfill("lat") ) - renamed_hgrid = self.hgrid # This is not a deep copy - renamed_hgrid["lon"] = renamed_hgrid["x"] - renamed_hgrid["lat"] = renamed_hgrid["y"] + + self.hgrid["lon"] = self.hgrid["x"] + self.hgrid["lat"] = self.hgrid["y"] tgrid = ( rgd.get_hgrid_arakawa_c_points(self.hgrid, "t") .rename({"tlon": "lon", "tlat": "lat", "nxp": "nx", "nyp": "ny"}) @@ -1323,10 +1337,10 @@ def setup_initial_condition( ## Make our three horizontal regridders regridder_u = rgd.create_regridder( - ic_raw_u, renamed_hgrid, locstream_out=False, method="bilinear" + ic_raw_u, self.hgrid, locstream_out=False, method="bilinear" ) regridder_v = rgd.create_regridder( - ic_raw_v, renamed_hgrid, locstream_out=False, method="bilinear" + ic_raw_v, self.hgrid, locstream_out=False, method="bilinear" ) regridder_t = rgd.create_regridder( ic_raw_tracers, tgrid, locstream_out=False, method="bilinear" @@ -1344,8 +1358,7 @@ def setup_initial_condition( regridded_u = regridder_u(ic_raw_u) regridded_v = regridder_v(ic_raw_v) if rotational_method == rot.RotationMethod.GIVEN_ANGLE: - rotated_u, rotated_v = segment.rotate( - None, + rotated_u, rotated_v = rotate( regridded_u, regridded_v, radian_angle=np.radians(self.hgrid.angle_dx.values), @@ -1354,7 +1367,7 @@ def setup_initial_condition( self.hgrid["angle_dx_rm6"] = ( rot.initialize_grid_rotation_angles_using_expanded_hgrid(self.hgrid) ) - rotated_u, rotated_v = segment.rotate( + rotated_u, rotated_v = rotate( regridded_u, regridded_v, radian_angle=np.radians(self.hgrid.angle_dx_rm6.values), @@ -1601,13 +1614,13 @@ def setup_ocean_state_boundaries( Default is `["south", "north", "west", "east"]`. arakawa_grid (Optional[str]): Arakawa grid staggering type of the boundary forcing. Either ``'A'`` (default), ``'B'``, or ``'C'``. - boundary_type (Optional[str]): Type of box around region. Currently, only ``'rectangular'`` is supported. + boundary_type (Optional[str]): Type of box around region. Currently, only ``'rectangular'`` or ``'curvilinear'`` is supported. bathymetry_path (Optional[str]): Path to the bathymetry file. Default is None, in which case the BC is not masked. rotational_method (Optional[str]): Method to use for rotating the boundary velocities. Default is 'GIVEN_ANGLE'. """ - if boundary_type != "rectangular": + if not (boundary_type == "rectangular" or boundary_type == "curvilinear"): raise ValueError( - "Only rectangular boundaries are supported by this method. To set up more complex boundary shapes you can manually call the 'simple_boundary' method for each boundary." + "Only rectangular or curvilinear boundaries are supported by this method. To set up more complex boundary shapes you can manually call the 'simple_boundary' method for each boundary." ) for i in self.boundaries: if i not in ["south", "north", "west", "east"]: @@ -1650,7 +1663,6 @@ def setup_single_boundary( orientation, segment_number, arakawa_grid="A", - boundary_type="simple", bathymetry_path=None, rotational_method=rot.RotationMethod.GIVEN_ANGLE, ): @@ -1671,18 +1683,17 @@ def setup_single_boundary( the ``MOM_input``. arakawa_grid (Optional[str]): Arakawa grid staggering type of the boundary forcing. Either ``'A'`` (default), ``'B'``, or ``'C'``. - boundary_type (Optional[str]): Type of boundary. Currently, only ``'simple'`` is supported. Here 'simple' refers to boundaries that are parallel to lines of constant longitude or latitude. bathymetry_path (Optional[str]): Path to the bathymetry file. Default is None, in which case the BC is not masked rotational_method (Optional[str]): Method to use for rotating the boundary velocities. Default is 'GIVEN_ANGLE'. """ - print("Processing {} boundary...".format(orientation), end="") + print( + "Processing {} boundary velocity & tracers...".format(orientation), end="" + ) if not path_to_bc.exists(): raise FileNotFoundError( f"Boundary file not found at {path_to_bc}. Please ensure that the files are named in the format `east_unprocessed.nc`." ) - if boundary_type != "simple": - raise ValueError("Only simple boundaries are supported by this method.") self.segments[orientation] = segment( hgrid=self.hgrid, bathymetry_path=bathymetry_path, @@ -1708,7 +1719,7 @@ def setup_boundary_tides( tpxo_elevation_filepath, tpxo_velocity_filepath, tidal_constituents="read_from_expt_init", - boundary_type="rectangle", + boundary_type="rectangular", bathymetry_path=None, rotational_method=rot.RotationMethod.GIVEN_ANGLE, ): @@ -1717,9 +1728,10 @@ def setup_boundary_tides( Args: path_to_td (str): Path to boundary tidal file. - tidal_filename: Name of the tpxo product that's used in the tidal_filename. Should be h_tidal_filename, u_tidal_filename + tpxo_elevation_filepath: Filepath to the TPXO elevation product. Generally of the form h_tidalversion.nc + tpxo_velocity_filepath: Filepath to the TPXO velocity product. Generally of the form u_tidalversion.nc tidal_constituents: List of tidal constituents to include in the regridding. Default is [0] which is the M2 constituent. - boundary_type (str): Type of boundary. Currently, only rectangle is supported. Here rectangle refers to boundaries that are parallel to lines of constant longitude or latitude. + boundary_type (str): Type of boundary. Currently, only rectangle is supported. Here, rectangle refers to boundaries that are parallel to lines of constant longitude or latitude. Curvilinear is also suported. bathymetry_path (str): Path to the bathymetry file. Default is None, in which case the BC is not masked rotational_method (str): Method to use for rotating the tidal velocities. Default is 'GIVEN_ANGLE'. Returns: @@ -1740,9 +1752,9 @@ def setup_boundary_tides( Type: Python Functions, Source Code Web Address: https://github.com/jsimkins2/nwa25 """ - if boundary_type != "rectangle" and boundary_type != "curvilinear": + if not (boundary_type == "rectangular" or boundary_type == "curvilinear"): raise ValueError( - "Only rectangular boundaries are supported by this method." + "Only rectangular or curvilinear boundaries are supported by this method." ) if tidal_constituents != "read_from_expt_init": self.tidal_constituents = tidal_constituents @@ -2999,45 +3011,6 @@ def __init__( self.segment_name = segment_name self.repeat_year_forcing = repeat_year_forcing - def rotate_complex(self, u, v, radian_angle): - """ - Rotate velocities to grid orientation using complex number math (Same as rotate) - Args: - u (xarray.DataArray): The u-component of the velocity. - v (xarray.DataArray): The v-component of the velocity. - radian_angle (xarray.DataArray): The angle of the grid in RADIANS - - Returns: - Tuple[xarray.DataArray, xarray.DataArray]: The rotated u and v components of the velocity. - """ - - # express velocity in the complex plan - vel = u + v * 1j - # rotate velocity using grid angle theta - vel = vel * np.exp(1j * radian_angle) - - # From here you can easily get the rotated u, v, or the magnitude/direction of the currents: - u = np.real(vel) - v = np.imag(vel) - - return u, v - - def rotate(self, u, v, radian_angle): - """ - Rotate the velocities to the grid orientation. - Args: - u (xarray.DataArray): The u-component of the velocity. - v (xarray.DataArray): The v-component of the velocity. - radian_angle (xarray.DataArray): The angle of the grid in RADIANS - - Returns: - Tuple[xarray.DataArray, xarray.DataArray]: The rotated u and v components of the velocity. - """ - - u_rot = u * np.cos(radian_angle) - v * np.sin(radian_angle) - v_rot = u * np.sin(radian_angle) + v * np.cos(radian_angle) - return u_rot, v_rot - def regrid_velocity_tracers(self, rotational_method=rot.RotationMethod.GIVEN_ANGLE): """ Cut out and interpolate the velocities and tracers @@ -3071,7 +3044,7 @@ def regrid_velocity_tracers(self, rotational_method=rot.RotationMethod.GIVEN_ANG ## Angle Calculation & Rotation if rotational_method == rot.RotationMethod.GIVEN_ANGLE: - rotated_u, rotated_v = self.rotate( + rotated_u, rotated_v = rotate( regridded[self.u], regridded[self.v], radian_angle=np.radians(coords.angle.values), @@ -3092,7 +3065,7 @@ def regrid_velocity_tracers(self, rotational_method=rot.RotationMethod.GIVEN_ANG )["angle"] # Rotate - rotated_u, rotated_v = self.rotate( + rotated_u, rotated_v = rotate( regridded[self.u], regridded[self.v], radian_angle=np.radians(degree_angle.values), @@ -3130,7 +3103,7 @@ def regrid_velocity_tracers(self, rotational_method=rot.RotationMethod.GIVEN_ANG # See explanation of the rotational methods in the A grid section if rotational_method == rot.RotationMethod.GIVEN_ANGLE: - velocities_out["u"], velocities_out["v"] = self.rotate( + velocities_out["u"], velocities_out["v"] = rotate( velocities_out["u"], velocities_out["v"], radian_angle=np.radians(coords.angle.values), @@ -3145,7 +3118,7 @@ def regrid_velocity_tracers(self, rotational_method=rot.RotationMethod.GIVEN_ANG self.segment_name, angle_variable_name="angle_dx_rm6", )["angle"] - velocities_out["u"], velocities_out["v"] = self.rotate( + velocities_out["u"], velocities_out["v"] = rotate( velocities_out["u"], velocities_out["v"], radian_angle=np.radians(degree_angle.values), @@ -3195,7 +3168,7 @@ def regrid_velocity_tracers(self, rotational_method=rot.RotationMethod.GIVEN_ANG # See explanation of the rotational methods in the A grid section if rotational_method == rot.RotationMethod.GIVEN_ANGLE: - rotated_u, rotated_v = self.rotate( + rotated_u, rotated_v = rotate( regridded_u, regridded_v, radian_angle=np.radians(coords.angle.values), @@ -3210,7 +3183,7 @@ def regrid_velocity_tracers(self, rotational_method=rot.RotationMethod.GIVEN_ANG self.segment_name, angle_variable_name="angle_dx_rm6", )["angle"] - rotated_u, rotated_v = self.rotate( + rotated_u, rotated_v = rotate( regridded_u, regridded_v, radian_angle=np.radians(degree_angle.values), diff --git a/regional_mom6/utils.py b/regional_mom6/utils.py index f4602f04..cb477f15 100644 --- a/regional_mom6/utils.py +++ b/regional_mom6/utils.py @@ -321,15 +321,62 @@ def setup_logger( return logger -def is_rectilinear_hgrid(hgrid: xr.Dataset) -> bool: +def rotate_complex(u, v, radian_angle): """ - Check if the hgrid is a rectilinear grid. + Rotate velocities to grid orientation using complex number math (Same as rotate) + Args: + u (xarray.DataArray): The u-component of the velocity. + v (xarray.DataArray): The v-component of the velocity. + radian_angle (xarray.DataArray): The angle of the grid in RADIANS + + Returns: + Tuple[xarray.DataArray, xarray.DataArray]: The rotated u and v components of the velocity. + """ + + # express velocity in the complex plan + vel = u + v * 1j + # rotate velocity using grid angle theta + vel = vel * np.exp(1j * radian_angle) + + # From here you can easily get the rotated u, v, or the magnitude/direction of the currents: + u = np.real(vel) + v = np.imag(vel) + + return u, v + + +def rotate(u, v, radian_angle): + """ + Rotate the velocities to the grid orientation. + Args: + u (xarray.DataArray): The u-component of the velocity. + v (xarray.DataArray): The v-component of the velocity. + radian_angle (xarray.DataArray): The angle of the grid in RADIANS + + Returns: + Tuple[xarray.DataArray, xarray.DataArray]: The rotated u and v components of the velocity. + """ + + u_rot = u * np.cos(radian_angle) - v * np.sin(radian_angle) + v_rot = u * np.sin(radian_angle) + v * np.cos(radian_angle) + return u_rot, v_rot + + +def is_rectilinear_hgrid(hgrid: xr.Dataset, rtol: float = 1e-3) -> bool: """ - if hgrid.x.shape[0] < 2 or hgrid.x.shape[1] < 2: - raise ValueError("hgrid must have at least 2 points in each direction") - if not np.all(hgrid.y == hgrid.y[:, 0].values[:, np.newaxis]): - return False - if not np.all(hgrid.x == hgrid.x[0, :].values[np.newaxis, :]): - return False - - return True + Check if the hgrid is a rectilinear grid. From mom6_bathy.grid.is_rectangular by Alper (Altuntas + ) + Check if the grid is a rectangular lat-lon grid by comparing the first and last rows and columns of the tlon and tlat arrays. + + Args: + hgrid (xarray.Dataset): The horizontal grid dataset. + rtol (float): Relative tolerance. Default is 1e-3. + """ + if ( + np.allclose(hgrid.tlon[:, 0], hgrid.tlon[0, 0], rtol=rtol) + and np.allclose(hgrid.tlon[:, -1], hgrid.tlon[0, -1], rtol=rtol) + and np.allclose(hgrid.tlat[0, :], hgrid.tlat[0, 0], rtol=rtol) + and np.allclose(hgrid.tlat[-1, :], hgrid.tlat[-1, 0], rtol=rtol) + ): + return True + return False From 15d8d36770ca29370ad7c4d1b58e608b4d2d79b6 Mon Sep 17 00:00:00 2001 From: manishvenu Date: Fri, 10 Jan 2025 14:16:24 -0700 Subject: [PATCH 83/87] Relative Imports --- regional_mom6/regional_mom6.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/regional_mom6/regional_mom6.py b/regional_mom6/regional_mom6.py index f220d2cc..ae3d6612 100644 --- a/regional_mom6/regional_mom6.py +++ b/regional_mom6/regional_mom6.py @@ -20,9 +20,9 @@ from collections import defaultdict import json import copy -from regional_mom6 import regridding as rgd -from regional_mom6 import rotation as rot -from regional_mom6.utils import ( +from . import regridding as rgd +from . import rotation as rot +from .utils import ( quadrilateral_areas, ap2ep, ep2ap, From 05b96df720648325ed25eda4b49f16ab1b89a335 Mon Sep 17 00:00:00 2001 From: manishvenu Date: Fri, 10 Jan 2025 14:29:04 -0700 Subject: [PATCH 84/87] Revert "Relative Imports" This reverts commit 15d8d36770ca29370ad7c4d1b58e608b4d2d79b6. --- regional_mom6/regional_mom6.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/regional_mom6/regional_mom6.py b/regional_mom6/regional_mom6.py index ae3d6612..f220d2cc 100644 --- a/regional_mom6/regional_mom6.py +++ b/regional_mom6/regional_mom6.py @@ -20,9 +20,9 @@ from collections import defaultdict import json import copy -from . import regridding as rgd -from . import rotation as rot -from .utils import ( +from regional_mom6 import regridding as rgd +from regional_mom6 import rotation as rot +from regional_mom6.utils import ( quadrilateral_areas, ap2ep, ep2ap, From 606273ddd2d6f910866eb44e83ec4f6109a5dc43 Mon Sep 17 00:00:00 2001 From: manishvenu Date: Fri, 10 Jan 2025 14:49:29 -0700 Subject: [PATCH 85/87] Check if the ESMF warning is the issue in the tests failure --- demos/reanalysis-forced.ipynb | 24 +++++++++++++++++++----- 1 file changed, 19 insertions(+), 5 deletions(-) diff --git a/demos/reanalysis-forced.ipynb b/demos/reanalysis-forced.ipynb index 84ba01a9..8fe52907 100644 --- a/demos/reanalysis-forced.ipynb +++ b/demos/reanalysis-forced.ipynb @@ -44,10 +44,12 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ + "import warnings\n", + "warnings.filterwarnings(\"ignore\", module=\"esmpy\")\n", "import regional_mom6 as rmom6\n", "\n", "import os\n", @@ -134,9 +136,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "metadata": {}, - "outputs": [], + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'longitude_extent' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "Input \u001b[0;32mIn [2]\u001b[0m, in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 1\u001b[0m expt \u001b[38;5;241m=\u001b[39m rmom6\u001b[38;5;241m.\u001b[39mexperiment(\n\u001b[0;32m----> 2\u001b[0m longitude_extent \u001b[38;5;241m=\u001b[39m \u001b[43mlongitude_extent\u001b[49m,\n\u001b[1;32m 3\u001b[0m latitude_extent \u001b[38;5;241m=\u001b[39m latitude_extent,\n\u001b[1;32m 4\u001b[0m date_range \u001b[38;5;241m=\u001b[39m date_range,\n\u001b[1;32m 5\u001b[0m resolution \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m0.05\u001b[39m,\n\u001b[1;32m 6\u001b[0m number_vertical_layers \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m75\u001b[39m,\n\u001b[1;32m 7\u001b[0m layer_thickness_ratio \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m10\u001b[39m,\n\u001b[1;32m 8\u001b[0m depth \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m4500\u001b[39m,\n\u001b[1;32m 9\u001b[0m minimum_depth \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m5\u001b[39m,\n\u001b[1;32m 10\u001b[0m mom_run_dir \u001b[38;5;241m=\u001b[39m run_dir,\n\u001b[1;32m 11\u001b[0m mom_input_dir \u001b[38;5;241m=\u001b[39m input_dir,\n\u001b[1;32m 12\u001b[0m toolpath_dir \u001b[38;5;241m=\u001b[39m toolpath_dir,\n\u001b[1;32m 13\u001b[0m boundaries\u001b[38;5;241m=\u001b[39m[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mnorth\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124msouth\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124meast\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mwest\u001b[39m\u001b[38;5;124m\"\u001b[39m]\n\u001b[1;32m 14\u001b[0m )\n", + "\u001b[0;31mNameError\u001b[0m: name 'longitude_extent' is not defined" + ] + } + ], "source": [ "expt = rmom6.experiment(\n", " longitude_extent = longitude_extent,\n", @@ -439,7 +453,7 @@ ], "metadata": { "kernelspec": { - "display_name": "crr_dev", + "display_name": "CrocoDash", "language": "python", "name": "python3" }, @@ -453,7 +467,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.12.7" + "version": "3.12.8" } }, "nbformat": 4, From e83298369939822d518843364449c1cc9cbac104 Mon Sep 17 00:00:00 2001 From: manishvenu Date: Mon, 13 Jan 2025 11:13:48 -0700 Subject: [PATCH 86/87] Add Rotational Methods function --- demos/reanalysis-forced.ipynb | 18 +--- regional_mom6/regional_mom6.py | 169 +++++++++------------------------ regional_mom6/regridding.py | 2 +- regional_mom6/rotation.py | 83 +++++++++++++++- regional_mom6/utils.py | 10 +- tests/conftest.py | 9 ++ tests/test_rotation.py | 53 +++++++++++ 7 files changed, 194 insertions(+), 150 deletions(-) diff --git a/demos/reanalysis-forced.ipynb b/demos/reanalysis-forced.ipynb index 8fe52907..245b0964 100644 --- a/demos/reanalysis-forced.ipynb +++ b/demos/reanalysis-forced.ipynb @@ -49,7 +49,7 @@ "outputs": [], "source": [ "import warnings\n", - "warnings.filterwarnings(\"ignore\", module=\"esmpy\")\n", + "warnings.filterwarnings(\"ignore\")\n", "import regional_mom6 as rmom6\n", "\n", "import os\n", @@ -136,21 +136,9 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "ename": "NameError", - "evalue": "name 'longitude_extent' is not defined", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", - "Input \u001b[0;32mIn [2]\u001b[0m, in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 1\u001b[0m expt \u001b[38;5;241m=\u001b[39m rmom6\u001b[38;5;241m.\u001b[39mexperiment(\n\u001b[0;32m----> 2\u001b[0m longitude_extent \u001b[38;5;241m=\u001b[39m \u001b[43mlongitude_extent\u001b[49m,\n\u001b[1;32m 3\u001b[0m latitude_extent \u001b[38;5;241m=\u001b[39m latitude_extent,\n\u001b[1;32m 4\u001b[0m date_range \u001b[38;5;241m=\u001b[39m date_range,\n\u001b[1;32m 5\u001b[0m resolution \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m0.05\u001b[39m,\n\u001b[1;32m 6\u001b[0m number_vertical_layers \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m75\u001b[39m,\n\u001b[1;32m 7\u001b[0m layer_thickness_ratio \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m10\u001b[39m,\n\u001b[1;32m 8\u001b[0m depth \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m4500\u001b[39m,\n\u001b[1;32m 9\u001b[0m minimum_depth \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m5\u001b[39m,\n\u001b[1;32m 10\u001b[0m mom_run_dir \u001b[38;5;241m=\u001b[39m run_dir,\n\u001b[1;32m 11\u001b[0m mom_input_dir \u001b[38;5;241m=\u001b[39m input_dir,\n\u001b[1;32m 12\u001b[0m toolpath_dir \u001b[38;5;241m=\u001b[39m toolpath_dir,\n\u001b[1;32m 13\u001b[0m boundaries\u001b[38;5;241m=\u001b[39m[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mnorth\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124msouth\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124meast\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mwest\u001b[39m\u001b[38;5;124m\"\u001b[39m]\n\u001b[1;32m 14\u001b[0m )\n", - "\u001b[0;31mNameError\u001b[0m: name 'longitude_extent' is not defined" - ] - } - ], + "outputs": [], "source": [ "expt = rmom6.experiment(\n", " longitude_extent = longitude_extent,\n", diff --git a/regional_mom6/regional_mom6.py b/regional_mom6/regional_mom6.py index f220d2cc..4bda003c 100644 --- a/regional_mom6/regional_mom6.py +++ b/regional_mom6/regional_mom6.py @@ -1357,23 +1357,14 @@ def setup_initial_condition( print("Regridding Velocities... ", end="") regridded_u = regridder_u(ic_raw_u) regridded_v = regridder_v(ic_raw_v) - if rotational_method == rot.RotationMethod.GIVEN_ANGLE: - rotated_u, rotated_v = rotate( - regridded_u, - regridded_v, - radian_angle=np.radians(self.hgrid.angle_dx.values), - ) - elif rotational_method == rot.RotationMethod.EXPAND_GRID: - self.hgrid["angle_dx_rm6"] = ( - rot.initialize_grid_rotation_angles_using_expanded_hgrid(self.hgrid) - ) - rotated_u, rotated_v = rotate( - regridded_u, - regridded_v, - radian_angle=np.radians(self.hgrid.angle_dx_rm6.values), - ) - elif rotational_method == rot.RotationMethod.NO_ROTATION: - rotated_u, rotated_v = regridded_u, regridded_v + rotated_u, rotated_v = rotate( + regridded_u, + regridded_v, + radian_angle=np.radians( + rot.get_rotation_angle(rotational_method, self.hgrid).values + ), + ) + # Slice the velocites to the u and v grid. u_points = rgd.get_hgrid_arakawa_c_points(self.hgrid, "u") v_points = rgd.get_hgrid_arakawa_c_points(self.hgrid, "v") @@ -3017,9 +3008,7 @@ def regrid_velocity_tracers(self, rotational_method=rot.RotationMethod.GIVEN_ANG Args: rotational_method (rot.RotationMethod): The method to use for rotation of the velocities. Currently, the default method, GIVEN_ANGLE, works even with non-rotated grids """ - if rotational_method == rot.RotationMethod.NO_ROTATION: - if not is_rectilinear_hgrid(self.hgrid): - raise ValueError("NO_ROTATION method only works with rectilinear grids") + rawseg = xr.open_dataset(self.infile, decode_times=False, engine="netcdf4") coords = rgd.coords(self.hgrid, self.orientation, self.segment_name) @@ -3043,36 +3032,15 @@ def regrid_velocity_tracers(self, rotational_method=rot.RotationMethod.GIVEN_ANG ) ## Angle Calculation & Rotation - if rotational_method == rot.RotationMethod.GIVEN_ANGLE: - rotated_u, rotated_v = rotate( - regridded[self.u], - regridded[self.v], - radian_angle=np.radians(coords.angle.values), - ) - elif rotational_method == rot.RotationMethod.EXPAND_GRID: - - # Recalculate entire hgrid angles - self.hgrid["angle_dx_rm6"] = ( - rot.initialize_grid_rotation_angles_using_expanded_hgrid(self.hgrid) - ) - - # Get just the boundary - degree_angle = rgd.coords( - self.hgrid, - self.orientation, - self.segment_name, - angle_variable_name="angle_dx_rm6", - )["angle"] - - # Rotate - rotated_u, rotated_v = rotate( - regridded[self.u], - regridded[self.v], - radian_angle=np.radians(degree_angle.values), - ) - elif rotational_method == rot.RotationMethod.NO_ROTATION: - # Just transfer values - rotated_u, rotated_v = regridded[self.u], regridded[self.v] + rotated_u, rotated_v = rotate( + regridded[self.u], + regridded[self.v], + radian_angle=np.radians( + rot.get_rotation_angle( + rotational_method, self.hgrid, orientation=self.orientation + ).values + ), + ) rotated_ds = xr.Dataset( { @@ -3102,32 +3070,15 @@ def regrid_velocity_tracers(self, rotational_method=rot.RotationMethod.GIVEN_ANG ) # See explanation of the rotational methods in the A grid section - if rotational_method == rot.RotationMethod.GIVEN_ANGLE: - velocities_out["u"], velocities_out["v"] = rotate( - velocities_out["u"], - velocities_out["v"], - radian_angle=np.radians(coords.angle.values), - ) - elif rotational_method == rot.RotationMethod.EXPAND_GRID: - self.hgrid["angle_dx_rm6"] = ( - rot.initialize_grid_rotation_angles_using_expanded_hgrid(self.hgrid) - ) - degree_angle = rgd.coords( - self.hgrid, - self.orientation, - self.segment_name, - angle_variable_name="angle_dx_rm6", - )["angle"] - velocities_out["u"], velocities_out["v"] = rotate( - velocities_out["u"], - velocities_out["v"], - radian_angle=np.radians(degree_angle.values), - ) - elif rotational_method == rot.RotationMethod.NO_ROTATION: - velocities_out["u"], velocities_out["v"] = ( - velocities_out["u"], - velocities_out["v"], - ) + velocities_out["u"], velocities_out["v"] = rotate( + velocities_out["u"], + velocities_out["v"], + radian_angle=np.radians( + rot.get_rotation_angle( + rotational_method, self.hgrid, orientation=self.orientation + ).values + ), + ) segment_out = xr.merge( [ @@ -3167,29 +3118,16 @@ def regrid_velocity_tracers(self, rotational_method=rot.RotationMethod.GIVEN_ANG regridded_v = regridder_vvelocity(rawseg[[self.v]]) # See explanation of the rotational methods in the A grid section - if rotational_method == rot.RotationMethod.GIVEN_ANGLE: - rotated_u, rotated_v = rotate( - regridded_u, - regridded_v, - radian_angle=np.radians(coords.angle.values), - ) - elif rotational_method == rot.RotationMethod.EXPAND_GRID: - self.hgrid["angle_dx_rm6"] = ( - rot.initialize_grid_rotation_angles_using_expanded_hgrid(self.hgrid) - ) - degree_angle = rgd.coords( - self.hgrid, - self.orientation, - self.segment_name, - angle_variable_name="angle_dx_rm6", - )["angle"] - rotated_u, rotated_v = rotate( - regridded_u, - regridded_v, - radian_angle=np.radians(degree_angle.values), - ) - elif rotational_method == rot.RotationMethod.NO_ROTATION: - rotated_u, rotated_v = regridded_u, regridded_v + rotated_u, rotated_v = rotate( + regridded_u, + regridded_v, + radian_angle=np.radians( + rot.get_rotation_angle( + rotational_method, self.hgrid, orientation=self.orientation + ).values + ), + ) + rotated_ds = xr.Dataset( { self.u: rotated_u, @@ -3357,9 +3295,6 @@ def regrid_tides( Type: Python Functions, Source Code Web Address: https://github.com/jsimkins2/nwa25 """ - if rotational_method == rot.RotationMethod.NO_ROTATION: - if not is_rectilinear_hgrid(self.hgrid): - raise ValueError("NO_ROTATION method only works with rectilinear grids") # Establish Coords coords = rgd.coords(self.hgrid, self.orientation, self.segment_name) @@ -3450,31 +3385,13 @@ def regrid_tides( # and convert ellipse back to amplitude and phase. SEMA, ECC, INC, PHA = ap2ep(ucplex, vcplex) - if rotational_method == rot.RotationMethod.GIVEN_ANGLE: - - # Get user-provided angle - angle = coords["angle"] - - # Rotate - INC -= np.radians(angle.data[np.newaxis, :]) - - elif rotational_method == rot.RotationMethod.EXPAND_GRID: - - # Generate entire hgrid angles using pseudo_hgrid - self.hgrid["angle_dx_rm6"] = ( - rot.initialize_grid_rotation_angles_using_expanded_hgrid(self.hgrid) - ) - - # Get just boundary angles - degree_angle = rgd.coords( - self.hgrid, - self.orientation, - self.segment_name, - angle_variable_name="angle_dx_rm6", - )["angle"] + # Rotate + INC -= np.radians( + rot.get_rotation_angle( + rotational_method, self.hgrid, orientation=self.orientation + ).data[np.newaxis, :] + ) - # Rotate - INC -= np.radians(degree_angle.data[np.newaxis, :]) ua, va, up, vp = ep2ap(SEMA, ECC, INC, PHA) # Convert to real amplitude and phase. diff --git a/regional_mom6/regridding.py b/regional_mom6/regridding.py index ef003964..963aa20b 100644 --- a/regional_mom6/regridding.py +++ b/regional_mom6/regridding.py @@ -32,7 +32,7 @@ import dask.array as da import numpy as np import netCDF4 -from .utils import setup_logger +from regional_mom6.utils import setup_logger regridding_logger = setup_logger(__name__, set_handler=False) diff --git a/regional_mom6/rotation.py b/regional_mom6/rotation.py index 979d0cd6..7193779d 100644 --- a/regional_mom6/rotation.py +++ b/regional_mom6/rotation.py @@ -1,12 +1,11 @@ -from .utils import setup_logger -import logging +from regional_mom6 import utils +from regional_mom6.regridding import get_hgrid_arakawa_c_points, coords -rotation_logger = setup_logger(__name__, set_handler=False) +rotation_logger = utils.setup_logger(__name__, set_handler=False) # An Enum is like a dropdown selection for a menu, it essentially limits the type of input parameters. It comes with additional complexity, which of course is always a challenge. from enum import Enum import xarray as xr import numpy as np -from .regridding import get_hgrid_arakawa_c_points class RotationMethod(Enum): @@ -249,3 +248,79 @@ def create_expanded_hgrid(hgrid: xr.Dataset, expansion_width=1) -> xr.Dataset: } ) return pseudo_hgrid + + +def get_rotation_angle( + rotational_method: RotationMethod, hgrid: xr.Dataset, orientation=None +): + """ + This function returns the rotation angle - THIS IS ALWAYS BASED ON THE ASSUMPTION OF DEGREES - based on the rotational method and provided hgrid, if orientation & coords are provided, it will assume the boundary is requested + Parameters + ---------- + rotational_method: RotationMethod + The rotational method to use + hgrid: xr.Dataset + The hgrid dataset + orientation: xr.Dataset + The orientation, which also lets us now that we are on a boundary + Returns + ------- + xr.DataArray + angle in degrees + """ + rotation_logger.info("Getting rotation angle") + boundary = False + if orientation != None: + rotation_logger.debug( + "The rotational angle is requested for the boundary: {}".format(orientation) + ) + boundary = True + + if rotational_method == RotationMethod.NO_ROTATION: + rotation_logger.debug("Using NO_ROTATION method") + if not utils.is_rectilinear_hgrid(hgrid): + raise ValueError("NO_ROTATION method only works with rectilinear grids") + angles = xr.zeros_like(hgrid.x) + + if boundary: + # Subset to just boundary + # Add zeroes to hgrid + hgrid["zero_angle"] = angles + + # Cut to boundary + zero_angle = coords( + hgrid, + orientation, + "doesnt_matter", + angle_variable_name="zero_angle", + )["angle"] + + return zero_angle + else: + return angles + elif rotational_method == RotationMethod.GIVEN_ANGLE: + rotation_logger.debug("Using GIVEN_ANGLE method") + if boundary: + return coords( + hgrid, orientation, "doesnt_matter", angle_variable_name="angle_dx" + )["angle"] + else: + return hgrid["angle_dx"] + elif rotational_method == RotationMethod.EXPAND_GRID: + rotation_logger.debug("Using EXPAND_GRID method") + hgrid["angle_dx_rm6"] = initialize_grid_rotation_angles_using_expanded_hgrid( + hgrid + ) + + if boundary: + degree_angle = coords( + hgrid, + orientation, + "doesnt_matter", + angle_variable_name="angle_dx_rm6", + )["angle"] + return degree_angle + else: + return hgrid["angle_dx_rm6"] + else: + raise ValueError("Invalid rotational method") diff --git a/regional_mom6/utils.py b/regional_mom6/utils.py index cb477f15..5f393c5e 100644 --- a/regional_mom6/utils.py +++ b/regional_mom6/utils.py @@ -2,6 +2,7 @@ import logging import sys import xarray as xr +from regional_mom6 import regridding as rgd def vecdot(v1, v2): @@ -372,11 +373,12 @@ def is_rectilinear_hgrid(hgrid: xr.Dataset, rtol: float = 1e-3) -> bool: hgrid (xarray.Dataset): The horizontal grid dataset. rtol (float): Relative tolerance. Default is 1e-3. """ + ds_t = rgd.get_hgrid_arakawa_c_points(hgrid) if ( - np.allclose(hgrid.tlon[:, 0], hgrid.tlon[0, 0], rtol=rtol) - and np.allclose(hgrid.tlon[:, -1], hgrid.tlon[0, -1], rtol=rtol) - and np.allclose(hgrid.tlat[0, :], hgrid.tlat[0, 0], rtol=rtol) - and np.allclose(hgrid.tlat[-1, :], hgrid.tlat[-1, 0], rtol=rtol) + np.allclose(ds_t.tlon[:, 0], ds_t.tlon[0, 0], rtol=rtol) + and np.allclose(ds_t.tlon[:, -1], ds_t.tlon[0, -1], rtol=rtol) + and np.allclose(ds_t.tlat[0, :], ds_t.tlat[0, 0], rtol=rtol) + and np.allclose(ds_t.tlat[-1, :], ds_t.tlat[-1, 0], rtol=rtol) ): return True return False diff --git a/tests/conftest.py b/tests/conftest.py index e9eaece9..ab580660 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -2,6 +2,7 @@ import os import xarray as xr import numpy as np +import regional_mom6 as rm6 # Define the path where the curvilinear hgrid file is expected in the Docker container DOCKER_FILE_PATH = "/data/small_curvilinear_hgrid.nc" @@ -30,6 +31,14 @@ def get_curvilinear_hgrid(): ) +@pytest.fixture +def get_rectilinear_hgrid(): + lat = np.linspace(0, 10, 7) + lon = np.linspace(0, 10, 13) + rect_hgrid = rm6.generate_rectangular_hgrid(lat, lon) + return rect_hgrid + + @pytest.fixture() def generate_silly_vt_dataset(): latitude_extent = [30, 40] diff --git a/tests/test_rotation.py b/tests/test_rotation.py index ccf29d2d..5604e5c3 100644 --- a/tests/test_rotation.py +++ b/tests/test_rotation.py @@ -231,3 +231,56 @@ def test_initialize_grid_rotation_angle_using_expanded_hgrid(get_curvilinear_hgr assert (angle.values - hgrid.angle_dx < 1).all() assert angle.values.shape == hgrid.x.shape return + + +def test_get_rotation_angle(get_curvilinear_hgrid, get_rectilinear_hgrid): + """ + Generate a curvilinear grid and test the grid rotation angle at t_points based on what we pass to generate to generate_curvilinear_grid + """ + curved_hgrid = get_curvilinear_hgrid + rect_hgrid = get_rectilinear_hgrid + + o = None + rotational_method = rot.RotationMethod.NO_ROTATION + angle = rot.get_rotation_angle(rotational_method, rect_hgrid, orientation=o) + assert angle.shape == rect_hgrid.x.shape + assert (angle.values == 0).all() + + rotational_method == rot.RotationMethod.NO_ROTATION + with pytest.raises( + ValueError, match="NO_ROTATION method only works with rectilinear grids" + ): + angle = rot.get_rotation_angle(rotational_method, curved_hgrid, orientation=o) + + rotational_method = rot.RotationMethod.GIVEN_ANGLE + angle = rot.get_rotation_angle(rotational_method, curved_hgrid, orientation=o) + assert angle.shape == curved_hgrid.x.shape + assert (angle.values == curved_hgrid.angle_dx).all() + angle = rot.get_rotation_angle(rotational_method, rect_hgrid, orientation=o) + assert angle.shape == rect_hgrid.x.shape + assert (angle.values == 0).all() + + rotational_method = rot.RotationMethod.EXPAND_GRID + angle = rot.get_rotation_angle(rotational_method, curved_hgrid, orientation=o) + assert angle.shape == curved_hgrid.x.shape + assert ( + abs(angle.values - curved_hgrid.angle_dx) < 1 + ).all() # There shouldn't be large differences + angle = rot.get_rotation_angle(rotational_method, rect_hgrid, orientation=o) + assert angle.shape == rect_hgrid.x.shape + assert (angle.values == 0).all() + + # Check if o is boundary that the shape is of a boundary + o = "north" + rotational_method = rot.RotationMethod.NO_ROTATION + angle = rot.get_rotation_angle(rotational_method, rect_hgrid, orientation=o) + assert angle.shape == rect_hgrid.x[-1].shape + assert (angle.values == 0).all() + rotational_method = rot.RotationMethod.EXPAND_GRID + angle = rot.get_rotation_angle(rotational_method, rect_hgrid, orientation=o) + assert angle.shape == rect_hgrid.x[-1].shape + assert (angle.values == 0).all() + rotational_method = rot.RotationMethod.GIVEN_ANGLE + angle = rot.get_rotation_angle(rotational_method, rect_hgrid, orientation=o) + assert angle.shape == rect_hgrid.x[-1].shape + assert (angle.values == 0).all() From 0c5f08cfe176f89c92a08181cb46e373b9ee245e Mon Sep 17 00:00:00 2001 From: manishvenu Date: Fri, 17 Jan 2025 10:12:15 -0700 Subject: [PATCH 87/87] Small Adj to Docs' --- docs/angle_calc.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/angle_calc.md b/docs/angle_calc.md index 7a74e958..089cda3f 100644 --- a/docs/angle_calc.md +++ b/docs/angle_calc.md @@ -42,4 +42,4 @@ Both regridding functions (regrid_velocity_tracers, regrid_tides) accept a param We then define each method with a bunch of if statements. Here are the processes: 1. Given angle is the default method of accepting the hgrid's angle_dx -2. Fred's method is the least code, and we simply swap out the hgrid angle with the generated one we calculate right where we do the rotation. +2. The EXPAND_GRID method is the least code, and we simply swap out the hgrid angle with the generated one we calculate right where we do the rotation.