13044417862

Committed 28 Jan 2025 09:32AM UTC coverage: 87.668%. Remained the same

Build # 13044417862

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #1048 from mantidproject/ruff-format

Ruff format mslice

Run Details

440 of 499 new or added lines in 39 files covered. (88.18%)

6 existing lines in 5 files now uncovered.

3064 of 3495 relevant lines covered (87.67%)

0.88 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

75.0

/src/mslice/presenters/slice_plotter_presenter.py

from matplotlib.colors import Normalize

from mslice.models.slice.slice_functions import compute_slice, compute_recoil_line
from mslice.models.powder.powder_functions import compute_powder_line
from mslice.models.cmap import ALLOWED_CMAPS
from mslice.models.slice.slice import Slice
from mslice.models.labels import is_momentum, is_twotheta
from mslice.models.units import convert_energy_to_meV
from mslice.views.slice_plotter import (
    set_colorbar_label,
    plot_cached_slice,
    create_slice_figure,
)
from mslice.models.workspacemanager.workspace_provider import get_workspace_handle
from mslice.plotting.plot_window.overplot_interface import (
    plot_overplot_line,
    remove_line,
)
from mslice.presenters.presenter_utility import PresenterUtility


class SlicePlotterPresenter(PresenterUtility):
    def __init__(self):
        self._main_presenter = None
        self._slice_cache = {}

    def plot_slice(
        self,
        selected_ws,
        x_axis,
        y_axis,
        intensity_start,
        intensity_end,
        norm_to_one,
        colourmap,
    ):
        workspace = get_workspace_handle(selected_ws)
        self.create_slice(
            workspace,
            x_axis,
            y_axis,
            intensity_start,
            intensity_end,
            norm_to_one,
            colourmap,
        )
        self.plot_from_cache(workspace)

    def create_slice(
        self,
        selected_ws,
        x_axis,
        y_axis,
        intensity_start,
        intensity_end,
        norm_to_one,
        colourmap,
    ):
        norm = Normalize(vmin=intensity_start, vmax=intensity_end)
        slice = compute_slice(selected_ws, x_axis, y_axis, norm_to_one)
        self._cache_slice(slice, colourmap, norm, None, x_axis, y_axis)
        self._slice_cache[selected_ws.name].norm_to_one = norm_to_one
        return slice

    def plot_from_cache(self, workspace):
        ws_name = workspace.name.lstrip("__")
        create_slice_figure(ws_name, self)
        self.show_scattering_function(ws_name)

    def change_intensity(self, workspace_name, intensity_start, intensity_end):
        workspace_name = workspace_name.lstrip("__")
        intensity_start, intensity_end = self.validate_intensity(
            intensity_start, intensity_end
        )
        norm = Normalize(vmin=intensity_start, vmax=intensity_end)
        self._slice_cache[workspace_name].norm = norm

    def change_colourmap(self, workspace_name, colourmap):
        if colourmap in ALLOWED_CMAPS:
            workspace_name = workspace_name.lstrip("__")
            self._slice_cache[workspace_name].colourmap = colourmap
        else:
            raise ValueError("colourmap not recognised")

    def update_displayed_workspaces(self):
        self._main_presenter.update_displayed_workspaces()

    def _cache_slice(self, slice, colourmap, norm, sample_temp, x_axis, y_axis):
        rotated = not is_twotheta(x_axis.units) and not is_momentum(x_axis.units)
        (q_axis, e_axis) = (x_axis, y_axis) if not rotated else (y_axis, x_axis)
        self._slice_cache[slice.name[2:]] = Slice(
            slice, colourmap, norm, sample_temp, q_axis, e_axis, rotated
        )

    def get_slice_cache(self, workspace):
        return self._slice_cache[
            workspace.name[2:] if hasattr(workspace, "name") else workspace
        ]

    def show_scattering_function(self, workspace_name):
        slice_cache = self._slice_cache[workspace_name]
        plot_cached_slice(slice_cache, slice_cache.scattering_function)

    def show_dynamical_susceptibility(self, workspace_name):
        slice_cache = self._slice_cache[workspace_name]
        plot_cached_slice(slice_cache, slice_cache.chi)

    def show_dynamical_susceptibility_magnetic(self, workspace_name):
        slice_cache = self._slice_cache[workspace_name]
        plot_cached_slice(slice_cache, slice_cache.chi_magnetic)
        set_colorbar_label(
            "chi''(Q,E) |F(Q)|$^2$ ($mu_B$ $meV^{-1} sr^{-1} f.u.^{-1}$)"
        )

    def show_d2sigma(self, workspace_name):
        slice_cache = self._slice_cache[workspace_name]
        plot_cached_slice(slice_cache, slice_cache.d2sigma)

    def show_symmetrised(self, workspace_name):
        slice_cache = self._slice_cache[workspace_name]
        plot_cached_slice(slice_cache, slice_cache.symmetrised)

    def show_gdos(self, workspace_name):
        slice_cache = self._slice_cache[workspace_name]
        plot_cached_slice(slice_cache, slice_cache.gdos)

    def hide_overplot_line(self, workspace, key):
        cache = self._slice_cache[workspace]
        if key in cache.overplot_lines:
            line = cache.overplot_lines.pop(key)
            remove_line(line)

    def add_overplot_line(
        self,
        workspace_name,
        key,
        recoil,
        cif=None,
        y_has_logarithmic=None,
        datum=None,
        intensity_correction=None,
        **kwargs,
    ):
        cache = self._slice_cache[workspace_name]
        if recoil:
            x, y = compute_recoil_line(workspace_name, cache.momentum_axis, key)
        else:
            x, y = compute_powder_line(
                workspace_name, cache.momentum_axis, key, cif_file=cif
            )
        y = convert_energy_to_meV(y, cache.energy_axis.e_unit)
        cache.overplot_lines[key] = plot_overplot_line(
            x, y, key, recoil, cache, **kwargs
        )

    def validate_intensity(self, intensity_start, intensity_end):
        intensity_start = self._to_float(intensity_start)
        intensity_end = self._to_float(intensity_end)
        if (
            intensity_start is not None
            and intensity_end is not None
            and intensity_start > intensity_end
        ):
            raise ValueError()
        return intensity_start, intensity_end

    def set_sample_temperature(self, workspace_name, temp):
        self._slice_cache[workspace_name].sample_temp = temp

    def workspace_selection_changed(self):
        pass

1	from matplotlib.colors import Normalize	1✔
2
3	from mslice.models.slice.slice_functions import compute_slice, compute_recoil_line	1✔
4	from mslice.models.powder.powder_functions import compute_powder_line	1✔
5	from mslice.models.cmap import ALLOWED_CMAPS	1✔
6	from mslice.models.slice.slice import Slice	1✔
7	from mslice.models.labels import is_momentum, is_twotheta	1✔
8	from mslice.models.units import convert_energy_to_meV	1✔
9	from mslice.views.slice_plotter import (	1✔
10	set_colorbar_label,
11	plot_cached_slice,
12	create_slice_figure,
13	)
14	from mslice.models.workspacemanager.workspace_provider import get_workspace_handle	1✔
15	from mslice.plotting.plot_window.overplot_interface import (	1✔
16	plot_overplot_line,
17	remove_line,
18	)
19	from mslice.presenters.presenter_utility import PresenterUtility	1✔
20
21
22	class SlicePlotterPresenter(PresenterUtility):	1✔
23	def __init__(self):	1✔
24	self._main_presenter = None	1✔
25	self._slice_cache = {}	1✔
26
27	def plot_slice(	1✔
28	self,
29	selected_ws,
30	x_axis,
31	y_axis,
32	intensity_start,
33	intensity_end,
34	norm_to_one,
35	colourmap,
36	):
37	workspace = get_workspace_handle(selected_ws)	1✔
38	self.create_slice(	1✔
39	workspace,
40	x_axis,
41	y_axis,
42	intensity_start,
43	intensity_end,
44	norm_to_one,
45	colourmap,
46	)
47	self.plot_from_cache(workspace)	1✔
48
49	def create_slice(	1✔
50	self,
51	selected_ws,
52	x_axis,
53	y_axis,
54	intensity_start,
55	intensity_end,
56	norm_to_one,
57	colourmap,
58	):
59	norm = Normalize(vmin=intensity_start, vmax=intensity_end)	1✔
60	slice = compute_slice(selected_ws, x_axis, y_axis, norm_to_one)	1✔
61	self._cache_slice(slice, colourmap, norm, None, x_axis, y_axis)	1✔
62	self._slice_cache[selected_ws.name].norm_to_one = norm_to_one	1✔
63	return slice	1✔
64
65	def plot_from_cache(self, workspace):	1✔
66	ws_name = workspace.name.lstrip("__")	1✔
67	create_slice_figure(ws_name, self)	1✔
68	self.show_scattering_function(ws_name)	1✔
69
70	def change_intensity(self, workspace_name, intensity_start, intensity_end):	1✔
NEW 71	workspace_name = workspace_name.lstrip("__")	×
NEW 72	intensity_start, intensity_end = self.validate_intensity(	×
73	intensity_start, intensity_end
74	)
75	norm = Normalize(vmin=intensity_start, vmax=intensity_end)	×
76	self._slice_cache[workspace_name].norm = norm	×
77
78	def change_colourmap(self, workspace_name, colourmap):	1✔
79	if colourmap in ALLOWED_CMAPS:	×
NEW 80	workspace_name = workspace_name.lstrip("__")	×
81	self._slice_cache[workspace_name].colourmap = colourmap	×
82	else:
NEW 83	raise ValueError("colourmap not recognised")	×
84
85	def update_displayed_workspaces(self):	1✔
86	self._main_presenter.update_displayed_workspaces()	×
87
88	def _cache_slice(self, slice, colourmap, norm, sample_temp, x_axis, y_axis):	1✔
89	rotated = not is_twotheta(x_axis.units) and not is_momentum(x_axis.units)	1✔
90	(q_axis, e_axis) = (x_axis, y_axis) if not rotated else (y_axis, x_axis)	1✔
91	self._slice_cache[slice.name[2:]] = Slice(	1✔
92	slice, colourmap, norm, sample_temp, q_axis, e_axis, rotated
93	)
94
95	def get_slice_cache(self, workspace):	1✔
96	return self._slice_cache[	1✔
97	workspace.name[2:] if hasattr(workspace, "name") else workspace
98	]
99
100	def show_scattering_function(self, workspace_name):	1✔
101	slice_cache = self._slice_cache[workspace_name]	1✔
102	plot_cached_slice(slice_cache, slice_cache.scattering_function)	1✔
103
104	def show_dynamical_susceptibility(self, workspace_name):	1✔
105	slice_cache = self._slice_cache[workspace_name]	×
106	plot_cached_slice(slice_cache, slice_cache.chi)	×
107
108	def show_dynamical_susceptibility_magnetic(self, workspace_name):	1✔
109	slice_cache = self._slice_cache[workspace_name]	×
110	plot_cached_slice(slice_cache, slice_cache.chi_magnetic)	×
NEW 111	set_colorbar_label(	×
112	"chi''(Q,E) \|F(Q)\|$^2$ ($mu_B$ $meV^{-1} sr^{-1} f.u.^{-1}$)"
113	)
114
115	def show_d2sigma(self, workspace_name):	1✔
116	slice_cache = self._slice_cache[workspace_name]	×
117	plot_cached_slice(slice_cache, slice_cache.d2sigma)	×
118
119	def show_symmetrised(self, workspace_name):	1✔
120	slice_cache = self._slice_cache[workspace_name]	×
121	plot_cached_slice(slice_cache, slice_cache.symmetrised)	×
122
123	def show_gdos(self, workspace_name):	1✔
124	slice_cache = self._slice_cache[workspace_name]	×
125	plot_cached_slice(slice_cache, slice_cache.gdos)	×
126
127	def hide_overplot_line(self, workspace, key):	1✔
128	cache = self._slice_cache[workspace]	1✔
129	if key in cache.overplot_lines:	1✔
130	line = cache.overplot_lines.pop(key)	1✔
131	remove_line(line)	1✔
132
133	def add_overplot_line(	1✔
134	self,
135	workspace_name,
136	key,
137	recoil,
138	cif=None,
139	y_has_logarithmic=None,
140	datum=None,
141	intensity_correction=None,
142	**kwargs,
143	):
144	cache = self._slice_cache[workspace_name]	1✔
145	if recoil:	1✔
146	x, y = compute_recoil_line(workspace_name, cache.momentum_axis, key)	1✔
147	else:
148	x, y = compute_powder_line(	1✔
149	workspace_name, cache.momentum_axis, key, cif_file=cif
150	)
151	y = convert_energy_to_meV(y, cache.energy_axis.e_unit)	1✔
152	cache.overplot_lines[key] = plot_overplot_line(	1✔
153	x, y, key, recoil, cache, **kwargs
154	)
155
156	def validate_intensity(self, intensity_start, intensity_end):	1✔
157	intensity_start = self._to_float(intensity_start)	1✔
158	intensity_end = self._to_float(intensity_end)	1✔
159	if (	1✔
160	intensity_start is not None
161	and intensity_end is not None
162	and intensity_start > intensity_end
163	):
164	raise ValueError()	1✔
165	return intensity_start, intensity_end	1✔
166
167	def set_sample_temperature(self, workspace_name, temp):	1✔
168	self._slice_cache[workspace_name].sample_temp = temp	×
169
170	def workspace_selection_changed(self):	1✔
171	pass	×

mantidproject / mslice / 13044417862

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous