sas.qtgui.Perspectives.ParticleEditor package

Subpackages

Submodules

sas.qtgui.Perspectives.ParticleEditor.AngularSamplingMethodSelector module

class sas.qtgui.Perspectives.ParticleEditor.AngularSamplingMethodSelector.AngularSamplingMethodSelector(parent=None)

Bases: QWidget

Selects the method for doing angular sampling, and provides access to the parameters

__annotate_func__ = None
__annotations_cache__ = {}
__doc__ = 'Selects the method for doing angular sampling, and provides access to the parameters '
__firstlineno__ = 51
__init__(parent=None)
__module__ = 'sas.qtgui.Perspectives.ParticleEditor.AngularSamplingMethodSelector'
__static_attributes__ = ('combo', 'entry_widgets', 'subwidget_layout')
generate_sampler() → AngularDistribution

Create the angular distribution sampler spectified by the current settings

on_update()
staticMetaObject = PySide6.QtCore.QMetaObject("AngularSamplingMethodSelector" inherits "QWidget": )
class sas.qtgui.Perspectives.ParticleEditor.AngularSamplingMethodSelector.ParametersForm(sampling_class: type, parent=None)

Bases: QWidget

Form that displays the parameters associated with the class (also responsible for generating the sampler)

__annotate_func__ = None
__annotations_cache__ = {}
__doc__ = 'Form that displays the parameters associated with the class (also responsible for generating the sampler)'
__firstlineno__ = 10
__init__(sampling_class: type, parent=None)
__module__ = 'sas.qtgui.Perspectives.ParticleEditor.AngularSamplingMethodSelector'
__static_attributes__ = ('layout', 'parameter_callbacks', 'sampling_class')
generate_sampler() → AngularDistribution

Generate a sampler based on the selected parameters

staticMetaObject = PySide6.QtCore.QMetaObject("ParametersForm" inherits "QWidget": )
sas.qtgui.Perspectives.ParticleEditor.AngularSamplingMethodSelector.main()

Show a demo

sas.qtgui.Perspectives.ParticleEditor.CodeToolBar module

class sas.qtgui.Perspectives.ParticleEditor.CodeToolBar.CodeToolBar(parent=None)

Bases: QWidget, Ui_CodeToolBar

__annotate_func__ = None
__annotations_cache__ = {}
__doc__ = None
__firstlineno__ = 7
__init__(parent=None)
__module__ = 'sas.qtgui.Perspectives.ParticleEditor.CodeToolBar'
__static_attributes__ = ()
staticMetaObject = PySide6.QtCore.QMetaObject("CodeToolBar" inherits "QWidget": )

sas.qtgui.Perspectives.ParticleEditor.DesignWindow module

class sas.qtgui.Perspectives.ParticleEditor.DesignWindow.DesignWindow(parent=None)

Bases: QDialog, Ui_DesignWindow

Main window for the particle editor

__annotate_func__ = None
__annotations_cache__ = {'last_calculation_n_q': 'int', 'last_calculation_n_r': 'int', 'last_calculation_time': 'float | None', 'magnetism_coordinate_mapping': 'np.ndarray | None', 'magnetism_function': 'np.ndarray | None', 'sld_coordinate_mapping': 'CoordinateSystemTransform | None', 'sld_function': 'SLDFunction | None'}
__doc__ = 'Main window for the particle editor'
__firstlineno__ = 47
__init__(parent=None)
__module__ = 'sas.qtgui.Perspectives.ParticleEditor.DesignWindow'
__static_attributes__ = ('_parameterTableModel', 'angularSamplingMethodSelector', 'codeToolBar', 'functionViewer', 'last_calculation_n_q', 'last_calculation_n_r', 'last_calculation_time', 'magnetism_coordinate_mapping', 'magnetism_function', 'methodComboOptions', 'outputCanvas', 'outputViewer', 'parameterTabButtons', 'parametersTable', 'parent', 'pythonViewer', 'sld_coordinate_mapping', 'sld_function')
angularDistribution() → AngularDistribution

Get the AngularDistribution object that represents the GUI selected orientational distribution

codeError(text)

Show an error concerning input code

codeText(text)

Show info about input code / code stdout

codeWarning(text)

Show a warning about input code

currentSeed()
display_calculation_result(scattering_result: ScatteringOutput)

Update graphs and select tab

doBuild()

Build functionality requested

doScatter()

Scatter functionality requested

magnetismDefinition() → MagnetismDefinition | None
onFit()

Fit functionality requested

onLoad()
onRadiusChanged()
onSave()
onTimeEstimateParametersChanged()

Called when the number of samples changes

parametersForCalculation() → CalculationParameters
particleDefinition() → ParticleDefinition

Get the ParticleDefinition object that contains the SLD and magnetism functions

polarisationVector() → ndarray

Get a numpy vector representing the GUI specified polarisation vector

qSampling() → QSample

Calculate the q sampling object based on current gui settings

scatteringCalculation() → ScatteringCalculation

Get the ScatteringCalculation object that represents the calculation that is to be passed to the solver

sldDefinition() → SLDDefinition
spatialSampling() → SpatialDistribution

Calculate the spatial sampling object based on current gui settings

staticMetaObject = PySide6.QtCore.QMetaObject("DesignWindow" inherits "QDialog": )
sas.qtgui.Perspectives.ParticleEditor.DesignWindow.main()

Demo/testing window

sas.qtgui.Perspectives.ParticleEditor.DesignWindow.safe_float(text: str)

sas.qtgui.Perspectives.ParticleEditor.FunctionViewer module

class sas.qtgui.Perspectives.ParticleEditor.FunctionViewer.FunctionViewer(parent=None)

Bases: QWidget

__annotate_func__ = None
__annotations_cache__ = {}
__doc__ = None
__firstlineno__ = 62
__init__(parent=None)
__module__ = 'sas.qtgui.Perspectives.ParticleEditor.FunctionViewer'
__static_attributes__ = ('_graphics_viewer_offset', '_size_px', 'alpha', 'beta', 'coordinate_mapping', 'dPhidY', 'dThetadX', 'densityPixmapItem', 'densityScene', 'densityViewer', 'depth_slider', 'function', 'lastMouseX', 'lastMouseY', 'layer_size', 'mag_buttons', 'mag_phi', 'mag_phi_slider', 'mag_theta', 'mag_theta_slider', 'n_draw_layers', 'normal_offset', 'plane_buttons', 'radius', 'radius_control', 'sld_magnetism_option', 'slicePixmapItem', 'sliceScene', 'sliceViewer', 'upscale')
drawAxes(im)

Draw a small xyz axis on an image

drawScale(im)

Draw a scalebar

eventFilter(source, event)

Event filter intercept, grabs mouse drags on the images

onDepthChanged()

Callback for cross section depth slider

onDisplayTypeSelected()

Switch between SLD and magnetism view

onMagPhiChanged()

Magnetic field phi angle changed

onMagThetaChanged()

Magnetic field theta angle changed

onRadiusChanged()

Draw radius changed

setAngles(alpha_deg, beta_deg)

Set the viewer angles

setSLDFunction(fun, coordinate_mapping)

Set the function to be plotted

staticMetaObject = PySide6.QtCore.QMetaObject("FunctionViewer" inherits "QWidget": )
updateImage(mag_only=True)

Update the images in the viewer

sas.qtgui.Perspectives.ParticleEditor.FunctionViewer.cross_section_coordinates(radius: float, alpha: float, beta: float, plane_distance: float, n_points: int)
sas.qtgui.Perspectives.ParticleEditor.FunctionViewer.draw_line_in_place(im, x0, y0, dx, dy, channel)

Simple line drawing (otherwise need to import something heavyweight)

sas.qtgui.Perspectives.ParticleEditor.FunctionViewer.main()

Show a demo of the function viewer

sas.qtgui.Perspectives.ParticleEditor.FunctionViewer.rotation_matrix(alpha: float, beta: float)

sas.qtgui.Perspectives.ParticleEditor.GeodesicSampleSelector module

class sas.qtgui.Perspectives.ParticleEditor.GeodesicSampleSelector.GeodesicSamplingSpinBox(parent: QWidget | None = None)

Bases: QSpinBox

SpinBox that only takes values that corresponds to the number of vertices on a geodesic sphere

__annotate_func__ = None
__annotations_cache__ = {}
__doc__ = 'SpinBox that only takes values that corresponds to the number of vertices on a geodesic sphere '
__firstlineno__ = 7
__init__(parent: QWidget | None = None)
__module__ = 'sas.qtgui.Perspectives.ParticleEditor.GeodesicSampleSelector'
__static_attributes__ = ('n_divisions',)
getNDivisions()
onEditingFinished()
staticMetaObject = PySide6.QtCore.QMetaObject("GeodesicSamplingSpinBox" inherits "QSpinBox": )
stepBy(steps: int)
updateDisplayValue()
sas.qtgui.Perspectives.ParticleEditor.GeodesicSampleSelector.main()

Show a demo of the spinner

sas.qtgui.Perspectives.ParticleEditor.LabelledSlider module

class sas.qtgui.Perspectives.ParticleEditor.LabelledSlider.LabelledSlider(name: str, min_value: int, max_value: int, value: int, tick_interval: int = 10, name_width=10, value_width=30, value_units='°')

Bases: QWidget

Slider with labels and value text

__annotate_func__ = None
__annotations_cache__ = {}
__doc__ = 'Slider with labels and value text'
__firstlineno__ = 5
__init__(name: str, min_value: int, max_value: int, value: int, tick_interval: int = 10, name_width=10, value_width=30, value_units='°')
__module__ = 'sas.qtgui.Perspectives.ParticleEditor.LabelledSlider'
__static_attributes__ = ('name_label', 'slider', 'units', 'value_label')
_on_value_changed()
staticMetaObject = PySide6.QtCore.QMetaObject("LabelledSlider" inherits "QWidget": )
value() → int
property valueChanged

sas.qtgui.Perspectives.ParticleEditor.OutputViewer module

class sas.qtgui.Perspectives.ParticleEditor.OutputViewer.OutputViewer(parent=None)

Bases: QTextEdit

Python text editor window

__annotate_func__ = None
__annotations_cache__ = {}
__doc__ = 'Python text editor window'
__firstlineno__ = 9
__init__(parent=None)
__module__ = 'sas.qtgui.Perspectives.ParticleEditor.OutputViewer'
__static_attributes__ = ()
_htmlise(text)
addError(text)
addText(text)
addWarning(text)
appendAndMove(text)
keyPressEvent(e)

Itercepted key press event

reset()
staticMetaObject = PySide6.QtCore.QMetaObject("OutputViewer" inherits "QTextEdit": )
sas.qtgui.Perspectives.ParticleEditor.OutputViewer.main()

sas.qtgui.Perspectives.ParticleEditor.PythonViewer module

class sas.qtgui.Perspectives.ParticleEditor.PythonViewer.PythonViewer(parent=None)

Bases: QTextEdit

Python text editor window

__annotate_func__ = None
__annotations_cache__ = {}
__doc__ = 'Python text editor window'
__firstlineno__ = 10
__init__(parent=None)
__module__ = 'sas.qtgui.Perspectives.ParticleEditor.PythonViewer'
__static_attributes__ = ('code_highlighter',)
build_trigger
insertFromMimeData(source)

Keep own highlighting

keyPressEvent(e)

Itercepted key press event

staticMetaObject = PySide6.QtCore.QMetaObject("PythonViewer" inherits "QTextEdit": Methods:   #73 type=Signal, signature=build_trigger() )
sas.qtgui.Perspectives.ParticleEditor.PythonViewer.main()

Demo/testing window

sas.qtgui.Perspectives.ParticleEditor.RadiusSelection module

class sas.qtgui.Perspectives.ParticleEditor.RadiusSelection.RadiusSelection(text: str | None = None, parent=None)

Bases: QWidget, Ui_RadiusSelection

__annotate_func__ = None
__annotations_cache__ = {}
__doc__ = None
__firstlineno__ = 7
__init__(text: str | None = None, parent=None)
__module__ = 'sas.qtgui.Perspectives.ParticleEditor.RadiusSelection'
__static_attributes__ = ()
radius()
staticMetaObject = PySide6.QtCore.QMetaObject("RadiusSelection" inherits "QWidget": )

sas.qtgui.Perspectives.ParticleEditor.SLDMagnetismOption module

class sas.qtgui.Perspectives.ParticleEditor.SLDMagnetismOption.SLDMagnetismOption(parent=None)

Bases: QWidget, Ui_SLDMagnetismOption

__annotate_func__ = None
__annotations_cache__ = {}
__doc__ = None
__firstlineno__ = 6
__init__(parent=None)
__module__ = 'sas.qtgui.Perspectives.ParticleEditor.SLDMagnetismOption'
__static_attributes__ = ()
staticMetaObject = PySide6.QtCore.QMetaObject("SLDMagnetismOption" inherits "QWidget": )

sas.qtgui.Perspectives.ParticleEditor.ViewerButtons module

class sas.qtgui.Perspectives.ParticleEditor.ViewerButtons.AxisButtons(set_angles_function: Callable[[float, float], None])

Bases: QWidget, Ui_AxisSelection

X, Y, Z axis selection buttons, sets angles

__annotate_func__ = None
__annotations_cache__ = {}
__doc__ = 'X, Y, Z axis selection buttons, sets angles '
__firstlineno__ = 28
__init__(set_angles_function: Callable[[float, float], None])
__module__ = 'sas.qtgui.Perspectives.ParticleEditor.ViewerButtons'
__static_attributes__ = ('setAngles',)
staticMetaObject = PySide6.QtCore.QMetaObject("AxisButtons" inherits "QWidget": )
class sas.qtgui.Perspectives.ParticleEditor.ViewerButtons.PlaneButtons(set_angles_function: Callable[[float, float], None])

Bases: QWidget, Ui_PlaneSelection

XY, XZ, YZ plane selection buttons, sets angles

__annotate_func__ = None
__annotations_cache__ = {}
__doc__ = 'XY, XZ, YZ plane selection buttons, sets angles '
__firstlineno__ = 13
__init__(set_angles_function: Callable[[float, float], None])
__module__ = 'sas.qtgui.Perspectives.ParticleEditor.ViewerButtons'
__static_attributes__ = ('setAngles',)
staticMetaObject = PySide6.QtCore.QMetaObject("PlaneButtons" inherits "QWidget": )

sas.qtgui.Perspectives.ParticleEditor.defaults module

sas.qtgui.Perspectives.ParticleEditor.defaults.default_text = '"""\n\nHere\'s a new perspective. It calculates the scattering based on real-space description of a particle.\n\nBasically, define your SLD as a function of either cartesian or polar coordinates and click scatter\n\n  def sld(x,y,z)\n  def sld(r,theta,phi)\n\nThe display on the right shows your particle, both as a total projected density (top) and as a slice (bottom).\n\nThis is a minimal working system. Currently magnetism doesn\'t work, neither do extra parameters for your functions,\nnor structure factors, nor fitting, nor 2D plots.\n\nHere\'s a simple example: """\n\ndef sld_cube(x,y,z):\n    """ A cube with 100Ang side length"""\n\n    return rect(0.02*x)*rect(0.02*y)*rect(0.02*z)\n\n\ndef sld_sphere(r, theta, phi):\n    """ Sphere r=50Ang"""\n\n    return rect(0.02*r)\n\nsld = sld_sphere\n\n'

Press shift-return to build and update views Click scatter to show the scattering profile

sas.qtgui.Perspectives.ParticleEditor.defaults.sld(r, theta, phi)

sas.qtgui.Perspectives.ParticleEditor.function_processor module

exception sas.qtgui.Perspectives.ParticleEditor.function_processor.FunctionDefinitionFailed(*args)

Bases: Exception

__annotate_func__ = None
__annotations_cache__ = {}
__doc__ = None
__firstlineno__ = 12
__init__(*args)
__module__ = 'sas.qtgui.Perspectives.ParticleEditor.function_processor'
__static_attributes__ = ()
__weakref__

list of weak references to the object

sas.qtgui.Perspectives.ParticleEditor.function_processor.cartesian_converter(x, y, z)

Converter from calculation coordinates to function definition

For functions specified in cartesian coordinates

sas.qtgui.Perspectives.ParticleEditor.function_processor.default_callback(string: str)

Just for default

sas.qtgui.Perspectives.ParticleEditor.function_processor.main()
sas.qtgui.Perspectives.ParticleEditor.function_processor.process_code(input_text: str, solvent_sld: float = 0.0, text_callback: ~collections.abc.Callable[[str], None] = <function default_callback>, warning_callback: ~collections.abc.Callable[[str], None] = <function default_callback>, error_callback: ~collections.abc.Callable[[str], None] = <function default_callback>)

Process the code for generating functions that specify sld/magnetism

sas.qtgui.Perspectives.ParticleEditor.function_processor.spherical_converter(x, y, z)

Converter from calculation coordinates to function definition

For functions specified in spherical coordinates

sas.qtgui.Perspectives.ParticleEditor.helper_functions module

Functions that get automatically included in the build window

sas.qtgui.Perspectives.ParticleEditor.helper_functions.rect(x: ndarray)

Rectangle function, zero if mod(input) > 1, 1 otherwise

sas.qtgui.Perspectives.ParticleEditor.helper_functions.step(x: ndarray)

Step function, 0 if input < 0, 1 if input >= 0

sas.qtgui.Perspectives.ParticleEditor.syntax_highlight module

Modified from: art1415926535/PyQt5-syntax-highlighting on github

It’s not great, should all really be implemented as a finite state machine with a stack

class sas.qtgui.Perspectives.ParticleEditor.syntax_highlight.PythonHighlighter(document)

Bases: QSyntaxHighlighter

Syntax highlighter for the Python language.

__annotate_func__ = None
__annotations_cache__ = {}
__doc__ = 'Syntax highlighter for the Python language.\n    '
__firstlineno__ = 50
__init__(document)
__module__ = 'sas.qtgui.Perspectives.ParticleEditor.syntax_highlight'
__static_attributes__ = ('rules', 'tri_double', 'tri_single')
braces = ['\\{', '\\}', '\\(', '\\)', '\\[', '\\]']
highlightBlock(text)

Apply syntax highlighting to the given block of text.

keywords = ['and', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'exec', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'not', 'or', 'pass', 'print', 'raise', 'return', 'try', 'while', 'yield', 'None', 'True', 'False']
operators = ['=', '==', '!=', '<', '<=', '>', '>=', '\\+', '-', '\\*', '/', '//', '\\%', '\\*\\*', '\\+=', '-=', '\\*=', '/=', '\\%=', '\\^', '\\|', '\\&', '\\~', '>>', '<<']
special = ['sld', 'solvent_sld', 'magnetism']
staticMetaObject = PySide6.QtCore.QMetaObject("PythonHighlighter" inherits "QSyntaxHighlighter": )
sas.qtgui.Perspectives.ParticleEditor.syntax_highlight.format(color, style='')

Return a QTextCharFormat with the given attributes.

sas.qtgui.Perspectives.ParticleEditor.util module

sas.qtgui.Perspectives.ParticleEditor.util.format_time_estimate(est_time_seconds)

Get easily understandable string for a computational time estimate

sas.qtgui.Perspectives.ParticleEditor.vectorise module

sas.qtgui.Perspectives.ParticleEditor.vectorise.clean_traceback(trace: str)

Tracebacks from vectorise contain potentially confusing information from the vectorisation infrastructure. Clean it up and replace empty filename with something else

sas.qtgui.Perspectives.ParticleEditor.vectorise.main()
sas.qtgui.Perspectives.ParticleEditor.vectorise.vectorise_magnetism(fun: Callable, warning_callback: Callable[[str], None], *args, **kwargs)

Check whether a magnetism function can handle numpy arrays properly, if not, create a wrapper that that can

sas.qtgui.Perspectives.ParticleEditor.vectorise.vectorise_sld(fun: Callable, warning_callback: Callable[[str], None], error_callback: Callable[[str], None], *args, **kwargs)

Check whether an SLD function can handle numpy arrays properly, if not, create a wrapper that that can

Module contents