pyFAI.detectors package#

Module contents#

Description of all detectors with a factory to instantiate them.

class pyFAI.detectors.ADSC_Q210(pixel1: float | None = None, pixel2: float | None = None, splinefile: str | None = None, max_shape: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#

Bases: _ADSC

ADSC Quantum 210r detector, 2x2 chips

Information from http://www.adsc-xray.com/products/ccd-detectors/q210r-ccd-detector/

Question: how are the gaps handled ?

MAX_SHAPE = (4096, 4096)#
PIXEL_SIZE = (5.1e-05, 5.1e-05)#
aliases = ('Quantum 210',)#
force_pixel = True#
class pyFAI.detectors.ADSC_Q270(pixel1: float | None = None, pixel2: float | None = None, splinefile: str | None = None, max_shape: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#

Bases: _ADSC

ADSC Quantum 270r detector, 2x2 chips

Information from http://www.adsc-xray.com/products/ccd-detectors/q270-ccd-detector/

Question: how are the gaps handled ?

MAX_SHAPE = (4168, 4168)#
PIXEL_SIZE = (5.1e-05, 5.1e-05)#
aliases = ('Quantum 270',)#
force_pixel = True#
class pyFAI.detectors.ADSC_Q315(pixel1: float | None = None, pixel2: float | None = None, splinefile: str | None = None, max_shape: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#

Bases: _ADSC

ADSC Quantum 315r detector, 3x3 chips

Information from http://www.adsc-xray.com/products/ccd-detectors/q315r-ccd-detector/

Question: how are the gaps handled ?

MAX_SHAPE = (6144, 6144)#
PIXEL_SIZE = (5.1e-05, 5.1e-05)#
aliases = ('Quantum 315',)#
force_pixel = True#
class pyFAI.detectors.ADSC_Q4(pixel1: float | None = None, pixel2: float | None = None, splinefile: str | None = None, max_shape: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#

Bases: _ADSC

ADSC Quantum 4r detector, 2x2 chips

Information from http://proteincrystallography.org/detectors/adsc.php

Question: how are the gaps handled ?

MAX_SHAPE = (2304, 2304)#
PIXEL_SIZE = (5.1e-05, 5.1e-05)#
aliases = ('Quantum 4',)#
force_pixel = True#
class pyFAI.detectors.Aarhus(pixel1=2.4893e-05, pixel2=2.4893e-05, radius=0.29989, orientation=0)#

Bases: CylindricalDetector

Cylindrical detector made of a bent imaging-plate. Developed at the Danish university of Aarhus r = 1.2m or 0.3m

Credits: Private communication; B. B. Iversen, Center for Materials Crystallography & Dept. of Chemistry and iNANO, Aarhus University

The image has to be laid-out horizontally

Nota: the detector is bend towards the sample, hence reducing the sample-detector distance. This is why z<0 (or p3<0)

MANUFACTURER = 'Aarhus University'#
MAX_SHAPE = (1000, 16000)#
__init__(pixel1=2.4893e-05, pixel2=2.4893e-05, radius=0.29989, orientation=0)#

Constructor of the Detector class, most of the time, not used. :param pixel1: size of the pixel in meter along the slow dimension (often Y) :param pixel2: size of the pixel in meter along the fast dimension (often X) :param splinefile: path to file containing the geometric correction. :param max_shape: maximum size of the detector :type max_shape: 2-tuple of integers :param orientation: Orientation of the detector :param sensor: Optional sensor configuration specifying detector material and sensor thickness (in metres). :type sensor: SensorConfig | None

class pyFAI.detectors.Apex2(pixel1=0.00012, pixel2=0.00012, max_shape=None, orientation=0)#

Bases: Detector

BrukerApex2 detector

Actually a derivative from the Fairchild detector with higher binning

MANUFACTURER = 'Bruker'#
MAX_SHAPE = (1024, 1024)#
PIXEL_SIZE = (0.00012, 0.00012)#
__init__(pixel1=0.00012, pixel2=0.00012, max_shape=None, orientation=0)#

Defaults to 2x2 binning

aliases = ('ApexII', 'Bruker')#
force_pixel = True#
class pyFAI.detectors.Basler(pixel1: float | None = None, pixel2: float | None = None, splinefile: str | None = None, max_shape: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#

Bases: Detector

Basler camera are simple CCD camara over GigaE

MANUFACTURER = 'Basler'#
MAX_SHAPE = (966, 1296)#
PIXEL_SIZE = (3.75e-06, 3.75e-06)#
aliases = ('aca1300',)#
force_pixel = True#
class pyFAI.detectors.Cirpad(pixel1=0.00013, pixel2=0.00013, max_shape=None, module_size=None, orientation=0, sensor: SensorConfig | None = None)#

Bases: ImXPadS10

DIFFERENT_PIXEL_SIZE = 2.5#
IS_CONTIGUOUS = False#
IS_FLAT = False#
MAX_SHAPE = (11200, 120)#
MEDIUM_MODULE_SIZE = (560, 120)#
MODULE_SIZE = (80, 120)#
PIXEL_SIZE = (0.00013, 0.00013)#
ROT = (0, 0, -6.74)#
__init__(pixel1=0.00013, pixel2=0.00013, max_shape=None, module_size=None, orientation=0, sensor: SensorConfig | None = None)#

Constructor of the Detector class, most of the time, not used. :param pixel1: size of the pixel in meter along the slow dimension (often Y) :param pixel2: size of the pixel in meter along the fast dimension (often X) :param splinefile: path to file containing the geometric correction. :param max_shape: maximum size of the detector :type max_shape: 2-tuple of integers :param orientation: Orientation of the detector :param sensor: Optional sensor configuration specifying detector material and sensor thickness (in metres). :type sensor: SensorConfig | None

aliases = ('CirPAD', 'XCirpad')#
calc_cartesian_positions(d1=None, d2=None, center=True, use_cython=True)#

Calculate the position of each pixel center in cartesian coordinate and in meter of a couple of coordinates. The half pixel offset is taken into account here !!!

Parameters:
  • d1 (ndarray (1D or 2D)) – the Y pixel positions (slow dimension)

  • d2 (ndarray (1D or 2D)) – the X pixel positions (fast dimension)

Returns:

position in meter of the center of each pixels.

Return type:

ndarray

d1 and d2 must have the same shape, returned array will have the same shape.

force_pixel = True#
get_pixel_corners(correct_binning=False)#

Calculate the position of the corner of the pixels

This should be overwritten by class representing non-contiguous detector (Xpad, …)

Precision float32 is ok: precision of 1µm for a detector size of 1m

Returns:

4D array containing: pixel index (slow dimension) pixel index (fast dimension) corner index (A, B, C or D), triangles or hexagons can be handled the same way vertex position (z,y,x)

uniform_pixel = False#
class pyFAI.detectors.CylindricalDetector(pixel1=2.4893e-05, pixel2=2.4893e-05, radius=0.29989, orientation=0, sensor: SensorConfig | None = None)#

Bases: Detector

Abstract base class for all cylindrical detecors

IS_FLAT = False#
MANUFACTURER = None#
__init__(pixel1=2.4893e-05, pixel2=2.4893e-05, radius=0.29989, orientation=0, sensor: SensorConfig | None = None)#

Constructor of the Detector class, most of the time, not used. :param pixel1: size of the pixel in meter along the slow dimension (often Y) :param pixel2: size of the pixel in meter along the fast dimension (often X) :param splinefile: path to file containing the geometric correction. :param max_shape: maximum size of the detector :type max_shape: 2-tuple of integers :param orientation: Orientation of the detector :param sensor: Optional sensor configuration specifying detector material and sensor thickness (in metres). :type sensor: SensorConfig | None

calc_cartesian_positions(d1=None, d2=None, center=True, use_cython=True)#

Calculate the position of each pixel center in cartesian coordinate and in meter of a couple of coordinates. The half pixel offset is taken into account here !!! Adapted to Nexus detector definition

Parameters:
  • d1 (ndarray (1D or 2D)) – the Y pixel positions (slow dimension)

  • d2 (ndarray (1D or 2D)) – the X pixel positions (fast dimension)

  • center – retrieve the coordinate of the center of the pixel

  • use_cython – set to False to test Python implementation

Returns:

position in meter of the center of each pixels.

Return type:

ndarray

d1 and d2 must have the same shape, returned array will have the same shape.

force_pixel = True#
get_config()#

Return the configuration with arguments to the constructor

Returns:

dict with param for serialization

get_pixel_corners(correct_binning=False, use_cython=True)#

Calculate the position of the corner of the pixels

This should be overwritten by class representing non-contiguous detector (Xpad, …) :param correct_binning: If True, check that the produced array have the right shape regarding binning :param use_cython: set to False for testing :return: 4D array containing:

  • pixel index (slow dimension)

  • pixel index (fast dimension)

  • corner index (A, B, C or D), triangles or hexagons can be handled the same way

  • vertex position (z,y,x)

set_config(config)#

Sets the configuration of the detector.

The configuration is either a python dictionary or a JSON string or a file containing this JSON configuration

keys in that dictionary are: pixel1, pixel2, radius

Parameters:

config – string or JSON-serialized dict

Returns:

self

class pyFAI.detectors.Detector(pixel1: float | None = None, pixel2: float | None = None, splinefile: str | None = None, max_shape: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#

Bases: object

Generic class representing a 2D detector

API_VERSION = '1.2'#
CORNERS = 4#
DELTA_DUMMY = None#
DUMMY = None#
HAVE_TAPER = False#

If true a spline file is mandatory to correct the geometry

IS_CONTIGUOUS = True#
IS_FLAT = True#
MANUFACTURER = None#
ORIENTATION = 0#
SENSORS = ()#
__init__(pixel1: float | None = None, pixel2: float | None = None, splinefile: str | None = None, max_shape: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#

Constructor of the Detector class, most of the time, not used. :param pixel1: size of the pixel in meter along the slow dimension (often Y) :param pixel2: size of the pixel in meter along the fast dimension (often X) :param splinefile: path to file containing the geometric correction. :param max_shape: maximum size of the detector :type max_shape: 2-tuple of integers :param orientation: Orientation of the detector :param sensor: Optional sensor configuration specifying detector material and sensor thickness (in metres). :type sensor: SensorConfig | None

aliases = ()#
property binning: tuple[int, int]#
calc_cartesian_positions(d1=None, d2=None, center=True, use_cython=True)#

Calculate the position of each pixel center in cartesian coordinate and in meter of a couple of coordinates. The half pixel offset is taken into account here !!! Adapted to Nexus detector definition

Parameters:
  • d1 (ndarray (1D or 2D)) – the Y pixel positions (slow dimension)

  • d2 (ndarray (1D or 2D)) – the X pixel positions (fast dimension)

  • center – retrieve the coordinate of the center of the pixel, unless gives one corner

  • use_cython – set to False to test Python implementation

Returns:

position in meter of the center of each pixels.

Return type:

3xndarray, the later being None if IS_FLAT

d1 and d2 must have the same shape, returned array will have the same shape.

pos_z is None for flat detectors

calc_mask()#

Method calculating the mask for a given detector

Detectors with gaps should overwrite this method with something actually calculating the mask!

Returns:

the mask with valid pixel to 0

Return type:

numpy ndarray of int8 or None

property darkcurrent#
classmethod default_sensor() → SensorConfig | None#

Sensor assumed for this detector when the user does not provide one.

This is the first entry of SENSORS, the allowed sensors of the detector. When several are possible, it is logged that the first one is assumed. Detectors which do not know their sensor (empty SENSORS) return None.

Returns:

a new SensorConfig (the instances are mutable), or None

property delta_dummy#
property dummy#
dynamic_mask(img)#

Calculate the dynamic mask for the given image.

This uses the dummy and delta_dummy properties in addition to the static mask.

Parameters:

img – 2D array with the image to analyse

Returns:

the mask with valid pixel to 0

Return type:

numpy ndarray of int8 or None

classmethod factory(name: str, config: None | str | dict[str, Any] = None)#

Create a pyFAI detector from a name.

If the detector is a known detector class, config in injected as constructor arguments.

If the name is an existing hdf5 filename, the config argument is ignored.

Parameters:
  • name (str) – A name of a detector or an existing hdf5 detector description file.

  • config (dict or JSON representation of it.) – configuration of the detector

Returns:

an instance of the right detector, set-up if possible

Return type:

pyFAI.detectors.Detector

property flatfield#
force_pixel = False#
classmethod from_dict(dico)#

Creates a brand new detector from the description of the detector as a dict

Parameters:

dico – JSON serializable dictionary

Returns:

Detector instance

getFit2D() → dict#

Helper method to serialize the description of a detector using the Fit2d units

Returns:

representation of the detector easy to serialize

Return type:

dict

getPyFAI() → dict#

Helper method to serialize the description of a detector using the pyFAI way with everything in S.I units.

Returns:

representation of the detector easy to serialize

Return type:

dict

get_binning() → tuple[int, int]#
get_config()#

Return the configuration with arguments to the constructor

Derivative classes should implement this method if they change the constructor!

Returns:

dict with param for serialization

get_darkcurrent()#
get_darkcurrent_crc()#
get_dummies(img)#

Calculate the actual dummy value from dtype of the img

Parameters:

img – numpy array (or actually its dtype)

Returns:

actual (dummy, delta_dummy) values as data_d (i.e. float32)

get_flatfield()#
get_flatfield_crc()#
get_mask()#
get_mask_crc()#
get_maskfile()#
get_name()#

Get a meaningful name for detector

get_pixel1() → float#
get_pixel2() → float#
get_pixel_corners(correct_binning=False)#

Calculate the position of the corner of the pixels

This should be overwritten by class representing non-contiguous detector (Xpad, …)

Precision float32 is ok: precision of 1µm for a detector size of 1m :param correct_binning: If True, check that the produced array have the right shape regarding binning :return: 4D array containing …

  • pixel index (slow dimension)

  • pixel index (fast dimension)

  • corner index (A, B, C or D), triangles or hexagons can be handled the same way

  • vertex position (z,y,x)

get_splineFile() → str#
guess_binning(data)#

Guess the binning/mode depending on the image shape

If the binning changes, this enforces the reset of the mask.

Parameters:

data – 2-tuple with the shape of the image or the image with a .shape attribute.

Returns:

True if the data fit the detector

Return type:

bool

property mask#
property maskfile#
property name#

Get a meaningful name for detector

property orientation#
property origin#

What are the coordinates of the detector’s origin ?

property pixel1: float#
property pixel2: float#
registry: ClassVar[dict] = {'aarhus': <class 'pyFAI.detectors._non_flat.Aarhus'>, 'aca1300': <class 'pyFAI.detectors._others.Basler'>, 'adsc_q210': <class 'pyFAI.detectors._adsc.ADSC_Q210'>, 'adsc_q270': <class 'pyFAI.detectors._adsc.ADSC_Q270'>, 'adsc_q315': <class 'pyFAI.detectors._adsc.ADSC_Q315'>, 'adsc_q4': <class 'pyFAI.detectors._adsc.ADSC_Q4'>, 'agilent_titan': <class 'pyFAI.detectors._others.Titan'>, 'agilenttitan': <class 'pyFAI.detectors._others.Titan'>, 'apex2': <class 'pyFAI.detectors._others.Apex2'>, 'apexii': <class 'pyFAI.detectors._others.Apex2'>, 'basler': <class 'pyFAI.detectors._others.Basler'>, 'bruker': <class 'pyFAI.detectors._others.Apex2'>, 'cirpad': <class 'pyFAI.detectors._imxpad.Cirpad'>, 'condor': <class 'pyFAI.detectors._others.Fairchild'>, 'd5': <class 'pyFAI.detectors._imxpad.Xpad_flat'>, 'detector': <class 'pyFAI.detectors._common.Detector'>, 'dexela2923': <class 'pyFAI.detectors._others.Dexela2923'>, 'dexela_2923': <class 'pyFAI.detectors._others.Dexela2923'>, 'eiger16m': <class 'pyFAI.detectors._dectris.Eiger16M'>, 'eiger1m': <class 'pyFAI.detectors._dectris.Eiger1M'>, 'eiger216m': <class 'pyFAI.detectors._dectris.Eiger2_16M'>, 'eiger21m': <class 'pyFAI.detectors._dectris.Eiger2_1M'>, 'eiger21m-w': <class 'pyFAI.detectors._dectris.Eiger2_1MW'>, 'eiger2250k': <class 'pyFAI.detectors._dectris.Eiger2_250k'>, 'eiger22m-w': <class 'pyFAI.detectors._dectris.Eiger2_2MW'>, 'eiger24m': <class 'pyFAI.detectors._dectris.Eiger2_4M'>, 'eiger2500k': <class 'pyFAI.detectors._dectris.Eiger2_500k'>, 'eiger29m': <class 'pyFAI.detectors._dectris.Eiger2_9M'>, 'eiger2_16m': <class 'pyFAI.detectors._dectris.Eiger2_16M'>, 'eiger2_1m': <class 'pyFAI.detectors._dectris.Eiger2_1M'>, 'eiger2_1m-w': <class 'pyFAI.detectors._dectris.Eiger2_1MW'>, 'eiger2_1mw': <class 'pyFAI.detectors._dectris.Eiger2_1MW'>, 'eiger2_250k': <class 'pyFAI.detectors._dectris.Eiger2_250k'>, 'eiger2_2m-w': <class 'pyFAI.detectors._dectris.Eiger2_2MW'>, 'eiger2_2mw': <class 'pyFAI.detectors._dectris.Eiger2_2MW'>, 'eiger2_4m': <class 'pyFAI.detectors._dectris.Eiger2_4M'>, 'eiger2_500k': <class 'pyFAI.detectors._dectris.Eiger2_500k'>, 'eiger2_9m': <class 'pyFAI.detectors._dectris.Eiger2_9M'>, 'eiger2_cdte_16m': <class 'pyFAI.detectors._dectris.Eiger2CdTe_16M'>, 'eiger2_cdte_1m': <class 'pyFAI.detectors._dectris.Eiger2CdTe_1M'>, 'eiger2_cdte_1m-w': <class 'pyFAI.detectors._dectris.Eiger2CdTe_1MW'>, 'eiger2_cdte_2m-w': <class 'pyFAI.detectors._dectris.Eiger2CdTe_2MW'>, 'eiger2_cdte_4m': <class 'pyFAI.detectors._dectris.Eiger2CdTe_4M'>, 'eiger2_cdte_500k': <class 'pyFAI.detectors._dectris.Eiger2CdTe_500k'>, 'eiger2_cdte_9m': <class 'pyFAI.detectors._dectris.Eiger2CdTe_9M'>, 'eiger2cdte16m': <class 'pyFAI.detectors._dectris.Eiger2CdTe_16M'>, 'eiger2cdte1m': <class 'pyFAI.detectors._dectris.Eiger2CdTe_1M'>, 'eiger2cdte1m-w': <class 'pyFAI.detectors._dectris.Eiger2CdTe_1MW'>, 'eiger2cdte2m-w': <class 'pyFAI.detectors._dectris.Eiger2CdTe_2MW'>, 'eiger2cdte4m': <class 'pyFAI.detectors._dectris.Eiger2CdTe_4M'>, 'eiger2cdte500k': <class 'pyFAI.detectors._dectris.Eiger2CdTe_500k'>, 'eiger2cdte9m': <class 'pyFAI.detectors._dectris.Eiger2CdTe_9M'>, 'eiger2cdte_16m': <class 'pyFAI.detectors._dectris.Eiger2CdTe_16M'>, 'eiger2cdte_1m': <class 'pyFAI.detectors._dectris.Eiger2CdTe_1M'>, 'eiger2cdte_1mw': <class 'pyFAI.detectors._dectris.Eiger2CdTe_1MW'>, 'eiger2cdte_2mw': <class 'pyFAI.detectors._dectris.Eiger2CdTe_2MW'>, 'eiger2cdte_4m': <class 'pyFAI.detectors._dectris.Eiger2CdTe_4M'>, 'eiger2cdte_500k': <class 'pyFAI.detectors._dectris.Eiger2CdTe_500k'>, 'eiger2cdte_9m': <class 'pyFAI.detectors._dectris.Eiger2CdTe_9M'>, 'eiger4m': <class 'pyFAI.detectors._dectris.Eiger4M'>, 'eiger500k': <class 'pyFAI.detectors._dectris.Eiger500k'>, 'eiger9m': <class 'pyFAI.detectors._dectris.Eiger9M'>, 'eiger_16m': <class 'pyFAI.detectors._dectris.Eiger16M'>, 'eiger_1m': <class 'pyFAI.detectors._dectris.Eiger1M'>, 'eiger_4m': <class 'pyFAI.detectors._dectris.Eiger4M'>, 'eiger_500k': <class 'pyFAI.detectors._dectris.Eiger500k'>, 'eiger_9m': <class 'pyFAI.detectors._dectris.Eiger9M'>, 'fairchild': <class 'pyFAI.detectors._others.Fairchild'>, 'fairchild_condor_486:90': <class 'pyFAI.detectors._others.Fairchild'>, 'fairchildcondor486:90': <class 'pyFAI.detectors._others.Fairchild'>, 'frelon': <class 'pyFAI.detectors._esrf.FReLoN'>, 'hf-130k': <class 'pyFAI.detectors._adsc.HF_130K'>, 'hf-1m': <class 'pyFAI.detectors._adsc.HF_1M'>, 'hf-2.4m': <class 'pyFAI.detectors._adsc.HF_2M'>, 'hf-262k': <class 'pyFAI.detectors._adsc.HF_262k'>, 'hf-4m': <class 'pyFAI.detectors._adsc.HF_4M'>, 'hf-9.4m': <class 'pyFAI.detectors._adsc.HF_9M'>, 'hf_130k': <class 'pyFAI.detectors._adsc.HF_130K'>, 'hf_1m': <class 'pyFAI.detectors._adsc.HF_1M'>, 'hf_262k': <class 'pyFAI.detectors._adsc.HF_262k'>, 'hf_2m': <class 'pyFAI.detectors._adsc.HF_2M'>, 'hf_4m': <class 'pyFAI.detectors._adsc.HF_4M'>, 'hf_9m': <class 'pyFAI.detectors._adsc.HF_9M'>, 'imxpad_s10': <class 'pyFAI.detectors._imxpad.ImXPadS10'>, 'imxpad_s140': <class 'pyFAI.detectors._imxpad.ImXPadS140'>, 'imxpad_s70': <class 'pyFAI.detectors._imxpad.ImXPadS70'>, 'imxpad_s70_v': <class 'pyFAI.detectors._imxpad.ImXPadS70V'>, 'imxpads10': <class 'pyFAI.detectors._imxpad.ImXPadS10'>, 'imxpads140': <class 'pyFAI.detectors._imxpad.ImXPadS140'>, 'imxpads70': <class 'pyFAI.detectors._imxpad.ImXPadS70'>, 'imxpads70v': <class 'pyFAI.detectors._imxpad.ImXPadS70V'>, 'jungfrau': <class 'pyFAI.detectors._psi.Jungfrau'>, 'jungfrau16mcor': <class 'pyFAI.detectors._psi.Jungfrau_16M_cor'>, 'jungfrau1m': <class 'pyFAI.detectors._psi.Jungfrau1M'>, 'jungfrau4m': <class 'pyFAI.detectors._psi.Jungfrau4M'>, 'jungfrau500k': <class 'pyFAI.detectors._psi.Jungfrau'>, 'jungfrau8m': <class 'pyFAI.detectors._psi.Jungfrau8M'>, 'jungfrau_16m_cor': <class 'pyFAI.detectors._psi.Jungfrau_16M_cor'>, 'jungfrau_1m': <class 'pyFAI.detectors._psi.Jungfrau1M'>, 'jungfrau_4m': <class 'pyFAI.detectors._psi.Jungfrau4M'>, 'jungfrau_500k': <class 'pyFAI.detectors._psi.Jungfrau'>, 'jungfrau_8m': <class 'pyFAI.detectors._psi.Jungfrau8M'>, 'lambda10m': <class 'pyFAI.detectors._xspectrum.Lambda10M'>, 'lambda250k': <class 'pyFAI.detectors._xspectrum.Lambda250k'>, 'lambda2m': <class 'pyFAI.detectors._xspectrum.Lambda2M'>, 'lambda60k': <class 'pyFAI.detectors._xspectrum.Lambda60k'>, 'lambda7.5m': <class 'pyFAI.detectors._xspectrum.Lambda7M5'>, 'lambda750k': <class 'pyFAI.detectors._xspectrum.Lambda750k'>, 'lambda7m5': <class 'pyFAI.detectors._xspectrum.Lambda7M5'>, 'lambda9m': <class 'pyFAI.detectors._xspectrum.Lambda9M'>, 'lambda_10m': <class 'pyFAI.detectors._xspectrum.Lambda10M'>, 'lambda_250k': <class 'pyFAI.detectors._xspectrum.Lambda250k'>, 'lambda_2m': <class 'pyFAI.detectors._xspectrum.Lambda2M'>, 'lambda_60k': <class 'pyFAI.detectors._xspectrum.Lambda60k'>, 'lambda_7.5m': <class 'pyFAI.detectors._xspectrum.Lambda7M5'>, 'lambda_750k': <class 'pyFAI.detectors._xspectrum.Lambda750k'>, 'lambda_9m': <class 'pyFAI.detectors._xspectrum.Lambda9M'>, 'mar133': <class 'pyFAI.detectors._rayonix.Rayonix133'>, 'mar165': <class 'pyFAI.detectors._rayonix.RayonixSx165'>, 'mar225': <class 'pyFAI.detectors._rayonix.RayonixMx225'>, 'mar300': <class 'pyFAI.detectors._rayonix.RayonixMx300'>, 'mar345': <class 'pyFAI.detectors._rayonix.Mar345'>, 'mar3450': <class 'pyFAI.detectors._rayonix.Mar345'>, 'mar555': <class 'pyFAI.detectors._rayonix.Mar555'>, 'mar_133': <class 'pyFAI.detectors._rayonix.Rayonix133'>, 'mar_165': <class 'pyFAI.detectors._rayonix.RayonixSx165'>, 'mar_225': <class 'pyFAI.detectors._rayonix.RayonixMx225'>, 'mar_300': <class 'pyFAI.detectors._rayonix.RayonixMx300'>, 'mar_345': <class 'pyFAI.detectors._rayonix.Mar345'>, 'mar_555': <class 'pyFAI.detectors._rayonix.Mar555'>, 'maxipix': <class 'pyFAI.detectors._esrf.Maxipix'>, 'maxipix1x1': <class 'pyFAI.detectors._esrf.Maxipix'>, 'maxipix2x2': <class 'pyFAI.detectors._esrf.Maxipix2x2'>, 'maxipix5x1': <class 'pyFAI.detectors._esrf.Maxipix5x1'>, 'maxipix_1x1': <class 'pyFAI.detectors._esrf.Maxipix'>, 'maxipix_2x2': <class 'pyFAI.detectors._esrf.Maxipix2x2'>, 'maxipix_5x1': <class 'pyFAI.detectors._esrf.Maxipix5x1'>, 'mythen': <class 'pyFAI.detectors._dectris.Mythen'>, 'mythen1280': <class 'pyFAI.detectors._dectris.Mythen'>, 'mythen_1280': <class 'pyFAI.detectors._dectris.Mythen'>, 'oxd_titan': <class 'pyFAI.detectors._others.Titan'>, 'oxdtitan': <class 'pyFAI.detectors._others.Titan'>, 'perkin': <class 'pyFAI.detectors._others.Perkin'>, 'perkin_detector': <class 'pyFAI.detectors._others.Perkin'>, 'perkin_elmer': <class 'pyFAI.detectors._others.Perkin'>, 'perkindetector': <class 'pyFAI.detectors._others.Perkin'>, 'perkinelmer': <class 'pyFAI.detectors._others.Perkin'>, 'picam_hq': <class 'pyFAI.detectors._others.RaspberryPi12M'>, 'picam_v1': <class 'pyFAI.detectors._others.RaspberryPi5M'>, 'picam_v2': <class 'pyFAI.detectors._others.RaspberryPi8M'>, 'picamhq': <class 'pyFAI.detectors._others.RaspberryPi12M'>, 'picamv1': <class 'pyFAI.detectors._others.RaspberryPi5M'>, 'picamv2': <class 'pyFAI.detectors._others.RaspberryPi8M'>, 'pilatus100k': <class 'pyFAI.detectors._dectris.Pilatus100k'>, 'pilatus1m': <class 'pyFAI.detectors._dectris.Pilatus1M'>, 'pilatus1m_cdte': <class 'pyFAI.detectors._dectris.PilatusCdTe1M'>, 'pilatus1mcdte': <class 'pyFAI.detectors._dectris.PilatusCdTe1M'>, 'pilatus200k': <class 'pyFAI.detectors._dectris.Pilatus200k'>, 'pilatus2m': <class 'pyFAI.detectors._dectris.Pilatus2M'>, 'pilatus2m_cdte': <class 'pyFAI.detectors._dectris.PilatusCdTe2M'>, 'pilatus2mcdte': <class 'pyFAI.detectors._dectris.PilatusCdTe2M'>, 'pilatus300k': <class 'pyFAI.detectors._dectris.Pilatus300k'>, 'pilatus300k_cdte': <class 'pyFAI.detectors._dectris.PilatusCdTe300k'>, 'pilatus300kcdte': <class 'pyFAI.detectors._dectris.PilatusCdTe300k'>, 'pilatus300kw': <class 'pyFAI.detectors._dectris.Pilatus300kw'>, 'pilatus300kw_cdte': <class 'pyFAI.detectors._dectris.PilatusCdTe300kw'>, 'pilatus300kwcdte': <class 'pyFAI.detectors._dectris.PilatusCdTe300kw'>, 'pilatus41m': <class 'pyFAI.detectors._dectris.Pilatus4_1M'>, 'pilatus41mcdte': <class 'pyFAI.detectors._dectris.Pilatus4_CdTe_1M'>, 'pilatus4260k': <class 'pyFAI.detectors._dectris.Pilatus4_260k'>, 'pilatus4260kcdte': <class 'pyFAI.detectors._dectris.Pilatus4_CdTe_260k'>, 'pilatus4260kw': <class 'pyFAI.detectors._dectris.Pilatus4_260kw'>, 'pilatus4260kwcdte': <class 'pyFAI.detectors._dectris.Pilatus4_CdTe_260kw'>, 'pilatus42m': <class 'pyFAI.detectors._dectris.Pilatus4_2M'>, 'pilatus42mcdte': <class 'pyFAI.detectors._dectris.Pilatus4_CdTe_2M'>, 'pilatus44m': <class 'pyFAI.detectors._dectris.Pilatus4_4M'>, 'pilatus44mcdte': <class 'pyFAI.detectors._dectris.Pilatus4_CdTe_4M'>, 'pilatus4_1m': <class 'pyFAI.detectors._dectris.Pilatus4_1M'>, 'pilatus4_1m_cdte': <class 'pyFAI.detectors._dectris.Pilatus4_CdTe_1M'>, 'pilatus4_260k': <class 'pyFAI.detectors._dectris.Pilatus4_260k'>, 'pilatus4_260k_cdte': <class 'pyFAI.detectors._dectris.Pilatus4_CdTe_260k'>, 'pilatus4_260kw': <class 'pyFAI.detectors._dectris.Pilatus4_260kw'>, 'pilatus4_260kw_cdte': <class 'pyFAI.detectors._dectris.Pilatus4_CdTe_260kw'>, 'pilatus4_2m': <class 'pyFAI.detectors._dectris.Pilatus4_2M'>, 'pilatus4_2m_cdte': <class 'pyFAI.detectors._dectris.Pilatus4_CdTe_2M'>, 'pilatus4_4m': <class 'pyFAI.detectors._dectris.Pilatus4_4M'>, 'pilatus4_4m_cdte': <class 'pyFAI.detectors._dectris.Pilatus4_CdTe_4M'>, 'pilatus4_cdte_1m': <class 'pyFAI.detectors._dectris.Pilatus4_CdTe_1M'>, 'pilatus4_cdte_260k': <class 'pyFAI.detectors._dectris.Pilatus4_CdTe_260k'>, 'pilatus4_cdte_260kw': <class 'pyFAI.detectors._dectris.Pilatus4_CdTe_260kw'>, 'pilatus4_cdte_2m': <class 'pyFAI.detectors._dectris.Pilatus4_CdTe_2M'>, 'pilatus4_cdte_4m': <class 'pyFAI.detectors._dectris.Pilatus4_CdTe_4M'>, 'pilatus6m': <class 'pyFAI.detectors._dectris.Pilatus6M'>, 'pilatus900k': <class 'pyFAI.detectors._dectris.Pilatus900k'>, 'pilatus900kw_cdte': <class 'pyFAI.detectors._dectris.PilatusCdTe900kw'>, 'pilatus900kwcdte': <class 'pyFAI.detectors._dectris.PilatusCdTe900kw'>, 'pilatus_100k': <class 'pyFAI.detectors._dectris.Pilatus100k'>, 'pilatus_1m': <class 'pyFAI.detectors._dectris.Pilatus1M'>, 'pilatus_1m_cdte': <class 'pyFAI.detectors._dectris.PilatusCdTe1M'>, 'pilatus_200k': <class 'pyFAI.detectors._dectris.Pilatus200k'>, 'pilatus_2m': <class 'pyFAI.detectors._dectris.Pilatus2M'>, 'pilatus_2m_cdte': <class 'pyFAI.detectors._dectris.PilatusCdTe2M'>, 'pilatus_300k': <class 'pyFAI.detectors._dectris.Pilatus300k'>, 'pilatus_300k_cdte': <class 'pyFAI.detectors._dectris.PilatusCdTe300k'>, 'pilatus_300kw': <class 'pyFAI.detectors._dectris.Pilatus300kw'>, 'pilatus_300kw_cdte': <class 'pyFAI.detectors._dectris.PilatusCdTe300kw'>, 'pilatus_6m': <class 'pyFAI.detectors._dectris.Pilatus6M'>, 'pilatus_900k': <class 'pyFAI.detectors._dectris.Pilatus900k'>, 'pilatus_900kw_cdte': <class 'pyFAI.detectors._dectris.PilatusCdTe900kw'>, 'pilatus_cdte_1m': <class 'pyFAI.detectors._dectris.PilatusCdTe1M'>, 'pilatus_cdte_2m': <class 'pyFAI.detectors._dectris.PilatusCdTe2M'>, 'pilatus_cdte_300k': <class 'pyFAI.detectors._dectris.PilatusCdTe300k'>, 'pilatus_cdte_300kw': <class 'pyFAI.detectors._dectris.PilatusCdTe300kw'>, 'pilatus_cdte_900kw': <class 'pyFAI.detectors._dectris.PilatusCdTe900kw'>, 'pilatuscdte1m': <class 'pyFAI.detectors._dectris.PilatusCdTe1M'>, 'pilatuscdte2m': <class 'pyFAI.detectors._dectris.PilatusCdTe2M'>, 'pilatuscdte300k': <class 'pyFAI.detectors._dectris.PilatusCdTe300k'>, 'pilatuscdte300kw': <class 'pyFAI.detectors._dectris.PilatusCdTe300kw'>, 'pilatuscdte900kw': <class 'pyFAI.detectors._dectris.PilatusCdTe900kw'>, 'pixirad-1': <class 'pyFAI.detectors._hexagonal.Pixirad1'>, 'pixirad-2': <class 'pyFAI.detectors._hexagonal.Pixirad2'>, 'pixirad-4': <class 'pyFAI.detectors._hexagonal.Pixirad4'>, 'pixirad-8': <class 'pyFAI.detectors._hexagonal.Pixirad8'>, 'pixirad1': <class 'pyFAI.detectors._hexagonal.Pixirad1'>, 'pixirad2': <class 'pyFAI.detectors._hexagonal.Pixirad2'>, 'pixirad4': <class 'pyFAI.detectors._hexagonal.Pixirad4'>, 'pixirad8': <class 'pyFAI.detectors._hexagonal.Pixirad8'>, 'pixium': <class 'pyFAI.detectors._others.Pixium'>, 'pixium4700': <class 'pyFAI.detectors._others.Pixium'>, 'pixium4700detector': <class 'pyFAI.detectors._others.Pixium'>, 'pixium_4700': <class 'pyFAI.detectors._others.Pixium'>, 'pixium_4700_detector': <class 'pyFAI.detectors._others.Pixium'>, 'quantum210': <class 'pyFAI.detectors._adsc.ADSC_Q210'>, 'quantum270': <class 'pyFAI.detectors._adsc.ADSC_Q270'>, 'quantum315': <class 'pyFAI.detectors._adsc.ADSC_Q315'>, 'quantum4': <class 'pyFAI.detectors._adsc.ADSC_Q4'>, 'quantum_210': <class 'pyFAI.detectors._adsc.ADSC_Q210'>, 'quantum_270': <class 'pyFAI.detectors._adsc.ADSC_Q270'>, 'quantum_315': <class 'pyFAI.detectors._adsc.ADSC_Q315'>, 'quantum_4': <class 'pyFAI.detectors._adsc.ADSC_Q4'>, 'rapid': <class 'pyFAI.detectors._non_flat.Rapid'>, 'rapidii': <class 'pyFAI.detectors._non_flat.Rapid'>, 'raspberrypi12m': <class 'pyFAI.detectors._others.RaspberryPi12M'>, 'raspberrypi5m': <class 'pyFAI.detectors._others.RaspberryPi5M'>, 'raspberrypi8m': <class 'pyFAI.detectors._others.RaspberryPi8M'>, 'rayonix133': <class 'pyFAI.detectors._rayonix.Rayonix133'>, 'rayonix_lx170': <class 'pyFAI.detectors._rayonix.RayonixLx170'>, 'rayonix_lx170-hs': <class 'pyFAI.detectors._rayonix.RayonixLx170'>, 'rayonix_lx170_hs': <class 'pyFAI.detectors._rayonix.RayonixLx170'>, 'rayonix_lx255': <class 'pyFAI.detectors._rayonix.RayonixLx255'>, 'rayonix_lx255-hs': <class 'pyFAI.detectors._rayonix.RayonixLx255'>, 'rayonix_lx_255hs': <class 'pyFAI.detectors._rayonix.RayonixLx255'>, 'rayonix_mx170': <class 'pyFAI.detectors._rayonix.RayonixMx170'>, 'rayonix_mx170-hs': <class 'pyFAI.detectors._rayonix.RayonixMx170'>, 'rayonix_mx170_hs': <class 'pyFAI.detectors._rayonix.RayonixMx170'>, 'rayonix_mx225': <class 'pyFAI.detectors._rayonix.RayonixMx225'>, 'rayonix_mx225_hs': <class 'pyFAI.detectors._rayonix.RayonixMx225hs'>, 'rayonix_mx225hs': <class 'pyFAI.detectors._rayonix.RayonixMx225hs'>, 'rayonix_mx300': <class 'pyFAI.detectors._rayonix.RayonixMx300'>, 'rayonix_mx300_hs': <class 'pyFAI.detectors._rayonix.RayonixMx300hs'>, 'rayonix_mx300hs': <class 'pyFAI.detectors._rayonix.RayonixMx300hs'>, 'rayonix_mx325': <class 'pyFAI.detectors._rayonix.RayonixMx325'>, 'rayonix_mx340hs': <class 'pyFAI.detectors._rayonix.RayonixMx340hs'>, 'rayonix_mx425_hs': <class 'pyFAI.detectors._rayonix.RayonixMx425hs'>, 'rayonix_mx425hs': <class 'pyFAI.detectors._rayonix.RayonixMx425hs'>, 'rayonix_sx165': <class 'pyFAI.detectors._rayonix.RayonixSx165'>, 'rayonix_sx200': <class 'pyFAI.detectors._rayonix.RayonixSx200'>, 'rayonix_sx30_hs': <class 'pyFAI.detectors._rayonix.RayonixSx30hs'>, 'rayonix_sx30hs': <class 'pyFAI.detectors._rayonix.RayonixSx30hs'>, 'rayonix_sx85_hs': <class 'pyFAI.detectors._rayonix.RayonixSx85hs'>, 'rayonix_sx85hs': <class 'pyFAI.detectors._rayonix.RayonixSx85hs'>, 'rayonixlx170': <class 'pyFAI.detectors._rayonix.RayonixLx170'>, 'rayonixlx170-hs': <class 'pyFAI.detectors._rayonix.RayonixLx170'>, 'rayonixlx170hs': <class 'pyFAI.detectors._rayonix.RayonixLx170'>, 'rayonixlx225hs': <class 'pyFAI.detectors._rayonix.RayonixLx255'>, 'rayonixlx255': <class 'pyFAI.detectors._rayonix.RayonixLx255'>, 'rayonixlx255-hs': <class 'pyFAI.detectors._rayonix.RayonixLx255'>, 'rayonixlx255hs': <class 'pyFAI.detectors._rayonix.RayonixLx255'>, 'rayonixmx170': <class 'pyFAI.detectors._rayonix.RayonixMx170'>, 'rayonixmx170-hs': <class 'pyFAI.detectors._rayonix.RayonixMx170'>, 'rayonixmx170hs': <class 'pyFAI.detectors._rayonix.RayonixMx170'>, 'rayonixmx225': <class 'pyFAI.detectors._rayonix.RayonixMx225'>, 'rayonixmx225hs': <class 'pyFAI.detectors._rayonix.RayonixMx225hs'>, 'rayonixmx300': <class 'pyFAI.detectors._rayonix.RayonixMx300'>, 'rayonixmx300hs': <class 'pyFAI.detectors._rayonix.RayonixMx300hs'>, 'rayonixmx325': <class 'pyFAI.detectors._rayonix.RayonixMx325'>, 'rayonixmx340hs': <class 'pyFAI.detectors._rayonix.RayonixMx340hs'>, 'rayonixmx425hs': <class 'pyFAI.detectors._rayonix.RayonixMx425hs'>, 'rayonixsx165': <class 'pyFAI.detectors._rayonix.RayonixSx165'>, 'rayonixsx200': <class 'pyFAI.detectors._rayonix.RayonixSx200'>, 'rayonixsx30hs': <class 'pyFAI.detectors._rayonix.RayonixSx30hs'>, 'rayonixsx85hs': <class 'pyFAI.detectors._rayonix.RayonixSx85hs'>, 'thales_electronics': <class 'pyFAI.detectors._others.Pixium'>, 'thaleselectronics': <class 'pyFAI.detectors._others.Pixium'>, 'titan': <class 'pyFAI.detectors._others.Titan'>, 'titan2kx2k': <class 'pyFAI.detectors._others.Titan'>, 'titan_2k_x_2k': <class 'pyFAI.detectors._others.Titan'>, 'xcirpad': <class 'pyFAI.detectors._imxpad.Cirpad'>, 'xpad_flat': <class 'pyFAI.detectors._imxpad.Xpad_flat'>, 'xpad_s540_flat': <class 'pyFAI.detectors._imxpad.Xpad_flat'>, 'xpads540flat': <class 'pyFAI.detectors._imxpad.Xpad_flat'>}#
reset_pixel_corners()#
save(filename)#

Saves the detector description into a NeXus file, adapted from: http://download.nexusformat.org/sphinx/classes/base_classes/NXdetector.html Main differences:

  • differentiate pixel center from pixel corner offsets

  • store all offsets are ndarray according to slow/fast dimension (not x, y)

Parameters:

filename – name of the file on the disc

property sensor#

Configuration of the sensor: material and thickness, or None

setFit2D(**kwarg)#

Twin method of getFit2D: setup a detector instance according to a description

Parameters:

kwarg – dictionary containing pixel1, pixel2 and splineFile

setPyFAI(**kwarg)#

Twin method of getPyFAI: setup a detector instance according to a description

Parameters:

kwarg – dictionary containing detector, pixel1, pixel2 and splineFile

set_binning(bin_size: tuple[int, int] = (1, 1))#

Set the “binning” of the detector,

Parameters:

bin_size ((int, int)) – binning as integer or tuple of integers.

set_config(config)#

Sets the configuration of the detector.

The configuration is either a python dictionary or a JSON string or a file containing this JSON configuration

keys in that dictionary are: pixel1, pixel2, splinefile, max_shape

Parameters:

config – string or JSON-serialized dict

Returns:

self

set_darkcurrent(dark)#
set_darkfiles(files=None, method='mean')#
Parameters:
  • files (str or list(str) or None) – file(s) used to compute the dark.

  • method (str) – method used to compute the dark, “mean” or “median”

Set the dark current from one or multiple files, avaraged according to the method provided

set_dx(dx=None)#

set the pixel-wise displacement along X (dim2)

units: Displacement of a fraction of pixel in the direction X (along axis2)

set_dy(dy=None)#

set the pixel-wise displacement along Y (dim1)

unit: Displacement of a fraction of pixel in the Y direction (along dim1)

set_flatfield(flat)#
set_flatfiles(files, method='mean')#
Parameters:
  • files (str or list(str) or None) – file(s) used to compute the flat-field.

  • method (str) – method used to compute the dark, “mean” or “median”

Set the flat field from one or multiple files, averaged according to the method provided

set_mask(mask)#
set_maskfile(maskfile)#
set_pixel1(value)#

Set the pixel size along the first dimension.

set_pixel2(value)#

Set the pixel size along the second dimension.

set_pixel_corners(ary)#

Sets the position of pixel corners with some additional validation

Parameters:

ary – This a 4D array which contains: number of lines, number of columns, corner index, position in space Z, Y, X

set_splineFile(splinefile)#
property splineFile: str#
property splinefile: str#
uniform_pixel = True#
class pyFAI.detectors.Dexela2923(pixel1: float | None = None, pixel2: float | None = None, splinefile: str | None = None, max_shape: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#

Bases: Detector

Dexela CMOS family detector

MAX_SHAPE = (3888, 3072)#
PIXEL_SIZE = (7.5e-05, 7.5e-05)#
aliases = ('Dexela 2923',)#
force_pixel = True#
class pyFAI.detectors.Eiger(pixel1: float = 7.5e-05, pixel2: float = 7.5e-05, max_shape: tuple[int, int] | None = None, module_size: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#

Bases: _Dectris

Eiger detector: generic description containing mask algorithm

Nota: 512k modules (514*1030) are made of 2x4 submodules of 256*256 pixels. Two missing pixels are interpolated at each sub-module boundary which explains the +2 and the +6 pixels.

MODULE_GAP = (37, 10)#
MODULE_SIZE = (514, 1030)#
PIXEL_SIZE = (7.5e-05, 7.5e-05)#
SENSORS = ({   "material": "Si",   "thickness": 0.00045 },)#
__init__(pixel1: float = 7.5e-05, pixel2: float = 7.5e-05, max_shape: tuple[int, int] | None = None, module_size: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#

Constructor of the Detector class, most of the time, not used. :param pixel1: size of the pixel in meter along the slow dimension (often Y) :param pixel2: size of the pixel in meter along the fast dimension (often X) :param splinefile: path to file containing the geometric correction. :param max_shape: maximum size of the detector :type max_shape: 2-tuple of integers :param orientation: Orientation of the detector :param sensor: Optional sensor configuration specifying detector material and sensor thickness (in metres). :type sensor: SensorConfig | None

calc_cartesian_positions(d1=None, d2=None, center=True, use_cython=True)#

Calculate the position of each pixel center in cartesian coordinate and in meter of a couple of coordinates. The half pixel offset is taken into account here !!!

Parameters:
  • d1 (ndarray (1D or 2D)) – the Y pixel positions (slow dimension)

  • d2 (ndarray (1D or 2D)) – the X pixel positions (fast dimension)

Returns:

p1, p2 position in meter of the center of each pixels.

Return type:

2-tuple of numpy.ndarray

d1 and d2 must have the same shape, returned array will have the same shape.

force_pixel = True#
class pyFAI.detectors.Eiger16M(pixel1: float = 7.5e-05, pixel2: float = 7.5e-05, max_shape: tuple[int, int] | None = None, module_size: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#

Bases: Eiger

Eiger 16M detector

MAX_SHAPE = (4371, 4150)#
aliases = ('Eiger 16M',)#
class pyFAI.detectors.Eiger1M(pixel1: float = 7.5e-05, pixel2: float = 7.5e-05, max_shape: tuple[int, int] | None = None, module_size: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#

Bases: Eiger

Eiger 1M detector

MAX_SHAPE = (1065, 1030)#
aliases = ('Eiger 1M',)#
class pyFAI.detectors.Eiger2(pixel1: float = 7.5e-05, pixel2: float = 7.5e-05, max_shape: tuple[int, int] | None = None, module_size: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#

Bases: Eiger

MODULE_GAP = (38, 12)#
MODULE_SIZE = (512, 1028)#
class pyFAI.detectors.Eiger2CdTe(pixel1: float = 7.5e-05, pixel2: float = 7.5e-05, max_shape: tuple[int, int] | None = None, module_size: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#

Bases: Eiger2

Eiger2 CdTe detector: Like the Eiger2 with an extra 2-pixel gap in the middle of every module (vertically)

SENSORS = ({   "material": "CdTe",   "thickness": 0.00075 },)#
calc_mask()#

Mask out an extra 2 pixels in the middle of each module

class pyFAI.detectors.Eiger2CdTe_16M(pixel1: float = 7.5e-05, pixel2: float = 7.5e-05, max_shape: tuple[int, int] | None = None, module_size: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#

Bases: Eiger2CdTe

Eiger2 CdTe 16M detector

MAX_SHAPE = (4362, 4148)#
aliases = ('Eiger2 CdTe 16M',)#
class pyFAI.detectors.Eiger2CdTe_1M(pixel1: float = 7.5e-05, pixel2: float = 7.5e-05, max_shape: tuple[int, int] | None = None, module_size: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#

Bases: Eiger2CdTe

Eiger2 CdTe 1M detector

MAX_SHAPE = (1062, 1028)#
aliases = ('Eiger2 CdTe 1M',)#
class pyFAI.detectors.Eiger2CdTe_1MW(pixel1: float = 7.5e-05, pixel2: float = 7.5e-05, max_shape: tuple[int, int] | None = None, module_size: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#

Bases: Eiger2CdTe

Eiger2 CdTe 1M-Wide detector

MAX_SHAPE = (512, 2068)#
aliases = ('Eiger2 CdTe 1M-W',)#
class pyFAI.detectors.Eiger2CdTe_2MW(pixel1: float = 7.5e-05, pixel2: float = 7.5e-05, max_shape: tuple[int, int] | None = None, module_size: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#

Bases: Eiger2CdTe

Eiger2 CdTe 2M-Wide detector

MAX_SHAPE = (512, 4148)#
aliases = ('Eiger2 CdTe 2M-W',)#
class pyFAI.detectors.Eiger2CdTe_4M(pixel1: float = 7.5e-05, pixel2: float = 7.5e-05, max_shape: tuple[int, int] | None = None, module_size: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#

Bases: Eiger2CdTe

Eiger2 CdTe 4M detector

MAX_SHAPE = (2162, 2068)#
aliases = ('Eiger2 CdTe 4M',)#
class pyFAI.detectors.Eiger2CdTe_500k(pixel1: float = 7.5e-05, pixel2: float = 7.5e-05, max_shape: tuple[int, int] | None = None, module_size: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#

Bases: Eiger2CdTe

Eiger2 CdTe 500k detector

MAX_SHAPE = (512, 1028)#
aliases = ('Eiger2 CdTe 500k',)#
class pyFAI.detectors.Eiger2CdTe_9M(pixel1: float = 7.5e-05, pixel2: float = 7.5e-05, max_shape: tuple[int, int] | None = None, module_size: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#

Bases: Eiger2CdTe

Eiger2 CdTe 9M detector

MAX_SHAPE = (3262, 3108)#
aliases = ('Eiger2 CdTe 9M',)#
class pyFAI.detectors.Eiger2_16M(pixel1: float = 7.5e-05, pixel2: float = 7.5e-05, max_shape: tuple[int, int] | None = None, module_size: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#

Bases: Eiger2

Eiger2 16M detector

MAX_SHAPE = (4362, 4148)#
aliases = ('Eiger2 16M',)#
class pyFAI.detectors.Eiger2_1M(pixel1: float = 7.5e-05, pixel2: float = 7.5e-05, max_shape: tuple[int, int] | None = None, module_size: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#

Bases: Eiger2

Eiger2 1M detector

MAX_SHAPE = (1062, 1028)#
aliases = ('Eiger2 1M',)#
class pyFAI.detectors.Eiger2_1MW(pixel1: float = 7.5e-05, pixel2: float = 7.5e-05, max_shape: tuple[int, int] | None = None, module_size: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#

Bases: Eiger2

Eiger2 1M-Wide detector

MAX_SHAPE = (512, 2068)#
aliases = ('Eiger2 1M-W',)#
class pyFAI.detectors.Eiger2_250k(pixel1: float = 7.5e-05, pixel2: float = 7.5e-05, max_shape: tuple[int, int] | None = None, module_size: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#

Bases: Eiger2

Eiger2 250k detector

MAX_SHAPE = (512, 512)#
aliases = ('Eiger2 250k',)#
class pyFAI.detectors.Eiger2_2MW(pixel1: float = 7.5e-05, pixel2: float = 7.5e-05, max_shape: tuple[int, int] | None = None, module_size: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#

Bases: Eiger2

Eiger2 2M-Wide detector

MAX_SHAPE = (512, 4148)#
aliases = ('Eiger2 2M-W',)#
class pyFAI.detectors.Eiger2_4M(pixel1: float = 7.5e-05, pixel2: float = 7.5e-05, max_shape: tuple[int, int] | None = None, module_size: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#

Bases: Eiger2

Eiger2 4M detector

MAX_SHAPE = (2162, 2068)#
aliases = ('Eiger2 4M',)#
class pyFAI.detectors.Eiger2_500k(pixel1: float = 7.5e-05, pixel2: float = 7.5e-05, max_shape: tuple[int, int] | None = None, module_size: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#

Bases: Eiger2

Eiger2 500k detector

MAX_SHAPE = (512, 1028)#
aliases = ('Eiger2 500k',)#
class pyFAI.detectors.Eiger2_9M(pixel1: float = 7.5e-05, pixel2: float = 7.5e-05, max_shape: tuple[int, int] | None = None, module_size: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#

Bases: Eiger2

Eiger2 9M detector

MAX_SHAPE = (3262, 3108)#
aliases = ('Eiger2 9M',)#
class pyFAI.detectors.Eiger4M(pixel1: float = 7.5e-05, pixel2: float = 7.5e-05, max_shape: tuple[int, int] | None = None, module_size: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#

Bases: Eiger

Eiger 4M detector

MAX_SHAPE = (2167, 2070)#
aliases = ('Eiger 4M',)#
class pyFAI.detectors.Eiger500k(pixel1: float = 7.5e-05, pixel2: float = 7.5e-05, max_shape: tuple[int, int] | None = None, module_size: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#

Bases: Eiger

Eiger 500k detector

MAX_SHAPE = (514, 1030)#
aliases = ('Eiger 500k',)#
class pyFAI.detectors.Eiger9M(pixel1: float = 7.5e-05, pixel2: float = 7.5e-05, max_shape: tuple[int, int] | None = None, module_size: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#

Bases: Eiger

Eiger 9M detector

MAX_SHAPE = (3269, 3110)#
aliases = ('Eiger 9M',)#
class pyFAI.detectors.FReLoN(splinefile: str | None = None, orientation=0)#

Bases: Detector

FReLoN detector: The spline is mandatory to correct for geometric distortion of the taper

TODO: create automatically a mask that removes pixels out of the “valid region”

HAVE_TAPER = True#

If true a spline file is mandatory to correct the geometry

MANUFACTURER = 'ESRF'#
MAX_SHAPE = (2048, 2048)#
__init__(splinefile: str | None = None, orientation=0)#

Constructor of the Detector class, most of the time, not used. :param pixel1: size of the pixel in meter along the slow dimension (often Y) :param pixel2: size of the pixel in meter along the fast dimension (often X) :param splinefile: path to file containing the geometric correction. :param max_shape: maximum size of the detector :type max_shape: 2-tuple of integers :param orientation: Orientation of the detector :param sensor: Optional sensor configuration specifying detector material and sensor thickness (in metres). :type sensor: SensorConfig | None

calc_mask()#

Returns a generic mask for Frelon detectors… All pixels which (center) turns to be out of the valid region are by default discarded

class pyFAI.detectors.Fairchild(pixel1: float | None = None, pixel2: float | None = None, splinefile: str | None = None, max_shape: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#

Bases: Detector

Fairchild Condor 486:90 detector

MANUFACTURER = 'Fairchild Semiconductor'#
MAX_SHAPE = (4096, 4096)#
PIXEL_SIZE = (1.5e-05, 1.5e-05)#
aliases = ('Fairchild', 'Condor', 'Fairchild Condor 486:90')#
force_pixel = True#
uniform_pixel = True#
class pyFAI.detectors.HF_130K(pixel1: float | None = None, pixel2: float | None = None, splinefile: str | None = None, max_shape: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#

Bases: _ADSC

ADSC HF-130K 1 module

Information from http://www.adsc-xray.com/products/pixel-array-detectors/hf-130k/

MAX_SHAPE = (256, 512)#
PIXEL_SIZE = (0.00015, 0.00015)#
aliases = ('HF-130k',)#
force_pixel = True#
class pyFAI.detectors.HF_1M(pixel1: float | None = None, pixel2: float | None = None, splinefile: str | None = None, max_shape: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#

Bases: _ADSC

ADSC HF-1M 2x4 modules

Information from http://www.adsc-xray.com/products/pixel-array-detectors/hf-1m/

Nota: gaps between modules is not known/described

MAX_SHAPE = (1024, 1024)#
PIXEL_SIZE = (0.00015, 0.00015)#
aliases = ('HF-1M',)#
force_pixel = True#
class pyFAI.detectors.HF_262k(pixel1: float | None = None, pixel2: float | None = None, splinefile: str | None = None, max_shape: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#

Bases: _ADSC

ADSC HF-262k 2 module

Information from http://www.adsc-xray.com/products/pixel-array-detectors/hf-262k/

Nota: gaps between modules is not known/described

MAX_SHAPE = (512, 512)#
PIXEL_SIZE = (0.00015, 0.00015)#
aliases = ('HF-262k',)#
force_pixel = True#
class pyFAI.detectors.HF_2M(pixel1: float | None = None, pixel2: float | None = None, splinefile: str | None = None, max_shape: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#

Bases: _ADSC

ADSC HF-1M 3x6 modules

Information from http://www.adsc-xray.com/products/pixel-array-detectors/hf-2.4m/

Nota: gaps between modules is not known/described

MAX_SHAPE = (1536, 1536)#
PIXEL_SIZE = (0.00015, 0.00015)#
aliases = ('HF-2.4M',)#
force_pixel = True#
class pyFAI.detectors.HF_4M(pixel1: float | None = None, pixel2: float | None = None, splinefile: str | None = None, max_shape: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#

Bases: _ADSC

ADSC HF-4M 4x8 modules

Information from http://www.adsc-xray.com/products/pixel-array-detectors/hf-4m/

MAX_SHAPE = (2048, 2048)#
PIXEL_SIZE = (0.00015, 0.00015)#
aliases = ('HF-4M',)#
force_pixel = True#
class pyFAI.detectors.HF_9M(pixel1: float | None = None, pixel2: float | None = None, splinefile: str | None = None, max_shape: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#

Bases: _ADSC

ADSC HF-130K 1 module

Information from http://www.adsc-xray.com/products/pixel-array-detectors/hf-9-4m/

MAX_SHAPE = (3072, 3072)#
PIXEL_SIZE = (0.00015, 0.00015)#
aliases = ('HF-9.4M',)#
force_pixel = True#
class pyFAI.detectors.HexDetector(pitch=None, pixel1=None, pixel2=None, max_shape=None, orientation=0)#

Bases: Detector

Abstract class for regular hexagonal-pixel detectors

This is characterized by the pitch, distance between 2 pixels

Pixels are aligned horizontally with the provided pitch Vertically, 2 raws are separated by pitch*sqrt(3)/2 Odd raws are offsetted horizontally by pitch/2

CORNERS = 6#
IS_CONTIGUOUS = False#
IS_FLAT = True#
__init__(pitch=None, pixel1=None, pixel2=None, max_shape=None, orientation=0)#

Constructor of the Detector class, most of the time, not used. :param pixel1: size of the pixel in meter along the slow dimension (often Y) :param pixel2: size of the pixel in meter along the fast dimension (often X) :param splinefile: path to file containing the geometric correction. :param max_shape: maximum size of the detector :type max_shape: 2-tuple of integers :param orientation: Orientation of the detector :param sensor: Optional sensor configuration specifying detector material and sensor thickness (in metres). :type sensor: SensorConfig | None

classmethod build_pixel_coordinates(shape, pitch=1)#

Build the 4D array with pixel coordinates for a detector composed of hexagonal-pixels

Parameters:
  • shape – 2-tuple with size of the detector in number of pixels (y, x)

  • pitch – the distance between two pixels

Returns:

array with pixel coordinates

property pitch#

This is the distance between 2 pixel in the hexagonal pattern

uniform_pixel = False#
class pyFAI.detectors.ImXPadS10(pixel1=0.00013, pixel2=0.00013, max_shape=None, module_size=None, orientation=0, sensor: SensorConfig | None = None)#

Bases: ModuleDetector

ImXPad detector: ImXPad s10 detector with 1x1modules

BORDER_SIZE_RELATIVE = 2.5#
MANUFACTURER = 'ImXPad'#
MAX_SHAPE = (120, 80)#
MODULE_SIZE = (120, 80)#
PIXEL_SIZE = (0.00013, 0.00013)#
SENSORS = ()#
__init__(pixel1=0.00013, pixel2=0.00013, max_shape=None, module_size=None, orientation=0, sensor: SensorConfig | None = None)#

Constructor of the Detector class, most of the time, not used. :param pixel1: size of the pixel in meter along the slow dimension (often Y) :param pixel2: size of the pixel in meter along the fast dimension (often X) :param splinefile: path to file containing the geometric correction. :param max_shape: maximum size of the detector :type max_shape: 2-tuple of integers :param orientation: Orientation of the detector :param sensor: Optional sensor configuration specifying detector material and sensor thickness (in metres). :type sensor: SensorConfig | None

aliases = ('Imxpad S10',)#
calc_cartesian_positions(d1=None, d2=None, center=True, use_cython=True)#

Calculate the position of each pixel center in cartesian coordinate and in meter of a couple of coordinates. The half pixel offset is taken into account here !!!

Parameters:
  • d1 (ndarray (1D or 2D)) – the Y pixel positions (slow dimension)

  • d2 (ndarray (1D or 2D)) – the X pixel positions (fast dimension)

Returns:

position in meter of the center of each pixels.

Return type:

ndarray

d1 and d2 must have the same shape, returned array will have the same shape.

calc_mask()#

Calculate the mask

calc_pixels_edges()#

Calculate the position of the pixel edges

force_pixel = True#
get_pixel_corners(correct_binning=False)#

Calculate the position of the corner of the pixels

This should be overwritten by class representing non-contiguous detector (Xpad, …)

Precision float32 is ok: precision of 1µm for a detector size of 1m

Returns:

4D array containing: pixel index (slow dimension) pixel index (fast dimension) corner index (A, B, C or D), triangles or hexagons can be handled the same way vertex position (z,y,x)

uniform_pixel = False#
class pyFAI.detectors.ImXPadS140(pixel1=0.00013, pixel2=0.00013, max_shape=None, module_size=None, orientation=0, sensor: SensorConfig | None = None)#

Bases: ImXPadS10

ImXPad detector: ImXPad s140 detector with 2x7modules

BORDER_PIXEL_SIZE_RELATIVE = 2.5#
MAX_SHAPE = (240, 560)#
MODULE_SIZE = (120, 80)#
PIXEL_SIZE = (0.00013, 0.00013)#
aliases = ('Imxpad S140',)#
force_pixel = True#
class pyFAI.detectors.ImXPadS70(pixel1=0.00013, pixel2=0.00013, max_shape=None, module_size=None, orientation=0, sensor: SensorConfig | None = None)#

Bases: ImXPadS10

ImXPad detector: ImXPad s70 detector with 1x7modules

BORDER_SIZE_RELATIVE = 2.5#
MAX_SHAPE = (120, 560)#
MODULE_SIZE = (120, 80)#
PIXEL_EDGES = None#
PIXEL_SIZE = (0.00013, 0.00013)#
__init__(pixel1=0.00013, pixel2=0.00013, max_shape=None, module_size=None, orientation=0, sensor: SensorConfig | None = None)#

Constructor of the Detector class, most of the time, not used. :param pixel1: size of the pixel in meter along the slow dimension (often Y) :param pixel2: size of the pixel in meter along the fast dimension (often X) :param splinefile: path to file containing the geometric correction. :param max_shape: maximum size of the detector :type max_shape: 2-tuple of integers :param orientation: Orientation of the detector :param sensor: Optional sensor configuration specifying detector material and sensor thickness (in metres). :type sensor: SensorConfig | None

aliases = ('Imxpad S70',)#
force_pixel = True#
class pyFAI.detectors.ImXPadS70V(pixel1=0.00013, pixel2=0.00013, max_shape=None, module_size=None, orientation=0, sensor: SensorConfig | None = None)#

Bases: ImXPadS10

ImXPad detector: ImXPad s70 detector with 1x7modules

BORDER_SIZE_RELATIVE = 2.5#
MAX_SHAPE = (560, 120)#
MODULE_SIZE = (80, 120)#
PIXEL_EDGES = None#
PIXEL_SIZE = (0.00013, 0.00013)#
aliases = ('Imxpad S70 V',)#
force_pixel = True#
class pyFAI.detectors.Jungfrau(pixel1=7.5e-05, pixel2=7.5e-05, max_shape=None, module_size=None, orientation=0, sensor: SensorConfig | None = None)#

Bases: ModuleDetector

Raw Jungfrau module without sub-module pixel expansion applied.

BORDER_SIZE_RELATIVE = 2.0#
MANUFACTURER = 'PSI'#
MAX_SHAPE = (512, 1024)#
MODULE_SIZE = (256, 256)#
PIXEL_SIZE = (7.5e-05, 7.5e-05)#
SENSORS = ({   "material": "Si",   "thickness": 0.00032 }, {   "material": "Si",   "thickness": 0.00045 })#
__init__(pixel1=7.5e-05, pixel2=7.5e-05, max_shape=None, module_size=None, orientation=0, sensor: SensorConfig | None = None)#

Constructor of the Detector class, most of the time, not used. :param pixel1: size of the pixel in meter along the slow dimension (often Y) :param pixel2: size of the pixel in meter along the fast dimension (often X) :param splinefile: path to file containing the geometric correction. :param max_shape: maximum size of the detector :type max_shape: 2-tuple of integers :param orientation: Orientation of the detector :param sensor: Optional sensor configuration specifying detector material and sensor thickness (in metres). :type sensor: SensorConfig | None

aliases = ('Jungfrau 500k',)#
calc_cartesian_positions(d1=None, d2=None, center=True, use_cython=True)#

Calculate the position of each pixel center in cartesian coordinate and in meter of a couple of coordinates. The half pixel offset is taken into account here !!!

Parameters:
  • d1 (ndarray (1D or 2D)) – the Y pixel positions (slow dimension)

  • d2 (ndarray (1D or 2D)) – the X pixel positions (fast dimension)

Returns:

position in meter of the center of each pixels.

Return type:

ndarray

d1 and d2 must have the same shape, returned array will have the same shape.

calc_pixels_edges()#

Calculate the position of the pixel edges

force_pixel = True#
get_pixel_corners(correct_binning=False)#

Calculate the position of the corner of the pixels

This should be overwritten by class representing non-contiguous detector (Xpad, …)

Precision float32 is ok: precision of 1µm for a detector size of 1m

Returns:

4D array containing: pixel index (slow dimension) pixel index (fast dimension) corner index (A, B, C or D), triangles or hexagons can be handled the same way vertex position (z,y,x)

uniform_pixel = False#
class pyFAI.detectors.Jungfrau1M(pixel1=7.5e-05, pixel2=7.5e-05, max_shape=None, module_size=None, orientation=0, sensor: SensorConfig | None = None)#

Bases: Jungfrau4M

Jungfrau 1M module without sub-module pixel expansion applied.

MANUFACTURER = 'PSI'#
MAX_SHAPE = (1064, 1030)#
MODULE_GAP = (36, 8)#
MODULE_SIZE = (514, 1030)#
PIXEL_SIZE = (7.5e-05, 7.5e-05)#
aliases = ('Jungfrau 1M',)#
force_pixel = True#
uniform_pixel = True#
class pyFAI.detectors.Jungfrau4M(pixel1=7.5e-05, pixel2=7.5e-05, max_shape=None, module_size=None, orientation=0, sensor: SensorConfig | None = None)#

Bases: _Dectris

Jungfrau 4M module without sub-module pixel expansion applied.

MANUFACTURER = 'PSI'#
MAX_SHAPE = (2164, 2068)#
MODULE_GAP = (36, 8)#
MODULE_SIZE = (514, 1030)#
PIXEL_SIZE = (7.5e-05, 7.5e-05)#
SENSORS = ({   "material": "Si",   "thickness": 0.00032 }, {   "material": "Si",   "thickness": 0.00045 })#
__init__(pixel1=7.5e-05, pixel2=7.5e-05, max_shape=None, module_size=None, orientation=0, sensor: SensorConfig | None = None)#

Constructor of the Detector class, most of the time, not used. :param pixel1: size of the pixel in meter along the slow dimension (often Y) :param pixel2: size of the pixel in meter along the fast dimension (often X) :param splinefile: path to file containing the geometric correction. :param max_shape: maximum size of the detector :type max_shape: 2-tuple of integers :param orientation: Orientation of the detector :param sensor: Optional sensor configuration specifying detector material and sensor thickness (in metres). :type sensor: SensorConfig | None

aliases = ('Jungfrau 4M',)#
force_pixel = True#
uniform_pixel = True#
class pyFAI.detectors.Jungfrau8M(pixel1=7.5e-05, pixel2=7.5e-05, max_shape=None, module_size=None, orientation=0, sensor: SensorConfig | None = None)#

Bases: Jungfrau

Jungfrau 8M module composed of 16 modules, 12 horizontals and 4 vertical

To simplify the layout, one considers the chips (256x256) thus there are 128 chips (8 per modules)

MANUFACTURER = 'PSI'#
MAX_SHAPE = (3333, 3212)#
MODULE_SIZE = (256, 256)#
PIXEL_SIZE = (7.5e-05, 7.5e-05)#
__init__(pixel1=7.5e-05, pixel2=7.5e-05, max_shape=None, module_size=None, orientation=0, sensor: SensorConfig | None = None)#

Constructor of the Detector class, most of the time, not used. :param pixel1: size of the pixel in meter along the slow dimension (often Y) :param pixel2: size of the pixel in meter along the fast dimension (often X) :param splinefile: path to file containing the geometric correction. :param max_shape: maximum size of the detector :type max_shape: 2-tuple of integers :param orientation: Orientation of the detector :param sensor: Optional sensor configuration specifying detector material and sensor thickness (in metres). :type sensor: SensorConfig | None

aliases = ('Jungfrau 8M',)#
calc_mask()#

Method calculating the mask for a given detector

Detectors with gaps should overwrite this method with something actually calculating the mask!

Returns:

the mask with valid pixel to 0

Return type:

numpy ndarray of int8 or None

force_pixel = True#
module_positions = ([1, 607], [1, 866], [1, 1124], [1, 1382], [69, 1646], [69, 1905], [69, 2163], [69, 2421], [259, 607], [259, 866], [259, 1124], [259, 1382], [328, 1646], [328, 1905], [328, 2163], [328, 2421], [550, 607], [550, 866], [550, 1124], [550, 1382], [619, 1646], [619, 1905], [619, 2163], [619, 2421], [667, 2698], [667, 2957], [809, 607], [809, 866], [809, 1124], [809, 1382], [597, 69], [597, 328], [856, 69], [856, 328], [878, 1646], [878, 1905], [878, 2163], [878, 2421], [926, 2698], [926, 2957], [1185, 2698], [1185, 2957], [1100, 607], [1100, 866], [1100, 1124], [1100, 1382], [1114, 69], [1114, 328], [1169, 1646], [1169, 1905], [1169, 2163], [1169, 2421], [1359, 607], [1359, 866], [1359, 1124], [1359, 1382], [1372, 69], [1372, 328], [1428, 1646], [1428, 1905], [1428, 2163], [1428, 2421], [1442, 2698], [1442, 2957], [1636, 1], [1636, 259], [1650, 538], [1650, 797], [1650, 1055], [1650, 1313], [1706, 2629], [1706, 2888], [1719, 1577], [1719, 1836], [1719, 2094], [1719, 2352], [1895, 1], [1895, 259], [1909, 538], [1909, 797], [1909, 1055], [1909, 1313], [1965, 2629], [1965, 2888], [1978, 1577], [1978, 1836], [1978, 2094], [1978, 2352], [2153, 1], [2153, 259], [2200, 538], [2200, 797], [2200, 1055], [2200, 1313], [2223, 2629], [2223, 2888], [2269, 1577], [2269, 1836], [2269, 2094], [2269, 2352], [2411, 1], [2411, 259], [2459, 538], [2459, 797], [2459, 1055], [2459, 1313], [2481, 2629], [2481, 2888], [2528, 1577], [2528, 1836], [2528, 2094], [2528, 2352], [2750, 538], [2750, 797], [2750, 1055], [2750, 1313], [2819, 1577], [2819, 1836], [2819, 2094], [2819, 2352], [3009, 538], [3009, 797], [3009, 1055], [3009, 1313], [3078, 1577], [3078, 1836], [3078, 2094], [3078, 2352])#
uniform_pixel = True#
class pyFAI.detectors.Jungfrau_16M_cor(pixel1=7.5e-05, pixel2=7.5e-05, max_shape=None, module_size=None, orientation=0, sensor: SensorConfig | None = None)#

Bases: Jungfrau

Jungfrau 16 corrected for double-sized pixels

MAX_SHAPE = (16448, 1030)#
MODULE_SIZE = (514, 1030)#
aliases = ('Jungfrau 16M cor',)#
calc_mask()#

Mask out sub-module junctions

force_pixel = True#
init_from_geometry(filename)#

initialize the detector from “geom” file produced at PSI

static load_geom(geom_fname)#

“Load module geometry from ASCII file

Based on Alejandro Homs’ code

class pyFAI.detectors.Lambda10M(pixel1=5.5e-05, pixel2=5.5e-05, max_shape=None, module_size=None, orientation=0, sensor: SensorConfig | None = None)#

Bases: _Lambda

LAMBDA 10M detector

MAX_SHAPE = (2596, 4676)#
aliases = ('Lambda 10M',)#
class pyFAI.detectors.Lambda250k(pixel1=5.5e-05, pixel2=5.5e-05, max_shape=None, module_size=None, orientation=0, sensor: SensorConfig | None = None)#

Bases: _Lambda

LAMBDA 250k detector

MAX_SHAPE = (516, 516)#
aliases = ('Lambda 250k',)#
class pyFAI.detectors.Lambda2M(pixel1=5.5e-05, pixel2=5.5e-05, max_shape=None, module_size=None, orientation=0, sensor: SensorConfig | None = None)#

Bases: _Lambda

LAMBDA 2M detector

MAX_SHAPE = (1556, 1556)#
aliases = ('Lambda 2M',)#
class pyFAI.detectors.Lambda60k(pixel1=5.5e-05, pixel2=5.5e-05, max_shape=None, module_size=None, orientation=0, sensor: SensorConfig | None = None)#

Bases: _Lambda

LAMBDA 60k detector

MAX_SHAPE = (256, 256)#
aliases = ('Lambda 60k',)#
class pyFAI.detectors.Lambda750k(pixel1=5.5e-05, pixel2=5.5e-05, max_shape=None, module_size=None, orientation=0, sensor: SensorConfig | None = None)#

Bases: _Lambda

LAMBDA 750k detector

MAX_SHAPE = (516, 1556)#
aliases = ('Lambda 750k',)#
class pyFAI.detectors.Lambda7M5(pixel1=5.5e-05, pixel2=5.5e-05, max_shape=None, module_size=None, orientation=0, sensor: SensorConfig | None = None)#

Bases: _Lambda

LAMBDA 7.5M detector

MAX_SHAPE = (2596, 2596)#
aliases = ('Lambda 7.5M',)#
class pyFAI.detectors.Lambda9M(pixel1=5.5e-05, pixel2=5.5e-05, max_shape=None, module_size=None, orientation=0, sensor: SensorConfig | None = None)#

Bases: _Lambda

LAMBDA 9M detector

MAX_SHAPE = (3868, 3227)#
aliases = ('Lambda 9M',)#
calc_mask()#

Returns a generic mask for module based detectors…

class pyFAI.detectors.Mar345(pixel1=0.0001, pixel2=0.0001, max_shape=None, orientation=0, sensor: SensorConfig | None = None)#

Bases: Detector

Mar345 Imaging plate detector

In this detector, pixels are always square The valid image size are 2300, 2000, 1600, 1200, 3450, 3000, 2400, 1800

MANUFACTURER = 'Mar Research'#
MAX_SHAPE = (3450, 3450)#
SENSORS = ({   "material": "BaFBr0.85I0.15",   "thickness": 0.000124 },)#
VALID_SIZE: ClassVar[dict] = {1200: 0.00015, 1600: 0.00015, 1800: 0.0001, 2000: 0.00015, 2300: 0.00015, 2400: 0.0001, 3000: 0.0001, 3450: 0.0001}#
__init__(pixel1=0.0001, pixel2=0.0001, max_shape=None, orientation=0, sensor: SensorConfig | None = None)#

Constructor of the Detector class, most of the time, not used. :param pixel1: size of the pixel in meter along the slow dimension (often Y) :param pixel2: size of the pixel in meter along the fast dimension (often X) :param splinefile: path to file containing the geometric correction. :param max_shape: maximum size of the detector :type max_shape: 2-tuple of integers :param orientation: Orientation of the detector :param sensor: Optional sensor configuration specifying detector material and sensor thickness (in metres). :type sensor: SensorConfig | None

aliases = ('MAR 345', 'Mar3450')#
calc_mask()#

Method calculating the mask for a given detector

Detectors with gaps should overwrite this method with something actually calculating the mask!

Returns:

the mask with valid pixel to 0

Return type:

numpy ndarray of int8 or None

force_pixel = True#
guess_binning(data)#

Guess the binning/mode depending on the image shape :param data: 2-tuple with the shape of the image or the image with a .shape attribute. :return: True if the data fit the detector :rtype: bool

class pyFAI.detectors.Mar555(pixel1=0.000139, pixel2=0.000139, max_shape=None, orientation=0, sensor: SensorConfig | None = None)#

Bases: Detector

Mar555 is a Selenium flat panel detector.

The detector specifications are adapted from http://xds.mpimf-heidelberg.mpg.de/html_doc/detectors.html

MANUFACTURER = 'Mar Research'#
MAX_SHAPE = (3072, 2560)#
SENSORS = ({   "material": "Se",   "thickness": 0.0003 },)#
__init__(pixel1=0.000139, pixel2=0.000139, max_shape=None, orientation=0, sensor: SensorConfig | None = None)#

Constructor of the Detector class, most of the time, not used. :param pixel1: size of the pixel in meter along the slow dimension (often Y) :param pixel2: size of the pixel in meter along the fast dimension (often X) :param splinefile: path to file containing the geometric correction. :param max_shape: maximum size of the detector :type max_shape: 2-tuple of integers :param orientation: Orientation of the detector :param sensor: Optional sensor configuration specifying detector material and sensor thickness (in metres). :type sensor: SensorConfig | None

aliases = ('MAR 555',)#
force_pixel = True#
class pyFAI.detectors.Maxipix(pixel1=5.5e-05, pixel2=5.5e-05, max_shape=None, module_size=None, orientation=0, sensor: SensorConfig | None = None)#

Bases: ModuleDetector

ESRF Maxipix detector: generic description containing mask algorithm

Sub-classed by Maxipix2x2 and Maxipix5x1

MANUFACTURER = 'ESRF'#
MAX_SHAPE = (256, 256)#
MODULE_GAP = (4, 4)#
MODULE_SIZE = (256, 256)#
PIXEL_SIZE = (5.5e-05, 5.5e-05)#
SENSORS = ({   "material": "Si",   "thickness": 0.0005 },)#
__init__(pixel1=5.5e-05, pixel2=5.5e-05, max_shape=None, module_size=None, orientation=0, sensor: SensorConfig | None = None)#

Constructor of the Detector class, most of the time, not used. :param pixel1: size of the pixel in meter along the slow dimension (often Y) :param pixel2: size of the pixel in meter along the fast dimension (often X) :param splinefile: path to file containing the geometric correction. :param max_shape: maximum size of the detector :type max_shape: 2-tuple of integers :param orientation: Orientation of the detector :param sensor: Optional sensor configuration specifying detector material and sensor thickness (in metres). :type sensor: SensorConfig | None

aliases = ('Maxipix 1x1', 'Maxipix1x1')#
calc_mask()#

Returns a generic mask for Maxipix detectors…

force_pixel = True#
class pyFAI.detectors.Maxipix2x2(pixel1=5.5e-05, pixel2=5.5e-05, max_shape=None, module_size=None, orientation=0, sensor: SensorConfig | None = None)#

Bases: Maxipix

Maxipix 2x2 detector

MAX_SHAPE = (516, 516)#
aliases = ('Maxipix 2x2',)#
class pyFAI.detectors.Maxipix5x1(pixel1=5.5e-05, pixel2=5.5e-05, max_shape=None, module_size=None, orientation=0, sensor: SensorConfig | None = None)#

Bases: Maxipix

Maxipix 5x1 detector

MAX_SHAPE = (256, 1296)#
aliases = ('Maxipix 5x1',)#
class pyFAI.detectors.ModuleDetector(pixel1: float | None = None, pixel2: float | None = None, max_shape: tuple[int, int] | None = None, module_size: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#

Bases: Detector

Base class for all modular detectors (e.g., Dectris, Lambda, Imxpad). Factors out the common logic for handling module size and gaps in configuration.

MODULE_SIZE = (None, None)#
__init__(pixel1: float | None = None, pixel2: float | None = None, max_shape: tuple[int, int] | None = None, module_size: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#

Constructor of the Detector class, most of the time, not used. :param pixel1: size of the pixel in meter along the slow dimension (often Y) :param pixel2: size of the pixel in meter along the fast dimension (often X) :param splinefile: path to file containing the geometric correction. :param max_shape: maximum size of the detector :type max_shape: 2-tuple of integers :param orientation: Orientation of the detector :param sensor: Optional sensor configuration specifying detector material and sensor thickness (in metres). :type sensor: SensorConfig | None

get_config()#

Detector.get_config handles already: pixel1, pixel2, orientation, max_shape, splinefile, sensor Extends Detector.get_config to include module_size

set_config(config: dict | str)#

Detector.set_config handles already enforcment of pixel, splinefile, orientation, sensor Extends Detector.set_config to handle module_size.

class pyFAI.detectors.Mythen(pixel1: float | None = None, pixel2: float | None = None, splinefile: str | None = None, max_shape: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#

Bases: Detector

Mythen strip detector from Dectris

MANUFACTURER = 'Dectris'#
MAX_SHAPE = (1, 1280)#
PIXEL_SIZE = (0.008, 5e-05)#
SENSORS = ({   "material": "Si",   "thickness": 0.00032 }, {   "material": "Si",   "thickness": 0.00045 }, {   "material": "Si",   "thickness": 0.001 })#
aliases = ('Mythen 1280',)#
calc_mask()#

Mythen has no masks

force_pixel = True#
class pyFAI.detectors.NexusDetector(filename: str | None = None, orientation: int = 0, sensor: SensorConfig | None = None)#

Bases: Detector

Class representing a 2D detector loaded from a NeXus file

__init__(filename: str | None = None, orientation: int = 0, sensor: SensorConfig | None = None)#

Constructor of the Detector class, most of the time, not used. :param pixel1: size of the pixel in meter along the slow dimension (often Y) :param pixel2: size of the pixel in meter along the fast dimension (often X) :param splinefile: path to file containing the geometric correction. :param max_shape: maximum size of the detector :type max_shape: 2-tuple of integers :param orientation: Orientation of the detector :param sensor: Optional sensor configuration specifying detector material and sensor thickness (in metres). :type sensor: SensorConfig | None

property filename: str | None#

Returns the filename containing the description of this detector.

Return type:

Enum[None|str]

getFit2D()#

Helper method to serialize the description of a detector using the Fit2d units

Returns:

representation of the detector easy to serialize

Return type:

dict

getPyFAI()#

Helper method to serialize the description of a detector using the pyFAI way with everything in S.I units.

Returns:

representation of the detector easy to serialize

Return type:

dict

get_config()#

Return the configuration with arguments to the constructor.

get_filename() → str | None#

Returns the filename containing the description of this detector.

Return type:

Enum[None|str]

load(filename)#

Loads the detector description from a NeXus file, adapted from: http://download.nexusformat.org/sphinx/classes/base_classes/NXdetector.html

Parameters:

filename – name of the file on the disk

Returns:

self

set_config(config: dict | str)#

set the config of the detector

For Nexus detector, the valid keys are “filename”, “orientation, “sensor”

Parameters:

config – dict or JSON serialized dict

Returns:

detector instance

classmethod sload(filename)#

Instantiate the detector description from a NeXus file, adapted from: http://download.nexusformat.org/sphinx/classes/base_classes/NXdetector.html

Parameters:

filename – name of the file on the disk

Returns:

Detector instance

class pyFAI.detectors.Perkin(pixel1=0.0002, pixel2=0.0002, max_shape=None, orientation=0)#

Bases: Detector

Perkin detector

DEFAULT_PIXEL1 = 0.0002#
DEFAULT_PIXEL2 = 0.0002#
MANUFACTURER = 'Perkin Elmer'#
MAX_SHAPE = (4096, 4096)#
PIXEL_SIZE = (0.0002, 0.0002)#
__init__(pixel1=0.0002, pixel2=0.0002, max_shape=None, orientation=0)#

Constructor of the Detector class, most of the time, not used. :param pixel1: size of the pixel in meter along the slow dimension (often Y) :param pixel2: size of the pixel in meter along the fast dimension (often X) :param splinefile: path to file containing the geometric correction. :param max_shape: maximum size of the detector :type max_shape: 2-tuple of integers :param orientation: Orientation of the detector :param sensor: Optional sensor configuration specifying detector material and sensor thickness (in metres). :type sensor: SensorConfig | None

aliases = ('Perkin detector', 'Perkin Elmer')#
force_pixel = True#
class pyFAI.detectors.Pilatus(pixel1: float = 0.000172, pixel2: float = 0.000172, max_shape: tuple[int, int] | None = None, module_size: tuple[int, int] | None = None, x_offset_file: str | None = None, y_offset_file: str | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#

Bases: _Dectris

Pilatus detector: generic description containing mask algorithm

Sub-classed by Pilatus1M, Pilatus2M and Pilatus6M

MODULE_GAP = (17, 7)#
MODULE_SIZE = (195, 487)#
PIXEL_SIZE = (0.000172, 0.000172)#
SENSORS = ({   "material": "Si",   "thickness": 0.00032 }, {   "material": "Si",   "thickness": 0.00045 }, {   "material": "Si",   "thickness": 0.001 })#
__init__(pixel1: float = 0.000172, pixel2: float = 0.000172, max_shape: tuple[int, int] | None = None, module_size: tuple[int, int] | None = None, x_offset_file: str | None = None, y_offset_file: str | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#

Constructor of the Detector class, most of the time, not used. :param pixel1: size of the pixel in meter along the slow dimension (often Y) :param pixel2: size of the pixel in meter along the fast dimension (often X) :param splinefile: path to file containing the geometric correction. :param max_shape: maximum size of the detector :type max_shape: 2-tuple of integers :param orientation: Orientation of the detector :param sensor: Optional sensor configuration specifying detector material and sensor thickness (in metres). :type sensor: SensorConfig | None

calc_cartesian_positions(d1=None, d2=None, center=True, use_cython=True)#

Calculate the position of each pixel center in cartesian coordinate and in meter of a couple of coordinates. The half pixel offset is taken into account here !!!

Parameters:
  • d1 (ndarray (1D or 2D)) – the Y pixel positions (slow dimension)

  • d2 (ndarray (1D or 2D)) – the X pixel positions (fast dimension)

Returns:

position in meter of the center of each pixels.

Return type:

ndarray

d1 and d2 must have the same shape, returned array will have the same shape.

force_pixel = True#
get_config()#

Return the configuration with arguments to the constructor

Returns:

dict with param for serialization

get_splineFile()#
set_config(config: dict | str)#

set the config of the detector

For Pilatus detector, possible keys are: max_shape, module_size, x_offset_file, y_offset_file, orientation, sensor

Parameters:

config – dict or JSON serialized dict

Returns:

detector instance

set_offset_files(x_offset_file=None, y_offset_file=None)#
set_splineFile(splinefile=None)#

In this case splinefile is a couple filenames

property splineFile#
property splinefile#
class pyFAI.detectors.Pilatus100k(pixel1: float = 0.000172, pixel2: float = 0.000172, max_shape: tuple[int, int] | None = None, module_size: tuple[int, int] | None = None, x_offset_file: str | None = None, y_offset_file: str | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#

Bases: Pilatus

Pilatus 100k detector

MAX_SHAPE = (195, 487)#
aliases = ('Pilatus 100k',)#
class pyFAI.detectors.Pilatus1M(pixel1: float = 0.000172, pixel2: float = 0.000172, max_shape: tuple[int, int] | None = None, module_size: tuple[int, int] | None = None, x_offset_file: str | None = None, y_offset_file: str | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#

Bases: Pilatus

Pilatus 1M detector

MAX_SHAPE = (1043, 981)#
aliases = ('Pilatus 1M',)#
class pyFAI.detectors.Pilatus200k(pixel1: float = 0.000172, pixel2: float = 0.000172, max_shape: tuple[int, int] | None = None, module_size: tuple[int, int] | None = None, x_offset_file: str | None = None, y_offset_file: str | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#

Bases: Pilatus

Pilatus 200k detector

MAX_SHAPE = (407, 487)#
aliases = ('Pilatus 200k',)#
class pyFAI.detectors.Pilatus2M(pixel1: float = 0.000172, pixel2: float = 0.000172, max_shape: tuple[int, int] | None = None, module_size: tuple[int, int] | None = None, x_offset_file: str | None = None, y_offset_file: str | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#

Bases: Pilatus

Pilatus 2M detector

MAX_SHAPE = (1679, 1475)#
aliases = ('Pilatus 2M',)#
class pyFAI.detectors.Pilatus300k(pixel1: float = 0.000172, pixel2: float = 0.000172, max_shape: tuple[int, int] | None = None, module_size: tuple[int, int] | None = None, x_offset_file: str | None = None, y_offset_file: str | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#

Bases: Pilatus

Pilatus 300k detector

MAX_SHAPE = (619, 487)#
aliases = ('Pilatus 300k',)#
class pyFAI.detectors.Pilatus300kw(pixel1: float = 0.000172, pixel2: float = 0.000172, max_shape: tuple[int, int] | None = None, module_size: tuple[int, int] | None = None, x_offset_file: str | None = None, y_offset_file: str | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#

Bases: Pilatus

Pilatus 300k-wide detector

MAX_SHAPE = (195, 1475)#
aliases = ('Pilatus 300kw',)#
class pyFAI.detectors.Pilatus4(pixel1: float = 0.00015, pixel2: float = 0.00015, max_shape: tuple[int, int] | None = None, module_size: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#

Bases: _Dectris

Pilatus4 detector: generic description containing mask algorithm

Sub-classed by Pilatus4_1M, Pilatus4_2M and Pilatus_4M

MODULE_GAP = (20, 7)#
MODULE_SIZE = (255, 513)#
PIXEL_SIZE = (0.00015, 0.00015)#
SENSORS = ({   "material": "Si",   "thickness": 0.00045 },)#
__init__(pixel1: float = 0.00015, pixel2: float = 0.00015, max_shape: tuple[int, int] | None = None, module_size: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#

Constructor of the Detector class, most of the time, not used. :param pixel1: size of the pixel in meter along the slow dimension (often Y) :param pixel2: size of the pixel in meter along the fast dimension (often X) :param splinefile: path to file containing the geometric correction. :param max_shape: maximum size of the detector :type max_shape: 2-tuple of integers :param orientation: Orientation of the detector :param sensor: Optional sensor configuration specifying detector material and sensor thickness (in metres). :type sensor: SensorConfig | None

force_pixel = True#
class pyFAI.detectors.Pilatus4_1M(pixel1: float = 0.00015, pixel2: float = 0.00015, max_shape: tuple[int, int] | None = None, module_size: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#

Bases: Pilatus4

MAX_SHAPE = (1080, 1033)#
aliases = ('Pilatus4 1M',)#
class pyFAI.detectors.Pilatus4_260k(pixel1: float = 0.00015, pixel2: float = 0.00015, max_shape: tuple[int, int] | None = None, module_size: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#

Bases: Pilatus4

MAX_SHAPE = (530, 513)#
aliases = ('Pilatus4 260k',)#
class pyFAI.detectors.Pilatus4_260kw(pixel1: float = 0.00015, pixel2: float = 0.00015, max_shape: tuple[int, int] | None = None, module_size: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#

Bases: Pilatus4

MAX_SHAPE = (255, 1033)#
aliases = ('Pilatus4 260kw',)#
class pyFAI.detectors.Pilatus4_2M(pixel1: float = 0.00015, pixel2: float = 0.00015, max_shape: tuple[int, int] | None = None, module_size: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#

Bases: Pilatus4

MAX_SHAPE = (1630, 1553)#
aliases = ('Pilatus4 2M',)#
class pyFAI.detectors.Pilatus4_4M(pixel1: float = 0.00015, pixel2: float = 0.00015, max_shape: tuple[int, int] | None = None, module_size: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#

Bases: Pilatus4

MAX_SHAPE = (2180, 2073)#
aliases = ('Pilatus4 4M',)#
class pyFAI.detectors.Pilatus4_CdTe(pixel1: float = 0.00015, pixel2: float = 0.00015, max_shape: tuple[int, int] | None = None, module_size: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#

Bases: Pilatus4

Pilatus CdTe detector: Like the Pilatus4 with an extra gap of 1 pixel in the middle of every module (vertically)

SENSORS = ({   "material": "CdTe",   "thickness": 0.001 },)#
calc_mask()#

Mask out an extra 3 pixel in the middle of each module

class pyFAI.detectors.Pilatus4_CdTe_1M(pixel1: float = 0.00015, pixel2: float = 0.00015, max_shape: tuple[int, int] | None = None, module_size: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#

Bases: Pilatus4_CdTe

MAX_SHAPE = (1080, 1033)#
aliases = ('Pilatus4 1M CdTe',)#
class pyFAI.detectors.Pilatus4_CdTe_260k(pixel1: float = 0.00015, pixel2: float = 0.00015, max_shape: tuple[int, int] | None = None, module_size: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#

Bases: Pilatus4_CdTe

MAX_SHAPE = (530, 513)#
aliases = ('Pilatus4 260k CdTe',)#
class pyFAI.detectors.Pilatus4_CdTe_260kw(pixel1: float = 0.00015, pixel2: float = 0.00015, max_shape: tuple[int, int] | None = None, module_size: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#

Bases: Pilatus4_CdTe

MAX_SHAPE = (255, 1033)#
aliases = ('Pilatus4 260kw CdTe',)#
class pyFAI.detectors.Pilatus4_CdTe_2M(pixel1: float = 0.00015, pixel2: float = 0.00015, max_shape: tuple[int, int] | None = None, module_size: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#

Bases: Pilatus4_CdTe

MAX_SHAPE = (1630, 1553)#
aliases = ('Pilatus4 2M CdTe',)#
class pyFAI.detectors.Pilatus4_CdTe_4M(pixel1: float = 0.00015, pixel2: float = 0.00015, max_shape: tuple[int, int] | None = None, module_size: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#

Bases: Pilatus4_CdTe

MAX_SHAPE = (2180, 2073)#
aliases = ('Pilatus4 4M CdTe',)#
class pyFAI.detectors.Pilatus6M(pixel1: float = 0.000172, pixel2: float = 0.000172, max_shape: tuple[int, int] | None = None, module_size: tuple[int, int] | None = None, x_offset_file: str | None = None, y_offset_file: str | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#

Bases: Pilatus

Pilatus 6M detector

MAX_SHAPE = (2527, 2463)#
aliases = ('Pilatus 6M',)#
class pyFAI.detectors.Pilatus900k(pixel1: float = 0.000172, pixel2: float = 0.000172, max_shape: tuple[int, int] | None = None, module_size: tuple[int, int] | None = None, x_offset_file: str | None = None, y_offset_file: str | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#

Bases: Pilatus

Pilatus 900k detector, assembly of 3x3 modules Available at NSLS-II 12-ID.

This is different from the “Pilatus CdTe 900kw” available at ESRF ID06-LVP which is 1x9 modules

MAX_SHAPE = (619, 1475)#
aliases = ('Pilatus 900k',)#
class pyFAI.detectors.PilatusCdTe(pixel1: float = 0.000172, pixel2: float = 0.000172, max_shape: tuple[int, int] | None = None, module_size: tuple[int, int] | None = None, x_offset_file: str | None = None, y_offset_file: str | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#

Bases: Pilatus

Pilatus CdTe detector: Like the Pilatus with an extra 3 pixel in the middle of every module (vertically)

SENSORS = ({   "material": "CdTe",   "thickness": 0.001 },)#
calc_mask()#

Mask out an extra 3 pixel in the middle of each module

class pyFAI.detectors.PilatusCdTe1M(pixel1: float = 0.000172, pixel2: float = 0.000172, max_shape: tuple[int, int] | None = None, module_size: tuple[int, int] | None = None, x_offset_file: str | None = None, y_offset_file: str | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#

Bases: PilatusCdTe

Pilatus CdTe 1M detector

MAX_SHAPE = (1043, 981)#
aliases = ('Pilatus CdTe 1M', 'Pilatus 1M CdTe', 'Pilatus1M CdTe', 'Pilatus1MCdTe')#
class pyFAI.detectors.PilatusCdTe2M(pixel1: float = 0.000172, pixel2: float = 0.000172, max_shape: tuple[int, int] | None = None, module_size: tuple[int, int] | None = None, x_offset_file: str | None = None, y_offset_file: str | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#

Bases: PilatusCdTe

Pilatus CdTe 2M detector

MAX_SHAPE = (1679, 1475)#
aliases = ('Pilatus CdTe 2M', 'Pilatus 2M CdTe', 'Pilatus2M CdTe', 'Pilatus2MCdTe')#
class pyFAI.detectors.PilatusCdTe300k(pixel1: float = 0.000172, pixel2: float = 0.000172, max_shape: tuple[int, int] | None = None, module_size: tuple[int, int] | None = None, x_offset_file: str | None = None, y_offset_file: str | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#

Bases: PilatusCdTe

Pilatus CdTe 300k detector

MAX_SHAPE = (619, 487)#
aliases = ('Pilatus CdTe 300k', 'Pilatus 300k CdTe', 'Pilatus300k CdTe', 'Pilatus300kCdTe')#
class pyFAI.detectors.PilatusCdTe300kw(pixel1: float = 0.000172, pixel2: float = 0.000172, max_shape: tuple[int, int] | None = None, module_size: tuple[int, int] | None = None, x_offset_file: str | None = None, y_offset_file: str | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#

Bases: PilatusCdTe

Pilatus CdTe 300k-wide detector

MAX_SHAPE = (195, 1475)#
aliases = ('Pilatus CdTe 300kw', 'Pilatus 300kw CdTe', 'Pilatus300kw CdTe', 'Pilatus300kwCdTe')#
class pyFAI.detectors.PilatusCdTe900kw(pixel1: float = 0.000172, pixel2: float = 0.000172, max_shape: tuple[int, int] | None = None, module_size: tuple[int, int] | None = None, x_offset_file: str | None = None, y_offset_file: str | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#

Bases: PilatusCdTe

Pilatus CdTe 900k-wide detector, assembly of 1x9 modules Available at ESRF ID06-LVP

This differs from the “Pilatus 900k” detector, assembly of 3x3 modules, available at NSLS-II 12-ID.

MAX_SHAPE = (195, 4439)#
aliases = ('Pilatus CdTe 900kw', 'Pilatus 900kw CdTe', 'Pilatus900kw CdTe', 'Pilatus900kwCdTe')#
class pyFAI.detectors.Pixirad1(pitch=6e-05, pixel1=None, pixel2=None, max_shape=None, orientation=0)#

Bases: HexDetector

MANUFACTURER = 'Pixirad'#
MAX_SHAPE = (476, 512)#
__init__(pitch=6e-05, pixel1=None, pixel2=None, max_shape=None, orientation=0)#

Constructor of the Detector class, most of the time, not used. :param pixel1: size of the pixel in meter along the slow dimension (often Y) :param pixel2: size of the pixel in meter along the fast dimension (often X) :param splinefile: path to file containing the geometric correction. :param max_shape: maximum size of the detector :type max_shape: 2-tuple of integers :param orientation: Orientation of the detector :param sensor: Optional sensor configuration specifying detector material and sensor thickness (in metres). :type sensor: SensorConfig | None

aliases = ('Pixirad-1',)#
class pyFAI.detectors.Pixirad2(pitch=6e-05, pixel1=None, pixel2=None, max_shape=None, orientation=0)#

Bases: HexDetector

MANUFACTURER = 'Pixirad'#
MAX_SHAPE = (476, 1024)#
__init__(pitch=6e-05, pixel1=None, pixel2=None, max_shape=None, orientation=0)#

Constructor of the Detector class, most of the time, not used. :param pixel1: size of the pixel in meter along the slow dimension (often Y) :param pixel2: size of the pixel in meter along the fast dimension (often X) :param splinefile: path to file containing the geometric correction. :param max_shape: maximum size of the detector :type max_shape: 2-tuple of integers :param orientation: Orientation of the detector :param sensor: Optional sensor configuration specifying detector material and sensor thickness (in metres). :type sensor: SensorConfig | None

aliases = ('Pixirad-2',)#
class pyFAI.detectors.Pixirad4(pitch=6e-05, pixel1=None, pixel2=None, max_shape=None, orientation=0)#

Bases: HexDetector

MANUFACTURER = 'Pixirad'#
MAX_SHAPE = (476, 2048)#
__init__(pitch=6e-05, pixel1=None, pixel2=None, max_shape=None, orientation=0)#

Constructor of the Detector class, most of the time, not used. :param pixel1: size of the pixel in meter along the slow dimension (often Y) :param pixel2: size of the pixel in meter along the fast dimension (often X) :param splinefile: path to file containing the geometric correction. :param max_shape: maximum size of the detector :type max_shape: 2-tuple of integers :param orientation: Orientation of the detector :param sensor: Optional sensor configuration specifying detector material and sensor thickness (in metres). :type sensor: SensorConfig | None

aliases = ('Pixirad-4',)#
class pyFAI.detectors.Pixirad8(pitch=6e-05, pixel1=None, pixel2=None, max_shape=None, orientation=0)#

Bases: HexDetector

MANUFACTURER = 'Pixirad'#
MAX_SHAPE = (476, 4096)#
__init__(pitch=6e-05, pixel1=None, pixel2=None, max_shape=None, orientation=0)#

Constructor of the Detector class, most of the time, not used. :param pixel1: size of the pixel in meter along the slow dimension (often Y) :param pixel2: size of the pixel in meter along the fast dimension (often X) :param splinefile: path to file containing the geometric correction. :param max_shape: maximum size of the detector :type max_shape: 2-tuple of integers :param orientation: Orientation of the detector :param sensor: Optional sensor configuration specifying detector material and sensor thickness (in metres). :type sensor: SensorConfig | None

aliases = ('Pixirad-8',)#
class pyFAI.detectors.Pixium(pixel1=0.000308, pixel2=0.000308, max_shape=None, orientation=0)#

Bases: Detector

PIXIUM 4700 detector

High energy X ray diffraction using the Pixium 4700 flat panel detector J E Daniels, M Drakopoulos, et al.; Journal of Synchrotron Radiation 16(Pt 4):463-8 · August 2009

DEFAULT_PIXEL1 = 0.000154#
DEFAULT_PIXEL2 = 0.000154#
MANUFACTURER = 'Thales Electronics'#
MAX_SHAPE = (1910, 2480)#
PIXEL_SIZE = (0.000308, 0.000308)#
__init__(pixel1=0.000308, pixel2=0.000308, max_shape=None, orientation=0)#

Defaults to 2x2 binning

aliases = ('Pixium 4700', 'Pixium 4700 detector', 'Thales Electronics')#
force_pixel = True#
class pyFAI.detectors.Rapid(pixel1=0.0001, pixel2=0.0001, radius=0.12726, orientation=0)#

Bases: CylindricalDetector

Cylindrical detector: Rigaku R-axis RAPID II Unlike the Aarhus detector, the detectors is bent the other direction. It covers 210° r = 127.26mm pixel size 100µm but can be binned 2x2

Credits: Private communication; Dr. Jozef Bednarčík Department of Condensed Matter Physics Institute of Physics P.J. Šafárik University, Košice, Slovakia

The image has to be laid-out horizontally

Nota: the detector is bend towards the sample, hence reducing the sample-detector distance. This is why z<0 (or p3<0)

MANUFACTURER = 'Rigaku'#
MAX_SHAPE = (2560, 4700)#
__init__(pixel1=0.0001, pixel2=0.0001, radius=0.12726, orientation=0)#

Constructor of the Detector class, most of the time, not used. :param pixel1: size of the pixel in meter along the slow dimension (often Y) :param pixel2: size of the pixel in meter along the fast dimension (often X) :param splinefile: path to file containing the geometric correction. :param max_shape: maximum size of the detector :type max_shape: 2-tuple of integers :param orientation: Orientation of the detector :param sensor: Optional sensor configuration specifying detector material and sensor thickness (in metres). :type sensor: SensorConfig | None

aliases = ('RapidII',)#
class pyFAI.detectors.RaspberryPi12M(pixel1: float | None = None, pixel2: float | None = None, splinefile: str | None = None, max_shape: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#

Bases: Detector

8 Mpix detector from Raspberry Pi

MAX_SHAPE = (3040, 4056)#
PIXEL_SIZE = (1.55e-06, 1.55e-06)#
aliases = ('Picam HQ',)#
force_pixel = True#
class pyFAI.detectors.RaspberryPi5M(pixel1: float | None = None, pixel2: float | None = None, splinefile: str | None = None, max_shape: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#

Bases: Detector

5 Mpix detector from Raspberry Pi

MAX_SHAPE = (1944, 2592)#
PIXEL_SIZE = (1.4e-06, 1.4e-06)#
aliases = ('Picam v1',)#
force_pixel = True#
class pyFAI.detectors.RaspberryPi8M(pixel1: float | None = None, pixel2: float | None = None, splinefile: str | None = None, max_shape: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#

Bases: Detector

8 Mpix detector from Raspberry Pi

MAX_SHAPE = (2464, 3280)#
PIXEL_SIZE = (1.12e-06, 1.12e-06)#
aliases = ('Picam v2',)#
force_pixel = True#
class pyFAI.detectors.Rayonix133(pixel1=6.4e-05, pixel2=6.4e-05, max_shape=None, orientation=0, sensor: SensorConfig | None = None)#

Bases: _Rayonix

Rayonix 133 2D CCD detector detector also known as mar133

personal communication from M. Blum

What should be the default binning factor for those cameras ?

Circular detector

BINNED_PIXEL_SIZE: ClassVar[dict] = {1: 3.2e-05, 2: 6.4e-05, 4: 0.000128, 8: 0.000256}#
MANUFACTURER: ClassVar[list] = ['Rayonix', 'Mar Research']#
MAX_SHAPE = (4096, 4096)#
__init__(pixel1=6.4e-05, pixel2=6.4e-05, max_shape=None, orientation=0, sensor: SensorConfig | None = None)#

Constructor of the Detector class, most of the time, not used. :param pixel1: size of the pixel in meter along the slow dimension (often Y) :param pixel2: size of the pixel in meter along the fast dimension (often X) :param splinefile: path to file containing the geometric correction. :param max_shape: maximum size of the detector :type max_shape: 2-tuple of integers :param orientation: Orientation of the detector :param sensor: Optional sensor configuration specifying detector material and sensor thickness (in metres). :type sensor: SensorConfig | None

aliases = ('Rayonix133', 'MAR 133', 'MAR133')#
calc_mask()#

Circular mask

force_pixel = True#
class pyFAI.detectors.RayonixLx170(pixel1=4.42708e-05, pixel2=4.42708e-05, max_shape=None, orientation=0, sensor: SensorConfig | None = None)#

Bases: _Rayonix

Rayonix lx170 2d CCD Detector (2x1 CCDs).

Nota: this is the same for lx170hs

BINNED_PIXEL_SIZE: ClassVar[dict] = {1: 4.42708e-05, 2: 8.85417e-05, 3: 0.0001328125, 4: 0.0001770833, 5: 0.0002213542, 6: 0.000265625, 8: 0.0003541667, 10: 0.0004427083}#
MAX_SHAPE = (1920, 3840)#
__init__(pixel1=4.42708e-05, pixel2=4.42708e-05, max_shape=None, orientation=0, sensor: SensorConfig | None = None)#

Constructor of the Detector class, most of the time, not used. :param pixel1: size of the pixel in meter along the slow dimension (often Y) :param pixel2: size of the pixel in meter along the fast dimension (often X) :param splinefile: path to file containing the geometric correction. :param max_shape: maximum size of the detector :type max_shape: 2-tuple of integers :param orientation: Orientation of the detector :param sensor: Optional sensor configuration specifying detector material and sensor thickness (in metres). :type sensor: SensorConfig | None

aliases = ('Rayonix LX170', 'Rayonix LX170-HS', 'Rayonix LX170 HS', 'RayonixLX170HS')#
force_pixel = True#
class pyFAI.detectors.RayonixLx255(pixel1=4.42708e-05, pixel2=4.42708e-05, max_shape=None, orientation=0, sensor: SensorConfig | None = None)#

Bases: _Rayonix

Rayonix lx255 2d Detector (3x1 CCDs)

Nota: this detector is also called lx255hs

BINNED_PIXEL_SIZE: ClassVar[dict] = {1: 4.42708e-05, 2: 8.85417e-05, 3: 0.0001328125, 4: 0.0001770833, 5: 0.0002213542, 6: 0.000265625, 8: 0.0003541667, 10: 0.0004427083}#
MAX_SHAPE = (1920, 5760)#
__init__(pixel1=4.42708e-05, pixel2=4.42708e-05, max_shape=None, orientation=0, sensor: SensorConfig | None = None)#

Constructor of the Detector class, most of the time, not used. :param pixel1: size of the pixel in meter along the slow dimension (often Y) :param pixel2: size of the pixel in meter along the fast dimension (often X) :param splinefile: path to file containing the geometric correction. :param max_shape: maximum size of the detector :type max_shape: 2-tuple of integers :param orientation: Orientation of the detector :param sensor: Optional sensor configuration specifying detector material and sensor thickness (in metres). :type sensor: SensorConfig | None

aliases = ('Rayonix LX255', 'Rayonix LX255-HS', 'Rayonix LX 255HS', 'RayonixLX225HS')#
class pyFAI.detectors.RayonixMx170(pixel1=4.42708e-05, pixel2=4.42708e-05, max_shape=None, orientation=0, sensor: SensorConfig | None = None)#

Bases: _Rayonix

Rayonix mx170 2d CCD Detector (2x2 CCDs).

Nota: this is the same for mx170hs

BINNED_PIXEL_SIZE: ClassVar[dict] = {1: 4.42708e-05, 2: 8.85417e-05, 3: 0.0001328125, 4: 0.0001770833, 5: 0.0002213542, 6: 0.000265625, 8: 0.0003541667, 10: 0.0004427083}#
MAX_SHAPE = (3840, 3840)#
__init__(pixel1=4.42708e-05, pixel2=4.42708e-05, max_shape=None, orientation=0, sensor: SensorConfig | None = None)#

Constructor of the Detector class, most of the time, not used. :param pixel1: size of the pixel in meter along the slow dimension (often Y) :param pixel2: size of the pixel in meter along the fast dimension (often X) :param splinefile: path to file containing the geometric correction. :param max_shape: maximum size of the detector :type max_shape: 2-tuple of integers :param orientation: Orientation of the detector :param sensor: Optional sensor configuration specifying detector material and sensor thickness (in metres). :type sensor: SensorConfig | None

aliases = ('Rayonix MX170', 'Rayonix MX170-HS', 'RayonixMX170HS', 'Rayonix MX170 HS')#
class pyFAI.detectors.RayonixMx225(pixel1=7.3242e-05, pixel2=7.3242e-05, max_shape=None, orientation=0, sensor: SensorConfig | None = None)#

Bases: _Rayonix

Rayonix mx225 2D CCD detector detector

Nota: this is the same definition for mx225he personal communication from M. Blum

BINNED_PIXEL_SIZE: ClassVar[dict] = {1: 3.6621e-05, 2: 7.3242e-05, 3: 0.000109971, 4: 0.000146484, 8: 0.000292969}#
MANUFACTURER: ClassVar[list] = ['Rayonix', 'Mar Research']#
MAX_SHAPE = (6144, 6144)#
__init__(pixel1=7.3242e-05, pixel2=7.3242e-05, max_shape=None, orientation=0, sensor: SensorConfig | None = None)#

Constructor of the Detector class, most of the time, not used. :param pixel1: size of the pixel in meter along the slow dimension (often Y) :param pixel2: size of the pixel in meter along the fast dimension (often X) :param splinefile: path to file containing the geometric correction. :param max_shape: maximum size of the detector :type max_shape: 2-tuple of integers :param orientation: Orientation of the detector :param sensor: Optional sensor configuration specifying detector material and sensor thickness (in metres). :type sensor: SensorConfig | None

aliases = ('Rayonix MX225', 'MAR 225', 'MAR225')#
force_pixel = True#
class pyFAI.detectors.RayonixMx225hs(pixel1=7.8125e-05, pixel2=7.8125e-05, max_shape=None, orientation=0, sensor: SensorConfig | None = None)#

Bases: _Rayonix

Rayonix mx225hs 2D CCD detector detector

Pixel size from a personal communication from M. Blum

BINNED_PIXEL_SIZE: ClassVar[dict] = {1: 3.90625e-05, 2: 7.8125e-05, 3: 0.0001171875, 4: 0.00015625, 5: 0.0001953125, 6: 0.000234375, 8: 0.0003125, 10: 0.000390625}#
MAX_SHAPE = (5760, 5760)#
__init__(pixel1=7.8125e-05, pixel2=7.8125e-05, max_shape=None, orientation=0, sensor: SensorConfig | None = None)#

Constructor of the Detector class, most of the time, not used. :param pixel1: size of the pixel in meter along the slow dimension (often Y) :param pixel2: size of the pixel in meter along the fast dimension (often X) :param splinefile: path to file containing the geometric correction. :param max_shape: maximum size of the detector :type max_shape: 2-tuple of integers :param orientation: Orientation of the detector :param sensor: Optional sensor configuration specifying detector material and sensor thickness (in metres). :type sensor: SensorConfig | None

aliases = ('Rayonix MX225HS', 'Rayonix MX225 HS')#
force_pixel = True#
class pyFAI.detectors.RayonixMx300(pixel1=7.3242e-05, pixel2=7.3242e-05, max_shape=None, orientation=0, sensor: SensorConfig | None = None)#

Bases: _Rayonix

Rayonix mx300 2D detector (4x4 CCDs)

Pixel size from a personal communication from M. Blum

BINNED_PIXEL_SIZE: ClassVar[dict] = {1: 3.6621e-05, 2: 7.3242e-05, 3: 0.000109971, 4: 0.000146484, 8: 0.000292969}#
MANUFACTURER: ClassVar[list] = ['Rayonix', 'Mar Research']#
MAX_SHAPE = (8192, 8192)#
__init__(pixel1=7.3242e-05, pixel2=7.3242e-05, max_shape=None, orientation=0, sensor: SensorConfig | None = None)#

Constructor of the Detector class, most of the time, not used. :param pixel1: size of the pixel in meter along the slow dimension (often Y) :param pixel2: size of the pixel in meter along the fast dimension (often X) :param splinefile: path to file containing the geometric correction. :param max_shape: maximum size of the detector :type max_shape: 2-tuple of integers :param orientation: Orientation of the detector :param sensor: Optional sensor configuration specifying detector material and sensor thickness (in metres). :type sensor: SensorConfig | None

aliases = ('Rayonix MX300', 'MAR 300', 'MAR300')#
force_pixel = True#
class pyFAI.detectors.RayonixMx300hs(pixel1=7.8125e-05, pixel2=7.8125e-05, max_shape=None, orientation=0, sensor: SensorConfig | None = None)#

Bases: _Rayonix

Rayonix mx300hs 2D detector (4x4 CCDs)

Pixel size from a personal communication from M. Blum

BINNED_PIXEL_SIZE: ClassVar[dict] = {1: 3.90625e-05, 2: 7.8125e-05, 3: 0.0001171875, 4: 0.00015625, 5: 0.0001953125, 6: 0.000234375, 8: 0.0003125, 10: 0.000390625}#
MAX_SHAPE = (7680, 7680)#
__init__(pixel1=7.8125e-05, pixel2=7.8125e-05, max_shape=None, orientation=0, sensor: SensorConfig | None = None)#

Constructor of the Detector class, most of the time, not used. :param pixel1: size of the pixel in meter along the slow dimension (often Y) :param pixel2: size of the pixel in meter along the fast dimension (often X) :param splinefile: path to file containing the geometric correction. :param max_shape: maximum size of the detector :type max_shape: 2-tuple of integers :param orientation: Orientation of the detector :param sensor: Optional sensor configuration specifying detector material and sensor thickness (in metres). :type sensor: SensorConfig | None

aliases = ('Rayonix MX300HS', 'Rayonix MX300 HS')#
force_pixel = True#
class pyFAI.detectors.RayonixMx325(pixel1=7.9346e-05, pixel2=7.9346e-05, max_shape=None, orientation=0, sensor: SensorConfig | None = None)#

Bases: _Rayonix

Rayonix mx325 and mx325he 2D detector (4x4 CCD chips)

Pixel size from a personal communication from M. Blum

BINNED_PIXEL_SIZE: ClassVar[dict] = {1: 3.9673e-05, 2: 7.9346e-05, 3: 0.000119135, 4: 0.000158691, 8: 0.000317383}#
MAX_SHAPE = (8192, 8192)#
__init__(pixel1=7.9346e-05, pixel2=7.9346e-05, max_shape=None, orientation=0, sensor: SensorConfig | None = None)#

Constructor of the Detector class, most of the time, not used. :param pixel1: size of the pixel in meter along the slow dimension (often Y) :param pixel2: size of the pixel in meter along the fast dimension (often X) :param splinefile: path to file containing the geometric correction. :param max_shape: maximum size of the detector :type max_shape: 2-tuple of integers :param orientation: Orientation of the detector :param sensor: Optional sensor configuration specifying detector material and sensor thickness (in metres). :type sensor: SensorConfig | None

aliases = ('Rayonix MX325',)#
class pyFAI.detectors.RayonixMx340hs(pixel1=8.85417e-05, pixel2=8.85417e-05, max_shape=None, orientation=0, sensor: SensorConfig | None = None)#

Bases: _Rayonix

Rayonix mx340hs 2D detector (4x4 CCDs)

Pixel size from a personal communication from M. Blum

BINNED_PIXEL_SIZE: ClassVar[dict] = {1: 4.42708e-05, 2: 8.85417e-05, 3: 0.0001328125, 4: 0.0001770833, 5: 0.0002213542, 6: 0.000265625, 8: 0.0003541667, 10: 0.0004427083}#
MAX_SHAPE = (7680, 7680)#
__init__(pixel1=8.85417e-05, pixel2=8.85417e-05, max_shape=None, orientation=0, sensor: SensorConfig | None = None)#

Constructor of the Detector class, most of the time, not used. :param pixel1: size of the pixel in meter along the slow dimension (often Y) :param pixel2: size of the pixel in meter along the fast dimension (often X) :param splinefile: path to file containing the geometric correction. :param max_shape: maximum size of the detector :type max_shape: 2-tuple of integers :param orientation: Orientation of the detector :param sensor: Optional sensor configuration specifying detector material and sensor thickness (in metres). :type sensor: SensorConfig | None

aliases = ('Rayonix MX340HS', 'Rayonix MX340HS')#
force_pixel = True#
class pyFAI.detectors.RayonixMx425hs(pixel1=4.42708e-05, pixel2=4.42708e-05, max_shape=None, orientation=0, sensor: SensorConfig | None = None)#

Bases: _Rayonix

Rayonix mx425hs 2D CCD camera (5x5 CCD chip)

Pixel size from a personal communication from M. Blum

BINNED_PIXEL_SIZE: ClassVar[dict] = {1: 4.42708e-05, 2: 8.85417e-05, 3: 0.0001328125, 4: 0.0001770833, 5: 0.0002213542, 6: 0.000265625, 8: 0.0003541667, 10: 0.0004427083}#
MAX_SHAPE = (9600, 9600)#
__init__(pixel1=4.42708e-05, pixel2=4.42708e-05, max_shape=None, orientation=0, sensor: SensorConfig | None = None)#

Constructor of the Detector class, most of the time, not used. :param pixel1: size of the pixel in meter along the slow dimension (often Y) :param pixel2: size of the pixel in meter along the fast dimension (often X) :param splinefile: path to file containing the geometric correction. :param max_shape: maximum size of the detector :type max_shape: 2-tuple of integers :param orientation: Orientation of the detector :param sensor: Optional sensor configuration specifying detector material and sensor thickness (in metres). :type sensor: SensorConfig | None

aliases = ('Rayonix MX425HS', 'Rayonix MX425 HS')#
class pyFAI.detectors.RayonixSx165(pixel1=3.95e-05, pixel2=3.95e-05, max_shape=None, orientation=0, sensor: SensorConfig | None = None)#

Bases: _Rayonix

Rayonix sx165 2d Detector also known as MAR165.

Circular detector

BINNED_PIXEL_SIZE: ClassVar[dict] = {1: 3.95e-05, 2: 7.9e-05, 3: 0.000118616, 4: 0.000158, 8: 0.000316}#
MANUFACTURER: ClassVar[list] = ['Rayonix', 'Mar Research']#
MAX_SHAPE = (4096, 4096)#
__init__(pixel1=3.95e-05, pixel2=3.95e-05, max_shape=None, orientation=0, sensor: SensorConfig | None = None)#

Constructor of the Detector class, most of the time, not used. :param pixel1: size of the pixel in meter along the slow dimension (often Y) :param pixel2: size of the pixel in meter along the fast dimension (often X) :param splinefile: path to file containing the geometric correction. :param max_shape: maximum size of the detector :type max_shape: 2-tuple of integers :param orientation: Orientation of the detector :param sensor: Optional sensor configuration specifying detector material and sensor thickness (in metres). :type sensor: SensorConfig | None

aliases = ('Rayonix SX165', 'MAR 165', 'MAR165')#
calc_mask()#

Circular mask

force_pixel = True#
class pyFAI.detectors.RayonixSx200(pixel1=4.8e-05, pixel2=4.8e-05, max_shape=None, orientation=0, sensor: SensorConfig | None = None)#

Bases: _Rayonix

Rayonix sx200 2d CCD Detector.

Pixel size are personal communication from M. Blum.

BINNED_PIXEL_SIZE: ClassVar[dict] = {1: 4.8e-05, 2: 9.6e-05, 3: 0.000144, 4: 0.000192, 8: 0.000384}#
MAX_SHAPE = (4096, 4096)#
__init__(pixel1=4.8e-05, pixel2=4.8e-05, max_shape=None, orientation=0, sensor: SensorConfig | None = None)#

Constructor of the Detector class, most of the time, not used. :param pixel1: size of the pixel in meter along the slow dimension (often Y) :param pixel2: size of the pixel in meter along the fast dimension (often X) :param splinefile: path to file containing the geometric correction. :param max_shape: maximum size of the detector :type max_shape: 2-tuple of integers :param orientation: Orientation of the detector :param sensor: Optional sensor configuration specifying detector material and sensor thickness (in metres). :type sensor: SensorConfig | None

aliases = ('Rayonix SX200',)#
class pyFAI.detectors.RayonixSx30hs(pixel1=1.5625e-05, pixel2=1.5625e-05, max_shape=None, orientation=0, sensor: SensorConfig | None = None)#

Bases: _Rayonix

Rayonix sx30hs 2D CCD camera (1 CCD chip)

Pixel size from a personal communication from M. Blum

BINNED_PIXEL_SIZE: ClassVar[dict] = {1: 1.5625e-05, 2: 3.125e-05, 3: 4.6875e-05, 4: 6.25e-05, 5: 7.8125e-05, 6: 9.375e-05, 8: 0.000125, 10: 0.00015625}#
MAX_SHAPE = (1920, 1920)#
__init__(pixel1=1.5625e-05, pixel2=1.5625e-05, max_shape=None, orientation=0, sensor: SensorConfig | None = None)#

Constructor of the Detector class, most of the time, not used. :param pixel1: size of the pixel in meter along the slow dimension (often Y) :param pixel2: size of the pixel in meter along the fast dimension (often X) :param splinefile: path to file containing the geometric correction. :param max_shape: maximum size of the detector :type max_shape: 2-tuple of integers :param orientation: Orientation of the detector :param sensor: Optional sensor configuration specifying detector material and sensor thickness (in metres). :type sensor: SensorConfig | None

aliases = ('Rayonix SX30HS', 'Rayonix SX30 HS')#
class pyFAI.detectors.RayonixSx85hs(pixel1=4.42708e-05, pixel2=4.42708e-05, max_shape=None, orientation=0, sensor: SensorConfig | None = None)#

Bases: _Rayonix

Rayonix sx85hs 2D CCD camera (1 CCD chip)

Pixel size from a personal communication from M. Blum

BINNED_PIXEL_SIZE: ClassVar[dict] = {1: 4.42708e-05, 2: 8.85417e-05, 3: 0.0001328125, 4: 0.0001770833, 5: 0.0002213542, 6: 0.000265625, 8: 0.0003541667, 10: 0.0004427083}#
MAX_SHAPE = (1920, 1920)#
__init__(pixel1=4.42708e-05, pixel2=4.42708e-05, max_shape=None, orientation=0, sensor: SensorConfig | None = None)#

Constructor of the Detector class, most of the time, not used. :param pixel1: size of the pixel in meter along the slow dimension (often Y) :param pixel2: size of the pixel in meter along the fast dimension (often X) :param splinefile: path to file containing the geometric correction. :param max_shape: maximum size of the detector :type max_shape: 2-tuple of integers :param orientation: Orientation of the detector :param sensor: Optional sensor configuration specifying detector material and sensor thickness (in metres). :type sensor: SensorConfig | None

aliases = ('Rayonix SX85HS', 'Rayonix SX85 HS')#
class pyFAI.detectors.Titan(pixel1: float | None = None, pixel2: float | None = None, splinefile: str | None = None, max_shape: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#

Bases: Detector

Titan CCD detector from Agilent. Mask not handled

MANUFACTURER: ClassVar[list] = ['Agilent', 'Oxford Diffraction']#
MAX_SHAPE = (2048, 2048)#
PIXEL_SIZE = (6e-05, 6e-05)#
aliases = ('Titan 2k x 2k', 'Titan 2k x 2k', 'OXD Titan', 'Agilent Titan')#
force_pixel = True#
uniform_pixel = True#
class pyFAI.detectors.Xpad_flat(pixel1=0.00013, pixel2=0.00013, max_shape=None, module_size=None, orientation=0, sensor: SensorConfig | None = None)#

Bases: ImXPadS10

Xpad detector: generic description for ImXPad detector with 8x7modules

BORDER_PIXEL_SIZE_RELATIVE = 2.5#
IS_CONTIGUOUS = False#
MAX_SHAPE = (960, 560)#
MODULE_GAP = (0.00357, 0)#
MODULE_SIZE = (120, 80)#
PIXEL_SIZE = (0.00013, 0.00013)#
__init__(pixel1=0.00013, pixel2=0.00013, max_shape=None, module_size=None, orientation=0, sensor: SensorConfig | None = None)#

Constructor of the Detector class, most of the time, not used. :param pixel1: size of the pixel in meter along the slow dimension (often Y) :param pixel2: size of the pixel in meter along the fast dimension (often X) :param splinefile: path to file containing the geometric correction. :param max_shape: maximum size of the detector :type max_shape: 2-tuple of integers :param orientation: Orientation of the detector :param sensor: Optional sensor configuration specifying detector material and sensor thickness (in metres). :type sensor: SensorConfig | None

aliases = ('Xpad S540 flat', 'd5')#
calc_cartesian_positions(d1=None, d2=None, center=True, use_cython=True)#

Calculate the position of each pixel center in cartesian coordinate and in meter of a couple of coordinates. The half pixel offset is taken into account here !!! Adapted to Nexus detector definition

Parameters:
  • d1 (ndarray (1D or 2D)) – the Y pixel positions (slow dimension)

  • d2 (ndarray (1D or 2D)) – the X pixel positions (fast dimension)

  • center – retrieve the coordinate of the center of the pixel

  • use_cython – set to False to test Numpy implementation

Returns:

position in meter of the center of each pixels.

Return type:

ndarray

d1 and d2 must have the same shape, returned array will have the same shape.

calc_mask()#

Returns a generic mask for Xpad detectors… discards the first line and raw form all modules: those are 2.5x bigger and often misbehaving

calc_pixels_edges()#

Calculate the position of the pixel edges, specific to the S540, d5 detector

force_pixel = True#
get_pixel_corners(correct_binning=False)#

Calculate the position of the corner of the pixels

Returns:

4D array containing: pixel index (slow dimension) pixel index (fast dimension) corner index (A, B, C or D), triangles or hexagons can be handled the same way vertex position (z,y,x)

uniform_pixel = False#
pyFAI.detectors.detector_factory(name: str, config: None | str | dict[str, Any] = None)#

Create a pyFAI detector from a name.

If the detector is a known detector class, config in injected as constructor arguments.

If the name is an existing hdf5 filename, the config argument is ignored.

Parameters:
  • name (str) – A name of a detector or an existing hdf5 detector description file.

  • config (dict or JSON representation of it.) – configuration of the detector

Returns:

an instance of the right detector, set-up if possible

Return type:

pyFAI.detectors.Detector

pyFAI.detectors.load(filename)#

Instantiate the detector description from a NeXus file, adapted from: http://download.nexusformat.org/sphinx/classes/base_classes/NXdetector.html

Parameters:

filename – name of the file on the disk

Returns:

Detector instance