sasdata.data_util.averaging module

This module contains various data processors used by Sasview’s slicers.

class sasdata.data_util.averaging.Boxavg(qx_range: tuple[float, float] = (0.0, 0.0), qy_range: tuple[float, float] = (0.0, 0.0))

Bases: Boxsum

Compute the average intensity within a rectangular Region Of Interest.

__call__(data2d: Data2D) → tuple[float, float]

Coordinate data processing operations and return the results.

Parameters:

data2d – The Data2D object for which the average is calculated.

__doc__ = '\nCompute the average intensity within a rectangular Region Of Interest.\n'

__firstlineno__ = 109

__init__(qx_range: tuple[float, float] = (0.0, 0.0), qy_range: tuple[float, float] = (0.0, 0.0)) → None

Set up the Region of Interest and its boundaries.

The units of these parameters are A^-1 :param qx_range: Bounds of the ROI along the Q_x direction. :param qy_range: Bounds of the ROI along the Q_y direction.

__module__ = 'sasdata.data_util.averaging'

__static_attributes__ = ()

class sasdata.data_util.averaging.Boxcut(qx_range: tuple[float, float] = (0.0, 0.0), qy_range: tuple[float, float] = (0.0, 0.0))

Bases: CartesianROI

Find a rectangular 2D region of interest.

__annotations__ = {}

__call__(data2D: Data2D) → ndarray[tuple[Any, ...], dtype[bool]]

Find a rectangular 2D region of interest where data points inside the ROI are True, and False otherwise

Parameters:

data2D – Data2D object

Returns:

mask, 1d array (len = len(data))

__doc__ = '\nFind a rectangular 2D region of interest.\n'

__firstlineno__ = 964

__init__(qx_range: tuple[float, float] = (0.0, 0.0), qy_range: tuple[float, float] = (0.0, 0.0)) → None

Assign the variables used to label the properties of the Data2D object. Also establish the upper and lower bounds defining the ROI.

The units of these parameters are A^-1 :param qx_range: Bounds of the ROI along the Q_x direction. :param qy_range: Bounds of the ROI along the Q_y direction.

__module__ = 'sasdata.data_util.averaging'

__static_attributes__ = ()

class sasdata.data_util.averaging.Boxsum(qx_range: tuple[float, float] = (0.0, 0.0), qy_range: tuple[float, float] = (0.0, 0.0))

Bases: CartesianROI

Compute the sum of the intensity within a rectangular Region Of Interest.

__annotations__ = {}

__call__(data2d: Data2D) → tuple[float, float, float]

Coordinate data processing operations and return the results.

Parameters:

data2d – The Data2D object for which the sum is calculated.

__doc__ = '\nCompute the sum of the intensity within a rectangular Region Of Interest.\n'

__firstlineno__ = 58

__init__(qx_range: tuple[float, float] = (0.0, 0.0), qy_range: tuple[float, float] = (0.0, 0.0)) → None

Set up the Region of Interest and its boundaries.

The units of these parameters are A^-1 :param qx_range: Bounds of the ROI along the Q_x direction. :param qy_range: Bounds of the ROI along the Q_y direction.

__module__ = 'sasdata.data_util.averaging'

__static_attributes__ = ()

_sum() → tuple[float, float, float]

Determine which data are inside the ROI and compute their sum. Also calculate the error on this calculation and the total number of datapoints in the region.

class sasdata.data_util.averaging.CircularAverage(r_range: tuple[float, float], center: tuple[float, float] = (0.0, 0.0), nbins: int = 100, base: float | None = None)

Bases: PolarROI

Calculate I(|Q|) by circularly averaging 2D data between 2 radial limits.

This class is initialised by specifying lower and upper limits on the magnitude of Q values to consider during the averaging, though currently SasView always calls this class using the full range of data. When called, this class is supplied with a Data2D object. It returns a Data1D object where intensity is given as a function of Q only.

__annotations__ = {'base': 'float | None', 'nbins': 'int'}

__call__(data2D: Data2D, ismask: bool = False) → Data1D

Perform circular averaging on the data. Uses DirectionalAverage for bin construction and weights, and computes dx (d_q) using get_dq_data averaged with those weights so behavior matches the legacy implementation.

Parameters:

• data2D – Data2D object

• ismask – If True, respect data2D.mask (skip masked points). If False, ignore mask.

Returns:

Data1D object with x (bin centers), y (intensity), dy and dx (if available)

__doc__ = '\nCalculate I(|Q|) by circularly averaging 2D data between 2 radial limits.\n\nThis class is initialised by specifying lower and upper limits on the\nmagnitude of Q values to consider during the averaging, though currently\nSasView always calls this class using the full range of data. When called,\nthis class is supplied with a Data2D object. It returns a Data1D object\nwhere intensity is given as a function of Q only.\n'

__firstlineno__ = 275

__init__(r_range: tuple[float, float], center: tuple[float, float] = (0.0, 0.0), nbins: int = 100, base: float | None = None) → None

Set up the lower and upper radial limits as well as the number of bins.

The units are A^-1 for the radial parameters. :param r_min: Lower limit for |Q| values to use during averaging. :param r_max: Upper limit for |Q| values to use during averaging. :param nbins: The number of bins data is sorted into along |Q| the axis

__module__ = 'sasdata.data_util.averaging'

__static_attributes__ = ('base', 'nbins')

base: float | None

nbins: int

class sasdata.data_util.averaging.Ring(r_range: tuple[float, float], center: tuple[float, float] = (0.0, 0.0), nbins: int = 100, base: float | None = None)

Bases: PolarROI

Calculate I(φ) by radially averaging 2D data between 2 radial limits.

This class is initialised by specifying lower and upper limits on the magnitude of Q values to consider during the averaging. When called, this class is supplied with a Data2D object. It returns a Data1D object. This Data1D object gives intensity as a function of the angle from the positive x-axis, φ, only.

__annotations__ = {'base': 'float | None', 'nbins': 'int'}

__call__(data2D: Data2D) → Data1D

Apply the ring to the data set. Returns the angular distribution for a given q range

Parameters:

data2D – Data2D object

Returns:

Data1D object

__doc__ = '\nCalculate I(φ) by radially averaging 2D data between 2 radial limits.\n\nThis class is initialised by specifying lower and upper limits on the\nmagnitude of Q values to consider during the averaging. When called,\nthis class is supplied with a Data2D object. It returns a Data1D object.\nThis Data1D object gives intensity as a function of the angle from the\npositive x-axis, φ, only.\n'

__firstlineno__ = 381

__init__(r_range: tuple[float, float], center: tuple[float, float] = (0.0, 0.0), nbins: int = 100, base: float | None = None) → None

Set up the lower and upper radial limits as well as the number of bins.

The units are A^-1 for the radial parameters. :param r_min: Lower limit for |Q| values to use during averaging. :param r_max: Upper limit for |Q| values to use during averaging. :param nbins: The number of bins data is sorted into along Phi the axis

__module__ = 'sasdata.data_util.averaging'

__static_attributes__ = ('base', 'nbins')

base: float | None

nbins: int

class sasdata.data_util.averaging.Ringcut(r_range: tuple[float, float] = (0.0, 0.0), phi_range: tuple[float, float] = (0.0, 6.283185307179586), center: tuple[float, float] = (0.0, 0.0))

Bases: PolarROI

Defines a ring on a 2D data set. The ring is defined by r_min, r_max, and the position of the center of the ring.

The data returned is the region inside the ring

Phi_min and phi_max should be defined between 0 and 2*pi in anti-clockwise starting from the x- axis on the left-hand side

__annotations__ = {}

__call__(data2D: Data2D) → ndarray[tuple[Any, ...], dtype[bool]]

Apply the ring to the data set. Returns the angular distribution for a given q range

Parameters:

data2D – Data2D object

Returns:

index array in the range

__doc__ = '\nDefines a ring on a 2D data set.\nThe ring is defined by r_min, r_max, and\nthe position of the center of the ring.\n\nThe data returned is the region inside the ring\n\nPhi_min and phi_max should be defined between 0 and 2*pi\nin anti-clockwise starting from the x- axis on the left-hand side\n'

__firstlineno__ = 925

__init__(r_range: tuple[float, float] = (0.0, 0.0), phi_range: tuple[float, float] = (0.0, 6.283185307179586), center: tuple[float, float] = (0.0, 0.0)) → None

Assign the variables used to label the properties of the Data2D object. Also establish the upper and lower bounds defining the ROI.

The units are A^-1 for radial parameters, and radians for anglar ones. :param r_range: Tuple (r_min, r_max) defining limits for |Q| values to use during averaging. :param phi_range: Tuple (phi_min, phi_max) defining limits for φ in radians (in the ROI).

Note that Phi is measured anti-clockwise from the positive x-axis.

__module__ = 'sasdata.data_util.averaging'

__static_attributes__ = ()

class sasdata.data_util.averaging.SectorPhi(r_min: float, r_max: float, phi_min: float = 0.0, phi_max: float = 6.283185307179586, center: tuple[float, float] = (0.0, 0.0), nbins: int = 100)

Bases: WedgePhi

Sector average as a function of phi. I(phi) is return and the data is averaged over Q.

A sector is defined by r_min, r_max, phi_min, phi_max. The number of bin in phi also has to be defined.

__annotations__ = {}

__doc__ = '\nSector average as a function of phi.\nI(phi) is return and the data is averaged over Q.\n\nA sector is defined by r_min, r_max, phi_min, phi_max.\nThe number of bin in phi also has to be defined.\n'

__firstlineno__ = 892

__init__(r_min: float, r_max: float, phi_min: float = 0.0, phi_max: float = 6.283185307179586, center: tuple[float, float] = (0.0, 0.0), nbins: int = 100) → None

Set up the ROI boundaries, and the binning of the output 1D data.

The units are A^-1 for radial parameters, and radians for anglar ones. :param r_range: Tuple (r_min, r_max) defining limits for |Q| values to use during averaging. :param phi_range: Tuple (phi_min, phi_max) defining angular bounds in radians.

Defaults to full circle (0, 2*pi).

Parameters:

nbins – The number of bins data is sorted into along the φ axis.

__module__ = 'sasdata.data_util.averaging'

__static_attributes__ = ()

class sasdata.data_util.averaging.SectorQ(r_range: tuple[float, float], phi_range: tuple[float, float] = (0.0, 6.283185307179586), center: tuple[float, float] = (0.0, 0.0), nbins: int = 100, fold: bool = True, base: float | None = None)

Bases: PolarROI

Project I(Q, φ) data onto I(Q) within a region defined by Cartesian limits.

The projection is computed by averaging together datapoints with the same angle φ (so long as they are within the ROI), measured anticlockwise from the positive x-axis.

This class is initialised by specifying lower and upper limits on both the magnitude of Q and the angle φ. These four parameters specify the primary Region Of Interest, however there is a secondary ROI with the same |Q| values on the opposite side of the origin (φ + π). How this secondary ROI is treated depends on the value of the fold parameter. If fold is set to True, data on opposite sides of the origin are averaged together and the results are plotted against positive values of Q. If fold is set to False, the data from the two regions are graphed separeately, with the secondary ROI data labelled using negative Q values.

When called, this class is supplied with a Data2D object. It returns a Data1D object where intensity is given as a function of Q only.

__annotations__ = {'base': 'float | None', 'fold': 'bool', 'nbins': 'int'}

__call__(data2d: Data2D) → Data1D

Compute the 1D average of 2D data, projecting along the Q_y axis.

Parameters:

data2d – The Data2D object for which the average is computed.

Returns:

Data1D object for plotting.

__doc__ = '\nProject I(Q, φ) data onto I(Q) within a region defined by Cartesian limits.\n\nThe projection is computed by averaging together datapoints with the same\nangle φ (so long as they are within the ROI), measured anticlockwise from\nthe positive x-axis.\n\nThis class is initialised by specifying lower and upper limits on both the\nmagnitude of Q and the angle φ. These four parameters specify the primary\nRegion Of Interest, however there is a secondary ROI with the same |Q|\nvalues on the opposite side of the origin (φ + π). How this secondary ROI\nis treated depends on the value of the `fold` parameter. If fold is set to\nTrue, data on opposite sides of the origin are averaged together and the\nresults are plotted against positive values of Q. If fold is set to False,\nthe data from the two regions are graphed separeately, with the secondary\nROI data labelled using negative Q values.\n\nWhen called, this class is supplied with a Data2D object. It returns a\nData1D object where intensity is given as a function of Q only.\n'

__firstlineno__ = 551

__init__(r_range: tuple[float, float], phi_range: tuple[float, float] = (0.0, 6.283185307179586), center: tuple[float, float] = (0.0, 0.0), nbins: int = 100, fold: bool = True, base: float | None = None) → None

Set up the ROI boundaries, the binning of the output 1D data, and fold.

The units are A^-1 for radial parameters, and radians for anglar ones. :param r_range: Tuple (r_min, r_max) defining limits for |Q| values to use during averaging. :param phi_range: Tuple (phi_min, phi_max) defining limits for φ in radians (in the primary ROI). :Defaults to full circle (0, 2*pi). :param nbins: The number of bins data is sorted into along the |Q| axis :param fold: Whether the primary and secondary ROIs should be folded

together during averaging.

__module__ = 'sasdata.data_util.averaging'

__static_attributes__ = ('base', 'fold', 'nbins', 'phi_data', 'phi_max', 'phi_min')

base: float | None

fold: bool

nbins: int

class sasdata.data_util.averaging.Sectorcut(phi_range: tuple[float, float] = (0.0, 3.141592653589793), center: tuple[float, float] = (0.0, 0.0))

Bases: PolarROI

Defines a sector (major + minor) region on a 2D data set. The sector is defined by phi_min, phi_max, where phi_min and phi_max are defined by the right and left lines wrt central line.

Phi_min and phi_max are given in units of radian and (phi_max-phi_min) should not be larger than pi

__annotations__ = {}

__call__(data2D: Data2D) → ndarray[tuple[Any, ...], dtype[bool]]

Find a rectangular 2D region of interest where data points inside the ROI are True, and False otherwise

Parameters:

data2D – Data2D object

Returns:

mask, 1d array (len = len(data))

__doc__ = '\nDefines a sector (major + minor) region on a 2D data set.\nThe sector is defined by phi_min, phi_max,\nwhere phi_min and phi_max are defined by the right\nand left lines wrt central line.\n\nPhi_min and phi_max are given in units of radian\nand (phi_max-phi_min) should not be larger than pi\n'

__firstlineno__ = 988

__init__(phi_range: tuple[float, float] = (0.0, 3.141592653589793), center: tuple[float, float] = (0.0, 0.0)) → None

Assign the variables used to label the properties of the Data2D object. Also establish the upper and lower bounds defining the ROI.

The units are A^-1 for radial parameters, and radians for anglar ones. :param r_range: Tuple (r_min, r_max) defining limits for |Q| values to use during averaging. :param phi_range: Tuple (phi_min, phi_max) defining limits for φ in radians (in the ROI).

Note that Phi is measured anti-clockwise from the positive x-axis.

__module__ = 'sasdata.data_util.averaging'

__static_attributes__ = ('phi_data', 'phi_max', 'phi_min')

class sasdata.data_util.averaging.SlabX(qx_range: tuple[float, float] = (0.0, 0.0), qy_range: tuple[float, float] = (0.0, 0.0), nbins: int = 100, fold: bool = False, base: float | None = None)

Bases: CartesianROI

Average I(Q_x, Q_y) along the y direction (within a ROI), giving I(Q_x).

This class is initialised by specifying the boundaries of the ROI and is called by supplying a Data2D object. It returns a Data1D object. The averaging process can also be thought of as projecting 2D -> 1D.

There also exists the option to “fold” the ROI, where Q data on opposite sides of the origin but with equal magnitudes are averaged together, resulting in a 1D plot with only positive Q values shown.

__annotations__ = {'base': 'float | None', 'fold': 'bool', 'nbins': 'int'}

__call__(data2d: Data2D) → Data1D

Compute the 1D average of 2D data, projecting along the Q_x axis.

Parameters:

data2d – The Data2D object for which the average is computed.

Returns:

Data1D object for plotting.

__doc__ = '\nAverage I(Q_x, Q_y) along the y direction (within a ROI), giving I(Q_x).\n\nThis class is initialised by specifying the boundaries of the ROI and is\ncalled by supplying a Data2D object. It returns a Data1D object.\nThe averaging process can also be thought of as projecting 2D -> 1D.\n\nThere also exists the option to "fold" the ROI, where Q data on opposite\nsides of the origin but with equal magnitudes are averaged together,\nresulting in a 1D plot with only positive Q values shown.\n'

__firstlineno__ = 136

__init__(qx_range: tuple[float, float] = (0.0, 0.0), qy_range: tuple[float, float] = (0.0, 0.0), nbins: int = 100, fold: bool = False, base: float | None = None) → None

Set up the ROI boundaries, the binning of the output 1D data, and fold.

The units of these parameters are A^-1 :param qx_range: Bounds of the ROI along the Q_x direction. :param qy_range: Bounds of the ROI along the Q_y direction. :param nbins: The number of bins data is sorted into along Q_x. :param fold: Whether the two halves of the ROI along Q_x should be

folded together during averaging.

__module__ = 'sasdata.data_util.averaging'

__static_attributes__ = ('base', 'fold', 'nbins', 'qx_data')

base: float | None

fold: bool

nbins: int

class sasdata.data_util.averaging.SlabY(qx_range: tuple[float, float] = (0.0, 0.0), qy_range: tuple[float, float] = (0.0, 0.0), nbins: int = 100, fold: bool = False, base: float | None = None)

Bases: CartesianROI

Average I(Q_x, Q_y) along the x direction (within a ROI), giving I(Q_y).

This class is initialised by specifying the boundaries of the ROI and is called by supplying a Data2D object. It returns a Data1D object. The averaging process can also be thought of as projecting 2D -> 1D.

There also exists the option to “fold” the ROI, where Q data on opposite sides of the origin but with equal magnitudes are averaged together, resulting in a 1D plot with only positive Q values shown.

__annotations__ = {'base': 'float | None', 'fold': 'bool', 'nbins': 'int'}

__call__(data2d: Data2D) → Data1D

Compute the 1D average of 2D data, projecting along the Q_y axis.

Parameters:

data2d – The Data2D object for which the average is computed.

Returns:

Data1D object for plotting.

__doc__ = '\nAverage I(Q_x, Q_y) along the x direction (within a ROI), giving I(Q_y).\n\nThis class is initialised by specifying the boundaries of the ROI and is\ncalled by supplying a Data2D object. It returns a Data1D object.\nThe averaging process can also be thought of as projecting 2D -> 1D.\n\nThere also exists the option to "fold" the ROI, where Q data on opposite\nsides of the origin but with equal magnitudes are averaged together,\nresulting in a 1D plot with only positive Q values shown.\n'

__firstlineno__ = 205

__init__(qx_range: tuple[float, float] = (0.0, 0.0), qy_range: tuple[float, float] = (0.0, 0.0), nbins: int = 100, fold: bool = False, base: float | None = None) → None

Set up the ROI boundaries, the binning of the output 1D data, and fold.

The units of these parameters are A^-1 :param qx_range: Bounds of the ROI along the Q_x direction. :param qy_range: Bounds of the ROI along the Q_y direction. :param qy_max: Upper bound of the ROI along the Q_y direction. :param nbins: The number of bins data is sorted into along Q_y. :param fold: Whether the two halves of the ROI along Q_y should be

folded together during averaging.

__module__ = 'sasdata.data_util.averaging'

__static_attributes__ = ('base', 'fold', 'nbins', 'qy_data')

base: float | None

fold: bool

nbins: int

class sasdata.data_util.averaging.WedgePhi(r_range: tuple[float, float], phi_range: tuple[float, float] = (0.0, 6.283185307179586), center: tuple[float, float] = (0.0, 0.0), nbins: int = 100, base: float | None = None)

Bases: PolarROI

Project I(Q, φ) data onto I(φ) within a region defined by Cartesian limits.

The projection is computed by averaging together datapoints with the same Q value (so long as they are within the ROI).

This class is initialised by specifying lower and upper limits on both the magnitude of Q and the angle φ, measured anticlockwise from the positive x-axis. When called, this class is supplied with a Data2D object. It returns a Data1D object where intensity is given as a function of Q only.

__annotations__ = {'base': 'float | None', 'nbins': 'int'}

__call__(data2d: Data2D) → Data1D

Compute the 1D average of 2D data, projecting along the Q_y axis.

Parameters:

data2d – The Data2D object for which the average is computed.

Returns:

Data1D object for plotting.

__doc__ = '\nProject I(Q, φ) data onto I(φ) within a region defined by Cartesian limits.\n\nThe projection is computed by averaging together datapoints with the same\nQ value (so long as they are within the ROI).\n\nThis class is initialised by specifying lower and upper limits on both the\nmagnitude of Q and the angle φ, measured anticlockwise from the positive\nx-axis.\nWhen called, this class is supplied with a Data2D object. It returns a\nData1D object where intensity is given as a function of Q only.\n'

__firstlineno__ = 772

__init__(r_range: tuple[float, float], phi_range: tuple[float, float] = (0.0, 6.283185307179586), center: tuple[float, float] = (0.0, 0.0), nbins: int = 100, base: float | None = None) → None

Set up the ROI boundaries, and the binning of the output 1D data.

The units are A^-1 for radial parameters, and radians for anglar ones. :param r_range: Tuple (r_min, r_max) defining limits for |Q| values to use during averaging. :param phi_range: Tuple (phi_min, phi_max) defining angular bounds in radians.

Defaults to full circle (0, 2*pi).

Parameters:

nbins – The number of bins data is sorted into along the φ axis.

__module__ = 'sasdata.data_util.averaging'

__static_attributes__ = ('base', 'nbins', 'phi_data', 'phi_max', 'phi_min')

base: float | None

nbins: int

class sasdata.data_util.averaging.WedgeQ(r_range: tuple[float, float], phi_range: tuple[float, float] = (0.0, 6.283185307179586), center: tuple[float, float] = (0.0, 0.0), nbins: int = 100, base: float | None = None)

Bases: PolarROI

Project I(Q, φ) data onto I(Q) within a region defined by Cartesian limits.

The projection is computed by averaging together datapoints with the same angle φ (so long as they are within the ROI), measured anticlockwise from the positive x-axis.

This class is initialised by specifying lower and upper limits on both the magnitude of Q and the angle φ. When called, this class is supplied with a Data2D object. It returns a Data1D object where intensity is given as a function of Q only.

__annotations__ = {'base': 'float | None', 'nbins': 'int'}

__call__(data2d: Data2D) → Data1D

Compute the 1D average of 2D data, projecting along the Q_y axis.

Parameters:

data2d – The Data2D object for which the average is computed.

Returns:

Data1D object for plotting.

__doc__ = '\nProject I(Q, φ) data onto I(Q) within a region defined by Cartesian limits.\n\nThe projection is computed by averaging together datapoints with the same\nangle φ (so long as they are within the ROI), measured anticlockwise from\nthe positive x-axis.\n\nThis class is initialised by specifying lower and upper limits on both the\nmagnitude of Q and the angle φ.\nWhen called, this class is supplied with a Data2D object. It returns a\nData1D object where intensity is given as a function of Q only.\n'

__firstlineno__ = 690

__init__(r_range: tuple[float, float], phi_range: tuple[float, float] = (0.0, 6.283185307179586), center: tuple[float, float] = (0.0, 0.0), nbins: int = 100, base: float | None = None) → None

Set up the ROI boundaries, and the binning of the output 1D data.

The units are A^-1 for radial parameters, and radians for anglar ones. :param r_range: Tuple (r_min, r_max) defining limits for |Q| values to use during averaging. :param phi_range: Tuple (phi_min, phi_max) defining limits for φ in radians (in the primary ROI). :Defaults to full circle (0, 2*pi). :param nbins: The number of bins data is sorted into along the |Q| axis

__module__ = 'sasdata.data_util.averaging'

__static_attributes__ = ('base', 'nbins', 'phi_data', 'phi_max', 'phi_min')

base: float | None

nbins: int

sasdata.data_util.averaging.get_dq_data(data2d: Data2D) → ndarray[tuple[Any, ...], dtype[floating]]

Get the dq for resolution averaging The pinholes and det. pix contribution present in both direction of the 2D which must be subtracted when converting to 1D: dq_overlap should be calculated ideally at q = 0. Note This method works on only pinhole geometry. Extrapolate dqx(r) and dqy(phi) at q = 0, and take an average.