1253567430

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/dc17313ac5905e1ed7f734da50292642e7bcb46c">dc17313ac">&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/dc17313ac5905e1ed7f734da50292642e7bcb46c">dc17313ac</a><a href="https://github.com/pyxem/diffsims/commit/dc17313ac5905e1ed7f734da50292642e7bcb46c">&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/dc17313ac5905e1ed7f734da50292642e7bcb46c&quot;&gt;dc17313ac&lt;/a&gt;&lt;a href=&quot;https://github.com/pyxem/diffsims/commit/dc17313ac5905e1ed7f734da50292642e7bcb46c&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;double-link&amp;quot; href=&amp;quot;https://github.com/pyxem/diffsims/commit/&amp;amp;lt;a class=&amp;amp;quot;double-link&amp;amp;quot; href=... (continued)

Pull Request Pull Request #175: Improve DiffractionSimulation

Run Details

26 of 35 new or added lines in 2 files covered. (74.29%)

3292 of 3301 relevant lines covered (99.73%)

2.95 hits per line

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

93.48

/diffsims/sims/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 matplotlib.pyplot as plt
import numpy as np
from diffsims.pattern.detector_functions import add_shot_and_point_spread
from diffsims.utils import mask_utils
from collections import Sequence


class DiffractionSimulation(Sequence):
    """Holds the result of a kinematic diffraction pattern simulation.

    Parameters
    ----------
    coordinates : array-like, shape [n_points, 2]
        The x-y coordinates of points in reciprocal space.
    indices : array-like, shape [n_points, 3]
        The indices of the reciprocal lattice points that intersect the
        Ewald sphere.
    intensities : array-like, shape [n_points, ]
        The intensity of the reciprocal lattice points.
    calibration : float or tuple of float, optional
        The x- and y-scales of the pattern, with respect to the original
        reciprocal angstrom coordinates.
    offset : tuple of float, optional
        The x-y offset of the pattern in reciprocal angstroms. Defaults to
        zero in each direction.
    """

    def __init__(
        self,
        coordinates,
        indices=None,
        intensities=None,
        calibration=1.0,
        offset=(0.0, 0.0),
        with_direct_beam=False,
    ):
        """Initializes the DiffractionSimulation object with data values for
        the coordinates, indices, intensities, calibration and offset.
        """
        if indices is None:
            indices = np.zeros((coordinates.shape[0], 3))
        if intensities is None:
            intensities = np.zeros((coordinates.shape[0]))
        # check here whether shapes are all the same
        if coordinates.shape[0] == indices.shape[0] == intensities.shape[0]:
            self._coordinates = coordinates
            self._indices = indices
            self._intensities = intensities
        else:
            raise ValueError("Coordinate, intensity, and indices lists must be same size.")
        self.calibration = calibration
        self.offset = offset
        self.with_direct_beam = with_direct_beam

    def __len__(self):
        return self.direct_beam_mask.shape[0]

    def __getitem__(self, sliced):
        coords = self.coordinates[sliced]
        inds = self.indices[sliced]
        ints = self.intensities[sliced]
        return DiffractionSimulation(coords,
                                     indices=inds,
                                     intensities=ints,
                                     calibration=self.calibration,
                                     offset=self.offset,
                                     with_direct_beam=self.with_direct_beam
                                    )

    @property
    def indices(self):
        return self._indices[self.direct_beam_mask]

    @indices.setter
    def indices(self, indices):
        self._indices[self.direct_beam_mask] = indices

    @property
    def calibrated_coordinates(self):
        """ndarray : Coordinates converted into pixel space."""
        return (self.coordinates[:, :2] + np.array(self.offset))/np.array(self.calibration)

    @property
    def calibration(self):
        """tuple of float : The x- and y-scales of the pattern, with respect to
        the original reciprocal angstrom coordinates."""
        return self._calibration

    @calibration.setter
    def calibration(self, calibration):
        if np.all(np.equal(calibration, 0)):
            raise ValueError("`calibration` cannot be zero.")
        if isinstance(calibration, float) or isinstance(calibration, int):
            self._calibration = (calibration, calibration)
        elif len(calibration) == 2:
            self._calibration = calibration
        else:
            raise ValueError(
                "`calibration` must be a float or length-2" "tuple of floats."
            )

    @property
    def direct_beam_mask(self):
        """ndarray : If `with_direct_beam` is True, returns a True array for all
        points. If `with_direct_beam` is False, returns a True array with False
        in the position of the direct beam."""
        if self.with_direct_beam:
            return np.ones_like(self._intensities, dtype=bool)
        else:
            return np.any(self._coordinates, axis=1)

    @property
    def coordinates(self):
        """ndarray : The coordinates of all unmasked points."""
        return self._coordinates[self.direct_beam_mask]

    @coordinates.setter
    def coordinates(self, coordinates):
        self._coordinates[self.direct_beam_mask] = coordinates

    @property
    def intensities(self):
        """ndarray : The intensities of all unmasked points."""
        return self._intensities[self.direct_beam_mask]

    @intensities.setter
    def intensities(self, intensities):
        self._intensities[self.direct_beam_mask] = intensities

    def get_as_mask(self, shape, radius=6., negative=True,
                    radius_function=None, direct_beam_position=None,
                    in_plane_angle=0, mirrored=False,
                    *args, **kwargs):
        """
        Return the diffraction pattern as a binary mask of type
        bool

        Parameters
        ----------
        shape: 2-tuple of ints
            Shape of the output mask (width, height)
        radius: float or array, optional
            Radii of the spots in pixels. An array may be supplied
            of the same length as the number of spots.
        negative: bool, optional
            Whether the spots are masked (True) or everything
            else is masked (False)
        radius_function: Callable, optional
            Calculate the radius as a function of the spot intensity,
            for example np.sqrt. args and kwargs supplied to this method
            are passed to this function. Will override radius.
        direct_beam_position: 2-tuple of ints, optional
            The (x,y) coordinate in pixels of the direct beam. Defaults to
            the center of the image.
        in_plane_angle: float, optional
            In plane rotation of the pattern in degrees
        mirrored: bool, optional
            Whether the pattern should be flipped over the x-axis,
            corresponding to the inverted orientation
        """
        r = radius
        cx, cy = shape[0]//2, shape[1]//2
        if direct_beam_position is not None:
            cx, cy = direct_beam_position
        point_coordinates_shifted = self.calibrated_coordinates.copy()
        x = point_coordinates_shifted[:, 0]
        y = point_coordinates_shifted[:, 1]
        mirrored_factor = -1 if mirrored else 1
        theta = mirrored_factor * np.arctan2(y, x) + np.deg2rad(in_plane_angle)
        rd = np.sqrt(x**2 + y**2)
        point_coordinates_shifted[:, 0] = rd * np.cos(theta) + cx
        point_coordinates_shifted[:, 1] = rd * np.sin(theta) + cy
        if radius_function is not None:
            r = radius_function(self.intensities, *args, **kwargs)
        mask = mask_utils.create_mask(shape, fill=negative)
        mask_utils.add_circles_to_mask(mask, point_coordinates_shifted, r,
                                    fill=not negative)
        return mask

    def get_diffraction_pattern(self, size=512, sigma=10):
        """Returns the diffraction data as a numpy array with
        two-dimensional Gaussians representing each diffracted peak. Should only
        be used for qualitative work.

        Parameters
        ----------
        size  : int
            The size of a side length (in pixels)

        sigma : float
            Standard deviation of the Gaussian function to be plotted (in pixels).

        Returns
        -------
        diffraction-pattern : numpy.array
            The simulated electron diffraction pattern, normalised.

        Notes
        -----
        If don't know the exact calibration of your diffraction signal using 1e-2
        produces reasonably good patterns when the lattice parameters are on
        the order of 0.5nm and a the default size and sigma are used.
        """
        side_length = np.min(np.multiply((size / 2), self.calibration))
        mask_for_sides = np.all(
            (np.abs(self.coordinates[:, 0:2]) < side_length), axis=1
        )

        spot_coords = np.add(
            self.calibrated_coordinates[mask_for_sides], size / 2
        ).astype(int)
        spot_intens = self.intensities[mask_for_sides]
        pattern = np.zeros([size, size])
        # checks that we have some spots
        if spot_intens.shape[0] == 0:
            return pattern
        else:
            pattern[spot_coords[:, 0], spot_coords[:, 1]] = spot_intens
            pattern = add_shot_and_point_spread(pattern.T, sigma, shot_noise=False)

        return np.divide(pattern, np.max(pattern))

    def plot(self, size_factor=1, units="real", show_labels=False,
            label_offset=(0, 0),
            label_formatting={},
            ax=None,
            **kwargs):
        """A quick-plot function for a simulation of spots

        Parameters
        ----------
        size_factor : float, optional
            linear spot size scaling, default to 1
        units : str, optional
            'real' or 'pixel', only changes scalebars, falls back on 'real', the default
        show_labels : bool, optional
            draw the miller indices near the spots
        label_offset : 2-tuple, optional
            the relative location of the spot labels. Does nothing if `show_labels`
            is False.
        label_formatting : dict, optional
            keyword arguments passed to `ax.text` for drawing the labels. Does
            nothing if `show_labels` is False.
        ax : matplotlib Axes, optional
            axes on which to draw the pattern. If `None`, a new axis is created
        **kwargs :
            passed to ax.scatter() method

        Returns
        -------
        ax,sp

        Notes
        -----
        spot size scales with the square root of the intensity.
        """
        if ax is None:
            _, ax = plt.subplots()
            ax.set_aspect("equal")
        if units == "pixel":
            coords = self.calibrated_coordinates
        else:
            coords = self.coordinates

        sp = ax.scatter(
            coords[:, 0],
            coords[:, 1],
            s=size_factor * np.sqrt(self.intensities),
            **kwargs
        )

        if show_labels:
            millers = self.indices.astype(np.int16)
            # only label the points inside the axes
            xlim = ax.get_xlim()
            ylim = ax.get_ylim()
            condition = ((coords[:,0] > min(xlim)) &
                         (coords[:,0] < max(xlim)) &
                         (coords[:,1] > min(ylim)) &
                         (coords[:,1] < max(ylim)))
            millers = millers[condition]
            coords = coords[condition]
            # default alignment options
            if "ha" not in label_offset and "horizontalalignment" not in label_formatting:
                label_formatting["ha"]="center"
            if "va" not in label_offset and "verticalalignment" not in label_formatting:
                label_formatting["va"]="center"
            for miller, coordinate in zip(millers, coords):
                label = "("
                for index in miller:
                    if index<0:
                        label += r"$\bar{" + str(abs(index)) +r"}$"
                    else:
                        label += str(abs(index))
                    label += " "
                label = label[:-1] + ")"
                ax.text(coordinate[0] + label_offset[0],
                        coordinate[1] + label_offset[1],
                        label,
                        **label_formatting,
                        )
        return ax, sp


class ProfileSimulation:
    """Holds the result of a given kinematic simulation of a diffraction
    profile.

    Parameters
    ----------
    magnitudes : array-like, shape [n_peaks, 1]
        Magnitudes of scattering vectors.
    intensities : array-like, shape [n_peaks, 1]
        The kinematic intensity of the diffraction peaks.
    hkls : [{(h, k, l): mult}] {(h, k, l): mult} is a dict of Miller
        indices for all diffracted lattice facets contributing to each
        intensity.
    """

    def __init__(self, magnitudes, intensities, hkls):
        self.magnitudes = magnitudes
        self.intensities = intensities
        self.hkls = hkls

    def get_plot(self, annotate_peaks=True, with_labels=True, fontsize=12):
        """Plots the diffraction profile simulation for the
           calculate_profile_data method in DiffractionGenerator.

        Parameters
        ----------
        annotate_peaks : boolean
            If True, peaks are annotaed with hkl information.
        with_labels : boolean
            If True, xlabels and ylabels are added to the plot.
        fontsize : integer
            Fontsize for peak labels.
        """

        ax = plt.gca()
        for g, i, hkls in zip(self.magnitudes, self.intensities, self.hkls):
            label = hkls
            ax.plot([g, g], [0, i], color="k", linewidth=3, label=label)
            if annotate_peaks:
                ax.annotate(label, xy=[g, i], xytext=[g, i], fontsize=fontsize)

            if with_labels:
                ax.set_xlabel("A ($^{-1}$)")
                ax.set_ylabel("Intensities (scaled)")

        return plt

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 matplotlib.pyplot as plt	3✔
20	import numpy as np	3✔
21	from diffsims.pattern.detector_functions import add_shot_and_point_spread	3✔
22	from diffsims.utils import mask_utils	3✔
23	from collections import Sequence	3✔
24
25
26	class DiffractionSimulation(Sequence):	3✔
27	"""Holds the result of a kinematic diffraction pattern simulation.
28
29	Parameters
30	----------
31	coordinates : array-like, shape [n_points, 2]
32	The x-y coordinates of points in reciprocal space.
33	indices : array-like, shape [n_points, 3]
34	The indices of the reciprocal lattice points that intersect the
35	Ewald sphere.
36	intensities : array-like, shape [n_points, ]
37	The intensity of the reciprocal lattice points.
38	calibration : float or tuple of float, optional
39	The x- and y-scales of the pattern, with respect to the original
40	reciprocal angstrom coordinates.
41	offset : tuple of float, optional
42	The x-y offset of the pattern in reciprocal angstroms. Defaults to
43	zero in each direction.
44	"""
45
46	def __init__(	3✔
47	self,
48	coordinates,
49	indices=None,
50	intensities=None,
51	calibration=1.0,
52	offset=(0.0, 0.0),
53	with_direct_beam=False,
54	):
55	"""Initializes the DiffractionSimulation object with data values for
56	the coordinates, indices, intensities, calibration and offset.
57	"""
58	if indices is None:	3✔
59	indices = np.zeros((coordinates.shape[0], 3))	3✔
60	if intensities is None:	3✔
61	intensities = np.zeros((coordinates.shape[0]))	3✔
62	# check here whether shapes are all the same
63	if coordinates.shape[0] == indices.shape[0] == intensities.shape[0]:	3✔
64	self._coordinates = coordinates	3✔
65	self._indices = indices	3✔
66	self._intensities = intensities	3✔
67	else:
NEW 68	raise ValueError("Coordinate, intensity, and indices lists must be same size.")	×
69	self.calibration = calibration	3✔
70	self.offset = offset	3✔
71	self.with_direct_beam = with_direct_beam	3✔
72
73	def __len__(self):	3✔
NEW 74	return self.direct_beam_mask.shape[0]	×
75
76	def __getitem__(self, sliced):	3✔
NEW 77	coords = self.coordinates[sliced]	×
NEW 78	inds = self.indices[sliced]	×
NEW 79	ints = self.intensities[sliced]	×
NEW 80	return DiffractionSimulation(coords,	×
81	indices=inds,
82	intensities=ints,
83	calibration=self.calibration,
84	offset=self.offset,
85	with_direct_beam=self.with_direct_beam
86	)
87
88	@property	3✔
89	def indices(self):	2✔
90	return self._indices[self.direct_beam_mask]	3✔
91
92	@indices.setter	3✔
93	def indices(self, indices):	2✔
NEW 94	self._indices[self.direct_beam_mask] = indices	×
95
96	@property	3✔
97	def calibrated_coordinates(self):	2✔
98	"""ndarray : Coordinates converted into pixel space."""
99	return (self.coordinates[:, :2] + np.array(self.offset))/np.array(self.calibration)	3✔
100
101	@property	3✔
102	def calibration(self):	2✔
103	"""tuple of float : The x- and y-scales of the pattern, with respect to
104	the original reciprocal angstrom coordinates."""
105	return self._calibration	3✔
106
107	@calibration.setter	3✔
108	def calibration(self, calibration):	2✔
109	if np.all(np.equal(calibration, 0)):	3✔
110	raise ValueError("`calibration` cannot be zero.")	3✔
111	if isinstance(calibration, float) or isinstance(calibration, int):	3✔
112	self._calibration = (calibration, calibration)	3✔
113	elif len(calibration) == 2:	3✔
114	self._calibration = calibration	3✔
115	else:
116	raise ValueError(	3✔
117	"`calibration` must be a float or length-2" "tuple of floats."
118	)
119
120	@property	3✔
121	def direct_beam_mask(self):	2✔
122	"""ndarray : If `with_direct_beam` is True, returns a True array for all
123	points. If `with_direct_beam` is False, returns a True array with False
124	in the position of the direct beam."""
125	if self.with_direct_beam:	3✔
126	return np.ones_like(self._intensities, dtype=bool)	3✔
127	else:
128	return np.any(self._coordinates, axis=1)	3✔
129
130	@property	3✔
131	def coordinates(self):	2✔
132	"""ndarray : The coordinates of all unmasked points."""
133	return self._coordinates[self.direct_beam_mask]	3✔
134
135	@coordinates.setter	3✔
136	def coordinates(self, coordinates):	2✔
NEW 137	self._coordinates[self.direct_beam_mask] = coordinates	×
138
139	@property	3✔
140	def intensities(self):	2✔
141	"""ndarray : The intensities of all unmasked points."""
142	return self._intensities[self.direct_beam_mask]	3✔
143
144	@intensities.setter	3✔
145	def intensities(self, intensities):	2✔
NEW 146	self._intensities[self.direct_beam_mask] = intensities	×
147
148	def get_as_mask(self, shape, radius=6., negative=True,	3✔
149	radius_function=None, direct_beam_position=None,
150	in_plane_angle=0, mirrored=False,
151	args, *kwargs):
152	"""
153	Return the diffraction pattern as a binary mask of type
154	bool
155
156	Parameters
157	----------
158	shape: 2-tuple of ints
159	Shape of the output mask (width, height)
160	radius: float or array, optional
161	Radii of the spots in pixels. An array may be supplied
162	of the same length as the number of spots.
163	negative: bool, optional
164	Whether the spots are masked (True) or everything
165	else is masked (False)
166	radius_function: Callable, optional
167	Calculate the radius as a function of the spot intensity,
168	for example np.sqrt. args and kwargs supplied to this method
169	are passed to this function. Will override radius.
170	direct_beam_position: 2-tuple of ints, optional
171	The (x,y) coordinate in pixels of the direct beam. Defaults to
172	the center of the image.
173	in_plane_angle: float, optional
174	In plane rotation of the pattern in degrees
175	mirrored: bool, optional
176	Whether the pattern should be flipped over the x-axis,
177	corresponding to the inverted orientation
178	"""
179	r = radius	3✔
180	cx, cy = shape[0]//2, shape[1]//2	3✔
181	if direct_beam_position is not None:	3✔
182	cx, cy = direct_beam_position	3✔
183	point_coordinates_shifted = self.calibrated_coordinates.copy()	3✔
184	x = point_coordinates_shifted[:, 0]	3✔
185	y = point_coordinates_shifted[:, 1]	3✔
186	mirrored_factor = -1 if mirrored else 1	3✔
187	theta = mirrored_factor * np.arctan2(y, x) + np.deg2rad(in_plane_angle)	3✔
188	rd = np.sqrt(x2 + y2)	3✔
189	point_coordinates_shifted[:, 0] = rd * np.cos(theta) + cx	3✔
190	point_coordinates_shifted[:, 1] = rd * np.sin(theta) + cy	3✔
191	if radius_function is not None:	3✔
192	r = radius_function(self.intensities, args, *kwargs)	3✔
193	mask = mask_utils.create_mask(shape, fill=negative)	3✔
194	mask_utils.add_circles_to_mask(mask, point_coordinates_shifted, r,	3✔
195	fill=not negative)
196	return mask	3✔
197
198	def get_diffraction_pattern(self, size=512, sigma=10):	3✔
199	"""Returns the diffraction data as a numpy array with
200	two-dimensional Gaussians representing each diffracted peak. Should only
201	be used for qualitative work.
202
203	Parameters
204	----------
205	size : int
206	The size of a side length (in pixels)
207
208	sigma : float
209	Standard deviation of the Gaussian function to be plotted (in pixels).
210
211	Returns
212	-------
213	diffraction-pattern : numpy.array
214	The simulated electron diffraction pattern, normalised.
215
216	Notes
217	-----
218	If don't know the exact calibration of your diffraction signal using 1e-2
219	produces reasonably good patterns when the lattice parameters are on
220	the order of 0.5nm and a the default size and sigma are used.
221	"""
222	side_length = np.min(np.multiply((size / 2), self.calibration))	3✔
223	mask_for_sides = np.all(	3✔
224	(np.abs(self.coordinates[:, 0:2]) < side_length), axis=1
225	)
226
227	spot_coords = np.add(	3✔
228	self.calibrated_coordinates[mask_for_sides], size / 2
229	).astype(int)
230	spot_intens = self.intensities[mask_for_sides]	3✔
231	pattern = np.zeros([size, size])	3✔
232	# checks that we have some spots
233	if spot_intens.shape[0] == 0:	3✔
234	return pattern	3✔
235	else:
236	pattern[spot_coords[:, 0], spot_coords[:, 1]] = spot_intens	3✔
237	pattern = add_shot_and_point_spread(pattern.T, sigma, shot_noise=False)	3✔
238
239	return np.divide(pattern, np.max(pattern))	3✔
240
241	def plot(self, size_factor=1, units="real", show_labels=False,	3✔
242	label_offset=(0, 0),
243	label_formatting={},
244	ax=None,
245	**kwargs):
246	"""A quick-plot function for a simulation of spots
247
248	Parameters
249	----------
250	size_factor : float, optional
251	linear spot size scaling, default to 1
252	units : str, optional
253	'real' or 'pixel', only changes scalebars, falls back on 'real', the default
254	show_labels : bool, optional
255	draw the miller indices near the spots
256	label_offset : 2-tuple, optional
257	the relative location of the spot labels. Does nothing if `show_labels`
258	is False.
259	label_formatting : dict, optional
260	keyword arguments passed to `ax.text` for drawing the labels. Does
261	nothing if `show_labels` is False.
262	ax : matplotlib Axes, optional
263	axes on which to draw the pattern. If `None`, a new axis is created
264	**kwargs :
265	passed to ax.scatter() method
266
267	Returns
268	-------
269	ax,sp
270
271	Notes
272	-----
273	spot size scales with the square root of the intensity.
274	"""
275	if ax is None:	3✔
276	_, ax = plt.subplots()	3✔
277	ax.set_aspect("equal")	3✔
278	if units == "pixel":	3✔
279	coords = self.calibrated_coordinates	3✔
280	else:
281	coords = self.coordinates	3✔
282
283	sp = ax.scatter(	3✔
284	coords[:, 0],
285	coords[:, 1],
286	s=size_factor * np.sqrt(self.intensities),
287	**kwargs
288	)
289
290	if show_labels:	3✔
291	millers = self.indices.astype(np.int16)	3✔
292	# only label the points inside the axes
293	xlim = ax.get_xlim()	3✔
294	ylim = ax.get_ylim()	3✔
295	condition = ((coords[:,0] > min(xlim)) &	3✔
296	(coords[:,0] < max(xlim)) &
297	(coords[:,1] > min(ylim)) &
298	(coords[:,1] < max(ylim)))
299	millers = millers[condition]	3✔
300	coords = coords[condition]	3✔
301	# default alignment options
302	if "ha" not in label_offset and "horizontalalignment" not in label_formatting:	3✔
303	label_formatting["ha"]="center"	3✔
304	if "va" not in label_offset and "verticalalignment" not in label_formatting:	3✔
305	label_formatting["va"]="center"	3✔
306	for miller, coordinate in zip(millers, coords):	3✔
307	label = "("	3✔
308	for index in miller:	3✔
309	if index<0:	3✔
310	label += r"$\bar{" + str(abs(index)) +r"}$"	3✔
311	else:
312	label += str(abs(index))	3✔
313	label += " "	3✔
314	label = label[:-1] + ")"	3✔
315	ax.text(coordinate[0] + label_offset[0],	3✔
316	coordinate[1] + label_offset[1],
317	label,
318	**label_formatting,
319	)
320	return ax, sp	3✔
321
322
323	class ProfileSimulation:	3✔
324	"""Holds the result of a given kinematic simulation of a diffraction
325	profile.
326
327	Parameters
328	----------
329	magnitudes : array-like, shape [n_peaks, 1]
330	Magnitudes of scattering vectors.
331	intensities : array-like, shape [n_peaks, 1]
332	The kinematic intensity of the diffraction peaks.
333	hkls : [{(h, k, l): mult}] {(h, k, l): mult} is a dict of Miller
334	indices for all diffracted lattice facets contributing to each
335	intensity.
336	"""
337
338	def __init__(self, magnitudes, intensities, hkls):	3✔
339	self.magnitudes = magnitudes	3✔
340	self.intensities = intensities	3✔
341	self.hkls = hkls	3✔
342
343	def get_plot(self, annotate_peaks=True, with_labels=True, fontsize=12):	3✔
344	"""Plots the diffraction profile simulation for the
345	calculate_profile_data method in DiffractionGenerator.
346
347	Parameters
348	----------
349	annotate_peaks : boolean
350	If True, peaks are annotaed with hkl information.
351	with_labels : boolean
352	If True, xlabels and ylabels are added to the plot.
353	fontsize : integer
354	Fontsize for peak labels.
355	"""
356
357	ax = plt.gca()	3✔
358	for g, i, hkls in zip(self.magnitudes, self.intensities, self.hkls):	3✔
359	label = hkls	3✔
360	ax.plot([g, g], [0, i], color="k", linewidth=3, label=label)	3✔
361	if annotate_peaks:	3✔
362	ax.annotate(label, xy=[g, i], xytext=[g, i], fontsize=fontsize)	3✔
363
364	if with_labels:	3✔
365	ax.set_xlabel("A ($^{-1}$)")	3✔
366	ax.set_ylabel("Intensities (scaled)")	3✔
367
368	return plt	3✔

pyxem / diffsims / 1253567430

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