pyFAI.detectors package

Module contents

Description of all detectors with a factory to instantiate them.

class pyFAI.detectors.ADSC_Q210(pixel1=5.1e-05, pixel2=5.1e-05, max_shape=None, orientation=0)

Bases: _ADSC

ADSC Quantum 210r detector, 2x2 chips

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

Question: how are the gaps handled ?

MAX_SHAPE = (4096, 4096)

__init__(pixel1=5.1e-05, pixel2=5.1e-05, max_shape=None, orientation=0)

Parameters:

pixel1 (float) – size of the pixel in meter along the slow dimension (often Y)
pixel2 (float) – size of the pixel in meter along the fast dimension (often X)
splineFile (str) – path to file containing the geometric correction.
max_shape (2-tuple of integrers) – maximum size of the detector
orientation – Orientation of the detector

aliases = ['Quantum 210']

force_pixel = True

class pyFAI.detectors.ADSC_Q270(pixel1=6.48e-05, pixel2=6.48e-05, max_shape=None, orientation=0)

Bases: _ADSC

ADSC Quantum 270r detector, 2x2 chips

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

Question: how are the gaps handled ?

MAX_SHAPE = (4168, 4168)

__init__(pixel1=6.48e-05, pixel2=6.48e-05, max_shape=None, orientation=0)

Parameters:

pixel1 (float) – size of the pixel in meter along the slow dimension (often Y)
pixel2 (float) – size of the pixel in meter along the fast dimension (often X)
splineFile (str) – path to file containing the geometric correction.
max_shape (2-tuple of integrers) – maximum size of the detector
orientation – Orientation of the detector

aliases = ['Quantum 270']

force_pixel = True

class pyFAI.detectors.ADSC_Q315(pixel1=5.1e-05, pixel2=5.1e-05, max_shape=None, orientation=0)

Bases: _ADSC

ADSC Quantum 315r detector, 3x3 chips

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

Question: how are the gaps handled ?

MAX_SHAPE = (6144, 6144)

__init__(pixel1=5.1e-05, pixel2=5.1e-05, max_shape=None, orientation=0)

Parameters:

pixel1 (float) – size of the pixel in meter along the slow dimension (often Y)
pixel2 (float) – size of the pixel in meter along the fast dimension (often X)
splineFile (str) – path to file containing the geometric correction.
max_shape (2-tuple of integrers) – maximum size of the detector
orientation – Orientation of the detector

aliases = ['Quantum 315']

force_pixel = True

class pyFAI.detectors.ADSC_Q4(pixel1=8.2e-05, pixel2=8.2e-05, max_shape=None, orientation=0)

Bases: _ADSC

ADSC Quantum 4r detector, 2x2 chips

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

Question: how are the gaps handled ?

MAX_SHAPE = (2304, 2304)

__init__(pixel1=8.2e-05, pixel2=8.2e-05, max_shape=None, orientation=0)

Parameters:

pixel1 (float) – size of the pixel in meter along the slow dimension (often Y)
pixel2 (float) – size of the pixel in meter along the fast dimension (often X)
splineFile (str) – path to file containing the geometric correction.
max_shape (2-tuple of integrers) – maximum size of the detector
orientation – Orientation of the detector

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. Developped 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)

Parameters:

pixel1 (float) – size of the pixel in meter along the slow dimension (often Y)
pixel2 (float) – size of the pixel in meter along the fast dimension (often X)
splineFile (str) – path to file containing the geometric correction.
max_shape (2-tuple of integrers) – maximum size of the detector
orientation – Orientation of the detector

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

DEFAULT_PIXEL1 = 6e-05

DEFAULT_PIXEL2 = 6e-05

MANUFACTURER = 'Bruker'

MAX_SHAPE = (1024, 1024)

__init__(pixel1=0.00012, pixel2=0.00012, max_shape=None, orientation=0): Defaults to 2x2 binning

aliases = ['ApexII', 'Bruker']

force_pixel = True

get_config()

Return the configuration with arguments to the constructor

Returns:: dict with param for serialization

class pyFAI.detectors.Basler(pixel1=3.75e-06, pixel2=3.75e-06, max_shape=None, orientation=0)

Bases: Detector

Basler camera are simple CCD camara over GigaE

MANUFACTURER = 'Basler'

MAX_SHAPE = (966, 1296)

__init__(pixel1=3.75e-06, pixel2=3.75e-06, max_shape=None, orientation=0)

Parameters:

pixel1 (float) – size of the pixel in meter along the slow dimension (often Y)
pixel2 (float) – size of the pixel in meter along the fast dimension (often X)
splineFile (str) – path to file containing the geometric correction.
max_shape (2-tuple of integrers) – maximum size of the detector
orientation – Orientation of the detector

aliases = ['aca1300']

force_pixel = True

get_config()

Return the configuration with arguments to the constructor

Returns:: dict with param for serialization

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: pixel

Parameters:: config – string or JSON-serialized dict
Returns:: self

class pyFAI.detectors.Cirpad(pixel1=0.00013, pixel2=0.00013, max_shape=None, module_size=None, orientation=0)

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)

Parameters:

pixel1 (float) – size of the pixel in meter along the slow dimension (often Y)
pixel2 (float) – size of the pixel in meter along the fast dimension (often X)
splineFile (str) – path to file containing the geometric correction.
max_shape (2-tuple of integrers) – maximum size of the detector
orientation – Orientation of the detector

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)

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)

Parameters:

pixel1 (float) – size of the pixel in meter along the slow dimension (often Y)
pixel2 (float) – size of the pixel in meter along the fast dimension (often X)
splineFile (str) – path to file containing the geometric correction.
max_shape (2-tuple of integrers) – maximum size of the detector
orientation – Orientation of the detector

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 implementeation

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=None, pixel2=None, splineFile=None, max_shape=None, orientation=0)

Bases: object

Generic class representing a 2D detector

API_VERSION = '1.1'

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

__init__(pixel1=None, pixel2=None, splineFile=None, max_shape=None, orientation=0)

Parameters:

pixel1 (float) – size of the pixel in meter along the slow dimension (often Y)
pixel2 (float) – size of the pixel in meter along the fast dimension (often X)
splineFile (str) – path to file containing the geometric correction.
max_shape (2-tuple of integrers) – maximum size of the detector
orientation – Orientation of the detector

aliases = []

property binning

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

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: Union[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()

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_binning()

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_flatfield()

get_flatfield_crc()

get_mask()

get_mask_crc()

get_maskfile()

get_name(): Get a meaningful name for detector

get_pixel1()

get_pixel2()

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()

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 pixel1

property pixel2

registry = {'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'>, '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_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'>, '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'>, '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_v1': <class 'pyFAI.detectors._others.RaspberryPi5M'>, 'picam_v2': <class 'pyFAI.detectors._others.RaspberryPi8M'>, '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'>, '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

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=(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 mutliple 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 mutliple files, averaged according to the method provided

set_mask(mask)

set_maskfile(maskfile)

set_pixel1(value)

set_pixel2(value)

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

uniform_pixel = True

class pyFAI.detectors.Dexela2923(pixel1=7.5e-05, pixel2=7.5e-05, max_shape=None, orientation=0)

Bases: Detector

Dexela CMOS family detector

MAX_SHAPE = (3888, 3072)

__init__(pixel1=7.5e-05, pixel2=7.5e-05, max_shape=None, orientation=0)

Parameters:

pixel1 (float) – size of the pixel in meter along the slow dimension (often Y)
pixel2 (float) – size of the pixel in meter along the fast dimension (often X)
splineFile (str) – path to file containing the geometric correction.
max_shape (2-tuple of integrers) – maximum size of the detector
orientation – Orientation of the detector

aliases = ['Dexela 2923']

force_pixel = True

get_config()

Return the configuration with arguments to the constructor

Returns:: dict with param for serialization

class pyFAI.detectors.Eiger(pixel1=7.5e-05, pixel2=7.5e-05, max_shape=None, module_size=None, orientation=0)

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)

__init__(pixel1=7.5e-05, pixel2=7.5e-05, max_shape=None, module_size=None, orientation=0)

Parameters:

pixel1 (float) – size of the pixel in meter along the slow dimension (often Y)
pixel2 (float) – size of the pixel in meter along the fast dimension (often X)
splineFile (str) – path to file containing the geometric correction.
max_shape (2-tuple of integrers) – maximum size of the detector
orientation – Orientation of the detector

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

get_config()

Return the configuration with arguments to the constructor

Returns:: dict with param for serialization

set_config(config)

set the config of the detector

For Eiger detector, possible keys are: max_shape, module_size

Parameters:: config – dict or JSON serialized dict
Returns:: detector instance

class pyFAI.detectors.Eiger16M(pixel1=7.5e-05, pixel2=7.5e-05, max_shape=None, module_size=None, orientation=0)

Bases: Eiger

Eiger 16M detector

MAX_SHAPE = (4371, 4150)

aliases = ['Eiger 16M']

class pyFAI.detectors.Eiger1M(pixel1=7.5e-05, pixel2=7.5e-05, max_shape=None, module_size=None, orientation=0)

Bases: Eiger

Eiger 1M detector

MAX_SHAPE = (1065, 1030)

aliases = ['Eiger 1M']

class pyFAI.detectors.Eiger2(pixel1=7.5e-05, pixel2=7.5e-05, max_shape=None, module_size=None, orientation=0)

Bases: Eiger

MODULE_GAP = (38, 12)

MODULE_SIZE = (512, 1028)

class pyFAI.detectors.Eiger2CdTe(pixel1=7.5e-05, pixel2=7.5e-05, max_shape=None, module_size=None, orientation=0)

Bases: Eiger2

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

calc_mask(): Mask out an extra 2 pixels in the middle of each module

class pyFAI.detectors.Eiger2CdTe_16M(pixel1=7.5e-05, pixel2=7.5e-05, max_shape=None, module_size=None, orientation=0)

Bases: Eiger2CdTe

Eiger2 CdTe 16M detector

MAX_SHAPE = (4362, 4148)

aliases = ['Eiger2 CdTe 16M']

class pyFAI.detectors.Eiger2CdTe_1M(pixel1=7.5e-05, pixel2=7.5e-05, max_shape=None, module_size=None, orientation=0)

Bases: Eiger2CdTe

Eiger2 CdTe 1M detector

MAX_SHAPE = (1062, 1028)

aliases = ['Eiger2 CdTe 1M']

class pyFAI.detectors.Eiger2CdTe_1MW(pixel1=7.5e-05, pixel2=7.5e-05, max_shape=None, module_size=None, orientation=0)

Bases: Eiger2CdTe

Eiger2 CdTe 1M-Wide detector

MAX_SHAPE = (512, 2068)

aliases = ['Eiger2 CdTe 1M-W']

class pyFAI.detectors.Eiger2CdTe_2MW(pixel1=7.5e-05, pixel2=7.5e-05, max_shape=None, module_size=None, orientation=0)

Bases: Eiger2CdTe

Eiger2 CdTe 2M-Wide detector

MAX_SHAPE = (512, 4148)

aliases = ['Eiger2 CdTe 2M-W']

class pyFAI.detectors.Eiger2CdTe_4M(pixel1=7.5e-05, pixel2=7.5e-05, max_shape=None, module_size=None, orientation=0)

Bases: Eiger2CdTe

Eiger2 CdTe 4M detector

MAX_SHAPE = (2162, 2068)

aliases = ['Eiger2 CdTe 4M']

class pyFAI.detectors.Eiger2CdTe_500k(pixel1=7.5e-05, pixel2=7.5e-05, max_shape=None, module_size=None, orientation=0)

Bases: Eiger2CdTe

Eiger2 CdTe 500k detector

MAX_SHAPE = (512, 1028)

aliases = ['Eiger2 CdTe 500k']

class pyFAI.detectors.Eiger2CdTe_9M(pixel1=7.5e-05, pixel2=7.5e-05, max_shape=None, module_size=None, orientation=0)

Bases: Eiger2CdTe

Eiger2 CdTe 9M detector

MAX_SHAPE = (3262, 3108)

aliases = ['Eiger2 CdTe 9M']

class pyFAI.detectors.Eiger2_16M(pixel1=7.5e-05, pixel2=7.5e-05, max_shape=None, module_size=None, orientation=0)

Bases: Eiger2

Eiger2 16M detector

MAX_SHAPE = (4362, 4148)

aliases = ['Eiger2 16M']

class pyFAI.detectors.Eiger2_1M(pixel1=7.5e-05, pixel2=7.5e-05, max_shape=None, module_size=None, orientation=0)

Bases: Eiger2

Eiger2 1M detector

MAX_SHAPE = (1062, 1028)

aliases = ['Eiger2 1M']

class pyFAI.detectors.Eiger2_1MW(pixel1=7.5e-05, pixel2=7.5e-05, max_shape=None, module_size=None, orientation=0)

Bases: Eiger2

Eiger2 1M-Wide detector

MAX_SHAPE = (512, 2068)

aliases = ['Eiger2 1M-W']

class pyFAI.detectors.Eiger2_250k(pixel1=7.5e-05, pixel2=7.5e-05, max_shape=None, module_size=None, orientation=0)

Bases: Eiger2

Eiger2 250k detector

MAX_SHAPE = (512, 512)

aliases = ['Eiger2 250k']

class pyFAI.detectors.Eiger2_2MW(pixel1=7.5e-05, pixel2=7.5e-05, max_shape=None, module_size=None, orientation=0)

Bases: Eiger2

Eiger2 2M-Wide detector

MAX_SHAPE = (512, 4148)

aliases = ['Eiger2 2M-W']

class pyFAI.detectors.Eiger2_4M(pixel1=7.5e-05, pixel2=7.5e-05, max_shape=None, module_size=None, orientation=0)

Bases: Eiger2

Eiger2 4M detector

MAX_SHAPE = (2162, 2068)

aliases = ['Eiger2 4M']

class pyFAI.detectors.Eiger2_500k(pixel1=7.5e-05, pixel2=7.5e-05, max_shape=None, module_size=None, orientation=0)

Bases: Eiger2

Eiger2 500k detector

MAX_SHAPE = (512, 1028)

aliases = ['Eiger2 500k']

class pyFAI.detectors.Eiger2_9M(pixel1=7.5e-05, pixel2=7.5e-05, max_shape=None, module_size=None, orientation=0)

Bases: Eiger2

Eiger2 9M detector

MAX_SHAPE = (3262, 3108)

aliases = ['Eiger2 9M']

class pyFAI.detectors.Eiger4M(pixel1=7.5e-05, pixel2=7.5e-05, max_shape=None, module_size=None, orientation=0)

Bases: Eiger

Eiger 4M detector

MAX_SHAPE = (2167, 2070)

aliases = ['Eiger 4M']

class pyFAI.detectors.Eiger500k(pixel1=7.5e-05, pixel2=7.5e-05, max_shape=None, module_size=None, orientation=0)

Bases: Eiger

Eiger 1M detector

MAX_SHAPE = (514, 1030)

aliases = ['Eiger 500k']

class pyFAI.detectors.Eiger9M(pixel1=7.5e-05, pixel2=7.5e-05, max_shape=None, module_size=None, orientation=0)

Bases: Eiger

Eiger 9M detector

MAX_SHAPE = (3269, 3110)

aliases = ['Eiger 9M']

class pyFAI.detectors.FReLoN(splineFile=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 reagion”

HAVE_TAPER = True: If true a spline file is mandatory to correct the geometry

MANUFACTURER = 'ESRF'

MAX_SHAPE = (2048, 2048)

__init__(splineFile=None, orientation=0)

Parameters:

pixel1 (float) – size of the pixel in meter along the slow dimension (often Y)
pixel2 (float) – size of the pixel in meter along the fast dimension (often X)
splineFile (str) – path to file containing the geometric correction.
max_shape (2-tuple of integrers) – maximum size of the detector
orientation – Orientation of the detector

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

get_config()

Return the configuration with arguments to the constructor

Returns:: dict with param for serialization

class pyFAI.detectors.Fairchild(pixel1=1.5e-05, pixel2=1.5e-05, max_shape=None, orientation=0)

Bases: Detector

Fairchild Condor 486:90 detector

MANUFACTURER = 'Fairchild Semiconductor'

MAX_SHAPE = (4096, 4096)

__init__(pixel1=1.5e-05, pixel2=1.5e-05, max_shape=None, orientation=0)

Parameters:

pixel1 (float) – size of the pixel in meter along the slow dimension (often Y)
pixel2 (float) – size of the pixel in meter along the fast dimension (often X)
splineFile (str) – path to file containing the geometric correction.
max_shape (2-tuple of integrers) – maximum size of the detector
orientation – Orientation of the detector

aliases = ['Fairchild', 'Condor', 'Fairchild Condor 486:90']

force_pixel = True

get_config()

Return the configuration with arguments to the constructor

Returns:: dict with param for serialization

uniform_pixel = True

class pyFAI.detectors.HF_130K(pixel1=0.00015, pixel2=0.00015, max_shape=None, orientation=0)

Bases: _ADSC

ADSC HF-130K 1 module

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

MAX_SHAPE = (256, 512)

__init__(pixel1=0.00015, pixel2=0.00015, max_shape=None, orientation=0)

Parameters:

pixel1 (float) – size of the pixel in meter along the slow dimension (often Y)
pixel2 (float) – size of the pixel in meter along the fast dimension (often X)
splineFile (str) – path to file containing the geometric correction.
max_shape (2-tuple of integrers) – maximum size of the detector
orientation – Orientation of the detector

aliases = ['HF-130k']

force_pixel = True

class pyFAI.detectors.HF_1M(pixel1=0.00015, pixel2=0.00015, max_shape=None, orientation=0)

Bases: _ADSC

ADSC HF-1M 2x4 modules

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

Nota: gaps between modules is not known/described

MAX_SHAPE = (1024, 1024)

__init__(pixel1=0.00015, pixel2=0.00015, max_shape=None, orientation=0)

Parameters:

pixel1 (float) – size of the pixel in meter along the slow dimension (often Y)
pixel2 (float) – size of the pixel in meter along the fast dimension (often X)
splineFile (str) – path to file containing the geometric correction.
max_shape (2-tuple of integrers) – maximum size of the detector
orientation – Orientation of the detector

aliases = ['HF-1M']

force_pixel = True

class pyFAI.detectors.HF_262k(pixel1=0.00015, pixel2=0.00015, max_shape=None, orientation=0)

Bases: _ADSC

ADSC HF-262k 2 module

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

Nota: gaps between modules is not known/described

MAX_SHAPE = (512, 512)

__init__(pixel1=0.00015, pixel2=0.00015, max_shape=None, orientation=0)

Parameters:

pixel1 (float) – size of the pixel in meter along the slow dimension (often Y)
pixel2 (float) – size of the pixel in meter along the fast dimension (often X)
splineFile (str) – path to file containing the geometric correction.
max_shape (2-tuple of integrers) – maximum size of the detector
orientation – Orientation of the detector

aliases = ['HF-262k']

force_pixel = True

class pyFAI.detectors.HF_2M(pixel1=0.00015, pixel2=0.00015, max_shape=None, orientation=0)

Bases: _ADSC

ADSC HF-1M 3x6 modules

Informations 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)

__init__(pixel1=0.00015, pixel2=0.00015, max_shape=None, orientation=0)

Parameters:

pixel1 (float) – size of the pixel in meter along the slow dimension (often Y)
pixel2 (float) – size of the pixel in meter along the fast dimension (often X)
splineFile (str) – path to file containing the geometric correction.
max_shape (2-tuple of integrers) – maximum size of the detector
orientation – Orientation of the detector

aliases = ['HF-2.4M']

force_pixel = True

class pyFAI.detectors.HF_4M(pixel1=0.00015, pixel2=0.00015, max_shape=None, orientation=0)

Bases: _ADSC

ADSC HF-4M 4x8 modules

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

MAX_SHAPE = (2048, 2048)

__init__(pixel1=0.00015, pixel2=0.00015, max_shape=None, orientation=0)

Parameters:

pixel1 (float) – size of the pixel in meter along the slow dimension (often Y)
pixel2 (float) – size of the pixel in meter along the fast dimension (often X)
splineFile (str) – path to file containing the geometric correction.
max_shape (2-tuple of integrers) – maximum size of the detector
orientation – Orientation of the detector

aliases = ['HF-4M']

force_pixel = True

class pyFAI.detectors.HF_9M(pixel1=0.00015, pixel2=0.00015, max_shape=None, orientation=0)

Bases: _ADSC

ADSC HF-130K 1 module

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

MAX_SHAPE = (3072, 3072)

__init__(pixel1=0.00015, pixel2=0.00015, max_shape=None, orientation=0)

Parameters:

pixel1 (float) – size of the pixel in meter along the slow dimension (often Y)
pixel2 (float) – size of the pixel in meter along the fast dimension (often X)
splineFile (str) – path to file containing the geometric correction.
max_shape (2-tuple of integrers) – maximum size of the detector
orientation – Orientation of the detector

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)

Parameters:

pixel1 (float) – size of the pixel in meter along the slow dimension (often Y)
pixel2 (float) – size of the pixel in meter along the fast dimension (often X)
splineFile (str) – path to file containing the geometric correction.
max_shape (2-tuple of integrers) – maximum size of the detector
orientation – Orientation of the detector

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)

Bases: Detector

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)

__init__(pixel1=0.00013, pixel2=0.00013, max_shape=None, module_size=None, orientation=0)

Parameters:

pixel1 (float) – size of the pixel in meter along the slow dimension (often Y)
pixel2 (float) – size of the pixel in meter along the fast dimension (often X)
splineFile (str) – path to file containing the geometric correction.
max_shape (2-tuple of integrers) – maximum size of the detector
orientation – Orientation of the detector

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_config()

Return the configuration with arguments to the constructor

Returns:: dict with param for serialization

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)

set_config(config)

set the config of the detector

For Xpad detector, possible keys are: max_shape, module_size

Parameters:: config – dict or JSON serialized dict
Returns:: detector instance

uniform_pixel = False

class pyFAI.detectors.ImXPadS140(pixel1=0.00013, pixel2=0.00013, max_shape=None, module_size=None, orientation=0)

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)

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)

Parameters:

pixel1 (float) – size of the pixel in meter along the slow dimension (often Y)
pixel2 (float) – size of the pixel in meter along the fast dimension (often X)
splineFile (str) – path to file containing the geometric correction.
max_shape (2-tuple of integrers) – maximum size of the detector
orientation – Orientation of the detector

aliases = ['Imxpad S70']

force_pixel = True

class pyFAI.detectors.ImXPadS70V(pixel1=0.00013, pixel2=0.00013, max_shape=None, module_size=None, orientation=0)

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)

Bases: Detector

Raw Jungfrau module without sub-module pixel expension applied.

BORDER_SIZE_RELATIVE = 2.0

MANUFACTURER = 'PSI'

MAX_SHAPE = (512, 1024)

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)

Parameters:

pixel1 (float) – size of the pixel in meter along the slow dimension (often Y)
pixel2 (float) – size of the pixel in meter along the fast dimension (often X)
splineFile (str) – path to file containing the geometric correction.
max_shape (2-tuple of integrers) – maximum size of the detector
orientation – Orientation of the detector

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.Jungfrau4M(pixel1=7.5e-05, pixel2=7.5e-05, max_shape=None, module_size=None, orientation=0)

Bases: _Dectris

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

MANUFACTURER = 'PSI'

MAX_SHAPE = (2164, 2068)

MODULE_GAP = (36, 8)

MODULE_SIZE = (514, 1030)

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)

Parameters:

pixel1 (float) – size of the pixel in meter along the slow dimension (often Y)
pixel2 (float) – size of the pixel in meter along the fast dimension (often X)
splineFile (str) – path to file containing the geometric correction.
max_shape (2-tuple of integrers) – maximum size of the detector
orientation – Orientation of the detector

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)

Bases: Jungfrau

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

To simplyfy 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)

Parameters:

pixel1 (float) – size of the pixel in meter along the slow dimension (often Y)
pixel2 (float) – size of the pixel in meter along the fast dimension (often X)
splineFile (str) – path to file containing the geometric correction.
max_shape (2-tuple of integrers) – maximum size of the detector
orientation – Orientation of the detector

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)

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

Stollen from Alejandro Homs’ code

class pyFAI.detectors.Lambda10M(pixel1=5.5e-05, pixel2=5.5e-05, max_shape=None, module_size=None, orientation=0)

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)

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)

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)

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)

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)

Bases: _Lambda

LAMBDA 7.5M detector

MAX_SHAPE = (2596, 2596)

aliases = ['Lambda 7.5M']

class pyFAI.detectors.Mar345(pixel1=0.0001, pixel2=0.0001, max_shape=None, orientation=0)

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)

VALID_SIZE = {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)

Parameters:

pixel1 (float) – size of the pixel in meter along the slow dimension (often Y)
pixel2 (float) – size of the pixel in meter along the fast dimension (often X)
splineFile (str) – path to file containing the geometric correction.
max_shape (2-tuple of integrers) – maximum size of the detector
orientation – Orientation of the detector

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

get_config()

Return the configuration with arguments to the constructor

Returns:: dict with param for serialization

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

set_config(config)

set the config of the detector

For Eiger detector, possible keys are: max_shape, module_size

Parameters:: config – dict or JSON serialized dict
Returns:: detector instance

class pyFAI.detectors.Mar555(pixel1=0.000139, pixel2=0.000139, max_shape=None, orientation=0)

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)

__init__(pixel1=0.000139, pixel2=0.000139, max_shape=None, orientation=0)

Parameters:

pixel1 (float) – size of the pixel in meter along the slow dimension (often Y)
pixel2 (float) – size of the pixel in meter along the fast dimension (often X)
splineFile (str) – path to file containing the geometric correction.
max_shape (2-tuple of integrers) – maximum size of the detector
orientation – Orientation of the detector

aliases = ['MAR 555']

force_pixel = True

get_config()

Return the configuration with arguments to the constructor

Returns:: dict with param for serialization

set_config(config)

set the config of the detector

For Eiger detector, possible keys are: max_shape, module_size

Parameters:: config – dict or JSON serialized dict
Returns:: detector instance

class pyFAI.detectors.Maxipix(pixel1=5.5e-05, pixel2=5.5e-05, max_shape=None, module_size=None, orientation=0)

Bases: Detector

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)

__init__(pixel1=5.5e-05, pixel2=5.5e-05, max_shape=None, module_size=None, orientation=0)

Parameters:

pixel1 (float) – size of the pixel in meter along the slow dimension (often Y)
pixel2 (float) – size of the pixel in meter along the fast dimension (often X)
splineFile (str) – path to file containing the geometric correction.
max_shape (2-tuple of integrers) – maximum size of the detector
orientation – Orientation of the detector

aliases = ['Maxipix 1x1', 'Maxipix1x1']

calc_mask(): Returns a generic mask for Mexipix detectors…

force_pixel = True

get_config()

Return the configuration with arguments to the constructor

Returns:: dict with param for serialization

set_config(config)

set the config of the detector

For Eiger detector, possible keys are: max_shape, module_size

Parameters:: config – dict or JSON serialized dict
Returns:: detector instance

class pyFAI.detectors.Maxipix2x2(pixel1=5.5e-05, pixel2=5.5e-05, max_shape=None, module_size=None, orientation=0)

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)

Bases: Maxipix

Maxipix 5x1 detector

MAX_SHAPE = (256, 1296)

aliases = ['Maxipix 5x1']

class pyFAI.detectors.Mythen(pixel1=0.008, pixel2=5e-05, orientation=0)

Bases: _Dectris

Mythen strip detector from Dectris

MAX_SHAPE = (1, 1280)

__init__(pixel1=0.008, pixel2=5e-05, orientation=0)

Parameters:

pixel1 (float) – size of the pixel in meter along the slow dimension (often Y)
pixel2 (float) – size of the pixel in meter along the fast dimension (often X)
splineFile (str) – path to file containing the geometric correction.
max_shape (2-tuple of integrers) – maximum size of the detector
orientation – Orientation of the detector

aliases = ['Mythen 1280']

calc_mask(): Mythen have no masks

force_pixel = True

get_config()

Return the configuration with arguments to the constructor

Returns:: dict with param for serialization

class pyFAI.detectors.NexusDetector(filename=None)

Bases: Detector

Class representing a 2D detector loaded from a NeXus file

__init__(filename=None)

Parameters:

pixel1 (float) – size of the pixel in meter along the slow dimension (often Y)
pixel2 (float) – size of the pixel in meter along the fast dimension (often X)
splineFile (str) – path to file containing the geometric correction.
max_shape (2-tuple of integrers) – maximum size of the detector
orientation – Orientation of the detector

property filename

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

Returns:: dict with param for serialization

get_filename()

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

set_config(config)

set the config of the detector

For Nexus detector, the only valid key is “filename”

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)

__init__(pixel1=0.0002, pixel2=0.0002, max_shape=None, orientation=0)

Parameters:

pixel1 (float) – size of the pixel in meter along the slow dimension (often Y)
pixel2 (float) – size of the pixel in meter along the fast dimension (often X)
splineFile (str) – path to file containing the geometric correction.
max_shape (2-tuple of integrers) – maximum size of the detector
orientation – Orientation of the detector

aliases = ['Perkin detector', 'Perkin Elmer']

force_pixel = True

get_config()

Return the configuration with arguments to the constructor

Returns:: dict with param for serialization

class pyFAI.detectors.Pilatus(pixel1=0.000172, pixel2=0.000172, max_shape=None, module_size=None, x_offset_file=None, y_offset_file=None, orientation=0)

Bases: _Dectris

Pilatus detector: generic description containing mask algorithm

Sub-classed by Pilatus1M, Pilatus2M and Pilatus6M

MODULE_GAP = (17, 7)

MODULE_SIZE = (195, 487)

__init__(pixel1=0.000172, pixel2=0.000172, max_shape=None, module_size=None, x_offset_file=None, y_offset_file=None, orientation=0)

Parameters:

pixel1 (float) – size of the pixel in meter along the slow dimension (often Y)
pixel2 (float) – size of the pixel in meter along the fast dimension (often X)
splineFile (str) – path to file containing the geometric correction.
max_shape (2-tuple of integrers) – maximum size of the detector
orientation – Orientation of the detector

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)

set the config of the detector

For Eiger detector, possible keys are: max_shape, module_size, x_offset_file, y_offset_file

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

class pyFAI.detectors.Pilatus100k(pixel1=0.000172, pixel2=0.000172, max_shape=None, module_size=None, x_offset_file=None, y_offset_file=None, orientation=0)

Bases: Pilatus

Pilatus 100k detector

MAX_SHAPE = (195, 487)

aliases = ['Pilatus 100k']

class pyFAI.detectors.Pilatus1M(pixel1=0.000172, pixel2=0.000172, max_shape=None, module_size=None, x_offset_file=None, y_offset_file=None, orientation=0)

Bases: Pilatus

Pilatus 1M detector

MAX_SHAPE = (1043, 981)

aliases = ['Pilatus 1M']

class pyFAI.detectors.Pilatus200k(pixel1=0.000172, pixel2=0.000172, max_shape=None, module_size=None, x_offset_file=None, y_offset_file=None, orientation=0)

Bases: Pilatus

Pilatus 200k detector

MAX_SHAPE = (407, 487)

aliases = ['Pilatus 200k']

class pyFAI.detectors.Pilatus2M(pixel1=0.000172, pixel2=0.000172, max_shape=None, module_size=None, x_offset_file=None, y_offset_file=None, orientation=0)

Bases: Pilatus

Pilatus 2M detector

MAX_SHAPE = (1679, 1475)

aliases = ['Pilatus 2M']

class pyFAI.detectors.Pilatus300k(pixel1=0.000172, pixel2=0.000172, max_shape=None, module_size=None, x_offset_file=None, y_offset_file=None, orientation=0)

Bases: Pilatus

Pilatus 300k detector

MAX_SHAPE = (619, 487)

aliases = ['Pilatus 300k']

class pyFAI.detectors.Pilatus300kw(pixel1=0.000172, pixel2=0.000172, max_shape=None, module_size=None, x_offset_file=None, y_offset_file=None, orientation=0)

Bases: Pilatus

Pilatus 300k-wide detector

MAX_SHAPE = (195, 1475)

aliases = ['Pilatus 300kw']

class pyFAI.detectors.Pilatus4(pixel1=0.00015, pixel2=0.00015, max_shape=None, orientation=0)

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)

__init__(pixel1=0.00015, pixel2=0.00015, max_shape=None, orientation=0)

Parameters:

pixel1 (float) – size of the pixel in meter along the slow dimension (often Y)
pixel2 (float) – size of the pixel in meter along the fast dimension (often X)
splineFile (str) – path to file containing the geometric correction.
max_shape (2-tuple of integrers) – maximum size of the detector
orientation – Orientation of the detector

force_pixel = True

class pyFAI.detectors.Pilatus4_1M(pixel1=0.00015, pixel2=0.00015, max_shape=None, orientation=0)

Bases: Pilatus4

MAX_SHAPE = (1080, 1033)

aliases = ['Pilatus4 1M']

class pyFAI.detectors.Pilatus4_260k(pixel1=0.00015, pixel2=0.00015, max_shape=None, orientation=0)

Bases: Pilatus4

MAX_SHAPE = (530, 513)

aliases = ['Pilatus4 260k']

class pyFAI.detectors.Pilatus4_260kw(pixel1=0.00015, pixel2=0.00015, max_shape=None, orientation=0)

Bases: Pilatus4

MAX_SHAPE = (255, 1033)

aliases = ['Pilatus4 260kw']

class pyFAI.detectors.Pilatus4_2M(pixel1=0.00015, pixel2=0.00015, max_shape=None, orientation=0)

Bases: Pilatus4

MAX_SHAPE = (1630, 1553)

aliases = ['Pilatus4 2M']

class pyFAI.detectors.Pilatus4_4M(pixel1=0.00015, pixel2=0.00015, max_shape=None, orientation=0)

Bases: Pilatus4

MAX_SHAPE = (2180, 2073)

aliases = ['Pilatus4 4M']

class pyFAI.detectors.Pilatus4_CdTe(pixel1=0.000172, pixel2=0.000172, max_shape=None, module_size=None, x_offset_file=None, y_offset_file=None, orientation=0)

Bases: Pilatus

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

calc_mask(): Mask out an extra 3 pixel in the middle of each module

class pyFAI.detectors.Pilatus4_CdTe_1M(pixel1=0.000172, pixel2=0.000172, max_shape=None, module_size=None, x_offset_file=None, y_offset_file=None, orientation=0)

Bases: Pilatus4_CdTe

MAX_SHAPE = (1080, 1033)

aliases = ['Pilatus4 1M CdTe']

class pyFAI.detectors.Pilatus4_CdTe_260k(pixel1=0.000172, pixel2=0.000172, max_shape=None, module_size=None, x_offset_file=None, y_offset_file=None, orientation=0)

Bases: Pilatus4_CdTe

MAX_SHAPE = (530, 513)

aliases = ['Pilatus4 260k CdTe']

class pyFAI.detectors.Pilatus4_CdTe_260kw(pixel1=0.000172, pixel2=0.000172, max_shape=None, module_size=None, x_offset_file=None, y_offset_file=None, orientation=0)

Bases: Pilatus4_CdTe

MAX_SHAPE = (255, 1033)

aliases = ['Pilatus4 260kw CdTe']

class pyFAI.detectors.Pilatus4_CdTe_2M(pixel1=0.000172, pixel2=0.000172, max_shape=None, module_size=None, x_offset_file=None, y_offset_file=None, orientation=0)

Bases: Pilatus4_CdTe

MAX_SHAPE = (1630, 1553)

aliases = ['Pilatus4 2M CdTe']

class pyFAI.detectors.Pilatus4_CdTe_4M(pixel1=0.000172, pixel2=0.000172, max_shape=None, module_size=None, x_offset_file=None, y_offset_file=None, orientation=0)

Bases: Pilatus4_CdTe

MAX_SHAPE = (2180, 2073)

aliases = ['Pilatus4 4M CdTe']

class pyFAI.detectors.Pilatus6M(pixel1=0.000172, pixel2=0.000172, max_shape=None, module_size=None, x_offset_file=None, y_offset_file=None, orientation=0)

Bases: Pilatus

Pilatus 6M detector

MAX_SHAPE = (2527, 2463)

aliases = ['Pilatus 6M']

class pyFAI.detectors.Pilatus900k(pixel1=0.000172, pixel2=0.000172, max_shape=None, module_size=None, x_offset_file=None, y_offset_file=None, orientation=0)

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=0.000172, pixel2=0.000172, max_shape=None, module_size=None, x_offset_file=None, y_offset_file=None, orientation=0)

Bases: Pilatus

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

calc_mask(): Mask out an extra 3 pixel in the middle of each module

class pyFAI.detectors.PilatusCdTe1M(pixel1=0.000172, pixel2=0.000172, max_shape=None, module_size=None, x_offset_file=None, y_offset_file=None, orientation=0)

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=0.000172, pixel2=0.000172, max_shape=None, module_size=None, x_offset_file=None, y_offset_file=None, orientation=0)

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=0.000172, pixel2=0.000172, max_shape=None, module_size=None, x_offset_file=None, y_offset_file=None, orientation=0)

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=0.000172, pixel2=0.000172, max_shape=None, module_size=None, x_offset_file=None, y_offset_file=None, orientation=0)

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=0.000172, pixel2=0.000172, max_shape=None, module_size=None, x_offset_file=None, y_offset_file=None, orientation=0)

Bases: PilatusCdTe

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

This differes 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)

Parameters:

pixel1 (float) – size of the pixel in meter along the slow dimension (often Y)
pixel2 (float) – size of the pixel in meter along the fast dimension (often X)
splineFile (str) – path to file containing the geometric correction.
max_shape (2-tuple of integrers) – maximum size of the detector
orientation – Orientation of the detector

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)

Parameters:

pixel1 (float) – size of the pixel in meter along the slow dimension (often Y)
pixel2 (float) – size of the pixel in meter along the fast dimension (often X)
splineFile (str) – path to file containing the geometric correction.
max_shape (2-tuple of integrers) – maximum size of the detector
orientation – Orientation of the detector

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)

Parameters:

pixel1 (float) – size of the pixel in meter along the slow dimension (often Y)
pixel2 (float) – size of the pixel in meter along the fast dimension (often X)
splineFile (str) – path to file containing the geometric correction.
max_shape (2-tuple of integrers) – maximum size of the detector
orientation – Orientation of the detector

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)

Parameters:

pixel1 (float) – size of the pixel in meter along the slow dimension (often Y)
pixel2 (float) – size of the pixel in meter along the fast dimension (often X)
splineFile (str) – path to file containing the geometric correction.
max_shape (2-tuple of integrers) – maximum size of the detector
orientation – Orientation of the detector

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)

__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

get_config()

Return the configuration with arguments to the constructor

Returns:: dict with param for serialization

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)

Parameters:

pixel1 (float) – size of the pixel in meter along the slow dimension (often Y)
pixel2 (float) – size of the pixel in meter along the fast dimension (often X)
splineFile (str) – path to file containing the geometric correction.
max_shape (2-tuple of integrers) – maximum size of the detector
orientation – Orientation of the detector

aliases = ['RapidII']

class pyFAI.detectors.RaspberryPi5M(pixel1=1.4e-06, pixel2=1.4e-06, max_shape=None, orientation=0)

Bases: Detector

5 Mpix detector from Raspberry Pi

MAX_SHAPE = (1944, 2592)

__init__(pixel1=1.4e-06, pixel2=1.4e-06, max_shape=None, orientation=0)

Parameters:

pixel1 (float) – size of the pixel in meter along the slow dimension (often Y)
pixel2 (float) – size of the pixel in meter along the fast dimension (often X)
splineFile (str) – path to file containing the geometric correction.
max_shape (2-tuple of integrers) – maximum size of the detector
orientation – Orientation of the detector

aliases = ['Picam v1']

force_pixel = True

get_config()

Return the configuration with arguments to the constructor

Returns:: dict with param for serialization

class pyFAI.detectors.RaspberryPi8M(pixel1=1.12e-06, pixel2=1.12e-06, max_shape=None, orientation=0)

Bases: Detector

8 Mpix detector from Raspberry Pi

MAX_SHAPE = (2464, 3280)

__init__(pixel1=1.12e-06, pixel2=1.12e-06, max_shape=None, orientation=0)

Parameters:

pixel1 (float) – size of the pixel in meter along the slow dimension (often Y)
pixel2 (float) – size of the pixel in meter along the fast dimension (often X)
splineFile (str) – path to file containing the geometric correction.
max_shape (2-tuple of integrers) – maximum size of the detector
orientation – Orientation of the detector

aliases = ['Picam v2']

force_pixel = True

get_config()

Return the configuration with arguments to the constructor

Returns:: dict with param for serialization

class pyFAI.detectors.Rayonix133(pixel1=6.4e-05, pixel2=6.4e-05, max_shape=None, orientation=0)

Bases: _Rayonix

Rayonix 133 2D CCD detector detector also known as mar133

Personnal communication from M. Blum

What should be the default binning factor for those cameras ?

Circular detector

BINNED_PIXEL_SIZE = {1: 3.2e-05, 2: 6.4e-05, 4: 0.000128, 8: 0.000256}

MANUFACTURER = ['Rayonix', 'Mar Research']

MAX_SHAPE = (4096, 4096)

__init__(pixel1=6.4e-05, pixel2=6.4e-05, max_shape=None, orientation=0)

Parameters:

pixel1 (float) – size of the pixel in meter along the slow dimension (often Y)
pixel2 (float) – size of the pixel in meter along the fast dimension (often X)
splineFile (str) – path to file containing the geometric correction.
max_shape (2-tuple of integrers) – maximum size of the detector
orientation – Orientation of the detector

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)

Bases: _Rayonix

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

Nota: this is the same for lx170hs

BINNED_PIXEL_SIZE = {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)

Parameters:

pixel1 (float) – size of the pixel in meter along the slow dimension (often Y)
pixel2 (float) – size of the pixel in meter along the fast dimension (often X)
splineFile (str) – path to file containing the geometric correction.
max_shape (2-tuple of integrers) – maximum size of the detector
orientation – Orientation of the detector

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)

Bases: _Rayonix

Rayonix lx255 2d Detector (3x1 CCDs)

Nota: this detector is also called lx255hs

BINNED_PIXEL_SIZE = {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)

Parameters:

pixel1 (float) – size of the pixel in meter along the slow dimension (often Y)
pixel2 (float) – size of the pixel in meter along the fast dimension (often X)
splineFile (str) – path to file containing the geometric correction.
max_shape (2-tuple of integrers) – maximum size of the detector
orientation – Orientation of the detector

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)

Bases: _Rayonix

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

Nota: this is the same for mx170hs

BINNED_PIXEL_SIZE = {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)

Parameters:

pixel1 (float) – size of the pixel in meter along the slow dimension (often Y)
pixel2 (float) – size of the pixel in meter along the fast dimension (often X)
splineFile (str) – path to file containing the geometric correction.
max_shape (2-tuple of integrers) – maximum size of the detector
orientation – Orientation of the detector

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)

Bases: _Rayonix

Rayonix mx225 2D CCD detector detector

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

BINNED_PIXEL_SIZE = {1: 3.6621e-05, 2: 7.3242e-05, 3: 0.000109971, 4: 0.000146484, 8: 0.000292969}

MANUFACTURER = ['Rayonix', 'Mar Research']

MAX_SHAPE = (6144, 6144)

__init__(pixel1=7.3242e-05, pixel2=7.3242e-05, max_shape=None, orientation=0)

Parameters:

pixel1 (float) – size of the pixel in meter along the slow dimension (often Y)
pixel2 (float) – size of the pixel in meter along the fast dimension (often X)
splineFile (str) – path to file containing the geometric correction.
max_shape (2-tuple of integrers) – maximum size of the detector
orientation – Orientation of the detector

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)

Bases: _Rayonix

Rayonix mx225hs 2D CCD detector detector

Pixel size from a personnal communication from M. Blum

BINNED_PIXEL_SIZE = {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)

Parameters:

pixel1 (float) – size of the pixel in meter along the slow dimension (often Y)
pixel2 (float) – size of the pixel in meter along the fast dimension (often X)
splineFile (str) – path to file containing the geometric correction.
max_shape (2-tuple of integrers) – maximum size of the detector
orientation – Orientation of the detector

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)

Bases: _Rayonix

Rayonix mx300 2D detector (4x4 CCDs)

Pixel size from a personnal communication from M. Blum

BINNED_PIXEL_SIZE = {1: 3.6621e-05, 2: 7.3242e-05, 3: 0.000109971, 4: 0.000146484, 8: 0.000292969}

MANUFACTURER = ['Rayonix', 'Mar Research']

MAX_SHAPE = (8192, 8192)

__init__(pixel1=7.3242e-05, pixel2=7.3242e-05, max_shape=None, orientation=0)

Parameters:

pixel1 (float) – size of the pixel in meter along the slow dimension (often Y)
pixel2 (float) – size of the pixel in meter along the fast dimension (often X)
splineFile (str) – path to file containing the geometric correction.
max_shape (2-tuple of integrers) – maximum size of the detector
orientation – Orientation of the detector

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)

Bases: _Rayonix

Rayonix mx300hs 2D detector (4x4 CCDs)

Pixel size from a personnal communication from M. Blum

BINNED_PIXEL_SIZE = {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)

Parameters:

pixel1 (float) – size of the pixel in meter along the slow dimension (often Y)
pixel2 (float) – size of the pixel in meter along the fast dimension (often X)
splineFile (str) – path to file containing the geometric correction.
max_shape (2-tuple of integrers) – maximum size of the detector
orientation – Orientation of the detector

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)

Bases: _Rayonix

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

Pixel size from a personnal communication from M. Blum

BINNED_PIXEL_SIZE = {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)

Parameters:

pixel1 (float) – size of the pixel in meter along the slow dimension (often Y)
pixel2 (float) – size of the pixel in meter along the fast dimension (often X)
splineFile (str) – path to file containing the geometric correction.
max_shape (2-tuple of integrers) – maximum size of the detector
orientation – Orientation of the detector

aliases = ['Rayonix MX325']

class pyFAI.detectors.RayonixMx340hs(pixel1=8.85417e-05, pixel2=8.85417e-05, max_shape=None, orientation=0)

Bases: _Rayonix

Rayonix mx340hs 2D detector (4x4 CCDs)

Pixel size from a personnal communication from M. Blum

BINNED_PIXEL_SIZE = {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)

Parameters:

pixel1 (float) – size of the pixel in meter along the slow dimension (often Y)
pixel2 (float) – size of the pixel in meter along the fast dimension (often X)
splineFile (str) – path to file containing the geometric correction.
max_shape (2-tuple of integrers) – maximum size of the detector
orientation – Orientation of the detector

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)

Bases: _Rayonix

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

Pixel size from a personnal communication from M. Blum

BINNED_PIXEL_SIZE = {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)

Parameters:

pixel1 (float) – size of the pixel in meter along the slow dimension (often Y)
pixel2 (float) – size of the pixel in meter along the fast dimension (often X)
splineFile (str) – path to file containing the geometric correction.
max_shape (2-tuple of integrers) – maximum size of the detector
orientation – Orientation of the detector

aliases = ['Rayonix MX425HS', 'Rayonix MX425 HS']

class pyFAI.detectors.RayonixSx165(pixel1=3.95e-05, pixel2=3.95e-05, max_shape=None, orientation=0)

Bases: _Rayonix

Rayonix sx165 2d Detector also known as MAR165.

Circular detector

BINNED_PIXEL_SIZE = {1: 3.95e-05, 2: 7.9e-05, 3: 0.000118616, 4: 0.000158, 8: 0.000316}

MANUFACTURER = ['Rayonix', 'Mar Research']

MAX_SHAPE = (4096, 4096)

__init__(pixel1=3.95e-05, pixel2=3.95e-05, max_shape=None, orientation=0)

Parameters:

pixel1 (float) – size of the pixel in meter along the slow dimension (often Y)
pixel2 (float) – size of the pixel in meter along the fast dimension (often X)
splineFile (str) – path to file containing the geometric correction.
max_shape (2-tuple of integrers) – maximum size of the detector
orientation – Orientation of the detector

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)

Bases: _Rayonix

Rayonix sx200 2d CCD Detector.

Pixel size are personnal communication from M. Blum.

BINNED_PIXEL_SIZE = {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)

Parameters:

pixel1 (float) – size of the pixel in meter along the slow dimension (often Y)
pixel2 (float) – size of the pixel in meter along the fast dimension (often X)
splineFile (str) – path to file containing the geometric correction.
max_shape (2-tuple of integrers) – maximum size of the detector
orientation – Orientation of the detector

aliases = ['Rayonix SX200']

class pyFAI.detectors.RayonixSx30hs(pixel1=1.5625e-05, pixel2=1.5625e-05, max_shape=None, orientation=0)

Bases: _Rayonix

Rayonix sx30hs 2D CCD camera (1 CCD chip)

Pixel size from a personnal communication from M. Blum

BINNED_PIXEL_SIZE = {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)

Parameters:

pixel1 (float) – size of the pixel in meter along the slow dimension (often Y)
pixel2 (float) – size of the pixel in meter along the fast dimension (often X)
splineFile (str) – path to file containing the geometric correction.
max_shape (2-tuple of integrers) – maximum size of the detector
orientation – Orientation of the detector

aliases = ['Rayonix SX30HS', 'Rayonix SX30 HS']

class pyFAI.detectors.RayonixSx85hs(pixel1=4.42708e-05, pixel2=4.42708e-05, max_shape=None, orientation=0)

Bases: _Rayonix

Rayonix sx85hs 2D CCD camera (1 CCD chip)

Pixel size from a personnal communication from M. Blum

BINNED_PIXEL_SIZE = {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)

Parameters:

pixel1 (float) – size of the pixel in meter along the slow dimension (often Y)
pixel2 (float) – size of the pixel in meter along the fast dimension (often X)
splineFile (str) – path to file containing the geometric correction.
max_shape (2-tuple of integrers) – maximum size of the detector
orientation – Orientation of the detector

aliases = ['Rayonix SX85HS', 'Rayonix SX85 HS']

class pyFAI.detectors.Titan(pixel1=6e-05, pixel2=6e-05, max_shape=None, orientation=0)

Bases: Detector

Titan CCD detector from Agilent. Mask not handled

MANUFACTURER = ['Agilent', 'Oxford Diffraction']

MAX_SHAPE = (2048, 2048)

__init__(pixel1=6e-05, pixel2=6e-05, max_shape=None, orientation=0)

Parameters:

pixel1 (float) – size of the pixel in meter along the slow dimension (often Y)
pixel2 (float) – size of the pixel in meter along the fast dimension (often X)
splineFile (str) – path to file containing the geometric correction.
max_shape (2-tuple of integrers) – maximum size of the detector
orientation – Orientation of the detector

aliases = ['Titan 2k x 2k', 'Titan 2k x 2k', 'OXD Titan', 'Agilent Titan']

force_pixel = True

get_config()

Return the configuration with arguments to the constructor

Returns:: dict with param for serialization

uniform_pixel = True

class pyFAI.detectors.Xpad_flat(pixel1=0.00013, pixel2=0.00013, max_shape=None, module_size=None, orientation=0)

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)

Parameters:

pixel1 (float) – size of the pixel in meter along the slow dimension (often Y)
pixel2 (float) – size of the pixel in meter along the fast dimension (often X)
splineFile (str) – path to file containing the geometric correction.
max_shape (2-tuple of integrers) – maximum size of the detector
orientation – Orientation of the detector

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 mis - behaving

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: Union[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