def test_filter(self):
pdict_id = self.dataset_management.read_parameter_dictionary_by_name('ctd_parsed_param_dict', id_only=True)
filtered_stream_def_id = self.pubsub_management.create_stream_definition('filtered', parameter_dictionary_id=pdict_id, available_fields=['time', 'temp'])
self.addCleanup(self.pubsub_management.delete_stream_definition, filtered_stream_def_id)
rdt = RecordDictionaryTool(stream_definition_id=filtered_stream_def_id)
self.assertEquals(rdt._available_fields,['time','temp'])
rdt['time'] = np.arange(20)
rdt['temp'] = np.arange(20)
with self.assertRaises(KeyError):
rdt['pressure'] = np.arange(20)
granule = rdt.to_granule()
rdt2 = RecordDictionaryTool.load_from_granule(granule)
self.assertEquals(rdt._available_fields, rdt2._available_fields)
self.assertEquals(rdt.fields, rdt2.fields)
for k,v in rdt.iteritems():
self.assertTrue(np.array_equal(rdt[k], rdt2[k]))
class CoverageCraft(object):
'''
AKA the BlackBox
PFM courtesy of Tommy Vandesteene
'''
def __init__(self,coverage=None, granule=None):
if coverage is None:
self.coverage = self.create_coverage()
self.rdt = RecordDictionaryTool(param_dictionary=self.coverage.parameter_dictionary)
else:
self.coverage = coverage
if granule is not None:
self.sync_with_granule(granule)
else:
self.rdt = RecordDictionaryTool(param_dictionary=self.coverage.parameter_dictionary)
self.pdict = self.coverage.parameter_dictionary
def sync_rdt_with_granule(self, granule):
rdt = RecordDictionaryTool.load_from_granule(granule)
self.rdt = rdt
return rdt
def sync_with_granule(self, granule=None):
if granule is not None:
self.sync_rdt_with_granule(granule)
if self.rdt is None:
log.error('Failed to add granule, no granule assigned.')
return
start_index = self.coverage.num_timesteps
elements = self.rdt._shp[0]
if not elements: return
self.coverage.insert_timesteps(elements)
for k,v in self.rdt.iteritems():
log.info("key: %s" , k)
log.info("value: %s" , v)
slice_ = slice(start_index,None)
log.info("slice: %s", slice_)
self.coverage.set_parameter_values(param_name=k,tdoa=slice_, value=v)
def sync_rdt_with_coverage(self, coverage=None, tdoa=None, start_time=None, end_time=None, stride_time=None, parameters=None):
'''
Builds a granule based on the coverage
'''
if coverage is None:
coverage = self.coverage
slice_ = slice(None) # Defaults to all values
if tdoa is not None and isinstance(tdoa,slice):
slice_ = tdoa
elif stride_time is not None:
validate_is_instance(start_time, Number, 'start_time must be a number for striding.')
validate_is_instance(end_time, Number, 'end_time must be a number for striding.')
validate_is_instance(stride_time, Number, 'stride_time must be a number for striding.')
ugly_range = np.arange(start_time, end_time, stride_time)
idx_values = [TimeUtils.get_relative_time(coverage,i) for i in ugly_range]
slice_ = [idx_values]
elif not (start_time is None and end_time is None):
time_var = coverage._temporal_param_name
uom = coverage.get_parameter_context(time_var).uom
if start_time is not None:
start_units = TimeUtils.ts_to_units(uom,start_time)
log.info('Units: %s', start_units)
start_idx = TimeUtils.get_relative_time(coverage,start_units)
log.info('Start Index: %s', start_idx)
start_time = start_idx
if end_time is not None:
end_units = TimeUtils.ts_to_units(uom,end_time)
log.info('End units: %s', end_units)
end_idx = TimeUtils.get_relative_time(coverage,end_units)
log.info('End index: %s', end_idx)
end_time = end_idx
slice_ = slice(start_time,end_time,stride_time)
log.info('Slice: %s', slice_)
if parameters is not None:
pdict = ParameterDictionary()
params = set(coverage.list_parameters()).intersection(parameters)
for param in params:
pdict.add_context(coverage.get_parameter_context(param))
rdt = RecordDictionaryTool(param_dictionary=pdict)
self.pdict = pdict
else:
rdt = RecordDictionaryTool(param_dictionary=coverage.parameter_dictionary)
fields = coverage.list_parameters()
if parameters is not None:
fields = set(fields).intersection(parameters)
for d in fields:
rdt[d] = coverage.get_parameter_values(d,tdoa=slice_)
self.rdt = rdt # Sync
def to_granule(self):
return self.rdt.to_granule()
@classmethod
def create_coverage(cls):
pdict = cls.create_parameters()
sdom, tdom = cls.create_domains()
scov = SimplexCoverage('sample grid coverage_model', pdict, tdom, sdom)
return scov
@classmethod
def create_domains(cls):
'''
WARNING: This method is a wrapper intended only for tests, it should not be used in production code.
It probably will not align to most datasets.
'''
tcrs = CRS([AxisTypeEnum.TIME])
scrs = CRS([AxisTypeEnum.LON, AxisTypeEnum.LAT, AxisTypeEnum.HEIGHT])
tdom = GridDomain(GridShape('temporal', [0]), tcrs, MutabilityEnum.EXTENSIBLE)
sdom = GridDomain(GridShape('spatial', [0]), scrs, MutabilityEnum.IMMUTABLE) # Dimensionality is excluded for now
return sdom, tdom
@classmethod
def create_parameters(cls):
'''
WARNING: This method is a wrapper intended only for tests, it should not be used in production code.
It probably will not align to most datasets.
'''
pdict = ParameterDictionary()
t_ctxt = ParameterContext('time', param_type=QuantityType(value_encoding=np.int64))
t_ctxt.axis = AxisTypeEnum.TIME
t_ctxt.uom = 'seconds since 1970-01-01'
t_ctxt.fill_value = 0x0
pdict.add_context(t_ctxt)
lat_ctxt = ParameterContext('lat', param_type=QuantityType(value_encoding=np.float32))
lat_ctxt.axis = AxisTypeEnum.LAT
lat_ctxt.uom = 'degree_north'
lat_ctxt.fill_value = 0e0
pdict.add_context(lat_ctxt)
lon_ctxt = ParameterContext('lon', param_type=QuantityType(value_encoding=np.float32))
lon_ctxt.axis = AxisTypeEnum.LON
lon_ctxt.uom = 'degree_east'
lon_ctxt.fill_value = 0e0
pdict.add_context(lon_ctxt)
temp_ctxt = ParameterContext('temp', param_type=QuantityType(value_encoding=np.float32))
temp_ctxt.uom = 'degree_Celsius'
temp_ctxt.fill_value = 0e0
pdict.add_context(temp_ctxt)
cond_ctxt = ParameterContext('conductivity', param_type=QuantityType(value_encoding=np.float32))
cond_ctxt.uom = 'unknown'
cond_ctxt.fill_value = 0e0
pdict.add_context(cond_ctxt)
data_ctxt = ParameterContext('data', param_type=QuantityType(value_encoding=np.int8))
data_ctxt.uom = 'byte'
data_ctxt.fill_value = 0x0
pdict.add_context(data_ctxt)
pres_ctxt = ParameterContext('pressure', param_type=QuantityType(value_encoding=np.float32))
pres_ctxt.uom = 'Pascal'
pres_ctxt.fill_value = 0x0
pdict.add_context(pres_ctxt)
sal_ctxt = ParameterContext('salinity', param_type=QuantityType(value_encoding=np.float32))
sal_ctxt.uom = 'PSU'
sal_ctxt.fill_value = 0x0
pdict.add_context(sal_ctxt)
dens_ctxt = ParameterContext('density', param_type=QuantityType(value_encoding=np.float32))
dens_ctxt.uom = 'unknown'
dens_ctxt.fill_value = 0x0
pdict.add_context(dens_ctxt)
return pdict
def build_coverage(self):
pass
class CoverageCraft(object):
'''
AKA the BlackBox
PFM courtesy of Tommy Vandesteene
'''
def __init__(self, coverage=None, granule=None):
if coverage is None:
self.coverage = self.create_coverage()
self.rdt = RecordDictionaryTool(
param_dictionary=self.coverage.parameter_dictionary)
else:
self.coverage = coverage
if granule is not None:
self.sync_with_granule(granule)
else:
self.rdt = RecordDictionaryTool(
param_dictionary=self.coverage.parameter_dictionary)
self.pdict = self.coverage.parameter_dictionary
def sync_rdt_with_granule(self, granule):
rdt = RecordDictionaryTool.load_from_granule(granule)
self.rdt = rdt
return rdt
def sync_with_granule(self, granule=None):
if granule is not None:
self.sync_rdt_with_granule(granule)
if self.rdt is None:
log.error('Failed to add granule, no granule assigned.')
return
start_index = self.coverage.num_timesteps
elements = self.rdt._shp[0]
if not elements: return
self.coverage.insert_timesteps(elements)
for k, v in self.rdt.iteritems():
log.info("key: %s", k)
log.info("value: %s", v)
slice_ = slice(start_index, None)
log.info("slice: %s", slice_)
self.coverage.set_parameter_values(param_name=k,
tdoa=slice_,
value=v)
def sync_rdt_with_coverage(self,
coverage=None,
tdoa=None,
start_time=None,
end_time=None,
stride_time=None,
parameters=None):
'''
Builds a granule based on the coverage
'''
if coverage is None:
coverage = self.coverage
slice_ = slice(None) # Defaults to all values
if tdoa is not None and isinstance(tdoa, slice):
slice_ = tdoa
elif stride_time is not None:
validate_is_instance(start_time, Number,
'start_time must be a number for striding.')
validate_is_instance(end_time, Number,
'end_time must be a number for striding.')
validate_is_instance(stride_time, Number,
'stride_time must be a number for striding.')
ugly_range = np.arange(start_time, end_time, stride_time)
idx_values = [
TimeUtils.get_relative_time(coverage, i) for i in ugly_range
]
slice_ = [idx_values]
elif not (start_time is None and end_time is None):
time_var = coverage._temporal_param_name
uom = coverage.get_parameter_context(time_var).uom
if start_time is not None:
start_units = TimeUtils.ts_to_units(uom, start_time)
log.info('Units: %s', start_units)
start_idx = TimeUtils.get_relative_time(coverage, start_units)
log.info('Start Index: %s', start_idx)
start_time = start_idx
if end_time is not None:
end_units = TimeUtils.ts_to_units(uom, end_time)
log.info('End units: %s', end_units)
end_idx = TimeUtils.get_relative_time(coverage, end_units)
log.info('End index: %s', end_idx)
end_time = end_idx
slice_ = slice(start_time, end_time, stride_time)
log.info('Slice: %s', slice_)
if parameters is not None:
pdict = ParameterDictionary()
params = set(coverage.list_parameters()).intersection(parameters)
for param in params:
pdict.add_context(coverage.get_parameter_context(param))
rdt = RecordDictionaryTool(param_dictionary=pdict)
self.pdict = pdict
else:
rdt = RecordDictionaryTool(
param_dictionary=coverage.parameter_dictionary)
fields = coverage.list_parameters()
if parameters is not None:
fields = set(fields).intersection(parameters)
for d in fields:
rdt[d] = coverage.get_parameter_values(d, tdoa=slice_)
self.rdt = rdt # Sync
def to_granule(self):
return self.rdt.to_granule()
@classmethod
def create_coverage(cls):
pdict = cls.create_parameters()
sdom, tdom = cls.create_domains()
scov = SimplexCoverage('sample grid coverage_model', pdict, tdom, sdom)
return scov
@classmethod
def create_domains(cls):
'''
WARNING: This method is a wrapper intended only for tests, it should not be used in production code.
It probably will not align to most datasets.
'''
tcrs = CRS([AxisTypeEnum.TIME])
scrs = CRS([AxisTypeEnum.LON, AxisTypeEnum.LAT, AxisTypeEnum.HEIGHT])
tdom = GridDomain(GridShape('temporal', [0]), tcrs,
MutabilityEnum.EXTENSIBLE)
sdom = GridDomain(
GridShape('spatial', [0]), scrs,
MutabilityEnum.IMMUTABLE) # Dimensionality is excluded for now
return sdom, tdom
@classmethod
def create_parameters(cls):
'''
WARNING: This method is a wrapper intended only for tests, it should not be used in production code.
It probably will not align to most datasets.
'''
pdict = ParameterDictionary()
t_ctxt = ParameterContext(
'time', param_type=QuantityType(value_encoding=np.int64))
t_ctxt.axis = AxisTypeEnum.TIME
t_ctxt.uom = 'seconds since 1970-01-01'
t_ctxt.fill_value = 0x0
pdict.add_context(t_ctxt)
lat_ctxt = ParameterContext(
'lat', param_type=QuantityType(value_encoding=np.float32))
lat_ctxt.axis = AxisTypeEnum.LAT
lat_ctxt.uom = 'degree_north'
lat_ctxt.fill_value = 0e0
pdict.add_context(lat_ctxt)
lon_ctxt = ParameterContext(
'lon', param_type=QuantityType(value_encoding=np.float32))
lon_ctxt.axis = AxisTypeEnum.LON
lon_ctxt.uom = 'degree_east'
lon_ctxt.fill_value = 0e0
pdict.add_context(lon_ctxt)
temp_ctxt = ParameterContext(
'temp', param_type=QuantityType(value_encoding=np.float32))
temp_ctxt.uom = 'degree_Celsius'
temp_ctxt.fill_value = 0e0
pdict.add_context(temp_ctxt)
cond_ctxt = ParameterContext(
'conductivity', param_type=QuantityType(value_encoding=np.float32))
cond_ctxt.uom = 'unknown'
cond_ctxt.fill_value = 0e0
pdict.add_context(cond_ctxt)
data_ctxt = ParameterContext(
'data', param_type=QuantityType(value_encoding=np.int8))
data_ctxt.uom = 'byte'
data_ctxt.fill_value = 0x0
pdict.add_context(data_ctxt)
pres_ctxt = ParameterContext(
'pressure', param_type=QuantityType(value_encoding=np.float32))
pres_ctxt.uom = 'Pascal'
pres_ctxt.fill_value = 0x0
pdict.add_context(pres_ctxt)
sal_ctxt = ParameterContext(
'salinity', param_type=QuantityType(value_encoding=np.float32))
sal_ctxt.uom = 'PSU'
sal_ctxt.fill_value = 0x0
pdict.add_context(sal_ctxt)
dens_ctxt = ParameterContext(
'density', param_type=QuantityType(value_encoding=np.float32))
dens_ctxt.uom = 'unknown'
dens_ctxt.fill_value = 0x0
pdict.add_context(dens_ctxt)
return pdict
def build_coverage(self):
pass
def test_granule(self):
pdict_id = self.dataset_management.read_parameter_dictionary_by_name('ctd_parsed_param_dict', id_only=True)
stream_def_id = self.pubsub_management.create_stream_definition('ctd', parameter_dictionary_id=pdict_id)
pdict = DatasetManagementService.get_parameter_dictionary_by_name('ctd_parsed_param_dict')
self.addCleanup(self.pubsub_management.delete_stream_definition,stream_def_id)
stream_id, route = self.pubsub_management.create_stream('ctd_stream', 'xp1', stream_definition_id=stream_def_id)
self.addCleanup(self.pubsub_management.delete_stream,stream_id)
self.xps.append('xp1')
publisher = StandaloneStreamPublisher(stream_id, route)
subscriber = StandaloneStreamSubscriber('sub', self.verify_incoming)
subscriber.start()
subscription_id = self.pubsub_management.create_subscription('sub', stream_ids=[stream_id])
self.xns.append('sub')
self.pubsub_management.activate_subscription(subscription_id)
rdt = RecordDictionaryTool(stream_definition_id=stream_def_id)
rdt['time'] = np.arange(10)
rdt['temp'] = np.random.randn(10) * 10 + 30
rdt['pressure'] = [20] * 10
self.assertEquals(set(pdict.keys()), set(rdt.fields))
self.assertEquals(pdict.temporal_parameter_name, rdt.temporal_parameter)
self.rdt = rdt
self.data_producer_id = 'data_producer'
self.provider_metadata_update = {1:1}
publisher.publish(rdt.to_granule(data_producer_id='data_producer', provider_metadata_update={1:1}))
self.assertTrue(self.event.wait(10))
self.pubsub_management.deactivate_subscription(subscription_id)
self.pubsub_management.delete_subscription(subscription_id)
filtered_stream_def_id = self.pubsub_management.create_stream_definition('filtered', parameter_dictionary_id=pdict_id, available_fields=['time', 'temp'])
self.addCleanup(self.pubsub_management.delete_stream_definition, filtered_stream_def_id)
rdt = RecordDictionaryTool(stream_definition_id=filtered_stream_def_id)
self.assertEquals(rdt._available_fields,['time','temp'])
rdt['time'] = np.arange(20)
rdt['temp'] = np.arange(20)
with self.assertRaises(KeyError):
rdt['pressure'] = np.arange(20)
granule = rdt.to_granule()
rdt2 = RecordDictionaryTool.load_from_granule(granule)
self.assertEquals(rdt._available_fields, rdt2._available_fields)
self.assertEquals(rdt.fields, rdt2.fields)
for k,v in rdt.iteritems():
self.assertTrue(np.array_equal(rdt[k], rdt2[k]))
rdt = RecordDictionaryTool(stream_definition_id=stream_def_id)
rdt['time'] = np.array([None,None,None])
self.assertTrue(rdt['time'] is None)
rdt['time'] = np.array([None, 1, 2])
self.assertEquals(rdt['time'][0], rdt.fill_value('time'))
def test_granule(self):
pdict_id = self.dataset_management.read_parameter_dictionary_by_name(
'ctd_parsed_param_dict', id_only=True)
stream_def_id = self.pubsub_management.create_stream_definition(
'ctd', parameter_dictionary_id=pdict_id)
pdict = DatasetManagementService.get_parameter_dictionary_by_name(
'ctd_parsed_param_dict')
self.addCleanup(self.pubsub_management.delete_stream_definition,
stream_def_id)
stream_id, route = self.pubsub_management.create_stream(
'ctd_stream', 'xp1', stream_definition_id=stream_def_id)
self.addCleanup(self.pubsub_management.delete_stream, stream_id)
self.xps.append('xp1')
publisher = StandaloneStreamPublisher(stream_id, route)
subscriber = StandaloneStreamSubscriber('sub', self.verify_incoming)
subscriber.start()
subscription_id = self.pubsub_management.create_subscription(
'sub', stream_ids=[stream_id])
self.xns.append('sub')
self.pubsub_management.activate_subscription(subscription_id)
rdt = RecordDictionaryTool(stream_definition_id=stream_def_id)
rdt['time'] = np.arange(10)
rdt['temp'] = np.random.randn(10) * 10 + 30
rdt['pressure'] = [20] * 10
self.assertEquals(set(pdict.keys()), set(rdt.fields))
self.assertEquals(pdict.temporal_parameter_name,
rdt.temporal_parameter)
self.rdt = rdt
self.data_producer_id = 'data_producer'
self.provider_metadata_update = {1: 1}
publisher.publish(
rdt.to_granule(data_producer_id='data_producer',
provider_metadata_update={1: 1}))
self.assertTrue(self.event.wait(10))
self.pubsub_management.deactivate_subscription(subscription_id)
self.pubsub_management.delete_subscription(subscription_id)
filtered_stream_def_id = self.pubsub_management.create_stream_definition(
'filtered',
parameter_dictionary_id=pdict_id,
available_fields=['time', 'temp'])
self.addCleanup(self.pubsub_management.delete_stream_definition,
filtered_stream_def_id)
rdt = RecordDictionaryTool(stream_definition_id=filtered_stream_def_id)
self.assertEquals(rdt._available_fields, ['time', 'temp'])
rdt['time'] = np.arange(20)
rdt['temp'] = np.arange(20)
with self.assertRaises(KeyError):
rdt['pressure'] = np.arange(20)
granule = rdt.to_granule()
rdt2 = RecordDictionaryTool.load_from_granule(granule)
self.assertEquals(rdt._available_fields, rdt2._available_fields)
self.assertEquals(rdt.fields, rdt2.fields)
for k, v in rdt.iteritems():
self.assertTrue(np.array_equal(rdt[k], rdt2[k]))
rdt = RecordDictionaryTool(stream_definition_id=stream_def_id)
rdt['time'] = np.array([None, None, None])
self.assertTrue(rdt['time'] is None)
rdt['time'] = np.array([None, 1, 2])
self.assertEquals(rdt['time'][0], rdt.fill_value('time'))
class CoverageCraft(object):
'''
AKA the BlackBox
PFM courtesy of Tommy Vandesteene
'''
def __init__(self,coverage=None, granule=None):
if coverage is None:
self.coverage = self.create_coverage()
self.rdt = RecordDictionaryTool(param_dictionary=self.coverage.parameter_dictionary)
else:
self.coverage = coverage
if granule is not None:
self.sync_with_granule(granule)
else:
self.rdt = RecordDictionaryTool(param_dictionary=self.coverage.parameter_dictionary)
self.pdict = self.coverage.parameter_dictionary
def sync_rdt_with_granule(self, granule):
rdt = RecordDictionaryTool.load_from_granule(granule)
self.rdt = rdt
return rdt
def sync_with_granule(self, granule=None):
if granule is not None:
self.sync_rdt_with_granule(granule)
if self.rdt is None:
log.error('Failed to add granule, no granule assigned.')
return
start_index = self.coverage.num_timesteps
elements = self.rdt._shp[0]
if not elements: return
self.coverage.insert_timesteps(elements)
for k,v in self.rdt.iteritems():
log.info("key: %s" , k)
log.info("value: %s" , v)
slice_ = slice(start_index,None)
log.info("slice: %s", slice_)
self.coverage.set_parameter_values(param_name=k,tdoa=slice_, value=v)
def sync_rdt_with_coverage(self, coverage=None, tdoa=None, start_time=None, end_time=None, stride_time=None, parameters=None):
'''
Builds a granule based on the coverage
'''
if coverage is None:
coverage = self.coverage
slice_ = slice(None) # Defaults to all values
if tdoa is not None and isinstance(tdoa,slice):
slice_ = tdoa
elif stride_time is not None:
validate_is_instance(start_time, Number, 'start_time must be a number for striding.')
validate_is_instance(end_time, Number, 'end_time must be a number for striding.')
validate_is_instance(stride_time, Number, 'stride_time must be a number for striding.')
ugly_range = np.arange(start_time, end_time, stride_time)
idx_values = [self.get_relative_time(coverage,i) for i in ugly_range]
slice_ = [idx_values]
elif not (start_time is None and end_time is None):
time_var = coverage._temporal_param_name
uom = coverage.get_parameter_context(time_var).uom
if start_time is not None:
start_units = self.ts_to_units(uom,start_time)
log.info('Units: %s', start_units)
start_idx = self.get_relative_time(coverage,start_units)
log.info('Start Index: %s', start_idx)
start_time = start_idx
if end_time is not None:
end_units = self.ts_to_units(uom,end_time)
log.info('End units: %s', end_units)
end_idx = self.get_relative_time(coverage,end_units)
log.info('End index: %s', end_idx)
end_time = end_idx
slice_ = slice(start_time,end_time,stride_time)
log.info('Slice: %s', slice_)
if parameters is not None:
pdict = ParameterDictionary()
params = set(coverage.list_parameters()).intersection(parameters)
for param in params:
pdict.add_context(coverage.get_parameter_context(param))
rdt = RecordDictionaryTool(param_dictionary=pdict)
self.pdict = pdict
else:
rdt = RecordDictionaryTool(param_dictionary=coverage.parameter_dictionary)
fields = coverage.list_parameters()
if parameters is not None:
fields = set(fields).intersection(parameters)
for d in fields:
rdt[d] = coverage.get_parameter_values(d,tdoa=slice_)
self.rdt = rdt # Sync
def to_granule(self):
return self.rdt.to_granule()
@classmethod
def create_coverage(cls):
pdict = cls.create_parameters()
sdom, tdom = cls.create_domains()
scov = SimplexCoverage('sample grid coverage_model', pdict, tdom, sdom)
return scov
@classmethod
def create_domains(cls):
'''
WARNING: This method is a wrapper intended only for tests, it should not be used in production code.
It probably will not align to most datasets.
'''
tcrs = CRS([AxisTypeEnum.TIME])
scrs = CRS([AxisTypeEnum.LON, AxisTypeEnum.LAT, AxisTypeEnum.HEIGHT])
tdom = GridDomain(GridShape('temporal', [0]), tcrs, MutabilityEnum.EXTENSIBLE)
sdom = GridDomain(GridShape('spatial', [0]), scrs, MutabilityEnum.IMMUTABLE) # Dimensionality is excluded for now
return sdom, tdom
@classmethod
def create_parameters(cls):
'''
WARNING: This method is a wrapper intended only for tests, it should not be used in production code.
It probably will not align to most datasets.
'''
pdict = ParameterDictionary()
t_ctxt = ParameterContext('time', param_type=QuantityType(value_encoding=np.int64))
t_ctxt.axis = AxisTypeEnum.TIME
t_ctxt.uom = 'seconds since 1970-01-01'
t_ctxt.fill_value = 0x0
pdict.add_context(t_ctxt)
lat_ctxt = ParameterContext('lat', param_type=QuantityType(value_encoding=np.float32))
lat_ctxt.axis = AxisTypeEnum.LAT
lat_ctxt.uom = 'degree_north'
lat_ctxt.fill_value = 0e0
pdict.add_context(lat_ctxt)
lon_ctxt = ParameterContext('lon', param_type=QuantityType(value_encoding=np.float32))
lon_ctxt.axis = AxisTypeEnum.LON
lon_ctxt.uom = 'degree_east'
lon_ctxt.fill_value = 0e0
pdict.add_context(lon_ctxt)
temp_ctxt = ParameterContext('temp', param_type=QuantityType(value_encoding=np.float32))
temp_ctxt.uom = 'degree_Celsius'
temp_ctxt.fill_value = 0e0
pdict.add_context(temp_ctxt)
cond_ctxt = ParameterContext('conductivity', param_type=QuantityType(value_encoding=np.float32))
cond_ctxt.uom = 'unknown'
cond_ctxt.fill_value = 0e0
pdict.add_context(cond_ctxt)
data_ctxt = ParameterContext('data', param_type=QuantityType(value_encoding=np.int8))
data_ctxt.uom = 'byte'
data_ctxt.fill_value = 0x0
pdict.add_context(data_ctxt)
pres_ctxt = ParameterContext('pressure', param_type=QuantityType(value_encoding=np.float32))
pres_ctxt.uom = 'Pascal'
pres_ctxt.fill_value = 0x0
pdict.add_context(pres_ctxt)
sal_ctxt = ParameterContext('salinity', param_type=QuantityType(value_encoding=np.float32))
sal_ctxt.uom = 'PSU'
sal_ctxt.fill_value = 0x0
pdict.add_context(sal_ctxt)
dens_ctxt = ParameterContext('density', param_type=QuantityType(value_encoding=np.float32))
dens_ctxt.uom = 'unknown'
dens_ctxt.fill_value = 0x0
pdict.add_context(dens_ctxt)
return pdict
@classmethod
def get_relative_time(cls, coverage, time):
'''
Determines the relative time in the coverage model based on a given time
The time must match the coverage's time units
'''
time_name = coverage._temporal_param_name
pc = coverage.get_parameter_context(time_name)
units = pc.uom
if 'iso' in units:
return None # Not sure how to implement this.... How do you compare iso strings effectively?
values = coverage.get_parameter_values(time_name)
return cls.find_nearest(values,time)
@classmethod
def find_nearest(cls, arr, val):
'''
The sexiest algorithm for finding the best matching value for a numpy array
'''
idx = np.abs(arr-val).argmin()
return idx
@staticmethod
def ts_to_units(units, val):
'''
Converts a unix timestamp into various formats
Example:
ts = time.time()
CoverageCraft.ts_to_units('days since 2000-01-01', ts)
'''
if 'iso' in units:
return time.strftime('%Y-%d-%mT%H:%M:%S', time.gmtime(val))
elif 'since' in units:
t = netCDF4.netcdftime.utime(units)
return t.date2num(datetime.datetime.utcfromtimestamp(val))
else:
return val
@staticmethod
def units_to_ts(units, val):
'''
Converts known time formats into a unix timestamp
Example:
ts = CoverageCraft.units_to_ts('days since 2000-01-01', 1200)
'''
if 'since' in units:
t = netCDF4.netcdftime.utime(units)
dtg = t.num2date(val)
return time.mktime(dtg.timetuple())
elif 'iso' in units:
t = dateutil.parser.parse(val)
return time.mktime(t.timetuple())
else:
return val
def build_coverage(self):
pass