1296834460

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/40391f380ca779ea8ca2c7fd99192f2d693add7a">40391f380">&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/40391f380ca779ea8ca2c7fd99192f2d693add7a">40391f380</a><a href="https://github.com/pyxem/diffsims/commit/40391f380ca779ea8ca2c7fd99192f2d693add7a">&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/40391f380ca779ea8ca2c7fd99192f2d693add7a&quot;&gt;40391f380&lt;/a&gt;&lt;a href=&quot;https://github.com/pyxem/diffsims/commit/40391f380ca779ea8ca2c7fd99192f2d693add7a&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

165 of 166 new or added lines in 2 files covered. (99.4%)

3390 of 3391 relevant lines covered (99.97%)

2.96 hits per line

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

99.44

/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
import copy


class DiffractionSimulation:
    """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=None,
        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 coordinates.ndim == 1:
            coordinates = coordinates[None, :]
        if indices is None:
            indices = np.full((coordinates.shape[0], 3), np.nan)
        if intensities is None:
            intensities = np.full((coordinates.shape[0]), np.nan)
        # check here whether shapes are all the same
        if (
            coordinates.shape[0] == indices.shape[0] == intensities.shape[0]
            and coordinates.ndim == indices.ndim == 2
            and intensities.ndim == 1
        ):
            self._coordinates = coordinates
            self._indices = indices
            self._intensities = intensities
        else:
            raise ValueError(
                "Coordinate, intensity, and indices lists must be of the correct and matching shape."
            )
        self.calibration = calibration
        self.offset = np.array(offset)
        self.with_direct_beam = with_direct_beam

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

    @property
    def size(self):
        return self.__len__()

    def __getitem__(self, sliced):
        """Sliced is any valid numpy slice that does not change the number of
        dimensions or number of columns"""
        coords = self.coordinates[sliced]
        inds = self.indices[sliced]
        ints = self.intensities[sliced]
        if coords.ndim == 1:
            coords = coords[None, :]
            inds = inds[None, :]
            ints = ints[None]
        # some valid numpy slices will create invalid shapes for diffraction simulation
        if coords.ndim > 2 or coords.shape[1] > 3 or coords.shape[1] < 2:
            raise ValueError(f"Invalid slice: {sliced}")
        return DiffractionSimulation(
            coords,
            indices=inds,
            intensities=ints,
            calibration=self.calibration,
            offset=self.offset,
            with_direct_beam=self.with_direct_beam,
        )

    def deepcopy(self):
        return copy.deepcopy(self)

    def __add__(self, other):
        new = self.deepcopy()
        new.extend(other)
        return new

    def extend(self, other):
        """Add the diffraction spots from another DiffractionSimulation"""
        coords = np.concatenate([self._coordinates, other._coordinates], axis=0)
        inds = np.concatenate([self._indices, other._indices], axis=0)
        ints = np.concatenate([self._intensities, other._intensities], axis=0)
        self._coordinates = coords
        self._indices = inds
        self._ints = ints

    @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."""
        if self.calibration is not None:
            return (self.coordinates[:, :2] + self.offset) / self.calibration
        else:
            raise Exception("Pixel calibration is not set!")

    @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 calibration is None:
            pass
        elif np.all(np.equal(calibration, 0)):
            raise ValueError("`calibration` cannot be zero.")
        elif isinstance(calibration, float) or isinstance(calibration, int):
            calibration = np.array((calibration, calibration))
        elif len(calibration) == 2:
            calibration = np.array(calibration)
        else:
            raise ValueError(
                "`calibration` must be a float or length-2" "tuple of floats."
            )
        self._calibration = calibration

    @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_transformed_coordinates(
        self, angle, center=(0, 0), mirrored=False, units="real"
    ):
        """Translate, rotate or mirror the pattern spot coordinates"""
        if units == "real":
            coords_transformed = self.coordinates.copy()
        else:
            coords_transformed = self.calibrated_coordinates.copy()
        cx, cy = center
        x = coords_transformed[:, 0]
        y = coords_transformed[:, 1]
        mirrored_factor = -1 if mirrored else 1
        theta = mirrored_factor * np.arctan2(y, x) + np.deg2rad(angle)
        rd = np.sqrt(x ** 2 + y ** 2)
        coords_transformed[:, 0] = rd * np.cos(theta) + cx
        coords_transformed[:, 1] = rd * np.sin(theta) + cy
        return coords_transformed

    def rotate_shift_coordinates(self, angle, center=(0, 0), mirrored=False):
        """
        Rotate, flip or shift patterns in-plane

        Parameters
        ----------
        angle: float
            In plane rotation angle in degrees
        center: 2-tuple of floats
            Center coordinate of the patterns
        mirrored: bool
            Mirror across the x axis
        """
        coords_new = self._get_transformed_coordinates(
            angle, center, mirrored, units="real"
        )
        self.coordinates = coords_new

    def get_as_mask(
        self,
        shape,
        radius=6.0,
        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

        Returns
        -------
        mask: numpy.ndarray
            Boolean mask of the diffraction pattern
        """
        r = radius
        if direct_beam_position is None:
            direct_beam_position = (shape[1] // 2, shape[0] // 2)
        point_coordinates_shifted = self._get_transformed_coordinates(
            in_plane_angle,
            center=direct_beam_position,
            mirrored=mirrored,
            units="pixels",
        )
        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,
        shape=(512, 512),
        sigma=10,
        direct_beam_position=None,
        in_plane_angle=0,
        mirrored=False,
    ):
        """Returns the diffraction data as a numpy array with
        two-dimensional Gaussians representing each diffracted peak. Should only
        be used for qualitative work.

        Parameters
        ----------
        shape  : tuple of ints
            The size of a side length (in pixels)
        sigma : float
            Standard deviation of the Gaussian function to be plotted (in pixels).
        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

        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.
        """
        if direct_beam_position is None:
            direct_beam_position = (shape[1] // 2, shape[0] // 2)
        coordinates = self._get_transformed_coordinates(
            in_plane_angle, direct_beam_position, mirrored, units="pixel"
        )
        in_frame = (
            (coordinates[:, 0] >= 0)
            & (coordinates[:, 0] < shape[1])
            & (coordinates[:, 1] >= 0)
            & (coordinates[:, 1] < shape[0])
        )
        spot_coords = coordinates[in_frame].astype(int)
        spot_intens = self.intensities[in_frame]
        pattern = np.zeros(shape)
        # 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,
        direct_beam_position=None,
        in_plane_angle=0,
        mirrored=False,
        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
        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
        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 direct_beam_position is None:
            direct_beam_position = (0, 0)
        if ax is None:
            _, ax = plt.subplots()
            ax.set_aspect("equal")
        coords = self._get_transformed_coordinates(
            in_plane_angle, direct_beam_position, mirrored, units=units
        )
        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	import copy	3✔
24
25
26	class DiffractionSimulation:	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=None,
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 coordinates.ndim == 1:	3✔
59	coordinates = coordinates[None, :]	3✔
60	if indices is None:	3✔
61	indices = np.full((coordinates.shape[0], 3), np.nan)	3✔
62	if intensities is None:	3✔
63	intensities = np.full((coordinates.shape[0]), np.nan)	3✔
64	# check here whether shapes are all the same
65	if (	3✔
66	coordinates.shape[0] == indices.shape[0] == intensities.shape[0]
67	and coordinates.ndim == indices.ndim == 2
68	and intensities.ndim == 1
69	):
70	self._coordinates = coordinates	3✔
71	self._indices = indices	3✔
72	self._intensities = intensities	3✔
73	else:
74	raise ValueError(	3✔
75	"Coordinate, intensity, and indices lists must be of the correct and matching shape."
76	)
77	self.calibration = calibration	3✔
78	self.offset = np.array(offset)	3✔
79	self.with_direct_beam = with_direct_beam	3✔
80
81	def __len__(self):	3✔
82	return self.coordinates.shape[0]	3✔
83
84	@property	3✔
85	def size(self):	2✔
NEW 86	return self.__len__()	×
87
88	def __getitem__(self, sliced):	3✔
89	"""Sliced is any valid numpy slice that does not change the number of
90	dimensions or number of columns"""
91	coords = self.coordinates[sliced]	3✔
92	inds = self.indices[sliced]	3✔
93	ints = self.intensities[sliced]	3✔
94	if coords.ndim == 1:	3✔
95	coords = coords[None, :]	3✔
96	inds = inds[None, :]	3✔
97	ints = ints[None]	3✔
98	# some valid numpy slices will create invalid shapes for diffraction simulation
99	if coords.ndim > 2 or coords.shape[1] > 3 or coords.shape[1] < 2:	3✔
100	raise ValueError(f"Invalid slice: {sliced}")	3✔
101	return DiffractionSimulation(	3✔
102	coords,
103	indices=inds,
104	intensities=ints,
105	calibration=self.calibration,
106	offset=self.offset,
107	with_direct_beam=self.with_direct_beam,
108	)
109
110	def deepcopy(self):	3✔
111	return copy.deepcopy(self)	3✔
112
113	def __add__(self, other):	3✔
114	new = self.deepcopy()	3✔
115	new.extend(other)	3✔
116	return new	3✔
117
118	def extend(self, other):	3✔
119	"""Add the diffraction spots from another DiffractionSimulation"""
120	coords = np.concatenate([self._coordinates, other._coordinates], axis=0)	3✔
121	inds = np.concatenate([self._indices, other._indices], axis=0)	3✔
122	ints = np.concatenate([self._intensities, other._intensities], axis=0)	3✔
123	self._coordinates = coords	3✔
124	self._indices = inds	3✔
125	self._ints = ints	3✔
126
127	@property	3✔
128	def indices(self):	2✔
129	return self._indices[self.direct_beam_mask]	3✔
130
131	@indices.setter	3✔
132	def indices(self, indices):	2✔
133	self._indices[self.direct_beam_mask] = indices	3✔
134
135	@property	3✔
136	def calibrated_coordinates(self):	2✔
137	"""ndarray : Coordinates converted into pixel space."""
138	if self.calibration is not None:	3✔
139	return (self.coordinates[:, :2] + self.offset) / self.calibration	3✔
140	else:
141	raise Exception("Pixel calibration is not set!")	3✔
142
143	@property	3✔
144	def calibration(self):	2✔
145	"""tuple of float : The x- and y-scales of the pattern, with respect to
146	the original reciprocal angstrom coordinates."""
147	return self._calibration	3✔
148
149	@calibration.setter	3✔
150	def calibration(self, calibration):	2✔
151	if calibration is None:	3✔
152	pass	3✔
153	elif np.all(np.equal(calibration, 0)):	3✔
154	raise ValueError("`calibration` cannot be zero.")	3✔
155	elif isinstance(calibration, float) or isinstance(calibration, int):	3✔
156	calibration = np.array((calibration, calibration))	3✔
157	elif len(calibration) == 2:	3✔
158	calibration = np.array(calibration)	3✔
159	else:
160	raise ValueError(	3✔
161	"`calibration` must be a float or length-2" "tuple of floats."
162	)
163	self._calibration = calibration	3✔
164
165	@property	3✔
166	def direct_beam_mask(self):	2✔
167	"""ndarray : If `with_direct_beam` is True, returns a True array for all
168	points. If `with_direct_beam` is False, returns a True array with False
169	in the position of the direct beam."""
170	if self.with_direct_beam:	3✔
171	return np.ones_like(self._intensities, dtype=bool)	3✔
172	else:
173	return np.any(self._coordinates, axis=1)	3✔
174
175	@property	3✔
176	def coordinates(self):	2✔
177	"""ndarray : The coordinates of all unmasked points."""
178	return self._coordinates[self.direct_beam_mask]	3✔
179
180	@coordinates.setter	3✔
181	def coordinates(self, coordinates):	2✔
182	self._coordinates[self.direct_beam_mask] = coordinates	3✔
183
184	@property	3✔
185	def intensities(self):	2✔
186	"""ndarray : The intensities of all unmasked points."""
187	return self._intensities[self.direct_beam_mask]	3✔
188
189	@intensities.setter	3✔
190	def intensities(self, intensities):	2✔
191	self._intensities[self.direct_beam_mask] = intensities	3✔
192
193	def _get_transformed_coordinates(	3✔
194	self, angle, center=(0, 0), mirrored=False, units="real"
195	):
196	"""Translate, rotate or mirror the pattern spot coordinates"""
197	if units == "real":	3✔
198	coords_transformed = self.coordinates.copy()	3✔
199	else:
200	coords_transformed = self.calibrated_coordinates.copy()	3✔
201	cx, cy = center	3✔
202	x = coords_transformed[:, 0]	3✔
203	y = coords_transformed[:, 1]	3✔
204	mirrored_factor = -1 if mirrored else 1	3✔
205	theta = mirrored_factor * np.arctan2(y, x) + np.deg2rad(angle)	3✔
206	rd = np.sqrt(x 2 + y 2)	3✔
207	coords_transformed[:, 0] = rd * np.cos(theta) + cx	3✔
208	coords_transformed[:, 1] = rd * np.sin(theta) + cy	3✔
209	return coords_transformed	3✔
210
211	def rotate_shift_coordinates(self, angle, center=(0, 0), mirrored=False):	3✔
212	"""
213	Rotate, flip or shift patterns in-plane
214
215	Parameters
216	----------
217	angle: float
218	In plane rotation angle in degrees
219	center: 2-tuple of floats
220	Center coordinate of the patterns
221	mirrored: bool
222	Mirror across the x axis
223	"""
224	coords_new = self._get_transformed_coordinates(	3✔
225	angle, center, mirrored, units="real"
226	)
227	self.coordinates = coords_new	3✔
228
229	def get_as_mask(	3✔
230	self,
231	shape,
232	radius=6.0,
233	negative=True,
234	radius_function=None,
235	direct_beam_position=None,
236	in_plane_angle=0,
237	mirrored=False,
238	*args,
239	**kwargs,
240	):
241	"""
242	Return the diffraction pattern as a binary mask of type
243	bool
244
245	Parameters
246	----------
247	shape: 2-tuple of ints
248	Shape of the output mask (width, height)
249	radius: float or array, optional
250	Radii of the spots in pixels. An array may be supplied
251	of the same length as the number of spots.
252	negative: bool, optional
253	Whether the spots are masked (True) or everything
254	else is masked (False)
255	radius_function: Callable, optional
256	Calculate the radius as a function of the spot intensity,
257	for example np.sqrt. args and kwargs supplied to this method
258	are passed to this function. Will override radius.
259	direct_beam_position: 2-tuple of ints, optional
260	The (x,y) coordinate in pixels of the direct beam. Defaults to
261	the center of the image.
262	in_plane_angle: float, optional
263	In plane rotation of the pattern in degrees
264	mirrored: bool, optional
265	Whether the pattern should be flipped over the x-axis,
266	corresponding to the inverted orientation
267
268	Returns
269	-------
270	mask: numpy.ndarray
271	Boolean mask of the diffraction pattern
272	"""
273	r = radius	3✔
274	if direct_beam_position is None:	3✔
275	direct_beam_position = (shape[1] // 2, shape[0] // 2)	3✔
276	point_coordinates_shifted = self._get_transformed_coordinates(	3✔
277	in_plane_angle,
278	center=direct_beam_position,
279	mirrored=mirrored,
280	units="pixels",
281	)
282	if radius_function is not None:	3✔
283	r = radius_function(self.intensities, args, *kwargs)	3✔
284	mask = mask_utils.create_mask(shape, fill=negative)	3✔
285	mask_utils.add_circles_to_mask(	3✔
286	mask, point_coordinates_shifted, r, fill=not negative
287	)
288	return mask	3✔
289
290	def get_diffraction_pattern(	3✔
291	self,
292	shape=(512, 512),
293	sigma=10,
294	direct_beam_position=None,
295	in_plane_angle=0,
296	mirrored=False,
297	):
298	"""Returns the diffraction data as a numpy array with
299	two-dimensional Gaussians representing each diffracted peak. Should only
300	be used for qualitative work.
301
302	Parameters
303	----------
304	shape : tuple of ints
305	The size of a side length (in pixels)
306	sigma : float
307	Standard deviation of the Gaussian function to be plotted (in pixels).
308	direct_beam_position: 2-tuple of ints, optional
309	The (x,y) coordinate in pixels of the direct beam. Defaults to
310	the center of the image.
311	in_plane_angle: float, optional
312	In plane rotation of the pattern in degrees
313	mirrored: bool, optional
314	Whether the pattern should be flipped over the x-axis,
315	corresponding to the inverted orientation
316
317	Returns
318	-------
319	diffraction-pattern : numpy.array
320	The simulated electron diffraction pattern, normalised.
321
322	Notes
323	-----
324	If don't know the exact calibration of your diffraction signal using 1e-2
325	produces reasonably good patterns when the lattice parameters are on
326	the order of 0.5nm and a the default size and sigma are used.
327	"""
328	if direct_beam_position is None:	3✔
329	direct_beam_position = (shape[1] // 2, shape[0] // 2)	3✔
330	coordinates = self._get_transformed_coordinates(	3✔
331	in_plane_angle, direct_beam_position, mirrored, units="pixel"
332	)
333	in_frame = (	3✔
334	(coordinates[:, 0] >= 0)
335	& (coordinates[:, 0] < shape[1])
336	& (coordinates[:, 1] >= 0)
337	& (coordinates[:, 1] < shape[0])
338	)
339	spot_coords = coordinates[in_frame].astype(int)	3✔
340	spot_intens = self.intensities[in_frame]	3✔
341	pattern = np.zeros(shape)	3✔
342	# checks that we have some spots
343	if spot_intens.shape[0] == 0:	3✔
344	return pattern	3✔
345	else:
346	pattern[spot_coords[:, 0], spot_coords[:, 1]] = spot_intens	3✔
347	pattern = add_shot_and_point_spread(pattern.T, sigma, shot_noise=False)	3✔
348	return np.divide(pattern, np.max(pattern))	3✔
349
350	def plot(	3✔
351	self,
352	size_factor=1,
353	direct_beam_position=None,
354	in_plane_angle=0,
355	mirrored=False,
356	units="real",
357	show_labels=False,
358	label_offset=(0, 0),
359	label_formatting={},
360	ax=None,
361	**kwargs,
362	):
363	"""A quick-plot function for a simulation of spots
364
365	Parameters
366	----------
367	size_factor : float, optional
368	linear spot size scaling, default to 1
369	direct_beam_position: 2-tuple of ints, optional
370	The (x,y) coordinate in pixels of the direct beam. Defaults to
371	the center of the image.
372	in_plane_angle: float, optional
373	In plane rotation of the pattern in degrees
374	mirrored: bool, optional
375	Whether the pattern should be flipped over the x-axis,
376	corresponding to the inverted orientation
377	units : str, optional
378	'real' or 'pixel', only changes scalebars, falls back on 'real', the default
379	show_labels : bool, optional
380	draw the miller indices near the spots
381	label_offset : 2-tuple, optional
382	the relative location of the spot labels. Does nothing if `show_labels`
383	is False.
384	label_formatting : dict, optional
385	keyword arguments passed to `ax.text` for drawing the labels. Does
386	nothing if `show_labels` is False.
387	ax : matplotlib Axes, optional
388	axes on which to draw the pattern. If `None`, a new axis is created
389	**kwargs :
390	passed to ax.scatter() method
391
392	Returns
393	-------
394	ax,sp
395
396	Notes
397	-----
398	spot size scales with the square root of the intensity.
399	"""
400	if direct_beam_position is None:	3✔
401	direct_beam_position = (0, 0)	3✔
402	if ax is None:	3✔
403	_, ax = plt.subplots()	3✔
404	ax.set_aspect("equal")	3✔
405	coords = self._get_transformed_coordinates(	3✔
406	in_plane_angle, direct_beam_position, mirrored, units=units
407	)
408	sp = ax.scatter(	3✔
409	coords[:, 0],
410	coords[:, 1],
411	s=size_factor * np.sqrt(self.intensities),
412	**kwargs,
413	)
414
415	if show_labels:	3✔
416	millers = self.indices.astype(np.int16)	3✔
417	# only label the points inside the axes
418	xlim = ax.get_xlim()	3✔
419	ylim = ax.get_ylim()	3✔
420	condition = (	3✔
421	(coords[:, 0] > min(xlim))
422	& (coords[:, 0] < max(xlim))
423	& (coords[:, 1] > min(ylim))
424	& (coords[:, 1] < max(ylim))
425	)
426	millers = millers[condition]	3✔
427	coords = coords[condition]	3✔
428	# default alignment options
429	if (	3✔
430	"ha" not in label_offset
431	and "horizontalalignment" not in label_formatting
432	):
433	label_formatting["ha"] = "center"	3✔
434	if "va" not in label_offset and "verticalalignment" not in label_formatting:	3✔
435	label_formatting["va"] = "center"	3✔
436	for miller, coordinate in zip(millers, coords):	3✔
437	label = "("	3✔
438	for index in miller:	3✔
439	if index < 0:	3✔
440	label += r"$\bar{" + str(abs(index)) + r"}$"	3✔
441	else:
442	label += str(abs(index))	3✔
443	label += " "	3✔
444	label = label[:-1] + ")"	3✔
445	ax.text(	3✔
446	coordinate[0] + label_offset[0],
447	coordinate[1] + label_offset[1],
448	label,
449	**label_formatting,
450	)
451	return ax, sp	3✔
452
453
454	class ProfileSimulation:	3✔
455	"""Holds the result of a given kinematic simulation of a diffraction
456	profile.
457
458	Parameters
459	----------
460	magnitudes : array-like, shape [n_peaks, 1]
461	Magnitudes of scattering vectors.
462	intensities : array-like, shape [n_peaks, 1]
463	The kinematic intensity of the diffraction peaks.
464	hkls : [{(h, k, l): mult}] {(h, k, l): mult} is a dict of Miller
465	indices for all diffracted lattice facets contributing to each
466	intensity.
467	"""
468
469	def __init__(self, magnitudes, intensities, hkls):	3✔
470	self.magnitudes = magnitudes	3✔
471	self.intensities = intensities	3✔
472	self.hkls = hkls	3✔
473
474	def get_plot(self, annotate_peaks=True, with_labels=True, fontsize=12):	3✔
475	"""Plots the diffraction profile simulation for the
476	calculate_profile_data method in DiffractionGenerator.
477
478	Parameters
479	----------
480	annotate_peaks : boolean
481	If True, peaks are annotaed with hkl information.
482	with_labels : boolean
483	If True, xlabels and ylabels are added to the plot.
484	fontsize : integer
485	Fontsize for peak labels.
486	"""
487
488	ax = plt.gca()	3✔
489	for g, i, hkls in zip(self.magnitudes, self.intensities, self.hkls):	3✔
490	label = hkls	3✔
491	ax.plot([g, g], [0, i], color="k", linewidth=3, label=label)	3✔
492	if annotate_peaks:	3✔
493	ax.annotate(label, xy=[g, i], xytext=[g, i], fontsize=fontsize)	3✔
494
495	if with_labels:	3✔
496	ax.set_xlabel("A ($^{-1}$)")	3✔
497	ax.set_ylabel("Intensities (scaled)")	3✔
498
499	return plt	3✔

pyxem / diffsims / 1296834460

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