# pyFAI.detectors package

## Module contents

Description of all detectors with a factory to instantiate them.

class `pyFAI.detectors.``Detector`(pixel1=None, pixel2=None, splineFile=None, max_shape=None)

  Bases: `object`

  Generic class representing a 2D detector

  `API_VERSION` = '1.0'
  `HAVE_TAPER` = False

    If true a spline file is mandatory to correct the geometry

  `IS_CONTIGUOUS` = True
  `IS_FLAT` = True
  `MANUFACTURER` = None
  `__init__`(pixel1=None, pixel2=None, splineFile=None, max_shape=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

  `aliases` = []
  `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

  `darkcurrent`
  classmethod `factory`(name, config=None)

    A kind of factory…

    Parameters:

    - name (str) – name of a detector
    - 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

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

    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)

  `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

  `mask`
  `maskfile`
  `name`

    Get a meaningful name for detector

  `pixel1`
  `pixel2`
  `registry` = {'aarhus': <class 'pyFAI.detectors._others.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'>, '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'>, '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'>, 'pilatus6m': <class 'pyFAI.detectors._dectris.Pilatus6M'>, '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_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'>, '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'>, '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'>}
  `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):

  `set_dy`(dy=None)

    set the pixel-wise displacement along Y (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)
  `splineFile`
  `uniform_pixel` = True

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

  Bases: `pyFAI.detectors._common.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

  `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.``ADSC_Q315`(pixel1=5.1e-05, pixel2=5.1e-05)

  Bases: `pyFAI.detectors._adsc._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)

    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

  `aliases` = ['Quantum 315']
  `force_pixel` = True

class `pyFAI.detectors.``ADSC_Q210`(pixel1=5.1e-05, pixel2=5.1e-05)

  Bases: `pyFAI.detectors._adsc._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)

    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

  `aliases` = ['Quantum 210']
  `force_pixel` = True

class `pyFAI.detectors.``ADSC_Q270`(pixel1=6.48e-05, pixel2=6.48e-05)

  Bases: `pyFAI.detectors._adsc._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)

    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

  `aliases` = ['Quantum 270']
  `force_pixel` = True

class `pyFAI.detectors.``ADSC_Q4`(pixel1=8.2e-05, pixel2=8.2e-05)

  Bases: `pyFAI.detectors._adsc._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)

    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

  `aliases` = ['Quantum 4']
  `force_pixel` = True

class `pyFAI.detectors.``HF_130K`(pixel1=0.00015, pixel2=0.00015)

  Bases: `pyFAI.detectors._adsc._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)

    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

  `aliases` = ['HF-130k']
  `force_pixel` = True

class `pyFAI.detectors.``HF_262k`(pixel1=0.00015, pixel2=0.00015)

  Bases: `pyFAI.detectors._adsc._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)

    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

  `aliases` = ['HF-262k']
  `force_pixel` = True

class `pyFAI.detectors.``HF_1M`(pixel1=0.00015, pixel2=0.00015)

  Bases: `pyFAI.detectors._adsc._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)

    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

  `aliases` = ['HF-1M']
  `force_pixel` = True

class `pyFAI.detectors.``HF_2M`(pixel1=0.00015, pixel2=0.00015)

  Bases: `pyFAI.detectors._adsc._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)

    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

  `aliases` = ['HF-2.4M']
  `force_pixel` = True

class `pyFAI.detectors.``HF_4M`(pixel1=0.00015, pixel2=0.00015)

  Bases: `pyFAI.detectors._adsc._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)

    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

  `aliases` = ['HF-4M']
  `force_pixel` = True

class `pyFAI.detectors.``HF_9M`(pixel1=0.00015, pixel2=0.00015)

  Bases: `pyFAI.detectors._adsc._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)

    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

  `aliases` = ['HF-9.4M']
  `force_pixel` = True

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

  Bases: `pyFAI.detectors._dectris._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)

    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

  `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.

  `calc_mask`()

    Returns a generic mask for Pilatus 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.``Eiger500k`(pixel1=7.5e-05, pixel2=7.5e-05, max_shape=None, module_size=None)

  Bases: `pyFAI.detectors._dectris.Eiger`

  Eiger 1M detector

  `MAX_SHAPE` = (514, 1030)
  `aliases` = ['Eiger 500k']

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

  Bases: `pyFAI.detectors._dectris.Eiger`

  Eiger 1M detector

  `MAX_SHAPE` = (1065, 1030)
  `aliases` = ['Eiger 1M']

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

  Bases: `pyFAI.detectors._dectris.Eiger`

  Eiger 4M detector

  `MAX_SHAPE` = (2167, 2070)
  `aliases` = ['Eiger 4M']

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

  Bases: `pyFAI.detectors._dectris.Eiger`

  Eiger 9M detector

  `MAX_SHAPE` = (3269, 3110)
  `aliases` = ['Eiger 9M']

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

  Bases: `pyFAI.detectors._dectris.Eiger`

  Eiger 16M detector

  `MAX_SHAPE` = (4371, 4150)
  `aliases` = ['Eiger 16M']

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

  Bases: `pyFAI.detectors._dectris._Dectris`

  Mythen dtrip detector from Dectris

  `MAX_SHAPE` = (1, 1280)
  `__init__`(pixel1=0.008, pixel2=5e-05)

    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

  `aliases` = ['Mythen 1280']
  `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)

  Bases: `pyFAI.detectors._dectris._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)

    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

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

    Returns a generic mask for Pilatus detectors…

  `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

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

  Bases: `pyFAI.detectors._dectris.Pilatus`

  Pilatus 100k detector

  `MAX_SHAPE` = (195, 487)
  `aliases` = ['Pilatus 100k']

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

  Bases: `pyFAI.detectors._dectris.Pilatus`

  Pilatus 200k detector

  `MAX_SHAPE` = (407, 487)
  `aliases` = ['Pilatus 200k']

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

  Bases: `pyFAI.detectors._dectris.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)

  Bases: `pyFAI.detectors._dectris.Pilatus`

  Pilatus 300k-wide detector

  `MAX_SHAPE` = (195, 1475)
  `aliases` = ['Pilatus 300kw']

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

  Bases: `pyFAI.detectors._dectris.Pilatus`

  Pilatus 1M detector

  `MAX_SHAPE` = (1043, 981)
  `aliases` = ['Pilatus 1M']

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

  Bases: `pyFAI.detectors._dectris.Pilatus`

  Pilatus 2M detector

  `MAX_SHAPE` = (1679, 1475)
  `aliases` = ['Pilatus 2M']

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

  Bases: `pyFAI.detectors._dectris.Pilatus`

  Pilatus 6M detector

  `MAX_SHAPE` = (2527, 2463)
  `aliases` = ['Pilatus 6M']

class `pyFAI.detectors.``PilatusCdTe`(pixel1=0.000172, pixel2=0.000172, max_shape=None, module_size=None, x_offset_file=None, y_offset_file=None)

  Bases: `pyFAI.detectors._dectris.Pilatus`

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

  `calc_mask`()

    Returns a generic mask for Pilatus detectors…

class `pyFAI.detectors.``PilatusCdTe300k`(pixel1=0.000172, pixel2=0.000172, max_shape=None, module_size=None, x_offset_file=None, y_offset_file=None)

  Bases: `pyFAI.detectors._dectris.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)

  Bases: `pyFAI.detectors._dectris.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)

  Bases: `pyFAI.detectors._dectris.PilatusCdTe`

  Pilatus CdTe 900k-wide detector

  `MAX_SHAPE` = (195, 4439)
  `aliases` = ['Pilatus CdTe 900kw', 'Pilatus 900kw CdTe', 'Pilatus900kw CdTe', 'Pilatus900kwCdTe']

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

  Bases: `pyFAI.detectors._dectris.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)

  Bases: `pyFAI.detectors._dectris.PilatusCdTe`

  Pilatus CdTe 2M detector

  `MAX_SHAPE` = (1679, 1475)
  `aliases` = ['Pilatus CdTe 2M', 'Pilatus 2M CdTe', 'Pilatus2M CdTe', 'Pilatus2MCdTe']

class `pyFAI.detectors.``ImXPadS10`(pixel1=0.00013, pixel2=0.00013, max_shape=None, module_size=None)

  Bases: `pyFAI.detectors._common.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)

    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

  `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`(d1=None, d2=None)

    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.``ImXPadS70`(pixel1=0.00013, pixel2=0.00013)

  Bases: `pyFAI.detectors._imxpad.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)

    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

  `aliases` = ['Imxpad S70']
  `force_pixel` = True

class `pyFAI.detectors.``ImXPadS70V`(pixel1=0.00013, pixel2=0.00013)

  Bases: `pyFAI.detectors._imxpad.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)
  `__init__`(pixel1=0.00013, pixel2=0.00013)

    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

  `aliases` = ['Imxpad S70 V']
  `force_pixel` = True

class `pyFAI.detectors.``ImXPadS140`(pixel1=0.00013, pixel2=0.00013)

  Bases: `pyFAI.detectors._imxpad.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)
  `__init__`(pixel1=0.00013, pixel2=0.00013)

    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

  `aliases` = ['Imxpad S140']
  `force_pixel` = True

class `pyFAI.detectors.``Xpad_flat`(pixel1=0.00013, pixel2=0.00013, max_shape=None, module_size=None)

  Bases: `pyFAI.detectors._imxpad.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)

    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

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

    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

class `pyFAI.detectors.``Cirpad`(pixel1=0.00013, pixel2=0.00013)

  Bases: `pyFAI.detectors._imxpad.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)

    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

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

    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.``Rayonix133`(pixel1=6.4e-05, pixel2=6.4e-05)

  Bases: `pyFAI.detectors._rayonix._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)

    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

  `aliases` = ['Rayonix133', 'MAR 133', 'MAR133']
  `calc_mask`()

    Circular mask

  `force_pixel` = True

class `pyFAI.detectors.``RayonixSx165`(pixel1=3.95e-05, pixel2=3.95e-05)

  Bases: `pyFAI.detectors._rayonix._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)

    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

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

  Bases: `pyFAI.detectors._rayonix._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)

    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

  `aliases` = ['Rayonix SX200']

class `pyFAI.detectors.``RayonixLx170`(pixel1=4.42708e-05, pixel2=4.42708e-05)

  Bases: `pyFAI.detectors._rayonix._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)

    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

  `aliases` = ['Rayonix LX170', 'Rayonix LX170-HS', 'Rayonix LX170 HS', 'RayonixLX170HS']
  `force_pixel` = True

class `pyFAI.detectors.``RayonixMx170`(pixel1=4.42708e-05, pixel2=4.42708e-05)

  Bases: `pyFAI.detectors._rayonix._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)

    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

  `aliases` = ['Rayonix MX170', 'Rayonix MX170-HS', 'RayonixMX170HS', 'Rayonix MX170 HS']

class `pyFAI.detectors.``RayonixLx255`(pixel1=4.42708e-05, pixel2=4.42708e-05)

  Bases: `pyFAI.detectors._rayonix._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)

    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

  `aliases` = ['Rayonix LX255', 'Rayonix LX255-HS', 'Rayonix LX 255HS', 'RayonixLX225HS']

class `pyFAI.detectors.``RayonixMx225`(pixel1=7.3242e-05, pixel2=7.3242e-05)

  Bases: `pyFAI.detectors._rayonix._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)

    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

  `aliases` = ['Rayonix MX225', 'MAR 225', 'MAR225']
  `force_pixel` = True

class `pyFAI.detectors.``RayonixMx225hs`(pixel1=7.8125e-05, pixel2=7.8125e-05)

  Bases: `pyFAI.detectors._rayonix._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)

    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

  `aliases` = ['Rayonix MX225HS', 'Rayonix MX225 HS']
  `force_pixel` = True

class `pyFAI.detectors.``RayonixMx300`(pixel1=7.3242e-05, pixel2=7.3242e-05)

  Bases: `pyFAI.detectors._rayonix._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)

    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

  `aliases` = ['Rayonix MX300', 'MAR 300', 'MAR300']
  `force_pixel` = True

class `pyFAI.detectors.``RayonixMx300hs`(pixel1=7.8125e-05, pixel2=7.8125e-05)

  Bases: `pyFAI.detectors._rayonix._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)

    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

  `aliases` = ['Rayonix MX300HS', 'Rayonix MX300 HS']
  `force_pixel` = True

class `pyFAI.detectors.``RayonixMx340hs`(pixel1=8.85417e-05, pixel2=8.85417e-05)

  Bases: `pyFAI.detectors._rayonix._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)

    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

  `aliases` = ['Rayonix MX340HS', 'Rayonix MX340HS']
  `force_pixel` = True

class `pyFAI.detectors.``RayonixSx30hs`(pixel1=1.5625e-05, pixel2=1.5625e-05)

  Bases: `pyFAI.detectors._rayonix._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)

    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

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

class `pyFAI.detectors.``RayonixSx85hs`(pixel1=4.42708e-05, pixel2=4.42708e-05)

  Bases: `pyFAI.detectors._rayonix._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)

    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

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

class `pyFAI.detectors.``RayonixMx425hs`(pixel1=4.42708e-05, pixel2=4.42708e-05)

  Bases: `pyFAI.detectors._rayonix._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)

    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

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

class `pyFAI.detectors.``RayonixMx325`(pixel1=7.9346e-05, pixel2=7.9346e-05)

  Bases: `pyFAI.detectors._rayonix._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)

    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

  `aliases` = ['Rayonix MX325']

class `pyFAI.detectors.``Mar345`(pixel1=0.0001, pixel2=0.0001)

  Bases: `pyFAI.detectors._common.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)

    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

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

  Bases: `pyFAI.detectors._common.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)

    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

  `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.``FReLoN`(splineFile=None)

  Bases: `pyFAI.detectors._common.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
  `MANUFACTURER` = 'ESRF'
  `MAX_SHAPE` = (2048, 2048)
  `__init__`(splineFile=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

  `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.``Maxipix`(pixel1=5.5e-05, pixel2=5.5e-05, max_shape=None, module_size=None)

  Bases: `pyFAI.detectors._common.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)

    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

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

  Bases: `pyFAI.detectors._esrf.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)

  Bases: `pyFAI.detectors._esrf.Maxipix`

  Maxipix 5x1 detector

  `MAX_SHAPE` = (256, 1296)
  `aliases` = ['Maxipix 5x1']

class `pyFAI.detectors.``Fairchild`(pixel1=1.5e-05, pixel2=1.5e-05)

  Bases: `pyFAI.detectors._common.Detector`

  Fairchild Condor 486:90 detector

  `MANUFACTURER` = 'Fairchild Semiconductor'
  `MAX_SHAPE` = (4096, 4096)
  `__init__`(pixel1=1.5e-05, pixel2=1.5e-05)

    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

  `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.``Titan`(pixel1=6e-05, pixel2=6e-05)

  Bases: `pyFAI.detectors._common.Detector`

  Titan CCD detector from Agilent. Mask not handled

  `MANUFACTURER` = ['Agilent', 'Oxford Diffraction']
  `MAX_SHAPE` = (2048, 2048)
  `__init__`(pixel1=6e-05, pixel2=6e-05)

    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

  `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.``Dexela2923`(pixel1=7.5e-05, pixel2=7.5e-05)

  Bases: `pyFAI.detectors._common.Detector`

  Dexela CMOS family detector

  `MAX_SHAPE` = (3888, 3072)
  `__init__`(pixel1=7.5e-05, pixel2=7.5e-05)

    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

  `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.``Basler`(pixel=3.75e-06)

  Bases: `pyFAI.detectors._common.Detector`

  Basler camera are simple CCD camara over GigaE

  `MANUFACTURER` = 'Basler'
  `MAX_SHAPE` = (966, 1296)
  `__init__`(pixel=3.75e-06)

    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

  `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.``Perkin`(pixel1=0.0002, pixel2=0.0002)

  Bases: `pyFAI.detectors._common.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)

    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

  `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.``Aarhus`(pixel1=2.4893e-05, pixel2=2.4893e-05, radius=0.29989)

  Bases: `pyFAI.detectors._common.Detector`

  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)

  TODO: update cython code for 3d detectors use expand2d instead of outer product with ones

  `IS_FLAT` = False
  `MANUFACTURER` = 'Aarhus University'
  `MAX_SHAPE` = (1000, 16000)
  `__init__`(pixel1=2.4893e-05, pixel2=2.4893e-05, radius=0.29989)

    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

  `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`(use_cython=True)

    Calculate the position of the corner of the pixels

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

    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)

    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.``Pixium`(pixel1=0.000308, pixel2=0.000308)

  Bases: `pyFAI.detectors._common.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)

    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.``Apex2`(pixel1=0.00012, pixel2=0.00012)

  Bases: `pyFAI.detectors._common.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)

    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.``RaspberryPi5M`(pixel1=1.4e-06, pixel2=1.4e-06)

  Bases: `pyFAI.detectors._common.Detector`

  5 Mpix detector from Raspberry Pi

  `MAX_SHAPE` = (1944, 2592)
  `__init__`(pixel1=1.4e-06, pixel2=1.4e-06)

    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

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

  Bases: `pyFAI.detectors._common.Detector`

  8 Mpix detector from Raspberry Pi

  `MAX_SHAPE` = (2464, 3280)
  `__init__`(pixel1=1.12e-06, pixel2=1.12e-06)

    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

  `aliases` = ['Picam v2']
  `force_pixel` = True
  `get_config`()

    Return the configuration with arguments to the constructor

    Returns: | dict with param for serialization