From a67e1266b1d17aeec4a839ad190541ba4ae1ee45 Mon Sep 17 00:00:00 2001 From: Nils Date: Mon, 22 Nov 2021 23:55:10 +0100 Subject: [PATCH 01/21] Code modified to be fully python3 compatible --- lkf_detection.py | 85 ++++++++++++++++++++++++++++++++++++------------ lkf_tracking.py | 23 ++++++++----- 2 files changed, 79 insertions(+), 29 deletions(-) diff --git a/lkf_detection.py b/lkf_detection.py index c126ca6..0fcce0d 100644 --- a/lkf_detection.py +++ b/lkf_detection.py @@ -268,33 +268,59 @@ def detect_segments(lkf_thin,eps_thres=0.1): new_starts = np.append(new_starts,neigh_deactivate[new_starts_deact_ind].reshape((new_starts_deact_ind.size,2)),axis=0) nodetect[new_starts[:,0].astype('int'),new_starts[:,1].astype('int')] = 0 nodetect_intm[1:-1,1:-1] = nodetect.copy() + # if ind<5: + # print(new_starts.shape) + # print(new_starts) + # print(deactivate_segs_muln.shape) + # print(deactivate_segs_muln) + + + + # Test for segements that are on the same point + nan_mask_segs = np.all(~np.isnan(seg_append),axis=-1) + ravel_seg_append = np.ravel_multi_index((seg_append[nan_mask_segs,0].astype('int'), + seg_append[nan_mask_segs,1].astype('int')), + lkf_thin[1:-1,1:-1].shape) + seg_head_unique, seg_head_counts = np.unique(ravel_seg_append,return_counts=True) + deactivate_segs_samehead = np.empty((0,)) + seg_head_continue = seg_head_unique[seg_head_counts==1] + + if np.any(seg_head_counts>1): + deactivate_segs_samehead = np.hstack([np.where(ravel_seg_append==ihead) + for ihead in seg_head_unique[seg_head_counts>1]]).squeeze() + new_starts = np.concatenate([new_starts,np.vstack(np.unravel_index(seg_head_unique[seg_head_counts>1], + lkf_thin[1:-1,1:-1].shape)).T]) + #print(deactivate_segs_samehead) + + # Remove sharp turns from seg_append (here because search for new starting points # needs to run beforehand) if seg.shape[-1]>1: seg_append[np.sum(np.abs(dx),axis=1)>1,:] = np.NaN # Remove from appending list + # Plot intermediate results - if ind%20==0: + if ind<5:#ind%5==0: do_plot = False else: do_plot = False if do_plot: - plt.figure() - plt.pcolormesh(num_neighbours.copy()) + fig,ax = plt.subplots(1,2,sharex=True,sharey=True,figsize=(9,5),tight_layout=True) + ax[0].pcolormesh(num_neighbours.copy()) for i in range(seg.shape[0]): if np.any(active_detection==i): col = 'r' else: col = 'g' - plt.plot(seg[i,1,:]+0.5,seg[i,0,:]+0.5,col) - plt.text(seg[i,1,~np.isnan(seg[i,1,:])][-1]+0.5,seg[i,0,~np.isnan(seg[i,1,:])][-1]+0.5,'%i' %i,color='w') + ax[0].plot(seg[i,1,:]+0.5,seg[i,0,:]+0.5,col) + ax[0].text(seg[i,1,~np.isnan(seg[i,1,:])][-1]+0.5,seg[i,0,~np.isnan(seg[i,1,:])][-1]+0.5,'%i' %i,color='w') for i in range(neigh_deactivate.shape[0]): - plt.plot(neigh_deactivate[i,1]+0.5,neigh_deactivate[i,0]+0.5,'m.') + ax[0].plot(neigh_deactivate[i,1]+0.5,neigh_deactivate[i,0]+0.5,'m.') for i in range(new_starts.shape[0]): - plt.plot(new_starts[i,1]+0.5,new_starts[i,0]+0.5,'c.') + ax[0].plot(new_starts[i,1]+0.5,new_starts[i,0]+0.5,'c.') for i in range(active_detection.size): if np.any(deactivate_segs_end.copy()==i): mark = 'x' @@ -302,23 +328,25 @@ def detect_segments(lkf_thin,eps_thres=0.1): mark = 'v' elif np.any(deactivate_segs_muln.copy()==i): mark = 's' + elif np.any(deactivate_segs_samehead.copy()==i): + mark = '>' else: mark = '.' if ~np.isnan(seg_append[i,1]): - plt.plot(seg_append[i,1]+0.5,seg_append[i,0]+0.5,color='r',marker=mark) + ax[0].plot(seg_append[i,1]+0.5,seg_append[i,0]+0.5,color='r',marker=mark) else: - plt.plot(seg[active_detection[i],1,-1]+0.5,seg[active_detection[i],0,-1]+0.5,color='r',marker=mark) + ax[0].plot(seg[active_detection[i],1,-1]+0.5,seg[active_detection[i],0,-1]+0.5,color='r',marker=mark) - plt.figure() - plt.pcolormesh(nodetect.copy()+lkf_thin[1:-1,1:-1]) + #plt.figure() + ax[1].pcolormesh(nodetect.copy()+lkf_thin[1:-1,1:-1]) for i in range(seg.shape[0]): if np.any(active_detection==i): col = 'r' else: col = 'g' - plt.plot(seg[i,1,:]+0.5,seg[i,0,:]+0.5,col) - plt.text(seg[i,1,~np.isnan(seg[i,1,:])][-1]+0.5,seg[i,0,~np.isnan(seg[i,1,:])][-1]+0.5,'%i' %i,color='w') + ax[1].plot(seg[i,1,:]+0.5,seg[i,0,:]+0.5,col) + ax[1].text(seg[i,1,~np.isnan(seg[i,1,:])][-1]+0.5,seg[i,0,~np.isnan(seg[i,1,:])][-1]+0.5,'%i' %i,color='w') for i in range(active_detection.size): if np.any(deactivate_segs_end.copy()==i): mark = 'x' @@ -326,23 +354,35 @@ def detect_segments(lkf_thin,eps_thres=0.1): mark = 'v' elif np.any(deactivate_segs_muln.copy()==i): mark = 's' + elif np.any(deactivate_segs_samehead.copy()==i): + mark = 'd' else: mark = '.' if ~np.isnan(seg_append[i,1]): - plt.plot(seg_append[i,1]+0.5,seg_append[i,0]+0.5,color='r',marker=mark) + ax[1].plot(seg_append[i,1]+0.5,seg_append[i,0]+0.5,color='r',marker=mark) else: - plt.plot(seg[active_detection[i],1,-1]+0.5,seg[active_detection[i],0,-1]+0.5,color='r',marker=mark) + ax[1].plot(seg[active_detection[i],1,-1]+0.5,seg[active_detection[i],0,-1]+0.5,color='r',marker=mark) + ax[0].set_xlim([380,395]) + ax[0].set_ylim([180,197]) + for iax in ax: iax.set_aspect('equal') + + + + # Test for multiple times same start new_starts_unique, new_starts_counts = np.unique(np.ravel_multi_index((new_starts[:,0].astype('int'), new_starts[:,1].astype('int')), lkf_thin[1:-1,1:-1].shape), return_counts=True) - if np.any(new_starts_counts > 1): - # print 'Warning: %i starting points arises maximum %i-times' %(np.sum(new_starts_counts>1), - # np.max(new_starts_counts)) - new_starts = np.vstack(np.unravel_index(new_starts_unique,lkf_thin[1:-1,1:-1].shape)).T - + + new_starts_unique = np.array([i_seg_start for i_seg_start in new_starts_unique if not np.any(seg_head_unique==i_seg_start)],dtype='int') + + # if np.any(new_starts_counts > 1): + # # print 'Warning: %i starting points arises maximum %i-times' %(np.sum(new_starts_counts>1), + # # np.max(new_starts_counts)) + # new_starts = np.vstack(np.unravel_index(new_starts_unique,lkf_thin[1:-1,1:-1].shape)).T + new_starts = np.vstack(np.unravel_index(new_starts_unique,lkf_thin[1:-1,1:-1].shape)).T # Append new positions of this detection step num_new_starts = new_starts.shape[0] @@ -360,9 +400,12 @@ def detect_segments(lkf_thin,eps_thres=0.1): active_detection_old = active_detection.copy() if np.any([(deactivate_segs_muln.size > 0), (deactivate_segs_ang.size > 0), - (deactivate_segs_end.size > 0)]): + (deactivate_segs_end.size > 0), + (deactivate_segs_samehead.size > 0)]): deactivate_segs = np.unique(np.append(deactivate_segs_muln, np.append(deactivate_segs_ang,deactivate_segs_end))) + deactivate_segs = np.unique(np.hstack([deactivate_segs_muln,deactivate_segs_ang, + deactivate_segs_end,deactivate_segs_samehead])) active_detection = np.delete(active_detection,deactivate_segs) # remove from active list # Activate new segments that started in this iteration diff --git a/lkf_tracking.py b/lkf_tracking.py index 3c7b4c5..e0cfb4a 100644 --- a/lkf_tracking.py +++ b/lkf_tracking.py @@ -55,7 +55,7 @@ def compute_MHD_segment(A,B,return_overlap=False,overlap_thres=2,angle_thres=45, # ------------------- 1. Tracking function -def track_lkf(lkf0_d, lkf1, nx, ny, thres_frac=0.75, min_overlap=4,first_overlap=False,overlap_thres=1.5,angle_thres=25.): +def track_lkf(lkf0_d, lkf1, nx, ny, thres_frac=0.75, min_overlap=4,first_overlap=False,overlap_thres=1.5,angle_thres=25.,search_area_expansion=1): """Tracking function for LKFs Input: lkf0_d: advected detected LKF features @@ -86,7 +86,7 @@ def track_lkf(lkf0_d, lkf1, nx, ny, thres_frac=0.75, min_overlap=4,first_overlap np.vstack([np.ceil(iseg_d)[:,0],np.floor(iseg_d)[:,1]]).T], axis=0) # Floor and ceil broken indexes # Broadening of search area - search_area_expansion = 1 # Number of cell for which the search area is expanded to be consider differences in the morphological thinning + #search_area_expansion = 1 # Number of cell for which the search area is expanded to be consider differences in the morphological thinning for i in range(search_area_expansion): n_rows = search_area[:,0].size search_area = np.concatenate([search_area, @@ -107,10 +107,17 @@ def track_lkf(lkf0_d, lkf1, nx, ny, thres_frac=0.75, min_overlap=4,first_overlap search_area+np.concatenate([-np.ones(n_rows).reshape((n_rows,1)), -np.ones(n_rows).reshape((n_rows,1))],axis=1)],axis=0) - - search_area = np.vstack({tuple(row) for row in search_area}) + search_area = np.unique(search_area, axis=0) - + search_area = search_area[np.all(search_area>=0,axis=1),:] + search_area = search_area[np.all([search_area[:,0] Date: Mon, 14 Mar 2022 15:31:08 -0700 Subject: [PATCH 02/21] initialize move of lkf_tools to python package --- environment.yml | 15 +++++++++ lkf_tools/__init__.py | 15 +++++++++ setup.cfg | 72 +++++++++++++++++++++++++++++++++++++++++ setup.cfg~ | 75 +++++++++++++++++++++++++++++++++++++++++++ setup.py | 10 ++++++ setup.py~ | 10 ++++++ 6 files changed, 197 insertions(+) create mode 100644 environment.yml create mode 100644 lkf_tools/__init__.py create mode 100644 setup.cfg create mode 100644 setup.cfg~ create mode 100644 setup.py create mode 100644 setup.py~ diff --git a/environment.yml b/environment.yml new file mode 100644 index 0000000..3af0b96 --- /dev/null +++ b/environment.yml @@ -0,0 +1,15 @@ +name: lkf_tools +channels: + - conda-forge +dependencies: + - pytest + - netcdf4 + - scipy + - jupyter + - numpy + - jupyterlab + - matplotlib + - scikit-image + - xarray + - ipympl +prefix: /Users/nhutter/miniforge3/envs/lkf_tools diff --git a/lkf_tools/__init__.py b/lkf_tools/__init__.py new file mode 100644 index 0000000..351a0b2 --- /dev/null +++ b/lkf_tools/__init__.py @@ -0,0 +1,15 @@ +# -*- coding: utf-8 -*- + +""" +The lkf_tools python package is project to develop detection and tracking +routines to identify deformation features (leads, pressure ridges, LKFs) +in gridded sea-ice deformation data. The package includes statistical tools +to analyse spatial and temporal statistics of LKFs. +""" + + +# Package Metadata +__version__ = 0.1 +__author__ = "Nils Hutter" +__author_email__ = "nhutter@uw.edu" + diff --git a/setup.cfg b/setup.cfg new file mode 100644 index 0000000..fda7e90 --- /dev/null +++ b/setup.cfg @@ -0,0 +1,72 @@ +[sdist] +formats = gztar + +[check-manifest] +ignore = + *.yml + *.yaml + .coveragerc + docs + docs/* + *.enc + notebooks + notebooks/* + tests + tests/* + +[flake8] +max-line-length = 105 +select = C,E,F,W,B,B950 +ignore = E203, E501, W503 +exclude = lkf_tools/_version.py + + +[metadata] +name = lkf_tools +description = this package allows to detect and track deformation features (LKFs) in sea-ice deformation data +author = Nils Hutter +url = https://github.com/nhutter/lkf_tools +long_description = file: README.md +long_description_content_type = text/markdown +license = GNU General Public License v3.0 +license_file = LICENSE.txt + +## These need to be filled in by the author! +# For details see: https://pypi.org/classifiers/ + +classifiers = + Development Status :: 3 - Alpha #5 - Production/Stable + Topic :: Scientific/Engineering + Intended Audience :: Science/Research + Operating System :: OS Independent + Programming Language :: Python + Programming Language :: Python :: 3 + Programming Language :: Python :: 3.6 + Programming Language :: Python :: 3.7 + Programming Language :: Python :: 3.8 + Programming Language :: Python :: 3.9 + # Dont change this one + License :: OSI Approved :: MIT License + +## Add your email here +author_email = nhutter@uw.edu + + +### make sure to fill in your dependencies! +[options] +install_requires = + numpy + requests + numpy + matplotlib + scipy + netCDF4 + datetime + scikit-image +setup_requires= + setuptools_scm +python_requires = >=3.6 +################ Up until here + +zip_safe = False +packages = find: diff --git a/setup.cfg~ b/setup.cfg~ new file mode 100644 index 0000000..5df674b --- /dev/null +++ b/setup.cfg~ @@ -0,0 +1,75 @@ +[sdist] +formats = gztar + +[check-manifest] +ignore = + *.yml + *.yaml + .coveragerc + docs + docs/* + *.enc + notebooks + notebooks/* + tests + tests/* + +[flake8] +max-line-length = 105 +select = C,E,F,W,B,B950 +ignore = E203, E501, W503 +exclude = lkf_tools/_version.py + + +[metadata] +name = lkf_tools +description = this package allows to detect and track deformation features (LKFs) in sea-ice deformation data +author = Nils Hutter +url = https://github.com/nhutter/lkf_tools +long_description = file: README.md +long_description_content_type = text/markdown +license = GNU General Public License v3.0 +license_file = LICENSE.txt + +## These need to be filled in by the author! +# For details see: https://pypi.org/classifiers/ + +classifiers = + Development Status :: 3 - Alpha #5 - Production/Stable + Topic :: Scientific/Engineering + Intended Audience :: Science/Research + Operating System :: OS Independent + Programming Language :: Python + Programming Language :: Python :: 3 + Programming Language :: Python :: 3.6 + Programming Language :: Python :: 3.7 + Programming Language :: Python :: 3.8 + Programming Language :: Python :: 3.9 + # Dont change this one + License :: OSI Approved :: MIT License + +## Add your email here +author_email = nhutter@uw.edu + + +### make sure to fill in your dependencies! +[options] +install_requires = + numpy + requests + numpy + matplotlib + scipy + netCDF4 + datetime + osgeo + pyproj + loguru + scikit-image +setup_requires= + setuptools_scm +python_requires = >=3.6 +################ Up until here + +zip_safe = False +packages = find: diff --git a/setup.py b/setup.py new file mode 100644 index 0000000..00f6121 --- /dev/null +++ b/setup.py @@ -0,0 +1,10 @@ +from setuptools import setup + + +setup( + use_scm_version={ + "write_to": "lkf_tools/_version.py", + "write_to_template": '__version__ = "{version}"', + "tag_regex": r"^(?Pv)?(?P[^\+]+)(?P.*)?$", + } +) diff --git a/setup.py~ b/setup.py~ new file mode 100644 index 0000000..43009bb --- /dev/null +++ b/setup.py~ @@ -0,0 +1,10 @@ +from setuptools import setup + + +setup( + use_scm_version={ + "write_to": "floe_deform/_version.py", + "write_to_template": '__version__ = "{version}"', + "tag_regex": r"^(?Pv)?(?P[^\+]+)(?P.*)?$", + } +) From fdb8464dff394792a59f7061e907ffe55390d9a6 Mon Sep 17 00:00:00 2001 From: Nils Hutter Date: Mon, 14 Mar 2022 16:56:42 -0700 Subject: [PATCH 03/21] detection and tracking routines moved to package --- environment.yml | 2 + lkf_tools/detection.py | 1064 ++++++++++++++++++++++++++++ lkf_tools/rgps.py | 312 ++++++++ lkf_tools/tracking.py | 305 ++++++++ notebooks/detection_tutorial.ipynb | 139 ++++ setup.cfg | 2 + 6 files changed, 1824 insertions(+) create mode 100644 lkf_tools/detection.py create mode 100644 lkf_tools/rgps.py create mode 100644 lkf_tools/tracking.py create mode 100644 notebooks/detection_tutorial.ipynb diff --git a/environment.yml b/environment.yml index 3af0b96..cbfc9e3 100644 --- a/environment.yml +++ b/environment.yml @@ -12,4 +12,6 @@ dependencies: - scikit-image - xarray - ipympl + - pyproj + - cartopy prefix: /Users/nhutter/miniforge3/envs/lkf_tools diff --git a/lkf_tools/detection.py b/lkf_tools/detection.py new file mode 100644 index 0000000..e04535b --- /dev/null +++ b/lkf_tools/detection.py @@ -0,0 +1,1064 @@ +# -*- coding: utf-8 -*- + +""" +Detection routines to detect LKF in deformation data. +""" + + +# Package Metadata +__version__ = 0.1 +__author__ = "Nils Hutter" +__author_email__ = "nhutter@uw.edu" + + +import numpy as np +import matplotlib.pylab as plt +import os +import sys +from multiprocessing import Pool +import warnings +#from mpl_toolkits.basemap import Basemap # need to be replaced! + + +# Packages for image processing +import scipy.ndimage as ndim +import skimage.morphology + +from .rgps import * + + + +# ----------------- 1. Filtering and image processing -------------- +# ------------------- ( described in Section 3.1.1 ) ------------- + + + +def fill_lkf(lkf_segment): + """ Function to fill detected LKFs as only points of direction change are saved + Output: indexes of all pixels containing to the LKF""" + lkf_filled = lkf_segment[:,0].reshape((1,2)) + for i in range(lkf_segment[0,:].size-1): + diffx = lkf_segment[0,i+1]-lkf_segment[0,i] + diffy = lkf_segment[1,i+1]-lkf_segment[1,i] + if (np.abs(diffx)>1) | (np.abs(diffy)>1): + num_add = np.max([np.abs(diffx), np.abs(diffy)]).astype('int') + addx = np.linspace(0,diffx,num_add+1)[1:].reshape((num_add,1)) + addy = np.linspace(0,diffy,num_add+1)[1:].reshape((num_add,1)) + add = np.concatenate([addx,addy],axis=1) + lkf_filled = np.concatenate([lkf_filled,lkf_segment[:,i]+add],axis=1) + else: + lkf_filled = np.concatenate([lkf_filled,lkf_segment[:,i+1].reshape((1,2))],axis=1) + return lkf_filled + + +def hist_eq(array, number_bins=256): + """ Histogram equalization + Input: array and number_bins (range of possible output valus: 0 to number_bins as integers) + Output: histogram equalized version of array + """ + # Compute histogram + bins_center = np.linspace(np.nanmin(array[~np.isnan(array)]),np.nanmax(array[~np.isnan(array)]),number_bins) + bins = np.append(bins_center-np.diff(bins_center)[0],(bins_center+np.diff(bins_center)[0])[-1]) + hist,bins = np.histogram(array[~np.isnan(array)].flatten(), bins) + + # Distribute bins equally to create lookup table + new_values = np.floor((number_bins-1)*np.cumsum(hist/float(array[~np.isnan(array)].size))) + + # Compute equalized array with lookuptable + array_equalized = np.take(new_values,np.digitize(array[~np.isnan(array)].flatten(),bins)-1) + + new_array_equalized = array.flatten() + new_array_equalized[~np.isnan(new_array_equalized)]=array_equalized + + return new_array_equalized.reshape(array.shape) + + +def nan_gaussian_filter(field,kernel,truncate): + """ Version of scipy.ndimage.gaussian_filter that considers + NaNs in the input array by setting them to zero and afterwards + rescale the output array. + Source https://stackoverflow.com/questions/18697532/gaussian-filtering-a-image-with-nan-in-python + + Input: field - field to be filtered + kernel - kernel of gaussian filter + + Output: gaussian_field - filtered field """ + + field_nonnan = field.copy() + mask_nan = np.ones(field.shape) + + field_nonnan[np.isnan(field)] = 0 + mask_nan[np.isnan(field)] = 0 + + field_nonnan_f = ndim.gaussian_filter(field_nonnan,kernel,truncate=truncate) + mask_nan_f = ndim.gaussian_filter(mask_nan,kernel,truncate=truncate) + + gaussian_field = field_nonnan_f/mask_nan_f + + #gaussian_field[np.isnan(field) | np.isnan(gaussian_field)] = 0. + + return gaussian_field + + +def DoG_leads(in_array,max_kern,min_kern): + """DoG: Difference of Gaussian Filters Combination as implemented in Linow & Dierking, 2017""" + + res = np.zeros(in_array.shape) + c = np.arange(min_kern,max_kern+1)*0.5 + + for i in range(0,c.size-1): + + gaus1 = nan_gaussian_filter(in_array,c[i],truncate=2) + gaus2 = nan_gaussian_filter(in_array,c[i+1],truncate=2) + res += (gaus1 - gaus2) + + return res + + + + + + +# --------------------- 2. Segment detection ------------------ +# ---------------- ( described in Section 3.1.2 ) ------------- + + + +def cut_neighbours(img): + """Function that stencils each pixel with neighbouring pixels + Input: image (shape: MxN) + Output: all neighbours (shape: MxNx3x3) + """ + img = np.ascontiguousarray(img) # won't make a copy if not needed + X, Y = img.shape + x, y = (1,1) + overlap = 1 + shape = (((X-2*overlap)//x), ((Y-2*overlap)//y), x+2*overlap, y+2*overlap) # number of patches, patch_shape + strides = img.itemsize*np.array([Y*x, y, Y, 1]) + return np.lib.stride_tricks.as_strided(img, shape=shape, strides=strides) + +def nansum_neighbours(img): + return np.nansum(cut_neighbours(img),axis=(2,3)) + +def nanmean_neighbours(img): + return np.nanmean(cut_neighbours(img),axis=(2,3)) + + + +def detect_segments(lkf_thin,eps_thres=0.1): + """ Function to detect segments of LKFs in thinned binary field + The aim of this function is to split the binary field into + multiple smaller segments, and guarantee that all points in a + segment belong to the same LKF. To do so a threshold for the + deformation rate is establishes, which cuts to line that might + belong to different LKFs. Note that also segments belonging + to one LKF might be detected as multiple single segments in this + step. + + Input: lkf_thin - thinned binary field + eps_thres - deformation difference threshold to break a + segment + + Output: seg_list - list of segments """ + + + # ------------------ Find starting points ----------------------- + seg = np.rollaxis(np.array(np.where((nansum_neighbours(lkf_thin)<=2) & (lkf_thin[1:-1,1:-1]==1))),1) + seg = seg.reshape((seg.shape[0],seg.shape[1],1)) + # seg - array of dimension [N,2,M] with N being the number of segments + # M being an index for the point + + # Array of LKF points that have not been detected so far + nodetect = lkf_thin[1:-1,1:-1].copy() + + # Set all starting points to zero as they are detected already + nodetect[(nansum_neighbours(lkf_thin)==2) & (nodetect==1)] = 0. + nodetect_intm = np.zeros((nodetect.shape[0]+2, + nodetect.shape[1]+2)) + nodetect_intm[1:-1,1:-1] = nodetect.copy() + + # Initialize list of active segments + active_detection = np.arange(seg.shape[0]) + + # Deactivate segments that contain only one or two points + deactivate_segs = np.where(nansum_neighbours(nodetect_intm)[seg[:,0].astype('int'), + seg[:,1].astype('int')].squeeze() != 1) + if deactivate_segs[0].size > 0: + active_detection = np.delete(active_detection, + active_detection[deactivate_segs]) # remove from active list + + + # --------------------- Detection loop -------------------------- + + # Loop parameters + num_nodetect = np.sum(nodetect) # Number of undetected pixels + ind = 0 # Index of detection iteration + max_ind = 500 # Maximum number of iterations + + angle_point_thres = 5 # Number of last point in segment to compute the critical angel to break segments + + while num_nodetect > 0: + #print ind, num_nodetect + # Reduce segment array to active indeces + seg_active = seg[active_detection] + + # Scheme of neighbouring cells + # + # 1 | 2 | 3 + # ----------- ----> y + # 8 | X | 4 | + # ----------- v + # 7 | 6 | 5 x + # + + x = np.empty(seg_active.shape[:1])*np.NaN + y = np.empty(seg_active.shape[:1])*np.NaN + + for ix in [-1,0,1]: + for iy in [-1,0,1]: + indx = (seg_active[:,0,ind] + ix).astype('int') + indy = (seg_active[:,1,ind] + iy).astype('int') + mask = np.all([indx>=0,indx=0, indy1: + # Compute number of valid points per active segment + num_points = np.sum(np.all(~np.isnan(seg_active),axis=1),axis=-1) + # Limit points for the computation of the angle to threshold + num_points[num_points>angle_point_thres] = angle_point_thres + dx = (seg_active[:,:,-1]-seg_active[np.arange(seg_active.shape[0]),:,-num_points])/np.stack([num_points-1,num_points-1],axis=1) - (seg_append-seg_active[:,:,-1]) + new_starts = seg_append[np.sum(np.abs(dx),axis=1)>1] # high angle -> new starting point + #print 'Number of segments broken by angel: %i' %np.sum(np.sum(np.abs(dx),axis=1)>1) + + deactivate_segs_ang = np.where(np.sum(np.abs(dx),axis=1)>1)[0] + + # Mark pixels as detected + mask = np.all(~np.isnan(seg_append),axis=1) # masks all NaN entries in seg_append + nodetect[seg_append[:,0][mask].astype('int'),seg_append[:,1][mask].astype('int')] = 0. + if new_starts.size>0: + nodetect[new_starts[:,0].astype('int'),new_starts[:,1].astype('int')] = 0 + nodetect_intm[1:-1,1:-1] = nodetect.copy() + + # Deactivate pixels with more than one neighbour and activate neighbours + num_neighbours = nansum_neighbours(nodetect_intm) + + deactivate_segs_muln = np.where(num_neighbours[seg_append[:,0][mask].astype('int'), + seg_append[:,1][mask].astype('int')].squeeze() > 1)[0] + deactivate_segs_muln = np.arange(seg_append.shape[0])[mask][deactivate_segs_muln] + + if (deactivate_segs_muln.size > 0): + # Search for possibles neighbours to activate + seg_deact = seg_append[deactivate_segs_muln] + neigh_deactivate = np.vstack([seg_deact + + i*np.hstack([np.ones((seg_deact.shape[0],1)), + np.zeros((seg_deact.shape[0],1))]) + + j*np.hstack([np.zeros((seg_deact.shape[0],1)), + np.ones((seg_deact.shape[0],1))]) + for i in [-1,0,1] for j in [-1,0,1]]) + # new_starts_deact_ind = np.rollaxis(np.array(np.where((num_neighbours[neigh_deactivate[:,0].astype('int'), + # neigh_deactivate[:,1].astype('int')]<=2) & + # (nodetect[neigh_deactivate[:,0].astype('int'), + # neigh_deactivate[:,1].astype('int')]==1))),1).squeeze() + new_starts_deact_ind = np.rollaxis(np.array(np.where((num_neighbours[neigh_deactivate[:,0].astype('int'), + neigh_deactivate[:,1].astype('int')]<=2) & + (nodetect[neigh_deactivate[:,0].astype('int'), + neigh_deactivate[:,1].astype('int')]==1))),1).squeeze() + if new_starts_deact_ind.size>0: + new_starts = np.append(new_starts,neigh_deactivate[new_starts_deact_ind].reshape((new_starts_deact_ind.size,2)),axis=0) + nodetect[new_starts[:,0].astype('int'),new_starts[:,1].astype('int')] = 0 + nodetect_intm[1:-1,1:-1] = nodetect.copy() + # if ind<5: + # print(new_starts.shape) + # print(new_starts) + # print(deactivate_segs_muln.shape) + # print(deactivate_segs_muln) + + + + # Test for segements that are on the same point + nan_mask_segs = np.all(~np.isnan(seg_append),axis=-1) + + ravel_seg_append = np.ravel_multi_index((seg_append[nan_mask_segs,0].astype('int'), + seg_append[nan_mask_segs,1].astype('int')), + lkf_thin[1:-1,1:-1].shape) + seg_head_unique, seg_head_counts = np.unique(ravel_seg_append,return_counts=True) + deactivate_segs_samehead = np.empty((0,)) + seg_head_continue = seg_head_unique[seg_head_counts==1] + + if np.any(seg_head_counts>1): + deactivate_segs_samehead = np.hstack([np.where(ravel_seg_append==ihead) + for ihead in seg_head_unique[seg_head_counts>1]]).squeeze() + new_starts = np.concatenate([new_starts,np.vstack(np.unravel_index(seg_head_unique[seg_head_counts>1], + lkf_thin[1:-1,1:-1].shape)).T]) + #print(deactivate_segs_samehead) + + + # Remove sharp turns from seg_append (here because search for new starting points + # needs to run beforehand) + if seg.shape[-1]>1: + seg_append[np.sum(np.abs(dx),axis=1)>1,:] = np.NaN # Remove from appending list + + + + # Plot intermediate results + if ind<5:#ind%5==0: + do_plot = False + else: + do_plot = False + + if do_plot: + fig,ax = plt.subplots(1,2,sharex=True,sharey=True,figsize=(9,5),tight_layout=True) + ax[0].pcolormesh(num_neighbours.copy()) + for i in range(seg.shape[0]): + if np.any(active_detection==i): + col = 'r' + else: + col = 'g' + ax[0].plot(seg[i,1,:]+0.5,seg[i,0,:]+0.5,col) + ax[0].text(seg[i,1,~np.isnan(seg[i,1,:])][-1]+0.5,seg[i,0,~np.isnan(seg[i,1,:])][-1]+0.5,'%i' %i,color='w') + for i in range(neigh_deactivate.shape[0]): + ax[0].plot(neigh_deactivate[i,1]+0.5,neigh_deactivate[i,0]+0.5,'m.') + for i in range(new_starts.shape[0]): + ax[0].plot(new_starts[i,1]+0.5,new_starts[i,0]+0.5,'c.') + for i in range(active_detection.size): + if np.any(deactivate_segs_end.copy()==i): + mark = 'x' + elif np.any(deactivate_segs_ang.copy()==i): + mark = 'v' + elif np.any(deactivate_segs_muln.copy()==i): + mark = 's' + elif np.any(deactivate_segs_samehead.copy()==i): + mark = '>' + else: + mark = '.' + if ~np.isnan(seg_append[i,1]): + ax[0].plot(seg_append[i,1]+0.5,seg_append[i,0]+0.5,color='r',marker=mark) + else: + ax[0].plot(seg[active_detection[i],1,-1]+0.5,seg[active_detection[i],0,-1]+0.5,color='r',marker=mark) + + + #plt.figure() + ax[1].pcolormesh(nodetect.copy()+lkf_thin[1:-1,1:-1]) + for i in range(seg.shape[0]): + if np.any(active_detection==i): + col = 'r' + else: + col = 'g' + ax[1].plot(seg[i,1,:]+0.5,seg[i,0,:]+0.5,col) + ax[1].text(seg[i,1,~np.isnan(seg[i,1,:])][-1]+0.5,seg[i,0,~np.isnan(seg[i,1,:])][-1]+0.5,'%i' %i,color='w') + for i in range(active_detection.size): + if np.any(deactivate_segs_end.copy()==i): + mark = 'x' + elif np.any(deactivate_segs_ang.copy()==i): + mark = 'v' + elif np.any(deactivate_segs_muln.copy()==i): + mark = 's' + elif np.any(deactivate_segs_samehead.copy()==i): + mark = 'd' + else: + mark = '.' + if ~np.isnan(seg_append[i,1]): + ax[1].plot(seg_append[i,1]+0.5,seg_append[i,0]+0.5,color='r',marker=mark) + else: + ax[1].plot(seg[active_detection[i],1,-1]+0.5,seg[active_detection[i],0,-1]+0.5,color='r',marker=mark) + + ax[0].set_xlim([380,395]) + ax[0].set_ylim([180,197]) + for iax in ax: iax.set_aspect('equal') + + + + + # Test for multiple times same start + new_starts_unique, new_starts_counts = np.unique(np.ravel_multi_index((new_starts[:,0].astype('int'), + new_starts[:,1].astype('int')), + lkf_thin[1:-1,1:-1].shape), + return_counts=True) + + new_starts_unique = np.array([i_seg_start for i_seg_start in new_starts_unique if not np.any(seg_head_unique==i_seg_start)],dtype='int') + + # if np.any(new_starts_counts > 1): + # # print 'Warning: %i starting points arises maximum %i-times' %(np.sum(new_starts_counts>1), + # # np.max(new_starts_counts)) + # new_starts = np.vstack(np.unravel_index(new_starts_unique,lkf_thin[1:-1,1:-1].shape)).T + new_starts = np.vstack(np.unravel_index(new_starts_unique,lkf_thin[1:-1,1:-1].shape)).T + + # Append new positions of this detection step + num_new_starts = new_starts.shape[0] + # Initialize list of new segment elements + seg_append_time = np.empty((seg.shape[0],2))*np.NaN + seg_append_time[active_detection] = seg_append + seg_append_time = np.append(seg_append_time,new_starts,axis=0) + seg_old_shape = seg.shape[0] + # Fill up seg with NaNs for new starts + seg = np.append(seg,np.empty((num_new_starts,2,seg.shape[-1]))*np.NaN,axis=0) + # Append seg with new detected pixels + seg = np.append(seg,seg_append_time.reshape(seg_append_time.shape[0],2,1),axis=-1) + + # Deactivate segments if finished + active_detection_old = active_detection.copy() + if np.any([(deactivate_segs_muln.size > 0), + (deactivate_segs_ang.size > 0), + (deactivate_segs_end.size > 0), + (deactivate_segs_samehead.size > 0)]): + deactivate_segs = np.unique(np.append(deactivate_segs_muln, + np.append(deactivate_segs_ang,deactivate_segs_end))) + deactivate_segs = np.unique(np.hstack([deactivate_segs_muln,deactivate_segs_ang, + deactivate_segs_end,deactivate_segs_samehead])) + active_detection = np.delete(active_detection,deactivate_segs) # remove from active list + + # Activate new segments that started in this iteration + active_detection = np.append(active_detection,np.arange(seg_old_shape, seg_old_shape + num_new_starts)) + + # Compute number of undetected points and update ind + num_nodetect = np.sum(nodetect) + ind += 1 + + if ind > max_ind: + break + if active_detection.size == 0: + fac_starts = 100 + new_starts = np.append(np.rollaxis(np.array(np.where((nansum_neighbours(nodetect_intm)==3) & (nodetect==1))),1)[::fac_starts,:], + np.rollaxis(np.array(np.where((nansum_neighbours(nodetect_intm)==3) & (nodetect==1))),1)[1::fac_starts,:],axis=0) + + # Mark new starts as detected + if new_starts.size>0: + nodetect[new_starts[:,0].astype('int'),new_starts[:,1].astype('int')] = 0 + nodetect_intm[1:-1,1:-1] = nodetect.copy() + + # Add new generated end points as well + new_starts = np.append(new_starts,np.rollaxis(np.array(np.where((nansum_neighbours(nodetect_intm)<=2) & (nodetect==1))),1),axis=0) + + # Mark new starts as detected + if new_starts.size>0: + nodetect[new_starts[:,0].astype('int'),new_starts[:,1].astype('int')] = 0 + nodetect_intm[1:-1,1:-1] = nodetect.copy() + + # Test for multiple times same start + new_starts_unique, new_starts_counts = np.unique(np.ravel_multi_index((new_starts[:,0].astype('int'), + new_starts[:,1].astype('int')), + lkf_thin[1:-1,1:-1].shape), + return_counts=True) + if np.any(new_starts_counts > 1): + print ('Warning: %i starting points arises maximum %i-times' %(np.sum(new_starts_counts>1), + np.max(new_starts_counts))) + + # Append new positions of this detection step + num_new_starts = new_starts.shape[0] + seg_old_shape = seg.shape[0] + # Fill up seg with NaNs for new starts + seg = np.append(seg,np.empty((num_new_starts,2,seg.shape[-1]))*np.NaN,axis=0) + # Fill in new start values + seg[seg_old_shape:,:,-1] = new_starts + + # Activate new segments that started in this iteration + active_detection = np.append(active_detection,np.arange(seg_old_shape, seg_old_shape + num_new_starts)) + + + + if active_detection.size == 0: + break + + return seg + + + + + + + + + + +# ----------------- 3. Reconnection of segments---------------- +# ---------------- ( described in Section 3.1.3 ) ------------- + + + + +def elliptical_distance(seg_I,seg_II,ellp_fac=1,dis_thres=np.inf): + """ Function to compute the elliptical distance between two + segments, where the distance within the segment direction is + weighted by 1 and the direction perpendicular to the direction + by the factor 3. The weighted distance is computed from both + segments and averaged. If the first computation already exceeds + an threhold the second computation is skipped for efficiency. + + Input: seg_I - array with start and end coordinates of seg I + (rows dimension, column start-end) + seg_II - array with start and end coordinates of seg II + ellp_fac - weighting factor for ellipse + dis_thres - distance threshold to stop computation + + Output: dis - elliptical distance""" + + # Determine basis vectors along seg_I direction + e1 = (seg_I[:,0]-seg_I[:,1]) + e1 = (e1/np.sqrt(np.sum(e1**2))).reshape((2,1)) # Normalize basis vector + + e2 = np.dot(np.array([[0,-1],[1,0]]),e1) + + # Project connection vetor on basis vectors + coeff = np.linalg.solve(np.hstack([e1,e2]),(seg_II[:,0] - seg_I[:,0])) + + if coeff[0]<0: coeff[0] = np.inf + + # Compute weighted distance + d1 = np.sqrt(np.sum(coeff**2 * np.array([1,ellp_fac]))) + + if d1 <= dis_thres: + # Determine basis vectors along seg_II direction + e1 = (seg_II[:,0]-seg_II[:,1]) + e1 = (e1/np.sqrt(np.sum(e1**2))).reshape((2,1)) # Normalize basis vector + + e2 = np.dot(np.array([[0,-1],[1,0]]),e1) + + # Project connection vetor on basis vectors + coeff = np.linalg.solve(np.hstack([e1,e2]),(seg_I[:,0] - seg_II[:,0])) + + # Compute weighted distance + d2 = np.sqrt(np.sum(coeff**2 * np.array([1,ellp_fac]))) + + dis = 0.5*(d1+d2) + else: + dis = np.NaN + + return dis + + +def angle_segs(seg_I,seg_II): + """ Function to compute the angle between two segments. + + Input: seg_I - array with start and end coordinates of seg I + (rows dimension, column start-end) + seg_II - array with start and end coordinates of seg II + + Output: angle - angle between segments""" + + # Determine directions of segments + e1 = (seg_I[:,0]-seg_I[:,1]) + e1 = (e1/np.sqrt(np.sum(e1**2))) # Normalize basis vector + + f1 = (seg_II[:,0]-seg_II[:,1]) + f1 = (f1/np.sqrt(np.sum(f1**2))) # Normalize basis vector + + # Determine angle between both directions + angle = np.dot(e1,-f1) + angle = np.arccos(angle)/np.pi*180 + + return angle + + +def find_pos_connect(seg_I,segs,dis_thres): + """ Function to determine the possible connection segments + and to compute both corresponding starting point. The latter + information is given as arrays of the orientation where 1 means + that the current orientation has the starting point in the + first column and -1 that the starting point is in the second + column. These orientation can be used by indexing to flip the + the array to the right order [:,::i] where i=1,-1 + + Input: seg_I - array coordinates of seg I + (rows dimension, column start-end) + segs - array with arrays containing coordinates of other + segments + (number segments, rows dimension, column start-end) + + Output: ori_segI - required orientation of seg_I + ori_segs - required orientation of segs + mask - mask of all segments in segs that fulfill distance + criteria""" + + # Compute displacement from starting and end points in segs from start in seg_I + disp_start = np.rollaxis(np.rollaxis(segs,-1,start=1)-seg_I[:,0],-1,start=1) + + # Compute displacement from starting and end points in segs from end in seg_I + disp_end = np.rollaxis(np.rollaxis(segs,-1,start=1)-seg_I[:,1],-1,start=1) + + # # Filter for larger displacements than dis_thres + # mask = np.all([np.all(np.any(np.abs(disp_start)>dis_thres,axis=1),axis=1), + # np.all(np.any(np.abs(disp_end )>dis_thres,axis=1),axis=1)],axis=0) + # disp_start[mask,:,:] = np.NaN + # disp_end[mask,:,:] = np.NaN + + # Compute distance only for filtered displacements + dis = np.hstack([np.sqrt(np.sum(disp_start**2,axis=1)).reshape((segs.shape[0],1,2)), + np.sqrt(np.sum(disp_end**2, axis=1)).reshape((segs.shape[0],1,2))]) + + # Give out combination of orientation of segments with starting point being first column + ori_segI = np.argmin(dis,axis=1) + ori_segs = np.argmin(np.min(dis,axis=1),axis=1) + ori_segI = ori_segI[np.arange(ori_segs.size),ori_segs] + + # Filter for larger displacements than dis_thres + mask = np.all(np.abs(dis)>dis_thres,axis=(1,2)) + + return ori_segI, ori_segs, ~mask + + + +def compute_mn_eps(eps,seg): + eps_mn = np.zeros(len(seg)) + + for i in range(len(seg)): + eps_mn[i] = np.mean(eps[1:-1,1:-1][seg[i][0,:],seg[i][1,:]]) + + return eps_mn + + + +def compute_prob(seg_I,segs,eps_segI,eps_segs,dis_thres,angle_thres,eps_thres,ellp_fac=1): + """ Function to compute the probabilty for each segment in segs + to be a succession of seg_I given the critical parameters for + distance dis_thres, the angle angle_thres, and the deformation + rate eps_thres. + + Input: seg_I - array coordinates of seg I + (rows dimension, column start-end) + segs - array with arrays containing coordinates of other + segments + (number segments, rows dimension, column start-end) + eps_segI - mean deformation rate of seg_I + eps_seg - mean deformation rate of segs + ellp_fac - weighting factor for ellipse + dis_thres - distance threshold to stop computation + eps_thres - threshold difference in deformation rate + + Output: prob - probablility metric of segs, in second column + orientation information of segI and in third column + orientation information of the corresponding segment + from segs is stored in case of reconnection""" + + # 1. Check for similarity of deformation rates + p_eps = np.abs(eps_segs-eps_segI)/eps_thres + p_eps[p_eps > 1] = np.nan + + mask_eps = ~np.isnan(p_eps) + segs_i = segs[mask_eps] + + + # 2. Find corresponding starting and end points and first instance of + # distance thresholding + ori_segI, ori_segs, mask_dis_i = find_pos_connect(seg_I,segs_i,dis_thres) + + segs_i = segs_i[mask_dis_i] + ori_segI = ori_segI[mask_dis_i] + ori_segs = ori_segs[mask_dis_i] + + + # 3. Check angle between segments and angle thresholding + p_ang = np.zeros(p_eps.shape) * np.nan + mask_ang = np.zeros(segs_i.shape[0]).astype('bool') + + for i in range(segs_i.shape[0]): + # Resort arrays if necessary to have proper orientation with starting + # points + if ori_segI[i] == 1: + seg_I_i = seg_I[:,::-1].copy() + else: + seg_I_i = seg_I.copy() + if ori_segs[i] == 1: + seg_II_i = segs_i[i][:,::-1].copy() + else: + seg_II_i = segs_i[i].copy() + + # Determine angle + p_ang[np.arange(p_ang.size)[mask_eps][mask_dis_i][i]] = angle_segs(seg_I_i,seg_II_i)/angle_thres + mask_ang[i] = (p_ang[mask_eps][mask_dis_i][i]<=1) + + p_ang[p_ang>1] = np.nan + + segs_i = segs_i[mask_ang] + ori_segI = ori_segI[mask_ang] + ori_segs = ori_segs[mask_ang] + + + + # 4. Compute elliptical distance and final distance thresholding + p_dis = np.zeros(p_eps.shape) * np.nan + + for i in range(segs_i.shape[0]): + # Resort arrays if necessary to have proper orientation with starting + # points + if ori_segI[i] == 1: + seg_I_i = seg_I[:,::-1].copy() + else: + seg_I_i = seg_I.copy() + if ori_segs[i] == 1: + seg_II_i = segs_i[i][:,::-1].copy() + else: + seg_II_i = segs_i[i].copy() + + # Determine distance + p_dis[np.arange(p_dis.size)[mask_eps][mask_dis_i][mask_ang][i]] = elliptical_distance(seg_I_i,seg_II_i,ellp_fac=ellp_fac,dis_thres=dis_thres)/dis_thres + + p_dis[p_dis>1] = np.nan + + + # 5. Compute joint probability as sum of all three components + + prob = np.sqrt(p_eps**2 + p_ang**2 + p_dis**2) + + + # 6. Save orientation of the corresponding connection partners + ori_segI_all = np.zeros(prob.size) * np.nan + ori_segs_all = np.zeros(prob.size) * np.nan + ori_segI_all[np.arange(p_dis.size)[mask_eps][mask_dis_i][mask_ang]] = ori_segI + ori_segs_all[np.arange(p_dis.size)[mask_eps][mask_dis_i][mask_ang]] = ori_segs + + return np.rollaxis(np.stack([prob,ori_segI_all,ori_segs_all]),1) + + +def init_prob_matrix(segs,eps_segs,dis_thres,angle_thres,eps_thres,ellp_fac=1): + """ Function to initialize the probability matrix given the + probability of all possible combinations of segments to belong + to the same deformation feature. The probabilty matrix is a + upper triangular matrix with empty diagonal. + + Input: segs - array with arrays containing coordinates of + segments + (number segments, rows dimension, column start-end) + eps_seg - mean deformation rate of segs + ellp_fac - weighting factor for ellipse + dis_thres - distance threshold to stop computation + eps_thres - threshold difference in deformation rate + + Output: prob_ma - probablility matrics of segs""" + + + # 1. Initialize empty probability matrix + num_segs = segs.shape[0] + prob_ma = np.zeros((num_segs,num_segs,3)) * np.nan + + # 2. Loop over all segments an fill + for i_s in range(num_segs-1): + prob_ma[i_s,i_s+1:,:] = compute_prob(segs[i_s],segs[i_s+1:],eps_segs[i_s],eps_segs[i_s+1:],dis_thres,angle_thres,eps_thres,ellp_fac=ellp_fac) + + return prob_ma + +def update_segs(ind_connect,ori_connect,seg,segs,eps_segs,num_points_segs): + """ Function to update the list of segment seg, array of start + and end points segs, and the array of mean deformation rates. + + Input: ind_connect - index that were connected in this step + ori_connect - orientation of segmeents that are reconnected + ( 0 means orientation as given in segs is + right, if 1 segment needs to be reversed) + seg - list of segments + segs - array with arrays containing coordinates + of segments + (number segments, rows dimension, column start-end) + eps_segs - mean deformation rate of segs + num_points_segs - array of the number of points of all + segments + + Output: seg - updated list of segments + segs - updated array with arrays containing coordinates + of segments + (number segments, rows dimension, column start-end) + eps_segs - updated mean deformation rate of segs_up + num_points_segs - updated array of the number of points + of all segments""" + + # 1. Update list of segments seg + # - Update smaller index element + seg[ind_connect[0]] = np.append(seg[ind_connect[0]][:,::int(2*ori_connect[0]-1)], + seg[ind_connect[1]][:,::int(-2*ori_connect[1]+1)], + axis=1) + # - Remove larger index element + seg.pop(ind_connect[1]); + + + # 2. Update array of end and starting points + # - Update smaller index element + segs[ind_connect[0]] = np.stack([segs[ind_connect[0]][:,::int(2*ori_connect[0]-1)][:,0], + segs[ind_connect[1]][:,::int(-2*ori_connect[1]+1)][:,-1]]).T + # - Remove larger index element + segs = np.delete(segs,(ind_connect[1]),axis=0) + + + # 3. Update array of mean deformation rates + # - Update smaller index element + eps_segs[ind_connect[0]] = (((eps_segs[ind_connect[0]]*num_points_segs[ind_connect[0]]) + + (eps_segs[ind_connect[1]]*num_points_segs[ind_connect[1]]))/ + (num_points_segs[ind_connect[0]]+num_points_segs[ind_connect[1]])) + # - Remove larger index element + eps_segs = np.delete(eps_segs,(ind_connect[1]),axis=0) + + + # 4. Update array of number of points of all segments + # - Update smaller index element + num_points_segs[ind_connect[0]] = (num_points_segs[ind_connect[0]] + + num_points_segs[ind_connect[1]]) + # - Remove larger index element + num_points_segs = np.delete(num_points_segs,(ind_connect[1]),axis=0) + + + return seg, segs, eps_segs, num_points_segs + + +def update_prob_matrix(prob_ma,ind_connect,segs_up,eps_segs_up,dis_thres,angle_thres,eps_thres,ellp_fac=1): + """ Function to update the probability matrix given the + probability of all possible combinations of segments to belong + to the same deformation feature. Only the rows and columns + corresponding to indeces ind_connect are updated as the others + remain unchanged. The column and row corresponding to the larger + index ind_connect[1] are removed from the matrix and the others + are recalculated. As the orientation and deformation rate of the + newly reconnected segment besides its length might have changed + a new computation of the entire row is required instead of only + updating all non NaN values. + + Input: prob_ma - probablility matrics of segs + ind_connect - index that were connected in this step + segs_up - updated array with arrays containing coordinates + of segments + (number segments, rows dimension, column start-end) + eps_seg_up - updated mean deformation rate of segs_up + ellp_fac - weighting factor for ellipse + dis_thres - distance threshold to stop computation + eps_thres - threshold difference in deformation rate + + Output: prob_ma_up - probablility matrics of segs""" + + # 1. Remove column and row corresponding to the larger index + prob_ma = np.delete(np.delete(prob_ma,ind_connect[1],axis=0), + ind_connect[1],axis=1) + + # 2. Reevaluate the probabilty in the row for the lower index + i_s = ind_connect[0] + prob_ma[i_s,i_s+1:,:] = compute_prob(segs_up[i_s],segs_up[i_s+1:],eps_segs_up[i_s],eps_segs_up[i_s+1:],dis_thres,angle_thres,eps_thres,ellp_fac=ellp_fac) + prob_ma[:i_s,i_s,:] = compute_prob(segs_up[i_s],segs_up[:i_s],eps_segs_up[i_s],eps_segs_up[:i_s],dis_thres,angle_thres,eps_thres,ellp_fac=ellp_fac)[:,[0,2,1]] + + return prob_ma + + +def seg_reconnection(seg,segs,eps_segs,num_points_segs,dis_thres,angle_thres,eps_thres,ellp_fac=1): + """ Function that does the reconnection + + Input: seg - list of segments + segs - array with arrays containing coordinates + of segments + (number segments, rows dimension, column start-end) + eps_segs - mean deformation rate of segs + num_points_segs - array of the number of points of all + segments + angle_thres - angle threshold for reconnection + ellp_fac - weighting factor for ellipse + dis_thres - distance threshold for reconnection + eps_thres - threshold difference in deformation rate + + Output: seg - new list of reconnected segments""" + + + # 1. Initialize probability matrix + prob_ma = init_prob_matrix(segs,eps_segs,dis_thres,angle_thres,eps_thres,ellp_fac=ellp_fac) + + # 2. Loop over matrix and reconnect within one iteration the pair + # of segments that minimizes the probability matrix + + # - Loop parameters + ind = 0 + num_pos_reconnect = np.sum(prob_ma[:,:,0]<1) + max_ind = 500 + + # loop (break criteria: no connection possible or max iterations are reached) + while num_pos_reconnect >= 1: + + # 2.a. Find minimum of probability matrix + ind_connect = np.unravel_index(np.nanargmin(prob_ma[:,:,0]), + prob_ma[:,:,0].shape) + ori_connect = prob_ma[ind_connect][1:] + + # 2.b. Update segments + seg, segs, eps_segs, num_points_segs = update_segs(ind_connect,ori_connect,seg,segs,eps_segs,num_points_segs) + + # 2.c. Update probability matrix + prob_ma = update_prob_matrix(prob_ma,ind_connect,segs,eps_segs,dis_thres,angle_thres,eps_thres,ellp_fac=ellp_fac) + + # 2.d. Update loop parameters + ind += 1 + num_pos_reconnect = np.sum(prob_ma[:,:,0]<1) + + if ind>= max_ind: + break + + return seg + + + + + + + + + + + + + +# --------------- 5. Helper and filter functions ---------------- +# --------------------------------------------------------------- + + + +def filter_segs_lmin(seg,lmin): + """ Function to filter all segements in seg where the distance + between start and end point is below threshold lmin""" + return [i for i in seg if np.sqrt(np.sum((i[:,0]-i[:,-1])**2))>=lmin] + + + +def segs2latlon_rgps(segs,xg0,xg1,yg0,yg1,nxcell,nycell,m=mSSMI()): + """ Function that converts index format of detected LKFs to + lat,lon coordinates + """ + lon,lat = get_latlon_RGPS(xg0,xg1,yg0,yg1,nxcell,nycell,m=m) + segsf = [] + for iseg in segs: + segsf.append(np.concatenate([iseg, + np.stack([lon[iseg[0],iseg[1]], + lat[iseg[0],iseg[1]]])], + axis=0)) + return segsf + +def segs2eps(segs,epsI,epsII): + """ Function that saves for each point of each LKF the deformation + rates and attach them to segs. + """ + segsf = [] + for iseg in segs: + segsf.append(np.concatenate([iseg, + np.stack([epsI[iseg[0].astype('int'), + iseg[1].astype('int')], + epsII[iseg[0].astype('int'), + iseg[1].astype('int')]])], + axis=0)) + return segsf + + + + + + + +# ---------------- 6. Detection functions ------------------------------ +# ------------- ( described in Section 3.1 ) --------------------------- + + + +def lkf_detect_rgps(filename_rgps,max_kernel=5,min_kernel=1,dog_thres=0,dis_thres=4,ellp_fac=3,angle_thres=35,eps_thres=0.5,lmin=4,latlon=False,return_eps=False): + """Function that detects LKFs in input RGPS file. + + Input: filename_rgps - filename of RGPS deformation dataset + max_kernel - maximum kernel size of DoG filter + min_kernel - minimum kernel size of DoG filter + dog_thres - threshold for DoG filtering, pixels that + exceed threshold are marked as LKFs + angle_thres - angle threshold for reconnection + ellp_fac - weighting factor for ellipse + dis_thres - distance threshold for reconnection + eps_thres - threshold difference in deformation rate + lmin - minimum length of segments [in pixel] + latlon - option to return latlon information of LKFs + return_eps - option to return deformation rates of LKFs + + Output: seg - list of detected LKFs""" + + (div,xg0,xg1,yg0,yg1,nxcell,nycell) = read_RGPS(filename_rgps + ".DIV", land_fill=np.NaN, nodata_fill=np.NaN) + (shr,xg0,xg1,yg0,yg1,nxcell,nycell) = read_RGPS(filename_rgps + ".SHR", land_fill=np.NaN, nodata_fill=np.NaN) + + # Process deformation data + eps_tot = np.sqrt(div**2+shr**2) + + seg = lkf_detect_eps(eps_tot,max_kernel=max_kernel,min_kernel=min_kernel, + dog_thres=dog_thres,dis_thres=dis_thres, + ellp_fac=ellp_fac,angle_thres=angle_thres, + eps_thres=eps_thres,lmin=lmin) + + if latlon: + seg = segs2latlon_rgps(seg,xg0,xg1,yg0,yg1,nxcell,nycell,m=mSSMI()) + if return_eps: + return segs2eps(seg,div,shr) + else: + return seg + + +def lkf_detect_eps(eps_tot,max_kernel=5,min_kernel=1,dog_thres=0,dis_thres=4,ellp_fac=3,angle_thres=35,eps_thres=0.5,lmin=4): + """Function that detects LKFs in input RGPS file. + + Input: eps_tot - total deformation rate + max_kernel - maximum kernel size of DoG filter + min_kernel - minimum kernel size of DoG filter + dog_thres - threshold for DoG filtering, pixels that + exceed threshold are marked as LKFs + angle_thres - angle threshold for reconnection + ellp_fac - weighting factor for ellipse + dis_thres - distance threshold for reconnection + eps_thres - threshold difference in deformation rate + lmin - minimum length of segments [in pixel] + + Output: seg - list of detected LKFs""" + + ## Take natural logarithm + proc_eps = np.log(eps_tot) + proc_eps[~np.isfinite(proc_eps)] = np.NaN + ## Apply histogram equalization + proc_eps = hist_eq(proc_eps) + ## Apply DoG filter + lkf_detect = DoG_leads(proc_eps,max_kernel,min_kernel) + ### Filter for DoG>0 + lkf_detect = (lkf_detect > dog_thres).astype('float') + lkf_detect[~np.isfinite(proc_eps)] = np.NaN + ## Apply morphological thinning + lkf_thin = skimage.morphology.skeletonize(lkf_detect).astype('float') + + + # Segment detection + seg_f = detect_segments(lkf_thin) # Returns matrix fill up with NaNs + ## Convert matrix to list with arrays containing indexes of points + seg = [seg_f[i][:,~np.any(np.isnan(seg_f[i]),axis=0)].astype('int') + for i in range(seg_f.shape[0])] + ## Filter segments that are only points + seg = [i for i in seg if i.size>2] + + # 1st Reconnection of segments + eps_mn = compute_mn_eps(np.log10(eps_tot),seg) + num_points_segs = np.array([i.size/2. for i in seg]) + ## Initialize array containing start and end point of segments + segs = np.array([np.stack([i[:,0],i[:,-1]]).T for i in seg]) + + seg = seg_reconnection(seg,segs,eps_mn,num_points_segs,1.5, + 50,eps_thres,ellp_fac=1) + + # 2nd Reconnection of segments + eps_mn = compute_mn_eps(np.log10(eps_tot),seg) + num_points_segs = np.array([i.size/2. for i in seg]) + ## Initialize array containing start and end point of segments + segs = np.array([np.stack([i[:,0],i[:,-1]]).T for i in seg]) + + seg = seg_reconnection(seg,segs,eps_mn,num_points_segs,dis_thres, + angle_thres,eps_thres,ellp_fac=ellp_fac) + + # Filter too short segments + seg = filter_segs_lmin(seg,lmin) + + # Convert to indexes of the original input image + seg = [segi+1 for segi in seg] + + return seg + diff --git a/lkf_tools/rgps.py b/lkf_tools/rgps.py new file mode 100644 index 0000000..ea11f37 --- /dev/null +++ b/lkf_tools/rgps.py @@ -0,0 +1,312 @@ +# -*- coding: utf-8 -*- + +""" +All functions used to read and georeference RGPS data. +""" + + +# Package Metadata +__version__ = 0.1 +__author__ = "Nils Hutter" +__author_email__ = "nhutter@uw.edu" + + +import numpy as np +import matplotlib.pylab as plt +import os +import sys +from multiprocessing import Pool +import warnings +#from mpl_toolkits.basemap import Basemap # need to be replaced! +from pyproj import Proj + + +# --------------- 1. RGPS read and georeference functions -------------- +# ---------------------------------------------------------------------- + + + +def read_RGPS(filename,land_fill=1e10,nodata_fill=1e20): + RGPS_file = open(filename,'r',encoding= 'unicode_escape') + + # RGPS product header + dxg=0. #Size of x cell in product + dyg=0. #Size of y cell in product + xg0=0. #Map location of x lower left + yg0=0. #Map location of y lower left + xg1=0. #Map location of x higher right + yg1=0. #Map location of y higher right + nxcell=0 #x cells dimensional array + nycell=0 #y cells dimensional array + + dxg,dyg,xg0,yg0,xg1,yg1 = RGPS_file.readline().strip().split() + nxcell,nycell = RGPS_file.readline().strip().split() + + data = np.fromfile(RGPS_file,np.float32).reshape(int(nycell),int(nxcell)) + + if sys.byteorder == 'little': data.byteswap(True) + + data[data==1e10] = land_fill + data[data==1e20] = nodata_fill + + return data, float(xg0), float(xg1), float(yg0), float(yg1), int(nxcell), int(nycell) + + +def mSSMI(): + ''' Returns the SSMI grid projection used for RGPS data + as Basemap class + ATTENION: for coordinate transform from RGPS coordinate + m(0,90) must be added, because in RGPS NP is the origin''' + return Proj(proj='stere',lat_0=90, lat_ts=75, lon_0=-45, ellps='WGS84')#Basemap(projection='stere',lat_ts=70,lat_0=90,lon_0=-45,resolution='l',llcrnrlon=279.26-360,llcrnrlat=33.92,urcrnrlon=102.34,urcrnrlat=31.37,ellps='WGS84') + + + +def get_latlon_RGPS(xg0,xg1,yg0,yg1,nxcell,nycell,m=mSSMI()): + # Gives only rough estimate, better use SSM/I POLAR STEREOGRAPHIC PROJECTION + x = np.linspace(xg0,xg1,nxcell+1); x = 0.5*(x[1:]+x[:-1]) + y = np.linspace(yg0,yg1,nycell+1); y = 0.5*(y[1:]+y[:-1]) + x,y = np.meshgrid(x,y) + #xpol,ypol = m(0,90) + #lon,lat = m(x*1e3 + xpol, y*1e3 + ypol,inverse=True) + lon,lat = m(x*1e3, y*1e3,inverse=True) + return lon, lat + + + +# --------------- 1. lagranian RGPS read and interpolate functions ----- +# ---------------------------------------------------------------------- + + + +def read_RGPS_lag_motion(filename): + RGPS_file = open(filename,'r') + + # RGPS product identifier + idf_id='123456789012345678901234' + # Description of this product + prod_desc='1234567890123456789012345678901234567890' + # Number of images used in the creation of this product + n_images = np.int16(0) + # Number of trajectories in this product + n_trajectories = np.int32(0) + # Product Type + prod_type='12345678' + # Product creation year/time + create_year = np.int16(0) + create_time = np.float64(0) + # Season start year/time + season_start_year = np.int16(0) + season_start_time = np.float64(0) + # Season end year/time + season_end_year = np.int16(0) + season_end_time = np.float64(0) + # Software version used to create this product + sw_version = '123456789012' + #Northwest Lat/Long of initial datatake + n_w_lat = np.float32(0) ; n_w_lon = np.float32(0) + #Northeast Lat/Long of initial datatake + n_e_lat = np.float32(0) ; n_e_lon = np.float32(0) + #Southwest Lat/Long of initial datatake + s_w_lat = np.float32(0) ; s_w_lon = np.float32(0) + #Southeast Lat/Long of initial datatake + s_e_lat = np.float32(0) ; s_e_lon = np.float32(0) + + #======================================================= + # AREA CHANGE and ICE MOTION DERIVATIVES DATA + #======================================================= + # Cell identifier + gpid = np.int32(0) + # Birth and Death year/time of gridpoint + birth_year = np.int16(0) ; birth_time = np.float64(0) + death_year = np.int16(0) ; death_time = np.float64(0) + # Number of observations of cell + n_obs = np.int32(0) + # Year/Time of observation + obs_year = np.int16(0) ; obs_time = np.float64(0) + # Map location of observation + x_map = np.float64(0) ; y_map = np.float64(0) + # Quality Flag of observation + q_flag = np.int16(0) + # Only the first 3 cells in this product will be printed out + max_read_cell = 3 + + # ======================================================= + # ASF image identifier + image_id = '1234567890123456' + # Image center year/time + image_year = np.int16(0) ; image_time = np.float64(0) + # Image center location + map_x = np.float64(0) ; map_y = np.float64(0) + + + para_val = [idf_id,prod_desc,n_images,n_trajectories,prod_type, + create_year,create_time, + season_start_year,season_start_time, + season_end_year, season_end_time, + sw_version, + n_w_lat,n_w_lon, n_e_lat,n_e_lon, + s_w_lat,s_w_lon, s_e_lat,s_e_lon] + para_name = ['idf_id','prod_desc','n_images','n_trajectories','prod_type', + 'create_year','create_time', + 'season_start_year','season_start_time', + 'season_end_year',' season_end_time', + 'sw_version', + 'n_w_lat','n_w_lon',' n_e_lat','n_e_lon', + 's_w_lat','s_w_lon',' s_e_lat','s_e_lon'] + + for ip in range(len(para_val)): + if para_val[ip] == 0: + para_val[ip] = np.fromfile(RGPS_file,np.dtype(para_val[ip]),1).byteswap(True) + else: + para_val[ip] = RGPS_file.read(len(para_val[ip])) + + # Read image data + n_images = para_val[2] + + image_para_val_org = [image_id,image_year,image_time,map_x,map_y] + + image_para_val = [image_id,image_year,image_time,map_x,map_y] + + image_data = [] + + for ii in range(n_images): + image_para_val = [] + + # Read header: + for ip in range(len(image_para_val_org)): + if image_para_val_org[ip] == 0: + image_para_val.append(np.fromfile(RGPS_file,np.dtype(image_para_val_org[ip]),1).byteswap(True)) + else: + image_para_val.append(RGPS_file.read(len(image_para_val_org[ip]))) + + image_data.append(image_para_val) + + + # Read ice motion data + cell_para_val_org = [gpid,birth_year,birth_time,death_year,death_time,n_obs] + + cell_para_val = [gpid,birth_year,birth_time,death_year,death_time,n_obs] + + data_para_val_org = [obs_year,obs_time, + x_map,y_map, + q_flag] + + data_para_val = [obs_year,obs_time, + x_map,y_map, + q_flag] + + cell_data = [] + + n_cells = para_val[3] + + for ic in range(n_cells): + cell_para_val = np.copy(cell_para_val_org) + + # Read header: + for ip in range(len(cell_para_val)): + cell_para_val[ip] = np.fromfile(RGPS_file,np.dtype(cell_para_val_org[ip]),1).byteswap(True) + + + # Read data + n_obs = cell_para_val[-1] + data_list = [] + for id in range(int(n_obs)): + data_para_val = np.copy(data_para_val_org) + for ip in range(len(data_para_val)): + readout = np.fromfile(RGPS_file,np.dtype(data_para_val_org[ip]),1).byteswap(True) + data_para_val[ip] = readout + #data_para_val[ip] = np.fromfile(RGPS_file,np.dtype(data_para_val_org[ip]),1).byteswap(True) + data_list.append(data_para_val) + + cell_data.append([cell_para_val, np.array(data_list)]) + + return para_name, para_val, image_data, cell_data + + + + + +def get_icemotion_RGPS(RGPS_path,stream='None'): + ''' Function that reads in all RGPS files in directory (most probably month) and + saves them in gridded format''' + + if not RGPS_path.endswith('/'): + RGPS_path += '/' + + if stream != 'None': + icemotion_files = [f for f in os.listdir(RGPS_path) if f.endswith('.LP') and f.startswith('R1001'+stream)] + else: + icemotion_files = [f for f in os.listdir(RGPS_path) if f.endswith('.LP')] + + motion_data = [] + + for iif in range(len(icemotion_files)): + para_name, para_val, image_data, cell_data = read_RGPS_lag_motion(RGPS_path + icemotion_files[iif]) + + motion_data += cell_data + + + gid = np.zeros((len(motion_data),1)) # List of all grid cell IDs + nobs = np.zeros((len(motion_data),1)) # List of number of observations at all grid cell IDs + + for it in range(len(motion_data)): + gid[it] = motion_data[it][0][0] + nobs[it] = motion_data[it][0][5] + + # Test for double mentioning of grid IDs + if np.unique(gid).size != gid.size: + gcids,n_gcids = np.unique(gid,return_index=True) + print('ERROR: grid cell IDs: ' + str(gcids[n_gcids!=1]) + ' are more than once in the dataset') + + return motion_data + + + +def get_icemotion_RGPS_season(season_path,stream='None'): + ''' Function that reads in all RGPS files for one season (each month in + one directory and saves them in gridded format (GID,year,day,x,y,qflag) + + Note as RGPS positions are saved cummulative for month only last month + of season is read, because it contains the entire season''' + + if not season_path.endswith('/'): + season_path += '/' + + month_path = [f for f in os.listdir(season_path)] + + month_rgps = ['may', 'apr', 'mar', 'feb', 'jan', 'dec', 'nov'] + + for im in range(len(month_rgps)): + if np.any(np.array(month_path)==month_rgps[im]): + imonth = np.where(np.array(month_path)==month_rgps[im])[0][0] + break + + print('Read last month available for season: ' + month_path[imonth]) + motion_data = [] + if stream != 'None': + motion_data += get_icemotion_RGPS(season_path + month_path[imonth],stream=stream) + else: + motion_data += get_icemotion_RGPS(season_path + month_path[imonth]) + + gid_org = np.zeros((len(motion_data),1)) # List of all grid cell IDs + nobs_org = np.zeros((len(motion_data),1)) # List of number of observations at all grid cell IDs + + for it in range(len(motion_data)): + gid_org[it] = motion_data[it][0][0] + nobs_org[it] = motion_data[it][0][5] + + gid, gid_ind = np.unique(gid_org,return_index=True) + nobs = np.zeros(gid.shape) + for it in range(gid.size): + nobs[it] = np.sum(nobs_org[gid_org==gid[it]]) + + icemotion_data = np.zeros((gid.size,np.int(nobs.max()),5))*np.nan # obs_year,obs_time,x_map,y_map,q_flag + + for it_id in range(gid.size): + cur_ind = 0 + for it in np.where(gid_org==gid[it_id])[0]: + icemotion_data[it_id,cur_ind:cur_ind+np.int(nobs_org[it])] = motion_data[it][1] + cur_ind += np.int(nobs_org[it]) + + return icemotion_data + diff --git a/lkf_tools/tracking.py b/lkf_tools/tracking.py new file mode 100644 index 0000000..d349619 --- /dev/null +++ b/lkf_tools/tracking.py @@ -0,0 +1,305 @@ +# -*- coding: utf-8 -*- + +""" +Tracking routines to follow detected LKFs in time using drift data. +""" + + +# Package Metadata +__version__ = 0.1 +__author__ = "Nils Hutter" +__author_email__ = "nhutter@uw.edu" + + + + +import numpy as np +import matplotlib.pylab as plt + +from lkf_detection import * + + + + +# ------------------- 0. Helper Functions + +def compute_MHD_segment(A,B,return_overlap=False,overlap_thres=2,angle_thres=45,return_overlaping_area=False): + """ Function to compute Modified Hausdorff Distnce between two + segments. + Following: Marie-Pierre Dubuisson and Anil K. Jain: A Modified + Hausdorff Distance for Object Matching, 1994 + + Input : A,B - two segments + return_part_overlap - optinal: return number of pixels + that partly overlap between segments + overlap_thres - threshold what defines overlap + Output: mhd, pixel_overlap(optional)""" + daB = np.array([np.min(np.sqrt(np.sum((B.T-a)**2,axis=1))) for a in A.T]) + dbA = np.array([np.min(np.sqrt(np.sum((A.T-b)**2,axis=1))) for b in B.T]) + + if return_overlap: + overlap = np.min([(daB <= overlap_thres).sum(), + (dbA <= overlap_thres).sum()]) + if overlap>1: + A_o = A[:,daB <= overlap_thres] + B_o = B[:,dbA <= overlap_thres] + # Filter two large angles + angle = angle_segs(A_o[:,[0,-1]],B_o[:,[0,-1]]) + if angle > 90: angle = 180-angle + if angle >= angle_thres: overlap = 0 + if return_overlaping_area: + return np.max([(daB.sum()/ A.shape[1]),(dbA.sum()/ B.shape[1])]), overlap, [A_o,B_o] + else: + return np.max([(daB.sum()/ A.shape[1]),(dbA.sum()/ B.shape[1])]), overlap + else: + overlap = 0 + if return_overlaping_area: + return np.max([(daB.sum()/ A.shape[1]),(dbA.sum()/ B.shape[1])]), overlap, [np.array([]),np.array([])] + else: + return np.max([(daB.sum()/ A.shape[1]),(dbA.sum()/ B.shape[1])]), overlap + + else: + return np.max([(daB.sum()/ A.shape[1]),(dbA.sum()/ B.shape[1])]) + + + + + + + + +# ------------------- 1. Tracking function + +def track_lkf(lkf0_d, lkf1, nx, ny, thres_frac=0.75, min_overlap=4,first_overlap=False,overlap_thres=1.5,angle_thres=25.,search_area_expansion=1): + """Tracking function for LKFs + + Input: lkf0_d: advected detected LKF features + lkf1: detected LKF features as a list of arrays that contain to indices of all cell containing to one LKF + + Output: lkf_track_pairs: List with pairs of indexes to LKFs in lkf0 that are tracked in lkf1 + """ + + # ----------------------- Define index grid ----------------------------- + + xgi = np.linspace(1,nx,nx)-1 + ygi = np.linspace(1,ny,ny)-1 + XGi,YGi = np.meshgrid(xgi,ygi) + + + # -------------- First rough estimate of drifted LKFs ------------------- + + lkf_track_pairs = [] + #thres_frac = 0.75 + #min_overlap = 4 + + for ilkf,iseg_d in enumerate(lkf0_d): + + if ~np.any(np.isnan(iseg_d)): + # Define search area + search_area = np.concatenate([np.floor(iseg_d),np.ceil(iseg_d), + np.vstack([np.floor(iseg_d)[:,0],np.ceil(iseg_d)[:,1]]).T, + np.vstack([np.ceil(iseg_d)[:,0],np.floor(iseg_d)[:,1]]).T], + axis=0) # Floor and ceil broken indexes + # Broadening of search area + #search_area_expansion = 1 # Number of cell for which the search area is expanded to be consider differences in the morphological thinning + for i in range(search_area_expansion): + n_rows = search_area[:,0].size + search_area = np.concatenate([search_area, + search_area+np.concatenate([np.ones(n_rows).reshape((n_rows,1)), + np.zeros(n_rows).reshape((n_rows,1))],axis=1), + search_area+np.concatenate([-np.ones(n_rows).reshape((n_rows,1)), + np.zeros(n_rows).reshape((n_rows,1))],axis=1), + search_area+np.concatenate([np.zeros(n_rows).reshape((n_rows,1)), + np.ones(n_rows).reshape((n_rows,1))],axis=1), + search_area+np.concatenate([np.zeros(n_rows).reshape((n_rows,1)), + np.ones(n_rows).reshape((n_rows,1))],axis=1), + search_area+np.concatenate([np.ones(n_rows).reshape((n_rows,1)), + np.ones(n_rows).reshape((n_rows,1))],axis=1), + search_area+np.concatenate([np.ones(n_rows).reshape((n_rows,1)), + -np.ones(n_rows).reshape((n_rows,1))],axis=1), + search_area+np.concatenate([-np.ones(n_rows).reshape((n_rows,1)), + np.ones(n_rows).reshape((n_rows,1))],axis=1), + search_area+np.concatenate([-np.ones(n_rows).reshape((n_rows,1)), + -np.ones(n_rows).reshape((n_rows,1))],axis=1)],axis=0) + + search_area = np.unique(search_area, axis=0) + + search_area = search_area[np.all(search_area>=0,axis=1),:] + search_area = search_area[np.all([search_area[:,0]=2: + coeff = np.squeeze(np.linalg.solve(np.dot(A.T,A),np.dot(A.T,b))) + + if coeff[0]!=0: + ## Define boundary lines at both endpoints + ### determine line through endpoint #1 + x1 = iseg_d[0,0]; y1 = iseg_d[0,1] + a = -1/coeff[0] + b1 = y1 - a*x1 + f1 = a*XGi + b1 - YGi + + ### determine line through endpoint #2 + x2 = iseg_d[-1,0]; y2 = iseg_d[-1,1] + b2 = y2 - a*x2 + f2 = a*XGi + b2 -YGi + + ## Define mask of orthogonal area + orth_area = ((f1>0) & (f2<0)) | ((f1<0) & (f2>0)) + elif coeff[0]==0: # LKF parallel to x axis + orth_area = ((XGi >= np.min([iseg_d[0,0],iseg_d[-1,0]])) & + (XGi <= np.max([iseg_d[0,0],iseg_d[-1,0]]))) + else: # LKF parallel to y axis + orth_area = ((YGi >= np.min([iseg_d[0,1],iseg_d[-1,1]])) & + (YGi <= np.max([iseg_d[0,1],iseg_d[-1,1]]))) + + orth_area = np.concatenate([XGi[orth_area].reshape((XGi[orth_area].size,1)), + YGi[orth_area].reshape((YGi[orth_area].size,1))],axis=1) + + + # Ravel indeces to 1D index for faster comparison + orth_area_ravel = [] + for io in range(orth_area.shape[0]): + orth_area_ravel.append(np.ravel_multi_index(orth_area[io,:].astype('int'), + np.transpose(XGi).shape)) + search_area_ravel = [] + for io in range(search_area.shape[0]): + search_area_ravel.append(np.ravel_multi_index(search_area[io,:].astype('int'), + np.transpose(XGi).shape)) + search_area_ravel = list(set(search_area_ravel).intersection(orth_area_ravel)) + search_area = np.zeros((len(search_area_ravel),2)) + for io in range(search_area.shape[0]): + search_area[io,:] = np.unravel_index(search_area_ravel[io],np.transpose(XGi).shape) + + + # Loop over all LKFs to check whether there is overlap with search area + for i in range(lkf1.shape[0]): + lkf_ravel = [] + for io in range(lkf1[i].shape[0]): + lkf_ravel.append(np.ravel_multi_index(lkf1[i][io,:].astype('int'), + np.transpose(XGi).shape)) + + comb_seg_search_area, comb_seg_search_area_count = np.unique(search_area_ravel+lkf_ravel, + return_counts=True) + + # Check for overlap + if np.any(comb_seg_search_area_count > 1): + # LKF1[i] is overlapping with search area + num_points_overlap = np.sum(comb_seg_search_area_count>1) + + if first_overlap: + if (num_points_overlap >= min_overlap): + # Test again with overlap: + A = iseg_d.T + B = np.stack(np.unravel_index(comb_seg_search_area[comb_seg_search_area_count>1], + np.transpose(XGi).shape)) + mhdi, overlap_i = compute_MHD_segment(A,B,return_overlap=True, + overlap_thres=overlap_thres, + angle_thres=angle_thres) + if overlap_i>=min_overlap: + lkf_track_pairs.append(np.array([ilkf,i])) + else: + # Check in orthogonal area of LKF + comb_seg_orth_area, comb_seg_orth_area_count = np.unique(orth_area_ravel+lkf_ravel, + return_counts=True) + num_points_overlap_orth = np.sum(comb_seg_orth_area_count>1) + frac_search_to_orth = num_points_overlap/float(num_points_overlap_orth) + + if (frac_search_to_orth > thres_frac) & (num_points_overlap >= min_overlap): + # Test again with overlap: + A = iseg_d.T + B = np.stack(np.unravel_index(comb_seg_orth_area[comb_seg_orth_area_count>1], + np.transpose(XGi).shape)) + mhdi, overlap_i = compute_MHD_segment(A,B,return_overlap=True, + overlap_thres=overlap_thres, + angle_thres=angle_thres) + if overlap_i>=min_overlap: + lkf_track_pairs.append(np.array([ilkf,i])) + + + return lkf_track_pairs + + + + +# ------------------- 2. Drift functions + +def drift_estimate_rgps(lkf0_path,drift_path,read_lkf0=None): + """Function that computes the position of LKFs after a certain time + considering the drift + + Input: lkf0_path - filename of lkf0 including path + drift_path - directory where drift data is stored including prefix + + Output: lkf0_d - drifted LKFs from lkf0""" + + # Read in lkf0 + if read_lkf0 is None: + lkf0 = np.load(lkf0_path) + else: + lkf0 = read_lkf0 + + # Read in drift data + drift = np.load(drift_path + lkf0_path[-19:]) + + # Compute drift estimate + t = 3*24.*3600. + res = 12.5e3 + lkf0_d = [] + for ilkf,iseg in enumerate(lkf0): + iseg_d = drift[iseg[:,0].astype('int'),iseg[:,1].astype('int'),:]*t/res + iseg[:,:2] + lkf0_d.append(iseg_d) + + return lkf0_d + + + + +# ------------------- 3. Generate tracking dataset +def gen_tracking_dataset_rgps(lkf_path,drift_path,output_path): + """Function that generates tracking data set + + Input: lkf_path - directory including all LKF files for season + drift_path - directory where drift data is stored including prefix + output_path - directory where output is stored + """ + + nx = 264; ny = 248 + + lkf_filelist = [i for i in os.listdir(lkf_path) if i.startswith('lkf') and i.endswith('.npy')] + lkf_filelist.sort() + + for ilkf in range(len(lkf_filelist[:-1])): + print("Track features in %s to %s" %(lkf_filelist[ilkf], + lkf_filelist[ilkf+1])) + # Open lkf0 and compute drift estimate + lkf0_d = drift_estimate_rgps(lkf_path + lkf_filelist[ilkf],drift_path) + + # Read LKFs + lkf1 = np.load(lkf_path + lkf_filelist[ilkf+1]) + # lkf1_l = [] + # for ilkf,iseg in enumerate(lkf1): + # lkf1_l.append(iseg[:,:2]) + lkf1_l = lkf1 + for ilkf1,iseg in enumerate(lkf1): + lkf1_l[ilkf1] = iseg[:,:2] + + # Compute tracking + tracked_pairs = track_lkf(lkf0_d, lkf1_l, nx, ny, thres_frac=0.75, min_overlap=4,overlap_thres=1.5,angle_thres=25) + + # Save tracked pairs + np.save(output_path + 'lkf_tracked_pairs_%s_to_%s' %(lkf_filelist[ilkf][4:-4], + lkf_filelist[ilkf+1][4:-4]), + tracked_pairs) + + diff --git a/notebooks/detection_tutorial.ipynb b/notebooks/detection_tutorial.ipynb new file mode 100644 index 0000000..924556a --- /dev/null +++ b/notebooks/detection_tutorial.ipynb @@ -0,0 +1,139 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 3, + "id": "f00f91bc-66b9-45a6-acd5-30de3f7b9b0b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The autoreload extension is already loaded. To reload it, use:\n", + " %reload_ext autoreload\n" + ] + } + ], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2\n", + "\n", + "from lkf_tools.detection import *\n", + "from lkf_tools.rgps import *" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "54c5e173-a2af-4668-ada2-4c21c02c3e78", + "metadata": {}, + "outputs": [], + "source": [ + "test = read_RGPS('../data/RGPS/2005363_2006001.DIV')" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "79fa5296-7b35-4e30-86a1-3e9ee514eefd", + "metadata": {}, + "outputs": [], + "source": [ + "rfile = open('../data/RGPS/2005363_2006001.DIV','r',encoding= 'unicode_escape')" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "fc2d3b14-b4f7-4cc0-a4bb-63f1668f6561", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(array([[1.e+10, 1.e+10, 1.e+10, ..., 1.e+20, 1.e+20, 1.e+20],\n", + " [1.e+10, 1.e+10, 1.e+10, ..., 1.e+20, 1.e+20, 1.e+20],\n", + " [1.e+10, 1.e+10, 1.e+10, ..., 1.e+20, 1.e+20, 1.e+20],\n", + " ...,\n", + " [1.e+20, 1.e+20, 1.e+20, ..., 1.e+10, 1.e+10, 1.e+10],\n", + " [1.e+20, 1.e+20, 1.e+20, ..., 1.e+10, 1.e+10, 1.e+10],\n", + " [1.e+20, 1.e+20, 1.e+20, ..., 1.e+10, 1.e+10, 1.e+10]],\n", + " dtype=float32),\n", + " -2300.0,\n", + " 1000.0,\n", + " -1000.0,\n", + " 2100.0,\n", + " 264,\n", + " 248)" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "test" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "f611e408-c093-43b4-a813-ea9e9ce5ac2e", + "metadata": {}, + "outputs": [], + "source": [ + "lon,lat = get_latlon_RGPS(test[1],test[2],test[3],test[4],test[5],test[6])" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "7a2ff405-d095-4023-aef6-96f259a2fe7b", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "62.24692249540107" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "52d75568-ce42-42e3-bb71-742a25469b82", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.10.2" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/setup.cfg b/setup.cfg index fda7e90..190d59a 100644 --- a/setup.cfg +++ b/setup.cfg @@ -63,6 +63,8 @@ install_requires = netCDF4 datetime scikit-image + pyproj + cartopy setup_requires= setuptools_scm python_requires = >=3.6 From aac0277b6ba8caefc1f60a9aee23ca61401ef18e Mon Sep 17 00:00:00 2001 From: Nils Hutter Date: Mon, 14 Mar 2022 21:26:51 -0700 Subject: [PATCH 04/21] Created dataset module to process entire data set --- lkf_tools/dataset.py | 209 +++++++++ lkf_tools/detection.py | 91 +++- lkf_tools/rgps.py | 1 + lkf_tools/tracking.py | 2 +- notebooks/detection_tutorial.ipynb | 705 ++++++++++++++++++++++++++++- 5 files changed, 999 insertions(+), 9 deletions(-) create mode 100644 lkf_tools/dataset.py diff --git a/lkf_tools/dataset.py b/lkf_tools/dataset.py new file mode 100644 index 0000000..02af9f2 --- /dev/null +++ b/lkf_tools/dataset.py @@ -0,0 +1,209 @@ +# -*- coding: utf-8 -*- + +""" +Routines to process deformation and drift data and generate LKF data set +""" + + +# Package Metadata +__version__ = 0.1 +__author__ = "Nils Hutter" +__author_email__ = "nhutter@uw.edu" + + +import numpy as np +import matplotlib.pylab as plt +import os +import sys +from multiprocessing import Pool +import warnings +from pathlib import Path + +import xarray as xr + +from .detection import * +from .tracking import * +from .rgps import * + + + +class process_dataset(object): + """ + Class to process deformation and drift dataset to LKF data set. + """ + def __init__(self,netcdf_file,output_path='./',max_kernel=5,min_kernel=1, + dog_thres=0.01,dis_thres=4,ellp_fac=2,angle_thres=45, + eps_thres=1.25,lmin=3,latlon=True,return_eps=True,red_fac=1,t_red=3): + """ + Processes deformation and drift dataset to LKF data set + + netcdf_file: expected variables U,V,A in shape (time,x,y) + """ + # Set output path + self.lkfpath = Path(output_path).joinpath(netcdf_file.split('.')[0]) + for lkfpathseg in str(self.lkfpath.absolute()).split('/'): + if not os.path.exists(self.lkfpath): + os.mkdir(self.lkfpath) + + # Store detection parameters + self.max_kernel = max_kernel + self.min_kernel = min_kernel + self.dog_thres = dog_thres + self.dis_thres = dis_thres + self.ellp_fac = ellp_fac + self.angle_thres = angle_thres + self.eps_thres = eps_thres + self.lmin = lmin + self.latlon = latlon + self.return_eps = return_eps + self.red_fac = red_fac + self.t_red = t_red + + + # Read netcdf file + self.netcdf_file = netcdf_file + self.data = xr.open_dataset(self.netcdf_file) + + # Store variables + self.time = self.data.time + self.lon = self.data.ULON + self.lat = self.data.ULAT + + self.lon = self.lon.where(self.lon<=1e30); self.lat = self.lat.where(self.lat<=1e30); + self.lon = self.lon.where(self.lon<180,other=self.lon-360) + + if hasattr(self.data,'DXU') and hasattr(self.data,'DYV'): + self.dxu = self.data.DXU + self.dyu = self.data.DYV + else: + print("ERROR: DXU and DYU are missing in netcdf file!") + print(" --> Compute dxu and dyu from lon,lat using SSMI projection") + m = mSSMI() + x,y = m(self.lon,self.lat) + self.dxu = np.sqrt((x[:,1:]-x[:,:-1])**2 + (y[:,1:]-y[:,:-1])**2) + self.dxu = np.concatenate([self.dxu,self.dxu[:,-1].reshape((self.dxu.shape[0],1))],axis=1) + self.dyu = np.sqrt((x[1:,:]-x[:-1,:])**2 + (y[1:,:]-y[:-1,:])**2) + self.dyu = np.concatenate([self.dyu,self.dyu[-1,:].reshape((1,self.dyu.shape[1]))],axis=0) + + + # Generate Arctic Basin mask + self.mask = ((((self.lon > -120) & (self.lon < 100)) & (self.lat >= 80)) | + ((self.lon <= -120) & (self.lat >= 70)) | + ((self.lon >= 100) & (self.lat >= 70))) + self.index_x = np.where(np.sum(self.mask[1:-1,1:-1],axis=0)>0) + self.index_y = np.where(np.sum(self.mask[1:-1,1:-1],axis=1)>0) + + + def detect_lkfs(self,indexes=None,force_redetect=False): + """ + Detects LKFs in data set given in netcdf file + + :param indexes: time indexes that should be detected. If None all time steps are detected + """ + + # Check for already dectected features + if force_redetect: + self.lkf_filelist = [i for i in os.listdir(self.lkfpath) if i.startswith('lkf') and i.endswith('.npy')] + self.lkf_filelist.sort() + self.ind_detect = [int(i.split('.')[0].split('_')[-1]) for i in self.lkf_filelist] + else: + self.ind_detect = [] + + if indexes is None: + self.indexes = np.arange(time.size/self.t_red) + else: + self.indexes = indexes + + for it in [j for j in self.indexes if j+1 not in self.ind_detect]: + + print("Compute deformation rates and detect features for day %i" %(it+1)) + + self.eps_tot_list = [] + + for itr in range(self.t_red): + # Read in velocities + uice = self.data.U[it+itr,:,:] + vice = self.data.V[it+itr,:,:] + aice = self.data.A[it+itr,:,:] + + # Check if deformation rates are given + if hasattr(self.data,'div') and hasattr(self.data,'shr'): + div = self.data.div[it+itr,:,:] + shr = self.data.shr[it+itr,:,:] + else: + dudx = ((uice[2:,:]-uice[:-2,:])/(self.dxu[:-2,:]+self.dxu[1:-1,:]))[:,1:-1] + dvdx = ((vice[2:,:]-vice[:-2,:])/(self.dxu[:-2,:]+self.dxu[1:-1,:]))[:,1:-1] + dudy = ((uice[:,2:]-uice[:,:-2])/(self.dyu[:,:-2]+self.dyu[:,1:-1]))[1:-1,:] + dvdy = ((vice[:,2:]-vice[:,:-2])/(self.dyu[:,:-2]+self.dyu[:,1:-1]))[1:-1,:] + + div = (dudx + dvdy) * 3600. *24. # in day^-1 + shr = np.sqrt((dudx-dvdy)**2 + (dudy + dvdx)**2) * 3600. *24. # in day^-1 + + eps_tot = np.sqrt(div**2+shr**2) + + eps_tot = eps_tot.where((aice[1:-1,1:-1]>0) & (aice[1:-1,1:-1]<=1)) + + # Mask Arctic basin and shrink array + eps_tot = eps_tot.where(self.mask[1:-1,1:-1]) + eps_tot = eps_tot[max([0,self.index_y[0][0]-1]):self.index_y[0][-1]+2:self.red_fac, + max([0,self.index_x[0][0]-1]):self.index_x[0][-1]+2:self.red_fac] + eps_tot[0,:] = np.nan; eps_tot[-1,:] = np.nan + eps_tot[:,0] = np.nan; eps_tot[:,-1] = np.nan + eps_tot[1,:] = np.nan; eps_tot[-2,:] = np.nan + eps_tot[:,1] = np.nan; eps_tot[:,-2] = np.nan + + self.eps_tot_list.append(np.array(eps_tot)) + + + # Apply detection algorithm + # Correct detection parameters for different resolution + self.corfac = 12.5e3/np.mean([np.nanmean(self.dxu),np.nanmean(self.dyu)])/float(self.red_fac) + + # Detect features + print('Start detection routines') + lkf = lkf_detect_eps_multday(self.eps_tot_list,max_kernel=self.max_kernel*(1+self.corfac)*0.5, + min_kernel=self.min_kernel*(1+self.corfac)*0.5, + dog_thres=self.dog_thres,dis_thres=self.dis_thres*self.corfac, + ellp_fac=self.ellp_fac,angle_thres=self.angle_thres, + eps_thres=self.eps_thres,lmin=self.lmin*self.corfac, + max_ind=500*self.corfac,use_eps=True) + + # Save the detected features + + if self.latlon: + lkf = segs2latlon_model(lkf, + self.lon[max([0,self.index_y[0][0]-1]):self.index_y[0][-1]+2:self.red_fac, + max([0,self.index_x[0][0]-1]):self.index_x[0][-1]+2:self.red_fac], + self.lat[max([0,self.index_y[0][0]-1]):self.index_y[0][-1]+2:self.red_fac, + max([0,self.index_x[0][0]-1]):self.index_x[0][-1]+2:self.red_fac]) + if return_eps: + lkf = segs2eps(lkf, + div[max([0,self.index_y[0][0]-1]):self.index_y[0][-1]+2:self.red_fac, + max([0,self.index_x[0][0]-1]):self.index_x[0][-1]+2:self.red_fac], + shr[max([0,self.index_y[0][0]-1]):self.index_y[0][-1]+2:self.red_fac, + max([0,self.index_x[0][0]-1]):self.index_x[0][-1]+2:self.red_fac]) + + lkf_T = [j.T for j in lkf] + np.save(lkfpath + 'lkf_' + datafile.split('/')[-1][:-3] + '_%03i.npy' %(it+1), lkf_T) + + + + + + + + + + +def segs2latlon_model(segs,lon,lat): + """ Function that converts index format of detected LKFs to + lat,lon coordinates + """ + segsf = [] + for iseg in segs: + segsf.append(np.concatenate([iseg, + np.stack([lon[iseg[0],iseg[1]], + lat[iseg[0],iseg[1]]])], + axis=0)) + return segsf + diff --git a/lkf_tools/detection.py b/lkf_tools/detection.py index e04535b..d26777b 100644 --- a/lkf_tools/detection.py +++ b/lkf_tools/detection.py @@ -145,7 +145,7 @@ def nanmean_neighbours(img): -def detect_segments(lkf_thin,eps_thres=0.1): +def detect_segments(lkf_thin,eps_thres=0.1,max_ind=500): """ Function to detect segments of LKFs in thinned binary field The aim of this function is to split the binary field into multiple smaller segments, and guarantee that all points in a @@ -193,7 +193,7 @@ def detect_segments(lkf_thin,eps_thres=0.1): # Loop parameters num_nodetect = np.sum(nodetect) # Number of undetected pixels ind = 0 # Index of detection iteration - max_ind = 500 # Maximum number of iterations + max_ind = max_ind # Maximum number of iterations angle_point_thres = 5 # Number of last point in segment to compute the critical angel to break segments @@ -419,7 +419,7 @@ def detect_segments(lkf_thin,eps_thres=0.1): np.append(deactivate_segs_ang,deactivate_segs_end))) deactivate_segs = np.unique(np.hstack([deactivate_segs_muln,deactivate_segs_ang, deactivate_segs_end,deactivate_segs_samehead])) - active_detection = np.delete(active_detection,deactivate_segs) # remove from active list + active_detection = np.delete(active_detection,deactivate_segs.astype('int')) # remove from active list # Activate new segments that started in this iteration active_detection = np.append(active_detection,np.arange(seg_old_shape, seg_old_shape + num_new_starts)) @@ -1062,3 +1062,88 @@ def lkf_detect_eps(eps_tot,max_kernel=5,min_kernel=1,dog_thres=0,dis_thres=4,ell return seg + + +def lkf_detect_eps_multday(eps_tot,max_kernel=5,min_kernel=1, + dog_thres=0,dis_thres=4,ellp_fac=3, + angle_thres=35,eps_thres=0.5,lmin=4, + max_ind=500, use_eps=False): + """Function that detects LKFs in temporal slice of deformation rate. + LKF binary map is generated for each time slice and all binary maps + are combined into one before segments are detected. + + Input: eps_tot - list of time slices of total deformation rate + max_kernel - maximum kernel size of DoG filter + min_kernel - minimum kernel size of DoG filter + dog_thres - threshold for DoG filtering, pixels that + exceed threshold are marked as LKFs + angle_thres - angle threshold for reconnection + ellp_fac - weighting factor for ellipse + dis_thres - distance threshold for reconnection + eps_thres - threshold difference in deformation rate + lmin - minimum length of segments [in pixel] + + Output: seg - list of detected LKFs""" + + lkf_detect_multday = np.zeros(eps_tot[0].shape) + + for i in range(len(eps_tot)): + if use_eps: + proc_eps = eps_tot[i] + else: + ## Take natural logarithm + proc_eps = np.log(eps_tot[i]) + proc_eps[~np.isfinite(proc_eps)] = np.NaN + if not use_eps: + ## Apply histogram equalization + proc_eps = hist_eq(proc_eps) + ## Apply DoG filter + lkf_detect = DoG_leads(proc_eps,max_kernel,min_kernel) + ### Filter for DoG>0 + lkf_detect = (lkf_detect > dog_thres).astype('float') + lkf_detect[~np.isfinite(proc_eps)] = np.NaN + lkf_detect_multday += lkf_detect + + lkf_detect = (lkf_detect_multday > 0) + + ## Apply morphological thinning + lkf_thin = skimage.morphology.skeletonize(lkf_detect).astype('float') + + # Compute average total deformation + eps_tot = np.nanmean(np.stack(eps_tot),axis=0) + + # Segment detection + seg_f = detect_segments(lkf_thin,max_ind=max_ind) # Returns matrix fill up with NaNs + ## Convert matrix to list with arrays containing indexes of points + seg = [seg_f[i][:,~np.any(np.isnan(seg_f[i]),axis=0)].astype('int') + for i in range(seg_f.shape[0])] + # ## Apply inter junction connection + # seg = connect_inter_junctions(seg,lkf_thin) + ## Filter segments that are only points + seg = [i for i in seg if i.size>2] + + # Reconnection of segments + eps_mn = compute_mn_eps(np.log10(eps_tot),seg) + num_points_segs = np.array([i.size/2. for i in seg]) + ## Initialize array containing start and end point of segments + segs = np.array([np.stack([i[:,0],i[:,-1]]).T for i in seg]) + + seg = seg_reconnection(seg,segs,eps_mn,num_points_segs,1.5, + 50,eps_thres,ellp_fac=1) + + # Reconnection of segments + eps_mn = compute_mn_eps(np.log10(eps_tot),seg) + num_points_segs = np.array([i.size/2. for i in seg]) + ## Initialize array containing start and end point of segments + segs = np.array([np.stack([i[:,0],i[:,-1]]).T for i in seg]) + + seg = seg_reconnection(seg,segs,eps_mn,num_points_segs,dis_thres, + angle_thres,eps_thres,ellp_fac=ellp_fac) + + # Filter too short segments + seg = filter_segs_lmin(seg,lmin) + + # Convert to indexes of the original input image + seg = [segi+1 for segi in seg] + + return seg \ No newline at end of file diff --git a/lkf_tools/rgps.py b/lkf_tools/rgps.py index ea11f37..65f8e47 100644 --- a/lkf_tools/rgps.py +++ b/lkf_tools/rgps.py @@ -310,3 +310,4 @@ def get_icemotion_RGPS_season(season_path,stream='None'): return icemotion_data + diff --git a/lkf_tools/tracking.py b/lkf_tools/tracking.py index d349619..3e4001f 100644 --- a/lkf_tools/tracking.py +++ b/lkf_tools/tracking.py @@ -16,7 +16,7 @@ import numpy as np import matplotlib.pylab as plt -from lkf_detection import * +from .detection import * diff --git a/notebooks/detection_tutorial.ipynb b/notebooks/detection_tutorial.ipynb index 924556a..6407854 100644 --- a/notebooks/detection_tutorial.ipynb +++ b/notebooks/detection_tutorial.ipynb @@ -89,29 +89,724 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 24, "id": "7a2ff405-d095-4023-aef6-96f259a2fe7b", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "62.24692249540107" + "" ] }, - "execution_count": 20, + "execution_count": 24, "metadata": {}, "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" } ], - "source": [] + "source": [ + "import matplotlib.pyplot as plt\n", + "import cartopy.crs as ccrs\n", + "\n", + "fig = plt.figure(figsize=[10, 5])\n", + "\n", + "ax = plt.subplot(1, 1, 1, projection=ccrs.Orthographic(0, 90))\n", + "\n", + "ax.coastlines(zorder=3)\n", + "\n", + "ax.pcolormesh(lon,lat,test[0],vmin=-1e-2,vmax=1e-2,transform=ccrs.PlateCarree())" + ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 25, "id": "52d75568-ce42-42e3-bb71-742a25469b82", "metadata": {}, "outputs": [], + "source": [ + "import xarray as xr\n", + "\n", + "data = xr.open_dataset('/Users/nhutter/Documents/Research/sirex/data/McGill/McGill_runno01_expno07_1997_daily_means.nc')" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "617a164f-58c9-40c0-9368-653d4bd16b7f", + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2\n", + "\n", + "from lkf_tools.dataset import *" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "a042483c-95cb-416b-8e8d-b5751d5923ae", + "metadata": {}, + "outputs": [], + "source": [ + "test = process_dataset('/Users/nhutter/Documents/Research/sirex/data/McGill/McGill_runno01_expno07_1997_daily_means.nc')" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "cdf35d68-be9e-43c7-af81-d5c65817c464", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Compute deformation rates and detect features for day 1\n", + "Start detection routines\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/nhutter/Documents/Research/lkf_tools/lkf_tools/detection.py:96: RuntimeWarning: invalid value encountered in true_divide\n", + " gaussian_field = field_nonnan_f/mask_nan_f\n", + "/Users/nhutter/Documents/Research/lkf_tools/lkf_tools/detection.py:1113: RuntimeWarning: Mean of empty slice\n", + " eps_tot = np.nanmean(np.stack(eps_tot),axis=0)\n", + "/Users/nhutter/Documents/Research/lkf_tools/lkf_tools/detection.py:243: RuntimeWarning: invalid value encountered in true_divide\n", + " dx = (seg_active[:,:,-1]-seg_active[np.arange(seg_active.shape[0]),:,-num_points])/np.stack([num_points-1,num_points-1],axis=1) - (seg_append-seg_active[:,:,-1])\n", + "/Users/nhutter/Documents/Research/lkf_tools/lkf_tools/detection.py:561: RuntimeWarning: invalid value encountered in arccos\n", + " angle = np.arccos(angle)/np.pi*180\n", + "/Users/nhutter/Documents/Research/lkf_tools/lkf_tools/detection.py:557: RuntimeWarning: invalid value encountered in true_divide\n", + " f1 = (f1/np.sqrt(np.sum(f1**2))) # Normalize basis vector\n", + "/Users/nhutter/Documents/Research/lkf_tools/lkf_tools/detection.py:554: RuntimeWarning: invalid value encountered in true_divide\n", + " e1 = (e1/np.sqrt(np.sum(e1**2))) # Normalize basis vector\n" + ] + }, + { + "ename": "ValueError", + "evalue": "all the input arrays must have same number of dimensions, but the array at index 0 has 2 dimension(s) and the array at index 1 has 3 dimension(s)", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "Input \u001b[0;32mIn [9]\u001b[0m, in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mtest\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdetect_lkfs\u001b[49m\u001b[43m(\u001b[49m\u001b[43mindexes\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/Documents/Research/lkf_tools/lkf_tools/dataset.py:174\u001b[0m, in \u001b[0;36mprocess_dataset.detect_lkfs\u001b[0;34m(self, indexes, force_redetect)\u001b[0m\n\u001b[1;32m 171\u001b[0m \u001b[38;5;66;03m# Save the detected features\u001b[39;00m\n\u001b[1;32m 173\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mlatlon:\n\u001b[0;32m--> 174\u001b[0m lkf \u001b[38;5;241m=\u001b[39m \u001b[43msegs2latlon_model\u001b[49m\u001b[43m(\u001b[49m\u001b[43mlkf\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 175\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mlon\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;28;43mmax\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m,\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mindex_y\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m]\u001b[49m\u001b[38;5;241;43m-\u001b[39;49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m\u001b[43m:\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mindex_y\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m-\u001b[39;49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m]\u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[38;5;241;43m2\u001b[39;49m\u001b[43m:\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mred_fac\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 176\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mmax\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m,\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mindex_x\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m]\u001b[49m\u001b[38;5;241;43m-\u001b[39;49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m\u001b[43m:\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mindex_x\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m-\u001b[39;49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m]\u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[38;5;241;43m2\u001b[39;49m\u001b[43m:\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mred_fac\u001b[49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 177\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mlat\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;28;43mmax\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m,\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mindex_y\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m]\u001b[49m\u001b[38;5;241;43m-\u001b[39;49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m\u001b[43m:\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mindex_y\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m-\u001b[39;49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m]\u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[38;5;241;43m2\u001b[39;49m\u001b[43m:\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mred_fac\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 178\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mmax\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m,\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mindex_x\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m]\u001b[49m\u001b[38;5;241;43m-\u001b[39;49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m\u001b[43m:\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mindex_x\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m-\u001b[39;49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m]\u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[38;5;241;43m2\u001b[39;49m\u001b[43m:\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mred_fac\u001b[49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 179\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m return_eps:\n\u001b[1;32m 180\u001b[0m lkf \u001b[38;5;241m=\u001b[39m segs2eps(lkf,\n\u001b[1;32m 181\u001b[0m div[\u001b[38;5;28mmax\u001b[39m([\u001b[38;5;241m0\u001b[39m,\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mindex_y[\u001b[38;5;241m0\u001b[39m][\u001b[38;5;241m0\u001b[39m]\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m]):\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mindex_y[\u001b[38;5;241m0\u001b[39m][\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m]\u001b[38;5;241m+\u001b[39m\u001b[38;5;241m2\u001b[39m:\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mred_fac,\n\u001b[1;32m 182\u001b[0m \u001b[38;5;28mmax\u001b[39m([\u001b[38;5;241m0\u001b[39m,\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mindex_x[\u001b[38;5;241m0\u001b[39m][\u001b[38;5;241m0\u001b[39m]\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m]):\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mindex_x[\u001b[38;5;241m0\u001b[39m][\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m]\u001b[38;5;241m+\u001b[39m\u001b[38;5;241m2\u001b[39m:\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mred_fac],\n\u001b[1;32m 183\u001b[0m shr[\u001b[38;5;28mmax\u001b[39m([\u001b[38;5;241m0\u001b[39m,\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mindex_y[\u001b[38;5;241m0\u001b[39m][\u001b[38;5;241m0\u001b[39m]\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m]):\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mindex_y[\u001b[38;5;241m0\u001b[39m][\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m]\u001b[38;5;241m+\u001b[39m\u001b[38;5;241m2\u001b[39m:\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mred_fac,\n\u001b[1;32m 184\u001b[0m \u001b[38;5;28mmax\u001b[39m([\u001b[38;5;241m0\u001b[39m,\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mindex_x[\u001b[38;5;241m0\u001b[39m][\u001b[38;5;241m0\u001b[39m]\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m]):\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mindex_x[\u001b[38;5;241m0\u001b[39m][\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m]\u001b[38;5;241m+\u001b[39m\u001b[38;5;241m2\u001b[39m:\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mred_fac])\n", + "File \u001b[0;32m~/Documents/Research/lkf_tools/lkf_tools/dataset.py:204\u001b[0m, in \u001b[0;36msegs2latlon_model\u001b[0;34m(segs, lon, lat)\u001b[0m\n\u001b[1;32m 202\u001b[0m segsf \u001b[38;5;241m=\u001b[39m []\n\u001b[1;32m 203\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m iseg \u001b[38;5;129;01min\u001b[39;00m segs:\n\u001b[0;32m--> 204\u001b[0m segsf\u001b[38;5;241m.\u001b[39mappend(\u001b[43mnp\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mconcatenate\u001b[49m\u001b[43m(\u001b[49m\u001b[43m[\u001b[49m\u001b[43miseg\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 205\u001b[0m \u001b[43m \u001b[49m\u001b[43mnp\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mstack\u001b[49m\u001b[43m(\u001b[49m\u001b[43m[\u001b[49m\u001b[43mlon\u001b[49m\u001b[43m[\u001b[49m\u001b[43miseg\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43miseg\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 206\u001b[0m \u001b[43m \u001b[49m\u001b[43mlat\u001b[49m\u001b[43m[\u001b[49m\u001b[43miseg\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43miseg\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m]\u001b[49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 207\u001b[0m \u001b[43m \u001b[49m\u001b[43maxis\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m)\u001b[49m)\n\u001b[1;32m 208\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m segsf\n", + "File \u001b[0;32m<__array_function__ internals>:180\u001b[0m, in \u001b[0;36mconcatenate\u001b[0;34m(*args, **kwargs)\u001b[0m\n", + "\u001b[0;31mValueError\u001b[0m: all the input arrays must have same number of dimensions, but the array at index 0 has 2 dimension(s) and the array at index 1 has 3 dimension(s)" + ] + } + ], + "source": [ + "test.detect_lkfs(indexes=[0])" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "3c986c0a-80a4-428a-b799-2e7b00660ee4", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAR0AAAEeCAYAAAC3/sHVAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAADodUlEQVR4nOydd3gUVdvGfzNb0kmh946E3kGKCEhTpCgiIEVQRF4QCyiKCKKCDVRQVBAVFQQbiICIIEURkCJVeu8QCAmp2+Z8f8zO7OxmN9mEUPTLfV25kuzOnnNmds49T38kIQQFKEABCnCjIN/sBRSgAAX4/4UC0ilAAQpwQ1FAOgUoQAFuKApIpwAFKMANRQHpFKAABbihKCCdAhSgADcU5uze7NSpk7h06dKNWosXbDYbR48exW63Ex4eTtWqVfX3zpw5w/nz5yldujQlSpS4KevLDQ4fPkxMTAxFihS52UvJE86cOUNiYiKVK1cmPDz8Zi8nKLhcLkwmEwBpaWkcPnyYOnXqAHD06FFCQ0MpVqwYiqIQEhLid4ykpCSOHz9OlSpViIyMvKb1pKWlce7cOex2OxUrViQsLCzgsQkJCZw8eZKwsDBsNhuKolC3bl1cLlfAtd5q2LZt2zYhRCO/bwohAv40bNhQ3AwsWbJEAKJjx46iW7duYtSoUV7vV65cWQDC6XTelPUFi9TUVLF582YRFxcnUlJScvVZp9MpBgwYIHbv3n2dVpc7vPbaawIQ69atu9lLyRFNmzYVgBg7dqz4+eefxW233Sa++uorIYQQf/31l6hQoYLIzMzMdowlS5aIEiVKiE2bNuVpDYcPHxYTJ04UHTp0EGXKlBGlS5cW77//vkhPTw/q808++aSYPHmySE5OFgcPHhSlS5cWgDh+/Hie1nOjAWwVAXjlliSd/v37iwEDBoh3331XAKJv375i2bJlQgghTpw4IWJjY8XevXtvytpyg379+glATJ8+PVefczqdYvny5QIQVatWFc8995xITU0VQghhs9nE3Llzxc6dO6/HkgMiISFBACI8PFy4XK4bOndu8dlnnwlAAKJBgwbis88+E4qiiOTkZFG3bl3x7rvvZvv59PR0ER4eLiZNmiQ+/vhjceDAgaDnVhRFfPjhh6Jw4cLiqaeeEj/99JM4evRorq/ZypUrRZUqVcTOnTvF+vXrRUpKyg3/zq8F/yrScTgcAhAbNmwQ1apVE4B44YUXRI0aNYQQQpw9e1a/oRYsWHDD15cbhIeHCyBXUs6uXbsEIMLCwsSYMWPEL7/8Ijp06CDq1q0rxo8fL9q2bSuaN28u4uLixMGDB6/j6rOiZs2a4pFHHhGKotzQefMCu90uWrRoIfr06SNee+01MXHiRNGvXz9Rp06dHNefkpIiqlSpIpo3by4qVqwoHnrooRzn27dvnxgzZoyoXr26qFevXr58N2+99ZaIiYkRgBg0aNA1j3cjkR3p3HKG5N69e3PbbbdRvnx5mjdvzqRJkxg9ejRnzpwBoFixYsTExADc8vrtnj17qFWrFjt37gz6M5cvXwYgMjKSL774gscee4xq1arx1ltvsWbNGlavXk3lypVRFIUjR45cr6X7RcmSJalfvz6SJN3QefMCi8XCTz/9RJ06dUhLS8PpdFKlShW++eabHNcfGRnJoUOH+PPPP1m3bh0//fQTDRo0oHHjxowZM4Z3330Xu92uH3/q1CnuueceFEVh9uzZ/P333142yLzi2Wef5cqVK9SqVYvPP/8ch8NxzWPeEgjERuImSDq7d+8WgEhOTvZ6fevWraJ27doiOTlZ9OjRQ0RERNzST9u0tDShKIquHh45ciRP49jtdrF7925Ru3Zt0bx5c1G4cGHx7rvvilGjRonatWuLU6dO5fPKs8eXX34pSpYseUPnvBVw7NgxsXnzZvHHH3+I5557TnTs2FHEx8eLBx98ULRo0ULExsZmsTvmJ2w2m+jQoYMYMmSIUBRFpKamiiVLlogGDRqIQYMGiYSEhOs2d17Bv0G9stvtutrkSzrr168XjRo1Elu2bBGAMJlMuo3jVsLJkyfFk08+KQCxdu1a0axZM1GpUqVrHjc1NVUsW7ZMnD17Nh9WmXckJSUJQLRs2VJMnTr1lrftXC8oiiJWrlwpZs2aJX755ZccjdL5gatXr4patWqJESNGiMcee0zfK4AYMWLEdZ8/t8iOdLJ1md9IaCJvly5dKFSokNd7DRs25ODBg8TFxTFt2jS++eYbIiIibsYyA8Jut9OyZUs6dOhASEgIHTp0oHTp0sybN++ax46IiODuu+/O9piMjAw2bdpE8+bNr5vaGR0dTZcuXfjnn3/4+uuvSUtL46WXXrouc93KkCSJu+6664bOGRUVxcqVK3njjTe4cOECU6dOJS0tjdatW9O9e3dCQkKIiIhg6NChlCpV6oauLdcIxEbiBkk6iqKIX375RfTv318AYvPmzX6Pmzx5smjTpo3o0qWLeOqpp677unKLV199Vdx99936/w6H44aogIqiiI0bN4pmzZrpT74qVaqIlStX5vtc69atEytWrBAOh0McOnRIFCtWTBf3U1JSxMWLF/N9zgLkjL1794px48aJRx99VNSrV0+kpaXd7CXdeupVZmamUGOHhHjxxRdF1apVxdixY8X06dMD3rgjRowQffr0EY8//riYOHHidVlXXuFyuUTp0qVvihv/77//1slGkiQBiOXLl4uiRYuK7777Ll+Ib/fu3aJ///6iUqVKolq1aqJixYqiUaNGAhCNGzcWZrNZD20QQoiMjAxx+vRp8fXXXwuHw3HN8xcgOCiKIvr16yfatGkjkpOTxenTp0VSUtJNWcstRzojRowQgHj33XdFRESEWLFiRbbHHzx4UBQuXFh88sknoly5cuL8+fPXZV25xR9//CG6du0qrFarKF269E1Zg8vlEi+88IIAxOTJk0ViYqIQQogNGzaIWrVqifj4eNGrVy8xcOBAcfXq1VyP/8EHH4gSJUqIMWPGiNTUVOFyucT+/ftFhw4ddLKrXr26AESZMmW8bA2AOHz4cH6fcgGygcPhEA8++KCIj48XsbGxIiwsTOzbt++Gr+OWIx3jTSnLsli2bJk4deqUsNvtXsddunRJTJ48WTRu3Fi8/vrr4s477xQ//PDDdVlTbrF48WJRsmRJ8cknn4g///xT7Nmz56atxeFwCFmWBSAyMjL01xVFERs2bBCffvqpePTRR0X16tWDVoFcLpf45JNPRLFixcSxY8eyvJ+enp6FYADx3HPPie3bt99wz1oBPLh06ZJ47733xMWLF0WjRo1uShT5LUk6NWvWFIBo27atqFChgu7xEUKIPXv2iAEDBuhPz2eeeUa88cYbomLFil6b6maiefPmYvHixTd7GcLhcIjOnTuL+vXrixdffDHbY5s2bZqjVKnh+eefF82aNcs2yO38+fOifv36IjIyUgwfPvyWT0v5/4gxY8aIpk2b3nDV/5YinTNnzghADBs2zMsOAYjx48eL/fv36/9rtgLc4exr1qzJ9/XkFaGhoeLChQtBH68oihg3bpzo1auXeOihh0SPHj1Er169xIYNG65pHbt37xYRERFB5QgNGTJETJkyJcfjUlJSRExMjDhz5sw1ra0ANx9Op1NMnz5dFC5cWIwdO/aGGZlvGdI5ePCgGDlypKhQoYKYNm2a2LFjh1i7dq1YsmSJKFeunK4enDt3TjeAAuJm5YBlh8cee0wMHDgwy+t2u11s3bpVbNu2TdjtdqEoitixY4eoV6+eqFChgpg/f7748ssvxffffy8+/PBDYbVar0lCcLlcOjFr9pxA2Lx5syhWrJh47bXXxNatW8XJkyfFAw88ICpXriyKFi0q2rVrJ5xOp3jzzTdF796987ymAtx6OHPmjOjVq5eoWrWqX3U5v3HDScefx8TpdOrEYkyAzMzMFPXr19c3zvr16/X35s+fLwAxZ86cPK3jeiI1NVWULVtWrF692uv1WbNmedk4SpcuLSpUqCDeeeedLNclMzNTAGLChAlZ7FnBwOVyia1bt+qSYzDYsGGDGDlypIiPjxchISFiwoQJYv/+/eLcuXPCZDKJs2fPikmTJolOnToFnRFdgH8Ppk2bJkqXLi2++eabPEk9KSkp4ueffxYJCQkiPT1dnDhxQiQkJGQZ64aSTs+ePcVjjz2W5fXffvtNAKJz585i0aJFwuVyibS0NFGuXDkRGRkpAFGxYkUvF+vMmTNFnz59btnI12XLlokiRYqIRo0aiX379glFUUSjRo3EyJEjBSDuu+8+cejQoWzd1ps2bRKAuOuuu4Ke1+l0itKlS4vIyEgRFRXlpZ7mBr7r6t69u+jatavIyMgQ3bp1Ey+88EKuxivAvwPLly8Xd911l6hQoUJAB8i5c+fE7t27xcmTJ4WiKEJRFLFw4UJRtmxZ0aRJE1GoUCERGRkpihUrJqKiokShQoVExYoVRUhIiObNvHGkA4hq1aqJlJQUsWfPHlGxYkXRsGFDAYjbbrtNd68+/vjjolOnTqJ27dri2LFjAhD//PNPHi7hzcW9994rALFjxw4xYcIE0aBBg6BJ8tKlSzppDBw4ULzxxhtiwYIF2apJW7ZsESaTSSea9PR0cfr0adGtWzfx8ssvX9O5nDx5UgBi69at4ocffhDdunW7pvEKcGtj5syZolixYqJOnTpi9OjRYsqUKWLcuHGibt26Ii4uTtSoUUMUL15cFC5cWMTExIjatWvrdlWbzSauXLmiE1JCQoLYt2+fuHr1qlYp4fqTjsvlEv/73/8EIJo3by7MZrPuxv3qq69E3759RcOGDcXbb78tpkyZ4rVp/q1wOp0CEBcuXBD333+/iIiIyFUMUUpKiqhVq5bo1q2bGDNmjHj22WfFPffcIwDxzjvv+P3ML7/8Im6//Xbxxx9/iPj4eHHixIn8Oh3x9ttv69KoMdivAP9dOJ1OsX79ejFp0iTx9NNPi3Hjxok1a9bodkZFUcTZs2dzHW1+3UlHURTxzDPPiFatWomvvvpKfPHFFyItLU2/iX2TMzdu3HjL2mpyiy5duojixYuL1q1bi0OHDl3zeH/++acARP369bO8t3PnTtGjRw8xdOjQHMdJTEzMdUyT0Rb1v//9T1y6dClXny9AATRcV9JxuVzi6aefFvXq1ctyk27YsEFER0dn+YyiKOLy5cvXcEq3DpxOp5gzZ06+eAQWLlwoypcvL2bNmpVFAtRUUEmSvLx7gXD//fcLQNx7771Bp0I8+eSTYtGiReKVV14pSF8owDXhupHOzp07xZ133ilatWqVo7u2ANnj9OnTIi4uTvz0009+ScLhcIhHHnlEl0RmzJiR7Xht27bVj/3444+zlAspQAGuJ/KddH7//Xdx7733ihIlSoj33nuvIBL1GnDw4EHx66+/ihYtWojnn38+x+PPnTsnunfvLgoXLiy++eabgEbrs2fPirCwMHHnnXcKQHz44Yf5vfQCFCAgrpl0Ll26JN58803Rpk0bAYjo6Gjx8ccf3xIp9P9m/PLLLwIQFotFDB06NFcZ4WvXrhUNGjQQHTt2zJIasnjxYpGYmChKliwpDh8+LGrWrOkV/1SAAlxvZEc62dZIFkKwdu1aatSowYEDBxg1ahQAFStWZOjQof+aHkg3C2lpaezevZspU6bQsWNHHnnkEU6cOKG/X79+fWRZxuFwMGXKlFzVHm7dujWbN28mOjqanj17smHDBoYNG0bhwoXp1q0b33//Pe3bt6dHjx44nU5WrFhxPU6xAAXIPQKxkRCCihUrihIlSohff/1VZzCn0/mvdnPfCPzxxx/iwQcfFIULFxYVK1YU/fv3F4sWLRJVqlTRA/j+/PNPcdttt4nu3bsLm82W57nsdrsYNWqUV1Q3IGJjY/Wgy9atW4vmzZvn1+kVoAA5gmwkHUl93z+io6NFixYt+Pnnn28MA/5H0L59exo0aMDjjz9OxYoV9defffZZoqOjadq0Kf379+e9997jwQcfzNfuCpmZmaSnp7Nt2zbKli3LbbfdxqJFi7j//vu56667WLlyZb7NVYACBIIkSQE7fGZbI/nq1atYrdbrs6r/IH788Ud69OgBQIMGDYiOjvZ6f8qUKQBUr16d2bNn06VLl3xfQ2hoKKGhobRv315/rUWLFgCsWrUq3+crQAFyixz7Xg0YMOBGrONfjytXrvD777/r/7/11ltUrFjRq1fR1q1b+e2339i7d+91IZxAKF68OMnJyRQqVKiAeApw05Et6TRs2JD77rvvRq3lX41KlSpx4sQJmjdvrr+mSYpvvfUWoF7Ptm3b3pRmdYUKFWLevHkMHjyYhx56iLNnz97wNRSgABCEpFOA4NCiRQsWL17Mhg0bGDdunFdXzzFjxvD666/z9NNP8+6775KZmXlT1tilSxf27dtH+fLlqVOnDu+8885/p2tkAf41KCCdfMKiRYs4d+4cDoeDV199NctmPnLkCOXKlWPVqlU8+OCDZGfAv56IiIhg8uTJbNiwgVWrVlG1alVefvllVq9eTWpq6k1ZUwH+fyFb71WjRo3E1q1bb+By/juw2+3Mnz+f4sWLU7JkSerWrQuAw+GgUaNGPPXUUwwaNOgmrxJWrFhBp06dAJgzZw4DBw68ySsqwH8B2XmvCkjnJmD37t106NCBHj16MHr0aCpVqnRT17Njxw7q168PQO3atdmxYweyXCAEFyDvyI50Cu6sm4DatWuzc+dOYmJiaNy4MQ899BC7du26aeupV68eqampxMfHs3v3bjZt2nTT1lKA/z4KSOcmoVixYkyePJmjR49Sp04dOnXqRKlSpXjkkUc4evQoNpvthq4nIiKCvXv3MmXKFLp06cJTTz1FQkLCDV1DAf5/oIB0bjKio6MZM2YMZ86cYcOGDcTGxlK5cmVCQ0NRFOWGr2fUqFEcOHCAw4cPc9ddd/HRRx/d8DUU4L+NAtK5RSBJEhUqVNCjlkeMGHHT7CpFixZl6dKl/PDDD7zxxht89dVX+Tq+EIIpU6ZQpkwZqlatSvfu3Qtc9/+PUEA6tyBq1arFo48+erOXQZUqVfjll18YPXo0ffr0yTc3/9tvv80XX3zBihUrWLZsGadPn/aK5i7AfxsFpHOL4cyZM5w4ceKWiRiOj4/nyJEjHDp0iFq1avHCCy9w8uTJaxpzzZo1TJ48mZo1a1KtWjVq1apVQDr/j1BAOrcAHA4HX375JXXq1KFu3brUrFmTwoUL3+xl6YiMjGTLli18/PHHOBwOGjRowKhRo8hrOEWtWrW8Pvviiy8yd+5chg8fTnJycn4tuwC3KApI5yZjx44dVKlShc8//5ypU6dy8eJFNm7cSJMmTW720rwgSRKtWrViypQpbNy4kejoaO69914mT56ca7WrVatWXqRTtWpVtm7dyoEDB3j77bevea07duxAkiSWL19+zWMVIP9REBx4E2Gz2YiPj2fSpEn06dPnZi8n1zhz5gxdu3alVKlSREREkJGRQYUKFWjQoAHx8fFcvHiRevXqUaZMGa/PHTlyhCpVqvDOO+/wxBNPMGXKFCpUqMDBgwex2+289tpreV7T/v37iY+PB+DEiROUK1fums6xAHlDnuvpFOD6Yu7cucTHx19Xwrm9z1Rs0TLmDIE5QxBxOgNTuh1cLiSXAKcLJAl7yUKYMp1IDhcoIKdlgsOhvg8gSd7/Wy0AxEW14cjO/bgKgxQWx67Dh7h8+TIvv/wyx48fp0iRInz44YfcfffdREREABATE0NkZCQxMTF89913zJw5k9jYWJxOJ3Xr1uXAgQO8+OKLnDx5Us+Kj4qKyvFcXS6XTjipqan6fAW4tVAg6dxEVK1alfHjx9O/f/9rHqtzlWcREaEIs4x8PhFkGUwyIjmF5M7xSC6QHQJHpIzJJkBA5Mk0hCxjPpWAvWoJJKeC5A4NMiekgKKASwGnU33Rbkc4nUgWC4RYwex+ZkkSWMzgcKIUCgNZxik5SSyhkJ6WQCnlEH///Te9e/fmiSeeYO3atWzatIm5c+fSokULqlatysyZM7nvvvtYuXIlkZGRvPDCC9SsWZPZs2ezdetWhg0bxv3330+1atUCXoPt27fToEEDYmNjSUxMvOZrWoC8oyD36haFyWRi06ZNNG7cOFef61z6CZUQTCbPi0Ig0jNQqpZDWGSQJBSLDBIIScKSlIEwmZBcLuQraaTUK4HsEghZwhEuEXHODooAWUK2K5iupCMpCtgcIBQQAtIyIDoKXC5EeBiSw6m+LgS4XO7f7mMjwlXSkyTsJaLIkNI5e3IjrvR9XLp0ibLFW1OhTCuSM86hyH8REhJC+fLlWb16Nfv27SM2NlY/tfXr1zN//nwWLVpEuXLlWLlypV/J55133mHUqFFERkaSkpKS5++lANeOAtK5RdGtWzf69+9Pz549Ax7TMcwgBZlkJJMJKTRElTLc0gygqj0OB8LuQLgD7aTyZRBHT+JqXB3LvlM4q5VBCTEh2xVkmxNhlpEcLk51iibqpCDinB3JoSA7VSJRrCYSa4QSflGh0IbjuMoWVdUvAAUkuxPJpqpqutqlKOqPdl8JASEhYLXgKBWDEIKMlIuEKeFYnTLCJIHDyVnnMa5ePEzFQg0ISZcQdjsIwYq0L/XTVxSFIUOGsHXrVmrVqkXXrl0pU6YM0dHRfPbZZ0yfPh2Xy0WHDh0Kul/cZBTYdG5RKIqSJeq4U9wQcDoRLpe6mQGhCCSTSZVm3K9LmkpjrELo/luSZYSiIE6cBpOMecdhda6/D+juSjmmkEoURWIxNUlCnIomo6iFkEQnv/0yhhYPTOXP70bpQ9/eZyqSCywZCiGXMpEzHKokBB7pRpN2NMJxS07YbOBwYDmtvm5VTOBIA7fkhaJQ2lyS0iFxiBS7+xzVsTuGPgQmEyvSvkSWZWbOnMnKlSs5duwYc+fO5eLFiyQmJlKlShVcLhcxMTF07Ngxn7+pAuQnCkjnJsHpdPLnn3+SuqMkM/v+AJIMQlEJRlbJQygGKVQooMhgktTN7HLbWyRJlXZkGcxmJJeCkCQkl0vdvP4gSyhXU0CSkFOstC17nGlfzNffvnTpEi8/VoeMjAzmz5/P1q1bOfXHT8R1eYLYkxJCklRpxuZQ7T1u4tAJx7BubQ2SIlTykSQPQdkdCKEgSbIqnbkMEpJJdv9tAkXQMXIgkqyqjZqE98ulJfo8KSkpLFu2jB9++IFdu3Zht9sLmgrcoiggnZuEzZs348iwYLXbVMIxQCMeSZY8Ug6ALKkbz+VCAJLD4fYq4VG3rBYkxYTItCG5N7DQCEHOWps5rUFZptWfzpkzZ5g3bx6///4769evp1KlSrhcLkJCQnjggQeQJAnln2NYlTKYUjKQMh2guDzqlKKoBKMRjix5SBEQuJDs7tdlWScXSTt3RahjGFUzTVIyyep5g+c9oHOJ/4HJxPIz7xMVFUXv3r3p2LEjAwYMoFOnTixfvpyQkJBr/q4KkL8oIJ2bgBMnTtCiRQvKF70drjr11zWyMUo4kix5yMKoSrlcCDsgBJLVokocsqwal00mlahsblXFbs+6CElCMplwhslcunSJ22+/nc6dO9OvXz/mz59PVFQUycnJREREkJ6ezrRp04hMkjCRgWRzqvM5XepvIRAO93kI4fZ6+cwny+pahIR+Ftp5KYHtirhcYDIhFMUj6SiKR2ICOpcZqbrzFQEmmaVnfqRy5cps2bKFli1b5vh9FODGooB0bjB27txJvXr1AChFWZUkfNQgSZY80o8seSQd8BCPEKqxFdTPu9UOKcQKVqtKQCFW1dBrtbpJyuEZMzQEyWzGkuLi4sWLJCcnM3DgQK9uFtHR0SQmJtKhQwckZ2lik6yQeVl9M8TqIRxt/RrhgDq/sTSHorhfAySDNKRBk3zc9iijRKOSkvBISG7CES4XktlwC4eFsvzke/z0009ERkbSsGHDHL6NAtwMFKRB3ACcO3eOjRs3cu7cORrf0YxSd/emfpn7KSTFqYTiJhidXAyEo5OMJHme7kJ4NqZ78wm3bUVkZCJS0zxEFBqCFBmhSj9WC5LFjGRWf0TRWC7XtNBv+grmzp1Lt27dWLp0KTabjeTkZNasWUPJqtU54Yqkhq02Ii0dYbcjbDbE1RR1rkybJ5bHy65j+FtXlxR1jS4XQngIyfi3Dskt4RlUT+FyeRGSJLltWRpCrFy6dIlhw4bx+uuvExYWlj9fYAHyFQWSzg3ArFmzePnllylepygxJetTZ0cRRGoaUqgaQ4MsqUZi4283wfjaMoQmPRjtHm4IxQlCQbJaVeIxmZDCw1SbSHSUSg6KgkjPALMZW6lCFDqpEJLkZMKyw0S1uJ8HBj2O7cp5TJKEpVR5qhS5gzInYyEz00MOkqwbeiWTSXfRa+uSTCZVCtHUIeN6dbUosGqlSzvgvibGcxUeKUq7TqEh6m+XwuLFi2nVqhX33nvvNXxjBbieKCCdG4CpU6cCcGFXAq0r90RJTFLf0CUbCTBsPoPtRrNlZCEb8G8LkWTVviIMx7tcSHExegSxBOBwEHL6KtZLZlwRVqKPQmRYZYp2fgY5MZ3IBCfmkwkol1NB2NwkklUdEppEZViX9powqFeS7EeoVoRKZIFsOj7jeo0PSIoVEVeIX3a8AkDnksM5ePCg3nmjALcmCtSrG4DnnnsOAAmZ0AR3oz2Tx4OTZWMZVRLcm8zojtZ+soMkqwSUkYGw21HOX0Rcuoy4kqRKCrKMEhGCZHdiTsrAeiWTsLPpRJ62EfNPIuZzSapE5FIQDqeHcCQ/t0wQWebC1zMFHsIx2oL8wdfr5j5/YbcjXU0HYPDgwSSmnSI6OvqWqUVUAP8oIJ3rjL///puXXnoJgMYlHlBtLxqMG03bWEY7jmIgn2CIxh+MNhG7HZFpQ0m8gnA4MCWlIdld4BLIl1OQk9OxHr0IqenqMXY1BULy42r3nkPK/n9/UAIQbqCxNS+eYS3C6URcVnOsPv/8cy4WzaBv377Mnz+f8+fP57yGAtwUFKRBXCfYbDZeeeUV3pj6DmEhsRS1lqd6aBOUS4mq6qO5tfGoC3pcivZ3fsNtH5EsZqQSxTykZ3foGeTCndSpr8HXyGs0cuuvBdebXbfxmEyez7t8PFzgMZRr8L1HdcLyXEdHCIjqlbCkO2lyt8KmTZtYvnw5ZnOBBeFmoCAN4iageI97yTx6lMq9n6TiP2HIl5IhPUNVqzQPszH2RH1FjzVBaCUl8lkYNRnGc7kMJCIjXHa/BmovCOXa1qTZdrIjVUnytmMFsO1o4whJwWKTYc8JpMKxbFoSilxcZvDgwXz22WcFxHOLoUC9yicsXLiQGTNmoCgKmZmZpPz+JyU79abMmRjkyynq091sVknGR12RDBG6gPfTP7/gM6cIMbvtRG4vkOYNChZeKRr+PVC+P1mOD0Qk/mxc2UGLFVIUSEnFnJyGOFGHS5cu0aRJk4L6y7cYCh4B14ATJ05w8uRJatWqxf333w/A/fffz7Fjx4gghuo/pCAyLoLFoj7hnU7vYEC3GuFxixtc0tcJkpaj5XQbcc0mVaqS5dyTnVEd1IL2cosABmQRyLDsT0Jyv6YFP0phoZhkC8rROrguCR5++GEqVqzIs88+S+PGjYmLi1MTZgtwU1Ag6WQDh8PBzJkziYmJYdCgQfz888/6e8uXL6dChQrccccdPPjgg4DaOWHx4sXc03cYEVIhPWZFUyn0p7HPDS8UH7exv2C5a4FPGoUUGQF62oLiSWfwcXMHRKD1ZSeRSJL3eedFygnCziWcTsSVZMi0IymCUmHVqJrWnoTNCmPHjqVChQo0btyYCRMm8OWXX7Jo0aKCgl83GAWG5AA4duwYdzbsSWLmGdJtl6levRp79+5l7dq1DOr3MqfP/UWdst0xSWaOXdxAZGhxMi2ZZBa1cmX3JuKLt6e8ubqeKqAFrwmnUw2mM1x3NcDO6bWZ9Wzz/JB6DKQjyTJSRLiaxiCb1KRNm92T5a1lpxuNtf5gXJcfo3KWuBwtO1z72+XKmioB3kGQ2RGOcV2St6QohYSoQZER4WCzQ6ZNDztQMjK55DzNFddFMknFgQNndAatWrXi0UcfpVu3bv7PtwC5QoEhOZeYP38+Q4cORSKahrUfwRQWgRAKexnPXXd1pnhMdZpUHUykJQaEILb8g4hQMxmlI7GkOEmtWYfYtEh32QdtcxjsDj4Qmj1Fi0b2DcTLDxjTKULdmdcmWU8GlSQZoTiDk3R8YVSzAs3tz6YDBsNyLud1lwLxB+FSC5pJNrtavVCrfKgoyFYLRU3lKGIvoSbWCgVHsp0+fR5k+PDhREZG0q5du9ytpQC5wv9rSUdRFHbu3IkkSXzxxRfExcWxa9cufvzpZ+rF9yPOVAI5wy2VOF0oFhOS3QnhIUhORa16p40VEYIzwoolKQP5aob6hLXbddLR3eLGOjdZUgNQvTG+pHNN3iIf1cpkQoqKVAuAmUyQkamuyelUVS7dKJuDpGNcV3aSjh5nY/jf3z3n4yLPMQI7EOFoZUGsVqSYaDUK22ZDpKap11UrhuZQC6WpEpA6VmrT02zatCnfOpn+f0aBpOMHixcvpveDD1O4SARnzpwhNrYKUdaiRJgK0arkQKyOWKSERLBaECmpSBaLWuVPUVRCASSTDCEhCKsJyamohJOcDpk2tfqfMRAQ1A3krofjXezKICnIEpLIJ8LxByHcFQfdrnqn0xN46Bsfkx2M68pJ0vFVtbSMc30sKYuq5eUyzyWE4k79sNvdIQou/brrOWEmGQnDwwAIDw/nqaeeytOcBQge/29IJzMzk71795KcnEyf3k+TlHSMWlUfILpIJWqUciKn2ZDsDpVQbA5Iu6xmU7s7Iggy9GhhyWpVjcShIeB0ITmsas1ghxNS09wZ3waDsVYpzx0MKGm1ZbRkRmNAoDHdwPg0v9b4GM2u5HbdYzZBqppCgCyB01BaIlDFQa/xAqzHPY+XVy5YGIjHb4yOMfkzJ7ilN8npUtVJrayHVhLDZEIAstWKcDoQiqBMmTJUqVIld2suQK7x/4J0PvvsM0aNGoU9Q0Y2WyhRuA7xNe8mxCEhnUlSo3E1Y6rdoRaNstsD3+BaYSmHAynEiggLQbqaikhLVyWVQoUgJVU11kqSmvGtGU9xbyhtMxmD9QigPujJm7l0qfuRPiSzWSVRqwVJk3Ig62bXPxDYdnJN0KQdf65r3+BA/TPBqz1CEepDxGwGyaqqVSaT7lYXkjuR1qWSpyQrDB06lJ49e5Kamsru3buZOHEilStXvpazLIAf/OdtOtu2baNZkxY0qjGYqLASyDaHapdxunQ1SSRf9ag9GoxSikYQ2msWd7a2xQKREYjwEKSUDJVoUEV2KSJcPdatguFyQWqax2ZiqLTntblcAaSbQOkI2cGXdNxSmlTU3Sc9NU2tU6wVgTfW6QnWhe/Pi2W06/h6rXwLffmWvgC9Fk+2dh0/a/KtKS1ZrUhhoUjh4WrPrvQMj5dQ8i4hohVEa/xcZSZPngzAxo0badasWeBzL0BAZGfT+U/H6Rw4cIBWt7cjvmJXb8JxOFW7S0amSjga3E9DtNgadyCdsQwoFjOSpLaCITREb3CH3Y4Qiu6aFWnpqoSTkQlJyYikZFXtkiS1iJbVqqppJpO3GuKV+JnN1yOU3EsgQs27QlHUiGTN5pTfnjIj/NlzbhSM5K6plRoMJTUkk0mtQaQI7r//fqKjo3nttdcKCOc64T+hXh07doxZs2ZhtVrZtGkThQsXxmKx8NVX86hWpj2lIm5TJRGbQ/UoSRLiqrsZm794El+4VSC9iLjJTULubgPy1QzPBna5kCIjEDYb2J2ARRXpNdXK4VQlJa2glmbYxGA8FS5PjWFtzkBqTjAqlyYBuLtG6JIZqO5krWlefiO7qF9/1z3YNeQk5Rhfc7nUVjlaqoksgUs73uWuSa2OJ4eF0qBBA5YsWcKgQYMYPXp0QWH364B/taSTnp7O888/T4MGDTh+/DhOp5OEA9Hs2pDG1rWJNK/xOBWiG6idC9yEIzIzVcLRJBkNvhGzGtxSgKSJ4ya3ShASgjCbEBaTajy2q8F1xoxxoSgeG4KhnozItKllPkG3NXgnOBpjWvwEwflDIMnHq8i7e+MJoffWkgxj5tVb5G+unI/NGpmdpzSK7CAUT4scw/frRVBuyVQym1mR+gXr1q1j1qxZJCcnc+edd+IwVkUsQL7gXyXpOJ1OJElClmU2bdrEiy++SGxsLHv27KF06dJ0qvkiRYvUUOvDZNohzQaOFNVIrNXwheCkG8hKOJr3R3tPBjk107ORjVnjWkwIeFzkWpqB+4krDIZcyWrRJR7NuJnFgJxb+CMBsxkRYlHd/ZDVU3U9Y1T8pThkQzTBus39STk6TCbVfmexuAd1t/ZxZ9gLRSDh8Sy+9dZbxMbGUqpUKex2e0HMznXALUs6Qgh+++03Fi9ezPr16zl79izJyckoioLJZKJIkSI88cQTPPPMM9xb/QVEeAhYTMjp7vIMiUkgSSipad7lI4J14xoJR/0Dvf2J27YjrGYkW6Y3oYFH1YIsT9mA56slK4aGqPEjDu8YH2MTvmuCtokybWoUMq5rI5oArvOg3OU5XZNr8F7pYzicCKEggWrPcjpRjMZoN/Fo6m9MTAwtW7Zk7ty5uZ6rAMHhllSvjhw5Qs2aNXniiScoV64cH374Idu3bycpKYnk5GQyMzO56667eO655zCbzYgQd8sVh0s13CYmITIyUVJScxfwFggm2XuDaN4ru1P1WOkN5mQ1mNDdg0qyWj22iiA3tsjI8MTwGDpFQA5P9IADGs7dZFLX5/YoCaF4e+zy66kesPaNsVKij/Hct7eXP68W5E3q02xWmlTpVevZPZ67i+jQoUOZNGkSycnJuZ+nAEHhlpF0EhIS+OKLL9i4cSMLFy7k888/Z+DAgX5LECiKgiRJdK7yLCLM3TrW4UJKTAIhUK6meg7WumJmh5zKMgjhKUnh9oIo4VbklExVdDe0WJHcSYYCxROD4yvp5GQ01YprGaQIrQlfdsQjyVLgTanVzHEpqupp97ZVXDMx5wf0YEk/iaB5raSo5V2ZTeqPLQB5CwWQmXT3p/QY3IMHH3yQhQsXEh6uhj7Y7XZ++ukn/vjjD4oUKUL//v2pUKFC3tb0/xy3DOksW7aMZ599Vv//9ttvD1jzRJIkOlcbA1aLGglsd0B6hmqg1RrQ+euKGSw01UqzyZjNHsOnyeSJpcm0edqyaMSm5TGB5zh3K5ksnR38npysG4U1D4v6cj6oVhYzIjpCVQtlCTLzyWuVXbS0b2xO0B4qn+MCRCMHI/3pOVdOrXOFf++X5FIfFPs/T6ZEj2I0a9aMDz74gAULFvDRRx/px1auXJnx48eTmppKREREcOdTAB23jHr18MMPk5iYyLfffkv16tUZPHhwwGM7VxrtzhtyIaWkIa4koSQlqx4hr1QCP/Vb8vJE1zaOO2dHHzI93RMHopGSxeITZew+Nq+ShNAihbNXM4Iqnq4IpNQM5EvJ2ac6XI/6zIHgb93+HhS5XZMvCSpCfUj5e88r+lsgCTj/jZPhw4fTt29fL8IBVf3v1q2bLgUVIHe4ZSQdgNjYWB544AFcLhd9+vRBCOEl7XQu8T91U4eFqi84HGoGcabNu94v5Czh+CYd+qhYkiQbKutpcS4mXRKRL19VkxaMqoAW2ZtNBb7ckI+qUsn+JYk85mE5yhbGcuqyd6cJCCyBXEsKRCC11ue7kSTZIDG66w751tPJTd6VL1wuREQIXLqsfocBi5ApgJYfZ+KHJ9ZxynaKLl266AXcvvjiC1q0aEGpUqUKqg/mETdV0lm6dKlfL8GhQ4eoXbt21i/VbFaT94RQ1ankFJTUNHfVOz9lFgJB2/gBCkjp0MZyRxKjqHEfSlyUugF8ycVk8vJy+W2Xmwvo0s21Zppr/dA1t396hroR/eVb5YeUE2gzGmsj+1x7SZL1H78IsC5JlgJLedpYWlS5If8tO+h1rIVCB3Nvvfc8wMCBA+nevTvbtm3LcZwC+MdNIx1FUbj33nvp378/x48fB+CJJ55g06ZNrFq1ijvvvNPr+M5lRupeI5xONdDPbve+iXJr95B9DL2S5D2GXnJBeI4VAsklwGbLMpxktXgqBWr2oPxAoMC/AK97GZy1EhayjBQSgiPCnFXKyc2cOSGXpOVLMlk8asGOk6XYveF/pxOhZc8HK51Iki7Vjh8/nlq1aumdQ/fs2cOcOXNyvcYCqLhp6tV3332n/71r1y5KlizJBx98wPr169mxYwcTJkzQ3+9cfJiaNGkyqUmaGZko6ememzMHSUAvsxBk8XA9GBDccTmyh5QcDneulZ9IVZeiqmPgfpqT/ebOYYNqHqtgJJ1svVqGIMXwvefU3lbZ9ZXKC4xJlPrEQW5wTXUyyUguVLU10JqyyXr3K/FIWt6c+p6SkZn9WrTvWeuUAXQJ60eEKMHRojv55ZdfaNu2LUoQanJmZibHjx+nevXqOR77/wk3TdJp3rw5Y8aMAWDVqlX8+OOPxMXFkZqaSmRkJOfPn6djWH86xQ3xJF66XGoFOJstK+Fci3fHJ45GV4s0r5W72px2jJxocMkbvTImWS2PYRzX38bLr3gYv/VsfCQUA3mmNanocfH7rsHYQTQvEo62Fn+taYIuDCZlLXzmi1ysTSchRSCfSVDjpoKBpiYbECXFMH/+fB5++GGOHDkSVE7W9OnTiY+PZ/DgwdjckrHNZiMjIyPoc/gv4qaRTtmyZbnnnnsAuHLlCsuXL2fcuHEcOnSIlJQU+vbtqz75TCa1Lo1Q1MA/p9PjFs+vqnp+DJuA98bUDJvh4arkoyjexmj301HyVav8EUwuDJDZeqUMG9DfcUJRc4r0ouQWNdFVL0fqrzRpXu1QIg+SkxYUqKm1gQzPRiLL5XcuyRJSpXLqA8QgvfiFyaQWZpMld1Cp93m80f5jXn/9dTp16sSpU6eynddms/HDDz8wffp0vv76a86cOcPLL79MaGgorVu3ztU5/NdwUw3J2hfXrFkzmjVrxvfffw9Ae9ODdAx9SL0BQtxPJ6fL3UkhhyehhmBu/ECxI9oGMNoANOOn4oKkq56EUR8jrO6K9o2sDXZtPpsi2zgUSdY3ob/jjAQolSiGOc3lqZ1jWPM1kY33YnN3vHHNZrPHAJ+dZJSbOdzXRxJCjalyOAKSluQ2tksmk1pjSHuw+WDe4GWMGDGCZs2asXnz5qynpCg4HA4eeeQR9mzey7Bhw4iIiKBPnz5MnDgRIEfC+q/jppCO0+nkwoULWN3i7qJFixg2bBj79+8H3E9ts9nTM8qlqPVp0jIMm9pPDRpfBEM8BnKQTCaPqxxUG43R4yIESmwh7xgX7ens27nT+LnriOwkIcnifrq7FFwxEYRu2O+90d2EoxGWZoDO7ieHxeh/+i3A5QtNygH1t82w0QPlq+VWupUlnDGGeBo/pCWZLaqUExWpPjgcTrROERpWKt+xUlHtkCue+4uiZytwzz33sHnzZs6dO8f+/fsRQjBp0iSsVivz5s0jhiJ0tvYhPrEpsbGx+lhVq1bN3Tn8x3BTSGf37t2UKFGCBx54AIDo6GgA5s2bR3vTg+rTKTTEY1NxODylGPKz4JRPO1/hcqn2HJOh9ormZnWrI5JeukLx/GS3sXw3Ti6knGDhr3OEZLWoGeXuzZ9UI9Id+2Iw+PoQji7xZLOObAnJS93TbDyKlw0poBRjNulqTZYxrgGSyYRidZ+v04lkMiGHhyO7A/ukkBDkmELIheMQNhuu5Ksotsws1+DAgQPceeedjF83EoCiUimmTJnC888/z3333Ud8fDyNGzemR48e1KhRA4Aq1AIgTIrAuSJSj7jfu3fv/+vs9ZtCOvXr19eZ32w2M3r0aMqUKcPUuz91tw+xuD1I6uYXNjtKpsFFnZunXU43u559LmWVVLQNqRk3c8gW97KP+Myf8zrzrt74bnjclQ3V0H+nKvHktBbf+Y0ElBv1S6vIFyBhU08DkQ0xOZI7INDh9AoKzI98MCkmmt/WjmX5hY9YkTmPFZnzoHwppOJFMRUvhhxdCCUlFZGejpJ8FeHM6pX81fUtDz/8MKVKleL+++/nxdXDAejatSt///03mzZtoi330bt3b9q2bUtSUhJFKY0Fj7FZkiS2TzlGQkICZrOZo0ePXvO5/Vtx02w6M2bMAKB79+7s2LGDK6eTPZvFatVD1kVGpq5fB+x4GURsSLZPTa2mrxacZjJ5p1NoxbnCQpESr+qtTPTSpP4KUhkQlKpxDdCui1HikcLDUNxeEqlEMeIW7fHYcgxpGkFJjrkheV+3uf66z2tGQnEXsMdgD5Nk+ZolHcmda/b+++9TpUoVKlWqxIABA/jsl/+x/OCbKJev4Dx3HiU9HVfilYCpIadPn+bw4cPMmzePr776ij59+vDJ0bfpVfgxKiTXpAyVkCWZFc/9ReWEepQ/W5s6NPMbsdyn2DB69+7N888/z+bNm/9fSjw3jXQaN24MqJJOUlISUcSqG8Do/XFXfQvaeJwb+OlEIIQ7itj3CWvSxHMXIiNDJw+v5E2t7YxucPYzjhH50LtcIxu/tpawMIS76PrF1iVUI7zupRJe8+fYvji3xcSMwZSBoOWxaQRv2PBa/SOdBHKpUusqn8PJ8MnNGDlyJLNnz2bFihWULVuWRo0asXnzZlWNCgKSJGG1WpEkiY4dO/LEE0/oqlJRqRTVpQb6sZFSNBFSVLYpEjunnaBYsWL07duX0qVLc/vtt5OQkJCrc/w346aRjiZehoeH8/nYBbgkTyqDpLVuybSpxa2EkvPGyCdoHSA1GKv76e14JT/lMq5THk6Okohb9dGO036Lq1f1Q4r8nYRwOD3X0Cta2X3NtbwygzcsYAkIX5XLmJQqFK/YIF8VyasflhCeKPPsyn3khaCFghxTiLfGrqJcuXLs2bOHqlWrMmnSJN555x0ee+yx4MYBihQpwuXLl3G61exhw4axevVqpu2ZyK+ub4MeR4NZMnPwo4uUP1KXCufq0LRpUx555JFcj/NvxU0hnUmTJjF48GAsFgsLFy7kJIcpJ1UDUPsygdt4q+hlJXPE9ciMlmXvcR2ehm3gY3PIjZicy/5N2cLoMnf/bSpTSnffp97XGPlKmud4jRD8EIdmB5LMFmSLOQvhBa5DgzcZuG06wp0SIhQlq+qixTjJJjXKOz3Dcz2NUk6A8/WHLOkfZjMRJ66yaNEiJk+ezOOPP87Jkyfp1q0bR44cIVUkBxzLiNDQUOrUqcOsWbNQFIXTp0+TmJhIzZo1kWUZl8ibJC5LMhFSFLumnWD16tWkpKRkOebChQtcvHgxT+PfqrgppDNu3DjOnDnDuHHjSEpKogRliTOVROtB7RUBnBvVI6/E4xu67xtJ6y7crUft+gYTGqWeQHWYtbF957sWGDagVwGvUKuaCAtkxsq4Tp32/pxPuQyP2uUhIp3EDD9e0pBBKsoCH6O8X/uMLENEOKSneyRI97FBl5T1gZdNS5YQsVEIReGFO6axZcsWNmzYwOTJkwkLC2PixImUfzAuqHHbyw/wySef8Mknn1CxYkUa1mlMVeoQT0MKUwLpGrfRarEIq9WqRy0fOXKEGTNm0KxZM+Lj4ylZsiQ7duy4pjluJdwU0rnrrruwYGXVhC3cTgcqmlQXo9Geo3usNANpfqtWRuLwJSvNiGyMIdFsNbkoPZplHp3M8smeA7pEoJOE2YxwSwqm2GhM9qy5W0aJIJAk5auuea01kEfLTVaS1armphlSK7y6YSiKSuJax02nyxBl7t/rlRNOug5w0nXQs+7wcD1GCSEYXO0FKleuzIULF0hKSuK+++7jt99+wymC6/ZQp04d7rrrLmw2G6UoT3mpGqWlitSXWiJf4715/PhxrFYrhQoV4uOPP6ZZs2a8MuJ1Mv8y8dtvv6Eoih7T9l/ATUn47Nu3L5cvX8a6PYQQOdxjdNPq17jUm1C4XMiWXC7R6HUKBD2gT/I2qPpuTmMekNnsCV7zEf81tcCv8TCnzXOtbXvdn9UkHclkQRw5rr5VviRxX29DaO8H2hxCQSiyZxx9aR7i8Uo8NXYd9SmrCqg5aHa793n5i7/JyEQKD/M2uLvd/DpyKF6mIUOkqQRiQg+7IOGKmjzqLjOburk4hZolEBsbS+/evTGbzaSSzBZljddY7eUHsoy/evVqvvzyS5555hkmP/+m3zXkCJ/Ss9rfb7/9NhcuXKBKlSqknbJRhboUktSQkicavEjRokX5+++/9fiffztuiqQzYMAAtm/fztjf/oeQDDeV5spVDBvpWpFbA6+2OdyxI3o+leYiNx5jnCZQJ8sbVOhJIwVRrbx+Q59vEeMtyZhk/2UjfIq/Z5F+3NJmlu/DD+Fo6QRoJGUy4VuvRygKFI1Ty4NYrSjuLqt6Cx693lEQDxA3bjM3oIapiTqO1YooFqfXO9K6PcjJGfzwww8MGDCABQsWMGDAADY5VzFx4kRq165NgwYNOH36NEMWPMDAL7t5ubNLliyJyWTizTffpAK5yBrXwkDMFs+10V5zPwhWfryB0nJlSp+Np4F0h044oAYW1qhRg6JFiwY/5y2O6ybpbNq0iQkTJrB9+3YcDgdRUVHcc8899O3bV0/1b9euHTFSERqb2wOovcFlGWGze+e+XIv4GmQ5CyBrcKDRvuNSPP2rfMfHxyvjT6Xyp1rlEV5Si09jPjkpDZdvKVOfanlG8vBbBtXghtePdROMr1qnf0Yb2xqmexyRZE/CqUYg7kL5wmoGh1PvvwWo0qRWj0iSru2RKMsoGd5pM5Isqx0fvuzGhh2pNG3alJEjR7JkyRK+/fZbvv/+e8qWLUuNGjU4f/48lahDDEUAeLLWBKqJxtjIIFKKznl+g1TjMRFYslw74XJRnmruf0DtP+S5nr+6vqVWrVpERkZew8W4tXDdJJ0OHTpw//33s3PnTo4ePcpvv/1G6dKlefLJJ6lYsSJxcXGEh4djF5lqWVJjXWPDE+GakUMjvRzf8/2833wgP6kOwdgk8ppoaVRvDGPIFcvpqsnVh5pS6qeTns+YzX7LqGaRYPzZf1yuLOvUI559jcp60qbBCeBSvFRZoShISSlqaIRLk2rVWCg90DIPQXO62lKhNFLi1SylLLTNPuODA1QMr8err77K33//zc8//0yzZs0YPXo0oEbMlyxZkhJdIlVp3L0Wi2QNmnAkWVI9gFar3sVVJ13NMxioVrPh9WXLlmEymbj99ttzfT1uVVw3Saddu3Y888wzpKen89RTT9GrsBoXUZjKNKYCznQ7ZtmK2WRBQuhPRVBvaEV/GuRjBb6cYCQPbTO4bUq+AYo5Rssa6y1rVeuMuNasbllSG0UYVSOrGeXwMYQicIRJKOcv6lKOJJvVzqH69ME37wtUNsPwj3ag2nEiNc0TuOinsqNcrjRcSYYQK8rFBPcQCpLxGuvG+yDJR5PETCbEkZP8kvYlnas+BykpHklPkUEGy9aDiMrleOihh9i/fz+1aqk5UitXrgSgVq1avPbaayxZsoTHH38cay0rv/76KytWrOCTQd8QLmWVOpZmzOWPP/7gjfYfY7K6t5W7Lo9kMdzDxlZGdjsIj33H+F2uVL5DCMEdd9zBuHHjkPMhD+1WQb6fydy5cylSpAjjx4/nzz//5Omnn6a51NFzgCRjliyEShFYJKvH+CoUj0qVX7WBc4Dferzu/CphDHIzdoPQIpn9la7QXtey42XZ45HLIjFd47n52YzOmLAs9hltLqO04kU4eaxK6CUhGVQJyT2X4nB6Eme1fCxN0jHLqs1La/ULSKEhPipbLshGS72QZOSypfj0wGRef/11Pvv9aeSwMHflQJO3G//UOfr06cPChQvJzMzkhRdeYMiQIYAqpVeoUIEnnniC/fv3ExMTQ6lSpXjttdco3iPM7zKefvpp2rdvjxSiJipLISFIWqUE430BetNDKSTESxrTrqkkS7z77rtYrVbWr19Pjx49grsW/xLkq6STlJTEs88+S8eOHenfvz+DBg2iZs2abP9nPS1EZyQ5sNQiFOGRKtx9itSb8DpIOpLk3YGArATkm4zoJfIbM6i1YzT4s+u4y2YghNrGFzyGVsi91ONWVXwTPc27jqIIBXPJ4pjsBmLxY8PRbTY+l9foWQkGHinIhBwVpcYHSbI+rkdCVCsEyOFRkG5Tif1Cgm6/UVscE5y3LxBMMuL8RRrWaMfFlIO8+OJLdCw+VA3q9C0v63DySK0JdOrcibi4ODIyMihcuDBdunShQQNPWoMkSYwfP54LFy7QpUsXKlWqRE3RnFDJQD6SzNdff60uQYsz02DMu9NCLtwqqGS1qqTjcunf5ZLULzh27Bjx8fEAtG7dGouBnP8LyFfS2bJlC7GxscycOZP//e9/bN++nX/++QcABzasZN8nSNvoksWM0DwguUUwKoPmCpbcvby97EnaTe3yjtXxtxmM5JOd+GtoxOcJEHS/lwP56IZbX8Oub7GvJrUQOw4CcLZnRUp8vNUjgZhMWYpSGccxkkx2hJNlDVnO0xDbo6nKRmnIJENUJKSmQWgIIjVNJZzQELUELWR/vb0X4/2/W9UULoX6xTqRbKlFmD0EYgqBxeRJ1E13lwp1S6xnE2rz2muN+Pzzz3n00Ufp3bs3GzZs8Gr22L59e32aypUrk7E1lVBU0pFD1HZIKcmpRJuLuRtACg/JuM/FN+lX+06k8DD9/7knp9GsWTP27dtHXFwcoaGhrFq1Kvvr8C9Evuovbdu25dSpU2zbto0vv/ySC1/baMAdlKICJsktRhoMn8YbXJI9YfOYzd5GwPyoagc+pIJ3ixiTQXVSFE/1QCHU47LzgGVLOJJHvDbmbBm7Txg3ZoBoX291Jqv3SgkxoWTa1GuqnZZvuQ6jRwXy1LHClwR9x9a9VrLsibdxE45kMqm5VhaL3qTQq7zrNWZca5n/UrqNaKkwFsWMcvw04shJtA4dUvGiamkLt+oTdjiBZs2aERUVxZNPPsnEiRNp0aIFv//+e5bxr169yj///EM0caoqZ7UiWS3IkRG0iH2ABlEdvQlHCDXRVvN6GjyYQuuvHhqiltzI+IoJEybQokULRo4cSWJiIiNGjMBsvimhdNcV+XpGJpOJH3/8kXvvvZft27cDECcVI45i6gF+yMNz87qQtMxsiwUpNARJK2CdV/tHtkThNsQaN3JOn8ljtKxvj26v7HTdXiRlK9n5kzKMQXvCJOnG25JrL3uC4jSXtTqIt+ShlfRwjxOQUAyv+a5D+5wUGqI2PdQXZ1Q53VUZC0XpT3+Rkuq5jlodHX/XPofr4g/CblcJxmxW3fcuF0pikrqstHRVtQMoWQxMErGxsWzcuJHu3buze/duAMqXL59l3JCQEDIyMpBNFiTZ5FGPZIkIotWHk0vxEI4x3sh4PrKkx0uJpKtcvXqVSZMm8dFHH3HHHXdQsmRJQI1n+y8i3y21YWFhhIaGMrjK07n+rHA60Ts/hIWpRrl8MCb7epokw4bT/1f/cC9EZE8weQ34M0haXvlIgXKy/Eg7WVQxt8fGvG4XAFceaoSUmuktLfkLCJQlLxe6L5n5/viDkagkqwVhs+m2Cb2UhrYGk0ntzGqzqz3LFMXjSs6JxINQmb1URHdJFE/1R1mXsEWmTa/RJE6cRhw9xVO95lK6dgcO7jOzbds2ypQpQ3p6utf4J06coHr16kQSg2yxIheKRIoI97QcArex3EA4/mpvg/p9ux8Gv1yZzaeffsqqVavo3bs3v//+u97Ir3Tp0jme978R+Uo66enpDB06lBIJlbBKObfo0OBVckFPmJTUJyMEr14FY8/JSZIx/uQ0Tm7IR3vC+Yzvl3iyU4kArVOBttFsrWvp18geJaluaMM4flWhXBKnPxLKoqZpSaFut7CkxaWYTGpMjhCI9HRERqaH2I0SgeH8rglabJG/70hT712Kp/7R4ZPUOl4K25DmxMTEoCiKHoyXnp7O+fPnuf/++xFCUMPUCLloYaTQUPXhqHmntGthMetqtJ61bzFnkaglWUaOiaZr164888wzpKSkMH/+fIQQvPDCC6xdu/barsEtjHwjnUOHDnH33Xdzac9VilEm+4P9hM3/av+aFRlfUaxDKocurlVjSiwW5CJxnidVbhBoU/uDZr/RXLyg23NyFO1zIh9/nw+mx7cPgerE4W78Z9z8QiMBswXZiVvEd29qpzOw4Te7a5pTJrnXcd7GbcngGpZMJnVzWiyQafNUYdQIx+HISjKB1CzfeQNBeBJz9RbBxuP9fFa4XFSbcZoa41RX9V9//cWJEye49957KVmyJBe2JbF27Vpi2snsy/wLpWRhlCIxqqQTHg5xMUhxMVCyKMptFZBKFveQklvV0+xIkkUtBL/42FSWLFnCzz//zLp16/S1DB48+D/dpuaabDonT55k3rx5HDt2jIULF/Lcc89hXrfZf+KjJLPS9Q0nT57kzz//JD4+nmcbvc6vjgUkJyczbdo05s2bx/Hjx7mUdhmzKYyKsY3UGyciTPV0ZIegvFay51jf6FwjEQQyNmcHX3XMqKIZc4hkSTX0GtrXeNl4cppGlj1uaEkGSWBNtiMUgalQJMU+22qoxqfoKpBQDD25ZMnPRvchdt8kzmwgR4TrpTQATw0kzXgeHqaWJE3PcFdUFJ6AOS1aWf9w7qWcQB43r2sqS2pwoNfCvdVaJeEy5aZfYa8UzciRI0lNTcVmDaFMn8c4Oe9jQkJCcDgchBcqQdkSYbjCTSjmQkgKhF104Iww4QpxG/YtEQipKK4QiSI/H+Zqy0pE/bZfl4oks5mu8WMBiImJ0e04/x+QZ9LRDG8PPPAA3bt3Z+rUqdwXPdg/4RjQtm1batSowf79+0mISqBGjRqcO3eOTp06MWnSJFq2bMnatWvp0aUnpSNrYDWpth3hfkoGBV8pxxeyDChoITNeRuRrbbcbTAi/LIFL+Cce30hcX9LTRXkTwuHEVKo4zk27kUwmzvapRolPtqvXy2535zF5Msj1sRRZd5VnyePyJR6vuQ3vSwYCB931L1nchmuTod6125MlUtPcdju3hJaXYEA/8DWAC0UgSUKV4zVJNKi0FPWYmqG3AzKu+OIIITjUMZS1a9ficDiIrt+M+Mr3kR5jJvSKi5BUhZDLmZgup6pl2FPTcFQrjTkpA2dMGOakDC7dXQVJgcSuNbBHSZT87iBIEvM2v0CRIlP/37UdzhPp7N27l+7duzNnzhw6d+6cq89KksTrr79OzZo1SUhI4MKFCxQpUoQSJUrox3Tu3JleD93P5iV7qRjdCDAhh4Wpxj+bLesT2MsG4odw/KktXmH8wq22GFQFY2eH3MYL+SNe34xpk+zl0cpuU3gZSbVmeW6pJa1OKUJOnXVndrvnNtYb1vKjTLJ3yYiAa/e5tr4Sj69xW3sgZMk2l1XCCXPbPtLTvWNUDLY7Hb5eHl/k4MnKMa0jJ0+Y+3sTDrVVjenUBTCbiZ8cxsuZ86nWsA8VE4rB8YOqami3I8dEo1xORISE6AZs0+arCKFgcgegFj4eokrsIe7uoWGhJLQrS6sxHxAbG0tERET26/6PIVekk5SUxGeffcbUqVOZOnVqrgkHVO+W5hkoWrRowJT9QYMG8eOP3bCmRVA6rLoadOV2hQa8cYxxMAGgt7Zxizn6/5IEirHzZT7FBgUDX1e6lmHte55mM5IsoygCSVu/y31MjUpEn3B6XNdGgvGT8uAlFchZEw2DW7db6nK6pRyrxaNWmkyeXlZOp+ox8nWLG4k4UCE139eMyM7Wp+VamXzGCERMXnl3Lu8YpoxMwlIFFS5IKK7zXvO6LiaAJKvGcX1urZOo2y3ufk+yq2qwdDWVIotSkcLDiKtRg/LlyxMXF8eOHTv+c9HH/hD0XbZ27Vri4+P5+++/+fbbb+nXr1+WY7QOiFlguJmrV6/OkiVLcpyvTZs2bNy4kcNpv5NptoPFjBQVqSaF+rtxAmV/++ZGgRqZquUDgbulrdEg6t6Q+RWUqMGQfwR4e7Pc6/MiTbfq4/EWqXlNktUCkowcFkr41mPIYaG4IqxEbDji1ZVUKMJjzDWWfjW6x72C8/ycbw5EJEluG5NmjAcki0X1VmmeHZvNI+VoxGqU7AI9RHxfD8Zu5wt/EqTv96AdZ/CkeQX02Wx6UTn1zRzuiwBqqk70TgdKSgquCxeRN8XRsGFD9u7d+59K6swOQZ3lTz/9RK9evZg3bx5z586lRYsWAY81tl/V4b7oSUlJLF68mIoVKwa1uJo1a1K2bFnWHvuIi/aTIMt62LjXBtJclL7RvkZo7xnjKozuaVkCp7F75zW6bY3wLXXhL1hMSxL1si8ZIrbdSYJ6xKtQsDephsi0IZlMpJUJ9RRBc28OyZjGoWSd/5qKpLm9jhoxS1o3VmNIgNndF9wd/OfVBSKvqmtuvFja+Nl1mfAhIMnH2SAyM1UjudMZnDcvp3X5EJapXQu9E8Rnn30W3Nj/cuR4BY8dO8aAAQP46aefaNu2bdAD+yOfXbt20ahRIwYNGhT0OLt27WLRokUkhe3ALjkgMgJJsxNAVkkmGNc4eN/0IVaD4db9xNONrvlMPhqMN7yeDe6RaHRXrwGS5HlNKAJzijufqlxJrEnuxn/uVAhdyslSEN0QY+NvY2RX40cjSG2MsFBDcS63mmoy6S2N9X5WTqe+Dr9dHvJaVygn+BszCJsOoEZJO52eWs9exxnIJxgSyuYY6/p/6NGjByVLlqRly5Y5j/UfQLZXzOVy0b17d8aPH0+zZs3yNIFOPkIhKiqKkydPcuHChaA/HxISQvfu3enUqRNHLq9Xb+CihZGLFUWrQicZJQR/0MR+Tdw3esHccS/e4nA+Eo0vsivwpZXPMEo77oZ0ksXsNqKr78m3VUROtyOFhpBRIYbwveeyNiU0GEb1ze5bB8dPHpz+ngbfgEXj2Ha7KuUYgxu1v202hM2TaOo3LcB3zmDIJ7cxO/6kqkDF5cHz4LHb3TlSAdaUl2h5388ogjYd3yQ1NdXLbf7+++/Tt29fBgwYwOXLl3M/zy2MbK/alStX2LVrF2FhqkqzZ88eFi5cyJw5c3j11VdZuXIlrkD9iXywUvmO+vXrM2TIEOrXr89vv/2Wq4WOHDmStLCzpGRcRMgyhFqRw8MDSzfak9dPcKB3oqfb4ClpwYCG9/JTyvGF3mJHeBORYX5JC1DUwuYNKooIsSCdu4QoXhhzqtpdVNhsXpKEl5dIHdD/UgxGZb/FubI86X1tT55rLFncUo4QuqdN7wSRdeK8SzhesT0+Gfe+5+F7DiLwNdHWKhzuJouGLPx8qdmtzemO3pYsZtq1chAWFsann37KqVOn+Oabb3jppZfY+d0RvvrqK4oUKcKRI0fyZ+5bANmSTnh4OBaLhU6dOvHOO+/Qrl075syZw+HDh0lPT+fZZ5+lTZs2+vGKorB9+3amTp3KiBEjOH78eJYxx48fz9y5c+nbty/ffPNN0Au97bbbGD9+PHvtP7MvdS7FGp/hsVkdcZpzEfGr1eAFVUoyBLDpnqvcVKsLBsFKTcY2xO4NKwy2JUlTlSQJKSwUZ6EQiAjDVSgM6/EENdoXPKkK7l7w+ub3WpNi+DPr+rKtpyN5VCthd3hJmZJmlwI1x8pX8srva6uvKTCZ6jWHsiGaLMGJbpuZ0OrceE2VT8QD6v1otfDhq18QllGaTz75hHLlyvHUU09Rw3EHZUKq88UXX1C9enUWLlyYf/PeZEjZNXC3WCzCNx+kTBlPisO+ffvo2rUrhw4dQghB7969+fvvv+nQoQPnzp2jQoUKvPPOO4Cqqq1evZq6detSrFgxdu7cSYMGDdi1axc1a9YMarEul4s1a9ZQunRpVq1axXvvvUfCiWSaR3RVD8jG+i+ZzartxunUW8tIZjNo+V1aPpBD1eG9vFvXgmBIx6fWCvjYPiQ1i1szyspF4tRzkWWUQmHIF5MQyVc9MUxCLRAlFMWTdoCPHSeQWmVAluqCRqN9WKjqmpfdxdeF4pFynE5VrXI68a0jEzDo0Xti7/+z2+gaqWjXLcD5BKyUGMAtn6UutMGLmN08wULPyXJLhbhcuEoV5myhS7hur0rU1TDivt0BkkSL5yqzY8cOvvvuO0x5KEdyMyBJ0jYhRCN/72Ubp3PbbbfRpUsXKleuzPfff+9FOKAGCd52222AWkB6z5497N69m9DQUJYsWcKMGTOYP38+3377LWazmT179pCQkMDMmTO57777kCSJsmXLBn0iJpOJu+66C4D4+HjemrGYwqFB6LuaJwWyRjVLkueJ7A4IzHdXeXbw0+vbmAyJJKlpBmnpukqTUas0YUcTEWYT8umLKrFo3hUtWlkLIgQ9DcIwSY6bJkuTPeNmNcZKSWppV13KEUIlHH+JnMEQjr/5gkRQROA7tjGnTRjWF6AMy7VKOjrxa7YvLTpdkjCdvUzZsxLOUEipAPaWNQnZuJ91b+4nrfZZ5syZ85/oeZ7tNxsaGso333xDzZo1/Vaj/+OPP2jVqhVCCKZNm8bzzz9PaKhaSe348eOUKFGCxx57jB9//JHvv/+e7du388svvzBs2DCuXLlC586deemll8hO2goEp9PJpRPbKBlXJ0vV/6xn6WPP0W40qxVh1epq3kB7jj5HgM2nuXkNv7UYHblIHIpVQgl3Z/GHeiJhAU9iobsQmv6Ty80SjIqFO5Pa63WtEJuxR5jwJrwc4cfY6je2JsvHAp+jv+LnWdQqHxvOtUozAeHOvfIKQDRcI/OOw8StPMKVamqskzW8EL1792bmzJlB21BvZeTovXr11Vd57rnn/L6/bt06WrVqxYwZM0hMTOSBBzydEU+cOMHZs2epVq0ac+fOZebMmYSGhtKoUSOaNm3Ku+++y6uvvspvv/3GnDlzcr3whtHtCQmLJayKIW/FdxMbjcxGew6a/UHybBStqFJ+Sjk55mAZLr/xWC1c331z6qU8AaVEHKEXM5HTMtXuCYo7U9uQ9yScToTd4bELgXr+ZrO66d2N3nw3qbFkRZa2NMaAQqvFq/upJMnuFjcuvYiVXykn2Gub3XF+Qw0CuP613/7yyfypVcbP6If7l87yIvFoZVy9bF9a0S+vpavSbrG/Ujj7cE2QJSZMmMDff//Njz/+mOt5bzVkSzq7d++mc+fOukpjxPnz5zl27BiNGzdmxowZvPfee7qUA6rna+XKlTz66KM89NBDPPbYY/p7AwcO5JdffuGuu+5i+PDhLFiwINcLP5Oxn/LhdXCGmrDXLq/aPMCv9KA/jbWSD7KkllqQJCSb0/O5vAas+UNubDl4vCb6GrV1uD1QWp5PavkIJLtTtT2lpKoV+LyKcXnnjwm7Qy1jand4SNfYgM5tWzB2ngwYhyJJnmup9SMHQyqDu6NHoHO/1sC6oD5qsN348Wr5Va0MsU+BKiR6jZHXdWnOAC10A7zy7oxePpGegSkxBZMNiIthyJAhFC1a9D8RtZztGVSrVo1p06b5fW/ZsmW0a9eOXbt24XA4sgQ2LVu2DMAvYfXs2ZMtW7YwYsQI1q5d69fLlR0uX75MkrhEkfRowk4lIyQJCkWpwWrgiYzVYLH43QiiUISaz5XfUk4e1EWvgECt+FVoiKcMhdmMs2IJws/bkC9fhYxMhMOhSjmgdkIwEpc+ruTVwlbbWFoTPb37pv9FZX1JI3c/apUWJxRsmY6AMMbQGCUVf6/lAlq/94BzGn/rLwdhaM9hTg+RG6K1NRU0wL0iFAVSUrEXAluZaP5ZYKdt27ZcvXo1xzlvdeToMvfHrFevXuX1119n6NCh/P7773Tq1ClLSQtN96xSpUrA8QcNGsSqVas4efIkzhwyoIUQ7Nixg/vvv5/iRUpQliqYUmxw8hwAqbWKuaNhtQLwHlezZwx3yL6e9InHlpOfUk4w8CmhIRTFQwDGNbgznuWIcFLKhyJphKLdrFqpCJ+bV3P36uSiCC8vlpcnRvPU+Nt4GglqUo4kqVITPiStCJV4Atkc9HHy+KT2G8RnWHMQ43oRiKZOuVXZHL1eeYDRaCxZzHrbbL8PQD9ELewOiu6wc2crO4/PaMfu3bupUKFCntdzqyBPd8Arr7zCHXfcQYcOHdixY4dfl3elSpXo3bt3tvV1ypcvz2233Ubx4sXZtWuX32MuXLjA9OnTkWWZJvWbsWfhEVpyN1WkWrr9IuTgOUIvZnKlTUWS21bVS0bqkCRVHQH1JjObEFHucgIOp6oW3CgpxxiP4z4+yw1nVFdcLrBayKhfAdkBplMJagwMeMfwmLy9c14Sjtf6FK/4Fb81kI0uckV4X0vhrZIAescD3fPmG/Doe26SpmIYVLhsSMMonQU4wD8pBap+qB3vp960Nl/AeXze90dKunTjtht6RWxrcEs5gaRCyR2KEHYiiQkTJtC9e3fq1q1L8+bN/a/tX4Rc19M5ceIEn3/+Obt27WLXrl0sW7aMV155JctxmzZtyrGgF6iu7/T0dI4fP+7V5EzD4sWLefLJJwE4eGw/Qyo96/W+kpGBciYDU0wkYQkWUktZONs/ntI/X8BRohCWA6c9pTINEKFm5OT0/JVycqtWeXl1vCUcrQkbgBQViSPKTKF9iWCz63YToZVg8FcHGAIHBRo2XNbgN8XLpStZtBrA7tIVmk0MTWKU1AoOvqqCj73EK4PfmGRL9v3NfNeX04bXXg/a9mKw3Qify5WtlBOgrIZXdUZNOvTVFjS7jc9vfxBmmQEDBlC5cmXGjx+fw8n8O5BrSefpp59m9OjRXLhwgY4dO/Lhhx/6bdcRDOGAajcym83s3bvX7/uDBg2iVKlSrFixggoVKui5XL7JpK5/DmJeuZW4HcnsevdpHnqpFlt3vsVO+Ucy7cmedZlMEBmhboJMm0fKuRGE40+E1qQDPXHS43ETioJcohip9UphsitIFxP13mB6tLIk+VTg87Hn+C0DEmDDGI9VDJKKIbDPVyLU0gW81uCrxmhjafFHxtwyvRIiXhJJtpKNzzHBEIyxuqAwEmIQQZLBQJduZMlTNdGXcNxSrpdU6HcsWa0oEBGGKzqcsWPH8v7775OamnpNa7xVkGvS2bhxI0WLFqVTp0589NFH9OrV65oWEB0dTXR0NDt37vT7fmpqKk6nk0qVKmV5z1/9noadHcyfP59ff/2V4sWLc+7cOfYlrvFy8SLLyCmZWaSLPCO3hONP9TBIBJLFonZTCA1BiY1EyBCx+4JPtKzwVnE0d7X2v78NqeX8GI2bvtCkF9ljw9Ezx309OULJ0SDqOX8fAvNVf6/R5uN7rjnZYkQQcT9BwejxM0Rsa9IhkCXFxeu33zHd195iQXK6GNn3aypXVqOS/wvI1Td88OBBzp8/z/PPP893331H9+7dczWZEILFixdjN7S4NZvNCCFwaDYXwOFwsH37dt555x0aN27Mww8/HNAgbSSelcp3rFmzhr59+7Js2TJWrlzJuXPnuJhxTN0gDidYLLhiw3UD8jVLOXmUcMBHygEvY60UHoarWjnSS4cTkqi6u9VmbgZjszHxUt/Mnoz67PpV+W7QLJGyhgBAPRM/y3m5SdDpDC6Az0g8vnYfo9TjL44oSM+Vv8A+fxHZqjqVNbcqGGitdTSbTRbpxpdw3Oeck4QDGGxBMkp0OJLDhXwljZo1a+r9sP7tyBXplC1bljfeeIM9e/bkqUXGxYsX6d69O88//7z+WnR0NJIksW3bNj744APatWtHbGws/fr1Y//+/cyePZs333wz23FnHXmLlhNqkZSUxKZNmwBITExk3bp1bNq0iUKWIkiyR9SVnIramcCZjbs4vxCgp5PXzWe8YbWcnLgYHIUsmDMUrEcuINLTPZKMJokYY3J8g9iCUbOM8K19rN38Jhm9GaHvtTJGcefFy6ORlLEHlV4AzOwuzyp5JDOvubOSj3ZstkTiL1AQg6eJANfLICUCHnKRcpBuskRkByZnLYZHCrFCbDRCltWYLJuNBx54gC+//DLwef2LkCtDclhYGGPGjMnzZCdOnABg6dKlpKen8/TTTxMTE0NmZibPP/88O3fuZNiwYSxcuJDo6Oigxjxz5gx16tQhMjKSuLg4rFYrI0eOpGvXrtSsWROLxUKhEiFcSb5AXGhpRFwh/Ua4Zo9VMJ4qP8d7tRTWIEl6IXMRVwhXuBWTTcFyxdO2RSsT4RVlHcCe42u3MQa7+fsb8FYPtIx2rai77/VShMe7Fixx+9qMfKEIwEPEgB4CIRxOJLPnnLKUDnXHIGnnZTxnf80GvYrdZ5vy4SEidV0ew7ffOk4BuolkqWdkjPDWiMpqUa93iBVhNWNKzYTEJER6Bu3bt2fYsGG8++67PPnkk1lCWc6fP8/o0aP58ssvb/kAwhu6ukKFChEVFUW1atWIjIykXbt23HPPPfTs2ZPhw4cza9YsevbsmSPhrF+/nsKFC9OvXz/MZjMmk4mpU6cybdo0pk2bxpQpU7jjjjuw2+1ERUUxcuRIztkOq0ZXi0kNrrM7sp0jR+TGU2V42vl6KvSuCSaTerNFReCIC1OlnKRMpMSriMzMLK2Bszz5fe0hWkySIbVBfVl4Pcl91SpjxKxuGDWqgLp0YsitChbZqWC+6pNb+tECGCWLWbUradKg1kfc6PY2GIVzrIFj8OB5STYGN7t2jfVrpAX4aaqVJtn4bnKf79tv/BV4S0jufDmiIlEKF0KYJMTFS2pBe4eTzmH9KXkinjlz5jBr1ixSUlI4d+4cixYt4s4776Rhw4bMmzePxMTE4L+Pm4RrarYXDLRkTkmSqF69OgkJCdx2222MGTOGt99+G5vN5pU+kR2cTifLli3jySef5OOPP+aVV15h1apVPPvss0yfPp309HQ9eKp27dpkZqpV+O+8807GOSZQRclAigrBmmDYQNcLgTxVbujF0s1mVZyOisRVOBJnpAUhS4SeuYpkd6lFzX3THMA7ItgITcLx46EK6Mkyqgzg7VECj9fKxxicKyknt9DW7vIx+gpFvWYWi6r6uUtm41IlQCU1Tc1B863lkx10O5hhbuNrRiO/sSicr90G/KvPvtfI6E7XiM1qUZN3I0OR7E6khCue/Dl38GaEFMVHX35JmzZteOWVVzh37pzXsE8//TRFihQJ/rxvEq67pGM2m3n88cf1/2fNmoXL5aJOnTpIkhQ04QA88sgjPPzwwzz22GN06tSJPXv20K9fP86dO0e1atU4d+4c//zzD1988QW7d+9mypQpAGpd5scGcIwDqrqiVdjLKZAtL/D1VPhIOFqPa0wmpIhwpMKxEBmBKyYCV5gZFLBezkBKs0HyVc/mMa4vQHay1/tGySeQl0rybCBPfIl7sxnrMfshHK9rlpdEzuwMw36C+rSNJxSh5pOlpSNS01CuGnLPXC7kiHC3FGRBdqfFGPPLjCkhXhKOIf0ETaX0icbWpRItjcHr3Nwqu79kV+PYmtpoqCctRYRDoShElFoJU0pJR9jUUqlauVRNcouPj6dmzZqcO3eOQoUKcfnyZYQQCCH02lW3OrIt4tWoUSOxdevWPA/udDr1Pj5//PEH33zzDcuWLWPNmjV+Y3t8sWPHDpYsWUKPHj0oVKgQ5cuXp0GDBmzbto0ffviBnj170qNHDxYtWsT8+fNZs2YNkiTxzTffkJSUBMCPP/5It27dOHv2LDVr1qRe+SGEnE7KvltoTjFGvtdMUTB26/R7DLjtAYraTickBCLCccVE4IyyggymdCeSIjAlpkFaulutMhgkjR4lQ/5OlqeqHtEsPFHF/uDPxeuWcjTS8ZJmtDlyytkKeN1yYUPzF0WMH9uUu5aPV60bPWjRrQJqmd3+IoCFyKKqGh8QXl0swPMdaJIqeCVt+o7h9b1hIButlZJFlXDQeoZdSUakZ3i1vPnVsYD28gP8bPua2267Dbvdzttvv02bNm28mlTeSsiuiNd1lXRMJhPFixcnNjaWTp06cfXqVbZt2xYU4Tz33HN06dKF3bt3M3z4cFJTU5FlmU8++QSAuLg4AJ3UnnjiCWRZ5vz587Ru3Zrp06cD6NHSpUqV4oEHHuDOHhGejWz8McJXAspOItKLjSuBj9F09hArUlwMFC+Ks3xxXHEGwslwYUq1YTp/RZVwMjO9N7Uv4fjCX2H0QPYM4xNcs+G4PVU64UDWwD4tuE0zbOeUeOnr8sb4b86pDV7V+4x1hb2STT1GYd0F7g4t0Md2OtX60XqrZT/XVftbl4YMEonvsVpiru9nDaEGWgKvZBjP6BHEJEN4mPpjMqmVK1PSVBuOuykfwCt/PMVDDz1Eg2cr8fbbb3Ps2DHS09OJjY29ZQknJ1xXm44kSaxcuZL27duzZ88etm7ditmc85SbN29mwYIF7Nmzh+TkZFq1aoXdbkdRFBo2bMipU6eoU6cOAN9++y0ACxcu5I477uDChQvcc889ZGRksGXLFs6fP6+PW758ea5cucIvV2brr3WKHqz+obt+g+Th7DKpDVKDFGJVXfNF49Ryo5FhOAuFoISoG8eUoT7NzOeT1M/aHZ7yFkaXtO/afN/T5s0OvraJQDYcbQo/yZu+QYjZzhWAUIJNbfB41/yUWzWbkbTARGPNIaF4pTN4pTZodi7F0MNdk+a0a2KoQZSlfY8mtWgeRN/vwN/DxksN1eybsqfBo0lW7w+TCeXiJU+mvlOtkfTRRx8RGhrKxYsX+frrr7mDe3l4ag/mzJlDp06d/F7fWx3X3aZTu3ZtihQpQrly5ejWrRuffvppjp/57bff6NWrFzExMURFRZGUlORlJBs+fDiFCxfm4sWLNGvWjG+//ZY77rgDgCeffJIWLVqQkZFBfHw8Xbp0AeDw4cPMmTOHO++802uuX5I/45fkz7I8zQP++EJvzqaGrkthoUiFolRdvVAkxEajlCmOo0gEtoqFsRWLQJhkUMCU5sR0NUMlnEybWh/HaG8KknCMmyNLw0Hd22IMGjTYJjTbhQ9097jxmviz4/izF/mOlwu1yl8hdGP8jWZYFXaHKrlIMrhUFUsKCVF/zBb1x1gjyP9kXl44X7LRO0P4+959Y2+M3irtx5AI6ym0r6jXPDTE3YVEYtmBN+g3sR61hxWjx7RWTFz3BL+6vgWhEBsbS6VKlXj88cdRFIX3/p7IkSNHKFy4cNDX9FZDvpFOSkoKgexDCxYsYNiwYXTs2JGHHnoox7EyMjIoVKgQoKpRUVFRrF27ljVr1lCiRAl9jKJFi7Jx40a9J9eqVatYsWIFAwcO5MMPPyQyMpKnn36ajRs3MnDgQA4fPkzHjh39zvnL1c/VPwLZuHxdoxaz22WrxtdI4WFI4eEQF4NSPBZn5dLYKhfHGRuOIy5MNRID5nQn5qRMQs4mYz57GSk1E1JSweHw2EmypEj4fE3+CpX5Ix7tfDSR35DWoKkIkmQI/tM/4kfSMuZ75UQiulqWVf3yq07loHoZ7Ti+7m3hdHgTkZu0hdPhaamsqWWy5EVGWYzp2fRPy1JgHnQi1kkmUIlWl4HMZBksFpYffpsBE+tRqPYRTCYT/fr1Iy4ujm3btjF48GAaN27M49/1pnXr1owbN45mzZrRrVs3GjRowKRJk0hJSaFr167/yp5Y+aJeDRo0iDlz5hAbG0uxYsUoXrw4VatWJSoqitWrV3P27FkGDBjA7NmzKVq0aI7jFS9enO3btwNq8fezZ88CcOTIkSxuQlCDDkeNGsWqVauoXLky4eHh/PXXX7zxxhscPnyYgQMH8uijj7JhwwZ++eUX7r33Xr/zasTTMXKg5wY0uDSFza56m9xdEIgMR4kMRZhlXBFmzMl2bEVCMdkUFIuEJEAJMWFOdyCn2VBCrchpNiSb3d2iRVWlvDa5L4IgHA0BiUd/UdLTGoxEo8/vZYPxlqb04mDB1q8JthiWbwR1lj5UWYnH+BtM7vdltzRkOC8t3cYwpmQUerIzskNA47CkOQ00IvZDMH4hSUgli7F872T+/vtv+vbtS40aNQBo2bIlY8eOBUBRFL7//ntmzJjB+fPn+euvvxjY9HH++ei0bq6oVKkSEydOpFKlSkyePJnhw4cHnvcWQ76Qjs1mo2vXrrzyyivs3LmT9PR0FEXh8uXLjB49mvbt2+fK6NWgQQNmzZqFEIIDBw4AMGDAALp16+b3+ClTpiCEIDY2lrfffpvq1avTtGlTNm3ahM1mIyYmhmnTplG7dm2/5TN8sSL1C9q3nIQrxIT1fAqu6DDsMVZMDgVHpJnw4ymkVYoiJNGBM9ykEowCijkUS5oTZ5iJ0LMpuCJDMaXZkNJt4HRiupzsLrolqx0TjDd9XgnH133rz50bwDMVsKSHV56Sn42VE/zVGA6EADVtsrxnLMVhrIWjH+oTXR2oF5axHY9m71FkQCBwe6z8dUMFb73A97r45HZ5rUFWa+pIYaEoYRZmzpzJ448/To8ePUhNTWXv3r3MmjXLM40s06tXL3r16sWsWbPo1q0bPUf0ZNSoUVSoUIHKlStz9OhRzGYzn376KQ888ACVKlWic+fOfs/5VkO+kM706dOpVKkS9erVo2HDhly5coVz585RpEgRKlasyPr166levTp33nkn9evXz3G8xo0bI8syX3/9Nffddx+A3uHQbreTnJzMM888Q+PGjVm/fj0bN25k69atlC1bVo/N0ew/ISEhbNy4kdDQUKpXr+5/Qj9Yuf5FABoMfZdCJ+ykFzcju8CSppBWKQpLqgtTphNThgM5xYYrNhw5zY6clonF6QK7HfMFVfQVLpfq1vVVnxwGK6evyz2QQdvHBavD15OiHWswFusRxsbhNPuRMYfLn5FaT0rNRsLJSbrxDVr0qr+cNZgxS1yP8TO+c2UpHeSOvHa709WPSlne916XUXXyY7tyS4NB9fLyqS2NO2t8xbaJemnfvXv3MmbMGMaNG0d8fDz+8Nhjj9GrVy9GjhxJ9erVMZvNVK9enfLly/PRRx9x3333MXPmTAYPHswnn3yi2zBvZeQL6RQpUkSPi9HyPpKTk7l48SInTpzgwIED7N+/n2eeeYZXXnmFl156KftFmc088sgjHDp0iLCwMPbu3UtiYiKffvopw4YN0zPSMzMz6dq1K++//z7FixcHoGPHjhw6dIinnnpKH69evXoAHDt2jO3bt1OhQoWgJB6Av2c+rf/dufQTKCULI6fZVBVLklUVyenEnJikblSjJ8VAMHqQny+5aMiprnB20kYgr5UeUyJ7RxsDei6VRjAWs/66jjxIOTnabHz/zol4shsrG+iGZ8XpRxUL3L8qoN1KW6vxWgcTpySrta6lsDBSwjLR6kwtXbqUe+65J6hziYmJ4csvv+Sll17C6XTy6aef8tlnn9G7d2/++usvhgwZQqVKlejSpQvz5s3j/vvvD2rcm4XrGhxoREZGBuXLl6dmzZqsWbMmx+Ofe+45IiIimDBhAqDquY0aNeLVV1+lXbt2WK3WXCW2nT59mpo1a1K9enU2b96M0+nMU7fETtGDPVG7ZrNHivFNhgSfZMwgblBf8vBTHsHruOykIy1gUSMcydteo0tdmrphtWb1mmmk42un8GcL8S2GldtAwPwqF4s3qfglGH8F57UoZS2FwhAFbHxf8wJ65aOpE2Wdw6BWERbKXSNKM3r0aAC2b9+uPwzzgl27dvH9998zf/58GjVqxLx589i6dSsdO3Zk3759Nz2G56YFBxoxceJEEhMT+fzzz1FyeqoDTZs25dVXX9ULti9atIj4+Hg6depERkZGUIRz4cIFxo4dS9GiRRk+fDh2u519+/YBkJaWlutz6FRoEFoUMG6XqNcG1qAlSRpq3QQqSZlt54RA5RGM0DwivtfDHfXqVYJBH1e4Eyp9im8FknJ8UwW8T0DfoH77hgeDfCYc7XfALPNAXjXhdo+7zyfoouyBCMdkUiVIsxksFhZ/dJiwsDCSk5OviXAA6tSpwyuvvMLu3bvZuXMn06ZNo2jRorRu3ZqlS5de09jXG0GTjtPp5KuvvuL555/n1KlTQU8ghOD777/nq6++4v7776dixYrcd999XkW7/OGll17C5XKRkpICwOTJkylfvjz33HMPcXFx/Pbbb7z//vu0bNmSdevW+R1jyJAhHDx4kKVLl3LXXXdRvHhxJkyYgBCCiIiIoM9BPxeHTwHy7LotGu0q2ueNMRz+4j/yIwfMGJsjGwzI2hRaxwaD90WXcoxL8Zc/pMFHmsmTdHOLQvVaGozWgRDoPSPhmM1IoaFqPI7dzksf3UfTpk31cJD8QGhoKO+//z6rVq2icePGnD9/nnHjxvHss8/espUGc7TpHDx4kDFjxrBq1SoaNGhA/fr1adCgAT179qRkyZIcPHiQAwcO4HA4kGUZWZYpUqQIJUuWJCIigpUrV3L69GkyMzM5deoU69evZ/jw4axZs4YOHTr4ndNut+spE7GxsQAMHjyYDz74gH79+tGvXz/uvvtuWrduzYMPPsi0adOoX79+li/T5XIxYMAAmjZtStOmTfV1bNmyhSZNmrB48WK6du0a1IXqGPqQx5jo9nSAGnXtu7HVGjSaKzpnm0iWCFg/rtosLnDf/w2pD3oNHN9MaGOks0Y4Wki/7snJYb1BEo6/IL+bhWDKW3gOloIjT03F9DUea+kRWolXSQKnC5GWTrVq1di9ezeHDx/OtjVTbtGuXTvatWvHhQsXaNCgARcuXGDKlClMmTKFyZMn88ILL+TbXPmBbEknJSWFmjVrMmnSJD777DOdAIYPH86yZctISEigbdu2PPHEE1itVoQQuFwuLl68yNmzZ9myZQsHDx7k008/pV+/fljdBZkiIyMJCwsLOO/kyZOpW7eunuqgzdmqVSuioqI4fPgwO3fupHr16ggh2LdvH127duXXX3/V5wDVjhMXF4fdbsflchEREUFmZiZ79uwB4IMPPgiKdDpY+wIgyQZPhjG03R1GD97eIUmSEe7EQAmyGmV9bDjZdgUIFJpvGEc3FptkT70XbX1CeOpEG6Q1KSTEY8sJFj72jmBc5LmpX5xX5Lr0qN9oalXSkWQl63iB7DnGsbRgUa32j9Opko7dzpAqY+g1pBeLFy9m1KhRuVtrEChevDinT5/m0qVLHDp0iIkTJzJ27NhbjnSyNSRLkiRAtX+Eh4fnenCXy8XgwYP5559/WLRoEWXLliU9PZ2qVauybt26gGw/duxYXC5XljKlQ4YMYfZsNW8qJiaGdu3acfLkSerWrcvixYv54osvvGIVHnroIdLT09m7dy8lSpTQe2y99tprvPjiiyxcuDBgFwojNNIxQmsTq/5jaDXi65rWatE4nN4Rq16D+QTlGV/3NR5jIBev2i6GQurG/DYhPN03/fRakiPCvV35xqA33/UYnuz+JJzcbvrrQT7+1pBjKxnDcVJIiO59zJK57o90jLV33P3WJKtVzRoHdSyHEyU9HaEI/vd9b1555RW2bdt2y1f4uxbk2ZBcqFAhDh48mCfCATXLfM6cOdx3333UrVuXBx98kKpVq9K+fXsqV64c8HNdunRh2bJlepdQUEulaoTz/fff8/PPP9OtWzemTJmCLMu0bNlST4fQ8NFHH9GkSRMiIiKQZZnVq1cTFRUFwO23386FCxe4cuVKtufgj3DAfXPrHiB3CLxve2J3bpNePydgDpBH5cnyuu8xvq+jTeX+Ko2GY5fL03XTkBvkNZYkZfFO+ZW48plwgv5MHrtD5BluSSfL2mQpq5RpVK006dJkUglHkhDpGSrhZGTqhuoZ980jKSmJ++67j/nz51//87kFka2k07BhQ5FfFegvXLjA8uXLKVu2LO3atcv2WKfTSZcuXXTvU/fu3Vm+fDmDBg3Cbrdz4MABSpUqFfTcmZmZVKtWjSZNmhAbG8sdd9xB//79ad++PYMHD6ZPnz4BPxuIdMDnCWpwkeqN6YwFn7R0B7sj+9iX7GrfAFnq36C67r1UKm1Op1NVqTRPFd4qnhQWqrr99Y6hfqQcfzacayQbXwRdND4HW0uupRyf8SVZQgoLQ2RkeI2nSbVqoKHifV20tIyQELfx2OSOOLchMtWqj4rdrq99/sWPWLlyJSdPnuS1117j9OnTQdcD/zchO0nnusTpHD9+nOjoaN0GlFts3LiRixcvIoTg7bffJi0tjccffxyLxcKYMWPYsWMHZcqUydWYNpsNIQR16tShevXqZGZmkp6ezieffBIwGhSyJx0NXkW7DfYVtfaxrBfvEu5cqyyFtzTktIEDFN3Sb3ZNxdPIw2bzxOL4CfSTI1UPnl6uwjdpUVuT0YaTz4QDtxjphIernTcwqFdu1Uor6qWTjvZ9WCzeDxlFQWTaEDYbisNJqnKF7axnx76/adGiBU6nk+joaE6dOsUHH3zwr8qbChbZkU6+1tM5cuQIgwYN4uDBg9jtdsaPH+8VGRwMduzYQdeuXSlcuDBVqlRh9erVLFu2jKVLl5KYmMjChQtzTTigpkOAWtT9p59+wmw206tXr2xVx2AIBww3p9uzpXdPcDpBGNQrALNAZGR6D3Atm1eW9KerV/0Wu8O7AJcPJHfsiEhL97ZVaL8NJONLOPlFNhqCKqKuHuD9fw7IDeH4W4//tXgkHE/WvidWSrFl4rClYrZ5vGAmzIQRwYD4/5FIIikpKRw5coRx48bRpk2boM7lv4RsJZ3Y2Fhx6dKlHCN3U1JSaN++PXv37uWll17imWeeYf/+/TRp0oQ9e/ZQsWLFoBe0ZMkSJk6cyCuvvELfvn357bffaNiwIQBaLdgbZYALlnSM8DU8SlarRxLRDLyKopekzD7L2cel61vtDzd5WC0eo7IWsOhPrQKPamW1IkWEeyoU+kpDRgnnOkg3/pAfhuVce8l8Dcn+JB1f1Qo8Eo52/QFcLjZf/pFE5znuMvXSI7t/cSxg+/btNGrUCLPZzMyZM3nkkUeu+VxvZeRZ0klLS0NRlBxJ57333uPAgQNcvHiR06dP89RTTzF//nxuv/12SpcunavFdurUiRUrVvDOO+8wYsQIPUH0vffeY8yYMVgsFoYPH86VK1eoVKkSY8aMQZIknE4n7777Lnv27MHhcOB0OqlevbperjS3yAvhgOFGFQo4FYQ76VIyhaFHKUvufByzGSUjI3A5hJyMqCZZN1rqhmMj4SiaZOIbMSshRUUi0tNVtz7ZEI7hvK43cpR4goCWc5XnMfw9hH2TaYVwE7+sPkwAXC5sqVdwugyeL/dHRo4cyYcffkjnzp1xuVz/SRtObpAt6dSqVUuvQewPBw8eZNasWXzxxRcsXbqU0NBQ3n33XRISEvjjjz+Ij4/n4MGDPPbYY5QpU4avvvpKT3gLBIvFwgcffABAUlISp06dYsCAAfz+++80aNAARVF4//33ue+++3jhhRfo2bMnVapUYfLkyUydOpXw8HAuXLiAEIK2bdvm4ZJcO7w2j1arNyNTJZ/ICLfUYwIlU7X7OD1V//3HjniMyDokyTvFQVOpwKuYuz/Xt9ELo7UqDkg4/8Io46AJJ0tgoPpA8OoNJslZintJZncBN7PHhibsDq46L3FVJBJFLJI7fPRX17fUrl2bNWvWsHXrVpYvX86lS5fy61T/lcj2UepPjRFCsHPnTh599FFatmyJ2Wxm8+bNtGjRAlAzzg8fPsyZM2eYPXs2t912G/Hx8cybN4+RI0eSkJAQ9OIaN25MpUqV+P3332nevDm//fYbFSpUwOFwsGDBApo2baoXeW/Tpg3169endevWzJgxg3Xr1rFixYrcXIt8hzEfSa9ql56uFvByKRAWqpY01Yp1a4mPxo3us4H0bgImHzuOw4HQiplnF2sDSFGR4HJ53Oya3ccP4WRbPP064YbN6S+T3OXyrs1jKMCuF4W3mD12HPf1/v7ku3z4+ySa0YF6NNeH/PXXX7Hb7TRv3pzRo0f/v7Th+CJo75UQguHDh/Prr7/idDp56KGHeO6557KIipcvXw7Y8Ktx48YMGDCAESNGBLW42rVr06hRI7788kuKFCnC1atXsdvtPPTQQwwcODBH17uGpKQkhg8fzsaNG3n00UcZNmwYmZmZzJ49m5IlS9KnT58suVh5Va+ygxY0KJlM6sZ35+fgDkZTkpI98TCGvlPaZ/W0BbO726XFohOGyMjEGNwH3u5xz0AScky0x/bjcqmuXTfpGDsw3Giy8Yfrmj7hWwjM3RpIuAP5JFnytK8BNRTCbPaWcBxO7nq+KpMmTaJ06dKcPHmSP/74g9H1XwOgzWv1+fnnn1mxYkWe8v3+rcgXl/ncuXN54YUXWL58OfHx8dnaeS5dusTRo0dp2rQp9957LwsWLCAsLEyXnLKbE9Cz0Js2bUpSUhKHDx/2en/MmDG88cYb2Y6hwel0Mn36dL7//nsqVarEtm3bKF68uJ4k2rRpU5xOJ8bQgOtBOL6Qw0LVOstmM2geNMWFSE1To5dtNs+mcLtrAbX4u7sglN6ZwO5Q7Ti+hAMBSUekZ6ik5u4iqRucdcPzzSccDXkinmDKZfiSjsmEFBGmfgfu9yWjkd7kJh13CMTyczNYv349rVq14tSpU5QpU4YpU6bwxRdfUGRPZcySBadwkNH0PPXr1+e9997TvahGpKen43Q68zUR9GYjX0pbXLlyhTJlyrBq1SrKlCnDggULAh5bpEgRmjRpgsvl4qeffiI8PJyLFy8CBIyJ0ZIzK1asiMlkonv37tjtdg4fPkzTpk2ZOXMmdevWpVy5cixevJiWLVsGLJGxbds2Jk2axPHjx3n++ecZNWoUly5d4q+//mL//v064bz99tuMGDGCSpUqBXsZ8g1KRiYiNU3N+r56VS0GJqs2HykqUrUZ6JXt3KqSJBnal7gJx+UKOrEUSUKOilT/dieG6kWruLWIxog8r8tYfN3fjy9Msrc3UVOhTCr5SCEhKuG4VaqdO3fywAMPMHnyZN1hMmrUKEqVKkWbiQ0AMEsWQraX5Pz581StWpUZM2bo7a41tGnThtq1a+ftHP+FCDpO53//+x+XLl3i6aefBmDLli307t07y3GKovD555/Ttm1bL1f5888/D0CxYsX8jr9lyxZWrFjByJEjSUxMZN68eVy4cIFff/2VsLAwhgwZwv79+wGIiIhg//79fP311/Tr1y/LWH369CE1NRWXy8Wjjz7K1KlTsVqtLF++nDlz5lCkSBFq1KjBHXfcwahRo4IqFn89IBQBqWlq2H2mTSWEEKsqxkdFItkdqnfLCK1chTaG0wkOp7cNR3/Tz2Z12yEkSY2a1esBqQvyrOsWQ648UnlNnXApBqO9IdrbWCLE5VIfFE4nM2bMQAhB586d9W62kiQxePBgevfuTTvuR5IkQqVwMrcWoXRYYVasWMHEiRO58847qVu3Lp9++inHjh3LVXvtfzuC/nZMJhMTJ6r1XX/55RemTp3q9zhFUXj00UepVKmSThLgMUrv2rWL06dPZ/nc1atXcTgcvPjii0ydOpVFixYBkJCQQKtWrbzG6tWrF6BGLvvDpUuXOHfuHC1btuTIkSOULFmSnTt3UrZsWV566SXGjh3LnXfeSYkSJfjll18YM2aM/tkboVoZofVywqWgpKQiklPcfapUD5ccFqbH+qgeE7NuOMbpNEgpqr1H+wE8ni3331JoCFqpBR032WicG+TYFfQaIYWFqvYtUCVBo4fKGGNld2Crd5RPPvmECxcuUL9+fdq3b6+P06tXL6pWrcrrm9X7Si5ZHBETSWTRCtjO1CdedGDPmkQ+mbKIYhmNWblyJUWKFMHpdDJq1CgkSUKSJL788svrcp43G9mSTkpKChk+T9patWoxe/bsLKqNw+EgMTFRLybUrl072rRpo+eZtGzZEovFQkhICH/88UeWufbt26cXYQc1ITMsLIxGjRqxdOlSOnfuzIwZM1ixYgVHjx5l3LhxTJs2ze+6x48fT/PmzRk5ciRdu3blm2++0W1Q+/fv55tvvgHUhNA9e/ZQrly5IC7V9YXQkjMdDkRyiurlEgJCrN4eE/C0xlWEJ6FTG8dQAkMnIHdAoaQRlix5emXnpdLfLYDso4bzdk7Cpnbt0FznUlioSjYh7nIpDgdKWjp2Z5quoh86dIgLFy7w888/6wnKmrTTo0cPkrmCvUJRHIUjMB8+g3w+kdAUQenEwhy/spVN576hTZs2ZGRk0LNnT9555x2KFi3K4MGD9dbZ/zVkq15pyWilSpVi7NixPPbYY7zzzjvUqlWL7t27Y7VaqVKlCu3atePcuXMMHDiQ8PBwihUrRufOnSlWrBgdOnSgUqVKzJkzh+joaM6fP48QgjNnzjBq1CimTJmipzV8+umnlC5dmmHDhlGiRAnS3ZGh1apV04tYV6lShSNHjvDiiy8GbFG8YcMGatasybBhw6hYsaKe6iCEoGHDhqSnpzN69Gi6dOmSJSxA79pwA+GlNjidCJeCFBqCwKm2zjWbkExqYz+vXlkOp8dDJXm6FBiJR1e5NDuQXvsH1VvlE8Gb42ZWD8y3c78WBJU+kYu1yuHhKOnpoAjkiHBPsXqXooYkZKqkZLYLJk+ezNixY2nTpg0xMTHs2bOHTp060bNnT8xmM40aNWL69OkMHTqULZ/PpkKFCgHnNZlMXL58mfXr1wOwdevWW+JBeL2Qo/fqjz/+4M8//+Tee+/lrbfeYsCAAZw+fZpNmzZx9uxZFi1axJEjRyhevDiHDh1i6tSpeoGi48ePs2vXLp5//nkuX77M22+/Tc+ePQkNDeXChQuULFmSoUOH8vHHH3PhwgWvYtLjx4/n6NGjtGvXjubNm1OtWjXsdjtr1qyhU6dO2XaVGDp0KBcvXuTuu+/myy+/ZP369dSrVw+Hw4HJZGLTpk0Bi4h1rjEW1+Hjeb+ieYBX6oQxLsTtoZJCrB7xXiMdt1TkVaLCTT7qUIbNplWyi4yAjEz1s3a7J3DRtyiXPwRqr3KLIDc1cwKdqxwZgcjIVF3nhaIgLFQlnPR0NW3F4cRls+EUNtaKxbST7mfK3+P4+eefuXz5sl4mxel0smfPHk6dOsXly5f5+++/c2y9tGHDBqpXr87w4cM5d+4c33333U2zNeYHrtllvnnzZpo2bQqo3qe5c+d6tXC5fPkyR48epXz58hQpUoRNmzZRrVq1gPE6Gi5evEhkZCTh4eHs3buXcuXKcfDgQd3zVbFiRSpUqKDbcy5cuEBISAivvfYaTz/9dMDo5jNnzjBt2jTOnj3LPffcQ9euXVm4cCEVKlTg9ttvDyghTZ8+nUlzFlNldzgRUlS2a79WZCmLAZ4yCVpdFq0Tp1mtPqi5arX4ED3tQW9v46fQF3jGslg8GdDGKGg3/k1Sjj8EQzy+va+MMMXFoKSkqtn3hWNVwtG8jOnpvLNtLOPHj2fhwoXcddddJCcns2XLFlq0aIHD4eD222/nvffeU8cWgnPnznHp0iWvCpj+8Ndff/HPP/8wePBgbDYbtWvX5tChQyiKkmME/62Ka84yb9iwIbNmzSIhIYGSJUvSsWNHnnzySeLi4oiNjcXlcrFnzx42bdrEpUuXKFmyJOXKlSMmJoaoqCiKFy9Ov3799AJahoURHh7OuHHjmDRpkn6cy+XCZDKxe/duIiIicDqdnDp1ipIlS3LlyhWcTierV6+mefPmfiWW0qVL07dvXxITE1myZAmTJ08mLi6O0qVLYzabuf32272Odzgc3HfffSxdupRu3brxx45NNDRfvxSKgIRjLFuhucc1t63dI+FIZrNapc5kUv/HrVJpOVzGhnC440/CwlQpSZK8ulwK3XGVk7v91iUbCD6Wx+gF8yf1SCYTFIpCWExImXZEUjJKpo1MJZV27doxePBgRo4cSYMGDVi7di02m42ffvqJxMREGjduzFtvvYXVakWSJEqVKhVU3aeXX34Zu91OhQoVaNeuHRMnTmTChAm8/PLLTJw4MfcX4xZHUKRjMpkYMmSI/v+lS5cYO3YsHTt21KvyVa9enRdffJHixYtz9uxZTp06RVJSEqmpqbz66qssXryYCRMm6Bt+5cqVdOjQgbFjx/Lhhx/y3Xff4XQ6eeGFF7BYLDgcDi5fvkxERARms5mKFSuSmZnJ6dOnadKkib4ujYw0nDx5ksGDB/Pbb78B0KFDB95++23++ecfvvvuO1auXJmFdGw2G+fPnwfULPfqsa0hJe8X1V8nyWz7L5m0p7DskUq0NAfQ69xovbmFw+HJcHYXYJe0dsUa+WgOLE06Ak8iKGTJbs/RnvNvRwBJzUu1NZuRYqJRosORHC5ISdUN7gNndePRR5dQoUIFHnvsMQAGDhyoj2O1WklKSgooRfti6tSpFC1alD59+rB8+XJAleQBvdfbli1b8ny6tzJyXcTrtdde49VXX8VkMrFjxw6qVaumv+d0OrNc9PPnz1OyZEmKFy+uq0b9+/dnwYIFTJs2jfPnz/P666/rMT9Op5NOnTrRuHFjXn/9dX2cc+fOcc8997B9+3ZGjBhBq1atWLRoEc2bN+eJJ55g48aNvPHGG1SoUIHp06ezYcMG5syZw5QpU4iMjOSPP/6gZ8+e/Pnnn1StWtXv+bbo8TZXqkmU//IYrstXcnchcxs1a0xz8FdjWevmAHrxL2G3Z7Xd+NZL1o53H+NxtZs842i/b7GUh7wiT9cew7VzG5zlooVRCkejmGU+mNubEY1eY2XKVyiKQq9evfjhhx8AtT2Sb/UCreXLypUrg1pCsWLFSEhIYNKkSYwdO1Z/PTo6mqtXrwJqmInrBjs18gv5EpEshGD69Om8+eabfP7551gsFnr37s3XX3+NEILXXnvNb25JXFwcS5cu5fz587z//vt67EHv3r2JiYnh0Ucf5cEHH9SPN5vNjB8/np9++on//e9/DBgwACEETZo0oUmTJixdupSJEyfSq1cvvfsEwBtvvEG1atX44YcfKFGiBFarlZkzZxIVFcXDDz/Mvffey2effeaXcIQQ/P777zzUPoIrG9Zx+OEyappCkMhV0JrklmYM9htJa5bnh3D0nCitT5hPnWThcqk/DocuCWmJiZK7E4UQilqSVCOcazmH/wI0l7pwBwOazWoMU2Q4SoSVjg9GqNUl6x2nb9++mEwmli9fzs8//8y6desYNmyY13AZGRlMmTKFefPmBb2EXbt2AejtuDWMGDGCsmXL8vHHH+uNJv9ryFYW1GJxTp8+zYsvvsjOnTv1shIPPvgga9euZeTIkYwdO5a0tDTsdjtCCC/jl9Vq1d3dhQsX1kVIUC/4nXfe6XX8zp07GT16NBUqVOCjjz4C1O6g4eHhDB48WFetfv/9d9avX88nn3wCwIkTJxg/fjzffvstnTp14pFHHiE9PZ0777yTn376iW3btnl1n8jMzOTJJ58E1LSJ9PR0KleuzPn1SylzfAdFu97J2tNOSp4KJS68HMr+o17XJs/Rsf5qHbv/V4MCDcc7XW6VKMDTziDx6C9l2jyuYreapoYBOLxTJYzqhtBc7P8+FetayFKteePSW8Y4JCet2jt5661p/PXXXyxfvpyiRYvy+OOP07lzZxYtWsSsWbOyjKNJNzExMUHPXaJECfbv30/hwoW9Xp80aRJHjhzhhx9+oGzZstx99915Pr9bFTm2oAkLC8NisTBkyBAmTJiQxRhst9s5cuQILpeLDh06cPbs2YDjXbhwgdKlS5OZmYnZbKZ37978/vvv1KhRgwsXLuBwOEhKSuLll1/WW9fcdttthISEYDab+eeff6hatSoWi4X27dvTu3dvHnnkEZxOJ3FxcRw/fpwqVaqwfft2li9fTkREBD///DMPPvgg3bt391rL6NGjmTlzJqGhoVy6dAmHw8H06dMZNWoUZrMZp9NJ27ZtWb16NePGjWP1m38TKccEF46vbWQfr1QWd7ZW51jzUhkJR0tPcDhz35dKW4ZWLFyW1O6kdrtnHGOBLmM5hxtUJTC/cM0SmiQjh4ZgLxzGGetv1K5dm9dee43q1at7HRYfH8/+/fv1xE4NKSkpPPzww5w8eTLfbDDz5s3T03uCcbffisiz96pBgwasW7eOiIiIgK47q9VKfHw8r732Gj179sx2IYsXL6Z169a63WfevHn8888/nD9/nqJFi+JyuWjQoIEesKdd7HPnzlGsWDFq1qwJQLdu3Th06JDe4yo1NZWUlBTefPNNUlJSKF++PI8//jgA/fv3B2Dz5s3Mnj2buXPnMn36dJxOJ6mpqaxZs4bGjRuzc+dOUlNTAfj444/p0qWLHje0evVqNrk2cfLYSQZXfs77pHwJRoOhJ5bnUINkY/hb8iljoUcb59Q5wtgXy/d1fR2ynlOk2TCE3aBiyRKSrIX4Oz3nIRR9Q98K5HO91qKN67CncfD4QXr16pWFcAAefvhhXnrpJdq2bUvnzp157rnnWL16NcOHD6dTp058/fXX+bamRo08e/Xtt9/O17FvBWRLOpIkERkZGdRACQkJnDp1iuTkZL/lGNetW8czzzyjR12C6n0qU6YMFy9eZPfu3axYsYKrV6/So0cPunbtyt69e3n33XdZt24d99xzD0888YReuOvTTz/VRdOYmBjWrl3LlClTdJVJw/r161m6dKneuG/58uX069dPJ8gGDRpgt9uxWCw0aNCAJk2aULNmTT0aesmSJdxzzz3Url2bNm3acMp+lmbWzlixejaoRhqK0Iuye0k1RhII1CBPg1HCyYlwjL99KwNKfsY2lGjApaUKeOJ5JC0CVxG6K91IPvoSbxAJ+ZNijCrgNUk5kqxLgZjNOO+oTl3bi8yePZu77rqLFi1aYDKZ9Ift6NGj+e6779i5cyfz58/n+++/5+LFiyxevDjfVaBq1arRrl07Ll26xOLFi7l8+XIWNezfjHzrBjF58mSeeeYZqlSpQv/+/WncuLFXP6nw8HDKlStHvXr19NemTZvG+PHjqVevHk6nkx49elC+fHlmz57NM888Q8WKFXn00Uf56quvdPJr2rQpHTt2zPIltG7dmtatW3u99v777zNmzBgyMjJ0la1s2bLce++9LF68GFANetqaJEmiU6dO+ueNqmfbtm15//33AUhuWZ6if17IqjZZsko3QBaiQRGeDe5rMNYC/rLzWviTOn1fs7izo7XkTsXH/iNLav9yPxXykEFyk5GRfPSpsgmw+1dAktVz0JI6gagjaUQfOs+zH0yhb9++upng9ddf57nnnmPv3r0cOXKEmjVrcvfdd7N27VoGDBiQ5Z7Ll+VJEqtWrQLg3nvv5aeffmLQoEH5Ps/NQr73vTp48CDvvvsuH3/8MY888gijRo0iPj6eTZs2MWTIEHbv3u2ZXJLo379/ttm0Qgj69+9P9+7dmTFjBlarlVq1anlluR8+fJgjR45w22236Tku+/bto3Xr1mzZsoWmTZvy+++/6+59Y7F5p9OZY+H5ixcvsmzZMj755BOKFCnCjz/+yLFjx/hfhw+REhKRCkUhUlK93NZZNri7T5KuSvmQDaAX0wrYftjf2NpL7hgdzV4khYWqgYCaB0RrRyNJniRRdxqE3zQMX9tPDnWTr5fa4w95Lrzu6yrX4qGAtDbxKDJYlmwkrUIUTTpE8sfXB5DKJdC2bVvdKzpgwAA2bNiAzWbTXejXE6tXr+aRRx7h2LFj132u/ES+uMyDRbVq1fjoo4+4dOkSZcuWpVWrVkycOJFp06bpXixQUycAvvrqq2xdg9999x3z5s3jyJEjrF27ll9//RWLxaJnv69du5amTZsyZcoUatWqhcPtEp4/fz6NGzfG6XRy/vx5r3giWZb54IMPeOuttwISjhCCv/76i4ceeohq1arx/OCXOC+X59tvv2X+/PlUqVKFTafnYi8SodY6LlZELcAVEa5GDGulSS1md6yMRU1DMPmoW27pRtjtnuxxdQFBX3OdaDRVzuyRoiRJ9gQE+nY10M7VSCYaOekXyy2duaUDvfmcnyC7azXqGiOFczou1yTnmwYhu72Hbqky7EImLw+rxzrnIpTUqxz8+BLFrxYmcndpvv1gCU888QStW7fmhRde4OLFi8ydOzfX55cX3H777SQkJOj2xv8CglavTp06xa5duzhz5gyHDx+mZcuWVKlShcuXL1O3bt0spRYLFy7MhAkT6Nu3L1OnTiUjI4PnnvMYYb/66ivuuecelixZEtBIferUKV588UUAEhMT9dfffPNNYmNjGTNmDMOGDePVV18lISGBy5cv60bq0NBQfv75Z3bt2kXlypX54IMPqFWrlj5GTl0VP/30U4YN+R9lqcKpq6dYv349ycnJjBgxgk8//RSAgUMfZOHMFdQu0sFjGJYkCFVLUmpRwvgpriW0QlpaqVA/HThzBaPB2mpR0yO0jakoXoZrzV0vJBlJ9q6jI8kKKD5eN/1vk6oaylpAocforM8dhMHXeIwvwQRLXLkiOD95V+r87nW7FOQDJ9mwwX1eV64Cat5guBRFTRqxcuw2sFrYsm0LVatWzVE6zgmKogTVvy0sLIxmzZoxb948hg4dek1z3irIlnQyMzNJTk7m77//pmfPnjRp0oTSpUtTvnx5hg4dSmJiIg0aNGDv3r1069aNYcOGUb58eUqUKKFf0KpVq/Lxxx9nGXvjxo106tRJr7hmRM2aNRkyZAhPP/00Y8eO5YcffmDq1KlUrlyZEydOIITQmX/QoEGMGzeOevXqsWjRIp3AtEDF06dPc/r0ab+1af1h+fLlLF26lE8+nE0ZKvH1xs/o0qULv//+u9dxPXr04JFHHmHBggUkpp0gzuLOsTF2y3SrMsiymrpgMnnbbRSPZJPXchqS741rIBdhVIM04nEjS5VB/XU3qUiyp3Wu1/iSSkpeBmZTFne7v1SQrGu/9oDEbFUtn+xy/TVDGVj3ICgpKayavo9K1rrE2GPBMKQ2hxwS6tezlVskJycTExPDm2++6fUgDoT33nuP22+/nc6dO/8nSl5kSzr//PMPs2fPZsaMGcybN8/LyDpq1ChSU1MpVqwYly9fZvbs2Tz22GMkJCQgSRKvvPIKjzzySEA2Hzx4MJ06deLFF18kOTlZf33GjBns3buXp59+msmTJ/PCCy9QtWpV1q5dyxdffEGfPn0oX7488+fPB9Q8FX9fnJbhXqNGDa5cucLOnTuJiooiKioqYFX+AwcOeHki5m+cQ7du3fQs4XXr1lGkSBFq1qxJyZIlqVu3Lp9//jnd772P1jF9MMtWsLu8g/YMkotwOL3/D1Q8PSf4BgVqNhifXurC5VITRX09XVrrFM2Y7Du8QZpBkQMTj+cD7k1t8mv3uZ7RzsGM7UU44E2mWnkPIDK2LNWiSuI85R1rpqvHEYFbUOcGYWFh9OzZ06uUS3aoVasWrVq1YsGCBUGR1K2ObOW7mJgYjh07RuHChb0IB9CLdYGqSo0ZM4bdu3dz/vx5VqxYwbRp06hWrRo7duzIMq4QQq/6d/XqVU6cOKG/p0UNDxs2jBdeeAFQYyQeeughQLXVvPHGGyxZsoRVq1bx8ccfI4Rg/fr1DB8+nKFDh5KamsoDDzzA0qVLqV27NufOneOBBx6gZMmSREZGsnr1an2+pKQkPZVCy/WyWq0Upyzz5s2jc+fOPPzww+rFkmVq1KhBmzZt9PKUv/32G05hJ0lJQBg7dborAWrF040qlFAUT8BfXtSpbLxXUohVTXnwvuDePxgDFL3Jw/Onj53H98drbtlLhcli9wn09/VETnP4Ow+L2W8irGQyIcfFqvV18gFWq5XvvvuOAQMGBP2Z6dOnM336dL777rt8WcPNRI5thYUQXrVzgkGdOnXYs2cPCxYsoH379nzyySdeEcF2u53/a++sw6M41zb+m5W4ASEJ3uISEghSLBDcS/EcirtDS1vkIzgt1gKFYqcUb6GlFKe4uzdYsQIhQCDutvt+f+zOZDeGxejhvq5ckNmRdzY7zz5633v27OHw4cMEBASYuYwymfvEiRPNzplg1IYaPny4Urru1asXZ8+epVOnTly7do3evXtz6dIlJk6ciJOTE1OnTkWtVlO+fHmCgoIICwujdu3aZrmdEiVKEBkZSf78+UlMTKRLly5UrFiRL774giZNmnDmzBnWrFkDQL9+/Th37pyZ0ZI7tC9G7KaEpTulLaqgkbRpwybZO3nTnM3LkKofSO71USCrR6T2PDOh9TSTSIaXP8jpNBbKfUBCL8yPfxWJmDdFemGVcV2pr20aFopnL5DczImzJI0WlYORMD+DubWcQOnSpdmyZQtt27alQYMGGQocvAvI9FOk1WpJTEx8ZTcwNXx9ffnzzz/p16+fGRm7PNNVs2ZNevToYZZIlqtS27dvNzuXTF9hOrtVt25dVq9ezT///MNff/3F+PHjqVevnpLs7tmzJ7GxscybN4/WrVvj5uZGYGAgfn5+CCG4fv06kZGRlC9fHisrK5o0aUKZMmWYMmUKJ06c4OLFi2bu7O3bt9P0ZciUGJcuXULvEsHthItmHg3wRhWpN4FMYyGp1UgmD56SoJbF+CAl6W12grQfB7OEsOmgZGYGI4Pq1qvs90bIQFomUxpTUhkcubEzKsbseEmrMfDrPA9G/zx35YA9PDx4/vw5rq6u+Pj4KM/C5cuXlUJLUFAQDRo0yFC0IC/gpbNX5cqV4/jx429FnThy5Ejs7e2ZOXOm6bk5duwY3t7eZvv+8ccfjB07lhMnTphZ87Nnz1KrVi0AM0a1EydOULt2bYKCgpg7dy4bNmxg586dCtOhbDjBMFYxYcIEZs2aRYsWLfj777/5/fffsbS05MWLF9jb25OYmIiNjQ3r169n5cqV7N+/n+vXryve0VdffaV0N4Nh9iY2Npbnz58b+IXqdKLUvqjs5Vk2rVSZqk9aGBLysroEpmGcPGAKyoiGTHHxKnSlGXICpeyQ/va36el5C7bCzBLZqQ2pol2u0aIqVpjkew8M51CrUTs6gLUV+hchCJ2OfYm5N5KQmJiIu7s7ISEhhIaG4uTkxDfffMOQIUPo2LEj+fLl48cff1T2P3HihCL3ndN44z4dOzs7Vq1a9VKDExwczNixY2nVqhWTJ0/m9u3bZq/3799fUWAwRXpa49OnT+fJkydpxi8kScLV1ZX9+/ebeUb16tUjLCyMIkWKsGDBAooUKUKdOila0klJSbRp04a4uDgGDRrEN998Q7du3Th+/Djnz5+naNGi/Pbbb0qYJJdCy5Qpw5UrV1i5ciUVK1ZUxiZMOX7AEF4dOnQIDw8Pnj59ykdWofi73ifJ5dXGR94Ipl8U8v/lqpleGLwcOZQz8bIUz8tIeWqg1Hi1nhd5nwz3Te0FZeINvTYVyBsgtVxNuvI1qdanKuIGkVFGuhEJdT5HcLQ3UJbmssEBQy7o9u3btGvXDjDkI2Wajd9//50PPviATp06KSoShw4dIjo6GicnJ+bOnZtr606NTP+ilpaWaSZnExIS+O9//0v79u2pUKECJUqUoGTJkkRHRzNkyBBCQ0Np0KCBUtmRuY7lMERG8+bN05UX/uKLL8ifP3+aMvt///tfvvzyS5o0aZLmGNm6e3l58X//9388e/aMzz//XHl97969xMTEEBERweXLl/niiy84fvw4w4cP5+7du7Rt2xYwGKhBgwYhSRJqtZp+/frRv39/jh49yrJlyxg/fny6PUWmIZ9Go+HJ3WMcfrCUF0mP0Yts9HhkpB6zMB3PMP3BJNSSIb1+U19WaE9lZUVLTl6/6TmV46Jj0EdFG3JSarUhcZyQiC48HKHT0VTdNfMT5RBWrFihULosXLiQdu3aMWrUKP7v//6PGjVq0LNnT4WXyt7enoiIiJcOY+ckMg2vHB0dRWRkJP7+/ri7u/Pw4UPatm2rjDIcO3aMokWLEhwczMaNG3nx4gWNGzdWqCF+/PFHhBD88MMPtGrVisDAQOXcvr6+bNq0Kd0xhFOnTtGmTRuePHmiKB/OmDEDf39/mjdvjqWlpVLNAsOM1ciRI2nZsiW7d+8GDBWy8ePHM3XqVKVHp2bNmooRvXr1qhlhdmxsLD169GDLli04Ojqi0WgoWLAgt27deumoRqtWrdizZw/37t2jZMmSCuczQAlrd8pJVdPveXkbpB4oNZZ1lRkuU7UI+dpy3gKTsEwmdn8VRYjUS8jiUnjqQc6M1vOyEYnXuKDpSVGVLwkBzwylceNMlggOQR8Xh9AL9uvSeuu5icjISDQajSKxBIb8TqNGjdi+fTtNmjQhMTGRFy9evFQkIavxxuFVqVKlAEMC69mzZ9SrVw9/f39cXV1p3bo1LVq0YNGiRbRq1QobGxt8fHzo3bs33bt357PPPqNBgwbUr1+fWrVqpdFqrly5MpIkpatHXqdOHerVq0e3bt2UfEzPnj359ddf6devH7NmzTLbX7bie/bswcHBgVWrVhEZGcmsWbPMmgJr1KgBGHSFTA3O7du3KVKkCFu2bKF58+YEBgbSsGFDSpUqRalSpZRqWXo4cOAAe/bsYezYsYomusxx6+3tTRJJKdPMkLZMmxVQpcwQpe46VrwfGaZJ7fSkiF8DpiFLZj+vitTeiqkH87bejMmi04Z+8sS5EGx9upgkCxB2VhAVjS4mNs8OtTo4OGBra0u/fv2UbVWrVqVUqVJERUWRkJCAECLHDc7LkKnREUKQL18+hBBUqFABDw8PypQpw/Xr19m5cyfW1tbMnz8fb29vpk+frvTYHDlyhNu3b7Nq1SoqV67MjRs3FJlgGYULF6Z58+ZpupFl/Pbbbxw6dIiTJ08CULx4cWbOnMno0aPNhkbBUNmKi4tT+HT69u2bLoubrMM+Z84cs+3t27cnPDycL774gh07dmBra8uXX37JhQsXKFmyJA0bNmTPnj2cO3eO+Ph4s2OfPHnCmDFjzHI9Wq2WmzdvUqlSJZ7E/c0j9T/KAKbicaTXJ/Km0BvF96QMjIvZvqn7UOQhT1W2NfHlKbnidHJEkkoyNP/pBB06dODIoyUISUIfHZM1hi4b8dVXXylfpjKePXtmxpKZ15Cp0YmIiFAExMLDwzl58iS1a9emQIEC/Prrr4SEhNC9e3dFKWLJkiWAgWbC2dmZKVOm0K1bN2JjY9NIxXTr1o3Tp0/Tp08fJEni4sWLZq9bWFiQkJBAiRIllG3u7u6cOXMGHx8fs8T0li1buHnzJn369EEIQWJiYho5ZDD0Ojx9+pQZM2aYbb9x4wblypVj7ty5ihGsWbMmU6dO5fz584SEhDBo0CA++ugjrK2t2bFjh5KP6tmzJ/PmzTPL9cTGxvLNN9+wbNkyihUrxt+RpxAqjLSYFuaeh6nxSa8JLyPjlMqYKCVyE0/HzIsxS6Cm8nDeUW2l9PBKRsK0rK5WGziS7WzZc+Nr7t+/j06nQ3//gXk5PY9i9uzZDB48mGvXrim0qaVKlcqUwTO38VJqiwMHDpCQkEBSUhIqlYpChQohSRJHjhzh+fPndOnSRdk/Li4OtVqNhTEePnLkCPPnz8ff35/r16+nMTxt27Zl586dgCFBLR8nY/z48YSGhrJ8+XLAUCWTK2mHDx/Gx8eHxMREsxDqVagqUuPw4cOEhYWZaanLCAoKolGjRty4cYOqVaty+fJlwDD9e+rUqXTPd/ToUXx8fOjcuTPr16/Hzc0NT1pjibGjVW4cjE949UWm2+eSEkJJVpZpJGtITDIv3afizpFL6IpsTQ49ZNmdC0q9PdO1qNWoHOwMk/5x8cTqo4jIr6dQiJ3Ze7cvaWOWrvl1EBsbi1arzTAqAJQvPSEEHTt2pEOHDmZ5z5zGW1FbODk54erqStGiRSlcuLBycz4+PmYGBwwzJaaGw8fHh23btlGzZs00HcZgMEp3795FCJHG4ICBsMvUYjs7O1O/fn3mzJmDj48PYPCI5JzOzJkz32j6t2HDhukaHABXV1e2bt0KGBLGer2en376ib/++ivdfBQYPL2oqCh++eUX8uXLR1hYGAF2Bg13M4Y/rSaFzOtlyMDjEXKXcerX5N9f04t5Vw1OettfaS5LqwGNBhGfgD4+ATsHN4rYmg91Cr2gmdY3S9b7uoiNjcXW1hYLCwvlCzo1dDodTk5OipGJiIh4rTzO3bt3mT59OmPGjOHq1atmr+n1egICAnjw4MEb30Nq5MAQjKHy9Ouvv5pte/bsGZIkZTg1Gx8fz+zZs5UE9NKlS/H09OTatWsKVzIYPKTNmzcDKLNaL0NSUhL9+vVT9IVehjJlyvD999/TsGFDJEmiT58+REdHZ0pNYGdnx/79+4mNjWXRokXcCzhARPJz852M8sGShdaclD0zmBofhWgrlfGTqUpNfgfMy+mpIc9LZTFMw53sMDgZnfNVrqWytkKyt1Pm5ORQyxB+CjMPytTTkRO0OQFra2sqVqwIZCy+p9Pp8PDwUPjAAwICKFas2CudPzIyknLlyjFp0iS+++47qlSpQtu2bfn+++9p164dBQoUoGbNmnz00Udm4oJvgxwxOi4uLmZ8OGAYEpW5jtPDvXv3uHnzJmPGjAEMfDqhoaEcPXrUbBJcr9dTrlw5wMAW+CpYsmSJ4q2AgRnwZSRJI0aMoHHjxq90fhl16tTh5s2biqf0WH83ZfjTsHhlX8moCmGQEU5nXiijZrvUM17GcEtOLJspTygXM9ludq6smYVKr9KUHcnYVzl/htu1GkN+Ta9HHx6BPinZ0HVdMB/6gJTWjtSe1M2bN7GyssqxwUtJkrh69SoBAQEZSgxbWFhw9OhRmjdvDhjoXEwVK9JDWFiYQrmq1+tp1KgREydOxNHRkbp163LmzBm2b9+ORqOhRo0ajBs3jrVr1/LFF18QEBDwVveUrUYnISGBHTt20LFjxzTk1VqtlkWLFrFq1SrAMOawdOlSYmNjiYmJoXv37hQrVgyNRsORI0cYM2aMotQpf8tcuXKFAgUKYG9vz8cff8x///tfhBDcu3ePdevWpdvxDCje04EDB0hKSsLV1ZXp06dn+f07ODhQvnx55s2bx1dffUVMQkjKTJY8niAbC1l0D8yb/FJ7H7LxkT0e085j+dtXPo8Jo6CpRrrhNNkzbJkblZ7X6duR56lUNjYG1dP4hJR9JCPhmlqdrgFOTk5WvA7TAkd2Q6PRvNSImEKSpEw9sSdPnuDp6cn48eOpXr06q1atws7OjunTpzNw4EC2b9+uPK86nY5q1aopggrffvut0gv3xvfzVkdjSFydPn2aWrVqmYUbOp1OoVoMDAwkf/78LF261EwdsWbNmpw7d85MSvWXX37h448/5sqVK9y/f5/Zs2cr5ejFixezaNEiDh48yNq1a3n48CE6nY61a9diZ2dHixYtsLW1xcnJicqVK3Pu3Dml+gYpsseNGjXCwsKCqVOn8vTpUwDlwxQXF4eVlVWGbIZv8v54enqyefNm7KV8ihxM6odeMvLhSGqj/K8JSTqgEGelcwHjCSSzgU5JrUZAymS5TofMo6wcajqQmgW5nLxYWk6P2lSytASNGpJ16GNiDSyOajWqYoURT55nKG6oVquVrnh5ti8vws3NjbNnz9KsWTPA4NXY29srrJpz586lc+fOCs/46tWrlWMnT57M4sWLWb9+PWXKlOHOnTtMmTIFgI0bNyJJUob5z1fFGxud0NBQDh48yPHjx5Xmud9++43GjRszc+ZMDh8+TFBQED4+PowePZpNmzYp4YwMGxsb7t27R1hYGN7e3iQkJNCoUSPOnTvHkSNH+PDDD+nbty8XL17k2rVr2Nvbc+XKFQYOHEj58uUpWrQojo6OWFtbU6xYMa5du0Z0dDR2dnYIIbC2tubhw4eUKFGChIQErKysuH//PqGhoUrT4YoVK2jcuDG3bt0CDMnqoUOHZtmsytSpU5k6dSo9e/YkThha7NGR4sGoTSpIssFQqSBd46POMJks6XSGb2iNCcWFvE0m+EqP8D2Vcc2IfzijAcq8XE6WYUriJVlbKbrx+rhohYZDMlb0ZDoQ0/uS8zmSJKXp8cqL6N27Nx06dKBly5ZoNBq2bt1KwYIFad++PREREezatYtTp04RFBTE6tWr+fbbb5UWFFtbW8aOHcvYsWMBQ7Sybt06bty4QZs2bTIkwHsdvLEaxPLlyxVBu/Lly3Pr1i2qVKnClStXaNCgAREREdy7d4/jx4/j6elJ9+7dadiwoVn3pCnu3buHJElKV29mEEJw8+ZNXrx4QbVq1TLU5vLz82PHjh107dqViIgIZs+ezZIlS7C0tGT58uVcuHABvV7P4sWLmTRpEkePHqVy5cpm4xRvi2vXrinhnL26ALW1LdN0wwJmihFmU+RyWVunS/FmjP+a6Vqp1YZKjEoFWq3BgCUkGnI7epFCIqbkk0TafqEMSuaZcRrL295YoSEnodGgsrczGPT4eERMnHEK30DPqi5eBPE8GJGYaCihG9+HvDb+8CoICAjg2LFjREdH07ZtWwIDAzl8+DD29va0bduW48ePM3DgQLy9vVm6dGmWh4tvrPCZGQYOHEjNmjXp378/ly5dwsXFhR07dnDo0CEmTJjA/PnzadOmjdKbExgYSJEiRTI8nzxy8SqQJEkJhzLD+PHjcXR0JCgoiLNnzzJhwgTGjRtHZGQkhw4dIjIyEmtraxo1asSDBw8U49CpUyfCw8MZN24cc+bMwcHBQQnNXhfu7u6Eh4fToEEDrl69SoJlApZ6y5QH3GgEJCGPSahA6BTqUUVWJjU1RSqydcUAmY5DqCRISsn3GLypdL5kTLaZGhF4ebI2uypTWQaZ0dBCi2RjnWKQE5MMEjQAwqh/ZexrMhh4FZKaLEuu5zSKFSvGp59+ir+/P2vXrqVUqVJ89tlnSrf8iBEjOHXqVJrxpJzAW+tenT59mgkTJnDkyBHu3bvH+vXrefLkSZop8YkTJ6LX6/n666+zZOFviufPnxMbG6voY8nQ6/VERUVRo0YN/Pz8ePbsGV999RXVq1enefPmzJw5k6ioKDOv6q+//qJVq1YcOHDgpYTdK1eupH///jS07opWn4pLODPiKaPGecoclcrc45GhMsrNaNQpIZXcHGjq5aQ2OrKHJa8lE7wT3owpTLxIlY0N2BqbUxUPRygNmpKVJZKdLfqwcAPNrJFdcG/8htxZexYgJCQEZ2dnOnbsyPbt29m4cSP58+enc+fOfPfdd0qJPTuQbbpXQgju379PcLCBUc3NzY1evXqxZcsWzp07Z7avt7d3hh28OQkXF5c0BgcM/MeOjo6sXr0aPz8/hTHwwoULzJw5E1tbWzZt2sTJkycVbS0hBIGBgVSoUIHmzZsrtKapcf78eebPn08Ri7KodZK5wZH/NQltFGpPWbnAtCwucy9Dyv+FSNG2Ss0Q+Jr9JBnNSaUR5ctLSM2/bLo+o6CeKFwwRQ8MTMjWrVNI1xMTjcZdhT4xEb0p3es7iAIFCjBt2jQuXrxIvnz5FOrg6dOnZ6vBeRne6tMzYMAAunfvzrVr1wBDKDFy5Ej8/PzSNOpdv36dMmXKvM3l3hgJCQmMHDkSb29vSpYsydy5czMU+KtTpw4PHjxACIEP7dDpdNy8eZPBgwdz/PhxRowYQcGCBenRowePHj3i2rVreHp6sm/fPnr37k3z5s3TdCr7+vpy/fp1Kui9UsKodCtRKRPQIjnJzDMxDbOEXo9IMoYCJgloRXJG9ojk/2NaqUo1ZS3TXWRAbSEboXRF9vKK8Umvl8losCWtlqRqZZV2AX1waEpeSxZF1GpSkuwm4eq7mMtJjYkTJ7Jo0SKOHTvG3LlzOXTo0Ev7zYKCgjIVwHxbZPqpefToUaYHu7q6sm7dOmVYc/To0ZQrV45Vq1Zx7NgxRWUhMDCQn376yYycPSfxxRdfcPv2bfr27cuWLVvYtWuXovCQGTSSluaaroyo6MfV7x6yevVqLl26xK1bt6hZsyYLFy7E29tb4fwZM2YMMTExlC9fnm+//ZZbt24RFhbGokWLsMT61cvwRqqF1HrnZioSyq6qlH4fvdHjMb7vQqQi7EptVFI/pOkuJR3vxjQkTM+7yG3I96XTIWk0HDw8njgRTXzYM4Okclw8uqRE9LpkgzqrlZUhJDVWDf9NkCSJNm3asGnTJtatW0dwcDBPnz5l5syZTJ48Od1RHjc3N7p165Zta8o0M/qy8phMVDVu3DjAkFy2tLRUOoSTk5NJTEykffv2tGjRgpYtW2bFml+K2bNnY21tzciRIwkNDWXVqlUEBASQL18+wMDDXKZMGUaOHMm8efPSnfsC2K83dJ3u3buXuXPnUq5cOYoVK0bXrl1p06YN3bt3x8rKitOnT3P//n1WD9jCCXGCQ4cOsWnTJubPn6/QRVbQmNAPpOflmOpsC32KhpU6FV1FKj0tuaqlcPaojF6OSoWk1SJ0JkOlsl5ValUEkZI0fikt6TsA0yR4UKdyPH36lGN/zceRAtTUNGHFnZlUrVoVXawO54SKlC3WBCk82rxZ8x2EEILPP/8cLy+vNOHTsWPH+Pjjj9mxYwcNGjTAw8OD4OBgWrduTc2aNUlOTmbcuHFKCiSr+tTSQ6ZfTwUKFHilk3Tr1o2tW7cqTXVFihTB2tqaa9euUbNmTUqXLs0333zzSjKqWYFx48bxxRdfALBp0yYaNmyoGByAfPnycefOHYWqdNOmTYpXlhohISG0atWKQYMGsXXrVkaPHs2WLVto0KABJUqUoEaNGoxtPJ31A3ZgLRmMdPXq1fn444/5/fffCQsLo9yL+hSkUMYLlnXCtRpDDsLCwqCHbuwkNhtZyCxHk2boU28eaqWGbNz0pp5TWmoIMxka43rTnePKJW8nQwOpVqONEYo6ayltZYReoFar0Wq1DBgwACn/C0IjHxjyPSqVIdQS+lznQ34TLFy4kAULFqQbGq1atYrdu3fzzz//UK1aNaKjo4mJiVFYB/fs2cPGjRtJSkrC1taWadOmZds637p6lRqPHz/G09OTcuXKcfr0aYYOHcrixYuz1XKaIjk5mSFDhpCcnMyqVauoV68eJ0+eJDw8HEdHR7N94+Pj6d27N5cvX6Z06dJs3bo1DX2AXq9HrVZz9+7dNGV9WR4WDFQXJ0+eZMeOHQwbNoyyZcty48YNqlSpQs+ePVnZcxtqjdasL0RSGUrckkaD0OlQWVsj5A+MJBlVOFVGFcrUc1pqRGIiknFAUTYukoU25QGSKUuNyqJKjii9PiETVQRAKRsj8wWb7p9eBesVK2BZicwoLSS1mqR6lbB8FI7OzpKIEpY47b5uWGpiIp2XNWXz5s24ublx8Ug4xW0rQXgkIjYOkZDwTlatmjVrxv79+9HpdOl+wV+8eJH169fTtGlThg8fztatWxVBgWbNmnHt2jXatWvH8uXLcXV1fau1ZFv1Kj3cuHGDkiVL8vvvv3Px4kV++OGHHDM4U6ZMQavVotfrlbzSyZMn8fT0JCoqKs3+VlZWbNy4kevXryNJEt27d0+zT0JCAmXLlqV06dL8888/Zq89ePAAb29vDh48yOnTp6lduzZfffUVq1ev5uDBg3zwwQf8+eefrFixgqdl/YkqYYOqQilU5UshWWhROTqgKuQKxQuhKl4EnPMh2VgjOdobOmftbJFsbZBsbVDZ2qCytjb0k1hoDcfb2Ci/p8jKJKcoi6pUhjJ6Oh/ANN6BmU6WSN/gvApyIL/zMiZCSSUR09KTmMg/cKn1FHVUPPlvRiH0gm3hKxmwsTNubm5cunSJffv24WBZEL2VBVhaIHS6d9LgAIwdOxYXFxczgxMVFcX9+/d5/vw5Xl5ezJ8/n5CQEDw9PXF3d+fu3bs0a9ZMUZjo2LHjWxucl+GtZq/Onz/P9u3bqV+/Pj4+Pmi1WtRqNcnJyRQqVEgRyMsJbN68malTp3L58mU6derE/v37+fnnn/n222/NlCHSg0aj4bfffuODDz5gx44dODs7c+XKFQ4fPsz+/fvx8PDg9u3bXL58WVEgBfD09OTYsWNERkby9ddf4+npSfPmzVGr1dy5c4czZ84wcuRIFixYwLp16xg9ejQFNZ4Us6uMNp8TqFWI0HCkAvkM3cPRMYa5rPAIg/EA1I4OKSTrJv0jQqMx0DFYWKAoPEgSKlubFE9HksACg8ekDHumx0KYUv3RJ6XViMq0N0fuGTLt94GUfFE2IMMOaLUalYszJCVjcTuIk9fPceevJ4TEPuLUqVN4enqya9cuunbtSunSpQkJCaFt27Yk/uWAXmtkEMyhFEB2oHHjxgQFBREVFcWoUaNo2bIlffv2xcLCgqSkJGJiYujYsSNz5syhZ8+eqNVqnJycmDRpEmXLlqVMmTK0bt36ta8rhODWrVtIkkRCQsJLGRveyug8fPjQjPpz8ODBbN26lfnz57/Nad8IcuhUtWpVlixZwsKFC3F2dmb+/PlUrlxZ0R7PCNbW1owbN44pU6agVqupVKkSrVq1YtGiRS+1/A4ODmlaBOQk+5w5c5AkiZ49e+Ls7Ey3tr1IDH9BWYtqSuJSHx2TUhEyLV0LPckhIeYXkxPOxvBHxCco5WxJqzYML8q5CSVEk0CoUvp7TKGSDLNgyulTPchCj9Cb0nuSdoQiI8OTTUjP4Eh2toZBzqRk9OERaMME8+fP59KlS5QsWZIHDx4wf/58HBwcAANx1fnz56lRowbezt2w1BRA2FrxZ+SqbF9/dmPlypWsWrVKYXCwtbUlOTmZGjVqcPr0aWrWrMmqVatISkpSOMBbtmzJqFGjFM2s18Hy5csZMmQIZcuWxcLCQtGQywhvZXSsrKzw8fFhw4YNFClShPPnz7Nz506qVav2Nqd9LQghlEn3Tp060aNHDypWrMiyZcs4d+4carU6TViUET777DOFvP1toNPpWLNmDdWrVzejUq1evToR+mAi9MEUUn+Anc7wAOxL/JlmWl8T3XN9xiFKJq8ZBj/1YGlkElRLilJEptUotVrxrNI80OlRa6R3/fQMTzZ5O2k8HbUaydISfUQkIjEJSSWhcnRg3Q3BpXXrsLS0RKvVotPpuHfvHt26dWPv3r1UrlyZcuXK8VHbwly6qEZorLJ8raaIi4vD0tIy2wsqhQsXxsbGhj59+vDdd99hYWFBREQE+/fvZ/jw4QwaNIiff/4ZFxcX5syZg1arxdnZmYEDB772tdasWcOMGTO4evUqz5494/Dhwzg6OmYqa/zaieTAwEDKlStHTEyK5nO/fv0IDg6mXr16StUop9CuXTuOHTtGYmIiQ4YMYd68ecprM2fOZOLEiTg5OdG3b980BOrZhcDAQIoWLcrjx4+VebPDhw/TqFEjZZ/du3czbNgwbB+44q9P+QPdunWL7du3s2/suYzXKns7pioOcjOcxkhOZWsNKmP5PTHJkCA1dlIrHo9cuVIbvCC5Azcz6WDlWpBmOBUgXZqMbE4uq5wcEcnJ6CNT3HpJq4EKJclX+haBgYEKH0y9evUUyerq1auze/du6jh0wMa9KvtPpqXUzQo8fvyYLl26cPHiRVxdXZk3b14aqt+cwvz587l8+bKi4xYSEsK2bdvo1KmT4gW+Kvbs2cMnn3yCj48PT548Qa/X4+vrS3h4ON99913WJZKdnZ359NNPkSRJGSfYvHkzdnZ2OU4EffXqVc6dO8fRo0cBFH4QGf369UOj0fDtt9+yePFihc4iu1GkSBH0er1icGbMmKEYnAEDBlCvXj3GjBlD/fr1iSv5AiEE/v7+hIeH4+Pjw9ixYznI74RUucdtcTXtBdKbBjd9sFVSyliEMZEsyd238jZTw6HTp9FeT5OsTd0cmBFS62ylPjaLIRkrfiLGXP1DJCWTWMCapKQkTpw4QZkyZShYsCCnT5+mSJEiHDx4kLCwMD744AO0kcmEPLycbrEhK9C3b1+aNGlCbGwsq1evZtiwYbxuVTir0KBBA0VcAAxtMX379n1tg/PkyRN69epF69atEUKwbNky/P398fPzS/McpsZrfxpkWojvvvtOIWt2dXVl/fr1OZo4BoOc8ODBg/Hw8ODRo0ccOXLE7PWEhASSk5NZvHgx64xudk7B1Evx8fFh9erVxMfHk5iYyP379ylWrBg//fQTDx8+ZOfOnXh4eFCsWDFFovjFixf88MMPPOIO3lMq031VG34OWsLS2+Za6mY5IL1I8TT0BrIw1MYhULlpEExYCSXl94xmq9LMiZlcV7kepO0nyonBUOMwrIiJQyQnmXdYCz1W/4Ty7bff4uvrS3R0NN27d2fkyJGULFmSLVu2cOnSJR48eIDv0pZcDtyiiCRmNWJjY2ncuDFqtZpGjRqxdOlSOnXqlK08y9euXaNRo0b85z//YdeuXUofmru7O2FhYRkq1oaFhXHlypU0+m6p8csvv9CuXTsaNGhA2bJlqVu37iuHjW/8FdSmTRvl/zIxek7j+vXr1KlTBzBY7AYNGpi9XqxYMf755x8uXbqUa+4sGFz6Xr16YWlpSdGiRXny5Andu3cnODgYR0dHZs+ezaZNm4iJiVG+cebNm6eIqK1du5bevXvj4uJCmTJlCCx/nYEbUz605tUmo9ciNwYquZZU0+oy5GQzGRsY0+3plqtTPzzphYXZUEqXrCzTyuwY14lx4n5QmxVs/O03GjRoQPfu3QkMDMTFxYXJkycrHffPnz+ndu3aymcpq1GyZEkzgchOnToRFRXFs2fPsuT8/v7+fP3117Rr144TJ04QERGhlMHr16/PlClTqFixIuvWrUOj0bBv3z4mTpzIvHnz+O233+jRowfNmjWjaNGiFC9enK5du+Ll5cW9e/cyvKatrS1BQUE4Ozun4T9/Gd74UyAzw7dp00ap8ec03NzcGD58eIb0iSqVKt2J8tzE5MmTWb9+PV27diUsLIx8+fLx999/o1KpsLKy4vvvv8fb25vZs2dz5coVhBDK9PrEiRPx9/enX79+fP7550RWf8AT3QP0OhMjIbfyq1SGEEuSDCV0OX9j5OWRjNSoBh6e9NU90xCsZ2I0hCnrYWbIYsOjNFumgrpAPoRGhbCzolTz/mzcuJFq1apx6tcLPPk9mjp16hAaGoqFhQXly5fn1KlTipRRVqN3797Mnz/fzMg0atQoQw7v10FsbCx16tThxYsXPHz4kDNnzlC/fn0++eQTRo0axZAhQzh37hxLly7lhx9+oFmzZjg5OXHixAnWrVunyDmNHj2a48ePExERwd9//82wYcNo1KgRly5dSve6Xbp0UYjuMurmzwhv/Ak4duwYer2eCRMmKAOPOQ0nJydu377NH3/8oSQK8zq0Wi2ffvopFhYW6HQ6hBAEBwfzn//8R+E+kRUyHj9+DMDff/8NQOfOnXF3d2fMmDGcPHmS0aNHo64ch8PHieiFyR9eCGODoC4ljNKokSwt0jYKqlQpRGIqyazS9VI9cjnESoUcMTxGIjORDv2EysaGiEJaolwt0FlpKHPXiQMHDlCSijzlETqSFWYEgCZNmrz9ejJBo0aNaNSokVn4VqVKlVdWL8kMAQEBSmtIzZo1iYuLIzg4mB9++EHZR5IkGjVqxIkTJ/D29sbT05OAgACuXr3K1q1bUalU6PV67OzslBBp2LBhzJ49m5YtWzJ06FBCQkLQ6/U8f/4cvV7PokWL6NSpE56enpw9e9assPQyvNZfPygoCEmSWLNmDYmJiUiSRP78+XMsQZsac+bM4dGjR3Tq1InFixfnyhreBleuXFEUSzt06MCNGzews7OjTJky6PV6ZSrf19eXp0+f4uHhoRxbvHhxunXrxvnz54mOjuaB7paSR1EYAnXGf1UqYyXLOC5h1NuSu5jNKlKkhGupmwRT8/6YwSTEUkY2Mm0qfMNwy1Q+WQ4vNVokS0vFc9NX+IDTlxdyPWAriY8fkfD4IbOaLsMSa3QkE0oQ2kgbZs2axZEjR96oN+V10a5dO+7cuaP8XqJEiZeyOLwKihcvjlarpWnTppw7d46zZ8/SpEmTdCufGo2GyZMns2TJErp3706fPn3w9PRk7969LFq0iDJlytC4cWN+/PFHEhMT8fX15ebNm6jVakqVKkX+/PkpW7YsXl5erFu3Dl9fXypWrEiTJk348MMPGTRoEK1ataJmzZqZrvm1/uryAGjv3r2xsbEhKSmJAwcO4Onp+TqnyTLY2dlRrFgxPDw8uH//vpk8zbsA2R3+8ssv2bRpkxkroemHxsbGBjc3N7Njb9y4QUxMDBYWFnz99deEOT0mQReTwr+TnGxSGjfkc8xE+GS6DLmMbpKAzWjSPHXORzFEshSOvPbUeaOsQCojJVlYIJKSDQRcWkNlTrK2RlWsCJGlbHH7v94USIrgZvhmDsduJFQ8xwbD+3uXa5SiEmPHjqV27dpZu84MUL58eW7cuKF8Pu3s7F7LO8gI1tbWXL58mU8//ZTo6GgOHTqU7jiPKTp16sSsWbOoVasW58+fZ+PGjezdu5dnz54xfPhwfvnlF1q0aMHGjRsVscj79+9z9+5dwsLCmDp1Kp9++iktWrRApVLx448/cvz4cSpUqMCAAQMUoYaM8ErNgXFxccpChBBs2LCB7t27U7lyZUJCQjh48OCrv0vZgPHjx2NlZUX9+vW5cOFCjjYnvg18fX1xdXV9JW4fUzx69MhM5XT+/Pl8+umn/P3334gjVijfJTKXstrIuaPRpDAKyvSmKhVCUoH08oFNs7xP6ibB1FI4rwqTgdMMXzOFSgKMhtNESUNSqUCvJ8rDheAqEmqVG8HBwYSHh9OnTx9OrrnImeAjODs7Y29vj53dh2nPnY1wcnIiLi6lrF+wYEFevHiRJee2tbWld+/eHD9+nJ9++ol69eplur8kSXTt2jXNdisrK9q3b0+bNm349ttv+fXXXxkxYgT29vY0b96cNm3a0LJlS9q1a6fkcR8/fsyUKVOQJIlly5a9kqz3KzUH/vXXX4o3s2/fPmxtbalbty6tWrVi2bJlryxhmp3Q6XQULVoUnU7H+fPnc1QMLaeRmJjIjz/+CBhib1M0sGiPpcbO4NFYaJGcHBGWFkh6PcQnQLRB50luJNRHxxim0V9WuTIivW5leVpeIY+XJCO1ajqGRD4+szyRqbFJZ9xCsrAwXEOmF5VfU6kIbVeRZ7WiaHn5CVu2bKFNmzbs3buXQk/LkF9yYdb5ceTPn99shi4ncPbsWYYPH65IA587d46hQ4dmab/Os2fPaN26NV5eXnz//feKKMLbQAjBjRs3+PPPP9m4cSPR0dH07t2bBg0acP36dcaPH8/AgQM5ceIEJUuWZMWKFWg0mrebMp8xY4ZZ+NSsWTPq1q2Lvb09tWrVyhMGBwxCaE+ePEGj0fD8+fOXH/AOw8LCgqFDhzJ06FAiIyP54osvlB6kKF1YSpVKUkFiEpJej1CpjFUsY+VKMng/Mk3G22iCAyk9OzLd58uSyZl0PSuvGxPbclgoV92Ua8gT9poUieDntfU0PH2fFStWEBwczOrVq3n69CltJzek5viy/Oc//6Fjx47Z1giYEQIDAxXuGjB8Xl+36vMyuLm5ceTIEaKiovDy8uLMmTNvfU5JkqhUqRJjxozh3LlzrFixgvv37zNixAi2bNnC7t27mTFjBjt37uTJkyd8+OGH+Pr6ZnrOlxqdIUOGsH//fi5evMjVq1eVMYPp06fj5+f31jeVlZAkiZo1a3L1ajpdvP9S2NvbM3fuXOLj4yldujQWWBq4kxOTDHSlapXR4BiHQE0YBkVSckovT+oRh1dBRoqjqZREzSDLIYMJ06GJATJpXJRMvSfT5LfpcUZvSiQmklCrHJ6VHigJ2woVKtC+fXvAwBb59ddfc+fOHZ4/f55jhHJgCIcnTZpkFkZHRERkiXBdatjb27Nx40amTp1Khw4dGDp0KOHh4VlybkmS8Pb2Zvny5Zw/f55du3ZRvbrBmbGzs2PPnj0cPHjwpf1OL33nCxQoQJMmTfDy8sLDw4MxY8awefNmli9fniU3ktXw8vLi9u3bub2MXMHdu3fx/twjxRgkJUNcvEGyWM61yJ6C/NDJ3k4mQ55p+nVS7acklOHVPZ3USGVsJNkzk/81TVRLxoHWxCQDQX1iIpK9HZZBMcwpOEIZNsyfP7/CGPnXX39x4MABFi1axNmzZ7Plgc8Io0aNon379mZGx87O7qVdv2+DLl26cP36dXQ6HVWrVs2w3yYrIUkSZcuWZeTIkZnu99JPRnx8PD179mT//v3KtpIlS2aZ9cxqyDQG/4s4deoU69evZ8zOPgZvJ9noycgT5BqVknxN3a+TWZNghniZtvqrnks2KLJ3o1anyMXIxlKW1dHrEUJvUOE0EpapnBxBo0ZnY6H87fPly0fFihX56aefAAP3UePGjRk+fHimoo/ZAUdHR1auXGlWrbKysiIhISGTo94e+fLlY/ny5cyZM4cWLVqYzVzlJl5qdPR6PevWraNZs2b07dtX2Z6T3xSvg7CwMFxcXHJ7GdmG9evX06ZNG5YsWcKTJ0/MXqtduzZff/21wQs1qiGIpCTDQKckGYi/LCwMP5BC7iVDbczvGA1QSk9MBj01GYVir1PBMpF8kbTaFE9MhrHDWpbcSektMk7V29go11JHxDFn1iVq/WceH7kN5sHFQlSrOYwazf4vR77pM0LTpk3R6XRm3MXOzs48e/YsR1o8OnfuzOzZsxk6dGieaCl5qdGxsbHhxYsX+Pj4sGrVKr755hvOnTunzAXlNURERGSobf6uIz4+nh49enDv3j2++eYb3N3dqVWrFrNnz+bq1aucPHmSFStWUKFChZRO4qRkSEhAlZBkyOvozcMg5f8mlScwGoHUOZ6X5Xv0BuliJdmbmo9ZRhrid1VaYyMLC8r80PLDIoQhvJLDMAsjp7VGA1o1Ois11kFJ6K21qOOSuHB2Mef2zsjRHE5q2NraYmtrq/BpAxQqVIjQ0NAsK5u/DL169SIoKCjXpttNkelfIjAwECEEffv2VSa4169fz8iRI7NVF+dt8M8//1CyZMncXka2wMLCgtmzZ9O8eXPs7e2pXr06I0aMMExK+/oybNgwfH19mT59ekoDX3IyIiEBoVUjNCr0DtZgZYlInU9QqUzCG2OOR1apSJ3vSd2oZ8rnY6q3nlFiWp8SginhVGrvBlLEBE0n2TWalIl5mRvaQgsqFXHF7JH0Am14HKqwGPbcyF0JaxnVq1cnNjY2zfaqVaumYUbILqhUKjp16pQl815vi0ybA589e8b06dMZMWIET58+5cKFC9y+fZu///47zz7Yt2/fTrfx6d8AlUqlyB0nJSUxefJkJkyYwP3797l+/Tpubm64uLjQVNUZwEhdasjpSPFJYK1F0gmEVoMkGata5hcAfQoZuyEnpAGd3kBTCmaeSxqWQb1ASHokSwtEeESqc0spNKdyv03q68t5m/RCAIXjGfOpcmOiWW9rmP/TRCWhioxjz/15ac+RS7h//36aPJIkSYwaNYoFCxbQuXPnHCGXq1SpEkuWLKFz5844Ojpy9uxZGjZs+MpcOsnJyQgh0iimvC4y9XTUajWTJ09m8+bNnDlzhm3btpEvXz6cnZ3f6qLZieDg4NcmJHoXodVq+frrr4mNjeXLL7+kRYsWuLm54S7V5Il4gE4kG0Ya5DyIMX+jt9YiJesM5XSlXG5ask5JNMvEX/KoAXITYHpJZ2N5XjIK/aVhEJS5mo2Q0gunUpXZFY4es7K5UeECDPkcyVA219tosXocjeZxsKEJMg/Bw8ODW7dupalWeXh4cPr0afr165cj6+jevTsFChSgfPny1KxZk+7du1OqVClmzZr1SvOTI0aMwM7Ojrt3777VOjI1OnIcvGnTJs6ePcukSZOYNWtWnnyoV65cSdu2bQHMBiP/zYiOjiY4OJg1a9Zw4sQJOnbsyOBFPbnBBR5h6FUReoFITDSUzuOTSbbRIjTG5sDU3b6mMIr+mcrtKiKA8sMvvy6HUDIDYVKSuQ6Wmc5WOt/oOp0hlJIlk02qWab9OoZ1qZX+I2Wsw1JLoqMFqqhY9jxawJ6AhVnw7mYdnJyccHJyYuvWrWbbPT09+euvv1i1apXZiER2Qa1Ws2PHDk6dOkWRIkXw8PDghx9+4MSJE5QvX55hw4YphjEoKIgBAwbQpEkT/Pz8GDRoEBs3bqRVq1bUqVPHrJr9usjU6Dg5OdG5c2e8vLxo2LAhDRs2pE+fPm98sexCUlIS06ZNo1KlSuzbt8+s8/PfDFtbW3bt2sXJkyext7fnwIEDCrmaJP9phd4w+JmcjN5aS6KTxpBQNsJMjtgUsgFRSUhWlikJW9kAmXYKmzYdpmr8UzS0pBSPRTLpEUKIlLyNURBQlkqW5ZEVmWSjAZRsbJCcHCEhAYRAb2eF3kJiz9252fl2vxXmzJnDN998k6YTWh6iXr9+fY6sQ61WU7t2bYYNG8apU6cYP348O3bs4Ndff2Xnzp1MmjSJ06dPU758eeLj4xkxYgQAlStX5siRI/zxxx9s3rxZmfV7E2Q6e1WuXDnh5OTEhg0bePHiRY5N5L4uJk+ezMWLF9mxY0eOCfvlNcidpx4eHsTFxXFw2nkkJAL5BzuVE662paFyWcLL2uD85z1ITtuCn8bTAMUYSUZqUNRqgz4XmPDwqBRDobK3Qx8ZZUj4QkqvkAmUKpmp6qgpTBkO5fxTcrKBD8jGRiGSJz6BPU9/4F1AcHAwBQsWZMOGDWZFGH9/fzw8PFi2bBmDBg3KxRUaOLJ69erFgwcPkCQJV1dXnj59mma/gIAAqlevjq+vLwsXpu9VvvHsVVBQEOXLl6d06dJ51uCAgS512rRp/7MGZ/369axdu5bjx48zfvx41Go124LXcZFjePesgXMDK07FbiMh7AWJDnJnsiqFO1lpGExVQVL4loXSbCgSEgyej4NB28gsGWwcSZA0GoOx0WqQLC1R2RqUSCWt1tCLIxsc0xyOHIYJvcHLSko2GKREQ8cxxdxILF+U+NIFDeMc8M4YHICbN29ibW1NhQoVzLZXrlyZli1bsmzZslzvoalfvz43btxgwYIFzJgxw6zSlZiYyMWLF+nevTtVqlRhyJAhTJky5Y2uk6mnY2NjI06fPp1rfDmvgpCQED788EOePHnyr+3PyQhCCObNm8dXX32FJEl89dVX1KhRg759+2JpaUm/fv345hsDkfsPP/zA6HH/h3ehXlhGJackjE1DG6PmuVlzn/z/9Ay6EEi2xlA2KQm0WkhKMkyuy6GXlWVKYtl4jEhMUq4r5H4cU5iW460sQa0iqfKHbNk6lOKlvNi/+5eXEkXlNeh0OkqXLk2JEiU4dOiQWd/Qt99+y5w5c+jYsSNLlizJxVWmD39/f+rXr0++fPkYOnQoXbt2femgd2aezmvrXuU1+Pr6UrRoUTO9q/8F6PV6WrduzZ9//gnAqlWr6NWrF5IksWfPHo4fP86MGeZNcQMHDuTw1tuUtqqS4skYu2RFcrLBUzE1ADI3SkbDm3I/jcxnI0lIjg6I2FhDSKTTGXJBcjLa9FxGD0YJ6SClmVCuTmk1SPZ2iPwO/Ok/Ey8vLy5fvsyjR4/yDLvBq+LevXuULl0agM8//zyNTEtkZCRFixbl3r17CptkXsDGjRsZNWoUCxcufOn0uCkyMzpvpfCZG0hOTubFixfY29uzevVqNm3alGYc4H8BCxYs4M8//6Rv377MmDHDTP6nZcuWtGzZ0mz/8PBw7t+/T3xcKNhIkGw0MHIIZfRylJBH7pkhJYQyD4dMNbGMXpBRcQK9QCQnpDTvyQ18YORuFmCtRlKrDBruSUmGa1hqDN6TpQVYWUJCoqHpr7gjL1684PLly6xcufKdMzhgmAlcu3YtR48e5eTJk2led3BwQK1Ws3PnTnr37p3rqYIXL17Qo0cP/v77b3bs2JGlnmXu9Ya/Ic6ePUvhwoWxt7dnxYoV1K9fPw2V5/8C6taty8GDB1m5cuVL9cYiIyNp3749xYoVo4JLE4StjfHh16cMhsqhjon3k6aipDOGYjL3smkSWDKQgmFhgWRjnVLhMh27UKkMIZiR1wd7OyS3gobSe7HCSI726MuXILFCMYSjHdjZQnIyR3d9Rf78+bl586bZ/N+7BEmS6NGjB0uXLiUsLIx69erx5Zdfmu0zd+5c+vbtyy+//JJLqzQYm88//xwXFxeqVKmCv79/loey75zRqVu3rlLGu3r1KkePHs31b4XcwEcffWQmU5weQkNDqVGjBuXKleOiNo6zLu6ENC5GpHt+Yqt9APmdkFKzy5kK96X+MX1dpPV6hNAjNGqQS+ySZDAyalUK742NJcLOSvl/ZGEL/ikQRIQ2kgCnYIKco/GbXJsg62B2356tJIvVajXly5d/8zcsj0Cr1fLTTz9x8uTJNHNXFStWBAwqsKbDoTkBWaWzQoUK3Lp1i2+//ZZZs2ZlS570nQuvYmNjOXz4MCtXrvyfNDavAp1OR2JiIvv37+fGjRs4TRxMhZtFsD8dhzYghLjybggJ4ko4oY63xyIwHOITEKFhr38xoTeMSqhUSFotAgz0qPHalPAtMclQcdJL/Hl1Og2rT0CrN4RU3jUSmH1oh3K6EmElGDJkO0+fPmXlymr0798/y96XvIK6devi5+enELXLn+M6deoghKBKlSrs27ePVq1a5ch6EhISFOpUmWA9O/HOeDpxcXFMnDgRW1tbPDw88mSTYl7A7du3sba2xsnJiXnz5mHdpS1OEUVxvB2N9t4ziIvH+spDbG48xfrvIFTJgmQXB3SFCqAqWACVk4NhvOBlXDipSdn1erC0QNgY+ZjlcEpvaE4UkdFg7O+xcb3K/keLad2ngFkfyN27d3nw4AE3b95ky5YtfP/999nxFuUJTJgwgevXr7Nz5840r02aNCnbJI5TQ6fT0a1bN0JCQjh58mS2Gxx4h4zO9u3b2bx5M2vWrGH16tXvvRwjQkNDGTNmjMIXo9PpsLCwoNPqBgT/x5eysTUo/vtT1E9CDRUjYy6HhERISkbz8Dmah89RJSYjnOwRzk5Itjao7O2M5e5M3meTTmNUKkMyOlmP0KpBFvaTNbiEQB8fj6urq6IMuXnzZqUT98KFC5QqVUo59fPnz81+/7fBysqKGTNmMGHCBLNQKjk5mZ07dxIREZFlssOZYerUqYSGhqaRQMpOvDPhlTxN3bNnz9xeSp5BVFQU3t7elCxZklatWtG/f390Oh0ajYaArytSsJqE47nHBgUIkfLwC0CSRfhk2oigkJQkccH8hipSZHRKo59OZ66macpjLI9AWGhJzmeFKlGPJiElGS2M+Z8/w1ZSpkwZhTj/2LFjhISE8Pvvv1OlShWze7t06ZLCv/tvRfPmzfH19UVvTLY/fvyYzz//nN27d+Pm5saQIUPYtGkTFjLpWhbjxo0bLF26FH9/f4XYPyeQJz0dIQSbNm1SCK0dHR0JDw83k0p9D1iyZAnu7u64u7vj5uaGv7+/oVnSewi2z+LJv/0mIiLKzOAAho5fI7OgMt0tv6aSEM+DEUHBYG0F1laGpLBGY5yxUinDnpJabeg6litVOj2STiAlGs8pe6N6QZIujujoaMV7Wbt2LWCYPRo4cGAavSRHR0ciIlLRY/zLIM8IHjp0iDt37lCxYkW2bt3K6NGjuXLlCvHx8TRs2DBbrh0UFETXrl2ZNm1ajld/86TRefLkCb6+vnh5ebF161Y8PT25evUqQ4cOze2l5SmcPHmS58+fc+bMGXx8fAwzV+XK43YmTPEugJRSNyg8w2bbTP81mYMSIWGIqGiDkqatjUFHy9hlLNnbITnYG/I/GiOnsa01z72sScxvibC2SOlk1unQ1A5WelHAYGzkZsbAwECz+woODubw4cNpKjh//fUXQ4YMYerUqVn7RuYSVCoVfn5+zJw5k7JlyxIVFcXmzZuZMWMGdnZ2TJs2jVOnThEdHZ2l101KSsLHx4fOnTszePDgLD33qyBPdiQfOHCApk2bAgbZ1Li4uFyfS8mL2L9/P82aNUOtVqPVatPIf7TIPyAtIZai8KlSNLAUj8RodIRx/slsX5lovbALSQVs0YTHgwqkJB1SlJEVT6slsLUbFpGCCys/R6/Xk5SUhKWlpUFl8+RJateuzYkTJ9BqtcqUcmhoKAkJCQwbNoxhw4Zx9uxZDhw4wC+//KLwXQshlO7qDh068Pvvv2fPm5pLOHjwIO3bt+fixYuUKVMGMOR3Pv74Y7y8vJgxY8ZbnT85OZm9e/eyc+dOLl++jL+/P9evX+eDDz7IgtWnxTvTkRwfH0/z5s05duwYYOhbCAkJ4cCBA7m8sryJEydO0K9fP0aMGIGbmxuurq5mr/8Z+t8Mj22Rr7/BwKBTJsIBA5WFXoWQhEki2NiZ7OCIzsoCVYIOSQj0xl6cP//5zuzct2/fZsWKFfz3v/9VOHlr1apF7969GTdunOLtzJkzh6lTp+Ls7IydnR1RUVEcPHiQmJgY/vjjD8XgJCQkkJycTJkyZdi0aRNVq1Z96/cur+HBgwe0atVKMTgAGo0GPz8/2rRpQ3R0NMOHD1dGKV4VM2bMYOnSpTx79owaNWrQoUMHPvroI/r06cPvv//OiBEj0Gq1PHr0KOdUcYUQGf5Uq1ZN5BTCwsLE9OnTBRhaPYoXLy727t0rIiMjc2wN7xrKlSsntm/fntvLMEOvXr2Uv2HqHy8vLyGEUH7v3Lmz0Ov14s6dOyIuLk4kJyeLEydOiPDwcLNzDh48WADi8uXLuXBHOYOjR4+KggULiilTpoj4+Hiz1x49eiRGjRolPvzwQ/Hw4cPXOm+tWrXE4sWLhU6nEyEhIWLw4MGibt26wtPTUxQrVkxYWVkJW1tbAYgmTZqIpKSkLLkf4ILIwK7kutF59uyZ+OSTT4STk5Po2rWr+PHHH8WqVavEnTt3REJCQrZf/13FnTt3hLu7u/j1119zeylmGDlypChVqpQ4ffq0Yly8vb3Fxx9/LABx5swZsWbNGrFt2zYBiCpVqghAzJo1K8Nz3r17VzRu3FjcvHkzB+8k57FmzRoBiLCwsHRf/+abbwQgqlatKqZPny4OHDggHjx4ICIiIkRoaKi4cOGCGDx4sChevLh4+vSpEEKIRYsWiYIFC4pPPvlEODs7i7Zt24pp06aJFy9eCCGEiIuLE5cuXRJ//fWXaNCggfjxxx+z5F7ytNHx9fUVw4cPF4GBgco2vV6vWN/UVv89hLhx44ZwcnISAwYMyHOe4ObNm4W3t7cQwvCBbt26tQDE3bt3BSDc3d2VfQ8dOiQmTZok8ufPLxwdHcWWLVuEXq/PraXnOs6ePSsKFSokBg4cKKKjo9PdJzExURw4cECMGTNGeHt7iyJFigg7Ozthb28v3N3dxfjx44Wzs7PYuXOncszt27fFpk2bxM8//yxCQ0MzvP7ixYtFr169suRe8rTRKV26tDh9+rTZtu+//14A4pdffsn2679LuHPnjvDx8REajUYsWbIkt5eTLpKSkoSLi4vIly+fmD17ttDr9UpIIIfPp06dMjtGr9eLX375RVhZWYmdO3eKiIiI3Fh6riM5OVmMGzdO2Nraik6dOgmdTvdax587d04AQq1WK57O66BSpUqiX79+Ijk5+bWPTY08bXRGjx4thg4dKsLCwkS/fv3EpEmTBCCKFCmS7dd+19CxY0fRv39/ERQUlNtLyRQzZ84UgGjUqFGa13r06CH27t1rti0gIEC0bt1auLm5CUB4eHhkyQf/XUVUVJSoXr36a4c6HTt2FIAYO3bsKx/Tt29fUaVKFdG8eXPx/fffCw8PDzF06NDXXXIa5Gmj8/z5c1G1alVhZWVllnSMiorK9mu/S7h48aIoWLCg+Oeff3J7KS9FVFSUyJcvnwDMck6XLl0Su3fvFo8ePRJ///23st3Pz0/UqFFDAOLevXtKDmjYsGFv9I39b8CGDRtE7dq1zbYlJCSIxMTEdPe/ePGiAETPnj1f6zrW1tZizZo1olmzZqJz586iR48eok2bNm+8bhmZGZ1cbw7cunUrJUqUYOnSpYqEzKRJk/7nqEczgxCCkSNHMnv2bEqUKMGgQYOYOzfvKh+0bduW/PnzA1C2bFnAwIPk5eVFq1atKF68OAMGDFD2f/DgAR07dgRg586dLFiwgKdPn7Jt2zY2bNhAfHw8CQl5S8squ7Ft2zYqVapktq1Vq1aUL1+ezp07o9FomDlzJmCgEx08eDDz589nzZo1r3yNyMhI4uLiaNq0Kb/99hsuLi7Y2dmxYcOGLL2XNMjIGols8nSSk5NFjRo1hJubmzh27JhwdXUVgGjatKmwsLBQPJ3g4OAsv/a7ip9//llUqlRJJCcniwsXLghAzJs3L7eXlSH69u0rAOHg4CC2bdsmhBBm1Sz5Z/DgwUIIIbp16ybWrFkj7ty5I5ydncWePXuEEEIsXLhQKSgA4uDBg7l2TzmNoUOHitGjRyu/b9iwQVhZWQkvLy/RtGlTAYj27duL3bt3C0BUqlTptXNAUVFRAsgwaf02ILfDq5iYGDFx4kTx9ddfi23btomqVauK9evXi9q1a4tdu3aJqVOnCkBs27ZN/Pjjj8qH7D0M5WK1Wi1mzJgh9Hq9mDJligDydF4nODhY+Rs6OjoKf39/ERsbq5TGUxuRmTNnim7dugkhhDhy5IgAxKhRo4QQQjx+/Fjs3r1baLXadyK0zCoEBgaKkiVLioEDB4orV64IZ2dnM4Ndvnx5Jfe5e/fuN86BFStWTNy7dy+LV5+L4ZVer2fr1q3Y2tpy4sQJjh8/zvTp02natCmdOnUiICAAvV6Pn58fgwcPZs+ePfTr14+oqKgcGet/FzB48GB0Oh3z5s1j1qxZbNu2DQsLC6VbNy+iQIECiuufkJBAs2bN+PLLLylatKgiNieEUJgPt2/frtxPgwYN2LhxI48fP0an06FSqdBqtdStWzfbWvbzIgoXLsz58+ext7enU6dOdOzYkYYNG9KhQweaNGlCiRIl+Omnn7h27RotW7ZMMzD7qvjwww95+PBhFq/+JcjIGoks8HRGjRolPDw8BCAGDhwonjx5ImxsbETVqlWFEELs27dPuLu7i2vXronPPvtM2NjYiEePHr3VNf9tGDt2rGjVqpVo3LixAMTx48fF1atXxejRozNMKuYV7NixQwBi6dKlomPHjsLCwkJYWVmJhw8fCp1OJ1atWiUeP34shgwZImbPnq0ct2vXLlG3bl0xduxYAYh+/fqJzp075+Kd/Dvx008/CWdnZ3H37t0sPze5FV41adJEbN68WQQGBirhwEcffSScnJzEo0ePhE6nE2q1WowfPz5NnP8eKRg0aJCoVKmSAMTatWuFvb29AERsbGxuL+2lkLtrN23aJACxfPlysxBr1KhRYsuWLaJFixbKMevXrxeA8PT0VPbz9/fPpTv4d2Lr1q3Czc1N3LhxI1vOn5nRybaBT51Oh5OTk8IFKyMiIgIXFxeCg4MpXLgwOp2OESNGsGnTJu7fv49Wq82uJb2zkCSJjz/+mM8//5y2bdty6dIlGjdujHVqUvU8CCcnJwCaNm1KwYIF+eOPPxStrkWLFtGrVy/8/f25du2ackznzp0BaN++PYcPH+b27du4u7vn+Nr/zZg0aRKrVq3KEXrSNMjIGom39HROnDihfEvFxMQIIYS4deuWKFq0qHB1dRUBAQEiMTFRqFQq0bBhQ9GkSRNx5cqV/9lu1Mxw9+5dUahQITFlyhSz/pZ3DdevXxfNmjUTgHj8+LGyvVevXuLzzz/PxZX9+7F//36lSvXkyRORL1++bH3WyI1EsoWFBQULFmT58uUKQ1pMTAz58+fH0tKSp0+fotVqKVq0KIcPH2bv3r14enri4OCQXUt6JyCE4ObNm+j1euWnVKlSfPfdd+zbt49PP/00t5f4xihYsCD79u3D19eXIkWKKNsTExPx8vLKxZX9u7Fv3z6aNm3KzZs3AcNnTK1WY29vnyvryTajU716dfz8/JgwYQKzZ88mLi4OBwcHrl27xqhRoxg3bhxPnz6ld+/eAGk0gP5XMW/ePCpWrMinn36Kl5cXarWaLl260L59e4YMGULhwoVze4lvDGdnZzw8PGjdurXZdhsbG2JiYnJpVf9+tGnTBkChfy1UqBAuLi4sXrw4V9aTbUZHkiRGjBjBuXPnOH36NC4uLtSrV49hw4bx4sUL7t69S5cuXZgyZQq3bt1KQ0D1vwpnZ2fAQIQ1evRoIiMj0ev1tGzZku+++47u3bvn8grfHJIksXbtWsaMGUP79u0VOWiNRmMmRfMeWYsCBQowfPhwunTpwqRJkwgMDFRI2XMFGcVd4g1zOnFxcelWVQICAsTx48dF586dzZqc/Pz83ihm/LciOTlZWFtbm3VkHzp0SLi6uormzZu/dtdpXkRMTIwYP368qFy5snj+/Ln44YcfxIABA3J7Wf9aWFlZiZiYGLF//37h4OAgSpUqJbp06ZKtfFXkRMl806ZNwsPDQ9jb2wsHB4d0J2RDQ0MFILRarVCr1cLNzc2M9+M9hIiOjhYajcbsfWnUqJEAsozVLS9Ar9cLPz8/4ebmJgYNGiQqV66c20v6VyI+Pl6o1WqRnJwskpOTlS/7q1evZut1s83ohIWFiT///FMsXbpUuZkbN26IW7duCVtbW4WAKykpSenFqVatmjh8+LC4efOmCAgIyKZbfrfh5+cnLC0txbRp04Rer1fet38jTp8+LZycnBTir/fIWsifH0Bs375dDB8+XJw5cybbr5vlRicsLEyMHj1auLi4CB8fH9GzZ0/Rv39/5caEEMLR0VGEhYWJ48ePi+rVqys3vmXLlmy+3X8H7t+/L2xsbMT169cFIObOnZvbS8o2JCUl/SvCxtxERESE0ppiCtM5uIULF+bYejIzOq+VSI6MjGTcuHEUL16cBQsW8Pz5c44cOcInn3zCokWLABg0aBAPHjygRIkSDBs2DG9vb54+fcq9e/ewsrJKo3H0HukjPDwcZ2dn4uPjAWjWrFkuryj7oNFoFHmZ93h1hIeHM2PGDKpVq0bhwoWxtbVl+/btZvscOHCANm3asGzZMnx9fXNppeZ4rY5kPz8/Hjx4wLVr14iLi2PJkiV8//33dOjQgQULFtCiRQsCAgL48MMPAahWrRpFixalW7dulCxZkri4uGy5iX8jkpKSyJ8/P0WKFGHkyJFUrlw5t5f0HnkM/fv3Jy4ujgULFvDRRx9haWnJ/fv3zfa5desWlSpVYtCgQbm0ynSQkQsk0gmv3N3dxdGjR9NzpQQgzp49K6ysrIS7u7vo06dPhqz27/Fy3LhxQ3zwwQe5vYz3yMOoVKmSWUK4d+/eZiGUTqcTJUqUECdPnszxtfE24VVCQgIHDhxg5cqVODs7M23atDT7fPXVVwDs3buXqKgo/P39+emnn5S5m/d4fZw6dYq6devm9jLeIw+jfPny7Nq1S/ldo9EYErVGREdHExISYqb6mheQqaxwhQoVhF6vJ3/+/Hz44YecPHmSR48e8d133/HZZ58p+4WFhSn0lAMHDmT58uXZvvB/E+zs7Lh8+TJXrlxh4cKFVKtWjdDQUDw8PBg9ejSSJKHR5Ckx1vfIA3jw4AH169enf//+9OnTh+rVq3Py5ElFBfT58+dUrFiR4ODgHF9bZrLCmRodSZL+BJyza2Hv8R7v8a9FsBCiRXovZGp03uM93uM9shrv65Tv8R7vkaN4b3Te4z3eI0fx3ui8x3u8R47ivdF5j/d4jxzFe6PzHu/xHjmK/wezQbWp3GSmQQAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "import cartopy.crs as ccrs\n", + "\n", + "fig = plt.figure(figsize=[10, 5])\n", + "\n", + "ax = plt.subplot(1, 1, 1, projection=ccrs.Orthographic(0, 90))\n", + "\n", + "ax.coastlines(zorder=3)\n", + "\n", + "ax.pcolormesh(test.lon[max([0,test.index_y[0][0]-1]):test.index_y[0][-1]+2:test.red_fac,\n", + " max([0,test.index_x[0][0]-1]):test.index_x[0][-1]+2:test.red_fac],\n", + " test.lat[max([0,test.index_y[0][0]-1]):test.index_y[0][-1]+2:test.red_fac,\n", + " max([0,test.index_x[0][0]-1]):test.index_x[0][-1]+2:test.red_fac],\n", + " np.sum(test.eps_tot_list,axis=0),transform=ccrs.PlateCarree())" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "a5e4599e-bf15-43fd-9fc7-90b2a1da7435", + "metadata": {}, + "outputs": [ + { + "ename": "IndexError", + "evalue": "2-dimensional boolean indexing is not supported. ", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mIndexError\u001b[0m Traceback (most recent call last)", + "Input \u001b[0;32mIn [11]\u001b[0m, in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0m test\u001b[38;5;241m.\u001b[39mlon[test\u001b[38;5;241m.\u001b[39mlon\u001b[38;5;241m>\u001b[39m\u001b[38;5;241m180\u001b[39m] \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m=\u001b[39m \u001b[38;5;241m360\u001b[39m\n", + "File \u001b[0;32m~/miniforge3/envs/lkf_tools/lib/python3.10/site-packages/xarray/core/dataarray.py:741\u001b[0m, in \u001b[0;36mDataArray.__getitem__\u001b[0;34m(self, key)\u001b[0m\n\u001b[1;32m 738\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_getitem_coord(key)\n\u001b[1;32m 739\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 740\u001b[0m \u001b[38;5;66;03m# xarray-style array indexing\u001b[39;00m\n\u001b[0;32m--> 741\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43misel\u001b[49m\u001b[43m(\u001b[49m\u001b[43mindexers\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_item_key_to_dict\u001b[49m\u001b[43m(\u001b[49m\u001b[43mkey\u001b[49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/miniforge3/envs/lkf_tools/lib/python3.10/site-packages/xarray/core/dataarray.py:1197\u001b[0m, in \u001b[0;36mDataArray.isel\u001b[0;34m(self, indexers, drop, missing_dims, **indexers_kwargs)\u001b[0m\n\u001b[1;32m 1194\u001b[0m indexers \u001b[38;5;241m=\u001b[39m either_dict_or_kwargs(indexers, indexers_kwargs, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124misel\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m 1196\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28many\u001b[39m(is_fancy_indexer(idx) \u001b[38;5;28;01mfor\u001b[39;00m idx \u001b[38;5;129;01min\u001b[39;00m indexers\u001b[38;5;241m.\u001b[39mvalues()):\n\u001b[0;32m-> 1197\u001b[0m ds \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_to_temp_dataset\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_isel_fancy\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 1198\u001b[0m \u001b[43m \u001b[49m\u001b[43mindexers\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdrop\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mdrop\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmissing_dims\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmissing_dims\u001b[49m\n\u001b[1;32m 1199\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1200\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_from_temp_dataset(ds)\n\u001b[1;32m 1202\u001b[0m \u001b[38;5;66;03m# Much faster algorithm for when all indexers are ints, slices, one-dimensional\u001b[39;00m\n\u001b[1;32m 1203\u001b[0m \u001b[38;5;66;03m# lists, or zero or one-dimensional np.ndarray's\u001b[39;00m\n", + "File \u001b[0;32m~/miniforge3/envs/lkf_tools/lib/python3.10/site-packages/xarray/core/dataset.py:2416\u001b[0m, in \u001b[0;36mDataset._isel_fancy\u001b[0;34m(self, indexers, drop, missing_dims)\u001b[0m\n\u001b[1;32m 2414\u001b[0m indexes[name] \u001b[38;5;241m=\u001b[39m new_index\n\u001b[1;32m 2415\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m var_indexers:\n\u001b[0;32m-> 2416\u001b[0m new_var \u001b[38;5;241m=\u001b[39m \u001b[43mvar\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43misel\u001b[49m\u001b[43m(\u001b[49m\u001b[43mindexers\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mvar_indexers\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 2417\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 2418\u001b[0m new_var \u001b[38;5;241m=\u001b[39m var\u001b[38;5;241m.\u001b[39mcopy(deep\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mFalse\u001b[39;00m)\n", + "File \u001b[0;32m~/miniforge3/envs/lkf_tools/lib/python3.10/site-packages/xarray/core/variable.py:1186\u001b[0m, in \u001b[0;36mVariable.isel\u001b[0;34m(self, indexers, missing_dims, **indexers_kwargs)\u001b[0m\n\u001b[1;32m 1183\u001b[0m indexers \u001b[38;5;241m=\u001b[39m drop_dims_from_indexers(indexers, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mdims, missing_dims)\n\u001b[1;32m 1185\u001b[0m key \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mtuple\u001b[39m(indexers\u001b[38;5;241m.\u001b[39mget(dim, \u001b[38;5;28mslice\u001b[39m(\u001b[38;5;28;01mNone\u001b[39;00m)) \u001b[38;5;28;01mfor\u001b[39;00m dim \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mdims)\n\u001b[0;32m-> 1186\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m[\u001b[49m\u001b[43mkey\u001b[49m\u001b[43m]\u001b[49m\n", + "File \u001b[0;32m~/miniforge3/envs/lkf_tools/lib/python3.10/site-packages/xarray/core/variable.py:778\u001b[0m, in \u001b[0;36mVariable.__getitem__\u001b[0;34m(self, key)\u001b[0m\n\u001b[1;32m 765\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m__getitem__\u001b[39m(\u001b[38;5;28mself\u001b[39m: T_Variable, key) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m T_Variable:\n\u001b[1;32m 766\u001b[0m \u001b[38;5;124;03m\"\"\"Return a new Variable object whose contents are consistent with\u001b[39;00m\n\u001b[1;32m 767\u001b[0m \u001b[38;5;124;03m getting the provided key from the underlying data.\u001b[39;00m\n\u001b[1;32m 768\u001b[0m \n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 776\u001b[0m \u001b[38;5;124;03m array `x.values` directly.\u001b[39;00m\n\u001b[1;32m 777\u001b[0m \u001b[38;5;124;03m \"\"\"\u001b[39;00m\n\u001b[0;32m--> 778\u001b[0m dims, indexer, new_order \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_broadcast_indexes\u001b[49m\u001b[43m(\u001b[49m\u001b[43mkey\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 779\u001b[0m data \u001b[38;5;241m=\u001b[39m as_indexable(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_data)[indexer]\n\u001b[1;32m 780\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m new_order:\n", + "File \u001b[0;32m~/miniforge3/envs/lkf_tools/lib/python3.10/site-packages/xarray/core/variable.py:621\u001b[0m, in \u001b[0;36mVariable._broadcast_indexes\u001b[0;34m(self, key)\u001b[0m\n\u001b[1;32m 618\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mall\u001b[39m(\u001b[38;5;28misinstance\u001b[39m(k, BASIC_INDEXING_TYPES) \u001b[38;5;28;01mfor\u001b[39;00m k \u001b[38;5;129;01min\u001b[39;00m key):\n\u001b[1;32m 619\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_broadcast_indexes_basic(key)\n\u001b[0;32m--> 621\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_validate_indexers\u001b[49m\u001b[43m(\u001b[49m\u001b[43mkey\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 622\u001b[0m \u001b[38;5;66;03m# Detect it can be mapped as an outer indexer\u001b[39;00m\n\u001b[1;32m 623\u001b[0m \u001b[38;5;66;03m# If all key is unlabeled, or\u001b[39;00m\n\u001b[1;32m 624\u001b[0m \u001b[38;5;66;03m# key can be mapped as an OuterIndexer.\u001b[39;00m\n\u001b[1;32m 625\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mall\u001b[39m(\u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(k, Variable) \u001b[38;5;28;01mfor\u001b[39;00m k \u001b[38;5;129;01min\u001b[39;00m key):\n", + "File \u001b[0;32m~/miniforge3/envs/lkf_tools/lib/python3.10/site-packages/xarray/core/variable.py:667\u001b[0m, in \u001b[0;36mVariable._validate_indexers\u001b[0;34m(self, key)\u001b[0m\n\u001b[1;32m 662\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mIndexError\u001b[39;00m(\n\u001b[1;32m 663\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mBoolean array size \u001b[39m\u001b[38;5;132;01m{:d}\u001b[39;00m\u001b[38;5;124m is used to index array \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 664\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mwith shape \u001b[39m\u001b[38;5;132;01m{:s}\u001b[39;00m\u001b[38;5;124m.\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;241m.\u001b[39mformat(\u001b[38;5;28mlen\u001b[39m(k), \u001b[38;5;28mstr\u001b[39m(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mshape))\n\u001b[1;32m 665\u001b[0m )\n\u001b[1;32m 666\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m k\u001b[38;5;241m.\u001b[39mndim \u001b[38;5;241m>\u001b[39m \u001b[38;5;241m1\u001b[39m:\n\u001b[0;32m--> 667\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mIndexError\u001b[39;00m(\n\u001b[1;32m 668\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;132;01m{}\u001b[39;00m\u001b[38;5;124m-dimensional boolean indexing is \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 669\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mnot supported. \u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;241m.\u001b[39mformat(k\u001b[38;5;241m.\u001b[39mndim)\n\u001b[1;32m 670\u001b[0m )\n\u001b[1;32m 671\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mgetattr\u001b[39m(k, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mdims\u001b[39m\u001b[38;5;124m\"\u001b[39m, (dim,)) \u001b[38;5;241m!=\u001b[39m (dim,):\n\u001b[1;32m 672\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mIndexError\u001b[39;00m(\n\u001b[1;32m 673\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mBoolean indexer should be unlabeled or on the \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 674\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124msame dimension to the indexed array. Indexer is \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 677\u001b[0m )\n\u001b[1;32m 678\u001b[0m )\n", + "\u001b[0;31mIndexError\u001b[0m: 2-dimensional boolean indexing is not supported. " + ] + } + ], + "source": [ + "test.lon[test.lon>180] -= 360" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "1f7d626c-5c32-498d-8660-fd39877ae5cc", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.DataArray 'ULON' (y: 438, x: 518)>\n",
+       "array([[-105.96823  , -105.85332  , -105.737885 , ...,   -8.047913 ,\n",
+       "          -7.94223  ,   -7.837036 ],\n",
+       "       [-106.09569  , -105.980835 , -105.86545  , ...,   -7.921692 ,\n",
+       "          -7.816101 ,   -7.7109985],\n",
+       "       [-106.22366  , -106.10886  , -105.99353  , ...,   -7.794983 ,\n",
+       "          -7.689514 ,   -7.5844727],\n",
+       "       ...,\n",
+       "       [ 171.66559  ,  171.55157  ,  171.43701  , ...,   70.37024  ,\n",
+       "          70.26585  ,   70.16194  ],\n",
+       "       [ 171.53189  ,  171.41777  ,  171.30313  , ...,   70.50215  ,\n",
+       "          70.397644 ,   70.293625 ],\n",
+       "       [ 171.39871  ,  171.28452  ,  171.16978  , ...,   70.63358  ,\n",
+       "          70.52897  ,   70.42483  ]], dtype=float32)\n",
+       "Coordinates:\n",
+       "    VLON     (y, x) float32 253.9 254.0 254.1 254.3 ... 70.86 70.75 70.65 70.54\n",
+       "    VLAT     (y, x) float32 60.57 60.63 60.69 60.76 ... 60.09 60.02 59.96 59.89\n",
+       "    ULON     (y, x) float32 254.0 254.1 254.3 254.4 ... 70.74 70.63 70.53 70.42\n",
+       "    ULAT     (y, x) float32 60.57 60.63 60.7 60.76 ... 60.08 60.02 59.95 59.89\n",
+       "    TLON     (y, x) float32 254.0 254.1 254.2 254.3 ... 70.79 70.69 70.58 70.48\n",
+       "    TLAT     (y, x) float32 60.54 60.6 60.67 60.73 ... 60.12 60.05 59.98 59.92\n",
+       "Dimensions without coordinates: y, x\n",
+       "Attributes:\n",
+       "    standard_name:        longitude\n",
+       "    long_name:            longitude at U points\n",
+       "    units:                degrees_east\n",
+       "    _CoordinateAxisType:  Lon
" + ], + "text/plain": [ + "\n", + "array([[-105.96823 , -105.85332 , -105.737885 , ..., -8.047913 ,\n", + " -7.94223 , -7.837036 ],\n", + " [-106.09569 , -105.980835 , -105.86545 , ..., -7.921692 ,\n", + " -7.816101 , -7.7109985],\n", + " [-106.22366 , -106.10886 , -105.99353 , ..., -7.794983 ,\n", + " -7.689514 , -7.5844727],\n", + " ...,\n", + " [ 171.66559 , 171.55157 , 171.43701 , ..., 70.37024 ,\n", + " 70.26585 , 70.16194 ],\n", + " [ 171.53189 , 171.41777 , 171.30313 , ..., 70.50215 ,\n", + " 70.397644 , 70.293625 ],\n", + " [ 171.39871 , 171.28452 , 171.16978 , ..., 70.63358 ,\n", + " 70.52897 , 70.42483 ]], dtype=float32)\n", + "Coordinates:\n", + " VLON (y, x) float32 253.9 254.0 254.1 254.3 ... 70.86 70.75 70.65 70.54\n", + " VLAT (y, x) float32 60.57 60.63 60.69 60.76 ... 60.09 60.02 59.96 59.89\n", + " ULON (y, x) float32 254.0 254.1 254.3 254.4 ... 70.74 70.63 70.53 70.42\n", + " ULAT (y, x) float32 60.57 60.63 60.7 60.76 ... 60.08 60.02 59.95 59.89\n", + " TLON (y, x) float32 254.0 254.1 254.2 254.3 ... 70.79 70.69 70.58 70.48\n", + " TLAT (y, x) float32 60.54 60.6 60.67 60.73 ... 60.12 60.05 59.98 59.92\n", + "Dimensions without coordinates: y, x\n", + "Attributes:\n", + " standard_name: longitude\n", + " long_name: longitude at U points\n", + " units: degrees_east\n", + " _CoordinateAxisType: Lon" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "test.lon.where(test.lon<180,other=test.lon-360)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3bfdcd57-90bc-4e63-8e7f-6201c4515c38", + "metadata": {}, + "outputs": [], "source": [] } ], From 6929d63d28e96ef3b1f6d5686de0dfde3bdd6e2b Mon Sep 17 00:00:00 2001 From: Nils Hutter Date: Tue, 15 Mar 2022 10:36:14 -0700 Subject: [PATCH 05/21] Detection of netcdf data-set is working --- lkf_tools/dataset.py | 54 ++++++++--------- lkf_tools/detection.py | 32 +++++++++- notebooks/detection_tutorial.ipynb | 94 +++++++++++++----------------- 3 files changed, 94 insertions(+), 86 deletions(-) diff --git a/lkf_tools/dataset.py b/lkf_tools/dataset.py index 02af9f2..c0ce347 100644 --- a/lkf_tools/dataset.py +++ b/lkf_tools/dataset.py @@ -40,10 +40,12 @@ def __init__(self,netcdf_file,output_path='./',max_kernel=5,min_kernel=1, netcdf_file: expected variables U,V,A in shape (time,x,y) """ # Set output path - self.lkfpath = Path(output_path).joinpath(netcdf_file.split('.')[0]) - for lkfpathseg in str(self.lkfpath.absolute()).split('/'): - if not os.path.exists(self.lkfpath): - os.mkdir(self.lkfpath) + self.lkfpath = Path(output_path).joinpath(netcdf_file.split('/')[-1].split('.')[0]) + lkfpath = '/' + for lkfpathseg in str(self.lkfpath.absolute()).split('/')[1:]: + lkfpath += lkfpathseg + '/' + if not os.path.exists(lkfpath): + os.mkdir(lkfpath) # Store detection parameters self.max_kernel = max_kernel @@ -110,11 +112,11 @@ def detect_lkfs(self,indexes=None,force_redetect=False): self.ind_detect = [] if indexes is None: - self.indexes = np.arange(time.size/self.t_red) + self.indexes = np.arange(self.time.size/self.t_red) else: self.indexes = indexes - for it in [j for j in self.indexes if j+1 not in self.ind_detect]: + for it in [int(j) for j in self.indexes if j+1 not in self.ind_detect]: print("Compute deformation rates and detect features for day %i" %(it+1)) @@ -127,9 +129,10 @@ def detect_lkfs(self,indexes=None,force_redetect=False): aice = self.data.A[it+itr,:,:] # Check if deformation rates are given - if hasattr(self.data,'div') and hasattr(self.data,'shr'): + if hasattr(self.data,'div') and hasattr(self.data,'shr') and hasattr(self.data,'vor'): div = self.data.div[it+itr,:,:] shr = self.data.shr[it+itr,:,:] + vor = self.data.vor[it+itr,:,:] else: dudx = ((uice[2:,:]-uice[:-2,:])/(self.dxu[:-2,:]+self.dxu[1:-1,:]))[:,1:-1] dvdx = ((vice[2:,:]-vice[:-2,:])/(self.dxu[:-2,:]+self.dxu[1:-1,:]))[:,1:-1] @@ -138,6 +141,7 @@ def detect_lkfs(self,indexes=None,force_redetect=False): div = (dudx + dvdy) * 3600. *24. # in day^-1 shr = np.sqrt((dudx-dvdy)**2 + (dudy + dvdx)**2) * 3600. *24. # in day^-1 + vor = 0.5*(dudy-dvdx) * 3600. *24. # in day^-1 eps_tot = np.sqrt(div**2+shr**2) @@ -172,19 +176,21 @@ def detect_lkfs(self,indexes=None,force_redetect=False): if self.latlon: lkf = segs2latlon_model(lkf, - self.lon[max([0,self.index_y[0][0]-1]):self.index_y[0][-1]+2:self.red_fac, - max([0,self.index_x[0][0]-1]):self.index_x[0][-1]+2:self.red_fac], - self.lat[max([0,self.index_y[0][0]-1]):self.index_y[0][-1]+2:self.red_fac, - max([0,self.index_x[0][0]-1]):self.index_x[0][-1]+2:self.red_fac]) - if return_eps: - lkf = segs2eps(lkf, - div[max([0,self.index_y[0][0]-1]):self.index_y[0][-1]+2:self.red_fac, - max([0,self.index_x[0][0]-1]):self.index_x[0][-1]+2:self.red_fac], - shr[max([0,self.index_y[0][0]-1]):self.index_y[0][-1]+2:self.red_fac, - max([0,self.index_x[0][0]-1]):self.index_x[0][-1]+2:self.red_fac]) + np.array(self.lon[max([0,self.index_y[0][0]-1]):self.index_y[0][-1]+2:self.red_fac, + max([0,self.index_x[0][0]-1]):self.index_x[0][-1]+2:self.red_fac]), + np.array(self.lat[max([0,self.index_y[0][0]-1]):self.index_y[0][-1]+2:self.red_fac, + max([0,self.index_x[0][0]-1]):self.index_x[0][-1]+2:self.red_fac])) + if self.return_eps: + lkf = segs2epsvor(lkf, + np.array(div[max([0,self.index_y[0][0]-1]):self.index_y[0][-1]+2:self.red_fac, + max([0,self.index_x[0][0]-1]):self.index_x[0][-1]+2:self.red_fac]), + np.array(shr[max([0,self.index_y[0][0]-1]):self.index_y[0][-1]+2:self.red_fac, + max([0,self.index_x[0][0]-1]):self.index_x[0][-1]+2:self.red_fac]), + np.array(vor[max([0,self.index_y[0][0]-1]):self.index_y[0][-1]+2:self.red_fac, + max([0,self.index_x[0][0]-1]):self.index_x[0][-1]+2:self.red_fac])) lkf_T = [j.T for j in lkf] - np.save(lkfpath + 'lkf_' + datafile.split('/')[-1][:-3] + '_%03i.npy' %(it+1), lkf_T) + np.save(self.lkfpath.joinpath('lkf_%s_%03i.npy' %(self.netcdf_file.split('/')[-1].split('.')[0],(it+1))), lkf_T) @@ -195,15 +201,3 @@ def detect_lkfs(self,indexes=None,force_redetect=False): -def segs2latlon_model(segs,lon,lat): - """ Function that converts index format of detected LKFs to - lat,lon coordinates - """ - segsf = [] - for iseg in segs: - segsf.append(np.concatenate([iseg, - np.stack([lon[iseg[0],iseg[1]], - lat[iseg[0],iseg[1]]])], - axis=0)) - return segsf - diff --git a/lkf_tools/detection.py b/lkf_tools/detection.py index d26777b..e779bfe 100644 --- a/lkf_tools/detection.py +++ b/lkf_tools/detection.py @@ -936,6 +936,21 @@ def segs2latlon_rgps(segs,xg0,xg1,yg0,yg1,nxcell,nycell,m=mSSMI()): axis=0)) return segsf + +def segs2latlon_model(segs,lon,lat): + """ Function that converts index format of detected LKFs to + lat,lon coordinates + """ + segsf = [] + for iseg in segs: + segsf.append(np.concatenate([iseg, + np.stack([lon[iseg[0],iseg[1]], + lat[iseg[0],iseg[1]]])], + axis=0)) + return segsf + + + def segs2eps(segs,epsI,epsII): """ Function that saves for each point of each LKF the deformation rates and attach them to segs. @@ -949,8 +964,23 @@ def segs2eps(segs,epsI,epsII): iseg[1].astype('int')]])], axis=0)) return segsf + - +def segs2epsvor(segs,epsI,epsII,epsvor): + """ Function that saves for each point of each LKF the deformation + rates and attach them to segs (including vorticity!). + """ + segsf = [] + for iseg in segs: + segsf.append(np.concatenate([iseg, + np.stack([epsI[iseg[0].astype('int'), + iseg[1].astype('int')], + epsII[iseg[0].astype('int'), + iseg[1].astype('int')], + epsvor[iseg[0].astype('int'), + iseg[1].astype('int')]])], + axis=0)) + return segsf diff --git a/notebooks/detection_tutorial.ipynb b/notebooks/detection_tutorial.ipynb index 6407854..333f598 100644 --- a/notebooks/detection_tutorial.ipynb +++ b/notebooks/detection_tutorial.ipynb @@ -143,7 +143,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 1, "id": "617a164f-58c9-40c0-9368-653d4bd16b7f", "metadata": {}, "outputs": [], @@ -156,25 +156,25 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 2, "id": "a042483c-95cb-416b-8e8d-b5751d5923ae", "metadata": {}, "outputs": [], "source": [ - "test = process_dataset('/Users/nhutter/Documents/Research/sirex/data/McGill/McGill_runno01_expno07_1997_daily_means.nc')" + "test = process_dataset('/Users/nhutter/Documents/Research/sirex/data/McGill/McGill_runno01_expno07_1997_daily_means.nc',output_path='../data/lkfs/')" ] }, { "cell_type": "code", - "execution_count": 9, - "id": "cdf35d68-be9e-43c7-af81-d5c65817c464", + "execution_count": 3, + "id": "9d2ce375-a27c-4180-9de8-902c51f96dee", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Compute deformation rates and detect features for day 1\n", + "Compute deformation rates and detect features for day 29\n", "Start detection routines\n" ] }, @@ -184,56 +184,34 @@ "text": [ "/Users/nhutter/Documents/Research/lkf_tools/lkf_tools/detection.py:96: RuntimeWarning: invalid value encountered in true_divide\n", " gaussian_field = field_nonnan_f/mask_nan_f\n", - "/Users/nhutter/Documents/Research/lkf_tools/lkf_tools/detection.py:1113: RuntimeWarning: Mean of empty slice\n", + "/Users/nhutter/Documents/Research/lkf_tools/lkf_tools/detection.py:1143: RuntimeWarning: Mean of empty slice\n", " eps_tot = np.nanmean(np.stack(eps_tot),axis=0)\n", "/Users/nhutter/Documents/Research/lkf_tools/lkf_tools/detection.py:243: RuntimeWarning: invalid value encountered in true_divide\n", " dx = (seg_active[:,:,-1]-seg_active[np.arange(seg_active.shape[0]),:,-num_points])/np.stack([num_points-1,num_points-1],axis=1) - (seg_append-seg_active[:,:,-1])\n", "/Users/nhutter/Documents/Research/lkf_tools/lkf_tools/detection.py:561: RuntimeWarning: invalid value encountered in arccos\n", " angle = np.arccos(angle)/np.pi*180\n", + "/Users/nhutter/Documents/Research/lkf_tools/lkf_tools/detection.py:554: RuntimeWarning: invalid value encountered in true_divide\n", + " e1 = (e1/np.sqrt(np.sum(e1**2))) # Normalize basis vector\n", "/Users/nhutter/Documents/Research/lkf_tools/lkf_tools/detection.py:557: RuntimeWarning: invalid value encountered in true_divide\n", " f1 = (f1/np.sqrt(np.sum(f1**2))) # Normalize basis vector\n", - "/Users/nhutter/Documents/Research/lkf_tools/lkf_tools/detection.py:554: RuntimeWarning: invalid value encountered in true_divide\n", - " e1 = (e1/np.sqrt(np.sum(e1**2))) # Normalize basis vector\n" - ] - }, - { - "ename": "ValueError", - "evalue": "all the input arrays must have same number of dimensions, but the array at index 0 has 2 dimension(s) and the array at index 1 has 3 dimension(s)", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", - "Input \u001b[0;32mIn [9]\u001b[0m, in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mtest\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdetect_lkfs\u001b[49m\u001b[43m(\u001b[49m\u001b[43mindexes\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/Documents/Research/lkf_tools/lkf_tools/dataset.py:174\u001b[0m, in \u001b[0;36mprocess_dataset.detect_lkfs\u001b[0;34m(self, indexes, force_redetect)\u001b[0m\n\u001b[1;32m 171\u001b[0m \u001b[38;5;66;03m# Save the detected features\u001b[39;00m\n\u001b[1;32m 173\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mlatlon:\n\u001b[0;32m--> 174\u001b[0m lkf \u001b[38;5;241m=\u001b[39m \u001b[43msegs2latlon_model\u001b[49m\u001b[43m(\u001b[49m\u001b[43mlkf\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 175\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mlon\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;28;43mmax\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m,\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mindex_y\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m]\u001b[49m\u001b[38;5;241;43m-\u001b[39;49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m\u001b[43m:\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mindex_y\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m-\u001b[39;49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m]\u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[38;5;241;43m2\u001b[39;49m\u001b[43m:\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mred_fac\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 176\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mmax\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m,\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mindex_x\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m]\u001b[49m\u001b[38;5;241;43m-\u001b[39;49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m\u001b[43m:\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mindex_x\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m-\u001b[39;49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m]\u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[38;5;241;43m2\u001b[39;49m\u001b[43m:\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mred_fac\u001b[49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 177\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mlat\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;28;43mmax\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m,\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mindex_y\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m]\u001b[49m\u001b[38;5;241;43m-\u001b[39;49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m\u001b[43m:\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mindex_y\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m-\u001b[39;49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m]\u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[38;5;241;43m2\u001b[39;49m\u001b[43m:\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mred_fac\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 178\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mmax\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m,\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mindex_x\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m]\u001b[49m\u001b[38;5;241;43m-\u001b[39;49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m\u001b[43m:\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mindex_x\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m-\u001b[39;49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m]\u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[38;5;241;43m2\u001b[39;49m\u001b[43m:\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mred_fac\u001b[49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 179\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m return_eps:\n\u001b[1;32m 180\u001b[0m lkf \u001b[38;5;241m=\u001b[39m segs2eps(lkf,\n\u001b[1;32m 181\u001b[0m div[\u001b[38;5;28mmax\u001b[39m([\u001b[38;5;241m0\u001b[39m,\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mindex_y[\u001b[38;5;241m0\u001b[39m][\u001b[38;5;241m0\u001b[39m]\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m]):\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mindex_y[\u001b[38;5;241m0\u001b[39m][\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m]\u001b[38;5;241m+\u001b[39m\u001b[38;5;241m2\u001b[39m:\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mred_fac,\n\u001b[1;32m 182\u001b[0m \u001b[38;5;28mmax\u001b[39m([\u001b[38;5;241m0\u001b[39m,\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mindex_x[\u001b[38;5;241m0\u001b[39m][\u001b[38;5;241m0\u001b[39m]\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m]):\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mindex_x[\u001b[38;5;241m0\u001b[39m][\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m]\u001b[38;5;241m+\u001b[39m\u001b[38;5;241m2\u001b[39m:\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mred_fac],\n\u001b[1;32m 183\u001b[0m shr[\u001b[38;5;28mmax\u001b[39m([\u001b[38;5;241m0\u001b[39m,\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mindex_y[\u001b[38;5;241m0\u001b[39m][\u001b[38;5;241m0\u001b[39m]\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m]):\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mindex_y[\u001b[38;5;241m0\u001b[39m][\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m]\u001b[38;5;241m+\u001b[39m\u001b[38;5;241m2\u001b[39m:\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mred_fac,\n\u001b[1;32m 184\u001b[0m \u001b[38;5;28mmax\u001b[39m([\u001b[38;5;241m0\u001b[39m,\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mindex_x[\u001b[38;5;241m0\u001b[39m][\u001b[38;5;241m0\u001b[39m]\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m]):\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mindex_x[\u001b[38;5;241m0\u001b[39m][\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m]\u001b[38;5;241m+\u001b[39m\u001b[38;5;241m2\u001b[39m:\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mred_fac])\n", - "File \u001b[0;32m~/Documents/Research/lkf_tools/lkf_tools/dataset.py:204\u001b[0m, in \u001b[0;36msegs2latlon_model\u001b[0;34m(segs, lon, lat)\u001b[0m\n\u001b[1;32m 202\u001b[0m segsf \u001b[38;5;241m=\u001b[39m []\n\u001b[1;32m 203\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m iseg \u001b[38;5;129;01min\u001b[39;00m segs:\n\u001b[0;32m--> 204\u001b[0m segsf\u001b[38;5;241m.\u001b[39mappend(\u001b[43mnp\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mconcatenate\u001b[49m\u001b[43m(\u001b[49m\u001b[43m[\u001b[49m\u001b[43miseg\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 205\u001b[0m \u001b[43m \u001b[49m\u001b[43mnp\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mstack\u001b[49m\u001b[43m(\u001b[49m\u001b[43m[\u001b[49m\u001b[43mlon\u001b[49m\u001b[43m[\u001b[49m\u001b[43miseg\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43miseg\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 206\u001b[0m \u001b[43m \u001b[49m\u001b[43mlat\u001b[49m\u001b[43m[\u001b[49m\u001b[43miseg\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43miseg\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m]\u001b[49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 207\u001b[0m \u001b[43m \u001b[49m\u001b[43maxis\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m)\u001b[49m)\n\u001b[1;32m 208\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m segsf\n", - "File \u001b[0;32m<__array_function__ internals>:180\u001b[0m, in \u001b[0;36mconcatenate\u001b[0;34m(*args, **kwargs)\u001b[0m\n", - "\u001b[0;31mValueError\u001b[0m: all the input arrays must have same number of dimensions, but the array at index 0 has 2 dimension(s) and the array at index 1 has 3 dimension(s)" + "/Users/nhutter/miniforge3/envs/lkf_tools/lib/python3.10/site-packages/numpy/lib/npyio.py:518: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n", + " arr = np.asanyarray(arr)\n" ] } ], "source": [ - "test.detect_lkfs(indexes=[0])" + "test.detect_lkfs(indexes=[28])" ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 6, "id": "3c986c0a-80a4-428a-b799-2e7b00660ee4", "metadata": {}, "outputs": [ { "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -245,6 +223,8 @@ } ], "source": [ + "#%matplotlib widget\n", + "\n", "import matplotlib.pyplot as plt\n", "import cartopy.crs as ccrs\n", "\n", @@ -258,36 +238,40 @@ " max([0,test.index_x[0][0]-1]):test.index_x[0][-1]+2:test.red_fac],\n", " test.lat[max([0,test.index_y[0][0]-1]):test.index_y[0][-1]+2:test.red_fac,\n", " max([0,test.index_x[0][0]-1]):test.index_x[0][-1]+2:test.red_fac],\n", - " np.sum(test.eps_tot_list,axis=0),transform=ccrs.PlateCarree())" + " np.sum(test.eps_tot_list,axis=0),transform=ccrs.PlateCarree(),vmin=0,vmax=1e-1)\n", + "\n", + "lkfs = np.load(test.lkfpath.joinpath('lkf_McGill_runno01_expno07_1997_daily_means_029.npy'),allow_pickle=True)\n", + "\n", + "for ilkf in lkfs:\n", + " if np.min(ilkf[:,2])<-150 and np.max(ilkf[:,2]>150):\n", + " ilkf[ilkf[:,2]<0,2]+=360\n", + " ax.plot(ilkf[:,2],ilkf[:,3],transform=ccrs.PlateCarree())" ] }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 5, "id": "a5e4599e-bf15-43fd-9fc7-90b2a1da7435", "metadata": {}, "outputs": [ { - "ename": "IndexError", - "evalue": "2-dimensional boolean indexing is not supported. ", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mIndexError\u001b[0m Traceback (most recent call last)", - "Input \u001b[0;32mIn [11]\u001b[0m, in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0m test\u001b[38;5;241m.\u001b[39mlon[test\u001b[38;5;241m.\u001b[39mlon\u001b[38;5;241m>\u001b[39m\u001b[38;5;241m180\u001b[39m] \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m=\u001b[39m \u001b[38;5;241m360\u001b[39m\n", - "File \u001b[0;32m~/miniforge3/envs/lkf_tools/lib/python3.10/site-packages/xarray/core/dataarray.py:741\u001b[0m, in \u001b[0;36mDataArray.__getitem__\u001b[0;34m(self, key)\u001b[0m\n\u001b[1;32m 738\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_getitem_coord(key)\n\u001b[1;32m 739\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 740\u001b[0m \u001b[38;5;66;03m# xarray-style array indexing\u001b[39;00m\n\u001b[0;32m--> 741\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43misel\u001b[49m\u001b[43m(\u001b[49m\u001b[43mindexers\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_item_key_to_dict\u001b[49m\u001b[43m(\u001b[49m\u001b[43mkey\u001b[49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/miniforge3/envs/lkf_tools/lib/python3.10/site-packages/xarray/core/dataarray.py:1197\u001b[0m, in \u001b[0;36mDataArray.isel\u001b[0;34m(self, indexers, drop, missing_dims, **indexers_kwargs)\u001b[0m\n\u001b[1;32m 1194\u001b[0m indexers \u001b[38;5;241m=\u001b[39m either_dict_or_kwargs(indexers, indexers_kwargs, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124misel\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m 1196\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28many\u001b[39m(is_fancy_indexer(idx) \u001b[38;5;28;01mfor\u001b[39;00m idx \u001b[38;5;129;01min\u001b[39;00m indexers\u001b[38;5;241m.\u001b[39mvalues()):\n\u001b[0;32m-> 1197\u001b[0m ds \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_to_temp_dataset\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_isel_fancy\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 1198\u001b[0m \u001b[43m \u001b[49m\u001b[43mindexers\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdrop\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mdrop\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmissing_dims\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmissing_dims\u001b[49m\n\u001b[1;32m 1199\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1200\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_from_temp_dataset(ds)\n\u001b[1;32m 1202\u001b[0m \u001b[38;5;66;03m# Much faster algorithm for when all indexers are ints, slices, one-dimensional\u001b[39;00m\n\u001b[1;32m 1203\u001b[0m \u001b[38;5;66;03m# lists, or zero or one-dimensional np.ndarray's\u001b[39;00m\n", - "File \u001b[0;32m~/miniforge3/envs/lkf_tools/lib/python3.10/site-packages/xarray/core/dataset.py:2416\u001b[0m, in \u001b[0;36mDataset._isel_fancy\u001b[0;34m(self, indexers, drop, missing_dims)\u001b[0m\n\u001b[1;32m 2414\u001b[0m indexes[name] \u001b[38;5;241m=\u001b[39m new_index\n\u001b[1;32m 2415\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m var_indexers:\n\u001b[0;32m-> 2416\u001b[0m new_var \u001b[38;5;241m=\u001b[39m \u001b[43mvar\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43misel\u001b[49m\u001b[43m(\u001b[49m\u001b[43mindexers\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mvar_indexers\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 2417\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 2418\u001b[0m new_var \u001b[38;5;241m=\u001b[39m var\u001b[38;5;241m.\u001b[39mcopy(deep\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mFalse\u001b[39;00m)\n", - "File \u001b[0;32m~/miniforge3/envs/lkf_tools/lib/python3.10/site-packages/xarray/core/variable.py:1186\u001b[0m, in \u001b[0;36mVariable.isel\u001b[0;34m(self, indexers, missing_dims, **indexers_kwargs)\u001b[0m\n\u001b[1;32m 1183\u001b[0m indexers \u001b[38;5;241m=\u001b[39m drop_dims_from_indexers(indexers, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mdims, missing_dims)\n\u001b[1;32m 1185\u001b[0m key \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mtuple\u001b[39m(indexers\u001b[38;5;241m.\u001b[39mget(dim, \u001b[38;5;28mslice\u001b[39m(\u001b[38;5;28;01mNone\u001b[39;00m)) \u001b[38;5;28;01mfor\u001b[39;00m dim \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mdims)\n\u001b[0;32m-> 1186\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m[\u001b[49m\u001b[43mkey\u001b[49m\u001b[43m]\u001b[49m\n", - "File \u001b[0;32m~/miniforge3/envs/lkf_tools/lib/python3.10/site-packages/xarray/core/variable.py:778\u001b[0m, in \u001b[0;36mVariable.__getitem__\u001b[0;34m(self, key)\u001b[0m\n\u001b[1;32m 765\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m__getitem__\u001b[39m(\u001b[38;5;28mself\u001b[39m: T_Variable, key) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m T_Variable:\n\u001b[1;32m 766\u001b[0m \u001b[38;5;124;03m\"\"\"Return a new Variable object whose contents are consistent with\u001b[39;00m\n\u001b[1;32m 767\u001b[0m \u001b[38;5;124;03m getting the provided key from the underlying data.\u001b[39;00m\n\u001b[1;32m 768\u001b[0m \n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 776\u001b[0m \u001b[38;5;124;03m array `x.values` directly.\u001b[39;00m\n\u001b[1;32m 777\u001b[0m \u001b[38;5;124;03m \"\"\"\u001b[39;00m\n\u001b[0;32m--> 778\u001b[0m dims, indexer, new_order \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_broadcast_indexes\u001b[49m\u001b[43m(\u001b[49m\u001b[43mkey\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 779\u001b[0m data \u001b[38;5;241m=\u001b[39m as_indexable(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_data)[indexer]\n\u001b[1;32m 780\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m new_order:\n", - "File \u001b[0;32m~/miniforge3/envs/lkf_tools/lib/python3.10/site-packages/xarray/core/variable.py:621\u001b[0m, in \u001b[0;36mVariable._broadcast_indexes\u001b[0;34m(self, key)\u001b[0m\n\u001b[1;32m 618\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mall\u001b[39m(\u001b[38;5;28misinstance\u001b[39m(k, BASIC_INDEXING_TYPES) \u001b[38;5;28;01mfor\u001b[39;00m k \u001b[38;5;129;01min\u001b[39;00m key):\n\u001b[1;32m 619\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_broadcast_indexes_basic(key)\n\u001b[0;32m--> 621\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_validate_indexers\u001b[49m\u001b[43m(\u001b[49m\u001b[43mkey\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 622\u001b[0m \u001b[38;5;66;03m# Detect it can be mapped as an outer indexer\u001b[39;00m\n\u001b[1;32m 623\u001b[0m \u001b[38;5;66;03m# If all key is unlabeled, or\u001b[39;00m\n\u001b[1;32m 624\u001b[0m \u001b[38;5;66;03m# key can be mapped as an OuterIndexer.\u001b[39;00m\n\u001b[1;32m 625\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mall\u001b[39m(\u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(k, Variable) \u001b[38;5;28;01mfor\u001b[39;00m k \u001b[38;5;129;01min\u001b[39;00m key):\n", - "File \u001b[0;32m~/miniforge3/envs/lkf_tools/lib/python3.10/site-packages/xarray/core/variable.py:667\u001b[0m, in \u001b[0;36mVariable._validate_indexers\u001b[0;34m(self, key)\u001b[0m\n\u001b[1;32m 662\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mIndexError\u001b[39;00m(\n\u001b[1;32m 663\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mBoolean array size \u001b[39m\u001b[38;5;132;01m{:d}\u001b[39;00m\u001b[38;5;124m is used to index array \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 664\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mwith shape \u001b[39m\u001b[38;5;132;01m{:s}\u001b[39;00m\u001b[38;5;124m.\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;241m.\u001b[39mformat(\u001b[38;5;28mlen\u001b[39m(k), \u001b[38;5;28mstr\u001b[39m(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mshape))\n\u001b[1;32m 665\u001b[0m )\n\u001b[1;32m 666\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m k\u001b[38;5;241m.\u001b[39mndim \u001b[38;5;241m>\u001b[39m \u001b[38;5;241m1\u001b[39m:\n\u001b[0;32m--> 667\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mIndexError\u001b[39;00m(\n\u001b[1;32m 668\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;132;01m{}\u001b[39;00m\u001b[38;5;124m-dimensional boolean indexing is \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 669\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mnot supported. \u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;241m.\u001b[39mformat(k\u001b[38;5;241m.\u001b[39mndim)\n\u001b[1;32m 670\u001b[0m )\n\u001b[1;32m 671\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mgetattr\u001b[39m(k, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mdims\u001b[39m\u001b[38;5;124m\"\u001b[39m, (dim,)) \u001b[38;5;241m!=\u001b[39m (dim,):\n\u001b[1;32m 672\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mIndexError\u001b[39;00m(\n\u001b[1;32m 673\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mBoolean indexer should be unlabeled or on the \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 674\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124msame dimension to the indexed array. Indexer is \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 677\u001b[0m )\n\u001b[1;32m 678\u001b[0m )\n", - "\u001b[0;31mIndexError\u001b[0m: 2-dimensional boolean indexing is not supported. " - ] + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" } ], "source": [ - "test.lon[test.lon>180] -= 360" + "fig,ax = plt.subplots(1,1)\n", + "\n", + "for ilkf in lkfs:\n", + " ax.plot(ilkf[:,2],ilkf[:,3])" ] }, { From acb8d1ff8e4a0deeebdb1490e02be5185d1fd916 Mon Sep 17 00:00:00 2001 From: Nils Hutter Date: Tue, 15 Mar 2022 11:29:41 -0700 Subject: [PATCH 06/21] netcdf tracking works --- lkf_tools/dataset.py | 77 +++- lkf_tools/tracking.py | 120 +++++++ notebooks/detection_tutorial.ipynb | 558 +++-------------------------- 3 files changed, 237 insertions(+), 518 deletions(-) diff --git a/lkf_tools/dataset.py b/lkf_tools/dataset.py index c0ce347..7a08055 100644 --- a/lkf_tools/dataset.py +++ b/lkf_tools/dataset.py @@ -195,9 +195,76 @@ def detect_lkfs(self,indexes=None,force_redetect=False): + def track_lkfs(self,indexes=None, force_recompute=False): + """Function that generates tracking data set + :param indexes: time indexes that should be tracked. If None all time steps are tracked. + """ + + # Set output path + self.track_output_path = self.lkfpath.joinpath('tracked_pairs') + if not os.path.exists(self.track_output_path): + os.mkdir(self.track_output_path) + + self.nx,self.ny = self.mask[max([0,self.index_y[0][0]-1]):self.index_y[0][-1]+2:self.red_fac, + max([0,self.index_x[0][0]-1]):self.index_x[0][-1]+2:self.red_fac].shape + + self.lkf_filelist = [i for i in os.listdir(self.lkfpath) if i.startswith('lkf') and i.endswith('.npy')] + self.lkf_filelist.sort() + + # Determine which files have been already tracked + if force_recompute: + self.tracked_lkfs = [] + else: + self.tracked_lkfs = [int(i.split('.')[0].split('_')[-1])-1 for i in os.listdir(self.track_output_path) if i.startswith('lkf') and i.endswith('.npy')] + self.tracked_lkfs.sort() + + if indexes is None: + self.indexes = np.arange(self.time.size/self.t_red-1) + else: + self.indexes = indexes + + # Determine advection time step + self.dt = float(self.time.diff(dim='time')[0]/1e9) + self.adv_time = float(self.time.diff(dim='time')[0]/1e9)*self.t_red + + # Do the tracking + for ilkf in [int(j) for j in self.indexes if j+1 not in self.tracked_lkfs]: + print("Track features in %s to %s" %(self.lkf_filelist[ilkf], + self.lkf_filelist[ilkf+1])) - - - - - + # Open lkf0 and compute drift estimate + lkf0_d = drift_estimate(self.lkfpath.joinpath(self.lkf_filelist[ilkf]),self.data, + self.mask,self.index_x,self.index_y,self.red_fac, + self.dxu,self.dyu,adv_time=self.adv_time,t=self.dt,dt=self.dt) + + # Filter zero length LKFs due to NaN drift + ind_f = np.where(np.array([iseg.size for iseg in lkf0_d])>0)[0] + lkf0_df = [iseg for iseg in lkf0_d if iseg.size>0] + + # Read LKFs + lkf1 = np.load(self.lkfpath.joinpath(self.lkf_filelist[ilkf+1]),allow_pickle=True) + # lkf1_l = [] + # for ilkf,iseg in enumerate(lkf1): + # lkf1_l.append(iseg[:,:2]) + lkf1_l = lkf1 + if len(lkf1_l)==1: + #lkf1_l = np.array([lkf1.squeeze()],dtype='object') + lkf1_l = [lkf1.squeeze()] + for ilkf1,iseg in enumerate(lkf1): + lkf1_l[ilkf1] = iseg[:,:2] + + # Compute tracking + tracked_pairs = track_lkf(lkf0_df, lkf1_l, self.nx, self.ny, + thres_frac=0.75, min_overlap=4, + overlap_thres=1.5,angle_thres=25) + + if len(tracked_pairs)==0: + tracked_pairs = np.array([[],[]]) + else: + tracked_pairs = np.stack(tracked_pairs) + tracked_pairs[:,0] = ind_f[np.stack(tracked_pairs)[:,0]] + + # Save tracked pairs + np.save(self.track_output_path.joinpath('lkf_tracked_pairs_%s_to_%s' %(self.lkf_filelist[ilkf][4:-4], + self.lkf_filelist[ilkf+1][4:-4])), + tracked_pairs) \ No newline at end of file diff --git a/lkf_tools/tracking.py b/lkf_tools/tracking.py index 3e4001f..ffff3ff 100644 --- a/lkf_tools/tracking.py +++ b/lkf_tools/tracking.py @@ -263,6 +263,66 @@ def drift_estimate_rgps(lkf0_path,drift_path,read_lkf0=None): return lkf0_d +def drift_estimate(lkf0_path,ncfile,mask,index_x,index_y,red_fac, + dxu,dyu,read_lkf0=None,adv_time=3.*24.*3600., + t=1.*24.*3600.,dt = 1.*24.*3600.): + """Function that computes the position of LKFs after a certain time + considering the drift + + Input: lkf0_path - filename of lkf0 including path + drift_path - directory where drift data is stored including prefix + + Output: lkf0_d - drifted LKFs from lkf0""" + + # Read in lkf0 + if read_lkf0 is None: + lkf0 = np.load(lkf0_path,allow_pickle=True) + else: + lkf0 = read_lkf0 + + if len(lkf0)==1: + lkf0 = [lkf0.squeeze()] + lkf0_d = [lkf0[0]] + else: + lkf0_d = lkf0.copy() + + # Loop over days + t_tot = adv_time + t = 1.*24.*3600. + dt = 1.*24.*3600. + it0 = int(str(lkf0_path).split('/')[-1].split('.')[0].split("_")[-1]) + + #lkf0_d = lkf0.copy() + + for i in range(int(t_tot/t)): + it = int(it0 + i*t/dt) + # Read in drift data + drift = np.stack([np.array(ncfile.U[it,1:-1,1:-1]), + np.array(ncfile.V[it,1:-1,1:-1])]) + + # Mask + drift[:,~mask[1:-1,1:-1]] = np.nan + drift = drift[:,max([0,index_y[0][0]-1]):index_y[0][-1]+2:red_fac, + max([0,index_x[0][0]-1]):index_x[0][-1]+2:red_fac] + drift = np.rollaxis(drift,0,3) + + res = np.stack([dxu,dyu])[:,max([0,index_y[0][0]-1]):index_y[0][-1]+2:red_fac, + max([0,index_x[0][0]-1]):index_x[0][-1]+2:red_fac] + res = np.rollaxis(res,0,3) + + # Compute drift estimate + for ilkf,iseg in enumerate(lkf0): + iseg_d = (drift[iseg[:,0].astype('int'),iseg[:,1].astype('int'),:]/ + res[iseg[:,0].astype('int'),iseg[:,1].astype('int'),:])/float(red_fac)*t + lkf0_d[ilkf][:,:2] + mask_d = np.all(np.stack([np.all(np.isfinite(iseg_d),axis=1), + np.all(iseg_d>=1,axis=1), + (iseg_d[:,0]0)[0] + lkf0_df = [iseg for iseg in lkf0_d if iseg.size>0] + + # Read LKFs + lkf1 = np.load(lkf_path + lkf_filelist[ilkf+1]) + # lkf1_l = [] + # for ilkf,iseg in enumerate(lkf1): + # lkf1_l.append(iseg[:,:2]) + lkf1_l = lkf1 + if len(lkf1_l)==1: + #lkf1_l = np.array([lkf1.squeeze()],dtype='object') + lkf1_l = [lkf1.squeeze()] + for ilkf1,iseg in enumerate(lkf1): + lkf1_l[ilkf1] = iseg[:,:2] + + # Compute tracking + tracked_pairs = track_lkf(lkf0_df, lkf1_l, nx, ny, thres_frac=0.75, min_overlap=4,overlap_thres=1.5,angle_thres=25) + + if len(tracked_pairs)==0: + tracked_pairs = np.array([[],[]]) + else: + tracked_pairs = np.stack(tracked_pairs) + tracked_pairs[:,0] = ind_f[np.stack(tracked_pairs)[:,0]] + + # Save tracked pairs + np.save(output_path + 'lkf_tracked_pairs_%s_to_%s' %(lkf_filelist[ilkf][4:-4], + lkf_filelist[ilkf+1][4:-4]), + tracked_pairs) diff --git a/notebooks/detection_tutorial.ipynb b/notebooks/detection_tutorial.ipynb index 333f598..79e8eac 100644 --- a/notebooks/detection_tutorial.ipynb +++ b/notebooks/detection_tutorial.ipynb @@ -205,7 +205,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 4, "id": "3c986c0a-80a4-428a-b799-2e7b00660ee4", "metadata": {}, "outputs": [ @@ -250,545 +250,77 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 12, "id": "a5e4599e-bf15-43fd-9fc7-90b2a1da7435", "metadata": {}, "outputs": [ { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" + "name": "stdout", + "output_type": "stream", + "text": [ + "Track features in lkf_McGill_runno01_expno07_1997_daily_means_001.npy to lkf_McGill_runno01_expno07_1997_daily_means_002.npy\n" + ] } ], "source": [ - "fig,ax = plt.subplots(1,1)\n", - "\n", - "for ilkf in lkfs:\n", - " ax.plot(ilkf[:,2],ilkf[:,3])" + "test.track_lkfs(indexes=[0])" ] }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 23, "id": "1f7d626c-5c32-498d-8660-fd39877ae5cc", "metadata": {}, "outputs": [ { "data": { - "text/html": [ - "
\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "
<xarray.DataArray 'ULON' (y: 438, x: 518)>\n",
-       "array([[-105.96823  , -105.85332  , -105.737885 , ...,   -8.047913 ,\n",
-       "          -7.94223  ,   -7.837036 ],\n",
-       "       [-106.09569  , -105.980835 , -105.86545  , ...,   -7.921692 ,\n",
-       "          -7.816101 ,   -7.7109985],\n",
-       "       [-106.22366  , -106.10886  , -105.99353  , ...,   -7.794983 ,\n",
-       "          -7.689514 ,   -7.5844727],\n",
-       "       ...,\n",
-       "       [ 171.66559  ,  171.55157  ,  171.43701  , ...,   70.37024  ,\n",
-       "          70.26585  ,   70.16194  ],\n",
-       "       [ 171.53189  ,  171.41777  ,  171.30313  , ...,   70.50215  ,\n",
-       "          70.397644 ,   70.293625 ],\n",
-       "       [ 171.39871  ,  171.28452  ,  171.16978  , ...,   70.63358  ,\n",
-       "          70.52897  ,   70.42483  ]], dtype=float32)\n",
-       "Coordinates:\n",
-       "    VLON     (y, x) float32 253.9 254.0 254.1 254.3 ... 70.86 70.75 70.65 70.54\n",
-       "    VLAT     (y, x) float32 60.57 60.63 60.69 60.76 ... 60.09 60.02 59.96 59.89\n",
-       "    ULON     (y, x) float32 254.0 254.1 254.3 254.4 ... 70.74 70.63 70.53 70.42\n",
-       "    ULAT     (y, x) float32 60.57 60.63 60.7 60.76 ... 60.08 60.02 59.95 59.89\n",
-       "    TLON     (y, x) float32 254.0 254.1 254.2 254.3 ... 70.79 70.69 70.58 70.48\n",
-       "    TLAT     (y, x) float32 60.54 60.6 60.67 60.73 ... 60.12 60.05 59.98 59.92\n",
-       "Dimensions without coordinates: y, x\n",
-       "Attributes:\n",
-       "    standard_name:        longitude\n",
-       "    long_name:            longitude at U points\n",
-       "    units:                degrees_east\n",
-       "    _CoordinateAxisType:  Lon
" - ], + "image/png": "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\n", "text/plain": [ - "\n", - "array([[-105.96823 , -105.85332 , -105.737885 , ..., -8.047913 ,\n", - " -7.94223 , -7.837036 ],\n", - " [-106.09569 , -105.980835 , -105.86545 , ..., -7.921692 ,\n", - " -7.816101 , -7.7109985],\n", - " [-106.22366 , -106.10886 , -105.99353 , ..., -7.794983 ,\n", - " -7.689514 , -7.5844727],\n", - " ...,\n", - " [ 171.66559 , 171.55157 , 171.43701 , ..., 70.37024 ,\n", - " 70.26585 , 70.16194 ],\n", - " [ 171.53189 , 171.41777 , 171.30313 , ..., 70.50215 ,\n", - " 70.397644 , 70.293625 ],\n", - " [ 171.39871 , 171.28452 , 171.16978 , ..., 70.63358 ,\n", - " 70.52897 , 70.42483 ]], dtype=float32)\n", - "Coordinates:\n", - " VLON (y, x) float32 253.9 254.0 254.1 254.3 ... 70.86 70.75 70.65 70.54\n", - " VLAT (y, x) float32 60.57 60.63 60.69 60.76 ... 60.09 60.02 59.96 59.89\n", - " ULON (y, x) float32 254.0 254.1 254.3 254.4 ... 70.74 70.63 70.53 70.42\n", - " ULAT (y, x) float32 60.57 60.63 60.7 60.76 ... 60.08 60.02 59.95 59.89\n", - " TLON (y, x) float32 254.0 254.1 254.2 254.3 ... 70.79 70.69 70.58 70.48\n", - " TLAT (y, x) float32 60.54 60.6 60.67 60.73 ... 60.12 60.05 59.98 59.92\n", - "Dimensions without coordinates: y, x\n", - "Attributes:\n", - " standard_name: longitude\n", - " long_name: longitude at U points\n", - " units: degrees_east\n", - " _CoordinateAxisType: Lon" + "
" ] }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" } ], "source": [ - "test.lon.where(test.lon<180,other=test.lon-360)" + "import matplotlib.pyplot as plt\n", + "import cartopy.crs as ccrs\n", + "\n", + "fig = plt.figure(figsize=[10, 5])\n", + "\n", + "ax = plt.subplot(1, 1, 1, projection=ccrs.Orthographic(0, 90))\n", + "\n", + "ax.coastlines(zorder=3)\n", + "\n", + "it = 1\n", + "\n", + "lkfs0 = np.load(test.lkfpath.joinpath('lkf_McGill_runno01_expno07_1997_daily_means_%03i.npy' %it),allow_pickle=True)\n", + "lkfs1 = np.load(test.lkfpath.joinpath('lkf_McGill_runno01_expno07_1997_daily_means_%03i.npy' %(it+1)),allow_pickle=True)\n", + "\n", + "tracks = np.load(test.track_output_path.joinpath('lkf_tracked_pairs_McGill_runno01_expno07_1997_daily_means_%03i_to_McGill_runno01_expno07_1997_daily_means_%03i.npy' %(it,it+1)),allow_pickle=True)\n", + "\n", + "for ilkf in lkfs0:\n", + " if np.min(ilkf[:,2])<-150 and np.max(ilkf[:,2]>150):\n", + " ilkf[ilkf[:,2]<0,2]+=360\n", + " ax.plot(ilkf[:,2],ilkf[:,3],'0.5',transform=ccrs.PlateCarree())\n", + " \n", + "for ilkf in lkfs1:\n", + " if np.min(ilkf[:,2])<-150 and np.max(ilkf[:,2]>150):\n", + " ilkf[ilkf[:,2]<0,2]+=360\n", + " ax.plot(ilkf[:,2],ilkf[:,3],'0.75',transform=ccrs.PlateCarree())\n", + "\n", + "for itrack in tracks:\n", + " ax.plot(lkfs0[itrack[0]][:,2],lkfs0[itrack[0]][:,3],'r--',alpha=0.25,transform=ccrs.PlateCarree())\n", + " ax.plot(lkfs1[itrack[1]][:,2],lkfs1[itrack[1]][:,3],'b--',alpha=0.25,transform=ccrs.PlateCarree())" ] }, { "cell_type": "code", "execution_count": null, - "id": "3bfdcd57-90bc-4e63-8e7f-6201c4515c38", + "id": "257484b7-e86c-4237-8e3d-d531d2f740b6", "metadata": {}, "outputs": [], "source": [] From 2c0a58b2e678bf6932f89de2dae2707eb53b925e Mon Sep 17 00:00:00 2001 From: Nils Hutter Date: Tue, 15 Mar 2022 12:32:56 -0700 Subject: [PATCH 07/21] Added tutorial to produce SIREx lkf data set --- notebooks/tutorial_gen_dataset.ipynb | 373 +++++++++++++++++++++++++++ 1 file changed, 373 insertions(+) create mode 100644 notebooks/tutorial_gen_dataset.ipynb diff --git a/notebooks/tutorial_gen_dataset.ipynb b/notebooks/tutorial_gen_dataset.ipynb new file mode 100644 index 0000000..e3555aa --- /dev/null +++ b/notebooks/tutorial_gen_dataset.ipynb @@ -0,0 +1,373 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "d7e50086-ca38-42d6-8c09-889f936cc8ab", + "metadata": { + "tags": [] + }, + "source": [ + "# Detect and track LKFs in netcdf model output\n", + "\n", + "This tutorial shows how to generate a LKF data-set based on gridded sea ice model output in netcdf format. It follows the methodolgy of the Sea Ice Rheology Experiment and details can be found in the [preprint](https://www.essoar.org/doi/10.1002/essoar.10507396.1). \n", + "\n", + "The netcdf file needs to follow the SIREx naming conventions that are described in detail in the [SIREx model output repository](https://doi.org/10.5281/zenodo.5555329). The required fields are:\n", + "1. dimensions:\n", + " - time dimension named `time`\n", + " - x dimension\n", + " - y dimension\n", + "2. variables:\n", + " - longitude named `lon` (x,y)\n", + " - latitude named `lat` (x,y)\n", + " - sea-ice velocity in x-direction named `U` (time,x,y)\n", + " - sea-ice velocity in y-direction named `V` (time,x,y)\n", + " - sea-ice concentration named `A` (time,x,y)\n", + " \n", + "### Load `lkf_tools` package" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "f00f91bc-66b9-45a6-acd5-30de3f7b9b0b", + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2\n", + "\n", + "import xarray as xr\n", + "from pathlib import Path\n", + "from lkf_tools.dataset import *" + ] + }, + { + "cell_type": "markdown", + "id": "a2765c52-cb4a-4432-ac8e-9f534a6af225", + "metadata": {}, + "source": [ + "### Open netcdf file\n", + "\n", + "We open the netcdf file with xarray. As an example we use here a simulation with the McGill model that is downloaded from the [SIREx model repository](https://zenodo.org/record/5555329/files/McGill_e2_1997_daily_means.zip?download=1) to the `../data/McGill/` directory. The zip-file is 170 MB large and the extracted netcdf 340 MB, so this might a few seconds." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "ad3e51c0-b44d-4e45-9041-efc9a0b8472f", + "metadata": {}, + "outputs": [], + "source": [ + "from urllib.request import urlopen\n", + "from io import BytesIO\n", + "from zipfile import ZipFile\n", + "\n", + "datadir = Path('../data/McGill')\n", + "if not datadir.is_dir(): os.mkdir(datadir)\n", + "\n", + "url = 'https://zenodo.org/record/5555329/files/McGill_e2_1997_daily_means.zip?download=1'\n", + "http_response = urlopen(url)\n", + "zipfile = ZipFile(BytesIO(http_response.read()))\n", + "zipfile.extractall(path=datadir)" + ] + }, + { + "cell_type": "markdown", + "id": "2a15406b-0afd-4a06-a95d-e74c92422a62", + "metadata": {}, + "source": [ + "### Open a new processing object\n", + "This step initiates a lkf processing object that reads in the netcdf files and sets everything up to run the detection and processing steps." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "a042483c-95cb-416b-8e8d-b5751d5923ae", + "metadata": {}, + "outputs": [], + "source": [ + "lkf_data = process_dataset('../data/McGill/McGill_e2_1997_daily_means.nc',\n", + " output_path='../data/lkfs/')" + ] + }, + { + "cell_type": "markdown", + "id": "2a1c7259-fb26-4ef1-9273-fa0050240b45", + "metadata": {}, + "source": [ + "### Detection of LKFs\n", + "After initialising the lkf processing object, we run the detection step. If `indexes` is defined only those specific time steps will be detected. Here we just detect the first two days for demonstration purposes.\n", + "\n", + "*Note: the algorithms currently outputs a number of warnings, that can be ignored mostly. It is an open issue to remove those warnings.*" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "9d2ce375-a27c-4180-9de8-902c51f96dee", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Compute deformation rates and detect features for day 1\n", + "Start detection routines\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/nhutter/Documents/Research/lkf_tools/lkf_tools/detection.py:96: RuntimeWarning: invalid value encountered in true_divide\n", + " gaussian_field = field_nonnan_f/mask_nan_f\n", + "/Users/nhutter/Documents/Research/lkf_tools/lkf_tools/detection.py:1143: RuntimeWarning: Mean of empty slice\n", + " eps_tot = np.nanmean(np.stack(eps_tot),axis=0)\n", + "/Users/nhutter/Documents/Research/lkf_tools/lkf_tools/detection.py:243: RuntimeWarning: invalid value encountered in true_divide\n", + " dx = (seg_active[:,:,-1]-seg_active[np.arange(seg_active.shape[0]),:,-num_points])/np.stack([num_points-1,num_points-1],axis=1) - (seg_append-seg_active[:,:,-1])\n", + "/Users/nhutter/Documents/Research/lkf_tools/lkf_tools/detection.py:561: RuntimeWarning: invalid value encountered in arccos\n", + " angle = np.arccos(angle)/np.pi*180\n", + "/Users/nhutter/Documents/Research/lkf_tools/lkf_tools/detection.py:557: RuntimeWarning: invalid value encountered in true_divide\n", + " f1 = (f1/np.sqrt(np.sum(f1**2))) # Normalize basis vector\n", + "/Users/nhutter/Documents/Research/lkf_tools/lkf_tools/detection.py:554: RuntimeWarning: invalid value encountered in true_divide\n", + " e1 = (e1/np.sqrt(np.sum(e1**2))) # Normalize basis vector\n", + "/Users/nhutter/miniforge3/envs/lkf_tools/lib/python3.10/site-packages/numpy/lib/npyio.py:518: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n", + " arr = np.asanyarray(arr)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Compute deformation rates and detect features for day 2\n", + "Start detection routines\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/nhutter/Documents/Research/lkf_tools/lkf_tools/detection.py:96: RuntimeWarning: invalid value encountered in true_divide\n", + " gaussian_field = field_nonnan_f/mask_nan_f\n", + "/Users/nhutter/Documents/Research/lkf_tools/lkf_tools/detection.py:1143: RuntimeWarning: Mean of empty slice\n", + " eps_tot = np.nanmean(np.stack(eps_tot),axis=0)\n", + "/Users/nhutter/Documents/Research/lkf_tools/lkf_tools/detection.py:243: RuntimeWarning: invalid value encountered in true_divide\n", + " dx = (seg_active[:,:,-1]-seg_active[np.arange(seg_active.shape[0]),:,-num_points])/np.stack([num_points-1,num_points-1],axis=1) - (seg_append-seg_active[:,:,-1])\n", + "/Users/nhutter/Documents/Research/lkf_tools/lkf_tools/detection.py:561: RuntimeWarning: invalid value encountered in arccos\n", + " angle = np.arccos(angle)/np.pi*180\n", + "/Users/nhutter/Documents/Research/lkf_tools/lkf_tools/detection.py:554: RuntimeWarning: invalid value encountered in true_divide\n", + " e1 = (e1/np.sqrt(np.sum(e1**2))) # Normalize basis vector\n", + "/Users/nhutter/Documents/Research/lkf_tools/lkf_tools/detection.py:557: RuntimeWarning: invalid value encountered in true_divide\n", + " f1 = (f1/np.sqrt(np.sum(f1**2))) # Normalize basis vector\n", + "/Users/nhutter/miniforge3/envs/lkf_tools/lib/python3.10/site-packages/numpy/lib/npyio.py:518: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n", + " arr = np.asanyarray(arr)\n" + ] + } + ], + "source": [ + "lkf_data.detect_lkfs(indexes=[0,1])" + ] + }, + { + "cell_type": "markdown", + "id": "05269991-ec5b-4af5-9069-419a932389c1", + "metadata": {}, + "source": [ + "Now we can have a short look at the outcome of the detection. We will plot the LKFs detected in the last time step over the deformation rates." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "3c986c0a-80a4-428a-b799-2e7b00660ee4", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "import cartopy.crs as ccrs\n", + "\n", + "fig = plt.figure(figsize=[10, 5])\n", + "\n", + "ax = plt.subplot(1, 1, 1, projection=ccrs.Orthographic(0, 90))\n", + "\n", + "ax.coastlines(zorder=3)\n", + "\n", + "pcm = ax.pcolormesh(lkf_data.lon[max([0,lkf_data.index_y[0][0]-1]):lkf_data.index_y[0][-1]+2:lkf_data.red_fac,\n", + " max([0,lkf_data.index_x[0][0]-1]):lkf_data.index_x[0][-1]+2:lkf_data.red_fac],\n", + " lkf_data.lat[max([0,lkf_data.index_y[0][0]-1]):lkf_data.index_y[0][-1]+2:lkf_data.red_fac,\n", + " max([0,lkf_data.index_x[0][0]-1]):lkf_data.index_x[0][-1]+2:lkf_data.red_fac],\n", + " np.sum(lkf_data.eps_tot_list,axis=0),transform=ccrs.PlateCarree(),vmin=0,vmax=1e-1)\n", + "\n", + "it = lkf_data.indexes[-1]\n", + "\n", + "#lkfs = np.load(lkf_data.lkfpath.joinpath('lkf_McGill_runno01_expno07_1997_daily_means_029.npy'),allow_pickle=True)\n", + "lkfs = np.load(lkf_data.lkfpath.joinpath('lkf_%s_%03i.npy' %(lkf_data.netcdf_file.split('/')[-1].split('.')[0],(it+1))),allow_pickle=True)\n", + "\n", + "for ilkf in lkfs:\n", + " if np.min(ilkf[:,2])<-150 and np.max(ilkf[:,2]>150):\n", + " ilkf[ilkf[:,2]<0,2]+=360\n", + " ax.plot(ilkf[:,2],ilkf[:,3],transform=ccrs.PlateCarree())\n", + "\n", + "plt.colorbar(pcm,label='total deformation')" + ] + }, + { + "cell_type": "markdown", + "id": "46818dcd-437d-433d-b00e-3961501ba118", + "metadata": {}, + "source": [ + "### Track LKFs\n", + "\n", + "After detecting LKFs, we can track LKFs using the drift fields to advect features. Since we only detected two time steps, we can just track the first pair, which we define with `indexes` again." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "a5e4599e-bf15-43fd-9fc7-90b2a1da7435", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Track features in lkf_McGill_e2_1997_daily_means_001.npy to lkf_McGill_e2_1997_daily_means_002.npy\n" + ] + } + ], + "source": [ + "lkf_data.track_lkfs(indexes=[0])" + ] + }, + { + "cell_type": "markdown", + "id": "3f6d6551-50aa-45ef-abb0-c512450e7788", + "metadata": {}, + "source": [ + "After tracking the features, we will plot the tracked results to see if it worked appropriately." + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "1f7d626c-5c32-498d-8660-fd39877ae5cc", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "import cartopy.crs as ccrs\n", + "\n", + "fig = plt.figure(figsize=[10, 5])\n", + "\n", + "ax = plt.subplot(1, 1, 1, projection=ccrs.Orthographic(0, 90))\n", + "\n", + "ax.coastlines(zorder=3)\n", + "\n", + "it = 0\n", + "\n", + "lkfs0 = np.load(lkf_data.lkfpath.joinpath('lkf_%s_%03i.npy' %(lkf_data.netcdf_file.split('/')[-1].split('.')[0],(it+1))),allow_pickle=True)\n", + "lkfs1 = np.load(lkf_data.lkfpath.joinpath('lkf_%s_%03i.npy' %(lkf_data.netcdf_file.split('/')[-1].split('.')[0],(it+2))),allow_pickle=True)\n", + "\n", + "tracks = np.load(lkf_data.track_output_path.joinpath('lkf_tracked_pairs_%s_to_%s.npy' %(lkf_data.lkf_filelist[it][4:-4],\n", + " lkf_data.lkf_filelist[it+1][4:-4])),allow_pickle=True)\n", + "\n", + "for ilkf in lkfs0:\n", + " if np.min(ilkf[:,2])<-150 and np.max(ilkf[:,2]>150):\n", + " ilkf[ilkf[:,2]<0,2]+=360\n", + " ax.plot(ilkf[:,2],ilkf[:,3],'0.5',transform=ccrs.PlateCarree())\n", + " \n", + "for ilkf in lkfs1:\n", + " if np.min(ilkf[:,2])<-150 and np.max(ilkf[:,2]>150):\n", + " ilkf[ilkf[:,2]<0,2]+=360\n", + " ax.plot(ilkf[:,2],ilkf[:,3],'0.75',transform=ccrs.PlateCarree())\n", + "\n", + "for itrack in tracks:\n", + " ax.plot(lkfs0[itrack[0]][:,2],lkfs0[itrack[0]][:,3],'r:',alpha=0.25,transform=ccrs.PlateCarree())\n", + " ax.plot(lkfs1[itrack[1]][:,2],lkfs1[itrack[1]][:,3],'b:',alpha=0.25,transform=ccrs.PlateCarree())\n", + " \n", + "ax.plot([0,0],[0,0],'0.5',label='LKFs day 0')\n", + "ax.plot([0,0],[0,0],'0.75',label='LKFs day 1')\n", + "ax.plot([0,0],[0,0],'r:',label='tracked LKFs day 0')\n", + "ax.plot([0,0],[0,0],'b:',label='tracked LKFs day 1')\n", + "\n", + "ax.legend()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "257484b7-e86c-4237-8e3d-d531d2f740b6", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.10.2" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 0aba50de6031ad036e51ed21215cb322cad80907 Mon Sep 17 00:00:00 2001 From: Nils Hutter Date: Tue, 15 Mar 2022 15:05:02 -0700 Subject: [PATCH 08/21] modified readme --- README.md | 29 +++++++++++++--------------- notebooks/tutorial_gen_dataset.ipynb | 14 +++++++------- 2 files changed, 20 insertions(+), 23 deletions(-) diff --git a/README.md b/README.md index 8f4d131..01b9004 100644 --- a/README.md +++ b/README.md @@ -2,30 +2,27 @@ Tools to detect and track deformation features (leads and pressure ridges) in sea-ice deformation data. ## Getting Started +Download/clone this repository. ### Installing python -A good description how to install python is given by N. Koldunov in: -https://github.com/koldunovn/python_for_geosciences +First you need to install conda to install the python environment needed for this package. This can easily be done using a [miniforge](https://github.com/conda-forge/miniforge). -After installing a miniconda you need to install to additional packages with: +After installing conda with a miniforge you can install the python environment using: ``` -conda install scipy.ndimage skimage +conda env create -f environment.yml +``` +and activate the environment: +``` +conda activate lkf_tools ``` - -### Download RGPS example data - -RGPS data in Lagrangian and Eulerian format need to be downloaded from Ron Kwok's homepage: -https://rkwok.jpl.nasa.gov/radarsat/index.html - -RGPS data needs to be unzip. The data needs to be orgnaized in a seperate directory for each winter that are named w9798, w9899, ... - ## Generate LKF data-set -Use gen_dataset.py to generate LKF data-sets, which performs three steps for each year: -* run the LKF detection on RGPS deformation data -* interpolate Lagrangian drift data to Eulerian grid -* run the LKF tracking algorithm +There is a [tutorial notebook](notebooks/tutorial_gen_dataset.ipynb) that illustrates how to generate a LKF data-set from a netcdf file. This tutorial uses model output from the [SIREx model output repository](https://doi.org/10.5281/zenodo.5555329) and also uses the SIREx sampling strategies that are described in detail in this [preprint](https://www.essoar.org/doi/10.1002/essoar.10507396.1). The tutorial shows you how to: +* download and read in the netcdf file +* detect LKFs in the netcdf file +* run the tracking algorithm on the detected LKFs +* some basic plotting routines of the extracted LKFs ## Algorithm description diff --git a/notebooks/tutorial_gen_dataset.ipynb b/notebooks/tutorial_gen_dataset.ipynb index e3555aa..930d7c6 100644 --- a/notebooks/tutorial_gen_dataset.ipynb +++ b/notebooks/tutorial_gen_dataset.ipynb @@ -82,13 +82,13 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 24, "id": "a042483c-95cb-416b-8e8d-b5751d5923ae", "metadata": {}, "outputs": [], "source": [ "lkf_data = process_dataset('../data/McGill/McGill_e2_1997_daily_means.nc',\n", - " output_path='../data/lkfs/')" + " output_path='../data/lkfs/McGill/')" ] }, { @@ -104,7 +104,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 25, "id": "9d2ce375-a27c-4180-9de8-902c51f96dee", "metadata": {}, "outputs": [ @@ -179,17 +179,17 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 26, "id": "3c986c0a-80a4-428a-b799-2e7b00660ee4", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 16, + "execution_count": 26, "metadata": {}, "output_type": "execute_result" }, @@ -247,7 +247,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 27, "id": "a5e4599e-bf15-43fd-9fc7-90b2a1da7435", "metadata": {}, "outputs": [ From 104f892c9cb544051bf3bef9754db69298d1f691 Mon Sep 17 00:00:00 2001 From: Nils Hutter Date: Tue, 15 Mar 2022 16:03:50 -0700 Subject: [PATCH 09/21] Started statistic module --- lkf_tools/stats.py | 389 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 389 insertions(+) create mode 100644 lkf_tools/stats.py diff --git a/lkf_tools/stats.py b/lkf_tools/stats.py new file mode 100644 index 0000000..6b00d20 --- /dev/null +++ b/lkf_tools/stats.py @@ -0,0 +1,389 @@ +# -*- coding: utf-8 -*- + +""" +Statistic module of lkf_tools to perform spatial and temporal LKF statistics +""" + + +# Package Metadata +__version__ = 0.1 +__author__ = "Nils Hutter" +__author_email__ = "nhutter@uw.edu" + + +import numpy as np +import matplotlib.pylab as plt +import os +import sys +import datetime as dt +import scipy +import warnings +from pathlib import Path +from scipy.spatial import cKDTree +import pickle + +from pyproj import Proj +import xarray as xr + + +# Define function for fit to polynom + +def lkf_poly_fit(x,y,deg,return_p=False): + if x.size-10) + index_y = np.where(np.sum(mask[1:-1,1:-1],axis=1)>0) + red_fac = 3 # Take only every red_fac point to reduce array size + lon_cov = lon_cov[index_y[0][0]-1:index_y[0][-1]+2:red_fac, + index_x[0][0]-1:index_x[0][-1]+2:red_fac] + lat_cov = lat_cov[index_y[0][0]-1:index_y[0][-1]+2:red_fac, + index_x[0][0]-1:index_x[0][-1]+2:red_fac] + x_cov,y_cov = m(lon_cov,lat_cov) + + if self.datatype == 'sirex': + # if self.lkf_path.split('/')[-2].split('_')[-1] == 'means': + # ind_yp = -2 + # elif self.lkf_path.split('/')[-2].split('_')[-1] == 'inst': + # ind_yp = -1 + # ncfile = ('/work/ollie/nhutter/sirex/data/' + + # '/'.join(lkf_path[47:-1].split('/')[:-1])+'/'+ + # '_'.join(lkf_path[47:-1].split('/')[-1].split('_')[:ind_yp]) + '_' + + # years[-1] + '_' + + # '_'.join(lkf_path[47:-1].split('/')[-1].split('_')[ind_yp:]) + '.nc') + lkf_ps=lkf_path.split('/') + sp = '/'.join(lkf_ps[:np.where(np.array(lkf_ps)=='analysis')[0][0]]) + ind_m = np.where(np.array(lkf_ps)=='lead_detect')[0][0]+1 + ind_f = np.where(['means' in iseg or 'inst' in iseg for iseg in lkf_ps])[0][0] + ind_yp = np.array([-2,-1])[[np.any(['means' in iseg for iseg in lkf_ps]),np.any(['inst' in iseg for iseg in lkf_ps])]][0] + flnml = lkf_ps[ind_f].split('_'); flnml.insert(ind_yp,years[-1]) + ncfile = os.path.join(sp,'data','/'.join(lkf_ps[ind_m:ind_f]),'_'.join(flnml)+'.nc') + + + ncdata = Dataset(ncfile) + lon = ncdata.variables['ULON'][:,:] + lat = ncdata.variables['ULAT'][:,:] + + mask = ((((lon > -120) & (lon < 100)) & (lat >= 80)) | + ((lon <= -120) & (lat >= 70)) | + ((lon >= 100) & (lat >= 70))) + index_x = np.where(np.sum(mask[1:-1,1:-1],axis=0)>0) + index_y = np.where(np.sum(mask[1:-1,1:-1],axis=1)>0) + red_fac = 1 # Take only every red_fac point to reduce array size + x_cov,y_cov = m(lon[max([index_y[0][0]-1,0]):index_y[0][-1]+2:red_fac, + max([index_x[0][0]-1,0]):index_x[0][-1]+2:red_fac], + lat[max([index_y[0][0]-1,0]):index_y[0][-1]+2:red_fac, + max([index_x[0][0]-1,0]):index_x[0][-1]+2:red_fac]) + + if self.datatype == 'rgps': + cov = np.load('/work/ollie/nhutter/sirex/analysis/lead_detect/RGPS/coverage_rgps_1997_mod.npz') + x_cov, y_cov = m(cov['lon'],cov['lat']) + + + # RGPS coverage + if self.datatype=='mitgcm_2km': + cov = np.load('/work/ollie/nhutter/lkf_data/rgps_opt/coverage_rgps.npz') + else: + cov = np.load('/work/ollie/nhutter/sirex/analysis/lead_detect/RGPS/coverage_rgps_1997_mod.npz') + print('Loading this coverage file for masking: /work/ollie/nhutter/sirex/analysis/lead_detect/RGPS/coverage_rgps_1997_mod.npz') + + x_rgps,y_rgps = m(cov['lon'],cov['lat']) + + # Generate KDTree for interpolation + tree = cKDTree(np.rollaxis(np.stack([x_rgps.flatten(),y_rgps.flatten()]),0,2)) + distances, inds = tree.query(np.rollaxis(np.stack([x_cov.flatten(),y_cov.flatten()]),0,2), k = 1) + mask_cov = (distances>=12.5e3).reshape(x_cov.shape) + + + for year_dic in years: + print("Start reading with year: " + year_dic) + new_dir = lkf_path + year_dic + '/' + # Generate list of files + lkffile_list = [ifile for ifile in os.listdir(new_dir) if ifile.startswith('lkf')] + lkffile_list.sort() + + # Initialize list for year + lkf_data_year = [] + lkf_meta_year = [] + + # Read yearly RGPS coverage + if self.mask_rgps: + if self.datatype=='mitgcm_2km': + cov_year = np.load('/work/ollie/nhutter/lkf_data/rgps_opt/coverage_rgps_%s.npz' %year_dic)['coverage'] + else: + cov_year = np.load('/work/ollie/nhutter/sirex/analysis/lead_detect/RGPS/coverage_rgps_%s_mod.npz' %year_dic)['coverage'] + + + if len(lkffile_list)>cov_year.shape[0]: + lkffile_list = lkffile_list[:cov_year.shape[0]] + + # Loop over files to read an process + for it,lkffile in enumerate(lkffile_list): + + # Save meta information: start/end time, number features + if datatype == 'rgps': + startdate = (dt.date(int(lkffile[4:-15]),1,1)+ + dt.timedelta(int(lkffile[-15:-12]))) + enddate = (dt.date(int(lkffile[-11:-7]),1,1)+ + dt.timedelta(int(lkffile[-7:-4]))) + elif datatype == 'mitgcm_2km': + startdate = (dt.datetime(1992,1,1,0,0,0) + + dt.timedelta(0,int(lkffile[-14:-4])*120.)) + enddate = (dt.datetime(1992,1,1,0,0,0) + + dt.timedelta(0,int(lkffile[-14:-4])*120. + + 24*3600.)) + elif datatype == 'sirex': + if lkffile.split('_')[-2] == 'means': + ind_year = -4 + elif lkffile.split('_')[-2] == 'inst': + ind_year = -3 + startdate = (dt.date(int(lkffile.split('_')[ind_year]),1,1)+ + dt.timedelta(int(lkffile.split('_')[-1][:-4]))) + enddate = (dt.date(int(lkffile.split('_')[ind_year]),1,1)+ + dt.timedelta(int(lkffile.split('_')[-1][:-4])+3)) + + + if lkffile.endswith('.npy'): + lkfi = np.load(new_dir+lkffile, allow_pickle=True,encoding='bytes') + lkf_meta_year.append(np.array([startdate, + enddate, + lkfi.size])) + elif lkffile.endswith('.npz'): + lkfiz = np.load(new_dir+lkffile, allow_pickle=True,encoding='bytes') + lkfi = lkfiz['lkf'] + + if datatype == 'mosaic': + print(str(lkfiz['fname']).split('/')[-1].split('_')) + startdate = dt.datetime.strptime(str(lkfiz['fname']).split('/')[-1].split('_')[1][:-2],'%Y%m%dT%H%M%S') + enddate = dt.datetime.strptime(str(lkfiz['fname']).split('/')[-1].split('_')[2][:-2],'%Y%m%dT%H%M%S') + + lkf_meta_year.append(np.array([startdate, + enddate, + lkfi.size,lkfiz['fname'],lkfiz['shape']])) + + # Add projected coordinates + lkfim = [] + + if self.mask_rgps: + if self.datatype=='rgps': + cov_int = cov_year[it,100:-100,100:-100] + #if it==0: + # fig,ax = plt.subplots(1,1) + # ax.pcolormesh(cov_int) + # for iseg in lkfi: + # ax.plot(iseg[:,1].astype('int'),iseg[:,0].astype('int')) + else: + # Coverage mask of all LKFs in one day + cov_int = cov_year[it,:,:][np.unravel_index(inds,x_rgps.shape)].reshape(x_cov.shape) + cov_int[mask_cov] = np.nan + + for iseg in lkfi: + if self.mask_rgps: + mask_seg = cov_int[iseg[:,0].astype('int'), + iseg[:,1].astype('int')] + ind_mask = np.where(mask_seg)[0] + if np.any(np.diff(ind_mask)!=1): + ind_c = np.concatenate([np.array([-1]), + np.where(np.diff(ind_mask)!=1)[0], + np.array([ind_mask.size-1])]) + for ic in range(ind_c.size-1): + if ind_c[ic]+1!=ind_c[ic+1]: + iseg_c = iseg[ind_mask[ind_c[ic]+1]:ind_mask[ind_c[ic+1]]+1,:] + isegm = np.rollaxis(np.stack(m(iseg_c[:,2], + iseg_c[:,3])),1,0) + lkfim.append(np.concatenate([iseg_c, isegm], axis=1)) + if polyfit: + isegf = np.rollaxis(np.stack(lkf_poly_fit(lkfim[-1][:,self.indm0], + lkfim[-1][:,self.indm1], + poly_deg)),1,0) + lkfim[-1] = np.concatenate([lkfim[-1], isegf], axis=1) + + else: + iseg = iseg[mask_seg,:] + if iseg.shape[0]>1: + isegm = np.rollaxis(np.stack(m(iseg[:,2], + iseg[:,3])),1,0) + #print iseg, isegm + lkfim.append(np.concatenate([iseg, isegm], axis=1)) + if polyfit: + isegf = np.rollaxis(np.stack(lkf_poly_fit(lkfim[-1][:,self.indm0], + lkfim[-1][:,self.indm1], + poly_deg)),1,0) + lkfim[-1] = np.concatenate([lkfim[-1], isegf], axis=1) + else: + isegm = np.rollaxis(np.stack(m(iseg[:,2], + iseg[:,3])),1,0) + lkfim.append(np.concatenate([iseg, isegm], axis=1)) + + if polyfit: + isegf = np.rollaxis(np.stack(lkf_poly_fit(lkfim[-1][:,self.indm0], + lkfim[-1][:,self.indm1], + poly_deg)),1,0) + lkfim[-1] = np.concatenate([lkfim[-1], isegf], axis=1) + + lkf_data_year.append(lkfim) + + if read_tracking: + print( "Start reading tracking data of year: " + year_dic) + track_dir = os.path.join(lkf_path,year_dic,track_dir_name) + # Generate list of files + trackfile_list = os.listdir(track_dir) + trackfile_list.sort() + + track_year = [] + + for itrack, trackfile_i in enumerate(trackfile_list[:len(lkf_data_year)-1]): + tracked_pairs = np.load(os.path.join(track_dir, trackfile_i)) + + #track_day = np.empty((lkf_meta_year[-1][itrack][2],2),dtype=object) + track_year.append(tracked_pairs) + + + # Append to global data set + lkf_dataset.append(lkf_data_year) + lkf_meta.append(np.stack(lkf_meta_year)) + if read_tracking: lkf_track_data.append(track_year) + + # Store read and processed data + self.lkf_dataset = lkf_dataset + self.lkf_meta = lkf_meta + self.lkf_track_data = lkf_track_data + + + # Set all statistical fields to None + self.length = None + self.density = None + self.curvature = None + self.deformation = None + self.intersection = None + self.orientation = None + self.lifetime = None + self.growthrate = None From bbe15123795a3908b1f3f68ee35fcd2d798a3564 Mon Sep 17 00:00:00 2001 From: Nils Hutter Date: Wed, 16 Mar 2022 11:56:42 -0700 Subject: [PATCH 10/21] Add package install to README --- README.md | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/README.md b/README.md index 01b9004..189afeb 100644 --- a/README.md +++ b/README.md @@ -15,6 +15,10 @@ and activate the environment: ``` conda activate lkf_tools ``` +To install as python package run the following command with the repository directory: +``` +$ python setup.py develop +``` ## Generate LKF data-set From d772484b8074019d94b880025d267b267bb4d857 Mon Sep 17 00:00:00 2001 From: Nils Hutter Date: Fri, 18 Mar 2022 11:15:32 -0700 Subject: [PATCH 11/21] fixed missing imported package in tutorial --- notebooks/tutorial_gen_dataset.ipynb | 31 +++++++++++----------------- 1 file changed, 12 insertions(+), 19 deletions(-) diff --git a/notebooks/tutorial_gen_dataset.ipynb b/notebooks/tutorial_gen_dataset.ipynb index 930d7c6..03405a1 100644 --- a/notebooks/tutorial_gen_dataset.ipynb +++ b/notebooks/tutorial_gen_dataset.ipynb @@ -37,6 +37,7 @@ "%autoreload 2\n", "\n", "import xarray as xr\n", + "import os\n", "from pathlib import Path\n", "from lkf_tools.dataset import *" ] @@ -53,7 +54,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 2, "id": "ad3e51c0-b44d-4e45-9041-efc9a0b8472f", "metadata": {}, "outputs": [], @@ -82,7 +83,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 3, "id": "a042483c-95cb-416b-8e8d-b5751d5923ae", "metadata": {}, "outputs": [], @@ -104,7 +105,7 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 4, "id": "9d2ce375-a27c-4180-9de8-902c51f96dee", "metadata": {}, "outputs": [ @@ -179,17 +180,17 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 5, "id": "3c986c0a-80a4-428a-b799-2e7b00660ee4", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 26, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" }, @@ -247,18 +248,10 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 6, "id": "a5e4599e-bf15-43fd-9fc7-90b2a1da7435", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Track features in lkf_McGill_e2_1997_daily_means_001.npy to lkf_McGill_e2_1997_daily_means_002.npy\n" - ] - } - ], + "outputs": [], "source": [ "lkf_data.track_lkfs(indexes=[0])" ] @@ -273,17 +266,17 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 7, "id": "1f7d626c-5c32-498d-8660-fd39877ae5cc", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 23, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" }, From 1f278a05f05fb6d6a0f3f94893aec1574bcf6bab Mon Sep 17 00:00:00 2001 From: Nils Hutter Date: Thu, 21 Jul 2022 11:38:18 -0700 Subject: [PATCH 12/21] Indexing bug fixes --- lkf_tools/dataset.py | 2 +- lkf_tools/tracking.py | 12 ++++++------ 2 files changed, 7 insertions(+), 7 deletions(-) diff --git a/lkf_tools/dataset.py b/lkf_tools/dataset.py index 7a08055..761149c 100644 --- a/lkf_tools/dataset.py +++ b/lkf_tools/dataset.py @@ -78,7 +78,7 @@ def __init__(self,netcdf_file,output_path='./',max_kernel=5,min_kernel=1, self.dxu = self.data.DXU self.dyu = self.data.DYV else: - print("ERROR: DXU and DYU are missing in netcdf file!") + print("Warning: DXU and DYU are missing in netcdf file!") print(" --> Compute dxu and dyu from lon,lat using SSMI projection") m = mSSMI() x,y = m(self.lon,self.lat) diff --git a/lkf_tools/tracking.py b/lkf_tools/tracking.py index ffff3ff..1a3bf40 100644 --- a/lkf_tools/tracking.py +++ b/lkf_tools/tracking.py @@ -96,10 +96,10 @@ def track_lkf(lkf0_d, lkf1, nx, ny, thres_frac=0.75, min_overlap=4,first_overlap if ~np.any(np.isnan(iseg_d)): # Define search area - search_area = np.concatenate([np.floor(iseg_d),np.ceil(iseg_d), - np.vstack([np.floor(iseg_d)[:,0],np.ceil(iseg_d)[:,1]]).T, - np.vstack([np.ceil(iseg_d)[:,0],np.floor(iseg_d)[:,1]]).T], - axis=0) # Floor and ceil broken indexes + search_area = np.concatenate([np.floor(iseg_d[:,:2]),np.ceil(iseg_d[:,:2]), + np.vstack([np.floor(iseg_d)[:,0],np.ceil(iseg_d)[:,1]]).T, + np.vstack([np.ceil(iseg_d)[:,0],np.floor(iseg_d)[:,1]]).T], + axis=0) # Floor and ceil broken indexes # Broadening of search area #search_area_expansion = 1 # Number of cell for which the search area is expanded to be consider differences in the morphological thinning for i in range(search_area_expansion): @@ -288,8 +288,8 @@ def drift_estimate(lkf0_path,ncfile,mask,index_x,index_y,red_fac, # Loop over days t_tot = adv_time - t = 1.*24.*3600. - dt = 1.*24.*3600. + #t = 1.*24.*3600. + #dt = 1.*24.*3600. it0 = int(str(lkf0_path).split('/')[-1].split('.')[0].split("_")[-1]) #lkf0_d = lkf0.copy() From 3aa5b92624cc7778dcb114b86cc0e52445f80df6 Mon Sep 17 00:00:00 2001 From: Nils Hutter Date: Thu, 21 Jul 2022 14:05:53 -0700 Subject: [PATCH 13/21] Exmaple tutorial for rgps dataset and new skeleton function --- lkf_tools/_dir_filter.py | 182 ++++++ lkf_tools/dataset.py | 19 +- lkf_tools/detection.py | 39 +- notebooks/rgps_gen_dataset.ipynb | 1009 ++++++++++++++++++++++++++++++ 4 files changed, 1228 insertions(+), 21 deletions(-) create mode 100644 lkf_tools/_dir_filter.py create mode 100644 notebooks/rgps_gen_dataset.ipynb diff --git a/lkf_tools/_dir_filter.py b/lkf_tools/_dir_filter.py new file mode 100644 index 0000000..1b75583 --- /dev/null +++ b/lkf_tools/_dir_filter.py @@ -0,0 +1,182 @@ +from scipy import signal +import sys +import numpy as np +import os +import scipy.ndimage as ndim +from netCDF4 import Dataset +import datetime +import skimage.morphology + + +# ----------------------- Filter routines ------------------------- + + +def gkern(kernlen=21, std=3): + """Returns a 2D Gaussian kernel array.""" + gkern1d = signal.gaussian(kernlen, std=std).reshape(kernlen, 1) + gkern2d = np.outer(gkern1d, gkern1d) + return gkern2d + + +def line(x0, y0, x1, y1): + """Bresenham's line algorithm + Source: stackoverflow.com + Returns index of line points between the two points (x0,y0) and (x1,y1)""" + points_in_line = [] + dx = abs(x1 - x0) + dy = abs(y1 - y0) + x, y = x0, y0 + sx = -1 if x0 > x1 else 1 + sy = -1 if y0 > y1 else 1 + if dx > dy: + err = dx / 2.0 + while x != x1: + points_in_line.append((x, y)) + err -= dy + if err < 0: + y += sy + err += dx + x += sx + else: + err = dy / 2.0 + while y != y1: + points_in_line.append((x, y)) + err -= dx + if err < 0: + x += sx + err += dy + y += sy + points_in_line.append((x, y)) + return points_in_line + + + +def gen_dir_kernels(kernelsize=5): + """Generates directional kernels: + List of arrays of size (kernelsize,kernelsize) that mask all possible directions + crossing the center of the array that can be discretized with the number of pixels.""" + kernels = [] + for i in range(kernelsize): + kern = np.zeros((kernelsize,kernelsize)) + points=np.stack(line(i,0,kernelsize-i-1,kernelsize-1)) + kern[points[:,0],points[:,1]]+=1. + points=np.stack(line(kernelsize-i-1,kernelsize-1,i,0)) + kern[points[:,0],points[:,1]]+=1. + kernels.append(kern/np.sum(kern)) + for i in range(1,kernelsize-1): + kern = np.zeros((kernelsize,kernelsize)) + points=np.stack(line(0,i,kernelsize-1,kernelsize-i-1)) + kern[points[:,0],points[:,1]]+=1. + points=np.stack(line(kernelsize-1,kernelsize-i-1,0,i)) + kern[points[:,0],points[:,1]]+=1. + kernels.append(kern/np.sum(kern)) + return kernels + + + +def gen_dir_kernels_gaus(kernelsize=5,std=2.5): + """Generates directional Gaussian kernels: + List of arrays of size (kernelsize,kernelsize) that contain the magnitude of 1-D Gaussian kernels + with standard deviation std along all directions crossing the center of the array that can be + discretized with the number of pixels.""" + kernels = [] + for i in range(kernelsize): + mask = np.zeros((kernelsize,kernelsize),dtype='bool') + points=np.stack(line(i,0,kernelsize-i-1,kernelsize-1)) + mask[points[:,0],points[:,1]]=True + points=np.stack(line(kernelsize-i-1,kernelsize-1,i,0)) + mask[points[:,0],points[:,1]]=True + kern = gkern(kernlen=kernelsize,std=std) + kern[~mask] = 0 + kernels.append(kern/np.sum(kern)) + for i in range(1,kernelsize-1): + mask = np.zeros((kernelsize,kernelsize),dtype='bool') + points=np.stack(line(0,i,kernelsize-1,kernelsize-i-1)) + mask[points[:,0],points[:,1]]=True + points=np.stack(line(kernelsize-1,kernelsize-i-1,0,i)) + mask[points[:,0],points[:,1]]=True + kern = gkern(kernlen=kernelsize,std=std) + kern[~mask] = 0 + kernels.append(kern/np.sum(kern)) + return kernels + + +def slicing_run(img, patch_shape): + """Rolling window over array img of size (patch_shape,patch_shape)""" + img = np.ascontiguousarray(img) # won't make a copy if not needed + X, Y = img.shape + x, y = patch_shape + shape = (int(X-x+1), int(Y-y+1), int(x), int(y)) # number of patches, patch_shape + strides = img.itemsize*np.array([Y, 1, Y, 1]) + return np.lib.stride_tricks.as_strided(img, shape=shape, strides=strides) + + + +def dir_filt(field,kernelsize=7): + """Directional filter: + For each pixel the local standard deviation along all possible directions is computed. The neighbourhood + for the computation of the standard deviation is given by the kernel size. The filter chooses for each + pixel the direction with lowest standard deviation and averages along this direction. + + Input: field - input array to be filtered + kernelsize - number of points used to describe the neighbourhood of a pixel + + Output: field filtered with directional filter""" + + kernels = gen_dir_kernels(kernelsize=kernelsize) + sliced_field = slicing_run(field,(kernelsize,kernelsize)) + #inds = np.argmin([np.std(sliced_field[:,:,kernels[i]>0],axis=-1) for i in range(len(kernels))]),axis==0) + #return np.stack([signal.convolve2d(field, kernels[i], boundary='symm', mode='same') for i in range(len(kernels))])[inds,:,:] + inds = np.argmin([np.std(sliced_field[:,:,kernels[i]>0],axis=-1) for i in range(len(kernels))],axis=0) + filt_all = np.stack([np.sum(sliced_field*kernels[i],axis=(-1,-2)) for i in range(len(kernels))]) + filt = np.zeros(inds.shape)*np.NaN + for i in range(len(kernels)): + filt[inds==i] = filt_all[i,inds==i] + return filt + +# def skeleton_along_max(field,detect,skeleton,kernelsize=7): +# """ +# skeleton at maximum value +# """ +# kernels = gen_dir_kernels(kernelsize=kernelsize) +# sliced_skel = slicing_run(skeleton,(kernelsize,kernelsize)) +# sliced_field = slicing_run(field,(kernelsize,kernelsize)) +# # Finds direction perpendicular to LKF orientation +# inds = np.argmin([np.sum(sliced_field[:,:,kernels[i]>0],axis=-1) for i in range(len(kernels))]) +# # Find maximum value in this direction for each pixel +# max_ind = [[np.argmax(sliced_field[ix,iy,kernels[inds[ix,iy]]>0]) for iy in range(field.shape[1])] for ix in range(field.shape[0])] + +# return np.stack([signal.convolve2d(field, kernels[i], boundary='symm', mode='same') for i in range(len(kernels))])[inds,:,:] + +def skeleton_along_max(field,detect,kernelsize=7): + kernels = gen_dir_kernels(kernelsize=kernelsize) + sliced_detect = slicing_run(detect,(kernelsize,kernelsize)) + sliced_field = slicing_run(field,(kernelsize,kernelsize)) + # Finds direction perpendicular to LKF orientation + inds = np.argmin([np.sum(sliced_detect[:,:,kernels[i]>0],axis=-1) for i in range(len(kernels))],axis=0) + # Find maximum value in this direction for each pixel + nx,ny = field.shape; nx -= kernelsize-1; ny -= kernelsize-1 + max_ind = np.array([[np.argmax(sliced_field[ix,iy,kernels[inds[ix,iy]]>0]) for iy in range(ny)] for ix in range(nx)]) + # Convert from kernel indexing to x,y indexing + km = int(kernelsize/2) + ix = np.array([np.where(kernels[inds[ix,iy]])[0][max_ind[ix,iy]]+ix for ix,iy in list(zip(*np.where(detect[km:-km,km:-km]>=1)))],dtype='int') + iy = np.array([np.where(kernels[inds[ix,iy]])[1][max_ind[ix,iy]]+iy for ix,iy in list(zip(*np.where(detect[km:-km,km:-km]>=1)))],dtype='int') + #Generate new mask + mask = np.zeros(field.shape) + mask[ix,iy]=1 + return skimage.morphology.skeletonize(mask).astype('float') + + +# def DoG_leads(in_array,max_kern,min_kern): +# """DoG: Difference of Gaussian Filters Combination as implemented in Linow & Dierking, 2017""" + +# res = np.zeros(in_array.shape) +# c = np.arange(min_kern,max_kern+1)*0.5 + +# for i in range(0,c.size-1): +# gaus1 = ndim.gaussian_filter(in_array,c[i],truncate=2) +# gaus2 = ndim.gaussian_filter(in_array,c[i+1],truncate=2) +# res += (gaus1 - gaus2) + +# return res + \ No newline at end of file diff --git a/lkf_tools/dataset.py b/lkf_tools/dataset.py index 761149c..7a50cdc 100644 --- a/lkf_tools/dataset.py +++ b/lkf_tools/dataset.py @@ -31,16 +31,18 @@ class process_dataset(object): """ Class to process deformation and drift dataset to LKF data set. """ - def __init__(self,netcdf_file,output_path='./',max_kernel=5,min_kernel=1, - dog_thres=0.01,dis_thres=4,ellp_fac=2,angle_thres=45, - eps_thres=1.25,lmin=3,latlon=True,return_eps=True,red_fac=1,t_red=3): + def __init__(self,netcdf_file,output_path='./',xarray=None, + max_kernel=5,min_kernel=1, dog_thres=0.01,skeleton_kernel=0, + dis_thres=4,ellp_fac=2,angle_thres=45,eps_thres=1.25,lmin=3, + latlon=True,return_eps=True,red_fac=1,t_red=3): """ Processes deformation and drift dataset to LKF data set netcdf_file: expected variables U,V,A in shape (time,x,y) """ # Set output path - self.lkfpath = Path(output_path).joinpath(netcdf_file.split('/')[-1].split('.')[0]) + self.netcdf_file = str(netcdf_file) + self.lkfpath = Path(output_path).joinpath(self.netcdf_file.split('/')[-1].split('.')[0]) lkfpath = '/' for lkfpathseg in str(self.lkfpath.absolute()).split('/')[1:]: lkfpath += lkfpathseg + '/' @@ -51,6 +53,7 @@ def __init__(self,netcdf_file,output_path='./',max_kernel=5,min_kernel=1, self.max_kernel = max_kernel self.min_kernel = min_kernel self.dog_thres = dog_thres + self.skeleton_kernel = skeleton_kernel self.dis_thres = dis_thres self.ellp_fac = ellp_fac self.angle_thres = angle_thres @@ -63,8 +66,10 @@ def __init__(self,netcdf_file,output_path='./',max_kernel=5,min_kernel=1, # Read netcdf file - self.netcdf_file = netcdf_file - self.data = xr.open_dataset(self.netcdf_file) + if xarray is None: + self.data = xr.open_dataset(self.netcdf_file) + else: + self.data = xarray # Store variables self.time = self.data.time @@ -170,7 +175,7 @@ def detect_lkfs(self,indexes=None,force_redetect=False): dog_thres=self.dog_thres,dis_thres=self.dis_thres*self.corfac, ellp_fac=self.ellp_fac,angle_thres=self.angle_thres, eps_thres=self.eps_thres,lmin=self.lmin*self.corfac, - max_ind=500*self.corfac,use_eps=True) + max_ind=500*self.corfac,use_eps=True,skeleton_kernel=self.skeleton_kernel) # Save the detected features diff --git a/lkf_tools/detection.py b/lkf_tools/detection.py index e779bfe..bfe13b7 100644 --- a/lkf_tools/detection.py +++ b/lkf_tools/detection.py @@ -25,6 +25,7 @@ import skimage.morphology from .rgps import * +from ._dir_filter import skeleton_along_max @@ -102,16 +103,20 @@ def nan_gaussian_filter(field,kernel,truncate): def DoG_leads(in_array,max_kern,min_kern): """DoG: Difference of Gaussian Filters Combination as implemented in Linow & Dierking, 2017""" - + res = np.zeros(in_array.shape) c = np.arange(min_kern,max_kern+1)*0.5 - - for i in range(0,c.size-1): + + # for i in range(0,c.size-1): - gaus1 = nan_gaussian_filter(in_array,c[i],truncate=2) - gaus2 = nan_gaussian_filter(in_array,c[i+1],truncate=2) - res += (gaus1 - gaus2) - + # gaus1 = nan_gaussian_filter(in_array,c[i],truncate=2) + # gaus2 = nan_gaussian_filter(in_array,c[i+1],truncate=2) + # res += (gaus1 - gaus2) + + gaus1 = nan_gaussian_filter(in_array,c[0],truncate=2) + gaus2 = nan_gaussian_filter(in_array,c[-1],truncate=2) + + res = (gaus1 - gaus2) return res @@ -1028,7 +1033,7 @@ def lkf_detect_rgps(filename_rgps,max_kernel=5,min_kernel=1,dog_thres=0,dis_thre return seg -def lkf_detect_eps(eps_tot,max_kernel=5,min_kernel=1,dog_thres=0,dis_thres=4,ellp_fac=3,angle_thres=35,eps_thres=0.5,lmin=4): +def lkf_detect_eps(eps_tot,max_kernel=5,min_kernel=1,dog_thres=0,dis_thres=4,ellp_fac=3,angle_thres=35,eps_thres=0.5,lmin=4,skeleton_kernel=0): """Function that detects LKFs in input RGPS file. Input: eps_tot - total deformation rate @@ -1055,7 +1060,10 @@ def lkf_detect_eps(eps_tot,max_kernel=5,min_kernel=1,dog_thres=0,dis_thres=4,ell lkf_detect = (lkf_detect > dog_thres).astype('float') lkf_detect[~np.isfinite(proc_eps)] = np.NaN ## Apply morphological thinning - lkf_thin = skimage.morphology.skeletonize(lkf_detect).astype('float') + if skeleton_kernel==0: + lkf_thin = skimage.morphology.skeletonize(lkf_detect).astype('float') + else: + lkf_thin = skeleton_along_max(eps_tot,lkf_detect,kernel_size=skeleton_kernel).astype('float') # Segment detection @@ -1097,7 +1105,7 @@ def lkf_detect_eps(eps_tot,max_kernel=5,min_kernel=1,dog_thres=0,dis_thres=4,ell def lkf_detect_eps_multday(eps_tot,max_kernel=5,min_kernel=1, dog_thres=0,dis_thres=4,ellp_fac=3, angle_thres=35,eps_thres=0.5,lmin=4, - max_ind=500, use_eps=False): + max_ind=500, use_eps=False,skeleton_kernel=0): """Function that detects LKFs in temporal slice of deformation rate. LKF binary map is generated for each time slice and all binary maps are combined into one before segments are detected. @@ -1135,13 +1143,16 @@ def lkf_detect_eps_multday(eps_tot,max_kernel=5,min_kernel=1, lkf_detect_multday += lkf_detect lkf_detect = (lkf_detect_multday > 0) - - ## Apply morphological thinning - lkf_thin = skimage.morphology.skeletonize(lkf_detect).astype('float') - + # Compute average total deformation eps_tot = np.nanmean(np.stack(eps_tot),axis=0) + ## Apply morphological thinning + if skeleton_kernel==0: + lkf_thin = skimage.morphology.skeletonize(lkf_detect).astype('float') + else: + lkf_thin = skeleton_along_max(eps_tot,lkf_detect,kernelsize=skeleton_kernel).astype('float') + # Segment detection seg_f = detect_segments(lkf_thin,max_ind=max_ind) # Returns matrix fill up with NaNs ## Convert matrix to list with arrays containing indexes of points diff --git a/notebooks/rgps_gen_dataset.ipynb b/notebooks/rgps_gen_dataset.ipynb new file mode 100644 index 0000000..1a20d35 --- /dev/null +++ b/notebooks/rgps_gen_dataset.ipynb @@ -0,0 +1,1009 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "d7e50086-ca38-42d6-8c09-889f936cc8ab", + "metadata": { + "tags": [] + }, + "source": [ + "# Detect and track LKFs in netcdf model output\n", + "\n", + "This tutorial shows how to generate a LKF data-set based on gridded RGPS sea-ice drift and deformation data in netcdf format. \n", + " \n", + "### Load `lkf_tools` package" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "f00f91bc-66b9-45a6-acd5-30de3f7b9b0b", + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2\n", + "\n", + "import xarray as xr\n", + "import os\n", + "from pathlib import Path\n", + "from lkf_tools.dataset import *" + ] + }, + { + "cell_type": "markdown", + "id": "a2765c52-cb4a-4432-ac8e-9f534a6af225", + "metadata": {}, + "source": [ + "### Open netcdf file\n", + "\n", + "We open the netcdf file with xarray. As an example we use here winter 2000/2001." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "ad3e51c0-b44d-4e45-9041-efc9a0b8472f", + "metadata": {}, + "outputs": [], + "source": [ + "data_path = Path('../../RGPS/eulerian/netcdfs/RGPS_eulerian_drift_deformation_w0001.nc')\n", + "\n", + "rgps_nc = xr.open_dataset(data_path)" + ] + }, + { + "cell_type": "markdown", + "id": "f161ab50-177f-4af2-9e64-24695a4b2cdb", + "metadata": {}, + "source": [ + "### Processing netcdf file\n", + "\n", + "Since the RGPS netcdf file does not follow the conventions of `lkf_tools` package, we need to rename some variables and coordinates." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "a17c22fb-01a2-492c-b71a-a47bc508f7de", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.Dataset>\n",
+       "Dimensions:     (time: 60, y: 248, x: 264)\n",
+       "Coordinates:\n",
+       "    ULON        (y, x) float64 -111.6 -111.5 -111.3 -111.2 ... 110.2 109.9 109.6\n",
+       "    ULAT        (y, x) float64 67.51 67.61 67.71 67.81 ... 69.21 69.16 69.12\n",
+       "  * x           (x) float64 -2.294e+06 -2.281e+06 ... 9.812e+05 9.938e+05\n",
+       "  * y           (y) float64 -9.938e+05 -9.812e+05 ... 2.081e+06 2.094e+06\n",
+       "  * time        (time) datetime64[ns] 2000-11-11T12:00:00 ... 2001-05-07T12:0...\n",
+       "    start_time  (time) datetime64[ns] 2000-11-10 2000-11-13 ... 2001-05-06\n",
+       "    end_time    (time) datetime64[ns] 2000-11-13 2000-11-16 ... 2001-05-09\n",
+       "Data variables:\n",
+       "    div         (time, y, x) float32 nan nan nan nan nan ... nan nan nan nan nan\n",
+       "    shr         (time, y, x) float32 ...\n",
+       "    vor         (time, y, x) float32 ...\n",
+       "    U           (time, y, x) float64 ...\n",
+       "    V           (time, y, x) float64 ...\n",
+       "    A           (time, y, x) float64 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n",
+       "Attributes: (12/21)\n",
+       "    title:                  RADARSAT Geophysical Processing System: Eulerian ...\n",
+       "    summary:                Eulerian sea ice deformation and drift data inter...\n",
+       "    keywords:               sea ice; deformation; divergence; shear; vorticit...\n",
+       "    Conventions:            ACDD-1.3\n",
+       "    id:                     w0001\n",
+       "    instrument:             RADARSAT\n",
+       "    ...                     ...\n",
+       "    geospatial_lat_max:     89.91949435184777\n",
+       "    geospatial_lon_min:     -180.0\n",
+       "    geospatial_lon_max:     179.82845626253842\n",
+       "    time_coverage_start:    2000-11-10T00:00:00\n",
+       "    time_coverage_end:      2001-05-09T00:00:00\n",
+       "    metadata_link:          https://asf.alaska.edu/wp-content/uploads/2019/03...
" + ], + "text/plain": [ + "\n", + "Dimensions: (time: 60, y: 248, x: 264)\n", + "Coordinates:\n", + " ULON (y, x) float64 ...\n", + " ULAT (y, x) float64 ...\n", + " * x (x) float64 -2.294e+06 -2.281e+06 ... 9.812e+05 9.938e+05\n", + " * y (y) float64 -9.938e+05 -9.812e+05 ... 2.081e+06 2.094e+06\n", + " * time (time) datetime64[ns] 2000-11-11T12:00:00 ... 2001-05-07T12:0...\n", + " start_time (time) datetime64[ns] ...\n", + " end_time (time) datetime64[ns] ...\n", + "Data variables:\n", + " div (time, y, x) float32 nan nan nan nan nan ... nan nan nan nan nan\n", + " shr (time, y, x) float32 ...\n", + " vor (time, y, x) float32 ...\n", + " U (time, y, x) float64 ...\n", + " V (time, y, x) float64 ...\n", + " A (time, y, x) float64 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", + "Attributes: (12/21)\n", + " title: RADARSAT Geophysical Processing System: Eulerian ...\n", + " summary: Eulerian sea ice deformation and drift data inter...\n", + " keywords: sea ice; deformation; divergence; shear; vorticit...\n", + " Conventions: ACDD-1.3\n", + " id: w0001\n", + " instrument: RADARSAT\n", + " ... ...\n", + " geospatial_lat_max: 89.91949435184777\n", + " geospatial_lon_min: -180.0\n", + " geospatial_lon_max: 179.82845626253842\n", + " time_coverage_start: 2000-11-10T00:00:00\n", + " time_coverage_end: 2001-05-09T00:00:00\n", + " metadata_link: https://asf.alaska.edu/wp-content/uploads/2019/03..." + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "rgps_nc = rgps_nc.rename({'xc':'x', 'yc':'y', 'divergence':'div', 'shear':'shr',\n", + " 'vorticity':'vor', 'u':'U', 'v':'V', 'lon':'ULON', 'lat':'ULAT'})\n", + "rgps_nc = rgps_nc.assign(A=np.isfinite(rgps_nc.div).astype('float'))\n", + "rgps_nc" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "c0a4f99b-d2ea-4343-b6a5-784bb45afd8a", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "rgps_nc.A[0,:,:].plot()" + ] + }, + { + "cell_type": "markdown", + "id": "2a15406b-0afd-4a06-a95d-e74c92422a62", + "metadata": {}, + "source": [ + "### Open a new processing object\n", + "This step initiates a lkf processing object that reads in the netcdf files and sets everything up to run the detection and processing steps." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "a042483c-95cb-416b-8e8d-b5751d5923ae", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Warning: DXU and DYU are missing in netcdf file!\n", + " --> Compute dxu and dyu from lon,lat using SSMI projection\n" + ] + } + ], + "source": [ + "lkf_data = process_dataset(data_path,\n", + " output_path='../data/lkfs/RGPS/w0001/',\n", + " xarray=rgps_nc,t_red=1)" + ] + }, + { + "cell_type": "markdown", + "id": "2a1c7259-fb26-4ef1-9273-fa0050240b45", + "metadata": {}, + "source": [ + "### Detection of LKFs\n", + "After initialising the lkf processing object, we run the detection step. If `indexes` is defined only those specific time steps will be detected. Here we just detect the first two days for demonstration purposes.\n", + "\n", + "*Note: the algorithms currently outputs a number of warnings, that can be ignored mostly. It is an open issue to remove those warnings.*" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "9d2ce375-a27c-4180-9de8-902c51f96dee", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Compute deformation rates and detect features for day 1\n", + "Start detection routines\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/nhutter/Documents/Research/lkf_tools/lkf_tools/detection.py:97: RuntimeWarning: invalid value encountered in true_divide\n", + " gaussian_field = field_nonnan_f/mask_nan_f\n", + "/Users/nhutter/Documents/Research/lkf_tools/lkf_tools/detection.py:1148: RuntimeWarning: Mean of empty slice\n", + " eps_tot = np.nanmean(np.stack(eps_tot),axis=0)\n", + "/Users/nhutter/Documents/Research/lkf_tools/lkf_tools/detection.py:248: RuntimeWarning: invalid value encountered in true_divide\n", + " dx = (seg_active[:,:,-1]-seg_active[np.arange(seg_active.shape[0]),:,-num_points])/np.stack([num_points-1,num_points-1],axis=1) - (seg_append-seg_active[:,:,-1])\n", + "/Users/nhutter/Documents/Research/lkf_tools/lkf_tools/detection.py:559: RuntimeWarning: invalid value encountered in true_divide\n", + " e1 = (e1/np.sqrt(np.sum(e1**2))) # Normalize basis vector\n", + "/Users/nhutter/Documents/Research/lkf_tools/lkf_tools/detection.py:562: RuntimeWarning: invalid value encountered in true_divide\n", + " f1 = (f1/np.sqrt(np.sum(f1**2))) # Normalize basis vector\n", + "/Users/nhutter/miniforge3/envs/lkf_tools/lib/python3.10/site-packages/numpy/lib/npyio.py:518: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n", + " arr = np.asanyarray(arr)\n", + "/Users/nhutter/Documents/Research/lkf_tools/lkf_tools/detection.py:97: RuntimeWarning: invalid value encountered in true_divide\n", + " gaussian_field = field_nonnan_f/mask_nan_f\n", + "/Users/nhutter/Documents/Research/lkf_tools/lkf_tools/detection.py:1148: RuntimeWarning: Mean of empty slice\n", + " eps_tot = np.nanmean(np.stack(eps_tot),axis=0)\n", + "/Users/nhutter/Documents/Research/lkf_tools/lkf_tools/detection.py:248: RuntimeWarning: invalid value encountered in true_divide\n", + " dx = (seg_active[:,:,-1]-seg_active[np.arange(seg_active.shape[0]),:,-num_points])/np.stack([num_points-1,num_points-1],axis=1) - (seg_append-seg_active[:,:,-1])\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Compute deformation rates and detect features for day 2\n", + "Start detection routines\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/nhutter/Documents/Research/lkf_tools/lkf_tools/detection.py:1167: RuntimeWarning: divide by zero encountered in log10\n", + " eps_mn = compute_mn_eps(np.log10(eps_tot),seg)\n", + "/Users/nhutter/Documents/Research/lkf_tools/lkf_tools/detection.py:1176: RuntimeWarning: divide by zero encountered in log10\n", + " eps_mn = compute_mn_eps(np.log10(eps_tot),seg)\n", + "/Users/nhutter/Documents/Research/lkf_tools/lkf_tools/detection.py:562: RuntimeWarning: invalid value encountered in true_divide\n", + " f1 = (f1/np.sqrt(np.sum(f1**2))) # Normalize basis vector\n", + "/Users/nhutter/Documents/Research/lkf_tools/lkf_tools/detection.py:559: RuntimeWarning: invalid value encountered in true_divide\n", + " e1 = (e1/np.sqrt(np.sum(e1**2))) # Normalize basis vector\n", + "/Users/nhutter/miniforge3/envs/lkf_tools/lib/python3.10/site-packages/numpy/lib/npyio.py:518: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n", + " arr = np.asanyarray(arr)\n" + ] + } + ], + "source": [ + "lkf_data.detect_lkfs(indexes=[0,1])" + ] + }, + { + "cell_type": "markdown", + "id": "05269991-ec5b-4af5-9069-419a932389c1", + "metadata": {}, + "source": [ + "Now we can have a short look at the outcome of the detection. We will plot the LKFs detected in the last time step over the deformation rates." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "3c986c0a-80a4-428a-b799-2e7b00660ee4", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "import cartopy.crs as ccrs\n", + "\n", + "fig = plt.figure(figsize=[10, 5])\n", + "\n", + "ax = plt.subplot(1, 1, 1, projection=ccrs.Orthographic(0, 90))\n", + "\n", + "ax.coastlines(zorder=3)\n", + "\n", + "pcm = ax.pcolormesh(lkf_data.lon[max([0,lkf_data.index_y[0][0]-1]):lkf_data.index_y[0][-1]+2:lkf_data.red_fac,\n", + " max([0,lkf_data.index_x[0][0]-1]):lkf_data.index_x[0][-1]+2:lkf_data.red_fac],\n", + " lkf_data.lat[max([0,lkf_data.index_y[0][0]-1]):lkf_data.index_y[0][-1]+2:lkf_data.red_fac,\n", + " max([0,lkf_data.index_x[0][0]-1]):lkf_data.index_x[0][-1]+2:lkf_data.red_fac],\n", + " np.sum(lkf_data.eps_tot_list,axis=0),transform=ccrs.PlateCarree(),vmin=0,vmax=1e-1,cmap='Greys_r')\n", + "\n", + "it = lkf_data.indexes[-1]\n", + "\n", + "#lkfs = np.load(lkf_data.lkfpath.joinpath('lkf_McGill_runno01_expno07_1997_daily_means_029.npy'),allow_pickle=True)\n", + "lkfs = np.load(lkf_data.lkfpath.joinpath('lkf_%s_%03i.npy' %(lkf_data.netcdf_file.split('/')[-1].split('.')[0],(it+1))),allow_pickle=True)\n", + "\n", + "for ilkf in lkfs:\n", + " if np.min(ilkf[:,2])<-150 and np.max(ilkf[:,2]>150):\n", + " ilkf[ilkf[:,2]<0,2]+=360\n", + " ax.plot(ilkf[:,2],ilkf[:,3],transform=ccrs.PlateCarree())\n", + "\n", + "plt.colorbar(pcm,label='total deformation')" + ] + }, + { + "cell_type": "markdown", + "id": "46818dcd-437d-433d-b00e-3961501ba118", + "metadata": {}, + "source": [ + "### Track LKFs\n", + "\n", + "After detecting LKFs, we can track LKFs using the drift fields to advect features. Since we only detected two time steps, we can just track the first pair, which we define with `indexes` again." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "a5e4599e-bf15-43fd-9fc7-90b2a1da7435", + "metadata": {}, + "outputs": [], + "source": [ + "lkf_data.track_lkfs(indexes=[0])" + ] + }, + { + "cell_type": "markdown", + "id": "3f6d6551-50aa-45ef-abb0-c512450e7788", + "metadata": {}, + "source": [ + "After tracking the features, we will plot the tracked results to see if it worked appropriately." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "1f7d626c-5c32-498d-8660-fd39877ae5cc", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAASsAAAEeCAYAAADSEzOqAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAADl5klEQVR4nOx9d1gbV/r1GTVAAtERvfeOsXGLe+9x3LEB25vuJN7NbrLJtmST7C/Jl2TTNomzSTZUGxfccccVF7AxvffeuwAJlfn+IDOLQBISpjnr8zx+NotGM3dGd85971vOS5AkiSd4gid4gqkOxmQP4Ame4AmeQBM8IasneIIneCzwhKye4Ame4LHAE7J6gid4gscCT8jqCZ7gCR4LPCGrJ3iCJ3gswFL34cqVK8mWlpaJGssTaICysjLw+XyYmZlN9lCmLORyOQiCAEEQkz2UKYPu7m5UV1fD2dkZ5eXlsLGxAZ/Pn+xhDUNaWloaSZLTlX2mlqxaWlrw4MGD8RnVE2gNqVQKgUCA5ORk2NraTvZwJhUymQwMBgMEQYAkSSQnJ6O0tBT37t3D999/j8TERKxevXqyhzkl8cYbbyAlJQVHjx6FQCCY7OEoQN0C82Qb+BghNTUVNjY2/7NEJRaLceLECTzzzDMwNjaGo6MjvvnmG+zbtw8RERG4evUqbGxs8Prrr+PixYuTPdwpi48++ggLFixAcHAw7ty5M9nD0RhqLasnmFq4cOECVq1aNdnDmFBUVlYiMjISt2/fxv379xEQEIDw8HD8+9//Rk5ODn788UcIBALcv38fpqamAIDbt2/jt7/97eQOfAqDyWTi/fffx6xZs/D000/j3LlzmD5d6c5rSuEJWT0mKCoqwr/+9S+cPn16socyYcjPz8fixYuxbds27N+/H9OnT1fYtixcuBALFy4c9r1bt27BwcFhAkf6eGLNmjV488038f333z8hqycYG5w+fRobNmwAAMyZM2eSRzNx2L9/P/70pz/h1Vdf1fg7JSUl+Pjjj/Hw4cNxHNmvA1KpFBcuXMCSJUsmeyga4YnPagqDJEnExMTQRLVr1y4wGP87P5lAIMD169fR3t6u0fFJSUmYO3cuPv74Yzg5OY3z6B5/nDp1CkKhEG+++eZkD0UjPLGspihkMhkiIiKQnp6O9PR03LhxA/Pnz5/sYU0ovv/+e/zhD3/AnDlzcO/ePRgaGqo89sGDB9ixYweOHDmidGv4BIro6OjAu+++i7/85S9gMpmTPRzNQJKkyn/BwcHkE0wMent7ycrKSlIul5MkSZJRUVHkzJkzyd7e3kke2eRj3759ZEhICFlTUzPss/b2dvKtt94iTUxMyISEhEkY3eOJtWvXkvv27aPn21QBgAekCj56QlZTBGfPniUBkIsXLyZJkiQ9PT3JS5cuTfKopgZkMhn5/vvvk/r6+qSPjw/57LPPksHBweT8+fNJQ0NDcu/evWRjY+NkD/OxQX19PWlsbEz29fVN9lCGQR1ZEaQa8b3p06eTT5JCJwYSiQQcDgcA8M033+CLL75ATk4O/bcnGHhGmZmZuHHjBoKCgiCRSBAQEABLS8vJHtpjhcTERHz55Ze4dOnSZA9lGAiCGF0G+xNMHF577TX6v/ft24ekpKRJJ6r6+noYGxtDV1d3UsdBgc1mY/r06Y9FmH0qo7S0FO7u7pM9DK3xvxNamsIQCoU4cOAAZs+eTf9t8eLFkzgioKqqCoWFhaiurp7UcTzB+EDdjmqq4glZTQHo6+uDJEncuXMHq1atUrCyJhokSaK8vBxlZWWwsLCAi4vLpI3lCcYG0dHRWLFiBTo6OgAAgYGBuHHjxmNHWE/IagpALpfj008/xdGjR3H37l28/fbbkzIOkiRRWlqKyspKWFpawsvL638qr+vXipKSEly6dAkpKSkAgHnz5kEmk+HWrVuTPDLt8MRnNckoKirCBx98gJiYGADA22+/PakOY5IkYWNjA1dX1ycSK2MIOqI1CdI1r7/+OsrLy+k8PYIg8Oabb+J3v/sd7ty5Ax0dnQkdz2jxJBo4SSBJEomJiQgNDcWLL74IOzs7pKSk4KeffprUyUPNhydENbYoKCjA4cOHAQCGhobYvn37pC9Kmzdvhq2tLb788stJG8dQqIsGPiGrSYBQKMTSpUvR1dWFv//979iyZctkD+kJxhktLS3Izc0FSZJIT09Hf38/NmzYAAMDA5ibm09K5Le9vR1BQUF47733EB4ePuHXV4YnqQtTDP/4xz/g7OyMuLi4JxbM/wjMzMywYMECAAMO7ujoaNrSMjIyQnh4OIyNjSd0TMbGxjh//jwWL14MPT29Kb9oPrGsJhgdHR1wcnJCTk4ObGxsJns4TzBJEIlEqKmpQV9fH86fPw8Wi4Xw8PBJkavOzMzE8uXLsX//fvzhD3+Y1Pw+dZbVk1DPOCEmJgYrVqwYJlVy6NAhLFu27AlRjYCCggIUFhZO9jDGDbq6unB1dYWfnx8iIiIgl8vx888/o7GxccLHEhAQgJSUFCQnJ2PatGlITEyckmkNT8hqHFBXV4f9+/ejpKRkmFZQUlISnn766ckZ2GOEvr4+9PX1TfYwJgQCgQC7d+8Gi8VCZGQkamtrJ3wMjo6OSExMxPvvv48//vGPmD17Ni5cuDClSOsJWT0iWltbcfToUXzwwQf4+eefAQBXr17FU089hc7OTly5ckXh+KqqqidaSyOgv78fIpHof8qfZ2Zmht27d0NXVxfR0dGIjIxEdHQ0WltbJ2wMBEFg48aNyMzMxP79+/HGG2/A398fP//8MzIyMlBcXDxhY1GGJ2SlBLW1tfjggw8QHByMmpoa1NXVqTz2xRdfxOeff462tjbs3bsXPT09yMzMBIfDgUAggIeHB7q7u9HX1wepVIrCwkK4urpO4N08XhCLxcjIyIBEIoG9vb1G3+np6UFXV9c4j2z8YWxsjD179tBVA1KpdFLGwWQysWPHDmRlZeGf//wnjh07hvDwcMyfPx9LlixBTEwMsrKyIBaLJ3ZgquQYyP9RiZi///3vpKGhIblp0yYSAMnj8UgA5IoVKxSOa29vJ3//+9+TDg4OpFAoJEmSJHfs2EFaWlqS+vr65Pfff086OzuTenp6pL6+Pqmrq0sCIK2trSfjth4L9Pb2knfv3iVv3rxJtre3a/SdwsJC8vbt2+TNmzfJyspKsqamZkpKn4wGcrmcbG5uHrdzawuxWEzGxcWRmzZtIj09PUkOh0PyeDzSzMyMnDVrFnno0CGyq6vrkcaFJ3pWmuHkyZOklZUVWV5eTsrlcvKrr74i6+vrybq6OpLH45F1dXVkSUkJeerUKXLu3LlkaGgoWV9fr3COkpISsqSkhCTJgR9XLBaTJEmSEomEBEB+/vnnE31bjwVaWlrImzdvkrdu3SI7Ozs1/t7Dhw/JBw8ekKmpqeS1a9fIa9eukcnJyWR3d/c4jnZikJaWRr733ntkbm7umJ63vLyc/P7777V6zsoglUrJrq4usrGxkTxx4gS5bNkyUl9fn1y6dCkZHx9PymQyrc+pjqz+51MXurq6sGHDBuTk5EAkEuHq1auYMWOGwjEtLS0wNzfH5s2bcfnyZcydOxczZszA3/72N61q5xobG6dcU8nxQk9PD+rq6kCSJFgsFpydnVUeKxQKkZ6eDplMBhMTE/j6+g57ruQvpSpDkZ6eDmAgd0kikUAsFiM7OxtyuRxBQUHg8Xhje2MTCJFIhLi4ONTX1+OPf/wj2Gz2mJy3srISBw8eBI/HQ3h4OIyMjMbkvMBA5+dLly7hvffewzPPPIN33nlHq+8/SV1Qg08++QQCgQDp6ekoLi4eRlTAgPPz8uXLWLduHfLz85GYmIh3331X6yLfx5Go1C1mqtDV1YX09HTU19ejublZrZO4u7sbGRkZYDKZsLGxQVtbG/Ly8iCXy+ljhEIhfvzxR5SWlqo8D0EQ4HA4MDAwQFBQEORyOWpqarQe+1SCrq4u/Pz8IJPJ0N/fP2bndXBwQFhYGPr6+hAZGYm2trYxO7eBgQE2bdqExMREfP3118jPzx+zc//PZLAXFBSAJEk4OTmhrq4OGRkZ+Omnn5Cfn4+kpKQRuxwvXbp0gkY6dSASiZCXlwcPDw+NLZSOjg5kZ2eDzWYjICAAenp6I35HV1cXPj4+0NPTg66uLkpLS1FcXAwPDw90dXUhOjoaXV1dGkcH9fT0YGZmhubmZri5uT3WyhF8Ph/AQIR57dq1YxYhtbW1RXh4OGJiYvDzzz8jIiJiTBNSDQwMIJVK4e3tDblcPibj/lWSFUmSSE1NRUxMDCwsLGBubo79+/fD2NgYPT09MDc3h0AgwLPPPoujR4+Cy+VO9pCnJGQyGfr6+pCRkYGAgADo6+urPb6zsxNZWVnQ0dFBYGCg0oLsvr4+kCQJBoMBXV1dGBgYIDg4mJ7MdnZ2aGtrQ3d3N9rb2xEdHY2+vj7s2rVL4+ggMGDFNjU1oba2FnZ2dtrd+BSCh4cHnnrqKSQnJ4MgCKxdu3bMzm1lZYXdu3cjOjoacXFxeOWVV8as001RURE6OzuxcuVKlVt4bfGrI6vMzEyEhYWht7cXu3fvRklJCfLy8vCPf/wDv/vd79DV1QUTE5PJHuaoUVlZCQ6HAysrq3G/Fo/HQ1BQEDIzM5GRkYHZs2erncxcLhdmZmZwdXVVWbLx5Zdf0iHvWbNmYfny5cMmMpPJhFAoxJkzZyAWixEeHg5ra2utxm5iYgJTU1OUlpaCJEmtiG4qgSAILFmyhF4IRkNWJEni+vXrcHd3H1Y5YWFhgT179qCrq2tMW3LxeDx4eXnh/PnzY3bOXw1ZkSSJ6OhovPHGG/jnP/+J0NBQpeb/VCYqys/CYrFgampKWyYtLS2or6+HVCpFZ2cnBAIBLC0tFV5ykUg0LlrpXC4XDg4OKCoqgkQiUTuh2Ww2vL291Z5v6dKlkMlkqK+vx71799Df3z9se2Nvb4/MzExYWlrC0NBQLVGpsvYIgoCPjw/y8/NRVlYGmUwGR0dHlSu8VCpFR0cH9PX1p4zm/GAwGAwFP542EIlEyMrKwr179+Dl5QUdHR3MmTOH7sNoamoKU1PTsRwuDA0N0draOmZWFfCYkhVJkujt7UVeXh4MDQ1x9uxZ/PTTT9DT08O5c+cey4YCMpkMOTk5Ct2HeTweGAwGuru7oaOjAw6HAzs7Ozg7OytMgJycHJw7dw7h4eGPpJHU1dVFvxB8Pp8me+p/79+/DysrK1hZWY0qynb//n3w+Xx4eHiAJEkYGBggOTkZ7u7u8PDwoI/j8/kwMjKCSCQCn89Hb2+vyq26m5ubyusxGAx4e3ujsLAQlZWVIElSZVSyv78fOTk58PT0nHLdcoqKipCZmYmgoKBRfV9PTw979uzB8ePHUVFRAaFQiMLCQkRERIyb0oO1tTV0dHSQmpqKmTNnjsk5HzuyunnzJt566y3cvXsX/v7+6OnpgZOTE3744QfMnDnz8ekuOwgymQzZ2dno6OiAh4cHDAwM0NLSgs7OTgADP7yLi4vSe8vMzMSpU6dgZ2f3yBMvLy8PIpEIwABhWFlZgSRJ+rzNzc2Qy+Voa2tDSEiI1vfY3t6O7u5uWFtbw8DAAEuWLIGLiwscHR0Vji0oKMCJEyfg6OgIBwcH1NfXj1oLniAImgirqqogEAgeu3QGagEbWmeqDfh8Pnbv3g1goGsR5VgfL6UHgiDw/vvv45VXXsGtW7fGxFp9rMIk0dHRCAsLw0svvYS+vj5kZmaipKQEly9fxpw5cx5LogL+G3b38vKClZUV9PX14ejoiICAAAQEBMDd3V3pvaWlpeHkyZNwdHTEzp07H1lh1MvLCwEBAXBzc0N3dzcKCwtRVFRE+5iys7NhZmY2qnQGJpNJ15ZlZGTQRDyUqICB++Lz+di2bRsYDAZkMtnobwoDz5eqx2xqahr2uUwmo8emSfQSAHp7e5GYmDgh6RGUZTua564MVlZWtNJDZGQkmpqaIJfLIZFIxuT8FMLCwuDp6QkzMzNazpkgiFGnMzw2ZFVfX48PP/wQX3zxBcLCwqakX2G0YDAY8PLyovOw2tvbIZPJlOYVlZaWIj8/H9evX8fZs2fh5uaGHTt2jIkGkaGhIYyNjWFjY4M5c+Zg1qxZmD17Nvh8Pu3rq6+vR19fHyorK7U+f39/P4RCITgcDjIzMxW2vINBkiT09fWho6MDPp+Purq6R5ZO0dHRgZGRERobGxVq7qRSKbKystDe3g4PDw/aj6PJvTx48AAtLS2PNC5N4O7ujp07d47pnKeUHhgMBqKiopCeno6MjIxHXhgGg8FgICYmhlYZCQkJwXfffQdPT8/RnW/MRjaOkEgkWLlyJUJDQx9reRV1BdF9fX1oa2tDRkYGMjMzcfbsWcTGxqKhoUHhuDNnzuDIkSO4ceMGPD09sW3btjHLbB4MNpsNXV1d6OjogMFgwM/PD56ensjIyIBAIKDbdWmz2lNlE4GBgdDV1UV2drbShEQTExM0Njaiv78fPj4+MDQ0RH5+Purr6x/pnuzt7SEWi5GZmUlbEXl5eejs7KStWk1BWZtjZe2og6GhIaysrFBeXj5qJ7syUEoPVlZW6O7uBpPJREtLC92ya6xw48YNhIaG4vjx43jxxRdH7XCf8mTV0dGBl156CZaWlvjLX/7y2MqG5OTk4IcffqDbIQ3Fw4cPkZWVhY6ODjQ0NCAjIwPLli0b5uzdsWMHXnjhBbz88svYunXrhG19CYIAl8sFQRDw9PSElZUVqqqq1BLwUFCRISoPi8vl0r66wfDx8aEVKlgsFvz9/WFsbIzCwsJHUlcwMTGBj48PhEIhMjMzIZfLIRQKIRAItKou6O7uRlRUFH3OiUB7eztqa2uRn5+vEWGVl5fj2rVrIx5nYmKCadOmQS6X48yZMzhw4ADOnj07FkOm8eDBA5iYmGDhwoWPdJ5JJavBD72pqQknTpxASkoKent70dXVhYsXL9KO1cOHDz+2RAUAnp6e8PDwwIULF3Dx4kWkpqYiKysLwMBzkEqlqK+vh1AoxPz587F//37MmTNn2HmotAVzc/MJfx4U2RAEAXd3d7BYLPT09Gj8fSaTiaamJkgkEnA4HAQEBNA+usHg8/kgCAIlJSX096h5QAUARgszMzP4+fnB2tqalu3RlvC5XC5YrIHYlLbWpaYYep+2trZwcXFBc3MzcnNzRySsyspK3Lx5c8SxCYVCNDU1gcFgYPv27di6dSvmzZv3yOMfDIFAgI8//hi1tbWPpM81adHAixcvYuXKlfDy8oJMJkNjYyNmz56NqqoqlJWVAQCmT5+OP/3pT/j9738/WcMcM7BYLGzZsgUnT57EvXv3APz3xaEcjiYmJkqTJKcKGAwGRCIRWlpawOFwIJVKIRQKIZfLNSppWbhwIU6dOoXU1FSEhISgs7MTjo6O9ItP4cqVK2Cz2QoRR4pQampqYGho+EjBBMoaSk9PB5PJHLHUqrOzE11dXXQmPBX+NzMzw82bNyGVSrF06dIx+926u7vx448/Ijg4mO71Bwxk9zMYDBQXF6OwsBBeXl4qzzHYKa9qXFQpE5/Ph729Pdzd3TW+h+rqavT392scpeVyuXjuuefw29/+FtHR0aN6VhNOVnfv3sWf//xnFBUV4cyZM7C3twdBEPD29qYnJEmSkMvlj210TxWYTCY2bdqElStXAhggMJlMhp6eHlhYWMDT0xMEQaC1tRWVlZXw8fFR+VLK5SRIEmhubkJZWSm+/toeq1Y1Ijw8eNzGP3PmTBQUFODHH3+kV9+uri5kZmbCz89vGOkMRWBgIE6fPg2RSIS+vj7k5OTAz89vWEJiX18fBAKBQra1np4ezM3N0dzcjObm5hEJRhNIpVLw+fwRy63OnTuH8vJybN++Hc7Ozjh9+jTMzMwQERGBa9eu4c6dO5BKpVi5cuWYEBaPx4OjoyOuXbsGqVSKRYsW0ee1sbFBe3v7iNthKjdP1Xg6OjoQHR2Nnp4ezJs3D+3t7fQ7p0ki5+3bt9HR0TEiWcnlcsTExKC/vx9/+ctfsGrVKkREROC7777TOoVkwraBJEnizTffxNatW7Fr1y6Ul5dj7dq18Pf3h5+fnwIxEQTxqyKqoSY7j8cDj8eDjo4OWCwWpk2bptCqvb+/H11dXSpN+L6+Pnz6aTamT+/A7dul0NHRwdy5DLi4jK//xNzcHOHh4ZBIJLh9+zasra3h6upKE5amoe/RvtBUUe9YbLuamprQ29urkYW2bt06GBsb4+DBg3Qqh5OTE3g8HtasWYNZs2YhNTUVZ8+eHZOxMRgMbNiwAUFBQbh16xYuX76scF4GgzHidRoaGoZVOVDo6OhAZGQk+vr6EBYWRufRUQGQkpISVFRUqL0Gk8nUSMn0zJkz+PDDD3H69Gn4+/sjICAAMTExuH///ojfHYoJIavCwkK8+OKLuHjxIrKysrB3795xiWBNNiorK2k/C4WWlhYcOHBArSOaxWIpnVS9vb1Kjx/YIhlj1y4pfHwcEBgYiFdescbcueOv7W5hYYGwsDCw2WwcP34cJEnSTuuMjAwUFRWhoqJCZQicegHUvQjbtm1DaGgoEhMTkZOTM+b3QJIkGhoawOfz1epsUdDX10dERATMzc0RHx8PsVhMpzgQBIHly5fjqaeewsOHD3HmzJkxGSODwcC6deswY8YM3L17F+fPn9e4W7ZcLkdjY6PKTHw9PT1YWFggPDwctra29Pmo88tkMlRUVKCqqkrl72Rubo7W1lbcvHlT7VgyMjKwZcsWnDlzBpcuXYKbmxvi4+NH5Wx/pG1gR0cH7t69i6ysLLBYLDQ0NKCsrAwGBgawsbEBl8vFmTNnUFlZiV27duHKlSsT3shxItHZ2TnMumAymZBIJPjPf/4DDocDPp+PjRs3Ql9fn46wDYWpqSn09PSQk5MDf3//YeJoLBYLCxfaQdnv3dLSApIkYW5u/kj30tzcjJSUFMyZM2dYxMvR0RF79+5FdHQ0YmJi6MJlqVSK7u5uEASBwsJCLF68WOmiNPhlU0ZqOjo6kEgkaG5uRlpaGqRSKQIDA5V+fzSg6gYBqLXgc3NzkZGRge3bt4PL5WLnzp34+uuv0d/frxAUoIqN+/r6kJaWhpUrV45J3htBEFi1ahVYLBbu3r0LLy8vODk5gcViQSwWo7W1VWlNX2trKyQSiUqy0tHRQWhoqMJ1gP/6tzw8PNDe3o7MzEwUFhZi2bJlw575/Pnz0d7ejmvXrkFHR0dlSY2hoSHdUs3Pzw9+fn6jehbAKCyrtrY2vPXWWwgMDISdnR0++eQTNDc3o6amBqampti2bRvmzZsHDoeD9957DykpKaiqqsInn3zyyC/QVAdJkpBKpQovoLGxMXbv3o0ZM2bA19cXXV1dOHDgAD799FMcO3ZM6Xk4HA6di5SVlaVSHE0ikaCsrExhm1lbW4uqqqpHvpeuri6kpaWpjPYZGhpi9+7dsLe3R0tLC+rq6lBUVISioiI0NDSAJMlhRDR4lR6c56RsO8Fms7Fz5044OTnh1KlTGGvFWiaTOaKrob29HSUlJfS49fX18corr8De3h4nTpxARkaGwvEUcYxlCzGCILBs2TLs2bOHzsJ3dHQEj8dDaWmp0qgglahqYWGh8TUAKFhuLBYLBgYGaGxsxMWLF4ddh9qqmpubq+16s3LlSpw8eVLlLkEbaGxZNTc344UXXkBSUhJ27NiBAwcOYNq0aSpXkJycHLz77rvw9fX9VW75lMHS0hL5+fnIycmBr68v/TIYGhpixYoVAAZkUYqLi8FgMMDn89HU1AQ9PT0YGBgonIvKRcrMzER2djZ8fX2HraJtbW2oqqpCT08PfHx8NPJlaAqKpNRZMQYGBti1a5fSz1RFCKnUB2p7Z2FhofIabDYbO3bswNGjR5GYmIjFixcDePT0BW0x+JlS9xwfH49Tp04pbCUdHR3BZDJx8OBBhIWFjaj/pSkIglCQuKGEDWUymdoorCYRWqrWc+jxLi4udCkRQRBISUnBrFmzFH4rSpNMXda7p6cnFi1ahPfeew8fffTRiONRB43IqqysDH/+85/h6OiIqqoqjUoSfH190draOqb6zpOJb775Bo6OjlizZo3KYwQCAeRyOQoLC2mCGRohMzExUTCZb968CRsbm2FkBfzXwsrMzEROTg68vb0VrFOBQACpVIri4mKkpaVBR0cH/f396O3tRWVlJXp7e2mxO+C/DtSh/21sbAxXV1d6slZUVCAxMRHOzs6oqqpScLYaGBjAx8dn2ALU09OjEN1R9qJQeuzAQFTL2dl5ROumtbUVq1atApfLhVQqBUEQqKmpgYGBwbjLRA+1OCiw2Wxs2rQJn3zyCRoaGmiysrKyQmhoKOLj4xEZGYnw8HA6KDDWYLPZKo0A6tkrs7pSUlJgbm5Oj7mzsxOtra1wdHRUOJ+JiQlMTEzQ09OD48ePw87ODoWFhfDw8FAgLCaTOWLO1+effw4/Pz+sXr1aIRVDW6il3sbGRmzfvh3Tp0/HrFmz8Nlnn2lcOwUM3PDjLCk7GCKRSKPMYSsrK3h5eaGjowNZWVkjRkxGsoSoVVRfXx+5ubnD6ulsbGzg6ekJBoNBN0wABjKYGxsbwWAwwGKxwGazoaOjA11dXejp6YHH40FfXx9cLhd1dXW4efMmbty4gbS0NBw9ehQODg6ws7ODrq4unYgqEAjQ2dmJlJQU5Ofno6WlBd3d3aipqcH9+/fpglhVNX+DweVyNYr4/vDDD7h//z4MDQ0hlUpx584dkCSJ/Px8rRJSxxpsNpsmzsHzwtnZGbt27UJ3dzciIyPR0dGB3t7eCe0BqIqs7t+/jwsXLtDJyAAUFixlyMvLo633hoaGYRn0mpCVQCBAXFwctm7dSvuvRgO1llVjYyMOHz4MCwsLbN++fcomK04ERjK5B0MgEIAgCPqHVhdxosjCyspKZb4PRVjJyclob28fNrEsLS1pZ6pcLkdDQwOKiopgYWExohgeMLDF7+7upv+XappBlacMJhWBQIC6ujq0trYqFBcbGxvD1NSUtsQ8PDyU1toRBIGGhgYFh7km8PT0hKmpKXp7e5GcnIxNmzaNu9SLKssKGPhNFixYgOvXr+PEiRPYuHEjPT/s7e0RFhaG2NhYREVFYfr06dDV1YW/v/+EuERUkVVOTg4sLCywfv16+vPS0lK6BKqgoACFhYVgMBhgMBh0p6Dg4GDweDwIhUIAA8/D29sbBEHQqhjNzc1gs9kqd1LLli3Dxx9/jHnz5uGnn37CunXrFD5PT0/HX//6V/X3pe5DLpeLxYsXo6mpCX/+85/H1HE4lVBVVTVitblMJtMq94vSfq+trVWbf+Tt7U1rPakDld4gEonUWmMMBgPW1tZ0aFmTrijm5uZ0B5/a2lo4OjrC29tbwe9GwdDQEF5eXpgzZw4CAgLg4+MDf39/eHp64s6dO7C2tqbr+IamazAYDKxfvx7FxcU4duyYRvOJsii5XC7YbDZWrlwJBoMxKtUHbaGOrABgwYIFWLJkCXJycnDs2DGFOWRra4uIiAiIxWIUFBTQ9Yhj2aVGFSiyGhyYkcvlEIlE0NPTU8hup9RfJRIJOjo60Nrait7eXuTn56O4uBizZ8+Gvr4+9PX1kZmZCT09PTQ3N9O/HeWELygoGLFONCIiAqdOncK+ffvw1ltvobGxEQkJCTA3N8e0adOQmJio/r7Ufejq6oq9e/ciLCwM9+/fx+HDh0d+Uo8ZcnNzERkZOWK+CJfLRUFBgVJSGez/GQxHR0fIZDIUFRUhOroQzzzTjBs3chWOoXw4mlitVlZWaGpq0qgejbp2QUGBRrIffD4fmzZtwqZNm+Do6AgLC4sRnbfGxsYwNzeHiYkJSktLcfXqVRw/fhxeXl7g8/moqKhQ+E5paSk4HA5WrlxJN4MYKUq0efNmdHZ2Ijd34Lnp6OjAzc0Nubm5Y66/pArqnvVTTz2FFStWID8/H0eOHFHY7lG6Ue3t7SgsLERPT8+EEJatrS0sLS1x9uxZ2kmelJSEpqYmOmUDGIhaUsmdaWlptJKqQCDA8uXLsX79enA4HNjb2yM4OBivvfYavUugrLZly5bB2toa3d3dtEaZOsyePRtpaWkoKSmBh4cHNm/ejJaWFnz88cdKtc0GY8R9zc6dOxEdHY0//vGP+OCDD0YczFRGc3PzsKTNM2fOwNraWmnR8GBs2bIFYrFYaZ+1yspKFBUVDZvUPB4PBgb8XxQ2RTA2JsHhKG4DNE30AwYkfK2trVFdXT2ijAePx4O7uzva2tqQk5Ojkb/Ny8tr1JpJ3t7eWLVqFQoLC3H06FHo6elBLpcrPJPGxkY0NDSgt7cXQUFBMDU1xcWLF9ValVT4ffD4p0+fjp6eHvzwww84ePAgkpKS1N7faGVVqGDGuXPn1B43a9YsrF69GkVFRYiPj1cgUUo3qru7G/n5+ejt7UVGRgbtWxwPsNlshIeHY9asWbCysoJcLkd6ejqcnJzoLb5IJKL1q8zMzMBgMNDf309XJbS1taGxsRGOjo60jLaBgcEwa1NXVxdLly4Fl8tFUVERsrOzRxyfubk5jh07ho6ODsTGxoLD4YAgCGzevFnt9zT2fmdlZU2I0Jg26O/vR0dHh8aCYRkZGQrWIUmSEIvFcHV1VSi7ULaSWltbIyIiAlKpFJGRkXT4nKpjrK+vp3W+qRyjY8fa8dFH5ujvZ8DdvQc//miO2bPdFc6rDVkRBEH7gTRx2FITr729XWONIolEgtTUHFRUaL/lDwkJwdq1a+mOQlKplO7XCIDeOhYXF6O3txfm5ubg8/lITU1VaWGxWCzo6ekp6Ho5Oztj06ZN4HA46OrqQnJyMo4fP650HtTX1yPm/ffRrEKaRx1cXV0xbdo0jbLoZ8yYgfXr16O0tBQHDx5UsJ7MzMywZ88eNDY2QiaTQSwWIz09fVxTMPT09LB06VIwmUxUVVWhr68PNTU1qK2tBTBgodrY2CAoKAi+vr5wd3cHSZKwtbWFra0tfH194enpOczaoeapsgXA2NgYJ06cQGZmpsbj3LlzJz7//HO8+eab+PTTT9UeqxFZVVZW4uOPP8aRI0c0HsREoLS0FF9++SWam5s1On6o34ma3IP/VlxcjEOHDindYlhaWmL16tXo7u6miZuSzOVyueju7oZUKsWNGzdw69YtVFdXgsEAmEePQScrCzU1NagqL0fduXOoTE1FaWkpPam1DV5oejwVOlc2uUiSRHFxMaqrq+m/iUQi/Otfhnj++R50dmqfyBccHIynn34aQqEQdnZ2aGxspFU0SJJEbGwshEIh3SZeV1cXIpFIpaUxuOnDYALw9fXFs88+ixdffBHLli1Dbm4uPv30U3z22WdISkqiCZLDZiPw0iXU79uHul9eVG1ApZRQzmV1CAoKwsaNG1FZWYnY2FiFezIxMQGTyYRIJIK/vz8kEgkyMjI08ttJpVIFfXxtUV5eDmDA2o6OjkZ1dTU9bykZZ8odQe0azMzMlGbA6+rqwsrKSiFQYG9vD1tbW/D5fEybNk3ruRwVFaVR+Y1GeVYODg7Yu3cvLl++jOXLl2s1kPGEMrIZ6XhlZCUSiXDw4EGIenow4+efAUdHfFxWBkNDQ7i4uNCNGmUyGf0dsViMzs5OyGQymgio6AjV8snNjYXf7NJBy448iMx4+M9//gOmRIKdcXFICw5Grp8fHCwtEdzcjKJfZIx1y8vBLSgAuXUrvJSUJmhjiQEDk4vJZKKkpAQ8Ho+enCRJoqioCPX19ejq6kJ1dTXmzJkDAwMDvP46gTt3ypGb242AgACto24BAQHw9/cHQRC0vAoAuoRm4cKFkEqlkMvl0NXVRUZGBi2wpww+Pj5IS0tDWVmZUkncOXPm0D6y7u5uJCcno6+vD2vWrIGpmRmYP/6I4/HxaIqJwc6dOzVuelpXVweCIKCnp6dx3pS/vz9YLBYSEhIQ88v1qGfu7OyM+/fvw9raGgEBAcjKyqIbyKpTfujr60Nrays6OjporS/gvwm21H9TiqJDQZXR7NmzB1FRUfS4HBwc6GOovKqSkhIIBAL09/ejuroaEokEurq6MDMzA5/PB4/HU+hERF3bxcUFBEGgurpaa0HCffv24Z133kFkZCTd1EIZ1JIV9WI0NTUhOTkZ//jHP7QaxHhjNGRFbdso57ELgwHZt9+i5pf9PcPMDEZWVjAwMICZmRnu37+vtEI8NjZW4f/PnDkTHA4HTCZzmOnc9Pnn6CgsxM7AQBAkCc6sWZhlbQ1XBgONf/kLzEpK0BEYiHuZmbC7exfTHzzAQbkcbvn5cLt5E2J9fdTPnIng4GCFAlpNQIncZWVl4eHDhzA0NKQ1qPr7+2FnZ4f09HRcvnwZUqkUc+bMgY+PDhwcbJGXl4ejR4sQHOwOPz/tCIsaH4PBQF9fn4KlSjl1u7u74eHhgdu3byM+Ph4bN26kdeAH+84oElNnhfj6+sLX1xckSSIpKQm3b9+GsbEx5s6dCyMvL2x6/XVER0fj/ltvgRkWButfZHrUgdrSb9myBfHx8Th+/Ljal4kCJXd09OhRREdH4ze/+Q2tZ0Zlvq9du5ZO+KUIS9WiYGBggMDAQBQXF9NJvkOTe0mSVPoetLe3Iy0tDUZGRnSHG6oD8/r16+Hj40MvsmZmZmhra0NraysOHjyI7u5uTJs2DQYGBqitrYWBgYHK9AuCIODs7Iz6+nqtS2vCw8Px8OFDlSq6FNSSVVtbG62r9Ic//GFEB9hEg3oBNCUrBwcHpKenIyEhAZs3b0ZHRwcM8/PhXFqKGR99BFMPDyA8HD6DvpOXl0crKTKZTIX/pf5RTTubmppw7949sFgseosDADpGRug3M4OOjs7Aqv5LrztbAP1xcWitq4OsoWFg5X7xRRAAAq9eRUFhIVxyciA2NkaxiQnqkpOxNDsb3J07caGuDnKpFOsWLIDhoBVyMHp6epCRkUHXLAL/lQ5hMpn0Suzk5AQmk4lr164pSOHq6xvi4sUdOHeuAz/+KAefPzzLfiTY29sjOzsbGRkZtFgcQRCwsLBAVVUVGAwG9uzZg+joaNqfyOPxEB4eTjvXqURCTYqDqaLixsZGJCcnIzg4GLq6ugO1jDt2oCYuDgVffAGRu7va/DeSJGnHv62tLby8vLRKl/Dw8MD27dvR0tJCb7Go8qEjR47g7NmzkMlkCAwMREZGBrKysoaVswyGgYEBpk2bpvH1KZSVlaG3txc7d+6kzxMREYG4uDgkJCQgOTkZCxYsoLXUAODo0aOQyWTYuXOnQlIx1b8wICBAJWGNtuTrT3/604j3p5asOjo6wOFwYGZmNqZdL8YCQqEQN2/epLWhRoJcJoNAIICjgwM8/t//w/XvvsPNBQvACwrCnA8+gKmSidve3gEnJyeNEivLyspQVlaGjo4OpKenIy0tDWFhYeByubCxsUFXVxddeDrY/OYYGoIjlQKNjeBwOOBwuSBJEitXrcKatWuBX1RSp/f04GZMDGQFBZDKZLC0swP55Zdo+PRTJH/wAbz9/GBpaAhSLgeppzcQPGhshDGbDQafDxaLhZqaGrS3t2PRokXD9MM2bNgABwcHOiucwWAgJycHM2ceR0iIP9LTpXB3d9e6bb2JiQn8/PyQk5OD3NxcOvLj5eUFgiBQUVEBuVyOvXv3oqqqChKJBBcvXkRUVBTCwsJgamqKS5cuwdnZedj2QxUIgsCiRYvwww8/4N69e7Q/xMDMDPYnTuBGQgIeHj+O/fv3q0zSbGtrQ0tLCxwcHOhjtH0JXV1d4erqqvA3FouFrVu34tixYzh//jykUilsbW3pZhBjreNGEdDgd0RfXx/PPfcccnJycOPGDRw5cgQCgQALFiygUxh2795NR0MzMjJQV1cHFosFuVxOa5lRc3swwRIEMSqysrCwwKlTp9Q2KFbrYO/u7sbrr7+ORYsW4YMPPnjkdkhjCco/sWnTJrUKlWlpabi2eDGyp03D999/j8qqKnTOng2j1asHQuC9vUgtLBz2gO/d60RERB8ePCij/yYSiejt0lA4OzsjKCgIurq6WLFiBVpaWmglRqrVloWFBbq7u4dda6gfqqSkBJmZmQrX4fF4WPXii/BOTITLmjVgMBjwfP11VPj54UF6OqKjo5G9ciUy16+nHc3l27ah4u9/B0EQ9EtjYmKi1NnOYDAwbdo0zJs3D/PmzcPcuXMRHh4Oe3sWcnNvoaenFx9/3IHERO2TMU1MTODv7w+xWIyAgAD6Xgc3nqitrYW7uzt8fX2xZ88esFgsREVFob6+HnK5HK6uriMqkQ6GtbU1vLy8cPfuXYWyHJ6VFcL37kVoaKjabHJqcaZe2NG+hMpAbQl9fHxw+fJlOh9NW31yiUSitA/iYBgbG8PLy0vh2R09ehT/+te/cOvWLQQHB2Pjxo3o6enBqVOnQBAETVQkSeLatWs4deoUMjMzkZaWhtzcXPT396Ourg4lJSXD0nge5TkFB6tXuVX76zs4OGDWrFlobGzEZ599prHkxESAmkwjTWCBQABi3TqwhEKsW7MGnp6etDMz8BfHY2pqKgICAmBtbQ1gYFXt6sqDg4M93N3/2568rKwMd+7cQVNTE7Zt2zbs2lTkSCAQYMeOHTh06BCioqIQHh4OfX19eHl5KZWMHUpWhoaGtOSKMquO9ge5u0OyYwe4+flYu3Yt5GZmIJhMrPolIqNvawsun08X/HK5XPT29qKlpUUjC4lqOz5QXtOP7GwuWKwOuLgUqO391tDQQOd28fl8zJo1C0ZGRvDw8FCoLaMaTzAYDLrGzs3NDSYmJtizZw+++eYbrcLgQ7Fo0SIUFRUhJiYGYWFhtHXB5XJHlDIebzCZTDzzzDNgMpm4desW5s6di7y8PJAkqVGBdn9/Pw4ePIjm5ma8+uqrKvPjnJycaGkZChYWFmAymejo6MDly5ehp6c3MF/09bFt2zaFDs3d3d0ICgrC2rVraT9veXk5EhISEBISgqamJgU1kKCgoHGrB1b7phsbG2P//v3jcuFHBaXpc/z4cbz22msq9/oSiQRdQUHw9vYeRraU0Nj9+/dpK+bevXb09GTD2JiLzz6zVPCTeHt7Y926dThz5gyOHTuG7du3K5xvMOk4Oztj586dOHjwIL766ivahJbL5fDx8cHatWsVNOep7wEDk6murk5lON/U1JQWNeNwOHQZheO+fYoH/pIASEFfXx89PT10LaImYLFYsLe3h7098PPPbcjNrUJtLRsSiQx+fj7Djm++dw9lb72FlHnzAF1dWFtbY9asWQCglCAoq4/BYKC6uhokScLd3R1GRkbgcDgoLS2Fl5cXvZBoA3Nzc+zYsQPx8fEKi4YmMDMzw7x58xTq7Ma6iw2lCcVgMHD37l0sWbIEpaWlKslKLBajqKgIMpkMDx8+RE1NDTZu3Kh1Iu+CBQsADNxTSkoK2traIJfLERQUpKDqQRAEXcM3+P1ycnLCa6+9RhfLOzk5/dc/+4hdwdVh0rrbPCoMDQ0xbdo0JCcn0w+yrKwMEomEJgsWiwU7Ozu0tbWhpKREqWVIWUO3bt1CUNBKvPoqgZUrHfC3v9ko3SZMmzYN9fX1aG1tRUZGhkJBLjWZKZJxdHREREQEMjIyaOcjlTksFovx1FNPgcVigcvlwtnZWYEYGQwGuru70dvbO+wlZzKZ8Pf3R1tbG/T09JCfn48rV67g2WefVfvMqIk02mah9vYm4PNn4dKlNHz6qTFeeqkE69cr+mQarl0Dt6MDr/3mN2j+pcXY4HFTUjIdHR100Sv1exEEgaqqKsjlcnh6esLHxwfV1dWoqqpCcXExnn/+ea0FHF1cXOhFQxvZlsHWQVlZGbKzs+Hu7q7mG6MDVS85a9YsdHV1obGxcZj13dvbi5SUFKSmptK5VgwGA5s3b9bIn6ru2rNnz1Z7jCojgMPhwMbGBk1NTfR7MN5d0h9bsgKGKyEkJCTQYVNHR0e6rbqBgYHKsLeFhQXmzZuHW7duYfr0FuzeTWDHDie1/gwWiwVdXV309fWhr68PDAYDOjo60NHRgYmJCSorK6GjowNra2vY2NgodGkBBpJLL168SLfgmjFjBlatWqUwMZydnZGZmYmSkhL4+/sPGwOTyaRfXAsLC42af1JNSinnOQUbGxuFHKfy8nIkJydj/fr1wySBjIyMMHv2dJw+3YHq6uGWX8usWbjZ3493HB1RnpU1LLk2KysLc+bMQVZWFvz8/OjrUoTFYDBo/SyqaLmpqQnfffcdamtrR6U26+joiF27diEuLo4mLG101qik1meeeUbra2sCgiBobTKpVIqSkhLaiqqtraXz+by8vOjCYkrqZzKhr6+PgIAAhfSL8RzTY09Wg/1GVHi2vr4eiYmJiIqKgqWlJfh8PkiSRHV1tdKEQGprYGNjgxdf1FMZkaFyeFJSUuDu7g6hUIgvvvgCzs7O2LZtG8rLy+Hl5YX8/HwUFRXRzTCH5sYEBQXB3t4eQqEQpaWlSE1NhUwmw9q1a+lEyra2NpiZmUFfXx8SiUQleTY2NoLP52uU3WxpaUkXQTc3N9PbQg6Ho0BW3d3dKCsrU1nSY2vLx7PPpivkk9H5PjIZoKYpRH9/P3R0dMBkMpGdnY2ZM2cqbB0cHR3BYDBQVlYGNpsNNze3MZFVsbe3R3h4OGJjYxEZGYmIiAit+gEQBDEmuurqYG1tDZFIhOrqarqmk/Jhbdq0adSy4C0tLcjIyMCCBQvGXKKGz+crJLjOmDFDq0CINnjsyWqwZUX5NaytraGjo4NLly6hs7MTPT09CAkJQV5eHtra2uiI1ODzAAMWk7rQ8b1793D79m34+PjAwsICcrkcc+bMofvZxcTEwNPTE8888wyam5thaGiI4uLiYdIZOjo6tEPfzc0NHA4HycnJ6O7uhqmpKR3ep1BcXAwjIyOw2WwF0qOE7qytrelehOpAEATmzJmD6OhoiEQivPDCC7h9+zb6+/sVth4jZckPJqGKmBhUR0Xh6i99BLfGx2OZqSnw7rvDzkF9j8FgwMnJCTk5ORCLxcP8HPb29hCJRKirq1PoD/ioemo2NjYIDw9HTEwMfv75Z4SHhys4k1VhonTcCIKAUCiEUCikf+uFCxfSPqbRoqysDCwWC5cuXQJJkrC0tERwcPCI99XR0YGenh4QBAE+n6/S30cRVldX17gRFfArIStlETYqoxkYUEhsaWmBWCxGYWGhSrIaKceF+h6VvEf1y+vq6oKTkxPc3d1RUFCAw4cPw9HREc3NzXRuElUa0d/fj7y8PHqfz+Vy4eXlhcLCQgiFQlhaWqKnpwfFxcUgSRIcDgeGhoYQi8UKpRX8X3KnBAIB3N3dNc7PoZoBUCQvEAhQU1OD0tJSumRiZLIi8H//5wk3NynWVB6Gpa4uFsyfD4LBgFRHB1a/OIgZDAaEQiFEItEwfwY13vb2dqU+JAcHBzQ0NKCiokJll5bRgJJtiY6Opi0sTSyW8WgRPxjUFrC8vBxSqRS6urrw8/N7ZKICBgrM7969C2CAgM6dO4fW1tYRu383NzfThc8MBgN2dnZgsVgwNzcf9nsaGBgolebWBiM948earAQCAdLT03HhwgWFbriUfpCvry/09fUxY8YMpKeno66uDl1dXcNqBKlQ+kghVy6XC1tbWzx48AByuVyhtvDq1at0qkFBQQFKS0sBDDh4+Xw+HQmUy+VgsVgwMTHBvXv30N/fD6FQCD6fTxeDzp8/H2vXrgUw4Fw9d+4c6uvraX9TbW0t5HI5dHR06CiVk5MTHWEcul2hXgQA9IpNPSsXFxeQJImamhqQJAlXV1f62VRVVSndKjGZBFavZoLNroP+1jfgExQEHYpwBr1cDg4OyMjIoLfHg0nQ0NAQZmZmKC8vR319PR0xpED5/GpqasZcx5+SbYmOjsaxY8fw4osvqn1pvb29lba8Gkukpqbi8uXLAAbaxAsEArrrtSaQSCQ4ffo0XRVA5cxRmD17Np0OM3fuXNy5cwcymWyYr3QwnJ2d4eDgAKlUivz8fDqDv7q6elQ1oyPhww8/VPv5Y01WISEh6OjowL1790CSJP3gpVKpUkVNfX19NDQ04NixY9i8eTP9UlKko4qs2trakJ+fj4CAAOTn59OrFIV58+ahra0NCxYswIIFC+gaxNu3byMtLY0u16H+UYmibm5u0NXVpbXq+Xw+XQhLgcvlDitzamxsxP3790GSJBgMBqRSKTIyMpCXlwdgoE377NmzaSJra2ujlSlYLJZCU1UqdYDSE6cKVW1tbXH27FmlaqEA8NJLfNy92wVXN/f/EtUQ8Pl86OnpKfV9UWoKN2/ehEgkwo0bN4ZZEfb29qivr0dFRcWY+1rMzc2xe/duyGQyZGRkwMDAYFi2OQUrKyutM/c1RW9vLxoaGmBtbY3ly5fTPqqR2rIPRn9/P+Lj41FeXg5fX18wGAylBG9tbQ2CGOjpOHfu3BH9nFS7Mg6Hg2nTpkEul6Ovrw+ZmZlobW0dU7JKT0/HF198ofaYx5qsCIKgTdm7d++CJEmsXr1awTdCgapRW7hwIZKSkuiaKOC/baNUrTBNTU24cuUKnJ2dsWDBAsydO1eBfDIyMuDo6Ag/Pz96mwUACxcuVCp90dzcjB9++AE5OTnYvn07TE1NUVZWRm8R29vbkZXFR2GhDT77zAw6OookKhAIaMuLgr+/P+rq6ujC1cE97bhcLvh8PhgMBjw8PGBubq5QPkVVzevr69MKoR4eHnSipjKyYjKZaGvj4O9/B/75Txl4POXbUA6Hg46ODjQ0NAyLFDEYDAQHB+PevXtgs9nIy8uDjo4ObXVxOBz4+voiMzNT6VaturoahYWFWLJkyaj8SpS1dPDgQTg6Oqokq/FEbW0tDh48iGeffXbENAJVOHXqFCoqKvD0008Pc3EMBeWSKCgo0IqACYIAk8mkdypjvXj88Y9/xD/+8Q88//zzKo95rMkK+G8TSIIgcOfOHTg6OtKTcHD+FTCwBTI3N8fWrVsVJuZIzSCobSJJknSKwmD4+/vTxajKOihTEIvF9Bj279+PmJgYxMXFAQDd3EEikcDCwgJWVno4eZJESko+fHxsUV3NhL8/DwyG8pdycKayn58fhEIhvW2k/GU3btzAnTt3EBAQAEtLS+Tm5tKRUpIkYWpqCgaDga6uLqSnp0NPT3VklMViQSbzRGVlP1JTu7BokfLImqenJzIzM1FQUACCIODr60sTZU9PD7Kzs+lu3pT/sbq6Gm5ubrCxsaGdusrIqKioCLdv34ZYLMbq1atH7Qgf/D2hUIikpCQEBwcrOPfHC+rE7DTF/Pnz4e3trSBZrA6Wlpb0DkTZM5NIJPjd736Hy5cvQywWg8fjISQkBO+++y4cHBzURkWpuaRNFrtMJsPVq1dx6tSpXzdZAQM/+KxZs3Dnzh1aVxoYCNna29vT+urUdoeq/qcgl8tpxzJJkqisrKRfdjs7O1hYWIDFYuH06dMKZRsUBjckHZo/REEqleLhw4fg8/nw8vICj8dDREQEHj58CJlMhvT0dDx48AD+/v6orq7G3Ll+CA6WobKyGSkpbfjzn30RFlaLnTvZw1INhsJBhQqDs7MzCgsLkZOTAwMDAzQ3NysIF3I4HOjr66OoqAhCoRC7du1S2f+PIAisXMmGuXmW2sREHR0dzJgxg0547O/vR3d3NyoqKlBbWwuCIGBmZoabN2+CIAg888wzKCgooAMMAoGAbk0/9MVavHgx5HI57X9Zt27dqAlrcEJvRkYGnJycJoSsqODCjRs3sG3bNgWL5cGDB2CxWCN2AqKeUXNzs8bpDaqy5EmSxPPPP4+GhgYcP34cPB4PXV1dOHHiBKZNm4aPPvoIzz33nMrz3rhxA3V1ddi6davGkUEGgwE2mz0iYU86WQ1tjjlaDI7omZqawsTEBOXl5bCzs6Od2hQpDUZrayv09fUhk8mQlJQEa2trNDU1gcvlQiKRoK2tDbq6uli0aBHu3buH+Ph4/OY3vxl2fWUdlAeLkLFYLNjY2NB5Tt7e3tDT08PcuXMBDBRxlpWVQSwWo729HdnZ2TA2NoaBgQFcXKyxe3c/PDzKkJ8vx+XLFuDzpXjjDTOVlpYysFgs+Pj4wMfHB11dXYiLi0NXVxc2b95M5zcBAxrnHh4eSqM7/f39OHLkCIKDg39xxrOQlFSDFSuMYWKifGtAOdQNDQ3BYDBQWFiIyspKsNlsOiLa29uLCxcu4NixY9i0aROKiopQUlICuVwOX19fFBYWDsvkJwiClu69desWysvLwWaz4eXlhUWLFmn8XAiCQG9vr0LgYaI6OVGtsU6fPo1Dhw5h+/bt4HA4IEkSLS0t6Ovrg46OzrAFdihqa2tpqehHwY8//ojIyEh8+OGHCpaav78/duzYgQ0bNiAjIwNfffWVUqtbX18fxcXFOHz4sNL6WWUgCAKmpqYjFnJPagfS1tZW/Otf/xrmsB4NBpMVg8GAvr4+Pfmo6J+yFIf+/n5IpVLaId3U1ARnZ2eEhIRg+vTpsLCwAI/HA0mSCAoKUpspTgnd6enpITs7e9jDt7e3h4uLC1paWobp2fN4PPj5+WH69Olwd3cHQRBoa2tDUlISTp8+Dj+/XPB4BAICAiGRmKG4uFujLjeqwOfzERYWBj6fj/j4eFRUVCg8G1Vh6OPHj9NlTTKZDGy2N77+2h75+Zq93CRJIj09nf5dKEti5syZdNOFI0eOwM3NDRYWFigrK0N7ezv27Nmj1KdEEAQWL16MNWvW0C3ItA2he3p6oqSkhBYnFAgEuHz58rDmIuMFSg65oqIChw8fpuepubk5dHR0cOzYMbq7jyqMlSrE6tWr8e677+Lo0aPDPnN3d8e9e/fw8OFDREZGKv3+9OnTsW7dOpSUlODixYsaX9fMzGzEHg+TSlZGRkZwdnbGpUuXFBoCjAZD0w8YDAa9t6bkiEmSRFdXF124CQw4HL29vSGVStHb2wtXV1fY29sDGLCWqBo1yhT38fFBWVkZurq60NnZiY6ODgXzlWr5zuPxkJOTM4ywqCTEofpg+fn5SEpKoiVoQkJCwOPxMGvWLEilUiQnJ+Pq1as4efIE/v53Pn7/eylqaqrx9dfl2L+/AVVVVVo/M319fYSHh8PU1BSHDh1CUVHRiN+pqqpCQEAArKys8PXXX6OrqwqrVzfAxGTkDPrm5mYkJCTAwMAATk5OdPMECjNmzMC6detQWlqKpKQkeHl5QSAQoLy8HOXl5WpfxunTp2PLli3YsmWLWk0kZVi2bBl0dHTQ2NgIJpOJ8PBwmJubIz4+/pE6CGsDf39/zJkzR6FygMFgwNLSEra2tkhISFDbOYbH46Gvr29Y+zNtYWNjgzfffBPV1dU4dOjQsM8NDQ3x0ksvISkpSeU5pk2bBjs7O60kb1xcXOhotipMKlkxmUyEhIQAeHSze2hip6OjI91ey8nJiRbN7+7uRlZWFu7cuUMrQVpYWMDe3h6ZmZlISkpS2tdtsPZ0VVUVHj58iPT0dGRkZCAjI4NWCpXL5XQHZR6Ph+LiYgUyoxIya2trFQirpKQEd+7cwb179xAXF4eLFy+ipaUFcrkcmzZtwt/+9jds3rwZ1dXVOHgwDo6OdnBwcEBHB4nGRmLUvego35mFhQUOHz6MgoICtceTJAk2m01bICkpZ7BkSTeamwsU6gB7enqGddQxMTFBYGAg9uzZQ/9OQy3dadOmwdLSEp2dnbTmlaWlJSorKzVqSz8aUIEIClwuF+Hh4RAIBDhy5AhdwzneGKyPT42LIAhaL/3EiRMKrd8Hw8HBAQKBABUVFcOIvaenB5GRZcjJyUVxcfGInZH09PSQlJSEP/7xj3jrrbeGLYS+vr64c+cOuru7VZ6DyWRqJdi5fv16/Pzzz2qPmVSyomrtAIy4co4EdVnoy5YtQ0BAAG7cuAEmkwlfX19wOBxkZ2fTL4C3tzfdmWRoKyUK1tbW8Pf3R2lpKQoLC2FnZwc3Nzd0d3ejsLAQeXl5yM7ORllZGaqqqmBoaAhbW1uFF4HNZtN1hYO3lOvWrcNf//pXvPXWW/Dx8UFTUxNNsJTAmo+PD7Zs2YK6ujrExsbC0tISf/ubC+LjBY8UdtfT00N4eDisrKxw9OhRtSsctUXhcDi0g7utzQjnzlmgtVVCH3P06NFhPRaZTCZWrlwJAwMD1NTUqNSV4nA4aGhoQFdXFwiCoC3diWpqCgw8k7CwMFhbWyMhIWFc+/xREAgESvWgOBwOQkND4ezsjPPnzyvV+BosZlhZWUnPHQC/tHeXQigUora2Fv/+dzk6O9UTlp+fH9LS0lBYWIjAwECFnqFBQUFYsWKFWj16BoOhVYRzx44dI+Z9TSpZ9fX10W2gbt26hbNnz46asNRloVMyHLNnz4aHhwfMzMwQGBhI+5aoF8rf3x8bN25EVVUV4uLilE5QS0tLbNy4Eb29vUhLS4ONjQ3mzJkDPz8/9Pb2oqOjA1VVVaipqaHVFLOyspCTk0PvydVJabDZbGzatAmvvPIKnn/+eYjFYnR1ddEmta2tLbZu3YrGxkbExMQMe4HlcjnEYjHEYjFEIhH6+vo06jGoq6uLsLAw2NjYICEhQW2fQcoaorZIbW16SE42Q319O/35tGnT0NnZiVu3bg37flNTE3p7e+kuQEOxdOlSiEQiREZGoqOjg16AKMt1vDB07unq6iIwMBAymWxC2r67urpi/fr1tFOakhTq7+8Hm83Ghg0bIBKJVJI2JWZI1cZS4PP5eOMNd8yaNROmpn74z3/M8PnnNSPOC3Nzc5w4cQJvvfUWnV1PXeezzz7DuXPnVI5FW7LicDgK+v/KMKnRQC6XizfffBNSqRSpqalITk4GAFp9QBuMVN/HYDAU2ohRzvDMzEzk5OTQ0Ts/Pz8wGAwkJCQgLi4OO3fuHJZXRSlZUlYBm81GR0cH0tLSYGxsTLc1Wrx4MSoqKtDR0QGpVIqWlhba8c/j8UaMlPB4PCxatIgmOw6Hgxs3biAsLAzbtm1DfX39sOS8vr6+Yd14GAwGfHx8RiwZ0dHRwcaNG/HVV18hNzeXjlQOxsaNG2FkZASRSITk5GQYGBhg0yZrWFmVoLOzCTKZJVpaWnDixAkAGKYBJZfLUVFRAR6PpzJyZWdnN0whwdnZGWVlZejs7NRKLUFTjDTfxrs2UBns7OyQlZVFCxAOrtNTBYqwhqK7uxscDgd+fqb46qt28HhCjXOhvv32W3zyyScKf9PX14enpyeSk5OVRl6HJi1rgpFULSbNspJIJCgqKkJpaSnKy8sxd+5czJs3Dw8fPhyVhUVNtqEKB+qgKnrn4+ODzZs3o66uTqGjSUpKCo4dO4YjR46gsrJS4eG6uLhg+/bt0NXVRXd3N1JSUvDNN9/g8uXL6OzsREhICL3iyWQyuj3V4L6D6saor68PsVgMS0tLxMTEQFdXF/Pnzx92PJvNhr6+Ptzc3ODu7g4PDw9wuVzk5ORopKFvbGwMa2trZGRkIDU1dZjD1sPDAwKBALq6uli5ciW6u7tx6lQC3NwG0k/kcrlC5OrEiRMKW5Kenh709fXBzs5OLUFQCgn9/f2IjIykSXkiLStgwD3w0ksvjSq9ZnAp2GhgbGxMSwQBA5nqAoFAa8G97u5u8Pl8vP/++wCAOXOM4e/vozFZvffee9i3bx9Onjyp8PcXX3wRH3/8sdLvUKkq2mCkrfaEWVY1NTXo7Oyk69V6e3shFovB5XLpzOVFixaBJEkkJyfDxMRE6cquCra2tnB1dUVSUhKCgoI01timoneDLSxTU1N4e3vDxsZG4YG3tbWhoaGBDrkLhUKFMbq5ucHtlzZbOTk5yMvLg1gsxp07d5CSkkL3LORyuZg5cybtLOVwOPD391cpwUE57DMzM+Hk5AShUIjY2FiEhoYOSwCltLy8vLzg6uoKHo8Hf39/5ObmoqCgAAwGY8RcnICAAJw/fx7nz58HMLBKKhPznzlzJphMJhITE5Gd7Yxbt3yQmEhg0aJFmDlzJkQiEQ4fPoyDBw9i+/btCvVumuTfWFlZITQ0FD/99JNWbbBGA1XEqaenN2pBubS0NCQnJ6OnpweLFy8eVcIqm81GV1cXrV4REhKitSKnUCik1TsoaDOW8PBweHp6YvPmzXj22WdhaGiI8+fPY+HChXjllVeUqtmOBu+8847azyeMrPr6+mhtHEpZ093dfVj31sWLFyMzM3PEnIuhYDKZ8PDwQElJidZtwwaTwWDCGroyrFq1CsCAVZiUlASJRIKYmBg0NTXB3t4enp6edHHy4KabWVlZaGpqou+9srISt27dwoIFC8Dn89Hd3Y0HDx7QNXFURvJgsFgsujvOrl27EBsbi7i4OISGhiqI4Dk4OGDp0qW4cuUKHcWaOXMmlixZgqysLOTl5dGddlQhJCQEvr6+kMvlOH36NB4+fKiyEcD06dPBZDJx/HglAgJMwWQagSAIukVaREQEYmJicOjQIWzbtk2jZgiDQVk0k7ENe1QsXrwYvb29SE5Ohlwux9KlS7UmLDc3N6SlpdEt3wc/B7FYjNTUVLpWVRWsrKxoq6Wrq4surDc2Nqa31F1dXdDV1VW5FQsJCUFBQQE6OzuxePFiXL9+HZ988gm+/PJLpUSlLKdxJFDbXFWYMLKiLI6RQL3QTU1NahUylYGa2CkpKVi6dKlW46MIi/IP+fj4qBRmY7PZWLJkCW7fvg07OzsYGxvT0UDK72NkZAQjIyNaaG8wJBIJDh8+TEdC9fT0sGTJEkilUpSWlqK2tlapRCxljXR2dip01t2xY4dCw865c+ciMDAQUqkUd+/eRUpKCuRyOZYtW4bs7Gzk5eXRHXhVgZqAW7duhVQqVfsyBAUFobW1FWJxIRgMGwD//c2ohqWxsbGIj49HaGioyvMMBUmSiI6OpusV9fT0NG74MBqMddY6QRB0VxiqJGjFihUav8Q5OTl0706ZTKbQxUYkEiEuLg51dXVwdnYeJp2tCiUlJThz5gyAAd/XjBkzUFlZiYaGBpiZmSEiIkLlM+Zyubh79y4KCgrwj3/8A6+99hpefvllAAO/VUJCAo4dO4YLFy5ALpfj559/xqZNmwAMyDY1NzfTvRGU4f/+7/+GdTofjEmNBqrCokWLUFdXh/T0dK2+5+npSfeKS0hIwNGjR1XmpSgDm82mt2O5ublqrTs2m42ZM2cCGLAuXn/9dezZswf6+vqIj4/HgQMH8K9//Qs5OTkoKChQCMtSnXnDwsIQGhoKIyMjnD9/Hnw+H0FBQbTkC5UzQ/W9EwgEdJJkW1sbIiIiYGJigocPHw4bH4/Hg6GhIVasWIHZs2ejoqICMpmMbv/94MEDjZ4NpTc/EvT09PDgwQOlAQ4ul4tt27bRFQKA8m3IqVOnEBMTQ/9/giDg7e0NgUAAHR0dFBYWjir5VRN4eHggLy9PQZt+LEAQBFavXo2QkBCkpKTg/PnzGluJJSUlSEpKotunyeVy6Onpoa+vDzExMairq8PmzZs1JipgIOCxd+9eREREwMrKCikpKWCxWHjqqafQ2dmJqKgotflTVlZW0NXVxccff4zf/9KAFwDOnTuHP/7xj1iyZAkKCgpw5coVvPzyy3jw4AHmzp0Le3t7LFmyhN6dKIMyyfHBmPTaQGXw8vLCyZMntc6roWrQgAFHu0QiQV5eHu7evQsGg4EFCxaM2KGEIqysrCzk5uZi1qxZKtsLUdZGe3s7BAIB7O3t8Zvf/Abl5eWQyWS4dOkSEhISAAzIkURERNClIEwmk7aGbG1tERsbiyNHjmDLli0ICAhAdnY27dzW19cHj8cbaGzq6UlL/trb2yMiIkJtFIVSpViwYAF9H0wmE1KpFCdOnIBcLh+xUFYTjKQuqomFLBKJFBqS9vb20pI8qamp4PF4OHz4MLZs2aJxd2ZNYWZmBnd3d9TX19MKs5pgpPumPlu5cqXW3ZbXr18PkiRx69YtPPXUU2huboaenh5iY2Pp3pXadtzR19enLac9e/bQfmNgIHXi4MGDdNsyZQqu3t7etAUqkUjw9ttvQ09PD4cOHcILL7xAFzlbWlrin//8JzZv3oyGhgb09vaiuLhYLVmNhClpWTGZTOjo6CAzMxNCoVCr78pkMnA4HLz66qvYv38/Zs2aBQMDA4jFYhw+fBj5+fkQiUSQyWS0SN9QsNls2NragiRJtYSpo6MDBwcHNDY2ovCXrs56enrw9vaGn58f9u3bh+eeew7btm1Dd3c3IiMjcfnyZVy8eBGdnZ30eagERCop8+LFi2hsbISrqysWLFgwrJcbpRBKOetHclZT36FgZGQEX19fODs749SpU7RlNtrER4lEQj9HVbk7mlgTQ4/54osvcP36dfr/z5s3b9yyykfjYwGATz/9FImJiSMeRy0alJyRJqD6ClLdrAsKCvDZZ59BJBKNiqiGgslkKvibHBwcsGvXLnR3dyMqKmrEjkm1tbX47LPPIJfL8c033+CNN95Q+Hz58uV0X4GysjLk5eWBx+PR3Yu0xZQlq+3bt6O9vZ1uwa4pSJKkUwOYTCZWrFiB0NBQPPvss7CyssKRI0fw8ccf47PPPqNLZpT5Kqhw+0hbUUdHR1ovfGgdme4vTT49PT2xa9cuSCQSpKamIi0tTYGESZKkkzKp1b2oqAjR0dFKtz3Gxsbo7+9Hfn4+TYDawNPTk25V5urqijNnzuDevXu4d++e1oENAMjIyMDt27cBAF9//bXa9BFNJaQHg5rYHA6HJvWEhIQxT9QcDVlp8x2qfEYbUAnNurq6MDIygqOjI55++mmNfcDaws7ODmFhYejp6aF14FTBwcEBrq6uePrpp5X64urq6mBmZgahUAhDQ0MsWLAAPj4+mD17Nnx9fREVFaXV7mlKkhUwQAI7d+5ER0cHoqKiNCYsKooVExOjQEIUGaxatQrLly+Hrq4urYF+//79YZGI6dOnQywWQyaT0XpYykAQBJycnGBtbY2GhgaVloWdnR1ef/11/PnPf8af/vQn2s9QXV1Nt1rX0dHBtm3b8Oqrr+Lll18Gn89HXFzcsFwnKysrODs70x10qF6J2oLFYtErdFJSEgiCQG5uroLGlSZwcHDAmjVrsGbNGujo6CA6Oho1NTUKx1DNLyQSidJIKzBARu3t7WrJTldXF/7+/pDJZBq1H9MW2qz4NTU1EIlE49rRBRiYYwsWLEBjYyPs7OzobkQj4eHDh6NSjrC1tcWrr74KR0dHREVFqaxmoOoWKQHJoThy5Aj4fD7s7e1hbm4OExMTxMfHo66uDl999RWioqJgYWGBr7/+WqNxTVmyAgYIKzQ0FO3t7fj666/x2Wef4ejRo2rZ2MHBAdu2bUNTUxOio6MVCEtHRwchISGYPXs2IiIiAAx0vhGLxcjOzsa3336LK1euoK+vDywWC0uXLoVYLIZcLse5c+dw/vx5JCYmIjExcdjLSEXutE1aZDAYaG1txd27d3H37l2UlJSAJEkYGBhg9+7dMDQ0RFxc3LDrUXIzxsbG4HK5o06WZLFYtHIqRcr5+flanc/CwgLTp0/H9OnTsXv3bnC5XBw/fnzYOaiXmpJOHopFixZBT08P0dHRCosH1UGa8ntRDv9//etfOHr0KN2cYyJRXV2NmJgY8Pn8UcsRq4NYLFb4zSmN/M7OTtTU1NDzRB36+/tHXU/J4XAQFRVF+5tUYefOnYiPjx+2SKekpODf//43Zs6cOUzamyAILFmyBFevXsWdO3fwzjvvoK+vD2+++abaMU1psgIGCCs8PBze3t5wdnZGXl4e4uPj0dzcjLa2NqU/mJubG7Zv347GxkbcuXNH6XkNDQ3x4osv0lshJpMJV1dXpKWlISoqCr29vWAymVi6dCkkEgm4XC4aGxuRl5eHzMxMREdHIzY2FocPH0ZzczPtONdWUsTGxgbe3t4wMTGBvr4+ampqaP+Xvr4+du/eDT8/P6V5UXZ2dqiqqgKbzX6kF5bJZGLz5s1wd3dHaWkpnbg7GhgaGmL37t3Ytm2bAiHp6elhy5YtAFRvnYyNjWmyu379Oj2GmpoaWFpa0jlBfn5+CA8PR0BAACorKxEbG6s0IqotKEWJkUBdk/p9tM3UHgkikQixsbGIjY1VWGwXLVqEjIwMuiCZUlNVBYIg0NPTozLvsKWlBX/961+VRkAp+aNly5bR/TiVwc3NDQ4ODnQaTmNjI5YsWYJ58+bhwIEDSExMxI4dO1R+38vLCzKZDNOnTx9RomjKkxUw8FKuX78eGzduxIYNG1BWVoZvv/0WX3/9Nc6cOaP0B3N1daW3HarA4XBgY2NDN9zkcDhYsWIFWltbER0dTRPWkiVLwOPxEBAQgDfeeAOvvfYanJ2dIRKJUFlZiR9//BGxsbHo7u4elYyJhYUFvLy84Ovrq+D/omoI169frzLi19jYCJFINGLYdyRQhEUl6VIF5qMBn89HXV2dgv7S4Hb3FCoqKnD+/HmF38jIyAi7d++mO/pQxGZgYKDQkcfJyQlr1qzB/v374eLigjNnzihVI9AUEokEJEmqjDK2tLTgwYMHdJE7n8/H7t27lUbMHgVisRixsbGoq6vDhg0bFHLtpk2bhnXr1iEtLQ0kSdKttVQRloODA4RCIbKzs5USlrm5OT744AP4+flh//79Cp9RASBNtri/+c1v8Oqrr+K7777Djz/+iN7eXnR1dSElJQUhISG0VJMqfPLJJ9i3bx+OHz+u9rgJS11IT09Hf38/PdGohERtHY6BgYEwNzdHW1sbamtrkZKSAgBK9bd5PB7y8vIQEhIyLFN+KKhwLoPBwPbt2xEfH0+HcKmiY6lUSls827dvBzAwiZOTkyGVDkhwcLlcdHZ2jmq1pZ4NQRB0xMTT01PtM6ICCtqWYCgDg8GAiYkJXSBtY2Mzqi4mJEnSqRdyuVwhKZbJZNL309DQgNTUVCxcuFDhOtoQAJvNxvbt23HgwAFkZGSM2N1FVdSvpqYGzc3NSju+NDQ0ICYmht4OsdlstcmTj4L8/HzU1tZi8+bNsLW1RV1dnYJlM23aNOjr68PR0RE1NTW0FJGyRrDU3woKCujeAIPJ5/PPP8eVK1fQ0tKCp556iv57dXU1jh49CmNjY41agj333HOQSCQ4cuQIbf1Sc0edYCAFdU0iBmPCLCsq+5hy4lKdVtra2tSaqspgY2MDPz8/rFixAvPnz0dGRobSVP2tW7dCJpMhMjJyRNXCbdu2QSQSobm5GTweDzt27EBbWxsdjTQzM0NPT8+w6JyZmRmefvppbN68Gf7+/mAymThy5AhqamrQ2NiodekPMLD1dXR0RGNj44j+I2rrok7SRRuYmpqioKAAra2tWucFUSAIAjt27ICjoyNOnjxJC/rxeDzMmzdvmIX1qFE9FotFF3qr2xa1t7fj4cOHSq9H1eANdUjX19cjOjoaLBaLTgKWSCTjlklPzRczMzNkZmaisrJymD/I3d0dHA4HTk5O0NfXpxcFZbC0tISXlxc6OzuRnZ2tcK7f/va3OHv2LO7du0dv0auqqhAbGwsej4fdu3drVMBNEARtGSUlJeH8+fPIzc1FVlbWI2vCD8aEkRUlDxwUFARnZ2c4OjqCyWQiKysL9+/fx/3790eM7mRlZSlU8BMEgYULF+KFF15Q2olEIBAgPDwcMpkMUVFRagmLz+fDyckJTCaT1mGnCCsqKgomJibQ0dFR62ykwsl6enr46aefcODAAfz888+jilo5OjrCyckJTU1NagmLirKNFVn5+Phg4cKFSE9Px6lTp0btuKey9HV0dFBSUoL+/n48ePBAIdJob28PJpOJY8eOqTwPpaw6kqXq4uKC+vp6nDt3TiVhkSSJnp4eZGRkDCOsjRs3gsViKfj+amtrER0dDQ6Hg927d2PlypV0RcB4oK2tDTdv3gSXy0V3dzekUikCAwNVbsUoS1wkEqmVBaeUGjo7O+lgxWB0dXUhMzMT9+/fR2xsLB3codq05eTkaOTDNDY2hpeXF3Jzc2FpaUn7WQ8cOIDw8PBRR60pTHgGO4vFopUfra2tcfr0aXR2dsLFxQUpKSl0EfFQyGQy3LlzB62trfDz8wOTycTMmTPpwl9VoAgrOjoaUVFRiIiIUKnrNFi/HRhoXRUaGkpn9QYFBdFWoDKrg2qRxWQy4efnB5FIhEuXLiE2NhZhYWEqM+FVwcHBAQRB0PkuXl5eKvOTRtuCShkWLFgAgiBQW1v7SAXEbDYbLBYLQqEQcrkcQqFQwT9lbW2NmTNnqgyCAKCVQkeyZJ566imIRCLcuXMHxsbGSv0klF5ZdnY2vWWkfhM2m63wbGtqahAbGws9PT1ERETQvSCHtrkHBmRvTp48ifb2drrjjrYZ9r29vYiMjIRUKkV4eDidhzeS4oOJiQkMDAxQWVlJt4xTBgsLC+jq6tKBIKFQiMzMTMhkMqSmptKpQWZmZggPD6ePKyoqQkJCAsrLyzXSmeNyuQqL85EjR/DJJ5/QHZso63Q0mFQHO4fDwbJly9DT04OHDx9CIpHgwYMHyMvLQ0VFhYLJymQyaSXLoqIiZGRkIDIyUqOcIIFAgIiICMhkMsTGxqpdeQHFhEUnJyc636ukpISOxKiCu7s7GAwGTaabNm1CbW3tiGL4qkClKDQ3NyMvL2+YpTNeagTz58/Htm3bRr0VpBAQEIDCwkLadzE0AVfd+ansak0SSCmSoPohqoKxsTH8/f0hEomQkZGhkLUfEBAAW1tbVFVVISYmBlwuF7t371bZtDYyMhIfffQRvvjiC1RUVEAgEIDP5+PkyZNaR2fLysrQ3d2NrVu3Qk9PD7W1tUqvO9StQHXT7u/vR1ZWllr1Tz6fD4Ig0NXVhcjISFy5cgXXrl0Di8XC3r178corr+DFF19U6A7k7u5O68ypCmYNhoGBAV1beOfOHezbtw9vvfUWeDwegoKCtHgiwzHptYGGhoZ4+eWXIRQK0dAw0KWF6s5L9e+jQukmJiaIiIgAQRBobm7G0aNHNZLsBQZWlpCQEFy/fl1tS3RgwKE6WOCMyvc6ePAg7Ozs1Fbn6+npQVdXlyYVantKTbL29nY0NTXBxcVF42RCSqiupKQEubm58PH5r3AaNXk0fQ7aQJssc1VYunQpcnNzIRQKwePxUF1dDQ6HoxC9VLZa19fXw9PTEyRJqpWzGQxNM8SNjIxohY2MjAzMmDEDDAYDc+fOxe3bt+mWXKrq4yh4eHjQTmxfX1/aIf7DDz9o/XvU19eDyWTCzs4O9fX1IElyWK9AsViMuLg4uLm5Yd68efTfKSltOzs7ZGZm0sXqytDV1YWoqCgIhULs2bMHNjY2dNduZSCIAX0ygiDoRrTr1q1TeR8+Pj5477338MYbb6C9vR0xMTEwMjJCTU0N+vr6RlQDVYdJJytgYGtISaoYGBjg0KFDWLVqFXp7e9HX1weCICCXy2n5FIIg4OjoiBdffFGrF4rJZILFYqGkpESpme7k5ISSkhLo6Ojgxo0bWLBgAf0ZRVjFxcWoqKigM3KVQVdXl+4NaGhoCD09PSQnJ8PFxQU9PT2or6+nW71rCor0hhIWpTRaXV0Nc3PzMQ+lPyoo5QSpVAovLy9UVVWhtLQUJEnC3t4eLBYLJEmivLycfib9/f2IjY1FcHAwrUqqKebPnw8+n4+Kigp6TimDoaEhAgICIBKJIBQKcevWLaSnp9PRyyVLloy49VTmu6IWoNraWq22gvX19RAIBGAymfRiOHhuD5aEGbwV7ejowMGDB2FkZARXV1eUlpYiKytLKWFRqgq9vb3YtWuXxukuFGEJhUI8fPgQy5cvV+nSeP3112FhYYFly5bB3d0dbDabTsEZaSEZqUplyuVZ2djYYP/+/fDx8cGMGTMwY8YMTJ8+HTNmzICTkxP4fD6YTCby8/NpuRFgwHLp6emh/SPKEBgYCF9fX9TU1ChtOcVgMLB06VL09fWBJMlhpjxVB8hisXD//n2VhZ7u7u60zExPTw/CwsJoeV7qBxmN49rW1hZubm5obW1FTk4O3QuRwqM6MMcLbDYbdXV1OHPmDNzd3WFubo6ysjL09fUhODgYZmZmOH36NH08h8PB+vXr6YJ2TUGV4LS1teHQoUMj5l1RDuTvv/8eDx8+REBAAF599VVs2LBh1NE+c3Nz+Pj44NatWxrJSAMD1nF9fT0sLS3R0dGB2tpaWFhYKJDNuXPnaEmYwVZ/W1sbJBIJVq1aBVtbW/j4+Cj4owaDyWSCx+MhLCxsVHl5lIWrruDdzMwMv/3tb+Hj40OPv7m5GTo6OmoXUpIk8eyzz6q9/pQjK0C5nAhBEHBwcIC3tzeCgoJgbGyMgoICVFRUID8/H3fu3MH9+/fx4MEDPHjwAC0tLWhtbVUgBX19fcyfPx9SqRS1tbVKCYvJZEJfXx8NDQ2orq4eVpfn7u4OMzMzMBgMlQ0lKZkZkiTR3t4OKysrhIeHQyKR4Nq1ayAIAtnZ2aMK2dvY2MDd3R1tbW0oKCgYtVrARCE1NRUEQcDAwADFxcVIS0ujJ71MJgOPx4Ojo+OwZ0FZJZreW1lZGSorK+Hj4wOxWIyAgACN/HnXrl0DSZJ46aWXsG7dOo2bUdTX1yv9/QmCoJusarp4dHd3QyQSwdLSkn4OQ+WqOzs7YW9vP2xrSBEi5cIwMzOjg1RDdx36+vrYu3evVvpXg0FtGU+cOKGVr5TNZtM5iqrw1VdfjaikMSJZ5efnayUdUl5ejoSEhFHlF2kKqvefsbExKioq0NraSmeBu7u7QyQSIScnB9nZ2cOyd42NjRESEkITlrJCTyaTibKyMpVNI01NTZGSkqLWOTzUH2VpaYmIiAh0d3ejqKgIvb29yMzMHBVhWVtbw8PDg550gzO7pxo6OzshEomwevVqhIeHIyQkhF6Mqqur6SRbqrUZBeozdT6OtrY2VFZWgiRJXL16FYcOHaIXKC6Xq5F/hCqsVqea2tvbS/s6gQE1gejoaJw7d25MGlhQ52CxWLTqxWCiaW9vR2tr67A59fDhQ1y6dGmYUqipqSmdXDwUjzJHbG1taSFHbe7byMgIDAZDoYckAOTm5uKVV17BP//5T3z++eePlsHe29sLb29v7N69Gz/88INGDmFqi1JfX0+3X3/qqafG/EWiCIvq3DH4xzU1NYVYLEZ3dzeKi4tx8+ZNSKVS8Pl8hISE0IT18OFDlJeXD2sQOmfOHMyZM4e2WqhmBVSfOzMzM3C5XCQmJsLc3FypA1iZKNvgNIqioiK4u7sjIyMDgYGBWjserays6PH19/c/kuNyvECNj1IbpXxSlNRJVVUV7O3tMXfuXNTU1NBdjQICAlBWVgZTU1O1dWltbW2or6+Hg4MDQkNDERUVhbi4OJAkiQULFijNRh+MwsJCVFRUDLNWBqOnpwfR0dFoa2uDl5cXJBIJndIQGhqq1GdK/eaaanhRJC0Wi9HZ2QkHBweFlIWbN2+iv78fixcvpv+WlpaGs2fPwsXFZUyitpqC8h+qClIpQ1dXF7q6umijgZoXH3/8MWJiYuDk5ISbN2/SKU2qoNayKi8vxyeffILi4mJaa3kkTJ8+HRs2bIChoSEIgsDVq1eRlJQ0LiF2JpNJs/ZgUPtjqjuNXC5HXl4eLly4gNOnT4MkSRgbG49YsEsQBB3xqayspElLV1cXu3fvho2NzYgZvkNJmkqj6OzsREFBAfr6+oaF0DUFFWigxjXVLKsbN24AUN7U1dHRESEhIXQpEyVVk5iYiPT0dJAkCQcHB40DKFwuF6GhoXQ5D0EQal+mgoICHDlyBJaWllizZo3SY4RCIaKiotDW1oYdO3agv79fo5QGTcmK6kienJyM4OBgiEQi2NraDgu+SCQSGBoa0uTb1dWFCxcu0AX7oymJGi20IWIKVN6hk5MTnX0/c+ZMXL16FY2NjSgpKRmRqIARLCuBQIDXX38d06ZNw5IlS7Bt2zYsWbJkxJMGBgYiMDAQJEkiMTERt2/fBkEQCAgIgK6urlrnpUwmQ1tbG83CymqetEFQUBD6+/uxZMkSXL9+nX6B1q9fD5lMBh0dHdy/fx8zZsxQ+n2KsBgMhsK4TUxMsHPnTpXXVSd3a2FhgYiICERFRaGsrAzOzs6oqqoalaCat7c3rly5Ajc3twnpGqwNsrKy4OvrqzJpdzCJUVI13377Ldra2ujIsDYwNDTEvn37cOTIEdy8eVPldfPy8pCQkAArKyvs2rVLKZl2d3cjOjqa9jmmpqaivLwc+vr6iIiIUOsstrOzw1/+8he1REuSJK5cuYI7d+4gODgYCxcuxIMHD1SedzA58Pl8REREwNLScty1tIaCuidttoH6+vrIyMiATCbDgwcPYGNjg/z8fFrFl8JIcjZq75RyJC9evBg//vgj3nzzTdy9e1fjLQdBEFizZg3dCzA5ORksFgsrVqygnZDAwA/R1tYGsViMpqYmunSEwWBoTFbqHM3UeCldHYqwli1bpqDhpGo7oKrLrTpQq3t7eztsbW2HTVxzc3NERERAIpGgsrJy1D4+Z2dniMViMBgMtLS0KC07mgxIJBLY2dlpVCpDgclkQldXFywWS0FlQRsYGRnR3XSOHj2KzZs3K/yuubm5SEhIgK2trdJu28DAixgdHY3Ozk4sXboUmZmZ6OjogL29PdavXz8iiY5k1QEDz6e8vBwzZsyg03RUgSTJYZbMZP3OTk5OWL169ahIkkqUBpSP/7333lP7fY2vuHfvXhw+fBhRUVG0KLwmoNoReXh4QCwWo7y8nO5YTOmcUwmh1PFubm4wMTHReLJWVFSgr69vRIUC4L+ExeVyweVyERwcjOTkZBAEAWNj40e25CgwGAy4uLigpKQEra2tSgs6qb/V1dWhtbUVQqFQ65A59VJQxcxTxX917do1GBsbg8fjaZzUORiUZMtoCEtXVxe7du3CyZMn0dLSgvr6enoLxeVy4ezsjC1btqhMi+jp6UFLSwuWL1+OWbNmKS2xeVRwOBy62cfgexxKSrm5ucjPzx/zBhmjhaWl5Zi9I0MxOBVJGTROXSAIAq+88goiIyO1HgRlmfj5+WHZsmUQiUTo6+tDcXExSkpK0NDQAGtra8yePRtz586FjY0NnQmuKRobG+lQ/khYuHAhQkJC6LHl5OSAxWKhoKBAbUGotqCSRkcymb29vUEQxKgaZFD3S5HWVMm1ksvlEIlEKrfXqkBZo1S+0WghlUrpzP/i4mI6xE+VT6nL36Is+/EmfR0dHZqomEwm+Hy+gv8pJyeHtgKffvrpcR3LVMD333+v9nOt8qyWLl2KjIwMfPnll6N2mOvp6WHx4sWoq6vDnTt3cPv2baSkpIDL5UJHR2dU5uVgSRVNCYsC1SWGynYeS8LSdBxcLheBgYGjIiyKCKdS+kJnZ+eoo1MzZsygayC1aRQyGN3d3cjIyAAwUPxtYGCA/Px8mrDUPaP6+nocOnQIfD5fax9iR0fHqN8LXV1dTJs2TaEqgs1mw8nJCbt27dK6CB4YcHdQDU1/DdCKrLhcLm7duoWDBw9i48aNo+5gq6Ojg9DQULz99tt49dVX6V5oj7KSDiaskbpyDAa1khUVFcHX15cmrPv37496LBS0mbiDCYuSrtX0Gmw2G729vdDV1dVIf2g8QZIkUlNTwWAwhiU2aoKAgACsW7cOEokE1dXVan15VBnW0KacVMfp5ORkFBcXw9/fH0ZGRsjPz1fbwBMYUAmgJGG0KV2qr6/Hv//9b1y9elXj74wEDw8P7Nq1a9QWXmNj4yMpvk41aJ3BPm3aNNy6dQtisRg//PDDI12cIAg6sqGnp4fIyEh89dVX+M9//qPQV09TODo6wsXFZcT8msEwNjbGggULaGVLPz8/SKVStLe3P3JiK2UplpWVaVTYShEWk8lERkaGRmL/lPOVJEmYm5tPeHRoKAiCoOsiKcd2aWmpVo0LKAuDxWKp7XRjY2MDHR2dYYm//f39MDExoaVKqJw8FouloIemDEKhED4+PhpnsgP/TRLlcDiYNm2axt/TBI9iKTMYDPT19U25KPFoMapyGw6HA1dXV1RXV+PcuXP0w2hubh5RxF4ZqCYDfn5+sLW1RVNTE6KiotDU1ISuri50dHRobGLb2dkpNG7UBAsXLsTevXvpxhE9PT0oLi5+5EQ7NpsNd3d3iMVijbc0XC4XLi4uKhuwDgVJkpBKpWCz2Whubh43yRhN0dzcTGefAwNbwoMHD+LgwYNaERaVd6Mu8qarq4vAwEB4eXnRv1VLSwtkMhmdCU5tn1gsFqytrdHW1qZyISwoKIBUKtXakjlz5gxtjWlDcuMNPz8/9PT04Ny5c5M9lDHBqJfhZcuWYffu3Thx4gQWLVqEH374Ad3d3bRgm5ubm1argqGhIdavXw9goGI9JiYG3333ncIxvr6+CAoKov1M6gT+tcXgwk4TExNkZGTg+vXrw9oIaYvREB6V5tDb2ztimHywY53NZqOvr09rsh4rUIsM1RUIGPhd161bh1OnTiEvL29EjfTB5+JwOCOmPejq6ioEYkpLS8Hj8XDlyhU4OTnBz88PwIC1devWLVhZWaGoqAjTp09XmJ/5+fk4duwYbGxstBaIE4vFcHBwUJkkOlnw8PCAs7PzqBrXTkWMmqzWr1+PtrY2dHR0wMXFBa+//jo8PT0hl8tRU1MDgiDg6uo6KjPWxsYGzz77LMrLy8FgMMBgMNDc3Iy7d+8Oaxv0zjvvjPYWVGLu3Lloa2uj87EehbDUJYeqgpGREfT19VFQUAAWi6VS2RQY2MYGBgaisLAQvr6+41qTORKSkpLAZDKHqbFSTQe0say6urpgamqq9fyRy+Xg8/no7++nJWikfX1IffllVNvbw9vbGz09PSgvL4ezszOAAR8XRVQ7d+7UKgpdUFCAzs7OceuQ/KhgMBhjUr84FfDIDg4jIyN88skn2LhxI+7du0dPTIqwXFxcRkVYZmZmw4pLKf0hisAYDMa4qA4wGAxaYGwsCAvQjqxYLBYCAgKQmZmJnJwc+Pj4qCy0pcTQ7t69C4lEMqk+q40bN6K3t3fETkKagCTJMRH/A4CmGzdgc/06tvzhD3CfPh25ubmorq6Gs7MzcnJycPz4cbVJoqpAWWNWVlZYtGjRmIx1rDEVosNjhTGZ2Xv37kVaWhreeOMN/PDDD3BxcQFJkqipqYGhoeGYdbhQp7U+1hhKWHfv3gWTycSKFSs03soAo5cdZrPZtJolJbanjLBIkkRBQQEkEgmcnJxG1OweTwzdkg2FNis8j8dDQ0MDLC0tNY7KKcv0BoBeJyccCQ1F6MqVIAgCPB4PLS0tyMrKwsmTJ2FnZ4fQ0FCtiEqTTPipAF1dXZSXlyM9PR26urpwcHCYNDfBo2LM9KzeeOMNnD59GjKZjBb5Bx69zdJkgiKsFStWYNq0aTAzM6OzojXFaLaBFChdLD09PZXpGD09PWhqaoK9vf2oUgXGAiMRsp6eHvh8Pm7cuKFSsHAofHx8IJfLR2yhNngMRUVF6O/vB5/Ph4mJCZgSCYo++QS3o6LAMDCA6S+Z9IObIdjb22tNNlSypp2d3ZQmKgBYvHgx9PX1cfr0aRw5cgQ//PDDmHVCmmiMGVk5OjoiODgYzz77rMIKN9iUb2xsVNqqeiqDwWBg1qxZWLFiBW3qjyZZcbTmOJvNhr6+vkqrhPr7ZMkZFxYWIjIyUm3kksVi4ZlnnkFvb6/GeT+jyS2Sy+Wwt7eHsbExTExMcOPmTRD//jfsqqoQFhZGkxTVet3MzAxBQUFabZ2zs7Nx/PjxUZHcZMDQ0BAvvfQSXnrpJezcuRMikQiRkZEaLxpTCWOqFHr06FHcvXsXly5dQmFhIXR0dBRCuTdv3sTx48c16tI6FUFN6uLiYo2Ol8vldJ+2R/El6erqQiQSoaamZthnlF7UWPl3tAEls6JJDhm1PRwvHwpBEPD09IRATw8Pnn8eFSUleGrJEhifPYvFsbG0OF16ejpOnjwJXV1dODs7D6vNU4fMzEycOHGC1s+aCjWYmoDNZsPCwgKurq4ICwtDZ2cnsrKyJntYWmNMvbE8Hg//93//h2eeeQbGxsbQ0dGBWCzG008/jY0bN2LFihXo6enBiRMnwGAw4OPjM5aXH3fY2toiMDAQt2/fBovFGtHp3tnZifb2dri6uj7SCuzo6Ije3l6UlJSAxWIpFJIaGBgotP6eKAx2LquSWRkLiEQijYMoUqkUVz/+GD737mHnrl1wHPL7UO2kKME6qpmBJufOyMjAqVOn4OTkhB07dkyohtRYgpo7kxk1Hi3GfDl+5plnUFxcjNLSUpSWluLKlSuwsbHB22+/DUNDQxQVFcHOzg4JCQmj7qU3WSAIAuvXr6cJq729Xe3xY7VFYzAY8Pb2hq6urkZ9EoEBH854Tcji4mIcPXoU1tbWCAsL04ioRuO7s7a2RmNjo8Y+QjabDePNm8E4eBCOK1cqfJaWloYzZ87A1dVVQbBO3XgkEgn6+vrw8OFDnDp1Cs7Ozti+fbvWxeZTCZQe/uNiFQ7GuMS5B0vRenp64u2338bbb7+NF154AXK5HKGhoYiLi0NCQgIIglArKzvVQBHW7NmzR8xWfhTn+lBQjVMp4f2RzllcXAyhUAh/f/8xT2ewsbFBYGAgVqxYMa4+GycnJ9TV1WmUyU9BmZVZXFyMs2fPws3NDVu3blX7PMRiMS1ZdOrUKTo3zMXFBVu2bMH58+dRWFiIl19+edQdcCYTBEHg9ddfn+xhjAoTlpQjl8tx7tw5XLhwATo6Oti5cydiY2Nx7NgxbN++fcom1SkDQRAaaTSNdemLubk5KioqUFJSMmLCrbGxMerr61FUVKTQumkswOVy6WqD8QTlh+vo6KA7q4wGzs7OWLJkCWbNmqWUqEQiEZqbmyEUCnHq1ClaYtrKygr+/v7gcDjw9fXFuXPnkJmZiQULFjyWREVBLBZr5aubKpgwsrp58yZMTU1pPxVFWImJiaMSZ3ucMFaTwsHBAVKpFDU1NSOWNJmbm8PIyEgrq2QioM2zYDKZcHFxQWlpKa3kOhrCYjKZKv16ra2tiIqKotUYjI2NsXr1ajCZTNrXKJfLcerUKWRlZWHhwoUKzW8fN/T29uKnn36Cr68vFi5cqNXvIZVKJzXpeMKu/NNPP2HXrl0Kf9PV1cWmTZsmaggTjrG2rAZXBFApAOoIi8FgQCgUQiQSjZsDXFOM9llQNZulpaUwNTUdU5XKlpYWREVFQS6X08qhNjY2Cs9KLpfj5MmTyM7OxqJFizB//vwxu/5kQE9PDw4ODrh58yaSk5PBZrOxatUq+Pj40FLc1L/B6OjoQHR0NBYsWKBVUvRYYkLIqqSkBOfPn8fXX389EZebMhhLnxUFgiDomraRCMvBwQGZmZnIz8+ntbIeR9jZ2cHAwEBjLXdN0NzcjKioKADA7t27lVZZyOVynDhxAjk5OVi8eDHmzZs3ZtefLFDlWdbW1ujs7ERlZSVOnjyJkydPKj2WIAi6vpDNZo9ZNcpoMCFk9dlnn+GVV16ZclXpE4WxJomhhEWSJNzd3Yddh8/nIyAgACwWa1KJSiaT0Y05tO1YQ2Es585gooqIiFD6AspkMhw/fhx5eXlYunQp5s6dO2bXnyw0NDSAwWDAwsKCbtgikUiQkZFBp4gM/kcpm1CLrr+//4SWvA3FuJOVTCZDfHw8MjMzx+X8RUVFkEgkIAgCtra2k5bJrQzjqS1FERZBEKiqqgIAlYQ12WhpaUFZWRlWrlw56tblYwVKxobBYCAiIkJpveVgolq2bBnmzJkzCSMde5w+fRoGBgbYsWMH/Tc2m621Tv5kYdzJKj09HdbW1ho1MRwKmUyGgoICODo6qpTrFQqFkEgkkEgkaG1tBZfLBZvNhpub26QW9Q7GeGZtUw0xq6qqYGVlNSXIaSgEAgFeffXVSYugdXZ24vr16+jv70dFRYVSGRsKMpkMCQkJyM/Px/LlyxEQEIC8vDzY29srjD8/Px+VlZVYsWLFY7O9Jghi0sUZHwXjTlbnzp3TqDEqBZIkUV1djc7OTjQ0NNClAqrIipKRFYlEKC0thVQqRWdnJzIzMxEUFDSptVvj4bMaCoqwLCwspnQ4faLH1tfXhwsXLqCrqwstLS0Qi8UwMjKCmZkZ1q9fr5Kojh07hoKCAqxYsQKzZs1CR0cHmpqaFBz7g/WvKJXWxwE8Hg+VlZWoq6tTyIV8XDAuZEWSJNLT03HhwgV8/fXXtCYUMDAhEhMT6f2wXC4Hl8vF4sWLweFwUFJSgtraWujo6EAqlaKsrGxYO21l0NXVpdMiuru7UV1dPemTiArz1tfXa3QPowVBEFOaqCYafX19iImJQVNTE2xsbCAQCLBo0SK1W1CpVIqjR4+iqKgIq1atUmjVNhhDpWEme45pg7Vr1+K7775DSkoKNm7cONnD0RpjSlYkSeL48eP4+9//jp6eHqxcuRJJSUnDkhJLSkrAYDDozrVtbW1oaGhAaGgoZDIZbGxs4Orqip6eHkRGRuLgwYPYt2+fxlscAwODMU+EHA3MzMwgEAhQWVkJS0vLKbMt/TVDLBYjOjoazc3N2LZtm0bJxoOJavXq1Sp9OJRQnzr9q6nSZFYZ+Hw+9PX1H8u6QGCMyGr9+vUIDQ3FgQMH0Nraiv/3//4fVqxYoTSBj8lkDkv3p1arQ4cOITQ0FGw2m7YWVq5cibi4OLS3t09Jf4w6EARBtwdrbm4eld/uCbQDh8OBnZ0dlixZAldX1xGPl0qlOHLkCIqLi7FmzRo6SkaBSqotLy9HYmIi7O3tVSoudHd3Izo6GoGBgVM2esjlcqcsmY6ERyKrf//733B2dsa5c+dw5swZ/OlPf8Lf//53rbNcfXx8aF8VRVQUqFZMQqEQ7e3tdDPUxwV6enrQ19dHS0vLE7KaABAEgdWrV494XG9vL2QyGU6fPo2SkhKsXbsWwcHBCse0t7ejsLAQTCYTFy5cGJGooqKi0NXVBVtb2zG7n7HGnj17JnsIo8YjkVVMTAySk5Oho6ODffv24YMPPhi1M9nX1xe+vr4KfxMKhbh27RoA4NixYwAGfFO7du2a9BC4NuDz+WhqaprsYTwBBhI9z549i/T0dPpv69atG9bvTyaTITs7GwRBIDk5Gba2ttixY8cwopJIJEhLS8Pt27chFouxc+fOSVNs/bXjkcjq8OHD8PHxQVRU1LgUtjY0NCAwMBBWVla0wNyNGzcQGxuL5cuXg8PhwMnJ6bHVlH6CiQFJkmhuboZYLEZaWhoyMzMxffp0WFhYwNzcHI6OjsO+I5VKIZfLUVRUBBsbm2EaVhKJBA8ePMDt27fR09MDBwcHLF++/LGMsj0ueCSysra2xnPPPYf79++PC1n5+/vTofnq6mq0trbC0dERUVFROH36NICBwtOIiIgxLcUYDzwuuTi/JtTX16Orqwvl5eVISUmh/65JMXJGRgYAwNTUFOvXr1cgKpFIhNjYWNTW1sLJyQnz589XSnhPMLZ4ZAd7fn4+tm3bNhZjQWFhIUxNTemsYlNTU/zzn//Ed999h9zcXHz++ed444038PLLL6O1tRV1dXVITk5GVFQUdu/ereCALygoQH19vdaV5eOBxzkR73FDfX09mpqa0Nrailu3btF/DwoKgo+PD/T09Ea0fpqbm9HT04P+/n6sWbNmGFHFxMSgoaEBW7ZsmRJR56Ho7+9Hd3c3CIIAl8ud9CL2scIjkdWlS5eQlpaGgwcPjslggoKC4OjoiIyMDPz5z3+GVCrFsmXLsGXLFhQXF2P27NkIDw+HQCCAqakpysvLERgYiNTULJqwqNqz0tJSPHjwACRJYtGiRZNOWJN9/f8F5OXlISEhgVZo9fT0xFNPPUUX4Gr6G5ibm8PKygpOTk7DXvQ7d+6goaEBW7duHbNu4GMJsViMBw8e4MqVKwAGcv22bdumUWR0qmNUZFVfX48DBw7g22+/RUJCwqiLU4fiz3/+M/7yl78gNDQUFRUVePjwIV3A6ubmBjc3N6Snp2PlypVgs9kIDAxEZGQpzpzZhmXLTqC1tZUey+rVqyGVSnHr1i0wGIxHblI6WshkMgiFwklp6PC/BCr9xcbGBhs2bACLxYKhoeGoFwlV6rULFiyAu7v7lI34NTY24sqVK5g7dy7Mzc2RkpKC+Ph4jXPOpjJGfINIkkRxcTHi4uLw2muvITg4GN7e3qitrcX9+/fHTN+nsbERly9fxpYtW2BoaIiSkhK6QBcYSGEoLCxUIB09PT3MmWOPkJA2LFq0XsFvMFgv/caNGwpZ9BMFmUyGnJwcdHd3P/FpjCNIkkRaWhpsbW2xa9cumJmZwcjIaFysWSaTSRNVWVkZ7t69O+bXeBRQ9+zo6IiAgACEhYXBwsICCQkJU06IUVuotawqKythZmYGHo+HmTNnYubMmdi6dStCQkIeObGsv78f3377LdatWwcXFxfcu3cPRUVF8Pf3x9WrV9HZ2YlZs2ZBLpeDIAikpaXB0dFxWI6VqysTa9bUw9FxeLkJpd1DkiSuX78ONps9YRX0FFG1t7fDw8NjTEXjnkARBEFg+/btIEnykXPw5HI5EhMT4ePjQ8vwKENpaSni4+NhamqKGTNmTKqCJgW5XI4HDx4AAF0toaenh7CwMDQ1NT32viu1T5jNZiMlJYVWaxwr5OXlISIiAu3t7YiLi0NqaiqEQiF8fHzw5ZdfgiAINDc3o6mpiV4pVq5ciT/96U84cuSIgkNfT08PPB4P33/fhaVLDTB/vmKWO4PBwPr16+k0h4lCU1MTTVRWVlYTdt3/VYxVVvb58+fx8OFDGBsbqySr0tJSHDp0CGZmZggPD58yREVJLw+tg6TUQR93qN0GWltbjzlRAcC7776LFStWoLCwEF1dXUhOTsbmzZuRkpKCtWvX4scff4S5ublCX0E2m40DBw7gD3/4g0JLegaDAQ+PADx8aIbDh5uVtkliMBhYvXr1hJIGVX+lTC/pCSYHmtTE9Z88idkcjkrN9pKSEgWimio5fh0dHSgqKvpVSC+rwrh7fb/99lvMmjULP//8M/03T09P9PT0gMlk4ne/+x0+/PBD6Ojo4Nq1a3BxccGrr76KPXv2oK2tTeFcc+fOhUAgUMiZAQA+n4OoKEPs309OmcnzJF1haqGyshJff/01GhoaVB7T398P2/x82BQWKv28pKQE8fHxMDc3n1JEBQAmJibYt2/fMKKqra3FiRMnHtvi5cEYV/v1iy++wLfffotPP/0U+/btg0AgwOrVq/H8889j+vTp2LBhA/bs2YP3338fhYWFmDZtGmbPng2JRILIyEiIxeJhaREBAQHIzs4epodtasqBqany8Gxrayv4fL5aOY/CvDwwLl+GyNERDosWjVnR9JOUhclDU1MTjh8/DqFQiL6+PhgbG6vURevv78ehQ4dQs3gxQmfNUnoMl8uFvb09tmzZMiUVNIbKBNXW1iImJgZ6enro7e0ds6j9ZGFcyEoul6Ourg4ffPAB7t27B1dXVzAYDLz77rtYvXo1bG1tERMTgx07duDevXuYO3cuHj58CA8PD4SFhaGyshI//fSTUl/Apk2b8Pzzz2PdunUabVH7+/uRm5sLLpeLgIAAlYR1++ZNLPriCxRNm4YrZWV4ytgY/MpK2L/0EvR+5a3Cfo3o7Oyk5Ys9PT3BZrMxd+5clbpfaR98gBoA6zZvhpO/v9JjrK2tER4ePo6jHjsMJqrB+YePM8Z0G0iSJL7//ntYWlpixowZWLt2LZ2MVl9fD4FAgDfeeAPx8fFYtmwZ3nrrLdqXdO/ePQADSg5isRhffPEFcnJy6I64FFavXo1Nmzbhyy+/1GhMHA4HPj4+6OnpQWZm5rDzUdi6cyfMkpIQ8n//B5IkUXHuHMhDh3AsMhJ9fX2jehbAE8tqsmBgYICAgABERERg7dq1WLFihVqBQqM7d7AuKwv+KojqccJQoprqpWgaY2hHi8H/goODSW1QW1tLAiDj4+MV/i6VSkk3Nzdy3bp1ZEBAAGlhYUFmZGSQJEmSr776Kung4EACICUSCUmSJFlUVETu3LmTNDQ0JL/55hul1zExMSHLy8s1HltLSwt5/fp1MjU1lSwuLiYrKytJmUym9Fi5XE7KZTKyOD+ffP/998kDBw6Qvb29Gl+LJEmyoqKCvHbtGimVSrX63hNMPNra2sgb//43efOnn0i5XD7Zw3kk1NfXkx9++CH55Zdfkh0dHZM9HK0B4AGpgo/G1LIqLCzE8uXL8dFHHyn8/dKlS9DV1cXNmzdx7NgxLF26lO528/nnn2PDhg3YsWMHWltb8c477+Dtt99GQEAAtm/fjqNHj6K+vl7hfNbW1njhhRfw6aefajw2qht0f38/6uvrUVZWhry8PLo0YzAIggDBYMDV0xPbtm2DSCRCb2/vKJ7IE8vqccDdu3chcXaG+Zw5Wncorquro//V19ejo6Nj/AaqAYyNjeHu7v5YFPdrC4JUE7WaPn06SSWZUWhra8P333+PuLg4AAM6U56engPM90tO05IlS/Daa6/R3zl58iR2794NDw8PpKSkYP78+bTGelRUFC1KN2/ePLi4uGDlypWIjY1FRUUFAgICkJqaipycHIWEv7q6Ovj6+iI3N3dUKQk1NTUoKSmBmZkZvL291ZbDyGQyMJlMrc5fUVGBiooKzJ8//0mpzRRGX1MT6sLD0bZpE2Y899yIx3d2dqKlpQUAkJSUNGwh9fPzwzPPPDMuY/1fAEEQaSRJTlf2mVYO9gsXLiAsLAxr1qzBjz/+iDNnzuCTTz7BTz/9BIIg4O3tjb/+9a/DpGGdnZ3R2dkJKysrul7PxMQE4eHh8Pb2xvfff4+dO3dCT08PBgYGePrpp7Ft2zZ8/fXX+Oijj1BfX4/y8nJ4enrS57S2tsauXbvw1Vdf4cMPP9T6oVAlEyUlJcjLy1NLWNoS1WCoWwy0QV1dHczNzR+rBgVTEf39/SgqKoJMJhuwosrLYcxigaOhFVJQUIALFy4AGJgXa9asoZ3XJEk+dtLbjxM0Jqva2lpERETg+PHjdNoAQRB4+eWX6WPWr1+PN998EwsXLsTu3btpi4nKBCZJEpcuXQIAvPPOO3jttdewbt06vPHGG9i5cyfi4+Pxm9/8Bu7u7rh27Rpee+01ODg44L333lM6CZYuXYrvvvtu1Ddva2sLkiRRWlqKu3fvgiAIWFlZwdHR8ZG3b9QE7ujoUNr2SRtUVlYiLi4Ofn5+WLdu3ajOkZ2dDQ8Pj8dWf/tRQKl+isVi5OTkoKamBsBAa6pp06ahcf9+zJ49W6NzeXt705a8oaHhr26rNZWhMVl99tlnCA8PV8hv4nK5EIvFAAZeqICAABQVFeGdd97B9OnTabLS19fH8uXL4erqin/9618AgF27dgEY2FZSWecmJiY4ceIEZs6ciZKSEri4uGDDhg3YsGGD0jHl5OSorI7XFHZ2dmCz2ejo6IBYLEZlZSUqKyvBYDDg6uo6auVHY2NjMJlMNDc3PxJZUURlaGiIRYsWjeocLS0tOHHiBOzs7LBz587/KcKSyWQ4evQoCn9J9GSxWNi4cSNsbW1RV1eH5uZmlJWVYdmyZfR3SJJEcnIyvLy8hlUgGBgY/CrSAB5HaExW586dG5agyWaz6bD+s88+i4aGBuTk5AAA1qxZo9Dz7+LFiwAGrJng4GCYmJigvb0dW7ZsATCQknDs2DFwuVz09vZCIBCoHY9MJsOFCxfw+9//XtNbUAqRSAQejwdLS0uQJIn6+nqIRCJ0dXWhqKgIAEZFWAwGg77H0WIwUYWHh4+6N6CZmRmeeeYZHD9+HHFxcb9qwsrMzFTwIzU0NKCyshIrV66Ev78/WCwWvZVuaWmBQ1QUDNragBdeQF5eHmpqatDZ2Ym8vDxIJBIsXrxY4fzt7e24d++eyu5NTzB+0JisGhsbhxUCu7m5oa2tDXV1dXj48CFycnLQ2dlJWzt1dXXDvpOWlka/dJQT/uTJk4iOjsann36Kv/3tb3B3d8eNGzcQGBgIuVw+bFJ0dnZi48aNYDKZWLp0qfZ3/QtIksThw4fR3d2N3bt3Q19fnyYmmUyG3NxcFBUV0dtDbcFms5VGGzXBUKJ61NXc19cXBEEgISEB0dHRdGErFez4NeDGjRu4fv06OBwOvY2n/EpD/ajd3d1oqK8Hn8uFrpsb7t27h4sXL9Ja/7Nnzx5myba3tyMyMhISiQQzZ86EiYnJhN3bE2hBVlKpdFhGOZPJRGBgII4dOwYejwcrKytYWVlhz549qKurU9o7bbDFFBsbi+eeew4bNmyAUCjEuXPnAADvvfceFi9ejDfffBP9/f3Iy8tT2O6dOHECN2/ehFgsfiTnN0EQWLhwIeLi4hAVFYVVq1ZBLBbDxcWFTibNyclBYWEh+Hy+ylINZRCJRGhraxuVQ3ysiYoCVRiemJiIhoYGEASB2bNnP9ZklZubi+zsbPT396O8vBwBAQFYv379iFZPS0sL5CSJc7a2ePbZZ5F3/Tq8vLywadMmpXOqra0NycnJAIDw8PAnRDUJ0JismEwmxGKxwosjl8uRl5eHb775Bh9++CHOnDmDdevW4T//+Y9GUbC+vj5aY6e9vZ22uHx8fNDQ0AChUAg+n4/169ej9v+3d95RUV1dG39GukgXpBcRpEgXREERUcGC3dhFo8aosSZqNHZN7MaoMWLsig17SYgNrFgAKdJRBClKR8oAA7O/P3jnfowwMEMRTOa31qzF3HLuucPcPefss/ez09MxYMAAXLlyBa9evUJVVRW6deuGkJAQkYzIpxgYGGDSpEnw8/PD+fPn4eTkhJSUFPTt2xeysrLo1q0b8vLyRL4Gbzr5aYmnhmgpQ8XD0tKST82iLcNms3Hu3DmB+4kIqampUFJSgpycHHr27In+/fsLNT2rrKwEcblox2JBQ0MDo0ePBlD3yi+bzUZ0dDTk5OQwcOBAsTZZKyG0sbK3t8eLFy8waNAgZtuNGzegra2NrVu3goj4Rk0NraZFRUXhzp07UFVVhbOzMw4dOoRVq1YBqB6VyMjIQEFBAY8fP0ZVVRUsLCxgaGiIgoICLFmyBI6OjtiyZQueP3/eaMczDwMDA8ybNw/5+flIT08Hi8XC8+fP4eLiAgkJCairq4vcJm/6KspSdksbqi+dT79TLBYLDg4O8PLyEklTqqCgAOnp6dA9dQq6T58CK1YIHKFXVVUhPDwcRISIiIg2WSDiv4LQ/2EHBwdERETwGauAgABMnToVmzZtwqtXr0Ty68ydOxfKysqQlJTEypUrMWXKFIwaNQqJiYkwMzPDwoULsWvXLj5lz86dOyM2NhYZGRm4ceMG3r17BxsbG6GvWR+8ZWhDQ0PExMQgKysLkZGRUFFRgbS0NLS0tFo0Gj01NRV+fn5QVFQUG6r/wctta26KiooAAAHq6ujdgDZ/WVkZysvLoaysjJKSkmbvixjhEXo5w8bGppaOeffu3XH16lUUFRWJLDL34cMHbNmyBZcvX0Z6ejq2bNmCqqoqTJw4EbNnz2bqAtZk5MiRcHFxwf79++Hi4oLIyMgW8R1YWFjAzMwMRUVFePv2LRISEhAfHy9SgKcox6ampuLUqVNQVFSEj49PmzJUjUnibutkZ2cDALQcHWH9v1AaQfB0y790/fJ/A0KPrEaNGoUtW7bg0KFDmDlzJgBg4sSJWL9+PTgcDiIjI+Hg4FDrvOTkZBAROnfujLKyMoSFhcHPzw+SkpIwNTXlO/bs2bMoLy+Hm5sbUlJSarW1bt06rF69uklOdWHR1NRkprVv375FSkoKWCwWTE1NhRphSUtL1yvOlpubi4CAALDZbGRlZbVJQ1VYWIg///wTzs7OApUzv0SkAgPR9d49OJ440WCaVWxsLKSkpBAUFAQtLa0GQ2rEtBxCj6zat2+Pffv2wdfXl9kmKyuLo0ePQlNTk09qOC0tDQkJCSgpKYGLiwtsbGwwYcIEdOrUCfPnz4eMjAwePXpUa6WM/lfme/78+fj666/r7MfnMFQ8WCwWWCwWSkpKUFxcjMzMTCQkJAg1atLX16+1XM4jLy8Px48fR3p6OuTk5GBmZtbmDBVQHQBpZGSEu3fvMithXzpEhCpZWVSoqoLVgCO+srISlZWVyM3NBVAdyNwW9Nb/q4j0yWtpadX6Z/Xr148vCG/+/Pk4c+YMlJWVkZKSAnt7e3h7e0NNTQ179uyp11k9ZcoUmJqaomPHjm2qKGNFRQVCQ0OZlT0WiwUTE5NG+bDy8vJw7NgxVFVVwcfHp03/Urdr1w4jR44EUJ20a2Bg0CKa/J8L+l9ZuQJLSxRZW0O3gcWPwsJCANXxgs7Ozm1Kxvi/iEjGKi0trd5yPhwOB6dOnUJUVBSTdwcIL5PCYrHgLEBS9lNSU1Mxb948hISE4P379xgxYgQuX74s1LmiYm9vDyLCjRs3YG9vD0lJyUYbquPHj6OysrLNGyoe7dq1g6urK169elVnMY4vifz8fGRkZEBXVxfGxsb1/g/LysoQGxsLDoeDoqIiob+XNXn79i309PQ+62zg34xI+QKlpaX1Cs+fOHEC9vb2jKIBbxrVEmzcuBE6OjoICQlBcnIybt++zQzXWwIHBwcMGTIEYWFheP78ucgC/DxDxeFwMHXq1C/CUPHgTdeFnQK3VSorKwFU+yMb+l7KyspCWloaz549g6Ojo8g196KionDixAk8fPiw0f0Vw49IxmrgwIFISkpCVFRUrX1lZWW4du0aNm7c2Gydq0l6ejrWrl2LVatWobS0FGpqaigsLMTFixcxfvx4lJSUICYmpkWuzaN79+4YPHgw4uPj4e/vL7TBys/P5zNUnzuokDdCaCyqqqpwcXFBeHg4/vrrry/SYHG5XHz48AEAhPI7VVVV4c6dOzAwMBB5cSEqKgqXL1+Gvr7+Zyuq+19AJGPF4XBARFixYkWtfTzHO++fU1hYiPT09CZ3MCcnB9999x0cHBzw4cMHxMXFQUNDAwEBAUhMTERgYCBWr16NyMjIRg3VRcXR0RGDBg1CfHy8UKXDa+aTtYahys3Nhb+/P06fPt0kg+Xh4QEXFxeEhITUuVLbluFyuYiOjkZubi5MTEyEGiVxuVxwuVwYGRmJ5FTnGSoDAwNMnDjxX5sw3hqIZKy+/vprvH//vlZycllZGX755Rds2LABRITTp0/D1NQU5ubmTGxWUVERtm/fjm+++QZPnjwR+prff/89SkpKcPfuXRw4cAAXLlxARkYG9u7di+LiYowePRpDhgyBlZXVZxOmc3JygrS0dINBggUFBcyIasqUKa2SpqGmpoYRI0YgJSWlSQaLxWLBw8MDX3/9NQwNDZu3ky0IEfEZqpqVipubyMhIxlBNmDBBbKiaGZEc7NHR0XyrYjyIqouLrlu3DuXl5UhNTcWNGzfw9OlTrF+/HgsXLsT69evRs2dPmJqaYvTo0UhOThbqFy4vLw8zZ87ky2dTVFRE79694eLiwqeNnpqaivj4ePTv37/Ftc+FmQpdu3YN5eXlmDp1aquWkOdVbLly5QpOnz6NiRMnCm3Yq6qqcOvWLbi6ukJBQeGLWw0sKytDbm4uDAwMRDJUkpKSWLZsmdCjqsjISFy5ckVsqFoQoY0VL4K3LkF8OTk5REVF4dy5cygpKcHs2bMhIyMDS0tLJCcnY//+/Zg6dSoWLFiAdu3aITExEWvWrMG2bdsavK62trbA6WSXLl2QlJTEvJ8/fz6uXbuGrVu3YtmyZcLeWp2UlZWhuLgYRARZWdk6Y6AaMogjRoxASUlJqxoqHo01WDk5OQgPD0dSUhJ8fHwgLS2N+Ph4FBQUwMXFpc3HHfEkekQNO2CxWEIXMhUbqs+D0N+0GTNmwNLSslZ5ah4dOnTAjBkz+La1b98eu3btqnXspk2b4ObmBjU1NSxfvrze68bExMDLy0vgNWsaMjk5OaxZswa7du3CDz/80CRxtIKCAsTFxTHvDQwMICMjA0VFRbx+/RocDqfBB0BRUbFNaXI3xmB16tQJkydPxqlTp+Dr64vy8nJmYSEjIwNjx479rAaLiPh+JD59X5PKykrExcWBxWI1SZmjPmoaKlFGrGJER6inOS4uDnfv3sWxY8ca/GLu3bsXGRkZzN+8Kjg1UVdXx+3bt3HgwAGcOXOm3vaKioqYUAigOkCTNwUrKSlhvoQRERGIiYmBg4MD2rdvzzfiagxqampwcHCAg4MDVFRUkJKSgoSEBISFheHFixfQ0dFBjx49mnSN1sDa2lpkH5aenh4mT54MFRUVODo6YsaMGRg8eDASEhLg7+/PhAS0NB8/fkRoaCgzys/MzERUVJTAVdmqqipUVVXB0tKy0Sqr9SE2VJ8XoX4SdXR0mNp59Y0miAgLFizAggUL8OTJEyxevBg6OjpIT0+Hi4sLAgMDweFwYGxsjKFDh8LPzw9Tp07FhAkTBLbp6uqKP/74A2ZmZnjz5g1sbW2xefNm/Pjjj8jOzmYi5V1cXLB06VJ4enqiU6dOyMrKqpV7KApSUlLMl8/a2hoVFRWoqqrCq1evYGRkhKqqKmZVjGc8paSkvoggwMaMsPT09JicUOD/qwPFxsZ+1lAGNpuN8PBw2NraAqj2aT5//pzvR5Q30tLU1ET37t1bRH44IiICV65cgaGhodhQfSaE+i8qKChg4MCBuHnzZr3HsVgsnDx5EgDw1VdfYeHChQgICMDjx4+xePFifPjwARwOB5cuXYKjoyPWrVvHFJUQxNq1a1FaWgo9PT2MHj0aenp6iI2NBVCtpzVgwAAoKiqiqqoKXbt2hYyMDHJycppVjYHFYkFGRgbt27eHra0t2Gw2pKSkmMKW79+/x/v37/H27dt6f+lFpbGSyMLQmBEWD14eqKOjIyZPnvzZHlRFRUXY2NiAw+EgPDwcKioqsLCwQIcOHSArK8u8ZGRkICMjw0gUNze8EZWRkZHYUH1GhHY29OnTB/fv34ePj0+tfTk5OUzOn6qqKg4ePIhZNQpGXr16tdY5Fy5cwLt37zBnzpx6r6uuro6zZ8/iw4cPePbsGUpKSnDr1i28e/cOHz58gLW1NX799VdISEgwo76+ffvi8OHD2Llzp7C3JzTS0tKIjY2Fubk5hg4dyrfvw4cPiI2NRVRUFKysrJo0wqqsrIS/vz+0tbXh5ubW1G7XCW+E9fr1a6H7Gh0dzdSP1NDQ+OxFE3gGKyIighlhaWhofNY+qKqqwtzcHCNHjhQbqs+I0BWZMzIy4ODggGXLlmHu3Lm1dLvv3bsHDw8PAICXlxcuX74scoqCMLx9+xbdu3dH79694ejoiKVLl0JRURFv3rxhVt3S09NhaWmJDx8+tIi++Pbt22FhYYEhQ4bU2vf+/XvExcVBWVlZZINFRAgMDERMTAwqKipQVFSEwYMHw9HRsTm73yRycnJw/PhxEBGmTp362Q0Fj48fPyIiIgJSUlKwsbEReuVOTNumvorMQv8samtrIygoCLdv34aJiQn27dvHV2aqX79+KCgoAIfDQbt27XDgwIFm6HptDA0NmanmnDlz8PTpU/Tr148vPEBTUxNycnJITU1tkT7UZ+A1NTVhZmYmcrIzESEgIAAPHz6EkpISDAwMMHr06DZlqIDqsl4+Pj5gsVg4ceIEsrKyWqUfvBFWZWUlwsPD/5UigWL4EWkM37VrV/z111/w9/fH/fv3YWJigv379zOrQUpKSigvL8e7d++aXIW4PgYNGoTLly9DRUUFT58+RVlZGZKSklBcXIwTJ07A29sbFhYWtSLtm4v6lsuBaoNlaWkp9BSJZ6ieP38OZ2dnTJ48GaNHj0a3bt2aq8vNSk2Ddfz48VY3WFVVVYiMjGwxH19hYSGys7ORnZ3dpJQlMU1DqGngnTt38PPPP8PZ2RmrV69mfEMxMTGYO3cuEhMT4ejoCF1dXdy/fx89e/aEr69vi0eRA9VfpDVr1jBpOK6urvj+++8xYsSIFrvm1q1bYW1tzcR/NeU+iQj//PMPnj17BmdnZwwcOPCzfG7NAW9KyOVy4ePj02pTwqKiIlRUVDTpBzIrK4upLg5UL268efMGMTExyMnJYbb7+Ph8UelGXxr1TQMbNFZnz56Fs7Mzdu7cib/++gvBwcHw9/fnizGKj49HdHQ00tLSYGRkhKFDh7bKA9fQiKc+ysrK8OLFC74pnrS0NJSUlJCVlSVw6sdisWBsbMw8qLzjhPGVERFu3bqFp0+fokePHvD09Gyxzy0pKalBDafGkJubi2PHjrW6wWoqJ0+exJs3b2ptNzAwgLm5ORPPZ2Rk1GIBpmKaaKxmz56NBw8eMH6iK1euYM6cOUhLS2vz8USiwOFwmLgp3gPN+7XV0NBgFgtYLBYeP34MTU1NdOnSBYWFhbVKxLNYLKFW8EJCQnDz5k04OTnBy8urxQxVSkoKjh07BltbW5ibm6N9+/Z8gbZNpabBmjZtWqNKl7U2GRkZYLPZfD9KmpqaLRJMKkYw9RmrBkMXbG1tsWnTJkREREBCQgIcDgdcLveLmaoIi5SUVC0pZR0dHaZyT8375YVqGBoagsvlIisriy+2StjPxsbGBkSE7t27t+jnqa+vj969e+Phw4cIDw8HUB3e0VwhEWpqapg2bRoOHTqEBw8eMAVDvyS0tbVbuwtiGqBBY+Xo6IiZM2dizJgxkJCQgKqqKs6cOVPLeVxZWYmysjKsXLkSRISNGzdCSUkJgPAPb0lJCSoqKiAtLY2KigpwOBwoKSm1WnlzWVlZSEhI4OPHj8y9AOBboWvXrl2jpV+kpKQ+y2ofi8VCv379YG1tjfLycrx48QJBQUEA0KwGS0lJSeyAFtNiCLVctXr1aiQmJiIuLg5PnjxBv379+Pbn5OTA1NQUCgoKCAkJQXx8PPbv3w81NTVISkqiffv2MDIyqlPJMzs7G56enlBSUoK6ujqMjIygoqICfX19dOrUqcGg0ZYmMTERERERtaZ6XyIdO3aEjo4Ohg0bBhsbGwQFBdWqBdkUePFuX5o4n5gvgyaFHxMRfvzxRzx48IAZVe3atQtDhw7FgwcP4OzsjPLycoSGhsLY2Bjnz5+vdf6gQYNgZWWF169fIzw8HH/++SfOnDmDuXPnQldXV2A5q89Fly5dICsri6ioqDrlcb5E2rVr1yIGa9iwYVBSUoKfnx/evn3bLG2KEcND6Ah2HlwuFwcPHkRaWhrGjh0LW1tbqKmpIS8vD2w2GzIyMjh//jzWrFmDESNGYPXq1fD29kZgYCD8/f0xZswYpi0igpmZGfT19aGvr48zZ87A0dERysrKsLe3x+DBg1vcnyMMFRUVePnyJVgsFpycnFq1L80Jl8vFtWvXEBERATMzM8jJycHU1BRmZmaNbrO4uBjHjx9HYWEhJk6cKF7mFyMSTVoN/NRYPX36FN7e3rC0tIS+vj4CAwNx9epV5OTkYODAgQCqJWV69uyJPn36IDc3F7Kysti9e3edQY6lpaX4+++/kZWVhT59+vApgrYl0tPTmXiyf9PSNZfLRUBAAOLi4lBZWQk2m43hw4czqgaA6CEhYoMlprE0q7FKTk5G37598fjxY2bU4+XlhT179uDEiRMoLy9HdnY27t69i44dO8LOzg4bN25s1oTX0tJSBAcH4+PHj3B1df0sS+Xl5eUIDg6GgYFBi0XGtzYcDgfnzp3D69evMWzYMNjZ2aGsrAzR0dGMT1JYxAZLTGNoVmNVUVGBDh06oLS0FKmpqZg0aRKePn0KNTU1ODs7o0uXLvjw4QPmz5/fImWIgoODMWbMGBgZGUFRURFRUVFISkqCtLQ0Xr16BQsLCwQEBGDp0qUYMGAAZs2a1WxpK1FRUcjLy4OFhUWLGkhRi8M2JzUN1vDhw2FmZobw8HBwOBzIyclBSkoKpqamQiUO89KfCgoKxAZLjFA0SyIzD97qXnZ2Nl68eIGnT59i+vTp6Ny5MzgcDpSVlXH27Fns2rWrRSr4Llu2DJs3b8ajR48wc+ZMSEtLg8Vi4enTp7C2toadnR3Wr18PW1tbKCsro1evXvj555+b5drm5uZQUFBATExMiznbeX6kf/75p1Xq80lJSWHcuHHo3Lkzrl69iri4OMYvKSMjg6KiIqEThzt06ICpU6dCWVkZp0+fFjvdxTQJoYxVZWUlXr16BSJCYmIi5OXl8fr1a4wfPx4AcPToUUYCeP369bhx4wbatWuHJUuWNFtHU1JSkJSUBCMjIyQnJ6OyshJLlixBjx498PjxY/j7+8PNzQ1RUVEoKSnBzp07sX79ekyePLnZjKakpCSsra1BRMjLy2uWNmtCRLh+/TrCw8MhKyvbagsLUlJSGD9+PGOwsrOzYWFhASsrKyZxODw8nC+XThA8g6WkpCQ2WGKaRL3GKjY2Ft26dYOXlxesrKywZcsW6OrqIjc3l5Fk4XA4KC4uxt69e7Fp0yasWbMGXC4XCQkJMDc3h5GRUa2QhYZITU1FQEAAMjMzmW1TpkyBiYkJdHV1kZycjIqKCmRmZuLMmTPo168fjhw5glevXgGoLrjK69+bN28EFrloDDz5XEHBj43VIyciXLt2DeHh4XBzc0Pfvn0b28VmQUpKCt7e3gCqY+F4KCgowMbGBmpqakILz3Xo0AE+Pj7iEZaYJlGvsdLT0wObzcbLly9x8+ZNnDp1ChISEqiqqoKuri64XC4kJSUhLy+PxMREDBs2DCdOnMCOHTvQs2dPODo64u3btzhw4IDQU5rs7Gw4OTlh69at0NXVZSR016xZAwDYvHkzUlJS0L59e4SHh+PChQuQk5PD9u3bcenSJYSGhsLFxYVpr6ysrNlFANXV1ZGZmckUxuDx7t07hISEMAUNhKXmiKpPnz6tbqh48HI/eWXXeSgoKMDU1FSkRRPxlFBMU2nQwf7XX39BQUEBMjIyGD9+PIgI9+7dQ3x8PDp27IjU1FRs3rwZFy5cwKhRo+Dm5oasrCxs374dbDYbcnJyyMjIwOHDh/H111832KE//vgDf//9N/z9/SEvL4+KigrmoRg6dCg6deqEiRMnMqqkgOCl9bCwMAwYMAChoaFCOXfLy8uFSu2pWY7czs6OScXhqVfKyckJHcxKRLhx4wbCwsLQu3dvuLu7t3pcWU2uXLmCiIgIuLu7N8sIled0z8/Px6RJk8ROdzF81OdgBxEJfDk4OFBNysrKyNLSkgBQeno65eTkEIBaLzU1NUpKSqI9e/aQjY0NAaCdO3eSMNy9e5d69OhBmzZtIg8PD2Z7cXExmZqa0oMHD+o8b/369QSABg4cSGvWrKFJkyaRiooK+fv7C3XdwsJCun//PmVkZAh1fElJCQUGBlJmZibf9oSEBHr48KFQbRARBQYG0rp16+jOnTvE5XLrPCYtLY2qqqqEbrM5qaqqokuXLtG6devo/v37zdJmUVER/f7777Rp0yZKTk5uljbF/DsAEEIC7JFIq4EyMjL48ccfAVSL5ldVVaFz585MYQYLCwsMHz4cW7ZsgbGxMTw8PFBSUgIPDw+hxfAqKyvx7NkznDlzBkePHmUM6vjx4+Hq6gpXV9c6z+MJ4d26dQsA4OHhgYiICL6I+fqQl5eHkpIS4uPj8f79+waP5432ioqK+LazWCxUVVUJ7dR3cHDAwIED0a9fvzpHVPHx8Thy5AgePnwoVHvNTbt27TB8+HBYW1sjMDAQDx48aHKbvCmhioqKODVHjNA0KoJ91qxZiIqK4tu+aNEiLF68GAYGBgCqFRRWrFiB5ORkXL9+XegOcblcvH37Frdu3cKNGzdARIiJiYGUlBSio6PrderyCqIGBASgZ8+eQl+TB68uYH5+PszMzOpVUyAixrDZ29szlZd5Pj4igo2NDaOH9PbtWygpKUFFRUXo/sTHx+P8+fPQ0tLC5MmTW6QAh7BwuVxcvXoVkZGR4imhmBajWeOsnJ2daxkqANi9ezdjqK5cuQJ9fX1kZmZi//79onYWW7duZXxc3377LS5evIi4uLg6DdWTJ0/g5uaGrVu3wsLCAv3792dKTImKhIQEunXrBmVlZcTFxdVyLH/az5orojzk5ORga2sLFouF6OhoRhf8+PHjjJaUMCQkJOD8+fPQ1NRsdUMF1B5hPXr0qMlt1hxh3bx5s0XrJIr58qlXz6qxw/OQkBDk5eXh4sWLGDp0aJ21BgXx8eNHHD58GHl5ecxopT5u374NFouFV69eYcuWLZg0aVKj+sxDQkICVlZWiIqKQmxsLFgsVoNSvZ9O39q3bw8TExNER0cjKyurUXpXt2/fhpqaGqZMmdLqhooHz2CVlZXh3r176NWrV5PTqHgGi1cVSYwYQdT77cjNzYWKigosLS1x8eJFANXTn5ojhrpYv349ysrKsHz5cmzYsEGkDvF0rQoLC5ltVVVVOH78OMaOHYtZs2YhISEBqampOHz4MI4fPw5vb2+cPHmyyYaKB2+EpaSkhISEhEYJynXs2BHy8vJISUlpVCQ6h8OBtrZ2mzFUPNq1awcdHZ1mDYzt0KGDSNNjMf9N6h1ZmZqa4vHjx1i4cCHGjBmDe/fu4fHjx1i9ejW+//57ODo6wsLCAt26deMbXRARxowZg9TUVPj7+4vcqX79+qF3796YMGECSkpKcPHiRWhpaWHWrFlISUlB9+7dISEhAU9PT/zxxx/w9PQU/c4bQFJSElZWVkyp+LrgbU9LS4OysjLfyIDFYsHAwAAxMTFMqSphQxJCQ0NRWFgo1MiyNVBVVQUA/P7779DU1ISjoyPs7e1buVdi/u006GB/9uwZ+vTpgydPnsDKygrFxcU4cuQITpw4gY8fPyI0NBTKysrQ0tLC8+fPISMjAz09PcjIyODOnTuNKq9NRAgJCcGVK1egpKQEb29vmJubM/vz8/NBRMxDIwoVFRUIDw+HpqYm9PT0mhzTlJGRgYSEBKiqqqJbt258BouIEBoaCjabjZCQENjZ2TUY8BkWFobr16/DxMQEX331FRMx39YoLCxETEwMoqKikJmZyfzAiBHTFJqkutCrVy/4+vpCXl4eERER0NPT4zumqqoKDx8+RGFhIbp3747i4mK8fv0arq6uzT4yICJUVFQ0SZN97dq1+PPPP8HlcqGnp4c7d+7w6as3Bp7B6tixYy2Fh/LycoSHh6OoqAjt2rWrJQldEyLC2bNnweVyMW7cuDZrqGrC5XJx5coVREVFtblS92K+PBodFGpmZkbXr18nNTU10tPTo7FjxxKHwxE6wIvL5VJWVpbAYMeGyMnJIS6XS0+fPqU5c+aQnZ0dAaBJkybR999/Tz4+PvTy5Uuh2oqIiCBbW1sCQJGRkcTlcsnS0rLBoFFh+56YmEiBgYF1fj5sNpsCAwPpxIkTlJWVVW87HA5HpM+4LVBVVUX79u2jkydPtnZXxHzBhISEND4oNDExEQcOHIC1tTVYLBb8/f1FWrL++eefoaGhATc3N8ybNw+pqakNnkNE+PjxIwYPHoyOHTti06ZNcHFxgZaWFtasWYO3b99CSkoKqqqqKC0tFTo0wt/fH+Hh4XB3d4efnx/WrVuH1NRUDBkyROA579+/R0xMjFBL6vWN9nj7qqqq6iykWRNJSckvYkRVk3bt2kFWVhZlZWWtImsj5t8BL7hcEPU+FRYWFhgyZAhWrFgBWVlZbNq0qcHSTRUVFSgtLcXhw4dx6NAhANXVb5KSkrB//35s2bJF4LllZWVQUlJCZWUlZs6cicmTJ2PNmjXYuHEjVq1axRzHi2wfN24cHBwc6u0Pjw0bNmDChAkICwtDamoqSkpKcOvWrXpF5DgcDqM4YG5uXu/SekMPqYKCAsrKylo97+/Vq1cICgrC9OnTG5RnFjZXEqhejLl37x7++usvDB48WOB9cjgcpKWliZzsLebfhaysLHR1dfl82g1ppNVrrKSlpTFnzhxoaWlh0aJFWL58eb0PG0/yODU1FR07dsTLly9RVVUFNTU1xMTE4KuvvsKmTZv4Rg4cDgd37twBEcHDwwMmJiaYO3cu5syZg/DwcGhra2PlypW1rnX06FE8e/YMBw8erPcGebBYLFhYWMDCwkKo44Fq1Qkiwps3b8BisWBmZtZgLBCHw6k1MuKde+PGDaGv3VKUlZUhNze3QeNaUFCAI0eOoHfv3kL5oVxdXVFWVoYnT54AgECDlZaWBgUFBRgaGra64RbTOhARcnNzkZaWxkiEFxcXN7hgJtR8Y8SIEdi1axfOnz+PiRMn1nnM1atXsXbtWsyfPx8XL16EkZERX4lyJycnsFgsvH79Gl27dgVQ/WCbmppCU1MTVVVVOHnyJKZMmcIYBzs7O9jZ2fFd58OHD3jw4AGWLl2KJ0+eNNk53hD6+voAwEzfzM3N63zI1NTUkJKSgsjISNjb29daBeVwOOjVqxejH29iYoKOHTu2aN/rghcb1ZCh6NChA7S0tPDXX3+hU6dOzOcgCBaLhf79+wNAvQarrKxMbKj+gxARioqKwGazoa6uDjU1NWRnZ6OsrAz5+fn4/vvvGxRzFNo5MmXKFPz9998wNjbGgwcP8P79e/z4449QV1dHamoqfHx88Ouvv8LHxwc//PBDrfOjoqJQWlrK96VPS0tDZWUlgoODUVpaChMTEzg7O+PJkyd1yr6Eh4ejV69ecHBwgL+/P0xNTYXtPoBqn1FGRgYkJSWRl5cHY2NjoYIu9fX1QURITk6GhIQEY2xrIi8vD2tra2RlZdXpc2rXrh2ysrJgYGAASUlJRigQAHr16gVpaWmR7qUxvHv3DsHBwbCwsED79u3rPVZSUhKenp5ISEhAXl5eg8YKqG2w2rdvD3d39zqPE/PfoqCggPFZl5WVQU1NDfn5+fD09MS7d+/g4eHBV1GpLoTKb6ioqMD169dhZmaGvn374sGDB9i7dy9++eUXAGBGN97e3nVOk4gIy5cvx/Lly/l8RKmpqUzyKk+twN7eHvn5+Yx6QkhICCNy9+TJE4wdOxYPHz6s8yEQREZGBpYvXw4NDQ04OTnBzs4O3bp1w40bNxAfH4+cnJwG2zAwMEDnzp3rTb1RUlKCiYlJnQ+jlJQUkpKSkJ+fDxsbGxgZGcHAwAAGBgaMyF1Lw8sK6Nu3r1AGg2d009PThXac8wyWMF++1oKXXF6TdevWYceOHQCqH6YBAwZg/fr1AKozGmxtbZlXY9LQjh07hu+++65J/Qaqn6UFCxagS5cusLa2RlhYWJPbbGkqKirw7t076Ovrw9zcHOXl5UzVbn9/f4SGhiImJobxRQuiQWP1/PlzODo6gsViYfHixdDV1WVW1Xi+DElJSXC5XIEP3blz5/D27dta/6yUlBQm+ZnFYiEvLw89e/bE+PHjMXv2bHz11Vfo06cPevbsibNnz2LDhg0YO3Zsgx/OlStXoKmpib59++L69euwsbFBWVkZXrx4gczMTPj5+aFLly4ICwtD3759YWNjg5SUFPz55584e/aswFVLfX39RqeF8AT5wsLCkJaWxpT0MjIy+mzGimdwhB3ZKCoqwt7eHiEhIXj37p3Q12GxWHB1df0iU2gqKiowevRoODg4YO3atQCq/3fh4eHMqzXVIf7++28kJiYiMTERBw8exJw5c1qtLw1RVVWFzMxMxMTEQF1dHSoqKpCWloapqSksLS2hoqKCHj16wN7eHvr6+nxuo7qo11glJCRgxIgRWLZsGa5cuYL27dsjMTER7969wz///MP4r6Kjo2FsbFznl7Oqqgrfffcdjh8/Xmuq8+bNG8ZYlZeXQ0pKChISEli7di1OnDiBAQMGIC0tDYsWLcK+fftw5MgRDB06tN4b+vPPPzFy5EgcP34cPXr0wLBhw+Dh4YHffvsNnTt3BlCtRqqnp4fNmzdj165dyMjIQNeuXXHv3j2cPHlS6BVGUenRoweA6rqHXwo8xdMvqc+NpbKyEuPHj4eJiUm9q9ZA9XfeyckJtra2sLa2RmJiYq1jjh49ClNTU7i5ueHx48fM9uvXr6NHjx6ws7ND//798eHDB3C5XJiYmDCrz1wuF126dKk16r969SqmTp0KFosFZ2dnFBQU8NUqaCuw2WzExMSAzWbDxMSEUSgRxLRp02ppw31KvT4rDQ0NREVFNVgjrqCgAFlZWUxcUt++fZnpYGZmJvLy8mBlZVXrvCdPnmDu3LkAgIiICNjY2DC/+n369GE0kxYvXozFixfX2wceVlZW6NChA+zt7dGrVy9s27YN586dw+HDh5ml+pcvX+LNmzdYv349Ro0ahf3792PUqFFQUFDA2rVrUVRUhMGDB6O0tBSzZs3CxIkTW8zPUlpayhiC9u3bN+hL+jcREBAglNChKGhqajJCjKKybds29O/fH7t37+bbzmazmSmtkZERLl++jAMHDmDhwoWYNGkSKioqUFVVxXdOZmYm1q5di9DQUCgpKcHd3Z1ZLHJ1dcXTp0/BYrFw6NAhbNu2DTt37sTkyZPh5+eHRYsW4c6dO7Cxsam1CJOens6XRaKrq4v09PQGjcHnpLKyEtHR0dDT00OnTp2EOsfT05MR9hREvSMrZWVloYpZ9u/fH/b29pg7dy48PDwgISGBI0eO4PTp07C3t8fWrVvrdGSXlpbi/v37eP/+PYqLi0VOzwkMDISxsTHMzMyYL312djYqKipw5MgRKCgo4MyZMwD+X0EU+H91zytXrkBGRgZz5syBuro6VFVVsWPHDsTHx0NCQgLz5s3D1q1bRdbkAqqlbmoqRwgiKysLr169wqtXrxhpnbaEmpoapk2bJpSD/UvH1dUVwcHBSEhI4Ntecxp4+fJlAEDPnj3xyy+/YOvWrUhJSan1nDx79gx9+/aFuro6pKWlMW7cOGZfWloaPD09YWVlhe3btyM6OhoA8PXXX+PEiRMAgCNHjmD69Om1+liX77CtLVhISEhAQkICHz9+RElJiVDnGBkZ1TmgqUmTQqU/fvyIc+fOwc/PD6GhodixYwdWrFgBJycnzJgxAx4eHjh37pxAZ/i2bduwb98+aGlpoWPHjpgxY0aD10xMTMSGDRtw6tQpAMDNmzfx6NEj+Pj44O+//8bJkydRUVHB3Pj48ePh5eXFFwCZmpqKXbt2MZVzACApKQnl5eXo2bMnZs+ejYkTJ0JKSgq3b99GSUkJuFwukpOT0alTpzodtDUhIiQkJIDNZsPa2ppZgODVAnz58iXMzMwgKSkJLS0tqKqqMue8evUKVlZWbcbfIy0tzUzVm5vGjoBaij59+sDHxweDBg3Cw4cPoa2tLfDYiRMnokePHrh58yY8PT1x6NChWnmfgozI/PnzsWTJEgwbNgxBQUFYt24dADAjkXv37uHZs2fw8/Orda6uri6f/zAtLa3efrYGvJjGjx8/IjExEdbW1kJplZ0+fbr+H0VBeThEBFlZWRo5ciRdu3aNr2BBamoqzZ07l5SVlWnEiBF0+fJlKi0tZfaPHTtWpDyxtLQ08vPzqzcnLjIyktLS0sjNzY2+++47AkBz5swhoup8OicnJ/Lz86P09HRSVlamiIgIoa9PRJSZmUk9evSg9PR0vu03b96kzp0706pVq0hRUZHMzc2Fao/NZlNwcDA9ePCACgsLme1hYWG0bt06io2NrXVOeXk5PX/+nO7fv095eXki9b8+KisrKTExkcLDw2ndunWUnZ3dbG2LSkxMTKtdm4e8vHytbWvXrqXt27cTEdEff/xBVlZWlJ+fL/D4169fM3mjCxcupF9//ZVvf0ZGBunr61NOTg5VVFSQq6srzZs3j4iIbG1tKSQkhIiIpk2bRm5ubsx5Fy5cIC0tLVq2bFmdfb9x4wZ5eXkRl8ul4OBgcnR0FOnePzevX7+mt2/f1rmvru8C6skNrNdYWVhY0NGjR8nOzo4sLCzI29ubbG1tSUVFhZYuXSqwEszMmTNr/fMaS2VlJS1dupQ6dOhAXbt2pa5du1JISAh9/PiRL8l4586d1Lt3b4qKiqIjR46Qs7Nzs1w/MTGRAJCOjg6dPXuWOnToIHRyc02DVVRUxGyvL5m5vLycnj171qwGKy8vj4KCgujhw4e0cePG/7yxYrFYpKOjw7x27tzJZ6yIqo1X7969ic1m12msfvnlF7KwsCAbGxvy9PSk3NzcWsccOXKETExMqE+fPrRgwQLGWF25coWMjIzI1dWVfvjhBz5jVVFRQQoKCnX+mBFVJ9bPnTuXOnfuTN26daMXL1408dNoWTgcDoWGhlJRURFVVlZSTEwM5eXlMX/XJD09vV5jJVTBCCLCo0ePkJubCx0dHVhaWtbrCL537x7mzZuHmJiYJs2n6X8xJREREbh8+TLjbKyqqqo1rCwuLsbPP/+Mffv2wdvbG+np6bh//36jr82Dy+XiwIEDYLFYkJeXx7Zt2/gCOhuirKwMz549g66uLoyNjYU6h6e5VVZWBg0NDeYzZLFYUFFRgaqqqsjhDtnZ2YiOjkZRURH09PQYH6KkpCS6dOkiUltNITY2lk+bTAw/ISEhWLx4catVM2oJ8vLykJaWBikpKZSUlEBWVhYcDgelpaXo2bMn8ywvXLgQe/bsESgRI5TPisViCRRWe/bsGWJiYjB9+nRGMG/dunX48OEDsrOzG9Qvr49//vkHAQEBePHiBZSVlTFp0iTIyMjUOf/t0KEDNm/ejKNHj+LMmTNCObeFoV27dvDx8cGZM2fw/fff4+7duyKdz/NTiVIMQVpaGtnZ2VBQUOBzuPMi8CUkJKCuro6uXbsK/WOgrq4OHR0dJCUlIScnB3JycmCxWEJFzpOAIrJimpctW7bgjz/+qNNX9SWjqqoKZWVlFBYWorKyEh07dkRlZSUePnyIEydOYNq0adi/fz+zGCYQQUMuqqPI6aeUlJQQAJKWliYiIm9vbwJAoaGhpKSkRGw2u87zsrKyaPny5TR+/Hjy8fGhU6dO1Xmcu7s7nTlzpsGhZk18fHyo+raaxvv372n37t3Uq1cvkpOTI09PTwoLC2P2f/z4kXbu3Em3bt1qsK2XL19SUFAQn++qIXbu3ElXr17l21ZVVUV5eXkUHh5OgYGBVF5eLvwN/Y/o6Gjau3ev0H0pKCigP//8k96/fy/yteqiLUwDxXweKisrKTs7W2CB3pcvX1KnTp2oT58+JCcnRwkJCfVOA5u0GsiLnuUVheDVBxw9ejS2b9+OnJycWlGpHA4HgwcPhp2dHby9vcFmszFnzhz079+fLyajsLCQGakVFBRAWVlZqD79+uuvGDhwYKPv6f3791i2bBmuX78Ob29vrFq1Cu7u7rVCLxYvXox79+5BUlISvXr1wqFDhwTqUFlYWODJkyfIz88XKTyDV+C0V69ejOKDiooKSktLkZ+fj8rKSpFzCi0sLNC1a1dmGhkcHMwsnddFQUEBKisrUVlZKdJ1xIhJT09HVlYW8vPzYWJiUmu/jIwMXr9+jXv37sHGxqbB8JhG1z4qKiqCv78/tLS04OXlhdevXwMADA0NYWpqipUrV8Lc3BzHjx/nO2/Tpk1QV1eHr68vJk6cCA8PD0hKStZST8jJyQGXy0WPHj0ajL+oiYqKikBliPqIi4uDpaUlzMzMoK2tjbdv3+LEiRMYNGgQn6G6ffs2Zs+ejREjRiA5ORk3b95Eamoqs/xcFzwjJkqVnO7du0NLSwulpaU4f/48YmJimH284hSvXr3iC78QFp6hun//Pm7dugUulwtZWdk6X7q6upg6dSp0dHREvo6Y/zalpaXo2LFjvWEL8vLy8Pb2Fi6OT9CQi+qZBubl5VHXrl1pxowZZGhoSImJibR+/Xr65ptvSEZGhgYPHkzh4eHk6+tLtra2fOdqaWnRpUuXiIgoNDSUdHR0aN++fbWuweVyafPmzSQtLU0uLi506NAhkpKSIgsLi0bLJAuCw+FQjx49aN26dZSTk8O3LykpiZYsWUL+/v7E4XBo1qxZBICUlJQIAJWXl1N6enqdK0Y1iYyMpMDAQIErqIIoKyujw4cP0/r16yk6OprZnp+fT/fv36dnz541ajpIRPTq1Su6du1as3+e9SGeBv53ePXqFYWGhtKHDx/q3N+soQs8Y3XhwgW6du0aEREFBARQhw4dmBin/v37019//UWmpqb0119/EQBSVVUlOTk5kpeXp99//52vM9evXycVFRXS09MjDQ0Ngf6qqqoqMjQ0JAB8r02bNonyedVLcXExlZSUUEZGBgGgZ8+eMftSU1MpJiaGlJWV6ccffyQZGRkCQLq6ugSANm7cSAsWLCCiasPaoUMHevz4scBrVVZWMr4mUXxXRP9vsDZs2MAXdlDTYFVWVop4962D2Fj9dygqKqKMjAyB380WMVY9e/YkALRq1SqysLCg9evXM40vWbKErKysqEuXLnT16lXS0NCgRYsW0dSpU2nEiBGkrq5O9+7d4+tQYWEhJScnU1lZmcAbrayspL59+xIA0tTUpKtXrzbrCODnn38mRUVFkpCQIAkJCTIzM2MCQn19fUlVVZXk5eVJUlKSnj9/Tn5+fvTbb7/R7t27GcNZ859w48YN6tSpE23evFngNYuLiykwMFDgL019pKam0rp16ygxMZFve15ensCgu7ZIWzBWDQWFstls6t+/P61bt46IiNq1a0c2NjbMKzk5WeRrHj16lImzagqxsbHk7OxM0tLSfHFhXyKiGqsGHezLli1DcHAwVqxYgY8fP2LGjBl8ScUbNmyAjo4O3N3dERQUhHHjxuHXX39l9t+/fx9jx47lU0xQVFRs0NEsISEBaWlpdOjQAYsXL8b79+8xZ84cFBcX4+TJk01aSn/48CF++uknKCgoMBpaz549g6SkJAICArBq1So8f/4chw4dwpYtW/DixQsm4RqodsJv2bIFsbGxTOmtIUOGIDw8HN27d0f//v0ZtYKa8PpcVFQkckiHoPtVUVFpM6k5/wbqk4hpC6iqqmLPnj24cuVKa3fls9OgscrPz4eBgQF27dqFw4cP1yrRLi8vjyVLlgAAU5V37969AKrjhYqKinD58mVMnjwZQUFBjMCZMPj6+uLWrVuIjY3Fo0ePcP36daiqqmLJkiWMLKqKigp8fHwYLWdh4BnTzZs3Y+zYsdDX10dRURFYLBamTJmCq1evwtjYmHHs84TCePCCGj91OktLS0NTUxPp6el1Gis5OTl06tQJ7969g6KiItTV1YXus7KyMgYNGtQqUsj/FUSViJk+fToqKirA5XJx8eLFWiteR48exebNm6GlpQVTU1Om+Mb169exadMmVFRUQE1NDX5+fkzc3JMnT6Curg4ulwtTU1M8ffqU73+uoaEBDQ0N3Lx5s/k/gDZOg8Zq3759mDZtGiP9IgjeqpSqqipcXV2hoaEBdXV1SEpKwsXFBeHh4ejcuTOWLFnCJF5WVlbi7t27OHv2LB4/fozBgwdj586dzGqVoaEhvvnmGwDVssjXr19HSUlJLQmP9evXIzc3V6gKzWw2G7dv34aSkhJWrlzJFMJQUVFBVFQUZGVlGblkDocDCQmJWlpF7u7uOHfuHN+IhvfFk5eXh7u7e52R2rzCEYqKilBTU2uwrzXp0KEDnJycRDqnrZOYmIji4uJmbbNDhw51LpMLw5cgEfNfpkFjVVxcjOvXr+PFixf1Ll9zuVzIyMggKyurzlQQJSUl2NraIjIyEtra2jh58iRWrVoFDQ0NTJ48GQsXLsTixYuxYcMGrF+/HhwOB3PnzkVqaiokJCRARNi/fz/GjRsHXV1dmJmZYe/evXBwcMDbt2/rNFSrVq3CmTNn4O7uDjU1NcjJycHf3x99+/bFhQsXUFJSAiUlJT7jaG1tDTMzM/zwww/o3bs35OTkcOvWLSQkJDBGTE9Pr1Zlamlpafj5+WHu3LmYNGkSbty4gUePHsHFxYXvOBaLJQ4DaKPUlIipqe9f1zSwZ8+e+Pnnn5GWloZRo0bVMpA1JWKA6rJxPOmZtLQ0jBs3DpmZmaioqGBmBV9//TWGDx+ORYsWCZSI+S/ToLHiadJcuHABq1evFnhcWloaysvLmZiiysrKWkZLQUEBOTk5ePDgAX744Qdcv36db7Rw4sQJdOvWDWvWrMGzZ8/w5MkT7NixA1VVVaioqMDRo0excuVKDB06FBISEpg4cSLYbDZ27twJMzOzWn3S1NTEmzdvMGfOHOTn5yMiIgKOjo7Iz89H9+7doaGhgdGjR2Pu3LkoLy9Hr169kJubi9zcXKxYsQLa2trML7+rqyuuXr2Knj171nn/RISNGzeiQ4cOyMjIwJUrVzBkyBDMnDkTGzZs+E+J6glLY0dALcWXIBHzX6bBoFCeeNaGDRvqLUzZuXNnmJqaomvXrrh27Vqdo6vJkydjypQpGDlyJHbs2FFrWvPx40dmXq+mpoa8vDzY2tpi6NChGDVqFK5fv46YmBgMGDAAiYmJWLx4MTZv3oxFixYhMDCQr63S0lJoa2tDUVERRARfX18QETQ0NPDVV1/hxIkTmDlzJqNOmJOTg7dv3yI1NRVBQUGws7NDcXExEyGek5ODvn37ClS2pP+VGkpPT4efnx+GDx+O6Oho3L17F/Pnz2/oYxbTRhg9ejSWLl0KLy8vFBQUCDzuzZs36Ny5MxYsWIBhw4YhMjKSb3+PHj0QFBSE3NxccDgc+Pv7M/sKCwuZ0fWnQdO84r5fffXVZ9Pm/2IQtExI/wtd4C3jjhs3rt7QgcLCQpKXl6e9e/dSampqncew2WxasWIFvXv3rs7ze/XqxUjLBAYGkrm5OQGgmzdv1jr++fPn1LlzZyIiunfvHnXs2JHRCCKqDk0AQCoqKqSqqlqnvtWjR4/IycmJiKp1q0xMTJhwBA6HQ2vWrCEApKenRwsXLiQAdPz4cYGfQUhICL18+ZJ5X1ZWRmpqanT9+nWB5/zXaAuhC1+yRExmZibp6OiQgoICKSkpkY6Ojshxe22FZo+zOnDgAHl4eDQYdFhSUkI//vgjE4OUlpYmVIdLSkpoz549pKWlRXPnzmUE+JYsWULa2tpMe0+fPuU7j8vlkpaWFj158oSIiC5evEi6urqUmppKKSkpNHPmTAJAvXv3JgsLizqvffbsWRo5ciQREW3dupWWLFlS65g5c+YQAHr06BFFRETw6VLVR0VFBf3yyy9tXhztc9MWjFVb5sWLF+Tq6tra3fgsNKuxsrOzI01NTfrnn3+EuviKFSvI2dmZb4RTHwEBAaShoUHDhg2jsLAwSk9PpzVr1tDs2bPp3LlzpKenRxcvXhSYTnLx4kXq0qULM+L79ddfSUFBgVRUVGj8+PFkYWFB3bt3F/iAPHjwgHr27Mm01bt371pqpZmZmQSAJk6cKNQ9EVWPsNTV1cnJyYmio6M/azpLW0dsrASzefNm0tfXp4cPH7Z2Vz4LzWqsLC0tmZHN5cuX673w8+fPSUtLS+jobDabTdra2jRhwgSysrIiTU1NUlRUpLlz59LSpUtJU1OTJk2aVCvdpuY0LCIigrS0tCgsLIyWLFlCSUlJ9PjxYxo2bBgZGBjQpUuX6jUU58+fp0GDBhERUWlpKXl5eZGhoWGtqZ6joyMBECh1UZO8vDymryYmJjRkyBCSlpamWbNmUZ8+fejGjRtCfT7/VsTGSgyPZjVW9vb2dPHiRTp9+jTp6+vXe+F58+bVm2ryKb6+vjR48GCSlZWlW7duUXp6OlVUVDD779+/T7a2tgSAjI2Nyc3NjXR1denixYvMMUePHqV+/fqRqqoqWVhYkKSkJKmrq9Ovv/5KJSUl9V4/OTmZDA0Nyd/fn297cHAwqaurU3x8PLMtIyNDYA7jp+Tm5tKgQYMYg7VixQpKTEwkNTU1kpWVJV1dXfr222/r9HH8FxAbKzE8WiQ3kMPhkLq6OgUEBAi88OTJk+mPP/4QuqOLFy+mX375hb766ismIfhTePrnkZGRde5ftGgRubm5kbu7O2McUlJSGrz2ixcvSFNTk+bPn09Dhw6lsWPHUllZGfn6+jLt8EZcjYFX0GLp0qXMNi6XyzjrAdCVK1fo4MGDfIU2/guIjZUYHqIaK6H0rCQlJeHv74/p06dXW7g6GDlyJLM8S0QoKSlBeXm5wDZdXFwQFBSETp06CUw7MTY2Rk5OTp16VqWlpfD19cXo0aPB5XKxYcMGpKenN6iL8/LlSwwbNgxWVlY4c+YMPDw8kJ+fj/379zOa0JMnT0ZwcHC97QgiJiaGKS+2adMmZjuLxUJGRgaOHDkCVVVVLFq0CIsWLcKxY8cadR0AYkE8Mf8tBFkxotp6Vjo6OnTixIk6rSSbzSZVVVVSVlZmRicDBw4UaFWLioqoY8eO1LVrV7KwsKCEhASRrHJ+fj4ZGxuThYUF4ySvDw6HQ9u2bSM1NTXq0qULWVpaMtcMDg6mzp07U1FREXXu3FnoBYW68PLyIgDMKuWnnDp1igDQmjVraNGiRfTLL7806jppaWn05MmTL25kJh5ZieHRItNAHpGRkaSjo0O7d++u8+JZWVk0ZswYsrGxoYCAgAYd0nfv3qUBAwYwxk1fX5+2b98utOEKCwsjADRp0qR6jystLaUBAwaQk5MT9e3bl6ytrfl0obhcLnXv3p2uXbtGJ06cIHt7+0bFrsyfP58A0A8//CDwmMDAQAJAbDabhg0bRkeOHBH5OkTVGvAPHz7k0+D6EmhtY5Wfn19LY60pfBqfJQqCZGMEbTcwMGC+tyEhIWRoaEhhYWF09OhR6tixIyNhM2XKlEb1x83NrVlKe71584acnJyoS5cu9NVXXwmUgmqRaSAPKysr3L17F4sWLUJGRkat/erq6igvL8e6devg6enZYBXWfv364datWwgLC8P06dORmpqKpUuXwtTUFCwWiynzLgheorCfnx/OnTsn8LidO3fi3bt3yM3NhZ6eHh4/fsyXIMpisbBs2TIsX74cI0eOhLOzM/r164fs7Ox6r/8pJSUl2LhxI7Zv3y7wmL59+zIywqampnjy5AnOnz8vcHotCAUFBWhpaYHNZot03n+dgoIC7N+/v859nyYjt1UiIyMxZswYnDt3jkmOHjduHFPinleCvrVYvnw5Fi9ejMTERMjLy2Pt2rUCMz9EQWQNdg6HA11dXWhqata5X0dHB2/fvhWpTTs7Oxw5cgSVlZWIjIzE+fPn4evr22A+naysLDIyMjB8+PB6s/dPnz6NuLg4rFy5EidOnKiz/PuYMWPQo0cPTJw4EYsXL8agQYNgYWGBFStWwNfXF76+voiKiqq3P4cPH8aqVasavF8Wi4VTp05hx44dOHToEMaNG4c7d+40eF5d7YgRjR9//BGvX7+Gra0tli5diqCgILi7u2PixImMb3TEiBFwcHCApaUlDh48yJwbEBAAe3t72NjYwMPDo1bbf/75JwYNGgQ2m41Tp07ByckJtra2mD17NmMIjx49ClNTU7i5ueHx48ci9z82NhYjRozAyZMnG1Th2LNnDywsLGBtbY3x48fX2s9mszF+/HhYW1tj3LhxfD98c+bMQffu3WFpacnoet29excjR45kjrl9+zZGjRrF1yYR4d69exgzZgwAwNPTE0+ePKk3dUloBA25qI5pIBHR6dOnycPDQ+AQ8MSJEzR27FgiqpZDFjRlTE5OpoKCAoHtNCcdO3YkAHyhEXVRWlpKy5YtI1VVVVq4cCHFxcXRihUraMaMGfTVV18x8WYNhUXUB5fLpT/++IOZ+p4+fZr8/Pz4Ui6E5fXr1xQUFNTovrQGtYb+bm5ER49W/11RUf3+5Mnq9yUl1e/Pnq1+X1BQ/Z4XvpKdXf3+f5LblJnZ4PWTk5PJ0tKSeR8YGEjt27enN2/eMNt4YSWlpaVkaWlJOTk5lJWVRbq6usxxvGN408C9e/eSt7c3lZWVUUxMDA0dOpT5vs2ZM4eOHz9OGRkZpKenR1lZWVReXk69evUSeRqooqJSK/3s02kgz7WgpaXFTMHy8/Nrtbdz506aPn06EVXHLEpISDDTQN79VVZWkpubG0VERBCXy6WuXbsyFcUnTJjAyJ3zyM7OJmNjY+b9gwcPqEuXLhQVFVXr+i06DQSA4cOH4/Xr17h9+3ad+3v27IkLFy5g0qRJGDNmDEJCQmod8/LlSxgZGWH37t1ISUnBvHnzGpzyNQWePlF9idhAtRTI1q1b8fr1azx58gT79+/HsmXLcOPGDVy7dg1A9aqnvLw8fH19G9UXJycnpoTZrVu3MGHCBAwYMECkKs882rVrByLiK4QqRnScnJz4xBv37NkDGxsbODs74927d0hMTMTTp0/Rp08f5riakkQnT57E33//jYsXL0JGRgZ3795FaGgoHB0dYWtri7t37+LNmzd8sjHS0tIYN26cyH3t378/Dh06VGvKWnMayJOWsba2xqRJk3Dq1Kk6y8Q9ePAAkydPZo61trZm9p0/fx729vaws7NDdHQ0U119ypQpOHXqFAoKChAcHIxBgwbxtUmfuDO0tbUhISEhsn5bXYhsrNq3b49t27bxLcvXxNjYGIsWLcLp06ehrq5e5/yZl6G+ZcsWGBoaYv/+/S06pZk0aRKICAoKCkIdr6ysjFu3buHRo0dYuXIlFBQUUFpaivT0dMYf9e2332LNmjUi92XUqFFwcHDAvXv3MGDAAADVoSGNMdY6OjqQl5dHTEzMlxvGEBQETJtW/beUVPX7/z1AaN+++j3voVZSqn7Pm3p07Fj93tu7+r0A10RDyMvL1+hOEO7cuYPg4GBERETAzs4OZWVlIBJclbpbt254+/Yt0tLSAFQ/sD4+PozxiI+PZ2Rgmvo937dvHwDwyWwL4ubNm5g3bx5CQ0Ph4OBQ53ekrv4kJydjx44duHv3LiIjIzFkyBDmh3769Ok4deoUzpw5g7Fjx9Yygh07dmRqTQJAVlYWDAwMoKWlJfK9fkqj6gZaWloKdJixWCxoaGjA09MTycnJdX4YEyZMQL9+/Rg5mL///rtOP1JroqysjNOnT+PYsWNISkpCRUUFtLW18cMPP6CsrAzjxo3Dxo0bkZWVJVK7K1asQEhICNzd3QFUK0r27t0bNjY2ItcAlJKSgo2NDaysrAQWWBXDj4KCQr0/DIWFhVBRUUH79u0RFxeHp0+fAqieMdy/fx/JyckAwDeatbOzg6+vL4YNG4aMjAx4eHjgwoULzHcjLy8PKSkp9crGCEu7du1w5swZxMfH1/tjyeVy8e7dO7i7u2Pbtm0oKCio5dft06cPo5n16tUrZhDx8eNHyMvLQ0lJCR8+fMDff//NnKOtrQ1tbW1s2rQJ03g/MjVgsVhwd3fHhQsXAFRL4AwfPlzk+6yLRhmrN2/ewNDQUOD+bt26ITU1le8XqybS0tLo1q0bCgsLsXz5cnh5eTWmGy1O165dMWPGDADVWvQ8ZGRkcPbsWXC5XJELP9SEp7kVHR2NgoIC6Ojo4MaNGyK1IS0tXatArBjBqKmpwcXFBd26dcPSpUtr7ffy8kJlZSWsra2xevVqODs7A6he6T548CBGjRoFGxubWlM4V1dX7NixA0OGDIGGhgY2bdqEgQMHwtraGgMGDEBmZia0tLSwbt069OzZE/3792dqFtTFsWPHoKury7x4ozag+vt39epVXLt2Db///nud51dVVWHy5MmwsrKCnZ0dFi9eXKuqOa8Ai7W1NbZt28Y47G1sbGBnZwdLS0t8/fXXtdRuJ02aBD09PVhYWNR57a1bt2LXrl3o0qULcnNzmWeoyQhyZpEAB/vHjx9p/PjxtHLlSr7tgYGBNGPGDFq6dCl5eHjQuHHjap3L48WLF6SmpkZaWlr06NEjgceJCpvNprM8Z2wzkZeXR5s3b24R5YStW7cSAKbo69mzZ0lbW7vZr9OWaO04KzFNZ968eXTo0KEmt9PiDvbvvvsOERERtarc7N+/HxkZGVBWVsbw4cNx8uRJgW28e/cOEhISMDc3r1U5pin4+vpi/PjxePfuXbO1qaKigh9//LFFfGrdu3fHjh07MHLkSHz8+BHjx4/H+/fvUVhY2OzXEiOmOXBwcEBkZCTjmP+sCLJiJGBkNW7cODrJW1quwcOHD0lDQ6NOFdC6cHd3p1GjRtGwYcOEOr4hMjIySFZWliQlJYXW02pL9O7dmwDQyJEjycfHp7W702KIR1ZieLTYyIrL5SIuLg4KCgp1OpVdXV0xadIkrF+/XmAb+fn5WLx4MTw9PREVFYXVq1cjKCiIzx/UWBQVFaGnp4fKyspaI6slS5YwJb3aKps3b0ZaWhoWLlyIU6dOfbmre2LEtBSCrBgRwdbWlrF4jx49IgCkrq7OyLAkJSXRrVu3mMCzvLw86tKlC+3cubNOH8+3335LY8aMocuXLzPywEOHDqWNGzcyx3O5XIqIiKADBw7Q0qVLBSYE10VwcDABIBsbG2ZbTk4OU4L+S8Dd3Z1+++231u5GiyEeWYnh0awjq9evXzNh8iUlJbC1tUVqaiojw+Lq6opFixbBxMQE27dvBxHh1q1b8PPzg4uLC7PMyyMjIwNEBBcXFyZU4ffff8eZM2dgb2+P/v37Q1NTE6NGjcLTp0/x6tWrWgUn68PZ2Rlubm6IiIjA06dPUVJSAhsbGwDA2LFjhW6nNTEwMKhXWkeMmP8q9QbnyMrKwtbWFt27d8fdu3exevVqyMrKMvtdXV1x9+5dcDgcLFu2DOfOnUNISAhevHiB3377DS4uLrh8+TJ69OgBoDp3qmvXrjh48CB++uknAIC+vj7Cw8Px4sULFBUVwdzcnDGGkZGRmDBhQp19q6iowIcPH/iKjZaWliI7OxsDBw7En3/+CX19fTg5OYHNZsPNzY3v/JSUFLRv316kEu4tAREhJyeH6UdVVRVKS0tbtU9ixLRJBA256H8O9idPntDhw4cpJyen1pAtLy+PfH196dq1a/Tzzz/XErq/du0aqaioUJ8+fWjMmDFkZGRE3t7e9PHjR6GGienp6aSqqlpnLt6ZM2cIAF+BhylTptD48ePpm2++YUop3blzh3x9fcnW1pZPqoInmSxstZqWIikpiSlI8f79ezp48CCNHj2a2c/lcpnXv4HWngaKJWIE01wSMXv37iVjY2MCwCfF9CnN7mDv2bMnvv766zpze1RUVPDNN9/A29sbK1euhKurK99+b29vpKSkYPXq1Rg9ejQuXbqEq1evCp32oq2tjZEjR8Kbl05Rg7t37wIAQkNDmW0VFRUYOnQoYmNj0atXL6ipqSEoKAizZs1Cu3bt8PDhQ+ZYXjRvS+YkCoORkRGsrKxw+vRpaGlpISAggK9ga1VVFe7fv88XFCim8YglYloeFxcX3LlzBwYGBs3abqMi2EVBQUEB/fv3x/jx42FraytyvNLBgwcRERGBb7/9Fj/99BN+++03vHr1CpcuXcKgQYNw7949ANUrjffv34e1tTV69+6N6dOn48qVK3j9+jVYLBaWLFkCHx8f5OXloaSkhKk0LUjq5nPRrl07BAUFYc6cOSAiXLp0Cbt27ap1HImodyWmbsQSMf9PS0jEANXpR/VluDQaQUMuEhBn1RqEhYXRb7/9Rhs3bqSZM2eSvLw8ffvttxQZGUlqamq0bt06GjhwIE2bNo2IiIqLiykgIIAyP5EM8fT0pOHDh5OxsTF16NCB+vbty7c/MzOzVadbycnJJCsrS8rKyhQcHExE1RIdgYGBFBUV9a+YCn469P/MCjFiiZgatIREzKf9/azTwLaAnZ0dFixYgFWrVuHPP/9EUVER/vjjD1hZWSEgIIApKsHLbJeXl4enp2etUdPvv/+Ofv364fDhw/D09OSLwo2Li4OWlhaOHj3Kd05RUdFnc3gbGhpi5cqVKCgowMePHwEAEhISMDIyQk5ODuLi4sQjrBZALBHTfBIxLckXYaw+peZUsnv37ti7dy927NjR4BzZ2NgYCxYsgJubGzIzMyElJQWgenTJUyWdMWMGMzy/d+8eFBUVaxmwT8nLy8Pw4cPx8uXLptwWADDJrRISEsw2AwMDGBoa4sOHD/86g9UGFGLEEjGf0BSJmJbkizRWzcHu3buxbNky/PTTT5CXl8eECRMwc+ZMANUxWT/99BM8PDwgISGBb7/9tt62oqKicO3aNdjb22Pp0qWMP0xUiAgXL16EpKQkY0h5GBoaMgZLVG14Mf+PWCLm/2kJiZiW5D8rguTo6IiHDx/C19cX33zzDZSUlHDp0iX88MMP0NXVRWBgIAwMDDBixAhcv34dysrKMDY2hq6ubq1fIzc3NwQGBsLT0xM7duyAn58fc6yfn1+DhTOA6tXJAwcO4MWLF8jKyoKKikqtYwwNDaGkpFRL6kOM8NSUiBk0aBCGDBnCt9/LywsHDhyAtbU1unbtWqdEDE8aqKZabk2JmNu3bzMSMVwuF1JSUvj999/h7OzMSMRoaWnB3t5e4ArksWPHcOXKFeY9z2gC/y8R4+bmhk6dOtUpxcSTiCksLAQRCZSImT59OqytrWFra1unREznzp3rlIjJzs4WKBGzZ88ebNu2De/fv4e1tTUGDx6MQ4cO1XmsKLDqm1J0796d6pIlbm04HA4A4PHjx4iMjISNjQ369OnT7MoIISEhOHDgALKzs5Gfn4+EhARISUnBy8sLgwcPxqBBg/iCZHNycjBt2jTcvHkThw4dwtGjR2FjY4MhQ4Zg0KBBAvtXUVHBCBEmJSXB2Ni4We+jLREbG8tUJRLzZfLdd9/Bzs6uyTpVdX0XWCxWKBF1r/MEQZ53akOrgTV58+YN6erqUvv27UlDQ4O+/fZbMjU1pYkTJzKrFC0Fl8uluLg42r17N/Xr149UVFRoxowZdPnyZYqPj2eCN3/99VdSV1enW7du0cyZM0lVVZXu379fb9svX74kXV3dZgnKa8u0dlComKZhb29PvXv3FlgLUBRatMhpa1NeXk52dna0e/duys/PZ5ZjS0pKaMGCBaSurv5ZH4a0tDTatm0bDRo0iHR1dcnU1JRWrFhB58+fpylTptDQoUOJiOjgwYPUoUMHmj17NiUmJgpsz8vLi06fPv25ut8qiI2VGB6iGqsvahq4ZMkSJCcn49KlS3VOqVauXAk2m41ff/31s/eNiBAaGoorV64gNjYW8fHxGD9+PFNHMCcnB1u3bsWpU6egqqqKkSNHwsbGBnJycmCxWPjrr79w586dWgVY/22Ip4FfDkVFRcjLy4Ouri7f6jRQXSmKw+Ggffv2tfYJi6jTwDZnrAoKCrB06VL069evVhKziYkJrl+/DjMzszrPTUpKQv/+/dGlSxecPHmyyRU1goODsWPHDoSEhKCgoABaWlqwtbXF1KlTMXjw4Ea1yeVy8eLFC5w7dw4pKSnMsri5uTl+/PHHVk+sbmliY2NhZmYmLtDaxikrK0NcXByqqqpgaGjIl26XlZWFjIwMyMjIoLy8HGpqanUuPNUHESEuLu7LNla///47Tp06haioKOTn5zNL+GFhYRgwYADS0tIgJycn8PzKykr88ssvOHz4MO7fv9/osP8LFy7gu+++w8aNG+Hu7g41NTVkZGQgODgYW7duhZSUFIyMjKCnpwcigo2NDb755htxlZkGSE5OhoKCAtTU1MQGqw3z5s0b5OXlQVZWFubm5nyjp7S0NJSUlKBz586oqqrC69ev0alTJ6FnBESE3NxcFBUV8QXjAvUbqzb3ZJWUlEBTUxORkZF8H9Dp06exYMGCeg0VUF2Db82aNVBRUcGAAQMwb948qKurY+LEiSI9HDdu3MC8efMwa9YsZpuKigosLS0xdepUxMbGIiUlBWlpaWCxWLh48SLOnDmD27dvo7y8XGDFmejoaCQlJUFZWRk9evTgW038L8Cr1CKOFWvbFBcXo6KiAnJyckhISODbR0QoKChASkoKdHV1UVFRgcjISJFmMrKystDV1RWtU4KcWdRKDvYPHz6QvLx8rby9jRs3Ur9+/ZicJWH4+eefqVu3bmRnZ0deXl5UWFgo9Lm+vr40efJkoY+PiYkhAKSgoEASEhJ08OBBvv25ubk0ceJE0tXVJW9vb3J0dCRzc/NmWVURI+Zz8+7dO1JRUSE2m03v378nFRWVZmkXX0JuIJvNRmZmJtTV1VFYWMioKQDVCqOrV6/GvXv3sGDBAqHbXLlyJaKiovDs2TNoa2tj0qRJtaJ46yMkJATCTIMrKiqYALlHjx7h8OHDePDgAYBqH9WxY8dgaWkJNTU1xMfH49q1a3j+/DmysrLg7u6OLl26YPbs2UhPTxe6b2LENCdVVVUiKdS+e/cOCgoKkJWVRXR0NCwtLVuwd9W0CWOVkZGBLl26wNLSEi4uLigrK2OmbGw2G9999x28vb1x9+5dTJkyReT2paSksHfvXsjJyWHYsGFC5dbNmjUL3377LcaOHcukIQiCiPDzzz+DzWbD2toaycnJyMzMxObNm2FhYYEDBw7g2rVr2LNnD5ODWFZWhtzcXAQHB+P8+fNQVVWFtbU19u3b96/K/RPzZTBhwgTIyso2mCrGyy/k5bDu3r0bBw4cYHS1WhRBQy76TNPApKQksrS0pAULFhCXy6Vx48bxFVA9efIk9e3bV6QpnCA4HA5ZWlrWK2uRn59PR44cIS8vL5KRkSEAVP0xCY+/vz/16tWLFixYQEFBQXVKu2zbto0A0Pfff89sS0hIIHt7e5o0aZJI1xMjpimkpKSQiooKKSoqUlBQkMDjAgMDCQCtXbuWLl++TI6OjmRmZkaLFi2iDx8+NEtf0Ng4KxaLFQDg3xv0I0aMmLZGDhF51bWjXmMlRowYMW2FNuGzEiNGjJiGEBsrMWLEfBGIjZUYMWK+CMTGSowYMV8EYmMlRoyYL4L/A28PQIEcDxCKAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "import cartopy.crs as ccrs\n", + "\n", + "fig = plt.figure(figsize=[10, 5])\n", + "\n", + "ax = plt.subplot(1, 1, 1, projection=ccrs.Orthographic(0, 90))\n", + "\n", + "ax.coastlines(zorder=3)\n", + "\n", + "it = 0\n", + "\n", + "lkfs0 = np.load(lkf_data.lkfpath.joinpath('lkf_%s_%03i.npy' %(lkf_data.netcdf_file.split('/')[-1].split('.')[0],(it+1))),allow_pickle=True)\n", + "lkfs1 = np.load(lkf_data.lkfpath.joinpath('lkf_%s_%03i.npy' %(lkf_data.netcdf_file.split('/')[-1].split('.')[0],(it+2))),allow_pickle=True)\n", + "\n", + "tracks = np.load(lkf_data.track_output_path.joinpath('lkf_tracked_pairs_%s_to_%s.npy' %(lkf_data.lkf_filelist[it][4:-4],\n", + " lkf_data.lkf_filelist[it+1][4:-4])),allow_pickle=True)\n", + "\n", + "for ilkf in lkfs0:\n", + " if np.min(ilkf[:,2])<-150 and np.max(ilkf[:,2]>150):\n", + " ilkf[ilkf[:,2]<0,2]+=360\n", + " ax.plot(ilkf[:,2],ilkf[:,3],'0.5',transform=ccrs.PlateCarree())\n", + " \n", + "for ilkf in lkfs1:\n", + " if np.min(ilkf[:,2])<-150 and np.max(ilkf[:,2]>150):\n", + " ilkf[ilkf[:,2]<0,2]+=360\n", + " ax.plot(ilkf[:,2],ilkf[:,3],'0.75',transform=ccrs.PlateCarree())\n", + "\n", + "for itrack in tracks:\n", + " ax.plot(lkfs0[itrack[0]][:,2],lkfs0[itrack[0]][:,3],'r:',alpha=0.75,transform=ccrs.PlateCarree())\n", + " ax.plot(lkfs1[itrack[1]][:,2],lkfs1[itrack[1]][:,3],'b:',alpha=0.75,transform=ccrs.PlateCarree())\n", + " \n", + "ax.plot([0,0],[0,0],'0.5',label='LKFs day 0')\n", + "ax.plot([0,0],[0,0],'0.75',label='LKFs day 1')\n", + "ax.plot([0,0],[0,0],'r:',label='tracked LKFs day 0')\n", + "ax.plot([0,0],[0,0],'b:',label='tracked LKFs day 1')\n", + "\n", + "ax.legend()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "257484b7-e86c-4237-8e3d-d531d2f740b6", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.10.2" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 3223ff98b5b40b8868e69108b2daa8bdce82c9f6 Mon Sep 17 00:00:00 2001 From: Nils Hutter Date: Fri, 4 Nov 2022 15:12:36 -0700 Subject: [PATCH 14/21] Bug fix for skeleton_along_max option --- lkf_tools/detection.py | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/lkf_tools/detection.py b/lkf_tools/detection.py index bfe13b7..992fbdc 100644 --- a/lkf_tools/detection.py +++ b/lkf_tools/detection.py @@ -1064,7 +1064,8 @@ def lkf_detect_eps(eps_tot,max_kernel=5,min_kernel=1,dog_thres=0,dis_thres=4,ell lkf_thin = skimage.morphology.skeletonize(lkf_detect).astype('float') else: lkf_thin = skeleton_along_max(eps_tot,lkf_detect,kernel_size=skeleton_kernel).astype('float') - + lkf_thin[:2,:] = 0.; lkf_thin[-2:,:] = 0. + lkf_thin[:,:2] = 0.; lkf_thin[:,-2:] = 0. # Segment detection seg_f = detect_segments(lkf_thin) # Returns matrix fill up with NaNs @@ -1152,6 +1153,8 @@ def lkf_detect_eps_multday(eps_tot,max_kernel=5,min_kernel=1, lkf_thin = skimage.morphology.skeletonize(lkf_detect).astype('float') else: lkf_thin = skeleton_along_max(eps_tot,lkf_detect,kernelsize=skeleton_kernel).astype('float') + lkf_thin[:2,:] = 0.; lkf_thin[-2:,:] = 0. + lkf_thin[:,:2] = 0.; lkf_thin[:,-2:] = 0. # Segment detection seg_f = detect_segments(lkf_thin,max_ind=max_ind) # Returns matrix fill up with NaNs From 287a303126818355ced01c259bb84c38959e09f0 Mon Sep 17 00:00:00 2001 From: Nils Hutter Date: Tue, 29 Nov 2022 10:43:30 -0800 Subject: [PATCH 15/21] Bug fix in the computing the drift estimate of advected LKFs --- lkf_tools/tracking.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lkf_tools/tracking.py b/lkf_tools/tracking.py index 1a3bf40..d0a49ce 100644 --- a/lkf_tools/tracking.py +++ b/lkf_tools/tracking.py @@ -319,7 +319,7 @@ def drift_estimate(lkf0_path,ncfile,mask,index_x,index_y,red_fac, (iseg_d[:,0] Date: Wed, 15 Feb 2023 08:56:31 -0800 Subject: [PATCH 16/21] Adding original code of all statistical tools -> need to be ported into package code --- lkf_tools/lkf_stats_tools.py | 3307 ++++++++++++++++++++++++++++++++ notebooks/lkf_statistics.ipynb | 68 + 2 files changed, 3375 insertions(+) create mode 100644 lkf_tools/lkf_stats_tools.py create mode 100644 notebooks/lkf_statistics.ipynb diff --git a/lkf_tools/lkf_stats_tools.py b/lkf_tools/lkf_stats_tools.py new file mode 100644 index 0000000..45c02c6 --- /dev/null +++ b/lkf_tools/lkf_stats_tools.py @@ -0,0 +1,3307 @@ +import numpy as np +import matplotlib.pylab as plt +import os +import sys +import datetime as dt +from mpl_toolkits.basemap import Basemap +import scipy +import matplotlib as mpl +from netCDF4 import Dataset, MFDataset +import pickle +from scipy.spatial import cKDTree + +# Self-written functions +from read_RGPS import * +from model_utils import * +from lkf_utils import * +from griddata_fast import griddata_fast +from local_paths import * + +# Suppress rank warnings for fit to polynom +import warnings +warnings.simplefilter('ignore', np.RankWarning) + + +# Define function for fit to polynom + +def lkf_poly_fit(x,y,deg,return_p=False): + if x.size-10) + index_y = np.where(np.sum(mask[1:-1,1:-1],axis=1)>0) + red_fac = 3 # Take only every red_fac point to reduce array size + lon_cov = lon_cov[index_y[0][0]-1:index_y[0][-1]+2:red_fac, + index_x[0][0]-1:index_x[0][-1]+2:red_fac] + lat_cov = lat_cov[index_y[0][0]-1:index_y[0][-1]+2:red_fac, + index_x[0][0]-1:index_x[0][-1]+2:red_fac] + x_cov,y_cov = m(lon_cov,lat_cov) + + if self.datatype == 'sirex': + # if self.lkf_path.split('/')[-2].split('_')[-1] == 'means': + # ind_yp = -2 + # elif self.lkf_path.split('/')[-2].split('_')[-1] == 'inst': + # ind_yp = -1 + # ncfile = ('/work/ollie/nhutter/sirex/data/' + + # '/'.join(lkf_path[47:-1].split('/')[:-1])+'/'+ + # '_'.join(lkf_path[47:-1].split('/')[-1].split('_')[:ind_yp]) + '_' + + # years[-1] + '_' + + # '_'.join(lkf_path[47:-1].split('/')[-1].split('_')[ind_yp:]) + '.nc') + lkf_ps=lkf_path.split('/') + sp = '/'.join(lkf_ps[:np.where(np.array(lkf_ps)=='analysis')[0][0]]) + ind_m = np.where(np.array(lkf_ps)=='lead_detect')[0][0]+1 + ind_f = np.where(['means' in iseg or 'inst' in iseg for iseg in lkf_ps])[0][0] + ind_yp = np.array([-2,-1])[[np.any(['means' in iseg for iseg in lkf_ps]),np.any(['inst' in iseg for iseg in lkf_ps])]][0] + flnml = lkf_ps[ind_f].split('_'); flnml.insert(ind_yp,years[-1]) + ncfile = os.path.join(sp,'data','/'.join(lkf_ps[ind_m:ind_f]),'_'.join(flnml)+'.nc') + + + ncdata = Dataset(ncfile) + lon = ncdata.variables['ULON'][:,:] + lat = ncdata.variables['ULAT'][:,:] + + mask = ((((lon > -120) & (lon < 100)) & (lat >= 80)) | + ((lon <= -120) & (lat >= 70)) | + ((lon >= 100) & (lat >= 70))) + index_x = np.where(np.sum(mask[1:-1,1:-1],axis=0)>0) + index_y = np.where(np.sum(mask[1:-1,1:-1],axis=1)>0) + red_fac = 1 # Take only every red_fac point to reduce array size + x_cov,y_cov = m(lon[max([index_y[0][0]-1,0]):index_y[0][-1]+2:red_fac, + max([index_x[0][0]-1,0]):index_x[0][-1]+2:red_fac], + lat[max([index_y[0][0]-1,0]):index_y[0][-1]+2:red_fac, + max([index_x[0][0]-1,0]):index_x[0][-1]+2:red_fac]) + + if self.datatype == 'rgps': + cov = np.load('/work/ollie/nhutter/sirex/analysis/lead_detect/RGPS/coverage_rgps_1997_mod.npz') + x_cov, y_cov = m(cov['lon'],cov['lat']) + + + # RGPS coverage + if self.datatype=='mitgcm_2km': + cov = np.load('/work/ollie/nhutter/lkf_data/rgps_opt/coverage_rgps.npz') + else: + cov = np.load('/work/ollie/nhutter/sirex/analysis/lead_detect/RGPS/coverage_rgps_1997_mod.npz') + print('Loading this coverage file for masking: /work/ollie/nhutter/sirex/analysis/lead_detect/RGPS/coverage_rgps_1997_mod.npz') + + x_rgps,y_rgps = m(cov['lon'],cov['lat']) + + # Generate KDTree for interpolation + tree = cKDTree(np.rollaxis(np.stack([x_rgps.flatten(),y_rgps.flatten()]),0,2)) + distances, inds = tree.query(np.rollaxis(np.stack([x_cov.flatten(),y_cov.flatten()]),0,2), k = 1) + mask_cov = (distances>=12.5e3).reshape(x_cov.shape) + + + for year_dic in years: + print("Start reading with year: " + year_dic) + new_dir = lkf_path + year_dic + '/' + # Generate list of files + lkffile_list = [ifile for ifile in os.listdir(new_dir) if ifile.startswith('lkf')] + lkffile_list.sort() + + # Initialize list for year + lkf_data_year = [] + lkf_meta_year = [] + + # Read yearly RGPS coverage + if self.mask_rgps: + if self.datatype=='mitgcm_2km': + cov_year = np.load('/work/ollie/nhutter/lkf_data/rgps_opt/coverage_rgps_%s.npz' %year_dic)['coverage'] + else: + cov_year = np.load('/work/ollie/nhutter/sirex/analysis/lead_detect/RGPS/coverage_rgps_%s_mod.npz' %year_dic)['coverage'] + + + if len(lkffile_list)>cov_year.shape[0]: + lkffile_list = lkffile_list[:cov_year.shape[0]] + + # Loop over files to read an process + for it,lkffile in enumerate(lkffile_list): + + # Save meta information: start/end time, number features + if datatype == 'rgps': + startdate = (dt.date(int(lkffile[4:-15]),1,1)+ + dt.timedelta(int(lkffile[-15:-12]))) + enddate = (dt.date(int(lkffile[-11:-7]),1,1)+ + dt.timedelta(int(lkffile[-7:-4]))) + elif datatype == 'mitgcm_2km': + startdate = (dt.datetime(1992,1,1,0,0,0) + + dt.timedelta(0,int(lkffile[-14:-4])*120.)) + enddate = (dt.datetime(1992,1,1,0,0,0) + + dt.timedelta(0,int(lkffile[-14:-4])*120. + + 24*3600.)) + elif datatype == 'sirex': + if lkffile.split('_')[-2] == 'means': + ind_year = -4 + elif lkffile.split('_')[-2] == 'inst': + ind_year = -3 + startdate = (dt.date(int(lkffile.split('_')[ind_year]),1,1)+ + dt.timedelta(int(lkffile.split('_')[-1][:-4]))) + enddate = (dt.date(int(lkffile.split('_')[ind_year]),1,1)+ + dt.timedelta(int(lkffile.split('_')[-1][:-4])+3)) + + + if lkffile.endswith('.npy'): + lkfi = np.load(new_dir+lkffile, allow_pickle=True,encoding='bytes') + lkf_meta_year.append(np.array([startdate, + enddate, + lkfi.size])) + elif lkffile.endswith('.npz'): + lkfiz = np.load(new_dir+lkffile, allow_pickle=True,encoding='bytes') + lkfi = lkfiz['lkf'] + + if datatype == 'mosaic': + print(str(lkfiz['fname']).split('/')[-1].split('_')) + startdate = dt.datetime.strptime(str(lkfiz['fname']).split('/')[-1].split('_')[1][:-2],'%Y%m%dT%H%M%S') + enddate = dt.datetime.strptime(str(lkfiz['fname']).split('/')[-1].split('_')[2][:-2],'%Y%m%dT%H%M%S') + + lkf_meta_year.append(np.array([startdate, + enddate, + lkfi.size,lkfiz['fname'],lkfiz['shape']])) + + # Add projected coordinates + lkfim = [] + + if self.mask_rgps: + if self.datatype=='rgps': + cov_int = cov_year[it,100:-100,100:-100] + #if it==0: + # fig,ax = plt.subplots(1,1) + # ax.pcolormesh(cov_int) + # for iseg in lkfi: + # ax.plot(iseg[:,1].astype('int'),iseg[:,0].astype('int')) + else: + # Coverage mask of all LKFs in one day + cov_int = cov_year[it,:,:][np.unravel_index(inds,x_rgps.shape)].reshape(x_cov.shape) + cov_int[mask_cov] = np.nan + + for iseg in lkfi: + if self.mask_rgps: + mask_seg = cov_int[iseg[:,0].astype('int'), + iseg[:,1].astype('int')] + ind_mask = np.where(mask_seg)[0] + if np.any(np.diff(ind_mask)!=1): + ind_c = np.concatenate([np.array([-1]), + np.where(np.diff(ind_mask)!=1)[0], + np.array([ind_mask.size-1])]) + for ic in range(ind_c.size-1): + if ind_c[ic]+1!=ind_c[ic+1]: + iseg_c = iseg[ind_mask[ind_c[ic]+1]:ind_mask[ind_c[ic+1]]+1,:] + isegm = np.rollaxis(np.stack(m(iseg_c[:,2], + iseg_c[:,3])),1,0) + lkfim.append(np.concatenate([iseg_c, isegm], axis=1)) + if polyfit: + isegf = np.rollaxis(np.stack(lkf_poly_fit(lkfim[-1][:,self.indm0], + lkfim[-1][:,self.indm1], + poly_deg)),1,0) + lkfim[-1] = np.concatenate([lkfim[-1], isegf], axis=1) + + else: + iseg = iseg[mask_seg,:] + if iseg.shape[0]>1: + isegm = np.rollaxis(np.stack(m(iseg[:,2], + iseg[:,3])),1,0) + #print iseg, isegm + lkfim.append(np.concatenate([iseg, isegm], axis=1)) + if polyfit: + isegf = np.rollaxis(np.stack(lkf_poly_fit(lkfim[-1][:,self.indm0], + lkfim[-1][:,self.indm1], + poly_deg)),1,0) + lkfim[-1] = np.concatenate([lkfim[-1], isegf], axis=1) + else: + isegm = np.rollaxis(np.stack(m(iseg[:,2], + iseg[:,3])),1,0) + lkfim.append(np.concatenate([iseg, isegm], axis=1)) + + if polyfit: + isegf = np.rollaxis(np.stack(lkf_poly_fit(lkfim[-1][:,self.indm0], + lkfim[-1][:,self.indm1], + poly_deg)),1,0) + lkfim[-1] = np.concatenate([lkfim[-1], isegf], axis=1) + + lkf_data_year.append(lkfim) + + if read_tracking: + print( "Start reading tracking data of year: " + year_dic) + track_dir = os.path.join(lkf_path,year_dic,track_dir_name) + # Generate list of files + trackfile_list = os.listdir(track_dir) + trackfile_list.sort() + + track_year = [] + + for itrack, trackfile_i in enumerate(trackfile_list[:len(lkf_data_year)-1]): + tracked_pairs = np.load(os.path.join(track_dir, trackfile_i)) + + #track_day = np.empty((lkf_meta_year[-1][itrack][2],2),dtype=object) + track_year.append(tracked_pairs) + + + # Append to global data set + lkf_dataset.append(lkf_data_year) + lkf_meta.append(np.stack(lkf_meta_year)) + if read_tracking: lkf_track_data.append(track_year) + + # Store read and processed data + self.lkf_dataset = lkf_dataset + self.lkf_meta = lkf_meta + self.lkf_track_data = lkf_track_data + + + # Set all statistical fields to None + self.length = None + self.density = None + self.curvature = None + self.deformation = None + self.intersection = None + self.orientation = None + self.lifetime = None + self.growthrate = None + + + + def gen_length(self,overwrite=False,write_pickle=True): + if self.length is None or overwrite: + self.length = lkf_lengths(self) + if write_pickle: + with open(self.pickle, 'wb') as output_pkl: + pickle.dump(self, output_pkl, pickle.HIGHEST_PROTOCOL) + else: + print('Warning: length object exists already, to overwrite active overwrite=True option') + + def gen_density(self,overwrite=False,write_pickle=True,**kwargs): + if self.density is None or overwrite: + self.density = lkf_density(self,lkf_path=self.lkf_path,years=self.years,**kwargs) + if write_pickle: + with open(self.pickle, 'wb') as output_pkl: + pickle.dump(self, output_pkl, pickle.HIGHEST_PROTOCOL) + else: + print('Warning: density object exists already, to overwrite active overwrite=True option') + + def gen_density_len_class(self,len_class=[0e3,100e3,np.inf],write_pickle=True,**kwargs): + if self.density is None: + self.density = lkf_density(self,lkf_path=self.lkf_path,years=self.years,**kwargs) + if self.length is None: + self.length = lkf_lengths(self) + self.density.density_len_class(self,len_class=len_class) + if write_pickle: + with open(self.pickle, 'wb') as output_pkl: + pickle.dump(self, output_pkl, pickle.HIGHEST_PROTOCOL) + + + def gen_curvature(self,overwrite=False,write_pickle=True): + if self.curvature is None or overwrite: + self.gen_length(write_pickle=False) + self.curvature = lkf_curvature(self) + if write_pickle: + with open(self.pickle, 'wb') as output_pkl: + pickle.dump(self, output_pkl, pickle.HIGHEST_PROTOCOL) + else: + print('Warning: curvature object exists already, to overwrite active overwrite=True option') + + def gen_deformation(self,overwrite=False,write_pickle=True): + if self.deformation is None or overwrite: + self.deformation = lkf_deformation(self) + if write_pickle: + with open(self.pickle, 'wb') as output_pkl: + pickle.dump(self, output_pkl, pickle.HIGHEST_PROTOCOL) + else: + print('Warning: deformation object exists already, to overwrite active overwrite=True option') + + def gen_intersection(self,overwrite=False,write_pickle=True, + link_def_life_len=True,link_def_len=False,**kwargs): + if self.intersection is None or overwrite: + if link_def_life_len: + self.gen_deformation(write_pickle=False) + self.gen_length(write_pickle=False) + self.gen_lifetime(write_pickle=False) + if link_def_len: + self.gen_deformation(write_pickle=False) + self.gen_length(write_pickle=False) + self.intersection = lkf_intersection(self,link_def_life_len=link_def_life_len, + link_def_len=link_def_len, + lkf_path=self.lkf_path,years=self.years,**kwargs) + if write_pickle: + with open(self.pickle, 'wb') as output_pkl: + pickle.dump(self, output_pkl, pickle.HIGHEST_PROTOCOL) + else: + print('Warning: intersection object exists already, to overwrite active overwrite=True option') + + def gen_orientation(self,overwrite=False,write_pickle=True,**kwargs): + if self.orientation is None or overwrite: + self.orientation = lkf_orientation(self,**kwargs) + if write_pickle: + with open(self.pickle, 'wb') as output_pkl: + pickle.dump(self, output_pkl, pickle.HIGHEST_PROTOCOL) + else: + print('Warning: orientation object exists already, to overwrite active overwrite=True option') + + def gen_lifetime(self,overwrite=False,write_pickle=True): + if self.lifetime is None or overwrite: + self.lifetime = lkf_lifetime(self) + if write_pickle: + with open(self.pickle, 'wb') as output_pkl: + pickle.dump(self, output_pkl, pickle.HIGHEST_PROTOCOL) + else: + print('Warning: lifetime object exists already, to overwrite active overwrite=True option') + + def gen_growthrate(self,overwrite=False,write_pickle=True): + if self.growthrate is None or overwrite: + self.gen_length(write_pickle=False) + self.gen_lifetime(write_pickle=False) + self.growthrate = lkf_growthrate(self) + if write_pickle: + with open(self.pickle, 'wb') as output_pkl: + pickle.dump(self, output_pkl, pickle.HIGHEST_PROTOCOL) + else: + print('Warning: growth rate object exists already, to overwrite active overwrite=True option') + + + + def write2tex(self,output_path,output_name): + for iyear in range(len(self.years)): + print('Write output file: %s%s_%s.txt' %(output_path,output_name,self.years[iyear])) + output_file = open('%s%s_%s.txt' %(output_path,output_name,self.years[iyear]),'w') + + # Write header + output_file.write('Start_Year\tStart_Month\tStart_Day\tEnd_Year\tEnd_Month\tEnd_Day\tDate(RGPS_format)\tLKF_No.\tParent_LKF_No.\tind_x\tind_y\tlon\tlat\tdivergence_rate\tshear_rate\n') + + # Loop over days + id_year = [] + id_c = 1 + for iday in range(len(self.lkf_dataset[iyear])): + id_day = [] + # Loop over LKFs + for ilkf in range(len(self.lkf_dataset[iyear][iday])): + # Determine LKF ID + id_lkf = int(np.copy(id_c)); + id_c+=1 + if iday!=0: + if self.lkf_track_data[iyear][iday-1].size>0: + if np.any(self.lkf_track_data[iyear][iday-1][:,1]==ilkf): + id_parent = ','.join([str(id_year[-1][int(it)]) for it in self.lkf_track_data[iyear][iday-1][:,0][self.lkf_track_data[iyear][iday-1][:,1]==ilkf]]) + else: + id_parent = '0' + else: + id_parent = '0' + else: + id_parent = '0' + + # Loop over all points of LKF and write data to file + for ip in range(self.lkf_dataset[iyear][iday][ilkf].shape[0]): + output_file.write('\t'.join([self.lkf_meta[iyear][iday][0].strftime('%Y'), + self.lkf_meta[iyear][iday][0].strftime('%m'), + self.lkf_meta[iyear][iday][0].strftime('%d'), + self.lkf_meta[iyear][iday][1].strftime('%Y'), + self.lkf_meta[iyear][iday][1].strftime('%m'), + self.lkf_meta[iyear][iday][1].strftime('%d'), + '_'.join([self.lkf_meta[iyear][iday][idate].strftime('%Y%j') for idate in [0,1]]), + '%i' %id_lkf, + id_parent, + '%i' %self.lkf_dataset[iyear][iday][ilkf][ip,0], + '%i' %self.lkf_dataset[iyear][iday][ilkf][ip,1], + '%.020e' %self.lkf_dataset[iyear][iday][ilkf][ip,2], + '%.020e' %self.lkf_dataset[iyear][iday][ilkf][ip,3], + '%.020e' %self.lkf_dataset[iyear][iday][ilkf][ip,4], + '%.020e\n' %self.lkf_dataset[iyear][iday][ilkf][ip,5]])) + + id_day.append(id_c) + + id_year.append(id_day) + + output_file.close() + + + + +# ------------ Statistic functions ---------------------------- + +# 1. Length + +def ks(cdf_sample,cdf_model): + """Computes Komologorov-Smirnov (KS) statistic: + D = max( abs( S(x) - N(x) ) / sqrt( N(x) - (1 - N(x)) ) ) + S(x): CDF of sample, N(x): CDF of model""" + return np.max((np.abs(cdf_sample-cdf_model)/np.sqrt(cdf_model*(1-cdf_model)))[1:]) + +class lkf_lengths: + #def compute_lengths(self): + def __init__(self,lkf): + self.output_path = lkf.output_path + + print("Compute length of segments") + lkf_length = [] + + for lkf_year in lkf.lkf_dataset: + len_year = [] + for lkf_day in lkf_year: + len_day = [] + for ilkf in lkf_day: + len_day.append(np.sum(np.sqrt(np.diff(ilkf[:,lkf.indm0])**2 + + np.diff(ilkf[:,lkf.indm1])**2))) + + len_year.append(np.array(len_day)[np.isfinite(len_day)]) + + lkf_length.append(len_year) + + self.lkf_length = np.array(lkf_length) + + + def plot_length_hist(self, years=None, bins=np.linspace(50,1000,80),pow_law_lim=[50,600], + output_plot_data=False,gen_fig=True,save_fig=False, + fig_name=None): + #if self.lkf_length is None: + # self.compute_lengths() + if years is None: + years=range(len(self.lkf_length)) + + if gen_fig: + style_label = 'seaborn-darkgrid' + with plt.style.context(style_label): + fig,ax = plt.subplots(nrows=1,ncols=1, figsize=(6,5)) + ax.set_xlabel('LKF length in km') + ax.set_ylabel('PDF') + ax.set_yscale('log') + ax.set_xscale('log') + ax.set_xlim([bins.min(),bins.max()]) + colors=plt.rcParams['axes.prop_cycle'].by_key()['color'] + + for iyear in years: + pdf_length, bins_length = np.histogram(np.concatenate(self.lkf_length[iyear])/1e3, + bins=bins, density=True) + bins_mean = 0.5*(bins_length[1:]+bins_length[:-1]) + if gen_fig: + if iyear==0: + ax.plot(bins_mean, pdf_length,color='0.5',alpha=0.5,label="single years") + else: + ax.plot(bins_mean, pdf_length,color='0.5',alpha=0.5) + + pdf_length, bins_length = np.histogram(np.concatenate([np.concatenate(self.lkf_length[iyear]) for iyear in years])/1e3, + bins=bins, density=True) + bins_mean = 0.5*(bins_length[1:]+bins_length[:-1]) + if gen_fig: + ax.plot(bins_mean, pdf_length,color=colors[1],alpha=1.0,label="all years") + + coeff,pl_fit = power_law_fit(bins_mean[(bins_mean>=pow_law_lim[0]) & (bins_mean<=pow_law_lim[1])], + pdf_length[(bins_mean>=pow_law_lim[0]) & (bins_mean<=pow_law_lim[1])]) + + if gen_fig: + ax.plot(bins_mean[bins_mean<=600], pl_fit,color=colors[1],alpha=1.0,linestyle='--',label="power-law fit\nexponent %.2f" %(-coeff[0])) + ax.plot(bins_mean[bins_mean>600], + np.power(10,np.polyval(coeff,np.log10(bins_mean[bins_mean>600]))), + color=colors[1],alpha=1.0,linestyle=':') + + ax.legend() + + if save_fig: + if fig_name is None: + fig.savefig(self.output_path + 'length_pdf.pdf') + else: + fig.savefig(self.output_path + fig_name) + + if output_plot_data: + return pdf_length, bins_mean, coeff, pl_fit + + def fit_stretched_exponential(self,bins=np.linspace(50,1000,80),xmin=100,xmax=1000,mctest=True,mctest_plots=False,mciter=1000): + import powerlaw + + # Compute PDF and power-law fit + (pdf_length, bins_mean, + coeff, pl_fit) = self.plot_length_hist(bins=bins, + output_plot_data=True, + gen_fig=False) + + # Fit to stretched exponential + len_all = np.concatenate([np.concatenate(self.lkf_length[iyear]) for iyear in range(len(self.lkf_length))])/1e3 + + fit = powerlaw.Fit(len_all,xmin=xmin,xmax=len_all.max()) + + lamd = fit.stretched_exponential.parameter1 + beta = fit.stretched_exponential.parameter2 + + print('Fit to stretched exponential:\n Parameter of fit: lambda = %.010e, beta = %.010e' %(lamd,beta)) + + # Perform Monte-Carlo Simulation for KS test + if mctest: + bins_cdf = np.logspace(np.log10(xmin),np.log10(xmax),40) + bins_cdf[0] = xmin; bins_cdf[-1] = xmax + bins_cdf_m = 10**(np.log10(bins_cdf[:-1])+0.5*np.diff(np.log10(bins_cdf))) + + hist,bins = np.histogram(len_all,bins=bins_cdf,density=True) + cdf_org = (hist*np.diff(bins_cdf))[::-1].cumsum()[::-1] + + cdf_model = fit.stretched_exponential.cdf(bins_cdf[:-1],survival=True) + #cdf_model = cdf_stretched_exponential(fit.stretched_exponential,bins_cdf[:-1]) + ks_org = ks(cdf_org,cdf_model) + + n_sample = len_all.size + + ks_list = [] + + discrete_values = np.unique(np.hstack([i*12.5 + np.array([j*np.sqrt(2)*12.5 for j in range(140)]) for i in range(140)])) + bins_discrete = discrete_values[:-1] - 0.5*np.diff(discrete_values) + + if mctest_plots: + fig3,ax3 = plt.subplots(1,1) + fig2,ax2 = plt.subplots(1,1) + + for itest in range(mciter): + #print(itest) + sample = fit.stretched_exponential.generate_random(n_sample) + # Bin to discrete values + hist_s,bins_s = np.histogram(sample,bins=bins_discrete) + sample_dis = np.hstack([np.ones(hist_s[i])*discrete_values[i] for i in range(hist_s.size)]) + + # Compute cdf + hist,bins = np.histogram(sample_dis,bins=bins_cdf,density=True) + cdf_sample = (hist*np.diff(bins_cdf))[::-1].cumsum()[::-1] + + if mctest_plots: + ax3.plot(bins_cdf_m,cdf_sample) + ax2.plot(bins_cdf_m,np.abs(cdf_sample-cdf_model)/np.sqrt(cdf_model*(1-cdf_model))) + + ks_list.append(ks(cdf_sample,cdf_model)) + + if mctest_plots: + ax3.plot(bins_cdf_m,cdf_model,'k',linewidth=2.) + ax3.plot(bins_cdf_m,cdf_org,'r',linewidth=2.) + ax2.plot(bins_cdf_m,np.abs(cdf_org-cdf_model)/np.sqrt(cdf_model*(1-cdf_model)),'r',linewidth=2.) + + \\ + + cf = (pdf_length[bins_mean>=xmin]*np.diff(bins)[bins_mean>=xmin]).sum() + bins_fit = np.logspace(np.log10(xmin),np.log10(xmax),100) + pdf_fit = fit.stretched_exponential.pdf(bins_fit)*cf + + return ks_org0]) + H, xedges, yedges = np.histogram2d(lkf_year[:,lkf.indm0], lkf_year[:,lkf.indm1], + bins=(xedg, yedg)) + lkf_density[iyear,:,:] = H + + #Save output + self.lkf_density = lkf_density + + if norm_coverage: + if lkf.datatype=='rgps': + cov_dict = np.load(lkf.lkf_path + 'coverage_%s.npz' %lkf.datatype) + coverage = cov_dict['coverage'] + lon_cov = cov_dict['lon']; lat_cov = cov_dict['lat'] + x_cov,y_cov = m(lon_cov,lat_cov) + coverage_map = np.zeros((len(lkf.lkf_dataset),xedg.size-1,yedg.size-1)) + for iyear in range(len(lkf.lkf_dataset)): + coverage_map[iyear,:,:], xedges, yedges = np.histogram2d(x_cov.flatten(), + y_cov.flatten(), + bins=(self.xedg, self.yedg), + weights=coverage[iyear,:,:].flatten()) + self.coverage_map = coverage_map + + elif lkf.datatype == 'mitgcm_2km': + grid_path = '/work/ollie/nhutter/arctic_2km/run_cor_cs/' + lon_cov, lat_cov = read_latlon(grid_path) + mask = mask_arcticbasin(grid_path,read_latlon) + index_x = np.where(np.sum(mask[1:-1,1:-1],axis=0)>0) + index_y = np.where(np.sum(mask[1:-1,1:-1],axis=1)>0) + red_fac = 3 # Take only every red_fac point to reduce array size + lon_cov = lon_cov[index_y[0][0]-1:index_y[0][-1]+2:red_fac, + index_x[0][0]-1:index_x[0][-1]+2:red_fac] + lat_cov = lat_cov[index_y[0][0]-1:index_y[0][-1]+2:red_fac, + index_x[0][0]-1:index_x[0][-1]+2:red_fac] + mask = mask[index_y[0][0]-1:index_y[0][-1]+2:red_fac, + index_x[0][0]-1:index_x[0][-1]+2:red_fac] + x_cov,y_cov = m(lon_cov[mask],lat_cov[mask]) + coverage_map = np.zeros((len(years),xedg.size-1,yedg.size-1)) + for iyear in range(len(lkf.lkf_dataset)): + coverage_map[iyear,:,:], xedges, yedges = np.histogram2d(x_cov.flatten(), + y_cov.flatten(), + bins=(self.xedg, self.yedg)) + coverage_map[iyear,:,:] *= len(lkf.lkf_dataset[iyear]) + + self.coverage_map = coverage_map + + elif lkf.datatype =='sirex': + # if lkf_path.split('/')[-2].split('_')[-1] == 'means': + # ind_yp = -2 + # elif lkf_path.split('/')[-2].split('_')[-1] == 'inst': + # ind_yp = -1 + # ncfile = ('/work/ollie/nhutter/sirex/data/' + + # '/'.join(lkf_path[47:-1].split('/')[:-1])+'/'+ + # '_'.join(lkf_path[47:-1].split('/')[-1].split('_')[:ind_yp]) + '_' + + # years[-1] + '_' + + # '_'.join(lkf_path[47:-1].split('/')[-1].split('_')[ind_yp:]) + '.nc') + lkf_ps=lkf_path.split('/') + sp = '/'.join(lkf_ps[:np.where(np.array(lkf_ps)=='analysis')[0][0]]) + ind_m = np.where(np.array(lkf_ps)=='lead_detect')[0][0]+1 + ind_f = np.where(['means' in iseg or 'inst' in iseg for iseg in lkf_ps])[0][0] + ind_yp = np.array([-2,-1])[[np.any(['means' in iseg for iseg in lkf_ps]),np.any(['inst' in iseg for iseg in lkf_ps])]][0] + flnml = lkf_ps[ind_f].split('_'); flnml.insert(ind_yp,years[-1]) + ncfile = os.path.join(sp,'data','/'.join(lkf_ps[ind_m:ind_f]),'_'.join(flnml)+'.nc') + + ncdata = Dataset(ncfile) + lon = ncdata.variables['ULON'][:,:] + lat = ncdata.variables['ULAT'][:,:] + + mask = ((((lon > -120) & (lon < 100)) & (lat >= 80)) | + ((lon <= -120) & (lat >= 70)) | + ((lon >= 100) & (lat >= 70))) + index_x = np.where(np.sum(mask[1:-1,1:-1],axis=0)>0) + index_y = np.where(np.sum(mask[1:-1,1:-1],axis=1)>0) + red_fac = 1 # Take only every red_fac point to reduce array size + x_cov,y_cov = m(lon[max([0,index_y[0][0]-1]):index_y[0][-1]+2:red_fac, + max([0,index_x[0][0]-1]):index_x[0][-1]+2:red_fac], + lat[max([0,index_y[0][0]-1]):index_y[0][-1]+2:red_fac, + max([0,index_x[0][0]-1]):index_x[0][-1]+2:red_fac]) + + coverage_map = np.zeros((len(years),xedg.size-1,yedg.size-1)) + for iyear in range(len(lkf.lkf_dataset)): + coverage_map[iyear,:,:], xedges, yedges = np.histogram2d(x_cov.flatten(), + y_cov.flatten(), + bins=(self.xedg, self.yedg)) + coverage_map[iyear,:,:] *= len(lkf.lkf_dataset[iyear]) + + self.coverage_map = coverage_map + + + def density_len_class(self,lkf,len_class=[0e3,100e3,np.inf],filt_rgps_temp=False,dt=3.): + dt_rgps = 3. + + if not lkf.length is None: + self.len_class = len_class + + density_len_class = np.zeros((len(len_class)-1,len(lkf.lkf_dataset), + self.xedg.size-1,self.yedg.size-1)) + + for iclass in range(len(len_class)-1): + for iyear in range(len(lkf.lkf_dataset)): + if ~filt_rgps_temp: + lkf_year = np.concatenate(np.concatenate([np.array(lkf.lkf_dataset[iyear][iday])[(lkf.length.lkf_length[iyear][iday]>=len_class[iclass]) & (lkf.length.lkf_length[iyear][iday]=len_class[iclass]) & (lkf.length.lkf_length[iyear][iday]=len_class[iclass]) & (lkf.length.lkf_length[iyear][iday]0) + index_y = np.where(np.sum(mask[1:-1,1:-1],axis=1)>0) + red_fac = 3. # Take only every red_fac point to reduce array size + + if lkf.datatype == 'sirex': + # if lkf_path is None: + # print('ERROR: No lkf_path to netcdf_file is given!') + # if lkf_path.split('/')[-2].split('_')[-1] == 'means': + # ind_yp = -2 + # elif lkf_path.split('/')[-2].split('_')[-1] == 'inst': + # ind_yp = -1 + # else: + # print(lkf_path.split('/')[-1].split('_')[-1]) + # ncfile = ('/work/ollie/nhutter/sirex/data/' + + # '/'.join(lkf_path[47:-1].split('/')[:-1])+'/'+ + # '_'.join(lkf_path[47:-1].split('/')[-1].split('_')[:ind_yp]) + '_' + + # years[-1] + '_' + + # '_'.join(lkf_path[47:-1].split('/')[-1].split('_')[ind_yp:]) + '.nc') + lkf_ps=lkf_path.split('/') + sp = '/'.join(lkf_ps[:np.where(np.array(lkf_ps)=='analysis')[0][0]]) + ind_m = np.where(np.array(lkf_ps)=='lead_detect')[0][0]+1 + ind_f = np.where(['means' in iseg or 'inst' in iseg for iseg in lkf_ps])[0][0] + ind_yp = np.array([-2,-1])[[np.any(['means' in iseg for iseg in lkf_ps]),np.any(['inst' in iseg for iseg in lkf_ps])]][0] + flnml = lkf_ps[ind_f].split('_'); flnml.insert(ind_yp,years[-1]) + ncfile = os.path.join(sp,'data','/'.join(lkf_ps[ind_m:ind_f]),'_'.join(flnml)+'.nc') + + + ncdata = Dataset(ncfile) + lon = ncdata.variables['ULON'][:,:] + lat = ncdata.variables['ULAT'][:,:] + + mask = ((((lon > -120) & (lon < 100)) & (lat >= 80)) | + ((lon <= -120) & (lat >= 70)) | + ((lon >= 100) & (lat >= 70))) + index_x = np.where(np.sum(mask[1:-1,1:-1],axis=0)>0) + index_y = np.where(np.sum(mask[1:-1,1:-1],axis=1)>0) + red_fac = 1. # Take only every red_fac point to reduce array size + + lkf_interc = [] + lkf_interc_par = [] + if self.use_vorticity: + lkf_interc_type = [] + + for iyear in range(len(lkf.lkf_dataset)): + intc_ang_year = [] + intc_par_year = [] + if self.use_vorticity: + intc_type_year = [] + + for iday in range(len(lkf.lkf_dataset[iyear])): + if lkf.datatype == 'rgps': + lkf_map = np.zeros((248,264)) + if self.use_vorticity: + vor_file = os.listdir(os.path.join(lkf_path,str(lkf.years[iyear]))); + vor_file.sort(); vor_file = vor_file[iday][4:-4] + rgps_path = '/work/ollie/nhutter/RGPS/eulerian/' + vor_path = os.path.join(rgps_path,'w%02i%s' %(int(str(lkf.years[iyear])[-2:])-1,str(lkf.years[iyear])[-2:])) + (vor,xg0,xg1,yg0,yg1,nxcell,nycell) = read_RGPS(os.path.join(vor_path,vor_file + ".VRT"), land_fill=np.NaN, nodata_fill=np.NaN) + elif lkf.datatype == 'mitgcm_2km' or lkf.datatype == 'sirex': + lkf_map = np.zeros((int(np.ceil((index_y[0][-1]+1-index_y[0][0]+1)/red_fac)), + int(np.ceil((index_x[0][-1]+1-index_x[0][0]+1)/red_fac)))) + elif lkf.datatype == 'mosaic': + lkf_map = np.zeros(lkf.lkf_meta[iyear][iday][-1]) + if self.use_vorticity: + print('vorticity used in mosaic data') + vor = Dataset(lkf.lkf_meta[iyear][iday][3],'r')['vorticity'][:] + # if lkf.datatype == 'sirex': + # if use_vorticity: + # flnml = lkf_ps[ind_f].split('_'); flnml.insert(ind_yp,lkf.years[iyear]) + # ncfile = os.path.join(sp,'data','/'.join(lkf_ps[ind_m:ind_f]),'_'.join(flnml)+'.nc') + # data = Dataset(ncfile) + # time = data.variables['time'][:] + # lon = data.variables['ULON'][:,:] + # lat = data.variables['ULAT'][:,:] + # lon[lon==1e30] = np.nan; lat[lat==1e30] = np.nan; + # if np.any(np.array(data.variables.keys())=='DXU') and np.any(np.array(data.variables.keys())=='DYU'): + # dxu = data.variables['DXU'][:,:] + # dyu = data.variables['DYU'][:,:] + # else: + # print("ERROR: DXU and DYU are missing in netcdf file!") + # print(" --> Compute dxu and dyu from lon,lat using SSMI projection") + # m = mSSMI() + # x,y = m(lon,lat) + # dxu = np.sqrt((x[:,1:]-x[:,:-1])**2 + (y[:,1:]-y[:,:-1])**2) + # dxu = np.concatenate([dxu,dxu[:,-1].reshape((dxu.shape[0],1))],axis=1) + # dyu = np.sqrt((x[1:,:]-x[:-1,:])**2 + (y[1:,:]-y[:-1,:])**2) + # dyu = np.concatenate([dyu,dyu[-1,:].reshape((1,dyu.shape[1]))],axis=0) + + + + + + for iseg, seg_i in enumerate(lkf.lkf_dataset[iyear][iday]): + lkf_map[seg_i[:,0].astype('int'),seg_i[:,1].astype('int')] += iseg + + intc_ang_day = [] + intc_par_day = [] + if self.use_vorticity: + intc_type_day = [] + + # Check for possible intersection partners + for iseg, seg_i in enumerate(lkf.lkf_dataset[iyear][iday]): + search_ind = np.zeros(lkf_map.shape).astype('bool') + + # search_ind[seg_i[:,0].astype('int')+1,seg_i[:,1].astype('int') ] = True + # search_ind[seg_i[:,0].astype('int')-1,seg_i[:,1].astype('int') ] = True + # search_ind[seg_i[:,0].astype('int') ,seg_i[:,1].astype('int')+1] = True + # search_ind[seg_i[:,0].astype('int') ,seg_i[:,1].astype('int')-1] = True + # search_ind[seg_i[:,0].astype('int')+1,seg_i[:,1].astype('int')+1] = True + # search_ind[seg_i[:,0].astype('int')-1,seg_i[:,1].astype('int')-1] = True + # search_ind[seg_i[:,0].astype('int')-1,seg_i[:,1].astype('int')+1] = True + # search_ind[seg_i[:,0].astype('int')+1,seg_i[:,1].astype('int')-1] = True + # search_ind[seg_i[:,0].astype('int') ,seg_i[:,1].astype('int') ] = False + + for ix in range(-dis_par,dis_par+1): + for iy in range(-dis_par,dis_par+1): + if np.all([seg_i[:,0].astype('int')+ix >= 0, seg_i[:,0].astype('int')+ix < search_ind.shape[0]]): + if np.all([seg_i[:,1].astype('int')+iy >= 0, seg_i[:,1].astype('int')+iy < search_ind.shape[1]]): + search_ind[seg_i[:,0].astype('int')+ix,seg_i[:,1].astype('int')+iy] = True + search_ind[seg_i[:,0].astype('int') ,seg_i[:,1].astype('int') ] = False + + + intercep_points = np.where(search_ind & (lkf_map!=0)) + + intercep_partners, intercep_counts = np.unique(lkf_map[intercep_points], + return_counts=True) + + for ipar,pari in enumerate(intercep_partners): + if pari > iseg and pari < len(lkf.lkf_dataset[iyear][iday]): + # Determine one intercetion point for pair + dis_intercep = np.zeros(intercep_counts[ipar]) + for iintc in range(intercep_counts[ipar]): + dis_intercep[iintc] = np.min(np.sqrt((seg_i[:,0] - + intercep_points[0][lkf_map[intercep_points]==pari][iintc])**2 + + (seg_i[:,1] - + intercep_points[1][lkf_map[intercep_points]==pari][iintc])**2)) + intcp = (intercep_points[0][lkf_map[intercep_points]==pari][np.argmin(dis_intercep)], + intercep_points[1][lkf_map[intercep_points]==pari][np.argmin(dis_intercep)]) + + # Determine angle between both pairs + # # Determine orientation of seg_i + ind = np.argmin(np.sqrt((seg_i[:,0] - intcp[0])**2 + + (seg_i[:,1] - intcp[1])**2)) + ind = np.array([np.max([0,ind-num_p]), + np.min([seg_i.shape[0],ind+num_p+1])]) + p_x,p_y = lkf_poly_fit_p(seg_i[ind[0]:ind[1],indc0], + seg_i[ind[0]:ind[1],indc1],1) # Linear fit + p = p_y[0]/p_x[0] + # # Determin angle from linear fit + if np.isnan(p): + ang_i = 90. + else: + ang_i = np.arctan(p)/np.pi*180. + + if self.use_vorticity: + vor0 = np.mean(vor[seg_i[ind[0]:ind[1],0].astype('int'), + seg_i[ind[0]:ind[1],1].astype('int')]) + + # # Determine orientation of pari + lkf_par = lkf.lkf_dataset[iyear][iday][int(pari)] + ind = np.argmin(np.sqrt((lkf_par[:,0] - intcp[0])**2 + + (lkf_par[:,1] - intcp[1])**2)) + ind = np.array([np.max([0,ind-num_p]), + np.min([lkf_par.shape[0],ind+num_p+1])]) + p_x,p_y = lkf_poly_fit_p(lkf_par[ind[0]:ind[1],indc0], + lkf_par[ind[0]:ind[1],indc1],1) # Linear fit + p = p_y[0]/p_x[0] + # # Determin angle from linear fit + if np.isnan(p): + ang_ii = 90. + else: + ang_ii = np.arctan(p)/np.pi*180. + if self.use_vorticity: + vor1 = np.mean(vor[lkf_par[ind[0]:ind[1],0].astype('int'), + lkf_par[ind[0]:ind[1],1].astype('int')]) + # angdiff = np.abs(ang_ii-ang_i) + # if vor1*vor0>0: + # # vorticity same sign + # if angdiff > 90: angdiff=180-angdiff + # intc_ang_day.append(180-angdiff) + # else: + # if vor1<0: + # angdiff = 180-angdiff + # intc_ang_day.append(angdiff) + # intc_ang_day.append(angdiff) + if vor0>0 and vor1<0: + if ang_ii0 and vor0<0: + if ang_i 90: angdiff=180-angdiff + intc_ang_day.append(angdiff) + intc_par_day.append(np.array([iseg,pari])) + + intc_ang_year.append(intc_ang_day) + intc_par_year.append(intc_par_day) + if self.use_vorticity: + intc_type_year.append(intc_type_day) + lkf_interc.append(intc_ang_year) + lkf_interc_par.append(intc_par_year) + if self.use_vorticity: + lkf_interc_type.append(intc_type_year) + + self.lkf_interc = np.array(lkf_interc) + self.lkf_interc_par = np.array(lkf_interc_par) + if self.use_vorticity: + self.lkf_interc_type = np.array(lkf_interc_type) + + + if link_def_life_len: + # Compute mean deformation of intersecting partners + self.def_par = []; self.diff_def_par = []; + self.life_par = []; self.len_par = [] + for iyear in range(len(lkf.lkf_dataset)): + def_par_year = []; diff_def_par_year = []; + life_par_year = []; len_par_year = [] + for iday in range(len(lkf.lkf_dataset[iyear])): + if len(self.lkf_interc_par[iyear][iday]) > 0: + def_par_day = np.array([np.sqrt(np.sum(np.array(lkf.deformation.lkf_deformation[iyear][iday])[np.stack(self.lkf_interc_par[iyear][iday])[:,0].astype('int')]**2,axis=1)), + np.sqrt(np.sum(np.array(lkf.deformation.lkf_deformation[iyear][iday])[np.stack(self.lkf_interc_par[iyear][iday])[:,1].astype('int')]**2,axis=1))]) + diff_def_par_day = np.abs(np.diff(def_par_day,axis=0)) + life_par_day = np.array([lkf.lifetime.lkf_lifetime[iyear][iday][np.stack(self.lkf_interc_par[iyear][iday])[:,0].astype('int')], + lkf.lifetime.lkf_lifetime[iyear][iday][np.stack(self.lkf_interc_par[iyear][iday])[:,1].astype('int')]]) + len_par_day = np.array([np.array(lkf.length.lkf_length[iyear][iday])[np.stack(self.lkf_interc_par[iyear][iday])[:,0].astype('int')], + np.array(lkf.length.lkf_length[iyear][iday])[np.stack(self.lkf_interc_par[iyear][iday])[:,1].astype('int')]]) + else: + life_par_day = np.array([]) + len_par_day = np.array([]) + def_par_day = np.array([]) + diff_def_par_day = np.array([]) + + def_par_year.append(def_par_day) + diff_def_par_year.append(diff_def_par_day) + life_par_year.append(life_par_day) + len_par_year.append(len_par_day) + self.def_par.append(def_par_year) + self.diff_def_par.append(diff_def_par_year) + self.life_par.append(life_par_year) + self.len_par.append(len_par_year) + + if link_def_len: + # Compute mean deformation of intersecting partners + self.def_par = []; self.diff_def_par = []; + #self.life_par = []; + self.len_par = [] + for iyear in range(len(lkf.lkf_dataset)): + def_par_year = []; diff_def_par_year = []; + #life_par_year = []; + len_par_year = [] + for iday in range(len(lkf.lkf_dataset[iyear])): + if len(self.lkf_interc_par[iyear][iday]) > 0: + def_par_day = np.array([np.sqrt(np.sum(np.array(lkf.deformation.lkf_deformation[iyear][iday])[np.stack(self.lkf_interc_par[iyear][iday])[:,0].astype('int')]**2,axis=1)), + np.sqrt(np.sum(np.array(lkf.deformation.lkf_deformation[iyear][iday])[np.stack(self.lkf_interc_par[iyear][iday])[:,1].astype('int')]**2,axis=1))]) + diff_def_par_day = np.abs(np.diff(def_par_day,axis=0)) + #life_par_day = np.array([lkf.lifetime.lkf_lifetime[iyear][iday][np.stack(self.lkf_interc_par[iyear][iday])[:,0].astype('int')], + # lkf.lifetime.lkf_lifetime[iyear][iday][np.stack(self.lkf_interc_par[iyear][iday])[:,1].astype('int')]]) + len_par_day = np.array([np.array(lkf.length.lkf_length[iyear][iday])[np.stack(self.lkf_interc_par[iyear][iday])[:,0].astype('int')], + np.array(lkf.length.lkf_length[iyear][iday])[np.stack(self.lkf_interc_par[iyear][iday])[:,1].astype('int')]]) + else: + #life_par_day = np.array([]) + len_par_day = np.array([]) + def_par_day = np.array([]) + diff_def_par_day = np.array([]) + + def_par_year.append(def_par_day) + diff_def_par_year.append(diff_def_par_day) + #life_par_year.append(life_par_day) + len_par_year.append(len_par_day) + self.def_par.append(def_par_year) + self.diff_def_par.append(diff_def_par_year) + #self.life_par.append(life_par_year) + self.len_par.append(len_par_year) + + + + def plot_hist(self,bins=np.linspace(0,90,45), + output_plot_data=False,gen_fig=True,save_fig=False, + fig_name=None): + + if gen_fig: + style_label = 'seaborn-darkgrid' + with plt.style.context(style_label): + fig,ax = plt.subplots(nrows=1,ncols=1) + + ax.set_xlabel('Intersection angle') + ax.set_ylabel('PDF') + #ax.set_xlim([0,90]) + for iyear in range(len(self.lkf_interc)): + pdf_interc, bins_interc = np.histogram(np.concatenate(self.lkf_interc[iyear]), + bins=bins, density=True) + bins_mean = 0.5*(bins_interc[1:]+bins_interc[:-1]) + ax.plot(bins_mean, pdf_interc,label=self.years[iyear],color='0.5',alpha=0.5) + + pdf_interc, bins_interc = np.histogram(np.concatenate([np.concatenate(self.lkf_interc[iyear]) for iyear in range(len(self.lkf_interc))]), + bins=bins, density=True) + bins_mean = 0.5*(bins_interc[1:]+bins_interc[:-1]) + + if gen_fig: + ax.plot(bins_mean, pdf_interc,label=self.years[iyear]) + + if save_fig: + if fig_name is None: + fig.savefig(self.output_path + 'Interc_pdf_all_years.pdf') + else: + fig.savefig(self.output_path + fig_name) + + if output_plot_data: + return pdf_interc, bins_mean + + + def plot_hist_def_life_len(self,def_class=None,bins=np.linspace(0,90,23), + len_thres = 10*12.5e3, + output_plot_data=False,gen_fig=True, + save_fig=False, fig_name=None, + return_num_meas=False): + if def_class is None: + if datatype=='rgps': + def_class = [0,0.03,0.1,2] + elif datatype == 'mitgcm_2km': + def_class = [0,0.05,0.2,10] + if gen_fig: + style_label = 'seaborn-darkgrid' + with plt.style.context(style_label): + fig,ax = plt.subplots(nrows=1,ncols=len(def_class)-1, figsize=(6*(len(def_class)-1),5)) + colors=plt.rcParams['axes.prop_cycle'].by_key()['color'] + + def_masked_class = [[] for i in range(len(def_class))] + + pdf_all_class = [] + pdf_years_class = [] + + for iax in range(len(def_class)-1): + if gen_fig: + if (len(def_class)-1)==1: + axi=ax + else: + axi = ax[iax] + + axi.set_title('Def. class: %.2f to %.2f [1/day]' %(def_class[iax],def_class[iax+1])) + axi.set_xlabel('Intersection angle') + axi.set_ylabel('PDF') + axi.set_xlim([0,90]) + + pdf_year_save = [] + + for iyear in range(len(self.lkf_interc)): + mask_def = np.all([np.all(np.hstack(self.def_par[iyear])>=def_class[iax],axis=0), + np.all(np.hstack(self.def_par[iyear])=len_thres,axis=0) + mask_life = mask_len & mask_life + if self.use_vorticity: + mask_def = np.stack([mask_def,mask_def]).T.flatten() + mask_life = np.stack([mask_life,mask_life]).T.flatten() + pdf_interc, bins_interc = np.histogram(np.concatenate(self.lkf_interc[iyear])[mask_def & mask_life], + bins=bins, density=True) + pdf_year_save.append(pdf_interc) + bins_mean = 0.5*(bins_interc[1:]+bins_interc[:-1]) + if gen_fig: + if iyear==0: + axi.plot(bins_mean, pdf_interc,'.',label='single years',color='0.5',alpha=0.5) + else: + axi.plot(bins_mean, pdf_interc,'.',color='0.5',alpha=0.5) + + def_masked_class[iax].append(np.concatenate(self.lkf_interc[iyear])[mask_def & mask_life]) + pdf_interc, bins_interc = np.histogram(np.concatenate(def_masked_class[iax]), + bins=bins, density=True) + bins_mean = 0.5*(bins_interc[1:]+bins_interc[:-1]) + + pdf_all_class.append(pdf_interc) + pdf_years_class.append(pdf_year_save) + + if gen_fig: + axi.plot(bins_mean, pdf_interc,label='all years',color=colors[0],alpha=1.0) + + axi.plot([],[],' ',label='Tot. num: %i' %np.concatenate(def_masked_class[iax]).size) + axi.legend() + + self.def_masked_class = def_masked_class + + if save_fig: + if fig_name is None: + fig.savefig(self.output_path + 'Interc_pdf_def_len_life_all_years.pdf') + else: + fig.savefig(self.output_path + fig_name) + + if output_plot_data: + if return_num_meas: + return pdf_all_class, pdf_years_class, bins_mean, np.concatenate(def_masked_class[iax]).size + else: + return pdf_all_class, pdf_years_class, bins_mean + + + def plot_hist_def_len(self,def_class=None,bins=np.linspace(0,90,23), + len_thres = 10*12.5e3, + output_plot_data=False,gen_fig=True, + save_fig=False, fig_name=None, + return_num_meas=False): + if def_class is None: + if datatype=='rgps': + def_class = [0,0.03,0.1,2] + elif datatype == 'mitgcm_2km': + def_class = [0,0.05,0.2,10] + if gen_fig: + style_label = 'seaborn-darkgrid' + with plt.style.context(style_label): + fig,ax = plt.subplots(nrows=1,ncols=len(def_class)-1, figsize=(6*(len(def_class)-1),5)) + colors=plt.rcParams['axes.prop_cycle'].by_key()['color'] + + def_masked_class = [[] for i in range(len(def_class))] + + pdf_all_class = [] + pdf_years_class = [] + + for iax in range(len(def_class)-1): + if gen_fig: + if (len(def_class)-1)==1: + axi=ax + else: + axi = ax[iax] + + axi.set_title('Def. class: %.2f to %.2f [1/day]' %(def_class[iax],def_class[iax+1])) + axi.set_xlabel('Intersection angle') + axi.set_ylabel('PDF') + axi.set_xlim([0,90]) + + pdf_year_save = [] + + for iyear in range(len(self.lkf_interc)): + mask_def = np.all([np.all(np.hstack(self.def_par[iyear])>=def_class[iax],axis=0), + np.all(np.hstack(self.def_par[iyear])=len_thres,axis=0) + mask_life = mask_len #& mask_life + if self.use_vorticity: + mask_def = np.stack([mask_def,mask_def]).T.flatten() + mask_life = np.stack([mask_life,mask_life]).T.flatten() + pdf_interc, bins_interc = np.histogram(np.concatenate(self.lkf_interc[iyear])[mask_def & mask_life], + bins=bins, density=True) + pdf_year_save.append(pdf_interc) + bins_mean = 0.5*(bins_interc[1:]+bins_interc[:-1]) + if gen_fig: + if iyear==0: + axi.plot(bins_mean, pdf_interc,'.',label='single years',color='0.5',alpha=0.5) + else: + axi.plot(bins_mean, pdf_interc,'.',color='0.5',alpha=0.5) + + def_masked_class[iax].append(np.concatenate(self.lkf_interc[iyear])[mask_def & mask_life]) + pdf_interc, bins_interc = np.histogram(np.concatenate(def_masked_class[iax]), + bins=bins, density=True) + bins_mean = 0.5*(bins_interc[1:]+bins_interc[:-1]) + + pdf_all_class.append(pdf_interc) + pdf_years_class.append(pdf_year_save) + + if gen_fig: + axi.plot(bins_mean, pdf_interc,label='all years',color=colors[0],alpha=1.0) + + axi.plot([],[],' ',label='Tot. num: %i' %np.concatenate(def_masked_class[iax]).size) + axi.legend() + + self.def_masked_class = def_masked_class + + if save_fig: + if fig_name is None: + fig.savefig(self.output_path + 'Interc_pdf_def_len_life_all_years.pdf') + else: + fig.savefig(self.output_path + fig_name) + + if output_plot_data: + if return_num_meas: + return pdf_all_class, pdf_years_class, bins_mean, np.concatenate(def_masked_class[iax]).size + else: + return pdf_all_class, pdf_years_class, bins_mean + + + + + + + + + +# 6. Compute orientation + +class lkf_orientation: + def __init__(self,lkf,res=200e3,use_poly_ori=True): + print("Compute orientation of LKFs") + + self.output_path = lkf.output_path + self.m = lkf.m + + # Compute cell that an LKF contributes to + # Mapping grid + self.xedg = np.arange(m.xmin,m.xmax,res) + self.yedg = np.arange(m.ymin,m.ymax,res) + self.y,self.x = np.meshgrid(0.5*(self.yedg[1:]+self.yedg[:-1]), + 0.5*(self.xedg[1:]+self.xedg[:-1])) + + cell_contrib = [] + + for lkf_year in lkf.lkf_dataset: + cell_contrib_year = [] + for lkf_day in lkf_year: + cell_contrib_day = [] + for ilkf in lkf_day: + if use_poly_ori: + H, xedges, yedges = np.histogram2d(ilkf[:,lkf.indp0], ilkf[:,lkf.indp1], + bins=(self.xedg, self.yedg)) + else: + H, xedges, yedges = np.histogram2d(ilkf[:,lkf.indm0], ilkf[:,lkf.indm1], + bins=(self.xedg, self.yedg)) + cell_contrib_day.append(np.where(H.flatten()>0)[0]) + + cell_contrib_year.append(cell_contrib_day) + + cell_contrib.append(cell_contrib_year) + + self.cell_contrib = np.array(cell_contrib) + + + + # Compute orientation + print("Compute orientation of segments") + lkf_orientation = [] + lkf_ori_len_wght = [] + + lkf_angle = [] + lkf_angle_len_wght = [] + + ori_day_org = np.empty((self.x.shape),dtype=object) + for ix in range(self.xedg.size-1): + for iy in range(self.yedg.size-1): + ori_day_org[ix,iy] = np.array([]) + + for iyear,lkf_year in enumerate(lkf.lkf_dataset): + + ori_year = [] + ori_len_year = [] + ang_year = [] + ang_len_year = [] + for iday,lkf_day in enumerate(lkf_year): + ori_day = ori_day_org.copy() + ori_len_day = ori_day_org.copy() + ang_day = [] + ang_len_day = [] + for ilkf,lkf_i in enumerate(lkf_day): + ang_lkf = [] + ang_len_lkf = [] + for i_cell in self.cell_contrib[iyear][iday][ilkf]: + # Find part of lkf inside box + ix,iy = np.unravel_index(i_cell,self.x.shape) + if use_poly_ori: + lkf_i_c = lkf_i[:,lkf.indp0:lkf.indp0+2][np.all([lkf_i[:,lkf.indp0]>=self.xedg[ix], + lkf_i[:,lkf.indp0]<=self.xedg[ix+1], + lkf_i[:,lkf.indp1]>=self.yedg[iy], + lkf_i[:,lkf.indp1]<=self.yedg[iy+1]], + axis=0),:] + else: + lkf_i_c = lkf_i[:,lkf.indm0:lkf.indm0+2][np.all([lkf_i[:,lkf.indm0]>=self.xedg[ix], + lkf_i[:,lkf.indm0]<=self.xedg[ix+1], + lkf_i[:,lkf.indm1]>=self.yedg[iy], + lkf_i[:,lkf.indm1]<=self.yedg[iy+1]], + axis=0),:] + + # Linear fit & determine angle from linear fit + if lkf_i_c.size > 2: + # All cases that are not a line in y-direction + p_x,p_y = lkf_poly_fit_p(lkf_i_c[:,0],lkf_i_c[:,1], + 1) # Linear fit + p = p_y[0]/p_x[0] + + # Determin angle from linear fit + if np.isnan(p): + ang = 90. + else: + ang = np.arctan(p)/np.pi*180. + + ang_lkf.append(ang) + ang_len_lkf.append(lkf_i_c.shape[0]) + + ori_day[ix,iy] = np.concatenate([ori_day[ix,iy], + np.array([ang])]) + ori_len_day[ix,iy] = np.concatenate([ori_len_day[ix,iy], + np.array([lkf_i_c.shape[0]])]) + else: + ang_lkf.append(np.nan) + ang_len_lkf.append(np.nan) + + ang_day.append(ang_lkf) + ang_len_day.append(ang_len_lkf) + + ang_year.append(ang_day) + ang_len_year.append(ang_len_day) + + ori_year.append(ori_day) + ori_len_year.append(ori_len_day) + + lkf_angle.append(ang_year) + lkf_angle_len_wght.append(ang_len_year) + + lkf_orientation.append(ori_year) + lkf_ori_len_wght.append(ori_len_year) + + + + #Save output + self.lkf_angle = np.array(lkf_angle) + self.lkf_angle_len_wght = np.array(lkf_angle_len_wght) + self.lkf_orientation = np.array(lkf_orientation) + self.lkf_ori_len_wght = np.array(lkf_ori_len_wght) + + + + +# 7. Lifetime of LKFs + +class lkf_lifetime: + def __init__(self,lkf): + print("Compute lifetime of LKFs") + + self.output_path = lkf.output_path + + lkf_lifetime = [] + + for iyear,lkf_year in enumerate(lkf.lkf_dataset): + life_year = [np.ones((len(i_num_lkf),)) for i_num_lkf in lkf_year] + #print(len(lkf_year),len(lkf.lkf_track_data[iyear])) + #print(len(life_year)) + for it,itrack in enumerate(lkf.lkf_track_data[iyear]): + #print(it,itrack) + if itrack.size>0: + #print(life_year[it+1].shape) + life_year[it+1][itrack[:,1].astype('int')] += life_year[it][itrack[:,0].astype('int')] + + lkf_lifetime.append(life_year) + + #Save output + self.lkf_lifetime = np.array(lkf_lifetime) + + + def plot_pdf(self,xlim=[0,31],dt=3., + output_plot_data=False,gen_fig=True,save_fig=False, + fig_name=None): + # Compute histograms + if gen_fig: + style_label = 'seaborn-darkgrid' + with plt.style.context(style_label): + fig,ax = plt.subplots(nrows=1,ncols=1) + ax.set_xlabel('LKF lifetime') + ax.set_ylabel('Relative frequency') + ax.set_yscale('log') + ax.set_xlim(xlim) + colors=plt.rcParams['axes.prop_cycle'].by_key()['color'] + for iyear in range(len(self.lkf_lifetime)): + pdf_life = np.bincount(np.concatenate(self.lkf_lifetime[iyear]).astype('int')-1) + bins_mean = np.arange(pdf_life.size)*dt+dt/2. + if iyear==0: + ax.plot(bins_mean, pdf_life/float(np.sum(pdf_life)),'.',color='0.5',alpha=0.5,label="single years") + else: + ax.plot(bins_mean, pdf_life/float(np.sum(pdf_life)),'.',color='0.5',alpha=0.5) + + pdf_life = np.bincount(np.concatenate([np.concatenate(life_year) for life_year in self.lkf_lifetime]).astype('int')-1) + bins_mean = np.arange(pdf_life.size)*dt+dt/2. + + if gen_fig: + ax.plot(bins_mean, pdf_life/float(np.sum(pdf_life)),'.',color=colors[1],alpha=1.0,label="all years") + + coeff = np.polyfit(bins_mean, np.log(pdf_life/float(np.sum(pdf_life))),1) + pdf_life_fit = np.exp(np.polyval(coeff,bins_mean)) + if gen_fig: + ax.plot(bins_mean,pdf_life_fit, + color=colors[1],alpha=1.0,linestyle='--', + label="exponential fit\nexponent %.2f" %(-coeff[0])) + ax.legend() + + if save_fig: + if fig_name is None: + fig.savefig(self.output_path + 'Lifetime_pdf_exp_fit_all_years.pdf') + else: + fig.savefig(self.output_path + fig_name) + + if output_plot_data: + return pdf_life, bins_mean, coeff, pdf_life_fit + + + + + +# 8. Growth rates + +class lkf_growthrate: + def __init__(self,lkf): + print("Compute growth rates of LKFs") + + self.output_path = lkf.output_path + self.lkf_lifetime = lkf.lifetime.lkf_lifetime + + lkf_growth = [] + lkf_shrink = [] + + for iyear,lkf_year in enumerate(lkf.lkf_dataset): + growth_year = [np.ones((len(i_num_lkf),))*np.nan for i_num_lkf in lkf_year[1:]] + shrink_year = [np.ones((len(i_num_lkf),))*np.nan for i_num_lkf in lkf_year[1:]] + for iday,day_track in enumerate(lkf.lkf_track_data[iyear]): + # Compute growth rate of all tracked features + for it,itrack in enumerate(day_track): + if len(itrack)>0: + # Compute overlapping area for both features + mhd,overlap,[A_o,B_o] = compute_MHD_segment(lkf.lkf_dataset[iyear][iday][itrack[0].astype('int')][:,:2].T, + lkf.lkf_dataset[iyear][iday+1][itrack[1].astype('int')][:,:2].T, + overlap_thres=1.5,angle_thres=25, + return_overlap=True, + return_overlaping_area=True, + mask_instead=True) + A = lkf.lkf_dataset[iyear][iday][itrack[0].astype('int')][:,lkf.indm0:lkf.indm1+1].copy() + B = lkf.lkf_dataset[iyear][iday+1][itrack[1].astype('int')][:,lkf.indm0:lkf.indm1+1].copy() + + A[A_o,:] = np.nan; B[B_o,:] = np.nan; + + # Determine growth + growth_year[iday][itrack[1].astype('int')] = np.nansum(np.sqrt(np.sum(np.diff(A,axis=0)**2,axis=1))) + if np.isnan(growth_year[iday][itrack[1].astype('int')]): + growth_year[iday][itrack[1].astype('int')] = 0 + + # Determine shrink + shrink_year[iday][itrack[1].astype('int')] = np.nansum(np.sqrt(np.sum(np.diff(B,axis=0)**2,axis=1))) + if np.isnan(shrink_year[iday][itrack[1].astype('int')]): + shrink_year[iday][itrack[1].astype('int')] = 0 + + # Add growth rates of all not tracked features + ind_life1 = (lkf.lifetime.lkf_lifetime[iyear][iday+1]==1) + growth_year[iday][ind_life1] = lkf.length.lkf_length[iyear][iday+1][ind_life1] + shrink_year[iday][ind_life1] = lkf.length.lkf_length[iyear][iday+1][ind_life1] + + lkf_growth.append(growth_year) + lkf_shrink.append(shrink_year) + + + #Save output + self.lkf_growth = np.array(lkf_growth) + self.lkf_shrink = np.array(lkf_shrink) + + + def plot_pdf(self, bins=np.linspace(0,500,50), + output_plot_data=False,gen_fig=True,save_fig=False, + fig_name=None): + #if self.lkf_length is None: + # self.compute_lengths() + + if gen_fig: + style_label = 'seaborn-darkgrid' + with plt.style.context(style_label): + fig,ax = plt.subplots(nrows=1,ncols=1, figsize=(6,5)) + ax.set_xlabel('LKF growth rates [km/day]') + ax.set_ylabel('PDF') + ax.set_yscale('log') + #ax.set_xscale('log') + ax.set_xlim([bins.min(),bins.max()]) + colors=plt.rcParams['axes.prop_cycle'].by_key()['color'] + + plot_list = [self.lkf_growth,self.lkf_shrink] + plot_label = ['positive (grow)', 'negative (shrink)'] + lifetime = self.lkf_lifetime + coeffs = [] + pdfs = [] + binss = [] + pdf_fits = [] + yerrs = [] + + for i,growthi in enumerate(plot_list): + pdf_years_lifee1 = [] + pdf_years_lifel1 = [] + for iyear in range(len(growthi)): + growth_year = np.concatenate(growthi[iyear])/3e3 + lifetime_year = np.concatenate(lifetime[iyear][1:]) + # All LKFs of year + pdf_growth, bins_growth = np.histogram(growth_year[lifetime_year==1], + bins=bins, density=True) + bins_mean = 0.5*(bins_growth[1:]+bins_growth[:-1]) + pdf_years_lifee1.append(pdf_growth) + + pdf_growth, bins_growth = np.histogram(growth_year[lifetime_year!=1], + bins=bins, density=True) + bins_mean = 0.5*(bins_growth[1:]+bins_growth[:-1]) + pdf_years_lifel1.append(pdf_growth) + + pdf_years_lifee1 = np.stack(pdf_years_lifee1) + pdf_years_lifel1 = np.stack(pdf_years_lifel1) + + growth_all = np.concatenate([np.concatenate(growthi[iyear]) for iyear in range(len(growthi))])/3e3 + lifetime_all = np.concatenate([np.concatenate(lifetime[iyear][1:]) for iyear in range(len(lifetime))]) + pdf_growth, bins_growth = np.histogram(growth_all[lifetime_all==1], + bins=bins, density=True) + bins_mean = 0.5*(bins_growth[1:]+bins_growth[:-1]) + if i==0: + ista = np.where(pdf_growth!=0)[0][0] + if np.any(pdf_growth==0): + if np.where(np.where(pdf_growth==0)[0]>ista)[0].size>0: + iend = np.where(pdf_growth==0)[0][np.where(np.where(pdf_growth==0)[0]>ista)[0][0]] + else: + iend = -1 + else: + iend = -1 + coeff_l1 = np.polyfit(bins_mean[ista:iend], + np.log(pdf_growth[ista:iend]),1) + pdf_growth_fit_l1 = np.exp(np.polyval(coeff_l1,bins_mean)) + yerr = [pdf_growth-pdf_years_lifee1.min(axis=0), + pdf_years_lifee1.max(axis=0)-pdf_growth] + + coeffs.append(coeff_l1) + pdfs.append(pdf_growth) + binss.append(bins_mean) + pdf_fits.append(pdf_growth_fit_l1) + yerrs.append(yerr) + + if gen_fig: + ax.errorbar(bins_mean, pdf_growth,yerr=yerr, + color=colors[2],alpha=0.5, + label='Newly formed (%.03f)' %coeff_l1[0], + fmt='.') + ax.plot(bins_mean,pdf_growth_fit_l1,'--',color=colors[2]) + + + pdf_growth, bins_growth = np.histogram(growth_all[lifetime_all!=1], + bins=bins, density=True) + bins_mean = 0.5*(bins_growth[1:]+bins_growth[:-1]) + ista = np.where(pdf_growth!=0)[0][0] + if np.any(pdf_growth==0): + if np.where(np.where(pdf_growth==0)[0]>ista)[0].size>0: + iend = np.where(pdf_growth==0)[0][np.where(np.where(pdf_growth==0)[0]>ista)[0][0]] + else: + iend = -1 + else: + iend = -1 + coeff_e1 = np.polyfit(bins_mean[ista:iend], + np.log(pdf_growth[ista:iend]),1) + pdf_growth_fit_e1 = np.exp(np.polyval(coeff_e1,bins_mean)) + yerr = [pdf_growth-pdf_years_lifel1.min(axis=0), + pdf_years_lifel1.max(axis=0)-pdf_growth] + + coeffs.append(coeff_e1) + pdfs.append(pdf_growth) + binss.append(bins_mean) + pdf_fits.append(pdf_growth_fit_e1) + yerrs.append(yerr) + if gen_fig: + ax.errorbar(bins_mean, pdf_growth,yerr=yerr, + color=colors[i],alpha=0.5, + label=plot_label[i]+' (%.03f)' %coeff_e1[0],fmt='.') + ax.plot(bins_mean,pdf_growth_fit_e1,'--',color=colors[i]) + + ax.legend() + ax.set_ylim([10**np.floor(np.nanmin(np.log10(pdf_growth)[np.isfinite(np.log10(pdf_growth))])), + 10**np.ceil(np.nanmax(np.log10(pdf_growth)))]) + + if save_fig: + if fig_name is None: + fig.savefig(self.output_path + 'growth_rate_pdf.pdf') + else: + fig.savefig(self.output_path + fig_name) + + if output_plot_data: + return pdfs, binss, yerrs ,coeffs, pdf_fits + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +def runmean(data,win): + datam = np.zeros(data.size-win+1) + for i in range(win): + datam += data[i:(data.size+1-win+i)] + return datam/float(win) + + +def power_law_fit(x,y): + coeff = np.polyfit(np.log10(x),np.log10(y),1) + fit = np.power(10,np.polyval(coeff,np.log10(x))) + return coeff,fit + + + + + + + + + + + + + + + + +# # --------------------- Statistics -------------------------------- + +# # if datatype == 'rgps': +# # plot_output_path = '/work/ollie/nhutter/lkf_data/rgps_eps/stats/' +# # elif datatype == 'mitgcm_2km': +# # plot_output_path = '/work/ollie/nhutter/lkf_data/mitgcm_2km/stats/' +# # elif datatype == 'mitgcm_2km_cor_cs': +# # plot_output_path = '/work/ollie/nhutter/lkf_data/mitgcm_2km_cor_cs/stats/' + +# num_time = False + +# length = False + +# density = False + +# curvature = False + +# comp_cell_contrib = False + +# orientation = False +# use_poly_ori = True +# plot_ori_mean = True +# plot_ori_years = False +# plot_ori_months = True +# plot_rad_hist = False +# plot_broehan = True + +# deformation = False + +# intersection = False +# link_interc_def = False +# link_interc_lifetime = False +# link_interc_len = False + +# lifetime = False + +# if curvature: length = True +# if orientation: comp_cell_contrib = True +# if intersection: +# if link_interc_def: +# deformation = True +# if link_interc_len: +# link_interc_lifetime = True +# if link_interc_lifetime: +# intersection = True +# lifetime = True +# if lifetime: +# if not read_tracking: +# lifetime=False +# print "Please activate reading of tracking data first" + + +# force_recompute = False + +# # Meta data statistics + +# def runmean(data,win): +# datam = np.zeros(data.size-win+1) +# for i in range(win): +# datam += data[i:(data.size+1-win+i)] +# return datam/float(win) + + +# if num_time: +# fig,ax = plt.subplots(nrows=1,ncols=1) +# for lkfyear in lkf_meta: +# ax.plot(lkfyear[:,0],lkfyear[:,2],color='0.5', +# linestyle='',marker='.') +# ax.plot(lkfyear[2:-2,0],runmean(lkfyear[:,2].astype('float'),5),'k') +# ax.set_ylabel('Number of detected features') +# fig.savefig(plot_output_path + 'Num_lkfs.pdf') + + +# # Data statistics + +# # 1. Length of LKFs + +# def power_law_fit(x,y): +# coeff = np.polyfit(np.log10(x),np.log10(y),1) +# fit = np.power(10,np.polyval(coeff,np.log10(x))) +# return coeff,fit + +# if length: +# length_file = int_mem_path + 'length_%s_dataset.npy' %datatype +# if os.path.exists(length_file) and not force_recompute: +# print "Open already computed file: %s" %length_file +# lkf_length = np.load(length_file) + +# else: +# print "Compute length of segments" +# lkf_length = [] + +# for lkf_year in lkf_dataset: +# len_year = [] +# for lkf_day in lkf_year: +# len_day = [] +# for ilkf in lkf_day: +# len_day.append(np.sum(np.sqrt(np.diff(ilkf[:,indm0])**2 + +# np.diff(ilkf[:,indm1])**2))) + +# len_year.append(len_day) + +# lkf_length.append(len_year) + +# #Save output +# print "Saving computed file: %s" %length_file +# np.save(length_file,lkf_length) +# lkf_length = np.array(lkf_length) + +# # Compute histograms +# # - one plot with lines for each year +# nbins = 80 +# bins = np.logspace(1.68,3,nbins) +# bins = np.linspace(50,1000,nbins) +# style_label = 'seaborn-darkgrid' +# with plt.style.context(style_label): +# fig,ax = plt.subplots(nrows=1,ncols=1, figsize=(6,5)) +# ax.set_xlabel('LKF length in km') +# ax.set_ylabel('PDF') +# ax.set_yscale('log') +# ax.set_xscale('log') +# ax.set_xlim([50,1000]) +# colors=plt.rcParams['axes.prop_cycle'].by_key()['color'] +# for iyear in range(len(lkf_length)): +# pdf_length, bins_length = np.histogram(np.concatenate(lkf_length[iyear])/1e3, +# bins=bins, density=True) +# bins_mean = 0.5*(bins_length[1:]+bins_length[:-1]) +# if iyear==0: +# ax.plot(bins_mean, pdf_length,color='0.5',alpha=0.5,label="single years") +# else: +# ax.plot(bins_mean, pdf_length,color='0.5',alpha=0.5) + +# pdf_length, bins_length = np.histogram(np.concatenate([np.concatenate(lkf_length[iyear]) for iyear in range(len(lkf_length))])/1e3, +# bins=bins, density=True) +# bins_mean = 0.5*(bins_length[1:]+bins_length[:-1]) +# ax.plot(bins_mean, pdf_length,color=colors[1],alpha=1.0,label="all years") + +# coeff,pl_fit = power_law_fit(bins_mean[bins_mean<=600], pdf_length[bins_mean<=600]) + +# ax.plot(bins_mean[bins_mean<=600], pl_fit,color=colors[1],alpha=1.0,linestyle='--',label="power-law fit\nexponent %.2f" %(-coeff[0])) +# ax.plot(bins_mean[bins_mean>600], +# np.power(10,np.polyval(coeff,np.log10(bins_mean[bins_mean>600]))), +# color=colors[1],alpha=1.0,linestyle=':') + +# ax.legend() + +# fig.savefig(plot_output_path + 'length_pdf.pdf') + + + +# # 2. Density + +# if density: +# density_file = int_mem_path + 'density_%s_dataset.npy' %datatype +# # Mapping grid +# res = 50e3 +# xedg = np.arange(m.xmin,m.xmax,res) +# yedg = np.arange(m.ymin,m.ymax,res) +# y,x = np.meshgrid(yedg[1:],xedg[1:]) + +# if os.path.exists(density_file) and not force_recompute: +# print "Open already computed file: %s" %density_file +# lkf_density = np.load(density_file) + +# else: +# print "Compute density of segments" +# res = 50e3 +# lkf_density = np.zeros((len(lkf_dataset),xedg.size-1,yedg.size-1)) + +# for iyear in range(len(lkf_dataset)): +# lkf_year = np.concatenate(np.concatenate(lkf_dataset[iyear])) +# H, xedges, yedges = np.histogram2d(lkf_year[:,indm0], lkf_year[:,indm1], +# bins=(xedg, yedg)) +# lkf_density[iyear,:,:] = H + +# #Save output +# print "Saving computed file: %s" %density_file +# np.save(density_file,lkf_density) + +# norm_coverage = True +# if norm_coverage: +# if datatype=='rgps': +# cov_dict = np.load(lkf_path + 'coverage_%s.npz' %datatype) +# coverage = cov_dict['coverage'] +# lon_cov = cov_dict['lon']; lat_cov = cov_dict['lat'] +# x_cov,y_cov = m(lon_cov,lat_cov) +# coverage_map = np.zeros((coverage.shape[0],xedg.size-1,yedg.size-1)) +# for iyear in range(coverage.shape[0]): +# coverage_map[iyear,:,:], xedges, yedges = np.histogram2d(x_cov.flatten(), +# y_cov.flatten(), +# bins=(xedg, yedg), +# weights=coverage[iyear,:,:].flatten()) + +# elif datatype == 'mitgcm_2km': +# lon_cov, lat_cov = read_latlon(grid_path) +# mask = mask_arcticbasin(grid_path,read_latlon) +# index_x = np.where(np.sum(mask[1:-1,1:-1],axis=0)>0) +# index_y = np.where(np.sum(mask[1:-1,1:-1],axis=1)>0) +# red_fac = 3 # Take only every red_fac point to reduce array size +# lon_cov = lon_cov[index_y[0][0]-1:index_y[0][-1]+2:red_fac, +# index_x[0][0]-1:index_x[0][-1]+2:red_fac] +# lat_cov = lat_cov[index_y[0][0]-1:index_y[0][-1]+2:red_fac, +# index_x[0][0]-1:index_x[0][-1]+2:red_fac] +# mask = mask[index_y[0][0]-1:index_y[0][-1]+2:red_fac, +# index_x[0][0]-1:index_x[0][-1]+2:red_fac] +# x_cov,y_cov = m(lon_cov[mask],lat_cov[mask]) +# coverage_map = np.zeros((len(years),xedg.size-1,yedg.size-1)) +# for iyear in range(coverage_map.shape[0]): +# coverage_map[iyear,:,:], xedges, yedges = np.histogram2d(x_cov.flatten(), +# y_cov.flatten(), +# bins=(xedg, yedg)) +# coverage_map[iyear,:,:] *= len(lkf_dataset[iyear]) + + + +# for iyear in range(len(lkf_dataset)): +# H = lkf_density[iyear,:,:].copy() + +# # Plot density for year +# fig,ax = plt.subplots(nrows=1,ncols=1) +# if norm_coverage: +# H /= coverage_map[iyear,:,:] +# pcm = m.pcolormesh(x,y,np.ma.masked_where(np.isnan(H) | (H==0),H), +# vmin=0,vmax=0.2) +# m.drawcoastlines() +# cb = plt.colorbar(pcm) +# cb.set_label('Relative LKF frequency') +# ax.set_title('Year: %s' %years[iyear]) + +# # Plot Cummulated density +# #style_label = 'seaborn-darkgrid' +# #with plt.style.context(style_label): +# fig,ax = plt.subplots(nrows=1,ncols=2,figsize=(8.4,6),gridspec_kw={'width_ratios':[12,1]}) +# H = np.sum(lkf_density,axis=0) +# if norm_coverage: +# H /= np.sum(coverage_map,axis=0) +# H = np.ma.masked_where(np.sum(coverage_map,axis=0)<500,H) +# pcm = ax[0].pcolormesh(x,y,np.ma.masked_where(np.isnan(H) | (H==0),H), +# vmin=0,vmax=0.2) +# m.drawcoastlines(ax=ax[0]) +# m.fillcontinents(ax=ax[0],color=(0.9176470588235294, 0.9176470588235294, 0.9490196078431372, 1.0),lake_color='w') +# cb = plt.colorbar(pcm,cax=ax[1]) +# cb.set_label('Relative LKF frequency') +# cb.outline.set_visible(False) +# #ax.set_title('Average over entire data set') +# ax[0].axis('off') + +# fig.savefig(plot_output_path + 'Density_all_paper.pdf') + + + + +# # 3. Curvature + +# if curvature: +# curvature_file = int_mem_path + 'curvature_%s_dataset.npy' %datatype +# if os.path.exists(curvature_file) and not force_recompute: +# print "Open already computed file: %s" %curvature_file +# lkf_curvature = np.load(curvature_file) + +# else: +# print "Compute curvature of segments" +# lkf_curvature = [] + +# for lkf_year in lkf_dataset: +# curv_year = [] +# for lkf_day in lkf_year: +# curv_day = [] +# for ilkf in lkf_day: +# curv_day.append(np.sum(np.sqrt((ilkf[0,indm0]-ilkf[-1,indm0])**2 + +# (ilkf[0,indm1]-ilkf[-1,indm1])**2))) + +# curv_year.append(curv_day) + +# lkf_curvature.append(curv_year) + +# #Save output +# print "Saving computed file: %s" %curvature_file +# np.save(curvature_file,lkf_curvature) +# lkf_curvature = np.array(lkf_curvature) + +# # Plot curvature +# for iyear in range(len(lkf_dataset)): +# fig,ax = plt.subplots(nrows=1,ncols=1) +# ax.plot(np.concatenate(lkf_length[iyear])/1e3, +# np.concatenate(lkf_curvature[iyear])/1e3,'.') +# ax.plot([0,1700],[0,1700],'k--') +# ax.set_xlabel('LKF Length') +# ax.set_ylabel('Distance between LKF endpoints') +# ax.set_title('Winter %s/%s' %(years[iyear][1:3],years[iyear][3:])) + +# fig.savefig(plot_output_path + 'Curvature_year_' + years[iyear]+'.pdf') + + + +# # 4. Compute orientation + + +# # Compute cell that an LKF contributes to + +# # Mapping grid +# res = 200e3 +# xedg = np.arange(m.xmin,m.xmax,res) +# yedg = np.arange(m.ymin,m.ymax,res) +# y,x = np.meshgrid(0.5*(yedg[1:]+yedg[:-1]), +# 0.5*(xedg[1:]+xedg[:-1])) + + +# if comp_cell_contrib: +# cell_contrib_file = int_mem_path + 'cell_contrib_lkf_%s_dataset_%i_poly_%i.npy' %(datatype,res,use_poly_ori) +# if os.path.exists(cell_contrib_file) and not force_recompute: +# print "Open already computed file: %s" %cell_contrib_file +# cell_contrib = np.load(cell_contrib_file) + +# else: +# print "Compute cell contributions of lkfs" +# cell_contrib = [] + +# for lkf_year in lkf_dataset: +# cell_contrib_year = [] +# for lkf_day in lkf_year: +# cell_contrib_day = [] +# for ilkf in lkf_day: +# if use_poly_ori: +# H, xedges, yedges = np.histogram2d(ilkf[:,indp0], ilkf[:,indp1], +# bins=(xedg, yedg)) +# else: +# H, xedges, yedges = np.histogram2d(ilkf[:,indm0], ilkf[:,indm1], +# bins=(xedg, yedg)) +# cell_contrib_day.append(np.where(H.flatten()>0)[0]) + +# cell_contrib_year.append(cell_contrib_day) + +# cell_contrib.append(cell_contrib_year) + +# #Save output +# print "Saving computed file: %s" %cell_contrib_file +# np.save(cell_contrib_file,cell_contrib) +# cell_contrib = np.array(cell_contrib) + + + +# # Compute orientation + +# if orientation: +# orientation_file = int_mem_path + 'orientation_%s_dataset_%i_poly_%i.npy' %(datatype,res,use_poly_ori) +# ori_len_wght_file = int_mem_path + 'ori_len_wght_%s_dataset_%i_poly_%i.npy' %(datatype,res,use_poly_ori) +# if os.path.exists(orientation_file) and os.path.exists(ori_len_wght_file) and not force_recompute: +# print "Open already computed file: %s" %orientation_file +# lkf_orientation = np.load(orientation_file) +# lkf_ori_len_wght = np.load(ori_len_wght_file) + +# else: +# print "Compute orientation of segments" +# lkf_orientation = [] +# lkf_ori_len_wght = [] + +# ori_day_org = np.empty((x.shape),dtype=object) +# for ix in range(xedg.size-1): +# for iy in range(yedg.size-1): +# ori_day_org[ix,iy] = np.array([]) + +# for iyear,lkf_year in enumerate(lkf_dataset): +# ori_year = [] +# ori_len_year = [] +# for iday,lkf_day in enumerate(lkf_year): +# ori_day = ori_day_org.copy() +# ori_len_day = ori_day_org.copy() +# for ilkf,lkf_i in enumerate(lkf_day): +# for i_cell in cell_contrib[iyear][iday][ilkf]: +# # Find part of lkf inside box +# ix,iy = np.unravel_index(i_cell,x.shape) +# if use_poly_ori: +# lkf_i_c = lkf_i[:,indp0:indp0+2][np.all([lkf_i[:,indp0]>=xedg[ix], +# lkf_i[:,indp0]<=xedg[ix+1], +# lkf_i[:,indp1]>=yedg[iy], +# lkf_i[:,indp1]<=yedg[iy+1]], +# axis=0),:] +# else: +# lkf_i_c = lkf_i[:,indm0:indm0+2][np.all([lkf_i[:,indm0]>=xedg[ix], +# lkf_i[:,indm0]<=xedg[ix+1], +# lkf_i[:,indm1]>=yedg[iy], +# lkf_i[:,indm1]<=yedg[iy+1]], +# axis=0),:] + +# # Linear fit & determine angle from linear fit +# if lkf_i_c.size > 2: +# # All cases that are not a line in y-direction +# p_x,p_y = lkf_poly_fit_p(lkf_i_c[:,0],lkf_i_c[:,1], +# 1) # Linear fit +# p = p_y[0]/p_x[0] + +# # Determin angle from linear fit +# if np.isnan(p): +# ang = 90. +# else: +# ang = np.arctan(p)/np.pi*180. + +# ori_day[ix,iy] = np.concatenate([ori_day[ix,iy], +# np.array([ang])]) +# ori_len_day[ix,iy] = np.concatenate([ori_len_day[ix,iy], +# np.array([lkf_i_c.shape[0]])]) + + +# ori_year.append(ori_day) +# ori_len_year.append(ori_len_day) + +# lkf_orientation.append(ori_year) +# lkf_ori_len_wght.append(ori_len_year) + +# #Save output +# print "Saving computed file: %s" %orientation_file +# np.save(orientation_file,lkf_orientation) +# np.save(ori_len_wght_file,lkf_ori_len_wght) +# lkf_orientation = np.array(lkf_orientation) +# lkf_ori_len_wght = np.array(lkf_ori_len_wght) + + + + +# # Define function to plot radial histogram +# def plot_radial_hist(ang,wght,x0,y0,max_rad,nbins=10,ax=plt.gca,color='b'): +# if nbins%2==1: nbins += 1. +# binint=180/float(nbins) +# bins = np.arange(-90+binint/2.,90+binint,binint) +# ang[ang90] = np.abs(ang[ang_diff>90]-180.-ang_m) +# return np.sqrt(np.sum(ang_diff**2*wght)/np.sum(wght)) + +# def chisquare_sig(ang,wght,nchi=int(1e4),nbins=10,pmax=0.01): +# p = np.zeros((nchi,)) + +# # Relative frequency of observed orientations +# binint=180/float(nbins); bins = np.arange(-90,90+binint/2.,binint) +# hist_obs,bins_ang = np.histogram(ang,bins,weights=wght) + +# for i in range(nchi): +# # Create random distribution +# ang_rand = 180.*np.random.random((int(wght.sum()),)) - 90. +# hist_rand,bins_ang = np.histogram(ang_rand,bins) +# # Chi squared test +# chisq, p[i] = scipy.stats.chisquare(hist_rand/float(ang.size), +# hist_obs/float(wght.sum())) + +# p_mean = p.mean() +# return p_mean<=pmax, p_mean + + +# def map_rad_hist(ori,ori_wght,x,y,res,nbins=8,color='b'): +# fig,ax = plt.subplots(nrows=1,ncols=1) +# m.drawcoastlines(ax=ax) +# for ix in range(ori.shape[0]): +# for iy in range(ori.shape[1]): +# plot_radial_hist(ori[ix,iy],ori_wght[ix,iy],x[ix,iy],y[ix,iy], +# res/2,nbins=nbins,ax=ax,color=color) + +# def map_mean_std_ori(ori,ori_wght,x,y,res,color='b', +# do_chi=False,nchi=int(1e4),nbins=10,pmax=0.01, +# color_dens=True): +# fig,ax = plt.subplots(nrows=1,ncols=1,figsize=(8,6)) +# m.drawcoastlines(ax=ax) +# std_bounds = [0,15,30,45,180] +# std_linew = [0.5,1,1.5,2.] +# if color_dens: +# ori_dens = np.zeros(ori.shape) +# for ix in range(ori.shape[0]): +# for iy in range(ori.shape[1]): +# ori_dens[ix,iy] = ori[ix,iy].size +# dens_max = np.ceil(ori_dens.max()/100.)*100. +# dens_min = np.floor(ori_dens.min()/100.)*100. +# cm_dens = plt.get_cmap('plasma',100) +# # plt.figure();m.drawcoastlines(); m.pcolormesh(x,y,ori_dens);plt.colorbar() +# # print dens_max,dens_min + +# for ix in range(ori.shape[0]): +# for iy in range(ori.shape[1]): +# # Compute mean, std and chi squared test +# ang_mean = average_angle(ori[ix,iy],ori_wght[ix,iy]) +# ang_std = std_angle(ori[ix,iy],ori_wght[ix,iy],ang_mean) +# std_class = np.floor(ang_std/15.); +# if std_class>len(std_linew)-1: std_class=len(std_linew)-1 + + +# # Plot direction +# if ~np.isnan(ang_std): +# if color_dens: +# color = cm_dens((ori_dens[ix,iy]-dens_min)/float(dens_max-dens_min)) +# ax.plot([x[ix,iy]-res/2.*np.cos(ang_mean/180.*np.pi), +# x[ix,iy]+res/2.*np.cos(ang_mean/180.*np.pi)], +# [y[ix,iy]-res/2.*np.sin(ang_mean/180.*np.pi), +# y[ix,iy]+res/2.*np.sin(ang_mean/180.*np.pi)], +# color=color,linewidth=std_linew[int(std_class)]) +# if do_chi: +# chi,p = chisquare_sig(ori[ix,iy],ori_wght[ix,iy], +# nchi=nchi,nbins=nbins,pmax=pmax) +# if chi: +# ax.plot(x[ix,iy],y[ix,iy],'k.') + +# if color_dens: +# ax_pos = ax.get_position().get_points() +# mar = (ax_pos[0,0] + 1-(ax_pos[1,0]))/2. +# mar_cbar = 0.005 +# ax.set_position([mar/2.,ax_pos[0,1],ax_pos[1,0]-ax_pos[0,0], +# ax_pos[1,1]-ax_pos[0,1]]) +# cax = fig.add_axes([mar/2.+ax_pos[1,0]-ax_pos[0,0]+mar_cbar, ax_pos[0,1], +# 0.3*mar-2*mar_cbar, ax_pos[1,1]-ax_pos[0,1]]) +# print ax.get_position(), cax.get_position() +# norm = mpl.colors.Normalize(vmin=dens_min, vmax=dens_max) +# cb1 = mpl.colorbar.ColorbarBase(cax, cmap=cm_dens,norm=norm) +# cb1.set_label('Number of LKFs') + +# for i in range(len(std_linew)): +# ax.plot([m.xmin,m.xmin],[m.ymin,m.ymin],linewidth=std_linew[i],color='k', +# label = "%i - %i deg std" %(std_bounds[i],std_bounds[i+1])) + +# ax.legend(loc="upper left",title='STD') + +# return fig + + +# # Plot orientation in radial histograms + +# if orientation: +# ori_org = np.empty((x.shape),dtype=object) +# for ix in range(xedg.size-1): +# for iy in range(yedg.size-1): +# ori_org[ix,iy] = np.array([]) + +# ori = [] +# ori_wght = [] + +# for iyear,lkf_year in enumerate(lkf_dataset): +# ori_month = np.stack([ori_org.copy() for i in range(12)]) +# ori_wght_month = np.stack([ori_org.copy() for i in range(12)]) +# for iday,lkf_day in enumerate(lkf_year): +# imonth = lkf_meta[iyear][iday][0].month - 1 +# for ix in range(ori_month.shape[1]): +# for iy in range(ori_month.shape[2]): +# ori_month[imonth,ix,iy] = np.concatenate([ori_month[imonth,ix,iy], +# lkf_orientation[iyear][iday][ix,iy]]) +# ori_wght_month[imonth,ix,iy] = np.concatenate([ori_wght_month[imonth,ix,iy], +# lkf_ori_len_wght[iyear][iday][ix,iy]]) + +# ori.append(ori_month) +# ori_wght.append(ori_wght_month) + + +# ori_mean = ori_org.copy() +# ori_wght_mean = ori_org.copy() +# ori_year_mean = np.stack([ori_org.copy() for i in range(len(years))]) +# ori_wght_year_mean = np.stack([ori_org.copy() for i in range(len(years))]) +# ori_month_mean = np.stack([ori_org.copy() for i in range(12)]) +# ori_wght_month_mean = np.stack([ori_org.copy() for i in range(12)]) + +# for iyear,lkf_year in enumerate(lkf_dataset): +# for imonth in range(12): +# for ix in range(ori_month_mean.shape[1]): +# for iy in range(ori_month_mean.shape[2]): +# ori_month_mean[imonth,ix,iy] = np.concatenate([ori_month_mean[imonth,ix,iy], +# ori[iyear][imonth,ix,iy]]) +# ori_wght_month_mean[imonth,ix,iy] = np.concatenate([ori_wght_month_mean[imonth,ix,iy], +# ori_wght[iyear][imonth,ix,iy]]) +# ori_year_mean[iyear,ix,iy] = np.concatenate([ori_year_mean[iyear,ix,iy], +# ori[iyear][imonth,ix,iy]]) +# ori_wght_year_mean[iyear,ix,iy] = np.concatenate([ori_wght_year_mean[iyear,ix,iy], +# ori_wght[iyear][imonth,ix,iy]]) + +# ori_mean[ix,iy] = np.concatenate([ori_mean[ix,iy],ori[iyear][imonth,ix,iy]]) +# ori_wght_mean[ix,iy] = np.concatenate([ori_wght_mean[ix,iy], +# ori_wght[iyear][imonth,ix,iy]]) + + + + + +# if plot_ori_mean: +# if plot_rad_hist: +# # Plot radial histogram for mean orientation of data set +# map_rad_hist(ori_mean,ori_wght_mean,x,y,res,nbins=8,color='b') + +# if plot_broehan: +# # Plot mean orientation of data set with std as linewidth +# fig = map_mean_std_ori(ori_mean,ori_wght_mean,x,y,res,color='b', +# do_chi=True,nchi=int(1e4),nbins=20,pmax=0.01, +# color_dens=True) +# fig.savefig(plot_output_path + 'Mean_ori_all_200.pdf') + + + + +# # 5. Deformation rate diagram + +# if deformation: +# deformation_file = int_mem_path + 'deformation_%s_dataset.npy' %datatype +# if os.path.exists(deformation_file) and not force_recompute: +# print "Open already computed file: %s" %deformation_file +# lkf_deformation = np.load(deformation_file) + +# else: +# print "Compute deformation of segments" +# lkf_deformation = [] + +# for lkf_year in lkf_dataset: +# defo_year = [] +# for lkf_day in lkf_year: +# defo_day = [] +# for ilkf in lkf_day: +# defo_day.append([np.mean(ilkf[:,indd0]),np.mean(ilkf[:,indd1])]) + +# defo_year.append(defo_day) + +# lkf_deformation.append(defo_year) + +# #Save output +# print "Saving computed file: %s" %deformation_file +# np.save(deformation_file,lkf_deformation) +# lkf_deformation = np.array(lkf_deformation) + +# deform_all = np.vstack([np.vstack([np.stack([np.array(iseg) for iseg in lkf_deformation[i][j]]) +# for j in range(len(lkf_deformation[i]))]) +# for i in range(len(lkf_dataset))]) + +# shr_lim = [0,0.3] +# div_lim = [-0.15,0.15] +# nbins_shr = 500 +# nbins_div = 500 + +# hist2d,div_edg,shr_edg = np.histogram2d(deform_all[:,0], deform_all[:,1], +# [np.linspace(div_lim[0],div_lim[1],nbins_div), +# np.linspace(shr_lim[0],shr_lim[1],nbins_shr)], +# ) +# hist2d = np.ma.masked_where(hist2d==0,hist2d) + +# fig,ax = plt.subplots(nrows=1,ncols=1,figsize=(8,6)) +# hist_lims = [2,300/4] +# pcm = ax.pcolormesh(shr_edg,div_edg,np.ma.masked_where(hist2d==0,hist2d), +# norm=mpl.colors.LogNorm(vmin=hist_lims[0], vmax=hist_lims[1])) +# ax.plot([shr_edg[0],shr_edg[-1]],[0,0],'k--') +# ax.set_ylabel('Divergence rate [1/day]') +# ax.set_xlabel('Shear rate [1/day]') +# ax.set_aspect('equal') +# cb = fig.colorbar(pcm, ax=ax, extend='both') +# cb.set_label('Number of LKFs') + +# fig.savefig(plot_output_path + 'deformation_shr_div_hist.pdf') + + +# # 6. Intersections angles + +# if intersection: +# pos_type = 'poly' +# if pos_type=='ind': +# indc0 = 0; indc1 = 1; +# if pos_type=='m': +# indc0 = indm0; indc1 = indm1; +# if pos_type=='poly': +# indc0 = indp0; indc1 = indp1; +# num_p = 10 # Number of points on each side of the intersection +# # contribute to the orientation computation + +# interc_file = int_mem_path + 'interc_%s_dataset_num%i_%s.npy' %(datatype, num_p, pos_type) +# interc_par_file = int_mem_path + 'interc_par_%s_dataset_num%i_%s.npy' %(datatype, num_p, pos_type) + +# if os.path.exists(interc_file) and os.path.exists(interc_par_file) and not force_recompute: +# print "Open already computed file: %s" %interc_file +# lkf_interc = np.load(interc_file) +# lkf_interc_par = np.load(interc_par_file) + +# else: +# print "Compute interc of segments" + +# if datatype == 'mitgcm_2km': +# mask = mask_arcticbasin(grid_path,read_latlon) +# index_x = np.where(np.sum(mask[1:-1,1:-1],axis=0)>0) +# index_y = np.where(np.sum(mask[1:-1,1:-1],axis=1)>0) +# red_fac = 3 # Take only every red_fac point to reduce array size + + +# lkf_interc = [] +# lkf_interc_par = [] +# for iyear in range(len(lkf_dataset)): +# intc_ang_year = [] +# intc_par_year = [] +# for iday in range(len(lkf_dataset[iyear])): +# if datatype == 'rgps': +# lkf_map = np.zeros((248,264)) +# elif datatype == 'mitgcm_2km': +# lkf_map = np.zeros((int(np.ceil((index_y[0][-1]+1-index_y[0][0]+1)/3.)), +# int(np.ceil((index_x[0][-1]+1-index_x[0][0]+1)/3.)))) + + +# for iseg, seg_i in enumerate(lkf_dataset[iyear][iday]): +# lkf_map[seg_i[:,0].astype('int'),seg_i[:,1].astype('int')] += iseg + +# intc_ang_day = [] +# intc_par_day = [] + +# # Check for possible intersection partners +# for iseg, seg_i in enumerate(lkf_dataset[iyear][iday]): +# search_ind = np.zeros(lkf_map.shape).astype('bool') +# search_ind[seg_i[:,0].astype('int')+1,seg_i[:,1].astype('int') ] = True +# search_ind[seg_i[:,0].astype('int')-1,seg_i[:,1].astype('int') ] = True +# search_ind[seg_i[:,0].astype('int') ,seg_i[:,1].astype('int')+1] = True +# search_ind[seg_i[:,0].astype('int') ,seg_i[:,1].astype('int')-1] = True +# search_ind[seg_i[:,0].astype('int')+1,seg_i[:,1].astype('int')+1] = True +# search_ind[seg_i[:,0].astype('int')-1,seg_i[:,1].astype('int')-1] = True +# search_ind[seg_i[:,0].astype('int')-1,seg_i[:,1].astype('int')+1] = True +# search_ind[seg_i[:,0].astype('int')+1,seg_i[:,1].astype('int')-1] = True +# search_ind[seg_i[:,0].astype('int') ,seg_i[:,1].astype('int') ] = False + +# intercep_points = np.where(search_ind & (lkf_map!=0)) + +# intercep_partners, intercep_counts = np.unique(lkf_map[intercep_points], +# return_counts=True) + +# for ipar,pari in enumerate(intercep_partners): +# if pari > iseg and pari < len(lkf_dataset[iyear][iday]): +# # Determine one intercetion point for pair +# dis_intercep = np.zeros(intercep_counts[ipar]) +# for iintc in range(intercep_counts[ipar]): +# dis_intercep[iintc] = np.min(np.sqrt((seg_i[:,0] - +# intercep_points[0][lkf_map[intercep_points]==pari][iintc])**2 + +# (seg_i[:,1] - +# intercep_points[1][lkf_map[intercep_points]==pari][iintc])**2)) +# intcp = (intercep_points[0][lkf_map[intercep_points]==pari][np.argmin(dis_intercep)], +# intercep_points[1][lkf_map[intercep_points]==pari][np.argmin(dis_intercep)]) + +# # Determine angle between both pairs +# # # Determine orientation of seg_i +# ind = np.argmin(np.sqrt((seg_i[:,0] - intcp[0])**2 + +# (seg_i[:,1] - intcp[1])**2)) +# ind = np.array([np.max([0,ind-num_p]), +# np.min([seg_i.shape[0],ind+num_p+1])]) +# p_x,p_y = lkf_poly_fit_p(seg_i[ind[0]:ind[1],indc0], +# seg_i[ind[0]:ind[1],indc1],1) # Linear fit +# p = p_y[0]/p_x[0] +# # # Determin angle from linear fit +# if np.isnan(p): +# ang_i = 90. +# else: +# ang_i = np.arctan(p)/np.pi*180. + +# # # Determine orientation of pari +# lkf_par = lkf_dataset[iyear][iday][int(pari)] +# ind = np.argmin(np.sqrt((lkf_par[:,0] - intcp[0])**2 + +# (lkf_par[:,1] - intcp[1])**2)) +# ind = np.array([np.max([0,ind-num_p]), +# np.min([lkf_par.shape[0],ind+num_p+1])]) +# p_x,p_y = lkf_poly_fit_p(lkf_par[ind[0]:ind[1],indc0], +# lkf_par[ind[0]:ind[1],indc1],1) # Linear fit +# p = p_y[0]/p_x[0] +# # # Determin angle from linear fit +# if np.isnan(p): +# ang_ii = 90. +# else: +# ang_ii = np.arctan(p)/np.pi*180. + +# angdiff = np.abs(ang_ii-ang_i) +# if angdiff > 90: angdiff=180-angdiff +# intc_ang_day.append(angdiff) +# intc_par_day.append(np.array([iseg,pari])) + +# intc_ang_year.append(intc_ang_day) +# intc_par_year.append(intc_par_day) +# lkf_interc.append(intc_ang_year) +# lkf_interc_par.append(intc_par_year) + +# #Save output +# print "Saving computed file: %s" %interc_file +# np.save(interc_file,lkf_interc) +# np.save(interc_par_file,lkf_interc_par) + +# lkf_interc = np.array(lkf_interc) +# lkf_interc_par = np.array(lkf_interc_par) + + +# # Compute histograms +# # - one plot with lines for each year +# nbins = 45 +# bins = np.linspace(0,90,nbins) +# fig,ax = plt.subplots(nrows=1,ncols=1) +# ax.set_xlabel('Intersection angle') +# ax.set_ylabel('PDF') +# ax.set_xlim([0,90]) +# for iyear in range(len(lkf_interc)): +# pdf_interc, bins_interc = np.histogram(np.concatenate(lkf_interc[iyear]), +# bins=bins, density=True) +# bins_mean = 0.5*(bins_interc[1:]+bins_interc[:-1]) +# ax.plot(bins_mean, pdf_interc,label=years[iyear],color='0.5',alpha=0.5) + +# pdf_interc, bins_interc = np.histogram(np.concatenate([np.concatenate(lkf_interc[iyear]) for iyear in range(len(lkf_interc))]), +# bins=bins, density=True) +# bins_mean = 0.5*(bins_interc[1:]+bins_interc[:-1]) +# ax.plot(bins_mean, pdf_interc,label=years[iyear],color='k',alpha=1.0) + +# #ax.legend() +# fig.savefig(plot_output_path + 'interc_pdf.pdf') + + + +# # Plot intersection angle statistics depending on deformation rate +# if link_interc_def: +# # Compute mean deformation of intersecting partners +# def_par = []; diff_def_par = []; +# for iyear in range(len(lkf_dataset)): +# def_par_year = []; diff_def_par_year = []; +# for iday in range(len(lkf_dataset[iyear])): +# def_par_day = np.array([np.sqrt(np.sum(np.array(lkf_deformation[iyear][iday])[np.stack(lkf_interc_par[iyear][iday])[:,0].astype('int')]**2,axis=1)), +# np.sqrt(np.sum(np.array(lkf_deformation[iyear][iday])[np.stack(lkf_interc_par[iyear][iday])[:,1].astype('int')]**2,axis=1))]) +# diff_def_par_day = np.abs(np.diff(def_par_day,axis=0)) + +# def_par_year.append(def_par_day) +# diff_def_par_year.append(diff_def_par_day) +# def_par.append(def_par_year) +# diff_def_par.append(diff_def_par_year) + + +# # Plot histograms in different deformation rate classes +# fig,ax = plt.subplots(nrows=1,ncols=3,figsize=(12,4.8)) +# if datatype=='rgps': +# def_class = [0,0.03,0.05,2] +# elif datatype == 'mitgcm_2km': +# def_class = [0,0.05,0.2,10] +# nbins = 45 +# bins = np.linspace(0,90,nbins) +# def_masked_class = [[],[],[]] +# for iax,axi in enumerate(ax): +# axi.set_title('Def. class: %.2f to %.2f [1/day]' %(def_class[iax],def_class[iax+1])) +# axi.set_xlabel('Intersection angle') +# axi.set_ylabel('PDF') +# axi.set_xlim([0,90]) + +# for iyear in range(len(lkf_interc)): +# mask_def = np.all([np.all(np.hstack(def_par[iyear])>=def_class[iax],axis=0), +# np.all(np.hstack(def_par[iyear])0: +# life_year[it+1][itrack[:,1].astype('int')] += life_year[it][itrack[:,0].astype('int')] + +# lkf_lifetime.append(life_year) + +# #Save output +# print "Saving computed file: %s" %lifetime_file +# np.save(lifetime_file,lkf_lifetime) +# lkf_lifetime = np.array(lkf_lifetime) + + +# # Generate Plots +# # One plot for each year +# for iyear in range(len(lkf_lifetime)): +# #fig,ax = plt.subplots(nrows=1,ncols=2) +# fig, ax = plt.subplots(nrows=1, ncols=3, figsize=(10,4), +# gridspec_kw={'width_ratios':[4,4,1]}) + +# # Determine all existing lifetimes +# lt_max = np.max([np.max(ilife) for ilife in lkf_lifetime[iyear]]) +# lt_class = np.arange(lt_max)+1 + + +# # Compute the percentage of each lifetime for each timeslice +# lt_perc = np.zeros((len(lkf_lifetime[iyear]),lt_class.size)) +# lt_abs = np.zeros((len(lkf_lifetime[iyear]),lt_class.size)) +# for it,ilife in enumerate(lkf_lifetime[iyear]): +# for ilt in lt_class: +# lt_perc[it,int(ilt-1)] = np.sum(ilife==ilt)/float(ilife.size) +# lt_abs[it,int(ilt-1)] = np.sum(ilife==ilt) + +# # Make plot +# cmap = plt.get_cmap('viridis') +# col = cmap(np.linspace(0,1,lt_class.size)) + +# for ic in range(lt_class.size): +# ax[0].plot(3*np.arange(len(lkf_lifetime[iyear])), np.array(lt_perc[:,ic])*100, +# color = col[ic]) + +# # Make line plot absolute lifetime numbers +# for ic in range(lt_class.size): +# ax[1].plot(3*np.arange(len(lkf_lifetime[iyear])), np.array(lt_abs[:,ic]), +# color = col[ic]) + +# # Labeling x axis +# xax = [ax[0],ax[1]] +# for iax in xax: iax.set_xlabel('Time [days]') + +# # Plot colorbar +# norm = mpl.colors.Normalize(vmin=1, vmax=lt_max) +# cbar = mpl.colorbar.ColorbarBase(ax[2], cmap=cmap,norm=norm) +# cbar.set_label('Lifetime [days]') + +# # Labeling yaxis +# ax[0].set_ylabel('Fraction [%]') +# ax[1].set_ylabel('Absolute numbers') + +# # Compute histograms +# # - one plot with lines for each year +# style_label = 'seaborn-darkgrid' +# with plt.style.context(style_label): +# fig,ax = plt.subplots(nrows=1,ncols=1, figsize=(6,5)) +# ax.set_xlabel('LKF lifetime') +# ax.set_ylabel('Relative frequency') +# ax.set_yscale('log') +# ax.set_xlim([0,31]) +# colors=plt.rcParams['axes.prop_cycle'].by_key()['color'] +# for iyear in range(len(lkf_length)): +# pdf_life = np.bincount(np.concatenate(lkf_lifetime[iyear]).astype('int')-1) +# bins_mean = np.arange(pdf_life.size)*3+1.5 +# if iyear==0: +# ax.plot(bins_mean, pdf_life/float(np.sum(pdf_life)),'.',color='0.5',alpha=0.5,label="single years") +# else: +# ax.plot(bins_mean, pdf_life/float(np.sum(pdf_life)),'.',color='0.5',alpha=0.5) + +# pdf_life = np.bincount(np.concatenate([np.concatenate(lkf_lifetime[iyear]) for iyear in range(len(lkf_lifetime))]).astype('int')-1) +# bins_mean = np.arange(pdf_life.size)*3+1.5 +# ax.plot(bins_mean, pdf_life/float(np.sum(pdf_life)),'.',color=colors[1],alpha=1.0,label="all years") + +# coeff = np.polyfit(bins_mean, np.log(pdf_life/float(np.sum(pdf_life))),1) +# pdf_life_fit = np.exp(np.polyval(coeff,bins_mean)) +# ax.plot(bins_mean,pdf_life_fit,color=colors[1],alpha=1.0,linestyle='--',label="exponential fit\nexponent %.2f" %(-coeff[0])) + +# #ax.plot(bins_mean[bins_mean<=600], pl_fit,color=colors[1],alpha=1.0,linestyle='--',label="power-law fit\nexponent %.2f" %(-coeff[0])) +# #ax.plot(bins_mean[bins_mean>600], +# # np.power(10,np.polyval(coeff,np.log10(bins_mean[bins_mean>600]))), +# # color=colors[1],alpha=1.0,linestyle=':') + +# ax.legend() + +# fig.savefig(plot_output_path + "Lifetime_distribution_exp_fit.pdf") + + +# # # Lifetime bar plot with atmospheric link +# # +# # # Load atmospheric grid +# # coord = np.load(lkf_path + 'coord_jra55.npz') +# # lat_cut = 52 + 1 +# # lon_atm = coord['lon']; lat_atm = coord['lat'][:lat_cut] +# # lon_atm,lat_atm = np.meshgrid(lon_atm,lat_atm) +# # x_atm,y_atm = m(lon_atm,lat_atm) +# # +# # # Load RGPS grid +# # lon_rgps = np.load(lkf_path+'coverage_rgps.npz')['lon'][:] +# # lat_rgps = np.load(lkf_path+'coverage_rgps.npz')['lat'][:] +# # x_rgps,y_rgps = m(lon_rgps,lat_rgps) +# # +# # # Initialize interpolation routine +# # interp_jra = griddata_fast(x_atm,y_atm,x_rgps,y_rgps) +# # +# # for iyear in range(len(lkf_lifetime)): +# # # Read Coverage of RGPS data +# # coverage = np.load(lkf_path+'coverage_rgps_%s.npz' %years[iyear])['coverage'][:] +# # +# # # Read surface pressure fields +# # year_cov = np.unique([lkf_meta[iyear][0][0].year,lkf_meta[iyear][-1][0].year]) +# # atm_file = '/work/ollie/projects/clidyn/forcing/JRA55_3h/fcst_surf.001_pres.reg_tl319.' +# # year_lkf = [imeta[0].year for imeta in lkf_meta[iyear]] +# # ncfile = Dataset('/work/ollie/projects/clidyn/forcing/JRA55_3h/fcst_surf.001_pres.reg_tl319.2000.nc','r') +# # +# # +# # # Optinal filtering of lifetimes +# # lifetime_filt = np.copy(lkf_lifetime[iyear]) +# # +# # # Determine all existing lifetimes +# # lt_max = np.max([np.max(ilife) for ilife in lifetime_filt]) +# # lt_class = np.arange(lt_max)+1 +# # +# # # Compute the percentage of each lifetime for each timeslice +# # lt_abs = np.zeros((len(lifetime_filt),lt_class.size)) +# # for it,ilife in enumerate(lifetime_filt): +# # for ilt in lt_class: +# # lt_abs[it,int(ilt-1)] = np.sum(ilife==ilt)/float(np.sum(coverage[it,:,:])) +# # +# # # Generate plot +# # fig, ax = plt.subplots(nrows=1, ncols=1)#, figsize=(10,4), +# # # gridspec_kw={'width_ratios':[4,4,1]}) +# # +# # # Make line plot absolute lifetime numbers +# # for ic in range(lt_class.size): +# # ax.plot(3*np.arange(len(lkf_lifetime[iyear])), np.array(lt_abs[:,ic]), +# # color = col[ic]) + + +# # Lifetime bar plot linked to storms + +# # Load ncep strom data set +# storms_path = '/work/ollie/nhutter/ncep_storms/' +# sys.path.append(storms_path) +# from read_ncepstorms import storms + +# storm = storms(storms_path) +# storm.filt_storms() +# storms_all = [] + +# for iyear in range(len(lkf_lifetime)): +# if datatype=='rgps': +# # Read Coverage of RGPS data +# coverage = np.load(lkf_path+'coverage_rgps_%s.npz' %years[iyear])['coverage'][:] + +# # Read surface pressure fields +# storms_year = [] +# for it in range(len(lkf_lifetime[iyear])): +# start_it = lkf_meta[iyear][it][0] +# end_it = lkf_meta[iyear][it][1] +# storms_it = storm.get_storms(start_it,end_it) +# sto_it = [] +# for ist in np.unique(storms_it[:,-1]): +# sto_it.append([ist, storms_it[storms_it[:,-1]==ist,-2].max()]) +# storms_year.append(sto_it) +# storms_all.append(storms_year) + +# # Optinal filtering of lifetimes +# lifetime_filt = np.copy(lkf_lifetime[iyear]) + +# # Determine all existing lifetimes +# lt_max = np.max([np.max(ilife) for ilife in lifetime_filt]) +# lt_class = np.arange(lt_max)+1 + +# # Compute the percentage of each lifetime for each timeslice +# lt_abs = np.zeros((len(lifetime_filt),lt_class.size)) +# for it,ilife in enumerate(lifetime_filt): +# for ilt in lt_class: +# if datatype=='rgps': +# lt_abs[it,int(ilt-1)] = np.sum(ilife==ilt)/float(np.sum(coverage[it,:,:])) +# else: +# lt_abs[it,int(ilt-1)] = np.sum(ilife==ilt) + +# # Generate plot +# fig, ax = plt.subplots(nrows=1, ncols=1)#, figsize=(10,4), +# # gridspec_kw={'width_ratios':[4,4,1]}) + +# axt = ax.twinx() + +# # Make line plot absolute lifetime numbers +# for ic in range(lt_class.size): +# ax.plot(3*np.arange(len(lkf_lifetime[iyear])), np.array(np.cumsum(lt_abs,axis=1)[:,ic]), +# color = col[ic]) + +# # Plot storms +# cmap_storm = plt.get_cmap('inferno') +# storm_stren_max = 25. +# storm_stren_min = 0. +# for it in range(len(lkf_lifetime[iyear])): +# for isto in range(len(storms_year[it])): +# axt.plot(3*it,storms_year[it][isto][1],'.', +# color=cmap_storm((storms_year[it][isto][1]-storm_stren_min)/(storm_stren_max-storm_stren_min))) + + +# # Deformation plot + +# deformation_filt = np.copy(lkf_deformation[iyear]) +# num_class = 25 +# def_class = np.linspace(0,2,num_class+1) +# def_class = np.concatenate([np.array([0]),np.logspace(-2,0.5,num_class)]) +# def_class = np.concatenate([np.logspace(-2,0.,num_class),np.array([np.inf])]) + +# lkf_def_abs = np.zeros((len(deformation_filt),num_class)) + +# for it,idef in enumerate(deformation_filt): +# lkf_def_abs[it,:],bins = np.histogram(np.sqrt(np.sum(np.array(idef)**2,axis=1)),def_class)#,weights=lkf_length[iyear][it]) +# if datatype=='rgps': +# lkf_def_abs[it,:] /= float(np.sum(coverage[it,:,:])) + +# # Generate plot +# style_label = 'seaborn-darkgrid' +# with plt.style.context(style_label): +# fig, ax = plt.subplots(nrows=2, ncols=2, figsize=(10,6), sharex='col',tight_layout=True, +# gridspec_kw={'height_ratios':[1,2],'width_ratios':[25,1]}) +# #fig = plt.figure() +# #ax = fig.add_subplot(111, projection='polar') +# #axt = ax.twinx() +# #rlim = 0.02 + +# # Make bar plot +# bottoms = np.zeros((len(deformation_filt),)) +# wid=1*3 +# cmap_def = plt.get_cmap('inferno') +# col = cmap_def(np.linspace(0,1,num_class)) + +# for ic in range(num_class): +# heights = np.array(lkf_def_abs[:,ic]) +# ax[1,0].bar(lkf_meta[iyear][:,0],#3*np.arange(len(deformation_filt)), +# heights, width = wid, bottom=bottoms, +# color = col[ic]) +# bottoms += heights + + +# # Plot storms +# cmap_storm = plt.get_cmap('YlOrRd')#inferno') +# storm_stren_max = 30. +# storm_stren_min = 0. +# for it in range(len(lkf_deformation[iyear])): +# for isto in range(len(storms_year[it])): +# ax[0,0].plot(lkf_meta[iyear][it,0],#3*it, +# storms_year[it][isto][1],'.', +# color=cmap_storm((storms_year[it][isto][1]-storm_stren_min)/(storm_stren_max-storm_stren_min))) + +# import matplotlib.dates as mdates +# months = mdates.MonthLocator(range(1, 13), bymonthday=1, interval=1) +# monthsFmt = mdates.DateFormatter("%b") + +# ax[0,0].xaxis_date() +# ax[1,0].xaxis_date() + +# ax[1,0].xaxis.set_major_locator(months) +# ax[1,0].xaxis.set_major_formatter(monthsFmt) +# ax[0,0].set_yticklabels([]) + +# ax[0,0].set_ylabel('Storm stength') +# ax[1,0].set_ylabel('No. of LKFs (normalized)') + +# # Plot storm colorbar +# norm_sto = mpl.colors.Normalize(vmin=storm_stren_min, vmax=storm_stren_max) +# norm_sto = mpl.colors.BoundaryNorm(boundaries=np.linspace(storm_stren_min, +# storm_stren_max,13) +# ,ncolors=256) +# cbar_sto = mpl.colorbar.ColorbarBase(ax[0,1], cmap=cmap_storm,norm=norm_sto) +# cbar_sto.set_label('Local Laplacian [mPa/km^2]') +# cbar_sto.outline.set_visible(False) + +# # Plot deformation colorbar +# norm_def = mpl.colors.BoundaryNorm(boundaries=def_class[:-1],ncolors=256) +# cbar_def = mpl.colorbar.ColorbarBase(ax[1,1], cmap=cmap_def,norm=norm_def) +# cbar_def.set_label('Total deformation [1/day]') +# cbar_def.outline.set_visible(False) +# ticks = [] +# for it in cbar_def.ax.yaxis.get_majorticklabels(): +# ticks.append('%.2f' %float(it.get_text())) +# cbar_def.ax.yaxis.set_ticklabels(ticks) + +# fig.savefig(plot_output_path + 'deformation_linked_storms_year_%s.pdf' %years[iyear]) + +# # Link spatial with temporal statistics + +# if intersection: +# # Plot intersection angle statistics depending on deformation rate +# if link_interc_def & link_interc_lifetime: +# # Compute mean deformation of intersecting partners +# def_par = []; diff_def_par = []; +# life_par = [] +# if link_interc_len: +# len_par = [] +# for iyear in range(len(lkf_dataset)): +# def_par_year = []; diff_def_par_year = []; +# life_par_year = [] +# if link_interc_len: +# len_par_year = [] +# for iday in range(len(lkf_dataset[iyear])): +# def_par_day = np.array([np.sqrt(np.sum(np.array(lkf_deformation[iyear][iday])[np.stack(lkf_interc_par[iyear][iday])[:,0].astype('int')]**2,axis=1)), +# np.sqrt(np.sum(np.array(lkf_deformation[iyear][iday])[np.stack(lkf_interc_par[iyear][iday])[:,1].astype('int')]**2,axis=1))]) +# diff_def_par_day = np.abs(np.diff(def_par_day,axis=0)) +# life_par_day = np.array([lkf_lifetime[iyear][iday][np.stack(lkf_interc_par[iyear][iday])[:,0].astype('int')], +# lkf_lifetime[iyear][iday][np.stack(lkf_interc_par[iyear][iday])[:,1].astype('int')]]) +# if link_interc_len: +# len_par_day = np.array([np.array(lkf_length[iyear][iday])[np.stack(lkf_interc_par[iyear][iday])[:,0].astype('int')], +# np.array(lkf_length[iyear][iday])[np.stack(lkf_interc_par[iyear][iday])[:,1].astype('int')]]) + +# def_par_year.append(def_par_day) +# diff_def_par_year.append(diff_def_par_day) +# life_par_year.append(life_par_day) +# if link_interc_len: +# len_par_year.append(len_par_day) +# def_par.append(def_par_year) +# diff_def_par.append(diff_def_par_year) +# life_par.append(life_par_year) +# if link_interc_len: +# len_par.append(len_par_year) + + +# # Plot histograms in different deformation rate classes +# fig,ax = plt.subplots(nrows=1,ncols=3,figsize=(12,4.8)) +# if datatype=='rgps': +# def_class = [0,0.03,0.05,2] +# elif datatype == 'mitgcm_2km': +# def_class = [0,0.05,0.2,10] +# len_thres = 8*12.5e3 +# nbins = 45 +# bins = np.linspace(0,90,nbins) +# def_masked_class = [[],[],[]] +# for iax,axi in enumerate(ax): +# axi.set_title('Def. class: %.2f to %.2f [1/day]' %(def_class[iax],def_class[iax+1])) +# axi.set_xlabel('Intersection angle') +# axi.set_ylabel('PDF') +# axi.set_xlim([0,90]) + +# for iyear in range(len(lkf_interc)): +# mask_def = np.all([np.all(np.hstack(def_par[iyear])>=def_class[iax],axis=0), +# np.all(np.hstack(def_par[iyear])=len_thres,axis=0) +# mask_life = mask_len & mask_life +# pdf_interc, bins_interc = np.histogram(np.concatenate(lkf_interc[iyear])[mask_def & mask_life], +# bins=bins, density=True) +# bins_mean = 0.5*(bins_interc[1:]+bins_interc[:-1]) +# axi.plot(bins_mean, pdf_interc,label=years[iyear],color='0.5',alpha=0.5) +# def_masked_class[iax].append(np.concatenate(lkf_interc[iyear])[mask_def & mask_life]) +# pdf_interc, bins_interc = np.histogram(np.concatenate(def_masked_class[iax]), +# bins=bins, density=True) +# bins_mean = 0.5*(bins_interc[1:]+bins_interc[:-1]) +# axi.plot(bins_mean, pdf_interc,label=years[iyear],color='k',alpha=1.0) +# axi.text(axi.get_xlim()[0]+0.1*axi.get_xlim()[1], +# axi.get_ylim()[0]+0.9*axi.get_ylim()[1], +# 'Tot. num: %i' %np.concatenate(def_masked_class[iax]).size) + +# fig.savefig(plot_output_path + 'interc_pdf_def_class_lifetime.pdf') + +# with plt.style.context(style_label): +# fig,axi = plt.subplots(nrows=1,ncols=1, figsize=(6,5)) +# if datatype=='rgps': +# def_class = [0,0.03,0.00,2] +# elif datatype == 'mitgcm_2km': +# def_class = [0,0.05,0.2,10] +# len_thres = 10*12.5e3 +# nbins = 23 +# bins = np.linspace(0,90,nbins) +# def_masked_class = [[],[],[]] +# iax = 2 + +# #axi.set_title('Def. class: %.2f to %.2f [1/day]' %(def_class[iax],def_class[iax+1])) +# axi.set_xlabel('Intersection angle') +# axi.set_ylabel('PDF') +# axi.set_xlim([0,90]) + +# pdf_year_save = [] + +# for iyear in range(len(lkf_interc)): +# mask_def = np.all([np.all(np.hstack(def_par[iyear])>=def_class[iax],axis=0), +# np.all(np.hstack(def_par[iyear])=len_thres,axis=0) +# mask_life = mask_len & mask_life +# pdf_interc, bins_interc = np.histogram(np.concatenate(lkf_interc[iyear])[mask_def & mask_life], +# bins=bins, density=True) +# pdf_year_save.append(pdf_interc) +# bins_mean = 0.5*(bins_interc[1:]+bins_interc[:-1]) +# if iyear==0: +# axi.plot(bins_mean, pdf_interc,'.',label='single years',color='0.5',alpha=0.5) +# else: +# axi.plot(bins_mean, pdf_interc,'.',color='0.5',alpha=0.5) +# def_masked_class[iax].append(np.concatenate(lkf_interc[iyear])[mask_def & mask_life]) +# pdf_interc, bins_interc = np.histogram(np.concatenate(def_masked_class[iax]), +# bins=bins, density=True) +# bins_mean = 0.5*(bins_interc[1:]+bins_interc[:-1]) +# axi.plot(bins_mean, pdf_interc,label='all years',color=colors[0],alpha=1.0) +# #axi.text(axi.get_xlim()[0]+0.1*axi.get_xlim()[1], +# # axi.get_ylim()[0]+0.9*axi.get_ylim()[1], +# # 'Tot. num: %i' %np.concatenate(def_masked_class[iax]).size) +# axi.plot([],[],' ',label='Tot. num: %i' %np.concatenate(def_masked_class[iax]).size) +# axi.legend() + +# np.savez(int_mem_path + 'Plot_data_interc_len_lifetime.npz',pdf_years=pdf_year_save,pdf_all=pdf_interc) + +# fig.savefig(plot_output_path + 'interc_pdf_def_lifetime0_len%i.pdf' %len_thres) + diff --git a/notebooks/lkf_statistics.ipynb b/notebooks/lkf_statistics.ipynb new file mode 100644 index 0000000..42e406a --- /dev/null +++ b/notebooks/lkf_statistics.ipynb @@ -0,0 +1,68 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "9c865a27-cb7f-4a76-b3f8-7972aadef184", + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2\n", + "\n", + "import xarray as xr\n", + "import os\n", + "from pathlib import Path\n", + "from lkf_tools.dataset import *\n", + "from lkf_tools.stats import *" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "791c731b-1704-46fe-8228-891d3d92eef7", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Error: Cannot choose which pickle to load in []\n" + ] + } + ], + "source": [ + "test = load_lkf_dataset('../data/lkfs/RGPS/w0001/')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "81149309-e490-470f-9b76-8dd313cf3654", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.10.2" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 1ac25eaaae59d7ffa6ec8dd0cc683c209961866f Mon Sep 17 00:00:00 2001 From: Nils Hutter Date: Mon, 3 Jul 2023 09:17:35 +0200 Subject: [PATCH 17/21] Bug fix in true latitude of projection --- lkf_tools/rgps.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lkf_tools/rgps.py b/lkf_tools/rgps.py index 65f8e47..55815ad 100644 --- a/lkf_tools/rgps.py +++ b/lkf_tools/rgps.py @@ -57,7 +57,7 @@ def mSSMI(): as Basemap class ATTENION: for coordinate transform from RGPS coordinate m(0,90) must be added, because in RGPS NP is the origin''' - return Proj(proj='stere',lat_0=90, lat_ts=75, lon_0=-45, ellps='WGS84')#Basemap(projection='stere',lat_ts=70,lat_0=90,lon_0=-45,resolution='l',llcrnrlon=279.26-360,llcrnrlat=33.92,urcrnrlon=102.34,urcrnrlat=31.37,ellps='WGS84') + return Proj(proj='stere',lat_0=90, lat_ts=70, lon_0=-45, ellps='WGS84')#Basemap(projection='stere',lat_ts=70,lat_0=90,lon_0=-45,resolution='l',llcrnrlon=279.26-360,llcrnrlat=33.92,urcrnrlon=102.34,urcrnrlat=31.37,ellps='WGS84') From f2394c3b5e5a1b52cef9b787a27a2c805d4f32e6 Mon Sep 17 00:00:00 2001 From: Nils Hutter Date: Mon, 3 Jul 2023 09:32:08 +0200 Subject: [PATCH 18/21] Added new email address --- lkf_tools/__init__.py | 2 +- lkf_tools/_dir_filter.py | 14 ++++++++++++++ lkf_tools/dataset.py | 2 +- lkf_tools/detection.py | 2 +- lkf_tools/rgps.py | 2 +- lkf_tools/stats.py | 2 +- lkf_tools/tracking.py | 2 +- setup.cfg | 2 +- setup.cfg~ | 2 +- 9 files changed, 22 insertions(+), 8 deletions(-) diff --git a/lkf_tools/__init__.py b/lkf_tools/__init__.py index 351a0b2..55e4f30 100644 --- a/lkf_tools/__init__.py +++ b/lkf_tools/__init__.py @@ -11,5 +11,5 @@ # Package Metadata __version__ = 0.1 __author__ = "Nils Hutter" -__author_email__ = "nhutter@uw.edu" +__author_email__ = "nils.hutter@awi.de" diff --git a/lkf_tools/_dir_filter.py b/lkf_tools/_dir_filter.py index 1b75583..be02357 100644 --- a/lkf_tools/_dir_filter.py +++ b/lkf_tools/_dir_filter.py @@ -1,3 +1,15 @@ +# -*- coding: utf-8 -*- + +""" +Directional filter routines +""" + +# Package Metadata +__version__ = 0.1 +__author__ = "Nils Hutter" +__author_email__ = "nils.hutter@awi.de" + + from scipy import signal import sys import numpy as np @@ -8,6 +20,8 @@ import skimage.morphology + + # ----------------------- Filter routines ------------------------- diff --git a/lkf_tools/dataset.py b/lkf_tools/dataset.py index 7a50cdc..f8df757 100644 --- a/lkf_tools/dataset.py +++ b/lkf_tools/dataset.py @@ -8,7 +8,7 @@ # Package Metadata __version__ = 0.1 __author__ = "Nils Hutter" -__author_email__ = "nhutter@uw.edu" +__author_email__ = "nils.hutter@awi.de" import numpy as np diff --git a/lkf_tools/detection.py b/lkf_tools/detection.py index 992fbdc..320c93c 100644 --- a/lkf_tools/detection.py +++ b/lkf_tools/detection.py @@ -8,7 +8,7 @@ # Package Metadata __version__ = 0.1 __author__ = "Nils Hutter" -__author_email__ = "nhutter@uw.edu" +__author_email__ = "nils.hutter@awi.de" import numpy as np diff --git a/lkf_tools/rgps.py b/lkf_tools/rgps.py index 55815ad..d3a3032 100644 --- a/lkf_tools/rgps.py +++ b/lkf_tools/rgps.py @@ -8,7 +8,7 @@ # Package Metadata __version__ = 0.1 __author__ = "Nils Hutter" -__author_email__ = "nhutter@uw.edu" +__author_email__ = "nils.hutter@awi.de" import numpy as np diff --git a/lkf_tools/stats.py b/lkf_tools/stats.py index 6b00d20..c53021a 100644 --- a/lkf_tools/stats.py +++ b/lkf_tools/stats.py @@ -8,7 +8,7 @@ # Package Metadata __version__ = 0.1 __author__ = "Nils Hutter" -__author_email__ = "nhutter@uw.edu" +__author_email__ = "nils.hutter@awi.de" import numpy as np diff --git a/lkf_tools/tracking.py b/lkf_tools/tracking.py index d0a49ce..febca22 100644 --- a/lkf_tools/tracking.py +++ b/lkf_tools/tracking.py @@ -8,7 +8,7 @@ # Package Metadata __version__ = 0.1 __author__ = "Nils Hutter" -__author_email__ = "nhutter@uw.edu" +__author_email__ = "nils.hutter@awi.de" diff --git a/setup.cfg b/setup.cfg index 190d59a..101c4d2 100644 --- a/setup.cfg +++ b/setup.cfg @@ -49,7 +49,7 @@ classifiers = License :: OSI Approved :: MIT License ## Add your email here -author_email = nhutter@uw.edu +author_email = nils.hutter@awi.de ### make sure to fill in your dependencies! diff --git a/setup.cfg~ b/setup.cfg~ index 5df674b..a0f8459 100644 --- a/setup.cfg~ +++ b/setup.cfg~ @@ -49,7 +49,7 @@ classifiers = License :: OSI Approved :: MIT License ## Add your email here -author_email = nhutter@uw.edu +author_email = nils.hutter@awi.de ### make sure to fill in your dependencies! From e59aecc6fc8a95a9c75458fe8e0b9ff1500b4fe8 Mon Sep 17 00:00:00 2001 From: Nils Hutter Date: Mon, 3 Jul 2023 09:38:50 +0200 Subject: [PATCH 19/21] new verion number --- lkf_tools/__init__.py | 2 +- lkf_tools/_dir_filter.py | 2 +- lkf_tools/dataset.py | 2 +- lkf_tools/detection.py | 2 +- lkf_tools/rgps.py | 2 +- lkf_tools/stats.py | 2 +- lkf_tools/tracking.py | 2 +- 7 files changed, 7 insertions(+), 7 deletions(-) diff --git a/lkf_tools/__init__.py b/lkf_tools/__init__.py index 55e4f30..4d2a2a8 100644 --- a/lkf_tools/__init__.py +++ b/lkf_tools/__init__.py @@ -9,7 +9,7 @@ # Package Metadata -__version__ = 0.1 +__version__ = 2.0 __author__ = "Nils Hutter" __author_email__ = "nils.hutter@awi.de" diff --git a/lkf_tools/_dir_filter.py b/lkf_tools/_dir_filter.py index be02357..772ea9d 100644 --- a/lkf_tools/_dir_filter.py +++ b/lkf_tools/_dir_filter.py @@ -5,7 +5,7 @@ """ # Package Metadata -__version__ = 0.1 +__version__ = 2.0 __author__ = "Nils Hutter" __author_email__ = "nils.hutter@awi.de" diff --git a/lkf_tools/dataset.py b/lkf_tools/dataset.py index f8df757..7f35fc4 100644 --- a/lkf_tools/dataset.py +++ b/lkf_tools/dataset.py @@ -6,7 +6,7 @@ # Package Metadata -__version__ = 0.1 +__version__ = 2.0 __author__ = "Nils Hutter" __author_email__ = "nils.hutter@awi.de" diff --git a/lkf_tools/detection.py b/lkf_tools/detection.py index 320c93c..2727de9 100644 --- a/lkf_tools/detection.py +++ b/lkf_tools/detection.py @@ -6,7 +6,7 @@ # Package Metadata -__version__ = 0.1 +__version__ = 2.0 __author__ = "Nils Hutter" __author_email__ = "nils.hutter@awi.de" diff --git a/lkf_tools/rgps.py b/lkf_tools/rgps.py index d3a3032..da9e175 100644 --- a/lkf_tools/rgps.py +++ b/lkf_tools/rgps.py @@ -6,7 +6,7 @@ # Package Metadata -__version__ = 0.1 +__version__ = 2.0 __author__ = "Nils Hutter" __author_email__ = "nils.hutter@awi.de" diff --git a/lkf_tools/stats.py b/lkf_tools/stats.py index c53021a..8bb80f6 100644 --- a/lkf_tools/stats.py +++ b/lkf_tools/stats.py @@ -6,7 +6,7 @@ # Package Metadata -__version__ = 0.1 +__version__ = 2.0 __author__ = "Nils Hutter" __author_email__ = "nils.hutter@awi.de" diff --git a/lkf_tools/tracking.py b/lkf_tools/tracking.py index febca22..a245799 100644 --- a/lkf_tools/tracking.py +++ b/lkf_tools/tracking.py @@ -6,7 +6,7 @@ # Package Metadata -__version__ = 0.1 +__version__ = 2.0 __author__ = "Nils Hutter" __author_email__ = "nils.hutter@awi.de" From ba7edcea029b2995e18c0ee38c8bf874d605503b Mon Sep 17 00:00:00 2001 From: Nils Hutter Date: Mon, 3 Jul 2023 09:44:29 +0200 Subject: [PATCH 20/21] Remove development files for release --- gen_dataset.py | 102 -- griddata_fast.py | 87 - interp_RGPS_drift.py | 132 -- lkf_detection.py | 1100 ----------- lkf_tools/lkf_stats_tools.py | 3307 ---------------------------------- lkf_tracking.py | 290 --- read_RGPS_lagrangian.py | 240 --- setup.cfg~ | 75 - setup.py~ | 10 - 9 files changed, 5343 deletions(-) delete mode 100644 gen_dataset.py delete mode 100644 griddata_fast.py delete mode 100644 interp_RGPS_drift.py delete mode 100644 lkf_detection.py delete mode 100644 lkf_tools/lkf_stats_tools.py delete mode 100644 lkf_tracking.py delete mode 100644 read_RGPS_lagrangian.py delete mode 100644 setup.cfg~ delete mode 100644 setup.py~ diff --git a/gen_dataset.py b/gen_dataset.py deleted file mode 100644 index cf95e05..0000000 --- a/gen_dataset.py +++ /dev/null @@ -1,102 +0,0 @@ -import numpy as np -import matplotlib.pylab as plt -import os -import sys - -# Self-written functions -from lkf_detection import * -from lkf_tracking import * -from interp_RGPS_drift import interp_RGPS_drift - - -# gen_dataset.py -# -# Python script to generate the LKF data-set from RGPS data -# -# Requirements: - RGPS data: Lagrangian and Eulerian needs to -# be downloaded from Ron Kwok's homepage -# https://rkwok.jpl.nasa.gov/radarsat/index.html -# -# - RGPS data needs to be unzip. The data needs -# to be orgnaized in a seperate directory for -# each winter that are named w9798, w9899, ... -# -# - RGPS_eul_path needs to be set to the path -# eulerian RGPS data -# -# - RGPS_lag_path needs to be set to the path -# lagrangian RGPS data - - - -# ------------- Helper functions --------------------------- - -def lkf_detect_loop(path_RGPS,path_processed,max_kernel=5,min_kernel=1,dog_thres=0,dis_thres=4,ellp_fac=3,angle_thres=35,eps_thres=0.5,lmin=4,latlon=False,return_eps=False): - - files = [i for i in os.listdir(path_RGPS) if i.endswith('.DIV')] - files.sort() - - for i in files: - print i.split('.')[0] - lkf = lkf_detect_rgps(path_RGPS + i.split('.')[0], - max_kernel=max_kernel, min_kernel=min_kernel, - dog_thres=dog_thres,dis_thres=dis_thres,ellp_fac=ellp_fac, - angle_thres=angle_thres,eps_thres=eps_thres,lmin=lmin, - latlon=latlon,return_eps=return_eps) - lkf_T = [j.T for j in lkf] - np.save(path_processed + 'lkf_' + i.split('.')[0] + '.npy', lkf_T) - - - -# ------------- Run part ----------------------------------- - -# Input data -years = ['w0001', 'w0102', 'w0203', 'w0304', - 'w0405', 'w0506', 'w0607', 'w0708', - 'w9697', 'w9798', 'w9899', 'w9900'] - - -RGPS_eul_path = './RGPS_data/eulerian/' -RGPS_lag_path = './RGPS_data/lagrangian/' -drift_path = './RGPS_drift_interp/' - -lkf_path = './lkf_output/' - - -# Iterate over years - -for year_dic in years: - # ---------- (1. Detection) -------------------------------- - - print "Start detection with season: " + year_dic - new_dir = lkf_path + year_dic + '/' - if not os.path.exists(new_dir): - os.mkdir(new_dir) - - lkf_detect_loop(RGPS_eul_path+year_dic+'/', new_dir, - max_kernel=5,min_kernel=1, - dog_thres=15,dis_thres=4, - ellp_fac=2,angle_thres=35, - eps_thres=1.25,lmin=3,latlon=True,return_eps=True) - - - - # ---------- (2. Interpolate drift) -------------------------------- - - print "Start interpolating drift with season: " + year_dic - interp_RGPS_drift(year_dic,RGPS_lag_path,RGPS_eul_path,drift_path) - - - - # ---------- (3. Tracking) -------------------------------- - - print "Start tracking with season: " + year_dic - new_dir = lkf_path + year_dic + '/tracked_pairs/' - if not os.path.exists(new_dir): - os.mkdir(new_dir) - - gen_tracking_dataset_rgps(lkf_path + year_dic + '/', - drift_path + year_dic + '/drift_int_', - new_dir) - - diff --git a/griddata_fast.py b/griddata_fast.py deleted file mode 100644 index c94e416..0000000 --- a/griddata_fast.py +++ /dev/null @@ -1,87 +0,0 @@ -import numpy as np -import scipy.interpolate as spint -import scipy.spatial.qhull as qhull -import itertools - -def interp_weights(x,y,xint,yint): - """ Function to find vertices on x,y grid for - each point on xint,yint and compute corresponding - weight - - Input: x,y Grid of interpolation data - xint,yint Grid to which data is interpolated - - Output: vtx Vertices - wts Weights of each vertice""" - - vtx, wts = interp_weights_nd(np.array([x.flatten(),y.flatten()]).T, - np.array([xint.flatten(),yint.flatten()]).T, - d=2) - return vtx, wts - - -def interp_weights_nd(xyz, uvw, d=2): - # Check for right shape: - if xyz.shape[1]!=d: - xyz = xyz.T - if uvw.shape[1]!=d: - uvw = uvw.T - tri = qhull.Delaunay(xyz) - simplex = tri.find_simplex(uvw) - vertices = np.take(tri.simplices, simplex, axis=0) - temp = np.take(tri.transform, simplex, axis=0) - delta = uvw - temp[:, d] - bary = np.einsum('njk,nk->nj', temp[:, :d, :], delta) - return vertices, np.hstack((bary, 1 - bary.sum(axis=1, keepdims=True))) - - -def interpolate(values, vtx, wts): - return np.einsum('nj,nj->n', np.take(values, vtx), wts) - - - - -class griddata_fast(object): - - def __init__(self,x,y,xint,yint): - """ Interpolation Class: In the initialisation vertices are computed around - each point on the interpolation grid (xint,yint) of neighbouring grid - points (x,y). In the next step weights for interpolation are computed. - """ - # Test for right shapes - if np.any([(x.shape != y.shape),(xint.shape != yint.shape)]): - print "Input grid data does not have corresponding shape" - - self.x = x.flatten() - self.y = y.flatten() - self.xint = xint.flatten() - self.yint = yint.flatten() - self.intshape = xint.shape - - self.vtx, self.wts = interp_weights_nd(np.array([x.flatten(),y.flatten()]).T, - np.array([xint.flatten(),yint.flatten()]).T, - d=2) - - # Filter for points in xint,yint that lay outside of x,y - self.wts[np.where(np.any(self.wts<0,axis=1)),:]=np.zeros((3,))*np.nan - - def interpolate(self,data): - """ Interpolates data field with the same dimension as x,y to xint,yint - """ - return np.einsum('nj,nj->n', np.take(data.flatten(), self.vtx), self.wts).reshape(self.intshape) - - def minimum_distance(self,distance): - """ Discards vertices where the distance between the vertex exceed - a minimum distance """ - delete_list = [] - for iv in range(self.vtx.shape[0]): - # disv = np.sqrt((self.x[self.vtx[iv]]-np.roll(self.x[self.vtx[iv]],1))**2+ - # (self.x[self.vtx[iv]]-np.roll(self.x[self.vtx[iv]],1))**2) - disv = np.sqrt((self.x[self.vtx[iv]]-self.xint[iv])**2+ - (self.y[self.vtx[iv]]-self.yint[iv])**2) - - if np.any(disv > distance): - delete_list.append(iv) - - self.wts[delete_list,:]=np.zeros((3,))*np.nan - diff --git a/interp_RGPS_drift.py b/interp_RGPS_drift.py deleted file mode 100644 index cefd357..0000000 --- a/interp_RGPS_drift.py +++ /dev/null @@ -1,132 +0,0 @@ -""" Script interpolate ice drift velocities to the -regular RGPS grid -""" - -import numpy as np -import read_RGPS_lagrangian as rrl -import calendar -from griddata_fast import griddata_fast -import matplotlib.pylab as plt -import os -import sys - - - - -def interp_RGPS_drift(RGPS_season,RGPS_lag_path,RGPS_eul_path,output_drift_path): - # -------------------- Initialise integration ----------------------------- - - # Set-up RGPS grid - - xg0 = -2300. - xg1 = 1000. - yg0 = -1000. - yg1 = 2100. - - nx = 264 # number of cells in x direction - ny = 248 # number of cells in x direction - - xg = np.linspace(xg0,xg1,nx+1) - xg = 0.5*(xg[1:]+xg[:-1]) - yg = np.linspace(yg0,yg1,ny+1) - yg = 0.5*(yg[1:]+yg[:-1]) - xg,yg = np.meshgrid(xg,yg) - - - # Initialise start year, day and time intervals - - time_int = 3 # in days - - RGPS_dir_lag = RGPS_lag_path + RGPS_season - RGPS_dir_eul = RGPS_eul_path + RGPS_season - - new_dir = output_drift_path + RGPS_season + '/' - if not os.path.exists(new_dir): - os.mkdir(new_dir) - output_path = new_dir - - - # --------------------- Load Lagrangian motion data ----------------------- - - icemotion_org = rrl.get_icemotion_RGPS_season(RGPS_dir_lag) - - filelist = [i for i in os.listdir(RGPS_dir_eul) if i.endswith('.DIV')] - - filelist.sort() - - start_year_season = int(filelist[0][:4]) - - for ifile in filelist: - start_year = int(ifile[:4]) - start_day = int(ifile[4:7]) - end_year = int(ifile[8:12]) - end_day = int(ifile[12:15]) - - print 'Interpolating drift for %i%03i to %i%03i' %(start_year,start_day,end_year,end_day) - - # Loop parameters - iyear = start_year - iday = start_day - - icemotion = icemotion_org.copy() - - # Convert year-day-format to continuing start-year-day format - if calendar.isleap(start_year_season): - icemotion[:,:,1] += (icemotion[:,:,0]-start_year_season)*366 - iday += (iyear-start_year_season)*366 - else: - icemotion[:,:,1] += (icemotion[:,:,0]-start_year_season)*365 - iday += (iyear-start_year_season)*365 - - # Find buoys with valid data before and after the time interval - index = np.any((icemotion[:,:,1] < iday),axis=1) & np.any((icemotion[:,:,1] > iday+time_int),axis=1) - num_val_buoy = np.sum(index) - - # Find position of buoys at start of interval - ## Find last position of buoys before the start of interval - icemotion_copy = icemotion[index,:,:].copy() - icemotion_copy[icemotion_copy[:,:,1]>iday,1] = np.nan - pos_before_start = icemotion_copy[[np.arange(num_val_buoy),np.nanargmax((icemotion_copy[:,:,1]-iday),axis=1)]][:,1:4] - - ## Find first position of buoys after the start of interval - icemotion_copy = icemotion[index,:,:].copy() - icemotion_copy[icemotion_copy[:,:,1]<=iday,1] = np.nan - pos_after_start = icemotion_copy[[np.arange(num_val_buoy),np.nanargmin((icemotion_copy[:,:,1]-iday),axis=1)]][:,1:4] - - - # Find position of buoys at end of interval - ## Find last position of buoys before the end of interval - icemotion_copy = icemotion[index,:,:].copy() - icemotion_copy[icemotion_copy[:,:,1]>iday+time_int,1] = np.nan - pos_before_end = icemotion_copy[[np.arange(num_val_buoy),np.nanargmax((icemotion_copy[:,:,1]-iday-time_int),axis=1)]][:,1:4] - - ## Find first position of buoys after the end of interval - icemotion_copy = icemotion[index,:,:].copy() - icemotion_copy[icemotion_copy[:,:,1]<=iday+time_int,1] = np.nan - pos_after_end = icemotion_copy[[np.arange(num_val_buoy),np.nanargmin((icemotion_copy[:,:,1]-iday-time_int),axis=1)]][:,1:4] - - - # Determine mean drift during for time interval and mean position - pos_start = np.nansum([pos_before_start[:,1:].T,(pos_after_start[:,1:].T-pos_before_start[:,1:].T)/(pos_after_start[:,0]-pos_before_start[:,0])*(iday-pos_before_start[:,0])],axis=0).T - - pos_end = np.nansum([pos_before_end[:,1:].T,(pos_after_end[:,1:].T-pos_before_end[:,1:].T)/(pos_after_end[:,0]-pos_before_end[:,0])*(iday+time_int-pos_before_end[:,0])],axis=0).T - - drift = (pos_end-pos_start)*1e3/time_int/3600./24. - - pos_drift = 0.5 * (pos_start+pos_end) - - - # Interpolation on the regular grid - - interp = griddata_fast(pos_drift[:,0],pos_drift[:,1],xg,yg) - dis_thres = 4*12.5 # Filter threshold for filtering too large vertices - interp.minimum_distance(dis_thres) - - drift_int = np.rollaxis(np.array([interp.interpolate(drift[:,0]),interp.interpolate(drift[:,1])]),0,3) - - - # Save interpolated drift - np.save(output_path + 'drift_int_%i%03i_%i%03i' %(start_year,start_day,end_year,end_day), drift_int) - - - diff --git a/lkf_detection.py b/lkf_detection.py deleted file mode 100644 index 0fcce0d..0000000 --- a/lkf_detection.py +++ /dev/null @@ -1,1100 +0,0 @@ -import numpy as np -import matplotlib.pylab as plt -import os -import sys -from multiprocessing import Pool -import warnings -from mpl_toolkits.basemap import Basemap - - -# Packages for image processing -import scipy.ndimage as ndim -import skimage.morphology - - - - - -# ----------------- 1. Filtering and image processing -------------- -# ------------------- ( described in Section 3.1.1 ) ------------- - - - -def fill_lkf(lkf_segment): - """ Function to fill detected LKFs as only points of direction change are saved - Output: indexes of all pixels containing to the LKF""" - lkf_filled = lkf_segment[:,0].reshape((1,2)) - for i in range(lkf_segment[0,:].size-1): - diffx = lkf_segment[0,i+1]-lkf_segment[0,i] - diffy = lkf_segment[1,i+1]-lkf_segment[1,i] - if (np.abs(diffx)>1) | (np.abs(diffy)>1): - num_add = np.max([np.abs(diffx), np.abs(diffy)]).astype('int') - addx = np.linspace(0,diffx,num_add+1)[1:].reshape((num_add,1)) - addy = np.linspace(0,diffy,num_add+1)[1:].reshape((num_add,1)) - add = np.concatenate([addx,addy],axis=1) - lkf_filled = np.concatenate([lkf_filled,lkf_segment[:,i]+add],axis=1) - else: - lkf_filled = np.concatenate([lkf_filled,lkf_segment[:,i+1].reshape((1,2))],axis=1) - return lkf_filled - - -def hist_eq(array, number_bins=256): - """ Histogram equalization - Input: array and number_bins (range of possible output valus: 0 to number_bins as integers) - Output: histogram equalized version of array - """ - # Compute histogram - bins_center = np.linspace(np.nanmin(array[~np.isnan(array)]),np.nanmax(array[~np.isnan(array)]),number_bins) - bins = np.append(bins_center-np.diff(bins_center)[0],(bins_center+np.diff(bins_center)[0])[-1]) - hist,bins = np.histogram(array[~np.isnan(array)].flatten(), bins) - - # Distribute bins equally to create lookup table - new_values = np.floor((number_bins-1)*np.cumsum(hist/float(array[~np.isnan(array)].size))) - - # Compute equalized array with lookuptable - array_equalized = np.take(new_values,np.digitize(array[~np.isnan(array)].flatten(),bins)-1) - - new_array_equalized = array.flatten() - new_array_equalized[~np.isnan(new_array_equalized)]=array_equalized - - return new_array_equalized.reshape(array.shape) - - -def nan_gaussian_filter(field,kernel,truncate): - """ Version of scipy.ndimage.gaussian_filter that considers - NaNs in the input array by setting them to zero and afterwards - rescale the output array. - Source https://stackoverflow.com/questions/18697532/gaussian-filtering-a-image-with-nan-in-python - - Input: field - field to be filtered - kernel - kernel of gaussian filter - - Output: gaussian_field - filtered field """ - - field_nonnan = field.copy() - mask_nan = np.ones(field.shape) - - field_nonnan[np.isnan(field)] = 0 - mask_nan[np.isnan(field)] = 0 - - field_nonnan_f = ndim.gaussian_filter(field_nonnan,kernel,truncate=truncate) - mask_nan_f = ndim.gaussian_filter(mask_nan,kernel,truncate=truncate) - - gaussian_field = field_nonnan_f/mask_nan_f - - #gaussian_field[np.isnan(field) | np.isnan(gaussian_field)] = 0. - - return gaussian_field - - -def DoG_leads(in_array,max_kern,min_kern): - """DoG: Difference of Gaussian Filters Combination as implemented in Linow & Dierking, 2017""" - - res = np.zeros(in_array.shape) - c = np.arange(min_kern,max_kern+1)*0.5 - - for i in range(0,c.size-1): - - gaus1 = nan_gaussian_filter(in_array,c[i],truncate=2) - gaus2 = nan_gaussian_filter(in_array,c[i+1],truncate=2) - res += (gaus1 - gaus2) - - return res - - - - - - -# --------------------- 2. Segment detection ------------------ -# ---------------- ( described in Section 3.1.2 ) ------------- - - - -def cut_neighbours(img): - """Function that stencils each pixel with neighbouring pixels - Input: image (shape: MxN) - Output: all neighbours (shape: MxNx3x3) - """ - img = np.ascontiguousarray(img) # won't make a copy if not needed - X, Y = img.shape - x, y = (1,1) - overlap = 1 - shape = (((X-2*overlap)//x), ((Y-2*overlap)//y), x+2*overlap, y+2*overlap) # number of patches, patch_shape - strides = img.itemsize*np.array([Y*x, y, Y, 1]) - return np.lib.stride_tricks.as_strided(img, shape=shape, strides=strides) - -def nansum_neighbours(img): - return np.nansum(cut_neighbours(img),axis=(2,3)) - -def nanmean_neighbours(img): - return np.nanmean(cut_neighbours(img),axis=(2,3)) - - - -def detect_segments(lkf_thin,eps_thres=0.1): - """ Function to detect segments of LKFs in thinned binary field - The aim of this function is to split the binary field into - multiple smaller segments, and guarantee that all points in a - segment belong to the same LKF. To do so a threshold for the - deformation rate is establishes, which cuts to line that might - belong to different LKFs. Note that also segments belonging - to one LKF might be detected as multiple single segments in this - step. - - Input: lkf_thin - thinned binary field - eps_thres - deformation difference threshold to break a - segment - - Output: seg_list - list of segments """ - - - # ------------------ Find starting points ----------------------- - seg = np.rollaxis(np.array(np.where((nansum_neighbours(lkf_thin)<=2) & (lkf_thin[1:-1,1:-1]==1))),1) - seg = seg.reshape((seg.shape[0],seg.shape[1],1)) - # seg - array of dimension [N,2,M] with N being the number of segments - # M being an index for the point - - # Array of LKF points that have not been detected so far - nodetect = lkf_thin[1:-1,1:-1].copy() - - # Set all starting points to zero as they are detected already - nodetect[(nansum_neighbours(lkf_thin)==2) & (nodetect==1)] = 0. - nodetect_intm = np.zeros((nodetect.shape[0]+2, - nodetect.shape[1]+2)) - nodetect_intm[1:-1,1:-1] = nodetect.copy() - - # Initialize list of active segments - active_detection = np.arange(seg.shape[0]) - - # Deactivate segments that contain only one or two points - deactivate_segs = np.where(nansum_neighbours(nodetect_intm)[seg[:,0].astype('int'), - seg[:,1].astype('int')].squeeze() != 1) - if deactivate_segs[0].size > 0: - active_detection = np.delete(active_detection, - active_detection[deactivate_segs]) # remove from active list - - - # --------------------- Detection loop -------------------------- - - # Loop parameters - num_nodetect = np.sum(nodetect) # Number of undetected pixels - ind = 0 # Index of detection iteration - max_ind = 500 # Maximum number of iterations - - angle_point_thres = 5 # Number of last point in segment to compute the critical angel to break segments - - while num_nodetect > 0: - #print ind, num_nodetect - # Reduce segment array to active indeces - seg_active = seg[active_detection] - - # Scheme of neighbouring cells - # - # 1 | 2 | 3 - # ----------- ----> y - # 8 | X | 4 | - # ----------- v - # 7 | 6 | 5 x - # - - x = np.empty(seg_active.shape[:1])*np.NaN - y = np.empty(seg_active.shape[:1])*np.NaN - - for ix in [-1,0,1]: - for iy in [-1,0,1]: - indx = (seg_active[:,0,ind] + ix).astype('int') - indy = (seg_active[:,1,ind] + iy).astype('int') - mask = np.all([indx>=0,indx=0, indy1: - # Compute number of valid points per active segment - num_points = np.sum(np.all(~np.isnan(seg_active),axis=1),axis=-1) - # Limit points for the computation of the angle to threshold - num_points[num_points>angle_point_thres] = angle_point_thres - dx = (seg_active[:,:,-1]-seg_active[np.arange(seg_active.shape[0]),:,-num_points])/np.stack([num_points-1,num_points-1],axis=1) - (seg_append-seg_active[:,:,-1]) - new_starts = seg_append[np.sum(np.abs(dx),axis=1)>1] # high angle -> new starting point - #print 'Number of segments broken by angel: %i' %np.sum(np.sum(np.abs(dx),axis=1)>1) - - deactivate_segs_ang = np.where(np.sum(np.abs(dx),axis=1)>1)[0] - - # Mark pixels as detected - mask = np.all(~np.isnan(seg_append),axis=1) # masks all NaN entries in seg_append - nodetect[seg_append[:,0][mask].astype('int'),seg_append[:,1][mask].astype('int')] = 0. - if new_starts.size>0: - nodetect[new_starts[:,0].astype('int'),new_starts[:,1].astype('int')] = 0 - nodetect_intm[1:-1,1:-1] = nodetect.copy() - - # Deactivate pixels with more than one neighbour and activate neighbours - num_neighbours = nansum_neighbours(nodetect_intm) - - deactivate_segs_muln = np.where(num_neighbours[seg_append[:,0][mask].astype('int'), - seg_append[:,1][mask].astype('int')].squeeze() > 1)[0] - deactivate_segs_muln = np.arange(seg_append.shape[0])[mask][deactivate_segs_muln] - - if (deactivate_segs_muln.size > 0): - # Search for possibles neighbours to activate - seg_deact = seg_append[deactivate_segs_muln] - neigh_deactivate = np.vstack([seg_deact + - i*np.hstack([np.ones((seg_deact.shape[0],1)), - np.zeros((seg_deact.shape[0],1))]) + - j*np.hstack([np.zeros((seg_deact.shape[0],1)), - np.ones((seg_deact.shape[0],1))]) - for i in [-1,0,1] for j in [-1,0,1]]) - # new_starts_deact_ind = np.rollaxis(np.array(np.where((num_neighbours[neigh_deactivate[:,0].astype('int'), - # neigh_deactivate[:,1].astype('int')]<=2) & - # (nodetect[neigh_deactivate[:,0].astype('int'), - # neigh_deactivate[:,1].astype('int')]==1))),1).squeeze() - new_starts_deact_ind = np.rollaxis(np.array(np.where((num_neighbours[neigh_deactivate[:,0].astype('int'), - neigh_deactivate[:,1].astype('int')]<=2) & - (nodetect[neigh_deactivate[:,0].astype('int'), - neigh_deactivate[:,1].astype('int')]==1))),1).squeeze() - if new_starts_deact_ind.size>0: - new_starts = np.append(new_starts,neigh_deactivate[new_starts_deact_ind].reshape((new_starts_deact_ind.size,2)),axis=0) - nodetect[new_starts[:,0].astype('int'),new_starts[:,1].astype('int')] = 0 - nodetect_intm[1:-1,1:-1] = nodetect.copy() - # if ind<5: - # print(new_starts.shape) - # print(new_starts) - # print(deactivate_segs_muln.shape) - # print(deactivate_segs_muln) - - - - # Test for segements that are on the same point - nan_mask_segs = np.all(~np.isnan(seg_append),axis=-1) - - ravel_seg_append = np.ravel_multi_index((seg_append[nan_mask_segs,0].astype('int'), - seg_append[nan_mask_segs,1].astype('int')), - lkf_thin[1:-1,1:-1].shape) - seg_head_unique, seg_head_counts = np.unique(ravel_seg_append,return_counts=True) - deactivate_segs_samehead = np.empty((0,)) - seg_head_continue = seg_head_unique[seg_head_counts==1] - - if np.any(seg_head_counts>1): - deactivate_segs_samehead = np.hstack([np.where(ravel_seg_append==ihead) - for ihead in seg_head_unique[seg_head_counts>1]]).squeeze() - new_starts = np.concatenate([new_starts,np.vstack(np.unravel_index(seg_head_unique[seg_head_counts>1], - lkf_thin[1:-1,1:-1].shape)).T]) - #print(deactivate_segs_samehead) - - - # Remove sharp turns from seg_append (here because search for new starting points - # needs to run beforehand) - if seg.shape[-1]>1: - seg_append[np.sum(np.abs(dx),axis=1)>1,:] = np.NaN # Remove from appending list - - - - # Plot intermediate results - if ind<5:#ind%5==0: - do_plot = False - else: - do_plot = False - - if do_plot: - fig,ax = plt.subplots(1,2,sharex=True,sharey=True,figsize=(9,5),tight_layout=True) - ax[0].pcolormesh(num_neighbours.copy()) - for i in range(seg.shape[0]): - if np.any(active_detection==i): - col = 'r' - else: - col = 'g' - ax[0].plot(seg[i,1,:]+0.5,seg[i,0,:]+0.5,col) - ax[0].text(seg[i,1,~np.isnan(seg[i,1,:])][-1]+0.5,seg[i,0,~np.isnan(seg[i,1,:])][-1]+0.5,'%i' %i,color='w') - for i in range(neigh_deactivate.shape[0]): - ax[0].plot(neigh_deactivate[i,1]+0.5,neigh_deactivate[i,0]+0.5,'m.') - for i in range(new_starts.shape[0]): - ax[0].plot(new_starts[i,1]+0.5,new_starts[i,0]+0.5,'c.') - for i in range(active_detection.size): - if np.any(deactivate_segs_end.copy()==i): - mark = 'x' - elif np.any(deactivate_segs_ang.copy()==i): - mark = 'v' - elif np.any(deactivate_segs_muln.copy()==i): - mark = 's' - elif np.any(deactivate_segs_samehead.copy()==i): - mark = '>' - else: - mark = '.' - if ~np.isnan(seg_append[i,1]): - ax[0].plot(seg_append[i,1]+0.5,seg_append[i,0]+0.5,color='r',marker=mark) - else: - ax[0].plot(seg[active_detection[i],1,-1]+0.5,seg[active_detection[i],0,-1]+0.5,color='r',marker=mark) - - - #plt.figure() - ax[1].pcolormesh(nodetect.copy()+lkf_thin[1:-1,1:-1]) - for i in range(seg.shape[0]): - if np.any(active_detection==i): - col = 'r' - else: - col = 'g' - ax[1].plot(seg[i,1,:]+0.5,seg[i,0,:]+0.5,col) - ax[1].text(seg[i,1,~np.isnan(seg[i,1,:])][-1]+0.5,seg[i,0,~np.isnan(seg[i,1,:])][-1]+0.5,'%i' %i,color='w') - for i in range(active_detection.size): - if np.any(deactivate_segs_end.copy()==i): - mark = 'x' - elif np.any(deactivate_segs_ang.copy()==i): - mark = 'v' - elif np.any(deactivate_segs_muln.copy()==i): - mark = 's' - elif np.any(deactivate_segs_samehead.copy()==i): - mark = 'd' - else: - mark = '.' - if ~np.isnan(seg_append[i,1]): - ax[1].plot(seg_append[i,1]+0.5,seg_append[i,0]+0.5,color='r',marker=mark) - else: - ax[1].plot(seg[active_detection[i],1,-1]+0.5,seg[active_detection[i],0,-1]+0.5,color='r',marker=mark) - - ax[0].set_xlim([380,395]) - ax[0].set_ylim([180,197]) - for iax in ax: iax.set_aspect('equal') - - - - - # Test for multiple times same start - new_starts_unique, new_starts_counts = np.unique(np.ravel_multi_index((new_starts[:,0].astype('int'), - new_starts[:,1].astype('int')), - lkf_thin[1:-1,1:-1].shape), - return_counts=True) - - new_starts_unique = np.array([i_seg_start for i_seg_start in new_starts_unique if not np.any(seg_head_unique==i_seg_start)],dtype='int') - - # if np.any(new_starts_counts > 1): - # # print 'Warning: %i starting points arises maximum %i-times' %(np.sum(new_starts_counts>1), - # # np.max(new_starts_counts)) - # new_starts = np.vstack(np.unravel_index(new_starts_unique,lkf_thin[1:-1,1:-1].shape)).T - new_starts = np.vstack(np.unravel_index(new_starts_unique,lkf_thin[1:-1,1:-1].shape)).T - - # Append new positions of this detection step - num_new_starts = new_starts.shape[0] - # Initialize list of new segment elements - seg_append_time = np.empty((seg.shape[0],2))*np.NaN - seg_append_time[active_detection] = seg_append - seg_append_time = np.append(seg_append_time,new_starts,axis=0) - seg_old_shape = seg.shape[0] - # Fill up seg with NaNs for new starts - seg = np.append(seg,np.empty((num_new_starts,2,seg.shape[-1]))*np.NaN,axis=0) - # Append seg with new detected pixels - seg = np.append(seg,seg_append_time.reshape(seg_append_time.shape[0],2,1),axis=-1) - - # Deactivate segments if finished - active_detection_old = active_detection.copy() - if np.any([(deactivate_segs_muln.size > 0), - (deactivate_segs_ang.size > 0), - (deactivate_segs_end.size > 0), - (deactivate_segs_samehead.size > 0)]): - deactivate_segs = np.unique(np.append(deactivate_segs_muln, - np.append(deactivate_segs_ang,deactivate_segs_end))) - deactivate_segs = np.unique(np.hstack([deactivate_segs_muln,deactivate_segs_ang, - deactivate_segs_end,deactivate_segs_samehead])) - active_detection = np.delete(active_detection,deactivate_segs) # remove from active list - - # Activate new segments that started in this iteration - active_detection = np.append(active_detection,np.arange(seg_old_shape, seg_old_shape + num_new_starts)) - - # Compute number of undetected points and update ind - num_nodetect = np.sum(nodetect) - ind += 1 - - if ind > max_ind: - break - if active_detection.size == 0: - fac_starts = 100 - new_starts = np.append(np.rollaxis(np.array(np.where((nansum_neighbours(nodetect_intm)==3) & (nodetect==1))),1)[::fac_starts,:], - np.rollaxis(np.array(np.where((nansum_neighbours(nodetect_intm)==3) & (nodetect==1))),1)[1::fac_starts,:],axis=0) - - # Mark new starts as detected - if new_starts.size>0: - nodetect[new_starts[:,0].astype('int'),new_starts[:,1].astype('int')] = 0 - nodetect_intm[1:-1,1:-1] = nodetect.copy() - - # Add new generated end points as well - new_starts = np.append(new_starts,np.rollaxis(np.array(np.where((nansum_neighbours(nodetect_intm)<=2) & (nodetect==1))),1),axis=0) - - # Mark new starts as detected - if new_starts.size>0: - nodetect[new_starts[:,0].astype('int'),new_starts[:,1].astype('int')] = 0 - nodetect_intm[1:-1,1:-1] = nodetect.copy() - - # Test for multiple times same start - new_starts_unique, new_starts_counts = np.unique(np.ravel_multi_index((new_starts[:,0].astype('int'), - new_starts[:,1].astype('int')), - lkf_thin[1:-1,1:-1].shape), - return_counts=True) - if np.any(new_starts_counts > 1): - print ('Warning: %i starting points arises maximum %i-times' %(np.sum(new_starts_counts>1), - np.max(new_starts_counts))) - - # Append new positions of this detection step - num_new_starts = new_starts.shape[0] - seg_old_shape = seg.shape[0] - # Fill up seg with NaNs for new starts - seg = np.append(seg,np.empty((num_new_starts,2,seg.shape[-1]))*np.NaN,axis=0) - # Fill in new start values - seg[seg_old_shape:,:,-1] = new_starts - - # Activate new segments that started in this iteration - active_detection = np.append(active_detection,np.arange(seg_old_shape, seg_old_shape + num_new_starts)) - - - - if active_detection.size == 0: - break - - return seg - - - - - - - - - - -# ----------------- 3. Reconnection of segments---------------- -# ---------------- ( described in Section 3.1.3 ) ------------- - - - - -def elliptical_distance(seg_I,seg_II,ellp_fac=1,dis_thres=np.inf): - """ Function to compute the elliptical distance between two - segments, where the distance within the segment direction is - weighted by 1 and the direction perpendicular to the direction - by the factor 3. The weighted distance is computed from both - segments and averaged. If the first computation already exceeds - an threhold the second computation is skipped for efficiency. - - Input: seg_I - array with start and end coordinates of seg I - (rows dimension, column start-end) - seg_II - array with start and end coordinates of seg II - ellp_fac - weighting factor for ellipse - dis_thres - distance threshold to stop computation - - Output: dis - elliptical distance""" - - # Determine basis vectors along seg_I direction - e1 = (seg_I[:,0]-seg_I[:,1]) - e1 = (e1/np.sqrt(np.sum(e1**2))).reshape((2,1)) # Normalize basis vector - - e2 = np.dot(np.array([[0,-1],[1,0]]),e1) - - # Project connection vetor on basis vectors - coeff = np.linalg.solve(np.hstack([e1,e2]),(seg_II[:,0] - seg_I[:,0])) - - if coeff[0]<0: coeff[0] = np.inf - - # Compute weighted distance - d1 = np.sqrt(np.sum(coeff**2 * np.array([1,ellp_fac]))) - - if d1 <= dis_thres: - # Determine basis vectors along seg_II direction - e1 = (seg_II[:,0]-seg_II[:,1]) - e1 = (e1/np.sqrt(np.sum(e1**2))).reshape((2,1)) # Normalize basis vector - - e2 = np.dot(np.array([[0,-1],[1,0]]),e1) - - # Project connection vetor on basis vectors - coeff = np.linalg.solve(np.hstack([e1,e2]),(seg_I[:,0] - seg_II[:,0])) - - # Compute weighted distance - d2 = np.sqrt(np.sum(coeff**2 * np.array([1,ellp_fac]))) - - dis = 0.5*(d1+d2) - else: - dis = np.NaN - - return dis - - -def angle_segs(seg_I,seg_II): - """ Function to compute the angle between two segments. - - Input: seg_I - array with start and end coordinates of seg I - (rows dimension, column start-end) - seg_II - array with start and end coordinates of seg II - - Output: angle - angle between segments""" - - # Determine directions of segments - e1 = (seg_I[:,0]-seg_I[:,1]) - e1 = (e1/np.sqrt(np.sum(e1**2))) # Normalize basis vector - - f1 = (seg_II[:,0]-seg_II[:,1]) - f1 = (f1/np.sqrt(np.sum(f1**2))) # Normalize basis vector - - # Determine angle between both directions - angle = np.dot(e1,-f1) - angle = np.arccos(angle)/np.pi*180 - - return angle - - -def find_pos_connect(seg_I,segs,dis_thres): - """ Function to determine the possible connection segments - and to compute both corresponding starting point. The latter - information is given as arrays of the orientation where 1 means - that the current orientation has the starting point in the - first column and -1 that the starting point is in the second - column. These orientation can be used by indexing to flip the - the array to the right order [:,::i] where i=1,-1 - - Input: seg_I - array coordinates of seg I - (rows dimension, column start-end) - segs - array with arrays containing coordinates of other - segments - (number segments, rows dimension, column start-end) - - Output: ori_segI - required orientation of seg_I - ori_segs - required orientation of segs - mask - mask of all segments in segs that fulfill distance - criteria""" - - # Compute displacement from starting and end points in segs from start in seg_I - disp_start = np.rollaxis(np.rollaxis(segs,-1,start=1)-seg_I[:,0],-1,start=1) - - # Compute displacement from starting and end points in segs from end in seg_I - disp_end = np.rollaxis(np.rollaxis(segs,-1,start=1)-seg_I[:,1],-1,start=1) - - # # Filter for larger displacements than dis_thres - # mask = np.all([np.all(np.any(np.abs(disp_start)>dis_thres,axis=1),axis=1), - # np.all(np.any(np.abs(disp_end )>dis_thres,axis=1),axis=1)],axis=0) - # disp_start[mask,:,:] = np.NaN - # disp_end[mask,:,:] = np.NaN - - # Compute distance only for filtered displacements - dis = np.hstack([np.sqrt(np.sum(disp_start**2,axis=1)).reshape((segs.shape[0],1,2)), - np.sqrt(np.sum(disp_end**2, axis=1)).reshape((segs.shape[0],1,2))]) - - # Give out combination of orientation of segments with starting point being first column - ori_segI = np.argmin(dis,axis=1) - ori_segs = np.argmin(np.min(dis,axis=1),axis=1) - ori_segI = ori_segI[np.arange(ori_segs.size),ori_segs] - - # Filter for larger displacements than dis_thres - mask = np.all(np.abs(dis)>dis_thres,axis=(1,2)) - - return ori_segI, ori_segs, ~mask - - - -def compute_mn_eps(eps,seg): - eps_mn = np.zeros(len(seg)) - - for i in range(len(seg)): - eps_mn[i] = np.mean(eps[1:-1,1:-1][seg[i][0,:],seg[i][1,:]]) - - return eps_mn - - - -def compute_prob(seg_I,segs,eps_segI,eps_segs,dis_thres,angle_thres,eps_thres,ellp_fac=1): - """ Function to compute the probabilty for each segment in segs - to be a succession of seg_I given the critical parameters for - distance dis_thres, the angle angle_thres, and the deformation - rate eps_thres. - - Input: seg_I - array coordinates of seg I - (rows dimension, column start-end) - segs - array with arrays containing coordinates of other - segments - (number segments, rows dimension, column start-end) - eps_segI - mean deformation rate of seg_I - eps_seg - mean deformation rate of segs - ellp_fac - weighting factor for ellipse - dis_thres - distance threshold to stop computation - eps_thres - threshold difference in deformation rate - - Output: prob - probablility metric of segs, in second column - orientation information of segI and in third column - orientation information of the corresponding segment - from segs is stored in case of reconnection""" - - # 1. Check for similarity of deformation rates - p_eps = np.abs(eps_segs-eps_segI)/eps_thres - p_eps[p_eps > 1] = np.nan - - mask_eps = ~np.isnan(p_eps) - segs_i = segs[mask_eps] - - - # 2. Find corresponding starting and end points and first instance of - # distance thresholding - ori_segI, ori_segs, mask_dis_i = find_pos_connect(seg_I,segs_i,dis_thres) - - segs_i = segs_i[mask_dis_i] - ori_segI = ori_segI[mask_dis_i] - ori_segs = ori_segs[mask_dis_i] - - - # 3. Check angle between segments and angle thresholding - p_ang = np.zeros(p_eps.shape) * np.nan - mask_ang = np.zeros(segs_i.shape[0]).astype('bool') - - for i in range(segs_i.shape[0]): - # Resort arrays if necessary to have proper orientation with starting - # points - if ori_segI[i] == 1: - seg_I_i = seg_I[:,::-1].copy() - else: - seg_I_i = seg_I.copy() - if ori_segs[i] == 1: - seg_II_i = segs_i[i][:,::-1].copy() - else: - seg_II_i = segs_i[i].copy() - - # Determine angle - p_ang[np.arange(p_ang.size)[mask_eps][mask_dis_i][i]] = angle_segs(seg_I_i,seg_II_i)/angle_thres - mask_ang[i] = (p_ang[mask_eps][mask_dis_i][i]<=1) - - p_ang[p_ang>1] = np.nan - - segs_i = segs_i[mask_ang] - ori_segI = ori_segI[mask_ang] - ori_segs = ori_segs[mask_ang] - - - - # 4. Compute elliptical distance and final distance thresholding - p_dis = np.zeros(p_eps.shape) * np.nan - - for i in range(segs_i.shape[0]): - # Resort arrays if necessary to have proper orientation with starting - # points - if ori_segI[i] == 1: - seg_I_i = seg_I[:,::-1].copy() - else: - seg_I_i = seg_I.copy() - if ori_segs[i] == 1: - seg_II_i = segs_i[i][:,::-1].copy() - else: - seg_II_i = segs_i[i].copy() - - # Determine distance - p_dis[np.arange(p_dis.size)[mask_eps][mask_dis_i][mask_ang][i]] = elliptical_distance(seg_I_i,seg_II_i,ellp_fac=ellp_fac,dis_thres=dis_thres)/dis_thres - - p_dis[p_dis>1] = np.nan - - - # 5. Compute joint probability as sum of all three components - - prob = np.sqrt(p_eps**2 + p_ang**2 + p_dis**2) - - - # 6. Save orientation of the corresponding connection partners - ori_segI_all = np.zeros(prob.size) * np.nan - ori_segs_all = np.zeros(prob.size) * np.nan - ori_segI_all[np.arange(p_dis.size)[mask_eps][mask_dis_i][mask_ang]] = ori_segI - ori_segs_all[np.arange(p_dis.size)[mask_eps][mask_dis_i][mask_ang]] = ori_segs - - return np.rollaxis(np.stack([prob,ori_segI_all,ori_segs_all]),1) - - -def init_prob_matrix(segs,eps_segs,dis_thres,angle_thres,eps_thres,ellp_fac=1): - """ Function to initialize the probability matrix given the - probability of all possible combinations of segments to belong - to the same deformation feature. The probabilty matrix is a - upper triangular matrix with empty diagonal. - - Input: segs - array with arrays containing coordinates of - segments - (number segments, rows dimension, column start-end) - eps_seg - mean deformation rate of segs - ellp_fac - weighting factor for ellipse - dis_thres - distance threshold to stop computation - eps_thres - threshold difference in deformation rate - - Output: prob_ma - probablility matrics of segs""" - - - # 1. Initialize empty probability matrix - num_segs = segs.shape[0] - prob_ma = np.zeros((num_segs,num_segs,3)) * np.nan - - # 2. Loop over all segments an fill - for i_s in range(num_segs-1): - prob_ma[i_s,i_s+1:,:] = compute_prob(segs[i_s],segs[i_s+1:],eps_segs[i_s],eps_segs[i_s+1:],dis_thres,angle_thres,eps_thres,ellp_fac=ellp_fac) - - return prob_ma - -def update_segs(ind_connect,ori_connect,seg,segs,eps_segs,num_points_segs): - """ Function to update the list of segment seg, array of start - and end points segs, and the array of mean deformation rates. - - Input: ind_connect - index that were connected in this step - ori_connect - orientation of segmeents that are reconnected - ( 0 means orientation as given in segs is - right, if 1 segment needs to be reversed) - seg - list of segments - segs - array with arrays containing coordinates - of segments - (number segments, rows dimension, column start-end) - eps_segs - mean deformation rate of segs - num_points_segs - array of the number of points of all - segments - - Output: seg - updated list of segments - segs - updated array with arrays containing coordinates - of segments - (number segments, rows dimension, column start-end) - eps_segs - updated mean deformation rate of segs_up - num_points_segs - updated array of the number of points - of all segments""" - - # 1. Update list of segments seg - # - Update smaller index element - seg[ind_connect[0]] = np.append(seg[ind_connect[0]][:,::int(2*ori_connect[0]-1)], - seg[ind_connect[1]][:,::int(-2*ori_connect[1]+1)], - axis=1) - # - Remove larger index element - seg.pop(ind_connect[1]); - - - # 2. Update array of end and starting points - # - Update smaller index element - segs[ind_connect[0]] = np.stack([segs[ind_connect[0]][:,::int(2*ori_connect[0]-1)][:,0], - segs[ind_connect[1]][:,::int(-2*ori_connect[1]+1)][:,-1]]).T - # - Remove larger index element - segs = np.delete(segs,(ind_connect[1]),axis=0) - - - # 3. Update array of mean deformation rates - # - Update smaller index element - eps_segs[ind_connect[0]] = (((eps_segs[ind_connect[0]]*num_points_segs[ind_connect[0]]) + - (eps_segs[ind_connect[1]]*num_points_segs[ind_connect[1]]))/ - (num_points_segs[ind_connect[0]]+num_points_segs[ind_connect[1]])) - # - Remove larger index element - eps_segs = np.delete(eps_segs,(ind_connect[1]),axis=0) - - - # 4. Update array of number of points of all segments - # - Update smaller index element - num_points_segs[ind_connect[0]] = (num_points_segs[ind_connect[0]] + - num_points_segs[ind_connect[1]]) - # - Remove larger index element - num_points_segs = np.delete(num_points_segs,(ind_connect[1]),axis=0) - - - return seg, segs, eps_segs, num_points_segs - - -def update_prob_matrix(prob_ma,ind_connect,segs_up,eps_segs_up,dis_thres,angle_thres,eps_thres,ellp_fac=1): - """ Function to update the probability matrix given the - probability of all possible combinations of segments to belong - to the same deformation feature. Only the rows and columns - corresponding to indeces ind_connect are updated as the others - remain unchanged. The column and row corresponding to the larger - index ind_connect[1] are removed from the matrix and the others - are recalculated. As the orientation and deformation rate of the - newly reconnected segment besides its length might have changed - a new computation of the entire row is required instead of only - updating all non NaN values. - - Input: prob_ma - probablility matrics of segs - ind_connect - index that were connected in this step - segs_up - updated array with arrays containing coordinates - of segments - (number segments, rows dimension, column start-end) - eps_seg_up - updated mean deformation rate of segs_up - ellp_fac - weighting factor for ellipse - dis_thres - distance threshold to stop computation - eps_thres - threshold difference in deformation rate - - Output: prob_ma_up - probablility matrics of segs""" - - # 1. Remove column and row corresponding to the larger index - prob_ma = np.delete(np.delete(prob_ma,ind_connect[1],axis=0), - ind_connect[1],axis=1) - - # 2. Reevaluate the probabilty in the row for the lower index - i_s = ind_connect[0] - prob_ma[i_s,i_s+1:,:] = compute_prob(segs_up[i_s],segs_up[i_s+1:],eps_segs_up[i_s],eps_segs_up[i_s+1:],dis_thres,angle_thres,eps_thres,ellp_fac=ellp_fac) - prob_ma[:i_s,i_s,:] = compute_prob(segs_up[i_s],segs_up[:i_s],eps_segs_up[i_s],eps_segs_up[:i_s],dis_thres,angle_thres,eps_thres,ellp_fac=ellp_fac)[:,[0,2,1]] - - return prob_ma - - -def seg_reconnection(seg,segs,eps_segs,num_points_segs,dis_thres,angle_thres,eps_thres,ellp_fac=1): - """ Function that does the reconnection - - Input: seg - list of segments - segs - array with arrays containing coordinates - of segments - (number segments, rows dimension, column start-end) - eps_segs - mean deformation rate of segs - num_points_segs - array of the number of points of all - segments - angle_thres - angle threshold for reconnection - ellp_fac - weighting factor for ellipse - dis_thres - distance threshold for reconnection - eps_thres - threshold difference in deformation rate - - Output: seg - new list of reconnected segments""" - - - # 1. Initialize probability matrix - prob_ma = init_prob_matrix(segs,eps_segs,dis_thres,angle_thres,eps_thres,ellp_fac=ellp_fac) - - # 2. Loop over matrix and reconnect within one iteration the pair - # of segments that minimizes the probability matrix - - # - Loop parameters - ind = 0 - num_pos_reconnect = np.sum(prob_ma[:,:,0]<1) - max_ind = 500 - - # loop (break criteria: no connection possible or max iterations are reached) - while num_pos_reconnect >= 1: - - # 2.a. Find minimum of probability matrix - ind_connect = np.unravel_index(np.nanargmin(prob_ma[:,:,0]), - prob_ma[:,:,0].shape) - ori_connect = prob_ma[ind_connect][1:] - - # 2.b. Update segments - seg, segs, eps_segs, num_points_segs = update_segs(ind_connect,ori_connect,seg,segs,eps_segs,num_points_segs) - - # 2.c. Update probability matrix - prob_ma = update_prob_matrix(prob_ma,ind_connect,segs,eps_segs,dis_thres,angle_thres,eps_thres,ellp_fac=ellp_fac) - - # 2.d. Update loop parameters - ind += 1 - num_pos_reconnect = np.sum(prob_ma[:,:,0]<1) - - if ind>= max_ind: - break - - return seg - - - - - - - - - -# --------------- 4. RGPS related functions ---------------------------- -# ---------------------------------------------------------------------- - - - -def read_RGPS(filename,land_fill=1e10,nodata_fill=1e20): - RGPS_file = open(filename,'r') - - # RGPS product header - dxg=0. #Size of x cell in product - dyg=0. #Size of y cell in product - xg0=0. #Map location of x lower left - yg0=0. #Map location of y lower left - xg1=0. #Map location of x higher right - yg1=0. #Map location of y higher right - nxcell=0 #x cells dimensional array - nycell=0 #y cells dimensional array - - dxg,dyg,xg0,yg0,xg1,yg1 = RGPS_file.readline().strip().split() - nxcell,nycell = RGPS_file.readline().strip().split() - - data = np.fromfile(RGPS_file,np.float32).reshape(int(nycell),int(nxcell)) - - if sys.byteorder == 'little': data.byteswap(True) - - data[data==1e10] = land_fill - data[data==1e20] = nodata_fill - - return data, float(xg0), float(xg1), float(yg0), float(yg1), int(nxcell), int(nycell) - -def mSSMI(): - ''' Returns the SSMI grid projection used for RGPS data - as Basemap class - ATTENION: for coordinate transform from RGPS coordinate - m(0,90) must be added, because in RGPS NP is the origin''' - return Basemap(projection='stere',lat_ts=70,lat_0=90,lon_0=-45,resolution='l',llcrnrlon=279.26-360,llcrnrlat=33.92,urcrnrlon=102.34,urcrnrlat=31.37,ellps='WGS84') - - - -def get_latlon_RGPS(xg0,xg1,yg0,yg1,nxcell,nycell,m=mSSMI()): - # Gives only rough estimate, better use SSM/I POLAR STEREOGRAPHIC PROJECTION - x = np.linspace(xg0,xg1,nxcell+1); x = 0.5*(x[1:]+x[:-1]) - y = np.linspace(yg0,yg1,nycell+1); y = 0.5*(y[1:]+y[:-1]) - x,y = np.meshgrid(x,y) - xpol,ypol = m(0,90) - lon,lat = m(x*1e3 + xpol, y*1e3 + ypol,inverse=True) - return lon, lat - - - - - - -# --------------- 5. Helper and filter functions ---------------- -# --------------------------------------------------------------- - - - -def filter_segs_lmin(seg,lmin): - """ Function to filter all segements in seg where the distance - between start and end point is below threshold lmin""" - return [i for i in seg if np.sqrt(np.sum((i[:,0]-i[:,-1])**2))>=lmin] - - - -def segs2latlon_rgps(segs,xg0,xg1,yg0,yg1,nxcell,nycell,m=mSSMI()): - """ Function that converts index format of detected LKFs to - lat,lon coordinates - """ - lon,lat = get_latlon_RGPS(xg0,xg1,yg0,yg1,nxcell,nycell,m=m) - segsf = [] - for iseg in segs: - segsf.append(np.concatenate([iseg, - np.stack([lon[iseg[0],iseg[1]], - lat[iseg[0],iseg[1]]])], - axis=0)) - return segsf - -def segs2eps(segs,epsI,epsII): - """ Function that saves for each point of each LKF the deformation - rates and attach them to segs. - """ - segsf = [] - for iseg in segs: - segsf.append(np.concatenate([iseg, - np.stack([epsI[iseg[0].astype('int'), - iseg[1].astype('int')], - epsII[iseg[0].astype('int'), - iseg[1].astype('int')]])], - axis=0)) - return segsf - - - - - - - -# ---------------- 6. Detection functions ------------------------------ -# ------------- ( described in Section 3.1 ) --------------------------- - - - -def lkf_detect_rgps(filename_rgps,max_kernel=5,min_kernel=1,dog_thres=0,dis_thres=4,ellp_fac=3,angle_thres=35,eps_thres=0.5,lmin=4,latlon=False,return_eps=False): - """Function that detects LKFs in input RGPS file. - - Input: filename_rgps - filename of RGPS deformation dataset - max_kernel - maximum kernel size of DoG filter - min_kernel - minimum kernel size of DoG filter - dog_thres - threshold for DoG filtering, pixels that - exceed threshold are marked as LKFs - angle_thres - angle threshold for reconnection - ellp_fac - weighting factor for ellipse - dis_thres - distance threshold for reconnection - eps_thres - threshold difference in deformation rate - lmin - minimum length of segments [in pixel] - latlon - option to return latlon information of LKFs - return_eps - option to return deformation rates of LKFs - - Output: seg - list of detected LKFs""" - - (div,xg0,xg1,yg0,yg1,nxcell,nycell) = read_RGPS(filename_rgps + ".DIV", land_fill=np.NaN, nodata_fill=np.NaN) - (shr,xg0,xg1,yg0,yg1,nxcell,nycell) = read_RGPS(filename_rgps + ".SHR", land_fill=np.NaN, nodata_fill=np.NaN) - - # Process deformation data - eps_tot = np.sqrt(div**2+shr**2) - - seg = lkf_detect_eps(eps_tot,max_kernel=max_kernel,min_kernel=min_kernel, - dog_thres=dog_thres,dis_thres=dis_thres, - ellp_fac=ellp_fac,angle_thres=angle_thres, - eps_thres=eps_thres,lmin=lmin) - - if latlon: - seg = segs2latlon_rgps(seg,xg0,xg1,yg0,yg1,nxcell,nycell,m=mSSMI()) - if return_eps: - return segs2eps(seg,div,shr) - else: - return seg - - -def lkf_detect_eps(eps_tot,max_kernel=5,min_kernel=1,dog_thres=0,dis_thres=4,ellp_fac=3,angle_thres=35,eps_thres=0.5,lmin=4): - """Function that detects LKFs in input RGPS file. - - Input: eps_tot - total deformation rate - max_kernel - maximum kernel size of DoG filter - min_kernel - minimum kernel size of DoG filter - dog_thres - threshold for DoG filtering, pixels that - exceed threshold are marked as LKFs - angle_thres - angle threshold for reconnection - ellp_fac - weighting factor for ellipse - dis_thres - distance threshold for reconnection - eps_thres - threshold difference in deformation rate - lmin - minimum length of segments [in pixel] - - Output: seg - list of detected LKFs""" - - ## Take natural logarithm - proc_eps = np.log(eps_tot) - proc_eps[~np.isfinite(proc_eps)] = np.NaN - ## Apply histogram equalization - proc_eps = hist_eq(proc_eps) - ## Apply DoG filter - lkf_detect = DoG_leads(proc_eps,max_kernel,min_kernel) - ### Filter for DoG>0 - lkf_detect = (lkf_detect > dog_thres).astype('float') - lkf_detect[~np.isfinite(proc_eps)] = np.NaN - ## Apply morphological thinning - lkf_thin = skimage.morphology.skeletonize(lkf_detect).astype('float') - - - # Segment detection - seg_f = detect_segments(lkf_thin) # Returns matrix fill up with NaNs - ## Convert matrix to list with arrays containing indexes of points - seg = [seg_f[i][:,~np.any(np.isnan(seg_f[i]),axis=0)].astype('int') - for i in range(seg_f.shape[0])] - ## Filter segments that are only points - seg = [i for i in seg if i.size>2] - - # 1st Reconnection of segments - eps_mn = compute_mn_eps(np.log10(eps_tot),seg) - num_points_segs = np.array([i.size/2. for i in seg]) - ## Initialize array containing start and end point of segments - segs = np.array([np.stack([i[:,0],i[:,-1]]).T for i in seg]) - - seg = seg_reconnection(seg,segs,eps_mn,num_points_segs,1.5, - 50,eps_thres,ellp_fac=1) - - # 2nd Reconnection of segments - eps_mn = compute_mn_eps(np.log10(eps_tot),seg) - num_points_segs = np.array([i.size/2. for i in seg]) - ## Initialize array containing start and end point of segments - segs = np.array([np.stack([i[:,0],i[:,-1]]).T for i in seg]) - - seg = seg_reconnection(seg,segs,eps_mn,num_points_segs,dis_thres, - angle_thres,eps_thres,ellp_fac=ellp_fac) - - # Filter too short segments - seg = filter_segs_lmin(seg,lmin) - - # Convert to indexes of the original input image - seg = [segi+1 for segi in seg] - - return seg - diff --git a/lkf_tools/lkf_stats_tools.py b/lkf_tools/lkf_stats_tools.py deleted file mode 100644 index 45c02c6..0000000 --- a/lkf_tools/lkf_stats_tools.py +++ /dev/null @@ -1,3307 +0,0 @@ -import numpy as np -import matplotlib.pylab as plt -import os -import sys -import datetime as dt -from mpl_toolkits.basemap import Basemap -import scipy -import matplotlib as mpl -from netCDF4 import Dataset, MFDataset -import pickle -from scipy.spatial import cKDTree - -# Self-written functions -from read_RGPS import * -from model_utils import * -from lkf_utils import * -from griddata_fast import griddata_fast -from local_paths import * - -# Suppress rank warnings for fit to polynom -import warnings -warnings.simplefilter('ignore', np.RankWarning) - - -# Define function for fit to polynom - -def lkf_poly_fit(x,y,deg,return_p=False): - if x.size-10) - index_y = np.where(np.sum(mask[1:-1,1:-1],axis=1)>0) - red_fac = 3 # Take only every red_fac point to reduce array size - lon_cov = lon_cov[index_y[0][0]-1:index_y[0][-1]+2:red_fac, - index_x[0][0]-1:index_x[0][-1]+2:red_fac] - lat_cov = lat_cov[index_y[0][0]-1:index_y[0][-1]+2:red_fac, - index_x[0][0]-1:index_x[0][-1]+2:red_fac] - x_cov,y_cov = m(lon_cov,lat_cov) - - if self.datatype == 'sirex': - # if self.lkf_path.split('/')[-2].split('_')[-1] == 'means': - # ind_yp = -2 - # elif self.lkf_path.split('/')[-2].split('_')[-1] == 'inst': - # ind_yp = -1 - # ncfile = ('/work/ollie/nhutter/sirex/data/' + - # '/'.join(lkf_path[47:-1].split('/')[:-1])+'/'+ - # '_'.join(lkf_path[47:-1].split('/')[-1].split('_')[:ind_yp]) + '_' + - # years[-1] + '_' + - # '_'.join(lkf_path[47:-1].split('/')[-1].split('_')[ind_yp:]) + '.nc') - lkf_ps=lkf_path.split('/') - sp = '/'.join(lkf_ps[:np.where(np.array(lkf_ps)=='analysis')[0][0]]) - ind_m = np.where(np.array(lkf_ps)=='lead_detect')[0][0]+1 - ind_f = np.where(['means' in iseg or 'inst' in iseg for iseg in lkf_ps])[0][0] - ind_yp = np.array([-2,-1])[[np.any(['means' in iseg for iseg in lkf_ps]),np.any(['inst' in iseg for iseg in lkf_ps])]][0] - flnml = lkf_ps[ind_f].split('_'); flnml.insert(ind_yp,years[-1]) - ncfile = os.path.join(sp,'data','/'.join(lkf_ps[ind_m:ind_f]),'_'.join(flnml)+'.nc') - - - ncdata = Dataset(ncfile) - lon = ncdata.variables['ULON'][:,:] - lat = ncdata.variables['ULAT'][:,:] - - mask = ((((lon > -120) & (lon < 100)) & (lat >= 80)) | - ((lon <= -120) & (lat >= 70)) | - ((lon >= 100) & (lat >= 70))) - index_x = np.where(np.sum(mask[1:-1,1:-1],axis=0)>0) - index_y = np.where(np.sum(mask[1:-1,1:-1],axis=1)>0) - red_fac = 1 # Take only every red_fac point to reduce array size - x_cov,y_cov = m(lon[max([index_y[0][0]-1,0]):index_y[0][-1]+2:red_fac, - max([index_x[0][0]-1,0]):index_x[0][-1]+2:red_fac], - lat[max([index_y[0][0]-1,0]):index_y[0][-1]+2:red_fac, - max([index_x[0][0]-1,0]):index_x[0][-1]+2:red_fac]) - - if self.datatype == 'rgps': - cov = np.load('/work/ollie/nhutter/sirex/analysis/lead_detect/RGPS/coverage_rgps_1997_mod.npz') - x_cov, y_cov = m(cov['lon'],cov['lat']) - - - # RGPS coverage - if self.datatype=='mitgcm_2km': - cov = np.load('/work/ollie/nhutter/lkf_data/rgps_opt/coverage_rgps.npz') - else: - cov = np.load('/work/ollie/nhutter/sirex/analysis/lead_detect/RGPS/coverage_rgps_1997_mod.npz') - print('Loading this coverage file for masking: /work/ollie/nhutter/sirex/analysis/lead_detect/RGPS/coverage_rgps_1997_mod.npz') - - x_rgps,y_rgps = m(cov['lon'],cov['lat']) - - # Generate KDTree for interpolation - tree = cKDTree(np.rollaxis(np.stack([x_rgps.flatten(),y_rgps.flatten()]),0,2)) - distances, inds = tree.query(np.rollaxis(np.stack([x_cov.flatten(),y_cov.flatten()]),0,2), k = 1) - mask_cov = (distances>=12.5e3).reshape(x_cov.shape) - - - for year_dic in years: - print("Start reading with year: " + year_dic) - new_dir = lkf_path + year_dic + '/' - # Generate list of files - lkffile_list = [ifile for ifile in os.listdir(new_dir) if ifile.startswith('lkf')] - lkffile_list.sort() - - # Initialize list for year - lkf_data_year = [] - lkf_meta_year = [] - - # Read yearly RGPS coverage - if self.mask_rgps: - if self.datatype=='mitgcm_2km': - cov_year = np.load('/work/ollie/nhutter/lkf_data/rgps_opt/coverage_rgps_%s.npz' %year_dic)['coverage'] - else: - cov_year = np.load('/work/ollie/nhutter/sirex/analysis/lead_detect/RGPS/coverage_rgps_%s_mod.npz' %year_dic)['coverage'] - - - if len(lkffile_list)>cov_year.shape[0]: - lkffile_list = lkffile_list[:cov_year.shape[0]] - - # Loop over files to read an process - for it,lkffile in enumerate(lkffile_list): - - # Save meta information: start/end time, number features - if datatype == 'rgps': - startdate = (dt.date(int(lkffile[4:-15]),1,1)+ - dt.timedelta(int(lkffile[-15:-12]))) - enddate = (dt.date(int(lkffile[-11:-7]),1,1)+ - dt.timedelta(int(lkffile[-7:-4]))) - elif datatype == 'mitgcm_2km': - startdate = (dt.datetime(1992,1,1,0,0,0) + - dt.timedelta(0,int(lkffile[-14:-4])*120.)) - enddate = (dt.datetime(1992,1,1,0,0,0) + - dt.timedelta(0,int(lkffile[-14:-4])*120. + - 24*3600.)) - elif datatype == 'sirex': - if lkffile.split('_')[-2] == 'means': - ind_year = -4 - elif lkffile.split('_')[-2] == 'inst': - ind_year = -3 - startdate = (dt.date(int(lkffile.split('_')[ind_year]),1,1)+ - dt.timedelta(int(lkffile.split('_')[-1][:-4]))) - enddate = (dt.date(int(lkffile.split('_')[ind_year]),1,1)+ - dt.timedelta(int(lkffile.split('_')[-1][:-4])+3)) - - - if lkffile.endswith('.npy'): - lkfi = np.load(new_dir+lkffile, allow_pickle=True,encoding='bytes') - lkf_meta_year.append(np.array([startdate, - enddate, - lkfi.size])) - elif lkffile.endswith('.npz'): - lkfiz = np.load(new_dir+lkffile, allow_pickle=True,encoding='bytes') - lkfi = lkfiz['lkf'] - - if datatype == 'mosaic': - print(str(lkfiz['fname']).split('/')[-1].split('_')) - startdate = dt.datetime.strptime(str(lkfiz['fname']).split('/')[-1].split('_')[1][:-2],'%Y%m%dT%H%M%S') - enddate = dt.datetime.strptime(str(lkfiz['fname']).split('/')[-1].split('_')[2][:-2],'%Y%m%dT%H%M%S') - - lkf_meta_year.append(np.array([startdate, - enddate, - lkfi.size,lkfiz['fname'],lkfiz['shape']])) - - # Add projected coordinates - lkfim = [] - - if self.mask_rgps: - if self.datatype=='rgps': - cov_int = cov_year[it,100:-100,100:-100] - #if it==0: - # fig,ax = plt.subplots(1,1) - # ax.pcolormesh(cov_int) - # for iseg in lkfi: - # ax.plot(iseg[:,1].astype('int'),iseg[:,0].astype('int')) - else: - # Coverage mask of all LKFs in one day - cov_int = cov_year[it,:,:][np.unravel_index(inds,x_rgps.shape)].reshape(x_cov.shape) - cov_int[mask_cov] = np.nan - - for iseg in lkfi: - if self.mask_rgps: - mask_seg = cov_int[iseg[:,0].astype('int'), - iseg[:,1].astype('int')] - ind_mask = np.where(mask_seg)[0] - if np.any(np.diff(ind_mask)!=1): - ind_c = np.concatenate([np.array([-1]), - np.where(np.diff(ind_mask)!=1)[0], - np.array([ind_mask.size-1])]) - for ic in range(ind_c.size-1): - if ind_c[ic]+1!=ind_c[ic+1]: - iseg_c = iseg[ind_mask[ind_c[ic]+1]:ind_mask[ind_c[ic+1]]+1,:] - isegm = np.rollaxis(np.stack(m(iseg_c[:,2], - iseg_c[:,3])),1,0) - lkfim.append(np.concatenate([iseg_c, isegm], axis=1)) - if polyfit: - isegf = np.rollaxis(np.stack(lkf_poly_fit(lkfim[-1][:,self.indm0], - lkfim[-1][:,self.indm1], - poly_deg)),1,0) - lkfim[-1] = np.concatenate([lkfim[-1], isegf], axis=1) - - else: - iseg = iseg[mask_seg,:] - if iseg.shape[0]>1: - isegm = np.rollaxis(np.stack(m(iseg[:,2], - iseg[:,3])),1,0) - #print iseg, isegm - lkfim.append(np.concatenate([iseg, isegm], axis=1)) - if polyfit: - isegf = np.rollaxis(np.stack(lkf_poly_fit(lkfim[-1][:,self.indm0], - lkfim[-1][:,self.indm1], - poly_deg)),1,0) - lkfim[-1] = np.concatenate([lkfim[-1], isegf], axis=1) - else: - isegm = np.rollaxis(np.stack(m(iseg[:,2], - iseg[:,3])),1,0) - lkfim.append(np.concatenate([iseg, isegm], axis=1)) - - if polyfit: - isegf = np.rollaxis(np.stack(lkf_poly_fit(lkfim[-1][:,self.indm0], - lkfim[-1][:,self.indm1], - poly_deg)),1,0) - lkfim[-1] = np.concatenate([lkfim[-1], isegf], axis=1) - - lkf_data_year.append(lkfim) - - if read_tracking: - print( "Start reading tracking data of year: " + year_dic) - track_dir = os.path.join(lkf_path,year_dic,track_dir_name) - # Generate list of files - trackfile_list = os.listdir(track_dir) - trackfile_list.sort() - - track_year = [] - - for itrack, trackfile_i in enumerate(trackfile_list[:len(lkf_data_year)-1]): - tracked_pairs = np.load(os.path.join(track_dir, trackfile_i)) - - #track_day = np.empty((lkf_meta_year[-1][itrack][2],2),dtype=object) - track_year.append(tracked_pairs) - - - # Append to global data set - lkf_dataset.append(lkf_data_year) - lkf_meta.append(np.stack(lkf_meta_year)) - if read_tracking: lkf_track_data.append(track_year) - - # Store read and processed data - self.lkf_dataset = lkf_dataset - self.lkf_meta = lkf_meta - self.lkf_track_data = lkf_track_data - - - # Set all statistical fields to None - self.length = None - self.density = None - self.curvature = None - self.deformation = None - self.intersection = None - self.orientation = None - self.lifetime = None - self.growthrate = None - - - - def gen_length(self,overwrite=False,write_pickle=True): - if self.length is None or overwrite: - self.length = lkf_lengths(self) - if write_pickle: - with open(self.pickle, 'wb') as output_pkl: - pickle.dump(self, output_pkl, pickle.HIGHEST_PROTOCOL) - else: - print('Warning: length object exists already, to overwrite active overwrite=True option') - - def gen_density(self,overwrite=False,write_pickle=True,**kwargs): - if self.density is None or overwrite: - self.density = lkf_density(self,lkf_path=self.lkf_path,years=self.years,**kwargs) - if write_pickle: - with open(self.pickle, 'wb') as output_pkl: - pickle.dump(self, output_pkl, pickle.HIGHEST_PROTOCOL) - else: - print('Warning: density object exists already, to overwrite active overwrite=True option') - - def gen_density_len_class(self,len_class=[0e3,100e3,np.inf],write_pickle=True,**kwargs): - if self.density is None: - self.density = lkf_density(self,lkf_path=self.lkf_path,years=self.years,**kwargs) - if self.length is None: - self.length = lkf_lengths(self) - self.density.density_len_class(self,len_class=len_class) - if write_pickle: - with open(self.pickle, 'wb') as output_pkl: - pickle.dump(self, output_pkl, pickle.HIGHEST_PROTOCOL) - - - def gen_curvature(self,overwrite=False,write_pickle=True): - if self.curvature is None or overwrite: - self.gen_length(write_pickle=False) - self.curvature = lkf_curvature(self) - if write_pickle: - with open(self.pickle, 'wb') as output_pkl: - pickle.dump(self, output_pkl, pickle.HIGHEST_PROTOCOL) - else: - print('Warning: curvature object exists already, to overwrite active overwrite=True option') - - def gen_deformation(self,overwrite=False,write_pickle=True): - if self.deformation is None or overwrite: - self.deformation = lkf_deformation(self) - if write_pickle: - with open(self.pickle, 'wb') as output_pkl: - pickle.dump(self, output_pkl, pickle.HIGHEST_PROTOCOL) - else: - print('Warning: deformation object exists already, to overwrite active overwrite=True option') - - def gen_intersection(self,overwrite=False,write_pickle=True, - link_def_life_len=True,link_def_len=False,**kwargs): - if self.intersection is None or overwrite: - if link_def_life_len: - self.gen_deformation(write_pickle=False) - self.gen_length(write_pickle=False) - self.gen_lifetime(write_pickle=False) - if link_def_len: - self.gen_deformation(write_pickle=False) - self.gen_length(write_pickle=False) - self.intersection = lkf_intersection(self,link_def_life_len=link_def_life_len, - link_def_len=link_def_len, - lkf_path=self.lkf_path,years=self.years,**kwargs) - if write_pickle: - with open(self.pickle, 'wb') as output_pkl: - pickle.dump(self, output_pkl, pickle.HIGHEST_PROTOCOL) - else: - print('Warning: intersection object exists already, to overwrite active overwrite=True option') - - def gen_orientation(self,overwrite=False,write_pickle=True,**kwargs): - if self.orientation is None or overwrite: - self.orientation = lkf_orientation(self,**kwargs) - if write_pickle: - with open(self.pickle, 'wb') as output_pkl: - pickle.dump(self, output_pkl, pickle.HIGHEST_PROTOCOL) - else: - print('Warning: orientation object exists already, to overwrite active overwrite=True option') - - def gen_lifetime(self,overwrite=False,write_pickle=True): - if self.lifetime is None or overwrite: - self.lifetime = lkf_lifetime(self) - if write_pickle: - with open(self.pickle, 'wb') as output_pkl: - pickle.dump(self, output_pkl, pickle.HIGHEST_PROTOCOL) - else: - print('Warning: lifetime object exists already, to overwrite active overwrite=True option') - - def gen_growthrate(self,overwrite=False,write_pickle=True): - if self.growthrate is None or overwrite: - self.gen_length(write_pickle=False) - self.gen_lifetime(write_pickle=False) - self.growthrate = lkf_growthrate(self) - if write_pickle: - with open(self.pickle, 'wb') as output_pkl: - pickle.dump(self, output_pkl, pickle.HIGHEST_PROTOCOL) - else: - print('Warning: growth rate object exists already, to overwrite active overwrite=True option') - - - - def write2tex(self,output_path,output_name): - for iyear in range(len(self.years)): - print('Write output file: %s%s_%s.txt' %(output_path,output_name,self.years[iyear])) - output_file = open('%s%s_%s.txt' %(output_path,output_name,self.years[iyear]),'w') - - # Write header - output_file.write('Start_Year\tStart_Month\tStart_Day\tEnd_Year\tEnd_Month\tEnd_Day\tDate(RGPS_format)\tLKF_No.\tParent_LKF_No.\tind_x\tind_y\tlon\tlat\tdivergence_rate\tshear_rate\n') - - # Loop over days - id_year = [] - id_c = 1 - for iday in range(len(self.lkf_dataset[iyear])): - id_day = [] - # Loop over LKFs - for ilkf in range(len(self.lkf_dataset[iyear][iday])): - # Determine LKF ID - id_lkf = int(np.copy(id_c)); - id_c+=1 - if iday!=0: - if self.lkf_track_data[iyear][iday-1].size>0: - if np.any(self.lkf_track_data[iyear][iday-1][:,1]==ilkf): - id_parent = ','.join([str(id_year[-1][int(it)]) for it in self.lkf_track_data[iyear][iday-1][:,0][self.lkf_track_data[iyear][iday-1][:,1]==ilkf]]) - else: - id_parent = '0' - else: - id_parent = '0' - else: - id_parent = '0' - - # Loop over all points of LKF and write data to file - for ip in range(self.lkf_dataset[iyear][iday][ilkf].shape[0]): - output_file.write('\t'.join([self.lkf_meta[iyear][iday][0].strftime('%Y'), - self.lkf_meta[iyear][iday][0].strftime('%m'), - self.lkf_meta[iyear][iday][0].strftime('%d'), - self.lkf_meta[iyear][iday][1].strftime('%Y'), - self.lkf_meta[iyear][iday][1].strftime('%m'), - self.lkf_meta[iyear][iday][1].strftime('%d'), - '_'.join([self.lkf_meta[iyear][iday][idate].strftime('%Y%j') for idate in [0,1]]), - '%i' %id_lkf, - id_parent, - '%i' %self.lkf_dataset[iyear][iday][ilkf][ip,0], - '%i' %self.lkf_dataset[iyear][iday][ilkf][ip,1], - '%.020e' %self.lkf_dataset[iyear][iday][ilkf][ip,2], - '%.020e' %self.lkf_dataset[iyear][iday][ilkf][ip,3], - '%.020e' %self.lkf_dataset[iyear][iday][ilkf][ip,4], - '%.020e\n' %self.lkf_dataset[iyear][iday][ilkf][ip,5]])) - - id_day.append(id_c) - - id_year.append(id_day) - - output_file.close() - - - - -# ------------ Statistic functions ---------------------------- - -# 1. Length - -def ks(cdf_sample,cdf_model): - """Computes Komologorov-Smirnov (KS) statistic: - D = max( abs( S(x) - N(x) ) / sqrt( N(x) - (1 - N(x)) ) ) - S(x): CDF of sample, N(x): CDF of model""" - return np.max((np.abs(cdf_sample-cdf_model)/np.sqrt(cdf_model*(1-cdf_model)))[1:]) - -class lkf_lengths: - #def compute_lengths(self): - def __init__(self,lkf): - self.output_path = lkf.output_path - - print("Compute length of segments") - lkf_length = [] - - for lkf_year in lkf.lkf_dataset: - len_year = [] - for lkf_day in lkf_year: - len_day = [] - for ilkf in lkf_day: - len_day.append(np.sum(np.sqrt(np.diff(ilkf[:,lkf.indm0])**2 + - np.diff(ilkf[:,lkf.indm1])**2))) - - len_year.append(np.array(len_day)[np.isfinite(len_day)]) - - lkf_length.append(len_year) - - self.lkf_length = np.array(lkf_length) - - - def plot_length_hist(self, years=None, bins=np.linspace(50,1000,80),pow_law_lim=[50,600], - output_plot_data=False,gen_fig=True,save_fig=False, - fig_name=None): - #if self.lkf_length is None: - # self.compute_lengths() - if years is None: - years=range(len(self.lkf_length)) - - if gen_fig: - style_label = 'seaborn-darkgrid' - with plt.style.context(style_label): - fig,ax = plt.subplots(nrows=1,ncols=1, figsize=(6,5)) - ax.set_xlabel('LKF length in km') - ax.set_ylabel('PDF') - ax.set_yscale('log') - ax.set_xscale('log') - ax.set_xlim([bins.min(),bins.max()]) - colors=plt.rcParams['axes.prop_cycle'].by_key()['color'] - - for iyear in years: - pdf_length, bins_length = np.histogram(np.concatenate(self.lkf_length[iyear])/1e3, - bins=bins, density=True) - bins_mean = 0.5*(bins_length[1:]+bins_length[:-1]) - if gen_fig: - if iyear==0: - ax.plot(bins_mean, pdf_length,color='0.5',alpha=0.5,label="single years") - else: - ax.plot(bins_mean, pdf_length,color='0.5',alpha=0.5) - - pdf_length, bins_length = np.histogram(np.concatenate([np.concatenate(self.lkf_length[iyear]) for iyear in years])/1e3, - bins=bins, density=True) - bins_mean = 0.5*(bins_length[1:]+bins_length[:-1]) - if gen_fig: - ax.plot(bins_mean, pdf_length,color=colors[1],alpha=1.0,label="all years") - - coeff,pl_fit = power_law_fit(bins_mean[(bins_mean>=pow_law_lim[0]) & (bins_mean<=pow_law_lim[1])], - pdf_length[(bins_mean>=pow_law_lim[0]) & (bins_mean<=pow_law_lim[1])]) - - if gen_fig: - ax.plot(bins_mean[bins_mean<=600], pl_fit,color=colors[1],alpha=1.0,linestyle='--',label="power-law fit\nexponent %.2f" %(-coeff[0])) - ax.plot(bins_mean[bins_mean>600], - np.power(10,np.polyval(coeff,np.log10(bins_mean[bins_mean>600]))), - color=colors[1],alpha=1.0,linestyle=':') - - ax.legend() - - if save_fig: - if fig_name is None: - fig.savefig(self.output_path + 'length_pdf.pdf') - else: - fig.savefig(self.output_path + fig_name) - - if output_plot_data: - return pdf_length, bins_mean, coeff, pl_fit - - def fit_stretched_exponential(self,bins=np.linspace(50,1000,80),xmin=100,xmax=1000,mctest=True,mctest_plots=False,mciter=1000): - import powerlaw - - # Compute PDF and power-law fit - (pdf_length, bins_mean, - coeff, pl_fit) = self.plot_length_hist(bins=bins, - output_plot_data=True, - gen_fig=False) - - # Fit to stretched exponential - len_all = np.concatenate([np.concatenate(self.lkf_length[iyear]) for iyear in range(len(self.lkf_length))])/1e3 - - fit = powerlaw.Fit(len_all,xmin=xmin,xmax=len_all.max()) - - lamd = fit.stretched_exponential.parameter1 - beta = fit.stretched_exponential.parameter2 - - print('Fit to stretched exponential:\n Parameter of fit: lambda = %.010e, beta = %.010e' %(lamd,beta)) - - # Perform Monte-Carlo Simulation for KS test - if mctest: - bins_cdf = np.logspace(np.log10(xmin),np.log10(xmax),40) - bins_cdf[0] = xmin; bins_cdf[-1] = xmax - bins_cdf_m = 10**(np.log10(bins_cdf[:-1])+0.5*np.diff(np.log10(bins_cdf))) - - hist,bins = np.histogram(len_all,bins=bins_cdf,density=True) - cdf_org = (hist*np.diff(bins_cdf))[::-1].cumsum()[::-1] - - cdf_model = fit.stretched_exponential.cdf(bins_cdf[:-1],survival=True) - #cdf_model = cdf_stretched_exponential(fit.stretched_exponential,bins_cdf[:-1]) - ks_org = ks(cdf_org,cdf_model) - - n_sample = len_all.size - - ks_list = [] - - discrete_values = np.unique(np.hstack([i*12.5 + np.array([j*np.sqrt(2)*12.5 for j in range(140)]) for i in range(140)])) - bins_discrete = discrete_values[:-1] - 0.5*np.diff(discrete_values) - - if mctest_plots: - fig3,ax3 = plt.subplots(1,1) - fig2,ax2 = plt.subplots(1,1) - - for itest in range(mciter): - #print(itest) - sample = fit.stretched_exponential.generate_random(n_sample) - # Bin to discrete values - hist_s,bins_s = np.histogram(sample,bins=bins_discrete) - sample_dis = np.hstack([np.ones(hist_s[i])*discrete_values[i] for i in range(hist_s.size)]) - - # Compute cdf - hist,bins = np.histogram(sample_dis,bins=bins_cdf,density=True) - cdf_sample = (hist*np.diff(bins_cdf))[::-1].cumsum()[::-1] - - if mctest_plots: - ax3.plot(bins_cdf_m,cdf_sample) - ax2.plot(bins_cdf_m,np.abs(cdf_sample-cdf_model)/np.sqrt(cdf_model*(1-cdf_model))) - - ks_list.append(ks(cdf_sample,cdf_model)) - - if mctest_plots: - ax3.plot(bins_cdf_m,cdf_model,'k',linewidth=2.) - ax3.plot(bins_cdf_m,cdf_org,'r',linewidth=2.) - ax2.plot(bins_cdf_m,np.abs(cdf_org-cdf_model)/np.sqrt(cdf_model*(1-cdf_model)),'r',linewidth=2.) - - \\ - - cf = (pdf_length[bins_mean>=xmin]*np.diff(bins)[bins_mean>=xmin]).sum() - bins_fit = np.logspace(np.log10(xmin),np.log10(xmax),100) - pdf_fit = fit.stretched_exponential.pdf(bins_fit)*cf - - return ks_org0]) - H, xedges, yedges = np.histogram2d(lkf_year[:,lkf.indm0], lkf_year[:,lkf.indm1], - bins=(xedg, yedg)) - lkf_density[iyear,:,:] = H - - #Save output - self.lkf_density = lkf_density - - if norm_coverage: - if lkf.datatype=='rgps': - cov_dict = np.load(lkf.lkf_path + 'coverage_%s.npz' %lkf.datatype) - coverage = cov_dict['coverage'] - lon_cov = cov_dict['lon']; lat_cov = cov_dict['lat'] - x_cov,y_cov = m(lon_cov,lat_cov) - coverage_map = np.zeros((len(lkf.lkf_dataset),xedg.size-1,yedg.size-1)) - for iyear in range(len(lkf.lkf_dataset)): - coverage_map[iyear,:,:], xedges, yedges = np.histogram2d(x_cov.flatten(), - y_cov.flatten(), - bins=(self.xedg, self.yedg), - weights=coverage[iyear,:,:].flatten()) - self.coverage_map = coverage_map - - elif lkf.datatype == 'mitgcm_2km': - grid_path = '/work/ollie/nhutter/arctic_2km/run_cor_cs/' - lon_cov, lat_cov = read_latlon(grid_path) - mask = mask_arcticbasin(grid_path,read_latlon) - index_x = np.where(np.sum(mask[1:-1,1:-1],axis=0)>0) - index_y = np.where(np.sum(mask[1:-1,1:-1],axis=1)>0) - red_fac = 3 # Take only every red_fac point to reduce array size - lon_cov = lon_cov[index_y[0][0]-1:index_y[0][-1]+2:red_fac, - index_x[0][0]-1:index_x[0][-1]+2:red_fac] - lat_cov = lat_cov[index_y[0][0]-1:index_y[0][-1]+2:red_fac, - index_x[0][0]-1:index_x[0][-1]+2:red_fac] - mask = mask[index_y[0][0]-1:index_y[0][-1]+2:red_fac, - index_x[0][0]-1:index_x[0][-1]+2:red_fac] - x_cov,y_cov = m(lon_cov[mask],lat_cov[mask]) - coverage_map = np.zeros((len(years),xedg.size-1,yedg.size-1)) - for iyear in range(len(lkf.lkf_dataset)): - coverage_map[iyear,:,:], xedges, yedges = np.histogram2d(x_cov.flatten(), - y_cov.flatten(), - bins=(self.xedg, self.yedg)) - coverage_map[iyear,:,:] *= len(lkf.lkf_dataset[iyear]) - - self.coverage_map = coverage_map - - elif lkf.datatype =='sirex': - # if lkf_path.split('/')[-2].split('_')[-1] == 'means': - # ind_yp = -2 - # elif lkf_path.split('/')[-2].split('_')[-1] == 'inst': - # ind_yp = -1 - # ncfile = ('/work/ollie/nhutter/sirex/data/' + - # '/'.join(lkf_path[47:-1].split('/')[:-1])+'/'+ - # '_'.join(lkf_path[47:-1].split('/')[-1].split('_')[:ind_yp]) + '_' + - # years[-1] + '_' + - # '_'.join(lkf_path[47:-1].split('/')[-1].split('_')[ind_yp:]) + '.nc') - lkf_ps=lkf_path.split('/') - sp = '/'.join(lkf_ps[:np.where(np.array(lkf_ps)=='analysis')[0][0]]) - ind_m = np.where(np.array(lkf_ps)=='lead_detect')[0][0]+1 - ind_f = np.where(['means' in iseg or 'inst' in iseg for iseg in lkf_ps])[0][0] - ind_yp = np.array([-2,-1])[[np.any(['means' in iseg for iseg in lkf_ps]),np.any(['inst' in iseg for iseg in lkf_ps])]][0] - flnml = lkf_ps[ind_f].split('_'); flnml.insert(ind_yp,years[-1]) - ncfile = os.path.join(sp,'data','/'.join(lkf_ps[ind_m:ind_f]),'_'.join(flnml)+'.nc') - - ncdata = Dataset(ncfile) - lon = ncdata.variables['ULON'][:,:] - lat = ncdata.variables['ULAT'][:,:] - - mask = ((((lon > -120) & (lon < 100)) & (lat >= 80)) | - ((lon <= -120) & (lat >= 70)) | - ((lon >= 100) & (lat >= 70))) - index_x = np.where(np.sum(mask[1:-1,1:-1],axis=0)>0) - index_y = np.where(np.sum(mask[1:-1,1:-1],axis=1)>0) - red_fac = 1 # Take only every red_fac point to reduce array size - x_cov,y_cov = m(lon[max([0,index_y[0][0]-1]):index_y[0][-1]+2:red_fac, - max([0,index_x[0][0]-1]):index_x[0][-1]+2:red_fac], - lat[max([0,index_y[0][0]-1]):index_y[0][-1]+2:red_fac, - max([0,index_x[0][0]-1]):index_x[0][-1]+2:red_fac]) - - coverage_map = np.zeros((len(years),xedg.size-1,yedg.size-1)) - for iyear in range(len(lkf.lkf_dataset)): - coverage_map[iyear,:,:], xedges, yedges = np.histogram2d(x_cov.flatten(), - y_cov.flatten(), - bins=(self.xedg, self.yedg)) - coverage_map[iyear,:,:] *= len(lkf.lkf_dataset[iyear]) - - self.coverage_map = coverage_map - - - def density_len_class(self,lkf,len_class=[0e3,100e3,np.inf],filt_rgps_temp=False,dt=3.): - dt_rgps = 3. - - if not lkf.length is None: - self.len_class = len_class - - density_len_class = np.zeros((len(len_class)-1,len(lkf.lkf_dataset), - self.xedg.size-1,self.yedg.size-1)) - - for iclass in range(len(len_class)-1): - for iyear in range(len(lkf.lkf_dataset)): - if ~filt_rgps_temp: - lkf_year = np.concatenate(np.concatenate([np.array(lkf.lkf_dataset[iyear][iday])[(lkf.length.lkf_length[iyear][iday]>=len_class[iclass]) & (lkf.length.lkf_length[iyear][iday]=len_class[iclass]) & (lkf.length.lkf_length[iyear][iday]=len_class[iclass]) & (lkf.length.lkf_length[iyear][iday]0) - index_y = np.where(np.sum(mask[1:-1,1:-1],axis=1)>0) - red_fac = 3. # Take only every red_fac point to reduce array size - - if lkf.datatype == 'sirex': - # if lkf_path is None: - # print('ERROR: No lkf_path to netcdf_file is given!') - # if lkf_path.split('/')[-2].split('_')[-1] == 'means': - # ind_yp = -2 - # elif lkf_path.split('/')[-2].split('_')[-1] == 'inst': - # ind_yp = -1 - # else: - # print(lkf_path.split('/')[-1].split('_')[-1]) - # ncfile = ('/work/ollie/nhutter/sirex/data/' + - # '/'.join(lkf_path[47:-1].split('/')[:-1])+'/'+ - # '_'.join(lkf_path[47:-1].split('/')[-1].split('_')[:ind_yp]) + '_' + - # years[-1] + '_' + - # '_'.join(lkf_path[47:-1].split('/')[-1].split('_')[ind_yp:]) + '.nc') - lkf_ps=lkf_path.split('/') - sp = '/'.join(lkf_ps[:np.where(np.array(lkf_ps)=='analysis')[0][0]]) - ind_m = np.where(np.array(lkf_ps)=='lead_detect')[0][0]+1 - ind_f = np.where(['means' in iseg or 'inst' in iseg for iseg in lkf_ps])[0][0] - ind_yp = np.array([-2,-1])[[np.any(['means' in iseg for iseg in lkf_ps]),np.any(['inst' in iseg for iseg in lkf_ps])]][0] - flnml = lkf_ps[ind_f].split('_'); flnml.insert(ind_yp,years[-1]) - ncfile = os.path.join(sp,'data','/'.join(lkf_ps[ind_m:ind_f]),'_'.join(flnml)+'.nc') - - - ncdata = Dataset(ncfile) - lon = ncdata.variables['ULON'][:,:] - lat = ncdata.variables['ULAT'][:,:] - - mask = ((((lon > -120) & (lon < 100)) & (lat >= 80)) | - ((lon <= -120) & (lat >= 70)) | - ((lon >= 100) & (lat >= 70))) - index_x = np.where(np.sum(mask[1:-1,1:-1],axis=0)>0) - index_y = np.where(np.sum(mask[1:-1,1:-1],axis=1)>0) - red_fac = 1. # Take only every red_fac point to reduce array size - - lkf_interc = [] - lkf_interc_par = [] - if self.use_vorticity: - lkf_interc_type = [] - - for iyear in range(len(lkf.lkf_dataset)): - intc_ang_year = [] - intc_par_year = [] - if self.use_vorticity: - intc_type_year = [] - - for iday in range(len(lkf.lkf_dataset[iyear])): - if lkf.datatype == 'rgps': - lkf_map = np.zeros((248,264)) - if self.use_vorticity: - vor_file = os.listdir(os.path.join(lkf_path,str(lkf.years[iyear]))); - vor_file.sort(); vor_file = vor_file[iday][4:-4] - rgps_path = '/work/ollie/nhutter/RGPS/eulerian/' - vor_path = os.path.join(rgps_path,'w%02i%s' %(int(str(lkf.years[iyear])[-2:])-1,str(lkf.years[iyear])[-2:])) - (vor,xg0,xg1,yg0,yg1,nxcell,nycell) = read_RGPS(os.path.join(vor_path,vor_file + ".VRT"), land_fill=np.NaN, nodata_fill=np.NaN) - elif lkf.datatype == 'mitgcm_2km' or lkf.datatype == 'sirex': - lkf_map = np.zeros((int(np.ceil((index_y[0][-1]+1-index_y[0][0]+1)/red_fac)), - int(np.ceil((index_x[0][-1]+1-index_x[0][0]+1)/red_fac)))) - elif lkf.datatype == 'mosaic': - lkf_map = np.zeros(lkf.lkf_meta[iyear][iday][-1]) - if self.use_vorticity: - print('vorticity used in mosaic data') - vor = Dataset(lkf.lkf_meta[iyear][iday][3],'r')['vorticity'][:] - # if lkf.datatype == 'sirex': - # if use_vorticity: - # flnml = lkf_ps[ind_f].split('_'); flnml.insert(ind_yp,lkf.years[iyear]) - # ncfile = os.path.join(sp,'data','/'.join(lkf_ps[ind_m:ind_f]),'_'.join(flnml)+'.nc') - # data = Dataset(ncfile) - # time = data.variables['time'][:] - # lon = data.variables['ULON'][:,:] - # lat = data.variables['ULAT'][:,:] - # lon[lon==1e30] = np.nan; lat[lat==1e30] = np.nan; - # if np.any(np.array(data.variables.keys())=='DXU') and np.any(np.array(data.variables.keys())=='DYU'): - # dxu = data.variables['DXU'][:,:] - # dyu = data.variables['DYU'][:,:] - # else: - # print("ERROR: DXU and DYU are missing in netcdf file!") - # print(" --> Compute dxu and dyu from lon,lat using SSMI projection") - # m = mSSMI() - # x,y = m(lon,lat) - # dxu = np.sqrt((x[:,1:]-x[:,:-1])**2 + (y[:,1:]-y[:,:-1])**2) - # dxu = np.concatenate([dxu,dxu[:,-1].reshape((dxu.shape[0],1))],axis=1) - # dyu = np.sqrt((x[1:,:]-x[:-1,:])**2 + (y[1:,:]-y[:-1,:])**2) - # dyu = np.concatenate([dyu,dyu[-1,:].reshape((1,dyu.shape[1]))],axis=0) - - - - - - for iseg, seg_i in enumerate(lkf.lkf_dataset[iyear][iday]): - lkf_map[seg_i[:,0].astype('int'),seg_i[:,1].astype('int')] += iseg - - intc_ang_day = [] - intc_par_day = [] - if self.use_vorticity: - intc_type_day = [] - - # Check for possible intersection partners - for iseg, seg_i in enumerate(lkf.lkf_dataset[iyear][iday]): - search_ind = np.zeros(lkf_map.shape).astype('bool') - - # search_ind[seg_i[:,0].astype('int')+1,seg_i[:,1].astype('int') ] = True - # search_ind[seg_i[:,0].astype('int')-1,seg_i[:,1].astype('int') ] = True - # search_ind[seg_i[:,0].astype('int') ,seg_i[:,1].astype('int')+1] = True - # search_ind[seg_i[:,0].astype('int') ,seg_i[:,1].astype('int')-1] = True - # search_ind[seg_i[:,0].astype('int')+1,seg_i[:,1].astype('int')+1] = True - # search_ind[seg_i[:,0].astype('int')-1,seg_i[:,1].astype('int')-1] = True - # search_ind[seg_i[:,0].astype('int')-1,seg_i[:,1].astype('int')+1] = True - # search_ind[seg_i[:,0].astype('int')+1,seg_i[:,1].astype('int')-1] = True - # search_ind[seg_i[:,0].astype('int') ,seg_i[:,1].astype('int') ] = False - - for ix in range(-dis_par,dis_par+1): - for iy in range(-dis_par,dis_par+1): - if np.all([seg_i[:,0].astype('int')+ix >= 0, seg_i[:,0].astype('int')+ix < search_ind.shape[0]]): - if np.all([seg_i[:,1].astype('int')+iy >= 0, seg_i[:,1].astype('int')+iy < search_ind.shape[1]]): - search_ind[seg_i[:,0].astype('int')+ix,seg_i[:,1].astype('int')+iy] = True - search_ind[seg_i[:,0].astype('int') ,seg_i[:,1].astype('int') ] = False - - - intercep_points = np.where(search_ind & (lkf_map!=0)) - - intercep_partners, intercep_counts = np.unique(lkf_map[intercep_points], - return_counts=True) - - for ipar,pari in enumerate(intercep_partners): - if pari > iseg and pari < len(lkf.lkf_dataset[iyear][iday]): - # Determine one intercetion point for pair - dis_intercep = np.zeros(intercep_counts[ipar]) - for iintc in range(intercep_counts[ipar]): - dis_intercep[iintc] = np.min(np.sqrt((seg_i[:,0] - - intercep_points[0][lkf_map[intercep_points]==pari][iintc])**2 + - (seg_i[:,1] - - intercep_points[1][lkf_map[intercep_points]==pari][iintc])**2)) - intcp = (intercep_points[0][lkf_map[intercep_points]==pari][np.argmin(dis_intercep)], - intercep_points[1][lkf_map[intercep_points]==pari][np.argmin(dis_intercep)]) - - # Determine angle between both pairs - # # Determine orientation of seg_i - ind = np.argmin(np.sqrt((seg_i[:,0] - intcp[0])**2 + - (seg_i[:,1] - intcp[1])**2)) - ind = np.array([np.max([0,ind-num_p]), - np.min([seg_i.shape[0],ind+num_p+1])]) - p_x,p_y = lkf_poly_fit_p(seg_i[ind[0]:ind[1],indc0], - seg_i[ind[0]:ind[1],indc1],1) # Linear fit - p = p_y[0]/p_x[0] - # # Determin angle from linear fit - if np.isnan(p): - ang_i = 90. - else: - ang_i = np.arctan(p)/np.pi*180. - - if self.use_vorticity: - vor0 = np.mean(vor[seg_i[ind[0]:ind[1],0].astype('int'), - seg_i[ind[0]:ind[1],1].astype('int')]) - - # # Determine orientation of pari - lkf_par = lkf.lkf_dataset[iyear][iday][int(pari)] - ind = np.argmin(np.sqrt((lkf_par[:,0] - intcp[0])**2 + - (lkf_par[:,1] - intcp[1])**2)) - ind = np.array([np.max([0,ind-num_p]), - np.min([lkf_par.shape[0],ind+num_p+1])]) - p_x,p_y = lkf_poly_fit_p(lkf_par[ind[0]:ind[1],indc0], - lkf_par[ind[0]:ind[1],indc1],1) # Linear fit - p = p_y[0]/p_x[0] - # # Determin angle from linear fit - if np.isnan(p): - ang_ii = 90. - else: - ang_ii = np.arctan(p)/np.pi*180. - if self.use_vorticity: - vor1 = np.mean(vor[lkf_par[ind[0]:ind[1],0].astype('int'), - lkf_par[ind[0]:ind[1],1].astype('int')]) - # angdiff = np.abs(ang_ii-ang_i) - # if vor1*vor0>0: - # # vorticity same sign - # if angdiff > 90: angdiff=180-angdiff - # intc_ang_day.append(180-angdiff) - # else: - # if vor1<0: - # angdiff = 180-angdiff - # intc_ang_day.append(angdiff) - # intc_ang_day.append(angdiff) - if vor0>0 and vor1<0: - if ang_ii0 and vor0<0: - if ang_i 90: angdiff=180-angdiff - intc_ang_day.append(angdiff) - intc_par_day.append(np.array([iseg,pari])) - - intc_ang_year.append(intc_ang_day) - intc_par_year.append(intc_par_day) - if self.use_vorticity: - intc_type_year.append(intc_type_day) - lkf_interc.append(intc_ang_year) - lkf_interc_par.append(intc_par_year) - if self.use_vorticity: - lkf_interc_type.append(intc_type_year) - - self.lkf_interc = np.array(lkf_interc) - self.lkf_interc_par = np.array(lkf_interc_par) - if self.use_vorticity: - self.lkf_interc_type = np.array(lkf_interc_type) - - - if link_def_life_len: - # Compute mean deformation of intersecting partners - self.def_par = []; self.diff_def_par = []; - self.life_par = []; self.len_par = [] - for iyear in range(len(lkf.lkf_dataset)): - def_par_year = []; diff_def_par_year = []; - life_par_year = []; len_par_year = [] - for iday in range(len(lkf.lkf_dataset[iyear])): - if len(self.lkf_interc_par[iyear][iday]) > 0: - def_par_day = np.array([np.sqrt(np.sum(np.array(lkf.deformation.lkf_deformation[iyear][iday])[np.stack(self.lkf_interc_par[iyear][iday])[:,0].astype('int')]**2,axis=1)), - np.sqrt(np.sum(np.array(lkf.deformation.lkf_deformation[iyear][iday])[np.stack(self.lkf_interc_par[iyear][iday])[:,1].astype('int')]**2,axis=1))]) - diff_def_par_day = np.abs(np.diff(def_par_day,axis=0)) - life_par_day = np.array([lkf.lifetime.lkf_lifetime[iyear][iday][np.stack(self.lkf_interc_par[iyear][iday])[:,0].astype('int')], - lkf.lifetime.lkf_lifetime[iyear][iday][np.stack(self.lkf_interc_par[iyear][iday])[:,1].astype('int')]]) - len_par_day = np.array([np.array(lkf.length.lkf_length[iyear][iday])[np.stack(self.lkf_interc_par[iyear][iday])[:,0].astype('int')], - np.array(lkf.length.lkf_length[iyear][iday])[np.stack(self.lkf_interc_par[iyear][iday])[:,1].astype('int')]]) - else: - life_par_day = np.array([]) - len_par_day = np.array([]) - def_par_day = np.array([]) - diff_def_par_day = np.array([]) - - def_par_year.append(def_par_day) - diff_def_par_year.append(diff_def_par_day) - life_par_year.append(life_par_day) - len_par_year.append(len_par_day) - self.def_par.append(def_par_year) - self.diff_def_par.append(diff_def_par_year) - self.life_par.append(life_par_year) - self.len_par.append(len_par_year) - - if link_def_len: - # Compute mean deformation of intersecting partners - self.def_par = []; self.diff_def_par = []; - #self.life_par = []; - self.len_par = [] - for iyear in range(len(lkf.lkf_dataset)): - def_par_year = []; diff_def_par_year = []; - #life_par_year = []; - len_par_year = [] - for iday in range(len(lkf.lkf_dataset[iyear])): - if len(self.lkf_interc_par[iyear][iday]) > 0: - def_par_day = np.array([np.sqrt(np.sum(np.array(lkf.deformation.lkf_deformation[iyear][iday])[np.stack(self.lkf_interc_par[iyear][iday])[:,0].astype('int')]**2,axis=1)), - np.sqrt(np.sum(np.array(lkf.deformation.lkf_deformation[iyear][iday])[np.stack(self.lkf_interc_par[iyear][iday])[:,1].astype('int')]**2,axis=1))]) - diff_def_par_day = np.abs(np.diff(def_par_day,axis=0)) - #life_par_day = np.array([lkf.lifetime.lkf_lifetime[iyear][iday][np.stack(self.lkf_interc_par[iyear][iday])[:,0].astype('int')], - # lkf.lifetime.lkf_lifetime[iyear][iday][np.stack(self.lkf_interc_par[iyear][iday])[:,1].astype('int')]]) - len_par_day = np.array([np.array(lkf.length.lkf_length[iyear][iday])[np.stack(self.lkf_interc_par[iyear][iday])[:,0].astype('int')], - np.array(lkf.length.lkf_length[iyear][iday])[np.stack(self.lkf_interc_par[iyear][iday])[:,1].astype('int')]]) - else: - #life_par_day = np.array([]) - len_par_day = np.array([]) - def_par_day = np.array([]) - diff_def_par_day = np.array([]) - - def_par_year.append(def_par_day) - diff_def_par_year.append(diff_def_par_day) - #life_par_year.append(life_par_day) - len_par_year.append(len_par_day) - self.def_par.append(def_par_year) - self.diff_def_par.append(diff_def_par_year) - #self.life_par.append(life_par_year) - self.len_par.append(len_par_year) - - - - def plot_hist(self,bins=np.linspace(0,90,45), - output_plot_data=False,gen_fig=True,save_fig=False, - fig_name=None): - - if gen_fig: - style_label = 'seaborn-darkgrid' - with plt.style.context(style_label): - fig,ax = plt.subplots(nrows=1,ncols=1) - - ax.set_xlabel('Intersection angle') - ax.set_ylabel('PDF') - #ax.set_xlim([0,90]) - for iyear in range(len(self.lkf_interc)): - pdf_interc, bins_interc = np.histogram(np.concatenate(self.lkf_interc[iyear]), - bins=bins, density=True) - bins_mean = 0.5*(bins_interc[1:]+bins_interc[:-1]) - ax.plot(bins_mean, pdf_interc,label=self.years[iyear],color='0.5',alpha=0.5) - - pdf_interc, bins_interc = np.histogram(np.concatenate([np.concatenate(self.lkf_interc[iyear]) for iyear in range(len(self.lkf_interc))]), - bins=bins, density=True) - bins_mean = 0.5*(bins_interc[1:]+bins_interc[:-1]) - - if gen_fig: - ax.plot(bins_mean, pdf_interc,label=self.years[iyear]) - - if save_fig: - if fig_name is None: - fig.savefig(self.output_path + 'Interc_pdf_all_years.pdf') - else: - fig.savefig(self.output_path + fig_name) - - if output_plot_data: - return pdf_interc, bins_mean - - - def plot_hist_def_life_len(self,def_class=None,bins=np.linspace(0,90,23), - len_thres = 10*12.5e3, - output_plot_data=False,gen_fig=True, - save_fig=False, fig_name=None, - return_num_meas=False): - if def_class is None: - if datatype=='rgps': - def_class = [0,0.03,0.1,2] - elif datatype == 'mitgcm_2km': - def_class = [0,0.05,0.2,10] - if gen_fig: - style_label = 'seaborn-darkgrid' - with plt.style.context(style_label): - fig,ax = plt.subplots(nrows=1,ncols=len(def_class)-1, figsize=(6*(len(def_class)-1),5)) - colors=plt.rcParams['axes.prop_cycle'].by_key()['color'] - - def_masked_class = [[] for i in range(len(def_class))] - - pdf_all_class = [] - pdf_years_class = [] - - for iax in range(len(def_class)-1): - if gen_fig: - if (len(def_class)-1)==1: - axi=ax - else: - axi = ax[iax] - - axi.set_title('Def. class: %.2f to %.2f [1/day]' %(def_class[iax],def_class[iax+1])) - axi.set_xlabel('Intersection angle') - axi.set_ylabel('PDF') - axi.set_xlim([0,90]) - - pdf_year_save = [] - - for iyear in range(len(self.lkf_interc)): - mask_def = np.all([np.all(np.hstack(self.def_par[iyear])>=def_class[iax],axis=0), - np.all(np.hstack(self.def_par[iyear])=len_thres,axis=0) - mask_life = mask_len & mask_life - if self.use_vorticity: - mask_def = np.stack([mask_def,mask_def]).T.flatten() - mask_life = np.stack([mask_life,mask_life]).T.flatten() - pdf_interc, bins_interc = np.histogram(np.concatenate(self.lkf_interc[iyear])[mask_def & mask_life], - bins=bins, density=True) - pdf_year_save.append(pdf_interc) - bins_mean = 0.5*(bins_interc[1:]+bins_interc[:-1]) - if gen_fig: - if iyear==0: - axi.plot(bins_mean, pdf_interc,'.',label='single years',color='0.5',alpha=0.5) - else: - axi.plot(bins_mean, pdf_interc,'.',color='0.5',alpha=0.5) - - def_masked_class[iax].append(np.concatenate(self.lkf_interc[iyear])[mask_def & mask_life]) - pdf_interc, bins_interc = np.histogram(np.concatenate(def_masked_class[iax]), - bins=bins, density=True) - bins_mean = 0.5*(bins_interc[1:]+bins_interc[:-1]) - - pdf_all_class.append(pdf_interc) - pdf_years_class.append(pdf_year_save) - - if gen_fig: - axi.plot(bins_mean, pdf_interc,label='all years',color=colors[0],alpha=1.0) - - axi.plot([],[],' ',label='Tot. num: %i' %np.concatenate(def_masked_class[iax]).size) - axi.legend() - - self.def_masked_class = def_masked_class - - if save_fig: - if fig_name is None: - fig.savefig(self.output_path + 'Interc_pdf_def_len_life_all_years.pdf') - else: - fig.savefig(self.output_path + fig_name) - - if output_plot_data: - if return_num_meas: - return pdf_all_class, pdf_years_class, bins_mean, np.concatenate(def_masked_class[iax]).size - else: - return pdf_all_class, pdf_years_class, bins_mean - - - def plot_hist_def_len(self,def_class=None,bins=np.linspace(0,90,23), - len_thres = 10*12.5e3, - output_plot_data=False,gen_fig=True, - save_fig=False, fig_name=None, - return_num_meas=False): - if def_class is None: - if datatype=='rgps': - def_class = [0,0.03,0.1,2] - elif datatype == 'mitgcm_2km': - def_class = [0,0.05,0.2,10] - if gen_fig: - style_label = 'seaborn-darkgrid' - with plt.style.context(style_label): - fig,ax = plt.subplots(nrows=1,ncols=len(def_class)-1, figsize=(6*(len(def_class)-1),5)) - colors=plt.rcParams['axes.prop_cycle'].by_key()['color'] - - def_masked_class = [[] for i in range(len(def_class))] - - pdf_all_class = [] - pdf_years_class = [] - - for iax in range(len(def_class)-1): - if gen_fig: - if (len(def_class)-1)==1: - axi=ax - else: - axi = ax[iax] - - axi.set_title('Def. class: %.2f to %.2f [1/day]' %(def_class[iax],def_class[iax+1])) - axi.set_xlabel('Intersection angle') - axi.set_ylabel('PDF') - axi.set_xlim([0,90]) - - pdf_year_save = [] - - for iyear in range(len(self.lkf_interc)): - mask_def = np.all([np.all(np.hstack(self.def_par[iyear])>=def_class[iax],axis=0), - np.all(np.hstack(self.def_par[iyear])=len_thres,axis=0) - mask_life = mask_len #& mask_life - if self.use_vorticity: - mask_def = np.stack([mask_def,mask_def]).T.flatten() - mask_life = np.stack([mask_life,mask_life]).T.flatten() - pdf_interc, bins_interc = np.histogram(np.concatenate(self.lkf_interc[iyear])[mask_def & mask_life], - bins=bins, density=True) - pdf_year_save.append(pdf_interc) - bins_mean = 0.5*(bins_interc[1:]+bins_interc[:-1]) - if gen_fig: - if iyear==0: - axi.plot(bins_mean, pdf_interc,'.',label='single years',color='0.5',alpha=0.5) - else: - axi.plot(bins_mean, pdf_interc,'.',color='0.5',alpha=0.5) - - def_masked_class[iax].append(np.concatenate(self.lkf_interc[iyear])[mask_def & mask_life]) - pdf_interc, bins_interc = np.histogram(np.concatenate(def_masked_class[iax]), - bins=bins, density=True) - bins_mean = 0.5*(bins_interc[1:]+bins_interc[:-1]) - - pdf_all_class.append(pdf_interc) - pdf_years_class.append(pdf_year_save) - - if gen_fig: - axi.plot(bins_mean, pdf_interc,label='all years',color=colors[0],alpha=1.0) - - axi.plot([],[],' ',label='Tot. num: %i' %np.concatenate(def_masked_class[iax]).size) - axi.legend() - - self.def_masked_class = def_masked_class - - if save_fig: - if fig_name is None: - fig.savefig(self.output_path + 'Interc_pdf_def_len_life_all_years.pdf') - else: - fig.savefig(self.output_path + fig_name) - - if output_plot_data: - if return_num_meas: - return pdf_all_class, pdf_years_class, bins_mean, np.concatenate(def_masked_class[iax]).size - else: - return pdf_all_class, pdf_years_class, bins_mean - - - - - - - - - -# 6. Compute orientation - -class lkf_orientation: - def __init__(self,lkf,res=200e3,use_poly_ori=True): - print("Compute orientation of LKFs") - - self.output_path = lkf.output_path - self.m = lkf.m - - # Compute cell that an LKF contributes to - # Mapping grid - self.xedg = np.arange(m.xmin,m.xmax,res) - self.yedg = np.arange(m.ymin,m.ymax,res) - self.y,self.x = np.meshgrid(0.5*(self.yedg[1:]+self.yedg[:-1]), - 0.5*(self.xedg[1:]+self.xedg[:-1])) - - cell_contrib = [] - - for lkf_year in lkf.lkf_dataset: - cell_contrib_year = [] - for lkf_day in lkf_year: - cell_contrib_day = [] - for ilkf in lkf_day: - if use_poly_ori: - H, xedges, yedges = np.histogram2d(ilkf[:,lkf.indp0], ilkf[:,lkf.indp1], - bins=(self.xedg, self.yedg)) - else: - H, xedges, yedges = np.histogram2d(ilkf[:,lkf.indm0], ilkf[:,lkf.indm1], - bins=(self.xedg, self.yedg)) - cell_contrib_day.append(np.where(H.flatten()>0)[0]) - - cell_contrib_year.append(cell_contrib_day) - - cell_contrib.append(cell_contrib_year) - - self.cell_contrib = np.array(cell_contrib) - - - - # Compute orientation - print("Compute orientation of segments") - lkf_orientation = [] - lkf_ori_len_wght = [] - - lkf_angle = [] - lkf_angle_len_wght = [] - - ori_day_org = np.empty((self.x.shape),dtype=object) - for ix in range(self.xedg.size-1): - for iy in range(self.yedg.size-1): - ori_day_org[ix,iy] = np.array([]) - - for iyear,lkf_year in enumerate(lkf.lkf_dataset): - - ori_year = [] - ori_len_year = [] - ang_year = [] - ang_len_year = [] - for iday,lkf_day in enumerate(lkf_year): - ori_day = ori_day_org.copy() - ori_len_day = ori_day_org.copy() - ang_day = [] - ang_len_day = [] - for ilkf,lkf_i in enumerate(lkf_day): - ang_lkf = [] - ang_len_lkf = [] - for i_cell in self.cell_contrib[iyear][iday][ilkf]: - # Find part of lkf inside box - ix,iy = np.unravel_index(i_cell,self.x.shape) - if use_poly_ori: - lkf_i_c = lkf_i[:,lkf.indp0:lkf.indp0+2][np.all([lkf_i[:,lkf.indp0]>=self.xedg[ix], - lkf_i[:,lkf.indp0]<=self.xedg[ix+1], - lkf_i[:,lkf.indp1]>=self.yedg[iy], - lkf_i[:,lkf.indp1]<=self.yedg[iy+1]], - axis=0),:] - else: - lkf_i_c = lkf_i[:,lkf.indm0:lkf.indm0+2][np.all([lkf_i[:,lkf.indm0]>=self.xedg[ix], - lkf_i[:,lkf.indm0]<=self.xedg[ix+1], - lkf_i[:,lkf.indm1]>=self.yedg[iy], - lkf_i[:,lkf.indm1]<=self.yedg[iy+1]], - axis=0),:] - - # Linear fit & determine angle from linear fit - if lkf_i_c.size > 2: - # All cases that are not a line in y-direction - p_x,p_y = lkf_poly_fit_p(lkf_i_c[:,0],lkf_i_c[:,1], - 1) # Linear fit - p = p_y[0]/p_x[0] - - # Determin angle from linear fit - if np.isnan(p): - ang = 90. - else: - ang = np.arctan(p)/np.pi*180. - - ang_lkf.append(ang) - ang_len_lkf.append(lkf_i_c.shape[0]) - - ori_day[ix,iy] = np.concatenate([ori_day[ix,iy], - np.array([ang])]) - ori_len_day[ix,iy] = np.concatenate([ori_len_day[ix,iy], - np.array([lkf_i_c.shape[0]])]) - else: - ang_lkf.append(np.nan) - ang_len_lkf.append(np.nan) - - ang_day.append(ang_lkf) - ang_len_day.append(ang_len_lkf) - - ang_year.append(ang_day) - ang_len_year.append(ang_len_day) - - ori_year.append(ori_day) - ori_len_year.append(ori_len_day) - - lkf_angle.append(ang_year) - lkf_angle_len_wght.append(ang_len_year) - - lkf_orientation.append(ori_year) - lkf_ori_len_wght.append(ori_len_year) - - - - #Save output - self.lkf_angle = np.array(lkf_angle) - self.lkf_angle_len_wght = np.array(lkf_angle_len_wght) - self.lkf_orientation = np.array(lkf_orientation) - self.lkf_ori_len_wght = np.array(lkf_ori_len_wght) - - - - -# 7. Lifetime of LKFs - -class lkf_lifetime: - def __init__(self,lkf): - print("Compute lifetime of LKFs") - - self.output_path = lkf.output_path - - lkf_lifetime = [] - - for iyear,lkf_year in enumerate(lkf.lkf_dataset): - life_year = [np.ones((len(i_num_lkf),)) for i_num_lkf in lkf_year] - #print(len(lkf_year),len(lkf.lkf_track_data[iyear])) - #print(len(life_year)) - for it,itrack in enumerate(lkf.lkf_track_data[iyear]): - #print(it,itrack) - if itrack.size>0: - #print(life_year[it+1].shape) - life_year[it+1][itrack[:,1].astype('int')] += life_year[it][itrack[:,0].astype('int')] - - lkf_lifetime.append(life_year) - - #Save output - self.lkf_lifetime = np.array(lkf_lifetime) - - - def plot_pdf(self,xlim=[0,31],dt=3., - output_plot_data=False,gen_fig=True,save_fig=False, - fig_name=None): - # Compute histograms - if gen_fig: - style_label = 'seaborn-darkgrid' - with plt.style.context(style_label): - fig,ax = plt.subplots(nrows=1,ncols=1) - ax.set_xlabel('LKF lifetime') - ax.set_ylabel('Relative frequency') - ax.set_yscale('log') - ax.set_xlim(xlim) - colors=plt.rcParams['axes.prop_cycle'].by_key()['color'] - for iyear in range(len(self.lkf_lifetime)): - pdf_life = np.bincount(np.concatenate(self.lkf_lifetime[iyear]).astype('int')-1) - bins_mean = np.arange(pdf_life.size)*dt+dt/2. - if iyear==0: - ax.plot(bins_mean, pdf_life/float(np.sum(pdf_life)),'.',color='0.5',alpha=0.5,label="single years") - else: - ax.plot(bins_mean, pdf_life/float(np.sum(pdf_life)),'.',color='0.5',alpha=0.5) - - pdf_life = np.bincount(np.concatenate([np.concatenate(life_year) for life_year in self.lkf_lifetime]).astype('int')-1) - bins_mean = np.arange(pdf_life.size)*dt+dt/2. - - if gen_fig: - ax.plot(bins_mean, pdf_life/float(np.sum(pdf_life)),'.',color=colors[1],alpha=1.0,label="all years") - - coeff = np.polyfit(bins_mean, np.log(pdf_life/float(np.sum(pdf_life))),1) - pdf_life_fit = np.exp(np.polyval(coeff,bins_mean)) - if gen_fig: - ax.plot(bins_mean,pdf_life_fit, - color=colors[1],alpha=1.0,linestyle='--', - label="exponential fit\nexponent %.2f" %(-coeff[0])) - ax.legend() - - if save_fig: - if fig_name is None: - fig.savefig(self.output_path + 'Lifetime_pdf_exp_fit_all_years.pdf') - else: - fig.savefig(self.output_path + fig_name) - - if output_plot_data: - return pdf_life, bins_mean, coeff, pdf_life_fit - - - - - -# 8. Growth rates - -class lkf_growthrate: - def __init__(self,lkf): - print("Compute growth rates of LKFs") - - self.output_path = lkf.output_path - self.lkf_lifetime = lkf.lifetime.lkf_lifetime - - lkf_growth = [] - lkf_shrink = [] - - for iyear,lkf_year in enumerate(lkf.lkf_dataset): - growth_year = [np.ones((len(i_num_lkf),))*np.nan for i_num_lkf in lkf_year[1:]] - shrink_year = [np.ones((len(i_num_lkf),))*np.nan for i_num_lkf in lkf_year[1:]] - for iday,day_track in enumerate(lkf.lkf_track_data[iyear]): - # Compute growth rate of all tracked features - for it,itrack in enumerate(day_track): - if len(itrack)>0: - # Compute overlapping area for both features - mhd,overlap,[A_o,B_o] = compute_MHD_segment(lkf.lkf_dataset[iyear][iday][itrack[0].astype('int')][:,:2].T, - lkf.lkf_dataset[iyear][iday+1][itrack[1].astype('int')][:,:2].T, - overlap_thres=1.5,angle_thres=25, - return_overlap=True, - return_overlaping_area=True, - mask_instead=True) - A = lkf.lkf_dataset[iyear][iday][itrack[0].astype('int')][:,lkf.indm0:lkf.indm1+1].copy() - B = lkf.lkf_dataset[iyear][iday+1][itrack[1].astype('int')][:,lkf.indm0:lkf.indm1+1].copy() - - A[A_o,:] = np.nan; B[B_o,:] = np.nan; - - # Determine growth - growth_year[iday][itrack[1].astype('int')] = np.nansum(np.sqrt(np.sum(np.diff(A,axis=0)**2,axis=1))) - if np.isnan(growth_year[iday][itrack[1].astype('int')]): - growth_year[iday][itrack[1].astype('int')] = 0 - - # Determine shrink - shrink_year[iday][itrack[1].astype('int')] = np.nansum(np.sqrt(np.sum(np.diff(B,axis=0)**2,axis=1))) - if np.isnan(shrink_year[iday][itrack[1].astype('int')]): - shrink_year[iday][itrack[1].astype('int')] = 0 - - # Add growth rates of all not tracked features - ind_life1 = (lkf.lifetime.lkf_lifetime[iyear][iday+1]==1) - growth_year[iday][ind_life1] = lkf.length.lkf_length[iyear][iday+1][ind_life1] - shrink_year[iday][ind_life1] = lkf.length.lkf_length[iyear][iday+1][ind_life1] - - lkf_growth.append(growth_year) - lkf_shrink.append(shrink_year) - - - #Save output - self.lkf_growth = np.array(lkf_growth) - self.lkf_shrink = np.array(lkf_shrink) - - - def plot_pdf(self, bins=np.linspace(0,500,50), - output_plot_data=False,gen_fig=True,save_fig=False, - fig_name=None): - #if self.lkf_length is None: - # self.compute_lengths() - - if gen_fig: - style_label = 'seaborn-darkgrid' - with plt.style.context(style_label): - fig,ax = plt.subplots(nrows=1,ncols=1, figsize=(6,5)) - ax.set_xlabel('LKF growth rates [km/day]') - ax.set_ylabel('PDF') - ax.set_yscale('log') - #ax.set_xscale('log') - ax.set_xlim([bins.min(),bins.max()]) - colors=plt.rcParams['axes.prop_cycle'].by_key()['color'] - - plot_list = [self.lkf_growth,self.lkf_shrink] - plot_label = ['positive (grow)', 'negative (shrink)'] - lifetime = self.lkf_lifetime - coeffs = [] - pdfs = [] - binss = [] - pdf_fits = [] - yerrs = [] - - for i,growthi in enumerate(plot_list): - pdf_years_lifee1 = [] - pdf_years_lifel1 = [] - for iyear in range(len(growthi)): - growth_year = np.concatenate(growthi[iyear])/3e3 - lifetime_year = np.concatenate(lifetime[iyear][1:]) - # All LKFs of year - pdf_growth, bins_growth = np.histogram(growth_year[lifetime_year==1], - bins=bins, density=True) - bins_mean = 0.5*(bins_growth[1:]+bins_growth[:-1]) - pdf_years_lifee1.append(pdf_growth) - - pdf_growth, bins_growth = np.histogram(growth_year[lifetime_year!=1], - bins=bins, density=True) - bins_mean = 0.5*(bins_growth[1:]+bins_growth[:-1]) - pdf_years_lifel1.append(pdf_growth) - - pdf_years_lifee1 = np.stack(pdf_years_lifee1) - pdf_years_lifel1 = np.stack(pdf_years_lifel1) - - growth_all = np.concatenate([np.concatenate(growthi[iyear]) for iyear in range(len(growthi))])/3e3 - lifetime_all = np.concatenate([np.concatenate(lifetime[iyear][1:]) for iyear in range(len(lifetime))]) - pdf_growth, bins_growth = np.histogram(growth_all[lifetime_all==1], - bins=bins, density=True) - bins_mean = 0.5*(bins_growth[1:]+bins_growth[:-1]) - if i==0: - ista = np.where(pdf_growth!=0)[0][0] - if np.any(pdf_growth==0): - if np.where(np.where(pdf_growth==0)[0]>ista)[0].size>0: - iend = np.where(pdf_growth==0)[0][np.where(np.where(pdf_growth==0)[0]>ista)[0][0]] - else: - iend = -1 - else: - iend = -1 - coeff_l1 = np.polyfit(bins_mean[ista:iend], - np.log(pdf_growth[ista:iend]),1) - pdf_growth_fit_l1 = np.exp(np.polyval(coeff_l1,bins_mean)) - yerr = [pdf_growth-pdf_years_lifee1.min(axis=0), - pdf_years_lifee1.max(axis=0)-pdf_growth] - - coeffs.append(coeff_l1) - pdfs.append(pdf_growth) - binss.append(bins_mean) - pdf_fits.append(pdf_growth_fit_l1) - yerrs.append(yerr) - - if gen_fig: - ax.errorbar(bins_mean, pdf_growth,yerr=yerr, - color=colors[2],alpha=0.5, - label='Newly formed (%.03f)' %coeff_l1[0], - fmt='.') - ax.plot(bins_mean,pdf_growth_fit_l1,'--',color=colors[2]) - - - pdf_growth, bins_growth = np.histogram(growth_all[lifetime_all!=1], - bins=bins, density=True) - bins_mean = 0.5*(bins_growth[1:]+bins_growth[:-1]) - ista = np.where(pdf_growth!=0)[0][0] - if np.any(pdf_growth==0): - if np.where(np.where(pdf_growth==0)[0]>ista)[0].size>0: - iend = np.where(pdf_growth==0)[0][np.where(np.where(pdf_growth==0)[0]>ista)[0][0]] - else: - iend = -1 - else: - iend = -1 - coeff_e1 = np.polyfit(bins_mean[ista:iend], - np.log(pdf_growth[ista:iend]),1) - pdf_growth_fit_e1 = np.exp(np.polyval(coeff_e1,bins_mean)) - yerr = [pdf_growth-pdf_years_lifel1.min(axis=0), - pdf_years_lifel1.max(axis=0)-pdf_growth] - - coeffs.append(coeff_e1) - pdfs.append(pdf_growth) - binss.append(bins_mean) - pdf_fits.append(pdf_growth_fit_e1) - yerrs.append(yerr) - if gen_fig: - ax.errorbar(bins_mean, pdf_growth,yerr=yerr, - color=colors[i],alpha=0.5, - label=plot_label[i]+' (%.03f)' %coeff_e1[0],fmt='.') - ax.plot(bins_mean,pdf_growth_fit_e1,'--',color=colors[i]) - - ax.legend() - ax.set_ylim([10**np.floor(np.nanmin(np.log10(pdf_growth)[np.isfinite(np.log10(pdf_growth))])), - 10**np.ceil(np.nanmax(np.log10(pdf_growth)))]) - - if save_fig: - if fig_name is None: - fig.savefig(self.output_path + 'growth_rate_pdf.pdf') - else: - fig.savefig(self.output_path + fig_name) - - if output_plot_data: - return pdfs, binss, yerrs ,coeffs, pdf_fits - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -def runmean(data,win): - datam = np.zeros(data.size-win+1) - for i in range(win): - datam += data[i:(data.size+1-win+i)] - return datam/float(win) - - -def power_law_fit(x,y): - coeff = np.polyfit(np.log10(x),np.log10(y),1) - fit = np.power(10,np.polyval(coeff,np.log10(x))) - return coeff,fit - - - - - - - - - - - - - - - - -# # --------------------- Statistics -------------------------------- - -# # if datatype == 'rgps': -# # plot_output_path = '/work/ollie/nhutter/lkf_data/rgps_eps/stats/' -# # elif datatype == 'mitgcm_2km': -# # plot_output_path = '/work/ollie/nhutter/lkf_data/mitgcm_2km/stats/' -# # elif datatype == 'mitgcm_2km_cor_cs': -# # plot_output_path = '/work/ollie/nhutter/lkf_data/mitgcm_2km_cor_cs/stats/' - -# num_time = False - -# length = False - -# density = False - -# curvature = False - -# comp_cell_contrib = False - -# orientation = False -# use_poly_ori = True -# plot_ori_mean = True -# plot_ori_years = False -# plot_ori_months = True -# plot_rad_hist = False -# plot_broehan = True - -# deformation = False - -# intersection = False -# link_interc_def = False -# link_interc_lifetime = False -# link_interc_len = False - -# lifetime = False - -# if curvature: length = True -# if orientation: comp_cell_contrib = True -# if intersection: -# if link_interc_def: -# deformation = True -# if link_interc_len: -# link_interc_lifetime = True -# if link_interc_lifetime: -# intersection = True -# lifetime = True -# if lifetime: -# if not read_tracking: -# lifetime=False -# print "Please activate reading of tracking data first" - - -# force_recompute = False - -# # Meta data statistics - -# def runmean(data,win): -# datam = np.zeros(data.size-win+1) -# for i in range(win): -# datam += data[i:(data.size+1-win+i)] -# return datam/float(win) - - -# if num_time: -# fig,ax = plt.subplots(nrows=1,ncols=1) -# for lkfyear in lkf_meta: -# ax.plot(lkfyear[:,0],lkfyear[:,2],color='0.5', -# linestyle='',marker='.') -# ax.plot(lkfyear[2:-2,0],runmean(lkfyear[:,2].astype('float'),5),'k') -# ax.set_ylabel('Number of detected features') -# fig.savefig(plot_output_path + 'Num_lkfs.pdf') - - -# # Data statistics - -# # 1. Length of LKFs - -# def power_law_fit(x,y): -# coeff = np.polyfit(np.log10(x),np.log10(y),1) -# fit = np.power(10,np.polyval(coeff,np.log10(x))) -# return coeff,fit - -# if length: -# length_file = int_mem_path + 'length_%s_dataset.npy' %datatype -# if os.path.exists(length_file) and not force_recompute: -# print "Open already computed file: %s" %length_file -# lkf_length = np.load(length_file) - -# else: -# print "Compute length of segments" -# lkf_length = [] - -# for lkf_year in lkf_dataset: -# len_year = [] -# for lkf_day in lkf_year: -# len_day = [] -# for ilkf in lkf_day: -# len_day.append(np.sum(np.sqrt(np.diff(ilkf[:,indm0])**2 + -# np.diff(ilkf[:,indm1])**2))) - -# len_year.append(len_day) - -# lkf_length.append(len_year) - -# #Save output -# print "Saving computed file: %s" %length_file -# np.save(length_file,lkf_length) -# lkf_length = np.array(lkf_length) - -# # Compute histograms -# # - one plot with lines for each year -# nbins = 80 -# bins = np.logspace(1.68,3,nbins) -# bins = np.linspace(50,1000,nbins) -# style_label = 'seaborn-darkgrid' -# with plt.style.context(style_label): -# fig,ax = plt.subplots(nrows=1,ncols=1, figsize=(6,5)) -# ax.set_xlabel('LKF length in km') -# ax.set_ylabel('PDF') -# ax.set_yscale('log') -# ax.set_xscale('log') -# ax.set_xlim([50,1000]) -# colors=plt.rcParams['axes.prop_cycle'].by_key()['color'] -# for iyear in range(len(lkf_length)): -# pdf_length, bins_length = np.histogram(np.concatenate(lkf_length[iyear])/1e3, -# bins=bins, density=True) -# bins_mean = 0.5*(bins_length[1:]+bins_length[:-1]) -# if iyear==0: -# ax.plot(bins_mean, pdf_length,color='0.5',alpha=0.5,label="single years") -# else: -# ax.plot(bins_mean, pdf_length,color='0.5',alpha=0.5) - -# pdf_length, bins_length = np.histogram(np.concatenate([np.concatenate(lkf_length[iyear]) for iyear in range(len(lkf_length))])/1e3, -# bins=bins, density=True) -# bins_mean = 0.5*(bins_length[1:]+bins_length[:-1]) -# ax.plot(bins_mean, pdf_length,color=colors[1],alpha=1.0,label="all years") - -# coeff,pl_fit = power_law_fit(bins_mean[bins_mean<=600], pdf_length[bins_mean<=600]) - -# ax.plot(bins_mean[bins_mean<=600], pl_fit,color=colors[1],alpha=1.0,linestyle='--',label="power-law fit\nexponent %.2f" %(-coeff[0])) -# ax.plot(bins_mean[bins_mean>600], -# np.power(10,np.polyval(coeff,np.log10(bins_mean[bins_mean>600]))), -# color=colors[1],alpha=1.0,linestyle=':') - -# ax.legend() - -# fig.savefig(plot_output_path + 'length_pdf.pdf') - - - -# # 2. Density - -# if density: -# density_file = int_mem_path + 'density_%s_dataset.npy' %datatype -# # Mapping grid -# res = 50e3 -# xedg = np.arange(m.xmin,m.xmax,res) -# yedg = np.arange(m.ymin,m.ymax,res) -# y,x = np.meshgrid(yedg[1:],xedg[1:]) - -# if os.path.exists(density_file) and not force_recompute: -# print "Open already computed file: %s" %density_file -# lkf_density = np.load(density_file) - -# else: -# print "Compute density of segments" -# res = 50e3 -# lkf_density = np.zeros((len(lkf_dataset),xedg.size-1,yedg.size-1)) - -# for iyear in range(len(lkf_dataset)): -# lkf_year = np.concatenate(np.concatenate(lkf_dataset[iyear])) -# H, xedges, yedges = np.histogram2d(lkf_year[:,indm0], lkf_year[:,indm1], -# bins=(xedg, yedg)) -# lkf_density[iyear,:,:] = H - -# #Save output -# print "Saving computed file: %s" %density_file -# np.save(density_file,lkf_density) - -# norm_coverage = True -# if norm_coverage: -# if datatype=='rgps': -# cov_dict = np.load(lkf_path + 'coverage_%s.npz' %datatype) -# coverage = cov_dict['coverage'] -# lon_cov = cov_dict['lon']; lat_cov = cov_dict['lat'] -# x_cov,y_cov = m(lon_cov,lat_cov) -# coverage_map = np.zeros((coverage.shape[0],xedg.size-1,yedg.size-1)) -# for iyear in range(coverage.shape[0]): -# coverage_map[iyear,:,:], xedges, yedges = np.histogram2d(x_cov.flatten(), -# y_cov.flatten(), -# bins=(xedg, yedg), -# weights=coverage[iyear,:,:].flatten()) - -# elif datatype == 'mitgcm_2km': -# lon_cov, lat_cov = read_latlon(grid_path) -# mask = mask_arcticbasin(grid_path,read_latlon) -# index_x = np.where(np.sum(mask[1:-1,1:-1],axis=0)>0) -# index_y = np.where(np.sum(mask[1:-1,1:-1],axis=1)>0) -# red_fac = 3 # Take only every red_fac point to reduce array size -# lon_cov = lon_cov[index_y[0][0]-1:index_y[0][-1]+2:red_fac, -# index_x[0][0]-1:index_x[0][-1]+2:red_fac] -# lat_cov = lat_cov[index_y[0][0]-1:index_y[0][-1]+2:red_fac, -# index_x[0][0]-1:index_x[0][-1]+2:red_fac] -# mask = mask[index_y[0][0]-1:index_y[0][-1]+2:red_fac, -# index_x[0][0]-1:index_x[0][-1]+2:red_fac] -# x_cov,y_cov = m(lon_cov[mask],lat_cov[mask]) -# coverage_map = np.zeros((len(years),xedg.size-1,yedg.size-1)) -# for iyear in range(coverage_map.shape[0]): -# coverage_map[iyear,:,:], xedges, yedges = np.histogram2d(x_cov.flatten(), -# y_cov.flatten(), -# bins=(xedg, yedg)) -# coverage_map[iyear,:,:] *= len(lkf_dataset[iyear]) - - - -# for iyear in range(len(lkf_dataset)): -# H = lkf_density[iyear,:,:].copy() - -# # Plot density for year -# fig,ax = plt.subplots(nrows=1,ncols=1) -# if norm_coverage: -# H /= coverage_map[iyear,:,:] -# pcm = m.pcolormesh(x,y,np.ma.masked_where(np.isnan(H) | (H==0),H), -# vmin=0,vmax=0.2) -# m.drawcoastlines() -# cb = plt.colorbar(pcm) -# cb.set_label('Relative LKF frequency') -# ax.set_title('Year: %s' %years[iyear]) - -# # Plot Cummulated density -# #style_label = 'seaborn-darkgrid' -# #with plt.style.context(style_label): -# fig,ax = plt.subplots(nrows=1,ncols=2,figsize=(8.4,6),gridspec_kw={'width_ratios':[12,1]}) -# H = np.sum(lkf_density,axis=0) -# if norm_coverage: -# H /= np.sum(coverage_map,axis=0) -# H = np.ma.masked_where(np.sum(coverage_map,axis=0)<500,H) -# pcm = ax[0].pcolormesh(x,y,np.ma.masked_where(np.isnan(H) | (H==0),H), -# vmin=0,vmax=0.2) -# m.drawcoastlines(ax=ax[0]) -# m.fillcontinents(ax=ax[0],color=(0.9176470588235294, 0.9176470588235294, 0.9490196078431372, 1.0),lake_color='w') -# cb = plt.colorbar(pcm,cax=ax[1]) -# cb.set_label('Relative LKF frequency') -# cb.outline.set_visible(False) -# #ax.set_title('Average over entire data set') -# ax[0].axis('off') - -# fig.savefig(plot_output_path + 'Density_all_paper.pdf') - - - - -# # 3. Curvature - -# if curvature: -# curvature_file = int_mem_path + 'curvature_%s_dataset.npy' %datatype -# if os.path.exists(curvature_file) and not force_recompute: -# print "Open already computed file: %s" %curvature_file -# lkf_curvature = np.load(curvature_file) - -# else: -# print "Compute curvature of segments" -# lkf_curvature = [] - -# for lkf_year in lkf_dataset: -# curv_year = [] -# for lkf_day in lkf_year: -# curv_day = [] -# for ilkf in lkf_day: -# curv_day.append(np.sum(np.sqrt((ilkf[0,indm0]-ilkf[-1,indm0])**2 + -# (ilkf[0,indm1]-ilkf[-1,indm1])**2))) - -# curv_year.append(curv_day) - -# lkf_curvature.append(curv_year) - -# #Save output -# print "Saving computed file: %s" %curvature_file -# np.save(curvature_file,lkf_curvature) -# lkf_curvature = np.array(lkf_curvature) - -# # Plot curvature -# for iyear in range(len(lkf_dataset)): -# fig,ax = plt.subplots(nrows=1,ncols=1) -# ax.plot(np.concatenate(lkf_length[iyear])/1e3, -# np.concatenate(lkf_curvature[iyear])/1e3,'.') -# ax.plot([0,1700],[0,1700],'k--') -# ax.set_xlabel('LKF Length') -# ax.set_ylabel('Distance between LKF endpoints') -# ax.set_title('Winter %s/%s' %(years[iyear][1:3],years[iyear][3:])) - -# fig.savefig(plot_output_path + 'Curvature_year_' + years[iyear]+'.pdf') - - - -# # 4. Compute orientation - - -# # Compute cell that an LKF contributes to - -# # Mapping grid -# res = 200e3 -# xedg = np.arange(m.xmin,m.xmax,res) -# yedg = np.arange(m.ymin,m.ymax,res) -# y,x = np.meshgrid(0.5*(yedg[1:]+yedg[:-1]), -# 0.5*(xedg[1:]+xedg[:-1])) - - -# if comp_cell_contrib: -# cell_contrib_file = int_mem_path + 'cell_contrib_lkf_%s_dataset_%i_poly_%i.npy' %(datatype,res,use_poly_ori) -# if os.path.exists(cell_contrib_file) and not force_recompute: -# print "Open already computed file: %s" %cell_contrib_file -# cell_contrib = np.load(cell_contrib_file) - -# else: -# print "Compute cell contributions of lkfs" -# cell_contrib = [] - -# for lkf_year in lkf_dataset: -# cell_contrib_year = [] -# for lkf_day in lkf_year: -# cell_contrib_day = [] -# for ilkf in lkf_day: -# if use_poly_ori: -# H, xedges, yedges = np.histogram2d(ilkf[:,indp0], ilkf[:,indp1], -# bins=(xedg, yedg)) -# else: -# H, xedges, yedges = np.histogram2d(ilkf[:,indm0], ilkf[:,indm1], -# bins=(xedg, yedg)) -# cell_contrib_day.append(np.where(H.flatten()>0)[0]) - -# cell_contrib_year.append(cell_contrib_day) - -# cell_contrib.append(cell_contrib_year) - -# #Save output -# print "Saving computed file: %s" %cell_contrib_file -# np.save(cell_contrib_file,cell_contrib) -# cell_contrib = np.array(cell_contrib) - - - -# # Compute orientation - -# if orientation: -# orientation_file = int_mem_path + 'orientation_%s_dataset_%i_poly_%i.npy' %(datatype,res,use_poly_ori) -# ori_len_wght_file = int_mem_path + 'ori_len_wght_%s_dataset_%i_poly_%i.npy' %(datatype,res,use_poly_ori) -# if os.path.exists(orientation_file) and os.path.exists(ori_len_wght_file) and not force_recompute: -# print "Open already computed file: %s" %orientation_file -# lkf_orientation = np.load(orientation_file) -# lkf_ori_len_wght = np.load(ori_len_wght_file) - -# else: -# print "Compute orientation of segments" -# lkf_orientation = [] -# lkf_ori_len_wght = [] - -# ori_day_org = np.empty((x.shape),dtype=object) -# for ix in range(xedg.size-1): -# for iy in range(yedg.size-1): -# ori_day_org[ix,iy] = np.array([]) - -# for iyear,lkf_year in enumerate(lkf_dataset): -# ori_year = [] -# ori_len_year = [] -# for iday,lkf_day in enumerate(lkf_year): -# ori_day = ori_day_org.copy() -# ori_len_day = ori_day_org.copy() -# for ilkf,lkf_i in enumerate(lkf_day): -# for i_cell in cell_contrib[iyear][iday][ilkf]: -# # Find part of lkf inside box -# ix,iy = np.unravel_index(i_cell,x.shape) -# if use_poly_ori: -# lkf_i_c = lkf_i[:,indp0:indp0+2][np.all([lkf_i[:,indp0]>=xedg[ix], -# lkf_i[:,indp0]<=xedg[ix+1], -# lkf_i[:,indp1]>=yedg[iy], -# lkf_i[:,indp1]<=yedg[iy+1]], -# axis=0),:] -# else: -# lkf_i_c = lkf_i[:,indm0:indm0+2][np.all([lkf_i[:,indm0]>=xedg[ix], -# lkf_i[:,indm0]<=xedg[ix+1], -# lkf_i[:,indm1]>=yedg[iy], -# lkf_i[:,indm1]<=yedg[iy+1]], -# axis=0),:] - -# # Linear fit & determine angle from linear fit -# if lkf_i_c.size > 2: -# # All cases that are not a line in y-direction -# p_x,p_y = lkf_poly_fit_p(lkf_i_c[:,0],lkf_i_c[:,1], -# 1) # Linear fit -# p = p_y[0]/p_x[0] - -# # Determin angle from linear fit -# if np.isnan(p): -# ang = 90. -# else: -# ang = np.arctan(p)/np.pi*180. - -# ori_day[ix,iy] = np.concatenate([ori_day[ix,iy], -# np.array([ang])]) -# ori_len_day[ix,iy] = np.concatenate([ori_len_day[ix,iy], -# np.array([lkf_i_c.shape[0]])]) - - -# ori_year.append(ori_day) -# ori_len_year.append(ori_len_day) - -# lkf_orientation.append(ori_year) -# lkf_ori_len_wght.append(ori_len_year) - -# #Save output -# print "Saving computed file: %s" %orientation_file -# np.save(orientation_file,lkf_orientation) -# np.save(ori_len_wght_file,lkf_ori_len_wght) -# lkf_orientation = np.array(lkf_orientation) -# lkf_ori_len_wght = np.array(lkf_ori_len_wght) - - - - -# # Define function to plot radial histogram -# def plot_radial_hist(ang,wght,x0,y0,max_rad,nbins=10,ax=plt.gca,color='b'): -# if nbins%2==1: nbins += 1. -# binint=180/float(nbins) -# bins = np.arange(-90+binint/2.,90+binint,binint) -# ang[ang90] = np.abs(ang[ang_diff>90]-180.-ang_m) -# return np.sqrt(np.sum(ang_diff**2*wght)/np.sum(wght)) - -# def chisquare_sig(ang,wght,nchi=int(1e4),nbins=10,pmax=0.01): -# p = np.zeros((nchi,)) - -# # Relative frequency of observed orientations -# binint=180/float(nbins); bins = np.arange(-90,90+binint/2.,binint) -# hist_obs,bins_ang = np.histogram(ang,bins,weights=wght) - -# for i in range(nchi): -# # Create random distribution -# ang_rand = 180.*np.random.random((int(wght.sum()),)) - 90. -# hist_rand,bins_ang = np.histogram(ang_rand,bins) -# # Chi squared test -# chisq, p[i] = scipy.stats.chisquare(hist_rand/float(ang.size), -# hist_obs/float(wght.sum())) - -# p_mean = p.mean() -# return p_mean<=pmax, p_mean - - -# def map_rad_hist(ori,ori_wght,x,y,res,nbins=8,color='b'): -# fig,ax = plt.subplots(nrows=1,ncols=1) -# m.drawcoastlines(ax=ax) -# for ix in range(ori.shape[0]): -# for iy in range(ori.shape[1]): -# plot_radial_hist(ori[ix,iy],ori_wght[ix,iy],x[ix,iy],y[ix,iy], -# res/2,nbins=nbins,ax=ax,color=color) - -# def map_mean_std_ori(ori,ori_wght,x,y,res,color='b', -# do_chi=False,nchi=int(1e4),nbins=10,pmax=0.01, -# color_dens=True): -# fig,ax = plt.subplots(nrows=1,ncols=1,figsize=(8,6)) -# m.drawcoastlines(ax=ax) -# std_bounds = [0,15,30,45,180] -# std_linew = [0.5,1,1.5,2.] -# if color_dens: -# ori_dens = np.zeros(ori.shape) -# for ix in range(ori.shape[0]): -# for iy in range(ori.shape[1]): -# ori_dens[ix,iy] = ori[ix,iy].size -# dens_max = np.ceil(ori_dens.max()/100.)*100. -# dens_min = np.floor(ori_dens.min()/100.)*100. -# cm_dens = plt.get_cmap('plasma',100) -# # plt.figure();m.drawcoastlines(); m.pcolormesh(x,y,ori_dens);plt.colorbar() -# # print dens_max,dens_min - -# for ix in range(ori.shape[0]): -# for iy in range(ori.shape[1]): -# # Compute mean, std and chi squared test -# ang_mean = average_angle(ori[ix,iy],ori_wght[ix,iy]) -# ang_std = std_angle(ori[ix,iy],ori_wght[ix,iy],ang_mean) -# std_class = np.floor(ang_std/15.); -# if std_class>len(std_linew)-1: std_class=len(std_linew)-1 - - -# # Plot direction -# if ~np.isnan(ang_std): -# if color_dens: -# color = cm_dens((ori_dens[ix,iy]-dens_min)/float(dens_max-dens_min)) -# ax.plot([x[ix,iy]-res/2.*np.cos(ang_mean/180.*np.pi), -# x[ix,iy]+res/2.*np.cos(ang_mean/180.*np.pi)], -# [y[ix,iy]-res/2.*np.sin(ang_mean/180.*np.pi), -# y[ix,iy]+res/2.*np.sin(ang_mean/180.*np.pi)], -# color=color,linewidth=std_linew[int(std_class)]) -# if do_chi: -# chi,p = chisquare_sig(ori[ix,iy],ori_wght[ix,iy], -# nchi=nchi,nbins=nbins,pmax=pmax) -# if chi: -# ax.plot(x[ix,iy],y[ix,iy],'k.') - -# if color_dens: -# ax_pos = ax.get_position().get_points() -# mar = (ax_pos[0,0] + 1-(ax_pos[1,0]))/2. -# mar_cbar = 0.005 -# ax.set_position([mar/2.,ax_pos[0,1],ax_pos[1,0]-ax_pos[0,0], -# ax_pos[1,1]-ax_pos[0,1]]) -# cax = fig.add_axes([mar/2.+ax_pos[1,0]-ax_pos[0,0]+mar_cbar, ax_pos[0,1], -# 0.3*mar-2*mar_cbar, ax_pos[1,1]-ax_pos[0,1]]) -# print ax.get_position(), cax.get_position() -# norm = mpl.colors.Normalize(vmin=dens_min, vmax=dens_max) -# cb1 = mpl.colorbar.ColorbarBase(cax, cmap=cm_dens,norm=norm) -# cb1.set_label('Number of LKFs') - -# for i in range(len(std_linew)): -# ax.plot([m.xmin,m.xmin],[m.ymin,m.ymin],linewidth=std_linew[i],color='k', -# label = "%i - %i deg std" %(std_bounds[i],std_bounds[i+1])) - -# ax.legend(loc="upper left",title='STD') - -# return fig - - -# # Plot orientation in radial histograms - -# if orientation: -# ori_org = np.empty((x.shape),dtype=object) -# for ix in range(xedg.size-1): -# for iy in range(yedg.size-1): -# ori_org[ix,iy] = np.array([]) - -# ori = [] -# ori_wght = [] - -# for iyear,lkf_year in enumerate(lkf_dataset): -# ori_month = np.stack([ori_org.copy() for i in range(12)]) -# ori_wght_month = np.stack([ori_org.copy() for i in range(12)]) -# for iday,lkf_day in enumerate(lkf_year): -# imonth = lkf_meta[iyear][iday][0].month - 1 -# for ix in range(ori_month.shape[1]): -# for iy in range(ori_month.shape[2]): -# ori_month[imonth,ix,iy] = np.concatenate([ori_month[imonth,ix,iy], -# lkf_orientation[iyear][iday][ix,iy]]) -# ori_wght_month[imonth,ix,iy] = np.concatenate([ori_wght_month[imonth,ix,iy], -# lkf_ori_len_wght[iyear][iday][ix,iy]]) - -# ori.append(ori_month) -# ori_wght.append(ori_wght_month) - - -# ori_mean = ori_org.copy() -# ori_wght_mean = ori_org.copy() -# ori_year_mean = np.stack([ori_org.copy() for i in range(len(years))]) -# ori_wght_year_mean = np.stack([ori_org.copy() for i in range(len(years))]) -# ori_month_mean = np.stack([ori_org.copy() for i in range(12)]) -# ori_wght_month_mean = np.stack([ori_org.copy() for i in range(12)]) - -# for iyear,lkf_year in enumerate(lkf_dataset): -# for imonth in range(12): -# for ix in range(ori_month_mean.shape[1]): -# for iy in range(ori_month_mean.shape[2]): -# ori_month_mean[imonth,ix,iy] = np.concatenate([ori_month_mean[imonth,ix,iy], -# ori[iyear][imonth,ix,iy]]) -# ori_wght_month_mean[imonth,ix,iy] = np.concatenate([ori_wght_month_mean[imonth,ix,iy], -# ori_wght[iyear][imonth,ix,iy]]) -# ori_year_mean[iyear,ix,iy] = np.concatenate([ori_year_mean[iyear,ix,iy], -# ori[iyear][imonth,ix,iy]]) -# ori_wght_year_mean[iyear,ix,iy] = np.concatenate([ori_wght_year_mean[iyear,ix,iy], -# ori_wght[iyear][imonth,ix,iy]]) - -# ori_mean[ix,iy] = np.concatenate([ori_mean[ix,iy],ori[iyear][imonth,ix,iy]]) -# ori_wght_mean[ix,iy] = np.concatenate([ori_wght_mean[ix,iy], -# ori_wght[iyear][imonth,ix,iy]]) - - - - - -# if plot_ori_mean: -# if plot_rad_hist: -# # Plot radial histogram for mean orientation of data set -# map_rad_hist(ori_mean,ori_wght_mean,x,y,res,nbins=8,color='b') - -# if plot_broehan: -# # Plot mean orientation of data set with std as linewidth -# fig = map_mean_std_ori(ori_mean,ori_wght_mean,x,y,res,color='b', -# do_chi=True,nchi=int(1e4),nbins=20,pmax=0.01, -# color_dens=True) -# fig.savefig(plot_output_path + 'Mean_ori_all_200.pdf') - - - - -# # 5. Deformation rate diagram - -# if deformation: -# deformation_file = int_mem_path + 'deformation_%s_dataset.npy' %datatype -# if os.path.exists(deformation_file) and not force_recompute: -# print "Open already computed file: %s" %deformation_file -# lkf_deformation = np.load(deformation_file) - -# else: -# print "Compute deformation of segments" -# lkf_deformation = [] - -# for lkf_year in lkf_dataset: -# defo_year = [] -# for lkf_day in lkf_year: -# defo_day = [] -# for ilkf in lkf_day: -# defo_day.append([np.mean(ilkf[:,indd0]),np.mean(ilkf[:,indd1])]) - -# defo_year.append(defo_day) - -# lkf_deformation.append(defo_year) - -# #Save output -# print "Saving computed file: %s" %deformation_file -# np.save(deformation_file,lkf_deformation) -# lkf_deformation = np.array(lkf_deformation) - -# deform_all = np.vstack([np.vstack([np.stack([np.array(iseg) for iseg in lkf_deformation[i][j]]) -# for j in range(len(lkf_deformation[i]))]) -# for i in range(len(lkf_dataset))]) - -# shr_lim = [0,0.3] -# div_lim = [-0.15,0.15] -# nbins_shr = 500 -# nbins_div = 500 - -# hist2d,div_edg,shr_edg = np.histogram2d(deform_all[:,0], deform_all[:,1], -# [np.linspace(div_lim[0],div_lim[1],nbins_div), -# np.linspace(shr_lim[0],shr_lim[1],nbins_shr)], -# ) -# hist2d = np.ma.masked_where(hist2d==0,hist2d) - -# fig,ax = plt.subplots(nrows=1,ncols=1,figsize=(8,6)) -# hist_lims = [2,300/4] -# pcm = ax.pcolormesh(shr_edg,div_edg,np.ma.masked_where(hist2d==0,hist2d), -# norm=mpl.colors.LogNorm(vmin=hist_lims[0], vmax=hist_lims[1])) -# ax.plot([shr_edg[0],shr_edg[-1]],[0,0],'k--') -# ax.set_ylabel('Divergence rate [1/day]') -# ax.set_xlabel('Shear rate [1/day]') -# ax.set_aspect('equal') -# cb = fig.colorbar(pcm, ax=ax, extend='both') -# cb.set_label('Number of LKFs') - -# fig.savefig(plot_output_path + 'deformation_shr_div_hist.pdf') - - -# # 6. Intersections angles - -# if intersection: -# pos_type = 'poly' -# if pos_type=='ind': -# indc0 = 0; indc1 = 1; -# if pos_type=='m': -# indc0 = indm0; indc1 = indm1; -# if pos_type=='poly': -# indc0 = indp0; indc1 = indp1; -# num_p = 10 # Number of points on each side of the intersection -# # contribute to the orientation computation - -# interc_file = int_mem_path + 'interc_%s_dataset_num%i_%s.npy' %(datatype, num_p, pos_type) -# interc_par_file = int_mem_path + 'interc_par_%s_dataset_num%i_%s.npy' %(datatype, num_p, pos_type) - -# if os.path.exists(interc_file) and os.path.exists(interc_par_file) and not force_recompute: -# print "Open already computed file: %s" %interc_file -# lkf_interc = np.load(interc_file) -# lkf_interc_par = np.load(interc_par_file) - -# else: -# print "Compute interc of segments" - -# if datatype == 'mitgcm_2km': -# mask = mask_arcticbasin(grid_path,read_latlon) -# index_x = np.where(np.sum(mask[1:-1,1:-1],axis=0)>0) -# index_y = np.where(np.sum(mask[1:-1,1:-1],axis=1)>0) -# red_fac = 3 # Take only every red_fac point to reduce array size - - -# lkf_interc = [] -# lkf_interc_par = [] -# for iyear in range(len(lkf_dataset)): -# intc_ang_year = [] -# intc_par_year = [] -# for iday in range(len(lkf_dataset[iyear])): -# if datatype == 'rgps': -# lkf_map = np.zeros((248,264)) -# elif datatype == 'mitgcm_2km': -# lkf_map = np.zeros((int(np.ceil((index_y[0][-1]+1-index_y[0][0]+1)/3.)), -# int(np.ceil((index_x[0][-1]+1-index_x[0][0]+1)/3.)))) - - -# for iseg, seg_i in enumerate(lkf_dataset[iyear][iday]): -# lkf_map[seg_i[:,0].astype('int'),seg_i[:,1].astype('int')] += iseg - -# intc_ang_day = [] -# intc_par_day = [] - -# # Check for possible intersection partners -# for iseg, seg_i in enumerate(lkf_dataset[iyear][iday]): -# search_ind = np.zeros(lkf_map.shape).astype('bool') -# search_ind[seg_i[:,0].astype('int')+1,seg_i[:,1].astype('int') ] = True -# search_ind[seg_i[:,0].astype('int')-1,seg_i[:,1].astype('int') ] = True -# search_ind[seg_i[:,0].astype('int') ,seg_i[:,1].astype('int')+1] = True -# search_ind[seg_i[:,0].astype('int') ,seg_i[:,1].astype('int')-1] = True -# search_ind[seg_i[:,0].astype('int')+1,seg_i[:,1].astype('int')+1] = True -# search_ind[seg_i[:,0].astype('int')-1,seg_i[:,1].astype('int')-1] = True -# search_ind[seg_i[:,0].astype('int')-1,seg_i[:,1].astype('int')+1] = True -# search_ind[seg_i[:,0].astype('int')+1,seg_i[:,1].astype('int')-1] = True -# search_ind[seg_i[:,0].astype('int') ,seg_i[:,1].astype('int') ] = False - -# intercep_points = np.where(search_ind & (lkf_map!=0)) - -# intercep_partners, intercep_counts = np.unique(lkf_map[intercep_points], -# return_counts=True) - -# for ipar,pari in enumerate(intercep_partners): -# if pari > iseg and pari < len(lkf_dataset[iyear][iday]): -# # Determine one intercetion point for pair -# dis_intercep = np.zeros(intercep_counts[ipar]) -# for iintc in range(intercep_counts[ipar]): -# dis_intercep[iintc] = np.min(np.sqrt((seg_i[:,0] - -# intercep_points[0][lkf_map[intercep_points]==pari][iintc])**2 + -# (seg_i[:,1] - -# intercep_points[1][lkf_map[intercep_points]==pari][iintc])**2)) -# intcp = (intercep_points[0][lkf_map[intercep_points]==pari][np.argmin(dis_intercep)], -# intercep_points[1][lkf_map[intercep_points]==pari][np.argmin(dis_intercep)]) - -# # Determine angle between both pairs -# # # Determine orientation of seg_i -# ind = np.argmin(np.sqrt((seg_i[:,0] - intcp[0])**2 + -# (seg_i[:,1] - intcp[1])**2)) -# ind = np.array([np.max([0,ind-num_p]), -# np.min([seg_i.shape[0],ind+num_p+1])]) -# p_x,p_y = lkf_poly_fit_p(seg_i[ind[0]:ind[1],indc0], -# seg_i[ind[0]:ind[1],indc1],1) # Linear fit -# p = p_y[0]/p_x[0] -# # # Determin angle from linear fit -# if np.isnan(p): -# ang_i = 90. -# else: -# ang_i = np.arctan(p)/np.pi*180. - -# # # Determine orientation of pari -# lkf_par = lkf_dataset[iyear][iday][int(pari)] -# ind = np.argmin(np.sqrt((lkf_par[:,0] - intcp[0])**2 + -# (lkf_par[:,1] - intcp[1])**2)) -# ind = np.array([np.max([0,ind-num_p]), -# np.min([lkf_par.shape[0],ind+num_p+1])]) -# p_x,p_y = lkf_poly_fit_p(lkf_par[ind[0]:ind[1],indc0], -# lkf_par[ind[0]:ind[1],indc1],1) # Linear fit -# p = p_y[0]/p_x[0] -# # # Determin angle from linear fit -# if np.isnan(p): -# ang_ii = 90. -# else: -# ang_ii = np.arctan(p)/np.pi*180. - -# angdiff = np.abs(ang_ii-ang_i) -# if angdiff > 90: angdiff=180-angdiff -# intc_ang_day.append(angdiff) -# intc_par_day.append(np.array([iseg,pari])) - -# intc_ang_year.append(intc_ang_day) -# intc_par_year.append(intc_par_day) -# lkf_interc.append(intc_ang_year) -# lkf_interc_par.append(intc_par_year) - -# #Save output -# print "Saving computed file: %s" %interc_file -# np.save(interc_file,lkf_interc) -# np.save(interc_par_file,lkf_interc_par) - -# lkf_interc = np.array(lkf_interc) -# lkf_interc_par = np.array(lkf_interc_par) - - -# # Compute histograms -# # - one plot with lines for each year -# nbins = 45 -# bins = np.linspace(0,90,nbins) -# fig,ax = plt.subplots(nrows=1,ncols=1) -# ax.set_xlabel('Intersection angle') -# ax.set_ylabel('PDF') -# ax.set_xlim([0,90]) -# for iyear in range(len(lkf_interc)): -# pdf_interc, bins_interc = np.histogram(np.concatenate(lkf_interc[iyear]), -# bins=bins, density=True) -# bins_mean = 0.5*(bins_interc[1:]+bins_interc[:-1]) -# ax.plot(bins_mean, pdf_interc,label=years[iyear],color='0.5',alpha=0.5) - -# pdf_interc, bins_interc = np.histogram(np.concatenate([np.concatenate(lkf_interc[iyear]) for iyear in range(len(lkf_interc))]), -# bins=bins, density=True) -# bins_mean = 0.5*(bins_interc[1:]+bins_interc[:-1]) -# ax.plot(bins_mean, pdf_interc,label=years[iyear],color='k',alpha=1.0) - -# #ax.legend() -# fig.savefig(plot_output_path + 'interc_pdf.pdf') - - - -# # Plot intersection angle statistics depending on deformation rate -# if link_interc_def: -# # Compute mean deformation of intersecting partners -# def_par = []; diff_def_par = []; -# for iyear in range(len(lkf_dataset)): -# def_par_year = []; diff_def_par_year = []; -# for iday in range(len(lkf_dataset[iyear])): -# def_par_day = np.array([np.sqrt(np.sum(np.array(lkf_deformation[iyear][iday])[np.stack(lkf_interc_par[iyear][iday])[:,0].astype('int')]**2,axis=1)), -# np.sqrt(np.sum(np.array(lkf_deformation[iyear][iday])[np.stack(lkf_interc_par[iyear][iday])[:,1].astype('int')]**2,axis=1))]) -# diff_def_par_day = np.abs(np.diff(def_par_day,axis=0)) - -# def_par_year.append(def_par_day) -# diff_def_par_year.append(diff_def_par_day) -# def_par.append(def_par_year) -# diff_def_par.append(diff_def_par_year) - - -# # Plot histograms in different deformation rate classes -# fig,ax = plt.subplots(nrows=1,ncols=3,figsize=(12,4.8)) -# if datatype=='rgps': -# def_class = [0,0.03,0.05,2] -# elif datatype == 'mitgcm_2km': -# def_class = [0,0.05,0.2,10] -# nbins = 45 -# bins = np.linspace(0,90,nbins) -# def_masked_class = [[],[],[]] -# for iax,axi in enumerate(ax): -# axi.set_title('Def. class: %.2f to %.2f [1/day]' %(def_class[iax],def_class[iax+1])) -# axi.set_xlabel('Intersection angle') -# axi.set_ylabel('PDF') -# axi.set_xlim([0,90]) - -# for iyear in range(len(lkf_interc)): -# mask_def = np.all([np.all(np.hstack(def_par[iyear])>=def_class[iax],axis=0), -# np.all(np.hstack(def_par[iyear])0: -# life_year[it+1][itrack[:,1].astype('int')] += life_year[it][itrack[:,0].astype('int')] - -# lkf_lifetime.append(life_year) - -# #Save output -# print "Saving computed file: %s" %lifetime_file -# np.save(lifetime_file,lkf_lifetime) -# lkf_lifetime = np.array(lkf_lifetime) - - -# # Generate Plots -# # One plot for each year -# for iyear in range(len(lkf_lifetime)): -# #fig,ax = plt.subplots(nrows=1,ncols=2) -# fig, ax = plt.subplots(nrows=1, ncols=3, figsize=(10,4), -# gridspec_kw={'width_ratios':[4,4,1]}) - -# # Determine all existing lifetimes -# lt_max = np.max([np.max(ilife) for ilife in lkf_lifetime[iyear]]) -# lt_class = np.arange(lt_max)+1 - - -# # Compute the percentage of each lifetime for each timeslice -# lt_perc = np.zeros((len(lkf_lifetime[iyear]),lt_class.size)) -# lt_abs = np.zeros((len(lkf_lifetime[iyear]),lt_class.size)) -# for it,ilife in enumerate(lkf_lifetime[iyear]): -# for ilt in lt_class: -# lt_perc[it,int(ilt-1)] = np.sum(ilife==ilt)/float(ilife.size) -# lt_abs[it,int(ilt-1)] = np.sum(ilife==ilt) - -# # Make plot -# cmap = plt.get_cmap('viridis') -# col = cmap(np.linspace(0,1,lt_class.size)) - -# for ic in range(lt_class.size): -# ax[0].plot(3*np.arange(len(lkf_lifetime[iyear])), np.array(lt_perc[:,ic])*100, -# color = col[ic]) - -# # Make line plot absolute lifetime numbers -# for ic in range(lt_class.size): -# ax[1].plot(3*np.arange(len(lkf_lifetime[iyear])), np.array(lt_abs[:,ic]), -# color = col[ic]) - -# # Labeling x axis -# xax = [ax[0],ax[1]] -# for iax in xax: iax.set_xlabel('Time [days]') - -# # Plot colorbar -# norm = mpl.colors.Normalize(vmin=1, vmax=lt_max) -# cbar = mpl.colorbar.ColorbarBase(ax[2], cmap=cmap,norm=norm) -# cbar.set_label('Lifetime [days]') - -# # Labeling yaxis -# ax[0].set_ylabel('Fraction [%]') -# ax[1].set_ylabel('Absolute numbers') - -# # Compute histograms -# # - one plot with lines for each year -# style_label = 'seaborn-darkgrid' -# with plt.style.context(style_label): -# fig,ax = plt.subplots(nrows=1,ncols=1, figsize=(6,5)) -# ax.set_xlabel('LKF lifetime') -# ax.set_ylabel('Relative frequency') -# ax.set_yscale('log') -# ax.set_xlim([0,31]) -# colors=plt.rcParams['axes.prop_cycle'].by_key()['color'] -# for iyear in range(len(lkf_length)): -# pdf_life = np.bincount(np.concatenate(lkf_lifetime[iyear]).astype('int')-1) -# bins_mean = np.arange(pdf_life.size)*3+1.5 -# if iyear==0: -# ax.plot(bins_mean, pdf_life/float(np.sum(pdf_life)),'.',color='0.5',alpha=0.5,label="single years") -# else: -# ax.plot(bins_mean, pdf_life/float(np.sum(pdf_life)),'.',color='0.5',alpha=0.5) - -# pdf_life = np.bincount(np.concatenate([np.concatenate(lkf_lifetime[iyear]) for iyear in range(len(lkf_lifetime))]).astype('int')-1) -# bins_mean = np.arange(pdf_life.size)*3+1.5 -# ax.plot(bins_mean, pdf_life/float(np.sum(pdf_life)),'.',color=colors[1],alpha=1.0,label="all years") - -# coeff = np.polyfit(bins_mean, np.log(pdf_life/float(np.sum(pdf_life))),1) -# pdf_life_fit = np.exp(np.polyval(coeff,bins_mean)) -# ax.plot(bins_mean,pdf_life_fit,color=colors[1],alpha=1.0,linestyle='--',label="exponential fit\nexponent %.2f" %(-coeff[0])) - -# #ax.plot(bins_mean[bins_mean<=600], pl_fit,color=colors[1],alpha=1.0,linestyle='--',label="power-law fit\nexponent %.2f" %(-coeff[0])) -# #ax.plot(bins_mean[bins_mean>600], -# # np.power(10,np.polyval(coeff,np.log10(bins_mean[bins_mean>600]))), -# # color=colors[1],alpha=1.0,linestyle=':') - -# ax.legend() - -# fig.savefig(plot_output_path + "Lifetime_distribution_exp_fit.pdf") - - -# # # Lifetime bar plot with atmospheric link -# # -# # # Load atmospheric grid -# # coord = np.load(lkf_path + 'coord_jra55.npz') -# # lat_cut = 52 + 1 -# # lon_atm = coord['lon']; lat_atm = coord['lat'][:lat_cut] -# # lon_atm,lat_atm = np.meshgrid(lon_atm,lat_atm) -# # x_atm,y_atm = m(lon_atm,lat_atm) -# # -# # # Load RGPS grid -# # lon_rgps = np.load(lkf_path+'coverage_rgps.npz')['lon'][:] -# # lat_rgps = np.load(lkf_path+'coverage_rgps.npz')['lat'][:] -# # x_rgps,y_rgps = m(lon_rgps,lat_rgps) -# # -# # # Initialize interpolation routine -# # interp_jra = griddata_fast(x_atm,y_atm,x_rgps,y_rgps) -# # -# # for iyear in range(len(lkf_lifetime)): -# # # Read Coverage of RGPS data -# # coverage = np.load(lkf_path+'coverage_rgps_%s.npz' %years[iyear])['coverage'][:] -# # -# # # Read surface pressure fields -# # year_cov = np.unique([lkf_meta[iyear][0][0].year,lkf_meta[iyear][-1][0].year]) -# # atm_file = '/work/ollie/projects/clidyn/forcing/JRA55_3h/fcst_surf.001_pres.reg_tl319.' -# # year_lkf = [imeta[0].year for imeta in lkf_meta[iyear]] -# # ncfile = Dataset('/work/ollie/projects/clidyn/forcing/JRA55_3h/fcst_surf.001_pres.reg_tl319.2000.nc','r') -# # -# # -# # # Optinal filtering of lifetimes -# # lifetime_filt = np.copy(lkf_lifetime[iyear]) -# # -# # # Determine all existing lifetimes -# # lt_max = np.max([np.max(ilife) for ilife in lifetime_filt]) -# # lt_class = np.arange(lt_max)+1 -# # -# # # Compute the percentage of each lifetime for each timeslice -# # lt_abs = np.zeros((len(lifetime_filt),lt_class.size)) -# # for it,ilife in enumerate(lifetime_filt): -# # for ilt in lt_class: -# # lt_abs[it,int(ilt-1)] = np.sum(ilife==ilt)/float(np.sum(coverage[it,:,:])) -# # -# # # Generate plot -# # fig, ax = plt.subplots(nrows=1, ncols=1)#, figsize=(10,4), -# # # gridspec_kw={'width_ratios':[4,4,1]}) -# # -# # # Make line plot absolute lifetime numbers -# # for ic in range(lt_class.size): -# # ax.plot(3*np.arange(len(lkf_lifetime[iyear])), np.array(lt_abs[:,ic]), -# # color = col[ic]) - - -# # Lifetime bar plot linked to storms - -# # Load ncep strom data set -# storms_path = '/work/ollie/nhutter/ncep_storms/' -# sys.path.append(storms_path) -# from read_ncepstorms import storms - -# storm = storms(storms_path) -# storm.filt_storms() -# storms_all = [] - -# for iyear in range(len(lkf_lifetime)): -# if datatype=='rgps': -# # Read Coverage of RGPS data -# coverage = np.load(lkf_path+'coverage_rgps_%s.npz' %years[iyear])['coverage'][:] - -# # Read surface pressure fields -# storms_year = [] -# for it in range(len(lkf_lifetime[iyear])): -# start_it = lkf_meta[iyear][it][0] -# end_it = lkf_meta[iyear][it][1] -# storms_it = storm.get_storms(start_it,end_it) -# sto_it = [] -# for ist in np.unique(storms_it[:,-1]): -# sto_it.append([ist, storms_it[storms_it[:,-1]==ist,-2].max()]) -# storms_year.append(sto_it) -# storms_all.append(storms_year) - -# # Optinal filtering of lifetimes -# lifetime_filt = np.copy(lkf_lifetime[iyear]) - -# # Determine all existing lifetimes -# lt_max = np.max([np.max(ilife) for ilife in lifetime_filt]) -# lt_class = np.arange(lt_max)+1 - -# # Compute the percentage of each lifetime for each timeslice -# lt_abs = np.zeros((len(lifetime_filt),lt_class.size)) -# for it,ilife in enumerate(lifetime_filt): -# for ilt in lt_class: -# if datatype=='rgps': -# lt_abs[it,int(ilt-1)] = np.sum(ilife==ilt)/float(np.sum(coverage[it,:,:])) -# else: -# lt_abs[it,int(ilt-1)] = np.sum(ilife==ilt) - -# # Generate plot -# fig, ax = plt.subplots(nrows=1, ncols=1)#, figsize=(10,4), -# # gridspec_kw={'width_ratios':[4,4,1]}) - -# axt = ax.twinx() - -# # Make line plot absolute lifetime numbers -# for ic in range(lt_class.size): -# ax.plot(3*np.arange(len(lkf_lifetime[iyear])), np.array(np.cumsum(lt_abs,axis=1)[:,ic]), -# color = col[ic]) - -# # Plot storms -# cmap_storm = plt.get_cmap('inferno') -# storm_stren_max = 25. -# storm_stren_min = 0. -# for it in range(len(lkf_lifetime[iyear])): -# for isto in range(len(storms_year[it])): -# axt.plot(3*it,storms_year[it][isto][1],'.', -# color=cmap_storm((storms_year[it][isto][1]-storm_stren_min)/(storm_stren_max-storm_stren_min))) - - -# # Deformation plot - -# deformation_filt = np.copy(lkf_deformation[iyear]) -# num_class = 25 -# def_class = np.linspace(0,2,num_class+1) -# def_class = np.concatenate([np.array([0]),np.logspace(-2,0.5,num_class)]) -# def_class = np.concatenate([np.logspace(-2,0.,num_class),np.array([np.inf])]) - -# lkf_def_abs = np.zeros((len(deformation_filt),num_class)) - -# for it,idef in enumerate(deformation_filt): -# lkf_def_abs[it,:],bins = np.histogram(np.sqrt(np.sum(np.array(idef)**2,axis=1)),def_class)#,weights=lkf_length[iyear][it]) -# if datatype=='rgps': -# lkf_def_abs[it,:] /= float(np.sum(coverage[it,:,:])) - -# # Generate plot -# style_label = 'seaborn-darkgrid' -# with plt.style.context(style_label): -# fig, ax = plt.subplots(nrows=2, ncols=2, figsize=(10,6), sharex='col',tight_layout=True, -# gridspec_kw={'height_ratios':[1,2],'width_ratios':[25,1]}) -# #fig = plt.figure() -# #ax = fig.add_subplot(111, projection='polar') -# #axt = ax.twinx() -# #rlim = 0.02 - -# # Make bar plot -# bottoms = np.zeros((len(deformation_filt),)) -# wid=1*3 -# cmap_def = plt.get_cmap('inferno') -# col = cmap_def(np.linspace(0,1,num_class)) - -# for ic in range(num_class): -# heights = np.array(lkf_def_abs[:,ic]) -# ax[1,0].bar(lkf_meta[iyear][:,0],#3*np.arange(len(deformation_filt)), -# heights, width = wid, bottom=bottoms, -# color = col[ic]) -# bottoms += heights - - -# # Plot storms -# cmap_storm = plt.get_cmap('YlOrRd')#inferno') -# storm_stren_max = 30. -# storm_stren_min = 0. -# for it in range(len(lkf_deformation[iyear])): -# for isto in range(len(storms_year[it])): -# ax[0,0].plot(lkf_meta[iyear][it,0],#3*it, -# storms_year[it][isto][1],'.', -# color=cmap_storm((storms_year[it][isto][1]-storm_stren_min)/(storm_stren_max-storm_stren_min))) - -# import matplotlib.dates as mdates -# months = mdates.MonthLocator(range(1, 13), bymonthday=1, interval=1) -# monthsFmt = mdates.DateFormatter("%b") - -# ax[0,0].xaxis_date() -# ax[1,0].xaxis_date() - -# ax[1,0].xaxis.set_major_locator(months) -# ax[1,0].xaxis.set_major_formatter(monthsFmt) -# ax[0,0].set_yticklabels([]) - -# ax[0,0].set_ylabel('Storm stength') -# ax[1,0].set_ylabel('No. of LKFs (normalized)') - -# # Plot storm colorbar -# norm_sto = mpl.colors.Normalize(vmin=storm_stren_min, vmax=storm_stren_max) -# norm_sto = mpl.colors.BoundaryNorm(boundaries=np.linspace(storm_stren_min, -# storm_stren_max,13) -# ,ncolors=256) -# cbar_sto = mpl.colorbar.ColorbarBase(ax[0,1], cmap=cmap_storm,norm=norm_sto) -# cbar_sto.set_label('Local Laplacian [mPa/km^2]') -# cbar_sto.outline.set_visible(False) - -# # Plot deformation colorbar -# norm_def = mpl.colors.BoundaryNorm(boundaries=def_class[:-1],ncolors=256) -# cbar_def = mpl.colorbar.ColorbarBase(ax[1,1], cmap=cmap_def,norm=norm_def) -# cbar_def.set_label('Total deformation [1/day]') -# cbar_def.outline.set_visible(False) -# ticks = [] -# for it in cbar_def.ax.yaxis.get_majorticklabels(): -# ticks.append('%.2f' %float(it.get_text())) -# cbar_def.ax.yaxis.set_ticklabels(ticks) - -# fig.savefig(plot_output_path + 'deformation_linked_storms_year_%s.pdf' %years[iyear]) - -# # Link spatial with temporal statistics - -# if intersection: -# # Plot intersection angle statistics depending on deformation rate -# if link_interc_def & link_interc_lifetime: -# # Compute mean deformation of intersecting partners -# def_par = []; diff_def_par = []; -# life_par = [] -# if link_interc_len: -# len_par = [] -# for iyear in range(len(lkf_dataset)): -# def_par_year = []; diff_def_par_year = []; -# life_par_year = [] -# if link_interc_len: -# len_par_year = [] -# for iday in range(len(lkf_dataset[iyear])): -# def_par_day = np.array([np.sqrt(np.sum(np.array(lkf_deformation[iyear][iday])[np.stack(lkf_interc_par[iyear][iday])[:,0].astype('int')]**2,axis=1)), -# np.sqrt(np.sum(np.array(lkf_deformation[iyear][iday])[np.stack(lkf_interc_par[iyear][iday])[:,1].astype('int')]**2,axis=1))]) -# diff_def_par_day = np.abs(np.diff(def_par_day,axis=0)) -# life_par_day = np.array([lkf_lifetime[iyear][iday][np.stack(lkf_interc_par[iyear][iday])[:,0].astype('int')], -# lkf_lifetime[iyear][iday][np.stack(lkf_interc_par[iyear][iday])[:,1].astype('int')]]) -# if link_interc_len: -# len_par_day = np.array([np.array(lkf_length[iyear][iday])[np.stack(lkf_interc_par[iyear][iday])[:,0].astype('int')], -# np.array(lkf_length[iyear][iday])[np.stack(lkf_interc_par[iyear][iday])[:,1].astype('int')]]) - -# def_par_year.append(def_par_day) -# diff_def_par_year.append(diff_def_par_day) -# life_par_year.append(life_par_day) -# if link_interc_len: -# len_par_year.append(len_par_day) -# def_par.append(def_par_year) -# diff_def_par.append(diff_def_par_year) -# life_par.append(life_par_year) -# if link_interc_len: -# len_par.append(len_par_year) - - -# # Plot histograms in different deformation rate classes -# fig,ax = plt.subplots(nrows=1,ncols=3,figsize=(12,4.8)) -# if datatype=='rgps': -# def_class = [0,0.03,0.05,2] -# elif datatype == 'mitgcm_2km': -# def_class = [0,0.05,0.2,10] -# len_thres = 8*12.5e3 -# nbins = 45 -# bins = np.linspace(0,90,nbins) -# def_masked_class = [[],[],[]] -# for iax,axi in enumerate(ax): -# axi.set_title('Def. class: %.2f to %.2f [1/day]' %(def_class[iax],def_class[iax+1])) -# axi.set_xlabel('Intersection angle') -# axi.set_ylabel('PDF') -# axi.set_xlim([0,90]) - -# for iyear in range(len(lkf_interc)): -# mask_def = np.all([np.all(np.hstack(def_par[iyear])>=def_class[iax],axis=0), -# np.all(np.hstack(def_par[iyear])=len_thres,axis=0) -# mask_life = mask_len & mask_life -# pdf_interc, bins_interc = np.histogram(np.concatenate(lkf_interc[iyear])[mask_def & mask_life], -# bins=bins, density=True) -# bins_mean = 0.5*(bins_interc[1:]+bins_interc[:-1]) -# axi.plot(bins_mean, pdf_interc,label=years[iyear],color='0.5',alpha=0.5) -# def_masked_class[iax].append(np.concatenate(lkf_interc[iyear])[mask_def & mask_life]) -# pdf_interc, bins_interc = np.histogram(np.concatenate(def_masked_class[iax]), -# bins=bins, density=True) -# bins_mean = 0.5*(bins_interc[1:]+bins_interc[:-1]) -# axi.plot(bins_mean, pdf_interc,label=years[iyear],color='k',alpha=1.0) -# axi.text(axi.get_xlim()[0]+0.1*axi.get_xlim()[1], -# axi.get_ylim()[0]+0.9*axi.get_ylim()[1], -# 'Tot. num: %i' %np.concatenate(def_masked_class[iax]).size) - -# fig.savefig(plot_output_path + 'interc_pdf_def_class_lifetime.pdf') - -# with plt.style.context(style_label): -# fig,axi = plt.subplots(nrows=1,ncols=1, figsize=(6,5)) -# if datatype=='rgps': -# def_class = [0,0.03,0.00,2] -# elif datatype == 'mitgcm_2km': -# def_class = [0,0.05,0.2,10] -# len_thres = 10*12.5e3 -# nbins = 23 -# bins = np.linspace(0,90,nbins) -# def_masked_class = [[],[],[]] -# iax = 2 - -# #axi.set_title('Def. class: %.2f to %.2f [1/day]' %(def_class[iax],def_class[iax+1])) -# axi.set_xlabel('Intersection angle') -# axi.set_ylabel('PDF') -# axi.set_xlim([0,90]) - -# pdf_year_save = [] - -# for iyear in range(len(lkf_interc)): -# mask_def = np.all([np.all(np.hstack(def_par[iyear])>=def_class[iax],axis=0), -# np.all(np.hstack(def_par[iyear])=len_thres,axis=0) -# mask_life = mask_len & mask_life -# pdf_interc, bins_interc = np.histogram(np.concatenate(lkf_interc[iyear])[mask_def & mask_life], -# bins=bins, density=True) -# pdf_year_save.append(pdf_interc) -# bins_mean = 0.5*(bins_interc[1:]+bins_interc[:-1]) -# if iyear==0: -# axi.plot(bins_mean, pdf_interc,'.',label='single years',color='0.5',alpha=0.5) -# else: -# axi.plot(bins_mean, pdf_interc,'.',color='0.5',alpha=0.5) -# def_masked_class[iax].append(np.concatenate(lkf_interc[iyear])[mask_def & mask_life]) -# pdf_interc, bins_interc = np.histogram(np.concatenate(def_masked_class[iax]), -# bins=bins, density=True) -# bins_mean = 0.5*(bins_interc[1:]+bins_interc[:-1]) -# axi.plot(bins_mean, pdf_interc,label='all years',color=colors[0],alpha=1.0) -# #axi.text(axi.get_xlim()[0]+0.1*axi.get_xlim()[1], -# # axi.get_ylim()[0]+0.9*axi.get_ylim()[1], -# # 'Tot. num: %i' %np.concatenate(def_masked_class[iax]).size) -# axi.plot([],[],' ',label='Tot. num: %i' %np.concatenate(def_masked_class[iax]).size) -# axi.legend() - -# np.savez(int_mem_path + 'Plot_data_interc_len_lifetime.npz',pdf_years=pdf_year_save,pdf_all=pdf_interc) - -# fig.savefig(plot_output_path + 'interc_pdf_def_lifetime0_len%i.pdf' %len_thres) - diff --git a/lkf_tracking.py b/lkf_tracking.py deleted file mode 100644 index e0cfb4a..0000000 --- a/lkf_tracking.py +++ /dev/null @@ -1,290 +0,0 @@ -import numpy as np -import matplotlib.pylab as plt - -from lkf_detection import * - - - - -# ------------------- 0. Helper Functions - -def compute_MHD_segment(A,B,return_overlap=False,overlap_thres=2,angle_thres=45,return_overlaping_area=False): - """ Function to compute Modified Hausdorff Distnce between two - segments. - Following: Marie-Pierre Dubuisson and Anil K. Jain: A Modified - Hausdorff Distance for Object Matching, 1994 - - Input : A,B - two segments - return_part_overlap - optinal: return number of pixels - that partly overlap between segments - overlap_thres - threshold what defines overlap - Output: mhd, pixel_overlap(optional)""" - daB = np.array([np.min(np.sqrt(np.sum((B.T-a)**2,axis=1))) for a in A.T]) - dbA = np.array([np.min(np.sqrt(np.sum((A.T-b)**2,axis=1))) for b in B.T]) - - if return_overlap: - overlap = np.min([(daB <= overlap_thres).sum(), - (dbA <= overlap_thres).sum()]) - if overlap>1: - A_o = A[:,daB <= overlap_thres] - B_o = B[:,dbA <= overlap_thres] - # Filter two large angles - angle = angle_segs(A_o[:,[0,-1]],B_o[:,[0,-1]]) - if angle > 90: angle = 180-angle - if angle >= angle_thres: overlap = 0 - if return_overlaping_area: - return np.max([(daB.sum()/ A.shape[1]),(dbA.sum()/ B.shape[1])]), overlap, [A_o,B_o] - else: - return np.max([(daB.sum()/ A.shape[1]),(dbA.sum()/ B.shape[1])]), overlap - else: - overlap = 0 - if return_overlaping_area: - return np.max([(daB.sum()/ A.shape[1]),(dbA.sum()/ B.shape[1])]), overlap, [np.array([]),np.array([])] - else: - return np.max([(daB.sum()/ A.shape[1]),(dbA.sum()/ B.shape[1])]), overlap - - else: - return np.max([(daB.sum()/ A.shape[1]),(dbA.sum()/ B.shape[1])]) - - - - - - - - -# ------------------- 1. Tracking function - -def track_lkf(lkf0_d, lkf1, nx, ny, thres_frac=0.75, min_overlap=4,first_overlap=False,overlap_thres=1.5,angle_thres=25.,search_area_expansion=1): - """Tracking function for LKFs - - Input: lkf0_d: advected detected LKF features - lkf1: detected LKF features as a list of arrays that contain to indices of all cell containing to one LKF - - Output: lkf_track_pairs: List with pairs of indexes to LKFs in lkf0 that are tracked in lkf1 - """ - - # ----------------------- Define index grid ----------------------------- - - xgi = np.linspace(1,nx,nx)-1 - ygi = np.linspace(1,ny,ny)-1 - XGi,YGi = np.meshgrid(xgi,ygi) - - - # -------------- First rough estimate of drifted LKFs ------------------- - - lkf_track_pairs = [] - #thres_frac = 0.75 - #min_overlap = 4 - - for ilkf,iseg_d in enumerate(lkf0_d): - - if ~np.any(np.isnan(iseg_d)): - # Define search area - search_area = np.concatenate([np.floor(iseg_d),np.ceil(iseg_d), - np.vstack([np.floor(iseg_d)[:,0],np.ceil(iseg_d)[:,1]]).T, - np.vstack([np.ceil(iseg_d)[:,0],np.floor(iseg_d)[:,1]]).T], - axis=0) # Floor and ceil broken indexes - # Broadening of search area - #search_area_expansion = 1 # Number of cell for which the search area is expanded to be consider differences in the morphological thinning - for i in range(search_area_expansion): - n_rows = search_area[:,0].size - search_area = np.concatenate([search_area, - search_area+np.concatenate([np.ones(n_rows).reshape((n_rows,1)), - np.zeros(n_rows).reshape((n_rows,1))],axis=1), - search_area+np.concatenate([-np.ones(n_rows).reshape((n_rows,1)), - np.zeros(n_rows).reshape((n_rows,1))],axis=1), - search_area+np.concatenate([np.zeros(n_rows).reshape((n_rows,1)), - np.ones(n_rows).reshape((n_rows,1))],axis=1), - search_area+np.concatenate([np.zeros(n_rows).reshape((n_rows,1)), - np.ones(n_rows).reshape((n_rows,1))],axis=1), - search_area+np.concatenate([np.ones(n_rows).reshape((n_rows,1)), - np.ones(n_rows).reshape((n_rows,1))],axis=1), - search_area+np.concatenate([np.ones(n_rows).reshape((n_rows,1)), - -np.ones(n_rows).reshape((n_rows,1))],axis=1), - search_area+np.concatenate([-np.ones(n_rows).reshape((n_rows,1)), - np.ones(n_rows).reshape((n_rows,1))],axis=1), - search_area+np.concatenate([-np.ones(n_rows).reshape((n_rows,1)), - -np.ones(n_rows).reshape((n_rows,1))],axis=1)],axis=0) - - search_area = np.unique(search_area, axis=0) - - search_area = search_area[np.all(search_area>=0,axis=1),:] - search_area = search_area[np.all([search_area[:,0]=2: - coeff = np.squeeze(np.linalg.solve(np.dot(A.T,A),np.dot(A.T,b))) - - if coeff[0]!=0: - ## Define boundary lines at both endpoints - ### determine line through endpoint #1 - x1 = iseg_d[0,0]; y1 = iseg_d[0,1] - a = -1/coeff[0] - b1 = y1 - a*x1 - f1 = a*XGi + b1 - YGi - - ### determine line through endpoint #2 - x2 = iseg_d[-1,0]; y2 = iseg_d[-1,1] - b2 = y2 - a*x2 - f2 = a*XGi + b2 -YGi - - ## Define mask of orthogonal area - orth_area = ((f1>0) & (f2<0)) | ((f1<0) & (f2>0)) - elif coeff[0]==0: # LKF parallel to x axis - orth_area = ((XGi >= np.min([iseg_d[0,0],iseg_d[-1,0]])) & - (XGi <= np.max([iseg_d[0,0],iseg_d[-1,0]]))) - else: # LKF parallel to y axis - orth_area = ((YGi >= np.min([iseg_d[0,1],iseg_d[-1,1]])) & - (YGi <= np.max([iseg_d[0,1],iseg_d[-1,1]]))) - - orth_area = np.concatenate([XGi[orth_area].reshape((XGi[orth_area].size,1)), - YGi[orth_area].reshape((YGi[orth_area].size,1))],axis=1) - - - # Ravel indeces to 1D index for faster comparison - orth_area_ravel = [] - for io in range(orth_area.shape[0]): - orth_area_ravel.append(np.ravel_multi_index(orth_area[io,:].astype('int'), - np.transpose(XGi).shape)) - search_area_ravel = [] - for io in range(search_area.shape[0]): - search_area_ravel.append(np.ravel_multi_index(search_area[io,:].astype('int'), - np.transpose(XGi).shape)) - search_area_ravel = list(set(search_area_ravel).intersection(orth_area_ravel)) - search_area = np.zeros((len(search_area_ravel),2)) - for io in range(search_area.shape[0]): - search_area[io,:] = np.unravel_index(search_area_ravel[io],np.transpose(XGi).shape) - - - # Loop over all LKFs to check whether there is overlap with search area - for i in range(lkf1.shape[0]): - lkf_ravel = [] - for io in range(lkf1[i].shape[0]): - lkf_ravel.append(np.ravel_multi_index(lkf1[i][io,:].astype('int'), - np.transpose(XGi).shape)) - - comb_seg_search_area, comb_seg_search_area_count = np.unique(search_area_ravel+lkf_ravel, - return_counts=True) - - # Check for overlap - if np.any(comb_seg_search_area_count > 1): - # LKF1[i] is overlapping with search area - num_points_overlap = np.sum(comb_seg_search_area_count>1) - - if first_overlap: - if (num_points_overlap >= min_overlap): - # Test again with overlap: - A = iseg_d.T - B = np.stack(np.unravel_index(comb_seg_search_area[comb_seg_search_area_count>1], - np.transpose(XGi).shape)) - mhdi, overlap_i = compute_MHD_segment(A,B,return_overlap=True, - overlap_thres=overlap_thres, - angle_thres=angle_thres) - if overlap_i>=min_overlap: - lkf_track_pairs.append(np.array([ilkf,i])) - else: - # Check in orthogonal area of LKF - comb_seg_orth_area, comb_seg_orth_area_count = np.unique(orth_area_ravel+lkf_ravel, - return_counts=True) - num_points_overlap_orth = np.sum(comb_seg_orth_area_count>1) - frac_search_to_orth = num_points_overlap/float(num_points_overlap_orth) - - if (frac_search_to_orth > thres_frac) & (num_points_overlap >= min_overlap): - # Test again with overlap: - A = iseg_d.T - B = np.stack(np.unravel_index(comb_seg_orth_area[comb_seg_orth_area_count>1], - np.transpose(XGi).shape)) - mhdi, overlap_i = compute_MHD_segment(A,B,return_overlap=True, - overlap_thres=overlap_thres, - angle_thres=angle_thres) - if overlap_i>=min_overlap: - lkf_track_pairs.append(np.array([ilkf,i])) - - - return lkf_track_pairs - - - - -# ------------------- 2. Drift functions - -def drift_estimate_rgps(lkf0_path,drift_path,read_lkf0=None): - """Function that computes the position of LKFs after a certain time - considering the drift - - Input: lkf0_path - filename of lkf0 including path - drift_path - directory where drift data is stored including prefix - - Output: lkf0_d - drifted LKFs from lkf0""" - - # Read in lkf0 - if read_lkf0 is None: - lkf0 = np.load(lkf0_path) - else: - lkf0 = read_lkf0 - - # Read in drift data - drift = np.load(drift_path + lkf0_path[-19:]) - - # Compute drift estimate - t = 3*24.*3600. - res = 12.5e3 - lkf0_d = [] - for ilkf,iseg in enumerate(lkf0): - iseg_d = drift[iseg[:,0].astype('int'),iseg[:,1].astype('int'),:]*t/res + iseg[:,:2] - lkf0_d.append(iseg_d) - - return lkf0_d - - - - -# ------------------- 3. Generate tracking dataset -def gen_tracking_dataset_rgps(lkf_path,drift_path,output_path): - """Function that generates tracking data set - - Input: lkf_path - directory including all LKF files for season - drift_path - directory where drift data is stored including prefix - output_path - directory where output is stored - """ - - nx = 264; ny = 248 - - lkf_filelist = [i for i in os.listdir(lkf_path) if i.startswith('lkf') and i.endswith('.npy')] - lkf_filelist.sort() - - for ilkf in range(len(lkf_filelist[:-1])): - print("Track features in %s to %s" %(lkf_filelist[ilkf], - lkf_filelist[ilkf+1])) - # Open lkf0 and compute drift estimate - lkf0_d = drift_estimate_rgps(lkf_path + lkf_filelist[ilkf],drift_path) - - # Read LKFs - lkf1 = np.load(lkf_path + lkf_filelist[ilkf+1]) - # lkf1_l = [] - # for ilkf,iseg in enumerate(lkf1): - # lkf1_l.append(iseg[:,:2]) - lkf1_l = lkf1 - for ilkf1,iseg in enumerate(lkf1): - lkf1_l[ilkf1] = iseg[:,:2] - - # Compute tracking - tracked_pairs = track_lkf(lkf0_d, lkf1_l, nx, ny, thres_frac=0.75, min_overlap=4,overlap_thres=1.5,angle_thres=25) - - # Save tracked pairs - np.save(output_path + 'lkf_tracked_pairs_%s_to_%s' %(lkf_filelist[ilkf][4:-4], - lkf_filelist[ilkf+1][4:-4]), - tracked_pairs) - - diff --git a/read_RGPS_lagrangian.py b/read_RGPS_lagrangian.py deleted file mode 100644 index 4092400..0000000 --- a/read_RGPS_lagrangian.py +++ /dev/null @@ -1,240 +0,0 @@ -import numpy as np -import sys -from mpl_toolkits.basemap import Basemap -import os -import rw as rw - - - -def read_RGPS_lag_motion(filename): - RGPS_file = open(filename,'r') - - # RGPS product identifier - idf_id='123456789012345678901234' - # Description of this product - prod_desc='1234567890123456789012345678901234567890' - # Number of images used in the creation of this product - n_images = np.int16(0) - # Number of trajectories in this product - n_trajectories = np.int32(0) - # Product Type - prod_type='12345678' - # Product creation year/time - create_year = np.int16(0) - create_time = np.float64(0) - # Season start year/time - season_start_year = np.int16(0) - season_start_time = np.float64(0) - # Season end year/time - season_end_year = np.int16(0) - season_end_time = np.float64(0) - # Software version used to create this product - sw_version = '123456789012' - #Northwest Lat/Long of initial datatake - n_w_lat = np.float32(0) ; n_w_lon = np.float32(0) - #Northeast Lat/Long of initial datatake - n_e_lat = np.float32(0) ; n_e_lon = np.float32(0) - #Southwest Lat/Long of initial datatake - s_w_lat = np.float32(0) ; s_w_lon = np.float32(0) - #Southeast Lat/Long of initial datatake - s_e_lat = np.float32(0) ; s_e_lon = np.float32(0) - - #======================================================= - # AREA CHANGE and ICE MOTION DERIVATIVES DATA - #======================================================= - # Cell identifier - gpid = np.int32(0) - # Birth and Death year/time of gridpoint - birth_year = np.int16(0) ; birth_time = np.float64(0) - death_year = np.int16(0) ; death_time = np.float64(0) - # Number of observations of cell - n_obs = np.int32(0) - # Year/Time of observation - obs_year = np.int16(0) ; obs_time = np.float64(0) - # Map location of observation - x_map = np.float64(0) ; y_map = np.float64(0) - # Quality Flag of observation - q_flag = np.int16(0) - # Only the first 3 cells in this product will be printed out - max_read_cell = 3 - - # ======================================================= - # ASF image identifier - image_id = '1234567890123456' - # Image center year/time - image_year = np.int16(0) ; image_time = np.float64(0) - # Image center location - map_x = np.float64(0) ; map_y = np.float64(0) - - - para_val = [idf_id,prod_desc,n_images,n_trajectories,prod_type, - create_year,create_time, - season_start_year,season_start_time, - season_end_year, season_end_time, - sw_version, - n_w_lat,n_w_lon, n_e_lat,n_e_lon, - s_w_lat,s_w_lon, s_e_lat,s_e_lon] - para_name = ['idf_id','prod_desc','n_images','n_trajectories','prod_type', - 'create_year','create_time', - 'season_start_year','season_start_time', - 'season_end_year',' season_end_time', - 'sw_version', - 'n_w_lat','n_w_lon',' n_e_lat','n_e_lon', - 's_w_lat','s_w_lon',' s_e_lat','s_e_lon'] - - for ip in range(len(para_val)): - if para_val[ip] == 0: - para_val[ip] = np.fromfile(RGPS_file,np.dtype(para_val[ip]),1).byteswap(True) - else: - para_val[ip] = RGPS_file.read(len(para_val[ip])) - - # Read image data - n_images = para_val[2] - - image_para_val_org = [image_id,image_year,image_time,map_x,map_y] - - image_para_val = [image_id,image_year,image_time,map_x,map_y] - - image_data = [] - - for ii in range(n_images): - image_para_val = [] - - # Read header: - for ip in range(len(image_para_val_org)): - if image_para_val_org[ip] == 0: - image_para_val.append(np.fromfile(RGPS_file,np.dtype(image_para_val_org[ip]),1).byteswap(True)) - else: - image_para_val.append(RGPS_file.read(len(image_para_val_org[ip]))) - - image_data.append(image_para_val) - - - # Read ice motion data - cell_para_val_org = [gpid,birth_year,birth_time,death_year,death_time,n_obs] - - cell_para_val = [gpid,birth_year,birth_time,death_year,death_time,n_obs] - - data_para_val_org = [obs_year,obs_time, - x_map,y_map, - q_flag] - - data_para_val = [obs_year,obs_time, - x_map,y_map, - q_flag] - - cell_data = [] - - n_cells = para_val[3] - - for ic in range(n_cells): - cell_para_val = np.copy(cell_para_val_org) - - # Read header: - for ip in range(len(cell_para_val)): - cell_para_val[ip] = np.fromfile(RGPS_file,np.dtype(cell_para_val_org[ip]),1).byteswap(True) - - - # Read data - n_obs = cell_para_val[-1] - data_list = [] - for id in range(int(n_obs)): - data_para_val = np.copy(data_para_val_org) - for ip in range(len(data_para_val)): - readout = np.fromfile(RGPS_file,np.dtype(data_para_val_org[ip]),1).byteswap(True) - data_para_val[ip] = readout - #data_para_val[ip] = np.fromfile(RGPS_file,np.dtype(data_para_val_org[ip]),1).byteswap(True) - data_list.append(data_para_val) - - cell_data.append([cell_para_val, np.array(data_list)]) - - return para_name, para_val, image_data, cell_data - - - - - -def get_icemotion_RGPS(RGPS_path,stream='None'): - ''' Function that reads in all RGPS files in directory (most probably month) and - saves them in gridded format''' - - if not RGPS_path.endswith('/'): - RGPS_path += '/' - - if stream != 'None': - icemotion_files = [f for f in os.listdir(RGPS_path) if f.endswith('.LP') and f.startswith('R1001'+stream)] - else: - icemotion_files = [f for f in os.listdir(RGPS_path) if f.endswith('.LP')] - - motion_data = [] - - for iif in range(len(icemotion_files)): - para_name, para_val, image_data, cell_data = read_RGPS_lag_motion(RGPS_path + icemotion_files[iif]) - - motion_data += cell_data - - - gid = np.zeros((len(motion_data),1)) # List of all grid cell IDs - nobs = np.zeros((len(motion_data),1)) # List of number of observations at all grid cell IDs - - for it in range(len(motion_data)): - gid[it] = motion_data[it][0][0] - nobs[it] = motion_data[it][0][5] - - # Test for double mentioning of grid IDs - if np.unique(gid).size != gid.size: - gcids,n_gcids = np.unique(gid,return_index=True) - print 'ERROR: grid cell IDs: ' + str(gcids[n_gcids!=1]) + ' are more than once in the dataset' - - return motion_data - - - -def get_icemotion_RGPS_season(season_path,stream='None'): - ''' Function that reads in all RGPS files for one season (each month in - one directory and saves them in gridded format (GID,year,day,x,y,qflag) - - Note as RGPS positions are saved cummulative for month only last month - of season is read, because it contains the entire season''' - - if not season_path.endswith('/'): - season_path += '/' - - month_path = [f for f in os.listdir(season_path)] - - month_rgps = ['may', 'apr', 'mar', 'feb', 'jan', 'dec', 'nov'] - - for im in range(len(month_rgps)): - if np.any(np.array(month_path)==month_rgps[im]): - imonth = np.where(np.array(month_path)==month_rgps[im])[0][0] - break - - print 'Read last month available for season: ' + month_path[imonth] - motion_data = [] - if stream != 'None': - motion_data += get_icemotion_RGPS(season_path + month_path[imonth],stream=stream) - else: - motion_data += get_icemotion_RGPS(season_path + month_path[imonth]) - - gid_org = np.zeros((len(motion_data),1)) # List of all grid cell IDs - nobs_org = np.zeros((len(motion_data),1)) # List of number of observations at all grid cell IDs - - for it in range(len(motion_data)): - gid_org[it] = motion_data[it][0][0] - nobs_org[it] = motion_data[it][0][5] - - gid, gid_ind = np.unique(gid_org,return_index=True) - nobs = np.zeros(gid.shape) - for it in range(gid.size): - nobs[it] = np.sum(nobs_org[gid_org==gid[it]]) - - icemotion_data = np.zeros((gid.size,np.int(nobs.max()),5))*np.nan # obs_year,obs_time,x_map,y_map,q_flag - - for it_id in range(gid.size): - cur_ind = 0 - for it in np.where(gid_org==gid[it_id])[0]: - icemotion_data[it_id,cur_ind:cur_ind+np.int(nobs_org[it])] = motion_data[it][1] - cur_ind += np.int(nobs_org[it]) - - return icemotion_data - diff --git a/setup.cfg~ b/setup.cfg~ deleted file mode 100644 index a0f8459..0000000 --- a/setup.cfg~ +++ /dev/null @@ -1,75 +0,0 @@ -[sdist] -formats = gztar - -[check-manifest] -ignore = - *.yml - *.yaml - .coveragerc - docs - docs/* - *.enc - notebooks - notebooks/* - tests - tests/* - -[flake8] -max-line-length = 105 -select = C,E,F,W,B,B950 -ignore = E203, E501, W503 -exclude = lkf_tools/_version.py - - -[metadata] -name = lkf_tools -description = this package allows to detect and track deformation features (LKFs) in sea-ice deformation data -author = Nils Hutter -url = https://github.com/nhutter/lkf_tools -long_description = file: README.md -long_description_content_type = text/markdown -license = GNU General Public License v3.0 -license_file = LICENSE.txt - -## These need to be filled in by the author! -# For details see: https://pypi.org/classifiers/ - -classifiers = - Development Status :: 3 - Alpha #5 - Production/Stable - Topic :: Scientific/Engineering - Intended Audience :: Science/Research - Operating System :: OS Independent - Programming Language :: Python - Programming Language :: Python :: 3 - Programming Language :: Python :: 3.6 - Programming Language :: Python :: 3.7 - Programming Language :: Python :: 3.8 - Programming Language :: Python :: 3.9 - # Dont change this one - License :: OSI Approved :: MIT License - -## Add your email here -author_email = nils.hutter@awi.de - - -### make sure to fill in your dependencies! -[options] -install_requires = - numpy - requests - numpy - matplotlib - scipy - netCDF4 - datetime - osgeo - pyproj - loguru - scikit-image -setup_requires= - setuptools_scm -python_requires = >=3.6 -################ Up until here - -zip_safe = False -packages = find: diff --git a/setup.py~ b/setup.py~ deleted file mode 100644 index 43009bb..0000000 --- a/setup.py~ +++ /dev/null @@ -1,10 +0,0 @@ -from setuptools import setup - - -setup( - use_scm_version={ - "write_to": "floe_deform/_version.py", - "write_to_template": '__version__ = "{version}"', - "tag_regex": r"^(?Pv)?(?P[^\+]+)(?P.*)?$", - } -) From e74bb408a7c38f9d471432a227b41166e0520e55 Mon Sep 17 00:00:00 2001 From: Nils Hutter Date: Mon, 3 Jul 2023 09:53:41 +0200 Subject: [PATCH 21/21] Update links --- README.md | 2 +- notebooks/rgps_gen_dataset.ipynb | 2 ++ 2 files changed, 3 insertions(+), 1 deletion(-) diff --git a/README.md b/README.md index 189afeb..f31d26d 100644 --- a/README.md +++ b/README.md @@ -22,7 +22,7 @@ $ python setup.py develop ## Generate LKF data-set -There is a [tutorial notebook](notebooks/tutorial_gen_dataset.ipynb) that illustrates how to generate a LKF data-set from a netcdf file. This tutorial uses model output from the [SIREx model output repository](https://doi.org/10.5281/zenodo.5555329) and also uses the SIREx sampling strategies that are described in detail in this [preprint](https://www.essoar.org/doi/10.1002/essoar.10507396.1). The tutorial shows you how to: +There is a [tutorial notebook](notebooks/tutorial_gen_dataset.ipynb) that illustrates how to generate a LKF data-set from a netcdf file. This tutorial uses model output from the [SIREx model output repository](https://doi.org/10.5281/zenodo.5555329) and also uses the SIREx sampling strategies that are described in detail in this [Hutter et al. 2022](https://doi.org/10.1029/2021JC017667). The tutorial shows you how to: * download and read in the netcdf file * detect LKFs in the netcdf file * run the tracking algorithm on the detected LKFs diff --git a/notebooks/rgps_gen_dataset.ipynb b/notebooks/rgps_gen_dataset.ipynb index 1a20d35..37dde2f 100644 --- a/notebooks/rgps_gen_dataset.ipynb +++ b/notebooks/rgps_gen_dataset.ipynb @@ -10,6 +10,8 @@ "# Detect and track LKFs in netcdf model output\n", "\n", "This tutorial shows how to generate a LKF data-set based on gridded RGPS sea-ice drift and deformation data in netcdf format. \n", + "\n", + "**Warning:** The data used in this tutorial is a preprocessed version of RGPS data that is not publicly available anymore. The distribution of the RGPS data has moved to the Alaska Satellite Facility and is available in a different format here: https://asf.alaska.edu/data-sets/derived-data-sets/seaice-measures/sea-ice-measures-data-products/. Updating this notebook to the new data formar is in progress. \n", " \n", "### Load `lkf_tools` package" ]