diff --git a/plotter.py b/plotter.py
index 2f823dd..862fd52 100644
--- a/plotter.py
+++ b/plotter.py
@@ -946,18 +946,21 @@ class Plotter(Aggregator, BaseProcessor):
             self, name, ax_los, extent, unit=U.km_s, unit_coeff=1.0, reduce_res=1, kind="quiver", **kwargs
     ):
         """
-        Add an overlay : velocity vector field
+        Add an overlay : vector field
         """
 
-        self.current_processor.process(f"{name}_h", ax_los)
-        self.current_processor.process(f"{name}_v", ax_los)
+        ax_h = self._axes_h[ax_los]
+        ax_v = self._axes_v[ax_los]
 
-        map_h = self.current_processor.get_value("/maps/speed_h_{}".format(ax_los))
-        map_v = self.current_processor.get_value("/maps/speed_v_{}".format(ax_los))
-        label, unit_old, unit = self._ax_label_unit(f"/maps/speed_h_{ax_los}", "", unit, unit_coeff)
+        self.current_processor.process(f"slice_{name}{ax_h}", ax_los)
+        self.current_processor.process(f"slice_{name}{ax_v}", ax_los)
+
+        map_h = self.current_processor.get_value(f"/maps/slice_{name}{ax_h}_{ax_los}")
+        map_v = self.current_processor.get_value(f"/maps/slice_{name}{ax_v}_{ax_los}")
+        label, unit_old, unit = self._ax_label_unit(f"/maps/slice_{name}{ax_h}_{ax_los}", "", unit, unit_coeff)
 
 
-        # take only a subset of velocities
+        # take only a subset
         map_h = map_h[::reduce_res, ::reduce_res] * unit_old.express(unit)
         map_v = map_v[::reduce_res, ::reduce_res] * unit_old.express(unit)
 
@@ -969,7 +972,7 @@ class Plotter(Aggregator, BaseProcessor):
             line_integral_convolution(plt.gca(), map_h, map_v, extent=extent, **kwargs)
 
     def _overlay_speed(self, ax_los, extent,  **kwargs):
-        self._overlay_vector("speed", ax_los, extent, **kwargs)
+        self._overlay_vector("vel", ax_los, extent, **kwargs)
 
     def _overlay_B(self, ax_los, extent, **kwargs):
         self._overlay_vector("B", ax_los, extent, **kwargs)
@@ -1453,31 +1456,7 @@ class Plotter(Aggregator, BaseProcessor):
                     overlays=[self._overlay_speed],
                 ),
                 "Density slice with speed overlay",
-                dependencies=["slice_rho", "speed_h", "speed_v"],
-            ),
-            "slice_rho_B": PlotRule(
-                self,
-                partial(
-                    self._plot_map,
-                    "slice_rho",
-                    label=r"$\rho$",
-                    unit=U.Msun_pc3,
-                    overlays=[self._overlay_B],
-                ),
-                "Density slice with magnetic field overlay",
-                dependencies=["slice_rho", "B_h", "B_v"],
-            ),
-            "slice_rho_B_vel": PlotRule(
-                self,
-                partial(
-                    self._plot_map,
-                    "slice_rho",
-                    label=r"$\rho$",
-                    unit=U.Msun_pc3,
-                    overlays=[self._overlay_B, self._overlay_speed],
-                ),
-                "Density slice with magnetic field and velocity  overlay",
-                dependencies=["slice_rho", "B_h", "B_v", "speed_h", "speed_v"],
+                dependencies=["slice_rho"],
             ),
             "jeans_ratio": PlotRule(
                 self,
@@ -1548,14 +1527,6 @@ class Plotter(Aggregator, BaseProcessor):
                 "P-PDF on a 2D slice ",
                 dependencies=["P_pdf"],
             ),
-            "B_int": PlotRule(
-                self,
-                partial(
-                    self._plot_map, "B_int", label=r"$\mid \mathrm{B} \mid$", unit=U.T
-                ),
-                "Magnetic intensity map",
-                dependencies=["B_int"],
-            ),
             "Brho": PlotRule(
                 self,
                 partial(
@@ -1902,7 +1873,9 @@ class Plotter(Aggregator, BaseProcessor):
 
         # Dict of overlays
         self.overlays = {
+            "g": partial(self._overlay_vector, "g"),
             "B": self._overlay_B,
+            "vel": self._overlay_speed,
             "speed": self._overlay_speed,
             "levels": self._overlay_levels,
             "contour": self._overlay_contour,
diff --git a/snapshotprocessor.py b/snapshotprocessor.py
index 452c981..217bd41 100644
--- a/snapshotprocessor.py
+++ b/snapshotprocessor.py
@@ -910,34 +910,6 @@ class SnapshotProcessor(HDF5Container):
         datamap = self._rt.process(self._cam[ax_los], surf_qty=True)
         return datamap.map.T
 
-    def _vector_h(self, name, unit, ax_los, z=0.0):
-        h_op = ScalarOperator(
-            lambda dset: dset[name][:, self._ax_nb[self._axes_h[ax_los]]],
-            self._ro.info[unit],
-        )
-        dmap_h = slicing.SliceMap(self._amr, self._cam[ax_los], h_op, z=z).map.T
-        return dmap_h
-
-    def _vector_v(self, name, unit, ax_los, z=0.0):
-        v_op = ScalarOperator(
-            lambda dset: dset[name][:, self._ax_nb[self._axes_v[ax_los]]],
-            self._ro.info[unit],
-        )
-        dmap_v = slicing.SliceMap(self._amr, self._cam[ax_los], v_op, z=z).map.T
-        return dmap_v
-
-    def _speed_h(self, ax_los, z=0.0):
-        return self._vector_h("vel", "unit_velocity", ax_los, z)
-
-    def _speed_v(self, ax_los, z=0.0):
-        return self._vector_v("vel", "unit_velocity", ax_los, z)
-
-    def _B_h(self, ax_los, z=0.0):
-        return self._vector_h("Br", "unit_mag", ax_los, z)
-
-    def _B_v(self, ax_los, z=0.0):
-        return self._vector_v("Br", "unit_mag", ax_los, z)
-
     def _B_int(self, ax_los, z=0.0):
         """
         Slice ont the intensity of the magnetic field
@@ -1595,34 +1567,6 @@ class SnapshotProcessor(HDF5Container):
                 unit=U.none,
                 dependencies=["avg_map_coldens", "avg_map_T_mwavg"],
             ),
-            "speed_h": Rule(
-                self,
-                self._speed_h,
-                "Horizontal speed slice wrt the line of sight",
-                "/maps",
-                unit=self.info["unit_velocity"],
-            ),
-            "speed_v": Rule(
-                self,
-                self._speed_v,
-                "Vertical speed slice wrt the line of sight",
-                "/maps",
-                unit=self.info["unit_velocity"],
-            ),
-            "B_h": Rule(
-                self,
-                self._B_h,
-                "Horizontal slice of the magnetic field wrt the line of sight",
-                "/maps",
-                unit=self.info["unit_mag"],
-            ),
-            "B_v": Rule(
-                self,
-                self._B_v,
-                "Vertical  slice  of the magnetic field wrt the line of sight",
-                "/maps",
-                unit=self.info["unit_mag"],
-            ),
             "T": Rule(
                 self,
                 self._temperature,