Wedge load noise

src/progpy/loading/__init__.py

@@ -2,5 +2,5 @@
 # National Aeronautics and Space Administration. All Rights Reserved.
 
 from progpy.loading.moving_average import MovingAverage
-from progpy.loading.gaussian_wrapper import GaussianNoiseLoadWrapper
+from progpy.loading.gaussian_wrapper import GaussianNoiseLoadWrapper, GaussianNoiseWrapper
 from progpy.loading.piecewise import Piecewise

src/progpy/loading/gaussian_wrapper.py

@@ -5,7 +5,7 @@
 import numpy as np
 
 
-class GaussianNoiseLoadWrapper():
+class GaussianNoiseWrapper():
  """
  .. versionadded:: 1.5.0
 
@@ -22,6 +22,10 @@ class GaussianNoiseLoadWrapper():
  -------------------
  seed: {int, SeedSequence, BitGenerator, Generator}, optional
  The seed for random number generator. This can be set to make results repeatable.
+ std_slope: float, optional
+ The increase in standard deviation per second of time. Std is the standard deviation at t<=t0.
+ t0: float, optional
+ Initial time (at which standard deviation is std). After t0, the standard deviation increases at a rate of std_slope.
 
  Example
  -------
@@ -30,23 +34,32 @@ class GaussianNoiseLoadWrapper():
  >>> future_load = GaussianNoiseLoadWrapper(future_load, STANDARD_DEV)
  >>> m.simulate_to_threshold(future_load)
  """
- def __init__(self, fcn: Callable, std: float, seed: int = None):
+ def __init__(self, fcn: Callable, std: float, seed: int = None, std_slope: float = 0, t0: float = 0):
  self.fcn = fcn
  self.std = std
+ self.std_slope = std_slope
+ self.t0 = t0
  self.gen = np.random.default_rng(seed)
 
  def __call__(self, t: float, x=None):
  """
  Return the load with noise added
 
- Args:
- t (float): Time (s)
- x (StateContainer, optional): Current state. Defaults to None.
+ Arguments
+ ------------
+ t: float
+ Time (s)
+ x: StateContainer, optional
+ Current state. Defaults to None.
 
  Returns:
  InputContainer: The load with noise added
  """
  input = self.fcn(t, x)
+ std = self.std + self.std_slope*(t-self.t0) if t > self.t0 else self.std
  for key, value in input.items():
- input[key] = self.gen.normal(value, self.std)
+ input[key] = self.gen.normal(value, std)
  return input
+
+# Old name kept for backwards compatability
+GaussianNoiseLoadWrapper = GaussianNoiseWrapper

tests/test_loading.py

@@ -1,8 +1,9 @@
 # Copyright © 2021 United States Government as represented by the Administrator of the National Aeronautics and Space Administration. All Rights Reserved.
 
+import numpy as np
 import unittest
 
-from progpy.loading import Piecewise, GaussianNoiseLoadWrapper
+from progpy.loading import Piecewise, GaussianNoiseWrapper
 
 
 class Testloading(unittest.TestCase):
@@ -30,21 +31,57 @@ def loading(t, x=None):
  return {'a': 10}
 
  # Default: two values should be different (because of randomness)
- loading_with_noise = GaussianNoiseLoadWrapper(loading, 10)
+ loading_with_noise = GaussianNoiseWrapper(loading, 10)
  load1 = loading_with_noise(10)
 
- loading_with_noise = GaussianNoiseLoadWrapper(loading, 10)
+ loading_with_noise = GaussianNoiseWrapper(loading, 10)
  load2 = loading_with_noise(10)
 
  self.assertNotEqual(load1['a'], load2['a'])
 
  # Setting seed, two values should be the same now
- loading_with_noise = GaussianNoiseLoadWrapper(loading, 10, seed=550)
+ loading_with_noise = GaussianNoiseWrapper(loading, 10, seed=550)
  load1 = loading_with_noise(10)
 
- loading_with_noise = GaussianNoiseLoadWrapper(loading, 10, seed=550)
+ loading_with_noise = GaussianNoiseWrapper(loading, 10, seed=550)
  load2 = loading_with_noise(10)
  self.assertEqual(load1['a'], load2['a'])
+
+ def test_wedge_gaussian_load(self):
+ def loading(t, x=None):
+ return {'a': 10}
+
+ loading_with_noise = GaussianNoiseWrapper(loading, 0, std_slope=10)
+
+ # Standard deviation at t=0 should be 0.
+ self.assertEqual(
+ loading_with_noise(0),
+ loading_with_noise(0))
+
+ # At any greater time, the standard deviation is not 0
+ self.assertNotEqual(
+ loading_with_noise(10),
+ loading_with_noise(10))
+
+ # Check that standard deviation increases with time. 
+ values = [loading_with_noise(10)['a'] for _ in range(20)]
+ std = np.std(values)
+
+ values = [loading_with_noise(1e4)['a'] for _ in range(20)]
+ std2 = np.std(values)
+ self.assertGreater(std2, std)
+
+ # Check t0 functionality
+ loading_with_noise.t0 = 10
+ self.assertEqual( # Case t<t0
+ loading_with_noise(5),
+ loading_with_noise(5))
+ self.assertEqual( # Case t==t0
+ loading_with_noise(10),
+ loading_with_noise(10))
+ self.assertNotEqual( # Case t > t0
+ loading_with_noise(11),
+ loading_with_noise(11))
 
 # This allows the module to be executed directly 
 def main():