def measurement_chain_with_equipment() -> MeasurementChain:
"""Get a default measurement chain with attached equipment."""
source = SignalSource(
"Current measurement",
output_signal=Signal(signal_type="analog", units="V"),
error=Error(Q_(1, "percent")),
)
ad_conversion = SignalTransformation(
"AD conversion current measurement",
error=Error(Q_(0, "percent")),
func=MathematicalExpression(expression="a*x+b",
parameters=dict(a=Q_(1, "1/V"),
b=Q_(1, ""))),
)
calibration = SignalTransformation(
"Current measurement calibration",
error=Error(Q_(1.2, "percent")),
func=MathematicalExpression(expression="a*x+b",
parameters=dict(a=Q_(1, "A"), b=Q_(1,
"A"))),
)
eq_source = MeasurementEquipment(
name="Source Equipment",
sources=[source],
)
eq_ad_conversion = MeasurementEquipment(name="AD Equipment",
transformations=[ad_conversion])
eq_calibration = MeasurementEquipment(name="Calibration Equipment",
transformations=[calibration])
mc = MeasurementChain.from_equipment("Measurement chain", eq_source)
mc.add_transformation_from_equipment(eq_ad_conversion)
mc.add_transformation_from_equipment(eq_calibration)
return mc
def measurement_chain_without_equipment() -> MeasurementChain:
"""Get a default measurement chain without attached equipment."""
mc = MeasurementChain(
"Current measurement chain",
SignalSource(
"Current measurement",
Signal("analog", "V"),
Error(Q_(0.1, "percent")),
),
)
mc.add_transformation(
SignalTransformation(
name="AD conversion",
error=Error(Q_(0.5, "percent")),
type_transformation="AD",
))
mc.add_transformation(
SignalTransformation(
name="Calibration",
error=Error(Q_(1.5, "percent")),
func=MathematicalExpression("a*x+b",
parameters=dict(a=Q_(3, "A/V"),
b=Q_(2, "A"))),
))
return mc
def _default_source_kwargs(kwargs: dict = None) -> dict:
"""Update a dict with default keyword arguments to create a `SignalSource`."""
default_kwargs = dict(
name="source", output_signal=Signal("analog", "V"), error=Error(0.01)
)
if kwargs is not None:
default_kwargs.update(kwargs)
return default_kwargs
def _default_add_transformation_kwargs(cls, kwargs: dict = None) -> dict:
"""Update a dict with default keyword arguments to call `add_transformation`."""
default_kwargs = dict(
transformation=cls._default_transformation(),
error=Error(0.02),
output_signal_type="digital",
output_signal_unit="",
)
if kwargs is not None:
default_kwargs.update(kwargs)
return default_kwargs
def _default_transformation(kwargs: dict = None) -> SignalTransformation:
"""Return a default `SignalTransformation`.
Use the kwargs parameter to modify the default values.
"""
default_kwargs = dict(
name="transformation",
error=Error(0.1),
func=MathematicalExpression("a*x", parameters={"a": Q_(1, "1/V")}),
type_transformation="AD",
)
if kwargs is not None:
default_kwargs.update(kwargs)
return SignalTransformation(**default_kwargs)
def test_meta_attr():
e = Error(3.0)
ts = pd.Timestamp("2020-01-01")
setattr(ts, META_ATTR, {"name": "Timestamp"})
setattr(e, META_ATTR, {"ts": ts})
setattr(e, USER_ATTR, {"description": "user info"})
tree = {"Error": e}
data = _write_read_buffer(tree)
e2 = data["Error"]
assert e2 == e
assert getattr(e2, META_ATTR) == getattr(e, META_ATTR)
assert getattr(e2, USER_ATTR) == getattr(e, USER_ATTR)
assert getattr(getattr(e2, META_ATTR)["ts"], META_ATTR) == getattr(ts, META_ATTR)
def test_meta_attr():
e = Error(3.0)
ts = pd.DatetimeIndex(["2020", "2021"])
setattr(ts, META_ATTR, {"name": "reference years"})
setattr(e, META_ATTR, {"ts": ts})
setattr(e, USER_ATTR, {"description": "user info"})
tree = {"Error": e}
data = write_read_buffer(tree)
e2 = data["Error"]
assert e2 == e
assert compare_nested(getattr(e2, META_ATTR), getattr(e, META_ATTR))
assert compare_nested(getattr(e2, USER_ATTR), getattr(e, USER_ATTR))
assert compare_nested(getattr(getattr(e2, META_ATTR)["ts"], META_ATTR),
getattr(ts, META_ATTR))
def from_tree(cls, tree, ctx):
obj = Error(**tree)
return obj