Measurement asdf

.typo-ci.yml

@@ -20,6 +20,7 @@ excluded_words:
   - pandas
   - xarray
   - scipy
+  - sympy
   - pytest
   - pydocstyle
   - matplotlib
@@ -101,3 +102,4 @@ excluded_words:
   - xyz
   - bamwelding
   - netcdf
+  - msm

CHANGELOG.md

@@ -15,3 +15,16 @@
 `weldx.transformations.CoordinateSystemManager`.
 - add test for `xarray.DataArray`, `xarray.Dataset`, `weldx.transformations.LocalCoordinateSystem` and
 `weldx.transformations.CoordinateSystemManager` serialization.
+- allow using `pint.Quantity` coordinates in `weldx.transformations.LocalCoordinateSystem` [#70]
+- add measurement related ASDF serialization classes: [#70]
+  - `equipment/generic_equipment-1.0.0`
+  - `equipment/sensor-1.0.0`
+  - `measurement/data-1.0.0`
+  - `data_transformation-1.0.0`
+  - `measurement/error-1.0.0`
+  - `measurement/measurement-1.0.0`
+  - `measurement/measurement_chain-1.0.0`
+  - `measurement/signal-1.0.0`
+  - `measurement/source-1.0.0`
+- add ASDF support for `sympy` expressions with `core/mathematical_expression-1.0.0` [#70]
+- add example notebook for measurement chains in tutorials [#70]

environment.yml

@@ -8,6 +8,7 @@ dependencies:
   - numpy>=1.18
   - pandas>=1.0
   - scipy>=1.4
+  - sympy>=1.6
   - xarray>=0.15
   - pint>=0.11
   - bottleneck

setup.py

@@ -17,6 +17,7 @@
     "pandas>=1.0",
     "xarray>=0.15",
     "scipy>=1.4",
+    "sympy>=1.6",
     "pint>=0.11",
     "asdf>=2.6",
     "bottleneck>=1.3",

tests/asdf_tests/test_core.py

@@ -142,7 +142,7 @@ def get_local_coordinate_system(time_dep_orientation: bool, time_dep_coordinates
         A local coordinate system
 
     """
-    coords = [2, 5, 1]
+    coords = Q_(np.asarray([2.0, 5.0, 1.0]), "mm")
     orientation = tf.rotation_matrix_z(np.pi / 3)
 
     if not time_dep_orientation and not time_dep_coordinates:

tests/test_measurement.py

@@ -0,0 +1,125 @@
+import asdf
+import sympy
+import xarray as xr
+
+import weldx.measurement as msm
+from weldx.asdf.extension import WeldxAsdfExtension, WeldxExtension
+from weldx.asdf.tags.weldx.core.mathematical_expression import MathematicalExpression
+
+
+def test_generic_save():
+    data_01 = msm.Data(
+        name="Welding current", data=xr.DataArray([1, 2, 3, 4], dims=["time"])
+    )
+
+    data_02 = msm.Data(
+        name="Welding voltage", data=xr.DataArray([10, 20, 30, 40], dims=["time"])
+    )
+
+    src_01 = msm.Source(
+        name="Current Sensor",
+        output_signal=msm.Signal("analog", "V", data=None),
+        error=msm.Error(1337.42),
+    )
+
+    src_02 = msm.Source(
+        name="Voltage Sensor",
+        output_signal=msm.Signal("analog", "V", data=None),
+        error=msm.Error(1),
+    )
+
+    dp_01 = msm.DataTransformation(
+        name="AD conversion current measurement",
+        input_signal=msm.Signal("analog", "V", data=None),
+        output_signal=msm.Signal("digital", "V", data=None),
+        error=msm.Error(999.0),
+    )
+
+    dp_02 = msm.DataTransformation(
+        name="Calibration current measurement",
+        input_signal=msm.Signal("digital", "V", data=None),
+        output_signal=msm.Signal("digital", "A", data=data_01),
+        error=msm.Error(43.0),
+    )
+
+    dp_03 = msm.DataTransformation(
+        name="AD conversion voltage measurement",
+        input_signal=msm.Signal("analog", "V", data=None),
+        output_signal=msm.Signal("digital", "V", data=None),
+        error=msm.Error(2.0),
+    )
+
+    dp_04 = msm.DataTransformation(
+        name="Calibration voltage measurement",
+        input_signal=msm.Signal("digital", "V", data=None),
+        output_signal=msm.Signal("digital", "V", data=data_02),
+        error=msm.Error(3.0),
+    )
+
+    chn_01 = msm.MeasurementChain(
+        name="Current measurement", data_source=src_01, data_processors=[dp_01, dp_02]
+    )
+
+    chn_02 = msm.MeasurementChain(
+        name="Voltage measurement", data_source=src_02, data_processors=[dp_03, dp_04]
+    )
+
+    eqp_01 = msm.GenericEquipment(
+        "Current Sensor", sources=[src_01], data_transformations=[dp_02]
+    )
+    eqp_02 = msm.GenericEquipment(
+        "AD Converter", sources=None, data_transformations=[dp_01, dp_03]
+    )
+    eqp_03 = msm.GenericEquipment(
+        "Voltage Sensor", sources=None, data_transformations=[dp_04]
+    )
+
+    measurement_01 = msm.Measurement(
+        name="Current measurement", data=[data_01], measurement_chain=chn_01
+    )
+    measurement_02 = msm.Measurement(
+        name="Voltage measurement", data=[data_02], measurement_chain=chn_02
+    )
+
+    equipment = [eqp_01, eqp_02, eqp_03]
+    measurement_data = [data_01, data_02]
+    measurement_chains = [chn_01]
+    measurements = [measurement_01, measurement_02]
+    sources = [src_01]
+    processors = [dp_01, dp_02]
+
+    [a, x, b] = sympy.symbols("a x b")
+    expr_01 = MathematicalExpression(a * x + b)
+    expr_01.set_parameter("a", 2)
+    expr_01.set_parameter("b", 3)
+    print(expr_01.parameters)
+    print(expr_01.get_variable_names())
+    print(expr_01.evaluate(x=3))
+
+    tree = {
+        "equipment": equipment,
+        "data": measurement_data,
+        "measurements": measurements,
+        "expression": expr_01,
+        # "measurement_chains": measurement_chains,
+        # "data_sources": sources,
+        # "data_processors": processors,
+    }
+    with asdf.AsdfFile(tree, extensions=[WeldxExtension(), WeldxAsdfExtension()]) as f:
+        f.write_to("test.yaml")
+
+
+def test_generic_load():
+    f = asdf.open("test.yaml", extensions=[WeldxExtension(), WeldxAsdfExtension()])
+
+    # processors = f.tree["data_processors"]
+    # sources = f.tree["data_sources"]
+    # measurement_chains = f.tree["measurement_chains"]
+
+    # print(processors[0])
+    # print(sources[0])
+    # print(measurement_chains[0])
+    data = f.tree["data"]
+    expr = f.tree["expression"]
+    print(f.tree["expression"].expression)
+    res = expr.evaluate(x=data[0].data)