Updated long overdue scripts to work with new layout and refactoring!

.idea/inspectionProfiles/Project_Default.xml

@@ -4,9 +4,17 @@
     <inspection_tool class="LongLine" enabled="true" level="WARNING" enabled_by_default="true">
       <scope name="*.c" level="WARNING" enabled="false" />
     </inspection_tool>
+    <inspection_tool class="PyArgumentListInspection" enabled="true" level="WARNING" enabled_by_default="true">
+      <scope name="gui" level="WARNING" enabled="false" />
+    </inspection_tool>
     <inspection_tool class="PyAttributeOutsideInitInspection" enabled="false" level="WEAK WARNING" enabled_by_default="false" />
     <inspection_tool class="PyBroadExceptionInspection" enabled="false" level="WEAK WARNING" enabled_by_default="false" />
-    <inspection_tool class="PyClassicStyleClassInspection" enabled="true" level="WARNING" enabled_by_default="true" />
+    <inspection_tool class="PyCallByClassInspection" enabled="true" level="WEAK WARNING" enabled_by_default="true">
+      <scope name="gui" level="WEAK WARNING" enabled="false" />
+    </inspection_tool>
+    <inspection_tool class="PyClassicStyleClassInspection" enabled="true" level="WARNING" enabled_by_default="true">
+      <scope name="gui" level="WARNING" enabled="false" />
+    </inspection_tool>
     <inspection_tool class="PyCompatibilityInspection" enabled="true" level="WARNING" enabled_by_default="true">
       <option name="ourVersions">
         <value>
@@ -17,8 +25,27 @@
       </option>
     </inspection_tool>
     <inspection_tool class="PyMandatoryEncodingInspection" enabled="true" level="WARNING" enabled_by_default="true" />
-    <inspection_tool class="PyMissingOrEmptyDocstringInspection" enabled="true" level="WEAK WARNING" enabled_by_default="true" />
+    <inspection_tool class="PyMissingOrEmptyDocstringInspection" enabled="true" level="WEAK WARNING" enabled_by_default="true">
+      <scope name="gui" level="WEAK WARNING" enabled="false" />
+    </inspection_tool>
     <inspection_tool class="PyPackageRequirementsInspection" enabled="true" level="WARNING" enabled_by_default="true">
+      <scope name="gui" level="WARNING" enabled="false">
+        <option name="ignoredPackages">
+          <value>
+            <list size="0" />
+          </value>
+        </option>
+      </scope>
+      <scope name="scripts" level="WARNING" enabled="true">
+        <option name="ignoredPackages">
+          <value>
+            <list size="2">
+              <item index="0" class="java.lang.String" itemvalue="pylab" />
+              <item index="1" class="java.lang.String" itemvalue="tqdm" />
+            </list>
+          </value>
+        </option>
+      </scope>
       <option name="ignoredPackages">
         <value>
           <list size="1">

pyramid/__init__.py

@@ -66,12 +66,14 @@ from . import dataset
 from .dataset import *
 from . import diagnostics
 from .diagnostics import *
+from . import fieldconverter
+from .fieldconverter import *
+from . import fielddata
+from .fielddata import *
 from . import forwardmodel
 from .forwardmodel import *
 from . import kernel
 from .kernel import *
-from . import fielddata
-from .fielddata import *
 from . import phasemap
 from .phasemap import *
 from . import phasemapper

pyramid/dataset.py

@@ -8,15 +8,15 @@ and additional data like corresponding projectors."""
 import logging
 from numbers import Number
 
+from pyramid.kernel import Kernel
+from pyramid.phasemap import PhaseMap
+from pyramid.phasemapper import PhaseMapperRDFC
+from pyramid.projector import Projector
+
 import matplotlib.pyplot as plt
 import numpy as np
 from scipy import sparse
 
-from .kernel import Kernel
-from .phasemap import PhaseMap
-from .phasemapper import PhaseMapperRDFC
-from .projector import Projector
-
 __all__ = ['DataSet']
 
 

pyramid/diagnostics.py

@@ -7,13 +7,14 @@ specified costfunction for a fixed magnetization distribution."""
 
 import logging
 
+from pyramid import fft
+from pyramid.fielddata import VectorData
+from pyramid.phasemap import PhaseMap
+
 import matplotlib.pyplot as plt
 import numpy as np
 
 import jutil
-from pyramid import fft
-from pyramid.fielddata import VectorData
-from pyramid.phasemap import PhaseMap
 
 __all__ = ['Diagnostics']
 

pyramid/fielddata.py

@@ -6,6 +6,11 @@
 
 from __future__ import division
 
+from scipy.ndimage.interpolation import zoom
+
+from pyramid import fft
+from pyramid.colormap import DirectionalColormap
+
 import logging
 import os
 from abc import ABCMeta, abstractmethod
@@ -14,10 +19,6 @@ from numbers import Number
 import numpy as np
 from matplotlib import pyplot as plt
 from matplotlib.ticker import MaxNLocator
-from scipy.ndimage.interpolation import zoom
-
-from pyramid import fft
-from pyramid.colormap import DirectionalColormap
 
 _log = logging.getLogger(__name__)
 try:  # Try importing HyperSpy:
@@ -123,20 +124,20 @@ class FieldData(object):
 
     def __neg__(self):  # -self
         self._log.debug('Calling __neg__')
-        return VectorData(self.a, -self.field)
+        return self.__class__(self.a, -self.field)
 
     def __add__(self, other):  # self + other
         self._log.debug('Calling __add__')
         assert isinstance(other, (FieldData, Number)), \
             'Only FieldData objects and scalar numbers (as offsets) can be added/subtracted!'
-        if isinstance(other, FieldData):
-            self._log.debug('Adding two VectorData objects')
+        if isinstance(other, Number):  # other is a Number
+            self._log.debug('Adding an offset')
+            return self.__class__(self.a, self.field + other)
+        elif isinstance(other, FieldData):
+            self._log.debug('Adding two FieldData objects')
             assert other.a == self.a, 'Added phase has to have the same grid spacing!'
             assert other.shape == self.shape, 'Added field has to have the same dimensions!'
-            return self.__init__(self.a, self.field + other.field)
-        else:  # other is a Number
-            self._log.debug('Adding an offset')
-            return self.__init__(self.a, self.field + other)
+            return self.__class__(self.a, self.field + other.field)
 
     def __sub__(self, other):  # self - other
         self._log.debug('Calling __sub__')
@@ -145,7 +146,7 @@ class FieldData(object):
     def __mul__(self, other):  # self * other
         self._log.debug('Calling __mul__')
         assert isinstance(other, Number), 'FieldData objects can only be multiplied by numbers!'
-        return VectorData(self.a, other * self.field)
+        return self.__class__(self.a, other * self.field)
 
     def __radd__(self, other):  # other + self
         self._log.debug('Calling __radd__')
@@ -181,7 +182,7 @@ class FieldData(object):
 
         """
         self._log.debug('Calling copy')
-        return self.__init__(self.a, self.field.copy())
+        return self.__class__(self.a, self.field.copy())
 
     def get_mask(self, threshold=0):
         """Mask all pixels where the amplitude of the field lies above `threshold`.
@@ -228,7 +229,6 @@ class FieldData(object):
         mlab.axes(plot)
         mlab.title(title, height=0.95, size=0.35)
         mlab.orientation_axes()
-        # mlab.show()
         return plot
 
     @abstractmethod
@@ -327,7 +327,7 @@ class FieldData(object):
         pass
 
     @abstractmethod
-    def save_to_hdf5(self, filename):
+    def save_to_hdf5(self, filename, *args, **kwargs):
         """Save field data in a file with HyperSpys HDF5-format.
 
         Parameters
@@ -709,7 +709,7 @@ class VectorData(FieldData):
         a = signal.axes_manager[0].scale
         return cls(a, field)
 
-    def save_to_hdf5(self, filename='vecdata.hdf5'):
+    def save_to_hdf5(self, filename='vecdata.hdf5', *args, **kwargs):
         """Save vector field data in a file with HyperSpys HDF5-format.
 
         Parameters
@@ -732,7 +732,7 @@ class VectorData(FieldData):
                 os.makedirs(directory)
             filename = os.path.join(directory, filename)
         # Save data to file:
-        self.to_signal().save(filename)
+        self.to_signal().save(filename, *args, **kwargs)
 
     @classmethod
     def load_from_hdf5(cls, filename):
@@ -1221,7 +1221,7 @@ class ScalarData(FieldData):
         a = signal.axes_manager[0].scale
         return cls(a, field)
 
-    def save_to_hdf5(self, filename='scaldata.hdf5'):
+    def save_to_hdf5(self, filename='scaldata.hdf5', *args, **kwargs):
         """Save field data in a file with HyperSpys HDF5-format.
 
         Parameters

pyramid/kernel.py

@@ -130,8 +130,8 @@ class Kernel(object):
                 B = np.arctan(n / m)
                 return n * A - 2 * n + 2 * m * B
 
-            return 0.5 * (_F_a(n - 0.5, m - 0.5) - _F_a(n + 0.5, m - 0.5) -
-                          _F_a(n - 0.5, m + 0.5) + _F_a(n + 0.5, m + 0.5))
+            return 0.5 * (_F_a(m - 0.5, n - 0.5) - _F_a(m + 0.5, n - 0.5) -
+                          _F_a(m - 0.5, n + 0.5) + _F_a(m + 0.5, n + 0.5))
 
     def print_info(self):
         """Print information about the kernel.

pyramid/phasemap.py

@@ -8,6 +8,8 @@ import logging
 import os
 from numbers import Number
 
+from pyramid.colormap import DirectionalColormap, TransparentColormap
+
 import matplotlib.pyplot as plt
 import numpy as np
 from PIL import Image
@@ -16,8 +18,6 @@ from matplotlib.ticker import MaxNLocator, FuncFormatter
 from mpl_toolkits.mplot3d import Axes3D
 from scipy.ndimage.interpolation import zoom
 
-from pyramid.colormap import DirectionalColormap, TransparentColormap
-
 _log = logging.getLogger(__name__)
 try:  # Try importing HyperSpy:
     import hyperspy.api as hs
@@ -468,7 +468,7 @@ class PhaseMap(object):
             confidence = None
         return cls(a, phase, mask, confidence, unit)
 
-    def save_to_hdf5(self, filename='phasemap.hdf5'):
+    def save_to_hdf5(self, filename='phasemap.hdf5', *args, **kwargs):
         """Save magnetization data in a file with HyperSpys HDF5-format.
 
         Parameters
@@ -491,7 +491,7 @@ class PhaseMap(object):
                 os.makedirs(directory)
             filename = os.path.join(directory, filename)
         # Save data to file:
-        self.to_signal().save(filename)
+        self.to_signal().save(filename, *args, **kwargs)
 
     @classmethod
     def load_from_hdf5(cls, filename):

pyramid/projector.py

@@ -16,7 +16,7 @@ from numpy import pi
 from scipy.sparse import coo_matrix, csr_matrix
 
 import pyramid.fft as fft
-from pyramid.fielddata import FieldData, VectorData, ScalarData
+from pyramid.fielddata import VectorData, ScalarData
 from pyramid.quaternion import Quaternion
 
 __all__ = ['RotTiltProjector', 'XTiltProjector', 'YTiltProjector', 'SimpleProjector']

pyramid/reconstruction.py

@@ -4,11 +4,11 @@
 #
 """Reconstruct magnetic distributions from given phasemaps.
 
-This module reconstructs 3-dimensional magnetic distributions (as :class:`~pyramid.magdata.VectorData`
-objects) from a given set of phase maps (represented by :class:`~pyramid.phasemap.PhaseMap`
-objects) by using several model based reconstruction algorithms which use the forward model
-provided by :mod:`~pyramid.projector` and :mod:`~pyramid.phasemapper` and a priori knowledge of
-the distribution.
+This module reconstructs 3-dimensional magnetic distributions (as
+:class:`~pyramid.magdata.VectorData` objects) from a given set of phase maps (represented by
+:class:`~pyramid.phasemap.PhaseMap` objects) by using several model based reconstruction algorithms
+ which use the forward model provided by :mod:`~pyramid.projector` and :mod:`~pyramid.phasemapper`
+ and a priori knowledge of the distribution.
 
 """
 

pyramid/version.py

 # -*- coding: utf-8 -*-
-"""This file is generated automatically by the Pyramid `setup.py`"""
+"""This file is generated automatically by the Pyramid `setup.pr`"""
 version = '0.1.0-dev'
 hg_revision = 'a7afcc233730+'

scripts/gui/mag_slicer.py

 # -*- coding: utf-8 -*-
-
 # Form implementation generated from reading ui file 'mag_slicer2.ui'
 #
 # Created: Sun Aug 31 20:39:52 2014
 #      by: PyQt4 UI code generator 4.9.6
 #
 # WARNING! All changes made in this file will be lost!
-
+"""GUI for slicing 3D magnetization distributions."""
 
 import os
 import sys
 
 import pyramid
-from pyramid.kernel import Kernel
 from pyramid.fielddata import VectorData
+from pyramid.kernel import Kernel
 from pyramid.phasemapper import PhaseMapperRDFC
 from pyramid.projector import SimpleProjector
 
@@ -29,6 +28,7 @@ except AttributeError:
 try:
     _encoding = QtGui.QApplication.UnicodeUTF8
 
+
     def _translate(context, text, disambig):
         return QtGui.QApplication.translate(context, text, disambig, _encoding)
 
@@ -205,7 +205,7 @@ class UI_MagSlicerMain(QtGui.QWidget):
             self.projector = SimpleProjector(self.mag_data.dim, axis=self.mode)
             self.spinBoxSlice.setMaximum(length)
             self.scrollBarSlice.setMaximum(length)
-            self.spinBoxSlice.setValue(int(length/2.))
+            self.spinBoxSlice.setValue(int(length / 2.))
             self.update_slice()
             self.phase_mapper = PhaseMapperRDFC(Kernel(self.mag_data.a, self.projector.dim_uv))
             self.phase_map = self.phase_mapper(self.projector(self.mag_data))

scripts/gui/phasemap_creator.py

@@ -6,21 +6,19 @@
 #      by: PyQt4 UI code generator 4.9.6
 #
 # WARNING! All changes made in this file will be lost!
-
+"""GUI for setting up PhasMaps from existing data in different formats."""
 
 import os
 import sys
 
-import numpy as np
-
-from PyQt4 import QtCore, QtGui
+import hyperspy.api as hs
 
-from matplotlibwidget import MatplotlibWidget
-
-from PIL import Image
 from pyramid import PhaseMap
-import ercpy
 
+import numpy as np
+from PIL import Image
+from PyQt4 import QtCore, QtGui
+from matplotlibwidget import MatplotlibWidget
 
 try:
     _fromUtf8 = QtCore.QString.fromUtf8
@@ -31,6 +29,7 @@ except AttributeError:
 try:
     _encoding = QtGui.QApplication.UnicodeUTF8
 
+
     def _translate(context, text, disambig):
         return QtGui.QApplication.translate(context, text, disambig, _encoding)
 except AttributeError:
@@ -202,22 +201,19 @@ class UI_PhaseMapCreatorMain(QtGui.QWidget):
     def update_mask(self):
         if self.mask_loaded:
             threshold = self.doubleSpinBox_thres.value()
-            mask_img = Image.fromarray(self.emd['mask'])
-            mask = np.asarray(mask_img.resize(reversed(self.emd['phase'].shape)))
+            mask_img = Image.fromarray(self.raw_mask)
+            mask = np.asarray(mask_img.resize(list(reversed(self.phase_map.dim_uv))))
             self.phase_map.mask = np.where(mask >= threshold, True, False)
             self.update_phasemap()
 
     def load_phase(self):
         try:
             self.phase_path = QtGui.QFileDialog.getOpenFileName(self, 'Load Phase', self.dir)
-            self.emd = ercpy.EMD()
-            self.emd.add_signal_from_file(self.phase_path, name='phase')
+            self.phase_map = PhaseMap.from_signal(hs.load(self.phase_path))
         except ValueError:
             return  # Abort if no phase_path is selected!
-        if self.emd.signals['phase'].axes_manager[0].scale != 1.:
-            self.doubleSpinBox_a.setValue(self.emd.signals['phase'].axes_manager[0].scale)
+        self.doubleSpinBox_a.setValue(self.phase_map.a)
         self.dir = os.path.join(os.path.dirname(self.phase_path))
-        self.phase_map = PhaseMap(self.doubleSpinBox_a.value(), self.emd['phase'])
         self.mplwidget.axes.set_visible(True)
         self.mplwidget.axes.set_visible(True)
         self.mplwidget.axes.set_visible(True)
@@ -238,21 +234,21 @@ class UI_PhaseMapCreatorMain(QtGui.QWidget):
     def load_mask(self):
         try:
             mask_path = QtGui.QFileDialog.getOpenFileName(self, 'Load Mask', self.dir)
-            self.emd.add_signal_from_file(mask_path, name='mask')
+            self.raw_mask = hs.load(mask_path).data
         except ValueError:
             return  # Abort if no mask_path is selected!
-        mask_min = self.emd['mask'].min()
-        mask_max = self.emd['mask'].max()
+        mask_min = self.raw_mask.min()
+        mask_max = self.raw_mask.max()
         self.horizontalScrollBar.setEnabled(True)
         self.horizontalScrollBar.setMinimum(mask_min)
         self.horizontalScrollBar.setMaximum(mask_max)
-        self.horizontalScrollBar.setSingleStep((mask_max-mask_min)/255.)
-        self.horizontalScrollBar.setValue((mask_max-mask_min)/2.)
+        self.horizontalScrollBar.setSingleStep((mask_max - mask_min) / 255.)
+        self.horizontalScrollBar.setValue((mask_max - mask_min) / 2.)
         self.doubleSpinBox_thres.setEnabled(True)
         self.doubleSpinBox_thres.setMinimum(mask_min)
         self.doubleSpinBox_thres.setMaximum(mask_max)
-        self.doubleSpinBox_thres.setSingleStep((mask_max-mask_min)/255.)
-        self.doubleSpinBox_thres.setValue((mask_max-mask_min)/2.)
+        self.doubleSpinBox_thres.setSingleStep((mask_max - mask_min) / 255.)
+        self.doubleSpinBox_thres.setValue((mask_max - mask_min) / 2.)
         self.mask_loaded = True
         self.update_mask()
 
@@ -261,26 +257,23 @@ class UI_PhaseMapCreatorMain(QtGui.QWidget):
             conf_path = QtGui.QFileDialog.getOpenFileName(self, 'Load Confidence', self.dir)
         except ValueError:
             return  # Abort if no conf_path is selected!
-        self.emd.add_signal_from_file(conf_path, name='confidence')
-        confidence = self.emd['confidence'] / self.emd['confidence'].max()
-        confidence = np.asarray(Image.fromarray(confidence).resize(self.emd['phase'].shape))
+        confidence = hs.load(conf_path).data
+        confidence /= confidence.max()
+        confidence = np.asarray(Image.fromarray(confidence).resize(self.phase_map.dim_uv))
         self.phase_map.confidence = confidence
         self.update_phasemap()
 
     def export(self):
         try:
             export_name = os.path.splitext(os.path.basename(self.phase_path))[0]
-            export_default = os.path.join(self.dir, 'phasemap_gui_{}.nc'.format(export_name))
+            export_default = os.path.join(self.dir, 'phasemap_gui_{}.hdf5'.format(export_name))
             export_path = QtGui.QFileDialog.getSaveFileName(self, 'Export PhaseMap',
-                                                            export_default,
-                                                            'EMD/NetCDF4 (*.emd *.nc)')
-            if export_path.endswith('.nc'):
-                self.phase_map.save_to_netcdf4(export_path)
-            elif export_path.endswith('.emd'):
-                self.emd.save_to_emd(export_path)
+                                                            export_default, 'HDF5 (*.hdf5)')
+            self.phase_map.to_signal().save(export_path, overwrite=True)
         except ValueError:
             return  # Abort if no export_path is selected!
 
+
 if __name__ == '__main__':
     app = QtGui.QApplication(sys.argv)
     widget = UI_PhaseMapCreatorMain()

scripts/magdata/magcreator/create_alternating_filaments.py

@@ -2,29 +2,28 @@
 # -*- coding: utf-8 -*-
 """Create magnetic distribution of alternating filaments."""
 
+import logging.config
 
 import numpy as np
-import pyramid as py
-import logging.config
 
+import pyramid as pr
 
-logging.config.fileConfig(py.LOGGING_CONFIG, disable_existing_loggers=False)
+logging.config.fileConfig(pr.LOGGING_CONFIG, disable_existing_loggers=False)
 
 # Parameters:
 dim = (1, 21, 21)
 a = 1.0  # in nm
-phi = np.pi/2
-theta = np.pi/2  # in rad
-magnitude = 1
+phi = np.pi / 2
+theta = np.pi / 2  # in rad
 spacing = 5
-filename = 'magdata_mc_alternating_filaments_spacing={}.nc'.format(spacing)
+filename = 'magdata_mc_alternating_filaments_spacing={}.hdf5'.format(spacing)
 
 # Create and save VectorData object:
-mag_data = py.VectorData(a, np.zeros((3,) + dim))
-count = int((dim[1]-1) / spacing) + 1
+mag_data = pr.VectorData(a, np.zeros((3,) + dim))
+count = int((dim[1] - 1) / spacing) + 1
 for i in range(count):
     pos = i * spacing
-    mag_shape = py.magcreator.Shapes.filament(dim, (0, pos))
-    mag_data += py.VectorData(a, py.magcreator.create_mag_dist_homog(mag_shape, phi))
+    mag_shape = pr.magcreator.Shapes.filament(dim, (0, pos))
+    mag_data += pr.VectorData(a, pr.magcreator.create_mag_dist_homog(mag_shape, phi))
     phi *= -1  # Switch the angle
-mag_data.save_to_netcdf4(filename)
+mag_data.save_to_hdf5(filename, overwrite=True)

scripts/magdata/magcreator/create_array_sphere_disc_slab.py

@@ -6,31 +6,31 @@ import logging.config
 
 import numpy as np
 
-import pyramid as py
+import pyramid as pr
 
-logging.config.fileConfig(py.LOGGING_CONFIG, disable_existing_loggers=False)
+logging.config.fileConfig(pr.LOGGING_CONFIG, disable_existing_loggers=False)
 
 # Parameters:
 dim = (64, 128, 128)
 a = 10.0  # in nm
-filename = 'magdata_mc_array_sphere_disc_slab.nc'
+filename = 'magdata_mc_array_sphere_disc_slab.hdf5'
 
 # Slab:
 center = (32, 32, 32)  # in px (z, y, x), index starts with 0!
 width = (48, 48, 48)  # in px (z, y, x)
-mag_shape_slab = py.magcreator.Shapes.slab(dim, center, width)
+mag_shape_slab = pr.magcreator.Shapes.slab(dim, center, width)
 # Disc:
 center = (32, 32, 96)  # in px (z, y, x), index starts with 0!
 radius = 24  # in px
 height = 24  # in px
-mag_shape_disc = py.magcreator.Shapes.disc(dim, center, radius, height)
+mag_shape_disc = pr.magcreator.Shapes.disc(dim, center, radius, height)
 # Sphere:
 center = (32, 96, 64)  # in px (z, y, x), index starts with 0!
 radius = 24  # in px
-mag_shape_sphere = py.magcreator.Shapes.sphere(dim, center, radius)
+mag_shape_sphere = pr.magcreator.Shapes.sphere(dim, center, radius)
 
 # Create and save VectorData object:
-mag_data = py.VectorData(a, py.magcreator.create_mag_dist_homog(mag_shape_slab, np.pi / 4))
-mag_data += py.VectorData(a, py.magcreator.create_mag_dist_homog(mag_shape_disc, np.pi / 2))
-mag_data += py.VectorData(a, py.magcreator.create_mag_dist_homog(mag_shape_sphere, np.pi))
-mag_data.save_to_hdf5(filename)
+mag_data = pr.VectorData(a, pr.magcreator.create_mag_dist_homog(mag_shape_slab, np.pi / 4))
+mag_data += pr.VectorData(a, pr.magcreator.create_mag_dist_homog(mag_shape_disc, np.pi / 2))
+mag_data += pr.VectorData(a, pr.magcreator.create_mag_dist_homog(mag_shape_sphere, np.pi))
+mag_data.save_to_hdf5(filename, overwrite=True)

scripts/magdata/magcreator/create_core_shell_disc.py

@@ -2,29 +2,29 @@
 # -*- coding: utf-8 -*-
 """Create magnetic core shell disc."""
 
+import logging.config
 
 import numpy as np
-import pyramid as py
-import logging.config
 
+import pyramid as pr
 
-logging.config.fileConfig(py.LOGGING_CONFIG, disable_existing_loggers=False)
+logging.config.fileConfig(pr.LOGGING_CONFIG, disable_existing_loggers=False)
 
 # Parameters:
 dim = (32, 32, 32)
 a = 1.0  # in nm
-center = (dim[0]//2-0.5, dim[1]//2-0.5, dim[2]//2-0.5)
-radius_core = dim[1]//8
-radius_shell = dim[1]//4
-height = dim[0]//2
-filename = 'magdata_mc_core_shell_disc.nc'
+center = (dim[0] // 2 - 0.5, dim[1] // 2 - 0.5, dim[2] // 2 - 0.5)
+radius_core = dim[1] // 8
+radius_shell = dim[1] // 4
+height = dim[0] // 2
+filename = 'magdata_mc_core_shell_disc.hdf5'
 
 # Magnetic shape:
-mag_shape_core = py.magcreator.Shapes.disc(dim, center, radius_core, height)
-mag_shape_outer = py.magcreator.Shapes.disc(dim, center, radius_shell, height)
+mag_shape_core = pr.magcreator.Shapes.disc(dim, center, radius_core, height)
+mag_shape_outer = pr.magcreator.Shapes.disc(dim, center, radius_shell, height)
 mag_shape_shell = np.logical_xor(mag_shape_outer, mag_shape_core)
 
 # Create and save VectorData object:
-mag_data = py.VectorData(a, py.magcreator.create_mag_dist_vortex(mag_shape_shell, amplitude=0.75))
-mag_data += py.VectorData(a, py.magcreator.create_mag_dist_homog(mag_shape_core, phi=0, theta=0))
-mag_data.save_to_netcdf4(filename)
+mag_data = pr.VectorData(a, pr.magcreator.create_mag_dist_vortex(mag_shape_shell, amplitude=0.75))
+mag_data += pr.VectorData(a, pr.magcreator.create_mag_dist_homog(mag_shape_core, phi=0, theta=0))
+mag_data.save_to_hdf5(filename, overwrite=True)

scripts/magdata/magcreator/create_core_shell_sphere.py

@@ -2,29 +2,29 @@
 # -*- coding: utf-8 -*-
 """Create magnetic core shell sphere."""
 
+import logging.config
 
 import numpy as np
-import pyramid as py
-import logging.config
 
+import pyramid as pr
 
-logging.config.fileConfig(py.LOGGING_CONFIG, disable_existing_loggers=False)
+logging.config.fileConfig(pr.LOGGING_CONFIG, disable_existing_loggers=False)
 
 # Parameters:
 dim = (32, 32, 32)
 a = 1.0  # in nm
-center = (dim[0]//2-0.5, dim[1]//2-0.5, dim[2]//2-0.5)
-radius_core = dim[1]//8
-radius_shell = dim[1]//4
-filename = 'magdata_mc_core_shell_sphere.nc'
+center = (dim[0] // 2 - 0.5, dim[1] // 2 - 0.5, dim[2] // 2 - 0.5)
+radius_core = dim[1] // 8
+radius_shell = dim[1] // 4
+filename = 'magdata_mc_core_shell_sphere.hdf5'
 
 # Magnetic shape:
-mag_shape_sphere = py.magcreator.Shapes.sphere(dim, center, radius_shell)
-mag_shape_disc = py.magcreator.Shapes.disc(dim, center, radius_core, height=dim[0])
+mag_shape_sphere = pr.magcreator.Shapes.sphere(dim, center, radius_shell)
+mag_shape_disc = pr.magcreator.Shapes.disc(dim, center, radius_core, height=dim[0])
 mag_shape_core = np.logical_and(mag_shape_sphere, mag_shape_disc)
 mag_shape_shell = np.logical_and(mag_shape_sphere, np.logical_not(mag_shape_core))
 
 # Create and save VectorData object:
-mag_data = py.VectorData(a, py.magcreator.create_mag_dist_vortex(mag_shape_shell, amplitude=0.75))
-mag_data += py.VectorData(a, py.magcreator.create_mag_dist_homog(mag_shape_core, phi=0, theta=0))
-mag_data.save_to_netcdf4(filename)
+mag_data = pr.VectorData(a, pr.magcreator.create_mag_dist_vortex(mag_shape_shell, amplitude=0.75))
+mag_data += pr.VectorData(a, pr.magcreator.create_mag_dist_homog(mag_shape_core, phi=0, theta=0))
+mag_data.save_to_hdf5(filename, overwrite=True)

scripts/magdata/magcreator/create_flat_homog_slab.py

+#! python
+# -*- coding: utf-8 -*-
+"""Create vortex disc magnetization distribution."""
+
+import logging.config
+
+import numpy as np
+
+import pyramid as pr
+
+logging.config.fileConfig(pr.LOGGING_CONFIG, disable_existing_loggers=False)
+
+# Parameters:
+dim = (1, 512, 512)
+a = 1.0  # in nm
+axis = 'z'
+amplitude = 1
+filename = 'magdata_mc_flat_homog_slab.hdf5'
+rotation = np.pi / 4
+tilt = 0
+
+# Magnetic shape:
+center_1 = (0, dim[1] // 2 - 0.5 + 40, dim[2] // 2 - 0.5)
+center_2 = (0, dim[1] // 2 - 0.5 - 40, dim[2] // 2 - 0.5)
+width = (1, 80, 80)  # in px
+mag_shape_1 = pr.magcreator.Shapes.slab(dim, center_1, width)
+mag_shape_2 = pr.magcreator.Shapes.slab(dim, center_2, width)
+
+# Create and save VectorData object:
+mag = pr.magcreator.create_mag_dist_homog(mag_shape_1, phi=7 / 12. * np.pi, amplitude=amplitude)
+mag += pr.magcreator.create_mag_dist_homog(mag_shape_2, phi=1 / 3. * np.pi, amplitude=amplitude)
+mag_data = pr.VectorData(a, mag)
+projector = pr.RotTiltProjector(mag_data.dim, rotation, tilt)
+mag_proj = projector(mag_data)
+mag_proj.save_to_hdf5(filename, overwrite=True)

scripts/magdata/magcreator/create_paper2_vortex_slab.py → scripts/magdata/magcreator/create_flat_vortex_slab.py

@@ -2,26 +2,25 @@
 # -*- coding: utf-8 -*-
 """Create vortex disc magnetization distribution."""
 
-
-import pyramid as py
 import logging.config
 
+import pyramid as pr
 
-logging.config.fileConfig(py.LOGGING_CONFIG, disable_existing_loggers=False)
+logging.config.fileConfig(pr.LOGGING_CONFIG, disable_existing_loggers=False)
 
 # Parameters:
 dim = (1, 512, 512)
 a = 1.0  # in nm
 axis = 'z'
-magnitude = 1
-filename = 'magdata_mc_paper2_vortex_slab_simulated.nc'
+amplitude = 1
+filename = 'magdata_mc_vortex_slab.hdf5'
 
 # Magnetic shape:
-center = (0, dim[1]//2-0.5, dim[2]//2-0.5)
-width = (0, 128, 128)  # in px
-mag_shape = py.magcreator.Shapes.slab(dim, center, width)
+center = (0, dim[1] // 2 - 0.5, dim[2] // 2 - 0.5)
+width = (1, 128, 128)  # in px
+mag_shape = pr.magcreator.Shapes.slab(dim, center, width)
 
 # Create and save VectorData object:
-mag_data = py.VectorData(a,
-                         py.magcreator.create_mag_dist_vortex(mag_shape, center, axis, magnitude))
-mag_data.save_to_netcdf4(filename)
+magnitude = pr.magcreator.create_mag_dist_vortex(mag_shape, center, axis, amplitude)
+mag_data = pr.VectorData(a, magnitude)
+mag_data.save_to_hdf5(filename, overwrite=True)

scripts/magdata/magcreator/create_homog_disc.py

@@ -2,28 +2,28 @@
 # -*- coding: utf-8 -*-
 """Create pyramid logo."""
 
+import logging.config
 
 import numpy as np
-import pyramid as py
-import logging.config
 
+import pyramid as pr
 
-logging.config.fileConfig(py.LOGGING_CONFIG, disable_existing_loggers=False)
+logging.config.fileConfig(pr.LOGGING_CONFIG, disable_existing_loggers=False)
 
 # Parameters:
 dim = (32, 32, 32)
 a = 1.0  # in nm
-phi = np.pi/4  # in rad
-theta = np.pi/4  # in rad
-magnitude = 1
-filename = 'magdata_mc_homog_disc.nc'
+phi = np.pi / 4  # in rad
+theta = np.pi / 4  # in rad
+amplitude = 1
+filename = 'magdata_mc_homog_disc.hdf5'
 
 # Magnetic shape:
-center = (dim[0]//2-0.5, dim[1]//2-0.5, dim[2]//2-0.5)
-radius = dim[2]//4
-height = dim[0]//2
-mag_shape = py.magcreator.Shapes.disc(dim, center, radius, height)
+center = (dim[0] // 2 - 0.5, dim[1] // 2 - 0.5, dim[2] // 2 - 0.5)
+radius = dim[2] // 4
+height = dim[0] // 2
+mag_shape = pr.magcreator.Shapes.disc(dim, center, radius, height)
 
 # Create and save VectorData object:
-mag_data = py.VectorData(a, py.magcreator.create_mag_dist_homog(mag_shape, phi, theta, magnitude))
-mag_data.save_to_netcdf4(filename)
+mag_data = pr.VectorData(a, pr.magcreator.create_mag_dist_homog(mag_shape, phi, theta, amplitude))
+mag_data.save_to_hdf5(filename, overwrite=True)