Skip to content
Snippets Groups Projects

Compare revisions

Changes are shown as if the source revision was being merged into the target revision. Learn more about comparing revisions.

Source

Select target project
No results found

Target

Select target project
  • empyre/empyre
  • weber/empyre
  • wessels/empyre
  • bryan/empyre
4 results
Show changes
Hide whitespace changes
Inline Side-by-side
Showing
with 87 additions and 998 deletions
scripts/compare_pixel_fields.py deleted 100644 → 0
View file @ 7d656100
# -*- coding: utf-8 -*-
"""Compare the phase map of one pixel for different real space approaches."""
import pdb, traceback, sys
from numpy import pi
import pyramid.magcreator as mc
import pyramid.projector as pj
import pyramid.phasemapper as pm
from pyramid.magdata import MagData
from pyramid.phasemap import PhaseMap
def compare_pixel_fields():
'''Calculate and display the phase map for different real space approaches.
Arguments:
None
Returns:
None
'''
# Input parameters:
res = 10.0 # in nm
phi = pi/2 # in rad
dim = (1, 11, 11)
pixel = (0, 5, 5)
# Create magnetic data, project it, get the phase map and display the holography image:
mag_data = MagData(res, mc.create_mag_dist(mc.Shapes.pixel(dim, pixel), phi))
projection = pj.simple_axis_projection(mag_data)
phase_map_slab = PhaseMap(res, pm.phase_mag_real(res, projection, 'slab'))
phase_map_slab.display('Phase of one Pixel (Slab)')
phase_map_disc = PhaseMap(res, pm.phase_mag_real(res, projection, 'disc'))
phase_map_disc.display('Phase of one Pixel (Disc)')
phase_map_diff = PhaseMap(res, phase_map_disc.phase - phase_map_slab.phase)
phase_map_diff.display('Phase difference of one Pixel (Disc - Slab)')
if __name__ == "__main__":
try:
compare_pixel_fields()
except:
type, value, tb = sys.exc_info()
traceback.print_exc()
pdb.post_mortem(tb)
\ No newline at end of file
scripts/compare_vortices.py deleted 100644 → 0
View file @ 7d656100
# -*- coding: utf-8 -*-
"""Create the Pyramid-Logo."""
import pdb, traceback, sys
import numpy as np
from numpy import pi
import matplotlib.pyplot as plt
import pyramid.magcreator as mc
import pyramid.projector as pj
import pyramid.phasemapper as pm
import pyramid.holoimage as hi
from pyramid.magdata import MagData
from pyramid.phasemap import PhaseMap
def compare_vortices():
'''Calculate and display the Pyramid-Logo.
Arguments:
None
Returns:
None
'''
# Input parameters:
dim_list = [(1, 512, 512), (1, 256, 256), (1, 128, 128), (1, 64, 64), (1, 32, 32), (1, 16, 16)]
res_list = [2., 4., 8., 16., 32., 64.] # in nm
density = 10
height = 1
x = []
y = []
# Starting magnetic distribution:
dim_start = (1, 2*dim_list[0][1], 2*dim_list[0][2])
res_start = res_list[0] / 2
print 'dim_start = ', dim_start
print 'res_start = ', res_start
center = (0, dim_start[1]/2 - 0.5, dim_start[2]/2 - 0.5)
radius = 0.25 * dim_start[1]
mag_shape = mc.Shapes.disc(dim_start, center, radius, height)
mag_data = MagData(res_start, mc.create_mag_dist_vortex(mag_shape))
#mag_data.quiver_plot()
for i, (dim, res) in enumerate(zip(dim_list, res_list)):
# Create coarser grid for the magnetization:
z_mag = mag_data.magnitude[0].reshape(1, dim[1], 2, dim[1], 2)
y_mag = mag_data.magnitude[1].reshape(1, dim[1], 2, dim[1], 2)
x_mag = mag_data.magnitude[2].reshape(1, dim[1], 2, dim[1], 2)
print 'dim = ', dim
print 'res = ', res
magnitude = (z_mag.mean(axis=4).mean(axis=2) / 2,
y_mag.mean(axis=4).mean(axis=2) / 2,
x_mag.mean(axis=4).mean(axis=2) / 2)
mag_data = MagData(res, magnitude)
print np.shape(mag_data.magnitude[0])
#mag_data.quiver_plot()
projection = pj.simple_axis_projection(mag_data)
phase_map = PhaseMap(res, pm.phase_mag_real(res, projection, 'slab'))
hi.display_combined(phase_map, density, 'Vortex State, res = {}'.format(res))
x.append(np.linspace(0, dim[1]*res, dim[1]))
y.append(phase_map.phase[dim[1]/2, :]/pi)
fig = plt.figure()
fig.add_subplot(1, 1, 1)
plt.plot(x[i], y[i])
#
# Plot:
fig = plt.figure()
axis = fig.add_subplot(1, 1, 1)
axis.plot(x[0], y[0], 'k',
x[1], y[1], 'r',
x[2], y[2], 'm',
x[3], y[3], 'y',
x[4], y[4], 'c',
x[5], y[5], 'g',
x[6], y[6], 'b')
axis.set_xlabel('x [nm]')
axis.set_ylabel('phase')
if __name__ == "__main__":
try:
compare_vortices()
except:
type, value, tb = sys.exc_info()
traceback.print_exc()
pdb.post_mortem(tb)
\ No newline at end of file
scripts/create_alternating_filaments.py deleted 100644 → 0
View file @ 7d656100
# -*- coding: utf-8 -*-
"""Create magnetic distribution of alternating filaments"""
import pdb, traceback, sys
import numpy as np
from numpy import pi
import pyramid.magcreator as mc
from pyramid.magdata import MagData
def create_alternating_filaments():
'''Calculate, display and save the magnetic distribution of alternating filaments to file.
Arguments:
None
Returns:
None
'''
# Input parameters:
filename = '../output/mag_dist_alt_filaments.txt'
dim = (1, 21, 21) # in px (z, y, x)
res = 10.0 # in nm
phi = pi/2
spacing = 5
# Create lists for magnetic objects:
count = int((dim[1]-1) / spacing) + 1
mag_shape_list = np.zeros((count,) + dim)
phi_list = np.zeros(count)
for i in range(count):
pos = i * spacing
mag_shape_list[i] = mc.Shapes.filament(dim, (0, pos))
phi_list[i] = (1-2*(int(pos/spacing)%2)) * phi
# Create magnetic distribution
magnitude = mc.create_mag_dist_comb(mag_shape_list, phi_list)
mag_data = MagData(res, magnitude)
mag_data.quiver_plot()
mag_data.save_to_llg(filename)
if __name__ == "__main__":
try:
create_alternating_filaments()
except:
type, value, tb = sys.exc_info()
traceback.print_exc()
pdb.post_mortem(tb)
\ No newline at end of file
scripts/create_logo.py deleted 100644 → 0
View file @ 7d656100
# -*- coding: utf-8 -*-
"""Create the Pyramid-Logo."""
import pdb, traceback, sys
import numpy as np
from numpy import pi
import pyramid.magcreator as mc
import pyramid.projector as pj
import pyramid.phasemapper as pm
import pyramid.holoimage as hi
from pyramid.magdata import MagData
from pyramid.phasemap import PhaseMap
def create_logo():
'''Calculate and display the Pyramid-Logo.
Arguments:
None
Returns:
None
'''
# Input parameters:
res = 10.0 # in nm
phi = -pi/2 # in rad
density = 10
dim = (1, 128, 128)
# Create magnetic shape:
mag_shape = np.zeros(dim)
x = range(dim[2])
y = range(dim[1])
xx, yy = np.meshgrid(x, y)
bottom = (yy >= 0.25*dim[1])
left = (yy <= 0.75/0.5 * dim[1]/dim[2] * xx)
right = np.fliplr(left)
mag_shape[0,...] = np.logical_and(np.logical_and(left, right), bottom)
# Create magnetic data, project it, get the phase map and display the holography image:
mag_data = MagData(res, mc.create_mag_dist(mag_shape, phi))
projection = pj.simple_axis_projection(mag_data)
phase_map = PhaseMap(res, pm.phase_mag_real(res, projection, 'slab'))
hi.display(hi.holo_image(phase_map, density), 'PYRAMID - LOGO')
if __name__ == "__main__":
try:
create_logo()
except:
type, value, tb = sys.exc_info()
traceback.print_exc()
pdb.post_mortem(tb)
\ No newline at end of file
scripts/create_multiple_samples.py deleted 100644 → 0
View file @ 7d656100
# -*- coding: utf-8 -*-
"""Create random magnetic distributions."""
import random as rnd
import pdb, traceback, sys
import numpy as np
from numpy import pi
import pyramid.magcreator as mc
from pyramid.magdata import MagData
import pyramid.phasemapper as pm
import pyramid.projector as pj
import pyramid.holoimage as hi
from pyramid.phasemap import PhaseMap
def create_multiple_samples():
'''Calculate, display and save a random magnetic distribution to file.
Arguments:
None
Returns:
None
'''
filename = '../output/mag_dist_multiple_samples.txt'
res = 10.0 # nm
dim = (64, 128, 128)
# 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 = mc.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 = mc.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 = mc.Shapes.sphere(dim, center, radius)
# Create lists for magnetic objects:
mag_shape_list = [mag_shape_slab, mag_shape_disc, mag_shape_sphere]
phi_list = [pi/4, pi/2, pi]
# Create magnetic distribution:
magnitude = mc.create_mag_dist_comb(mag_shape_list, phi_list)
mag_data = MagData(res, magnitude)
mag_data.quiver_plot('z', dim[0]/2)
mag_data.save_to_llg(filename)
projection = pj.simple_axis_projection(mag_data)
phase_map = PhaseMap(res, pm.phase_mag_real(res, projection, 'slab'))
phase_map.display()
hi.display(hi.holo_image(phase_map, 0.5))
if __name__ == "__main__":
try:
create_multiple_samples()
except:
type, value, tb = sys.exc_info()
traceback.print_exc()
pdb.post_mortem(tb)
\ No newline at end of file
scripts/create_random_pixels.py deleted 100644 → 0
View file @ 7d656100
# -*- coding: utf-8 -*-
"""Create random magnetic distributions."""
import random as rnd
import pdb, traceback, sys
import numpy as np
from numpy import pi
import pyramid.magcreator as mc
from pyramid.magdata import MagData
import pyramid.phasemapper as pm
import pyramid.projector as pj
import pyramid.holoimage as hi
from pyramid.phasemap import PhaseMap
def create_random_pixels():
'''Calculate, display and save a random magnetic distribution to file.
Arguments:
None
Returns:
None
'''
# Input parameters:
count = 10
dim = (1, 128, 128)
res = 10 # in nm
rnd.seed(12)
# Create lists for magnetic objects:
mag_shape_list = np.zeros((count,) + dim)
phi_list = np.zeros(count)
magnitude_list = np.zeros(count)
for i in range(count):
pixel = (rnd.randrange(dim[0]), rnd.randrange(dim[1]), rnd.randrange(dim[2]))
mag_shape_list[i,...] = mc.Shapes.pixel(dim, pixel)
phi_list[i] = 2*pi*rnd.random()
magnitude_list[i] = 1#rnd.random()
# Create magnetic distribution:
magnitude = mc.create_mag_dist_comb(mag_shape_list, phi_list, magnitude_list)
mag_data = MagData(res, magnitude)
mag_data.quiver_plot()
mag_data.save_to_llg('../output/mag_dist_random_pixels.txt')
projection = pj.simple_axis_projection(mag_data)
phase_map = PhaseMap(res, pm.phase_mag_real(res, projection, 'slab'))
hi.display(hi.holo_image(phase_map, 10))
if __name__ == "__main__":
try:
create_random_pixels()
except:
type, value, tb = sys.exc_info()
traceback.print_exc()
pdb.post_mortem(tb)
\ No newline at end of file
scripts/create_random_slabs.py deleted 100644 → 0
View file @ 7d656100
# -*- coding: utf-8 -*-
"""Create random magnetic distributions."""
import random as rnd
import pdb, traceback, sys
import numpy as np
from numpy import pi
import pyramid.magcreator as mc
from pyramid.magdata import MagData
import pyramid.phasemapper as pm
import pyramid.projector as pj
import pyramid.holoimage as hi
from pyramid.phasemap import PhaseMap
def create_random_slabs():
'''Calculate, display and save a random magnetic distribution to file.
Arguments:
None
Returns:
None
'''
# Input parameters:
count = 10
dim = (1, 128, 128)
res = 10 # in nm
rnd.seed(42)
w_max = 10
# Create lists for magnetic objects:
mag_shape_list = np.zeros((count,) + dim)
phi_list = np.zeros(count)
magnitude_list = np.zeros(count)
for i in range(count):
width = (1, rnd.randint(1, w_max), rnd.randint(1, w_max))
center = (rnd.randrange(int(width[0]/2), dim[0]-int(width[0]/2)),
rnd.randrange(int(width[1]/2), dim[1]-int(width[1]/2)),
rnd.randrange(int(width[2]/2), dim[2]-int(width[2]/2)))
mag_shape_list[i,...] = mc.Shapes.slab(dim, center, width)
phi_list[i] = 2*pi*rnd.random()
magnitude_list[i] = 1#rnd.random()
# Create magnetic distribution:
magnitude = mc.create_mag_dist_comb(mag_shape_list, phi_list, magnitude_list)
mag_data = MagData(res, magnitude)
mag_data.quiver_plot()
mag_data.save_to_llg('../output/mag_dist_random_slabs.txt')
projection = pj.simple_axis_projection(mag_data)
phase_map = PhaseMap(res, pm.phase_mag_real(res, projection, 'slab'))
hi.display(hi.holo_image(phase_map, 10))
if __name__ == "__main__":
try:
create_random_slabs()
except:
type, value, tb = sys.exc_info()
traceback.print_exc()
pdb.post_mortem(tb)
\ No newline at end of file
scripts/create_sample.py deleted 100644 → 0
View file @ 7d656100
# -*- coding: utf-8 -*-
"""Create magnetic distributions with simple geometries."""
import pdb, traceback, sys
from numpy import pi
import pyramid.magcreator as mc
from pyramid.magdata import MagData
def create_sample():
'''Calculate, display and save simple magnetic distributions to file.
Arguments:
None
Returns:
None
'''
# Input parameters:
key = 'slab'
filename = '../output/mag_dist_' + key + '.txt'
dim = (1, 128, 128) # in px (z, y, x)
res = 10.0 # in nm
phi = pi/4
# Geometry parameters:
center = (0, 64, 64) # in px (z, y, x), index starts with 0!
width = (1, 50, 50) # in px (z, y, x)
radius = 25 # in px
height = 1 # in px
pos = (0, 63) # in px (tuple of length 2)
pixel = (0, 63, 63) # in px (z, y, x), index starts with 0!
# Determine the magnetic shape:
if key == 'slab':
mag_shape = mc.Shapes.slab(dim, center, width)
elif key == 'disc':
mag_shape = mc.Shapes.disc(dim, center, radius, height)
elif key == 'sphere':
mag_shape = mc.Shapes.sphere(dim, center, radius)
elif key == 'filament':
mag_shape = mc.Shapes.filament(dim, pos)
elif key == 'pixel':
mag_shape = mc.Shapes.pixel(dim, pixel)
# Create magnetic distribution
magnitude = mc.create_mag_dist(mag_shape, phi)
mag_data = MagData(res, magnitude)
mag_data.quiver_plot()
mag_data.save_to_llg(filename)
if __name__ == "__main__":
try:
create_sample()
except:
type, value, tb = sys.exc_info()
traceback.print_exc()
pdb.post_mortem(tb)
\ No newline at end of file
scripts/create_vortex.py deleted 100644 → 0
View file @ 7d656100
# -*- coding: utf-8 -*-
"""Create the Pyramid-Logo."""
import pdb, traceback, sys
import numpy as np
from numpy import pi
import matplotlib.pyplot as plt
import pyramid.magcreator as mc
import pyramid.projector as pj
import pyramid.phasemapper as pm
import pyramid.holoimage as hi
from pyramid.magdata import MagData
from pyramid.phasemap import PhaseMap
def create_vortex():
'''Calculate and display the Pyramid-Logo.
Arguments:
None
Returns:
None
'''
# Input parameters:
filename = '../output/mag_dist_vortex.txt'
res = 10.0 # in nm
density = 1
dim = (1, 128, 128)
center = (0, int(dim[1]/2)-0.5, int(dim[2]/2)-0.5)
radius = 0.25 * dim[1]
height = 1
# Create magnetic shape:
mag_shape = mc.Shapes.disc(dim, center, radius, height)
mag_data = MagData(res, mc.create_mag_dist_vortex(mag_shape))
mag_data.quiver_plot()
mag_data.quiver_plot3d()
mag_data.save_to_llg(filename)
projection = pj.simple_axis_projection(mag_data)
phase_map = PhaseMap(res, pm.phase_mag_real(res, projection, 'slab'))
hi.display_combined(phase_map, density, 'Vortex State')
phase_slice = phase_map.phase[dim[1]/2, :]
fig = plt.figure()
fig.add_subplot(111)
plt.plot(range(dim[1]), phase_slice)
if __name__ == "__main__":
try:
create_vortex()
except:
type, value, tb = sys.exc_info()
traceback.print_exc()
pdb.post_mortem(tb)
\ No newline at end of file
scripts/get_jacobi.py deleted 100644 → 0
View file @ 7d656100
# -*- coding: utf-8 -*-
"""
Created on Wed Apr 03 11:15:38 2013
@author: Jan
"""
import numpy as np
import pyramid.magcreator as mc
import pyramid.projector as pj
import pyramid.phasemapper as pm
from pyramid.magdata import MagData
from pyramid.phasemap import PhaseMap
import time
import pdb, traceback, sys
from numpy import pi
def get_jacobi():
'''Calculate and display the phase map from a given magnetization.
Arguments:
None
Returns:
None
'''
# TODO: Input via GUI
b_0 = 1.0 # in T
dim = (1, 3, 3) # in px (y,x)
res = 10.0 # in nm
phi = pi/4
center = (0, 1, 1) # in px (y,x) index starts with 0!
width = (0, 1, 1) # in px (y,x)
mag_data = MagData(res, mc.create_mag_dist(mc.Shapes.slab(dim, center, width), phi))
projection = pj.simple_axis_projection(mag_data)
'''NUMERICAL SOLUTION'''
# numerical solution Real Space (Slab):
jacobi = np.zeros((dim[2]*dim[1], 2*dim[2]*dim[1]))
tic = time.clock()
phase_map = PhaseMap(res, pm.phase_mag_real(res, projection, 'slab', b_0, jacobi=jacobi))
toc = time.clock()
phase_map.display()
np.savetxt('../output/jacobi.npy', jacobi)
print 'Time for Real Space Approach with Jacobi-Matrix (Slab): ' + str(toc - tic)
return jacobi
if __name__ == "__main__":
try:
jacobi = get_jacobi()
except:
type, value, tb = sys.exc_info()
traceback.print_exc()
pdb.post_mortem(tb)
\ No newline at end of file
scripts/gui/__init__.py deleted 100644 → 0
View file @ 7d656100
# -*- coding: utf-8 -*-
"""
Created on Tue May 21 14:29:25 2013
@author: Jan
"""
scripts/gui/create_logo.py deleted 100644 → 0
View file @ 7d656100
# -*- coding: utf-8 -*-
# Form implementation generated from reading ui file 'create_logo.ui'
#
# Created: Tue May 21 14:29:03 2013
# by: PyQt4 UI code generator 4.9.5
#
# WARNING! All changes made in this file will be lost!
from PyQt4 import QtCore, QtGui
try:
_fromUtf8 = QtCore.QString.fromUtf8
except AttributeError:
_fromUtf8 = lambda s: s
class Ui_CreateLogoWidget(object):
def setupUi(self, CreateLogoWidget):
CreateLogoWidget.setObjectName(_fromUtf8("CreateLogoWidget"))
CreateLogoWidget.resize(520, 492)
self.verticalLayout_2 = QtGui.QVBoxLayout(CreateLogoWidget)
self.verticalLayout_2.setObjectName(_fromUtf8("verticalLayout_2"))
self.verticalLayout = QtGui.QVBoxLayout()
self.verticalLayout.setObjectName(_fromUtf8("verticalLayout"))
self.horizontalLayout = QtGui.QHBoxLayout()
self.horizontalLayout.setObjectName(_fromUtf8("horizontalLayout"))
self.xLabel = QtGui.QLabel(CreateLogoWidget)
self.xLabel.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.xLabel.setObjectName(_fromUtf8("xLabel"))
self.horizontalLayout.addWidget(self.xLabel)
self.xSpinBox = QtGui.QSpinBox(CreateLogoWidget)
self.xSpinBox.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.xSpinBox.setMaximum(512)
self.xSpinBox.setProperty("value", 128)
self.xSpinBox.setObjectName(_fromUtf8("xSpinBox"))
self.horizontalLayout.addWidget(self.xSpinBox)
self.yLabel = QtGui.QLabel(CreateLogoWidget)
self.yLabel.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.yLabel.setObjectName(_fromUtf8("yLabel"))
self.horizontalLayout.addWidget(self.yLabel)
self.ySpinBox = QtGui.QSpinBox(CreateLogoWidget)
self.ySpinBox.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.ySpinBox.setMaximum(512)
self.ySpinBox.setProperty("value", 128)
self.ySpinBox.setObjectName(_fromUtf8("ySpinBox"))
self.horizontalLayout.addWidget(self.ySpinBox)
self.logoPushButton = QtGui.QPushButton(CreateLogoWidget)
self.logoPushButton.setObjectName(_fromUtf8("logoPushButton"))
self.horizontalLayout.addWidget(self.logoPushButton)
self.verticalLayout.addLayout(self.horizontalLayout)
self.verticalLayout_2.addLayout(self.verticalLayout)
self.mplWidget = MatplotlibWidget(CreateLogoWidget)
self.mplWidget.setCursor(QtGui.QCursor(QtCore.Qt.ArrowCursor))
self.mplWidget.setLayoutDirection(QtCore.Qt.LeftToRight)
self.mplWidget.setAutoFillBackground(False)
self.mplWidget.setObjectName(_fromUtf8("mplWidget"))
self.verticalLayout_2.addWidget(self.mplWidget)
self.retranslateUi(CreateLogoWidget)
QtCore.QMetaObject.connectSlotsByName(CreateLogoWidget)
def retranslateUi(self, CreateLogoWidget):
CreateLogoWidget.setWindowTitle(QtGui.QApplication.translate("CreateLogoWidget", "Form", None, QtGui.QApplication.UnicodeUTF8))
self.xLabel.setText(QtGui.QApplication.translate("CreateLogoWidget", "X [px] :", None, QtGui.QApplication.UnicodeUTF8))
self.yLabel.setText(QtGui.QApplication.translate("CreateLogoWidget", "Y [px] :", None, QtGui.QApplication.UnicodeUTF8))
self.logoPushButton.setText(QtGui.QApplication.translate("CreateLogoWidget", "Create Logo", None, QtGui.QApplication.UnicodeUTF8))
from matplotlibwidget import MatplotlibWidget
scripts/gui/create_logo.ui deleted 100644 → 0
View file @ 7d656100
<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
<class>CreateLogoWidget</class>
<widget class="QWidget" name="CreateLogoWidget">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
<width>520</width>
<height>492</height>
</rect>
</property>
<property name="windowTitle">
<string>Create Pyramid Logo</string>
</property>
<layout class="QVBoxLayout" name="verticalLayout_2">
<item>
<layout class="QVBoxLayout" name="verticalLayout">
<item>
<layout class="QHBoxLayout" name="horizontalLayout">
<item>
<widget class="QLabel" name="xLabel">
<property name="text">
<string>X [px] :</string>
</property>
<property name="alignment">
<set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
</property>
</widget>
</item>
<item>
<widget class="QSpinBox" name="xSpinBox">
<property name="alignment">
<set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
</property>
<property name="maximum">
<number>512</number>
</property>
<property name="value">
<number>128</number>
</property>
</widget>
</item>
<item>
<widget class="QLabel" name="yLabel">
<property name="text">
<string>Y [px] :</string>
</property>
<property name="alignment">
<set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
</property>
</widget>
</item>
<item>
<widget class="QSpinBox" name="ySpinBox">
<property name="alignment">
<set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
</property>
<property name="maximum">
<number>512</number>
</property>
<property name="value">
<number>128</number>
</property>
</widget>
</item>
<item>
<widget class="QPushButton" name="logoPushButton">
<property name="text">
<string>Create Logo</string>
</property>
</widget>
</item>
</layout>
</item>
</layout>
</item>
<item>
<widget class="MatplotlibWidget" name="mplWidget">
<property name="cursor">
<cursorShape>ArrowCursor</cursorShape>
</property>
<property name="layoutDirection">
<enum>Qt::LeftToRight</enum>
</property>
<property name="autoFillBackground">
<bool>false</bool>
</property>
</widget>
</item>
</layout>
</widget>
<customwidgets>
<customwidget>
<class>MatplotlibWidget</class>
<extends>QWidget</extends>
<header>matplotlibwidget</header>
</customwidget>
</customwidgets>
<resources/>
<connections/>
</ui>
scripts/gui_create_logo.py deleted 100644 → 0
View file @ 7d656100
# -*- coding: utf-8 -*-
"""Create the Pyramid-Logo via GUI-Input."""
import sys
import numpy as np
from numpy import pi
from PyQt4 import QtCore, QtGui, uic
import pyramid.magcreator as mc
import pyramid.projector as pj
import pyramid.phasemapper as pm
import pyramid.holoimage as hi
from pyramid.magdata import MagData
from pyramid.phasemap import PhaseMap
from gui.create_logo import Ui_CreateLogoWidget
class Overlay(QtGui.QWidget):
def __init__(self, parent = None):
QtGui.QWidget.__init__(self, parent)
palette = QtGui.QPalette(self.palette())
palette.setColor(palette.Background, QtCore.Qt.transparent)
self.setPalette(palette)
def paintEvent(self, event):
painter = QtGui.QPainter()
painter.begin(self)
painter.setRenderHint(QtGui.QPainter.Antialiasing)
painter.fillRect(event.rect(), QtGui.QBrush(QtGui.QColor(255, 255, 255, 127)))
painter.setPen(QtGui.QPen(QtCore.Qt.NoPen))
for i in range(6):
if (self.counter / 5) % 6 == i:
painter.setBrush(QtGui.QBrush(QtGui.QColor(127, 127 + (self.counter % 5)*32, 127)))
else:
painter.setBrush(QtGui.QBrush(QtGui.QColor(127, 127, 127)))
painter.drawEllipse(
self.width()/2 + 30 * np.cos(2 * pi * i / 6.0) - 10,
self.height()/2 + 30 * np.sin(2 * pi * i / 6.0) - 10,
20, 20)
painter.end()
def showEvent(self, event):
self.timer = self.startTimer(50)
self.counter = 0
def hideEvent(self, event):
self.killTimer(self.timer)
def timerEvent(self, event):
self.counter += 1
self.update()
class CreateLogoWidget(QtGui.QWidget, Ui_CreateLogoWidget):
def __init__(self):
# Call parent constructor
QtGui.QWidget.__init__(self)
self.setupUi(self)
self.ui = uic.loadUi('gui/create_logo.ui')
# self.setCentralWidget(self.ui)
# Connect Widgets with locally defined functions:
self.connect(self.logoPushButton, QtCore.SIGNAL('clicked()'), self.buttonPushed)
# Create overlay to indicate busy state:
self.overlay = Overlay(self)
# self.ui.overlay = Overlay(self.ui)
self.overlay.hide()
# Show Widget:
self.show()
self.workerThread = WorkerThread()
def buttonPushed(self):
self.overlay.show()
x = self.xSpinBox.value()
y = self.ySpinBox.value()
create_logo((1, y, x), self.mplWidget.axes)
self.mplWidget.draw()
# self.workerThread.start()
self.overlay.hide()
def resizeEvent(self, event):
self.overlay.resize(event.size())
event.accept()
class WorkerThread(QtCore.QThread):
def __init__(self, parent=None):
QtCore.QThread.__init__(self)
def run(self):
x = self.xSpinBox.value()
y = self.ySpinBox.value()
create_logo((1, y, x), self.mplWidget.axes)
self.mplWidget.draw()
def create_logo(dim, axis):
'''Calculate and display the Pyramid-Logo.
Arguments:
None
Returns:
None
'''
# Input parameters:
res = 10.0 # in nm
phi = -pi/2 # in rad
density = 10
# Create magnetic shape:
mag_shape = np.zeros(dim)
x = range(dim[2])
y = range(dim[1])
xx, yy = np.meshgrid(x, y)
bottom = (yy >= 0.25*dim[1])
left = (yy <= 0.75/0.5 * dim[1]/dim[2] * xx)
right = np.fliplr(left)
mag_shape[0,...] = np.logical_and(np.logical_and(left, right), bottom)
# Create magnetic data, project it, get the phase map and display the holography image:
mag_data = MagData(res, mc.create_mag_dist(mag_shape, phi))
projection = pj.simple_axis_projection(mag_data)
phase_map = PhaseMap(res, pm.phase_mag_real(res, projection, 'slab'))
hi.display(hi.holo_image(phase_map, density), 'PYRAMID - LOGO', axis)
if __name__ == '__main__':
app = QtGui.QApplication(sys.argv)
gui = CreateLogoWidget()
sys.exit(app.exec_())
\ No newline at end of file
scripts/interactive_setup.py deleted 100644 → 0
View file @ 7d656100
# -*- coding: utf-8 -*-
"""Imports pyramid package and sets working directory to output directory"""
import pyramid.analytic as an
import pyramid.holoimage as hi
import pyramid.magcreator as mc
import pyramid.phasemapper as pm
import pyramid.projector as pj
import pyramid.reconstructor as rc
from pyramid.magdata import MagData
from pyramid.phasemap import PhaseMap
import os
os.chdir('C:\Users\Jan\PhD Thesis\Pyramid\output')
\ No newline at end of file
scripts/reconstruct_random_pixels.py deleted 100644 → 0
View file @ 7d656100
# -*- coding: utf-8 -*-
"""Create random magnetic distributions."""
import random as rnd
import pdb, traceback, sys
import numpy as np
from numpy import pi
import pyramid.magcreator as mc
from pyramid.magdata import MagData
import pyramid.phasemapper as pm
import pyramid.projector as pj
import pyramid.holoimage as hi
from pyramid.phasemap import PhaseMap
import pyramid.reconstructor as rc
def reconstruct_random_distribution():
'''Calculate and reconstruct a random magnetic distribution.
Arguments:
None
Returns:
None
'''
# Input parameters:
n_pixel = 5
dim = (1, 16, 16)
b_0 = 1 # in T
res = 10.0 # in nm
rnd.seed(18)
threshold = 0
# Create lists for magnetic objects:
mag_shape_list = np.zeros((n_pixel,) + dim)
phi_list = np.zeros(n_pixel)
magnitude_list = np.zeros(n_pixel)
for i in range(n_pixel):
pixel = (rnd.randrange(dim[0]), rnd.randrange(dim[1]), rnd.randrange(dim[2]))
mag_shape_list[i,...] = mc.Shapes.pixel(dim, pixel)
phi_list[i] = 2*pi*rnd.random()
magnitude_list[i] = rnd.random()
# Create magnetic distribution:
magnitude = mc.create_mag_dist_comb(mag_shape_list, phi_list, magnitude_list)
mag_data = MagData(res, magnitude)
mag_data.quiver_plot()
# Display phase map and holography image:
projection = pj.simple_axis_projection(mag_data)
phase_map = PhaseMap(res, pm.phase_mag_real(res, projection, 'slab', b_0))
hi.display_combined(phase_map, 10, 'Generated Distribution')
# Get the locations of the magnetized pixels (mask):
z_mag, y_mag, x_mag = mag_data.magnitude
z_mask = abs(z_mag) > threshold
x_mask = abs(x_mag) > threshold
y_mask = abs(y_mag) > threshold
mask = np.logical_or(np.logical_or(x_mask, y_mask), z_mask)
# Reconstruct the magnetic distribution:
mag_data_rec = rc.reconstruct_simple_leastsq(phase_map, mask, b_0)
# Display the reconstructed phase map and holography image:
projection_rec = pj.simple_axis_projection(mag_data_rec)
phase_map_rec = PhaseMap(res, pm.phase_mag_real(res, projection_rec, 'slab', b_0))
hi.display_combined(phase_map_rec, 10, 'Reconstructed Distribution')
if __name__ == "__main__":
try:
reconstruct_random_distribution()
except:
type, value, tb = sys.exc_info()
traceback.print_exc()
pdb.post_mortem(tb)
setup.cfg 0 → 100644
View file @ 6e3128b8
# -*- coding: utf-8 -*-
# setup.cfg
# :copyright: Copyright 2020 Jan Caron
# TODO: pip install .[io] is not working because hyperspy depends on trait which has no wheels on PyPI at the moment...
# TODO: See https://github.com/hyperspy/hyperspy/issues/2315 and https://github.com/enthought/traits/issues/357
# TODO: Add hyperspy back as soon (if?) this is resolved... Until then: install hyperspy with conda!
# TODO: mayavi has the same exact problem and tvtk is apparently also a problem...
# CONFIGURATION FOR TESTING:
[aliases]
test = pytest
[coverage:run]
branch = True
source = src/empyre
omit =
tests/*
[flake8]
max-line-length = 120
ignore =
# module import not at top of file
E402
# closing bracket does not match visual indentation
E124
# continuation line with same indent as next logical line
E125
# missing whitespace around arithmetic operator
E226
# line break before binary operator
W503
# line break after binary operator
W504
# do not use variables named ‘l’, ‘O’, or ‘I’
E741
per-file-ignores =
*/__init__.py: F401, F403, F405, F821
# F401: module imported but unused
# F403: 'from module import *' used; unable to detect undefined names
# F405: Name may be undefined, or defined from star imports: module
# F821: undefined name 'name'
setup.py deleted 100644 → 0
View file @ 7d656100
# -*- coding: utf-8 -*-
"""
Created on Fri May 03 10:27:04 2013
@author: Jan
"""
#call with: python setup.py build_ext --inplace --compiler=mingw32
import os
import glob
from distutils.core import setup
from Cython.Build import cythonize
setup(
name = 'Pyramid',
version = '0.1',
description = 'PYthon based Reconstruction Algorithm for MagnetIc Distributions',
author = 'Jan Caron',
author_email = 'j.caron@fz-juelich.de',
packages = ['pyramid', 'pyramid.numcore'],
ext_modules = cythonize(glob.glob(os.path.join('pyramid', 'numcore', '*.pyx')))
)
src/empyre/__init__.py 0 → 100644
View file @ 6e3128b8
# -*- coding: utf-8 -*-
# Copyright 2020 by Forschungszentrum Juelich GmbH
# Author: J. Caron
#
"""Subpackage containing functionality for visualisation of multidimensional fields."""
from . import fields
from . import io
from . import models
from . import reconstruct
from . import vis
from . import utils
__version__ = "0.3.4"
__git_revision__ = "undefined"
import logging
_log = logging.getLogger(__name__)
_log.info(f'Imported EMPyRe V-{__version__}')
del logging
__all__ = ['fields', 'io', 'models', 'reconstruct', 'vis', 'utils']
src/empyre/fields/__init__.py 0 → 100644
View file @ 6e3128b8
# -*- coding: utf-8 -*-
# Copyright 2020 by Forschungszentrum Juelich GmbH
# Author: J. Caron
#
"""Subpackage containing container classes for multidimensional fields and ways to create them."""
from .field import *
from .shapes import *
from .vectors import *
__all__ = []
__all__.extend(field.__all__)
__all__.extend(shapes.__all__)
__all__.extend(vectors.__all__)
del field
del shapes
del vectors