Repository: BAMWelDX/weldx

Issue:
update single pass weld schema
- add reference weld speed under process parameters,
- also add wire data
- add TCP system in reference to workpiece/groove system
- remove absolute reference timestamp from example

Discussion:
review-notebook-app[bot]: Check out this pull request on&nbsp; <a href="https://app.reviewnb.com/BAMWelDX/weldx/pull/256"><img align="absmiddle"  alt="ReviewNB" height="28" class="BotMessageButtonImage" src="https://raw.githubusercontent.com/ReviewNB/support/master/images/button_reviewnb.png"/></a> 

 See visual diffs & provide feedback on Jupyter Notebooks. 

---

 <i>Powered by <a href='https://www.reviewnb.com/?utm_source=gh'>ReviewNB</a></i>
CagtayFabry: for reference @marscher 

I will add more description texts later
codecov[bot]: # [Codecov](https://codecov.io/gh/BAMWelDX/weldx/pull/256?src=pr&el=h1) Report
> Merging [#256](https://codecov.io/gh/BAMWelDX/weldx/pull/256?src=pr&el=desc) (8b411e2) into [master](https://codecov.io/gh/BAMWelDX/weldx/commit/7c15afec24779132cb56bc76ac7ea66ea3a7003f?el=desc) (7c15afe) will **increase** coverage by `0.00%`.
> The diff coverage is `100.00%`.

[![Impacted file tree graph](https://codecov.io/gh/BAMWelDX/weldx/pull/256/graphs/tree.svg?width=650&height=150&src=pr&token=wdof1qQTsn)](https://codecov.io/gh/BAMWelDX/weldx/pull/256?src=pr&el=tree)

```diff
@@           Coverage Diff           @@
##           master     #256   +/-   ##
=======================================
  Coverage   99.39%   99.39%           
=======================================
  Files          71       71           
  Lines        3941     3942    +1     
=======================================
+ Hits         3917     3918    +1     
  Misses         24       24           
```


| [Impacted Files](https://codecov.io/gh/BAMWelDX/weldx/pull/256?src=pr&el=tree) | Coverage Δ | |
|---|---|---|
| [weldx/\_\_init\_\_.py](https://codecov.io/gh/BAMWelDX/weldx/pull/256/diff?src=pr&el=tree#diff-d2VsZHgvX19pbml0X18ucHk=) | `100.00% <100.00%> (ø)` | |

------

[Continue to review full report at Codecov](https://codecov.io/gh/BAMWelDX/weldx/pull/256?src=pr&el=continue).
> **Legend** - [Click here to learn more](https://docs.codecov.io/docs/codecov-delta)
> `Δ = absolute <relative> (impact)`, `ø = not affected`, `? = missing data`
> Powered by [Codecov](https://codecov.io/gh/BAMWelDX/weldx/pull/256?src=pr&el=footer). Last update [7c15afe...97839da](https://codecov.io/gh/BAMWelDX/weldx/pull/256?src=pr&el=lastupdated). Read the [comment docs](https://docs.codecov.io/docs/pull-request-comments).

CagtayFabry: not sure why RTD fails here, it runs for me locally so lets try the GH action ..
CagtayFabry: > not sure why RTD fails here, it runs for me locally so lets try the GH action ..

all good now, push was missing 33cb852
CagtayFabry: I have changed `weld_speed` to always be `TimeSeries` and added the required shape validator cases for scalar values @vhirtham @AndreasPittner 

Patch:
diff --git a/CHANGELOG.md b/CHANGELOG.md
index ba4aea9..d825667 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -8,9 +8,10 @@
   function [[#219]](https://github.com/BAMWelDX/weldx/pull/219)
 - add `SpatialDate` class for storing 3D point data with optional
   triangulation [[#234]](https://github.com/BAMWelDX/weldx/pull/234)
-- add `plot` function to `SpatialData`[[#251]](https://github.com/BAMWelDX/weldx/pull/251) 
-- add `plot` function to visualize `LocalCoordinateSystem` and `CoordinateSystemManager` instances in 3d space 
+- add `plot` function to `SpatialData`[[#251]](https://github.com/BAMWelDX/weldx/pull/251)
+- add `plot` function to visualize `LocalCoordinateSystem` and `CoordinateSystemManager` instances in 3d space
   [[#231]](https://github.com/BAMWelDX/weldx/pull/231)
+
 ### ASDF
 
 - Add possibility to store meta data and content of an external file in an ASDF
@@ -28,11 +29,14 @@
       as `custom_schema` when reading/writing `ASDF`-files
     - the `single_pass_weld-1.0.0.schema` is an example schema for a simple, linear, single pass GMAW application
     - add `core/geometry/point_cloud-1.0.0.yaml` schema [[#234]](https://github.com/BAMWelDX/weldx/pull/234)
+- add file schema describing a simple linear welding
+  application `datamodels/single_pass_weld-1.0.0.schema` [[#256]](https://github.com/BAMWelDX/weldx/pull/256)
 
 ### documentation
+
 - Simplify tutorial code and enhance plots by using newly implemented plot functions
-  [[#231]](https://github.com/BAMWelDX/weldx/pull/231) [[#251]](https://github.com/BAMWelDX/weldx/pull/251) 
-  
+  [[#231]](https://github.com/BAMWelDX/weldx/pull/231) [[#251]](https://github.com/BAMWelDX/weldx/pull/251)
+
 ### changes
 
 - pass variable names as tuple to `sympy.lambdify` in `MathematicalExpression` to prevent sympy
@@ -48,10 +52,12 @@
 - add `stack` option to most `geometry` classes for rasterization [[#234]](https://github.com/BAMWelDX/weldx/pull/234)
 - The graph of a `CoordinateSystemManager` is now plotted with `plot_graph` instead of `plot`.
   [[#231]](https://github.com/BAMWelDX/weldx/pull/231)
+- add custom `wx_shape` validation for `TimeSeries` and `Quantity` [[#256]](https://github.com/BAMWelDX/weldx/pull/256)
 - refactor the `transformations` and `visualization` module into smaller files [[#247]](https://github.com/BAMWelDX/weldx/pull/247)
 - refactor `weldx.utility` into `weldx.util` [[#247]](https://github.com/BAMWelDX/weldx/pull/247)
 - refactor `weldx.asdf.utils` into `weldx.asdf.util` [[#247]](https://github.com/BAMWelDX/weldx/pull/247)
 
+
 ### fixes
 
 - don't inline time dependent `LCS.coordinates` [[#222]](https://github.com/BAMWelDX/weldx/pull/222)
@@ -62,6 +68,8 @@
 - fix a bug with singleton dimensions in xarray
   interpolation/matmul [[#243]](https://github.com/BAMWelDX/weldx/pull/243)
 - update some documentation formatting and links [[#247]](https://github.com/BAMWelDX/weldx/pull/247)
+- fix `wx_shape` validation for scalar `Quantity` and `TimeSeries`
+  objects [[#256]](https://github.com/BAMWelDX/weldx/pull/256)
 
 ### dependencies
 
diff --git a/doc/shape-validation.md b/doc/shape-validation.md
index 9b6648a..1927a89 100644
--- a/doc/shape-validation.md
+++ b/doc/shape-validation.md
@@ -32,7 +32,7 @@ Each shape item follows these rules:
 
 * an ``Integer`` indicates a fix dimension for the same item
 
-* a ``~``, `:` or `None` indicates a single dimension of arbitrary length.
+* a ``~`` indicates a single dimension of arbitrary length.
 
 * a ``...`` indicates an arbitrary number of dimensions of arbitrary length, which can be optional.
 
@@ -40,7 +40,7 @@ Each shape item follows these rules:
 
 * parenthesis ``(_)`` indicate that the dimension is optional. This can be combined with the other rules.
 
-* the symbols ``~`` or `:` furthermore add the option to implement an interval. This string `4~` would be an open
+* the symbols ``~`` furthermore add the option to implement an interval. This string `4~` would be an open
   interval that accepts all dimensions that are greater or equal to 4.
 
 ### Exceptions
diff --git a/scripts/welding_schema.ipynb b/scripts/welding_schema.ipynb
deleted file mode 100644
index 8bef39a..0000000
--- a/scripts/welding_schema.ipynb
+++ /dev/null
@@ -1,485 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Welding schema"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "%cd -q .."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# some python imports that will be used throughout the tutorial\n",
-    "import matplotlib.pyplot as plt\n",
-    "import networkx as nx\n",
-    "import numpy as np\n",
-    "import pandas as pd\n",
-    "import pint\n",
-    "import sympy\n",
-    "import xarray as xr\n",
-    "from mpl_toolkits.mplot3d import Axes3D\n",
-    "\n",
-    "import asdf"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# importing the weldx package with prevalent default abbreviations\n",
-    "import weldx\n",
-    "import weldx.geometry as geo\n",
-    "import weldx.measurement as msm\n",
-    "import weldx.transformations as tf\n",
-    "import weldx.utility as ut\n",
-    "import weldx.visualization as vis\n",
-    "from weldx import Q_\n",
-    "from weldx.transformations import LocalCoordinateSystem as lcs\n",
-    "from weldx.transformations import WXRotation\n",
-    "from weldx.welding.groove.iso_9692_1 import get_groove"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Timestamp"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# file timestamp\n",
-    "reference_timestamp = pd.Timestamp(\"2020-11-09 12:00:00\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Geometry"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# groove + trace = geometry\n",
-    "groove = get_groove(\n",
-    "    groove_type=\"VGroove\",\n",
-    "    workpiece_thickness=Q_(5, \"mm\"),\n",
-    "    groove_angle=Q_(50, \"deg\"),\n",
-    "    root_face=Q_(1, \"mm\"),\n",
-    "    root_gap=Q_(1, \"mm\"),\n",
-    ")\n",
-    "\n",
-    "# define the weld seam length in mm\n",
-    "seam_length = Q_(300, \"mm\")\n",
-    "\n",
-    "# create a linear trace segment a the complete weld seam trace\n",
-    "trace_segment = geo.LinearHorizontalTraceSegment(seam_length)\n",
-    "trace = geo.Trace(trace_segment)\n",
-    "\n",
-    "geometry = dict(groove_shape=groove, seam_length=seam_length)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Setup the Coordinate System Manager (CSM)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# crete a new coordinate system manager with default base coordinate system\n",
-    "csm = weldx.transformations.CoordinateSystemManager(\"base\")\n",
-    "\n",
-    "# add the workpiece coordinate system\n",
-    "csm.add_cs(\n",
-    "    coordinate_system_name=\"workpiece\",\n",
-    "    reference_system_name=\"base\",\n",
-    "    lcs=trace.coordinate_system,\n",
-    ")\n",
-    "\n",
-    "tcp_start_point = Q_([5.0, 0.0, 2.0], \"mm\")\n",
-    "tcp_end_point = Q_([-5.0, 0.0, 2.0], \"mm\") + np.append(seam_length, Q_([0, 0], \"mm\"))\n",
-    "\n",
-    "v_weld = Q_(10, \"mm/s\")\n",
-    "s_weld = (tcp_end_point - tcp_start_point)[0]  # length of the weld\n",
-    "t_weld = s_weld / v_weld\n",
-    "\n",
-    "t_start = pd.Timedelta(\"0s\")\n",
-    "t_end = pd.Timedelta(str(t_weld.to_base_units()))\n",
-    "\n",
-    "rot = WXRotation.from_euler(seq=\"x\", angles=180, degrees=True)\n",
-    "\n",
-    "coords = [tcp_start_point.magnitude, tcp_end_point.magnitude]\n",
-    "\n",
-    "tcp_wire = lcs(coordinates=coords, orientation=rot, time=[t_start, t_end])\n",
-    "\n",
-    "# add the workpiece coordinate system\n",
-    "csm.add_cs(\n",
-    "    coordinate_system_name=\"tcp_wire\",\n",
-    "    reference_system_name=\"workpiece\",\n",
-    "    lcs=tcp_wire,\n",
-    ")\n",
-    "\n",
-    "tcp_contact = lcs(coordinates=[0, 0, -10])\n",
-    "\n",
-    "# add the workpiece coordinate system\n",
-    "csm.add_cs(\n",
-    "    coordinate_system_name=\"tcp_contact\",\n",
-    "    reference_system_name=\"tcp_wire\",\n",
-    "    lcs=tcp_contact,\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Measurements"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# time\n",
-    "time = pd.timedelta_range(start=\"0s\", end=\"10s\", freq=\"1ms\")\n",
-    "\n",
-    "# current data\n",
-    "I_ts = ut.sine(f=Q_(10, \"1/s\"), amp=Q_(20, \"A\"), bias=Q_(300, \"A\"))\n",
-    "I = I_ts.interp_time(time)\n",
-    "I[\"time\"] = I[\"time\"]\n",
-    "\n",
-    "current_data = msm.Data(name=\"Welding current\", data=I)\n",
-    "\n",
-    "# voltage data\n",
-    "U_ts = ut.sine(f=Q_(10, \"1/s\"), amp=Q_(3, \"V\"), bias=Q_(40, \"V\"), phase=Q_(0.1, \"rad\"))\n",
-    "U = U_ts.interp_time(time)\n",
-    "U[\"time\"] = U[\"time\"]\n",
-    "\n",
-    "voltage_data = msm.Data(name=\"Welding voltage\", data=U)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from asdf.tags.core import Software\n",
-    "\n",
-    "HKS_sensor = msm.GenericEquipment(name=\"HKS P1000-S3\")\n",
-    "BH_ELM = msm.GenericEquipment(name=\"Beckhoff ELM3002-0000\")\n",
-    "twincat_scope = Software(name=\"Beckhoff TwinCAT ScopeView\", version=\"3.4.3143\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "src_current = msm.Source(\n",
-    "    name=\"Current Sensor\",\n",
-    "    output_signal=msm.Signal(signal_type=\"analog\", unit=\"V\", data=None),\n",
-    "    error=msm.Error(Q_(0.1, \"percent\")),\n",
-    ")\n",
-    "\n",
-    "HKS_sensor.sources = []\n",
-    "HKS_sensor.sources.append(src_current)\n",
-    "\n",
-    "from weldx.core import MathematicalExpression\n",
-    "\n",
-    "[a, x, b] = sympy.symbols(\"a x b\")\n",
-    "current_AD_func = MathematicalExpression(a * x + b)\n",
-    "current_AD_func.set_parameter(\"a\", Q_(32768.0 / 10.0, \"1/V\"))\n",
-    "current_AD_func.set_parameter(\"b\", Q_(0.0, \"\"))\n",
-    "\n",
-    "current_AD_transform = msm.DataTransformation(\n",
-    "    name=\"AD conversion current measurement\",\n",
-    "    input_signal=src_current.output_signal,\n",
-    "    output_signal=msm.Signal(\"digital\", \"\", data=None),\n",
-    "    error=msm.Error(Q_(0.01, \"percent\")),\n",
-    "    func=current_AD_func,\n",
-    ")\n",
-    "\n",
-    "BH_ELM.data_transformations = []\n",
-    "BH_ELM.data_transformations.append(current_AD_transform)\n",
-    "\n",
-    "# define current output calibration expression and transformation\n",
-    "current_calib_func = MathematicalExpression(a * x + b)\n",
-    "current_calib_func.set_parameter(\"a\", Q_(1000.0 / 32768.0, \"A\"))\n",
-    "current_calib_func.set_parameter(\"b\", Q_(0.0, \"A\"))\n",
-    "\n",
-    "current_calib_transform = msm.DataTransformation(\n",
-    "    name=\"Calibration current measurement\",\n",
-    "    input_signal=current_AD_transform.output_signal,\n",
-    "    output_signal=msm.Signal(\"digital\", \"A\", data=current_data),\n",
-    "    error=msm.Error(0.0),\n",
-    "    func=current_calib_func,\n",
-    "    meta=twincat_scope,\n",
-    ")\n",
-    "\n",
-    "\n",
-    "welding_current_chain = msm.MeasurementChain(\n",
-    "    name=\"welding current measurement chain\",\n",
-    "    data_source=src_current,\n",
-    "    data_processors=[current_AD_transform, current_calib_transform],\n",
-    ")\n",
-    "\n",
-    "welding_current = msm.Measurement(\n",
-    "    name=\"welding current measurement\",\n",
-    "    data=[current_data],\n",
-    "    measurement_chain=welding_current_chain,\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "src_voltage = msm.Source(\n",
-    "    name=\"Voltage Sensor\",\n",
-    "    output_signal=msm.Signal(\"analog\", \"V\", data=None),\n",
-    "    error=msm.Error(Q_(0.1, \"percent\")),\n",
-    ")\n",
-    "\n",
-    "HKS_sensor.sources.append(src_voltage)\n",
-    "\n",
-    "# define AD conversion expression and transformation step\n",
-    "[a, x, b] = sympy.symbols(\"a x b\")\n",
-    "voltage_ad_func = MathematicalExpression(a * x + b)\n",
-    "voltage_ad_func.set_parameter(\"a\", Q_(32768.0 / 10.0, \"1/V\"))\n",
-    "voltage_ad_func.set_parameter(\"b\", Q_(0.0, \"\"))\n",
-    "\n",
-    "voltage_AD_transform = msm.DataTransformation(\n",
-    "    name=\"AD conversion voltage measurement\",\n",
-    "    input_signal=src_voltage.output_signal,\n",
-    "    output_signal=msm.Signal(\"digital\", \"\", data=None),\n",
-    "    error=msm.Error(Q_(0.01, \"percent\")),\n",
-    "    func=voltage_ad_func,\n",
-    ")\n",
-    "\n",
-    "HKS_sensor.data_transformations.append(voltage_AD_transform)\n",
-    "\n",
-    "# define voltage output calibration expression and transformation\n",
-    "voltage_calib_func = MathematicalExpression(a * x + b)\n",
-    "voltage_calib_func.set_parameter(\"a\", Q_(100.0 / 32768.0, \"V\"))\n",
-    "voltage_calib_func.set_parameter(\"b\", Q_(0.0, \"V\"))\n",
-    "\n",
-    "voltage_calib_transform = msm.DataTransformation(\n",
-    "    name=\"Calibration voltage measurement\",\n",
-    "    input_signal=voltage_AD_transform.output_signal,\n",
-    "    output_signal=msm.Signal(\"digital\", \"V\", data=voltage_data),\n",
-    "    error=msm.Error(0.0),\n",
-    "    func=voltage_calib_func,\n",
-    "    meta=twincat_scope,\n",
-    ")\n",
-    "\n",
-    "\n",
-    "welding_voltage_chain = msm.MeasurementChain(\n",
-    "    name=\"welding voltage measurement chain\",\n",
-    "    data_source=src_voltage,\n",
-    "    data_processors=[voltage_AD_transform, voltage_calib_transform],\n",
-    ")\n",
-    "\n",
-    "welding_voltage = msm.Measurement(\n",
-    "    name=\"welding voltage measurement\",\n",
-    "    data=[voltage_data],\n",
-    "    measurement_chain=welding_voltage_chain,\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## GMAW Process"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from weldx.welding.processes import GmawProcess"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "params_pulse = dict(\n",
-    "    wire_feedrate=Q_(10.0, \"m/min\"),\n",
-    "    pulse_voltage=Q_(40.0, \"V\"),\n",
-    "    pulse_duration=Q_(5.0, \"ms\"),\n",
-    "    pulse_frequency=Q_(100.0, \"Hz\"),\n",
-    "    base_current=Q_(60.0, \"A\"),\n",
-    ")\n",
-    "process_pulse = GmawProcess(\n",
-    "    \"pulse\",\n",
-    "    \"CLOOS\",\n",
-    "    \"Quinto\",\n",
-    "    params_pulse,\n",
-    "    tag=\"CLOOS/pulse\",\n",
-    "    meta={\"modulation\": \"UI\"},\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from weldx.asdf.tags.weldx.aws.process.gas_component import GasComponent\n",
-    "from weldx.asdf.tags.weldx.aws.process.shielding_gas_for_procedure import (\n",
-    "    ShieldingGasForProcedure,\n",
-    ")\n",
-    "from weldx.asdf.tags.weldx.aws.process.shielding_gas_type import ShieldingGasType"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "gas_comp = [\n",
-    "    GasComponent(\"argon\", Q_(82, \"percent\")),\n",
-    "    GasComponent(\"carbon dioxide\", Q_(18, \"percent\")),\n",
-    "]\n",
-    "gas_type = ShieldingGasType(gas_component=gas_comp, common_name=\"SG\")\n",
-    "\n",
-    "gas_for_procedure = ShieldingGasForProcedure(\n",
-    "    use_torch_shielding_gas=True,\n",
-    "    torch_shielding_gas=gas_type,\n",
-    "    torch_shielding_gas_flowrate=Q_(20, \"l / min\"),\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "process = dict(welding_process=process_pulse, shielding_gas=gas_for_procedure)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## ASDF file"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "tree = dict(\n",
-    "    reference_timestamp=reference_timestamp,\n",
-    "    equipment=[HKS_sensor, BH_ELM],\n",
-    "    measurements=[welding_current, welding_voltage],\n",
-    "    welding_current=current_calib_transform.output_signal,\n",
-    "    welding_voltage=voltage_calib_transform.output_signal,\n",
-    "    coordinate_systems=csm,\n",
-    "    geometry=geometry,\n",
-    "    process=process,\n",
-    "    meta={\"welder\": \"A.W. Elder\"},\n",
-    ")\n",
-    "\n",
-    "\n",
-    "buffer = weldx.asdf.utils._write_buffer(\n",
-    "    tree,\n",
-    "    asdffile_kwargs=dict(\n",
-    "        custom_schema=\"./weldx/asdf/schemas/weldx.bam.de/weldx/datamodels/single_pass_weld-1.0.0.schema.yaml\"\n",
-    "    ),\n",
-    ")\n",
-    "weldx.asdf.utils.notebook_fileprinter(buffer)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "filename = \"schema_example_01.asdf\"\n",
-    "\n",
-    "with asdf.AsdfFile(\n",
-    "    tree,\n",
-    "    ignore_version_mismatch=False,\n",
-    "    custom_schema=\"./weldx/asdf/schemas/weldx.bam.de/weldx/datamodels/single_pass_weld-1.0.0.schema.yaml\",\n",
-    ") as ff:\n",
-    "    ff.write_to(filename)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "weldx",
-   "language": "python",
-   "name": "weldx"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.7.9"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 4
-}
diff --git a/scripts/welding_schema.py b/scripts/welding_schema.py
new file mode 100644
index 0000000..e076278
--- /dev/null
+++ b/scripts/welding_schema.py
@@ -0,0 +1,292 @@
+# Welding schema
+if __name__ == "__main__":
+
+    # Imports
+    from pathlib import Path
+
+    import asdf
+    import numpy as np
+    import pandas as pd
+    import sympy
+    from asdf.tags.core import Software
+
+    # importing the weldx package with prevalent default abbreviations
+    import weldx
+    import weldx.geometry as geo
+    import weldx.measurement as msm
+    import weldx.utility as ut
+    from weldx import Q_, GmawProcess
+    from weldx import LocalCoordinateSystem as lcs
+    from weldx import TimeSeries, WXRotation, get_groove
+    from weldx.asdf.tags.weldx.aws.process.gas_component import GasComponent
+    from weldx.asdf.tags.weldx.aws.process.shielding_gas_for_procedure import (
+        ShieldingGasForProcedure,
+    )
+    from weldx.asdf.tags.weldx.aws.process.shielding_gas_type import ShieldingGasType
+
+    # Timestamp
+    reference_timestamp = pd.Timestamp("2020-11-09 12:00:00")
+
+    # Geometry
+    # groove + trace = geometry
+    groove = get_groove(
+        groove_type="VGroove",
+        workpiece_thickness=Q_(5, "mm"),
+        groove_angle=Q_(50, "deg"),
+        root_face=Q_(1, "mm"),
+        root_gap=Q_(1, "mm"),
+    )
+
+    # define the weld seam length in mm
+    seam_length = Q_(300, "mm")
+
+    # create a linear trace segment a the complete weld seam trace
+    trace_segment = geo.LinearHorizontalTraceSegment(seam_length)
+    trace = geo.Trace(trace_segment)
+
+    geometry = dict(groove_shape=groove, seam_length=seam_length)
+
+    base_metal = dict(common_name="S355J2+N", standard="DIN EN 10225-2:2011")
+
+    workpiece = dict(base_metal=base_metal, geometry=geometry)
+
+    # Setup the Coordinate System Manager (CSM)
+    # crete a new coordinate system manager with default base coordinate system
+    csm = weldx.transformations.CoordinateSystemManager("base")
+
+    # add the workpiece coordinate system
+    csm.add_cs(
+        coordinate_system_name="workpiece",
+        reference_system_name="base",
+        lcs=trace.coordinate_system,
+    )
+
+    tcp_start_point = Q_([5.0, 0.0, 2.0], "mm")
+    tcp_end_point = Q_([-5.0, 0.0, 2.0], "mm") + np.append(
+        seam_length, Q_([0, 0], "mm")
+    )
+
+    v_weld = Q_(10, "mm/s")
+    s_weld = (tcp_end_point - tcp_start_point)[0]  # length of the weld
+    t_weld = s_weld / v_weld
+
+    t_start = pd.Timedelta("0s")
+    t_end = pd.Timedelta(str(t_weld.to_base_units()))
+
+    rot = WXRotation.from_euler(seq="x", angles=180, degrees=True)
+
+    coords = [tcp_start_point.magnitude, tcp_end_point.magnitude]
+
+    tcp_wire = lcs(coordinates=coords, orientation=rot, time=[t_start, t_end])
+
+    # add the workpiece coordinate system
+    csm.add_cs(
+        coordinate_system_name="tcp_wire",
+        reference_system_name="workpiece",
+        lcs=tcp_wire,
+    )
+
+    tcp_contact = lcs(coordinates=[0, 0, -10])
+
+    # add the workpiece coordinate system
+    csm.add_cs(
+        coordinate_system_name="tcp_contact",
+        reference_system_name="tcp_wire",
+        lcs=tcp_contact,
+    )
+
+    TCP_reference = csm.get_cs("tcp_contact", "workpiece")
+
+    # Measurements
+    # time
+    time = pd.timedelta_range(start="0s", end="10s", freq="1ms")
+
+    # current data
+    I_ts = ut.sine(f=Q_(10, "1/s"), amp=Q_(20, "A"), bias=Q_(300, "A"))
+    I = I_ts.interp_time(time)  # noqa: E741
+    I["time"] = I["time"]
+
+    current_data = msm.Data(name="Welding current", data=I)
+
+    # voltage data
+    U_ts = ut.sine(
+        f=Q_(10, "1/s"), amp=Q_(3, "V"), bias=Q_(40, "V"), phase=Q_(0.1, "rad")
+    )
+    U = U_ts.interp_time(time)
+    U["time"] = U["time"]
+
+    voltage_data = msm.Data(name="Welding voltage", data=U)
+
+    HKS_sensor = msm.GenericEquipment(name="HKS P1000-S3")
+    BH_ELM = msm.GenericEquipment(name="Beckhoff ELM3002-0000")
+    twincat_scope = Software(name="Beckhoff TwinCAT ScopeView", version="3.4.3143")
+
+    src_current = msm.Source(
+        name="Current Sensor",
+        output_signal=msm.Signal(signal_type="analog", unit="V", data=None),
+        error=msm.Error(Q_(0.1, "percent")),
+    )
+
+    HKS_sensor.sources = []
+    HKS_sensor.sources.append(src_current)
+
+    from weldx.core import MathematicalExpression
+
+    [a, x, b] = sympy.symbols("a x b")
+    current_AD_func = MathematicalExpression(a * x + b)
+    current_AD_func.set_parameter("a", Q_(32768.0 / 10.0, "1/V"))
+    current_AD_func.set_parameter("b", Q_(0.0, ""))
+
+    current_AD_transform = msm.DataTransformation(
+        name="AD conversion current measurement",
+        input_signal=src_current.output_signal,
+        output_signal=msm.Signal("digital", "", data=None),
+        error=msm.Error(Q_(0.01, "percent")),
+        func=current_AD_func,
+    )
+
+    BH_ELM.data_transformations = []
+    BH_ELM.data_transformations.append(current_AD_transform)
+
+    # define current output calibration expression and transformation
+    current_calib_func = MathematicalExpression(a * x + b)
+    current_calib_func.set_parameter("a", Q_(1000.0 / 32768.0, "A"))
+    current_calib_func.set_parameter("b", Q_(0.0, "A"))
+
+    current_calib_transform = msm.DataTransformation(
+        name="Calibration current measurement",
+        input_signal=current_AD_transform.output_signal,
+        output_signal=msm.Signal("digital", "A", data=current_data),
+        error=msm.Error(0.0),
+        func=current_calib_func,
+    )
+    current_calib_transform.wx_metadata = dict(software=twincat_scope)
+
+    welding_current_chain = msm.MeasurementChain(
+        name="welding current measurement chain",
+        data_source=src_current,
+        data_processors=[current_AD_transform, current_calib_transform],
+    )
+
+    welding_current = msm.Measurement(
+        name="welding current measurement",
+        data=[current_data],
+        measurement_chain=welding_current_chain,
+    )
+
+    src_voltage = msm.Source(
+        name="Voltage Sensor",
+        output_signal=msm.Signal("analog", "V", data=None),
+        error=msm.Error(Q_(0.1, "percent")),
+    )
+
+    HKS_sensor.sources.append(src_voltage)
+
+    # define AD conversion expression and transformation step
+    [a, x, b] = sympy.symbols("a x b")
+    voltage_ad_func = MathematicalExpression(a * x + b)
+    voltage_ad_func.set_parameter("a", Q_(32768.0 / 10.0, "1/V"))
+    voltage_ad_func.set_parameter("b", Q_(0.0, ""))
+
+    voltage_AD_transform = msm.DataTransformation(
+        name="AD conversion voltage measurement",
+        input_signal=src_voltage.output_signal,
+        output_signal=msm.Signal("digital", "", data=None),
+        error=msm.Error(Q_(0.01, "percent")),
+        func=voltage_ad_func,
+    )
+
+    HKS_sensor.data_transformations.append(voltage_AD_transform)
+
+    # define voltage output calibration expression and transformation
+    voltage_calib_func = MathematicalExpression(a * x + b)
+    voltage_calib_func.set_parameter("a", Q_(100.0 / 32768.0, "V"))
+    voltage_calib_func.set_parameter("b", Q_(0.0, "V"))
+
+    voltage_calib_transform = msm.DataTransformation(
+        name="Calibration voltage measurement",
+        input_signal=voltage_AD_transform.output_signal,
+        output_signal=msm.Signal("digital", "V", data=voltage_data),
+        error=msm.Error(0.0),
+        func=voltage_calib_func,
+    )
+    voltage_calib_transform.wx_metadata = dict(software=twincat_scope)
+
+    welding_voltage_chain = msm.MeasurementChain(
+        name="welding voltage measurement chain",
+        data_source=src_voltage,
+        data_processors=[voltage_AD_transform, voltage_calib_transform],
+    )
+
+    welding_voltage = msm.Measurement(
+        name="welding voltage measurement",
+        data=[voltage_data],
+        measurement_chain=welding_voltage_chain,
+    )
+
+    # GMAW Process
+    params_pulse = dict(
+        wire_feedrate=Q_(10.0, "m/min"),
+        pulse_voltage=Q_(40.0, "V"),
+        pulse_duration=Q_(5.0, "ms"),
+        pulse_frequency=Q_(100.0, "Hz"),
+        base_current=Q_(60.0, "A"),
+    )
+    process_pulse = GmawProcess(
+        "pulse",
+        "CLOOS",
+        "Quinto",
+        params_pulse,
+        tag="CLOOS/pulse",
+        meta={"modulation": "UI"},
+    )
+
+    gas_comp = [
+        GasComponent("argon", Q_(82, "percent")),
+        GasComponent("carbon dioxide", Q_(18, "percent")),
+    ]
+    gas_type = ShieldingGasType(gas_component=gas_comp, common_name="SG")
+
+    gas_for_procedure = ShieldingGasForProcedure(
+        use_torch_shielding_gas=True,
+        torch_shielding_gas=gas_type,
+        torch_shielding_gas_flowrate=Q_(20, "l / min"),
+    )
+
+    process = dict(
+        welding_process=process_pulse,
+        shielding_gas=gas_for_procedure,
+        weld_speed=TimeSeries(v_weld),
+        welding_wire={"diameter": Q_(1.2, "mm")},
+    )
+
+    # ASDF file
+    tree = dict(
+        reference_timestamp=reference_timestamp,
+        equipment=[HKS_sensor, BH_ELM],
+        measurements=[welding_current, welding_voltage],
+        welding_current=current_calib_transform.output_signal,
+        welding_voltage=voltage_calib_transform.output_signal,
+        coordinate_systems=csm,
+        TCP=TCP_reference,
+        workpiece=workpiece,
+        process=process,
+        wx_metadata={"welder": "A.W. Elder"},
+    )
+
+    model_path = Path(weldx.__path__[0]) / Path(
+        "./asdf/schemas/weldx.bam.de/weldx/datamodels/"
+        "single_pass_weld-1.0.0.schema.yaml"
+    )
+    model_path = model_path.as_posix()
+
+    res = weldx.asdf.utils._write_read_buffer(
+        tree,
+        asdffile_kwargs=dict(custom_schema=str(model_path)),
+    )
+
+    with asdf.AsdfFile(
+        tree,
+        custom_schema=str(model_path),
+    ) as ff:
+        ff.write_to("single_pass_weld_example.asdf")
diff --git a/setup.cfg b/setup.cfg
index 12248a6..e7d8ca9 100644
--- a/setup.cfg
+++ b/setup.cfg
@@ -86,11 +86,13 @@ ignore = D203,D213
 [tool:pytest]
 addopts = --tb=short --color=yes -rs --cov=weldx --cov-report=term-missing:skip-covered
 #addopts = --tb=short --color=yes -rs -p no:cov
-asdf_schema_root = weldx/asdf/schemas
-#asdf_schema_tests_enabled = true
 # custom test markers, see https://docs.pytest.org/en/latest/example/markers.html#mark-examples
 markers =
     slow: marks tests as slow to run (skipped by default, enable with --runslow option)
+asdf_schema_root = weldx/asdf/schemas
+#asdf_schema_tests_enabled = true
+asdf_schema_skip_tests =
+    weldx.bam.de/weldx/datamodels/single_pass_weld-1.0.0.schema.yaml
 
 [isort]
 profile = black
diff --git a/weldx/__init__.py b/weldx/__init__.py
index 3239273..393ba8e 100644
--- a/weldx/__init__.py
+++ b/weldx/__init__.py
@@ -40,12 +40,14 @@ from weldx.transformations import (
     LocalCoordinateSystem,
     WXRotation,
 )
+from weldx.welding.processes import GmawProcess
 from weldx.welding.groove.iso_9692_1 import get_groove
 
 __all__ = (
     # major modules
     "core",
     "geometry",
+    "GmawProcess",
     "measurement",
     "transformations",
     "util",
diff --git a/weldx/asdf/schemas/weldx.bam.de/weldx/datamodels/single_pass_weld-1.0.0.schema.yaml b/weldx/asdf/schemas/weldx.bam.de/weldx/datamodels/single_pass_weld-1.0.0.schema.yaml
index 0af1a85..107f8bd 100644
--- a/weldx/asdf/schemas/weldx.bam.de/weldx/datamodels/single_pass_weld-1.0.0.schema.yaml
+++ b/weldx/asdf/schemas/weldx.bam.de/weldx/datamodels/single_pass_weld-1.0.0.schema.yaml
@@ -4,10 +4,19 @@ $schema: "http://stsci.edu/schemas/yaml-schema/draft-01"
 id: "http://weldx.bam.de/schemas/weldx/datamodels/single_pass_weld-1.0.0.schema"
 
 title: |
-  Single pass GMAW weldment.
+  Single pass, single wire GMAW weldment.
 description: |
   Schema describing a simple single pass welding application along a linear weld seam with constant groove shape.
 
+  The workpiece is defined by two constant properties:
+  - the groove shape as defined by ISO 9692-1
+  - the total seam length
+  It is assumed that the complete workpiece length is equal to the seam length.
+  Outside of the welding groove shape, no information is given regarding the outer shape of the workpiece.
+  More complex workpiece data can be attached as custom data to the associated coordinate system.
+
+  The TCP movement coordinates along the workpiece x-axis should fall into the range between 0 and the seam length to be plausible.
+
 type: object
 properties:
   process:
@@ -17,52 +26,406 @@ properties:
         $ref: "http://weldx.bam.de/schemas/weldx/process/GMAW-1.0.0"
       shielding_gas:
         tag: "tag:weldx.bam.de:weldx/aws/process/shielding_gas_for_procedure-1.0.0"
-  equipment:
-    type: array
-    items:
-      tag: "tag:weldx.bam.de:weldx/equipment/generic_equipment-1.0.0"
-  measurements:
-    type: array
-    items:
-      tag: "tag:weldx.bam.de:weldx/measurement/measurement-1.0.0"
+      weld_speed:
+        description: |
+          The constant weld speed of the welding TCP movement.
+        tag: "tag:weldx.bam.de:weldx/core/time_series-1.0.0"
+        wx_unit: "m/s"
+        wx_shape: [1]
+      welding_wire:
+        type: object
+        properties:
+          diameter:
+            description: |
+              The diameter of the welding wire.
+            tag: "tag:stsci.edu:asdf/unit/quantity-1.1.0"
+            wx_unit: "m"
+            wx_shape: [1]
+          class:
+            description: |
+              The wire classification according to DIN EN ISO 14341, DIN EN 12072 or similar standards.
+              Addition standard details should be stored in the wx_user property.
+            type: string
+            required: [wire_diameter]
+    required: [welding_process, shielding_gas, weld_speed, welding_wire]
   welding_current:
+    description: |
+      The signal representing the welding current measurement.
     tag: "tag:weldx.bam.de:weldx/measurement/signal-1.0.0"
     wx_unit: "A"
   welding_voltage:
+    description: |
+      The signal representing the welding voltage measurement.
     tag: "tag:weldx.bam.de:weldx/measurement/signal-1.0.0"
     wx_unit: "V"
+  TCP:
+    description: |
+      Transformation describing the welding TCP movement in relation to the groove coordinates.
+    tag: "tag:weldx.bam.de:weldx/core/transformations/local_coordinate_system-1.0.0"
+    wx_shape:
+      time: [2~]
   coordinate_systems:
     tag: "tag:weldx.bam.de:weldx/core/transformations/coordinate_system_hierarchy-1.0.0"
-  geometry:
+  equipment:
+    type: array
+    items:
+      tag: "tag:weldx.bam.de:weldx/equipment/generic_equipment-1.0.0"
+  measurements:
+    description: |
+      List of all measurements associated with the experiment.
+    type: array
+    items:
+      tag: "tag:weldx.bam.de:weldx/measurement/measurement-1.0.0"
+  workpiece:
+    description: |
+      The workpiece to be welded defined by the base metal and the geometric description of the weld seam.
     type: object
     properties:
-      groove_shape:
+      base_metal:
         description: |
-          Constant groove shape of the weld seam.
-        oneOf:
-          - tag: "tag:weldx.bam.de:weldx/groove/iso_9692_1_2013_12/DHUGroove-1.0.0"
-          - tag: "tag:weldx.bam.de:weldx/groove/iso_9692_1_2013_12/DHVGroove-1.0.0"
-          - tag: "tag:weldx.bam.de:weldx/groove/iso_9692_1_2013_12/DUGroove-1.0.0"
-          - tag: "tag:weldx.bam.de:weldx/groove/iso_9692_1_2013_12/DVGroove-1.0.0"
-          - tag: "tag:weldx.bam.de:weldx/groove/iso_9692_1_2013_12/FFGroove-1.0.0"
-          - tag: "tag:weldx.bam.de:weldx/groove/iso_9692_1_2013_12/HUGroove-1.0.0"
-          - tag: "tag:weldx.bam.de:weldx/groove/iso_9692_1_2013_12/HVGroove-1.0.0"
-          - tag: "tag:weldx.bam.de:weldx/groove/iso_9692_1_2013_12/IGroove-1.0.0"
-          - tag: "tag:weldx.bam.de:weldx/groove/iso_9692_1_2013_12/UGroove-1.0.0"
-          - tag: "tag:weldx.bam.de:weldx/groove/iso_9692_1_2013_12/UVGroove-1.0.0"
-          - tag: "tag:weldx.bam.de:weldx/groove/iso_9692_1_2013_12/VGroove-1.0.0"
-          - tag: "tag:weldx.bam.de:weldx/groove/iso_9692_1_2013_12/VVGroove-1.0.0"
-      seam_length:
+          The base metal composition of the workpiece.
+        type: object
+        properties:
+          common_name:
+            description: |
+              The common description of the base metal composition or classification as listed in the standard.
+            type: string
+          standard:
+            description: |
+              The standard listing and describing the base metal compositions.
+            type: string
+        required: [common_name, standard]
+      geometry:
         description: |
-          Length of the linear weld seam.
-        tag: "tag:stsci.edu:asdf/unit/quantity-1.1.0"
-        wx_unit: "m"
-    required: [groove_shape, seam_length]
+          Description of the workpiece geometry consisting of the groove shape and the total seam length.
+        type: object
+        properties:
+          groove_shape:
+            description: |
+              Constant groove shape of the weld seam.
+            oneOf:
+              - tag: "tag:weldx.bam.de:weldx/groove/iso_9692_1_2013_12/DHUGroove-1.0.0"
+              - tag: "tag:weldx.bam.de:weldx/groove/iso_9692_1_2013_12/DHVGroove-1.0.0"
+              - tag: "tag:weldx.bam.de:weldx/groove/iso_9692_1_2013_12/DUGroove-1.0.0"
+              - tag: "tag:weldx.bam.de:weldx/groove/iso_9692_1_2013_12/DVGroove-1.0.0"
+              - tag: "tag:weldx.bam.de:weldx/groove/iso_9692_1_2013_12/FFGroove-1.0.0"
+              - tag: "tag:weldx.bam.de:weldx/groove/iso_9692_1_2013_12/HUGroove-1.0.0"
+              - tag: "tag:weldx.bam.de:weldx/groove/iso_9692_1_2013_12/HVGroove-1.0.0"
+              - tag: "tag:weldx.bam.de:weldx/groove/iso_9692_1_2013_12/IGroove-1.0.0"
+              - tag: "tag:weldx.bam.de:weldx/groove/iso_9692_1_2013_12/UGroove-1.0.0"
+              - tag: "tag:weldx.bam.de:weldx/groove/iso_9692_1_2013_12/UVGroove-1.0.0"
+              - tag: "tag:weldx.bam.de:weldx/groove/iso_9692_1_2013_12/VGroove-1.0.0"
+              - tag: "tag:weldx.bam.de:weldx/groove/iso_9692_1_2013_12/VVGroove-1.0.0"
+          seam_length:
+            description: |
+              Length of the linear weld seam.
+            tag: "tag:stsci.edu:asdf/unit/quantity-1.1.0"
+            wx_unit: "m"
+        required: [groove_shape, seam_length]
+    required: [base_metal, geometry]
   reference_timestamp:
+    description: |
+      An optional timestamp indicating the start of the welding process.
     tag: "tag:weldx.bam.de:weldx/time/timestamp-1.0.0"
-  meta:
+  wx_metadata:
     description: |
       General metadata container.
     type: object
-required: [equipment,geometry,measurements,coordinate_systems,welding_current,welding_voltage]
+  wx_user:
+    description: |
+      Metadata container for additional user documentation of the experiment.
+    type: object
+required: [equipment,workpiece,measurements,welding_current,welding_voltage,TCP]
+additionalProperties: false
+
+
+examples:
+  -
+    - A simple welding application
+    - |
+      TCP: !<tag:weldx.bam.de:weldx/core/transformations/local_coordinate_system-1.0.0>
+        time: !<tag:weldx.bam.de:weldx/time/timedeltaindex-1.0.0>
+          values: !core/ndarray-1.0.0
+            data: [0, 29000000000]
+            datatype: int64
+            shape: [2]
+          start: !<tag:weldx.bam.de:weldx/time/timedelta-1.0.0> {value: P0DT0H0M0S}
+          end: !<tag:weldx.bam.de:weldx/time/timedelta-1.0.0> {value: P0DT0H0M29S}
+          min: !<tag:weldx.bam.de:weldx/time/timedelta-1.0.0> {value: P0DT0H0M0S}
+          max: !<tag:weldx.bam.de:weldx/time/timedelta-1.0.0> {value: P0DT0H0M29S}
+        orientations: !<tag:weldx.bam.de:weldx/core/variable-1.0.0>
+          name: orientations
+          dimensions: [c, v]
+          dtype: <f8
+          data: !core/ndarray-1.0.0
+            data:
+            - [1.0, 0.0, 0.0]
+            - [0.0, -1.0, -1.2246467991473532e-16]
+            - [0.0, 1.2246467991473532e-16, -1.0]
+            datatype: float64
+            shape: [3, 3]
+        coordinates: !<tag:weldx.bam.de:weldx/core/variable-1.0.0>
+          name: coordinates
+          dimensions: [time, c]
+          dtype: <f8
+          data: !core/ndarray-1.0.0
+            data:
+            - [5.0, 1.2246467991473533e-15, 12.0]
+            - [295.0, 1.2246467991473533e-15, 12.0]
+            datatype: float64
+            shape: [2, 3]
+      coordinate_systems: !<tag:weldx.bam.de:weldx/core/transformations/coordinate_system_hierarchy-1.0.0>
+        name: Coordinate system manager 0
+        root_system_name: base
+        subsystems: []
+        coordinate_systems:
+        - !<tag:weldx.bam.de:weldx/core/transformations/coordinate_transformation-1.0.0>
+          name: workpiece
+          reference_system: base
+          transformation: !<tag:weldx.bam.de:weldx/core/transformations/local_coordinate_system-1.0.0> {}
+        - !<tag:weldx.bam.de:weldx/core/transformations/coordinate_transformation-1.0.0>
+          name: tcp_wire
+          reference_system: workpiece
+          transformation: !<tag:weldx.bam.de:weldx/core/transformations/local_coordinate_system-1.0.0>
+            time: !<tag:weldx.bam.de:weldx/time/timedeltaindex-1.0.0>
+              values: !core/ndarray-1.0.0
+                data: [0, 29000000000]
+                datatype: int64
+                shape: [2]
+              start: !<tag:weldx.bam.de:weldx/time/timedelta-1.0.0> {value: P0DT0H0M0S}
+              end: !<tag:weldx.bam.de:weldx/time/timedelta-1.0.0> {value: P0DT0H0M29S}
+              min: !<tag:weldx.bam.de:weldx/time/timedelta-1.0.0> {value: P0DT0H0M0S}
+              max: !<tag:weldx.bam.de:weldx/time/timedelta-1.0.0> {value: P0DT0H0M29S}
+            orientations: !<tag:weldx.bam.de:weldx/core/variable-1.0.0>
+              name: orientations
+              dimensions: [c, v]
+              dtype: <f8
+              data: !core/ndarray-1.0.0
+                data:
+                - [1.0, 0.0, 0.0]
+                - [0.0, -1.0, -1.2246467991473532e-16]
+                - [0.0, 1.2246467991473532e-16, -1.0]
+                datatype: float64
+                shape: [3, 3]
+            coordinates: !<tag:weldx.bam.de:weldx/core/variable-1.0.0>
+              name: coordinates
+              dimensions: [time, c]
+              dtype: <f8
+              data: !core/ndarray-1.0.0
+                data:
+                - [5.0, 0.0, 2.0]
+                - [295.0, 0.0, 2.0]
+                datatype: float64
+                shape: [2, 3]
+        - !<tag:weldx.bam.de:weldx/core/transformations/coordinate_transformation-1.0.0>
+          name: tcp_contact
+          reference_system: tcp_wire
+          transformation: !<tag:weldx.bam.de:weldx/core/transformations/local_coordinate_system-1.0.0>
+            coordinates: !<tag:weldx.bam.de:weldx/core/variable-1.0.0>
+              name: coordinates
+              dimensions: [c]
+              dtype: <f8
+              data: !core/ndarray-1.0.0
+                data: [0.0, 0.0, -10.0]
+                datatype: float64
+                shape: [3]
+        subsystem_names: []
+      equipment:
+      - !<tag:weldx.bam.de:weldx/equipment/generic_equipment-1.0.0>
+        name: HKS P1000-S3
+        sources:
+        - &id003 !<tag:weldx.bam.de:weldx/measurement/source-1.0.0>
+          name: Current Sensor
+          output_signal: &id002 !<tag:weldx.bam.de:weldx/measurement/signal-1.0.0>
+            signal_type: analog
+            unit: V
+          error: !<tag:weldx.bam.de:weldx/measurement/error-1.0.0>
+            deviation: !unit/quantity-1.1.0 {unit: percent, value: 0.1}
+        - &id007 !<tag:weldx.bam.de:weldx/measurement/source-1.0.0>
+          name: Voltage Sensor
+          output_signal: &id001 !<tag:weldx.bam.de:weldx/measurement/signal-1.0.0>
+            signal_type: analog
+            unit: V
+          error: !<tag:weldx.bam.de:weldx/measurement/error-1.0.0>
+            deviation: !unit/quantity-1.1.0 {unit: percent, value: 0.1}
+        data_transformations:
+        - &id008 !<tag:weldx.bam.de:weldx/measurement/data_transformation-1.0.0>
+          name: AD conversion voltage measurement
+          input_signal: *id001
+          output_signal: &id009 !<tag:weldx.bam.de:weldx/measurement/signal-1.0.0>
+            signal_type: digital
+            unit: ''
+          error: !<tag:weldx.bam.de:weldx/measurement/error-1.0.0>
+            deviation: !unit/quantity-1.1.0 {unit: percent, value: 0.01}
+          func: !<tag:weldx.bam.de:weldx/core/mathematical_expression-1.0.0>
+            expression: a*x + b
+            parameters:
+              a: !unit/quantity-1.1.0 {unit: 1 / volt, value: 3276.8}
+              b: !unit/quantity-1.1.0 {unit: dimensionless, value: 0.0}
+      - !<tag:weldx.bam.de:weldx/equipment/generic_equipment-1.0.0>
+        name: Beckhoff ELM3002-0000
+        sources: []
+        data_transformations:
+        - &id004 !<tag:weldx.bam.de:weldx/measurement/data_transformation-1.0.0>
+          name: AD conversion current measurement
+          input_signal: *id002
+          output_signal: &id005 !<tag:weldx.bam.de:weldx/measurement/signal-1.0.0>
+            signal_type: digital
+            unit: ''
+          error: !<tag:weldx.bam.de:weldx/measurement/error-1.0.0>
+            deviation: !unit/quantity-1.1.0 {unit: percent, value: 0.01}
+          func: !<tag:weldx.bam.de:weldx/core/mathematical_expression-1.0.0>
+            expression: a*x + b
+            parameters:
+              a: !unit/quantity-1.1.0 {unit: 1 / volt, value: 3276.8}
+              b: !unit/quantity-1.1.0 {unit: dimensionless, value: 0.0}
+      measurements:
+      - !<tag:weldx.bam.de:weldx/measurement/measurement-1.0.0>
+        name: welding current measurement
+        data:
+        - &id006 !<tag:weldx.bam.de:weldx/measurement/data-1.0.0>
+          name: Welding current
+          data: !<tag:weldx.bam.de:weldx/core/data_array-1.0.0>
+            attributes: {}
+            coordinates:
+            - !<tag:weldx.bam.de:weldx/core/variable-1.0.0>
+              name: time
+              dimensions: [time]
+              dtype: <m8[ns]
+              data: !core/ndarray-1.0.0
+                source: 0
+                datatype: int64
+                byteorder: little
+                shape: [10001]
+            data: !<tag:weldx.bam.de:weldx/core/variable-1.0.0>
+              name: data
+              dimensions: [time]
+              dtype: <f8
+              unit: ampere
+              data: !core/ndarray-1.0.0
+                source: 1
+                datatype: float64
+                byteorder: little
+                shape: [10001]
+        measurement_chain: !<tag:weldx.bam.de:weldx/measurement/measurement_chain-1.0.0>
+          name: welding current measurement chain
+          data_source: *id003
+          data_processors:
+          - *id004
+          - !<tag:weldx.bam.de:weldx/measurement/data_transformation-1.0.0>
+            name: Calibration current measurement
+            input_signal: *id005
+            output_signal: &id012 !<tag:weldx.bam.de:weldx/measurement/signal-1.0.0>
+              signal_type: digital
+              unit: A
+              data: *id006
+            error: !<tag:weldx.bam.de:weldx/measurement/error-1.0.0>
+              deviation: 0.0
+            func: !<tag:weldx.bam.de:weldx/core/mathematical_expression-1.0.0>
+              expression: a*x + b
+              parameters:
+                a: !unit/quantity-1.1.0 {unit: ampere, value: 0.030517578125}
+                b: !unit/quantity-1.1.0 {unit: ampere, value: 0.0}
+            wx_metadata:
+              software: &id011 !core/software-1.0.0 {name: Beckhoff TwinCAT ScopeView, version: 3.4.3143}
+      - !<tag:weldx.bam.de:weldx/measurement/measurement-1.0.0>
+        name: welding voltage measurement
+        data:
+        - &id010 !<tag:weldx.bam.de:weldx/measurement/data-1.0.0>
+          name: Welding voltage
+          data: !<tag:weldx.bam.de:weldx/core/data_array-1.0.0>
+            attributes: {}
+            coordinates:
+            - !<tag:weldx.bam.de:weldx/core/variable-1.0.0>
+              name: time
+              dimensions: [time]
+              dtype: <m8[ns]
+              data: !core/ndarray-1.0.0
+                source: 2
+                datatype: int64
+                byteorder: little
+                shape: [10001]
+            data: !<tag:weldx.bam.de:weldx/core/variable-1.0.0>
+              name: data
+              dimensions: [time]
+              dtype: <f8
+              unit: volt
+              data: !core/ndarray-1.0.0
+                source: 3
+                datatype: float64
+                byteorder: little
+                shape: [10001]
+        measurement_chain: !<tag:weldx.bam.de:weldx/measurement/measurement_chain-1.0.0>
+          name: welding voltage measurement chain
+          data_source: *id007
+          data_processors:
+          - *id008
+          - !<tag:weldx.bam.de:weldx/measurement/data_transformation-1.0.0>
+            name: Calibration voltage measurement
+            input_signal: *id009
+            output_signal: &id013 !<tag:weldx.bam.de:weldx/measurement/signal-1.0.0>
+              signal_type: digital
+              unit: V
+              data: *id010
+            error: !<tag:weldx.bam.de:weldx/measurement/error-1.0.0>
+              deviation: 0.0
+            func: !<tag:weldx.bam.de:weldx/core/mathematical_expression-1.0.0>
+              expression: a*x + b
+              parameters:
+                a: !unit/quantity-1.1.0 {unit: volt, value: 0.0030517578125}
+                b: !unit/quantity-1.1.0 {unit: volt, value: 0.0}
+            wx_metadata:
+              software: *id011
+      process:
+        shielding_gas: !<tag:weldx.bam.de:weldx/aws/process/shielding_gas_for_procedure-1.0.0>
+          use_torch_shielding_gas: true
+          torch_shielding_gas: !<tag:weldx.bam.de:weldx/aws/process/shielding_gas_type-1.0.0>
+            gas_component:
+            - !<tag:weldx.bam.de:weldx/aws/process/gas_component-1.0.0>
+              gas_chemical_name: argon
+              gas_percentage: !unit/quantity-1.1.0 {unit: percent, value: 82}
+            - !<tag:weldx.bam.de:weldx/aws/process/gas_component-1.0.0>
+              gas_chemical_name: carbon dioxide
+              gas_percentage: !unit/quantity-1.1.0 {unit: percent, value: 18}
+            common_name: SG
+          torch_shielding_gas_flowrate: !unit/quantity-1.1.0 {unit: liter / minute, value: 20}
+        weld_speed: !unit/quantity-1.1.0 {unit: millimeter / second, value: 10}
+        welding_process: !<tag:weldx.bam.de:weldx/process/CLOOS/pulse-1.0.0>
+          base_process: pulse
+          manufacturer: CLOOS
+          meta: {modulation: UI}
+          parameters:
+            base_current: !<tag:weldx.bam.de:weldx/core/time_series-1.0.0>
+              unit: ampere
+              value: 60.0
+            pulse_duration: !<tag:weldx.bam.de:weldx/core/time_series-1.0.0>
+              unit: millisecond
+              value: 5.0
+            pulse_frequency: !<tag:weldx.bam.de:weldx/core/time_series-1.0.0>
+              unit: hertz
+              value: 100.0
+            pulse_voltage: !<tag:weldx.bam.de:weldx/core/time_series-1.0.0>
+              unit: volt
+              value: 40.0
+            wire_feedrate: !<tag:weldx.bam.de:weldx/core/time_series-1.0.0>
+              unit: meter / minute
+              value: 10.0
+          power_source: Quinto
+          tag: CLOOS/pulse
+        welding_wire:
+          diameter: !unit/quantity-1.1.0 {unit: millimeter, value: 1.2}
+      reference_timestamp: !<tag:weldx.bam.de:weldx/time/timestamp-1.0.0> {value: '2020-11-09T12:00:00'}
+      welding_current: *id012
+      welding_voltage: *id013
+      workpiece:
+        base_metal: {common_name: S355J2+N, standard: 'DIN EN 10225-2:2011'}
+        geometry:
+          groove_shape: !<tag:weldx.bam.de:weldx/groove/iso_9692_1_2013_12/VGroove-1.0.0>
+            t: !unit/quantity-1.1.0 {unit: millimeter, value: 5}
+            alpha: !unit/quantity-1.1.0 {unit: degree, value: 50}
+            b: !unit/quantity-1.1.0 {unit: millimeter, value: 1}
+            c: !unit/quantity-1.1.0 {unit: millimeter, value: 1}
+            code_number: ['1.3', '1.5']
+          seam_length: !unit/quantity-1.1.0 {unit: millimeter, value: 300}
+      wx_metadata: {welder: A.W. Elder}
 ...
diff --git a/weldx/asdf/schemas/weldx.bam.de/weldx/measurement/data_transformation-1.0.0.yaml b/weldx/asdf/schemas/weldx.bam.de/weldx/measurement/data_transformation-1.0.0.yaml
index fac17e3..50910a9 100644
--- a/weldx/asdf/schemas/weldx.bam.de/weldx/measurement/data_transformation-1.0.0.yaml
+++ b/weldx/asdf/schemas/weldx.bam.de/weldx/measurement/data_transformation-1.0.0.yaml
@@ -21,8 +21,6 @@ properties:
     $ref: "tag:weldx.bam.de:weldx/measurement/error-1.0.0"
   func:
     $ref: "tag:weldx.bam.de:weldx/core/mathematical_expression-1.0.0"
-  meta:
-    type: object
 
 required: [name, input_signal, output_signal]
 propertyOrder: [name, input_signal, output_signal, error, func]
diff --git a/weldx/asdf/validators.py b/weldx/asdf/validators.py
index 85fb1fe..1b3417f 100644
--- a/weldx/asdf/validators.py
+++ b/weldx/asdf/validators.py
@@ -364,7 +364,7 @@ def _compare_lists(_list, list_expected):
 
 def _get_instance_shape(instance_dict: Union[TaggedDict, Dict[str, Any]]) -> List[int]:
     """Get the shape of an ASDF instance from its tagged dict form."""
-    if isinstance(instance_dict, (float, int)):  # test against [1] for single values
+    if isinstance(instance_dict, (float, int)):  # test against [1] for scalar values
         return [1]
     elif "shape" in instance_dict:
         return instance_dict["shape"]
@@ -374,6 +374,14 @@ def _get_instance_shape(instance_dict: Union[TaggedDict, Dict[str, Any]]) -> Lis
             return TimedeltaIndexType.shape_from_tagged(instance_dict)
         elif "weldx/time/datetimeindex" in instance_dict._tag:
             return DatetimeIndexType.shape_from_tagged(instance_dict)
+        elif "weldx/core/time_series" in instance_dict._tag:
+            if isinstance(instance_dict["value"], dict):  # ndarray
+                return _get_instance_shape(instance_dict["value"])
+            return [1]  # scalar
+        elif "asdf/unit/quantity" in instance_dict._tag:
+            if isinstance(instance_dict["value"], dict):  # ndarray
+                return _get_instance_shape(instance_dict["value"])
+            return [1]  # scalar
 
     return None
 


Test patch:
diff --git a/tests/asdf_tests/test_asdf_validators.py b/tests/asdf_tests/test_asdf_validators.py
index 1be9865..0024df2 100644
--- a/tests/asdf_tests/test_asdf_validators.py
+++ b/tests/asdf_tests/test_asdf_validators.py
@@ -4,7 +4,7 @@ import pandas as pd
 import pytest
 from asdf import ValidationError
 
-from weldx import Q_
+from weldx import Q_, TimeSeries
 from weldx.asdf.extension import WxSyntaxError
 from weldx.asdf.tags.weldx.debug.test_property_tag import PropertyTagTestClass
 from weldx.asdf.tags.weldx.debug.test_shape_validator import ShapeValidatorTestClass
@@ -200,6 +200,14 @@ def test_shape_validator(test_input):
             optional_prop=np.ones((3, 2, 9)),
         ),  # wrong optional
         ShapeValidatorTestClass(time_prop=pd.date_range("2020", freq="D", periods=3)),
+        ShapeValidatorTestClass(
+            quantity=Q_([0, 3], "s"),  # mismatch shape [1]
+        ),
+        ShapeValidatorTestClass(
+            timeseries=TimeSeries(
+                Q_([0, 3], "m"), Q_([0, 1], "s")
+            )  # mismatch shape [1]
+        ),
     ],
 )
 def test_shape_validator_exceptions(test_input):
diff --git a/weldx/asdf/schemas/weldx.bam.de/weldx/debug/test_shape_validator-1.0.0.yaml b/weldx/asdf/schemas/weldx.bam.de/weldx/debug/test_shape_validator-1.0.0.yaml
index 8690add..cf30437 100644
--- a/weldx/asdf/schemas/weldx.bam.de/weldx/debug/test_shape_validator-1.0.0.yaml
+++ b/weldx/asdf/schemas/weldx.bam.de/weldx/debug/test_shape_validator-1.0.0.yaml
@@ -28,6 +28,14 @@ properties:
     type: number
     wx_shape: [1]
 
+  quantity:
+    tag: "tag:stsci.edu:asdf/unit/quantity-1.1.0"
+    wx_shape: [1]
+
+  timeseries:
+    tag: "tag:weldx.bam.de:weldx/core/time_series-1.0.0"
+    wx_shape: [1]
+
   nested_prop:
     type: object
     properties:
@@ -49,7 +57,7 @@ properties:
 
 
 
-required: [prop1, prop2, prop3, prop4, nested_prop, time_prop]
+required: [prop1, prop2, prop3, prop4, quantity, timeseries, nested_prop, time_prop]
 propertyOrder: [prop1,prop2,prop3,prop4,nested_prop,optional_prop]
 flowStyle: block
 additionalProperties: true
diff --git a/weldx/asdf/tags/weldx/debug/test_shape_validator.py b/weldx/asdf/tags/weldx/debug/test_shape_validator.py
index dfbcffe..a9f3b1e 100644
--- a/weldx/asdf/tags/weldx/debug/test_shape_validator.py
+++ b/weldx/asdf/tags/weldx/debug/test_shape_validator.py
@@ -2,7 +2,9 @@ from dataclasses import dataclass, field
 
 import numpy as np
 import pandas as pd
+import pint
 
+from weldx import Q_, TimeSeries
 from weldx.asdf.types import WeldxType
 from weldx.asdf.validators import wx_shape_validator
 
@@ -18,6 +20,8 @@ class ShapeValidatorTestClass:
     prop3: np.ndarray = np.ones((2, 4, 6, 8, 10))
     prop4: np.ndarray = np.ones((1, 3, 5, 7, 9))
     prop5: float = 3.141
+    quantity: pint.Quantity = Q_(10, "m")
+    timeseries: TimeSeries = TimeSeries(Q_(10, "m"))
     nested_prop: dict = field(
         default_factory=lambda: {
             "p1": np.ones((10, 8, 6, 4, 2)),