def __init__(self, filename, topology_file=None, extrapolate=False, time_offset=0, current_scale=1, uncertain_along=0.5, uncertain_across=0.25, **kwargs): """ Initialize a GridCurrentMover :param filename: absolute or relative path to the data file: could be netcdf or filelist :param topology_file=None: absolute or relative path to topology file. If not given, the GridCurrentMover will compute the topology from the data file. :param active_start: datetime when the mover should be active :param active_stop: datetime after which the mover should be inactive :param current_scale: Value to scale current data :param uncertain_duration: how often does a given uncertain element get reset :param uncertain_time_delay: when does the uncertainly kick in. :param uncertain_cross: Scale for uncertainty perpendicular to the flow :param uncertain_along: Scale for uncertainty parallel to the flow :param extrapolate: Allow current data to be extrapolated before and after file data :param time_offset: Time zone shift if data is in GMT uses super, super(GridCurrentMover,self).__init__(\*\*kwargs) """ # if child is calling, the self.mover is set by child - do not reset if type(self) == GridCurrentMover: self.mover = CyGridCurrentMover() if not os.path.exists(filename): raise ValueError('Path for current file does not exist: {0}' .format(filename)) if topology_file is not None: if not os.path.exists(topology_file): raise ValueError('Path for Topology file does not exist: {0}' .format(topology_file)) # check if this is stored with cy_gridcurrent_mover? self.filename = filename self.name = os.path.split(filename)[1] # check if this is stored with cy_gridcurrent_mover? self.topology_file = topology_file self.current_scale = current_scale self.uncertain_along = uncertain_along self.uncertain_across = uncertain_across self.mover.text_read(filename, topology_file) self.mover.extrapolate_in_time(extrapolate) self.mover.offset_time(time_offset * 3600.) super(GridCurrentMover, self).__init__(**kwargs)
def test_init(): kwargs = {'current_scale': 2, 'uncertain_duration': 10*3600, 'uncertain_time_delay': 900, 'uncertain_along': 0.75, 'uncertain_cross': 0.5} gcm = CyGridCurrentMover(**kwargs) for key, val in kwargs.iteritems(): assert getattr(gcm, key) == val
def __init__(self, filename, topology_file=None, extrapolate=False, time_offset=0, current_scale=1, uncertain_along=0.5, uncertain_across=0.25, num_method='Euler', **kwargs): """ Initialize a GridCurrentMover :param filename: absolute or relative path to the data file: could be netcdf or filelist :param topology_file=None: absolute or relative path to topology file. If not given, the GridCurrentMover will compute the topology from the data file. :param active_range: Range of datetimes for when the mover should be active :type active_range: 2-tuple of datetimes :param current_scale: Value to scale current data :param uncertain_duration: how often does a given uncertain element get reset :param uncertain_time_delay: when does the uncertainly kick in. :param uncertain_cross: Scale for uncertainty perpendicular to the flow :param uncertain_along: Scale for uncertainty parallel to the flow :param extrapolate: Allow current data to be extrapolated before and after file data :param time_offset: Time zone shift if data is in GMT :param num_method: Numerical method for calculating movement delta. Default Euler option: Runga-Kutta 4 (RK4) uses super, super(GridCurrentMover,self).__init__(\*\*kwargs) """ # if child is calling, the self.mover is set by child - do not reset if type(self) == GridCurrentMover: self.mover = CyGridCurrentMover() if not os.path.exists(filename): raise ValueError( 'Path for current file does not exist: {0}'.format(filename)) if topology_file is not None: if not os.path.exists(topology_file): raise ValueError( 'Path for Topology file does not exist: {0}'.format( topology_file)) super(GridCurrentMover, self).__init__(**kwargs) # check if this is stored with cy_gridcurrent_mover? self.filename = filename self.name = os.path.split(filename)[1] # check if this is stored with cy_gridcurrent_mover? self.topology_file = topology_file self.current_scale = current_scale self.uncertain_along = uncertain_along self.uncertain_across = uncertain_across self.mover.text_read(filename, topology_file) self.mover.extrapolate_in_time(extrapolate) self.mover.offset_time(time_offset * 3600.) self.num_method = num_method if self.topology_file is None: # this causes an error saving for currents that don't have topology #self.topology_file = filename + '.dat' #self.export_topology(self.topology_file) temp_topology_file = filename + '.dat' self.export_topology(temp_topology_file) if os.path.exists(temp_topology_file): self.topology_file = temp_topology_file
class GridCurrentMover(CurrentMoversBase): _schema = GridCurrentMoverSchema def __init__(self, filename, topology_file=None, extrapolate=False, time_offset=0, current_scale=1, uncertain_along=0.5, uncertain_across=0.25, num_method='Euler', **kwargs): """ Initialize a GridCurrentMover :param filename: absolute or relative path to the data file: could be netcdf or filelist :param topology_file=None: absolute or relative path to topology file. If not given, the GridCurrentMover will compute the topology from the data file. :param active_range: Range of datetimes for when the mover should be active :type active_range: 2-tuple of datetimes :param current_scale: Value to scale current data :param uncertain_duration: how often does a given uncertain element get reset :param uncertain_time_delay: when does the uncertainly kick in. :param uncertain_cross: Scale for uncertainty perpendicular to the flow :param uncertain_along: Scale for uncertainty parallel to the flow :param extrapolate: Allow current data to be extrapolated before and after file data :param time_offset: Time zone shift if data is in GMT :param num_method: Numerical method for calculating movement delta. Default Euler option: Runga-Kutta 4 (RK4) uses super, super(GridCurrentMover,self).__init__(\*\*kwargs) """ # if child is calling, the self.mover is set by child - do not reset if type(self) == GridCurrentMover: self.mover = CyGridCurrentMover() if not os.path.exists(filename): raise ValueError( 'Path for current file does not exist: {0}'.format(filename)) if topology_file is not None: if not os.path.exists(topology_file): raise ValueError( 'Path for Topology file does not exist: {0}'.format( topology_file)) super(GridCurrentMover, self).__init__(**kwargs) # check if this is stored with cy_gridcurrent_mover? self.filename = filename self.name = os.path.split(filename)[1] # check if this is stored with cy_gridcurrent_mover? self.topology_file = topology_file self.current_scale = current_scale self.uncertain_along = uncertain_along self.uncertain_across = uncertain_across self.mover.text_read(filename, topology_file) self.mover.extrapolate_in_time(extrapolate) self.mover.offset_time(time_offset * 3600.) self.num_method = num_method if self.topology_file is None: # this causes an error saving for currents that don't have topology #self.topology_file = filename + '.dat' #self.export_topology(self.topology_file) temp_topology_file = filename + '.dat' self.export_topology(temp_topology_file) if os.path.exists(temp_topology_file): self.topology_file = temp_topology_file def __repr__(self): return ('GridCurrentMover(' 'uncertain_duration={0.uncertain_duration},' 'uncertain_time_delay={0.uncertain_time_delay}, ' 'uncertain_cross={0.uncertain_cross}, ' 'uncertain_along={0.uncertain_along}, ' 'active_range={1.active_range}, ' 'on={1.on})'.format(self.mover, self)) def __str__(self): return ('GridCurrentMover - current _state.\n' ' uncertain_duration={0.uncertain_duration}\n' ' uncertain_time_delay={0.uncertain_time_delay}\n' ' uncertain_cross={0.uncertain_cross}\n' ' uncertain_along={0.uncertain_along}\n' ' active_range time={1.active_range}\n' ' current on/off status={1.on}'.format(self.mover, self)) # Define properties using lambda functions: uses lambda function, which are # accessible via fget/fset as follows: uncertain_cross = property( lambda self: self.mover.uncertain_cross, lambda self, val: setattr(self.mover, 'uncertain_cross', val)) uncertain_along = property( lambda self: self.mover.uncertain_along, lambda self, val: setattr(self.mover, 'uncertain_along', val)) current_scale = property( lambda self: self.mover.current_scale, lambda self, val: setattr(self.mover, 'current_scale', val)) extrapolate = property( lambda self: self.mover.extrapolate, lambda self, val: setattr(self.mover, 'extrapolate', val)) time_offset = property( lambda self: self.mover.time_offset / 3600., lambda self, val: setattr(self.mover, 'time_offset', val * 3600.)) @property def data_start(self): return sec_to_datetime(self.mover.get_start_time()) @property def data_stop(self): return sec_to_datetime(self.mover.get_end_time()) @property def num_method(self): return self._num_method @num_method.setter def num_method(self, val): self.mover.num_method = val self._num_method = val @property def is_data_on_cells(self): return self.mover._is_data_on_cells() def get_grid_data(self): """ The main function for getting grid data from the mover """ if self.mover._is_triangle_grid(): return self.get_triangles() else: return self.get_cells() def get_center_points(self): if self.mover._is_triangle_grid(): if self.mover._is_data_on_cells(): return self.get_triangle_center_points() else: return self.get_points() else: return self.get_cell_center_points() def get_scaled_velocities(self, time): """ :param model_time=0: """ num_tri = self.mover.get_num_triangles() # will need to update this for regular grids if self.mover._is_triangle_grid(): if self.mover._is_data_on_cells(): num_cells = num_tri else: num_vertices = self.mover.get_num_points() num_cells = num_vertices elif self.mover._is_regular_grid(): num_cells = self.mover.get_num_points() else: num_cells = num_tri / 2 vels = np.zeros(num_cells, dtype=basic_types.velocity_rec) self.mover.get_scaled_velocities(time, vels) return vels def export_topology(self, topology_file): """ :param topology_file=None: absolute or relative path where topology file will be written. """ if topology_file is None: raise ValueError( 'Topology file path required: {0}'.format(topology_file)) self.mover.export_topology(topology_file) def extrapolate_in_time(self, extrapolate): """ :param extrapolate=false: allow current data to be extrapolated before and after file data. """ self.mover.extrapolate_in_time(extrapolate) def offset_time(self, time_offset): """ :param offset_time=0: allow data to be in GMT with a time zone offset (hours). """ self.mover.offset_time(time_offset * 3600.) def get_offset_time(self): """ :param offset_time=0: allow data to be in GMT with a time zone offset (hours). """ return self.mover.get_offset_time() / 3600. def get_start_time(self): """ :this will be the real_data_start time (seconds). """ return self.mover.get_start_time() def get_end_time(self): """ :this will be the real_data_stop time (seconds). """ return self.mover.get_end_time() def get_num_method(self): return self.mover.num_method
def __init__(self, filename, topology_file=None, extrapolate=False, time_offset=0, current_scale=1, uncertain_along=0.5, uncertain_across=0.25, num_method='Euler', **kwargs): """ Initialize a GridCurrentMover :param filename: absolute or relative path to the data file: could be netcdf or filelist :param topology_file=None: absolute or relative path to topology file. If not given, the GridCurrentMover will compute the topology from the data file. :param active_range: Range of datetimes for when the mover should be active :type active_range: 2-tuple of datetimes :param current_scale: Value to scale current data :param uncertain_duration: how often does a given uncertain element get reset :param uncertain_time_delay: when does the uncertainly kick in. :param uncertain_cross: Scale for uncertainty perpendicular to the flow :param uncertain_along: Scale for uncertainty parallel to the flow :param extrapolate: Allow current data to be extrapolated before and after file data :param time_offset: Time zone shift if data is in GMT :param num_method: Numerical method for calculating movement delta. Default Euler option: Runga-Kutta 4 (RK4) uses super, super(GridCurrentMover,self).__init__(\*\*kwargs) """ # if child is calling, the self.mover is set by child - do not reset if type(self) == GridCurrentMover: self.mover = CyGridCurrentMover() if not os.path.exists(filename): raise ValueError('Path for current file does not exist: {0}' .format(filename)) if topology_file is not None: if not os.path.exists(topology_file): raise ValueError('Path for Topology file does not exist: {0}' .format(topology_file)) super(GridCurrentMover, self).__init__(**kwargs) # check if this is stored with cy_gridcurrent_mover? self.filename = filename self.name = os.path.split(filename)[1] # check if this is stored with cy_gridcurrent_mover? self.topology_file = topology_file self.current_scale = current_scale self.uncertain_along = uncertain_along self.uncertain_across = uncertain_across self.mover.text_read(filename, topology_file) self.mover.extrapolate_in_time(extrapolate) self.mover.offset_time(time_offset * 3600.) self.num_method = num_method if self.topology_file is None: # this causes an error saving for currents that don't have topology #self.topology_file = filename + '.dat' #self.export_topology(self.topology_file) temp_topology_file = filename + '.dat' self.export_topology(temp_topology_file) if os.path.exists(temp_topology_file): self.topology_file = temp_topology_file
class GridCurrentMover(CurrentMoversBase): _schema = GridCurrentMoverSchema def __init__(self, filename, topology_file=None, extrapolate=False, time_offset=0, current_scale=1, uncertain_along=0.5, uncertain_across=0.25, num_method='Euler', **kwargs): """ Initialize a GridCurrentMover :param filename: absolute or relative path to the data file: could be netcdf or filelist :param topology_file=None: absolute or relative path to topology file. If not given, the GridCurrentMover will compute the topology from the data file. :param active_range: Range of datetimes for when the mover should be active :type active_range: 2-tuple of datetimes :param current_scale: Value to scale current data :param uncertain_duration: how often does a given uncertain element get reset :param uncertain_time_delay: when does the uncertainly kick in. :param uncertain_cross: Scale for uncertainty perpendicular to the flow :param uncertain_along: Scale for uncertainty parallel to the flow :param extrapolate: Allow current data to be extrapolated before and after file data :param time_offset: Time zone shift if data is in GMT :param num_method: Numerical method for calculating movement delta. Default Euler option: Runga-Kutta 4 (RK4) uses super, super(GridCurrentMover,self).__init__(\*\*kwargs) """ # if child is calling, the self.mover is set by child - do not reset if type(self) == GridCurrentMover: self.mover = CyGridCurrentMover() if not os.path.exists(filename): raise ValueError('Path for current file does not exist: {0}' .format(filename)) if topology_file is not None: if not os.path.exists(topology_file): raise ValueError('Path for Topology file does not exist: {0}' .format(topology_file)) super(GridCurrentMover, self).__init__(**kwargs) # check if this is stored with cy_gridcurrent_mover? self.filename = filename self.name = os.path.split(filename)[1] # check if this is stored with cy_gridcurrent_mover? self.topology_file = topology_file self.current_scale = current_scale self.uncertain_along = uncertain_along self.uncertain_across = uncertain_across self.mover.text_read(filename, topology_file) self.mover.extrapolate_in_time(extrapolate) self.mover.offset_time(time_offset * 3600.) self.num_method = num_method if self.topology_file is None: # this causes an error saving for currents that don't have topology #self.topology_file = filename + '.dat' #self.export_topology(self.topology_file) temp_topology_file = filename + '.dat' self.export_topology(temp_topology_file) if os.path.exists(temp_topology_file): self.topology_file = temp_topology_file def __repr__(self): return ('GridCurrentMover(' 'uncertain_duration={0.uncertain_duration},' 'uncertain_time_delay={0.uncertain_time_delay}, ' 'uncertain_cross={0.uncertain_cross}, ' 'uncertain_along={0.uncertain_along}, ' 'active_range={1.active_range}, ' 'on={1.on})' .format(self.mover, self)) def __str__(self): return ('GridCurrentMover - current _state.\n' ' uncertain_duration={0.uncertain_duration}\n' ' uncertain_time_delay={0.uncertain_time_delay}\n' ' uncertain_cross={0.uncertain_cross}\n' ' uncertain_along={0.uncertain_along}\n' ' active_range time={1.active_range}\n' ' current on/off status={1.on}' .format(self.mover, self)) # Define properties using lambda functions: uses lambda function, which are # accessible via fget/fset as follows: uncertain_cross = property(lambda self: self.mover.uncertain_cross, lambda self, val: setattr(self.mover, 'uncertain_cross', val)) uncertain_along = property(lambda self: self.mover.uncertain_along, lambda self, val: setattr(self.mover, 'uncertain_along', val)) current_scale = property(lambda self: self.mover.current_scale, lambda self, val: setattr(self.mover, 'current_scale', val)) extrapolate = property(lambda self: self.mover.extrapolate, lambda self, val: setattr(self.mover, 'extrapolate', val)) time_offset = property(lambda self: self.mover.time_offset / 3600., lambda self, val: setattr(self.mover, 'time_offset', val * 3600.)) @property def data_start(self): return sec_to_datetime(self.mover.get_start_time()) @property def data_stop(self): return sec_to_datetime(self.mover.get_end_time()) @property def num_method(self): return self._num_method @num_method.setter def num_method(self, val): self.mover.num_method = val self._num_method = val @property def is_data_on_cells(self): return self.mover._is_data_on_cells() def get_grid_data(self): """ The main function for getting grid data from the mover """ if self.mover._is_triangle_grid(): return self.get_triangles() else: return self.get_cells() def get_center_points(self): if self.mover._is_triangle_grid(): if self.mover._is_data_on_cells(): return self.get_triangle_center_points() else: return self.get_points() else: return self.get_cell_center_points() def get_scaled_velocities(self, time): """ :param model_time=0: """ num_tri = self.mover.get_num_triangles() # will need to update this for regular grids if self.mover._is_triangle_grid(): if self.mover._is_data_on_cells(): num_cells = num_tri else: num_vertices = self.mover.get_num_points() num_cells = num_vertices elif self.mover._is_regular_grid(): num_cells = self.mover.get_num_points() else: num_cells = num_tri / 2 vels = np.zeros(num_cells, dtype=basic_types.velocity_rec) self.mover.get_scaled_velocities(time, vels) return vels def export_topology(self, topology_file): """ :param topology_file=None: absolute or relative path where topology file will be written. """ if topology_file is None: raise ValueError('Topology file path required: {0}' .format(topology_file)) self.mover.export_topology(topology_file) def extrapolate_in_time(self, extrapolate): """ :param extrapolate=false: allow current data to be extrapolated before and after file data. """ self.mover.extrapolate_in_time(extrapolate) def offset_time(self, time_offset): """ :param offset_time=0: allow data to be in GMT with a time zone offset (hours). """ self.mover.offset_time(time_offset * 3600.) def get_offset_time(self): """ :param offset_time=0: allow data to be in GMT with a time zone offset (hours). """ return self.mover.get_offset_time() / 3600. def get_start_time(self): """ :this will be the real_data_start time (seconds). """ return self.mover.get_start_time() def get_end_time(self): """ :this will be the real_data_stop time (seconds). """ return self.mover.get_end_time() def get_num_method(self): return self.mover.num_method
class GridCurrentMover(CurrentMoversBase, serializable.Serializable): _update = ['uncertain_cross', 'uncertain_along', 'current_scale'] _save = ['uncertain_cross', 'uncertain_along', 'current_scale'] _state = copy.deepcopy(CurrentMoversBase._state) _state.add(update=_update, save=_save) _state.add_field([serializable.Field('filename', save=True, read=True, isdatafile=True, test_for_eq=False), serializable.Field('topology_file', save=True, read=True, isdatafile=True, test_for_eq=False)]) _schema = GridCurrentMoverSchema def __init__(self, filename, topology_file=None, extrapolate=False, time_offset=0, current_scale=1, uncertain_along=0.5, uncertain_across=0.25, **kwargs): """ Initialize a GridCurrentMover :param filename: absolute or relative path to the data file: could be netcdf or filelist :param topology_file=None: absolute or relative path to topology file. If not given, the GridCurrentMover will compute the topology from the data file. :param active_start: datetime when the mover should be active :param active_stop: datetime after which the mover should be inactive :param current_scale: Value to scale current data :param uncertain_duration: how often does a given uncertain element get reset :param uncertain_time_delay: when does the uncertainly kick in. :param uncertain_cross: Scale for uncertainty perpendicular to the flow :param uncertain_along: Scale for uncertainty parallel to the flow :param extrapolate: Allow current data to be extrapolated before and after file data :param time_offset: Time zone shift if data is in GMT uses super, super(GridCurrentMover,self).__init__(\*\*kwargs) """ # if child is calling, the self.mover is set by child - do not reset if type(self) == GridCurrentMover: self.mover = CyGridCurrentMover() if not os.path.exists(filename): raise ValueError('Path for current file does not exist: {0}' .format(filename)) if topology_file is not None: if not os.path.exists(topology_file): raise ValueError('Path for Topology file does not exist: {0}' .format(topology_file)) # check if this is stored with cy_gridcurrent_mover? self.filename = filename self.name = os.path.split(filename)[1] # check if this is stored with cy_gridcurrent_mover? self.topology_file = topology_file self.current_scale = current_scale self.uncertain_along = uncertain_along self.uncertain_across = uncertain_across self.mover.text_read(filename, topology_file) self.mover.extrapolate_in_time(extrapolate) self.mover.offset_time(time_offset * 3600.) super(GridCurrentMover, self).__init__(**kwargs) def __repr__(self): return ('GridCurrentMover(' 'uncertain_duration={0.uncertain_duration},' 'uncertain_time_delay={0.uncertain_time_delay}, ' 'uncertain_cross={0.uncertain_cross}, ' 'uncertain_along={0.uncertain_along}, ' 'active_start={1.active_start}, ' 'active_stop={1.active_stop}, ' 'on={1.on})'.format(self.mover, self)) def __str__(self): return ('GridCurrentMover - current _state.\n' ' uncertain_duration={0.uncertain_duration}\n' ' uncertain_time_delay={0.uncertain_time_delay}\n' ' uncertain_cross={0.uncertain_cross}\n' ' uncertain_along={0.uncertain_along}\n' ' active_start time={1.active_start}\n' ' active_stop time={1.active_stop}\n' ' current on/off status={1.on}' .format(self.mover, self)) # Define properties using lambda functions: uses lambda function, which are # accessible via fget/fset as follows: uncertain_cross = property(lambda self: self.mover.uncertain_cross, lambda self, val: setattr(self.mover, 'uncertain_cross', val)) uncertain_along = property(lambda self: self.mover.uncertain_along, lambda self, val: setattr(self.mover, 'uncertain_along', val)) current_scale = property(lambda self: self.mover.current_scale, lambda self, val: setattr(self.mover, 'current_scale', val)) extrapolate = property(lambda self: self.mover.extrapolate, lambda self, val: setattr(self.mover, 'extrapolate', val)) time_offset = property(lambda self: self.mover.time_offset / 3600., lambda self, val: setattr(self.mover, 'time_offset', val * 3600.)) def get_grid_data(self): """ The main function for getting grid data from the mover """ if self.mover._is_triangle_grid(): return self.get_triangles() else: return self.get_cells() def get_center_points(self): if self.mover._is_triangle_grid(): return self.get_triangle_center_points() else: return self.get_cell_center_points() def get_scaled_velocities(self, time): """ :param model_time=0: """ num_tri = self.mover.get_num_triangles() vels = np.zeros(num_tri, dtype=basic_types.velocity_rec) self.mover.get_scaled_velocities(time, vels) return vels def export_topology(self, topology_file): """ :param topology_file=None: absolute or relative path where topology file will be written. """ if topology_file is None: raise ValueError('Topology file path required: {0}' .format(topology_file)) self.mover.export_topology(topology_file) def extrapolate_in_time(self, extrapolate): """ :param extrapolate=false: allow current data to be extrapolated before and after file data. """ self.mover.extrapolate_in_time(extrapolate) def offset_time(self, time_offset): """ :param offset_time=0: allow data to be in GMT with a time zone offset (hours). """ self.mover.offset_time(time_offset * 3600.) def get_offset_time(self): """ :param offset_time=0: allow data to be in GMT with a time zone offset (hours). """ return (self.mover.get_offset_time()) / 3600.
class TestGridCurrentMover: cm = Common() gcm = CyGridCurrentMover() # delta = np.zeros((cm.num_le,), dtype=world_point) def move(self): self.gcm.prepare_for_model_run() print "Certain move" self.gcm.prepare_for_model_step(self.cm.model_time, self.cm.time_step) self.gcm.get_move( self.cm.model_time, self.cm.time_step, self.cm.ref, self.cm.delta, self.cm.status, spill_type.forecast, ) def move_uncertain(self): self.gcm.prepare_for_model_run() spill_size = np.zeros( (1, ), dtype=np.int32 ) # number of LEs in 1 uncertainty spill - simple test spill_size[0] = self.cm.num_le # for uncertainty spills start_pos = (-76.149368, 37.74496, 0) print "Uncertain move" self.gcm.prepare_for_model_step(self.cm.model_time, self.cm.time_step, 1, spill_size) self.gcm.get_move( self.cm.model_time, self.cm.time_step, self.cm.ref, self.cm.delta_uncertainty, self.cm.status, spill_type.uncertainty, ) def check_move(self): self.move() print self.cm.delta assert np.all(self.cm.delta['lat'] != 0) assert np.all(self.cm.delta['long'] != 0) def check_move_uncertain(self): self.move_uncertain() print self.cm.delta_uncertainty assert np.all(self.cm.delta_uncertainty['lat'] != 0) assert np.all(self.cm.delta_uncertainty['long'] != 0) def check_move_certain_uncertain(self, uncertain_time_delay=0): self.check_move() self.check_move_uncertain() tol = 1e-5 msg = r"{0} move is not within a tolerance of {1}" if uncertain_time_delay == 0: assert np.all( self.cm.delta_uncertainty['lat'] != self.cm.delta['lat']) assert np.all( self.cm.delta_uncertainty['long'] != self.cm.delta['long']) if uncertain_time_delay > 0: np.testing.assert_allclose( self.cm.delta['lat'], self.cm.delta_uncertainty['lat'], tol, tol, msg.format('grid_current.nc', tol), 0, ) np.testing.assert_allclose( self.cm.delta['long'], self.cm.delta_uncertainty['long'], tol, tol, msg.format('grid_current.nc', tol), 0, ) def test_move_reg(self): """ test move for a regular grid (first time in file) """ time = datetime.datetime(1999, 11, 29, 21) self.cm.model_time = time_utils.date_to_sec(time) time_grid_file = testdata['GridCurrentMover']['curr_reg'] self.gcm.text_read(time_grid_file) self.cm.ref[:]['long'] = 3.104588 # for simple example self.cm.ref[:]['lat'] = 52.016468 self.check_move() actual = np.empty((self.cm.num_le, ), dtype=world_point) actual[:]['lat'] = .003354610952486354 actual[:]['long'] = .0010056182923228838 actual[:]['z'] = 0. tol = 1e-5 msg = r"{0} move is not within a tolerance of {1}" np.testing.assert_allclose( self.cm.delta['lat'], actual['lat'], tol, tol, msg.format('test.cdf', tol), 0, ) np.testing.assert_allclose( self.cm.delta['long'], actual['long'], tol, tol, msg.format('test.cdf', tol), 0, ) # np.testing.assert_equal(self.cm.delta['z'], actual['z'], # "test_move_reg() failed", 0) np.all(self.cm.delta['z'] == 0) def test_move_curv(self): """ test move for a curvilinear grid (first time in file) """ time = datetime.datetime(2008, 1, 29, 17) self.cm.model_time = time_utils.date_to_sec(time) time_grid_file = testdata['GridCurrentMover']['curr_curv'] topology_file = testdata['GridCurrentMover']['top_curv'] self.gcm.text_read(time_grid_file, topology_file) # self.gcm.export_topology(topology_file2) self.cm.ref[:]['long'] = -74.03988 # for NY self.cm.ref[:]['lat'] = 40.536092 self.check_move() actual = np.empty((self.cm.num_le, ), dtype=world_point) actual[:]['lat'] = .000911 actual[:]['long'] = -.001288 tol = 1e-5 msg = r"{0} move is not within a tolerance of {1}" np.testing.assert_allclose( self.cm.delta['lat'], actual['lat'], tol, tol, msg.format('ny_cg.nc', tol), 0, ) np.testing.assert_allclose( self.cm.delta['long'], actual['long'], tol, tol, msg.format('ny_cg.nc', tol), 0, ) def test_move_curv_no_top(self): """ test move for a curvilinear grid (first time in file) """ time = datetime.datetime(2008, 1, 29, 17) self.cm.model_time = time_utils.date_to_sec(time) time_grid_file = testdata['GridCurrentMover']['curr_curv'] self.gcm.text_read(time_grid_file, topology_file=None) topology_file2 = os.path.join( os.path.split(time_grid_file)[0], 'NYTopologyNew.dat') self.gcm.export_topology(topology_file2) self.cm.ref[:]['long'] = -74.03988 # for NY self.cm.ref[:]['lat'] = 40.536092 self.check_move() actual = np.empty((self.cm.num_le, ), dtype=world_point) actual[:]['lat'] = .000911 actual[:]['long'] = -.001288 tol = 1e-5 msg = r"{0} move is not within a tolerance of {1}" np.testing.assert_allclose( self.cm.delta['lat'], actual['lat'], tol, tol, msg.format('ny_cg.nc', tol), 0, ) np.testing.assert_allclose( self.cm.delta['long'], actual['long'], tol, tol, msg.format('ny_cg.nc', tol), 0, ) def test_move_curv_series(self): """ Test a curvilinear file series - time in first file - time in second file """ # time = datetime.datetime(2009, 8, 2, 0) # first file time = datetime.datetime(2009, 8, 9, 0) # second file self.cm.model_time = time_utils.date_to_sec(time) time_grid_file = testdata['GridCurrentMover']['series_curv'] topology_file = testdata['GridCurrentMover']['series_top'] self.gcm.text_read(time_grid_file, topology_file) self.cm.ref[:]['long'] = -157.795728 # for HiROMS self.cm.ref[:]['lat'] = 21.069288 self.check_move() actual = np.empty((self.cm.num_le, ), dtype=world_point) #actual[:]['lat'] = -.003850193 # file 2 #actual[:]['long'] = .000152012 # updated to new curvilinear algorithm actual[:]['lat'] = .00292 # file 2 actual[:]['long'] = .00051458 tol = 1e-5 msg = r"{0} move is not within a tolerance of {1}" np.testing.assert_allclose( self.cm.delta['lat'], actual['lat'], tol, tol, msg.format('HiROMS', tol), 0, ) np.testing.assert_allclose( self.cm.delta['long'], actual['long'], tol, tol, msg.format('HiROMS', tol), 0, ) def test_move_tri(self): """ test move for a triangular grid (first time in file) """ time = datetime.datetime(2004, 12, 31, 13) self.cm.model_time = time_utils.date_to_sec(time) self.cm.uncertain = True time_grid_file = testdata['GridCurrentMover']['curr_tri'] topology_file = testdata['GridCurrentMover']['top_tri'] self.gcm.text_read(time_grid_file, topology_file) self.cm.ref[:]['long'] = -76.149368 # for ChesBay self.cm.ref[:]['lat'] = 37.74496 #self.check_move() self.check_move_certain_uncertain(self.gcm.uncertain_time_delay) actual = np.empty((self.cm.num_le, ), dtype=world_point) actual[:]['lat'] = .00148925 actual[:]['long'] = .00088789 tol = 1e-5 msg = r"{0} move is not within a tolerance of {1}" np.testing.assert_allclose( self.cm.delta['lat'], actual['lat'], tol, tol, msg.format('ches_bay', tol), 0, ) np.testing.assert_allclose( self.cm.delta['long'], actual['long'], tol, tol, msg.format('ches_bay', tol), 0, ) #check that certain and uncertain are the same if uncertainty is time delayed #self.gcm.uncertain_time_delay = 3 self.gcm.uncertain_time_delay = 10800 # cython expects time_delay in seconds self.check_move_certain_uncertain(self.gcm.uncertain_time_delay) def test_move_ptcur(self): """ test move for a ptCur grid (first time in file) """ time = datetime.datetime(2000, 2, 14, 10) self.cm.model_time = time_utils.date_to_sec(time) time_grid_file = testdata['GridCurrentMover']['ptCur'] self.gcm.text_read(time_grid_file) self.cm.ref[:]['long'] = -124.686928 # for ptCur test self.cm.ref[:]['lat'] = 48.401124 self.check_move() actual = np.empty((self.cm.num_le, ), dtype=world_point) actual[:]['lat'] = .0161987 actual[:]['long'] = -.02439887 tol = 1e-5 msg = r"{0} move is not within a tolerance of {1}" np.testing.assert_allclose( self.cm.delta['lat'], actual['lat'], tol, tol, msg.format('ptcur', tol), 0, ) np.testing.assert_allclose( self.cm.delta['long'], actual['long'], tol, tol, msg.format('ptcur', tol), 0, ) def test_move_ptcur_extrapolate(self): """ test move for a ptCur grid (first time in file) """ time = datetime.datetime(2000, 2, 14, 8) # time before first time in file self.cm.model_time = time_utils.date_to_sec(time) time_grid_file = testdata['GridCurrentMover']['ptCur'] self.gcm.text_read(time_grid_file) self.gcm.extrapolate_in_time( True) # result of move should be same as first step self.cm.ref[:]['long'] = -124.686928 # for ptCur test self.cm.ref[:]['lat'] = 48.401124 self.check_move() actual = np.empty((self.cm.num_le, ), dtype=world_point) actual[:]['lat'] = .0161987 actual[:]['long'] = -.02439887 tol = 1e-5 msg = r"{0} move is not within a tolerance of {1}" np.testing.assert_allclose( self.cm.delta['lat'], actual['lat'], tol, tol, msg.format('ptcur', tol), 0, ) np.testing.assert_allclose( self.cm.delta['long'], actual['long'], tol, tol, msg.format('ptcur', tol), 0, ) def test_move_gridcurtime(self): """ test move for a gridCurTime, grid current time series, file (first time in file) """ time = datetime.datetime(2002, 1, 30, 1) self.cm.model_time = time_utils.date_to_sec(time) time_grid_file = testdata['GridCurrentMover']['grid_ts'] self.gcm.text_read(time_grid_file) self.cm.ref[:]['long'] = -119.933264 # for gridCur test self.cm.ref[:]['lat'] = 34.138736 self.check_move() actual = np.empty((self.cm.num_le, ), dtype=world_point) actual[:]['lat'] = -0.0034527536849574456 actual[:]['long'] = 0.005182449331779978 actual[:]['z'] = 0. tol = 1e-5 msg = r"{0} move is not within a tolerance of {1}" np.testing.assert_allclose( self.cm.delta['lat'], actual['lat'], tol, tol, msg.format('gridcurtime', tol), 0, ) np.testing.assert_allclose( self.cm.delta['long'], actual['long'], tol, tol, msg.format('gridcurtime', tol), 0, ) # np.testing.assert_equal(self.cm.delta, actual, # "test_move_gridcurtime() failed", 0) np.all(self.cm.delta['z'] == 0) def test_move_gridcur_series(self): """ test move for a gridCur file series (first time in first file) """ time = datetime.datetime(2002, 1, 30, 1) self.cm.model_time = time_utils.date_to_sec(time) time_grid_file = testdata['GridCurrentMover']['series_gridCur'] topology_file = r"" self.gcm.text_read(time_grid_file, topology_file) self.cm.ref[:]['long'] = -119.933264 # for gridCur test self.cm.ref[:]['lat'] = 34.138736 self.check_move() actual = np.empty((self.cm.num_le, ), dtype=world_point) actual[:]['lat'] = -0.0034527536849574456 actual[:]['long'] = 0.005182449331779978 actual[:]['z'] = 0. tol = 1e-5 msg = r"{0} move is not within a tolerance of {1}" np.testing.assert_allclose( self.cm.delta['lat'], actual['lat'], tol, tol, msg.format('gridcur series', tol), 0, ) np.testing.assert_allclose( self.cm.delta['long'], actual['long'], tol, tol, msg.format('gridcur series', tol), 0, ) # np.testing.assert_equal(self.cm.delta, actual, # "test_move_gridcur_series() failed", 0) np.all(self.cm.delta['z'] == 0)