pyvale 2025.5.3__cp311-cp311-macosx_13_0_x86_64.whl

pyvale/examples/renderrasterisation/ex_rastercyth_static_pypara.py

@@ -0,0 +1,190 @@
+# ==============================================================================
+# pyvale: the python validation engine
+# License: MIT
+# Copyright (C) 2025 The Computer Aided Validation Team
+# ==============================================================================
+
+
+
+import time
+import numpy as np
+from scipy.spatial.transform import Rotation
+import matplotlib.pyplot as plt
+import mooseherder as mh
+import pyvale as pyv
+
+
+def main() -> None:
+    print()
+    print(80*"=")
+    print("RASTER CYTHON FILE (should be *.so on Linux):")
+    print(pyv.rastercyth.__file__)
+    print(80*"=")
+    print()
+
+    # This a path to an exodus *.e output file from MOOSE, this can be
+    # replaced with a path to your own simulation file
+    sim_path = pyv.DataSet.render_mechanical_3d_path()
+    #sim_path = pyv.DataSet.render_simple_block_path()
+    #sim_path = Path.home()/"pyvale"/"src"/"pyvale"/"simcases"/"case26_out.e"
+    sim_data = mh.ExodusReader(sim_path).read_all_sim_data()
+
+    disp_comps = ("disp_x","disp_y","disp_z")
+
+    # Scale m -> mm
+    sim_data = pyv.scale_length_units(sim_data,disp_comps,1000.0)
+
+    print()
+    print(f"{np.max(np.abs(sim_data.node_vars['disp_x']))=}")
+    print(f"{np.max(np.abs(sim_data.node_vars['disp_y']))=}")
+    print(f"{np.max(np.abs(sim_data.node_vars['disp_z']))=}")
+    print()
+
+    # Extracts the surface mesh from a full 3d simulation for rendering
+    render_mesh = pyv.create_render_mesh(sim_data,
+                                        ("disp_y","disp_x"),
+                                        sim_spat_dim=3,
+                                        field_disp_keys=disp_comps)
+
+    print()
+    print(80*"-")
+    print("MESH DATA:")
+    print(80*"-")
+    print("connectivity.shape=(num_elems,num_nodes_per_elem)")
+    print(f"{render_mesh.connectivity.shape=}")
+    print()
+    print("coords.shape=(num_nodes,coord[x,y,z])")
+    print(f"{render_mesh.coords.shape=}")
+    print()
+    print("fields.shape=(num_coords,num_time_steps,num_components)")
+    print(f"{render_mesh.fields_render.shape=}")
+    if render_mesh.fields_disp is not None:
+        print(f"{render_mesh.fields_disp.shape=}")
+    print(80*"-")
+    print()
+
+    pixel_num = np.array((960,1280),dtype=np.int32)
+    pixel_size = np.array((5.3e-3,5.3e-3),dtype=np.float64)
+    focal_leng: float = 50.0
+    cam_rot = Rotation.from_euler("zyx",(0.0,-30.0,-10.0),degrees=True)
+    fov_scale_factor: float = 1.1
+
+    (roi_pos_world,
+     cam_pos_world) = pyv.CameraTools.pos_fill_frame_from_rotation(
+         coords_world=render_mesh.coords,
+         pixel_num=pixel_num,
+         pixel_size=pixel_size,
+         focal_leng=focal_leng,
+         cam_rot=cam_rot,
+         frame_fill=fov_scale_factor,
+     )
+
+    cam_data = pyv.CameraData(
+        pixels_num=pixel_num,
+        pixels_size=pixel_size,
+        pos_world=cam_pos_world,
+        rot_world=cam_rot,
+        roi_cent_world=roi_pos_world,
+        focal_length=focal_leng,
+        sub_samp=2,
+        back_face_removal=True,
+    )
+
+    print(80*"-")
+    print("CAMERA DATA:")
+    print(80*"-")
+    print(f"{cam_data.image_dist=}")
+    print(f"{cam_data.roi_cent_world=}")
+    print(f"{cam_data.pos_world=}")
+    print()
+    print("World to camera matrix:")
+    print(cam_data.world_to_cam_mat)
+    print(80*"-")
+    print()
+
+    print(80*"-")
+    total_frames = render_mesh.fields_render.shape[1]*render_mesh.fields_render.shape[2]
+    print(f"Time steps to render: {render_mesh.fields_render.shape[1]}")
+    print(f"Fields to render: {render_mesh.fields_render.shape[2]}")
+    print(f"Total frames to render: {total_frames}")
+    print(80*"-")
+
+    print(80*"=")
+    print("RASTER ELEMENT LOOP START")
+    print(80*"=")
+
+    num_loops = 1
+    loop_times = np.zeros((num_loops,),dtype=np.float64)
+
+    print()
+    print("Running raster loop.")
+    for nn in range(num_loops):
+        print(f"Running loop {nn}")
+        loop_start = time.perf_counter()
+
+        (image_buffer,
+         depth_buffer,
+         elems_in_images) = pyv.RasterCY.raster_static_mesh(cam_data,
+                                                            render_mesh,
+                                                            16)
+
+        loop_times[nn] = time.perf_counter() - loop_start
+
+    print()
+    print(80*"=")
+    print("PERFORMANCE TIMERS")
+    print(f"Elements in image = {elems_in_images}")
+    print(f"Image buffer shape = {image_buffer.shape}")
+    print(f"Avg. total render time = {np.mean(loop_times):.4f} seconds")
+    print(f"Avg. render time per frame = {(np.mean(loop_times)/total_frames):.4f} seconds")
+    print(80*"=")
+
+
+    #===========================================================================
+    # PLOTTING
+    plot_on = False
+    plot_frames = (-1,)#range(3)
+    plot_field = 0
+
+    # depth_to_plot = np.copy(np.asarray(depth_buffer[:,:,plot_frame]))
+    # depth_to_plot[depth_buffer[:,:,plot_frame] > 10*cam_data.image_dist] = np.nan
+    # image_to_plot = np.copy(np.asarray(image_buffer[:,:,plot_frame,plot_field]))
+    # image_to_plot[depth_buffer[:,:,plot_frame] > 10*cam_data.image_dist] = np.nan
+
+    if plot_on:
+        plot_opts = pyv.PlotOptsGeneral()
+
+        for ff in plot_frames:
+            (fig, ax) = plt.subplots(figsize=plot_opts.single_fig_size_square,
+                                    layout='constrained')
+            fig.set_dpi(plot_opts.resolution)
+            cset = plt.imshow(depth_buffer[:,:,ff],
+                            cmap=plt.get_cmap(plot_opts.cmap_seq))
+                            #origin='lower')
+            ax.set_aspect('equal','box')
+            fig.colorbar(cset)
+            ax.set_title(f"Depth buffer: {ff}",fontsize=plot_opts.font_head_size)
+            ax.set_xlabel(r"x ($px$)",
+                        fontsize=plot_opts.font_ax_size, fontname=plot_opts.font_name)
+            ax.set_ylabel(r"y ($px$)",
+                        fontsize=plot_opts.font_ax_size, fontname=plot_opts.font_name)
+
+            (fig, ax) = plt.subplots(figsize=plot_opts.single_fig_size_square,
+                                    layout='constrained')
+            fig.set_dpi(plot_opts.resolution)
+            cset = plt.imshow(image_buffer[:,:,ff,plot_field],
+                            cmap=plt.get_cmap(plot_opts.cmap_seq))
+                            #origin='lower')
+            ax.set_aspect('equal','box')
+            fig.colorbar(cset)
+            ax.set_title(f"Field Image: {ff}",fontsize=plot_opts.font_head_size)
+            ax.set_xlabel(r"x ($px$)",
+                        fontsize=plot_opts.font_ax_size, fontname=plot_opts.font_name)
+            ax.set_ylabel(r"y ($px$)",
+                        fontsize=plot_opts.font_ax_size, fontname=plot_opts.font_name)
+
+        plt.show()
+
+
+if __name__ == "__main__":
+    main()

pyvale/examples/visualisation/ex1_1_plot_traces.py

@@ -0,0 +1,102 @@
+# ==============================================================================
+# pyvale: the python validation engine
+# License: MIT
+# Copyright (C) 2025 The Computer Aided Validation Team
+# ==============================================================================
+
+"""
+Pyvale example: TODO
+--------------------------------------------------------------------------------
+TODO
+
+Test case: TODO
+"""
+
+import numpy as np
+import matplotlib.pyplot as plt
+import mooseherder as mh
+import pyvale as pyv
+
+# TODO: comments and full description for this example like the basics examples
+
+def main() -> None:
+
+    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),12)
+
+    sens_data = pyv.SensorData(positions=sens_pos,
+                                  sample_times=sample_times)
+
+    field_key = "temperature"
+    tc_array = pyv.SensorArrayFactory \
+        .thermocouples_basic_errs(sim_data,
+                                  sens_data,
+                                  field_key,
+                                  elem_dims=2)
+
+    err_int = pyv.ErrIntegrator([pyv.ErrSysOffset(offset=-5.0)],
+                                     sens_data,
+                                     tc_array.get_measurement_shape())
+    tc_array.set_error_integrator(err_int)
+
+    measurements = tc_array.get_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*"-")
+
+
+    trace_props = pyv.TraceOptsSensor()
+
+    trace_props.truth_line = None
+    trace_props.sim_line = None
+    pyv.plot_time_traces(tc_array,field_key,trace_props)
+
+    trace_props.meas_line = "--o"
+    trace_props.truth_line = "-x"
+    trace_props.sim_line = ":+"
+    pyv.plot_time_traces(tc_array,field_key,trace_props)
+
+    trace_props.sensors_to_plot = np.arange(measurements.shape[0]-2
+                                           ,measurements.shape[0])
+    pyv.plot_time_traces(tc_array,field_key,trace_props)
+
+    trace_props.sensors_to_plot = None
+    trace_props.time_min_max = (0.0,100.0)
+    pyv.plot_time_traces(tc_array,field_key,trace_props)
+
+    plt.show()
+
+    pv_plot = pyv.plot_point_sensors_on_sim(tc_array,field_key)
+    pv_plot.camera_position = [(-7.547, 59.753, 134.52),
+                                   (41.916, 25.303, 9.297),
+                                   (0.0810, 0.969, -0.234)]
+    pv_plot.show()
+
+
+if __name__ == "__main__":
+    main()

pyvale/examples/visualisation/ex2_1_animate_sim.py

@@ -0,0 +1,89 @@
+# ==============================================================================
+# pyvale: the python validation engine
+# License: MIT
+# Copyright (C) 2025 The Computer Aided Validation Team
+# ==============================================================================
+
+"""
+Pyvale example: TODO
+--------------------------------------------------------------------------------
+TODO
+
+Test case: TODO
+"""
+
+from pathlib import Path
+import numpy as np
+import mooseherder as mh
+import pyvale as pyv
+
+
+def main() -> None:
+
+    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)
+    sim_data.coords = sim_data.coords*1000.0 # type: ignore
+
+    pyv.print_dimensions(sim_data)
+
+    n_sens = (1,4,1)
+    x_lims = (12.5,12.5)
+    y_lims = (0,33.0)
+    z_lims = (0.0,12.0)
+    sens_pos = pyv.create_sensor_pos_array(n_sens,x_lims,y_lims,z_lims)
+
+    sens_data = pyv.SensorData(positions=sens_pos)
+
+    field_key = 'temperature'
+    tc_array = pyv.SensorArrayFactory() \
+        .thermocouples_basic_errs(sim_data,
+                                  sens_data,
+                                  field_key,
+                                  elem_dims=3)
+
+    measurements = tc_array.get_measurements()
+    print(f'\nMeasurements for sensor at top of block:\n{measurements[-1,0,:]}\n')
+
+    vis_opts = pyv.VisOptsSimSensors()
+    vis_opts.window_size_px = (1200,800)
+    vis_opts.camera_position = np.array([(59.354, 43.428, 69.946),
+                                         (-2.858, 13.189, 4.523),
+                                         (-0.215, 0.948, -0.233)])
+
+    vis_mode = "vector"
+    save_dir = Path.cwd() / "exampleoutput"
+    if not save_dir.is_dir():
+        save_dir.mkdir()
+
+    if vis_mode == "animate":
+        anim_opts = pyv.VisOptsAnimation()
+
+        anim_opts.save_path = save_dir / "test_animation"
+        anim_opts.save_animation = pyv.EAnimationType.MP4
+
+        pv_anim = pyv.animate_sim_with_sensors(tc_array,
+                                                  field_key,
+                                                  time_steps=None,
+                                                  vis_opts=vis_opts,
+                                                  anim_opts=anim_opts)
+
+    else:
+        image_save_opts = pyv.VisOptsImageSave()
+
+        image_save_opts.path = save_dir / "test_vector_graphics"
+        image_save_opts.image_type = pyv.EImageType.SVG
+
+        pv_plot = pyv.plot_point_sensors_on_sim(tc_array,
+                                                field_key,
+                                                time_step=-1,
+                                                vis_opts=vis_opts,
+                                                image_save_opts=image_save_opts)
+        pv_plot.show()
+
+
+if __name__ == '__main__':
+    main()

pyvale/experimentsimulator.py

@@ -0,0 +1,175 @@
+# ==============================================================================
+# pyvale: the python validation engine
+# License: MIT
+# Copyright (C) 2025 The Computer Aided Validation Team
+# ==============================================================================
+
+"""
+This module is used for performing Monte-Carlo virtual experiments over a series
+of input simulation cases and sensor arrays.
+"""
+
+from dataclasses import dataclass
+import numpy as np
+import mooseherder as mh
+from pyvale.sensorarray import ISensorArray
+
+
+@dataclass(slots=True)
+class ExperimentStats:
+    """Dataclass holding summary statistics for a series of simulated
+    experiments produced using the experiment simulator. All summary statistics
+    are calculated over the 'experiments' dimension of the measurements array so
+    the arrays of statistics have the shape=(n_sims,n_sensors,n_field_comps,
+    n_time_steps). Note that the n_sims dimension refers to the number of input
+    multi-physics simulations (i.e. SimData objects) that the virtual
+    experiments were performed over.
+    """
+
+    mean: np.ndarray | None = None
+    """Mean of each sensors measurement for the given field component and time
+    step as an array with shape=(n_sims,n_sensors,n_field_comps,n_time_steps).
+    """
+
+    std: np.ndarray | None = None
+    """Standard deviation of the sensor measurements for the given field
+    component and time step as an array with shape=(n_sims,n_sensors,
+    n_field_comps, n_time_steps)
+    """
+
+    max: np.ndarray | None = None
+    """Maximum of the sensor measurements for the given field component and time
+    step as an array with shape=(n_sims,n_sensors,n_field_comps,n_time_steps)
+    """
+
+    min: np.ndarray | None = None
+    """Minmum of the sensor measurements for the given field component and time
+    step as an array with shape=(n_sims,n_sensors,n_field_comps,n_time_steps)
+    """
+
+    med: np.ndarray | None = None
+    """Median  of the sensor measurements for the given field component and time
+    step as an array with shape=(n_sims,n_sensors,n_field_comps,n_time_steps)
+    """
+
+    q25: np.ndarray | None = None
+    """Lower 25% quantile of the sensor measurements for the given field
+    component and time step as an array with shape=(n_sims,n_sensors,
+    n_field_comps, n_time_steps)
+    """
+
+    q75: np.ndarray | None = None
+    """Upper 75% quantile of the sensor measurements for the given field
+    component and time step as an array with shape=(n_sims,n_sensors,
+    _field_comps, n_time_steps)
+    """
+
+    mad: np.ndarray | None = None
+    """Median absolute deviation of the sensor measurements for the given field
+    component and time step as an array with shape=(n_sims,n_sensors,
+    n_field_comps, n_time_steps)
+    """
+
+
+class ExperimentSimulator:
+    """An experiment simulator for running monte-carlo analysis by applying a
+    list of sensor arrays to a list of simulations over a given number of user
+    defined experiments. Calculates summary statistics for each sensor array
+    applied to each simulation.
+    """
+    __slots__ = ("_sim_list","_sensor_arrays","_num_exp_per_sim","_exp_data",
+                 "_exp_stats")
+
+    def __init__(self,
+                 sim_list: list[mh.SimData],
+                 sensor_arrays: list[ISensorArray],
+                 num_exp_per_sim: int
+                 ) -> None:
+        """
+        Parameters
+        ----------
+        sim_list : list[mh.SimData]
+            List of simulation data objects over which the virtual experiments
+            will be performed.
+        sensor_arrays : list[ISensorArray]
+            The sensor arrays that will be applied to each simulation to
+            generate the virtual experiment data.
+        num_exp_per_sim : int
+            Number of virtual experiments to perform for each simulation and
+            sensor array.
+        """
+        self._sim_list = sim_list
+        self._sensor_arrays = sensor_arrays
+        self._num_exp_per_sim = num_exp_per_sim
+        self._exp_data = None
+        self._exp_stats = None
+
+    def run_experiments(self) -> list[np.ndarray]:
+        """Runs the specified number of virtual experiments over the number of
+        input simulation cases and virtual sensor arrays.
+
+        Returns
+        -------
+        list[np.ndarray]
+            List of virtual experimental data arrays where the list index
+            corresponds to the virtual sensor array and the data is an array
+            with shape=(n_sims,n_exps,n_sens,n_comps,n_time_steps).
+        """
+
+        n_sims = len(self._sim_list)
+        # shape=list[n_sens_arrays](n_sims,n_exps,n_sens,n_comps,n_time_steps)
+        self._exp_data = [None]*len(self._sensor_arrays)
+
+        for ii,aa in enumerate(self._sensor_arrays):
+            meas_array = np.zeros((n_sims,self._num_exp_per_sim)+
+                                aa.get_measurement_shape())
+
+            for jj,ss in enumerate(self._sim_list):
+                aa.get_field().set_sim_data(ss)
+
+                for ee in range(self._num_exp_per_sim):
+                    meas_array[jj,ee,:,:,:] = aa.calc_measurements()
+
+            self._exp_data[ii] = meas_array
+
+        # shape=list[n_sens_arrays](n_sims,n_exps,n_sens,n_comps,n_time_steps)
+        return self._exp_data
+
+
+    def calc_stats(self) -> list[ExperimentStats]:
+        """Calculates summary statistics over the number of virtual experiments
+        specified. If `run_experiments()` has not been called then it is called
+        to generate the virtual experimental data to perform the statistical
+        calculations.
+
+        Returns
+        -------
+        list[ExperimentStats]
+            List of summary statistics data classes for the virtual experiments.
+            The list index correponds to the virtual sensor array.
+        """
+        if self._exp_data is None:
+            self._exp_data = self.run_experiments()
+
+        # shape=list[n_sens_arrays](n_sims,n_sens,n_comps,n_time_steps)
+        self._exp_stats = [None]*len(self._sensor_arrays)
+        for ii,_ in enumerate(self._sensor_arrays):
+            array_stats = ExperimentStats()
+            array_stats.max = np.max(self._exp_data[ii],axis=1)
+            array_stats.min = np.min(self._exp_data[ii],axis=1)
+            array_stats.mean = np.mean(self._exp_data[ii],axis=1)
+            array_stats.std = np.std(self._exp_data[ii],axis=1)
+            array_stats.med = np.median(self._exp_data[ii],axis=1)
+            array_stats.q25 = np.quantile(self._exp_data[ii],0.25,axis=1)
+            array_stats.q75 = np.quantile(self._exp_data[ii],0.75,axis=1)
+            array_stats.mad = np.median(np.abs(self._exp_data[ii] -
+                np.median(self._exp_data[ii],axis=1,keepdims=True)),axis=1)
+            self._exp_stats[ii] = array_stats
+
+        # shape=list[n_sens_arrays](n_sims,n_sens,n_comps,n_time_steps)
+        return self._exp_stats
+
+
+
+
+

pyvale/field.py

@@ -0,0 +1,128 @@
+# ==============================================================================
+# pyvale: the python validation engine
+# License: MIT
+# Copyright (C) 2025 The Computer Aided Validation Team
+# ==============================================================================
+
+from abc import ABC, abstractmethod
+import numpy as np
+from scipy.spatial.transform import Rotation
+import pyvista as pv
+import mooseherder as mh
+
+
+class IField(ABC):
+    """Interface (abstract base class) for sampling (interpolating) physical
+    fields from simulations to provide sensor values at specified locations and
+    times.
+    """
+
+    @abstractmethod
+    def set_sim_data(self,sim_data: mh.SimData) -> None:
+        """Abstract method. Sets the SimData object that will be interpolated to
+        obtain sensor values. The purpose of this is to be able to apply the
+        same sensor array to an array of different simulations.
+
+        Parameters
+        ----------
+        sim_data : mh.SimData
+            Mooseherder SimData object. Contains a mesh and a simulated
+            physical field.
+        """
+
+    @abstractmethod
+    def get_sim_data(self) -> mh.SimData:
+        """Abstract method. Gets the simulation data object associated with this
+        field. Used by pyvale visualisation tools to display simulation data
+        with simulated sensor values.
+
+        Returns
+        -------
+        mh.SimData
+            Mooseherder SimData object. Contains a mesh and a simulated
+            physical field.
+        """
+
+    @abstractmethod
+    def get_time_steps(self) -> np.ndarray:
+        """Abstract method. Gets a 1D array of time steps from the simulation
+        data.
+
+        Returns
+        -------
+        np.ndarray
+            1D array of simulation time steps. shape=(num_time_steps,)
+        """
+
+    @abstractmethod
+    def get_visualiser(self) -> pv.UnstructuredGrid:
+        """Abstract method. Gets a pyvista unstructured grid object for
+        visualisation purposes.
+
+        Returns
+        -------
+        pv.UnstructuredGrid
+            Pyvista unstructured grid object containing only a mesh without any
+            physical field data attached.
+        """
+
+    @abstractmethod
+    def get_all_components(self) -> tuple[str,...]:
+        """Gets the string keys for the component of the physical field. For
+        example: a scalar field might just have ('temperature',) whereas a
+        vector field might have ('disp_x','disp_y','disp_z').
+
+        Returns
+        -------
+        tuple[str,...]
+            Tuple containing the string keys for all components of the physical
+            field.
+        """
+
+    @abstractmethod
+    def get_component_index(self,component: str) -> int:
+        """Gets the index for a component of the physical field. Used for
+        getting the index of a component in the sensor measurement array.
+
+        Parameters
+        ----------
+        component : str
+            String key for the field component (e.g. 'temperature' or 'disp_x').
+
+        Returns
+        -------
+        int
+            Index for the selected field component
+        """
+
+    @abstractmethod
+    def sample_field(self,
+                    points: np.ndarray,
+                    times: np.ndarray | None = None,
+                    angles: tuple[Rotation,...] | None = None,
+                    ) -> np.ndarray:
+        """Samples (interpolates) the simulation field at the specified
+        positions, times, and angles.
+
+        Parameters
+        ----------
+        points : np.ndarray
+            Spatial points to be sampled with the rows indicating the point
+            number of the columns indicating the X,Y and Z coordinates.
+        times : np.ndarray | None, optional
+            Times to sample the underlying simulation. If None then the
+            simulation time steps are used and no temporal interpolation is
+            performed, by default None.
+        angles : tuple[Rotation,...] | None, optional
+            Angles to rotate the sampled values into with rotations specified
+            with respect to the simulation world coordinates. If a single
+            rotation is specified then all points are assumed to have the same
+            angle and are batch processed for speed. If None then no rotation is
+            performed, by default None.
+
+        Returns
+        -------
+        np.ndarray
+            An array of sampled (interpolated) values with the following
+            dimensions: shape=(num_points,num_components,num_time_steps).
+        """