pyvale 2025.7.1__cp311-cp311-win_amd64.whl → 2025.8.1__cp311-cp311-win_amd64.whl

pyvale/verif/psensmech.py

@@ -0,0 +1,227 @@
+#===============================================================================
+# pyvale: the python validation engine
+# License: MIT
+# Copyright (C) 2025 The Computer Aided Validation Team
+#===============================================================================
+import numpy as np
+import pyvale.mooseherder as mh
+import pyvale.sensorsim as sens
+import pyvale.verif.psens as psens
+import pyvale.verif.psensconst as psensconst
+import pyvale.dataset as dataset
+
+"""
+DEVELOPER VERIFICATION MODULE
+--------------------------------------------------------------------------------
+This module contains developer utility functions used for verification testing
+of the point sensor simulation toolbox in pyvale.
+
+Specifically, this module contains functions used for testing point sensors
+applied to mechanical fields (displacement/strain) for testing vector and tensor
+field point sensors.
+"""
+
+def simdata_mech_2d() -> mh.SimData:
+    data_path = dataset.mechanical_2d_path()
+    sim_data = mh.ExodusReader(data_path).read_all_sim_data()
+    sim_data = sens.scale_length_units(scale=1000.0,
+                                      sim_data=sim_data,
+                                      disp_comps=("disp_x","disp_y"))
+    return sim_data
+
+
+def simdata_mech_3d() -> mh.SimData:
+    data_path = dataset.element_case_output_path(dataset.EElemTest.HEX20)
+    sim_data = mh.ExodusReader(data_path).read_all_sim_data()
+    field_comps = ("disp_x","disp_y","disp_z")
+    sim_data = sens.scale_length_units(scale=1000.0,
+                                        sim_data=sim_data,
+                                        disp_comps=field_comps)
+    return sim_data
+
+def sens_pos_2d() -> dict[str,np.ndarray]:
+    sim_dims = sens.SimTools.get_sim_dims(simdata_mech_2d())
+    sens_pos = {}
+
+    x_lims = sim_dims["x"]
+    y_lims = sim_dims["y"]
+    z_lims = (0,0)
+
+    n_sens = (1,4,1)
+    sens_pos["line-4"] = sens.create_sensor_pos_array(n_sens,x_lims,y_lims,z_lims)
+
+    n_sens = (2,3,1)
+    sens_pos["grid-23"] = sens.create_sensor_pos_array(n_sens,x_lims,y_lims,z_lims)
+
+    return sens_pos
+
+
+def sens_pos_3d() -> dict[str,np.ndarray]:
+    sens_pos = {}
+    sens_pos["cent-cube"] = np.array(((5.0,0.0,5.0),    # xz
+                                      (5.0,10.0,5.0),   # xz
+                                      (5.0,5.0,0.0),    # xy
+                                      (5.0,5.0,10.0),   # xy
+                                      (0.0,5.0,5.0),    # yz
+                                      (10.0,5.0,5.0),)) # yz
+    return sens_pos
+
+def sens_pos_2d_lock(sens_pos: np.ndarray) -> dict[str,np.ndarray]:
+    pos_lock = {}
+    (xx,yy,zz) = (0,1,2)
+
+    lock = np.full_like(sens_pos,False,dtype=bool)
+    lock[:,zz] = True # lock z
+    pos_lock["line-4"] = None
+
+    lock = np.full_like(sens_pos,False,dtype=bool)
+    lock[:,zz] = True # lock z
+    pos_lock["grid-23"] = None
+
+    return pos_lock
+
+
+def sens_pos_3d_lock(sens_pos: np.ndarray) -> dict[str,np.ndarray]:
+    pos_lock = {}
+    (xx,yy,zz) = (0,1,2)
+
+    lock = np.full_like(sens_pos,False,dtype=bool)
+    lock[0,yy] = True
+    lock[1,yy] = True
+    lock[2,zz] = True
+    lock[3,zz] = True
+    lock[4,xx] = True
+    lock[5,xx] = True
+    pos_lock["cent-cube"] = lock
+
+    return pos_lock
+
+
+def sens_data_2d_dict() -> dict[str,sens.SensorData]:
+    return psens.sens_data_dict(simdata_mech_2d(),sens_pos_2d())
+
+
+def sens_data_3d_dict() -> dict[str,sens.SensorData]:
+    return psens.sens_data_dict(simdata_mech_3d(),sens_pos_3d())
+
+
+def err_chain_field(field: sens.IField,
+                    sens_pos: np.ndarray,
+                    samp_times: np.ndarray | None,
+                    pos_lock: np.ndarray | None,
+                    ) -> list[sens.IErrCalculator]:
+
+    if samp_times is None:
+        samp_times = field.get_time_steps()
+
+    pos_offset_xyz = np.array((1.0,1.0,-1.0),dtype=np.float64)
+    pos_offset_xyz = np.tile(pos_offset_xyz,(sens_pos.shape[0],1))
+
+    time_offset = np.full((samp_times.shape[0],),0.1)
+
+    pos_rand = sens.GenNormal(std=1.0,
+                             mean=0.0,
+                             seed=psensconst.GOLD_SEED) # units = mm
+    time_rand = sens.GenNormal(std=0.1,
+                              mean=0.0,
+                              seed=psensconst.GOLD_SEED) # units = s
+    ang_rand = sens.GenUniform(low=-1.0,
+                              high=1.0,
+                              seed=psensconst.GOLD_SEED)
+
+    field_err_data = sens.ErrFieldData(
+        pos_offset_xyz=pos_offset_xyz,
+        time_offset=time_offset,
+        pos_rand_xyz=(pos_rand,pos_rand,pos_rand),
+        ang_rand_zyx=(ang_rand,ang_rand,ang_rand),
+        time_rand=time_rand,
+        pos_lock_xyz=pos_lock,
+    )
+
+    err_chain = []
+    err_chain.append(sens.ErrSysField(field,
+                                     field_err_data))
+    return err_chain
+
+
+def err_chain_field_dep(field: sens.IField,
+                        sens_pos: np.ndarray,
+                        samp_times: np.ndarray | None,
+                        pos_lock: np.ndarray | None,
+                        ) -> list[sens.IErrCalculator]:
+
+    if samp_times is None:
+        samp_times = field.get_time_steps()
+
+    time_offset = 2.0*np.ones_like(samp_times)
+    time_error_data = sens.ErrFieldData(time_offset=time_offset)
+
+    pos_offset = -1.0*np.ones_like(sens_pos)
+    pos_error_data = sens.ErrFieldData(pos_offset_xyz=pos_offset,
+                                      pos_lock_xyz=pos_lock)
+
+    angle_offset = np.ones_like(sens_pos)
+    angle_error_data = sens.ErrFieldData(ang_offset_zyx=angle_offset)
+
+    err_chain = []
+    err_chain.append(sens.ErrSysField(field,
+                                    time_error_data,
+                                    sens.EErrDep.DEPENDENT))
+    err_chain.append(sens.ErrSysField(field,
+                                    time_error_data,
+                                    sens.EErrDep.DEPENDENT))
+    err_chain.append(sens.ErrSysField(field,
+                                    pos_error_data,
+                                    sens.EErrDep.DEPENDENT))
+    err_chain.append(sens.ErrSysField(field,
+                                    pos_error_data,
+                                    sens.EErrDep.DEPENDENT))
+    err_chain.append(sens.ErrSysField(field,
+                                    angle_error_data,
+                                    sens.EErrDep.DEPENDENT))
+    err_chain.append(sens.ErrSysField(field,
+                                    angle_error_data,
+                                    sens.EErrDep.DEPENDENT))
+    return err_chain
+
+
+def err_chain_2d_dict(field: sens.IField,
+                      sens_pos: np.ndarray,
+                      samp_times: np.ndarray | None,
+                      pos_lock: np.ndarray | None
+                      ) -> dict[str,list[sens.IErrCalculator]]:
+    err_cases = {}
+    err_cases["none"] = None
+    err_cases["basic"] = psens.err_chain_basic()
+    err_cases["basic-gen"] = psens.err_chain_gen()
+    err_cases["field"] = err_chain_field(field,sens_pos,samp_times,pos_lock)
+    err_cases["field-dep"] = err_chain_field_dep(field,sens_pos,samp_times,pos_lock)
+
+    # This has to be last so when we chain all errors together the saturation
+    # error is the last thing that happens
+    err_cases["basic-dep"] = psens.err_chain_dep()
+
+    err_cases["all"] = psens.err_chain_all(err_cases)
+
+    return err_cases
+
+
+def err_chain_3d_dict(field: sens.IField,
+                      sens_pos: np.ndarray,
+                      samp_times: np.ndarray | None,
+                      pos_lock: np.ndarray | None
+                      ) -> dict[str,list[sens.IErrCalculator]]:
+    err_cases = {}
+    err_cases["none"] = None
+    err_cases["basic"] = psens.err_chain_basic()
+    err_cases["basic-gen"] = psens.err_chain_gen()
+    err_cases["field"] = err_chain_field(field,sens_pos,samp_times,pos_lock)
+    err_cases["field-dep"] = err_chain_field_dep(field,sens_pos,samp_times,pos_lock)
+
+    # This has to be last so when we chain all errors together the saturation
+    # error is the last thing that happens
+    err_cases["basic-dep"] = psens.err_chain_dep()
+
+    err_cases["all"] = psens.err_chain_all(err_cases)
+
+    return err_cases

pyvale/verif/psensmultiphys.py

@@ -0,0 +1,187 @@
+#===============================================================================
+# pyvale: the python validation engine
+# License: MIT
+# Copyright (C) 2025 The Computer Aided Validation Team
+#===============================================================================
+from pathlib import Path
+import copy
+import numpy as np
+import pyvale.mooseherder as mh
+import pyvale.sensorsim as sens
+import pyvale.verif.psens as psens
+import pyvale.verif.psensscalar as psensscalar
+import pyvale.verif.psensvector as psensvector
+import pyvale.verif.psenstensor as psenstensor
+import pyvale.verif.psensmech as psensmech
+import pyvale.dataset as dataset
+
+
+def load_simdata_list(data_paths: list[Path],
+                      disp_comps: tuple[str,...]) -> list[mh.SimData]:
+    sim_list = []
+    for pp in data_paths:
+        sim_data = mh.ExodusReader(pp).read_all_sim_data()
+        sim_data = sens.scale_length_units(scale=1000.0,
+                                            sim_data=sim_data,
+                                            disp_comps=disp_comps)
+        sim_list.append(sim_data)
+
+    return sim_list
+
+
+def simdata_list_2d() -> list[mh.SimData]:
+    data_paths = dataset.thermomechanical_2d_experiment_paths()
+    disp_comps = ("disp_x","disp_y")
+    return load_simdata_list(data_paths,disp_comps)
+
+
+def simdata_list_3d() -> list[mh.SimData]:
+    data_paths = [dataset.element_case_output_path(dataset.EElemTest.TET4),
+                  dataset.element_case_output_path(dataset.EElemTest.TET10),
+                  dataset.element_case_output_path(dataset.EElemTest.HEX8),
+                  dataset.element_case_output_path(dataset.EElemTest.HEX20)]
+    disp_comps = ("disp_x","disp_y","disp_z")
+    return load_simdata_list(data_paths,disp_comps)
+
+
+def sens_pos_2d() -> dict[str,np.ndarray]:
+    # Geometry does not change
+    sim_dims = sens.SimTools.get_sim_dims(simdata_list_2d()[0])
+    sens_pos = {}
+
+    x_lims = sim_dims["x"]
+    y_lims = sim_dims["y"]
+    z_lims = (0,0)
+
+    n_sens = (2,2,1)
+    sens_pos["grid-22"] = sens.create_sensor_pos_array(n_sens,x_lims,y_lims,z_lims)
+
+    return sens_pos
+
+def sens_pos_2d_lock(sens_pos: np.ndarray) -> dict[str,np.ndarray]:
+    pos_lock = {}
+    (xx,yy,zz) = (0,1,2)
+
+    lock = np.full_like(sens_pos,False,dtype=bool)
+    lock[:,zz] = True # lock z
+    pos_lock["grid-22"] = None
+
+    return pos_lock
+
+
+def sens_pos_3d_lock(sens_pos: np.ndarray) -> dict[str,np.ndarray]:
+    pos_lock = {}
+    (xx,yy,zz) = (0,1,2)
+
+    lock = np.full_like(sens_pos,False,dtype=bool)
+    lock[0,yy] = True
+    lock[1,yy] = True
+    lock[2,zz] = True
+    lock[3,zz] = True
+    lock[4,xx] = True
+    lock[5,xx] = True
+    pos_lock["cent-cube"] = lock
+
+    return pos_lock
+
+
+def sens_pos_3d() -> dict[str,np.ndarray]:
+    sens_pos = {}
+    sens_pos["cent-cube"] = np.array(((5.0,0.0,5.0),    # xz
+                                      (5.0,10.0,5.0),   # xz
+                                      (5.0,5.0,0.0),    # xy
+                                      (5.0,5.0,10.0),   # xy
+                                      (0.0,5.0,5.0),    # yz
+                                      (10.0,5.0,5.0),)) # yz
+    return sens_pos
+
+def sens_data_2d_dict() -> dict[str,sens.SensorData]:
+    # Time steps don't change so can take first sim here
+    return psens.sens_data_dict(simdata_list_2d()[0],sens_pos_2d())
+
+def sens_data_3d_dict() -> dict[str,sens.SensorData]:
+    # Time steps don't change so can take first sim here
+    return psens.sens_data_dict(simdata_list_3d()[0],sens_pos_3d())
+
+def exp_sim_2d() -> dict[str,sens.ExperimentSimulator]:
+    sens_data_dict = sens_data_2d_dict()
+    sim_list = simdata_list_2d()
+
+    fields = ("scal","vect","tens")
+    exp_sims = {}
+    for ss in sens_data_dict:
+
+        sens_noerrs = {}
+        sens_noerrs["scal"] = psensscalar.sens_noerrs(sim_list[0],
+                                                      sens_data_dict[ss],
+                                                      elem_dims=2)
+        sens_noerrs["vect"] = psensvector.sens_2d_noerrs(sim_list[0],
+                                                         sens_data_dict[ss])
+        sens_noerrs["tens"] = psenstensor.sens_2d_noerrs(sim_list[0],
+                                                         sens_data_dict[ss])
+
+        pos_lock = sens_pos_2d_lock(sens_data_dict[ss].positions)
+        for kk in pos_lock:
+            if kk in ss:
+                pos_lock_key = kk
+                break
+
+        err_chain_dict={}
+        err_chain_dict["scal"] = psensscalar.err_chain_2d_dict(
+            sens_noerrs["scal"].get_field(),
+            sens_data_dict[ss].positions,
+            sens_data_dict[ss].sample_times,
+            pos_lock[pos_lock_key]
+        )
+
+        err_chain_dict["vect"] = psensmech.err_chain_2d_dict(
+            sens_noerrs["vect"].get_field(),
+            sens_data_dict[ss].positions,
+            sens_data_dict[ss].sample_times,
+            pos_lock[pos_lock_key]
+        )
+
+        err_chain_dict["tens"] = psensmech.err_chain_2d_dict(
+            sens_noerrs["tens"].get_field(),
+            sens_data_dict[ss].positions,
+            sens_data_dict[ss].sample_times,
+            pos_lock[pos_lock_key]
+        )
+
+        common_keys = (err_chain_dict["scal"].keys() &
+                       err_chain_dict["vect"].keys() &
+                       err_chain_dict["tens"].keys())
+        # print(80*"=")
+        # print(common_keys)
+        # print(80*"=")
+
+        for ee in common_keys:
+            tag = f"exp2d_{ss}_err-{ee}"
+
+            sensor_arrays = []
+            for ff in fields:
+                this_sens = copy.deepcopy(sens_noerrs[ff])
+                # print(80*"-")
+                # print(f"{ff=}")
+                # print(f"{ee=}")
+                # print(80*"-")
+                if err_chain_dict[ff][ee] is not None:
+                    err_int_opts = sens.ErrIntOpts
+                    err_int = sens.ErrIntegrator(err_chain_dict[ff][ee],
+                                                sens_data_dict[ss],
+                                                this_sens.get_measurement_shape(),
+                                                err_int_opts=err_int_opts)
+                    this_sens.set_error_integrator(err_int)
+
+                sensor_arrays.append(this_sens)
+
+            sim_list = simdata_list_2d()
+            sensor_arrays = [sens_noerrs["scal"],sens_noerrs["vect"],sens_noerrs["tens"]]
+            exp_sim = sens.ExperimentSimulator(sim_list,
+                                             sensor_arrays,
+                                             num_exp_per_sim=10)
+            exp_sims[tag] = exp_sim
+
+    return exp_sims
+
+