def execute(input=None,
context=None,
config=None,
params=None,
state=None):
rdt = RecordDictionaryTool.load_from_granule(input)
out_rdt = RecordDictionaryTool(stream_definition_id=params)
conductivity = rdt['conductivity']
pressure = rdt['pressure']
temperature = rdt['temp']
sal_value = SP_from_cndr(r=conductivity / cte.C3515,
t=temperature,
p=pressure)
log.debug(
"Salinity algorithm calculated the sp (practical salinity) values: %s",
sal_value)
for key, value in rdt.iteritems():
if key in out_rdt:
if key == 'conductivity' or key == 'temp' or key == 'pressure':
continue
out_rdt[key] = value[:]
out_rdt['salinity'] = sal_value
return out_rdt.to_granule()
def validate_multiple_vis_queue_messages(self, msg1, msg2):
assertions = self.assertTrue
# verify that the salinity in msg2 is a result of content from msg1
rdt1 = RecordDictionaryTool.load_from_granule(msg1)
rdt2 = RecordDictionaryTool.load_from_granule(msg2)
# msg1 should not have salinity
# assertions(rdt1['salinity'] == None)
conductivity = rdt1['conductivity']
pressure = rdt1['pressure']
temperature = rdt1['temp']
msg1_sal_value = SP_from_cndr(r=conductivity / cte.C3515,
t=temperature,
p=pressure)
msg2_sal_value = rdt2['salinity']
b = msg1_sal_value == msg2_sal_value
if isinstance(b, bool):
assertions(b)
else:
assertions(b.all())
return
def check_salinity_algorithm_execution(self, publish_granule,
granule_from_transform):
#------------------------------------------------------------------
# Calculate the correct density from the input granule data
#------------------------------------------------------------------
input_rdt_to_transform = RecordDictionaryTool.load_from_granule(
publish_granule)
output_rdt_transform = RecordDictionaryTool.load_from_granule(
granule_from_transform)
conductivity = input_rdt_to_transform['conductivity']
pressure = input_rdt_to_transform['pressure']
temperature = input_rdt_to_transform['temp']
sal_value = SP_from_cndr(r=conductivity / cte.C3515,
t=temperature,
p=pressure)
out_salinity = output_rdt_transform['salinity']
#-----------------------------------------------------------------------------
# Check that the output data from the transform has the correct density values
#-----------------------------------------------------------------------------
self.assertTrue(numpy.array_equal(sal_value, out_salinity))
def check_density_algorithm_execution(self, publish_granule,
granule_from_transform):
#------------------------------------------------------------------
# Calculate the correct density from the input granule data
#------------------------------------------------------------------
input_rdt_to_transform = RecordDictionaryTool.load_from_granule(
publish_granule)
output_rdt_transform = RecordDictionaryTool.load_from_granule(
granule_from_transform)
conductivity = input_rdt_to_transform['conductivity']
pressure = input_rdt_to_transform['pressure']
temperature = input_rdt_to_transform['temp']
longitude = input_rdt_to_transform['lon']
latitude = input_rdt_to_transform['lat']
sp = SP_from_cndr(r=conductivity / cte.C3515,
t=temperature,
p=pressure)
sa = SA_from_SP(sp, pressure, longitude, latitude)
dens_value = rho(sa, temperature, pressure)
out_density = output_rdt_transform['density']
log.debug("density output from the transform: %s", out_density)
log.debug("values of density expected from the transform: %s",
dens_value)
numpy.testing.assert_array_almost_equal(out_density,
dens_value,
decimal=3)
def execute(input=None, context=None, config=None, params=None, state=None):
rdt = RecordDictionaryTool.load_from_granule(input)
out_rdt = RecordDictionaryTool(stream_definition_id=params)
conductivity = rdt['conductivity']
pressure = rdt['pressure']
temperature = rdt['temp']
longitude = rdt['lon'] if rdt['lon'] is not None else 0
latitude = rdt['lat'] if rdt['lat'] is not None else 0
sp = SP_from_cndr(r=conductivity/cte.C3515, t=temperature, p=pressure)
log.debug("Density algorithm calculated the sp (practical salinity) values: %s", sp)
sa = SA_from_SP(sp, pressure, longitude, latitude)
log.debug("Density algorithm calculated the sa (actual salinity) values: %s", sa)
dens_value = rho(sa, temperature, pressure)
for key, value in rdt.iteritems():
if key in out_rdt:
if key=='conductivity' or key=='temp' or key=='pressure':
continue
out_rdt[key] = value[:]
out_rdt['density'] = dens_value
log.debug("Density algorithm returning density values: %s", out_rdt['density'])
return out_rdt.to_granule()
def check_salinity_algorithm_execution(self, publish_granule, granule_from_transform):
#------------------------------------------------------------------
# Calculate the correct density from the input granule data
#------------------------------------------------------------------
input_rdt_to_transform = RecordDictionaryTool.load_from_granule(publish_granule)
output_rdt_transform = RecordDictionaryTool.load_from_granule(granule_from_transform)
conductivity = input_rdt_to_transform['conductivity']
pressure = input_rdt_to_transform['pressure']
temperature = input_rdt_to_transform['temp']
sal_value = SP_from_cndr(r=conductivity/cte.C3515, t=temperature, p=pressure)
out_salinity = output_rdt_transform['salinity']
#-----------------------------------------------------------------------------
# Check that the output data from the transform has the correct density values
#-----------------------------------------------------------------------------
self.assertTrue(sal_value.all() == out_salinity.all())
def execute(self, granule):
"""Processes incoming data!!!!
"""
# Use the deconstructor to pull data from a granule
psd = PointSupplementStreamParser(
stream_definition=self.incoming_stream_def, stream_granule=granule)
conductivity = psd.get_values('conductivity')
pressure = psd.get_values('pressure')
temperature = psd.get_values('temperature')
longitude = psd.get_values('longitude')
latitude = psd.get_values('latitude')
height = psd.get_values('height')
time = psd.get_values('time')
log.warn('Got conductivity: %s' % str(conductivity))
log.warn('Got pressure: %s' % str(pressure))
log.warn('Got temperature: %s' % str(temperature))
sp = SP_from_cndr(r=conductivity / cte.C3515,
t=temperature,
p=pressure)
sa = SA_from_SP(sp, pressure, longitude, latitude)
density = rho(sa, temperature, pressure)
log.warn('Got density: %s' % str(density))
# Use the constructor to put data into a granule
psc = PointSupplementConstructor(
point_definition=self.outgoing_stream_def,
stream_id=self.streams['output'])
### Assumes the config argument for output streams is known and there is only one 'output'.
### the stream id is part of the metadata which much go in each stream granule - this is awkward to do at the
### application level like this!
for i in xrange(len(density)):
point_id = psc.add_point(time=time[i],
location=(longitude[i], latitude[i],
height[i]))
psc.add_scalar_point_coverage(point_id=point_id,
coverage_id='density',
value=density[i])
return psc.close_stream_granule()
def execute(self, granule):
"""Processes incoming data!!!!
"""
# Use the deconstructor to pull data from a granule
psd = PointSupplementStreamParser(stream_definition=self.incoming_stream_def, stream_granule=granule)
conductivity = psd.get_values('conductivity')
pressure = psd.get_values('pressure')
temperature = psd.get_values('temperature')
longitude = psd.get_values('longitude')
latitude = psd.get_values('latitude')
height = psd.get_values('height')
time = psd.get_values('time')
log.warn('Got conductivity: %s' % str(conductivity))
log.warn('Got pressure: %s' % str(pressure))
log.warn('Got temperature: %s' % str(temperature))
salinity = SP_from_cndr(r=conductivity/cte.C3515, t=temperature, p=pressure)
log.warn('Got salinity: %s' % str(salinity))
# Use the constructor to put data into a granule
psc = PointSupplementConstructor(point_definition=self.outgoing_stream_def, stream_id=self.streams['output'])
for i in xrange(len(salinity)):
point_id = psc.add_point(time=time[i],location=(longitude[i],latitude[i],height[i]))
psc.add_scalar_point_coverage(point_id=point_id, coverage_id='salinity', value=salinity[i])
return psc.close_stream_granule()
def execute(input=None, context=None, config=None, params=None, state=None):
"""
Dependencies
------------
PRACSAL, PRESWAT_L1, longitude, latitude, TEMPWAT_L1
Algorithms used
------------
1. PRACSAL = gsw_SP_from_C((CONDWAT_L1 * 10),TEMPWAT_L1,PRESWAT_L1)
2. absolute_salinity = gsw_SA_from_SP(PRACSAL,PRESWAT_L1,longitude,latitude)
3. conservative_temperature = gsw_CT_from_t(absolute_salinity,TEMPWAT_L1,PRESWAT_L1)
4. DENSITY = gsw_rho(absolute_salinity,conservative_temperature,PRESWAT_L1)
Reference
------------
The calculations below are based on the following spreadsheet document:
https://docs.google.com/spreadsheet/ccc?key=0Au7PUzWoCKU4dDRMeVI0RU9yY180Z0Y5U0hyMUZERmc#gid=0
"""
lat = params['lat']
lon = params['lon']
stream_def_id = params['stream_def']
rdt = RecordDictionaryTool.load_from_granule(input)
out_rdt = RecordDictionaryTool(stream_definition_id=stream_def_id)
out_rdt['time'] = rdt['time']
conductivity = rdt['conductivity']
pressure = rdt['pressure']
temperature = rdt['temp']
log.debug('L2 transform using L1 values: temp %s, pressure %s, conductivity %s',
temperature, pressure, conductivity)
latitude = np.ones(conductivity.shape) * lat
longitude = np.ones(conductivity.shape) * lon
log.debug("Using latitude: %s, longitude: %s", latitude, longitude)
# Doing: PRACSAL = gsw_SP_from_C((CONDWAT_L1 * 10),TEMPWAT_L1,PRESWAT_L1)
pracsal = gsw.sp_from_c(conductivity * 10, temperature, pressure)
old_pracsal = SP_from_cndr(conductivity * 10, t=temperature, p=pressure)
log.debug("CTDBP Density algorithm calculated the pracsal (practical salinity) values: %s (old: %s)", pracsal, old_pracsal)
# Doing: absolute_salinity = gsw_SA_from_SP(PRACSAL,PRESWAT_L1,longitude,latitude)
absolute_salinity = gsw.sa_from_sp(pracsal, pressure, longitude, latitude)
old_absolute_salinity = SA_from_SP(old_pracsal, pressure, longitude, latitude)
log.debug('absolute_salinity = SA_from_SP(pracsal=%s, pressure=%s, longitude=%s, latitude=%s)=%s (old value: %s)',
pracsal, pressure, longitude, latitude, absolute_salinity, old_absolute_salinity)
log.debug("CTDBP Density algorithm calculated the absolute_salinity (actual salinity) values: %s", absolute_salinity)
conservative_temperature = gsw.ct_from_t(absolute_salinity, temperature, pressure)
old_conservative_temperature = conservative_t(old_absolute_salinity, temperature, pressure)
log.debug("CTDBP Density algorithm calculated the conservative temperature values: %s (old value: %s)",
conservative_temperature, old_conservative_temperature)
# Doing: DENSITY = gsw_rho(absolute_salinity,conservative_temperature,PRESWAT_L1)
dens_value = gsw.rho(absolute_salinity, conservative_temperature, pressure)
old_dens_value = rho(old_absolute_salinity, old_conservative_temperature, pressure)
log.debug("Calculated density values: %s (old: %s)", dens_value, old_dens_value)
for key, value in rdt.iteritems():
if key in out_rdt:
if key=='conductivity' or key=='temp' or key=='pressure':
continue
out_rdt[key] = value[:]
out_rdt['density'] = dens_value
return out_rdt.to_granule()