Merge branch 'PM' into 'master'

PM updated for fielddata

See merge request caron/pyramid!13

pyramid/kernel.py

@@ -183,7 +183,7 @@ class KernelCharge(object):
     v_acc : float, optional
         The acceleration voltage of the electron microscope in V. The default is 300000.
     electrode_vec : tuple of float (N=2)
-        The norm vector of the counter electrode, (elec_a,elec_b), and the distance to the origin is
+        The norm vector of the counter electrode in pixels, (elec_a,elec_b), and the distance to the origin is
         the norm of (elec_a,elec_b).
     dim_uv : tuple of int (N=2), optional
         Dimensions of the 2-dimensional electrostatic charge grid from which the phase should
@@ -240,7 +240,7 @@ class KernelCharge(object):
         self.slice_c = (slice(0, dim_uv[0]),  # Charge is padded on the far end!
                         slice(0, dim_uv[1]))  # (Phase cutout is shifted as listed above)
         # Calculate kernel (single pixel phase):
-        coeff = C_e * Q_E / (4 * np.pi * EPS_0)  # Minus is gone because of negative z-direction
+        coeff = a * C_e * Q_E / (4 * np.pi * EPS_0)  # Minus is gone because of negative z-direction
         v_dim, u_dim = dim_uv
         u = np.linspace(-(u_dim - 1), u_dim - 1, num=2 * u_dim - 1)
         v = np.linspace(-(v_dim - 1), v_dim - 1, num=2 * v_dim - 1)
@@ -276,7 +276,7 @@ class KernelCharge(object):
         r1 = np.sqrt(n ** 2 + m ** 2)
         r2 = np.sqrt((n - u_img) ** 2 + (m - v_img) ** 2)
         # The square height when  the path come across the sphere
-        R = a / 2  # the radius of the pixel
+        R = 1. / 2  # the radius of the pixel
         h1 = R ** 2 - r1 ** 2
         h2 = R ** 2 - r2 ** 2
         # Phase calculation in 3 different cases

pyramid/utils/pm.py

@@ -2,12 +2,12 @@
 # Copyright 2016 by Forschungszentrum Juelich GmbH
 # Author: J. Caron
 #
-"""Convenience function for phase mapping magnetic distributions."""
+"""Convenience function for phase mapping magnetic or charge distributions."""
 
 import logging
 
-from ..kernel import Kernel
-from ..phasemapper import PhaseMapperRDFC, PhaseMapperFDFC
+from ..kernel import Kernel, KernelCharge
+from ..phasemapper import PhaseMapperRDFC, PhaseMapperFDFC, PhaseMapperCharge
 from ..projector import RotTiltProjector, XTiltProjector, YTiltProjector, SimpleProjector
 
 __all__ = ['pm']
@@ -15,18 +15,24 @@ _log = logging.getLogger(__name__)
 
 # TODO: rename magdata to vecdata everywhere!
 
-def pm(magdata, mode='z', b_0=1, mapper='RDFC', **kwargs):
-    """Convenience function for fast magnetic phase mapping.
+
+def pm(fielddata, mode='z', b_0=1, electrode_vec=(1E6, 1E6), mapper='RDFC', **kwargs):
+    """Convenience function for fast electric charge and magnetic phase mapping.
 
     Parameters
     ----------
-    magdata : :class:`~.VectorData`
-        A :class:`~.VectorData` object, from which the projected phase map should be calculated.
+    fielddata : :class:`~.VectorData`, or `~.ScalarData`
+        A :class:`~.VectorData` or `~.ScalarData` object, from which the projected phase map should be calculated.
     mode: {'z', 'y', 'x', 'x-tilt', 'y-tilt', 'rot-tilt'}, optional
         Projection mode which determines the :class:`~.pyramid.projector.Projector` subclass, which
         is used for the projection. Default is a simple projection along the `z`-direction.
     b_0 : float, optional
         Saturation magnetization in Tesla, which is used for the phase calculation. Default is 1.
+    electrode_vec : tuple of float (N=2)
+        The norm vector of the counter electrode, (elec_a,elec_b), and the distance to the origin is
+        the norm of (elec_a,elec_b). The default value is (1E6, 1E6).
+    mapper : :class: '~. PhaseMap'
+        A :class: '~. PhaseMap' object, which maps a fielddata into a phase map. The default is 'RDFC'.
     **kwargs : additional arguments
         Additional arguments like `dim_uv`, 'tilt' or 'rotation', which are passed to the
         projector-constructor, defined by the `mode`.
@@ -42,26 +48,29 @@ def pm(magdata, mode='z', b_0=1, mapper='RDFC', **kwargs):
     padding = kwargs.pop('padding', 0)
     # Determine projection mode:
     if mode == 'rot-tilt':
-        projector = RotTiltProjector(magdata.dim, **kwargs)
+        projector = RotTiltProjector(fielddata.dim, **kwargs)
     elif mode == 'x-tilt':
-        projector = XTiltProjector(magdata.dim, **kwargs)
+        projector = XTiltProjector(fielddata.dim, **kwargs)
     elif mode == 'y-tilt':
-        projector = YTiltProjector(magdata.dim, **kwargs)
+        projector = YTiltProjector(fielddata.dim, **kwargs)
     elif mode in ['x', 'y', 'z']:
-        projector = SimpleProjector(magdata.dim, axis=mode, **kwargs)
+        projector = SimpleProjector(fielddata.dim, axis=mode, **kwargs)
     else:
         raise ValueError("Invalid mode (use 'x', 'y', 'z', 'x-tilt', 'y-tilt' or 'rot-tilt')")
     # Project:
-    mag_proj = projector(magdata)
+    field_proj = projector(fielddata)
     # Set up phasemapper and map phase:
     if mapper == 'RDFC':
-        phasemapper = PhaseMapperRDFC(Kernel(magdata.a, projector.dim_uv, b_0=b_0))
+        phasemapper = PhaseMapperRDFC(Kernel(fielddata.a, projector.dim_uv, b_0=b_0))
     elif mapper == 'FDFC':
-        phasemapper = PhaseMapperFDFC(magdata.a, projector.dim_uv, b_0=b_0, padding=padding)
+        phasemapper = PhaseMapperFDFC(fielddata.a, projector.dim_uv, b_0=b_0, padding=padding)
+        # Set up phasemapper and map phase:
+    elif mapper == 'Charge':
+        phasemapper = PhaseMapperCharge(KernelCharge(fielddata.a, projector.dim_uv, electrode_vec=electrode_vec))
     else:
-        raise ValueError("Invalid mapper (use 'RDFC' or 'FDFC'")
-    phasemap = phasemapper(mag_proj)
-    # Get mask from magdata:
-    phasemap.mask = mag_proj.get_mask()[0, ...]
+        raise ValueError("Invalid mapper (use 'RDFC', 'FDFC' or 'Charge'")
+    phasemap = phasemapper(field_proj)
+    # Get mask from fielddata:
+    phasemap.mask = field_proj.get_mask()[0, ...]
     # Return phase:
     return phasemap