38254 add PeakShapeDetectorbin to integration algorithms (#38452)

* Unit tests added for equal opeartor in python and c++

* early return added and cppcheck fix

* reverted exposing opearator== into python for consistency

* PeakShapeDetectorBin added to IntegratePeaksSkew

* PeakShapeDetectorBin added to IntegratePeaksShoeboxTOF

* PeakShapeDetectorBin added to IntegratePeaksSkew

* null check added for ipos data

* updated for review comments. Q plottting yet to do

* Unit tests added

* integratepeaksshoebox xlimits and det ids updated

* release note updated

* updated note

Author: warunawickramasingha

Framework/DataObjects/src/PeakShapeDetectorBin.cpp

@@ -55,6 +55,6 @@ Mantid::Geometry::PeakShape *PeakShapeDetectorBin::clone() const { return new Pe
 
 std::string PeakShapeDetectorBin::shapeName() const { return PeakShapeDetectorBin::detectorBinShapeName(); }
 
-const std::string PeakShapeDetectorBin::detectorBinShapeName() { return "PeakShapeDetectorBin"; }
+const std::string PeakShapeDetectorBin::detectorBinShapeName() { return "detectorbin"; }
 
 } // namespace Mantid::DataObjects

Framework/DataObjects/test/PeakShapeDetectorBinTest.h

@@ -39,7 +39,7 @@ class PeakShapeDetectorBinTest : public CxxTest::TestSuite {
     TS_ASSERT_EQUALS(algorithmName, peakShape->algorithmName());
     TS_ASSERT_EQUALS(version, peakShape->algorithmVersion());
     TS_ASSERT_EQUALS(coordinateSys, peakShape->frame());
-    TS_ASSERT_EQUALS("PeakShapeDetectorBin", peakShape->shapeName());
+    TS_ASSERT_EQUALS("detectorbin", peakShape->shapeName());
     TS_ASSERT_EQUALS(std::nullopt, peakShape->radius(Mantid::Geometry::PeakShape::RadiusType::Radius));
     TS_ASSERT_EQUALS(std::dynamic_pointer_cast<PeakShapeDetectorBin>(peakShape)->getDetectorBinList(), detPeakBinList);
 
@@ -48,7 +48,7 @@ class PeakShapeDetectorBinTest : public CxxTest::TestSuite {
     TS_ASSERT_EQUALS(algorithmName, cloneShape->algorithmName());
     TS_ASSERT_EQUALS(version, cloneShape->algorithmVersion());
     TS_ASSERT_EQUALS(coordinateSys, cloneShape->frame());
-    TS_ASSERT_EQUALS("PeakShapeDetectorBin", cloneShape->shapeName());
+    TS_ASSERT_EQUALS("detectorbin", cloneShape->shapeName());
     TS_ASSERT_EQUALS(std::nullopt, cloneShape->radius(Mantid::Geometry::PeakShape::RadiusType::Radius));
     TS_ASSERT_EQUALS(std::dynamic_pointer_cast<PeakShapeDetectorBin>(cloneShape)->getDetectorBinList(), detPeakBinList);
   }
@@ -62,7 +62,7 @@ class PeakShapeDetectorBinTest : public CxxTest::TestSuite {
     std::string jsonStr = peakShape->toJSON();
     Json::Value output;
     TSM_ASSERT("Should parse as JSON", Mantid::JsonHelpers::parse(jsonStr, &output));
-    TS_ASSERT_EQUALS("PeakShapeDetectorBin", output["shape"].asString());
+    TS_ASSERT_EQUALS("detectorbin", output["shape"].asString());
     TS_ASSERT_EQUALS("TestSuite", output["algorithm_name"].asString());
     TS_ASSERT_EQUALS(1, output["algorithm_version"].asInt());
     TS_ASSERT_EQUALS(0, output["frame"].asInt());

Framework/PythonInterface/plugins/algorithms/IntegratePeaksShoeboxTOF.py

@@ -21,6 +21,7 @@
     StringListValidator,
     EnabledWhenProperty,
     PropertyCriterion,
+    SpecialCoordinateSystem,
 )
 from dataclasses import dataclass
 import numpy as np
@@ -29,6 +30,7 @@
 from plugins.algorithms.IntegratePeaksSkew import InstrumentArrayConverter, get_fwhm_from_back_to_back_params
 from plugins.algorithms.FindSXPeaksConvolve import make_kernel, get_kernel_shape
 from enum import Enum
+from mantid.dataobjects import PeakShapeDetectorBin
 
 
 class PEAK_STATUS(Enum):
@@ -61,6 +63,7 @@ def __init__(self, ipk, pk, x, y, peak_shape, ipos, ipk_pos, intens_over_sig, st
         self.ipos_pk = list(ipk_pos)
         self.labels = ["Row", "Col", "TOF"]
         self.ysum = []
+        self.x = x
         self.xmin, self.xmax = np.round(x[0], 1), np.round(x[-1], 1)
         self.status = status
         # integrate y over each dim
@@ -332,6 +335,7 @@ def PyExec(self):
         weak_peaks_list = []
         ipks_strong = []
         results = np.full(peaks.getNumberPeaks(), None)
+        peaks_det_ids = np.full(peaks.getNumberPeaks(), None)
         prog_reporter = Progress(self, start=0.0, end=1.0, nreports=peaks.getNumberPeaks())
         for ipk, peak in enumerate(peaks):
             prog_reporter.report("Integrating")
@@ -365,6 +369,7 @@ def PyExec(self):
                 ix = np.argmin(abs(x - pk_tof))
                 ipos_predicted = [peak_data.irow, peak_data.icol, ix]
                 det_edges = peak_data.det_edges if not integrate_on_edge else None
+                peaks_det_ids[ipk] = peak_data.detids
 
                 intens, sigma, i_over_sig, status, ipos, nrows, ncols, nbins = integrate_peak(
                     ws,
@@ -383,6 +388,7 @@ def PyExec(self):
                     weak_peak_threshold,
                     do_optimise_shoebox,
                 )
+
                 if status == PEAK_STATUS.WEAK and do_optimise_shoebox and weak_peak_strategy == "NearestStrongPeak":
                     # look for possible strong peaks at any TOF in the window (won't know if strong until all pks integrated)
                     ipks_near, _ = find_ipks_in_window(ws, peaks, ispecs, ipk)
@@ -432,6 +438,8 @@ def PyExec(self):
                 x, y, esq, ispecs = get_and_clip_data_arrays(ws, peak_data, pk_tof, kernel, nshoebox)
                 # integrate at previously found ipos
                 ipos = [*np.argwhere(ispecs == weak_pk.ispec)[0], np.argmin(abs(x - weak_pk.tof))]
+                peaks_det_ids[ipk] = peak_data.detids
+
                 det_edges = peak_data.det_edges if not integrate_on_edge else None
                 intens, sigma, i_over_sig, status = integrate_shoebox_at_pos(y, esq, kernel, ipos, weak_peak_threshold, det_edges)
                 # scale summed intensity by bin width to get integrated area
@@ -452,6 +460,9 @@ def PyExec(self):
                 f"WeakPeakStrategy to Fix"
             )
 
+        # Sets PeakShapeDetectorBin shapes for successfully integrated peaks
+        self._set_peak_shapes(results, peaks_det_ids, peaks)
+
         # plot output
         if output_file:
             prog_reporter.resetNumSteps(int(len(results) - np.sum(results is None)), start=0.0, end=1.0)
@@ -460,6 +471,28 @@ def PyExec(self):
         # assign output
         self.setProperty("OutputWorkspace", peaks)
 
+    def _set_peak_shapes(self, shoebox_results, peaks_det_ids, peaks_ws):
+        """
+        Sets PeakShapeDetectorBin shapes for the successfully integrated peaks
+        @param shoebox_results - ShoeboxResult array for each peak
+        @param peaks_det_ids - detector ids related to each peak
+        @param peaks_ws - peaks workspace
+        """
+        for ipk, (shoebox_res, peak_detids) in enumerate(zip(shoebox_results, peaks_det_ids)):
+            if shoebox_res is not None and peak_detids is not None:
+                if shoebox_res.status != PEAK_STATUS.ON_EDGE and shoebox_res.status != PEAK_STATUS.NO_PEAK:
+                    det_id_row_start = shoebox_res.ipos[0] - shoebox_res.peak_shape[0] // 2
+                    det_id_row_end = shoebox_res.ipos[0] + shoebox_res.peak_shape[0] // 2 + 1
+                    det_id_col_start = shoebox_res.ipos[1] - shoebox_res.peak_shape[1] // 2
+                    det_id_col_end = shoebox_res.ipos[1] + shoebox_res.peak_shape[1] // 2 + 1
+                    selected_det_ids = peak_detids[det_id_row_start:det_id_row_end, det_id_col_start:det_id_col_end]
+                    xstart = shoebox_res.x[shoebox_res.ipos[2] - shoebox_res.peak_shape[2] // 2]
+                    xend = shoebox_res.x[shoebox_res.ipos[2] + shoebox_res.peak_shape[2] // 2]
+                    det_bin_list = [(int(det_id), xstart, xend) for det_id in selected_det_ids.ravel()]
+                    peak_shape = PeakShapeDetectorBin(det_bin_list, SpecialCoordinateSystem.NONE, self.name(), self.version())
+                    peak = peaks_ws.getPeak(ipk)
+                    peak.setPeakShape(peak_shape)
+
     def exec_child_alg(self, alg_name, **kwargs):
         alg = self.createChildAlgorithm(alg_name, enableLogging=False)
         alg.initialize()

Framework/PythonInterface/plugins/algorithms/IntegratePeaksSkew.py

@@ -26,6 +26,7 @@
     logger,
     CompositeValidator,
     CompositeRelation,
+    SpecialCoordinateSystem,
 )
 import numpy as np
 from scipy.signal import convolve2d
@@ -34,6 +35,7 @@
 from mantid.geometry import RectangularDetector, GridDetector
 import re
 from enum import Enum
+from mantid.dataobjects import PeakShapeDetectorBin
 
 
 class PEAK_MASK_STATUS(Enum):
@@ -1027,7 +1029,6 @@ def PyExec(self):
             # check that peak is in a valid detector
             detid = detids[ipk]
             detector_info = ws.detectorInfo()
-            invalid_detector = False
             try:
                 det_idx = detector_info.indexOf(detid)
                 invalid_detector = detector_info.isMonitor(det_idx) or detector_info.isMasked(det_idx)
@@ -1090,6 +1091,9 @@ def PyExec(self):
                 # set peak object intensity
                 pk.setIntensity(L * peak_data.intens)
                 pk.setSigmaIntensity(L * peak_data.sig)
+
+                # Set PeakShapeDetectorBin shape for valid peaks
+                self._set_peak_shapes(ws, pk, peak_data)
             else:
                 pk.setIntensity(0.0)
                 pk.setSigmaIntensity(0.0)
@@ -1174,6 +1178,25 @@ def PyExec(self):
         # assign output
         self.setProperty("OutputWorkspace", pk_ws_int)
 
+    def _set_peak_shapes(self, ws, peak, peak_data):
+        """
+        Sets PeakShapeDetectorBin shape for a peak
+        @param ws - Input workspace
+        @param peak - peak to add the shape
+        @param peak_data - PeakData object containing details of the integrated peak
+        """
+        if not peak_data.peak_mask.any():
+            return
+        det_bin_list = []
+        for det in peak_data.detids[peak_data.peak_mask]:
+            ispec = ws.getIndicesFromDetectorIDs([int(det)])[0]
+            x_start = ws.readX(ispec)[peak_data.ixmin_opt]
+            x_end = ws.readX(ispec)[peak_data.ixmax_opt]
+            det_bin_list.append((int(det), x_start, x_end))
+        if len(det_bin_list) > 0:
+            peak_shape = PeakShapeDetectorBin(det_bin_list, SpecialCoordinateSystem.NONE, self.name(), self.version())
+            peak.setPeakShape(peak_shape)
+
     @staticmethod
     def estimate_linear_params(x, y):
         # adapted from scipy.stats.siegelslopes with added vectorisation

Framework/PythonInterface/test/python/mantid/geometry/IPeakTest.py

@@ -189,7 +189,7 @@ def test_set_peak_shape(self):
         self.assertEqual(self._peak.getPeakShape().shapeName(), "none")
 
         self._peak.setPeakShape(detector_bin)
-        self.assertEqual(self._peak.getPeakShape().shapeName(), "PeakShapeDetectorBin")
+        self.assertEqual(self._peak.getPeakShape().shapeName(), "detectorbin")
         self.assertEqual(self._peak.getPeakShape().algorithmVersion(), 1)
         self.assertEqual(self._peak.getPeakShape().algorithmName(), "test")
         det_bin_dict = json.loads(self._peak.getPeakShape().toJSON())

Framework/PythonInterface/test/python/plugins/algorithms/IntegratePeaksShoeboxTOFTest.py

@@ -20,7 +20,7 @@
 import tempfile
 import shutil
 from os import path
-
+import json
 
 XML_PARAMS = """
 <?xml version="1.0" encoding="UTF-8" ?>
@@ -40,7 +40,7 @@
 """
 
 
-class FindSXPeaksConvolveTest(unittest.TestCase):
+class IntegratePeaksShoeboxTOFTest(unittest.TestCase):
     @classmethod
     def setUpClass(cls):
         # load empty instrument with RectangularDetector banks and create a peak table
@@ -227,6 +227,52 @@ def test_exec_no_peak(self, mock_find_ipos):
         )
         self._assert_found_correct_peaks(out, i_over_sigs=2 * [0.0])
 
+    def test_exec_peak_shape_when_IntegrateIfOnEdge_False(self):
+        out = IntegratePeaksShoeboxTOF(
+            InputWorkspace=self.ws,
+            PeaksWorkspace=self.peaks,
+            OutputWorkspace="peaks1",
+            GetNBinsFromBackToBackParams=False,
+            NRows=3,
+            NCols=3,
+            NBins=3,
+            WeakPeakThreshold=0.0,
+            OptimiseShoebox=False,
+            IntegrateIfOnEdge=False,
+        )
+        self.assertEqual(out.getNumberPeaks(), 2)
+        self.assertEqual(out.getPeak(0).getPeakShape().shapeName(), "none")
+        self.assertEqual(out.getPeak(1).getPeakShape().shapeName(), "none")
+
+    def test_exec_OptimiseShoebox_peak_shape(self):
+        # make kernel larger than optimum
+        out = IntegratePeaksShoeboxTOF(
+            InputWorkspace=self.ws,
+            PeaksWorkspace=self.peaks,
+            OutputWorkspace="peaks4",
+            GetNBinsFromBackToBackParams=False,
+            NRows=5,
+            NCols=5,
+            NBins=3,
+            WeakPeakThreshold=0.0,
+            OptimiseShoebox=True,
+            IntegrateIfOnEdge=True,
+        )
+
+        self.assertEqual(out.getNumberPeaks(), 2)
+
+        def _test_shapes(peaksws, start_end_points):
+            for i_pk, pk in enumerate(peaksws):
+                self.assertEqual(pk.getPeakShape().shapeName(), "detectorbin")
+                pk_shape_dict = json.loads(pk.getPeakShape().toJSON())
+                self.assertEqual(len(pk_shape_dict["detectors"]), 9)
+                self.assertEqual(pk_shape_dict["algorithm_name"], "IntegratePeaksShoeboxTOF")
+                for det in pk_shape_dict["detectors"]:
+                    self.assertEqual(det["startX"], start_end_points[i_pk][0])
+                    self.assertEqual(det["endX"], start_end_points[i_pk][1])
+
+        _test_shapes(out, ((2.5, 4.5), (8.5, 10.5)))
+
 
 if __name__ == "__main__":
     unittest.main()

Framework/PythonInterface/test/python/plugins/algorithms/IntegratePeaksSkewTest.py

@@ -21,6 +21,7 @@
 from plugins.algorithms.IntegratePeaksSkew import InstrumentArrayConverter
 from testhelpers import WorkspaceCreationHelper
 from numpy import array, sqrt, arange, ones, zeros
+import json
 
 
 class IntegratePeaksSkewTest(unittest.TestCase):
@@ -77,6 +78,7 @@ def test_integrate_on_edge_option(self):
         # check peaks in bank 1 were not integrated (mask touches masked pixel)
         for ipk, pk in enumerate(out):
             self.assertEqual(pk.getIntensity(), 0)
+            self.assertEqual(pk.getPeakShape().shapeName(), "none")
 
     def test_integrate_on_edge_option_respects_detector_masking(self):
         ws_masked = CloneWorkspace(InputWorkspace=self.ws)
@@ -513,6 +515,30 @@ def test_nrows_edge_ncols_edge_in_array_converter_component_array(self):
         det_edges_expected[:, -1] = True  # last tube in window is second from end of bank and ncols_edge=2
         self.assertTrue((peak_data.det_edges == det_edges_expected).all())
 
+    def test_shapeof_valid_peaks(self):
+        out = IntegratePeaksSkew(
+            InputWorkspace=self.ws,
+            PeaksWorkspace=self.peaks,
+            ThetaWidth=0,
+            BackscatteringTOFResolution=0.3,
+            IntegrateIfOnEdge=True,
+            UseNearestPeak=False,
+            UpdatePeakPosition=False,
+            LorentzCorrection=False,
+            OutputWorkspace="out10",
+        )
+        # check shape of the only valid peak
+        pk = out.getPeak(0)
+        self.assertEqual(pk.getPeakShape().shapeName(), "detectorbin")
+        self.assertEqual(pk.getPeakShape().algorithmName(), "IntegratePeaksSkew")
+        pk_shape_dict = json.loads(pk.getPeakShape().toJSON())
+        self.assertEqual(len(pk_shape_dict["detectors"]), 6)
+        for det in pk_shape_dict["detectors"]:
+            self.assertEqual(det["startX"], 3)
+            self.assertEqual(det["endX"], 8)
+        for i in [1, 2]:
+            self.assertEqual(out.getPeak(i).getPeakShape().shapeName(), "none")
+
 
 if __name__ == "__main__":
     unittest.main()

docs/source/release/v6.12.0/Diffraction/Single_Crystal/New_features/38254.rst

@@ -1 +1,3 @@
-- A new peak shape named PeakShapeDetectorBin was introduced to save the detector IDs and bin indices of either TOF or dSpacing domains. This peak shape could be used for Overlap detection, Two-step integration and Eventual visualisation on instrument view.
+- A new peak shape named `detectorbin` was introduced to save the detector IDs and bin indices of either TOF or dSpacing domains. This peak shape could be used for Overlap detection, Two-step integration and Eventual visualisation on instrument view.
+- The new peak shape has been associated with the peaks integrated with :ref:`algm-IntegratePeaksShoeboxTOF` and :ref:`IntegratePeaksSkew <algm-IntegratePeaksSkew>` integration algorithms.
+- By accessing the `detectorbin` peak shape users now can view the detector ids associated for each integrated peak from the above algorithms.

qt/python/mantidqt/mantidqt/widgets/sliceviewer/peaksviewer/representation/draw.py

@@ -23,6 +23,7 @@
     "none": NonIntegratedPeakRepresentation,
     "spherical": EllipsoidalIntegratedPeakRepresentation,
     "ellipsoid": EllipsoidalIntegratedPeakRepresentation,
+    "detectorbin": NonIntegratedPeakRepresentation,
 }
 
 

scripts/Diffraction/single_crystal/base_sx.py

@@ -692,7 +692,7 @@ def plot_integrated_peaks_MD(
             with PdfPages(filename) as pdf:
                 for ipk, pk in enumerate(peaks):
                     peak_shape = pk.getPeakShape()
-                    if peak_shape.shapeName().lower() == "none":
+                    if peak_shape.shapeName().lower() == "none" or peak_shape.shapeName().lower() == "detectorbin":
                         continue
                     ws_cut, radii, bg_inner_radii, bg_outer_radii, box_lengths, imax = BaseSX._bin_MD_around_peak(
                         wsMD, pk, peak_shape, nbins_max, extent, frame_to_peak_centre_attr