Merge pull request #19 from KonstantinChri/dev

Merge dev for new release

Author: bjorkqvi

dnora/aux.py dnora/aux_funcs.py

@@ -180,108 +180,6 @@ def month_list(start_time, end_time):
     months = pd.date_range(start=start_time[:7], end=end_time[:7], freq='MS')
     return months
 
-def add_extension(filename: str, extension: str):
-    """Adds a file extension to the file name.
-
-    If the file already has an extension, then no extension is added. An
-    extension is defined as a . in the last five characters of the string.
-    """
-
-    if ('.' in filename[-5:]) or (not extension):
-        return filename
-    else:
-        if not extension[0] == '.':
-            extension = f".{extension}"
-        return f"{filename}{extension}"
-
-
-def add_prefix(filename: str, prefix: str) -> str:
-    """Adds a prefix to a filename, e.g. FileName.txt -> new_FileName.txt"""
-    if (not prefix == '') and (not prefix[-1] == '_'):
-        return f"{prefix}_{filename}"
-    else:
-        return f"{prefix}{filename}"
-
-def add_suffix(filename: str, suffix: str) -> str:
-    """Adds a suffix to a filename, e.g. FileName.txt -> FileName_new.txt"""
-    if (not suffix == '') and (not suffix[0] == '_'):
-        suffix = f"_{suffix}"
-
-    filename_list = filename.split('.')
-
-    if len(filename_list) == 1:
-        return filename+suffix
-    else:
-        return '.'.join(filename_list[0:-1]) + suffix + '.' + filename_list[-1]
-
-
-def add_folder_to_filename(filename: str, folder: str) -> str:
-    """Adds a folder to filename to create a path:
-
-    e.g. FileName.txt, Folder -> Folder/FileName.txt
-    """
-
-    if (not folder == '') and (not folder[-1] == '/'):
-        return f"{folder}/{filename}"
-    else:
-        return f"{folder}{filename}"
-
-def create_filename_time(filestring: str, times: List, datestring: str='%Y%m%d%H%M') -> str:
-    """Substitutes the strings #T0, #T1, #T2... etc. in filestring with time
-    stamps from a list of times, using the format in datestring.
-
-    e.g. #T0_file.txt, ['2020-05-04 18:00'], %Y%m%d%H%M -> 202005041800_file.txt
-    """
-
-    ct = 0
-    for t in times:
-        filestring = re.sub(f"#T{ct}", pd.Timestamp(t).strftime(datestring), filestring)
-        ct = ct + 1
-
-    return filestring
-
-def create_filename_lonlat(filestring: str, lon: float, lat: float) -> str:
-    """Substitutes the strings #Lon, #Lat in filestring with values of lon and
-    lat.
-
-    e.g. #Lon_#Lat_file.txt, 8.0, 60.05 -> 08.0000000_60.05000000_file.txt
-    """
-
-    filestring = re.sub("#Lon", f"{lon:010.7f}", filestring)
-    filestring = re.sub("#Lat", f"{lat:010.7f}", filestring)
-
-    return filestring
-
-def create_filename_obj(filestring: str, objects: List[Union[Grid, Forcing, Boundary]]) -> str:
-    """Substitutes the strings #{Object} in filestring with the name given to
-    the object.
-
-    e.g. #Grid_#Forcing_file.txt, [Grid(..., name="Sula"), Forcing(..., name='NORA3')]
-        -> Sula_NORA3_file.txt
-    """
-
-    for object in objects:
-        if object is not None:
-            obj_str = type(object).__name__
-            obj_name = object.name()
-            filestring = re.sub(f"#{obj_str}", obj_name, filestring)
-
-    return filestring
-
-def clean_filename(filename: str, list_of_placeholders: List[str]) -> str:
-    """ Cleans out the file name from possible used placeholders, e.g. #Grid
-    as given in the list.
-
-    Also removes multiple underscores '___'
-    """
-
-    for s in list_of_placeholders:
-            filename = re.sub(s, '', filename)
-
-    filename = re.sub("_{2,10}", '_', filename)
-
-    return filename
-
 def create_time_stamps(start_time: str, end_time: str, stride: int, hours_per_file: int=0, last_file: str='', lead_time: int=0) -> Tuple:
     """Create time stamps to read in blocks of wind forcing from files.
 

dnora/bnd/bnd_mod.py

@@ -20,10 +20,9 @@
 if TYPE_CHECKING:
     from .write import BoundaryWriter # Abstract class
 
-# Import default values and auxiliry functions
+# Import default values and aux_funcsiliry functions
 from .. import msg
-from ..aux import day_list, create_filename_obj, create_filename_time, create_filename_lonlat, clean_filename, check_if_folder
-from ..defaults import dflt_bnd, list_of_placeholders
+from ..aux_funcs import day_list
 
 
 class Boundary:
@@ -42,18 +41,20 @@ def import_boundary(self, start_time: str, end_time: str, boundary_reader: Bound
         are determined by the point_picker.
         """
 
-        self.start_time = copy(start_time)
-        self.end_time = copy(end_time)
         self._history.append(copy(boundary_reader))
 
         msg.header(boundary_reader, "Reading coordinates of spectra...")
-        lon_all, lat_all = boundary_reader.get_coordinates(self.start_time)
+        lon_all, lat_all = boundary_reader.get_coordinates(start_time)
 
         msg.header(point_picker, "Choosing spectra...")
         inds = point_picker(self.grid, lon_all, lat_all)
 
+        if len(inds) < 1:
+            msg.warning("PointPicker didn't find any points. Aborting import of boundary.")
+            return
+
         msg.header(boundary_reader, "Loading boundary spectra...")
-        time, freq, dirs, spec, lon, lat, source = boundary_reader(self.start_time, end_time, inds)
+        time, freq, dirs, spec, lon, lat, source = boundary_reader(start_time, end_time, inds)
 
         self.data = self.compile_to_xr(time, freq, dirs, spec, lon, lat, source)
         self.mask = [True]*len(self.x())
@@ -130,71 +131,84 @@ def compile_to_xr(self, time, freq, dirs, spec, lon, lat, source):
             )
         return data
 
-    def slice_data(self, start_time: str='', end_time: str='', x: List[int]=None):
-        """Slice data in space (x) and time. Returns an xarray dataset."""
+    def slice_data(self, start_time: str='', end_time: str='', x: List[int]=None) -> xr.Dataset:
+        """Slice data in space (x) and time."""
+        if not hasattr(self, 'data'):
+            return None
 
         if x is None:
             x=self.x()
-
         if not start_time:
             # This is not a string, but slicing works also with this input
             start_time = self.time()[0]
-
         if not end_time:
             # This is not a string, but slicing works also with this input
             end_time = self.time()[-1]
-
         sliced_data = self.data.sel(time=slice(start_time, end_time), x = x)
-
         return sliced_data
 
-    def spec(self, start_time: str='', end_time: str='', x: List[int]=None):
-        """Slice spectra in space (x) and time. Returns an numpy array."""
-
-        spec = self.slice_data(start_time, end_time, x).spec.values
-        return spec
+    def spec(self, start_time: str='', end_time: str='', x: List[int]=None) -> np.ndarray:
+        """Slice spectra in space (x) and time."""
+        spec = self.slice_data(start_time, end_time, x)
+        if spec is None:
+            return None
+        return spec.spec.values
 
     def time(self):
+        if not hasattr(self, 'data'):
+            return pd.to_datetime([])
         return pd.to_datetime(self.data.time.values)
 
+    def start_time(self) -> str:
+        if len(self.time()) == 0:
+            return ''
+        return self.time()[0].strftime('%Y-%m-%d %H:%M')
+
+    def end_time(self) -> str:
+        if len(self.time()) == 0:
+            return ''
+        return self.time()[-1].strftime('%Y-%m-%d %H:%M')
+
     def dt(self) -> float:
         """ Returns time step of boundary spectra in hours."""
+        if len(self.time()) == 0:
+            return 0
         return self.time().to_series().diff().dt.total_seconds().values[-1]/3600
 
-    def freq(self):
-        if hasattr(self, 'data'):
-            return copy(self.data.freq.values)
-        else:
+    def freq(self) -> np.ndarray:
+        if not hasattr(self, 'data'):
             return np.array([])
+        return copy(self.data.freq.values)
 
-    def dirs(self):
-        if hasattr(self, 'data'):
-            return copy(self.data.dirs.values)
-        else:
+    def dirs(self) -> np.ndarray:
+        if not hasattr(self, 'data'):
             return np.array([])
+        return copy(self.data.dirs.values)
 
-    def lon(self):
-        if hasattr(self, 'data'):
-            return copy(self.data.lon.values)
-        else:
+    def lon(self) -> np.ndarray:
+        if not hasattr(self, 'data'):
             return np.array([])
+        return copy(self.data.lon.values)
 
-    def lat(self):
-        if hasattr(self, 'data'):
-            return copy(self.data.lat.values)
-        else:
+    def lat(self) -> np.ndarray:
+        if not hasattr(self, 'data'):
             return np.array([])
+        return copy(self.data.lat.values)
 
-    def x(self):
-        if hasattr(self, 'data'):
-            return copy(self.data.x.values)
-        else:
+    def x(self) -> np.ndarray:
+        if not hasattr(self, 'data'):
             return np.array([])
+        return copy(self.data.x.values)
 
     def days(self):
         """Determins a Pandas data range of all the days in the time span."""
-        days = day_list(start_time = self.start_time, end_time = self.end_time)
-        return days
+        if len(self.time()) == 0:
+            return []
+        return pd.date_range(start=str(self.time()[0]).split(' ')[0],
+                end=str(self.time()[-1]).split(' ')[0], freq='D')
+
+        #days = day_list(start_time = self.start_time, end_time = self.end_time)
+        #return days
 
     def size(self):
         return (len(self.time()), len(self.x()))
@@ -206,33 +220,32 @@ def name(self) -> str:
 
     def convention(self) -> str:
         """Returns the convention (WW3/Ocean/Met/Math) of the spectra"""
-        if hasattr(self, '_convention'):
-            return copy(self._convention)
-        else:
+        if not hasattr(self, '_convention'):
             return None
+        return copy(self._convention)
 
     def times_in_day(self, day):
         """Determines time stamps of one given day."""
         t0 = day.strftime('%Y-%m-%d') + "T00:00:00"
         t1 = day.strftime('%Y-%m-%d') + "T23:59:59"
 
-        times = self.slice_data(start_time=t0, end_time=t1, x=[0]).time.values
-        return times
+        times = self.slice_data(start_time=t0, end_time=t1, x=[0])
+        if times is None:
+            return []
+
+        return times.time.values
 
     def __str__(self) -> str:
         """Prints status of boundary."""
 
         msg.header(self, f"Status of boundary {self.name()}")
-        msg.plain(f"Contains data ({len(self.x())} points) for {self.start_time} - {self.end_time}")
+        msg.plain(f"Contains data ({len(self.x())} points) for {self.start_time()} - {self.end_time()}")
         msg.plain(f"Data covers: lon: {min(self.lon())} - {max(self.lon())}, lat: {min(self.lat())} - {max(self.lat())}")
         if len(self._history) > 0:
             msg.blank()
             msg.plain("Object has the following history:")
             for obj in self._history:
                 msg.process(f"{obj.__class__.__bases__[0].__name__}: {type(obj).__name__}")
-        #msg.print_line()
-        #msg.plain("The Boundary is for the following Grid:")
-        #print(self.grid)
 
         msg.print_line()
 

dnora/bnd/pick.py

@@ -4,9 +4,9 @@
 # Import objects
 from ..grd.grd_mod import Grid
 
-# Import auxiliry functions
+# Import aux_funcsiliry functions
 from .. import msg
-from ..aux import min_distance, expand_area
+from ..aux_funcs import min_distance, expand_area
 
 class PointPicker(ABC):
     """PointPickers take in longitude and latitude values, and returns indeces
@@ -28,8 +28,11 @@ def __call__(self, grid: Grid, bnd_lon, bnd_lat):
         return inds
 
 class NearestGridPoint(PointPicker):
-    """Choose the nearest grid point to each boundary point in the grid."""
-    def __init__(self):
+    """Choose the nearest grid point to each boundary point in the grid.
+    Set a maximum allowed distance using `max_dist` (in km) at instantiation time.
+    """
+    def __init__(self, max_dist=None):
+        self.max_dist = max_dist
         pass
 
     def __call__(self, grid, bnd_lon, bnd_lat):
@@ -41,8 +44,12 @@ def __call__(self, grid, bnd_lon, bnd_lat):
         inds = []
         for n in range(len(lat)):
             dx, ind = min_distance(lon[n], lat[n], bnd_lon, bnd_lat)
-            msg.plain(f"Point {n}: lat: {lat[n]:10.7f}, lon: {lon[n]:10.7f} <<< ({bnd_lat[ind]: .7f}, {bnd_lon[ind]: .7f}). Distance: {dx:.1f} km")
-            inds.append(ind)
+            ms = f"Point {n}: lat: {lat[n]:10.7f}, lon: {lon[n]:10.7f} <<< ({bnd_lat[ind]: .7f}, {bnd_lon[ind]: .7f}). Distance: {dx:.1f} km"
+            if self.max_dist is None or dx <= self.max_dist:
+                msg.plain(ms)
+                inds.append(ind)
+            else:
+                msg.plain('DISCARDED, too far: '+ms)
 
         inds = np.array(inds)
         return inds

dnora/bnd/process.py

@@ -3,9 +3,9 @@
 from abc import ABC, abstractmethod
 from typing import Tuple
 
-# Import auxiliry functions
+# Import aux_funcsiliry functions
 from .. import msg
-from ..aux import interp_spec, shift_spec, flip_spec
+from ..aux_funcs import interp_spec, shift_spec, flip_spec
 
 class BoundaryProcessor(ABC):
     def __init__(self):