1291469255

Build Type

github

Committed by GitHub

Commit Message

<a href="https://github.com/pyxem/diffsims/commit/<a class=hub.com/pyxem/diffsims/commit/<a class="double-link" href="https://git"><a class=hub.com/pyxem/diffsims/commit/<a class="double-link" href="https://git"><a class=hub.com/pyxem/diffsims/commit/<a class="double-link" href="https://git"><a class=hub.com/pyxem/diffsims/commit/6a8a0d3bcc51f3773d19497d8e8ea7aead8e86f5">6a8a0d3bc">&lt;a href=&quot;https://github.com/pyxem/diffsims/commit/</a><a class="double-link" href="https://github.com/pyxem/diffsims/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/pyxem/diffsims/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/pyxem/diffsims/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/pyxem/diffsims/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/pyxem/diffsims/commit/6a8a0d3bcc51f3773d19497d8e8ea7aead8e86f5">6a8a0d3bc</a><a href="https://github.com/pyxem/diffsims/commit/6a8a0d3bcc51f3773d19497d8e8ea7aead8e86f5">&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/pyxem/diffsims/commit/&lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/pyxem/diffsims/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/pyxem/diffsims/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/pyxem/diffsims/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/pyxem/diffsims/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/pyxem/diffsims/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/pyxem/diffsims/commit/6a8a0d3bcc51f3773d19497d8e8ea7aead8e86f5&quot;&gt;6a8a0d3bc&lt;/a&gt;&lt;a href=&quot;https://github.com/pyxem/diffsims/commit/6a8a0d3bcc51f3773d19497d8e8ea7aead8e86f5&quot;&gt;&amp;quot;&amp;gt;&amp;amp;lt;a href=&amp;amp;quot;https://github.com/pyxem/diffsims/commit/&amp;lt;/a&amp;gt;&amp;lt;a class=&amp;quot;dou... (continued)

Pull Request Pull Request #175: Improve DiffractionSimulation

Run Details

117 of 136 new or added lines in 2 files covered. (86.03%)

3363 of 3382 relevant lines covered (99.44%)

2.94 hits per line

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

95.7

/diffsims/tests/sims/test_diffraction_simulation.py

# -*- coding: utf-8 -*-
# Copyright 2017-2021 The diffsims developers
#
# This file is part of diffsims.
#
# diffsims is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# diffsims is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with diffsims.  If not, see <http://www.gnu.org/licenses/>.

import numpy as np
import pytest
from diffsims.sims.diffraction_simulation import DiffractionSimulation
from diffsims.sims.diffraction_simulation import ProfileSimulation


@pytest.mark.xfail(raises=ValueError)
def test_wrong_calibration_setting():
    DiffractionSimulation(
        coordinates=np.asarray([[0.3, 1.2, 0]]),
        intensities=np.ones(1),
        calibration=[1, 2, 5],
    )


@pytest.fixture
def profile_simulation():
    return ProfileSimulation(
        magnitudes=[
            0.31891931643691351,
            0.52079306292509475,
            0.6106839974876449,
            0.73651261277849378,
            0.80259601243613932,
            0.9020400452156796,
            0.95675794931074043,
            1.0415861258501895,
            1.0893168446141808,
            1.1645286909108374,
            1.2074090451670043,
            1.2756772657476541,
        ],
        intensities=np.array(
            [
                100.0,
                99.34619104,
                64.1846346,
                18.57137199,
                28.84307971,
                41.31084268,
                23.42104951,
                13.996264,
                24.87559364,
                20.85636003,
                9.46737774,
                5.43222307,
            ]
        ),
        hkls=[
            (1, 1, 1),
            (2, 2, 0),
            (3, 1, 1),
            (4, 0, 0),
            (3, 3, 1),
            (4, 2, 2),
            (3, 3, 3),
            (4, 4, 0),
            (5, 3, 1),
            (6, 2, 0),
            (5, 3, 3),
            (4, 4, 4),
        ],
    )


def test_plot_profile_simulation(profile_simulation):
    profile_simulation.get_plot()


class TestDiffractionSimulation:
    @pytest.fixture
    def diffraction_simulation(self):
        return DiffractionSimulation(np.array([[0, 0, 0],[1, 2, 3], [3, 4, 5]]))

    @pytest.fixture
    def diffraction_simulation_calibrated(self):
        return DiffractionSimulation(np.array([[0, 0, 0],[1, 2, 3], [3, 4, 5]]), calibration=0.5)

    @pytest.mark.xfail(raises=ValueError)
    def failed_initialization(self):
        DiffractionSimulation(np.array([[0, 0, 0],[1, 2, 3], [3, 4, 5]]), indices=np.array([1, 2, 3]))

    def test_init(self, diffraction_simulation):
        assert np.allclose(diffraction_simulation.coordinates, np.array([[1, 2, 3], [3, 4, 5]]))
        assert np.isnan(diffraction_simulation.indices).all()
        assert diffraction_simulation.indices.shape == (2, 3)
        assert np.isnan(diffraction_simulation.intensities).all()
        assert diffraction_simulation.intensities.shape == (2,)
        assert diffraction_simulation.calibration is None
        assert len(diffraction_simulation) == 2

    def get_get_item(self, diffraction_simulation):
        assert diffraction_simulation[1].coordinates.shape == (1, 3)
        assert diffraction_simulation[1:3].coordinates.shape == (2, 3)

    @pytest.mark.xfail(raises=ValueError)
    def fail_get_item(self, diffraction_simulation):
        diffraction_simulation[None]

    def test_addition(self, diffraction_simulation):
        sim = diffraction_simulation + diffraction_simulation
        assert np.allclose(sim.coordinates, np.array([[1, 2, 3],
                                                      [3, 4, 5],
                                                      [1, 2, 3],
                                                      [3, 4, 5],
                                                      ]))

    def test_extend(self, diffraction_simulation):
        diffraction_simulation.extend(diffraction_simulation)
        assert np.allclose(diffraction_simulation.coordinates, np.array([
                                                      [1, 2, 3],
                                                      [3, 4, 5],
                                                      [1, 2, 3],
                                                      [3, 4, 5],
                                                      ]))

    def test_indices_setter_getter(self, diffraction_simulation):
        indices = np.array([[1, 2, 3],[2, 3,4],[3, 4, 5]])
        diffraction_simulation.indices = indices[-1]
        assert np.allclose(diffraction_simulation.indices, indices[-1])
        diffraction_simulation.with_direct_beam = True
        diffraction_simulation.indices = indices
        assert np.allclose(diffraction_simulation.indices, indices)

    def test_coordinates_setter(self, diffraction_simulation):
        coords = np.array([[1, 2, 3],[2, 3,4],[3, 4, 5]])
        diffraction_simulation.coordinates = coords[-1]
        assert np.allclose(diffraction_simulation.coordinates, coords[-1])
        diffraction_simulation.with_direct_beam = True
        diffraction_simulation.coordinates = coords
        assert np.allclose(diffraction_simulation.coordinates, coords)

    @pytest.mark.parametrize(
        "calibration, expected",
        [
            (5.0, (5.0, 5.0)),
            pytest.param(0, (0, 0), marks=pytest.mark.xfail(raises=ValueError)),
            pytest.param((0, 0), (0, 0), marks=pytest.mark.xfail(raises=ValueError)),
            ((1.5, 1.5), (1.5, 1.5)),
            ((1.3, 1.5), (1.3, 1.5)),
        ],
    )
    def test_calibration(self, diffraction_simulation, calibration, expected):
        diffraction_simulation.calibration = calibration
        assert diffraction_simulation.calibration == expected

    @pytest.mark.parametrize(
        "coordinates, with_direct_beam, expected",
        [
            (
                np.array([[-1, 0, 0], [0, 0, 0], [1, 0, 0]]),
                False,
                np.array([True, False, True]),
            ),
            (
                np.array([[-1, 0, 0], [0, 0, 0], [1, 0, 0]]),
                True,
                np.array([True, True, True]),
            ),
            (np.array([[-1, 0, 0], [1, 0, 0]]), False, np.array([True, True])),
        ],
    )
    def test_direct_beam_mask(
        self, coordinates, with_direct_beam, expected
    ):
        diffraction_simulation = DiffractionSimulation(coordinates,
                                                       with_direct_beam=with_direct_beam)
        diffraction_simulation.with_direct_beam = with_direct_beam
        mask = diffraction_simulation.direct_beam_mask
        assert np.all(mask == expected)

    @pytest.mark.parametrize(
        "coordinates, calibration, offset, expected",
        [
            (
                np.array([[1.0, 0.0, 0.0], [1.0, 2.0, 0.0]]),
                1.0,
                (0.0, 0.0),
                np.array([[1.0, 0.0], [1.0, 2.0]]),
            ),
            (
                np.array([[1.0, 0.0, 0.0], [1.0, 2.0, 0.0]]),
                2.0,
                (3.0, 1.0),
                np.array([[2.0, 0.5], [2.0, 1.5]]),
            ),
            pytest.param(
                np.array([[1.0, 0.0, 0.0], [1.0, 2.0, 0.0]]),
                None,
                (0.0, 0.0),
                None,
                marks=pytest.mark.xfail(raises=Exception)
            ),
        ],
    )
    def test_calibrated_coordinates(
        self,
        coordinates,
        calibration,
        offset,
        expected,
    ):
        diffraction_simulation = DiffractionSimulation(coordinates)
        diffraction_simulation.calibration = calibration
        diffraction_simulation.offset = offset
        assert np.allclose(diffraction_simulation.calibrated_coordinates,
                           expected)

    @pytest.mark.parametrize(
        "units, expected",
        [
            ("real", np.array([[-2,1,3],[-4,3,5]])),
            ("pixel", np.array([[-4,2],[-8,6]])),
        ],
    )
    def test_transform_coordinates(self, diffraction_simulation_calibrated, units, expected):
        tc = diffraction_simulation_calibrated._get_transformed_coordinates(90, units=units)
        assert np.allclose(tc, expected)

    def test_rotate_shift_coordinates(self, diffraction_simulation):
        diffraction_simulation.rotate_shift_coordinates(90)
        assert np.allclose(diffraction_simulation.coordinates,
                           np.array([[-2,1,3],[-4,3,5]]))

    def test_assertion_free_get_diffraction_pattern(self):
        short_sim = DiffractionSimulation(
            coordinates=np.asarray([[0.3, 1.2, 0]]),
            intensities=np.ones(1),
            calibration=[1, 2],
        )
        z = short_sim.get_diffraction_pattern()

        empty_sim = DiffractionSimulation(
            coordinates=np.asarray([[0.3, 1000, 0]]),
            intensities=np.ones(1),
            calibration=[2, 2],
        )
        z = empty_sim.get_diffraction_pattern(shape=(10, 20))

    def test_get_as_mask(self):
        short_sim = DiffractionSimulation(
            coordinates=np.asarray([[0.3, 1.2, 0]]),
            intensities=np.ones(1),
            calibration=[1, 2],
        )
        mask = short_sim.get_as_mask((20, 10),
                                     radius_function=np.sqrt,
                                     direct_beam_position=(10, 6)
                                     )
        assert mask.shape[0] == 20
        assert mask.shape[1] == 10

    @pytest.mark.parametrize("units_in",['pixel','real'])
    def test_plot_method(self,units_in):
        short_sim = DiffractionSimulation(
            coordinates=np.asarray([[0.3, 1.2, 0],
                                    [-2, 3, 0],
                                    [2.1, 3.4, 0],]),
            indices=np.array([[-2, 3, 4],
                              [ 2,-6, 1],
                              [ 0, 0, 0]]),
            intensities=np.array([3., 5., 2.]),
            calibration=[1, 2],
        )
        ax, sp = short_sim.plot(units=units_in, show_labels=True)

1	# -- coding: utf-8 --
2	# Copyright 2017-2021 The diffsims developers
3	#
4	# This file is part of diffsims.
5	#
6	# diffsims is free software: you can redistribute it and/or modify
7	# it under the terms of the GNU General Public License as published by
8	# the Free Software Foundation, either version 3 of the License, or
9	# (at your option) any later version.
10	#
11	# diffsims is distributed in the hope that it will be useful,
12	# but WITHOUT ANY WARRANTY; without even the implied warranty of
13	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14	# GNU General Public License for more details.
15	#
16	# You should have received a copy of the GNU General Public License
17	# along with diffsims. If not, see <http://www.gnu.org/licenses/>.
18
19	import numpy as np	3✔
20	import pytest	3✔
21	from diffsims.sims.diffraction_simulation import DiffractionSimulation	3✔
22	from diffsims.sims.diffraction_simulation import ProfileSimulation	3✔
23
24
25	@pytest.mark.xfail(raises=ValueError)	3✔
26	def test_wrong_calibration_setting():	2✔
27	DiffractionSimulation(	3✔
28	coordinates=np.asarray([[0.3, 1.2, 0]]),
29	intensities=np.ones(1),
30	calibration=[1, 2, 5],
31	)
32
33
34	@pytest.fixture	3✔
35	def profile_simulation():	2✔
36	return ProfileSimulation(	3✔
37	magnitudes=[
38	0.31891931643691351,
39	0.52079306292509475,
40	0.6106839974876449,
41	0.73651261277849378,
42	0.80259601243613932,
43	0.9020400452156796,
44	0.95675794931074043,
45	1.0415861258501895,
46	1.0893168446141808,
47	1.1645286909108374,
48	1.2074090451670043,
49	1.2756772657476541,
50	],
51	intensities=np.array(
52	[
53	100.0,
54	99.34619104,
55	64.1846346,
56	18.57137199,
57	28.84307971,
58	41.31084268,
59	23.42104951,
60	13.996264,
61	24.87559364,
62	20.85636003,
63	9.46737774,
64	5.43222307,
65	]
66	),
67	hkls=[
68	(1, 1, 1),
69	(2, 2, 0),
70	(3, 1, 1),
71	(4, 0, 0),
72	(3, 3, 1),
73	(4, 2, 2),
74	(3, 3, 3),
75	(4, 4, 0),
76	(5, 3, 1),
77	(6, 2, 0),
78	(5, 3, 3),
79	(4, 4, 4),
80	],
81	)
82
83
84	def test_plot_profile_simulation(profile_simulation):	3✔
85	profile_simulation.get_plot()	3✔
86
87
88	class TestDiffractionSimulation:	3✔
89	@pytest.fixture	3✔
90	def diffraction_simulation(self):	2✔
91	return DiffractionSimulation(np.array([[0, 0, 0],[1, 2, 3], [3, 4, 5]]))	3✔
92
93	@pytest.fixture	3✔
94	def diffraction_simulation_calibrated(self):	2✔
95	return DiffractionSimulation(np.array([[0, 0, 0],[1, 2, 3], [3, 4, 5]]), calibration=0.5)	3✔
96
97	@pytest.mark.xfail(raises=ValueError)	3✔
98	def failed_initialization(self):	2✔
NEW 99	DiffractionSimulation(np.array([[0, 0, 0],[1, 2, 3], [3, 4, 5]]), indices=np.array([1, 2, 3]))	×
100
101	def test_init(self, diffraction_simulation):	3✔
102	assert np.allclose(diffraction_simulation.coordinates, np.array([[1, 2, 3], [3, 4, 5]]))	3✔
103	assert np.isnan(diffraction_simulation.indices).all()	3✔
104	assert diffraction_simulation.indices.shape == (2, 3)	3✔
105	assert np.isnan(diffraction_simulation.intensities).all()	3✔
106	assert diffraction_simulation.intensities.shape == (2,)	3✔
107	assert diffraction_simulation.calibration is None	3✔
108	assert len(diffraction_simulation) == 2	3✔
109
110	def get_get_item(self, diffraction_simulation):	3✔
NEW 111	assert diffraction_simulation[1].coordinates.shape == (1, 3)	×
NEW 112	assert diffraction_simulation[1:3].coordinates.shape == (2, 3)	×
113
114	@pytest.mark.xfail(raises=ValueError)	3✔
115	def fail_get_item(self, diffraction_simulation):	2✔
NEW 116	diffraction_simulation[None]	×
117
118	def test_addition(self, diffraction_simulation):	3✔
119	sim = diffraction_simulation + diffraction_simulation	3✔
120	assert np.allclose(sim.coordinates, np.array([[1, 2, 3],	3✔
121	[3, 4, 5],
122	[1, 2, 3],
123	[3, 4, 5],
124	]))
125
126	def test_extend(self, diffraction_simulation):	3✔
127	diffraction_simulation.extend(diffraction_simulation)	3✔
128	assert np.allclose(diffraction_simulation.coordinates, np.array([	3✔
129	[1, 2, 3],
130	[3, 4, 5],
131	[1, 2, 3],
132	[3, 4, 5],
133	]))
134
135	def test_indices_setter_getter(self, diffraction_simulation):	3✔
136	indices = np.array([[1, 2, 3],[2, 3,4],[3, 4, 5]])	3✔
137	diffraction_simulation.indices = indices[-1]	3✔
138	assert np.allclose(diffraction_simulation.indices, indices[-1])	3✔
139	diffraction_simulation.with_direct_beam = True	3✔
140	diffraction_simulation.indices = indices	3✔
141	assert np.allclose(diffraction_simulation.indices, indices)	3✔
142
143	def test_coordinates_setter(self, diffraction_simulation):	3✔
144	coords = np.array([[1, 2, 3],[2, 3,4],[3, 4, 5]])	3✔
145	diffraction_simulation.coordinates = coords[-1]	3✔
146	assert np.allclose(diffraction_simulation.coordinates, coords[-1])	3✔
147	diffraction_simulation.with_direct_beam = True	3✔
148	diffraction_simulation.coordinates = coords	3✔
149	assert np.allclose(diffraction_simulation.coordinates, coords)	3✔
150
151	@pytest.mark.parametrize(	3✔
152	"calibration, expected",
153	[
154	(5.0, (5.0, 5.0)),
155	pytest.param(0, (0, 0), marks=pytest.mark.xfail(raises=ValueError)),
156	pytest.param((0, 0), (0, 0), marks=pytest.mark.xfail(raises=ValueError)),
157	((1.5, 1.5), (1.5, 1.5)),
158	((1.3, 1.5), (1.3, 1.5)),
159	],
160	)
161	def test_calibration(self, diffraction_simulation, calibration, expected):	2✔
162	diffraction_simulation.calibration = calibration	3✔
163	assert diffraction_simulation.calibration == expected	3✔
164
165	@pytest.mark.parametrize(	3✔
166	"coordinates, with_direct_beam, expected",
167	[
168	(
169	np.array([[-1, 0, 0], [0, 0, 0], [1, 0, 0]]),
170	False,
171	np.array([True, False, True]),
172	),
173	(
174	np.array([[-1, 0, 0], [0, 0, 0], [1, 0, 0]]),
175	True,
176	np.array([True, True, True]),
177	),
178	(np.array([[-1, 0, 0], [1, 0, 0]]), False, np.array([True, True])),
179	],
180	)
181	def test_direct_beam_mask(	2✔
182	self, coordinates, with_direct_beam, expected
183	):
184	diffraction_simulation = DiffractionSimulation(coordinates,	3✔
185	with_direct_beam=with_direct_beam)
186	diffraction_simulation.with_direct_beam = with_direct_beam	3✔
187	mask = diffraction_simulation.direct_beam_mask	3✔
188	assert np.all(mask == expected)	3✔
189
190	@pytest.mark.parametrize(	3✔
191	"coordinates, calibration, offset, expected",
192	[
193	(
194	np.array([[1.0, 0.0, 0.0], [1.0, 2.0, 0.0]]),
195	1.0,
196	(0.0, 0.0),
197	np.array([[1.0, 0.0], [1.0, 2.0]]),
198	),
199	(
200	np.array([[1.0, 0.0, 0.0], [1.0, 2.0, 0.0]]),
201	2.0,
202	(3.0, 1.0),
203	np.array([[2.0, 0.5], [2.0, 1.5]]),
204	),
205	pytest.param(
206	np.array([[1.0, 0.0, 0.0], [1.0, 2.0, 0.0]]),
207	None,
208	(0.0, 0.0),
209	None,
210	marks=pytest.mark.xfail(raises=Exception)
211	),
212	],
213	)
214	def test_calibrated_coordinates(	2✔
215	self,
216	coordinates,
217	calibration,
218	offset,
219	expected,
220	):
221	diffraction_simulation = DiffractionSimulation(coordinates)	3✔
222	diffraction_simulation.calibration = calibration	3✔
223	diffraction_simulation.offset = offset	3✔
224	assert np.allclose(diffraction_simulation.calibrated_coordinates,	3✔
225	expected)
226
227	@pytest.mark.parametrize(	3✔
228	"units, expected",
229	[
230	("real", np.array([[-2,1,3],[-4,3,5]])),
231	("pixel", np.array([[-4,2],[-8,6]])),
232	],
233	)
234	def test_transform_coordinates(self, diffraction_simulation_calibrated, units, expected):	2✔
235	tc = diffraction_simulation_calibrated._get_transformed_coordinates(90, units=units)	3✔
236	assert np.allclose(tc, expected)	3✔
237
238	def test_rotate_shift_coordinates(self, diffraction_simulation):	3✔
239	diffraction_simulation.rotate_shift_coordinates(90)	3✔
240	assert np.allclose(diffraction_simulation.coordinates,	3✔
241	np.array([[-2,1,3],[-4,3,5]]))
242
243	def test_assertion_free_get_diffraction_pattern(self):	3✔
244	short_sim = DiffractionSimulation(	3✔
245	coordinates=np.asarray([[0.3, 1.2, 0]]),
246	intensities=np.ones(1),
247	calibration=[1, 2],
248	)
249	z = short_sim.get_diffraction_pattern()	3✔
250
251	empty_sim = DiffractionSimulation(	3✔
252	coordinates=np.asarray([[0.3, 1000, 0]]),
253	intensities=np.ones(1),
254	calibration=[2, 2],
255	)
256	z = empty_sim.get_diffraction_pattern(shape=(10, 20))	3✔
257
258	def test_get_as_mask(self):	3✔
259	short_sim = DiffractionSimulation(	3✔
260	coordinates=np.asarray([[0.3, 1.2, 0]]),
261	intensities=np.ones(1),
262	calibration=[1, 2],
263	)
264	mask = short_sim.get_as_mask((20, 10),	3✔
265	radius_function=np.sqrt,
266	direct_beam_position=(10, 6)
267	)
268	assert mask.shape[0] == 20	3✔
269	assert mask.shape[1] == 10	3✔
270
271	@pytest.mark.parametrize("units_in",['pixel','real'])	3✔
272	def test_plot_method(self,units_in):	2✔
273	short_sim = DiffractionSimulation(	3✔
274	coordinates=np.asarray([[0.3, 1.2, 0],
275	[-2, 3, 0],
276	[2.1, 3.4, 0],]),
277	indices=np.array([[-2, 3, 4],
278	[ 2,-6, 1],
279	[ 0, 0, 0]]),
280	intensities=np.array([3., 5., 2.]),
281	calibration=[1, 2],
282	)
283	ax, sp = short_sim.plot(units=units_in, show_labels=True)	3✔

pyxem / diffsims / 1291469255

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