diff --git a/.github/workflows/manual_tests_CPU.yml b/.github/workflows/manual_tests_CPU.yml
index f1f3d63..20c4fb9 100644
--- a/.github/workflows/manual_tests_CPU.yml
+++ b/.github/workflows/manual_tests_CPU.yml
@@ -28,6 +28,8 @@ jobs:
     - name: pip install
       run:  |
         pip install wakis['notebook']
+        pip uninstall vtk -y
+        pip install --extra-index-url https://wheels.vtk.org vtk-osmesa
 
     - name: Print versions
       run: conda list
diff --git a/.github/workflows/nightly_tests_CPU.yml b/.github/workflows/nightly_tests_CPU.yml
index a3bbda8..a39594d 100644
--- a/.github/workflows/nightly_tests_CPU.yml
+++ b/.github/workflows/nightly_tests_CPU.yml
@@ -28,7 +28,8 @@ jobs:
     - name: pip install
       run:  |
         pip install wakis['notebook']
-
+        pip uninstall vtk -y
+        pip install --extra-index-url https://wheels.vtk.org vtk-osmesa
     - name: Print versions
       run: conda list
     - name: Checkout wakis
diff --git a/.github/workflows/pull_request_CPU.yml b/.github/workflows/pull_request_CPU.yml
index 6b1714e..f361773 100644
--- a/.github/workflows/pull_request_CPU.yml
+++ b/.github/workflows/pull_request_CPU.yml
@@ -32,6 +32,8 @@ jobs:
         run: |
           cd wakis
           pip install .['notebook']
+          pip uninstall vtk -y
+          pip install --extra-index-url https://wheels.vtk.org vtk-osmesa
 
       - name: Print installed packages
         run: conda list
diff --git a/.gitignore b/.gitignore
index 4fdb3af..f0f746a 100644
--- a/.gitignore
+++ b/.gitignore
@@ -7,6 +7,7 @@ FDTD_*
 ECT_*
 */img*
 *.png
+*.html
 *.gif
 *.old*
 *.svg
diff --git a/notebooks/002_Wakefield_simulation.ipynb b/notebooks/002_Wakefield_simulation.ipynb
index 6a7331a..c34bc43 100644
--- a/notebooks/002_Wakefield_simulation.ipynb
+++ b/notebooks/002_Wakefield_simulation.ipynb
@@ -28,7 +28,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 1,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -59,9 +59,24 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "ac4484496d2c4647b287f5b7ec80a726",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Widget(value='<iframe src=\"http://localhost:46189/index.html?ui=P_0x7fdfc8967620_8&reconnect=auto\" class=\"pyvi…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "# Read geometry -change path if errors are found!\n",
     "stl_cavity = 'data/002_vacuum_cavity.stl'\n",
@@ -76,15 +91,25 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Generating grid with 1010000 mesh cells...\n",
+      "Importing STL solids...\n",
+      "Total grid initialization time: 17.937092781066895 s\n"
+     ]
+    }
+   ],
    "source": [
     "# ---------- Domain setup ---------\n",
     "# Number of mesh cells\n",
-    "Nx = 80\n",
-    "Ny = 80\n",
-    "Nz = 141\n",
+    "Nx = 100\n",
+    "Ny = 100\n",
+    "Nz = 101\n",
     "#dt = 2.187760221e-12 # like CST\n",
     "\n",
     "stl_solids = {'cavity': stl_cavity, 'shell': stl_shell}\n",
@@ -104,9 +129,24 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "79f2e7e9a25b4f8a9b72e29eea3f02a6",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Widget(value='<iframe src=\"http://localhost:46189/index.html?ui=P_0x7fe017f19a30_1&reconnect=auto\" class=\"pyvi…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "grid.plot_stl_mask('shell', add_stl='all',\n",
     "                   stl_opacity=0.2,\n",
@@ -115,9 +155,24 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "cd5e0d160966407188d07d4e1131e55d",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Widget(value='<iframe src=\"http://localhost:46189/index.html?ui=P_0x7fe0160d9a30_2&reconnect=auto\" class=\"pyvi…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "# Plot the imported geometry 3d interactive plot\n",
     "grid.plot_solids()"
@@ -125,9 +180,24 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "f7f76f21cabd4c2eae85b577a4a33e3d",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Widget(value='<iframe src=\"http://localhost:46189/index.html?ui=P_0x7fdfecbdc0e0_3&reconnect=auto\" class=\"pyvi…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "# Plot the geometry and the grid on 3d interactive plot\n",
     "grid.inspect()"
@@ -135,9 +205,17 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Saving grid to HDF5 file: grid.h5\n"
+     ]
+    }
+   ],
    "source": [
     "# [OPTIONAL] Save grid to HDF5 file for later use\n",
     "grid.save_to_h5('grid.h5')\n",
@@ -156,9 +234,23 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Assembling operator matrices...\n",
+      "Applying boundary conditions...\n",
+      "Adding material tensors...\n",
+      "Calculating maximal stable timestep...\n",
+      "Pre-computing...\n",
+      "Using MKL backend for time-stepping...\n",
+      "Total solver initialization time: 1.1660196781158447 s\n"
+     ]
+    }
+   ],
    "source": [
     "# boundary conditions\n",
     "bc_low=['pec', 'pec', 'pec']\n",
@@ -182,18 +274,59 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "a3c93511c268439bb48818c407f9e29c",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Widget(value='<iframe src=\"http://localhost:46189/index.html?ui=P_0x7fe0160dbad0_4&reconnect=auto\" class=\"pyvi…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "solver.sigma.inspect3D(field='x', ymax=0, grid=grid, show_grid=False, backend='pyvista')"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "b5307dd83a614cf59d1fd95cf9eb11b2",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "image/png": "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",
+      "text/html": [
+       "\n",
+       "            <div style=\"display: inline-block;\">\n",
+       "                <div class=\"jupyter-widgets widget-label\" style=\"text-align: center;\">\n",
+       "                    Figure\n",
+       "                </div>\n",
+       "                <img src='data:image/png;base64,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' width=800.0/>\n",
+       "            </div>\n",
+       "        "
+      ],
+      "text/plain": [
+       "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "# Inspect the material tensors before running the simulations\n",
     "solver.ieps.inspect(plane='XY',)"
@@ -201,13 +334,39 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "22b728d6089f4c82acee5caef6c46a80",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "image/png": "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",
+      "text/html": [
+       "\n",
+       "            <div style=\"display: inline-block;\">\n",
+       "                <div class=\"jupyter-widgets widget-label\" style=\"text-align: center;\">\n",
+       "                    Figure\n",
+       "                </div>\n",
+       "                <img src='data:image/png;base64,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' width=800.0/>\n",
+       "            </div>\n",
+       "        "
+      ],
+      "text/plain": [
+       "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "# Modify the field to add initial conditions and quickly inspect the modifications\n",
-    "solver.E[10,20:40,:,'z'] = 1.0\n",
-    "solver.E.inspect(plane='YZ')\n",
+    "solver.E[10,20:75,:,'z'] = 1.0\n",
+    "solver.E.inspect(plane='XY')\n",
     "solver.E[10,20:40,:,'z'] = 0.0 # And restore it back!"
    ]
   },
@@ -227,7 +386,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 12,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -255,6 +414,43 @@
     "                Ez_file='002_results/Ez.h5',)"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Before running the wakefield simultion, we can inspect the imported solids, beam and integration paths included in the simulation:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "fa3fce53c0464a54a26ab0d2613b4f35",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Widget(value='<iframe src=\"http://localhost:46189/index.html?ui=P_0x7fdfa8141d90_7&reconnect=auto\" class=\"pyvi…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "pl = solver.inspect(wake=wake, opacity=1.0, add_silhouette=True,\n",
+    "                    off_screen=False, specular=0.,\n",
+    "                    smooth_shading=False )\n",
+    "\n",
+    "# If off_screen = True, we can save the scene in HTML or as a screenshot\n",
+    "# pl.export_html('002_inspect.html')\n",
+    "# pl.screenshot('002_inspect.png')"
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
diff --git a/tests/test_003_planewave_sphere.py b/tests/test_003_planewave_sphere.py
index abea7e7..91de309 100644
--- a/tests/test_003_planewave_sphere.py
+++ b/tests/test_003_planewave_sphere.py
@@ -1,20 +1,24 @@
-import os, sys
-import numpy as np
+import os
+import sys
 import pyvista as pv
 import matplotlib.pyplot as plt
 from scipy.constants import c
 
 sys.path.append('../wakis')
-                
+
 from wakis import SolverFIT3D
-from wakis import GridFIT3D 
+from wakis import GridFIT3D
 from wakis.sources import PlaneWave
 
-import pytest 
+import pytest
 
-flag_interactive = False # Set to true to run PyVista tests
+# Turn False when running local
+flag_offscreen = True
 
 class TestPlanewave:
+
+    img_folder = 'tests/003_img/'
+
     def test_simulation(self):
         print("\n---------- Initializing simulation ------------------")
         # Number of mesh cells
@@ -23,7 +27,7 @@ def test_simulation(self):
         Nz = 120
 
         # Embedded boundaries
-        stl_file = 'tests/stl/003_sphere.stl' 
+        stl_file = 'tests/stl/003_sphere.stl'
         surf = pv.read(stl_file)
 
         stl_solids = {'Sphere': stl_file}
@@ -44,90 +48,75 @@ def test_simulation(self):
         xmax, ymax, zmax = (xmax+padx), (ymax+pady), (zmax+padz)
 
         global grid
-        grid = GridFIT3D(xmin, xmax, ymin, ymax, zmin, zmax, Nx, Ny, Nz, 
-                stl_solids=stl_solids, 
+        grid = GridFIT3D(xmin, xmax, ymin, ymax, zmin, zmax, Nx, Ny, Nz,
+                stl_solids=stl_solids,
                 stl_rotate=stl_rotate,
                 stl_scale=stl_scale,
                 stl_materials=stl_materials)
 
-        # Boundary conditions and 
+        # Boundary conditions and
         bc_low=['periodic', 'periodic', 'pec']
         bc_high=['periodic', 'periodic', 'pml']
-        
+
+        # -------------- Output folder ---------------------
+        if not os.path.exists(self.img_folder):
+            os.mkdir(self.img_folder)
+
         # simulation
         global solver
         solver = SolverFIT3D(grid, use_stl=True, bc_low=bc_low, bc_high=bc_high)
-        
+
         # source
         f = 15/((solver.z.max()-solver.z.min())/c)
-        source = PlaneWave(xs=slice(1, Nx-1), ys=slice(1,Ny-1), zs=1, 
+        source = PlaneWave(xs=slice(1, Nx-1), ys=slice(1,Ny-1), zs=1,
                            f=f, beta=1.0)
-        
+
         Nt = int(1.0*(solver.z.max()-solver.z.min())/c/solver.dt)
         solver.emsolve(Nt, source)
 
-    def test_plot2D(self):
+    def test_plot1D(self):
         global solver
-        solver.plot2D('Ex', plane='ZY', pos=0.5, cmap='rainbow', 
-                    add_patch='Sphere', patch_alpha=0.3, 
-                    off_screen=False)
-        if not flag_interactive:
-            plt.close()
-            
-    def test_plot2D_offscreen(self):
+        solver.plot1D('Ex', line='z', pos=[0.7, 0.6, 0.5, 0.4, 0.3, 0.2],
+                    xscale='linear', yscale='linear',
+                    off_screen=flag_offscreen, n=solver.Nt,
+                    colors=['#5ccfe6', '#fdb6d0', '#ffae57', '#bae67e', '#ffd580', '#a2aabc'],
+                    title=self.img_folder+'1Dplot_Ex')
+
+    def test_plot2D(self):
         global solver
-        solver.plot2D('Hy', plane='ZY', pos=0.5, cmap='bwr', 
+        solver.plot2D('Hy', plane='ZY', pos=0.5, cmap='bwr',
                     add_patch='Sphere', patch_alpha=0.1, interpolation='spline36',
-                    off_screen=True, n=solver.Nt, title='003_2Dplot_Hy') 
-        if not flag_interactive:
-            os.remove(f'003_2Dplot_Hy_{str(solver.Nt).zfill(6)}.png')
-    
-    @pytest.mark.skipif(not flag_interactive, reason="Requires interactive plotting")
+                    off_screen=flag_offscreen, n=solver.Nt,
+                    title=self.img_folder+'2Dplot_Hy')
+
+    @pytest.mark.skipif(flag_offscreen, reason="Requires interactive plotting")
     def test_plot3D_interactive(self):
         global solver
         solver.plot3D(field='E', component='x', cmap='jet',
             add_stl='Sphere', stl_opacity=0.1, stl_colors='white',
             clip_interactive=True, clip_normal='-y',
-            off_screen=False)  
-        
-    @pytest.mark.skipif(not flag_interactive, reason="Requires Xserver connection for plotting")     
+            off_screen=False)
+
     def test_plot3D_offscreen(self):
         global solver
         solver.plot3D(field='H', component='y', cmap='bwr',
                       add_stl='Sphere', stl_opacity=0.1, stl_colors='white',
-                      clip_box=True, clip_bounds=None, 
-                      off_screen=True, title='003_3Dplot_Hy')
-        if not flag_interactive:
-            os.remove('003_3Dplot_Hy.png')
-    
-    @pytest.mark.skipif(not flag_interactive, reason="Requires interactive plotting")
+                      clip_box=True, clip_bounds=None,
+                      off_screen=flag_offscreen, title=self.img_folder+'3Dplot_Hy')
+
+    @pytest.mark.skipif(flag_offscreen, reason="Requires interactive plotting")
     def test_plot3DonSTL_interactive(self):
         global solver
-        solver.plot3DonSTL('Ex', cmap='jet', 
+        solver.plot3DonSTL('Ex', cmap='jet',
                            stl_with_field='Sphere', field_opacity=1.,
                            stl_transparent='Sphere', stl_opacity=0.3, stl_colors='white',
                            clip_interactive=True, clip_normal='-y',
                            off_screen=False, zoom=1.0)
-        
-    @pytest.mark.skipif(not flag_interactive, reason="Requires Xserver connection for plotting")
+
     def test_plot3DonSTL_offscreen(self):
         global solver
-        solver.plot3DonSTL('Ex', cmap='jet', 
+        solver.plot3DonSTL('Ex', cmap='jet',
                            stl_with_field='Sphere', field_opacity=1.,
                            stl_transparent=None, stl_opacity=0., stl_colors=None,
-                           off_screen=True, zoom=1.0, title='003_3DplotOnSTL_Hy')
-        if not flag_interactive:
-            os.remove('003_3DplotOnSTL_Hy.png')
-        
-
-    @pytest.mark.skipif(not flag_interactive, reason="Requires interactive plotting")
-    def test_grid_inspect(self):
-        global grid
-        grid.inspect(add_stl=None, stl_opacity=0.5, stl_colors=None, 
-                     anti_aliasing='ssa')
-
-    @pytest.mark.skipif(not flag_interactive, reason="Requires interactive plotting")
-    def test_grid_plot_solids(self):
-        global grid
-        grid.plot_solids(bounding_box=False, opacity=1.0, specular=0.5,
-                         anti_aliasing=None)
+                           off_screen=flag_offscreen, zoom=1.0,
+                           title=self.img_folder+'3DplotOnSTL_Hy')
diff --git a/tests/test_007_mpi_lossy_cavity.py b/tests/test_007_mpi_lossy_cavity.py
index 7789c1b..95233ee 100644
--- a/tests/test_007_mpi_lossy_cavity.py
+++ b/tests/test_007_mpi_lossy_cavity.py
@@ -86,19 +86,19 @@ class TestMPILossyCavity:
                     -6.04105997e+01 ,-3.06532160e+01 ,-1.17749936e+01 ,-3.12574866e+00,
                     -7.35339521e-01 ,-1.13085658e-01 , 7.18247535e-01 , 8.73829036e-02])
 
-    gridLogs = {'use_mesh_refinement': False, 'Nx': 60, 'Ny': 60, 'Nz': 140, 'dx': 0.00866666634877522, 
-                'dy': 0.00866666634877522, 'dz': 0.005714285799435207, 
-                'xmin': -0.25999999046325684, 'xmax': 0.25999999046325684, 
-                'ymin': -0.25999999046325684, 'ymax': 0.25999999046325684, 
-                'zmin': -0.25, 'zmax': 0.550000011920929, 
+    gridLogs = {'use_mesh_refinement': False, 'Nx': 60, 'Ny': 60, 'Nz': 140, 'dx': 0.00866666634877522,
+                'dy': 0.00866666634877522, 'dz': 0.005714285799435207,
+                'xmin': -0.25999999046325684, 'xmax': 0.25999999046325684,
+                'ymin': -0.25999999046325684, 'ymax': 0.25999999046325684,
+                'zmin': -0.25, 'zmax': 0.550000011920929,
                 'stl_solids': {'cavity': 'tests/stl/007_vacuum_cavity.stl', 'shell': 'tests/stl/007_lossymetal_shell.stl'},
-                'stl_materials': {'cavity': 'vacuum', 'shell': [30, 1.0, 30]}, 
+                'stl_materials': {'cavity': 'vacuum', 'shell': [30, 1.0, 30]},
                 'gridInitializationTime': 0}
-    
+
     solverLogs = {'use_gpu': False, 'use_mpi': False, 'background': 'pec',
-                'bc_low': ['pec', 'pec', 'pec'], 'bc_high': ['pec', 'pec', 'pec'], 
+                'bc_low': ['pec', 'pec', 'pec'], 'bc_high': ['pec', 'pec', 'pec'],
                 'dt': 6.970326728398966e-12, 'solverInitializationTime': 0}
-    
+
     wakeSolverLogs = {'ti': 2.8516132094735135e-09, 'q': 1e-09, 'sigmaz': 0.1, 'beta': 1.0,
                        'xsource': 0.0, 'ysource': 0.0, 'xtest': 0.0, 'ytest': 0.0, 'chargedist': None,
                        'skip_cells': 10, 'results_folder': 'tests/007_results/', 'wakelength': 10.0, 'simulationTime': 0}
@@ -252,29 +252,6 @@ def test_mpi_plot1D(self):
                 xscale='linear', yscale='linear',
                 off_screen=True, title=self.img_folder+'Ez1d', n=3000)
 
-    @pytest.mark.skipif(not flag_plot_3D, reason="Requires interactive plotting")
-    def test_mpi_plot3D(self):
-        # Plot Abs Electric field on domain
-        # disabled when mpi = True
-        global solver
-        solver.plot3D('E', component='Abs',
-                cmap='rainbow', clim=[0, 500],
-                add_stl=['cavity', 'shell'], stl_opacity=0.1,
-                clip_interactive=True, clip_normal='-y')
-
-    @pytest.mark.skipif(not flag_plot_3D, reason="Requires interactive plotting")
-    def test_mpi_plot3DonSTL(self):
-        # Plot Abs Electric field on STL solid `cavity`
-        # disabled when mpi = True
-        global solver
-        solver.plot3DonSTL('E', component='Abs',
-                        cmap='rainbow', clim=[0, 500],
-                        stl_with_field='cavity', field_opacity=1.0,
-                        stl_transparent='shell', stl_opacity=0.1, stl_colors='white',
-                        clip_plane=True, clip_normal='-y', clip_origin=[0,0,0],
-                        off_screen=False, zoom=1.2, title=self.img_folder+'Ez3d')
-
-
     def test_mpi_wakefield(self):
         # Reset fields
         global solver
@@ -343,7 +320,7 @@ def test_long_impedance(self):
             assert np.allclose(np.real(wake.Z)[::20], np.real(self.Z), rtol=0.1), "Real Impedance samples failed"
             assert np.allclose(np.imag(wake.Z)[::20], np.imag(self.Z), rtol=0.1), "Imag Impedance samples failed"
             assert np.cumsum(np.abs(wake.Z))[-1] == pytest.approx(250910.51090497518, 0.1), "Abs Impedance cumsum failed"
-    
+
     def test_log_file(self):
         # Helper function to compare nested dicts with float tolerance
         def assert_dict_allclose(d1, d2, rtol=1e-6, atol=1e-12, path=""):
@@ -379,7 +356,7 @@ def assert_dict_allclose(d1, d2, rtol=1e-6, atol=1e-12, path=""):
 
         global solver
         # Exclude timing info from comparison as they can vary between runs
-        solver.logger.grid["gridInitializationTime"] = 0 
+        solver.logger.grid["gridInitializationTime"] = 0
         solver.logger.solver["solverInitializationTime"] = 0
         solver.logger.wakeSolver["simulationTime"] = 0
         self.solverLogs['use_mpi'] = use_mpi
diff --git a/tests/test_008_3D_plotting.py b/tests/test_008_3D_plotting.py
new file mode 100644
index 0000000..6660c50
--- /dev/null
+++ b/tests/test_008_3D_plotting.py
@@ -0,0 +1,164 @@
+import os
+import sys
+import pyvista as pv
+
+sys.path.append('../wakis')
+
+from tqdm import tqdm
+from scipy.constants import c
+
+from wakis import SolverFIT3D
+from wakis import GridFIT3D
+from wakis.sources import Beam
+from wakis import WakeSolver
+
+import pytest
+
+# Turn False when running local
+flag_offscreen = True
+
+@pytest.mark.slow
+class Test3Dplotting:
+
+    img_folder = 'tests/008_img/'
+
+    def test_simulation(self):
+
+        # ---------- Domain setup ---------
+
+        # Geometry & Materials
+        solid_1 = 'tests/stl/007_vacuum_cavity.stl'
+        solid_2 = 'tests/stl/007_lossymetal_shell.stl'
+
+        stl_solids = {'cavity': solid_1,
+                    'shell': solid_2
+                    }
+
+        stl_materials = {'cavity': 'vacuum',
+                        'shell': [30, 1.0, 30] #[eps_r, mu_r, sigma[S/m]]
+                        }
+
+        stl_colors = {'cavity': 'tab:blue',
+                    'shell': 'silver'}
+
+        # Extract domain bounds from geometry
+        solids = pv.read(solid_1) + pv.read(solid_2)
+        xmin, xmax, ymin, ymax, ZMIN, ZMAX = solids.bounds
+
+        # Number of mesh cells
+        Nx = 60
+        Ny = 60
+        NZ = 140
+
+        grid = GridFIT3D(xmin, xmax, ymin, ymax, ZMIN, ZMAX,
+                        Nx, Ny, NZ,
+                        use_mpi=False, # Enables MPI subdivision of the domain
+                        stl_solids=stl_solids,
+                        stl_materials=stl_materials,
+                        stl_colors=stl_colors,
+                        stl_scale=1.0,
+                        stl_rotate=[0,0,0],
+                        stl_translate=[0,0,0],
+                        verbose=1)
+
+        # ------------ Beam source & Wake ----------------
+        # Beam parameters
+        sigmaz = 10e-2      #[m] -> 2 GHz
+        q = 1e-9            #[C]
+        beta = 1.0          # beam beta
+        xs = 0.             # x source position [m]
+        ys = 1e-2           # y source position [m]
+        ti = 3*sigmaz/c     # injection time [s]
+
+        beam = Beam(q=q, sigmaz=sigmaz, beta=beta,
+                    xsource=xs, ysource=ys, ti=ti)
+
+        wake = WakeSolver(q=q, sigmaz=sigmaz, beta=beta,
+                         xsource=xs, ysource=ys, ti=ti)
+
+        # ----------- Solver & Simulation ----------
+        # boundary conditions
+        bc_low=['pec', 'pec', 'pec']
+        bc_high=['pec', 'pec', 'pec']
+
+        # Solver setup
+        global solver
+        solver = SolverFIT3D(grid, wake,
+                            bc_low=bc_low,
+                            bc_high=bc_high,
+                            use_stl=True,
+                            use_mpi=False, # Activate MPI
+                            bg='pec' # Background material
+                            )
+
+        # -------------- Output folder ---------------------
+        if not os.path.exists(self.img_folder):
+            os.mkdir(self.img_folder)
+
+        # -------------- Custom time loop  -----------------
+        Nt = 1000
+        for n in tqdm(range(Nt)):
+            beam.update(solver, n*solver.dt)
+            solver.one_step()
+
+    def test_grid_inspect(self):
+        # Plot grid and imported solids
+        global solver
+        pl = solver.grid.inspect(add_stl=['cavity', 'shell'],
+                            stl_opacity=0.1, off_screen=flag_offscreen,
+                            anti_aliasing='ssaa')
+        if flag_offscreen:
+            #pl.screenshot(self.img_folder+'grid_inspect.png')
+            pl.export_html(self.img_folder+'grid_inspect.html')
+
+    def test_grid_plot_solids(self):
+        # Plot only imported solids
+        global solver
+        solver.grid.plot_solids(bounding_box=True,
+                                show_grid=False,
+                                opacity=1,
+                                specular=0.5,
+                                smooth_shading=False,
+                                off_screen=flag_offscreen,)
+
+    def test_grid_stl_mask(self):
+        # Plot STL solid masks in the grid
+        global solver
+        solver.grid.plot_stl_mask(stl_solid='cavity',
+                                  cmap='viridis',
+                                  add_stl='all',
+                                  stl_opacity=0.5,
+                                  smooth_shading=False,
+                                  anti_aliasing='ssaa',
+                                  ymax=0.0,
+                                  off_screen=flag_offscreen,)
+
+    def test_solver_inspect(self):
+        # Plot imported solids and beam source and integraiton path
+        global solver
+        pl = solver.inspect(window_size=(1200,800), off_screen=flag_offscreen,
+                            specular=0., opacity=1, inactive_opacity=0.1,
+                            add_silhouette=True,)
+        if flag_offscreen:
+            #pl.screenshot(self.img_folder+'solver_inspect.png')
+            pl.export_html(self.img_folder+'solver_inspect.html')
+
+    def test_plot3D(self):
+        # Plot Abs Electric field on domain
+        global solver
+        solver.plot3D('E', component='z',
+                cmap='rainbow', clim=[0, 500],
+                add_stl=['cavity', 'shell'], stl_opacity=0.1,
+                clip_interactive=True, clip_normal='-y',
+                title=self.img_folder+'Ez3d',
+                off_screen=flag_offscreen)
+
+    def test_plot3DonSTL(self):
+        # Plot Abs Electric field on STL solid `cavity`
+        global solver
+        solver.plot3DonSTL('E', component='Abs',
+                        cmap='rainbow', clim=[0, 500],
+                        stl_with_field='cavity', field_opacity=1.0,
+                        stl_transparent='shell', stl_opacity=0.1, stl_colors='white',
+                        clip_plane=True, clip_normal='-y', clip_origin=[0,0,0],
+                        off_screen=flag_offscreen, zoom=1.2, title=self.img_folder+'EAbs3donSTL')
diff --git a/wakis/geometry.py b/wakis/geometry.py
index d99e5dd..a691fb0 100644
--- a/wakis/geometry.py
+++ b/wakis/geometry.py
@@ -68,8 +68,16 @@ def extract_materials_from_stp(stp_file):
 
     return stl_materials
 
-def extract_solids_from_stp(stp_file, path=''):
-    if path and not path.endswith('/'):
+def extract_solids_from_stp(stp_file, path=None):
+    '''
+    Extracts a mapping from solid names to STL file names from a STEP (.stp) file.  
+    Args:
+        stp_file (str): Path to the STEP file.
+        path (str) (optional): default: None, path to save the STL (.stl) files
+    Returns:
+        dict[str, str]: A dictionary mapping solid names to STL file names.
+    '''    
+    if path is not None and not path.endswith('/'):
         path += '/'
     solids, materials = extract_names_from_stp(stp_file)
     stl_solids = {}
@@ -85,7 +93,10 @@ def extract_solids_from_stp(stp_file, path=''):
         solid_re = re.sub(r'[^a-zA-Z0-9_-]', '-', solid)
         mat_re = re.sub(r'[^a-zA-Z0-9_-]', '-', mat)
         name = f'{str(i).zfill(3)}_{solid_re}_{mat_re}'
-        stl_solids[f'{str(i).zfill(3)}_{solid_re}'] = path + name + '.stl'
+        if path is not None:
+            stl_solids[f'{str(i).zfill(3)}_{solid_re}'] = path + name + '.stl'
+        else:
+            stl_solids[f'{str(i).zfill(3)}_{solid_re}'] = name + '.stl'
 
     return stl_solids
 
@@ -195,7 +206,7 @@ def get_stp_unit_scale(stp_file):
 
         return 1.0
 
-def generate_stl_solids_from_stp(stp_file, results_path=''):
+def generate_stl_solids_from_stp(stp_file, results_path=None):
     """
     Extracts solid objects from a STEP (.stp) file and exports them as STL files.
 
@@ -238,16 +249,13 @@ def generate_stl_solids_from_stp(stp_file, results_path=''):
         scaled_solids = [solid.scale(scale_factor) for solid in stp.objects[0]]
         stp.objects = [scaled_solids]
 
-    solid_dict = extract_solids_from_stp(stp_file)
-
-    if not results_path.endswith('/'):
-        results_path += '/'
+    solid_dict = extract_solids_from_stp(stp_file, results_path)
 
     print(f"Generating stl from file: {stp_file}... ")
     for i, obj in enumerate(stp.objects[0]):
         name = solid_dict[list(solid_dict.keys())[i]]
         print(name)
-        obj.exportStl(results_path+name)
+        obj.exportStl(name)
 
     return solid_dict
 
diff --git a/wakis/gridFIT3D.py b/wakis/gridFIT3D.py
index 4e77914..71089bb 100644
--- a/wakis/gridFIT3D.py
+++ b/wakis/gridFIT3D.py
@@ -12,6 +12,7 @@
 
 from .field import Field
 from .logger import Logger
+from .materials import material_colors
 
 try:
     from mpi4py import MPI
@@ -165,8 +166,8 @@ def __init__(self, xmin=None, xmax=None,
             if verbose:
                 print('Applying mesh refinement...')
             if self.snap_points is None and stl_solids is not None:
-                self.compute_snap_points(snap_solids=snap_solids, snap_tol=snap_tol)
-            self.refine_xyz_axis(method=refinement_method, tol=refinement_tol)
+                self._compute_snap_points(snap_solids=snap_solids, snap_tol=snap_tol)
+            self._refine_xyz_axis(method=refinement_method, tol=refinement_tol)
 
         if verbose:
             print(f'Generating grid with {self.Nx*self.Ny*self.Nz} mesh cells...')
@@ -183,23 +184,21 @@ def __init__(self, xmin=None, xmax=None,
             self.NZ = None
             self.Z = None
             if imported_mpi:
-                self.mpi_initialize()
+                self._mpi_initialize()
                 if self.verbose:
                     print(f"MPI initialized for {self.rank} of {self.size}")
             else:
                 raise ImportError("[!] mpi4py is required when use_mpi=True but was not found")
 
         # grid G and tilde grid ~G, lengths and inverse areas
-        self.compute_grid()
+        self._compute_grid()
 
         # tolerance for stl import tol*min(dx,dy,dz)
         if verbose:
             print('Importing STL solids...')
         self.stl_tol = stl_tol
         if stl_solids is not None:
-            self.mark_cells_in_stl()
-            if stl_colors is None:
-                self.assign_colors()
+            self._mark_cells_in_stl()
 
         if verbose:
             print(f'Total grid initialization time: {time.time() - t0} s')
@@ -207,7 +206,7 @@ def __init__(self, xmin=None, xmax=None,
         self.gridInitializationTime = time.time()-t0
         self.update_logger(['gridInitializationTime'])
 
-    def compute_grid(self):
+    def _compute_grid(self):
         X, Y, Z = np.meshgrid(self.x, self.y, self.z, indexing='ij')
         self.grid = pv.StructuredGrid(X.transpose(), Y.transpose(), Z.transpose())
 
@@ -246,7 +245,7 @@ def compute_grid(self):
         self.itA.field_z = np.divide(1.0, aux, out=np.zeros_like(aux), where=aux!=0)
         del aux
 
-    def mpi_initialize(self):
+    def _mpi_initialize(self):
         comm = MPI.COMM_WORLD  # Get MPI communicator
         self.comm = comm
         self.rank = self.comm.Get_rank()
@@ -338,18 +337,41 @@ def _prepare_stl_dicts(self):
                 stl_translate[key] = self.stl_translate
             self.stl_translate = stl_translate
 
-    def mark_cells_in_stl(self):
+        if type(self.stl_colors) is not dict:
+            if self.stl_colors is None:
+                self._assign_colors()
+            elif self.stl_colors is str: # single color for all solids
+                stl_colors = {}
+                for key in self.stl_solids.keys():
+                    stl_colors[key] = self.stl_colors
+                self.stl_colors = stl_colors
+            elif type(self.stl_colors) is list:
+                stl_colors = {}
+                try:
+                    for i, key in enumerate(self.stl_solids.keys()):
+                        stl_colors[key] = self.stl_colors[i]
+                    self.stl_colors = stl_colors
+                except IndexError:
+                    self._assign_colors()
+                    print('[!] If `stl_colors` is a list, it must have the same length as `stl_solids`.')
+
+    def _mark_cells_in_stl(self):
         # Obtain masks with grid cells inside each stl solid
         stl_tolerance = np.min([self.dx, self.dy, self.dz])*self.stl_tol
+        progress_bar = False
+        if self.Nx*self.Ny*self.Nz > 5e6 and self.verbose:
+            progress_bar = True
         for key in self.stl_solids.keys():
 
             surf = self.read_stl(key)
 
             # mark cells in stl [True == in stl, False == out stl]
             try:
-                select = self.grid.select_enclosed_points(surf, tolerance=stl_tolerance)
+                select = self.grid.select_enclosed_points(surf, tolerance=stl_tolerance,
+                                                          progress_bar=progress_bar)
             except Exception:
-                select = self.grid.select_enclosed_points(surf, tolerance=stl_tolerance, check_surface=False)
+                select = self.grid.select_enclosed_points(surf, tolerance=stl_tolerance,
+                                                          check_surface=False, progress_bar=progress_bar)
                 if self.verbose > 1:
                     print(f'[!] Warning: stl solid {key} may have issues with closed surfaces. Consider checking the STL file.')
 
@@ -378,7 +400,7 @@ def read_stl(self, key):
 
         return surf
 
-    def compute_snap_points(self, snap_solids=None, snap_tol=1e-8):
+    def _compute_snap_points(self, snap_solids=None, snap_tol=1e-8):
         if self.verbose > 1:
             print(' * Calculating snappy points...')
         # Support for user-defined stl_keys as list
@@ -521,7 +543,7 @@ def loss_function(x, x0, is_snap):
         # transform back to [xmin, xmax]
         return result.x*(xmax-xmin)+xmin
 
-    def refine_xyz_axis(self, method='insert', tol=1e-6):
+    def _refine_xyz_axis(self, method='insert', tol=1e-6):
         '''Refine the grid in the x, y, z axis
         using the snap points extracted from the stl solids.
         The snap points are used to refine the grid '''
@@ -551,7 +573,7 @@ def refine_xyz_axis(self, method='insert', tol=1e-6):
         if self.verbose:
             print(f"Refined grid: Nx = {len(self.x)}, Ny ={len(self.y)}, Nz = {len(self.z)}")
 
-    def assign_colors(self):
+    def _assign_colors(self):
         '''Classify colors assigned to each solid
         based on the categories in `material_colors` dict
         inside `materials.py`
@@ -561,18 +583,19 @@ def assign_colors(self):
         for key in self.stl_solids:
             mat = self.stl_materials[key]
             if type(mat) is str:
-                self.stl_colors[key] = mat
+                _color = material_colors.get(mat, material_colors['other'])
+                self.stl_colors[key] = _color
             elif len(mat) == 2:
                 if mat[0] is np.inf:  #eps_r
-                    self.stl_colors[key] = 'pec'
+                    self.stl_colors[key] = material_colors['pec']
                 elif mat[0] > 1.0:    #eps_r
-                    self.stl_colors[key] = 'dielectric'
+                    self.stl_colors[key] = material_colors['dielectric']
                 else:
-                    self.stl_colors[key] = 'vacuum'
+                    self.stl_colors[key] = material_colors['vacuum']
             elif len(mat) == 3:
-                self.stl_colors[key] = 'lossy metal'
+                self.stl_colors[key] = material_colors['lossy metal']
             else:
-                self.stl_colors[key] = 'other'
+                self.stl_colors[key] = material_colors['other']
 
     def _add_logo_widget(self, pl):
         """Add packaged logo via importlib.resources (Python 3.9+)."""
@@ -592,7 +615,8 @@ def _add_logo_widget(self, pl):
                     print(f'[!] Could not add logo widget: {e}')
 
     def plot_solids(self, bounding_box=False, show_grid=False, anti_aliasing=None,
-                    opacity=1.0, specular=0.5, offscreen=False, **kwargs):
+                    opacity=1.0, specular=0.5, smooth_shading=False,
+                    off_screen=False, **kwargs):
         """
         Generates a 3D visualization of the imported STL geometries using PyVista.
 
@@ -627,22 +651,16 @@ def plot_solids(self, bounding_box=False, show_grid=False, anti_aliasing=None,
 
         """
 
-        from .materials import material_colors
-
         pl = pv.Plotter()
         pl.add_mesh(self.grid, opacity=0., name='grid', show_scalar_bar=False)
         for key in self.stl_solids:
-            try:
-                color = material_colors[self.stl_colors[key]] # match library e.g. 'vacuum'
-            except KeyError:
-                color = self.stl_colors[key] # specifies color e.g. 'tab:red'
-
-            if self.stl_colors[key] == 'vacuum' or self.stl_materials[key] == 'vacuum':
+            color = self.stl_colors[key]
+            if self.stl_materials[key] == 'vacuum':
                 _opacity = 0.3
             else:
                 _opacity = opacity
             pl.add_mesh(self.read_stl(key), color=color,
-                        opacity=_opacity, specular=specular, smooth_shading=True,
+                        opacity=_opacity, specular=specular, smooth_shading=smooth_shading,
                         **kwargs)
 
         pl.set_background('mistyrose', top='white')
@@ -661,7 +679,7 @@ def plot_solids(self, bounding_box=False, show_grid=False, anti_aliasing=None,
         if show_grid:
             pl.add_mesh(self.grid, style='wireframe', color='grey', opacity=0.3, name='grid')
 
-        if offscreen:
+        if off_screen:
             pl.export_html('grid_plot_solids.html')
         else:
             pl.show()
@@ -669,7 +687,7 @@ def plot_solids(self, bounding_box=False, show_grid=False, anti_aliasing=None,
     def plot_stl_mask(self, stl_solid, cmap='viridis', bounding_box=True, show_grid=True,
                       add_stl='all', stl_opacity=0., stl_colors=None,
                       xmax=None, ymax=None, zmax=None,
-                      anti_aliasing='ssaa', offscreen=False):
+                      anti_aliasing='ssaa', smooth_shading=False, off_screen=False):
 
         """
         Interactive 3D visualization of the structured grid mask and imported STL geometries.
@@ -704,15 +722,15 @@ def plot_stl_mask(self, stl_solid, cmap='viridis', bounding_box=True, show_grid=
             Color(s) of the STL surfaces:
             * str   → single color for all STL surfaces
             * list  → per-solid colors, in order
-            * dict  → mapping from STL key to color (using `material_colors`)
+            * dict  → mapping from STL key to color
             * None  → use default colors from `self.stl_colors`
         xmax, ymax, zmax : float, optional
             Initial clipping positions along each axis. If None, use the
             maximum domain extent.
         anti_aliasing : {'ssaa', 'fxaa', None}, default 'ssaa'
             Anti-aliasing mode passed to `pl.enable_anti_aliasing`.
-        offscreen : bool, default False
-            If True, render offscreen and export the scene to
+        off_screen : bool, default False
+            If True, render off-screen and export the scene to
             ``grid_stl_mask_<stl_solid>.html``. If False, open an interactive window.
 
         Notes
@@ -726,7 +744,6 @@ def plot_stl_mask(self, stl_solid, cmap='viridis', bounding_box=True, show_grid=
         * A static domain bounding box can be added for reference.
         * Camera, background, and lighting are pre-configured for clarity
         """
-        from .materials import material_colors
         if stl_colors is None:
             stl_colors = self.stl_colors
 
@@ -773,10 +790,7 @@ def update_clip(val, axis="x"):
                     for i, key in enumerate(self.stl_solids):
                         surf = self.read_stl(key)
                         if type(stl_colors) is dict:
-                            if type(stl_colors[key]) is str:
-                                pl.add_mesh(surf, color=material_colors[stl_colors[key]], opacity=stl_opacity, silhouette=dict(color=material_colors[stl_colors[key]]), name=key)
-                            else:
-                                pl.add_mesh(surf, color=stl_colors[key], opacity=stl_opacity, silhouette=dict(color=stl_colors[key]), name=key)
+                            pl.add_mesh(surf, color=stl_colors[key], opacity=stl_opacity, silhouette=dict(color=stl_colors[key]), name=key)
                         elif type(stl_colors) is list:
                             pl.add_mesh(surf, color=stl_colors[i], opacity=stl_opacity, silhouette=dict(color=stl_colors[i]), name=key)
                         else:
@@ -784,19 +798,13 @@ def update_clip(val, axis="x"):
                 else: #add 1 selected stl solid
                     key = add_stl
                     surf = self.read_stl(key)
-                    if type(stl_colors[key]) is str:
-                        pl.add_mesh(surf, color=material_colors[stl_colors[key]], opacity=stl_opacity, silhouette=dict(color=material_colors[stl_colors[key]]), name=key)
-                    else:
-                        pl.add_mesh(surf, color=stl_colors[key], opacity=stl_opacity, silhouette=dict(color=stl_colors[key]), name=key)
+                    pl.add_mesh(surf, color=stl_colors[key], opacity=stl_opacity, silhouette=dict(color=stl_colors[key]), name=key)
 
             elif type(add_stl) is list: #add selected list of stl solids
                 for i, key in enumerate(add_stl):
                     surf = self.read_stl(key)
                     if type(stl_colors[key]) is dict:
-                        if type(stl_colors) is str:
-                            pl.add_mesh(surf, color=material_colors[stl_colors[key]], opacity=stl_opacity, silhouette=dict(color=material_colors[stl_colors[key]]), name=key)
-                        else:
-                            pl.add_mesh(surf, color=stl_colors[key], opacity=stl_opacity, silhouette=dict(color=stl_colors[key]), name=key)
+                        pl.add_mesh(surf, color=stl_colors[key], opacity=stl_opacity, silhouette=dict(color=stl_colors[key]), name=key)
                     elif type(stl_colors) is list:
                         pl.add_mesh(surf, color=stl_colors[i], opacity=stl_opacity, silhouette=dict(color=stl_colors[i]), name=key)
                     else:
@@ -841,13 +849,13 @@ def update_clip(val, axis="x"):
             pl.add_mesh(pv.Box(bounds=(self.xmin, self.xmax, self.ymin, self.ymax, self.zmin, self.zmax)),
             style="wireframe", color="black", line_width=2, name="domain_box")
 
-        if offscreen:
+        if off_screen:
             pl.export_html(f'grid_stl_mask_{stl_solid}.html')
         else:
             pl.show()
 
     def inspect(self, add_stl=None, stl_opacity=0.5, stl_colors=None,
-                anti_aliasing='ssaa', offscreen=False):
+                anti_aliasing='ssaa', smooth_shading=True, off_screen=False):
 
         '''3D plot using pyvista to visualize
         the structured grid and
@@ -862,7 +870,6 @@ def inspect(self, add_stl=None, stl_opacity=0.5, stl_colors=None,
         stl_colors: str or list of str, default 'white'
             Color of the stl surfaces
         '''
-        from .materials import material_colors
         if stl_colors is None:
             stl_colors = self.stl_colors
 
@@ -885,38 +892,29 @@ def clip(widget):
                     key = add_stl
                     surf = self.read_stl(key)
                     surf = surf.clip_box(widget.bounds, invert=False)
-                    if type(stl_colors[key]) is str:
-                        pl.add_mesh(surf, color=material_colors[self.stl_colors[key]], opacity=stl_opacity, silhouette=True, smooth_shading=True, name=key)
-                    else:
-                        pl.add_mesh(surf, color=stl_colors[key], opacity=stl_opacity, silhouette=True, smooth_shading=True, name=key)
+                    pl.add_mesh(surf, color=stl_colors[key], opacity=stl_opacity, silhouette=True, smooth_shading=smooth_shading, name=key)
 
                 elif type(add_stl) is list: #add selected list of stl solids
                     for i, key in enumerate(add_stl):
                         surf = self.read_stl(key)
                         surf = surf.clip_box(widget.bounds, invert=False)
                         if type(stl_colors) is dict:
-                            if type(stl_colors[key]) is str:
-                                pl.add_mesh(surf, color=material_colors[stl_colors[key]], opacity=stl_opacity, silhouette=True, smooth_shading=True, name=key)
-                            else:
-                                pl.add_mesh(surf, color=stl_colors[key], opacity=stl_opacity, silhouette=True, smooth_shading=True, name=key)
+                            pl.add_mesh(surf, color=stl_colors[key], opacity=stl_opacity, silhouette=True, smooth_shading=smooth_shading, name=key)
                         elif type(stl_colors) is list:
-                            pl.add_mesh(surf, color=stl_colors[i], opacity=stl_opacity, silhouette=True, smooth_shading=True, name=key)
+                            pl.add_mesh(surf, color=stl_colors[i], opacity=stl_opacity, silhouette=True, smooth_shading=smooth_shading, name=key)
                         else:
-                            pl.add_mesh(surf, color='white', opacity=stl_opacity, silhouette=True, smooth_shading=True, name=key)
+                            pl.add_mesh(surf, color='white', opacity=stl_opacity, silhouette=True, smooth_shading=smooth_shading, name=key)
 
             else: #add all stl solids
                 for i, key in enumerate(self.stl_solids):
                     surf = self.read_stl(key)
                     surf = surf.clip_box(widget.bounds, invert=False)
                     if type(stl_colors) is dict:
-                        if type(stl_colors[key]) is str:
-                            pl.add_mesh(surf, color=material_colors[stl_colors[key]], opacity=stl_opacity, silhouette=True, smooth_shading=True, name=key)
-                        else:
-                            pl.add_mesh(surf, color=stl_colors[key], opacity=stl_opacity, silhouette=True, smooth_shading=True, name=key)
+                        pl.add_mesh(surf, color=stl_colors[key], opacity=stl_opacity, silhouette=True, smooth_shading=smooth_shading, name=key)
                     elif type(stl_colors) is list:
-                        pl.add_mesh(surf, color=stl_colors[i], opacity=stl_opacity, silhouette=True, smooth_shading=True, name=key)
+                        pl.add_mesh(surf, color=stl_colors[i], opacity=stl_opacity, silhouette=True, smooth_shading=smooth_shading, name=key)
                     else:
-                        pl.add_mesh(surf, color='white', opacity=stl_opacity, silhouette=True, smooth_shading=True, name=key)
+                        pl.add_mesh(surf, color='white', opacity=stl_opacity, silhouette=True, smooth_shading=smooth_shading, name=key)
 
         _ = pl.add_box_widget(callback=clip, rotation_enabled=False)
 
@@ -930,10 +928,13 @@ def clip(widget):
         pl.enable_3_lights()
         pl.enable_anti_aliasing(anti_aliasing)
 
-        if offscreen:
-            pl.export_html('grid_inspect.html')
+        if off_screen:
+            pl.off_screen = True
+            return pl
+            #pl.export_html('grid_inspect.html')
         else:
             pl.show()
+            return None
 
     def save_to_h5(self, filename='grid.h5'):
         '''Save generated grid to HDF5 file
@@ -1023,7 +1024,7 @@ def load_from_h5(self, filename):
         self.zmin, self.zmax = self.z[0], self.z[-1]
 
         # recommpute grid and L, iA, tL, itA
-        self.compute_grid()
+        self._compute_grid()
 
         # asign masks to grid.cell_data
         with h5py.File(filename, 'r') as hf:
diff --git a/wakis/logger.py b/wakis/logger.py
index c51b5fe..c7e9731 100644
--- a/wakis/logger.py
+++ b/wakis/logger.py
@@ -24,10 +24,13 @@ def __init__(self):
         self.solver = {}
         self.wakeSolver = {}
 
-    def save_logs(self):
+    def save_logs(self, results_folder=None):
         """
         Save all logs (grid, solver, wakeSolver) into log-file inside the results folder.
         """
+        if results_folder is not None:
+            self.wakeSolver["results_folder"] = results_folder
+            
         logfile = os.path.join(self.wakeSolver["results_folder"], "wakis.log")
 
         # Write sections
diff --git a/wakis/materials.py b/wakis/materials.py
index 155d8e2..039f933 100644
--- a/wakis/materials.py
+++ b/wakis/materials.py
@@ -38,7 +38,7 @@
 }
 
 material_colors = {
-    'pec' : 'silver',
+    'pec' : 'white',
 
     'vacuum' : 'tab:blue',
 
@@ -46,5 +46,13 @@
 
     'lossy metal' : 'tab:orange',
 
-    'other' : 'white',
+    'copper' : [0.82745099, 0.698039, 0.49019599],
+
+    'berillium' : [0.82745099, 0.698039, 0.49019599],
+
+    'stainless steel' : 'silver',
+
+    'martensite' : [0.,1.,1.],
+
+    'other' : 'cyan',
 }
\ No newline at end of file
diff --git a/wakis/plotting.py b/wakis/plotting.py
index cdf2ef6..f2aefae 100644
--- a/wakis/plotting.py
+++ b/wakis/plotting.py
@@ -3,21 +3,22 @@
 # Copyright (c) CERN, 2024.                   #
 # ########################################### #
 
+import pyvista as pv
 import numpy as np
 import matplotlib.pyplot as plt
 
 class PlotMixin:
-        
+
     def plot3D(self, field='E', component='z', clim=None, hide_solids=None,
                show_solids=None, add_stl=None, stl_opacity=0.1, stl_colors='white',
-               title=None, cmap='jet', 
+               title=None, cmap='jet',
                clip_interactive=False, clip_normal='-y',
-               clip_box=False, clip_bounds=None, 
+               clip_box=False, clip_bounds=None,
                off_screen=False, zoom=0.5, camera_position=None,
                nan_opacity=1.0, n=None):
         '''
         Built-in 3D plotting using PyVista
-        
+
         Parameters:
         -----------
         field: str, default 'E'
@@ -29,10 +30,10 @@ def plot3D(self, field='E', component='z', clim=None, hide_solids=None,
         clim: list, optional
             Colorbar limits for the field plot [min, max]
         hide_solids: bool, optional
-            Mask the values inside solid to np.nan. NaNs will be shown in gray, 
+            Mask the values inside solid to np.nan. NaNs will be shown in gray,
             since there is a bug with the nan_opacity parameter
         show_solids: bool, optional
-            Mask the values outside solid to np.nan. 
+            Mask the values outside solid to np.nan.
         add_stl: str or list, optional
             List or str of stl solids to add to the plot by `pv.add_mesh`
         stl_opacity: float, default 0.1
@@ -44,30 +45,28 @@ def plot3D(self, field='E', component='z', clim=None, hide_solids=None,
         cmap: str, default 'jet'
             Colormap name to use in the field display
         clip_interactive: bool, default False
-            Enable an interactive widget to clip out part of the domain, plane normal is defined by 
+            Enable an interactive widget to clip out part of the domain, plane normal is defined by
             `clip_normal` parameter
         clip_normal: str, default '-y'
             Normal direction of the clip_volume interactive plane
         clip_box: bool, default False
             Enable a static box clipping of the domain. The box bounds are defined by `clip_bounds` parameter
         clip_bounds: Default None
-            List of bounds [xmin, xmax, ymin, ymax, zmin, zmax] of the box to clip if clip_box is active. 
+            List of bounds [xmin, xmax, ymin, ymax, zmin, zmax] of the box to clip if clip_box is active.
         field_on_stl : bool, default False
             Samples the field on the stl file specified in `add_stl`.
         field_opacity : optional, default 1.0
             Sets de opacity of the `field_on_stl` plot
         off_screen: bool, default False
-            Enable plot rendering off screen, for gif frames generation. 
+            Enable plot rendering off screen, for gif frames generation.
             Plot will not be rendered if set to True.
         n: int, optional
             Timestep number to be added to the plot title and figsave title.
         '''
         if self.use_mpi:
-            print('*** plot3D is not supported when `use_mpi=True`')
+            print('[!] plot3D is not supported when `use_mpi=True`')
             return
 
-        import pyvista as pv
-
         if len(field) == 2: #support for e.g. field='Ex'
             component = field[1]
             field = field[0]
@@ -97,7 +96,7 @@ def plot3D(self, field='E', component='z', clim=None, hide_solids=None,
                         else:
                             pl.add_mesh(surf, color=stl_colors, opacity=stl_opacity, smooth_shading=True)
                 else:
-                    key = self.grid.stl_solids.keys()[0] 
+                    key = self.grid.stl_solids.keys()[0]
                     surf = self.grid.read_stl(key)
                     pl.add_mesh(surf, color=stl_colors, opacity=stl_opacity, smooth_shading=True)
 
@@ -109,15 +108,14 @@ def plot3D(self, field='E', component='z', clim=None, hide_solids=None,
                 pl.camera_position = camera_position
 
             pl.set_background('mistyrose', top='white')
-            try: pl.add_logo_widget('docs/img/wakis-logo-pink.png')
-            except: pass
+            self._add_logo_widget(pl)
             pl.camera.zoom(zoom)
             pl.add_axes()
             pl.enable_3_lights()
 
             if off_screen:
                 self.plotter_active = True
-        else: 
+        else:
             pl = self.pl
 
 
@@ -132,7 +130,7 @@ def plot3D(self, field='E', component='z', clim=None, hide_solids=None,
             print("`field` value not valid")
 
         points = self.grid.grid.cell_data_to_point_data() #interpolate
-        
+
         # Mask the values inside solid to np.nan
         if hide_solids is not None:
             tol = np.min([self.dx, self.dy, self.dz])*1e-3
@@ -150,7 +148,7 @@ def plot3D(self, field='E', component='z', clim=None, hide_solids=None,
                     else:
                         mask += select['SelectedPoints'] > 0
 
-            points[field+component][mask] = np.nan 
+            points[field+component][mask] = np.nan
 
         # Mask the values outside solid to np.nan
         if show_solids is not None:
@@ -169,7 +167,7 @@ def plot3D(self, field='E', component='z', clim=None, hide_solids=None,
                     else:
                         mask += select['SelectedPoints'] > 0
 
-            points[field+component][np.logical_not(mask)] = np.nan 
+            points[field+component][np.logical_not(mask)] = np.nan
 
         # Clip a rectangle of the domain
         if clip_box:
@@ -178,14 +176,14 @@ def plot3D(self, field='E', component='z', clim=None, hide_solids=None,
                 clip_bounds = [self.grid.xmax-Lx/2, self.grid.xmax,
                                self.grid.ymax-Ly/2, self.grid.ymax,
                                self.grid.zmin, self.grid.zmax]
-                
+
             ac1 = pl.add_mesh(points.clip_box(bounds=clip_bounds), opacity=nan_opacity,
                               scalars=field+component, cmap=cmap, clim=clim)
-            
+
         # Enable an interactive widget to clip out part of the domain with a plane, with clip_normal
         elif clip_interactive:
             ac1 = pl.add_mesh_clip_plane(points, normal=clip_normal, opacity=1.0,
-                                         scalars=field+component, cmap=cmap, clim=clim, 
+                                         scalars=field+component, cmap=cmap, clim=clim,
                                          normal_rotation=False, nan_opacity=nan_opacity)
         else:
             print('Plotting option inconsistent')
@@ -204,14 +202,14 @@ def plot3D(self, field='E', component='z', clim=None, hide_solids=None,
     def plot3DonSTL(self, field='E', component='z', clim=None, cmap='jet', log_scale=False,
                     stl_with_field=None, field_opacity=1.0, tolerance=None,
                     stl_transparent=None, stl_opacity=0.1, stl_colors='white',
-                    clip_plane = False, clip_interactive=False, 
+                    clip_plane = False, clip_interactive=False,
                     clip_normal='-x', clip_origin=[0,0,0],
-                    clip_box=False, clip_bounds=None, 
-                    title=None, off_screen=False, n=None, 
+                    clip_box=False, clip_bounds=None,
+                    title=None, off_screen=False, n=None,
                     zoom=0.5, camera_position=None, **kwargs):
         '''
         Built-in 3D plotting using PyVista
-        
+
         Parameters:
         -----------
         field: str, default 'E'
@@ -221,13 +219,13 @@ def plot3DonSTL(self, field='E', component='z', clim=None, cmap='jet', log_scale
             3D field compoonent ('x', 'y', 'z', 'Abs') to plot. It will be overriden
             if a component is defined in field
         clim: list, optional
-            Colorbar limits for the field plot [min, max]  
+            Colorbar limits for the field plot [min, max]
         cmap: str or cmap obj, default 'jet'
-            Colormap to use for the field plot     
+            Colormap to use for the field plot
         log_scale: bool, default False
-            Turns on logarithmic scale colorbar         
+            Turns on logarithmic scale colorbar
         stl_with_field : list or str
-            STL str name or list of names to samples the selected field on 
+            STL str name or list of names to samples the selected field on
         field_opacity : optional, default 1.0
             Sets de opacity of the `field_on_stl` plot
         tolerance : float, default None
@@ -239,7 +237,7 @@ def plot3DonSTL(self, field='E', component='z', clim=None, cmap='jet', log_scale
         stl_colors: list or str, default 'white'
             str or list of colors to use for each STL solid
         clip_interactive: bool, default False
-            Enable an interactive widget to clip out part of the domain, plane normal is defined by 
+            Enable an interactive widget to clip out part of the domain, plane normal is defined by
             `clip_normal` parameter
         clip_plane: bool, default False
             Clip stl_with_field surface with a plane and show field on such plane
@@ -250,23 +248,21 @@ def plot3DonSTL(self, field='E', component='z', clim=None, cmap='jet', log_scale
         clip_box: bool, default False
             Enable a static box clipping of the domain. The box bounds are defined by `clip_bounds` parameter
         clip_bounds: Default None
-            List of bounds [xmin, xmax, ymin, ymax, zmin, zmax] of the box to clip if clip_box is active. 
+            List of bounds [xmin, xmax, ymin, ymax, zmin, zmax] of the box to clip if clip_box is active.
         off_screen: bool, default False
-            Enable plot rendering off screen, for gif frames generation. 
+            Enable plot rendering off screen, for gif frames generation.
             Plot will not be rendered if set to True.
         title: str
             Name to use in the .png savefile with off_screen is True
         n: int, optional
             Timestep number to be added to the plot title and figsave title.
         **kwargs: optional
-            PyVista's add_mesh optional arguments: 
+            PyVista's add_mesh optional arguments:
             https://docs.pyvista.org/api/plotting/_autosummary/pyvista.plotter.add_mesh
         '''
         if self.use_mpi:
-            print('*** plot3D is not supported when `use_mpi=True`')
+            print('[!] plot3D is not supported when `use_mpi=True`')
             return
-        
-        import pyvista as pv
 
         if len(field) == 2: #support for e.g. field='Ex'
             component = field[1]
@@ -300,7 +296,7 @@ def plot3DonSTL(self, field='E', component='z', clim=None, cmap='jet', log_scale
 
             if off_screen:
                 self.plotter_active = True
-        else: 
+        else:
             pl = self.pl
 
         # Plot field
@@ -316,65 +312,69 @@ def plot3DonSTL(self, field='E', component='z', clim=None, cmap='jet', log_scale
             print("`field` value not valid")
 
         points = self.grid.grid.cell_data_to_point_data() #interpolate
-        
-        # Interpolate fields on stl 
+
+        # Interpolate fields on stl
         if stl_with_field is not None:
             if type(stl_with_field) is str:
                 key = stl_with_field
                 surf = self.grid.read_stl(key)
                 if clip_plane:
-                    try: surf = surf.clip_closed_surface(normal=clip_normal, origin=clip_origin).subdivide_adaptive(max_edge_len=3*self.dz)
-                    except: print("Surface non-manifold, clip with plane skipped")
+                    try:
+                        surf = surf.clip_closed_surface(normal=clip_normal, origin=clip_origin).subdivide_adaptive(max_edge_len=3*self.dz)
+                    except Exception:
+                        print("[!] Surface non-manifold, clip with plane skipped")
 
-                fieldonsurf = surf.sample(points, tolerance)
+                fieldonsurf = surf.sample(points, tolerance=tolerance)
 
                 if clip_interactive: # interactive plotting with a plane
                     ac1 = pl.add_mesh_clip_plane(fieldonsurf, normal=clip_normal, normal_rotation=False,
                                         scalars=field+component, opacity=field_opacity,
-                                        cmap=cmap, clim=clim, log_scale=log_scale, 
+                                        cmap=cmap, clim=clim, log_scale=log_scale,
                                         **kwargs)
-                        
+
                 elif clip_box: # Clip a rectangle of the domain
                     if clip_bounds is None:
                         Lx, Ly = (self.grid.xmax-self.grid.xmin), (self.grid.ymax-self.grid.ymin)
                         clip_bounds = [self.grid.xmax-Lx/2, self.grid.xmax,
                                     self.grid.ymax-Ly/2, self.grid.ymax,
-                                    self.grid.zmin, self.grid.zmax]    
+                                    self.grid.zmin, self.grid.zmax]
 
                     ac1 = pl.add_mesh(fieldonsurf.clip_box(bounds=clip_bounds), cmap=cmap, clim=clim,
                                   scalars=field+component, opacity=field_opacity,
-                                  log_scale=log_scale, 
+                                  log_scale=log_scale,
                                   **kwargs)
 
                 else:
                     ac1 = pl.add_mesh(fieldonsurf, cmap=cmap, clim=clim,
                                   scalars=field+component, opacity=field_opacity,
-                                  log_scale=log_scale, 
+                                  log_scale=log_scale,
                                   **kwargs)
 
             elif type(stl_with_field) is list:
                 for i, key in enumerate(stl_with_field):
                     surf = self.grid.read_stl(key)
                     if clip_plane:
-                        try: surf = surf.clip_closed_surface(normal=clip_normal, origin=clip_origin)
-                        except: print("Surface non-manifold, clip with plane skipped")
+                        try:
+                            surf = surf.clip_closed_surface(normal=clip_normal, origin=clip_origin)
+                        except Exception:
+                            print("Surface non-manifold, clip with plane skipped")
 
-                    fieldonsurf = surf.sample(points)
+                    fieldonsurf = surf.sample(points, tolerance=tolerance)
 
                     if clip_interactive: # interactive plotting with a plane
                         ac1 = pl.add_mesh_clip_plane(fieldonsurf, normal=clip_normal, normal_rotation=False,
                                         scalars=field+component, opacity=field_opacity,
-                                        cmap=cmap, clim=clim, log_scale=log_scale, 
+                                        cmap=cmap, clim=clim, log_scale=log_scale,
                                         **kwargs)
                     elif clip_box: # Clip a rectangle of the domain
                         if clip_bounds is None:
                             Lx, Ly = (self.grid.xmax-self.grid.xmin), (self.grid.ymax-self.grid.ymin)
                             clip_bounds = [self.grid.xmax-Lx/2, self.grid.xmax,
                                         self.grid.ymax-Ly/2, self.grid.ymax,
-                                        self.grid.zmin, self.grid.zmax]  
+                                        self.grid.zmin, self.grid.zmax]
                         ac1 = pl.add_mesh(fieldonsurf.clip_box(bounds=clip_bounds), cmap=cmap, clim=clim,
                                   scalars=field+component, opacity=field_opacity,
-                                  log_scale=log_scale, **kwargs)  
+                                  log_scale=log_scale, **kwargs)
                     else:
                         ac1 = pl.add_mesh(fieldonsurf, cmap=cmap, clim=clim,
                                       scalars=field+component, opacity=field_opacity,
@@ -388,8 +388,7 @@ def plot3DonSTL(self, field='E', component='z', clim=None, cmap='jet', log_scale
             pl.camera_position = camera_position
 
         pl.set_background('mistyrose', top='white')
-        try: pl.add_logo_widget('docs/img/wakis-logo-pink.png')
-        except: pass
+        self._add_logo_widget(pl)
         pl.camera.zoom(zoom)
         pl.add_axes()
         pl.enable_anti_aliasing()
@@ -407,13 +406,13 @@ def plot3DonSTL(self, field='E', component='z', clim=None, cmap='jet', log_scale
         else:
             pl.show(full_screen=False)
 
-    def plot2D(self, field='E', component='z', plane='ZY', pos=0.5, norm=None, 
-               vmin=None, vmax=None, figsize=[8,4], cmap='jet', patch_alpha=0.1, 
-               patch_reverse=False, add_patch=False, title=None, off_screen=False, 
+    def plot2D(self, field='E', component='z', plane='ZY', pos=0.5, norm=None,
+               vmin=None, vmax=None, figsize=[8,4], cmap='jet', patch_alpha=0.1,
+               patch_reverse=False, add_patch=False, title=None, off_screen=False,
                n=None, interpolation='antialiased', dpi=100, return_handles=False):
         '''
         Built-in 2D plotting of a field slice using matplotlib
-        
+
         Parameters:
         ----------
         field: str, default 'E'
@@ -434,8 +433,8 @@ def plot2D(self, field='E', component='z', plane='ZY', pos=0.5, norm=None,
         vmin: list, optional
             Colorbar min limit for the field plot
         vmax: list, optional
-            Colorbar max limit for the field plot       
-        figsize: list, default [8,4]    
+            Colorbar max limit for the field plot
+        figsize: list, default [8,4]
             Figure size to pass to the plot initialization
         add_patch: str or list, optional
             List or str of stl solids to add to the plot by `pv.add_mesh`
@@ -447,7 +446,7 @@ def plot2D(self, field='E', component='z', plane='ZY', pos=0.5, norm=None,
         cmap: str, default 'jet'
             Colormap name to use in the field display
         off_screen: bool, default False
-            Enable plot rendering off screen, for gif frames generation. 
+            Enable plot rendering off screen, for gif frames generation.
             Plot will not be rendered if set to True.
         n: int, optional
             Timestep number to be added to the plot title and figsave title.
@@ -458,7 +457,7 @@ def plot2D(self, field='E', component='z', plane='ZY', pos=0.5, norm=None,
         from mpl_toolkits.axes_grid1 import make_axes_locatable
 
         Nx, Ny, Nz = self.Nx, self.Ny, self.Nz
-        xmin, xmax = self.grid.xmin, self.grid.xmax 
+        xmin, xmax = self.grid.xmin, self.grid.xmax
         ymin, ymax = self.grid.ymin, self.grid.ymax
         zmin, zmax = self.grid.zmin, self.grid.zmax
         _z = self.z
@@ -467,7 +466,7 @@ def plot2D(self, field='E', component='z', plane='ZY', pos=0.5, norm=None,
             zmin, zmax = self.grid.ZMIN, self.grid.ZMAX
             Nz = self.grid.NZ
             _z = self.grid.Z
-        
+
         if type(field) is str:
             if len(field) == 2: #support for e.g. field='Ex'
                 component = field[1]
@@ -475,30 +474,30 @@ def plot2D(self, field='E', component='z', plane='ZY', pos=0.5, norm=None,
             elif len(field) == 4: #support for e.g. field='EAbs'
                 component = field[1:]
                 field = field[0]
-        
+
         if title is None:
             title = field + component +'2d'
-            
+
         if type(plane) is not str and len(plane) == 3:
             x, y, z = plane[0], plane[1], plane[2]
 
             if type(plane[2]) is int:
                 cut = f'(x,y,a) a={round(self.z[z],3)}'
                 xax, yax = 'y', 'x'
-                extent = [self.y[y].min(), self.y[y].max(), 
-                          self.x[x].min(), self.x[x].max()]            
+                extent = [self.y[y].min(), self.y[y].max(),
+                          self.x[x].min(), self.x[x].max()]
 
             if type(plane[0]) is int:
                 cut = f'(a,y,z) a={round(self.x[x],3)}'
                 xax, yax = 'z', 'y'
-                extent = [_z[z].min(), _z[z].max(), 
-                          self.y[y].min(), self.y[y].max()]    
+                extent = [_z[z].min(), _z[z].max(),
+                          self.y[y].min(), self.y[y].max()]
 
             if type(plane[1]) is int:
                 cut = f'(x,a,z) a={round(self.y[y],3)}'
                 xax, yax = 'z', 'x'
-                extent = [_z[z].min(), _z[z].max(), 
-                          self.x[x].min(), self.x[x].max()]   
+                extent = [_z[z].min(), _z[z].max(),
+                          self.x[x].min(), self.x[x].max()]
 
         elif plane == 'XY':
             x, y, z = slice(0,Nx), slice(0,Ny), int(Nz*pos) #plane XY
@@ -511,13 +510,13 @@ def plot2D(self, field='E', component='z', plane='ZY', pos=0.5, norm=None,
             cut = f'(a,y,z) a={round(pos*(xmax-xmin)+xmin,3)}'
             xax, yax = 'z', 'y'
             extent = [zmin, zmax, ymin, ymax]
-        
+
         elif plane == 'ZX' or plane == 'XZ':
             x, y, z = slice(0,Nx),  int(Ny*pos), slice(0,Nz) #plane XZ
             cut = f'(x,a,z) a={round(pos*(ymax-ymin)+ymin,3)}'
             xax, yax = 'z', 'x'
             extent = [zmin, zmax, xmin, xmax]
-        
+
         else:
             print("Plane needs to be an array of slices [x,y,z] or a str 'XY', 'ZY', 'ZX'")
 
@@ -526,15 +525,15 @@ def plot2D(self, field='E', component='z', plane='ZY', pos=0.5, norm=None,
 
             if self.rank == 0:
                 fig, ax = plt.subplots(1,1, figsize=figsize, dpi=dpi)
-                im = ax.imshow(_field, cmap=cmap,  norm=norm, 
+                im = ax.imshow(_field, cmap=cmap,  norm=norm,
                     extent=extent, origin='lower', vmin=vmin, vmax=vmax,
-                    interpolation=interpolation)  
-            
+                    interpolation=interpolation)
+
                 fig.colorbar(im, cax=make_axes_locatable(ax).append_axes('right', size='5%', pad=0.05))
                 ax.set_title(f'Wakis {field}{component}{cut}')
                 ax.set_xlabel(xax)
                 ax.set_ylabel(yax)
-                
+
                 if n is not None:
                     fig.suptitle('$'+str(field)+'_{'+str(component)+'}$ field, timestep='+str(n))
                     title += '_'+str(n).zfill(6)
@@ -558,10 +557,10 @@ def plot2D(self, field='E', component='z', plane='ZY', pos=0.5, norm=None,
             if field == 'J':
                 _field = self.J[x, y, z, component]
 
-            im = ax.imshow(_field, cmap=cmap,  norm=norm, 
+            im = ax.imshow(_field, cmap=cmap,  norm=norm,
                             extent=extent, origin='lower', vmin=vmin, vmax=vmax,
-                            interpolation=interpolation)  
-                              
+                            interpolation=interpolation)
+
             fig.colorbar(im, cax=make_axes_locatable(ax).append_axes('right', size='5%', pad=0.05))
             ax.set_title(f'Wakis {field}{component}{cut}')
             ax.set_xlabel(xax)
@@ -573,9 +572,9 @@ def plot2D(self, field='E', component='z', plane='ZY', pos=0.5, norm=None,
                     mask = np.reshape(self.grid.grid[add_patch], (Nx, Ny, Nz))
                     patch = np.ones((Nx, Ny, Nz))
                     if patch_reverse:
-                        patch[mask] = np.nan 
+                        patch[mask] = np.nan
                     else:
-                        patch[np.logical_not(mask)] = np.nan 
+                        patch[np.logical_not(mask)] = np.nan
                     ax.imshow(patch[x,y,z], cmap='Greys', extent=extent, origin='lower', alpha=patch_alpha)
 
                 elif type(add_patch) is list:
@@ -583,9 +582,9 @@ def plot2D(self, field='E', component='z', plane='ZY', pos=0.5, norm=None,
                         mask = np.reshape(self.grid.grid[solid], (Nx, Ny, Nz))
                         patch = np.ones((Nx, Ny, Nz))
                         if patch_reverse:
-                            patch[mask] = np.nan 
+                            patch[mask] = np.nan
                         else:
-                            patch[np.logical_not(mask)] = np.nan 
+                            patch[np.logical_not(mask)] = np.nan
                         ax.imshow(patch[x,y,z], cmap='Greys', extent=extent, origin='lower', alpha=patch_alpha)
 
             if n is not None:
@@ -603,13 +602,13 @@ def plot2D(self, field='E', component='z', plane='ZY', pos=0.5, norm=None,
             else:
                 plt.show(block=False)
 
-    def plot1D(self, field='E', component='z', line='z', pos=[0.5], 
-               xscale='linear', yscale='linear', xlim=None, ylim=None, 
+    def plot1D(self, field='E', component='z', line='z', pos=[0.5],
+               xscale='linear', yscale='linear', xlim=None, ylim=None,
                figsize=[8,4], title=None, off_screen=False, n=None,
                colors=None, **kwargs):
         '''
         Built-in 1D plotting of a field line using matplotlib
-        
+
         Parameters:
         ----------
         field: str, default 'E'
@@ -621,13 +620,13 @@ def plot1D(self, field='E', component='z', line='z', pos=[0.5],
         line: str or list, default 'z'
             line of indexes to plot. E.g. line=[0, slice(10,Ny-10), 0]
         pos: float or list, default 0.5
-            Float or list of floats betwwen 0-1 indicating the cut position. 
+            Float or list of floats betwwen 0-1 indicating the cut position.
             Only used if line is str.
         xlim, ylim: tupple
             limits for x and y axis (see matplotlib.ax.set_xlim for more)
         xscale, yscale: str
             scale to use in x and y axes (see matplotlib.ax.set_xscale for more)
-        figsize: list, default [8,4]    
+        figsize: list, default [8,4]
             Figure size to pass to the plot initialization
         title: str, optional
             Title used to save the screenshot of the 3D plot (Path+Name) if off_screen=True.
@@ -635,7 +634,7 @@ def plot1D(self, field='E', component='z', line='z', pos=[0.5],
         cmap: str, default 'jet'
             Colormap name to use in the field display
         off_screen: bool, default False
-            Enable plot rendering off screen, for gif frames generation. 
+            Enable plot rendering off screen, for gif frames generation.
             Plot will not be rendered if set to True.
         n: int, optional
             Timestep number to be added to the plot title and figsave title.
@@ -643,11 +642,11 @@ def plot1D(self, field='E', component='z', line='z', pos=[0.5],
             List of matplotlib-compatible colors. len(colors) >= len(pos)
         **kwargs:
             Keyword arguments to be passed to the `matplotlib.plot` function.
-            Default kwargs used: 
+            Default kwargs used:
                 kwargs = {'color':'g', 'lw':1.2, 'ls':'-'}
         '''
         Nx, Ny, Nz = self.Nx, self.Ny, self.Nz
-        xmin, xmax = self.grid.xmin, self.grid.xmax 
+        xmin, xmax = self.grid.xmin, self.grid.xmax
         ymin, ymax = self.grid.ymin, self.grid.ymax
         zmin, zmax = self.grid.zmin, self.grid.zmax
         _z = self.z
@@ -663,45 +662,45 @@ def plot1D(self, field='E', component='z', line='z', pos=[0.5],
 
 
         plotkw = {'lw':1.2, 'ls':'-'}
-        
+
         if colors is None:
-            colors = ['k', 'tab:red', 'tab:blue', 'tab:green', 
+            colors = ['k', 'tab:red', 'tab:blue', 'tab:green',
                     'tab:orange', 'tab:purple', 'tab:pink']
         plotkw.update(kwargs)
 
         if len(field) == 2: #support for e.g. field='Ex'
             component = field[1]
             field = field[0]
-        
+
         if title is None:
             title = field + component +'1d'
-        
+
         if type(pos) is not list: #support for a list of cut positions
             pos_arr = [pos]
         else:
             pos_arr = pos
-        
+
         for i, pos in enumerate(pos_arr):
 
             if type(line) is not str and len(line) == 3:
                 x, y, z = line[0], line[1], line[2]
 
                 #z-axis
-                if type(line[2]) is slice:  
+                if type(line[2]) is slice:
                     cut = f'(a,b,z) a={round(self.x[x],3)}, b={round(self.y[y],3)}'
                     xax = 'z'
                     xx = _z[z]
                     xlims = (_z[z].min(), _z[z].max())
-                
+
                 #x-axis
-                elif type(line[0]) is slice:  
+                elif type(line[0]) is slice:
                     cut = f'(x,a,b) a={round(self.y[y],3)}, b={round(_z[z],3)}'
                     xax = 'x'
                     xx = self.x[x]
                     xlims = (self.x[x].min(), self.x[x].max())
 
                 #y-axis
-                elif type(line[1]) is slice:  
+                elif type(line[1]) is slice:
                     cut = f'(a,y,b) a={round(self.x[x],3)}, b={round(_z[z],3)}'
                     xax = 'y'
                     xx = self.y[y]
@@ -720,20 +719,21 @@ def plot1D(self, field='E', component='z', line='z', pos=[0.5],
                 xax = 'y'
                 xx = self.y[y]
                 xlims = (ymin, ymax)
-            
+
             elif line.lower() == 'z':
                 x, y, z = int(Nx*pos), int(Ny*pos), slice(0,Nz) #z-axis
                 cut = f'(a,b,z) a={round(self.x[x],3)}, b={round(self.y[y],3)}'
                 xax = 'z'
                 xx = _z[z]
                 xlims = (zmin, zmax)
-            
+
             else:
                 print("line needs to be an array of slices [x,y,z] or a str 'x', 'y', 'z'")
 
             if i == 0: # first one on top
                 zorder = 10
-            else: zorder = i
+            else:
+                zorder = i
 
             if self.use_mpi: # only in rank=0
                 _field = self.mpi_gather(field, x=x, y=y, z=z, component=component)
@@ -754,7 +754,7 @@ def plot1D(self, field='E', component='z', line='z', pos=[0.5],
 
         if not self.use_mpi:
             yax = f'{field}{component} amplitude'
-                            
+
             ax.set_title(f'Wakis {field}{component}'+(len(pos_arr)==1)*f'{cut}')
             ax.set_xlabel(xax)
             ax.set_ylabel(yax, color=colors[0])
@@ -787,7 +787,7 @@ def plot1D(self, field='E', component='z', line='z', pos=[0.5],
 
         elif self.use_mpi and self.rank == 0:
             yax = f'{field}{component} amplitude'
-                            
+
             ax.set_title(f'Wakis {field}{component}'+(len(pos_arr)==1)*f'{cut}')
             ax.set_xlabel(xax)
             ax.set_ylabel(yax, color=colors[0])
@@ -818,3 +818,161 @@ def plot1D(self, field='E', component='z', line='z', pos=[0.5],
             else:
                 plt.show()
 
+    def inspect(self, wake=None, window_size=None, off_screen=False,
+                opacity=1.0, inactive_opacity=0.1, add_silhouette=False,
+                specular=0.5, smooth_shading=False):
+
+        if self.use_mpi:
+            print('[!] plot3D is not supported when `use_mpi=True`')
+            return
+        if wake is not None:
+            self.wake = wake
+
+        # Initialize plotter
+        pl = pv.Plotter(window_size=window_size)
+        solid_state = {}
+        for key, path in self.stl_solids.items():
+            surf = self.grid.read_stl(key)
+            color = self.stl_colors.get(key, "lightgray")
+            actor = pl.add_mesh(surf, color=color, name=key,
+                                opacity=inactive_opacity, silhouette=False,
+                                smooth_shading=smooth_shading, specular=specular)
+            sil = None
+            if add_silhouette:
+                sil = pl.add_silhouette(surf, color="black", line_width=3.0)
+                sil.SetVisibility(False)
+
+            solid_state[key] = {
+                "actor": actor,
+                "silhouette": sil,
+                "active_opacity": opacity,
+                "inactive_opacity": inactive_opacity,
+                "checked": False,
+                "highlight": False,
+                "button": None,
+            }
+
+        # UI scale and solid checkboxes positioning
+        w, h = pl.window_size
+        ui = h / 800.0
+        box = max(16, int(20 * ui))
+        font = max(8, int(12 * ui))
+        pad = int(10 * ui)
+        dy = box + pad
+        cx = int(10 * ui)
+        cy = h // 2
+
+        # checkboxes callbacks for solids and master (all On/Off)
+        color_on = 'green'
+        color_off = 'white'
+        def apply(state):
+            if state["highlight"]:
+                state["actor"].GetProperty().SetOpacity(state["active_opacity"])
+                if add_silhouette:
+                    state["silhouette"].SetVisibility(True)
+            else:
+                state["actor"].GetProperty().SetOpacity(state["inactive_opacity"])
+                if add_silhouette:
+                    state["silhouette"].SetVisibility(False)
+
+        def make_cb(name):
+            def _cb(v):
+                s = solid_state[name]
+                s["checked"] = bool(v)
+                s["highlight"] = s["checked"]
+                apply(s)
+            return _cb
+
+        master_on = True
+        def master_cb(v):
+            nonlocal master_on
+            master_on = bool(v)
+            for s in solid_state.values():
+                s["checked"] = master_on
+                s["highlight"] = master_on
+                btn = s["button"]
+                if btn:
+                    rep = btn.GetRepresentation()
+                    if hasattr(rep, "SetState"):
+                        rep.SetState(1 if master_on else 0)
+                apply(s)
+
+        pl.add_checkbox_button_widget(master_cb, value=False,
+                                    color_on=color_on, color_off=color_off,
+                                    position=(cx, cy), size=box)
+        pl.add_text("All on", position=(cx + box + pad, cy), font_size=font)
+
+        for i, name in enumerate(solid_state):
+            y = cy - (i + 2) * dy
+            _color_on = self.stl_colors.get(name, color_on)
+            if str(_color_on) == 'white' or list(_color_on) == [1.0, 1.0, 1.0]:
+                _color_on = 'gray'
+            btn = pl.add_checkbox_button_widget(make_cb(name), value=False,
+                                                color_on=_color_on,
+                                                color_off=color_off,
+                                                position=(cx, y), size=box)
+            solid_state[name]["button"] = btn
+            pl.add_text(name, position=(cx + box + pad, y), font_size=font)
+
+        # Add beam & integration path checkboxes if wake object is passed
+        if self.wake is not None:
+            z_center = 0.5 * (self.grid.zmin + self.grid.zmax)
+            z_height = self.grid.zmax - self.grid.zmin
+            radius = 0.005 * max(self.grid.xmax-self.grid.xmin, self.grid.ymax-self.grid.ymin)
+
+            beam = pv.Cylinder(center=(self.wake.xsource, self.wake.ysource, z_center),
+                              direction=(0, 0, 1), height=z_height, radius=radius*1.1)
+            path = pv.Cylinder(center=(self.wake.xtest, self.wake.ytest, z_center),
+                               direction=(0, 0, 1), height=z_height, radius=radius)
+
+            beam_actor = pl.add_mesh(beam, color="orange", name="beam", opacity=1.0)
+            beam_actor.SetVisibility(True)
+            path_actor = pl.add_mesh(path, color="blue", name="integration_path", opacity=1.0)
+            path_actor.SetVisibility(True)
+
+            bx = int(w - box - 200 * ui)
+            to = box + pad
+
+            def beam_cb(v):
+                beam_actor.SetVisibility(bool(v))
+            def path_cb(v):
+                path_actor.SetVisibility(bool(v))
+
+            pl.add_checkbox_button_widget(path_cb, value=True,
+                                        color_off=color_off, color_on="blue",
+                                        position=(bx, cy + dy), size=box)
+            pl.add_text("Integration path", position=(bx + to, cy + dy), font_size=font)
+
+            pl.add_checkbox_button_widget(beam_cb, value=True,
+                                        color_off=color_off, color_on="orange",
+                                        position=(bx, cy), size=box)
+            pl.add_text("Beam", position=(bx + to, cy), font_size=font)
+
+        pl.set_background('mistyrose', top='white')
+        self._add_logo_widget(pl)
+        pl.add_axes()
+
+        # Save
+        if off_screen:
+            pl.off_screen = True
+            return pl
+        else:
+            pl.show()
+            return None
+
+    def _add_logo_widget(self, pl):
+        """Add packaged logo via importlib.resources (Python 3.9+)."""
+        try:
+            from importlib import resources
+            # resource inside the installed package (use current package)
+            logo_res = resources.files(__package__).joinpath('static', 'img', 'wakis-logo-pink.png')
+            with resources.as_file(logo_res) as logo_path:
+                pl.add_logo_widget(str(logo_path))
+                return
+        except Exception as e:
+            # fallback to the legacy relative path for dev installs
+            try:
+                pl.add_logo_widget('../docs/img/wakis-logo-pink.png')
+            except Exception:
+                if self.verbose > 1:
+                    print(f'[!] Could not add logo widget: {e}')
\ No newline at end of file
diff --git a/wakis/solverFIT3D.py b/wakis/solverFIT3D.py
index 7ad4cda..9b4c185 100644
--- a/wakis/solverFIT3D.py
+++ b/wakis/solverFIT3D.py
@@ -137,6 +137,8 @@ def __init__(self, grid, wake=None, cfln=0.5, dt=None,
 
         # Wake computation
         self.wake = wake
+        if self.wake is not None:
+            self.logger.wakeSolver=self.wake.logger.wakeSolver
 
         # Fields
         self.dtype = dtype
@@ -181,7 +183,7 @@ def __init__(self, grid, wake=None, cfln=0.5, dt=None,
         self.bc_low = bc_low
         self.bc_high = bc_high
         self.update_logger(['bc_low', 'bc_high'])
-        self.apply_bc_to_C() 
+        self.apply_bc_to_C()
 
         # Materials
         if verbose:
@@ -952,6 +954,7 @@ def apply_stl(self):
         grid = self.grid.grid
         self.stl_solids = self.grid.stl_solids
         self.stl_materials = self.grid.stl_materials
+        self.stl_colors = self.grid.stl_colors
 
         for key in self.stl_solids.keys():