update plotting

Framework/API/inc/MantidAPI/MatrixWorkspace.h

@@ -32,7 +32,7 @@ namespace Geometry {
 class ParameterMap;
 }
 
-const std::vector<std::string> validPlotTypes{"plot", "scatter", "histogram", "errorbar"};
+const std::vector<std::string> validPlotTypes{"plot", "marker", "histogram", "errorbar_x", "errorbar_y", "errorbar_xy"};
 
 namespace API {
 class Axis;
@@ -141,6 +141,16 @@ class MANTID_API_DLL MatrixWorkspace : public IMDWorkspace, public ExperimentInf
   /// Gets MatrixWorkspace plot_type
   std::string getPlotType() const;
 
+  /// Set the marker style for plotting
+  void setMarkerStyle(const std::string &markerType);
+  /// Get the marker style for plotting
+  std::string getMarkerStyle() const;
+
+  /// Set the size of the marker for plotting
+  void setMarkerSize(const float markerSize);
+  /// Get the size of the marker for plotting
+  float getMarkerSize() const;
+
   virtual Types::Core::DateAndTime getFirstPulseTime() const;
   Types::Core::DateAndTime getLastPulseTime() const;
 
@@ -520,6 +530,10 @@ class MANTID_API_DLL MatrixWorkspace : public IMDWorkspace, public ExperimentInf
   mutable std::atomic<bool> m_indexInfoNeedsUpdate{true};
   mutable std::mutex m_indexInfoMutex;
 
+  // Marker style and size, used for plotting
+  std::string m_marker;
+  float m_marker_size;
+
 protected:
   /// Getter for the dimension id based on the axis.
   std::string getDimensionIdFromAxis(const int &axisIndex) const;

Framework/API/src/MatrixWorkspace.cpp

@@ -111,12 +111,13 @@ const std::string MatrixWorkspace::yDimensionId = "yDimension";
 
 /// Default constructor
 MatrixWorkspace::MatrixWorkspace()
-    : IMDWorkspace(), ExperimentInfo(), m_axes(), m_isInitialized(false), m_YUnit(), m_YUnitLabel(), m_masks() {}
+    : IMDWorkspace(), ExperimentInfo(), m_axes(), m_isInitialized(false), m_YUnit(), m_YUnitLabel(), m_masks(),
+      m_marker_size(6.) {}
 
 MatrixWorkspace::MatrixWorkspace(const MatrixWorkspace &other)
     : IMDWorkspace(other), ExperimentInfo(other), m_indexInfo(std::make_unique<Indexing::IndexInfo>(other.indexInfo())),
       m_isInitialized(other.m_isInitialized), m_YUnit(other.m_YUnit), m_YUnitLabel(other.m_YUnitLabel),
-      m_masks(other.m_masks), m_indexInfoNeedsUpdate(false) {
+      m_masks(other.m_masks), m_indexInfoNeedsUpdate(false), m_marker_size(6.) {
   m_axes.resize(other.m_axes.size());
   for (size_t i = 0; i < m_axes.size(); ++i)
     m_axes[i] = std::unique_ptr<Axis>(other.m_axes[i]->clone(this));
@@ -325,7 +326,7 @@ const std::string MatrixWorkspace::getTitle() const {
 
 /** Set the plot type of the workspace
  *
- * @param t :: The plot type. Must be one of: ["plot", "scatter", "histogram", "errorbar"]
+ * @param t :: The plot type. Must be one of: ["plot", "marker", "histogram", "errorbar_x", "errorbar_y", "errorbar_xy"]
  */
 void MatrixWorkspace::setPlotType(const std::string &t) {
   Run &run = mutableRun();
@@ -353,6 +354,41 @@ std::string MatrixWorkspace::getPlotType() const {
   return plotType;
 }
 
+/**
+ * set marker type
+ *
+ * @param marker :: The Marker Type
+ */
+void MatrixWorkspace::setMarkerStyle(const std::string &markerType) { m_marker = markerType; }
+
+/**
+ * get the marker type
+ *
+ * @return std::string :: the marker type
+ */
+std::string MatrixWorkspace::getMarkerStyle() const {
+  if (m_marker.empty())
+    return Kernel::ConfigService::Instance().getString("markerworkspace.marker.Style");
+  else
+    return m_marker;
+}
+
+/**
+ * Set the marker size for plotting
+ *
+ * @param size :: size of the marker
+ */
+void MatrixWorkspace::setMarkerSize(const float size) {
+  if (size > 0)
+    m_marker_size = size;
+}
+/**
+ * Get the marker size for plotting
+ *
+ * @return int :: marker size
+ */
+float MatrixWorkspace::getMarkerSize() const { return m_marker_size; }
+
 void MatrixWorkspace::updateSpectraUsing(const SpectrumDetectorMapping &map) {
   for (size_t j = 0; j < getNumberHistograms(); ++j) {
     auto &spec = getSpectrum(j);

Framework/API/test/MatrixWorkspaceTest.h

@@ -411,8 +411,17 @@ class MatrixWorkspaceTest : public CxxTest::TestSuite {
     TS_ASSERT_EQUALS(ws->getPlotType(), "plot");
 
     // test valid is accepted
-    ws->setPlotType("scatter");
-    TS_ASSERT_EQUALS(ws->getPlotType(), "scatter");
+    ws->setPlotType("marker");
+    TS_ASSERT_EQUALS(ws->getPlotType(), "marker");
+  }
+
+  void testGetSetMarkerStyle() {
+    // test default
+    TS_ASSERT_EQUALS(ws->getMarkerStyle(), "");
+
+    // test set
+    ws->setMarkerStyle("square");
+    TS_ASSERT_EQUALS(ws->getMarkerStyle(), "square");
   }
 
   void testGetSetComment() {

Framework/Properties/Mantid.properties.template

@@ -314,6 +314,12 @@ plots.errorbar.errorEvery = 1
 # Default width of error bars in 1d plots
 plots.errorbar.Width = 1.0
 
+# Default marker style for the errorbar workspace
+plots.errorbar.MarkerStyle = circle
+
+# Default marker size for the errorbar workspace
+plots.errorbar.MarkerSize = 4
+
 # Default legend location
 plots.legend.Location = best
 
@@ -326,8 +332,14 @@ plots.images.Colormap = viridis
 # Default colorbar scale for image plots
 plots.images.ColorBarScale = Linear
 
+# Default marker style for marker workspace plots
+plots.markerworkspace.MarkerStyle = vline
+
+# Default marker size for marker workspace plots
+plots.markerworkspace.MarkerSize = 6
+
 # Profiler Default Filename
-performancelog.filename = algorithmregister.out
+performancelog.filename = algotimeregister.out
 
 # Algorithm Profiler Default Status
 performancelog.write = Off

Framework/PythonInterface/mantid/api/src/Exports/MatrixWorkspace.cpp

@@ -333,6 +333,8 @@ void export_MatrixWorkspace() {
       .def("getNumberHistograms", &MatrixWorkspace::getNumberHistograms, arg("self"),
            "Returns the number of spectra in the workspace")
       .def("getPlotType", &MatrixWorkspace::getPlotType, arg("self"), "Returns the plot type of the workspace")
+      .def("getMarkerStyle", &MatrixWorkspace::getMarkerStyle, arg("self"), "Return the marker style for the workspace")
+      .def("getMarkerSize", &MatrixWorkspace::getMarkerSize, arg("self"), "Returns the marker size for the workspace")
       .def("getSpectrumNumbers", &getSpectrumNumbers, arg("self"),
            "Returns a list of all spectrum numbers in the workspace")
       .def("yIndexOfX", &MatrixWorkspace::yIndexOfX,
@@ -399,6 +401,10 @@ void export_MatrixWorkspace() {
       //------------------------------------
       .def("setPlotType", &MatrixWorkspace::setPlotType, (arg("self"), arg("newType")),
            "Sets a new plot type for the workspace")
+      .def("setMarkerStyle", &MatrixWorkspace::setMarkerStyle, (arg("self"), arg("markerType")),
+           "Sets the marker type for the workspace")
+      .def("setMarkerSize", &MatrixWorkspace::setMarkerSize, (arg("self"), arg("markerSize")),
+           "Sets the size of the marker for the workspace")
       .def("setYUnitLabel", &MatrixWorkspace::setYUnitLabel, (arg("self"), arg("newLabel")),
            "Sets a new caption for the data (Y axis) in the workspace")
       .def("setYUnit", &MatrixWorkspace::setYUnit, (arg("self"), arg("newUnit")),

Framework/PythonInterface/mantid/plots/axesfunctions.py

@@ -126,7 +126,7 @@ def _get_data_for_plot(axes, workspace, kwargs, with_dy=False, with_dx=False):
         workspace_index, distribution, kwargs = get_wksp_index_dist_and_label(workspace, axis, **kwargs)
         if axis == MantidAxType.BIN:
             # get_bin returns the bin *without the monitor data*
-            x, y, dy, dx = get_bins(workspace, workspace_index, with_dy)
+            x, y, dy, dx = get_bins(workspace, workspace_index, with_dy, with_dx)
             vertical_axis = workspace.getAxis(1)
             if isinstance(vertical_axis, mantid.api.NumericAxis):
                 axes.set_xlabel(vertical_axis.getUnit().unitID())
@@ -281,8 +281,22 @@ def errorbar(axes, workspace, *args, **kwargs):
     keyword for MDHistoWorkspaces. These type of workspaces have to have exactly one non integrated
     dimension
     """
+    withDy = True
+    withDx = False
+    if isinstance(workspace, mantid.api.MatrixWorkspace) and workspace.run().hasProperty("plot_type"):
+        plot_type = workspace.run().getProperty("plot_type").value
+        if plot_type == "errorbar_x":
+            withDy = False
+            withDx = True
+        if plot_type == "errorbar_y":
+            withDy = True
+            withDx = False
+        if plot_type == "errorbar_xy":
+            withDy = True
+            withDx = True
+
     normalize_by_bin_width, kwargs = get_normalize_by_bin_width(workspace, axes, **kwargs)
-    x, y, dy, dx, indices, axis, kwargs = _get_data_for_plot(axes, workspace, kwargs, with_dy=True, with_dx=False)
+    x, y, dy, dx, indices, axis, kwargs = _get_data_for_plot(axes, workspace, kwargs, with_dy=withDy, with_dx=withDx)
     if kwargs.pop("update_axes_labels", True):
         _setLabels1D(axes, workspace, indices, normalize_by_bin_width=normalize_by_bin_width, axis=axis)
     kwargs.pop("normalize_by_bin_width", None)

Framework/PythonInterface/mantid/plots/datafunctions.py

@@ -404,7 +404,7 @@ def get_bin_indices(workspace):
         return indices
 
 
-def get_bins(workspace, bin_index, withDy=False):
+def get_bins(workspace, bin_index, withDy=False, withDx=False):
     """
     Extract a requested bin from each spectrum, except if they correspond to monitors
 
@@ -416,14 +416,17 @@ def get_bins(workspace, bin_index, withDy=False):
     indices = get_bin_indices(workspace)
     x_values, y_values = [], []
     dy = [] if withDy else None
+    dx = [] if withDx else None
     for row_index in indices:
         y_data = workspace.readY(int(row_index))
         if bin_index < len(y_data):
             x_values.append(row_index)
             y_values.append(y_data[bin_index])
             if withDy:
                 dy.append(workspace.readE(int(row_index))[bin_index])
-    dx = None
+            if withDx:
+                dx.append(workspace.readDx(int(row_index))[bin_index])
+
     return x_values, y_values, dy, dx
 
 

Framework/PythonInterface/mantid/plots/mantidaxes.py

@@ -28,10 +28,11 @@
 
 from mantid import logger
 from mantid.api import AnalysisDataService as ads
+from mantid.api import MatrixWorkspace
 from mantid.plots import datafunctions, axesfunctions, axesfunctions3D
 from mantid.plots.legend import LegendProperties
 from mantid.plots.datafunctions import get_normalize_by_bin_width
-from mantid.plots.utility import artists_hidden, autoscale_on_update, legend_set_draggable, MantidAxType
+from mantid.plots.utility import artists_hidden, autoscale_on_update, legend_set_draggable, MantidAxType, get_plot_specific_properties
 
 
 WATERFALL_XOFFSET_DEFAULT, WATERFALL_YOFFSET_DEFAULT = 10, 20
@@ -694,6 +695,8 @@ def _data_update(artists, workspace, new_kwargs=None):
             spec_num = self.get_spec_number_or_bin(workspace, kwargs)
             normalize_by_bin_width, kwargs = get_normalize_by_bin_width(workspace, self, **kwargs)
             is_normalized = normalize_by_bin_width or (hasattr(workspace, "isDistribution") and workspace.isDistribution())
+            if isinstance(workspace, MatrixWorkspace):
+                kwargs = get_plot_specific_properties(workspace, workspace.getPlotType(), kwargs)
             with autoscale_on_update(self, autoscale_on):
                 artist = self.track_workspace_artist(
                     workspace,

Framework/PythonInterface/mantid/plots/plotfunctions.py

@@ -22,53 +22,13 @@
 from mantid.api import IMDHistoWorkspace
 from mantid.kernel import ConfigService
 from mantid.plots import datafunctions, MantidAxes
-from mantid.plots.utility import MantidAxType
+from mantid.plots.utility import MantidAxType, MARKER_MAP, get_plot_specific_properties
 
 # -----------------------------------------------------------------------------
 # Constants
 # -----------------------------------------------------------------------------
 PROJECTION = "mantid"
 
-MARKER_MAP = {
-    "square": "s",
-    "plus (filled)": "P",
-    "point": ".",
-    "tickdown": 3,
-    "triangle_right": ">",
-    "tickup": 2,
-    "hline": "_",
-    "vline": "|",
-    "pentagon": "p",
-    "tri_left": "3",
-    "caretdown": 7,
-    "caretright (centered at base)": 9,
-    "tickright": 1,
-    "caretright": 5,
-    "caretleft": 4,
-    "tickleft": 0,
-    "tri_up": "2",
-    "circle": "o",
-    "pixel": ",",
-    "caretleft (centered at base)": 8,
-    "diamond": "D",
-    "star": "*",
-    "hexagon1": "h",
-    "octagon": "8",
-    "hexagon2": "H",
-    "tri_right": "4",
-    "x (filled)": "X",
-    "thin_diamond": "d",
-    "tri_down": "1",
-    "triangle_left": "<",
-    "plus": "+",
-    "triangle_down": "v",
-    "triangle_up": "^",
-    "x": "x",
-    "caretup": 6,
-    "caretup (centered at base)": 10,
-    "caretdown (centered at base)": 11,
-    "None": "None",
-}
 
 # -----------------------------------------------------------------------------
 # Decorators
@@ -582,23 +542,27 @@ def _set_axes_limits_from_properties(ax):
 
 
 def _do_single_plot(ax, workspaces, errors, set_title, nums, kw, plot_kwargs, log_name=None, log_values=None):
-    # do the plotting
-    plot_fn = ax.errorbar if errors else ax.plot
-
     counter = 0
     for ws in workspaces:
         for num in nums:
+            plot_fn = ax.errorbar if errors else ax.plot
+            if isinstance(ws, MatrixWorkspace):
+                plot_type = ws.getPlotType()
+                _plot_kwargs = get_plot_specific_properties(ws, plot_type, plot_kwargs)
+                if "errorbar" in plot_type or errors:
+                    plot_fn = ax.errorbar
+
             if log_values:
                 label = log_values[counter]
                 if len(nums) > 1:
                     label = f"spec {num}: {label}"
 
-                plot_kwargs["label"] = label
+                _plot_kwargs["label"] = label
 
                 counter += 1
 
-            plot_kwargs[kw] = num
-            plot_fn(ws, **plot_kwargs)
+            _plot_kwargs[kw] = num
+            plot_fn(ws, **_plot_kwargs)
 
     _set_axes_limits_from_properties(ax)
     ax.make_legend()

Framework/PythonInterface/mantid/plots/utility.py

@@ -14,13 +14,54 @@
 from matplotlib.legend import Legend
 from matplotlib import colormaps
 from matplotlib.container import ErrorbarContainer
+from mantid.kernel import ConfigService
 
 # -----------------------------------------------------------------------------
 # Constants
 # -----------------------------------------------------------------------------
 # Restrict zooming out of plots.
 ZOOM_LIMIT = 1e300
 
+MARKER_MAP = {
+    "square": "s",
+    "plus (filled)": "P",
+    "point": ".",
+    "tickdown": 3,
+    "triangle_right": ">",
+    "tickup": 2,
+    "hline": "_",
+    "vline": "|",
+    "pentagon": "p",
+    "tri_left": "3",
+    "caretdown": 7,
+    "caretright (centered at base)": 9,
+    "tickright": 1,
+    "caretright": 5,
+    "caretleft": 4,
+    "tickleft": 0,
+    "tri_up": "2",
+    "circle": "o",
+    "pixel": ",",
+    "caretleft (centered at base)": 8,
+    "diamond": "D",
+    "star": "*",
+    "hexagon1": "h",
+    "octagon": "8",
+    "hexagon2": "H",
+    "tri_right": "4",
+    "x (filled)": "X",
+    "thin_diamond": "d",
+    "tri_down": "1",
+    "triangle_left": "<",
+    "plus": "+",
+    "triangle_down": "v",
+    "triangle_up": "^",
+    "x": "x",
+    "caretup": 6,
+    "caretup (centered at base)": 10,
+    "caretdown (centered at base)": 11,
+    "None": "None",
+}
 # Use the correct draggable method based on the matplotlib version
 if hasattr(Legend, "set_draggable"):
     SET_DRAGGABLE_METHOD = "set_draggable"
@@ -243,3 +284,43 @@ def convert_color_to_hex(color):
     except (KeyError, TypeError):
         rgb = colors.colorConverter.to_rgb(color)
         return colors.rgb2hex(rgb)
+
+
+def get_plot_specific_properties(ws, plot_type, plot_kwargs):
+    """
+    Set plot specific properties from the workspace
+    :param ws:
+    :param ax:
+    :param errors:
+    :param plot_kwargs:
+    """
+
+    if plot_type in ["errorbar_x", "errorbar_y", "errorbar_xy"]:
+        plot_kwargs["linestyle"] = "None"
+        plot_kwargs["marker"] = MARKER_MAP[ConfigService.getString("plots.errorbar.MarkerStyle")]
+        plot_kwargs["markersize"] = float(ConfigService.getString("plots.errorbar.MarkerSize"))
+        if "capsize" not in plot_kwargs:
+            plot_kwargs["capsize"] = float(ConfigService.getString("plots.errorbar.Capsize"))
+        if "capthick" not in plot_kwargs:
+            plot_kwargs["capthick"] = float(ConfigService.getString("plots.errorbar.CapThickness"))
+        if "errorevery" not in plot_kwargs:
+            plot_kwargs["errorevery"] = int(ConfigService.getString("plots.errorbar.errorEvery"))
+        if "elinewidth" not in plot_kwargs:
+            plot_kwargs["elinewidth"] = float(ConfigService.getString("plots.errorbar.Width"))
+    else:
+        if plot_type == "marker":
+            plot_kwargs["linestyle"] = "None"
+            if ws.getMarkerStyle():
+                plot_kwargs["marker"] = MARKER_MAP[ws.getMarkerType()]
+            else:
+                plot_kwargs["marker"] = MARKER_MAP[ConfigService.getString("plots.markerworkspace.MarkerStyle")]
+            marker_size = ws.getMarkerSize()
+            plot_kwargs["markersize"] = (
+                marker_size if marker_size != 6 else float(ConfigService.getString("plots.markerworkspace.MarkerSize"))
+            )
+        plot_kwargs.pop("capsize", None)
+        plot_kwargs.pop("capthick", None)
+        plot_kwargs.pop("errorevery", None)
+        plot_kwargs.pop("elinewidth", None)
+
+    return plot_kwargs

Framework/PythonInterface/test/python/mantid/api/MatrixWorkspaceTest.py

@@ -408,8 +408,8 @@ def test_setPlotType(self):
         self.assertEqual("plot", ws1.getPlotType())
 
         # test valid takes
-        ws1.setPlotType("scatter")
-        self.assertEqual("scatter", ws1.getPlotType())
+        ws1.setPlotType("marker")
+        self.assertEqual("marker", ws1.getPlotType())
 
     def test_setGetMonitorWS(self):
         run_algorithm("CreateWorkspace", OutputWorkspace="ws1", DataX=[1.0, 2.0, 3.0], DataY=[2.0, 3.0], DataE=[2.0, 3.0], UnitX="TOF")

docs/source/api/python/mantid/plots/index.rst

@@ -185,6 +185,40 @@ when giving the projection:
     ax.plot_wireframe(x,y,z)       #for arrays
     fig.show()
 
+Matrix Workspace Plotting
+=========================
+
+The `setPlotType()` method allows you to define how a workspace should be visualized when plotting. The following plot types are available:
+
+- **marker**:
+  A scatter plot where data points are displayed as markers without connecting lines. Ideal for visualizing individual data points.
+
+- **plot**:
+  A standard line plot that connects data points using lines. This is the default visualization for continuous data.
+
+- **errorbar_x**:
+  A plot with error bars in the x-direction only. Uses `dataX` for the x-values, `dataY` for the y-values, and `dataDx` for the x-error values.
+
+- **errorbar_y**:
+  A plot with error bars in the y-direction only. Uses `dataX` for the x-values, `dataY` for the y-values, and `dataE` for the y-error values.
+
+- **errorbar_xy**:
+  A plot with error bars in both x- and y-directions. Uses `dataX` for the x-values, `dataY` for the y-values, `dataDx` for the x-error values, and `dataE` for the y-error values.
+
+These options can be set using:
+
+.. code-block:: python
+
+    workspace.setPlotType('marker') # or 'plot', 'errorbar_x', 'errorbar_y', 'errorbar_xy'
+    workspace.getPlotType() # returns the current plot type
+
+
+.. figure:: ../../../../images/mantid_plot_types.png
+   :align: center
+   :figwidth: image
+
+
+
 Types of functions
 ==================
 

qt/python/mantidqt/mantidqt/widgets/superplot/presenter.py

@@ -9,7 +9,7 @@
 from .model import SuperplotModel
 
 from mantid.kernel import ConfigService
-from mantid.api import mtd
+from mantid.api import mtd, MatrixWorkspace
 from mantid.plots.utility import MantidAxType, legend_set_draggable
 from mantid.plots.plotfunctions import MARKER_MAP
 from mantid.plots import MantidAxes
@@ -479,7 +479,12 @@ def _plot_selection(self):
                     if ws_name not in mtd:
                         continue
                     ws = mtd[ws_name]
-                    if self._error_bars:
+                    error_ws = False
+                    if isinstance(ws, MatrixWorkspace):
+                        plot_type = ws.getPlotType()
+                        if "errorbar" in plot_type:
+                            error_ws = True
+                    if self._error_bars or error_ws:
                         lines = axes.errorbar(ws, **kwargs)
                         color = lines.lines[0].get_color()
                     else: