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 analyze
- 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:
- 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.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