def testRangeChecker(self):
array = numpy.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
cranges = check_range.RangeChecker([{3, 4}, 5, [7], [8, None], [None, 1]])
self.assertIn(0, cranges)
self.assertIn(1, cranges)
self.assertNotIn(2, cranges)
self.assertIn(3, cranges)
self.assertIn(4, cranges)
self.assertIn(5, cranges)
self.assertNotIn(6, cranges)
self.assertIn(7, cranges)
self.assertIn(8, cranges)
self.assertIn(9, cranges)
self.assertTrue(numpy.array_equal(
cranges.Select(array), numpy.array([1, 1, 0, 1, 1, 1, 0, 1, 1, 1])))
cranges = check_range.RangeChecker([])
self.assertNotIn(4, cranges)
self.assertTrue(numpy.array_equal(
cranges.Select(array), numpy.array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0])))
with self.assertRaises(TypeError):
check_range.RangeChecker(None)
cranges = check_range.RangeChecker([[None, None]])
self.assertIn(123, cranges)
self.assertIn('a', cranges)
cranges = check_range.RangeChecker([None])
self.assertNotIn(123, cranges)
self.assertNotIn('a', cranges)
def __init__(self, for_log):
self._motors = [
_MOTOR_LABELS_HELPER.ShortName(i)
for i in range(len(_MOTOR_LABELS_HELPER))
]
# The maximum sequence difference can be 3.
normal_ranges = check_range.RangeChecker([[0, 3]])
# Any difference larger than 30 is likely to be caused by logger dropping
# packets and therefore tends to raise false alarms.
# Any difference between 4 and 30 is likely to be a real alarm.
warning_ranges = check_range.RangeChecker([[31, None]])
self._name = 'Motor Stacking Sequence'
# To check neighboring pairs of sequences, we apply windowing to log data,
# and circular buffer to AIO data.
# `window_size` defines the length of the window, or the circular buffer.
# and circular buffer to AIO data.
# `window_size` defines the length of the window, or the circular buffer.
# E.g., for a time-series of [A, B, C, D] and a window with length as 2 and
# step as 1, the windowed log data becomes
# [[A, B], [B, C], [C, D]], and the circular buffer yields [A, B], [B, C],
# and [C, D] at each time step.
window_size = 2
window_step = 1
super(MotorStackingSequence,
self).__init__(for_log,
window_size,
window_step,
normal_ranges,
warning_ranges,
name='MotorStackingSequence(%s)' % self._motors)
def testLogCheckByRange(self):
normal_ranges = check_range.RangeChecker([[5, 8], [15, 18]])
warning_ranges = check_range.RangeChecker([0, [3, 20]])
array = numpy.array([0, 1, 5, 10, 18])
results = log_util.CheckByRange(
array, normal_ranges, warning_ranges, min_gap=1000)
self.assertEqual(
results['warning'],
{'total': 5, 'count': 2, 'range': [0, 10], 'sections': [(0, 4)],
'expecting': '[[5, 8], [15, 18]]'})
self.assertEqual(
results['error'],
{'total': 5, 'count': 1, 'range': [1, 1], 'sections': [(1, 2)],
'expecting': '[0, [3, 20]]'})
def GetChecker(mapping, check_type, default):
value = mapping.get(check_type, default)
if value == 'any':
return check_range.AllInclusiveRange()
elif value is None:
# No checks for this type.
return None
else:
return check_range.RangeChecker(value)
def testAioCheckByRange(self):
normal_ranges = check_range.RangeChecker([[5, 8], [15, 18]])
warning_ranges = check_range.RangeChecker([0, [3, 20]])
self.assertEqual(
aio_util.CheckByRange(
5, normal_ranges, warning_ranges, 'test')[0]['stoplight'],
stoplights.STOPLIGHT_NORMAL)
self.assertEqual(
aio_util.CheckByRange(
0, normal_ranges, warning_ranges, 'test')[0]['stoplight'],
stoplights.STOPLIGHT_WARNING)
self.assertEqual(
aio_util.CheckByRange(
1, normal_ranges, warning_ranges, 'test')[0]['stoplight'],
stoplights.STOPLIGHT_ERROR)
array = numpy.array([5, 15, 18])
self.assertEqual(
aio_util.CheckByRange(
array, normal_ranges, warning_ranges, '')[0]['stoplight'],
stoplights.STOPLIGHT_NORMAL)
array = numpy.array([0, 5, 18])
self.assertEqual(
aio_util.CheckByRange(
array, normal_ranges, warning_ranges, '')[0]['stoplight'],
stoplights.STOPLIGHT_WARNING)
array = numpy.array([1, 5, 10, 18])
self.assertEqual(
aio_util.CheckByRange(
array, normal_ranges, warning_ranges, '')[0]['stoplight'],
stoplights.STOPLIGHT_ERROR)
def testSpecs(self):
normal_ranges = [[1, 3]]
warning_ranges = [[0, 10]]
derived_check = DerivedCheck(
for_log=True, normal_ranges=check_range.RangeChecker(normal_ranges),
warning_ranges=warning_ranges)
derived_init_check = DerivedCheckWithInit(True, history_len=30)
derived_init_check_default = DerivedCheckWithInit(True)
self.assertEqual(
derived_check.GetDeterministicSpecs(), (
'makani.analysis.checks.tests.DerivedCheck', {
'for_log': True,
'name': None,
'sort_by_sequence': True,
'normal_ranges': normal_ranges,
'warning_ranges': warning_ranges
}
)
)
self.assertEqual(
derived_init_check.GetDeterministicSpecs(), (
'makani.analysis.checks.tests.DerivedCheckWithInit', {
'find_history': True,
'history_len': 30,
}
)
)
self.assertEqual(
derived_init_check_default.GetDeterministicSpecs(), (
'makani.analysis.checks.tests.DerivedCheckWithInit', {
'find_history': True,
'history_len': 12,
}
)
)
with self.assertRaises(ValueError):
BadDerivedCheck(True)
def __init__(self, for_log, motors):
"""Initialize the object.
Args:
for_log: True if this check is performed over a log. False if it is for
realtime AIO messages.
motors: Names of the motors to check.
"""
normal_ranges = check_range.RangeChecker([[None, 15]])
self._motors = motors
assert len(motors) == 2
self._filter_order = 3
cutoff = 0.25
self._kernel = signal.butter(self._filter_order, cutoff)
if not for_log:
self._zi_1 = signal.lfiltic(self._kernel[0], self._kernel[1],
[0.0])
self._zi_2 = signal.lfiltic(self._kernel[0], self._kernel[1],
[0.0])
super(MotorStackPairVoltageDiff,
self).__init__(for_log,
normal_ranges,
name='StackedMotorsVoltageDiff(%s)' % motors)