warnings

Author: danielrichman

setup.py

@@ -51,7 +51,7 @@ def get_version():
     description='High Altitude Balloon Landing Prediction Software',
     long_description=long_description,
     test_suite='nose.collector',
-    tests_require=['nose', 'mock'],
+    tests_require=['nose', 'mock', 'Flask-Testing'],
     install_requires=[
         "magicmemoryview",
         "ruaumoko",

tawhiri/interpolate.pyx

@@ -37,6 +37,7 @@ memory access.
 
 
 from magicmemoryview import MagicMemoryView
+from .warnings cimport WarningCounts
 
 
 # These need to match Dataset.axes.variable
@@ -64,7 +65,7 @@ class RangeError(ValueError):
         super(RangeError, self).__init__(s)
 
 
-def make_interpolator(dataset):
+def make_interpolator(dataset, WarningCounts warnings):
     """
     Produce a function that can get wind data from `dataset`
 
@@ -75,15 +76,18 @@ def make_interpolator(dataset):
 
     cdef float[:, :, :, :, :] data
 
+    if warnings is None:
+        raise TypeError("Warnings must not be None")
+
     data = MagicMemoryView(dataset.array, (65, 47, 3, 361, 720), b"f")
 
     def f(hour, lat, lng, alt):
-        return get_wind(data, hour, lat, lng, alt)
+        return get_wind(data, warnings, hour, lat, lng, alt)
 
     return f
 
 
-cdef object get_wind(dataset ds,
+cdef object get_wind(dataset ds, WarningCounts warnings,
                      double hour, double lat, double lng, double alt):
     """
     Return [u, v] wind components for the given position.
@@ -111,12 +115,15 @@ cdef object get_wind(dataset ds,
     else:
         lerp = 0.5
 
+    if lerp < 0: warnings.altitude_too_high += 1
+    if alt < 0:  warnings.altitude_too_low  += 1
+
     cdef Lerp1 alt_lerp = Lerp1(altidx, lerp)
 
     u = interp4(ds, lerps, alt_lerp, VAR_U)
     v = interp4(ds, lerps, alt_lerp, VAR_V)
 
-    return u, v
+    return u, v, 
 
 cdef long pick(double left, double step, long n, double value,
                object variable_name, Lerp1[2] out) except -1:
@@ -171,6 +178,7 @@ cdef double interp3(dataset ds, Lerp3[8] lerps, long variable, long level):
 
     return r
 
+# Searches for the largest index lower than target, excluding the topmost level.
 cdef long search(dataset ds, Lerp3[8] lerps, double target):
     cdef long lower, upper, mid
     cdef double test

tawhiri/models.py

@@ -73,12 +73,12 @@ def drag_descent(t, lat, lng, alt):
 ## Sideways Models ############################################################
 
 
-def make_wind_velocity(dataset):
+def make_wind_velocity(dataset, warningcounts):
     """Return a wind-velocity model, which gives lateral movement at
        the wind velocity for the current time, latitude, longitude and
        altitude. The `dataset` argument is the wind dataset in use.
     """
-    get_wind = interpolate.make_interpolator(dataset)
+    get_wind = interpolate.make_interpolator(dataset, warningcounts)
     dataset_epoch = calendar.timegm(dataset.ds_time.timetuple())
     def wind_velocity(t, lat, lng, alt):
         t -= dataset_epoch
@@ -159,7 +159,7 @@ def terminator(t, lat, lng, alt):
 
 
 def standard_profile(ascent_rate, burst_altitude, descent_rate,
-                     wind_dataset, elevation_dataset):
+                     wind_dataset, elevation_dataset, warningcounts):
     """Make a model chain for the standard high altitude balloon situation of
        ascent at a constant rate followed by burst and subsequent descent
        at terminal velocity under parachute with a predetermined sea level
@@ -172,26 +172,26 @@ def standard_profile(ascent_rate, burst_altitude, descent_rate,
     """
 
     model_up = make_linear_model([make_constant_ascent(ascent_rate),
-                                  make_wind_velocity(wind_dataset)])
+                                  make_wind_velocity(wind_dataset, warningcounts)])
     term_up = make_burst_termination(burst_altitude)
 
     model_down = make_linear_model([make_drag_descent(descent_rate),
-                                    make_wind_velocity(wind_dataset)])
+                                    make_wind_velocity(wind_dataset, warningcounts)])
     term_down = make_elevation_data_termination(elevation_dataset)
 
     return ((model_up, term_up), (model_down, term_down))
 
 
-def float_profile(ascent_rate, float_altitude, stop_time, dataset):
+def float_profile(ascent_rate, float_altitude, stop_time, dataset, warningcounts):
     """Make a model chain for the typical floating balloon situation of ascent
        at constant altitude to a float altitude which persists for some
        amount of time before stopping. Descent is in general not modelled.
     """
 
     model_up = make_linear_model([make_constant_ascent(ascent_rate),
-                                  make_wind_velocity(dataset)])
+                                  make_wind_velocity(dataset, warningcounts)])
     term_up = make_burst_termination(float_altitude)
-    model_float = make_wind_velocity(dataset)
+    model_float = make_wind_velocity(dataset, warningcounts)
     term_float = make_time_termination(stop_time)
 
     return ((model_up, term_up), (model_float, term_float))

tawhiri/warnings.pxd

@@ -0,0 +1,24 @@
+# Copyright 2016 Daniel Richman
+#
+# This file is part of Tawhiri.
+#
+# Tawhiri is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Tawhiri is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Tawhiri.  If not, see <http://www.gnu.org/licenses/>.
+
+# Cython compiler directives:
+#
+# cython: language_level=3
+
+cdef class WarningCounts:
+    cdef public int altitude_too_low
+    cdef public int altitude_too_high

tawhiri/warnings.pyx

@@ -0,0 +1,46 @@
+# Copyright 2016 Daniel Richman
+#
+# This file is part of Tawhiri.
+#
+# Tawhiri is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Tawhiri is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Tawhiri.  If not, see <http://www.gnu.org/licenses/>.
+
+# Cython compiler directives:
+#
+# cython: language_level=3
+
+"""
+A WarningCounts object is a set of flags that record which warnings have
+fired, and how many times they have fired.
+"""
+
+cdef class WarningCounts:
+    def __init__(self):
+        self.altitude_too_low = 0
+        self.altitude_too_high = 0
+
+    @property
+    def any(self):
+        return bool(self.altitude_too_low or self.altitude_too_high)
+
+    def to_dict(self):
+        res = \
+            { "altitude_too_low": self.altitude_too_low 
+            , "altitude_too_high": self.altitude_too_high 
+            }
+
+        for key in list(res.keys()):
+            if res[key] == 0:
+                del res[key]
+
+        return res

testing/bench_prediction.py

@@ -8,9 +8,11 @@
 
 from tawhiri import solver, models
 from tawhiri.dataset import Dataset as WindDataset
+from tawhiri.warnings import WarningCounts
 from ruaumoko import Dataset as ElevationDataset
 
 elevation = ElevationDataset()
+warningcounts = WarningCounts()
 
 lat0 = 52.0
 lng0 = 0.0
@@ -23,7 +25,7 @@
     wind = WindDataset.open_latest(persistent=True)
     t0 = wind.ds_time + timedelta(hours=12)
     t0 = calendar.timegm(t0.timetuple())
-    stages = models.standard_profile(5.0, 30000, 5.0, wind, elevation)
+    stages = models.standard_profile(5.0, 30000, 5.0, wind, elevation, warningcounts)
     result = solver.solve(t0, lat0, lng0, alt0, stages)
 end_time = time.time()
 

testing/test_prediction.py

@@ -8,17 +8,19 @@
 
 from tawhiri import solver, models, kml
 from tawhiri.dataset import Dataset as WindDataset
+from tawhiri.warnings import WarningCounts
 from ruaumoko import Dataset as ElevationDataset
 
 lat0 = 52.5563
 lng0 = 360 - 3.1970
-alt0 = 0.0
-t0 = calendar.timegm(datetime(2014, 2, 19, 15).timetuple())
+alt0 = 100.0
+t0 = calendar.timegm(datetime(2016, 11, 28, 15).timetuple())
 
 wind = WindDataset.open_latest()
 elevation = ElevationDataset()
+warningcounts = WarningCounts()
 
-stages = models.standard_profile(5.0, 30000, 5.0, wind, elevation)
+stages = models.standard_profile(5.0, 30000, 5.0, wind, elevation, warningcounts)
 rise, fall = solver.solve(t0, lat0, lng0, alt0, stages)
 
 assert rise[-1] == fall[0]
@@ -34,4 +36,6 @@
     {'name': 'burst', 'description': 'TODO', 'point': fall[0]}
 ]
 
+print("Warnings:", str(warningcounts.to_dict()))
+
 kml.kml([rise, fall], markers, 'test_prediction.kml')

tests/test_models.py

@@ -20,7 +20,7 @@
 from nose.tools import assert_true, assert_false
 from mock import patch, Mock
 
-from tawhiri import models
+from tawhiri import models, warnings
 
 
 class TestModels:
@@ -71,7 +71,8 @@ def test_wind_velocity(self, timegm, make_interpolator):
         get_wind.return_value = 3.0, -5.0
         make_interpolator.return_value = get_wind
 
-        f = models.make_wind_velocity(ds)
+        w = warnings.WarningCounts()
+        f = models.make_wind_velocity(ds, w)
         dlat, dlng, zero = f(10.0, 52.0, 0.5, 1000.0)
         assert_equal(zero, 0.0)
         get_wind.assert_called_with(0.0, 52.0, 0.5, 1000.0)
@@ -80,6 +81,8 @@ def test_wind_velocity(self, timegm, make_interpolator):
         assert_almost_equal(dlat, -4.495895997e-5)
         assert_almost_equal(dlng, 4.381527359e-5)
 
+        assert not w.any
+
     def test_burst_termination(self):
         for alt in (0.0, 5000.0, 50000.0):
             f = models.make_burst_termination(alt)
@@ -152,6 +155,7 @@ def test_any_terminator(self):
     @patch('tawhiri.models.make_drag_descent')
     @patch('tawhiri.models.make_elevation_data_termination')
     def test_standard_profile(self, elev, drag, burst, wind, const, linear):
+        warns = warnings.WarningCounts()
         wind_ds = Mock()
         elev_ds = Mock()
         const.return_value = 'const'
@@ -160,32 +164,35 @@ def test_standard_profile(self, elev, drag, burst, wind, const, linear):
         burst.return_value = 'burst'
         drag.return_value = 'drag'
         elev.return_value = 'elev'
-        model = models.standard_profile(5.0, 30000.0, 6.0, wind_ds, elev_ds)
+        model = models.standard_profile(5.0, 30000.0, 6.0, wind_ds, elev_ds, warns)
         const.assert_called_with(5.0)
-        wind.assert_called_with(wind_ds)
+        wind.assert_called_with(wind_ds, warns)
         linear.assert_any_call(['const', 'wind'])
         burst.assert_called_with(30000.0)
         drag.assert_called_with(6.0)
         linear.assert_called_with(['drag', 'wind'])
         elev.assert_called_with(elev_ds)
         assert_equal(model, (('linear', 'burst'), ('linear', 'elev')))
+        assert not warns.any
 
     @patch('tawhiri.models.make_linear_model')
     @patch('tawhiri.models.make_constant_ascent')
     @patch('tawhiri.models.make_wind_velocity')
     @patch('tawhiri.models.make_burst_termination')
     @patch('tawhiri.models.make_time_termination')
     def test_float_profile(self, time, burst, wind, const, linear):
+        warns = warnings.WarningCounts()
         wind_ds = Mock()
         time.return_value = 'time'
         burst.return_value = 'burst'
         wind.return_value = 'wind'
         const.return_value = 'const'
         linear.return_value = 'linear'
-        model = models.float_profile(5.0, 12000.0, 7200.0, wind_ds)
+        model = models.float_profile(5.0, 12000.0, 7200.0, wind_ds, warns)
         const.assert_called_with(5.0)
-        wind.assert_called_with(wind_ds)
+        wind.assert_called_with(wind_ds, warns)
         linear.assert_called_with(['const', 'wind'])
         burst.assert_called_with(12000.0)
         time.assert_called_with(7200.0)
         assert_equal(model, (('linear', 'burst'), ('wind', 'time')))
+        assert not warns.any

tests/testapi.py

@@ -2,7 +2,7 @@
 
 import json
 
-from flask.ext.testing import TestCase
+from flask_testing import TestCase
 from mock import patch, MagicMock
 from urllib.parse import urlencode