class WindSchema(base_schema.ObjTypeSchema):
'''
validate data after deserialize, before it is given back to pyGnome's
from_dict to set _state of object
'''
name = SchemaNode(String(), test_equal=False)
description = SchemaNode(String())
filename = FilenameSchema(isdatafile=True, update=False,
test_equal=False) #Thanks to CyTimeseries
updated_at = SchemaNode(LocalDateTime())
latitude = SchemaNode(Float())
longitude = SchemaNode(Float())
source_id = SchemaNode(String())
source_type = SchemaNode(String(),
validator=OneOf(wind_datasources._attr),
default='undefined',
missing='undefined')
units = SchemaNode(String(), default='m/s')
speed_uncertainty_scale = SchemaNode(Float())
timeseries = WindTimeSeriesSchema(
test_equal=False
) #Because comparing datetimevalue2d arrays does not play nice
extrapolation_is_allowed = SchemaNode(Boolean())
data_start = SchemaNode(LocalDateTime(),
read_only=True,
validator=convertible_to_seconds)
data_stop = SchemaNode(LocalDateTime(),
read_only=True,
validator=convertible_to_seconds)
class LongLat(MappingSchema):
"""
A :class:`colander.MappingSchema`-based LongLat schema, as opposed to the
TupleSchema-based class:`gnome.persist.base_schema.LongLat` version.
"""
long = SchemaNode(Float())
lat = SchemaNode(Float())
class CurrentMoversBaseSchema(ProcessSchema):
uncertain_duration = SchemaNode(Float())
uncertain_time_delay = SchemaNode(Float())
data_start = SchemaNode(LocalDateTime(), read_only=True,
validator=convertible_to_seconds)
data_stop = SchemaNode(LocalDateTime(), read_only=True,
validator=convertible_to_seconds)
class GridCurrentMoverSchema(CurrentMoversBaseSchema):
filename = FilenameSchema(
missing=drop, save=True, update=False, isdatafile=True, test_equal=False
)
topology_file = FilenameSchema(
missing=drop, save=True, update=False, isdatafile=True, test_equal=False
)
current_scale = SchemaNode(
Float(), missing=drop, save=True, update=True
)
uncertain_along = SchemaNode(
Float(), missing=drop, save=True, update=True
)
uncertain_cross = SchemaNode(
Float(), missing=drop, save=True, update=True
)
extrapolate = SchemaNode(
Bool(), missing=drop, save=True, update=True
)
time_offset = SchemaNode(
Float(), missing=drop, save=True, update=True
)
is_data_on_cells = SchemaNode(
Bool(), missing=drop, read_only=True
)
data_start = SchemaNode(LocalDateTime(), read_only=True,
validator=convertible_to_seconds)
data_stop = SchemaNode(LocalDateTime(), read_only=True,
validator=convertible_to_seconds)
class SetpointInterpolationSchema(MappingSchema):
name = SchemaNode(typ=String(),
title='Name')
order = SchemaNode(typ=Int(),
title='Type (order)',
default=deferred_order_default,
widget=SelectWidget(values=[(0, 'Constant'),
(1, 'Linear'),
(2, 'Quadratic'),
(3, 'Cubic'),
(4, 'Spline')]))
start_value = SchemaNode(typ=Float(),
title='Start Value',
default=deferred_start_value_default)
end_time = SchemaNode(typ=Int(),
title='End Time',
default=deferred_end_time_default)
end_value = SchemaNode(typ=Float(),
title='End Value',
default=deferred_end_value_default,
missing=None)
description = SchemaNode(typ=String(),
title='Description',
default=deferred_description_default,
missing=None)
class SpillSchema(ObjType):
'Spill class schema'
on = SchemaNode(Bool(), default=True, missing=True,
description='on/off status of spill')
amount = SchemaNode(Float(), missing=drop)
units = SchemaNode(String(), missing=drop)
amount_uncertainty_scale = SchemaNode(Float(), missing=drop)
class NormalDistributionSchema(ObjType):
mean = SchemaNode(Float(), name='mean',
description='mean for normal distribution')
sigma = SchemaNode(Float(), name='sigma',
description='standard deviation for normal distribution'
)
name = 'normal'
class IceMoverSchema(CurrentMoversBaseSchema):
filename = SchemaNode(String(), missing=drop)
topology_file = SchemaNode(String(), missing=drop)
current_scale = SchemaNode(Float(), missing=drop)
uncertain_along = SchemaNode(Float(), missing=drop)
uncertain_cross = SchemaNode(Float(), missing=drop)
extrapolate = SchemaNode(Bool(), missing=drop)
class SpillSchema(ObjTypeSchema):
'Spill class schema'
on = SchemaNode(Bool(),
default=True,
missing=True,
description='on/off status of spill',
save=True,
update=True)
release = GeneralGnomeObjectSchema(acceptable_schemas=[
BaseReleaseSchema, PointLineReleaseSchema, ContinuousReleaseSchema,
SpatialReleaseSchema
],
save=True,
update=True,
save_reference=True)
amount = SchemaNode(Float(), missing=drop, save=True, update=True)
units = SchemaNode(String(), missing=drop, save=True, update=True)
amount_uncertainty_scale = SchemaNode(Float(),
missing=drop,
save=True,
update=True)
# frac_coverage = SchemaNode(
# Float(), missing=drop, save=True, update=True
# )
element_type = ElementTypeSchema(save=True,
update=True,
save_reference=True)
water = WaterSchema(missing=drop,
save=True,
update=True,
save_reference=True)
class WeibullDistributionSchema(ObjTypeSchema):
name = 'weibull'
alpha = SchemaNode(Float(),
name='alpha',
description='shape parameter for weibull distribution',
save=True,
update=True)
lambda_ = SchemaNode(
Float(),
name='lambda_',
default=1.0,
description='scale parameter for weibull distribution',
save=True,
update=True)
min_ = SchemaNode(Float(),
name='min_',
description='lower bound? for weibull distribution',
missing=drop,
save=True,
update=True)
max_ = SchemaNode(Float(),
name='max_',
description='upper bound? for weibull distribution',
missing=drop,
save=True,
update=True)
class PyWindMoverSchema(base_schema.ObjType):
filename = SchemaNode(typ=Sequence(accept_scalar=True),
children=[SchemaNode(String())],
missing=drop)
current_scale = SchemaNode(Float(), missing=drop)
extrapolate = SchemaNode(Bool(), missing=drop)
time_offset = SchemaNode(Float(), missing=drop)
wind = GridVectorPropSchema(missing=drop)
class RandomVerticalMoverSchema(ObjType, ProcessSchema):
vertical_diffusion_coef_above_ml = SchemaNode(Float(), missing=drop)
vertical_diffusion_coef_below_ml = SchemaNode(Float(), missing=drop)
mixed_layer_depth = SchemaNode(Float(), missing=drop)
horizontal_diffusion_coef_above_ml = SchemaNode(Float(), missing=drop)
horizontal_diffusion_coef_below_ml = SchemaNode(Float(), missing=drop)
class WaterSchema(base_schema.ObjType):
'Colander Schema for Conditions object'
units = UnitsSchema()
temperature = SchemaNode(Float())
salinity = SchemaNode(Float())
sediment = SchemaNode(Float(), missing=drop)
wave_height = SchemaNode(Float(), missing=drop)
fetch = SchemaNode(Float(), missing=drop)
class WaterSchema(base_schema.ObjTypeSchema):
'Colander Schema for Conditions object'
units = UnitsSchema(save=True, update=True)
temperature = SchemaNode(Float(), save=True, update=True)
salinity = SchemaNode(Float(), save=True, update=True)
sediment = SchemaNode(Float(), missing=drop, save=True, update=True)
wave_height = SchemaNode(Float(), missing=drop, save=True, update=True)
fetch = SchemaNode(Float(), missing=drop, save=True, update=True)
class WorldPointNumpy(NumpyFixedLenSchema):
'''
Define same schema as WorldPoint; however, the base class
NumpyFixedLenSchema serializes/deserializes it from/to a numpy array
'''
long = SchemaNode(Float())
lat = SchemaNode(Float())
z = SchemaNode(Float())
class VectorFieldSchema(ObjType, ProcessSchema):
uncertain_duration = SchemaNode(Float(), missing=drop)
uncertain_time_delay = SchemaNode(Float(), missing=drop)
filename = SchemaNode(String(), missing=drop)
topology_file = SchemaNode(String(), missing=drop)
current_scale = SchemaNode(Float(), missing=drop)
uncertain_along = SchemaNode(Float(), missing=drop)
uncertain_cross = SchemaNode(Float(), missing=drop)
class SkimmerSchema(WeathererSchema):
amount = SchemaNode(Float(), save=True, update=True)
units = SchemaNode(String(), save=True, update=True)
efficiency = SchemaNode(Float(), save=True, update=True)
water = WaterSchema(missing=drop,
save=True,
update=True,
save_reference=True)
class SimpleMoverVelocitySchema(NumpyFixedLenSchema):
'''
Currently this is only used by SimpleMover so it is here. If it becomes
more general purpose then move it to gnome.persist.base_schema
'''
vel_x = SchemaNode(Float())
vel_y = SchemaNode(Float())
vel_z = SchemaNode(Float())
class CurrentCycleMoverSchema(ObjType, ProcessSchema):
filename = SchemaNode(String(), missing=drop)
topology_file = SchemaNode(String(), missing=drop)
current_scale = SchemaNode(Float(), default=1, missing=drop)
uncertain_duration = SchemaNode(Float(), default=24, missing=drop)
uncertain_time_delay = SchemaNode(Float(), default=0, missing=drop)
uncertain_along = SchemaNode(Float(), default=.5, missing=drop)
uncertain_cross = SchemaNode(Float(), default=.25, missing=drop)
class ValidPositionSchema(FieldSchema, CopyingSchema):
"""A schema which validates the fields present in a position."""
lat = SchemaNode(Float(),
missing=0.0,
validator=Range(constants.MIN_LAT, constants.MAX_LAT))
lon = SchemaNode(Float(),
missing=0.0,
validator=Range(constants.MIN_LON, constants.MAX_LON))
class TimeSeriesPropSchema(PropertySchema):
time = TimeSchema(missing=drop)
data = SequenceSchema(SchemaNode(Float()), missing=drop)
timeseries = SequenceSchema(TupleSchema(children=[
SchemaNode(DateTime(default_tzinfo=None), missing=drop),
SchemaNode(Float(), missing=0)
],
missing=drop),
missing=drop)
class GridCurrentMoverSchema(CurrentMoversBaseSchema):
filename = SchemaNode(String(), missing=drop)
topology_file = SchemaNode(String(), missing=drop)
current_scale = SchemaNode(Float(), missing=drop)
uncertain_along = SchemaNode(Float(), missing=drop)
uncertain_cross = SchemaNode(Float(), missing=drop)
extrapolate = SchemaNode(Bool(), missing=drop)
time_offset = SchemaNode(Float(), missing=drop)
is_data_on_cells = SchemaNode(Bool(), missing=drop)
class UniformDistributionSchema(ObjType):
low = SchemaNode(Float(),
name='low',
default=0.0,
description='lower bound for uniform distribution')
high = SchemaNode(Float(),
name='high',
default=0.1,
description='lower bound for uniform distribution')
name = 'uniform'
class UniformDistributionSchema(ObjTypeSchema):
low = SchemaNode(
Float(), default=0.0,
description='lower bound for uniform distribution',
save=True, update=True
)
high = SchemaNode(
Float(), name='high', default=0.1,
description='lower bound for uniform distribution',
save=True, update=True
)
class VelocityTSSchema(PropertySchema):
timeseries = SequenceSchema(
TupleSchema(children=[
SchemaNode(DateTime(default_tzinfo=None), missing=drop),
TupleSchema(children=[
SchemaNode(Float(), missing=0),
SchemaNode(Float(), missing=0)
])
],
missing=drop))
varnames = SequenceSchema(SchemaNode(String(), missing=drop))
class NormalDistributionSchema(ObjTypeSchema):
mean = SchemaNode(
Float(),
description='mean for normal distribution',
save=True, update=True
)
sigma = SchemaNode(
Float(),
description='standard deviation for normal distribution',
save=True, update=True
)
class StageConfigurationSchema(MappingSchema):
parameter = SchemaNode(
typ=Int(),
title='Parameter',
widget=SelectWidget(values=[(_id, name)
for _id, name in DBSession.query(
Parameter._id, Parameter.name)]))
time = SchemaNode(typ=Time(), title='Time', default=time(0, 0))
setpoint = SchemaNode(typ=Float(), title='Setpoint')
upper_limit = SchemaNode(typ=Float(), title='Upper limit')
lower_limit = SchemaNode(typ=Float(), title='Lower limit')
class RandomMoverSchema(ProcessSchema):
diffusion_coef = SchemaNode(Float(), save=True, update=True, missing=drop)
uncertain_factor = SchemaNode(Float(),
save=True,
update=True,
missing=drop)
data_start = SchemaNode(LocalDateTime(),
validator=convertible_to_seconds,
read_only=True)
data_stop = SchemaNode(LocalDateTime(),
validator=convertible_to_seconds,
read_only=True)
class TSVectorPropSchema(VectorPropSchema):
timeseries = SequenceSchema(TupleSchema(children=[
SchemaNode(DateTime(default_tzinfo=None), missing=drop),
TupleSchema(children=[
SchemaNode(Float(), missing=0),
SchemaNode(Float(), missing=0)
])
],
missing=drop),
missing=drop)
# variables = SequenceSchema(TupleSchema(SchemaNode(Float())))
varnames = SequenceSchema(SchemaNode(String(), missing=drop), missing=drop)
class BaseReportSchema(MappingSchema):
lat = SchemaNode(Float(), missing=None)
lon = SchemaNode(Float(), missing=None)
time = SchemaNode(String(), missing='')
accuracy = SchemaNode(Integer(), missing=0)
altitude = SchemaNode(Integer(), missing=0)
altitude_accuracy = SchemaNode(Integer(), missing=0)
radio = SchemaNode(String(), validator=OneOf(RADIO_STRINGS), missing=None)
heading = SchemaNode(Float(), missing=-1.0)
speed = SchemaNode(Float(), missing=-1.0)