def test_no_match(self):
"""
Test limit situations where no harmonization should happen
"""
# conversion provided applies to a different domain
h = Harmoniser(target_scale=self.target_scale)
self.a_conversion.update({'domain': []})
h.add_conversion_formula(**self.a_conversion)
converted, unconverted = h.harmonise(self.measures)
# 1/3 of the measures are already in the target_scale
self.assertEqual(self.number_of_measures / 3, len(converted))
self.assertEqual(self.number_of_measures * 2 / 3, len(unconverted))
# no conversion are provided
h = Harmoniser(target_scale=self.target_scale)
converted, unconverted = h.harmonise(self.measures)
self.assertEqual(self.number_of_measures / 3, len(converted))
self.assertEqual(self.number_of_measures * 2 / 3, len(unconverted))
# no conversion matches the target scale
h = Harmoniser(target_scale="wrong scale")
h.add_conversion_formula(**self.a_conversion)
converted, unconverted = h.harmonise(self.measures)
self.assertEqual(0, len(converted))
self.assertEqual(self.number_of_measures, len(unconverted))
def test_no_match(self):
"""
Test limit situations where no harmonization should happen
"""
# model provided does not convert from the native magnitude scale
for measure in self.measures:
measure.scale = "fake scale"
h = Harmoniser(target_scale=self.target_scale)
h.add_conversion_formula_from_model(self.a_model)
converted, unconverted = h.harmonise(self.measures)
self.assertEqual(0, len(converted))
self.assertEqual(self.number_of_measures, len(unconverted))
# no model are provided
h = Harmoniser(target_scale=self.target_scale)
converted, unconverted = h.harmonise(self.measures)
self.assertEqual(0, len(converted))
self.assertEqual(self.number_of_measures, len(unconverted))
# no model matches the target scale
h = Harmoniser(target_scale="wrong scale")
h.add_conversion_formula_from_model(self.a_model)
converted, unconverted = h.harmonise(self.measures)
self.assertEqual(0, len(converted))
self.assertEqual(self.number_of_measures, len(unconverted))
def test_conversion(self):
h = Harmoniser(target_scale=self.target_scale)
h.add_conversion_formula(formula=lambda x: x * 2, module_error=0.2,
domain=C(agency__in=['LDG', 'NEIC']),
target_scale=self.target_scale)
converted, unconverted = h.harmonise(self.measures)
self.assertConversion(converted, 6, unconverted, 24)
def test_conversion_not_trivial_same_native_and_target_scale(self):
h = Harmoniser(target_scale=self.target_scale)
my_measure = self.measures[20]
h.add_conversion_formula(
lambda x: x * 2, 0.1, domain=C(scale="Mw"),
target_scale="Mw")
result = h.harmonise([my_measure], allow_trivial_conversion=False)
self.assertEqual(1, len(result.converted))
self.assertEqual(0, len(result.unconverted))
self.assertAlmostEqual(my_measure.value * 2,
result.converted[my_measure].value)
def test_one_conversion(self):
"""
Test with one conversion. Given a target scale, a list of measures
(in a single magnitude scales), and an empirical magnitude
scaling relationship (between a native scale mb and the
considered target scale), an Harmoniser should convert to the
target scale only the measure in that native scale
"""
mismatches = self.number_of_measures / 3
h = Harmoniser(target_scale=self.target_scale)
h.add_conversion_formula(**self.a_conversion)
converted, unconverted = h.harmonise(self.measures)
self.assertConversion(converted, self.number_of_measures - mismatches,
unconverted, mismatches)
def test_disallow_trivial_conversion(self):
h = Harmoniser(target_scale=self.target_scale)
h.add_conversion_formula_from_model(self.a_model)
h.add_conversion_formula_from_model(self.ya_model)
converted, unconverted = h.harmonise(self.measures,
allow_trivial_conversion=False)
self.assertConversion(converted, 20, unconverted, 10)
def test_more_model(self):
h = Harmoniser(target_scale=self.target_scale)
h.add_conversion_formula_from_model(self.a_model)
h.add_conversion_formula_from_model(self.ya_model)
converted, unconverted = h.harmonise(self.measures)
self.assertConversion(converted, self.number_of_measures,
unconverted, 0)
def test_disallow_trivial_conversion(self):
h = Harmoniser(target_scale=self.target_scale)
h.add_conversion_formula_from_model(self.a_model,
C(scale=self.a_native_scale))
h.add_conversion_formula_from_model(self.ya_model,
C(scale=self.ya_native_scale))
result = h.harmonise(self.measures, allow_trivial_conversion=False)
self.assertConversion(result, 20, 10)
def test_more_conversion(self):
"""
Test with several conversions
"""
h = Harmoniser(target_scale=self.target_scale)
h.add_conversion_formula(**self.a_conversion)
h.add_conversion_formula(**self.ya_conversion)
result = h.harmonise(self.measures)
self.assertConversion(result, self.number_of_measures, 0)
def test_more_model(self):
h = Harmoniser(target_scale=self.target_scale)
h.add_conversion_formula_from_model(self.a_model,
C(scale=self.a_native_scale))
h.add_conversion_formula_from_model(self.ya_model,
C(scale=self.ya_native_scale))
result = h.harmonise(self.measures)
self.assertConversion(result, self.number_of_measures, 0)
def test_conversion(self):
h = Harmoniser(target_scale=self.target_scale)
h.add_conversion_formula(formula=lambda x: x * 2., module_error=0.2,
domain=C(scale=self.a_native_scale),
target_scale="M2")
h.add_conversion_formula(formula=lambda x: x * 3., module_error=0.1,
domain=C(scale=self.ya_native_scale),
target_scale="M3")
h.add_conversion_formula(formula=lambda x: x * 3., module_error=0.2,
domain=C(scale="M3"),
target_scale="M2")
h.add_conversion_formula(formula=lambda x: x * 4., module_error=0.3,
domain=C(scale="M2"),
target_scale=self.target_scale)
h.add_conversion_formula(formula=lambda x: x * 4., module_error=0.4,
domain=C(scale="M2"),
target_scale="M4")
h.add_conversion_formula(formula=lambda x: x * 4., module_error=0.2,
domain=C(scale="M2"),
target_scale="M5")
converted, unconverted = h.harmonise(self.measures)
self.assertEqual(30, len(converted))
self.assertEqual(0, len(unconverted))
for measure in self.measures:
self.assertTrue(measure in converted)
converted_measure = converted[measure]
if measure.scale == self.a_native_scale:
self.assertEqual(2, len(converted_measure['formulas']))
self.assertAlmostEqual(converted_measure['measure'].value,
measure.value * 8)
elif measure.scale == self.target_scale:
self.assertEqual(converted_measure['formulas'], [])
self.assertAlmostEqual(converted_measure['measure'].value,
measure.value)
elif measure.scale == self.ya_native_scale:
self.assertEqual(3,
len(converted_measure['formulas']))
self.assertAlmostEqual(converted_measure['measure'].value,
measure.value * 36)
def test_conversion(self):
h = Harmoniser(target_scale=self.target_scale)
h.add_conversion_formula(formula=lambda x: x * 2., model_error=0.2,
domain=C(scale=self.a_native_scale),
target_scale="M2")
h.add_conversion_formula(formula=lambda x: x * 3., model_error=0.1,
domain=C(scale=self.ya_native_scale),
target_scale="M3")
h.add_conversion_formula(formula=lambda x: x * 3., model_error=0.2,
domain=C(scale="M3"),
target_scale="M2")
h.add_conversion_formula(formula=lambda x: x * 4., model_error=0.3,
domain=C(scale="M2"),
target_scale=self.target_scale)
h.add_conversion_formula(formula=lambda x: x * 4., model_error=0.4,
domain=C(scale="M2"),
target_scale="M4")
h.add_conversion_formula(formula=lambda x: x * 4., model_error=0.2,
domain=C(scale="M2"),
target_scale="M5")
result = h.harmonise(self.measures)
self.assertEqual(30, len(result.converted))
self.assertEqual(0, len(result.unconverted))
for measure in self.measures:
converted_measure = result.converted[measure]
if measure.scale == self.a_native_scale:
self.assertAlmostEqual(converted_measure.value,
measure.value * 8)
elif measure.scale == self.target_scale:
self.assertAlmostEqual(converted_measure.value, measure.value)
elif measure.scale == self.ya_native_scale:
self.assertEqual(3, len(converted_measure.formulas))
self.assertAlmostEqual(
converted_measure.value, measure.value * 36)
