added dataloader

README.md

@@ -6,4 +6,55 @@ tags:
 - physics
 - Fluid-Solid-Interaction
 - Fluid-Dynamics
----
+---
+
+## Dataset Description: Fluid-Solid Interaction Simulations
+
+For each time step \( t \), the simulation records the following variables:
+
+### **Velocity**
+\[
+\mathbf{v}_t = \begin{bmatrix} v_{x,t} \\ v_{y,t} \end{bmatrix}
+\]
+where \( v_{x,t} \) and \( v_{y,t} \) are the velocity components in the \( x \) and \( y \) directions, respectively.
+
+### **Pressure**
+\[
+P_t
+\]
+which represents the pressure field at time \( t \).
+
+### **Displacement**
+\[
+\mathbf{d}_t = \begin{bmatrix} d_{x,t} \\ d_{y,t} \end{bmatrix}
+\]
+where \( d_{x,t} \) and \( d_{y,t} \) denote the displacement in the \( x \) and \( y \) directions, respectively.
+
+---
+
+## **Mesh Representation**
+The initial mesh is given by:  
+\[
+\mathbf{M}_0 = \begin{bmatrix} x_1 & y_1 \\ x_2 & y_2 \\ \vdots & \vdots \\ x_N & y_N \end{bmatrix} \in \mathbb{R}^{N \times 2}
+\]
+where each row \( (x_i, y_i) \) represents a mesh point in 2D space.
+
+Since the mesh is time-dependent, the mesh at time \( t \) is updated based on displacement:
+
+\[
+\mathbf{M}_t = \mathbf{M}_0 + \mathbf{d}_t
+\]
+
+where  
+\[
+\mathbf{d}_t = \begin{bmatrix} d_{x,t,1} & d_{y,t,1} \\ d_{x,t,2} & d_{y,t,2} \\ \vdots & \vdots \\ d_{x,t,N} & d_{y,t,N} \end{bmatrix} \in \mathbb{R}^{N \times 2}
+\]
+is the displacement field at time \( t \).
+
+Thus, the updated coordinates of the mesh points at time \( t \) are:
+
+\[
+(x_i^t, y_i^t) = (x_i^0 + d_{x,t,i}, y_i^0 + d_{y,t,i}) \quad \forall i = 1, \dots, N
+\]
+
+This formulation describes how the mesh deforms over time due to displacement.

fsi_reader.py

@@ -8,14 +8,38 @@ import h5py
 class FsiDataReader():
     def __init__(self,
                  location,
-                 mu=None,
+                 mu,
                  in_lets_x1=None,
                  in_lets_x2=None,):
+        '''
+        Data set of fluid solid interaction simulations. 
+        At each time step t, the simulataion records 5 variables: 
+        velocity_t = [vx_t, vy_t]: velocity in x and y direction,
+        P_t: pressure,
+        displacment_t = [dx_t, dy_t]: displacement in x and y direction.
+        
+        The inital mesh is loaded as self.input_mesh. The mesh is a 2D mesh with 2 columns. The first column is the x coordinate and the second column is the y coordinate.
+        
+        The mesh is time dependent i.e., the mesh changes with time. 
+        The mesh at time t is given by   mesh_t = self.input_mesh + displacement_t.
+        
+        Parameters
+        ----------
+        location : str
+            path to the directory containing the data
+        mu : list, optional
+            list mu vlues. The siumulations corresponding to the mu values will be loaded. The values should be one of ['0.1', '0.01', '0.5', '5', '1.0', '10.0'] and slould exactly match the string values given here. The mu='0.5' should not be loaded separately.
+        in_lets_x1, : list, optional
+            list of x1 parameter controlling the inlet boundary condition of the simulation. The values should be one of ['-4.0', '-2.0', '0.0', '2.0', '4.0', '6.0'] and slould exactly match the string values given here. default is None, which loads all the values.
+        in_lets_x2 : list, optional
+            list of x2 parameter controlling the inlet boundary condition of the simulation. The values should be one of ['-4.0', '-2.0', '0.0', '2.0', '4.0', '6.0'] and slould exactly match the string values given here. default is None, which loads all the values.
+
+        '''
         self.location = location
         self._x1 = ['-4.0', '-2.0', '0.0', '2.0', '4.0', '6.0']
         self._x2 = ['-4.0', '-2.0', '0', '2.0', '4.0', '6.0']
         self._mu = ['0.1', '0.01', '0.5', '5', '1.0', '10.0'] 
-        # keeping vx,xy, P, dx,dy
+        # keeping vx, xy, P, dx,dy
         self.varable_idices = [0, 1, 3, 4, 5]
         
         if mu is not None:
@@ -33,6 +57,7 @@ class FsiDataReader():
             
         # assert _mu = 0.5 should not be mixed with other mu values
         assert not('0.5' in self._mu and len(self._mu) > 1), "mu=0.5 should not be mixed with other mu values"
+        self.load_mesh(location)
         
     
     def load_mesh(self, location):
@@ -138,10 +163,10 @@ class FsiDataReader():
                 for x2 in self._x2:
                     try:
                         if mu == 0.5:
-                            mu_data = self.get_data_txt(mu, x1, x2))
+                            mu_data = self.get_data_txt(mu, x1, x2)
                         else:
-                            mu_data = data.append(self.get_data(mu, x1, x2))
-                        mu_data_t0  = mu_data[:1,:,:]
+                            mu_data = self.get_data(mu, x1, x2)
+                        mu_data_t0  = mu_data[:-1,:,:]
                         mu_data_t1 = mu_data[1:,:,:]
                         data_t0.append(mu_data_t0)
                         data_t1.append(mu_data_t1)

plotting.py

@@ -0,0 +1,174 @@
+from fsi_reader import FsiDataReader
+import matplotlib.pyplot as plt
+import numpy as np
+from matplotlib.tri import Triangulation
+from matplotlib.animation import FuncAnimation
+from scipy.interpolate import griddata
+
+def single_plot(data, mesh_points):
+    data = np.squeeze(data)  # Shape becomes (1317,)
+    print(data.shape)
+    print(mesh_points.shape)
+    x, y = mesh_points[:, 0], mesh_points[:, 1]
+
+    # Create figure with subplots
+    fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(16, 6), 
+                                gridspec_kw={'width_ratios': [1, 1.2]})
+
+    # Approach 1: Triangulation-based contour plot
+    tri = Triangulation(x, y)
+    contour = ax1.tricontourf(tri, data, levels=40, cmap='viridis')
+    fig.colorbar(contour, ax=ax1, label='Value', shrink=0.3)
+    ax1.set_title('Contour Plot of Field Data')
+    ax1.set_aspect('equal')
+
+    # Approach 2: Scatter plot with interpolated background
+    grid_x, grid_y = np.mgrid[x.min():x.max():100j, y.min():y.max():100j]
+    grid_z = griddata((x, y), data, (grid_x, grid_y), method='cubic')
+
+    im = ax2.imshow(grid_z.T, origin='lower', extent=[x.min(), x.max(), 
+                    y.min(), y.max()], cmap='plasma')
+    ax2.scatter(x, y, c=data, edgecolor='k', lw=0.3, cmap='plasma', s=15)
+    fig.colorbar(im, ax=ax2, label='Interpolated Value', shrink=0.3)
+    ax2.set_title('Interpolated Surface with Sample Points')
+
+    # Common formatting
+    for ax in (ax1, ax2):
+        ax.set_xlabel('X Coordinate')
+        ax.set_ylabel('Y Coordinate')
+        ax.grid(True, alpha=0.3)
+        
+    plt.tight_layout()
+    plt.show()
+    
+def create_field_animation(data_frames, mesh_frames, interval=100, save_path=None):
+    """
+    Create an animation of time-varying 2D field data on a mesh.
+    
+    Parameters:
+    -----------
+    data_frames : list of arrays
+        List of data arrays for each time frame (each with shape [1, 1317, 1] or similar)
+    mesh_frames : list of arrays or single array
+        Either a list of mesh coordinates for each frame or a single fixed mesh
+    interval : int
+        Delay between animation frames in milliseconds
+    save_path : str, optional
+        Path to save the GIF animation
+    """
+    
+    plt.rcParams.update({
+        'font.size': 20,            # Base font size
+        'axes.titlesize': 20,       # Title font size
+        'axes.labelsize': 20,       # Axis label size
+        'xtick.labelsize': 20,      # X-tick label size
+        'ytick.labelsize': 18,      # Y-tick label size
+        'figure.titlesize': 22      # Super title size (if used)
+    })
+    
+    # Determine if mesh is fixed or time-varying
+    mesh_varying = isinstance(mesh_frames, list)
+    
+    # Get initial mesh and data
+    mesh_initial = mesh_frames[0] if mesh_varying else mesh_frames
+    data_initial = np.squeeze(data_frames[0])
+    
+    # Extract coordinates
+    x, y = mesh_initial[:, 0], mesh_initial[:, 1]
+    
+    # Create figure
+    fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(50, 10), 
+                                   gridspec_kw={'width_ratios': [1.5, 1.5]})
+    
+    # Calculate global min/max for consistent colorbars
+    all_data = np.concatenate([np.squeeze(frame) for frame in data_frames])
+    vmin, vmax = all_data.min(), all_data.max()
+    
+    # Create initial triangulation
+    tri_initial = Triangulation(x, y)
+    
+    # Set up first subplot - contour
+    contour = ax1.tricontourf(tri_initial, data_initial, levels=40, cmap='viridis', 
+                             vmin=vmin, vmax=vmax)
+    # Add contour lines for better visibility
+    contour_lines = ax1.tricontour(tri_initial, data_initial, levels=15, 
+                                  colors='black', linewidths=0.5, alpha=0.7)
+    
+    fig.colorbar(contour, ax=ax1, label='Value', shrink=0.3)
+    ax1.set_title('Contour Plot of Field Data')
+    ax1.set_aspect('equal')
+    
+    # Set up second subplot - interpolated surface with scatter points
+    grid_x, grid_y = np.mgrid[x.min():x.max():100j, y.min():y.max():100j]
+    grid_z = griddata((x, y), data_initial, (grid_x, grid_y), method='cubic')
+    
+    im = ax2.imshow(grid_z.T, origin='lower', extent=[x.min(), x.max(), 
+                                                    y.min(), y.max()], 
+                   cmap='plasma', vmin=vmin, vmax=vmax)
+    scat = ax2.scatter(x, y, c=data_initial, edgecolor='k', lw=0.3, 
+                      cmap='plasma', s=15, vmin=vmin, vmax=vmax)
+    
+    fig.colorbar(im, ax=ax2, label='Interpolated Value', shrink=0.3)
+    ax2.set_title('Interpolated Surface with Sample Points')
+    
+    # Common formatting
+    for ax in (ax1, ax2):
+        ax.set_xlabel('X Coordinate')
+        ax.set_ylabel('Y Coordinate')
+        ax.grid(True, alpha=0.3)
+    
+    # Add frame counter
+    time_text = ax1.text(0.02, 0.98, '', transform=ax1.transAxes, 
+                        fontsize=10, va='top', ha='left')
+    
+    plt.tight_layout()
+    
+    # Update function for animation
+    def update(frame):
+        # Get current data
+        data = np.squeeze(data_frames[frame])
+        
+        # Get current mesh if varying
+        if mesh_varying:
+            mesh = mesh_frames[frame]
+            x, y = mesh[:, 0], mesh[:, 1]
+            tri = Triangulation(x, y)
+        else:
+            mesh = mesh_frames
+            x, y = mesh[:, 0], mesh[:, 1]
+            tri = tri_initial
+        
+        # Update contour plot
+        for c in ax1.collections:
+            c.remove()
+        new_contour = ax1.tricontourf(tri, data, levels=40, cmap='viridis', 
+                                     vmin=vmin, vmax=vmax)
+        new_lines = ax1.tricontour(tri, data, levels=15, colors='black', 
+                                  linewidths=0.5, alpha=0.7)
+        
+        # Update interpolated surface
+        grid_z = griddata((x, y), data, (grid_x, grid_y), method='cubic')
+        im.set_array(grid_z.T)
+        
+        # Update scatter points
+        scat.set_offsets(mesh)
+        scat.set_array(data)
+        
+        # Update frame counter
+        time_text.set_text(f'Frame: {frame+1}/{len(data_frames)}')
+        
+        return [new_contour, new_lines, im, scat, time_text]
+    
+    # Create animation
+    anim = FuncAnimation(fig, update, frames=len(data_frames), 
+                         interval=interval, blit=False)
+    
+    # Save if path provided
+    if save_path:
+        print(f"Saving animation to {save_path}...")
+        if save_path.endswith('.gif'):
+            anim.save(save_path, writer='pillow', dpi=150)
+        else:
+            anim.save(save_path, writer='ffmpeg', dpi=150)
+    
+    return anim