def __init__(self, *args, **kwargs): self, args, kwargs = push_metadata_through(self, *args, **kwargs) super().__init__(*args, **kwargs) self.cartesian = None self.hkls = None self.detector_shape = None self.pixel_calibration = None
def __init__(self, *args, **kwargs): self, args, kwargs = push_metadata_through(self, *args, **kwargs) super().__init__(*args, **kwargs) # check init dimension are correct if 'current_basis_x' in kwargs.keys(): self.current_basis_x = kwargs['current_basis_x'] else: self.current_basis_x = [1, 0] self.current_basis_y = np.matmul(np.asarray([[0, 1], [-1, 0]]), self.current_basis_x)
def __init__(self, *args, **kwargs): """ Create an Diffraction2D object from a hs.Signal2D or np.array. Parameters ---------- *args : Passed to the __init__ of Signal2D. The first arg should be either a numpy.ndarray or a Signal2D **kwargs : Passed to the __init__ of Signal2D """ self, args, kwargs = push_metadata_through(self, *args, **kwargs) super().__init__(*args, **kwargs) self.decomposition.__func__.__doc__ = BaseSignal.decomposition.__doc__
def __init__(self, *args, **kwargs): """ Create an ElectronDiffraction2D object from a hs.Signal2D or np.array. Parameters ---------- *args : Passed to the __init__ of Diffraction2D. The first arg should be either a numpy.ndarray or a Signal2D **kwargs : Passed to the __init__ of Diffraction2D """ self, args, kwargs = push_metadata_through(self, *args, **kwargs) super().__init__(*args, **kwargs) # Set default attributes if 'Acquisition_instrument' in self.metadata.as_dictionary(): if 'SEM' in self.metadata.as_dictionary( )['Acquisition_instrument']: self.metadata.set_item( "Acquisition_instrument.TEM", self.metadata.Acquisition_instrument.SEM) del self.metadata.Acquisition_instrument.SEM self.decomposition.__func__.__doc__ = BaseSignal.decomposition.__doc__
def __init__(self, *args, **kwargs): self, args, kwargs = push_metadata_through(self, *args, **kwargs) super().__init__(*args, **kwargs)
def __init__(self, *args, **kwargs): self, args, kwargs = push_metadata_through(self, *args, **kwargs) super().__init__(*args, **kwargs) self.cartesian = None self.hkls = None
def get_azimuthal_integral(self, origin, detector, detector_distance, wavelength, size_1d, unit='k_A^-1', inplace=False, kwargs_for_map={}, kwargs_for_integrator={}, kwargs_for_integrate1d={}): """ Returns the azimuthal integral of the diffraction pattern as a Diffraction1D signal. Parameters ---------- origin : np.array_like This parameter should either be a list or numpy.array with two coordinates ([x_origin,y_origin]), or an array of the same shape as the navigation axes, with an origin (with the shape [x_origin,y_origin]) at each navigation location. detector : pyFAI.detectors.Detector object A pyFAI detector used for the AzimuthalIntegrator. detector_distance : float Detector distance in meters passed to pyFAI AzimuthalIntegrator. wavelength : float The electron wavelength in meters. Used by pyFAI AzimuthalIntegrator size_1d : int The size of the returned 1D signal. (i.e. number of pixels in the 1D azimuthal integral.) unit : str The unit for for PyFAI integrate1d. The default "k_A^-1" gives k in inverse Angstroms and is not natively in PyFAI. The other options are from PyFAI and are can be "q_nm^-1", "q_A^-1", "2th_deg", "2th_rad", and "r_mm". inplace : bool If True (default False), this signal is overwritten. Otherwise, returns anew signal. kwargs_for_map : dictionary Keyword arguments to be passed to self.map(). kwargs_for_integrator : dictionary Keyword arguments to be passed to pyFAI AzimuthalIntegrator(). kwargs_for_integrate1d : dictionary Keyword arguments to be passed to pyFAI ai.integrate1d(). Returns ------- radial_profile: :obj:`pyxem.signals.ElectronDiffraction1D` The radial average profile of each diffraction pattern in the ElectronDiffraction2D signal as an ElectronDiffraction1D. See also -------- :func:`pyxem.utils.expt_utils.azimuthal_integrate` :func:`pyxem.utils.expt_utils.azimuthal_integrate_fast` """ # Scaling factor is used to output the unit in k instead of q. # It multiplies the scale that comes out of pyFAI integrate1d scaling_factor = 1 if unit == 'k_A^-1': scaling_factor = 1 / 2 / np.pi unit = 'q_A^-1' if np.array(origin).size == 2: # single origin # The AzimuthalIntegrator can be defined once and repeatedly used, # making for a fast integration # this uses azimuthal_integrate_fast p1, p2 = origin[0] * detector.pixel1, origin[1] * detector.pixel2 ai = AzimuthalIntegrator(dist=detector_distance, poni1=p1, poni2=p2, detector=detector, wavelength=wavelength, **kwargs_for_integrator) azimuthal_integrals = self.map( azimuthal_integrate_fast, azimuthal_integrator=ai, size_1d=size_1d, unit=unit, inplace=inplace, kwargs_for_integrate1d=kwargs_for_integrate1d, **kwargs_for_map) else: # this time each centre is read in origin # origin is passed as a flattened array in the navigation dimensions azimuthal_integrals = self._map_iterate( azimuthal_integrate, iterating_kwargs=(('origin', origin.reshape(-1, 2)), ), detector_distance=detector_distance, detector=detector, wavelength=wavelength, size_1d=size_1d, unit=unit, inplace=inplace, kwargs_for_integrator=kwargs_for_integrator, kwargs_for_integrate1d=kwargs_for_integrate1d, **kwargs_for_map) if len(azimuthal_integrals.data.shape) == 3: ap = Diffraction1D(azimuthal_integrals.data[:, 1, :]) tth = azimuthal_integrals.data[0, 0, :] # tth is the signal axis else: ap = Diffraction1D(azimuthal_integrals.data[:, :, 1, :]) tth = azimuthal_integrals.data[0, 0, 0, :] # tth is the signal axis scale = (tth[1] - tth[0]) * scaling_factor offset = tth[0] * scaling_factor ap.axes_manager.signal_axes[0].scale = scale ap.axes_manager.signal_axes[0].offset = offset ap.axes_manager.signal_axes[0].name = 'scattering' ap.axes_manager.signal_axes[0].units = unit transfer_navigation_axes(ap, self) push_metadata_through(ap, self) return ap
def __init__(self, *args, **kwargs): self, args, kwargs = push_metadata_through(self, *args, **kwargs) super().__init__(*args, **kwargs) self.axes_manager.set_signal_dimension(2)