def __init__(self, **kwargs):
"""
Constructor
Required parameters:
- quantity: quantity to be filtered on
- threshold: either absolute or relative filter
- absolute: requires unit compatible with quantity
- relative: applies filter on relative contribute to sum
:param dict kwargs: configuration parameter
:raises InvalidInputError: if required arguments are not provided
"""
try:
self.quantity = kwargs["quantity"]
except KeyError:
raise InvalidInputError("Try to initialise Filter without specifying quantity.")
try:
try:
self.threshold = float(kwargs["threshold"])
self.type = "rel"
except ValueError:
self.threshold = PQ.create_generic(self.quantity + "Threshold", kwargs["threshold"])
self.type = "abs"
except KeyError:
raise InvalidInputError("Try to initialise Filter without specifying threshold.")
def __init__(self, *args, **kwargs):
try:
setattr(self, kwargs['type'], True)
self.multiplier = kwargs['multiplier']
tmp_multiplicand = kwargs['multiplicand']
if tmp_multiplicand.count("const"):
tmp_multiplicand = tmp_multiplicand.replace("const:", "")
try:
self.multiplicand = float(tmp_multiplicand)
except ValueError:
self.multiplicand = PQ.create_generic("multiplicand", tmp_multiplicand)
elif tmp_multiplicand.count("builtin"):
self.multiplicand = self.find_builtin(tmp_multiplicand.replace("builtin:", ""))
elif tmp_multiplicand.count("global:"):
if tmp_multiplicand.count("mass"):
self.multiplicand = "mass"
self.dict = True
else:
self.multiplicand = _global_data[tmp_multiplicand.replace("global:", "")]
self.scalar = True
else:
self.multiplicand = tmp_multiplicand
self.product = kwargs['product'].split(":")[0]
m = importlib.import_module("pyfluka.utils.PhysicsQuantities")
try:
self.quantity = getattr(m, kwargs['product'].split(":")[-1])
except AttributeError:
self.quantity = partial(getattr(m, 'create_generic'), kwargs['product'].split(":")[-1])
self.current_detector = None
except KeyError:
raise InvalidInputError("Unable to initialise multiplication operator")
def test_generic_pq(self):
generic_quantity = PQ.create_generic("foo", 10., 2., ureg.Bq)
self.assertEqual(generic_quantity.__class__.__name__, "foo")
self.assertEqual(generic_quantity.val, ureg.Quantity(10., ureg.Bq))
self.assertEqual(generic_quantity.unc, ureg.Quantity(2., ureg.Bq))
def test_division_scalar_int_lhs(self):
activity = PQ.Activity(10., 2.)
result = 5 / activity
self.assertEqual(result, PQ.create_generic("InvertedActivity", 0.5, 0., 1. / ureg.Bq))
def test_float_dimensionless_gt_true(self):
q1 = PQ.create_generic("dimless", 30.)
q2 = 20.
self.assertTrue(q1 > q2)
def test_get_header_generic(self):
q = PQ.create_generic("gen", 100., unit=ureg.Bq)
self.assertEqual('{:Lsu}'.format(q), " [$Bq$]")
def test_generic_formatting_latex(self):
q = PQ.create_generic("generic", 100., 0., ureg.Bq)
self.assertEqual("$100.0 Bq \pm 0.0 Bq$", '{:L}'.format(q))
def test_generic_comparison_2(self):
generic = PQ.create_generic("foo", 10000., 2000., ureg.Bq / ureg.kg)
res = PQ.SpecificActivity(10., 2., ureg.Bq / ureg.g)
self.assertEqual(generic, res)
def testActivityUnEqualsDiffUnc(self):
val1 = PQ.Activity(20., 2.1)
val2 = PQ.Activity(20., 3.1)
self.assertNotEqual(val1, val2)
def testActivityEqualsUnc(self):
val1 = PQ.Activity(20., 2.1)
val2 = PQ.Activity(20., 2.1)
self.assertEqual(val1, val2)
def testActivityUnEqualsDiffUnit(self):
val1 = PQ.Activity(20.)
val2 = PQ.Activity(20., unit=ureg.kBq)
self.assertNotEqual(val1, val2)
def testActivityUnEqualsSameUnit(self):
val1 = PQ.Activity(20.)
val2 = PQ.Activity(10.)
self.assertNotEqual(val1, val2)
def setUp(self):
self.config = {"quantity": "Activity", "threshold": 0.01}
self.filter = Filter(**self.config)
self.data = {"det1": {PQ.Isotope(3, 1, 0): StoredData(PQ.Activity(10.)),
PQ.Isotope(4, 2, 0): StoredData(PQ.Activity(2.)),
PQ.Isotope(22, 11, 0): StoredData(PQ.Activity(5.))}}
def test_relative_filter_resnuc_data_single_pass(self):
config = {"quantity": "Activity", "threshold": "0.5"}
fil = Filter(**config)
fil.invoke(self.data)
self.assertEqual(self.data, {"det1": {PQ.Isotope(3, 1, 0): StoredData(PQ.Activity(10.))}})
def test_config_absolute_threshold(self):
config = {"quantity": "Activity", "threshold": "2.0 Bq"}
fil = Filter(**config)
self.assertEqual(fil.threshold, PQ.create_generic("ActivityThreshold", 2.0, 0., ureg.Bq))
def test_generic_multiplication(self):
generic_quantity = PQ.create_generic("foo", 10., 2., ureg.Bq)
new_value = generic_quantity * 5.
self.assertTrue(new_value.val, ureg.Quantity(50., ureg.Bq))
def test_generic_comparison(self):
generic = PQ.create_generic("foo", 10., 2., ureg.Bq)
activity = PQ.Activity(10., 2., ureg.Bq)
self.assertEqual(generic, activity)
def testIsotopeCreationFromString(self):
isotope = PQ.Isotope(3, "H")
self.assertEqual([isotope.A, isotope.Z], [3, 1])
def test_copy_ctor_generic(self):
generic = PQ.create_generic("foo", 10000., 2000., ureg.Bq / ureg.kg)
res = PQ.SpecificActivity(10., 2., ureg.Bq / ureg.g)
val = PQ.SpecificActivity(generic)
self.assertEqual(val, res)
def testSummationActivityDifferentUnitsEquals(self):
val1 = PQ.Activity(20., 2.)
val2 = PQ.Activity(10., 3.)
unc = sqrt(pow(2., 2) + pow(3., 2))
res = PQ.Activity(30., unc)
self.assertEqual(val1 + val2, res)
def test_generic_formatting_latex_nounit(self):
q = PQ.create_generic("generic", 100., 0., ureg.Bq)
self.assertEqual("$100.0 \pm 0.0 $", '{:Lnu}'.format(q))
def testLatexString(self):
val = PQ.Activity(20., 2.)
self.assertEqual('{:L}'.format(val), "$20.0 Bq \pm 2.0 Bq$")
def test_comparison_dimension_check_pass_float(self):
q1 = PQ.create_generic("dimless", 20.)
q2 = 10.
self.assertFalse(q1._validate_comparison_input(q2))
def test_string(self):
val = PQ.Activity(20., 2.)
self.assertEqual('{!s}'.format(val), "Activity: 20.0 Bq +- 2.0 Bq")
def test_float_dimensionless_gt_false(self):
q1 = PQ.create_generic("dimless", 1.)
q2 = 5.
self.assertFalse(q1 > q2)
def test_latex_no_units(self):
val = PQ.Activity(20., 2.)
self.assertEqual('{:Lnu}'.format(val), "$20.0 \pm 2.0 $")
