pyvale 2025.5.3__cp311-cp311-win32.whl → 2025.7.1__cp311-cp311-win32.whl

pyvale/examples/basics/ex1_5_fielderrs_therm3d.py

@@ -5,8 +5,9 @@
 # ==============================================================================
 
 """
-Pyvale example: Field-based systematic errors
---------------------------------------------------------------------------------
+Basics: Field-based systematic errors
+================================================================================
+
 In this example we give an overview of field-based systematic errors. Field
 errors require additional interpolation of the underlying physical field such as
 uncertainty in a sensors position or sampling time. For this example we will
@@ -26,143 +27,146 @@ import matplotlib.pyplot as plt
 import mooseherder as mh
 import pyvale as pyv
 
+#%%
+# First we use everything we learned from the first three examples to build
+# a thermocouple sensor array for the same 3D thermal simulation we have
+# analysed in the previous examples. Then we will look at a new type of
+# systematic error called a field error which requires additional
+# interpolation of the underlying physical field to be measured.
+data_path = pyv.DataSet.thermal_3d_path()
+sim_data = mh.ExodusReader(data_path).read_all_sim_data()
+sim_data = pyv.scale_length_units(scale=1000.0,
+                                    sim_data=sim_data,
+                                    disp_comps=None)
+
+n_sens = (1,4,1)
+x_lims = (12.5,12.5)
+y_lims = (0.0,33.0)
+z_lims = (0.0,12.0)
+sens_pos = pyv.create_sensor_pos_array(n_sens,x_lims,y_lims,z_lims)
+
+sample_times = np.linspace(0.0,np.max(sim_data.time),50) # | None
+
+sensor_data = pyv.SensorData(positions=sens_pos,
+                                sample_times=sample_times)
+
+field_key: str = "temperature"
+tc_array = pyv.SensorArrayFactory \
+    .thermocouples_no_errs(sim_data,
+                            sensor_data,
+                            elem_dims=3,
+                            field_name=field_key)
+#%%
+# Now we will create a field error data class which we will use to build our
+# field error. This controls which sensor parameters will be perturbed such
+# as: position, time and orientation. Here we will perturb the sensor
+# positions on the face of the block using a normal distribution and we will
+# also perturb the measurement times.
+#
+# We can apply a constant offset to each sensors position in x,y,z by
+# providing a shape=(num_sensors,coord[x,y,z]) array. Here we apply a
+# constant offset in the y and z direction for all sensors.
+pos_offset_xyz = np.array((0.0,1.0,1.0),dtype=np.float64)
+pos_offset_xyz = np.tile(pos_offset_xyz,(sens_pos.shape[0],1))
+
+#%%
+# We can also apply a constant offset to the sampling times for all sensors
+time_offset = np.full((sample_times.shape[0],),0.1)
+
+#%%
+# Using the `Gen*` random generators in pyvale we can randomly perturb the
+# position or sampling times of our virtual sensors.
+pos_rand = pyv.GenNormal(std=1.0) # units = mm
+time_rand = pyv.GenNormal(std=0.1) # units = s
+
+#%%
+# Now we put everything into our field error data class ready to build our
+# field error object. Have a look at the other parameters in this data class
+# to geta feel for the other types of supported field errors. We will look
+# at the orientation and area averaging errors when we look at vector and
+# tensor fields in later examples.
+field_err_data = pyv.ErrFieldData(
+    pos_offset_xyz=pos_offset_xyz,
+    time_offset=time_offset,
+    pos_rand_xyz=(None,pos_rand,pos_rand),
+    time_rand=time_rand
+)
+
+#%%
+# Adding our field error to our error chain is exactly the same as the basic
+# errors we have seen previously. We can also combine field errors with
+# basic errors and place them anywhere in our error chain. We can even chain
+# field errors together which we will look at in the next example. For now
+# we will just have a single field error so we can easily visualise what
+# this type of error does.
+err_chain = []
+
+#%%
+# A field error needs to know which field it should interpolate for error
+# calculations so we provide the field from the sensor array as well as the
+# field error error data class.
+err_chain.append(pyv.ErrSysField(tc_array.get_field(),
+                                    field_err_data))
+err_int = pyv.ErrIntegrator(err_chain,
+                            sensor_data,
+                            tc_array.get_measurement_shape())
+tc_array.set_error_integrator(err_int)
+
+#%%
+# Now we can run the sensor simulation and display the results to see what
+# our field error has done.
+measurements = tc_array.calc_measurements()
+
+print(80*"-")
+
+sens_print = 0
+comp_print = 0
+time_last = 5
+time_print = slice(measurements.shape[2]-time_last,measurements.shape[2])
+
+
+print(f"These are the last {time_last} virtual measurements of sensor "
+        + f"{sens_print}:")
+
+pyv.print_measurements(tc_array,sens_print,comp_print,time_print)
+
+print(80*"-")
+
+#%%
+# We are going to save some figures to disk as well as displaying them
+# interactively so we create a directory for this:
+output_path = Path.cwd() / "pyvale-output"
+if not output_path.is_dir():
+    output_path.mkdir(parents=True, exist_ok=True)
+
+#%%
+# If we analyse the time traces we can see offsets in the sensor value and
+# the sampling times which we expect from our field error setup.
+(fig,ax) = pyv.plot_time_traces(tc_array,field_key)
+
+save_traces = output_path/"field_ex1_5_sensortraces.png"
+fig.savefig(save_traces, dpi=300, bbox_inches="tight")
+fig.savefig(save_traces.with_suffix(".svg"), dpi=300, bbox_inches="tight")
+
+plt.show()
+
+#%%
+# It is also possible to view the perturbed sensor locations on the
+# simulation mesh if we create a plot after running the sensor simulation.
+pv_plot = pyv.plot_point_sensors_on_sim(tc_array,field_key)
+pv_plot.camera_position = [(59.354, 43.428, 69.946),
+                            (-2.858, 13.189, 4.523),
+                            (-0.215, 0.948, -0.233)]
+
+save_render = output_path / "fielderrs_ex1_5_sensorlocs.svg"
+pv_plot.save_graphic(save_render) # only for .svg .eps .ps .pdf .tex
+pv_plot.screenshot(save_render.with_suffix(".png"))
+
+pv_plot.show()
+
+#%%
+# We have saved an image of the sensor traces and the perturbed locations of
+# the sensors to the `pyvale-output` directory in your current working
+# directory. Analyse these figures side by side to show that the location of
+# the perturbed sensor locations matches the expected sensor traces.
 
-def main() -> None:
-    # First we use everything we learned from the first three examples to build
-    # a thermocouple sensor array for the same 3D thermal simulation we have
-    # analysed in the previous examples. Then we will look at a new type of
-    # systematic error called a field error which requires additional
-    # interpolation of the underlying physical field to be measured.
-    data_path = pyv.DataSet.thermal_3d_path()
-    sim_data = mh.ExodusReader(data_path).read_all_sim_data()
-    sim_data = pyv.scale_length_units(scale=1000.0,
-                                      sim_data=sim_data,
-                                      disp_comps=None)
-
-    n_sens = (1,4,1)
-    x_lims = (12.5,12.5)
-    y_lims = (0.0,33.0)
-    z_lims = (0.0,12.0)
-    sens_pos = pyv.create_sensor_pos_array(n_sens,x_lims,y_lims,z_lims)
-
-    sample_times = np.linspace(0.0,np.max(sim_data.time),50) # | None
-
-    sensor_data = pyv.SensorData(positions=sens_pos,
-                                 sample_times=sample_times)
-
-    field_key: str = "temperature"
-    tc_array = pyv.SensorArrayFactory \
-        .thermocouples_no_errs(sim_data,
-                               sensor_data,
-                               elem_dims=3,
-                               field_name=field_key)
-
-    # Now we will create a field error data class which we will use to build our
-    # field error. This controls which sensor parameters will be perturbed such
-    # as: position, time and orientation. Here we will perturb the sensor
-    # positions on the face of the block using a normal distribution and we will
-    # also perturb the measurement times.
-
-    # We can apply a constant offset to each sensors position in x,y,z by
-    # providing a shape=(num_sensors,coord[x,y,z]) array. Here we apply a
-    # constant offset in the y and z direction for all sensors.
-    pos_offset_xyz = np.array((0.0,1.0,1.0),dtype=np.float64)
-    pos_offset_xyz = np.tile(pos_offset_xyz,(sens_pos.shape[0],1))
-
-    # We can also apply a constant offset to the sampling times for all sensors
-    time_offset = np.full((sample_times.shape[0],),0.1)
-
-    # Using the `Gen*` random generators in pyvale we can randomly perturb the
-    # position or sampling times of our virtual sensors.
-    pos_rand = pyv.GenNormal(std=1.0) # units = mm
-    time_rand = pyv.GenNormal(std=0.1) # units = s
-
-    # Now we put everything into our field error data class ready to build our
-    # field error object. Have a look at the other parameters in this data class
-    # to geta feel for the other types of supported field errors. We will look
-    # at the orientation and area averaging errors when we look at vector and
-    # tensor fields in later examples.
-    field_err_data = pyv.ErrFieldData(
-        pos_offset_xyz=pos_offset_xyz,
-        time_offset=time_offset,
-        pos_rand_xyz=(None,pos_rand,pos_rand),
-        time_rand=time_rand
-    )
-
-    # Adding our field error to our error chain is exactly the same as the basic
-    # errors we have seen previously. We can also combine field errors with
-    # basic errors and place them anywhere in our error chain. We can even chain
-    # field errors together which we will look at in the next example. For now
-    # we will just have a single field error so we can easily visualise what
-    # this type of error does.
-    err_chain = []
-
-    # A field error needs to know which field it should interpolate for error
-    # calculations so we provide the field from the sensor array as well as the
-    # field error error data class.
-    err_chain.append(pyv.ErrSysField(tc_array.get_field(),
-                                     field_err_data))
-    err_int = pyv.ErrIntegrator(err_chain,
-                                sensor_data,
-                                tc_array.get_measurement_shape())
-    tc_array.set_error_integrator(err_int)
-
-
-    # Now we can run the sensor simulation and display the results to see what
-    # our field error has done.
-    measurements = tc_array.calc_measurements()
-
-    print(80*"-")
-
-    sens_print: int = 0
-    time_print: int = 5
-    comp_print: int = 0
-
-    print(f"These are the last {time_print} virtual measurements of sensor "
-          + f"{sens_print}:")
-
-    pyv.print_measurements(sens_array=tc_array,
-                           sensors=(sens_print,sens_print+1),
-                           components=(comp_print,comp_print+1),
-                           time_steps=(measurements.shape[2]-time_print,
-                                       measurements.shape[2]))
-    print(80*"-")
-
-    # We are going to save some figures to disk as well as displaying them
-    # interactively so we create a directory for this:
-    output_path = Path.cwd() / "pyvale-output"
-    if not output_path.is_dir():
-        output_path.mkdir(parents=True, exist_ok=True)
-
-
-    # If we analyse the time traces we can see offsets in the sensor value and
-    # the sampling times which we expect from our field error setup.
-    (fig,ax) = pyv.plot_time_traces(tc_array,field_key)
-
-    save_traces = output_path/"field_ex1_5_sensortraces.png"
-    fig.savefig(save_traces, dpi=300, bbox_inches="tight")
-    fig.savefig(save_traces.with_suffix(".svg"), dpi=300, bbox_inches="tight")
-
-    plt.show()
-
-    # It is also possible to view the perturbed sensor locations on the
-    # simulation mesh if we create a plot after running the sensor simulation.
-    pv_plot = pyv.plot_point_sensors_on_sim(tc_array,field_key)
-    pv_plot.camera_position = [(59.354, 43.428, 69.946),
-                               (-2.858, 13.189, 4.523),
-                               (-0.215, 0.948, -0.233)]
-
-    save_render = output_path / "fielderrs_ex1_5_sensorlocs.svg"
-    pv_plot.save_graphic(save_render) # only for .svg .eps .ps .pdf .tex
-    pv_plot.screenshot(save_render.with_suffix(".png"))
-
-    pv_plot.show()
-
-    # We have saved an image of the sensor traces and the perturbed locations of
-    # the sensors to the `pyvale-output` directory in your current working
-    # directory. Analyse these figures side by side to show that the location of
-    # the perturbed sensor locations matches the expected sensor traces.
-
-
-if __name__ == '__main__':
-    main()

pyvale/examples/basics/ex1_6_caliberrs_therm2d.py

@@ -5,9 +5,10 @@
 # ==============================================================================
 
 """
-Pyvale example: Sensor calibration systematic errors
---------------------------------------------------------------------------------
-In this example we show how pyvale can simulate sensor calibration errors with
+Basics: Sensor calibration systematic errors
+================================================================================
+
+In this example we show how `pyvale` can simulate sensor calibration errors with
 user defined calibration functions.
 
 Test case: Scalar field point sensors (thermocouples) on a 2D thermal simulation
@@ -18,6 +19,7 @@ import matplotlib.pyplot as plt
 import mooseherder as mh
 import pyvale as pyv
 
+#%%
 # First we need to define some calibration functions. These functions must take
 # a numpy array and return a numpy array of the same shape. We start by
 # defining what we think our calibration is called `assumed_calib()` and then
@@ -33,101 +35,94 @@ def truth_calib(signal: np.ndarray) -> np.ndarray:
     return -0.01897 + 25.41881*signal - 0.42456*signal**2 + 0.04365*signal**3
 
 
-def main() -> None:
-
-    # We are first going to do a quick analytical calculation for the minimum
-    # and maximum systematic error we expect between our assumed and true
-    # calibration. For our true calibration we know this holds between 0 and 6mV
-    # so we perform the calculation over this range and print the min/max
-    # expected error over this range.
-    n_cal_divs = 10000
-    signal_calib_range = np.array((0.0,6.0),dtype=np.float64)
-    milli_volts = np.linspace(signal_calib_range[0],
-                              signal_calib_range[1],
-                              n_cal_divs)
-    temp_truth = truth_calib(milli_volts)
-    temp_assumed = assumed_calib(milli_volts)
-    calib_error = temp_assumed - temp_truth
-
-    print()
-    print(80*"-")
-    print(f"Max calibrated temperature: {np.min(temp_truth)} degC")
-    print(f"Min calibrated temperature: {np.max(temp_truth)} degC")
-    print()
-    print(f"Calibration error over signal:"
-          + f" {signal_calib_range[0]} to {signal_calib_range[1]} mV")
-    print(f"Max calib error: {np.max(calib_error)}")
-    print(f"Min calib error: {np.min(calib_error)}")
-    print(80*"-")
-    print()
-
-
-    # Now let's go back and build the 2D thermal plate with simulated
-    # thermocouples that we analysed in the first two examples. We use this
-    # simulation as the temperatures are within our calibrated range.
-    data_path = pyv.DataSet.thermal_2d_path()
-    sim_data = mh.ExodusReader(data_path).read_all_sim_data()
-    sim_data = pyv.scale_length_units(scale=1000.0,
-                                      sim_data=sim_data,
-                                      disp_comps=None)
-
-    n_sens = (4,1,1)
-    x_lims = (0.0,100.0)
-    y_lims = (0.0,50.0)
-    z_lims = (0.0,0.0)
-    sens_pos = pyv.create_sensor_pos_array(n_sens,x_lims,y_lims,z_lims)
-
-    sample_times = np.linspace(0.0,np.max(sim_data.time),50) # | None
-
-    sensor_data = pyv.SensorData(positions=sens_pos,
-                                 sample_times=sample_times)
-
-    field_key: str = "temperature"
-    tc_array = pyv.SensorArrayFactory \
-        .thermocouples_no_errs(sim_data,
-                               sensor_data,
-                               elem_dims=2,
-                               field_name=field_key)
-
-
-    # With our assumed and true calibration functions we can build our
-    # calibration error object and add it to our error chain as normal. Note
-    # that the truth calibration function must be inverted numerically so to
-    # increase accuracy the number of divisions can be increased. However, 1e4
-    # divisions should be suitable for most applications.
-    cal_err = pyv.ErrSysCalibration(assumed_calib,
-                                    truth_calib,
-                                    signal_calib_range,
-                                    n_cal_divs=10000)
-    sys_err_int = pyv.ErrIntegrator([cal_err],
-                                     sensor_data,
-                                     tc_array.get_measurement_shape())
-    tc_array.set_error_integrator(sys_err_int)
-
-    # Now we run our sensor simulation to see what our calibration does.
-    measurements = tc_array.calc_measurements()
-
-    print(80*"-")
-
-    sens_print: int = 0
-    time_print: int = 5
-    comp_print: int = 0
-
-    print(f"These are the last {time_print} virtual measurements of sensor "
-          + f"{sens_print}:")
-
-    pyv.print_measurements(sens_array=tc_array,
-                           sensors=(sens_print,sens_print+1),
-                           components=(comp_print,comp_print+1),
-                           time_steps=(measurements.shape[2]-time_print,
-                                       measurements.shape[2]))
-    print(80*"-")
-
-    pyv.plot_time_traces(tc_array,field_key)
-    plt.show()
-
-
-
-
-if __name__ == "__main__":
-    main()
+#%%
+# We are first going to do a quick analytical calculation for the minimum
+# and maximum systematic error we expect between our assumed and true
+# calibration. For our true calibration we know this holds between 0 and 6mV
+# so we perform the calculation over this range and print the min/max
+# expected error over this range.
+n_cal_divs = 10000
+signal_calib_range = np.array((0.0,6.0),dtype=np.float64)
+milli_volts = np.linspace(signal_calib_range[0],
+                            signal_calib_range[1],
+                            n_cal_divs)
+temp_truth = truth_calib(milli_volts)
+temp_assumed = assumed_calib(milli_volts)
+calib_error = temp_assumed - temp_truth
+
+print()
+print(80*"-")
+print(f"Max calibrated temperature: {np.min(temp_truth)} degC")
+print(f"Min calibrated temperature: {np.max(temp_truth)} degC")
+print()
+print(f"Calibration error over signal:"
+        + f" {signal_calib_range[0]} to {signal_calib_range[1]} mV")
+print(f"Max calib error: {np.max(calib_error)}")
+print(f"Min calib error: {np.min(calib_error)}")
+print(80*"-")
+print()
+
+#%%
+# Now let's go back and build the 2D thermal plate with simulated
+# thermocouples that we analysed in the first two examples. We use this
+# simulation as the temperatures are within our calibrated range.
+data_path = pyv.DataSet.thermal_2d_path()
+sim_data = mh.ExodusReader(data_path).read_all_sim_data()
+sim_data = pyv.scale_length_units(scale=1000.0,
+                                    sim_data=sim_data,
+                                    disp_comps=None)
+
+n_sens = (4,1,1)
+x_lims = (0.0,100.0)
+y_lims = (0.0,50.0)
+z_lims = (0.0,0.0)
+sens_pos = pyv.create_sensor_pos_array(n_sens,x_lims,y_lims,z_lims)
+
+sample_times = np.linspace(0.0,np.max(sim_data.time),50) # | None
+
+sensor_data = pyv.SensorData(positions=sens_pos,
+                                sample_times=sample_times)
+
+field_key: str = "temperature"
+tc_array = pyv.SensorArrayFactory \
+    .thermocouples_no_errs(sim_data,
+                            sensor_data,
+                            elem_dims=2,
+                            field_name=field_key)
+
+#%%
+# With our assumed and true calibration functions we can build our
+# calibration error object and add it to our error chain as normal. Note
+# that the truth calibration function must be inverted numerically so to
+# increase accuracy the number of divisions can be increased. However, 1e4
+# divisions should be suitable for most applications.
+cal_err = pyv.ErrSysCalibration(assumed_calib,
+                                truth_calib,
+                                signal_calib_range,
+                                n_cal_divs=10000)
+sys_err_int = pyv.ErrIntegrator([cal_err],
+                                    sensor_data,
+                                    tc_array.get_measurement_shape())
+tc_array.set_error_integrator(sys_err_int)
+
+#%%
+# Now we run our sensor simulation to see what our calibration does.
+measurements = tc_array.calc_measurements()
+
+print(80*"-")
+
+sens_print = 0
+comp_print = 0
+time_last = 5
+time_print = slice(measurements.shape[2]-time_last,measurements.shape[2])
+
+print(f"These are the last {time_last} virtual measurements of sensor "
+        + f"{sens_print}:")
+
+pyv.print_measurements(tc_array,sens_print,comp_print,time_print)
+
+print(80*"-")
+
+pyv.plot_time_traces(tc_array,field_key)
+plt.show()
+