fargopy 0.3.14__py3-none-any.whl → 0.4.0__py3-none-any.whl

fargopy/fsimulation.py

@@ -2,63 +2,207 @@ import pandas as pd
 import numpy as np
 import fargopy as fp
 
-
 import matplotlib.pyplot as plt
 import plotly.figure_factory as ff
 from plotly.subplots import make_subplots
 import plotly.graph_objects as go
 from matplotlib.animation import FFMpegWriter
 
-from ipywidgets import interact, FloatSlider,IntSlider 
+from ipywidgets import interact, FloatSlider, IntSlider
 from celluloid import Camera
-from IPython.display import HTML
-from IPython.display import Video
+from IPython.display import HTML, Video
 
 from scipy.interpolate import griddata
 from scipy.integrate import solve_ivp
 from tqdm import tqdm
 
 
-
-
-class DataHandler:
+class FieldInterpolate:
     def __init__(self, sim):
         self.sim = sim
         self.df = None
         self.plane = None
+        self.angle = None
+
+    def load_data(self, field=None, plane=None, angle=None, snapshots=None):
+        """
+        Loads data in 2D or 3D depending on the provided parameters.
+
+        Parameters:
+            field (list of str, optional): List of fields to load (e.g., ["gasdens", "gasv"]).
+            plane (str, optional): Plane for 2D data ('XZ', 'XY', 'YZ'). Required for 2D.
+            angle (float, optional): Angle for the 2D slice. Required for 2D.
+            snapshots (list or int, optional): List of snapshot indices or a single snapshot to load. Required for both 2D and 3D.
+        Returns:
+            pd.DataFrame: DataFrame containing the loaded data.
+        """
+        if field is None:
+            raise ValueError("You must specify at least one field to load using the 'fields' parameter.")
+
+        if (plane and not angle) or (angle and not plane):
+            raise ValueError("Both 'plane' and 'angle' must be provided for 2D data.")
+
+        if angle and not isinstance(angle, str):
+            raise ValueError("'angle' must be a str example: angle='theta=1.5' [rad]")
+
+        if not isinstance(snapshots, (int, list, tuple)):
+            raise ValueError("'snapshots' must be an integer, a list, or a tuple.")
+
+        if isinstance(snapshots, (list, tuple)) and len(snapshots) == 2:
+            if snapshots[0] > snapshots[1]:
+                raise ValueError("The range in 'snapshots' is invalid. The first value must be less than or equal to the second.")
+
+        if not hasattr(self.sim, "domains") or self.sim.domains is None:
+            raise ValueError("Simulation domains are not loaded. Ensure the simulation data is properly initialized.")
+
+        # Convert a single snapshot to a list
+        if isinstance(snapshots, int):
+            snapshots = [snapshots]
+
+        # Handle the case where snapshots is a single value or a list with one value
+        if len(snapshots) == 1:
+            snaps = snapshots
+            time_values = [0]  # Single snapshot corresponds to a single time value
+        else:
+            snaps = np.arange(snapshots[0], snapshots[1] + 1)
+            time_values = np.linspace(0, 1, len(snaps))
 
-    def load_data(self, plane, angle, num_snapshots):
-        self.plane = plane 
-        snapshots = np.arange(1, num_snapshots + 1)
-        time_values = snapshots / num_snapshots
-
-        df_snapshots = pd.DataFrame(columns=["snapshot", "time", "vel1", "vel2", "gasdens", "coord1", "coord2"])
-
-        for i, snap in enumerate(snapshots):
-            gasv = self.sim.load_field('gasv', snapshot=snap, type='vector')
-            gasvx, gasvy, gasvz = gasv.to_cartesian()
-            gasd = self.sim.load_field('gasdens', snapshot=snap, type='scalar')
-
-            if plane == 'XZ':
-                vel1_slice, mesh = gasvx.meshslice(slice=angle)
-                vel2_slice, _ = gasvz.meshslice(slice=angle)
-                coord1, coord2 = mesh.x, mesh.z
-            elif plane == 'XY':
-                vel1_slice, mesh = gasvx.meshslice(slice=angle)
-                vel2_slice, _ = gasvy.meshslice(slice=angle)
-                coord1, coord2 = mesh.x, mesh.y
-            elif plane == 'YZ':
-                vel1_slice, mesh = gasvy.meshslice(slice='r=1.0')
-                vel2_slice, _ = gasvz.meshslice(slice='r=1.0')
-                coord1, coord2 = mesh.y, mesh.z
-
-            gasd_slice, _ = gasd.meshslice(slice=angle)
-            df_snapshots.loc[i] = [snap, time_values[i], vel1_slice, vel2_slice, gasd_slice, coord1, coord2]
-
-        self.df = df_snapshots
-        return df_snapshots
-
-    def interpolate_field(self, time, var1, var2, field_name):
+        if plane and angle:  # Load 2D data
+        
+            # Map plane to coordinate names
+            plane_map = {
+                "XY": ("x", "y", "vx", "vy"),
+                "XZ": ("x", "z", "vx", "vz"),
+                "YZ": ("y", "z", "vy", "vz")
+            }
+
+            if plane not in plane_map:
+                raise ValueError(f"Invalid plane '{plane}'. Valid options are 'XY', 'XZ', 'YZ'.")
+
+            coord1, coord2, vel1, vel2 = plane_map[plane]
+
+            # Dynamically create DataFrame columns based on the fields
+            columns = ["snapshot", "time", coord1, coord2]
+            if field=="gasdens":
+                print(f"Loading 2D density data for plane {plane} at angle {angle} rad.")
+                columns.append("gasdens")
+            if field=="gasv":
+                columns.extend([vel1, vel2])
+                print(f"Loading 2D gas velocity data for plane {plane} at angle {angle} rad.")
+            
+            if field=="gasenergy":
+                columns.append("gasenergy")
+                print(f"Loading 2D gas energy data for plane {plane} at angle {angle} rad.")
+            df_snapshots = pd.DataFrame(columns=columns)
+
+            for i, snap in enumerate(snaps):
+                row = {"snapshot": snap, "time": time_values[i]}
+
+                # Assign coordinates for all fields
+                gasv = self.sim.load_field('gasv', snapshot=snap, type='vector')
+                _, mesh = gasv.meshslice(slice=angle)
+                coord1_vals, coord2_vals = getattr(mesh, coord1), getattr(mesh, coord2)
+                row[coord1] = coord1_vals
+                row[coord2] = coord2_vals
+
+                if field=="gasdens" :
+                    gasd = self.sim.load_field('gasdens', snapshot=snap, type='scalar')
+                    gasd_slice, _ = gasd.meshslice(slice=angle)
+                    row["gasdens"] = gasd_slice
+
+                if field=="gasv":
+                    gasvx, gasvy, gasvz = gasv.to_cartesian()
+                    vel1_slice, _ = getattr(gasvx, f"meshslice")(slice=angle)
+                    vel2_slice, _ = getattr(gasvy, f"meshslice")(slice=angle)
+                    row[vel1] = vel1_slice
+                    row[vel2] = vel2_slice
+
+                if field=="gasenergy":
+                    gasenergy = self.sim.load_field('gasenergy', snapshot=snap, type='scalar')
+                    gasenergy_slice, _ = gasenergy.meshslice(slice=angle)
+                    row["gasenergy"] = gasenergy_slice
+
+                # Convert the row to a DataFrame and concatenate it
+                row_df = pd.DataFrame([row])
+                df_snapshots = pd.concat([df_snapshots, row_df], ignore_index=True)
+
+            self.df = df_snapshots
+            return df_snapshots
+        
+        elif plane is None and angle is None:  # Load 3D data
+            print("Loading 3D data.")
+
+
+            # Generate 3D mesh
+            theta, r, phi = np.meshgrid(self.sim.domains.theta, self.sim.domains.r, self.sim.domains.phi, indexing='ij')
+            x, y, z = r * np.sin(theta) * np.cos(phi), r * np.sin(theta) * np.sin(phi), r * np.cos(theta)
+
+        
+            # Create an empty DataFrame for the current field
+            columns = ["snapshot", "time", "x", "y", "z"]
+            if field == "gasv":
+                columns.extend(["vx", "vy", "vz"])
+            else:
+                columns.append(field)
+
+            df_snapshots = pd.DataFrame(columns=columns)
+
+            for i, snap in enumerate(snaps):
+                row = {"snapshot": snap, "time": time_values[i], "x": x.ravel(), "y": y.ravel(), "z": z.ravel()}
+
+                if field == "gasdens":
+                    gasd = self.sim.load_field("gasdens", snapshot=snap, type="scalar")
+                    row[field] = gasd.data.ravel()
+
+                elif field == "gasv":
+                    gasv = self.sim.load_field("gasv", snapshot=snap, type="vector")
+                    gasvx, gasvy, gasvz = gasv.to_cartesian()
+                    row["vx"] = gasvx.data.ravel()
+                    row["vy"] = gasvy.data.ravel()
+                    row["vz"] = gasvz.data.ravel()
+
+                elif field == "gasenergy":
+                    gasenergy = self.sim.load_field("gasenergy", snapshot=snap, type="scalar")
+                    row[field] = gasenergy.data.ravel()
+
+                # Append the row to the DataFrame
+                df_snapshots = pd.concat([df_snapshots, pd.DataFrame([row])], ignore_index=True)
+            
+            self.df = df_snapshots
+            # Return the single DataFrame
+            return df_snapshots
+    
+
+    def evaluate(self, time, var1, var2, var3=None):
+        """
+        Interpolates a field in 2D or 3D depending on the provided parameters.
+
+        Parameters:
+            time (float): Time at which to interpolate.
+            var1, var2 (numpy.ndarray or float): Spatial coordinates in 2D.
+            var3 (numpy.ndarray or float, optional): Additional coordinate for 3D. If None, 2D is assumed.
+
+        Returns:
+            numpy.ndarray or float: Interpolated field values at the given coordinates.
+                                    If velocity fields are present, returns a tuple (vx, vy, vz) or (vx, vy).
+        """
+        # Automatically determine the field to interpolate
+        if "gasdens" in self.df.columns:
+            field_name = "gasdens"
+        elif "gasenergy" in self.df.columns:
+            field_name = "gasenergy"
+        elif {"vx", "vy", "vz"}.issubset(self.df.columns):  # 3D velocity
+            field_name = ["vx", "vy", "vz"]
+        elif {"vx", "vy"}.issubset(self.df.columns):  # 2D velocity (vx, vy)
+            field_name = ["vx", "vy"]
+        elif {"vx", "vz"}.issubset(self.df.columns):  # 2D velocity (vx, vz)
+            field_name = ["vx", "vz"]
+        elif {"vy", "vz"}.issubset(self.df.columns):  # 2D velocity (vy, vz)
+            field_name = ["vy", "vz"]
+        else:
+            raise ValueError("No valid field found in the DataFrame for interpolation.")
+
+        # Sort the DataFrame by time
         df_sorted = self.df.sort_values("time")
         idx = df_sorted["time"].searchsorted(time) - 1
         if idx == -1:
@@ -70,49 +214,122 @@ class DataHandler:
         if factor < 0:
             factor = 0
 
-        def interp(idx):
-            coord1, coord2 = df_sorted.iloc[idx]["coord1"], df_sorted.iloc[idx]["coord2"]
-            points = np.column_stack((coord1.ravel(), coord2.ravel()))
-            data = df_sorted.iloc[idx][field_name].ravel()
-            return griddata(points, data, (var1, var2), method='linear', fill_value=0.0)
-
-        result = (1 - factor) * interp(idx) + factor * interp(idx_after)
-        return result
+        # Check if the input is a single point or a mesh
+        is_scalar = np.isscalar(var1) and np.isscalar(var2) and (var3 is None or np.isscalar(var3))
+        if is_scalar:
+            result_shape = ()
+        else:
+            result_shape = var1.shape  # Preserve the shape of the input mesh
+
+        def interp(idx, field):
+            if var3 is not None:  # 3D interpolation
+                coord_x = np.array(df_sorted.iloc[idx]["x"])
+                coord_y = np.array(df_sorted.iloc[idx]["y"])
+                coord_z = np.array(df_sorted.iloc[idx]["z"])
+                points = np.column_stack((coord_x.ravel(), coord_y.ravel(), coord_z.ravel()))
+                data = np.array(df_sorted.iloc[idx][field]).ravel()
+                return griddata(points, data, (var1, var2, var3), method='nearest', fill_value=0.0)
+            else:  # 2D interpolation
+                if 'x' in self.df.columns and 'y' in self.df.columns:
+                    coord1 = np.array(df_sorted.iloc[idx]["x"])
+                    coord2 = np.array(df_sorted.iloc[idx]["y"])
+                elif 'x' in self.df.columns and 'z' in self.df.columns:
+                    coord1 = np.array(df_sorted.iloc[idx]["x"])
+                    coord2 = np.array(df_sorted.iloc[idx]["z"])
+                elif 'y' in self.df.columns and 'z' in self.df.columns:
+                    coord1 = np.array(df_sorted.iloc[idx]["y"])
+                    coord2 = np.array(df_sorted.iloc[idx]["z"])
+                else:
+                    raise ValueError("Insufficient spatial coordinates for interpolation.")
+                points = np.column_stack((coord1.ravel(), coord2.ravel()))
+                data = np.array(df_sorted.iloc[idx][field]).ravel()
+                return griddata(points, data, (var1, var2), method='linear', fill_value=0.0)
+
+        # Preallocate arrays for results
+        if isinstance(field_name, list):  # Velocity (multiple fields)
+            results = []
+            for field in field_name:
+                interpolated = (1 - factor) * interp(idx, field) + factor * interp(idx_after, field)
+                if is_scalar:
+                    results.append(interpolated.item())  # Extract scalar value
+                else:
+                    results.append(interpolated)
+            return results
+        else:  # Scalar field (gasdens or gasenergy)
+            interpolated = (1 - factor) * interp(idx, field_name) + factor * interp(idx_after, field_name)
+            if is_scalar:
+                return interpolated.item()  # Extract scalar value
+            else:
+                return interpolated
 
-    def interpolate_velocity(self, time, var1, var2):
-        v1 = self.interpolate_field(time, var1, var2, "vel1")
-        v2 = self.interpolate_field(time, var1, var2, "vel2")
-        return v1, v2
 
-    def interpolate_density(self, time, var1, var2):
-        return self.interpolate_field(time, var1, var2, "gasdens")
         
 
-class Simulation:
+class fluidmotion:
     def __init__(self, plane, angle, num_snapshots, dir_path):
+        """
+        Initializes the Simulation class.
+
+        Parameters:
+            plane (str): The plane for 2D data ('XZ', 'XY', 'YZ').
+            angle (float): The angle for the 2D slice.
+            num_snapshots (int): Number of snapshots for 2D data.
+            dir_path (str): Directory path where the simulation data is stored.
+        """
         self.sim = fp.Simulation(output_dir=dir_path)
         self.data_handler = DataHandler(self.sim)
         self.data_handler.load_data(plane, angle, num_snapshots)
 
     def velocity_field(self, t, y):
+        """
+        Computes the velocity field at a given time and position.
+
+        Parameters:
+            t (float): Time at which to compute the velocity field.
+            y (array-like): Position [var1, var2] where the velocity is computed.
+
+        Returns:
+            numpy.ndarray: Velocity vector [v1, v2] at the given position and time.
+        """
         var1, var2 = y
         v1, v2 = self.data_handler.interpolate_velocity(t, np.array([var1]), np.array([var2]))
         return np.array([v1[0], v2[0]])
 
     def integrate_particles(self, particle_pos, time, dt=0.01):
-        """ Integra todas las partículas con un paso explícito de Euler."""
+        """
+        Integrates all particles using an explicit Euler step.
+
+        Parameters:
+            particle_pos (numpy.ndarray): Array of particle positions (shape: [n_particles, 2]).
+            time (float): Current time of the simulation.
+            dt (float): Time step for integration.
+
+        Returns:
+            numpy.ndarray: Updated particle positions after integration.
+        """
         if len(particle_pos) == 0:
             return np.array([])
 
         v1, v2 = self.data_handler.interpolate_velocity(time, particle_pos[:, 0], particle_pos[:, 1])
 
-        # Paso de Euler: x_{n+1} = x_n + v * dt
+        # Euler step: x_{n+1} = x_n + v * dt
         particle_pos[:, 0] += v1 * dt
         particle_pos[:, 1] += v2 * dt
 
         return particle_pos
 
     def generate_uniform_particles(self, var1_min, var1_max, var2_min, var2_max, num_particles):
+        """
+        Generates uniformly distributed particles within a specified region.
+
+        Parameters:
+            var1_min, var1_max (float): Range for the first coordinate.
+            var2_min, var2_max (float): Range for the second coordinate.
+            num_particles (int): Number of particles to generate.
+
+        Returns:
+            numpy.ndarray: Array of particle positions (shape: [num_particles, 2]).
+        """
         grid_size = int(np.sqrt(num_particles))
         var1_candidates = np.linspace(var1_min + 0.01, var1_max - 0.01, grid_size)
         var2_candidates = np.linspace(var2_min + 0.001, var2_max - 0.001, grid_size)
@@ -133,6 +350,21 @@ class Simulation:
         return new_particles
 
     def run_simulation(self, res, var1_min, var1_max, var2_min, var2_max, ts, npi, max_lifetime, generation_interval):
+        """
+        Runs the particle simulation and generates an animation.
+
+        Parameters:
+            res (int): Resolution of the grid for density interpolation.
+            var1_min, var1_max (float): Range for the first coordinate.
+            var2_min, var2_max (float): Range for the second coordinate.
+            ts (int): Number of time steps for the simulation.
+            npi (int): Number of particles to generate at each interval.
+            max_lifetime (int): Maximum lifetime of particles.
+            generation_interval (int): Interval for generating new particles.
+
+        Returns:
+            IPython.display.Video: Animation of the particle simulation.
+        """
         var1_reg, var2_reg = np.linspace(var1_min, var1_max, res), np.linspace(var2_min, var2_max, res)
         VAR1_reg, VAR2_reg = np.meshgrid(var1_reg, var2_reg, indexing='ij')
 
@@ -143,14 +375,14 @@ class Simulation:
         lifetimes = np.empty(0)
         new_particles = self.generate_uniform_particles(var1_min, var1_max, var2_min, var2_max, npi)
 
-            # Determinar el label del eje y en función del plano
+        # Determine the y-axis label based on the plane
         plane = self.data_handler.plane
-        y_label = "Z [AU]" if plane == "XZ" else r"$\phi$ [rad]"
+        y_label = "Z [AU]" if plane == "XZ" else "Y [AU]"
 
         fig, ax = plt.subplots(figsize=(8, 8))
         camera = Camera(fig)
 
-        with tqdm(total=len(t_eval), desc="Generando animación", unit="frame") as pbar:
+        with tqdm(total=len(t_eval), desc="Generating animation", unit="frame") as pbar:
             for frame in range(len(t_eval)):
                 time = t_eval[frame]
                 if frame % generation_interval == 0:
@@ -167,437 +399,31 @@ class Simulation:
 
                 lifetimes_normalized = lifetimes / max_lifetime
 
-                # Agregar interpolación de densidad como fondo
+                # Add density interpolation as background
                 gasd_interpolated = self.data_handler.interpolate_density(time, VAR1_reg, VAR2_reg)
                 c = ax.pcolormesh(VAR1_reg, VAR2_reg, np.log10(gasd_interpolated * self.sim.URHO * 1e3),
-                                cmap="viridis", shading='auto')
+                                  cmap="viridis", shading='auto')
 
-                # Graficar partículas
+                # Plot particles
                 if len(particle_pos) > 0:
                     ax.scatter(particle_pos[:, 0], particle_pos[:, 1], c='lightgray', alpha=lifetimes_normalized, s=1.0)
 
                 ax.set_xlim(var1_min, var1_max)
                 ax.set_ylim(var2_min, var2_max)
-                ax.set_xlabel(r"$r \ [AU]$",size=12)
-                ax.set_ylabel(y_label,size=12)
+                ax.set_xlabel(r"$r \ [AU]$", size=12)
+                ax.set_ylabel(y_label, size=12)
                 camera.snap()
 
                 pbar.update(1)
 
-        # Agregar barra de color
+        # Add color bar
         fig.colorbar(c, ax=ax, label=r'$\log_{10}(\rho)$ [kg/m$^3$]')
         plt.close(fig)
         animation = camera.animate()
-        video_filename = 'figures/streaklines.mp4'
+        video_filename = 'particles.mp4'
         animation.save(video_filename, writer=FFMpegWriter(fps=10, codec='libx264', bitrate=5000))
 
-        # Mostrar el video en el entorno interactivo
+        # Display the video in the interactive environment
         return Video(video_filename, embed=True)
     
 
-class Visualize:
-    def __init__(self, data_handler):
-        """
-        Inicializa la clase Visualize con una instancia de DataHandler.
-        """
-        self.data_handler = data_handler
-
-    def density(self, var1_min, var1_max, var2_min, var2_max, res, time):
-        """
-        Grafica un mapa de contornos de densidad interpolada en un tiempo dado.
-        """
-        # Crear una cuadrícula regular para las coordenadas
-        var1 = np.linspace(var1_min, var1_max, res)
-        var2 = np.linspace(var2_min, var2_max, res)
-        VAR1, VAR2 = np.meshgrid(var1, var2, indexing='ij')
-
-        # Interpolar la densidad en el tiempo dado
-        density = self.data_handler.interpolate_density(time, VAR1, VAR2).T
-
-        # Determinar el label del eje y en función del plano
-        plane = self.data_handler.plane
-        y_label = "Z [AU]" if plane == "XZ" else r"$\phi$ [rad]"
-
-        # Crear el gráfico de contorno
-        fig = go.Figure(
-            data=go.Contour(
-                z=np.log10(density * self.data_handler.sim.URHO * 1e3),
-                x=var1,
-                y=var2,
-                colorscale="Spectral_r",
-                contours=dict(coloring="heatmap"),
-                colorbar=dict(title="log10(ρ) [kg/m³]")
-            )
-        )
-
-        # Configurar el diseño del gráfico
-        fig.update_layout(
-            title=f"Mapa de Contornos de Densidad (t = {time:.2f})",
-            xaxis_title="r [AU]",
-            yaxis_title=y_label,
-            width=600,
-            height=600
-        )
-
-        # Mostrar el gráfico
-        fig.show()
-
-        
-
-
-    def animate_density(self, var1_min, var1_max, var2_min, var2_max, res, time_array):
-
-        # Crear una cuadrícula regular para las coordenadas
-        var1 = np.linspace(var1_min, var1_max, res)
-        var2 = np.linspace(var2_min, var2_max, res)
-        VAR1, VAR2 = np.meshgrid(var1, var2, indexing='ij')
-
-        # Precalcular el campo de densidad para todos los tiempos
-        precalculated_density = [
-            self.data_handler.interpolate_density(time, VAR1, VAR2).T
-            for time in time_array
-        ]
-            # Determinar el label del eje y en función del plano
-        plane = self.data_handler.plane
-        y_label = "Z [AU]" if plane == "XZ" else r"$\phi$ [rad]"
-
-        # Crear la figura inicial
-        initial_density = precalculated_density[0]
-        fig = go.Figure(
-            data=go.Contour(
-                z=np.log10(initial_density * self.data_handler.sim.URHO * 1e3),
-                x=var1,
-                y=var2,
-                colorscale="Spectral_r",
-                contours=dict(coloring="heatmap"),
-                colorbar=dict(title="log10(ρ) [kg/m³]")
-            )
-        )
-
-        # Crear los frames para la animación
-        frames = []
-        for i, time in enumerate(time_array):
-            density = precalculated_density[i]
-            frames.append(go.Frame(
-                data=go.Contour(
-                    z=np.log10(density * self.data_handler.sim.URHO * 1e3),
-                    x=var1,
-                    y=var2,
-                    colorscale="Spectral_r",  # Este colormap será actualizado dinámicamente
-                    contours=dict(coloring="heatmap")
-                ),
-                name=f"{time:.2f}"
-            ))
-
-        fig.frames = frames
-
-        # Configurar el slider
-        sliders = [
-            dict(
-                steps=[
-                    dict(
-                        method="animate",
-                        args=[[f"{time:.2f}"], dict(mode="immediate", frame=dict(duration=100, redraw=True), transition=dict(duration=0))],
-                        label=f"{time:.2f}"
-                    )
-                    for time in time_array
-                ],
-                transition=dict(duration=0),
-                currentvalue=dict(font=dict(size=16), prefix="Tiempo: ", visible=True),
-                len=0.9
-            )
-        ]
-
-        # Configurar los botones de reproducción y pausa
-        updatemenus = [
-            dict(
-                type="buttons",
-                showactive=False,
-                buttons=[
-                    dict(label="Play",
-                        method="animate",
-                        args=[None, dict(frame=dict(duration=100, redraw=True), fromcurrent=True)]),
-                    dict(label="Pause",
-                        method="animate",
-                        args=[[None], dict(frame=dict(duration=0, redraw=False), mode="immediate")])
-                ]
-            )
-        ]
-
-        # Actualizar el diseño de la figura
-        fig.update_layout(
-            title="Evolución del Campo de Densidad",
-            xaxis_title='r [AU]',
-            yaxis_title=y_label,
-            width=600,
-            height=600,
-            sliders=sliders,
-            updatemenus=updatemenus
-        )
-
-        # Mostrar la animación
-        fig.show()
-
-    def velocity(self, var1_min, var1_max, var2_min, var2_max, res, time):
-        """
-        Grafica un mapa de magnitud de velocidad interpolada en un tiempo dado.
-        Las zonas donde la interpolación da 0 no serán coloreadas.
-        """
-        # Crear una cuadrícula regular para las coordenadas
-        var1 = np.linspace(var1_min, var1_max, res)
-        var2 = np.linspace(var2_min, var2_max, res)
-        VAR1, VAR2 = np.meshgrid(var1, var2, indexing='ij')
-
-        # Interpolar el campo de velocidad en el tiempo dado
-        velocity_x, velocity_y = self.data_handler.interpolate_velocity(time, VAR1, VAR2)
-
-        # Calcular la magnitud de la velocidad
-        velocity_magnitude = np.sqrt(velocity_x**2 + velocity_y**2).T * self.data_handler.sim.UV / (1e5)  # Convertir a km/s
-
-        # Establecer las zonas donde velocity_x y velocity_y son 0 como None
-        velocity_magnitude[velocity_magnitude==0] = None
-
-        # Determinar el label del eje y en función del plano
-        plane = self.data_handler.plane
-        y_label = "Z [AU]" if plane == "XZ" else r"$\phi$ [rad]"
-
-        # Crear el gráfico de contorno
-        fig = go.Figure(
-            data=go.Contour(
-                z=velocity_magnitude,
-                x=var1,
-                y=var2,
-                colorscale="Viridis",
-                contours=dict(coloring="heatmap"),
-                colorbar=dict(title="|v| [km/s]"),
-                zmin=np.nanmin(velocity_magnitude),
-                zmax=np.nanmax(velocity_magnitude),
-                showscale=True
-            )
-        )
-
-        # Configurar el diseño del gráfico
-        fig.update_layout(
-            title=f"Mapa de Velocidad (t = {time:.2f})",
-            xaxis_title="r [AU]",
-            yaxis_title=y_label,
-            width=600,
-            height=600,
-            plot_bgcolor="white"  # Fondo blanco para que las zonas no coloreadas sean visibles
-        )
-
-        # Mostrar el gráfico
-        fig.show()
-
-    def animate_velocity(self, var1_min, var1_max, var2_min, var2_max, res, time_array):
-        """
-        Crea una animación del mapa de magnitud de velocidad interpolada en función del tiempo.
-        Las zonas donde la magnitud de la velocidad es 0 no serán coloreadas.
-        """
-        # Crear una cuadrícula regular para las coordenadas
-        var1 = np.linspace(var1_min, var1_max, res)
-        var2 = np.linspace(var2_min, var2_max, res)
-        VAR1, VAR2 = np.meshgrid(var1, var2, indexing='ij')
-
-        # Determinar el label del eje y en función del plano
-        plane = self.data_handler.plane
-        y_label = "Z [AU]" if plane == "XZ" else r"$\phi$ [rad]"
-
-        # Precalcular la magnitud del campo de velocidad para todos los tiempos
-        precalculated_velocity_magnitude = []
-        for time in time_array:
-            velocity_x, velocity_y = self.data_handler.interpolate_velocity(time, VAR1, VAR2)
-            velocity_magnitude = np.sqrt(velocity_x**2 + velocity_y**2).T * self.data_handler.sim.UV / (1e5)  # Convertir a km/s
-            velocity_magnitude[velocity_magnitude == 0] = None  # Reemplazar las zonas con magnitud 0 por None
-            precalculated_velocity_magnitude.append(velocity_magnitude)
-
-        # Crear la figura inicial
-        initial_velocity_magnitude = precalculated_velocity_magnitude[0]
-        fig = go.Figure(
-            data=go.Contour(
-                z=initial_velocity_magnitude,
-                x=var1,
-                y=var2,
-                colorscale="Viridis",
-                contours=dict(coloring="heatmap"),
-                colorbar=dict(title="|v| [km/s]")
-            )
-        )
-
-        # Crear los frames para la animación
-        frames = []
-        for i, time in enumerate(time_array):
-            velocity_magnitude = precalculated_velocity_magnitude[i]
-            frames.append(go.Frame(
-                data=go.Contour(
-                    z=velocity_magnitude,
-                    x=var1,
-                    y=var2,
-                    colorscale="Viridis",
-                    contours=dict(coloring="heatmap")
-                ),
-                name=f"{time:.2f}"
-            ))
-
-        fig.frames = frames
-
-        # Configurar el slider
-        sliders = [
-            dict(
-                steps=[
-                    dict(
-                        method="animate",
-                        args=[[f"{time:.2f}"], dict(mode="immediate", frame=dict(duration=150, redraw=True), transition=dict(duration=0))],
-                        label=f"{time:.2f}"
-                    )
-                    for time in time_array
-                ],
-                transition=dict(duration=0),
-                currentvalue=dict(font=dict(size=16), prefix="Tiempo: ", visible=True),
-                len=0.9
-            )
-        ]
-
-        # Configurar los botones de reproducción y pausa
-        updatemenus = [
-            dict(
-                type="buttons",
-                showactive=False,
-                buttons=[
-                    dict(label="Play",
-                        method="animate",
-                        args=[None, dict(frame=dict(duration=100, redraw=True), fromcurrent=True)]),
-                    dict(label="Pause",
-                        method="animate",
-                        args=[[None], dict(frame=dict(duration=0, redraw=False), mode="immediate")])
-                ]
-            )
-        ]
-
-        # Actualizar el diseño de la figura
-        fig.update_layout(
-            title="Evolución del Campo de Velocidad",
-            xaxis_title='r [AU]',
-            yaxis_title=y_label,
-            width=600,
-            height=600,
-            sliders=sliders,
-            updatemenus=updatemenus
-        )
-
-        # Mostrar la animación
-        fig.show()
-
-    def vel_streamlines(self, var1_min, var1_max, var2_min, var2_max, res, time):
-        """
-        Grafica las streamlines del campo de velocidad con la densidad de fondo para un tiempo dado.
-        """
-        # Crear una cuadrícula regular para las coordenadas
-        var1 = np.linspace(var1_min, var1_max, res)
-        var2 = np.linspace(var2_min, var2_max, res)
-        VAR1, VAR2 = np.meshgrid(var1, var2, indexing='ij')
-
-        # Interpolar el campo de densidad y velocidad en el tiempo dado
-        density = self.data_handler.interpolate_density(time, VAR1, VAR2)
-        velocity_x, velocity_y = self.data_handler.interpolate_velocity(time, VAR1, VAR2)
-
-        # Calcular la magnitud de la velocidad
-        v_mag = np.sqrt(velocity_x**2 + velocity_y**2).T * self.data_handler.sim.UV / (1e5)  # Convertir a km/s
-
-        # Determinar el label del eje y en función del plano
-        plane = self.data_handler.plane
-        y_label = "Z [AU]" if plane == "XZ" else r"$\phi$ [rad]"
-
-        # Crear el gráfico
-        plt.figure(figsize=(6, 6))
-        plt.pcolormesh(var1, var2, np.log10(density * self.data_handler.sim.URHO * 1e3).T, cmap="Spectral_r", shading='auto')
-        plt.streamplot(var1, var2, velocity_x.T, velocity_y.T, color=v_mag, linewidth=0.7, density=3.0, cmap='viridis')
-        plt.colorbar(label="|v| [km/s]")
-        plt.title(f"Streamlines (t = {time:.2f})")
-        plt.xlabel("r [AU]")
-        plt.ylabel(y_label)
-        plt.show()          
-
-    def vel_streamlines_slide(self, var1_min, var1_max, var2_min, var2_max, res, time_array):
-
-        # Crear una cuadrícula regular para las coordenadas
-        var1 = np.linspace(var1_min, var1_max, res)
-        var2 = np.linspace(var2_min, var2_max, res)
-        VAR1, VAR2 = np.meshgrid(var1, var2, indexing='ij')
-            # Determinar el label del eje y en función del plano
-        plane = self.data_handler.plane
-        y_label = "Z [AU]" if plane == "XZ" else r"$\phi$ [rad]"
-
-        # Precalcular densidad y velocidades para todos los tiempos
-        precalculated_data = [
-            {
-                "density": self.data_handler.interpolate_density(time, VAR1, VAR2),
-                "velocity": self.data_handler.interpolate_velocity(time, VAR1, VAR2)
-            }
-            for time in time_array
-        ]
-
-        def update_plot(time_index):
-            """
-            Actualiza el gráfico para un índice de tiempo dado.
-            """
-            data = precalculated_data[time_index]
-            density = data["density"]
-            velocity_x = data["velocity"][0]
-            velocity_y = data["velocity"][1]
-            v_mag = np.sqrt(velocity_x**2 + velocity_y**2).T*self.data_handler.sim.UV/(1e5)  
-            # Crear el gráfico
-            plt.figure(figsize=(6, 6))
-            plt.pcolormesh(var1, var2, np.log10(density * self.data_handler.sim.URHO * 1e3).T, cmap="Spectral_r", shading='auto')
-            plt.streamplot(var1, var2, velocity_x.T, velocity_y.T, color=v_mag, linewidth=0.7, density=3.0,cmap='viridis')
-            plt.colorbar(label="|v| [km/s]")
-            plt.title(f"Streamlines (t = {time_array[time_index]:.2f})")
-            plt.xlabel("r [AU]")
-            plt.ylabel(y_label)
-            plt.show()
-
-        # Crear un slider interactivo para el tiempo (con índices enteros)
-        interact(update_plot, time_index=IntSlider(value=0, min=0, max=len(time_array) - 1, step=1))
-
-        
-    def vel_streamlines_vid(self, var1_min, var1_max, var2_min, var2_max, res, time_array,output_file="streamlines_animation.mp4"):
-
-        # Crear una cuadrícula regular para las coordenadas
-        var1 = np.linspace(var1_min, var1_max, res)
-        var2 = np.linspace(var2_min, var2_max, res)
-        VAR1, VAR2 = np.meshgrid(var1, var2, indexing='ij')
-            # Determinar el label del eje y en función del plano
-        plane = self.data_handler.plane
-        y_label = "Z [AU]" if plane == "XZ" else r"$\phi$ [rad]"
-
-        # Configurar la figura y la cámara para la animación
-        fig, ax = plt.subplots(figsize=(6, 6))
-        camera = Camera(fig)
-
-        # Generar los frames de la animación
-        for time in time_array:
-            # Interpolar el campo de densidad y velocidad
-            density = self.data_handler.interpolate_density(time, VAR1, VAR2)
-            velocity_x, velocity_y = self.data_handler.interpolate_velocity(time, VAR1, VAR2)
-            v_mag = np.sqrt(velocity_x**2 + velocity_y**2).T*self.data_handler.sim.UV/(1e5) 
-            
-            # Crear el gráfico para el frame actual
-            c = ax.pcolormesh(var1, var2, np.log10(density * self.data_handler.sim.URHO * 1e3).T, cmap="Spectral_r", shading='auto')
-            strm=ax.streamplot(var1, var2, velocity_x.T, velocity_y.T, color=v_mag, linewidth=0.7, density=3.0,cmap='viridis')
-            ax.set_xlabel("r [AU]")
-            ax.set_ylabel(y_label)
-            camera.snap()
-            
-
-        # Crear la animación
-        fig.colorbar(strm.lines, ax=ax, label="|v| [km/s]")
-        plt.close(fig)
-        animation = camera.animate()
-
-
-        # Guardar la animación en un archivo
-        animation.save(output_file, writer="ffmpeg", fps=10)
-
-        plt.close(fig)
-        return Video(output_file, embed=True)
-