Second update

.gitattributes

@@ -33,3 +33,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+Placeholder_Images/*.stl filter=lfs diff=lfs merge=lfs -text
+Placeholder_Images/*.gif filter=lfs diff=lfs merge=lfs -text

Placeholder_Images/gaussian.stl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e2d745eb9141c1a86e48dff2c4e08aa197bc60ff4103d41f9595b6da6c1b9ef2
+size 3960184

Placeholder_Images/gaussian_fluid.stl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d4d4eb92f2a9391b46704ec3094909ecd889d9429b596e772005e9eb267e5ad2
+size 242884

Placeholder_Images/gaussian_surface.stl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b5d4a636efb5ba15d4e0aee8b7a0b1321f1ae134ceadff70f4e586952a7ef507
+size 242884

Placeholder_Images/sinusoidal.stl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:33fa8d72c4dc9b96372194663b81da3da4fe66236def23b6eb7a6de9ce986b31
+size 3960184

Placeholder_Images/sinusoidal_fluid.stl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8eacd3635c25b0e6127cd3b6f1bea965c7477ea05536c17281eda08b3ce78822
+size 392084

Placeholder_Images/sinusoidal_surface.stl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f81ac68f7b3755fc4a9a339e0c8a5d904ddd7fb940f7071f82bfa123204fe5c3
+size 392084

app.py

@@ -27,41 +27,6 @@ def qlbm_gradio_interface(grid_size_input: int, time_steps_input: int, distribut
         return None, None # Modified return
     return plot_fig, plotly_json_frames # Modified return
 
-def qlbm_3D_gradio_interface(grid_size_input: int, time_steps_input: int, distribution_type_param: str, vx_param, vy_param, vz_param, boundary_condition_param: str):
-    num_reg_qubits_val = int(math.log2(grid_size_input)) # Convert grid_size back to num_reg_qubits
-    grid_size_val = grid_size_input
-    time_steps_val = int(time_steps_input)
-
-    vx_val = str(vx_param)
-    vy_val = str(vy_param)
-    vz_val = str(vz_param)
-
-    x_sym, y_sym, z_sym = symbols('x y z')
-    vx_sympified = sympify(vx_val)
-    vy_sympified = sympify(vy_val)
-    vz_sympified = sympify(vz_val)
-
-    vx = lambdify((x_sym, y_sym, z_sym), vx_sympified, modules="numpy")
-    vy = lambdify((x_sym, y_sym, z_sym), vy_sympified, modules="numpy")
-    vz = lambdify((x_sym, y_sym, z_sym), vz_sympified, modules="numpy")
-
-    print(f"Gradio Interface: Qubits/Direction={num_reg_qubits_val}, Grid Size={grid_size_val}, T={time_steps_val}, Distribution={distribution_type_param}, vx={vx_val}, vy={vy_val}, vz={vz_val}, Boundary={boundary_condition_param}")
-
-    plot_fig, plotly_json_frames = simulate_qlbm_3D_and_animate( # Modified to unpack two return values
-        num_reg_qubits=num_reg_qubits_val,
-        T=time_steps_val,
-        distribution_type=distribution_type_param,
-        vx_input=vx,
-        vy_input=vy,
-        vz_input=vz,
-        boundary_condition=boundary_condition_param
-    )
-
-    if plot_fig is None:
-        gr.Warning("Simulation or plotting failed. Please check console for errors.")
-        return None, None # Modified return
-    return plot_fig, plotly_json_frames # Modified return
-
 # New functions for downloading Plotly objects
 def download_plot_data(plotly_json_frames):
     if not plotly_json_frames:
@@ -98,32 +63,13 @@ def update_qubit_info(grid_size):
 
     return fig, total_qubits_display, warning, recommended_display
 
-def update_qubit_3D_info(grid_size):
-    num_reg_qubits = int(math.log2(grid_size))
-    total_qubits = 3 * num_reg_qubits + 3
-    grid_display = f"Grid Size: {grid_size} × {grid_size} × {grid_size}"
-
-    x = np.array([16, 32, 64, 128, 256])
-    y = np.log2(x).astype(int)
-    fig = go.Figure()
-    fig.add_trace(go.Scatter(x=x, y=y, mode='lines', name='Qubits/Direction'))
-    fig.add_trace(go.Scatter(x=[grid_size], y=[num_reg_qubits], mode='markers', marker=dict(size=12, color='red'), name='Current Selection'))
-    fig.update_layout(
-        xaxis_title="Grid Size (Points/Direction)",
-        yaxis_title="Qubits/Direction",
-        width=400,
-        height=300
-    )
-    warning = "⚠️ Warning: Grid sizes > 64 may exceed simulator/memory limits!" if grid_size > 64 else ""
-    return fig, grid_display, warning
-
 # Modified example functions to set grid_size
 def set_sinusoidal_example():
     return (
         gr.update(value=256),  # grid_size = 256 (corresponds to 8 qubits)
         gr.update(value=1600),  # time_steps
         gr.update(value="Sinusoidal"),  # distribution_type
-        gr.update(value="User"),  # velocity_field
+        gr.update(value="Uniform"),  # velocity_field
         gr.update(value=0.2),  # vx
         gr.update(value=0.15),  # vy
         gr.update(value="Periodic"),  # boundary_condition
@@ -134,247 +80,87 @@ def set_gaussian_example():
         gr.update(value=256),  # grid_size = 256 (corresponds to 8 qubits)
         gr.update(value=1600),  # time_steps
         gr.update(value="Gaussian"),  # distribution_type
-        gr.update(value="User"),  # velocity_field
+        gr.update(value="Uniform"),  # velocity_field
         gr.update(value=0.2),  # vx
         gr.update(value=0.15),  # vy
         gr.update(value="Periodic"),  # boundary_condition
     )
 
-def set_sinusoidal_3d_example():
-    return (
-        gr.update(value=32),  # grid_size = 32 (corresponds to 5 qubits)
-        gr.update(value=100),  # time_steps
-        gr.update(value="Sinusoidal"),  # distribution_type
-        gr.update(value="0.2"),  # vx
-        gr.update(value="-0.15"),  # vy
-        gr.update(value="0.3"),  # vz
-        gr.update(value="Periodic"),  # boundary_condition
-    )
-
-def set_gaussian_3d_example():
-    return (
-        gr.update(value=32),  # grid_size = 32 (corresponds to 5 qubits)
-        gr.update(value=100),  # time_steps
-        gr.update(value="Gaussian"),  # distribution_type
-        gr.update(value="0.2"),  # vx
-        gr.update(value="-0.15"),  # vy
-        gr.update(value="0.3"),  # vz
-        gr.update(value="Periodic"),  # boundary_condition
-    )
-
-# Gradio interface with modified layout and slider
-with gr.Blocks(theme=gr.themes.Soft(), title="Quantum Simulation Demo") as demo:
-    problem_type = gr.Radio(
-        choices=["Fluid Dynamics", "EM", "Mechanical"],
-        value="Fluid Dynamics",
-        label="Select Problem Type"
-    )
-
-    with gr.Tabs() as tabs:
-        with gr.TabItem("Fluid Dynamics - 2D", visible=True) as fluid_tab_2D:
-            with gr.Row(): # Main row for top section
-                with gr.Column(scale=1): # Column for left-side controls
-                    gr.Markdown("## Initial Distribution Examples")
-                    with gr.Row():
-                        with gr.Column(scale=1):
-                            example1 = LitModel3D("Placeholder_Images/sinusoidal.stl", label="Sinusoidal")
-                            sinusoidal_btn_2d = gr.Button("Sinusoidal")
-                        with gr.Column(scale=1):
-                            example2 = LitModel3D("Placeholder_Images/gaussian.stl", label="Gaussian")
-                            gaussian_btn_2d = gr.Button("Gaussian")
-
-                    gr.Markdown("## Simulation Parameters")
-                    num_reg_qubits_input_2d = gr.Slider(
-                        minimum=2**7, maximum=2**12, # Grid size values
-                        value=2**8, step=None, # step=None for arbitrary powers of 2 (handled by update function)
-                        label="Grid Size/Direction"
-                    )
-                    time_steps_slider_2d = gr.Slider(minimum=0, maximum=4000, value=1600, step=10, label="Time Steps")
-                    qubit_plot_2d = gr.Plot(label="Qubits vs. Grid Size")
-                    total_qubits_display_2d = gr.Markdown("Total Qubits: 19")
-                    warning_display_2d = gr.Markdown("")
-                    recommended_time_steps_display_2d = gr.Markdown("Recommended time steps: 1600")
-
-                with gr.Column(scale=2): # Column for the main plot
-                    qlbm_interactive_plot_2d = gr.Plot(label="QLBM")
-                    download_button_2d = gr.DownloadButton(label="Download Plot Data (JSON)", visible=False) # New download button
-                    plotly_json_frames_state_2d = gr.State([]) # New state to store Plotly JSON frames
-
-            with gr.Row(): # Row for bottom section
+# Gradio interface for Fluid Dynamics - 2D only
+with gr.Blocks(theme=gr.themes.Soft(), title="QLBM Fluid Simulation (2D)") as demo:
+    with gr.Row(): # Main row for top section
+        with gr.Column(scale=1): # Column for left-side controls
+            gr.Markdown("## Initial Distribution Examples")
+            with gr.Row():
                 with gr.Column(scale=1):
-                    gr.Markdown("## Initialization")
-                    with gr.Row():
-                        shear_btn_2d = gr.Button("Shear")
-                        tgv_btn_2d = gr.Button("TGV")
-                    with gr.Row():
-                        swirl_btn_2d = gr.Button("Swirl")
-                        user_btn_2d = gr.Button("User")
-                    selected_velocity_field_2d = gr.State("User")
-                    vx_slider_2d = gr.Slider(minimum=-0.3, maximum=0.3, value=0.2, step=0.01, label="V_x", visible=True)
-                    vy_slider_2d = gr.Slider(minimum=-0.3, maximum=0.3, value=0.15, step=0.01, label="V_y", visible=True)
-                    distribution_type_input_2d = gr.Radio(choices=["Gaussian", "Sinusoidal", "Random"], value="Sinusoidal", label="Initial Distribution Type")
-
+                    example1 = LitModel3D("Placeholder_Images/sinusoidal.stl", label="Sinusoidal")
+                    sinusoidal_btn_2d = gr.Button("Sinusoidal")
                 with gr.Column(scale=1):
-                    gr.Markdown("## Boundary Conditions")
-                    boundary_condition_input_2d = gr.Radio(choices=["Periodic", "Dirichlet", "Neumann"], value="Periodic", label="Boundary Condition")
-
-            run_qlbm_btn_2d = gr.Button("Run Simulation", variant="primary") # Button below the sections
-
-            qlbm_inputs_list_2d = [
-                num_reg_qubits_input_2d, time_steps_slider_2d, distribution_type_input_2d,
-                selected_velocity_field_2d, vx_slider_2d, vy_slider_2d, boundary_condition_input_2d
-            ]
-            run_qlbm_btn_2d.click(
-                fn=qlbm_gradio_interface,
-                inputs=qlbm_inputs_list_2d,
-                outputs=[qlbm_interactive_plot_2d, plotly_json_frames_state_2d] # Modified output
-            ).then(
-                lambda: gr.update(visible=True), # Make download button visible after simulation
-                outputs=[download_button_2d]
+                    example2 = LitModel3D("Placeholder_Images/gaussian.stl", label="Gaussian")
+                    gaussian_btn_2d = gr.Button("Gaussian")
+
+            gr.Markdown("## Simulation Parameters")
+            num_reg_qubits_input_2d = gr.Slider(
+                minimum=2**7, maximum=2**12, # Grid size values
+                value=2**8, step=None, # step=None for arbitrary powers of 2 (handled by update function)
+                label="Grid Size/Direction"
             )
-            download_button_2d.click(
-                fn=download_plot_data,
-                inputs=[plotly_json_frames_state_2d],
-                outputs=[download_button_2d]
-            )
-            num_reg_qubits_input_2d.change(
-                fn=update_qubit_info,
-                inputs=num_reg_qubits_input_2d,
-                outputs=[qubit_plot_2d, total_qubits_display_2d, warning_display_2d, recommended_time_steps_display_2d]
-            )
-            sinusoidal_btn_2d.click(
-                fn=set_sinusoidal_example,
-                inputs=[],
-                outputs=[num_reg_qubits_input_2d, time_steps_slider_2d, distribution_type_input_2d, selected_velocity_field_2d, vx_slider_2d, vy_slider_2d, boundary_condition_input_2d]
-            )
-            gaussian_btn_2d.click(
-                fn=set_gaussian_example,
-                inputs=[],
-                outputs=[num_reg_qubits_input_2d, time_steps_slider_2d, distribution_type_input_2d, selected_velocity_field_2d, vx_slider_2d, vy_slider_2d, boundary_condition_input_2d]
-            )
-
-            def update_velocity_sliders_2d_from_button(velocity_type):
-                return velocity_type, gr.update(visible=velocity_type == "User"), gr.update(visible=velocity_type == "User")
-
-            shear_btn_2d.click(fn=lambda: update_velocity_sliders_2d_from_button("Shear"), outputs=[selected_velocity_field_2d, vx_slider_2d, vy_slider_2d])
-            tgv_btn_2d.click(fn=lambda: update_velocity_sliders_2d_from_button("TGV"), outputs=[selected_velocity_field_2d, vx_slider_2d, vy_slider_2d])
-            swirl_btn_2d.click(fn=lambda: update_velocity_sliders_2d_from_button("Swirl"), outputs=[selected_velocity_field_2d, vx_slider_2d, vy_slider_2d])
-            user_btn_2d.click(fn=lambda: update_velocity_sliders_2d_from_button("User"), outputs=[selected_velocity_field_2d, vx_slider_2d, vy_slider_2d])
-
-        with gr.TabItem("Fluid Dynamics - 3D", visible=True) as fluid_tab_3D:
-            with gr.Row(): # Main row for top section
-                with gr.Column(scale=1): # Column for left-side controls
-                    gr.Markdown("## Initial Distribution Examples")
-                    with gr.Row():
-                        with gr.Column(scale=1):
-                            example1 = LitModel3D("Placeholder_Images/sinusoidal_fluid.stl", label="Sinusoidal")
-                            sinusoidal_3d_btn = gr.Button("Sinusoidal")
-                        with gr.Column(scale=1):
-                            example2 = LitModel3D("Placeholder_Images/gaussian_fluid.stl", label="Gaussian")
-                            gaussian_3d_btn = gr.Button("Gaussian")
-                    gr.Markdown("## Simulation Parameters")
-                    num_reg_qubits_input_3d = gr.Slider(
-                        minimum=2**4, maximum=2**8, # Grid size values
-                        value=2**5, step=None, # step=None for arbitrary powers of 2
-                        label="Grid Size/Direction"
-                    )
-                    time_steps_slider_3d = gr.Slider(minimum=0, maximum=2000, value=100, step=10, label="Time Steps")
-                    # Removed num_slider_steps_slider_3d
-                    qubit_plot_3d = gr.Plot(label="Qubits vs. Grid Size")
-                    grid_display_3d = gr.Markdown("Grid Size: 32 × 32 × 32")
-                    warning_display_3d = gr.Markdown("")
-
-                with gr.Column(scale=2): # Column for the main plot
-                    qlbm_interactive_plot_3d = gr.Plot(label="QLBM")
-                    download_button_3d = gr.DownloadButton(label="Download Plot Data (JSON)", visible=False) # New download button
-                    plotly_json_frames_state_3d = gr.State([]) # New state to store Plotly JSON frames
-
-            with gr.Row(): # Row for bottom section
-                with gr.Column(scale=1):
-                    gr.Markdown("## Initialization")
-                    with gr.Row():
-                        uniform_btn_3d = gr.Button("Uniform")
-                        swirl_btn_3d = gr.Button("Swirl")
-                    with gr.Row():
-                        shear_btn_3d = gr.Button("Shear")
-                        tgv_btn_3d = gr.Button("TGV")
-                    vx_text_input_3d = gr.Textbox(value="0.2", label="Velocity vx")
-                    vy_text_input_3d = gr.Textbox(value="-0.15", label="Velocity vy")
-                    vz_text_input_3d = gr.Textbox(value="0.3", label="Velocity vz")
-                    distribution_type_input_3d = gr.Radio(choices=["Gaussian", "Sinusoidal"], value="Sinusoidal", label="Initial Distribution Type")
-
-                with gr.Column(scale=1):
-                    gr.Markdown("## Boundary Conditions")
-                    boundary_condition_input_3d = gr.Radio(choices=["Periodic", "Dirichlet", "Neumann"], value="Periodic", label="Boundary Condition")
-
-            run_qlbm_btn_3d = gr.Button("Run Simulation", variant="primary") # Button below the sections
-
-            qlbm_inputs_list_3d = [
-                num_reg_qubits_input_3d, time_steps_slider_3d, distribution_type_input_3d,
-                vx_text_input_3d, vy_text_input_3d, vz_text_input_3d, boundary_condition_input_3d
-                # Removed num_slider_steps_slider_3d from inputs
-            ]
-            run_qlbm_btn_3d.click(
-                fn=qlbm_3D_gradio_interface,
-                inputs=qlbm_inputs_list_3d,
-                outputs=[qlbm_interactive_plot_3d, plotly_json_frames_state_3d] # Modified output
-            ).then(
-                lambda: gr.update(visible=True), # Make download button visible after simulation
-                outputs=[download_button_3d]
-            )
-            download_button_3d.click(
-                fn=download_plot_data,
-                inputs=[plotly_json_frames_state_3d],
-                outputs=[download_button_3d]
-            )
-            num_reg_qubits_input_3d.change(
-                fn=update_qubit_3D_info,
-                inputs=num_reg_qubits_input_3d,
-                outputs=[qubit_plot_3d, grid_display_3d, warning_display_3d]
-            )
-
-            sinusoidal_3d_btn.click(
-                fn=set_sinusoidal_3d_example,
-                inputs=[],
-                outputs=[num_reg_qubits_input_3d, time_steps_slider_3d, distribution_type_input_3d, vx_text_input_3d, vy_text_input_3d, vz_text_input_3d, boundary_condition_input_3d]
-            )
-            gaussian_3d_btn.click(
-                fn=set_gaussian_3d_example,
-                inputs=[],
-                outputs=[num_reg_qubits_input_3d, time_steps_slider_3d, distribution_type_input_3d, vx_text_input_3d, vy_text_input_3d, vz_text_input_3d, boundary_condition_input_3d]
-            )
-
-            def update_velocity_entries_3d(val):
-                fieldname_to_index = {"Uniform": 0, "Swirl": 1, "Shear": 2, "TGV": 3}
-                selection = fieldname_to_index[val]
-                return (
-                    gr.update(value=(["0.2", "0.3*sin(-2*pi*z)", "abs(z-0.5)*1.2-0.3", "0.15*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z)"])[selection]),
-                    gr.update(value=(["-0.15", "0.2", "0", "-0.3*sin(2*pi*x)*cos(2*pi*y)*sin(2*pi*z)"])[selection]),
-                    gr.update(value=(["0.3", "0.3*sin(2*pi*x)", "0", "0.15*sin(2*pi*x)*sin(2*pi*y)*cos(2*pi*z)"])[selection])
-                )
-
-            uniform_btn_3d.click(fn=lambda: update_velocity_entries_3d("Uniform"), outputs=[vx_text_input_3d, vy_text_input_3d, vz_text_input_3d])
-            swirl_btn_3d.click(fn=lambda: update_velocity_entries_3d("Swirl"), outputs=[vx_text_input_3d, vy_text_input_3d, vz_text_input_3d])
-            shear_btn_3d.click(fn=lambda: update_velocity_entries_3d("Shear"), outputs=[vx_text_input_3d, vy_text_input_3d, vz_text_input_3d])
-            tgv_btn_3d.click(fn=lambda: update_velocity_entries_3d("TGV"), outputs=[vx_text_input_3d, vy_text_input_3d, vz_text_input_3d])
-
-        with gr.TabItem("EM", visible=False) as em_tab:
-            gr.Markdown("## Coming Soon")
-        with gr.TabItem("Mechanical", visible=False) as mech_tab:
-            gr.Markdown("## Coming Soon")
-
-    def update_tabs(selection):
-        return (
-            gr.update(visible=selection == "Fluid Dynamics"),
-            gr.update(visible=selection == "Fluid Dynamics"),
-            gr.update(visible=selection == "EM"),
-            gr.update(visible=selection == "Mechanical")
-        )
-
-    problem_type.change(
-        fn=update_tabs,
-        inputs=problem_type,
-        outputs=[fluid_tab_2D, fluid_tab_3D, em_tab, mech_tab]
+            time_steps_slider_2d = gr.Slider(minimum=0, maximum=4000, value=1600, step=10, label="Time Steps")
+            qubit_plot_2d = gr.Plot(label="Qubits vs. Grid Size")
+            total_qubits_display_2d = gr.Markdown("Total Qubits: 19")
+            warning_display_2d = gr.Markdown("")
+            recommended_time_steps_display_2d = gr.Markdown("Recommended time steps: 1600")
+
+        with gr.Column(scale=2): # Column for the main plot
+            qlbm_interactive_plot_2d = gr.Plot(label="QLBM")
+            download_button_2d = gr.DownloadButton(label="Download Plot Data (JSON)", visible=False) # New download button
+            plotly_json_frames_state_2d = gr.State([]) # New state to store Plotly JSON frames
+
+    with gr.Row(): # Row for bottom section
+        with gr.Column(scale=1):
+            gr.Markdown("## Initialization (Uniform)")
+            selected_velocity_field_2d = gr.State("Uniform")
+            vx_slider_2d = gr.Slider(minimum=-0.3, maximum=0.3, value=0.2, step=0.01, label="V_x", visible=True)
+            vy_slider_2d = gr.Slider(minimum=-0.3, maximum=0.3, value=0.15, step=0.01, label="V_y", visible=True)
+            distribution_type_input_2d = gr.Radio(choices=["Gaussian", "Sinusoidal"], value="Sinusoidal", label="Initial Distribution Type")
+
+        with gr.Column(scale=1):
+            gr.Markdown("## Boundary Conditions")
+            boundary_condition_input_2d = gr.Radio(choices=["Periodic"], value="Periodic", label="Boundary Condition")
+
+    run_qlbm_btn_2d = gr.Button("Run Simulation", variant="primary") # Button below the sections
+
+    qlbm_inputs_list_2d = [
+        num_reg_qubits_input_2d, time_steps_slider_2d, distribution_type_input_2d,
+        selected_velocity_field_2d, vx_slider_2d, vy_slider_2d, boundary_condition_input_2d
+    ]
+    run_qlbm_btn_2d.click(
+        fn=qlbm_gradio_interface,
+        inputs=qlbm_inputs_list_2d,
+        outputs=[qlbm_interactive_plot_2d, plotly_json_frames_state_2d] # Modified output
+    ).then(
+        lambda: gr.update(visible=True), # Make download button visible after simulation
+        outputs=[download_button_2d]
+    )
+    download_button_2d.click(
+        fn=download_plot_data,
+        inputs=[plotly_json_frames_state_2d],
+        outputs=[download_button_2d]
+    )
+    num_reg_qubits_input_2d.change(
+        fn=update_qubit_info,
+        inputs=num_reg_qubits_input_2d,
+        outputs=[qubit_plot_2d, total_qubits_display_2d, warning_display_2d, recommended_time_steps_display_2d]
+    )
+    sinusoidal_btn_2d.click(
+        fn=set_sinusoidal_example,
+        inputs=[],
+        outputs=[num_reg_qubits_input_2d, time_steps_slider_2d, distribution_type_input_2d, selected_velocity_field_2d, vx_slider_2d, vy_slider_2d, boundary_condition_input_2d]
+    )
+    gaussian_btn_2d.click(
+        fn=set_gaussian_example,
+        inputs=[],
+        outputs=[num_reg_qubits_input_2d, time_steps_slider_2d, distribution_type_input_2d, selected_velocity_field_2d, vx_slider_2d, vy_slider_2d, boundary_condition_input_2d]
     )
 
 if __name__ == "__main__":

fluid.py

@@ -149,10 +149,6 @@ def simulate_qlbm_and_animate(num_reg_qubits: int, T: int, distribution_type: st
         selected_initial_state_function_raw = lambda x, y, N_val_func: \
             np.exp(-((x - N_val_func / 2)**2 / (2 * (N_val_func / 5)**2) +
                      (y - N_val_func / 2)**2 / (2 * (N_val_func / 5)**2))) * 1.8 + 0.2
-    elif distribution_type == "Random":
-        selected_initial_state_function_raw = lambda x, y, N_val_func: \
-            np.random.rand(N_val_func, N_val_func) * 1.5 + 0.2 if isinstance(x, int) else \
-            np.random.rand(x.shape[0], x.shape[1]) * 1.5 + 0.2
     else:
         print(f"Warning: Unknown distribution type '{distribution_type}'. Defaulting to Sinusoidal.")
         selected_initial_state_function_raw = lambda x, y, N_val_func: \
@@ -163,16 +159,8 @@ def simulate_qlbm_and_animate(num_reg_qubits: int, T: int, distribution_type: st
         selected_initial_state_function_raw(x_coords, y_coords, current_N) * \
         (y_coords < current_N).astype(int)
 
-    if velocity_field == "User":
+    if velocity_field == "Uniform":
         pass
-    elif velocity_field == "Shear":
-        vx_input = vx_input * (current_N / 2)
-    elif velocity_field == "TGV":
-        vx_input = vx_input * np.sin(np.pi * current_N / 10)
-        vy_input = vy_input * np.cos(np.pi * current_N / 10)
-    elif velocity_field == "Swirl":
-        vx_input = vx_input * np.cos(np.pi * current_N / 5)
-        vy_input = vy_input * np.sin(np.pi * current_N / 5)
 
     with tempfile.TemporaryDirectory() as tmp_npy_dir:
         intermediate_folder_path = Path(tmp_npy_dir)
@@ -359,10 +347,6 @@ def simulate_qlbm_and_animate(num_reg_qubits: int, T: int, distribution_type: st
 
         if boundary_condition == "Periodic":
             pass
-        elif boundary_condition == "Dirichlet":
-            pass
-        elif boundary_condition == "Neumann":
-            pass
 
         downsampling_factor = 2**5
         if current_N == 0:
@@ -378,10 +362,7 @@ def simulate_qlbm_and_animate(num_reg_qubits: int, T: int, distribution_type: st
         yv_init = np.arange(current_N)
         initial_grid_2d_X, initial_grid_2d_Y = np.meshgrid(xv_init, yv_init)
 
-        if distribution_type == "Random":
-            initial_grid_2d = selected_initial_state_function_raw(current_N, current_N, current_N)
-        else:
-            initial_grid_2d = initial_state_func_eval(initial_grid_2d_X, initial_grid_2d_Y)
+        initial_grid_2d = initial_state_func_eval(initial_grid_2d_X, initial_grid_2d_Y)
 
         sub_sv_init_flat = initial_grid_2d.flatten().astype(np.complex128)
         norm = np.linalg.norm(sub_sv_init_flat)
@@ -456,10 +437,10 @@ def simulate_qlbm_and_animate(num_reg_qubits: int, T: int, distribution_type: st
         for i, Z in enumerate(data_frames):
             frame_trace = go.Surface(
                 z=Z, x=x_coords_plot, y=y_coords_plot,
-                colorscale='Viridis',
+                colorscale='Blues',
                 cmin=z_min, cmax=z_max,
                 name=f'Time: {actual_timesteps[i]}',
-                showscale=True
+                showscale=False
             )
             fig.add_trace(frame_trace)
             
@@ -494,537 +475,32 @@ def simulate_qlbm_and_animate(num_reg_qubits: int, T: int, distribution_type: st
 
         sliders = [dict(active=0, currentvalue={"prefix": "Time: "}, pad={"t": 50}, steps=steps)]
 
+        # fig.update_layout(
+        #     title='', # Removed graph title
+        #     scene=dict(
+        #         xaxis_title='X',
+        #         yaxis_title='Y',
+        #         zaxis_title='Density',
+        #         xaxis=dict(range=[x_coords_plot[0], x_coords_plot[-1]]),
+        #         yaxis=dict(range=[y_coords_plot[0], y_coords_plot[-1]]),
+        #         zaxis=dict(range=[z_min, z_max]),
+        #     ),
+        #     sliders=sliders,
+        #     width=800,
+        #     height=700
+        # )
         fig.update_layout(
             title='', # Removed graph title
             scene=dict(
                 xaxis_title='X',
                 yaxis_title='Y',
                 zaxis_title='Density',
-                xaxis=dict(range=[x_coords_plot[0], x_coords_plot[-1]]),
-                yaxis=dict(range=[y_coords_plot[0], y_coords_plot[-1]]),
-                zaxis=dict(range=[z_min, z_max]),
+                xaxis=dict(visible=False),
+                yaxis=dict(visible=False),
+                zaxis=dict(visible=False),
             ),
             sliders=sliders,
             width=800,
             height=700
         )
-
-        return fig, plotly_json_frames # Modified return
-
-def simulate_qlbm_3D_and_animate(num_reg_qubits: int, T: int, distribution_type: str, vx_input, vy_input, vz_input, boundary_condition: str):
-    num_anc = 3
-    num_qubits_total = 3 * num_reg_qubits + num_anc
-    current_N = 2**num_reg_qubits
-    N_tot_state_vector = 2**num_qubits_total
-    num_ranks = 1
-    rank = 0
-    N_sub_per_rank = int(N_tot_state_vector // num_ranks)
-
-    # Simplified time steps for 3D since slider steps are removed
-    NUM_ANIMATION_FRAMES_3D = 10 # Default number of frames if no specific slider steps
-
-    if T == 0:
-        time_steps = [0]
-    else:
-        num_points = min(T + 1, NUM_ANIMATION_FRAMES_3D)
-        time_steps = np.linspace(start=0, stop=T, num=num_points, dtype=int)
-        time_steps = sorted(list(set(time_steps)))
-
-
-    if distribution_type == "Sinusoidal":
-        selected_initial_state_function_raw = lambda x, y, z, N_val_func: \
-            np.sin(x * 2 * np.pi / N_val_func) * \
-            np.sin(y * 2 * np.pi / N_val_func) * \
-            np.sin(z * 2 * np.pi / N_val_func) + 1
-    elif distribution_type == "Gaussian":
-        selected_initial_state_function_raw = lambda x, y, z, N_val_func: \
-            np.exp(-((x - N_val_func / 2)**2 / (2 * (N_val_func / 5)**2) + (y - N_val_func / 2)**2 / (2 * (N_val_func / 5)**2) +
-                     (z - N_val_func / 2)**2 / (2 * (N_val_func / 5)**2))) * 1.8 + 0.2
-    else:
-        print(f"Warning: Unknown distribution type '{distribution_type}'. Defaulting to Sinusoidal.")
-        selected_initial_state_function_raw = lambda x, y, z, N_val_func: \
-            np.sin(x * 2 * np.pi / N_val_func) * \
-            np.sin(y * 2 * np.pi / N_val_func) * \
-            np.sin(z * 2 * np.pi / N_val_func) + 1
-
-    initial_state_func_eval = lambda i:\
-        selected_initial_state_function_raw(i%current_N,(i//current_N)%current_N,i//(current_N**2),current_N)*(i<(current_N**3)).astype(int)
-
-    with tempfile.TemporaryDirectory() as tmp_npy_dir:
-        intermediate_folder_path = Path(tmp_npy_dir)
-
-        cudaq.set_target('nvidia', option='fp64')
-
-        @cudaq.kernel
-        def alloc_kernel(num_qubits_alloc: int):
-            qubits = cudaq.qvector(num_qubits_alloc)
-
-        from cupy.cuda.memory import MemoryPointer, UnownedMemory
-
-        def to_cupy_array(state):
-            tensor = state.getTensor()
-            pDevice = tensor.data()
-            sizeByte = tensor.get_num_elements() * tensor.get_element_size()
-            mem = UnownedMemory(pDevice, sizeByte, owner=state)
-            memptr_obj = MemoryPointer(mem, 0)
-            cupy_array_val = cp.ndarray(tensor.get_num_elements(),
-                                      dtype=cp.complex128,
-                                      memptr=memptr_obj)
-            return cupy_array_val
-
-        class QLBMAdvecDiffD3Q7_new:
-            def __init__(self,vx,vy,vz) -> None:
-                self.dim = 3
-                self.ndir = 7
-                self.nq_dir = math.ceil(np.log2(self.ndir))
-                self.dirs=[]
-                for dir_int in range(self.ndir):
-                    if dir_int==4:
-                        dir_bin="111"
-                    else:
-                        dir_bin = f"{dir_int:b}".zfill(self.nq_dir)
-                    self.dirs.append(dir_bin)
-                self.cs = 1/np.sqrt(3)
-                self.ux = lambda x,y,z: vx(x,y,z)/self.cs**2
-                self.uy = lambda x,y,z: vy(x,y,z)/self.cs**2
-                self.uz = lambda x,y,z: vz(x,y,z)/self.cs**2
-                self.create_circuit()
-
-            def create_circuit(self):
-                print("Creating circuit")
-                x_coeffs,x_coeff_var_indices=get_circuit_inputs(lambda x,y,z: ((1+self.ux(x/current_N,y/current_N,z/current_N))/2)**0.5,num_reg_qubits,min(current_N,32))
-                y_coeffs,y_coeff_var_indices=get_circuit_inputs(lambda x,y,z: ((1+self.uy(x/current_N,y/current_N,z/current_N))/2)**0.5,num_reg_qubits,min(current_N,32))
-                z_coeffs,z_coeff_var_indices=get_circuit_inputs(lambda x,y,z: ((1+self.uz(x/current_N,y/current_N,z/current_N))/2)**0.5,num_reg_qubits,min(current_N,32))
-                x_coeffs_,x_coeff_var_indices_=get_circuit_inputs(lambda x,y,z: 0 if (1+self.ux((x-1)/current_N,y/current_N,z/current_N))==0 else \
-                                        ((1+self.ux((x-1)/current_N,y/current_N,z/current_N))/(2+self.ux((x-1)/current_N,y/current_N,z/current_N)-self.ux((x+1)/current_N,y/current_N,z/current_N)))**0.5,num_reg_qubits,min(current_N,32))
-                y_coeffs_,y_coeff_var_indices_=get_circuit_inputs(lambda x,y,z: 0 if (1+self.uy(x/current_N,(y-1)/current_N,z/current_N))==0 else \
-                                        ((1+self.uy(x/current_N,(y-1)/current_N,z/current_N))/(2+self.uy(x/current_N,(y-1)/current_N,z/current_N)-self.uy(x/current_N,(y+1)/current_N,z/current_N)))**0.5,num_reg_qubits,min(current_N,32))
-                z_coeffs_,z_coeff_var_indices_=get_circuit_inputs(lambda x,y,z: 0 if (1+self.uz(x/current_N,y/current_N,(z-1)/current_N))==0 else \
-                                        ((1+self.uz(x/current_N,y/current_N,(z-1)/current_N))/(2+self.uz(x/current_N,y/current_N,(z-1)/current_N)-self.uz(x/current_N,y/current_N,(z+1)/current_N)))**0.5,num_reg_qubits,min(current_N,32))
-                unprep1_coeffs,unprep1_coeff_var_indices=get_circuit_inputs(lambda x,y,z:\
-                                        (1/3**0.5)*(1+(self.ux((x-1)/current_N,y/current_N,z/current_N)-self.ux((x+1)/current_N,y/current_N,z/current_N))/2)**0.5,num_reg_qubits,min(current_N,32))
-                unprep2_coeffs, unprep2_coeff_var_indices = get_circuit_inputs(lambda x, y, z: ((1 + (self.uy(x/current_N, (y-1)/current_N, z/current_N) - self.uy(x/current_N, (y+1)/current_N, z/current_N))/2) /(2 - (self.ux((x-1)/current_N, y/current_N, z/current_N) - self.ux((x+1)/current_N, y/current_N, z/current_N))/2))**0.5, num_reg_qubits, min(current_N, 32))
-                print("Generated angles")
-                v=np.pad([1/4, 1/4, 0, 1/4, 0, 1/4, 0],(0,2**num_anc - self.ndir))
-                v=v**0.5
-                v[0]+=1
-                v=v/np.linalg.norm(v)
-                U_prep=2*np.outer(v,v)-np.eye(len(v))
-                cudaq.register_operation("prep_op", U_prep)
-                def collisionOp(dirs):
-                    dirs_i_list=[]
-                    for dir_ in dirs:
-                        dirs_i=[(int(c)) for c in dir_]
-                        dirs_i_list+=dirs_i[::-1]
-                    return dirs_i_list
-                self.dirs_i_list=collisionOp(self.dirs)
-                print("Generated dirs_i_list")
-                @cudaq.kernel
-                def rshift(q: cudaq.qview, n: int):
-                    for i in range(n):
-                        if i == n-1:
-                            x(q[n-1-i])
-                        elif i == n-2:
-                            x.ctrl(q[n-1-(i+1)], q[n-1-i])
-                        else:
-                            x.ctrl(q[0:n-1-i], q[n-1-i])
-                @cudaq.kernel
-                def lshift(q: cudaq.qview, n: int):
-                    for i in range(n):
-                        if i == 0:
-                            x(q[0])
-                        elif i == 1:
-                            x.ctrl(q[0], q[1])
-                        else:
-                            x.ctrl(q[0:i], q[i])
-                @cudaq.kernel
-                def d2q5_tstep(q: cudaq.qview, nqx: int, nqy: int, nqz: int, nq_dir: int, dirs_i: list[int]):
-                    qx=q[0:nqx]
-                    qy=q[nqx:nqx+nqy]
-                    qz=q[nqx+nqy:nqx+nqy+nqz]
-                    qdir=q[nqx+nqy+nqz:nqx+nqy+nqz+nq_dir]
-                    i=2
-                    b_list=dirs_i[i*nq_dir:(i+1)*nq_dir]
-                    for j in range(nq_dir):
-                        b=b_list[j]
-                        if b==0:
-                            x(qdir[j])
-                    cudaq.control(lshift,qdir,qx,nqx)
-                    for j in range(nq_dir):
-                        b=b_list[j]
-                        if b==0:
-                            x(qdir[j])
-                    i=1
-                    b_list=dirs_i[i*nq_dir:(i+1)*nq_dir]
-                    for j in range(nq_dir):
-                        b=b_list[j]
-                        if b==0:
-                            x(qdir[j])
-                    cudaq.control(rshift,qdir,qx,nqx)
-                    for j in range(nq_dir):
-                        b=b_list[j]
-                        if b==0:
-                            x(qdir[j])
-                    i=4
-                    b_list=dirs_i[i*nq_dir:(i+1)*nq_dir]
-                    for j in range(nq_dir):
-                        b=b_list[j]
-                        if b==0:
-                            x(qdir[j])
-                    cudaq.control(lshift,qdir,qy,nqy)
-                    for j in range(nq_dir):
-                        b=b_list[j]
-                        if b==0:
-                            x(qdir[j])
-                    i=3
-                    b_list=dirs_i[i*nq_dir:(i+1)*nq_dir]
-                    for j in range(nq_dir):
-                        b=b_list[j]
-                        if b==0:
-                            x(qdir[j])
-                    cudaq.control(rshift,qdir,qy,nqy)
-                    for j in range(nq_dir):
-                        b=b_list[j]
-                        if b==0:
-                            x(qdir[j])
-                    i=6
-                    b_list=dirs_i[i*nq_dir:(i+1)*nq_dir]
-                    for j in range(nq_dir):
-                        b=b_list[j]
-                        if b==0:
-                            x(qdir[j])
-                    cudaq.control(lshift,qdir,qz,nqz)
-                    for j in range(nq_dir):
-                        b=b_list[j]
-                        if b==0:
-                            x(qdir[j])
-                    i=5
-                    b_list=dirs_i[i*nq_dir:(i+1)*nq_dir]
-                    for j in range(nq_dir):
-                        b=b_list[j]
-                        if b==0:
-                            x(qdir[j])
-                    cudaq.control(rshift,qdir,qz,nqz)
-                    for j in range(nq_dir):
-                        b=b_list[j]
-                        if b==0:
-                            x(qdir[j])
-                @cudaq.kernel
-                def d2q5_tstep_wrapper(state: cudaq.State,nqx:int,nqy:int,nqz:int,nq_dir:int,dirs_i:list[int],\
-                                    x_coeff_var_indices:list[int],x_coeffs:list[float],\
-                                    y_coeff_var_indices:list[int],y_coeffs:list[float],\
-                                    z_coeff_var_indices:list[int],z_coeffs:list[float],\
-                                    x_coeff_var_indices_:list[int],x_coeffs_:list[float],\
-                                    y_coeff_var_indices_:list[int],y_coeffs_:list[float],\
-                                    z_coeff_var_indices_:list[int],z_coeffs_:list[float],\
-                                    unprep1_coeff_var_indices:list[int],unprep1_coeffs:list[float],\
-                                    unprep2_coeff_var_indices:list[int],unprep2_coeffs:list[float]):
-                    q=cudaq.qvector(state)
-                    qdir=q[nqx+nqy+nqz:nqx+nqy+nqz+nq_dir]
-                    prep_op(qdir[2],qdir[1],qdir[0])
-                    x.ctrl(qdir[0],qdir[1])
-                    ind=0
-                    coeff_ind=0
-                    x(qdir[2])
-                    while ind<len(x_coeff_var_indices):
-                        tuple_length=x_coeff_var_indices[ind]
-                        for sub_ind in range(ind+1, ind+1+tuple_length):
-                            x.ctrl(q[nqx+nqy+nqz-1-x_coeff_var_indices[sub_ind]],qdir[0])
-                        ry.ctrl(-x_coeffs[coeff_ind],[qdir[2],qdir[1]],qdir[0])
-                        coeff_ind+=1
-                        ind+=(1+tuple_length)
-                    x(qdir[2])
-                    ind=0
-                    coeff_ind=0
-                    while ind<len(z_coeff_var_indices):
-                        tuple_length=z_coeff_var_indices[ind]
-                        for sub_ind in range(ind+1,ind+1+tuple_length):
-                            x.ctrl(q[nqx+nqy+nqz-1-z_coeff_var_indices[sub_ind]],qdir[0])
-                        ry.ctrl(-z_coeffs[coeff_ind],[qdir[2],qdir[1]],qdir[0])
-                        coeff_ind+=1
-                        ind+=(1+tuple_length)
-                    x.ctrl(qdir[0],qdir[1])
-                    ind=0
-                    coeff_ind=0
-                    while ind<len(y_coeff_var_indices):
-                        tuple_length=y_coeff_var_indices[ind]
-                        for sub_ind in range(ind+1,ind+1+tuple_length):
-                            x.ctrl(q[nqx+nqy+nqz-1-y_coeff_var_indices[sub_ind]],qdir[2])
-                        ry.ctrl(y_coeffs[coeff_ind],[qdir[0],qdir[1]],qdir[2])
-                        coeff_ind+=1
-                        ind+=(1+tuple_length)
-                    d2q5_tstep(q,nqx,nqy,nqz,nq_dir,dirs_i)
-                    ind=0
-                    coeff_ind=0
-                    while ind<len(y_coeff_var_indices_):
-                        tuple_length=y_coeff_var_indices_[ind]
-                        for sub_ind in range(ind+1,ind+1+tuple_length):
-                            x.ctrl(q[nqx+nqy+nqz-1-y_coeff_var_indices_[sub_ind]],qdir[2])
-                        ry.ctrl(-y_coeffs_[coeff_ind],[qdir[0],qdir[1]],qdir[2])
-                        coeff_ind+=1
-                        ind+=(1+tuple_length)
-                    x.ctrl(qdir[0],qdir[1])
-                    ind=0
-                    coeff_ind=0
-                    x(qdir[2])
-                    while ind<len(x_coeff_var_indices_):
-                        tuple_length=x_coeff_var_indices_[ind]
-                        for sub_ind in range(ind+1,ind+1+tuple_length):
-                            x.ctrl(q[nqx+nqy+nqz-1-x_coeff_var_indices_[sub_ind]],qdir[0])
-                        ry.ctrl(x_coeffs_[coeff_ind],[qdir[1],qdir[2]],qdir[0])
-                        coeff_ind+=1
-                        ind+=(1+tuple_length)
-                    x(qdir[2])
-                    ind=0
-                    coeff_ind=0
-                    while ind<len(z_coeff_var_indices_):
-                        tuple_length=z_coeff_var_indices_[ind]
-                        for sub_ind in range(ind+1,ind+1+tuple_length):
-                            x.ctrl(q[nqx+nqy+nqz-1-z_coeff_var_indices_[sub_ind]],qdir[0])
-                        ry.ctrl(z_coeffs_[coeff_ind],[qdir[1],qdir[2]],qdir[0])
-                        coeff_ind+=1
-                        ind+=(1+tuple_length)
-                    x.ctrl(qdir[0],qdir[1])
-                    ind=0
-                    coeff_ind=0
-                    x.ctrl(qdir[1],qdir[2])
-                    while ind<len(unprep2_coeff_var_indices):
-                        tuple_length=unprep2_coeff_var_indices[ind]
-                        for sub_ind in range(ind+1,ind+1+tuple_length):
-                            x.ctrl(q[nqx+nqy+nqz-1-unprep2_coeff_var_indices[sub_ind]],qdir[1])
-                        ry.ctrl(unprep2_coeffs[coeff_ind],qdir[2],qdir[1])
-                        coeff_ind+=1
-                        ind+=(1+tuple_length)
-                    x.ctrl(qdir[1],qdir[2])
-                    ind=0
-                    coeff_ind=0
-                    while ind<len(unprep1_coeff_var_indices):
-                        tuple_length=unprep1_coeff_var_indices[ind]
-                        for sub_ind in range(ind+1,ind+1+tuple_length):
-                            x.ctrl(q[nqx+nqy+nqz-1-unprep1_coeff_var_indices[sub_ind]],qdir[1])
-                        ry.ctrl(-unprep1_coeffs[coeff_ind],qdir[0],qdir[1])
-                        coeff_ind+=1
-                        ind+=(1+tuple_length)
-                    ry(-2*np.pi/3,qdir[0])
-                print("Kernels defined")
-                def run_timestep_func(vec_arg, hadamard=False):
-                    result=cudaq.get_state(d2q5_tstep_wrapper,vec_arg,num_reg_qubits,num_reg_qubits,num_reg_qubits,self.nq_dir,self.dirs_i_list,\
-                                            x_coeff_var_indices,x_coeffs,\
-                                            y_coeff_var_indices,y_coeffs,\
-                                            z_coeff_var_indices,z_coeffs,\
-                                            x_coeff_var_indices_,x_coeffs_,\
-                                            y_coeff_var_indices_,y_coeffs_,\
-                                            z_coeff_var_indices_,z_coeffs_,\
-                                            unprep1_coeff_var_indices,unprep1_coeffs,\
-                                            unprep2_coeff_var_indices,unprep2_coeffs)
-                    num_nonzero_ranks = num_ranks / (2**num_anc)
-                    rank_slice_cupy = to_cupy_array(result)
-                    if rank >= num_nonzero_ranks and num_nonzero_ranks > 0:
-                        sub_sv_zeros = np.zeros(N_sub_per_rank, dtype=np.complex128)
-                        cp.cuda.runtime.memcpy(rank_slice_cupy.data.ptr, sub_sv_zeros.ctypes.data, sub_sv_zeros.nbytes, cp.cuda.runtime.memcpyHostToDevice)
-                    if rank == 0 and num_nonzero_ranks < 1 and N_sub_per_rank > 0:
-                        limit_idx = int(N_tot_state_vector / (2**num_anc))
-                        if limit_idx < rank_slice_cupy.size:
-                            rank_slice_cupy[limit_idx:] = 0
-                    return result
-                self.run_timestep = run_timestep_func
-            print("Circuit created")
-            def write_state(self, state_to_write, t_step_str_val):
-                rank_slice_cupy = to_cupy_array(state_to_write)
-                num_nonzero_ranks = num_ranks / (2**num_anc)
-                if rank < num_nonzero_ranks or (rank == 0 and num_nonzero_ranks <= 0):
-                    save_path = intermediate_folder_path / f"{t_step_str_val}_{rank}.npy"
-                    with open(save_path, 'wb') as f:
-                        arr_to_save = None
-                        data_limit = N_sub_per_rank
-                        if num_nonzero_ranks < 1 and rank == 0:
-                            data_limit = int(N_tot_state_vector / (2**num_anc))
-                        if data_limit > 0:
-                            relevant_part_cupy = cp.real(rank_slice_cupy[:data_limit])
-                        else:
-                            relevant_part_cupy = cp.array([], dtype=cp.float64)
-                        if relevant_part_cupy.size >= current_N * current_N * current_N:
-                            arr_flat = relevant_part_cupy[:current_N * current_N * current_N]
-                            if downsampling_factor > 1 and current_N > 0:
-                                arr_reshaped = arr_flat.reshape((current_N, current_N, current_N))
-                                arr_downsampled = arr_reshaped[::downsampling_factor, ::downsampling_factor, ::downsampling_factor]
-                                arr_to_save = arr_downsampled.flatten()
-                            else:
-                                arr_to_save = arr_flat
-                        elif relevant_part_cupy.size > 0:
-                            if downsampling_factor > 1:
-                                arr_to_save = relevant_part_cupy[::downsampling_factor]
-                            else:
-                                arr_to_save = relevant_part_cupy
-                        if arr_to_save is not None and arr_to_save.size > 0:
-                            np.save(f, arr_to_save.get() if isinstance(arr_to_save, cp.ndarray) else arr_to_save)
-            print("Write state defined")
-            def run_evolution(self, initial_state_arg, total_timesteps, time_steps_to_save, observable=False):
-                current_state_val = initial_state_arg
-                save_times = set(time_steps_to_save)
-                if 0 in save_times:
-                    print("Writing first state")
-                    self.write_state(current_state_val, '0')
-                for t_iter in range(total_timesteps):
-                    print("Running timestep")
-                    next_state_val = self.run_timestep(current_state_val)
-                    if (t_iter + 1) in save_times:
-                        print("Writing next state")
-                        self.write_state(next_state_val, str(t_iter + 1))
-                    cp.get_default_memory_pool().free_all_blocks()
-                    current_state_val = next_state_val
-                if rank == 0:
-                    print(f"Timestep: {total_timesteps}/{total_timesteps} (Evolution complete)")
-                cp.get_default_memory_pool().free_all_blocks()
-                self.final_state = current_state_val
-
-        if boundary_condition == "Periodic":
-            pass
-        elif boundary_condition == "Dirichlet":
-            pass
-        elif boundary_condition == "Neumann":
-            pass
-
-        downsampling_factor = 1
-        if current_N == 0:
-            print("Error: current_N is zero. num_reg_qubits likely too small.")
-            return None, None # Modified return
-        if current_N < downsampling_factor:
-            downsampling_factor = current_N if current_N > 0 else 1
-
-        qlbm_obj = QLBMAdvecDiffD3Q7_new(vx=vx_input, vy=vy_input, vz=vz_input)
-        initial_state_val = cudaq.get_state(alloc_kernel, num_qubits_total)
-
-        sub_sv_init_flat = initial_state_func_eval(np.arange(N_sub_per_rank)).astype(np.complex128)
-
-        norm = np.linalg.norm(sub_sv_init_flat)
-        if norm > 0:
-            sub_sv_init_flat /= norm
-        else:
-            print("Error: Initial state norm is zero.")
-            return None, None # Modified return
-        full_initial_sv_host = np.zeros(N_sub_per_rank, dtype=np.complex128)
-        num_computational_states = current_N ** 3
-        if len(sub_sv_init_flat) == num_computational_states:
-            if num_computational_states <= N_sub_per_rank:
-                full_initial_sv_host[:num_computational_states] = sub_sv_init_flat
-            else:
-                print(f"Error: Grid data {num_computational_states} > N_sub_per_rank {N_sub_per_rank}")
-                return None, None # Modified return
-        else:
-            print(f"Warning: Initial state size {len(sub_sv_init_flat)} != expected {num_computational_states}")
-            fill_len = min(len(sub_sv_init_flat), num_computational_states, N_sub_per_rank)
-            full_initial_sv_host[:fill_len] = sub_sv_init_flat[:fill_len]
-
-        rank_slice_init = to_cupy_array(initial_state_val)
-        print(f'Rank {rank}: Initializing state with {distribution_type} (vx={vx_input}, vy={vy_input})...')
-        cp.cuda.runtime.memcpy(rank_slice_init.data.ptr, full_initial_sv_host.ctypes.data, full_initial_sv_host.nbytes, cp.cuda.runtime.memcpyHostToDevice)
-        print(f'Rank {rank}: Initial state copied. Size: {len(sub_sv_init_flat)}. N_sub_per_rank: {N_sub_per_rank}')
-
-        print("Starting QLBM evolution...")
-        qlbm_obj.run_evolution(initial_state_val, T, time_steps)
-        print("QLBM evolution complete.")
-
-        print("Generating interactive plot with Plotly...")
-        downsampled_N = current_N // downsampling_factor
-        if downsampled_N == 0 and current_N > 0:
-            downsampled_N = 1
-        elif current_N == 0:
-            print("Error: current_N is zero before Plotly stage.")
-            return None, None # Modified return
-
-        data_frames = []
-        actual_timesteps = []
-        for t in time_steps:
-            file_path = intermediate_folder_path / f"{t}_{rank}.npy"
-            if file_path.exists():
-                sol_loaded = np.load(file_path)
-                if sol_loaded.size == downsampled_N * downsampled_N* downsampled_N:
-                    data = np.reshape(sol_loaded, (downsampled_N, downsampled_N, downsampled_N))
-                    data_frames.append(data)
-                    actual_timesteps.append(t)
-                    print(f"Time {t}: Min={np.min(data)}, Max={np.max(data)}, Mean={np.mean(data)}")
-                else:
-                    print(f"Warning: File {file_path} size {sol_loaded.size} != expected {downsampled_N*downsampled_N*downsampled_N}. Skipping.")
-            else:
-                print(f"Warning: File {file_path} not found. Skipping.")
-
-        if not data_frames:
-            print("Error: No data frames loaded for plotting.")
-            return None, None # Modified return
-
-        x_coords_plot = np.linspace(0, 1, downsampled_N)
-        y_coords_plot = np.linspace(0, 1, downsampled_N)
-        z_coords_plot = np.linspace(0, 1, downsampled_N)
-        Z_grid_mesh, Y_grid_mesh, X_grid_mesh = np.meshgrid(x_coords_plot, y_coords_plot, z_coords_plot, indexing='ij')
-
-        data_min = min([np.min(data) for data in data_frames])
-        data_max = max([np.max(data) for data in data_frames])
-        if data_max == data_min:
-            data_max += 1e-9
-
-        fig = go.Figure()
-
-        # Store individual frames for download
-        plotly_json_frames = []
-
-        for i, output_data in enumerate(data_frames):
-            frame_trace = go.Isosurface(
-                x=X_grid_mesh.flatten(),
-                y=Y_grid_mesh.flatten(),
-                z=Z_grid_mesh.flatten(),
-                value=output_data.flatten(),
-                isomin=data_min,
-                isomax=data_max,
-                opacity=0.4, # needs to be small to see through all surfaces
-                surface_count=7, # needs to be a large number for good volume rendering,
-                caps=dict(x_show=False, y_show=False, z_show=False)
-            )
-            fig.add_trace(frame_trace)
-
-            # Create a figure for the individual frame and convert to JSON
-            single_frame_fig = go.Figure(data=[frame_trace], layout=fig.layout)
-            single_frame_fig.update_layout(
-                title=f"Time: {actual_timesteps[i]}",
-                scene=dict(
-                    xaxis_title='X',
-                    yaxis_title='Y',
-                    zaxis_title='Z',
-                    xaxis=dict(range=[x_coords_plot[0], x_coords_plot[-1]]),
-                    yaxis=dict(range=[y_coords_plot[0], y_coords_plot[-1]]),
-                    zaxis=dict(range=[z_coords_plot[0], z_coords_plot[-1]]),
-                )
-            )
-            plotly_json_frames.append(single_frame_fig.to_json())
-
-        for trace in fig.data[1:]:
-            trace.visible = False
-
-        steps = []
-        for i in range(len(data_frames)):
-            step = dict(
-                method="update",
-                args=[{"visible": [False] * len(data_frames)}],
-                label=f"Time: {actual_timesteps[i]}"
-            )
-            step["args"][0]["visible"][i] = True
-            steps.append(step)
-
-        sliders = [dict(active=0, currentvalue={"prefix": "Time: "}, pad={"t": 50}, steps=steps)]
-
-        fig.update_layout(
-            title='',  # Removed graph title
-            scene=dict(
-                xaxis_title='X',
-                yaxis_title='Y',
-                zaxis_title='Z',
-                xaxis=dict(range=[x_coords_plot[0], x_coords_plot[-1]]),
-                yaxis=dict(range=[y_coords_plot[0], y_coords_plot[-1]]),
-                zaxis=dict(range=[z_coords_plot[0], z_coords_plot[-1]]),
-            ),
-            sliders=sliders,
-            width=800,
-            height=700
-        )
-
         return fig, plotly_json_frames # Modified return