sas.sascalc.shape2sas package

Subpackages

Submodules

sas.sascalc.shape2sas.ExperimentalScattering module

class sas.sascalc.shape2sas.ExperimentalScattering.IExperimental(q: ndarray, I0: ndarray, I: ndarray, exposure: float)

Bases: object

__dict__ = mappingproxy({'__module__': 'sas.sascalc.shape2sas.ExperimentalScattering', '__firstlineno__': 28, '__init__': <function IExperimental.__init__>, 'simulate_data': <function IExperimental.simulate_data>, 'save_Iexperimental': <function IExperimental.save_Iexperimental>, '__static_attributes__': ('I', 'I0', 'exposure', 'q'), '__dict__': <attribute '__dict__' of 'IExperimental' objects>, '__weakref__': <attribute '__weakref__' of 'IExperimental' objects>, '__doc__': None, '__annotations__': {}})
__doc__ = None
__firstlineno__ = 28
__init__(q: ndarray, I0: ndarray, I: ndarray, exposure: float)
__module__ = 'sas.sascalc.shape2sas.ExperimentalScattering'
__static_attributes__ = ('I', 'I0', 'exposure', 'q')
__weakref__

list of weak references to the object

save_Iexperimental(Isim: ndarray, sigma: ndarray, Model: str)
simulate_data() → tuple[ndarray, ndarray]

Simulate SAXS data using calculated scattering and empirical expression for sigma

input q,I : calculated scattering, normalized I0 : forward scattering #noise : relative noise (scales the simulated sigmas by a factor) exposure : exposure (in arbitrary units) - affects the noise level of data

output sigma : simulated noise Isim : simulated data

data is also written to a file

class sas.sascalc.shape2sas.ExperimentalScattering.SimulateScattering(q: ndarray, I0: ndarray, I: ndarray, exposure: float | None = <factory>)

Bases: object

Class containing parameters for simulating scattering

I: ndarray
I0: ndarray
__annotations__ = {'I': <class 'numpy.ndarray'>, 'I0': <class 'numpy.ndarray'>, 'exposure': float | None, 'q': <class 'numpy.ndarray'>}
__dataclass_fields__ = {'I': Field(name='I',type=<class 'numpy.ndarray'>,default=<dataclasses._MISSING_TYPE object>,default_factory=<dataclasses._MISSING_TYPE object>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD), 'I0': Field(name='I0',type=<class 'numpy.ndarray'>,default=<dataclasses._MISSING_TYPE object>,default_factory=<dataclasses._MISSING_TYPE object>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD), 'exposure': Field(name='exposure',type=float | None,default=<dataclasses._MISSING_TYPE object>,default_factory=<function SimulateScattering.<lambda>>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD), 'q': Field(name='q',type=<class 'numpy.ndarray'>,default=<dataclasses._MISSING_TYPE object>,default_factory=<dataclasses._MISSING_TYPE object>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD)}
__dataclass_params__ = _DataclassParams(init=True,repr=True,eq=True,order=False,unsafe_hash=False,frozen=False,match_args=True,kw_only=False,slots=False,weakref_slot=False)
__dict__ = mappingproxy({'__module__': 'sas.sascalc.shape2sas.ExperimentalScattering', '__firstlineno__': 8, '__annotations__': {'q': <class 'numpy.ndarray'>, 'I0': <class 'numpy.ndarray'>, 'I': <class 'numpy.ndarray'>, 'exposure': float | None}, '__doc__': 'Class containing parameters for\nsimulating scattering', '__static_attributes__': (), '__dict__': <attribute '__dict__' of 'SimulateScattering' objects>, '__weakref__': <attribute '__weakref__' of 'SimulateScattering' objects>, '__dataclass_params__': _DataclassParams(init=True,repr=True,eq=True,order=False,unsafe_hash=False,frozen=False,match_args=True,kw_only=False,slots=False,weakref_slot=False), '__dataclass_fields__': {'q': Field(name='q',type=<class 'numpy.ndarray'>,default=<dataclasses._MISSING_TYPE object>,default_factory=<dataclasses._MISSING_TYPE object>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD), 'I0': Field(name='I0',type=<class 'numpy.ndarray'>,default=<dataclasses._MISSING_TYPE object>,default_factory=<dataclasses._MISSING_TYPE object>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD), 'I': Field(name='I',type=<class 'numpy.ndarray'>,default=<dataclasses._MISSING_TYPE object>,default_factory=<dataclasses._MISSING_TYPE object>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD), 'exposure': Field(name='exposure',type=float | None,default=<dataclasses._MISSING_TYPE object>,default_factory=<function SimulateScattering.<lambda>>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD)}, '__replace__': <function _replace>, '__hash__': None, '__init__': <function SimulateScattering.__init__>, '__repr__': <function SimulateScattering.__repr__>, '__eq__': <function SimulateScattering.__eq__>, '__match_args__': ('q', 'I0', 'I', 'exposure')})
__doc__ = 'Class containing parameters for\nsimulating scattering'
__eq__(other)

Return self==value.

__firstlineno__ = 8
__hash__ = None
__init__(q: ndarray, I0: ndarray, I: ndarray, exposure: float | None = <factory>) → None
__match_args__ = ('q', 'I0', 'I', 'exposure')
__module__ = 'sas.sascalc.shape2sas.ExperimentalScattering'
__replace__(**changes)
__repr__()

Return repr(self).

__static_attributes__ = ()
__weakref__

list of weak references to the object

exposure: float | None
q: ndarray
class sas.sascalc.shape2sas.ExperimentalScattering.SimulatedScattering(I_sim: ndarray, q: ndarray, I_err: ndarray)

Bases: object

Class containing parameters for simulated scattering

I_err: ndarray
I_sim: ndarray
__annotations__ = {'I_err': <class 'numpy.ndarray'>, 'I_sim': <class 'numpy.ndarray'>, 'q': <class 'numpy.ndarray'>}
__dataclass_fields__ = {'I_err': Field(name='I_err',type=<class 'numpy.ndarray'>,default=<dataclasses._MISSING_TYPE object>,default_factory=<dataclasses._MISSING_TYPE object>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD), 'I_sim': Field(name='I_sim',type=<class 'numpy.ndarray'>,default=<dataclasses._MISSING_TYPE object>,default_factory=<dataclasses._MISSING_TYPE object>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD), 'q': Field(name='q',type=<class 'numpy.ndarray'>,default=<dataclasses._MISSING_TYPE object>,default_factory=<dataclasses._MISSING_TYPE object>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD)}
__dataclass_params__ = _DataclassParams(init=True,repr=True,eq=True,order=False,unsafe_hash=False,frozen=False,match_args=True,kw_only=False,slots=False,weakref_slot=False)
__dict__ = mappingproxy({'__module__': 'sas.sascalc.shape2sas.ExperimentalScattering', '__firstlineno__': 19, '__annotations__': {'I_sim': <class 'numpy.ndarray'>, 'q': <class 'numpy.ndarray'>, 'I_err': <class 'numpy.ndarray'>}, '__doc__': 'Class containing parameters for\nsimulated scattering', '__static_attributes__': (), '__dict__': <attribute '__dict__' of 'SimulatedScattering' objects>, '__weakref__': <attribute '__weakref__' of 'SimulatedScattering' objects>, '__dataclass_params__': _DataclassParams(init=True,repr=True,eq=True,order=False,unsafe_hash=False,frozen=False,match_args=True,kw_only=False,slots=False,weakref_slot=False), '__dataclass_fields__': {'I_sim': Field(name='I_sim',type=<class 'numpy.ndarray'>,default=<dataclasses._MISSING_TYPE object>,default_factory=<dataclasses._MISSING_TYPE object>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD), 'q': Field(name='q',type=<class 'numpy.ndarray'>,default=<dataclasses._MISSING_TYPE object>,default_factory=<dataclasses._MISSING_TYPE object>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD), 'I_err': Field(name='I_err',type=<class 'numpy.ndarray'>,default=<dataclasses._MISSING_TYPE object>,default_factory=<dataclasses._MISSING_TYPE object>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD)}, '__replace__': <function _replace>, '__hash__': None, '__init__': <function SimulatedScattering.__init__>, '__repr__': <function SimulatedScattering.__repr__>, '__eq__': <function SimulatedScattering.__eq__>, '__match_args__': ('I_sim', 'q', 'I_err')})
__doc__ = 'Class containing parameters for\nsimulated scattering'
__eq__(other)

Return self==value.

__firstlineno__ = 19
__hash__ = None
__init__(I_sim: ndarray, q: ndarray, I_err: ndarray) → None
__match_args__ = ('I_sim', 'q', 'I_err')
__module__ = 'sas.sascalc.shape2sas.ExperimentalScattering'
__replace__(**changes)
__repr__()

Return repr(self).

__static_attributes__ = ()
__weakref__

list of weak references to the object

q: ndarray
sas.sascalc.shape2sas.ExperimentalScattering.getSimulatedScattering(scalc: SimulateScattering) → SimulatedScattering

Simulate scattering for a given theoretical scattering.

sas.sascalc.shape2sas.HelperFunctions module

class sas.sascalc.shape2sas.HelperFunctions.Qsampling

Bases: object

__dict__ = mappingproxy({'__module__': 'sas.sascalc.shape2sas.HelperFunctions', '__firstlineno__': 6, 'onQsampling': <staticmethod(<function Qsampling.onQsampling>)>, 'onUserSampledQ': <staticmethod(<function Qsampling.onUserSampledQ>)>, 'qMethodsNames': <staticmethod(<function Qsampling.qMethodsNames>)>, 'qMethodsInput': <staticmethod(<function Qsampling.qMethodsInput>)>, '__static_attributes__': (), '__dict__': <attribute '__dict__' of 'Qsampling' objects>, '__weakref__': <attribute '__weakref__' of 'Qsampling' objects>, '__doc__': None, '__annotations__': {}})
__doc__ = None
__firstlineno__ = 6
__module__ = 'sas.sascalc.shape2sas.HelperFunctions'
__static_attributes__ = ()
__weakref__

list of weak references to the object

static onQsampling(qmin: float, qmax: float, Nq: int) → ndarray

Returns uniform q sampling

static onUserSampledQ(q: ndarray) → ndarray

Returns user sampled q

static qMethodsInput(name: str)
static qMethodsNames(name: str)
sas.sascalc.shape2sas.HelperFunctions.check_unique(A_list: list[float]) → bool

if all elements in a list are unique then return True, else return False

sas.sascalc.shape2sas.HelperFunctions.euler_rotation_matrix(alpha: float, beta: float, gamma: float) → ndarray

Convert Euler angles to a rotation matrix, following the intrinsic ZYX convention.

sas.sascalc.shape2sas.HelperFunctions.generate_pdb(x_list: list[ndarray], y_list: list[ndarray], z_list: list[ndarray], p_list: list[ndarray], Model_list: list[str]) → None

Generates a visualisation file in PDB format with the simulated points (coordinates) and contrasts ONLY FOR VISUALIZATION! Each bead is represented as a dummy atom Carbon, C : positive contrast Hydrogen, H : zero contrast Oxygen, O : negateive contrast information of accurate contrasts not included, only sign IMPORTANT: IT WILL NOT GIVE THE CORRECT RESULTS IF SCATTERING IS CACLLUATED FROM THIS MODEL WITH E.G. CRYSOL, PEPSI-SAXS, FOXS, CAPP OR THE LIKE!

sas.sascalc.shape2sas.HelperFunctions.get_max_dimension(x_list: ndarray, y_list: ndarray, z_list: ndarray) → float

find max dimensions of n models used for determining plot limits

sas.sascalc.shape2sas.HelperFunctions.plot_2D(x_list: ndarray, y_list: ndarray, z_list: ndarray, p_list: ndarray, Models: ndarray, high_res: bool) → None

plot 2D-projections of generated points (shapes) using matplotlib: positive contrast in red (Model 1) or blue (Model 2) or yellow (Model 3) or green (Model 4) zero contrast in grey negative contrast in black

input (x_list,y_list,z_list) : coordinates of simulated points p_list : excess scattering length densities (contrast) of simulated points Model : Model number

output plot : points<Model>.png

sas.sascalc.shape2sas.HelperFunctions.plot_results(q: ndarray, r_list: list[ndarray], pr_list: list[ndarray], I_list: list[ndarray], Isim_list: list[ndarray], sigma_list: list[ndarray], S_list: list[ndarray], names: list[str], scales: list[float], xscale_log: bool, high_res: bool) → None

plot results for all models, using matplotlib: - p(r) - calculated formfactor, P(r) on log-log or log-lin scale - simulated noisy data on log-log or log-lin scale

sas.sascalc.shape2sas.HelperFunctions.sinc(x) → ndarray

function for calculating sinc = sin(x)/x numpy.sinc is defined as sinc(x) = sin(pi*x)/(pi*x)

sas.sascalc.shape2sas.Models module

class sas.sascalc.shape2sas.Models.GenerateAllPoints(Npoints: int, com: list[list[float]], subunits: list[list[float]], dimensions: list[list[float]], rotation: list[list[float]], rotation_point: list[float], p: list[float], exclude_overlap: bool)

Bases: object

__dict__ = mappingproxy({'__module__': 'sas.sascalc.shape2sas.Models', '__firstlineno__': 138, '__init__': <function GenerateAllPoints.__init__>, 'setAvailableSubunits': <function GenerateAllPoints.setAvailableSubunits>, 'getSubunitClass': <function GenerateAllPoints.getSubunitClass>, 'onAppendingPoints': <staticmethod(<function GenerateAllPoints.onAppendingPoints>)>, 'onCheckOverlap': <staticmethod(<function GenerateAllPoints.onCheckOverlap>)>, 'onGeneratingAllPointsSeparately': <function GenerateAllPoints.onGeneratingAllPointsSeparately>, 'onGeneratingAllPoints': <function GenerateAllPoints.onGeneratingAllPoints>, '__static_attributes__': ('Npoints', 'Number_of_subunits', 'com', 'dimensions', 'exclude_overlap', 'p_s', 'rotation', 'rotation_point', 'subunitClasses', 'subunits'), '__dict__': <attribute '__dict__' of 'GenerateAllPoints' objects>, '__weakref__': <attribute '__weakref__' of 'GenerateAllPoints' objects>, '__doc__': None, '__annotations__': {}})
__doc__ = None
__firstlineno__ = 138
__init__(Npoints: int, com: list[list[float]], subunits: list[list[float]], dimensions: list[list[float]], rotation: list[list[float]], rotation_point: list[float], p: list[float], exclude_overlap: bool)
__module__ = 'sas.sascalc.shape2sas.Models'
__static_attributes__ = ('Npoints', 'Number_of_subunits', 'com', 'dimensions', 'exclude_overlap', 'p_s', 'rotation', 'rotation_point', 'subunitClasses', 'subunits')
__weakref__

list of weak references to the object

getSubunitClass(key: str)
static onAppendingPoints(x_new: ndarray, y_new: ndarray, z_new: ndarray, p_new: ndarray, x_add: ndarray, y_add: ndarray, z_add: ndarray, p_add: ndarray) → tuple[ndarray, ndarray, ndarray, ndarray]

append new points to vectors of point coordinates

static onCheckOverlap(x: ndarray, y: ndarray, z: ndarray, p: ndarray, rotation: list[float], rotation_point: list[float], com: list[float], subunitClass: object, dimensions: list[float])

check for overlap with previous subunits. if overlap, the point is removed

onGeneratingAllPoints() → tuple[ndarray, ndarray, ndarray, ndarray, float]

Generating points for all subunits from each built model

onGeneratingAllPointsSeparately() → tuple[ndarray, ndarray, ndarray]

Generating points for all subunits from each built model, but save them separately in their own list

setAvailableSubunits()

Returns the available subunits

class sas.sascalc.shape2sas.Models.GeneratePoints(com: list[float], subunitClass: object, dimensions: list[float], rotation: list[float], rotation_point: list[float], Npoints: int)

Bases: object

__dict__ = mappingproxy({'__module__': 'sas.sascalc.shape2sas.Models', '__firstlineno__': 102, '__init__': <function GeneratePoints.__init__>, 'onGeneratingPoints': <function GeneratePoints.onGeneratingPoints>, 'onTransformingPoints': <function GeneratePoints.onTransformingPoints>, '__static_attributes__': ('Npoints', 'com', 'dimensions', 'rotation', 'rotation_point', 'subunitClass'), '__dict__': <attribute '__dict__' of 'GeneratePoints' objects>, '__weakref__': <attribute '__weakref__' of 'GeneratePoints' objects>, '__doc__': None, '__annotations__': {}})
__doc__ = None
__firstlineno__ = 102
__init__(com: list[float], subunitClass: object, dimensions: list[float], rotation: list[float], rotation_point: list[float], Npoints: int)
__module__ = 'sas.sascalc.shape2sas.Models'
__static_attributes__ = ('Npoints', 'com', 'dimensions', 'rotation', 'rotation_point', 'subunitClass')
__weakref__

list of weak references to the object

onGeneratingPoints() → tuple[ndarray, ndarray, ndarray]

Generates the points

onTransformingPoints(x: ndarray, y: ndarray, z: ndarray) → tuple[ndarray, ndarray, ndarray]

Transforms the points

class sas.sascalc.shape2sas.Models.ModelPointDistribution(x: ndarray, y: ndarray, z: ndarray, p: ndarray, volume_total: float)

Bases: object

Point distribution of a model

__annotations__ = {'p': <class 'numpy.ndarray'>, 'volume_total': <class 'float'>, 'x': <class 'numpy.ndarray'>, 'y': <class 'numpy.ndarray'>, 'z': <class 'numpy.ndarray'>}
__dataclass_fields__ = {'p': Field(name='p',type=<class 'numpy.ndarray'>,default=<dataclasses._MISSING_TYPE object>,default_factory=<dataclasses._MISSING_TYPE object>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD), 'volume_total': Field(name='volume_total',type=<class 'float'>,default=<dataclasses._MISSING_TYPE object>,default_factory=<dataclasses._MISSING_TYPE object>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD), 'x': Field(name='x',type=<class 'numpy.ndarray'>,default=<dataclasses._MISSING_TYPE object>,default_factory=<dataclasses._MISSING_TYPE object>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD), 'y': Field(name='y',type=<class 'numpy.ndarray'>,default=<dataclasses._MISSING_TYPE object>,default_factory=<dataclasses._MISSING_TYPE object>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD), 'z': Field(name='z',type=<class 'numpy.ndarray'>,default=<dataclasses._MISSING_TYPE object>,default_factory=<dataclasses._MISSING_TYPE object>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD)}
__dataclass_params__ = _DataclassParams(init=True,repr=True,eq=True,order=False,unsafe_hash=False,frozen=False,match_args=True,kw_only=False,slots=False,weakref_slot=False)
__dict__ = mappingproxy({'__module__': 'sas.sascalc.shape2sas.Models', '__firstlineno__': 41, '__annotations__': {'x': <class 'numpy.ndarray'>, 'y': <class 'numpy.ndarray'>, 'z': <class 'numpy.ndarray'>, 'p': <class 'numpy.ndarray'>, 'volume_total': <class 'float'>}, '__doc__': 'Point distribution of a model', '__static_attributes__': (), '__dict__': <attribute '__dict__' of 'ModelPointDistribution' objects>, '__weakref__': <attribute '__weakref__' of 'ModelPointDistribution' objects>, '__dataclass_params__': _DataclassParams(init=True,repr=True,eq=True,order=False,unsafe_hash=False,frozen=False,match_args=True,kw_only=False,slots=False,weakref_slot=False), '__dataclass_fields__': {'x': Field(name='x',type=<class 'numpy.ndarray'>,default=<dataclasses._MISSING_TYPE object>,default_factory=<dataclasses._MISSING_TYPE object>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD), 'y': Field(name='y',type=<class 'numpy.ndarray'>,default=<dataclasses._MISSING_TYPE object>,default_factory=<dataclasses._MISSING_TYPE object>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD), 'z': Field(name='z',type=<class 'numpy.ndarray'>,default=<dataclasses._MISSING_TYPE object>,default_factory=<dataclasses._MISSING_TYPE object>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD), 'p': Field(name='p',type=<class 'numpy.ndarray'>,default=<dataclasses._MISSING_TYPE object>,default_factory=<dataclasses._MISSING_TYPE object>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD), 'volume_total': Field(name='volume_total',type=<class 'float'>,default=<dataclasses._MISSING_TYPE object>,default_factory=<dataclasses._MISSING_TYPE object>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD)}, '__replace__': <function _replace>, '__hash__': None, '__init__': <function ModelPointDistribution.__init__>, '__repr__': <function ModelPointDistribution.__repr__>, '__eq__': <function ModelPointDistribution.__eq__>, '__match_args__': ('x', 'y', 'z', 'p', 'volume_total')})
__doc__ = 'Point distribution of a model'
__eq__(other)

Return self==value.

__firstlineno__ = 41
__hash__ = None
__init__(x: ndarray, y: ndarray, z: ndarray, p: ndarray, volume_total: float) → None
__match_args__ = ('x', 'y', 'z', 'p', 'volume_total')
__module__ = 'sas.sascalc.shape2sas.Models'
__replace__(**changes)
__repr__()

Return repr(self).

__static_attributes__ = ()
__weakref__

list of weak references to the object

p: ndarray
volume_total: float
x: ndarray
y: ndarray
z: ndarray
class sas.sascalc.shape2sas.Models.ModelProfile(subunits: list[str] = <factory>, p_s: list[float] = <factory>, dimensions: list[list[float]] = <factory>, com: list[list[float]] = <factory>, rotation_points: list[list[float]] = <factory>, rotation: list[list[float]] = <factory>, exclude_overlap: bool | None = <factory>)

Bases: object

Class containing parameters for creating a particle

NOTE: Default values create a sphere with a radius of 50 Å at the origin.

__annotations__ = {'com': list[list[float]], 'dimensions': list[list[float]], 'exclude_overlap': bool | None, 'p_s': list[float], 'rotation': list[list[float]], 'rotation_points': list[list[float]], 'subunits': list[str]}
__dataclass_fields__ = {'com': Field(name='com',type=list[list[float]],default=<dataclasses._MISSING_TYPE object>,default_factory=<function ModelProfile.<lambda>>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD), 'dimensions': Field(name='dimensions',type=list[list[float]],default=<dataclasses._MISSING_TYPE object>,default_factory=<function ModelProfile.<lambda>>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD), 'exclude_overlap': Field(name='exclude_overlap',type=bool | None,default=<dataclasses._MISSING_TYPE object>,default_factory=<function ModelProfile.<lambda>>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD), 'p_s': Field(name='p_s',type=list[float],default=<dataclasses._MISSING_TYPE object>,default_factory=<function ModelProfile.<lambda>>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD), 'rotation': Field(name='rotation',type=list[list[float]],default=<dataclasses._MISSING_TYPE object>,default_factory=<function ModelProfile.<lambda>>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD), 'rotation_points': Field(name='rotation_points',type=list[list[float]],default=<dataclasses._MISSING_TYPE object>,default_factory=<function ModelProfile.<lambda>>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD), 'subunits': Field(name='subunits',type=list[str],default=<dataclasses._MISSING_TYPE object>,default_factory=<function ModelProfile.<lambda>>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD)}
__dataclass_params__ = _DataclassParams(init=True,repr=True,eq=True,order=False,unsafe_hash=False,frozen=False,match_args=True,kw_only=False,slots=False,weakref_slot=False)
__dict__ = mappingproxy({'__module__': 'sas.sascalc.shape2sas.Models', '__firstlineno__': 23, '__annotations__': {'subunits': list[str], 'p_s': list[float], 'dimensions': list[list[float]], 'com': list[list[float]], 'rotation_points': list[list[float]], 'rotation': list[list[float]], 'exclude_overlap': bool | None}, '__doc__': 'Class containing parameters for\ncreating a particle\n\nNOTE: Default values create a sphere with a \nradius of 50 Å at the origin.\n', '__static_attributes__': (), '__dict__': <attribute '__dict__' of 'ModelProfile' objects>, '__weakref__': <attribute '__weakref__' of 'ModelProfile' objects>, '__dataclass_params__': _DataclassParams(init=True,repr=True,eq=True,order=False,unsafe_hash=False,frozen=False,match_args=True,kw_only=False,slots=False,weakref_slot=False), '__dataclass_fields__': {'subunits': Field(name='subunits',type=list[str],default=<dataclasses._MISSING_TYPE object>,default_factory=<function ModelProfile.<lambda>>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD), 'p_s': Field(name='p_s',type=list[float],default=<dataclasses._MISSING_TYPE object>,default_factory=<function ModelProfile.<lambda>>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD), 'dimensions': Field(name='dimensions',type=list[list[float]],default=<dataclasses._MISSING_TYPE object>,default_factory=<function ModelProfile.<lambda>>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD), 'com': Field(name='com',type=list[list[float]],default=<dataclasses._MISSING_TYPE object>,default_factory=<function ModelProfile.<lambda>>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD), 'rotation_points': Field(name='rotation_points',type=list[list[float]],default=<dataclasses._MISSING_TYPE object>,default_factory=<function ModelProfile.<lambda>>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD), 'rotation': Field(name='rotation',type=list[list[float]],default=<dataclasses._MISSING_TYPE object>,default_factory=<function ModelProfile.<lambda>>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD), 'exclude_overlap': Field(name='exclude_overlap',type=bool | None,default=<dataclasses._MISSING_TYPE object>,default_factory=<function ModelProfile.<lambda>>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD)}, '__replace__': <function _replace>, '__hash__': None, '__init__': <function ModelProfile.__init__>, '__repr__': <function ModelProfile.__repr__>, '__eq__': <function ModelProfile.__eq__>, '__match_args__': ('subunits', 'p_s', 'dimensions', 'com', 'rotation_points', 'rotation', 'exclude_overlap')})
__doc__ = 'Class containing parameters for\ncreating a particle\n\nNOTE: Default values create a sphere with a \nradius of 50 Å at the origin.\n'
__eq__(other)

Return self==value.

__firstlineno__ = 23
__hash__ = None
__init__(subunits: list[str] = <factory>, p_s: list[float] = <factory>, dimensions: list[list[float]] = <factory>, com: list[list[float]] = <factory>, rotation_points: list[list[float]] = <factory>, rotation: list[list[float]] = <factory>, exclude_overlap: bool | None = <factory>) → None
__match_args__ = ('subunits', 'p_s', 'dimensions', 'com', 'rotation_points', 'rotation', 'exclude_overlap')
__module__ = 'sas.sascalc.shape2sas.Models'
__replace__(**changes)
__repr__()

Return repr(self).

__static_attributes__ = ()
__weakref__

list of weak references to the object

com: list[list[float]]
dimensions: list[list[float]]
exclude_overlap: bool | None
p_s: list[float]
rotation: list[list[float]]
rotation_points: list[list[float]]
subunits: list[str]
class sas.sascalc.shape2sas.Models.ModelSystem(PointDistribution: ModelPointDistribution, Stype: str = <factory>, par: list[float] = <factory>, polydispersity: float = <factory>, conc: float = <factory>, sigma_r: float = <factory>)

Bases: object

Class containing parameters for the system

PointDistribution: ModelPointDistribution
Stype: str
__annotations__ = {'PointDistribution': <class 'sas.sascalc.shape2sas.Models.ModelPointDistribution'>, 'Stype': <class 'str'>, 'conc': <class 'float'>, 'par': list[float], 'polydispersity': <class 'float'>, 'sigma_r': <class 'float'>}
__dataclass_fields__ = {'PointDistribution': Field(name='PointDistribution',type=<class 'sas.sascalc.shape2sas.Models.ModelPointDistribution'>,default=<dataclasses._MISSING_TYPE object>,default_factory=<dataclasses._MISSING_TYPE object>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD), 'Stype': Field(name='Stype',type=<class 'str'>,default=<dataclasses._MISSING_TYPE object>,default_factory=<function ModelSystem.<lambda>>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD), 'conc': Field(name='conc',type=<class 'float'>,default=<dataclasses._MISSING_TYPE object>,default_factory=<function ModelSystem.<lambda>>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD), 'par': Field(name='par',type=list[float],default=<dataclasses._MISSING_TYPE object>,default_factory=<function ModelSystem.<lambda>>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD), 'polydispersity': Field(name='polydispersity',type=<class 'float'>,default=<dataclasses._MISSING_TYPE object>,default_factory=<function ModelSystem.<lambda>>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD), 'sigma_r': Field(name='sigma_r',type=<class 'float'>,default=<dataclasses._MISSING_TYPE object>,default_factory=<function ModelSystem.<lambda>>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD)}
__dataclass_params__ = _DataclassParams(init=True,repr=True,eq=True,order=False,unsafe_hash=False,frozen=False,match_args=True,kw_only=False,slots=False,weakref_slot=False)
__dict__ = mappingproxy({'__module__': 'sas.sascalc.shape2sas.Models', '__firstlineno__': 65, '__annotations__': {'PointDistribution': <class 'sas.sascalc.shape2sas.Models.ModelPointDistribution'>, 'Stype': <class 'str'>, 'par': list[float], 'polydispersity': <class 'float'>, 'conc': <class 'float'>, 'sigma_r': <class 'float'>}, '__doc__': 'Class containing parameters for\nthe system', '__static_attributes__': (), '__dict__': <attribute '__dict__' of 'ModelSystem' objects>, '__weakref__': <attribute '__weakref__' of 'ModelSystem' objects>, '__dataclass_params__': _DataclassParams(init=True,repr=True,eq=True,order=False,unsafe_hash=False,frozen=False,match_args=True,kw_only=False,slots=False,weakref_slot=False), '__dataclass_fields__': {'PointDistribution': Field(name='PointDistribution',type=<class 'sas.sascalc.shape2sas.Models.ModelPointDistribution'>,default=<dataclasses._MISSING_TYPE object>,default_factory=<dataclasses._MISSING_TYPE object>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD), 'Stype': Field(name='Stype',type=<class 'str'>,default=<dataclasses._MISSING_TYPE object>,default_factory=<function ModelSystem.<lambda>>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD), 'par': Field(name='par',type=list[float],default=<dataclasses._MISSING_TYPE object>,default_factory=<function ModelSystem.<lambda>>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD), 'polydispersity': Field(name='polydispersity',type=<class 'float'>,default=<dataclasses._MISSING_TYPE object>,default_factory=<function ModelSystem.<lambda>>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD), 'conc': Field(name='conc',type=<class 'float'>,default=<dataclasses._MISSING_TYPE object>,default_factory=<function ModelSystem.<lambda>>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD), 'sigma_r': Field(name='sigma_r',type=<class 'float'>,default=<dataclasses._MISSING_TYPE object>,default_factory=<function ModelSystem.<lambda>>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD)}, '__replace__': <function _replace>, '__hash__': None, '__init__': <function ModelSystem.__init__>, '__repr__': <function ModelSystem.__repr__>, '__eq__': <function ModelSystem.__eq__>, '__match_args__': ('PointDistribution', 'Stype', 'par', 'polydispersity', 'conc', 'sigma_r')})
__doc__ = 'Class containing parameters for\nthe system'
__eq__(other)

Return self==value.

__firstlineno__ = 65
__hash__ = None
__init__(PointDistribution: ModelPointDistribution, Stype: str = <factory>, par: list[float] = <factory>, polydispersity: float = <factory>, conc: float = <factory>, sigma_r: float = <factory>) → None
__match_args__ = ('PointDistribution', 'Stype', 'par', 'polydispersity', 'conc', 'sigma_r')
__module__ = 'sas.sascalc.shape2sas.Models'
__replace__(**changes)
__repr__()

Return repr(self).

__static_attributes__ = ()
__weakref__

list of weak references to the object

conc: float
par: list[float]
polydispersity: float
sigma_r: float
class sas.sascalc.shape2sas.Models.Rotation(matrix: ndarray, center_mass: ndarray)

Bases: object

__dict__ = mappingproxy({'__module__': 'sas.sascalc.shape2sas.Models', '__firstlineno__': 78, '__init__': <function Rotation.__init__>, '__static_attributes__': ('M', 'cm'), '__dict__': <attribute '__dict__' of 'Rotation' objects>, '__weakref__': <attribute '__weakref__' of 'Rotation' objects>, '__doc__': None, '__annotations__': {}})
__doc__ = None
__firstlineno__ = 78
__init__(matrix: ndarray, center_mass: ndarray)
__module__ = 'sas.sascalc.shape2sas.Models'
__static_attributes__ = ('M', 'cm')
__weakref__

list of weak references to the object

class sas.sascalc.shape2sas.Models.SimulationParameters(q: ndarray | None = <factory>, prpoints: int | None = <factory>, Npoints: int | None = <factory>, model_name: list[str] | None = <factory>)

Bases: object

Class containing parameters for the simulation itself

Npoints: int | None
__annotations__ = {'Npoints': int | None, 'model_name': list[str] | None, 'prpoints': int | None, 'q': numpy.ndarray | None}
__dataclass_fields__ = {'Npoints': Field(name='Npoints',type=int | None,default=<dataclasses._MISSING_TYPE object>,default_factory=<function SimulationParameters.<lambda>>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD), 'model_name': Field(name='model_name',type=list[str] | None,default=<dataclasses._MISSING_TYPE object>,default_factory=<function SimulationParameters.<lambda>>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD), 'prpoints': Field(name='prpoints',type=int | None,default=<dataclasses._MISSING_TYPE object>,default_factory=<function SimulationParameters.<lambda>>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD), 'q': Field(name='q',type=numpy.ndarray | None,default=<dataclasses._MISSING_TYPE object>,default_factory=<function SimulationParameters.<lambda>>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD)}
__dataclass_params__ = _DataclassParams(init=True,repr=True,eq=True,order=False,unsafe_hash=False,frozen=False,match_args=True,kw_only=False,slots=False,weakref_slot=False)
__dict__ = mappingproxy({'__module__': 'sas.sascalc.shape2sas.Models', '__firstlineno__': 52, '__annotations__': {'q': numpy.ndarray | None, 'prpoints': int | None, 'Npoints': int | None, 'model_name': list[str] | None}, '__doc__': 'Class containing parameters for\nthe simulation itself', '__static_attributes__': (), '__dict__': <attribute '__dict__' of 'SimulationParameters' objects>, '__weakref__': <attribute '__weakref__' of 'SimulationParameters' objects>, '__dataclass_params__': _DataclassParams(init=True,repr=True,eq=True,order=False,unsafe_hash=False,frozen=False,match_args=True,kw_only=False,slots=False,weakref_slot=False), '__dataclass_fields__': {'q': Field(name='q',type=numpy.ndarray | None,default=<dataclasses._MISSING_TYPE object>,default_factory=<function SimulationParameters.<lambda>>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD), 'prpoints': Field(name='prpoints',type=int | None,default=<dataclasses._MISSING_TYPE object>,default_factory=<function SimulationParameters.<lambda>>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD), 'Npoints': Field(name='Npoints',type=int | None,default=<dataclasses._MISSING_TYPE object>,default_factory=<function SimulationParameters.<lambda>>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD), 'model_name': Field(name='model_name',type=list[str] | None,default=<dataclasses._MISSING_TYPE object>,default_factory=<function SimulationParameters.<lambda>>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD)}, '__replace__': <function _replace>, '__hash__': None, '__init__': <function SimulationParameters.__init__>, '__repr__': <function SimulationParameters.__repr__>, '__eq__': <function SimulationParameters.__eq__>, '__match_args__': ('q', 'prpoints', 'Npoints', 'model_name')})
__doc__ = 'Class containing parameters for\nthe simulation itself'
__eq__(other)

Return self==value.

__firstlineno__ = 52
__hash__ = None
__init__(q: ndarray | None = <factory>, prpoints: int | None = <factory>, Npoints: int | None = <factory>, model_name: list[str] | None = <factory>) → None
__match_args__ = ('q', 'prpoints', 'Npoints', 'model_name')
__module__ = 'sas.sascalc.shape2sas.Models'
__replace__(**changes)
__repr__()

Return repr(self).

__static_attributes__ = ()
__weakref__

list of weak references to the object

model_name: list[str] | None
prpoints: int | None
q: ndarray | None
sas.sascalc.shape2sas.Models.getPointDistribution(prof: ModelProfile, Npoints)

Generate points for a given model profile.

sas.sascalc.shape2sas.Models.transform(coords: ~numpy.ndarray[tuple[~numpy.ndarray, ~numpy.ndarray, ~numpy.ndarray]], translate: ~numpy.ndarray = array([0, 0, 0]), rotate: ~sas.sascalc.shape2sas.Models.Rotation = <sas.sascalc.shape2sas.Models.Rotation object>)

Transform a set of coordinates by a rotation R and translation T

sas.sascalc.shape2sas.PluginGenerator module

sas.sascalc.shape2sas.PluginGenerator.format_parameter_list(par: list[list[str | float]]) → str

Format a list of parameters to the model string. In this case the list is on element for each shape. For a single shape there will be only a single value. Mainly for delta Rho.

sas.sascalc.shape2sas.PluginGenerator.format_parameter_list_of_list(par: list[str | float]) → str

Format a list of list containing parameters to the model string. This is used for single shape parameter lists like the center of mass of the object which will be an element of the list of such COM for each shape in a multishape model.

sas.sascalc.shape2sas.PluginGenerator.format_parameter_list_of_list_dimension(par: list[list[str | float]]) → str

Format a list of lists containing dimensional parameters to the model string. Variables will be enclosed in ‘min(abs(x), 1)’ for safety.

sas.sascalc.shape2sas.PluginGenerator.generate_model(prof: ModelProfile, modelPars: list[list[str], list[str | float]], usertext: UserText, fitPar: list[str], Npoints: int, pr_points: int, model_name: str) → str

Generates a theoretical model

sas.sascalc.shape2sas.PluginGenerator.generate_plugin(prof: ModelProfile, modelPars: list[list[str], list[str | float]], usertext: UserText, fitPar: list[str], Npoints: int, pr_points: int, file_name: str) → tuple[str, Path]

Generates a theoretical scattering plugin model

sas.sascalc.shape2sas.PluginGenerator.get_shape_symbols(symbols: tuple[set[str], set[str]], modelPars: list[list[str], list[str | float]]) → tuple[set[str], set[str]]

Get the symbols used in the model, discarding user-defined variables

sas.sascalc.shape2sas.PluginGenerator.script_insert_apply_constraints(lhs_symbols: set[str]) → str

Create the code responsible for updating constraints.

sas.sascalc.shape2sas.PluginGenerator.script_insert_constrained_parameters(symbols: set[str], modelPars: list[list[str], list[str | float]]) → str

Create the code defining the constrained parameters.

sas.sascalc.shape2sas.PluginGenerator.script_insert_delta_parameters(modelPars: list[list[str | float]], fitPars: list[str], symbols: tuple[set[str], set[str]]) → tuple[str, str]

Create the code sections defining and updating the delta parameters. Only parameters declared in the symbol list will be included.

sas.sascalc.shape2sas.Shape2SAS module

sas.sascalc.shape2sas.StructureFactor module

class sas.sascalc.shape2sas.StructureFactor.StructureFactor(q: ndarray, x_new: ndarray, y_new: ndarray, z_new: ndarray, p_new: ndarray, Stype: str, par: list[float] | None)

Bases: object

__dict__ = mappingproxy({'__module__': 'sas.sascalc.shape2sas.StructureFactor', '__firstlineno__': 7, '__init__': <function StructureFactor.__init__>, 'setAvailableStructureFactors': <function StructureFactor.setAvailableStructureFactors>, 'getStructureFactorClass': <function StructureFactor.getStructureFactorClass>, 'getparname': <staticmethod(<function StructureFactor.getparname>)>, 'save_S': <staticmethod(<function StructureFactor.save_S>)>, '__static_attributes__': ('Stype', 'p_new', 'par', 'q', 'structureFactor', 'x_new', 'y_new', 'z_new'), '__dict__': <attribute '__dict__' of 'StructureFactor' objects>, '__weakref__': <attribute '__weakref__' of 'StructureFactor' objects>, '__doc__': None, '__annotations__': {}})
__doc__ = None
__firstlineno__ = 7
__init__(q: ndarray, x_new: ndarray, y_new: ndarray, z_new: ndarray, p_new: ndarray, Stype: str, par: list[float] | None)
__module__ = 'sas.sascalc.shape2sas.StructureFactor'
__static_attributes__ = ('Stype', 'p_new', 'par', 'q', 'structureFactor', 'x_new', 'y_new', 'z_new')
__weakref__

list of weak references to the object

getStructureFactorClass()

Return chosen structure factor

static getparname(name: str) → list[str]

Return the name of the parameters

static save_S(q: ndarray, S_eff: ndarray, Model: str)

save S to file

setAvailableStructureFactors()

Available structure factors

sas.sascalc.shape2sas.TheoreticalScattering module

class sas.sascalc.shape2sas.TheoreticalScattering.ITheoretical(q: ndarray)

Bases: object

__dict__ = mappingproxy({'__module__': 'sas.sascalc.shape2sas.TheoreticalScattering', '__firstlineno__': 220, '__init__': <function ITheoretical.__init__>, 'calc_Pq': <function ITheoretical.calc_Pq>, 'calc_Pq_ausaxs': <function ITheoretical.calc_Pq_ausaxs>, 'calc_Iq': <function ITheoretical.calc_Iq>, 'save_I': <function ITheoretical.save_I>, '__static_attributes__': ('q',), '__dict__': <attribute '__dict__' of 'ITheoretical' objects>, '__weakref__': <attribute '__weakref__' of 'ITheoretical' objects>, '__doc__': None, '__annotations__': {}})
__doc__ = None
__firstlineno__ = 220
__init__(q: ndarray)
__module__ = 'sas.sascalc.shape2sas.TheoreticalScattering'
__static_attributes__ = ('q',)
__weakref__

list of weak references to the object

calc_Iq(Pq: ndarray, S_eff: ndarray, sigma_r: float) → ndarray

calculates intensity

calc_Pq(r: ndarray, pr: ndarray, conc: float, volume_total: float) → tuple[ndarray, ndarray]

calculate form factor, P(q), and forward scattering, I(0), using pair distribution, p(r)

calc_Pq_ausaxs(q: ndarray, x: ndarray, y: ndarray, z: ndarray, p: ndarray) → ndarray

calculate form factor, P(q), using ausaxs SANS Debye method

save_I(I: ndarray, Model: str)

Save theoretical intensity to file

class sas.sascalc.shape2sas.TheoreticalScattering.TheoreticalScattering(q: ndarray, I0: ndarray, I: ndarray, S_eff: ndarray)

Bases: object

Class containing parameters for theoretical scattering

I: ndarray
I0: ndarray
S_eff: ndarray
__annotations__ = {'I': <class 'numpy.ndarray'>, 'I0': <class 'numpy.ndarray'>, 'S_eff': <class 'numpy.ndarray'>, 'q': <class 'numpy.ndarray'>}
__dataclass_fields__ = {'I': Field(name='I',type=<class 'numpy.ndarray'>,default=<dataclasses._MISSING_TYPE object>,default_factory=<dataclasses._MISSING_TYPE object>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD), 'I0': Field(name='I0',type=<class 'numpy.ndarray'>,default=<dataclasses._MISSING_TYPE object>,default_factory=<dataclasses._MISSING_TYPE object>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD), 'S_eff': Field(name='S_eff',type=<class 'numpy.ndarray'>,default=<dataclasses._MISSING_TYPE object>,default_factory=<dataclasses._MISSING_TYPE object>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD), 'q': Field(name='q',type=<class 'numpy.ndarray'>,default=<dataclasses._MISSING_TYPE object>,default_factory=<dataclasses._MISSING_TYPE object>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD)}
__dataclass_params__ = _DataclassParams(init=True,repr=True,eq=True,order=False,unsafe_hash=False,frozen=False,match_args=True,kw_only=False,slots=False,weakref_slot=False)
__dict__ = mappingproxy({'__module__': 'sas.sascalc.shape2sas.TheoreticalScattering', '__firstlineno__': 20, '__annotations__': {'q': <class 'numpy.ndarray'>, 'I0': <class 'numpy.ndarray'>, 'I': <class 'numpy.ndarray'>, 'S_eff': <class 'numpy.ndarray'>}, '__doc__': 'Class containing parameters for\ntheoretical scattering', '__static_attributes__': (), '__dict__': <attribute '__dict__' of 'TheoreticalScattering' objects>, '__weakref__': <attribute '__weakref__' of 'TheoreticalScattering' objects>, '__dataclass_params__': _DataclassParams(init=True,repr=True,eq=True,order=False,unsafe_hash=False,frozen=False,match_args=True,kw_only=False,slots=False,weakref_slot=False), '__dataclass_fields__': {'q': Field(name='q',type=<class 'numpy.ndarray'>,default=<dataclasses._MISSING_TYPE object>,default_factory=<dataclasses._MISSING_TYPE object>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD), 'I0': Field(name='I0',type=<class 'numpy.ndarray'>,default=<dataclasses._MISSING_TYPE object>,default_factory=<dataclasses._MISSING_TYPE object>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD), 'I': Field(name='I',type=<class 'numpy.ndarray'>,default=<dataclasses._MISSING_TYPE object>,default_factory=<dataclasses._MISSING_TYPE object>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD), 'S_eff': Field(name='S_eff',type=<class 'numpy.ndarray'>,default=<dataclasses._MISSING_TYPE object>,default_factory=<dataclasses._MISSING_TYPE object>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD)}, '__replace__': <function _replace>, '__hash__': None, '__init__': <function TheoreticalScattering.__init__>, '__repr__': <function TheoreticalScattering.__repr__>, '__eq__': <function TheoreticalScattering.__eq__>, '__match_args__': ('q', 'I0', 'I', 'S_eff')})
__doc__ = 'Class containing parameters for\ntheoretical scattering'
__eq__(other)

Return self==value.

__firstlineno__ = 20
__hash__ = None
__init__(q: ndarray, I0: ndarray, I: ndarray, S_eff: ndarray) → None
__match_args__ = ('q', 'I0', 'I', 'S_eff')
__module__ = 'sas.sascalc.shape2sas.TheoreticalScattering'
__replace__(**changes)
__repr__()

Return repr(self).

__static_attributes__ = ()
__weakref__

list of weak references to the object

q: ndarray
class sas.sascalc.shape2sas.TheoreticalScattering.TheoreticalScatteringCalculation(System: ModelSystem, Calculation: SimulationParameters)

Bases: object

Class containing parameters for simulating scattering for a given model system

Calculation: SimulationParameters
System: ModelSystem
__annotations__ = {'Calculation': <class 'sas.sascalc.shape2sas.Models.SimulationParameters'>, 'System': <class 'sas.sascalc.shape2sas.Models.ModelSystem'>}
__dataclass_fields__ = {'Calculation': Field(name='Calculation',type=<class 'sas.sascalc.shape2sas.Models.SimulationParameters'>,default=<dataclasses._MISSING_TYPE object>,default_factory=<dataclasses._MISSING_TYPE object>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD), 'System': Field(name='System',type=<class 'sas.sascalc.shape2sas.Models.ModelSystem'>,default=<dataclasses._MISSING_TYPE object>,default_factory=<dataclasses._MISSING_TYPE object>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD)}
__dataclass_params__ = _DataclassParams(init=True,repr=True,eq=True,order=False,unsafe_hash=False,frozen=False,match_args=True,kw_only=False,slots=False,weakref_slot=False)
__dict__ = mappingproxy({'__module__': 'sas.sascalc.shape2sas.TheoreticalScattering', '__firstlineno__': 11, '__annotations__': {'System': <class 'sas.sascalc.shape2sas.Models.ModelSystem'>, 'Calculation': <class 'sas.sascalc.shape2sas.Models.SimulationParameters'>}, '__doc__': 'Class containing parameters for simulating\nscattering for a given model system', '__static_attributes__': (), '__dict__': <attribute '__dict__' of 'TheoreticalScatteringCalculation' objects>, '__weakref__': <attribute '__weakref__' of 'TheoreticalScatteringCalculation' objects>, '__dataclass_params__': _DataclassParams(init=True,repr=True,eq=True,order=False,unsafe_hash=False,frozen=False,match_args=True,kw_only=False,slots=False,weakref_slot=False), '__dataclass_fields__': {'System': Field(name='System',type=<class 'sas.sascalc.shape2sas.Models.ModelSystem'>,default=<dataclasses._MISSING_TYPE object>,default_factory=<dataclasses._MISSING_TYPE object>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD), 'Calculation': Field(name='Calculation',type=<class 'sas.sascalc.shape2sas.Models.SimulationParameters'>,default=<dataclasses._MISSING_TYPE object>,default_factory=<dataclasses._MISSING_TYPE object>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=False,_field_type=_FIELD)}, '__replace__': <function _replace>, '__hash__': None, '__init__': <function TheoreticalScatteringCalculation.__init__>, '__repr__': <function TheoreticalScatteringCalculation.__repr__>, '__eq__': <function TheoreticalScatteringCalculation.__eq__>, '__match_args__': ('System', 'Calculation')})
__doc__ = 'Class containing parameters for simulating\nscattering for a given model system'
__eq__(other)

Return self==value.

__firstlineno__ = 11
__hash__ = None
__init__(System: ModelSystem, Calculation: SimulationParameters) → None
__match_args__ = ('System', 'Calculation')
__module__ = 'sas.sascalc.shape2sas.TheoreticalScattering'
__replace__(**changes)
__repr__()

Return repr(self).

__static_attributes__ = ()
__weakref__

list of weak references to the object

class sas.sascalc.shape2sas.TheoreticalScattering.WeightedPairDistribution(x: ndarray, y: ndarray, z: ndarray, p: ndarray)

Bases: object

__dict__ = mappingproxy({'__module__': 'sas.sascalc.shape2sas.TheoreticalScattering', '__firstlineno__': 31, '__init__': <function WeightedPairDistribution.__init__>, 'calc_dist': <staticmethod(<function WeightedPairDistribution.calc_dist>)>, 'calc_all_dist': <function WeightedPairDistribution.calc_all_dist>, 'calc_all_contrasts': <function WeightedPairDistribution.calc_all_contrasts>, 'generate_histogram': <staticmethod(<function WeightedPairDistribution.generate_histogram>)>, 'calc_Rg': <staticmethod(<function WeightedPairDistribution.calc_Rg>)>, 'calc_hr': <function WeightedPairDistribution.calc_hr>, 'calc_pr': <function WeightedPairDistribution.calc_pr>, 'save_pr': <staticmethod(<function WeightedPairDistribution.save_pr>)>, '__static_attributes__': ('p', 'x', 'y', 'z'), '__dict__': <attribute '__dict__' of 'WeightedPairDistribution' objects>, '__weakref__': <attribute '__weakref__' of 'WeightedPairDistribution' objects>, '__doc__': None, '__annotations__': {}})
__doc__ = None
__firstlineno__ = 31
__init__(x: ndarray, y: ndarray, z: ndarray, p: ndarray)
__module__ = 'sas.sascalc.shape2sas.TheoreticalScattering'
__static_attributes__ = ('p', 'x', 'y', 'z')
__weakref__

list of weak references to the object

static calc_Rg(r: ndarray, pr: ndarray) → float

calculate Rg from r and p(r)

calc_all_contrasts() → ndarray

calculate all pairwise contrast products of p: all contrasts

calc_all_dist() → ndarray

calculate all pairwise distances calls calc_dist() for each set of coordinates: x,y,z does a square sum of coordinates convert from matrix to

static calc_dist(x: ndarray) → ndarray

calculate all distances between points in an array

calc_hr(dist: ndarray, Nbins: int, contrast: ndarray, polydispersity: float) → tuple[ndarray, ndarray]

calculate h(r) h(r) is the contrast-weighted histogram of distances, including self-terms (dist = 0)

input: dist : all pairwise distances contrast : all pair-wise contrast products polydispersity: relative polydispersity, float

output: hr : pair distance distribution function

calc_pr(Nbins: int, polydispersity: float) → tuple[ndarray, ndarray, ndarray]

calculate p(r) p(r) is the contrast-weighted histogram of distances, without the self-terms (dist = 0)

input: dist : all pairwise distances contrast : all pair-wise contrast products polydispersity: boolian, True or False

output: pr : pair distance distribution function

static generate_histogram(dist: ndarray, contrast: ndarray, r_max: float, Nbins: int) → tuple[ndarray, ndarray]

make histogram of point pairs, h(r), binned after pair-distances, r used for calculating scattering (fast Debye)

input dist : all pairwise distances Nbins : number of bins in h(r) contrast : contrast of points r_max : max distance to include in histogram

output r : distances of bins histo : histogram, weighted by contrast

static save_pr(Nbins: int, r: ndarray, pr_norm: ndarray, Model: str)

save p(r) to textfile

sas.sascalc.shape2sas.TheoreticalScattering.getTheoreticalHistogram(model: ModelSystem, sim_pars: SimulationParameters) → tuple[ndarray, ndarray, ndarray]

Get theoretical histogram for a given model system and simulation parameters. This function is used to calculate the pair distribution function (p(r)).

Parameters:

  • model – ModelSystem object containing the model parameters.

  • sim_pars – SimulationParameters object containing the simulation parameters.

Returns:

r, pr, pr_norm - pair distance distribution function.

sas.sascalc.shape2sas.TheoreticalScattering.getTheoreticalScattering(scalc: TheoreticalScatteringCalculation) → TheoreticalScattering

Calculate theoretical scattering for a given model profile.

sas.sascalc.shape2sas.Typing module

sas.sascalc.shape2sas.UserText module

class sas.sascalc.shape2sas.UserText.UserText(imports: list[str], params: list[str], constraints: list[str], symbols: tuple[set[str], set[str]])

Bases: object

__dataclass_fields__ = {}
__dataclass_params__ = _DataclassParams(init=True,repr=True,eq=True,order=False,unsafe_hash=False,frozen=False,match_args=True,kw_only=False,slots=False,weakref_slot=False)
__dict__ = mappingproxy({'__module__': 'sas.sascalc.shape2sas.UserText', '__firstlineno__': 4, '__init__': <function UserText.__init__>, '__static_attributes__': ('constraints', 'imports', 'params', 'symbols'), '__dict__': <attribute '__dict__' of 'UserText' objects>, '__weakref__': <attribute '__weakref__' of 'UserText' objects>, '__doc__': 'UserText(imports: list[str], params: list[str], constraints: list[str], symbols: tuple[set[str], set[str]])', '__dataclass_params__': _DataclassParams(init=True,repr=True,eq=True,order=False,unsafe_hash=False,frozen=False,match_args=True,kw_only=False,slots=False,weakref_slot=False), '__dataclass_fields__': {}, '__replace__': <function _replace>, '__hash__': None, '__repr__': <function UserText.__repr__>, '__eq__': <function UserText.__eq__>, '__match_args__': (), '__annotations__': {}})
__doc__ = 'UserText(imports: list[str], params: list[str], constraints: list[str], symbols: tuple[set[str], set[str]])'
__eq__(other)

Return self==value.

__firstlineno__ = 4
__hash__ = None
__init__(imports: list[str], params: list[str], constraints: list[str], symbols: tuple[set[str], set[str]])
__match_args__ = ()
__module__ = 'sas.sascalc.shape2sas.UserText'
__replace__(**changes)
__repr__()

Return repr(self).

__static_attributes__ = ('constraints', 'imports', 'params', 'symbols')
__weakref__

list of weak references to the object

Module contents